edition = "2018"

[dependencies]

# convenience macros

maplit = "1.0.2"

derive_more = "0.99.2"

# runtime

bincode = "1.3.1"

serde = { version = "1.0.114", features = ["derive"] }

getrandom = "0.1.14" # tiny crate. used to guess controller-id

# network

mio = { version = "0.7.0", package = "mio", features = ["udp", "tcp", "os-poll"] }

socket2 = { version = "0.3.12", optional = true }

# protocol

backtrace = "0.3"

lazy_static = "1.4.0"

# ffi

# socket ffi

libc = { version = "^0.2", optional = true }

[dev-dependencies]

# test-generator = "0.3.0"

crossbeam-utils = "0.7.2"

lazy_static = "1.4.0"

[lib]

# compile target: dynamically linked library using C ABI

crate-type = ["cdylib"]

[features]

default = ["ffi", "session_optimization"]

ffi = [] # see src/ffi/mod.rs

ffi_pseudo_socket_api = ["ffi", "libc", "os_socketaddr"]# see src/ffi/pseudo_socket_api.rs

endpoint_logging = [] # see src/macros.rs

session_optimization = [] # see src/runtime/setup.rs

        })

    }

    fn tl_clear() {

        STORED_ERROR.with(|stored_error| {

            let mut stored_error = stored_error.borrow_mut();

            stored_error.clear();

        })

    }

    fn tl_bytes_peek() -> (*const u8, usize) {

        STORED_ERROR.with(|stored_error| {

            let stored_error = stored_error.borrow();

            match stored_error.buf.len() {

                0 => (core::ptr::null(), 0), // no error!

                n => {

                    // stores an error of length n-1 AND a NULL TERMINATOR

                    (stored_error.buf.as_ptr(), n - 1)

                }

            }

        })

    }

}

thread_local! {

    static STORED_ERROR: RefCell<StoredError> = RefCell::new(StoredError::default());

}

pub const ERR_OK: c_int = 0;

pub const ERR_REOWOLF: c_int = -1;

pub const WRONG_STATE: c_int = -2;

pub const CC_MAP_LOCK_POISONED: c_int = -3;

pub const CLOSE_FAIL: c_int = -4;

pub const BAD_FD: c_int = -5;

pub const CONNECT_FAILED: c_int = -6;

pub const WOULD_BLOCK: c_int = -7;

pub const BAD_SOCKADDR: c_int = -8;

///////////////////// REOWOLF //////////////////////////

/// Returns length (via out pointer) and pointer (via return value) of the last Reowolf error.

/// - pointer is NULL iff there was no last error

/// - data at pointer is null-delimited

/// - len does NOT include the length of the null-delimiter

/// If len is NULL, it will not written to.

#[no_mangle]

pub unsafe extern "C" fn reowolf_error_peek(len: *mut usize) -> *const u8 {

    let (err_ptr, err_len) = StoredError::tl_bytes_peek();

    if !len.is_null() {

        len.write(err_len);

    }

use super::*;

use std::{

    collections::HashMap,

    ffi::c_void,

    libc::{sockaddr, socklen_t},

    net::{Ipv4Addr, SocketAddr, SocketAddrV4},

    os::raw::c_int,

    sync::RwLock,

};

///////////////////////////////////////////////////////////////////

struct FdAllocator {

    next: Option<c_int>,

    freed: Vec<c_int>,

}

struct ConnectorBound {

    connector: Connector,

    putter: PortId,

    getter: PortId,

}

struct ConnectorComplex {

    // invariants:

    // 1. connector is a upd-socket singleton

    // 2. putter and getter are ports in the native interface with the appropriate polarities

    // 3. peer_addr always mirrors connector's single udp socket's connect addr. both are overwritten together.

    peer_addr: SocketAddr,

    connector_bound: Option<ConnectorBound>,

}

#[derive(Default)]

struct CcMap {

    fd_to_cc: HashMap<c_int, RwLock<ConnectorComplex>>,

    fd_allocator: FdAllocator,

}

///////////////////////////////////////////////////////////////////

fn addr_from_raw(addr: *const sockaddr, addr_len: socklen_t) -> Option<SocketAddr> {

    os_socketaddr::OsSocketAddr::from_raw_parts(addr, addr_len as usize).into_addr()

}

fn trivial_peer_addr() -> SocketAddr {

    // SocketAddrV4::new isn't a constant-time func

    SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(0, 0, 0, 0), 0))

}

    }

}

#[no_mangle]

pub unsafe extern "C" fn rw_bind(fd: c_int, addr: *const sockaddr, addr_len: socklen_t) -> c_int {

    let addr = match addr_from_raw(addr, addr_len) {

        Some(addr) => addr,

        _ => return BAD_SOCKADDR,

    };

    // assuming _domain is AF_INET and _type is SOCK_DGRAM

    let r = if let Ok(r) = CC_MAP.read() { r } else { return CC_MAP_LOCK_POISONED };

    let cc = if let Some(cc) = r.fd_to_cc.get(&fd) { cc } else { return BAD_FD };

    let mut cc = if let Ok(cc) = cc.write() { cc } else { return CC_MAP_LOCK_POISONED };

    let cc: &mut ConnectorComplex = &mut cc;

    if cc.connector_bound.is_some() {

        return WRONG_STATE;

    }

    cc.connector_bound = {

        let mut connector = Connector::new(

            Box::new(crate::DummyLogger),

            crate::TRIVIAL_PD.clone(),

            Connector::random_id(),

        );

        let [putter, getter] = connector.new_udp_mediator_component(addr, cc.peer_addr).unwrap();

    };

    ERR_OK

}

#[no_mangle]

pub unsafe extern "C" fn rw_connect(

    fd: c_int,

    addr: *const sockaddr,

    addr_len: socklen_t,

) -> c_int {

    let addr = match addr_from_raw(addr, addr_len) {

        Some(addr) => addr,

        _ => return BAD_SOCKADDR,

    };

    // assuming _domain is AF_INET and _type is SOCK_DGRAM

    let r = if let Ok(r) = CC_MAP.read() { r } else { return CC_MAP_LOCK_POISONED };

    let cc = if let Some(cc) = r.fd_to_cc.get(&fd) { cc } else { return BAD_FD };

    let mut cc = if let Ok(cc) = cc.write() { cc } else { return CC_MAP_LOCK_POISONED };

    let cc: &mut ConnectorComplex = &mut cc;

    cc.connect(addr)

}

#[no_mangle]

pub unsafe extern "C" fn rw_send(