Added wrapper type to ed25519_dalek::PublicKey.

src/fleck_core.rs

@@ -1,11 +1,6 @@
 //! This module contains the core services (and channel definitions) that make up a `fleck` node.
 //!
 //! Currently, the following externally-accessible services are added by default:
-//! - [`msg::MessageService`]
-//! - [`node::NodeService`]
-//! - [`discovery::LocalDiscovery`]
-//! - [`peer::PeerService`]
-//! - [`crypto::EncryptionService`]
 
 pub mod crypto;
 pub mod discovery;
@@ -13,6 +8,7 @@ pub mod io;
 pub mod msg;
 pub mod node;
 pub mod peer;
+pub mod routing;
 
 pub use msg::{Message, MessageChannel, MessageParams, MessageService};
 pub use node::{Node, NodeRegistrationChannel, NodeService};
@@ -80,5 +76,7 @@ impl crate::service::DefaultService for CoreInitService {
         api.add_service::<peer::PeerService>();
         api.add_service::<crypto::SignPacket>();
         api.add_service::<crypto::EncryptionService>();
+        api.add_service::<routing::RoutingTableService>();
+        api.add_service::<routing::PacketRoutingService>();
     }
 }

src/fleck_core/crypto.rs

@@ -1,8 +1,10 @@
-use std::{cell::RefCell, collections::HashMap};
+use std::{cell::RefCell, collections::HashMap, rc::Rc};
 
-// use aes_gcm::aes::cipher::BlockEncrypt;
-use aes_gcm::{Aes128Gcm, aead::{KeyInit, Aead}, Nonce};
-pub use ed25519_dalek::{Keypair, PublicKey, Signature, Signer};
+use aes_gcm::{
+    aead::{Aead, KeyInit},
+    Aes128Gcm, Nonce,
+};
+pub use ed25519_dalek::{Keypair, Signature, Signer};
 
 use crate::prelude::*;
 
@@ -25,6 +27,35 @@ pub enum PacketHeader {
     Encrypted(u128),
 }
 
+#[derive(Default, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct PublicKey(ed25519_dalek::PublicKey);
+
+impl PublicKey {
+    pub fn wrap(pkey: ed25519_dalek::PublicKey) -> Self {
+        Self(pkey)
+    }
+}
+
+// *technically* there may be equivalence classes, but we really don't care about those in this
+// context.
+impl Eq for PublicKey {
+    fn assert_receiver_is_total_eq(&self) {}
+}
+
+impl std::hash::Hash for PublicKey {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        state.write(self.0.as_bytes())
+    }
+}
+
+impl std::fmt::Debug for PublicKey {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str("PublicKey {")?;
+        self.0.as_bytes().fmt(f)?;
+        f.write_str("}")
+    }
+}
+
 pub struct SymmetricKey {
     key: [u8; 16],
     nonce: u128,
@@ -60,7 +91,7 @@ impl VerifyPacketSignature {
                 bincode::serialize(&message).expect("assume that we can re-serialize the message");
 
             use ed25519_dalek::Verifier;
-            pubkey.verify(&to_verify, &signature).ok()?;
+            pubkey.0.verify(&to_verify, &signature).ok()?;
             // verification passed!
             Some(message)
         } else {
@@ -145,9 +176,25 @@ impl std::fmt::Debug for KeyExchangeState {
     }
 }
 
+#[derive(Clone)]
+struct EncryptionStateKey(Rc<fleck_core::Node>);
+impl PartialEq for EncryptionStateKey {
+    fn eq(&self, other: &Self) -> bool {
+        Rc::as_ptr(&self.0) == Rc::as_ptr(&other.0)
+    }
+}
+impl Eq for EncryptionStateKey {
+    fn assert_receiver_is_total_eq(&self) {}
+}
+impl std::hash::Hash for EncryptionStateKey {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        Rc::as_ptr(&self.0).hash(state);
+    }
+}
+
 pub struct EncryptionService {
-    api: std::rc::Rc<crate::API>,
-    state: RefCell<HashMap<fleck_core::peer::Peer, KeyExchangeState>>,
+    api: Rc<crate::API>,
+    state: RefCell<HashMap<EncryptionStateKey, KeyExchangeState>>,
 }
 
 impl Service for EncryptionService {
@@ -159,9 +206,13 @@ impl Service for EncryptionService {
     }
 
     fn setup(self: &std::rc::Rc<Self>) {
-        self.api.channel::<fleck_core::SendPacketChannel>()
-            .sub_opt(fleck_core::SendOrder::Encrypt, self, Self::encrypt);
-        self.api.channel::<fleck_core::ReceivePacketChannel>()
+        self.api.channel::<fleck_core::SendPacketChannel>().sub_opt(
+            fleck_core::SendOrder::Encrypt,
+            self,
+            Self::encrypt,
+        );
+        self.api
+            .channel::<fleck_core::ReceivePacketChannel>()
             .sub_opt(fleck_core::ReceiveOrder::Decrypt, self, Self::decrypt);
 
         self.api.with_service(|msg: &fleck_core::MessageService| {
@@ -179,15 +230,15 @@ impl Service for EncryptionService {
 impl EncryptionService {
     fn encrypt(&self, mut packet: fleck_core::Message) -> Option<fleck_core::Message> {
         if !packet.saved_params.unwrap().encrypted {
-            return Some(packet)
+            return Some(packet);
         }
 
         let mut state = self.state.borrow_mut();
-        let mut keyexchange = state.get_mut(packet.peer.as_ref()?)?;
+        let mut keyexchange = state.get_mut(&EncryptionStateKey(packet.node.as_ref().cloned()?))?;
         if let KeyExchangeState::Completed(_, symkey) = &mut keyexchange {
             let cipher = Aes128Gcm::new_from_slice(&symkey.key).expect("key length mismatch?");
-            let nonce_bytes : [u8; 12] = u128::to_be_bytes(symkey.nonce)[0..12].try_into().unwrap();
-            let nonce : Nonce<_> = nonce_bytes.into();
+            let nonce_bytes: [u8; 12] = u128::to_be_bytes(symkey.nonce)[0..12].try_into().unwrap();
+            let nonce: Nonce<_> = nonce_bytes.into();
 
             // serialize+encrypt with the message type so we don't leak that
             let plaintext = bincode::serialize(&packet.content).ok()?;
@@ -200,8 +251,7 @@ impl EncryptionService {
             symkey.nonce += 1;
 
             Some(packet)
-        }
-        else {
+        } else {
             log::info!("Tried to send packet before encryption handshake was finished");
             None
         }
@@ -210,7 +260,7 @@ impl EncryptionService {
     fn decrypt(&self, mut packet: fleck_core::Message) -> Option<fleck_core::Message> {
         // no peer = pass along
         if packet.peer.is_none() {
-            return Some(packet)
+            return Some(packet);
         }
 
         // check for an encryption header
@@ -227,33 +277,38 @@ impl EncryptionService {
 
         // There shouldn't be anything wrong with decrypting a message that claims to be encrypted
         // and is authenticated, right?... TODO: double-check this assertion.
-        if let KeyExchangeState::Completed(_, symkey) = state.get_mut(packet.peer.as_ref()?)? {
+        if let KeyExchangeState::Completed(_, symkey) =
+            state.get_mut(&EncryptionStateKey(packet.node.as_ref().cloned()?))?
+        {
             let cipher = Aes128Gcm::new_from_slice(&symkey.key).expect("key length mismatch?");
-            let nonce_bytes : [u8; 12] = u128::to_be_bytes(nonce)[0..12].try_into().unwrap();
-            let nonce : Nonce<_> = nonce_bytes.into();
+            let nonce_bytes: [u8; 12] = u128::to_be_bytes(nonce)[0..12].try_into().unwrap();
+            let nonce: Nonce<_> = nonce_bytes.into();
 
-            let plaintext = cipher.decrypt(&nonce, packet.content.data.as_slice()).ok()?;
+            let plaintext = cipher
+                .decrypt(&nonce, packet.content.data.as_slice())
+                .ok()?;
             packet.content = bincode::deserialize(&plaintext).ok()?;
 
             packet.crypto_header = PacketHeader::NoCrypto;
 
             Some(packet)
-        }
-        else {
+        } else {
             None
         }
     }
 
     fn new_node(&self, node: &mut std::rc::Rc<fleck_core::node::Node>) {
         // we may want to initiate a handshake, if we're not already doing that...
-        if let Some(peer) = node.peer().as_ref() {
-            if !self.state.borrow().contains_key(peer) {
-                self.begin_handshake(peer)
-            }
+        if !self
+            .state
+            .borrow()
+            .contains_key(&EncryptionStateKey(node.clone()))
+        {
+            self.begin_handshake(node)
         }
     }
 
-    fn begin_handshake(&self, with: &fleck_core::peer::Peer) {
+    fn begin_handshake(&self, with: &Rc<fleck_core::Node>) {
         use rand::SeedableRng;
         let csprng = rand::rngs::StdRng::from_entropy();
         let secret = x25519_dalek::EphemeralSecret::new(csprng);
@@ -263,21 +318,22 @@ impl EncryptionService {
             log::trace!("sending KeyExchange message");
             self.api.queue::<fleck_core::SendPacketChannel>(
                 fleck_core::msg::Message::build(KeyExchange {
-                    pubkey: self.api.with_service(|ns: &fleck_core::NodeService| {
-                        *ns.self_node().pubkey()
-                    }),
+                    pubkey: self
+                        .api
+                        .with_service(|ns: &fleck_core::NodeService| ns.self_node().pubkey().0),
                     key: x25519_dalek::PublicKey::from(&secret),
                 })
-                .with_peer(with.clone()),
+                .with_node(with.clone()),
             );
         };
 
         let mut states = self.state.borrow_mut();
-        let state = states.remove(with).unwrap_or(KeyExchangeState::NoState);
+        let key = EncryptionStateKey(with.clone());
+        let state = states.remove(&key).unwrap_or(KeyExchangeState::NoState);
         match state {
             KeyExchangeState::NoState => {
                 send();
-                states.insert(with.clone(), KeyExchangeState::WaitForResponse(secret));
+                states.insert(key, KeyExchangeState::WaitForResponse(secret));
             },
             KeyExchangeState::Given(pubkey) => {
                 send();
@@ -289,11 +345,11 @@ impl EncryptionService {
                 };
 
                 log::trace!("Completed key negotiation with peer!");
-                states.insert(with.clone(), KeyExchangeState::Completed(pubkey, sk));
+                states.insert(key, KeyExchangeState::Completed(pubkey, sk));
             },
             KeyExchangeState::WaitForResponse(secret) => {
                 send();
-                states.insert(with.clone(), KeyExchangeState::WaitForResponse(secret));
+                states.insert(key, KeyExchangeState::WaitForResponse(secret));
             },
             KeyExchangeState::Completed(_pubkey, _symmetric_key) => {
                 log::warn!("asked to begin handshake when already have a good encryption key --- did the peer die?");
@@ -303,38 +359,49 @@ impl EncryptionService {
 
     fn incoming(&self, msg: (fleck_core::msg::Metadata, KeyExchange)) {
         let mut states = self.state.borrow_mut();
-        let peer = msg
-            .0
-            .peer
-            .expect("incoming KeyExchange should have a peer?");
 
-        let state = states.remove(&peer).unwrap_or(KeyExchangeState::NoState);
+        // cases:
+        // 1. we already know about this node, and have a Node instance for it
+        // 2. we don't know about this node yet, and it has a Peer
+        // 3. we don't know about this node yet, and it has no Peer
+
+        let node = if let Some(node) = msg.0.node {
+            node
+        } else {
+            // exciting! let's tell the node service about it, with all the info we have right now:
+            // the pubkey, and potentially a peer
+
+            self.api.with_service(|ns: &fleck_core::NodeService| {
+                let pk = PublicKey::wrap(msg.1.pubkey);
+                ns.inform_of(pk.clone(), msg.0.peer);
+                ns.node_by_pubkey(&pk)
+                    .expect("we just told the service about this node")
+            })
+        };
+
+        let skey = EncryptionStateKey(node.clone());
+        let state = states.remove(&skey).unwrap_or(KeyExchangeState::NoState);
         log::trace!(
             "incoming key exchange message: {:?}, state: {:?}",
             msg.1,
             &state
         );
 
-        // tell the node service about this peer, just in case they don't know already.
-        self.api.with_service(|ns: &fleck_core::NodeService| {
-            ns.inform_of(msg.1.pubkey, peer.clone());
-        });
-
         match state {
             KeyExchangeState::NoState => {
-                states.insert(peer.clone(), KeyExchangeState::Given(msg.1.key));
+                states.insert(skey.clone(), KeyExchangeState::Given(msg.1.key));
 
                 drop(states);
-                self.begin_handshake(&peer);
+                self.begin_handshake(&node);
             },
             KeyExchangeState::Given(peer_pubkey) => {
                 if peer_pubkey != msg.1.key {
                     log::info!("peer DH key changed!");
-                    states.insert(peer.clone(), KeyExchangeState::Given(msg.1.key));
+                    states.insert(skey.clone(), KeyExchangeState::Given(msg.1.key));
                 }
 
                 drop(states);
-                self.begin_handshake(&peer);
+                self.begin_handshake(&node);
             },
             KeyExchangeState::WaitForResponse(secret) => {
                 // key handshake is finished!
@@ -345,7 +412,7 @@ impl EncryptionService {
                     nonce: u128::from_be_bytes(result.as_bytes()[16..32].try_into().unwrap()),
                 };
 
-                states.insert(peer.clone(), KeyExchangeState::Completed(msg.1.key, sk));
+                states.insert(skey.clone(), KeyExchangeState::Completed(msg.1.key, sk));
                 drop(states);
             },
             KeyExchangeState::Completed(peer_pubkey, _symmetric_key) => {
@@ -354,14 +421,14 @@ impl EncryptionService {
                     return;
                 }
                 // it's a new pubkey, so we want to restart the handshake
-                states.insert(peer.clone(), KeyExchangeState::Given(msg.1.key));
+                states.insert(skey.clone(), KeyExchangeState::Given(msg.1.key));
                 drop(states);
-                self.begin_handshake(&peer);
+                self.begin_handshake(&node);
             },
         }
         log::trace!(
             "after processing incoming key exchange message, state: {:?}",
-            self.state.borrow().get(&peer)
+            self.state.borrow().get(&skey)
         );
     }
 }

src/fleck_core/discovery.rs

@@ -42,9 +42,7 @@ impl DiscoveryService {
 
         // this will automatically ignore self-messages because we already know our own pubkey
         self.api.with_service(|ns: &fleck_core::NodeService| {
-            if ns.node_by_pubkey(&discovery.pkey).is_none() {
-                ns.inform_of(discovery.pkey, msg.0.peer.unwrap());
-            }
+            ns.inform_of(discovery.pkey, msg.0.peer);
         });
     }
 }
@@ -137,7 +135,7 @@ impl PeerDiscovery {
             fleck_core::msg::Message::build(DiscoveryMsg {
                 pkey: self
                     .api
-                    .with_service(|ns: &fleck_core::NodeService| *ns.self_node().pubkey()),
+                    .with_service(|ns: &fleck_core::NodeService| ns.self_node().pubkey().clone()),
                 ttl: 2,
             })
             .with_peer(peer),

src/fleck_core/node.rs

@@ -1,42 +1,16 @@
 use rand::prelude::*;
 
 use std::{
-    cell::{Ref, RefCell},
+    cell::RefCell,
     collections::HashMap,
     rc::{Rc, Weak},
 };
 
+use crate::helper::InnerRef;
 use crate::prelude::*;
 
 use fleck_core::crypto::{Keypair, PublicKey};
 
-pub struct InnerRef<'l, T> {
-    r: Ref<'l, Option<T>>,
-}
-
-impl<'l, T> InnerRef<'l, T> {
-    fn build(from: Ref<'l, Option<T>>) -> Option<Self> {
-        if from.is_none() {
-            None
-        } else {
-            Some(Self { r: from })
-        }
-    }
-}
-
-impl<'l, T> AsRef<T> for InnerRef<'l, T> {
-    fn as_ref(&self) -> &T {
-        self.r.as_ref().unwrap()
-    }
-}
-
-impl<'l, T> std::ops::Deref for InnerRef<'l, T> {
-    type Target = T;
-    fn deref(&self) -> &Self::Target {
-        self.r.as_ref().unwrap()
-    }
-}
-
 #[derive(Debug, Default)]
 pub struct Node {
     pubkey: PublicKey,
@@ -45,10 +19,10 @@ pub struct Node {
 }
 
 impl Node {
-    pub fn build_with_peer(pubkey: PublicKey, peer: fleck_core::peer::Peer) -> Self {
+    pub fn build(pubkey: PublicKey, peer: Option<fleck_core::peer::Peer>) -> Self {
         Self {
             pubkey,
-            peer: Some(peer),
+            peer,
             ..Default::default()
         }
     }
@@ -58,7 +32,7 @@ impl Node {
         let kp = Keypair::generate(&mut csprng);
 
         Self {
-            pubkey: kp.public,
+            pubkey: PublicKey::wrap(kp.public),
             peer: None,
             keypair: RefCell::new(Some(kp)),
         }
@@ -66,7 +40,7 @@ impl Node {
 
     pub fn build_with_keypair(kp: Keypair) -> Self {
         Self {
-            pubkey: kp.public,
+            pubkey: PublicKey::wrap(kp.public),
             peer: None,
             keypair: RefCell::new(Some(kp)),
         }
@@ -87,11 +61,11 @@ impl Node {
 pub struct RegTag {}
 pub type NodeRegistrationChannel = (RegTag, Rc<Node>);
 
+type NodePeerMap = HashMap<fleck_core::Peer, Rc<Node>>;
 pub struct NodeService {
     api: Rc<crate::API>,
-    all_nodes: RefCell<Vec<Rc<Node>>>,
-    // node_by_pubkey: RefCell<HashMap<fleck_core::crypto::PublicKey, Rc<Node>>>,
-    node_by_peer: RefCell<HashMap<fleck_core::Peer, Rc<Node>>>,
+    node_by_pubkey: RefCell<HashMap<fleck_core::crypto::PublicKey, Rc<Node>>>,
+    node_by_peer: RefCell<NodePeerMap>,
     self_node: RefCell<Weak<Node>>,
 }
 
@@ -108,57 +82,38 @@ impl NodeService {
 
         let nself = Rc::new(Node::build_ephemeral());
 
-        self.all_nodes.borrow_mut().push(nself.clone());
+        self.node_by_pubkey
+            .borrow_mut()
+            .insert(nself.pubkey.clone(), nself.clone());
         *self.self_node.borrow_mut() = nself.as_weak();
     }
 
     pub fn node_by_pubkey(&self, pubkey: &PublicKey) -> Option<Rc<Node>> {
-        self.all_nodes
-            .borrow()
-            .iter()
-            .find(|n| n.pubkey() == pubkey)
-            .map(|r| r.to_owned())
+        self.node_by_pubkey.borrow().get(pubkey).cloned()
     }
 
-    // nodes we believe we can communicate with directly
-    pub fn direct_neighbours(&self) -> Vec<Rc<Node>> {
-        self.all_nodes
-            .borrow()
-            .iter()
-            .filter(|n| n.peer.is_some())
-            .map(|r| r.to_owned())
-            .collect()
+    pub fn peers(&self) -> Vec<Rc<Node>> {
+        self.node_by_peer.borrow().values().cloned().collect()
     }
 
-    pub fn inform_of(&self, pubkey: PublicKey, peer: fleck_core::Peer) {
-        // do we know of a node with these properties already?
-        let pref = &peer;
-        log::trace!(
-            "checking to see if we already know of peer: ({:?}, {:?})",
-            pubkey,
-            peer
-        );
-        for node in self.all_nodes.borrow().iter() {
-            log::trace!("\toption: {:?}, {:?}", node.pubkey, node.peer);
-        }
-        if self
-            .all_nodes
-            .borrow()
-            .iter()
-            .filter(|n| n.peer.as_ref() == Some(pref) && n.pubkey == pubkey)
-            .count()
-            != 0
-        {
-            return;
+    pub fn inform_of(&self, pubkey: PublicKey, peer: Option<fleck_core::Peer>) {
+        // do we know of a node with this pubkey already?
+        if let Some(_node) = self.node_by_pubkey(&pubkey) {
+            // yes, we do.
+            // TODO: update node information if have different peer
+        } else {
+            // nope! let's add it.
+            log::trace!("Informed of new node! pubkey: {:?}", &pubkey);
+            let node = Rc::new(Node::build(pubkey.clone(), peer.clone()));
+
+            self.node_by_pubkey
+                .borrow_mut()
+                .insert(pubkey, node.clone());
+            if let Some(peer) = peer {
+                self.node_by_peer.borrow_mut().insert(peer, node.clone());
+            }
+            self.api.channel::<NodeRegistrationChannel>().queue(node);
         }
-
-        // nope, it's a new node
-        log::trace!("Informed of new peer!");
-        let node = Rc::new(Node::build_with_peer(pubkey, peer.clone()));
-
-        self.all_nodes.borrow_mut().push(node.clone());
-        self.node_by_peer.borrow_mut().insert(peer, node.clone());
-        self.api.channel::<NodeRegistrationChannel>().queue(node);
     }
 }
 
@@ -166,8 +121,7 @@ impl Service for NodeService {
     fn new(api: Rc<crate::API>) -> Self {
         Self {
             api,
-            all_nodes: Default::default(),
-            // node_by_pubkey: Default::default(),
+            node_by_pubkey: Default::default(),
             node_by_peer: Default::default(),
             self_node: Default::default(),
         }

src/fleck_core/routing.rs

@@ -0,0 +1,86 @@
+use std::{
+    cell::{Cell, RefCell},
+    collections::{HashMap, HashSet},
+    rc::Rc,
+};
+
+use crate::fleck_core;
+
+use fleck_core::crypto::PublicKey;
+
+pub struct PacketRoutingService {}
+
+impl crate::Service for PacketRoutingService {
+    fn new(api: std::rc::Rc<crate::API>) -> Self {
+        Self {}
+    }
+
+    fn setup(self: &std::rc::Rc<Self>) {}
+}
+
+struct RoutingTableMessage {
+    generation: usize,
+    known: Vec<PublicKey>,
+}
+
+impl fleck_core::msg::MessageParams for RoutingTableMessage {
+    const NAME: &'static str = "RoutingTableMessage";
+    const SIGNED: bool = false;
+    const ENCRYPTED: bool = true;
+}
+
+#[derive(Debug, serde::Serialize, serde::Deserialize)]
+struct RoutingTableRequest {
+    known_generation: Option<usize>,
+}
+
+impl fleck_core::msg::MessageParams for RoutingTableRequest {
+    const NAME: &'static str = "RoutingTableRequest";
+    const SIGNED: bool = false;
+    const ENCRYPTED: bool = true;
+}
+
+pub struct RoutingTableService {
+    api: Rc<crate::API>,
+    table_generation: Cell<usize>,
+    table: RefCell<HashMap<PublicKey, HashSet<fleck_core::peer::Peer>>>,
+}
+
+impl crate::Service for RoutingTableService {
+    fn new(api: std::rc::Rc<crate::API>) -> Self {
+        Self {
+            api,
+            table_generation: Cell::new(0),
+            table: Default::default(),
+        }
+    }
+
+    fn setup(self: &std::rc::Rc<Self>) {
+        self.api
+            .channel::<fleck_core::NodeRegistrationChannel>()
+            .sub_ref(self, Self::new_node);
+        self.api
+            .channel::<fleck_core::MajorTickChannel>()
+            .sub_ref(self, Self::ask_for_updates);
+    }
+}
+
+impl RoutingTableService {
+    fn new_node(&self, node: &mut Rc<fleck_core::Node>) {}
+
+    fn ask_for_updates(&self, _: &mut ()) {
+        // TODO: ask each peer for what their known peers are
+        // FUTURE TODO: stagger these requests at random offsets
+        for node in self
+            .api
+            .with_service(|ns: &fleck_core::NodeService| ns.peers())
+        {
+            self.api
+                .queue::<fleck_core::SendPacketChannel>(fleck_core::msg::Message::build(
+                    RoutingTableRequest {
+                        known_generation: None,
+                    },
+                ));
+        }
+    }
+}

src/helper.rs

@@ -1,4 +1,5 @@
 use std::any::Any;
+use std::cell::Ref;
 
 pub trait AsAny {
     fn as_any(&self) -> &dyn Any;
@@ -37,3 +38,30 @@ impl<'a, T> IntoWeak<T> for &'a std::rc::Weak<T> {
         (*self).clone()
     }
 }
+
+pub struct InnerRef<'l, T> {
+    r: Ref<'l, Option<T>>,
+}
+
+impl<'l, T> InnerRef<'l, T> {
+    pub fn build(from: Ref<'l, Option<T>>) -> Option<Self> {
+        if from.is_none() {
+            None
+        } else {
+            Some(Self { r: from })
+        }
+    }
+}
+
+impl<'l, T> AsRef<T> for InnerRef<'l, T> {
+    fn as_ref(&self) -> &T {
+        self.r.as_ref().unwrap()
+    }
+}
+
+impl<'l, T> std::ops::Deref for InnerRef<'l, T> {
+    type Target = T;
+    fn deref(&self) -> &Self::Target {
+        self.r.as_ref().unwrap()
+    }
+}

src/lib.rs

@@ -5,6 +5,10 @@
 //! event loop, peer identity verification, packet encryption and forwarding, NAT punchthrough,
 //! etc) is handled within the library, in a way that the program need not care about.
 //!
+//! Currently, the following features are implemented:
+//! - Network event loop
+//! - Packet encryption
+//!
 //! ### Library structure
 //! `fleck` is structured with a 'global' [`API`] instance, where any node-wide
 //! global state is stored. The [`API`] instance stores a collection of

src/test/encryption.rs

@@ -2,11 +2,11 @@ use std::{cell::Cell, rc::Rc};
 
 use crate::fleck_core;
 
-const SECRET : u32 = 0x12345678;
+const SECRET: u32 = 0x12345678;
 
 #[derive(Debug, serde::Serialize, serde::Deserialize)]
 struct EncryptedMessage {
-    secret_payload: u32
+    secret_payload: u32,
 }
 
 impl fleck_core::MessageParams for EncryptedMessage {
@@ -22,13 +22,14 @@ struct ReceiveService {
 
 impl crate::DefaultService for ReceiveService {
     fn setup(self: &Rc<Self>, api: Rc<crate::API>) {
-        api.channel::<fleck_core::MessageChannel<EncryptedMessage>>().sub_eat(self, Self::message);
+        api.channel::<fleck_core::MessageChannel<EncryptedMessage>>()
+            .sub_eat(self, Self::message);
     }
 }
 
 impl ReceiveService {
     fn message(&self, msg: (fleck_core::msg::Metadata, EncryptedMessage)) {
-        if msg.1 .secret_payload == SECRET {
+        if msg.1.secret_payload == SECRET {
             self.counter.set(self.counter.get() + 1);
         }
     }
@@ -67,13 +68,24 @@ fn one_way_test() {
     }
 
     // grab f1's node for f2
-    let node_for_f2 = f1.with_service(|ns: &fleck_core::NodeService|
-        ns.node_by_pubkey(&f2.with_service(|ns: &fleck_core::NodeService| *ns.self_node().pubkey()))).expect("handshake failure?");
+    let node_for_f2 = f1
+        .with_service(|ns: &fleck_core::NodeService| {
+            ns.node_by_pubkey(
+                &f2.with_service(|ns: &fleck_core::NodeService| *ns.self_node().pubkey()),
+            )
+        })
+        .expect("handshake failure?");
 
     log::info!("--- test triggering a message to be sent ---");
 
     // trigger f1 to send a packet
-    f1.queue::<fleck_core::SendPacketChannel>(fleck_core::msg::Message::build(EncryptedMessage { secret_payload: SECRET }).with_peer(node_for_f2.peer().unwrap()).with_node(node_for_f2));
+    f1.queue::<fleck_core::SendPacketChannel>(
+        fleck_core::msg::Message::build(EncryptedMessage {
+            secret_payload: SECRET,
+        })
+        .with_peer(node_for_f2.peer().unwrap())
+        .with_node(node_for_f2),
+    );
 
     // let the communication commence...
     for _ in 0..5 {

src/test/mod.rs

@@ -1,5 +1,6 @@
-mod handshake;
 mod encryption;
+mod handshake;
+mod routing;
 
 static TRACING_SETUP_FLAG: std::sync::Mutex<bool> = std::sync::Mutex::new(false);
 
@@ -41,7 +42,9 @@ impl TestSkeleton {
             use crate::fleck_core;
             let fleck = crate::API::new();
 
-            fleck.with_service(|ns: &fleck_core::NodeService| { ns.build_ephemeral_self_node(); });
+            fleck.with_service(|ns: &fleck_core::NodeService| {
+                ns.build_ephemeral_self_node();
+            });
 
             fleck.with_service(|io: &fleck_core::io::IOService| {
                 fleck_core::io::UnixSocketBuilder::default()
@@ -59,17 +62,20 @@ impl TestSkeleton {
                 use crate::fleck_core;
                 let fleck = crate::API::new();
 
-                fleck.with_service(|ns: &fleck_core::NodeService| { ns.build_ephemeral_self_node(); });
+                fleck.with_service(|ns: &fleck_core::NodeService| {
+                    ns.build_ephemeral_self_node();
+                });
 
                 fleck.with_service(|pd: &fleck_core::discovery::PeerDiscovery| {
                     pd.new_peer(
-                        fleck.with_service(|io: &fleck_core::io::IOService| {
-                            fleck_core::io::UnixSocketBuilder::default()
-                                .set_path(self.socket_path().to_str().unwrap())
-                                .connect_mode()
-                                .build(io)
-                        })
-                        .connected_peer(),
+                        fleck
+                            .with_service(|io: &fleck_core::io::IOService| {
+                                fleck_core::io::UnixSocketBuilder::default()
+                                    .set_path(self.socket_path().to_str().unwrap())
+                                    .connect_mode()
+                                    .build(io)
+                            })
+                            .connected_peer(),
                     )
                 });
 

src/test/routing.rs

@@ -0,0 +1,73 @@
+use std::{cell::RefCell, rc::Rc};
+
+use crate::fleck_core;
+
+#[derive(Debug, serde::Serialize, serde::Deserialize)]
+struct RoutedMessage {
+    msg: String,
+}
+
+impl fleck_core::MessageParams for RoutedMessage {
+    const NAME: &'static str = "RoutedMessage";
+    const SIGNED: bool = false;
+    const ENCRYPTED: bool = false;
+}
+
+#[derive(Default)]
+struct ReceiveService {
+    messages: RefCell<Vec<String>>,
+}
+
+impl crate::DefaultService for ReceiveService {
+    fn setup(self: &Rc<Self>, api: Rc<crate::API>) {
+        api.channel::<fleck_core::MessageChannel<RoutedMessage>>()
+            .sub_eat(self, Self::message);
+    }
+}
+
+impl ReceiveService {
+    fn message(&self, msg: (fleck_core::msg::Metadata, RoutedMessage)) {
+        self.messages.borrow_mut().push(msg.1.msg);
+    }
+}
+
+#[test_log::test]
+fn one_way_test() {
+    let skeleton = super::TestSkeleton::new();
+
+    let span_f1 = tracing::span!(tracing::Level::TRACE, "f1");
+    let span_f2 = tracing::span!(tracing::Level::TRACE, "f2");
+    let span_f3 = tracing::span!(tracing::Level::TRACE, "f3");
+
+    let fvec = skeleton.initialize_nodes(2);
+    let f1 = fvec[0].clone();
+    let f2 = fvec[1].clone();
+    let f3 = fvec[2].clone();
+
+    // we explicitly *don't* tell f1 about the message type, because it should never see it anyway
+    f2.with_service(|ms: &fleck_core::MessageService| {
+        ms.add_message_type::<RoutedMessage>();
+    });
+    f3.with_service(|ms: &fleck_core::MessageService| {
+        ms.add_message_type::<RoutedMessage>();
+    });
+
+    f2.add_service::<ReceiveService>();
+    f3.add_service::<ReceiveService>();
+
+    // let the encryption handshake and routing table exchange happen
+    for _ in 0..5 {
+        {
+            let _guard = span_f1.enter();
+            f1.run_once();
+        }
+        {
+            let _guard = span_f2.enter();
+            f2.run_once();
+        }
+        {
+            let _guard = span_f3.enter();
+            f2.run_once();
+        }
+    }
+}