libs/smux/INTEGER.c

   1 /*
   2  * Copyright (c) 2003-2019 Lev Walkin <vlm@lionet.info>.
   3  * All rights reserved.
   4  * Redistribution and modifications are permitted subject to BSD license.
   5  */
   6 #include <asn_internal.h>
   7 #include <INTEGER.h>
   8 #include <asn_codecs_prim.h>    /* Encoder and decoder of a primitive type */
   9 #include <errno.h>
  10
  11 /*
  12  * INTEGER basic type description.
  13  */
  14 static const ber_tlv_tag_t asn_DEF_INTEGER_tags[] = {
  15         (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
  16 };
  17 asn_TYPE_operation_t asn_OP_INTEGER = {
  18         INTEGER_free,
  19         INTEGER_print,
  20         INTEGER_compare,
  21         ber_decode_primitive,
  22         INTEGER_encode_der,
  23         INTEGER_decode_xer,
  24         INTEGER_encode_xer,
  25 #ifdef  ASN_DISABLE_OER_SUPPORT
  26         0,
  27         0,
  28 #else
  29         INTEGER_decode_oer,     /* OER decoder */
  30         INTEGER_encode_oer,     /* Canonical OER encoder */
  31 #endif  /* ASN_DISABLE_OER_SUPPORT */
  32 #ifdef  ASN_DISABLE_PER_SUPPORT
  33         0,
  34         0,
  35 #else
  36         INTEGER_decode_uper,    /* Unaligned PER decoder */
  37         INTEGER_encode_uper,    /* Unaligned PER encoder */
  38 #endif  /* ASN_DISABLE_PER_SUPPORT */
  39         INTEGER_random_fill,
  40         0       /* Use generic outmost tag fetcher */
  41 };
  42 asn_TYPE_descriptor_t asn_DEF_INTEGER = {
  43         "INTEGER",
  44         "INTEGER",
  45         &asn_OP_INTEGER,
  46         asn_DEF_INTEGER_tags,
  47         sizeof(asn_DEF_INTEGER_tags) / sizeof(asn_DEF_INTEGER_tags[0]),
  48         asn_DEF_INTEGER_tags,   /* Same as above */
  49         sizeof(asn_DEF_INTEGER_tags) / sizeof(asn_DEF_INTEGER_tags[0]),
  50         { 0, 0, asn_generic_no_constraint },
  51         0, 0,   /* No members */
  52         0       /* No specifics */
  53 };
  54
  55 /*
  56  * Encode INTEGER type using DER.
  57  */
  58 asn_enc_rval_t
  59 INTEGER_encode_der(const asn_TYPE_descriptor_t *td, const void *sptr,
  60                    int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb,
  61                    void *app_key) {
  62     const INTEGER_t *st = (const INTEGER_t *)sptr;
  63     asn_enc_rval_t rval;
  64     INTEGER_t effective_integer;
  65
  66         ASN_DEBUG("%s %s as INTEGER (tm=%d)",
  67                 cb?"Encoding":"Estimating", td->name, tag_mode);
  68
  69         /*
  70          * Canonicalize integer in the buffer.
  71          * (Remove too long sign extension, remove some first 0x00 bytes)
  72          */
  73         if(st->buf) {
  74                 uint8_t *buf = st->buf;
  75                 uint8_t *end1 = buf + st->size - 1;
  76                 int shift;
  77
  78                 /* Compute the number of superfluous leading bytes */
  79                 for(; buf < end1; buf++) {
  80                         /*
  81                          * If the contents octets of an integer value encoding
  82                          * consist of more than one octet, then the bits of the
  83                          * first octet and bit 8 of the second octet:
  84                          * a) shall not all be ones; and
  85                          * b) shall not all be zero.
  86                          */
  87                         switch(*buf) {
  88                         case 0x00: if((buf[1] & 0x80) == 0)
  89                                         continue;
  90                                 break;
  91                         case 0xff: if((buf[1] & 0x80))
  92                                         continue;
  93                                 break;
  94                         }
  95                         break;
  96                 }
  97
  98                 /* Remove leading superfluous bytes from the integer */
  99                 shift = buf - st->buf;
 100                 if(shift) {
 101             union {
 102                 const uint8_t *c_buf;
 103                 uint8_t *nc_buf;
 104             } unconst;
 105             unconst.c_buf = st->buf;
 106             effective_integer.buf = unconst.nc_buf + shift;
 107             effective_integer.size = st->size - shift;
 108
 109             st = &effective_integer;
 110         }
 111     }
 112
 113     rval = der_encode_primitive(td, st, tag_mode, tag, cb, app_key);
 114     if(rval.structure_ptr == &effective_integer) {
 115         rval.structure_ptr = sptr;
 116     }
 117     return rval;
 118 }
 119
 120 static const asn_INTEGER_enum_map_t *INTEGER_map_enum2value(
 121     const asn_INTEGER_specifics_t *specs, const char *lstart,
 122     const char *lstop);
 123
 124 /*
 125  * INTEGER specific human-readable output.
 126  */
 127 static ssize_t
 128 INTEGER__dump(const asn_TYPE_descriptor_t *td, const INTEGER_t *st, asn_app_consume_bytes_f *cb, void *app_key, int plainOrXER) {
 129     const asn_INTEGER_specifics_t *specs =
 130         (const asn_INTEGER_specifics_t *)td->specifics;
 131         char scratch[32];
 132         uint8_t *buf = st->buf;
 133         uint8_t *buf_end = st->buf + st->size;
 134         intmax_t value;
 135         ssize_t wrote = 0;
 136         char *p;
 137         int ret;
 138
 139         if(specs && specs->field_unsigned)
 140                 ret = asn_INTEGER2umax(st, (uintmax_t *)&value);
 141         else
 142                 ret = asn_INTEGER2imax(st, &value);
 143
 144         /* Simple case: the integer size is small */
 145         if(ret == 0) {
 146                 const asn_INTEGER_enum_map_t *el;
 147                 el = (value >= 0 || !specs || !specs->field_unsigned)
 148                         ? INTEGER_map_value2enum(specs, value) : 0;
 149                 if(el) {
 150                         if(plainOrXER == 0)
 151                                 return asn__format_to_callback(cb, app_key,
 152                                         "%" ASN_PRIdMAX " (%s)", value, el->enum_name);
 153                         else
 154                                 return asn__format_to_callback(cb, app_key,
 155                                         "<%s/>", el->enum_name);
 156                 } else if(plainOrXER && specs && specs->strict_enumeration) {
 157                         ASN_DEBUG("ASN.1 forbids dealing with "
 158                                 "unknown value of ENUMERATED type");
 159                         errno = EPERM;
 160                         return -1;
 161                 } else {
 162             return asn__format_to_callback(cb, app_key,
 163                                            (specs && specs->field_unsigned)
 164                                                ? "%" ASN_PRIuMAX
 165                                                : "%" ASN_PRIdMAX,
 166                                            value);
 167         }
 168         } else if(plainOrXER && specs && specs->strict_enumeration) {
 169                 /*
 170                  * Here and earlier, we cannot encode the ENUMERATED values
 171                  * if there is no corresponding identifier.
 172                  */
 173                 ASN_DEBUG("ASN.1 forbids dealing with "
 174                         "unknown value of ENUMERATED type");
 175                 errno = EPERM;
 176                 return -1;
 177         }
 178
 179         /* Output in the long xx:yy:zz... format */
 180         /* TODO: replace with generic algorithm (Knuth TAOCP Vol 2, 4.3.1) */
 181         for(p = scratch; buf < buf_end; buf++) {
 182                 const char * const h2c = "0123456789ABCDEF";
 183                 if((p - scratch) >= (ssize_t)(sizeof(scratch) - 4)) {
 184                         /* Flush buffer */
 185                         if(cb(scratch, p - scratch, app_key) < 0)
 186                                 return -1;
 187                         wrote += p - scratch;
 188                         p = scratch;
 189                 }
 190                 *p++ = h2c[*buf >> 4];
 191                 *p++ = h2c[*buf & 0x0F];
 192                 *p++ = 0x3a;    /* ":" */
 193         }
 194         if(p != scratch)
 195                 p--;    /* Remove the last ":" */
 196
 197         wrote += p - scratch;
 198         return (cb(scratch, p - scratch, app_key) < 0) ? -1 : wrote;
 199 }
 200
 201 /*
 202  * INTEGER specific human-readable output.
 203  */
 204 int
 205 INTEGER_print(const asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
 206               asn_app_consume_bytes_f *cb, void *app_key) {
 207     const INTEGER_t *st = (const INTEGER_t *)sptr;
 208         ssize_t ret;
 209
 210         (void)ilevel;
 211
 212         if(!st || !st->buf)
 213                 ret = cb("<absent>", 8, app_key);
 214         else
 215                 ret = INTEGER__dump(td, st, cb, app_key, 0);
 216
 217         return (ret < 0) ? -1 : 0;
 218 }
 219
 220 struct e2v_key {
 221         const char *start;
 222         const char *stop;
 223         const asn_INTEGER_enum_map_t *vemap;
 224         const unsigned int *evmap;
 225 };
 226 static int
 227 INTEGER__compar_enum2value(const void *kp, const void *am) {
 228         const struct e2v_key *key = (const struct e2v_key *)kp;
 229         const asn_INTEGER_enum_map_t *el = (const asn_INTEGER_enum_map_t *)am;
 230         const char *ptr, *end, *name;
 231
 232         /* Remap the element (sort by different criterion) */
 233         el = key->vemap + key->evmap[el - key->vemap];
 234
 235         /* Compare strings */
 236         for(ptr = key->start, end = key->stop, name = el->enum_name;
 237                         ptr < end; ptr++, name++) {
 238                 if(*ptr != *name || !*name)
 239                         return *(const unsigned char *)ptr
 240                                 - *(const unsigned char *)name;
 241         }
 242         return name[0] ? -1 : 0;
 243 }
 244
 245 static const asn_INTEGER_enum_map_t *
 246 INTEGER_map_enum2value(const asn_INTEGER_specifics_t *specs, const char *lstart,
 247                        const char *lstop) {
 248     const asn_INTEGER_enum_map_t *el_found;
 249         int count = specs ? specs->map_count : 0;
 250         struct e2v_key key;
 251         const char *lp;
 252
 253         if(!count) return NULL;
 254
 255         /* Guaranteed: assert(lstart < lstop); */
 256         /* Figure out the tag name */
 257         for(lstart++, lp = lstart; lp < lstop; lp++) {
 258                 switch(*lp) {
 259                 case 9: case 10: case 11: case 12: case 13: case 32: /* WSP */
 260                 case 0x2f: /* '/' */ case 0x3e: /* '>' */
 261                         break;
 262                 default:
 263                         continue;
 264                 }
 265                 break;
 266         }
 267         if(lp == lstop) return NULL;    /* No tag found */
 268         lstop = lp;
 269
 270         key.start = lstart;
 271         key.stop = lstop;
 272         key.vemap = specs->value2enum;
 273         key.evmap = specs->enum2value;
 274         el_found = (asn_INTEGER_enum_map_t *)bsearch(&key,
 275                 specs->value2enum, count, sizeof(specs->value2enum[0]),
 276                 INTEGER__compar_enum2value);
 277         if(el_found) {
 278                 /* Remap enum2value into value2enum */
 279                 el_found = key.vemap + key.evmap[el_found - key.vemap];
 280         }
 281         return el_found;
 282 }
 283
 284 static int
 285 INTEGER__compar_value2enum(const void *kp, const void *am) {
 286         long a = *(const long *)kp;
 287         const asn_INTEGER_enum_map_t *el = (const asn_INTEGER_enum_map_t *)am;
 288         long b = el->nat_value;
 289         if(a < b) return -1;
 290         else if(a == b) return 0;
 291         else return 1;
 292 }
 293
 294 const asn_INTEGER_enum_map_t *
 295 INTEGER_map_value2enum(const asn_INTEGER_specifics_t *specs, long value) {
 296         int count = specs ? specs->map_count : 0;
 297         if(!count) return 0;
 298         return (asn_INTEGER_enum_map_t *)bsearch(&value, specs->value2enum,
 299                 count, sizeof(specs->value2enum[0]),
 300                 INTEGER__compar_value2enum);
 301 }
 302
 303 static int
 304 INTEGER_st_prealloc(INTEGER_t *st, int min_size) {
 305         void *p = MALLOC(min_size + 1);
 306         if(p) {
 307                 void *b = st->buf;
 308                 st->size = 0;
 309                 st->buf = p;
 310                 FREEMEM(b);
 311                 return 0;
 312         } else {
 313                 return -1;
 314         }
 315 }
 316
 317 /*
 318  * Decode the chunk of XML text encoding INTEGER.
 319  */
 320 static enum xer_pbd_rval
 321 INTEGER__xer_body_decode(const asn_TYPE_descriptor_t *td, void *sptr,
 322                          const void *chunk_buf, size_t chunk_size) {
 323     INTEGER_t *st = (INTEGER_t *)sptr;
 324         intmax_t dec_value;
 325         intmax_t hex_value = 0;
 326         const char *lp;
 327         const char *lstart = (const char *)chunk_buf;
 328         const char *lstop = lstart + chunk_size;
 329         enum {
 330                 ST_LEADSPACE,
 331                 ST_SKIPSPHEX,
 332                 ST_WAITDIGITS,
 333                 ST_DIGITS,
 334                 ST_DIGITS_TRAILSPACE,
 335                 ST_HEXDIGIT1,
 336                 ST_HEXDIGIT2,
 337                 ST_HEXDIGITS_TRAILSPACE,
 338                 ST_HEXCOLON,
 339                 ST_END_ENUM,
 340                 ST_UNEXPECTED
 341         } state = ST_LEADSPACE;
 342         const char *dec_value_start = 0; /* INVARIANT: always !0 in ST_DIGITS */
 343         const char *dec_value_end = 0;
 344
 345         if(chunk_size)
 346                 ASN_DEBUG("INTEGER body %ld 0x%2x..0x%2x",
 347                         (long)chunk_size, *lstart, lstop[-1]);
 348
 349         if(INTEGER_st_prealloc(st, (chunk_size/3) + 1))
 350                 return XPBD_SYSTEM_FAILURE;
 351
 352         /*
 353          * We may have received a tag here. It will be processed inline.
 354          * Use strtoul()-like code and serialize the result.
 355          */
 356         for(lp = lstart; lp < lstop; lp++) {
 357                 int lv = *lp;
 358                 switch(lv) {
 359                 case 0x09: case 0x0a: case 0x0d: case 0x20:
 360                         switch(state) {
 361                         case ST_LEADSPACE:
 362                         case ST_DIGITS_TRAILSPACE:
 363                         case ST_HEXDIGITS_TRAILSPACE:
 364                         case ST_SKIPSPHEX:
 365                                 continue;
 366                         case ST_DIGITS:
 367                                 dec_value_end = lp;
 368                                 state = ST_DIGITS_TRAILSPACE;
 369                                 continue;
 370                         case ST_HEXCOLON:
 371                                 state = ST_HEXDIGITS_TRAILSPACE;
 372                                 continue;
 373                         default:
 374                                 break;
 375                         }
 376                         break;
 377                 case 0x2d:      /* '-' */
 378                         if(state == ST_LEADSPACE) {
 379                                 dec_value = 0;
 380                                 dec_value_start = lp;
 381                                 state = ST_WAITDIGITS;
 382                                 continue;
 383                         }
 384                         break;
 385                 case 0x2b:      /* '+' */
 386                         if(state == ST_LEADSPACE) {
 387                                 dec_value = 0;
 388                                 dec_value_start = lp;
 389                                 state = ST_WAITDIGITS;
 390                                 continue;
 391                         }
 392                         break;
 393                 case 0x30: case 0x31: case 0x32: case 0x33: case 0x34:
 394                 case 0x35: case 0x36: case 0x37: case 0x38: case 0x39:
 395                         switch(state) {
 396                         case ST_DIGITS: continue;
 397                         case ST_SKIPSPHEX:      /* Fall through */
 398                         case ST_HEXDIGIT1:
 399                                 hex_value = (lv - 0x30) << 4;
 400                                 state = ST_HEXDIGIT2;
 401                                 continue;
 402                         case ST_HEXDIGIT2:
 403                                 hex_value += (lv - 0x30);
 404                                 state = ST_HEXCOLON;
 405                                 st->buf[st->size++] = (uint8_t)hex_value;
 406                                 continue;
 407                         case ST_HEXCOLON:
 408                                 return XPBD_BROKEN_ENCODING;
 409                         case ST_LEADSPACE:
 410                                 dec_value = 0;
 411                                 dec_value_start = lp;
 412                                 /* FALL THROUGH */
 413                         case ST_WAITDIGITS:
 414                                 state = ST_DIGITS;
 415                                 continue;
 416                         default:
 417                                 break;
 418                         }
 419                         break;
 420                 case 0x3c:      /* '<', start of XML encoded enumeration */
 421                         if(state == ST_LEADSPACE) {
 422                                 const asn_INTEGER_enum_map_t *el;
 423                                 el = INTEGER_map_enum2value(
 424                                         (const asn_INTEGER_specifics_t *)
 425                                         td->specifics, lstart, lstop);
 426                                 if(el) {
 427                                         ASN_DEBUG("Found \"%s\" => %ld",
 428                                                 el->enum_name, el->nat_value);
 429                                         dec_value = el->nat_value;
 430                                         state = ST_END_ENUM;
 431                                         lp = lstop - 1;
 432                                         continue;
 433                                 }
 434                                 ASN_DEBUG("Unknown identifier for INTEGER");
 435                         }
 436                         return XPBD_BROKEN_ENCODING;
 437                 case 0x3a:      /* ':' */
 438                         if(state == ST_HEXCOLON) {
 439                                 /* This colon is expected */
 440                                 state = ST_HEXDIGIT1;
 441                                 continue;
 442                         } else if(state == ST_DIGITS) {
 443                                 /* The colon here means that we have
 444                                  * decoded the first two hexadecimal
 445                                  * places as a decimal value.
 446                                  * Switch decoding mode. */
 447                                 ASN_DEBUG("INTEGER re-evaluate as hex form");
 448                                 state = ST_SKIPSPHEX;
 449                                 dec_value_start = 0;
 450                                 lp = lstart - 1;
 451                                 continue;
 452                         } else {
 453                                 ASN_DEBUG("state %d at %ld", state, (long)(lp - lstart));
 454                                 break;
 455                         }
 456                 /* [A-Fa-f] */
 457                 case 0x41:case 0x42:case 0x43:case 0x44:case 0x45:case 0x46:
 458                 case 0x61:case 0x62:case 0x63:case 0x64:case 0x65:case 0x66:
 459                         switch(state) {
 460                         case ST_SKIPSPHEX:
 461                         case ST_LEADSPACE: /* Fall through */
 462                         case ST_HEXDIGIT1:
 463                                 hex_value = lv - ((lv < 0x61) ? 0x41 : 0x61);
 464                                 hex_value += 10;
 465                                 hex_value <<= 4;
 466                                 state = ST_HEXDIGIT2;
 467                                 continue;
 468                         case ST_HEXDIGIT2:
 469                                 hex_value += lv - ((lv < 0x61) ? 0x41 : 0x61);
 470                                 hex_value += 10;
 471                                 st->buf[st->size++] = (uint8_t)hex_value;
 472                                 state = ST_HEXCOLON;
 473                                 continue;
 474                         case ST_DIGITS:
 475                                 ASN_DEBUG("INTEGER re-evaluate as hex form");
 476                                 state = ST_SKIPSPHEX;
 477                                 dec_value_start = 0;
 478                                 lp = lstart - 1;
 479                                 continue;
 480                         default:
 481                                 break;
 482                         }
 483                         break;
 484                 }
 485
 486                 /* Found extra non-numeric stuff */
 487                 ASN_DEBUG("INTEGER :: Found non-numeric 0x%2x at %ld",
 488                         lv, (long)(lp - lstart));
 489                 state = ST_UNEXPECTED;
 490                 break;
 491         }
 492
 493         switch(state) {
 494         case ST_END_ENUM:
 495                 /* Got a complete and valid enumeration encoded as a tag. */
 496                 break;
 497         case ST_DIGITS:
 498                 dec_value_end = lstop;
 499                 /* FALL THROUGH */
 500         case ST_DIGITS_TRAILSPACE:
 501                 /* The last symbol encountered was a digit. */
 502         switch(asn_strtoimax_lim(dec_value_start, &dec_value_end, &dec_value)) {
 503         case ASN_STRTOX_OK:
 504             if(dec_value >= LONG_MIN && dec_value <= LONG_MAX) {
 505                 break;
 506             } else {
 507                 /*
 508                  * We model INTEGER on long for XER,
 509                  * to avoid rewriting all the tests at once.
 510                  */
 511                 ASN_DEBUG("INTEGER exceeds long range");
 512             }
 513             /* Fall through */
 514         case ASN_STRTOX_ERROR_RANGE:
 515             ASN_DEBUG("INTEGER decode %s hit range limit", td->name);
 516             return XPBD_DECODER_LIMIT;
 517                 case ASN_STRTOX_ERROR_INVAL:
 518                 case ASN_STRTOX_EXPECT_MORE:
 519                 case ASN_STRTOX_EXTRA_DATA:
 520                         return XPBD_BROKEN_ENCODING;
 521                 }
 522                 break;
 523         case ST_HEXCOLON:
 524         case ST_HEXDIGITS_TRAILSPACE:
 525                 st->buf[st->size] = 0;  /* Just in case termination */
 526                 return XPBD_BODY_CONSUMED;
 527         case ST_HEXDIGIT1:
 528         case ST_HEXDIGIT2:
 529         case ST_SKIPSPHEX:
 530                 return XPBD_BROKEN_ENCODING;
 531         case ST_LEADSPACE:
 532                 /* Content not found */
 533                 return XPBD_NOT_BODY_IGNORE;
 534         case ST_WAITDIGITS:
 535         case ST_UNEXPECTED:
 536                 ASN_DEBUG("INTEGER: No useful digits (state %d)", state);
 537                 return XPBD_BROKEN_ENCODING;    /* No digits */
 538         }
 539
 540         /*
 541          * Convert the result of parsing of enumeration or a straight
 542          * decimal value into a BER representation.
 543          */
 544         if(asn_imax2INTEGER(st, dec_value)) {
 545                 ASN_DEBUG("INTEGER decode %s conversion failed", td->name);
 546                 return XPBD_SYSTEM_FAILURE;
 547         }
 548
 549         return XPBD_BODY_CONSUMED;
 550 }
 551
 552 asn_dec_rval_t
 553 INTEGER_decode_xer(const asn_codec_ctx_t *opt_codec_ctx,
 554                    const asn_TYPE_descriptor_t *td, void **sptr,
 555                    const char *opt_mname, const void *buf_ptr, size_t size) {
 556     return xer_decode_primitive(opt_codec_ctx, td,
 557                 sptr, sizeof(INTEGER_t), opt_mname,
 558                 buf_ptr, size, INTEGER__xer_body_decode);
 559 }
 560
 561 asn_enc_rval_t
 562 INTEGER_encode_xer(const asn_TYPE_descriptor_t *td, const void *sptr,
 563                    int ilevel, enum xer_encoder_flags_e flags,
 564                    asn_app_consume_bytes_f *cb, void *app_key) {
 565     const INTEGER_t *st = (const INTEGER_t *)sptr;
 566         asn_enc_rval_t er;
 567
 568         (void)ilevel;
 569         (void)flags;
 570
 571         if(!st || !st->buf)
 572                 ASN__ENCODE_FAILED;
 573
 574         er.encoded = INTEGER__dump(td, st, cb, app_key, 1);
 575         if(er.encoded < 0) ASN__ENCODE_FAILED;
 576
 577         ASN__ENCODED_OK(er);
 578 }
 579
 580 #ifndef ASN_DISABLE_PER_SUPPORT
 581
 582 asn_dec_rval_t
 583 INTEGER_decode_uper(const asn_codec_ctx_t *opt_codec_ctx,
 584                     const asn_TYPE_descriptor_t *td,
 585                     const asn_per_constraints_t *constraints, void **sptr,
 586                     asn_per_data_t *pd) {
 587     const asn_INTEGER_specifics_t *specs =
 588         (const asn_INTEGER_specifics_t *)td->specifics;
 589     asn_dec_rval_t rval = { RC_OK, 0 };
 590         INTEGER_t *st = (INTEGER_t *)*sptr;
 591         const asn_per_constraint_t *ct;
 592         int repeat;
 593
 594         (void)opt_codec_ctx;
 595
 596         if(!st) {
 597                 st = (INTEGER_t *)(*sptr = CALLOC(1, sizeof(*st)));
 598                 if(!st) ASN__DECODE_FAILED;
 599         }
 600
 601         if(!constraints) constraints = td->encoding_constraints.per_constraints;
 602         ct = constraints ? &constraints->value : 0;
 603
 604         if(ct && ct->flags & APC_EXTENSIBLE) {
 605                 int inext = per_get_few_bits(pd, 1);
 606                 if(inext < 0) ASN__DECODE_STARVED;
 607                 if(inext) ct = 0;
 608         }
 609
 610         FREEMEM(st->buf);
 611         st->buf = 0;
 612         st->size = 0;
 613         if(ct) {
 614                 if(ct->flags & APC_SEMI_CONSTRAINED) {
 615                         st->buf = (uint8_t *)CALLOC(1, 2);
 616                         if(!st->buf) ASN__DECODE_FAILED;
 617                         st->size = 1;
 618                 } else if(ct->flags & APC_CONSTRAINED && ct->range_bits >= 0) {
 619                         size_t size = (ct->range_bits + 7) >> 3;
 620                         st->buf = (uint8_t *)MALLOC(1 + size + 1);
 621                         if(!st->buf) ASN__DECODE_FAILED;
 622                         st->size = size;
 623                 }
 624         }
 625
 626         /* X.691-2008/11, #13.2.2, constrained whole number */
 627         if(ct && ct->flags != APC_UNCONSTRAINED) {
 628                 /* #11.5.6 */
 629                 ASN_DEBUG("Integer with range %d bits", ct->range_bits);
 630                 if(ct->range_bits >= 0) {
 631                         if((size_t)ct->range_bits > 8 * sizeof(unsigned long))
 632                                 ASN__DECODE_FAILED;
 633
 634                         if(specs && specs->field_unsigned) {
 635                                 unsigned long uvalue = 0;
 636                                 if(uper_get_constrained_whole_number(pd,
 637                                         &uvalue, ct->range_bits))
 638                                         ASN__DECODE_STARVED;
 639                                 ASN_DEBUG("Got value %lu + low %ld",
 640                                         uvalue, ct->lower_bound);
 641                                 uvalue += ct->lower_bound;
 642                                 if(asn_ulong2INTEGER(st, uvalue))
 643                                         ASN__DECODE_FAILED;
 644                         } else {
 645                                 unsigned long uvalue = 0;
 646                                 long svalue;
 647                                 if(uper_get_constrained_whole_number(pd,
 648                                         &uvalue, ct->range_bits))
 649                                         ASN__DECODE_STARVED;
 650                                 ASN_DEBUG("Got value %lu + low %ld",
 651                                         uvalue, ct->lower_bound);
 652                 if(per_long_range_unrebase(uvalue, ct->lower_bound,
 653                                            ct->upper_bound, &svalue)
 654                    || asn_long2INTEGER(st, svalue)) {
 655                     ASN__DECODE_FAILED;
 656                 }
 657                         }
 658                         return rval;
 659                 }
 660         } else {
 661                 ASN_DEBUG("Decoding unconstrained integer %s", td->name);
 662         }
 663
 664         /* X.691, #12.2.3, #12.2.4 */
 665         do {
 666                 ssize_t len = 0;
 667                 void *p = NULL;
 668                 int ret = 0;
 669
 670                 /* Get the PER length */
 671                 len = uper_get_length(pd, -1, 0, &repeat);
 672                 if(len < 0) ASN__DECODE_STARVED;
 673
 674                 p = REALLOC(st->buf, st->size + len + 1);
 675                 if(!p) ASN__DECODE_FAILED;
 676                 st->buf = (uint8_t *)p;
 677
 678                 ret = per_get_many_bits(pd, &st->buf[st->size], 0, 8 * len);
 679                 if(ret < 0) ASN__DECODE_STARVED;
 680                 st->size += len;
 681         } while(repeat);
 682         st->buf[st->size] = 0;  /* JIC */
 683
 684         /* #12.2.3 */
 685         if(ct && ct->lower_bound) {
 686                 /*
 687                  * TODO: replace by in-place arithmetics.
 688                  */
 689                 long value = 0;
 690                 if(asn_INTEGER2long(st, &value))
 691                         ASN__DECODE_FAILED;
 692                 if(asn_imax2INTEGER(st, value + ct->lower_bound))
 693                         ASN__DECODE_FAILED;
 694         }
 695
 696         return rval;
 697 }
 698
 699 asn_enc_rval_t
 700 INTEGER_encode_uper(const asn_TYPE_descriptor_t *td,
 701                     const asn_per_constraints_t *constraints, const void *sptr,
 702                     asn_per_outp_t *po) {
 703     const asn_INTEGER_specifics_t *specs =
 704         (const asn_INTEGER_specifics_t *)td->specifics;
 705     asn_enc_rval_t er;
 706         const INTEGER_t *st = (const INTEGER_t *)sptr;
 707         const uint8_t *buf;
 708         const uint8_t *end;
 709         const asn_per_constraint_t *ct;
 710         long value = 0;
 711
 712         if(!st || st->size == 0) ASN__ENCODE_FAILED;
 713
 714         if(!constraints) constraints = td->encoding_constraints.per_constraints;
 715         ct = constraints ? &constraints->value : 0;
 716
 717         er.encoded = 0;
 718
 719         if(ct) {
 720                 int inext = 0;
 721                 if(specs && specs->field_unsigned) {
 722                         unsigned long uval;
 723                         if(asn_INTEGER2ulong(st, &uval))
 724                                 ASN__ENCODE_FAILED;
 725                         /* Check proper range */
 726                         if(ct->flags & APC_SEMI_CONSTRAINED) {
 727                                 if(uval < (unsigned long)ct->lower_bound)
 728                                         inext = 1;
 729                         } else if(ct->range_bits >= 0) {
 730                                 if(uval < (unsigned long)ct->lower_bound
 731                                 || uval > (unsigned long)ct->upper_bound)
 732                                         inext = 1;
 733                         }
 734                         ASN_DEBUG("Value %lu (%02x/%" ASN_PRI_SIZE ") lb %lu ub %lu %s",
 735                                 uval, st->buf[0], st->size,
 736                                 ct->lower_bound, ct->upper_bound,
 737                                 inext ? "ext" : "fix");
 738                         value = uval;
 739                 } else {
 740                         if(asn_INTEGER2long(st, &value))
 741                                 ASN__ENCODE_FAILED;
 742                         /* Check proper range */
 743                         if(ct->flags & APC_SEMI_CONSTRAINED) {
 744                                 if(value < ct->lower_bound)
 745                                         inext = 1;
 746                         } else if(ct->range_bits >= 0) {
 747                                 if(value < ct->lower_bound
 748                                 || value > ct->upper_bound)
 749                                         inext = 1;
 750                         }
 751                         ASN_DEBUG("Value %ld (%02x/%" ASN_PRI_SIZE ") lb %ld ub %ld %s",
 752                                 value, st->buf[0], st->size,
 753                                 ct->lower_bound, ct->upper_bound,
 754                                 inext ? "ext" : "fix");
 755                 }
 756                 if(ct->flags & APC_EXTENSIBLE) {
 757                         if(per_put_few_bits(po, inext, 1))
 758                                 ASN__ENCODE_FAILED;
 759                         if(inext) ct = 0;
 760                 } else if(inext) {
 761                         ASN__ENCODE_FAILED;
 762                 }
 763         }
 764
 765
 766         /* X.691-11/2008, #13.2.2, test if constrained whole number */
 767         if(ct && ct->range_bits >= 0) {
 768         unsigned long v;
 769                 /* #11.5.6 -> #11.3 */
 770                 ASN_DEBUG("Encoding integer %ld (%lu) with range %d bits",
 771                         value, value - ct->lower_bound, ct->range_bits);
 772         if(per_long_range_rebase(value, ct->lower_bound, ct->upper_bound, &v)) {
 773             ASN__ENCODE_FAILED;
 774         }
 775         if(uper_put_constrained_whole_number_u(po, v, ct->range_bits))
 776             ASN__ENCODE_FAILED;
 777                 ASN__ENCODED_OK(er);
 778         }
 779
 780         if(ct && ct->lower_bound) {
 781                 ASN_DEBUG("Adjust lower bound to %ld", ct->lower_bound);
 782                 /* TODO: adjust lower bound */
 783                 ASN__ENCODE_FAILED;
 784         }
 785
 786         for(buf = st->buf, end = st->buf + st->size; buf < end;) {
 787         int need_eom = 0;
 788         ssize_t mayEncode = uper_put_length(po, end - buf, &need_eom);
 789         if(mayEncode < 0)
 790                         ASN__ENCODE_FAILED;
 791                 if(per_put_many_bits(po, buf, 8 * mayEncode))
 792                         ASN__ENCODE_FAILED;
 793                 buf += mayEncode;
 794         if(need_eom && uper_put_length(po, 0, 0)) ASN__ENCODE_FAILED;
 795     }
 796
 797         ASN__ENCODED_OK(er);
 798 }
 799
 800 #endif  /* ASN_DISABLE_PER_SUPPORT */
 801
 802 static intmax_t
 803 asn__integer_convert(const uint8_t *b, const uint8_t *end) {
 804     uintmax_t value;
 805
 806     /* Perform the sign initialization */
 807     /* Actually value = -(*b >> 7); gains nothing, yet unreadable! */
 808     if((*b >> 7)) {
 809         value = (uintmax_t)(-1);
 810     } else {
 811         value = 0;
 812     }
 813
 814     /* Conversion engine */
 815     for(; b < end; b++) {
 816         value = (value << 8) | *b;
 817     }
 818
 819     return value;
 820 }
 821
 822 int
 823 asn_INTEGER2imax(const INTEGER_t *iptr, intmax_t *lptr) {
 824         uint8_t *b, *end;
 825         size_t size;
 826
 827         /* Sanity checking */
 828         if(!iptr || !iptr->buf || !lptr) {
 829                 errno = EINVAL;
 830                 return -1;
 831         }
 832
 833         /* Cache the begin/end of the buffer */
 834         b = iptr->buf;  /* Start of the INTEGER buffer */
 835         size = iptr->size;
 836         end = b + size; /* Where to stop */
 837
 838         if(size > sizeof(intmax_t)) {
 839                 uint8_t *end1 = end - 1;
 840                 /*
 841                  * Slightly more advanced processing,
 842                  * able to process INTEGERs with >sizeof(intmax_t) bytes
 843                  * when the actual value is small, e.g. for intmax_t == int32_t
 844                  * (0x0000000000abcdef INTEGER would yield a fine 0x00abcdef int32_t)
 845                  */
 846                 /* Skip out the insignificant leading bytes */
 847                 for(; b < end1; b++) {
 848                         switch(*b) {
 849                                 case 0x00: if((b[1] & 0x80) == 0) continue; break;
 850                                 case 0xff: if((b[1] & 0x80) != 0) continue; break;
 851                         }
 852                         break;
 853                 }
 854
 855                 size = end - b;
 856                 if(size > sizeof(intmax_t)) {
 857                         /* Still cannot fit the sizeof(intmax_t) */
 858                         errno = ERANGE;
 859                         return -1;
 860                 }
 861         }
 862
 863         /* Shortcut processing of a corner case */
 864         if(end == b) {
 865                 *lptr = 0;
 866                 return 0;
 867         }
 868
 869         *lptr = asn__integer_convert(b, end);
 870         return 0;
 871 }
 872
 873 /* FIXME: negative INTEGER values are silently interpreted as large unsigned ones. */
 874 int
 875 asn_INTEGER2umax(const INTEGER_t *iptr, uintmax_t *lptr) {
 876         uint8_t *b, *end;
 877         uintmax_t value;
 878         size_t size;
 879
 880         if(!iptr || !iptr->buf || !lptr) {
 881                 errno = EINVAL;
 882                 return -1;
 883         }
 884
 885         b = iptr->buf;
 886         size = iptr->size;
 887         end = b + size;
 888
 889         /* If all extra leading bytes are zeroes, ignore them */
 890         for(; size > sizeof(value); b++, size--) {
 891                 if(*b) {
 892                         /* Value won't fit into uintmax_t */
 893                         errno = ERANGE;
 894                         return -1;
 895                 }
 896         }
 897
 898         /* Conversion engine */
 899         for(value = 0; b < end; b++)
 900                 value = (value << 8) | *b;
 901
 902         *lptr = value;
 903         return 0;
 904 }
 905
 906 int
 907 asn_umax2INTEGER(INTEGER_t *st, uintmax_t value) {
 908     uint8_t *buf;
 909     uint8_t *end;
 910     uint8_t *b;
 911     int shr;
 912
 913     if(value <= ((~(uintmax_t)0) >> 1)) {
 914         return asn_imax2INTEGER(st, value);
 915     }
 916
 917     buf = (uint8_t *)MALLOC(1 + sizeof(value));
 918     if(!buf) return -1;
 919
 920     end = buf + (sizeof(value) + 1);
 921     buf[0] = 0; /* INTEGERs are signed. 0-byte indicates positive. */
 922     for(b = buf + 1, shr = (sizeof(value) - 1) * 8; b < end; shr -= 8, b++)
 923         *b = (uint8_t)(value >> shr);
 924
 925     if(st->buf) FREEMEM(st->buf);
 926     st->buf = buf;
 927     st->size = 1 + sizeof(value);
 928
 929         return 0;
 930 }
 931
 932 int
 933 asn_imax2INTEGER(INTEGER_t *st, intmax_t value) {
 934         uint8_t *buf, *bp;
 935         uint8_t *p;
 936         uint8_t *pstart;
 937         uint8_t *pend1;
 938         int littleEndian = 1;   /* Run-time detection */
 939         int add;
 940
 941         if(!st) {
 942                 errno = EINVAL;
 943                 return -1;
 944         }
 945
 946         buf = (uint8_t *)(long *)MALLOC(sizeof(value));
 947         if(!buf) return -1;
 948
 949         if(*(char *)&littleEndian) {
 950                 pstart = (uint8_t *)&value + sizeof(value) - 1;
 951                 pend1 = (uint8_t *)&value;
 952                 add = -1;
 953         } else {
 954                 pstart = (uint8_t *)&value;
 955                 pend1 = pstart + sizeof(value) - 1;
 956                 add = 1;
 957         }
 958
 959         /*
 960          * If the contents octet consists of more than one octet,
 961          * then bits of the first octet and bit 8 of the second octet:
 962          * a) shall not all be ones; and
 963          * b) shall not all be zero.
 964          */
 965         for(p = pstart; p != pend1; p += add) {
 966                 switch(*p) {
 967                 case 0x00: if((*(p+add) & 0x80) == 0)
 968                                 continue;
 969                         break;
 970                 case 0xff: if((*(p+add) & 0x80))
 971                                 continue;
 972                         break;
 973                 }
 974                 break;
 975         }
 976         /* Copy the integer body */
 977         for(bp = buf, pend1 += add; p != pend1; p += add)
 978                 *bp++ = *p;
 979
 980         if(st->buf) FREEMEM(st->buf);
 981         st->buf = buf;
 982         st->size = bp - buf;
 983
 984         return 0;
 985 }
 986
 987 int
 988 asn_INTEGER2long(const INTEGER_t *iptr, long *l) {
 989     intmax_t v;
 990     if(asn_INTEGER2imax(iptr, &v) == 0) {
 991         if(v < LONG_MIN || v > LONG_MAX) {
 992             errno = ERANGE;
 993             return -1;
 994         }
 995         *l = v;
 996         return 0;
 997     } else {
 998         return -1;
 999     }
1000 }
1001
1002 int
1003 asn_INTEGER2ulong(const INTEGER_t *iptr, unsigned long *l) {
1004     uintmax_t v;
1005     if(asn_INTEGER2umax(iptr, &v) == 0) {
1006         if(v > ULONG_MAX) {
1007             errno = ERANGE;
1008             return -1;
1009         }
1010         *l = v;
1011         return 0;
1012     } else {
1013         return -1;
1014     }
1015 }
1016
1017 int
1018 asn_long2INTEGER(INTEGER_t *st, long value) {
1019     return asn_imax2INTEGER(st, value);
1020 }
1021
1022 int
1023 asn_ulong2INTEGER(INTEGER_t *st, unsigned long value) {
1024     return asn_imax2INTEGER(st, value);
1025 }
1026
1027 /*
1028  * Parse the number in the given string until the given *end position,
1029  * returning the position after the last parsed character back using the
1030  * same (*end) pointer.
1031  * WARNING: This behavior is different from the standard strtol/strtoimax(3).
1032  */
1033 enum asn_strtox_result_e
1034 asn_strtoimax_lim(const char *str, const char **end, intmax_t *intp) {
1035     int sign = 1;
1036     intmax_t value;
1037
1038     const intmax_t asn1_intmax_max = ((~(uintmax_t)0) >> 1);
1039     const intmax_t upper_boundary = asn1_intmax_max / 10;
1040     intmax_t last_digit_max = asn1_intmax_max % 10;
1041
1042     if(str >= *end) return ASN_STRTOX_ERROR_INVAL;
1043
1044     switch(*str) {
1045     case '-':
1046         last_digit_max++;
1047         sign = -1;
1048         /* FALL THROUGH */
1049     case '+':
1050         str++;
1051         if(str >= *end) {
1052             *end = str;
1053             return ASN_STRTOX_EXPECT_MORE;
1054         }
1055     }
1056
1057     for(value = 0; str < (*end); str++) {
1058         if(*str >= 0x30 && *str <= 0x39) {
1059             int d = *str - '0';
1060             if(value < upper_boundary) {
1061                 value = value * 10 + d;
1062             } else if(value == upper_boundary) {
1063                 if(d <= last_digit_max) {
1064                     if(sign > 0) {
1065                         value = value * 10 + d;
1066                     } else {
1067                         sign = 1;
1068                         value = -value * 10 - d;
1069                     }
1070                     str += 1;
1071                     if(str < *end) {
1072                         // If digits continue, we're guaranteed out of range.
1073                         *end = str;
1074                         if(*str >= 0x30 && *str <= 0x39) {
1075                             return ASN_STRTOX_ERROR_RANGE;
1076                         } else {
1077                             *intp = sign * value;
1078                             return ASN_STRTOX_EXTRA_DATA;
1079                         }
1080                     }
1081                     break;
1082                 } else {
1083                     *end = str;
1084                     return ASN_STRTOX_ERROR_RANGE;
1085                 }
1086             } else {
1087                 *end = str;
1088                 return ASN_STRTOX_ERROR_RANGE;
1089             }
1090         } else {
1091             *end = str;
1092             *intp = sign * value;
1093             return ASN_STRTOX_EXTRA_DATA;
1094         }
1095     }
1096
1097     *end = str;
1098     *intp = sign * value;
1099     return ASN_STRTOX_OK;
1100 }
1101
1102 /*
1103  * Parse the number in the given string until the given *end position,
1104  * returning the position after the last parsed character back using the
1105  * same (*end) pointer.
1106  * WARNING: This behavior is different from the standard strtoul/strtoumax(3).
1107  */
1108 enum asn_strtox_result_e
1109 asn_strtoumax_lim(const char *str, const char **end, uintmax_t *uintp) {
1110     uintmax_t value;
1111
1112     const uintmax_t asn1_uintmax_max = ((~(uintmax_t)0));
1113     const uintmax_t upper_boundary = asn1_uintmax_max / 10;
1114     uintmax_t last_digit_max = asn1_uintmax_max % 10;
1115
1116     if(str >= *end) return ASN_STRTOX_ERROR_INVAL;
1117
1118     switch(*str) {
1119     case '-':
1120         return ASN_STRTOX_ERROR_INVAL;
1121     case '+':
1122         str++;
1123         if(str >= *end) {
1124             *end = str;
1125             return ASN_STRTOX_EXPECT_MORE;
1126         }
1127     }
1128
1129     for(value = 0; str < (*end); str++) {
1130         if(*str >= 0x30 && *str <= 0x39) {
1131             unsigned int d = *str - '0';
1132             if(value < upper_boundary) {
1133                 value = value * 10 + d;
1134             } else if(value == upper_boundary) {
1135                 if(d <= last_digit_max) {
1136                     value = value * 10 + d;
1137                     str += 1;
1138                     if(str < *end) {
1139                         // If digits continue, we're guaranteed out of range.
1140                         *end = str;
1141                         if(*str >= 0x30 && *str <= 0x39) {
1142                             return ASN_STRTOX_ERROR_RANGE;
1143                         } else {
1144                             *uintp = value;
1145                             return ASN_STRTOX_EXTRA_DATA;
1146                         }
1147                     }
1148                     break;
1149                 } else {
1150                     *end = str;
1151                     return ASN_STRTOX_ERROR_RANGE;
1152                 }
1153             } else {
1154                 *end = str;
1155                 return ASN_STRTOX_ERROR_RANGE;
1156             }
1157         } else {
1158             *end = str;
1159             *uintp = value;
1160             return ASN_STRTOX_EXTRA_DATA;
1161         }
1162     }
1163
1164     *end = str;
1165     *uintp = value;
1166     return ASN_STRTOX_OK;
1167 }
1168
1169 enum asn_strtox_result_e
1170 asn_strtol_lim(const char *str, const char **end, long *lp) {
1171     intmax_t value;
1172     switch(asn_strtoimax_lim(str, end, &value)) {
1173     case ASN_STRTOX_ERROR_RANGE:
1174         return ASN_STRTOX_ERROR_RANGE;
1175     case ASN_STRTOX_ERROR_INVAL:
1176         return ASN_STRTOX_ERROR_INVAL;
1177     case ASN_STRTOX_EXPECT_MORE:
1178         return ASN_STRTOX_EXPECT_MORE;
1179     case ASN_STRTOX_OK:
1180         if(value >= LONG_MIN && value <= LONG_MAX) {
1181             *lp = value;
1182             return ASN_STRTOX_OK;
1183         } else {
1184             return ASN_STRTOX_ERROR_RANGE;
1185         }
1186     case ASN_STRTOX_EXTRA_DATA:
1187         if(value >= LONG_MIN && value <= LONG_MAX) {
1188             *lp = value;
1189             return ASN_STRTOX_EXTRA_DATA;
1190         } else {
1191             return ASN_STRTOX_ERROR_RANGE;
1192         }
1193     }
1194
1195     assert(!"Unreachable");
1196     return ASN_STRTOX_ERROR_INVAL;
1197 }
1198
1199 enum asn_strtox_result_e
1200 asn_strtoul_lim(const char *str, const char **end, unsigned long *ulp) {
1201     uintmax_t value;
1202     switch(asn_strtoumax_lim(str, end, &value)) {
1203     case ASN_STRTOX_ERROR_RANGE:
1204         return ASN_STRTOX_ERROR_RANGE;
1205     case ASN_STRTOX_ERROR_INVAL:
1206         return ASN_STRTOX_ERROR_INVAL;
1207     case ASN_STRTOX_EXPECT_MORE:
1208         return ASN_STRTOX_EXPECT_MORE;
1209     case ASN_STRTOX_OK:
1210         if(value <= ULONG_MAX) {
1211             *ulp = value;
1212             return ASN_STRTOX_OK;
1213         } else {
1214             return ASN_STRTOX_ERROR_RANGE;
1215         }
1216     case ASN_STRTOX_EXTRA_DATA:
1217         if(value <= ULONG_MAX) {
1218             *ulp = value;
1219             return ASN_STRTOX_EXTRA_DATA;
1220         } else {
1221             return ASN_STRTOX_ERROR_RANGE;
1222         }
1223     }
1224
1225     assert(!"Unreachable");
1226     return ASN_STRTOX_ERROR_INVAL;
1227 }
1228
1229 int
1230 INTEGER_compare(const asn_TYPE_descriptor_t *td, const void *aptr,
1231                      const void *bptr) {
1232     const INTEGER_t *a = aptr;
1233     const INTEGER_t *b = bptr;
1234
1235     (void)td;
1236
1237     if(a && b) {
1238         if(a->size && b->size) {
1239             int sign_a = (a->buf[0] & 0x80) ? -1 : 1;
1240             int sign_b = (b->buf[0] & 0x80) ? -1 : 1;
1241
1242             if(sign_a < sign_b) return -1;
1243             if(sign_a > sign_b) return 1;
1244
1245             /* The shortest integer wins, unless comparing negatives */
1246             if(a->size < b->size) {
1247                 return -1 * sign_a;
1248             } else if(a->size > b->size) {
1249                 return 1 * sign_b;
1250             }
1251
1252             return sign_a * memcmp(a->buf, b->buf, a->size);
1253         } else if(a->size) {
1254             int sign = (a->buf[0] & 0x80) ? -1 : 1;
1255             return (1) * sign;
1256         } else if(b->size) {
1257             int sign = (a->buf[0] & 0x80) ? -1 : 1;
1258             return (-1) * sign;
1259         } else {
1260             return 0;
1261         }
1262     } else if(!a && !b) {
1263         return 0;
1264     } else if(!a) {
1265         return -1;
1266     } else {
1267         return 1;
1268     }
1269
1270 }
1271
1272 asn_random_fill_result_t
1273 INTEGER_random_fill(const asn_TYPE_descriptor_t *td, void **sptr,
1274                     const asn_encoding_constraints_t *constraints,
1275                     size_t max_length) {
1276     const asn_INTEGER_specifics_t *specs =
1277         (const asn_INTEGER_specifics_t *)td->specifics;
1278     asn_random_fill_result_t result_ok = {ARFILL_OK, 1};
1279     asn_random_fill_result_t result_failed = {ARFILL_FAILED, 0};
1280     asn_random_fill_result_t result_skipped = {ARFILL_SKIPPED, 0};
1281     INTEGER_t *st = *sptr;
1282     const asn_INTEGER_enum_map_t *emap;
1283     size_t emap_len;
1284     intmax_t value;
1285     int find_inside_map;
1286
1287     if(max_length == 0) return result_skipped;
1288
1289     if(st == NULL) {
1290         st = (INTEGER_t *)CALLOC(1, sizeof(*st));
1291         if(st == NULL) {
1292             return result_failed;
1293         }
1294     }
1295
1296     if(specs) {
1297         emap = specs->value2enum;
1298         emap_len = specs->map_count;
1299         if(specs->strict_enumeration) {
1300             find_inside_map = emap_len > 0;
1301         } else {
1302             find_inside_map = emap_len ? asn_random_between(0, 1) : 0;
1303         }
1304     } else {
1305         emap = 0;
1306         emap_len = 0;
1307         find_inside_map = 0;
1308     }
1309
1310     if(find_inside_map) {
1311         assert(emap_len > 0);
1312         value = emap[asn_random_between(0, emap_len - 1)].nat_value;
1313     } else {
1314         const asn_per_constraints_t *ct;
1315
1316         static const long variants[] = {
1317             -65536, -65535, -65534, -32769, -32768, -32767, -16385, -16384,
1318             -16383, -257,   -256,   -255,   -254,   -129,   -128,   -127,
1319             -126,   -1,     0,      1,      126,    127,    128,    129,
1320             254,    255,    256,    257,    16383,  16384,  16385,  32767,
1321             32768,  32769,  65534,  65535,  65536,  65537};
1322         if(specs && specs->field_unsigned) {
1323             assert(variants[18] == 0);
1324             value = variants[asn_random_between(
1325                 18, sizeof(variants) / sizeof(variants[0]) - 1)];
1326         } else {
1327             value = variants[asn_random_between(
1328                 0, sizeof(variants) / sizeof(variants[0]) - 1)];
1329         }
1330
1331         if(!constraints) constraints = &td->encoding_constraints;
1332         ct = constraints ? constraints->per_constraints : 0;
1333         if(ct && (ct->value.flags & APC_CONSTRAINED)) {
1334             if(value < ct->value.lower_bound || value > ct->value.upper_bound) {
1335                 value = asn_random_between(ct->value.lower_bound,
1336                                            ct->value.upper_bound);
1337             }
1338         }
1339     }
1340
1341     if(asn_imax2INTEGER(st, value)) {
1342         if(st == *sptr) {
1343             ASN_STRUCT_RESET(*td, st);
1344         } else {
1345             ASN_STRUCT_FREE(*td, st);
1346         }
1347         return result_failed;
1348     } else {
1349         *sptr = st;
1350         result_ok.length = st->size;
1351         return result_ok;
1352     }
1353 }