Shift dual stack support to use two sockets instead of mapped addresses (#160)

* progress dealing with a second recv socket

* wip

* remove unused file

* start changes to two send sockets

* wip

* Make build pass

* Make Discv5::new requires ListenConfig and update `find_node` example

* Remove useless comments

* Remove unnecessary qualification

* Make tests pass

* Make SendHandler uses two sockets

* listen_socket holds two sockets

* Add a test for the case of self-request

* Add tests for running a simple query test

* Add tests for non-contactable nodes

* Tweak listen_sockets

* Checking if loopback address

* No longer need to treat mapped address

* cargo fmt

* Fix doc

* Update README

* Tweak ports to avoid `Address already in use`

* clippy

* fmt

* get tests working without ipv6 - kinda

* Revert "get tests working without ipv6 - kinda"

This reverts commit 31c1b9a.

* Skip some tests if IPv6 is not supported

* Separate `test_self_request` into ipv4 and ipv6.

* Add a comment

* Add `listen_config` to Discv5ConfigBuilder

* Remove `listen_config` from Discv5

* Fix tests and examples

* Fix doc

* cargo fmt

* Fix example

* cargo fmt

* fixes

* update readme

* update readme

* revert query interval to match comments

* Zero out ipv6 extra fields

* fix unused import warns

* better error handling in send addressing comments from @AgeManning

* improve ergonomics for ListenConfig. Not super sure about this one

* give direct access to the ListenConfig

* remove duplicated word in omment

* Document `ListenConfig` functions

Co-authored-by: Age Manning <[email protected]>

* Improve docs for `ListenConfig` functions

Co-authored-by: Age Manning <[email protected]>

* Document `ListenConfig` functions

Co-authored-by: Age Manning <[email protected]>

* Document `ListenConfig` functions

Co-authored-by: Age Manning <[email protected]>

---------

Co-authored-by: ackintosh <[email protected]>
Co-authored-by: Age Manning <[email protected]>

Author: 3 people

Cargo.toml

@@ -45,6 +45,7 @@ tokio = { version = "1.15.0", features = ["full"] }
 rand_xorshift = "0.3.0"
 rand_core = "0.6.3"
 clap = { version = "3.1", features = ["derive"] }
+if-addrs = "0.10.1"
 
 [features]
 libp2p = ["libp2p-core"]

README.md

@@ -38,11 +38,9 @@ A simple example of creating this service is as follows:
 
 ```rust
    use discv5::{enr, enr::{CombinedKey, NodeId}, TokioExecutor, Discv5, Discv5ConfigBuilder};
+   use discv5::socket::ListenConfig;
    use std::net::SocketAddr;
 
-   // listening address and port
-   let listen_addr = "0.0.0.0:9000".parse::<SocketAddr>().unwrap();
-
    // construct a local ENR
    let enr_key = CombinedKey::generate_secp256k1();
    let enr = enr::EnrBuilder::new("v4").build(&enr_key).unwrap();
@@ -54,8 +52,14 @@ A simple example of creating this service is as follows:
        .build()
        .unwrap();
 
+   // configuration for the sockets to listen on
+   let listen_config = ListenConfig::Ipv4 {
+       ip: Ipv4Addr::UNSPECIFIED,
+       port: 9000,
+   };
+
    // default configuration
-   let config = Discv5ConfigBuilder::new().build();
+   let config = Discv5ConfigBuilder::new(listen_config).build();
 
    // construct the discv5 server
    let mut discv5: Discv5 = Discv5::new(enr, enr_key, config).unwrap();
@@ -65,7 +69,7 @@ A simple example of creating this service is as follows:
    // discv5.add_enr(<ENR>)
 
    // start the discv5 server
-   runtime.block_on(discv5.start(listen_addr));
+   runtime.block_on(discv5.start());
 
    // run a find_node query
    runtime.block_on(async {

examples/custom_executor.rs

@@ -9,8 +9,8 @@
 //! $ cargo run --example custom_executor <BASE64ENR>
 //! ```
 
-use discv5::{enr, enr::CombinedKey, Discv5, Discv5ConfigBuilder, Discv5Event};
-use std::net::SocketAddr;
+use discv5::{enr, enr::CombinedKey, Discv5, Discv5ConfigBuilder, Discv5Event, ListenConfig};
+use std::net::Ipv4Addr;
 
 fn main() {
     // allows detailed logging with the RUST_LOG env variable
@@ -22,7 +22,10 @@ fn main() {
         .try_init();
 
     // listening address and port
-    let listen_addr = "0.0.0.0:9000".parse::<SocketAddr>().unwrap();
+    let listen_config = ListenConfig::Ipv4 {
+        ip: Ipv4Addr::UNSPECIFIED,
+        port: 9000,
+    };
 
     let enr_key = CombinedKey::generate_secp256k1();
     // construct a local ENR
@@ -36,7 +39,7 @@ fn main() {
         .unwrap();
 
     // default configuration - uses the current executor
-    let config = Discv5ConfigBuilder::new().build();
+    let config = Discv5ConfigBuilder::new(listen_config).build();
 
     // construct the discv5 server
     let mut discv5: Discv5 = Discv5::new(enr, enr_key, config).unwrap();
@@ -61,7 +64,7 @@ fn main() {
 
     runtime.block_on(async {
         // start the discv5 service
-        discv5.start(listen_addr).await.unwrap();
+        discv5.start().await.unwrap();
         println!("Server started");
 
         // get an event stream

examples/find_nodes.rs

@@ -19,18 +19,17 @@ use clap::Parser;
 use discv5::{
     enr,
     enr::{k256, CombinedKey},
-    Discv5, Discv5ConfigBuilder, Discv5Event,
+    Discv5, Discv5ConfigBuilder, Discv5Event, ListenConfig,
 };
 use std::{
-    net::{Ipv4Addr, Ipv6Addr, SocketAddr},
+    net::{Ipv4Addr, Ipv6Addr},
     time::Duration,
 };
 use tracing::{info, warn};
 
 #[derive(Parser)]
 struct FindNodesArgs {
-    /// Type of socket to bind ['ds', 'ip4', 'ip6']. The dual stack option will enable mapped
-    /// addresses over an IpV6 socket.
+    /// Type of socket to bind ['ds', 'ip4', 'ip6'].
     #[clap(long, default_value_t = SocketKind::Ds)]
     socket_kind: SocketKind,
     /// IpV4 to advertise in the ENR. This is needed so that other IpV4 nodes can connect to us.
@@ -43,6 +42,10 @@ struct FindNodesArgs {
     /// randomly.
     #[clap(long)]
     port: Option<u16>,
+    /// Port to bind for ipv6. If none is provided, a random one in the 9000 - 9999 range will be picked
+    /// randomly.
+    #[clap(long)]
+    port6: Option<u16>,
     /// Use a default test key.
     #[clap(long)]
     use_test_key: bool,
@@ -67,6 +70,12 @@ async fn main() {
     let port = args
         .port
         .unwrap_or_else(|| (rand::random::<u16>() % 1000) + 9000);
+    let port6 = args.port.unwrap_or_else(|| loop {
+        let port6 = (rand::random::<u16>() % 1000) + 9000;
+        if port6 != port {
+            return port6;
+        }
+    });
 
     let enr_key = if args.use_test_key {
         // A fixed key for testing
@@ -93,29 +102,28 @@ async fn main() {
         if let Some(ip6) = args.enr_ip6 {
             // if the given address is the UNSPECIFIED address we want to advertise localhost
             if ip6.is_unspecified() {
-                builder.ip6(Ipv6Addr::LOCALHOST).udp6(port);
+                builder.ip6(Ipv6Addr::LOCALHOST).udp6(port6);
             } else {
-                builder.ip6(ip6).udp6(port);
+                builder.ip6(ip6).udp6(port6);
             }
         }
         builder.build(&enr_key).unwrap()
     };
 
+    // the address to listen on.
+    let listen_config = match args.socket_kind {
+        SocketKind::Ip4 => ListenConfig::new_ipv4(Ipv4Addr::UNSPECIFIED, port),
+        SocketKind::Ip6 => ListenConfig::new_ipv6(Ipv6Addr::UNSPECIFIED, port6),
+        SocketKind::Ds => ListenConfig::default()
+            .with_ipv4(Ipv4Addr::UNSPECIFIED, port)
+            .with_ipv6(Ipv6Addr::UNSPECIFIED, port6),
+    };
+
     // default configuration with packet filtering
-    // let config = Discv5ConfigBuilder::new().enable_packet_filter().build();
+    // let config = Discv5ConfigBuilder::new(listen_config).enable_packet_filter().build();
 
     // default configuration without packet filtering
-    let config = Discv5ConfigBuilder::new()
-        .ip_mode(match args.socket_kind {
-            SocketKind::Ip4 => discv5::IpMode::Ip4,
-            SocketKind::Ip6 => discv5::IpMode::Ip6 {
-                enable_mapped_addresses: false,
-            },
-            SocketKind::Ds => discv5::IpMode::Ip6 {
-                enable_mapped_addresses: true,
-            },
-        })
-        .build();
+    let config = Discv5ConfigBuilder::new(listen_config).build();
 
     info!("Node Id: {}", enr.node_id());
     if args.enr_ip6.is_some() || args.enr_ip4.is_some() {
@@ -127,12 +135,6 @@ async fn main() {
             enr.udp4_socket()
         );
     }
-    // the address to listen on.
-    let bind_addr = match args.socket_kind {
-        SocketKind::Ip4 => Ipv4Addr::UNSPECIFIED.into(),
-        SocketKind::Ip6 | SocketKind::Ds => Ipv6Addr::UNSPECIFIED.into(),
-    };
-    let socket_addr = SocketAddr::new(bind_addr, port);
 
     // construct the discv5 server
     let mut discv5: Discv5 = Discv5::new(enr, enr_key, config).unwrap();
@@ -154,7 +156,7 @@ async fn main() {
     }
 
     // start the discv5 service
-    discv5.start(socket_addr).await.unwrap();
+    discv5.start().await.unwrap();
     let mut event_stream = discv5.event_stream().await.unwrap();
     let check_evs = args.events;
 

examples/request_enr.rs

@@ -13,9 +13,13 @@
 //!
 //! This requires the "libp2p" feature.
 #[cfg(feature = "libp2p")]
-use discv5::{enr, enr::CombinedKey, Discv5, Discv5Config};
+use discv5::Discv5ConfigBuilder;
 #[cfg(feature = "libp2p")]
-use std::net::SocketAddr;
+use discv5::ListenConfig;
+#[cfg(feature = "libp2p")]
+use discv5::{enr, enr::CombinedKey, Discv5};
+#[cfg(feature = "libp2p")]
+use std::net::Ipv4Addr;
 
 #[cfg(not(feature = "libp2p"))]
 fn main() {}
@@ -31,15 +35,18 @@ async fn main() {
         .try_init();
 
     // listening address and port
-    let listen_addr = "0.0.0.0:9000".parse::<SocketAddr>().unwrap();
+    let listen_config = ListenConfig::Ipv4 {
+        ip: Ipv4Addr::UNSPECIFIED,
+        port: 9000,
+    };
 
     // generate a new enr key
     let enr_key = CombinedKey::generate_secp256k1();
     // construct a local ENR
     let enr = enr::EnrBuilder::new("v4").build(&enr_key).unwrap();
 
     // default discv5 configuration
-    let config = Discv5Config::default();
+    let config = Discv5ConfigBuilder::new(listen_config).build();
 
     let multiaddr = std::env::args()
         .nth(1)
@@ -49,7 +56,7 @@ async fn main() {
     let mut discv5: Discv5 = Discv5::new(enr, enr_key, config).unwrap();
 
     // start the discv5 service
-    discv5.start(listen_addr).await.unwrap();
+    discv5.start().await.unwrap();
 
     // search for the ENR
     match discv5.request_enr(multiaddr).await {

examples/simple_server.rs

@@ -10,8 +10,8 @@
 //! $ cargo run --example simple_server -- <ENR-IP> <ENR-PORT> <BASE64ENR>
 //! ```
 
-use discv5::{enr, enr::CombinedKey, Discv5, Discv5Config, Discv5Event};
-use std::net::{Ipv4Addr, SocketAddr};
+use discv5::{enr, enr::CombinedKey, Discv5, Discv5ConfigBuilder, Discv5Event, ListenConfig};
+use std::net::Ipv4Addr;
 
 #[tokio::main]
 async fn main() {
@@ -37,7 +37,10 @@ async fn main() {
     };
 
     // listening address and port
-    let listen_addr = "0.0.0.0:9000".parse::<SocketAddr>().unwrap();
+    let listen_config = ListenConfig::Ipv4 {
+        ip: Ipv4Addr::UNSPECIFIED,
+        port: 9000,
+    };
 
     let enr_key = CombinedKey::generate_secp256k1();
 
@@ -69,7 +72,7 @@ async fn main() {
     }
 
     // default configuration
-    let config = Discv5Config::default();
+    let config = Discv5ConfigBuilder::new(listen_config).build();
 
     // construct the discv5 server
     let mut discv5: Discv5 = Discv5::new(enr, enr_key, config).unwrap();
@@ -93,7 +96,7 @@ async fn main() {
     }
 
     // start the discv5 service
-    discv5.start(listen_addr).await.unwrap();
+    discv5.start().await.unwrap();
     println!("Server started");
 
     // get an event stream

src/config.rs

@@ -1,5 +1,5 @@
 use crate::{
-    ipmode::IpMode, kbucket::MAX_NODES_PER_BUCKET, Enr, Executor, PermitBanList, RateLimiter,
+    kbucket::MAX_NODES_PER_BUCKET, socket::ListenConfig, Enr, Executor, PermitBanList, RateLimiter,
     RateLimiterBuilder,
 };
 ///! A set of configuration parameters to tune the discovery protocol.
@@ -64,10 +64,6 @@ pub struct Discv5Config {
     /// seconds.
     pub ping_interval: Duration,
 
-    /// Configures the type of socket to bind to. This also affects the selection of address to use
-    /// to contact an ENR.
-    pub ip_mode: IpMode,
-
     /// Reports all discovered ENR's when traversing the DHT to the event stream. Default true.
     pub report_discovered_peers: bool,
 
@@ -99,10 +95,18 @@ pub struct Discv5Config {
     /// A custom executor which can spawn the discv5 tasks. This must be a tokio runtime, with
     /// timing support. By default, the executor that created the discv5 struct will be used.
     pub executor: Option<Box<dyn Executor + Send + Sync>>,
+
+    /// Configuration for the sockets to listen on.
+    pub listen_config: ListenConfig,
+}
+
+#[derive(Debug)]
+pub struct Discv5ConfigBuilder {
+    config: Discv5Config,
 }
 
-impl Default for Discv5Config {
-    fn default() -> Self {
+impl Discv5ConfigBuilder {
+    pub fn new(listen_config: ListenConfig) -> Self {
         // This is only applicable if enable_packet_filter is set.
         let filter_rate_limiter = Some(
             RateLimiterBuilder::new()
@@ -113,7 +117,8 @@ impl Default for Discv5Config {
                 .expect("The total rate limit has been specified"),
         );
 
-        Self {
+        // set default values
+        let config = Discv5Config {
             enable_packet_filter: false,
             request_timeout: Duration::from_secs(1),
             vote_duration: Duration::from_secs(30),
@@ -136,21 +141,11 @@ impl Default for Discv5Config {
             filter_max_bans_per_ip: Some(5),
             permit_ban_list: PermitBanList::default(),
             ban_duration: Some(Duration::from_secs(3600)), // 1 hour
-            ip_mode: IpMode::default(),
             executor: None,
-        }
-    }
-}
-
-#[derive(Debug, Default)]
-pub struct Discv5ConfigBuilder {
-    config: Discv5Config,
-}
+            listen_config,
+        };
 
-impl Discv5ConfigBuilder {
-    // set default values
-    pub fn new() -> Self {
-        Discv5ConfigBuilder::default()
+        Discv5ConfigBuilder { config }
     }
 
     /// Whether to enable the incoming packet filter.
@@ -307,13 +302,6 @@ impl Discv5ConfigBuilder {
         self
     }
 
-    /// Configures the type of socket to bind to. This also affects the selection of address to use
-    /// to contact an ENR.
-    pub fn ip_mode(&mut self, ip_mode: IpMode) -> &mut Self {
-        self.config.ip_mode = ip_mode;
-        self
-    }
-
     pub fn build(&mut self) -> Discv5Config {
         // If an executor is not provided, assume a current tokio runtime is running.
         if self.config.executor.is_none() {
@@ -347,6 +335,7 @@ impl std::fmt::Debug for Discv5Config {
             .field("incoming_bucket_limit", &self.incoming_bucket_limit)
             .field("ping_interval", &self.ping_interval)
             .field("ban_duration", &self.ban_duration)
+            .field("listen_config", &self.listen_config)
             .finish()
     }
 }