use net utils for binding sockets

bench-streamer/src/main.rs

@@ -3,13 +3,14 @@
 use {
     clap::{crate_description, crate_name, Arg, Command},
     crossbeam_channel::unbounded,
+    solana_net_utils::bind_to,
     solana_streamer::{
         packet::{Packet, PacketBatch, PacketBatchRecycler, PACKET_DATA_SIZE},
         streamer::{receiver, PacketBatchReceiver, StreamerReceiveStats},
     },
     std::{
         cmp::max,
-        net::{IpAddr, Ipv4Addr, SocketAddr, UdpSocket},
+        net::{IpAddr, Ipv4Addr, SocketAddr},
         sync::{
             atomic::{AtomicBool, AtomicUsize, Ordering},
             Arc,
@@ -20,7 +21,7 @@ use {
 };
 
 fn producer(addr: &SocketAddr, exit: Arc<AtomicBool>) -> JoinHandle<()> {
-    let send = UdpSocket::bind("0.0.0.0:0").unwrap();
+    let send = bind_to(IpAddr::V4(Ipv4Addr::UNSPECIFIED), 0, false).unwrap();
     let batch_size = 10;
     let mut packet_batch = PacketBatch::with_capacity(batch_size);
     packet_batch.resize(batch_size, Packet::default());

client/Cargo.toml

@@ -22,6 +22,7 @@ quinn = { workspace = true }
 rayon = { workspace = true }
 solana-connection-cache = { workspace = true }
 solana-measure = { workspace = true }
+solana-net-utils = { workspace = true }
 solana-pubsub-client = { workspace = true }
 solana-quic-client = { workspace = true }
 solana-rpc-client = { workspace = true, features = ["default"] }

client/src/connection_cache.rs

@@ -201,6 +201,7 @@ mod tests {
         super::*,
         crate::connection_cache::ConnectionCache,
         crossbeam_channel::unbounded,
+        solana_net_utils::bind_to,
         solana_sdk::signature::Keypair,
         solana_streamer::{
             quic::{QuicServerParams, SpawnServerResult},
@@ -217,7 +218,7 @@ mod tests {
 
     fn server_args() -> (UdpSocket, Arc<AtomicBool>, Keypair) {
         (
-            UdpSocket::bind("127.0.0.1:0").unwrap(),
+            bind_to(IpAddr::V4(Ipv4Addr::UNSPECIFIED), 0, false).unwrap(),
             Arc::new(AtomicBool::new(false)),
             Keypair::new(),
         )

core/src/banking_simulation.rs

@@ -21,6 +21,7 @@ use {
         blockstore::{Blockstore, PurgeType},
         leader_schedule_cache::LeaderScheduleCache,
     },
+    solana_net_utils::bind_to,
     solana_poh::{
         poh_recorder::{PohRecorder, GRACE_TICKS_FACTOR, MAX_GRACE_SLOTS},
         poh_service::{PohService, DEFAULT_HASHES_PER_BATCH, DEFAULT_PINNED_CPU_CORE},
@@ -46,7 +47,7 @@ use {
         fmt::Display,
         fs::File,
         io::{self, BufRead, BufReader},
-        net::{Ipv4Addr, UdpSocket},
+        net::{IpAddr, Ipv4Addr},
         path::PathBuf,
         sync::{
             atomic::{AtomicBool, Ordering},
@@ -783,7 +784,7 @@ impl BankingSimulator {
         // Broadcast stage is needed to save the simulated blocks for post-run analysis by
         // inserting produced shreds into the blockstore.
         let broadcast_stage = BroadcastStageType::Standard.new_broadcast_stage(
-            vec![UdpSocket::bind((Ipv4Addr::LOCALHOST, 0)).unwrap()],
+            vec![bind_to(IpAddr::V4(Ipv4Addr::LOCALHOST), 0, false).unwrap()],
             cluster_info.clone(),
             entry_receiver,
             retransmit_slots_receiver,

core/src/banking_stage/forwarder.rs

@@ -16,6 +16,7 @@ use {
     solana_connection_cache::client_connection::ClientConnection as TpuConnection,
     solana_feature_set::FeatureSet,
     solana_measure::measure_us,
+    solana_net_utils::bind_to,
     solana_perf::{data_budget::DataBudget, packet::Packet},
     solana_poh::poh_recorder::PohRecorder,
     solana_runtime::bank_forks::BankForks,
@@ -24,7 +25,7 @@ use {
     solana_streamer::sendmmsg::batch_send,
     std::{
         iter::repeat,
-        net::{SocketAddr, UdpSocket},
+        net::{IpAddr, Ipv4Addr, SocketAddr, UdpSocket},
         sync::{atomic::Ordering, Arc, RwLock},
     },
 };
@@ -50,7 +51,7 @@ impl<T: LikeClusterInfo> Forwarder<T> {
         Self {
             poh_recorder,
             bank_forks,
-            socket: UdpSocket::bind("0.0.0.0:0").unwrap(),
+            socket: bind_to(IpAddr::V4(Ipv4Addr::UNSPECIFIED), 0, false).unwrap(),
             cluster_info,
             connection_cache,
             data_budget,

core/src/repair/ancestor_hashes_service.rs

@@ -917,13 +917,17 @@ mod test {
             blockstore::make_many_slot_entries, get_tmp_ledger_path,
             get_tmp_ledger_path_auto_delete, shred::Nonce,
         },
+        solana_net_utils::bind_to,
         solana_runtime::{accounts_background_service::AbsRequestSender, bank_forks::BankForks},
         solana_sdk::{
             hash::Hash,
             signature::{Keypair, Signer},
         },
         solana_streamer::socket::SocketAddrSpace,
-        std::collections::HashMap,
+        std::{
+            collections::HashMap,
+            net::{IpAddr, Ipv4Addr},
+        },
         trees::tr,
     };
 
@@ -1345,7 +1349,8 @@ mod test {
     impl ManageAncestorHashesState {
         fn new(bank_forks: Arc<RwLock<BankForks>>) -> Self {
             let ancestor_hashes_request_statuses = Arc::new(DashMap::new());
-            let ancestor_hashes_request_socket = Arc::new(UdpSocket::bind("0.0.0.0:0").unwrap());
+            let ancestor_hashes_request_socket =
+                Arc::new(bind_to(IpAddr::V4(Ipv4Addr::UNSPECIFIED), 0, false).unwrap());
             let epoch_schedule = bank_forks
                 .read()
                 .unwrap()

core/src/repair/quic_endpoint.rs

@@ -1021,9 +1021,14 @@ mod tests {
         super::*,
         itertools::{izip, multiunzip},
         solana_ledger::genesis_utils::{create_genesis_config, GenesisConfigInfo},
+        solana_net_utils::bind_to,
         solana_runtime::bank::Bank,
         solana_sdk::signature::Signer,
-        std::{iter::repeat_with, net::Ipv4Addr, time::Duration},
+        std::{
+            iter::repeat_with,
+            net::{IpAddr, Ipv4Addr},
+            time::Duration,
+        },
     };
 
     #[test]
@@ -1036,10 +1041,11 @@ mod tests {
             .build()
             .unwrap();
         let keypairs: Vec<Keypair> = repeat_with(Keypair::new).take(NUM_ENDPOINTS).collect();
-        let sockets: Vec<UdpSocket> = repeat_with(|| UdpSocket::bind((Ipv4Addr::LOCALHOST, 0)))
-            .take(NUM_ENDPOINTS)
-            .collect::<Result<_, _>>()
-            .unwrap();
+        let sockets: Vec<UdpSocket> =
+            repeat_with(|| bind_to(IpAddr::V4(Ipv4Addr::LOCALHOST), 0, false))
+                .take(NUM_ENDPOINTS)
+                .collect::<Result<_, _>>()
+                .unwrap();
         let addresses: Vec<SocketAddr> = sockets
             .iter()
             .map(UdpSocket::local_addr)

core/src/repair/repair_service.rs

@@ -1075,13 +1075,17 @@ mod test {
             get_tmp_ledger_path_auto_delete,
             shred::max_ticks_per_n_shreds,
         },
+        solana_net_utils::bind_to,
         solana_runtime::bank::Bank,
         solana_sdk::{
             signature::{Keypair, Signer},
             timing::timestamp,
         },
         solana_streamer::socket::SocketAddrSpace,
-        std::collections::HashSet,
+        std::{
+            collections::HashSet,
+            net::{IpAddr, Ipv4Addr},
+        },
     };
 
     fn new_test_cluster_info() -> ClusterInfo {
@@ -1097,9 +1101,9 @@ mod test {
         let pubkey = cluster_info.id();
         let slot = 100;
         let shred_index = 50;
-        let reader = UdpSocket::bind("127.0.0.1:0").expect("bind");
+        let reader = bind_to(IpAddr::V4(Ipv4Addr::LOCALHOST), 0, false).expect("bind");
         let address = reader.local_addr().unwrap();
-        let sender = UdpSocket::bind("127.0.0.1:0").expect("bind");
+        let sender = bind_to(IpAddr::V4(Ipv4Addr::LOCALHOST), 0, false).expect("bind");
         let outstanding_repair_requests = Arc::new(RwLock::new(OutstandingShredRepairs::default()));
 
         // Send a repair request
@@ -1452,7 +1456,7 @@ mod test {
         );
         let mut duplicate_slot_repair_statuses = HashMap::new();
         let dead_slot = 9;
-        let receive_socket = &UdpSocket::bind("0.0.0.0:0").unwrap();
+        let receive_socket = &bind_to(IpAddr::V4(Ipv4Addr::UNSPECIFIED), 0, false).unwrap();
         let duplicate_status = DuplicateSlotRepairStatus {
             correct_ancestor_to_repair: (dead_slot, Hash::default()),
             start_ts: u64::MAX,
@@ -1481,7 +1485,7 @@ mod test {
             &blockstore,
             &serve_repair,
             &mut RepairStats::default(),
-            &UdpSocket::bind("0.0.0.0:0").unwrap(),
+            &bind_to(IpAddr::V4(Ipv4Addr::UNSPECIFIED), 0, false).unwrap(),
             &None,
             &RwLock::new(OutstandingRequests::default()),
             &identity_keypair,
@@ -1507,7 +1511,7 @@ mod test {
             &blockstore,
             &serve_repair,
             &mut RepairStats::default(),
-            &UdpSocket::bind("0.0.0.0:0").unwrap(),
+            &bind_to(IpAddr::V4(Ipv4Addr::UNSPECIFIED), 0, false).unwrap(),
             &None,
             &RwLock::new(OutstandingRequests::default()),
             &identity_keypair,
@@ -1526,7 +1530,7 @@ mod test {
             &blockstore,
             &serve_repair,
             &mut RepairStats::default(),
-            &UdpSocket::bind("0.0.0.0:0").unwrap(),
+            &bind_to(IpAddr::V4(Ipv4Addr::UNSPECIFIED), 0, false).unwrap(),
             &None,
             &RwLock::new(OutstandingRequests::default()),
             &identity_keypair,
@@ -1541,7 +1545,10 @@ mod test {
         let bank_forks = BankForks::new_rw_arc(bank);
         let dummy_addr = Some((
             Pubkey::default(),
-            UdpSocket::bind("0.0.0.0:0").unwrap().local_addr().unwrap(),
+            bind_to(IpAddr::V4(Ipv4Addr::UNSPECIFIED), 0, false)
+                .unwrap()
+                .local_addr()
+                .unwrap(),
         ));
         let cluster_info = Arc::new(new_test_cluster_info());
         let serve_repair = ServeRepair::new(

dos/src/main.rs

@@ -56,6 +56,7 @@ use {
         gossip_service::{discover, get_client},
     },
     solana_measure::measure::Measure,
+    solana_net_utils::bind_to,
     solana_rpc_client::rpc_client::RpcClient,
     solana_sdk::{
         hash::Hash,
@@ -73,7 +74,7 @@ use {
     solana_tps_client::TpsClient,
     solana_tpu_client::tpu_client::DEFAULT_TPU_CONNECTION_POOL_SIZE,
     std::{
-        net::{SocketAddr, UdpSocket},
+        net::{IpAddr, Ipv4Addr, SocketAddr},
         process::exit,
         sync::Arc,
         thread,
@@ -725,7 +726,7 @@ fn run_dos<T: 'static + TpsClient + Send + Sync>(
             _ => panic!("Unsupported data_type detected"),
         };
 
-        let socket = UdpSocket::bind("0.0.0.0:0").unwrap();
+        let socket = bind_to(IpAddr::V4(Ipv4Addr::UNSPECIFIED), 0, false).unwrap();
         let mut last_log = Instant::now();
         let mut total_count: usize = 0;
         let mut count: usize = 0;