| /* |
| * ==================================================================== |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * ==================================================================== |
| * |
| * This software consists of voluntary contributions made by many |
| * individuals on behalf of the Apache Software Foundation. For more |
| * information on the Apache Software Foundation, please see |
| * <http://www.apache.org/>. |
| * |
| */ |
| package org.apache.http.impl.nio.client; |
| |
| import java.io.IOException; |
| import java.net.URI; |
| import java.net.URISyntaxException; |
| import java.nio.ByteBuffer; |
| import java.util.List; |
| |
| import org.apache.commons.logging.Log; |
| import org.apache.commons.logging.LogFactory; |
| import org.apache.http.HttpException; |
| import org.apache.http.HttpHost; |
| import org.apache.http.HttpRequest; |
| import org.apache.http.HttpResponse; |
| import org.apache.http.HttpStatus; |
| import org.apache.http.HttpVersion; |
| import org.apache.http.ProtocolException; |
| import org.apache.http.auth.AUTH; |
| import org.apache.http.auth.AuthProtocolState; |
| import org.apache.http.auth.AuthScheme; |
| import org.apache.http.auth.AuthScope; |
| import org.apache.http.auth.AuthState; |
| import org.apache.http.auth.UsernamePasswordCredentials; |
| import org.apache.http.client.AuthenticationStrategy; |
| import org.apache.http.client.CredentialsProvider; |
| import org.apache.http.client.NonRepeatableRequestException; |
| import org.apache.http.client.RedirectException; |
| import org.apache.http.client.RedirectStrategy; |
| import org.apache.http.client.UserTokenHandler; |
| import org.apache.http.client.config.RequestConfig; |
| import org.apache.http.client.methods.Configurable; |
| import org.apache.http.client.methods.HttpRequestWrapper; |
| import org.apache.http.client.methods.HttpUriRequest; |
| import org.apache.http.client.protocol.HttpClientContext; |
| import org.apache.http.client.protocol.RequestClientConnControl; |
| import org.apache.http.client.utils.URIUtils; |
| import org.apache.http.conn.routing.BasicRouteDirector; |
| import org.apache.http.conn.routing.HttpRoute; |
| import org.apache.http.conn.routing.HttpRouteDirector; |
| import org.apache.http.conn.routing.HttpRoutePlanner; |
| import org.apache.http.impl.auth.HttpAuthenticator; |
| import org.apache.http.message.BasicHttpRequest; |
| import org.apache.http.nio.ContentDecoder; |
| import org.apache.http.nio.ContentEncoder; |
| import org.apache.http.nio.IOControl; |
| import org.apache.http.nio.NHttpClientConnection; |
| import org.apache.http.nio.protocol.HttpAsyncRequestProducer; |
| import org.apache.http.nio.protocol.HttpAsyncResponseConsumer; |
| import org.apache.http.protocol.HttpCoreContext; |
| import org.apache.http.protocol.HttpProcessor; |
| import org.apache.http.protocol.ImmutableHttpProcessor; |
| import org.apache.http.protocol.RequestTargetHost; |
| |
| class MainClientExec implements InternalClientExec { |
| |
| private final Log log = LogFactory.getLog(getClass()); |
| |
| private final HttpProcessor httpProcessor; |
| private final HttpProcessor proxyHttpProcessor; |
| private final HttpRoutePlanner routePlanner; |
| private final AuthenticationStrategy targetAuthStrategy; |
| private final AuthenticationStrategy proxyAuthStrategy; |
| private final UserTokenHandler userTokenHandler; |
| private final RedirectStrategy redirectStrategy; |
| private final HttpRouteDirector routeDirector; |
| private final HttpAuthenticator authenticator; |
| |
| public MainClientExec( |
| final HttpProcessor httpProcessor, |
| final HttpRoutePlanner routePlanner, |
| final RedirectStrategy redirectStrategy, |
| final AuthenticationStrategy targetAuthStrategy, |
| final AuthenticationStrategy proxyAuthStrategy, |
| final UserTokenHandler userTokenHandler) { |
| super(); |
| this.httpProcessor = httpProcessor; |
| this.proxyHttpProcessor = new ImmutableHttpProcessor( |
| new RequestTargetHost(), new RequestClientConnControl()); |
| this.routePlanner = routePlanner; |
| this.redirectStrategy = redirectStrategy; |
| this.targetAuthStrategy = targetAuthStrategy; |
| this.proxyAuthStrategy = proxyAuthStrategy; |
| this.userTokenHandler = userTokenHandler; |
| this.routeDirector = new BasicRouteDirector(); |
| this.authenticator = new HttpAuthenticator(log); |
| } |
| |
| @Override |
| public void prepare( |
| final HttpHost target, |
| final HttpRequest original, |
| final InternalState state, |
| final AbstractClientExchangeHandler<?> handler) throws HttpException, IOException { |
| if (this.log.isDebugEnabled()) { |
| this.log.debug("[exchange: " + state.getId() + "] start execution"); |
| } |
| |
| final HttpClientContext localContext = state.getLocalContext(); |
| |
| if (original instanceof Configurable) { |
| final RequestConfig config = ((Configurable) original).getConfig(); |
| if (config != null) { |
| localContext.setRequestConfig(config); |
| } |
| } |
| |
| final List<URI> redirectLocations = localContext.getRedirectLocations(); |
| if (redirectLocations != null) { |
| redirectLocations.clear(); |
| } |
| |
| final HttpRequestWrapper request = HttpRequestWrapper.wrap(original); |
| final HttpRoute route = this.routePlanner.determineRoute(target, request, localContext); |
| |
| handler.setRoute(route); |
| |
| state.setMainRequest(request); |
| handler.setCurrentRequest(request); |
| |
| prepareRequest(state, handler); |
| } |
| |
| @Override |
| public HttpRequest generateRequest( |
| final InternalState state, |
| final AbstractClientExchangeHandler<?> handler) throws IOException, HttpException { |
| |
| final HttpRoute route = handler.getRoute(); |
| |
| handler.verifytRoute(); |
| |
| if (!handler.isRouteEstablished()) { |
| int step; |
| loop: |
| do { |
| final HttpRoute fact = handler.getActualRoute(); |
| step = this.routeDirector.nextStep(route, fact); |
| switch (step) { |
| case HttpRouteDirector.CONNECT_TARGET: |
| handler.onRouteToTarget(); |
| break; |
| case HttpRouteDirector.CONNECT_PROXY: |
| handler.onRouteToProxy(); |
| break; |
| case HttpRouteDirector.TUNNEL_TARGET: |
| if (this.log.isDebugEnabled()) { |
| this.log.debug("[exchange: " + state.getId() + "] Tunnel required"); |
| } |
| final HttpRequest connect = createConnectRequest(route, state); |
| handler.setCurrentRequest(HttpRequestWrapper.wrap(connect)); |
| break loop; |
| case HttpRouteDirector.TUNNEL_PROXY: |
| throw new HttpException("Proxy chains are not supported"); |
| case HttpRouteDirector.LAYER_PROTOCOL: |
| handler.onRouteUpgrade(); |
| break; |
| case HttpRouteDirector.UNREACHABLE: |
| throw new HttpException("Unable to establish route: " + |
| "planned = " + route + "; current = " + fact); |
| case HttpRouteDirector.COMPLETE: |
| handler.onRouteComplete(); |
| this.log.debug("Connection route established"); |
| break; |
| default: |
| throw new IllegalStateException("Unknown step indicator " |
| + step + " from RouteDirector."); |
| } |
| } while (step > HttpRouteDirector.COMPLETE); |
| } |
| |
| final HttpClientContext localContext = state.getLocalContext(); |
| HttpRequestWrapper currentRequest = handler.getCurrentRequest(); |
| if (currentRequest == null) { |
| currentRequest = state.getMainRequest(); |
| handler.setCurrentRequest(currentRequest); |
| } |
| |
| if (handler.isRouteEstablished()) { |
| state.incrementExecCount(); |
| if (state.getExecCount() > 1) { |
| final HttpAsyncRequestProducer requestProducer = state.getRequestProducer(); |
| if (!requestProducer.isRepeatable() && state.isRequestContentProduced()) { |
| throw new NonRepeatableRequestException("Cannot retry request " + |
| "with a non-repeatable request entity."); |
| } |
| requestProducer.resetRequest(); |
| } |
| if (this.log.isDebugEnabled()) { |
| this.log.debug("[exchange: " + state.getId() + "] Attempt " + state.getExecCount() + |
| " to execute request"); |
| } |
| |
| if (!currentRequest.containsHeader(AUTH.WWW_AUTH_RESP)) { |
| final AuthState targetAuthState = localContext.getTargetAuthState(); |
| if (this.log.isDebugEnabled()) { |
| this.log.debug("Target auth state: " + targetAuthState.getState()); |
| } |
| this.authenticator.generateAuthResponse(currentRequest, targetAuthState, localContext); |
| } |
| if (!currentRequest.containsHeader(AUTH.PROXY_AUTH_RESP) && !route.isTunnelled()) { |
| final AuthState proxyAuthState = localContext.getProxyAuthState(); |
| if (this.log.isDebugEnabled()) { |
| this.log.debug("Proxy auth state: " + proxyAuthState.getState()); |
| } |
| this.authenticator.generateAuthResponse(currentRequest, proxyAuthState, localContext); |
| } |
| } else { |
| if (!currentRequest.containsHeader(AUTH.PROXY_AUTH_RESP)) { |
| final AuthState proxyAuthState = localContext.getProxyAuthState(); |
| if (this.log.isDebugEnabled()) { |
| this.log.debug("Proxy auth state: " + proxyAuthState.getState()); |
| } |
| this.authenticator.generateAuthResponse(currentRequest, proxyAuthState, localContext); |
| } |
| } |
| |
| final NHttpClientConnection managedConn = handler.getConnection(); |
| localContext.setAttribute(HttpCoreContext.HTTP_CONNECTION, managedConn); |
| final RequestConfig config = localContext.getRequestConfig(); |
| if (config.getSocketTimeout() > 0) { |
| managedConn.setSocketTimeout(config.getSocketTimeout()); |
| } |
| return currentRequest; |
| } |
| |
| @Override |
| public void produceContent( |
| final InternalState state, |
| final ContentEncoder encoder, |
| final IOControl ioctrl) throws IOException { |
| if (this.log.isDebugEnabled()) { |
| this.log.debug("[exchange: " + state.getId() + "] produce content"); |
| } |
| final HttpAsyncRequestProducer requestProducer = state.getRequestProducer(); |
| state.setRequestContentProduced(); |
| requestProducer.produceContent(encoder, ioctrl); |
| if (encoder.isCompleted()) { |
| requestProducer.resetRequest(); |
| } |
| } |
| |
| @Override |
| public void requestCompleted( |
| final InternalState state, |
| final AbstractClientExchangeHandler<?> handler) { |
| if (this.log.isDebugEnabled()) { |
| this.log.debug("[exchange: " + state.getId() + "] Request completed"); |
| } |
| final HttpClientContext localContext = state.getLocalContext(); |
| final HttpAsyncRequestProducer requestProducer = state.getRequestProducer(); |
| requestProducer.requestCompleted(localContext); |
| } |
| |
| @Override |
| public void responseReceived( |
| final HttpResponse response, |
| final InternalState state, |
| final AbstractClientExchangeHandler<?> handler) throws IOException, HttpException { |
| if (this.log.isDebugEnabled()) { |
| this.log.debug("[exchange: " + state.getId() + "] Response received " + response.getStatusLine()); |
| } |
| final HttpClientContext context = state.getLocalContext(); |
| context.setAttribute(HttpCoreContext.HTTP_RESPONSE, response); |
| this.httpProcessor.process(response, context); |
| |
| handler.setCurrentResponse(response); |
| |
| if (!handler.isRouteEstablished()) { |
| final int status = response.getStatusLine().getStatusCode(); |
| if (status < 200) { |
| throw new HttpException("Unexpected response to CONNECT request: " + |
| response.getStatusLine()); |
| } |
| if (status == HttpStatus.SC_OK) { |
| handler.onRouteTunnelToTarget(); |
| handler.setCurrentRequest(null); |
| } else { |
| if (!handleConnectResponse(state, handler)) { |
| state.setFinalResponse(response); |
| } |
| } |
| } else { |
| if (!handleResponse(state, handler)) { |
| state.setFinalResponse(response); |
| } |
| } |
| if (state.getFinalResponse() != null) { |
| final HttpAsyncResponseConsumer<?> responseConsumer = state.getResponseConsumer(); |
| responseConsumer.responseReceived(response); |
| } |
| } |
| |
| @Override |
| public void consumeContent( |
| final InternalState state, |
| final ContentDecoder decoder, |
| final IOControl ioctrl) throws IOException { |
| if (this.log.isDebugEnabled()) { |
| this.log.debug("[exchange: " + state.getId() + "] Consume content"); |
| } |
| if (state.getFinalResponse() != null) { |
| final HttpAsyncResponseConsumer<?> responseConsumer = state.getResponseConsumer(); |
| responseConsumer.consumeContent(decoder, ioctrl); |
| } else { |
| final ByteBuffer tmpbuf = state.getTmpbuf(); |
| tmpbuf.clear(); |
| decoder.read(tmpbuf); |
| } |
| } |
| |
| @Override |
| public void responseCompleted( |
| final InternalState state, |
| final AbstractClientExchangeHandler<?> handler) throws IOException, HttpException { |
| final HttpClientContext localContext = state.getLocalContext(); |
| final HttpResponse currentResponse = handler.getCurrentResponse(); |
| |
| if (!handler.isRouteEstablished()) { |
| final int status = currentResponse.getStatusLine().getStatusCode(); |
| if (status == HttpStatus.SC_OK) { |
| handler.setCurrentResponse(null); |
| return; |
| } |
| } |
| |
| final boolean keepAlive = handler.manageConnectionPersistence(); |
| if (!keepAlive) { |
| handler.releaseConnection(); |
| final AuthState proxyAuthState = localContext.getProxyAuthState(); |
| if (proxyAuthState.getState() == AuthProtocolState.SUCCESS |
| && proxyAuthState.getAuthScheme() != null |
| && proxyAuthState.getAuthScheme().isConnectionBased()) { |
| if (this.log.isDebugEnabled()) { |
| this.log.debug("[exchange: " + state.getId() + "] Resetting proxy auth state"); |
| } |
| proxyAuthState.reset(); |
| } |
| final AuthState targetAuthState = localContext.getTargetAuthState(); |
| if (targetAuthState.getState() == AuthProtocolState.SUCCESS |
| && targetAuthState.getAuthScheme() != null |
| && targetAuthState.getAuthScheme().isConnectionBased()) { |
| if (this.log.isDebugEnabled()) { |
| this.log.debug("[exchange: " + state.getId() + "] Resetting target auth state"); |
| } |
| targetAuthState.reset(); |
| } |
| } |
| |
| Object userToken = localContext.getUserToken(); |
| if (userToken == null) { |
| userToken = this.userTokenHandler.getUserToken(localContext); |
| localContext.setAttribute(HttpClientContext.USER_TOKEN, userToken); |
| } |
| |
| if (state.getFinalResponse() != null) { |
| final HttpAsyncResponseConsumer<?> responseConsumer = state.getResponseConsumer(); |
| responseConsumer.responseCompleted(localContext); |
| if (this.log.isDebugEnabled()) { |
| this.log.debug("[exchange: " + state.getId() + "] Response processed"); |
| } |
| handler.releaseConnection(); |
| } else { |
| if (state.getRedirect() != null) { |
| final HttpUriRequest redirect = state.getRedirect(); |
| final URI uri = redirect.getURI(); |
| if (this.log.isDebugEnabled()) { |
| this.log.debug("[exchange: " + state.getId() + "] Redirecting to '" + uri + "'"); |
| } |
| state.setRedirect(null); |
| |
| final HttpHost newTarget = URIUtils.extractHost(uri); |
| if (newTarget == null) { |
| throw new ProtocolException("Redirect URI does not specify a valid host name: " + uri); |
| } |
| |
| // Reset auth states if redirecting to another host |
| final HttpRoute route = handler.getRoute(); |
| if (!route.getTargetHost().equals(newTarget)) { |
| final AuthState targetAuthState = localContext.getTargetAuthState(); |
| if (this.log.isDebugEnabled()) { |
| this.log.debug("[exchange: " + state.getId() + "] Resetting target auth state"); |
| } |
| targetAuthState.reset(); |
| final AuthState proxyAuthState = localContext.getProxyAuthState(); |
| final AuthScheme authScheme = proxyAuthState.getAuthScheme(); |
| if (authScheme != null && authScheme.isConnectionBased()) { |
| if (this.log.isDebugEnabled()) { |
| this.log.debug("[exchange: " + state.getId() + "] Resetting proxy auth state"); |
| } |
| proxyAuthState.reset(); |
| } |
| } |
| |
| if (!redirect.headerIterator().hasNext()) { |
| final HttpRequest original = state.getMainRequest().getOriginal(); |
| redirect.setHeaders(original.getAllHeaders()); |
| } |
| |
| final HttpRequestWrapper newRequest = HttpRequestWrapper.wrap(redirect); |
| final HttpRoute newRoute = this.routePlanner.determineRoute( |
| newTarget, newRequest, localContext); |
| if (!route.equals(newRoute)) { |
| handler.releaseConnection(); |
| } |
| handler.setRoute(newRoute); |
| handler.setCurrentRequest(newRequest); |
| state.setMainRequest(newRequest); |
| prepareRequest(state, handler); |
| } |
| } |
| handler.setCurrentResponse(null); |
| } |
| |
| private void rewriteRequestURI( |
| final HttpRequestWrapper request, |
| final HttpRoute route) throws ProtocolException { |
| try { |
| URI uri = request.getURI(); |
| if (uri != null) { |
| if (route.getProxyHost() != null && !route.isTunnelled()) { |
| // Make sure the request URI is absolute |
| if (!uri.isAbsolute()) { |
| final HttpHost target = route.getTargetHost(); |
| uri = URIUtils.rewriteURI(uri, target, true); |
| } else { |
| uri = URIUtils.rewriteURI(uri); |
| } |
| } else { |
| // Make sure the request URI is relative |
| if (uri.isAbsolute()) { |
| uri = URIUtils.rewriteURI(uri, null, true); |
| } else { |
| uri = URIUtils.rewriteURI(uri); |
| } |
| } |
| request.setURI(uri); |
| } |
| } catch (final URISyntaxException ex) { |
| throw new ProtocolException("Invalid URI: " + |
| request.getRequestLine().getUri(), ex); |
| } |
| } |
| |
| private void prepareRequest( |
| final InternalState state, |
| final AbstractClientExchangeHandler<?> handler) throws IOException, HttpException { |
| final HttpClientContext localContext = state.getLocalContext(); |
| final HttpRequestWrapper currentRequest = handler.getCurrentRequest(); |
| final HttpRoute route = handler.getRoute(); |
| |
| final HttpRequest original = currentRequest.getOriginal(); |
| URI uri = null; |
| if (original instanceof HttpUriRequest) { |
| uri = ((HttpUriRequest) original).getURI(); |
| } else { |
| final String uriString = original.getRequestLine().getUri(); |
| try { |
| uri = URI.create(uriString); |
| } catch (final IllegalArgumentException ex) { |
| if (this.log.isDebugEnabled()) { |
| this.log.debug("Unable to parse '" + uriString + "' as a valid URI; " + |
| "request URI and Host header may be inconsistent", ex); |
| } |
| } |
| |
| } |
| currentRequest.setURI(uri); |
| |
| // Re-write request URI if needed |
| rewriteRequestURI(currentRequest, route); |
| |
| HttpHost target = null; |
| if (uri != null && uri.isAbsolute() && uri.getHost() != null) { |
| target = new HttpHost(uri.getHost(), uri.getPort(), uri.getScheme()); |
| } |
| if (target == null) { |
| target = route.getTargetHost(); |
| } |
| |
| // Get user info from the URI |
| if (uri != null) { |
| final String userinfo = uri.getUserInfo(); |
| if (userinfo != null) { |
| final CredentialsProvider credsProvider = localContext.getCredentialsProvider(); |
| credsProvider.setCredentials( |
| new AuthScope(target), |
| new UsernamePasswordCredentials(userinfo)); |
| } |
| } |
| |
| localContext.setAttribute(HttpCoreContext.HTTP_REQUEST, currentRequest); |
| localContext.setAttribute(HttpCoreContext.HTTP_TARGET_HOST, target); |
| localContext.setAttribute(HttpClientContext.HTTP_ROUTE, route); |
| this.httpProcessor.process(currentRequest, localContext); |
| } |
| |
| private HttpRequest createConnectRequest( |
| final HttpRoute route, final InternalState state) throws IOException, HttpException { |
| // see RFC 2817, section 5.2 and |
| // INTERNET-DRAFT: Tunneling TCP based protocols through |
| // Web proxy servers |
| final HttpHost target = route.getTargetHost(); |
| final String host = target.getHostName(); |
| final int port = target.getPort(); |
| final StringBuilder buffer = new StringBuilder(host.length() + 6); |
| buffer.append(host); |
| buffer.append(':'); |
| buffer.append(Integer.toString(port)); |
| final HttpRequest request = new BasicHttpRequest("CONNECT", buffer.toString(), HttpVersion.HTTP_1_1); |
| final HttpClientContext localContext = state.getLocalContext(); |
| this.proxyHttpProcessor.process(request, localContext); |
| return request; |
| } |
| |
| private boolean handleConnectResponse( |
| final InternalState state, |
| final AbstractClientExchangeHandler<?> handler) throws HttpException { |
| final HttpClientContext localContext = state.getLocalContext(); |
| final RequestConfig config = localContext.getRequestConfig(); |
| if (config.isAuthenticationEnabled()) { |
| final CredentialsProvider credsProvider = localContext.getCredentialsProvider(); |
| if (credsProvider != null) { |
| final HttpRoute route = handler.getRoute(); |
| final HttpHost proxy = route.getProxyHost(); |
| final HttpResponse currentResponse = handler.getCurrentResponse(); |
| final AuthState proxyAuthState = localContext.getProxyAuthState(); |
| if (this.authenticator.isAuthenticationRequested(proxy, currentResponse, |
| this.proxyAuthStrategy, proxyAuthState, localContext)) { |
| return this.authenticator.handleAuthChallenge(proxy, currentResponse, |
| this.proxyAuthStrategy, proxyAuthState, localContext); |
| } |
| } |
| } |
| return false; |
| } |
| |
| private boolean handleResponse( |
| final InternalState state, |
| final AbstractClientExchangeHandler<?> handler) throws HttpException { |
| final HttpClientContext localContext = state.getLocalContext(); |
| final RequestConfig config = localContext.getRequestConfig(); |
| if (config.isAuthenticationEnabled()) { |
| if (needAuthentication(state, handler)) { |
| // discard previous auth headers |
| final HttpRequestWrapper currentRequest = handler.getCurrentRequest(); |
| final HttpRequest original = currentRequest.getOriginal(); |
| if (!original.containsHeader(AUTH.WWW_AUTH_RESP)) { |
| currentRequest.removeHeaders(AUTH.WWW_AUTH_RESP); |
| } |
| if (!original.containsHeader(AUTH.PROXY_AUTH_RESP)) { |
| currentRequest.removeHeaders(AUTH.PROXY_AUTH_RESP); |
| } |
| return true; |
| } |
| } |
| if (config.isRedirectsEnabled()) { |
| final HttpRequest currentRequest = handler.getCurrentRequest(); |
| final HttpResponse currentResponse = handler.getCurrentResponse(); |
| if (this.redirectStrategy.isRedirected(currentRequest, currentResponse, localContext)) { |
| final int maxRedirects = config.getMaxRedirects() >= 0 ? config.getMaxRedirects() : 100; |
| if (state.getRedirectCount() >= maxRedirects) { |
| throw new RedirectException("Maximum redirects (" + maxRedirects + ") exceeded"); |
| } |
| state.incrementRedirectCount(); |
| final HttpUriRequest redirect = this.redirectStrategy.getRedirect(currentRequest, currentResponse, |
| localContext); |
| state.setRedirect(redirect); |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| private boolean needAuthentication( |
| final InternalState state, |
| final AbstractClientExchangeHandler<?> handler) throws HttpException { |
| final HttpClientContext localContext = state.getLocalContext(); |
| final CredentialsProvider credsProvider = localContext.getCredentialsProvider(); |
| if (credsProvider != null) { |
| final HttpRoute route = handler.getRoute(); |
| final HttpResponse currentResponse = handler.getCurrentResponse(); |
| HttpHost target = localContext.getTargetHost(); |
| if (target == null) { |
| target = route.getTargetHost(); |
| } |
| if (target.getPort() < 0) { |
| target = new HttpHost( |
| target.getHostName(), |
| route.getTargetHost().getPort(), |
| target.getSchemeName()); |
| } |
| final AuthState targetAuthState = localContext.getTargetAuthState(); |
| final AuthState proxyAuthState = localContext.getProxyAuthState(); |
| |
| final boolean targetAuthRequested = this.authenticator.isAuthenticationRequested( |
| target, currentResponse, this.targetAuthStrategy, targetAuthState, localContext); |
| |
| HttpHost proxy = route.getProxyHost(); |
| // if proxy is not set use target host instead |
| if (proxy == null) { |
| proxy = route.getTargetHost(); |
| } |
| final boolean proxyAuthRequested = this.authenticator.isAuthenticationRequested( |
| proxy, currentResponse, this.proxyAuthStrategy, proxyAuthState, localContext); |
| |
| if (targetAuthRequested) { |
| return this.authenticator.handleAuthChallenge(target, currentResponse, |
| this.targetAuthStrategy, targetAuthState, localContext); |
| } |
| if (proxyAuthRequested) { |
| return this.authenticator.handleAuthChallenge(proxy, currentResponse, |
| this.proxyAuthStrategy, proxyAuthState, localContext); |
| } |
| } |
| return false; |
| } |
| |
| } |
