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"

# socket ffi

[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]

endpoint_logging = [] # see src/macros.rs

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

 */

Arc_ProtocolDescription *protocol_description_clone(const Arc_ProtocolDescription *pd);

/**

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

 */

void protocol_description_destroy(Arc_ProtocolDescription *pd);

/**

 * 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

 */

Arc_ProtocolDescription *protocol_description_parse(const uint8_t *pdl, uintptr_t pdl_len);

/**

 * 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.

 */

const uint8_t *reowolf_error_peek(uintptr_t *len);

#endif /* REOWOLF_HEADER_DEFINED */

use crate::{common::*, runtime::*};

use core::{cell::RefCell, convert::TryFrom};

use std::os::raw::c_int;

use std::slice::from_raw_parts as slice_from_raw_parts;

// Temporary simplfication: ignore ipv6. To revert, just refactor this structure and its usages

#[repr(C)]

pub struct FfiSocketAddr {

    pub ipv4: [u8; 4],

    pub port: u16,

}

impl Into<SocketAddr> for FfiSocketAddr {

    fn into(self) -> SocketAddr {

        (self.ipv4, self.port).into()

    }

}

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

#[derive(Default)]

struct StoredError {

    // invariant: len is zero IFF its occupied

    // contents are 1+ bytes because we also store the NULL TERMINATOR

    buf: Vec<u8>,

}

impl StoredError {

    const NULL_TERMINATOR: u8 = 0;

    fn clear(&mut self) {

        // no null terminator either!

unsafe fn tl_socketaddr_from_raw(

    bytes_ptr: *const u8,

    bytes_len: usize,

) -> Result<SocketAddr, c_int> {

    std::str::from_utf8(&*slice_from_raw_parts(bytes_ptr, bytes_len))

        .map_err(|err| {

            StoredError::tl_debug_store(&err);

            ERR_REOWOLF

        })?

        .parse()

        .map_err(|err| {

            StoredError::tl_debug_store(&err);

            ERR_REOWOLF

        })

}

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;

///////////////////// 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(

use super::*;

use std::{

    collections::HashMap,

    ffi::c_void,

    net::{Ipv4Addr, SocketAddr, SocketAddrV4},

    os::raw::c_int,

    sync::RwLock,

};

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

struct FdAllocator {

    next: Option<c_int>,

    freed: Vec<c_int>,

}

struct ConnectorBound {

    connector: Connector,

    is_nonblocking: bool,

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

    // 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(),

        );

        Some(ConnectorBound { connector, putter, getter, is_nonblocking: false })

    };

    ERR_OK

}

#[no_mangle]

pub unsafe extern "C" fn rw_connect(

    fd: c_int,

) -> c_int {

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

}

#[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 };

    let cc: &mut ConnectorComplex = &mut cc;

    cc.recv(bytes_ptr, bytes_len)

}

#[no_mangle]

pub unsafe extern "C" fn rw_sendto(

    fd: c_int,

    bytes_ptr: *mut c_void,

    bytes_len: usize,

    _flags: c_int,

) -> isize {

    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;

    // connect to given peer_addr

        e if e != ERR_OK => return e as isize,

        _ => {}

    }

    // send

    let ret = cc.send(bytes_ptr, bytes_len);

        e if e != ERR_OK => return e as isize,

        _ => {}

    }

    ret

}

#[no_mangle]

pub unsafe extern "C" fn rw_recvfrom(

    fd: c_int,

    bytes_ptr: *mut c_void,

    bytes_len: usize,

    _flags: c_int,

) -> isize {

    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;

    // connect to given peer_addr

    match cc.connect(peer_addr.read()) {

        e if e != ERR_OK => return e as isize,

        _ => {}

    }

    // send

    let ret = cc.send(bytes_ptr, bytes_len);

        e if e != ERR_OK => return e as isize,

        _ => {}

    }

    ret

}