Lightpanda: the headless browser designed for AI and automation
add basic CorsGate scaffold
Muki Kiboigo212c806be571
diff --git a/src/log.zig b/src/log.zigindex 82ed15c6e..8afe305cc 100644--- a/src/log.zig+++ b/src/log.zig@@ -42,6 +42,7 @@ pub const Scope = enum {telemetry,unknown_prop,websocket,+ cors,};pub const num_scopes = @typeInfo(Scope).@"enum".fields.len;diff --git a/src/network/CorsGate.zig b/src/network/CorsGate.zignew file mode 100644index 000000000..ea4753f31--- /dev/null+++ b/src/network/CorsGate.zig@@ -0,0 +1,120 @@+// Copyright (C) 2023-2026 Lightpanda (Selecy SAS)+//+// Francis Bouvier <[email protected]>+// Pierre Tachoire <[email protected]>+//+// This program is free software: you can redistribute it and/or modify+// it under the terms of the GNU Affero General Public License as+// published by the Free Software Foundation, either version 3 of the+// License, or (at your option) any later version.+//+// This program is distributed in the hope that it will be useful,+// but WITHOUT ANY WARRANTY; without even the implied warranty of+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the+// GNU Affero General Public License for more details.+//+// You should have received a copy of the GNU Affero General Public License+// along with this program. If not, see <https://www.gnu.org/licenses/>.++const std = @import("std");+const lp = @import("lightpanda");++const URL = @import("../browser/URL.zig");+const ArenaPool = @import("../ArenaPool.zig");++const http = @import("http.zig");+const Network = @import("Network.zig");+const Transfer = @import("HttpClient.zig").Transfer;+const SingleFlight = @import("SingleFlight.zig");++const log = lp.log;+const Allocator = std.mem.Allocator;++const CorsGate = @This();++network: *Network,+single_flight: SingleFlight,++pub fn deinit(self: *CorsGate) void {+ self.single_flight.deinit();+}++pub fn remove(self: *CorsGate, transfer: *Transfer) void {+ self.single_flight.remove(transfer);+}++fn flushPending(self: *CorsGate, key: []const u8, allowed: bool) void {+ var queued = self.single_flight.take(key) orelse return;+ defer queued.deinit(self.single_flight.allocator);++ for (queued.items) |transfer| {+ transfer.unpark();++ if (!allowed) {+ log.warn(.http, "blocked by cors (preflight)", .{ .url = transfer.req.url });+ transfer.failAsync(error.CorsBlocked);+ continue;+ }++ transfer.client.resumeAfterCors(transfer) catch |e| {+ transfer.abortPipelineError(e);+ };+ }+}++fn isSafelistedContentType(value: []const u8) bool {+ const semi = std.mem.indexOfScalar(u8, value, ';') orelse value.len;+ const mime = std.mem.trim(u8, value[0..semi], &std.ascii.whitespace);+ return std.ascii.eqlIgnoreCase(mime, "application/x-www-form-urlencoded") or+ std.ascii.eqlIgnoreCase(mime, "multipart/form-data") or+ std.ascii.eqlIgnoreCase(mime, "text/plain");+}++fn isSafelistedHeader(name: []const u8, value: []const u8) bool {+ if (std.ascii.eqlIgnoreCase(name, "accept") or+ std.ascii.eqlIgnoreCase(name, "accept-language") or+ std.ascii.eqlIgnoreCase(name, "content-language"))+ {+ return true;+ }+ if (std.ascii.eqlIgnoreCase(name, "content-type")) {+ return isSafelistedContentType(value);+ }+ return false;+}++fn requiresPreflight(transfer: *const Transfer) bool {+ const req = &transfer.req;++ switch (req.method) {+ .GET, .HEAD, .POST => {},+ else => return true,+ }++ for (transfer.req_headers.items) |hdr| {+ // Only authored headers can trigger a preflight+ if (hdr.source != .author) continue;+ if (!isSafelistedHeader(hdr.name, hdr.value)) return true;+ }++ return false;+}++const Result = enum { allowed, blocked, pending };++pub fn check(self: *CorsGate, transfer: *Transfer) !Result {+ _ = self;+ const req = &transfer.req;++ if (req.origin) |origin| {+ if (URL.isSameOrigin(req.url, origin)) {+ log.debug(.cors, "same origin", .{ .url = req.url, .origin = origin });+ return .allowed;+ }+ }++ log.debug(.cors, "cross origin", .{ .url = req.url, .origin = req.origin orelse "null" });+ transfer._cors_cross_origin = true;++ return .blocked;+}diff --git a/src/network/HttpClient.zig b/src/network/HttpClient.zigindex 936a6f4f1..f871fc703 100644--- a/src/network/HttpClient.zig+++ b/src/network/HttpClient.zig@@ -35,6 +35,7 @@ const http = @import("http.zig");const Network = @import("Network.zig");const Cache = @import("cache/Cache.zig");const RobotsGate = @import("RobotsGate.zig");+const CorsGate = @import("CorsGate.zig");const UrlBlocklist = @import("UrlBlocklist.zig");pub const BlockPattern = UrlBlocklist.Pattern;@@ -187,6 +188,7 @@ obey_robots: bool,http_version: lp.Config.HttpVersion,robots: RobotsGate,+cors: CorsGate,url_blocklist: ?UrlBlocklist,pub fn init(self: *Client, app: *lp.App) !void {@@ -233,6 +235,10 @@ pub fn init(self: *Client, app: *lp.App) !void {.network = network,.single_flight = .init(allocator),},+ .cors = .{+ .network = network,+ .single_flight = .init(allocator),+ },.url_blocklist = url_blocklist,.arena_pool = &app.arena_pool,};@@ -264,6 +270,7 @@ pub fn deinit(self: *Client) void {self.clearUrlBlocklist();self.robots.deinit();+ self.cors.deinit();self.blocking_requests.deinit(self.allocator);self.transfers.deinit(self.allocator);self.cache.maintenance(lp.datetime.timestamp(.real));@@ -461,6 +468,7 @@ pub fn abort(self: *Client) void {// - self.robots.pending : each robots fetch's shutdown_callback// drops its entry; parked waiters unlink in their own deinit.std.debug.assert(self.robots.single_flight.count() == 0);+ std.debug.assert(self.cors.single_flight.count() == 0);}}@@ -962,6 +970,7 @@ const SubmitFrom = enum {start, // Transfer.submit — a brand new request.redirect, // Followed 3xx. Same as .start, but a distinct name (e.g. for CDP)after_intercept, // Released by CDP+ after_cors, // cors allowed the request.throttle, // the robots gate allowed the request.network, // released by throttle};@@ -1015,9 +1024,18 @@ fn pipeline(self: *Client, transfer: *Transfer, from: SubmitFrom) !void {return transfer.failAsync(error.UrlBlocked);}if (try self.cacheLookup(transfer)) {- // response came from the cache, we're donereturn;}+ if (!transfer.req.internal) {+ switch (try self.cors.check(transfer)) {+ .allowed => {},+ .blocked => return transfer.failAsync(error.CorsBlocked),+ .pending => return,+ }+ }+ continue :sw SubmitFrom.after_cors;+ },+ .after_cors => {if (self.obey_robots and !transfer.req.internal) {switch (try self.robots.check(transfer)) {.allowed => {@@ -1059,6 +1077,12 @@ pub fn resumeAfterRobots(self: *Client, transfer: *Transfer) !void {return self.pipeline(transfer, .throttle);}+// CorsGate resumption after a preflight resolves as allowed. Re-enters+// right after the CORS step (not .after_intercept)+pub fn resumeAfterCors(self: *Client, transfer: *Transfer) !void {+ return self.pipeline(transfer, .after_cors);+}+fn findHeader(headers: []const http.Header, name: []const u8) ?[]const u8 {for (headers) |hdr| {if (std.ascii.eqlIgnoreCase(hdr.name, name)) {@@ -2162,6 +2186,8 @@ pub const Transfer = struct {// everything and sits on client.graveyard_retired: bool = false,+ _cors_cross_origin: bool = false,+pub const State = union(enum) {// Pre-commit. Only valid inside the request flow (Client.request// or a re-entry like continueTransfer / unpark) before any commit@@ -2214,6 +2240,9 @@ pub const Transfer = struct {// RobotsGate holds the transfer pending a robots.txt fetch.robots,++ // CorsGate holds the tranfer pending a CORS preflight.+ cors,};pub const HeaderResult = enum {@@ -2249,7 +2278,7 @@ pub const Transfer = struct {return;}switch (self.state.parked) {- .robots => {},+ .robots, .cors => {},.intercept_request, .intercept_auth => {lp.assert(self.client.intercepted > 0, "Transfer.leaveIntercept", .{ .value = self.client.intercepted });self.client.intercepted -= 1;@@ -2388,8 +2417,12 @@ pub const Transfer = struct {// And for the robots gate: RobotsGate.pending holds a raw *Transfer// while we're parked.- if (self.state == .parked and self.state.parked == .robots) {- self.client.robots.remove(self);+ if (self.state == .parked) {+ switch (self.state.parked) {+ .cors => self.client.cors.remove(self),+ .robots => self.client.robots.remove(self),+ .intercept_auth, .intercept_request => {},+ }}// A pending revalidation entry owns cache resources (possibly an