diff --git a/reowolf.h b/reowolf.h index 5f92cd04f9b15e7f4a2b06ac05d8d53be22ba8a9..c40c2585c23b94293a65fad9442bf4876e5ed53a 100644 --- a/reowolf.h +++ b/reowolf.h @@ -8,21 +8,23 @@ #include #include -#define BAD_FD -5 +#define RW_BAD_FD -5 -#define CC_MAP_LOCK_POISONED -3 +#define RW_BAD_SOCKADDR -8 -#define CLOSE_FAIL -4 +#define RW_CLOSE_FAIL -4 -#define CONNECT_FAILED -6 +#define RW_CONNECT_FAILED -6 -#define ERR_OK 0 +#define RW_LOCK_POISONED -3 -#define ERR_REOWOLF -1 +#define RW_OK 0 -#define WOULD_BLOCK -7 +#define RW_TL_ERR -1 -#define WRONG_STATE -2 +#define RW_WOULD_BLOCK -7 + +#define RW_WRONG_STATE -2 typedef enum { EndpointPolarity_Active, @@ -100,11 +102,11 @@ void connector_add_port_pair(Connector *connector, PortId *out_putter, PortId *o * - where P is a Putter port that sends messages into the socket * - where G is a Getter port that recvs messages from the socket */ -int connector_add_udp_port_pair(Connector *connector, - PortId *putter, - PortId *getter, - FfiSocketAddr local_addr, - FfiSocketAddr peer_addr); +int connector_add_udp_mediator_component(Connector *connector, + PortId *putter, + PortId *getter, + FfiSocketAddr local_addr, + FfiSocketAddr peer_addr); /** * Connects this connector to the distributed system of connectors reachable through endpoints, @@ -173,30 +175,4 @@ Arc_ProtocolDescription *protocol_description_parse(const uint8_t *pdl, uintptr_ */ const uint8_t *reowolf_error_peek(uintptr_t *len); -int rw_bind(int fd, const SocketAddr *local_addr, uintptr_t _addr_len); - -int rw_close(int fd, int _how); - -int rw_connect(int fd, const SocketAddr *peer_addr, uintptr_t _address_len); - -intptr_t rw_recv(int fd, void *bytes_ptr, uintptr_t bytes_len, int _flags); - -intptr_t rw_recvfrom(int fd, - void *bytes_ptr, - uintptr_t bytes_len, - int _flags, - const SocketAddr *peer_addr, - uintptr_t _addr_len); - -intptr_t rw_send(int fd, const void *bytes_ptr, uintptr_t bytes_len, int _flags); - -intptr_t rw_sendto(int fd, - void *bytes_ptr, - uintptr_t bytes_len, - int _flags, - const SocketAddr *peer_addr, - uintptr_t _addr_len); - -int rw_socket(int _domain, int _type); - #endif /* REOWOLF_HEADER_DEFINED */ diff --git a/src/ffi/mod.rs b/src/ffi/mod.rs index f5f1aabd32d4c2deb527c29c7bc9858a03338baa..e834e056417fb2dfbbb2e832d885776fbb669633 100644 --- a/src/ffi/mod.rs +++ b/src/ffi/mod.rs @@ -4,6 +4,7 @@ use std::os::raw::c_int; use std::slice::from_raw_parts as slice_from_raw_parts; #[cfg(all(target_os = "linux", feature = "ffi_pseudo_socket_api"))] +/// cbindgen:ignore pub mod pseudo_socket_api; // Temporary simplfication: ignore ipv6. To revert, just refactor this structure and its usages @@ -76,16 +77,15 @@ thread_local! { static STORED_ERROR: RefCell = 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 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; -pub const SEND_BEFORE_CONNECT: c_int = -9; +pub const RW_OK: c_int = 0; +pub const RW_TL_ERR: c_int = -1; +pub const RW_WRONG_STATE: c_int = -2; +pub const RW_LOCK_POISONED: c_int = -3; +pub const RW_CLOSE_FAIL: c_int = -4; +pub const RW_BAD_FD: c_int = -5; +pub const RW_CONNECT_FAILED: c_int = -6; +pub const RW_WOULD_BLOCK: c_int = -7; +pub const RW_BAD_SOCKADDR: c_int = -8; ///////////////////// REOWOLF ////////////////////////// @@ -223,10 +223,10 @@ pub unsafe extern "C" fn connector_add_component( &*slice_from_raw_parts(ident_ptr, ident_len), &*slice_from_raw_parts(ports_ptr, ports_len), ) { - Ok(()) => ERR_OK, + Ok(()) => RW_OK, Err(err) => { StoredError::tl_debug_store(&err); - ERR_REOWOLF + RW_TL_ERR } } } @@ -251,11 +251,11 @@ pub unsafe extern "C" fn connector_add_net_port( if !port.is_null() { port.write(p); } - ERR_OK + RW_OK } Err(err) => { StoredError::tl_debug_store(&err); - ERR_REOWOLF + RW_TL_ERR } } } @@ -284,11 +284,11 @@ pub unsafe extern "C" fn connector_add_udp_mediator_component( if !getter.is_null() { getter.write(g); } - ERR_OK + RW_OK } Err(err) => { StoredError::tl_debug_store(&err); - ERR_REOWOLF + RW_TL_ERR } } } @@ -304,10 +304,10 @@ pub unsafe extern "C" fn connector_connect( let option_timeout_millis: Option = TryFrom::try_from(timeout_millis).ok(); let timeout = option_timeout_millis.map(Duration::from_millis); match connector.connect(timeout) { - Ok(()) => ERR_OK, + Ok(()) => RW_OK, Err(err) => { StoredError::tl_debug_store(&err); - ERR_REOWOLF + RW_TL_ERR } } } @@ -354,10 +354,10 @@ pub unsafe extern "C" fn connector_put_bytes( StoredError::tl_clear(); let bytes = &*slice_from_raw_parts(bytes_ptr, bytes_len); match connector.put(port, Payload::from(bytes)) { - Ok(()) => ERR_OK, + Ok(()) => RW_OK, Err(err) => { StoredError::tl_debug_store(&err); - ERR_REOWOLF + RW_TL_ERR } } } @@ -366,10 +366,10 @@ pub unsafe extern "C" fn connector_put_bytes( pub unsafe extern "C" fn connector_get(connector: &mut Connector, port: PortId) -> c_int { StoredError::tl_clear(); match connector.get(port) { - Ok(()) => ERR_OK, + Ok(()) => RW_OK, Err(err) => { StoredError::tl_debug_store(&err); - ERR_REOWOLF + RW_TL_ERR } } } @@ -381,7 +381,7 @@ pub unsafe extern "C" fn connector_next_batch(connector: &mut Connector) -> isiz Ok(n) => n as isize, Err(err) => { StoredError::tl_debug_store(&err); - ERR_REOWOLF as isize + RW_TL_ERR as isize } } } @@ -395,7 +395,7 @@ pub unsafe extern "C" fn connector_sync(connector: &mut Connector, timeout_milli Ok(n) => n as isize, Err(err) => { StoredError::tl_debug_store(&err); - ERR_REOWOLF as isize + RW_TL_ERR as isize } } } diff --git a/src/ffi/pseudo_socket_api.rs b/src/ffi/pseudo_socket_api.rs index 27feccc7abb2692bb6a46910014cf4633ce43039..8adbbcb85fc32d9c0b0a8996dc525e544d374f28 100644 --- a/src/ffi/pseudo_socket_api.rs +++ b/src/ffi/pseudo_socket_api.rs @@ -81,7 +81,7 @@ impl ConnectorComplex { #[no_mangle] pub extern "C" fn rw_socket(_domain: c_int, _type: c_int, _protocol: c_int) -> c_int { // get writer lock - let mut w = if let Ok(w) = CC_MAP.write() { w } else { return LOCK_POISONED }; + let mut w = if let Ok(w) = CC_MAP.write() { w } else { return RW_LOCK_POISONED }; let fd = w.fd_allocator.alloc(); let cc = ConnectorComplex { connector: Connector::new( @@ -98,12 +98,12 @@ pub extern "C" fn rw_socket(_domain: c_int, _type: c_int, _protocol: c_int) -> c pub extern "C" fn rw_close(fd: c_int, _how: c_int) -> c_int { // ignoring HOW // get writer lock - let mut w = if let Ok(w) = CC_MAP.write() { w } else { return LOCK_POISONED }; + let mut w = if let Ok(w) = CC_MAP.write() { w } else { return RW_LOCK_POISONED }; if w.fd_to_cc.remove(&fd).is_some() { w.fd_allocator.free(fd); - ERR_OK + RW_OK } else { - CLOSE_FAIL + RW_CLOSE_FAIL } } #[no_mangle] @@ -111,18 +111,18 @@ pub unsafe extern "C" fn rw_bind(fd: c_int, addr: *const sockaddr, addr_len: soc // assuming _domain is AF_INET and _type is SOCK_DGRAM let addr = match libc_to_std_sockaddr(addr, addr_len) { Some(addr) => addr, - _ => return BAD_SOCKADDR, + _ => return RW_BAD_SOCKADDR, }; // get outer reader, inner writer locks - let r = if let Ok(r) = CC_MAP.read() { r } else { return 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.lock() { cc } else { return LOCK_POISONED }; + let r = if let Ok(r) = CC_MAP.read() { r } else { return RW_LOCK_POISONED }; + let cc = if let Some(cc) = r.fd_to_cc.get(&fd) { cc } else { return RW_BAD_FD }; + let mut cc = if let Ok(cc) = cc.lock() { cc } else { return RW_LOCK_POISONED }; match &mut cc.phased { - ConnectorComplexPhased::Communication { .. } => WRONG_STATE, + ConnectorComplexPhased::Communication { .. } => RW_WRONG_STATE, ConnectorComplexPhased::Setup { local, .. } => { *local = Some(addr); cc.try_become_connected(); - ERR_OK + RW_OK } } } @@ -134,19 +134,19 @@ pub unsafe extern "C" fn rw_connect( ) -> c_int { let addr = match libc_to_std_sockaddr(addr, addr_len) { Some(addr) => addr, - _ => return BAD_SOCKADDR, + _ => return RW_BAD_SOCKADDR, }; // assuming _domain is AF_INET and _type is SOCK_DGRAM // get outer reader, inner writer locks - let r = if let Ok(r) = CC_MAP.read() { r } else { return 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.lock() { cc } else { return LOCK_POISONED }; + let r = if let Ok(r) = CC_MAP.read() { r } else { return RW_LOCK_POISONED }; + let cc = if let Some(cc) = r.fd_to_cc.get(&fd) { cc } else { return RW_BAD_FD }; + let mut cc = if let Ok(cc) = cc.lock() { cc } else { return RW_LOCK_POISONED }; match &mut cc.phased { - ConnectorComplexPhased::Communication { .. } => WRONG_STATE, + ConnectorComplexPhased::Communication { .. } => RW_WRONG_STATE, ConnectorComplexPhased::Setup { peer, .. } => { *peer = Some(addr); cc.try_become_connected(); - ERR_OK + RW_OK } } } @@ -159,12 +159,12 @@ pub unsafe extern "C" fn rw_send( ) -> isize { // ignoring flags // get outer reader, inner writer locks - let r = if let Ok(r) = CC_MAP.read() { r } else { return 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.lock() { cc } else { return LOCK_POISONED as isize }; + let r = if let Ok(r) = CC_MAP.read() { r } else { return RW_LOCK_POISONED as isize }; + let cc = if let Some(cc) = r.fd_to_cc.get(&fd) { cc } else { return RW_BAD_FD as isize }; + let mut cc = if let Ok(cc) = cc.lock() { cc } else { return RW_LOCK_POISONED as isize }; let ConnectorComplex { connector, phased } = cc.deref_mut(); match phased { - ConnectorComplexPhased::Setup { .. } => WRONG_STATE as isize, + ConnectorComplexPhased::Setup { .. } => RW_WRONG_STATE as isize, ConnectorComplexPhased::Communication { putter, .. } => { let payload = payload_from_raw(bytes_ptr, bytes_len); connector.put(*putter, payload).unwrap(); @@ -182,12 +182,12 @@ pub unsafe extern "C" fn rw_recv( ) -> isize { // ignoring flags // get outer reader, inner writer locks - let r = if let Ok(r) = CC_MAP.read() { r } else { return 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.lock() { cc } else { return LOCK_POISONED as isize }; + let r = if let Ok(r) = CC_MAP.read() { r } else { return RW_LOCK_POISONED as isize }; + let cc = if let Some(cc) = r.fd_to_cc.get(&fd) { cc } else { return RW_BAD_FD as isize }; + let mut cc = if let Ok(cc) = cc.lock() { cc } else { return RW_LOCK_POISONED as isize }; let ConnectorComplex { connector, phased } = cc.deref_mut(); match phased { - ConnectorComplexPhased::Setup { .. } => WRONG_STATE as isize, + ConnectorComplexPhased::Setup { .. } => RW_WRONG_STATE as isize, ConnectorComplexPhased::Communication { getter, .. } => { connector.get(*getter).unwrap(); connector.sync(None).unwrap();