X-Git-Url: https://git.stg.codes/stg.git/blobdiff_plain/4271ab433cd55bbd2612292bcf39e4dc3d7274f1..2196a3a0cdc5384c082febb7f4aa5994cc7d80db:/libs/smux/OBJECT_IDENTIFIER.c diff --git a/libs/smux/OBJECT_IDENTIFIER.c b/libs/smux/OBJECT_IDENTIFIER.c index d0f8b311..290545d1 100644 --- a/libs/smux/OBJECT_IDENTIFIER.c +++ b/libs/smux/OBJECT_IDENTIFIER.c @@ -15,35 +15,51 @@ 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, +#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, - 0, /* Use generic outmost tag fetcher */ +#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) { @@ -63,285 +79,186 @@ OBJECT_IDENTIFIER_constraint(asn_TYPE_descriptor_t *td, const void *sptr, return 0; } - -int -OBJECT_IDENTIFIER_get_single_arc(const uint8_t *arcbuf, unsigned int arclen, signed int add, void *rvbufp, unsigned int rvsize) { - unsigned LE GCC_NOTUSED = 1; /* Little endian (x86) */ - const 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 *)(void *)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 & ((unsigned)~0 << 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(const 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 */ - char *p; /* Position in the scratch buffer */ - - if(OBJECT_IDENTIFIER_get_single_arc(arcbuf, arclen, add, - &accum, sizeof(accum))) - return -1; +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(accum) { - ssize_t len; - - /* Fill the scratch buffer in reverse. */ - p = scratch + sizeof(scratch); - 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(const 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(arcs_count == 0) { + } else if(num_arcs == 0) { return XPBD_NOT_BODY_IGNORE; } 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 */ @@ -353,301 +270,198 @@ 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(const 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; + } + } + + result_len = (scratch_end - b) + 1; - return bp - arcbuf; + 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; + 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, @@ -655,7 +469,7 @@ OBJECT_IDENTIFIER_parse_arcs(const char *oid_text, ssize_t oid_txt_length, 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; @@ -664,32 +478,33 @@ OBJECT_IDENTIFIER_parse_arcs(const char *oid_text, ssize_t oid_txt_length, 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; \ - long value; \ - switch(asn_strtol_lim(oid_text, &endp, &value)) { \ - case ASN_STRTOL_EXTRA_DATA: \ - case ASN_STRTOL_OK: \ - if(arcs_count < arcs_slots) \ - arcs[arcs_count] = value; \ - arcs_count++; \ - oid_text = endp - 1; \ - break; \ - case ASN_STRTOL_ERROR_RANGE: \ - if(opt_oid_text_end) \ - *opt_oid_text_end = oid_text; \ - errno = ERANGE; \ - return -1; \ - case ASN_STRTOL_ERROR_INVAL: \ - case ASN_STRTOL_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_textsize; + return result_ok; +}