Skip to content

Lightpanda: the headless browser designed for AI and automation

webapi: XHR response header compliance

Karl Seguin4e9f3bf6a299
diff --git a/src/browser/tests/net/xhr.html b/src/browser/tests/net/xhr.html
index ab223e09c..9cccdd279 100644
--- a/src/browser/tests/net/xhr.html
+++ b/src/browser/tests/net/xhr.html
@@ -820,6 +820,25 @@ handler runs, abort() cancels the re-send and no load is delivered.
}
</script>
+<script id=xhr_duplicate_response_headers type=module>
+ {
+ // Same-name headers combine with ", "; getAllResponseHeaders sorts by
+ // uppercased name, so "_" comes after letters.
+ const state = await testing.async();
+ const req = new XMLHttpRequest();
+ req.onload = (event) => state.resolve(event);
+ req.open('GET', 'http://127.0.0.1:9582/xhr/duplicate_headers');
+ req.send();
+
+ await state.done(() => {
+ testing.expectEqual('1, 2, 3', req.getResponseHeader('x-b'));
+ testing.expectEqual('a', req.getResponseHeader('X-A'));
+ testing.expectEqual(null, req.getResponseHeader('X'));
+ testing.expectEqual('content-length: 0\r\nx-a: a\r\nx-b: 1, 2, 3\r\nx_c: c\r\n', req.getAllResponseHeaders());
+ });
+ }
+</script>
+
<script id=xhr_sync_response_headers type=module>
{
// Sync XHR goes through HttpClient.submitSync; headers must still come
diff --git a/src/browser/webapi/net/XMLHttpRequest.zig b/src/browser/webapi/net/XMLHttpRequest.zig
index ae1ffb00f..f9f8e54fe 100644
--- a/src/browser/webapi/net/XMLHttpRequest.zig
+++ b/src/browser/webapi/net/XMLHttpRequest.zig
@@ -74,7 +74,7 @@ _response_mime: ?Mime = null,
_override_mime_raw: ?[]const u8 = null,
_response_mime_raw: ?[]const u8 = null,
_response_xml: ?*Node.Document = null,
-_response_headers: std.ArrayList([]const u8) = .empty,
+_response_headers: std.ArrayList(http.Header) = .empty,
_response_type: ResponseType = .default,
_ready_state: ReadyState = .unsent,
@@ -457,22 +457,35 @@ fn getReadyState(self: *const XMLHttpRequest) u32 {
return @backingInt(self._ready_state);
}
-pub fn getResponseHeader(self: *const XMLHttpRequest, name: []const u8) ?[]const u8 {
- for (self._response_headers.items) |entry| {
- if (entry.len <= name.len) {
- continue;
- }
- if (std.ascii.eqlIgnoreCase(name, entry[0..name.len]) == false) {
- continue;
+// Headers are sorted by name, so all values for `name` are contiguous.
+fn getResponseHeader(self: *const XMLHttpRequest, name: []const u8, exec: *const Execution) !?[]const u8 {
+ const items = self._response_headers.items;
+ const start = for (items, 0..) |hdr, i| {
+ if (std.ascii.eqlIgnoreCase(name, hdr.name)) {
+ break i;
}
- if (entry[name.len] != ':') {
- continue;
+ } else return null;
+
+ var end = start + 1;
+ while (end < items.len and std.mem.eql(u8, items[end].name, items[start].name)) {
+ end += 1;
+ }
+ if (end - start == 1) {
+ return items[start].value;
+ }
+
+ var buf: std.Io.Writer.Allocating = .init(exec.local_arena);
+ for (items[start..end], 0..) |hdr, i| {
+ if (i > 0) {
+ try buf.writer.writeAll(", ");
}
- return std.mem.trimStart(u8, entry[name.len + 1 ..], " ");
+ try buf.writer.writeAll(hdr.value);
}
- return null;
+ return buf.written();
}
+// Should return sorted and combined. They are already sorted, so combining
+// is easy.
fn getAllResponseHeaders(self: *const XMLHttpRequest, exec: *const Execution) ![]const u8 {
if (self._ready_state != .done) {
// MDN says this should return null, but it seems to return an empty string
@@ -480,9 +493,18 @@ fn getAllResponseHeaders(self: *const XMLHttpRequest, exec: *const Execution) ![
return "";
}
- var buf = std.Io.Writer.Allocating.init(exec.local_arena);
- for (self._response_headers.items) |entry| {
- try buf.writer.writeAll(entry);
+ var buf: std.Io.Writer.Allocating = .init(exec.local_arena);
+ for (self._response_headers.items, 0..) |hdr, i| {
+ if (i > 0 and std.mem.eql(u8, hdr.name, self._response_headers.items[i - 1].name)) {
+ try buf.writer.print(", {s}", .{hdr.value});
+ continue;
+ }
+ if (i > 0) {
+ try buf.writer.writeAll("\r\n");
+ }
+ try buf.writer.print("{s}: {s}", .{ hdr.name, hdr.value });
+ }
+ if (self._response_headers.items.len > 0) {
try buf.writer.writeAll("\r\n");
}
return buf.written();
@@ -655,13 +677,31 @@ fn applyContentType(self: *XMLHttpRequest, content_type: []const u8) !void {
}
fn applyResponseHeaders(self: *XMLHttpRequest, headers: []const http.Header) !void {
+ const allocator = self._arena.allocator();
for (headers) |hdr| {
if (Headers.isForbiddenResponseHeaderName(hdr.name)) {
continue;
}
- const joined = try self._arena.allocator().print("{s}: {s}", .{ hdr.name, hdr.value });
- try self._response_headers.append(self._arena.allocator(), joined);
+ try self._response_headers.append(allocator, .{
+ .name = try allocator.dupe(u8, hdr.name),
+ .value = try allocator.dupe(u8, hdr.value),
+ });
}
+
+ // Comparison is by uppercased name...so things like _ sort after letters.
+ std.mem.sort(http.Header, self._response_headers.items, {}, struct {
+ fn lessThan(_: void, a: http.Header, b: http.Header) bool {
+ const len = @min(a.name.len, b.name.len);
+ for (a.name[0..len], b.name[0..len]) |ca, cb| {
+ const ua = std.ascii.toUpper(ca);
+ const ub = std.ascii.toUpper(cb);
+ if (ua != ub) {
+ return ua < ub;
+ }
+ }
+ return a.name.len < b.name.len;
+ }
+ }.lessThan);
}
fn httpHeaderDoneCallback(transfer: *Transfer) !Transfer.HeaderResult {
diff --git a/src/testing.zig b/src/testing.zig
index c738167f6..8efdcb04b 100644
--- a/src/testing.zig
+++ b/src/testing.zig
@@ -923,6 +923,17 @@ fn testHTTPHandler(req: *std.http.Server.Request) !void {
});
}
+ if (std.mem.eql(u8, path, "/xhr/duplicate_headers")) {
+ return req.respond("", .{
+ .extra_headers = &.{
+ .{ .name = "X-B", .value = "1" },
+ .{ .name = "X-A", .value = "a" },
+ .{ .name = "X-B", .value = "2, 3" },
+ .{ .name = "X_C", .value = "c" },
+ },
+ });
+ }
+
if (std.mem.eql(u8, path, "/xhr/401")) {
return req.respond("No", .{
.status = .unauthorized,