3# This is a combination of 3 commits.

intercept continue and abort

feedback

First version of headers, no cookies yet

src/cdp/domains/fetch.zig

@@ -1,4 +1,4 @@
-// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
+// Copyright (C) 2023-2025    Lightpanda (Selecy SAS)
 //
 // Francis Bouvier <francis@lightpanda.io>
 // Pierre Tachoire <pierre@lightpanda.io>
@@ -17,13 +17,211 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 const std = @import("std");
+const Allocator = std.mem.Allocator;
+const Notification = @import("../../notification.zig").Notification;
+const log = @import("../../log.zig");
+const Request = @import("../../http/Client.zig").Request;
+const Method = @import("../../http/Client.zig").Method;
 
 pub fn processMessage(cmd: anytype) !void {
     const action = std.meta.stringToEnum(enum {
         disable,
+        enable,
+        continueRequest,
+        failRequest,
     }, cmd.input.action) orelse return error.UnknownMethod;
 
     switch (action) {
-        .disable => return cmd.sendResult(null, .{}),
+        .disable => return disable(cmd),
+        .enable => return enable(cmd),
+        .continueRequest => return continueRequest(cmd),
+        .failRequest => return failRequest(cmd),
     }
 }
+
+// Stored in CDP
+pub const InterceptState = struct {
+    const Self = @This();
+    waiting: std.AutoArrayHashMap(u64, Request),
+
+    pub fn init(allocator: Allocator) !InterceptState {
+        return .{
+            .waiting = std.AutoArrayHashMap(u64, Request).init(allocator),
+        };
+    }
+
+    pub fn deinit(self: *Self) void {
+        self.waiting.deinit();
+    }
+};
+
+const RequestPattern = struct {
+    urlPattern: []const u8 = "*", // Wildcards ('*' -> zero or more, '?' -> exactly one) are allowed. Escape character is backslash. Omitting is equivalent to "*".
+    resourceType: ?ResourceType = null,
+    requestStage: RequestStage = .Request,
+};
+const ResourceType = enum {
+    Document,
+    Stylesheet,
+    Image,
+    Media,
+    Font,
+    Script,
+    TextTrack,
+    XHR,
+    Fetch,
+    Prefetch,
+    EventSource,
+    WebSocket,
+    Manifest,
+    SignedExchange,
+    Ping,
+    CSPViolationReport,
+    Preflight,
+    FedCM,
+    Other,
+};
+const RequestStage = enum {
+    Request,
+    Response,
+};
+
+const EnableParam = struct {
+    patterns: []RequestPattern = &.{},
+    handleAuthRequests: bool = false,
+};
+const ErrorReason = enum {
+    Failed,
+    Aborted,
+    TimedOut,
+    AccessDenied,
+    ConnectionClosed,
+    ConnectionReset,
+    ConnectionRefused,
+    ConnectionAborted,
+    ConnectionFailed,
+    NameNotResolved,
+    InternetDisconnected,
+    AddressUnreachable,
+    BlockedByClient,
+    BlockedByResponse,
+};
+
+fn disable(cmd: anytype) !void {
+    const bc = cmd.browser_context orelse return error.BrowserContextNotLoaded;
+    bc.fetchDisable();
+    return cmd.sendResult(null, .{});
+}
+
+fn enable(cmd: anytype) !void {
+    const params = (try cmd.params(EnableParam)) orelse EnableParam{};
+    if (params.patterns.len != 0) log.warn(.cdp, "Fetch.enable No patterns yet", .{});
+    if (params.handleAuthRequests) log.warn(.cdp, "Fetch.enable No auth yet", .{});
+
+    const bc = cmd.browser_context orelse return error.BrowserContextNotLoaded;
+    try bc.fetchEnable();
+
+    return cmd.sendResult(null, .{});
+}
+
+pub fn requestPaused(arena: Allocator, bc: anytype, intercept: *const Notification.RequestIntercept) !void {
+    var cdp = bc.cdp;
+
+    // unreachable because we _have_ to have a page.
+    const session_id = bc.session_id orelse unreachable;
+    const target_id = bc.target_id orelse unreachable;
+
+    // We keep it around to wait for modifications to the request.
+    // NOTE: we assume whomever created the request created it with a lifetime of the Page.
+    // TODO: What to do when receiving replies for a previous page's requests?
+
+    try cdp.intercept_state.waiting.put(intercept.request.id.?, intercept.request.*);
+
+    // NOTE: .request data preparation is duped from network.zig
+    const full_request_url = try std.Uri.parse(intercept.request.url);
+    const request_url = try @import("network.zig").urlToString(arena, &full_request_url, .{
+        .scheme = true,
+        .authentication = true,
+        .authority = true,
+        .path = true,
+        .query = true,
+    });
+    const request_fragment = try @import("network.zig").urlToString(arena, &full_request_url, .{
+        .fragment = true,
+    });
+    const headers = try intercept.request.headers.asHashMap(arena);
+    // End of duped code
+
+    try cdp.sendEvent("Fetch.requestPaused", .{
+        .requestId = try std.fmt.allocPrint(arena, "INTERCEPT-{d}", .{intercept.request.id.?}),
+        .request = .{
+            .url = request_url,
+            .urlFragment = request_fragment,
+            .method = @tagName(intercept.request.method),
+            .hasPostData = intercept.request.body != null,
+            .headers = std.json.ArrayHashMap([]const u8){ .map = headers },
+        },
+        .frameId = target_id,
+        .resourceType = ResourceType.Document, //  TODO!
+        .networkId = try std.fmt.allocPrint(arena, "REQ-{d}", .{intercept.request.id.?}),
+    }, .{ .session_id = session_id });
+
+    // Await either continueRequest, failRequest or fulfillRequest
+    intercept.wait_for_interception.* = true;
+}
+
+const HeaderEntry = struct {
+    name: []const u8,
+    value: []const u8,
+};
+
+fn continueRequest(cmd: anytype) !void {
+    const bc = cmd.browser_context orelse return error.BrowserContextNotLoaded;
+    const params = (try cmd.params(struct {
+        requestId: []const u8, // "INTERCEPT-{d}"
+        url: ?[]const u8 = null,
+        method: ?[]const u8 = null,
+        postData: ?[]const u8 = null,
+        headers: ?[]const HeaderEntry = null,
+        interceptResponse: bool = false,
+    })) orelse return error.InvalidParams;
+    if (params.postData != null or params.headers != null or params.interceptResponse) return error.NotYetImplementedParams;
+
+    const request_id = try idFromRequestId(params.requestId);
+    var waiting_request = (bc.cdp.intercept_state.waiting.fetchSwapRemove(request_id) orelse return error.RequestNotFound).value;
+
+    // Update the request with the new parameters
+    if (params.url) |url| {
+        // The request url must be modified in a way that's not observable by page. So page.url is not updated.
+        waiting_request.url = try bc.cdp.browser.page_arena.allocator().dupeZ(u8, url);
+    }
+    if (params.method) |method| {
+        waiting_request.method = std.meta.stringToEnum(Method, method) orelse return error.InvalidParams;
+    }
+
+    log.info(.cdp, "Request continued by intercept", .{ .id = params.requestId });
+    try bc.cdp.browser.http_client.request(waiting_request);
+
+    return cmd.sendResult(null, .{});
+}
+
+fn failRequest(cmd: anytype) !void {
+    const bc = cmd.browser_context orelse return error.BrowserContextNotLoaded;
+    var state = &bc.cdp.intercept_state;
+    const params = (try cmd.params(struct {
+        requestId: []const u8, // "INTERCEPT-{d}"
+        errorReason: ErrorReason,
+    })) orelse return error.InvalidParams;
+
+    const request_id = try idFromRequestId(params.requestId);
+    if (state.waiting.fetchSwapRemove(request_id) == null) return error.RequestNotFound;
+
+    log.info(.cdp, "Request aborted by intercept", .{ .reason = params.errorReason });
+    return cmd.sendResult(null, .{});
+}
+
+// Get u64 from requestId which is formatted as: "INTERCEPT-{d}"
+fn idFromRequestId(request_id: []const u8) !u64 {
+    if (!std.mem.startsWith(u8, request_id, "INTERCEPT-")) return error.InvalidParams;
+    return std.fmt.parseInt(u64, request_id[10..], 10) catch return error.InvalidParams;
+}