const std = @import("std");

const c_ssl = @import("ssl.zig");

const Ssl = @import("Ssl.zig").Ssl;
const SslMethod = @import("SslMethod.zig").SslMethod;
const SslSession = @import("SslSession.zig").SslSession;

pub const SslContext = opaque {

    // --- MACROS --------------------------------------------------------------

    pub inline fn setMode(self: *SslContext, op: anytype) i64 {
        return self.ctrl(c_ssl.c_ssl.SSL_CTRL_MODE, op, null);
    }

    pub inline fn clearMode(self: *SslContext, op: anytype) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_CLEAR_MODE, op, null);
    }

    pub inline fn getMode(self: *SslContext) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_MODE, 0, null);
    }

    pub inline fn setCertFlags(self: *SslContext, op: anytype) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_CERT_FLAGS, op, null);
    }

    pub inline fn clearCertFlags(self: *SslContext, op: anytype) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_CLEAR_CERT_FLAGS, op, null);
    }

    pub inline fn setMsgCallbackArg(self: *SslContext, arg: anytype) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_SET_MSG_CALLBACK_ARG, 0, arg);
    }

    pub inline fn sessNumber(self: *SslContext) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_SESS_NUMBER, 0, null);
    }

    pub inline fn sessConnect(self: *SslContext) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_SESS_CONNECT, 0, null);
    }

    pub inline fn sessConnectGood(self: *SslContext) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_SESS_CONNECT_GOOD, 0, null);
    }

    pub inline fn sessConnectRenegotiate(self: *SslContext) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_SESS_CONNECT_RENEGOTIATE, 0, null);
    }

    pub inline fn sessAccept(self: *SslContext) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_SESS_ACCEPT, 0, null);
    }
    pub inline fn sessAcceptRenegotiate(self: *SslContext) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_SESS_ACCEPT_RENEGOTIATE, 0, null);
    }

    pub inline fn sessAcceptGood(self: *SslContext) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_SESS_ACCEPT_GOOD, 0, null);
    }

    pub inline fn sessHits(self: *SslContext) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_SESS_HIT, 0, null);
    }

    pub inline fn sessCbHits(self: *SslContext) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_SESS_CB_HIT, 0, null);
    }

    pub inline fn sessMisses(self: *SslContext) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_SESS_MISSES, 0, null);
    }

    pub inline fn sessTimeouts(self: *SslContext) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_SESS_TIMEOUTS, 0, null);
    }

    pub inline fn sessCacheFull(self: *SslContext) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_SESS_CACHE_FULL, 0, null);
    }

    pub inline fn setTlsextServernameArg(self: *SslContext, arg: anytype) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_SET_TLSEXT_SERVERNAME_ARG, 0, arg);
    }

    pub inline fn getTlsextTicketKeys(self: *SslContext, keys: anytype, keylen: anytype) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_GET_TLSEXT_TICKET_KEYS, keylen, keys);
    }

    pub inline fn setTlsextTicketKeys(self: *SslContext, keys: anytype, keylen: anytype) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_SET_TLSEXT_TICKET_KEYS, keylen, keys);
    }

    pub inline fn getTlsextStatusCb(self: *SslContext, cb: anytype) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_GET_TLSEXT_STATUS_REQ_CB, 0, @import("std").zig.c_translation.cast(?*anyopaque, cb));
    }

    pub inline fn getTlsextStatusArg(self: *SslContext, arg: anytype) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_GET_TLSEXT_STATUS_REQ_CB_ARG, 0, arg);
    }

    pub inline fn setTlsextStatusArg(self: *SslContext, arg: anytype) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_SET_TLSEXT_STATUS_REQ_CB_ARG, 0, arg);
    }

    pub inline fn setTlsextStatusType(self: *SslContext, @"type": anytype) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_SET_TLSEXT_STATUS_REQ_TYPE, @"type", null);
    }

    pub inline fn getTlsextStatusType(self: *SslContext) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_GET_TLSEXT_STATUS_REQ_TYPE, 0, null);
    }

    pub inline fn getAppData(self: *const SslContext) ?*anyopaque {
        return self.getExData(0);
    }

    pub inline fn setAppData(self: *SslContext, data: ?*anyopaque) i32 {
        return self.setExData(0, data);
    }

    pub inline fn setTmpDh(self: *SslContext, dh: anytype) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_SET_TMP_DH, 0, @import("std").zig.c_translation.cast([*c]u8, dh));
    }

    pub inline fn setDhAuto(self: *SslContext, onoff: anytype) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_SET_DH_AUTO, onoff, null);
    }

    pub inline fn setTmpEcdh(self: *SslContext, ecdh: anytype) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_SET_TMP_ECDH, 0, @import("std").zig.c_translation.cast([*c]u8, ecdh));
    }

    pub inline fn addExtraChainCert(self: *SslContext, x509: anytype) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_EXTRA_CHAIN_CERT, 0, @import("std").zig.c_translation.cast([*c]u8, x509));
    }

    pub inline fn getExtraChainCerts(self: *SslContext, px509: anytype) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_GET_EXTRA_CHAIN_CERTS, 0, px509);
    }

    pub inline fn getExtraChainCertsOnly(self: *SslContext, px509: anytype) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_GET_EXTRA_CHAIN_CERTS, @as(c_int, 1), px509);
    }

    pub inline fn clearExtraChainCerts(self: *SslContext) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_CLEAR_EXTRA_CHAIN_CERTS, 0, null);
    }

    pub inline fn set0Chain(self: *SslContext, sk: anytype) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_CHAIN, 0, @import("std").zig.c_translation.cast([*c]u8, sk));
    }

    pub inline fn set1Chain(self: *SslContext, sk: anytype) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_CHAIN, @as(c_int, 1), @import("std").zig.c_translation.cast([*c]u8, sk));
    }

    pub inline fn add0ChainCert(self: *SslContext, x509: anytype) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_CHAIN_CERT, 0, @import("std").zig.c_translation.cast([*c]u8, x509));
    }

    pub inline fn add1ChainCert(self: *SslContext, x509: anytype) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_CHAIN_CERT, @as(c_int, 1), @import("std").zig.c_translation.cast([*c]u8, x509));
    }

    pub inline fn get0ChainCerts(self: *SslContext, px509: anytype) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_GET_CHAIN_CERTS, 0, px509);
    }

    pub inline fn clearChainCerts(self: *SslContext) i64 {
        return self.set0Chain(null);
    }

    pub inline fn buildCertChain(self: *SslContext, flags: anytype) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_BUILD_CERT_CHAIN, flags, null);
    }

    pub inline fn selectCurrentCert(self: *SslContext, x509: anytype) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_SELECT_CURRENT_CERT, 0, @import("std").zig.c_translation.cast([*c]u8, x509));
    }

    pub inline fn setCurrentCert(self: *SslContext, op: anytype) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_SET_CURRENT_CERT, op, null);
    }

    pub inline fn set0VerifyCertStore(self: *SslContext, st: anytype) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_SET_VERIFY_CERT_STORE, 0, @import("std").zig.c_translation.cast([*c]u8, st));
    }

    pub inline fn set1VerifyCertStore(self: *SslContext, st: anytype) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_SET_VERIFY_CERT_STORE, @as(c_int, 1), @import("std").zig.c_translation.cast([*c]u8, st));
    }

    pub inline fn get0VerifyCertStore(self: *SslContext, st: anytype) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_GET_VERIFY_CERT_STORE, 0, @import("std").zig.c_translation.cast([*c]u8, st));
    }

    pub inline fn set0ChainCertStore(self: *SslContext, st: anytype) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_SET_CHAIN_CERT_STORE, 0, @import("std").zig.c_translation.cast([*c]u8, st));
    }

    pub inline fn set1ChainCertStore(self: *SslContext, st: anytype) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_SET_CHAIN_CERT_STORE, @as(c_int, 1), @import("std").zig.c_translation.cast([*c]u8, st));
    }

    pub inline fn get0ChainCertStore(self: *SslContext, st: anytype) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_GET_CHAIN_CERT_STORE, 0, @import("std").zig.c_translation.cast([*c]u8, st));
    }

    pub inline fn set1Groups(self: *SslContext, glist: anytype, glistlen: anytype) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_SET_GROUPS, glistlen, @import("std").zig.c_translation.cast([*c]c_int, glist));
    }

    pub inline fn set1GroupsList(self: *SslContext, s: anytype) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_SET_GROUPS_LIST, 0, @import("std").zig.c_translation.cast([*c]u8, s));
    }

    pub inline fn set1Sigalgs(self: *SslContext, slist: anytype, slistlen: anytype) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_SET_SIGALGS, slistlen, @import("std").zig.c_translation.cast([*c]c_int, slist));
    }

    pub inline fn set1SigalgsList(self: *SslContext, s: anytype) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_SET_SIGALGS_LIST, 0, @import("std").zig.c_translation.cast([*c]u8, s));
    }

    pub inline fn set1ClientSigalgs(self: *SslContext, slist: anytype, slistlen: anytype) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_SET_CLIENT_SIGALGS, slistlen, @import("std").zig.c_translation.cast([*c]c_int, slist));
    }

    pub inline fn set1ClientSigalgsList(self: *SslContext, s: anytype) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_SET_CLIENT_SIGALGS_LIST, 0, @import("std").zig.c_translation.cast([*c]u8, s));
    }

    pub inline fn set1ClientCertificateTypes(self: *SslContext, clist: anytype, clistlen: anytype) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_SET_CLIENT_CERT_TYPES, clistlen, @import("std").zig.c_translation.cast([*c]u8, clist));
    }

    pub inline fn setMinProtoVersion(self: *SslContext, version: anytype) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_SET_MIN_PROTO_VERSION, version, null);
    }

    pub inline fn setMaxProtoVersion(self: *SslContext, version: anytype) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_SET_MAX_PROTO_VERSION, version, null);
    }

    pub inline fn getMinProtoVersion(self: *SslContext) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_GET_MIN_PROTO_VERSION, 0, null);
    }

    pub inline fn getMaxProtoVersion(self: *SslContext) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_GET_MAX_PROTO_VERSION, 0, null);
    }

    pub inline fn getExNewIndex(
        argl: i64,
        argp: ?*anyopaque,
        new_func: ?*const c_ssl.CRYPTO_EX_new,
        dup_func: ?*const c_ssl.CRYPTO_EX_dup,
        free_func: ?*const c_ssl.CRYPTO_EX_free,
    ) i32 {
        return c_ssl.CRYPTO_get_ex_new_index(c_ssl.CRYPTO_EX_INDEX_SSL_CTX, argl, argp, new_func, dup_func, free_func);
    }

    pub inline fn sessSetCacheSize(self: *SslContext, t: anytype) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_SET_SESS_CACHE_SIZE, t, null);
    }

    pub inline fn sessGetCacheSize(self: *SslContext) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_GET_SESS_CACHE_SIZE, 0, null);
    }

    pub inline fn setSessionCacheMode(self: *SslContext, m: anytype) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_SET_SESS_CACHE_MODE, m, null);
    }

    pub inline fn getSessionCacheMode(self: *SslContext) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_GET_SESS_CACHE_MODE, 0, null);
    }

    pub inline fn getDefaultReadAhead(self: *SslContext) i64 {
        return self.getReadAhead();
    }

    pub inline fn setDefaultReadAhead(self: *SslContext, m: anytype) i64 {
        return self.setReadAhead(m);
    }

    pub inline fn getReadAhead(self: *SslContext) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_GET_READ_AHEAD, 0, null);
    }

    pub inline fn setReadAhead(self: *SslContext, m: anytype) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_SET_READ_AHEAD, m, null);
    }

    pub inline fn getMaxCertList(self: *SslContext) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_GET_MAX_CERT_LIST, 0, null);
    }

    pub inline fn setMaxCertList(self: *SslContext, m: anytype) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_SET_MAX_CERT_LIST, m, null);
    }

    pub inline fn setMaxSendFragment(self: *SslContext, m: anytype) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_SET_MAX_SEND_FRAGMENT, m, null);
    }

    pub inline fn setSplitSendFragment(self: *SslContext, m: anytype) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_SET_SPLIT_SEND_FRAGMENT, m, null);
    }

    pub inline fn setMaxPipelines(self: *SslContext, m: anytype) i64 {
        return self.ctrl(c_ssl.SSL_CTRL_SET_MAX_PIPELINES, m, null);
    }

    // --- METHODS -------------------------------------------------------------

    pub inline fn checkPrivateKey(self: *const SslContext) !void {
        if (import.SSL_CTX_check_private_key(self) == 0) {
            return error.InvalidPrivateKey;
        }
    }

    pub inline fn ctrl(self: *SslContext, cmd: i32, larg: i64, parg: ?*anyopaque) i64 {
        return import.SSL_CTX_ctrl(self, cmd, larg, parg);
    }

    pub inline fn free(self: *SslContext) void {
        import.SSL_CTX_free(self);
    }

    pub inline fn getExData(self: *const SslContext, index: i32) ?*anyopaque {
        return import.SSL_CTX_get_ex_data(self, index);
    }

    pub inline fn new(method: ?*const SslMethod) !*SslContext {
        return import.SSL_CTX_new(method) orelse error.OpenSslError;
    }

    pub inline fn setExData(self: *SslContext, index: i32, data: ?*anyopaque) i32 {
        return import.SSL_CTX_set_ex_data(self, index, data);
    }

    pub inline fn setOptions(self: *SslContext, op: u64) u64 {
        return import.SSL_CTX_set_options(self, op);
    }

    pub inline fn useCertificateFile(self: *SslContext, file: [*:0]const u8, @"type": i32) !void {
        const res = import.SSL_CTX_use_certificate_file(self, file, @"type");
        if (res <= 0) {
            return error.OpenSslError;
        }
    }

    pub inline fn usePrivateKeyFile(self: *SslContext, file: [*:0]const u8, @"type": i32) !void {
        const res = import.SSL_CTX_use_PrivateKey_file(self, file, @"type");
        if (res <= 0) {
            return error.OpenSslError;
        }
    }
};

const import = struct {
    pub extern fn SSL_CTX_add_client_CA(ctx: *SslContext, x: ?*c_ssl.X509) i32;
    pub extern fn SSL_CTX_add_client_custom_ext(
        ctx: *SslContext,
        ext_type: u32,
        add_cb: c_ssl.custom_ext_add_cb,
        free_cb: c_ssl.custom_ext_free_cb,
        add_arg: ?*anyopaque,
        parse_cb: c_ssl.custom_ext_parse_cb,
        parse_arg: ?*anyopaque,
    ) i32;
    pub extern fn SSL_CTX_add_custom_ext(
        ctx: *SslContext,
        ext_type: u32,
        context: u32,
        add_cb: c_ssl.SSL_custom_ext_add_cb_ex,
        free_cb: c_ssl.SSL_custom_ext_free_cb_ex,
        add_arg: ?*anyopaque,
        parse_cb: c_ssl.SSL_custom_ext_parse_cb_ex,
        parse_arg: ?*anyopaque,
    ) i32;
    pub extern fn SSL_CTX_add_server_custom_ext(
        ctx: *SslContext,
        ext_type: u32,
        add_cb: c_ssl.custom_ext_add_cb,
        free_cb: c_ssl.custom_ext_free_cb,
        add_arg: ?*anyopaque,
        parse_cb: c_ssl.custom_ext_parse_cb,
        parse_arg: ?*anyopaque,
    ) i32;
    pub extern fn SSL_CTX_add_session(ctx: *SslContext, session: ?*c_ssl.Session) i32;
    pub extern fn SSL_CTX_add1_to_CA_list(ctx: *SslContext, x: ?*const c_ssl.X509) i32;
    pub extern fn SSL_CTX_callback_ctrl(*SslContext, i32, ?*const fn () callconv(.c) void) i64;
    pub extern fn SSL_CTX_check_private_key(ctx: *const SslContext) i32;
    pub extern fn SSL_CTX_clear_options(ctx: *SslContext, op: u64) u64;
    pub extern fn SSL_CTX_config(ctx: *SslContext, name: [*c]const u8) i32;
    pub extern fn SSL_CTX_ct_is_enabled(ctx: *const SslContext) i32;
    pub extern fn SSL_CTX_ctrl(ctx: *SslContext, cmd: i32, larg: i64, parg: ?*anyopaque) i64;
    pub extern fn SSL_CTX_dane_clear_flags(ctx: *SslContext, flags: i64) i64;
    pub extern fn SSL_CTX_dane_enable(ctx: *SslContext) i32;
    pub extern fn SSL_CTX_dane_mtype_set(ctx: *SslContext, md: ?*const c_ssl.EVP_MD, mtype: u8, ord: u8) i32;
    pub extern fn SSL_CTX_dane_set_flags(ctx: *SslContext, flags: i64) i64;
    pub extern fn SSL_CTX_enable_ct(ctx: *SslContext, validation_mode: i32) i32;
    pub extern fn SSL_CTX_flush_sessions(ctx: *SslContext, tm: i64) void;
    pub extern fn SSL_CTX_free(*SslContext) void;
    pub extern fn SSL_CTX_get_cert_store(*const SslContext) ?*c_ssl.X509_STORE;
    pub extern fn SSL_CTX_get_ciphers(ctx: *const SslContext) ?*c_ssl.struct_stack_st_SSL_CIPHER;
    pub extern fn SSL_CTX_get_client_CA_list(s: *const SslContext) ?*c_ssl.struct_stack_st_X509_NAME;
    pub extern fn SSL_CTX_get_client_cert_cb(ctx: *SslContext) ?*const fn (?*Ssl, [*c]?*c_ssl.X509, [*c]?*c_ssl.EVP_PKEY) callconv(.c) i32;
    pub extern fn SSL_CTX_get_default_passwd_cb_userdata(ctx: *SslContext) ?*anyopaque;
    pub extern fn SSL_CTX_get_default_passwd_cb(ctx: *SslContext) ?*const c_ssl.pem_password_cb;
    pub extern fn SSL_CTX_get_ex_data(ssl: *const SslContext, idx: i32) ?*anyopaque;
    pub extern fn SSL_CTX_get_info_callback(ctx: *SslContext) ?*const fn (?*const Ssl, i32, i32) callconv(.c) void;
    pub extern fn SSL_CTX_get_keylog_callback(ctx: *const SslContext) c_ssl.SSL_CTX_keylog_cb_func;
    pub extern fn SSL_CTX_get_max_early_data(ctx: *const SslContext) u32;
    pub extern fn SSL_CTX_get_num_tickets(ctx: *const SslContext) usize;
    pub extern fn SSL_CTX_get_options(ctx: *const SslContext) u64;
    pub extern fn SSL_CTX_get_quiet_shutdown(ctx: *const SslContext) i32;
    pub extern fn SSL_CTX_get_record_padding_callback_arg(ctx: *const SslContext) ?*anyopaque;
    pub extern fn SSL_CTX_get_recv_max_early_data(ctx: *const SslContext) u32;
    pub extern fn SSL_CTX_get_security_callback(ctx: *const SslContext) ?*const fn (
        ?*const Ssl,
        *const SslContext,
        i32,
        i32,
        i32,
        ?*anyopaque,
        ?*anyopaque,
    ) callconv(.c) i32;
    pub extern fn SSL_CTX_get_security_level(ctx: *const SslContext) i32;
    pub extern fn SSL_CTX_get_ssl_method(ctx: *const SslContext) ?*const SslMethod;
    pub extern fn SSL_CTX_get_timeout(ctx: *const SslContext) i64;
    pub extern fn SSL_CTX_get_verify_callback(ctx: *const SslContext) c_ssl.SSL_verify_cb;
    pub extern fn SSL_CTX_get_verify_depth(ctx: *const SslContext) i32;
    pub extern fn SSL_CTX_get_verify_mode(ctx: *const SslContext) i32;
    pub extern fn SSL_CTX_get0_CA_list(ctx: *const SslContext) ?*const c_ssl.struct_stack_st_X509_NAME;
    pub extern fn SSL_CTX_get0_certificate(ctx: *const SslContext) ?*c_ssl.X509;
    pub extern fn SSL_CTX_get0_ctlog_store(ctx: *const SslContext) ?*const c_ssl.CTLOG_STORE;
    pub extern fn SSL_CTX_get0_param(ctx: *SslContext) ?*c_ssl.X509_VERIFY_PARAM;
    pub extern fn SSL_CTX_get0_privatekey(ctx: *const SslContext) ?*c_ssl.EVP_PKEY;
    pub extern fn SSL_CTX_get0_security_ex_data(ctx: *const SslContext) ?*anyopaque;
    pub extern fn SSL_CTX_has_client_custom_ext(ctx: *const SslContext, ext_type: u32) i32;
    pub extern fn SSL_CTX_load_verify_dir(ctx: *SslContext, CApath: [*c]const u8) i32;
    pub extern fn SSL_CTX_load_verify_file(ctx: *SslContext, CAfile: [*c]const u8) i32;
    pub extern fn SSL_CTX_load_verify_locations(ctx: *SslContext, CAfile: [*c]const u8, CApath: [*c]const u8) i32;
    pub extern fn SSL_CTX_load_verify_store(ctx: *SslContext, CAstore: [*c]const u8) i32;
    pub extern fn SSL_CTX_new_ex(libctx: ?*c_ssl.OSSL_LIB_CTX, propq: [*c]const u8, meth: ?*const SslMethod) ?*SslContext;
    pub extern fn SSL_CTX_new(meth: ?*const SslMethod) ?*SslContext;
    pub extern fn SSL_CTX_remove_session(ctx: *SslContext, session: ?*SslSession) i32;
    pub extern fn SSL_CTX_sess_get_get_cb(ctx: *SslContext) ?*const fn (
        ?*c_ssl.struct_ssl_st,
        [*c]const u8,
        i32,
        [*c]i32,
    ) callconv(.c) ?*SslSession;
    pub extern fn SSL_CTX_sess_get_new_cb(ctx: *SslContext) ?*const fn (
        ?*c_ssl.struct_ssl_st,
        ?*SslSession,
    ) callconv(.c) i32;
    pub extern fn SSL_CTX_sess_get_remove_cb(ctx: *SslContext) ?*const fn (
        ?*c_ssl.struct_ssl_ctx_st,
        ?*SslSession,
    ) callconv(.c) void;
    pub extern fn SSL_CTX_sess_set_get_cb(
        ctx: *SslContext,
        get_session_cb: ?*const fn (
            ?*c_ssl.struct_ssl_st,
            [*c]const u8,
            i32,
            [*c]i32,
        ) callconv(.c) ?*SslSession,
    ) void;
    pub extern fn SSL_CTX_sess_set_new_cb(
        ctx: *SslContext,
        new_session_cb: ?*const fn (
            ?*c_ssl.struct_ssl_st,
            ?*SslSession,
        ) callconv(.c) i32,
    ) void;
    pub extern fn SSL_CTX_sess_set_remove_cb(
        ctx: *SslContext,
        remove_session_cb: ?*const fn (
            ?*c_ssl.struct_ssl_ctx_st,
            ?*SslSession,
        ) callconv(.c) void,
    ) void;
    pub extern fn SSL_CTX_sessions(ctx: *SslContext) ?*c_ssl.struct_lhash_st_SSL_SESSION;
    pub extern fn SSL_CTX_set_allow_early_data_cb(ctx: *SslContext, cb: c_ssl.SSL_allow_early_data_cb_fn, arg: ?*anyopaque) void;
    pub extern fn SSL_CTX_set_alpn_protos(ctx: *SslContext, protos: [*c]const u8, protos_len: u32) i32;
    pub extern fn SSL_CTX_set_alpn_select_cb(ctx: *SslContext, cb: c_ssl.SSL_CTX_alpn_select_cb_func, arg: ?*anyopaque) void;
    pub extern fn SSL_CTX_set_async_callback_arg(ctx: *SslContext, arg: ?*anyopaque) i32;
    pub extern fn SSL_CTX_set_async_callback(ctx: *SslContext, callback: c_ssl.SSL_async_callback_fn) i32;
    pub extern fn SSL_CTX_set_block_padding(ctx: *SslContext, block_size: usize) i32;
    pub extern fn SSL_CTX_set_cert_cb(c: *SslContext, cb: ?*const fn (?*Ssl, ?*anyopaque) callconv(.c) i32, arg: ?*anyopaque) void;
    pub extern fn SSL_CTX_set_cert_store(*SslContext, ?*c_ssl.X509_STORE) void;
    pub extern fn SSL_CTX_set_cert_verify_callback(
        ctx: *SslContext,
        cb: ?*const fn (
            ?*c_ssl.X509_STORE_CTX,
            ?*anyopaque,
        ) callconv(.c) i32,
        arg: ?*anyopaque,
    ) void;
    pub extern fn SSL_CTX_set_cipher_list(*SslContext, str: [*c]const u8) i32;
    pub extern fn SSL_CTX_set_ciphersuites(ctx: *SslContext, str: [*c]const u8) i32;
    pub extern fn SSL_CTX_set_client_CA_list(ctx: *SslContext, name_list: ?*c_ssl.struct_stack_st_X509_NAME) void;
    pub extern fn SSL_CTX_set_client_cert_cb(
        ctx: *SslContext,
        client_cert_cb: ?*const fn (
            ?*Ssl,
            [*c]?*c_ssl.X509,
            [*c]?*c_ssl.EVP_PKEY,
        ) callconv(.c) i32,
    ) void;
    pub extern fn SSL_CTX_set_client_cert_engine(ctx: *SslContext, e: ?*c_ssl.ENGINE) i32;
    pub extern fn SSL_CTX_set_client_hello_cb(c: *SslContext, cb: c_ssl.SSL_client_hello_cb_fn, arg: ?*anyopaque) void;
    pub extern fn SSL_CTX_set_cookie_generate_cb(ctx: *SslContext, app_gen_cookie_cb: ?*const fn (?*Ssl, [*c]u8, [*c]u32) callconv(.c) i32) void;
    pub extern fn SSL_CTX_set_cookie_verify_cb(ctx: *SslContext, app_verify_cookie_cb: ?*const fn (?*Ssl, [*c]const u8, u32) callconv(.c) i32) void;
    pub extern fn SSL_CTX_set_ct_validation_callback(ctx: *SslContext, callback: c_ssl.ssl_ct_validation_cb, arg: ?*anyopaque) i32;
    pub extern fn SSL_CTX_set_ctlog_list_file(ctx: *SslContext, path: [*c]const u8) i32;
    pub extern fn SSL_CTX_set_default_ctlog_list_file(ctx: *SslContext) i32;
    pub extern fn SSL_CTX_set_default_passwd_cb_userdata(ctx: *SslContext, u: ?*anyopaque) void;
    pub extern fn SSL_CTX_set_default_passwd_cb(ctx: *SslContext, cb: ?*const c_ssl.pem_password_cb) void;
    pub extern fn SSL_CTX_set_default_read_buffer_len(ctx: *SslContext, len: usize) void;
    pub extern fn SSL_CTX_set_default_verify_dir(ctx: *SslContext) i32;
    pub extern fn SSL_CTX_set_default_verify_file(ctx: *SslContext) i32;
    pub extern fn SSL_CTX_set_default_verify_paths(ctx: *SslContext) i32;
    pub extern fn SSL_CTX_set_default_verify_store(ctx: *SslContext) i32;
    pub extern fn SSL_CTX_set_ex_data(ssl: *SslContext, idx: i32, data: ?*anyopaque) i32;
    pub extern fn SSL_CTX_set_generate_session_id(ctx: *SslContext, cb: c_ssl.GEN_SESSION_CB) i32;
    pub extern fn SSL_CTX_set_info_callback(ctx: *SslContext, cb: ?*const fn (?*const Ssl, i32, i32) callconv(.c) void) void;
    pub extern fn SSL_CTX_set_keylog_callback(ctx: *SslContext, cb: c_ssl.SSL_CTX_keylog_cb_func) void;
    pub extern fn SSL_CTX_set_max_early_data(ctx: *SslContext, max_early_data: u32) i32;
    pub extern fn SSL_CTX_set_msg_callback(
        ctx: *SslContext,
        cb: ?*const fn (
            i32,
            i32,
            i32,
            ?*const anyopaque,
            usize,
            ?*Ssl,
            ?*anyopaque,
        ) callconv(.c) void,
    ) void;
    pub extern fn SSL_CTX_set_next_proto_select_cb(s: *SslContext, cb: c_ssl.SSL_CTX_npn_select_cb_func, arg: ?*anyopaque) void;
    pub extern fn SSL_CTX_set_next_protos_advertised_cb(s: *SslContext, cb: c_ssl.SSL_CTX_npn_advertised_cb_func, arg: ?*anyopaque) void;
    pub extern fn SSL_CTX_set_not_resumable_session_callback(ctx: *SslContext, cb: ?*const fn (?*Ssl, i32) callconv(.c) i32) void;
    pub extern fn SSL_CTX_set_num_tickets(ctx: *SslContext, num_tickets: usize) i32;
    pub extern fn SSL_CTX_set_options(ctx: *SslContext, op: u64) u64;
    pub extern fn SSL_CTX_set_post_handshake_auth(ctx: *SslContext, val: i32) void;
    pub extern fn SSL_CTX_set_psk_client_callback(ctx: *SslContext, cb: c_ssl.SSL_psk_client_cb_func) void;
    pub extern fn SSL_CTX_set_psk_find_session_callback(ctx: *SslContext, cb: c_ssl.SSL_psk_find_session_cb_func) void;
    pub extern fn SSL_CTX_set_psk_server_callback(ctx: *SslContext, cb: c_ssl.SSL_psk_server_cb_func) void;
    pub extern fn SSL_CTX_set_psk_use_session_callback(ctx: *SslContext, cb: c_ssl.SSL_psk_use_session_cb_func) void;
    pub extern fn SSL_CTX_set_purpose(ctx: *SslContext, purpose: i32) i32;
    pub extern fn SSL_CTX_set_quiet_shutdown(ctx: *SslContext, mode: i32) void;
    pub extern fn SSL_CTX_set_record_padding_callback_arg(ctx: *SslContext, arg: ?*anyopaque) void;
    pub extern fn SSL_CTX_set_record_padding_callback(ctx: *SslContext, cb: ?*const fn (?*Ssl, i32, usize, ?*anyopaque) callconv(.c) usize) void;
    pub extern fn SSL_CTX_set_recv_max_early_data(ctx: *SslContext, recv_max_early_data: u32) i32;
    pub extern fn SSL_CTX_set_security_callback(
        ctx: *SslContext,
        cb: ?*const fn (
            ?*const Ssl,
            *const SslContext,
            i32,
            i32,
            i32,
            ?*anyopaque,
            ?*anyopaque,
        ) callconv(.c) i32,
    ) void;
    pub extern fn SSL_CTX_set_security_level(ctx: *SslContext, level: i32) void;
    pub extern fn SSL_CTX_set_session_id_context(ctx: *SslContext, sid_ctx: [*c]const u8, sid_ctx_len: u32) i32;
    pub extern fn SSL_CTX_set_session_ticket_cb(
        ctx: *SslContext,
        gen_cb: c_ssl.SSL_CTX_generate_session_ticket_fn,
        dec_cb: c_ssl.SSL_CTX_decrypt_session_ticket_fn,
        arg: ?*anyopaque,
    ) i32;
    pub extern fn SSL_CTX_set_srp_cb_arg(ctx: *SslContext, arg: ?*anyopaque) i32;
    pub extern fn SSL_CTX_set_srp_client_pwd_callback(ctx: *SslContext, cb: ?*const fn (?*Ssl, ?*anyopaque) callconv(.c) [*c]u8) i32;
    pub extern fn SSL_CTX_set_srp_password(ctx: *SslContext, password: [*c]u8) i32;
    pub extern fn SSL_CTX_set_srp_strength(ctx: *SslContext, strength: i32) i32;
    pub extern fn SSL_CTX_set_srp_username_callback(ctx: *SslContext, cb: ?*const fn (?*Ssl, [*c]i32, ?*anyopaque) callconv(.c) i32) i32;
    pub extern fn SSL_CTX_set_srp_username(ctx: *SslContext, name: [*c]u8) i32;
    pub extern fn SSL_CTX_set_srp_verify_param_callback(ctx: *SslContext, cb: ?*const fn (?*Ssl, ?*anyopaque) callconv(.c) i32) i32;
    pub extern fn SSL_CTX_set_ssl_version(ctx: *SslContext, meth: ?*const SslMethod) i32;
    pub extern fn SSL_CTX_set_stateless_cookie_generate_cb(
        ctx: *SslContext,
        gen_stateless_cookie_cb: ?*const fn (
            ?*Ssl,
            [*c]u8,
            [*c]usize,
        ) callconv(.c) i32,
    ) void;
    pub extern fn SSL_CTX_set_stateless_cookie_verify_cb(
        ctx: *SslContext,
        verify_stateless_cookie_cb: ?*const fn (
            ?*Ssl,
            [*c]const u8,
            usize,
        ) callconv(.c) i32,
    ) void;
    pub extern fn SSL_CTX_set_timeout(ctx: *SslContext, t: i64) i64;
    pub extern fn SSL_CTX_set_tlsext_max_fragment_length(ctx: *SslContext, mode: u8) i32;
    pub extern fn SSL_CTX_set_tlsext_ticket_key_evp_cb(
        ctx: *SslContext,
        fp: ?*const fn (
            ?*Ssl,
            [*c]u8,
            [*c]u8,
            ?*c_ssl.EVP_CIPHER_CTX,
            ?*c_ssl.EVP_MAC_CTX,
            i32,
        ) callconv(.c) i32,
    ) i32;
    pub extern fn SSL_CTX_set_tlsext_use_srtp(ctx: *SslContext, profiles: [*c]const u8) i32;
    pub extern fn SSL_CTX_set_tmp_dh_callback(ctx: *SslContext, dh: ?*const fn (?*Ssl, i32, i32) callconv(.c) ?*c_ssl.DH) void;
    pub extern fn SSL_CTX_set_trust(ctx: *SslContext, trust: i32) i32;
    pub extern fn SSL_CTX_set_verify_depth(ctx: *SslContext, depth: i32) void;
    pub extern fn SSL_CTX_set_verify(ctx: *SslContext, mode: i32, callback: c_ssl.SSL_verify_cb) void;
    pub extern fn SSL_CTX_set0_CA_list(ctx: *SslContext, name_list: ?*c_ssl.struct_stack_st_X509_NAME) void;
    pub extern fn SSL_CTX_set0_ctlog_store(ctx: *SslContext, logs: ?*c_ssl.CTLOG_STORE) void;
    pub extern fn SSL_CTX_set0_security_ex_data(ctx: *SslContext, ex: ?*anyopaque) void;
    pub extern fn SSL_CTX_set0_tmp_dh_pkey(ctx: *SslContext, dhpkey: ?*c_ssl.EVP_PKEY) i32;
    pub extern fn SSL_CTX_set1_cert_store(*SslContext, ?*c_ssl.X509_STORE) void;
    pub extern fn SSL_CTX_set1_param(ctx: *SslContext, vpm: ?*c_ssl.X509_VERIFY_PARAM) i32;
    pub extern fn SSL_CTX_SRP_CTX_free(ctx: *SslContext) i32;
    pub extern fn SSL_CTX_SRP_CTX_init(ctx: *SslContext) i32;
    pub extern fn SSL_CTX_up_ref(ctx: *SslContext) i32;
    pub extern fn SSL_CTX_use_cert_and_key(
        ctx: *SslContext,
        x509: ?*c_ssl.X509,
        privatekey: ?*c_ssl.EVP_PKEY,
        chain: ?*c_ssl.struct_stack_st_X509,
        override: i32,
    ) i32;
    pub extern fn SSL_CTX_use_certificate_ASN1(ctx: *SslContext, len: i32, d: [*c]const u8) i32;
    pub extern fn SSL_CTX_use_certificate_chain_file(ctx: *SslContext, file: [*c]const u8) i32;
    pub extern fn SSL_CTX_use_certificate_file(ctx: *SslContext, file: [*c]const u8, @"type": i32) i32;
    pub extern fn SSL_CTX_use_certificate(ctx: *SslContext, x: ?*c_ssl.X509) i32;
    pub extern fn SSL_CTX_use_PrivateKey_ASN1(pk: i32, ctx: *SslContext, d: [*c]const u8, len: i64) i32;
    pub extern fn SSL_CTX_use_PrivateKey_file(ctx: *SslContext, file: [*c]const u8, @"type": i32) i32;
    pub extern fn SSL_CTX_use_PrivateKey(ctx: *SslContext, pkey: ?*c_ssl.EVP_PKEY) i32;
    pub extern fn SSL_CTX_use_psk_identity_hint(ctx: *SslContext, identity_hint: [*c]const u8) i32;
    pub extern fn SSL_CTX_use_RSAPrivateKey_ASN1(ctx: *SslContext, d: [*c]const u8, len: i64) i32;
    pub extern fn SSL_CTX_use_RSAPrivateKey_file(ctx: *SslContext, file: [*c]const u8, @"type": i32) i32;
    pub extern fn SSL_CTX_use_RSAPrivateKey(ctx: *SslContext, rsa: ?*c_ssl.RSA) i32;
    pub extern fn SSL_CTX_use_serverinfo_ex(ctx: *SslContext, version: u32, serverinfo: [*c]const u8, serverinfo_length: usize) i32;
    pub extern fn SSL_CTX_use_serverinfo_file(ctx: *SslContext, file: [*c]const u8) i32;
    pub extern fn SSL_CTX_use_serverinfo(ctx: *SslContext, serverinfo: [*c]const u8, serverinfo_length: usize) i32;
};