Struct TcpSocketOptions 

pub struct TcpSocketOptions {
    pub nodelay: Option<bool>,
    pub keepalive: Option<bool>,
    pub keepalive_idle_secs: Option<u32>,
    pub keepalive_interval_secs: Option<u32>,
    pub keepalive_count: Option<u32>,
    pub recv_buf: Option<u32>,
    pub send_buf: Option<u32>,
    pub linger_secs: Option<u32>,
    pub quickack: Option<bool>,
    pub reuse_port: Option<bool>,
}

Per-connection TCP tuning applied to every accepted socket.

All fields are optional. When None, the FreeBSD default is used. Construct with Default::default() for all defaults, or use the builder methods to override specific values.

let opts = TcpSocketOptions::default()
    .nodelay(true)
    .keepalive(true)
    .keepalive_idle_secs(10)
    .keepalive_interval_secs(5)
    .keepalive_count(3);

Fields

nodelay: Option<bool>

Disable Nagle’s algorithm — send data immediately without coalescing small writes. Essential for latency-sensitive protocols.

keepalive: Option<bool>

Enable TCP keepalive probes on idle connections. When the remote peer disappears without sending a FIN (crash, network partition), keepalive detects it and tears down the connection.

keepalive_idle_secs: Option<u32>

Seconds of idle time before the first keepalive probe is sent. FreeBSD default: 7200 (2 hours).

keepalive_interval_secs: Option<u32>

Seconds between consecutive keepalive probes after the first. FreeBSD default: 75.

keepalive_count: Option<u32>

Number of unacknowledged keepalive probes before the connection is dropped. FreeBSD default: 8.

recv_buf: Option<u32>

Receive buffer size in bytes. Larger buffers allow higher throughput on high-latency links. FreeBSD default: ~64 KB.

send_buf: Option<u32>

Send buffer size in bytes. FreeBSD default: ~64 KB.

linger_secs: Option<u32>

Linger timeout in seconds. When set, ff_close blocks (up to this many seconds) until buffered data is sent, then sends RST if it couldn’t drain in time. When None, close returns immediately and the stack drains in the background.

quickack: Option<bool>

Disable delayed ACKs — acknowledge segments immediately instead of waiting up to 40ms to piggyback the ACK on outgoing data. Complementary to nodelay for lowest latency.

reuse_port: Option<bool>

Allow multiple sockets to bind the same address:port combination. Useful for multi-process F-Stack setups.

Implementations

impl TcpSocketOptions

pub fn nodelay(self, v: bool) -> Self

Examples found in repository

examples/tcp_echo.rs (line 49)

fn main() {
    // Docker/TAP configuration — swap for FStackConfig::for_bare_metal() on bare metal.
    let cfg = FStackConfig::for_docker();

    println!("Initializing F-Stack...");
    init_fstack(&cfg.config_args(), &cfg.eal_args());

    let bind_ip   = "0.0.0.0".to_string();
    let bind_port = 8080u16;

    let tcp_opts = TcpSocketOptions::default()
        .nodelay(true)
        .quickack(true);

    println!("Creating TCP listener on {}:{}...", bind_ip, bind_port);
    let listener: UniquePtr<FStackTcpListener> =
        create_tcp_listener(&bind_ip, bind_port, &tcp_opts.to_ffi(), on_connect, on_data, on_disconnect);

    unsafe {
        GLOBAL_LISTENER = Some(&*listener as *const FStackTcpListener);
    }

    println!("Starting F-Stack TCP event loop...");
    run_fstack_tcp(&listener);
}

pub fn keepalive(self, v: bool) -> Self

pub fn keepalive_idle_secs(self, v: u32) -> Self

pub fn keepalive_interval_secs(self, v: u32) -> Self

pub fn keepalive_count(self, v: u32) -> Self

pub fn recv_buf(self, v: u32) -> Self

pub fn send_buf(self, v: u32) -> Self

pub fn linger_secs(self, v: u32) -> Self

pub fn quickack(self, v: bool) -> Self

Examples found in repository

examples/tcp_echo.rs (line 50)

fn main() {
    // Docker/TAP configuration — swap for FStackConfig::for_bare_metal() on bare metal.
    let cfg = FStackConfig::for_docker();

    println!("Initializing F-Stack...");
    init_fstack(&cfg.config_args(), &cfg.eal_args());

    let bind_ip   = "0.0.0.0".to_string();
    let bind_port = 8080u16;

    let tcp_opts = TcpSocketOptions::default()
        .nodelay(true)
        .quickack(true);

    println!("Creating TCP listener on {}:{}...", bind_ip, bind_port);
    let listener: UniquePtr<FStackTcpListener> =
        create_tcp_listener(&bind_ip, bind_port, &tcp_opts.to_ffi(), on_connect, on_data, on_disconnect);

    unsafe {
        GLOBAL_LISTENER = Some(&*listener as *const FStackTcpListener);
    }

    println!("Starting F-Stack TCP event loop...");
    run_fstack_tcp(&listener);
}

pub fn reuse_port(self, v: bool) -> Self

pub fn to_ffi(&self) -> TcpSocketOptionsFfi

Convert to the flat cxx-bridge struct. -1 encodes “not set / use FreeBSD default”.

Examples found in repository

examples/tcp_echo.rs (line 54)

fn main() {
    // Docker/TAP configuration — swap for FStackConfig::for_bare_metal() on bare metal.
    let cfg = FStackConfig::for_docker();

    println!("Initializing F-Stack...");
    init_fstack(&cfg.config_args(), &cfg.eal_args());

    let bind_ip   = "0.0.0.0".to_string();
    let bind_port = 8080u16;

    let tcp_opts = TcpSocketOptions::default()
        .nodelay(true)
        .quickack(true);

    println!("Creating TCP listener on {}:{}...", bind_ip, bind_port);
    let listener: UniquePtr<FStackTcpListener> =
        create_tcp_listener(&bind_ip, bind_port, &tcp_opts.to_ffi(), on_connect, on_data, on_disconnect);

    unsafe {
        GLOBAL_LISTENER = Some(&*listener as *const FStackTcpListener);
    }

    println!("Starting F-Stack TCP event loop...");
    run_fstack_tcp(&listener);
}

Trait Implementations

impl Clone for TcpSocketOptions

fn clone(&self) -> TcpSocketOptions

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TcpSocketOptions

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for TcpSocketOptions

fn default() -> TcpSocketOptions

Returns the “default value” for a type.