C12: Networks, byte streams, and protocol boundaries

A. Prerequisites and observable goals#

Level: Degree core; all networking experiments are local or simulated.

B. The central question: how does one program know what another meant?#

A network carries representations of information, not Python objects or C++ structures as abstract values. An application chooses a message format; a transport moves bytes or datagrams; the network layer routes packets; link technologies move frames across individual links. This layering separates responsibilities. An application still has to decide which request a reply belongs to, how to reject malformed input, and what to do when communication stops.

An IP address identifies a network-layer endpoint or interface in a routing context, while a transport port helps distinguish services. DNS maps names to records such as addresses; it is not the connection itself, and a cached lookup can outlive a deployment change. A socket is a programming interface to communication, not a guarantee of successful delivery. A listening socket accepts connections; each accepted connection has its own stream state. A process may handle many sockets using threads or an event loop.

TCP provides a reliable, in-order byte stream while a connection is functioning. It does not preserve application write boundaries, prove that a remote application processed a request, or inherently establish application-level liveness. UDP preserves datagram boundaries, but does not by itself guarantee delivery, ordering, or freedom from duplication. Applications sometimes choose UDP when late data is less useful than fresh data, but then must specify the reliability and congestion behavior they actually need. [TCP]

C. Separate the quantities being measured#

Latency is elapsed time for a specified event, such as a round trip or completed request. Bandwidth is a capacity or rate limit; throughput is the achieved useful work per unit time. Jitter describes variation in delay under an explicit measurement convention. Packet loss is a fraction or count over a stated population. These quantities interact but are not interchangeable.

For a simplified one-way transfer of $B$ bytes over a bottleneck rate $r$ bytes per second with fixed delay $L$, a lower-order model is

This omits connection setup, retransmission, queueing, encryption, and server work. It is a model to challenge, not a law that every transfer exactly follows. If $B=10^6$ bytes, $r=10^7$ bytes/s, and $L=0.02$ s, the modeled time is $0.12$ s. A faster processor will not remove the $0.10$ s transmission term unless it changes the bottleneck.

Suppose an application permits only one outstanding request and each response requires a $50$ ms round trip. Even with negligible computation, it completes at most about $20$ such requests/s. Pipelining can improve throughput by allowing independent work to overlap. It does not make each individual request’s propagation delay vanish. A bounded number of outstanding requests also prevents a slow consumer from accumulating an unlimited queue.

D. A stream must be framed incrementally#

We choose a deliberately small protocol: a four-byte unsigned length in network byte order, followed by that many payload bytes. Payloads may contain any bytes, including zero. Length zero is valid; lengths above $4096$ are rejected. The length counts bytes, not Unicode characters. Text must first be encoded, for example as UTF-8, and decoded only after the complete payload is available.

The decoder maintains a buffer and either no expected payload length or one validated length. Append incoming bytes. If no length is known and at least four bytes are buffered, consume the header and validate it. If enough payload bytes are buffered, emit exactly one payload, reset to the header state, and continue: a single read may contain several messages. Otherwise stop and wait for more data. At end of stream, leftover header or payload bytes indicate truncation.

The invariant is that already emitted payloads correspond exactly to complete frames consumed from the stream prefix; the buffer contains only the unconsumed suffix. A header is consumed once, a payload is emitted once, and no payload is emitted until all its bytes are present. Length validation occurs before waiting for or allocating an attacker-declared huge payload. Our implementation accepts a caller-supplied chunk already allocated in memory; a real socket loop must also cap its read size and overall resource use.

E. Connections, HTTP, and security have distinct contracts#

A successful send or buffered write does not mean the peer has executed the operation. Reads can be short. A graceful end of stream differs from a timeout and from an application-level error response. After a protocol violation, attempting to guess where the next message begins may silently misinterpret data; this lab marks the decoder failed and requires a new instance.

HTTP supplies request methods, targets, headers, status codes, and message semantics. It does not automatically make a state-changing application safe to retry. A JSON object is a serialization format, not an authentication mechanism. TLS protects a connection’s confidentiality and integrity and supports peer authentication under a trust configuration; it does not decide whether an authenticated user is authorized to read a particular record. Project J03 deliberately omits TLS and authentication and therefore binds only to loopback. It is not an Internet service template. [HTTP][TLS]

Recognize a framing problem when the code assumes one read equals one message, splits on a delimiter that can occur inside payloads, or trusts a length before checking a limit. Recognize an application consistency problem when a request might execute twice after a timeout; that is the next module, not something TCP alone solves.

F. Worked trace: two frames across arbitrary chunks#

Encoding b"A" yields header $00\ 00\ 00\ 01$ then $41$. Encoding an empty payload yields four zero bytes. Concatenate them. After the first three bytes, no header is complete. After the fourth byte, the decoder knows a one-byte payload is expected. After byte five, it emits b"A". The next four bytes form a zero-length frame, which is emitted immediately; it must not wait for a nonexistent payload byte. Finishing now succeeds because there is neither a partial header nor an incomplete payload.

A sender that closes after the first four bytes instead has announced one payload byte but supplied none. finish() must reject this. Otherwise a truncated request could be mistaken for a clean boundary. Tests should feed the same stream whole, one byte at a time, and at every possible single split, then compare the outputs.

G. Independent practice#

F foundation C standard course work T transfer S optional stretch L runnable lab or project. Attempt the complete set before opening its solutions.

H. Complete solutions: C12#

Compare the first step where your work differs. A corrected answer is not yet an independent success.

Open every solution

"""C12.05: bounded length-prefixed framing over arbitrary byte chunks."""
import struct
MAX_PAYLOAD = 4096

def frame(payload: bytes) -> bytes:
    if len(payload) > MAX_PAYLOAD:
        raise ValueError("frame too large")
    return struct.pack(">I", len(payload)) + payload

class Decoder:
    def __init__(self):
        self._buffer = bytearray()
        self._needed: int | None = None
        self._failed = False

    def feed(self, chunk: bytes) -> list[bytes]:
        if self._failed:
            raise ValueError("decoder is failed")
        out = []
        # Consume incrementally: even a large caller chunk does not cause
        # an unbounded internal buffering allocation.
        for byte in chunk:
            self._buffer.append(byte)
            if self._needed is None and len(self._buffer) == 4:
                self._needed = struct.unpack(">I", self._buffer)[0]
                self._buffer.clear()
                if self._needed > MAX_PAYLOAD:
                    self._failed = True
                    raise ValueError("advertised frame too large")
            if self._needed is not None and len(self._buffer) == self._needed:
                out.append(bytes(self._buffer))
                self._buffer.clear()
                self._needed = None
        return out

    def finish(self) -> None:
        if self._failed or self._buffer or self._needed is not None:
            raise ValueError("truncated or invalid stream")

if __name__ == "__main__":
    d = Decoder()
    wire = frame(b"hello") + frame(b"")
    print(d.feed(wire[:3]) + d.feed(wire[3:]))
    d.finish()

I. Retention and readiness#

Retrieve C09 byte order and C10 bounded queues. Advance when you can draw the decoder state after every chunk, explain why one send need not match one read, and distinguish a transport acknowledgment from an application commit. Continue with C13 and J03 before designing a state-changing network API.