Serving

Called on whichever thread produced the line, including application polling threads. The callback must be thread-safe and return quickly.

UCall writes nothing anywhere on its own: every line goes to callback, and without one the library stays silent.

An interface is an address the server answers on, together with the security posture and admission limits for the connections it accepts. Several of them live under one server, which is what lets a single server answer VPN-internal Noise traffic and public plaintext at once, across as many physical devices as the machine has.

Encryption and admission live on the interface rather than on the server, so one server serves plaintext on loopback for health checks while requiring Noise on the wire - without standing up a second server to do it.

Only the loop's polling owner advances them. Byte counters cover the bytes UCall itself moves, never the copies the kernel makes between socket buffers and user memory.

Only the endpoint's polling owner advances them. Batches released by a stop fire no callback and count nowhere.

Does nothing for NULL.

The first call drains: the server stops accepting, closes idle connections, and answers the requests it already holds with connection: close, closing each connection after its last reply. Polling callers return once their loop has no connection left, and batch polling owners once every loop has returned. Any later call, or ucall_server_free(), cuts instead: replies still in flight are abandoned and their peers reset.

Safe from an endpoint callback or a separate thread.

Callbacks run synchronously; the timeout cannot preempt them.

Each counter is read on its own, so a snapshot of a running loop is not one instant.

Each counter is read on its own, so a snapshot of a polled endpoint is not one instant.

The uri_template field supports URI template syntax (RFC 6570 subset):

• "/users/{id}" matches "/users/123" or "/users/abc"
• "/posts/{year}/{month}" matches "/posts/2024/03"
• "/files/{*path}" matches "/files/a/b/c.txt" (greedy, captures "a/b/c.txt")

Routing precedence: Literals match before template variables, before greedy wildcards.

Very handy for batch-processing and high-latency operations (e.g., GPU inference).

Unlike client-side batching, which packs several calls into one request, the server aggregates independent requests from different sources and dispatches them together.

Batching behavior:

• Batch size < min_batch_size: Wait for more requests (up to max_latency_microseconds).
• Batch size >= min_batch_size: Dispatch immediately (optimal utilization).
• Batch size >= max_batch_size: Force dispatch (prevent unbounded growth).

Requests from every event loop share one queue per batch endpoint. The callback receives a counted array of request handles on the thread polling that endpoint through ucall_server_take_batch() or ucall_server_take_batches(), never on an event loop. Registration returns the endpoint's handle, so each endpoint can have its own polling thread. Copy the request handles into application-owned storage to process them later; received bytes need no copy.