Ticket #13681: 0008-tcp-rfc-2018-implemented-SACK-option.patch

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

@@ -436 +436 @@
         fPushPointer = fList.Tail()->sequence + fList.Tail()->size;
 }
 
+
+int
+BufferQueue::PopulateSackInfo(tcp_sequence sequence, int maxSackCount, tcp_sack* sacks)
+{
+    SegmentList::ReverseIterator iterator = fList.GetReverseIterator();
+    net_buffer* buffer = iterator.Next();
+
+    int sackCount = 0;
+    while (buffer != NULL && buffer->sequence > sequence) {
+        if (buffer->sequence + buffer->size < sacks[sackCount].left_edge) {
+            if (sackCount + 1 == maxSackCount)
+                break;
+            ++sackCount;
+            sacks[sackCount].left_edge = buffer->sequence;
+            sacks[sackCount].right_edge = buffer->sequence + buffer->size;
+        } else {
+            sacks[sackCount].left_edge = buffer->sequence;
+            if (sacks[sackCount].right_edge == 0)
+                sacks[sackCount].right_edge = buffer->sequence + buffer->size;
+        }
+
+        buffer = iterator.Next();
+    }
+
+    if (sacks[0].left_edge != 0) {
+        for (int i = 0; i <= sackCount; ++i) {
+            sacks[i].left_edge = htonl(sacks[i].left_edge);
+            sacks[i].right_edge = htonl(sacks[i].right_edge);
+        }
+        ++sackCount;
+    }
+
+    return sackCount;
+}
+
 #if DEBUG_BUFFER_QUEUE
 
 /*! Perform a sanity check of the whole queue.

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

@@ -42 +42 @@
 
     inline  size_t              PushedData() const;
             void                SetPushPointer();
+            int             PopulateSackInfo(tcp_sequence sequence, int maxSackCount, tcp_sack* sacks);
 
             size_t              Used() const { return fNumBytes; }
     inline  size_t              Free() const;

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

@@ -319 +319 @@
     FLAG_CLOSED                 = 0x08,
     FLAG_DELETE_ON_CLOSE        = 0x10,
     FLAG_LOCAL                  = 0x20,
-    FLAG_RECOVERY               = 0x40
+    FLAG_RECOVERY               = 0x40,
+    FLAG_OPTION_SACK_PERMITTED  = 0x80,
 };
 
 
@@ -450 +451 @@
     fCongestionWindow(0),
     fSlowStartThreshold(0),
     fState(CLOSED),
-    fFlags(FLAG_OPTION_WINDOW_SCALE | FLAG_OPTION_TIMESTAMP)
+    fFlags(FLAG_OPTION_WINDOW_SCALE | FLAG_OPTION_TIMESTAMP | FLAG_OPTION_SACK_PERMITTED)
 {
     // TODO: to be replaced with a real read/write locking strategy!
     mutex_init(&fLock, "tcp lock");
@@ -1426 +1427 @@
             fReceivedTimestamp = segment.timestamp_value;
         } else
             fFlags &= ~FLAG_OPTION_TIMESTAMP;
+
+        if ((segment.options & TCP_SACK_PERMITTED) == 0)
+            fFlags &= ~FLAG_OPTION_SACK_PERMITTED;
     }
 
     if (fSendMaxSegmentSize > 2190)
@@ -2027 +2031 @@
             segment.timestamp_value = tcp_now();
         }
 
+        // SACK information is embedded with duplicate acknowledgements
+        if (!fReceiveQueue.IsContiguous() && fLastAcknowledgeSent == fReceiveNext
+            && (fFlags & FLAG_OPTION_SACK_PERMITTED) != 0) {
+            segment.options |= TCP_HAS_SACK;
+            int maxSackCount = 4 - ((fFlags & FLAG_OPTION_TIMESTAMP) != 0);
+            segment.sacks = (tcp_sack*)calloc(maxSackCount, sizeof(tcp_sack));
+            if (segment.sacks != NULL)
+                segment.sackCount = fReceiveQueue.PopulateSackInfo(fReceiveNext, maxSackCount, segment.sacks);
+            else
+                segment.sackCount = 0;
+        }
+
         if ((segment.flags & TCP_FLAG_SYNCHRONIZE) != 0
             && fSendNext == fInitialSendSequence) {
             // add connection establishment options
@@ -2035 +2051 @@
                 segment.options |= TCP_HAS_WINDOW_SCALE;
                 segment.window_shift = fReceiveWindowShift;
             }
+            if ((fFlags & FLAG_OPTION_SACK_PERMITTED) != 0)
+                segment.options |= TCP_SACK_PERMITTED;
         }
     }
 

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

@@ -140 +140 @@
         bump_option(option, length);
     }
 
-    if (segment.sack_count > 0) {
+    if (segment.sackCount > 0) {
         int sackCount = ((int)(bufferSize - length) - 4) / sizeof(tcp_sack);
-        if (sackCount > segment.sack_count)
-            sackCount = segment.sack_count;
+        if (sackCount > segment.sackCount)
+            sackCount = segment.sackCount;
 
         if (sackCount > 0) {
             option->kind = TCP_OPTION_NOP;
@@ -154 +154 @@
             option->length = 2 + sackCount * sizeof(tcp_sack);
             memcpy(option->sack, segment.sacks, sackCount * sizeof(tcp_sack));
             bump_option(option, length);
+            free(segment.sacks);
         }
     }
 
@@ -218 +219 @@
                 if (option->length == 2 && size >= 2)
                     segment.options |= TCP_SACK_PERMITTED;
                 break;
+            case TCP_OPTION_SACK:
+                if (size >= option->length) {
+                    segment.options |= TCP_HAS_SACK;
+                    segment.sackCount = (option->length - 2) / sizeof(tcp_sack);
+                    segment.sacks = option->sack;
+
+                    for(int i = 0; i < segment.sackCount; ++i) {
+                        segment.sacks[i].left_edge = ntohl(segment.sacks[i].left_edge);
+                        segment.sacks[i].right_edge = ntohl(segment.sacks[i].right_edge);
+                    }
+                }
+                break;
         }
 
         if (length < 0) {
@@ -432 +445 @@
     if (segment.options & TCP_SACK_PERMITTED)
         length += 2;
 
-    if (segment.sack_count > 0) {
+    if (segment.sackCount > 0) {
         int sackCount = min_c((int)((kMaxOptionSize - length - 4)
-            / sizeof(tcp_sack)), segment.sack_count);
+            / sizeof(tcp_sack)), segment.sackCount);
         if (sackCount > 0)
             length += 4 + sackCount * sizeof(tcp_sack);
     }

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

@@ -231 +231 @@
     TCP_HAS_WINDOW_SCALE    = 1 << 0,
     TCP_HAS_TIMESTAMPS      = 1 << 1,
     TCP_SACK_PERMITTED      = 1 << 2,
+    TCP_HAS_SACK            = 1 << 3,
 };
 
 struct tcp_segment_header {
@@ -239 +240 @@
         flags(_flags),
         window_shift(0),
         max_segment_size(0),
-        sack_count(0),
+        sackCount(0),
         options(0)
     {}
 
@@ -255 +256 @@
     uint32  timestamp_reply;
 
     tcp_sack    *sacks;
-    int         sack_count;
+    int         sackCount;
 
     uint32  options;