Ticket #13629: 2.tcp-slow-start-rfc5681-updated-rules-for-congestion-window.patch

src/add-ons/kernel/network/protocols/tcp/TCPEndpoint.cpp

@@ -18 +18 @@
 #include <signal.h>
 #include <stdlib.h>
 #include <string.h>
+#include <stdint.h>
 
 #include <KernelExport.h>
 #include <Select.h>
@@ -427 +428 @@
     fSendWindow(0),
     fSendMaxWindow(0),
     fSendMaxSegmentSize(TCP_DEFAULT_MAX_SEGMENT_SIZE),
+    fSendMaxSegments(0),
     fSendQueue(socket->send.buffer_size),
     fInitialSendSequence(0),
     fDuplicateAcknowledgeCount(0),
@@ -1392 +1394 @@
             fFlags &= ~FLAG_OPTION_TIMESTAMP;
     }
 
-    fCongestionWindow = 2 * fSendMaxSegmentSize;
+    if (fSendMaxSegmentSize > 2190)
+        fCongestionWindow = 2 * fSendMaxSegmentSize;
+    else if (fSendMaxSegmentSize > 1095)
+        fCongestionWindow = 3 * fSendMaxSegmentSize;
+    else
+        fCongestionWindow = 4 * fSendMaxSegmentSize;
+
+    fSendMaxSegments = fCongestionWindow / fSendMaxSegmentSize;
     fSlowStartThreshold = (uint32)segment.advertised_window << fSendWindowShift;
 }
 
@@ -1897 +1906 @@
 TCPEndpoint::_ShouldSendSegment(tcp_segment_header& segment, uint32 length,
     uint32 segmentMaxSize, uint32 flightSize)
 {
+    if(fSendMaxSegments == 0)
+        return false;
+
     if (length > 0) {
         // Avoid the silly window syndrome - we only send a segment in case:
         // - we have a full segment to send, or
@@ -2033 +2045 @@
     bool retransmit = fSendNext < fSendMax;
 
     do {
-        uint32 segmentMaxSize = fSendMaxSegmentSize
-            - tcp_options_length(segment);
-        uint32 segmentLength = min_c(length, segmentMaxSize);
+        uint32 segmentLength = min_c(length, fSendMaxSegmentSize);
 
         if (fSendNext + segmentLength == fSendQueue.LastSequence()) {
             if (state_needs_finish(fState))
@@ -2046 +2056 @@
 
         // Determine if we should really send this segment
         if (!force && !retransmit && !_ShouldSendSegment(segment, segmentLength,
-                segmentMaxSize, flightSize)) {
+                fSendMaxSegmentSize, flightSize)) {
             if (fSendQueue.Available()
                 && !gStackModule->is_timer_active(&fPersistTimer)
                 && !gStackModule->is_timer_active(&fRetransmitTimer))
@@ -2114 +2124 @@
         fReceiveMaxAdvertised = fReceiveNext
             + ((uint32)segment.advertised_window << fReceiveWindowShift);
 
+        if (segmentLength !=0 && fState == ESTABLISHED)
+            fSendMaxSegments -= 1;
+
         status = next->module->send_routed_data(next, fRoute, buffer);
         if (status < B_OK) {
             gBufferModule->free(buffer);
@@ -2207 +2220 @@
 
     if (fSendUnacknowledged < segment.acknowledge) {
         fSendQueue.RemoveUntil(segment.acknowledge);
+
+        // the acknowledgment of the SYN/ACK MUST NOT increase the size of the congestion window
+        if (fSendUnacknowledged != fInitialSendSequence) {
+            if (fCongestionWindow < fSlowStartThreshold)
+                fCongestionWindow += min_c(segment.acknowledge - fSendUnacknowledged.Number(), 
+                    fSendMaxSegmentSize);
+            else {
+                uint32 increment = fSendMaxSegmentSize * fSendMaxSegmentSize;
+
+                if (increment < fCongestionWindow)
+                    increment = 1;
+                else
+                    increment /= fCongestionWindow;
+
+                fCongestionWindow += increment;
+            }
+
+            fSendMaxSegments = UINT32_MAX;
+        }
+
         fSendUnacknowledged = segment.acknowledge;
         if (fSendNext < fSendUnacknowledged)
             fSendNext = fSendUnacknowledged;
@@ -2236 +2269 @@
             fSendCondition.NotifyAll();
             gSocketModule->notify(socket, B_SELECT_WRITE, fSendQueue.Free());
         }
-
-        if (fCongestionWindow < fSlowStartThreshold)
-            fCongestionWindow += fSendMaxSegmentSize;
-    }
-
-    if (fCongestionWindow >= fSlowStartThreshold) {
-        uint32 increment = fSendMaxSegmentSize * fSendMaxSegmentSize;
-
-        if (increment < fCongestionWindow)
-            increment = 1;
-        else
-            increment /= fCongestionWindow;
-
-        fCongestionWindow += increment;
     }
 
     // if there is data left to be sent, send it now
@@ -2261 +2280 @@
 void
 TCPEndpoint::_Retransmit()
 {
-    TRACE("Retransmit()");
+    if (fState < ESTABLISHED) {
+        fRetransmitTimeout = TCP_SYN_RETRANSMIT_TIMEOUT;
+        fCongestionWindow = fSendMaxSegmentSize;
+    } else {
+        TRACE("Retransmit()");
 
-    _ResetSlowStart();
-    fSendNext = fSendUnacknowledged;
+        _ResetSlowStart();
+        fSendNext = fSendUnacknowledged;
 
-    // Do exponential back off of the retransmit timeout
-    fRetransmitTimeout *= 2;
-    if (fRetransmitTimeout > TCP_MAX_RETRANSMIT_TIMEOUT)
-        fRetransmitTimeout = TCP_MAX_RETRANSMIT_TIMEOUT;
+        // Do exponential back off of the retransmit timeout
+        fRetransmitTimeout *= 2;
+        if (fRetransmitTimeout > TCP_MAX_RETRANSMIT_TIMEOUT)
+            fRetransmitTimeout = TCP_MAX_RETRANSMIT_TIMEOUT;
 
-    _SendQueued();
+        _SendQueued();
+    }
 }
 
 

src/add-ons/kernel/network/protocols/tcp/TCPEndpoint.h

@@ -145 +145 @@
     uint32          fSendWindow;
     uint32          fSendMaxWindow;
     uint32          fSendMaxSegmentSize;
+    uint32          fSendMaxSegments;
     BufferQueue     fSendQueue;
     tcp_sequence    fLastAcknowledgeSent;
     tcp_sequence    fInitialSendSequence;

src/add-ons/kernel/network/protocols/tcp/tcp.h

@@ -193 +193 @@
 #define TCP_MIN_RETRANSMIT_TIMEOUT      200000      // 200 msecs
 // Maximum retransmit timeout (per RFC6298)
 #define TCP_MAX_RETRANSMIT_TIMEOUT      60000000    // 60 secs
+// New value for timeout in case of lost SYN (RFC 6298)
+#define TCP_SYN_RETRANSMIT_TIMEOUT      3000000     // 3 secs
 
 struct tcp_sack {
     uint32 left_edge;