| // |
| // ======================================================================== |
| // Copyright (c) 1995-2014 Mort Bay Consulting Pty. Ltd. |
| // ------------------------------------------------------------------------ |
| // All rights reserved. This program and the accompanying materials |
| // are made available under the terms of the Eclipse Public License v1.0 |
| // and Apache License v2.0 which accompanies this distribution. |
| // |
| // The Eclipse Public License is available at |
| // http://www.eclipse.org/legal/epl-v10.html |
| // |
| // The Apache License v2.0 is available at |
| // http://www.opensource.org/licenses/apache2.0.php |
| // |
| // You may elect to redistribute this code under either of these licenses. |
| // ======================================================================== |
| // |
| |
| package org.eclipse.jetty.http; |
| |
| import java.io.IOException; |
| import java.io.InterruptedIOException; |
| |
| import org.eclipse.jetty.io.Buffer; |
| import org.eclipse.jetty.io.BufferCache.CachedBuffer; |
| import org.eclipse.jetty.io.BufferUtil; |
| import org.eclipse.jetty.io.Buffers; |
| import org.eclipse.jetty.io.ByteArrayBuffer; |
| import org.eclipse.jetty.io.EndPoint; |
| import org.eclipse.jetty.io.EofException; |
| import org.eclipse.jetty.util.StringUtil; |
| import org.eclipse.jetty.util.log.Log; |
| import org.eclipse.jetty.util.log.Logger; |
| |
| /* ------------------------------------------------------------ */ |
| /** |
| * HttpGenerator. Builds HTTP Messages. |
| * |
| * |
| * |
| */ |
| public class HttpGenerator extends AbstractGenerator |
| { |
| private static final Logger LOG = Log.getLogger(HttpGenerator.class); |
| |
| // Build cache of response lines for status |
| private static class Status |
| { |
| Buffer _reason; |
| Buffer _schemeCode; |
| Buffer _responseLine; |
| } |
| private static final Status[] __status = new Status[HttpStatus.MAX_CODE+1]; |
| static |
| { |
| int versionLength=HttpVersions.HTTP_1_1_BUFFER.length(); |
| |
| for (int i=0;i<__status.length;i++) |
| { |
| HttpStatus.Code code = HttpStatus.getCode(i); |
| if (code==null) |
| continue; |
| String reason=code.getMessage(); |
| byte[] bytes=new byte[versionLength+5+reason.length()+2]; |
| HttpVersions.HTTP_1_1_BUFFER.peek(0,bytes, 0, versionLength); |
| bytes[versionLength+0]=' '; |
| bytes[versionLength+1]=(byte)('0'+i/100); |
| bytes[versionLength+2]=(byte)('0'+(i%100)/10); |
| bytes[versionLength+3]=(byte)('0'+(i%10)); |
| bytes[versionLength+4]=' '; |
| for (int j=0;j<reason.length();j++) |
| bytes[versionLength+5+j]=(byte)reason.charAt(j); |
| bytes[versionLength+5+reason.length()]=HttpTokens.CARRIAGE_RETURN; |
| bytes[versionLength+6+reason.length()]=HttpTokens.LINE_FEED; |
| |
| __status[i] = new Status(); |
| __status[i]._reason=new ByteArrayBuffer(bytes,versionLength+5,bytes.length-versionLength-7,Buffer.IMMUTABLE); |
| __status[i]._schemeCode=new ByteArrayBuffer(bytes,0,versionLength+5,Buffer.IMMUTABLE); |
| __status[i]._responseLine=new ByteArrayBuffer(bytes,0,bytes.length,Buffer.IMMUTABLE); |
| } |
| } |
| |
| /* ------------------------------------------------------------------------------- */ |
| public static Buffer getReasonBuffer(int code) |
| { |
| Status status = code<__status.length?__status[code]:null; |
| if (status!=null) |
| return status._reason; |
| return null; |
| } |
| |
| |
| // common _content |
| private static final byte[] LAST_CHUNK = |
| { (byte) '0', (byte) '\015', (byte) '\012', (byte) '\015', (byte) '\012'}; |
| private static final byte[] CONTENT_LENGTH_0 = StringUtil.getBytes("Content-Length: 0\015\012"); |
| private static final byte[] CONNECTION_KEEP_ALIVE = StringUtil.getBytes("Connection: keep-alive\015\012"); |
| private static final byte[] CONNECTION_CLOSE = StringUtil.getBytes("Connection: close\015\012"); |
| private static final byte[] CONNECTION_ = StringUtil.getBytes("Connection: "); |
| private static final byte[] CRLF = StringUtil.getBytes("\015\012"); |
| private static final byte[] TRANSFER_ENCODING_CHUNKED = StringUtil.getBytes("Transfer-Encoding: chunked\015\012"); |
| private static byte[] SERVER = StringUtil.getBytes("Server: Jetty(7.0.x)\015\012"); |
| |
| // other statics |
| private static final int CHUNK_SPACE = 12; |
| |
| public static void setServerVersion(String version) |
| { |
| SERVER=StringUtil.getBytes("Server: Jetty("+version+")\015\012"); |
| } |
| |
| // data |
| protected boolean _bypass = false; // True if _content buffer can be written directly to endp and bypass the content buffer |
| private boolean _needCRLF = false; |
| private boolean _needEOC = false; |
| private boolean _bufferChunked = false; |
| |
| |
| /* ------------------------------------------------------------------------------- */ |
| /** |
| * Constructor. |
| * |
| * @param buffers buffer pool |
| * @param io the end point to use |
| */ |
| public HttpGenerator(Buffers buffers, EndPoint io) |
| { |
| super(buffers,io); |
| } |
| |
| /* ------------------------------------------------------------------------------- */ |
| @Override |
| public void reset() |
| { |
| if (_persistent!=null && !_persistent && _endp!=null && !_endp.isOutputShutdown()) |
| { |
| try |
| { |
| _endp.shutdownOutput(); |
| } |
| catch(IOException e) |
| { |
| LOG.ignore(e); |
| } |
| } |
| super.reset(); |
| if (_buffer!=null) |
| _buffer.clear(); |
| if (_header!=null) |
| _header.clear(); |
| if (_content!=null) |
| _content=null; |
| _bypass = false; |
| _needCRLF = false; |
| _needEOC = false; |
| _bufferChunked=false; |
| _method=null; |
| _uri=null; |
| _noContent=false; |
| } |
| |
| /* ------------------------------------------------------------ */ |
| /** |
| * Add content. |
| * |
| * @param content |
| * @param last |
| * @throws IllegalArgumentException if <code>content</code> is {@link Buffer#isImmutable immutable}. |
| * @throws IllegalStateException If the request is not expecting any more content, |
| * or if the buffers are full and cannot be flushed. |
| * @throws IOException if there is a problem flushing the buffers. |
| */ |
| public void addContent(Buffer content, boolean last) throws IOException |
| { |
| if (_noContent) |
| throw new IllegalStateException("NO CONTENT"); |
| |
| if (_last || _state==STATE_END) |
| { |
| LOG.warn("Ignoring extra content {}",content); |
| content.clear(); |
| return; |
| } |
| _last = last; |
| |
| // Handle any unfinished business? |
| if (_content!=null && _content.length()>0 || _bufferChunked) |
| { |
| if (_endp.isOutputShutdown()) |
| throw new EofException(); |
| flushBuffer(); |
| if (_content != null && _content.length()>0) |
| { |
| if (_bufferChunked) |
| { |
| Buffer nc=_buffers.getBuffer(_content.length()+CHUNK_SPACE+content.length()); |
| nc.put(_content); |
| nc.put(HttpTokens.CRLF); |
| BufferUtil.putHexInt(nc, content.length()); |
| nc.put(HttpTokens.CRLF); |
| nc.put(content); |
| content=nc; |
| } |
| else |
| { |
| Buffer nc=_buffers.getBuffer(_content.length()+content.length()); |
| nc.put(_content); |
| nc.put(content); |
| content=nc; |
| } |
| } |
| } |
| |
| _content = content; |
| _contentWritten += content.length(); |
| |
| // Handle the _content |
| if (_head) |
| { |
| content.clear(); |
| _content=null; |
| } |
| else if (_endp != null && (_buffer==null || _buffer.length()==0) && _content.length() > 0 && (_last || isCommitted() && _content.length()>1024)) |
| { |
| _bypass = true; |
| } |
| else if (!_bufferChunked) |
| { |
| // Yes - so we better check we have a buffer |
| if (_buffer == null) |
| _buffer = _buffers.getBuffer(); |
| |
| // Copy _content to buffer; |
| int len=_buffer.put(_content); |
| _content.skip(len); |
| if (_content.length() == 0) |
| _content = null; |
| } |
| } |
| |
| /* ------------------------------------------------------------ */ |
| /** |
| * send complete response. |
| * |
| * @param response |
| */ |
| public void sendResponse(Buffer response) throws IOException |
| { |
| if (_noContent || _state!=STATE_HEADER || _content!=null && _content.length()>0 || _bufferChunked || _head ) |
| throw new IllegalStateException(); |
| |
| _last = true; |
| |
| _content = response; |
| _bypass = true; |
| _state = STATE_FLUSHING; |
| |
| // TODO this is not exactly right, but should do. |
| _contentLength =_contentWritten = response.length(); |
| |
| } |
| |
| /* ------------------------------------------------------------ */ |
| /** Prepare buffer for unchecked writes. |
| * Prepare the generator buffer to receive unchecked writes |
| * @return the available space in the buffer. |
| * @throws IOException |
| */ |
| @Override |
| public int prepareUncheckedAddContent() throws IOException |
| { |
| if (_noContent) |
| return -1; |
| |
| if (_last || _state==STATE_END) |
| return -1; |
| |
| // Handle any unfinished business? |
| Buffer content = _content; |
| if (content != null && content.length()>0 || _bufferChunked) |
| { |
| flushBuffer(); |
| if (content != null && content.length()>0 || _bufferChunked) |
| throw new IllegalStateException("FULL"); |
| } |
| |
| // we better check we have a buffer |
| if (_buffer == null) |
| _buffer = _buffers.getBuffer(); |
| |
| _contentWritten-=_buffer.length(); |
| |
| // Handle the _content |
| if (_head) |
| return Integer.MAX_VALUE; |
| |
| return _buffer.space()-(_contentLength == HttpTokens.CHUNKED_CONTENT?CHUNK_SPACE:0); |
| } |
| |
| /* ------------------------------------------------------------ */ |
| @Override |
| public boolean isBufferFull() |
| { |
| // Should we flush the buffers? |
| return super.isBufferFull() || _bufferChunked || _bypass || (_contentLength == HttpTokens.CHUNKED_CONTENT && _buffer != null && _buffer.space() < CHUNK_SPACE); |
| } |
| |
| /* ------------------------------------------------------------ */ |
| public void send1xx(int code) throws IOException |
| { |
| if (_state != STATE_HEADER) |
| return; |
| |
| if (code<100||code>199) |
| throw new IllegalArgumentException("!1xx"); |
| Status status=__status[code]; |
| if (status==null) |
| throw new IllegalArgumentException(code+"?"); |
| |
| // get a header buffer |
| if (_header == null) |
| _header = _buffers.getHeader(); |
| |
| _header.put(status._responseLine); |
| _header.put(HttpTokens.CRLF); |
| |
| try |
| { |
| // nasty semi busy flush! |
| while(_header.length()>0) |
| { |
| int len = _endp.flush(_header); |
| if (len<0) |
| throw new EofException(); |
| if (len==0) |
| Thread.sleep(100); |
| } |
| } |
| catch(InterruptedException e) |
| { |
| LOG.debug(e); |
| throw new InterruptedIOException(e.toString()); |
| } |
| } |
| |
| /* ------------------------------------------------------------ */ |
| @Override |
| public boolean isRequest() |
| { |
| return _method!=null; |
| } |
| |
| /* ------------------------------------------------------------ */ |
| @Override |
| public boolean isResponse() |
| { |
| return _method==null; |
| } |
| |
| /* ------------------------------------------------------------ */ |
| @Override |
| public void completeHeader(HttpFields fields, boolean allContentAdded) throws IOException |
| { |
| if (_state != STATE_HEADER) |
| return; |
| |
| // handle a reset |
| if (isResponse() && _status==0) |
| throw new EofException(); |
| |
| if (_last && !allContentAdded) |
| throw new IllegalStateException("last?"); |
| _last = _last | allContentAdded; |
| |
| // get a header buffer |
| if (_header == null) |
| _header = _buffers.getHeader(); |
| |
| boolean has_server = false; |
| |
| try |
| { |
| if (isRequest()) |
| { |
| _persistent=true; |
| |
| if (_version == HttpVersions.HTTP_0_9_ORDINAL) |
| { |
| _contentLength = HttpTokens.NO_CONTENT; |
| _header.put(_method); |
| _header.put((byte)' '); |
| _header.put(_uri.getBytes("UTF-8")); // TODO check |
| _header.put(HttpTokens.CRLF); |
| _state = STATE_FLUSHING; |
| _noContent=true; |
| return; |
| } |
| else |
| { |
| _header.put(_method); |
| _header.put((byte)' '); |
| _header.put(_uri.getBytes("UTF-8")); // TODO check |
| _header.put((byte)' '); |
| _header.put(_version==HttpVersions.HTTP_1_0_ORDINAL?HttpVersions.HTTP_1_0_BUFFER:HttpVersions.HTTP_1_1_BUFFER); |
| _header.put(HttpTokens.CRLF); |
| } |
| } |
| else |
| { |
| // Responses |
| if (_version == HttpVersions.HTTP_0_9_ORDINAL) |
| { |
| _persistent = false; |
| _contentLength = HttpTokens.EOF_CONTENT; |
| _state = STATE_CONTENT; |
| return; |
| } |
| else |
| { |
| if (_persistent==null) |
| _persistent= (_version > HttpVersions.HTTP_1_0_ORDINAL); |
| |
| // add response line |
| Status status = _status<__status.length?__status[_status]:null; |
| |
| if (status==null) |
| { |
| _header.put(HttpVersions.HTTP_1_1_BUFFER); |
| _header.put((byte) ' '); |
| _header.put((byte) ('0' + _status / 100)); |
| _header.put((byte) ('0' + (_status % 100) / 10)); |
| _header.put((byte) ('0' + (_status % 10))); |
| _header.put((byte) ' '); |
| if (_reason==null) |
| { |
| _header.put((byte) ('0' + _status / 100)); |
| _header.put((byte) ('0' + (_status % 100) / 10)); |
| _header.put((byte) ('0' + (_status % 10))); |
| } |
| else |
| _header.put(_reason); |
| _header.put(HttpTokens.CRLF); |
| } |
| else |
| { |
| if (_reason==null) |
| _header.put(status._responseLine); |
| else |
| { |
| _header.put(status._schemeCode); |
| _header.put(_reason); |
| _header.put(HttpTokens.CRLF); |
| } |
| } |
| |
| if (_status<200 && _status>=100 ) |
| { |
| _noContent=true; |
| _content=null; |
| if (_buffer!=null) |
| _buffer.clear(); |
| // end the header. |
| |
| if (_status!=101 ) |
| { |
| _header.put(HttpTokens.CRLF); |
| _state = STATE_CONTENT; |
| return; |
| } |
| } |
| else if (_status==204 || _status==304) |
| { |
| _noContent=true; |
| _content=null; |
| if (_buffer!=null) |
| _buffer.clear(); |
| } |
| } |
| } |
| |
| // Add headers |
| if (_status>=200 && _date!=null) |
| { |
| _header.put(HttpHeaders.DATE_BUFFER); |
| _header.put((byte)':'); |
| _header.put((byte)' '); |
| _header.put(_date); |
| _header.put(CRLF); |
| } |
| |
| // key field values |
| HttpFields.Field content_length = null; |
| HttpFields.Field transfer_encoding = null; |
| boolean keep_alive = false; |
| boolean close=false; |
| boolean content_type=false; |
| StringBuilder connection = null; |
| |
| if (fields != null) |
| { |
| int s=fields.size(); |
| for (int f=0;f<s;f++) |
| { |
| HttpFields.Field field = fields.getField(f); |
| if (field==null) |
| continue; |
| |
| switch (field.getNameOrdinal()) |
| { |
| case HttpHeaders.CONTENT_LENGTH_ORDINAL: |
| content_length = field; |
| _contentLength = field.getLongValue(); |
| |
| if (_contentLength < _contentWritten || _last && _contentLength != _contentWritten) |
| content_length = null; |
| |
| // write the field to the header buffer |
| field.putTo(_header); |
| break; |
| |
| case HttpHeaders.CONTENT_TYPE_ORDINAL: |
| if (BufferUtil.isPrefix(MimeTypes.MULTIPART_BYTERANGES_BUFFER, field.getValueBuffer())) _contentLength = HttpTokens.SELF_DEFINING_CONTENT; |
| |
| // write the field to the header buffer |
| content_type=true; |
| field.putTo(_header); |
| break; |
| |
| case HttpHeaders.TRANSFER_ENCODING_ORDINAL: |
| if (_version == HttpVersions.HTTP_1_1_ORDINAL) |
| transfer_encoding = field; |
| // Do NOT add yet! |
| break; |
| |
| case HttpHeaders.CONNECTION_ORDINAL: |
| if (isRequest()) |
| field.putTo(_header); |
| |
| int connection_value = field.getValueOrdinal(); |
| switch (connection_value) |
| { |
| case -1: |
| { |
| String[] values = field.getValue().split(","); |
| for (int i=0;values!=null && i<values.length;i++) |
| { |
| CachedBuffer cb = HttpHeaderValues.CACHE.get(values[i].trim()); |
| |
| if (cb!=null) |
| { |
| switch(cb.getOrdinal()) |
| { |
| case HttpHeaderValues.CLOSE_ORDINAL: |
| close=true; |
| if (isResponse()) |
| _persistent=false; |
| keep_alive=false; |
| if (!_persistent && isResponse() && _contentLength == HttpTokens.UNKNOWN_CONTENT) |
| _contentLength = HttpTokens.EOF_CONTENT; |
| break; |
| |
| case HttpHeaderValues.KEEP_ALIVE_ORDINAL: |
| if (_version == HttpVersions.HTTP_1_0_ORDINAL) |
| { |
| keep_alive = true; |
| if (isResponse()) |
| _persistent = true; |
| } |
| break; |
| |
| default: |
| if (connection==null) |
| connection=new StringBuilder(); |
| else |
| connection.append(','); |
| connection.append(values[i]); |
| } |
| } |
| else |
| { |
| if (connection==null) |
| connection=new StringBuilder(); |
| else |
| connection.append(','); |
| connection.append(values[i]); |
| } |
| } |
| |
| break; |
| } |
| case HttpHeaderValues.UPGRADE_ORDINAL: |
| { |
| // special case for websocket connection ordering |
| if (isResponse()) |
| { |
| field.putTo(_header); |
| continue; |
| } |
| } |
| case HttpHeaderValues.CLOSE_ORDINAL: |
| { |
| close=true; |
| if (isResponse()) |
| _persistent=false; |
| if (!_persistent && isResponse() && _contentLength == HttpTokens.UNKNOWN_CONTENT) |
| _contentLength = HttpTokens.EOF_CONTENT; |
| break; |
| } |
| case HttpHeaderValues.KEEP_ALIVE_ORDINAL: |
| { |
| if (_version == HttpVersions.HTTP_1_0_ORDINAL) |
| { |
| keep_alive = true; |
| if (isResponse()) |
| _persistent=true; |
| } |
| break; |
| } |
| default: |
| { |
| if (connection==null) |
| connection=new StringBuilder(); |
| else |
| connection.append(','); |
| connection.append(field.getValue()); |
| } |
| } |
| |
| // Do NOT add yet! |
| break; |
| |
| case HttpHeaders.SERVER_ORDINAL: |
| if (getSendServerVersion()) |
| { |
| has_server=true; |
| field.putTo(_header); |
| } |
| break; |
| |
| default: |
| // write the field to the header buffer |
| field.putTo(_header); |
| } |
| } |
| } |
| |
| // Calculate how to end _content and connection, _content length and transfer encoding |
| // settings. |
| // From RFC 2616 4.4: |
| // 1. No body for 1xx, 204, 304 & HEAD response |
| // 2. Force _content-length? |
| // 3. If Transfer-Encoding!=identity && HTTP/1.1 && !HttpConnection==close then chunk |
| // 4. Content-Length |
| // 5. multipart/byteranges |
| // 6. close |
| switch ((int) _contentLength) |
| { |
| case HttpTokens.UNKNOWN_CONTENT: |
| // It may be that we have no _content, or perhaps _content just has not been |
| // written yet? |
| |
| // Response known not to have a body |
| if (_contentWritten == 0 && isResponse() && (_status < 200 || _status == 204 || _status == 304)) |
| _contentLength = HttpTokens.NO_CONTENT; |
| else if (_last) |
| { |
| // we have seen all the _content there is |
| _contentLength = _contentWritten; |
| if (content_length == null && (isResponse() || _contentLength>0 || content_type ) && !_noContent) |
| { |
| // known length but not actually set. |
| _header.put(HttpHeaders.CONTENT_LENGTH_BUFFER); |
| _header.put(HttpTokens.COLON); |
| _header.put((byte) ' '); |
| BufferUtil.putDecLong(_header, _contentLength); |
| _header.put(HttpTokens.CRLF); |
| } |
| } |
| else |
| { |
| // No idea, so we must assume that a body is coming |
| _contentLength = (!_persistent || _version < HttpVersions.HTTP_1_1_ORDINAL ) ? HttpTokens.EOF_CONTENT : HttpTokens.CHUNKED_CONTENT; |
| if (isRequest() && _contentLength==HttpTokens.EOF_CONTENT) |
| { |
| _contentLength=HttpTokens.NO_CONTENT; |
| _noContent=true; |
| } |
| } |
| break; |
| |
| case HttpTokens.NO_CONTENT: |
| if (content_length == null && isResponse() && _status >= 200 && _status != 204 && _status != 304) |
| _header.put(CONTENT_LENGTH_0); |
| break; |
| |
| case HttpTokens.EOF_CONTENT: |
| _persistent = isRequest(); |
| break; |
| |
| case HttpTokens.CHUNKED_CONTENT: |
| break; |
| |
| default: |
| // TODO - maybe allow forced chunking by setting te ??? |
| break; |
| } |
| |
| // Add transfer_encoding if needed |
| if (_contentLength == HttpTokens.CHUNKED_CONTENT) |
| { |
| // try to use user supplied encoding as it may have other values. |
| if (transfer_encoding != null && HttpHeaderValues.CHUNKED_ORDINAL != transfer_encoding.getValueOrdinal()) |
| { |
| String c = transfer_encoding.getValue(); |
| if (c.endsWith(HttpHeaderValues.CHUNKED)) |
| transfer_encoding.putTo(_header); |
| else |
| throw new IllegalArgumentException("BAD TE"); |
| } |
| else |
| _header.put(TRANSFER_ENCODING_CHUNKED); |
| } |
| |
| // Handle connection if need be |
| if (_contentLength==HttpTokens.EOF_CONTENT) |
| { |
| keep_alive=false; |
| _persistent=false; |
| } |
| |
| if (isResponse()) |
| { |
| if (!_persistent && (close || _version > HttpVersions.HTTP_1_0_ORDINAL)) |
| { |
| _header.put(CONNECTION_CLOSE); |
| if (connection!=null) |
| { |
| _header.setPutIndex(_header.putIndex()-2); |
| _header.put((byte)','); |
| _header.put(connection.toString().getBytes()); |
| _header.put(CRLF); |
| } |
| } |
| else if (keep_alive) |
| { |
| _header.put(CONNECTION_KEEP_ALIVE); |
| if (connection!=null) |
| { |
| _header.setPutIndex(_header.putIndex()-2); |
| _header.put((byte)','); |
| _header.put(connection.toString().getBytes()); |
| _header.put(CRLF); |
| } |
| } |
| else if (connection!=null) |
| { |
| _header.put(CONNECTION_); |
| _header.put(connection.toString().getBytes()); |
| _header.put(CRLF); |
| } |
| } |
| |
| if (!has_server && _status>199 && getSendServerVersion()) |
| _header.put(SERVER); |
| |
| // end the header. |
| _header.put(HttpTokens.CRLF); |
| _state = STATE_CONTENT; |
| |
| } |
| catch(ArrayIndexOutOfBoundsException e) |
| { |
| throw new RuntimeException("Header>"+_header.capacity(),e); |
| } |
| } |
| |
| /* ------------------------------------------------------------ */ |
| /** |
| * Complete the message. |
| * |
| * @throws IOException |
| */ |
| @Override |
| public void complete() throws IOException |
| { |
| if (_state == STATE_END) |
| return; |
| |
| super.complete(); |
| |
| if (_state < STATE_FLUSHING) |
| { |
| _state = STATE_FLUSHING; |
| if (_contentLength == HttpTokens.CHUNKED_CONTENT) |
| _needEOC = true; |
| } |
| |
| flushBuffer(); |
| } |
| |
| /* ------------------------------------------------------------ */ |
| @Override |
| public int flushBuffer() throws IOException |
| { |
| try |
| { |
| |
| if (_state == STATE_HEADER) |
| throw new IllegalStateException("State==HEADER"); |
| |
| prepareBuffers(); |
| |
| if (_endp == null) |
| { |
| if (_needCRLF && _buffer!=null) |
| _buffer.put(HttpTokens.CRLF); |
| if (_needEOC && _buffer!=null && !_head) |
| _buffer.put(LAST_CHUNK); |
| _needCRLF=false; |
| _needEOC=false; |
| return 0; |
| } |
| |
| int total= 0; |
| |
| int len = -1; |
| int to_flush = flushMask(); |
| int last_flush; |
| |
| do |
| { |
| last_flush=to_flush; |
| switch (to_flush) |
| { |
| case 7: |
| throw new IllegalStateException(); // should never happen! |
| case 6: |
| len = _endp.flush(_header, _buffer, null); |
| break; |
| case 5: |
| len = _endp.flush(_header, _content, null); |
| break; |
| case 4: |
| len = _endp.flush(_header); |
| break; |
| case 3: |
| len = _endp.flush(_buffer, _content, null); |
| break; |
| case 2: |
| len = _endp.flush(_buffer); |
| break; |
| case 1: |
| len = _endp.flush(_content); |
| break; |
| case 0: |
| { |
| len=0; |
| // Nothing more we can write now. |
| if (_header != null) |
| _header.clear(); |
| |
| _bypass = false; |
| _bufferChunked = false; |
| |
| if (_buffer != null) |
| { |
| _buffer.clear(); |
| if (_contentLength == HttpTokens.CHUNKED_CONTENT) |
| { |
| // reserve some space for the chunk header |
| _buffer.setPutIndex(CHUNK_SPACE); |
| _buffer.setGetIndex(CHUNK_SPACE); |
| |
| // Special case handling for small left over buffer from |
| // an addContent that caused a buffer flush. |
| if (_content != null && _content.length() < _buffer.space() && _state != STATE_FLUSHING) |
| { |
| _buffer.put(_content); |
| _content.clear(); |
| _content=null; |
| } |
| } |
| } |
| |
| // Are we completely finished for now? |
| if (!_needCRLF && !_needEOC && (_content==null || _content.length()==0)) |
| { |
| if (_state == STATE_FLUSHING) |
| _state = STATE_END; |
| |
| if (_state==STATE_END && _persistent != null && !_persistent && _status!=100 && _method==null) |
| _endp.shutdownOutput(); |
| } |
| else |
| // Try to prepare more to write. |
| prepareBuffers(); |
| } |
| |
| } |
| |
| if (len > 0) |
| total+=len; |
| |
| to_flush = flushMask(); |
| } |
| // loop while progress is being made (OR we have prepared some buffers that might make progress) |
| while (len>0 || (to_flush!=0 && last_flush==0)); |
| |
| return total; |
| } |
| catch (IOException e) |
| { |
| LOG.ignore(e); |
| throw (e instanceof EofException) ? e:new EofException(e); |
| } |
| } |
| |
| /* ------------------------------------------------------------ */ |
| private int flushMask() |
| { |
| return ((_header != null && _header.length() > 0)?4:0) |
| | ((_buffer != null && _buffer.length() > 0)?2:0) |
| | ((_bypass && _content != null && _content.length() > 0)?1:0); |
| } |
| |
| /* ------------------------------------------------------------ */ |
| private void prepareBuffers() |
| { |
| // if we are not flushing an existing chunk |
| if (!_bufferChunked) |
| { |
| // Refill buffer if possible |
| if (!_bypass && _content != null && _content.length() > 0 && _buffer != null && _buffer.space() > 0) |
| { |
| int len = _buffer.put(_content); |
| _content.skip(len); |
| if (_content.length() == 0) |
| _content = null; |
| } |
| |
| // Chunk buffer if need be |
| if (_contentLength == HttpTokens.CHUNKED_CONTENT) |
| { |
| if (_bypass && (_buffer==null||_buffer.length()==0) && _content!=null) |
| { |
| // this is a bypass write |
| int size = _content.length(); |
| _bufferChunked = true; |
| |
| if (_header == null) |
| _header = _buffers.getHeader(); |
| |
| // if we need CRLF add this to header |
| if (_needCRLF) |
| { |
| if (_header.length() > 0) throw new IllegalStateException("EOC"); |
| _header.put(HttpTokens.CRLF); |
| _needCRLF = false; |
| } |
| // Add the chunk size to the header |
| BufferUtil.putHexInt(_header, size); |
| _header.put(HttpTokens.CRLF); |
| |
| // Need a CRLF after the content |
| _needCRLF=true; |
| } |
| else if (_buffer!=null) |
| { |
| int size = _buffer.length(); |
| if (size > 0) |
| { |
| // Prepare a chunk! |
| _bufferChunked = true; |
| |
| // Did we leave space at the start of the buffer. |
| //noinspection ConstantConditions |
| if (_buffer.getIndex() == CHUNK_SPACE) |
| { |
| // Oh yes, goodie! let's use it then! |
| _buffer.poke(_buffer.getIndex() - 2, HttpTokens.CRLF, 0, 2); |
| _buffer.setGetIndex(_buffer.getIndex() - 2); |
| BufferUtil.prependHexInt(_buffer, size); |
| |
| if (_needCRLF) |
| { |
| _buffer.poke(_buffer.getIndex() - 2, HttpTokens.CRLF, 0, 2); |
| _buffer.setGetIndex(_buffer.getIndex() - 2); |
| _needCRLF = false; |
| } |
| } |
| else |
| { |
| // No space so lets use a header buffer. |
| if (_header == null) |
| _header = _buffers.getHeader(); |
| |
| if (_needCRLF) |
| { |
| if (_header.length() > 0) throw new IllegalStateException("EOC"); |
| _header.put(HttpTokens.CRLF); |
| _needCRLF = false; |
| } |
| BufferUtil.putHexInt(_header, size); |
| _header.put(HttpTokens.CRLF); |
| } |
| |
| // Add end chunk trailer. |
| if (_buffer.space() >= 2) |
| _buffer.put(HttpTokens.CRLF); |
| else |
| _needCRLF = true; |
| } |
| } |
| |
| // If we need EOC and everything written |
| if (_needEOC && (_content == null || _content.length() == 0)) |
| { |
| if (_header == null && _buffer == null) |
| _header = _buffers.getHeader(); |
| |
| if (_needCRLF) |
| { |
| if (_buffer == null && _header != null && _header.space() >= HttpTokens.CRLF.length) |
| { |
| _header.put(HttpTokens.CRLF); |
| _needCRLF = false; |
| } |
| else if (_buffer!=null && _buffer.space() >= HttpTokens.CRLF.length) |
| { |
| _buffer.put(HttpTokens.CRLF); |
| _needCRLF = false; |
| } |
| } |
| |
| if (!_needCRLF && _needEOC) |
| { |
| if (_buffer == null && _header != null && _header.space() >= LAST_CHUNK.length) |
| { |
| if (!_head) |
| { |
| _header.put(LAST_CHUNK); |
| _bufferChunked=true; |
| } |
| _needEOC = false; |
| } |
| else if (_buffer!=null && _buffer.space() >= LAST_CHUNK.length) |
| { |
| if (!_head) |
| { |
| _buffer.put(LAST_CHUNK); |
| _bufferChunked=true; |
| } |
| _needEOC = false; |
| } |
| } |
| } |
| } |
| } |
| |
| if (_content != null && _content.length() == 0) |
| _content = null; |
| |
| } |
| |
| public int getBytesBuffered() |
| { |
| return(_header==null?0:_header.length())+ |
| (_buffer==null?0:_buffer.length())+ |
| (_content==null?0:_content.length()); |
| } |
| |
| public boolean isEmpty() |
| { |
| return (_header==null||_header.length()==0) && |
| (_buffer==null||_buffer.length()==0) && |
| (_content==null||_content.length()==0); |
| } |
| |
| @Override |
| public String toString() |
| { |
| Buffer header=_header; |
| Buffer buffer=_buffer; |
| Buffer content=_content; |
| return String.format("%s{s=%d,h=%d,b=%d,c=%d}", |
| getClass().getSimpleName(), |
| _state, |
| header == null ? -1 : header.length(), |
| buffer == null ? -1 : buffer.length(), |
| content == null ? -1 : content.length()); |
| } |
| } |
