/** * Returns true if the server switched to a different protocol than HTTP/1.0 or HTTP/1.1, e.g. HTTP/2 or Websocket. * Returns false if the upgrade happened in a different layer, e.g. upgrade from HTTP/1.1 to HTTP/1.1 over TLS. */ protected boolean isSwitchingToNonHttp1Protocol(HttpResponse msg) { if (msg.status().code() != HttpResponseStatus.SWITCHING_PROTOCOLS.code()) { return false; } String newProtocol = msg.headers().get(HttpHeaderNames.UPGRADE); return newProtocol == null || !newProtocol.contains(HttpVersion.HTTP_1_0.text()) && !newProtocol.contains(HttpVersion.HTTP_1_1.text()); }
@Override public boolean equals(Object o) { if (!(o instanceof DefaultHttpMessage)) { return false; } DefaultHttpMessage other = (DefaultHttpMessage) o; return headers().equals(other.headers()) && protocolVersion().equals(other.protocolVersion()) && super.equals(o); }
@Override public boolean equals(Object o) { if (!(o instanceof HttpVersion)) { return false; } HttpVersion that = (HttpVersion) o; return minorVersion() == that.minorVersion() && majorVersion() == that.majorVersion() && protocolName().equals(that.protocolName()); }
private org.apache.http.HttpVersion createVersion(final FullHttpRequest request) { HttpVersion protocolVersion = request.protocolVersion(); return new org.apache.http.HttpVersion(protocolVersion.majorVersion(), protocolVersion.minorVersion()); }
HttpMethod method = HttpMethod.valueOf(headers.getAsString(METHOD)); String url = headers.getAsString(PATH); HttpVersion httpVersion = HttpVersion.valueOf(headers.getAsString(VERSION)); headers.remove(METHOD); headers.remove(PATH); req.headers().set(HttpHeaderNames.HOST, host); req.headers().add(e.getKey(), e.getValue()); req.headers().remove(HttpHeaderNames.TRANSFER_ENCODING); release = false; return req; } finally { if (release) { buffer.release();
private static void writeResponse(final Channel channel, final HttpRequest request, final FullHttpResponse response) { response.headers().set(CONTENT_LENGTH, response.content().readableBytes()); boolean hasKeepAliveHeader = HttpHeaders.equalsIgnoreCase(KEEP_ALIVE, request.headers().get(CONNECTION)); if (!request.getProtocolVersion().isKeepAliveDefault() && hasKeepAliveHeader) { response.headers().set(CONNECTION, KEEP_ALIVE); } final ChannelFuture wf = channel.writeAndFlush(response); if (!HttpHeaders.isKeepAlive(request)) { wf.addListener(ChannelFutureListener.CLOSE); } }
protected void logResponseFirstChunk(HttpResponse response, ChannelHandlerContext ctx) { if (logger.isDebugEnabled()) { StringBuilder headers = new StringBuilder(); for (String headerName : response.headers().names()) { if (headers.length() > 0) headers.append(", "); headers.append(headerName).append("=\"") .append(String.join(",", response.headers().getAll(headerName))).append("\""); } StringBuilder sb = new StringBuilder(); sb.append("SENDING RESPONSE:"); sb.append("\n\tHTTP STATUS: ").append(response.status().code()); sb.append("\n\tHEADERS: ").append(headers.toString()); sb.append("\n\tPROTOCOL: ").append(response.protocolVersion().text()); if (response instanceof HttpContent) { HttpContent chunk = (HttpContent) response; sb.append("\n\tCONTENT CHUNK: ").append(chunk.getClass().getName()).append(", size: ") .append(chunk.content().readableBytes()); } runnableWithTracingAndMdc(() -> logger.debug(sb.toString()), ctx).run(); } }
@Override protected void encodeInitialLine(final ByteBuf buf, final HttpMessage message) throws Exception { if (message instanceof HttpRequest) { HttpRequest request = (HttpRequest) message; ByteBufUtil.copy(request.method().asciiName(), buf); buf.writeByte(SP); buf.writeCharSequence(request.uri(), CharsetUtil.UTF_8); buf.writeByte(SP); buf.writeCharSequence(request.protocolVersion().toString(), CharsetUtil.US_ASCII); ByteBufUtil.writeShortBE(buf, CRLF_SHORT); } else if (message instanceof HttpResponse) { HttpResponse response = (HttpResponse) message; buf.writeCharSequence(response.protocolVersion().toString(), CharsetUtil.US_ASCII); buf.writeByte(SP); ByteBufUtil.copy(response.status().codeAsText(), buf); buf.writeByte(SP); buf.writeCharSequence(response.status().reasonPhrase(), CharsetUtil.US_ASCII); ByteBufUtil.writeShortBE(buf, CRLF_SHORT); } else { throw new UnsupportedMessageTypeException("Unsupported type " + StringUtil.simpleClassName(message)); } } }
final String inboundProtocol = zuulRequest.getProtocol(); if (inboundProtocol.startsWith("HTTP/1")) { responseHttpVersion = HttpVersion.valueOf(inboundProtocol); HttpResponseStatus.valueOf(zuulResp.getStatus()), false, false); nativeHeaders.add(entry.getKey(), entry.getValue()); nativeResponse.headers().add(HttpHeaderNames.TRANSFER_ENCODING, HttpHeaderValues.CHUNKED); } else { nativeResponse.headers().set("Connection", "close"); if (nativeReq.headers().contains(HttpConversionUtil.ExtensionHeaderNames.STREAM_ID.text())) { String streamId = nativeReq.headers().get(HttpConversionUtil.ExtensionHeaderNames.STREAM_ID.text()); nativeResponse.headers().set(HttpConversionUtil.ExtensionHeaderNames.STREAM_ID.text(), streamId);
private void writeResponse(Channel channel, HttpResponseStatus statusCode) { // Convert the response content to a ChannelBuffer. ByteBuf buf = copiedBuffer(responseContent.toString(), CharsetUtil.UTF_8); responseContent.setLength(0); // Decide whether to close the connection or not. boolean close = HttpHeaders.Values.CLOSE.equalsIgnoreCase(request.headers().get(CONNECTION)) || request.getProtocolVersion().equals(HttpVersion.HTTP_1_0) && !HttpHeaders.Values.KEEP_ALIVE.equalsIgnoreCase(request.headers().get(CONNECTION)); // Build the response object. FullHttpResponse response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, statusCode, buf); response.headers().set(CONTENT_TYPE, "text/plain; charset=UTF-8"); if (!close) { // There's no need to add 'Content-Length' header if this is the last response. response.headers().set(CONTENT_LENGTH, buf.readableBytes()); } // Write the response. ChannelFuture future = channel.writeAndFlush(response); // Close the connection after the write operation is done if necessary. if (close) { future.addListener(ChannelFutureListener.CLOSE); } }
HttpResponseStatus status = HttpResponseStatus.parseLine(headers.get(STATUS)); HttpVersion version = HttpVersion.valueOf(headers.getAsString(VERSION)); headers.remove(STATUS); headers.remove(VERSION); FullHttpResponse res = new DefaultFullHttpResponse(version, status, buffer, validateHeaders); for (Map.Entry<CharSequence, CharSequence> e: responseFrame.headers()) { res.headers().add(e.getKey(), e.getValue()); res.headers().remove(HttpHeaderNames.TRANSFER_ENCODING); res.headers().remove(HttpHeaderNames.TRAILER); } finally { if (release) { buffer.release();
private HttpResponse setupNormalResponse(final org.apache.http.HttpResponse remoteResponse) throws IOException { HttpVersion httpVersion = HttpVersion.valueOf(remoteResponse.getProtocolVersion().toString()); HttpResponseStatus status = HttpResponseStatus.valueOf(remoteResponse.getStatusLine().getStatusCode()); FullHttpResponse response = new DefaultFullHttpResponse(httpVersion, status); response.setStatus(status); Header[] allHeaders = remoteResponse.getAllHeaders(); for (Header header : allHeaders) { if (isResponseHeader(header)) { response.headers().set(header.getName(), header.getValue()); } } HttpEntity entity = remoteResponse.getEntity(); if (entity != null) { byte[] content = toByteArray(entity); if (content.length > 0) { ByteBuf buffer = Unpooled.copiedBuffer(content); response.content().writeBytes(buffer); } } return newResponse(response); }
public FullHttpResponse toFullResponse() { FullHttpResponse response = new DefaultFullHttpResponse(HttpVersion.valueOf(this.version.text()), HttpResponseStatus.valueOf(this.status)); for (Map.Entry<String, String[]> entry : getHeaders().entrySet()) { String key = entry.getKey(); for (String value : entry.getValue()) { response.headers().add(key, value); } } if (this.content != null) { response.content().writeBytes(this.content.getContent()); } return response; } }
@SuppressWarnings("deprecation") private SpdySynStreamFrame createSynStreamFrame(HttpRequest httpRequest) throws Exception { final HttpHeaders httpHeaders = httpRequest.headers(); int streamId = httpHeaders.getInt(SpdyHttpHeaders.Names.STREAM_ID); int associatedToStreamId = httpHeaders.getInt(SpdyHttpHeaders.Names.ASSOCIATED_TO_STREAM_ID, 0); byte priority = (byte) httpHeaders.getInt(SpdyHttpHeaders.Names.PRIORITY, 0); CharSequence scheme = httpHeaders.get(SpdyHttpHeaders.Names.SCHEME); httpHeaders.remove(SpdyHttpHeaders.Names.STREAM_ID); frameHeaders.set(SpdyHeaders.HttpNames.METHOD, httpRequest.method().name()); frameHeaders.set(SpdyHeaders.HttpNames.PATH, httpRequest.uri()); frameHeaders.set(SpdyHeaders.HttpNames.VERSION, httpRequest.protocolVersion().text());
public FullHttpRequest toFullHttpRequest() { ByteBuf buffer = Unpooled.buffer(); MessageContent content = getContent(); if (content != null) { buffer.writeBytes(content.getContent()); } QueryStringEncoder encoder = new QueryStringEncoder(uri); for (Map.Entry<String, String[]> entry : queries.entrySet()) { String[] values = entry.getValue(); for (String value : values) { encoder.addParam(entry.getKey(), value); } } FullHttpRequest request = new DefaultFullHttpRequest(HttpVersion.valueOf(getVersion().text()), io.netty.handler.codec.http.HttpMethod.valueOf(method.name()), encoder.toString(), buffer); for (Map.Entry<String, String[]> entry : getHeaders().entrySet()) { String key = entry.getKey(); for (String value : entry.getValue()) { request.headers().add(key, value); } } return request; }
public void init(String remoteAddress) { this.remoteAddress = remoteAddress.substring(1); this.keepAlive = HttpUtil.isKeepAlive(nettyRequest); this.url = nettyRequest.uri(); this.protocol = nettyRequest.protocolVersion().text(); this.method = nettyRequest.method().name(); byteBuffs.add(content.content().copy());
protected HttpResponse createResponse(final String contentType) { final HttpVersion version = request.getProtocolVersion(); final HttpResponse response = new DefaultHttpResponse(version, HttpResponseStatus.OK); if (request.getProtocolVersion().equals(HttpVersion.HTTP_1_1)) { response.headers().set(TRANSFER_ENCODING, HttpHeaders.Values.CHUNKED); } response.headers().set(CONTENT_TYPE, contentType); Transports.setDefaultHeaders(response, config); return response; }
protected void captureRequestHeaderSize(HttpRequest httpRequest) { String requestLine = httpRequest.getMethod().toString() + ' ' + httpRequest.getUri() + ' ' + httpRequest.getProtocolVersion().toString(); // +2 => CRLF after status line, +4 => header/data separation long requestHeadersSize = requestLine.length() + 6; HttpHeaders headers = httpRequest.headers(); requestHeadersSize += BrowserMobHttpUtil.getHeaderSize(headers); harEntry.getRequest().setHeadersSize(requestHeadersSize); }
protected void captureResponse(HttpResponse httpResponse) { HarResponse response = new HarResponse(httpResponse.getStatus().code(), httpResponse.getStatus().reasonPhrase(), httpResponse.getProtocolVersion().text()); harEntry.setResponse(response); captureResponseHeaderSize(httpResponse); captureResponseMimeType(httpResponse); if (dataToCapture.contains(CaptureType.RESPONSE_COOKIES)) { captureResponseCookies(httpResponse); } if (dataToCapture.contains(CaptureType.RESPONSE_HEADERS)) { captureResponseHeaders(httpResponse); } if (BrowserMobHttpUtil.isRedirect(httpResponse)) { captureRedirectUrl(httpResponse); } }
protected void captureResponseHeaderSize(HttpResponse httpResponse) { String statusLine = httpResponse.getProtocolVersion().toString() + ' ' + httpResponse.getStatus().toString(); // +2 => CRLF after status line, +4 => header/data separation long responseHeadersSize = statusLine.length() + 6; HttpHeaders headers = httpResponse.headers(); responseHeadersSize += BrowserMobHttpUtil.getHeaderSize(headers); harEntry.getResponse().setHeadersSize(responseHeadersSize); }