CS144 計算機網路 Lab2：TCP Receiver

前言

Lab1 中我們使用雙端佇列實現了位元組流重組器，可以將無序到達的資料重組為有序的位元組流。Lab2 將在此基礎上實現 TCP Receiver，在收到報文段之後將資料寫入重組器中，並回復傳送方。

實驗要求

TCP 接收方除了將收到的資料寫入重組器中外，還需要告訴傳送傳送方：

• 下一個需要的但是還沒收到的位元組索引
• 允許接收的位元組範圍

接收方的資料情況如下圖所示，藍色部分表示已消費的資料，綠色表示已正確重組但是還沒消費的資料，紅色則是失序到達且還沒重組的資料。其中 first unassembled 就是還沒收到的第一個位元組，first unacceptable 就是不允許接收的第一個位元組。Lab2 的主要工作就是完成上述兩個任務。

索引轉換

TCP 三次握手的過程如下圖所示（圖片來自於小林coding）

客戶端隨機初始化一個序列號 client_isn，然後將此序號放在報文段的包頭上併發給服務端，表示想要建立連線。服務端收到之後也會生成含有隨機的序列號 server_isn 和確認應答號 ackno = client_isn + 1 的報文段，併傳送給客戶端表示接受連線。客戶端收到之後就可以開始向服務端傳送資料了，資料的第一個位元組對應的序列號為 client_isn + 1。

結合 Lab1 中實現的位元組流重組器，可以發現，在資料的收發過程中存在幾種序列號：

• 序列號 seqno：32bit 無符號整數，從初始序列號 ISN 開始遞增，SYN 和 FIN 各佔一個編號，溢位之後從 0 開始接著數
• 絕對序列號 absolute seqno：64bit 無符號整數，從 0 開始遞增，0 對應 ISN，不會溢位
• 位元組流索引 stream index：64bit 無符號整數，從 0 開始遞增，不考慮 SYN 報文段，所以 0 對應 ISN + 1，不會溢位

假設 ISN 為 \(2^{32}-2\)，待傳輸的資料為 cat，那麼三種編號的關係如下表所示：

由於 uint32_t 的數值範圍為 \(0\sim 2^{32}-1\)，所以 a 對應的報文段序列號溢位，又從 0 開始計數了。三者的關係可以表示為：

\[abs\_seqno = seqno - ISN + k\cdot2^{32},\ k\in{0,1,2,\dots}\\ index = abs\_seq-1 \]

可以看到，將絕對序列號轉為序列號比較簡單，只要加上 ISN 並強制轉換為 uint32_t 即可：

//! Transform an "absolute" 64-bit sequence number (zero-indexed) into a WrappingInt32
//! \param n The input absolute 64-bit sequence number
//! \param isn The initial sequence number
WrappingInt32 wrap(uint64_t n, WrappingInt32 isn) { return WrappingInt32{isn + static_cast<uint32_t>(n)}; }

要將序列號轉換為絕對序列號就比較麻煩了，由於 \(k\cdot2^{32}\) 項的存在，一個序列號可以對映為多個絕對序列號。這時候需要上一個收到的報文段絕對序列號 checkpoint 來輔助轉換，雖然我們不能保證各個報文段都是有序到達的，但是相鄰到達的報文段序列號差值超過 \(2^{32}\) 的可能性很小，所以我們可以將離 checkpoint 最近的轉換結果作為絕對序列號。

實現方式就是利用上述 wrap() 函式將存檔點序列號轉為序列號，然後計算新舊序列號的差值，一般情況下直接讓存檔點序列號加上差值就行，但是有時可能出現負值。比如 ISN 為 \(2^{32}-1\)，checkpoint 和 seqno 都是 0 時，相加結果會是 -1，這時候需要再加上 \(2^{32}\) 才能得到正確結果。

//! Transform a WrappingInt32 into an "absolute" 64-bit sequence number (zero-indexed)
//! \param n The relative sequence number
//! \param isn The initial sequence number
//! \param checkpoint A recent absolute 64-bit sequence number
//! \returns the 64-bit sequence number that wraps to `n` and is closest to `checkpoint`
//!
//! \note Each of the two streams of the TCP connection has its own ISN. One stream
//! runs from the local TCPSender to the remote TCPReceiver and has one ISN,
//! and the other stream runs from the remote TCPSender to the local TCPReceiver and
//! has a different ISN.
uint64_t unwrap(WrappingInt32 n, WrappingInt32 isn, uint64_t checkpoint) {
    auto offset = n - wrap(checkpoint, isn);
    int64_t abs_seq = checkpoint + offset;
    return abs_seq >= 0 ? abs_seq : abs_seq + (1ul << 32);
}

在 build 目錄輸入 ctest -R wrap 測試一下，發現測試用例都順利透過了：

TCP Receiver

確認應答號

TCP Receiver 在收到報文段之後應該回復給傳送方一個確認應答號，告知對方自己接下來需要的但是還沒收到的第一位元組對應的序列號是多少。假設當前已經收集了 2 個連續的位元組，那麼 first unassembled 的值就是 2，表明接下來需要索引為 2 的位元組，但是以此位元組打頭的包還沒到。由於 SYN 和 FIN 各佔一個序列號，所以確認應答號應該是 first unassembled + 1（收到 FIN 之前） 或者 first unassembled + 2（收到 FIN 之後）的轉換結果。

//! \brief The ackno that should be sent to the peer
//! \returns empty if no SYN has been received
//!
//! This is the beginning of the receiver's window, or in other words, the sequence number
//! of the first byte in the stream that the receiver hasn't received.
optional<WrappingInt32> TCPReceiver::ackno() const {
    if (!_is_syned)
        return nullopt;

    return {wrap(_reassembler.next_index() + 1 + _reassembler.input_ended(), _isn)};
}

接收視窗

接收方的緩衝區大小有限，如果應用沒有及時消費緩衝區的資料，隨著新資料的到來，緩衝區的剩餘空間會越來越小直至爆滿。為了配合應用程式的消費速度，TCP Receiver 應該告知傳送方自己的接收視窗有多大，如果傳送方的資料沒有落在這個視窗內，就會被丟棄掉。傳送方會根據這個視窗的大小調整自己的滑動視窗，以免向網路中傳送過多無效資料，這個過程稱為流量控制。

下圖展示了 TCP 報文段的結構，可以看到包頭的第 15 和 16 個位元組組成了視窗大小。

由於視窗大小等於緩衝區的容量減去緩衝區中的資料量，所以 window_size() 的程式碼為：

//! \brief The window size that should be sent to the peer
//!
//! Operationally: the capacity minus the number of bytes that the
//! TCPReceiver is holding in its byte stream (those that have been
//! reassembled, but not consumed).
//!
//! Formally: the difference between (a) the sequence number of
//! the first byte that falls after the window (and will not be
//! accepted by the receiver) and (b) the sequence number of the
//! beginning of the window (the ackno).
size_t TCPReceiver::window_size() const { return _reassembler.stream_out().remaining_capacity(); }

接收報文段

報文段的結構如上圖所示，CS144 使用 TCPSegment 類來表示報文段，由 _header 和 _payload 兩部分組成：

class TCPSegment {
  private:
    TCPHeader _header{};
    Buffer _payload{};

  public:
    //! \brief Parse the segment from a string
    ParseResult parse(const Buffer buffer, const uint32_t datagram_layer_checksum = 0);

    //! \brief Serialize the segment to a string
    BufferList serialize(const uint32_t datagram_layer_checksum = 0) const;

    const TCPHeader &header() const { return _header; }
    TCPHeader &header() { return _header; }

    const Buffer &payload() const { return _payload; }
    Buffer &payload() { return _payload; }

    //! \brief Segment's length in sequence space
    //! \note Equal to payload length plus one byte if SYN is set, plus one byte if FIN is set
    size_t TCPSegment::length_in_sequence_space() const {
    	return payload().str().size() + (header().syn ? 1 : 0) + (header().fin ? 1 : 0);
	}
};

TCPHeader 的結構也很簡單，只是把結構中的位元組和成員一一對應起來：

struct TCPHeader {
    static constexpr size_t LENGTH = 20;  // header length, not including options

    //! \name TCP Header fields
    uint16_t sport = 0;         //!< source port
    uint16_t dport = 0;         //!< destination port
    WrappingInt32 seqno{0};     //!< sequence number
    WrappingInt32 ackno{0};     //!< ack number
    uint8_t doff = LENGTH / 4;  //!< data offset
    bool urg = false;           //!< urgent flag
    bool ack = false;           //!< ack flag
    bool psh = false;           //!< push flag
    bool rst = false;           //!< rst flag
    bool syn = false;           //!< syn flag
    bool fin = false;           //!< fin flag
    uint16_t win = 0;           //!< window size
    uint16_t cksum = 0;         //!< checksum
    uint16_t uptr = 0;          //!< urgent pointer

    //! Parse the TCP fields from the provided NetParser
    ParseResult parse(NetParser &p);

    //! Serialize the TCP fields
    std::string serialize() const;

    //! Return a string containing a header in human-readable format
    std::string to_string() const;

    //! Return a string containing a human-readable summary of the header
    std::string summary() const;

    bool operator==(const TCPHeader &other) const;
};

接受到報文段的時候需要先判斷一下是否已建立連線，如果還沒建立連線且報文段的 SYN 位不為 1，就丟掉這個報文段。然後再判斷一下報文段的資料有沒有落在接收視窗內，如果落在視窗內就直接將資料交給重組器處理，同時儲存 checkpoint 以供下次使用。

比較奇怪的一種情況是會有 SYN 和 FIN 被同時置位的報文段，這時候得把位元組流的寫入功能關閉掉：

//! \brief handle an inbound segment
//! \returns `true` if any part of the segment was inside the window
bool TCPReceiver::segment_received(const TCPSegment &seg) {
    auto &header = seg.header();

    // 在完成握手之前不能接收資料
    if (!_is_syned && !header.syn)
        return false;

    // 丟棄網路延遲導致的重複 FIN
    if(_reassembler.input_ended() && header.fin)
        return false;

    // SYN
    if (header.syn) {

        // 丟棄網路延遲導致的重複 SYN
        if (_is_syned)
            return false;

        _isn = header.seqno;
        _is_syned = true;

        // FIN
        if (header.fin)
            _reassembler.push_substring(seg.payload().copy(), 0, true);

        return true;
    }

    // 分段所佔的序列號長度
    size_t seg_len = max(seg.length_in_sequence_space(), 1UL);

    // 將序列號轉換為位元組流索引
    _checkpoint = unwrap(header.seqno, _isn, _checkpoint);
    uint64_t index = _checkpoint - 1;

    // 視窗右邊界
    uint64_t unaccept_index = window_size() + _reassembler.next_index();

    // 序列號不能落在視窗外
    if (seg_len + index <= _reassembler.next_index() || index >= unaccept_index)
        return false;

    // 儲存資料
    _reassembler.push_substring(seg.payload().copy(), index, header.fin);
    return true;
}

在 build 目錄下輸入 ctest -R recv_ 或者 make check_lab2，發現各個測試用例也都順利透過：

後記

透過這次實驗，可以加深對報文段結構、各種序列號和流量控制機制的理解，期待下次實驗，以上~