2 * Copyright (c) 2003-2014 Lev Walkin <vlm@lionet.info>.
\r
3 * All rights reserved.
\r
4 * Redistribution and modifications are permitted subject to BSD license.
\r
6 #include <asn_internal.h>
\r
8 #include <asn_codecs_prim.h> /* Encoder and decoder of a primitive type */
\r
12 * INTEGER basic type description.
\r
14 static const ber_tlv_tag_t asn_DEF_INTEGER_tags[] = {
\r
15 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
\r
17 asn_TYPE_operation_t asn_OP_INTEGER = {
\r
21 ber_decode_primitive,
\r
25 #ifdef ASN_DISABLE_OER_SUPPORT
\r
29 INTEGER_decode_oer, /* OER decoder */
\r
30 INTEGER_encode_oer, /* Canonical OER encoder */
\r
31 #endif /* ASN_DISABLE_OER_SUPPORT */
\r
32 #ifdef ASN_DISABLE_PER_SUPPORT
\r
38 INTEGER_decode_uper, /* Unaligned PER decoder */
\r
39 INTEGER_encode_uper, /* Unaligned PER encoder */
\r
40 INTEGER_decode_aper, /* Aligned PER decoder */
\r
41 INTEGER_encode_aper, /* Aligned PER encoder */
\r
42 #endif /* ASN_DISABLE_PER_SUPPORT */
\r
43 INTEGER_random_fill,
\r
44 0 /* Use generic outmost tag fetcher */
\r
46 asn_TYPE_descriptor_t asn_DEF_INTEGER = {
\r
50 asn_DEF_INTEGER_tags,
\r
51 sizeof(asn_DEF_INTEGER_tags) / sizeof(asn_DEF_INTEGER_tags[0]),
\r
52 asn_DEF_INTEGER_tags, /* Same as above */
\r
53 sizeof(asn_DEF_INTEGER_tags) / sizeof(asn_DEF_INTEGER_tags[0]),
\r
54 { 0, 0, asn_generic_no_constraint },
\r
55 0, 0, /* No members */
\r
56 0 /* No specifics */
\r
60 * Encode INTEGER type using DER.
\r
63 INTEGER_encode_der(const asn_TYPE_descriptor_t *td, const void *sptr,
\r
64 int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb,
\r
66 const INTEGER_t *st = (const INTEGER_t *)sptr;
\r
67 asn_enc_rval_t rval;
\r
68 INTEGER_t effective_integer;
\r
70 ASN_DEBUG("%s %s as INTEGER (tm=%d)",
\r
71 cb?"Encoding":"Estimating", td->name, tag_mode);
\r
74 * Canonicalize integer in the buffer.
\r
75 * (Remove too long sign extension, remove some first 0x00 bytes)
\r
78 uint8_t *buf = st->buf;
\r
79 uint8_t *end1 = buf + st->size - 1;
\r
82 /* Compute the number of superfluous leading bytes */
\r
83 for(; buf < end1; buf++) {
\r
85 * If the contents octets of an integer value encoding
\r
86 * consist of more than one octet, then the bits of the
\r
87 * first octet and bit 8 of the second octet:
\r
88 * a) shall not all be ones; and
\r
89 * b) shall not all be zero.
\r
92 case 0x00: if((buf[1] & 0x80) == 0)
\r
95 case 0xff: if((buf[1] & 0x80))
\r
102 /* Remove leading superfluous bytes from the integer */
\r
103 shift = buf - st->buf;
\r
106 const uint8_t *c_buf;
\r
109 unconst.c_buf = st->buf;
\r
110 effective_integer.buf = unconst.nc_buf + shift;
\r
111 effective_integer.size = st->size - shift;
\r
113 st = &effective_integer;
\r
117 rval = der_encode_primitive(td, st, tag_mode, tag, cb, app_key);
\r
118 if(rval.structure_ptr == &effective_integer) {
\r
119 rval.structure_ptr = sptr;
\r
124 static const asn_INTEGER_enum_map_t *INTEGER_map_enum2value(
\r
125 const asn_INTEGER_specifics_t *specs, const char *lstart,
\r
126 const char *lstop);
\r
129 * INTEGER specific human-readable output.
\r
132 INTEGER__dump(const asn_TYPE_descriptor_t *td, const INTEGER_t *st, asn_app_consume_bytes_f *cb, void *app_key, int plainOrXER) {
\r
133 const asn_INTEGER_specifics_t *specs =
\r
134 (const asn_INTEGER_specifics_t *)td->specifics;
\r
136 uint8_t *buf = st->buf;
\r
137 uint8_t *buf_end = st->buf + st->size;
\r
143 if(specs && specs->field_unsigned)
\r
144 ret = asn_INTEGER2umax(st, (uintmax_t *)&value);
\r
146 ret = asn_INTEGER2imax(st, &value);
\r
148 /* Simple case: the integer size is small */
\r
150 const asn_INTEGER_enum_map_t *el;
\r
151 el = (value >= 0 || !specs || !specs->field_unsigned)
\r
152 ? INTEGER_map_value2enum(specs, value) : 0;
\r
154 if(plainOrXER == 0)
\r
155 return asn__format_to_callback(cb, app_key,
\r
156 "%" ASN_PRIdMAX " (%s)", value, el->enum_name);
\r
158 return asn__format_to_callback(cb, app_key,
\r
159 "<%s/>", el->enum_name);
\r
160 } else if(plainOrXER && specs && specs->strict_enumeration) {
\r
161 ASN_DEBUG("ASN.1 forbids dealing with "
\r
162 "unknown value of ENUMERATED type");
\r
166 return asn__format_to_callback(cb, app_key,
\r
167 (specs && specs->field_unsigned)
\r
172 } else if(plainOrXER && specs && specs->strict_enumeration) {
\r
174 * Here and earlier, we cannot encode the ENUMERATED values
\r
175 * if there is no corresponding identifier.
\r
177 ASN_DEBUG("ASN.1 forbids dealing with "
\r
178 "unknown value of ENUMERATED type");
\r
183 /* Output in the long xx:yy:zz... format */
\r
184 /* TODO: replace with generic algorithm (Knuth TAOCP Vol 2, 4.3.1) */
\r
185 for(p = scratch; buf < buf_end; buf++) {
\r
186 const char * const h2c = "0123456789ABCDEF";
\r
187 if((p - scratch) >= (ssize_t)(sizeof(scratch) - 4)) {
\r
189 if(cb(scratch, p - scratch, app_key) < 0)
\r
191 wrote += p - scratch;
\r
194 *p++ = h2c[*buf >> 4];
\r
195 *p++ = h2c[*buf & 0x0F];
\r
196 *p++ = 0x3a; /* ":" */
\r
199 p--; /* Remove the last ":" */
\r
201 wrote += p - scratch;
\r
202 return (cb(scratch, p - scratch, app_key) < 0) ? -1 : wrote;
\r
206 * INTEGER specific human-readable output.
\r
209 INTEGER_print(const asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
\r
210 asn_app_consume_bytes_f *cb, void *app_key) {
\r
211 const INTEGER_t *st = (const INTEGER_t *)sptr;
\r
216 if(!st || !st->buf)
\r
217 ret = cb("<absent>", 8, app_key);
\r
219 ret = INTEGER__dump(td, st, cb, app_key, 0);
\r
221 return (ret < 0) ? -1 : 0;
\r
227 const asn_INTEGER_enum_map_t *vemap;
\r
228 const unsigned int *evmap;
\r
231 INTEGER__compar_enum2value(const void *kp, const void *am) {
\r
232 const struct e2v_key *key = (const struct e2v_key *)kp;
\r
233 const asn_INTEGER_enum_map_t *el = (const asn_INTEGER_enum_map_t *)am;
\r
234 const char *ptr, *end, *name;
\r
236 /* Remap the element (sort by different criterion) */
\r
237 el = key->vemap + key->evmap[el - key->vemap];
\r
239 /* Compare strings */
\r
240 for(ptr = key->start, end = key->stop, name = el->enum_name;
\r
241 ptr < end; ptr++, name++) {
\r
242 if(*ptr != *name || !*name)
\r
243 return *(const unsigned char *)ptr
\r
244 - *(const unsigned char *)name;
\r
246 return name[0] ? -1 : 0;
\r
249 static const asn_INTEGER_enum_map_t *
\r
250 INTEGER_map_enum2value(const asn_INTEGER_specifics_t *specs, const char *lstart,
\r
251 const char *lstop) {
\r
252 const asn_INTEGER_enum_map_t *el_found;
\r
253 int count = specs ? specs->map_count : 0;
\r
254 struct e2v_key key;
\r
257 if(!count) return NULL;
\r
259 /* Guaranteed: assert(lstart < lstop); */
\r
260 /* Figure out the tag name */
\r
261 for(lstart++, lp = lstart; lp < lstop; lp++) {
\r
263 case 9: case 10: case 11: case 12: case 13: case 32: /* WSP */
\r
264 case 0x2f: /* '/' */ case 0x3e: /* '>' */
\r
271 if(lp == lstop) return NULL; /* No tag found */
\r
274 key.start = lstart;
\r
276 key.vemap = specs->value2enum;
\r
277 key.evmap = specs->enum2value;
\r
278 el_found = (asn_INTEGER_enum_map_t *)bsearch(&key,
\r
279 specs->value2enum, count, sizeof(specs->value2enum[0]),
\r
280 INTEGER__compar_enum2value);
\r
282 /* Remap enum2value into value2enum */
\r
283 el_found = key.vemap + key.evmap[el_found - key.vemap];
\r
289 INTEGER__compar_value2enum(const void *kp, const void *am) {
\r
290 long a = *(const long *)kp;
\r
291 const asn_INTEGER_enum_map_t *el = (const asn_INTEGER_enum_map_t *)am;
\r
292 long b = el->nat_value;
\r
293 if(a < b) return -1;
\r
294 else if(a == b) return 0;
\r
298 const asn_INTEGER_enum_map_t *
\r
299 INTEGER_map_value2enum(const asn_INTEGER_specifics_t *specs, long value) {
\r
300 int count = specs ? specs->map_count : 0;
\r
301 if(!count) return 0;
\r
302 return (asn_INTEGER_enum_map_t *)bsearch(&value, specs->value2enum,
\r
303 count, sizeof(specs->value2enum[0]),
\r
304 INTEGER__compar_value2enum);
\r
308 INTEGER_st_prealloc(INTEGER_t *st, int min_size) {
\r
309 void *p = MALLOC(min_size + 1);
\r
322 * Decode the chunk of XML text encoding INTEGER.
\r
324 static enum xer_pbd_rval
\r
325 INTEGER__xer_body_decode(const asn_TYPE_descriptor_t *td, void *sptr,
\r
326 const void *chunk_buf, size_t chunk_size) {
\r
327 const asn_INTEGER_specifics_t *specs =
\r
328 (const asn_INTEGER_specifics_t *)td->specifics;
\r
329 INTEGER_t *st = (INTEGER_t *)sptr;
\r
330 intmax_t dec_value;
\r
331 intmax_t hex_value = 0;
\r
333 const char *lstart = (const char *)chunk_buf;
\r
334 const char *lstop = lstart + chunk_size;
\r
340 ST_DIGITS_TRAILSPACE,
\r
343 ST_HEXDIGITS_TRAILSPACE,
\r
347 } state = ST_LEADSPACE;
\r
348 const char *dec_value_start = 0; /* INVARIANT: always !0 in ST_DIGITS */
\r
349 const char *dec_value_end = 0;
\r
352 ASN_DEBUG("INTEGER body %ld 0x%2x..0x%2x",
\r
353 (long)chunk_size, *lstart, lstop[-1]);
\r
355 if(INTEGER_st_prealloc(st, (chunk_size/3) + 1))
\r
356 return XPBD_SYSTEM_FAILURE;
\r
359 * We may have received a tag here. It will be processed inline.
\r
360 * Use strtoul()-like code and serialize the result.
\r
362 for(lp = lstart; lp < lstop; lp++) {
\r
365 case 0x09: case 0x0a: case 0x0d: case 0x20:
\r
368 case ST_DIGITS_TRAILSPACE:
\r
369 case ST_HEXDIGITS_TRAILSPACE:
\r
373 dec_value_end = lp;
\r
374 state = ST_DIGITS_TRAILSPACE;
\r
377 state = ST_HEXDIGITS_TRAILSPACE;
\r
383 case 0x2d: /* '-' */
\r
384 if(state == ST_LEADSPACE) {
\r
386 dec_value_start = lp;
\r
387 state = ST_WAITDIGITS;
\r
391 case 0x2b: /* '+' */
\r
392 if(state == ST_LEADSPACE) {
\r
394 dec_value_start = lp;
\r
395 state = ST_WAITDIGITS;
\r
399 case 0x30: case 0x31: case 0x32: case 0x33: case 0x34:
\r
400 case 0x35: case 0x36: case 0x37: case 0x38: case 0x39:
\r
402 case ST_DIGITS: continue;
\r
403 case ST_SKIPSPHEX: /* Fall through */
\r
405 hex_value = (lv - 0x30) << 4;
\r
406 state = ST_HEXDIGIT2;
\r
409 hex_value += (lv - 0x30);
\r
410 state = ST_HEXCOLON;
\r
411 st->buf[st->size++] = (uint8_t)hex_value;
\r
414 return XPBD_BROKEN_ENCODING;
\r
417 dec_value_start = lp;
\r
419 case ST_WAITDIGITS:
\r
426 case 0x3c: /* '<', start of XML encoded enumeration */
\r
427 if(state == ST_LEADSPACE) {
\r
428 const asn_INTEGER_enum_map_t *el;
\r
429 el = INTEGER_map_enum2value(
\r
430 (const asn_INTEGER_specifics_t *)
\r
431 td->specifics, lstart, lstop);
\r
433 ASN_DEBUG("Found \"%s\" => %ld",
\r
434 el->enum_name, el->nat_value);
\r
435 dec_value = el->nat_value;
\r
436 state = ST_END_ENUM;
\r
440 ASN_DEBUG("Unknown identifier for INTEGER");
\r
442 return XPBD_BROKEN_ENCODING;
\r
443 case 0x3a: /* ':' */
\r
444 if(state == ST_HEXCOLON) {
\r
445 /* This colon is expected */
\r
446 state = ST_HEXDIGIT1;
\r
448 } else if(state == ST_DIGITS) {
\r
449 /* The colon here means that we have
\r
450 * decoded the first two hexadecimal
\r
451 * places as a decimal value.
\r
452 * Switch decoding mode. */
\r
453 ASN_DEBUG("INTEGER re-evaluate as hex form");
\r
454 state = ST_SKIPSPHEX;
\r
455 dec_value_start = 0;
\r
459 ASN_DEBUG("state %d at %ld", state, (long)(lp - lstart));
\r
463 case 0x41:case 0x42:case 0x43:case 0x44:case 0x45:case 0x46:
\r
464 case 0x61:case 0x62:case 0x63:case 0x64:case 0x65:case 0x66:
\r
467 case ST_LEADSPACE: /* Fall through */
\r
469 hex_value = lv - ((lv < 0x61) ? 0x41 : 0x61);
\r
472 state = ST_HEXDIGIT2;
\r
475 hex_value += lv - ((lv < 0x61) ? 0x41 : 0x61);
\r
477 st->buf[st->size++] = (uint8_t)hex_value;
\r
478 state = ST_HEXCOLON;
\r
481 ASN_DEBUG("INTEGER re-evaluate as hex form");
\r
482 state = ST_SKIPSPHEX;
\r
483 dec_value_start = 0;
\r
492 /* Found extra non-numeric stuff */
\r
493 ASN_DEBUG("INTEGER :: Found non-numeric 0x%2x at %ld",
\r
494 lv, (long)(lp - lstart));
\r
495 state = ST_UNEXPECTED;
\r
501 /* Got a complete and valid enumeration encoded as a tag. */
\r
504 dec_value_end = lstop;
\r
506 case ST_DIGITS_TRAILSPACE:
\r
507 /* The last symbol encountered was a digit. */
\r
508 switch(asn_strtoimax_lim(dec_value_start, &dec_value_end, &dec_value)) {
\r
509 case ASN_STRTOX_OK:
\r
510 if(specs && specs->field_unsigned && (uintmax_t) dec_value <= ULONG_MAX) {
\r
512 } else if(dec_value >= LONG_MIN && dec_value <= LONG_MAX) {
\r
516 * We model INTEGER on long for XER,
\r
517 * to avoid rewriting all the tests at once.
\r
519 ASN_DEBUG("INTEGER exceeds long range");
\r
522 case ASN_STRTOX_ERROR_RANGE:
\r
523 ASN_DEBUG("INTEGER decode %s hit range limit", td->name);
\r
524 return XPBD_DECODER_LIMIT;
\r
525 case ASN_STRTOX_ERROR_INVAL:
\r
526 case ASN_STRTOX_EXPECT_MORE:
\r
527 case ASN_STRTOX_EXTRA_DATA:
\r
528 return XPBD_BROKEN_ENCODING;
\r
532 case ST_HEXDIGITS_TRAILSPACE:
\r
533 st->buf[st->size] = 0; /* Just in case termination */
\r
534 return XPBD_BODY_CONSUMED;
\r
538 return XPBD_BROKEN_ENCODING;
\r
540 /* Content not found */
\r
541 return XPBD_NOT_BODY_IGNORE;
\r
542 case ST_WAITDIGITS:
\r
543 case ST_UNEXPECTED:
\r
544 ASN_DEBUG("INTEGER: No useful digits (state %d)", state);
\r
545 return XPBD_BROKEN_ENCODING; /* No digits */
\r
549 * Convert the result of parsing of enumeration or a straight
\r
550 * decimal value into a BER representation.
\r
552 if(asn_imax2INTEGER(st, dec_value)) {
\r
553 ASN_DEBUG("INTEGER decode %s conversion failed", td->name);
\r
554 return XPBD_SYSTEM_FAILURE;
\r
557 return XPBD_BODY_CONSUMED;
\r
561 INTEGER_decode_xer(const asn_codec_ctx_t *opt_codec_ctx,
\r
562 const asn_TYPE_descriptor_t *td, void **sptr,
\r
563 const char *opt_mname, const void *buf_ptr, size_t size) {
\r
564 return xer_decode_primitive(opt_codec_ctx, td,
\r
565 sptr, sizeof(INTEGER_t), opt_mname,
\r
566 buf_ptr, size, INTEGER__xer_body_decode);
\r
570 INTEGER_encode_xer(const asn_TYPE_descriptor_t *td, const void *sptr,
\r
571 int ilevel, enum xer_encoder_flags_e flags,
\r
572 asn_app_consume_bytes_f *cb, void *app_key) {
\r
573 const INTEGER_t *st = (const INTEGER_t *)sptr;
\r
574 asn_enc_rval_t er = {0,0,0};
\r
579 if(!st || !st->buf)
\r
580 ASN__ENCODE_FAILED;
\r
582 er.encoded = INTEGER__dump(td, st, cb, app_key, 1);
\r
583 if(er.encoded < 0) ASN__ENCODE_FAILED;
\r
585 ASN__ENCODED_OK(er);
\r
588 #ifndef ASN_DISABLE_PER_SUPPORT
\r
591 INTEGER_decode_uper(const asn_codec_ctx_t *opt_codec_ctx,
\r
592 const asn_TYPE_descriptor_t *td,
\r
593 const asn_per_constraints_t *constraints, void **sptr,
\r
594 asn_per_data_t *pd) {
\r
595 const asn_INTEGER_specifics_t *specs =
\r
596 (const asn_INTEGER_specifics_t *)td->specifics;
\r
597 asn_dec_rval_t rval = { RC_OK, 0 };
\r
598 INTEGER_t *st = (INTEGER_t *)*sptr;
\r
599 const asn_per_constraint_t *ct;
\r
602 (void)opt_codec_ctx;
\r
605 st = (INTEGER_t *)(*sptr = CALLOC(1, sizeof(*st)));
\r
606 if(!st) ASN__DECODE_FAILED;
\r
609 if(!constraints) constraints = td->encoding_constraints.per_constraints;
\r
610 ct = constraints ? &constraints->value : 0;
\r
612 if(ct && ct->flags & APC_EXTENSIBLE) {
\r
613 int inext = per_get_few_bits(pd, 1);
\r
614 if(inext < 0) ASN__DECODE_STARVED;
\r
622 if(ct->flags & APC_SEMI_CONSTRAINED) {
\r
623 st->buf = (uint8_t *)CALLOC(1, 2);
\r
624 if(!st->buf) ASN__DECODE_FAILED;
\r
626 } else if(ct->flags & APC_CONSTRAINED && ct->range_bits >= 0) {
\r
627 size_t size = (ct->range_bits + 7) >> 3;
\r
628 st->buf = (uint8_t *)MALLOC(1 + size + 1);
\r
629 if(!st->buf) ASN__DECODE_FAILED;
\r
634 /* X.691-2008/11, #13.2.2, constrained whole number */
\r
635 if(ct && ct->flags != APC_UNCONSTRAINED) {
\r
637 ASN_DEBUG("Integer with range %d bits", ct->range_bits);
\r
638 if(ct->range_bits >= 0) {
\r
639 if((size_t)ct->range_bits > 8 * sizeof(unsigned long))
\r
640 ASN__DECODE_FAILED;
\r
642 if(specs && specs->field_unsigned) {
\r
643 unsigned long uvalue = 0;
\r
644 if(uper_get_constrained_whole_number(pd,
\r
645 &uvalue, ct->range_bits))
\r
646 ASN__DECODE_STARVED;
\r
647 ASN_DEBUG("Got value %lu + low %ld",
\r
648 uvalue, ct->lower_bound);
\r
649 uvalue += ct->lower_bound;
\r
650 if(asn_ulong2INTEGER(st, uvalue))
\r
651 ASN__DECODE_FAILED;
\r
653 unsigned long uvalue = 0;
\r
655 if(uper_get_constrained_whole_number(pd,
\r
656 &uvalue, ct->range_bits))
\r
657 ASN__DECODE_STARVED;
\r
658 ASN_DEBUG("Got value %lu + low %ld",
\r
659 uvalue, ct->lower_bound);
\r
660 if(per_long_range_unrebase(uvalue, ct->lower_bound,
\r
661 ct->upper_bound, &svalue)
\r
662 || asn_long2INTEGER(st, svalue)) {
\r
663 ASN__DECODE_FAILED;
\r
669 ASN_DEBUG("Decoding unconstrained integer %s", td->name);
\r
672 /* X.691, #12.2.3, #12.2.4 */
\r
678 /* Get the PER length */
\r
679 len = uper_get_length(pd, -1, 0, &repeat);
\r
680 if(len < 0) ASN__DECODE_STARVED;
\r
682 p = REALLOC(st->buf, st->size + len + 1);
\r
683 if(!p) ASN__DECODE_FAILED;
\r
684 st->buf = (uint8_t *)p;
\r
686 ret = per_get_many_bits(pd, &st->buf[st->size], 0, 8 * len);
\r
687 if(ret < 0) ASN__DECODE_STARVED;
\r
690 st->buf[st->size] = 0; /* JIC */
\r
693 if(ct && ct->lower_bound) {
\r
695 * TODO: replace by in-place arithmetics.
\r
698 if(asn_INTEGER2long(st, &value))
\r
699 ASN__DECODE_FAILED;
\r
700 if(asn_imax2INTEGER(st, value + ct->lower_bound))
\r
701 ASN__DECODE_FAILED;
\r
708 INTEGER_encode_uper(const asn_TYPE_descriptor_t *td,
\r
709 const asn_per_constraints_t *constraints, const void *sptr,
\r
710 asn_per_outp_t *po) {
\r
711 const asn_INTEGER_specifics_t *specs =
\r
712 (const asn_INTEGER_specifics_t *)td->specifics;
\r
713 asn_enc_rval_t er = {0,0,0};
\r
714 const INTEGER_t *st = (const INTEGER_t *)sptr;
\r
715 const uint8_t *buf;
\r
716 const uint8_t *end;
\r
717 const asn_per_constraint_t *ct;
\r
720 if(!st || st->size == 0) ASN__ENCODE_FAILED;
\r
722 if(!constraints) constraints = td->encoding_constraints.per_constraints;
\r
723 ct = constraints ? &constraints->value : 0;
\r
729 if(specs && specs->field_unsigned) {
\r
730 unsigned long uval;
\r
731 if(asn_INTEGER2ulong(st, &uval))
\r
732 ASN__ENCODE_FAILED;
\r
733 /* Check proper range */
\r
734 if(ct->flags & APC_SEMI_CONSTRAINED) {
\r
735 if(uval < (unsigned long)ct->lower_bound)
\r
737 } else if(ct->range_bits >= 0) {
\r
738 if(uval < (unsigned long)ct->lower_bound
\r
739 || uval > (unsigned long)ct->upper_bound)
\r
742 ASN_DEBUG("Value %lu (%02x/%" ASN_PRI_SIZE ") lb %lu ub %lu %s",
\r
743 uval, st->buf[0], st->size,
\r
744 ct->lower_bound, ct->upper_bound,
\r
745 inext ? "ext" : "fix");
\r
748 if(asn_INTEGER2long(st, &value))
\r
749 ASN__ENCODE_FAILED;
\r
750 /* Check proper range */
\r
751 if(ct->flags & APC_SEMI_CONSTRAINED) {
\r
752 if(value < ct->lower_bound)
\r
754 } else if(ct->range_bits >= 0) {
\r
755 if(value < ct->lower_bound
\r
756 || value > ct->upper_bound)
\r
759 ASN_DEBUG("Value %ld (%02x/%" ASN_PRI_SIZE ") lb %ld ub %ld %s",
\r
760 value, st->buf[0], st->size,
\r
761 ct->lower_bound, ct->upper_bound,
\r
762 inext ? "ext" : "fix");
\r
764 if(ct->flags & APC_EXTENSIBLE) {
\r
765 if(per_put_few_bits(po, inext, 1))
\r
766 ASN__ENCODE_FAILED;
\r
769 ASN__ENCODE_FAILED;
\r
774 /* X.691-11/2008, #13.2.2, test if constrained whole number */
\r
775 if(ct && ct->range_bits >= 0) {
\r
777 /* #11.5.6 -> #11.3 */
\r
778 ASN_DEBUG("Encoding integer %ld (%lu) with range %d bits",
\r
779 value, value - ct->lower_bound, ct->range_bits);
\r
780 if(specs && specs->field_unsigned) {
\r
781 if ( ((unsigned long)ct->lower_bound > (unsigned long)(ct->upper_bound)
\r
782 || ((unsigned long)value < (unsigned long)ct->lower_bound))
\r
783 || ((unsigned long)value > (unsigned long)ct->upper_bound)
\r
785 ASN_DEBUG("Value %lu to-be-encoded is outside the bounds [%lu, %lu]!",
\r
786 value, ct->lower_bound, ct->upper_bound);
\r
787 ASN__ENCODE_FAILED;
\r
789 v = (unsigned long)value - (unsigned long)ct->lower_bound;
\r
791 if(per_long_range_rebase(value, ct->lower_bound, ct->upper_bound, &v)) {
\r
792 ASN__ENCODE_FAILED;
\r
795 if(uper_put_constrained_whole_number_u(po, v, ct->range_bits))
\r
796 ASN__ENCODE_FAILED;
\r
797 ASN__ENCODED_OK(er);
\r
800 if(ct && ct->lower_bound) {
\r
801 ASN_DEBUG("Adjust lower bound to %ld", ct->lower_bound);
\r
802 /* TODO: adjust lower bound */
\r
803 ASN__ENCODE_FAILED;
\r
806 for(buf = st->buf, end = st->buf + st->size; buf < end;) {
\r
808 ssize_t mayEncode = uper_put_length(po, end - buf, &need_eom);
\r
810 ASN__ENCODE_FAILED;
\r
811 if(per_put_many_bits(po, buf, 8 * mayEncode))
\r
812 ASN__ENCODE_FAILED;
\r
814 if(need_eom && uper_put_length(po, 0, 0)) ASN__ENCODE_FAILED;
\r
817 ASN__ENCODED_OK(er);
\r
821 INTEGER_decode_aper(const asn_codec_ctx_t *opt_codec_ctx,
\r
822 const asn_TYPE_descriptor_t *td,
\r
823 const asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) {
\r
824 const asn_INTEGER_specifics_t *specs = (const asn_INTEGER_specifics_t *)td->specifics;
\r
825 asn_dec_rval_t rval = { RC_OK, 0 };
\r
826 INTEGER_t *st = (INTEGER_t *)*sptr;
\r
827 const asn_per_constraint_t *ct;
\r
830 (void)opt_codec_ctx;
\r
833 st = (INTEGER_t *)(*sptr = CALLOC(1, sizeof(*st)));
\r
834 if(!st) ASN__DECODE_FAILED;
\r
837 if(!constraints) constraints = td->encoding_constraints.per_constraints;
\r
838 ct = constraints ? &constraints->value : 0;
\r
840 if(ct && ct->flags & APC_EXTENSIBLE) {
\r
841 int inext = per_get_few_bits(pd, 1);
\r
842 if(inext < 0) ASN__DECODE_STARVED;
\r
850 if(ct->flags & APC_SEMI_CONSTRAINED) {
\r
851 st->buf = (uint8_t *)CALLOC(1, 2);
\r
852 if(!st->buf) ASN__DECODE_FAILED;
\r
854 } else if(ct->flags & APC_CONSTRAINED && ct->range_bits >= 0) {
\r
855 size_t size = (ct->range_bits + 7) >> 3;
\r
856 st->buf = (uint8_t *)MALLOC(1 + size + 1);
\r
857 if(!st->buf) ASN__DECODE_FAILED;
\r
862 /* X.691, #12.2.2 */
\r
863 if(ct && ct->flags != APC_UNCONSTRAINED) {
\r
865 ASN_DEBUG("Integer with range %d bits", ct->range_bits);
\r
866 if(ct->range_bits >= 0) {
\r
867 if (ct->range_bits > 16) {
\r
868 int max_range_bytes = (ct->range_bits >> 3) +
\r
869 (((ct->range_bits % 8) > 0) ? 1 : 0);
\r
873 for (i = 1; ; i++) {
\r
874 int upper = 1 << i;
\r
875 if (upper >= max_range_bytes)
\r
878 ASN_DEBUG("Can encode %d (%d bytes) in %d bits", ct->range_bits,
\r
879 max_range_bytes, i);
\r
881 if ((length = per_get_few_bits(pd, i)) < 0)
\r
882 ASN__DECODE_FAILED;
\r
884 /* X.691 #12.2.6 length determinant + lb (1) */
\r
886 ASN_DEBUG("Got length %d", length);
\r
887 if (aper_get_align(pd) != 0)
\r
888 ASN__DECODE_FAILED;
\r
890 int buf = per_get_few_bits(pd, 8);
\r
892 ASN__DECODE_FAILED;
\r
893 value += (((long)buf) << (8 * length));
\r
896 value += ct->lower_bound;
\r
897 if((specs && specs->field_unsigned)
\r
898 ? asn_uint642INTEGER(st, (unsigned long)value)
\r
899 : asn_int642INTEGER(st, value))
\r
900 ASN__DECODE_FAILED;
\r
901 ASN_DEBUG("Got value %ld + low %ld",
\r
902 value, ct->lower_bound);
\r
905 if (ct->range_bits < 8) {
\r
906 value = per_get_few_bits(pd, ct->range_bits);
\r
907 if(value < 0) ASN__DECODE_STARVED;
\r
908 } else if (ct->range_bits == 8) {
\r
909 if (aper_get_align(pd) < 0)
\r
910 ASN__DECODE_FAILED;
\r
911 value = per_get_few_bits(pd, ct->range_bits);
\r
912 if(value < 0) ASN__DECODE_STARVED;
\r
915 if (aper_get_align(pd) < 0)
\r
916 ASN__DECODE_FAILED;
\r
917 value = per_get_few_bits(pd, 16);
\r
918 if(value < 0) ASN__DECODE_STARVED;
\r
920 value += ct->lower_bound;
\r
921 if((specs && specs->field_unsigned)
\r
922 ? asn_ulong2INTEGER(st, value)
\r
923 : asn_long2INTEGER(st, value))
\r
924 ASN__DECODE_FAILED;
\r
925 ASN_DEBUG("Got value %ld + low %ld",
\r
926 value, ct->lower_bound);
\r
930 ASN__DECODE_FAILED;
\r
933 ASN_DEBUG("Decoding unconstrained integer %s", td->name);
\r
936 /* X.691, #12.2.3, #12.2.4 */
\r
942 /* Get the PER length */
\r
943 len = aper_get_length(pd, -1, -1, &repeat);
\r
944 if(len < 0) ASN__DECODE_STARVED;
\r
946 p = REALLOC(st->buf, st->size + len + 1);
\r
947 if(!p) ASN__DECODE_FAILED;
\r
948 st->buf = (uint8_t *)p;
\r
950 ret = per_get_many_bits(pd, &st->buf[st->size], 0, 8 * len);
\r
951 if(ret < 0) ASN__DECODE_STARVED;
\r
954 st->buf[st->size] = 0; /* JIC */
\r
957 if(ct && ct->lower_bound) {
\r
959 * TODO: replace by in-place arithmetics.
\r
962 if(asn_INTEGER2long(st, &value))
\r
963 ASN__DECODE_FAILED;
\r
964 if(asn_long2INTEGER(st, value + ct->lower_bound))
\r
965 ASN__DECODE_FAILED;
\r
972 INTEGER_encode_aper(const asn_TYPE_descriptor_t *td,
\r
973 const asn_per_constraints_t *constraints,
\r
974 const void *sptr, asn_per_outp_t *po) {
\r
975 const asn_INTEGER_specifics_t *specs = (const asn_INTEGER_specifics_t *)td->specifics;
\r
976 asn_enc_rval_t er = {0,0,0};
\r
977 const INTEGER_t *st = (const INTEGER_t *)sptr;
\r
978 const uint8_t *buf;
\r
979 const uint8_t *end;
\r
980 const asn_per_constraint_t *ct;
\r
983 if(!st || st->size == 0) ASN__ENCODE_FAILED;
\r
985 if(!constraints) constraints = td->encoding_constraints.per_constraints;
\r
986 ct = constraints ? &constraints->value : 0;
\r
992 if(specs && specs->field_unsigned) {
\r
993 unsigned long uval;
\r
994 if(asn_INTEGER2ulong(st, &uval))
\r
995 ASN__ENCODE_FAILED;
\r
996 /* Check proper range */
\r
997 if(ct->flags & APC_SEMI_CONSTRAINED) {
\r
998 if(uval < (unsigned long)ct->lower_bound)
\r
1000 } else if(ct->range_bits >= 0) {
\r
1001 if(uval < (unsigned long)ct->lower_bound
\r
1002 || uval > (unsigned long)ct->upper_bound)
\r
1005 ASN_DEBUG("Value %lu (%02x/%lu) lb %ld ub %ld %s",
\r
1006 uval, st->buf[0], st->size,
\r
1007 ct->lower_bound, ct->upper_bound,
\r
1008 inext ? "ext" : "fix");
\r
1011 if(asn_INTEGER2long(st, &value)) ASN__ENCODE_FAILED;
\r
1012 /* Check proper range */
\r
1013 if(ct->flags & APC_SEMI_CONSTRAINED) {
\r
1014 if(value < ct->lower_bound)
\r
1016 } else if(ct->range_bits >= 0) {
\r
1017 if(value < ct->lower_bound
\r
1018 || value > ct->upper_bound)
\r
1021 ASN_DEBUG("Value %lu (%02x/%lu) lb %ld ub %ld %s",
\r
1022 value, st->buf[0], st->size,
\r
1023 ct->lower_bound, ct->upper_bound,
\r
1024 inext ? "ext" : "fix");
\r
1026 if(ct->flags & APC_EXTENSIBLE) {
\r
1027 if(per_put_few_bits(po, inext, 1))
\r
1028 ASN__ENCODE_FAILED;
\r
1030 } else if(inext) {
\r
1031 ASN__ENCODE_FAILED;
\r
1035 /* X.691, #12.2.2 */
\r
1036 if(ct && ct->range_bits >= 0) {
\r
1040 ASN_DEBUG("Encoding integer %ld (%lu) with range %d bits",
\r
1041 value, value - ct->lower_bound, ct->range_bits);
\r
1043 v = value - ct->lower_bound;
\r
1045 /* #12 <= 8 -> alignment ? */
\r
1046 if (ct->range_bits < 8) {
\r
1047 if(per_put_few_bits(po, 0x00 | v, ct->range_bits))
\r
1048 ASN__ENCODE_FAILED;
\r
1049 } else if (ct->range_bits == 8) {
\r
1050 if(aper_put_align(po) < 0)
\r
1051 ASN__ENCODE_FAILED;
\r
1052 if(per_put_few_bits(po, 0x00 | v, ct->range_bits))
\r
1053 ASN__ENCODE_FAILED;
\r
1054 } else if (ct->range_bits <= 16) {
\r
1055 /* Consume the bytes to align on octet */
\r
1056 if(aper_put_align(po) < 0)
\r
1057 ASN__ENCODE_FAILED;
\r
1058 if(per_put_few_bits(po, 0x0000 | v,
\r
1060 ASN__ENCODE_FAILED;
\r
1062 /* TODO: extend to >64 bits */
\r
1065 int max_range_bytes = (ct->range_bits >> 3) +
\r
1066 (((ct->range_bits % 8) > 0) ? 1 : 0);
\r
1068 for (i = 1; ; i++) {
\r
1069 int upper = 1 << i;
\r
1070 if (upper >= max_range_bytes)
\r
1074 for (j = sizeof(int64_t) -1; j != 0; j--) {
\r
1076 val = v64 >> (j * 8);
\r
1081 /* Putting length in the minimum number of bits ex: 5 = 3bits */
\r
1082 if (per_put_few_bits(po, j, i))
\r
1083 ASN__ENCODE_FAILED;
\r
1085 /* Consume the bits to align on octet */
\r
1086 if (aper_put_align(po) < 0)
\r
1087 ASN__ENCODE_FAILED;
\r
1088 /* Put the value */
\r
1089 for (i = 0; i <= j; i++) {
\r
1090 if(per_put_few_bits(po, (v64 >> (8 * (j - i))) & 0xff, 8))
\r
1091 ASN__ENCODE_FAILED;
\r
1094 ASN__ENCODED_OK(er);
\r
1097 if(ct && ct->lower_bound) {
\r
1098 ASN_DEBUG("Adjust lower bound to %ld", ct->lower_bound);
\r
1099 /* TODO: adjust lower bound */
\r
1100 ASN__ENCODE_FAILED;
\r
1103 for(buf = st->buf, end = st->buf + st->size; buf < end;) {
\r
1104 ssize_t mayEncode = aper_put_length(po, -1, end - buf);
\r
1106 ASN__ENCODE_FAILED;
\r
1107 if(per_put_many_bits(po, buf, 8 * mayEncode))
\r
1108 ASN__ENCODE_FAILED;
\r
1112 ASN__ENCODED_OK(er);
\r
1115 #endif /* ASN_DISABLE_PER_SUPPORT */
\r
1118 asn__integer_convert(const uint8_t *b, const uint8_t *end) {
\r
1121 /* Perform the sign initialization */
\r
1122 /* Actually value = -(*b >> 7); gains nothing, yet unreadable! */
\r
1124 value = (uintmax_t)(-1);
\r
1129 /* Conversion engine */
\r
1130 for(; b < end; b++) {
\r
1131 value = (value << 8) | *b;
\r
1138 asn_INTEGER2imax(const INTEGER_t *iptr, intmax_t *lptr) {
\r
1142 /* Sanity checking */
\r
1143 if(!iptr || !iptr->buf || !lptr) {
\r
1148 /* Cache the begin/end of the buffer */
\r
1149 b = iptr->buf; /* Start of the INTEGER buffer */
\r
1150 size = iptr->size;
\r
1151 end = b + size; /* Where to stop */
\r
1153 if(size > sizeof(intmax_t)) {
\r
1154 uint8_t *end1 = end - 1;
\r
1156 * Slightly more advanced processing,
\r
1157 * able to process INTEGERs with >sizeof(intmax_t) bytes
\r
1158 * when the actual value is small, e.g. for intmax_t == int32_t
\r
1159 * (0x0000000000abcdef INTEGER would yield a fine 0x00abcdef int32_t)
\r
1161 /* Skip out the insignificant leading bytes */
\r
1162 for(; b < end1; b++) {
\r
1164 case 0x00: if((b[1] & 0x80) == 0) continue; break;
\r
1165 case 0xff: if((b[1] & 0x80) != 0) continue; break;
\r
1171 if(size > sizeof(intmax_t)) {
\r
1172 /* Still cannot fit the sizeof(intmax_t) */
\r
1178 /* Shortcut processing of a corner case */
\r
1184 *lptr = asn__integer_convert(b, end);
\r
1188 /* FIXME: negative INTEGER values are silently interpreted as large unsigned ones. */
\r
1190 asn_INTEGER2umax(const INTEGER_t *iptr, uintmax_t *lptr) {
\r
1195 if(!iptr || !iptr->buf || !lptr) {
\r
1201 size = iptr->size;
\r
1204 /* If all extra leading bytes are zeroes, ignore them */
\r
1205 for(; size > sizeof(value); b++, size--) {
\r
1207 /* Value won't fit into uintmax_t */
\r
1213 /* Conversion engine */
\r
1214 for(value = 0; b < end; b++)
\r
1215 value = (value << 8) | *b;
\r
1222 asn_umax2INTEGER(INTEGER_t *st, uintmax_t value) {
\r
1228 if(value <= ((~(uintmax_t)0) >> 1)) {
\r
1229 return asn_imax2INTEGER(st, value);
\r
1232 buf = (uint8_t *)MALLOC(1 + sizeof(value));
\r
1233 if(!buf) return -1;
\r
1235 end = buf + (sizeof(value) + 1);
\r
1236 buf[0] = 0; /* INTEGERs are signed. 0-byte indicates positive. */
\r
1237 for(b = buf + 1, shr = (sizeof(value) - 1) * 8; b < end; shr -= 8, b++)
\r
1238 *b = (uint8_t)(value >> shr);
\r
1240 if(st->buf) FREEMEM(st->buf);
\r
1242 st->size = 1 + sizeof(value);
\r
1248 asn_imax2INTEGER(INTEGER_t *st, intmax_t value) {
\r
1249 uint8_t *buf, *bp;
\r
1253 int littleEndian = 1; /* Run-time detection */
\r
1261 buf = (uint8_t *)(long *)MALLOC(sizeof(value));
\r
1262 if(!buf) return -1;
\r
1264 if(*(char *)&littleEndian) {
\r
1265 pstart = (uint8_t *)&value + sizeof(value) - 1;
\r
1266 pend1 = (uint8_t *)&value;
\r
1269 pstart = (uint8_t *)&value;
\r
1270 pend1 = pstart + sizeof(value) - 1;
\r
1275 * If the contents octet consists of more than one octet,
\r
1276 * then bits of the first octet and bit 8 of the second octet:
\r
1277 * a) shall not all be ones; and
\r
1278 * b) shall not all be zero.
\r
1280 for(p = pstart; p != pend1; p += add) {
\r
1282 case 0x00: if((*(p+add) & 0x80) == 0)
\r
1285 case 0xff: if((*(p+add) & 0x80))
\r
1291 /* Copy the integer body */
\r
1292 for(bp = buf, pend1 += add; p != pend1; p += add)
\r
1295 if(st->buf) FREEMEM(st->buf);
\r
1297 st->size = bp - buf;
\r
1303 asn_INTEGER2long(const INTEGER_t *iptr, long *l) {
\r
1305 if(asn_INTEGER2imax(iptr, &v) == 0) {
\r
1306 if(v < LONG_MIN || v > LONG_MAX) {
\r
1318 asn_INTEGER2ulong(const INTEGER_t *iptr, unsigned long *l) {
\r
1320 if(asn_INTEGER2umax(iptr, &v) == 0) {
\r
1321 if(v > ULONG_MAX) {
\r
1333 asn_long2INTEGER(INTEGER_t *st, long value) {
\r
1334 return asn_imax2INTEGER(st, value);
\r
1338 asn_ulong2INTEGER(INTEGER_t *st, unsigned long value) {
\r
1339 return asn_imax2INTEGER(st, value);
\r
1344 asn_uint642INTEGER(INTEGER_t *st, uint64_t value) {
\r
1350 if(value <= INT64_MAX)
\r
1351 return asn_int642INTEGER(st, value);
\r
1353 buf = (uint8_t *)MALLOC(1 + sizeof(value));
\r
1354 if(!buf) return -1;
\r
1356 end = buf + (sizeof(value) + 1);
\r
1358 for(b = buf + 1, shr = (sizeof(value)-1)*8; b < end; shr -= 8, b++)
\r
1359 *b = (uint8_t)(value >> shr);
\r
1361 if(st->buf) FREEMEM(st->buf);
\r
1363 st->size = 1 + sizeof(value);
\r
1369 asn_int642INTEGER(INTEGER_t *st, int64_t value) {
\r
1370 uint8_t *buf, *bp;
\r
1374 int littleEndian = 1; /* Run-time detection */
\r
1382 buf = (uint8_t *)MALLOC(sizeof(value));
\r
1383 if(!buf) return -1;
\r
1385 if(*(char *)&littleEndian) {
\r
1386 pstart = (uint8_t *)&value + sizeof(value) - 1;
\r
1387 pend1 = (uint8_t *)&value;
\r
1390 pstart = (uint8_t *)&value;
\r
1391 pend1 = pstart + sizeof(value) - 1;
\r
1396 * If the contents octet consists of more than one octet,
\r
1397 * then bits of the first octet and bit 8 of the second octet:
\r
1398 * a) shall not all be ones; and
\r
1399 * b) shall not all be zero.
\r
1401 for(p = pstart; p != pend1; p += add) {
\r
1403 case 0x00: if((*(p+add) & 0x80) == 0)
\r
1406 case 0xff: if((*(p+add) & 0x80))
\r
1412 /* Copy the integer body */
\r
1413 for(pstart = p, bp = buf, pend1 += add; p != pend1; p += add)
\r
1416 if(st->buf) FREEMEM(st->buf);
\r
1418 st->size = bp - buf;
\r
1424 * Parse the number in the given string until the given *end position,
\r
1425 * returning the position after the last parsed character back using the
\r
1426 * same (*end) pointer.
\r
1427 * WARNING: This behavior is different from the standard strtol/strtoimax(3).
\r
1429 enum asn_strtox_result_e
\r
1430 asn_strtoimax_lim(const char *str, const char **end, intmax_t *intp) {
\r
1434 #define ASN1_INTMAX_MAX ((~(uintmax_t)0) >> 1)
\r
1435 const intmax_t upper_boundary = ASN1_INTMAX_MAX / 10;
\r
1436 intmax_t last_digit_max = ASN1_INTMAX_MAX % 10;
\r
1437 #undef ASN1_INTMAX_MAX
\r
1439 if(str >= *end) return ASN_STRTOX_ERROR_INVAL;
\r
1445 /* FALL THROUGH */
\r
1450 return ASN_STRTOX_EXPECT_MORE;
\r
1454 for(value = 0; str < (*end); str++) {
\r
1456 case 0x30: case 0x31: case 0x32: case 0x33: case 0x34:
\r
1457 case 0x35: case 0x36: case 0x37: case 0x38: case 0x39: {
\r
1458 int d = *str - '0';
\r
1459 if(value < upper_boundary) {
\r
1460 value = value * 10 + d;
\r
1461 } else if(value == upper_boundary) {
\r
1462 if(d <= last_digit_max) {
\r
1464 value = value * 10 + d;
\r
1467 value = -value * 10 - d;
\r
1471 return ASN_STRTOX_ERROR_RANGE;
\r
1475 return ASN_STRTOX_ERROR_RANGE;
\r
1481 *intp = sign * value;
\r
1482 return ASN_STRTOX_EXTRA_DATA;
\r
1487 *intp = sign * value;
\r
1488 return ASN_STRTOX_OK;
\r
1492 * Parse the number in the given string until the given *end position,
\r
1493 * returning the position after the last parsed character back using the
\r
1494 * same (*end) pointer.
\r
1495 * WARNING: This behavior is different from the standard strtoul/strtoumax(3).
\r
1497 enum asn_strtox_result_e
\r
1498 asn_strtoumax_lim(const char *str, const char **end, uintmax_t *uintp) {
\r
1501 #define ASN1_UINTMAX_MAX ((~(uintmax_t)0))
\r
1502 const uintmax_t upper_boundary = ASN1_UINTMAX_MAX / 10;
\r
1503 uintmax_t last_digit_max = ASN1_UINTMAX_MAX % 10;
\r
1504 #undef ASN1_UINTMAX_MAX
\r
1506 if(str >= *end) return ASN_STRTOX_ERROR_INVAL;
\r
1510 return ASN_STRTOX_ERROR_INVAL;
\r
1515 return ASN_STRTOX_EXPECT_MORE;
\r
1519 for(value = 0; str < (*end); str++) {
\r
1521 case 0x30: case 0x31: case 0x32: case 0x33: case 0x34:
\r
1522 case 0x35: case 0x36: case 0x37: case 0x38: case 0x39: {
\r
1523 unsigned int d = *str - '0';
\r
1524 if(value < upper_boundary) {
\r
1525 value = value * 10 + d;
\r
1526 } else if(value == upper_boundary) {
\r
1527 if(d <= last_digit_max) {
\r
1528 value = value * 10 + d;
\r
1531 return ASN_STRTOX_ERROR_RANGE;
\r
1535 return ASN_STRTOX_ERROR_RANGE;
\r
1542 return ASN_STRTOX_EXTRA_DATA;
\r
1548 return ASN_STRTOX_OK;
\r
1551 enum asn_strtox_result_e
\r
1552 asn_strtol_lim(const char *str, const char **end, long *lp) {
\r
1554 switch(asn_strtoimax_lim(str, end, &value)) {
\r
1555 case ASN_STRTOX_ERROR_RANGE:
\r
1556 return ASN_STRTOX_ERROR_RANGE;
\r
1557 case ASN_STRTOX_ERROR_INVAL:
\r
1558 return ASN_STRTOX_ERROR_INVAL;
\r
1559 case ASN_STRTOX_EXPECT_MORE:
\r
1560 return ASN_STRTOX_EXPECT_MORE;
\r
1561 case ASN_STRTOX_OK:
\r
1562 if(value >= LONG_MIN && value <= LONG_MAX) {
\r
1564 return ASN_STRTOX_OK;
\r
1566 return ASN_STRTOX_ERROR_RANGE;
\r
1568 case ASN_STRTOX_EXTRA_DATA:
\r
1569 if(value >= LONG_MIN && value <= LONG_MAX) {
\r
1571 return ASN_STRTOX_EXTRA_DATA;
\r
1573 return ASN_STRTOX_ERROR_RANGE;
\r
1577 assert(!"Unreachable");
\r
1578 return ASN_STRTOX_ERROR_INVAL;
\r
1581 enum asn_strtox_result_e
\r
1582 asn_strtoul_lim(const char *str, const char **end, unsigned long *ulp) {
\r
1584 switch(asn_strtoumax_lim(str, end, &value)) {
\r
1585 case ASN_STRTOX_ERROR_RANGE:
\r
1586 return ASN_STRTOX_ERROR_RANGE;
\r
1587 case ASN_STRTOX_ERROR_INVAL:
\r
1588 return ASN_STRTOX_ERROR_INVAL;
\r
1589 case ASN_STRTOX_EXPECT_MORE:
\r
1590 return ASN_STRTOX_EXPECT_MORE;
\r
1591 case ASN_STRTOX_OK:
\r
1592 if(value <= ULONG_MAX) {
\r
1594 return ASN_STRTOX_OK;
\r
1596 return ASN_STRTOX_ERROR_RANGE;
\r
1598 case ASN_STRTOX_EXTRA_DATA:
\r
1599 if(value <= ULONG_MAX) {
\r
1601 return ASN_STRTOX_EXTRA_DATA;
\r
1603 return ASN_STRTOX_ERROR_RANGE;
\r
1607 assert(!"Unreachable");
\r
1608 return ASN_STRTOX_ERROR_INVAL;
\r
1612 INTEGER_compare(const asn_TYPE_descriptor_t *td, const void *aptr,
\r
1613 const void *bptr) {
\r
1614 const INTEGER_t *a = aptr;
\r
1615 const INTEGER_t *b = bptr;
\r
1620 if(a->size && b->size) {
\r
1621 int sign_a = (a->buf[0] & 0x80) ? -1 : 1;
\r
1622 int sign_b = (b->buf[0] & 0x80) ? -1 : 1;
\r
1624 if(sign_a < sign_b) return -1;
\r
1625 if(sign_a > sign_b) return 1;
\r
1627 /* The shortest integer wins, unless comparing negatives */
\r
1628 if(a->size < b->size) {
\r
1629 return -1 * sign_a;
\r
1630 } else if(a->size > b->size) {
\r
1631 return 1 * sign_b;
\r
1634 return sign_a * memcmp(a->buf, b->buf, a->size);
\r
1635 } else if(a->size) {
\r
1636 int sign = (a->buf[0] & 0x80) ? -1 : 1;
\r
1637 return (1) * sign;
\r
1638 } else if(b->size) {
\r
1639 int sign = (a->buf[0] & 0x80) ? -1 : 1;
\r
1640 return (-1) * sign;
\r
1644 } else if(!a && !b) {
\r
1654 asn_random_fill_result_t
\r
1655 INTEGER_random_fill(const asn_TYPE_descriptor_t *td, void **sptr,
\r
1656 const asn_encoding_constraints_t *constraints,
\r
1657 size_t max_length) {
\r
1658 const asn_INTEGER_specifics_t *specs =
\r
1659 (const asn_INTEGER_specifics_t *)td->specifics;
\r
1660 asn_random_fill_result_t result_ok = {ARFILL_OK, 1};
\r
1661 asn_random_fill_result_t result_failed = {ARFILL_FAILED, 0};
\r
1662 asn_random_fill_result_t result_skipped = {ARFILL_SKIPPED, 0};
\r
1663 INTEGER_t *st = *sptr;
\r
1664 const asn_INTEGER_enum_map_t *emap;
\r
1667 int find_inside_map;
\r
1669 if(max_length == 0) return result_skipped;
\r
1672 st = (INTEGER_t *)CALLOC(1, sizeof(*st));
\r
1674 return result_failed;
\r
1679 emap = specs->value2enum;
\r
1680 emap_len = specs->map_count;
\r
1681 if(specs->strict_enumeration) {
\r
1682 find_inside_map = emap_len > 0;
\r
1684 find_inside_map = emap_len ? asn_random_between(0, 1) : 0;
\r
1689 find_inside_map = 0;
\r
1692 if(find_inside_map) {
\r
1693 assert(emap_len > 0);
\r
1694 value = emap[asn_random_between(0, emap_len - 1)].nat_value;
\r
1696 const asn_per_constraints_t *ct;
\r
1698 static const long variants[] = {
\r
1699 -65536, -65535, -65534, -32769, -32768, -32767, -16385, -16384,
\r
1700 -16383, -257, -256, -255, -254, -129, -128, -127,
\r
1701 -126, -1, 0, 1, 126, 127, 128, 129,
\r
1702 254, 255, 256, 257, 16383, 16384, 16385, 32767,
\r
1703 32768, 32769, 65534, 65535, 65536, 65537};
\r
1704 if(specs && specs->field_unsigned) {
\r
1705 assert(variants[18] == 0);
\r
1706 value = variants[asn_random_between(
\r
1707 18, sizeof(variants) / sizeof(variants[0]) - 1)];
\r
1709 value = variants[asn_random_between(
\r
1710 0, sizeof(variants) / sizeof(variants[0]) - 1)];
\r
1713 if(!constraints) constraints = &td->encoding_constraints;
\r
1714 ct = constraints ? constraints->per_constraints : 0;
\r
1715 if(ct && (ct->value.flags & APC_CONSTRAINED)) {
\r
1716 if(value < ct->value.lower_bound || value > ct->value.upper_bound) {
\r
1717 value = asn_random_between(ct->value.lower_bound,
\r
1718 ct->value.upper_bound);
\r
1723 if(asn_imax2INTEGER(st, value)) {
\r
1725 ASN_STRUCT_RESET(*td, st);
\r
1727 ASN_STRUCT_FREE(*td, st);
\r
1729 return result_failed;
\r
1732 result_ok.length = st->size;
\r