wip

Author: krichprollsch

src/cdp/domains/fetch.zig

@@ -32,12 +32,14 @@ pub fn processMessage(cmd: anytype) !void {
         continueRequest,
         failRequest,
         fulfillRequest,
+        continueWithAuth,
     }, cmd.input.action) orelse return error.UnknownMethod;
 
     switch (action) {
         .disable => return disable(cmd),
         .enable => return enable(cmd),
         .continueRequest => return continueRequest(cmd),
+        .continueWithAuth => return continueWithAuth(cmd),
         .failRequest => return failRequest(cmd),
         .fulfillRequest => return fulfillRequest(cmd),
     }
@@ -272,6 +274,60 @@ fn continueRequest(cmd: anytype) !void {
     return cmd.sendResult(null, .{});
 }
 
+fn continueWithAuth(cmd: anytype) !void {
+    const bc = cmd.browser_context orelse return error.BrowserContextNotLoaded;
+    const params = (try cmd.params(struct {
+        requestId: []const u8, // "INTERCEPT-{d}"
+        authChallengeResponse: struct {
+            response: []const u8,
+            username: ?[]const u8,
+            password: ?[]const u8,
+        },
+    })) orelse return error.InvalidParams;
+
+    const page = bc.session.currentPage() orelse return error.PageNotLoaded;
+
+    var intercept_state = &bc.intercept_state;
+    const request_id = try idFromRequestId(params.requestId);
+    const transfer = intercept_state.remove(request_id) orelse return error.RequestNotFound;
+
+    log.debug(.cdp, "request intercept", .{
+        .state = "continue with auth",
+        .id = transfer.id,
+        .response = params.authChallengeResponse.response,
+    });
+
+    if (!std.mem.eql(u8, params.authChallengeResponse.response, "ProvideCredentials")) {
+        transfer.abort(); // Is it the correct way to cancel the transfer?
+        transfer.deinit();
+        return cmd.sendResult(null, .{});
+    }
+
+    // cancel the request, deinit the transfer on error.
+    errdefer {
+        transfer.abort(); // Is it the correct way to cancel the transfer?
+        transfer.deinit();
+    }
+
+    const username = params.authChallengeResponse.username orelse "";
+    const password = params.authChallengeResponse.password orelse "";
+
+    // restart the request with the provided credentials.
+    // we need to duplicate the cre
+    const arena = transfer.arena.allocator();
+    transfer.updateCredentials(
+        try std.fmt.allocPrintZ(arena, "{s}:{s}", .{ username, password }),
+    );
+
+    try bc.cdp.browser.http_client.process(transfer);
+
+    if (intercept_state.empty()) {
+        page.request_intercepted = false;
+    }
+
+    return cmd.sendResult(null, .{});
+}
+
 fn fulfillRequest(cmd: anytype) !void {
     const bc = cmd.browser_context orelse return error.BrowserContextNotLoaded;
 
@@ -371,7 +427,6 @@ const AuthChallenge = struct {
 };
 
 pub fn requestAuthRequired(arena: Allocator, bc: anytype, intercept: *const Notification.RequestAuthRequired) !void {
-    std.log.debug("AUTH REQU FETCH\n", .{});
     // unreachable because we _have_ to have a page.
     const session_id = bc.session_id orelse unreachable;
     const target_id = bc.target_id orelse unreachable;

src/http/Client.zig

@@ -331,6 +331,11 @@ fn makeRequest(self: *Client, handle: *Handle, transfer: *Transfer) !void {
             try errorCheck(c.curl_easy_setopt(easy, c.CURLOPT_COOKIE, cookies));
         }
 
+        // Proxy credentials
+        if (req.credentials) |creds| {
+            try errorCheck(c.curl_easy_setopt(easy, c.CURLOPT_PROXYUSERPWD, creds.ptr));
+        }
+
         try errorCheck(c.curl_easy_setopt(easy, c.CURLOPT_PRIVATE, transfer));
     }
 
@@ -383,7 +388,10 @@ fn perform(self: *Client, timeout_ms: c_int) !void {
         // If the transfer is waiting for auth challenge interception, don't
         // deinit the transfer and don't call the callbacks. All will be done
         // later during the interception's response.
+        // we only reset the transfer to release the handle and be reused later.
         if (transfer._auth_challenge) {
+            log.debug(.http, "transfer reset", .{});
+            transfer.reset();
             continue;
         }
 
@@ -551,6 +559,7 @@ pub const Request = struct {
     body: ?[]const u8 = null,
     cookie_jar: *CookieJar,
     resource_type: ResourceType,
+    credentials: ?[:0]const u8 = null,
 
     // arbitrary data that can be associated with this request
     ctx: *anyopaque = undefined,
@@ -599,7 +608,7 @@ pub const Transfer = struct {
     // stateful variables used to parse responses headers.
     _resp_header_status: enum { empty, first, next, end } = .empty,
 
-    fn deinit(self: *Transfer) void {
+    pub fn deinit(self: *Transfer) void {
         self.req.headers.deinit();
         if (self._handle) |handle| {
             self.client.handles.release(handle);
@@ -608,6 +617,21 @@ pub const Transfer = struct {
         self.client.transfer_pool.destroy(self);
     }
 
+    fn reset(self: *Transfer) void {
+        if (self._handle) |handle| {
+            self.client.handles.release(handle);
+            self._handle = null;
+        }
+        self.bytes_received = 0;
+        self.proxy_response_header = null;
+        self.response_header = null;
+        self._notified_fail = false;
+        self._redirecting = false;
+        self._auth_challenge = false;
+        self._use_proxy = false;
+        self._resp_header_status = .empty;
+    }
+
     pub fn format(self: *const Transfer, comptime _: []const u8, _: std.fmt.FormatOptions, writer: anytype) !void {
         const req = self.req;
         return writer.print("{s} {s}", .{ @tagName(req.method), req.url });
@@ -623,6 +647,10 @@ pub const Transfer = struct {
         self._request_header_list = c.curl_slist_append(self._request_header_list, value);
     }
 
+    pub fn updateCredentials(self: *Transfer, userpwd: [:0]const u8) void {
+        self.req.credentials = userpwd;
+    }
+
     pub fn updateURL(self: *Transfer, url: [:0]const u8) !void {
         // for cookies
         self.uri = try std.Uri.parse(url);
@@ -816,10 +844,12 @@ pub const Transfer = struct {
                 // We won't call the req's callbacks now, but for the following request only.
                 const status = transfer.response_header.?.status;
                 if (status == 401 or status == 407) {
+                    log.debug(.http, "FORBIDDEN", .{});
                     if (transfer.client.notification) |notification| {
                         var wait_for_interception = false;
                         notification.dispatch(.http_request_auth_required, &.{ .transfer = transfer, .wait_for_interception = &wait_for_interception });
                         if (wait_for_interception) {
+                            log.debug(.http, "WAIT FOR INTERCEPT", .{});
                             transfer._auth_challenge = true;
                             // The user is send an invitation to intercept this request.
                             return buf_len;