/** * @deprecated (4.3) use * {@link cz.msebera.android.httpclient.client.config.RequestConfig}. */ @Override @Deprecated public HttpParams getParams() { if (this.params == null) { this.params = original.getParams().copy(); } return this.params; }
String getCredentialsCharset(final HttpRequest request) { String charset = (String) request.getParams().getParameter(AuthPNames.CREDENTIAL_CHARSET); if (charset == null) { charset = getCredentialsCharset().name(); } return charset; }
@Override public AuthScheme create(final HttpContext context) { final HttpRequest request = (HttpRequest) context.getAttribute( ExecutionContext.HTTP_REQUEST); return getAuthScheme(name, request.getParams()); }
@Override public CookieSpec create(final HttpContext context) { final HttpRequest request = (HttpRequest) context.getAttribute( ExecutionContext.HTTP_REQUEST); return getCookieSpec(name, request.getParams()); }
private HttpRoute determineRoute( final HttpHost target, final HttpRequest request, final HttpContext context) throws HttpException { HttpHost host = target; if (host == null) { host = (HttpHost) request.getParams().getParameter(ClientPNames.DEFAULT_HOST); } return this.routePlanner.determineRoute(host, request, context); }
/** * Obtains parameters for executing a request. * The default implementation in this class creates a new * {@link ClientParamsStack} from the request parameters * and the client parameters. * <p> * This method is called by the default implementation of * {@link #execute(HttpHost,HttpRequest,HttpContext)} * to obtain the parameters for the * {@link DefaultRequestDirector}. * </p> * * @param req the request that will be executed * * @return the parameters to use */ protected HttpParams determineParams(final HttpRequest req) { return new ClientParamsStack (null, getParams(), req.getParams(), null); }
/** * Determines the route for a request. * Called by {@link #execute} * to determine the route for either the original or a followup request. * * @param targetHost the target host for the request. * Implementations may accept {@code null} * if they can still determine a route, for example * to a default target or by inspecting the request. * @param request the request to execute * @param context the context to use for the execution, * never {@code null} * * @return the route the request should take * * @throws HttpException in case of a problem */ protected HttpRoute determineRoute(final HttpHost targetHost, final HttpRequest request, final HttpContext context) throws HttpException { return this.routePlanner.determineRoute( targetHost != null ? targetHost : (HttpHost) request.getParams() .getParameter(ClientPNames.DEFAULT_HOST), request, context); }
@Override public void process(final HttpRequest request, final HttpContext context) throws HttpException, IOException { Args.notNull(request, "HTTP request"); if (!request.containsHeader(HTTP.USER_AGENT)) { String s = null; final HttpParams params = request.getParams(); if (params != null) { s = (String) params.getParameter(CoreProtocolPNames.USER_AGENT); } if (s == null) { s = this.userAgent; } if (s != null) { request.addHeader(HTTP.USER_AGENT, s); } } }
@Override public void process(final HttpRequest request, final HttpContext context) throws HttpException, IOException { Args.notNull(request, "HTTP request"); final String method = request.getRequestLine().getMethod(); if (method.equalsIgnoreCase("CONNECT")) { return; } // Add default headers @SuppressWarnings("unchecked") Collection<? extends Header> defHeaders = (Collection<? extends Header>) request.getParams().getParameter(ClientPNames.DEFAULT_HEADERS); if (defHeaders == null) { defHeaders = this.defaultHeaders; } if (defHeaders != null) { for (final Header defHeader : defHeaders) { request.addHeader(defHeader); } } }
public HttpRoute determineRoute(final HttpHost target, final HttpRequest request, final HttpContext context) throws HttpException { Args.notNull(request, "HTTP request"); // If we have a forced route, we can do without a target. HttpRoute route = ConnRouteParams.getForcedRoute(request.getParams()); if (route != null) { return route; } // If we get here, there is no forced route. // So we need a target to compute a route. Asserts.notNull(target, "Target host"); final InetAddress local = ConnRouteParams.getLocalAddress(request.getParams()); final HttpHost proxy = determineProxy(target, request, context); final Scheme schm = this.schemeRegistry.getScheme(target.getSchemeName()); // as it is typically used for TLS/SSL, we assume that // a layered scheme implies a secure connection final boolean secure = schm.isLayered(); if (proxy == null) { route = new HttpRoute(target, local, secure); } else { route = new HttpRoute(target, local, proxy, secure); } return route; }
@Override public void process(final HttpRequest request, final HttpContext context) throws HttpException, IOException { Args.notNull(request, "HTTP request"); if (!request.containsHeader(HTTP.EXPECT_DIRECTIVE)) { if (request instanceof HttpEntityEnclosingRequest) { final ProtocolVersion ver = request.getRequestLine().getProtocolVersion(); final HttpEntity entity = ((HttpEntityEnclosingRequest)request).getEntity(); // Do not send the expect header if request body is known to be empty if (entity != null && entity.getContentLength() != 0 && !ver.lessEquals(HttpVersion.HTTP_1_0)) { final boolean active = request.getParams().getBooleanParameter( CoreProtocolPNames.USE_EXPECT_CONTINUE, this.activeByDefault); if (active) { request.addHeader(HTTP.EXPECT_DIRECTIVE, HTTP.EXPECT_CONTINUE); } } } } }
public RequestWrapper(final HttpRequest request) throws ProtocolException { super(); Args.notNull(request, "HTTP request"); this.original = request; setParams(request.getParams()); setHeaders(request.getAllHeaders()); // Make a copy of the original URI if (request instanceof HttpUriRequest) { this.uri = ((HttpUriRequest) request).getURI(); this.method = ((HttpUriRequest) request).getMethod(); this.version = null; } else { final RequestLine requestLine = request.getRequestLine(); try { this.uri = new URI(requestLine.getUri()); } catch (final URISyntaxException ex) { throw new ProtocolException("Invalid request URI: " + requestLine.getUri(), ex); } this.method = requestLine.getMethod(); this.version = request.getProtocolVersion(); } this.execCount = 0; }
final HttpParams params = request.getParams(); if (params instanceof HttpParamsNames) { if (!((HttpParamsNames) params).getNames().isEmpty()) {