Merge pull request #946 from lightpanda-io/request_interception

Request Interception

src/http/Http.zig

@@ -22,14 +22,15 @@ pub const c = @cImport({
     @cInclude("curl/curl.h");
 });
 
-const Client = @import("Client.zig");
+pub const ENABLE_DEBUG = false;
+pub const Client = @import("Client.zig");
+pub const Transfer = Client.Transfer;
+
 const errors = @import("errors.zig");
 
 const Allocator = std.mem.Allocator;
 const ArenaAllocator = std.heap.ArenaAllocator;
 
-pub const ENABLE_DEBUG = false;
-
 // Client.zig does the bulk of the work and is loosely tied to a browser Page.
 // But we still need something above Client.zig for the "utility" http stuff
 // we need to do, like telemetry. The most important thing we want from this
@@ -216,6 +217,11 @@ pub const Connection = struct {
     }
 };
 
+pub const Header = struct {
+    name: []const u8,
+    value: []const u8,
+};
+
 pub const Headers = struct {
     headers: *c.curl_slist,
     cookies: ?[*c]const u8,
@@ -237,25 +243,7 @@ pub const Headers = struct {
         self.headers = updated_headers;
     }
 
-    pub fn asHashMap(self: *const Headers, allocator: Allocator) !std.StringArrayHashMapUnmanaged([]const u8) {
-        var list: std.StringArrayHashMapUnmanaged([]const u8) = .empty;
-        try list.ensureTotalCapacity(allocator, self.count());
-
-        var current: [*c]c.curl_slist = self.headers;
-        while (current) |node| {
-            const str = std.mem.span(@as([*:0]const u8, @ptrCast(node.*.data)));
-            const header = parseHeader(str) orelse return error.InvalidHeader;
-            list.putAssumeCapacity(header.name, header.value);
-            current = node.*.next;
-        }
-        // special case for cookies
-        if (self.cookies) |v| {
-            list.putAssumeCapacity("Cookie", std.mem.span(@as([*:0]const u8, @ptrCast(v))));
-        }
-        return list;
-    }
-
-    pub fn parseHeader(header_str: []const u8) ?std.http.Header {
+    pub fn parseHeader(header_str: []const u8) ?Header {
         const colon_pos = std.mem.indexOfScalar(u8, header_str, ':') orelse return null;
 
         const name = std.mem.trim(u8, header_str[0..colon_pos], " \t");
@@ -264,19 +252,28 @@ pub const Headers = struct {
         return .{ .name = name, .value = value };
     }
 
-    pub fn count(self: *const Headers) usize {
-        var current: [*c]c.curl_slist = self.headers;
-        var num: usize = 0;
-        while (current) |node| {
-            num += 1;
-            current = node.*.next;
-        }
-        // special case for cookies
-        if (self.cookies != null) {
-            num += 1;
-        }
-        return num;
+    pub fn iterator(self: *Headers) Iterator {
+        return .{
+            .header = self.headers,
+            .cookies = self.cookies,
+        };
     }
+
+    const Iterator = struct {
+        header: [*c]c.curl_slist,
+        cookies: ?[*c]const u8,
+
+        pub fn next(self: *Iterator) ?Header {
+            const h = self.header orelse {
+                const cookies = self.cookies orelse return null;
+                self.cookies = null;
+                return .{ .name = "Cookie", .value = std.mem.span(@as([*:0]const u8, cookies)) };
+            };
+
+            self.header = h.*.next;
+            return parseHeader(std.mem.span(@as([*:0]const u8, @ptrCast(h.*.data))));
+        }
+    };
 };
 
 pub fn errorCheck(code: c.CURLcode) errors.Error!void {