X-Git-Url: https://git.stg.codes/stg.git/blobdiff_plain/46b0747592074017ff0ea4b33d4a7194235886e5..37324ea9b8c06d96b9383be993da02a01f103253:/libs/smux/OBJECT_IDENTIFIER.c?ds=sidebyside
diff --git a/libs/smux/OBJECT_IDENTIFIER.c b/libs/smux/OBJECT_IDENTIFIER.c
index d0367f0f..290545d1 100644
--- a/libs/smux/OBJECT_IDENTIFIER.c
+++ b/libs/smux/OBJECT_IDENTIFIER.c
@@ -3,55 +3,74 @@
* Redistribution and modifications are permitted subject to BSD license.
*/
#include <asn_internal.h>
+#include <INTEGER.h>
#include <OBJECT_IDENTIFIER.h>
+#include <OCTET_STRING.h>
#include <limits.h> /* for CHAR_BIT */
#include <errno.h>
/*
* OBJECT IDENTIFIER basic type description.
*/
-static ber_tlv_tag_t asn_DEF_OBJECT_IDENTIFIER_tags[] = {
+static const ber_tlv_tag_t asn_DEF_OBJECT_IDENTIFIER_tags[] = {
(ASN_TAG_CLASS_UNIVERSAL | (6 << 2))
};
-asn_TYPE_descriptor_t asn_DEF_OBJECT_IDENTIFIER = {
- "OBJECT IDENTIFIER",
- "OBJECT_IDENTIFIER",
+asn_TYPE_operation_t asn_OP_OBJECT_IDENTIFIER = {
ASN__PRIMITIVE_TYPE_free,
OBJECT_IDENTIFIER_print,
- OBJECT_IDENTIFIER_constraint,
+ OCTET_STRING_compare, /* Implemented in terms of a string comparison */
ber_decode_primitive,
der_encode_primitive,
OBJECT_IDENTIFIER_decode_xer,
OBJECT_IDENTIFIER_encode_xer,
- 0, 0,
- 0, /* Use generic outmost tag fetcher */
+#ifdef ASN_DISABLE_OER_SUPPORT
+ 0,
+ 0,
+#else
+ OBJECT_IDENTIFIER_decode_oer,
+ OBJECT_IDENTIFIER_encode_oer,
+#endif /* ASN_DISABLE_OER_SUPPORT */
+#ifdef ASN_DISABLE_PER_SUPPORT
+ 0,
+ 0,
+#else
+ OCTET_STRING_decode_uper,
+ OCTET_STRING_encode_uper,
+#endif /* ASN_DISABLE_PER_SUPPORT */
+ OBJECT_IDENTIFIER_random_fill,
+ 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]),
- 0, /* No PER visible constraints */
+ { 0, 0, OBJECT_IDENTIFIER_constraint },
0, 0, /* No members */
0 /* No specifics */
};
-
int
-OBJECT_IDENTIFIER_constraint(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;
+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,
+ 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,
+ ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@@ -60,285 +79,186 @@ OBJECT_IDENTIFIER_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
return 0;
}
-
-int
-OBJECT_IDENTIFIER_get_single_arc(uint8_t *arcbuf, unsigned int arclen, signed int add, void *rvbufp, unsigned int rvsize) {
- unsigned LE __attribute__ ((unused)) = 1; /* Little endian (x86) */
- uint8_t *arcend = arcbuf + arclen; /* End of arc */
- unsigned int cache = 0; /* No more than 14 significant bits */
- unsigned char *rvbuf = (unsigned char *)rvbufp;
- unsigned char *rvstart = rvbuf; /* Original start of the value buffer */
- int inc; /* Return value growth direction */
-
- rvsize *= CHAR_BIT; /* bytes to bits */
- arclen *= 7; /* bytes to bits */
-
- /*
- * The arc has the number of bits
- * cannot be represented using supplied return value type.
- */
- if(arclen > rvsize) {
- if(arclen > (rvsize + CHAR_BIT)) {
- errno = ERANGE; /* Overflow */
- return -1;
- } else {
- /*
- * Even if the number of bits in the arc representation
- * is higher than the width of supplied * return value
- * type, there is still possible to fit it when there
- * are few unused high bits in the arc value
- * representaion.
- *
- * Moreover, there is a possibility that the
- * number could actually fit the arc space, given
- * that add is negative, but we don't handle
- * such "temporary lack of precision" situation here.
- * May be considered as a bug.
- */
- uint8_t mask = (0xff << (7-(arclen - rvsize))) & 0x7f;
- if((*arcbuf & mask)) {
- errno = ERANGE; /* Overflow */
- return -1;
- }
- /* Fool the routine computing unused bits */
- arclen -= 7;
- cache = *arcbuf & 0x7f;
- arcbuf++;
- }
- }
-
- /* Faster path for common size */
- if(rvsize == (CHAR_BIT * sizeof(unsigned long))) {
- unsigned long accum;
- /* Gather all bits into the accumulator */
- for(accum = cache; arcbuf < arcend; arcbuf++)
- accum = (accum << 7) | (*arcbuf & ~0x80);
- if(accum < (unsigned)-add) {
- errno = ERANGE; /* Overflow */
- return -1;
- }
- *(unsigned long *)rvbuf = accum + add; /* alignment OK! */
- return 0;
- }
-
-#ifndef WORDS_BIGENDIAN
- if(*(unsigned char *)&LE) { /* Little endian (x86) */
- /* "Convert" to big endian */
- rvbuf += rvsize / CHAR_BIT - 1;
- rvstart--;
- inc = -1; /* Descending */
- } else
-#endif /* !WORDS_BIGENDIAN */
- inc = +1; /* Big endian is known [at compile time] */
-
- {
- int bits; /* typically no more than 3-4 bits */
-
- /* Clear the high unused bits */
- for(bits = rvsize - arclen;
- bits > CHAR_BIT;
- rvbuf += inc, bits -= CHAR_BIT)
- *rvbuf = 0;
-
- /* Fill the body of a value */
- for(; arcbuf < arcend; arcbuf++) {
- cache = (cache << 7) | (*arcbuf & 0x7f);
- bits += 7;
- if(bits >= CHAR_BIT) {
- bits -= CHAR_BIT;
- *rvbuf = (cache >> bits);
- rvbuf += inc;
- }
- }
- if(bits) {
- *rvbuf = cache;
- rvbuf += inc;
- }
- }
-
- if(add) {
- for(rvbuf -= inc; rvbuf != rvstart; rvbuf -= inc) {
- int v = add + *rvbuf;
- if(v & (-1 << CHAR_BIT)) {
- *rvbuf = (unsigned char)(v + (1 << CHAR_BIT));
- add = -1;
- } else {
- *rvbuf = v;
- break;
- }
- }
- if(rvbuf == rvstart) {
- /* No space to carry over */
- errno = ERANGE; /* Overflow */
- 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__dump_arc(uint8_t *arcbuf, int arclen, int add,
- asn_app_consume_bytes_f *cb, void *app_key) {
- char scratch[64]; /* Conservative estimate */
- unsigned long accum; /* Bits accumulator */
+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;
+ /* Gather all bits into the accumulator */
+ for(accum = 0; b < arcend; b++) {
+ accum = (accum << 7) | (*b & ~0x80);
+ if((*b & 0x80) == 0) {
+ if(accum <= ASN_OID_ARC_MAX) {
+ *ret_value = accum;
+ return 1 + (b - arcbuf);
+ } else {
+ errno = ERANGE; /* Overflow */
+ return -1;
+ }
+ }
+ }
+ errno = EINVAL;
+ return -1;
+ }
- if(OBJECT_IDENTIFIER_get_single_arc(arcbuf, arclen, add,
- &accum, sizeof(accum)))
- return -1;
-
- if(accum) {
- ssize_t len;
- char *p = scratch + sizeof(scratch); /* Position in the scratch buffer */
-
- for(; accum; accum /= 10)
- *(--p) = (char)(accum % 10) + 0x30; /* Put a digit */
-
- len = sizeof(scratch) - (p - scratch);
- if(cb(p, len, app_key) < 0)
- return -1;
- return len;
- } else {
- *scratch = 0x30;
- if(cb(scratch, 1, app_key) < 0)
- return -1;
- return 1;
- }
-}
-
-int
-OBJECT_IDENTIFIER_print_arc(uint8_t *arcbuf, int arclen, int add,
- asn_app_consume_bytes_f *cb, void *app_key) {
-
- if(OBJECT_IDENTIFIER__dump_arc(arcbuf, arclen, add, cb, app_key) < 0)
- return -1;
-
- return 0;
}
static ssize_t
-OBJECT_IDENTIFIER__dump_body(const OBJECT_IDENTIFIER_t *st, asn_app_consume_bytes_f *cb, void *app_key) {
- ssize_t wrote_len = 0;
- int startn;
- int add = 0;
- int i;
-
- for(i = 0, startn = 0; i < st->size; i++) {
- uint8_t b = st->buf[i];
- if((b & 0x80)) /* Continuation expected */
- continue;
-
- if(startn == 0) {
- /*
- * First two arcs are encoded through the backdoor.
- */
- if(i) {
- add = -80;
- if(cb("2", 1, app_key) < 0) return -1;
- } else if(b <= 39) {
- add = 0;
- if(cb("0", 1, app_key) < 0) return -1;
- } else if(b < 79) {
- add = -40;
- if(cb("1", 1, app_key) < 0) return -1;
- } else {
- add = -80;
- if(cb("2", 1, app_key) < 0) return -1;
- }
- wrote_len += 1;
- }
-
- if(cb(".", 1, app_key) < 0) /* Separate arcs */
- return -1;
-
- add = OBJECT_IDENTIFIER__dump_arc(&st->buf[startn],
- i - startn + 1, add, cb, app_key);
- if(add < 0) return -1;
- wrote_len += 1 + add;
- startn = i + 1;
- add = 0;
- }
-
- return wrote_len;
+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, arc1;
+ 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;
}
static enum xer_pbd_rval
-OBJECT_IDENTIFIER__xer_body_decode(asn_TYPE_descriptor_t *td, void *sptr, const void *chunk_buf, size_t chunk_size) {
- OBJECT_IDENTIFIER_t *st = (OBJECT_IDENTIFIER_t *)sptr;
+OBJECT_IDENTIFIER__xer_body_decode(const asn_TYPE_descriptor_t *td, void *sptr,
+ const void *chunk_buf, size_t chunk_size) {
+ OBJECT_IDENTIFIER_t *st = (OBJECT_IDENTIFIER_t *)sptr;
const char *chunk_end = (const char *)chunk_buf + chunk_size;
const char *endptr;
- long s_arcs[10];
- long *arcs = s_arcs;
- int arcs_count;
- int ret;
+ asn_oid_arc_t s_arcs[10];
+ asn_oid_arc_t *arcs = s_arcs;
+ ssize_t num_arcs;
+ ssize_t ret;
(void)td;
- arcs_count = OBJECT_IDENTIFIER_parse_arcs(
- (const char *)chunk_buf, chunk_size, arcs,
- sizeof(s_arcs)/sizeof(s_arcs[0]), &endptr);
- if(arcs_count <= 0) {
+ num_arcs = OBJECT_IDENTIFIER_parse_arcs(
+ (const char *)chunk_buf, chunk_size, arcs,
+ sizeof(s_arcs) / sizeof(s_arcs[0]), &endptr);
+ if(num_arcs < 0) {
/* Expecting more than zero arcs */
return XPBD_BROKEN_ENCODING;
+ } else if(num_arcs == 0) {
+ return XPBD_NOT_BODY_IGNORE;
}
- if(endptr < chunk_end) {
- /* We have a tail of unrecognized data. Check its safety. */
- if(!xer_is_whitespace(endptr, chunk_end - endptr))
- return XPBD_BROKEN_ENCODING;
- }
+ assert(endptr == chunk_end);
- if((size_t)arcs_count > sizeof(s_arcs)/sizeof(s_arcs[0])) {
- arcs = (long *)MALLOC(arcs_count * sizeof(long));
+ if((size_t)num_arcs > sizeof(s_arcs)/sizeof(s_arcs[0])) {
+ arcs = (asn_oid_arc_t *)MALLOC(num_arcs * sizeof(asn_oid_arc_t));
if(!arcs) return XPBD_SYSTEM_FAILURE;
- ret = OBJECT_IDENTIFIER_parse_arcs(
- (const char *)chunk_buf, chunk_size,
- arcs, arcs_count, &endptr);
- if(ret != arcs_count)
+ ret = OBJECT_IDENTIFIER_parse_arcs((const char *)chunk_buf, chunk_size,
+ arcs, num_arcs, &endptr);
+ if(ret != num_arcs)
return XPBD_SYSTEM_FAILURE; /* assert?.. */
}
/*
* Convert arcs into BER representation.
*/
- ret = OBJECT_IDENTIFIER_set_arcs(st, arcs, sizeof(*arcs), arcs_count);
+ ret = OBJECT_IDENTIFIER_set_arcs(st, arcs, num_arcs);
if(arcs != s_arcs) FREEMEM(arcs);
return ret ? XPBD_SYSTEM_FAILURE : XPBD_BODY_CONSUMED;
}
asn_dec_rval_t
-OBJECT_IDENTIFIER_decode_xer(asn_codec_ctx_t *opt_codec_ctx,
- asn_TYPE_descriptor_t *td, void **sptr, const char *opt_mname,
- const void *buf_ptr, size_t size) {
-
- return xer_decode_primitive(opt_codec_ctx, td,
+OBJECT_IDENTIFIER_decode_xer(const asn_codec_ctx_t *opt_codec_ctx,
+ const asn_TYPE_descriptor_t *td, void **sptr,
+ const char *opt_mname, const void *buf_ptr,
+ size_t size) {
+ return xer_decode_primitive(opt_codec_ctx, td,
sptr, sizeof(OBJECT_IDENTIFIER_t), opt_mname,
buf_ptr, size, OBJECT_IDENTIFIER__xer_body_decode);
}
asn_enc_rval_t
-OBJECT_IDENTIFIER_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
- int ilevel, enum xer_encoder_flags_e flags,
- asn_app_consume_bytes_f *cb, void *app_key) {
- const OBJECT_IDENTIFIER_t *st = (const OBJECT_IDENTIFIER_t *)sptr;
+OBJECT_IDENTIFIER_encode_xer(const asn_TYPE_descriptor_t *td, const void *sptr,
+ int ilevel, enum xer_encoder_flags_e flags,
+ asn_app_consume_bytes_f *cb, void *app_key) {
+ const OBJECT_IDENTIFIER_t *st = (const OBJECT_IDENTIFIER_t *)sptr;
asn_enc_rval_t er;
- (void)ilevel;
- (void)flags;
+ (void)ilevel;
+ (void)flags;
- if(!st || !st->buf)
- _ASN_ENCODE_FAILED;
+ if(!st || !st->buf) {
+ ASN__ENCODE_FAILED;
+ }
- er.encoded = OBJECT_IDENTIFIER__dump_body(st, cb, app_key);
- if(er.encoded < 0) _ASN_ENCODE_FAILED;
+ er.encoded = OBJECT_IDENTIFIER__dump_body(st, cb, app_key);
+ if(er.encoded < 0) ASN__ENCODE_FAILED;
- _ASN_ENCODED_OK(er);
+ ASN__ENCODED_OK(er);
}
int
-OBJECT_IDENTIFIER_print(asn_TYPE_descriptor_t *td, const void *sptr,
- int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
- const OBJECT_IDENTIFIER_t *st = (const OBJECT_IDENTIFIER_t *)sptr;
+OBJECT_IDENTIFIER_print(const asn_TYPE_descriptor_t *td, const void *sptr,
+ int ilevel, asn_app_consume_bytes_f *cb,
+ void *app_key) {
+ const OBJECT_IDENTIFIER_t *st = (const OBJECT_IDENTIFIER_t *)sptr;
(void)td; /* Unused argument */
(void)ilevel; /* Unused argument */
@@ -350,309 +270,206 @@ OBJECT_IDENTIFIER_print(asn_TYPE_descriptor_t *td, const void *sptr,
if(cb("{ ", 2, app_key) < 0)
return -1;
- if(OBJECT_IDENTIFIER__dump_body(st, cb, app_key) < 0)
- return -1;
+ if(OBJECT_IDENTIFIER__dump_body(st, cb, app_key) < 0) {
+ return -1;
+ }
- return (cb(" }", 2, app_key) < 0) ? -1 : 0;
+ return (cb(" }", 2, app_key) < 0) ? -1 : 0;
}
-int
-OBJECT_IDENTIFIER_get_arcs(OBJECT_IDENTIFIER_t *oid, void *arcs,
- unsigned int arc_type_size, unsigned int arc_slots) {
- void *arcs_end = (char *)arcs + (arc_type_size * arc_slots);
- int num_arcs = 0;
- int startn = 0;
- int add = 0;
- int i;
-
- if(!oid || !oid->buf || (arc_slots && arc_type_size <= 1)) {
- errno = EINVAL;
- return -1;
- }
-
- for(i = 0; i < oid->size; i++) {
- uint8_t b = oid->buf[i];
- if((b & 0x80)) /* Continuation expected */
- continue;
-
- if(num_arcs == 0) {
- /*
- * First two arcs are encoded through the backdoor.
- */
- unsigned LE = 1; /* Little endian */
- int first_arc;
- num_arcs++;
- if(!arc_slots) { num_arcs++; continue; }
-
- if(i) first_arc = 2;
- else if(b <= 39) first_arc = 0;
- else if(b < 79) first_arc = 1;
- else first_arc = 2;
-
- add = -40 * first_arc;
- memset(arcs, 0, arc_type_size);
- *(unsigned char *)((char *)arcs
- + ((*(char *)&LE)?0:(arc_type_size - 1)))
- = first_arc;
- arcs = ((char *)arcs) + arc_type_size;
- }
-
- /* Decode, if has space */
- if(arcs < arcs_end) {
- if(OBJECT_IDENTIFIER_get_single_arc(&oid->buf[startn],
- i - startn + 1, add,
- arcs, arc_type_size))
- return -1;
- startn = i + 1;
- arcs = ((char *)arcs) + arc_type_size;
- add = 0;
- }
- num_arcs++;
- }
-
- return num_arcs;
+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, arc1;
+ 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.
*/
-int
-OBJECT_IDENTIFIER_set_single_arc(uint8_t *arcbuf, const void *arcval, unsigned int arcval_size, int prepared_order) {
- /*
+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(arcval);
- * assert(arcval_size > 0);
- * assert(arcval_size <= 16);
* assert(arcbuf);
*/
-#ifdef WORDS_BIGENDIAN
- const unsigned isLittleEndian = 0;
-#else
- unsigned LE = 1;
- unsigned isLittleEndian = *(char *)&LE;
-#endif
- const uint8_t *tend, *tp;
- unsigned int cache;
- uint8_t *bp = arcbuf;
- int bits;
- uint8_t buffer[16];
-
- if(isLittleEndian && !prepared_order) {
- const uint8_t *a = (const unsigned char *)arcval + arcval_size - 1;
- const uint8_t *aend = (const uint8_t *)arcval;
- uint8_t *msb = buffer + arcval_size - 1;
- uint8_t *tb;
- for(tb = buffer; a >= aend; tb++, a--)
- if((*tb = *a) && (tb < msb))
- msb = tb;
- tend = &buffer[arcval_size];
- tp = msb; /* Most significant non-zero byte */
- } else {
- /* Look for most significant non-zero byte */
- tend = (const unsigned char *)arcval + arcval_size;
- for(tp = (const uint8_t *)arcval; tp < tend - 1; tp++)
- if(*tp) break;
- }
+ 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;
- /*
- * Split the value in 7-bits chunks.
- */
- bits = ((tend - tp) * CHAR_BIT) % 7;
- if(bits) {
- cache = *tp >> (CHAR_BIT - bits);
- if(cache) {
- *bp++ = cache | 0x80;
- cache = *tp++;
- bits = CHAR_BIT - bits;
- } else {
- bits = -bits;
- }
- } else {
- cache = 0;
- }
- for(; tp < tend; tp++) {
- cache = (cache << CHAR_BIT) + *tp;
- bits += CHAR_BIT;
- while(bits >= 7) {
- bits -= 7;
- *bp++ = 0x80 | (cache >> bits);
- }
- }
- if(bits) *bp++ = cache;
- bp[-1] &= 0x7f; /* Clear the last bit */
+ for(b = scratch_end, mask = 0; ; mask = 0x80, b--) {
+ *b = mask | (value & 0x7f);
+ value >>= 7;
+ if(!value) {
+ break;
+ }
+ }
- return bp - arcbuf;
+ 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 *oid, const void *arcs, unsigned int arc_type_size, unsigned int arc_slots) {
- uint8_t *buf;
- uint8_t *bp;
- unsigned LE = 1; /* Little endian (x86) */
- unsigned isLittleEndian = *((char *)&LE);
- unsigned int arc0;
- unsigned int arc1;
- unsigned size;
- unsigned i;
-
- if(!oid || !arcs || arc_type_size < 1
- || arc_type_size > 16
- || arc_slots < 2) {
- errno = EINVAL;
+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;
}
- switch(arc_type_size) {
- case sizeof(char):
- arc0 = ((const unsigned char *)arcs)[0];
- arc1 = ((const unsigned char *)arcs)[1];
- break;
- case sizeof(short):
- arc0 = ((const unsigned short *)arcs)[0];
- arc1 = ((const unsigned short *)arcs)[1];
- break;
- case sizeof(int):
- arc0 = ((const unsigned int *)arcs)[0];
- arc1 = ((const unsigned int *)arcs)[1];
- break;
- default:
- arc1 = arc0 = 0;
- if(isLittleEndian) { /* Little endian (x86) */
- const unsigned char *ps, *pe;
- /* If more significant bytes are present,
- * make them > 255 quick */
- for(ps = (const unsigned char *)arcs + 1, pe = ps+arc_type_size;
- ps < pe; ps++)
- arc0 |= *ps, arc1 |= *(ps + arc_type_size);
- arc0 <<= CHAR_BIT, arc1 <<= CHAR_BIT;
- arc0 = *((const unsigned char *)arcs + 0);
- arc1 = *((const unsigned char *)arcs + arc_type_size);
- } else {
- const unsigned char *ps, *pe;
- /* If more significant bytes are present,
- * make them > 255 quick */
- for(ps = (const unsigned char *)arcs, pe = ps+arc_type_size - 1; ps < pe; ps++)
- arc0 |= *ps, arc1 |= *(ps + arc_type_size);
- arc0 = *((const unsigned char *)arcs + arc_type_size - 1);
- arc1 = *((const unsigned char *)arcs +(arc_type_size<< 1)-1);
- }
- }
+ arc0 = arcs[0];
+ arc1 = arcs[1];
- /*
- * The previous chapter left us with the first and the second arcs.
- * The values are not precise (that is, they are valid only if
- * they're less than 255), but OK for the purposes of making
- * the sanity test below.
- */
if(arc0 <= 1) {
- if(arc1 >= 39) {
+ if(arc1 >= 40) {
/* 8.19.4: At most 39 subsequent values (including 0) */
errno = ERANGE;
return -1;
}
- } else if(arc0 > 2) {
- /* 8.19.4: Only three values are allocated from the root node */
- 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 = ((arc_type_size * CHAR_BIT + 6) / 7) * arc_slots;
- bp = buf = (uint8_t *)MALLOC(size + 1);
- if(!buf) {
- /* ENOMEM */
- return -1;
- }
-
- /*
- * Encode the first two arcs.
- * These require special treatment.
- */
- {
- uint8_t *tp;
- uint8_t first_value[1 + 16]; /* of two arcs */
- uint8_t *fv = first_value;
-
- /*
- * Simulate first_value = arc0 * 40 + arc1;
- */
- /* Copy the second (1'st) arcs[1] into the first_value */
- *fv++ = 0;
- arcs = ((const char *)arcs) + arc_type_size;
- if(isLittleEndian) {
- const uint8_t *aend = (const unsigned char *)arcs - 1;
- const uint8_t *a1 = (const unsigned char *)arcs + arc_type_size - 1;
- for(; a1 > aend; fv++, a1--) *fv = *a1;
- } else {
- const uint8_t *a1 = (const uint8_t *)arcs;
- const uint8_t *aend = a1 + arc_type_size;
- for(; a1 < aend; fv++, a1++) *fv = *a1;
- }
- /* Increase the first_value by arc0 */
- arc0 *= 40; /* (0..80) */
- for(tp = first_value + arc_type_size; tp >= first_value; tp--) {
- unsigned int v = *tp;
- v += arc0;
- *tp = v;
- if(v >= (1 << CHAR_BIT)) arc0 = v >> CHAR_BIT;
- else break;
- }
-
- assert(tp >= first_value);
-
- bp += OBJECT_IDENTIFIER_set_single_arc(bp, first_value,
- fv - first_value, 1);
- }
-
- /*
- * Save the rest of arcs.
- */
- for(arcs = ((const char *)arcs) + arc_type_size, i = 2;
- i < arc_slots;
- i++, arcs = ((const char *)arcs) + arc_type_size) {
- bp += OBJECT_IDENTIFIER_set_single_arc(bp,
- arcs, arc_type_size, 0);
- }
-
- assert((unsigned)(bp - buf) <= size);
-
- /*
+ /*
+ * 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.
*/
- oid->size = bp - buf;
- bp = oid->buf;
- oid->buf = buf;
+ st->size = bp - buf;
+ bp = st->buf;
+ st->buf = buf;
+ st->buf[st->size] = '\0';
if(bp) FREEMEM(bp);
return 0;
}
-
-int
+ssize_t
OBJECT_IDENTIFIER_parse_arcs(const char *oid_text, ssize_t oid_txt_length,
- long *arcs, unsigned int arcs_slots, const char **opt_oid_text_end) {
- unsigned int arcs_count = 0;
- const char *oid_end;
- long value = 0;
+ 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_SKIPSPACE,
- ST_WAITDIGITS, /* Next character is expected to be a digit */
- ST_DIGITS
- } state = ST_SKIPSPACE;
+ 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_slots && !arcs)) {
+ 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;
@@ -661,41 +478,77 @@ OBJECT_IDENTIFIER_parse_arcs(const char *oid_text, ssize_t oid_txt_length,
if(oid_txt_length == -1)
oid_txt_length = strlen(oid_text);
- for(oid_end = oid_text + oid_txt_length; oid_text<oid_end; 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 */
- if(state == ST_SKIPSPACE) {
+ switch(state) {
+ case ST_LEADSPACE:
+ case ST_TAILSPACE:
continue;
- } else {
- break; /* Finish */
+ case ST_AFTERVALUE:
+ state = ST_TAILSPACE;
+ continue;
+ case ST_WAITDIGITS:
+ break; /* Digits expected after ".", got whitespace */
}
+ break;
case 0x2e: /* '.' */
- if(state != ST_DIGITS
- || (oid_text + 1) == oid_end) {
- state = ST_WAITDIGITS;
+ 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;
}
- if(arcs_count < arcs_slots)
- arcs[arcs_count] = value;
- arcs_count++;
- 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:
- if(state != ST_DIGITS) {
- state = ST_DIGITS;
- value = 0;
- }
- if(1) {
- long new_value = value * 10;
- if(new_value / 10 != value
- || (value = new_value + (*oid_text - 0x30)) < 0) {
- /* Overflow */
- state = ST_WAITDIGITS;
- break;
- }
+ 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;
@@ -709,17 +562,82 @@ OBJECT_IDENTIFIER_parse_arcs(const char *oid_text, ssize_t oid_txt_length,
/* Finalize last arc */
switch(state) {
+ case ST_LEADSPACE:
+ return 0; /* No OID found in input data */
case ST_WAITDIGITS:
- errno = EINVAL;
+ errno = EINVAL; /* Broken OID */
return -1;
- case ST_DIGITS:
- if(arcs_count < arcs_slots)
- arcs[arcs_count] = value;
- arcs_count++;
- /* Fall through */
- default:
- return arcs_count;
+ case ST_AFTERVALUE:
+ case ST_TAILSPACE:
+ return num_arcs;
}
+
+ errno = EINVAL; /* Broken OID */
+ return -1;
}
+/*
+ * Generate values from the list of interesting values, or just a random
+ * value up to the upper limit.
+ */
+static asn_oid_arc_t
+OBJECT_IDENTIFIER__biased_random_arc(asn_oid_arc_t upper_bound) {
+ const asn_oid_arc_t values[] = {0, 1, 127, 128, 129, 254, 255, 256};
+ size_t idx;
+
+ switch(asn_random_between(0, 2)) {
+ case 0:
+ idx = asn_random_between(0, sizeof(values) / sizeof(values[0]) - 1);
+ if(values[idx] < upper_bound) {
+ return values[idx];
+ }
+ /* Fall through */
+ case 1:
+ return asn_random_between(0, upper_bound);
+ case 2:
+ default:
+ return upper_bound;
+ }
+}
+asn_random_fill_result_t
+OBJECT_IDENTIFIER_random_fill(const asn_TYPE_descriptor_t *td, void **sptr,
+ const asn_encoding_constraints_t *constraints,
+ size_t max_length) {
+ asn_random_fill_result_t result_ok = {ARFILL_OK, 1};
+ asn_random_fill_result_t result_failed = {ARFILL_FAILED, 0};
+ asn_random_fill_result_t result_skipped = {ARFILL_SKIPPED, 0};
+ OBJECT_IDENTIFIER_t *st;
+ asn_oid_arc_t arcs[5];
+ size_t arcs_len = asn_random_between(2, 5);
+ size_t i;
+
+ (void)constraints;
+
+ if(max_length < arcs_len) return result_skipped;
+
+ if(*sptr) {
+ st = *sptr;
+ } else {
+ st = CALLOC(1, sizeof(*st));
+ }
+
+ arcs[0] = asn_random_between(0, 2);
+ arcs[1] = OBJECT_IDENTIFIER__biased_random_arc(
+ arcs[0] <= 1 ? 39 : (ASN_OID_ARC_MAX - 80));
+ for(i = 2; i < arcs_len; i++) {
+ arcs[i] = OBJECT_IDENTIFIER__biased_random_arc(ASN_OID_ARC_MAX);
+ }
+
+ if(OBJECT_IDENTIFIER_set_arcs(st, arcs, arcs_len)) {
+ if(st != *sptr) {
+ ASN_STRUCT_FREE(*td, st);
+ }
+ return result_failed;
+ }
+
+ *sptr = st;
+
+ result_ok.length = st->size;
+ return result_ok;
+}