From f0bbad2db95b00ec429f498fe15f1007bd87da5e Mon Sep 17 00:00:00 2001 From: Alex Auvolat Date: Mon, 19 Feb 2024 10:58:54 +0100 Subject: [networking-fixes] use rpc_public_addr in netapp's HelloMessage --- src/net/netapp.rs | 19 ++++++++++++------- 1 file changed, 12 insertions(+), 7 deletions(-) (limited to 'src/net') diff --git a/src/net/netapp.rs b/src/net/netapp.rs index b1ad9db8..e572dc11 100644 --- a/src/net/netapp.rs +++ b/src/net/netapp.rs @@ -38,6 +38,11 @@ pub(crate) type VersionTag = [u8; 16]; /// Value of the Netapp version used in the version tag pub(crate) const NETAPP_VERSION_TAG: u64 = 0x6e65746170700005; // netapp 0x0005 +/// HelloMessage is sent by the client on a Netapp connection to indicate +/// that they are also a server and ready to recieve incoming connections +/// at the specified address and port. If the client doesn't know their +/// public address, they don't need to specify it and we look at the +/// remote address of the socket is used instead. #[derive(Serialize, Deserialize, Debug)] pub(crate) struct HelloMessage { pub server_addr: Option, @@ -56,9 +61,6 @@ type OnDisconnectHandler = Box; /// NetApp can be used in a stand-alone fashion or together with a peering strategy. /// If using it alone, you will want to set `on_connect` and `on_disconnect` events /// in order to manage information about the current peer list. -/// -/// It is generally not necessary to use NetApp stand-alone, as the provided full mesh -/// and RPS peering strategies take care of the most common use cases. pub struct NetApp { listen_params: ArcSwapOption, @@ -83,7 +85,7 @@ pub struct NetApp { struct ListenParams { listen_addr: SocketAddr, - public_addr: Option, + public_addr: Option, } impl NetApp { @@ -180,7 +182,7 @@ impl NetApp { pub async fn listen( self: Arc, listen_addr: SocketAddr, - public_addr: Option, + public_addr: Option, mut must_exit: watch::Receiver, ) { let listen_params = ListenParams { @@ -396,8 +398,11 @@ impl NetApp { } if let Some(lp) = self.listen_params.load_full() { - let server_addr = lp.public_addr; - let server_port = lp.listen_addr.port(); + let server_addr = lp.public_addr.map(|x| x.ip()); + let server_port = lp + .public_addr + .map(|x| x.port()) + .unwrap_or(lp.listen_addr.port()); let hello_endpoint = self.hello_endpoint.load_full().unwrap(); tokio::spawn(async move { hello_endpoint -- cgit v1.2.3 From b96f84b894684ed43e281a3aa2f391b424414a84 Mon Sep 17 00:00:00 2001 From: Alex Auvolat Date: Mon, 19 Feb 2024 11:24:33 +0100 Subject: [networking-fixes] add option to bind outgoing RPC sockets (fix #638) Thanks to yuka for the original patch. --- src/net/netapp.rs | 26 ++++++++++++++++++++++---- src/net/test.rs | 2 +- 2 files changed, 23 insertions(+), 5 deletions(-) (limited to 'src/net') diff --git a/src/net/netapp.rs b/src/net/netapp.rs index e572dc11..faa51a99 100644 --- a/src/net/netapp.rs +++ b/src/net/netapp.rs @@ -13,7 +13,7 @@ use sodiumoxide::crypto::sign::ed25519; use futures::stream::futures_unordered::FuturesUnordered; use futures::stream::StreamExt; -use tokio::net::{TcpListener, TcpStream}; +use tokio::net::{TcpListener, TcpSocket, TcpStream}; use tokio::select; use tokio::sync::{mpsc, watch}; @@ -62,6 +62,7 @@ type OnDisconnectHandler = Box; /// If using it alone, you will want to set `on_connect` and `on_disconnect` events /// in order to manage information about the current peer list. pub struct NetApp { + bind_outgoing_to: Option, listen_params: ArcSwapOption, /// Version tag, 8 bytes for netapp version, 8 bytes for app version @@ -94,13 +95,19 @@ impl NetApp { /// using `.listen()` /// /// Our Peer ID is the public key associated to the secret key given here. - pub fn new(app_version_tag: u64, netid: auth::Key, privkey: ed25519::SecretKey) -> Arc { + pub fn new( + app_version_tag: u64, + netid: auth::Key, + privkey: ed25519::SecretKey, + bind_outgoing_to: Option, + ) -> Arc { let mut version_tag = [0u8; 16]; version_tag[0..8].copy_from_slice(&u64::to_be_bytes(NETAPP_VERSION_TAG)[..]); version_tag[8..16].copy_from_slice(&u64::to_be_bytes(app_version_tag)[..]); let id = privkey.public_key(); let netapp = Arc::new(Self { + bind_outgoing_to, listen_params: ArcSwapOption::new(None), version_tag, netid, @@ -300,9 +307,20 @@ impl NetApp { return Ok(()); } - let socket = TcpStream::connect(ip).await?; + let stream = match self.bind_outgoing_to { + Some(addr) => { + let socket = if addr.is_ipv4() { + TcpSocket::new_v4()? + } else { + TcpSocket::new_v6()? + }; + socket.bind(SocketAddr::new(addr, 0))?; + socket.connect(ip).await? + } + None => TcpStream::connect(ip).await?, + }; info!("Connected to {}, negotiating handshake...", ip); - ClientConn::init(self, socket, id).await?; + ClientConn::init(self, stream, id).await?; Ok(()) } diff --git a/src/net/test.rs b/src/net/test.rs index c6259752..5a3f236d 100644 --- a/src/net/test.rs +++ b/src/net/test.rs @@ -102,7 +102,7 @@ fn run_netapp( Arc, Arc, ) { - let netapp = NetApp::new(0u64, netid, sk); + let netapp = NetApp::new(0u64, netid, sk, None); let peering = PeeringManager::new(netapp.clone(), bootstrap_peers, None); let peering2 = peering.clone(); -- cgit v1.2.3