Refine search
HttpParams params = message.getParams(); boolean strict = params.isParameterTrue(CoreProtocolPNames.STRICT_TRANSFER_ENCODING); Header transferEncodingHeader = message.getFirstHeader(HTTP.TRANSFER_ENCODING); Header contentLengthHeader = message.getFirstHeader(HTTP.CONTENT_LEN); && !encoding.equalsIgnoreCase(HTTP.CHUNK_CODING) && !encoding.equalsIgnoreCase(HTTP.IDENTITY_CODING)) { throw new ProtocolException("Unsupported transfer encoding: " + encoding); if (HTTP.IDENTITY_CODING.equalsIgnoreCase(transferEncodingHeader.getValue())) { return IDENTITY; } else if ((len > 0) && (HTTP.CHUNK_CODING.equalsIgnoreCase( } else { if (strict) { throw new ProtocolException("Chunk-encoding must be the last one applied"); Header[] headers = message.getHeaders(HTTP.CONTENT_LEN); if (strict && headers.length > 1) { throw new ProtocolException("Multiple content length headers"); Header header = headers[i]; try { contentlen = Long.parseLong(header.getValue()); break; } catch (NumberFormatException e) {
public static void add(HttpMessage httpMessage, Headers headers) { for (Map.Entry<String, List<String>> entry : headers.entrySet()) { for (String value : entry.getValue()) { httpMessage.addHeader(entry.getKey(), value); } } }
Header transferEncodingHeader = message.getFirstHeader(HTTP.TRANSFER_ENCODING); Header contentLengthHeader = message.getFirstHeader(HTTP.CONTENT_LEN); if (transferEncodingHeader != null) { String s = transferEncodingHeader.getValue(); if (HTTP.CHUNK_CODING.equalsIgnoreCase(s)) { if (message.getProtocolVersion().lessEquals(HttpVersion.HTTP_1_0)) { throw new ProtocolException( "Chunked transfer encoding not allowed for " + message.getProtocolVersion()); return IDENTITY; } else { throw new ProtocolException( "Unsupported transfer encoding: " + s); String s = contentLengthHeader.getValue(); try { long len = Long.parseLong(s); return len; } catch (NumberFormatException e) { throw new ProtocolException("Invalid content length: " + s);
protected String get(final String headerName, final HttpMessage message) { Header header = message.getFirstHeader(headerName); if (header!=null) return header.getValue(); else return ""; }
public <T> T getHeader(Header<T> header) { org.apache.http.Header[] httpHeaders = message.getHeaders(header.getName()); List<String> headerValues = new ArrayList<>(httpHeaders.length); for (org.apache.http.Header httpHeader: httpHeaders) { headerValues.add(httpHeader.getValue()); } return header.deserialize(headerValues); }
protected boolean has(final String headerName, final String headerValueOrElement, final HttpMessage message) { Header[] headers = message.getHeaders(headerName); for (Header header : headers) { if (header.getValue().equals(headerValueOrElement)) return true; HeaderElement[] elements = header.getElements(); for (HeaderElement element : elements) if (element.getName().equals(headerValueOrElement)) return true; } return false; }
protected void transferFirstHeader(final String headerName, final String destName, final HttpMessage origin, final HttpMessage dest) { Header header = origin.getFirstHeader(headerName); if (header!=null) dest.setHeader(destName, header.getValue()); }
protected boolean hasCacheControlParameterFrom(final HttpMessage msg, final String[] params) { final Header[] cacheControlHeaders = msg.getHeaders(HeaderConstants.CACHE_CONTROL); for (final Header header : cacheControlHeaders) { for (final HeaderElement elem : header.getElements()) { for (final String param : params) { if (param.equalsIgnoreCase(elem.getName())) { return true; } } } } return false; }
protected String get(final String headerName, final String elementName, final HttpMessage message) { Header header = message.getFirstHeader(headerName); if (header==null) return ""; HeaderElement[] elements = header.getElements(); for (HeaderElement element : elements) if (element.getName().equals(elementName)) return element.getValue(); return ""; } }
public HttpMessage parse() throws IOException, HttpException { HttpMessage message = null; try { message = parseHead(this.sessionBuffer); } catch (ParseException px) { throw new ProtocolException(px.getMessage(), px); } Header[] headers = AbstractMessageParser.parseHeaders( this.sessionBuffer, this.maxHeaderCount, this.maxLineLen, this.lineParser); message.setHeaders(headers); return message; }
Header contentTypeHeader = message.getFirstHeader(HTTP.CONTENT_TYPE); if (contentTypeHeader != null) { entity.setContentType(contentTypeHeader); Header contentEncodingHeader = message.getFirstHeader(HTTP.CONTENT_ENCODING); if (contentEncodingHeader != null) { entity.setContentEncoding(contentEncodingHeader);
parseHeadLine(); } catch (final ParseException px) { throw new ProtocolException(px.getMessage(), px); for (final CharArrayBuffer buffer : this.headerBufs) { try { this.message.addHeader(lineParser.parseHeader(buffer)); } catch (final ParseException ex) { throw new ProtocolException(ex.getMessage(), ex);
public void write( final HttpMessage message) throws IOException, HttpException { if (message == null) { throw new IllegalArgumentException("HTTP message may not be null"); } writeHeadLine(message); for (Iterator it = message.headerIterator(); it.hasNext(); ) { Header header = (Header) it.next(); this.sessionBuffer.writeLine (lineFormatter.formatHeader(this.lineBuf, header)); } this.lineBuf.clear(); this.sessionBuffer.writeLine(this.lineBuf); }
protected boolean has(final String headerName, final HttpMessage message) { return message.getHeaders(headerName).length>0; }
private String generateViaHeader(HttpMessage msg) { final ProtocolVersion pv = msg.getProtocolVersion(); String existingEntry = viaHeaders.get(pv); if (existingEntry != null) return existingEntry; final VersionInfo vi = VersionInfo.loadVersionInfo("org.apache.http.client", getClass().getClassLoader()); final String release = (vi != null) ? vi.getRelease() : VersionInfo.UNAVAILABLE; String value; if ("http".equalsIgnoreCase(pv.getProtocol())) { value = String.format("%d.%d localhost (Apache-HttpClient/%s (cache))", pv.getMajor(), pv.getMinor(), release); } else { value = String.format("%s/%d.%d localhost (Apache-HttpClient/%s (cache))", pv.getProtocol(), pv.getMajor(), pv.getMinor(), release); } viaHeaders.put(pv, value); return value; }
public <T> void setHeader(Header<T> header, T value) { message.removeHeaders(header.getName()); for (String headerValue: header.serialize(value)) { message.addHeader(header.getName(), headerValue); } } }
/** * Applies the configured User-Agent string to the HTTP request * * @param message * HTTP request */ public static void applyUserAgent(HttpMessage message) { if (userAgent != null) { message.setHeader("User-Agent", userAgent); } }
protected static String getParam(HttpMessage message, String paramName) { HttpParams params = message.getParams(); String param = (String) params.getParameter(paramName); if (param == null) { param = "-"; } return param; }
protected String contentTypeOf(HttpMessage message) { final Header contentType = message.getFirstHeader("Content-Type"); return contentType == null ? null : contentType.getValue(); }
/** * gets the header values from the given message, with the given name. * * @param message - The message, HttpRequest or HttpResponse * @param name - The header, which we need to get the value of. * @return - The header value. */ protected static String getHeaderValues(HttpMessage message, String name) { int length = 0; Header[] header = new Header[0]; StringBuffer headerValue = new StringBuffer(); try { header = message.getHeaders(name); length = header.length; } catch (Exception e) { // The header doesn't exist } if (length == 0) { return "-"; } else if (length == 1) { return header[0].getValue(); } else { headerValue.append(header[0].getValue()); for (int i = 1; i < length; i++) { headerValue.append(" - ").append(header[i].getValue()); } } return headerValue.toString(); }