More std::jthread stuff.

[stg.git] / libs / smux / OBJECT_IDENTIFIER.c

diff --git a/libs/smux/OBJECT_IDENTIFIER.c b/libs/smux/OBJECT_IDENTIFIER.c
index d0367f0f2abee4384c2bcbb4fe8053712bd81654..290545d1c2e76c60ce7b879095508909671eb6bd 100644 (file)
--- a/libs/smux/OBJECT_IDENTIFIER.c
+++ b/libs/smux/OBJECT_IDENTIFIER.c
@@ -3,55 +3,74 @@
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #include <asn_internal.h>
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #include <asn_internal.h>

+#include <INTEGER.h>

 #include <OBJECT_IDENTIFIER.h>
 #include <OBJECT_IDENTIFIER.h>

+#include <OCTET_STRING.h>

 #include <limits.h>    /* for CHAR_BIT */
 #include <errno.h>
 
 /*
  * OBJECT IDENTIFIER basic type description.
  */
 #include <limits.h>    /* for CHAR_BIT */
 #include <errno.h>
 
 /*
  * OBJECT IDENTIFIER basic type description.
  */

-static ber_tlv_tag_t asn_DEF_OBJECT_IDENTIFIER_tags[] = {
+static const ber_tlv_tag_t asn_DEF_OBJECT_IDENTIFIER_tags[] = {

        (ASN_TAG_CLASS_UNIVERSAL | (6 << 2))
 };
        (ASN_TAG_CLASS_UNIVERSAL | (6 << 2))
 };

-asn_TYPE_descriptor_t asn_DEF_OBJECT_IDENTIFIER = {
-       "OBJECT IDENTIFIER",
-       "OBJECT_IDENTIFIER",
+asn_TYPE_operation_t asn_OP_OBJECT_IDENTIFIER = {

        ASN__PRIMITIVE_TYPE_free,
        OBJECT_IDENTIFIER_print,
        ASN__PRIMITIVE_TYPE_free,
        OBJECT_IDENTIFIER_print,

-       OBJECT_IDENTIFIER_constraint,
+       OCTET_STRING_compare,   /* Implemented in terms of a string comparison */

        ber_decode_primitive,
        der_encode_primitive,
        OBJECT_IDENTIFIER_decode_xer,
        OBJECT_IDENTIFIER_encode_xer,
        ber_decode_primitive,
        der_encode_primitive,
        OBJECT_IDENTIFIER_decode_xer,
        OBJECT_IDENTIFIER_encode_xer,

-       0, 0,
-       0, /* Use generic outmost tag fetcher */
+#ifdef ASN_DISABLE_OER_SUPPORT
+       0,
+       0,
+#else
+       OBJECT_IDENTIFIER_decode_oer,
+       OBJECT_IDENTIFIER_encode_oer,
+#endif  /* ASN_DISABLE_OER_SUPPORT */
+#ifdef ASN_DISABLE_PER_SUPPORT
+       0,
+       0,
+#else
+       OCTET_STRING_decode_uper,
+       OCTET_STRING_encode_uper,
+#endif /* ASN_DISABLE_PER_SUPPORT */
+       OBJECT_IDENTIFIER_random_fill,
+       0       /* Use generic outmost tag fetcher */
+};
+asn_TYPE_descriptor_t asn_DEF_OBJECT_IDENTIFIER = {
+       "OBJECT IDENTIFIER",
+       "OBJECT_IDENTIFIER",
+       &asn_OP_OBJECT_IDENTIFIER,

        asn_DEF_OBJECT_IDENTIFIER_tags,
        sizeof(asn_DEF_OBJECT_IDENTIFIER_tags)
            / sizeof(asn_DEF_OBJECT_IDENTIFIER_tags[0]),
        asn_DEF_OBJECT_IDENTIFIER_tags, /* Same as above */
        sizeof(asn_DEF_OBJECT_IDENTIFIER_tags)
            / sizeof(asn_DEF_OBJECT_IDENTIFIER_tags[0]),
        asn_DEF_OBJECT_IDENTIFIER_tags,
        sizeof(asn_DEF_OBJECT_IDENTIFIER_tags)
            / sizeof(asn_DEF_OBJECT_IDENTIFIER_tags[0]),
        asn_DEF_OBJECT_IDENTIFIER_tags, /* Same as above */
        sizeof(asn_DEF_OBJECT_IDENTIFIER_tags)
            / sizeof(asn_DEF_OBJECT_IDENTIFIER_tags[0]),

-       0,      /* No PER visible constraints */
+       { 0, 0, OBJECT_IDENTIFIER_constraint },

        0, 0,   /* No members */
        0       /* No specifics */
 };
 
        0, 0,   /* No members */
        0       /* No specifics */
 };
 

-

 int
 int

-OBJECT_IDENTIFIER_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
-               asn_app_constraint_failed_f *ctfailcb, void *app_key) {
-       const OBJECT_IDENTIFIER_t *st = (const OBJECT_IDENTIFIER_t *)sptr;
+OBJECT_IDENTIFIER_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
+                             asn_app_constraint_failed_f *ctfailcb,
+                             void *app_key) {
+    const OBJECT_IDENTIFIER_t *st = (const OBJECT_IDENTIFIER_t *)sptr;

 
        if(st && st->buf) {
                if(st->size < 1) {
 
        if(st && st->buf) {
                if(st->size < 1) {

-                       _ASN_CTFAIL(app_key, td,
+                       ASN__CTFAIL(app_key, td, sptr,

                                "%s: at least one numerical value "
                                "expected (%s:%d)",
                                td->name, __FILE__, __LINE__);
                        return -1;
                }
        } else {
                                "%s: at least one numerical value "
                                "expected (%s:%d)",
                                td->name, __FILE__, __LINE__);
                        return -1;
                }
        } else {

-               _ASN_CTFAIL(app_key, td,
+               ASN__CTFAIL(app_key, td, sptr,

                        "%s: value not given (%s:%d)",
                        td->name, __FILE__, __LINE__);
                return -1;
                        "%s: value not given (%s:%d)",
                        td->name, __FILE__, __LINE__);
                return -1;


@@ -60,285 +79,186 @@ OBJECT_IDENTIFIER_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
        return 0;
 }
 
        return 0;
 }
 

-
-int
-OBJECT_IDENTIFIER_get_single_arc(uint8_t *arcbuf, unsigned int arclen, signed int add, void *rvbufp, unsigned int rvsize) {
-       unsigned LE __attribute__ ((unused)) = 1; /* Little endian (x86) */
-       uint8_t *arcend = arcbuf + arclen;      /* End of arc */
-       unsigned int cache = 0; /* No more than 14 significant bits */
-       unsigned char *rvbuf = (unsigned char *)rvbufp;
-       unsigned char *rvstart = rvbuf; /* Original start of the value buffer */
-       int inc;        /* Return value growth direction */
-
-       rvsize *= CHAR_BIT;     /* bytes to bits */
-       arclen *= 7;            /* bytes to bits */
-
-       /*
-        * The arc has the number of bits
-        * cannot be represented using supplied return value type.
-        */
-       if(arclen > rvsize) {
-               if(arclen > (rvsize + CHAR_BIT)) {
-                       errno = ERANGE; /* Overflow */
-                       return -1;
-               } else {
-                       /*
-                        * Even if the number of bits in the arc representation
-                        * is higher than the width of supplied * return value
-                        * type, there is still possible to fit it when there
-                        * are few unused high bits in the arc value
-                        * representaion.
-                        * 
-                        * Moreover, there is a possibility that the
-                        * number could actually fit the arc space, given
-                        * that add is negative, but we don't handle
-                        * such "temporary lack of precision" situation here.
-                        * May be considered as a bug.
-                        */
-                       uint8_t mask = (0xff << (7-(arclen - rvsize))) & 0x7f;
-                       if((*arcbuf & mask)) {
-                               errno = ERANGE; /* Overflow */
-                               return -1;
-                       }
-                       /* Fool the routine computing unused bits */
-                       arclen -= 7;
-                       cache = *arcbuf & 0x7f;
-                       arcbuf++;
-               }
-       }
-
-       /* Faster path for common size */
-       if(rvsize == (CHAR_BIT * sizeof(unsigned long))) {
-               unsigned long accum;
-               /* Gather all bits into the accumulator */
-               for(accum = cache; arcbuf < arcend; arcbuf++)
-                       accum = (accum << 7) | (*arcbuf & ~0x80);
-               if(accum < (unsigned)-add) {
-                       errno = ERANGE; /* Overflow */
-                       return -1;
-               }
-               *(unsigned long *)rvbuf = accum + add;  /* alignment OK! */
-               return 0;
-       }
-
-#ifndef        WORDS_BIGENDIAN
-       if(*(unsigned char *)&LE) {     /* Little endian (x86) */
-               /* "Convert" to big endian */
-               rvbuf += rvsize / CHAR_BIT - 1;
-               rvstart--;
-               inc = -1;       /* Descending */
-       } else
-#endif /* !WORDS_BIGENDIAN */
-               inc = +1;       /* Big endian is known [at compile time] */
-
-       {
-               int bits;       /* typically no more than 3-4 bits */
-
-               /* Clear the high unused bits */
-               for(bits = rvsize - arclen;
-                       bits > CHAR_BIT;
-                               rvbuf += inc, bits -= CHAR_BIT)
-                               *rvbuf = 0;
-
-               /* Fill the body of a value */
-               for(; arcbuf < arcend; arcbuf++) {
-                       cache = (cache << 7) | (*arcbuf & 0x7f);
-                       bits += 7;
-                       if(bits >= CHAR_BIT) {
-                               bits -= CHAR_BIT;
-                               *rvbuf = (cache >> bits);
-                               rvbuf += inc;
-                       }
-               }
-               if(bits) {
-                       *rvbuf = cache;
-                       rvbuf += inc;
-               }
-       }
-
-       if(add) {
-               for(rvbuf -= inc; rvbuf != rvstart; rvbuf -= inc) {
-                       int v = add + *rvbuf;
-                       if(v & (-1 << CHAR_BIT)) {
-                               *rvbuf = (unsigned char)(v + (1 << CHAR_BIT));
-                               add = -1;
-                       } else {
-                               *rvbuf = v;
-                               break;
-                       }
-               }
-               if(rvbuf == rvstart) {
-                       /* No space to carry over */
-                       errno = ERANGE; /* Overflow */
-                       return -1;
-               }
-       }
-
-       return 0;
+static ssize_t
+OBJECT_IDENTIFIER_get_first_arcs(const uint8_t *arcbuf, size_t arcbuf_len,
+                                 asn_oid_arc_t *arc0, asn_oid_arc_t *arc1) {
+    asn_oid_arc_t value;
+
+    ssize_t rd = OBJECT_IDENTIFIER_get_single_arc(arcbuf, arcbuf_len, &value);
+    if(rd <= 0) return rd;
+
+    if(value >= 80) {
+        *arc0 = 2;
+        *arc1 = value - 80;
+    } else if(value >= 40) {
+        *arc0 = 1;
+        *arc1 = value - 40;
+    } else {
+        *arc0 = 0;
+        *arc1 = value;
+    }
+
+    return rd;

 }
 
 ssize_t
 }
 
 ssize_t

-OBJECT_IDENTIFIER__dump_arc(uint8_t *arcbuf, int arclen, int add,
-               asn_app_consume_bytes_f *cb, void *app_key) {
-       char scratch[64];       /* Conservative estimate */
-       unsigned long accum;    /* Bits accumulator */
+OBJECT_IDENTIFIER_get_single_arc(const uint8_t *arcbuf, size_t arcbuf_len,
+                                 asn_oid_arc_t *ret_value) {
+    const uint8_t *b = arcbuf;
+    const uint8_t *arcend = arcbuf + arcbuf_len; /* End of arc */
+
+    if(arcbuf == arcend) {
+        return 0;
+    } else {
+        asn_oid_arc_t accum;
+        /* Gather all bits into the accumulator */
+        for(accum = 0; b < arcend; b++) {
+            accum = (accum << 7) | (*b & ~0x80);
+            if((*b & 0x80) == 0) {
+                if(accum <= ASN_OID_ARC_MAX) {
+                    *ret_value = accum;
+                    return 1 + (b - arcbuf);
+                } else {
+                    errno = ERANGE; /* Overflow */
+                    return -1;
+                }
+            }
+        }
+        errno = EINVAL;
+        return -1;
+    }

 
 

-       if(OBJECT_IDENTIFIER_get_single_arc(arcbuf, arclen, add,
-                       &accum, sizeof(accum)))
-               return -1;
-
-       if(accum) {
-               ssize_t len;
-               char *p = scratch + sizeof(scratch);            /* Position in the scratch buffer */
-
-               for(; accum; accum /= 10)
-                       *(--p) = (char)(accum % 10) + 0x30; /* Put a digit */
-
-               len = sizeof(scratch) - (p - scratch);
-               if(cb(p, len, app_key) < 0)
-                       return -1;
-               return len;
-       } else {
-               *scratch = 0x30;
-               if(cb(scratch, 1, app_key) < 0)
-                       return -1;
-               return 1;
-       }
-}
-
-int
-OBJECT_IDENTIFIER_print_arc(uint8_t *arcbuf, int arclen, int add,
-               asn_app_consume_bytes_f *cb, void *app_key) {
-
-       if(OBJECT_IDENTIFIER__dump_arc(arcbuf, arclen, add, cb, app_key) < 0)
-               return -1;
-
-       return 0;

 }
 
 static ssize_t
 }
 
 static ssize_t

-OBJECT_IDENTIFIER__dump_body(const OBJECT_IDENTIFIER_t *st, asn_app_consume_bytes_f *cb, void *app_key) {
-       ssize_t wrote_len = 0;
-       int startn;
-       int add = 0;
-       int i;
-
-       for(i = 0, startn = 0; i < st->size; i++) {
-               uint8_t b = st->buf[i];
-               if((b & 0x80))                  /* Continuation expected */
-                       continue;
-
-               if(startn == 0) {
-                       /*
-                        * First two arcs are encoded through the backdoor.
-                        */
-                       if(i) {
-                               add = -80;
-                               if(cb("2", 1, app_key) < 0) return -1;
-                       } else if(b <= 39) {
-                               add = 0;
-                               if(cb("0", 1, app_key) < 0) return -1;
-                       } else if(b < 79) {
-                               add = -40;
-                               if(cb("1", 1, app_key) < 0) return -1;
-                       } else {
-                               add = -80;
-                               if(cb("2", 1, app_key) < 0) return -1;
-                       }
-                       wrote_len += 1;
-               }
-
-               if(cb(".", 1, app_key) < 0)     /* Separate arcs */
-                       return -1;
-
-               add = OBJECT_IDENTIFIER__dump_arc(&st->buf[startn],
-                               i - startn + 1, add, cb, app_key);
-               if(add < 0) return -1;
-               wrote_len += 1 + add;
-               startn = i + 1;
-               add = 0;
-       }
-
-       return wrote_len;
+OBJECT_IDENTIFIER__dump_body(const OBJECT_IDENTIFIER_t *st,
+                             asn_app_consume_bytes_f *cb, void *app_key) {
+    char scratch[32];
+    asn_oid_arc_t arc0, arc1;
+    size_t produced = 0;
+    size_t off = 0;
+    ssize_t rd;
+    int ret;
+
+    rd = OBJECT_IDENTIFIER_get_first_arcs(st->buf, st->size, &arc0, &arc1);
+    if(rd <= 0) {
+        return -1;
+    }
+
+    ret = snprintf(scratch, sizeof(scratch), "%"PRIu32".%"PRIu32, arc0, arc1);
+    if(ret >= (ssize_t)sizeof(scratch)) {
+        return -1;
+    }
+    produced += ret;
+    if(cb(scratch, ret, app_key) < 0)
+        return -1;
+
+    for(off = rd; ; ) {
+        asn_oid_arc_t arc;
+        rd = OBJECT_IDENTIFIER_get_single_arc(st->buf + off, st->size - off,
+                                              &arc);
+        if(rd < 0) {
+            return -1;
+        } else if(rd == 0) {
+            /* No more arcs. */
+            break;
+        } else {
+            off += rd;
+            assert(off <= st->size);
+            ret = snprintf(scratch, sizeof(scratch), ".%" PRIu32, arc);
+            if(ret >= (ssize_t)sizeof(scratch)) {
+                return -1;
+            }
+            produced += ret;
+            if(cb(scratch, ret, app_key) < 0) return -1;
+        }
+    }
+
+    if(off != st->size) {
+        ASN_DEBUG("Could not scan to the end of Object Identifier");
+        return -1;
+    }
+
+       return produced;

 }
 
 static enum xer_pbd_rval
 }
 
 static enum xer_pbd_rval

-OBJECT_IDENTIFIER__xer_body_decode(asn_TYPE_descriptor_t *td, void *sptr, const void *chunk_buf, size_t chunk_size) {
-       OBJECT_IDENTIFIER_t *st = (OBJECT_IDENTIFIER_t *)sptr;
+OBJECT_IDENTIFIER__xer_body_decode(const asn_TYPE_descriptor_t *td, void *sptr,
+                                   const void *chunk_buf, size_t chunk_size) {
+    OBJECT_IDENTIFIER_t *st = (OBJECT_IDENTIFIER_t *)sptr;

        const char *chunk_end = (const char *)chunk_buf + chunk_size;
        const char *endptr;
        const char *chunk_end = (const char *)chunk_buf + chunk_size;
        const char *endptr;

-       long s_arcs[10];
-       long *arcs = s_arcs;
-       int arcs_count;
-       int ret;
+       asn_oid_arc_t s_arcs[10];
+       asn_oid_arc_t *arcs = s_arcs;
+       ssize_t num_arcs;
+       ssize_t ret;

 
        (void)td;
 
 
        (void)td;
 

-       arcs_count = OBJECT_IDENTIFIER_parse_arcs(
-               (const char *)chunk_buf, chunk_size, arcs,
-                       sizeof(s_arcs)/sizeof(s_arcs[0]), &endptr);
-       if(arcs_count <= 0) {
+    num_arcs = OBJECT_IDENTIFIER_parse_arcs(
+        (const char *)chunk_buf, chunk_size, arcs,
+        sizeof(s_arcs) / sizeof(s_arcs[0]), &endptr);
+    if(num_arcs < 0) {

                /* Expecting more than zero arcs */
                return XPBD_BROKEN_ENCODING;
                /* Expecting more than zero arcs */
                return XPBD_BROKEN_ENCODING;

+       } else if(num_arcs == 0) {
+               return XPBD_NOT_BODY_IGNORE;

        }
        }

-       if(endptr < chunk_end) {
-               /* We have a tail of unrecognized data. Check its safety. */
-               if(!xer_is_whitespace(endptr, chunk_end - endptr))
-                       return XPBD_BROKEN_ENCODING;
-       }
+       assert(endptr == chunk_end);

 
 

-       if((size_t)arcs_count > sizeof(s_arcs)/sizeof(s_arcs[0])) {
-               arcs = (long *)MALLOC(arcs_count * sizeof(long));
+       if((size_t)num_arcs > sizeof(s_arcs)/sizeof(s_arcs[0])) {
+               arcs = (asn_oid_arc_t *)MALLOC(num_arcs * sizeof(asn_oid_arc_t));

                if(!arcs) return XPBD_SYSTEM_FAILURE;
                if(!arcs) return XPBD_SYSTEM_FAILURE;

-               ret = OBJECT_IDENTIFIER_parse_arcs(
-                       (const char *)chunk_buf, chunk_size,
-                       arcs, arcs_count, &endptr);
-               if(ret != arcs_count)
+        ret = OBJECT_IDENTIFIER_parse_arcs((const char *)chunk_buf, chunk_size,
+                                           arcs, num_arcs, &endptr);
+        if(ret != num_arcs)

                        return XPBD_SYSTEM_FAILURE;     /* assert?.. */
        }
 
        /*
         * Convert arcs into BER representation.
         */
                        return XPBD_SYSTEM_FAILURE;     /* assert?.. */
        }
 
        /*
         * Convert arcs into BER representation.
         */

-       ret = OBJECT_IDENTIFIER_set_arcs(st, arcs, sizeof(*arcs), arcs_count);
+       ret = OBJECT_IDENTIFIER_set_arcs(st, arcs, num_arcs);

        if(arcs != s_arcs) FREEMEM(arcs);
 
        return ret ? XPBD_SYSTEM_FAILURE : XPBD_BODY_CONSUMED;
 }
 
 asn_dec_rval_t
        if(arcs != s_arcs) FREEMEM(arcs);
 
        return ret ? XPBD_SYSTEM_FAILURE : XPBD_BODY_CONSUMED;
 }
 
 asn_dec_rval_t

-OBJECT_IDENTIFIER_decode_xer(asn_codec_ctx_t *opt_codec_ctx,
-       asn_TYPE_descriptor_t *td, void **sptr, const char *opt_mname,
-               const void *buf_ptr, size_t size) {
-
-       return xer_decode_primitive(opt_codec_ctx, td,
+OBJECT_IDENTIFIER_decode_xer(const asn_codec_ctx_t *opt_codec_ctx,
+                             const asn_TYPE_descriptor_t *td, void **sptr,
+                             const char *opt_mname, const void *buf_ptr,
+                             size_t size) {
+    return xer_decode_primitive(opt_codec_ctx, td,

                sptr, sizeof(OBJECT_IDENTIFIER_t), opt_mname,
                        buf_ptr, size, OBJECT_IDENTIFIER__xer_body_decode);
 }
 
 asn_enc_rval_t
                sptr, sizeof(OBJECT_IDENTIFIER_t), opt_mname,
                        buf_ptr, size, OBJECT_IDENTIFIER__xer_body_decode);
 }
 
 asn_enc_rval_t

-OBJECT_IDENTIFIER_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
-       int ilevel, enum xer_encoder_flags_e flags,
-               asn_app_consume_bytes_f *cb, void *app_key) {
-       const OBJECT_IDENTIFIER_t *st = (const OBJECT_IDENTIFIER_t *)sptr;
+OBJECT_IDENTIFIER_encode_xer(const asn_TYPE_descriptor_t *td, const void *sptr,
+                             int ilevel, enum xer_encoder_flags_e flags,
+                             asn_app_consume_bytes_f *cb, void *app_key) {
+    const OBJECT_IDENTIFIER_t *st = (const OBJECT_IDENTIFIER_t *)sptr;

        asn_enc_rval_t er;
 
        asn_enc_rval_t er;
 

-       (void)ilevel;
-       (void)flags;
+    (void)ilevel;
+    (void)flags;

 
 

-       if(!st || !st->buf)
-               _ASN_ENCODE_FAILED;
+    if(!st || !st->buf) {
+        ASN__ENCODE_FAILED;
+    }

 
 

-       er.encoded = OBJECT_IDENTIFIER__dump_body(st, cb, app_key);
-       if(er.encoded < 0) _ASN_ENCODE_FAILED;
+    er.encoded = OBJECT_IDENTIFIER__dump_body(st, cb, app_key);
+    if(er.encoded < 0) ASN__ENCODE_FAILED;

 
 

-       _ASN_ENCODED_OK(er);
+    ASN__ENCODED_OK(er);

 }
 
 int
 }
 
 int

-OBJECT_IDENTIFIER_print(asn_TYPE_descriptor_t *td, const void *sptr,
-       int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
-       const OBJECT_IDENTIFIER_t *st = (const OBJECT_IDENTIFIER_t *)sptr;
+OBJECT_IDENTIFIER_print(const asn_TYPE_descriptor_t *td, const void *sptr,
+                        int ilevel, asn_app_consume_bytes_f *cb,
+                        void *app_key) {
+    const OBJECT_IDENTIFIER_t *st = (const OBJECT_IDENTIFIER_t *)sptr;

 
        (void)td;       /* Unused argument */
        (void)ilevel;   /* Unused argument */
 
        (void)td;       /* Unused argument */
        (void)ilevel;   /* Unused argument */


@@ -350,309 +270,206 @@ OBJECT_IDENTIFIER_print(asn_TYPE_descriptor_t *td, const void *sptr,
        if(cb("{ ", 2, app_key) < 0)
                return -1;
 
        if(cb("{ ", 2, app_key) < 0)
                return -1;
 

-       if(OBJECT_IDENTIFIER__dump_body(st, cb, app_key) < 0)
-               return -1;
+    if(OBJECT_IDENTIFIER__dump_body(st, cb, app_key) < 0) {
+        return -1;
+    }

 
 

-       return (cb(" }", 2, app_key) < 0) ? -1 : 0;
+    return (cb(" }", 2, app_key) < 0) ? -1 : 0;

 }
 
 }
 

-int
-OBJECT_IDENTIFIER_get_arcs(OBJECT_IDENTIFIER_t *oid, void *arcs,
-               unsigned int arc_type_size, unsigned int arc_slots) {
-       void *arcs_end = (char *)arcs + (arc_type_size * arc_slots);
-       int num_arcs = 0;
-       int startn = 0;
-       int add = 0;
-       int i;
-
-       if(!oid || !oid->buf || (arc_slots && arc_type_size <= 1)) {
-               errno = EINVAL;
-               return -1;
-       }
-
-       for(i = 0; i < oid->size; i++) {
-               uint8_t b = oid->buf[i];
-               if((b & 0x80))                  /* Continuation expected */
-                       continue;
-
-               if(num_arcs == 0) {
-                       /*
-                        * First two arcs are encoded through the backdoor.
-                        */
-                       unsigned LE = 1;        /* Little endian */
-                       int first_arc;
-                       num_arcs++;
-                       if(!arc_slots) { num_arcs++; continue; }
-
-                       if(i) first_arc = 2;
-                       else if(b <= 39) first_arc = 0;
-                       else if(b < 79) first_arc = 1;
-                       else first_arc = 2;
-
-                       add = -40 * first_arc;
-                       memset(arcs, 0, arc_type_size);
-                       *(unsigned char *)((char *)arcs
-                               + ((*(char *)&LE)?0:(arc_type_size - 1)))
-                                       = first_arc;
-                       arcs = ((char *)arcs) + arc_type_size;
-               }
-
-               /* Decode, if has space */
-               if(arcs < arcs_end) {
-                       if(OBJECT_IDENTIFIER_get_single_arc(&oid->buf[startn],
-                               i - startn + 1, add,
-                                       arcs, arc_type_size))
-                               return -1;
-                       startn = i + 1;
-                       arcs = ((char *)arcs) + arc_type_size;
-                       add = 0;
-               }
-               num_arcs++;
-       }
-
-       return num_arcs;
+ssize_t
+OBJECT_IDENTIFIER_get_arcs(const OBJECT_IDENTIFIER_t *st, asn_oid_arc_t *arcs,
+                           size_t arc_slots) {
+    asn_oid_arc_t arc0, arc1;
+    size_t num_arcs = 0;
+    size_t off;
+    ssize_t rd;
+
+    if(!st || !st->buf) {
+        errno = EINVAL;
+        return -1;
+    }
+
+    rd = OBJECT_IDENTIFIER_get_first_arcs(st->buf, st->size, &arc0, &arc1);
+    if(rd <= 0) {
+        return -1;
+    }
+    num_arcs = 2;
+    switch(arc_slots) {
+    default:
+    case 2:
+        arcs[1] = arc1;
+        /* Fall through */
+    case 1:
+        arcs[0] = arc0;
+        /* Fall through */
+    case 0:
+        break;
+    }
+
+    for(off = rd; ; ) {
+        asn_oid_arc_t arc;
+        rd = OBJECT_IDENTIFIER_get_single_arc(st->buf + off, st->size - off,
+                                              &arc);
+        if(rd < 0) {
+            return -1;
+        } else if(rd == 0) {
+            /* No more arcs. */
+            break;
+        } else {
+            off += rd;
+            if(num_arcs < arc_slots) {
+                arcs[num_arcs] = arc;
+            }
+            num_arcs++;
+        }
+    }
+
+    if(off != st->size) {
+        return -1;
+    }
+
+    return num_arcs;

 }
 
 
 /*
  * Save the single value as an object identifier arc.
  */
 }
 
 
 /*
  * Save the single value as an object identifier arc.
  */

-int
-OBJECT_IDENTIFIER_set_single_arc(uint8_t *arcbuf, const void *arcval, unsigned int arcval_size, int prepared_order) {
-       /*
+ssize_t
+OBJECT_IDENTIFIER_set_single_arc(uint8_t *arcbuf, size_t arcbuf_len,
+                                 asn_oid_arc_t value) {
+    /*

         * The following conditions must hold:
         * The following conditions must hold:

-        * assert(arcval);
-        * assert(arcval_size > 0);
-        * assert(arcval_size <= 16);

         * assert(arcbuf);
         */
         * assert(arcbuf);
         */

-#ifdef WORDS_BIGENDIAN
-       const unsigned isLittleEndian = 0;
-#else
-       unsigned LE = 1;
-       unsigned isLittleEndian = *(char *)&LE;
-#endif
-       const uint8_t *tend, *tp;
-       unsigned int cache;
-       uint8_t *bp = arcbuf;
-       int bits;
-       uint8_t buffer[16];
-
-       if(isLittleEndian && !prepared_order) {
-               const uint8_t *a = (const unsigned char *)arcval + arcval_size - 1;
-               const uint8_t *aend = (const uint8_t *)arcval;
-               uint8_t *msb = buffer + arcval_size - 1;
-               uint8_t *tb;
-               for(tb = buffer; a >= aend; tb++, a--)
-                       if((*tb = *a) && (tb < msb))
-                               msb = tb;
-               tend = &buffer[arcval_size];
-               tp = msb;       /* Most significant non-zero byte */
-       } else {
-               /* Look for most significant non-zero byte */
-               tend = (const unsigned char *)arcval + arcval_size;
-               for(tp = (const uint8_t *)arcval; tp < tend - 1; tp++)
-                       if(*tp) break;
-       }
+    uint8_t scratch[((sizeof(value) * CHAR_BIT + 6) / 7)];
+    uint8_t *scratch_end = &scratch[sizeof(scratch)-1];
+    uint8_t *b;
+    size_t result_len;
+    uint8_t mask;

 
 

-       /*
-        * Split the value in 7-bits chunks.
-        */
-       bits = ((tend - tp) * CHAR_BIT) % 7;
-       if(bits) {
-               cache = *tp >> (CHAR_BIT - bits);
-               if(cache) {
-                       *bp++ = cache | 0x80;
-                       cache = *tp++;
-                       bits = CHAR_BIT - bits;
-               } else {
-                       bits = -bits;
-               }
-       } else {
-               cache = 0;
-       }
-       for(; tp < tend; tp++) {
-               cache = (cache << CHAR_BIT) + *tp;
-               bits += CHAR_BIT;
-               while(bits >= 7) {
-                       bits -= 7;
-                       *bp++ = 0x80 | (cache >> bits);
-               }
-       }
-       if(bits) *bp++ = cache;
-       bp[-1] &= 0x7f; /* Clear the last bit */
+    for(b = scratch_end, mask = 0; ; mask = 0x80, b--) {
+        *b = mask | (value & 0x7f);
+        value >>= 7;
+        if(!value) {
+            break;
+        }
+    }

 
 

-       return bp - arcbuf;
+    result_len = (scratch_end - b) + 1;
+
+    if(result_len > arcbuf_len) {
+        return -1;
+    }
+
+    memcpy(arcbuf, b, result_len);
+
+       return result_len;

 }
 
 int
 }
 
 int

-OBJECT_IDENTIFIER_set_arcs(OBJECT_IDENTIFIER_t *oid, const void *arcs, unsigned int arc_type_size, unsigned int arc_slots) {
-       uint8_t *buf;
-       uint8_t *bp;
-       unsigned LE = 1;        /* Little endian (x86) */
-       unsigned isLittleEndian = *((char *)&LE);
-       unsigned int arc0;
-       unsigned int arc1;
-       unsigned size;
-       unsigned i;
-
-       if(!oid || !arcs || arc_type_size < 1
-       || arc_type_size > 16
-       || arc_slots < 2) {
-               errno = EINVAL;
+OBJECT_IDENTIFIER_set_arcs(OBJECT_IDENTIFIER_t *st, const asn_oid_arc_t *arcs,
+                           size_t arc_slots) {
+    uint8_t *buf;
+    uint8_t *bp;
+    ssize_t wrote;
+    asn_oid_arc_t arc0;
+    asn_oid_arc_t arc1;
+    size_t size;
+    size_t i;
+
+    if(!st || !arcs || arc_slots < 2) {
+        errno = EINVAL;

                return -1;
        }
 
                return -1;
        }
 

-       switch(arc_type_size) {
-       case sizeof(char):
-               arc0 = ((const unsigned char *)arcs)[0];
-               arc1 = ((const unsigned char *)arcs)[1];
-               break;
-       case sizeof(short):
-               arc0 = ((const unsigned short *)arcs)[0];
-               arc1 = ((const unsigned short *)arcs)[1];
-               break;
-       case sizeof(int):
-               arc0 = ((const unsigned int *)arcs)[0];
-               arc1 = ((const unsigned int *)arcs)[1];
-               break;
-       default:
-               arc1 = arc0 = 0;
-               if(isLittleEndian) {    /* Little endian (x86) */
-                       const unsigned char *ps, *pe;
-                       /* If more significant bytes are present,
-                        * make them > 255 quick */
-                       for(ps = (const unsigned char *)arcs + 1, pe = ps+arc_type_size;
-                                       ps < pe; ps++)
-                               arc0 |= *ps, arc1 |= *(ps + arc_type_size);
-                       arc0 <<= CHAR_BIT, arc1 <<= CHAR_BIT;
-                       arc0 = *((const unsigned char *)arcs + 0);
-                       arc1 = *((const unsigned char *)arcs + arc_type_size);
-               } else {
-                       const unsigned char *ps, *pe;
-                       /* If more significant bytes are present,
-                        * make them > 255 quick */
-                       for(ps = (const unsigned char *)arcs, pe = ps+arc_type_size - 1; ps < pe; ps++)
-                               arc0 |= *ps, arc1 |= *(ps + arc_type_size);
-                       arc0 = *((const unsigned char *)arcs + arc_type_size - 1);
-                       arc1 = *((const unsigned char *)arcs +(arc_type_size<< 1)-1);
-               }
-       }
+    arc0 = arcs[0];
+    arc1 = arcs[1];

 
 

-       /*
-        * The previous chapter left us with the first and the second arcs.
-        * The values are not precise (that is, they are valid only if
-        * they're less than 255), but OK for the purposes of making
-        * the sanity test below.
-        */

        if(arc0 <= 1) {
        if(arc0 <= 1) {

-               if(arc1 >= 39) {
+               if(arc1 >= 40) {

                        /* 8.19.4: At most 39 subsequent values (including 0) */
                        errno = ERANGE;
                        return -1;
                }
                        /* 8.19.4: At most 39 subsequent values (including 0) */
                        errno = ERANGE;
                        return -1;
                }

-       } else if(arc0 > 2) {
-               /* 8.19.4: Only three values are allocated from the root node */
-               errno = ERANGE;
-               return -1;
-       }
-       /*
+    } else if(arc0 == 2) {
+        if(arc1 > ASN_OID_ARC_MAX - 80) {
+            errno = ERANGE;
+            return -1;
+        }
+    } else if(arc0 > 2) {
+        /* 8.19.4: Only three values are allocated from the root node */
+        errno = ERANGE;
+        return -1;
+    }
+
+    /*

         * After above tests it is known that the value of arc0 is completely
         * trustworthy (0..2). However, the arc1's value is still meaningless.
         */
 
         * After above tests it is known that the value of arc0 is completely
         * trustworthy (0..2). However, the arc1's value is still meaningless.
         */
 

-       /*
-        * Roughly estimate the maximum size necessary to encode these arcs.
-        * This estimation implicitly takes in account the following facts,
-        * that cancel each other:
-        *      * the first two arcs are encoded in a single value.
-        *      * the first value may require more space (+1 byte)
-        *      * the value of the first arc which is in range (0..2)
-        */
-       size = ((arc_type_size * CHAR_BIT + 6) / 7) * arc_slots;
-       bp = buf = (uint8_t *)MALLOC(size + 1);
-       if(!buf) {
-               /* ENOMEM */
-               return -1;
-       }
-
-       /*
-        * Encode the first two arcs.
-        * These require special treatment.
-        */
-       {
-               uint8_t *tp;
-               uint8_t first_value[1 + 16];    /* of two arcs */
-               uint8_t *fv = first_value;
-
-               /*
-                * Simulate first_value = arc0 * 40 + arc1;
-                */
-               /* Copy the second (1'st) arcs[1] into the first_value */
-               *fv++ = 0;
-               arcs = ((const char *)arcs) + arc_type_size;
-               if(isLittleEndian) {
-                       const uint8_t *aend = (const unsigned char *)arcs - 1;
-                       const uint8_t *a1 = (const unsigned char *)arcs + arc_type_size - 1;
-                       for(; a1 > aend; fv++, a1--) *fv = *a1;
-               } else {
-                       const uint8_t *a1 = (const uint8_t *)arcs;
-                       const uint8_t *aend = a1 + arc_type_size;
-                       for(; a1 < aend; fv++, a1++) *fv = *a1;
-               }
-               /* Increase the first_value by arc0 */
-               arc0 *= 40;     /* (0..80) */
-               for(tp = first_value + arc_type_size; tp >= first_value; tp--) {
-                       unsigned int v = *tp;
-                       v += arc0;
-                       *tp = v;
-                       if(v >= (1 << CHAR_BIT)) arc0 = v >> CHAR_BIT;
-                       else break;
-               }
-
-               assert(tp >= first_value);
-
-               bp += OBJECT_IDENTIFIER_set_single_arc(bp, first_value,
-                       fv - first_value, 1);
-       }
-
-       /*
-        * Save the rest of arcs.
-        */
-       for(arcs = ((const char *)arcs) + arc_type_size, i = 2;
-               i < arc_slots;
-                       i++, arcs = ((const char *)arcs) + arc_type_size) {
-               bp += OBJECT_IDENTIFIER_set_single_arc(bp,
-                       arcs, arc_type_size, 0);
-       }
-
-       assert((unsigned)(bp - buf) <= size);
-
-       /*
+    /*
+     * Roughly estimate the maximum size necessary to encode these arcs.
+     * This estimation implicitly takes in account the following facts,
+     * that cancel each other:
+     *         * the first two arcs are encoded in a single value.
+     *         * the first value may require more space (+1 byte)
+     *         * the value of the first arc which is in range (0..2)
+     */
+    size = ((sizeof(asn_oid_arc_t) * CHAR_BIT + 6) / 7) * arc_slots;
+    bp = buf = (uint8_t *)MALLOC(size + 1);
+    if(!buf) {
+        /* ENOMEM */
+        return -1;
+    }
+
+    wrote = OBJECT_IDENTIFIER_set_single_arc(bp, size, arc0 * 40 + arc1);
+    if(wrote <= 0) {
+        FREEMEM(buf);
+        return -1;
+    }
+    assert((size_t)wrote <= size);
+    bp += wrote;
+    size -= wrote;
+
+    for(i = 2; i < arc_slots; i++) {
+               wrote = OBJECT_IDENTIFIER_set_single_arc(bp, size, arcs[i]);
+        if(wrote <= 0) {
+            FREEMEM(buf);
+            return -1;
+        }
+        assert((size_t)wrote <= size);
+        bp += wrote;
+        size -= wrote;
+    }
+
+    /*

         * Replace buffer.
         */
         * Replace buffer.
         */

-       oid->size = bp - buf;
-       bp = oid->buf;
-       oid->buf = buf;
+       st->size = bp - buf;
+       bp = st->buf;
+       st->buf = buf;
+       st->buf[st->size] = '\0';

        if(bp) FREEMEM(bp);
 
        return 0;
 }
 
        if(bp) FREEMEM(bp);
 
        return 0;
 }
 

-
-int
+ssize_t

 OBJECT_IDENTIFIER_parse_arcs(const char *oid_text, ssize_t oid_txt_length,
 OBJECT_IDENTIFIER_parse_arcs(const char *oid_text, ssize_t oid_txt_length,

-       long *arcs, unsigned int arcs_slots, const char **opt_oid_text_end) {
-       unsigned int arcs_count = 0;
-       const char *oid_end;
-       long value = 0;
+                             asn_oid_arc_t *arcs, size_t arcs_count,
+                             const char **opt_oid_text_end) {
+    size_t num_arcs = 0;
+    const char *oid_end;

        enum {
        enum {

-               ST_SKIPSPACE,
-               ST_WAITDIGITS,  /* Next character is expected to be a digit */
-               ST_DIGITS
-       } state = ST_SKIPSPACE;
+               ST_LEADSPACE,
+               ST_TAILSPACE,
+               ST_AFTERVALUE,  /* Next character ought to be '.' or a space */
+               ST_WAITDIGITS   /* Next character is expected to be a digit */
+       } state = ST_LEADSPACE;

 
 

-       if(!oid_text || oid_txt_length < -1 || (arcs_slots && !arcs)) {
+       if(!oid_text || oid_txt_length < -1 || (arcs_count && !arcs)) {

                if(opt_oid_text_end) *opt_oid_text_end = oid_text;
                errno = EINVAL;
                return -1;
                if(opt_oid_text_end) *opt_oid_text_end = oid_text;
                errno = EINVAL;
                return -1;


@@ -661,41 +478,77 @@ OBJECT_IDENTIFIER_parse_arcs(const char *oid_text, ssize_t oid_txt_length,
        if(oid_txt_length == -1)
                oid_txt_length = strlen(oid_text);
 
        if(oid_txt_length == -1)
                oid_txt_length = strlen(oid_text);
 

-       for(oid_end = oid_text + oid_txt_length; oid_text<oid_end; oid_text++) {
+#define _OID_CAPTURE_ARC(oid_text, oid_end)                       \
+    do {                                                          \
+        const char *endp = oid_end;                               \
+        unsigned long value;                                      \
+        switch(asn_strtoul_lim(oid_text, &endp, &value)) {        \
+        case ASN_STRTOX_EXTRA_DATA:                               \
+        case ASN_STRTOX_OK:                                       \
+            if(value <= ASN_OID_ARC_MAX) {                        \
+                if(num_arcs < arcs_count) arcs[num_arcs] = value; \
+                num_arcs++;                                       \
+                oid_text = endp - 1;                              \
+                break;                                            \
+            }                                                     \
+            /* Fall through */                                    \
+        case ASN_STRTOX_ERROR_RANGE:                              \
+            if(opt_oid_text_end) *opt_oid_text_end = oid_text;    \
+            errno = ERANGE;                                       \
+            return -1;                                            \
+        case ASN_STRTOX_ERROR_INVAL:                              \
+        case ASN_STRTOX_EXPECT_MORE:                              \
+            if(opt_oid_text_end) *opt_oid_text_end = oid_text;    \
+            errno = EINVAL;                                       \
+            return -1;                                            \
+        }                                                         \
+    } while(0)
+
+    for(oid_end = oid_text + oid_txt_length; oid_text<oid_end; oid_text++) {

            switch(*oid_text) {
            case 0x09: case 0x0a: case 0x0d: case 0x20: /* whitespace */
            switch(*oid_text) {
            case 0x09: case 0x0a: case 0x0d: case 0x20: /* whitespace */

-               if(state == ST_SKIPSPACE) {
+               switch(state) {
+               case ST_LEADSPACE:
+               case ST_TAILSPACE:

                        continue;
                        continue;

-               } else {
-                       break;  /* Finish */
+               case ST_AFTERVALUE:
+                       state = ST_TAILSPACE;
+                       continue;
+               case ST_WAITDIGITS:
+                       break;  /* Digits expected after ".", got whitespace */

                }
                }

+               break;

            case 0x2e:  /* '.' */
            case 0x2e:  /* '.' */

-               if(state != ST_DIGITS
-               || (oid_text + 1) == oid_end) {
-                       state = ST_WAITDIGITS;
+               switch(state) {
+               case ST_LEADSPACE:
+               case ST_TAILSPACE:
+               case ST_WAITDIGITS:
+                       if(opt_oid_text_end)
+                               *opt_oid_text_end = oid_text;
+                       errno = EINVAL; /* Broken OID */
+                       return -1;

                        break;
                        break;

+               case ST_AFTERVALUE:
+                       state = ST_WAITDIGITS;
+                       continue;

                }
                }

-               if(arcs_count < arcs_slots)
-                       arcs[arcs_count] = value;
-               arcs_count++;
-               state = ST_WAITDIGITS;
-               continue;
+               break;

            case 0x30: case 0x31: case 0x32: case 0x33: case 0x34:
            case 0x35: case 0x36: case 0x37: case 0x38: case 0x39:
            case 0x30: case 0x31: case 0x32: case 0x33: case 0x34:
            case 0x35: case 0x36: case 0x37: case 0x38: case 0x39:

-               if(state != ST_DIGITS) {
-                       state = ST_DIGITS;
-                       value = 0;
-               }
-               if(1) {
-                       long new_value = value * 10;
-                       if(new_value / 10 != value
-                       || (value = new_value + (*oid_text - 0x30)) < 0) {
-                               /* Overflow */
-                               state = ST_WAITDIGITS;
-                               break;
-                       }
+               switch(state) {
+               case ST_TAILSPACE:
+               case ST_AFTERVALUE:
+                       if(opt_oid_text_end)
+                               *opt_oid_text_end = oid_text;
+                       errno = EINVAL; /* "1. 1" => broken OID */
+                       return -1;
+               case ST_LEADSPACE:
+               case ST_WAITDIGITS:
+                       _OID_CAPTURE_ARC(oid_text, oid_end);
+                       state = ST_AFTERVALUE;

                        continue;
                }
                        continue;
                }

+               break;

            default:
                /* Unexpected symbols */
                state = ST_WAITDIGITS;
            default:
                /* Unexpected symbols */
                state = ST_WAITDIGITS;


@@ -709,17 +562,82 @@ OBJECT_IDENTIFIER_parse_arcs(const char *oid_text, ssize_t oid_txt_length,
 
        /* Finalize last arc */
        switch(state) {
 
        /* Finalize last arc */
        switch(state) {

+       case ST_LEADSPACE:
+               return 0; /* No OID found in input data */

        case ST_WAITDIGITS:
        case ST_WAITDIGITS:

-               errno = EINVAL;
+               errno = EINVAL; /* Broken OID */

                return -1;
                return -1;

-       case ST_DIGITS:
-               if(arcs_count < arcs_slots)
-                       arcs[arcs_count] = value;
-               arcs_count++;
-               /* Fall through */
-       default:
-               return arcs_count;
+       case ST_AFTERVALUE:
+       case ST_TAILSPACE:
+               return num_arcs;

        }
        }

+
+       errno = EINVAL; /* Broken OID */
+       return -1;

 }
 
 }
 

+/*
+ * Generate values from the list of interesting values, or just a random
+ * value up to the upper limit.
+ */
+static asn_oid_arc_t
+OBJECT_IDENTIFIER__biased_random_arc(asn_oid_arc_t upper_bound) {
+    const asn_oid_arc_t values[] = {0, 1, 127, 128, 129, 254, 255, 256};
+    size_t idx;
+
+    switch(asn_random_between(0, 2)) {
+    case 0:
+        idx = asn_random_between(0, sizeof(values) / sizeof(values[0]) - 1);
+        if(values[idx] < upper_bound) {
+            return values[idx];
+        }
+        /* Fall through */
+    case 1:
+        return asn_random_between(0, upper_bound);
+    case 2:
+    default:
+        return upper_bound;
+    }
+}

 
 

+asn_random_fill_result_t
+OBJECT_IDENTIFIER_random_fill(const asn_TYPE_descriptor_t *td, void **sptr,
+                              const asn_encoding_constraints_t *constraints,
+                              size_t max_length) {
+    asn_random_fill_result_t result_ok = {ARFILL_OK, 1};
+    asn_random_fill_result_t result_failed = {ARFILL_FAILED, 0};
+    asn_random_fill_result_t result_skipped = {ARFILL_SKIPPED, 0};
+    OBJECT_IDENTIFIER_t *st;
+    asn_oid_arc_t arcs[5];
+    size_t arcs_len = asn_random_between(2, 5);
+    size_t i;
+
+    (void)constraints;
+
+    if(max_length < arcs_len) return result_skipped;
+
+    if(*sptr) {
+        st = *sptr;
+    } else {
+        st = CALLOC(1, sizeof(*st));
+    }
+
+    arcs[0] = asn_random_between(0, 2);
+    arcs[1] = OBJECT_IDENTIFIER__biased_random_arc(
+        arcs[0] <= 1 ? 39 : (ASN_OID_ARC_MAX - 80));
+    for(i = 2; i < arcs_len; i++) {
+        arcs[i] = OBJECT_IDENTIFIER__biased_random_arc(ASN_OID_ARC_MAX);
+    }
+
+    if(OBJECT_IDENTIFIER_set_arcs(st, arcs, arcs_len)) {
+        if(st != *sptr) {
+            ASN_STRUCT_FREE(*td, st);
+        }
+        return result_failed;
+    }
+
+    *sptr = st;
+
+    result_ok.length = st->size;
+    return result_ok;
+}