Track actual bound listening addresses in Node

Fix a TOCTOU race condition in integration tests where randomly
allocated ports were released before Node::start() re-bound them,
causing sporadic InvalidSocketAddress failures in CI.

Node now stores the actual addresses returned by TcpListener::bind()
and exposes them via listening_addresses(), which returns None when the
node is not running. Tests use port 0 to let the OS assign ports at
bind time, eliminating the race entirely.

AI tools were used in preparing this commit.

Author: joostjager

src/builder.rs

@@ -1994,6 +1994,7 @@ fn build_with_store_internal(
 		payment_store,
 		lnurl_auth,
 		is_running,
+		actual_listening_addresses: Arc::new(RwLock::new(None)),
 		node_metrics,
 		om_mailbox,
 		async_payments_role,

src/lib.rs

@@ -235,6 +235,7 @@ pub struct Node {
 	payment_store: Arc<PaymentStore>,
 	lnurl_auth: Arc<LnurlAuth>,
 	is_running: Arc<RwLock<bool>>,
+	actual_listening_addresses: Arc<RwLock<Option<Vec<SocketAddress>>>>,
 	node_metrics: Arc<RwLock<NodeMetrics>>,
 	om_mailbox: Option<Arc<OnionMessageMailbox>>,
 	async_payments_role: Option<AsyncPaymentsRole>,
@@ -403,6 +404,12 @@ impl Node {
 				Ok(listeners)
 			})?;
 
+			let actual_addrs: Vec<SocketAddress> = listeners
+				.iter()
+				.map(|l| l.local_addr().expect("listener must have local addr").into())
+				.collect();
+			*self.actual_listening_addresses.write().unwrap() = Some(actual_addrs);
+
 			for listener in listeners {
 				let logger = Arc::clone(&listening_logger);
 				let peer_mgr = Arc::clone(&peer_manager_connection_handler);
@@ -478,6 +485,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_actual_listening_addresses = Arc::clone(&self.actual_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,7 +533,7 @@ impl Node {
 
 							let addresses = if let Some(announcement_addresses) = bcast_config.announcement_addresses.clone() {
 								announcement_addresses
-							} else if let Some(listening_addresses) = bcast_config.listening_addresses.clone() {
+							} else if let Some(listening_addresses) = bcast_actual_listening_addresses.read().unwrap().clone() {
 								listening_addresses
 							} else {
 								debug_assert!(false, "We checked whether the node may announce, so listening addresses should always be set");
@@ -740,6 +748,8 @@ impl Node {
 		#[cfg(tokio_unstable)]
 		self.runtime.log_metrics();
 
+		*self.actual_listening_addresses.write().unwrap() = None;
+
 		log_info!(self.logger, "Shutdown complete.");
 		*is_running_lock = false;
 		Ok(())
@@ -842,16 +852,17 @@ impl Node {
 	}
 
 	/// Returns our own listening addresses.
+	///
+	/// Returns the addresses that the node is actually bound to, which may differ
+	/// from the configured addresses (e.g., when port 0 was configured to let the
+	/// OS assign a port). Returns `None` if the node is not running.
 	pub fn listening_addresses(&self) -> Option<Vec<SocketAddress>> {
-		self.config.listening_addresses.clone()
+		self.actual_listening_addresses.read().unwrap().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

@@ -269,16 +269,10 @@ pub(crate) fn random_storage_path() -> PathBuf {
 }
 
 pub(crate) fn random_listening_addresses() -> Vec<SocketAddress> {
-	let num_addresses = 2;
-	let mut listening_addresses = HashSet::new();
-
-	while listening_addresses.len() < num_addresses {
-		let socket = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
-		let address: SocketAddress = socket.local_addr().unwrap().into();
-		listening_addresses.insert(address);
-	}
-
-	listening_addresses.into_iter().collect()
+	vec![
+		SocketAddress::TcpIpV4 { addr: [127, 0, 0, 1], port: 0 },
+		SocketAddress::TcpIpV4 { addr: [127, 0, 0, 1], port: 0 },
+	]
 }
 
 pub(crate) fn random_node_alias() -> Option<NodeAlias> {