String key = WebSocketUtil.base64(ChannelBuffers.wrappedBuffer(nonce)); ChannelBuffer sha1 = WebSocketUtil.sha1(ChannelBuffers.copiedBuffer(acceptSeed, CharsetUtil.US_ASCII)); expectedChallengeResponseString = WebSocketUtil.base64(sha1); request.headers().add(Names.UPGRADE, Values.WEBSOCKET.toLowerCase()); request.headers().add(Names.CONNECTION, Values.UPGRADE); request.headers().add(Names.SEC_WEBSOCKET_KEY, key); request.headers().add(Names.HOST, wsURL.getHost()); request.headers().add(Names.SEC_WEBSOCKET_ORIGIN, originValue); request.headers().add(Names.SEC_WEBSOCKET_PROTOCOL, expectedSubprotocol); request.headers().add(Names.SEC_WEBSOCKET_VERSION, "7"); request.headers().add(e.getKey(), e.getValue()); ChannelFuture future = channel.write(request); future.addListener(new ChannelFutureListener() {
if (!Values.UPGRADE.equalsIgnoreCase(req.headers().get(CONNECTION)) || !WEBSOCKET.equalsIgnoreCase(req.headers().get(Names.UPGRADE))) { throw new WebSocketHandshakeException("not a WebSocket handshake request: missing upgrade"); boolean isHixie76 = req.headers().contains(SEC_WEBSOCKET_KEY1) && req.headers().contains(SEC_WEBSOCKET_KEY2); HttpResponse res = new DefaultHttpResponse(HTTP_1_1, new HttpResponseStatus(101, isHixie76 ? "WebSocket Protocol Handshake" : "Web Socket Protocol Handshake")); res.headers().add(Names.UPGRADE, WEBSOCKET); res.headers().add(CONNECTION, Values.UPGRADE); res.headers().add(SEC_WEBSOCKET_ORIGIN, req.headers().get(ORIGIN)); res.headers().add(SEC_WEBSOCKET_LOCATION, getWebSocketUrl()); String subprotocols = req.headers().get(SEC_WEBSOCKET_PROTOCOL); if (subprotocols != null) { String selectedSubprotocol = selectSubprotocol(subprotocols); throw new WebSocketHandshakeException("Requested subprotocol(s) not supported: " + subprotocols); } else { res.headers().add(SEC_WEBSOCKET_PROTOCOL, selectedSubprotocol); setSelectedSubprotocol(selectedSubprotocol); String key1 = req.headers().get(SEC_WEBSOCKET_KEY1); String key2 = req.headers().get(SEC_WEBSOCKET_KEY2); int a = (int) (Long.parseLong(key1.replaceAll("[^0-9]", "")) / key1.replaceAll("[^ ]", "").length()); int b = (int) (Long.parseLong(key2.replaceAll("[^0-9]", "")) / key2.replaceAll("[^ ]", "").length()); long c = req.getContent().readLong(); ChannelBuffer input = ChannelBuffers.buffer(16); input.writeInt(a);
private static void sendHttpResponse(ChannelHandlerContext ctx, HttpRequest req, HttpResponse res) { ChannelFuture f = ctx.getChannel().write(res); if (!isKeepAlive(req) || res.getStatus().getCode() != 200) { f.addListener(ChannelFutureListener.CLOSE); } }
/** * Check if the given request is a multipart request * * @return True if the request is a Multipart request */ public static boolean isMultipart(HttpRequest request) throws ErrorDataDecoderException { if (request.headers().contains(HttpHeaders.Names.CONTENT_TYPE)) { return getMultipartDataBoundary(request.headers().get(HttpHeaders.Names.CONTENT_TYPE)) != null; } else { return false; } }
/** * Cleans the current header entries and copies all header entries of the specified {@code headers}. * * @return {@code this} */ public HttpHeaders set(HttpHeaders headers) { if (headers == null) { throw new NullPointerException("headers"); } clear(); for (Map.Entry<String, String> e: headers) { add(e.getKey(), e.getValue()); } return this; }
public static void removeTransferEncodingChunked(HttpMessage m) { List<String> values = m.headers().getAll(Names.TRANSFER_ENCODING); if (values.isEmpty()) { return; } Iterator<String> valuesIt = values.iterator(); while (valuesIt.hasNext()) { String value = valuesIt.next(); if (value.equalsIgnoreCase(Values.CHUNKED)) { valuesIt.remove(); } } if (values.isEmpty()) { m.headers().remove(Names.TRANSFER_ENCODING); } else { m.headers().set(Names.TRANSFER_ENCODING, values); } }
private void sendHttpResponse(ChannelHandlerContext ctx, HttpRequest req, HttpResponse res) { // Generate an error page if response status code is not OK (200). if (res.getStatus().getCode() != 200) { res.setContent( ChannelBuffers.copiedBuffer( res.getStatus().toString(), CharsetUtil.UTF_8)); HttpHeaders.setContentLength(res, res.getContent().readableBytes()); } // Send the response and close the connection if necessary. ChannelFuture f = ctx.getChannel().write(res); if (!HttpHeaders.isKeepAlive(req) || res.getStatus().getCode() != 200) { f.addListener(ChannelFutureListener.CLOSE); } }
final String hostKey = getPoolKey(url); final ResourceContainer<ChannelFuture> channelResourceContainer = pool.take(hostKey); final ChannelFuture channelFuture = channelResourceContainer.get().awaitUninterruptibly(); if (!channelFuture.isSuccess()) { channelFuture.getCause() channel.setReadable(true); httpRequest.headers().add(HttpHeaders.Names.HOST, getHost(url)); httpRequest.headers().set(HttpHeaders.Names.ACCEPT_ENCODING, compressionCodec.getEncodingString()); httpRequest.headers().add(key, obj); channel.getPipeline().addLast( READ_TIMEOUT_HANDLER_NAME, new ReadTimeoutHandler(timer, readTimeout, TimeUnit.MILLISECONDS) channel.getPipeline().addLast( LAST_HANDLER_NAME, new SimpleChannelUpstreamHandler()
private void _write(String message) { if(!this.open) return; HttpResponse res = new DefaultHttpResponse(HTTP_1_1, HttpResponseStatus.OK); res.addHeader(CONTENT_TYPE, "text/plain; charset=UTF-8"); res.addHeader("Access-Control-Allow-Origin", "*"); res.addHeader("Access-Control-Allow-Credentials", "true"); res.addHeader("Connection", "keep-alive"); res.setContent(ChannelBuffers.copiedBuffer(message, CharsetUtil.UTF_8)); setContentLength(res, res.getContent().readableBytes()); // Send the response and close the connection if necessary. Channel chan = ctx.getChannel(); if(chan.isOpen()) { ChannelFuture f = chan.write(res); if (!isKeepAlive(req) || res.getStatus().getCode() != 200) { f.addListener(ChannelFutureListener.CLOSE); } } this.connected = false; }
protected void sendError(ChannelHandlerContext ctx, String message, HttpResponseStatus status) { HttpResponse response = new DefaultHttpResponse(HTTP_1_1, status); response.headers().add(CONTENT_TYPE, "text/plain; charset=UTF-8"); // Put shuffle version into http header response.headers().add(ShuffleHeader.HTTP_HEADER_NAME, ShuffleHeader.DEFAULT_HTTP_HEADER_NAME); response.headers().add(ShuffleHeader.HTTP_HEADER_VERSION, ShuffleHeader.DEFAULT_HTTP_HEADER_VERSION); response.setContent( ChannelBuffers.copiedBuffer(message, CharsetUtil.UTF_8)); // Close the connection as soon as the error message is sent. ctx.getChannel().write(response).addListener(ChannelFutureListener.CLOSE); }
private void handleMetaRequest(ChannelHandlerContext ctx, HttpRequest request, final PullServerParams params) throws IOException, ExecutionException { final List<String> jsonMetas; try { jsonMetas = PullServerUtil.getJsonMeta(conf, lDirAlloc, localFS, params, gson, indexReaderCache, lowCacheHitCheckThreshold); } catch (FileNotFoundException e) { sendError(ctx, e.getMessage(), HttpResponseStatus.NO_CONTENT); return; } catch (IOException | IllegalArgumentException e) { // IOException, EOFException, IllegalArgumentException sendError(ctx, e.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } catch (ExecutionException e) { // There are some problems in index cache throw new TajoInternalError(e.getCause()); } HttpResponse response = new DefaultHttpResponse(HTTP_1_1, HttpResponseStatus.OK); response.setContent(ChannelBuffers.copiedBuffer(gson.toJson(jsonMetas), CharsetUtil.UTF_8)); response.setHeader(Names.CONTENT_TYPE, "application/json; charset=UTF-8"); HttpHeaders.setContentLength(response, response.getContent().readableBytes()); if (HttpHeaders.isKeepAlive(request)) { response.setHeader(Names.CONNECTION, Values.KEEP_ALIVE); } ChannelFuture writeFuture = ctx.getChannel().write(response); // Decide whether to close the connection or not. if (!HttpHeaders.isKeepAlive(request)) { // Close the connection when the whole content is written out. writeFuture.addListener(ChannelFutureListener.CLOSE); } }
m.headers().add(Names.TRANSFER_ENCODING, Values.CHUNKED); ChannelBuffer header = dynamicBuffer( channel.getConfig().getBufferFactory()); encodeInitialLine(header, m); encodeHeaders(header, m); header.writeByte(CR); header.writeByte(LF); if (!content.readable()) { return header; // no content } else if (contentMustBeEmpty) { "if Transfer-Encoding is chunked."); } else { return wrappedBuffer(header, content); transferEncodingChunked = false; if (chunk instanceof HttpChunkTrailer) { ChannelBuffer trailer = dynamicBuffer( channel.getConfig().getBufferFactory()); trailer.writeByte((byte) '0'); trailer.writeByte(CR);
HttpHeaders headers = httpChildConfig.getWriteHeaders(); HttpResponse httpResponse = new DefaultHttpResponse(version, status); if (headers != null) { httpResponse.headers().add(headers); else if (isTransferEncodingChunked(httpResponse)) { httpResponse.setChunked(true); ChannelFuture future = transport.write(httpResponse); httpChildChannel.writeState(CONTENT_CHUNKED); chainFutures(future, httpFuture); else if (httpResponse.headers().getAll(Names.CONNECTION).contains(Values.CLOSE)) { break; default: setContentLength(httpResponse, 0); break; int httpReadableBytes = httpBufferedContent.readableBytes(); setContentLength(httpBufferedResponse, httpReadableBytes); case CONTENT_COMPLETE: case UPGRADED: httpFuture.setSuccess(); break; default:
/** * Sends an HTTP reply to the client. * * @param status The status of the request (e.g. 200 OK or 404 Not Found). * @param buf The content of the reply to send. */ private void sendBuffer(final HttpResponseStatus status, final ChannelBuffer buf) { if (!chan.isConnected()) { done(); return; } final DefaultHttpResponse response = new DefaultHttpResponse(HttpVersion.HTTP_1_1, status); response.setHeader(HttpHeaders.Names.CONTENT_TYPE, guessMimeType(buf)); // TODO(tsuna): Server, X-Backend, etc. headers. response.setContent(buf); final boolean keepalive = HttpHeaders.isKeepAlive(request); if (keepalive) { HttpHeaders.setContentLength(response, buf.readableBytes()); } final ChannelFuture future = chan.write(response); if (!keepalive) { future.addListener(ChannelFutureListener.CLOSE); } done(); }
throws Exception { HttpRequest request = (HttpRequest) evt.getMessage(); if (request.getMethod() != GET) { sendError(ctx, METHOD_NOT_ALLOWED); return; request.headers().get(ShuffleHeader.HTTP_HEADER_NAME)) || !ShuffleHeader.DEFAULT_HTTP_HEADER_VERSION.equals( request.headers().get(ShuffleHeader.HTTP_HEADER_VERSION))) { sendError(ctx, "Incompatible shuffle request version", BAD_REQUEST); return; HttpResponse response = new DefaultHttpResponse(HTTP_1_1, OK); try { verifyRequest(jobId, ctx, request, response, ChannelPipeline pipeline = ch.getPipeline(); TimeoutHandler timeoutHandler = (TimeoutHandler)pipeline.get(TIMEOUT_HANDLER); timeoutHandler.setEnabledTimeout(false); return; ch.write(response);
System.arraycopy(number2Array, 0, challenge, 4, 4); System.arraycopy(key3, 0, challenge, 8, 8); expectedChallengeResponseBytes = WebSocketUtil.md5(ChannelBuffers.wrappedBuffer(challenge)); request.headers().add(Names.UPGRADE, Values.WEBSOCKET); request.headers().add(Names.CONNECTION, Values.UPGRADE); request.headers().add(Names.HOST, wsURL.getHost()); request.headers().add(Names.ORIGIN, originValue); request.headers().add(Names.SEC_WEBSOCKET_KEY1, key1); request.headers().add(Names.SEC_WEBSOCKET_KEY2, key2); String expectedSubprotocol = getExpectedSubprotocol(); if (expectedSubprotocol != null && expectedSubprotocol.length() != 0) { request.headers().add(Names.SEC_WEBSOCKET_PROTOCOL, expectedSubprotocol); request.headers().add(e.getKey(), e.getValue()); request.headers().set(Names.CONTENT_LENGTH, key3.length); request.setContent(ChannelBuffers.copiedBuffer(key3)); ChannelFuture future = channel.write(request); future.addListener(new ChannelFutureListener() { public void operationComplete(ChannelFuture future) { ChannelPipeline p = future.getChannel().getPipeline();
@Override public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception { Object msg = e.getMessage(); if (msg instanceof HttpResponse && ((HttpResponse) msg).getStatus().getCode() == 100) { String contentEncoding = m.headers().get(HttpHeaders.Names.CONTENT_ENCODING); if (contentEncoding != null) { contentEncoding = contentEncoding.trim(); boolean hasContent = m.isChunked() || m.getContent().readable(); if (hasContent && (decoder = newContentDecoder(contentEncoding)) != null) { m.headers().remove(HttpHeaders.Names.CONTENT_ENCODING); } else { m.headers().set(HttpHeaders.Names.CONTENT_ENCODING, targetContentEncoding); ChannelBuffer content = m.getContent(); content = ChannelBuffers.wrappedBuffer( decode(content), finishDecode()); if (m.headers().contains(HttpHeaders.Names.CONTENT_LENGTH)) { m.headers().set( HttpHeaders.Names.CONTENT_LENGTH, Integer.toString(content.readableBytes()));
/** Handle conditional connection close depending on keep-alive */ private void writeResponse(Channel channel, HttpRequest request, HttpResponse response) { response.setHeader(CONTENT_LENGTH, response.getContent().readableBytes()); boolean hasKeepAliveHeader = KEEP_ALIVE.equalsIgnoreCase(request.getHeader(CONNECTION)); if (!request.getProtocolVersion().isKeepAliveDefault() && hasKeepAliveHeader) { response.setHeader(CONNECTION, KEEP_ALIVE); } ChannelFuture wf = channel.write(response); if (!HttpHeaders.isKeepAlive(request)) { wf.addListener(ChannelFutureListener.CLOSE); } }
@Override public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception { HttpRequest request = (HttpRequest) e.getMessage(); if (request.getMethod() != GET) { sendError(ctx, METHOD_NOT_ALLOWED); return; String uri = request.getUri(); if (stripFromUri != null) { uri = uri.replaceFirst(stripFromUri, ""); response.setRequestUri(request.getUri()); response.setCacheMaxAge(cacheMaxAge); response.setHeader(HttpHeaders.Names.CONTENT_TYPE, contentType); setContentLength(response, content.readableBytes()); ChannelFuture writeFuture = e.getChannel().write(response); if (!isKeepAlive(request)) { writeFuture.addListener(ChannelFutureListener.CLOSE);
private void writeResponse(HttpRequest request, HttpResponse response, Channel channel) { boolean keepAlive = isKeepAlive(request); if (keepAlive) { response.setHeader(CONTENT_LENGTH, response.getContent().readableBytes()); response.setHeader(CONNECTION, HttpHeaders.Values.KEEP_ALIVE); } ChannelFuture future = channel.write(response); if (!keepAlive) { future.addListener(ChannelFutureListener.CLOSE); } } }