fasthttp: expand http request parser (related to #26091 part1) (#26104)

Author: enghitalo

vlib/fasthttp/fasthttp.v

@@ -48,12 +48,16 @@ pub:
 	len   int
 }
 
+// HttpRequest represents an HTTP request.
+// TODO make fields immutable
 pub struct HttpRequest {
 pub mut:
 	buffer         []u8 // A V slice of the read buffer for convenience
 	method         Slice
 	path           Slice
 	version        Slice
+	header_fields  Slice
+	body           Slice
 	client_conn_fd int
 	user_data      voidptr // User-defined context data
 }
@@ -66,55 +70,3 @@ pub:
 	handler                 fn (HttpRequest) ![]u8 @[required]
 	user_data               voidptr
 }
-
-@[direct_array_access]
-fn parse_request_line(buffer []u8) !HttpRequest {
-	mut req := HttpRequest{
-		buffer: buffer
-	}
-
-	mut i := 0
-	// Parse HTTP method
-	for i < buffer.len && buffer[i] != ` ` {
-		i++
-	}
-	req.method = Slice{
-		start: 0
-		len:   i
-	}
-	i++
-
-	// Parse path
-	mut path_start := i
-	for i < buffer.len && buffer[i] != ` ` {
-		i++
-	}
-	req.path = Slice{
-		start: path_start
-		len:   i - path_start
-	}
-	i++
-
-	// Parse HTTP version
-	mut version_start := i
-	for i < buffer.len && buffer[i] != `\r` {
-		i++
-	}
-	req.version = Slice{
-		start: version_start
-		len:   i - version_start
-	}
-
-	// Move to the end of the request line
-	if i + 1 < buffer.len && buffer[i] == `\r` && buffer[i + 1] == `\n` {
-		i += 2
-	} else {
-		return error('Invalid HTTP request line')
-	}
-
-	return req
-}
-
-fn decode_http_request(buffer []u8) !HttpRequest {
-	return parse_request_line(buffer)
-}

vlib/fasthttp/fasthttp_test.v

@@ -25,7 +25,7 @@ fn test_fasthttp_example_compiles() {
 fn test_parse_request_line() {
 	// Test basic GET request
 	request := 'GET / HTTP/1.1\r\n'.bytes()
-	req := parse_request_line(request) or {
+	req := decode_http_request(request) or {
 		assert false, 'Failed to parse valid request: ${err}'
 		return
 	}
@@ -50,7 +50,7 @@ fn test_parse_request_line() {
 fn test_parse_request_line_with_path() {
 	// Test GET request with path
 	request := 'GET /users/123 HTTP/1.1\r\n'.bytes()
-	req := parse_request_line(request) or {
+	req := decode_http_request(request) or {
 		assert false, 'Failed to parse valid request: ${err}'
 		return
 	}
@@ -62,7 +62,7 @@ fn test_parse_request_line_with_path() {
 fn test_parse_request_line_post() {
 	// Test POST request
 	request := 'POST /api/data HTTP/1.1\r\n'.bytes()
-	req := parse_request_line(request) or {
+	req := decode_http_request(request) or {
 		assert false, 'Failed to parse valid request: ${err}'
 		return
 	}
@@ -77,8 +77,8 @@ fn test_parse_request_line_post() {
 fn test_parse_request_line_invalid() {
 	// Test invalid request (missing \r\n)
 	request := 'GET / HTTP/1.1'.bytes()
-	parse_request_line(request) or {
-		assert err.msg() == 'Invalid HTTP request line'
+	decode_http_request(request) or {
+		assert err.msg() == 'Invalid HTTP request line: Missing CR'
 		return
 	}
 	assert false, 'Should have failed to parse invalid request'

vlib/fasthttp/request_parser.v

@@ -0,0 +1,147 @@
+module fasthttp
+
+const empty_space = u8(` `)
+const cr_char = u8(`\r`)
+const lf_char = u8(`\n`)
+
+// libc memchr is AVX2-accelerated via glibc IFUNC
+@[inline]
+fn find_byte(buf &u8, len int, c u8) int {
+	unsafe {
+		p := C.memchr(buf, c, len)
+		if p == voidptr(nil) {
+			return -1
+		}
+		return int(&u8(p) - buf)
+	}
+}
+
+// parse_http1_request_line parses the request line of an HTTP/1.1 request.
+// spec: https://datatracker.ietf.org/doc/rfc9112/
+// request-line is the start-line for for requests
+// According to RFC 9112, the request line is structured as:
+// `request-line   = method SP request-target SP HTTP-version`
+// where:
+// METHOD is the HTTP method (e.g., GET, POST)
+// SP is a single space character
+// REQUEST-TARGET is the path or resource being requested
+// HTTP-VERSION is the version of HTTP being used (e.g., HTTP/1.1)
+// CRLF is a carriage return followed by a line feed
+// returns the position after the CRLF on success
+@[direct_array_access]
+pub fn parse_http1_request_line(mut req HttpRequest) !int {
+	unsafe {
+		buf := &req.buffer[0]
+		len := req.buffer.len
+
+		if len < 12 {
+			return error('Too short')
+		}
+
+		// METHOD
+		pos1 := find_byte(buf, len, empty_space)
+		if pos1 <= 0 {
+			return error('Invalid method')
+		}
+		req.method = Slice{0, pos1}
+
+		// PATH - skip any extra spaces
+		mut pos2 := pos1 + 1
+		for pos2 < len && buf[pos2] == empty_space {
+			pos2++
+		}
+		if pos2 >= len {
+			return error('Missing path')
+		}
+
+		path_start := pos2
+		space_pos := find_byte(buf + pos2, len - pos2, empty_space)
+		cr_pos := find_byte(buf + pos2, len - pos2, cr_char)
+
+		if space_pos < 0 && cr_pos < 0 {
+			return error('Invalid request line')
+		}
+
+		// pick earliest delimiter
+		mut path_len := 0
+		mut delim_pos := 0
+		if space_pos >= 0 && (cr_pos < 0 || space_pos < cr_pos) {
+			path_len = space_pos
+			delim_pos = pos2 + space_pos
+		} else {
+			path_len = cr_pos
+			delim_pos = pos2 + cr_pos
+		}
+
+		req.path = Slice{path_start, path_len}
+
+		// VERSION
+		if buf[delim_pos] == cr_char {
+			// No HTTP version specified
+			req.version = Slice{delim_pos, 0}
+		} else {
+			version_start := delim_pos + 1
+			cr := find_byte(buf + version_start, len - version_start, cr_char)
+			if cr < 0 {
+				return error('Invalid HTTP request line: Missing CR')
+			}
+			req.version = Slice{version_start, cr}
+			delim_pos = version_start + cr
+		}
+
+		// Validate CRLF
+		if delim_pos + 1 >= len || buf[delim_pos + 1] != lf_char {
+			return error('Invalid CRLF')
+		}
+
+		return delim_pos + 2 // Return position after CRLF
+	}
+}
+
+// decode_http_request parses a raw HTTP request from the given byte buffer
+pub fn decode_http_request(buffer []u8) !HttpRequest {
+	mut req := HttpRequest{
+		buffer: buffer
+	}
+
+	// header_start is the byte index immediately after the request line's \r\n
+	header_start := parse_http1_request_line(mut req)!
+
+	// Find the end of the header block (\r\n\r\n)
+	mut body_start := -1
+	for i := header_start; i <= buffer.len - 4; i++ {
+		if buffer[i] == cr_char && buffer[i + 1] == lf_char && buffer[i + 2] == cr_char
+			&& buffer[i + 3] == lf_char {
+			body_start = i + 4
+
+			// The header fields slice covers everything from header_start
+			// up to (but not including) the final double CRLF
+			req.header_fields = Slice{
+				start: header_start
+				len:   i - header_start
+			}
+			break
+		}
+	}
+
+	if body_start != -1 {
+		req.body = Slice{
+			start: body_start
+			len:   buffer.len - body_start
+		}
+	} else {
+		// If no body delimiter found, assume headers go to end or body is missing
+		req.header_fields = Slice{header_start, buffer.len - header_start - 2}
+		req.body = Slice{0, 0}
+	}
+
+	return req
+}
+
+// Helper function to convert Slice to string for debugging
+fn (slice Slice) to_string(buffer []u8) string {
+	if slice.len <= 0 {
+		return ''
+	}
+	return buffer[slice.start..slice.start + slice.len].bytestr()
+}

vlib/fasthttp/request_parser_test.v

@@ -0,0 +1,88 @@
+module fasthttp
+
+fn test_parse_http1_request_line_valid_request() {
+	buffer := 'GET /path/to/resource HTTP/1.1\r\n'.bytes()
+	mut req := HttpRequest{
+		buffer: buffer
+	}
+
+	parse_http1_request_line(mut req) or { panic(err) }
+
+	assert req.method.to_string(req.buffer) == 'GET'
+	assert req.path.to_string(req.buffer) == '/path/to/resource'
+	assert req.version.to_string(req.buffer) == 'HTTP/1.1'
+}
+
+fn test_parse_http1_request_line_invalid_request() {
+	buffer := 'INVALID REQUEST LINE'.bytes()
+	mut req := HttpRequest{
+		buffer: buffer
+	}
+
+	mut has_error := false
+	parse_http1_request_line(mut req) or {
+		has_error = true
+		assert err.msg() == 'Invalid HTTP request line: Missing CR'
+	}
+	assert has_error, 'Expected error for invalid request line'
+}
+
+fn test_decode_http_request_valid_request() {
+	buffer := 'POST /api/resource HTTP/1.0\r\n'.bytes()
+	req := decode_http_request(buffer) or { panic(err) }
+
+	assert req.method.to_string(req.buffer) == 'POST'
+	assert req.path.to_string(req.buffer) == '/api/resource'
+	assert req.version.to_string(req.buffer) == 'HTTP/1.0'
+}
+
+fn test_decode_http_request_invalid_request() {
+	buffer := 'INVALID REQUEST LINE'.bytes()
+
+	mut has_error := false
+	decode_http_request(buffer) or {
+		has_error = true
+		assert err.msg() == 'Invalid HTTP request line: Missing CR'
+	}
+	assert has_error, 'Expected error for invalid request'
+}
+
+fn test_decode_http_request_with_headers_and_body() {
+	raw := 'POST /submit HTTP/1.1\r\n' + 'Host: localhost\r\n' +
+		'Content-Type: application/json\r\n' + 'Content-Length: 18\r\n' + '\r\n' +
+		'{"status": "ok"}'
+
+	buffer := raw.bytes()
+	req := decode_http_request(buffer) or { panic(err) }
+
+	assert req.method.to_string(req.buffer) == 'POST'
+	assert req.path.to_string(req.buffer) == '/submit'
+
+	// Verify Header Fields block
+	// Should contain everything between the first \r\n and the \r\n\r\n
+	header_str := req.header_fields.to_string(req.buffer)
+	assert header_str == 'Host: localhost\r\nContent-Type: application/json\r\nContent-Length: 18'
+
+	// Verify Body
+	assert req.body.to_string(req.buffer) == '{"status": "ok"}'
+}
+
+fn test_decode_http_request_no_body() {
+	// A GET request usually ends with \r\n\r\n and no body
+	buffer := 'GET /index.html HTTP/1.1\r\nUser-Agent: V\r\n\r\n'.bytes()
+	req := decode_http_request(buffer) or { panic(err) }
+
+	assert req.header_fields.to_string(req.buffer) == 'User-Agent: V'
+	assert req.body.len == 0
+}
+
+fn test_decode_http_request_malformed_no_double_crlf() {
+	// Request that never finishes headers
+	buffer := 'GET / HTTP/1.1\r\nHost: example.com\r\n'.bytes()
+	req := decode_http_request(buffer) or { panic(err) }
+
+	// Based on our implementation, if no \r\n\r\n is found,
+	// body should be empty and headers go to the end.
+	assert req.body.len == 0
+	assert req.header_fields.to_string(req.buffer) == 'Host: example.com'
+}