protected boolean onHttpPacketParsed(final HttpHeader httpHeader, final FilterChainContext ctx) { final Connection connection = ctx.getConnection(); if (httpHeader.isSkipRemainder()) { cleanup(httpHeader.getProcessingState().getHttpContext()); return result; HttpTransactionContext.currentTransaction(httpHeader); if (context.establishingTunnel && HttpStatus.OK_200.statusMatches( ((HttpResponsePacket) httpHeader).getStatus())) { context.establishingTunnel = false; context.tunnelEstablished(connection); cleanup(httpHeader.getProcessingState().getHttpContext()); final AsyncHandler handler = context.getAsyncHandler(); if (handler != null) {
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; }
final HttpTransactionContext httpTransactionContext, final FilterChainContext ctx) { final String redirectURL = responsePacket.getHeader(Header.Location); if (redirectURL == null) { throw new IllegalStateException("redirect received, but no location header was present"); responsePacket.setSkipRemainder(true); // ignore the remainder of the response if (responsePacket.getProcessingState().isKeepAlive() && isSameHostAndProtocol(origUri, redirectUri)) { c = ctx.getConnection(); httpTransactionContext.reuseConnection(); } else {
boolean isGracefullyFinishResponseOnClose() { final HttpResponsePacket response = responsePacket; return response != null && !response.getProcessingState().isKeepAlive() && !response.isChunked() && response.getContentLength() == -1; }
return ctx.getInvokeAction(); final Connection connection = ctx.getConnection(); Http2State http2State = Http2State.get(connection); return ctx.getInvokeAction(); final HttpContent httpContent = ctx.getMessage(); final HttpHeader httpHeader = httpContent.getHttpHeader(); assert !httpHeader.isRequest(); final HttpRequestPacket httpRequest = httpResponse.getRequest(); obtainHttp2Session(http2State, ctx, true); final Buffer framePayload = httpContent.getContent(); httpContent.recycle();
@Override public void write(WebSocketResponse response) { if (ctx == null) { throw new UnsupportedOperationException("not supported on client side"); } final HttpResponsePacket responsePacket = ((HttpRequestPacket) httpContent.getHttpHeader()).getResponse(); responsePacket.setProtocol(Protocol.HTTP_1_1); responsePacket.setStatus(response.getStatus()); for (Map.Entry<String, String> entry : response.getHeaders().entrySet()) { responsePacket.setHeader(entry.getKey(), entry.getValue()); } ctx.write(HttpContent.builder(responsePacket).build()); }
final Connection connection = ctx.getConnection(); HttpResponsePacket httpResponse = httpResponseInProcessAttr.get(connection); final HttpRequestPacket request = httpResponse.getRequest(); httpCtx = request.getProcessingState().getHttpContext(); if (httpCtx == null) { httpCtx = HttpContext.newInstance(connection, connection, connection, request); request.getProcessingState().setHttpContext(httpCtx); httpCtx = HttpContext.newInstance(connection, connection, connection, null); httpCtx.attach(ctx); return handleRead(ctx, httpResponse);
public void respond(final FilterChainContext ctx, final WebSocketApplication application, final HttpResponsePacket response) { response.setProtocol(Protocol.HTTP_1_1); response.setStatus(HttpStatus.SWITCHING_PROTOCOLS_101); response.setHeader("Upgrade", "websocket"); response.setHeader("Connection", "Upgrade"); setHeaders(response); if (!getSubProtocol().isEmpty()) { response.setHeader(Constants.SEC_WS_PROTOCOL_HEADER, join(application.getSupportedProtocols(getSubProtocol()))); } if (!application.getSupportedExtensions().isEmpty() && !getExtensions().isEmpty()) { List<Extension> intersection = intersection(getExtensions(), application.getSupportedExtensions()); if (!intersection.isEmpty()) { application.onExtensionNegotiation(intersection); response.setHeader(Constants.SEC_WS_EXTENSIONS_HEADER, joinExtensions(intersection)); } } ctx.write(HttpContent.builder(response).build()); }
private void commitAndCloseAsError(FilterChainContext ctx, HttpResponsePacket response) { final HttpContent errorHttpResponse = customizeErrorResponse(response); final Buffer resBuf = encodeHttpPacket(ctx, errorHttpResponse); ctx.write(resBuf); response.getProcessingState().getHttpContext().close(); }
/** * 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; }
final FilterChainContext ctx) { final List<String> proxyAuthHeaders = listOf(responsePacket.getHeaders() .values(Header.ProxyAuthenticate)); newRealm = ntlmProxyChallenge(ctx.getConnection(), ntlmAuthenticate, req, proxyServer); responsePacket.setSkipRemainder(true); // ignore the remainder of the response if (responsePacket.getProcessingState().isKeepAlive()) { c = ctx.getConnection(); httpTransactionContext.reuseConnection(); } else {
@Override public NextAction handleEvent(final FilterChainContext ctx, final FilterChainEvent event) throws IOException { if (event.type() == GracefulCloseEvent.class) { // Connection was closed. // This event is fired only for responses, which don't have // associated transfer-encoding or content-length. // We have to complete such a request-response processing gracefully. final GracefulCloseEvent closeEvent = (GracefulCloseEvent) event; final HttpResponsePacket response = closeEvent.getHttpTxContext().responsePacket; response.getProcessingState().getHttpContext().attach(ctx); onHttpPacketParsed(response, ctx); return ctx.getStopAction(); } return ctx.getInvokeAction(); }
private void writeHttpResponse(FilterChainContext ctx, int status) { HttpResponsePacket responsePacket = getHttpRequest(ctx).getResponse(); responsePacket.setProtocol(Protocol.HTTP_1_1); responsePacket.setStatus(status); ctx.write(HttpContent.builder(responsePacket).build()); }
@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 boolean isHeadRequest(final HttpHeader header) { final HttpRequestPacket request = header.isRequest() ? (HttpRequestPacket) header : ((HttpResponsePacket) header).getRequest(); return request.isHeadRequest(); }
/** * Send the next part of the response * * @throws java.io.IOException */ public void sendResponse() throws IOException { if (!contentSend) { contentSend = true; isDone = httpResponsePacket.getRequest().getMethod().equals(HEAD) || !httpResponsePacket.isChunked(); ctx.write(httpResponseContent, this); return; } isDone = true; ctx.write(httpResponsePacket.httpTrailerBuilder().build(), this); }
@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); } } } }
private static WebSocketResponse getWebSocketResponse(HttpResponsePacket httpResponsePacket) { WebSocketResponse webSocketResponse = new WebSocketResponse(); for (String name : httpResponsePacket.getHeaders().names()) { webSocketResponse.getHeaders().put(name, httpResponsePacket.getHeader(name)); } webSocketResponse.setStatus(httpResponsePacket.getStatus()); return webSocketResponse; }
private static HttpResponsePacket composeHandshakeError(final HttpRequestPacket request, final HandshakeException e) { final HttpResponsePacket response = request.getResponse(); response.setStatus(e.getCode()); response.setReasonPhrase(e.getMessage()); return response; } }
/** * Return the content length that was set or calculated for this Response. */ public int getContentLength() { checkResponse(); return (int) response.getContentLength(); }