/*- * Copyright (c) 2003-2014 Lev Walkin . * All rights reserved. * Redistribution and modifications are permitted subject to BSD license. */ #include #include #include /* Encoder and decoder of a primitive type */ #include /* * INTEGER basic type description. */ static const ber_tlv_tag_t asn_DEF_INTEGER_tags[] = { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)) }; asn_TYPE_operation_t asn_OP_INTEGER = { INTEGER_free, INTEGER_print, INTEGER_compare, ber_decode_primitive, INTEGER_encode_der, INTEGER_decode_xer, INTEGER_encode_xer, #ifdef ASN_DISABLE_OER_SUPPORT 0, 0, #else INTEGER_decode_oer, /* OER decoder */ INTEGER_encode_oer, /* Canonical OER encoder */ #endif /* ASN_DISABLE_OER_SUPPORT */ #ifdef ASN_DISABLE_PER_SUPPORT 0, 0, 0, 0, #else INTEGER_decode_uper, /* Unaligned PER decoder */ INTEGER_encode_uper, /* Unaligned PER encoder */ INTEGER_decode_aper, /* Aligned PER decoder */ INTEGER_encode_aper, /* Aligned PER encoder */ #endif /* ASN_DISABLE_PER_SUPPORT */ INTEGER_random_fill, 0 /* Use generic outmost tag fetcher */ }; asn_TYPE_descriptor_t asn_DEF_INTEGER = { "INTEGER", "INTEGER", &asn_OP_INTEGER, asn_DEF_INTEGER_tags, sizeof(asn_DEF_INTEGER_tags) / sizeof(asn_DEF_INTEGER_tags[0]), asn_DEF_INTEGER_tags, /* Same as above */ sizeof(asn_DEF_INTEGER_tags) / sizeof(asn_DEF_INTEGER_tags[0]), { 0, 0, asn_generic_no_constraint }, 0, 0, /* No members */ 0 /* No specifics */ }; /* * Encode INTEGER type using DER. */ asn_enc_rval_t INTEGER_encode_der(const asn_TYPE_descriptor_t *td, const void *sptr, int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) { const INTEGER_t *st = (const INTEGER_t *)sptr; asn_enc_rval_t rval; INTEGER_t effective_integer; ASN_DEBUG("%s %s as INTEGER (tm=%d)", cb?"Encoding":"Estimating", td->name, tag_mode); /* * Canonicalize integer in the buffer. * (Remove too long sign extension, remove some first 0x00 bytes) */ if(st->buf) { uint8_t *buf = st->buf; uint8_t *end1 = buf + st->size - 1; int shift; /* Compute the number of superfluous leading bytes */ for(; buf < end1; buf++) { /* * If the contents octets of an integer value encoding * consist of more than one octet, then the bits of the * first octet and bit 8 of the second octet: * a) shall not all be ones; and * b) shall not all be zero. */ switch(*buf) { case 0x00: if((buf[1] & 0x80) == 0) continue; break; case 0xff: if((buf[1] & 0x80)) continue; break; } break; } /* Remove leading superfluous bytes from the integer */ shift = buf - st->buf; if(shift) { union { const uint8_t *c_buf; uint8_t *nc_buf; } unconst; unconst.c_buf = st->buf; effective_integer.buf = unconst.nc_buf + shift; effective_integer.size = st->size - shift; st = &effective_integer; } } rval = der_encode_primitive(td, st, tag_mode, tag, cb, app_key); if(rval.structure_ptr == &effective_integer) { rval.structure_ptr = sptr; } return rval; } static const asn_INTEGER_enum_map_t *INTEGER_map_enum2value( const asn_INTEGER_specifics_t *specs, const char *lstart, const char *lstop); /* * INTEGER specific human-readable output. */ static ssize_t INTEGER__dump(const asn_TYPE_descriptor_t *td, const INTEGER_t *st, asn_app_consume_bytes_f *cb, void *app_key, int plainOrXER) { const asn_INTEGER_specifics_t *specs = (const asn_INTEGER_specifics_t *)td->specifics; char scratch[32]; uint8_t *buf = st->buf; uint8_t *buf_end = st->buf + st->size; intmax_t value; ssize_t wrote = 0; char *p; int ret; if(specs && specs->field_unsigned) ret = asn_INTEGER2umax(st, (uintmax_t *)&value); else ret = asn_INTEGER2imax(st, &value); /* Simple case: the integer size is small */ if(ret == 0) { const asn_INTEGER_enum_map_t *el; el = (value >= 0 || !specs || !specs->field_unsigned) ? INTEGER_map_value2enum(specs, value) : 0; if(el) { if(plainOrXER == 0) return asn__format_to_callback(cb, app_key, "%" ASN_PRIdMAX " (%s)", value, el->enum_name); else return asn__format_to_callback(cb, app_key, "<%s/>", el->enum_name); } else if(plainOrXER && specs && specs->strict_enumeration) { ASN_DEBUG("ASN.1 forbids dealing with " "unknown value of ENUMERATED type"); errno = EPERM; return -1; } else { return asn__format_to_callback(cb, app_key, (specs && specs->field_unsigned) ? "%" ASN_PRIuMAX : "%" ASN_PRIdMAX, value); } } else if(plainOrXER && specs && specs->strict_enumeration) { /* * Here and earlier, we cannot encode the ENUMERATED values * if there is no corresponding identifier. */ ASN_DEBUG("ASN.1 forbids dealing with " "unknown value of ENUMERATED type"); errno = EPERM; return -1; } /* Output in the long xx:yy:zz... format */ /* TODO: replace with generic algorithm (Knuth TAOCP Vol 2, 4.3.1) */ for(p = scratch; buf < buf_end; buf++) { const char * const h2c = "0123456789ABCDEF"; if((p - scratch) >= (ssize_t)(sizeof(scratch) - 4)) { /* Flush buffer */ if(cb(scratch, p - scratch, app_key) < 0) return -1; wrote += p - scratch; p = scratch; } *p++ = h2c[*buf >> 4]; *p++ = h2c[*buf & 0x0F]; *p++ = 0x3a; /* ":" */ } if(p != scratch) p--; /* Remove the last ":" */ wrote += p - scratch; return (cb(scratch, p - scratch, app_key) < 0) ? -1 : wrote; } /* * INTEGER specific human-readable output. */ int INTEGER_print(const asn_TYPE_descriptor_t *td, const void *sptr, int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { const INTEGER_t *st = (const INTEGER_t *)sptr; ssize_t ret; (void)ilevel; if(!st || !st->buf) ret = cb("", 8, app_key); else ret = INTEGER__dump(td, st, cb, app_key, 0); return (ret < 0) ? -1 : 0; } struct e2v_key { const char *start; const char *stop; const asn_INTEGER_enum_map_t *vemap; const unsigned int *evmap; }; static int INTEGER__compar_enum2value(const void *kp, const void *am) { const struct e2v_key *key = (const struct e2v_key *)kp; const asn_INTEGER_enum_map_t *el = (const asn_INTEGER_enum_map_t *)am; const char *ptr, *end, *name; /* Remap the element (sort by different criterion) */ el = key->vemap + key->evmap[el - key->vemap]; /* Compare strings */ for(ptr = key->start, end = key->stop, name = el->enum_name; ptr < end; ptr++, name++) { if(*ptr != *name || !*name) return *(const unsigned char *)ptr - *(const unsigned char *)name; } return name[0] ? -1 : 0; } static const asn_INTEGER_enum_map_t * INTEGER_map_enum2value(const asn_INTEGER_specifics_t *specs, const char *lstart, const char *lstop) { const asn_INTEGER_enum_map_t *el_found; int count = specs ? specs->map_count : 0; struct e2v_key key; const char *lp; if(!count) return NULL; /* Guaranteed: assert(lstart < lstop); */ /* Figure out the tag name */ for(lstart++, lp = lstart; lp < lstop; lp++) { switch(*lp) { case 9: case 10: case 11: case 12: case 13: case 32: /* WSP */ case 0x2f: /* '/' */ case 0x3e: /* '>' */ break; default: continue; } break; } if(lp == lstop) return NULL; /* No tag found */ lstop = lp; key.start = lstart; key.stop = lstop; key.vemap = specs->value2enum; key.evmap = specs->enum2value; el_found = (asn_INTEGER_enum_map_t *)bsearch(&key, specs->value2enum, count, sizeof(specs->value2enum[0]), INTEGER__compar_enum2value); if(el_found) { /* Remap enum2value into value2enum */ el_found = key.vemap + key.evmap[el_found - key.vemap]; } return el_found; } static int INTEGER__compar_value2enum(const void *kp, const void *am) { long a = *(const long *)kp; const asn_INTEGER_enum_map_t *el = (const asn_INTEGER_enum_map_t *)am; long b = el->nat_value; if(a < b) return -1; else if(a == b) return 0; else return 1; } const asn_INTEGER_enum_map_t * INTEGER_map_value2enum(const asn_INTEGER_specifics_t *specs, long value) { int count = specs ? specs->map_count : 0; if(!count) return 0; return (asn_INTEGER_enum_map_t *)bsearch(&value, specs->value2enum, count, sizeof(specs->value2enum[0]), INTEGER__compar_value2enum); } static int INTEGER_st_prealloc(INTEGER_t *st, int min_size) { void *p = MALLOC(min_size + 1); if(p) { void *b = st->buf; st->size = 0; st->buf = p; FREEMEM(b); return 0; } else { return -1; } } /* * Decode the chunk of XML text encoding INTEGER. */ static enum xer_pbd_rval INTEGER__xer_body_decode(const asn_TYPE_descriptor_t *td, void *sptr, const void *chunk_buf, size_t chunk_size) { const asn_INTEGER_specifics_t *specs = (const asn_INTEGER_specifics_t *)td->specifics; INTEGER_t *st = (INTEGER_t *)sptr; intmax_t dec_value; intmax_t hex_value = 0; const char *lp; const char *lstart = (const char *)chunk_buf; const char *lstop = lstart + chunk_size; enum { ST_LEADSPACE, ST_SKIPSPHEX, ST_WAITDIGITS, ST_DIGITS, ST_DIGITS_TRAILSPACE, ST_HEXDIGIT1, ST_HEXDIGIT2, ST_HEXDIGITS_TRAILSPACE, ST_HEXCOLON, ST_END_ENUM, ST_UNEXPECTED } state = ST_LEADSPACE; const char *dec_value_start = 0; /* INVARIANT: always !0 in ST_DIGITS */ const char *dec_value_end = 0; if(chunk_size) ASN_DEBUG("INTEGER body %ld 0x%2x..0x%2x", (long)chunk_size, *lstart, lstop[-1]); if(INTEGER_st_prealloc(st, (chunk_size/3) + 1)) return XPBD_SYSTEM_FAILURE; /* * We may have received a tag here. It will be processed inline. * Use strtoul()-like code and serialize the result. */ for(lp = lstart; lp < lstop; lp++) { int lv = *lp; switch(lv) { case 0x09: case 0x0a: case 0x0d: case 0x20: switch(state) { case ST_LEADSPACE: case ST_DIGITS_TRAILSPACE: case ST_HEXDIGITS_TRAILSPACE: case ST_SKIPSPHEX: continue; case ST_DIGITS: dec_value_end = lp; state = ST_DIGITS_TRAILSPACE; continue; case ST_HEXCOLON: state = ST_HEXDIGITS_TRAILSPACE; continue; default: break; } break; case 0x2d: /* '-' */ if(state == ST_LEADSPACE) { dec_value = 0; dec_value_start = lp; state = ST_WAITDIGITS; continue; } break; case 0x2b: /* '+' */ if(state == ST_LEADSPACE) { dec_value = 0; dec_value_start = lp; 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_DIGITS: continue; case ST_SKIPSPHEX: /* Fall through */ case ST_HEXDIGIT1: hex_value = (lv - 0x30) << 4; state = ST_HEXDIGIT2; continue; case ST_HEXDIGIT2: hex_value += (lv - 0x30); state = ST_HEXCOLON; st->buf[st->size++] = (uint8_t)hex_value; continue; case ST_HEXCOLON: return XPBD_BROKEN_ENCODING; case ST_LEADSPACE: dec_value = 0; dec_value_start = lp; /* FALL THROUGH */ case ST_WAITDIGITS: state = ST_DIGITS; continue; default: break; } break; case 0x3c: /* '<', start of XML encoded enumeration */ if(state == ST_LEADSPACE) { const asn_INTEGER_enum_map_t *el; el = INTEGER_map_enum2value( (const asn_INTEGER_specifics_t *) td->specifics, lstart, lstop); if(el) { ASN_DEBUG("Found \"%s\" => %ld", el->enum_name, el->nat_value); dec_value = el->nat_value; state = ST_END_ENUM; lp = lstop - 1; continue; } ASN_DEBUG("Unknown identifier for INTEGER"); } return XPBD_BROKEN_ENCODING; case 0x3a: /* ':' */ if(state == ST_HEXCOLON) { /* This colon is expected */ state = ST_HEXDIGIT1; continue; } else if(state == ST_DIGITS) { /* The colon here means that we have * decoded the first two hexadecimal * places as a decimal value. * Switch decoding mode. */ ASN_DEBUG("INTEGER re-evaluate as hex form"); state = ST_SKIPSPHEX; dec_value_start = 0; lp = lstart - 1; continue; } else { ASN_DEBUG("state %d at %ld", state, (long)(lp - lstart)); break; } /* [A-Fa-f] */ case 0x41:case 0x42:case 0x43:case 0x44:case 0x45:case 0x46: case 0x61:case 0x62:case 0x63:case 0x64:case 0x65:case 0x66: switch(state) { case ST_SKIPSPHEX: case ST_LEADSPACE: /* Fall through */ case ST_HEXDIGIT1: hex_value = lv - ((lv < 0x61) ? 0x41 : 0x61); hex_value += 10; hex_value <<= 4; state = ST_HEXDIGIT2; continue; case ST_HEXDIGIT2: hex_value += lv - ((lv < 0x61) ? 0x41 : 0x61); hex_value += 10; st->buf[st->size++] = (uint8_t)hex_value; state = ST_HEXCOLON; continue; case ST_DIGITS: ASN_DEBUG("INTEGER re-evaluate as hex form"); state = ST_SKIPSPHEX; dec_value_start = 0; lp = lstart - 1; continue; default: break; } break; } /* Found extra non-numeric stuff */ ASN_DEBUG("INTEGER :: Found non-numeric 0x%2x at %ld", lv, (long)(lp - lstart)); state = ST_UNEXPECTED; break; } switch(state) { case ST_END_ENUM: /* Got a complete and valid enumeration encoded as a tag. */ break; case ST_DIGITS: dec_value_end = lstop; /* FALL THROUGH */ case ST_DIGITS_TRAILSPACE: /* The last symbol encountered was a digit. */ switch(asn_strtoimax_lim(dec_value_start, &dec_value_end, &dec_value)) { case ASN_STRTOX_OK: if(specs && specs->field_unsigned && (uintmax_t) dec_value <= ULONG_MAX) { break; } else if(dec_value >= LONG_MIN && dec_value <= LONG_MAX) { break; } else { /* * We model INTEGER on long for XER, * to avoid rewriting all the tests at once. */ ASN_DEBUG("INTEGER exceeds long range"); } /* Fall through */ case ASN_STRTOX_ERROR_RANGE: ASN_DEBUG("INTEGER decode %s hit range limit", td->name); return XPBD_DECODER_LIMIT; case ASN_STRTOX_ERROR_INVAL: case ASN_STRTOX_EXPECT_MORE: case ASN_STRTOX_EXTRA_DATA: return XPBD_BROKEN_ENCODING; } break; case ST_HEXCOLON: case ST_HEXDIGITS_TRAILSPACE: st->buf[st->size] = 0; /* Just in case termination */ return XPBD_BODY_CONSUMED; case ST_HEXDIGIT1: case ST_HEXDIGIT2: case ST_SKIPSPHEX: return XPBD_BROKEN_ENCODING; case ST_LEADSPACE: /* Content not found */ return XPBD_NOT_BODY_IGNORE; case ST_WAITDIGITS: case ST_UNEXPECTED: ASN_DEBUG("INTEGER: No useful digits (state %d)", state); return XPBD_BROKEN_ENCODING; /* No digits */ } /* * Convert the result of parsing of enumeration or a straight * decimal value into a BER representation. */ if(asn_imax2INTEGER(st, dec_value)) { ASN_DEBUG("INTEGER decode %s conversion failed", td->name); return XPBD_SYSTEM_FAILURE; } return XPBD_BODY_CONSUMED; } asn_dec_rval_t INTEGER_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(INTEGER_t), opt_mname, buf_ptr, size, INTEGER__xer_body_decode); } asn_enc_rval_t INTEGER_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 INTEGER_t *st = (const INTEGER_t *)sptr; asn_enc_rval_t er = {0,0,0}; (void)ilevel; (void)flags; if(!st || !st->buf) ASN__ENCODE_FAILED; er.encoded = INTEGER__dump(td, st, cb, app_key, 1); if(er.encoded < 0) ASN__ENCODE_FAILED; ASN__ENCODED_OK(er); } #ifndef ASN_DISABLE_PER_SUPPORT asn_dec_rval_t INTEGER_decode_uper(const asn_codec_ctx_t *opt_codec_ctx, const asn_TYPE_descriptor_t *td, const asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) { const asn_INTEGER_specifics_t *specs = (const asn_INTEGER_specifics_t *)td->specifics; asn_dec_rval_t rval = { RC_OK, 0 }; INTEGER_t *st = (INTEGER_t *)*sptr; const asn_per_constraint_t *ct; int repeat; (void)opt_codec_ctx; if(!st) { st = (INTEGER_t *)(*sptr = CALLOC(1, sizeof(*st))); if(!st) ASN__DECODE_FAILED; } if(!constraints) constraints = td->encoding_constraints.per_constraints; ct = constraints ? &constraints->value : 0; if(ct && ct->flags & APC_EXTENSIBLE) { int inext = per_get_few_bits(pd, 1); if(inext < 0) ASN__DECODE_STARVED; if(inext) ct = 0; } FREEMEM(st->buf); st->buf = 0; st->size = 0; if(ct) { if(ct->flags & APC_SEMI_CONSTRAINED) { st->buf = (uint8_t *)CALLOC(1, 2); if(!st->buf) ASN__DECODE_FAILED; st->size = 1; } else if(ct->flags & APC_CONSTRAINED && ct->range_bits >= 0) { size_t size = (ct->range_bits + 7) >> 3; st->buf = (uint8_t *)MALLOC(1 + size + 1); if(!st->buf) ASN__DECODE_FAILED; st->size = size; } } /* X.691-2008/11, #13.2.2, constrained whole number */ if(ct && ct->flags != APC_UNCONSTRAINED) { /* #11.5.6 */ ASN_DEBUG("Integer with range %d bits", ct->range_bits); if(ct->range_bits >= 0) { if((size_t)ct->range_bits > 8 * sizeof(unsigned long)) ASN__DECODE_FAILED; if(specs && specs->field_unsigned) { unsigned long uvalue = 0; if(uper_get_constrained_whole_number(pd, &uvalue, ct->range_bits)) ASN__DECODE_STARVED; ASN_DEBUG("Got value %lu + low %ld", uvalue, ct->lower_bound); uvalue += ct->lower_bound; if(asn_ulong2INTEGER(st, uvalue)) ASN__DECODE_FAILED; } else { unsigned long uvalue = 0; long svalue; if(uper_get_constrained_whole_number(pd, &uvalue, ct->range_bits)) ASN__DECODE_STARVED; ASN_DEBUG("Got value %lu + low %ld", uvalue, ct->lower_bound); if(per_long_range_unrebase(uvalue, ct->lower_bound, ct->upper_bound, &svalue) || asn_long2INTEGER(st, svalue)) { ASN__DECODE_FAILED; } } return rval; } } else { ASN_DEBUG("Decoding unconstrained integer %s", td->name); } /* X.691, #12.2.3, #12.2.4 */ do { ssize_t len = 0; void *p = NULL; int ret = 0; /* Get the PER length */ len = uper_get_length(pd, -1, 0, &repeat); if(len < 0) ASN__DECODE_STARVED; p = REALLOC(st->buf, st->size + len + 1); if(!p) ASN__DECODE_FAILED; st->buf = (uint8_t *)p; ret = per_get_many_bits(pd, &st->buf[st->size], 0, 8 * len); if(ret < 0) ASN__DECODE_STARVED; st->size += len; } while(repeat); st->buf[st->size] = 0; /* JIC */ /* #12.2.3 */ if(ct && ct->lower_bound) { /* * TODO: replace by in-place arithmetics. */ long value = 0; if(asn_INTEGER2long(st, &value)) ASN__DECODE_FAILED; if(asn_imax2INTEGER(st, value + ct->lower_bound)) ASN__DECODE_FAILED; } return rval; } asn_enc_rval_t INTEGER_encode_uper(const asn_TYPE_descriptor_t *td, const asn_per_constraints_t *constraints, const void *sptr, asn_per_outp_t *po) { const asn_INTEGER_specifics_t *specs = (const asn_INTEGER_specifics_t *)td->specifics; asn_enc_rval_t er = {0,0,0}; const INTEGER_t *st = (const INTEGER_t *)sptr; const uint8_t *buf; const uint8_t *end; const asn_per_constraint_t *ct; long value = 0; if(!st || st->size == 0) ASN__ENCODE_FAILED; if(!constraints) constraints = td->encoding_constraints.per_constraints; ct = constraints ? &constraints->value : 0; er.encoded = 0; if(ct) { int inext = 0; if(specs && specs->field_unsigned) { unsigned long uval; if(asn_INTEGER2ulong(st, &uval)) ASN__ENCODE_FAILED; /* Check proper range */ if(ct->flags & APC_SEMI_CONSTRAINED) { if(uval < (unsigned long)ct->lower_bound) inext = 1; } else if(ct->range_bits >= 0) { if(uval < (unsigned long)ct->lower_bound || uval > (unsigned long)ct->upper_bound) inext = 1; } ASN_DEBUG("Value %lu (%02x/%" ASN_PRI_SIZE ") lb %lu ub %lu %s", uval, st->buf[0], st->size, ct->lower_bound, ct->upper_bound, inext ? "ext" : "fix"); value = uval; } else { if(asn_INTEGER2long(st, &value)) ASN__ENCODE_FAILED; /* Check proper range */ if(ct->flags & APC_SEMI_CONSTRAINED) { if(value < ct->lower_bound) inext = 1; } else if(ct->range_bits >= 0) { if(value < ct->lower_bound || value > ct->upper_bound) inext = 1; } ASN_DEBUG("Value %ld (%02x/%" ASN_PRI_SIZE ") lb %ld ub %ld %s", value, st->buf[0], st->size, ct->lower_bound, ct->upper_bound, inext ? "ext" : "fix"); } if(ct->flags & APC_EXTENSIBLE) { if(per_put_few_bits(po, inext, 1)) ASN__ENCODE_FAILED; if(inext) ct = 0; } else if(inext) { ASN__ENCODE_FAILED; } } /* X.691-11/2008, #13.2.2, test if constrained whole number */ if(ct && ct->range_bits >= 0) { unsigned long v; /* #11.5.6 -> #11.3 */ ASN_DEBUG("Encoding integer %ld (%lu) with range %d bits", value, value - ct->lower_bound, ct->range_bits); if(specs && specs->field_unsigned) { if ( ((unsigned long)ct->lower_bound > (unsigned long)(ct->upper_bound) || ((unsigned long)value < (unsigned long)ct->lower_bound)) || ((unsigned long)value > (unsigned long)ct->upper_bound) ) { ASN_DEBUG("Value %lu to-be-encoded is outside the bounds [%lu, %lu]!", value, ct->lower_bound, ct->upper_bound); ASN__ENCODE_FAILED; } v = (unsigned long)value - (unsigned long)ct->lower_bound; } else { if(per_long_range_rebase(value, ct->lower_bound, ct->upper_bound, &v)) { ASN__ENCODE_FAILED; } } if(uper_put_constrained_whole_number_u(po, v, ct->range_bits)) ASN__ENCODE_FAILED; ASN__ENCODED_OK(er); } if(ct && ct->lower_bound) { ASN_DEBUG("Adjust lower bound to %ld", ct->lower_bound); /* TODO: adjust lower bound */ ASN__ENCODE_FAILED; } for(buf = st->buf, end = st->buf + st->size; buf < end;) { int need_eom = 0; ssize_t mayEncode = uper_put_length(po, end - buf, &need_eom); if(mayEncode < 0) ASN__ENCODE_FAILED; if(per_put_many_bits(po, buf, 8 * mayEncode)) ASN__ENCODE_FAILED; buf += mayEncode; if(need_eom && uper_put_length(po, 0, 0)) ASN__ENCODE_FAILED; } ASN__ENCODED_OK(er); } asn_dec_rval_t INTEGER_decode_aper(const asn_codec_ctx_t *opt_codec_ctx, const asn_TYPE_descriptor_t *td, const asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) { const asn_INTEGER_specifics_t *specs = (const asn_INTEGER_specifics_t *)td->specifics; asn_dec_rval_t rval = { RC_OK, 0 }; INTEGER_t *st = (INTEGER_t *)*sptr; const asn_per_constraint_t *ct; int repeat; (void)opt_codec_ctx; if(!st) { st = (INTEGER_t *)(*sptr = CALLOC(1, sizeof(*st))); if(!st) ASN__DECODE_FAILED; } if(!constraints) constraints = td->encoding_constraints.per_constraints; ct = constraints ? &constraints->value : 0; if(ct && ct->flags & APC_EXTENSIBLE) { int inext = per_get_few_bits(pd, 1); if(inext < 0) ASN__DECODE_STARVED; if(inext) ct = 0; } FREEMEM(st->buf); st->buf = 0; st->size = 0; if(ct) { if(ct->flags & APC_SEMI_CONSTRAINED) { st->buf = (uint8_t *)CALLOC(1, 2); if(!st->buf) ASN__DECODE_FAILED; st->size = 1; } else if(ct->flags & APC_CONSTRAINED && ct->range_bits >= 0) { size_t size = (ct->range_bits + 7) >> 3; st->buf = (uint8_t *)MALLOC(1 + size + 1); if(!st->buf) ASN__DECODE_FAILED; st->size = size; } } /* X.691, #12.2.2 */ if(ct && ct->flags != APC_UNCONSTRAINED) { /* #10.5.6 */ ASN_DEBUG("Integer with range %d bits", ct->range_bits); if(ct->range_bits >= 0) { if (ct->range_bits > 16) { int max_range_bytes = (ct->range_bits >> 3) + (((ct->range_bits % 8) > 0) ? 1 : 0); int length = 0, i; long value = 0; for (i = 1; ; i++) { int upper = 1 << i; if (upper >= max_range_bytes) break; } ASN_DEBUG("Can encode %d (%d bytes) in %d bits", ct->range_bits, max_range_bytes, i); if ((length = per_get_few_bits(pd, i)) < 0) ASN__DECODE_FAILED; /* X.691 #12.2.6 length determinant + lb (1) */ length += 1; ASN_DEBUG("Got length %d", length); if (aper_get_align(pd) != 0) ASN__DECODE_FAILED; while (length--) { int buf = per_get_few_bits(pd, 8); if (buf < 0) ASN__DECODE_FAILED; value += (((long)buf) << (8 * length)); } value += ct->lower_bound; if((specs && specs->field_unsigned) ? asn_uint642INTEGER(st, (unsigned long)value) : asn_int642INTEGER(st, value)) ASN__DECODE_FAILED; ASN_DEBUG("Got value %ld + low %ld", value, ct->lower_bound); } else { long value = 0; if (ct->range_bits < 8) { value = per_get_few_bits(pd, ct->range_bits); if(value < 0) ASN__DECODE_STARVED; } else if (ct->range_bits == 8) { if (aper_get_align(pd) < 0) ASN__DECODE_FAILED; value = per_get_few_bits(pd, ct->range_bits); if(value < 0) ASN__DECODE_STARVED; } else { /* Align */ if (aper_get_align(pd) < 0) ASN__DECODE_FAILED; value = per_get_few_bits(pd, 16); if(value < 0) ASN__DECODE_STARVED; } value += ct->lower_bound; if((specs && specs->field_unsigned) ? asn_ulong2INTEGER(st, value) : asn_long2INTEGER(st, value)) ASN__DECODE_FAILED; ASN_DEBUG("Got value %ld + low %ld", value, ct->lower_bound); } return rval; } else { ASN__DECODE_FAILED; } } else { ASN_DEBUG("Decoding unconstrained integer %s", td->name); } /* X.691, #12.2.3, #12.2.4 */ do { ssize_t len; void *p; int ret; /* Get the PER length */ len = aper_get_length(pd, -1, -1, &repeat); if(len < 0) ASN__DECODE_STARVED; p = REALLOC(st->buf, st->size + len + 1); if(!p) ASN__DECODE_FAILED; st->buf = (uint8_t *)p; ret = per_get_many_bits(pd, &st->buf[st->size], 0, 8 * len); if(ret < 0) ASN__DECODE_STARVED; st->size += len; } while(repeat); st->buf[st->size] = 0; /* JIC */ /* #12.2.3 */ if(ct && ct->lower_bound) { /* * TODO: replace by in-place arithmetics. */ long value; if(asn_INTEGER2long(st, &value)) ASN__DECODE_FAILED; if(asn_long2INTEGER(st, value + ct->lower_bound)) ASN__DECODE_FAILED; } return rval; } asn_enc_rval_t INTEGER_encode_aper(const asn_TYPE_descriptor_t *td, const asn_per_constraints_t *constraints, const void *sptr, asn_per_outp_t *po) { const asn_INTEGER_specifics_t *specs = (const asn_INTEGER_specifics_t *)td->specifics; asn_enc_rval_t er = {0,0,0}; const INTEGER_t *st = (const INTEGER_t *)sptr; const uint8_t *buf; const uint8_t *end; const asn_per_constraint_t *ct; long value = 0; if(!st || st->size == 0) ASN__ENCODE_FAILED; if(!constraints) constraints = td->encoding_constraints.per_constraints; ct = constraints ? &constraints->value : 0; er.encoded = 0; if(ct) { int inext = 0; if(specs && specs->field_unsigned) { unsigned long uval; if(asn_INTEGER2ulong(st, &uval)) ASN__ENCODE_FAILED; /* Check proper range */ if(ct->flags & APC_SEMI_CONSTRAINED) { if(uval < (unsigned long)ct->lower_bound) inext = 1; } else if(ct->range_bits >= 0) { if(uval < (unsigned long)ct->lower_bound || uval > (unsigned long)ct->upper_bound) inext = 1; } ASN_DEBUG("Value %lu (%02x/%lu) lb %ld ub %ld %s", uval, st->buf[0], st->size, ct->lower_bound, ct->upper_bound, inext ? "ext" : "fix"); value = uval; } else { if(asn_INTEGER2long(st, &value)) ASN__ENCODE_FAILED; /* Check proper range */ if(ct->flags & APC_SEMI_CONSTRAINED) { if(value < ct->lower_bound) inext = 1; } else if(ct->range_bits >= 0) { if(value < ct->lower_bound || value > ct->upper_bound) inext = 1; } ASN_DEBUG("Value %lu (%02x/%lu) lb %ld ub %ld %s", value, st->buf[0], st->size, ct->lower_bound, ct->upper_bound, inext ? "ext" : "fix"); } if(ct->flags & APC_EXTENSIBLE) { if(per_put_few_bits(po, inext, 1)) ASN__ENCODE_FAILED; if(inext) ct = 0; } else if(inext) { ASN__ENCODE_FAILED; } } /* X.691, #12.2.2 */ if(ct && ct->range_bits >= 0) { unsigned long v; /* #10.5.6 */ ASN_DEBUG("Encoding integer %ld (%lu) with range %d bits", value, value - ct->lower_bound, ct->range_bits); v = value - ct->lower_bound; /* #12 <= 8 -> alignment ? */ if (ct->range_bits < 8) { if(per_put_few_bits(po, 0x00 | v, ct->range_bits)) ASN__ENCODE_FAILED; } else if (ct->range_bits == 8) { if(aper_put_align(po) < 0) ASN__ENCODE_FAILED; if(per_put_few_bits(po, 0x00 | v, ct->range_bits)) ASN__ENCODE_FAILED; } else if (ct->range_bits <= 16) { /* Consume the bytes to align on octet */ if(aper_put_align(po) < 0) ASN__ENCODE_FAILED; if(per_put_few_bits(po, 0x0000 | v, 16)) ASN__ENCODE_FAILED; } else { /* TODO: extend to >64 bits */ int64_t v64 = v; int i, j; int max_range_bytes = (ct->range_bits >> 3) + (((ct->range_bits % 8) > 0) ? 1 : 0); for (i = 1; ; i++) { int upper = 1 << i; if (upper >= max_range_bytes) break; } for (j = sizeof(int64_t) -1; j != 0; j--) { int64_t val; val = v64 >> (j * 8); if (val != 0) break; } /* Putting length in the minimum number of bits ex: 5 = 3bits */ if (per_put_few_bits(po, j, i)) ASN__ENCODE_FAILED; /* Consume the bits to align on octet */ if (aper_put_align(po) < 0) ASN__ENCODE_FAILED; /* Put the value */ for (i = 0; i <= j; i++) { if(per_put_few_bits(po, (v64 >> (8 * (j - i))) & 0xff, 8)) ASN__ENCODE_FAILED; } } ASN__ENCODED_OK(er); } if(ct && ct->lower_bound) { ASN_DEBUG("Adjust lower bound to %ld", ct->lower_bound); /* TODO: adjust lower bound */ ASN__ENCODE_FAILED; } for(buf = st->buf, end = st->buf + st->size; buf < end;) { ssize_t mayEncode = aper_put_length(po, -1, end - buf); if(mayEncode < 0) ASN__ENCODE_FAILED; if(per_put_many_bits(po, buf, 8 * mayEncode)) ASN__ENCODE_FAILED; buf += mayEncode; } ASN__ENCODED_OK(er); } #endif /* ASN_DISABLE_PER_SUPPORT */ static intmax_t asn__integer_convert(const uint8_t *b, const uint8_t *end) { uintmax_t value; /* Perform the sign initialization */ /* Actually value = -(*b >> 7); gains nothing, yet unreadable! */ if((*b >> 7)) { value = (uintmax_t)(-1); } else { value = 0; } /* Conversion engine */ for(; b < end; b++) { value = (value << 8) | *b; } return value; } int asn_INTEGER2imax(const INTEGER_t *iptr, intmax_t *lptr) { uint8_t *b, *end; size_t size; /* Sanity checking */ if(!iptr || !iptr->buf || !lptr) { errno = EINVAL; return -1; } /* Cache the begin/end of the buffer */ b = iptr->buf; /* Start of the INTEGER buffer */ size = iptr->size; end = b + size; /* Where to stop */ if(size > sizeof(intmax_t)) { uint8_t *end1 = end - 1; /* * Slightly more advanced processing, * able to process INTEGERs with >sizeof(intmax_t) bytes * when the actual value is small, e.g. for intmax_t == int32_t * (0x0000000000abcdef INTEGER would yield a fine 0x00abcdef int32_t) */ /* Skip out the insignificant leading bytes */ for(; b < end1; b++) { switch(*b) { case 0x00: if((b[1] & 0x80) == 0) continue; break; case 0xff: if((b[1] & 0x80) != 0) continue; break; } break; } size = end - b; if(size > sizeof(intmax_t)) { /* Still cannot fit the sizeof(intmax_t) */ errno = ERANGE; return -1; } } /* Shortcut processing of a corner case */ if(end == b) { *lptr = 0; return 0; } *lptr = asn__integer_convert(b, end); return 0; } /* FIXME: negative INTEGER values are silently interpreted as large unsigned ones. */ int asn_INTEGER2umax(const INTEGER_t *iptr, uintmax_t *lptr) { uint8_t *b, *end; uintmax_t value; size_t size; if(!iptr || !iptr->buf || !lptr) { errno = EINVAL; return -1; } b = iptr->buf; size = iptr->size; end = b + size; /* If all extra leading bytes are zeroes, ignore them */ for(; size > sizeof(value); b++, size--) { if(*b) { /* Value won't fit into uintmax_t */ errno = ERANGE; return -1; } } /* Conversion engine */ for(value = 0; b < end; b++) value = (value << 8) | *b; *lptr = value; return 0; } int asn_umax2INTEGER(INTEGER_t *st, uintmax_t value) { uint8_t *buf; uint8_t *end; uint8_t *b; int shr; if(value <= ((~(uintmax_t)0) >> 1)) { return asn_imax2INTEGER(st, value); } buf = (uint8_t *)MALLOC(1 + sizeof(value)); if(!buf) return -1; end = buf + (sizeof(value) + 1); buf[0] = 0; /* INTEGERs are signed. 0-byte indicates positive. */ for(b = buf + 1, shr = (sizeof(value) - 1) * 8; b < end; shr -= 8, b++) *b = (uint8_t)(value >> shr); if(st->buf) FREEMEM(st->buf); st->buf = buf; st->size = 1 + sizeof(value); return 0; } int asn_imax2INTEGER(INTEGER_t *st, intmax_t value) { uint8_t *buf, *bp; uint8_t *p; uint8_t *pstart; uint8_t *pend1; int littleEndian = 1; /* Run-time detection */ int add; if(!st) { errno = EINVAL; return -1; } buf = (uint8_t *)(long *)MALLOC(sizeof(value)); if(!buf) return -1; if(*(char *)&littleEndian) { pstart = (uint8_t *)&value + sizeof(value) - 1; pend1 = (uint8_t *)&value; add = -1; } else { pstart = (uint8_t *)&value; pend1 = pstart + sizeof(value) - 1; add = 1; } /* * If the contents octet consists of more than one octet, * then bits of the first octet and bit 8 of the second octet: * a) shall not all be ones; and * b) shall not all be zero. */ for(p = pstart; p != pend1; p += add) { switch(*p) { case 0x00: if((*(p+add) & 0x80) == 0) continue; break; case 0xff: if((*(p+add) & 0x80)) continue; break; } break; } /* Copy the integer body */ for(bp = buf, pend1 += add; p != pend1; p += add) *bp++ = *p; if(st->buf) FREEMEM(st->buf); st->buf = buf; st->size = bp - buf; return 0; } int asn_INTEGER2long(const INTEGER_t *iptr, long *l) { intmax_t v; if(asn_INTEGER2imax(iptr, &v) == 0) { if(v < LONG_MIN || v > LONG_MAX) { errno = ERANGE; return -1; } *l = v; return 0; } else { return -1; } } int asn_INTEGER2ulong(const INTEGER_t *iptr, unsigned long *l) { uintmax_t v; if(asn_INTEGER2umax(iptr, &v) == 0) { if(v > ULONG_MAX) { errno = ERANGE; return -1; } *l = v; return 0; } else { return -1; } } int asn_long2INTEGER(INTEGER_t *st, long value) { return asn_imax2INTEGER(st, value); } int asn_ulong2INTEGER(INTEGER_t *st, unsigned long value) { return asn_imax2INTEGER(st, value); } int asn_uint642INTEGER(INTEGER_t *st, uint64_t value) { uint8_t *buf; uint8_t *end; uint8_t *b; int shr; if(value <= INT64_MAX) return asn_int642INTEGER(st, value); buf = (uint8_t *)MALLOC(1 + sizeof(value)); if(!buf) return -1; end = buf + (sizeof(value) + 1); buf[0] = 0; for(b = buf + 1, shr = (sizeof(value)-1)*8; b < end; shr -= 8, b++) *b = (uint8_t)(value >> shr); if(st->buf) FREEMEM(st->buf); st->buf = buf; st->size = 1 + sizeof(value); return 0; } int asn_int642INTEGER(INTEGER_t *st, int64_t value) { uint8_t *buf, *bp; uint8_t *p; uint8_t *pstart; uint8_t *pend1; int littleEndian = 1; /* Run-time detection */ int add; if(!st) { errno = EINVAL; return -1; } buf = (uint8_t *)MALLOC(sizeof(value)); if(!buf) return -1; if(*(char *)&littleEndian) { pstart = (uint8_t *)&value + sizeof(value) - 1; pend1 = (uint8_t *)&value; add = -1; } else { pstart = (uint8_t *)&value; pend1 = pstart + sizeof(value) - 1; add = 1; } /* * If the contents octet consists of more than one octet, * then bits of the first octet and bit 8 of the second octet: * a) shall not all be ones; and * b) shall not all be zero. */ for(p = pstart; p != pend1; p += add) { switch(*p) { case 0x00: if((*(p+add) & 0x80) == 0) continue; break; case 0xff: if((*(p+add) & 0x80)) continue; break; } break; } /* Copy the integer body */ for(pstart = p, bp = buf, pend1 += add; p != pend1; p += add) *bp++ = *p; if(st->buf) FREEMEM(st->buf); st->buf = buf; st->size = bp - buf; return 0; } /* * Parse the number in the given string until the given *end position, * returning the position after the last parsed character back using the * same (*end) pointer. * WARNING: This behavior is different from the standard strtol/strtoimax(3). */ enum asn_strtox_result_e asn_strtoimax_lim(const char *str, const char **end, intmax_t *intp) { int sign = 1; intmax_t value; #define ASN1_INTMAX_MAX ((~(uintmax_t)0) >> 1) const intmax_t upper_boundary = ASN1_INTMAX_MAX / 10; intmax_t last_digit_max = ASN1_INTMAX_MAX % 10; #undef ASN1_INTMAX_MAX if(str >= *end) return ASN_STRTOX_ERROR_INVAL; switch(*str) { case '-': last_digit_max++; sign = -1; /* FALL THROUGH */ case '+': str++; if(str >= *end) { *end = str; return ASN_STRTOX_EXPECT_MORE; } } for(value = 0; str < (*end); str++) { switch(*str) { case 0x30: case 0x31: case 0x32: case 0x33: case 0x34: case 0x35: case 0x36: case 0x37: case 0x38: case 0x39: { int d = *str - '0'; if(value < upper_boundary) { value = value * 10 + d; } else if(value == upper_boundary) { if(d <= last_digit_max) { if(sign > 0) { value = value * 10 + d; } else { sign = 1; value = -value * 10 - d; } } else { *end = str; return ASN_STRTOX_ERROR_RANGE; } } else { *end = str; return ASN_STRTOX_ERROR_RANGE; } } continue; default: *end = str; *intp = sign * value; return ASN_STRTOX_EXTRA_DATA; } } *end = str; *intp = sign * value; return ASN_STRTOX_OK; } /* * Parse the number in the given string until the given *end position, * returning the position after the last parsed character back using the * same (*end) pointer. * WARNING: This behavior is different from the standard strtoul/strtoumax(3). */ enum asn_strtox_result_e asn_strtoumax_lim(const char *str, const char **end, uintmax_t *uintp) { uintmax_t value; #define ASN1_UINTMAX_MAX ((~(uintmax_t)0)) const uintmax_t upper_boundary = ASN1_UINTMAX_MAX / 10; uintmax_t last_digit_max = ASN1_UINTMAX_MAX % 10; #undef ASN1_UINTMAX_MAX if(str >= *end) return ASN_STRTOX_ERROR_INVAL; switch(*str) { case '-': return ASN_STRTOX_ERROR_INVAL; case '+': str++; if(str >= *end) { *end = str; return ASN_STRTOX_EXPECT_MORE; } } for(value = 0; str < (*end); str++) { switch(*str) { case 0x30: case 0x31: case 0x32: case 0x33: case 0x34: case 0x35: case 0x36: case 0x37: case 0x38: case 0x39: { unsigned int d = *str - '0'; if(value < upper_boundary) { value = value * 10 + d; } else if(value == upper_boundary) { if(d <= last_digit_max) { value = value * 10 + d; } else { *end = str; return ASN_STRTOX_ERROR_RANGE; } } else { *end = str; return ASN_STRTOX_ERROR_RANGE; } } continue; default: *end = str; *uintp = value; return ASN_STRTOX_EXTRA_DATA; } } *end = str; *uintp = value; return ASN_STRTOX_OK; } enum asn_strtox_result_e asn_strtol_lim(const char *str, const char **end, long *lp) { intmax_t value; switch(asn_strtoimax_lim(str, end, &value)) { case ASN_STRTOX_ERROR_RANGE: return ASN_STRTOX_ERROR_RANGE; case ASN_STRTOX_ERROR_INVAL: return ASN_STRTOX_ERROR_INVAL; case ASN_STRTOX_EXPECT_MORE: return ASN_STRTOX_EXPECT_MORE; case ASN_STRTOX_OK: if(value >= LONG_MIN && value <= LONG_MAX) { *lp = value; return ASN_STRTOX_OK; } else { return ASN_STRTOX_ERROR_RANGE; } case ASN_STRTOX_EXTRA_DATA: if(value >= LONG_MIN && value <= LONG_MAX) { *lp = value; return ASN_STRTOX_EXTRA_DATA; } else { return ASN_STRTOX_ERROR_RANGE; } } assert(!"Unreachable"); return ASN_STRTOX_ERROR_INVAL; } enum asn_strtox_result_e asn_strtoul_lim(const char *str, const char **end, unsigned long *ulp) { uintmax_t value; switch(asn_strtoumax_lim(str, end, &value)) { case ASN_STRTOX_ERROR_RANGE: return ASN_STRTOX_ERROR_RANGE; case ASN_STRTOX_ERROR_INVAL: return ASN_STRTOX_ERROR_INVAL; case ASN_STRTOX_EXPECT_MORE: return ASN_STRTOX_EXPECT_MORE; case ASN_STRTOX_OK: if(value <= ULONG_MAX) { *ulp = value; return ASN_STRTOX_OK; } else { return ASN_STRTOX_ERROR_RANGE; } case ASN_STRTOX_EXTRA_DATA: if(value <= ULONG_MAX) { *ulp = value; return ASN_STRTOX_EXTRA_DATA; } else { return ASN_STRTOX_ERROR_RANGE; } } assert(!"Unreachable"); return ASN_STRTOX_ERROR_INVAL; } int INTEGER_compare(const asn_TYPE_descriptor_t *td, const void *aptr, const void *bptr) { const INTEGER_t *a = aptr; const INTEGER_t *b = bptr; (void)td; if(a && b) { if(a->size && b->size) { int sign_a = (a->buf[0] & 0x80) ? -1 : 1; int sign_b = (b->buf[0] & 0x80) ? -1 : 1; if(sign_a < sign_b) return -1; if(sign_a > sign_b) return 1; /* The shortest integer wins, unless comparing negatives */ if(a->size < b->size) { return -1 * sign_a; } else if(a->size > b->size) { return 1 * sign_b; } return sign_a * memcmp(a->buf, b->buf, a->size); } else if(a->size) { int sign = (a->buf[0] & 0x80) ? -1 : 1; return (1) * sign; } else if(b->size) { int sign = (a->buf[0] & 0x80) ? -1 : 1; return (-1) * sign; } else { return 0; } } else if(!a && !b) { return 0; } else if(!a) { return -1; } else { return 1; } } asn_random_fill_result_t INTEGER_random_fill(const asn_TYPE_descriptor_t *td, void **sptr, const asn_encoding_constraints_t *constraints, size_t max_length) { const asn_INTEGER_specifics_t *specs = (const asn_INTEGER_specifics_t *)td->specifics; 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}; INTEGER_t *st = *sptr; const asn_INTEGER_enum_map_t *emap; size_t emap_len; intmax_t value; int find_inside_map; if(max_length == 0) return result_skipped; if(st == NULL) { st = (INTEGER_t *)CALLOC(1, sizeof(*st)); if(st == NULL) { return result_failed; } } if(specs) { emap = specs->value2enum; emap_len = specs->map_count; if(specs->strict_enumeration) { find_inside_map = emap_len > 0; } else { find_inside_map = emap_len ? asn_random_between(0, 1) : 0; } } else { emap = 0; emap_len = 0; find_inside_map = 0; } if(find_inside_map) { assert(emap_len > 0); value = emap[asn_random_between(0, emap_len - 1)].nat_value; } else { const asn_per_constraints_t *ct; static const long variants[] = { -65536, -65535, -65534, -32769, -32768, -32767, -16385, -16384, -16383, -257, -256, -255, -254, -129, -128, -127, -126, -1, 0, 1, 126, 127, 128, 129, 254, 255, 256, 257, 16383, 16384, 16385, 32767, 32768, 32769, 65534, 65535, 65536, 65537}; if(specs && specs->field_unsigned) { assert(variants[18] == 0); value = variants[asn_random_between( 18, sizeof(variants) / sizeof(variants[0]) - 1)]; } else { value = variants[asn_random_between( 0, sizeof(variants) / sizeof(variants[0]) - 1)]; } if(!constraints) constraints = &td->encoding_constraints; ct = constraints ? constraints->per_constraints : 0; if(ct && (ct->value.flags & APC_CONSTRAINED)) { if(value < ct->value.lower_bound || value > ct->value.upper_bound) { value = asn_random_between(ct->value.lower_bound, ct->value.upper_bound); } } } if(asn_imax2INTEGER(st, value)) { if(st == *sptr) { ASN_STRUCT_RESET(*td, st); } else { ASN_STRUCT_FREE(*td, st); } return result_failed; } else { *sptr = st; result_ok.length = st->size; return result_ok; } }