libs/smux/INTEGER.c

   1 /*-
   2  * Copyright (c) 2003-2014 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_descriptor_t asn_DEF_INTEGER = {
  18         "INTEGER",
  19         "INTEGER",
  20         ASN__PRIMITIVE_TYPE_free,
  21         INTEGER_print,
  22         asn_generic_no_constraint,
  23         ber_decode_primitive,
  24         INTEGER_encode_der,
  25         INTEGER_decode_xer,
  26         INTEGER_encode_xer,
  27 #ifdef  ASN_DISABLE_PER_SUPPORT
  28         0,
  29         0,
  30 #else
  31         INTEGER_decode_uper,    /* Unaligned PER decoder */
  32         INTEGER_encode_uper,    /* Unaligned PER encoder */
  33 #endif  /* ASN_DISABLE_PER_SUPPORT */
  34         0, /* Use generic outmost tag fetcher */
  35         asn_DEF_INTEGER_tags,
  36         sizeof(asn_DEF_INTEGER_tags) / sizeof(asn_DEF_INTEGER_tags[0]),
  37         asn_DEF_INTEGER_tags,   /* Same as above */
  38         sizeof(asn_DEF_INTEGER_tags) / sizeof(asn_DEF_INTEGER_tags[0]),
  39         0,      /* No PER visible constraints */
  40         0, 0,   /* No members */
  41         0       /* No specifics */
  42 };
  43
  44 /*
  45  * Encode INTEGER type using DER.
  46  */
  47 asn_enc_rval_t
  48 INTEGER_encode_der(asn_TYPE_descriptor_t *td, void *sptr,
  49         int tag_mode, ber_tlv_tag_t tag,
  50         asn_app_consume_bytes_f *cb, void *app_key) {
  51         INTEGER_t *st = (INTEGER_t *)sptr;
  52
  53         ASN_DEBUG("%s %s as INTEGER (tm=%d)",
  54                 cb?"Encoding":"Estimating", td->name, tag_mode);
  55
  56         /*
  57          * Canonicalize integer in the buffer.
  58          * (Remove too long sign extension, remove some first 0x00 bytes)
  59          */
  60         if(st->buf) {
  61                 uint8_t *buf = st->buf;
  62                 uint8_t *end1 = buf + st->size - 1;
  63                 int shift;
  64
  65                 /* Compute the number of superfluous leading bytes */
  66                 for(; buf < end1; buf++) {
  67                         /*
  68                          * If the contents octets of an integer value encoding
  69                          * consist of more than one octet, then the bits of the
  70                          * first octet and bit 8 of the second octet:
  71                          * a) shall not all be ones; and
  72                          * b) shall not all be zero.
  73                          */
  74                         switch(*buf) {
  75                         case 0x00: if((buf[1] & 0x80) == 0)
  76                                         continue;
  77                                 break;
  78                         case 0xff: if((buf[1] & 0x80))
  79                                         continue;
  80                                 break;
  81                         }
  82                         break;
  83                 }
  84
  85                 /* Remove leading superfluous bytes from the integer */
  86                 shift = buf - st->buf;
  87                 if(shift) {
  88                         uint8_t *nb = st->buf;
  89                         uint8_t *end;
  90
  91                         st->size -= shift;      /* New size, minus bad bytes */
  92                         end = nb + st->size;
  93
  94                         for(; nb < end; nb++, buf++)
  95                                 *nb = *buf;
  96                 }
  97
  98         } /* if(1) */
  99
 100         return der_encode_primitive(td, sptr, tag_mode, tag, cb, app_key);
 101 }
 102
 103 static const asn_INTEGER_enum_map_t *INTEGER_map_enum2value(asn_INTEGER_specifics_t *specs, const char *lstart, const char *lstop);
 104
 105 /*
 106  * INTEGER specific human-readable output.
 107  */
 108 static ssize_t
 109 INTEGER__dump(const asn_TYPE_descriptor_t *td, const INTEGER_t *st, asn_app_consume_bytes_f *cb, void *app_key, int plainOrXER) {
 110         asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics;
 111         char scratch[32];       /* Enough for 64-bit integer */
 112         uint8_t *buf = st->buf;
 113         uint8_t *buf_end = st->buf + st->size;
 114         signed long value;
 115         ssize_t wrote = 0;
 116         char *p;
 117         int ret;
 118
 119         if(specs && specs->field_unsigned)
 120                 ret = asn_INTEGER2ulong(st, (unsigned long *)&value);
 121         else
 122                 ret = asn_INTEGER2long(st, &value);
 123
 124         /* Simple case: the integer size is small */
 125         if(ret == 0) {
 126                 const asn_INTEGER_enum_map_t *el;
 127                 size_t scrsize;
 128                 char *scr;
 129
 130                 el = (value >= 0 || !specs || !specs->field_unsigned)
 131                         ? INTEGER_map_value2enum(specs, value) : 0;
 132                 if(el) {
 133                         scrsize = el->enum_len + 32;
 134                         scr = (char *)alloca(scrsize);
 135                         if(plainOrXER == 0)
 136                                 ret = snprintf(scr, scrsize,
 137                                         "%ld (%s)", value, el->enum_name);
 138                         else
 139                                 ret = snprintf(scr, scrsize,
 140                                         "<%s/>", el->enum_name);
 141                 } else if(plainOrXER && specs && specs->strict_enumeration) {
 142                         ASN_DEBUG("ASN.1 forbids dealing with "
 143                                 "unknown value of ENUMERATED type");
 144                         errno = EPERM;
 145                         return -1;
 146                 } else {
 147                         scrsize = sizeof(scratch);
 148                         scr = scratch;
 149                         ret = snprintf(scr, scrsize,
 150                                 (specs && specs->field_unsigned)
 151                                 ?"%lu":"%ld", value);
 152                 }
 153                 assert(ret > 0 && (size_t)ret < scrsize);
 154                 return (cb(scr, ret, app_key) < 0) ? -1 : ret;
 155         } else if(plainOrXER && specs && specs->strict_enumeration) {
 156                 /*
 157                  * Here and earlier, we cannot encode the ENUMERATED values
 158                  * if there is no corresponding identifier.
 159                  */
 160                 ASN_DEBUG("ASN.1 forbids dealing with "
 161                         "unknown value of ENUMERATED type");
 162                 errno = EPERM;
 163                 return -1;
 164         }
 165
 166         /* Output in the long xx:yy:zz... format */
 167         /* TODO: replace with generic algorithm (Knuth TAOCP Vol 2, 4.3.1) */
 168         for(p = scratch; buf < buf_end; buf++) {
 169                 const char * const h2c = "0123456789ABCDEF";
 170                 if((p - scratch) >= (ssize_t)(sizeof(scratch) - 4)) {
 171                         /* Flush buffer */
 172                         if(cb(scratch, p - scratch, app_key) < 0)
 173                                 return -1;
 174                         wrote += p - scratch;
 175                         p = scratch;
 176                 }
 177                 *p++ = h2c[*buf >> 4];
 178                 *p++ = h2c[*buf & 0x0F];
 179                 *p++ = 0x3a;    /* ":" */
 180         }
 181         if(p != scratch)
 182                 p--;    /* Remove the last ":" */
 183
 184         wrote += p - scratch;
 185         return (cb(scratch, p - scratch, app_key) < 0) ? -1 : wrote;
 186 }
 187
 188 /*
 189  * INTEGER specific human-readable output.
 190  */
 191 int
 192 INTEGER_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
 193         asn_app_consume_bytes_f *cb, void *app_key) {
 194         const INTEGER_t *st = (const INTEGER_t *)sptr;
 195         ssize_t ret;
 196
 197         (void)td;
 198         (void)ilevel;
 199
 200         if(!st || !st->buf)
 201                 ret = cb("<absent>", 8, app_key);
 202         else
 203                 ret = INTEGER__dump(td, st, cb, app_key, 0);
 204
 205         return (ret < 0) ? -1 : 0;
 206 }
 207
 208 struct e2v_key {
 209         const char *start;
 210         const char *stop;
 211         const asn_INTEGER_enum_map_t *vemap;
 212         const unsigned int *evmap;
 213 };
 214 static int
 215 INTEGER__compar_enum2value(const void *kp, const void *am) {
 216         const struct e2v_key *key = (const struct e2v_key *)kp;
 217         const asn_INTEGER_enum_map_t *el = (const asn_INTEGER_enum_map_t *)am;
 218         const char *ptr, *end, *name;
 219
 220         /* Remap the element (sort by different criterion) */
 221         el = key->vemap + key->evmap[el - key->vemap];
 222
 223         /* Compare strings */
 224         for(ptr = key->start, end = key->stop, name = el->enum_name;
 225                         ptr < end; ptr++, name++) {
 226                 if(*ptr != *name)
 227                         return *(const unsigned char *)ptr
 228                                 - *(const unsigned char *)name;
 229         }
 230         return name[0] ? -1 : 0;
 231 }
 232
 233 static const asn_INTEGER_enum_map_t *
 234 INTEGER_map_enum2value(asn_INTEGER_specifics_t *specs, const char *lstart, const char *lstop) {
 235         const asn_INTEGER_enum_map_t *el_found;
 236         int count = specs ? specs->map_count : 0;
 237         struct e2v_key key;
 238         const char *lp;
 239
 240         if(!count) return NULL;
 241
 242         /* Guaranteed: assert(lstart < lstop); */
 243         /* Figure out the tag name */
 244         for(lstart++, lp = lstart; lp < lstop; lp++) {
 245                 switch(*lp) {
 246                 case 9: case 10: case 11: case 12: case 13: case 32: /* WSP */
 247                 case 0x2f: /* '/' */ case 0x3e: /* '>' */
 248                         break;
 249                 default:
 250                         continue;
 251                 }
 252                 break;
 253         }
 254         if(lp == lstop) return NULL;    /* No tag found */
 255         lstop = lp;
 256
 257         key.start = lstart;
 258         key.stop = lstop;
 259         key.vemap = specs->value2enum;
 260         key.evmap = specs->enum2value;
 261         el_found = (asn_INTEGER_enum_map_t *)bsearch(&key,
 262                 specs->value2enum, count, sizeof(specs->value2enum[0]),
 263                 INTEGER__compar_enum2value);
 264         if(el_found) {
 265                 /* Remap enum2value into value2enum */
 266                 el_found = key.vemap + key.evmap[el_found - key.vemap];
 267         }
 268         return el_found;
 269 }
 270
 271 static int
 272 INTEGER__compar_value2enum(const void *kp, const void *am) {
 273         long a = *(const long *)kp;
 274         const asn_INTEGER_enum_map_t *el = (const asn_INTEGER_enum_map_t *)am;
 275         long b = el->nat_value;
 276         if(a < b) return -1;
 277         else if(a == b) return 0;
 278         else return 1;
 279 }
 280
 281 const asn_INTEGER_enum_map_t *
 282 INTEGER_map_value2enum(asn_INTEGER_specifics_t *specs, long value) {
 283         int count = specs ? specs->map_count : 0;
 284         if(!count) return 0;
 285         return (asn_INTEGER_enum_map_t *)bsearch(&value, specs->value2enum,
 286                 count, sizeof(specs->value2enum[0]),
 287                 INTEGER__compar_value2enum);
 288 }
 289
 290 static int
 291 INTEGER_st_prealloc(INTEGER_t *st, int min_size) {
 292         void *p = MALLOC(min_size + 1);
 293         if(p) {
 294                 void *b = st->buf;
 295                 st->size = 0;
 296                 st->buf = p;
 297                 FREEMEM(b);
 298                 return 0;
 299         } else {
 300                 return -1;
 301         }
 302 }
 303
 304 /*
 305  * Decode the chunk of XML text encoding INTEGER.
 306  */
 307 static enum xer_pbd_rval
 308 INTEGER__xer_body_decode(asn_TYPE_descriptor_t *td, void *sptr, const void *chunk_buf, size_t chunk_size) {
 309         INTEGER_t *st = (INTEGER_t *)sptr;
 310         long dec_value;
 311         long hex_value = 0;
 312         const char *lp;
 313         const char *lstart = (const char *)chunk_buf;
 314         const char *lstop = lstart + chunk_size;
 315         enum {
 316                 ST_LEADSPACE,
 317                 ST_SKIPSPHEX,
 318                 ST_WAITDIGITS,
 319                 ST_DIGITS,
 320                 ST_DIGITS_TRAILSPACE,
 321                 ST_HEXDIGIT1,
 322                 ST_HEXDIGIT2,
 323                 ST_HEXDIGITS_TRAILSPACE,
 324                 ST_HEXCOLON,
 325                 ST_END_ENUM,
 326                 ST_UNEXPECTED
 327         } state = ST_LEADSPACE;
 328         const char *dec_value_start = 0; /* INVARIANT: always !0 in ST_DIGITS */
 329         const char *dec_value_end = 0;
 330
 331         if(chunk_size)
 332                 ASN_DEBUG("INTEGER body %ld 0x%2x..0x%2x",
 333                         (long)chunk_size, *lstart, lstop[-1]);
 334
 335         if(INTEGER_st_prealloc(st, (chunk_size/3) + 1))
 336                 return XPBD_SYSTEM_FAILURE;
 337
 338         /*
 339          * We may have received a tag here. It will be processed inline.
 340          * Use strtoul()-like code and serialize the result.
 341          */
 342         for(lp = lstart; lp < lstop; lp++) {
 343                 int lv = *lp;
 344                 switch(lv) {
 345                 case 0x09: case 0x0a: case 0x0d: case 0x20:
 346                         switch(state) {
 347                         case ST_LEADSPACE:
 348                         case ST_DIGITS_TRAILSPACE:
 349                         case ST_HEXDIGITS_TRAILSPACE:
 350                         case ST_SKIPSPHEX:
 351                                 continue;
 352                         case ST_DIGITS:
 353                                 dec_value_end = lp;
 354                                 state = ST_DIGITS_TRAILSPACE;
 355                                 continue;
 356                         case ST_HEXCOLON:
 357                                 state = ST_HEXDIGITS_TRAILSPACE;
 358                                 continue;
 359                         default:
 360                                 break;
 361                         }
 362                         break;
 363                 case 0x2d:      /* '-' */
 364                         if(state == ST_LEADSPACE) {
 365                                 dec_value = 0;
 366                                 dec_value_start = lp;
 367                                 state = ST_WAITDIGITS;
 368                                 continue;
 369                         }
 370                         break;
 371                 case 0x2b:      /* '+' */
 372                         if(state == ST_LEADSPACE) {
 373                                 dec_value = 0;
 374                                 dec_value_start = lp;
 375                                 state = ST_WAITDIGITS;
 376                                 continue;
 377                         }
 378                         break;
 379                 case 0x30: case 0x31: case 0x32: case 0x33: case 0x34:
 380                 case 0x35: case 0x36: case 0x37: case 0x38: case 0x39:
 381                         switch(state) {
 382                         case ST_DIGITS: continue;
 383                         case ST_SKIPSPHEX:      /* Fall through */
 384                         case ST_HEXDIGIT1:
 385                                 hex_value = (lv - 0x30) << 4;
 386                                 state = ST_HEXDIGIT2;
 387                                 continue;
 388                         case ST_HEXDIGIT2:
 389                                 hex_value += (lv - 0x30);
 390                                 state = ST_HEXCOLON;
 391                                 st->buf[st->size++] = (uint8_t)hex_value;
 392                                 continue;
 393                         case ST_HEXCOLON:
 394                                 return XPBD_BROKEN_ENCODING;
 395                         case ST_LEADSPACE:
 396                                 dec_value = 0;
 397                                 dec_value_start = lp;
 398                                 /* FALL THROUGH */
 399                         case ST_WAITDIGITS:
 400                                 state = ST_DIGITS;
 401                                 continue;
 402                         default:
 403                                 break;
 404                         }
 405                         break;
 406                 case 0x3c:      /* '<', start of XML encoded enumeration */
 407                         if(state == ST_LEADSPACE) {
 408                                 const asn_INTEGER_enum_map_t *el;
 409                                 el = INTEGER_map_enum2value(
 410                                         (asn_INTEGER_specifics_t *)
 411                                         td->specifics, lstart, lstop);
 412                                 if(el) {
 413                                         ASN_DEBUG("Found \"%s\" => %ld",
 414                                                 el->enum_name, el->nat_value);
 415                                         dec_value = el->nat_value;
 416                                         state = ST_END_ENUM;
 417                                         lp = lstop - 1;
 418                                         continue;
 419                                 }
 420                                 ASN_DEBUG("Unknown identifier for INTEGER");
 421                         }
 422                         return XPBD_BROKEN_ENCODING;
 423                 case 0x3a:      /* ':' */
 424                         if(state == ST_HEXCOLON) {
 425                                 /* This colon is expected */
 426                                 state = ST_HEXDIGIT1;
 427                                 continue;
 428                         } else if(state == ST_DIGITS) {
 429                                 /* The colon here means that we have
 430                                  * decoded the first two hexadecimal
 431                                  * places as a decimal value.
 432                                  * Switch decoding mode. */
 433                                 ASN_DEBUG("INTEGER re-evaluate as hex form");
 434                                 state = ST_SKIPSPHEX;
 435                                 dec_value_start = 0;
 436                                 lp = lstart - 1;
 437                                 continue;
 438                         } else {
 439                                 ASN_DEBUG("state %d at %ld", state, (long)(lp - lstart));
 440                                 break;
 441                         }
 442                 /* [A-Fa-f] */
 443                 case 0x41:case 0x42:case 0x43:case 0x44:case 0x45:case 0x46:
 444                 case 0x61:case 0x62:case 0x63:case 0x64:case 0x65:case 0x66:
 445                         switch(state) {
 446                         case ST_SKIPSPHEX:
 447                         case ST_LEADSPACE: /* Fall through */
 448                         case ST_HEXDIGIT1:
 449                                 hex_value = lv - ((lv < 0x61) ? 0x41 : 0x61);
 450                                 hex_value += 10;
 451                                 hex_value <<= 4;
 452                                 state = ST_HEXDIGIT2;
 453                                 continue;
 454                         case ST_HEXDIGIT2:
 455                                 hex_value += lv - ((lv < 0x61) ? 0x41 : 0x61);
 456                                 hex_value += 10;
 457                                 st->buf[st->size++] = (uint8_t)hex_value;
 458                                 state = ST_HEXCOLON;
 459                                 continue;
 460                         case ST_DIGITS:
 461                                 ASN_DEBUG("INTEGER re-evaluate as hex form");
 462                                 state = ST_SKIPSPHEX;
 463                                 dec_value_start = 0;
 464                                 lp = lstart - 1;
 465                                 continue;
 466                         default:
 467                                 break;
 468                         }
 469                         break;
 470                 }
 471
 472                 /* Found extra non-numeric stuff */
 473                 ASN_DEBUG("INTEGER :: Found non-numeric 0x%2x at %ld",
 474                         lv, (long)(lp - lstart));
 475                 state = ST_UNEXPECTED;
 476                 break;
 477         }
 478
 479         switch(state) {
 480         case ST_END_ENUM:
 481                 /* Got a complete and valid enumeration encoded as a tag. */
 482                 break;
 483         case ST_DIGITS:
 484                 dec_value_end = lstop;
 485                 /* FALL THROUGH */
 486         case ST_DIGITS_TRAILSPACE:
 487                 /* The last symbol encountered was a digit. */
 488                 switch(asn_strtol_lim(dec_value_start, &dec_value_end, &dec_value)) {
 489                 case ASN_STRTOL_OK:
 490                         break;
 491                 case ASN_STRTOL_ERROR_RANGE:
 492                         return XPBD_DECODER_LIMIT;
 493                 case ASN_STRTOL_ERROR_INVAL:
 494                 case ASN_STRTOL_EXPECT_MORE:
 495                 case ASN_STRTOL_EXTRA_DATA:
 496                         return XPBD_BROKEN_ENCODING;
 497                 }
 498                 break;
 499         case ST_HEXCOLON:
 500         case ST_HEXDIGITS_TRAILSPACE:
 501                 st->buf[st->size] = 0;  /* Just in case termination */
 502                 return XPBD_BODY_CONSUMED;
 503         case ST_HEXDIGIT1:
 504         case ST_HEXDIGIT2:
 505         case ST_SKIPSPHEX:
 506                 return XPBD_BROKEN_ENCODING;
 507         case ST_LEADSPACE:
 508                 /* Content not found */
 509                 return XPBD_NOT_BODY_IGNORE;
 510         case ST_WAITDIGITS:
 511         case ST_UNEXPECTED:
 512                 ASN_DEBUG("INTEGER: No useful digits (state %d)", state);
 513                 return XPBD_BROKEN_ENCODING;    /* No digits */
 514         }
 515
 516         /*
 517          * Convert the result of parsing of enumeration or a straight
 518          * decimal value into a BER representation.
 519          */
 520         if(asn_long2INTEGER(st, dec_value))
 521                 return XPBD_SYSTEM_FAILURE;
 522
 523         return XPBD_BODY_CONSUMED;
 524 }
 525
 526 asn_dec_rval_t
 527 INTEGER_decode_xer(asn_codec_ctx_t *opt_codec_ctx,
 528         asn_TYPE_descriptor_t *td, void **sptr, const char *opt_mname,
 529                 const void *buf_ptr, size_t size) {
 530
 531         return xer_decode_primitive(opt_codec_ctx, td,
 532                 sptr, sizeof(INTEGER_t), opt_mname,
 533                 buf_ptr, size, INTEGER__xer_body_decode);
 534 }
 535
 536 asn_enc_rval_t
 537 INTEGER_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
 538         int ilevel, enum xer_encoder_flags_e flags,
 539                 asn_app_consume_bytes_f *cb, void *app_key) {
 540         const INTEGER_t *st = (const INTEGER_t *)sptr;
 541         asn_enc_rval_t er;
 542
 543         (void)ilevel;
 544         (void)flags;
 545
 546         if(!st || !st->buf)
 547                 ASN__ENCODE_FAILED;
 548
 549         er.encoded = INTEGER__dump(td, st, cb, app_key, 1);
 550         if(er.encoded < 0) ASN__ENCODE_FAILED;
 551
 552         ASN__ENCODED_OK(er);
 553 }
 554
 555 #ifndef ASN_DISABLE_PER_SUPPORT
 556
 557 asn_dec_rval_t
 558 INTEGER_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 559         asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) {
 560         asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics;
 561         asn_dec_rval_t rval = { RC_OK, 0 };
 562         INTEGER_t *st = (INTEGER_t *)*sptr;
 563         asn_per_constraint_t *ct;
 564         int repeat;
 565
 566         (void)opt_codec_ctx;
 567
 568         if(!st) {
 569                 st = (INTEGER_t *)(*sptr = CALLOC(1, sizeof(*st)));
 570                 if(!st) ASN__DECODE_FAILED;
 571         }
 572
 573         if(!constraints) constraints = td->per_constraints;
 574         ct = constraints ? &constraints->value : 0;
 575
 576         if(ct && ct->flags & APC_EXTENSIBLE) {
 577                 int inext = per_get_few_bits(pd, 1);
 578                 if(inext < 0) ASN__DECODE_STARVED;
 579                 if(inext) ct = 0;
 580         }
 581
 582         FREEMEM(st->buf);
 583         st->buf = 0;
 584         st->size = 0;
 585         if(ct) {
 586                 if(ct->flags & APC_SEMI_CONSTRAINED) {
 587                         st->buf = (uint8_t *)CALLOC(1, 2);
 588                         if(!st->buf) ASN__DECODE_FAILED;
 589                         st->size = 1;
 590                 } else if(ct->flags & APC_CONSTRAINED && ct->range_bits >= 0) {
 591                         size_t size = (ct->range_bits + 7) >> 3;
 592                         st->buf = (uint8_t *)MALLOC(1 + size + 1);
 593                         if(!st->buf) ASN__DECODE_FAILED;
 594                         st->size = size;
 595                 }
 596         }
 597
 598         /* X.691-2008/11, #13.2.2, constrained whole number */
 599         if(ct && ct->flags != APC_UNCONSTRAINED) {
 600                 /* #11.5.6 */
 601                 ASN_DEBUG("Integer with range %d bits", ct->range_bits);
 602                 if(ct->range_bits >= 0) {
 603                         if((size_t)ct->range_bits > 8 * sizeof(unsigned long))
 604                                 ASN__DECODE_FAILED;
 605
 606                         if(specs && specs->field_unsigned) {
 607                                 unsigned long uvalue;
 608                                 if(uper_get_constrained_whole_number(pd,
 609                                         &uvalue, ct->range_bits))
 610                                         ASN__DECODE_STARVED;
 611                                 ASN_DEBUG("Got value %lu + low %ld",
 612                                         uvalue, ct->lower_bound);
 613                                 uvalue += ct->lower_bound;
 614                                 if(asn_ulong2INTEGER(st, uvalue))
 615                                         ASN__DECODE_FAILED;
 616                         } else {
 617                                 unsigned long svalue;
 618                                 if(uper_get_constrained_whole_number(pd,
 619                                         &svalue, ct->range_bits))
 620                                         ASN__DECODE_STARVED;
 621                                 ASN_DEBUG("Got value %ld + low %ld",
 622                                         svalue, ct->lower_bound);
 623                                 svalue += ct->lower_bound;
 624                                 if(asn_long2INTEGER(st, svalue))
 625                                         ASN__DECODE_FAILED;
 626                         }
 627                         return rval;
 628                 }
 629         } else {
 630                 ASN_DEBUG("Decoding unconstrained integer %s", td->name);
 631         }
 632
 633         /* X.691, #12.2.3, #12.2.4 */
 634         do {
 635                 ssize_t len;
 636                 void *p;
 637                 int ret;
 638
 639                 /* Get the PER length */
 640                 len = uper_get_length(pd, -1, &repeat);
 641                 if(len < 0) ASN__DECODE_STARVED;
 642
 643                 p = REALLOC(st->buf, st->size + len + 1);
 644                 if(!p) ASN__DECODE_FAILED;
 645                 st->buf = (uint8_t *)p;
 646
 647                 ret = per_get_many_bits(pd, &st->buf[st->size], 0, 8 * len);
 648                 if(ret < 0) ASN__DECODE_STARVED;
 649                 st->size += len;
 650         } while(repeat);
 651         st->buf[st->size] = 0;  /* JIC */
 652
 653         /* #12.2.3 */
 654         if(ct && ct->lower_bound) {
 655                 /*
 656                  * TODO: replace by in-place arithmetics.
 657                  */
 658                 long value;
 659                 if(asn_INTEGER2long(st, &value))
 660                         ASN__DECODE_FAILED;
 661                 if(asn_long2INTEGER(st, value + ct->lower_bound))
 662                         ASN__DECODE_FAILED;
 663         }
 664
 665         return rval;
 666 }
 667
 668 asn_enc_rval_t
 669 INTEGER_encode_uper(asn_TYPE_descriptor_t *td,
 670         asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) {
 671         asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics;
 672         asn_enc_rval_t er;
 673         INTEGER_t *st = (INTEGER_t *)sptr;
 674         const uint8_t *buf;
 675         const uint8_t *end;
 676         asn_per_constraint_t *ct;
 677         long value = 0;
 678         unsigned long v = 0;
 679
 680         if(!st || st->size == 0) ASN__ENCODE_FAILED;
 681
 682         if(!constraints) constraints = td->per_constraints;
 683         ct = constraints ? &constraints->value : 0;
 684
 685         er.encoded = 0;
 686
 687         if(ct) {
 688                 int inext = 0;
 689                 if(specs && specs->field_unsigned) {
 690                         unsigned long uval;
 691                         if(asn_INTEGER2ulong(st, &uval))
 692                                 ASN__ENCODE_FAILED;
 693                         /* Check proper range */
 694                         if(ct->flags & APC_SEMI_CONSTRAINED) {
 695                                 if(uval < (unsigned long)ct->lower_bound)
 696                                         inext = 1;
 697                         } else if(ct->range_bits >= 0) {
 698                                 if(uval < (unsigned long)ct->lower_bound
 699                                 || uval > (unsigned long)ct->upper_bound)
 700                                         inext = 1;
 701                         }
 702                         ASN_DEBUG("Value %lu (%02x/%d) lb %lu ub %lu %s",
 703                                 uval, st->buf[0], st->size,
 704                                 ct->lower_bound, ct->upper_bound,
 705                                 inext ? "ext" : "fix");
 706                         value = uval;
 707                 } else {
 708                         if(asn_INTEGER2long(st, &value))
 709                                 ASN__ENCODE_FAILED;
 710                         /* Check proper range */
 711                         if(ct->flags & APC_SEMI_CONSTRAINED) {
 712                                 if(value < ct->lower_bound)
 713                                         inext = 1;
 714                         } else if(ct->range_bits >= 0) {
 715                                 if(value < ct->lower_bound
 716                                 || value > ct->upper_bound)
 717                                         inext = 1;
 718                         }
 719                         ASN_DEBUG("Value %ld (%02x/%d) lb %ld ub %ld %s",
 720                                 value, st->buf[0], st->size,
 721                                 ct->lower_bound, ct->upper_bound,
 722                                 inext ? "ext" : "fix");
 723                 }
 724                 if(ct->flags & APC_EXTENSIBLE) {
 725                         if(per_put_few_bits(po, inext, 1))
 726                                 ASN__ENCODE_FAILED;
 727                         if(inext) ct = 0;
 728                 } else if(inext) {
 729                         ASN__ENCODE_FAILED;
 730                 }
 731         }
 732
 733
 734         /* X.691-11/2008, #13.2.2, test if constrained whole number */
 735         if(ct && ct->range_bits >= 0) {
 736                 /* #11.5.6 -> #11.3 */
 737                 ASN_DEBUG("Encoding integer %ld (%lu) with range %d bits",
 738                         value, value - ct->lower_bound, ct->range_bits);
 739                 v = value - ct->lower_bound;
 740                 if(uper_put_constrained_whole_number_u(po, v, ct->range_bits))
 741                         ASN__ENCODE_FAILED;
 742                 ASN__ENCODED_OK(er);
 743         }
 744
 745         if(ct && ct->lower_bound) {
 746                 ASN_DEBUG("Adjust lower bound to %ld", ct->lower_bound);
 747                 /* TODO: adjust lower bound */
 748                 ASN__ENCODE_FAILED;
 749         }
 750
 751         for(buf = st->buf, end = st->buf + st->size; buf < end;) {
 752                 ssize_t mayEncode = uper_put_length(po, end - buf);
 753                 if(mayEncode < 0)
 754                         ASN__ENCODE_FAILED;
 755                 if(per_put_many_bits(po, buf, 8 * mayEncode))
 756                         ASN__ENCODE_FAILED;
 757                 buf += mayEncode;
 758         }
 759
 760         ASN__ENCODED_OK(er);
 761 }
 762
 763 #endif  /* ASN_DISABLE_PER_SUPPORT */
 764
 765 int
 766 asn_INTEGER2long(const INTEGER_t *iptr, long *lptr) {
 767         uint8_t *b, *end;
 768         size_t size;
 769         long l;
 770
 771         /* Sanity checking */
 772         if(!iptr || !iptr->buf || !lptr) {
 773                 errno = EINVAL;
 774                 return -1;
 775         }
 776
 777         /* Cache the begin/end of the buffer */
 778         b = iptr->buf;  /* Start of the INTEGER buffer */
 779         size = iptr->size;
 780         end = b + size; /* Where to stop */
 781
 782         if(size > sizeof(long)) {
 783                 uint8_t *end1 = end - 1;
 784                 /*
 785                  * Slightly more advanced processing,
 786                  * able to >sizeof(long) bytes,
 787                  * when the actual value is small
 788                  * (0x0000000000abcdef would yield a fine 0x00abcdef)
 789                  */
 790                 /* Skip out the insignificant leading bytes */
 791                 for(; b < end1; b++) {
 792                         switch(*b) {
 793                         case 0x00: if((b[1] & 0x80) == 0) continue; break;
 794                         case 0xff: if((b[1] & 0x80) != 0) continue; break;
 795                         }
 796                         break;
 797                 }
 798
 799                 size = end - b;
 800                 if(size > sizeof(long)) {
 801                         /* Still cannot fit the long */
 802                         errno = ERANGE;
 803                         return -1;
 804                 }
 805         }
 806
 807         /* Shortcut processing of a corner case */
 808         if(end == b) {
 809                 *lptr = 0;
 810                 return 0;
 811         }
 812
 813         /* Perform the sign initialization */
 814         /* Actually l = -(*b >> 7); gains nothing, yet unreadable! */
 815         if((*b >> 7)) l = -1; else l = 0;
 816
 817         /* Conversion engine */
 818         for(; b < end; b++)
 819                 l = (l << 8) | *b;
 820
 821         *lptr = l;
 822         return 0;
 823 }
 824
 825 int
 826 asn_INTEGER2ulong(const INTEGER_t *iptr, unsigned long *lptr) {
 827         uint8_t *b, *end;
 828         unsigned long l;
 829         size_t size;
 830
 831         if(!iptr || !iptr->buf || !lptr) {
 832                 errno = EINVAL;
 833                 return -1;
 834         }
 835
 836         b = iptr->buf;
 837         size = iptr->size;
 838         end = b + size;
 839
 840         /* If all extra leading bytes are zeroes, ignore them */
 841         for(; size > sizeof(unsigned long); b++, size--) {
 842                 if(*b) {
 843                         /* Value won't fit unsigned long */
 844                         errno = ERANGE;
 845                         return -1;
 846                 }
 847         }
 848
 849         /* Conversion engine */
 850         for(l = 0; b < end; b++)
 851                 l = (l << 8) | *b;
 852
 853         *lptr = l;
 854         return 0;
 855 }
 856
 857 int
 858 asn_ulong2INTEGER(INTEGER_t *st, unsigned long value) {
 859         uint8_t *buf;
 860         uint8_t *end;
 861         uint8_t *b;
 862         int shr;
 863
 864         if(value <= LONG_MAX)
 865                 return asn_long2INTEGER(st, value);
 866
 867         buf = (uint8_t *)MALLOC(1 + sizeof(value));
 868         if(!buf) return -1;
 869
 870         end = buf + (sizeof(value) + 1);
 871         buf[0] = 0;
 872         for(b = buf + 1, shr = (sizeof(long)-1)*8; b < end; shr -= 8, b++)
 873                 *b = (uint8_t)(value >> shr);
 874
 875         if(st->buf) FREEMEM(st->buf);
 876         st->buf = buf;
 877         st->size = 1 + sizeof(value);
 878
 879         return 0;
 880 }
 881
 882 int
 883 asn_long2INTEGER(INTEGER_t *st, long value) {
 884         uint8_t *buf, *bp;
 885         uint8_t *p;
 886         uint8_t *pstart;
 887         uint8_t *pend1;
 888         int littleEndian = 1;   /* Run-time detection */
 889         int add;
 890
 891         if(!st) {
 892                 errno = EINVAL;
 893                 return -1;
 894         }
 895
 896         buf = (uint8_t *)MALLOC(sizeof(value));
 897         if(!buf) return -1;
 898
 899         if(*(char *)&littleEndian) {
 900                 pstart = (uint8_t *)&value + sizeof(value) - 1;
 901                 pend1 = (uint8_t *)&value;
 902                 add = -1;
 903         } else {
 904                 pstart = (uint8_t *)&value;
 905                 pend1 = pstart + sizeof(value) - 1;
 906                 add = 1;
 907         }
 908
 909         /*
 910          * If the contents octet consists of more than one octet,
 911          * then bits of the first octet and bit 8 of the second octet:
 912          * a) shall not all be ones; and
 913          * b) shall not all be zero.
 914          */
 915         for(p = pstart; p != pend1; p += add) {
 916                 switch(*p) {
 917                 case 0x00: if((*(p+add) & 0x80) == 0)
 918                                 continue;
 919                         break;
 920                 case 0xff: if((*(p+add) & 0x80))
 921                                 continue;
 922                         break;
 923                 }
 924                 break;
 925         }
 926         /* Copy the integer body */
 927         for(pstart = p, bp = buf, pend1 += add; p != pend1; p += add)
 928                 *bp++ = *p;
 929
 930         if(st->buf) FREEMEM(st->buf);
 931         st->buf = buf;
 932         st->size = bp - buf;
 933
 934         return 0;
 935 }
 936
 937 /*
 938  * This function is going to be DEPRECATED soon.
 939  */
 940 enum asn_strtol_result_e
 941 asn_strtol(const char *str, const char *end, long *lp) {
 942     const char *endp = end;
 943
 944     switch(asn_strtol_lim(str, &endp, lp)) {
 945     case ASN_STRTOL_ERROR_RANGE:
 946         return ASN_STRTOL_ERROR_RANGE;
 947     case ASN_STRTOL_ERROR_INVAL:
 948         return ASN_STRTOL_ERROR_INVAL;
 949     case ASN_STRTOL_EXPECT_MORE:
 950         return ASN_STRTOL_ERROR_INVAL;  /* Retain old behavior */
 951     case ASN_STRTOL_OK:
 952         return ASN_STRTOL_OK;
 953     case ASN_STRTOL_EXTRA_DATA:
 954         return ASN_STRTOL_ERROR_INVAL;  /* Retain old behavior */
 955     }
 956
 957     return ASN_STRTOL_ERROR_INVAL;  /* Retain old behavior */
 958 }
 959
 960 /*
 961  * Parse the number in the given string until the given *end position,
 962  * returning the position after the last parsed character back using the
 963  * same (*end) pointer.
 964  * WARNING: This behavior is different from the standard strtol(3).
 965  */
 966 enum asn_strtol_result_e
 967 asn_strtol_lim(const char *str, const char **end, long *lp) {
 968         int sign = 1;
 969         long l;
 970
 971         const long upper_boundary = LONG_MAX / 10;
 972         long last_digit_max = LONG_MAX % 10;
 973
 974         if(str >= *end) return ASN_STRTOL_ERROR_INVAL;
 975
 976         switch(*str) {
 977         case '-':
 978                 last_digit_max++;
 979                 sign = -1;
 980                 /* FALL THROUGH */
 981         case '+':
 982                 str++;
 983                 if(str >= *end) {
 984                         *end = str;
 985                         return ASN_STRTOL_EXPECT_MORE;
 986                 }
 987         }
 988
 989         for(l = 0; str < (*end); str++) {
 990                 switch(*str) {
 991                 case 0x30: case 0x31: case 0x32: case 0x33: case 0x34:
 992                 case 0x35: case 0x36: case 0x37: case 0x38: case 0x39: {
 993                         int d = *str - '0';
 994                         if(l < upper_boundary) {
 995                                 l = l * 10 + d;
 996                         } else if(l == upper_boundary) {
 997                                 if(d <= last_digit_max) {
 998                                         if(sign > 0) {
 999                                                 l = l * 10 + d;
1000                                         } else {
1001                                                 sign = 1;
1002                                                 l = -l * 10 - d;
1003                                         }
1004                                 } else {
1005                                         *end = str;
1006                                         return ASN_STRTOL_ERROR_RANGE;
1007                                 }
1008                         } else {
1009                                 *end = str;
1010                                 return ASN_STRTOL_ERROR_RANGE;
1011                         }
1012                     }
1013                     continue;
1014                 default:
1015                     *end = str;
1016                     *lp = sign * l;
1017                     return ASN_STRTOL_EXTRA_DATA;
1018                 }
1019         }
1020
1021         *end = str;
1022         *lp = sign * l;
1023         return ASN_STRTOL_OK;
1024 }
1025