fix: Fall back to IPv4 sockets if IPv6 is unavailable

Also fix broadcasting of UDP messages which before would abort on a send
failure instead of just dumping the message to all known addresses. Now
only debug logs and only errors if all sends failed.

Author: rustybee42

mgmtd/src/bee_msg.rs

@@ -196,8 +196,8 @@ pub async fn notify_nodes<M: Msg + Serializable>(
 ) {
     log::trace!("NOTIFICATION to {node_types:?}: {msg:?}");
 
-    if let Err(err) = async {
-        for t in node_types {
+    for t in node_types {
+        if let Err(err) = async {
             let nodes = ctx
                 .db
                 .read_tx(move |tx| db::node::get_with_type(tx, *t))
@@ -206,12 +206,12 @@ pub async fn notify_nodes<M: Msg + Serializable>(
             ctx.conn
                 .broadcast_datagram(nodes.into_iter().map(|e| e.uid), msg)
                 .await?;
-        }
 
-        Ok(()) as Result<_>
-    }
-    .await
-    {
-        log::error!("Notification could not be sent to all nodes: {err:#}");
+            Ok(()) as Result<_>
+        }
+        .await
+        {
+            log::error!("Notification could not be sent to all {t} nodes: {err:#}");
+        }
     }
 }

mgmtd/src/grpc.rs

@@ -16,7 +16,7 @@ use sqlite::{TransactionExt, check_affected_rows};
 use sqlite_check::sql;
 use std::fmt::Debug;
 use std::future::Future;
-use std::net::SocketAddr;
+use std::net::{SocketAddr, TcpListener};
 use std::pin::Pin;
 use tonic::transport::{Identity, Server, ServerTlsConfig};
 use tonic::{Code, Request, Response, Status};
@@ -181,13 +181,12 @@ pub(crate) fn serve(ctx: Context, mut shutdown: RunStateHandle) -> Result<()> {
         builder
     };
 
-    let serve_addr = SocketAddr::new("::".parse()?, ctx.info.user_config.grpc_port);
-
+    let ctx2 = ctx.clone();
     let service = pm::management_server::ManagementServer::with_interceptor(
         ManagementService { ctx: ctx.clone() },
         move |req: Request<()>| {
             // If authentication is enabled, require the secret passed with every request
-            if let Some(required_secret) = ctx.info.auth_secret {
+            if let Some(required_secret) = ctx2.info.auth_secret {
                 let check = || -> Result<()> {
                     let Some(request_secret) = req.metadata().get("auth-secret") else {
                         bail!("Request requires authentication but no secret was provided")
@@ -211,6 +210,14 @@ pub(crate) fn serve(ctx: Context, mut shutdown: RunStateHandle) -> Result<()> {
         },
     );
 
+    let mut serve_addr = SocketAddr::new("::".parse()?, ctx.info.user_config.grpc_port);
+
+    // Test for IPv6 available
+    if TcpListener::bind(serve_addr).is_err() {
+        log::debug!("gRPC: IPv6 not available, falling back to IPv4 sockets");
+        serve_addr = SocketAddr::new("0.0.0.0".parse()?, ctx.info.user_config.grpc_port);
+    }
+
     log::info!("Serving gRPC requests on {serve_addr}");
 
     tokio::spawn(async move {

mgmtd/src/lib.rs

@@ -27,7 +27,7 @@ use sqlite::TransactionExt;
 use sqlite_check::sql;
 use std::collections::HashSet;
 use std::future::Future;
-use std::net::SocketAddr;
+use std::net::{SocketAddr, TcpListener};
 use std::sync::Arc;
 use tokio::net::UdpSocket;
 use tokio::sync::mpsc;
@@ -60,14 +60,16 @@ pub async fn start(info: StaticInfo, license: LicenseVerifier) -> Result<RunCont
     // Static configuration which doesn't change at runtime
     let info = Box::leak(Box::new(info));
 
+    let mut beemsg_serve_addr = SocketAddr::new("::".parse()?, info.user_config.beemsg_port);
+
+    // Test for IPv6 available, fall back to IPv4 sockets if not
+    if TcpListener::bind(beemsg_serve_addr).is_err() {
+        log::debug!("BeeMsg: IPv6 not available, falling back to IPv4 sockets");
+        beemsg_serve_addr = SocketAddr::new("0.0.0.0".parse()?, info.user_config.beemsg_port);
+    }
+
     // UDP socket for in- and outgoing messages
-    let udp_socket = Arc::new(
-        UdpSocket::bind(SocketAddr::new(
-            "::0".parse()?,
-            info.user_config.beemsg_port,
-        ))
-        .await?,
-    );
+    let udp_socket = Arc::new(UdpSocket::bind(beemsg_serve_addr).await?);
 
     // Node address store and connection pool
     let conn_pool = Pool::new(
@@ -121,8 +123,9 @@ pub async fn start(info: StaticInfo, license: LicenseVerifier) -> Result<RunCont
     );
 
     // Listen for incoming TCP connections
+    // Fall back to ipv4 socket if ipv6 is not available
     incoming::listen_tcp(
-        SocketAddr::new("::0".parse()?, ctx.info.user_config.beemsg_port),
+        beemsg_serve_addr,
         ctx.clone(),
         info.auth_secret.is_some(),
         run_state.clone(),

shared/src/conn/outgoing.rs

@@ -194,12 +194,21 @@ impl Pool {
         buf.serialize_msg(msg)?;
 
         for node_uid in peers {
-            let Some(addrs) = self.store.get_node_addrs(node_uid) else {
-                bail!("No network address found for node with uid {node_uid:?}");
-            };
+            let addrs = self.store.get_node_addrs(node_uid).unwrap_or_default();
 
+            let mut sent = false;
             for addr in addrs.iter() {
-                buf.send_to_socket(&self.udp_socket, addr).await?;
+                if let Err(err) = buf.send_to_socket(&self.udp_socket, addr).await {
+                    log::debug!("Sending datagram to {addr} failed: {err}");
+                    continue;
+                }
+                sent = true;
+            }
+
+            if !sent {
+                log::error!(
+                    "Failed to send datagram to node with uid {node_uid}: Sending failed for all known addresses"
+                );
             }
         }