blob: d4cefa46e2de91a85ff222c18dc7288ff66ea0e4 [file] [log] [blame] [edit]
/* SDPX-License-Identifier: MIT */
#ifdef __cplusplus
extern "C" {
#endif
#ifdef EMACS_INDENTATION_HELPER
} /* Duh. */
#endif
#include "cn-cbor/cn-cbor.h"
#include "cbor.h"
#include <common.h>
#define CBOR_NO_FLOAT 1
#define CN_CBOR_FAIL(code) \
do { \
pb->err = code; \
goto fail; \
} while (0)
CN_CBOR_EXPORT
void cn_cbor_dont_free_data(cn_cbor *cbor)
{
cbor->flags |= CN_CBOR_FL_EXT_DATA;
}
CN_CBOR_EXPORT
void cn_cbor_free(cn_cbor *cb CBOR_CONTEXT)
{
cn_cbor *p = (cn_cbor *)cb;
assert(!p || !p->parent);
while (p) {
cn_cbor *p1;
while ((p1 = p->first_child)) { /* go down */
p = p1;
}
if (!(p1 = p->next)) { /* go up next */
if ((p1 = p->parent)) {
p1->first_child = 0;
}
}
if ((p->flags & CN_CBOR_FL_EXT_DATA) == 0) {
switch (p->type) {
case CN_CBOR_BYTES:
case CN_CBOR_TEXT:
CN_CBOR_FREE_CONTEXT((void *) p->v.bytes);
break;
default:
break;
}
}
if ((p->flags & CN_CBOR_FL_EXT_SELF) == 0) {
CN_CBOR_FREE_CONTEXT(p);
}
p = p1;
}
}
#ifndef CBOR_NO_FLOAT
static double decode_half(int half)
{
int exp = (half >> 10) & 0x1f;
int mant = half & 0x3ff;
double val;
if (exp == 0) {
val = ldexp(mant, -24);
}
else if (exp != 31) {
val = ldexp(mant + 1024, exp - 25);
}
else {
val = mant == 0 ? INFINITY : NAN;
}
return half & 0x8000 ? -val : val;
}
#endif /* CBOR_NO_FLOAT */
#define ntoh8p(p) (*(unsigned char *)(p))
#ifndef CBOR_ALIGN_READS
#define ntoh16p(p) (ntohs(*(unsigned short *)(p)))
#define ntoh32p(p) (ntohl(*(unsigned long *)(p)))
#else
static uint16_t ntoh16p(unsigned char *p)
{
uint16_t tmp;
memcpy(&tmp, p, sizeof(tmp));
return ntohs(tmp);
}
static uint32_t ntoh32p(unsigned char *p)
{
uint32_t tmp;
memcpy(&tmp, p, sizeof(tmp));
return ntohl(tmp);
}
#endif /* CBOR_ALIGN_READS */
static uint64_t ntoh64p(unsigned char *p)
{
uint64_t ret = ntoh32p(p);
ret <<= 32;
ret += ntoh32p(p + 4);
return ret;
}
static cn_cbor_type mt_trans[] = {
CN_CBOR_UINT,
CN_CBOR_INT,
CN_CBOR_BYTES,
CN_CBOR_TEXT,
CN_CBOR_ARRAY,
CN_CBOR_MAP,
CN_CBOR_TAG,
CN_CBOR_SIMPLE,
};
struct parse_buf {
unsigned char *buf;
unsigned char *ebuf;
cn_cbor_error err;
};
#define TAKE(pos, ebuf, n, stmt) \
if ((n) > (size_t)((ebuf) - (pos))) \
CN_CBOR_FAIL(CN_CBOR_ERR_OUT_OF_DATA); \
stmt; \
(pos) += (n);
static cn_cbor *decode_item(struct parse_buf *pb CBOR_CONTEXT, cn_cbor *top_parent)
{
unsigned char *pos = pb->buf;
unsigned char *ebuf = pb->ebuf;
cn_cbor *parent = top_parent;
int ib = 0;
unsigned int mt = 0;
int ai = 0;
uint64_t val = 0;
cn_cbor *cb = NULL;
#ifndef CBOR_NO_FLOAT
union {
float f;
uint32_t u;
} u32;
union {
double d;
uint64_t u;
} u64;
#endif /* CBOR_NO_FLOAT */
again:
TAKE(pos, ebuf, 1, ib = ntoh8p(pos));
if (ib == IB_BREAK) {
if (!(parent->flags & CN_CBOR_FL_INDEF)) {
CN_CBOR_FAIL(CN_CBOR_ERR_BREAK_OUTSIDE_INDEF);
}
switch (parent->type) {
case CN_CBOR_BYTES:
case CN_CBOR_TEXT:
parent->type += 2; /* CN_CBOR_* -> CN_CBOR_*_CHUNKED */
break;
case CN_CBOR_MAP:
if (parent->length & 1) {
CN_CBOR_FAIL(CN_CBOR_ERR_ODD_SIZE_INDEF_MAP);
}
break;
case CN_CBOR_ARRAY:
break;
default:
CN_CBOR_FAIL(CN_CBOR_ERR_WRONG_NESTING_IN_INDEF_STRING);
}
goto complete;
}
mt = ib >> 5;
ai = ib & 0x1f;
val = ai;
cb = CN_CALLOC_CONTEXT();
if (!cb) {
CN_CBOR_FAIL(CN_CBOR_ERR_OUT_OF_MEMORY);
}
cb->type = mt_trans[mt];
cb->parent = parent;
if (parent->last_child) {
parent->last_child->next = cb;
}
else {
parent->first_child = cb;
}
parent->last_child = cb;
parent->length++;
switch (ai) {
case AI_1:
TAKE(pos, ebuf, 1, val = ntoh8p(pos));
break;
case AI_2:
TAKE(pos, ebuf, 2, val = ntoh16p(pos));
break;
case AI_4:
TAKE(pos, ebuf, 4, val = ntoh32p(pos));
break;
case AI_8:
TAKE(pos, ebuf, 8, val = ntoh64p(pos));
break;
case 28:
case 29:
case 30:
CN_CBOR_FAIL(CN_CBOR_ERR_RESERVED_AI);
case AI_INDEF:
if ((mt - MT_BYTES) <= MT_MAP) {
cb->flags |= CN_CBOR_FL_INDEF;
goto push;
}
else {
CN_CBOR_FAIL(CN_CBOR_ERR_MT_UNDEF_FOR_INDEF);
}
default:
break;
}
// process content
switch (mt) {
case MT_UNSIGNED:
cb->v.uint = val; /* to do: Overflow check */
break;
case MT_NEGATIVE:
cb->v.sint = ~val; /* to do: Overflow check */
break;
case MT_BYTES:
case MT_TEXT:
cb->v.str = (char *)pos;
cb->length = (size_t)val;
cb->flags |= CN_CBOR_FL_EXT_DATA;
TAKE(pos, ebuf, val, ;);
break;
case MT_MAP:
val <<= 1;
/* fall through */
case MT_ARRAY:
if ((cb->v.count = val)) {
cb->flags |= CN_CBOR_FL_COUNT;
goto push;
}
break;
case MT_TAG:
cb->v.uint = val;
goto push;
case MT_PRIM:
switch (ai) {
case VAL_FALSE:
cb->type = CN_CBOR_FALSE;
break;
case VAL_TRUE:
cb->type = CN_CBOR_TRUE;
break;
case VAL_NIL:
cb->type = CN_CBOR_NULL;
break;
case VAL_UNDEF:
cb->type = CN_CBOR_UNDEF;
break;
case AI_2:
#ifndef CBOR_NO_FLOAT
cb->type = CN_CBOR_DOUBLE;
cb->v.dbl = decode_half((int) val);
#else /* CBOR_NO_FLOAT */
CN_CBOR_FAIL(CN_CBOR_ERR_FLOAT_NOT_SUPPORTED);
#endif /* CBOR_NO_FLOAT */
break;
case AI_4:
#ifndef CBOR_NO_FLOAT
cb->type = CN_CBOR_DOUBLE;
u32.u = (uint32_t)val;
cb->v.dbl = u32.f;
#else /* CBOR_NO_FLOAT */
CN_CBOR_FAIL(CN_CBOR_ERR_FLOAT_NOT_SUPPORTED);
#endif /* CBOR_NO_FLOAT */
break;
case AI_8:
#ifndef CBOR_NO_FLOAT
cb->type = CN_CBOR_DOUBLE;
u64.u = val;
cb->v.dbl = u64.d;
#else /* CBOR_NO_FLOAT */
CN_CBOR_FAIL(CN_CBOR_ERR_FLOAT_NOT_SUPPORTED);
#endif /* CBOR_NO_FLOAT */
break;
default:
cb->v.uint = val;
if (24 <= val && val < 32) {
CN_CBOR_FAIL(CN_CBOR_ERR_INVALID_PARAMETER);
}
break;
}
break;
default:
CN_CBOR_FAIL(CN_CBOR_ERR_INVALID_PARAMETER);
}
fill: /* emulate loops */
if (parent->flags & CN_CBOR_FL_INDEF) {
if (parent->type == CN_CBOR_BYTES || parent->type == CN_CBOR_TEXT) {
if (cb->type != parent->type) {
CN_CBOR_FAIL(CN_CBOR_ERR_WRONG_NESTING_IN_INDEF_STRING);
}
}
goto again;
}
if (parent->flags & CN_CBOR_FL_COUNT) {
if (--parent->v.count) {
goto again;
}
}
/* so we are done filling parent. */
complete: /* emulate return from call */
if (parent == top_parent) {
if (pos != ebuf) {
/* XXX do this outside */
CN_CBOR_FAIL(CN_CBOR_ERR_NOT_ALL_DATA_CONSUMED);
}
pb->buf = pos;
return cb;
}
cb = parent;
parent = parent->parent;
goto fill;
push: /* emulate recursive call */
parent = cb;
goto again;
fail:
pb->buf = pos;
return 0;
}
CN_CBOR_EXPORT
cn_cbor *cn_cbor_decode(const unsigned char *buf, size_t len CBOR_CONTEXT, cn_cbor_errback *errp)
{
cn_cbor catcher = {CN_CBOR_INVALID, 0, {0}, 0, NULL, NULL, NULL, NULL};
struct parse_buf pb;
cn_cbor *ret = NULL;
pb.buf = (unsigned char *)buf;
pb.ebuf = (unsigned char *)buf + len;
pb.err = CN_CBOR_NO_ERROR;
ret = decode_item(&pb CBOR_CONTEXT_PARAM, &catcher);
if (ret != NULL) {
/* mark as top node */
ret->parent = NULL;
}
else {
if (catcher.first_child) {
catcher.first_child->parent = 0;
cn_cbor_free(catcher.first_child CBOR_CONTEXT_PARAM);
}
// fail:
if (errp) {
errp->err = pb.err;
errp->pos = pb.buf - (unsigned char *)buf;
}
return NULL;
}
return ret;
}
#ifdef __cplusplus
}
#endif