🔌

TCP from Scratch

C++23 & Rust — RFC 793 Implementation

A complete TCP/IP stack over raw Linux AF_PACKET sockets — no OS TCP involvement

C++23 Rust (stable) AF_PACKET RFC 793 RFC 9293 RFC 6298 Timers

2

Full Implementations

10

Integration Tests

5

RFCs Implemented

github.com/sidx007/TCP-in-Cpp-and-Rust

Overview

What's implemented

Two self-contained TCP stacks — identical logic, different languages. Both open raw Ethernet sockets directly and implement the full TCP state machine in user space. The OS kernel is bypassed entirely for protocol logic.

State Machine

Full RFC 793/9293 TCP states — SYN_SENT, ESTABLISHED, FIN_WAIT, TIME_WAIT, simultaneous close, RST handling.

Reliability

Retransmission with RFC 6298 SRTT/RTTVAR/RTO. Sliding window flow control. Delayed ACK (200ms or every 2 segments).

Raw I/O

AF_PACKET SOCK_RAW sockets. ARP resolution for MAC discovery. RFC 1071 Internet checksum computed in software — no hardware offload.

Threading

RX thread, timer thread (100ms), per-connection mutex. 64 KiB circular send/recv buffers. ISN from /dev/urandom.

Architecture

Stack Layers

Application Layer — Echo server demo (port 9999)

↓

TCP Socket API — connect / listen / accept / send / recv / close

↓

TCP Protocol Engine — state machine · retransmit · timers

↓

Send Buffer — 64 KiB circular

Recv Buffer — 64 KiB circular

↓

IP / Checksum Layer — IPv4 header build + TCP checksum

↓

Raw Socket I/O — AF_PACKET SOCK_RAW read/write + ARP

Tests

Integration Tests T1–T10

#	Test	What it checks
T1	3-way handshake	Connect succeeds, reaches ESTABLISHED
T2	Echo small msg	"hello" → "hello" round-trip
T3	Echo 1 MB	SHA-256 match, zero corruption
T4	Clean close	FIN/ACK exchange, CLOSED state
T5	RST handling	Abrupt close tears down connection
T6	Retransmit	iptables packet loss — transfer still completes
T7	Checksum reject	Corrupt byte silently dropped
T8	Simultaneous connect	Two custom-stack peers connect each other
T9	50 connections	No resource leak across sequential connections
T10	TIME_WAIT expiry	Port reusable after 2×MSL (60s)

C++23 vs Rust

Two implementations, same spec

⚙️ C++23

Build: CMake + GCC/Clang

No external deps — pure libc + STL

Modules: raw_socket, ip, tcp_header, tcp_buffer, tcp_connection, tcp_listener, tcp_stream, timer

Run: sudo ./build/echo_server eth0

🦀 Rust (stable)

Build: Cargo

Only libc, log, env_logger

All unsafe isolated in raw_socket.rs — libc socket calls only

Run: sudo cargo run --bin echo_server -- eth0

Note: Both require CAP_NET_RAW or root. Set iptables to drop kernel RSTs on port 9999 before testing — otherwise the OS will interfere with your handshake.