stglibs/smux.lib/INTEGER.c

   1 /*-
   2  * Copyright (c) 2003, 2004, 2005, 2006 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 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         INTEGER_decode_uper,    /* Unaligned PER decoder */
  28         INTEGER_encode_uper,    /* Unaligned PER encoder */
  29         0, /* Use generic outmost tag fetcher */
  30         asn_DEF_INTEGER_tags,
  31         sizeof(asn_DEF_INTEGER_tags) / sizeof(asn_DEF_INTEGER_tags[0]),
  32         asn_DEF_INTEGER_tags,   /* Same as above */
  33         sizeof(asn_DEF_INTEGER_tags) / sizeof(asn_DEF_INTEGER_tags[0]),
  34         0,      /* No PER visible constraints */
  35         0, 0,   /* No members */
  36         0       /* No specifics */
  37 };
  38
  39 /*
  40  * Encode INTEGER type using DER.
  41  */
  42 asn_enc_rval_t
  43 INTEGER_encode_der(asn_TYPE_descriptor_t *td, void *sptr,
  44         int tag_mode, ber_tlv_tag_t tag,
  45         asn_app_consume_bytes_f *cb, void *app_key) {
  46         INTEGER_t *st = (INTEGER_t *)sptr;
  47
  48         ASN_DEBUG("%s %s as INTEGER (tm=%d)",
  49                 cb?"Encoding":"Estimating", td->name, tag_mode);
  50
  51         /*
  52          * Canonicalize integer in the buffer.
  53          * (Remove too long sign extension, remove some first 0x00 bytes)
  54          */
  55         if(st->buf) {
  56                 uint8_t *buf = st->buf;
  57                 uint8_t *end1 = buf + st->size - 1;
  58                 int shift;
  59
  60                 /* Compute the number of superfluous leading bytes */
  61                 for(; buf < end1; buf++) {
  62                         /*
  63                          * If the contents octets of an integer value encoding
  64                          * consist of more than one octet, then the bits of the
  65                          * first octet and bit 8 of the second octet:
  66                          * a) shall not all be ones; and
  67                          * b) shall not all be zero.
  68                          */
  69                         switch(*buf) {
  70                         case 0x00: if((buf[1] & 0x80) == 0)
  71                                         continue;
  72                                 break;
  73                         case 0xff: if((buf[1] & 0x80))
  74                                         continue;
  75                                 break;
  76                         }
  77                         break;
  78                 }
  79
  80                 /* Remove leading superfluous bytes from the integer */
  81                 shift = buf - st->buf;
  82                 if(shift) {
  83                         uint8_t *nb = st->buf;
  84                         uint8_t *end;
  85
  86                         st->size -= shift;      /* New size, minus bad bytes */
  87                         end = nb + st->size;
  88
  89                         for(; nb < end; nb++, buf++)
  90                                 *nb = *buf;
  91                 }
  92
  93         } /* if(1) */
  94
  95         return der_encode_primitive(td, sptr, tag_mode, tag, cb, app_key);
  96 }
  97
  98 static const asn_INTEGER_enum_map_t *INTEGER_map_enum2value(asn_INTEGER_specifics_t *specs, const char *lstart, const char *lstop);
  99
 100 /*
 101  * INTEGER specific human-readable output.
 102  */
 103 static ssize_t
 104 INTEGER__dump(asn_TYPE_descriptor_t *td, const INTEGER_t *st, asn_app_consume_bytes_f *cb, void *app_key, int plainOrXER) {
 105         asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics;
 106         char scratch[32];       /* Enough for 64-bit integer */
 107         uint8_t *buf = st->buf;
 108         uint8_t *buf_end = st->buf + st->size;
 109         signed long accum;
 110         ssize_t wrote = 0;
 111         char *p;
 112         int ret;
 113
 114         /*
 115          * Advance buf pointer until the start of the value's body.
 116          * This will make us able to process large integers using simple case,
 117          * when the actual value is small
 118          * (0x0000000000abcdef would yield a fine 0x00abcdef)
 119          */
 120         /* Skip the insignificant leading bytes */
 121         for(; buf < buf_end-1; buf++) {
 122                 switch(*buf) {
 123                 case 0x00: if((buf[1] & 0x80) == 0) continue; break;
 124                 case 0xff: if((buf[1] & 0x80) != 0) continue; break;
 125                 }
 126                 break;
 127         }
 128
 129         /* Simple case: the integer size is small */
 130         if((size_t)(buf_end - buf) <= sizeof(accum)) {
 131                 const asn_INTEGER_enum_map_t *el;
 132                 size_t scrsize;
 133                 char *scr;
 134
 135                 if(buf == buf_end) {
 136                         accum = 0;
 137                 } else {
 138                         accum = (*buf & 0x80) ? -1 : 0;
 139                         for(; buf < buf_end; buf++)
 140                                 accum = (accum << 8) | *buf;
 141                 }
 142
 143                 el = INTEGER_map_value2enum(specs, accum);
 144                 if(el) {
 145                         scrsize = el->enum_len + 32;
 146                         scr = (char *)alloca(scrsize);
 147                         if(plainOrXER == 0)
 148                                 ret = snprintf(scr, scrsize,
 149                                         "%ld (%s)", accum, el->enum_name);
 150                         else
 151                                 ret = snprintf(scr, scrsize,
 152                                         "<%s/>", el->enum_name);
 153                 } else if(plainOrXER && specs && specs->strict_enumeration) {
 154                         ASN_DEBUG("ASN.1 forbids dealing with "
 155                                 "unknown value of ENUMERATED type");
 156                         errno = EPERM;
 157                         return -1;
 158                 } else {
 159                         scrsize = sizeof(scratch);
 160                         scr = scratch;
 161                         ret = snprintf(scr, scrsize, "%ld", accum);
 162                 }
 163                 assert(ret > 0 && (size_t)ret < scrsize);
 164                 return (cb(scr, ret, app_key) < 0) ? -1 : ret;
 165         } else if(plainOrXER && specs && specs->strict_enumeration) {
 166                 /*
 167                  * Here and earlier, we cannot encode the ENUMERATED values
 168                  * if there is no corresponding identifier.
 169                  */
 170                 ASN_DEBUG("ASN.1 forbids dealing with "
 171                         "unknown value of ENUMERATED type");
 172                 errno = EPERM;
 173                 return -1;
 174         }
 175
 176         /* Output in the long xx:yy:zz... format */
 177         /* TODO: replace with generic algorithm (Knuth TAOCP Vol 2, 4.3.1) */
 178         for(p = scratch; buf < buf_end; buf++) {
 179                 static const char *h2c = "0123456789ABCDEF";
 180                 if((p - scratch) >= (ssize_t)(sizeof(scratch) - 4)) {
 181                         /* Flush buffer */
 182                         if(cb(scratch, p - scratch, app_key) < 0)
 183                                 return -1;
 184                         wrote += p - scratch;
 185                         p = scratch;
 186                 }
 187                 *p++ = h2c[*buf >> 4];
 188                 *p++ = h2c[*buf & 0x0F];
 189                 *p++ = 0x3a;    /* ":" */
 190         }
 191         if(p != scratch)
 192                 p--;    /* Remove the last ":" */
 193
 194         wrote += p - scratch;
 195         return (cb(scratch, p - scratch, app_key) < 0) ? -1 : wrote;
 196 }
 197
 198 /*
 199  * INTEGER specific human-readable output.
 200  */
 201 int
 202 INTEGER_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
 203         asn_app_consume_bytes_f *cb, void *app_key) {
 204         const INTEGER_t *st = (const INTEGER_t *)sptr;
 205         ssize_t ret;
 206
 207         (void)td;
 208         (void)ilevel;
 209
 210         if(!st || !st->buf)
 211                 ret = cb("<absent>", 8, app_key);
 212         else
 213                 ret = INTEGER__dump(td, st, cb, app_key, 0);
 214
 215         return (ret < 0) ? -1 : 0;
 216 }
 217
 218 struct e2v_key {
 219         const char *start;
 220         const char *stop;
 221         asn_INTEGER_enum_map_t *vemap;
 222         unsigned int *evmap;
 223 };
 224 static int
 225 INTEGER__compar_enum2value(const void *kp, const void *am) {
 226         const struct e2v_key *key = (const struct e2v_key *)kp;
 227         const asn_INTEGER_enum_map_t *el = (const asn_INTEGER_enum_map_t *)am;
 228         const char *ptr, *end, *name;
 229
 230         /* Remap the element (sort by different criterion) */
 231         el = key->vemap + key->evmap[el - key->vemap];
 232
 233         /* Compare strings */
 234         for(ptr = key->start, end = key->stop, name = el->enum_name;
 235                         ptr < end; ptr++, name++) {
 236                 if(*ptr != *name)
 237                         return *(const unsigned char *)ptr
 238                                 - *(const unsigned char *)name;
 239         }
 240         return name[0] ? -1 : 0;
 241 }
 242
 243 static const asn_INTEGER_enum_map_t *
 244 INTEGER_map_enum2value(asn_INTEGER_specifics_t *specs, const char *lstart, const char *lstop) {
 245         asn_INTEGER_enum_map_t *el_found;
 246         int count = specs ? specs->map_count : 0;
 247         struct e2v_key key;
 248         const char *lp;
 249
 250         if(!count) return NULL;
 251
 252         /* Guaranteed: assert(lstart < lstop); */
 253         /* Figure out the tag name */
 254         for(lstart++, lp = lstart; lp < lstop; lp++) {
 255                 switch(*lp) {
 256                 case 9: case 10: case 11: case 12: case 13: case 32: /* WSP */
 257                 case 0x2f: /* '/' */ case 0x3e: /* '>' */
 258                         break;
 259                 default:
 260                         continue;
 261                 }
 262                 break;
 263         }
 264         if(lp == lstop) return NULL;    /* No tag found */
 265         lstop = lp;
 266
 267         key.start = lstart;
 268         key.stop = lstop;
 269         key.vemap = specs->value2enum;
 270         key.evmap = specs->enum2value;
 271         el_found = (asn_INTEGER_enum_map_t *)bsearch(&key,
 272                 specs->value2enum, count, sizeof(specs->value2enum[0]),
 273                 INTEGER__compar_enum2value);
 274         if(el_found) {
 275                 /* Remap enum2value into value2enum */
 276                 el_found = key.vemap + key.evmap[el_found - key.vemap];
 277         }
 278         return el_found;
 279 }
 280
 281 static int
 282 INTEGER__compar_value2enum(const void *kp, const void *am) {
 283         long a = *(const long *)kp;
 284         const asn_INTEGER_enum_map_t *el = (const asn_INTEGER_enum_map_t *)am;
 285         long b = el->nat_value;
 286         if(a < b) return -1;
 287         else if(a == b) return 0;
 288         else return 1;
 289 }
 290
 291 const asn_INTEGER_enum_map_t *
 292 INTEGER_map_value2enum(asn_INTEGER_specifics_t *specs, long value) {
 293         int count = specs ? specs->map_count : 0;
 294         if(!count) return 0;
 295         return (asn_INTEGER_enum_map_t *)bsearch(&value, specs->value2enum,
 296                 count, sizeof(specs->value2enum[0]),
 297                 INTEGER__compar_value2enum);
 298 }
 299
 300 static int
 301 INTEGER_st_prealloc(INTEGER_t *st, int min_size) {
 302         void *p = MALLOC(min_size + 1);
 303         if(p) {
 304                 void *b = st->buf;
 305                 st->size = 0;
 306                 st->buf = p;
 307                 FREEMEM(b);
 308                 return 0;
 309         } else {
 310                 return -1;
 311         }
 312 }
 313
 314 /*
 315  * Decode the chunk of XML text encoding INTEGER.
 316  */
 317 static enum xer_pbd_rval
 318 INTEGER__xer_body_decode(asn_TYPE_descriptor_t *td, void *sptr, const void *chunk_buf, size_t chunk_size) {
 319         INTEGER_t *st = (INTEGER_t *)sptr;
 320         long sign = 1;
 321         long value;
 322         const char *lp;
 323         const char *lstart = (const char *)chunk_buf;
 324         const char *lstop = lstart + chunk_size;
 325         enum {
 326                 ST_SKIPSPACE,
 327                 ST_SKIPSPHEX,
 328                 ST_WAITDIGITS,
 329                 ST_DIGITS,
 330                 ST_HEXDIGIT1,
 331                 ST_HEXDIGIT2,
 332                 ST_HEXCOLON,
 333                 ST_EXTRASTUFF
 334         } state = ST_SKIPSPACE;
 335
 336         if(chunk_size)
 337                 ASN_DEBUG("INTEGER body %d 0x%2x..0x%2x",
 338                         chunk_size, *lstart, lstop[-1]);
 339
 340         /*
 341          * We may have received a tag here. It will be processed inline.
 342          * Use strtoul()-like code and serialize the result.
 343          */
 344         for(value = 0, lp = lstart; lp < lstop; lp++) {
 345                 int lv = *lp;
 346                 switch(lv) {
 347                 case 0x09: case 0x0a: case 0x0d: case 0x20:
 348                         switch(state) {
 349                         case ST_SKIPSPACE:
 350                         case ST_SKIPSPHEX:
 351                                 continue;
 352                         case ST_HEXCOLON:
 353                                 if(xer_is_whitespace(lp, lstop - lp)) {
 354                                         lp = lstop - 1;
 355                                         continue;
 356                                 }
 357                                 break;
 358                         default:
 359                                 break;
 360                         }
 361                         break;
 362                 case 0x2d:      /* '-' */
 363                         if(state == ST_SKIPSPACE) {
 364                                 sign = -1;
 365                                 state = ST_WAITDIGITS;
 366                                 continue;
 367                         }
 368                         break;
 369                 case 0x2b:      /* '+' */
 370                         if(state == ST_SKIPSPACE) {
 371                                 state = ST_WAITDIGITS;
 372                                 continue;
 373                         }
 374                         break;
 375                 case 0x30: case 0x31: case 0x32: case 0x33: case 0x34:
 376                 case 0x35: case 0x36: case 0x37: case 0x38: case 0x39:
 377                         switch(state) {
 378                         case ST_DIGITS: break;
 379                         case ST_SKIPSPHEX:      /* Fall through */
 380                         case ST_HEXDIGIT1:
 381                                 value = (lv - 0x30) << 4;
 382                                 state = ST_HEXDIGIT2;
 383                                 continue;
 384                         case ST_HEXDIGIT2:
 385                                 value += (lv - 0x30);
 386                                 state = ST_HEXCOLON;
 387                                 st->buf[st->size++] = value;
 388                                 continue;
 389                         case ST_HEXCOLON:
 390                                 return XPBD_BROKEN_ENCODING;
 391                         default:
 392                                 state = ST_DIGITS;
 393                                 break;
 394                         }
 395
 396                     {
 397                         long new_value = value * 10;
 398
 399                         if(new_value / 10 != value)
 400                                 /* Overflow */
 401                                 return XPBD_DECODER_LIMIT;
 402
 403                         value = new_value + (lv - 0x30);
 404                         /* Check for two's complement overflow */
 405                         if(value < 0) {
 406                                 /* Check whether it is a LONG_MIN */
 407                                 if(sign == -1
 408                                 && (unsigned long)value
 409                                                 == ~((unsigned long)-1 >> 1)) {
 410                                         sign = 1;
 411                                 } else {
 412                                         /* Overflow */
 413                                         return XPBD_DECODER_LIMIT;
 414                                 }
 415                         }
 416                     }
 417                         continue;
 418                 case 0x3c:      /* '<' */
 419                         if(state == ST_SKIPSPACE) {
 420                                 const asn_INTEGER_enum_map_t *el;
 421                                 el = INTEGER_map_enum2value(
 422                                         (asn_INTEGER_specifics_t *)
 423                                         td->specifics, lstart, lstop);
 424                                 if(el) {
 425                                         ASN_DEBUG("Found \"%s\" => %ld",
 426                                                 el->enum_name, el->nat_value);
 427                                         state = ST_DIGITS;
 428                                         value = el->nat_value;
 429                                         lp = lstop - 1;
 430                                         continue;
 431                                 }
 432                                 ASN_DEBUG("Unknown identifier for INTEGER");
 433                         }
 434                         return XPBD_BROKEN_ENCODING;
 435                 case 0x3a:      /* ':' */
 436                         if(state == ST_HEXCOLON) {
 437                                 /* This colon is expected */
 438                                 state = ST_HEXDIGIT1;
 439                                 continue;
 440                         } else if(state == ST_DIGITS) {
 441                                 /* The colon here means that we have
 442                                  * decoded the first two hexadecimal
 443                                  * places as a decimal value.
 444                                  * Switch decoding mode. */
 445                                 ASN_DEBUG("INTEGER re-evaluate as hex form");
 446                                 if(INTEGER_st_prealloc(st, (chunk_size/3) + 1))
 447                                         return XPBD_SYSTEM_FAILURE;
 448                                 state = ST_SKIPSPHEX;
 449                                 lp = lstart - 1;
 450                                 continue;
 451                         } else {
 452                                 ASN_DEBUG("state %d at %d", state, lp - lstart);
 453                                 break;
 454                         }
 455                 /* [A-Fa-f] */
 456                 case 0x41:case 0x42:case 0x43:case 0x44:case 0x45:case 0x46:
 457                 case 0x61:case 0x62:case 0x63:case 0x64:case 0x65:case 0x66:
 458                         switch(state) {
 459                         case ST_SKIPSPHEX:
 460                         case ST_SKIPSPACE: /* Fall through */
 461                         case ST_HEXDIGIT1:
 462                                 value = lv - ((lv < 0x61) ? 0x41 : 0x61);
 463                                 value += 10;
 464                                 value <<= 4;
 465                                 state = ST_HEXDIGIT2;
 466                                 continue;
 467                         case ST_HEXDIGIT2:
 468                                 value += lv - ((lv < 0x61) ? 0x41 : 0x61);
 469                                 value += 10;
 470                                 st->buf[st->size++] = value;
 471                                 state = ST_HEXCOLON;
 472                                 continue;
 473                         case ST_DIGITS:
 474                                 ASN_DEBUG("INTEGER re-evaluate as hex form");
 475                                 if(INTEGER_st_prealloc(st, (chunk_size/3) + 1))
 476                                         return XPBD_SYSTEM_FAILURE;
 477                                 state = ST_SKIPSPHEX;
 478                                 lp = lstart - 1;
 479                                 continue;
 480                         default:
 481                                 break;
 482                         }
 483                         break;
 484                 }
 485
 486                 /* Found extra non-numeric stuff */
 487                 ASN_DEBUG("Found non-numeric 0x%2x at %d",
 488                         lv, lp - lstart);
 489                 state = ST_EXTRASTUFF;
 490                 break;
 491         }
 492
 493         switch(state) {
 494         case ST_DIGITS:
 495                 /* Everything is cool */
 496                 break;
 497         case ST_HEXCOLON:
 498                 st->buf[st->size] = 0;  /* Just in case termination */
 499                 return XPBD_BODY_CONSUMED;
 500         case ST_HEXDIGIT1:
 501         case ST_HEXDIGIT2:
 502         case ST_SKIPSPHEX:
 503                 return XPBD_BROKEN_ENCODING;
 504         default:
 505                 if(xer_is_whitespace(lp, lstop - lp)) {
 506                         if(state != ST_EXTRASTUFF)
 507                                 return XPBD_NOT_BODY_IGNORE;
 508                         break;
 509                 } else {
 510                         ASN_DEBUG("INTEGER: No useful digits (state %d)",
 511                                 state);
 512                         return XPBD_BROKEN_ENCODING;    /* No digits */
 513                 }
 514                 break;
 515         }
 516
 517         value *= sign;  /* Change sign, if needed */
 518
 519         if(asn_long2INTEGER(st, value))
 520                 return XPBD_SYSTEM_FAILURE;
 521
 522         return XPBD_BODY_CONSUMED;
 523 }
 524
 525 asn_dec_rval_t
 526 INTEGER_decode_xer(asn_codec_ctx_t *opt_codec_ctx,
 527         asn_TYPE_descriptor_t *td, void **sptr, const char *opt_mname,
 528                 const void *buf_ptr, size_t size) {
 529
 530         return xer_decode_primitive(opt_codec_ctx, td,
 531                 sptr, sizeof(INTEGER_t), opt_mname,
 532                 buf_ptr, size, INTEGER__xer_body_decode);
 533 }
 534
 535 asn_enc_rval_t
 536 INTEGER_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
 537         int ilevel, enum xer_encoder_flags_e flags,
 538                 asn_app_consume_bytes_f *cb, void *app_key) {
 539         const INTEGER_t *st = (const INTEGER_t *)sptr;
 540         asn_enc_rval_t er;
 541
 542         (void)ilevel;
 543         (void)flags;
 544
 545         if(!st || !st->buf)
 546                 _ASN_ENCODE_FAILED;
 547
 548         er.encoded = INTEGER__dump(td, st, cb, app_key, 1);
 549         if(er.encoded < 0) _ASN_ENCODE_FAILED;
 550
 551         _ASN_ENCODED_OK(er);
 552 }
 553
 554 asn_dec_rval_t
 555 INTEGER_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 556         asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) {
 557         asn_dec_rval_t rval = { RC_OK, 0 };
 558         INTEGER_t *st = (INTEGER_t *)*sptr;
 559         asn_per_constraint_t *ct;
 560         int repeat;
 561
 562         (void)opt_codec_ctx;
 563
 564         if(!st) {
 565                 st = (INTEGER_t *)(*sptr = CALLOC(1, sizeof(*st)));
 566                 if(!st) _ASN_DECODE_FAILED;
 567         }
 568
 569         if(!constraints) constraints = td->per_constraints;
 570         ct = constraints ? &constraints->value : 0;
 571
 572         if(ct && ct->flags & APC_EXTENSIBLE) {
 573                 int inext = per_get_few_bits(pd, 1);
 574                 if(inext < 0) _ASN_DECODE_STARVED;
 575                 if(inext) ct = 0;
 576         }
 577
 578         FREEMEM(st->buf);
 579         if(ct) {
 580                 if(ct->flags & APC_SEMI_CONSTRAINED) {
 581                         st->buf = (uint8_t *)CALLOC(1, 2);
 582                         if(!st->buf) _ASN_DECODE_FAILED;
 583                         st->size = 1;
 584                 } else if(ct->flags & APC_CONSTRAINED && ct->range_bits >= 0) {
 585                         size_t size = (ct->range_bits + 7) >> 3;
 586                         st->buf = (uint8_t *)MALLOC(1 + size + 1);
 587                         if(!st->buf) _ASN_DECODE_FAILED;
 588                         st->size = size;
 589                 } else {
 590                         st->size = 0;
 591                 }
 592         } else {
 593                 st->size = 0;
 594         }
 595
 596         /* X.691, #12.2.2 */
 597         if(ct && ct->flags != APC_UNCONSTRAINED) {
 598                 /* #10.5.6 */
 599                 ASN_DEBUG("Integer with range %d bits", ct->range_bits);
 600                 if(ct->range_bits >= 0) {
 601                         long value = per_get_few_bits(pd, ct->range_bits);
 602                         if(value < 0) _ASN_DECODE_STARVED;
 603                         ASN_DEBUG("Got value %ld + low %ld",
 604                                 value, ct->lower_bound);
 605                         value += ct->lower_bound;
 606                         if(asn_long2INTEGER(st, value))
 607                                 _ASN_DECODE_FAILED;
 608                         return rval;
 609                 }
 610         } else {
 611                 ASN_DEBUG("Decoding unconstrained integer %s", td->name);
 612         }
 613
 614         /* X.691, #12.2.3, #12.2.4 */
 615         do {
 616                 ssize_t len;
 617                 void *p;
 618                 int ret;
 619
 620                 /* Get the PER length */
 621                 len = uper_get_length(pd, -1, &repeat);
 622                 if(len < 0) _ASN_DECODE_STARVED;
 623
 624                 p = REALLOC(st->buf, st->size + len + 1);
 625                 if(!p) _ASN_DECODE_FAILED;
 626                 st->buf = (uint8_t *)p;
 627
 628                 ret = per_get_many_bits(pd, &st->buf[st->size], 0, 8 * len);
 629                 if(ret < 0) _ASN_DECODE_STARVED;
 630                 st->size += len;
 631         } while(repeat);
 632         st->buf[st->size] = 0;  /* JIC */
 633
 634         /* #12.2.3 */
 635         if(ct && ct->lower_bound) {
 636                 /*
 637                  * TODO: replace by in-place arithmetics.
 638                  */
 639                 long value;
 640                 if(asn_INTEGER2long(st, &value))
 641                         _ASN_DECODE_FAILED;
 642                 if(asn_long2INTEGER(st, value + ct->lower_bound))
 643                         _ASN_DECODE_FAILED;
 644         }
 645
 646         return rval;
 647 }
 648
 649 asn_enc_rval_t
 650 INTEGER_encode_uper(asn_TYPE_descriptor_t *td,
 651         asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) {
 652         asn_enc_rval_t er;
 653         INTEGER_t *st = (INTEGER_t *)sptr;
 654         const uint8_t *buf;
 655         const uint8_t *end;
 656         asn_per_constraint_t *ct;
 657         long value = 0;
 658
 659         if(!st || st->size == 0) _ASN_ENCODE_FAILED;
 660
 661         if(!constraints) constraints = td->per_constraints;
 662         ct = constraints ? &constraints->value : 0;
 663
 664         er.encoded = 0;
 665
 666         if(ct) {
 667                 int inext = 0;
 668                 if(asn_INTEGER2long(st, &value))
 669                         _ASN_ENCODE_FAILED;
 670                 /* Check proper range */
 671                 if(ct->flags & APC_SEMI_CONSTRAINED) {
 672                         if(value < ct->lower_bound)
 673                                 inext = 1;
 674                 } else if(ct->range_bits >= 0) {
 675                         if(value < ct->lower_bound
 676                         || value > ct->upper_bound)
 677                                 inext = 1;
 678                 }
 679                 ASN_DEBUG("Value %ld (%02x/%d) lb %ld ub %ld %s",
 680                         value, st->buf[0], st->size,
 681                         ct->lower_bound, ct->upper_bound,
 682                         inext ? "ext" : "fix");
 683                 if(ct->flags & APC_EXTENSIBLE) {
 684                         if(per_put_few_bits(po, inext, 1))
 685                                 _ASN_ENCODE_FAILED;
 686                         if(inext) ct = 0;
 687                 } else if(inext) {
 688                         _ASN_ENCODE_FAILED;
 689                 }
 690         }
 691
 692
 693         /* X.691, #12.2.2 */
 694         if(ct && ct->range_bits >= 0) {
 695                 /* #10.5.6 */
 696                 ASN_DEBUG("Encoding integer with range %d bits",
 697                         ct->range_bits);
 698                 if(per_put_few_bits(po, value - ct->lower_bound,
 699                                 ct->range_bits))
 700                         _ASN_ENCODE_FAILED;
 701                 _ASN_ENCODED_OK(er);
 702         }
 703
 704         if(ct && ct->lower_bound) {
 705                 ASN_DEBUG("Adjust lower bound to %ld", ct->lower_bound);
 706                 /* TODO: adjust lower bound */
 707                 _ASN_ENCODE_FAILED;
 708         }
 709
 710         for(buf = st->buf, end = st->buf + st->size; buf < end;) {
 711                 ssize_t mayEncode = uper_put_length(po, end - buf);
 712                 if(mayEncode < 0)
 713                         _ASN_ENCODE_FAILED;
 714                 if(per_put_many_bits(po, buf, 8 * mayEncode))
 715                         _ASN_ENCODE_FAILED;
 716                 buf += mayEncode;
 717         }
 718
 719         _ASN_ENCODED_OK(er);
 720 }
 721
 722 int
 723 asn_INTEGER2long(const INTEGER_t *iptr, long *lptr) {
 724         uint8_t *b, *end;
 725         size_t size;
 726         long l;
 727
 728         /* Sanity checking */
 729         if(!iptr || !iptr->buf || !lptr) {
 730                 errno = EINVAL;
 731                 return -1;
 732         }
 733
 734         /* Cache the begin/end of the buffer */
 735         b = iptr->buf;  /* Start of the INTEGER buffer */
 736         size = iptr->size;
 737         end = b + size; /* Where to stop */
 738
 739         if(size > sizeof(long)) {
 740                 uint8_t *end1 = end - 1;
 741                 /*
 742                  * Slightly more advanced processing,
 743                  * able to >sizeof(long) bytes,
 744                  * when the actual value is small
 745                  * (0x0000000000abcdef would yield a fine 0x00abcdef)
 746                  */
 747                 /* Skip out the insignificant leading bytes */
 748                 for(; b < end1; b++) {
 749                         switch(*b) {
 750                         case 0x00: if((b[1] & 0x80) == 0) continue; break;
 751                         case 0xff: if((b[1] & 0x80) != 0) continue; break;
 752                         }
 753                         break;
 754                 }
 755
 756                 size = end - b;
 757                 if(size > sizeof(long)) {
 758                         /* Still cannot fit the long */
 759                         errno = ERANGE;
 760                         return -1;
 761                 }
 762         }
 763
 764         /* Shortcut processing of a corner case */
 765         if(end == b) {
 766                 *lptr = 0;
 767                 return 0;
 768         }
 769
 770         /* Perform the sign initialization */
 771         /* Actually l = -(*b >> 7); gains nothing, yet unreadable! */
 772         if((*b >> 7)) l = -1; else l = 0;
 773
 774         /* Conversion engine */
 775         for(; b < end; b++)
 776                 l = (l << 8) | *b;
 777
 778         *lptr = l;
 779         return 0;
 780 }
 781
 782 int
 783 asn_long2INTEGER(INTEGER_t *st, long value) {
 784         uint8_t *buf, *bp;
 785         uint8_t *p;
 786         uint8_t *pstart;
 787         uint8_t *pend1;
 788         int littleEndian = 1;   /* Run-time detection */
 789         int add;
 790
 791         if(!st) {
 792                 errno = EINVAL;
 793                 return -1;
 794         }
 795
 796         buf = (uint8_t *)MALLOC(sizeof(value));
 797         if(!buf) return -1;
 798
 799         if(*(char *)&littleEndian) {
 800                 pstart = (uint8_t *)&value + sizeof(value) - 1;
 801                 pend1 = (uint8_t *)&value;
 802                 add = -1;
 803         } else {
 804                 pstart = (uint8_t *)&value;
 805                 pend1 = pstart + sizeof(value) - 1;
 806                 add = 1;
 807         }
 808
 809         /*
 810          * If the contents octet consists of more than one octet,
 811          * then bits of the first octet and bit 8 of the second octet:
 812          * a) shall not all be ones; and
 813          * b) shall not all be zero.
 814          */
 815         for(p = pstart; p != pend1; p += add) {
 816                 switch(*p) {
 817                 case 0x00: if((*(p+add) & 0x80) == 0)
 818                                 continue;
 819                         break;
 820                 case 0xff: if((*(p+add) & 0x80))
 821                                 continue;
 822                         break;
 823                 }
 824                 break;
 825         }
 826         /* Copy the integer body */
 827         for(pstart = p, bp = buf, pend1 += add; p != pend1; p += add)
 828                 *bp++ = *p;
 829
 830         if(st->buf) FREEMEM(st->buf);
 831         st->buf = buf;
 832         st->size = bp - buf;
 833
 834         return 0;
 835 }