|
protected abstract SendAsync ( |
||
| request | ||
| cancellationToken | ||
| return | Task |
|
protected internal override async Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
if (_preAuthenticate)
{
TrySetBasicAuthToken(request);
}
HttpResponseMessage response = await _innerHandler.SendAsync(request, cancellationToken).ConfigureAwait(false);
if (!_preAuthenticate && response.StatusCode == HttpStatusCode.Unauthorized)
{
HttpHeaderValueCollection <AuthenticationHeaderValue> authenticateValues = response.Headers.WwwAuthenticate;
foreach (AuthenticationHeaderValue h in authenticateValues)
{
// We only support Basic auth, ignore others
if (h.Scheme == "Basic")
{
if (!TrySetBasicAuthToken(request))
{
break;
}
response.Dispose();
response = await _innerHandler.SendAsync(request, cancellationToken).ConfigureAwait(false);
break;
}
}
}
return(response);
}
internal override ValueTask <HttpResponseMessage> SendAsync(HttpRequestMessage request, bool async, CancellationToken cancellationToken)
{
if (IsEnabled())
{
return(SendAsyncCore(request, async, cancellationToken));
}
else
{
return(async ?
new ValueTask <HttpResponseMessage>(_innerHandler.SendAsync(request, cancellationToken)) :
new ValueTask <HttpResponseMessage>(_innerHandler.Send(request, cancellationToken)));
}
}
protected internal override async Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
HttpResponseMessage response = await _initialInnerHandler.SendAsync(request, cancellationToken).ConfigureAwait(false);
uint redirectCount = 0;
Uri redirectUri;
while ((redirectUri = GetUriForRedirect(request.RequestUri, response)) != null)
{
response.Dispose();
redirectCount++;
if (redirectCount > _maxAutomaticRedirections)
{
throw new HttpRequestException(SR.net_http_max_redirects);
}
// Clear the authorization header.
request.Headers.Authorization = null;
// Set up for the redirect
request.RequestUri = redirectUri;
if (RequestRequiresForceGet(response.StatusCode, request.Method))
{
request.Method = HttpMethod.Get;
request.Content = null;
request.Headers.TransferEncodingChunked = false;
}
// Issue the redirected request.
response = await _redirectInnerHandler.SendAsync(request, cancellationToken).ConfigureAwait(false);
}
return(response);
}
protected internal override async Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
// Add cookies to request, if any
string cookieHeader = _cookieContainer.GetCookieHeader(request.RequestUri);
if (!string.IsNullOrEmpty(cookieHeader))
{
request.Headers.Add("Cookie", cookieHeader);
}
HttpResponseMessage response = await _innerHandler.SendAsync(request, cancellationToken).ConfigureAwait(false);
// Handle Set-Cookie
IEnumerable <string> setCookies;
if (response.Headers.TryGetValues("Set-Cookie", out setCookies))
{
foreach (string setCookie in setCookies)
{
_cookieContainer.SetCookies(response.RequestMessage.RequestUri, setCookie);
}
}
return(response);
}
protected internal override async Task <HttpResponseMessage> SendAsync(HttpRequestMessage request,
CancellationToken cancellationToken)
{
CheckDisposed();
SetOperationStarted();
HttpResponseMessage response;
try
{
await ConfigureRequest(request).ConfigureAwait(false);
Task <HttpResponseMessage> responseTask = DiagnosticsHandler.IsEnabled() ?
_diagnosticsPipeline.SendAsync(request, cancellationToken) :
_handlerToFilter.SendAsync(request, cancellationToken);
response = await responseTask.ConfigureAwait(false);
}
catch (OperationCanceledException)
{
throw;
}
catch (Exception ex)
{
// Convert back to the expected exception type
throw new HttpRequestException(SR.net_http_client_execution_error, ex);
}
ProcessResponse(response);
return(response);
}
//
// Summary:
// Send an HTTP request as an asynchronous operation.
//
// Parameters:
// request:
// The HTTP request message to send.
//
// cancellationToken:
// The cancellation token to cancel operation.
//
// Returns:
// Returns System.Threading.Tasks.Task<TResult>.The task object representing
// the asynchronous operation.
//
// Exceptions:
// System.ArgumentNullException:
// The request was null.
public virtual Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
if (request == null)
{
throw new ArgumentNullException("request", "The request was null.");
}
return(m_handler.SendAsync(request, cancellationToken));
}
protected internal override Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
if (request == null)
{
throw new ArgumentNullException("request", SR.net_http_handler_norequest);
}
SetOperationStarted();
return(_innerHandler.SendAsync(request, cancellationToken));
}
protected internal override async Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
HttpResponseMessage response;
uint redirectCount = 0;
while (true)
{
response = await _innerHandler.SendAsync(request, cancellationToken).ConfigureAwait(false);
if (!RequestNeedsRedirect(response))
{
break;
}
Uri location = response.Headers.Location;
if (location == null)
{
// No location header. Nothing to redirect to.
break;
}
if (!location.IsAbsoluteUri)
{
location = new Uri(request.RequestUri, location);
}
// Disallow automatic redirection from secure to non-secure schemes
bool allowed =
(HttpUtilities.IsSupportedNonSecureScheme(request.RequestUri.Scheme) && HttpUtilities.IsSupportedScheme(location.Scheme)) ||
(HttpUtilities.IsSupportedSecureScheme(request.RequestUri.Scheme) && HttpUtilities.IsSupportedSecureScheme(location.Scheme));
if (!allowed)
{
break;
}
redirectCount++;
if (redirectCount > _maxAutomaticRedirections)
{
throw new HttpRequestException(SR.net_http_max_redirects);
}
// Set up for the automatic redirect
request.RequestUri = location;
if (RequestRequiresForceGet(response.StatusCode, request.Method))
{
request.Method = HttpMethod.Get;
request.Content = null;
}
// Do the redirect.
response.Dispose();
}
return(response);
}
protected internal override async Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
HttpResponseMessage response;
uint redirectCount = 0;
while (true)
{
response = await _innerHandler.SendAsync(request, cancellationToken).ConfigureAwait(false);
if (!RequestNeedsRedirect(response))
{
break;
}
Uri location = response.Headers.Location;
if (location == null)
{
throw new HttpRequestException(SR.net_http_headers_missing_location);
}
if (!location.IsAbsoluteUri)
{
location = new Uri(request.RequestUri, location);
}
// Disallow automatic redirection from https to http
bool allowed =
(request.RequestUri.Scheme == UriScheme.Http && (location.Scheme == UriScheme.Http || location.Scheme == UriScheme.Https)) ||
(request.RequestUri.Scheme == UriScheme.Https && location.Scheme == UriScheme.Https);
if (!allowed)
{
break;
}
redirectCount++;
if (redirectCount > _maxAutomaticRedirections)
{
throw new HttpRequestException(SR.net_http_max_redirects);
}
// Set up for the automatic redirect
request.RequestUri = location;
if (RequestRequiresForceGet(response.StatusCode, request.Method))
{
request.Method = HttpMethod.Get;
request.Content = null;
}
// Do the redirect.
response.Dispose();
}
return(response);
}
public virtual Task <HttpResponseMessage> SendAsync(HttpRequestMessage request,
CancellationToken cancellationToken)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
CheckDisposed();
return(_handler.SendAsync(request, cancellationToken));
}
public virtual Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
ArgumentNullException.ThrowIfNull(request);
ObjectDisposedException.ThrowIf(_disposed, this);
if (ShouldSendWithTelemetry(request))
{
return(SendAsyncWithTelemetry(_handler, request, cancellationToken));
}
return(_handler.SendAsync(request, cancellationToken));
protected internal override async Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
if (NetEventSource.IsEnabled)
{
NetEventSource.Enter(this, request, cancellationToken);
}
HttpResponseMessage response = await _initialInnerHandler.SendAsync(request, cancellationToken).ConfigureAwait(false);
uint redirectCount = 0;
Uri redirectUri;
while ((redirectUri = GetUriForRedirect(request.RequestUri, response)) != null)
{
redirectCount++;
if (redirectCount > _maxAutomaticRedirections)
{
// If we exceed the maximum number of redirects
// then just return the 3xx response.
if (NetEventSource.IsEnabled)
{
NetEventSource.Error(this, $"Exceeded max number of redirects. Redirect from {request.RequestUri} to {redirectUri} blocked.");
}
break;
}
response.Dispose();
// Clear the authorization header.
request.Headers.Authorization = null;
// Set up for the redirect
request.RequestUri = redirectUri;
if (RequestRequiresForceGet(response.StatusCode, request.Method))
{
request.Method = HttpMethod.Get;
request.Content = null;
request.Headers.TransferEncodingChunked = false;
}
// Issue the redirected request.
response = await _redirectInnerHandler.SendAsync(request, cancellationToken).ConfigureAwait(false);
}
if (NetEventSource.IsEnabled)
{
NetEventSource.Exit(this);
}
return(response);
}
protected internal override Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
Uri proxyUri = null;
try
{
if (!_proxy.IsBypassed(request.RequestUri))
{
proxyUri = _proxy.GetProxy(request.RequestUri);
}
}
catch (Exception)
{
// Eat any exception from the IWebProxy and just treat it as no proxy.
// TODO #21452: This seems a bit questionable, but it's what the tests expect
}
return(proxyUri == null?
_innerHandler.SendAsync(request, cancellationToken) :
SendWithProxyAsync(proxyUri, request, cancellationToken));
}
protected internal override Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
Uri proxyUri = null;
try
{
if (!_proxy.IsBypassed(request.RequestUri))
{
proxyUri = _proxy.GetProxy(request.RequestUri);
}
}
catch (Exception)
{
// Eat any exception from the IWebProxy and just treat it as no proxy.
// This matches the behavior of other handlers.
}
return(proxyUri == null?
_innerHandler.SendAsync(request, cancellationToken) :
SendWithProxyAsync(proxyUri, request, cancellationToken));
}
public virtual Task <HttpResponseMessage> SendAsync(HttpRequestMessage request,
CancellationToken cancellationToken)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
CheckDisposed();
if (HttpTelemetry.Log.IsEnabled() && !request.WasSentByHttpClient() && request.RequestUri != null)
{
return(SendAsyncWithTelemetry(_handler, request, cancellationToken));
}
return(_handler.SendAsync(request, cancellationToken));
protected internal override Task <HttpResponseMessage> SendAsync(HttpRequestMessage request,
CancellationToken cancellationToken)
{
if (_disposed)
{
throw new ObjectDisposedException(nameof(ManagedHandler));
}
if (_handler == null)
{
SetupHandlerChain();
}
return(_handler.SendAsync(request, cancellationToken));
}
static async Task <HttpResponseMessage> SendAsyncWithTelemetry(HttpMessageHandler handler, HttpRequestMessage request, CancellationToken cancellationToken)
{
HttpTelemetry.Log.RequestStart(request);
try
{
return(await handler.SendAsync(request, cancellationToken).ConfigureAwait(false));
}
catch when(LogRequestFailed(telemetryStarted: true))
{
// Unreachable as LogRequestFailed will return false
throw;
}
finally
{
HttpTelemetry.Log.RequestStop();
}
}
async Task <HttpResponseMessage> SendAsyncWorker(HttpRequestMessage request, HttpCompletionOption completionOption, CancellationToken cancellationToken)
{
try {
if (cancellation_token == null)
{
cancellation_token = new CancellationTokenSource();
}
using (var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellation_token.Token, cancellationToken)) {
cts.CancelAfter(timeout);
var task = handler.SendAsync(request, cts.Token);
if (task == null)
{
throw new InvalidOperationException("Handler failed to return a value");
}
var response = await task.ConfigureAwait(false);
if (response == null)
{
throw new InvalidOperationException("Handler failed to return a response");
}
//
// Read the content when default HttpCompletionOption.ResponseContentRead is set
//
if (response.Content != null && (completionOption & HttpCompletionOption.ResponseHeadersRead) == 0)
{
await response.Content.LoadIntoBufferAsync(MaxResponseContentBufferSize).ConfigureAwait(false);
}
return(response);
}
} finally {
cancellation_token.Dispose();
cancellation_token = null;
}
}
public virtual Task <HttpResponseMessage> SendAsync(HttpRequestMessage request,
CancellationToken cancellationToken)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
CheckDisposed();
if (NetEventSource.IsEnabled)
{
NetEventSource.Enter(this, request);
}
Task <HttpResponseMessage> task = _handler.SendAsync(request, cancellationToken);
if (NetEventSource.IsEnabled)
{
NetEventSource.Exit(this, task);
}
return(task);
}
protected internal override async Task <HttpResponseMessage> SendAsync(HttpRequestMessage request,
CancellationToken cancellationToken)
{
CheckDisposed();
SetOperationStarted();
HttpResponseMessage response;
try
{
if (string.Equals(request.Method.Method, HttpMethod.Trace.Method, StringComparison.OrdinalIgnoreCase))
{
// https://github.com/dotnet/corefx/issues/22161
throw new PlatformNotSupportedException(SR.Format(CultureInfo.InvariantCulture,
SR.net_http_httpmethod_notsupported_error, request.Method.Method));
}
await ConfigureRequest(request).ConfigureAwait(false);
Task <HttpResponseMessage> responseTask = DiagnosticsHandler.IsEnabled() ?
_diagnosticsPipeline.SendAsync(request, cancellationToken) :
_handlerToFilter.SendAsync(request, cancellationToken);
response = await responseTask.ConfigureAwait(false);
}
catch (OperationCanceledException)
{
throw;
}
catch (Exception ex)
{
// Convert back to the expected exception type.
throw new HttpRequestException(SR.net_http_client_execution_error, ex);
}
return(response);
}
public virtual Task <HttpResponseMessage> SendAsync(HttpRequestMessage request,
CancellationToken cancellationToken)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
CheckDisposed();
if (NetEventSource.Log.IsEnabled())
{
NetEventSource.Enter(NetEventSource.ComponentType.Http, this, "SendAsync",
LoggingHash.GetObjectLogHash(request) + ": " + request);
}
Task <HttpResponseMessage> task = _handler.SendAsync(request, cancellationToken);
if (NetEventSource.Log.IsEnabled())
{
NetEventSource.Exit(NetEventSource.ComponentType.Http, this, "SendAsync", task);
}
return(task);
}
public virtual Task <HttpResponseMessage> SendAsync(HttpRequestMessage request,
CancellationToken cancellationToken)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
CheckDisposed();
if (Logging.On)
{
Logging.Enter(Logging.Http, this, "SendAsync",
Logging.GetObjectLogHash(request) + ": " + request);
}
Task <HttpResponseMessage> task = handler.SendAsync(request, cancellationToken);
if (Logging.On)
{
Logging.Exit(Logging.Http, this, "SendAsync", task);
}
return(task);
}
protected internal override async Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
if (_preAuthenticate)
{
AuthenticationHelper.TrySetBasicAuthToken(request, _credentials);
}
HttpResponseMessage response = await _innerHandler.SendAsync(request, cancellationToken).ConfigureAwait(false);
if (response.StatusCode == HttpStatusCode.Unauthorized)
{
AuthenticationHeaderValue selectedAuth = GetSupportedAuthScheme(response.Headers.WwwAuthenticate);
if (selectedAuth != null)
{
switch (selectedAuth.Scheme)
{
case AuthenticationHelper.Digest:
// Update digest response with new parameter from WWWAuthenticate
var digestResponse = new AuthenticationHelper.DigestResponse(selectedAuth.Parameter);
if (await AuthenticationHelper.TrySetDigestAuthToken(request, _credentials, digestResponse, HttpKnownHeaderNames.Authorization).ConfigureAwait(false))
{
response.Dispose();
response = await _innerHandler.SendAsync(request, cancellationToken).ConfigureAwait(false);
// Retry in case of nonce timeout in server.
if (response.StatusCode == HttpStatusCode.Unauthorized)
{
foreach (AuthenticationHeaderValue ahv in response.Headers.WwwAuthenticate)
{
if (ahv.Scheme == AuthenticationHelper.Digest)
{
digestResponse = new AuthenticationHelper.DigestResponse(ahv.Parameter);
if (AuthenticationHelper.IsServerNonceStale(digestResponse) &&
await AuthenticationHelper.TrySetDigestAuthToken(request, _credentials, digestResponse, HttpKnownHeaderNames.Authorization).ConfigureAwait(false))
{
response.Dispose();
response = await _innerHandler.SendAsync(request, cancellationToken).ConfigureAwait(false);
}
break;
}
}
}
}
break;
case AuthenticationHelper.Basic:
if (_preAuthenticate)
{
// We already tried these credentials via preauthentication, so no need to try again
break;
}
if (AuthenticationHelper.TrySetBasicAuthToken(request, _credentials))
{
response.Dispose();
response = await _innerHandler.SendAsync(request, cancellationToken).ConfigureAwait(false);
}
break;
}
}
}
return(response);
}
protected internal override async Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
if (_preAuthenticate)
{
// Try using previous digest response WWWAuthenticate header
if (_digestResponse != null)
{
await AuthenticationHelper.TrySetDigestAuthToken(request, _credentials, _digestResponse, HttpKnownHeaderNames.Authorization).ConfigureAwait(false);
}
else
{
AuthenticationHelper.TrySetBasicAuthToken(request, _credentials);
}
}
HttpResponseMessage response = await _innerHandler.SendAsync(request, cancellationToken).ConfigureAwait(false);
if (!_preAuthenticate && response.StatusCode == HttpStatusCode.Unauthorized)
{
HttpHeaderValueCollection <AuthenticationHeaderValue> authenticateValues = response.Headers.WwwAuthenticate;
foreach (AuthenticationHeaderValue h in authenticateValues)
{
// We only support Basic and digest auth, ignore others
if (h.Scheme == AuthenticationHelper.Basic)
{
if (AuthenticationHelper.TrySetBasicAuthToken(request, _credentials))
{
response.Dispose();
response = await _innerHandler.SendAsync(request, cancellationToken).ConfigureAwait(false);
break;
}
}
else if (h.Scheme == AuthenticationHelper.Digest)
{
// Update digest response with new parameter from WWWAuthenticate
_digestResponse = new AuthenticationHelper.DigestResponse(h.Parameter);
if (await AuthenticationHelper.TrySetDigestAuthToken(request, _credentials, _digestResponse, HttpKnownHeaderNames.Authorization).ConfigureAwait(false))
{
response.Dispose();
response = await _innerHandler.SendAsync(request, cancellationToken).ConfigureAwait(false);
// Retry in case of nonce timeout in server.
if (response.StatusCode == HttpStatusCode.Unauthorized)
{
foreach (AuthenticationHeaderValue ahv in response.Headers.WwwAuthenticate)
{
if (ahv.Scheme == AuthenticationHelper.Digest)
{
_digestResponse = new AuthenticationHelper.DigestResponse(ahv.Parameter);
if (AuthenticationHelper.IsServerNonceStale(_digestResponse) &&
await AuthenticationHelper.TrySetDigestAuthToken(request, _credentials, _digestResponse, HttpKnownHeaderNames.Authorization).ConfigureAwait(false))
{
response.Dispose();
response = await _innerHandler.SendAsync(request, cancellationToken).ConfigureAwait(false);
}
break;
}
}
}
break;
}
}
}
}
return(response);
}
protected internal override async Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
HttpResponseMessage response = await _innerHandler.SendAsync(request, cancellationToken).ConfigureAwait(false);
int redirectCount = 0;
while (true)
{
bool needRedirect = false;
bool forceGet = false;
switch (response.StatusCode)
{
case HttpStatusCode.Moved:
case HttpStatusCode.TemporaryRedirect:
needRedirect = true;
break;
case HttpStatusCode.Found:
case HttpStatusCode.SeeOther:
needRedirect = true;
forceGet = true;
break;
case HttpStatusCode.MultipleChoices:
// Don't redirect if no Location specified
if (response.Headers.Location != null)
{
needRedirect = true;
}
break;
}
if (!needRedirect)
{
break;
}
Uri location = response.Headers.Location;
if (location == null)
{
throw new HttpRequestException("no Location header for redirect");
}
if (!location.IsAbsoluteUri)
{
location = new Uri(request.RequestUri, location);
}
// Disallow automatic redirection from https to http
bool allowed =
(request.RequestUri.Scheme == "http" && (location.Scheme == "http" || location.Scheme == "https")) ||
(request.RequestUri.Scheme == "https" && location.Scheme == "https");
if (!allowed)
{
break;
}
redirectCount++;
if (redirectCount > _maxAutomaticRedirections)
{
throw new HttpRequestException("max redirects exceeded");
}
// Set up for the automatic redirect
request.RequestUri = location;
if (forceGet)
{
request.Method = HttpMethod.Get;
request.Content = null;
}
// Do the redirect.
response.Dispose();
response = await _innerHandler.SendAsync(request, cancellationToken).ConfigureAwait(false);
}
return(response);
}
protected internal override async Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
HttpResponseMessage response;
uint redirectCount = 0;
while (true)
{
// Just as with WinHttpHandler and CurlHandler, for security reasons, we drop the server credential if it is
// anything other than a CredentialCache on redirection. We allow credentials in a CredentialCache since they
// are specifically tied to URIs.
ICredentials currentCredential = redirectCount > 0 ? _credentials as CredentialCache : _credentials;
if (currentCredential != null && _preAuthenticate)
{
// Try using previous digest response WWWAuthenticate header
if (_digestResponse != null)
{
await AuthenticationHelper.TrySetDigestAuthToken(request, currentCredential, _digestResponse, HttpKnownHeaderNames.Authorization).ConfigureAwait(false);
}
else
{
AuthenticationHelper.TrySetBasicAuthToken(request, currentCredential);
}
}
response = await _innerHandler.SendAsync(request, cancellationToken).ConfigureAwait(false);
if (currentCredential != null && !_preAuthenticate && response.StatusCode == HttpStatusCode.Unauthorized)
{
AuthenticationHeaderValue selectedAuth = GetSupportedAuthScheme(response.Headers.WwwAuthenticate);
if (selectedAuth != null)
{
switch (selectedAuth.Scheme)
{
case AuthenticationHelper.Digest:
// Update digest response with new parameter from WWWAuthenticate
_digestResponse = new AuthenticationHelper.DigestResponse(selectedAuth.Parameter);
if (await AuthenticationHelper.TrySetDigestAuthToken(request, currentCredential, _digestResponse, HttpKnownHeaderNames.Authorization).ConfigureAwait(false))
{
response.Dispose();
response = await _innerHandler.SendAsync(request, cancellationToken).ConfigureAwait(false);
// Retry in case of nonce timeout in server.
if (response.StatusCode == HttpStatusCode.Unauthorized)
{
foreach (AuthenticationHeaderValue ahv in response.Headers.WwwAuthenticate)
{
if (ahv.Scheme == AuthenticationHelper.Digest)
{
_digestResponse = new AuthenticationHelper.DigestResponse(ahv.Parameter);
if (AuthenticationHelper.IsServerNonceStale(_digestResponse) &&
await AuthenticationHelper.TrySetDigestAuthToken(request, currentCredential, _digestResponse, HttpKnownHeaderNames.Authorization).ConfigureAwait(false))
{
response.Dispose();
response = await _innerHandler.SendAsync(request, cancellationToken).ConfigureAwait(false);
}
break;
}
}
}
}
break;
case AuthenticationHelper.Basic:
if (AuthenticationHelper.TrySetBasicAuthToken(request, currentCredential))
{
response.Dispose();
response = await _innerHandler.SendAsync(request, cancellationToken).ConfigureAwait(false);
}
break;
}
}
}
if (!RequestNeedsRedirect(response))
{
break;
}
// Clear the authorization header, if the request requires redirect.
request.Headers.Authorization = null;
Uri location = response.Headers.Location;
if (location == null)
{
// No location header. Nothing to redirect to.
break;
}
if (!location.IsAbsoluteUri)
{
location = new Uri(request.RequestUri, location);
}
// Disallow automatic redirection from secure to non-secure schemes
bool allowed =
(HttpUtilities.IsSupportedNonSecureScheme(request.RequestUri.Scheme) && HttpUtilities.IsSupportedScheme(location.Scheme)) ||
(HttpUtilities.IsSupportedSecureScheme(request.RequestUri.Scheme) && HttpUtilities.IsSupportedSecureScheme(location.Scheme));
if (!allowed)
{
break;
}
redirectCount++;
if (redirectCount > _maxAutomaticRedirections)
{
throw new HttpRequestException(SR.net_http_max_redirects);
}
// Set up for the automatic redirect
request.RequestUri = location;
if (RequestRequiresForceGet(response.StatusCode, request.Method))
{
request.Method = HttpMethod.Get;
request.Content = null;
}
// Do the redirect.
response.Dispose();
}
return(response);
}
protected internal override async Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
if (_preAuthenticate)
{
// Try using previous digest response WWWAuthenticate header
if (_digestResponse != null)
{
await AuthenticationHelper.TrySetDigestAuthToken(request, _credentials, _digestResponse, HttpKnownHeaderNames.Authorization).ConfigureAwait(false);
}
else
{
AuthenticationHelper.TrySetBasicAuthToken(request, _credentials);
}
}
HttpResponseMessage response = await _innerHandler.SendAsync(request, cancellationToken).ConfigureAwait(false);
// In case of redirection, ensure _credentials as CredentialCache
if (AutoRedirectHandler.RequestNeedsRedirect(response))
{
// Just as with WinHttpHandler and CurlHandler, for security reasons, we drop the server credential if it is
// anything other than a CredentialCache. We allow credentials in a CredentialCache since they
// are specifically tied to URIs.
_credentials = _credentials as CredentialCache;
}
else if (_credentials != null && !_preAuthenticate && response.StatusCode == HttpStatusCode.Unauthorized)
{
HttpHeaderValueCollection <AuthenticationHeaderValue> authenticateValues = response.Headers.WwwAuthenticate;
foreach (AuthenticationHeaderValue h in authenticateValues)
{
// We only support Basic and digest auth, ignore others
if (h.Scheme == AuthenticationHelper.Basic)
{
if (AuthenticationHelper.TrySetBasicAuthToken(request, _credentials))
{
response.Dispose();
response = await _innerHandler.SendAsync(request, cancellationToken).ConfigureAwait(false);
break;
}
}
else if (h.Scheme == AuthenticationHelper.Digest)
{
// Update digest response with new parameter from WWWAuthenticate
_digestResponse = new AuthenticationHelper.DigestResponse(h.Parameter);
if (await AuthenticationHelper.TrySetDigestAuthToken(request, _credentials, _digestResponse, HttpKnownHeaderNames.Authorization).ConfigureAwait(false))
{
response.Dispose();
response = await _innerHandler.SendAsync(request, cancellationToken).ConfigureAwait(false);
// Retry in case of nonce timeout in server.
if (response.StatusCode == HttpStatusCode.Unauthorized)
{
foreach (AuthenticationHeaderValue ahv in response.Headers.WwwAuthenticate)
{
if (ahv.Scheme == AuthenticationHelper.Digest)
{
_digestResponse = new AuthenticationHelper.DigestResponse(ahv.Parameter);
if (AuthenticationHelper.IsServerNonceStale(_digestResponse) &&
await AuthenticationHelper.TrySetDigestAuthToken(request, _credentials, _digestResponse, HttpKnownHeaderNames.Authorization).ConfigureAwait(false))
{
response.Dispose();
response = await _innerHandler.SendAsync(request, cancellationToken).ConfigureAwait(false);
}
break;
}
}
}
break;
}
}
}
}
return(response);
}
protected internal override async Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
Uri proxyUri = null;
try
{
if (!_proxy.IsBypassed(request.RequestUri))
{
proxyUri = _proxy.GetProxy(request.RequestUri);
}
}
catch (Exception)
{
// Eat any exception from the IWebProxy and just treat it as no proxy.
// TODO: This seems a bit questionable, but it's what the tests expect
}
if (proxyUri == null)
{
return(await _innerHandler.SendAsync(request, cancellationToken).ConfigureAwait(false));
}
if (proxyUri.Scheme != "http")
{
throw new InvalidOperationException($"invalid scheme {proxyUri.Scheme} for proxy");
}
if (request.RequestUri.Scheme == "https")
{
// TODO: Implement SSL tunneling through proxy
throw new NotImplementedException("no support for SSL tunneling through proxy");
}
HttpConnection connection = await GetOrCreateConnection(request, proxyUri).ConfigureAwait(false);
HttpResponseMessage response = await connection.SendAsync(request, cancellationToken).ConfigureAwait(false);
// Handle proxy authentication
if (response.StatusCode == HttpStatusCode.ProxyAuthenticationRequired &&
_proxy.Credentials != null)
{
foreach (AuthenticationHeaderValue h in response.Headers.ProxyAuthenticate)
{
// We only support Basic auth, ignore others
if (h.Scheme == "Basic")
{
NetworkCredential credential = _proxy.Credentials.GetCredential(proxyUri, "Basic");
if (credential != null)
{
response.Dispose();
request.Headers.ProxyAuthorization = new AuthenticationHeaderValue("Basic",
BasicAuthenticationHelper.GetBasicTokenForCredential(credential));
connection = await GetOrCreateConnection(request, proxyUri).ConfigureAwait(false);
response = await connection.SendAsync(request, cancellationToken).ConfigureAwait(false);
}
break;
}
}
}
return(response);
}
public virtual Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
return(handler.SendAsync(request, cancellationToken));
}
