fix(#18): use ip_echo to get public_ip and shred_version

Fix error re: non-blocking and using from_std on a std TcpListener by setting it non-blocking

In debug mode:

thread 'main' panicked at src/ip_echo.rs:128:32:
Registering a blocking socket with the tokio runtime is unsupported. If you wish to do anyways, please add `--cfg tokio_allow_from_blocking_fd` to your RUSTFLAGS. See github.com/tokio-rs/tokio/issues/7172 for details.

Author: nyetwurk

README.md

@@ -86,6 +86,7 @@ Use `--config <path>` to specify a custom config file location. Default is `conf
 | `keypair_path`           | `keypair.json`            | Path to keypair file        |
 | `listen_ip`              | `0.0.0.0`                 | Local bind/listen IP        |
 | `public_ip`              | Auto (STUN)               | Public IP address           |
+| `enable_stun`            | `false`                   | Use STUN to discover public IP instead of `ip_echo` |
 | `stun_server`            | `stun.l.google.com:3478`  | STUN server address         |
 | `gossip_port`            | `8001`                    | Gossip listen port          |
 | `rpc_port`               | `8899`                    | RPC listen port             |
@@ -110,7 +111,22 @@ See [Solana Cluster Information](https://docs.anza.xyz/clusters/available) for t
   - TCP/UDP port 8001 (gossip) - if you need to be a publicly reachable gossip entrypoint (optional)
   - TCP port 8899 (RPC) - A publicly reachable RPC endpoint is required for validators to accept snapshots from you
 
-**Note**: STUN-based IP detection and UPnP port forwarding are not recommended for production. Use explicit `public_ip` configuration instead, and configure port firewall/forwarding rules manually.
+**Note**: STUN-based IP detection and UPnP port forwarding are not recommended for production.
+Configure port firewall/forwarding rules manually. IP detection will be done via `ip_echo` to each entrypoint by default.
+
+IP resolution preference order:
+1. `public_ip` from user config (if provided)
+2. IP echo result (if `public_ip` not provided)
+3. STUN result (only if IP echo fails and STUN is enabled)
+
+Shred version resolution:
+1. If both configured and discovered versions exist and differ, it's an error
+2. Use whichever version is available (either configured or discovered)
+3. Return None if neither version is available
+
+Note that even when `public_ip` is configured, IP echo is still attempted to get the shred version.
+
+Explicit `public_ip` and `shred_version` configuration is always checked against `ip_echo` results.
 
 ## Known Issues
    - Agave validators refuse to download snapshots from us, even though we are publicly reachable [issue #20](https://github.com/Blockdaemon/agave-snapshot-gossip-client/issues/20)

example-config.toml

@@ -30,9 +30,13 @@
 # Gossip is hardcoded to 0.0.0.0 and can't be changed.
 #listen_ip = "127.0.0.1"
 
-# Optional: Public IP address (default: use STUN)
+# Optional: Public IP address (default: use STUN if enabled, otherwise ip_echo to each entrypoint)
 #public_ip = "1.2.3.4"
 
+# Optional: Enable STUN (default: false)
+# By default, use ip_echo and not STUN
+#enable_stun = true
+
 # Optional: STUN server (default: stun.l.google.com:3478)
 #stun_server = "1.2.3.4:3478"
 

src/config.rs

@@ -4,7 +4,7 @@ use std::str::FromStr;
 
 use dns_lookup::lookup_host;
 use hyper::Uri;
-use log::{error, warn};
+use log::{error, info, warn};
 use serde::Deserialize;
 
 use crate::constants::{
@@ -28,6 +28,7 @@ pub struct Config {
 
     // What public IP to advertise, or how to discover it
     pub public_ip: Option<String>,
+    pub enable_stun: Option<bool>,
     pub stun_server: Option<String>,
 
     // What gossip and RPC ports to listen on and advertise
@@ -65,6 +66,7 @@ pub enum ConfigError {
     InvalidAddress(String),
     DnsLookupError(String),
     ParseError(String),
+    IpEchoError(String),
 }
 
 impl std::error::Error for ConfigError {}
@@ -76,6 +78,7 @@ impl std::fmt::Display for ConfigError {
             ConfigError::InvalidAddress(e) => write!(f, "Invalid address: {}", e),
             ConfigError::DnsLookupError(e) => write!(f, "DNS lookup error: {}", e),
             ConfigError::ParseError(e) => write!(f, "Parse error: {}", e),
+            ConfigError::IpEchoError(e) => write!(f, "IP echo error: {}", e),
         }
     }
 }
@@ -123,19 +126,38 @@ impl Config {
         stun_client.get_public_ip(false).await
     }
 
-    pub async fn resolve(&self) -> Result<ResolvedConfig, ConfigError> {
-        let public_ip = match &self.public_ip {
-            Some(addr) => addr
-                .parse()
-                .map_err(|e| ConfigError::ParseError(format!("Invalid public address: {}", e)))?,
-            None => {
-                warn!("No public_addr in config, attempting to discover...");
-                self.get_external_ip_with_stun()
-                    .await
-                    .map_err(ConfigError::StunError)?
+    pub async fn ip_echo(&self, entrypoints: &[SocketAddr]) -> Result<(IpAddr, u16), ConfigError> {
+        let mut discovered_ip = None;
+        let mut discovered_shred_version = None;
+
+        // Try each entrypoint with IP echo client
+        for entrypoint in entrypoints {
+            let request = crate::ip_echo::IpEchoServerMessage::new(&[], &[]);
+            info!("IP echo request to {}: {:?}", entrypoint, request);
+            if let Ok((ip, shred_version)) =
+                crate::ip_echo::ip_echo_client(*entrypoint, request).await
+            {
+                discovered_ip = Some(ip);
+                discovered_shred_version = Some(shred_version);
+                info!(
+                    "IP echo response from {}: {:?} {:?}",
+                    entrypoint, ip, shred_version
+                );
+                break;
             }
-        };
+        }
+        Ok((
+            discovered_ip.ok_or_else(|| {
+                ConfigError::IpEchoError("Failed to discover public IP through IP echo".into())
+            })?,
+            discovered_shred_version.ok_or_else(|| {
+                ConfigError::IpEchoError("Failed to discover shred version through IP echo".into())
+            })?,
+        ))
+    }
 
+    pub async fn resolve(&self) -> Result<ResolvedConfig, ConfigError> {
+        // Resolve entrypoints first since we need them for both IP echo and final config
         let entrypoints = self
             .entrypoints
             .clone()
@@ -144,6 +166,63 @@ impl Config {
             .map(|addr| Self::parse_addr(&addr, DEFAULT_GOSSIP_PORT))
             .collect::<Result<Vec<_>, _>>()?;
 
+        let (public_ip, discovered_shred_version) = {
+            // First try IP echo to get public ip and shred version at the same time
+            let ip_echo_result = self.ip_echo(&entrypoints).await;
+
+            // If public_ip is configured, use that regardless of IP echo result
+            // If we get ip echo result and user configured a public ip, compare them
+            if let Some(addr) = &self.public_ip {
+                let ip = addr.parse().map_err(|e| {
+                    ConfigError::ParseError(format!("Invalid public address: {}", e))
+                })?;
+                if let Ok((echo_ip, _)) = &ip_echo_result {
+                    if ip != *echo_ip {
+                        error!(
+                            "Configured public IP {} differs from IP echo result {}",
+                            ip, echo_ip
+                        );
+                    }
+                }
+                (ip, ip_echo_result.ok().map(|(_, version)| version))
+            } else {
+                match ip_echo_result {
+                    Ok((ip, shred_version)) => (ip, Some(shred_version)),
+                    Err(e) => {
+                        warn!("IP echo failed: {}", e);
+                        if self.enable_stun.unwrap_or(false) {
+                            (
+                                self.get_external_ip_with_stun()
+                                    .await
+                                    .map_err(ConfigError::StunError)?,
+                                None,
+                            )
+                        } else {
+                            return Err(ConfigError::IpEchoError(
+                                "Failed to discover public IP through IP echo and STUN is disabled"
+                                    .into(),
+                            ));
+                        }
+                    }
+                }
+            }
+        };
+
+        // Validate and resolve shred version:
+        // - Error if both versions exist and differ
+        // - Use whichever version is available
+        // - Return None if neither version is available
+        let shred_version = match (discovered_shred_version, self.shred_version) {
+            (Some(discovered), Some(configured)) if discovered != configured => {
+                return Err(ConfigError::ParseError(format!(
+                    "Shred version mismatch: {} from ip echo, {} from config",
+                    discovered, configured
+                )));
+            }
+            (Some(discovered), _) => Some(discovered),
+            (_, configured) => configured,
+        };
+
         let storage_path = match self.storage_path.as_deref() {
             None => None,
             Some(s) => Some(Uri::from_str(s).map_err(|e| {
@@ -158,7 +237,7 @@ impl Config {
                 .unwrap_or_else(|| DEFAULT_KEYPAIR_PATH.to_string()),
             entrypoints,
             expected_genesis_hash: self.expected_genesis_hash.clone(),
-            shred_version: self.shred_version.clone(),
+            shred_version,
             listen_ip: self
                 .listen_ip
                 .as_ref()
@@ -182,6 +261,7 @@ pub fn load_config(config_path: Option<&str>) -> Config {
                 error!("Failed to parse {}: {}", path, e);
                 std::process::exit(1);
             });
+            config.enable_stun.get_or_insert(false);
             config.enable_upnp.get_or_insert(false);
             config.enable_proxy.get_or_insert(false);
             config
@@ -191,6 +271,7 @@ pub fn load_config(config_path: Option<&str>) -> Config {
             Config {
                 keypair_path: None,
                 entrypoints: None,
+                enable_stun: None,
                 stun_server: None,
                 public_ip: None,
                 enable_upnp: None,

src/ip_echo.rs

@@ -21,7 +21,6 @@ pub struct IpEchoServerMessage {
 }
 
 // IpEchoServerMessage is used by the client to send its port array to the server
-#[allow(dead_code)]
 impl IpEchoServerMessage {
     pub fn new(tcp_ports: &[u16], udp_ports: &[u16]) -> Self {
         let mut request = Self::default();
@@ -44,7 +43,6 @@ pub struct IpEchoServerResponse {
     shred_version: Option<u16>,
 }
 
-#[allow(dead_code)]
 impl IpEchoServerResponse {
     pub fn new(address: IpAddr, shred_version: Option<u16>) -> Self {
         Self {
@@ -123,6 +121,9 @@ pub fn create_ip_echo_server(ip_echo: Option<TcpListener>, shred_version: u16) {
             tcp_listener.local_addr().unwrap()
         );
 
+        // Set non-blocking mode once before cloning
+        tcp_listener.set_nonblocking(true).unwrap();
+
         // Spawn multiple tasks in the existing runtime
         for _ in 0..DEFAULT_IP_ECHO_SERVER_THREADS {
             let tcp_listener = TokioTcpListener::from_std(tcp_listener.try_clone().unwrap())
@@ -145,7 +146,6 @@ pub fn create_ip_echo_server(ip_echo: Option<TcpListener>, shred_version: u16) {
     });
 }
 
-#[allow(dead_code)]
 pub async fn ip_echo_client(
     addr: SocketAddr,
     request: IpEchoServerMessage,
@@ -326,7 +326,9 @@ mod tests {
         create_ip_echo_server(Some(tcp_listener.into_std().unwrap()), shred_version);
 
         // Use our client to connect and get the response
-        let (address, version) = ip_echo_client(server_addr, create_test_request()).await.unwrap();
+        let (address, version) = ip_echo_client(server_addr, create_test_request())
+            .await
+            .unwrap();
 
         // Verify the response
         assert_eq!(address, IpAddr::from([127, 0, 0, 1]));