Mercurial Hosting > luan
view src/org/eclipse/jetty/http/HttpParser.java @ 815:07c82fabc46b
remove Authentication
author | Franklin Schmidt <fschmidt@gmail.com> |
---|---|
date | Fri, 09 Sep 2016 14:27:05 -0600 |
parents | 3428c60d7cfc |
children | 8e9db0bbf4f9 |
line wrap: on
line source
// // ======================================================================== // 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 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.io.View; import org.eclipse.jetty.io.bio.StreamEndPoint; import org.eclipse.jetty.util.StringUtil; import org.eclipse.jetty.util.log.Log; import org.eclipse.jetty.util.log.Logger; public class HttpParser implements Parser { private static final Logger LOG = Log.getLogger(HttpParser.class); // States public static final int STATE_START=-14; public static final int STATE_FIELD0=-13; public static final int STATE_SPACE1=-12; public static final int STATE_STATUS=-11; public static final int STATE_URI=-10; public static final int STATE_SPACE2=-9; public static final int STATE_END0=-8; public static final int STATE_END1=-7; public static final int STATE_FIELD2=-6; public static final int STATE_HEADER=-5; public static final int STATE_HEADER_NAME=-4; public static final int STATE_HEADER_IN_NAME=-3; public static final int STATE_HEADER_VALUE=-2; public static final int STATE_HEADER_IN_VALUE=-1; public static final int STATE_END=0; public static final int STATE_EOF_CONTENT=1; public static final int STATE_CONTENT=2; public static final int STATE_CHUNKED_CONTENT=3; public static final int STATE_CHUNK_SIZE=4; public static final int STATE_CHUNK_PARAMS=5; public static final int STATE_CHUNK=6; public static final int STATE_SEEKING_EOF=7; private final EventHandler _handler; private final Buffers _buffers; // source of buffers private final EndPoint _endp; private Buffer _header; // Buffer for header data (and small _content) private Buffer _body; // Buffer for large content private Buffer _buffer; // The current buffer in use (either _header or _content) private CachedBuffer _cached; private final View.CaseInsensitive _tok0; // Saved token: header name, request method or response version private final View.CaseInsensitive _tok1; // Saved token: header value, request URI or response code private String _multiLineValue; private int _responseStatus; // If >0 then we are parsing a response private boolean _forceContentBuffer; private boolean _persistent; /* ------------------------------------------------------------------------------- */ protected final View _contentView=new View(); // View of the content in the buffer for {@link Input} protected int _state=STATE_START; protected byte _eol; protected int _length; protected long _contentLength; protected long _contentPosition; protected int _chunkLength; protected int _chunkPosition; private boolean _headResponse; /* ------------------------------------------------------------------------------- */ /** * Constructor. */ public HttpParser(Buffer buffer, EventHandler handler) { _endp=null; _buffers=null; _header=buffer; _buffer=buffer; _handler=handler; _tok0=new View.CaseInsensitive(_header); _tok1=new View.CaseInsensitive(_header); } /* ------------------------------------------------------------------------------- */ /** * Constructor. * @param buffers the buffers to use * @param endp the endpoint * @param handler the even handler */ public HttpParser(Buffers buffers, EndPoint endp, EventHandler handler) { _buffers=buffers; _endp=endp; _handler=handler; _tok0=new View.CaseInsensitive(); _tok1=new View.CaseInsensitive(); } /* ------------------------------------------------------------------------------- */ public long getContentLength() { return _contentLength; } /* ------------------------------------------------------------ */ public long getContentRead() { return _contentPosition; } /* ------------------------------------------------------------ */ /** Set if a HEAD response is expected * @param head */ public void setHeadResponse(boolean head) { _headResponse=head; } /* ------------------------------------------------------------------------------- */ public int getState() { return _state; } /* ------------------------------------------------------------------------------- */ public boolean inContentState() { return _state > 0; } /* ------------------------------------------------------------------------------- */ public boolean inHeaderState() { return _state < 0; } /* ------------------------------------------------------------------------------- */ public boolean isChunking() { return _contentLength==HttpTokens.CHUNKED_CONTENT; } /* ------------------------------------------------------------ */ public boolean isIdle() { return isState(STATE_START); } /* ------------------------------------------------------------ */ public boolean isComplete() { return isState(STATE_END); } /* ------------------------------------------------------------ */ public boolean isMoreInBuffer() throws IOException { return ( _header!=null && _header.hasContent() || _body!=null && _body.hasContent()); } /* ------------------------------------------------------------------------------- */ public boolean isState(int state) { return _state == state; } /* ------------------------------------------------------------------------------- */ public boolean isPersistent() { return _persistent; } /* ------------------------------------------------------------------------------- */ public void setPersistent(boolean persistent) { _persistent = persistent; if (!_persistent &&(_state==STATE_END || _state==STATE_START)) _state=STATE_SEEKING_EOF; } /* ------------------------------------------------------------------------------- */ /** * Parse until {@link #STATE_END END} state. * If the parser is already in the END state, then it is {@link #reset reset} and re-parsed. * @throws IllegalStateException If the buffers have already been partially parsed. */ public void parse() throws IOException { if (_state==STATE_END) reset(); if (_state!=STATE_START) throw new IllegalStateException("!START"); // continue parsing while (_state != STATE_END) if (parseNext()<0) return; } /* ------------------------------------------------------------------------------- */ /** * Parse until END state. * This method will parse any remaining content in the current buffer as long as there is * no unconsumed content. It does not care about the {@link #getState current state} of the parser. * @see #parse * @see #parseNext */ public boolean parseAvailable() throws IOException { boolean progress=parseNext()>0; // continue parsing while (!isComplete() && _buffer!=null && _buffer.length()>0 && !_contentView.hasContent()) { progress |= parseNext()>0; } return progress; } /* ------------------------------------------------------------------------------- */ /** * Parse until next Event. * @return an indication of progress <0 EOF, 0 no progress, >0 progress. */ public int parseNext() throws IOException { try { int progress=0; if (_state == STATE_END) return 0; if (_buffer==null) _buffer=getHeaderBuffer(); if (_state == STATE_CONTENT && _contentPosition == _contentLength) { _state=STATE_END; _handler.messageComplete(_contentPosition); return 1; } int length=_buffer.length(); // Fill buffer if we can if (length == 0) { int filled=-1; IOException ex=null; try { filled=fill(); LOG.debug("filled {}/{}",filled,_buffer.length()); } catch(IOException e) { LOG.debug(this.toString(),e); ex=e; } if (filled > 0 ) progress++; else if (filled < 0 ) { _persistent=false; // do we have content to deliver? if (_state>STATE_END) { if (_buffer.length()>0 && !_headResponse) { Buffer chunk=_buffer.get(_buffer.length()); _contentPosition += chunk.length(); _contentView.update(chunk); _handler.content(chunk); // May recurse here } } // was this unexpected? switch(_state) { case STATE_END: case STATE_SEEKING_EOF: _state=STATE_END; break; case STATE_EOF_CONTENT: _state=STATE_END; _handler.messageComplete(_contentPosition); break; default: _state=STATE_END; if (!_headResponse) _handler.earlyEOF(); _handler.messageComplete(_contentPosition); } if (ex!=null) throw ex; if (!isComplete() && !isIdle()) throw new EofException(); return -1; } length=_buffer.length(); } // Handle header states byte ch; byte[] array=_buffer.array(); int last=_state; while (_state<STATE_END && length-->0) { if (last!=_state) { progress++; last=_state; } ch=_buffer.get(); if (_eol == HttpTokens.CARRIAGE_RETURN) { if (ch == HttpTokens.LINE_FEED) { _eol=HttpTokens.LINE_FEED; continue; } throw new HttpException(HttpStatus.BAD_REQUEST_400); } _eol=0; switch (_state) { case STATE_START: _contentLength=HttpTokens.UNKNOWN_CONTENT; _cached=null; if (ch > HttpTokens.SPACE || ch<0) { _buffer.mark(); _state=STATE_FIELD0; } break; case STATE_FIELD0: if (ch == HttpTokens.SPACE) { _tok0.update(_buffer.markIndex(), _buffer.getIndex() - 1); _responseStatus=HttpVersions.CACHE.get(_tok0)==null?-1:0; _state=STATE_SPACE1; continue; } else if (ch < HttpTokens.SPACE && ch>=0) { throw new HttpException(HttpStatus.BAD_REQUEST_400); } break; case STATE_SPACE1: if (ch > HttpTokens.SPACE || ch<0) { _buffer.mark(); if (_responseStatus>=0) { _state=STATE_STATUS; _responseStatus=ch-'0'; } else _state=STATE_URI; } else if (ch < HttpTokens.SPACE) { throw new HttpException(HttpStatus.BAD_REQUEST_400); } break; case STATE_STATUS: if (ch == HttpTokens.SPACE) { _tok1.update(_buffer.markIndex(), _buffer.getIndex() - 1); _state=STATE_SPACE2; continue; } else if (ch>='0' && ch<='9') { _responseStatus=_responseStatus*10+(ch-'0'); continue; } else if (ch < HttpTokens.SPACE && ch>=0) { _handler.startResponse(HttpMethods.CACHE.lookup(_tok0), _responseStatus, null); _eol=ch; _state=STATE_HEADER; _tok0.setPutIndex(_tok0.getIndex()); _tok1.setPutIndex(_tok1.getIndex()); _multiLineValue=null; continue; } // not a digit, so must be a URI _state=STATE_URI; _responseStatus=-1; break; case STATE_URI: if (ch == HttpTokens.SPACE) { _tok1.update(_buffer.markIndex(), _buffer.getIndex() - 1); _state=STATE_SPACE2; continue; } else if (ch < HttpTokens.SPACE && ch>=0) { // HTTP/0.9 _handler.startRequest(HttpMethods.CACHE.lookup(_tok0), _buffer.sliceFromMark(), null); _persistent=false; _state=STATE_SEEKING_EOF; _handler.headerComplete(); _handler.messageComplete(_contentPosition); return 1; } break; case STATE_SPACE2: if (ch > HttpTokens.SPACE || ch<0) { _buffer.mark(); _state=STATE_FIELD2; } else if (ch < HttpTokens.SPACE) { if (_responseStatus>0) { _handler.startResponse(HttpMethods.CACHE.lookup(_tok0), _responseStatus, null); _eol=ch; _state=STATE_HEADER; _tok0.setPutIndex(_tok0.getIndex()); _tok1.setPutIndex(_tok1.getIndex()); _multiLineValue=null; } else { // HTTP/0.9 _handler.startRequest(HttpMethods.CACHE.lookup(_tok0), _tok1, null); _persistent=false; _state=STATE_SEEKING_EOF; _handler.headerComplete(); _handler.messageComplete(_contentPosition); return 1; } } break; case STATE_FIELD2: if (ch == HttpTokens.CARRIAGE_RETURN || ch == HttpTokens.LINE_FEED) { Buffer version; if (_responseStatus>0) _handler.startResponse(version=HttpVersions.CACHE.lookup(_tok0), _responseStatus,_buffer.sliceFromMark()); else _handler.startRequest(HttpMethods.CACHE.lookup(_tok0), _tok1, version=HttpVersions.CACHE.lookup(_buffer.sliceFromMark())); _eol=ch; _persistent=HttpVersions.CACHE.getOrdinal(version)>=HttpVersions.HTTP_1_1_ORDINAL; _state=STATE_HEADER; _tok0.setPutIndex(_tok0.getIndex()); _tok1.setPutIndex(_tok1.getIndex()); _multiLineValue=null; continue; } break; case STATE_HEADER: switch(ch) { case HttpTokens.COLON: case HttpTokens.SPACE: case HttpTokens.TAB: { // header value without name - continuation? _length=-1; _state=STATE_HEADER_VALUE; break; } default: { // handler last header if any if (_cached!=null || _tok0.length() > 0 || _tok1.length() > 0 || _multiLineValue != null) { Buffer header=_cached!=null?_cached:HttpHeaders.CACHE.lookup(_tok0); _cached=null; Buffer value=_multiLineValue == null ? _tok1 : new ByteArrayBuffer(_multiLineValue); int ho=HttpHeaders.CACHE.getOrdinal(header); if (ho >= 0) { int vo; switch (ho) { case HttpHeaders.CONTENT_LENGTH_ORDINAL: if (_contentLength != HttpTokens.CHUNKED_CONTENT ) { try { _contentLength=BufferUtil.toLong(value); } catch(NumberFormatException e) { LOG.ignore(e); throw new HttpException(HttpStatus.BAD_REQUEST_400); } if (_contentLength <= 0) _contentLength=HttpTokens.NO_CONTENT; } break; case HttpHeaders.TRANSFER_ENCODING_ORDINAL: value=HttpHeaderValues.CACHE.lookup(value); vo=HttpHeaderValues.CACHE.getOrdinal(value); if (HttpHeaderValues.CHUNKED_ORDINAL == vo) _contentLength=HttpTokens.CHUNKED_CONTENT; else { String c=value.toString(StringUtil.__ISO_8859_1); if (c.endsWith(HttpHeaderValues.CHUNKED)) _contentLength=HttpTokens.CHUNKED_CONTENT; else if (c.indexOf(HttpHeaderValues.CHUNKED) >= 0) throw new HttpException(400,null); } break; case HttpHeaders.CONNECTION_ORDINAL: switch(HttpHeaderValues.CACHE.getOrdinal(value)) { case HttpHeaderValues.CLOSE_ORDINAL: _persistent=false; break; case HttpHeaderValues.KEEP_ALIVE_ORDINAL: _persistent=true; break; case -1: // No match, may be multi valued { for (String v : value.toString().split(",")) { switch(HttpHeaderValues.CACHE.getOrdinal(v.trim())) { case HttpHeaderValues.CLOSE_ORDINAL: _persistent=false; break; case HttpHeaderValues.KEEP_ALIVE_ORDINAL: _persistent=true; break; } } break; } } } } _handler.parsedHeader(header, value); _tok0.setPutIndex(_tok0.getIndex()); _tok1.setPutIndex(_tok1.getIndex()); _multiLineValue=null; } _buffer.setMarkIndex(-1); // now handle ch if (ch == HttpTokens.CARRIAGE_RETURN || ch == HttpTokens.LINE_FEED) { // is it a response that cannot have a body? if (_responseStatus > 0 && // response (_responseStatus == 304 || // not-modified response _responseStatus == 204 || // no-content response _responseStatus < 200)) // 1xx response _contentLength=HttpTokens.NO_CONTENT; // ignore any other headers set // else if we don't know framing else if (_contentLength == HttpTokens.UNKNOWN_CONTENT) { if (_responseStatus == 0 // request || _responseStatus == 304 // not-modified response || _responseStatus == 204 // no-content response || _responseStatus < 200) // 1xx response _contentLength=HttpTokens.NO_CONTENT; else _contentLength=HttpTokens.EOF_CONTENT; } _contentPosition=0; _eol=ch; if (_eol==HttpTokens.CARRIAGE_RETURN && _buffer.hasContent() && _buffer.peek()==HttpTokens.LINE_FEED) _eol=_buffer.get(); // We convert _contentLength to an int for this switch statement because // we don't care about the amount of data available just whether there is some. switch (_contentLength > Integer.MAX_VALUE ? Integer.MAX_VALUE : (int) _contentLength) { case HttpTokens.EOF_CONTENT: _state=STATE_EOF_CONTENT; _handler.headerComplete(); // May recurse here ! break; case HttpTokens.CHUNKED_CONTENT: _state=STATE_CHUNKED_CONTENT; _handler.headerComplete(); // May recurse here ! break; case HttpTokens.NO_CONTENT: _handler.headerComplete(); _state=_persistent||(_responseStatus>=100&&_responseStatus<200)?STATE_END:STATE_SEEKING_EOF; _handler.messageComplete(_contentPosition); return 1; default: _state=STATE_CONTENT; _handler.headerComplete(); // May recurse here ! break; } return 1; } else { // New header _length=1; _buffer.mark(); _state=STATE_HEADER_NAME; // try cached name! if (array!=null) { _cached=HttpHeaders.CACHE.getBest(array, _buffer.markIndex(), length+1); if (_cached!=null) { _length=_cached.length(); _buffer.setGetIndex(_buffer.markIndex()+_length); length=_buffer.length(); } } } } } break; case STATE_HEADER_NAME: switch(ch) { case HttpTokens.CARRIAGE_RETURN: case HttpTokens.LINE_FEED: if (_length > 0) _tok0.update(_buffer.markIndex(), _buffer.markIndex() + _length); _eol=ch; _state=STATE_HEADER; break; case HttpTokens.COLON: if (_length > 0 && _cached==null) _tok0.update(_buffer.markIndex(), _buffer.markIndex() + _length); _length=-1; _state=STATE_HEADER_VALUE; break; case HttpTokens.SPACE: case HttpTokens.TAB: break; default: { _cached=null; if (_length == -1) _buffer.mark(); _length=_buffer.getIndex() - _buffer.markIndex(); _state=STATE_HEADER_IN_NAME; } } break; case STATE_HEADER_IN_NAME: switch(ch) { case HttpTokens.CARRIAGE_RETURN: case HttpTokens.LINE_FEED: if (_length > 0) _tok0.update(_buffer.markIndex(), _buffer.markIndex() + _length); _eol=ch; _state=STATE_HEADER; break; case HttpTokens.COLON: if (_length > 0 && _cached==null) _tok0.update(_buffer.markIndex(), _buffer.markIndex() + _length); _length=-1; _state=STATE_HEADER_VALUE; break; case HttpTokens.SPACE: case HttpTokens.TAB: _state=STATE_HEADER_NAME; break; default: { _cached=null; _length++; } } break; case STATE_HEADER_VALUE: switch(ch) { case HttpTokens.CARRIAGE_RETURN: case HttpTokens.LINE_FEED: if (_length > 0) { if (_tok1.length() == 0) _tok1.update(_buffer.markIndex(), _buffer.markIndex() + _length); else { // Continuation line! if (_multiLineValue == null) _multiLineValue=_tok1.toString(StringUtil.__ISO_8859_1); _tok1.update(_buffer.markIndex(), _buffer.markIndex() + _length); _multiLineValue += " " + _tok1.toString(StringUtil.__ISO_8859_1); } } _eol=ch; _state=STATE_HEADER; break; case HttpTokens.SPACE: case HttpTokens.TAB: break; default: { if (_length == -1) _buffer.mark(); _length=_buffer.getIndex() - _buffer.markIndex(); _state=STATE_HEADER_IN_VALUE; } } break; case STATE_HEADER_IN_VALUE: switch(ch) { case HttpTokens.CARRIAGE_RETURN: case HttpTokens.LINE_FEED: if (_length > 0) { if (_tok1.length() == 0) _tok1.update(_buffer.markIndex(), _buffer.markIndex() + _length); else { // Continuation line! if (_multiLineValue == null) _multiLineValue=_tok1.toString(StringUtil.__ISO_8859_1); _tok1.update(_buffer.markIndex(), _buffer.markIndex() + _length); _multiLineValue += " " + _tok1.toString(StringUtil.__ISO_8859_1); } } _eol=ch; _state=STATE_HEADER; break; case HttpTokens.SPACE: case HttpTokens.TAB: _state=STATE_HEADER_VALUE; break; default: _length++; } break; } } // end of HEADER states loop // ========================== // Handle HEAD response if (_responseStatus>0 && _headResponse) { _state=_persistent||(_responseStatus>=100&&_responseStatus<200)?STATE_END:STATE_SEEKING_EOF; _handler.messageComplete(_contentLength); } // ========================== // Handle _content length=_buffer.length(); Buffer chunk; last=_state; while (_state > STATE_END && length > 0) { if (last!=_state) { progress++; last=_state; } if (_eol == HttpTokens.CARRIAGE_RETURN && _buffer.peek() == HttpTokens.LINE_FEED) { _eol=_buffer.get(); length=_buffer.length(); continue; } _eol=0; switch (_state) { case STATE_EOF_CONTENT: chunk=_buffer.get(_buffer.length()); _contentPosition += chunk.length(); _contentView.update(chunk); _handler.content(chunk); // May recurse here // TODO adjust the _buffer to keep unconsumed content return 1; case STATE_CONTENT: { long remaining=_contentLength - _contentPosition; if (remaining == 0) { _state=_persistent?STATE_END:STATE_SEEKING_EOF; _handler.messageComplete(_contentPosition); return 1; } if (length > remaining) { // We can cast reamining to an int as we know that it is smaller than // or equal to length which is already an int. length=(int)remaining; } chunk=_buffer.get(length); _contentPosition += chunk.length(); _contentView.update(chunk); _handler.content(chunk); // May recurse here if(_contentPosition == _contentLength) { _state=_persistent?STATE_END:STATE_SEEKING_EOF; _handler.messageComplete(_contentPosition); } // TODO adjust the _buffer to keep unconsumed content return 1; } case STATE_CHUNKED_CONTENT: { ch=_buffer.peek(); if (ch == HttpTokens.CARRIAGE_RETURN || ch == HttpTokens.LINE_FEED) _eol=_buffer.get(); else if (ch <= HttpTokens.SPACE) _buffer.get(); else { _chunkLength=0; _chunkPosition=0; _state=STATE_CHUNK_SIZE; } break; } case STATE_CHUNK_SIZE: { ch=_buffer.get(); if (ch == HttpTokens.CARRIAGE_RETURN || ch == HttpTokens.LINE_FEED) { _eol=ch; if (_chunkLength == 0) { if (_eol==HttpTokens.CARRIAGE_RETURN && _buffer.hasContent() && _buffer.peek()==HttpTokens.LINE_FEED) _eol=_buffer.get(); _state=_persistent?STATE_END:STATE_SEEKING_EOF; _handler.messageComplete(_contentPosition); return 1; } else _state=STATE_CHUNK; } else if (ch <= HttpTokens.SPACE || ch == HttpTokens.SEMI_COLON) _state=STATE_CHUNK_PARAMS; else if (ch >= '0' && ch <= '9') _chunkLength=_chunkLength * 16 + (ch - '0'); else if (ch >= 'a' && ch <= 'f') _chunkLength=_chunkLength * 16 + (10 + ch - 'a'); else if (ch >= 'A' && ch <= 'F') _chunkLength=_chunkLength * 16 + (10 + ch - 'A'); else throw new IOException("bad chunk char: " + ch); break; } case STATE_CHUNK_PARAMS: { ch=_buffer.get(); if (ch == HttpTokens.CARRIAGE_RETURN || ch == HttpTokens.LINE_FEED) { _eol=ch; if (_chunkLength == 0) { if (_eol==HttpTokens.CARRIAGE_RETURN && _buffer.hasContent() && _buffer.peek()==HttpTokens.LINE_FEED) _eol=_buffer.get(); _state=_persistent?STATE_END:STATE_SEEKING_EOF; _handler.messageComplete(_contentPosition); return 1; } else _state=STATE_CHUNK; } break; } case STATE_CHUNK: { int remaining=_chunkLength - _chunkPosition; if (remaining == 0) { _state=STATE_CHUNKED_CONTENT; break; } else if (length > remaining) length=remaining; chunk=_buffer.get(length); _contentPosition += chunk.length(); _chunkPosition += chunk.length(); _contentView.update(chunk); _handler.content(chunk); // May recurse here // TODO adjust the _buffer to keep unconsumed content return 1; } case STATE_SEEKING_EOF: { // Close if there is more data than CRLF if (_buffer.length()>2) { _state=STATE_END; _endp.close(); } else { // or if the data is not white space while (_buffer.length()>0) if (!Character.isWhitespace(_buffer.get())) { _state=STATE_END; _endp.close(); _buffer.clear(); } } _buffer.clear(); break; } } length=_buffer.length(); } return progress; } catch(HttpException e) { _persistent=false; _state=STATE_SEEKING_EOF; throw e; } } /* ------------------------------------------------------------------------------- */ /** fill the buffers from the endpoint * */ protected int fill() throws IOException { // Do we have a buffer? if (_buffer==null) _buffer=getHeaderBuffer(); // Is there unconsumed content in body buffer if (_state>STATE_END && _buffer==_header && _header!=null && !_header.hasContent() && _body!=null && _body.hasContent()) { _buffer=_body; return _buffer.length(); } // Shall we switch to a body buffer? if (_buffer==_header && _state>STATE_END && _header.length()==0 && (_forceContentBuffer || (_contentLength-_contentPosition)>_header.capacity()) && (_body!=null||_buffers!=null)) { if (_body==null) _body=_buffers.getBuffer(); _buffer=_body; } // Do we have somewhere to fill from? if (_endp != null ) { // Shall we compact the body? if (_buffer==_body || _state>STATE_END) { _buffer.compact(); } // Are we full? if (_buffer.space() == 0) { LOG.warn("HttpParser Full for {} ",_endp); _buffer.clear(); throw new HttpException(HttpStatus.REQUEST_ENTITY_TOO_LARGE_413, "Request Entity Too Large: "+(_buffer==_body?"body":"head")); } try { int filled = _endp.fill(_buffer); return filled; } catch(IOException e) { LOG.debug(e); throw (e instanceof EofException) ? e:new EofException(e); } } return -1; } /* ------------------------------------------------------------------------------- */ public void reset() { // reset state _contentView.setGetIndex(_contentView.putIndex()); _state=_persistent?STATE_START:(_endp.isInputShutdown()?STATE_END:STATE_SEEKING_EOF); _contentLength=HttpTokens.UNKNOWN_CONTENT; _contentPosition=0; _length=0; _responseStatus=0; // Consume LF if CRLF if (_eol == HttpTokens.CARRIAGE_RETURN && _buffer!=null && _buffer.hasContent() && _buffer.peek() == HttpTokens.LINE_FEED) _eol=_buffer.get(); if (_body!=null && _body.hasContent()) { // There is content in the body after the end of the request. // This is probably a pipelined header of the next request, so we need to // copy it to the header buffer. if (_header==null) getHeaderBuffer(); else { _header.setMarkIndex(-1); _header.compact(); } int take=_header.space(); if (take>_body.length()) take=_body.length(); _body.peek(_body.getIndex(),take); _body.skip(_header.put(_body.peek(_body.getIndex(),take))); } if (_header!=null) { _header.setMarkIndex(-1); _header.compact(); } if (_body!=null) _body.setMarkIndex(-1); _buffer=_header; returnBuffers(); } /* ------------------------------------------------------------------------------- */ public void returnBuffers() { if (_body!=null && !_body.hasContent() && _body.markIndex()==-1 && _buffers!=null) { if (_buffer==_body) _buffer=_header; if (_buffers!=null) _buffers.returnBuffer(_body); _body=null; } if (_header!=null && !_header.hasContent() && _header.markIndex()==-1 && _buffers!=null) { if (_buffer==_header) _buffer=null; _buffers.returnBuffer(_header); _header=null; } } /* ------------------------------------------------------------------------------- */ public void setState(int state) { this._state=state; _contentLength=HttpTokens.UNKNOWN_CONTENT; } /* ------------------------------------------------------------------------------- */ public String toString(Buffer buf) { return "state=" + _state + " length=" + _length + " buf=" + buf.hashCode(); } /* ------------------------------------------------------------------------------- */ @Override public String toString() { return String.format("%s{s=%d,l=%d,c=%d}", getClass().getSimpleName(), _state, _length, _contentLength); } /* ------------------------------------------------------------ */ public Buffer getHeaderBuffer() { if (_header == null) { _header=_buffers.getHeader(); _tok0.update(_header); _tok1.update(_header); } return _header; } /* ------------------------------------------------------------ */ public Buffer getBodyBuffer() { return _body; } /* ------------------------------------------------------------ */ /** * @param force True if a new buffer will be forced to be used for content and the header buffer will not be used. */ public void setForceContentBuffer(boolean force) { _forceContentBuffer=force; } /* ------------------------------------------------------------ */ public Buffer blockForContent(long maxIdleTime) throws IOException { if (_contentView.length()>0) return _contentView; if (getState() <= STATE_END || isState(STATE_SEEKING_EOF)) return null; try { parseNext(); // parse until some progress is made (or IOException thrown for timeout) while(_contentView.length() == 0 && !(isState(HttpParser.STATE_END)||isState(HttpParser.STATE_SEEKING_EOF)) && _endp!=null && _endp.isOpen()) { if (!_endp.isBlocking()) { if (parseNext()>0) continue; if (!_endp.blockReadable(maxIdleTime)) { _endp.close(); throw new EofException("timeout"); } } parseNext(); } } catch(IOException e) { // TODO is this needed? _endp.close(); throw e; } return _contentView.length()>0?_contentView:null; } /* ------------------------------------------------------------ */ /* (non-Javadoc) * @see java.io.InputStream#available() */ public int available() throws IOException { if (_contentView!=null && _contentView.length()>0) return _contentView.length(); if (_endp.isBlocking()) { if (_state>0 && _endp instanceof StreamEndPoint) return ((StreamEndPoint)_endp).getInputStream().available()>0?1:0; return 0; } parseNext(); return _contentView==null?0:_contentView.length(); } /* ------------------------------------------------------------ */ /* ------------------------------------------------------------ */ /* ------------------------------------------------------------ */ public static abstract class EventHandler { public abstract void content(Buffer ref) throws IOException; public void headerComplete() throws IOException { } public void messageComplete(long contentLength) throws IOException { } /** * This is the method called by parser when a HTTP Header name and value is found */ public void parsedHeader(Buffer name, Buffer value) throws IOException { } /** * This is the method called by parser when the HTTP request line is parsed */ public abstract void startRequest(Buffer method, Buffer url, Buffer version) throws IOException; /** * This is the method called by parser when the HTTP request line is parsed */ public abstract void startResponse(Buffer version, int status, Buffer reason) throws IOException; public void earlyEOF() {} } }