diff --git a/radicle-node/src/service.rs b/radicle-node/src/service.rs index 8d30990e..479f7113 100644 --- a/radicle-node/src/service.rs +++ b/radicle-node/src/service.rs @@ -9,7 +9,7 @@ use std::collections::hash_map::Entry; use std::collections::{BTreeMap, HashMap, HashSet}; use std::ops::{Deref, DerefMut}; use std::sync::Arc; -use std::{fmt, net, net::IpAddr, str}; +use std::{fmt, net, str}; use crossbeam_channel as chan; use fastrand::Rng; @@ -489,13 +489,12 @@ where } } - pub fn attempted(&mut self, addr: &std::net::SocketAddr) { + pub fn attempted(&mut self, addr: &net::SocketAddr) { let address = Address::from(*addr); - let ip = addr.ip(); let persistent = self.config.is_persistent(&address); let peer = self .sessions - .entry(ip) + .entry(*addr) .or_insert_with(|| Session::new(*addr, Link::Outbound, persistent, self.rng.clone())); peer.attempted(); @@ -510,16 +509,15 @@ where } pub fn connected(&mut self, addr: net::SocketAddr, link: Link) { - let ip = addr.ip(); let address = addr.into(); - debug!("Connected to {} ({:?})", ip, link); + debug!("Connected to {} ({:?})", addr, link); // For outbound connections, we are the first to say "Hello". // For inbound connections, we wait for the remote to say "Hello" first. // TODO: How should we deal with multiple peers connecting from the same IP address? if link.is_outbound() { - if let Some(peer) = self.sessions.get_mut(&ip) { + if let Some(peer) = self.sessions.get_mut(&addr) { if link.is_outbound() { self.reactor.write_all( addr, @@ -535,7 +533,7 @@ where } } else { self.sessions.insert( - ip, + addr, Session::new( addr, Link::Inbound, @@ -548,16 +546,15 @@ where pub fn disconnected( &mut self, - addr: &std::net::SocketAddr, + addr: &net::SocketAddr, reason: &nakamoto::DisconnectReason, ) { let since = self.local_time(); let address = Address::from(*addr); - let ip = addr.ip(); - debug!("Disconnected from {} ({})", ip, reason); + debug!("Disconnected from {} ({})", addr, reason); - if let Some(session) = self.sessions.get_mut(&ip) { + if let Some(session) = self.sessions.get_mut(addr) { session.state = session::State::Disconnected { since }; // Attempt to re-connect to persistent peers. @@ -574,7 +571,7 @@ where // with exponential back-off. debug!( "Reconnecting to {} (attempts={})...", - ip, + addr, session.attempts() ); @@ -583,7 +580,7 @@ where self.reactor.connect(*addr); } else { - self.sessions.remove(&ip); + self.sessions.remove(addr); self.maintain_connections(); } } @@ -769,9 +766,8 @@ where remote: &net::SocketAddr, message: Message, ) -> Result<(), session::Error> { - let peer_ip = remote.ip(); - let Some(peer) = self.sessions.get_mut(&peer_ip) else { - return Err(session::Error::NotFound(remote.ip())); + let Some(peer) = self.sessions.get_mut(remote) else { + return Err(session::Error::NotFound(*remote)); }; peer.last_active = self.clock.local_time(); @@ -826,7 +822,7 @@ where let relay_to = self .sessions .negotiated() - .filter(|(ip, _, _)| **ip != remote.ip()) + .filter(|(addr, _, _)| *addr != remote) .filter(|(_, id, _)| **id != ann.node); self.reactor.relay(ann.clone(), relay_to.map(|(_, _, p)| p)); @@ -1182,7 +1178,7 @@ impl Node { #[derive(Debug)] /// Holds currently (or recently) connected peers. -pub struct Sessions(AddressBook); +pub struct Sessions(AddressBook); impl Sessions { pub fn new(rng: Rng) -> Self { @@ -1194,23 +1190,25 @@ impl Sessions { } /// Iterator over fully negotiated peers. - pub fn negotiated(&self) -> impl Iterator + Clone { + pub fn negotiated( + &self, + ) -> impl Iterator + Clone { self.0 .iter() - .filter_map(move |(ip, sess)| match &sess.state { - session::State::Negotiated { id, .. } => Some((ip, id, sess)), + .filter_map(move |(addr, sess)| match &sess.state { + session::State::Negotiated { id, .. } => Some((addr, id, sess)), _ => None, }) } /// Iterator over mutable fully negotiated peers. - pub fn negotiated_mut(&mut self) -> impl Iterator { + pub fn negotiated_mut(&mut self) -> impl Iterator { self.0.iter_mut().filter(move |(_, p)| p.is_negotiated()) } } impl Deref for Sessions { - type Target = AddressBook; + type Target = AddressBook; fn deref(&self) -> &Self::Target { &self.0 diff --git a/radicle-node/src/service/session.rs b/radicle-node/src/service/session.rs index 62107714..9bc3ecf5 100644 --- a/radicle-node/src/service/session.rs +++ b/radicle-node/src/service/session.rs @@ -44,7 +44,7 @@ pub enum Error { #[error("invalid announcement timestamp: {0}")] InvalidTimestamp(u64), #[error("session not found for address `{0}`")] - NotFound(net::IpAddr), + NotFound(net::SocketAddr), #[error("verification failed on fetch: {0}")] VerificationFailed(#[from] storage::VerifyError), #[error("peer misbehaved")] diff --git a/radicle-node/src/tests.rs b/radicle-node/src/tests.rs index 1dff0dad..686861a8 100644 --- a/radicle-node/src/tests.rs +++ b/radicle-node/src/tests.rs @@ -133,8 +133,8 @@ fn test_outbound_connection() { .map(|(ip, _, _)| *ip) .collect::>(); - assert!(peers.contains(&eve.ip)); - assert!(peers.contains(&bob.ip)); + assert!(peers.contains(&eve.addr())); + assert!(peers.contains(&bob.addr())); } #[test] @@ -153,8 +153,8 @@ fn test_inbound_connection() { .map(|(ip, _, _)| *ip) .collect::>(); - assert!(peers.contains(&eve.ip)); - assert!(peers.contains(&bob.ip)); + assert!(peers.contains(&eve.addr())); + assert!(peers.contains(&bob.addr())); } #[test] @@ -719,8 +719,8 @@ fn test_persistent_peer_reconnect() { .negotiated() .map(|(ip, _, _)| *ip) .collect::>(); - assert!(ips.contains(&bob.ip)); - assert!(ips.contains(&eve.ip)); + assert!(ips.contains(&bob.addr())); + assert!(ips.contains(&eve.addr())); // ... Negotiated ... //