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