socket

Allocates an unbound, unconnected AF_INET/SOCK_STREAM fd; you must follow up with bind()+listen() or connect() before it can carry data, and close() it when done.

Lets a subsequent bind() reuse a local address still lingering in TIME_WAIT, so a restarted server can re-listen on the same port immediately; call it before bind().

Resolves host via getaddrinfo and assigns the resulting local address to the socket; a resolution failure returns -1 with errno set to EADDRNOTAVAIL (see the ResolveFailure test).

Switches an already-bound socket into the listening state so accept() can pull connections from it; backlog caps how many fully-established connections may queue before new ones are refused.

Resolves host and blocks until the TCP handshake succeeds or fails; a refused connection returns -1 with errno ECONNREFUSED (see the ConnectRefused test). Unlike tcp_connect() it does not close the fd on failure — the caller still owns fd.

Blocks until a client connects, then returns a new fd for that one connection (the listening fd stays open for further accepts). The returned client fd is owned by the caller and must be closed separately; the peer address is discarded.

Reads the address actually assigned via getsockname and returns its port in host byte order; this is the way to discover the ephemeral port the OS chose when you bound to port 0.

Issues a single send, which may transmit fewer bytes than supplied (a partial send); the caller is responsible for re-sending the remainder, or use sendall() to loop automatically.

Repeatedly calls send on the unsent remainder until every byte is written, so unlike send() there are no partial sends to handle; it aborts with -1 the moment a send returns <= 0 (error or peer hang-up), in which case some bytes may already have been transmitted.

Blocks for one recv and returns whatever bytes arrive (possibly fewer than bufsize); the result is binary-safe, so a returned string may contain embedded NULs and its length is the true byte count. A clean EOF (peer closed) and an error both yield "", so check last_error() to tell them apart; bufsize <= 0 also returns "" without touching the socket.

Releases the fd back to the OS; after this the fd is invalid and must not be reused. Closing an already-closed or never-opened fd fails with -1 (EBADF), which is how the BadFd test exercises the error path.

A blocking recv() on another thread returns immediately (EOF) — the safe way to wake a reader for a clean shutdown. The fd is still owned by the caller and must be close()d afterwards.

Performs socket()/set_reuseaddr/bind/listen in one shot; on any failure it closes the partially-created socket and returns -1, so the caller never leaks an fd. On success the returned fd is owned by the caller and must be passed to close() when done.

The host is resolved via getaddrinfo, so names, "localhost", and dotted IPs all work; the connect blocks until the handshake completes or fails. On failure the socket is closed and -1 is returned; on success the caller owns the connected fd and must close() it.

Unbound until bind; a client that only sends needs no bind (the kernel picks a port on the first sendto).

What a datagram is for: data whose NEXT packet supersedes this one — a presence pose, a live drag, a simulation snapshot. It may be dropped, duplicated or reordered by the network and the receiver must be written for that (newest-wins by stamp); nothing here acks, retries or orders. Everything that must arrive rides TCP (tcp_connect).

The whole of data is one packet: keep it under the path MTU (1200 bytes is safe on the public internet, 65507 the absolute cap).

Blocks until a packet arrives, or until set_timeout's window passes (an empty string, out_port 0).

A recv that times out returns "" (check last_error() to distinguish from EOF). timeout_ms <= 0 clears the timeouts (block forever).

Returns the human-readable text for the thread's current errno; call it right after a function reports failure (a -1 return, or "" from recv), since any later syscall may overwrite errno.