Files
@ 700221108e9f
Branch filter:
Location: CSY/reowolf/src/ffi/socket_api.rs
700221108e9f
5.8 KiB
application/rls-services+xml
socket api relaxed. bind and connect in any order. bind once and connect any number of times
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 | use super::*;
use atomic_refcell::AtomicRefCell;
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,
putter: PortId,
getter: PortId,
}
struct MaybeConnector {
// 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 CspStorage {
fd_to_mc: HashMap<c_int, AtomicRefCell<MaybeConnector>>,
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! {
static ref CSP_STORAGE: RwLock<CspStorage> = Default::default();
}
///////////////////////////////////////////////////////////////////
#[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) = CSP_STORAGE.write() { w } else { return FD_LOCK_POISONED };
let fd = w.fd_allocator.alloc();
let mc = MaybeConnector { peer_addr: trivial_peer_addr(), connector_bound: None };
w.fd_to_mc.insert(fd, AtomicRefCell::new(mc));
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) = CSP_STORAGE.write() { w } else { return FD_LOCK_POISONED };
w.fd_allocator.free(fd);
if w.fd_to_mc.remove(&fd).is_some() {
ERR_OK
} else {
CLOSE_FAIL
}
}
#[no_mangle]
pub unsafe extern "C" fn rw_bind(
fd: c_int,
local_addr: *const SocketAddr,
_addr_len: usize,
) -> c_int {
// assuming _domain is AF_INET and _type is SOCK_DGRAM
let r = if let Ok(r) = CSP_STORAGE.read() { r } else { return FD_LOCK_POISONED };
let mc = if let Some(mc) = r.fd_to_mc.get(&fd) { mc } else { return BAD_FD };
let mc: &mut MaybeConnector = &mut mc.borrow_mut();
if mc.connector_bound.is_some() {
return WRONG_STATE;
}
mc.connector_bound = {
let mut connector = Connector::new(
Box::new(crate::DummyLogger),
crate::TRIVIAL_PD.clone(),
Connector::random_id(),
);
let [putter, getter] = connector.new_udp_port(local_addr.read(), mc.peer_addr).unwrap();
Some(ConnectorBound { connector, putter, getter })
};
ERR_OK
}
#[no_mangle]
pub unsafe extern "C" fn rw_connect(
fd: c_int,
peer_addr: *const SocketAddr,
_address_len: usize,
) -> c_int {
// assuming _domain is AF_INET and _type is SOCK_DGRAM
let r = if let Ok(r) = CSP_STORAGE.read() { r } else { return FD_LOCK_POISONED };
let mc = if let Some(mc) = r.fd_to_mc.get(&fd) { mc } else { return BAD_FD };
let mc: &mut MaybeConnector = &mut mc.borrow_mut();
mc.peer_addr = peer_addr.read();
if let Some(ConnectorBound { connector, .. }) = &mut mc.connector_bound {
if connector.get_mut_udp_sock(0).unwrap().connect(mc.peer_addr).is_err() {
return CONNECT_FAILED;
}
}
ERR_OK
}
#[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) = CSP_STORAGE.read() { r } else { return FD_LOCK_POISONED as isize };
let mc = if let Some(mc) = r.fd_to_mc.get(&fd) { mc } else { return BAD_FD as isize };
let mc: &mut MaybeConnector = &mut mc.borrow_mut();
if let Some(ConnectorBound { connector, putter, .. }) = &mut mc.connector_bound {
match connector_put_bytes(connector, *putter, bytes_ptr as _, bytes_len) {
ERR_OK => connector_sync(connector, -1),
err => err as isize,
}
} else {
WRONG_STATE as isize // not bound!
}
}
#[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) = CSP_STORAGE.read() { r } else { return FD_LOCK_POISONED as isize };
let mc = if let Some(mc) = r.fd_to_mc.get(&fd) { mc } else { return BAD_FD as isize };
let mc: &mut MaybeConnector = &mut mc.borrow_mut();
if let Some(ConnectorBound { connector, getter, .. }) = &mut mc.connector_bound {
connector_get(connector, *getter);
match connector_sync(connector, -1) {
0 => {
// batch index 0 means OK
let slice = connector.gotten(*getter).unwrap().as_slice();
let copied_bytes = slice.len().min(bytes_len);
std::ptr::copy_nonoverlapping(slice.as_ptr(), bytes_ptr as *mut u8, copied_bytes);
copied_bytes as isize
}
err => return err as isize,
}
} else {
WRONG_STATE as isize // not bound!
}
}
|