--- /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 <BIT_STRING.h>\r
+#include <asn_internal.h>\r
+\r
+/*\r
+ * BIT STRING basic type description.\r
+ */\r
+static const ber_tlv_tag_t asn_DEF_BIT_STRING_tags[] = {\r
+ (ASN_TAG_CLASS_UNIVERSAL | (3 << 2))\r
+};\r
+asn_OCTET_STRING_specifics_t asn_SPC_BIT_STRING_specs = {\r
+ sizeof(BIT_STRING_t),\r
+ offsetof(BIT_STRING_t, _asn_ctx),\r
+ ASN_OSUBV_BIT\r
+};\r
+asn_TYPE_operation_t asn_OP_BIT_STRING = {\r
+ OCTET_STRING_free, /* Implemented in terms of OCTET STRING */\r
+ BIT_STRING_print,\r
+ BIT_STRING_compare,\r
+ OCTET_STRING_decode_ber, /* Implemented in terms of OCTET STRING */\r
+ OCTET_STRING_encode_der, /* Implemented in terms of OCTET STRING */\r
+ OCTET_STRING_decode_xer_binary,\r
+ BIT_STRING_encode_xer,\r
+#ifdef ASN_DISABLE_OER_SUPPORT\r
+ 0,\r
+ 0,\r
+#else\r
+ BIT_STRING_decode_oer,\r
+ BIT_STRING_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
+ BIT_STRING_decode_uper, /* Unaligned PER decoder */\r
+ BIT_STRING_encode_uper, /* Unaligned PER encoder */\r
+ OCTET_STRING_decode_aper, /* Aligned PER decoder */\r
+ OCTET_STRING_encode_aper, /* Aligned PER encoder */\r
+#endif /* ASN_DISABLE_PER_SUPPORT */\r
+ BIT_STRING_random_fill,\r
+ 0 /* Use generic outmost tag fetcher */\r
+};\r
+asn_TYPE_descriptor_t asn_DEF_BIT_STRING = {\r
+ "BIT STRING",\r
+ "BIT_STRING",\r
+ &asn_OP_BIT_STRING,\r
+ asn_DEF_BIT_STRING_tags,\r
+ sizeof(asn_DEF_BIT_STRING_tags)\r
+ / sizeof(asn_DEF_BIT_STRING_tags[0]),\r
+ asn_DEF_BIT_STRING_tags, /* Same as above */\r
+ sizeof(asn_DEF_BIT_STRING_tags)\r
+ / sizeof(asn_DEF_BIT_STRING_tags[0]),\r
+ { 0, 0, BIT_STRING_constraint },\r
+ 0, 0, /* No members */\r
+ &asn_SPC_BIT_STRING_specs\r
+};\r
+\r
+/*\r
+ * BIT STRING generic constraint.\r
+ */\r
+int\r
+BIT_STRING_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,\r
+ asn_app_constraint_failed_f *ctfailcb, void *app_key) {\r
+ const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;\r
+\r
+ if(st && st->buf) {\r
+ if((st->size == 0 && st->bits_unused)\r
+ || st->bits_unused < 0 || st->bits_unused > 7) {\r
+ ASN__CTFAIL(app_key, td, sptr,\r
+ "%s: invalid padding byte (%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 const char *_bit_pattern[16] = {\r
+ "0000", "0001", "0010", "0011", "0100", "0101", "0110", "0111",\r
+ "1000", "1001", "1010", "1011", "1100", "1101", "1110", "1111"\r
+};\r
+\r
+asn_enc_rval_t\r
+BIT_STRING_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
+ asn_enc_rval_t er = {0, 0, 0};\r
+ char scratch[128];\r
+ char *p = scratch;\r
+ char *scend = scratch + (sizeof(scratch) - 10);\r
+ const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;\r
+ int xcan = (flags & XER_F_CANONICAL);\r
+ uint8_t *buf;\r
+ uint8_t *end;\r
+\r
+ if(!st || !st->buf)\r
+ ASN__ENCODE_FAILED;\r
+\r
+ er.encoded = 0;\r
+\r
+ buf = st->buf;\r
+ end = buf + st->size - 1; /* Last byte is special */\r
+\r
+ /*\r
+ * Binary dump\r
+ */\r
+ for(; buf < end; buf++) {\r
+ int v = *buf;\r
+ int nline = xcan?0:(((buf - st->buf) % 8) == 0);\r
+ if(p >= scend || nline) {\r
+ ASN__CALLBACK(scratch, p - scratch);\r
+ p = scratch;\r
+ if(nline) ASN__TEXT_INDENT(1, ilevel);\r
+ }\r
+ memcpy(p + 0, _bit_pattern[v >> 4], 4);\r
+ memcpy(p + 4, _bit_pattern[v & 0x0f], 4);\r
+ p += 8;\r
+ }\r
+\r
+ if(!xcan && ((buf - st->buf) % 8) == 0)\r
+ ASN__TEXT_INDENT(1, ilevel);\r
+ ASN__CALLBACK(scratch, p - scratch);\r
+ p = scratch;\r
+\r
+ if(buf == end) {\r
+ int v = *buf;\r
+ int ubits = st->bits_unused;\r
+ int i;\r
+ for(i = 7; i >= ubits; i--)\r
+ *p++ = (v & (1 << i)) ? 0x31 : 0x30;\r
+ ASN__CALLBACK(scratch, p - scratch);\r
+ }\r
+\r
+ if(!xcan) ASN__TEXT_INDENT(1, ilevel - 1);\r
+\r
+ ASN__ENCODED_OK(er);\r
+cb_failed:\r
+ ASN__ENCODE_FAILED;\r
+}\r
+\r
+\r
+/*\r
+ * BIT STRING specific contents printer.\r
+ */\r
+int\r
+BIT_STRING_print(const asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,\r
+ asn_app_consume_bytes_f *cb, void *app_key) {\r
+ const char * const h2c = "0123456789ABCDEF";\r
+ char scratch[64];\r
+ const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;\r
+ uint8_t *buf;\r
+ uint8_t *end;\r
+ char *p = scratch;\r
+\r
+ (void)td; /* Unused argument */\r
+\r
+ if(!st || !st->buf)\r
+ return (cb("<absent>", 8, app_key) < 0) ? -1 : 0;\r
+\r
+ ilevel++;\r
+ buf = st->buf;\r
+ end = buf + st->size;\r
+\r
+ /*\r
+ * Hexadecimal dump.\r
+ */\r
+ for(; buf < end; buf++) {\r
+ if((buf - st->buf) % 16 == 0 && (st->size > 16)\r
+ && buf != st->buf) {\r
+ _i_INDENT(1);\r
+ /* Dump the string */\r
+ if(cb(scratch, p - scratch, app_key) < 0) return -1;\r
+ p = scratch;\r
+ }\r
+ *p++ = h2c[*buf >> 4];\r
+ *p++ = h2c[*buf & 0x0F];\r
+ *p++ = 0x20;\r
+ }\r
+\r
+ if(p > scratch) {\r
+ p--; /* Eat the tailing space */\r
+\r
+ if((st->size > 16)) {\r
+ _i_INDENT(1);\r
+ }\r
+\r
+ /* Dump the incomplete 16-bytes row */\r
+ if(cb(scratch, p - scratch, app_key) < 0)\r
+ return -1;\r
+ }\r
+\r
+ if(st->bits_unused) {\r
+ int ret = snprintf(scratch, sizeof(scratch), " (%d bit%s unused)",\r
+ st->bits_unused, st->bits_unused == 1 ? "" : "s");\r
+ assert(ret > 0 && ret < (ssize_t)sizeof(scratch));\r
+ if(ret > 0 && ret < (ssize_t)sizeof(scratch)\r
+ && cb(scratch, ret, app_key) < 0)\r
+ return -1;\r
+ }\r
+\r
+ return 0;\r
+}\r
+\r
+/*\r
+ * Non-destructively remove the trailing 0-bits from the given bit string.\r
+ */\r
+static const BIT_STRING_t *\r
+BIT_STRING__compactify(const BIT_STRING_t *st, BIT_STRING_t *tmp) {\r
+ const uint8_t *b;\r
+ union {\r
+ const uint8_t *c_buf;\r
+ uint8_t *nc_buf;\r
+ } unconst;\r
+\r
+ if(st->size == 0) {\r
+ assert(st->bits_unused == 0);\r
+ return st;\r
+ } else {\r
+ for(b = &st->buf[st->size - 1]; b > st->buf && *b == 0; b--) {\r
+ ;\r
+ }\r
+ /* b points to the last byte which may contain data */\r
+ if(*b) {\r
+ int unused = 7;\r
+ uint8_t v = *b;\r
+ v &= -(int8_t)v;\r
+ if(v & 0x0F) unused -= 4;\r
+ if(v & 0x33) unused -= 2;\r
+ if(v & 0x55) unused -= 1;\r
+ tmp->size = b-st->buf + 1;\r
+ tmp->bits_unused = unused;\r
+ } else {\r
+ tmp->size = b-st->buf;\r
+ tmp->bits_unused = 0;\r
+ }\r
+\r
+ assert(b >= st->buf);\r
+ }\r
+\r
+ unconst.c_buf = st->buf;\r
+ tmp->buf = unconst.nc_buf;\r
+ return tmp;\r
+}\r
+\r
+/*\r
+ * Lexicographically compare the common prefix of both strings,\r
+ * and if it is the same return -1 for the smallest string.\r
+ */\r
+int\r
+BIT_STRING_compare(const asn_TYPE_descriptor_t *td, const void *aptr,\r
+ const void *bptr) {\r
+ /*\r
+ * Remove information about trailing bits, since\r
+ * X.680 (08/2015) #22.7 "ensure that different semantics are not"\r
+ * "associated with [values that differ only in] the trailing 0 bits."\r
+ */\r
+ BIT_STRING_t compact_a, compact_b;\r
+ const BIT_STRING_t *a = BIT_STRING__compactify(aptr, &compact_a);\r
+ const BIT_STRING_t *b = BIT_STRING__compactify(bptr, &compact_b);\r
+ const asn_OCTET_STRING_specifics_t *specs = td->specifics;\r
+\r
+ assert(specs && specs->subvariant == ASN_OSUBV_BIT);\r
+\r
+ if(a && b) {\r
+ size_t common_prefix_size = a->size <= b->size ? a->size : b->size;\r
+ int ret = memcmp(a->buf, b->buf, common_prefix_size);\r
+ if(ret == 0) {\r
+ /* Figure out which string with equal prefixes is longer. */\r
+ if(a->size < b->size) {\r
+ return -1;\r
+ } else if(a->size > b->size) {\r
+ return 1;\r
+ } else {\r
+ /* Figure out how many unused bits */\r
+ if(a->bits_unused > b->bits_unused) {\r
+ return -1;\r
+ } else if(a->bits_unused < b->bits_unused) {\r
+ return 1;\r
+ } else {\r
+ return 0;\r
+ }\r
+ }\r
+ } else {\r
+ return ret;\r
+ }\r
+ } else if(!a && !b) {\r
+ return 0;\r
+ } else if(!a) {\r
+ return -1;\r
+ } else {\r
+ return 1;\r
+ }\r
+}\r
+\r
+#ifndef ASN_DISABLE_PER_SUPPORT\r
+\r
+#undef RETURN\r
+#define RETURN(_code) \\r
+ do { \\r
+ asn_dec_rval_t tmprval; \\r
+ tmprval.code = _code; \\r
+ tmprval.consumed = consumed_myself; \\r
+ return tmprval; \\r
+ } while(0)\r
+\r
+static asn_per_constraint_t asn_DEF_BIT_STRING_constraint_size = {\r
+ APC_SEMI_CONSTRAINED, -1, -1, 0, 0};\r
+\r
+asn_dec_rval_t\r
+BIT_STRING_decode_uper(const asn_codec_ctx_t *opt_codec_ctx,\r
+ const asn_TYPE_descriptor_t *td,\r
+ const asn_per_constraints_t *constraints, void **sptr,\r
+ asn_per_data_t *pd) {\r
+ const asn_OCTET_STRING_specifics_t *specs = td->specifics\r
+ ? (const asn_OCTET_STRING_specifics_t *)td->specifics\r
+ : &asn_SPC_BIT_STRING_specs;\r
+ const asn_per_constraints_t *pc =\r
+ constraints ? constraints : td->encoding_constraints.per_constraints;\r
+ const asn_per_constraint_t *csiz;\r
+ asn_dec_rval_t rval = { RC_OK, 0 };\r
+ BIT_STRING_t *st = (BIT_STRING_t *)*sptr;\r
+ ssize_t consumed_myself = 0;\r
+ int repeat;\r
+\r
+ (void)opt_codec_ctx;\r
+\r
+ if(pc) {\r
+ csiz = &pc->size;\r
+ } else {\r
+ csiz = &asn_DEF_BIT_STRING_constraint_size;\r
+ }\r
+\r
+ if(specs->subvariant != ASN_OSUBV_BIT) {\r
+ ASN_DEBUG("Subvariant %d is not BIT OSUBV_BIT", specs->subvariant);\r
+ RETURN(RC_FAIL);\r
+ }\r
+\r
+ /*\r
+ * Allocate the string.\r
+ */\r
+ if(!st) {\r
+ st = (BIT_STRING_t *)(*sptr = CALLOC(1, specs->struct_size));\r
+ if(!st) RETURN(RC_FAIL);\r
+ }\r
+\r
+ ASN_DEBUG("PER Decoding %s size %ld .. %ld bits %d",\r
+ csiz->flags & APC_EXTENSIBLE ? "extensible" : "non-extensible",\r
+ csiz->lower_bound, csiz->upper_bound, csiz->effective_bits);\r
+\r
+ if(csiz->flags & APC_EXTENSIBLE) {\r
+ int inext = per_get_few_bits(pd, 1);\r
+ if(inext < 0) RETURN(RC_WMORE);\r
+ if(inext) {\r
+ csiz = &asn_DEF_BIT_STRING_constraint_size;\r
+ }\r
+ }\r
+\r
+ if(csiz->effective_bits >= 0) {\r
+ FREEMEM(st->buf);\r
+ st->size = (csiz->upper_bound + 7) >> 3;\r
+ st->buf = (uint8_t *)MALLOC(st->size + 1);\r
+ if(!st->buf) { st->size = 0; RETURN(RC_FAIL); }\r
+ }\r
+\r
+ /* X.691, #16.5: zero-length encoding */\r
+ /* X.691, #16.6: short fixed length encoding (up to 2 octets) */\r
+ /* X.691, #16.7: long fixed length encoding (up to 64K octets) */\r
+ if(csiz->effective_bits == 0) {\r
+ int ret;\r
+ ASN_DEBUG("Encoding BIT STRING size %ld", csiz->upper_bound);\r
+ ret = per_get_many_bits(pd, st->buf, 0, csiz->upper_bound);\r
+ if(ret < 0) RETURN(RC_WMORE);\r
+ consumed_myself += csiz->upper_bound;\r
+ st->buf[st->size] = 0;\r
+ st->bits_unused = (8 - (csiz->upper_bound & 0x7)) & 0x7;\r
+ RETURN(RC_OK);\r
+ }\r
+\r
+ st->size = 0;\r
+ do {\r
+ ssize_t raw_len;\r
+ ssize_t len_bytes;\r
+ ssize_t len_bits;\r
+ void *p;\r
+ int ret;\r
+\r
+ /* Get the PER length */\r
+ raw_len = uper_get_length(pd, csiz->effective_bits, csiz->lower_bound,\r
+ &repeat);\r
+ if(raw_len < 0) RETURN(RC_WMORE);\r
+ if(raw_len == 0 && st->buf) break;\r
+\r
+ ASN_DEBUG("Got PER length eb %ld, len %ld, %s (%s)",\r
+ (long)csiz->effective_bits, (long)raw_len,\r
+ repeat ? "repeat" : "once", td->name);\r
+ len_bits = raw_len;\r
+ len_bytes = (len_bits + 7) >> 3;\r
+ if(len_bits & 0x7) st->bits_unused = 8 - (len_bits & 0x7);\r
+ /* len_bits be multiple of 16K if repeat is set */\r
+ p = REALLOC(st->buf, st->size + len_bytes + 1);\r
+ if(!p) RETURN(RC_FAIL);\r
+ st->buf = (uint8_t *)p;\r
+\r
+ ret = per_get_many_bits(pd, &st->buf[st->size], 0, len_bits);\r
+ if(ret < 0) RETURN(RC_WMORE);\r
+ st->size += len_bytes;\r
+ } while(repeat);\r
+ st->buf[st->size] = 0; /* nul-terminate */\r
+\r
+ return rval;\r
+}\r
+\r
+asn_enc_rval_t\r
+BIT_STRING_encode_uper(const asn_TYPE_descriptor_t *td,\r
+ const asn_per_constraints_t *constraints,\r
+ const void *sptr, asn_per_outp_t *po) {\r
+ const asn_OCTET_STRING_specifics_t *specs =\r
+ td->specifics ? (const asn_OCTET_STRING_specifics_t *)td->specifics\r
+ : &asn_SPC_BIT_STRING_specs;\r
+ const asn_per_constraints_t *pc =\r
+ constraints ? constraints : td->encoding_constraints.per_constraints;\r
+ const asn_per_constraint_t *csiz;\r
+ const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;\r
+ BIT_STRING_t compact_bstr; /* Do not modify this directly! */\r
+ asn_enc_rval_t er = { 0, 0, 0 };\r
+ int inext = 0; /* Lies not within extension root */\r
+ size_t size_in_bits;\r
+ const uint8_t *buf;\r
+ int ret;\r
+ int ct_extensible;\r
+\r
+ if(!st || (!st->buf && st->size))\r
+ ASN__ENCODE_FAILED;\r
+\r
+ if(specs->subvariant == ASN_OSUBV_BIT) {\r
+ if((st->size == 0 && st->bits_unused) || (st->bits_unused & ~7))\r
+ ASN__ENCODE_FAILED;\r
+ } else {\r
+ ASN__ENCODE_FAILED;\r
+ }\r
+\r
+ if(pc) {\r
+ csiz = &pc->size;\r
+ } else {\r
+ csiz = &asn_DEF_BIT_STRING_constraint_size;\r
+ }\r
+ ct_extensible = csiz->flags & APC_EXTENSIBLE;\r
+\r
+ /* Figure out the size without the trailing bits */\r
+ st = BIT_STRING__compactify(st, &compact_bstr);\r
+ size_in_bits = 8 * st->size - st->bits_unused;\r
+\r
+ ASN_DEBUG(\r
+ "Encoding %s into %" ASN_PRI_SIZE " bits"\r
+ " (%ld..%ld, effective %d)%s",\r
+ td->name, size_in_bits, csiz->lower_bound, csiz->upper_bound,\r
+ csiz->effective_bits, ct_extensible ? " EXT" : "");\r
+\r
+ /* Figure out whether size lies within PER visible constraint */\r
+\r
+ if(csiz->effective_bits >= 0) {\r
+ if((ssize_t)size_in_bits > csiz->upper_bound) {\r
+ if(ct_extensible) {\r
+ csiz = &asn_DEF_BIT_STRING_constraint_size;\r
+ inext = 1;\r
+ } else {\r
+ ASN__ENCODE_FAILED;\r
+ }\r
+ }\r
+ } else {\r
+ inext = 0;\r
+ }\r
+\r
+ if(ct_extensible) {\r
+ /* Declare whether length is [not] within extension root */\r
+ if(per_put_few_bits(po, inext, 1))\r
+ ASN__ENCODE_FAILED;\r
+ }\r
+\r
+ if(csiz->effective_bits >= 0 && !inext) {\r
+ int add_trailer = (ssize_t)size_in_bits < csiz->lower_bound;\r
+ ASN_DEBUG(\r
+ "Encoding %" ASN_PRI_SIZE " bytes (%ld), length (in %d bits) trailer %d; actual "\r
+ "value %" ASN_PRI_SSIZE "",\r
+ st->size, size_in_bits - csiz->lower_bound, csiz->effective_bits,\r
+ add_trailer,\r
+ add_trailer ? 0 : (ssize_t)size_in_bits - csiz->lower_bound);\r
+ ret = per_put_few_bits(\r
+ po, add_trailer ? 0 : (ssize_t)size_in_bits - csiz->lower_bound,\r
+ csiz->effective_bits);\r
+ if(ret) ASN__ENCODE_FAILED;\r
+ ret = per_put_many_bits(po, st->buf, size_in_bits);\r
+ if(ret) ASN__ENCODE_FAILED;\r
+ if(add_trailer) {\r
+ static const uint8_t zeros[16];\r
+ size_t trailing_zero_bits = csiz->lower_bound - size_in_bits;\r
+ while(trailing_zero_bits > 0) {\r
+ if(trailing_zero_bits > 8 * sizeof(zeros)) {\r
+ ret = per_put_many_bits(po, zeros, 8 * sizeof(zeros));\r
+ trailing_zero_bits -= 8 * sizeof(zeros);\r
+ } else {\r
+ ret = per_put_many_bits(po, zeros, trailing_zero_bits);\r
+ trailing_zero_bits = 0;\r
+ }\r
+ if(ret) ASN__ENCODE_FAILED;\r
+ }\r
+ }\r
+ ASN__ENCODED_OK(er);\r
+ }\r
+\r
+ ASN_DEBUG("Encoding %" ASN_PRI_SIZE " bytes", st->size);\r
+\r
+ buf = st->buf;\r
+ do {\r
+ int need_eom = 0;\r
+ ssize_t maySave = uper_put_length(po, size_in_bits, &need_eom);\r
+ if(maySave < 0) ASN__ENCODE_FAILED;\r
+\r
+ ASN_DEBUG("Encoding %" ASN_PRI_SSIZE " of %" ASN_PRI_SIZE "", maySave, size_in_bits);\r
+\r
+ ret = per_put_many_bits(po, buf, maySave);\r
+ if(ret) ASN__ENCODE_FAILED;\r
+\r
+ buf += maySave >> 3;\r
+ size_in_bits -= maySave;\r
+ assert(!(maySave & 0x07) || !size_in_bits);\r
+ if(need_eom && uper_put_length(po, 0, 0))\r
+ ASN__ENCODE_FAILED; /* End of Message length */\r
+ } while(size_in_bits);\r
+\r
+ ASN__ENCODED_OK(er);\r
+}\r
+\r
+#endif /* ASN_DISABLE_PER_SUPPORT */\r
+\r
+asn_random_fill_result_t\r
+BIT_STRING_random_fill(const asn_TYPE_descriptor_t *td, void **sptr,\r
+ const asn_encoding_constraints_t *constraints,\r
+ size_t max_length) {\r
+ const asn_OCTET_STRING_specifics_t *specs =\r
+ td->specifics ? (const asn_OCTET_STRING_specifics_t *)td->specifics\r
+ : &asn_SPC_BIT_STRING_specs;\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
+ static unsigned lengths[] = {0, 1, 2, 3, 4, 8,\r
+ 126, 127, 128, 16383, 16384, 16385,\r
+ 65534, 65535, 65536, 65537};\r
+ uint8_t *buf;\r
+ uint8_t *bend;\r
+ uint8_t *b;\r
+ size_t rnd_bits, rnd_len;\r
+ BIT_STRING_t *st;\r
+\r
+ if(max_length == 0) return result_skipped;\r
+\r
+ switch(specs->subvariant) {\r
+ case ASN_OSUBV_ANY:\r
+ return result_failed;\r
+ case ASN_OSUBV_BIT:\r
+ break;\r
+ default:\r
+ break;\r
+ }\r
+\r
+ /* Figure out how far we should go */\r
+ rnd_bits = lengths[asn_random_between(\r
+ 0, sizeof(lengths) / sizeof(lengths[0]) - 1)];\r
+ if(!constraints || !constraints->per_constraints)\r
+ constraints = &td->encoding_constraints;\r
+ if(constraints->per_constraints) {\r
+ const asn_per_constraint_t *pc = &constraints->per_constraints->size;\r
+ if(pc->flags & APC_CONSTRAINED) {\r
+ long suggested_upper_bound = pc->upper_bound < (ssize_t)max_length\r
+ ? pc->upper_bound\r
+ : (ssize_t)max_length;\r
+ if(max_length < (size_t)pc->lower_bound) {\r
+ return result_skipped;\r
+ }\r
+ if(pc->flags & APC_EXTENSIBLE) {\r
+ switch(asn_random_between(0, 5)) {\r
+ case 0:\r
+ if(pc->lower_bound > 0) {\r
+ rnd_bits = pc->lower_bound - 1;\r
+ break;\r
+ }\r
+ /* Fall through */\r
+ case 1:\r
+ rnd_bits = pc->upper_bound + 1;\r
+ break;\r
+ case 2:\r
+ /* Keep rnd_bits from the table */\r
+ if(rnd_bits < max_length) {\r
+ break;\r
+ }\r
+ /* Fall through */\r
+ default:\r
+ rnd_bits = asn_random_between(pc->lower_bound,\r
+ suggested_upper_bound);\r
+ }\r
+ } else {\r
+ rnd_bits =\r
+ asn_random_between(pc->lower_bound, suggested_upper_bound);\r
+ }\r
+ } else {\r
+ rnd_bits = asn_random_between(0, max_length - 1);\r
+ }\r
+ } else if(rnd_bits >= max_length) {\r
+ rnd_bits = asn_random_between(0, max_length - 1);\r
+ }\r
+\r
+ rnd_len = (rnd_bits + 7) / 8;\r
+ buf = CALLOC(1, rnd_len + 1);\r
+ if(!buf) return result_failed;\r
+\r
+ bend = &buf[rnd_len];\r
+\r
+ for(b = buf; b < bend; b++) {\r
+ *(uint8_t *)b = asn_random_between(0, 255);\r
+ }\r
+ *b = 0; /* Zero-terminate just in case. */\r
+\r
+ if(*sptr) {\r
+ st = *sptr;\r
+ FREEMEM(st->buf);\r
+ } else {\r
+ st = (BIT_STRING_t *)(*sptr = CALLOC(1, specs->struct_size));\r
+ if(!st) {\r
+ FREEMEM(buf);\r
+ return result_failed;\r
+ }\r
+ }\r
+\r
+ st->buf = buf;\r
+ st->size = rnd_len;\r
+ st->bits_unused = (8 - (rnd_bits & 0x7)) & 0x7;\r
+ if(st->bits_unused) {\r
+ assert(st->size > 0);\r
+ st->buf[st->size-1] &= 0xff << st->bits_unused;\r
+ }\r
+\r
+ result_ok.length = st->size;\r
+ return result_ok;\r
+}\r
Code Review / ric-app / kpimon.git / blobdiff