@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; } if (!request.containsHeader(HTTP.CONN_DIRECTIVE)) { // Default policy is to keep connection alive // whenever possible request.addHeader(HTTP.CONN_DIRECTIVE, HTTP.CONN_KEEP_ALIVE); } }
private HttpRequestWrapper(final HttpRequest request, final HttpHost target) { super(); this.original = Args.notNull(request, "HTTP request"); this.target = target; this.version = this.original.getRequestLine().getProtocolVersion(); this.method = this.original.getRequestLine().getMethod(); if (request instanceof HttpUriRequest) { this.uri = ((HttpUriRequest) request).getURI(); } else { this.uri = null; } setHeaders(request.getAllHeaders()); }
private void decrementOPTIONSMaxForwardsIfGreaterThen0(final HttpRequest request) { if (!HeaderConstants.OPTIONS_METHOD.equals(request.getRequestLine().getMethod())) { return; } final Header maxForwards = request.getFirstHeader(HeaderConstants.MAX_FORWARDS); if (maxForwards == null) { return; } request.removeHeaders(HeaderConstants.MAX_FORWARDS); final int currentMaxForwards = Integer.parseInt(maxForwards.getValue()); request.setHeader(HeaderConstants.MAX_FORWARDS, Integer.toString(currentMaxForwards - 1)); }
@Override public void process( final HttpRequest request, final HttpContext context) throws HttpException, IOException { /* Signal support for Accept-Encoding transfer encodings. */ if (!request.containsHeader("Accept-Encoding")) { request.addHeader("Accept-Encoding", acceptEncoding); } }
@Override protected boolean handleAsIdempotent(final HttpRequest request) { final String method = request.getRequestLine().getMethod().toUpperCase(Locale.ROOT); final Boolean b = this.idempotentMethods.get(method); return b != null && b.booleanValue(); }
@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); } } } } }
@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")) { request.setHeader(PROXY_CONN_DIRECTIVE, HTTP.CONN_KEEP_ALIVE); return; } final HttpClientContext clientContext = HttpClientContext.adapt(context); // Obtain the client connection (required) final RouteInfo route = clientContext.getHttpRoute(); if (route == null) { this.log.debug("Connection route not set in the context"); return; } if (route.getHopCount() == 1 || route.isTunnelled()) { if (!request.containsHeader(HTTP.CONN_DIRECTIVE)) { request.addHeader(HTTP.CONN_DIRECTIVE, HTTP.CONN_KEEP_ALIVE); } } if (route.getHopCount() == 2 && !route.isTunnelled()) { if (!request.containsHeader(PROXY_CONN_DIRECTIVE)) { request.addHeader(PROXY_CONN_DIRECTIVE, HTTP.CONN_KEEP_ALIVE); } } }
if (request instanceof HttpEntityEnclosingRequest) { if (this.overwrite) { request.removeHeaders(HTTP.TRANSFER_ENCODING); request.removeHeaders(HTTP.CONTENT_LEN); } else { if (request.containsHeader(HTTP.TRANSFER_ENCODING)) { throw new ProtocolException("Transfer-encoding header already present"); if (request.containsHeader(HTTP.CONTENT_LEN)) { throw new ProtocolException("Content-Length header already present"); final ProtocolVersion ver = request.getRequestLine().getProtocolVersion(); final HttpEntity entity = ((HttpEntityEnclosingRequest)request).getEntity(); if (entity == null) { request.addHeader(HTTP.CONTENT_LEN, "0"); return; request.addHeader(HTTP.TRANSFER_ENCODING, HTTP.CHUNK_CODING); } else { request.addHeader(HTTP.CONTENT_LEN, Long.toString(entity.getContentLength())); if (entity.getContentType() != null && !request.containsHeader( HTTP.CONTENT_TYPE )) { request.addHeader(entity.getContentType()); if (entity.getContentEncoding() != null && !request.containsHeader( HTTP.CONTENT_ENCODING)) { request.addHeader(entity.getContentEncoding());
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; }
@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); } } }
private void stripOtherFreshnessDirectivesWithNoCache(final HttpRequest request) { final List<HeaderElement> outElts = new ArrayList<HeaderElement>(); boolean shouldStrip = false; for(final Header h : request.getHeaders(HeaderConstants.CACHE_CONTROL)) { for(final HeaderElement elt : h.getElements()) { if (!disallowedWithNoCache.contains(elt.getName())) { outElts.add(elt); } if (HeaderConstants.CACHE_CONTROL_NO_CACHE.equals(elt.getName())) { shouldStrip = true; } } } if (!shouldStrip) { return; } request.removeHeaders(HeaderConstants.CACHE_CONTROL); request.setHeader(HeaderConstants.CACHE_CONTROL, buildHeaderFromElements(outElts)); }
private RequestProtocolError requestHasWeakETagAndRange(final HttpRequest request) { // TODO: Should these be looking at all the headers marked as Range? final String method = request.getRequestLine().getMethod(); if (!(HeaderConstants.GET_METHOD.equals(method))) { return null; } final Header range = request.getFirstHeader(HeaderConstants.RANGE); if (range == null) { return null; } final Header ifRange = request.getFirstHeader(HeaderConstants.IF_RANGE); if (ifRange == null) { return null; } final String val = ifRange.getValue(); if (val.startsWith("W/")) { return RequestProtocolError.WEAK_ETAG_AND_RANGE_ERROR; } return null; }
private void remove100ContinueHeaderIfExists(final HttpRequest request) { boolean hasHeader = false; final Header[] expectHeaders = request.getHeaders(HTTP.EXPECT_DIRECTIVE); List<HeaderElement> expectElementsThatAreNot100Continue = new ArrayList<HeaderElement>(); for (final Header h : expectHeaders) { for (final HeaderElement elt : h.getElements()) { if (!(HTTP.EXPECT_CONTINUE.equalsIgnoreCase(elt.getName()))) { expectElementsThatAreNot100Continue.add(elt); } else { hasHeader = true; } } if (hasHeader) { request.removeHeader(h); for (final HeaderElement elt : expectElementsThatAreNot100Continue) { final BasicHeader newHeader = new BasicHeader(HTTP.EXPECT_DIRECTIVE, elt.getName()); request.addHeader(newHeader); } return; } else { expectElementsThatAreNot100Continue = new ArrayList<HeaderElement>(); } } }
/** * @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; }
if (!redirect.headerIterator().hasNext()) { final HttpRequest original = request.getOriginal(); redirect.setHeaders(original.getAllHeaders());
private boolean hasValidDateField(final HttpRequest request, final String headerName) { for(final Header h : request.getHeaders(headerName)) { final Date date = DateUtils.parseDate(h.getValue()); return date != null; } return false; } }
final String method = request.getRequestLine().getMethod(); final ProtocolVersion pv = request.getRequestLine().getProtocolVersion(); if (HttpVersion.HTTP_1_1.compareToVersion(pv) != 0) { log.trace("non-HTTP/1.1 request was not serveable from cache"); if (request.getHeaders(HeaderConstants.PRAGMA).length > 0) { log.trace("request with Pragma header was not serveable from cache"); return false; final Header[] cacheControlHeaders = request.getHeaders(HeaderConstants.CACHE_CONTROL); for (final Header cacheControl : cacheControlHeaders) { for (final HeaderElement cacheControlElement : cacheControl.getElements()) {
@Override public void process(final HttpRequest request, final HttpContext context) throws HttpException, IOException { Args.notNull(request, "HTTP request"); if ((request instanceof HttpEntityEnclosingRequest) && !request.containsHeader(HTTP.DATE_HEADER)) { final String httpdate = DATE_GENERATOR.getCurrentDate(); request.setHeader(HTTP.DATE_HEADER, httpdate); } }
private void add100ContinueHeaderIfMissing(final HttpRequest request) { boolean hasHeader = false; for (final Header h : request.getHeaders(HTTP.EXPECT_DIRECTIVE)) { for (final HeaderElement elt : h.getElements()) { if (HTTP.EXPECT_CONTINUE.equalsIgnoreCase(elt.getName())) { hasHeader = true; } } } if (!hasHeader) { request.addHeader(HTTP.EXPECT_DIRECTIVE, HTTP.EXPECT_CONTINUE); } }