vgalaxy@vgalaxy-VirtualBox:~/Desktop$ telnet cs144.keithw.org http
Trying 104.196.238.229...
Connected to cs144.keithw.org.
Escape character is '^]'.
GET /lab0/sunetid HTTP/1.1
Host: cs144.keithw.org
Connection:  close

HTTP/1.1 200 OK
Date: Sun, 20 Feb 2022 13:11:17 GMT
Server: Apache
X-You-Said-Your-SunetID-Was: sunetid
X-Your-Code-Is: 477223
Content-length: 111
Vary: Accept-Encoding
Connection: close
Content-Type: text/plain

Hello! You told us that your SUNet ID was "sunetid". Please see the HTTP headers (above) for your secret code.
Connection closed by foreign host.

netcat -v -l -p 9090

telnet localhost 9090

void get_URL(const string &host, const string &path) {
    // Your code here.

    Address address(host, "http");
    TCPSocket socket;
    socket.connect(address);
    string request("GET ");
    request += path;
    request += " HTTP/1.1\r\nHost: ";
    request += host;
    request += "\r\nConnection: close\r\n\r\n";
    socket.write(request);

    string res;
    socket.read(res);
    while (res != "") {
        cout << res;
        socket.read(res);
    }
    socket.close();

    // You will need to connect to the "http" service on
    // the computer whose name is in the "host" string,
    // then request the URL path given in the "path" string.

    // Then you'll need to print out everything the server sends back,
    // (not just one call to read() -- everything) until you reach
    // the "eof" (end of file).

    // cerr << "Function called: get_URL(" << host << ", " << path << ").\n";
    // cerr << "Warning: get_URL() has not been implemented yet.\n";
}

$ ./apps/webget cs144.keithw.org /hello

$ make check_webget

$ make check_lab0

cmake .. -DCMAKE_BUILD_TYPE=RelASan
cmake .. -DCMAKE_BUILD_TYPE=Debug
cmake .. -DCMAKE_BUILD_TYPE=Release
make -j8

mutable std::forward_list<std::pair<std::string, uint64_t>> _unassembled_substrings{};

ctest -R wrap

vi Testing/Temporary/LastTest.log

make check_lab2

In your TCP implementation, you’ll use the index of the last reassembled byte as the checkpoint.

the index of the first unassembled byte

the distance between the first unassembled index and the first unacceptable index

payload 为空且设置了 fin
payload 不为空且设置了 syn
payload 给出的 seqno 无效
...

string TCPState::state_summary(const TCPReceiver &receiver) {
    if (receiver.stream_out().error()) {
        return TCPReceiverStateSummary::ERROR;
    } else if (not receiver.ackno().has_value()) {
        return TCPReceiverStateSummary::LISTEN;
    } else if (receiver.stream_out().input_ended()) {
        return TCPReceiverStateSummary::FIN_RECV;
    } else {
        return TCPReceiverStateSummary::SYN_RECV;
    }
}

namespace TCPReceiverStateSummary {
const std::string ERROR = "error (connection was reset)";
const std::string LISTEN = "waiting for SYN: ackno is empty";
const std::string SYN_RECV = "SYN received (ackno exists), and input to stream hasn't ended";
const std::string FIN_RECV = "input to stream has ended";
}  // namespace TCPReceiverStateSummary

the ackno is greater than all of the sequence numbers in the segment

string TCPState::state_summary(const TCPSender &sender) {
    if (sender.stream_in().error()) {
        return TCPSenderStateSummary::ERROR;
    } else if (sender.next_seqno_absolute() == 0) {
        return TCPSenderStateSummary::CLOSED;
    } else if (sender.next_seqno_absolute() == sender.bytes_in_flight()) {
        return TCPSenderStateSummary::SYN_SENT;
    } else if (not sender.stream_in().eof()) {
        return TCPSenderStateSummary::SYN_ACKED;
    } else if (sender.next_seqno_absolute() < sender.stream_in().bytes_written() + 2) {
        return TCPSenderStateSummary::SYN_ACKED;
    } else if (sender.bytes_in_flight()) {
        return TCPSenderStateSummary::FIN_SENT;
    } else {
        return TCPSenderStateSummary::FIN_ACKED;
    }
}

namespace TCPSenderStateSummary {
const std::string ERROR = "error (connection was reset)";
const std::string CLOSED = "waiting for stream to begin (no SYN sent)";
const std::string SYN_SENT = "stream started but nothing acknowledged";
const std::string SYN_ACKED = "stream ongoing";
const std::string FIN_SENT = "stream finished (FIN sent) but not fully acknowledged";
const std::string FIN_ACKED = "stream finished and fully acknowledged";
}  // namespace TCPSenderStateSummary

make check_lab3

inbound_stream().set_error();
outbound_stream().set_error();
_is_active = false;

TCPHeader header;
header.ack = true;
header.ackno = _receiver.ackno().value();
header.win = _receiver.window_size();
// not consume seqno
header.seqno = _sender.next_seqno();

    void try_clean_shutdown() {
        if (_linger_after_streams_finish) {
            if (
                // stream end
                inbound_stream().eof() and outbound_stream().eof() and
                // timeout
                _timer.has_value() and _timer.value() >= 10 * _cfg.rt_timeout) {
                _is_active = false;
            }
        } else {
            if (
                // the inbound stream has been fully assembled and has ended
                inbound_stream().eof() and _receiver.unassembled_bytes() == 0 and
                // the outbound stream has been fully acknowledged by the remote peer
                outbound_stream().eof() and _sender.bytes_in_flight() == 0) {
                _is_active = false;
            }
        }
    }

...
segment_received();
...
fill_window();
...
collect_output();
...

    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
    };

TCPState::TCPState(const TCPState::State state) {
    switch (state) {
        case TCPState::State::LISTEN:
            _receiver = TCPReceiverStateSummary::LISTEN;
            _sender = TCPSenderStateSummary::CLOSED;
            break;
        case TCPState::State::SYN_RCVD:
            _receiver = TCPReceiverStateSummary::SYN_RECV;
            _sender = TCPSenderStateSummary::SYN_SENT;
            break;
        case TCPState::State::SYN_SENT:
            _receiver = TCPReceiverStateSummary::LISTEN;
            _sender = TCPSenderStateSummary::SYN_SENT;
            break;
        case TCPState::State::ESTABLISHED:
            _receiver = TCPReceiverStateSummary::SYN_RECV;
            _sender = TCPSenderStateSummary::SYN_ACKED;
            break;
        case TCPState::State::CLOSE_WAIT:
            _receiver = TCPReceiverStateSummary::FIN_RECV;
            _sender = TCPSenderStateSummary::SYN_ACKED;
            _linger_after_streams_finish = false;
            break;
        case TCPState::State::LAST_ACK:
            _receiver = TCPReceiverStateSummary::FIN_RECV;
            _sender = TCPSenderStateSummary::FIN_SENT;
            _linger_after_streams_finish = false;
            break;
        case TCPState::State::CLOSING:
            _receiver = TCPReceiverStateSummary::FIN_RECV;
            _sender = TCPSenderStateSummary::FIN_SENT;
            break;
        case TCPState::State::FIN_WAIT_1:
            _receiver = TCPReceiverStateSummary::SYN_RECV;
            _sender = TCPSenderStateSummary::FIN_SENT;
            break;
        case TCPState::State::FIN_WAIT_2:
            _receiver = TCPReceiverStateSummary::SYN_RECV;
            _sender = TCPSenderStateSummary::FIN_ACKED;
            break;
        case TCPState::State::TIME_WAIT:
            _receiver = TCPReceiverStateSummary::FIN_RECV;
            _sender = TCPSenderStateSummary::FIN_ACKED;
            break;
        case TCPState::State::RESET:
            _receiver = TCPReceiverStateSummary::ERROR;
            _sender = TCPSenderStateSummary::ERROR;
            _linger_after_streams_finish = false;
            _active = false;
            break;
        case TCPState::State::CLOSED:
            _receiver = TCPReceiverStateSummary::FIN_RECV;
            _sender = TCPSenderStateSummary::FIN_ACKED;
            _linger_after_streams_finish = false;
            _active = false;
            break;
    }
}

make check_lab4

ctest -R '^test_name$'

void TCPTestHarness::execute(const TCPTestStep &step, std::string note) {
    try {
        step.execute(*this);
        while (not _fsm.segments_out().empty()) {
            _flt.write(_fsm.segments_out().front());
            _fsm.segments_out().pop();
        }
        _steps_executed.emplace_back(step.to_string());

void TestFdAdapter::write(TCPSegment &seg) {
    config_segment(seg);
    TestFD::write(seg.serialize());
}

TCPSegment TCPTestHarness::expect_seg(const ExpectSegment &expectation, std::string note) {
    try {
        auto ret = expectation.expect_seg(*this);
        _steps_executed.emplace_back(expectation.to_string());
        return ret;

In the test names, “c” means your code is the client (peer that sends the first syn), and “s” means your code is the server.
The letter “u” means it is testing TCP-over-UDP, and “i” is testing TCP-over-IP (TCP/IP). The letter “n” means it is trying to interoperate with Linux’s TCP implementation.
“S” means your code is sending data; “R” means your code is receiving data, and “D” means data is being sent in both directions.
At the end of a test name, a lowercase “l” means there is packet loss on the receiving (incoming segment) direction, and uppercase “L” means there is packet loss on the sending (outgoing segment) direction.

sudo apt install tshark

./apps/tcp_ipv4 -l 169.254.144.9 9090

sudo tshark -Pw /tmp/debug.raw -i tun144

./apps/tcp_ipv4 -d tun145 -a 169.254.145.9 169.254.144.9 9090

    1 0.000000000 169.254.144.1 → 169.254.144.9 TCP 40 15573 → 9090 [SYN] Seq=0 Win=0 Len=0
    2 0.000677060 169.254.144.9 → 169.254.144.1 TCP 40 9090 → 15573 [SYN, ACK] Seq=0 Ack=1 Win=64000 Len=0
    3 0.001396230 169.254.144.1 → 169.254.144.9 TCP 40 15573 → 9090 [ACK] Seq=1 Ack=1 Win=64000 Len=0
    4 6.934169758 169.254.144.9 → 169.254.144.1 TCP 40 9090 → 15573 [FIN, ACK] Seq=1 Ack=1 Win=64000 Len=0
    5 6.934802967 169.254.144.1 → 169.254.144.9 TCP 40 15573 → 9090 [ACK] Seq=1 Ack=2 Win=64000 Len=0
    6 10.090191484 169.254.144.1 → 169.254.144.9 TCP 40 15573 → 9090 [FIN, ACK] Seq=1 Ack=2 Win=64000 Len=0
    7 10.090765796 169.254.144.9 → 169.254.144.1 TCP 40 9090 → 15573 [ACK] Seq=2 Ack=2 Win=64000 Len=0

DEBUG: Outbound stream to 169.254.144.1:23086 finished (1 byte still in flight).
DEBUG: Outbound stream to 169.254.144.1:23086 has been fully acknowledged.

DEBUG: Inbound stream from 169.254.144.9:9090 finished cleanly.

DEBUG: Inbound stream from 169.254.144.1:40103 finished cleanly.
DEBUG: Waiting for lingering segments (e.g. retransmissions of FIN) from peer...
DEBUG: Waiting for clean shutdown...

DEBUG: TCP connection finished cleanly.
done.

DEBUG: Waiting for clean shutdown... DEBUG: Outbound stream to 169.254.144.9:9090 finished (1 byte still in flight).
DEBUG: Outbound stream to 169.254.144.9:9090 has been fully acknowledged.
DEBUG: TCP connection finished cleanly.
done.

build$ ./apps/tcp_benchmark
CPU-limited throughput                : 1.31 Gbit/s
CPU-limited throughput with reordering: 1.19 Gbit/s
build$ date
2022年 03月 08日 星期二 09:52:29 CST

Warning: unclean shutdown of TCPSpongeSocket