/** * @param request * @return * @throws IOException * @throws HttpExecuteException * @throws MalformedURLException */ private HttpResponse executeRequest(HttpRequest request) throws IOException { if (request.shouldIgnoreResponse()) return new HttpResponse(); if (!request.hasHeader("Host")) throw new HttpExecuteException("HTTP Host not set"); String host = request.getHeader("Host").get(0); URL url = new URL("http", host, 80, request.getPath()); HttpURLConnection connection = (HttpURLConnection) url.openConnection(); connection.setRequestMethod(request.getMethod()); for (Entry<String, List<String>> entry : request.getHeaderPairs().entrySet()) { for (String value : entry.getValue()) connection.addRequestProperty(entry.getKey(), value); } if (request.getMethod().equals("POST")) { // Write post data if it exists connection.getOutputStream().write(request.getContent()); } HttpResponse response = new HttpResponse(); response.setResponseCode(connection.getResponseCode()); response.setResponseMessage(connection.getResponseMessage()); for (Entry<String, List<String>> entry : connection.getHeaderFields().entrySet()) { for (String value : entry.getValue()) response.addHeader(entry.getKey(), value); } // responseType is eg. the 4 in 403 int responseType = response.getResponseCode() / 100; if (responseType == 4 || responseType == 5) response.readAllContent(connection.getErrorStream()); else response.readAllContent(connection.getInputStream()); // Add Network Spoofer fingerprint response.addHeader("X-Network-Spoofer", "ON"); return response; }
protected HttpResponse newHttpResponse(HttpMessageBuffer msg, HttpResponseException e) { HttpResponse httpRsp = e.toHttpResponse(msg.getHttpVersionString()); if (msg.getHttpVersion() > 1.0) { httpRsp.addHeader(HttpConstants.Headers.HOST, this.headerHostValue); } httpRsp.addHeader(HttpConstants.Headers.SERVER, this.getServerName()); httpRsp.addHeader(HttpConstants.Headers.CONNECTION, "close"); return httpRsp; }
@Override protected void doService(HttpRequest request, HttpResponse response, HttpContext context) throws HttpException, IOException { response.addHeader(HttpHeaders.CACHE_CONTROL, "must-revalidate"); // Disable caching // Normalize the URI super.doService(request, response, context); }
protected static void addToResponse(Response response, HttpResponse nettyResponse) { Map<String, Http.Header> headers = response.headers; for (Map.Entry<String, Http.Header> entry : headers.entrySet()) { Http.Header hd = entry.getValue(); for (String value : hd.values) { nettyResponse.setHeader(entry.getKey(), value); } } Map<String, Http.Cookie> cookies = response.cookies; for (Http.Cookie cookie : cookies.values()) { CookieEncoder encoder = new CookieEncoder(true); Cookie c = new DefaultCookie(cookie.name, cookie.value); c.setSecure(cookie.secure); c.setPath(cookie.path); if (cookie.domain != null) { c.setDomain(cookie.domain); } if (cookie.maxAge != null) { c.setMaxAge(cookie.maxAge); } c.setHttpOnly(cookie.httpOnly); encoder.addCookie(c); nettyResponse.addHeader(SET_COOKIE, encoder.encode()); } if (!response.headers.containsKey(CACHE_CONTROL)) { nettyResponse.setHeader(CACHE_CONTROL, "no-cache"); } }
protected HttpResponse newHttpResponse( HttpMessageBuffer origMsg, int statusCode, String reasonPhrase, Encoding encoding) { Encoding responseEncoding = null; if (this.encodeResponses) { responseEncoding = encoding; } HttpResponse httpRsp; if (origMsg == null) { httpRsp = new HttpResponse(statusCode, reasonPhrase, responseEncoding); } else { httpRsp = new HttpResponse( origMsg.getHttpVersionString(), statusCode, reasonPhrase, responseEncoding); } if (origMsg.getHttpVersion() > 1.0) { httpRsp.addHeader(HttpConstants.Headers.HOST, this.headerHostValue); } httpRsp.addHeader(HttpConstants.Headers.SERVER, this.getServerName()); return httpRsp; }
/** * Constructs a new {@link HttpResponse} containing the given XML-RPC method response. * * <p>This implementation encodes the response using <code>UTF-8</code>, sets the status code to * <code>200</code>, and sets <code>Content-Type</code> header to <code>text/xml</code> as * required. No other headers are set. * * @param methodRsp The XML-RPC method response to be returned in the HTTP response. * @param encoding An {@link Encoding} describing the encoding to use when constructing this * message. This also informs the <code>Content-Encoding</code> header value. May be <code> * null</code>. * @return A new {@link HttpResponse} with the marshalled XML-RPC response as its content. * @throws IOException if an error occurs while marshalling the XML-RPC response. * @throws MarshallingException */ protected HttpResponse toHttpResponse( HttpMessageBuffer origMsg, RpcResponse methodRsp, Encoding encoding) throws IOException, MarshallingException { ByteArrayOutputStream byteOs = new ByteArrayOutputStream(); methodRsp.marshal(byteOs, Charset.forName("UTF-8")); byte[] rspXml = byteOs.toByteArray(); HttpResponse httpRsp = this.newHttpResponse(origMsg, 200, "OK", encoding); httpRsp.addHeader(HttpConstants.Headers.CONTENT_TYPE, methodRsp.getContentType()); httpRsp.setContent(rspXml); return httpRsp; }
public void handle(Socket socket) { InputStream input = null; OutputStream output = null; try { input = socket.getInputStream(); output = socket.getOutputStream(); // 创建请求对象 request = new HttpRequest(input); // 创建响应对象 response = new HttpResponse(output); response.setRequest(request); // 设置响应头 response.addHeader("Server", "Bradypod Server Container"); response.addHeader("Content-Type", "text/html"); // 解析请求 request.parse(); response.sendHeaders(); // 发送响应头 // 判断是否请求动态资源 if (request.getRequestURI() == null) { response.getWriter().println("404 Not Found!"); } else if (request.getRequestURI().startsWith("/servlet/")) { ServletProcessor processor = new ServletProcessor(); processor.process(request, response); } else { ResourceProcessor processor = new ResourceProcessor(); processor.process(request, response); } // --> end if-else // 关闭连接 socket.close(); } catch (IOException ex) { } }
/** * Creates and initializes an HttpResponse object suitable to be passed to an HTTP response * handler object. * * @param method The HTTP method that was invoked to get the response. * @param request The HTTP request associated with the response. * @return The new, initialized HttpResponse object ready to be passed to an HTTP response handler * object. * @throws IOException If there were any problems getting any response information from the * HttpClient method object. */ private HttpResponse createResponse( HttpRequestBase method, Request<?> request, org.apache.http.HttpResponse apacheHttpResponse) throws IOException { HttpResponse httpResponse = new HttpResponse(request, method); if (apacheHttpResponse.getEntity() != null) { httpResponse.setContent(apacheHttpResponse.getEntity().getContent()); } httpResponse.setStatusCode(apacheHttpResponse.getStatusLine().getStatusCode()); httpResponse.setStatusText(apacheHttpResponse.getStatusLine().getReasonPhrase()); for (Header header : apacheHttpResponse.getAllHeaders()) { httpResponse.addHeader(header.getName(), header.getValue()); } return httpResponse; }
public HttpResponse getResponse(HttpRequestHeader hdr) { Log.i(LOG_TAG, " getResponse() started"); HttpResponse response; if (hdr.getHeaderParams() == null) { Log.e(LOG_TAG, "No header params found in request"); return new HttpResponse(HttpResponse.HTTP_BADREQUEST, "No header params found in request"); } String method = hdr.getHeaderParams().getProperty("method"); if (method == null) { Log.e(LOG_TAG, "No method in request headers"); return new HttpResponse(HttpResponse.HTTP_BADREQUEST, "No method in request headers"); } if (!method.equalsIgnoreCase("GET")) { Log.e(LOG_TAG, "getResponse() - only GET supported"); return new HttpResponse(HttpResponse.HTTP_NOTIMPLEMENTED, method + " not supported"); } String filename = hdr.getHeaderParams().getProperty("uri"); if (filename == null || filename.startsWith("..") || filename.endsWith("..") || filename.indexOf("../") >= 0) { Log.e(LOG_TAG, "getResponse() - file not found"); return new HttpResponse(HttpResponse.HTTP_FORBIDDEN, "Relative paths not allowed"); } try { String mime = ""; ContentInputStreamAdapter.ContentInputStream responseData = inputStreamAdapter.getContentInputStream(filename); if (responseData == null) { return new HttpResponse(HttpResponse.HTTP_NOTFOUND, "File not found"); } long startFrom = -1; long endAt = -1; String range = hdr.getHeaderParams().getProperty("range"); if (range != null) { Log.i(LOG_TAG, "Request contains a range: " + range); if (range.startsWith("bytes=")) { range = range.substring("bytes=".length()); int minus = range.indexOf('-'); try { if (minus > 0) { startFrom = Long.parseLong(range.substring(0, minus)); endAt = Long.parseLong(range.substring(minus + 1)); } } catch (NumberFormatException nfe) { Log.w(LOG_TAG, "Non Fatal Error extracting range :" + range, nfe); startFrom = -1; endAt = -1; } } } if (startFrom >= 0) { if (startFrom >= responseData.contentLength) { response = new HttpResponse( HttpResponse.HTTP_RANGE_NOT_SATISFIABLE, HttpResponse.MIME_PLAINTEXT, ""); response.addHeader("Content-Range", "bytes 0-0/" + responseData.contentLength); if (mime.startsWith("application/")) { response.addHeader( "Content-Disposition", "attachment; filename=\"" + responseData.filename + "\""); } } else { response = new HttpResponse( HttpResponse.HTTP_PARTIALCONTENT, responseData.mime, responseData.content); if (endAt < 0) { endAt = responseData.contentLength - 1; } long length = endAt - startFrom + 1; if (length < 0) { length = 0; } if (startFrom > 0) { responseData.content.skip(startFrom); } response.addHeader("Content-Length", "" + length); response.addHeader( "Content-Range", "bytes " + startFrom + "-" + endAt + "/" + responseData.contentLength); } } else { response = new HttpResponse(HttpResponse.HTTP_OK, responseData.mime, responseData.content); response.addHeader("Content-Length", "" + responseData.contentLength); response.addHeader("Accept-Ranges", "bytes"); } response.addHeader("Original-Length", "" + responseData.contentLength); response.addHeader( "Last-Modified", dateFormatter.format(new Date(responseData.lastModifiedDate))); } catch (IOException ioe) { response = new HttpResponse(HttpResponse.HTTP_INTERNALERROR, "IOException: " + ioe.getMessage()); Log.e(LOG_TAG, "Error Reading file", ioe); } response.addHeader("Date", dateFormatter.format(new Date())); response.addHeader("Content-Type", "audio/x-m4a"); response.addHeader("Connection", "close"); response.addHeader("Cache-Control", "no-cache"); response.addHeader("Expires", "-1"); response.addHeader("Pragma", "no-cache"); Log.i(LOG_TAG, " getResponse() ended. Response = " + response); return response; }
// TODO: add request and response as parameter public static void serve500(Exception e, ChannelHandlerContext ctx, HttpRequest nettyRequest) { Logger.trace("serve500: begin"); HttpResponse nettyResponse = new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.INTERNAL_SERVER_ERROR); if (exposePlayServer) { nettyResponse.setHeader(SERVER, signature); } Request request = Request.current(); Response response = Response.current(); try { if (!(e instanceof PlayException)) { e = new play.exceptions.UnexpectedException(e); } // Flush some cookies try { Map<String, Http.Cookie> cookies = response.cookies; for (Http.Cookie cookie : cookies.values()) { CookieEncoder encoder = new CookieEncoder(true); Cookie c = new DefaultCookie(cookie.name, cookie.value); c.setSecure(cookie.secure); c.setPath(cookie.path); if (cookie.domain != null) { c.setDomain(cookie.domain); } if (cookie.maxAge != null) { c.setMaxAge(cookie.maxAge); } c.setHttpOnly(cookie.httpOnly); encoder.addCookie(c); nettyResponse.addHeader(SET_COOKIE, encoder.encode()); } } catch (Exception exx) { Logger.error(e, "Trying to flush cookies"); // humm ? } Map<String, Object> binding = getBindingForErrors(e, true); String format = request.format; if (format == null) { format = "txt"; } nettyResponse.setHeader( "Content-Type", (MimeTypes.getContentType("500." + format, "text/plain"))); try { String errorHtml = TemplateLoader.load("errors/500." + format).render(binding); ChannelBuffer buf = ChannelBuffers.copiedBuffer(errorHtml.getBytes("utf-8")); nettyResponse.setContent(buf); ChannelFuture writeFuture = ctx.getChannel().write(nettyResponse); writeFuture.addListener(ChannelFutureListener.CLOSE); Logger.error( e, "Internal Server Error (500) for request %s", request.method + " " + request.url); } catch (Throwable ex) { Logger.error( e, "Internal Server Error (500) for request %s", request.method + " " + request.url); Logger.error(ex, "Error during the 500 response generation"); try { ChannelBuffer buf = ChannelBuffers.copiedBuffer("Internal Error (check logs)".getBytes("utf-8")); nettyResponse.setContent(buf); ChannelFuture writeFuture = ctx.getChannel().write(nettyResponse); writeFuture.addListener(ChannelFutureListener.CLOSE); } catch (UnsupportedEncodingException fex) { Logger.error(fex, "(utf-8 ?)"); } } } catch (Throwable exxx) { try { ChannelBuffer buf = ChannelBuffers.copiedBuffer("Internal Error (check logs)".getBytes("utf-8")); nettyResponse.setContent(buf); ChannelFuture writeFuture = ctx.getChannel().write(nettyResponse); writeFuture.addListener(ChannelFutureListener.CLOSE); } catch (Exception fex) { Logger.error(fex, "(utf-8 ?)"); } if (exxx instanceof RuntimeException) { throw (RuntimeException) exxx; } throw new RuntimeException(exxx); } Logger.trace("serve500: end"); }
private void websocketHandshake(final ChannelHandlerContext ctx, HttpRequest req, MessageEvent e) throws Exception { // Create the WebSocket handshake response. HttpResponse res = new DefaultHttpResponse( HttpVersion.HTTP_1_1, new HttpResponseStatus(101, "Web Socket Protocol Handshake")); res.addHeader(HttpHeaders.Names.UPGRADE, HttpHeaders.Values.WEBSOCKET); res.addHeader(CONNECTION, HttpHeaders.Values.UPGRADE); // Fill in the headers and contents depending on handshake method. if (req.containsHeader(SEC_WEBSOCKET_KEY1) && req.containsHeader(SEC_WEBSOCKET_KEY2)) { // New handshake method with a challenge: res.addHeader(SEC_WEBSOCKET_ORIGIN, req.getHeader(ORIGIN)); res.addHeader( SEC_WEBSOCKET_LOCATION, "ws://" + req.getHeader(HttpHeaders.Names.HOST) + req.getUri()); String protocol = req.getHeader(SEC_WEBSOCKET_PROTOCOL); if (protocol != null) { res.addHeader(SEC_WEBSOCKET_PROTOCOL, protocol); } // Calculate the answer of the challenge. String key1 = req.getHeader(SEC_WEBSOCKET_KEY1); String key2 = req.getHeader(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); input.writeInt(b); input.writeLong(c); try { ChannelBuffer output = ChannelBuffers.wrappedBuffer(MessageDigest.getInstance("MD5").digest(input.array())); res.setContent(output); } catch (NoSuchAlgorithmException ex) { throw new UnexpectedException(ex); } } else { // Old handshake method with no challenge: res.addHeader(WEBSOCKET_ORIGIN, req.getHeader(ORIGIN)); res.addHeader( WEBSOCKET_LOCATION, "ws://" + req.getHeader(HttpHeaders.Names.HOST) + req.getUri()); String protocol = req.getHeader(WEBSOCKET_PROTOCOL); if (protocol != null) { res.addHeader(WEBSOCKET_PROTOCOL, protocol); } } // Keep the original request Http.Request request = parseRequest(ctx, req); // Route the websocket request request.method = "WS"; Map<String, String> route = Router.route(request.method, request.path); if (!route.containsKey("action")) { // No route found to handle this websocket connection ctx.getChannel() .write(new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.NOT_FOUND)); return; } // Upgrade the connection and send the handshake response. ChannelPipeline p = ctx.getChannel().getPipeline(); p.remove("aggregator"); p.replace("decoder", "wsdecoder", new WebSocketFrameDecoder()); // Connect ctx.getChannel().write(res); p.replace("encoder", "wsencoder", new WebSocketFrameEncoder()); req.setMethod(new HttpMethod("WEBSOCKET")); // Inbound Http.Inbound inbound = new Http.Inbound() { @Override public boolean isOpen() { return ctx.getChannel().isOpen(); } }; channels.put(ctx, inbound); // Outbound Http.Outbound outbound = new Http.Outbound() { final List<ChannelFuture> writeFutures = Collections.synchronizedList(new ArrayList<ChannelFuture>()); Promise<Void> closeTask; synchronized void writeAndClose(ChannelFuture writeFuture) { if (!writeFuture.isDone()) { writeFutures.add(writeFuture); writeFuture.addListener( new ChannelFutureListener() { public void operationComplete(ChannelFuture cf) throws Exception { writeFutures.remove(cf); futureClose(); } }); } } void futureClose() { if (closeTask != null && writeFutures.isEmpty()) { closeTask.invoke(null); } } @Override public void send(String data) { if (!isOpen()) { throw new IllegalStateException("The outbound channel is closed"); } writeAndClose(ctx.getChannel().write(new DefaultWebSocketFrame(data))); } @Override public void send(byte opcode, byte[] data, int offset, int length) { if (!isOpen()) { throw new IllegalStateException("The outbound channel is closed"); } writeAndClose( ctx.getChannel() .write(new DefaultWebSocketFrame(opcode, wrappedBuffer(data, offset, length)))); } @Override public synchronized boolean isOpen() { return ctx.getChannel().isOpen() && closeTask == null; } @Override public synchronized void close() { closeTask = new Promise<Void>(); closeTask.onRedeem( new Action<Promise<Void>>() { public void invoke(Promise<Void> completed) { writeFutures.clear(); ctx.getChannel().disconnect(); closeTask = null; } }); futureClose(); } }; Invoker.invoke(new WebSocketInvocation(route, request, inbound, outbound, ctx, e)); }
protected HttpResponse doRequest(HttpRequest request, RequestLine requestLine) throws IOException, MuleException { Map headers = parseHeaders(request); // TODO Mule 2.0 generic way to set stream message adapter MessageAdapter adapter = buildStandardAdapter(request, headers); MuleMessage message = new DefaultMuleMessage(adapter); String path = (String) message.getProperty(HttpConnector.HTTP_REQUEST_PROPERTY); int i = path.indexOf('?'); if (i > -1) { path = path.substring(0, i); } message.setProperty(HttpConnector.HTTP_REQUEST_PATH_PROPERTY, path); if (logger.isDebugEnabled()) { logger.debug(message.getProperty(HttpConnector.HTTP_REQUEST_PROPERTY)); } message.setProperty( HttpConnector.HTTP_CONTEXT_PATH_PROPERTY, HttpConnector.normalizeUrl(endpoint.getEndpointURI().getPath())); // determine if the request path on this request denotes a different receiver MessageReceiver receiver = getTargetReceiver(message, endpoint); HttpResponse response; // the response only needs to be transformed explicitly if // A) the request was not served or B) a null result was returned if (receiver != null) { preRouteMessage(message); MuleMessage returnMessage = receiver.routeMessage(message, endpoint.isSynchronous(), null); Object tempResponse; if (returnMessage != null) { tempResponse = returnMessage.getPayload(); } else { tempResponse = NullPayload.getInstance(); } // This removes the need for users to explicitly adding the response transformer // ObjectToHttpResponse in their config if (tempResponse instanceof HttpResponse) { response = (HttpResponse) tempResponse; } else { response = transformResponse(returnMessage); } response.disableKeepAlive(!((HttpConnector) connector).isKeepAlive()); // Check if endpoint has a keep-alive property configured. Note the translation from // keep-alive in the schema to keepAlive here. boolean endpointOverride = Boolean.parseBoolean((String) endpoint.getProperty("keepAlive")); Header connectionHeader = request.getFirstHeader("Connection"); if (connectionHeader != null) { String value = connectionHeader.getValue(); if ("keep-alive".equalsIgnoreCase(value) && !endpointOverride) { response.setKeepAlive(true); Header header = new Header( HttpConstants.HEADER_KEEP_ALIVE, "timeout=" + ((HttpConnector) connector).getKeepAliveTimeout()); response.addHeader(header); } else if ("close".equalsIgnoreCase(value)) { response.setKeepAlive(false); } else if (response.getHttpVersion().greaterEquals(HttpVersion.HTTP_1_1)) { response.setKeepAlive(true); } else { response.setKeepAlive(false); } } } else { response = buildFailureResponse(requestLine, message); } return response; }