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;
}
