Home /Modules/http-4.0/http4_segmentation.c

http4_segmentation.c

http-4.0/http4_segmentation.c · 153 line(s) · c

#include "http4_segmentation.h"

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

static void put16(uint8_t *p, uint16_t v) {
    p[0] = (uint8_t)(v >> 8); p[1] = (uint8_t)v;
}
static void put32(uint8_t *p, uint32_t v) {
    p[0] = (uint8_t)(v >> 24); p[1] = (uint8_t)(v >> 16);
    p[2] = (uint8_t)(v >> 8); p[3] = (uint8_t)v;
}
static void put64(uint8_t *p, uint64_t v) {
    for (int i = 7; i >= 0; --i) { p[i] = (uint8_t)v; v >>= 8; }
}
static uint16_t get16(const uint8_t *p) {
    return (uint16_t)(((uint16_t)p[0] << 8) | p[1]);
}
static uint32_t get32(const uint8_t *p) {
    return ((uint32_t)p[0] << 24) | ((uint32_t)p[1] << 16) |
           ((uint32_t)p[2] << 8) | p[3];
}
static uint64_t get64(const uint8_t *p) {
    uint64_t v = 0;
    for (int i = 0; i < 8; ++i) v = (v << 8) | p[i];
    return v;
}

size_t http4_segment_count(size_t total_length, size_t mtu) {
    if (mtu <= HTTP4_FRAME_HEADER_SIZE + HTTP4_SEGMENT_HEADER_SIZE) return 0;
    const size_t capacity = mtu - HTTP4_FRAME_HEADER_SIZE - HTTP4_SEGMENT_HEADER_SIZE;
    if (total_length == 0) return 1;
    return 1u + ((total_length - 1u) / capacity);
}

int http4_segment_frame_encode(uint64_t stream_id,
                               uint64_t request_id,
                               uint64_t sequence,
                               uint64_t segment_id,
                               uint32_t segment_index,
                               const uint8_t *data,
                               size_t total_length,
                               size_t mtu,
                               uint8_t *out,
                               size_t out_size,
                               size_t *written) {
    if (!out || !written) return -1;
    if (total_length > UINT32_MAX) return -2;

    const size_t count = http4_segment_count(total_length, mtu);
    if (count == 0 || count > UINT32_MAX || segment_index >= count) return -3;

    const size_t capacity = mtu - HTTP4_FRAME_HEADER_SIZE - HTTP4_SEGMENT_HEADER_SIZE;
    if ((size_t)segment_index > (SIZE_MAX / capacity)) return -4;
    const size_t offset = (size_t)segment_index * capacity;
    if (offset > total_length) return -5;

    size_t data_length = total_length - offset;
    if (data_length > capacity) data_length = capacity;
    if (data_length && !data) return -6;
    if (sequence > UINT64_MAX - (uint64_t)segment_index) return -7;

    const uint8_t segment_flags =
        (uint8_t)((segment_index == 0 ? HTTP4_SEGMENT_FLAG_FIRST : 0) |
                  ((size_t)segment_index + 1u == count ? HTTP4_SEGMENT_FLAG_LAST : 0));

    const size_t payload_length = HTTP4_SEGMENT_HEADER_SIZE + data_length;
    if (payload_length > HTTP4_MAX_PAYLOAD ||
        out_size < HTTP4_FRAME_HEADER_SIZE + payload_length) return -8;

    http4_frame_header_t frame = {
        HTTP4_VERSION,
        HTTP4_FRAME_DATA,
        (uint16_t)(HTTP4_FLAG_INCREMENTAL | HTTP4_FLAG_RESUMABLE |
                   ((segment_flags & HTTP4_SEGMENT_FLAG_LAST) ? HTTP4_FLAG_FIN : 0)),
        stream_id,
        request_id,
        sequence + segment_index,
        (uint32_t)payload_length
    };

    /* Encode the fixed HTTP4 header directly because the payload is assembled
       in-place below; this preserves the protocol encoder's no-alias contract. */
    out[0] = frame.version;
    out[1] = frame.type;
    put16(out + 2, frame.flags);
    put64(out + 4, frame.stream_id);
    put64(out + 12, frame.request_id);
    put64(out + 20, frame.sequence);
    put32(out + 28, frame.payload_length);

    uint8_t *p = out + HTTP4_FRAME_HEADER_SIZE;
    put32(p + 0, HTTP4_SEGMENT_MAGIC);
    p[4] = HTTP4_SEGMENT_VERSION;
    p[5] = segment_flags;
    put16(p + 6, 0);
    put64(p + 8, segment_id);
    put32(p + 16, segment_index);
    put32(p + 20, (uint32_t)count);
    put32(p + 24, (uint32_t)total_length);
    put32(p + 28, (uint32_t)offset);
    if (data_length) memcpy(p + HTTP4_SEGMENT_HEADER_SIZE, data + offset, data_length);

    *written = HTTP4_FRAME_HEADER_SIZE + payload_length;
    return 0;
}

int http4_segment_frame_decode(const uint8_t *wire,
                               size_t wire_size,
                               http4_frame_view_t *frame,
                               http4_segment_view_t *segment,
                               size_t *consumed) {
    if (!wire || !frame || !segment || !consumed) return -1;

    size_t used = 0;
    if (http4_frame_decode(wire, wire_size, frame, &used) != 0) return -2;
    if (frame->header.type != HTTP4_FRAME_DATA ||
        frame->header.payload_length < HTTP4_SEGMENT_HEADER_SIZE) return -3;

    const uint8_t *p = frame->payload;
    http4_segment_header_t h;
    h.magic = get32(p + 0);
    h.version = p[4];
    h.flags = p[5];
    h.reserved = get16(p + 6);
    h.segment_id = get64(p + 8);
    h.segment_index = get32(p + 16);
    h.segment_count = get32(p + 20);
    h.total_length = get32(p + 24);
    h.offset = get32(p + 28);
    h.data_length = frame->header.payload_length - HTTP4_SEGMENT_HEADER_SIZE;

    if (h.magic != HTTP4_SEGMENT_MAGIC || h.version != HTTP4_SEGMENT_VERSION) return -4;
    if (h.reserved != 0 || h.segment_count == 0 || h.segment_index >= h.segment_count) return -5;
    if (h.data_length > h.total_length || h.offset > h.total_length ||
        h.data_length > h.total_length - h.offset) return -6;

    if ((h.flags & ~(HTTP4_SEGMENT_FLAG_FIRST | HTTP4_SEGMENT_FLAG_LAST)) != 0) return -7;
    if (((h.flags & HTTP4_SEGMENT_FLAG_FIRST) != 0) != (h.segment_index == 0)) return -8;
    if (((h.flags & HTTP4_SEGMENT_FLAG_LAST) != 0) !=
        ((uint64_t)h.segment_index + 1u == h.segment_count)) return -9;
    if (((h.flags & HTTP4_SEGMENT_FLAG_LAST) != 0) !=
        ((frame->header.flags & HTTP4_FLAG_FIN) != 0)) return -10;

    segment->header = h;
    segment->stream_id = frame->header.stream_id;
    segment->request_id = frame->header.request_id;
    segment->sequence = frame->header.sequence;
    segment->data = p + HTTP4_SEGMENT_HEADER_SIZE;
    *consumed = used;
    return 0;
}