Keep the colleague's microbu-esp32c5 tree in this repository
obu-firmware builds against vanetza-idf from microbu-esp32c5/external, but that tree was gitignored, so a clone of this repository could not build the firmware it ships. It is now committed here as ordinary files in its own folder, microbu-esp32c5/: the colleague's commit cf4b99f plus the V2X2MAP bridge's signature verification (--trust) used on the bench. Nothing is fetched from or pushed to the colleague's repository; this repository and its remotes carry everything. The folder's own .gitignore keeps build output, downloaded components and private key material out, as it did there; the committed file set is identical to that repository's tracked files. The ESP32-C5 is still flashed from obu-firmware/, which only takes vanetza-idf from microbu-esp32c5/, so the two stay separate folders. FLASHING.md says how to take a newer version of the colleague's tree (copy it over the folder, rebuild, test, commit).
This commit is contained in:
Ashin Walpola
+539
@@ -0,0 +1,539 @@
|
||||
/*-
|
||||
* Copyright (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
|
||||
* Redistribution and modifications are permitted subject to BSD license.
|
||||
*/
|
||||
#include "asn_internal.h"
|
||||
#include "INTEGER.h"
|
||||
#include "OBJECT_IDENTIFIER.h"
|
||||
#include "asn_codecs_prim.h"
|
||||
#include <inttypes.h> /* for PRIu32 */
|
||||
#include <limits.h> /* for CHAR_BIT */
|
||||
#include <errno.h>
|
||||
#include <inttypes.h>
|
||||
|
||||
/*
|
||||
* OBJECT IDENTIFIER basic type description.
|
||||
*/
|
||||
static const ber_tlv_tag_t asn_DEF_OBJECT_IDENTIFIER_tags[] = {
|
||||
(ASN_TAG_CLASS_UNIVERSAL | (6 << 2))
|
||||
};
|
||||
asn_TYPE_operation_t asn_OP_OBJECT_IDENTIFIER = {
|
||||
ASN__PRIMITIVE_TYPE_free,
|
||||
#if !defined(ASN_DISABLE_PRINT_SUPPORT)
|
||||
OBJECT_IDENTIFIER_print,
|
||||
#else
|
||||
0,
|
||||
#endif /* !defined(ASN_DISABLE_PRINT_SUPPORT) */
|
||||
OCTET_STRING_compare, /* Implemented in terms of a string comparison */
|
||||
OCTET_STRING_copy, /* Implemented in terms of a string copy */
|
||||
#if !defined(ASN_DISABLE_BER_SUPPORT)
|
||||
ber_decode_primitive,
|
||||
der_encode_primitive,
|
||||
#else
|
||||
0,
|
||||
0,
|
||||
#endif /* !defined(ASN_DISABLE_BER_SUPPORT) */
|
||||
#if !defined(ASN_DISABLE_XER_SUPPORT)
|
||||
OBJECT_IDENTIFIER_decode_xer,
|
||||
OBJECT_IDENTIFIER_encode_xer,
|
||||
#else
|
||||
0,
|
||||
0,
|
||||
#endif /* !defined(ASN_DISABLE_XER_SUPPORT) */
|
||||
#if !defined(ASN_DISABLE_JER_SUPPORT)
|
||||
OBJECT_IDENTIFIER_decode_jer,
|
||||
OBJECT_IDENTIFIER_encode_jer,
|
||||
#else
|
||||
0,
|
||||
0,
|
||||
#endif /* !defined(ASN_DISABLE_JER_SUPPORT) */
|
||||
#if !defined(ASN_DISABLE_OER_SUPPORT)
|
||||
OBJECT_IDENTIFIER_decode_oer,
|
||||
OBJECT_IDENTIFIER_encode_oer,
|
||||
#else
|
||||
0,
|
||||
0,
|
||||
#endif /* !defined(ASN_DISABLE_OER_SUPPORT) */
|
||||
#if !defined(ASN_DISABLE_UPER_SUPPORT)
|
||||
OCTET_STRING_decode_uper,
|
||||
OCTET_STRING_encode_uper,
|
||||
#else
|
||||
0,
|
||||
0,
|
||||
#endif /* !defined(ASN_DISABLE_UPER_SUPPORT) */
|
||||
#if !defined(ASN_DISABLE_APER_SUPPORT)
|
||||
OCTET_STRING_decode_aper,
|
||||
OCTET_STRING_encode_aper,
|
||||
#else
|
||||
0,
|
||||
0,
|
||||
#endif /* !defined(ASN_DISABLE_APER_SUPPORT) */
|
||||
#if !defined(ASN_DISABLE_RFILL_SUPPORT)
|
||||
OBJECT_IDENTIFIER_random_fill,
|
||||
#else
|
||||
0,
|
||||
#endif /* !defined(ASN_DISABLE_RFILL_SUPPORT) */
|
||||
0 /* Use generic outmost tag fetcher */
|
||||
};
|
||||
asn_TYPE_descriptor_t asn_DEF_OBJECT_IDENTIFIER = {
|
||||
"OBJECT IDENTIFIER",
|
||||
"OBJECT_IDENTIFIER",
|
||||
&asn_OP_OBJECT_IDENTIFIER,
|
||||
asn_DEF_OBJECT_IDENTIFIER_tags,
|
||||
sizeof(asn_DEF_OBJECT_IDENTIFIER_tags)
|
||||
/ sizeof(asn_DEF_OBJECT_IDENTIFIER_tags[0]),
|
||||
asn_DEF_OBJECT_IDENTIFIER_tags, /* Same as above */
|
||||
sizeof(asn_DEF_OBJECT_IDENTIFIER_tags)
|
||||
/ sizeof(asn_DEF_OBJECT_IDENTIFIER_tags[0]),
|
||||
{
|
||||
#if !defined(ASN_DISABLE_OER_SUPPORT)
|
||||
0,
|
||||
#endif /* !defined(ASN_DISABLE_OER_SUPPORT) */
|
||||
#if !defined(ASN_DISABLE_UPER_SUPPORT) || !defined(ASN_DISABLE_APER_SUPPORT)
|
||||
0,
|
||||
#endif /* !defined(ASN_DISABLE_UPER_SUPPORT) || !defined(ASN_DISABLE_APER_SUPPORT) */
|
||||
#if !defined(ASN_DISABLE_JER_SUPPORT)
|
||||
0,
|
||||
#endif /* !defined(ASN_DISABLE_JER_SUPPORT) */
|
||||
OBJECT_IDENTIFIER_constraint
|
||||
},
|
||||
0, 0, /* No members */
|
||||
0 /* No specifics */
|
||||
};
|
||||
|
||||
int
|
||||
OBJECT_IDENTIFIER_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
|
||||
asn_app_constraint_failed_f *ctfailcb,
|
||||
void *app_key) {
|
||||
const OBJECT_IDENTIFIER_t *st = (const OBJECT_IDENTIFIER_t *)sptr;
|
||||
|
||||
if(st && st->buf) {
|
||||
if(st->size < 1) {
|
||||
ASN__CTFAIL(app_key, td, sptr,
|
||||
"%s: at least one numerical value "
|
||||
"expected (%s:%d)",
|
||||
td->name, __FILE__, __LINE__);
|
||||
return -1;
|
||||
}
|
||||
} else {
|
||||
ASN__CTFAIL(app_key, td, sptr,
|
||||
"%s: value not given (%s:%d)",
|
||||
td->name, __FILE__, __LINE__);
|
||||
return -1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static ssize_t
|
||||
OBJECT_IDENTIFIER_get_first_arcs(const uint8_t *arcbuf, size_t arcbuf_len,
|
||||
asn_oid_arc_t *arc0, asn_oid_arc_t *arc1) {
|
||||
asn_oid_arc_t value;
|
||||
|
||||
ssize_t rd = OBJECT_IDENTIFIER_get_single_arc(arcbuf, arcbuf_len, &value);
|
||||
if(rd <= 0) return rd;
|
||||
|
||||
if(value >= 80) {
|
||||
*arc0 = 2;
|
||||
*arc1 = value - 80;
|
||||
} else if(value >= 40) {
|
||||
*arc0 = 1;
|
||||
*arc1 = value - 40;
|
||||
} else {
|
||||
*arc0 = 0;
|
||||
*arc1 = value;
|
||||
}
|
||||
|
||||
return rd;
|
||||
}
|
||||
|
||||
ssize_t
|
||||
OBJECT_IDENTIFIER_get_single_arc(const uint8_t *arcbuf, size_t arcbuf_len,
|
||||
asn_oid_arc_t *ret_value) {
|
||||
const uint8_t *b = arcbuf;
|
||||
const uint8_t *arcend = arcbuf + arcbuf_len; /* End of arc */
|
||||
|
||||
if(arcbuf == arcend) {
|
||||
return 0;
|
||||
} else {
|
||||
asn_oid_arc_t accum;
|
||||
asn_oid_arc_t upper_limit = (ASN_OID_ARC_MAX >> 7);
|
||||
/* When the value reaches "upper_limit", it can take */
|
||||
/* at most one more digit. If it exceeds "upper_limit" */
|
||||
/* but there are more digits - it's an Overflow condition */
|
||||
/* Gather all bits into the accumulator */
|
||||
for(accum = 0; b < arcend; b++) {
|
||||
accum = (accum << 7) | (*b & ~0x80);
|
||||
if((*b & 0x80) == 0) { // no more digits
|
||||
if(accum <= ASN_OID_ARC_MAX) {
|
||||
*ret_value = accum;
|
||||
return 1 + (b - arcbuf);
|
||||
} else {
|
||||
errno = ERANGE; /* Overflow */
|
||||
return -1;
|
||||
}
|
||||
} else { // to make sure we aren't wrapping around
|
||||
if(accum > upper_limit) {
|
||||
errno = ERANGE; /* Overflow */
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
}
|
||||
errno = EINVAL;
|
||||
return -1;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
ssize_t
|
||||
OBJECT_IDENTIFIER__dump_body(const OBJECT_IDENTIFIER_t *st,
|
||||
asn_app_consume_bytes_f *cb, void *app_key) {
|
||||
char scratch[32];
|
||||
asn_oid_arc_t arc0 = 0;
|
||||
asn_oid_arc_t arc1 = 0;
|
||||
size_t produced = 0;
|
||||
size_t off = 0;
|
||||
ssize_t rd;
|
||||
int ret;
|
||||
|
||||
rd = OBJECT_IDENTIFIER_get_first_arcs(st->buf, st->size, &arc0, &arc1);
|
||||
if(rd <= 0) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
ret = snprintf(scratch, sizeof(scratch), "%"PRIu32".%"PRIu32, arc0, arc1);
|
||||
if(ret >= (ssize_t)sizeof(scratch)) {
|
||||
return -1;
|
||||
}
|
||||
produced += ret;
|
||||
if(cb(scratch, ret, app_key) < 0)
|
||||
return -1;
|
||||
|
||||
for(off = rd; ; ) {
|
||||
asn_oid_arc_t arc;
|
||||
rd = OBJECT_IDENTIFIER_get_single_arc(st->buf + off, st->size - off,
|
||||
&arc);
|
||||
if(rd < 0) {
|
||||
return -1;
|
||||
} else if(rd == 0) {
|
||||
/* No more arcs. */
|
||||
break;
|
||||
} else {
|
||||
off += rd;
|
||||
assert(off <= st->size);
|
||||
ret = snprintf(scratch, sizeof(scratch), ".%" PRIu32, arc);
|
||||
if(ret >= (ssize_t)sizeof(scratch)) {
|
||||
return -1;
|
||||
}
|
||||
produced += ret;
|
||||
if(cb(scratch, ret, app_key) < 0) return -1;
|
||||
}
|
||||
}
|
||||
|
||||
if(off != st->size) {
|
||||
ASN_DEBUG("Could not scan to the end of Object Identifier");
|
||||
return -1;
|
||||
}
|
||||
|
||||
return produced;
|
||||
}
|
||||
|
||||
ssize_t
|
||||
OBJECT_IDENTIFIER_get_arcs(const OBJECT_IDENTIFIER_t *st, asn_oid_arc_t *arcs,
|
||||
size_t arc_slots) {
|
||||
asn_oid_arc_t arc0 = 0;
|
||||
asn_oid_arc_t arc1 = 0;
|
||||
size_t num_arcs = 0;
|
||||
size_t off;
|
||||
ssize_t rd;
|
||||
|
||||
if(!st || !st->buf) {
|
||||
errno = EINVAL;
|
||||
return -1;
|
||||
}
|
||||
|
||||
rd = OBJECT_IDENTIFIER_get_first_arcs(st->buf, st->size, &arc0, &arc1);
|
||||
if(rd <= 0) {
|
||||
return -1;
|
||||
}
|
||||
num_arcs = 2;
|
||||
switch(arc_slots) {
|
||||
default:
|
||||
case 2:
|
||||
arcs[1] = arc1;
|
||||
/* Fall through */
|
||||
case 1:
|
||||
arcs[0] = arc0;
|
||||
/* Fall through */
|
||||
case 0:
|
||||
break;
|
||||
}
|
||||
|
||||
for(off = rd; ; ) {
|
||||
asn_oid_arc_t arc;
|
||||
rd = OBJECT_IDENTIFIER_get_single_arc(st->buf + off, st->size - off,
|
||||
&arc);
|
||||
if(rd < 0) {
|
||||
return -1;
|
||||
} else if(rd == 0) {
|
||||
/* No more arcs. */
|
||||
break;
|
||||
} else {
|
||||
off += rd;
|
||||
if(num_arcs < arc_slots) {
|
||||
arcs[num_arcs] = arc;
|
||||
}
|
||||
num_arcs++;
|
||||
}
|
||||
}
|
||||
|
||||
if(off != st->size) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
return num_arcs;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Save the single value as an object identifier arc.
|
||||
*/
|
||||
ssize_t
|
||||
OBJECT_IDENTIFIER_set_single_arc(uint8_t *arcbuf, size_t arcbuf_len,
|
||||
asn_oid_arc_t value) {
|
||||
/*
|
||||
* The following conditions must hold:
|
||||
* assert(arcbuf);
|
||||
*/
|
||||
uint8_t scratch[((sizeof(value) * CHAR_BIT + 6) / 7)];
|
||||
uint8_t *scratch_end = &scratch[sizeof(scratch)-1];
|
||||
uint8_t *b;
|
||||
size_t result_len;
|
||||
uint8_t mask;
|
||||
|
||||
for(b = scratch_end, mask = 0; ; mask = 0x80, b--) {
|
||||
*b = mask | (value & 0x7f);
|
||||
value >>= 7;
|
||||
if(!value) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
result_len = (scratch_end - b) + 1;
|
||||
|
||||
if(result_len > arcbuf_len) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
memcpy(arcbuf, b, result_len);
|
||||
|
||||
return result_len;
|
||||
}
|
||||
|
||||
int
|
||||
OBJECT_IDENTIFIER_set_arcs(OBJECT_IDENTIFIER_t *st, const asn_oid_arc_t *arcs,
|
||||
size_t arc_slots) {
|
||||
uint8_t *buf;
|
||||
uint8_t *bp;
|
||||
ssize_t wrote;
|
||||
asn_oid_arc_t arc0;
|
||||
asn_oid_arc_t arc1;
|
||||
size_t size;
|
||||
size_t i;
|
||||
|
||||
if(!st || !arcs || arc_slots < 2) {
|
||||
errno = EINVAL;
|
||||
return -1;
|
||||
}
|
||||
|
||||
arc0 = arcs[0];
|
||||
arc1 = arcs[1];
|
||||
|
||||
if(arc0 <= 1) {
|
||||
if(arc1 >= 40) {
|
||||
/* 8.19.4: At most 39 subsequent values (including 0) */
|
||||
errno = ERANGE;
|
||||
return -1;
|
||||
}
|
||||
} else if(arc0 == 2) {
|
||||
if(arc1 > ASN_OID_ARC_MAX - 80) {
|
||||
errno = ERANGE;
|
||||
return -1;
|
||||
}
|
||||
} else if(arc0 > 2) {
|
||||
/* 8.19.4: Only three values are allocated from the root node */
|
||||
errno = ERANGE;
|
||||
return -1;
|
||||
}
|
||||
|
||||
/*
|
||||
* After above tests it is known that the value of arc0 is completely
|
||||
* trustworthy (0..2). However, the arc1's value is still meaningless.
|
||||
*/
|
||||
|
||||
/*
|
||||
* Roughly estimate the maximum size necessary to encode these arcs.
|
||||
* This estimation implicitly takes in account the following facts,
|
||||
* that cancel each other:
|
||||
* * the first two arcs are encoded in a single value.
|
||||
* * the first value may require more space (+1 byte)
|
||||
* * the value of the first arc which is in range (0..2)
|
||||
*/
|
||||
size = ((sizeof(asn_oid_arc_t) * CHAR_BIT + 6) / 7) * arc_slots;
|
||||
bp = buf = (uint8_t *)MALLOC(size + 1);
|
||||
if(!buf) {
|
||||
/* ENOMEM */
|
||||
return -1;
|
||||
}
|
||||
|
||||
wrote = OBJECT_IDENTIFIER_set_single_arc(bp, size, arc0 * 40 + arc1);
|
||||
if(wrote <= 0) {
|
||||
FREEMEM(buf);
|
||||
return -1;
|
||||
}
|
||||
assert((size_t)wrote <= size);
|
||||
bp += wrote;
|
||||
size -= wrote;
|
||||
|
||||
for(i = 2; i < arc_slots; i++) {
|
||||
wrote = OBJECT_IDENTIFIER_set_single_arc(bp, size, arcs[i]);
|
||||
if(wrote <= 0) {
|
||||
FREEMEM(buf);
|
||||
return -1;
|
||||
}
|
||||
assert((size_t)wrote <= size);
|
||||
bp += wrote;
|
||||
size -= wrote;
|
||||
}
|
||||
|
||||
/*
|
||||
* Replace buffer.
|
||||
*/
|
||||
st->size = bp - buf;
|
||||
bp = st->buf;
|
||||
st->buf = buf;
|
||||
st->buf[st->size] = '\0';
|
||||
if(bp) FREEMEM(bp);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
ssize_t
|
||||
OBJECT_IDENTIFIER_parse_arcs(const char *oid_text, ssize_t oid_txt_length,
|
||||
asn_oid_arc_t *arcs, size_t arcs_count,
|
||||
const char **opt_oid_text_end) {
|
||||
size_t num_arcs = 0;
|
||||
const char *oid_end;
|
||||
enum {
|
||||
ST_LEADSPACE,
|
||||
ST_TAILSPACE,
|
||||
ST_AFTERVALUE, /* Next character ought to be '.' or a space */
|
||||
ST_WAITDIGITS /* Next character is expected to be a digit */
|
||||
} state = ST_LEADSPACE;
|
||||
|
||||
if(!oid_text || oid_txt_length < -1 || (arcs_count && !arcs)) {
|
||||
if(opt_oid_text_end) *opt_oid_text_end = oid_text;
|
||||
errno = EINVAL;
|
||||
return -1;
|
||||
}
|
||||
|
||||
if(oid_txt_length == -1)
|
||||
oid_txt_length = strlen(oid_text);
|
||||
|
||||
#define _OID_CAPTURE_ARC(oid_text, oid_end) \
|
||||
do { \
|
||||
const char *endp = oid_end; \
|
||||
unsigned long value; \
|
||||
switch(asn_strtoul_lim(oid_text, &endp, &value)) { \
|
||||
case ASN_STRTOX_EXTRA_DATA: \
|
||||
case ASN_STRTOX_OK: \
|
||||
if(value <= ASN_OID_ARC_MAX) { \
|
||||
if(num_arcs < arcs_count) arcs[num_arcs] = value; \
|
||||
num_arcs++; \
|
||||
oid_text = endp - 1; \
|
||||
break; \
|
||||
} \
|
||||
/* Fall through */ \
|
||||
case ASN_STRTOX_ERROR_RANGE: \
|
||||
if(opt_oid_text_end) *opt_oid_text_end = oid_text; \
|
||||
errno = ERANGE; \
|
||||
return -1; \
|
||||
case ASN_STRTOX_ERROR_INVAL: \
|
||||
case ASN_STRTOX_EXPECT_MORE: \
|
||||
if(opt_oid_text_end) *opt_oid_text_end = oid_text; \
|
||||
errno = EINVAL; \
|
||||
return -1; \
|
||||
} \
|
||||
} while(0)
|
||||
|
||||
for(oid_end = oid_text + oid_txt_length; oid_text<oid_end; oid_text++) {
|
||||
switch(*oid_text) {
|
||||
case 0x09: case 0x0a: case 0x0d: case 0x20: /* whitespace */
|
||||
switch(state) {
|
||||
case ST_LEADSPACE:
|
||||
case ST_TAILSPACE:
|
||||
continue;
|
||||
case ST_AFTERVALUE:
|
||||
state = ST_TAILSPACE;
|
||||
continue;
|
||||
case ST_WAITDIGITS:
|
||||
break; /* Digits expected after ".", got whitespace */
|
||||
}
|
||||
break;
|
||||
case 0x2e: /* '.' */
|
||||
switch(state) {
|
||||
case ST_LEADSPACE:
|
||||
case ST_TAILSPACE:
|
||||
case ST_WAITDIGITS:
|
||||
if(opt_oid_text_end)
|
||||
*opt_oid_text_end = oid_text;
|
||||
errno = EINVAL; /* Broken OID */
|
||||
return -1;
|
||||
break;
|
||||
case ST_AFTERVALUE:
|
||||
state = ST_WAITDIGITS;
|
||||
continue;
|
||||
}
|
||||
break;
|
||||
case 0x30: case 0x31: case 0x32: case 0x33: case 0x34:
|
||||
case 0x35: case 0x36: case 0x37: case 0x38: case 0x39:
|
||||
switch(state) {
|
||||
case ST_TAILSPACE:
|
||||
case ST_AFTERVALUE:
|
||||
if(opt_oid_text_end)
|
||||
*opt_oid_text_end = oid_text;
|
||||
errno = EINVAL; /* "1. 1" => broken OID */
|
||||
return -1;
|
||||
case ST_LEADSPACE:
|
||||
case ST_WAITDIGITS:
|
||||
_OID_CAPTURE_ARC(oid_text, oid_end);
|
||||
state = ST_AFTERVALUE;
|
||||
continue;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
/* Unexpected symbols */
|
||||
state = ST_WAITDIGITS;
|
||||
break;
|
||||
} /* switch() */
|
||||
break;
|
||||
} /* for() */
|
||||
|
||||
|
||||
if(opt_oid_text_end) *opt_oid_text_end = oid_text;
|
||||
|
||||
/* Finalize last arc */
|
||||
switch(state) {
|
||||
case ST_LEADSPACE:
|
||||
return 0; /* No OID found in input data */
|
||||
case ST_WAITDIGITS:
|
||||
errno = EINVAL; /* Broken OID */
|
||||
return -1;
|
||||
case ST_AFTERVALUE:
|
||||
case ST_TAILSPACE:
|
||||
return num_arcs;
|
||||
}
|
||||
|
||||
errno = EINVAL; /* Broken OID */
|
||||
return -1;
|
||||
}
|
||||
Reference in New Issue
Block a user