@Override public FluentCaseInsensitiveStringsMap getHeaders() { if (!initialized) { synchronized (headers) { if (!initialized) { initialized = true; final MimeHeaders headersLocal = response.getHeaders(); for (int i = 0; i < headersLocal.size(); i++) { headers.add(headersLocal.getName(i).toString(Charsets.ASCII_CHARSET), headersLocal.getValue(i).toString(Charsets.ASCII_CHARSET)); } } } } return headers; }
private static Request newRequest(final HttpTransactionContext ctx, final Uri newUri, final HttpResponsePacket response, final Realm realm, boolean asGet) { final Request prototype = ctx.getAhcRequest(); final FluentCaseInsensitiveStringsMap prototypeHeaders = prototype.getHeaders(); prototypeHeaders.remove(Header.Host.toString()); prototypeHeaders.remove(Header.ContentLength.toString()); if (asGet) prototypeHeaders.remove(Header.ContentType.toString()); if (realm != null && realm.getScheme() == AuthScheme.NTLM) { prototypeHeaders.remove(Header.Authorization.toString()); prototypeHeaders.remove(Header.ProxyAuthorization.toString()); } final RequestBuilder builder = new RequestBuilder(prototype); if (asGet) { builder.setMethod("GET"); } builder.setUrl(newUri.toString()); for (String cookieStr : response.getHeaders().values(Header.SetCookie)) { builder.addOrReplaceCookie(CookieDecoder.decode(cookieStr)); } return builder.build(); }
/** * Return the set of header to be used for the push. * * @return the set of header to be used for the push. */ public Iterable<String> getHeaderNames() { return headers.names(); }
private void addAcceptHeaders(final HttpRequestPacket requestPacket) { final MimeHeaders headers = requestPacket.getHeaders(); if (config.isCompressionEnforced() && !headers.contains(Header.AcceptEncoding)) { headers.addValue(Header.AcceptEncoding).setString("gzip"); } if (!headers.contains(Header.Accept)) { headers.addValue(Header.Accept).setString("*/*"); } }
/** * check if we need to wrap the PayloadGenerator with ExpectHandler */ private PayloadGenerator wrapWithExpectHandlerIfNeeded(final PayloadGenerator payloadGenerator, final HttpRequestPacket requestPacket) { if (payloadGenerator == null) { return null; } // check if we need to wrap the PayloadGenerator with ExpectWrapper final MimeHeaders headers = requestPacket.getHeaders(); final int expectHeaderIdx = headers.indexOf(Header.Expect, 0); return expectHeaderIdx != -1 && headers.getValue(expectHeaderIdx).equalsIgnoreCase("100-Continue") ? PayloadGenFactory.wrapWithExpect(payloadGenerator) : payloadGenerator; }
/** * Return an array of all the header names set for this response, or * a zero-length array if no headers have been set. */ public String[] getHeaderNames() { checkResponse(); MimeHeaders headers = response.getHeaders(); int n = headers.size(); String[] result = new String[n]; for (int i = 0; i < n; i++) { result[i] = headers.getName(i).toString(); } return result; }
@SuppressWarnings("unchecked") static Buffer encodeResponseHeaders(final Http2Session http2Session, final HttpResponsePacket response, final Map<String,String> capture) throws IOException { assert http2Session.getDeflaterLock().isLocked(); final MimeHeaders headers = response.getHeaders(); headers.removeHeader(Header.Connection); headers.removeHeader(Header.KeepAlive); headers.removeHeader(Header.ProxyConnection); headers.removeHeader(Header.TransferEncoding); headers.removeHeader(Header.Upgrade); final HeadersEncoder encoder = http2Session.getHeadersEncoder(); // encoder.encodeHeader(Constants.STATUS_HEADER_BYTES, // response.getHttpStatus().getStatusBytes(), false); encoder.encodeHeader(STATUS_HEADER, String.valueOf(response.getHttpStatus().getStatusCode()), capture); encodeUserHeaders(headers, encoder, capture); return encoder.flushHeaders(); }
private static void processNormalHeader(final HttpHeader httpHeader, final String name, final String value) { if (name.equals(Header.Host.getLowerCase())) { return; } final MimeHeaders mimeHeaders = httpHeader.getHeaders(); final DataChunk valueChunk = mimeHeaders.addValue(name); validateHeaderCharacters(name, value); valueChunk.setString(value); finalizeKnownHeader(httpHeader, name, value); }
private static void prepareRequest(final HttpRequestPacket request) { String contentType = request.getContentType(); if (contentType != null) { request.getHeaders().setValue(Header.ContentType).setString(contentType); } }
final HttpTransactionContext httpTransactionContext, final FilterChainContext ctx) { final List<String> authHeaders = listOf(responsePacket.getHeaders() .values(Header.WWWAuthenticate)); final Connection connection = ctx.getConnection(); responsePacket.setSkipRemainder(true); // ignore the remainder of the response if (responsePacket.getProcessingState().isKeepAlive()) { c = ctx.getConnection(); httpTransactionContext.reuseConnection(); } else {
protected void findNext() { next = null; for (; pos < size; pos++) { final DataChunk n1 = headers.getName(pos); if (n1.equalsIgnoreCase(name)) { next = headers.getValue(pos); break; } } pos++; }
public boolean applyDecoding(HttpHeader httpPacket) { final HttpResponsePacket httpResponse = (HttpResponsePacket) httpPacket; final DataChunk bc = httpResponse.getHeaders().getValue(Header.ContentEncoding); return bc != null && bc.indexOf("gzip", 0) != -1; }
private void setKeepAliveForHeader(final Header header, final HttpRequestPacket requestPacket) { final MimeHeaders headers = requestPacket.getHeaders(); // Assign Connection: ... if needed if (!headers.contains(header)) { if (requestPacket.getProcessingState().isKeepAlive()) { headers.addValue(header).setBytes(KEEP_ALIVE_VALUE.getByteArray()); } else if (Protocol.HTTP_1_1.equals(requestPacket.getProtocol())) { headers.addValue(header).setBytes(CLOSE_VALUE.getByteArray()); } // switch (requestPacket.getProtocol()) { // case HTTP_0_9: // case HTTP_1_0: // if (requestPacket.getProcessingState().isKeepAlive()) { // headers.addValue(header).setBytes(KEEP_ALIVE_VALUE.getByteArray()); // } // break; // case HTTP_1_1: // if (!requestPacket.getProcessingState().isKeepAlive()) { // headers.addValue(header).setBytes(CLOSE_VALUE.getByteArray()); // } // break; // } } }
/** * {@inheritDoc} */ @Override public void setHeader(final String name, final String value) { if (name == null || value == null || name.isEmpty()) { return; } if (handleSetSpecialHeaders(name, value)) return; headers.setValue(name).setString(value); }
public void removeHeader(final Header header) { for (int i = 0; i < count; i++) { if (headers[i].getName().equalsIgnoreCase(header.getBytes())) { removeHeader(i--); } } }
/** * Return the names of all headers received with this request. */ public Iterable<String> getHeaderNames() { return request.getHeaders().names(); }
/** * Return all of the values of the specified header, if any; otherwise, * return an empty enumeration. * * @param name Name of the requested header */ public Iterable<String> getHeaders(String name) { return request.getHeaders().values(name); }
@Override protected void onInitialLineEncoded(HttpHeader header, FilterChainContext ctx) { super.onInitialLineEncoded(header, ctx); if (!header.isCommitted()) { final HttpResponsePacket response = (HttpResponsePacket) header; if (response.getStatus() == Response.Status.NO_CONTENT.getStatusCode()) { response.getHeaders().setValue("Content-Length").setString("0"); response.getHeaders().setValue("Content-Type").setString(MediaType.TEXT_PLAIN); } } } }
/** * {@inheritDoc} */ @Override public boolean containsHeader(final Header header) { if (header == null) { return false; } final String result = handleGetSpecialHeader(header); return result != null || headers.getHeader(header) != null; }
private void initializeHeaders() { this.headers = new CaseInsensitiveMultiMap(!PRESERVE_HEADER_CASE); for (String grizzlyHeaderName : requestPacket.getHeaders().names()) { final Iterable<String> headerValues = requestPacket.getHeaders().values(grizzlyHeaderName); for (String headerValue : headerValues) { this.headers.put(grizzlyHeaderName, headerValue); } } this.headers = this.headers.toImmutableMultiMap(); }