OAuth2 C Reference Documentation
OAuth2
Current Version: 11.5.0
Obtain OAuth2 access tokens from desktop and native applications
The Chilkat.OAuth2 class enables desktop and native applications
to perform the OAuth 2.0 Authorization Code Flow for obtaining an initial
access token. The flow begins with StartAuth, which generates
the authorization URL to open in a browser and starts a background listener
for the local redirect callback.
LaunchBrowser to open the generated authorization URL.
AuthFlowState, FailureInfo, and token response data.
After the user grants or denies authorization, Chilkat captures the redirect
response, completes the token exchange, and makes the results available through
properties such as AccessToken, RefreshToken,
AccessTokenResponse, AuthFlowState, and
FailureInfo.
The class also supports PKCE, refresh-token requests, custom authorization and token parameters, secure OS-backed secret resolution, and detailed diagnostic information.
For an extended overview, see OAuth2 Class Overview.
Create/Dispose
HCkOAuth2 instance = CkOAuth2_Create(); // ... CkOAuth2_Dispose(instance);
Creates an instance of the HCkOAuth2 object and returns a handle ("void *" pointer). The handle is passed in the 1st argument for the functions listed on this page.
Objects created by calling CkOAuth2_Create must be freed by calling this method. A memory leak occurs if a handle is not disposed by calling this function. Also, any handle returned by a Chilkat "C" function must also be freed by the application by calling the appropriate Dispose method, such as CkOAuth2_Dispose.
Callback Functions
Provides the opportunity for a method call to be aborted. If TRUE is returned, the operation in progress is aborted.
Return FALSE to allow the current method call to continue.
This callback function is called periodically based on the value of the HeartbeatMs property.
(If HeartbeatMs is 0, then no callbacks are made.) As an example, to make 5 AbortCheck callbacks per second, set the HeartbeatMs property equal to 200.
See Also:C Example using Callback Functions
Provides the percentage completed for any method that involves network communications or time-consuming processing (assuming it is a method where a percentage completion can be measured). This callback is only called when it is possible to know a percentage completion, and when it makes sense to express the operation as a percentage completed. The pctDone argument will have a value from 1 to 100. For methods that complete very quickly, the number of PercentDone callbacks will vary, but the final callback should have a value of 100. For long running operations, no more than one callback per percentage point will occur (for example: 1, 2, 3, ... 98, 99, 100).
This callback counts as an AbortCheck callback, and takes the place of the AbortCheck event when it fires.
The return value indicates whether the method call should be aborted, or whether it should proceed. Return TRUE to abort, and FALSE to proceed.
This is a general callback that provides name/value information about what is happening at certain points during a method call. To see the information provided in ProgressInfo callbacks, if any, write code to handle this event and log the name/value pairs. Most are self-explanatory.
Called in the background thread when an asynchronous task completes. (Note: When an async method is running, all callbacks are in the background thread.)
Properties
AccessToken
void CkOAuth2_putAccessToken(HCkOAuth2 cHandle, const char *newVal);
const char *CkOAuth2_accessToken(HCkOAuth2 cHandle);
Contains the access_token extracted from the most recent successful token response. It is updated after a successful authorization-code exchange or refresh-token request.
The access token is presented to the protected API, commonly in an HTTP header:
Authorization: Bearer ACCESS_TOKEN
AccessTokenResponse
const char *CkOAuth2_accessTokenResponse(HCkOAuth2 cHandle);
Contains the raw response body returned by the token endpoint after a successful authorization-code exchange or refresh-token request.
Most providers return JSON similar to:
{
"token_type": "Bearer",
"expires_in": 3600,
"access_token": "...",
"scope": "read write",
"refresh_token": "..."
}
| Field | Typical meaning |
|---|---|
access_token | Credential presented to the protected API. |
token_type | Usually Bearer. |
expires_in | Access-token lifetime in seconds, when supplied. |
scope | Scopes actually granted, when supplied. |
refresh_token | Credential used to request later access tokens, when issued. |
id_token | OpenID Connect identity token, when requested and issued. |
Some providers return form-encoded text instead of JSON. Use GetAccessTokenResponseSb when a StringBuilder destination is preferred.
AppCallbackUrl
void CkOAuth2_putAppCallbackUrl(HCkOAuth2 cHandle, const char *newVal);
const char *CkOAuth2_appCallbackUrl(HCkOAuth2 cHandle);
Specifies a public HTTPS callback URL on an application-controlled web server when the provider will not redirect directly to localhost or a loopback IP address.
The intermediary endpoint receives the provider's redirect and forwards the complete callback, including code, state, error, and any provider-specific parameters, to the local listener used by Chilkat.
AuthFlowState
Reports the current state of the background authorization flow.
| Value | State | Meaning |
|---|---|---|
0 | Idle | No authorization flow has been started. |
1 | Waiting for redirect | The local listener is waiting for the browser callback. |
2 | Exchanging code | The redirect was received and the background thread is waiting for the token-endpoint response. |
3 | Success | The flow completed and token response properties are available. |
4 | Denied | The authorization server returned an access-denied response. Inspect AccessTokenResponse. |
5 | Failed | The flow failed before successful completion. Inspect FailureInfo and LastErrorText. |
3, 4, or 5. Avoid a tight loop; sleep briefly or use the host environment's timer mechanism.AuthorizationEndpoint
void CkOAuth2_putAuthorizationEndpoint(HCkOAuth2 cHandle, const char *newVal);
const char *CkOAuth2_authorizationEndpoint(HCkOAuth2 cHandle);
Specifies the authorization endpoint to which the user's browser is directed. StartAuth appends the client identifier, redirect URI, scope, state, PKCE values, and other configured authorization parameters.
| Provider | Authorization endpoint | Token endpoint |
|---|---|---|
https://accounts.google.com/o/oauth2/v2/auth | https://oauth2.googleapis.com/token | |
| Microsoft identity platform | https://login.microsoftonline.com/{tenant}/oauth2/v2.0/authorize | https://login.microsoftonline.com/{tenant}/oauth2/v2.0/token |
| Salesforce production | https://login.salesforce.com/services/oauth2/authorize | https://login.salesforce.com/services/oauth2/token |
| QuickBooks Online | https://appcenter.intuit.com/connect/oauth2 | https://oauth.platform.intuit.com/oauth2/v1/tokens/bearer |
| X API | https://x.com/i/oauth2/authorize | https://api.x.com/2/oauth2/token |
authorization_endpoint value rather than copying an endpoint from an old example.ClientId
void CkOAuth2_putClientId(HCkOAuth2 cHandle, const char *newVal);
const char *CkOAuth2_clientId(HCkOAuth2 cHandle);
Specifies the client identifier assigned when the application is registered with the authorization server. It identifies the application in authorization and token requests.
ClientSecret
void CkOAuth2_putClientSecret(HCkOAuth2 cHandle, const char *newVal);
const char *CkOAuth2_clientSecret(HCkOAuth2 cHandle);
Specifies the client secret assigned to a confidential client by the authorization server. It is used when the provider requires the client to authenticate at the token endpoint.
CodeChallenge
void CkOAuth2_putCodeChallenge(HCkOAuth2 cHandle, BOOL newVal);
Set to TRUE to enable Proof Key for Code Exchange (PKCE) for the authorization-code flow. The default is FALSE.
When enabled, Chilkat generates a high-entropy code verifier, sends its transformed challenge in the authorization request, and sends the original verifier during the token exchange.
CodeChallengeMethod
void CkOAuth2_putCodeChallengeMethod(HCkOAuth2 cHandle, const char *newVal);
const char *CkOAuth2_codeChallengeMethod(HCkOAuth2 cHandle);
Selects the PKCE transformation used when CodeChallenge is TRUE.
| Value | Behavior |
|---|---|
S256 | Sends a Base64URL-encoded SHA-256 digest of the code verifier. This is the default and recommended method. |
plain | Sends the code verifier itself as the challenge. Use only for compatibility with a provider that cannot support S256. |
S256, do not automatically retry with plain unless the provider is known and explicitly requires it.DebugLogFilePath
void CkOAuth2_putDebugLogFilePath(HCkOAuth2 cHandle, const char *newVal);
const char *CkOAuth2_debugLogFilePath(HCkOAuth2 cHandle);
If set to a file path, this property logs the LastErrorText of each Chilkat method or property call to the specified file. This logging helps identify the context and history of Chilkat calls leading up to any crash or hang, aiding in debugging.
Enabling the VerboseLogging property provides more detailed information. This property is mainly used for debugging rare instances where a Chilkat method call causes a hang or crash, which should generally not happen.
Possible causes of hangs include:
- A timeout property set to 0, indicating an infinite timeout.
- A hang occurring within an event callback in the application code.
- An internal bug in the Chilkat code causing the hang.
EnableSecrets
void CkOAuth2_putEnableSecrets(HCkOAuth2 cHandle, BOOL newVal);
Controls automatic resolution of selected values from operating-system secure storage. The default is FALSE.
When TRUE, the following properties may contain a secret specification beginning with !! instead of a literal value:
The specification has the form:
!![appName|]service[|domain]|username
Chilkat resolves the value through Windows Credential Manager on Windows or Apple Keychain on macOS.
FailureInfo
const char *CkOAuth2_failureInfo(HCkOAuth2 cHandle);
Contains diagnostic information when AuthFlowState is 5. The value is cleared when StartAuth begins a new flow.
Use this property for failures in the listener, redirect processing, network connection, or token exchange. Provider-declared authorization denial is represented by state 4 and is normally available in AccessTokenResponse.
IncludeNonce
void CkOAuth2_putIncludeNonce(HCkOAuth2 cHandle, BOOL newVal);
Set to TRUE to include an OpenID Connect nonce parameter in the authorization request. The nonce is generated by Chilkat using the byte length specified by NonceLength. The default is FALSE.
In OpenID Connect, the authorization server includes the nonce in the ID token so the client can associate that token with the authorization request and detect replay or token-substitution problems.
nonce protects the relationship between an OpenID Connect request and its ID token. OAuth state correlates the browser callback with the initiating request and is used for CSRF protection. They are related security controls but are not interchangeable.LastErrorHtml
const char *CkOAuth2_lastErrorHtml(HCkOAuth2 cHandle);
Provides HTML-formatted information about the last called method or property. If a method call fails or behaves unexpectedly, check this property for details. Note that information is available regardless of the method call's success.
topLastErrorText
const char *CkOAuth2_lastErrorText(HCkOAuth2 cHandle);
Provides plain text information about the last called method or property. If a method call fails or behaves unexpectedly, check this property for details. Note that information is available regardless of the method call's success.
LastErrorXml
const char *CkOAuth2_lastErrorXml(HCkOAuth2 cHandle);
Provides XML-formatted information about the last called method or property. If a method call fails or behaves unexpectedly, check this property for details. Note that information is available regardless of the method call's success.
topLastMethodSuccess
void CkOAuth2_putLastMethodSuccess(HCkOAuth2 cHandle, BOOL newVal);
Indicates the success or failure of the most recent method call: TRUE means success, FALSE means failure. This property remains unchanged by property setters or getters. This method is present to address challenges in checking for null or Nothing returns in certain programming languages. Note: This property does not apply to methods that return integer values or to boolean-returning methods where the boolean does not indicate success or failure.
ListenPort
void CkOAuth2_putListenPort(HCkOAuth2 cHandle, int newVal);
Specifies the local TCP port on which Chilkat listens for the browser's OAuth redirect. Choose an available nonprivileged port, typically between 1024 and 65535.
The redirect URI registered with the provider must match the host, selected port, and terminating slash generated by this object. For example:
http://127.0.0.1:3017/
- Use
httpfor a loopback redirect handled entirely on the local computer. - Use
LocalHostto selectlocalhostor127.0.0.1. - Include the final
/when registering the redirect URI.
127.0.0.1 is generally more predictable than resolving localhost.ListenPortRangeEnd
void CkOAuth2_putListenPortRangeEnd(HCkOAuth2 cHandle, int newVal);
Defines the inclusive end of a local-listener port range that begins with ListenPort. The default value of 0 disables range selection and uses only ListenPort.
When nonzero, Chilkat selects an available port in the inclusive range. For example, ListenPort=55110 and ListenPortRangeEnd=55117 permit ports 55110 through 55117.
Read ListenPortSelected to determine which port was used.
ListenPortSelected
Returns the local port selected for the current or most recently completed authorization flow.
When a range is configured with ListenPortRangeEnd, use this value to determine the actual loopback redirect port. It is also available for the {listenPort} substitution supported by StateParam.
LocalHost
void CkOAuth2_putLocalHost(HCkOAuth2 cHandle, const char *newVal);
const char *CkOAuth2_localHost(HCkOAuth2 cHandle);
Selects the host name used in the loopback redirect URI:
| Value | Redirect form |
|---|---|
localhost | http://localhost:{port}/ |
127.0.0.1 | http://127.0.0.1:{port}/ |
The default is localhost. The value must match the redirect URI registered with the provider.
127.0.0.1 avoids DNS and hosts-file ambiguity and is generally preferable when the provider accepts an IPv4 loopback-literal redirect.NonceLength
void CkOAuth2_putNonceLength(HCkOAuth2 cHandle, int newVal);
Specifies the number of random bytes used to generate the hexadecimal OpenID Connect nonce when IncludeNonce is TRUE. The resulting string contains two hexadecimal characters per byte.
The default is 4 bytes, which produces an 8-character hexadecimal nonce.
Oob
void CkOAuth2_putOob(HCkOAuth2 cHandle, BOOL newVal);
Set to TRUE to use the legacy out-of-band redirect URI urn:ietf:wg:oauth:2.0:oob. The application must obtain the displayed authorization code and pass it to ExchangeCodeForToken. The default is FALSE.
RedirectAllowHtml
void CkOAuth2_putRedirectAllowHtml(HCkOAuth2 cHandle, const char *newVal);
const char *CkOAuth2_redirectAllowHtml(HCkOAuth2 cHandle);
Gets or sets the HTML response sent by Chilkat's local listener to the browser after authorization is granted and the redirect is accepted.
The default HTML immediately redirects the browser to Chilkat's confirmation page:
<html>
<head><meta http-equiv='refresh'
content='0;url=https://www.chilkatsoft.com/oauth2_allowed.html'></head>
<body>Thank you for allowing access.</body>
</html>
Replace this value to display application-specific instructions or redirect to a page operated by your organization.
RedirectDenyHtml
void CkOAuth2_putRedirectDenyHtml(HCkOAuth2 cHandle, const char *newVal);
const char *CkOAuth2_redirectDenyHtml(HCkOAuth2 cHandle);
Gets or sets the HTML response sent by Chilkat's local listener to the browser when the authorization server reports that access was denied.
The default HTML immediately redirects the browser to Chilkat's denial page:
<html>
<head><meta http-equiv='refresh'
content='0;url=https://www.chilkatsoft.com/oauth2_denied.html'></head>
<body>The app will not have access.</body>
</html>
Replace this value to display application-specific instructions or redirect to a page operated by your organization.
AuthFlowState value 4. It should normally be handled as a completed flow in which consent was not granted.RedirectReqReceived
const char *CkOAuth2_redirectReqReceived(HCkOAuth2 cHandle);
Contains the raw HTTP request received from the browser by Chilkat's local redirect listener. It is intended for troubleshooting callback and provider-parameter problems.
GET /?state=...&code=... HTTP/1.1 Host: 127.0.0.1:3017 User-Agent: ... Accept: text/html,...
The value can include the request target, query or form parameters, and browser-supplied headers.
RefreshToken
void CkOAuth2_putRefreshToken(HCkOAuth2 cHandle, const char *newVal);
const char *CkOAuth2_refreshToken(HCkOAuth2 cHandle);
Gets or sets the refresh token used to obtain new access tokens. Chilkat populates this property when the token endpoint issues a refresh_token, and RefreshAccessToken reads it when creating a refresh request.
A provider may omit the refresh token unless an offline-access scope or provider-specific authorization parameter was requested. A refresh response may also return a replacement token.
Resource
void CkOAuth2_putResource(HCkOAuth2 cHandle, const char *newVal);
const char *CkOAuth2_resource(HCkOAuth2 cHandle);
Specifies an optional provider-defined resource parameter identifying the API or audience for which a token is requested.
This is used by some OAuth deployments, including older Microsoft identity endpoints and certain Dynamics configurations. Modern Microsoft v2 endpoints generally identify the target API through scope values instead.
resource value. Do not assume that an API base URL is always the correct value.ResponseMode
void CkOAuth2_putResponseMode(HCkOAuth2 cHandle, const char *newVal);
const char *CkOAuth2_responseMode(HCkOAuth2 cHandle);
Specifies the response mode requested from an OpenID Connect or provider-specific authorization endpoint.
Set to form_post to add response_mode=form_post, causing the authorization server to return parameters in an auto-submitted HTML form that sends an HTTP POST to the redirect URI. The default is an empty string, which omits the parameter and lets the provider choose its normal mode.
ResponseType
void CkOAuth2_putResponseType(HCkOAuth2 cHandle, const char *newVal);
const char *CkOAuth2_responseType(HCkOAuth2 cHandle);
Specifies the authorization response type. The default is code, which requests an authorization code.
Set to id_token+code when a provider requires the OpenID Connect hybrid response response_type=id_token code; the plus sign is the URL-encoded representation of a SPACE in the query string.
Scope
void CkOAuth2_putScope(HCkOAuth2 cHandle, const char *newVal);
const char *CkOAuth2_scope(HCkOAuth2 cHandle);
Specifies the access scopes requested from the authorization server. A scope is a provider-defined permission or capability associated with the resulting access token.
OAuth scope values are commonly separated by a single SPACE character:
openid email profile https://www.googleapis.com/auth/drive.readonly
openidrequests OpenID Connect processing and an ID token when used with an appropriate response type.emailandprofilerequest standard OpenID Connect claims.- The Google Drive URI requests read-only access to Drive files.
StateParam
void CkOAuth2_putStateParam(HCkOAuth2 cHandle, const char *newVal);
const char *CkOAuth2_stateParam(HCkOAuth2 cHandle);
Allows the application to supply an explicit OAuth state value. Normally this property should remain empty so Chilkat generates a cryptographically random state value and validates the returned value automatically.
The automatically generated state is intentionally not exposed through this property.
The special token {listenPort} may appear in an explicitly supplied value. Chilkat replaces it with the actual listener port selected for the flow.
TokenEndpoint
void CkOAuth2_putTokenEndpoint(HCkOAuth2 cHandle, const char *newVal);
const char *CkOAuth2_tokenEndpoint(HCkOAuth2 cHandle);
Specifies the provider's token endpoint. Chilkat sends authorization-code and refresh-token requests to this URL over TLS.
| Provider | Authorization endpoint | Token endpoint |
|---|---|---|
https://accounts.google.com/o/oauth2/v2/auth | https://oauth2.googleapis.com/token | |
| Microsoft identity platform | https://login.microsoftonline.com/{tenant}/oauth2/v2.0/authorize | https://login.microsoftonline.com/{tenant}/oauth2/v2.0/token |
| Salesforce production | https://login.salesforce.com/services/oauth2/authorize | https://login.salesforce.com/services/oauth2/token |
| QuickBooks Online | https://appcenter.intuit.com/connect/oauth2 | https://oauth.platform.intuit.com/oauth2/v1/tokens/bearer |
| X API | https://x.com/i/oauth2/authorize | https://api.x.com/2/oauth2/token |
TokenType
void CkOAuth2_putTokenType(HCkOAuth2 cHandle, const char *newVal);
const char *CkOAuth2_tokenType(HCkOAuth2 cHandle);
Contains the token_type value from the most recent successful token response. The common value is Bearer.
UncommonOptions
void CkOAuth2_putUncommonOptions(HCkOAuth2 cHandle, const char *newVal);
const char *CkOAuth2_uncommonOptions(HCkOAuth2 cHandle);
Provides a comma-separated list of specialized compatibility options. The default is an empty string and is appropriate for normal OAuth providers.
| Keyword | Effect |
|---|---|
NO_OAUTH2_SCOPE | Omits the scope parameter from the authorization-code token request. |
ExchangeCodeForTokenUsingJson | Sends the authorization-code token request as an HTTP POST with a JSON body instead of the normal form/query representation. |
RefreshTokenUsingJson | Sends the refresh-token request as an HTTP POST with a JSON body. |
UseBasicAuth
void CkOAuth2_putUseBasicAuth(HCkOAuth2 cHandle, BOOL newVal);
Controls how ClientId and ClientSecret are supplied during the authorization-code token exchange.
| Value | Behavior |
|---|---|
TRUE | Sends HTTP Basic authentication using the client ID as the username and the client secret as the password. |
FALSE | Sends the client ID and client secret as request parameters. This is the default. |
invalid_client response.Utf8
void CkOAuth2_putUtf8(HCkOAuth2 cHandle, BOOL newVal);
When set to TRUE, all const char * arguments and return values are interpreted as UTF-8 strings. When set to FALSE, they are interpreted as ANSI strings.
In Chilkat v11.0.0 and later, the default value is TRUE. Before v11.0.0, it was FALSE.
VerboseLogging
void CkOAuth2_putVerboseLogging(HCkOAuth2 cHandle, BOOL newVal);
If set to TRUE, then the contents of LastErrorText (or LastErrorXml, or LastErrorHtml) may contain more verbose information. The default value is FALSE. Verbose logging should only be used for debugging. The potentially large quantity of logged information may adversely affect peformance.
Version
const char *CkOAuth2_version(HCkOAuth2 cHandle);
Methods
AddAuthQueryParam
Adds a name/value query parameter to the authorization URL produced by StartAuth. Call the method multiple times to add multiple provider-specific authorization parameters.
Typical examples include provider extensions such as access_type=offline, prompt=consent, or an account-selection hint.
Returns TRUE for success, FALSE for failure.
AddRefreshQueryParam
Adds a provider-specific name/value parameter to requests sent by RefreshAccessToken. Call the method multiple times to add multiple parameters.
Returns TRUE for success, FALSE for failure.
AddTokenQueryParam
Adds a provider-specific name/value parameter to the authorization-code token request that Chilkat sends after receiving the browser redirect. Call the method multiple times to add multiple parameters.
This setting affects the code-for-token exchange performed by StartAuth or ExchangeCodeForToken; it does not alter the browser authorization URL or refresh-token requests.
grant_type, code, or redirect_uri unless instructed by Chilkat support.Returns TRUE for success, FALSE for failure.
topCancel
Requests cancellation of the authorization flow currently running in the background thread.
Returns TRUE if the cancellation request is accepted. After cancellation, inspect AuthFlowState and FailureInfo to determine the final state.
Returns TRUE for success, FALSE for failure.
topExchangeCodeForToken
Exchanges the authorization code in code for tokens at TokenEndpoint.
This is used when the application obtains the authorization code outside Chilkat's local-listener workflow, most commonly with the legacy out-of-band mode selected by Oob. Configure the same client, endpoint, redirect, PKCE, and token-request settings that the provider requires for the original authorization request.
On success, the token properties and AccessTokenResponse are populated in the same manner as a successful background exchange.
urn:ietf:wg:oauth:2.0:oob. Prefer an authorization-code flow with a loopback redirect and PKCE whenever the provider supports it.Returns TRUE for success, FALSE for failure.
ExchangeCodeForTokenAsync (1)
Creates an asynchronous task to call the ExchangeCodeForToken method with the arguments provided.
Returns NULL on failure
GetAccessTokenResponseSb
Copies the raw token-endpoint response into sb and returns TRUE on success.
This is the StringBuilder equivalent of reading AccessTokenResponse. The response is commonly JSON, but some providers return form-encoded or other text; this method does not guarantee JSON.
StringBuilder as sensitive data and avoid logging or exposing its contents.Returns TRUE for success, FALSE for failure.
topGetRedirectRequestParam
const char *CkOAuth2_getRedirectRequestParam(HCkOAuth2 cHandle, const char *paramName);
Returns the decoded value of paramName from the authorization redirect received by Chilkat's local listener.
Call this after the redirect has been received. It is useful for provider-specific parameters in addition to the standard code, state, and error values. For example, QuickBooks can return a company identifier named realmId:
http://localhost:55568/?state=...&code=...&realmId=1234567890
Returns TRUE for success, FALSE for failure.
LaunchBrowser
Asks the operating system to open url in the user's default web browser. On Windows, macOS, and supported Linux desktop environments, an existing browser may open the URL in a new tab.
This method is typically called with the authorization URL returned by StartAuth. Returns FALSE if the operating system cannot launch a browser or open the URL.
Returns TRUE for success, FALSE for failure.
topLoadTaskCaller
Loads state from task so this object can act as the caller associated with a Chilkat asynchronous task.
Returns TRUE for success, FALSE for failure.
topRefreshAccessToken
Sends a refresh-token grant request to TokenEndpoint to obtain a new access token without repeating interactive browser authorization.
Configure ClientId, RefreshToken, and TokenEndpoint, together with whatever client authentication the provider requires. This may include ClientSecret and UseBasicAuth.
On success, Chilkat updates AccessToken, TokenType, and AccessTokenResponse. If the provider rotates refresh tokens and returns a new refresh_token, RefreshToken is also updated.
RefreshToken rather than assuming the previous value remains usable.SetRefreshHeader and AddRefreshQueryParam only when the provider documents additional headers or parameters.Returns TRUE for success, FALSE for failure.
RefreshAccessTokenAsync (1)
Creates an asynchronous task to call the RefreshAccessToken method with the arguments provided.
Returns NULL on failure
SetRefreshHeader
Adds or replaces an HTTP request header used by subsequent calls to RefreshAccessToken. name is the header field name and value is its value.
Call this method once for each required header. Passing an empty value removes the named header.
Accept: application/json
Returns TRUE for success, FALSE for failure.
SleepMs
Suspends the calling thread for millisec milliseconds.
This convenience method is commonly used in a polling loop that checks AuthFlowState while the authorization flow continues on Chilkat's background thread.
StartAuth
const char *CkOAuth2_startAuth(HCkOAuth2 cHandle);
Starts an OAuth 2.0 Authorization Code flow and returns the authorization URL that the application should open in the user's browser.
Before calling this method, configure ClientId, AuthorizationEndpoint, TokenEndpoint, the requested Scope, and the redirect-listener settings such as ListenPort. Configure ClientSecret only when the provider requires client authentication for this application type.
- Chilkat constructs and returns the provider's authorization URL.
- Chilkat starts a background thread that listens for the redirect request, validates the returned state, and exchanges the authorization code at the token endpoint.
Open the returned URL with LaunchBrowser or another browser-launch mechanism. Poll AuthFlowState until the flow reaches a terminal state.
CodeChallenge protects the authorization code from interception and is strongly recommended for desktop and other native applications. PKCE does not make a client secret confidential and does not replace client authentication when the provider requires it for a confidential client.LastErrorText before attempting to open the returned URL.Returns TRUE for success, FALSE for failure.
UseConnection
Associates sock with this object for HTTP connections to the token endpoint. This method is optional.
- Pass an unconnected
Socketwhen it is configured with HTTP-proxy, SOCKS-proxy, local-bind, or other connection options that Chilkat should use when opening the token-endpoint connection. - Pass an already connected socket when traffic must travel through an established SSH tunnel or another prebuilt connection.
Without this method, Chilkat opens a direct TLS connection to the token endpoint.
Returns TRUE for success, FALSE for failure.