Allow withholding the SYN|ACK packet by user code

In certain use cases, it's desirable to not send a SYN|ACK packet
immediately after receiving a SYN -- for example, a TCP proxy that
doesn't want to do so until it's connected to the end destination,
because the outgoing connection might get refused. (Currently, you have
to send a SYN|ACK and then reset the connection afterwards in this
case.)

To fix this, add a simple `synack_paused` flag, controllable by user
code, that withholds SYN|ACK packets in `SynReceived` state until it is
unset.

Author: eeeeeta

src/socket/tcp.rs

@@ -527,6 +527,9 @@ pub struct Socket<'a> {
     /// Used for rate-limiting: No more challenge ACKs will be sent until this instant.
     challenge_ack_timer: Instant,
 
+    /// If this is set, we will not send a SYN|ACK until this is unset.
+    synack_paused: bool,
+
     /// Nagle's Algorithm enabled.
     nagle: bool,
 
@@ -601,6 +604,7 @@ impl<'a> Socket<'a> {
             tsval_generator: None,
             last_remote_tsval: 0,
             congestion_controller: congestion::AnyController::new(),
+            synack_paused: false,
 
             #[cfg(feature = "async")]
             rx_waker: WakerRegistration::new(),
@@ -724,6 +728,15 @@ impl<'a> Socket<'a> {
         self.nagle
     }
 
+    /// Pause sending of SYN|ACK packets.
+    ///
+    /// When this flag is set, the socket will get stuck in `SynReceived` state without sending
+    /// any SYN|ACK packets back, until this flag is unset. This is useful for certain niche TCP
+    /// proxy usecases.
+    pub fn pause_synack(&mut self, pause: bool) {
+        self.synack_paused = pause;
+    }
+
     /// Return the current window field value, including scaling according to RFC 1323.
     ///
     /// Used in internal calculations as well as packet generation.
@@ -2372,6 +2385,10 @@ impl<'a> Socket<'a> {
                 .on_retransmit(cx.now());
         }
 
+        if matches!(self.state, State::SynReceived) && self.synack_paused {
+            return Ok(());
+        }
+
         // Decide whether we're sending a packet.
         if self.seq_to_transmit(cx) {
             // If we have data to transmit and it fits into partner's window, do it.