> 科技资讯 > CS144 计算机网络 Lab4:TCP Connection

CS144 计算机网络 Lab4:TCP Connection

科技资讯 投稿 7700℃ 0 评论

CS144 计算机网络 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 仍然处于连接状态的时候；

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 的测试用例失败了，但是单独运行这些测试用例却又可以通过，就很奇怪：

ByteStream 类，将内部数据类型换成 BufferList，这样在写入数据的时候就不用一个字符一个字符插入队列了，可以大大提高效率。

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

后记

约等于一坤天），调试的时候断点还总是失效，最后发现是优化搞的鬼，需要将 etc/cflags.cmake 第 18 行改为 set (CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -ggdb3 -O0" 才行。以上~~

编程笔记 » CS144 计算机网络 Lab4:TCP Connection

赞同 (45) or 分享 (0)
游客 发表我的评论   换个身份
取消评论

表情
(0)个小伙伴在吐槽