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)); }