--- /dev/null
+/*-\r
+ * Copyright (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.\r
+ * Redistribution and modifications are permitted subject to BSD license.\r
+ */\r
+#include <asn_internal.h>\r
+#include <INTEGER.h>\r
+#include <OBJECT_IDENTIFIER.h>\r
+#include <OCTET_STRING.h>\r
+#include <limits.h> /* for CHAR_BIT */\r
+#include <errno.h>\r
+\r
+/*\r
+ * OBJECT IDENTIFIER basic type description.\r
+ */\r
+static const ber_tlv_tag_t asn_DEF_OBJECT_IDENTIFIER_tags[] = {\r
+ (ASN_TAG_CLASS_UNIVERSAL | (6 << 2))\r
+};\r
+asn_TYPE_operation_t asn_OP_OBJECT_IDENTIFIER = {\r
+ ASN__PRIMITIVE_TYPE_free,\r
+ OBJECT_IDENTIFIER_print,\r
+ OCTET_STRING_compare, /* Implemented in terms of a string comparison */\r
+ ber_decode_primitive,\r
+ der_encode_primitive,\r
+ OBJECT_IDENTIFIER_decode_xer,\r
+ OBJECT_IDENTIFIER_encode_xer,\r
+#ifdef ASN_DISABLE_OER_SUPPORT\r
+ 0,\r
+ 0,\r
+#else\r
+ OBJECT_IDENTIFIER_decode_oer,\r
+ OBJECT_IDENTIFIER_encode_oer,\r
+#endif /* ASN_DISABLE_OER_SUPPORT */\r
+#ifdef ASN_DISABLE_PER_SUPPORT\r
+ 0,\r
+ 0,\r
+ 0,\r
+ 0,\r
+#else\r
+ OCTET_STRING_decode_uper,\r
+ OCTET_STRING_encode_uper,\r
+ OCTET_STRING_decode_aper,\r
+ OCTET_STRING_encode_aper,\r
+#endif /* ASN_DISABLE_PER_SUPPORT */\r
+ OBJECT_IDENTIFIER_random_fill,\r
+ 0 /* Use generic outmost tag fetcher */\r
+};\r
+asn_TYPE_descriptor_t asn_DEF_OBJECT_IDENTIFIER = {\r
+ "OBJECT IDENTIFIER",\r
+ "OBJECT_IDENTIFIER",\r
+ &asn_OP_OBJECT_IDENTIFIER,\r
+ asn_DEF_OBJECT_IDENTIFIER_tags,\r
+ sizeof(asn_DEF_OBJECT_IDENTIFIER_tags)\r
+ / sizeof(asn_DEF_OBJECT_IDENTIFIER_tags[0]),\r
+ asn_DEF_OBJECT_IDENTIFIER_tags, /* Same as above */\r
+ sizeof(asn_DEF_OBJECT_IDENTIFIER_tags)\r
+ / sizeof(asn_DEF_OBJECT_IDENTIFIER_tags[0]),\r
+ { 0, 0, OBJECT_IDENTIFIER_constraint },\r
+ 0, 0, /* No members */\r
+ 0 /* No specifics */\r
+};\r
+\r
+int\r
+OBJECT_IDENTIFIER_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,\r
+ asn_app_constraint_failed_f *ctfailcb,\r
+ void *app_key) {\r
+ const OBJECT_IDENTIFIER_t *st = (const OBJECT_IDENTIFIER_t *)sptr;\r
+\r
+ if(st && st->buf) {\r
+ if(st->size < 1) {\r
+ ASN__CTFAIL(app_key, td, sptr,\r
+ "%s: at least one numerical value "\r
+ "expected (%s:%d)",\r
+ td->name, __FILE__, __LINE__);\r
+ return -1;\r
+ }\r
+ } else {\r
+ ASN__CTFAIL(app_key, td, sptr,\r
+ "%s: value not given (%s:%d)",\r
+ td->name, __FILE__, __LINE__);\r
+ return -1;\r
+ }\r
+\r
+ return 0;\r
+}\r
+\r
+static ssize_t\r
+OBJECT_IDENTIFIER_get_first_arcs(const uint8_t *arcbuf, size_t arcbuf_len,\r
+ asn_oid_arc_t *arc0, asn_oid_arc_t *arc1) {\r
+ asn_oid_arc_t value;\r
+\r
+ ssize_t rd = OBJECT_IDENTIFIER_get_single_arc(arcbuf, arcbuf_len, &value);\r
+ if(rd <= 0) return rd;\r
+\r
+ if(value >= 80) {\r
+ *arc0 = 2;\r
+ *arc1 = value - 80;\r
+ } else if(value >= 40) {\r
+ *arc0 = 1;\r
+ *arc1 = value - 40;\r
+ } else {\r
+ *arc0 = 0;\r
+ *arc1 = value;\r
+ }\r
+\r
+ return rd;\r
+}\r
+\r
+ssize_t\r
+OBJECT_IDENTIFIER_get_single_arc(const uint8_t *arcbuf, size_t arcbuf_len,\r
+ asn_oid_arc_t *ret_value) {\r
+ const uint8_t *b = arcbuf;\r
+ const uint8_t *arcend = arcbuf + arcbuf_len; /* End of arc */\r
+\r
+ if(arcbuf == arcend) {\r
+ return 0;\r
+ } else {\r
+ asn_oid_arc_t accum;\r
+ asn_oid_arc_t upper_limit = (ASN_OID_ARC_MAX >> 7);\r
+ /* When the value reaches "upper_limit", it can take */\r
+ /* at most one more digit. If it exceeds "upper_limit" */\r
+ /* but there are more digits - it's an Overflow condition */\r
+ /* Gather all bits into the accumulator */\r
+ for(accum = 0; b < arcend; b++) {\r
+ accum = (accum << 7) | (*b & ~0x80);\r
+ if((*b & 0x80) == 0) { // no more digits\r
+ if(accum <= ASN_OID_ARC_MAX) {\r
+ *ret_value = accum;\r
+ return 1 + (b - arcbuf);\r
+ } else {\r
+ errno = ERANGE; /* Overflow */\r
+ return -1;\r
+ }\r
+ } else { // to make sure we aren't wrapping around\r
+ if(accum > upper_limit) {\r
+ errno = ERANGE; /* Overflow */\r
+ return -1;\r
+ }\r
+ }\r
+ }\r
+ errno = EINVAL;\r
+ return -1;\r
+ }\r
+\r
+}\r
+\r
+static ssize_t\r
+OBJECT_IDENTIFIER__dump_body(const OBJECT_IDENTIFIER_t *st,\r
+ asn_app_consume_bytes_f *cb, void *app_key) {\r
+ char scratch[32];\r
+ asn_oid_arc_t arc0, arc1;\r
+ size_t produced = 0;\r
+ size_t off = 0;\r
+ ssize_t rd;\r
+ int ret;\r
+\r
+ rd = OBJECT_IDENTIFIER_get_first_arcs(st->buf, st->size, &arc0, &arc1);\r
+ if(rd <= 0) {\r
+ return -1;\r
+ }\r
+\r
+ ret = snprintf(scratch, sizeof(scratch), "%"PRIu32".%"PRIu32, arc0, arc1);\r
+ if(ret >= (ssize_t)sizeof(scratch)) {\r
+ return -1;\r
+ }\r
+ produced += ret;\r
+ if(cb(scratch, ret, app_key) < 0)\r
+ return -1;\r
+\r
+ for(off = rd; ; ) {\r
+ asn_oid_arc_t arc;\r
+ rd = OBJECT_IDENTIFIER_get_single_arc(st->buf + off, st->size - off,\r
+ &arc);\r
+ if(rd < 0) {\r
+ return -1;\r
+ } else if(rd == 0) {\r
+ /* No more arcs. */\r
+ break;\r
+ } else {\r
+ off += rd;\r
+ assert(off <= st->size);\r
+ ret = snprintf(scratch, sizeof(scratch), ".%" PRIu32, arc);\r
+ if(ret >= (ssize_t)sizeof(scratch)) {\r
+ return -1;\r
+ }\r
+ produced += ret;\r
+ if(cb(scratch, ret, app_key) < 0) return -1;\r
+ }\r
+ }\r
+\r
+ if(off != st->size) {\r
+ ASN_DEBUG("Could not scan to the end of Object Identifier");\r
+ return -1;\r
+ }\r
+\r
+ return produced;\r
+}\r
+\r
+static enum xer_pbd_rval\r
+OBJECT_IDENTIFIER__xer_body_decode(const asn_TYPE_descriptor_t *td, void *sptr,\r
+ const void *chunk_buf, size_t chunk_size) {\r
+ OBJECT_IDENTIFIER_t *st = (OBJECT_IDENTIFIER_t *)sptr;\r
+ const char *chunk_end = (const char *)chunk_buf + chunk_size;\r
+ const char *endptr;\r
+ asn_oid_arc_t s_arcs[10];\r
+ asn_oid_arc_t *arcs = s_arcs;\r
+ ssize_t num_arcs;\r
+ ssize_t ret;\r
+\r
+ (void)td;\r
+\r
+ num_arcs = OBJECT_IDENTIFIER_parse_arcs(\r
+ (const char *)chunk_buf, chunk_size, arcs,\r
+ sizeof(s_arcs) / sizeof(s_arcs[0]), &endptr);\r
+ if(num_arcs < 0) {\r
+ /* Expecting more than zero arcs */\r
+ return XPBD_BROKEN_ENCODING;\r
+ } else if(num_arcs == 0) {\r
+ return XPBD_NOT_BODY_IGNORE;\r
+ }\r
+ assert(endptr == chunk_end);\r
+\r
+ if((size_t)num_arcs > sizeof(s_arcs)/sizeof(s_arcs[0])) {\r
+ arcs = (asn_oid_arc_t *)MALLOC(num_arcs * sizeof(asn_oid_arc_t));\r
+ if(!arcs) return XPBD_SYSTEM_FAILURE;\r
+ ret = OBJECT_IDENTIFIER_parse_arcs((const char *)chunk_buf, chunk_size,\r
+ arcs, num_arcs, &endptr);\r
+ if(ret != num_arcs)\r
+ return XPBD_SYSTEM_FAILURE; /* assert?.. */\r
+ }\r
+\r
+ /*\r
+ * Convert arcs into BER representation.\r
+ */\r
+ ret = OBJECT_IDENTIFIER_set_arcs(st, arcs, num_arcs);\r
+ if(arcs != s_arcs) FREEMEM(arcs);\r
+\r
+ return ret ? XPBD_SYSTEM_FAILURE : XPBD_BODY_CONSUMED;\r
+}\r
+\r
+asn_dec_rval_t\r
+OBJECT_IDENTIFIER_decode_xer(const asn_codec_ctx_t *opt_codec_ctx,\r
+ const asn_TYPE_descriptor_t *td, void **sptr,\r
+ const char *opt_mname, const void *buf_ptr,\r
+ size_t size) {\r
+ return xer_decode_primitive(opt_codec_ctx, td,\r
+ sptr, sizeof(OBJECT_IDENTIFIER_t), opt_mname,\r
+ buf_ptr, size, OBJECT_IDENTIFIER__xer_body_decode);\r
+}\r
+\r
+asn_enc_rval_t\r
+OBJECT_IDENTIFIER_encode_xer(const asn_TYPE_descriptor_t *td, const void *sptr,\r
+ int ilevel, enum xer_encoder_flags_e flags,\r
+ asn_app_consume_bytes_f *cb, void *app_key) {\r
+ const OBJECT_IDENTIFIER_t *st = (const OBJECT_IDENTIFIER_t *)sptr;\r
+ asn_enc_rval_t er = {0,0,0};\r
+\r
+ (void)ilevel;\r
+ (void)flags;\r
+\r
+ if(!st || !st->buf) {\r
+ ASN__ENCODE_FAILED;\r
+ }\r
+\r
+ er.encoded = OBJECT_IDENTIFIER__dump_body(st, cb, app_key);\r
+ if(er.encoded < 0) ASN__ENCODE_FAILED;\r
+\r
+ ASN__ENCODED_OK(er);\r
+}\r
+\r
+int\r
+OBJECT_IDENTIFIER_print(const asn_TYPE_descriptor_t *td, const void *sptr,\r
+ int ilevel, asn_app_consume_bytes_f *cb,\r
+ void *app_key) {\r
+ const OBJECT_IDENTIFIER_t *st = (const OBJECT_IDENTIFIER_t *)sptr;\r
+\r
+ (void)td; /* Unused argument */\r
+ (void)ilevel; /* Unused argument */\r
+\r
+ if(!st || !st->buf)\r
+ return (cb("<absent>", 8, app_key) < 0) ? -1 : 0;\r
+\r
+ /* Dump preamble */\r
+ if(cb("{ ", 2, app_key) < 0)\r
+ return -1;\r
+\r
+ if(OBJECT_IDENTIFIER__dump_body(st, cb, app_key) < 0) {\r
+ return -1;\r
+ }\r
+\r
+ return (cb(" }", 2, app_key) < 0) ? -1 : 0;\r
+}\r
+\r
+ssize_t\r
+OBJECT_IDENTIFIER_get_arcs(const OBJECT_IDENTIFIER_t *st, asn_oid_arc_t *arcs,\r
+ size_t arc_slots) {\r
+ asn_oid_arc_t arc0, arc1;\r
+ size_t num_arcs = 0;\r
+ size_t off;\r
+ ssize_t rd;\r
+\r
+ if(!st || !st->buf) {\r
+ errno = EINVAL;\r
+ return -1;\r
+ }\r
+\r
+ rd = OBJECT_IDENTIFIER_get_first_arcs(st->buf, st->size, &arc0, &arc1);\r
+ if(rd <= 0) {\r
+ return -1;\r
+ }\r
+ num_arcs = 2;\r
+ switch(arc_slots) {\r
+ default:\r
+ case 2:\r
+ arcs[1] = arc1;\r
+ /* Fall through */\r
+ case 1:\r
+ arcs[0] = arc0;\r
+ /* Fall through */\r
+ case 0:\r
+ break;\r
+ }\r
+\r
+ for(off = rd; ; ) {\r
+ asn_oid_arc_t arc;\r
+ rd = OBJECT_IDENTIFIER_get_single_arc(st->buf + off, st->size - off,\r
+ &arc);\r
+ if(rd < 0) {\r
+ return -1;\r
+ } else if(rd == 0) {\r
+ /* No more arcs. */\r
+ break;\r
+ } else {\r
+ off += rd;\r
+ if(num_arcs < arc_slots) {\r
+ arcs[num_arcs] = arc;\r
+ }\r
+ num_arcs++;\r
+ }\r
+ }\r
+\r
+ if(off != st->size) {\r
+ return -1;\r
+ }\r
+\r
+ return num_arcs;\r
+}\r
+\r
+\r
+/*\r
+ * Save the single value as an object identifier arc.\r
+ */\r
+ssize_t\r
+OBJECT_IDENTIFIER_set_single_arc(uint8_t *arcbuf, size_t arcbuf_len,\r
+ asn_oid_arc_t value) {\r
+ /*\r
+ * The following conditions must hold:\r
+ * assert(arcbuf);\r
+ */\r
+ uint8_t scratch[((sizeof(value) * CHAR_BIT + 6) / 7)];\r
+ uint8_t *scratch_end = &scratch[sizeof(scratch)-1];\r
+ uint8_t *b;\r
+ size_t result_len;\r
+ uint8_t mask;\r
+\r
+ for(b = scratch_end, mask = 0; ; mask = 0x80, b--) {\r
+ *b = mask | (value & 0x7f);\r
+ value >>= 7;\r
+ if(!value) {\r
+ break;\r
+ }\r
+ }\r
+\r
+ result_len = (scratch_end - b) + 1;\r
+\r
+ if(result_len > arcbuf_len) {\r
+ return -1;\r
+ }\r
+\r
+ memcpy(arcbuf, b, result_len);\r
+\r
+ return result_len;\r
+}\r
+\r
+int\r
+OBJECT_IDENTIFIER_set_arcs(OBJECT_IDENTIFIER_t *st, const asn_oid_arc_t *arcs,\r
+ size_t arc_slots) {\r
+ uint8_t *buf;\r
+ uint8_t *bp;\r
+ ssize_t wrote;\r
+ asn_oid_arc_t arc0;\r
+ asn_oid_arc_t arc1;\r
+ size_t size;\r
+ size_t i;\r
+\r
+ if(!st || !arcs || arc_slots < 2) {\r
+ errno = EINVAL;\r
+ return -1;\r
+ }\r
+\r
+ arc0 = arcs[0];\r
+ arc1 = arcs[1];\r
+\r
+ if(arc0 <= 1) {\r
+ if(arc1 >= 40) {\r
+ /* 8.19.4: At most 39 subsequent values (including 0) */\r
+ errno = ERANGE;\r
+ return -1;\r
+ }\r
+ } else if(arc0 == 2) {\r
+ if(arc1 > ASN_OID_ARC_MAX - 80) {\r
+ errno = ERANGE;\r
+ return -1;\r
+ }\r
+ } else if(arc0 > 2) {\r
+ /* 8.19.4: Only three values are allocated from the root node */\r
+ errno = ERANGE;\r
+ return -1;\r
+ }\r
+\r
+ /*\r
+ * After above tests it is known that the value of arc0 is completely\r
+ * trustworthy (0..2). However, the arc1's value is still meaningless.\r
+ */\r
+\r
+ /*\r
+ * Roughly estimate the maximum size necessary to encode these arcs.\r
+ * This estimation implicitly takes in account the following facts,\r
+ * that cancel each other:\r
+ * * the first two arcs are encoded in a single value.\r
+ * * the first value may require more space (+1 byte)\r
+ * * the value of the first arc which is in range (0..2)\r
+ */\r
+ size = ((sizeof(asn_oid_arc_t) * CHAR_BIT + 6) / 7) * arc_slots;\r
+ bp = buf = (uint8_t *)MALLOC(size + 1);\r
+ if(!buf) {\r
+ /* ENOMEM */\r
+ return -1;\r
+ }\r
+\r
+ wrote = OBJECT_IDENTIFIER_set_single_arc(bp, size, arc0 * 40 + arc1);\r
+ if(wrote <= 0) {\r
+ FREEMEM(buf);\r
+ return -1;\r
+ }\r
+ assert((size_t)wrote <= size);\r
+ bp += wrote;\r
+ size -= wrote;\r
+\r
+ for(i = 2; i < arc_slots; i++) {\r
+ wrote = OBJECT_IDENTIFIER_set_single_arc(bp, size, arcs[i]);\r
+ if(wrote <= 0) {\r
+ FREEMEM(buf);\r
+ return -1;\r
+ }\r
+ assert((size_t)wrote <= size);\r
+ bp += wrote;\r
+ size -= wrote;\r
+ }\r
+\r
+ /*\r
+ * Replace buffer.\r
+ */\r
+ st->size = bp - buf;\r
+ bp = st->buf;\r
+ st->buf = buf;\r
+ st->buf[st->size] = '\0';\r
+ if(bp) FREEMEM(bp);\r
+\r
+ return 0;\r
+}\r
+\r
+ssize_t\r
+OBJECT_IDENTIFIER_parse_arcs(const char *oid_text, ssize_t oid_txt_length,\r
+ asn_oid_arc_t *arcs, size_t arcs_count,\r
+ const char **opt_oid_text_end) {\r
+ size_t num_arcs = 0;\r
+ const char *oid_end;\r
+ enum {\r
+ ST_LEADSPACE,\r
+ ST_TAILSPACE,\r
+ ST_AFTERVALUE, /* Next character ought to be '.' or a space */\r
+ ST_WAITDIGITS /* Next character is expected to be a digit */\r
+ } state = ST_LEADSPACE;\r
+\r
+ if(!oid_text || oid_txt_length < -1 || (arcs_count && !arcs)) {\r
+ if(opt_oid_text_end) *opt_oid_text_end = oid_text;\r
+ errno = EINVAL;\r
+ return -1;\r
+ }\r
+\r
+ if(oid_txt_length == -1)\r
+ oid_txt_length = strlen(oid_text);\r
+\r
+#define _OID_CAPTURE_ARC(oid_text, oid_end) \\r
+ do { \\r
+ const char *endp = oid_end; \\r
+ unsigned long value; \\r
+ switch(asn_strtoul_lim(oid_text, &endp, &value)) { \\r
+ case ASN_STRTOX_EXTRA_DATA: \\r
+ case ASN_STRTOX_OK: \\r
+ if(value <= ASN_OID_ARC_MAX) { \\r
+ if(num_arcs < arcs_count) arcs[num_arcs] = value; \\r
+ num_arcs++; \\r
+ oid_text = endp - 1; \\r
+ break; \\r
+ } \\r
+ /* Fall through */ \\r
+ case ASN_STRTOX_ERROR_RANGE: \\r
+ if(opt_oid_text_end) *opt_oid_text_end = oid_text; \\r
+ errno = ERANGE; \\r
+ return -1; \\r
+ case ASN_STRTOX_ERROR_INVAL: \\r
+ case ASN_STRTOX_EXPECT_MORE: \\r
+ if(opt_oid_text_end) *opt_oid_text_end = oid_text; \\r
+ errno = EINVAL; \\r
+ return -1; \\r
+ } \\r
+ } while(0)\r
+\r
+ for(oid_end = oid_text + oid_txt_length; oid_text<oid_end; oid_text++) {\r
+ switch(*oid_text) {\r
+ case 0x09: case 0x0a: case 0x0d: case 0x20: /* whitespace */\r
+ switch(state) {\r
+ case ST_LEADSPACE:\r
+ case ST_TAILSPACE:\r
+ continue;\r
+ case ST_AFTERVALUE:\r
+ state = ST_TAILSPACE;\r
+ continue;\r
+ case ST_WAITDIGITS:\r
+ break; /* Digits expected after ".", got whitespace */\r
+ }\r
+ break;\r
+ case 0x2e: /* '.' */\r
+ switch(state) {\r
+ case ST_LEADSPACE:\r
+ case ST_TAILSPACE:\r
+ case ST_WAITDIGITS:\r
+ if(opt_oid_text_end)\r
+ *opt_oid_text_end = oid_text;\r
+ errno = EINVAL; /* Broken OID */\r
+ return -1;\r
+ break;\r
+ case ST_AFTERVALUE:\r
+ state = ST_WAITDIGITS;\r
+ continue;\r
+ }\r
+ break;\r
+ case 0x30: case 0x31: case 0x32: case 0x33: case 0x34:\r
+ case 0x35: case 0x36: case 0x37: case 0x38: case 0x39:\r
+ switch(state) {\r
+ case ST_TAILSPACE:\r
+ case ST_AFTERVALUE:\r
+ if(opt_oid_text_end)\r
+ *opt_oid_text_end = oid_text;\r
+ errno = EINVAL; /* "1. 1" => broken OID */\r
+ return -1;\r
+ case ST_LEADSPACE:\r
+ case ST_WAITDIGITS:\r
+ _OID_CAPTURE_ARC(oid_text, oid_end);\r
+ state = ST_AFTERVALUE;\r
+ continue;\r
+ }\r
+ break;\r
+ default:\r
+ /* Unexpected symbols */\r
+ state = ST_WAITDIGITS;\r
+ break;\r
+ } /* switch() */\r
+ break;\r
+ } /* for() */\r
+\r
+\r
+ if(opt_oid_text_end) *opt_oid_text_end = oid_text;\r
+\r
+ /* Finalize last arc */\r
+ switch(state) {\r
+ case ST_LEADSPACE:\r
+ return 0; /* No OID found in input data */\r
+ case ST_WAITDIGITS:\r
+ errno = EINVAL; /* Broken OID */\r
+ return -1;\r
+ case ST_AFTERVALUE:\r
+ case ST_TAILSPACE:\r
+ return num_arcs;\r
+ }\r
+\r
+ errno = EINVAL; /* Broken OID */\r
+ return -1;\r
+}\r
+\r
+/*\r
+ * Generate values from the list of interesting values, or just a random\r
+ * value up to the upper limit.\r
+ */\r
+static asn_oid_arc_t\r
+OBJECT_IDENTIFIER__biased_random_arc(asn_oid_arc_t upper_bound) {\r
+ const asn_oid_arc_t values[] = {0, 1, 127, 128, 129, 254, 255, 256};\r
+ size_t idx;\r
+\r
+ switch(asn_random_between(0, 2)) {\r
+ case 0:\r
+ idx = asn_random_between(0, sizeof(values) / sizeof(values[0]) - 1);\r
+ if(values[idx] < upper_bound) {\r
+ return values[idx];\r
+ }\r
+ /* Fall through */\r
+ case 1:\r
+ return asn_random_between(0, upper_bound);\r
+ case 2:\r
+ default:\r
+ return upper_bound;\r
+ }\r
+}\r
+\r
+asn_random_fill_result_t\r
+OBJECT_IDENTIFIER_random_fill(const asn_TYPE_descriptor_t *td, void **sptr,\r
+ const asn_encoding_constraints_t *constraints,\r
+ size_t max_length) {\r
+ asn_random_fill_result_t result_ok = {ARFILL_OK, 1};\r
+ asn_random_fill_result_t result_failed = {ARFILL_FAILED, 0};\r
+ asn_random_fill_result_t result_skipped = {ARFILL_SKIPPED, 0};\r
+ OBJECT_IDENTIFIER_t *st;\r
+ asn_oid_arc_t arcs[5];\r
+ size_t arcs_len = asn_random_between(2, 5);\r
+ size_t i;\r
+\r
+ (void)constraints;\r
+\r
+ if(max_length < arcs_len) return result_skipped;\r
+\r
+ if(*sptr) {\r
+ st = *sptr;\r
+ } else {\r
+ st = CALLOC(1, sizeof(*st));\r
+ }\r
+\r
+ arcs[0] = asn_random_between(0, 2);\r
+ arcs[1] = OBJECT_IDENTIFIER__biased_random_arc(\r
+ arcs[0] <= 1 ? 39 : (ASN_OID_ARC_MAX - 80));\r
+ for(i = 2; i < arcs_len; i++) {\r
+ arcs[i] = OBJECT_IDENTIFIER__biased_random_arc(ASN_OID_ARC_MAX);\r
+ }\r
+\r
+ if(OBJECT_IDENTIFIER_set_arcs(st, arcs, arcs_len)) {\r
+ if(st != *sptr) {\r
+ ASN_STRUCT_FREE(*td, st);\r
+ }\r
+ return result_failed;\r
+ }\r
+\r
+ *sptr = st;\r
+\r
+ result_ok.length = st->size;\r
+ return result_ok;\r
+}\r
Code Review / ric-app / kpimon.git / blobdiff