struct Options [src]

Fields

enable_segfault_handler: bool = debug.default_enable_segfault_handler

wasiCwd: fn () os.wasi.fd_t = fs.defaultWasiCwdFunction used to implement std.fs.cwd for WASI.

log_level: log.Level = log.default_levelThe current log level.

log_scope_levels: []const log.ScopeLevel = &.{}

logFn: fn ( comptime message_level: log.Level, comptime scope: @TypeOf(.enum_literal), comptime format: []const u8, args: anytype, ) void = log.defaultLog

page_size_min: ?usize = nullOverrides std.heap.page_size_min.

page_size_max: ?usize = nullOverrides std.heap.page_size_max.

queryPageSize: fn () usize = heap.defaultQueryPageSizeOverrides default implementation for determining OS page size at runtime.

fmt_max_depth: usize = fmt.default_max_depth

cryptoRandomSeed: fn (buffer: []u8) void = @import("crypto/tlcsprng.zig").defaultRandomSeed

crypto_always_getrandom: bool = false

crypto_fork_safety: bool = true

keep_sigpipe: bool = falseBy default Zig disables SIGPIPE by setting a "no-op" handler for it. Set this option to true to prevent that. Note that we use a "no-op" handler instead of SIG_IGN because it will not be inherited by any child process. SIGPIPE is triggered when a process attempts to write to a broken pipe. By default, SIGPIPE will terminate the process instead of exiting. It doesn't trigger the panic handler so in many cases it's unclear why the process was terminated. By capturing SIGPIPE instead, functions that write to broken pipes will return the EPIPE error (error.BrokenPipe) and the program can handle it like any other error.

http_disable_tls: bool = falseBy default, std.http.Client will support HTTPS connections. Set this option to true to disable TLS support. This will likely reduce the size of the binary, but it will also make it impossible to make a HTTPS connection.

http_enable_ssl_key_log_file: bool = @import("builtin").mode == .DebugThis enables std.http.Client to log ssl secrets to the file specified by the SSLKEYLOGFILE env var. Creating such a log file allows other programs with access to that file to decrypt all std.http.Client traffic made by this program.

side_channels_mitigations: crypto.SideChannelsMitigations = crypto.default_side_channels_mitigations

Source

  pub const Options = struct {
    enable_segfault_handler: bool = debug.default_enable_segfault_handler,

    /// Function used to implement `std.fs.cwd` for WASI.
    wasiCwd: fn () os.wasi.fd_t = fs.defaultWasiCwd,

    /// The current log level.
    log_level: log.Level = log.default_level,

    log_scope_levels: []const log.ScopeLevel = &.{},

    logFn: fn (
        comptime message_level: log.Level,
        comptime scope: @TypeOf(.enum_literal),
        comptime format: []const u8,
        args: anytype,
    ) void = log.defaultLog,

    /// Overrides `std.heap.page_size_min`.
    page_size_min: ?usize = null,
    /// Overrides `std.heap.page_size_max`.
    page_size_max: ?usize = null,
    /// Overrides default implementation for determining OS page size at runtime.
    queryPageSize: fn () usize = heap.defaultQueryPageSize,

    fmt_max_depth: usize = fmt.default_max_depth,

    cryptoRandomSeed: fn (buffer: []u8) void = @import("crypto/tlcsprng.zig").defaultRandomSeed,

    crypto_always_getrandom: bool = false,

    crypto_fork_safety: bool = true,

    /// By default Zig disables SIGPIPE by setting a "no-op" handler for it.  Set this option
    /// to `true` to prevent that.
    ///
    /// Note that we use a "no-op" handler instead of SIG_IGN because it will not be inherited by
    /// any child process.
    ///
    /// SIGPIPE is triggered when a process attempts to write to a broken pipe. By default, SIGPIPE
    /// will terminate the process instead of exiting.  It doesn't trigger the panic handler so in many
    /// cases it's unclear why the process was terminated.  By capturing SIGPIPE instead, functions that
    /// write to broken pipes will return the EPIPE error (error.BrokenPipe) and the program can handle
    /// it like any other error.
    keep_sigpipe: bool = false,

    /// By default, std.http.Client will support HTTPS connections.  Set this option to `true` to
    /// disable TLS support.
    ///
    /// This will likely reduce the size of the binary, but it will also make it impossible to
    /// make a HTTPS connection.
    http_disable_tls: bool = false,

    /// This enables `std.http.Client` to log ssl secrets to the file specified by the SSLKEYLOGFILE
    /// env var.  Creating such a log file allows other programs with access to that file to decrypt
    /// all `std.http.Client` traffic made by this program.
    http_enable_ssl_key_log_file: bool = @import("builtin").mode == .Debug,

    side_channels_mitigations: crypto.SideChannelsMitigations = crypto.default_side_channels_mitigations,
}  