--- /dev/null
+/*\r
+ * Copyright (c) 2003-2017 Lev Walkin <vlm@lionet.info>.\r
+ * All rights reserved.\r
+ * Redistribution and modifications are permitted subject to BSD license.\r
+ */\r
+#include <asn_internal.h>\r
+#include <constr_SET_OF.h>\r
+#include <asn_SET_OF.h>\r
+\r
+/*\r
+ * Number of bytes left for this structure.\r
+ * (ctx->left) indicates the number of bytes _transferred_ for the structure.\r
+ * (size) contains the number of bytes in the buffer passed.\r
+ */\r
+#define LEFT ((size<(size_t)ctx->left)?size:(size_t)ctx->left)\r
+\r
+/*\r
+ * If the subprocessor function returns with an indication that it wants\r
+ * more data, it may well be a fatal decoding problem, because the\r
+ * size is constrained by the <TLV>'s L, even if the buffer size allows\r
+ * reading more data.\r
+ * For example, consider the buffer containing the following TLVs:\r
+ * <T:5><L:1><V> <T:6>...\r
+ * The TLV length clearly indicates that one byte is expected in V, but\r
+ * if the V processor returns with "want more data" even if the buffer\r
+ * contains way more data than the V processor have seen.\r
+ */\r
+#define SIZE_VIOLATION (ctx->left >= 0 && (size_t)ctx->left <= size)\r
+\r
+/*\r
+ * This macro "eats" the part of the buffer which is definitely "consumed",\r
+ * i.e. was correctly converted into local representation or rightfully skipped.\r
+ */\r
+#undef ADVANCE\r
+#define ADVANCE(num_bytes) do { \\r
+ size_t num = num_bytes; \\r
+ ptr = ((const char *)ptr) + num;\\r
+ size -= num; \\r
+ if(ctx->left >= 0) \\r
+ ctx->left -= num; \\r
+ consumed_myself += num; \\r
+ } while(0)\r
+\r
+/*\r
+ * Switch to the next phase of parsing.\r
+ */\r
+#undef NEXT_PHASE\r
+#undef PHASE_OUT\r
+#define NEXT_PHASE(ctx) do { \\r
+ ctx->phase++; \\r
+ ctx->step = 0; \\r
+ } while(0)\r
+#define PHASE_OUT(ctx) do { ctx->phase = 10; } while(0)\r
+\r
+/*\r
+ * Return a standardized complex structure.\r
+ */\r
+#undef RETURN\r
+#define RETURN(_code) do { \\r
+ rval.code = _code; \\r
+ rval.consumed = consumed_myself;\\r
+ return rval; \\r
+ } while(0)\r
+\r
+/*\r
+ * The decoder of the SET OF type.\r
+ */\r
+asn_dec_rval_t\r
+SET_OF_decode_ber(const asn_codec_ctx_t *opt_codec_ctx,\r
+ const asn_TYPE_descriptor_t *td, void **struct_ptr,\r
+ const void *ptr, size_t size, int tag_mode) {\r
+ /*\r
+ * Bring closer parts of structure description.\r
+ */\r
+ const asn_SET_OF_specifics_t *specs = (const asn_SET_OF_specifics_t *)td->specifics;\r
+ const asn_TYPE_member_t *elm = td->elements; /* Single one */\r
+\r
+ /*\r
+ * Parts of the structure being constructed.\r
+ */\r
+ void *st = *struct_ptr; /* Target structure. */\r
+ asn_struct_ctx_t *ctx; /* Decoder context */\r
+\r
+ ber_tlv_tag_t tlv_tag; /* T from TLV */\r
+ asn_dec_rval_t rval; /* Return code from subparsers */\r
+\r
+ ssize_t consumed_myself = 0; /* Consumed bytes from ptr */\r
+\r
+ ASN_DEBUG("Decoding %s as SET OF", td->name);\r
+ \r
+ /*\r
+ * Create the target structure if it is not present already.\r
+ */\r
+ if(st == 0) {\r
+ st = *struct_ptr = CALLOC(1, specs->struct_size);\r
+ if(st == 0) {\r
+ RETURN(RC_FAIL);\r
+ }\r
+ }\r
+\r
+ /*\r
+ * Restore parsing context.\r
+ */\r
+ ctx = (asn_struct_ctx_t *)((char *)st + specs->ctx_offset);\r
+ \r
+ /*\r
+ * Start to parse where left previously\r
+ */\r
+ switch(ctx->phase) {\r
+ case 0:\r
+ /*\r
+ * PHASE 0.\r
+ * Check that the set of tags associated with given structure\r
+ * perfectly fits our expectations.\r
+ */\r
+\r
+ rval = ber_check_tags(opt_codec_ctx, td, ctx, ptr, size,\r
+ tag_mode, 1, &ctx->left, 0);\r
+ if(rval.code != RC_OK) {\r
+ ASN_DEBUG("%s tagging check failed: %d",\r
+ td->name, rval.code);\r
+ return rval;\r
+ }\r
+\r
+ if(ctx->left >= 0)\r
+ ctx->left += rval.consumed; /* ?Substracted below! */\r
+ ADVANCE(rval.consumed);\r
+\r
+ ASN_DEBUG("Structure consumes %ld bytes, "\r
+ "buffer %ld", (long)ctx->left, (long)size);\r
+\r
+ NEXT_PHASE(ctx);\r
+ /* Fall through */\r
+ case 1:\r
+ /*\r
+ * PHASE 1.\r
+ * From the place where we've left it previously,\r
+ * try to decode the next item.\r
+ */\r
+ for(;; ctx->step = 0) {\r
+ ssize_t tag_len; /* Length of TLV's T */\r
+\r
+ if(ctx->step & 1)\r
+ goto microphase2;\r
+\r
+ /*\r
+ * MICROPHASE 1: Synchronize decoding.\r
+ */\r
+\r
+ if(ctx->left == 0) {\r
+ ASN_DEBUG("End of SET OF %s", td->name);\r
+ /*\r
+ * No more things to decode.\r
+ * Exit out of here.\r
+ */\r
+ PHASE_OUT(ctx);\r
+ RETURN(RC_OK);\r
+ }\r
+\r
+ /*\r
+ * Fetch the T from TLV.\r
+ */\r
+ tag_len = ber_fetch_tag(ptr, LEFT, &tlv_tag);\r
+ switch(tag_len) {\r
+ case 0: if(!SIZE_VIOLATION) RETURN(RC_WMORE);\r
+ /* Fall through */\r
+ case -1: RETURN(RC_FAIL);\r
+ }\r
+\r
+ if(ctx->left < 0 && ((const uint8_t *)ptr)[0] == 0) {\r
+ if(LEFT < 2) {\r
+ if(SIZE_VIOLATION)\r
+ RETURN(RC_FAIL);\r
+ else\r
+ RETURN(RC_WMORE);\r
+ } else if(((const uint8_t *)ptr)[1] == 0) {\r
+ /*\r
+ * Found the terminator of the\r
+ * indefinite length structure.\r
+ */\r
+ break;\r
+ }\r
+ }\r
+\r
+ /* Outmost tag may be unknown and cannot be fetched/compared */\r
+ if(elm->tag != (ber_tlv_tag_t)-1) {\r
+ if(BER_TAGS_EQUAL(tlv_tag, elm->tag)) {\r
+ /*\r
+ * The new list member of expected type has arrived.\r
+ */\r
+ } else {\r
+ ASN_DEBUG("Unexpected tag %s fixed SET OF %s",\r
+ ber_tlv_tag_string(tlv_tag), td->name);\r
+ ASN_DEBUG("%s SET OF has tag %s",\r
+ td->name, ber_tlv_tag_string(elm->tag));\r
+ RETURN(RC_FAIL);\r
+ }\r
+ }\r
+\r
+ /*\r
+ * MICROPHASE 2: Invoke the member-specific decoder.\r
+ */\r
+ ctx->step |= 1; /* Confirm entering next microphase */\r
+ microphase2:\r
+ \r
+ /*\r
+ * Invoke the member fetch routine according to member's type\r
+ */\r
+ rval = elm->type->op->ber_decoder(opt_codec_ctx,\r
+ elm->type, &ctx->ptr, ptr, LEFT, 0);\r
+ ASN_DEBUG("In %s SET OF %s code %d consumed %d",\r
+ td->name, elm->type->name,\r
+ rval.code, (int)rval.consumed);\r
+ switch(rval.code) {\r
+ case RC_OK:\r
+ {\r
+ asn_anonymous_set_ *list = _A_SET_FROM_VOID(st);\r
+ if(ASN_SET_ADD(list, ctx->ptr) != 0)\r
+ RETURN(RC_FAIL);\r
+ else\r
+ ctx->ptr = 0;\r
+ }\r
+ break;\r
+ case RC_WMORE: /* More data expected */\r
+ if(!SIZE_VIOLATION) {\r
+ ADVANCE(rval.consumed);\r
+ RETURN(RC_WMORE);\r
+ }\r
+ /* Fall through */\r
+ case RC_FAIL: /* Fatal error */\r
+ ASN_STRUCT_FREE(*elm->type, ctx->ptr);\r
+ ctx->ptr = 0;\r
+ RETURN(RC_FAIL);\r
+ } /* switch(rval) */\r
+ \r
+ ADVANCE(rval.consumed);\r
+ } /* for(all list members) */\r
+\r
+ NEXT_PHASE(ctx);\r
+ case 2:\r
+ /*\r
+ * Read in all "end of content" TLVs.\r
+ */\r
+ while(ctx->left < 0) {\r
+ if(LEFT < 2) {\r
+ if(LEFT > 0 && ((const char *)ptr)[0] != 0) {\r
+ /* Unexpected tag */\r
+ RETURN(RC_FAIL);\r
+ } else {\r
+ RETURN(RC_WMORE);\r
+ }\r
+ }\r
+ if(((const char *)ptr)[0] == 0\r
+ && ((const char *)ptr)[1] == 0) {\r
+ ADVANCE(2);\r
+ ctx->left++;\r
+ } else {\r
+ RETURN(RC_FAIL);\r
+ }\r
+ }\r
+\r
+ PHASE_OUT(ctx);\r
+ }\r
+ \r
+ RETURN(RC_OK);\r
+}\r
+\r
+/*\r
+ * Internally visible buffer holding a single encoded element.\r
+ */\r
+struct _el_buffer {\r
+ uint8_t *buf;\r
+ size_t length;\r
+ size_t allocated_size;\r
+ unsigned bits_unused;\r
+};\r
+/* Append bytes to the above structure */\r
+static int _el_addbytes(const void *buffer, size_t size, void *el_buf_ptr) {\r
+ struct _el_buffer *el_buf = (struct _el_buffer *)el_buf_ptr;\r
+\r
+ if(el_buf->length + size > el_buf->allocated_size) {\r
+ size_t new_size = el_buf->allocated_size ? el_buf->allocated_size : 8;\r
+ void *p;\r
+\r
+ do {\r
+ new_size <<= 2;\r
+ } while(el_buf->length + size > new_size);\r
+\r
+ p = REALLOC(el_buf->buf, new_size);\r
+ if(p) {\r
+ el_buf->buf = p;\r
+ el_buf->allocated_size = new_size;\r
+ } else {\r
+ return -1;\r
+ }\r
+ }\r
+\r
+ memcpy(el_buf->buf + el_buf->length, buffer, size);\r
+\r
+ el_buf->length += size;\r
+ return 0;\r
+}\r
+\r
+static void assert_unused_bits(const struct _el_buffer* p) {\r
+ if(p->length) {\r
+ assert((p->buf[p->length-1] & ~(0xff << p->bits_unused)) == 0);\r
+ } else {\r
+ assert(p->bits_unused == 0);\r
+ }\r
+}\r
+\r
+static int _el_buf_cmp(const void *ap, const void *bp) {\r
+ const struct _el_buffer *a = (const struct _el_buffer *)ap;\r
+ const struct _el_buffer *b = (const struct _el_buffer *)bp;\r
+ size_t common_len;\r
+ int ret = 0;\r
+\r
+ if(a->length < b->length)\r
+ common_len = a->length;\r
+ else\r
+ common_len = b->length;\r
+\r
+ if (a->buf && b->buf) {\r
+ ret = memcmp(a->buf, b->buf, common_len);\r
+ }\r
+ if(ret == 0) {\r
+ if(a->length < b->length)\r
+ ret = -1;\r
+ else if(a->length > b->length)\r
+ ret = 1;\r
+ /* Ignore unused bits. */\r
+ assert_unused_bits(a);\r
+ assert_unused_bits(b);\r
+ }\r
+\r
+ return ret;\r
+}\r
+\r
+static void\r
+SET_OF__encode_sorted_free(struct _el_buffer *el_buf, size_t count) {\r
+ size_t i;\r
+\r
+ for(i = 0; i < count; i++) {\r
+ FREEMEM(el_buf[i].buf);\r
+ }\r
+\r
+ FREEMEM(el_buf);\r
+}\r
+\r
+enum SET_OF__encode_method {\r
+ SOES_DER, /* Distinguished Encoding Rules */\r
+ SOES_CUPER /* Canonical Unaligned Packed Encoding Rules */\r
+};\r
+\r
+static struct _el_buffer *\r
+SET_OF__encode_sorted(const asn_TYPE_member_t *elm,\r
+ const asn_anonymous_set_ *list,\r
+ enum SET_OF__encode_method method) {\r
+ struct _el_buffer *encoded_els;\r
+ int edx;\r
+\r
+ encoded_els =\r
+ (struct _el_buffer *)CALLOC(list->count, sizeof(encoded_els[0]));\r
+ if(encoded_els == NULL) {\r
+ return NULL;\r
+ }\r
+\r
+ /*\r
+ * Encode all members.\r
+ */\r
+ for(edx = 0; edx < list->count; edx++) {\r
+ const void *memb_ptr = list->array[edx];\r
+ struct _el_buffer *encoding_el = &encoded_els[edx];\r
+ asn_enc_rval_t erval = {0,0,0};\r
+\r
+ if(!memb_ptr) break;\r
+\r
+ /*\r
+ * Encode the member into the prepared space.\r
+ */\r
+ switch(method) {\r
+ case SOES_DER:\r
+ erval = elm->type->op->der_encoder(elm->type, memb_ptr, 0, elm->tag,\r
+ _el_addbytes, encoding_el);\r
+ break;\r
+ case SOES_CUPER:\r
+ erval = uper_encode(elm->type,\r
+ elm->encoding_constraints.per_constraints,\r
+ memb_ptr, _el_addbytes, encoding_el);\r
+ if(erval.encoded != -1) {\r
+ size_t extra_bits = erval.encoded % 8;\r
+ assert(encoding_el->length == (size_t)(erval.encoded + 7) / 8);\r
+ encoding_el->bits_unused = (8 - extra_bits) & 0x7;\r
+ }\r
+ break;\r
+ default:\r
+ assert(!"Unreachable");\r
+ break;\r
+ }\r
+ if(erval.encoded < 0) break;\r
+ }\r
+\r
+ if(edx == list->count) {\r
+ /*\r
+ * Sort the encoded elements according to their encoding.\r
+ */\r
+ qsort(encoded_els, list->count, sizeof(encoded_els[0]), _el_buf_cmp);\r
+\r
+ return encoded_els;\r
+ } else {\r
+ SET_OF__encode_sorted_free(encoded_els, edx);\r
+ return NULL;\r
+ }\r
+}\r
+\r
+\r
+/*\r
+ * The DER encoder of the SET OF type.\r
+ */\r
+asn_enc_rval_t\r
+SET_OF_encode_der(const asn_TYPE_descriptor_t *td, const void *sptr,\r
+ int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb,\r
+ void *app_key) {\r
+ const asn_TYPE_member_t *elm = td->elements;\r
+ const asn_anonymous_set_ *list = _A_CSET_FROM_VOID(sptr);\r
+ size_t computed_size = 0;\r
+ ssize_t encoding_size = 0;\r
+ struct _el_buffer *encoded_els;\r
+ int edx;\r
+\r
+ ASN_DEBUG("Estimating size for SET OF %s", td->name);\r
+\r
+ /*\r
+ * Gather the length of the underlying members sequence.\r
+ */\r
+ for(edx = 0; edx < list->count; edx++) {\r
+ void *memb_ptr = list->array[edx];\r
+ asn_enc_rval_t erval = {0,0,0};\r
+\r
+ if(!memb_ptr) ASN__ENCODE_FAILED;\r
+\r
+ erval =\r
+ elm->type->op->der_encoder(elm->type, memb_ptr, 0, elm->tag, 0, 0);\r
+ if(erval.encoded == -1) return erval;\r
+ computed_size += erval.encoded;\r
+ }\r
+\r
+\r
+ /*\r
+ * Encode the TLV for the sequence itself.\r
+ */\r
+ encoding_size =\r
+ der_write_tags(td, computed_size, tag_mode, 1, tag, cb, app_key);\r
+ if(encoding_size < 0) {\r
+ ASN__ENCODE_FAILED;\r
+ }\r
+ computed_size += encoding_size;\r
+\r
+ if(!cb || list->count == 0) {\r
+ asn_enc_rval_t erval = {0,0,0};\r
+ erval.encoded = computed_size;\r
+ ASN__ENCODED_OK(erval);\r
+ }\r
+\r
+ ASN_DEBUG("Encoding members of %s SET OF", td->name);\r
+\r
+ /*\r
+ * DER mandates dynamic sorting of the SET OF elements\r
+ * according to their encodings. Build an array of the\r
+ * encoded elements.\r
+ */\r
+ encoded_els = SET_OF__encode_sorted(elm, list, SOES_DER);\r
+\r
+ /*\r
+ * Report encoded elements to the application.\r
+ * Dispose of temporary sorted members table.\r
+ */\r
+ for(edx = 0; edx < list->count; edx++) {\r
+ struct _el_buffer *encoded_el = &encoded_els[edx];\r
+ /* Report encoded chunks to the application */\r
+ if(cb(encoded_el->buf, encoded_el->length, app_key) < 0) {\r
+ break;\r
+ } else {\r
+ encoding_size += encoded_el->length;\r
+ }\r
+ }\r
+\r
+ SET_OF__encode_sorted_free(encoded_els, list->count);\r
+\r
+ if(edx == list->count) {\r
+ asn_enc_rval_t erval = {0,0,0};\r
+ assert(computed_size == (size_t)encoding_size);\r
+ erval.encoded = computed_size;\r
+ ASN__ENCODED_OK(erval);\r
+ } else {\r
+ ASN__ENCODE_FAILED;\r
+ }\r
+}\r
+\r
+#undef XER_ADVANCE\r
+#define XER_ADVANCE(num_bytes) do { \\r
+ size_t num = num_bytes; \\r
+ buf_ptr = ((const char *)buf_ptr) + num;\\r
+ size -= num; \\r
+ consumed_myself += num; \\r
+ } while(0)\r
+\r
+/*\r
+ * Decode the XER (XML) data.\r
+ */\r
+asn_dec_rval_t\r
+SET_OF_decode_xer(const asn_codec_ctx_t *opt_codec_ctx,\r
+ const asn_TYPE_descriptor_t *td, void **struct_ptr,\r
+ const char *opt_mname, const void *buf_ptr, size_t size) {\r
+ /*\r
+ * Bring closer parts of structure description.\r
+ */\r
+ const asn_SET_OF_specifics_t *specs = (const asn_SET_OF_specifics_t *)td->specifics;\r
+ const asn_TYPE_member_t *element = td->elements;\r
+ const char *elm_tag;\r
+ const char *xml_tag = opt_mname ? opt_mname : td->xml_tag;\r
+\r
+ /*\r
+ * ... and parts of the structure being constructed.\r
+ */\r
+ void *st = *struct_ptr; /* Target structure. */\r
+ asn_struct_ctx_t *ctx; /* Decoder context */\r
+\r
+ asn_dec_rval_t rval = {RC_OK, 0};/* Return value from a decoder */\r
+ ssize_t consumed_myself = 0; /* Consumed bytes from ptr */\r
+\r
+ /*\r
+ * Create the target structure if it is not present already.\r
+ */\r
+ if(st == 0) {\r
+ st = *struct_ptr = CALLOC(1, specs->struct_size);\r
+ if(st == 0) RETURN(RC_FAIL);\r
+ }\r
+\r
+ /* Which tag is expected for the downstream */\r
+ if(specs->as_XMLValueList) {\r
+ elm_tag = (specs->as_XMLValueList == 1) ? 0 : "";\r
+ } else {\r
+ elm_tag = (*element->name)\r
+ ? element->name : element->type->xml_tag;\r
+ }\r
+\r
+ /*\r
+ * Restore parsing context.\r
+ */\r
+ ctx = (asn_struct_ctx_t *)((char *)st + specs->ctx_offset);\r
+\r
+ /*\r
+ * Phases of XER/XML processing:\r
+ * Phase 0: Check that the opening tag matches our expectations.\r
+ * Phase 1: Processing body and reacting on closing tag.\r
+ * Phase 2: Processing inner type.\r
+ */\r
+ for(; ctx->phase <= 2;) {\r
+ pxer_chunk_type_e ch_type; /* XER chunk type */\r
+ ssize_t ch_size; /* Chunk size */\r
+ xer_check_tag_e tcv; /* Tag check value */\r
+\r
+ /*\r
+ * Go inside the inner member of a set.\r
+ */\r
+ if(ctx->phase == 2) {\r
+ asn_dec_rval_t tmprval = {RC_OK, 0};\r
+\r
+ /* Invoke the inner type decoder, m.b. multiple times */\r
+ ASN_DEBUG("XER/SET OF element [%s]", elm_tag);\r
+ tmprval = element->type->op->xer_decoder(opt_codec_ctx,\r
+ element->type, &ctx->ptr, elm_tag,\r
+ buf_ptr, size);\r
+ if(tmprval.code == RC_OK) {\r
+ asn_anonymous_set_ *list = _A_SET_FROM_VOID(st);\r
+ if(ASN_SET_ADD(list, ctx->ptr) != 0)\r
+ RETURN(RC_FAIL);\r
+ ctx->ptr = 0;\r
+ XER_ADVANCE(tmprval.consumed);\r
+ } else {\r
+ XER_ADVANCE(tmprval.consumed);\r
+ RETURN(tmprval.code);\r
+ }\r
+ ctx->phase = 1; /* Back to body processing */\r
+ ASN_DEBUG("XER/SET OF phase => %d", ctx->phase);\r
+ /* Fall through */\r
+ }\r
+\r
+ /*\r
+ * Get the next part of the XML stream.\r
+ */\r
+ ch_size = xer_next_token(&ctx->context,\r
+ buf_ptr, size, &ch_type);\r
+ if(ch_size == -1) {\r
+ RETURN(RC_FAIL);\r
+ } else {\r
+ switch(ch_type) {\r
+ case PXER_WMORE:\r
+ RETURN(RC_WMORE);\r
+ case PXER_COMMENT: /* Got XML comment */\r
+ case PXER_TEXT: /* Ignore free-standing text */\r
+ XER_ADVANCE(ch_size); /* Skip silently */\r
+ continue;\r
+ case PXER_TAG:\r
+ break; /* Check the rest down there */\r
+ }\r
+ }\r
+\r
+ tcv = xer_check_tag(buf_ptr, ch_size, xml_tag);\r
+ ASN_DEBUG("XER/SET OF: tcv = %d, ph=%d t=%s",\r
+ tcv, ctx->phase, xml_tag);\r
+ switch(tcv) {\r
+ case XCT_CLOSING:\r
+ if(ctx->phase == 0) break;\r
+ ctx->phase = 0;\r
+ /* Fall through */\r
+ case XCT_BOTH:\r
+ if(ctx->phase == 0) {\r
+ /* No more things to decode */\r
+ XER_ADVANCE(ch_size);\r
+ ctx->phase = 3; /* Phase out */\r
+ RETURN(RC_OK);\r
+ }\r
+ /* Fall through */\r
+ case XCT_OPENING:\r
+ if(ctx->phase == 0) {\r
+ XER_ADVANCE(ch_size);\r
+ ctx->phase = 1; /* Processing body phase */\r
+ continue;\r
+ }\r
+ /* Fall through */\r
+ case XCT_UNKNOWN_OP:\r
+ case XCT_UNKNOWN_BO:\r
+\r
+ ASN_DEBUG("XER/SET OF: tcv=%d, ph=%d", tcv, ctx->phase);\r
+ if(ctx->phase == 1) {\r
+ /*\r
+ * Process a single possible member.\r
+ */\r
+ ctx->phase = 2;\r
+ continue;\r
+ }\r
+ /* Fall through */\r
+ default:\r
+ break;\r
+ }\r
+\r
+ ASN_DEBUG("Unexpected XML tag in SET OF");\r
+ break;\r
+ }\r
+\r
+ ctx->phase = 3; /* "Phase out" on hard failure */\r
+ RETURN(RC_FAIL);\r
+}\r
+\r
+\r
+\r
+typedef struct xer_tmp_enc_s {\r
+ void *buffer;\r
+ size_t offset;\r
+ size_t size;\r
+} xer_tmp_enc_t;\r
+static int\r
+SET_OF_encode_xer_callback(const void *buffer, size_t size, void *key) {\r
+ xer_tmp_enc_t *t = (xer_tmp_enc_t *)key;\r
+ if(t->offset + size >= t->size) {\r
+ size_t newsize = (t->size << 2) + size;\r
+ void *p = REALLOC(t->buffer, newsize);\r
+ if(!p) return -1;\r
+ t->buffer = p;\r
+ t->size = newsize;\r
+ }\r
+ memcpy((char *)t->buffer + t->offset, buffer, size);\r
+ t->offset += size;\r
+ return 0;\r
+}\r
+static int\r
+SET_OF_xer_order(const void *aptr, const void *bptr) {\r
+ const xer_tmp_enc_t *a = (const xer_tmp_enc_t *)aptr;\r
+ const xer_tmp_enc_t *b = (const xer_tmp_enc_t *)bptr;\r
+ size_t minlen = a->offset;\r
+ int ret;\r
+ if(b->offset < minlen) minlen = b->offset;\r
+ /* Well-formed UTF-8 has this nice lexicographical property... */\r
+ ret = memcmp(a->buffer, b->buffer, minlen);\r
+ if(ret != 0) return ret;\r
+ if(a->offset == b->offset)\r
+ return 0;\r
+ if(a->offset == minlen)\r
+ return -1;\r
+ return 1;\r
+}\r
+\r
+\r
+asn_enc_rval_t\r
+SET_OF_encode_xer(const asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,\r
+ enum xer_encoder_flags_e flags, asn_app_consume_bytes_f *cb,\r
+ void *app_key) {\r
+ asn_enc_rval_t er = {0,0,0};\r
+ const asn_SET_OF_specifics_t *specs = (const asn_SET_OF_specifics_t *)td->specifics;\r
+ const asn_TYPE_member_t *elm = td->elements;\r
+ const asn_anonymous_set_ *list = _A_CSET_FROM_VOID(sptr);\r
+ const char *mname = specs->as_XMLValueList\r
+ ? 0 : ((*elm->name) ? elm->name : elm->type->xml_tag);\r
+ size_t mlen = mname ? strlen(mname) : 0;\r
+ int xcan = (flags & XER_F_CANONICAL);\r
+ xer_tmp_enc_t *encs = 0;\r
+ size_t encs_count = 0;\r
+ void *original_app_key = app_key;\r
+ asn_app_consume_bytes_f *original_cb = cb;\r
+ int i;\r
+\r
+ if(!sptr) ASN__ENCODE_FAILED;\r
+\r
+ if(xcan) {\r
+ encs = (xer_tmp_enc_t *)MALLOC(list->count * sizeof(encs[0]));\r
+ if(!encs) ASN__ENCODE_FAILED;\r
+ cb = SET_OF_encode_xer_callback;\r
+ }\r
+\r
+ er.encoded = 0;\r
+\r
+ for(i = 0; i < list->count; i++) {\r
+ asn_enc_rval_t tmper = {0,0,0};\r
+\r
+ void *memb_ptr = list->array[i];\r
+ if(!memb_ptr) continue;\r
+\r
+ if(encs) {\r
+ memset(&encs[encs_count], 0, sizeof(encs[0]));\r
+ app_key = &encs[encs_count];\r
+ encs_count++;\r
+ }\r
+\r
+ if(mname) {\r
+ if(!xcan) ASN__TEXT_INDENT(1, ilevel);\r
+ ASN__CALLBACK3("<", 1, mname, mlen, ">", 1);\r
+ }\r
+\r
+ if(!xcan && specs->as_XMLValueList == 1)\r
+ ASN__TEXT_INDENT(1, ilevel + 1);\r
+ tmper = elm->type->op->xer_encoder(elm->type, memb_ptr,\r
+ ilevel + (specs->as_XMLValueList != 2),\r
+ flags, cb, app_key);\r
+ if(tmper.encoded == -1) return tmper;\r
+ er.encoded += tmper.encoded;\r
+ if(tmper.encoded == 0 && specs->as_XMLValueList) {\r
+ const char *name = elm->type->xml_tag;\r
+ size_t len = strlen(name);\r
+ ASN__CALLBACK3("<", 1, name, len, "/>", 2);\r
+ }\r
+\r
+ if(mname) {\r
+ ASN__CALLBACK3("</", 2, mname, mlen, ">", 1);\r
+ }\r
+\r
+ }\r
+\r
+ if(!xcan) ASN__TEXT_INDENT(1, ilevel - 1);\r
+\r
+ if(encs) {\r
+ xer_tmp_enc_t *enc = encs;\r
+ xer_tmp_enc_t *end = encs + encs_count;\r
+ ssize_t control_size = 0;\r
+\r
+ er.encoded = 0;\r
+ cb = original_cb;\r
+ app_key = original_app_key;\r
+ qsort(encs, encs_count, sizeof(encs[0]), SET_OF_xer_order);\r
+\r
+ for(; enc < end; enc++) {\r
+ ASN__CALLBACK(enc->buffer, enc->offset);\r
+ FREEMEM(enc->buffer);\r
+ enc->buffer = 0;\r
+ control_size += enc->offset;\r
+ }\r
+ assert(control_size == er.encoded);\r
+ }\r
+\r
+ goto cleanup;\r
+cb_failed:\r
+ ASN__ENCODE_FAILED;\r
+cleanup:\r
+ if(encs) {\r
+ size_t n;\r
+ for(n = 0; n < encs_count; n++) {\r
+ FREEMEM(encs[n].buffer);\r
+ }\r
+ FREEMEM(encs);\r
+ }\r
+ ASN__ENCODED_OK(er);\r
+}\r
+\r
+int\r
+SET_OF_print(const asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,\r
+ asn_app_consume_bytes_f *cb, void *app_key) {\r
+ asn_TYPE_member_t *elm = td->elements;\r
+ const asn_anonymous_set_ *list = _A_CSET_FROM_VOID(sptr);\r
+ int ret;\r
+ int i;\r
+\r
+ if(!sptr) return (cb("<absent>", 8, app_key) < 0) ? -1 : 0;\r
+\r
+ /* Dump preamble */\r
+ if(cb(td->name, strlen(td->name), app_key) < 0\r
+ || cb(" ::= {", 6, app_key) < 0)\r
+ return -1;\r
+\r
+ for(i = 0; i < list->count; i++) {\r
+ const void *memb_ptr = list->array[i];\r
+ if(!memb_ptr) continue;\r
+\r
+ _i_INDENT(1);\r
+\r
+ ret = elm->type->op->print_struct(elm->type, memb_ptr,\r
+ ilevel + 1, cb, app_key);\r
+ if(ret) return ret;\r
+ }\r
+\r
+ ilevel--;\r
+ _i_INDENT(1);\r
+\r
+ return (cb("}", 1, app_key) < 0) ? -1 : 0;\r
+}\r
+\r
+void\r
+SET_OF_free(const asn_TYPE_descriptor_t *td, void *ptr,\r
+ enum asn_struct_free_method method) {\r
+ if(td && ptr) {\r
+ const asn_SET_OF_specifics_t *specs;\r
+ asn_TYPE_member_t *elm = td->elements;\r
+ asn_anonymous_set_ *list = _A_SET_FROM_VOID(ptr);\r
+ asn_struct_ctx_t *ctx; /* Decoder context */\r
+ int i;\r
+\r
+ /*\r
+ * Could not use set_of_empty() because of (*free)\r
+ * incompatibility.\r
+ */\r
+ for(i = 0; i < list->count; i++) {\r
+ void *memb_ptr = list->array[i];\r
+ if(memb_ptr)\r
+ ASN_STRUCT_FREE(*elm->type, memb_ptr);\r
+ }\r
+ list->count = 0; /* No meaningful elements left */\r
+\r
+ asn_set_empty(list); /* Remove (list->array) */\r
+\r
+ specs = (const asn_SET_OF_specifics_t *)td->specifics;\r
+ ctx = (asn_struct_ctx_t *)((char *)ptr + specs->ctx_offset);\r
+ if(ctx->ptr) {\r
+ ASN_STRUCT_FREE(*elm->type, ctx->ptr);\r
+ ctx->ptr = 0;\r
+ }\r
+\r
+ switch(method) {\r
+ case ASFM_FREE_EVERYTHING:\r
+ FREEMEM(ptr);\r
+ break;\r
+ case ASFM_FREE_UNDERLYING:\r
+ break;\r
+ case ASFM_FREE_UNDERLYING_AND_RESET:\r
+ memset(ptr, 0, specs->struct_size);\r
+ break;\r
+ }\r
+ }\r
+}\r
+\r
+int\r
+SET_OF_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,\r
+ asn_app_constraint_failed_f *ctfailcb, void *app_key) {\r
+ const asn_TYPE_member_t *elm = td->elements;\r
+ asn_constr_check_f *constr;\r
+ const asn_anonymous_set_ *list = _A_CSET_FROM_VOID(sptr);\r
+ int i;\r
+\r
+ if(!sptr) {\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
+ constr = elm->encoding_constraints.general_constraints;\r
+ if(!constr) constr = elm->type->encoding_constraints.general_constraints;\r
+\r
+ /*\r
+ * Iterate over the members of an array.\r
+ * Validate each in turn, until one fails.\r
+ */\r
+ for(i = 0; i < list->count; i++) {\r
+ const void *memb_ptr = list->array[i];\r
+ int ret;\r
+\r
+ if(!memb_ptr) continue;\r
+\r
+ ret = constr(elm->type, memb_ptr, ctfailcb, app_key);\r
+ if(ret) return ret;\r
+ }\r
+\r
+ return 0;\r
+}\r
+\r
+#ifndef ASN_DISABLE_PER_SUPPORT\r
+\r
+asn_dec_rval_t\r
+SET_OF_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
+ asn_dec_rval_t rv = {RC_OK, 0};\r
+ const asn_SET_OF_specifics_t *specs = (const asn_SET_OF_specifics_t *)td->specifics;\r
+ const asn_TYPE_member_t *elm = td->elements; /* Single one */\r
+ void *st = *sptr;\r
+ asn_anonymous_set_ *list;\r
+ const asn_per_constraint_t *ct;\r
+ int repeat = 0;\r
+ ssize_t nelems;\r
+\r
+ if(ASN__STACK_OVERFLOW_CHECK(opt_codec_ctx))\r
+ ASN__DECODE_FAILED;\r
+\r
+ /*\r
+ * Create the target structure if it is not present already.\r
+ */\r
+ if(!st) {\r
+ st = *sptr = CALLOC(1, specs->struct_size);\r
+ if(!st) ASN__DECODE_FAILED;\r
+ } \r
+ list = _A_SET_FROM_VOID(st);\r
+\r
+ /* Figure out which constraints to use */\r
+ if(constraints) ct = &constraints->size;\r
+ else if(td->encoding_constraints.per_constraints)\r
+ ct = &td->encoding_constraints.per_constraints->size;\r
+ else ct = 0;\r
+\r
+ if(ct && ct->flags & APC_EXTENSIBLE) {\r
+ int value = per_get_few_bits(pd, 1);\r
+ if(value < 0) ASN__DECODE_STARVED;\r
+ if(value) ct = 0; /* Not restricted! */\r
+ }\r
+\r
+ if(ct && ct->effective_bits >= 0) {\r
+ /* X.691, #19.5: No length determinant */\r
+ nelems = per_get_few_bits(pd, ct->effective_bits);\r
+ ASN_DEBUG("Preparing to fetch %ld+%ld elements from %s",\r
+ (long)nelems, ct->lower_bound, td->name);\r
+ if(nelems < 0) ASN__DECODE_STARVED;\r
+ nelems += ct->lower_bound;\r
+ } else {\r
+ nelems = -1;\r
+ }\r
+\r
+ do {\r
+ int i;\r
+ if(nelems < 0) {\r
+ nelems = uper_get_length(pd, -1, 0, &repeat);\r
+ ASN_DEBUG("Got to decode %" ASN_PRI_SSIZE " elements (eff %d)",\r
+ nelems, (int)(ct ? ct->effective_bits : -1));\r
+ if(nelems < 0) ASN__DECODE_STARVED;\r
+ }\r
+\r
+ for(i = 0; i < nelems; i++) {\r
+ void *ptr = 0;\r
+ ASN_DEBUG("SET OF %s decoding", elm->type->name);\r
+ rv = elm->type->op->uper_decoder(opt_codec_ctx, elm->type,\r
+ elm->encoding_constraints.per_constraints, &ptr, pd);\r
+ ASN_DEBUG("%s SET OF %s decoded %d, %p",\r
+ td->name, elm->type->name, rv.code, ptr);\r
+ if(rv.code == RC_OK) {\r
+ if(ASN_SET_ADD(list, ptr) == 0) {\r
+ if(rv.consumed == 0 && nelems > 200) {\r
+ /* Protect from SET OF NULL compression bombs. */\r
+ ASN__DECODE_FAILED;\r
+ }\r
+ continue;\r
+ }\r
+ ASN_DEBUG("Failed to add element into %s",\r
+ td->name);\r
+ /* Fall through */\r
+ rv.code = RC_FAIL;\r
+ } else {\r
+ ASN_DEBUG("Failed decoding %s of %s (SET OF)",\r
+ elm->type->name, td->name);\r
+ }\r
+ if(ptr) ASN_STRUCT_FREE(*elm->type, ptr);\r
+ return rv;\r
+ }\r
+\r
+ nelems = -1; /* Allow uper_get_length() */\r
+ } while(repeat);\r
+\r
+ ASN_DEBUG("Decoded %s as SET OF", td->name);\r
+\r
+ rv.code = RC_OK;\r
+ rv.consumed = 0;\r
+ return rv;\r
+}\r
+\r
+asn_enc_rval_t\r
+SET_OF_encode_uper(const asn_TYPE_descriptor_t *td,\r
+ const asn_per_constraints_t *constraints, const void *sptr,\r
+ asn_per_outp_t *po) {\r
+ const asn_anonymous_set_ *list;\r
+ const asn_per_constraint_t *ct;\r
+ const asn_TYPE_member_t *elm = td->elements;\r
+ struct _el_buffer *encoded_els;\r
+ asn_enc_rval_t er = {0,0,0};\r
+ size_t encoded_edx;\r
+\r
+ if(!sptr) ASN__ENCODE_FAILED;\r
+\r
+ list = _A_CSET_FROM_VOID(sptr);\r
+\r
+ er.encoded = 0;\r
+\r
+ ASN_DEBUG("Encoding %s as SEQUENCE OF (%d)", td->name, list->count);\r
+\r
+ if(constraints) ct = &constraints->size;\r
+ else if(td->encoding_constraints.per_constraints)\r
+ ct = &td->encoding_constraints.per_constraints->size;\r
+ else ct = 0;\r
+\r
+ /* If extensible constraint, check if size is in root */\r
+ if(ct) {\r
+ int not_in_root =\r
+ (list->count < ct->lower_bound || list->count > ct->upper_bound);\r
+ ASN_DEBUG("lb %ld ub %ld %s", ct->lower_bound, ct->upper_bound,\r
+ ct->flags & APC_EXTENSIBLE ? "ext" : "fix");\r
+ if(ct->flags & APC_EXTENSIBLE) {\r
+ /* Declare whether size is in extension root */\r
+ if(per_put_few_bits(po, not_in_root, 1)) ASN__ENCODE_FAILED;\r
+ if(not_in_root) ct = 0;\r
+ } else if(not_in_root && ct->effective_bits >= 0) {\r
+ ASN__ENCODE_FAILED;\r
+ }\r
+\r
+ }\r
+\r
+ if(ct && ct->effective_bits >= 0) {\r
+ /* X.691, #19.5: No length determinant */\r
+ if(per_put_few_bits(po, list->count - ct->lower_bound,\r
+ ct->effective_bits))\r
+ ASN__ENCODE_FAILED;\r
+ } else if(list->count == 0) {\r
+ /* When the list is empty add only the length determinant\r
+ * X.691, #20.6 and #11.9.4.1\r
+ */\r
+ if (uper_put_length(po, 0, 0)) {\r
+ ASN__ENCODE_FAILED;\r
+ }\r
+ ASN__ENCODED_OK(er);\r
+ }\r
+\r
+\r
+ /*\r
+ * Canonical UPER #22.1 mandates dynamic sorting of the SET OF elements\r
+ * according to their encodings. Build an array of the encoded elements.\r
+ */\r
+ encoded_els = SET_OF__encode_sorted(elm, list, SOES_CUPER);\r
+\r
+ for(encoded_edx = 0; (ssize_t)encoded_edx < list->count;) {\r
+ ssize_t may_encode;\r
+ size_t edx;\r
+ int need_eom = 0;\r
+\r
+ if(ct && ct->effective_bits >= 0) {\r
+ may_encode = list->count;\r
+ } else {\r
+ may_encode =\r
+ uper_put_length(po, list->count - encoded_edx, &need_eom);\r
+ if(may_encode < 0) ASN__ENCODE_FAILED;\r
+ }\r
+\r
+ for(edx = encoded_edx; edx < encoded_edx + may_encode; edx++) {\r
+ const struct _el_buffer *el = &encoded_els[edx];\r
+ if(asn_put_many_bits(po, el->buf,\r
+ (8 * el->length) - el->bits_unused) < 0) {\r
+ break;\r
+ }\r
+ }\r
+\r
+ if(need_eom && uper_put_length(po, 0, 0))\r
+ ASN__ENCODE_FAILED; /* End of Message length */\r
+\r
+ encoded_edx += may_encode;\r
+ }\r
+\r
+ SET_OF__encode_sorted_free(encoded_els, list->count);\r
+\r
+ if((ssize_t)encoded_edx == list->count) {\r
+ ASN__ENCODED_OK(er);\r
+ } else {\r
+ ASN__ENCODE_FAILED;\r
+ }\r
+}\r
+\r
+asn_dec_rval_t\r
+SET_OF_decode_aper(const asn_codec_ctx_t *opt_codec_ctx,\r
+ const asn_TYPE_descriptor_t *td,\r
+ const asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) {\r
+ asn_dec_rval_t rv = {RC_OK, 0};\r
+ const asn_SET_OF_specifics_t *specs = (const asn_SET_OF_specifics_t *)td->specifics;\r
+ const asn_TYPE_member_t *elm = td->elements; /* Single one */\r
+ void *st = *sptr;\r
+ asn_anonymous_set_ *list;\r
+ const asn_per_constraint_t *ct;\r
+ int repeat = 0;\r
+ ssize_t nelems;\r
+\r
+ if(ASN__STACK_OVERFLOW_CHECK(opt_codec_ctx))\r
+ ASN__DECODE_FAILED;\r
+\r
+ /*\r
+ * Create the target structure if it is not present already.\r
+ */\r
+ if(!st) {\r
+ st = *sptr = CALLOC(1, specs->struct_size);\r
+ if(!st) ASN__DECODE_FAILED;\r
+ }\r
+ list = _A_SET_FROM_VOID(st);\r
+\r
+ /* Figure out which constraints to use */\r
+ if(constraints) ct = &constraints->size;\r
+ else if(td->encoding_constraints.per_constraints)\r
+ ct = &td->encoding_constraints.per_constraints->size;\r
+ else ct = 0;\r
+\r
+ if(ct && ct->flags & APC_EXTENSIBLE) {\r
+ int value = per_get_few_bits(pd, 1);\r
+ if(value < 0) ASN__DECODE_STARVED;\r
+ if(value) ct = 0; /* Not restricted! */\r
+ }\r
+\r
+ if(ct && ct->effective_bits >= 0) {\r
+ /* X.691, #19.5: No length determinant */\r
+ nelems = aper_get_nsnnwn(pd, ct->upper_bound - ct->lower_bound + 1);\r
+ ASN_DEBUG("Preparing to fetch %ld+%ld elements from %s",\r
+ (long)nelems, ct->lower_bound, td->name);\r
+ if(nelems < 0) ASN__DECODE_STARVED;\r
+ nelems += ct->lower_bound;\r
+ } else {\r
+ nelems = -1;\r
+ }\r
+\r
+ do {\r
+ int i;\r
+ if(nelems < 0) {\r
+ nelems = aper_get_length(pd, ct ? ct->upper_bound - ct->lower_bound + 1 : -1,\r
+ ct ? ct->effective_bits : -1, &repeat);\r
+ ASN_DEBUG("Got to decode %d elements (eff %d)",\r
+ (int)nelems, (int)(ct ? ct->effective_bits : -1));\r
+ if(nelems < 0) ASN__DECODE_STARVED;\r
+ }\r
+\r
+ for(i = 0; i < nelems; i++) {\r
+ void *ptr = 0;\r
+ ASN_DEBUG("SET OF %s decoding", elm->type->name);\r
+ rv = elm->type->op->aper_decoder(opt_codec_ctx, elm->type,\r
+ elm->encoding_constraints.per_constraints, &ptr, pd);\r
+ ASN_DEBUG("%s SET OF %s decoded %d, %p",\r
+ td->name, elm->type->name, rv.code, ptr);\r
+ if(rv.code == RC_OK) {\r
+ if(ASN_SET_ADD(list, ptr) == 0)\r
+ continue;\r
+ ASN_DEBUG("Failed to add element into %s",\r
+ td->name);\r
+ /* Fall through */\r
+ rv.code = RC_FAIL;\r
+ } else {\r
+ ASN_DEBUG("Failed decoding %s of %s (SET OF)",\r
+ elm->type->name, td->name);\r
+ }\r
+ if(ptr) ASN_STRUCT_FREE(*elm->type, ptr);\r
+ return rv;\r
+ }\r
+\r
+ nelems = -1; /* Allow uper_get_length() */\r
+ } while(repeat);\r
+\r
+ ASN_DEBUG("Decoded %s as SET OF", td->name);\r
+\r
+ rv.code = RC_OK;\r
+ rv.consumed = 0;\r
+ return rv;\r
+}\r
+\r
+#endif /* ASN_DISABLE_PER_SUPPORT */\r
+\r
+struct comparable_ptr {\r
+ const asn_TYPE_descriptor_t *td;\r
+ const void *sptr;\r
+};\r
+\r
+static int\r
+SET_OF__compare_cb(const void *aptr, const void *bptr) {\r
+ const struct comparable_ptr *a = aptr;\r
+ const struct comparable_ptr *b = bptr;\r
+ assert(a->td == b->td);\r
+ return a->td->op->compare_struct(a->td, a->sptr, b->sptr);\r
+}\r
+\r
+int\r
+SET_OF_compare(const asn_TYPE_descriptor_t *td, const void *aptr,\r
+ const void *bptr) {\r
+ const asn_anonymous_set_ *a = _A_CSET_FROM_VOID(aptr);\r
+ const asn_anonymous_set_ *b = _A_CSET_FROM_VOID(bptr);\r
+\r
+ if(a && b) {\r
+ struct comparable_ptr *asorted;\r
+ struct comparable_ptr *bsorted;\r
+ ssize_t common_length;\r
+ ssize_t idx;\r
+\r
+ if(a->count == 0) {\r
+ if(b->count) return -1;\r
+ return 0;\r
+ } else if(b->count == 0) {\r
+ return 1;\r
+ }\r
+\r
+ asorted = MALLOC(a->count * sizeof(asorted[0]));\r
+ bsorted = MALLOC(b->count * sizeof(bsorted[0]));\r
+ if(!asorted || !bsorted) {\r
+ FREEMEM(asorted);\r
+ FREEMEM(bsorted);\r
+ return -1;\r
+ }\r
+\r
+ for(idx = 0; idx < a->count; idx++) {\r
+ asorted[idx].td = td->elements->type;\r
+ asorted[idx].sptr = a->array[idx];\r
+ }\r
+\r
+ for(idx = 0; idx < b->count; idx++) {\r
+ bsorted[idx].td = td->elements->type;\r
+ bsorted[idx].sptr = b->array[idx];\r
+ }\r
+\r
+ qsort(asorted, a->count, sizeof(asorted[0]), SET_OF__compare_cb);\r
+ qsort(bsorted, b->count, sizeof(bsorted[0]), SET_OF__compare_cb);\r
+\r
+ common_length = (a->count < b->count ? a->count : b->count);\r
+ for(idx = 0; idx < common_length; idx++) {\r
+ int ret = td->elements->type->op->compare_struct(\r
+ td->elements->type, asorted[idx].sptr, bsorted[idx].sptr);\r
+ if(ret) {\r
+ FREEMEM(asorted);\r
+ FREEMEM(bsorted);\r
+ return ret;\r
+ }\r
+ }\r
+\r
+ FREEMEM(asorted);\r
+ FREEMEM(bsorted);\r
+\r
+ if(idx < b->count) /* more elements in b */\r
+ return -1; /* a is shorter, so put it first */\r
+ if(idx < a->count) return 1;\r
+ } else if(!a) {\r
+ return -1;\r
+ } else if(!b) {\r
+ return 1;\r
+ }\r
+\r
+ return 0;\r
+}\r
+\r
+\r
+asn_TYPE_operation_t asn_OP_SET_OF = {\r
+ SET_OF_free,\r
+ SET_OF_print,\r
+ SET_OF_compare,\r
+ SET_OF_decode_ber,\r
+ SET_OF_encode_der,\r
+ SET_OF_decode_xer,\r
+ SET_OF_encode_xer,\r
+#ifdef ASN_DISABLE_OER_SUPPORT\r
+ 0,\r
+ 0,\r
+#else\r
+ SET_OF_decode_oer,\r
+ SET_OF_encode_oer,\r
+#endif\r
+#ifdef ASN_DISABLE_PER_SUPPORT\r
+ 0,\r
+ 0,\r
+ 0,\r
+ 0,\r
+#else\r
+ SET_OF_decode_uper,\r
+ SET_OF_encode_uper,\r
+ SET_OF_decode_aper,\r
+ 0, /* SET_OF_encode_aper */\r
+#endif /* ASN_DISABLE_PER_SUPPORT */\r
+ SET_OF_random_fill,\r
+ 0 /* Use generic outmost tag fetcher */\r
+};\r
+\r
+\r
+asn_random_fill_result_t\r
+SET_OF_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_SET_OF_specifics_t *specs =\r
+ (const asn_SET_OF_specifics_t *)td->specifics;\r
+ asn_random_fill_result_t res_ok = {ARFILL_OK, 0};\r
+ asn_random_fill_result_t result_failed = {ARFILL_FAILED, 0};\r
+ asn_random_fill_result_t result_skipped = {ARFILL_SKIPPED, 0};\r
+ const asn_TYPE_member_t *elm = td->elements;\r
+ void *st = *sptr;\r
+ long max_elements = 5;\r
+ long slb = 0; /* Lower size bound */\r
+ long sub = 0; /* Upper size bound */\r
+ size_t rnd_len;\r
+\r
+ if(max_length == 0) return result_skipped;\r
+\r
+ if(st == NULL) {\r
+ st = (*sptr = CALLOC(1, specs->struct_size));\r
+ if(st == NULL) {\r
+ return result_failed;\r
+ }\r
+ }\r
+\r
+ switch(asn_random_between(0, 6)) {\r
+ case 0: max_elements = 0; break;\r
+ case 1: max_elements = 1; break;\r
+ case 2: max_elements = 5; break;\r
+ case 3: max_elements = max_length; break;\r
+ case 4: max_elements = max_length / 2; break;\r
+ case 5: max_elements = max_length / 4; break;\r
+ default: break;\r
+ }\r
+ sub = slb + max_elements;\r
+\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_SEMI_CONSTRAINED) {\r
+ slb = pc->lower_bound;\r
+ sub = pc->lower_bound + max_elements;\r
+ } else if(pc->flags & APC_CONSTRAINED) {\r
+ slb = pc->lower_bound;\r
+ sub = pc->upper_bound;\r
+ if(sub - slb > max_elements) sub = slb + max_elements;\r
+ }\r
+ }\r
+\r
+ /* Bias towards edges of allowed space */\r
+ switch(asn_random_between(-1, 4)) {\r
+ default:\r
+ case -1:\r
+ /* Prepare lengths somewhat outside of constrained range. */\r
+ if(constraints->per_constraints\r
+ && (constraints->per_constraints->size.flags & APC_EXTENSIBLE)) {\r
+ switch(asn_random_between(0, 5)) {\r
+ default:\r
+ case 0:\r
+ rnd_len = 0;\r
+ break;\r
+ case 1:\r
+ if(slb > 0) {\r
+ rnd_len = slb - 1;\r
+ } else {\r
+ rnd_len = 0;\r
+ }\r
+ break;\r
+ case 2:\r
+ rnd_len = asn_random_between(0, slb);\r
+ break;\r
+ case 3:\r
+ if(sub < (ssize_t)max_length) {\r
+ rnd_len = sub + 1;\r
+ } else {\r
+ rnd_len = max_length;\r
+ }\r
+ break;\r
+ case 4:\r
+ if(sub < (ssize_t)max_length) {\r
+ rnd_len = asn_random_between(sub + 1, max_length);\r
+ } else {\r
+ rnd_len = max_length;\r
+ }\r
+ break;\r
+ case 5:\r
+ rnd_len = max_length;\r
+ break;\r
+ }\r
+ break;\r
+ }\r
+ /* Fall through */\r
+ case 0:\r
+ rnd_len = asn_random_between(slb, sub);\r
+ break;\r
+ case 1:\r
+ if(slb < sub) {\r
+ rnd_len = asn_random_between(slb + 1, sub);\r
+ break;\r
+ }\r
+ /* Fall through */\r
+ case 2:\r
+ rnd_len = asn_random_between(slb, slb);\r
+ break;\r
+ case 3:\r
+ if(slb < sub) {\r
+ rnd_len = asn_random_between(slb, sub - 1);\r
+ break;\r
+ }\r
+ /* Fall through */\r
+ case 4:\r
+ rnd_len = asn_random_between(sub, sub);\r
+ break;\r
+ }\r
+\r
+ for(; rnd_len > 0; rnd_len--) {\r
+ asn_anonymous_set_ *list = _A_SET_FROM_VOID(st);\r
+ void *ptr = 0;\r
+ asn_random_fill_result_t tmpres = elm->type->op->random_fill(\r
+ elm->type, &ptr, &elm->encoding_constraints,\r
+ (max_length > res_ok.length ? max_length - res_ok.length : 0)\r
+ / rnd_len);\r
+ switch(tmpres.code) {\r
+ case ARFILL_OK:\r
+ ASN_SET_ADD(list, ptr);\r
+ res_ok.length += tmpres.length;\r
+ break;\r
+ case ARFILL_SKIPPED:\r
+ break;\r
+ case ARFILL_FAILED:\r
+ assert(ptr == 0);\r
+ return tmpres;\r
+ }\r
+ }\r
+\r
+ return res_ok;\r
+}\r
+\r
Code Review / ric-app / kpimon.git / blobdiff