| /* |
| */ |
| package org.apache.tomcat.lite.http; |
| |
| import java.io.IOException; |
| import java.nio.ByteBuffer; |
| import java.util.ArrayList; |
| import java.util.List; |
| import java.util.logging.Level; |
| import java.util.logging.Logger; |
| |
| import org.apache.tomcat.lite.http.HttpConnector.HttpConnection; |
| import org.apache.tomcat.lite.http.HttpMessage.HttpMessageBytes; |
| import org.apache.tomcat.lite.io.BBucket; |
| import org.apache.tomcat.lite.io.BBuffer; |
| import org.apache.tomcat.lite.io.CBuffer; |
| import org.apache.tomcat.lite.io.DumpChannel; |
| import org.apache.tomcat.lite.io.FastHttpDateFormat; |
| import org.apache.tomcat.lite.io.Hex; |
| import org.apache.tomcat.lite.io.IOBuffer; |
| import org.apache.tomcat.lite.io.IOChannel; |
| import org.apache.tomcat.lite.io.IOConnector; |
| |
| public class Http11Connection extends HttpConnection |
| implements IOConnector.ConnectedCallback { |
| public static final String CHUNKED = "chunked"; |
| |
| public static final String CLOSE = "close"; |
| |
| public static final String KEEPALIVE_S = "keep-alive"; |
| |
| public static final String CONNECTION = "connection"; |
| |
| public static final String TRANSFERENCODING = "transfer-encoding"; |
| |
| |
| protected static Logger log = Logger.getLogger("Http11Connection"); |
| static final byte COLON = (byte) ':'; |
| |
| // super.net is the socket |
| |
| boolean debug; |
| BBuffer line = BBuffer.wrapper(); |
| boolean endSent = false; |
| |
| BodyState receiveBodyState = new BodyState(); |
| BodyState sendBodyState = new BodyState(); |
| |
| BBuffer headW = BBuffer.wrapper(); |
| |
| boolean headersReceived = false; |
| boolean bodyReceived = false; |
| |
| /** |
| * Close connection when done writting, no content-length/chunked, |
| * or no keep-alive ( http/1.0 ) or error. |
| * |
| * ServerMode: set if HTTP/0.9 &1.0 || !keep-alive |
| * ClientMode: not currently used |
| */ |
| boolean keepAlive = true; |
| |
| protected boolean http11 = true; |
| protected boolean http10 = false; |
| protected boolean http09 = false; |
| |
| HttpConnection switchedProtocol = null; |
| |
| private int requestCount = 0; |
| |
| // dataReceived and endSendReceive |
| private Object readLock = new Object(); |
| |
| public Http11Connection(HttpConnector httpConnector) { |
| this.httpConnector = httpConnector; |
| if (httpConnector != null) { |
| debug = httpConnector.debugHttp; |
| } |
| } |
| |
| public void beforeRequest() { |
| nextRequest(); |
| headRecvBuf.recycle(); |
| } |
| |
| public void nextRequest() { |
| endSent = false; |
| keepAlive = true; |
| receiveBodyState.recycle(); |
| sendBodyState.recycle(); |
| http11 = true; |
| http09 = false; |
| http10 = false; |
| headersReceived = false; |
| bodyReceived = false; |
| } |
| |
| public Http11Connection serverMode() { |
| serverMode = true; |
| return this; |
| } |
| |
| private boolean readHead() throws IOException { |
| while (true) { |
| int read; |
| if (requestCount == 0 && headRecvBuf.remaining() < 4) { |
| // requests have at least 4 bytes - detect protocol |
| read = net.getIn().read(headRecvBuf, 4); |
| if (read < 0) { |
| return closeInHead(); |
| } |
| if (read < 4) { |
| return false; // need more |
| } |
| // we have at least 4 bytes |
| if (headRecvBuf.get(0) == 0x80 && |
| headRecvBuf.get(1) == 0x01) { |
| // SPDY signature ( experimental ) |
| switchedProtocol = new SpdyConnection(httpConnector, |
| remoteHost); |
| if (serverMode) { |
| switchedProtocol.serverMode = true; |
| } |
| switchedProtocol.withExtraBuffer(headRecvBuf); |
| // Will also call handleReceived |
| switchedProtocol.setSink(net); |
| return false; |
| } |
| |
| } |
| |
| // we know we have one |
| read = net.getIn().readLine(headRecvBuf); |
| // Remove starting empty lines. |
| headRecvBuf.skipEmptyLines(); |
| |
| // Do we have another full line in the input ? |
| if (BBuffer.hasLFLF(headRecvBuf)) { |
| break; // done |
| } |
| if (read == 0) { // no more data |
| return false; |
| } |
| if (read < 0) { |
| return closeInHead(); |
| } |
| } |
| |
| |
| return true; |
| } |
| |
| private boolean closeInHead() throws IOException { |
| if (debug) { |
| trace("CLOSE while reading HEAD"); |
| } |
| // too early - we don't have the head |
| abort("Close in head"); |
| return false; |
| } |
| |
| // Unit tests use this to access the HttpChannel |
| protected HttpChannel checkHttpChannel() throws IOException { |
| if (switchedProtocol != null) { |
| return switchedProtocol.checkHttpChannel(); |
| } |
| if (activeHttp == null) { |
| if (serverMode) { |
| activeHttp = httpConnector.getServer(); |
| activeHttp.setConnection(this); |
| if (httpConnector.defaultService != null) { |
| activeHttp.setHttpService(httpConnector.defaultService); |
| } |
| } else { |
| } |
| } |
| return activeHttp; |
| } |
| |
| @Override |
| public void dataReceived(IOBuffer netx) throws IOException { |
| if (switchedProtocol != null) { |
| switchedProtocol.dataReceived(netx); |
| return; |
| } |
| //trace("handleReceived " + headersReceived); |
| if (!checkKeepAliveClient()) { |
| return; // we were in client keep alive mode |
| } |
| // endSendReceived uses same lock - it will call this |
| // to check outstanding bytes |
| synchronized (readLock) { |
| if (bodyReceived) { |
| return; // leave data in net buffer, for next req |
| } |
| |
| if (!headersReceived) { |
| if (!readHead()) { |
| return; |
| } |
| } |
| |
| // We have a header |
| if (activeHttp == null) { |
| if (checkHttpChannel() == null) { |
| return; |
| } |
| } |
| |
| IOBuffer receiveBody = activeHttp.receiveBody; |
| |
| if (!headersReceived) { |
| headRecvBuf.wrapTo(headW); |
| parseMessage(activeHttp, headW); |
| // Part of parseMessage we can switch the protocol |
| if (switchedProtocol != null) { |
| return; |
| } |
| |
| if (serverMode && activeHttp.httpReq.decodedUri.remaining() == 0) { |
| abort(activeHttp, "Invalid url"); |
| } |
| |
| headersReceived = true; |
| // Send header callbacks - we process any incoming data |
| // first, so callbacks have more info |
| trace("Send headers received callback " + activeHttp.httpService); |
| activeHttp.handleHeadersReceived(activeHttp.inMessage); |
| } |
| |
| // any remaining data will be processed as part of the |
| // body - or left in the channel until endSendReceive() |
| |
| if (!bodyReceived) { |
| // Will close receiveBody when it consummed enough |
| rawDataReceived(activeHttp, receiveBody, net.getIn()); |
| // Did we process anything ? |
| if (receiveBody.getBufferCount() > 0) { |
| activeHttp.sendHandleReceivedCallback(); // callback |
| } |
| } |
| // Receive has marked the body as closed |
| if (receiveBody.isAppendClosed()) { |
| bodyReceived = true; |
| activeHttp.handleEndReceive(); |
| } |
| |
| |
| if (net.getIn().isClosedAndEmpty()) { |
| // If not already closed. |
| closeStreamOnEnd("closed after body"); |
| } |
| |
| } |
| } |
| |
| /** |
| * We got data while in client keep alive ( no activeHttp ) |
| * |
| * @return false if there is an error |
| */ |
| private boolean checkKeepAliveClient() throws IOException { |
| // Client, no active connection ( keep alive ) |
| if (!serverMode && activeHttp == null) { |
| if (net.getIn().isClosedAndEmpty() || !net.isOpen()) { |
| // server disconnected, fine |
| httpConnector.cpool.stopKeepAlive(this); |
| return false; |
| } |
| if (net.getIn().available() == 0) { |
| return true; |
| } |
| log.warning("Unexpected message from server in client keep alive " |
| + net.getIn() + ": " + net.getIn().readAll(null)); |
| if (net.isOpen()) { |
| net.close(); |
| } |
| return false; |
| } |
| return true; |
| } |
| |
| private void processProtocol(CBuffer protocolMB) throws IOException { |
| http11 = false; |
| http09 = false; |
| http10 = false; |
| |
| if (protocolMB.equals(HttpChannel.HTTP_11)) { |
| http11 = true; |
| } else if (protocolMB.equals(HttpChannel.HTTP_10)) { |
| http10 = true; |
| } else if (protocolMB.equals("")) { |
| http09 = true; |
| } else { |
| http11 = true; // hopefully will be backward compat |
| } |
| } |
| |
| void closeStreamOnEnd(String cause) { |
| if (debug) { |
| log.info("Not reusing connection because: " + cause); |
| } |
| keepAlive = false; |
| } |
| |
| boolean keepAlive() { |
| if (httpConnector != null) { |
| if (serverMode && !httpConnector.serverKeepAlive) { |
| keepAlive = false; |
| } |
| if (!serverMode && !httpConnector.clientKeepAlive) { |
| keepAlive = false; |
| } |
| } |
| if (http09) { |
| keepAlive = false; |
| } |
| if (net != null && !net.isOpen()) { |
| keepAlive = false; |
| } |
| return keepAlive; |
| } |
| |
| @Override |
| protected void endSendReceive(HttpChannel http) throws IOException { |
| if (switchedProtocol != null) { |
| switchedProtocol.endSendReceive(http); |
| return; |
| } |
| chunk.recycle(); |
| rchunk.recycle(); |
| boolean keepAlive = keepAlive(); |
| if (!keepAlive) { |
| if (debug) { |
| log.info("--- Close socket, no keepalive " + net); |
| } |
| if (net != null) { |
| net.close(); |
| net.startSending(); |
| |
| } |
| } |
| |
| requestCount++; |
| beforeRequest(); |
| httpConnector.cpool.afterRequest(http, this, true); |
| |
| if (serverMode && keepAlive) { |
| handleReceived(net); // will attempt to read next req |
| } |
| } |
| |
| private void trace(String s) { |
| if(debug) { |
| log.info(this.toString() + " " + activeHttp + " " + s); |
| } |
| } |
| |
| private boolean isDone(BodyState bodys, IOBuffer body) { |
| if (bodys.noBody) { |
| return true; |
| } |
| if (bodys.isContentDelimited()) { |
| if (!bodys.chunked && bodys.remaining == 0) { |
| return true; |
| } else if (bodys.chunked && body.isAppendClosed()) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| void parseMessage(HttpChannel http, BBuffer headB) throws IOException { |
| //Parse the response |
| line.recycle(); |
| headB.readLine(line); |
| |
| HttpMessageBytes msgBytes; |
| |
| if (serverMode) { |
| msgBytes = http.httpReq.getMsgBytes(); |
| parseRequestLine(line, msgBytes.method(), |
| msgBytes.url(), |
| msgBytes.query(), |
| msgBytes.protocol()); |
| } else { |
| msgBytes = http.httpRes.getMsgBytes(); |
| parseResponseLine(line, msgBytes.protocol(), |
| msgBytes.status(), msgBytes.message()); |
| } |
| |
| parseHeaders(http, msgBytes, headB); |
| |
| http.inMessage.state = HttpMessage.State.BODY_DATA; |
| |
| http.inMessage.processReceivedHeaders(); |
| |
| // TODO: hook to allow specific charsets ( can be done later ) |
| processProtocol(http.inMessage.protocol()); |
| |
| if (serverMode) { |
| // requested connection:close/keepAlive and proto |
| updateKeepAlive(http.getRequest().getMimeHeaders(), true); |
| |
| processExpectation(http); |
| |
| processContentDelimitation(receiveBodyState, http.getRequest()); |
| // Spec: |
| // The presence of a message-body in a request is signaled by the |
| // inclusion of a Content-Length or Transfer-Encoding header field in |
| // the request's message-headers |
| // Server should read - but ignore .. |
| receiveBodyState.noBody = !receiveBodyState.isContentDelimited(); |
| |
| updateCloseOnEnd(receiveBodyState, http, http.receiveBody); |
| |
| /* |
| * The presence of a message-body in a request is signaled by the |
| * inclusion of a Content-Length or Transfer-Encoding header field in |
| * the request's message-headers. A message-body MUST NOT be included |
| * in a request if the specification of the request method |
| * (section 5.1.1) does not allow sending an entity-body in requests. |
| * A server SHOULD read and forward a message-body on any request; if the request method does not include defined semantics for an entity-body, then the message-body SHOULD be ignored when handling the request. |
| */ |
| if (!receiveBodyState.isContentDelimited()) { |
| // No body |
| http.getIn().close(); |
| } |
| |
| } else { |
| receiveBodyState.noBody = !http.getResponse().hasBody(); |
| |
| updateKeepAlive(http.getResponse().getMimeHeaders(), false); |
| |
| if (statusDropsConnection(http.getResponse().getStatus())) { |
| closeStreamOnEnd("response status drops connection"); |
| } |
| IOBuffer body = http.receiveBody; |
| processContentDelimitation(receiveBodyState, http.getResponse()); |
| |
| if (isDone(receiveBodyState, body)) { |
| body.close(); |
| } |
| |
| if (!receiveBodyState.isContentDelimited()) { |
| closeStreamOnEnd("not content delimited"); |
| } |
| } |
| |
| } |
| |
| private void processExpectation(HttpChannel http) throws IOException { |
| http.expectation = false; |
| MultiMap headers = http.getRequest().getMimeHeaders(); |
| |
| CBuffer expect = headers.getHeader("expect"); |
| if ((expect != null) |
| && (expect.indexOf("100-continue") != -1)) { |
| http.expectation = true; |
| |
| // TODO: configure, use the callback or the servlet 'read'. |
| net.getOut().append("HTTP/1.1 100 Continue\r\n\r\n"); |
| net.startSending(); |
| } |
| } |
| |
| |
| /** |
| * Updates chunked, contentLength, remaining - based |
| * on headers |
| */ |
| private void processContentDelimitation(BodyState bodys, |
| HttpMessage httpMsg) { |
| |
| bodys.contentLength = httpMsg.getContentLength(); |
| if (bodys.contentLength >= 0) { |
| bodys.remaining = bodys.contentLength; |
| } |
| |
| // TODO: multiple transfer encoding headers, only process the last |
| String transferEncodingValue = httpMsg.getHeader(TRANSFERENCODING); |
| if (transferEncodingValue != null) { |
| int startPos = 0; |
| int commaPos = transferEncodingValue.indexOf(','); |
| String encodingName = null; |
| while (commaPos != -1) { |
| encodingName = transferEncodingValue.substring |
| (startPos, commaPos).toLowerCase().trim(); |
| if ("chunked".equalsIgnoreCase(encodingName)) { |
| bodys.chunked = true; |
| } |
| startPos = commaPos + 1; |
| commaPos = transferEncodingValue.indexOf(',', startPos); |
| } |
| encodingName = transferEncodingValue.substring(startPos) |
| .toLowerCase().trim(); |
| if ("chunked".equals(encodingName)) { |
| bodys.chunked = true; |
| httpMsg.chunked = true; |
| } else { |
| System.err.println("TODO: ABORT 501"); |
| //return 501; // Currently only chunked is supported for |
| // transfer encoding. |
| } |
| } |
| |
| if (bodys.chunked) { |
| bodys.remaining = 0; |
| } |
| } |
| |
| /** |
| * Read the request line. This function is meant to be used during the |
| * HTTP request header parsing. Do NOT attempt to read the request body |
| * using it. |
| * |
| * @throws IOException If an exception occurs during the underlying socket |
| * read operations, or if the given buffer is not big enough to accomodate |
| * the whole line. |
| */ |
| boolean parseRequestLine(BBuffer line, |
| BBuffer methodMB, BBuffer requestURIMB, |
| BBuffer queryMB, |
| BBuffer protoMB) |
| throws IOException { |
| |
| line.readToSpace(methodMB); |
| line.skipSpace(); |
| |
| line.readToDelimOrSpace(HttpChannel.QUESTION, requestURIMB); |
| if (line.remaining() > 0 && line.get(0) == HttpChannel.QUESTION) { |
| // Has query |
| line.readToSpace(queryMB); |
| // don't include '?' |
| queryMB.position(queryMB.position() + 1); |
| } else { |
| queryMB.setBytes(line.array(), line.position(), 0); |
| } |
| line.skipSpace(); |
| |
| line.readToSpace(protoMB); |
| |
| // proto is optional ( for 0.9 ) |
| return requestURIMB.remaining() > 0; |
| } |
| |
| boolean parseResponseLine(BBuffer line, |
| BBuffer protoMB, BBuffer statusCode, BBuffer status) |
| throws IOException { |
| line.skipEmptyLines(); |
| |
| line.readToSpace(protoMB); |
| line.skipSpace(); |
| line.readToSpace(statusCode); |
| line.skipSpace(); |
| line.wrapTo(status); |
| |
| // message may be empty |
| return statusCode.remaining() > 0; |
| } |
| |
| List<String> connectionHeaders = new ArrayList<String>(); |
| |
| private void parseHeaders(HttpChannel http, HttpMessageBytes msgBytes, |
| BBuffer head) |
| throws IOException { |
| |
| head.readLine(line); |
| |
| int idx = 0; |
| |
| BBuffer upgrade = null; |
| |
| while(line.remaining() > 0) { |
| // not empty.. |
| idx = msgBytes.addHeader(); |
| BBuffer nameBuf = msgBytes.getHeaderName(idx); |
| BBuffer valBuf = msgBytes.getHeaderValue(idx); |
| parseHeader(http, head, line, nameBuf, valBuf); |
| |
| // TODO: process 'interesting' headers here. |
| if (nameBuf.equalsIgnoreCase("connection")) { |
| // TODO: save and remove if not recognized |
| } |
| if (nameBuf.equalsIgnoreCase("upgrade")) { |
| upgrade = valBuf; |
| } |
| } |
| |
| if (upgrade != null) { |
| if (upgrade.equalsIgnoreCase("WebSocket")) { |
| |
| } else if (upgrade.equalsIgnoreCase("SPDY/1.0")) { |
| |
| } |
| } |
| |
| // TODO: process connection headers |
| } |
| |
| /** |
| * Parse one header. |
| * Line must be populated. On return line will be populated |
| * with the next header: |
| * |
| * @param line current header line, not empty. |
| */ |
| int parseHeader(HttpChannel http, BBuffer head, |
| BBuffer line, BBuffer name, BBuffer value) |
| throws IOException { |
| |
| int newPos = line.readToDelimOrSpace(COLON, name); |
| line.skipSpace(); |
| if (line.readByte() != COLON) { |
| throw new IOException("Missing ':' in header name " + line); |
| } |
| line.skipSpace(); |
| line.read(value); // remaining of the line |
| |
| while (true) { |
| head.readLine(line); |
| if (line.remaining() == 0) { |
| break; |
| } |
| int first = line.get(0); |
| if (first != BBuffer.SP && first != BBuffer.HT) { |
| break; |
| } |
| // continuation line - append it to value |
| value.setEnd(line.getEnd()); |
| line.position(line.limit()); |
| } |
| |
| // We may want to keep the original and use separate buffer ? |
| http.normalizeHeader(value); |
| return 1; |
| } |
| |
| private int receiveDone(HttpChannel http, IOBuffer body, boolean frameError) throws IOException { |
| // Content-length case, we're done reading |
| body.close(); |
| |
| http.error = frameError; |
| if (frameError) { |
| closeStreamOnEnd("frame error"); |
| } |
| |
| return DONE; |
| } |
| |
| /** |
| * Called when raw body data is received. |
| * Callback should not consume past the end of the body. |
| * @param rawReceiveBuffers |
| * |
| */ |
| private void rawDataReceived(HttpChannel http, IOBuffer body, |
| IOBuffer rawReceiveBuffers) throws IOException { |
| // TODO: Make sure we don't process more than we need ( eat next req ). |
| // If we read too much: leave it in readBuf, the finalzation code |
| // should skip KeepAlive and start processing it. |
| // we need to read at least something - to detect -1 ( we could |
| // suspend right away, but seems safer |
| BodyState bodys = receiveBodyState; |
| |
| while (http.inMessage.state == HttpMessage.State.BODY_DATA) { |
| if (receiveBodyState.noBody) { |
| receiveDone(http, body, false); |
| return; |
| } |
| if (rawReceiveBuffers.isClosedAndEmpty()) { |
| if (receiveBodyState.isContentDelimited()) { |
| if (receiveBodyState.contentLength >= 0 && receiveBodyState.remaining == 0) { |
| receiveDone(http, body, false); |
| } else { |
| // End of input - other side closed, no more data |
| //log.info("CLOSE while reading " + this); |
| // they're not supposed to close ! |
| receiveDone(http, body, true); |
| } |
| } else { |
| receiveDone(http, body, false); // ok |
| } |
| // input connection closed ? |
| closeStreamOnEnd("Closed input"); |
| return; |
| } |
| BBucket rawBuf = rawReceiveBuffers.peekFirst(); |
| if (rawBuf == null) { |
| return; // need more data |
| } |
| |
| if (!bodys.isContentDelimited()) { |
| while (true) { |
| BBucket first = rawReceiveBuffers.popFirst(); |
| if (first == null) { |
| break; // will go back to check if done. |
| } else { |
| received(body, first); |
| } |
| } |
| } else { |
| |
| if (bodys.contentLength >= 0 && bodys.remaining == 0) { |
| receiveDone(http, body, false); |
| return; |
| } |
| |
| if (bodys.chunked && bodys.remaining == 0) { |
| int rc = NEED_MORE; |
| // TODO: simplify, use readLine() |
| while (rc == NEED_MORE) { |
| rc = rchunk.parseChunkHeader(rawReceiveBuffers); |
| if (rc == ERROR) { |
| http.abort("Chunk error"); |
| receiveDone(http, body, true); |
| return; |
| } else if (rc == NEED_MORE) { |
| return; |
| } |
| } |
| if (rc == 0) { // last chunk |
| receiveDone(http, body, false); |
| return; |
| } else { |
| bodys.remaining = rc; |
| } |
| } |
| |
| rawBuf = (BBucket) rawReceiveBuffers.peekFirst(); |
| if (rawBuf == null) { |
| return; // need more data |
| } |
| |
| |
| if (bodys.remaining < rawBuf.remaining()) { |
| // To buffer has more data than we need. |
| int lenToConsume = (int) bodys.remaining; |
| BBucket sb = rawReceiveBuffers.popLen(lenToConsume); |
| received(body, sb); |
| //log.info("Queue received buffer " + this + " " + lenToConsume); |
| bodys.remaining = 0; |
| } else { |
| BBucket first = rawReceiveBuffers.popFirst(); |
| bodys.remaining -= first.remaining(); |
| received(body, first); |
| //log.info("Queue full received buffer " + this + " RAW: " + rawReceiveBuffers); |
| } |
| if (bodys.contentLength >= 0 && bodys.remaining == 0) { |
| // Content-Length, all done |
| body.close(); |
| receiveDone(http, body, false); |
| } |
| } |
| } |
| } |
| |
| private void received(IOBuffer body, BBucket bb) throws IOException { |
| body.queue(bb); |
| } |
| |
| |
| protected void sendRequest(HttpChannel http) |
| throws IOException { |
| if (switchedProtocol != null) { |
| switchedProtocol.sendRequest(http); |
| return; |
| } |
| |
| // Update transfer fields based on headers. |
| processProtocol(http.getRequest().protocol()); |
| updateKeepAlive(http.getRequest().getMimeHeaders(), true); |
| |
| // Update Host header |
| if (http.getRequest().getMimeHeaders().getHeader("Host") == null) { |
| String target = http.getTarget(); |
| if (target == null) { |
| throw new IOException("Missing host header"); |
| } |
| CBuffer hostH = http.getRequest().getMimeHeaders().addValue("Host"); |
| if (target.endsWith(":80")) { |
| hostH.set(target.substring(0, target.length() - 3)); |
| } else { |
| hostH.set(target); |
| } |
| } |
| |
| processContentDelimitation(sendBodyState, |
| http.getRequest()); |
| |
| |
| CBuffer method = http.getRequest().method(); |
| if (method.equals("GET") || method.equals("HEAD")) { |
| // TODO: add the others |
| sendBodyState.noBody = true; |
| } |
| |
| // 1.0: The presence of an entity body in a request is signaled by |
| // the inclusion of a Content-Length header field in the request |
| // message headers. HTTP/1.0 requests containing an entity body |
| // must include a valid Content-Length header field. |
| if (http10 && !sendBodyState.isContentDelimited()) { |
| // Will not close connection - just flush and mark the body |
| // as sent |
| sendBodyState.noBody = true; |
| } |
| |
| if (sendBodyState.noBody) { |
| http.getRequest().getMimeHeaders().remove(HttpChannel.CONTENT_LENGTH); |
| http.getRequest().getMimeHeaders().remove(TRANSFERENCODING); |
| http.getOut().close(); |
| } else { |
| long contentLength = |
| http.getRequest().getContentLength(); |
| if (contentLength < 0) { |
| http.getRequest().getMimeHeaders().addValue("Transfer-Encoding"). |
| set(CHUNKED); |
| } |
| } |
| |
| updateCloseOnEnd(sendBodyState, http, http.sendBody); |
| |
| try { |
| serialize(http.getRequest(), net.getOut()); |
| if (http.debug) { |
| http.trace("S: \n" + net.getOut()); |
| } |
| |
| if (http.outMessage.state == HttpMessage.State.HEAD) { |
| http.outMessage.state = HttpMessage.State.BODY_DATA; |
| } |
| |
| |
| // TODO: add any body and flush. More body can be added later - |
| // including 'end'. |
| |
| http.startSending(); |
| } catch (Throwable t) { |
| log.log(Level.SEVERE, "Error sending request", t); |
| abort(t.getMessage()); |
| } |
| |
| } |
| |
| |
| /** |
| * Determine if we must drop the connection because of the HTTP status |
| * code. Use the same list of codes as Apache/httpd. |
| */ |
| private boolean statusDropsConnection(int status) { |
| return status == 400 /* SC_BAD_REQUEST */ || |
| status == 408 /* SC_REQUEST_TIMEOUT */ || |
| status == 411 /* SC_LENGTH_REQUIRED */ || |
| status == 413 /* SC_REQUEST_ENTITY_TOO_LARGE */ || |
| status == 414 /* SC_REQUEST_URI_TOO_LARGE */ || |
| status == 500 /* SC_INTERNAL_SERVER_ERROR */ || |
| status == 503 /* SC_SERVICE_UNAVAILABLE */ || |
| status == 501 /* SC_NOT_IMPLEMENTED */; |
| } |
| |
| protected void sendResponseHeaders(HttpChannel http) |
| throws IOException { |
| if (switchedProtocol != null) { |
| switchedProtocol.sendResponseHeaders(http); |
| return; |
| } |
| |
| if (!serverMode) { |
| throw new IOException("Only in server mode"); |
| } |
| endSent = false; |
| IOBuffer sendBody = http.sendBody; |
| HttpResponse res = http.getResponse(); |
| if (res.isCommitted()) { |
| return; |
| } |
| res.setCommitted(true); |
| |
| sendBodyState.noBody = !res.hasBody(); |
| |
| if (statusDropsConnection(res.getStatus())) { |
| closeStreamOnEnd("status drops connection"); |
| } |
| if (http.error) { |
| closeStreamOnEnd("error"); |
| } |
| |
| MultiMap headers = res.getMimeHeaders(); |
| |
| // Add date header |
| if (headers.getHeader("Date") == null) { |
| headers.setValue("Date").set(FastHttpDateFormat.getCurrentDate()); |
| } |
| |
| // Add server header |
| if (http.serverHeader.length() > 0) { |
| headers.setValue("Server").set(http.serverHeader); |
| } |
| |
| // Decide on a transfer encoding for out. |
| if (keepAlive()) { // request and user allows keep alive |
| int cl = res.getContentLength(); |
| |
| if (http10) { |
| if (cl < 0 && !sendBodyState.noBody && |
| sendBody.isAppendClosed()) { |
| // We can generate content-lenght |
| cl = sendBody.available(); |
| res.setContentLength(cl); |
| } |
| if (cl < 0 && !sendBodyState.noBody) { |
| closeStreamOnEnd("HTTP/1.0 without content length"); |
| } else { |
| headers.setValue(CONNECTION).set(KEEPALIVE_S); |
| } |
| } else { // http11 |
| if (!sendBodyState.noBody) { |
| if (cl < 0) { |
| res.getMimeHeaders().setValue(TRANSFERENCODING).set(CHUNKED); |
| } |
| } |
| } |
| } else { |
| headers.setValue(CONNECTION).set(CLOSE); |
| // since we close the connection - don't bother with |
| // transfer encoding |
| headers.remove(TRANSFERENCODING); |
| } |
| |
| // Update our internal state based on headers we just set. |
| processContentDelimitation(sendBodyState, res); |
| updateCloseOnEnd(sendBodyState, http, sendBody); |
| |
| |
| if (http.debug) { |
| http.trace("Send response headers " + net); |
| } |
| if (net != null) { |
| serialize(res, net.getOut()); |
| } |
| |
| if (http.outMessage.state == HttpMessage.State.HEAD) { |
| http.outMessage.state = HttpMessage.State.BODY_DATA; |
| } |
| |
| if (isDone(sendBodyState, sendBody)) { |
| http.getOut().close(); |
| } |
| |
| if (net != null) { |
| net.startSending(); |
| } |
| } |
| |
| private void abort(String t) throws IOException { |
| abort(activeHttp, t); |
| } |
| |
| private void updateCloseOnEnd(BodyState bodys, HttpChannel http, IOBuffer body) { |
| if (!bodys.isContentDelimited() && !bodys.noBody) { |
| closeStreamOnEnd("not content delimited"); |
| } |
| } |
| |
| /** |
| * Disconnect abruptly - client closed, frame errors, etc |
| * @param t |
| * @throws IOException |
| */ |
| public void abort(HttpChannel http, String t) throws IOException { |
| if (switchedProtocol != null) { |
| switchedProtocol.abort(http, t); |
| return; |
| } |
| keepAlive = false; |
| if (net != null ) { |
| if (net.isOpen()) { |
| net.close(); |
| net.startSending(); |
| } |
| } |
| if (http != null) { |
| http.abort(t); |
| } |
| } |
| |
| /** |
| * Update keepAlive based on Connection header and protocol. |
| */ |
| private void updateKeepAlive(MultiMap headers, boolean request) { |
| if (http09) { |
| closeStreamOnEnd("http 0.9"); |
| return; |
| } |
| |
| // TODO: also need to remove headers matching connection |
| // ( like 'upgrade') |
| |
| CBuffer value = headers.getHeader(CONNECTION); |
| // TODO: split it by space |
| if (value != null) { |
| value.toLower(); |
| if (value.indexOf(CLOSE) >= 0) { |
| // 1.1 ( but we accept it for 1.0 too ) |
| closeStreamOnEnd("connection close"); |
| } |
| if (http10 && value.indexOf(KEEPALIVE_S) < 0) { |
| // Keep-Alive required for http/1.0 |
| closeStreamOnEnd("connection != keep alive"); |
| } |
| // we have connection: keepalive, good |
| } else { |
| // no connection header - for 1.1 default is keepAlive, |
| // for 10 it's close |
| if (http10) { |
| closeStreamOnEnd("http1.0 no connection header"); |
| } |
| } |
| } |
| |
| @Override |
| public void startSending() throws IOException { |
| if (switchedProtocol != null) { |
| switchedProtocol.startSending(); |
| return; |
| } |
| |
| } |
| |
| @Override |
| public void startSending(HttpChannel http) throws IOException { |
| if (switchedProtocol != null) { |
| switchedProtocol.startSending(http); |
| return; |
| } |
| http.send(); // if needed |
| |
| if (net == null) { |
| return; // not connected yet. |
| } |
| |
| if (net.getOut().isAppendClosed()) { |
| abort("Net closed"); |
| } else { |
| flushToNext(http.sendBody, net.getOut()); |
| net.startSending(); |
| } |
| |
| } |
| |
| protected void outClosed(HttpChannel http) throws IOException { |
| if (switchedProtocol != null) { |
| switchedProtocol.outClosed(http); |
| return; |
| } |
| // TODO: move it ? |
| if (sendBodyState.isContentDelimited() && !http.error) { |
| if (!sendBodyState.chunked && |
| sendBodyState.remaining - http.getOut().available() > 0) { |
| http.abort("CLOSE CALLED WITHOUT FULL LEN"); |
| } |
| } |
| |
| } |
| |
| @Override |
| public void handleFlushed(IOChannel net) throws IOException { |
| if (switchedProtocol != null) { |
| switchedProtocol.handleFlushed(net); |
| return; |
| } |
| if (activeHttp != null) { |
| activeHttp.flushLock.signal(this); |
| activeHttp.handleFlushed(this); |
| if (activeHttp.sendBody.isClosedAndEmpty()) { |
| activeHttp.handleEndSent(); |
| } |
| } |
| } |
| |
| |
| private void flushToNext(IOBuffer body, IOBuffer out) throws IOException { |
| |
| synchronized (this) { |
| // TODO: better head support |
| if (sendBodyState.noBody) { |
| for (int i = 0; i < body.getBufferCount(); i++) { |
| Object bc = body.peekBucket(i); |
| if (bc instanceof BBucket) { |
| ((BBucket) bc).release(); |
| } |
| } |
| body.clear(); |
| return; |
| } |
| |
| // TODO: only send < remainingWrite, if buffer |
| // keeps changing after startWrite() is called (shouldn't) |
| |
| if (sendBodyState.chunked) { |
| sendChunked(sendBodyState, body, out); |
| } else if (sendBodyState.contentLength >= 0) { |
| // content-length based |
| sendContentLen(sendBodyState, body, out); |
| } else { |
| sendCloseDelimited(body, out); |
| } |
| } |
| } |
| |
| private void sendCloseDelimited(IOBuffer body, IOBuffer out) throws IOException { |
| // Close delimitation |
| while (true) { |
| Object bc = body.popFirst(); |
| if (bc == null) { |
| break; |
| } |
| out.queue(bc); |
| } |
| if (body.isClosedAndEmpty()) { |
| out.close(); // no content-delimitation |
| } |
| } |
| |
| /** |
| * Convert the request to bytes, ready to send. |
| */ |
| public static void serialize(HttpRequest req, IOBuffer rawSendBuffers2) throws IOException { |
| rawSendBuffers2.append(req.method()); |
| rawSendBuffers2.append(BBuffer.SP); |
| |
| // TODO: encode or use decoded |
| rawSendBuffers2.append(req.requestURI()); |
| if (req.queryString().length() > 0) { |
| rawSendBuffers2.append("?"); |
| rawSendBuffers2.append(req.queryString()); |
| } |
| |
| rawSendBuffers2.append(BBuffer.SP); |
| rawSendBuffers2.append(req.protocol()); |
| rawSendBuffers2.append(BBuffer.CRLF_BYTES); |
| |
| serializeHeaders(req.getMimeHeaders(), rawSendBuffers2); |
| } |
| |
| /** |
| * Convert the response to bytes, ready to send. |
| */ |
| public static void serialize(HttpResponse res, IOBuffer rawSendBuffers2) throws IOException { |
| |
| rawSendBuffers2.append(res.protocol()).append(' '); |
| String status = Integer.toString(res.getStatus()); |
| rawSendBuffers2.append(status).append(' '); |
| if (res.getMessageBuffer().length() > 0) { |
| rawSendBuffers2.append(res.getMessage()); |
| } else { |
| rawSendBuffers2 |
| .append(res.getMessage(res.getStatus())); |
| } |
| rawSendBuffers2.append(BBuffer.CRLF_BYTES); |
| // Headers |
| serializeHeaders(res.getMimeHeaders(), rawSendBuffers2); |
| } |
| |
| public static void serializeHeaders(MultiMap mimeHeaders, IOBuffer rawSendBuffers2) throws IOException { |
| for (int i = 0; i < mimeHeaders.size(); i++) { |
| CBuffer name = mimeHeaders.getName(i); |
| CBuffer value = mimeHeaders.getValue(i); |
| if (name.length() == 0 || value.length() == 0) { |
| continue; |
| } |
| rawSendBuffers2.append(name); |
| rawSendBuffers2.append(Http11Connection.COLON); |
| rawSendBuffers2.append(value); |
| rawSendBuffers2.append(BBuffer.CRLF_BYTES); |
| } |
| rawSendBuffers2.append(BBuffer.CRLF_BYTES); |
| } |
| |
| |
| private boolean sendContentLen(BodyState bodys, IOBuffer body, IOBuffer out) throws IOException { |
| while (true) { |
| BBucket bucket = body.peekFirst(); |
| if (bucket == null) { |
| break; |
| } |
| int len = bucket.remaining(); |
| if (len <= bodys.remaining) { |
| bodys.remaining -= len; |
| bucket = body.popFirst(); |
| out.queue(bucket); |
| } else { |
| // Write over the end of the buffer ! |
| log.severe("write more than Content-Length"); |
| len = (int) bodys.remaining; |
| // data between position and limit |
| bucket = body.popLen((int) bodys.remaining); |
| out.queue(bucket); |
| while (bucket != null) { |
| bucket = body.popFirst(); |
| if (bucket != null) { |
| bucket.release(); |
| } |
| } |
| |
| // forced close |
| //close(); |
| bodys.remaining = 0; |
| return true; |
| } |
| } |
| if (body.isClosedAndEmpty()) { |
| //http.rawSendBuffers.queue(IOBrigade.MARK); |
| if (bodys.remaining > 0) { |
| closeStreamOnEnd("sent more than content-length"); |
| log.severe("Content-Length > body"); |
| } |
| return true; |
| } |
| return false; |
| } |
| |
| private boolean sendChunked(BodyState bodys, IOBuffer body, IOBuffer out) throws IOException { |
| int len = body.available(); |
| |
| if (len > 0) { |
| ByteBuffer sendChunkBuffer = chunk.prepareChunkHeader(len); |
| bodys.remaining = len; |
| out.queue(sendChunkBuffer); |
| while (bodys.remaining > 0) { |
| BBucket bc = body.popFirst(); |
| bodys.remaining -= bc.remaining(); |
| out.queue(bc); |
| } |
| } |
| |
| if (body.isClosedAndEmpty()) { |
| synchronized(this) { |
| if (!endSent) { |
| out.append(chunk.endChunk()); |
| endSent = true; |
| } |
| } |
| return true; |
| } else { |
| return false; |
| } |
| } |
| |
| // used for chunk parsing/end |
| ChunkState chunk = new ChunkState(); |
| ChunkState rchunk = new ChunkState(); |
| static final int NEED_MORE = -1; |
| static final int ERROR = -4; |
| static final int DONE = -5; |
| |
| |
| static class ChunkState { |
| static byte[] END_CHUNK_BYTES = { |
| (byte) '\r', (byte) '\n', |
| (byte) '0', |
| (byte) '\r', (byte) '\n', |
| (byte) '\r', (byte) '\n'}; |
| |
| |
| int partialChunkLen; |
| boolean readDigit = false; |
| boolean trailer = false; |
| protected boolean needChunkCrlf = false; |
| |
| // Buffer used for chunk length conversion. |
| protected byte[] sendChunkLength = new byte[10]; |
| |
| /** End chunk marker - will include chunked end or empty */ |
| protected BBuffer endSendBuffer = BBuffer.wrapper(); |
| |
| public ChunkState() { |
| sendChunkLength[8] = (byte) '\r'; |
| sendChunkLength[9] = (byte) '\n'; |
| } |
| |
| void recycle() { |
| partialChunkLen = 0; |
| readDigit = false; |
| trailer = false; |
| needChunkCrlf = false; |
| endSendBuffer.recycle(); |
| } |
| |
| /** |
| * Parse the header of a chunk. |
| * A chunk header can look like |
| * A10CRLF |
| * F23;chunk-extension to be ignoredCRLF |
| * The letters before CRLF but after the trailer mark, must be valid hex digits, |
| * we should not parse F23IAMGONNAMESSTHISUP34CRLF as a valid header |
| * according to spec |
| */ |
| int parseChunkHeader(IOBuffer buffer) throws IOException { |
| if (buffer.peekFirst() == null) { |
| return NEED_MORE; |
| } |
| if (needChunkCrlf) { |
| // TODO: Trailing headers |
| int c = buffer.read(); |
| if (c == BBuffer.CR) { |
| if (buffer.peekFirst() == null) { |
| return NEED_MORE; |
| } |
| c = buffer.read(); |
| } |
| if (c == BBuffer.LF) { |
| needChunkCrlf = false; |
| } else { |
| System.err.println("Bad CRLF " + c); |
| return ERROR; |
| } |
| } |
| |
| while (true) { |
| if (buffer.peekFirst() == null) { |
| return NEED_MORE; |
| } |
| int c = buffer.read(); |
| |
| if (c == BBuffer.CR) { |
| continue; |
| } else if (c == BBuffer.LF) { |
| break; |
| } else if (c == HttpChannel.SEMI_COLON) { |
| trailer = true; |
| } else if (c == BBuffer.SP) { |
| // ignore |
| } else if (trailer) { |
| // ignore |
| } else { |
| //don't read data after the trailer |
| if (Hex.DEC[c] != -1) { |
| readDigit = true; |
| partialChunkLen *= 16; |
| partialChunkLen += Hex.DEC[c]; |
| } else { |
| //we shouldn't allow invalid, non hex characters |
| //in the chunked header |
| log.info("Chunk parsing error1 " + c + " " + buffer); |
| //http.abort("Chunk error"); |
| return ERROR; |
| } |
| } |
| } |
| |
| if (!readDigit) { |
| log.info("Chunk parsing error2 " + buffer); |
| return ERROR; |
| } |
| |
| needChunkCrlf = true; // next time I need to parse CRLF |
| int result = partialChunkLen; |
| partialChunkLen = 0; |
| trailer = false; |
| readDigit = false; |
| return result; |
| } |
| |
| |
| ByteBuffer prepareChunkHeader(int current) { |
| int pos = 7; // 8, 9 are CRLF |
| while (current > 0) { |
| int digit = current % 16; |
| current = current / 16; |
| sendChunkLength[pos--] = Hex.HEX[digit]; |
| } |
| if (needChunkCrlf) { |
| sendChunkLength[pos--] = (byte) '\n'; |
| sendChunkLength[pos--] = (byte) '\r'; |
| } else { |
| needChunkCrlf = true; |
| } |
| // TODO: pool - this may stay in the queue while we flush more |
| ByteBuffer chunkBB = ByteBuffer.allocate(16); |
| chunkBB.put(sendChunkLength, pos + 1, 9 - pos); |
| chunkBB.flip(); |
| return chunkBB; |
| } |
| |
| public BBuffer endChunk() { |
| if (! needChunkCrlf) { |
| endSendBuffer.setBytes(END_CHUNK_BYTES, 2, |
| END_CHUNK_BYTES.length - 2); // CRLF |
| } else { // 0 |
| endSendBuffer.setBytes(END_CHUNK_BYTES, 0, |
| END_CHUNK_BYTES.length); |
| } |
| return endSendBuffer; |
| } |
| } |
| |
| static class BodyState { |
| /** response: HEAD or 1xx, 204, 304 status |
| * req: missing content-length or transfer-encoding |
| */ |
| protected boolean noBody = false; |
| protected boolean chunked = false; |
| protected long contentLength = -1; // C-L header |
| /** Bytes remaining in the current chunk or body ( if CL ) */ |
| protected long remaining = 0; // both chunked and C-L |
| |
| public void recycle() { |
| chunked = false; |
| remaining = 0; |
| contentLength = -1; |
| noBody = false; |
| } |
| public boolean isContentDelimited() { |
| return chunked || contentLength >= 0; |
| } |
| |
| } |
| |
| public String toString() { |
| if (switchedProtocol != null) { |
| return switchedProtocol.toString(); |
| } |
| |
| return (serverMode ? "SR " : "CL ") + |
| (keepAlive() ? " KA " : "") + |
| (headersReceived ? " HEAD " : "") + |
| (bodyReceived ? " BODY " : "") |
| ; |
| } |
| |
| @Override |
| public void handleConnected(IOChannel net) throws IOException { |
| HttpChannel httpCh = activeHttp; |
| |
| if (!net.isOpen()) { |
| httpCh.abort(net.lastException()); |
| return; |
| } |
| |
| boolean ssl = httpCh.getRequest().isSecure(); |
| if (ssl) { |
| String[] hostPort = httpCh.getTarget().split(":"); |
| |
| IOChannel ch1 = httpConnector.sslProvider.channel(net, |
| hostPort[0], Integer.parseInt(hostPort[1])); |
| //net.setHead(ch1); |
| net = ch1; |
| } |
| if (httpConnector.debugHttp) { |
| net = DumpChannel.wrap("Http-Client-", net); |
| } |
| |
| setSink(net); |
| |
| sendRequest(httpCh); |
| } |
| |
| } |
