strangers messages small

1 files changed, 35 insertions, 1 deletions

diff --git a/src/transport/identity.rs b/src/transport/identity.rs
index 0b36967..1131a11 100644
--- a/src/transport/identity.rs
+++ b/src/transport/identity.rs
@@ -27,7 +27,7 @@
 //! Addresses and the transports behind them are the paths layer's
 //! (`transport::paths`): the books keep addresses as paths keep them.
 
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 use std::sync::{Arc, Mutex, MutexGuard};
 use std::time::Duration;
 
@@ -112,6 +112,10 @@ struct Shared {
     traffic: Arc<Traffic>,
     // A std mutex: every access is short and never spans an await.
     book: Mutex<Book>,
+    /// Nodes that proved themselves members of our swarm (`Transport::admit`): at the
+    /// addresses they proved themselves at, their messages may be large
+    /// (`transport::Admission`).
+    admitted: Mutex<HashSet<String>>,
 }
 
 /// Who is where, by address.
@@ -258,6 +262,16 @@ impl IdentityTransport {
         let node_id = config.key.id();
         let shared = Arc::new_cyclic(|shared: &std::sync::Weak<Shared>| {
             let gate: std::sync::Weak<dyn Gate> = shared.clone();
+            let admitting = shared.clone();
+            let admission = crate::transport::Admission::new(move |address| {
+                admitting
+                    .upgrade()
+                    .is_some_and(|shared| shared.admits(address))
+            });
+            transport.set_admission(admission.clone());
+            for (_, more) in &config.more {
+                more.set_admission(admission.clone());
+            }
             Shared {
                 paths: Arc::new(Paths::new(
                     std::iter::once((config.scheme, transport))
@@ -273,6 +287,7 @@ impl IdentityTransport {
                 node_id,
                 traffic,
                 book: Mutex::default(),
+                admitted: Mutex::default(),
             }
         });
         Self { shared }
@@ -292,6 +307,17 @@ impl Gate for Shared {
 }
 
 impl Shared {
+    /// Whether the node proven at `address` is admitted (`Transport::admit`).
+    fn admits(&self, address: &str) -> bool {
+        let node = self.lock().at.get(address).map(|(node, _)| node.clone());
+        node.is_some_and(|node| {
+            self.admitted
+                .lock()
+                .unwrap_or_else(|poisoned| poisoned.into_inner())
+                .contains(&node)
+        })
+    }
+
     fn blocks(&self, address: &str, rule: fn(&Firewall, &str) -> bool) -> bool {
         let Some(firewall) = &self.firewall else {
             return false;
@@ -625,6 +651,14 @@ impl Transport for IdentityTransport {
             .min_by_key(|offset| offset.within_ms)
     }
 
+    fn admit(&self, node: &str) {
+        self.shared
+            .admitted
+            .lock()
+            .unwrap_or_else(|poisoned| poisoned.into_inner())
+            .insert(node.to_owned());
+    }
+
     /// The identity layer's, and each transport's.
     fn stats(&self) -> TransportStats {
         let mut stats = self.shared.paths.stats();