Skip to content

Lightpanda: the headless browser designed for AI and automation

rework `Connection.upgrade` with `header_parser`

Halil Durak46ce6cc1dcf2
diff --git a/src/cdp/Connection.zig b/src/cdp/Connection.zig
index 860716d90..aeb7baa80 100644
--- a/src/cdp/Connection.zig
+++ b/src/cdp/Connection.zig
@@ -27,6 +27,7 @@ const ArenaPool = @import("../ArenaPool.zig");
const WS = @import("../network/WS.zig");
const sys_net = @import("../sys/net.zig");
+const header_parser = @import("../network/header_parser.zig");
const log = lp.log;
const posix = std.posix;
@@ -433,59 +434,96 @@ fn pushCdp(self: *Connection, bytes: []const u8) !bool {
}
pub fn upgrade(self: *Connection, request: []u8) !void {
- // our caller already confirmed that we have a trailing \r\n\r\n
- const request_line_end = std.mem.indexOfScalar(u8, request, '\r') orelse unreachable;
- const request_line = request[0..request_line_end];
-
- if (!std.ascii.endsWithIgnoreCase(request_line, "http/1.1")) {
+ var cursor = header_parser.Cursor{
+ .idx = request.ptr,
+ .start = request.ptr,
+ .end = request.ptr + request.len,
+ };
+ // A malformed request line maps to a 400 in processHttpRequest.
+ header_parser.validateWebSocketRequestLine(&cursor) catch {
return error.InvalidProtocol;
- }
-
- // we need to extract the sec-websocket-key value
- var key: []const u8 = "";
-
- // we need to make sure that we got all the necessary headers + values
- var required_headers: u8 = 0;
+ };
- // can't std.mem.split because it forces the iterated value to be const
- // (we could @constCast...)
+ // We need to extract the `Sec-WebSocket-Key` value.
+ var sec_websocket_key: []const u8 = "";
+ // We need to make sure that we got all the necessary headers + values.
+ const RequiredHeaders = packed struct(u8) {
+ /// Upgrade: websocket
+ upgrade: bool = false,
+ sec_websocket_version: bool = false,
+ /// Connection: upgrade
+ connection: bool = false,
+ sec_websocket_key: bool = false,
+ __pad: u4 = 0,
+ };
- var buf = request[request_line_end + 2 ..];
+ var required_headers = RequiredHeaders{};
+ // We reuse this to parse headers that're required.
+ var header: header_parser.Header = undefined;
+ while (true) {
+ if (cursor.reachedEnd()) {
+ return error.InvalidRequest;
+ }
- while (buf.len > 4) {
- const index = std.mem.indexOfScalar(u8, buf, '\r') orelse unreachable;
- const separator = std.mem.indexOfScalar(u8, buf[0..index], ':') orelse return error.InvalidRequest;
+ // Check if headers part has finished.
+ switch (cursor.char()) {
+ '\n' => {
+ // End of headers.
+ cursor.advance(1);
+ break;
+ },
+ '\r' => {
+ // We need an LF too.
+ if (!cursor.hasLength(2) or !cursor.peek2('\r', '\n')) {
+ return error.InvalidRequest;
+ }
+ // End of headers.
+ cursor.advance(2);
+ break;
+ },
+ else => {},
+ }
- const name = std.mem.trim(u8, toLower(buf[0..separator]), &std.ascii.whitespace);
- const value = std.mem.trim(u8, buf[(separator + 1)..index], &std.ascii.whitespace);
+ // A malformed header maps to a 400 in processHttpRequest.
+ header.parse(&cursor) catch {
+ return error.InvalidRequest;
+ };
+ const key = header.key;
+ const value = header.value;
- if (std.mem.eql(u8, name, "upgrade")) {
+ // Header names are case-insensitive; `Header.parse` keeps their
+ // original casing.
+ if (std.ascii.eqlIgnoreCase(key, "upgrade")) {
if (!std.ascii.eqlIgnoreCase("websocket", value)) {
return error.InvalidUpgradeHeader;
}
- required_headers |= 1;
- } else if (std.mem.eql(u8, name, "sec-websocket-version")) {
+ required_headers.upgrade = true;
+ } else if (std.ascii.eqlIgnoreCase(key, "sec-websocket-version")) {
if (value.len != 2 or value[0] != '1' or value[1] != '3') {
return error.InvalidVersionHeader;
}
- required_headers |= 2;
- } else if (std.mem.eql(u8, name, "connection")) {
+ required_headers.sec_websocket_version = true;
+ } else if (std.ascii.eqlIgnoreCase(key, "connection")) {
// find if connection header has upgrade in it, example header:
// Connection: keep-alive, Upgrade
if (std.ascii.indexOfIgnoreCase(value, "upgrade") == null) {
return error.InvalidConnectionHeader;
}
- required_headers |= 4;
- } else if (std.mem.eql(u8, name, "sec-websocket-key")) {
- key = value;
- required_headers |= 8;
+ required_headers.connection = true;
+ } else if (std.ascii.eqlIgnoreCase(key, "sec-websocket-key")) {
+ sec_websocket_key = value;
+ required_headers.sec_websocket_key = true;
}
-
- const next = index + 2;
- buf = buf[next..];
}
- if (required_headers != 15) {
+ // Check if we've received all related headers.
+ const satisfied = @as(u8, @bitCast(required_headers)) == @as(u8, @bitCast(RequiredHeaders{
+ .upgrade = true,
+ .sec_websocket_version = true,
+ .connection = true,
+ .sec_websocket_key = true,
+ }));
+ if (!satisfied) {
return error.MissingHeaders;
}
@@ -513,7 +551,7 @@ pub fn upgrade(self: *Connection, request: []u8) !void {
const key_pos = res.len - 32;
var h: [20]u8 = undefined;
var hasher = std.crypto.hash.Sha1.init(.{});
- hasher.update(key);
+ hasher.update(sec_websocket_key);
// websocket spec always used this value
hasher.update("258EAFA5-E914-47DA-95CA-C5AB0DC85B11");
hasher.final(&h);
@@ -598,11 +636,3 @@ fn websocketHeader(buf: []u8, op_code: WS.OpCode, payload_len: usize) []const u8
buf[9] = @intCast(len & 0xFF);
return buf[0..10];
}
-
-// In-place string lowercase
-fn toLower(str: []u8) []u8 {
- for (str, 0..) |ch, i| {
- str[i] = std.ascii.toLower(ch);
- }
- return str;
-}
diff --git a/src/network/header_parser.zig b/src/network/header_parser.zig
index c1842ee8c..6c6ea8b0e 100644
--- a/src/network/header_parser.zig
+++ b/src/network/header_parser.zig
@@ -230,6 +230,66 @@ pub const Header = struct {
}
};
+/// Validates WebSocket initialization requests.
+/// Currently does not validate paths.
+pub fn validateWebSocketRequestLine(cursor: *Cursor) !void {
+ // GET / HTTP/1.1\n
+ const min_request_len = 0xf;
+ if (cursor.hasLength(min_request_len) == false) {
+ return error.Incomplete;
+ }
+
+ // WS requests can only be send w/ GET method.
+ if (!cursor.peek4('G', 'E', 'T', ' ')) {
+ return error.Invalid;
+ }
+ cursor.advance(4);
+
+ const path_start = cursor.current();
+ // Find the first space.
+ while (cursor.end - cursor.current() > 0 and cursor.char() != ' ') : (cursor.advance(1)) {}
+ const path_end = cursor.current();
+ // 0 length path.
+ if (path_start == path_end) {
+ return error.Invalid;
+ }
+ const path = path_start[0 .. path_end - path_start];
+ _ = path;
+
+ // Skip past the delimiting space(s); the scan above guarantees we're on
+ // a space or at the end, and recipients may parse on whitespace
+ // boundaries (RFC 9112 §3).
+ while (cursor.end - cursor.current() > 0 and cursor.char() == ' ') : (cursor.advance(1)) {}
+
+ // HTTP/1.1(\r)\n
+ if (cursor.hasLength(9) == false) {
+ return error.Incomplete;
+ }
+ // Make sure we got HTTP/1.1.
+ if (cursor.asInteger(u64) != @as(u64, @bitCast(@as([]const u8, "HTTP/1.1")[0..8].*))) {
+ return error.Invalid;
+ }
+ cursor.advance(8);
+
+ // Trailing (CR)LF.
+ switch (cursor.char()) {
+ '\n' => cursor.advance(1),
+ '\r' => {
+ // We need an LF too.
+ if (!cursor.hasLength(2)) {
+ return error.Incomplete;
+ }
+ if (!cursor.peek2('\r', '\n')) {
+ @branchHint(.unlikely);
+ return error.Invalid;
+ }
+ cursor.advance(2);
+ },
+ // Any other character is invalid.
+ else => return error.Invalid,
+ }
+}
+
pub const Disposition = struct {
name: ?[]const u8 = null,
filename: ?[]const u8 = null,
@@ -342,6 +402,12 @@ pub const Cursor = struct {
return cursor.asInteger(u16) == @as(u16, @bitCast([2]u8{ c0, c1 }));
}
+ /// Peek the current and next 3 characters but don't advance.
+ /// SAFETY: This function doesn't check if out of bounds reachable.
+ pub fn peek4(cursor: *const Cursor, c0: u8, c1: u8, c2: u8, c3: u8) bool {
+ return cursor.asInteger(u32) == @as(u32, @bitCast([4]u8{ c0, c1, c2, c3 }));
+ }
+
/// Moves the cursor until no leading spaces there are.
pub fn skipSpaces(cursor: *Cursor) void {
while (cursor.end - cursor.current() > 0 and (cursor.char() == ' ' or cursor.char() == '\t')) : (cursor.advance(1)) {}