Allow binding to port 0 for OS-assigned ports

Add support for configuring listening addresses with port 0, letting
the OS pick a free port. After binding, the actual port is resolved
via local_addr() and stored in two new fields on Node:

- active_listening_addresses: set on start(), cleared on stop()
- last_bound_addresses: set on start(), preserved across restarts
  so the node rebinds the same ports (important for peer reconnection
  with persisted addresses)

The listening_addresses() and announcement_addresses() getters return
the active addresses when running, last bound when stopped, and fall
back to configured addresses if the node was never started. The gossip
broadcast task also prefers active addresses over config.

This eliminates the need for the deterministic port picker in tests,
which was fragile due to potential port collisions. Tests now use
127.0.0.1:0 and query the actual port after start().

AI tools were used in preparing this commit.

Author: joostjager

src/builder.rs

@@ -1988,6 +1988,8 @@ fn build_with_store_internal(
 		peer_store,
 		payment_store,
 		lnurl_auth,
+		active_listening_addresses: Arc::new(RwLock::new(None)),
+		last_bound_addresses: Arc::new(RwLock::new(None)),
 		is_running,
 		node_metrics,
 		om_mailbox,

src/lib.rs

@@ -234,6 +234,11 @@ pub struct Node {
 	peer_store: Arc<PeerStore<Arc<Logger>>>,
 	payment_store: Arc<PaymentStore>,
 	lnurl_auth: Arc<LnurlAuth>,
+	/// Addresses the node is actively listening on. Set on `start()`, cleared on `stop()`.
+	active_listening_addresses: Arc<RwLock<Option<Vec<SocketAddress>>>>,
+	/// Addresses resolved from the last successful bind, used to rebind the same ports on
+	/// restart when the configured addresses contain port 0.
+	last_bound_addresses: Arc<RwLock<Option<Vec<SocketAddress>>>>,
 	is_running: Arc<RwLock<bool>>,
 	node_metrics: Arc<RwLock<NodeMetrics>>,
 	om_mailbox: Option<Arc<OnionMessageMailbox>>,
@@ -356,7 +361,14 @@ impl Node {
 			);
 		}
 
-		if let Some(listening_addresses) = &self.config.listening_addresses {
+		let effective_listening_addresses = self
+			.last_bound_addresses
+			.read()
+			.unwrap()
+			.clone()
+			.or_else(|| self.config.listening_addresses.clone());
+
+		if let Some(listening_addresses) = &effective_listening_addresses {
 			// Setup networking
 			let peer_manager_connection_handler = Arc::clone(&self.peer_manager);
 			let listening_logger = Arc::clone(&self.logger);
@@ -403,6 +415,36 @@ impl Node {
 				Ok(listeners)
 			})?;
 
+			// Store the actual bound addresses (resolving port 0 to real ports).
+			let mut bound_addrs = Vec::with_capacity(listeners.len());
+			for listener in &listeners {
+				let local_addr = listener.local_addr().map_err(|e| {
+					log_error!(
+						self.logger,
+						"Failed to retrieve local address from listener: {}",
+						e
+					);
+					Error::InvalidSocketAddress
+				})?;
+				let socket_address = match local_addr {
+					std::net::SocketAddr::V4(a) => {
+						SocketAddress::TcpIpV4 { addr: a.ip().octets(), port: a.port() }
+					},
+					std::net::SocketAddr::V6(a) => {
+						SocketAddress::TcpIpV6 { addr: a.ip().octets(), port: a.port() }
+					},
+				};
+				bound_addrs.push(socket_address);
+			}
+
+			log_info!(
+				self.logger,
+				"Listening on {}",
+				bound_addrs.iter().map(|a| a.to_string()).collect::<Vec<_>>().join(", ")
+			);
+			*self.active_listening_addresses.write().unwrap() = Some(bound_addrs.clone());
+			*self.last_bound_addresses.write().unwrap() = Some(bound_addrs);
+
 			for listener in listeners {
 				let logger = Arc::clone(&listening_logger);
 				let peer_mgr = Arc::clone(&peer_manager_connection_handler);
@@ -478,6 +520,7 @@ impl Node {
 		let bcast_store = Arc::clone(&self.kv_store);
 		let bcast_logger = Arc::clone(&self.logger);
 		let bcast_node_metrics = Arc::clone(&self.node_metrics);
+		let bcast_active_addrs = Arc::clone(&self.active_listening_addresses);
 		let mut stop_bcast = self.stop_sender.subscribe();
 		let node_alias = self.config.node_alias.clone();
 		if may_announce_channel(&self.config).is_ok() {
@@ -525,6 +568,8 @@ impl Node {
 
 							let addresses = if let Some(announcement_addresses) = bcast_config.announcement_addresses.clone() {
 								announcement_addresses
+							} else if let Some(bound_addrs) = bcast_active_addrs.read().unwrap().clone() {
+								bound_addrs
 							} else if let Some(listening_addresses) = bcast_config.listening_addresses.clone() {
 								listening_addresses
 							} else {
@@ -740,6 +785,7 @@ impl Node {
 		#[cfg(tokio_unstable)]
 		self.runtime.log_metrics();
 
+		*self.active_listening_addresses.write().unwrap() = None;
 		log_info!(self.logger, "Shutdown complete.");
 		*is_running_lock = false;
 		Ok(())
@@ -842,16 +888,22 @@ impl Node {
 	}
 
 	/// Returns our own listening addresses.
+	///
+	/// If the node has been started, this returns the actual bound addresses (which may differ
+	/// from the configured addresses if port 0 was used). Otherwise, this returns the configured
+	/// addresses.
 	pub fn listening_addresses(&self) -> Option<Vec<SocketAddress>> {
-		self.config.listening_addresses.clone()
+		self.active_listening_addresses
+			.read()
+			.unwrap()
+			.clone()
+			.or_else(|| self.last_bound_addresses.read().unwrap().clone())
+			.or_else(|| self.config.listening_addresses.clone())
 	}
 
 	/// Returns the addresses that the node will announce to the network.
 	pub fn announcement_addresses(&self) -> Option<Vec<SocketAddress>> {
-		self.config
-			.announcement_addresses
-			.clone()
-			.or_else(|| self.config.listening_addresses.clone())
+		self.config.announcement_addresses.clone().or_else(|| self.listening_addresses())
 	}
 
 	/// Returns our node alias.

tests/common/mod.rs

@@ -14,7 +14,6 @@ use std::collections::{HashMap, HashSet};
 use std::env;
 use std::future::Future;
 use std::path::PathBuf;
-use std::sync::atomic::{AtomicU16, Ordering};
 use std::sync::{Arc, RwLock};
 use std::time::Duration;
 
@@ -269,16 +268,6 @@ pub(crate) fn random_storage_path() -> PathBuf {
 	temp_path
 }
 
-static NEXT_PORT: AtomicU16 = AtomicU16::new(20000);
-
-pub(crate) fn generate_listening_addresses() -> Vec<SocketAddress> {
-	let port = NEXT_PORT.fetch_add(2, Ordering::Relaxed);
-	vec![
-		SocketAddress::TcpIpV4 { addr: [127, 0, 0, 1], port },
-		SocketAddress::TcpIpV4 { addr: [127, 0, 0, 1], port: port + 1 },
-	]
-}
-
 pub(crate) fn random_node_alias() -> Option<NodeAlias> {
 	let mut rng = rng();
 	let rand_val = rng.random_range(0..1000);
@@ -302,7 +291,7 @@ pub(crate) fn random_config(anchor_channels: bool) -> TestConfig {
 	println!("Setting random LDK storage dir: {}", rand_dir.display());
 	node_config.storage_dir_path = rand_dir.to_str().unwrap().to_owned();
 
-	let listening_addresses = generate_listening_addresses();
+	let listening_addresses = vec![SocketAddress::TcpIpV4 { addr: [127, 0, 0, 1], port: 0 }];
 	println!("Setting LDK listening addresses: {:?}", listening_addresses);
 	node_config.listening_addresses = Some(listening_addresses);
 

tests/integration_tests_rust.rs

@@ -21,10 +21,10 @@ use common::{
 	expect_channel_pending_event, expect_channel_ready_event, expect_channel_ready_events,
 	expect_event, expect_payment_claimable_event, expect_payment_received_event,
 	expect_payment_successful_event, expect_splice_pending_event, generate_blocks_and_wait,
-	generate_listening_addresses, open_channel, open_channel_push_amt, open_channel_with_all,
-	premine_and_distribute_funds, premine_blocks, prepare_rbf, random_chain_source, random_config,
-	setup_bitcoind_and_electrsd, setup_builder, setup_node, setup_two_nodes, splice_in_with_all,
-	wait_for_tx, TestChainSource, TestStoreType, TestSyncStore,
+	open_channel, open_channel_push_amt, open_channel_with_all, premine_and_distribute_funds,
+	premine_blocks, prepare_rbf, random_chain_source, random_config, setup_bitcoind_and_electrsd,
+	setup_builder, setup_node, setup_two_nodes, splice_in_with_all, wait_for_tx, TestChainSource,
+	TestStoreType, TestSyncStore,
 };
 use electrsd::corepc_node::Node as BitcoinD;
 use electrsd::ElectrsD;
@@ -37,6 +37,7 @@ use ldk_node::payment::{
 };
 use ldk_node::{Builder, Event, NodeError};
 use lightning::ln::channelmanager::PaymentId;
+use lightning::ln::msgs::SocketAddress;
 use lightning::routing::gossip::{NodeAlias, NodeId};
 use lightning::routing::router::RouteParametersConfig;
 use lightning_invoice::{Bolt11InvoiceDescription, Description};
@@ -1431,9 +1432,11 @@ async fn test_node_announcement_propagation() {
 	node_a_alias_bytes[..node_a_alias_string.as_bytes().len()]
 		.copy_from_slice(node_a_alias_string.as_bytes());
 	let node_a_node_alias = Some(NodeAlias(node_a_alias_bytes));
-	let node_a_announcement_addresses = generate_listening_addresses();
+	let node_a_announcement_addresses = vec![
+		SocketAddress::TcpIpV4 { addr: [127, 0, 0, 1], port: 10001 },
+		SocketAddress::TcpIpV4 { addr: [127, 0, 0, 1], port: 10002 },
+	];
 	config_a.node_config.node_alias = node_a_node_alias.clone();
-	config_a.node_config.listening_addresses = Some(generate_listening_addresses());
 	config_a.node_config.announcement_addresses = Some(node_a_announcement_addresses.clone());
 
 	// Node B will only use listening addresses
@@ -1443,9 +1446,7 @@ async fn test_node_announcement_propagation() {
 	node_b_alias_bytes[..node_b_alias_string.as_bytes().len()]
 		.copy_from_slice(node_b_alias_string.as_bytes());
 	let node_b_node_alias = Some(NodeAlias(node_b_alias_bytes));
-	let node_b_listening_addresses = generate_listening_addresses();
 	config_b.node_config.node_alias = node_b_node_alias.clone();
-	config_b.node_config.listening_addresses = Some(node_b_listening_addresses.clone());
 	config_b.node_config.announcement_addresses = None;
 
 	let node_a = setup_node(&chain_source, config_a);
@@ -1505,6 +1506,7 @@ async fn test_node_announcement_propagation() {
 	#[cfg(feature = "uniffi")]
 	assert_eq!(node_b_announcement_info.alias, node_b_alias_string);
 
+	let node_b_listening_addresses = node_b.listening_addresses().unwrap();
 	#[cfg(not(feature = "uniffi"))]
 	assert_eq!(node_b_announcement_info.addresses(), &node_b_listening_addresses);
 	#[cfg(feature = "uniffi")]