public void ParseRequestLineThrowsOnInvalidRequestLine(string requestLine) { var parser = new HttpParser(); var buffer = new ReadOnlyBuffer <byte>(Encoding.ASCII.GetBytes(requestLine)); var requestHandler = new RequestHandler(); var exception = Assert.Throws <BadHttpRequestException>(() => parser.ParseRequestLine(ref requestHandler, buffer, out var consumed)); //Assert.Equal($"Invalid request line: '{requestLine.EscapeNonPrintable()}'", exception.Message); //Assert.Equal(StatusCodes.Status400BadRequest, (exception as BadHttpRequestException).StatusCode); }
public void MultipleHeadersWithTheSameKey() { byte[] input = Encoding.ASCII.GetBytes(SampleRedirectWithMultipleCookiesResponse); int statusCode; var result = HttpParser.GetHttpHeaders(input, input.IndexOf(ByteArrayExtensionsTests.BODY_CRLF), out statusCode); var response = new SimpleHttpResponse(statusCode, input, result); Assert.True(response.StatusCode == 301); Assert.True(response.Headers["Set-Cookie"].Contains("blah")); }
public void ParseHeadersThrowsOnInvalidRequestHeaders(string rawHeaders, string expectedExceptionMessage) { var parser = new HttpParser(); var buffer = new ReadOnlyBuffer <byte>(Encoding.ASCII.GetBytes(rawHeaders)); var requestHandler = new RequestHandler(); var exception = Assert.Throws <BadHttpRequestException>(() => parser.ParseHeaders(ref requestHandler, buffer, out var consumed)); //Assert.Equal(expectedExceptionMessage, exception.Message); //Assert.Equal(StatusCodes.Status400BadRequest, exception.StatusCode); }
public async Task ParserCanParseSampleMarkup() { //arrange HttpParser parser = new HttpParser(); IEnumerable <Match> result = await parser.Parse(File.ReadAllText("Integration//SampleMarkup.html")); //act result.ToList().ForEach(r => Console.WriteLine(r.Value)); //assert // yeah yeah could assert a known match collection length. }
public int OnHeaderField(HttpParser parser, ByteBuffer data, int pos, int len) { string str = Encoding.ASCII.GetString(data.Bytes, pos, len); if (current_header_value.Length != 0) { FinishCurrentHeader(); } current_header_field.Append(str); return(0); }
public int OnHeaderValue(HttpParser parser, ByteBuffer data, int pos, int len) { string str = Encoding.ASCII.GetString(data.Bytes, pos, len); if (current_header_field.Length == 0) { throw new HttpException("Header Value raised with no header field set."); } current_header_value.Append(str); return(0); }
protected override int OnHeadersComplete(HttpParser parser) { base.OnHeadersComplete(parser); StatusCode = parser.StatusCode; if (Request.Method == HttpMethod.HTTP_HEAD) { return(1); } return(0); }
public void Test_GetRemainder_When_Buffer_is_NULL() { // Given var parser = new HttpParser(null); // When parser.ReadLine("abc"); var remainder = parser.GetRemainder(); // Then Assert.Null(remainder); }
/// <summary> /// Checks that the expected response of a method definition is valid with this resource. /// </summary> /// <param name="method"></param> /// <param name="issues"></param> /// <returns></returns> public bool ValidateExpectedResponse(MethodDefinition method, IssueLogger issues) { HttpResponse response; HttpParser.TryParseHttpResponse(method.ExpectedResponse, out response, issues); if (response != null) { JsonExample example = new JsonExample(response.Body, method.ExpectedResponseMetadata); var otherSchemas = new Dictionary <string, JsonSchema>(); return(this.ValidateJson(example, issues, otherSchemas, null)); } return(false); }
public static GRequestHandler ParseHeaders(byte[] data) { var buffer = new ReadOnlySequence <byte>(data); var headers = new GRequestHandler(); var p = new HttpParser <GRequestHandler>(); p.ParseRequestLine(headers, in buffer, out var consumed, out var examined); buffer = buffer.Slice(consumed); p.ParseHeaders(headers, in buffer, out consumed, out examined, out var b); return(headers); }
public void OnMessageEnd(HttpParser parser) { //performs some check if (String.IsNullOrEmpty(CurrentRequest.Path) || String.IsNullOrWhiteSpace(CurrentRequest.Path)) { return; } if (CurrentRequest.Method == null) { return; } Requests.Enqueue(CurrentRequest); }
public Task ExecuteAsync(ConnectionContext connection) { var parser = new HttpParser <HttpConnection>(); var httpConnection = new TConnection { Parser = parser, Reader = connection.Transport.Input, Writer = connection.Transport.Output }; return(httpConnection.ExecuteAsync()); }
public void OnHeaderValue(HttpParser parser, string value) { string existingValue = _request.Headers[_headerName]; if (string.IsNullOrWhiteSpace(existingValue)) { _request.Headers[_headerName] = value; } else { _request.Headers[_headerName] = existingValue + "," + value; } }
public void ParseRequestLineSplitBufferWithoutNewLineDoesNotUpdateConsumed() { HttpParser parser = new HttpParser(); ReadableBuffer buffer = BufferUtilities.CreateBuffer("GET ", "/"); RequestHandler requestHandler = new RequestHandler(); bool result = parser.ParseRequestLine(requestHandler, buffer, out ReadCursor consumed, out ReadCursor examined); Assert.False(result); Assert.Equal(buffer.Start, consumed); Assert.Equal(buffer.End, examined); }
protected virtual int OnHeadersComplete(HttpParser parser) { if (current_header_field.Length != 0) { FinishCurrentHeader(); } MajorVersion = parser.Major; MinorVersion = parser.Minor; Method = parser.HttpMethod; return(0); }
public void ParseRequestLineSplitBufferWithoutNewLineDoesNotUpdateConsumed() { HttpParser parser = new HttpParser(); ReadOnlyBuffer <byte> buffer = BufferUtilities.CreateBuffer("GET ", "/"); RequestHandler requestHandler = new RequestHandler(); bool result = parser.ParseRequestLine(requestHandler, buffer, out SequencePosition consumed, out SequencePosition examined); Assert.False(result); Assert.Equal(buffer.Slice(consumed).Length, buffer.Length); Assert.True(buffer.Slice(examined).IsEmpty); }
public void Test_IS_Chunk_Compete_Should_Work_For_Given_Minimum_Chunk_Size() { // Given byte[] buffer = Encoding.UTF8.GetBytes("3\r\nabc\r\n2b"); var parser = new HttpParser(buffer); // When parser.ReadLine(NewLine); parser = new HttpParser(parser.GetRemainder()); byte[] byteLine = parser.ReadLine(NewLine); // Then Assert.True(parser.IsChunkComplete(byteLine, NewLine, 5)); }
protected virtual void OnFinishedReading(HttpParser parser) { if (body_handler != null) { body_handler.Finish(this); body_handler = null; } if (OnCompleted != null) { OnCompleted(); } }
public async Task Invoke(IDictionary <string, object> environment) { var request = new OwinRequest(environment); Uri uri = request.Uri; // Create a stream for the host and port so we can send the request Stream stream = await _streamFactory.CreateStream(uri).ConfigureAwait(continueOnCapturedContext: false); var requestWriter = new StreamWriter(stream); // Request line requestWriter.WriteHttpLine("{0} {1} {2}", request.Method, uri.PathAndQuery, request.Protocol); // Write headers foreach (var header in request.Headers) { requestWriter.WriteHttpLine("{0}: {1}", header.Key, request.GetHeader(header.Key)); } // End headers requestWriter.WriteHttpLine(); if (request.Body == null) { // End request requestWriter.WriteHttpLine(); } // Flush buffered content to the stream async await requestWriter.FlushAsync().ConfigureAwait(continueOnCapturedContext: false); if (request.Body != null) { // Copy the body to the request await request.Body.CopyToAsync(stream).ConfigureAwait(continueOnCapturedContext: false); } var response = new OwinResponse(environment); // Parse the response HttpParser.ParseResponse(stream, (protocol, statusCode, reasonPhrase) => { response.Protocol = protocol; response.StatusCode = statusCode; response.ReasonPhrase = reasonPhrase; }, (key, value) => response.SetHeader(key, value)); // Set the body to the rest of the stream response.Body = stream; }
private void NewTcpClient(object obj) { var client = obj as TcpClient; var stream = client.GetStream(); var handler = new ParserHandler(); var requ = new Request(); var context = new Context(); var response = new Response(); var parser = new HttpParser(handler); handler.setData(requ); int bytesRead = 0; var buffer = new byte[1024 /* or whatever you like */]; try { while ((bytesRead = stream.Read(buffer, 0, buffer.Length)) > 0) { if (bytesRead == parser.Execute(new ArraySegment <byte>(buffer, 0, bytesRead))) { break; } } // ensure you get the last callbacks. parser.Execute(default(ArraySegment <byte>)); logger.InfoFormat("[{0}] URI : {1}", requ.method, requ.uri); var svc = this.router.route(requ.uri); switch (requ.method) { case "GET": svc._get(context, requ, response); break; case "POST": svc._post(context, requ, response); break; } response.send(stream); } catch (Exception ex) { logger.ErrorFormat("exception: {0} ", ex.Message); } finally { stream.Close(); client.Close(); } }
public int OnBody(HttpParser parser, ByteBuffer data, int pos, int len) { if (body_handler == null) { CreateBodyHandler(); } if (body_handler != null) { body_handler.HandleData(this, data, pos, len); } return(0); }
public void ParseProcessing() { var parser = new HttpParser(); var input = @"GET / HTTP/1.1 Content-Length: 4 Hi"; var data = Encoding.UTF8.GetBytes(input); Assert.AreEqual( parser.Write(data), HttpParseResult.Processing); }
private void Initialize(ILoggerFactory loggerFactory, IKestrelTrace kestrelTrace) { LoggerFactory = loggerFactory; Log = kestrelTrace; ThreadPool = new LoggingThreadPool(Log); SystemClock = new MockSystemClock(); DateHeaderValueManager = new DateHeaderValueManager(SystemClock); ConnectionManager = new HttpConnectionManager(Log, ResourceCounter.Unlimited); HttpParser = new HttpParser <Http1ParsingHandler>(Log.IsEnabled(LogLevel.Information)); ServerOptions = new KestrelServerOptions { AddServerHeader = false }; }
public void OnHeadersEnd(HttpParser parser) { //Console.WriteLine("OnHeadersEnd"); onHeadersEndCalled = true; if (!string.IsNullOrEmpty(headerValue)) { CommitHeader(); } versionMajor = parser.MajorVersion; versionMinor = parser.MinorVersion; shouldKeepAlive = parser.ShouldKeepAlive; }
// this one is a little bit different: // the current `position` of the buffer is the location of the // error, `ini_pos` indicates where the position of // the buffer when it was passed to the `execute` method of the parser, i.e. // using this information and `limit` we'll know all the valid data // in the buffer around the error we can use to print pretty error // messages. public void RaiseOnError(HttpParser p, string message, ByteBuffer buf, int ini_pos) { if (null != OnError) { OnError(p, message, buf, ini_pos); } // if on_error gets called it MUST throw an exception, else the parser // will attempt to continue parsing, which it can't because it's // in an invalid state. Console.WriteLine("ERROR: '{0}'", message); throw new HttpException(message); }
public void Test_GetPosition_SubArray_Is_At_The_End() { // Given const string data = "abcd"; const string subArray = "cd"; // When var parser = new HttpParser(Encoding.UTF8.GetBytes(data)); byte[] readLine = parser.ReadLine(NewLine); // Then Assert.Equal(4, parser.GetPosition(readLine, Encoding.UTF8.GetBytes(subArray))); }
public void ParseEndWithTrailing() { var parser = new HttpParser(); var input = @"GET / HTTP/1.1 Content-Length: 4 HiHiSOME_TRAILING_DATA"; var data = Encoding.UTF8.GetBytes(input); Assert.AreEqual( parser.Write(data), HttpParseResult.EndWithTrailing); }
public void ParseRequestLineThrowsOnUnrecognizedHttpVersion(string httpVersion) { var requestLine = $"GET / {httpVersion}\r\n"; var parser = new HttpParser(); var buffer = new ReadOnlyBuffer <byte>(Encoding.ASCII.GetBytes(requestLine)); var requestHandler = new RequestHandler(); var exception = Assert.Throws <BadHttpRequestException>(() => parser.ParseRequestLine(ref requestHandler, buffer, out var consumed)); //Assert.Equal($"Unrecognized HTTP version: '{httpVersion}'", exception.Message); //Assert.Equal(StatusCodes.Status505HttpVersionNotsupported, (exception as BadHttpRequestException).StatusCode); }
public void ParseRequestLineThrowsOnNonTokenCharsInCustomMethod(string method) { var requestLine = $"{method} / HTTP/1.1\r\n"; var parser = new HttpParser(); var buffer = new ReadOnlyBuffer <byte>(Encoding.ASCII.GetBytes(requestLine)); var requestHandler = new RequestHandler(); var exception = Assert.Throws <BadHttpRequestException>(() => parser.ParseRequestLine(ref requestHandler, buffer, out var consumed)); //Assert.Equal($"Invalid request line: '{method.EscapeNonPrintable()} / HTTP/1.1\\x0D\\x0A'", exception.Message); //Assert.Equal(StatusCodes.Status400BadRequest, (exception as BadHttpRequestException).StatusCode); }
private static async void HandleConnection(Socket socket) { Trace.WriteLine("client accepted"); var ns = new NetworkStream(socket); var request = new Request(); // // for an async parsing demo: https://github.com/gsscoder/owinhttplistener // var result = HttpParser.ParseMessage(ns, (method, uri, version) => { request.Method = method; request.Uri = uri; request.Version = version; }, (header, value) => request.Headers.Add(header, value)); if (!result) { Trace.WriteLine(" parsing failed"); } // we are not interested in body for this demo if (request.Method.ToUpperInvariant() == "GET" && request.Uri.StartsWith("/hello", StringComparison.InvariantCultureIgnoreCase)) { WriteResponse(ns, "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n" + "<html><body><p>Hello, at " + DateTime.Now.ToLongTimeString() + "</p></body></html>\r\n"); } else { WriteResponse(ns, "HTTP/1.1 404 Not Found\r\nContent-Type: text/html\r\n\r\n" + "<html><body><p>Sorry! Resource not found.</p></body></html>\r\n"); } try { ns.Close(); socket.Close(); } catch (Exception e) { Trace.WriteLine("Trouble: " + e.Message); } }
public static string HttpMethodVerb(this MethodDefinition method) { HttpParser parser = new HttpParser(); var request = parser.ParseHttpRequest(method.Request); return request.Method; }