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 a new bound_listening_addresses field.

The listening_addresses() and announcement_addresses() getters now
return the resolved bound addresses when the node is running, falling
back to the configured addresses when stopped. The gossip broadcast
task also prefers resolved addresses.

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,7 @@ fn build_with_store_internal(
 		peer_store,
 		payment_store,
 		lnurl_auth,
+		bound_listening_addresses: Arc::new(RwLock::new(None)),
 		is_running,
 		node_metrics,
 		om_mailbox,

src/lib.rs

@@ -234,6 +234,7 @@ pub struct Node {
 	peer_store: Arc<PeerStore<Arc<Logger>>>,
 	payment_store: Arc<PaymentStore>,
 	lnurl_auth: Arc<LnurlAuth>,
+	bound_listening_addresses: Arc<RwLock<Option<Vec<SocketAddress>>>>,
 	is_running: Arc<RwLock<bool>>,
 	node_metrics: Arc<RwLock<NodeMetrics>>,
 	om_mailbox: Option<Arc<OnionMessageMailbox>>,
@@ -403,6 +404,35 @@ 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.bound_listening_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 +508,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_bound_addrs = Arc::clone(&self.bound_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 +556,8 @@ impl Node {
 
 							let addresses = if let Some(announcement_addresses) = bcast_config.announcement_addresses.clone() {
 								announcement_addresses
+							} else if let Some(bound_addrs) = bcast_bound_addrs.read().unwrap().clone() {
+								bound_addrs
 							} else if let Some(listening_addresses) = bcast_config.listening_addresses.clone() {
 								listening_addresses
 							} else {
@@ -740,6 +773,7 @@ impl Node {
 		#[cfg(tokio_unstable)]
 		self.runtime.log_metrics();
 
+		*self.bound_listening_addresses.write().unwrap() = None;
 		log_info!(self.logger, "Shutdown complete.");
 		*is_running_lock = false;
 		Ok(())
@@ -842,16 +876,21 @@ impl Node {
 	}
 
 	/// Returns our own listening addresses.
+	///
+	/// When the node is running, this returns the actual bound addresses (which may differ from
+	/// the configured addresses if port 0 was used). When the node is not running, this returns
+	/// the configured addresses.
 	pub fn listening_addresses(&self) -> Option<Vec<SocketAddress>> {
-		self.config.listening_addresses.clone()
+		self.bound_listening_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")]