Skip to content

Lightpanda: the headless browser designed for AI and automation

32.2 KB
Raw Blame
// 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 crypto = @import("libcrypto.zig");

const c = @import("curl");

pub const Curl = c.CURL;
pub const CurlM = c.CURLM;
pub const CurlSH = c.CURLSH;
pub const CurlCode = c.CURLcode;
pub const CurlSList = c.curl_slist;
pub const CurlHeader = c.curl_header;
pub const CurlSocket = c.curl_socket_t;
const CurlOffT = c.curl_off_t;

pub const CURLE = struct {
    pub const OK = c.CURLE_OK;
    pub const ABORTED_BY_CALLBACK = c.CURLE_ABORTED_BY_CALLBACK;
};

pub const CurlHeaderFunction = *const fn ([*]const u8, usize, usize, *anyopaque) callconv(.c) usize;
pub const CurlWriteFunction = *const fn ([*]const u8, usize, usize, *anyopaque) callconv(.c) usize;
pub const curl_writefunc_error: usize = c.CURL_WRITEFUNC_ERROR;
pub const curl_readfunc_pause: usize = c.CURL_READFUNC_PAUSE;
pub const CurlReadFunction = *const fn ([*]u8, usize, usize, *anyopaque) callconv(.c) usize;
const CurlOpenSocketFunction = *const fn (?*anyopaque, c_uint, [*c]CurlSockAddr) callconv(.c) CurlSocket;
const CurlSslCtxFunction = *const fn (*Curl, *anyopaque, *anyopaque) callconv(.c) CurlCode;
const CurlDebugFunction = *const fn (*Curl, CurlInfoType, [*c]u8, usize, ?*anyopaque) callconv(.c) c_int;

pub const CurlSockType = enum(c.curlsocktype) {
    ipcxn = c.CURLSOCKTYPE_IPCXN,
    accept = c.CURLSOCKTYPE_ACCEPT,
};

/// Mirror of curl's struct curl_sockaddr. The addr field is a struct sockaddr
/// inline (not a pointer), so addrlen tells you how many bytes of addr are valid.
pub const CurlSockAddr = extern struct {
    family: c_int,
    socktype: c_int,
    protocol: c_int,
    addrlen: c_uint,
    addr: std.posix.sockaddr,
};

pub const CURL_SOCKET_BAD: c.curl_socket_t = c.CURL_SOCKET_BAD;

const FreeCallback = fn (ptr: ?*anyopaque) void;
const StrdupCallback = fn (str: [*:0]const u8) ?[*:0]u8;
const MallocCallback = fn (size: usize) ?*anyopaque;
const CallocCallback = fn (nmemb: usize, size: usize) ?*anyopaque;
const ReallocCallback = fn (ptr: ?*anyopaque, size: usize) ?*anyopaque;

const CurlAllocator = struct {
    free: FreeCallback,
    strdup: StrdupCallback,
    malloc: MallocCallback,
    calloc: CallocCallback,
    realloc: ReallocCallback,
};

const CurlGlobalFlags = packed struct(u8) {
    ssl: bool = false,
    _reserved: u7 = 0,

    fn to_c(self: @This()) c_long {
        var flags: c_long = 0;
        if (self.ssl) flags |= c.CURL_GLOBAL_SSL;
        return flags;
    }
};

const CurlHeaderOrigin = enum(c_uint) {
    header = c.CURLH_HEADER,
    trailer = c.CURLH_TRAILER,
    connect = c.CURLH_CONNECT,
    @"1xx" = c.CURLH_1XX,
    pseudo = c.CURLH_PSEUDO,
};

pub const CurlWaitEvents = packed struct(c_short) {
    pollin: bool = false,
    pollpri: bool = false,
    pollout: bool = false,
    _reserved: u13 = 0,
};

pub const CurlInfoType = enum(c.curl_infotype) {
    text = c.CURLINFO_TEXT,
    header_in = c.CURLINFO_HEADER_IN,
    header_out = c.CURLINFO_HEADER_OUT,
    data_in = c.CURLINFO_DATA_IN,
    data_out = c.CURLINFO_DATA_OUT,
    ssl_data_in = c.CURLINFO_SSL_DATA_IN,
    ssl_data_out = c.CURLINFO_SSL_DATA_OUT,
    end = c.CURLINFO_END,
};

pub const CurlWaitFd = extern struct {
    fd: CurlSocket,
    events: CurlWaitEvents,
    revents: CurlWaitEvents,
};

pub const CurlPauseFlags = packed struct(c_short) {
    recv: bool = false,
    send: bool = false,
    all: bool = false,
    cont: bool = false,
    _reserved: u12 = 0,

    fn to_c(self: @This()) c_int {
        var flags: c_int = 0;
        if (self.recv) flags |= c.CURLPAUSE_RECV;
        if (self.send) flags |= c.CURLPAUSE_SEND;
        if (self.all) flags |= c.CURLPAUSE_ALL;
        if (self.cont) flags |= c.CURLPAUSE_CONT;
        return flags;
    }
};

comptime {
    const debug_cb_check: c.curl_debug_callback = struct {
        fn cb(handle: ?*Curl, msg_type: c.curl_infotype, raw: [*c]u8, len: usize, user: ?*anyopaque) callconv(.c) c_int {
            _ = handle;
            _ = msg_type;
            _ = raw;
            _ = len;
            _ = user;
            return 0;
        }
    }.cb;
    const write_cb_check: c.curl_write_callback = struct {
        fn cb(buffer: [*c]u8, count: usize, len: usize, user: ?*anyopaque) callconv(.c) usize {
            _ = buffer;
            _ = count;
            _ = len;
            _ = user;
            return 0;
        }
    }.cb;
    const opensocket_cb_check: c.curl_opensocket_callback = struct {
        fn cb(clientp: ?*anyopaque, purpose: c.curlsocktype, address: [*c]c.curl_sockaddr) callconv(.c) c.curl_socket_t {
            _ = clientp;
            _ = purpose;
            _ = address;
            return CURL_SOCKET_BAD;
        }
    }.cb;
    _ = debug_cb_check;
    _ = write_cb_check;
    _ = opensocket_cb_check;

    if (@sizeOf(CurlWaitFd) != @sizeOf(c.curl_waitfd)) {
        @compileError("CurlWaitFd size mismatch");
    }
    if (@offsetOf(CurlWaitFd, "fd") != @offsetOf(c.curl_waitfd, "fd") or
        @offsetOf(CurlWaitFd, "events") != @offsetOf(c.curl_waitfd, "events") or
        @offsetOf(CurlWaitFd, "revents") != @offsetOf(c.curl_waitfd, "revents"))
    {
        @compileError("CurlWaitFd layout mismatch");
    }
    if (c.CURL_WAIT_POLLIN != 1 or c.CURL_WAIT_POLLPRI != 2 or c.CURL_WAIT_POLLOUT != 4) {
        @compileError("CURL_WAIT_* flag values don't match CurlWaitEvents packed struct bit layout");
    }
    if (@sizeOf(CurlSockAddr) != @sizeOf(c.curl_sockaddr)) {
        @compileError("CurlSockAddr size mismatch with curl_sockaddr");
    }
    if (@offsetOf(CurlSockAddr, "family") != @offsetOf(c.curl_sockaddr, "family") or
        @offsetOf(CurlSockAddr, "socktype") != @offsetOf(c.curl_sockaddr, "socktype") or
        @offsetOf(CurlSockAddr, "protocol") != @offsetOf(c.curl_sockaddr, "protocol") or
        @offsetOf(CurlSockAddr, "addrlen") != @offsetOf(c.curl_sockaddr, "addrlen") or
        @offsetOf(CurlSockAddr, "addr") != @offsetOf(c.curl_sockaddr, "addr"))
    {
        @compileError("CurlSockAddr layout mismatch with curl_sockaddr");
    }
}

const CurlOption = enum(c.CURLoption) {
    url = c.CURLOPT_URL,
    timeout_ms = c.CURLOPT_TIMEOUT_MS,
    connect_timeout_ms = c.CURLOPT_CONNECTTIMEOUT_MS,
    follow_location = c.CURLOPT_FOLLOWLOCATION,
    http_version = c.CURLOPT_HTTP_VERSION,
    proxy = c.CURLOPT_PROXY,
    ssl_verify_host = c.CURLOPT_SSL_VERIFYHOST,
    ssl_verify_peer = c.CURLOPT_SSL_VERIFYPEER,
    proxy_ssl_verify_host = c.CURLOPT_PROXY_SSL_VERIFYHOST,
    proxy_ssl_verify_peer = c.CURLOPT_PROXY_SSL_VERIFYPEER,
    accept_encoding = c.CURLOPT_ACCEPT_ENCODING,
    verbose = c.CURLOPT_VERBOSE,
    debug_function = c.CURLOPT_DEBUGFUNCTION,
    custom_request = c.CURLOPT_CUSTOMREQUEST,
    post = c.CURLOPT_POST,
    post_field_size = c.CURLOPT_POSTFIELDSIZE,
    copy_post_fields = c.CURLOPT_COPYPOSTFIELDS,
    http_get = c.CURLOPT_HTTPGET,
    no_body = c.CURLOPT_NOBODY,
    http_header = c.CURLOPT_HTTPHEADER,
    cookie = c.CURLOPT_COOKIE,
    private = c.CURLOPT_PRIVATE,
    proxy_user_pwd = c.CURLOPT_PROXYUSERPWD,
    user_pwd = c.CURLOPT_USERPWD,
    header_data = c.CURLOPT_HEADERDATA,
    header_function = c.CURLOPT_HEADERFUNCTION,
    write_data = c.CURLOPT_WRITEDATA,
    write_function = c.CURLOPT_WRITEFUNCTION,
    read_data = c.CURLOPT_READDATA,
    read_function = c.CURLOPT_READFUNCTION,
    connect_only = c.CURLOPT_CONNECT_ONLY,
    suppress_connect_headers = c.CURLOPT_SUPPRESS_CONNECT_HEADERS,
    forbid_reuse = c.CURLOPT_FORBID_REUSE,
    pipewait = c.CURLOPT_PIPEWAIT,
    upload = c.CURLOPT_UPLOAD,
    opensocket_function = c.CURLOPT_OPENSOCKETFUNCTION,
    opensocket_data = c.CURLOPT_OPENSOCKETDATA,
    ssl_ctx_function = c.CURLOPT_SSL_CTX_FUNCTION,
    ssl_ctx_data = c.CURLOPT_SSL_CTX_DATA,
    ssl_ec_curves = c.CURLOPT_SSL_EC_CURVES,
    connect_to = c.CURLOPT_CONNECT_TO,
    share = c.CURLOPT_SHARE,
    resolve = c.CURLOPT_RESOLVE,
};

pub const CurlHttpVersion = enum(c_long) {
    none = c.CURL_HTTP_VERSION_NONE, // libcurl's own defaults, picks the best
    v1_0 = c.CURL_HTTP_VERSION_1_0,
    v1_1 = c.CURL_HTTP_VERSION_1_1,
    v2 = c.CURL_HTTP_VERSION_2_0,
    v3 = c.CURL_HTTP_VERSION_3,
    _,
};

const CurlMOption = enum(c.CURLMoption) {
    max_host_connections = c.CURLMOPT_MAX_HOST_CONNECTIONS,
    max_connects = c.CURLMOPT_MAXCONNECTS,
};

pub const CurlInfo = enum(c.CURLINFO) {
    effective_url = c.CURLINFO_EFFECTIVE_URL,
    private = c.CURLINFO_PRIVATE,
    redirect_count = c.CURLINFO_REDIRECT_COUNT,
    response_code = c.CURLINFO_RESPONSE_CODE,
    connect_code = c.CURLINFO_HTTP_CONNECTCODE,
    total_time_t = c.CURLINFO_TOTAL_TIME_T,
    queue_time_t = c.CURLINFO_QUEUE_TIME_T,
    namelookup_time_t = c.CURLINFO_NAMELOOKUP_TIME_T,
    connect_time_t = c.CURLINFO_CONNECT_TIME_T,
    appconnect_time_t = c.CURLINFO_APPCONNECT_TIME_T,
    pretransfer_time_t = c.CURLINFO_PRETRANSFER_TIME_T,
    starttransfer_time_t = c.CURLINFO_STARTTRANSFER_TIME_T,
    size_download_t = c.CURLINFO_SIZE_DOWNLOAD_T,
    header_size = c.CURLINFO_HEADER_SIZE,
    http_version = c.CURLINFO_HTTP_VERSION,
    num_connects = c.CURLINFO_NUM_CONNECTS,
    conn_id = c.CURLINFO_CONN_ID,
};

pub const Error = error{
    UnsupportedProtocol,
    FailedInit,
    UrlMalformat,
    NotBuiltIn,
    CouldntResolveProxy,
    CouldntResolveHost,
    CouldntConnect,
    WeirdServerReply,
    RemoteAccessDenied,
    FtpAcceptFailed,
    FtpWeirdPassReply,
    FtpAcceptTimeout,
    FtpWeirdPasvReply,
    FtpWeird227Format,
    FtpCantGetHost,
    Http2,
    FtpCouldntSetType,
    PartialFile,
    FtpCouldntRetrFile,
    QuoteError,
    HttpReturnedError,
    WriteError,
    UploadFailed,
    ReadError,
    OutOfMemory,
    OperationTimedout,
    FtpPortFailed,
    FtpCouldntUseRest,
    RangeError,
    SslConnectError,
    BadDownloadResume,
    FileCouldntReadFile,
    LdapCannotBind,
    LdapSearchFailed,
    AbortedByCallback,
    BadFunctionArgument,
    InterfaceFailed,
    TooManyRedirects,
    UnknownOption,
    SetoptOptionSyntax,
    GotNothing,
    SslEngineNotfound,
    SslEngineSetfailed,
    SendError,
    RecvError,
    SslCertproblem,
    SslCipher,
    PeerFailedVerification,
    BadContentEncoding,
    FilesizeExceeded,
    UseSslFailed,
    SendFailRewind,
    SslEngineInitfailed,
    LoginDenied,
    TftpNotfound,
    TftpPerm,
    RemoteDiskFull,
    TftpIllegal,
    TftpUnknownid,
    RemoteFileExists,
    TftpNosuchuser,
    SslCacertBadfile,
    RemoteFileNotFound,
    Ssh,
    SslShutdownFailed,
    Again,
    SslCrlBadfile,
    SslIssuerError,
    FtpPretFailed,
    RtspCseqError,
    RtspSessionError,
    FtpBadFileList,
    ChunkFailed,
    NoConnectionAvailable,
    SslPinnedpubkeynotmatch,
    SslInvalidcertstatus,
    Http2Stream,
    RecursiveApiCall,
    AuthError,
    Http3,
    QuicConnectError,
    Proxy,
    SslClientcert,
    UnrecoverablePoll,
    TooLarge,
    Unknown,
};

fn errorFromCode(code: c.CURLcode) Error {
    if (comptime lp.IS_DEBUG) {
        std.debug.assert(code != c.CURLE_OK);
    }

    return switch (code) {
        c.CURLE_UNSUPPORTED_PROTOCOL => Error.UnsupportedProtocol,
        c.CURLE_FAILED_INIT => Error.FailedInit,
        c.CURLE_URL_MALFORMAT => Error.UrlMalformat,
        c.CURLE_NOT_BUILT_IN => Error.NotBuiltIn,
        c.CURLE_COULDNT_RESOLVE_PROXY => Error.CouldntResolveProxy,
        c.CURLE_COULDNT_RESOLVE_HOST => Error.CouldntResolveHost,
        c.CURLE_COULDNT_CONNECT => Error.CouldntConnect,
        c.CURLE_WEIRD_SERVER_REPLY => Error.WeirdServerReply,
        c.CURLE_REMOTE_ACCESS_DENIED => Error.RemoteAccessDenied,
        c.CURLE_FTP_ACCEPT_FAILED => Error.FtpAcceptFailed,
        c.CURLE_FTP_WEIRD_PASS_REPLY => Error.FtpWeirdPassReply,
        c.CURLE_FTP_ACCEPT_TIMEOUT => Error.FtpAcceptTimeout,
        c.CURLE_FTP_WEIRD_PASV_REPLY => Error.FtpWeirdPasvReply,
        c.CURLE_FTP_WEIRD_227_FORMAT => Error.FtpWeird227Format,
        c.CURLE_FTP_CANT_GET_HOST => Error.FtpCantGetHost,
        c.CURLE_HTTP2 => Error.Http2,
        c.CURLE_FTP_COULDNT_SET_TYPE => Error.FtpCouldntSetType,
        c.CURLE_PARTIAL_FILE => Error.PartialFile,
        c.CURLE_FTP_COULDNT_RETR_FILE => Error.FtpCouldntRetrFile,
        c.CURLE_QUOTE_ERROR => Error.QuoteError,
        c.CURLE_HTTP_RETURNED_ERROR => Error.HttpReturnedError,
        c.CURLE_WRITE_ERROR => Error.WriteError,
        c.CURLE_UPLOAD_FAILED => Error.UploadFailed,
        c.CURLE_READ_ERROR => Error.ReadError,
        c.CURLE_OUT_OF_MEMORY => Error.OutOfMemory,
        c.CURLE_OPERATION_TIMEDOUT => Error.OperationTimedout,
        c.CURLE_FTP_PORT_FAILED => Error.FtpPortFailed,
        c.CURLE_FTP_COULDNT_USE_REST => Error.FtpCouldntUseRest,
        c.CURLE_RANGE_ERROR => Error.RangeError,
        c.CURLE_SSL_CONNECT_ERROR => Error.SslConnectError,
        c.CURLE_BAD_DOWNLOAD_RESUME => Error.BadDownloadResume,
        c.CURLE_FILE_COULDNT_READ_FILE => Error.FileCouldntReadFile,
        c.CURLE_LDAP_CANNOT_BIND => Error.LdapCannotBind,
        c.CURLE_LDAP_SEARCH_FAILED => Error.LdapSearchFailed,
        c.CURLE_ABORTED_BY_CALLBACK => Error.AbortedByCallback,
        c.CURLE_BAD_FUNCTION_ARGUMENT => Error.BadFunctionArgument,
        c.CURLE_INTERFACE_FAILED => Error.InterfaceFailed,
        c.CURLE_TOO_MANY_REDIRECTS => Error.TooManyRedirects,
        c.CURLE_UNKNOWN_OPTION => Error.UnknownOption,
        c.CURLE_SETOPT_OPTION_SYNTAX => Error.SetoptOptionSyntax,
        c.CURLE_GOT_NOTHING => Error.GotNothing,
        c.CURLE_SSL_ENGINE_NOTFOUND => Error.SslEngineNotfound,
        c.CURLE_SSL_ENGINE_SETFAILED => Error.SslEngineSetfailed,
        c.CURLE_SEND_ERROR => Error.SendError,
        c.CURLE_RECV_ERROR => Error.RecvError,
        c.CURLE_SSL_CERTPROBLEM => Error.SslCertproblem,
        c.CURLE_SSL_CIPHER => Error.SslCipher,
        c.CURLE_PEER_FAILED_VERIFICATION => Error.PeerFailedVerification,
        c.CURLE_BAD_CONTENT_ENCODING => Error.BadContentEncoding,
        c.CURLE_FILESIZE_EXCEEDED => Error.FilesizeExceeded,
        c.CURLE_USE_SSL_FAILED => Error.UseSslFailed,
        c.CURLE_SEND_FAIL_REWIND => Error.SendFailRewind,
        c.CURLE_SSL_ENGINE_INITFAILED => Error.SslEngineInitfailed,
        c.CURLE_LOGIN_DENIED => Error.LoginDenied,
        c.CURLE_TFTP_NOTFOUND => Error.TftpNotfound,
        c.CURLE_TFTP_PERM => Error.TftpPerm,
        c.CURLE_REMOTE_DISK_FULL => Error.RemoteDiskFull,
        c.CURLE_TFTP_ILLEGAL => Error.TftpIllegal,
        c.CURLE_TFTP_UNKNOWNID => Error.TftpUnknownid,
        c.CURLE_REMOTE_FILE_EXISTS => Error.RemoteFileExists,
        c.CURLE_TFTP_NOSUCHUSER => Error.TftpNosuchuser,
        c.CURLE_SSL_CACERT_BADFILE => Error.SslCacertBadfile,
        c.CURLE_REMOTE_FILE_NOT_FOUND => Error.RemoteFileNotFound,
        c.CURLE_SSH => Error.Ssh,
        c.CURLE_SSL_SHUTDOWN_FAILED => Error.SslShutdownFailed,
        c.CURLE_AGAIN => Error.Again,
        c.CURLE_SSL_CRL_BADFILE => Error.SslCrlBadfile,
        c.CURLE_SSL_ISSUER_ERROR => Error.SslIssuerError,
        c.CURLE_FTP_PRET_FAILED => Error.FtpPretFailed,
        c.CURLE_RTSP_CSEQ_ERROR => Error.RtspCseqError,
        c.CURLE_RTSP_SESSION_ERROR => Error.RtspSessionError,
        c.CURLE_FTP_BAD_FILE_LIST => Error.FtpBadFileList,
        c.CURLE_CHUNK_FAILED => Error.ChunkFailed,
        c.CURLE_NO_CONNECTION_AVAILABLE => Error.NoConnectionAvailable,
        c.CURLE_SSL_PINNEDPUBKEYNOTMATCH => Error.SslPinnedpubkeynotmatch,
        c.CURLE_SSL_INVALIDCERTSTATUS => Error.SslInvalidcertstatus,
        c.CURLE_HTTP2_STREAM => Error.Http2Stream,
        c.CURLE_RECURSIVE_API_CALL => Error.RecursiveApiCall,
        c.CURLE_AUTH_ERROR => Error.AuthError,
        c.CURLE_HTTP3 => Error.Http3,
        c.CURLE_QUIC_CONNECT_ERROR => Error.QuicConnectError,
        c.CURLE_PROXY => Error.Proxy,
        c.CURLE_SSL_CLIENTCERT => Error.SslClientcert,
        c.CURLE_UNRECOVERABLE_POLL => Error.UnrecoverablePoll,
        c.CURLE_TOO_LARGE => Error.TooLarge,
        else => Error.Unknown,
    };
}

const ErrorMulti = error{
    BadHandle,
    BadEasyHandle,
    OutOfMemory,
    InternalError,
    BadSocket,
    UnknownOption,
    AddedAlready,
    RecursiveApiCall,
    WakeupFailure,
    BadFunctionArgument,
    AbortedByCallback,
    UnrecoverablePoll,
    Unknown,
};

const ErrorShare = error{
    BadOption,
    InUse,
    Invalid,
    OutOfMemory,
    NotBuiltIn,
    Unknown,
};

const ErrorHeader = error{
    OutOfMemory,
    BadArgument,
    NotBuiltIn,
    Unknown,
};

fn errorMFromCode(code: c.CURLMcode) ErrorMulti {
    if (comptime lp.IS_DEBUG) {
        std.debug.assert(code != c.CURLM_OK);
    }

    return switch (code) {
        c.CURLM_BAD_HANDLE => ErrorMulti.BadHandle,
        c.CURLM_BAD_EASY_HANDLE => ErrorMulti.BadEasyHandle,
        c.CURLM_OUT_OF_MEMORY => ErrorMulti.OutOfMemory,
        c.CURLM_INTERNAL_ERROR => ErrorMulti.InternalError,
        c.CURLM_BAD_SOCKET => ErrorMulti.BadSocket,
        c.CURLM_UNKNOWN_OPTION => ErrorMulti.UnknownOption,
        c.CURLM_ADDED_ALREADY => ErrorMulti.AddedAlready,
        c.CURLM_RECURSIVE_API_CALL => ErrorMulti.RecursiveApiCall,
        c.CURLM_WAKEUP_FAILURE => ErrorMulti.WakeupFailure,
        c.CURLM_BAD_FUNCTION_ARGUMENT => ErrorMulti.BadFunctionArgument,
        c.CURLM_ABORTED_BY_CALLBACK => ErrorMulti.AbortedByCallback,
        c.CURLM_UNRECOVERABLE_POLL => ErrorMulti.UnrecoverablePoll,
        else => ErrorMulti.Unknown,
    };
}

fn errorHFromCode(code: c.CURLHcode) ErrorHeader {
    if (comptime lp.IS_DEBUG) {
        std.debug.assert(code != c.CURLHE_OK);
    }

    return switch (code) {
        c.CURLHE_OUT_OF_MEMORY => ErrorHeader.OutOfMemory,
        c.CURLHE_BAD_ARGUMENT => ErrorHeader.BadArgument,
        c.CURLHE_NOT_BUILT_IN => ErrorHeader.NotBuiltIn,
        else => ErrorHeader.Unknown,
    };
}

fn errorCheck(code: c.CURLcode) Error!void {
    if (code == c.CURLE_OK) {
        return;
    }
    return errorFromCode(code);
}

fn errorMCheck(code: c.CURLMcode) ErrorMulti!void {
    if (code == c.CURLM_OK) {
        return;
    }
    if (code == c.CURLM_CALL_MULTI_PERFORM) {
        return;
    }
    return errorMFromCode(code);
}

const CurlMsgType = enum(c.CURLMSG) {
    none = c.CURLMSG_NONE,
    done = c.CURLMSG_DONE,
    last = c.CURLMSG_LAST,
};

const CurlMsgData = union(CurlMsgType) {
    none: ?*anyopaque,
    done: ?Error,
    last: ?*anyopaque,
};

const CurlMsg = struct {
    easy_handle: *Curl,
    data: CurlMsgData,
};

pub fn curl_global_init(flags: CurlGlobalFlags, comptime curl_allocator: ?CurlAllocator) Error!void {
    const alloc = curl_allocator orelse {
        return errorCheck(c.curl_global_init(flags.to_c()));
    };

    // The purpose of these wrappers is to hide callconv
    // and provide an easy place to add logging when debugging.
    const free = struct {
        fn cb(ptr: ?*anyopaque) callconv(.c) void {
            alloc.free(ptr);
        }
    }.cb;
    const strdup = struct {
        fn cb(str: [*c]const u8) callconv(.c) [*c]u8 {
            const s: [*:0]const u8 = @ptrCast(str orelse return null);
            return @ptrCast(alloc.strdup(s));
        }
    }.cb;
    const malloc = struct {
        fn cb(size: usize) callconv(.c) ?*anyopaque {
            return alloc.malloc(size);
        }
    }.cb;
    const calloc = struct {
        fn cb(nmemb: usize, size: usize) callconv(.c) ?*anyopaque {
            return alloc.calloc(nmemb, size);
        }
    }.cb;
    const realloc = struct {
        fn cb(ptr: ?*anyopaque, size: usize) callconv(.c) ?*anyopaque {
            return alloc.realloc(ptr, size);
        }
    }.cb;

    try errorCheck(c.curl_global_init_mem(flags.to_c(), malloc, free, realloc, strdup, calloc));
}

pub fn curl_global_cleanup() void {
    c.curl_global_cleanup();
}

pub fn curl_version() [*c]const u8 {
    return c.curl_version();
}

pub fn curl_easy_init() ?*Curl {
    return c.curl_easy_init();
}

pub fn curl_easy_cleanup(easy: *Curl) void {
    c.curl_easy_cleanup(easy);
}

pub fn curl_easy_reset(easy: *Curl) void {
    c.curl_easy_reset(easy);
}

pub fn curl_easy_perform(easy: *Curl) Error!void {
    try errorCheck(c.curl_easy_perform(easy));
}

pub fn curl_easy_setopt(easy: *Curl, comptime option: CurlOption, value: anytype) Error!void {
    const v = switch (comptime option) {
        .verbose,
        .post,
        .upload,
        .http_get,
        .pipewait,
        .no_body,
        .forbid_reuse,
        .suppress_connect_headers,
        .ssl_verify_peer,
        .proxy_ssl_verify_peer,
        => @as(c_long, @intFromBool(value)),

        // VERIFYHOST expects 0 or 2 (since 7.66.0, 1 is treated the same as 2).
        // https://curl.se/libcurl/c/CURLOPT_SSL_VERIFYHOST.html
        .ssl_verify_host,
        .proxy_ssl_verify_host,
        => @as(c_long, if (value) 2 else 0),

        .timeout_ms,
        .connect_timeout_ms,
        .follow_location,
        .post_field_size,
        .connect_only,
        => @as(c_long, @intCast(value)),

        .url,
        .proxy,
        .accept_encoding,
        .custom_request,
        .cookie,
        .user_pwd,
        .proxy_user_pwd,
        .copy_post_fields,
        .ssl_ec_curves,
        => @as(?[*]const u8, value),

        .http_header,
        .connect_to,
        .resolve,
        => @as(?*CurlSList, value),

        .private,
        .header_data,
        .read_data,
        .write_data,
        .opensocket_data,
        => @as(?*anyopaque, @ptrCast(value)),

        .ssl_ctx_data => @as(*crypto.X509_STORE, value),
        .share => @as(?*CurlSH, value),

        .http_version => @as(c_long, @backingInt(@as(CurlHttpVersion, value))),

        .debug_function => @as(CurlDebugFunction, value),
        .opensocket_function => @as(CurlOpenSocketFunction, value),
        .header_function => @as(CurlHeaderFunction, value),
        .read_function => @as(CurlReadFunction, value),
        .write_function => @as(CurlWriteFunction, value),
        .ssl_ctx_function => @as(CurlSslCtxFunction, value),
    };
    const code = c.curl_easy_setopt(easy, @backingInt(option), v);
    return errorCheck(code);
}

pub fn curl_easy_getinfo(easy: *Curl, comptime info: CurlInfo, out: anytype) Error!void {
    if (@typeInfo(@TypeOf(out)) != .pointer) {
        @compileError("curl_easy_getinfo out must be a pointer, got " ++ @typeName(@TypeOf(out)));
    }

    const inf: c.CURLINFO = @backingInt(info);
    const code = switch (info) {
        .effective_url => blk: {
            const p: *[*c]u8 = out;
            break :blk c.curl_easy_getinfo(easy, inf, p);
        },
        .response_code,
        .connect_code,
        .redirect_count,
        .num_connects,
        .http_version,
        .header_size,
        => blk: {
            const p: *c_long = out;
            break :blk c.curl_easy_getinfo(easy, inf, p);
        },
        .total_time_t,
        .queue_time_t,
        .namelookup_time_t,
        .connect_time_t,
        .appconnect_time_t,
        .pretransfer_time_t,
        .starttransfer_time_t,
        .size_download_t,
        .conn_id,
        => blk: {
            const p: *c.curl_off_t = out;
            break :blk c.curl_easy_getinfo(easy, inf, p);
        },
        .private => blk: {
            const p: **anyopaque = out;
            break :blk c.curl_easy_getinfo(easy, inf, p);
        },
    };
    try errorCheck(code);
}

pub fn curl_easy_pause(easy: *Curl, flags: CurlPauseFlags) Error!void {
    try errorCheck(c.curl_easy_pause(easy, flags.to_c()));
}

pub fn curl_easy_header(
    easy: *Curl,
    name: [*:0]const u8,
    index: usize,
    comptime origin: CurlHeaderOrigin,
    request: c_int,
    hout: *?*CurlHeader,
) ErrorHeader!void {
    var c_hout: [*c]CurlHeader = null;
    const code = c.curl_easy_header(easy, name, index, @backingInt(origin), request, &c_hout);
    switch (code) {
        c.CURLHE_OK => {
            hout.* = @ptrCast(c_hout);
            return;
        },
        c.CURLHE_BADINDEX,
        c.CURLHE_MISSING,
        c.CURLHE_NOHEADERS,
        c.CURLHE_NOREQUEST,
        => {
            hout.* = null;
            return;
        },
        else => {
            hout.* = null;
            return errorHFromCode(code);
        },
    }
}

pub fn curl_easy_nextheader(
    easy: *Curl,
    comptime origin: CurlHeaderOrigin,
    request: c_int,
    prev: ?*CurlHeader,
) ?*CurlHeader {
    const ptr = c.curl_easy_nextheader(easy, @backingInt(origin), request, prev);
    if (ptr == null) return null;
    return @ptrCast(ptr);
}

pub const CurlLockData = enum(c.curl_lock_data) {
    share = c.CURL_LOCK_DATA_SHARE,
    dns = c.CURL_LOCK_DATA_DNS,
    _,
};

pub const CurlLockAccess = c.curl_lock_access;
pub const CurlLockFunction = *const fn (?*Curl, CurlLockData, CurlLockAccess, ?*anyopaque) callconv(.c) void;
pub const CurlUnlockFunction = *const fn (?*Curl, CurlLockData, ?*anyopaque) callconv(.c) void;

const CurlSHOption = enum(c.CURLSHoption) {
    share = c.CURLSHOPT_SHARE,
    lock_function = c.CURLSHOPT_LOCKFUNC,
    unlock_function = c.CURLSHOPT_UNLOCKFUNC,
    user_data = c.CURLSHOPT_USERDATA,
};

pub fn curl_share_init() ?*CurlSH {
    return c.curl_share_init();
}

pub fn curl_share_cleanup(share: *CurlSH) ErrorShare!void {
    try errorSHCheck(c.curl_share_cleanup(share));
}

pub fn curl_share_setopt(share: *CurlSH, comptime option: CurlSHOption, value: anytype) ErrorShare!void {
    const opt: c.CURLSHoption = @backingInt(option);
    const code = switch (option) {
        .share => c.curl_share_setopt(share, opt, @as(c_int, @intCast(@backingInt(@as(CurlLockData, value))))),
        .lock_function => c.curl_share_setopt(share, opt, @as(CurlLockFunction, value)),
        .unlock_function => c.curl_share_setopt(share, opt, @as(CurlUnlockFunction, value)),
        .user_data => c.curl_share_setopt(share, opt, @as(?*anyopaque, @ptrCast(value))),
    };
    try errorSHCheck(code);
}

fn errorSHCheck(code: c.CURLSHcode) ErrorShare!void {
    return switch (code) {
        c.CURLSHE_OK => {},
        c.CURLSHE_BAD_OPTION => ErrorShare.BadOption,
        c.CURLSHE_IN_USE => ErrorShare.InUse,
        c.CURLSHE_INVALID => ErrorShare.Invalid,
        c.CURLSHE_NOMEM => ErrorShare.OutOfMemory,
        c.CURLSHE_NOT_BUILT_IN => ErrorShare.NotBuiltIn,
        else => ErrorShare.Unknown,
    };
}

pub fn curl_multi_init() ?*CurlM {
    return c.curl_multi_init();
}

pub fn curl_multi_cleanup(multi: *CurlM) ErrorMulti!void {
    try errorMCheck(c.curl_multi_cleanup(multi));
}

pub fn curl_multi_setopt(multi: *CurlM, comptime option: CurlMOption, value: anytype) ErrorMulti!void {
    const opt: c.CURLMoption = @backingInt(option);
    const code = switch (option) {
        .max_host_connections, .max_connects => blk: {
            const n: c_long = switch (@typeInfo(@TypeOf(value))) {
                .comptime_int, .int => @intCast(value),
                else => @compileError("expected integer for " ++ @tagName(option) ++ ", got " ++ @typeName(@TypeOf(value))),
            };
            break :blk c.curl_multi_setopt(multi, opt, n);
        },
    };
    try errorMCheck(code);
}

pub fn curl_multi_add_handle(multi: *CurlM, easy: *Curl) ErrorMulti!void {
    try errorMCheck(c.curl_multi_add_handle(multi, easy));
}

pub fn curl_multi_remove_handle(multi: *CurlM, easy: *Curl) ErrorMulti!void {
    try errorMCheck(c.curl_multi_remove_handle(multi, easy));
}

pub fn curl_multi_perform(multi: *CurlM, running_handles: *c_int) ErrorMulti!void {
    try errorMCheck(c.curl_multi_perform(multi, running_handles));
}

pub fn curl_multi_poll(
    multi: *CurlM,
    extra_fds: []CurlWaitFd,
    timeout_ms: c_int,
    numfds: ?*c_int,
) ErrorMulti!void {
    const raw_fds: [*c]c.curl_waitfd = if (extra_fds.len == 0) null else @ptrCast(extra_fds.ptr);
    try errorMCheck(c.curl_multi_poll(multi, raw_fds, @intCast(extra_fds.len), timeout_ms, numfds));
}

// Thread-safe wakeup for a curl_multi_poll sleeping on another thread.
// Per libcurl docs: "This function can be called from any thread, and it
// wakes up a sleeping curl_multi_poll call that is currently (or will be)
// waiting." Safe to call concurrently with curl_multi_perform on the same
// handle — the wake byte is delivered via an internal self-pipe.
pub fn curl_multi_wakeup(multi: *CurlM) ErrorMulti!void {
    try errorMCheck(c.curl_multi_wakeup(multi));
}

fn curl_multi_waitfds(multi: *CurlM, ufds: []CurlWaitFd, fd_count: *c_uint) ErrorMulti!void {
    const raw_fds: [*c]c.curl_waitfd = if (ufds.len == 0) null else @ptrCast(ufds.ptr);
    try errorMCheck(c.curl_multi_waitfds(multi, raw_fds, @intCast(ufds.len), fd_count));
}

fn curl_multi_timeout(multi: *CurlM, timeout_ms: *c_long) ErrorMulti!void {
    try errorMCheck(c.curl_multi_timeout(multi, timeout_ms));
}

pub fn curl_multi_info_read(multi: *CurlM, msgs_in_queue: *c_int) ?CurlMsg {
    const ptr = c.curl_multi_info_read(multi, msgs_in_queue);
    if (ptr == null) return null;

    const msg: *const c.CURLMsg = @ptrCast(ptr);
    const easy_handle = msg.easy_handle orelse unreachable;

    return switch (msg.msg) {
        c.CURLMSG_NONE => .{
            .easy_handle = easy_handle,
            .data = .{ .none = msg.data.whatever },
        },
        c.CURLMSG_DONE => .{
            .easy_handle = easy_handle,
            .data = .{ .done = if (errorCheck(msg.data.result)) |_| null else |err| err },
        },
        c.CURLMSG_LAST => .{
            .easy_handle = easy_handle,
            .data = .{ .last = msg.data.whatever },
        },
        else => unreachable,
    };
}

pub fn curl_slist_append(list: ?*CurlSList, header: [*:0]const u8) ?*CurlSList {
    return c.curl_slist_append(list, header);
}

pub fn curl_slist_free_all(list: ?*CurlSList) void {
    if (list) |ptr| {
        c.curl_slist_free_all(ptr);
    }
}

// WebSocket support (requires libcurl 7.86.0+)
pub const WsFrameType = enum {
    text,
    binary,
    cont,
    close,
    ping,
    pong,

    fn toInt(self: WsFrameType) c_uint {
        return switch (self) {
            .text => c.CURLWS_TEXT,
            .binary => c.CURLWS_BINARY,
            .cont => c.CURLWS_CONT,
            .close => c.CURLWS_CLOSE,
            .ping => c.CURLWS_PING,
            .pong => c.CURLWS_PONG,
        };
    }

    fn fromFlags(flags: c_int) WsFrameType {
        const f: c_uint = @bitCast(flags);
        if (f & c.CURLWS_TEXT != 0) return .text;
        if (f & c.CURLWS_BINARY != 0) return .binary;
        if (f & c.CURLWS_CLOSE != 0) return .close;
        if (f & c.CURLWS_PING != 0) return .ping;
        if (f & c.CURLWS_PONG != 0) return .pong;
        if (f & c.CURLWS_CONT != 0) return .cont;
        return .binary; // default fallback
    }
};

pub const WsFrameMeta = struct {
    frame_type: WsFrameType,
    offset: usize,
    bytes_left: usize,
    len: usize,

    fn from(frame: *const c.curl_ws_frame) WsFrameMeta {
        return .{
            .frame_type = WsFrameType.fromFlags(frame.flags),
            .offset = @intCast(frame.offset),
            .bytes_left = @intCast(frame.bytesleft),
            .len = if (frame.len < 0)
                std.math.maxInt(usize)
            else
                @intCast(frame.len),
        };
    }
};

fn curl_ws_send(easy: *Curl, buffer: []const u8, sent: *usize, fragsize: CurlOffT, frame_type: WsFrameType) Error!void {
    try errorCheck(c.curl_ws_send(easy, buffer.ptr, buffer.len, sent, fragsize, frame_type.toInt()));
}

fn curl_ws_recv(easy: *Curl, buffer: []u8, recv: *usize, meta: *?WsFrameMeta) Error!void {
    var c_meta: [*c]const c.curl_ws_frame = null;
    const code = c.curl_ws_recv(easy, buffer.ptr, buffer.len, recv, &c_meta);
    if (c_meta) |m| {
        meta.* = WsFrameMeta.from(m);
    } else {
        meta.* = null;
    }
    try errorCheck(code);
}

pub fn curl_ws_meta(easy: *Curl) ?WsFrameMeta {
    const ptr = c.curl_ws_meta(easy);
    if (ptr == null) return null;
    return WsFrameMeta.from(ptr);
}

pub fn curl_ws_start_frame(easy: *Curl, frame_type: WsFrameType, size: CurlOffT) Error!void {
    try errorCheck(c.curl_ws_start_frame(easy, frame_type.toInt(), size));
}