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