Home /Modules/http-2.0/h21_envelope.c

h21_envelope.c

http-2.0/h21_envelope.c · 209 line(s) · c

/* ==========================================================================
 * h21_envelope.c -- HTTP 2.1 compact envelope + response model (SKETCH).
 * Pure data: no I/O, no crypto, no allocation. The 2.1 core mirrors HTTP 3.0's
 * design goals without the 3.0-era per-packet integrity additions.
 * ========================================================================== */
#include "h21_envelope.h"

#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <limits.h>

int h21_envelope_init(h21_envelope_t *env,
                      uint32_t service_id,
                      uint32_t op_id,
                      uint64_t request_id,
                      uint8_t flags,
                      const uint8_t *payload,
                      size_t payload_len)
{
    if (env == NULL || payload_len > H21_ENVELOPE_MAX_PAYLOAD) {
        return -1;
    }
    memset(env, 0, sizeof(*env));
    env->version = H21_ENVELOPE_VERSION;
    env->flags = flags;
    env->service_id = service_id;
    env->op_id = op_id;
    env->request_id = request_id;
    if (payload != NULL && payload_len > 0U) {
        memcpy(env->payload, payload, payload_len);
    }
    env->payload_len = payload_len;
    return 0;
}

/* ---- Textual envelope ----------------------------------------------------- */

int h21_envelope_pack_text(const h21_envelope_t *env, char *out, size_t out_cap, size_t *written)
{
    int n;
    size_t pos;
    if (env == NULL || out == NULL || env->payload_len > H21_ENVELOPE_MAX_PAYLOAD) {
        return -1;
    }
    n = snprintf(out, out_cap, "H21 %u %u %u %u %llu %zu:",
                 (unsigned)env->version, (unsigned)env->flags,
                 (unsigned)env->service_id, (unsigned)env->op_id,
                 (unsigned long long)env->request_id, env->payload_len);
    if (n < 0 || (size_t)n >= out_cap) {
        return -1;
    }
    pos = (size_t)n;
    if (pos + env->payload_len + 1U > out_cap) {
        return -1;
    }
    memcpy(out + pos, env->payload, env->payload_len);
    pos += env->payload_len;
    out[pos++] = '\n';
    if (written != NULL) {
        *written = pos;
    }
    return 0;
}

int h21_envelope_unpack_text(const char *in,size_t in_len,h21_envelope_t *env)
{
    char header[160]; unsigned long long ver,flags,sid,oid,rid,plen; int used=0;
    if(!in||!env||!in_len)return -1;
    const char *colon=(const char *)memchr(in,':',in_len);
    if(!colon)return -1;
    size_t hlen=(size_t)(colon-in);
    if(!hlen||hlen>=sizeof(header))return -1;
    memcpy(header,in,hlen);header[hlen]='\0';
    if(sscanf(header,"H21 %llu %llu %llu %llu %llu %llu%n",&ver,&flags,&sid,&oid,&rid,&plen,&used)!=6||
       used<=0||(size_t)used!=hlen)return -1;
    const char *p=header+4; char *end=NULL;
    while(*p){while(*p==' ')++p;if(!*p)break;(void)strtoull(p,&end,10);
        if(end==p||(*end!=' '&&*end!='\0'))return -1;
        for(const char *q=p;q<end;++q)if(*q<'0'||*q>'9')return -1;p=end;}
    if(ver!=H21_ENVELOPE_VERSION||flags>UINT8_MAX||
       (flags&~(unsigned long long)(H21_FLAG_BINARY|H21_FLAG_COMPRESSED|H21_FLAG_IDEMPOTENT))||
       sid>UINT32_MAX||oid>UINT32_MAX||plen>H21_ENVELOPE_MAX_PAYLOAD)return -1;
    size_t rem=in_len-hlen-1u;
    if(rem!=(size_t)plen&&!(rem==(size_t)plen+1u&&in[in_len-1u]=='\n'))return -1;
    memset(env,0,sizeof(*env));env->version=(uint8_t)ver;env->flags=(uint8_t)flags;
    env->service_id=(uint32_t)sid;env->op_id=(uint32_t)oid;env->request_id=(uint64_t)rid;
    env->payload_len=(size_t)plen;if(plen)memcpy(env->payload,colon+1,(size_t)plen);
    return 0;
}

/* ---- Binary envelope (big-endian header) ---------------------------------- */

static void put_u32(uint8_t *b, uint32_t v)
{
    b[0] = (uint8_t)(v >> 24); b[1] = (uint8_t)(v >> 16);
    b[2] = (uint8_t)(v >> 8);  b[3] = (uint8_t)v;
}
static void put_u64(uint8_t *b, uint64_t v)
{
    b[0] = (uint8_t)(v >> 56); b[1] = (uint8_t)(v >> 48);
    b[2] = (uint8_t)(v >> 40); b[3] = (uint8_t)(v >> 32);
    b[4] = (uint8_t)(v >> 24); b[5] = (uint8_t)(v >> 16);
    b[6] = (uint8_t)(v >> 8);  b[7] = (uint8_t)v;
}
static uint32_t get_u32(const uint8_t *b)
{
    return ((uint32_t)b[0] << 24) | ((uint32_t)b[1] << 16) |
           ((uint32_t)b[2] << 8)  |  (uint32_t)b[3];
}
static uint64_t get_u64(const uint8_t *b)
{
    return ((uint64_t)b[0] << 56) | ((uint64_t)b[1] << 48) |
           ((uint64_t)b[2] << 40) | ((uint64_t)b[3] << 32) |
           ((uint64_t)b[4] << 24) | ((uint64_t)b[5] << 16) |
           ((uint64_t)b[6] << 8)  |  (uint64_t)b[7];
}

int h21_envelope_pack_binary(const h21_envelope_t *env, uint8_t *out, size_t out_cap, size_t *written)
{
    if (env == NULL || out == NULL || env->payload_len > H21_ENVELOPE_MAX_PAYLOAD ||
        out_cap < H21_ENVELOPE_BIN_HEADER + env->payload_len) {
        return -1;
    }
    out[0] = env->version;
    out[1] = (uint8_t)(env->flags | H21_FLAG_BINARY);
    put_u32(out + 2, env->service_id);
    put_u32(out + 6, env->op_id);
    put_u64(out + 10, env->request_id);
    put_u32(out + 18, (uint32_t)env->payload_len);
    memcpy(out + H21_ENVELOPE_BIN_HEADER, env->payload, env->payload_len);
    if (written != NULL) {
        *written = H21_ENVELOPE_BIN_HEADER + env->payload_len;
    }
    return 0;
}

int h21_envelope_unpack_binary(const uint8_t *in,size_t in_len,h21_envelope_t *env)
{
    uint32_t n;
    if(!in||!env||in_len<H21_ENVELOPE_BIN_HEADER||in[0]!=H21_ENVELOPE_VERSION||
       (in[1]&(uint8_t)~(H21_FLAG_BINARY|H21_FLAG_COMPRESSED|H21_FLAG_IDEMPOTENT)))return -1;
    n=get_u32(in+18);
    if(n>H21_ENVELOPE_MAX_PAYLOAD||in_len!=(size_t)H21_ENVELOPE_BIN_HEADER+(size_t)n)return -1;
    memset(env,0,sizeof(*env));env->version=in[0];
    env->flags=(uint8_t)(in[1]&(uint8_t)~H21_FLAG_BINARY);
    env->service_id=get_u32(in+2);env->op_id=get_u32(in+6);env->request_id=get_u64(in+10);
    env->payload_len=n;if(n)memcpy(env->payload,in+H21_ENVELOPE_BIN_HEADER,n);
    return 0;
}

/* ---- Response ------------------------------------------------------------- */

int h21_response_pack_text(const h21_response_t *resp, char *out, size_t out_cap, size_t *written)
{
    int n;
    size_t pos;
    if (resp == NULL || out == NULL || resp->result_len > H21_ENVELOPE_MAX_PAYLOAD) {
        return -1;
    }
    n = snprintf(out, out_cap, "H21R %d %llu %zu:",
                 (int)resp->status, (unsigned long long)resp->request_id, resp->result_len);
    if (n < 0 || (size_t)n >= out_cap) {
        return -1;
    }
    pos = (size_t)n;
    if (pos + resp->result_len + 1U > out_cap) {
        return -1;
    }
    memcpy(out + pos, resp->result, resp->result_len);
    pos += resp->result_len;
    out[pos++] = '\n';
    if (written != NULL) {
        *written = pos;
    }
    return 0;
}

int h21_response_unpack_text(const char *in,size_t in_len,h21_response_t *resp)
{
    char header[128];unsigned long long status,rid,n;int used=0;
    if(!in||!resp||!in_len)return -1;
    const char *colon=(const char *)memchr(in,':',in_len);if(!colon)return -1;
    size_t hlen=(size_t)(colon-in);if(!hlen||hlen>=sizeof(header))return -1;
    memcpy(header,in,hlen);header[hlen]='\0';
    if(sscanf(header,"H21R %llu %llu %llu%n",&status,&rid,&n,&used)!=3||
       used<=0||(size_t)used!=hlen||status>H21_STATUS_RETRY_DENIED||n>H21_ENVELOPE_MAX_PAYLOAD)return -1;
    size_t rem=in_len-hlen-1u;
    if(rem!=(size_t)n&&!(rem==(size_t)n+1u&&in[in_len-1u]=='\n'))return -1;
    memset(resp,0,sizeof(*resp));resp->status=(h21_status_t)status;
    resp->request_id=(uint64_t)rid;resp->result_len=(size_t)n;
    if(n)memcpy(resp->result,colon+1,(size_t)n);
    return 0;
}

const char *h21_status_name(h21_status_t status)
{
    switch (status) {
        case H21_STATUS_OK:           return "OK";
        case H21_STATUS_APP_ERROR:    return "APP_ERROR";
        case H21_STATUS_UNKNOWN_SVC:  return "UNKNOWN_SERVICE";
        case H21_STATUS_UNKNOWN_OP:   return "UNKNOWN_OPERATION";
        case H21_STATUS_BAD_ENVELOPE: return "BAD_ENVELOPE";
        case H21_STATUS_TOO_LARGE:    return "TOO_LARGE";
        case H21_STATUS_RETRY_DENIED: return "RETRY_DENIED";
        default:                      return "UNKNOWN";
    }
}