簡易TCPのシーケンス番号・再送・フロー制御と、自作TCPクライアントが踏む「自分のカーネルのRST」問題

// l2-arp/src/capture.cpp（追加分）
std::expected<std::span<std::byte>, CaptureError> RawSocket::receive(
    std::span<std::byte> buffer,
    std::chrono::milliseconds timeout
)
{
    pollfd pfd{.fd = fd_, .events = POLLIN, .revents = 0};
    int result = poll(&pfd, 1, static_cast<int>(timeout.count()));

    if (result == 0)
    {
        return std::unexpected(CaptureError::Timeout);
    }
    if (result < 0)
    {
        return std::unexpected(CaptureError::ReceiveFailed);
    }

    return receive(buffer);
}

// tcp-tls13/include/tcptls13/tcp_connection.hpp
class TcpConnection
{
public:
    static std::expected<TcpConnection, ConnectionError> connect(/* ... */);

    std::expected<void, ConnectionError> send(std::span<const std::byte> data);
    std::expected<std::vector<std::byte>, ConnectionError> receive();

private:
    l2arp::RawSocket* socket_;
    l2arp::MacAddress local_mac_;
    l2arp::MacAddress peer_mac_;
    Ipv4Address local_ip_;
    Ipv4Address peer_ip_;
    std::uint16_t local_port_;
    std::uint16_t peer_port_;
    std::uint32_t send_next_;
    std::uint32_t recv_next_;
    std::uint16_t peer_window_;
};

// tcp-tls13/src/tcp_connection.cpp（send抜粋）
std::expected<void, ConnectionError> TcpConnection::send(std::span<const std::byte> data)
{
    std::size_t sent = 0;

    while (sent < data.size())
    {
        if (peer_window_ == 0)
        {
            return std::unexpected(ConnectionError::WindowClosed);
        }

        const auto chunk_size = std::min(
            {MaxSegmentPayload, static_cast<std::size_t>(peer_window_), data.size() - sent}
        );
        const auto chunk = data.subspan(sent, chunk_size);

        bool acked = false;
        for (int attempt = 0; attempt < MaxRetries && !acked; ++attempt)
        {
            if (!send_segment(TcpFlags{.ack = true}, chunk))
            {
                return std::unexpected(ConnectionError::SendFailed);
            }

            auto reply = receive_segment(RetransmitTimeout);
            if (!reply)
            {
                if (reply.error() == ConnectionError::Timeout)
                {
                    continue;
                }
                return std::unexpected(reply.error());
            }

            if (!reply->header.flags.ack
                || reply->header.acknowledgement_number != send_next_ + chunk.size())
            {
                continue;
            }

            send_next_ += chunk.size();
            peer_window_ = reply->header.window_size;
            acked = true;
        }

        if (!acked)
        {
            return std::unexpected(ConnectionError::Timeout);
        }

        sent += chunk_size;
    }

    return {};
}

// tcp-tls13/src/tcp_connection.cpp（receive抜粋）
std::expected<std::vector<std::byte>, ConnectionError> TcpConnection::receive()
{
    while (true)
    {
        auto segment = receive_segment(NoTimeout);
        if (!segment)
        {
            return std::unexpected(segment.error());
        }

        if (segment->header.sequence_number < recv_next_)
        {
            // 相手からのACK取りこぼしによる再送。読み捨てて自分のACKだけ返す。
            send_segment(TcpFlags{.ack = true}, {});
            continue;
        }

        if (segment->header.sequence_number != recv_next_ || segment->payload.empty())
        {
            continue;
        }

        recv_next_ += segment->payload.size();

        if (!send_segment(TcpFlags{.ack = true}, {}))
        {
            return std::unexpected(ConnectionError::SendFailed);
        }

        return segment->payload;
    }
}

client → target   SYN
target → client   SYN-ACK
client → target   RST   ← このマシン自身のOSが送っている
client → target   ACK   ← 自作アプリが送った、本来のハンドシェイクの締め
client → target   "hello"
target → client   RST   ← targetは3番目のRSTで接続を既に破棄済み

sudo iptables -A OUTPUT -p tcp --sport 54322 --tcp-flags RST RST -j DROP