private async Task <AuthenticationResultEx> RefreshAccessTokenAsync(AuthenticationResultEx result)
{
AuthenticationResultEx newResultEx = null;
if (this.Resource != null)
{
PlatformPlugin.Logger.Verbose(this.CallState, "Refreshing access token...");
try
{
newResultEx = await this.SendTokenRequestByRefreshTokenAsync(result.RefreshToken);
this.Authenticator.UpdateTenantId(result.Result.TenantId);
if (newResultEx.Result.IdToken == null)
{
// If Id token is not returned by token endpoint when refresh token is redeemed, we should copy tenant and user information from the cached token.
newResultEx.Result.UpdateTenantAndUserInfo(result.Result.TenantId, result.Result.IdToken, result.Result.UserInfo);
}
}
catch (AdalException ex)
{
AdalServiceException serviceException = ex as AdalServiceException;
if (serviceException != null && serviceException.ErrorCode == "invalid_request")
{
throw new AdalServiceException(
AdalError.FailedToRefreshToken,
AdalErrorMessage.FailedToRefreshToken + ". " + serviceException.Message,
serviceException.ServiceErrorCodes,
serviceException);
}
newResultEx = new AuthenticationResultEx {
Exception = ex
};
}
}
return(newResultEx);
}
private async Task <T> GetResponseAsync <T>(string endpointType, bool respondToDeviceAuthChallenge)
{
T typedResponse = default(T);
IHttpWebResponse response;
ClientMetrics clientMetrics = new ClientMetrics();
try
{
clientMetrics.BeginClientMetricsRecord(this.CallState);
if (PlatformPlugin.HttpClientFactory.AddAdditionalHeaders)
{
Dictionary <string, string> clientMetricsHeaders = clientMetrics.GetPreviousRequestRecord(this.CallState);
foreach (KeyValuePair <string, string> kvp in clientMetricsHeaders)
{
this.Client.Headers[kvp.Key] = kvp.Value;
}
IDictionary <string, string> adalIdHeaders = AdalIdHelper.GetAdalIdParameters();
foreach (KeyValuePair <string, string> kvp in adalIdHeaders)
{
this.Client.Headers[kvp.Key] = kvp.Value;
}
}
//add pkeyauth header
this.Client.Headers[DeviceAuthHeaderName] = DeviceAuthHeaderValue;
using (response = await this.Client.GetResponseAsync())
{
typedResponse = DeserializeResponse <T>(response.ResponseStream);
clientMetrics.SetLastError(null);
}
}
catch (HttpRequestWrapperException ex)
{
if (!this.isDeviceAuthChallenge(endpointType, ex.WebResponse, respondToDeviceAuthChallenge))
{
AdalServiceException serviceEx;
if (ex.WebResponse != null)
{
TokenResponse tokenResponse = TokenResponse.CreateFromErrorResponse(ex.WebResponse);
string[] errorCodes = tokenResponse.ErrorCodes ?? new[] { ex.WebResponse.StatusCode.ToString() };
serviceEx = new AdalServiceException(tokenResponse.Error, tokenResponse.ErrorDescription,
errorCodes, ex);
}
else
{
serviceEx = new AdalServiceException(AdalError.Unknown, ex);
}
clientMetrics.SetLastError(serviceEx.ServiceErrorCodes);
PlatformPlugin.Logger.Error(CallState, serviceEx);
throw serviceEx;
}
else
{
response = ex.WebResponse;
}
}
finally
{
clientMetrics.EndClientMetricsRecord(endpointType, this.CallState);
}
//check for pkeyauth challenge
if (this.isDeviceAuthChallenge(endpointType, response, respondToDeviceAuthChallenge))
{
return(await HandleDeviceAuthChallenge <T>(endpointType, response));
}
return(typedResponse);
}