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

Changeset - 70e2e44574a6

Parent rev.

Child rev.

[Not reviewed]

0 3 0

Christopher Esterhuyse - 5 years ago 2020-07-24 09:11:36
christopher.esterhuyse@gmail.com

added minor util + doc comments to connector API

3 files changed with 18 insertions and 7 deletions:

Cargo.toml

src/ffi/pseudo_socket_api.rs

src/runtime/mod.rs

0 comments (0 inline, 0 general)

Cargo.toml

➞

Show inline comments

@@ @@ -38,11 +38,11 @@ lazy_static = "1.4.0" @@
 [lib]
 # compile target: dynamically linked library using C ABI
 crate-type = ["cdylib"]
 [features]
-default = ["ffi", "session_optimization", "ffi_pseudo_socket_api"]
 default = ["ffi", "session_optimization"]
 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 libc::{sockaddr, socklen_t};
 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 {
     // invariant: .connector.phased and .phased are variants Setup/Communication in lockstep.
     connector: Connector,
     phased: ConnectorComplexPhased,
+}
 #[derive(Default)]
 struct CcMap {
     fd_to_cc: HashMap<c_int, RwLock<ConnectorComplex>>,
+}
 unsafe fn libc_to_std_sockaddr(addr: *const sockaddr, addr_len: socklen_t) -> Option<SocketAddr> {
     os_socketaddr::OsSocketAddr::from_raw_parts(addr as _, addr_len as usize).into_addr()
+}
 impl Default for FdAllocator {
     fn default() -> Self {
         Self {
             next: Some(0), // positive values used only
             freed: vec![],
+        }
         // negative FDs aren't used s.t. they are available for error signalling
         Self { next: Some(0), freed: vec![] }
+    }
+}
 impl FdAllocator {
     fn alloc(&mut self) -> c_int {
         if let Some(fd) = self.freed.pop() {
             return fd;
@@ @@ -59,13 +58,14 @@ lazy_static::lazy_static! { @@
+}
 impl ConnectorComplex {
     fn try_become_connected(&mut self) {
         match self.phased {
             ConnectorComplexPhased::Setup { local: Some(local), peer: Some(peer) } => {
                 // complete setup
                 let [putter, getter] = self.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
+        }
+    }

src/runtime/mod.rs

➞

Show inline comments

@@ @@ -376,12 +376,23 @@ impl IdManager { @@
 impl Drop for Connector {
     fn drop(&mut self) {
         log!(&mut *self.unphased.inner.logger, "Connector dropping. Goodbye!");
+    }
+}
 impl Connector {
     pub fn is_connected(&self) -> bool {
         // If designed for Rust usage, connectors would be exposed as an enum type from the start.
         // consequently, this "phased" business would also include connector variants and this would
         // get a lot closer to the connector impl. itself.
         // Instead, the C-oriented implementation doesn't distinguish connector states as types,
         // and distinguish them as enum variants instead
         match self.phased {
             ConnectorPhased::Setup(..) => false,
             ConnectorPhased::Communication(..) => true,
+        }
+    }
     pub(crate) fn random_id() -> ConnectorId {
         type Bytes8 = [u8; std::mem::size_of::<ConnectorId>()];
         unsafe {
             let mut bytes = std::mem::MaybeUninit::<Bytes8>::uninit();
             // getrandom is the canonical crate for a small, secure rng
             getrandom::getrandom(&mut *bytes.as_mut_ptr()).unwrap();

0 comments (0 inline, 0 general)