CS144 Lab Assignments - 手写TCP - LAB2

CS 144: Introduction to Computer Networking, Fall 2020
https://cs144.github.io/

My Repo
https://github.com/wine99/cs1...

Translating between 64-bit indexes and 32-bit seqnos

注意 wrapping_integers.hh 中的这三个方法：

inline int32_t operator-(WrappingInt32 a, WrappingInt32 b) { return a.raw_value() - b.raw_value(); }

//! \brief The point `b` steps past `a`.
inline WrappingInt32 operator+(WrappingInt32 a, uint32_t b) { return WrappingInt32{a.raw_value() + b}; }

//! \brief The point `b` steps before `a`.
inline WrappingInt32 operator-(WrappingInt32 a, uint32_t b) { return a + -b; }

下面的两个加减，分别是在 WrappingInt32 上加上或减去一个 uint32_t，得到的结果仍然是一个 WrappingInt32，其意义是分别为把 a 这个 WrappingInt32 向前或向后移动 |b| 个单位距离。

而第一个减法重载，是两个 WrappingInt32 相减，得到的是一个 int32_t，要想理解其意义，首先要弄懂下面的代码：

// 2 ^ 32 = 4294967296

uint32_t a = 1;
uint32_t b = 0;
uint32_t x = a - b;
int32_t  y = a - b;
// x=1 y=1
uint32_t x = b - a;
int32_t  y = b - a;
// x=4294967295 y=-1

uint32_t a = 1;
uint32_t b = static_cast<uint32_t>((1UL << 32) - 1UL);
uint32_t x = a - b;
int32_t  y = a - b;
// x=2 y=2
uint32_t x = b - a;
int32_t  y = b - a;
// x=4294967294 y=-2

上面的运算说明：c(int32_t) = a(uint32_t) - b(uint32_t) 的 c 的绝对值的意义是从 b 走到 a 需要花费的最少步数，如果 c 是正数，则向数轴的正方向走，否则向反方向走。之所以存在最小步数一说，是因为往反方向走穿越 0 会到 2^32 - 1，往正方向走穿越 2^32 - 1 会回到 0。这个步数也一定不会超过 2^31 步。第一个减法也是这样的意义，代表了从 WrappingInt32 b 走到 WrappingInt32 a 最少需要的步数。

理解了这三个运算符重载后，就可以编写 Wrapping_integers.cc 了：

WrappingInt32 wrap(uint64_t n, WrappingInt32 isn) { return isn + static_cast<uint32_t>(n); }

uint64_t unwrap(WrappingInt32 n, WrappingInt32 isn, uint64_t checkpoint) {
    // STEP ranges from -UINT32_MAX/2 to UINT32_MAX/2
    // in most cases, just adding STEP to CHECKPOINT will get the absolute seq
    // but if after adding, the absolute seq is negative, it should add another (1UL << 32)
    // (this means the checkpoint is near 0 so the new seq should always go bigger
    // eg. test/unwrap.cc line 25)
    int32_t steps = n - wrap(checkpoint, isn);
    int64_t res = checkpoint + steps;
    return res >= 0 ? checkpoint + steps : res + (1UL << 32);
}

首先看把 64 位的 index 转换为 WrappingInt32 的 wrap 函数。根据上面的表格，显然，只需要利用加法重载，把 ISN 往前走 n(=index) 步就可以了。

然后看 unwrap 函数，起作用是把新接收到的报文段的 seqno（WrappingInt32）转换为 64 位的 index。seqno 转 index 的结果显然不唯一，我们想要的是与上一次收到的报文段的 index（checkpoint）最接近的那个转换结果。于是，可以先用刚写好的 wrap 函数把 checkpoint 变为 WrappingInt32，然后利用第一个减法重载，找出这个转换后的 seqno 最少需要走几步可以到新报文的 seqno，然后把这个步数加到 checkpoint 上。注意这里有一个特殊情况（见代码注释），因为我们有可能是往数轴的反方向走的，可能走完之后 res 的值是个负数，这时候需要在加上一个 2^32。

Implementing the TCP receiver

注意测试里面的特殊情况，例如

• SYN with DATA
• SYN with DATA with FIN
• SYN + FIN
• SYN + DATA with FIN + DATA
• ...

然后根据未通过的测试，一步步完善逻辑，测试全部通过后再重新简化代码，最终得到解法如下（部分思路见注释）：

void TCPReceiver::segment_received(const TCPSegment &seg) {
    TCPHeader header = seg.header();
    if (header.syn && _syn)
        return;
    if (header.syn) {
        _syn = true;
        _isn = header.seqno.raw_value();
    }
    // note that fin flag seg can carry payload
    if (_syn && header.fin)
        _fin = true;
    size_t absolute_seqno = unwrap(header.seqno, WrappingInt32(_isn), _checkpoint);
    _reassembler.push_substring(seg.payload().copy(), header.syn ? 0 : absolute_seqno - 1, header.fin);
    _checkpoint = absolute_seqno;
}

optional<WrappingInt32> TCPReceiver::ackno() const {
    // Return the corresponding 32bit seqno of _reassembler.first_unassembled().
    // Translate from Stream Index to Absolute Sequence Number is simple, just add 1.
    // If outgoing ack is corresponding to FIN
    // (meaning FIN is received and all segs are assembled),
    // add another 1.
    size_t shift = 1;
    if (_fin && _reassembler.unassembled_bytes() == 0)
        shift = 2;
    if (_syn)
        return wrap(_reassembler.first_unassembled() + shift, WrappingInt32(_isn));
    return {};
}

size_t TCPReceiver::window_size() const {
    // equal to first_unacceptable - first_unassembled
    return _capacity - stream_out().buffer_size();
}