fix(tcp): make some types regading congestion control private

Signed-off-by: Yuuki Takano <ytakanoster@gmail.com>

Author: ytakano

src/iface/interface/tcp.rs

@@ -1,6 +1,6 @@
 use super::*;
 
-use crate::socket::tcp::{congestion_controller::no_control::NoControl, Socket};
+use crate::socket::tcp::Socket;
 
 impl InterfaceInner {
     pub(crate) fn process_tcp<'frame>(
@@ -38,7 +38,7 @@ impl InterfaceInner {
             None
         } else {
             // The packet wasn't handled by a socket, send a TCP RST packet.
-            let (ip, tcp) = tcp::Socket::<NoControl>::rst_reply(&ip_repr, &tcp_repr);
+            let (ip, tcp) = tcp::Socket::rst_reply(&ip_repr, &tcp_repr);
             Some(Packet::new(ip, IpPayload::Tcp(tcp)))
         }
     }

src/socket/tcp.rs

@@ -17,9 +17,9 @@ use crate::wire::{
     TCP_HEADER_LEN,
 };
 
-use self::congestion_controller::CongestionController;
+use self::congestion_controller::{ActiveCC, CongestionController};
 
-pub mod congestion_controller;
+mod congestion_controller;
 
 macro_rules! tcp_trace {
     ($($arg:expr),*) => (net_log!(trace, $($arg),*));
@@ -156,7 +156,7 @@ const RTTE_MAX_RTO: u32 = 10000;
 
 #[derive(Debug, Clone, Copy)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub struct RttEstimator {
+struct RttEstimator {
     // Using u32 instead of Duration to save space (Duration is i64)
     rtt: u32,
     deviation: u32,
@@ -178,14 +178,6 @@ impl Default for RttEstimator {
 }
 
 impl RttEstimator {
-    pub fn get_rtt(&self) -> u32 {
-        self.rtt
-    }
-
-    pub fn get_deviation(&self) -> u32 {
-        self.deviation
-    }
-
     fn retransmission_timeout(&self) -> Duration {
         let margin = RTTE_MIN_MARGIN.max(self.deviation * 4);
         let ms = (self.rtt + margin).clamp(RTTE_MIN_RTO, RTTE_MAX_RTO);
@@ -402,23 +394,14 @@ impl Display for Tuple {
     }
 }
 
-#[cfg(feature = "socket-tcp-cubic")]
-type DefaultCC = congestion_controller::cubic::Cubic;
-
-#[cfg(feature = "socket-tcp-reno")]
-type DefaultCC = congestion_controller::reno::Reno;
-
-#[cfg(not(any(feature = "socket-tcp-cubic", feature = "socket-tcp-reno")))]
-type DefaultCC = congestion_controller::no_control::NoControl;
-
 /// A Transmission Control Protocol socket.
 ///
 /// A TCP socket may passively listen for connections or actively connect to another endpoint.
 /// Note that, for listening sockets, there is no "backlog"; to be able to simultaneously
 /// accept several connections, as many sockets must be allocated, or any new connection
 /// attempts will be reset.
 #[derive(Debug)]
-pub struct Socket<'a, CC: CongestionController = DefaultCC> {
+pub struct Socket<'a> {
     state: State,
     timer: Timer,
     rtte: RttEstimator,
@@ -486,7 +469,7 @@ pub struct Socket<'a, CC: CongestionController = DefaultCC> {
     nagle: bool,
 
     /// The congestion control algorithm.
-    congestion_controller: CC,
+    congestion_controller: ActiveCC,
 
     #[cfg(feature = "async")]
     rx_waker: WakerRegistration,
@@ -496,22 +479,10 @@ pub struct Socket<'a, CC: CongestionController = DefaultCC> {
 
 const DEFAULT_MSS: usize = 536;
 
-impl<'a> Socket<'a, DefaultCC> {
-    /// Create a socket using the given buffers with the default
-    /// congestion controller
-    pub fn new<T>(rx_buffer: T, tx_buffer: T) -> Socket<'a, DefaultCC>
-    where
-        T: Into<SocketBuffer<'a>>,
-    {
-        Socket::new_with_cc(rx_buffer, tx_buffer)
-    }
-}
-
-impl<'a, CC: CongestionController> Socket<'a, CC> {
+impl<'a> Socket<'a> {
     #[allow(unused_comparisons)] // small usize platforms always pass rx_capacity check
     /// Create a socket using the given buffers
-    /// with the `CC` of a congestion controller.
-    pub fn new_with_cc<T>(rx_buffer: T, tx_buffer: T) -> Socket<'a, CC>
+    pub fn new<T>(rx_buffer: T, tx_buffer: T) -> Socket<'a>
     where
         T: Into<SocketBuffer<'a>>,
     {
@@ -558,7 +529,7 @@ impl<'a, CC: CongestionController> Socket<'a, CC> {
             ack_delay_timer: AckDelayTimer::Idle,
             challenge_ack_timer: Instant::from_secs(0),
             nagle: true,
-            congestion_controller: CC::default(),
+            congestion_controller: ActiveCC::default(),
 
             #[cfg(feature = "async")]
             rx_waker: WakerRegistration::new(),
@@ -2436,7 +2407,7 @@ impl<'a, CC: CongestionController> Socket<'a, CC> {
     }
 }
 
-impl<'a, CC: CongestionController> fmt::Write for Socket<'a, CC> {
+impl<'a> fmt::Write for Socket<'a> {
     fn write_str(&mut self, slice: &str) -> fmt::Result {
         let slice = slice.as_bytes();
         if self.send_slice(slice) == Ok(slice.len()) {
@@ -7365,8 +7336,5 @@ mod test {
             r.sample(100);
             assert_eq!(r.retransmission_timeout(), Duration::from_millis(rto));
         }
-
-        r.get_deviation();
-        r.get_rtt();
     }
 }

src/socket/tcp/congestion_controller.rs

@@ -2,10 +2,24 @@ use crate::time::Instant;
 
 use super::RttEstimator;
 
+#[cfg(feature = "socket-tcp-cubic")]
 pub mod cubic;
-pub mod no_control;
+
+#[cfg(feature = "socket-tcp-reno")]
 pub mod reno;
 
+#[cfg(not(any(feature = "socket-tcp-cubic", feature = "socket-tcp-reno")))]
+pub mod no_control;
+
+#[cfg(feature = "socket-tcp-cubic")]
+pub type ActiveCC = cubic::Cubic;
+
+#[cfg(feature = "socket-tcp-reno")]
+pub type ActiveCC = reno::Reno;
+
+#[cfg(not(any(feature = "socket-tcp-cubic", feature = "socket-tcp-reno")))]
+pub type ActiveCC = no_control::NoControl;
+
 pub trait CongestionController: Default {
     /// Returns the number of bytes that can be sent.
     fn window(&self) -> usize;