From 7b9df91324ad400b93c44dff555f661084aac064 2020-07-13 16:52:23 From: Christopher Esterhuyse Date: 2020-07-13 16:52:23 Subject: [PATCH] fixed unintentional name collisions in socket-micking API --- diff --git a/Cargo.toml b/Cargo.toml index 975f1ac041e56bc71a3e2953ddc939500b43ebfc..15f6693b5223cb5daec4c73ef7a4ac8c5ebeea8a 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -37,7 +37,7 @@ lazy_static = "1.4.0" crate-type = ["cdylib"] [features] -default = ["ffi", "session_optimization"] +default = ["ffi", "session_optimization", "ffi_socket_api"] ffi = [] # see src/ffi.rs ffi_socket_api = ["ffi", "lazy_static", "atomic_refcell"] endpoint_logging = [] # see src/macros.rs diff --git a/examples/pres_1/amy.c b/examples/pres_1/amy.c new file mode 100644 index 0000000000000000000000000000000000000000..094d3f0765a40b15029345cfc54c03cd70db8a62 --- /dev/null +++ b/examples/pres_1/amy.c @@ -0,0 +1,39 @@ +#include "../../reowolf.h" +#include "../utility.c" +int main(int argc, char** argv) { + // Create a connector... + Arc_ProtocolDescription * pd = protocol_description_parse("", 0); + char logpath[] = "./pres_1_amy.txt"; + Connector * c = connector_new_logging(pd, logpath, sizeof(logpath)-1); + printf("Error str `%s`\n", reowolf_error_peek(NULL)); + + // ... with 1 outgoing network connection + PortId p0; + char addr_str[] = "127.0.0.1:8000"; + connector_add_net_port( + c, &p0, addr_str, sizeof(addr_str)-1, Polarity_Getter, EndpointPolarity_Active); + printf("Error str `%s`\n", reowolf_error_peek(NULL)); + + // Connect! Begin communication. 5000ms timeout + connector_connect(c, 5000); + printf("Error str `%s`\n", reowolf_error_peek(NULL)); + + // Ask to receive a message... + connector_get(c, p0); + printf("Error str `%s`\n", reowolf_error_peek(NULL)); + + // ... or timeout within 1000ms. + connector_sync(c, 1000); + printf("Error str `%s`\n", reowolf_error_peek(NULL)); + + // Print the message we received + size_t msg_len; + const char * msg_ptr = connector_gotten_bytes(c, p0, &msg_len); + printf("Got msg `%.*s`\n", msg_len, msg_ptr); + + printf("Exiting\n"); + protocol_description_destroy(pd); + connector_destroy(c); + sleep(1.0); + return 0; +} \ No newline at end of file diff --git a/examples/pres_1/bob.c b/examples/pres_1/bob.c new file mode 100644 index 0000000000000000000000000000000000000000..fcc81fb8a3f2971c1e6604c77bf7217721119bb4 --- /dev/null +++ b/examples/pres_1/bob.c @@ -0,0 +1,36 @@ + +#include "../../reowolf.h" +#include "../utility.c" + +int main(int argc, char** argv) { + // Create a connector... + Arc_ProtocolDescription * pd = protocol_description_parse("", 0); + char logpath[] = "./pres_1_bob.txt"; + Connector * c = connector_new_logging(pd, logpath, sizeof(logpath)-1); + printf("Error str `%s`\n", reowolf_error_peek(NULL)); + + // ... with 1 outgoing network connection + PortId p0; + char addr_str[] = "127.0.0.1:8000"; + connector_add_net_port( + c, &p0, addr_str, sizeof(addr_str)-1, Polarity_Putter, EndpointPolarity_Passive); + printf("Error str `%s`\n", reowolf_error_peek(NULL)); + + // Connect (5000ms timeout). Begin communication. + connector_connect(c, 5000); + printf("Error str `%s`\n", reowolf_error_peek(NULL)); + + // Send a single 2-byte message... + connector_put_bytes(c, p0, "hi", 2); + printf("Error str `%s`\n", reowolf_error_peek(NULL)); + + // ... and acknowledge receipt within 1000ms. + connector_sync(c, 1000); + printf("Error str `%s`\n", reowolf_error_peek(NULL)); + + printf("Exiting\n"); + protocol_description_destroy(pd); + connector_destroy(c); + sleep(1.0); + return 0; +} \ No newline at end of file diff --git a/examples/utility.c b/examples/utility.c index ef6ee10ce12c08c53e4b6468aeac99225c09e65b..a43f2b02b6b0acd6a91eb4d8fb60219658e46230 100644 --- a/examples/utility.c +++ b/examples/utility.c @@ -1,6 +1,8 @@ #include #include #include +#include +#include // allocates a buffer! char * buffer_pdl(char * filename) { diff --git a/src/ffi/socket_api.rs b/src/ffi/socket_api.rs index 92a688c54ab2e3e7f64df79f8e36c5d16007745c..d5869c9b181fbd42ec571fa7c149862fdfdd7633 100644 --- a/src/ffi/socket_api.rs +++ b/src/ffi/socket_api.rs @@ -1,5 +1,6 @@ use super::*; use atomic_refcell::AtomicRefCell; +use mio::net::UdpSocket; use std::{collections::HashMap, ffi::c_void, net::SocketAddr, os::raw::c_int, sync::RwLock}; /////////////////////////////////////////////////////////////////// @@ -20,6 +21,7 @@ struct ConnectorStorage { fd_allocator: FdAllocator, } /////////////////////////////////////////////////////////////////// + impl Default for FdAllocator { fn default() -> Self { Self { @@ -49,18 +51,18 @@ lazy_static::lazy_static! { /////////////////////////////////////////////////////////////////// #[no_mangle] -pub extern "C" fn socket(_domain: c_int, _type: c_int) -> c_int { +pub extern "C" fn rw_socket(_domain: c_int, _type: c_int) -> c_int { // assuming _domain is AF_INET and _type is SOCK_DGRAM - let w = if let Some(w) = CONNECTOR_STORAGE.write() { w } else { return FD_LOCK_POISONED }; + let mut w = if let Ok(w) = CONNECTOR_STORAGE.write() { w } else { return FD_LOCK_POISONED }; let fd = w.fd_allocator.alloc(); w.fd_to_connector.insert(fd, AtomicRefCell::new(MaybeConnector::New)); fd } #[no_mangle] -pub extern "C" fn close(fd: ConnectorFd, _how: c_int) -> c_int { +pub extern "C" fn rw_close(fd: ConnectorFd, _how: c_int) -> c_int { // ignoring HOW - let w = if let Some(w) = CONNECTOR_STORAGE.write() { w } else { return FD_LOCK_POISONED }; + let mut w = if let Ok(w) = CONNECTOR_STORAGE.write() { w } else { return FD_LOCK_POISONED }; w.fd_allocator.free(fd); if w.fd_to_connector.remove(&fd).is_some() { ERR_OK @@ -70,40 +72,50 @@ pub extern "C" fn close(fd: ConnectorFd, _how: c_int) -> c_int { } #[no_mangle] -pub extern "C" fn bind(fd: ConnectorFd, address: *const SocketAddr, _address_len: usize) -> c_int { +pub unsafe extern "C" fn rw_bind( + fd: ConnectorFd, + address: *const SocketAddr, + _address_len: usize, +) -> c_int { use MaybeConnector as Mc; // assuming _domain is AF_INET and _type is SOCK_DGRAM - let r = if let Some(r) = CONNECTOR_STORAGE.read() { r } else { return FD_LOCK_POISONED }; + let r = if let Ok(r) = CONNECTOR_STORAGE.read() { r } else { return FD_LOCK_POISONED }; let mc = if let Some(mc) = r.fd_to_connector.get(&fd) { mc } else { return BAD_FD }; - let mc: &mut Mc = &mut maybe_conn.borrow_mut(); + let mc: &mut Mc = &mut mc.borrow_mut(); let _ = if let Mc::New = mc { () } else { return WRONG_STATE }; *mc = Mc::Bound(address.read()); ERR_OK } #[no_mangle] -pub extern "C" fn connect( +pub extern "C" fn rw_connect( fd: ConnectorFd, _address: *const SocketAddr, _address_len: usize, ) -> c_int { use MaybeConnector as Mc; // assuming _domain is AF_INET and _type is SOCK_DGRAM - let r = if let Some(r) = CONNECTOR_STORAGE.read() { r } else { return FD_LOCK_POISONED }; + let r = if let Ok(r) = CONNECTOR_STORAGE.read() { r } else { return FD_LOCK_POISONED }; let mc = if let Some(mc) = r.fd_to_connector.get(&fd) { mc } else { return BAD_FD }; - let mc: &mut Mc = &mut maybe_conn.borrow_mut(); - let local = if let Mc::Bound(local) = mc { local } else { return WRONG_STATE }; + let mc: &mut Mc = &mut mc.borrow_mut(); + let _local = if let Mc::Bound(local) = mc { local } else { return WRONG_STATE }; *mc = Mc::Connected(Connector {}); ERR_OK } #[no_mangle] -pub extern "C" fn send(fd: ConnectorFd, msg: *const c_void, len: usize, flags: c_int) -> isize { +pub extern "C" fn rw_send( + fd: ConnectorFd, + _msg: *const c_void, + _len: usize, + _flags: c_int, +) -> isize { use MaybeConnector as Mc; // assuming _domain is AF_INET and _type is SOCK_DGRAM - let r = if let Some(r) = CONNECTOR_STORAGE.read() { r } else { return FD_LOCK_POISONED }; - let mc = if let Some(mc) = r.fd_to_connector.get(&fd) { mc } else { return BAD_FD }; - let mc: &mut Mc = &mut maybe_conn.borrow_mut(); - let c = if let Mc::Connected(c) = mc { c } else { return WRONG_STATE }; + let r = + if let Ok(r) = CONNECTOR_STORAGE.read() { r } else { return FD_LOCK_POISONED as isize }; + let mc = if let Some(mc) = r.fd_to_connector.get(&fd) { mc } else { return BAD_FD as isize }; + let mc: &mut Mc = &mut mc.borrow_mut(); + let _c = if let Mc::Connected(c) = mc { c } else { return WRONG_STATE as isize }; // TODO - ERR_OK + ERR_OK as isize } diff --git a/src/runtime/communication.rs b/src/runtime/communication.rs index a0c32dd3d83a1c33a769e3a677a9158ccfbb37a3..ef47ff4bc174db53c47c3e8adf49418dd8174aac 100644 --- a/src/runtime/communication.rs +++ b/src/runtime/communication.rs @@ -70,28 +70,37 @@ impl RoundCtxTrait for RoundCtx { } } impl Connector { + fn get_comm_mut(&mut self) -> Option<&mut ConnectorCommunication> { + if let ConnectorPhased::Communication(comm) = &mut self.phased { + Some(comm) + } else { + None + } + } + // pub(crate) fn get_mut_udp_sock(&mut self, index: usize) -> Option<&mut UdpSocket> { + // let sock = &mut self + // .get_comm_mut()? + // .endpoint_manager + // .udp_endpoint_store + // .endpoint_exts + // .get_mut(index)? + // .sock; + // Some(sock) + // } pub fn gotten(&mut self, port: PortId) -> Result<&Payload, GottenError> { use GottenError as Ge; - let Self { phased, .. } = self; - match phased { - ConnectorPhased::Setup { .. } => Err(Ge::NoPreviousRound), - ConnectorPhased::Communication(comm) => match &comm.round_result { - Err(_) => Err(Ge::PreviousSyncFailed), - Ok(None) => Err(Ge::NoPreviousRound), - Ok(Some(round_ok)) => round_ok.gotten.get(&port).ok_or(Ge::PortDidntGet), - }, + let comm = self.get_comm_mut().ok_or(Ge::NoPreviousRound)?; + match &comm.round_result { + Err(_) => Err(Ge::PreviousSyncFailed), + Ok(None) => Err(Ge::NoPreviousRound), + Ok(Some(round_ok)) => round_ok.gotten.get(&port).ok_or(Ge::PortDidntGet), } } pub fn next_batch(&mut self) -> Result { // returns index of new batch - let Self { phased, .. } = self; - match phased { - ConnectorPhased::Setup { .. } => Err(WrongStateError), - ConnectorPhased::Communication(comm) => { - comm.native_batches.push(Default::default()); - Ok(comm.native_batches.len() - 1) - } - } + let comm = self.get_comm_mut().ok_or(WrongStateError)?; + comm.native_batches.push(Default::default()); + Ok(comm.native_batches.len() - 1) } fn port_op_access( &mut self, diff --git a/src/runtime/setup.rs b/src/runtime/setup.rs index 682cc3f09741ed4fa5fc4cd9d7a48dbc87b3be20..35c2f1f5ace3c6f4119793f9400dc2621f9fc173 100644 --- a/src/runtime/setup.rs +++ b/src/runtime/setup.rs @@ -203,6 +203,7 @@ fn new_endpoint_manager( .enumerate() .map(|(index, endpoint_setup)| { let token = TokenTarget::NetEndpoint { index }.into(); + log!(logger, "Net endpoint {} beginning setup with {:?}", index, &endpoint_setup); let todo_endpoint = if let EndpointPolarity::Active = endpoint_setup.endpoint_polarity { let mut stream = TcpStream::connect(endpoint_setup.sock_addr) .expect("mio::TcpStream connect should not fail!");