/// <summary>Creates an instance of this class.</summary> /// <remarks>Creates an instance of this class.</remarks> /// <param name="buffer">the session input buffer.</param> /// <param name="lineParser">the line parser.</param> /// <param name="requestFactory"> /// the factory to use to create /// <see cref="Org.Apache.Http.IHttpRequest">Org.Apache.Http.IHttpRequest</see> /// s. /// </param> /// <param name="params">HTTP parameters.</param> [System.ObsoleteAttribute(@"(4.3) useDefaultHttpRequestParser(Org.Apache.Http.IO.SessionInputBuffer, Org.Apache.Http.Message.LineParser, Org.Apache.Http.HttpRequestFactory, Org.Apache.Http.Config.MessageConstraints)")] public DefaultHttpRequestParser(SessionInputBuffer buffer, LineParser lineParser, HttpRequestFactory requestFactory, HttpParams @params) : base(buffer, lineParser , @params) { this.requestFactory = Args.NotNull(requestFactory, "Request factory"); this.lineBuf = new CharArrayBuffer(128); }
public DefaultHttpResponseParser(SessionInputBuffer buffer, LineParser parser, HttpResponseFactory responseFactory, HttpParams @params) : base(buffer, parser, @params) { Args.NotNull(responseFactory, "Response factory"); this.responseFactory = responseFactory; this.lineBuf = new CharArrayBuffer(128); }
/// <summary>Wraps session input stream and reads chunk coded input.</summary> /// <remarks>Wraps session input stream and reads chunk coded input.</remarks> /// <param name="in">The session input buffer</param> public ChunkedInputStream(SessionInputBuffer @in) : base() { this.@in = Args.NotNull(@in, "Session input buffer"); this.pos = 0; this.buffer = new CharArrayBuffer(16); this.state = ChunkLen; }
/// <summary>Creates new instance of DefaultHttpRequestParser.</summary> /// <remarks>Creates new instance of DefaultHttpRequestParser.</remarks> /// <param name="buffer">the session input buffer.</param> /// <param name="lineParser"> /// the line parser. If <code>null</code> /// <see cref="Org.Apache.Http.Message.BasicLineParser.Instance">Org.Apache.Http.Message.BasicLineParser.Instance /// </see> /// will be used. /// </param> /// <param name="requestFactory"> /// the response factory. If <code>null</code> /// <see cref="Org.Apache.Http.Impl.DefaultHttpRequestFactory.Instance">Org.Apache.Http.Impl.DefaultHttpRequestFactory.Instance /// </see> /// will be used. /// </param> /// <param name="constraints"> /// the message constraints. If <code>null</code> /// <see cref="Org.Apache.Http.Config.MessageConstraints.Default">Org.Apache.Http.Config.MessageConstraints.Default /// </see> /// will be used. /// </param> /// <since>4.3</since> public DefaultHttpRequestParser(SessionInputBuffer buffer, LineParser lineParser, HttpRequestFactory requestFactory, MessageConstraints constraints) : base(buffer , lineParser, constraints) { this.requestFactory = requestFactory != null ? requestFactory : DefaultHttpRequestFactory .Instance; this.lineBuf = new CharArrayBuffer(128); }
/// <summary> /// Parses HTTP headers from the data receiver stream according to the generic /// format as given in Section 3.1 of RFC 822, RFC-2616 Section 4 and 19.3. /// </summary> /// <remarks> /// Parses HTTP headers from the data receiver stream according to the generic /// format as given in Section 3.1 of RFC 822, RFC-2616 Section 4 and 19.3. /// </remarks> /// <param name="inbuffer">Session input buffer</param> /// <param name="maxHeaderCount"> /// maximum number of headers allowed. If the number /// of headers received from the data stream exceeds maxCount value, an /// IOException will be thrown. Setting this parameter to a negative value /// or zero will disable the check. /// </param> /// <param name="maxLineLen"> /// maximum number of characters for a header line, /// including the continuation lines. Setting this parameter to a negative /// value or zero will disable the check. /// </param> /// <returns>array of HTTP headers</returns> /// <param name="parser"> /// line parser to use. Can be <code>null</code>, in which case /// the default implementation of this interface will be used. /// </param> /// <exception cref="System.IO.IOException">in case of an I/O error</exception> /// <exception cref="Org.Apache.Http.HttpException">in case of HTTP protocol violation /// </exception> public static Header[] ParseHeaders(SessionInputBuffer inbuffer, int maxHeaderCount , int maxLineLen, LineParser parser) { IList <CharArrayBuffer> headerLines = new AList <CharArrayBuffer>(); return(ParseHeaders(inbuffer, maxHeaderCount, maxLineLen, parser != null ? parser : BasicLineParser.Instance, headerLines)); }
/// <summary>Creates new instance of AbstractMessageParser.</summary> /// <remarks>Creates new instance of AbstractMessageParser.</remarks> /// <param name="buffer">the session input buffer.</param> /// <param name="lineParser"> /// the line parser. If <code>null</code> /// <see cref="Org.Apache.Http.Message.BasicLineParser.Instance">Org.Apache.Http.Message.BasicLineParser.Instance /// </see> /// will be used. /// </param> /// <param name="constraints"> /// the message constraints. If <code>null</code> /// <see cref="Org.Apache.Http.Config.MessageConstraints.Default">Org.Apache.Http.Config.MessageConstraints.Default /// </see> /// will be used. /// </param> /// <since>4.3</since> public AbstractMessageParser(SessionInputBuffer buffer, LineParser lineParser, MessageConstraints constraints) : base() { this.sessionBuffer = Args.NotNull(buffer, "Session input buffer"); this.lineParser = lineParser != null ? lineParser : BasicLineParser.Instance; this.messageConstraints = constraints != null ? constraints : MessageConstraints. Default; this.headerLines = new AList <CharArrayBuffer>(); this.state = HeadLine; }
/// <summary>Creates an instance of AbstractMessageParser.</summary> /// <remarks>Creates an instance of AbstractMessageParser.</remarks> /// <param name="buffer">the session input buffer.</param> /// <param name="parser">the line parser.</param> /// <param name="params">HTTP parameters.</param> [System.ObsoleteAttribute(@"(4.3) use AbstractMessageParser{T}.AbstractMessageParser(Org.Apache.Http.IO.SessionInputBuffer, Org.Apache.Http.Message.LineParser, Org.Apache.Http.Config.MessageConstraints)")] public AbstractMessageParser(SessionInputBuffer buffer, LineParser parser, HttpParams @params) : base() { Args.NotNull(buffer, "Session input buffer"); Args.NotNull(@params, "HTTP parameters"); this.sessionBuffer = buffer; this.messageConstraints = HttpParamConfig.GetMessageConstraints(@params); this.lineParser = (parser != null) ? parser : BasicLineParser.Instance; this.headerLines = new AList <CharArrayBuffer>(); this.state = HeadLine; }
/// <exception cref="System.IO.IOException"></exception> /// <exception cref="Org.Apache.Http.HttpException"></exception> /// <exception cref="Org.Apache.Http.ParseException"></exception> protected internal override IHttpRequest ParseHead(SessionInputBuffer sessionBuffer ) { this.lineBuf.Clear(); int i = sessionBuffer.ReadLine(this.lineBuf); if (i == -1) { throw new ConnectionClosedException("Client closed connection"); } ParserCursor cursor = new ParserCursor(0, this.lineBuf.Length()); RequestLine requestline = this.lineParser.ParseRequestLine(this.lineBuf, cursor); return(this.requestFactory.NewHttpRequest(requestline)); }
/// <exception cref="System.IO.IOException"></exception> /// <exception cref="Org.Apache.Http.HttpException"></exception> /// <exception cref="Org.Apache.Http.ParseException"></exception> protected internal override HttpResponse ParseHead(SessionInputBuffer sessionBuffer ) { this.lineBuf.Clear(); int i = sessionBuffer.ReadLine(this.lineBuf); if (i == -1) { throw new NoHttpResponseException("The target server failed to respond"); } //create the status line from the status string ParserCursor cursor = new ParserCursor(0, this.lineBuf.Length()); StatusLine statusline = lineParser.ParseStatusLine(this.lineBuf, cursor); return(this.responseFactory.NewHttpResponse(statusline, null)); }
protected internal virtual InputStream CreateInputStream(long len, SessionInputBuffer inbuffer) { if (len == ContentLengthStrategy.Chunked) { return(new ChunkedInputStream(inbuffer)); } else { if (len == ContentLengthStrategy.Identity) { return(new IdentityInputStream(inbuffer)); } else { return(new ContentLengthInputStream(inbuffer, len)); } } }
/// <exception cref="System.IO.IOException"></exception> /// <exception cref="Apache.Http.HttpException"></exception> protected override HttpResponse ParseHead(SessionInputBuffer sessionBuffer) { //read out the HTTP status string int count = 0; ParserCursor cursor = null; do { // clear the buffer this.lineBuf.Clear(); int i = sessionBuffer.ReadLine(this.lineBuf); if (i == -1 && count == 0) { // The server just dropped connection on us throw new NoHttpResponseException("The target server failed to respond"); } cursor = new ParserCursor(0, this.lineBuf.Length()); if (lineParser.HasProtocolVersion(this.lineBuf, cursor)) { // Got one break; } else { if (i == -1 || Reject(this.lineBuf, count)) { // Giving up throw new ProtocolException("The server failed to respond with a " + "valid HTTP response" ); } } if (this.log.IsDebugEnabled()) { this.log.Debug("Garbage in response: " + this.lineBuf.ToString()); } count++; }while (true); //create the status line from the status string StatusLine statusline = lineParser.ParseStatusLine(this.lineBuf, cursor); return(this.responseFactory.NewHttpResponse(statusline, null)); }
/// <summary>Wraps session input stream and reads input until the the end of stream.</summary> /// <remarks>Wraps session input stream and reads input until the the end of stream.</remarks> /// <param name="in">The session input buffer</param> public IdentityInputStream(SessionInputBuffer @in) : base() { this.@in = Args.NotNull(@in, "Session input buffer"); }
public virtual HttpMessageParser <HttpResponse> Create(SessionInputBuffer buffer, MessageConstraints constraints) { return(new DefaultHttpResponseParser(buffer, lineParser, responseFactory, constraints )); }
/// <summary> /// Parses HTTP headers from the data receiver stream according to the generic /// format as given in Section 3.1 of RFC 822, RFC-2616 Section 4 and 19.3. /// </summary> /// <remarks> /// Parses HTTP headers from the data receiver stream according to the generic /// format as given in Section 3.1 of RFC 822, RFC-2616 Section 4 and 19.3. /// </remarks> /// <param name="inbuffer">Session input buffer</param> /// <param name="maxHeaderCount"> /// maximum number of headers allowed. If the number /// of headers received from the data stream exceeds maxCount value, an /// IOException will be thrown. Setting this parameter to a negative value /// or zero will disable the check. /// </param> /// <param name="maxLineLen"> /// maximum number of characters for a header line, /// including the continuation lines. Setting this parameter to a negative /// value or zero will disable the check. /// </param> /// <param name="parser">line parser to use.</param> /// <param name="headerLines"> /// List of header lines. This list will be used to store /// intermediate results. This makes it possible to resume parsing of /// headers in case of a /// <see cref="System.Threading.ThreadInterruptedException">System.Threading.ThreadInterruptedException /// </see> /// . /// </param> /// <returns>array of HTTP headers</returns> /// <exception cref="System.IO.IOException">in case of an I/O error</exception> /// <exception cref="Org.Apache.Http.HttpException">in case of HTTP protocol violation /// </exception> /// <since>4.1</since> public static Header[] ParseHeaders(SessionInputBuffer inbuffer, int maxHeaderCount , int maxLineLen, LineParser parser, IList <CharArrayBuffer> headerLines) { Args.NotNull(inbuffer, "Session input buffer"); Args.NotNull(parser, "Line parser"); Args.NotNull(headerLines, "Header line list"); CharArrayBuffer current = null; CharArrayBuffer previous = null; for (; ;) { if (current == null) { current = new CharArrayBuffer(64); } else { current.Clear(); } int l = inbuffer.ReadLine(current); if (l == -1 || current.Length() < 1) { break; } // Parse the header name and value // Check for folded headers first // Detect LWS-char see HTTP/1.0 or HTTP/1.1 Section 2.2 // discussion on folded headers if ((current.CharAt(0) == ' ' || current.CharAt(0) == '\t') && previous != null) { // we have continuation folded header // so append value int i = 0; while (i < current.Length()) { char ch = current.CharAt(i); if (ch != ' ' && ch != '\t') { break; } i++; } if (maxLineLen > 0 && previous.Length() + 1 + current.Length() - i > maxLineLen) { throw new MessageConstraintException("Maximum line length limit exceeded"); } previous.Append(' '); previous.Append(current, i, current.Length() - i); } else { headerLines.AddItem(current); previous = current; current = null; } if (maxHeaderCount > 0 && headerLines.Count >= maxHeaderCount) { throw new MessageConstraintException("Maximum header count exceeded"); } } Header[] headers = new Header[headerLines.Count]; for (int i_1 = 0; i_1 < headerLines.Count; i_1++) { CharArrayBuffer buffer = headerLines[i_1]; try { headers[i_1] = parser.ParseHeader(buffer); } catch (ParseException ex) { throw new ProtocolException(ex.Message); } } return(headers); }
/// <summary> /// Wraps a session input buffer and cuts off output after a defined number /// of bytes. /// </summary> /// <remarks> /// Wraps a session input buffer and cuts off output after a defined number /// of bytes. /// </remarks> /// <param name="in">The session input buffer</param> /// <param name="contentLength"> /// The maximum number of bytes that can be read from /// the stream. Subsequent read operations will return -1. /// </param> public ContentLengthInputStream(SessionInputBuffer @in, long contentLength) : base () { this.@in = Args.NotNull(@in, "Session input buffer"); this.contentLength = Args.NotNegative(contentLength, "Content length"); }
/// <summary> /// Subclasses must override this method to generate an instance of /// <see cref="Org.Apache.Http.HttpMessage">Org.Apache.Http.HttpMessage</see> /// based on the initial input from the session buffer. /// <p> /// Usually this method is expected to read just the very first line or /// the very first valid from the data stream and based on the input generate /// an appropriate instance of /// <see cref="Org.Apache.Http.HttpMessage">Org.Apache.Http.HttpMessage</see> /// . /// </summary> /// <param name="sessionBuffer">the session input buffer.</param> /// <returns>HTTP message based on the input from the session buffer.</returns> /// <exception cref="System.IO.IOException">in case of an I/O error.</exception> /// <exception cref="Org.Apache.Http.HttpException">in case of HTTP protocol violation. /// </exception> /// <exception cref="Org.Apache.Http.ParseException">in case of a parse error.</exception> protected internal abstract T ParseHead(SessionInputBuffer sessionBuffer);
/// <since>4.3</since> public DefaultHttpRequestParser(SessionInputBuffer buffer, MessageConstraints constraints ) : this(buffer, null, null, constraints) { }
/// <since>4.3</since> public DefaultHttpResponseParser(SessionInputBuffer buffer) : this(buffer, null, null, MessageConstraints.Default) { }