前言

经过前面几个实验的铺垫，终于到了将他们组合起来的时候了。Lab4 将实现 TCP Connection 功能，内部含有 TCPReceiver 和 TCPSender，可以与 TCP 连接的另一个端点进行数据交换。

实验要求

简单来说，这次实验就是要在 TCPConnection 类中实现下图所示的有限状态机：

这些状态对应 TCPState 的内部枚举类 State：

//! \brief Official state names from the [TCP](\ref rfc::rfc793) specification
enum class State {
    LISTEN = 0,   //!< Listening for a peer to connect
    SYN_RCVD,     //!< Got the peer's SYN
    SYN_SENT,     //!< Sent a SYN to initiate a connection
    ESTABLISHED,  //!< Three-way handshake complete
    CLOSE_WAIT,   //!< Remote side has sent a FIN, connection is half-open
    LAST_ACK,     //!< Local side sent a FIN from CLOSE_WAIT, waiting for ACK
    FIN_WAIT_1,   //!< Sent a FIN to the remote side, not yet ACK'd
    FIN_WAIT_2,   //!< Received an ACK for previously-sent FIN
    CLOSING,      //!< Received a FIN just after we sent one
    TIME_WAIT,    //!< Both sides have sent FIN and ACK'd, waiting for 2 MSL
    CLOSED,       //!< A connection that has terminated normally
    RESET,        //!< A connection that terminated abnormally
};

除了三次握手和四次挥手外，我们还得处理报文段首部 RST 标志被置位的情况，这时候应该将断开连接，并将内部的输入流和输入流标记为 error，此时的 TCPState 应该是 RESET 。

代码实现

先在类声明里面加上一些成员：

class TCPConnection {
  private:
    TCPConfig _cfg;
    TCPReceiver _receiver{_cfg.recv_capacity};
    TCPSender _sender{_cfg.send_capacity, _cfg.rt_timeout, _cfg.fixed_isn};

    //! outbound queue of segments that the TCPConnection wants sent
    std::queue<TCPSegment> _segments_out{};

    //! Should the TCPConnection stay active (and keep ACKing)
    //! for 10 * _cfg.rt_timeout milliseconds after both streams have ended,
    //! in case the remote TCPConnection doesn't know we've received its whole stream?
    bool _linger_after_streams_finish{true};

    bool _is_active{true};

    size_t _last_segment_time{0};

    /**
     * @brief 发送报文段
     * @param fill_window 是否填满发送窗口
    */
    void send_segments(bool fill_window = false);

    // 发送 RST 报文段
    void send_rst_segment();

    // 中止连接
    void abort();

  public:
    // 省略其余成员
}

接着实现几个最简单的成员函数：

size_t TCPConnection::remaining_outbound_capacity() const { return _sender.stream_in().remaining_capacity(); }

size_t TCPConnection::bytes_in_flight() const { return _sender.bytes_in_flight(); }

size_t TCPConnection::unassembled_bytes() const { return _receiver.unassembled_bytes(); }

size_t TCPConnection::time_since_last_segment_received() const { return _last_segment_time; }

bool TCPConnection::active() const { return _is_active; }

主动连接

客户端可以调用 TCPConnection::connect 函数发送 SYN 报文段请求与服务端建立连接，由于 Lab3 中实现的 TCPSender::fill_window() 函数会根据发送方的状态选择要发送的报文段类型，在还没建立连接的情况下，这里直接调用 fill_window() 就会将一个 SYN 报文段放在队列中，我们只需将其取出放到 TCPConnection 的 _segments_out 队列中即可：

void TCPConnection::connect() {
    // 发送 SYN
    send_segments(true);
}

void TCPConnection::send_segments(bool fill_window) {
    if (fill_window)
        _sender.fill_window();

    auto &segments = _sender.segments_out();


    while (!segments.empty()) {
        auto seg = segments.front();

        // 设置 ACK、确认应答号和接收窗口大小
        if (_receiver.ackno()) {
            seg.header().ackno = _receiver.ackno().value();
            seg.header().win = _receiver.window_size();
            seg.header().ack = true;
        }

        _segments_out.push(seg);
        segments.pop();
    }
}

主动关闭

当上层程序没有更多数据需要发送时，将会调用 TCPConnection::end_input_stream() 结束输入，这时候需要发送 FIN 报文段给服务端，告诉他自己没有更多数据要发送了，但是可以继续接收服务端发来的数据。客户端的状态由 ESTABLISHED 转移到 FIN_WAIT_1，服务端收到 FIN 之后变成 CLOSE_WAIT 状态，并回复 ACK 给客户端，客户端收到之后接着转移到 FIN_WAIT_2 状态。

如果服务端数据传输完成了，会发送 FIN 报文段给客户端，转移到 LAST_ACK 状态，此时客户端会回复最后一个 ACK 给服务端并进入 TIME_WAIT 超时等待状态，如果这个等待时间内没有收到服务端重传的 FIN，就说明 ACK 顺利到达了服务端且服务端已经变成 CLOSED 状态了，此时客户端也能断开连接变成 CLOSED 了。

void TCPConnection::end_input_stream() {
    // 发送 FIN
    _sender.stream_in().end_input();
    send_segments(true);
}

在上述情景中，客户端是主动关闭（Active Close）的一方，服务端是被动关闭（Passive Close）的一方。

主动重置连接

有两种情况会导致发送 RST 报文段来主动重置连接：

• 当 TCPSender 超时重传的次数过多时，表明通信链路存在故障；
• TCPConnect 对象被释放但是 TCP 仍然处于连接状态的时候；

和 Lab3 中类似，TCPConnection 通过外部定期调用 tick() 函数来得知过了多长时间，在 tick() 函数里还得处理超时等待的情况：

//! \param[in] ms_since_last_tick number of milliseconds since the last call to this method
void TCPConnection::tick(const size_t ms_since_last_tick) {
    _sender.tick(ms_since_last_tick);

    // 重传次数太多时需要断开连接
    if (_sender.consecutive_retransmissions() > _cfg.MAX_RETX_ATTEMPTS) {
        return send_rst_segment();
    }

    // 重传数据包
    send_segments();

    _last_segment_time += ms_since_last_tick;

    //  TIME_WAIT 超时等待状态转移到 CLOSED 状态
    if (TCPState::state_summary(_receiver) == TCPReceiverStateSummary::FIN_RECV &&
        TCPState::state_summary(_sender) == TCPSenderStateSummary::FIN_ACKED &&
        _last_segment_time >= 10 * _cfg.rt_timeout) {
        _linger_after_streams_finish = false;
        _is_active = false;
    }
}

TCPConnection::~TCPConnection() {
    try {
        if (active()) {
            cerr << "Warning: Unclean shutdown of TCPConnection\n";

            // Your code here: need to send a RST segment to the peer
            send_rst_segment();
        }
    } catch (const exception &e) {
        std::cerr << "Exception destructing TCP FSM: " << e.what() << std::endl;
    }
}

void TCPConnection::send_rst_segment() {
    abort();
    TCPSegment seg;
    seg.header().rst = true;
    _segments_out.push(seg);
}

void TCPConnection::abort() {
    _is_active = false;
    _sender.stream_in().set_error();
    _receiver.stream_out().set_error();
}

接收报文段

外部通过 TCPConnection::segment_received() 将接收到的报文段传给它，在这个函数内部，需要将确认应答号和接收窗口大小告诉 TCPSender，好让他接着填满发送窗口。接着还需要把报文段传给 TCPReceiver 来重组数据，并更新确认应答号和自己的接收窗口大小。然后 TCPSender 需要根据收到的包类型进行状态转移，并决定发送含有有效数据的报文段还是空 ACK 给对方。

为什么即使没有新的数据要发送也要回复一个空 ACK 呢？因为如果不这么做，对方会以为刚刚发的包丢掉了而一直重传。

void TCPConnection::segment_received(const TCPSegment &seg) {
    if (!active())
        return;

    _last_segment_time = 0;

    // 是否需要发送空包回复 ACK，比如没有数据的时候收到 SYN/ACK 也要回一个 ACK
    bool need_empty_ack = seg.length_in_sequence_space();

    auto &header = seg.header();

    // 处理 RST 标志位
    if (header.rst)
        return abort();

    // 将包交给发送者
    if (header.ack) {
        need_empty_ack |= !_sender.ack_received(header.ackno, header.win);

        // 队列中已经有数据报文段了就不需要专门的空包回复 ACK
        if (!_sender.segments_out().empty())
            need_empty_ack = false;
    }

    // 将包交给接受者
    need_empty_ack |= !_receiver.segment_received(seg);

    // 被动连接
    if (TCPState::state_summary(_receiver) == TCPReceiverStateSummary::SYN_RECV &&
        TCPState::state_summary(_sender) == TCPSenderStateSummary::CLOSED)
        return connect();

    // 被动关闭
    if (TCPState::state_summary(_receiver) == TCPReceiverStateSummary::FIN_RECV &&
        TCPState::state_summary(_sender) == TCPSenderStateSummary::SYN_ACKED)
        _linger_after_streams_finish = false;

    // LAST_ACK 状态转移到 CLOSED
    if (TCPState::state_summary(_receiver) == TCPReceiverStateSummary::FIN_RECV &&
        TCPState::state_summary(_sender) == TCPSenderStateSummary::FIN_ACKED && !_linger_after_streams_finish) {
        _is_active = false;
        return;
    }

    if (need_empty_ack && TCPState::state_summary(_receiver) != TCPReceiverStateSummary::LISTEN)
        _sender.send_empty_segment();

    // 发送其余报文段
    send_segments();
}

测试

在终端中输入 make check_lab4 就能运行所有测试用例，测试结果如下：

发现有几个 txrx.sh 的测试用例失败了，但是单独运行这些测试用例却又可以通过，就很奇怪：

接着测试一下吞吐量（请确保构建类型是 Release 而不是 Debug），感觉还行， 0.71Gbit/s，超过了实验指导书要求的 0.1Gbit/s。但是实际上还可以优化一下 ByteStream 类，将内部数据类型换成 BufferList，这样在写入数据的时候就不用一个字符一个字符插入队列了，可以大大提高效率。

最后将 Lab0 中 webget 使用的 TCPSocket 换成 CS144TCPSocket，重新编译并运行 webegt，发现能够正确得到响应结果，说明我们实现的这个 CS144TCPSocket 已经能和别的操作系统实现的 Socket 进行交流了：

后记

至此，CS144 的 TCP 实验部分已全部完成，可以说是比较有挑战性的一次实验了，尤其是 Lab4 部分，各种奇奇怪怪的 bug，编码一晚上，调试时长两天半（约等于一坤天），调试的时候断点还总是失效，最后发现是优化搞的鬼，需要将 etc/cflags.cmake 第 18 行改为 set (CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -ggdb3 -O0") 才行。以上~~