fix(irtt): honor measurement socket routing settings

src/main.rs

@@ -389,6 +389,7 @@ fn run(settings: &Settings) -> anyhow::Result<()> {
         IrttEngine::new(
             start_time,
             Duration::from_secs_f64(settings.advanced_settings.tick_interval),
+            &settings.network,
             measurement_tx,
             irtt_binding_rx,
         )?

src/measurement/irtt.rs

@@ -19,6 +19,7 @@ use crate::measurement::model::{
     MeasurementEvent, MeasurementLoss, MeasurementObservation, MeasurementStream,
     MeasurementStreamId, OneWayClock, OneWayLatency, ProbeSchedule, SignedDuration,
 };
+use crate::settings::NetworkSettings;
 
 #[derive(Debug, Error)]
 pub enum IrttError {
@@ -91,10 +92,11 @@ impl IrttEngine {
     pub fn new(
         origin: Instant,
         interval: std::time::Duration,
+        settings: &NetworkSettings,
         observation_tx: Sender<MeasurementEvent>,
         binding_rx: Receiver<Vec<IrttBinding>>,
     ) -> Result<(ManagedClientTask, Self), IrttError> {
-        let config = managed_client_config(interval);
+        let config = managed_client_config(interval, settings);
         let (task, handle) = ManagedClient::task(config, Vec::new())?;
 
         Ok((
@@ -368,9 +370,21 @@ impl IrttEngine {
     }
 }
 
-fn managed_client_config(interval: std::time::Duration) -> ManagedClientConfig {
+fn managed_client_config(
+    interval: std::time::Duration,
+    #[allow(unused)] settings: &NetworkSettings,
+) -> ManagedClientConfig {
     ManagedClientConfig {
         client: ClientConfig {
+            socket: irtt_client::SocketConfig {
+                #[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
+                bind_to_device: settings.measurement_bind_device.clone(),
+                #[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
+                mark: settings.measurement_mark,
+                #[cfg(target_os = "freebsd")]
+                fib: settings.measurement_fib,
+                ..Default::default()
+            },
             request: irtt_client::SessionRequest {
                 duration: None,
                 interval,

src/ratecontroller.rs

@@ -491,12 +491,14 @@ impl<S: InterfaceStatsProvider, T: TrafficControlBackend> Ratecontroller<S, T> {
         self.state_dl.deltas = down_deltas;
         self.state_ul.deltas = up_deltas;
 
-        if self.state_dl.deltas.len() < 5 || self.state_ul.deltas.len() < 5 {
+        let minimum = usize::from(self.settings.reflectors.num_reflectors);
+        if self.state_dl.deltas.len() < minimum || self.state_ul.deltas.len() < minimum {
             // trigger reselection
             warn!(
-                "Not enough delta values (D: {}, U: {}, need 5), triggering reselection",
+                "Not enough delta values (D: {}, U: {}, need {}), triggering reselection",
                 self.state_dl.deltas.len(),
-                self.state_ul.deltas.len()
+                self.state_ul.deltas.len(),
+                minimum
             );
             let _ = self.reselect_trigger.try_send(true);
         }