private boolean transferEncodingIsPresent(final HttpResponse response) { final Header hdr = response.getFirstHeader(HTTP.TRANSFER_ENCODING); return hdr != null; }
@Override public Header getFirstHeader(final String name) { return original.getFirstHeader(name); }
private boolean entryAndResponseHaveDateHeader(final HttpCacheEntry entry, final HttpResponse response) { if (entry.getFirstHeader(HTTP.DATE_HEADER) != null && response.getFirstHeader(HTTP.DATE_HEADER) != null) { return true; } return false; }
protected boolean isExplicitlyCacheable(final HttpResponse response) { if (response.getFirstHeader(HeaderConstants.EXPIRES) != null) { return true; } final String[] cacheableParams = { HeaderConstants.CACHE_CONTROL_MAX_AGE, "s-maxage", HeaderConstants.CACHE_CONTROL_MUST_REVALIDATE, HeaderConstants.CACHE_CONTROL_PROXY_REVALIDATE, HeaderConstants.PUBLIC }; return hasCacheControlParameterFrom(response, cacheableParams); }
private boolean expiresHeaderLessOrEqualToDateHeaderAndNoCacheControl( final HttpResponse response) { if (response.getFirstHeader(HeaderConstants.CACHE_CONTROL) != null) { return false; } final Header expiresHdr = response.getFirstHeader(HeaderConstants.EXPIRES); final Header dateHdr = response.getFirstHeader(HTTP.DATE_HEADER); if (expiresHdr == null || dateHdr == null) { return false; } final Date expires = DateUtils.parseDate(expiresHdr.getValue()); final Date date = DateUtils.parseDate(dateHdr.getValue()); if (expires == null || date == null) { return false; } return expires.equals(date) || expires.before(date); }
private void ensure206ContainsDateHeader(final HttpResponse response) { if (response.getFirstHeader(HTTP.DATE_HEADER) == null) { response.addHeader(HTTP.DATE_HEADER, DateUtils.formatDate(new Date())); } }
private boolean from1_0Origin(final HttpResponse response) { final Header via = response.getFirstHeader(HeaderConstants.VIA); if (via != null) { for(final HeaderElement elt : via.getElements()) { final String proto = elt.toString().split("\\s")[0]; if (proto.contains("/")) { return proto.equals("HTTP/1.0"); } else { return proto.equals("1.0"); } } } return HttpVersion.HTTP_1_0.equals(response.getProtocolVersion()); }
private boolean responseAndEntryEtagsDiffer(final HttpResponse response, final HttpCacheEntry entry) { final Header entryEtag = entry.getFirstHeader(HeaderConstants.ETAG); final Header responseEtag = response.getFirstHeader(HeaderConstants.ETAG); if (entryEtag == null || responseEtag == null) { return false; } return (!entryEtag.getValue().equals(responseEtag.getValue())); }
private URL getContentLocationURL(final URL reqURL, final HttpResponse response) { final Header clHeader = response.getFirstHeader("Content-Location"); if (clHeader == null) { return null; } final String contentLocation = clHeader.getValue(); final URL canonURL = getAbsoluteURL(contentLocation); if (canonURL != null) { return canonURL; } return getRelativeURL(reqURL, contentLocation); }
private void addMissingContentLengthHeader(final HttpResponse response, final HttpEntity entity) { if (transferEncodingIsPresent(response)) { return; } Header contentLength = response.getFirstHeader(HTTP.CONTENT_LEN); if (contentLength == null) { contentLength = new BasicHeader(HTTP.CONTENT_LEN, Long.toString(entity .getContentLength())); response.setHeader(contentLength); } }
private URL getLocationURL(final URL reqURL, final HttpResponse response) { final Header clHeader = response.getFirstHeader("Location"); if (clHeader == null) { return null; } final String location = clHeader.getValue(); final URL canonURL = getAbsoluteURL(location); if (canonURL != null) { return canonURL; } return getRelativeURL(reqURL, location); }
private void ensure200ForOPTIONSRequestWithNoBodyHasContentLengthZero(final HttpRequest request, final HttpResponse response) { if (!request.getRequestLine().getMethod().equalsIgnoreCase(HeaderConstants.OPTIONS_METHOD)) { return; } if (response.getStatusLine().getStatusCode() != HttpStatus.SC_OK) { return; } if (response.getFirstHeader(HTTP.CONTENT_LEN) == null) { response.addHeader(HTTP.CONTENT_LEN, "0"); } }
CloseableHttpResponse generateIncompleteResponseError( final HttpResponse response, final Resource resource) { final Integer contentLength = Integer.valueOf(response.getFirstHeader(HTTP.CONTENT_LEN).getValue()); final HttpResponse error = new BasicHttpResponse(HttpVersion.HTTP_1_1, HttpStatus.SC_BAD_GATEWAY, "Bad Gateway"); error.setHeader("Content-Type","text/plain;charset=UTF-8"); final String msg = String.format("Received incomplete response " + "with Content-Length %d but actual body length %d", contentLength, resource.length()); final byte[] msgBytes = msg.getBytes(); error.setHeader("Content-Length", Integer.toString(msgBytes.length)); error.setEntity(new ByteArrayEntity(msgBytes)); return Proxies.enhanceResponse(error); }
private boolean entryDateHeaderNewerThenResponse(final HttpCacheEntry entry, final HttpResponse response) { final Date entryDate = DateUtils.parseDate(entry.getFirstHeader(HTTP.DATE_HEADER) .getValue()); final Date responseDate = DateUtils.parseDate(response.getFirstHeader(HTTP.DATE_HEADER) .getValue()); if (entryDate == null || responseDate == null) { return false; } if (!entryDate.after(responseDate)) { return false; } return true; }
boolean isIncompleteResponse(final HttpResponse resp, final Resource resource) { final int status = resp.getStatusLine().getStatusCode(); if (status != HttpStatus.SC_OK && status != HttpStatus.SC_PARTIAL_CONTENT) { return false; } final Header hdr = resp.getFirstHeader(HTTP.CONTENT_LEN); if (hdr == null) { return false; } final int contentLength; try { contentLength = Integer.parseInt(hdr.getValue()); } catch (final NumberFormatException nfe) { return false; } if (resource == null) { return false; } return (resource.length() < contentLength); }
private boolean responseDateOlderThanEntryDate(final HttpResponse response, final HttpCacheEntry entry) { final Header entryDateHeader = entry.getFirstHeader(HTTP.DATE_HEADER); final Header responseDateHeader = response.getFirstHeader(HTTP.DATE_HEADER); if (entryDateHeader == null || responseDateHeader == null) { /* be conservative; should probably flush */ return false; } final Date entryDate = DateUtils.parseDate(entryDateHeader.getValue()); final Date responseDate = DateUtils.parseDate(responseDateHeader.getValue()); if (entryDate == null || responseDate == null) { return false; } return responseDate.before(entryDate); } }
private boolean revalidationResponseIsTooOld(final HttpResponse backendResponse, final HttpCacheEntry cacheEntry) { final Header entryDateHeader = cacheEntry.getFirstHeader(HTTP.DATE_HEADER); final Header responseDateHeader = backendResponse.getFirstHeader(HTTP.DATE_HEADER); if (entryDateHeader != null && responseDateHeader != null) { final Date entryDate = DateUtils.parseDate(entryDateHeader.getValue()); final Date respDate = DateUtils.parseDate(responseDateHeader.getValue()); if (entryDate == null || respDate == null) { // either backend response or cached entry did not have a valid // Date header, so we can't tell if they are out of order // according to the origin clock; thus we can skip the // unconditional retry recommended in 13.2.6 of RFC 2616. return false; } if (respDate.before(entryDate)) { return true; } } return false; }
private void warningsWithNonMatchingWarnDatesAreRemoved( final HttpResponse response) { final Date responseDate = DateUtils.parseDate(response.getFirstHeader(HTTP.DATE_HEADER).getValue()); if (responseDate == null) { return; } final Header[] warningHeaders = response.getHeaders(HeaderConstants.WARNING); if (warningHeaders == null || warningHeaders.length == 0) { return; } final List<Header> newWarningHeaders = new ArrayList<Header>(); boolean modified = false; for(final Header h : warningHeaders) { for(final WarningValue wv : WarningValue.getWarningValues(h)) { final Date warnDate = wv.getWarnDate(); if (warnDate == null || warnDate.equals(responseDate)) { newWarningHeaders.add(new BasicHeader(HeaderConstants.WARNING,wv.toString())); } else { modified = true; } } } if (modified) { response.removeHeaders(HeaderConstants.WARNING); for(final Header h : newWarningHeaders) { response.addHeader(h); } } }
private boolean alreadyHaveNewerCacheEntry(final HttpHost target, final HttpRequestWrapper request, final HttpResponse backendResponse) { HttpCacheEntry existing = null; try { existing = responseCache.getCacheEntry(target, request); } catch (final IOException ioe) { // nop } if (existing == null) { return false; } final Header entryDateHeader = existing.getFirstHeader(HTTP.DATE_HEADER); if (entryDateHeader == null) { return false; } final Header responseDateHeader = backendResponse.getFirstHeader(HTTP.DATE_HEADER); if (responseDateHeader == null) { return false; } final Date entryDate = DateUtils.parseDate(entryDateHeader.getValue()); final Date responseDate = DateUtils.parseDate(responseDateHeader.getValue()); if (entryDate == null || responseDate == null) { return false; } return responseDate.before(entryDate); }
@Override public boolean isRedirected( final HttpRequest request, final HttpResponse response, final HttpContext context) throws ProtocolException { Args.notNull(request, "HTTP request"); Args.notNull(response, "HTTP response"); final int statusCode = response.getStatusLine().getStatusCode(); final String method = request.getRequestLine().getMethod(); final Header locationHeader = response.getFirstHeader("location"); switch (statusCode) { case HttpStatus.SC_MOVED_TEMPORARILY: return isRedirectable(method) && locationHeader != null; case HttpStatus.SC_MOVED_PERMANENTLY: case HttpStatus.SC_TEMPORARY_REDIRECT: return isRedirectable(method); case HttpStatus.SC_SEE_OTHER: return true; default: return false; } //end of switch }