[package]

name = "reowolf_rs"

version = "0.1.4"

authors = [

	"Christopher Esterhuyse <esterhuy@cwi.nl, christopher.esterhuyse@gmail.com>",

	"Hans-Dieter Hiep <hdh@cwi.nl>"

]

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 clear(&mut self) {

        // no null terminator either!

        self.buf.clear();

    }

    fn debug_store<E: Debug>(&mut self, error: &E) {

        let _ = write!(&mut self.buf, "{:?}", error);

        self.buf.push(Self::NULL_TERMINATOR);

    }

    fn tl_debug_store<E: Debug>(error: &E) {

        STORED_ERROR.with(|stored_error| {

            let mut stored_error = stored_error.borrow_mut();

            stored_error.clear();

            stored_error.debug_store(error);

        })

    }

    fn bytes_store(&mut self, bytes: &[u8]) {

        let _ = self.buf.write_all(bytes);

        self.buf.push(Self::NULL_TERMINATOR);

    }

    fn tl_bytes_store(bytes: &[u8]) {

        STORED_ERROR.with(|stored_error| {

            let mut stored_error = stored_error.borrow_mut();

            stored_error.clear();

            stored_error.bytes_store(bytes);

        })

    }

    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);

    }

    err_ptr

}

///////////////////// PROTOCOL DESCRIPTION //////////////////////////

/// Parses the utf8-encoded string slice to initialize a new protocol description object.

/// - On success, initializes `out` and returns 0

/// - On failure, stores an error string (see `reowolf_error_peek`) and returns -1

#[no_mangle]

pub unsafe extern "C" fn protocol_description_parse(

    pdl: *const u8,

    pdl_len: usize,

) -> *mut Arc<ProtocolDescription> {

    StoredError::tl_clear();

    match ProtocolDescription::parse(&*slice_from_raw_parts(pdl, pdl_len)) {

        Ok(new) => Box::into_raw(Box::new(Arc::new(new))),

        Err(err) => {

            StoredError::tl_bytes_store(err.as_bytes());

            std::ptr::null_mut()

        }

    }

}

/// Destroys the given initialized protocol description and frees its resources.

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))

}

impl Default for FdAllocator {

    fn default() -> Self {

        Self {

            next: Some(0), // positive values used only

            freed: vec![],

        }

    }

}

impl FdAllocator {

    fn alloc(&mut self) -> c_int {

        if let Some(fd) = self.freed.pop() {

            return fd;

        }

        if let Some(fd) = self.next {

            self.next = fd.checked_add(1);

            return fd;

        }

        panic!("No more Connector FDs to allocate!")

    }

    fn free(&mut self, fd: c_int) {

        self.freed.push(fd);

    }

}

lazy_static::lazy_static! {

    }

}

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

#[no_mangle]

pub extern "C" fn rw_socket(_domain: c_int, _type: c_int) -> c_int {

    // ignoring domain and type

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

    let fd = w.fd_allocator.alloc();

    let cc = ConnectorComplex { peer_addr: trivial_peer_addr(), connector_bound: None };

    w.fd_to_cc.insert(fd, RwLock::new(cc));

    fd

}

#[no_mangle]

pub extern "C" fn rw_close(fd: c_int, _how: c_int) -> c_int {

    // ignoring HOW

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

    if w.fd_to_cc.remove(&fd).is_some() {

        w.fd_allocator.free(fd);

        ERR_OK

    } else {

        CLOSE_FAIL

    }

}

#[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(

    fd: c_int,

    bytes_ptr: *const c_void,

    bytes_len: usize,

    _flags: c_int,

) -> isize {

    // ignoring flags

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

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

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

    let cc: &mut ConnectorComplex = &mut cc;

    cc.send(bytes_ptr, bytes_len)

}

#[no_mangle]

pub unsafe extern "C" fn rw_recv(

    fd: c_int,

    bytes_ptr: *mut c_void,

    bytes_len: usize,

    _flags: c_int,

) -> isize {

    // ignoring flags

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

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

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