CSY/reowolf Changeset - c9b0aaff86e5 · Centrum Wiskunde & Informatica (CWI)

Changeset - c9b0aaff86e5

Parent rev.

Child rev.

[Not reviewed]

0 2 0

Christopher Esterhuyse - 5 years ago 2020-07-23 16:40:33
christopher.esterhuyse@gmail.com

fixed from cargo check on linux

2 files changed with 20 insertions and 17 deletions:

Cargo.toml

src/ffi/pseudo_socket_api.rs

0 comments (0 inline, 0 general)

Cargo.toml

➞

Show inline comments

 # 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 }
 os_socketaddr = { version = "0.1.0", 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"]
+default = ["ffi", "session_optimization", "ffi_pseudo_socket_api"]
 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
@@ \ No newline at end of file @@

src/ffi/pseudo_socket_api.rs

➞

Show inline comments

 use super::*;
 use libc::{sockaddr, socklen_t};
 use core::ops::DerefMut;
 use std::{collections::HashMap, ffi::c_void, net::SocketAddr, os::raw::c_int, sync::RwLock};
 ///////////////////////////////////////////////////////////////////
 struct FdAllocator {
     next: Option<c_int>,
     freed: Vec<c_int>,
+}
 enum ConnectorComplexPhased {
     Setup { local: Option<SocketAddr>, peer: Option<SocketAddr> },
     Communication { putter: PortId, getter: PortId },
+}
 struct ConnectorComplex {
     connector: Connector,
     phased: ConnectorComplexPhased,
+}
 #[derive(Default)]
 struct CcMap {
     fd_to_cc: HashMap<c_int, RwLock<ConnectorComplex>>,
     fd_allocator: FdAllocator,
+}
 ///////////////////////////////////////////////////////////////////
 unsafe fn payload_from_raw(bytes_ptr: *const c_void, bytes_len: usize) -> Payload {
     let bytes_ptr = std::mem::transmute(bytes_ptr);
     let bytes = &*slice_from_raw_parts(bytes_ptr, bytes_len);
@@ @@ -40,154 +41,156 @@ impl Default for FdAllocator { @@
+}
 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 CC_MAP: RwLock<CcMap> = Default::default();
+}
 impl ConnectorComplex {
     fn try_become_connected(&mut self) {
         match self.phased {
             ConnectorComplexPhased::Setup { local: Some(local), peer: Some(peer) } => {
                 // complete setup
-                let [putter, getter] = connector.new_udp_mediator_component(*local, *peer).unwrap();
+                let [putter, getter] = self.connector.new_udp_mediator_component(local, peer).unwrap();
                 self.connector.connect(None).unwrap();
                 self.phased = ConnectorComplexPhased::Communication { putter, getter }
+            }
             _ => {} // setup incomplete
+        }
+    }
+}
 /////////////////////////////////
 #[no_mangle]
 pub extern "C" fn rw_socket(_domain: c_int, _type: c_int) -> c_int {
     // ignoring domain and type
     // get writer lock
     let mut w = if let Ok(w) = CC_MAP.write() { w } else { return LOCK_POISONED };
     let fd = w.fd_allocator.alloc();
     let cc = ConnectorComplex {
         connector: Connector::new(
             Box::new(crate::DummyLogger),
             crate::TRIVIAL_PD.clone(),
             Connector::random_id(),
         ),
         phased: ConnectorComplexPhased::Setup { local: None, peer: 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
     // get writer lock
     let mut w = if let Ok(w) = CC_MAP.write() { w } else { return 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 {
     // 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,
     };
     // 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.write() { cc } else { return LOCK_POISONED };
     match &cc.phased {
+    match &mut cc.phased {
         ConnectorComplexPhased::Communication { .. } => WRONG_STATE,
         ConnectorComplexPhased::Setup { local, .. } => {
             *local = Some(addr);
             cc.try_become_connected();
             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 libc_to_std_sockaddr(addr, addr_len) {
         Some(addr) => addr,
         _ => return 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.write() { cc } else { return LOCK_POISONED };
     match &cc.phased {
         ConnectorComplex::Communication { .. } => WRONG_STATE,
         ConnectorComplex::Setup { peer, .. } => {
     match &mut cc.phased {
         ConnectorComplexPhased::Communication { .. } => WRONG_STATE,
         ConnectorComplexPhased::Setup { peer, .. } => {
             *peer = Some(addr);
             cc.try_become_connected();
             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
     // 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.write() { cc } else { return LOCK_POISONED as isize };
     match &cc.phased {
         ConnectorComplex::Setup { .. } => WRONG_STATE as isize,
         ConnectorComplex::Communication { connector, putter, .. } => {
     let ConnectorComplex { connector, phased } = cc.deref_mut();
     match phased {
         ConnectorComplexPhased::Setup { .. } => WRONG_STATE as isize,
         ConnectorComplexPhased::Communication { putter, .. } => {
             let payload = payload_from_raw(bytes_ptr, bytes_len);
             cc.connector.put(*putter, payload).unwrap();
             cc.connector.sync(None).unwrap();
             connector.put(*putter, payload).unwrap();
             connector.sync(None).unwrap();
             bytes_len as isize
+        }
+    }
+}
 #[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
     // 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.write() { cc } else { return LOCK_POISONED as isize };
     match &cc.phased {
         ConnectorComplex::Setup { .. } => WRONG_STATE as isize,
         ConnectorComplex::Communication { connector, getter, .. } => {
             cc.connector.get(*getter).unwrap();
             cc.connector.sync(None).unwrap();
             let slice = cc.connector.gotten(*getter).unwrap().as_slice();
     let ConnectorComplex { connector, phased } = cc.deref_mut();
     match phased {
         ConnectorComplexPhased::Setup { .. } => WRONG_STATE as isize,
         ConnectorComplexPhased::Communication { getter, .. } => {
             connector.get(*getter).unwrap();
             connector.sync(None).unwrap();
             let slice = connector.gotten(*getter).unwrap().as_slice();
             if !bytes_ptr.is_null() {
                 let cpy_msg_bytes = slice.len().min(bytes_len);
                 std::ptr::copy_nonoverlapping(slice.as_ptr(), bytes_ptr as *mut u8, cpy_msg_bytes);
+            }
             slice.len() as isize
+        }
+    }
+}

0 comments (0 inline, 0 general)