http3_pipeline.c
http-3.0/http3_pipeline.c · 297 line(s) · c
/* ==========================================================================
* http3_pipeline.c -- implementation of the HTTP 3.0 §19 processing pipeline
* and §9 retry classes. Ties the envelope (§5) and fast naming (§4) into a
* short, traceable hot path with a service/op dispatch table.
* ========================================================================== */
#include "http3_pipeline.h"
#include "http3_intactx.h"
#include <string.h>
void http3_pipeline_init(http3_pipeline_t *pipe)
{
if (pipe == NULL) {
return;
}
memset(pipe, 0, sizeof(*pipe));
http3_naming_init(&pipe->naming);
pipe->intactx_threshold = HTTP3_INTACTX_TAMPER_THRESHOLD;
http3_timing_init(&pipe->timing);
}
void http3_pipeline_set_intactx_threshold(http3_pipeline_t *pipe, uint16_t threshold)
{
if (pipe == NULL) {
return;
}
pipe->intactx_threshold = (threshold == 0u) ? HTTP3_INTACTX_TAMPER_THRESHOLD
: threshold;
}
void http3_pipeline_set_mac_key(http3_pipeline_t *pipe,
const uint8_t key[HTTP3_MAC_KEY_BYTES])
{
if (pipe == NULL || key == NULL) {
return;
}
memcpy(pipe->mac_key, key, HTTP3_MAC_KEY_BYTES);
}
void http3_pipeline_reset_replay_window(http3_pipeline_t *pipe, uint64_t start)
{
if (pipe == NULL) {
return;
}
pipe->nonce_high_water = start;
}
void http3_pipeline_set_timing(http3_pipeline_t *pipe,
uint64_t min_gap_ns,
uint64_t lateness_ns,
uint64_t balance_ns)
{
if (pipe == NULL) {
return;
}
http3_timing_configure(&pipe->timing, min_gap_ns, lateness_ns, balance_ns);
}
unsigned http3_pipeline_observe_timing(http3_pipeline_t *pipe,
uint64_t arrival_ns,
uint64_t deadline_ns)
{
unsigned flags;
if (pipe == NULL) {
return HTTP3_TIMING_OK;
}
flags = http3_timing_observe(&pipe->timing, arrival_ns, deadline_ns);
/* Advisory: never rejects; just tally the concerns. */
if (flags & HTTP3_TIMING_LATE) { ++pipe->late_packets; }
if (flags & HTTP3_TIMING_OVER_RATE) { ++pipe->over_rate_packets; }
if (flags & HTTP3_TIMING_UNBALANCED) { ++pipe->unbalanced_packets; }
return flags;
}
double http3_pipeline_carrier_certainty(const http3_pipeline_t *pipe)
{
return (pipe != NULL) ? http3_timing_certainty(&pipe->timing) : 0.0;
}
static http3_service_binding_t *find_binding(http3_pipeline_t *pipe, uint32_t service_id)
{
size_t i;
for (i = 0; i < pipe->service_count; ++i) {
if (pipe->services[i].service_id == service_id) {
return &pipe->services[i];
}
}
return NULL;
}
uint32_t http3_pipeline_register_service(http3_pipeline_t *pipe,
const char *service_name,
void *ctx)
{
uint32_t sid;
http3_service_binding_t *b;
if (pipe == NULL) {
return 0u;
}
sid = http3_naming_intern_service(&pipe->naming, service_name);
if (sid == 0u) {
return 0u;
}
b = find_binding(pipe, sid);
if (b != NULL) {
b->ctx = ctx; /* re-registration updates context */
return sid;
}
if (pipe->service_count >= HTTP3_MAX_SERVICES) {
return 0u;
}
b = &pipe->services[pipe->service_count++];
b->service_id = sid;
b->ctx = ctx;
b->op_count = 0u;
return sid;
}
uint32_t http3_pipeline_register_op(http3_pipeline_t *pipe,
const char *service_name,
const char *op_name,
http3_retry_class_t retry_class,
http3_op_handler_t handler)
{
uint32_t sid, oid;
http3_service_binding_t *b;
size_t i;
if (pipe == NULL || handler == NULL) {
return 0u;
}
sid = http3_pipeline_register_service(pipe, service_name, NULL);
if (sid == 0u) {
return 0u;
}
oid = http3_naming_intern_op(&pipe->naming, service_name, op_name);
if (oid == 0u) {
return 0u;
}
b = find_binding(pipe, sid);
if (b == NULL) {
return 0u;
}
for (i = 0; i < b->op_count; ++i) {
if (b->ops[i].op_id == oid) {
b->ops[i].retry_class = retry_class; /* update existing */
b->ops[i].handler = handler;
return oid;
}
}
if (b->op_count >= HTTP3_MAX_OPS_PER_SVC) {
return 0u;
}
b->ops[b->op_count].op_id = oid;
b->ops[b->op_count].retry_class = retry_class;
b->ops[b->op_count].handler = handler;
++b->op_count;
return oid;
}
static const http3_op_binding_t *find_op(const http3_service_binding_t *b, uint32_t op_id)
{
size_t i;
for (i = 0; i < b->op_count; ++i) {
if (b->ops[i].op_id == op_id) {
return &b->ops[i];
}
}
return NULL;
}
int http3_pipeline_retry_class(const http3_pipeline_t *pipe,
uint32_t service_id, uint32_t op_id)
{
size_t i;
if (pipe == NULL) {
return -1;
}
for (i = 0; i < pipe->service_count; ++i) {
if (pipe->services[i].service_id == service_id) {
const http3_op_binding_t *op = find_op(&pipe->services[i], op_id);
return op != NULL ? (int)op->retry_class : -1;
}
}
return -1;
}
int http3_pipeline_dispatch(http3_pipeline_t *pipe,
const http3_envelope_t *env,
http3_response_t *resp)
{
http3_service_binding_t *b;
const http3_op_binding_t *op;
if (pipe == NULL || env == NULL || resp == NULL) {
return -1;
}
memset(resp, 0, sizeof(*resp));
resp->request_id = env->request_id; /* echo REQUEST-ID (§6/§7) */
/* §19: service-id lookup */
b = find_binding(pipe, env->service_id);
if (b == NULL) {
resp->status = HTTP3_STATUS_UNKNOWN_SVC;
return 0;
}
/* §19: operation-id lookup */
op = find_op(b, env->op_id);
if (op == NULL) {
resp->status = HTTP3_STATUS_UNKNOWN_OP;
return 0;
}
/* §9: a MUTATING op replayed without an idempotency assertion is refused.
* Here the caller signals a safe replay via the IDEMPOTENT flag. */
if (op->retry_class == HTTP3_RETRY_MUTATING &&
(env->flags & HTTP3_FLAG_IDEMPOTENT) == 0u) {
/* First delivery is always allowed; this guard is where a real
* connector would consult an idempotency-key store on retry. The
* reference pipeline admits it and lets business logic run, but the
* decision point is explicit and traceable. */
}
/* §19: SLeeLa dispatch -> business logic -> compact result pack */
resp->status = op->handler(env->payload, env->payload_len,
resp->result, sizeof(resp->result),
&resp->result_len, b->ctx);
++pipe->requests_handled;
return 0;
}
int http3_pipeline_handle_wire(http3_pipeline_t *pipe,
const uint8_t *wire, size_t wire_len,
char *out, size_t out_cap, size_t *written)
{
http3_envelope_t env;
http3_response_t resp;
int parsed;
if (pipe == NULL || wire == NULL || out == NULL) {
return -1;
}
/* §19: minimal parse. Auto-detect wire form: textual envelopes begin with
* the ASCII tag "H3 "; anything else is treated as binary. */
if (wire_len >= 3u && wire[0] == 'H' && wire[1] == '3' && wire[2] == ' ') {
parsed = http3_envelope_unpack_text((const char *)wire, wire_len, &env);
} else {
parsed = http3_envelope_unpack_binary(wire, wire_len, &env);
}
if (parsed != 0) {
/* Bad envelope: produce a response with no correlatable request id. */
memset(&resp, 0, sizeof(resp));
resp.status = HTTP3_STATUS_BAD_ENVELOPE;
return http3_response_pack_text(&resp, out, out_cap, written);
}
/* §19 integrity gate, before any dispatch:
* 1. Per-packet DIGEST (keyed MAC) must verify under the per-connection
* key -- else the packet was corrupted OR forged by a party without
* the shared secret. */
if (!http3_envelope_verify_digest(&env, pipe->mac_key)) {
memset(&resp, 0, sizeof(resp));
resp.status = HTTP3_STATUS_BAD_DIGEST;
resp.request_id = env.request_id; /* best-effort correlation */
++pipe->digest_rejects;
return http3_response_pack_text(&resp, out, out_cap, written);
}
/* 2. INTACTX variance must be below threshold -- else the emitting host
* has been tampered with / changed materially: RESET the exchange and
* do NOT dispatch. */
if (http3_intactx_is_tampered(env.intactx, pipe->intactx_threshold)) {
memset(&resp, 0, sizeof(resp));
resp.status = HTTP3_STATUS_TAMPERED;
resp.request_id = env.request_id;
/* RESET marker in the result body; the request-side flag is
* HTTP3_FLAG_RESET for a peer that echoes envelope flags. */
memcpy(resp.result, "RESET", 5);
resp.result_len = 5;
++pipe->tamper_resets;
return http3_response_pack_text(&resp, out, out_cap, written);
}
/* 3. NONCE must be strictly ahead of the high-water mark -- else this is
* a replay of a previously valid (and validly MAC'd) packet. Because
* the NONCE is inside the MAC, an attacker cannot bump it to slip a
* replay past this check without invalidating the DIGEST above. */
if (env.nonce <= pipe->nonce_high_water) {
memset(&resp, 0, sizeof(resp));
resp.status = HTTP3_STATUS_REPLAYED;
resp.request_id = env.request_id;
++pipe->replays_rejected;
return http3_response_pack_text(&resp, out, out_cap, written);
}
pipe->nonce_high_water = env.nonce; /* advance the window */
if (http3_pipeline_dispatch(pipe, &env, &resp) != 0) {
return -1;
}
/* §19: HTTP response (compact, textual here for interoperability) */
return http3_response_pack_text(&resp, out, out_cap, written);
}