asn1/OBJECT_IDENTIFIER.c

   1 /*-
   2  * Copyright (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
   3  * Redistribution and modifications are permitted subject to BSD license.
   4  */
   5 #include <asn_internal.h>
   6 #include <OBJECT_IDENTIFIER.h>
   7 #include <OCTET_STRING.h>
   8 #include <limits.h>     /* for CHAR_BIT */
   9 #include <errno.h>
  10
  11 /*
  12  * OBJECT IDENTIFIER basic type description.
  13  */
  14 static ber_tlv_tag_t asn_DEF_OBJECT_IDENTIFIER_tags[] = {
  15         (ASN_TAG_CLASS_UNIVERSAL | (6 << 2))
  16 };
  17 asn_TYPE_descriptor_t asn_DEF_OBJECT_IDENTIFIER = {
  18         "OBJECT IDENTIFIER",
  19         "OBJECT_IDENTIFIER",
  20         ASN__PRIMITIVE_TYPE_free,
  21         OBJECT_IDENTIFIER_print,
  22         OBJECT_IDENTIFIER_constraint,
  23         ber_decode_primitive,
  24         der_encode_primitive,
  25         OBJECT_IDENTIFIER_decode_xer,
  26         OBJECT_IDENTIFIER_encode_xer,
  27         OCTET_STRING_decode_uper,
  28         OCTET_STRING_encode_uper,
  29         0, /* Use generic outmost tag fetcher */
  30         asn_DEF_OBJECT_IDENTIFIER_tags,
  31         sizeof(asn_DEF_OBJECT_IDENTIFIER_tags)
  32             / sizeof(asn_DEF_OBJECT_IDENTIFIER_tags[0]),
  33         asn_DEF_OBJECT_IDENTIFIER_tags, /* Same as above */
  34         sizeof(asn_DEF_OBJECT_IDENTIFIER_tags)
  35             / sizeof(asn_DEF_OBJECT_IDENTIFIER_tags[0]),
  36         0,      /* No PER visible constraints */
  37         0, 0,   /* No members */
  38         0       /* No specifics */
  39 };
  40
  41
  42 int
  43 OBJECT_IDENTIFIER_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
  44                 asn_app_constraint_failed_f *ctfailcb, void *app_key) {
  45         const OBJECT_IDENTIFIER_t *st = (const OBJECT_IDENTIFIER_t *)sptr;
  46
  47         if(st && st->buf) {
  48                 if(st->size < 1) {
  49                         _ASN_CTFAIL(app_key, td, sptr,
  50                                 "%s: at least one numerical value "
  51                                 "expected (%s:%d)",
  52                                 td->name, __FILE__, __LINE__);
  53                         return -1;
  54                 }
  55         } else {
  56                 _ASN_CTFAIL(app_key, td, sptr,
  57                         "%s: value not given (%s:%d)",
  58                         td->name, __FILE__, __LINE__);
  59                 return -1;
  60         }
  61
  62         return 0;
  63 }
  64
  65
  66 int
  67 OBJECT_IDENTIFIER_get_single_arc(uint8_t *arcbuf, unsigned int arclen, signed int add, void *rvbufp, unsigned int rvsize) {
  68         unsigned LE GCC_NOTUSED = 1; /* Little endian (x86) */
  69         uint8_t *arcend = arcbuf + arclen;      /* End of arc */
  70         unsigned int cache = 0; /* No more than 14 significant bits */
  71         unsigned char *rvbuf = (unsigned char *)rvbufp;
  72         unsigned char *rvstart = rvbuf; /* Original start of the value buffer */
  73         int inc;        /* Return value growth direction */
  74
  75         rvsize *= CHAR_BIT;     /* bytes to bits */
  76         arclen *= 7;            /* bytes to bits */
  77
  78         /*
  79          * The arc has the number of bits
  80          * cannot be represented using supplied return value type.
  81          */
  82         if(arclen > rvsize) {
  83                 if(arclen > (rvsize + CHAR_BIT)) {
  84                         errno = ERANGE; /* Overflow */
  85                         return -1;
  86                 } else {
  87                         /*
  88                          * Even if the number of bits in the arc representation
  89                          * is higher than the width of supplied * return value
  90                          * type, there is still possible to fit it when there
  91                          * are few unused high bits in the arc value
  92                          * representaion.
  93                          *
  94                          * Moreover, there is a possibility that the
  95                          * number could actually fit the arc space, given
  96                          * that add is negative, but we don't handle
  97                          * such "temporary lack of precision" situation here.
  98                          * May be considered as a bug.
  99                          */
 100                         uint8_t mask = (0xff << (7-(arclen - rvsize))) & 0x7f;
 101                         if((*arcbuf & mask)) {
 102                                 errno = ERANGE; /* Overflow */
 103                                 return -1;
 104                         }
 105                         /* Fool the routine computing unused bits */
 106                         arclen -= 7;
 107                         cache = *arcbuf & 0x7f;
 108                         arcbuf++;
 109                 }
 110         }
 111
 112         /* Faster path for common size */
 113         if(rvsize == (CHAR_BIT * sizeof(unsigned long))) {
 114                 unsigned long accum;
 115                 /* Gather all bits into the accumulator */
 116                 for(accum = cache; arcbuf < arcend; arcbuf++)
 117                         accum = (accum << 7) | (*arcbuf & ~0x80);
 118                 if(accum < (unsigned)-add) {
 119                         errno = ERANGE; /* Overflow */
 120                         return -1;
 121                 }
 122                 *(unsigned long *)rvbuf = accum + add;  /* alignment OK! */
 123                 return 0;
 124         }
 125
 126 #ifndef WORDS_BIGENDIAN
 127         if(*(unsigned char *)&LE) {     /* Little endian (x86) */
 128                 /* "Convert" to big endian */
 129                 rvbuf += rvsize / CHAR_BIT - 1;
 130                 rvstart--;
 131                 inc = -1;       /* Descending */
 132         } else
 133 #endif  /* !WORDS_BIGENDIAN */
 134                 inc = +1;       /* Big endian is known [at compile time] */
 135
 136         {
 137                 int bits;       /* typically no more than 3-4 bits */
 138
 139                 /* Clear the high unused bits */
 140                 for(bits = rvsize - arclen;
 141                         bits > CHAR_BIT;
 142                                 rvbuf += inc, bits -= CHAR_BIT)
 143                                 *rvbuf = 0;
 144
 145                 /* Fill the body of a value */
 146                 for(; arcbuf < arcend; arcbuf++) {
 147                         cache = (cache << 7) | (*arcbuf & 0x7f);
 148                         bits += 7;
 149                         if(bits >= CHAR_BIT) {
 150                                 bits -= CHAR_BIT;
 151                                 *rvbuf = (cache >> bits);
 152                                 rvbuf += inc;
 153                         }
 154                 }
 155                 if(bits) {
 156                         *rvbuf = cache;
 157                         rvbuf += inc;
 158                 }
 159         }
 160
 161         if(add) {
 162                 for(rvbuf -= inc; rvbuf != rvstart; rvbuf -= inc) {
 163                         int v = add + *rvbuf;
 164                         if(v & (-1 << CHAR_BIT)) {
 165                                 *rvbuf = (unsigned char)(v + (1 << CHAR_BIT));
 166                                 add = -1;
 167                         } else {
 168                                 *rvbuf = v;
 169                                 break;
 170                         }
 171                 }
 172                 if(rvbuf == rvstart) {
 173                         /* No space to carry over */
 174                         errno = ERANGE; /* Overflow */
 175                         return -1;
 176                 }
 177         }
 178
 179         return 0;
 180 }
 181
 182 ssize_t
 183 OBJECT_IDENTIFIER__dump_arc(uint8_t *arcbuf, int arclen, int add,
 184                 asn_app_consume_bytes_f *cb, void *app_key) {
 185         char scratch[64];       /* Conservative estimate */
 186         unsigned long accum;    /* Bits accumulator */
 187         char *p;                /* Position in the scratch buffer */
 188
 189         if(OBJECT_IDENTIFIER_get_single_arc(arcbuf, arclen, add,
 190                         &accum, sizeof(accum)))
 191                 return -1;
 192
 193         if(accum) {
 194                 ssize_t len;
 195
 196                 /* Fill the scratch buffer in reverse. */
 197                 p = scratch + sizeof(scratch);
 198                 for(; accum; accum /= 10)
 199                         *(--p) = (char)(accum % 10) + 0x30; /* Put a digit */
 200
 201                 len = sizeof(scratch) - (p - scratch);
 202                 if(cb(p, len, app_key) < 0)
 203                         return -1;
 204                 return len;
 205         } else {
 206                 *scratch = 0x30;
 207                 if(cb(scratch, 1, app_key) < 0)
 208                         return -1;
 209                 return 1;
 210         }
 211 }
 212
 213 int
 214 OBJECT_IDENTIFIER_print_arc(uint8_t *arcbuf, int arclen, int add,
 215                 asn_app_consume_bytes_f *cb, void *app_key) {
 216
 217         if(OBJECT_IDENTIFIER__dump_arc(arcbuf, arclen, add, cb, app_key) < 0)
 218                 return -1;
 219
 220         return 0;
 221 }
 222
 223 static ssize_t
 224 OBJECT_IDENTIFIER__dump_body(const OBJECT_IDENTIFIER_t *st, asn_app_consume_bytes_f *cb, void *app_key) {
 225         ssize_t wrote_len = 0;
 226         int startn;
 227         int add = 0;
 228         int i;
 229
 230         for(i = 0, startn = 0; i < st->size; i++) {
 231                 uint8_t b = st->buf[i];
 232                 if((b & 0x80))                  /* Continuation expected */
 233                         continue;
 234
 235                 if(startn == 0) {
 236                         /*
 237                          * First two arcs are encoded through the backdoor.
 238                          */
 239                         if(i) {
 240                                 add = -80;
 241                                 if(cb("2", 1, app_key) < 0) return -1;
 242                         } else if(b <= 39) {
 243                                 add = 0;
 244                                 if(cb("0", 1, app_key) < 0) return -1;
 245                         } else if(b < 79) {
 246                                 add = -40;
 247                                 if(cb("1", 1, app_key) < 0) return -1;
 248                         } else {
 249                                 add = -80;
 250                                 if(cb("2", 1, app_key) < 0) return -1;
 251                         }
 252                         wrote_len += 1;
 253                 }
 254
 255                 if(cb(".", 1, app_key) < 0)     /* Separate arcs */
 256                         return -1;
 257
 258                 add = OBJECT_IDENTIFIER__dump_arc(&st->buf[startn],
 259                                 i - startn + 1, add, cb, app_key);
 260                 if(add < 0) return -1;
 261                 wrote_len += 1 + add;
 262                 startn = i + 1;
 263                 add = 0;
 264         }
 265
 266         return wrote_len;
 267 }
 268
 269 static enum xer_pbd_rval
 270 OBJECT_IDENTIFIER__xer_body_decode(asn_TYPE_descriptor_t *td, void *sptr, const void *chunk_buf, size_t chunk_size) {
 271         OBJECT_IDENTIFIER_t *st = (OBJECT_IDENTIFIER_t *)sptr;
 272         const char *chunk_end = (const char *)chunk_buf + chunk_size;
 273         const char *endptr;
 274         long s_arcs[10];
 275         long *arcs = s_arcs;
 276         int arcs_count;
 277         int ret;
 278
 279         (void)td;
 280
 281         arcs_count = OBJECT_IDENTIFIER_parse_arcs(
 282                 (const char *)chunk_buf, chunk_size, arcs,
 283                         sizeof(s_arcs)/sizeof(s_arcs[0]), &endptr);
 284         if(arcs_count <= 0) {
 285                 /* Expecting more than zero arcs */
 286                 return XPBD_BROKEN_ENCODING;
 287         }
 288         if(endptr < chunk_end) {
 289                 /* We have a tail of unrecognized data. Check its safety. */
 290                 if(!xer_is_whitespace(endptr, chunk_end - endptr))
 291                         return XPBD_BROKEN_ENCODING;
 292         }
 293
 294         if((size_t)arcs_count > sizeof(s_arcs)/sizeof(s_arcs[0])) {
 295                 arcs = (long *)MALLOC(arcs_count * sizeof(long));
 296                 if(!arcs) return XPBD_SYSTEM_FAILURE;
 297                 ret = OBJECT_IDENTIFIER_parse_arcs(
 298                         (const char *)chunk_buf, chunk_size,
 299                         arcs, arcs_count, &endptr);
 300                 if(ret != arcs_count)
 301                         return XPBD_SYSTEM_FAILURE;     /* assert?.. */
 302         }
 303
 304         /*
 305          * Convert arcs into BER representation.
 306          */
 307         ret = OBJECT_IDENTIFIER_set_arcs(st, arcs, sizeof(*arcs), arcs_count);
 308         if(arcs != s_arcs) FREEMEM(arcs);
 309
 310         return ret ? XPBD_SYSTEM_FAILURE : XPBD_BODY_CONSUMED;
 311 }
 312
 313 asn_dec_rval_t
 314 OBJECT_IDENTIFIER_decode_xer(asn_codec_ctx_t *opt_codec_ctx,
 315         asn_TYPE_descriptor_t *td, void **sptr, const char *opt_mname,
 316                 const void *buf_ptr, size_t size) {
 317
 318         return xer_decode_primitive(opt_codec_ctx, td,
 319                 sptr, sizeof(OBJECT_IDENTIFIER_t), opt_mname,
 320                         buf_ptr, size, OBJECT_IDENTIFIER__xer_body_decode);
 321 }
 322
 323 asn_enc_rval_t
 324 OBJECT_IDENTIFIER_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
 325         int ilevel, enum xer_encoder_flags_e flags,
 326                 asn_app_consume_bytes_f *cb, void *app_key) {
 327         const OBJECT_IDENTIFIER_t *st = (const OBJECT_IDENTIFIER_t *)sptr;
 328         asn_enc_rval_t er;
 329
 330         (void)ilevel;
 331         (void)flags;
 332
 333         if(!st || !st->buf)
 334                 _ASN_ENCODE_FAILED;
 335
 336         er.encoded = OBJECT_IDENTIFIER__dump_body(st, cb, app_key);
 337         if(er.encoded < 0) _ASN_ENCODE_FAILED;
 338
 339         _ASN_ENCODED_OK(er);
 340 }
 341
 342 int
 343 OBJECT_IDENTIFIER_print(asn_TYPE_descriptor_t *td, const void *sptr,
 344         int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
 345         const OBJECT_IDENTIFIER_t *st = (const OBJECT_IDENTIFIER_t *)sptr;
 346
 347         (void)td;       /* Unused argument */
 348         (void)ilevel;   /* Unused argument */
 349
 350         if(!st || !st->buf)
 351                 return (cb("<absent>", 8, app_key) < 0) ? -1 : 0;
 352
 353         /* Dump preamble */
 354         if(cb("{ ", 2, app_key) < 0)
 355                 return -1;
 356
 357         if(OBJECT_IDENTIFIER__dump_body(st, cb, app_key) < 0)
 358                 return -1;
 359
 360         return (cb(" }", 2, app_key) < 0) ? -1 : 0;
 361 }
 362
 363 int
 364 OBJECT_IDENTIFIER_get_arcs(OBJECT_IDENTIFIER_t *oid, void *arcs,
 365                 unsigned int arc_type_size, unsigned int arc_slots) {
 366         void *arcs_end = (char *)arcs + (arc_type_size * arc_slots);
 367         int num_arcs = 0;
 368         int startn = 0;
 369         int add = 0;
 370         int i;
 371
 372         if(!oid || !oid->buf || (arc_slots && arc_type_size <= 1)) {
 373                 errno = EINVAL;
 374                 return -1;
 375         }
 376
 377         for(i = 0; i < oid->size; i++) {
 378                 uint8_t b = oid->buf[i];
 379                 if((b & 0x80))                  /* Continuation expected */
 380                         continue;
 381
 382                 if(num_arcs == 0) {
 383                         /*
 384                          * First two arcs are encoded through the backdoor.
 385                          */
 386                         unsigned LE = 1;        /* Little endian */
 387                         int first_arc;
 388                         num_arcs++;
 389                         if(!arc_slots) { num_arcs++; continue; }
 390
 391                         if(i) first_arc = 2;
 392                         else if(b <= 39) first_arc = 0;
 393                         else if(b < 79) first_arc = 1;
 394                         else first_arc = 2;
 395
 396                         add = -40 * first_arc;
 397                         memset(arcs, 0, arc_type_size);
 398                         *(unsigned char *)((char *)arcs
 399                                 + ((*(char *)&LE)?0:(arc_type_size - 1)))
 400                                         = first_arc;
 401                         arcs = ((char *)arcs) + arc_type_size;
 402                 }
 403
 404                 /* Decode, if has space */
 405                 if(arcs < arcs_end) {
 406                         if(OBJECT_IDENTIFIER_get_single_arc(&oid->buf[startn],
 407                                 i - startn + 1, add,
 408                                         arcs, arc_type_size))
 409                                 return -1;
 410                         startn = i + 1;
 411                         arcs = ((char *)arcs) + arc_type_size;
 412                         add = 0;
 413                 }
 414                 num_arcs++;
 415         }
 416
 417         return num_arcs;
 418 }
 419
 420
 421 /*
 422  * Save the single value as an object identifier arc.
 423  */
 424 int
 425 OBJECT_IDENTIFIER_set_single_arc(uint8_t *arcbuf, const void *arcval, unsigned int arcval_size, int prepared_order) {
 426         /*
 427          * The following conditions must hold:
 428          * assert(arcval);
 429          * assert(arcval_size > 0);
 430          * assert(arcval_size <= 16);
 431          * assert(arcbuf);
 432          */
 433 #ifdef  WORDS_BIGENDIAN
 434         const unsigned isLittleEndian = 0;
 435 #else
 436         unsigned LE = 1;
 437         unsigned isLittleEndian = *(char *)&LE;
 438 #endif
 439         const uint8_t *tend, *tp;
 440         unsigned int cache;
 441         uint8_t *bp = arcbuf;
 442         int bits;
 443         uint8_t buffer[16];
 444
 445         if(isLittleEndian && !prepared_order) {
 446                 const uint8_t *a = (const unsigned char *)arcval + arcval_size - 1;
 447                 const uint8_t *aend = (const uint8_t *)arcval;
 448                 uint8_t *msb = buffer + arcval_size - 1;
 449                 uint8_t *tb;
 450                 for(tb = buffer; a >= aend; tb++, a--)
 451                         if((*tb = *a) && (tb < msb))
 452                                 msb = tb;
 453                 tend = &buffer[arcval_size];
 454                 tp = msb;       /* Most significant non-zero byte */
 455         } else {
 456                 /* Look for most significant non-zero byte */
 457                 tend = (const unsigned char *)arcval + arcval_size;
 458                 for(tp = (const uint8_t *)arcval; tp < tend - 1; tp++)
 459                         if(*tp) break;
 460         }
 461
 462         /*
 463          * Split the value in 7-bits chunks.
 464          */
 465         bits = ((tend - tp) * CHAR_BIT) % 7;
 466         if(bits) {
 467                 cache = *tp >> (CHAR_BIT - bits);
 468                 if(cache) {
 469                         *bp++ = cache | 0x80;
 470                         cache = *tp++;
 471                         bits = CHAR_BIT - bits;
 472                 } else {
 473                         bits = -bits;
 474                 }
 475         } else {
 476                 cache = 0;
 477         }
 478         for(; tp < tend; tp++) {
 479                 cache = (cache << CHAR_BIT) + *tp;
 480                 bits += CHAR_BIT;
 481                 while(bits >= 7) {
 482                         bits -= 7;
 483                         *bp++ = 0x80 | (cache >> bits);
 484                 }
 485         }
 486         if(bits) *bp++ = cache;
 487         bp[-1] &= 0x7f; /* Clear the last bit */
 488
 489         return bp - arcbuf;
 490 }
 491
 492 int
 493 OBJECT_IDENTIFIER_set_arcs(OBJECT_IDENTIFIER_t *oid, const void *arcs, unsigned int arc_type_size, unsigned int arc_slots) {
 494         uint8_t *buf;
 495         uint8_t *bp;
 496         unsigned LE = 1;        /* Little endian (x86) */
 497         unsigned isLittleEndian = *((char *)&LE);
 498         unsigned int arc0;
 499         unsigned int arc1;
 500         unsigned size;
 501         unsigned i;
 502
 503         if(!oid || !arcs || arc_type_size < 1
 504         || arc_type_size > 16
 505         || arc_slots < 2) {
 506                 errno = EINVAL;
 507                 return -1;
 508         }
 509
 510         switch(arc_type_size) {
 511         case sizeof(char):
 512                 arc0 = ((const unsigned char *)arcs)[0];
 513                 arc1 = ((const unsigned char *)arcs)[1];
 514                 break;
 515         case sizeof(short):
 516                 arc0 = ((const unsigned short *)arcs)[0];
 517                 arc1 = ((const unsigned short *)arcs)[1];
 518                 break;
 519         case sizeof(int):
 520                 arc0 = ((const unsigned int *)arcs)[0];
 521                 arc1 = ((const unsigned int *)arcs)[1];
 522                 break;
 523         default:
 524                 arc1 = arc0 = 0;
 525                 if(isLittleEndian) {    /* Little endian (x86) */
 526                         const unsigned char *ps, *pe;
 527                         /* If more significant bytes are present,
 528                          * make them > 255 quick */
 529                         for(ps = (const unsigned char *)arcs + 1, pe = ps+arc_type_size;
 530                                         ps < pe; ps++)
 531                                 arc0 |= *ps, arc1 |= *(ps + arc_type_size);
 532                         arc0 <<= CHAR_BIT, arc1 <<= CHAR_BIT;
 533                         arc0 = *((const unsigned char *)arcs + 0);
 534                         arc1 = *((const unsigned char *)arcs + arc_type_size);
 535                 } else {
 536                         const unsigned char *ps, *pe;
 537                         /* If more significant bytes are present,
 538                          * make them > 255 quick */
 539                         for(ps = (const unsigned char *)arcs, pe = ps+arc_type_size - 1; ps < pe; ps++)
 540                                 arc0 |= *ps, arc1 |= *(ps + arc_type_size);
 541                         arc0 = *((const unsigned char *)arcs + arc_type_size - 1);
 542                         arc1 = *((const unsigned char *)arcs +(arc_type_size<< 1)-1);
 543                 }
 544         }
 545
 546         /*
 547          * The previous chapter left us with the first and the second arcs.
 548          * The values are not precise (that is, they are valid only if
 549          * they're less than 255), but OK for the purposes of making
 550          * the sanity test below.
 551          */
 552         if(arc0 <= 1) {
 553                 if(arc1 >= 39) {
 554                         /* 8.19.4: At most 39 subsequent values (including 0) */
 555                         errno = ERANGE;
 556                         return -1;
 557                 }
 558         } else if(arc0 > 2) {
 559                 /* 8.19.4: Only three values are allocated from the root node */
 560                 errno = ERANGE;
 561                 return -1;
 562         }
 563         /*
 564          * After above tests it is known that the value of arc0 is completely
 565          * trustworthy (0..2). However, the arc1's value is still meaningless.
 566          */
 567
 568         /*
 569          * Roughly estimate the maximum size necessary to encode these arcs.
 570          * This estimation implicitly takes in account the following facts,
 571          * that cancel each other:
 572          *      * the first two arcs are encoded in a single value.
 573          *      * the first value may require more space (+1 byte)
 574          *      * the value of the first arc which is in range (0..2)
 575          */
 576         size = ((arc_type_size * CHAR_BIT + 6) / 7) * arc_slots;
 577         bp = buf = (uint8_t *)MALLOC(size + 1);
 578         if(!buf) {
 579                 /* ENOMEM */
 580                 return -1;
 581         }
 582
 583         /*
 584          * Encode the first two arcs.
 585          * These require special treatment.
 586          */
 587         {
 588                 uint8_t *tp;
 589                 uint8_t first_value[1 + 16];    /* of two arcs */
 590                 uint8_t *fv = first_value;
 591
 592                 /*
 593                  * Simulate first_value = arc0 * 40 + arc1;
 594                  */
 595                 /* Copy the second (1'st) arcs[1] into the first_value */
 596                 *fv++ = 0;
 597                 arcs = ((const char *)arcs) + arc_type_size;
 598                 if(isLittleEndian) {
 599                         const uint8_t *aend = (const unsigned char *)arcs - 1;
 600                         const uint8_t *a1 = (const unsigned char *)arcs + arc_type_size - 1;
 601                         for(; a1 > aend; fv++, a1--) *fv = *a1;
 602                 } else {
 603                         const uint8_t *a1 = (const uint8_t *)arcs;
 604                         const uint8_t *aend = a1 + arc_type_size;
 605                         for(; a1 < aend; fv++, a1++) *fv = *a1;
 606                 }
 607                 /* Increase the first_value by arc0 */
 608                 arc0 *= 40;     /* (0..80) */
 609                 for(tp = first_value + arc_type_size; tp >= first_value; tp--) {
 610                         unsigned int v = *tp;
 611                         v += arc0;
 612                         *tp = v;
 613                         if(v >= (1 << CHAR_BIT)) arc0 = v >> CHAR_BIT;
 614                         else break;
 615                 }
 616
 617                 assert(tp >= first_value);
 618
 619                 bp += OBJECT_IDENTIFIER_set_single_arc(bp, first_value,
 620                         fv - first_value, 1);
 621         }
 622
 623         /*
 624          * Save the rest of arcs.
 625          */
 626         for(arcs = ((const char *)arcs) + arc_type_size, i = 2;
 627                 i < arc_slots;
 628                         i++, arcs = ((const char *)arcs) + arc_type_size) {
 629                 bp += OBJECT_IDENTIFIER_set_single_arc(bp,
 630                         arcs, arc_type_size, 0);
 631         }
 632
 633         assert((unsigned)(bp - buf) <= size);
 634
 635         /*
 636          * Replace buffer.
 637          */
 638         oid->size = bp - buf;
 639         bp = oid->buf;
 640         oid->buf = buf;
 641         if(bp) FREEMEM(bp);
 642
 643         return 0;
 644 }
 645
 646
 647 int
 648 OBJECT_IDENTIFIER_parse_arcs(const char *oid_text, ssize_t oid_txt_length,
 649         long *arcs, unsigned int arcs_slots, const char **opt_oid_text_end) {
 650         unsigned int arcs_count = 0;
 651         const char *oid_end;
 652         long value = 0;
 653         enum {
 654                 ST_SKIPSPACE,
 655                 ST_WAITDIGITS,  /* Next character is expected to be a digit */
 656                 ST_DIGITS
 657         } state = ST_SKIPSPACE;
 658
 659         if(!oid_text || oid_txt_length < -1 || (arcs_slots && !arcs)) {
 660                 if(opt_oid_text_end) *opt_oid_text_end = oid_text;
 661                 errno = EINVAL;
 662                 return -1;
 663         }
 664
 665         if(oid_txt_length == -1)
 666                 oid_txt_length = strlen(oid_text);
 667
 668         for(oid_end = oid_text + oid_txt_length; oid_text<oid_end; oid_text++) {
 669             switch(*oid_text) {
 670             case 0x09: case 0x0a: case 0x0d: case 0x20: /* whitespace */
 671                 if(state == ST_SKIPSPACE) {
 672                         continue;
 673                 } else {
 674                         break;  /* Finish */
 675                 }
 676             case 0x2e:  /* '.' */
 677                 if(state != ST_DIGITS
 678                 || (oid_text + 1) == oid_end) {
 679                         state = ST_WAITDIGITS;
 680                         break;
 681                 }
 682                 if(arcs_count < arcs_slots)
 683                         arcs[arcs_count] = value;
 684                 arcs_count++;
 685                 state = ST_WAITDIGITS;
 686                 continue;
 687             case 0x30: case 0x31: case 0x32: case 0x33: case 0x34:
 688             case 0x35: case 0x36: case 0x37: case 0x38: case 0x39:
 689                 if(state != ST_DIGITS) {
 690                         state = ST_DIGITS;
 691                         value = 0;
 692                 }
 693                 if(1) {
 694                         long volatile new_value = value * 10;
 695                         /* GCC 4.x is being too smart without volatile */
 696                         if(new_value / 10 != value
 697                         || (value = new_value + (*oid_text - 0x30)) < 0) {
 698                                 /* Overflow */
 699                                 state = ST_WAITDIGITS;
 700                                 break;
 701                         }
 702                         continue;
 703                 }
 704             default:
 705                 /* Unexpected symbols */
 706                 state = ST_WAITDIGITS;
 707                 break;
 708             } /* switch() */
 709             break;
 710         } /* for() */
 711
 712
 713         if(opt_oid_text_end) *opt_oid_text_end = oid_text;
 714
 715         /* Finalize last arc */
 716         switch(state) {
 717         case ST_WAITDIGITS:
 718                 errno = EINVAL;
 719                 return -1;
 720         case ST_DIGITS:
 721                 if(arcs_count < arcs_slots)
 722                         arcs[arcs_count] = value;
 723                 arcs_count++;
 724                 /* Fall through */
 725         default:
 726                 return arcs_count;
 727         }
 728 }
 729
 730