msgpack.cpp

Go to the documentation of this file.

// Copyright (C) 2026 Douglas Quigg (dstroy0) <dquigg123@gmail.com>
// SPDX-License-Identifier: AGPL-3.0-or-later
 
/**
 * @file msgpack.cpp
 * @brief Zero-heap MessagePack encoder and decoder implementation.
 */
 
#include "msgpack.h"
 
#if PC_ENABLE_MSGPACK
 
#include "shared_primitives/bytes.h"
#include <string.h>
 
// Thin local names over the shared byte verbs (bytes.h) so the call sites
// below read the same as before; the cursor invariants live in one place.
static void put(pc_span *w, uint8_t b)
{
    pc_bw_put(w, b);
}
 
// Write the low @p nbytes of @p val, big-endian (MessagePack is network order).
static void put_be(pc_span *w, uint64_t val, int32_t nbytes)
{
    pc_bw_put_be(w, val, nbytes);
}
 
void pc_msgpack_uint(pc_span *w, uint64_t v)
{
    if (v <= 0x7f)
    {
        put(w, (uint8_t)v); // positive fixint
    }
    else if (v <= 0xff)
    {
        put(w, 0xcc);
        put(w, (uint8_t)v);
    }
    else if (v <= 0xffff)
    {
        put(w, 0xcd);
        put_be(w, v, 2);
    }
    else if (v <= 0xffffffffULL)
    {
        put(w, 0xce);
        put_be(w, v, 4);
    }
    else
    {
        put(w, 0xcf);
        put_be(w, v, 8);
    }
}
 
void pc_msgpack_int(pc_span *w, int64_t v)
{
    if (v >= 0)
    {
        pc_msgpack_uint(w, (uint64_t)v);
        return;
    }
    if (v >= -32)
    {
        put(w, (uint8_t)v); // negative fixint (two's-complement byte 0xe0..0xff)
    }
    else if (v >= -128)
    {
        put(w, 0xd0);
        put(w, (uint8_t)v);
    }
    else if (v >= -32768)
    {
        put(w, 0xd1);
        put_be(w, (uint64_t)(uint16_t)v, 2);
    }
    else if (v >= -2147483648LL)
    {
        put(w, 0xd2);
        put_be(w, (uint64_t)(uint32_t)v, 4);
    }
    else
    {
        put(w, 0xd3);
        put_be(w, (uint64_t)v, 8);
    }
}
 
void pc_msgpack_str_n(pc_span *w, const char *s, size_t len)
{
    if (len <= 31)
    {
        put(w, (uint8_t)(0xa0 | len)); // fixstr
    }
    else if (len <= 0xff)
    {
        put(w, 0xd9);
        put(w, (uint8_t)len);
    }
    else if (len <= 0xffff)
    {
        put(w, 0xda);
        put_be(w, len, 2);
    }
    else
    {
        put(w, 0xdb);
        put_be(w, len, 4);
    }
    for (size_t i = 0; i < len; i++)
    {
        put(w, (uint8_t)s[i]);
    }
}
 
void pc_msgpack_str(pc_span *w, const char *s)
{
    pc_msgpack_str_n(w, s, s ? strnlen(s, w->cap + 1) : 0);
}
 
void pc_msgpack_bytes(pc_span *w, const uint8_t *data, size_t len)
{
    if (len <= 0xff)
    {
        put(w, 0xc4);
        put(w, (uint8_t)len);
    }
    else if (len <= 0xffff)
    {
        put(w, 0xc5);
        put_be(w, len, 2);
    }
    else
    {
        put(w, 0xc6);
        put_be(w, len, 4);
    }
    for (size_t i = 0; i < len; i++)
    {
        put(w, data[i]);
    }
}
 
void pc_msgpack_bool(pc_span *w, bool b)
{
    put(w, b ? 0xc3 : 0xc2);
}
 
void pc_msgpack_null(pc_span *w)
{
    put(w, 0xc0);
}
 
void pc_msgpack_float(pc_span *w, float f)
{
    uint32_t bits;
    memcpy(&bits, &f, sizeof(bits));
    put(w, 0xca); // float32
    put_be(w, bits, 4);
}
 
void pc_msgpack_array(pc_span *w, size_t count)
{
    if (count <= 15)
    {
        put(w, (uint8_t)(0x90 | count)); // fixarray
    }
    else if (count <= 0xffff)
    {
        put(w, 0xdc);
        put_be(w, count, 2);
    }
    else
    {
        put(w, 0xdd);
        put_be(w, count, 4);
    }
}
 
void pc_msgpack_map(pc_span *w, size_t count)
{
    if (count <= 15)
    {
        put(w, (uint8_t)(0x80 | count)); // fixmap
    }
    else if (count <= 0xffff)
    {
        put(w, 0xde);
        put_be(w, count, 2);
    }
    else
    {
        put(w, 0xdf);
        put_be(w, count, 4);
    }
}
 
void pc_msgpack_label(pc_span *w, const char *name, int64_t num)
{
    (void)name; // the binary packs carry the integer label form, as CBOR does
    pc_msgpack_int(w, num);
}
 
// ---------------------------------------------------------------------------
// Decoder
// ---------------------------------------------------------------------------
 
// Read @p nbytes big-endian immediately after the format byte at r->pos, advancing
// past the format byte and the argument (shared byte cursor, bytes.h).
static bool take_be(pc_cspan *r, size_t nbytes, uint64_t *out)
{
    return pc_br_take_be(r, nbytes, out);
}
 
pc_codec_type pc_msgpack_peek(pc_cspan *r)
{
    if (r->err || r->pos >= r->len)
    {
        return pc_codec_type::PC_CODEC_INVALID;
    }
    uint8_t b = r->buf[r->pos];
    if (b <= 0x7f)
    {
        return pc_codec_type::PC_CODEC_UINT; // positive fixint
    }
    if (b >= 0xe0)
    {
        return pc_codec_type::PC_CODEC_INT; // negative fixint
    }
    // b is now in [0x80, 0xdf]; each fix* range's lower bound is already
    // established by the preceding checks, so test only the ascending upper bound.
    if (b <= 0x8f)
    {
        return pc_codec_type::PC_CODEC_MAP; // fixmap   (0x80-0x8f)
    }
    if (b <= 0x9f)
    {
        return pc_codec_type::PC_CODEC_ARRAY; // fixarray (0x90-0x9f)
    }
    if (b <= 0xbf)
    {
        return pc_codec_type::PC_CODEC_STR; // fixstr   (0xa0-0xbf)
    }
    switch (b)
    {
    case 0xc0:
        return pc_codec_type::PC_CODEC_NULL;
    case 0xc2:
    case 0xc3:
        return pc_codec_type::PC_CODEC_BOOL;
    case 0xc4:
    case 0xc5:
    case 0xc6:
        return pc_codec_type::PC_CODEC_BYTES;
    case 0xca:
    case 0xcb:
        return pc_codec_type::PC_CODEC_FLOAT;
    case 0xcc:
    case 0xcd:
    case 0xce:
    case 0xcf:
        return pc_codec_type::PC_CODEC_UINT;
    case 0xd0:
    case 0xd1:
    case 0xd2:
    case 0xd3:
        return pc_codec_type::PC_CODEC_INT;
    case 0xd9:
    case 0xda:
    case 0xdb:
        return pc_codec_type::PC_CODEC_STR;
    case 0xdc:
    case 0xdd:
        return pc_codec_type::PC_CODEC_ARRAY;
    case 0xde:
    case 0xdf:
        return pc_codec_type::PC_CODEC_MAP;
    default:
        return pc_codec_type::PC_CODEC_INVALID; // 0xc1, ext (0xc7-0xc9, 0xd4-0xd8)
    }
}
 
bool pc_msgpack_read_uint(pc_cspan *r, uint64_t *out)
{
    if (r->err || r->pos >= r->len)
    {
        r->err = true;
        return false;
    }
    uint8_t b = r->buf[r->pos];
    if (b <= 0x7f) // positive fixint
    {
        *out = b;
        r->pos += 1;
        return true;
    }
    uint64_t v;
    switch (b)
    {
    case 0xcc:
        if (!take_be(r, 1, &v))
        {
            return false;
        }
        break;
    case 0xcd:
        if (!take_be(r, 2, &v))
        {
            return false;
        }
        break;
    case 0xce:
        if (!take_be(r, 4, &v))
        {
            return false;
        }
        break;
    case 0xcf:
        if (!take_be(r, 8, &v))
        {
            return false;
        }
        break;
    default:
        r->err = true;
        return false;
    }
    *out = v;
    return true;
}
 
bool pc_msgpack_read_int(pc_cspan *r, int64_t *out)
{
    if (r->err || r->pos >= r->len)
    {
        r->err = true;
        return false;
    }
    uint8_t b = r->buf[r->pos];
    if (b <= 0x7f) // positive fixint
    {
        *out = b;
        r->pos += 1;
        return true;
    }
    if (b >= 0xe0) // negative fixint (two's-complement byte)
    {
        *out = (int8_t)b;
        r->pos += 1;
        return true;
    }
    uint64_t v;
    switch (b)
    {
    case 0xcc: // uint8
        if (!take_be(r, 1, &v))
        {
            return false;
        }
        *out = (int64_t)v;
        return true;
    case 0xcd: // uint16
        if (!take_be(r, 2, &v))
        {
            return false;
        }
        *out = (int64_t)v;
        return true;
    case 0xce: // uint32
        if (!take_be(r, 4, &v))
        {
            return false;
        }
        *out = (int64_t)v;
        return true;
    case 0xcf: // uint64 (may exceed int64 range; wraps as two's-complement)
        if (!take_be(r, 8, &v))
        {
            return false;
        }
        *out = (int64_t)v;
        return true;
    case 0xd0: // int8
        if (!take_be(r, 1, &v))
        {
            return false;
        }
        *out = (int8_t)(uint8_t)v;
        return true;
    case 0xd1: // int16
        if (!take_be(r, 2, &v))
        {
            return false;
        }
        *out = (int16_t)(uint16_t)v;
        return true;
    case 0xd2: // int32
        if (!take_be(r, 4, &v))
        {
            return false;
        }
        *out = (int32_t)(uint32_t)v;
        return true;
    case 0xd3: // int64
        if (!take_be(r, 8, &v))
        {
            return false;
        }
        *out = (int64_t)v;
        return true;
    default:
        r->err = true;
        return false;
    }
}
 
bool pc_msgpack_read_bool(pc_cspan *r, bool *out)
{
    if (r->err || r->pos >= r->len)
    {
        r->err = true;
        return false;
    }
    uint8_t b = r->buf[r->pos];
    if (b == 0xc2)
    {
        *out = false;
    }
    else if (b == 0xc3)
    {
        *out = true;
    }
    else
    {
        r->err = true;
        return false;
    }
    r->pos += 1;
    return true;
}
 
bool pc_msgpack_read_null(pc_cspan *r)
{
    if (r->err || r->pos >= r->len || r->buf[r->pos] != 0xc0)
    {
        r->err = true;
        return false;
    }
    r->pos += 1;
    return true;
}
 
bool pc_msgpack_read_float(pc_cspan *r, float *out)
{
    if (r->err || r->pos >= r->len)
    {
        r->err = true;
        return false;
    }
    uint8_t b = r->buf[r->pos];
    uint64_t v;
    if (b == 0xca) // float32
    {
        if (!take_be(r, 4, &v))
        {
            return false;
        }
        uint32_t bits = (uint32_t)v;
        memcpy(out, &bits, sizeof(*out));
        return true;
    }
    if (b == 0xcb) // float64 -> narrow to float
    {
        if (!take_be(r, 8, &v))
        {
            return false;
        }
        double d;
        memcpy(&d, &v, sizeof(d));
        *out = (float)d;
        return true;
    }
    r->err = true;
    return false;
}
 
// Shared body for the str family (fixstr / str8/16/32) and bin family (bin8/16/32).
static bool read_blob(pc_cspan *r, bool want_str, const uint8_t **out, size_t *len)
{
    if (r->err || r->pos >= r->len)
    {
        r->err = true;
        return false;
    }
    uint8_t b = r->buf[r->pos];
    size_t n;
    uint64_t v;
    if (want_str && b >= 0xa0 && b <= 0xbf) // fixstr
    {
        n = (size_t)(b & 0x1f);
        r->pos += 1;
    }
    else
    {
        const uint8_t f8 = want_str ? 0xd9 : 0xc4;
        const uint8_t f16 = want_str ? 0xda : 0xc5;
        const uint8_t f32 = want_str ? 0xdb : 0xc6;
        if (b == f8)
        {
            if (!take_be(r, 1, &v))
            {
                return false;
            }
        }
        else if (b == f16)
        {
            if (!take_be(r, 2, &v))
            {
                return false;
            }
        }
        else if (b == f32)
        {
            if (!take_be(r, 4, &v))
            {
                return false;
            }
        }
        else
        {
            r->err = true;
            return false;
        }
        n = (size_t)v;
    }
    if (r->pos + n > r->len) // payload bounds
    {
        r->err = true;
        return false;
    }
    *out = &r->buf[r->pos];
    *len = n;
    r->pos += n;
    return true;
}
 
bool pc_msgpack_read_str(pc_cspan *r, const char **out, size_t *len)
{
    return read_blob(r, true, (const uint8_t **)out, len);
}
 
bool pc_msgpack_read_bytes(pc_cspan *r, const uint8_t **out, size_t *len)
{
    return read_blob(r, false, out, len);
}
 
// Shared body for the array family (fixarray / array16/32) and map family.
static bool read_count(pc_cspan *r, bool want_map, size_t *count)
{
    if (r->err || r->pos >= r->len)
    {
        r->err = true;
        return false;
    }
    uint8_t b = r->buf[r->pos];
    const uint8_t fix_lo = want_map ? 0x80 : 0x90;
    const uint8_t fix_hi = want_map ? 0x8f : 0x9f;
    const uint8_t f16 = want_map ? 0xde : 0xdc;
    const uint8_t f32 = want_map ? 0xdf : 0xdd;
    if (b >= fix_lo && b <= fix_hi)
    {
        *count = (size_t)(b & 0x0f);
        r->pos += 1;
        return true;
    }
    uint64_t v;
    if (b == f16)
    {
        if (!take_be(r, 2, &v))
        {
            return false;
        }
    }
    else if (b == f32)
    {
        if (!take_be(r, 4, &v))
        {
            return false;
        }
    }
    else
    {
        r->err = true;
        return false;
    }
    *count = (size_t)v;
    return true;
}
 
bool pc_msgpack_read_array(pc_cspan *r, size_t *count)
{
    return read_count(r, false, count);
}
 
bool pc_msgpack_read_map(pc_cspan *r, size_t *count)
{
    return read_count(r, true, count);
}
 
#endif // PC_ENABLE_MSGPACK