2 * Copyright (c) 2003-2017 Lev Walkin <vlm@lionet.info>.
\r
3 * All rights reserved.
\r
4 * Redistribution and modifications are permitted subject to BSD license.
\r
6 #include <asn_internal.h>
\r
7 #include <constr_SEQUENCE.h>
\r
8 #include <OPEN_TYPE.h>
\r
9 #include <per_opentype.h>
\r
12 * Number of bytes left for this structure.
\r
13 * (ctx->left) indicates the number of bytes _transferred_ for the structure.
\r
14 * (size) contains the number of bytes in the buffer passed.
\r
16 #define LEFT ((size<(size_t)ctx->left)?size:(size_t)ctx->left)
\r
19 * If the subprocessor function returns with an indication that it wants
\r
20 * more data, it may well be a fatal decoding problem, because the
\r
21 * size is constrained by the <TLV>'s L, even if the buffer size allows
\r
22 * reading more data.
\r
23 * For example, consider the buffer containing the following TLVs:
\r
24 * <T:5><L:1><V> <T:6>...
\r
25 * The TLV length clearly indicates that one byte is expected in V, but
\r
26 * if the V processor returns with "want more data" even if the buffer
\r
27 * contains way more data than the V processor have seen.
\r
29 #define SIZE_VIOLATION (ctx->left >= 0 && (size_t)ctx->left <= size)
\r
32 * This macro "eats" the part of the buffer which is definitely "consumed",
\r
33 * i.e. was correctly converted into local representation or rightfully skipped.
\r
36 #define ADVANCE(num_bytes) do { \
\r
37 size_t num = num_bytes; \
\r
38 ptr = ((const char *)ptr) + num; \
\r
40 if(ctx->left >= 0) \
\r
42 consumed_myself += num; \
\r
46 * Switch to the next phase of parsing.
\r
50 #define NEXT_PHASE(ctx) do { \
\r
54 #define PHASE_OUT(ctx) do { ctx->phase = 10; } while(0)
\r
57 * Return a standardized complex structure.
\r
60 #define RETURN(_code) do { \
\r
61 rval.code = _code; \
\r
62 rval.consumed = consumed_myself;\
\r
67 * Check whether we are inside the extensions group.
\r
69 #define IN_EXTENSION_GROUP(specs, memb_idx) \
\r
70 ((specs)->first_extension >= 0 \
\r
71 && (unsigned)(specs)->first_extension <= (memb_idx))
\r
74 * Tags are canonically sorted in the tag2element map.
\r
77 _t2e_cmp(const void *ap, const void *bp) {
\r
78 const asn_TYPE_tag2member_t *a = (const asn_TYPE_tag2member_t *)ap;
\r
79 const asn_TYPE_tag2member_t *b = (const asn_TYPE_tag2member_t *)bp;
\r
81 int a_class = BER_TAG_CLASS(a->el_tag);
\r
82 int b_class = BER_TAG_CLASS(b->el_tag);
\r
84 if(a_class == b_class) {
\r
85 ber_tlv_tag_t a_value = BER_TAG_VALUE(a->el_tag);
\r
86 ber_tlv_tag_t b_value = BER_TAG_VALUE(b->el_tag);
\r
88 if(a_value == b_value) {
\r
89 if(a->el_no > b->el_no)
\r
92 * Important: we do not check
\r
93 * for a->el_no <= b->el_no!
\r
96 } else if(a_value < b_value)
\r
100 } else if(a_class < b_class) {
\r
109 * The decoder of the SEQUENCE type.
\r
112 SEQUENCE_decode_ber(const asn_codec_ctx_t *opt_codec_ctx,
\r
113 const asn_TYPE_descriptor_t *td, void **struct_ptr,
\r
114 const void *ptr, size_t size, int tag_mode) {
\r
116 * Bring closer parts of structure description.
\r
118 const asn_SEQUENCE_specifics_t *specs = (const asn_SEQUENCE_specifics_t *)td->specifics;
\r
119 const asn_TYPE_member_t *elements = td->elements;
\r
122 * Parts of the structure being constructed.
\r
124 void *st = *struct_ptr; /* Target structure. */
\r
125 asn_struct_ctx_t *ctx; /* Decoder context */
\r
127 ber_tlv_tag_t tlv_tag; /* T from TLV */
\r
128 asn_dec_rval_t rval; /* Return code from subparsers */
\r
130 ssize_t consumed_myself = 0; /* Consumed bytes from ptr */
\r
131 size_t edx; /* SEQUENCE element's index */
\r
133 ASN_DEBUG("Decoding %s as SEQUENCE", td->name);
\r
136 * Create the target structure if it is not present already.
\r
139 st = *struct_ptr = CALLOC(1, specs->struct_size);
\r
146 * Restore parsing context.
\r
148 ctx = (asn_struct_ctx_t *)((char *)st + specs->ctx_offset);
\r
151 * Start to parse where left previously
\r
153 switch(ctx->phase) {
\r
157 * Check that the set of tags associated with given structure
\r
158 * perfectly fits our expectations.
\r
161 rval = ber_check_tags(opt_codec_ctx, td, ctx, ptr, size,
\r
162 tag_mode, 1, &ctx->left, 0);
\r
163 if(rval.code != RC_OK) {
\r
164 ASN_DEBUG("%s tagging check failed: %d",
\r
165 td->name, rval.code);
\r
170 ctx->left += rval.consumed; /* ?Substracted below! */
\r
171 ADVANCE(rval.consumed);
\r
175 ASN_DEBUG("Structure consumes %ld bytes, buffer %ld",
\r
176 (long)ctx->left, (long)size);
\r
182 * From the place where we've left it previously,
\r
183 * try to decode the next member from the list of
\r
184 * this structure's elements.
\r
185 * (ctx->step) stores the member being processed
\r
186 * between invocations and the microphase {0,1} of parsing
\r
188 * step = (<member_number> * 2 + <microphase>).
\r
190 for(edx = ((size_t)ctx->step >> 1); edx < td->elements_count;
\r
191 edx++, ctx->step = (ctx->step & ~1) + 2) {
\r
192 void *memb_ptr; /* Pointer to the member */
\r
193 void **memb_ptr2; /* Pointer to that pointer */
\r
194 ssize_t tag_len; /* Length of TLV's T */
\r
195 size_t opt_edx_end; /* Next non-optional element */
\r
203 * MICROPHASE 1: Synchronize decoding.
\r
205 ASN_DEBUG("In %s SEQUENCE left %d, edx=%" ASN_PRI_SIZE " flags=%d"
\r
207 td->name, (int)ctx->left, edx,
\r
208 elements[edx].flags, elements[edx].optional,
\r
209 td->elements_count);
\r
211 if(ctx->left == 0 /* No more stuff is expected */
\r
213 /* Explicit OPTIONAL specification reaches the end */
\r
214 (edx + elements[edx].optional == td->elements_count) ||
\r
215 /* All extensions are optional */
\r
216 IN_EXTENSION_GROUP(specs, edx))) {
\r
217 ASN_DEBUG("End of SEQUENCE %s", td->name);
\r
219 * Found the legitimate end of the structure.
\r
226 * Fetch the T from TLV.
\r
228 tag_len = ber_fetch_tag(ptr, LEFT, &tlv_tag);
\r
229 ASN_DEBUG("Current tag in %s SEQUENCE for element %" ASN_PRI_SIZE " "
\r
230 "(%s) is %s encoded in %d bytes, of frame %ld",
\r
231 td->name, edx, elements[edx].name,
\r
232 ber_tlv_tag_string(tlv_tag), (int)tag_len, (long)LEFT);
\r
234 case 0: if(!SIZE_VIOLATION) RETURN(RC_WMORE);
\r
236 case -1: RETURN(RC_FAIL);
\r
239 if(ctx->left < 0 && ((const uint8_t *)ptr)[0] == 0) {
\r
241 if(SIZE_VIOLATION) {
\r
246 } else if(((const uint8_t *)ptr)[1] == 0) {
\r
247 ASN_DEBUG("edx = %" ASN_PRI_SIZE ", opt = %d, ec=%d", edx,
\r
248 elements[edx].optional, td->elements_count);
\r
249 if((edx + elements[edx].optional == td->elements_count)
\r
250 || IN_EXTENSION_GROUP(specs, edx)) {
\r
252 * Yeah, baby! Found the terminator
\r
253 * of the indefinite length structure.
\r
256 * Proceed to the canonical
\r
257 * finalization function.
\r
258 * No advancing is necessary.
\r
266 * Find the next available type with this tag.
\r
269 opt_edx_end = edx + elements[edx].optional + 1;
\r
270 if(opt_edx_end > td->elements_count)
\r
271 opt_edx_end = td->elements_count; /* Cap */
\r
272 else if(opt_edx_end - edx > 8) {
\r
273 /* Limit the scope of linear search... */
\r
274 opt_edx_end = edx + 8;
\r
276 /* ... and resort to bsearch() */
\r
278 for(n = edx; n < opt_edx_end; n++) {
\r
279 if(BER_TAGS_EQUAL(tlv_tag, elements[n].tag)) {
\r
281 * Found element corresponding to the tag
\r
283 * Reposition over the right element.
\r
286 ctx->step = 1 + 2 * edx; /* Remember! */
\r
288 } else if(elements[n].flags & ATF_ANY_TYPE) {
\r
290 * This is the ANY type, which may bear
\r
291 * any flag whatsoever.
\r
294 ctx->step = 1 + 2 * edx; /* Remember! */
\r
296 } else if(elements[n].tag == (ber_tlv_tag_t)-1) {
\r
303 * Resort to a binary search over
\r
304 * sorted array of tags.
\r
306 const asn_TYPE_tag2member_t *t2m;
\r
307 asn_TYPE_tag2member_t key = {0, 0, 0, 0};
\r
308 key.el_tag = tlv_tag;
\r
310 t2m = (const asn_TYPE_tag2member_t *)bsearch(&key,
\r
311 specs->tag2el, specs->tag2el_count,
\r
312 sizeof(specs->tag2el[0]), _t2e_cmp);
\r
314 const asn_TYPE_tag2member_t *best = 0;
\r
315 const asn_TYPE_tag2member_t *t2m_f, *t2m_l;
\r
316 size_t edx_max = edx + elements[edx].optional;
\r
318 * Rewind to the first element with that tag,
\r
319 * `cause bsearch() does not guarantee order.
\r
321 t2m_f = t2m + t2m->toff_first;
\r
322 t2m_l = t2m + t2m->toff_last;
\r
323 for(t2m = t2m_f; t2m <= t2m_l; t2m++) {
\r
324 if(t2m->el_no > edx_max) break;
\r
325 if(t2m->el_no < edx) continue;
\r
330 ctx->step = 1 + 2 * edx;
\r
336 if(n == opt_edx_end) {
\r
338 * If tag is unknown, it may be either
\r
339 * an unknown (thus, incorrect) tag,
\r
340 * or an extension (...),
\r
341 * or an end of the indefinite-length structure.
\r
343 if(!IN_EXTENSION_GROUP(specs,
\r
344 edx + elements[edx].optional)) {
\r
345 ASN_DEBUG("Unexpected tag %s (at %" ASN_PRI_SIZE ")",
\r
346 ber_tlv_tag_string(tlv_tag), edx);
\r
347 ASN_DEBUG("Expected tag %s (%s)%s",
\r
348 ber_tlv_tag_string(elements[edx].tag),
\r
349 elements[edx].name,
\r
350 elements[edx].optional
\r
351 ?" or alternatives":"");
\r
354 /* Skip this tag */
\r
356 edx += elements[edx].optional;
\r
358 ASN_DEBUG("Skipping unexpected %s (at %" ASN_PRI_SIZE ")",
\r
359 ber_tlv_tag_string(tlv_tag), edx);
\r
360 skip = ber_skip_length(opt_codec_ctx,
\r
361 BER_TLV_CONSTRUCTED(ptr),
\r
362 (const char *)ptr + tag_len,
\r
364 ASN_DEBUG("Skip length %d in %s",
\r
365 (int)skip, td->name);
\r
367 case 0: if(!SIZE_VIOLATION) RETURN(RC_WMORE);
\r
369 case -1: RETURN(RC_FAIL);
\r
372 ADVANCE(skip + tag_len);
\r
375 continue; /* Try again with the next tag */
\r
380 * MICROPHASE 2: Invoke the member-specific decoder.
\r
382 ctx->step |= 1; /* Confirm entering next microphase */
\r
384 ASN_DEBUG("Inside SEQUENCE %s MF2", td->name);
\r
387 * Compute the position of the member inside a structure,
\r
388 * and also a type of containment (it may be contained
\r
389 * as pointer or using inline inclusion).
\r
391 if(elements[edx].flags & ATF_POINTER) {
\r
392 /* Member is a pointer to another structure */
\r
393 memb_ptr2 = (void **)((char *)st + elements[edx].memb_offset);
\r
396 * A pointer to a pointer
\r
397 * holding the start of the structure
\r
399 memb_ptr = (char *)st + elements[edx].memb_offset;
\r
400 memb_ptr2 = &memb_ptr;
\r
403 * Invoke the member fetch routine according to member's type
\r
405 if(elements[edx].flags & ATF_OPEN_TYPE) {
\r
406 rval = OPEN_TYPE_ber_get(opt_codec_ctx, td, st, &elements[edx], ptr, LEFT);
\r
408 rval = elements[edx].type->op->ber_decoder(opt_codec_ctx,
\r
409 elements[edx].type,
\r
410 memb_ptr2, ptr, LEFT,
\r
411 elements[edx].tag_mode);
\r
413 ASN_DEBUG("In %s SEQUENCE decoded %" ASN_PRI_SIZE " %s of %d "
\r
414 "in %d bytes rval.code %d, size=%d",
\r
415 td->name, edx, elements[edx].type->name,
\r
416 (int)LEFT, (int)rval.consumed, rval.code, (int)size);
\r
417 switch(rval.code) {
\r
420 case RC_WMORE: /* More data expected */
\r
421 if(!SIZE_VIOLATION) {
\r
422 ADVANCE(rval.consumed);
\r
425 ASN_DEBUG("Size violation (c->l=%ld <= s=%ld)",
\r
426 (long)ctx->left, (long)size);
\r
428 case RC_FAIL: /* Fatal error */
\r
430 } /* switch(rval) */
\r
432 ADVANCE(rval.consumed);
\r
433 } /* for(all structure members) */
\r
438 case 3: /* 00 and other tags expected */
\r
439 case 4: /* only 00's expected */
\r
441 ASN_DEBUG("SEQUENCE %s Leftover: %ld, size = %ld",
\r
442 td->name, (long)ctx->left, (long)size);
\r
445 * Skip everything until the end of the SEQUENCE.
\r
450 tl = ber_fetch_tag(ptr, LEFT, &tlv_tag);
\r
452 case 0: if(!SIZE_VIOLATION) RETURN(RC_WMORE);
\r
454 case -1: RETURN(RC_FAIL);
\r
458 * If expected <0><0>...
\r
461 && ((const uint8_t *)ptr)[0] == 0) {
\r
467 } else if(((const uint8_t *)ptr)[1] == 0) {
\r
469 * Correctly finished with <0><0>.
\r
478 if(!IN_EXTENSION_GROUP(specs, td->elements_count)
\r
479 || ctx->phase == 4) {
\r
480 ASN_DEBUG("Unexpected continuation "
\r
481 "of a non-extensible type "
\r
482 "%s (SEQUENCE): %s",
\r
484 ber_tlv_tag_string(tlv_tag));
\r
488 ll = ber_skip_length(opt_codec_ctx,
\r
489 BER_TLV_CONSTRUCTED(ptr),
\r
490 (const char *)ptr + tl, LEFT - tl);
\r
492 case 0: if(!SIZE_VIOLATION) RETURN(RC_WMORE);
\r
494 case -1: RETURN(RC_FAIL);
\r
508 * The DER encoder of the SEQUENCE type.
\r
511 SEQUENCE_encode_der(const asn_TYPE_descriptor_t *td, const void *sptr,
\r
512 int tag_mode, ber_tlv_tag_t tag,
\r
513 asn_app_consume_bytes_f *cb, void *app_key) {
\r
514 size_t computed_size = 0;
\r
515 asn_enc_rval_t erval = {0,0,0};
\r
519 ASN_DEBUG("%s %s as SEQUENCE",
\r
520 cb?"Encoding":"Estimating", td->name);
\r
523 * Gather the length of the underlying members sequence.
\r
525 for(edx = 0; edx < td->elements_count; edx++) {
\r
526 asn_TYPE_member_t *elm = &td->elements[edx];
\r
528 const void *memb_ptr; /* Pointer to the member */
\r
529 const void *const *memb_ptr2; /* Pointer to that pointer */
\r
531 if(elm->flags & ATF_POINTER) {
\r
533 (const void *const *)((const char *)sptr + elm->memb_offset);
\r
535 ASN_DEBUG("Element %s %" ASN_PRI_SIZE " not present",
\r
539 /* Mandatory element is missing */
\r
540 ASN__ENCODE_FAILED;
\r
543 memb_ptr = (const void *)((const char *)sptr + elm->memb_offset);
\r
544 memb_ptr2 = &memb_ptr;
\r
547 /* Eliminate default values */
\r
548 if(elm->default_value_cmp && elm->default_value_cmp(*memb_ptr2) == 0)
\r
551 erval = elm->type->op->der_encoder(elm->type, *memb_ptr2,
\r
552 elm->tag_mode, elm->tag,
\r
554 if(erval.encoded == -1)
\r
556 computed_size += erval.encoded;
\r
557 ASN_DEBUG("Member %" ASN_PRI_SIZE " %s estimated %ld bytes",
\r
558 edx, elm->name, (long)erval.encoded);
\r
562 * Encode the TLV for the sequence itself.
\r
564 ret = der_write_tags(td, computed_size, tag_mode, 1, tag, cb, app_key);
\r
565 ASN_DEBUG("Wrote tags: %ld (+%ld)", (long)ret, (long)computed_size);
\r
567 ASN__ENCODE_FAILED;
\r
568 erval.encoded = computed_size + ret;
\r
570 if(!cb) ASN__ENCODED_OK(erval);
\r
573 * Encode all members.
\r
575 for(edx = 0; edx < td->elements_count; edx++) {
\r
576 asn_TYPE_member_t *elm = &td->elements[edx];
\r
577 asn_enc_rval_t tmperval = {0,0,0};
\r
578 const void *memb_ptr; /* Pointer to the member */
\r
579 const void *const *memb_ptr2; /* Pointer to that pointer */
\r
581 if(elm->flags & ATF_POINTER) {
\r
583 (const void *const *)((const char *)sptr + elm->memb_offset);
\r
584 if(!*memb_ptr2) continue;
\r
586 memb_ptr = (const void *)((const char *)sptr + elm->memb_offset);
\r
587 memb_ptr2 = &memb_ptr;
\r
590 /* Eliminate default values */
\r
591 if(elm->default_value_cmp && elm->default_value_cmp(*memb_ptr2) == 0)
\r
594 tmperval = elm->type->op->der_encoder(elm->type, *memb_ptr2,
\r
595 elm->tag_mode, elm->tag, cb, app_key);
\r
596 if(tmperval.encoded == -1)
\r
598 computed_size -= tmperval.encoded;
\r
599 ASN_DEBUG("Member %" ASN_PRI_SIZE " %s of SEQUENCE %s encoded in %ld bytes",
\r
600 edx, elm->name, td->name, (long)tmperval.encoded);
\r
603 if(computed_size != 0)
\r
605 * Encoded size is not equal to the computed size.
\r
607 ASN__ENCODE_FAILED;
\r
609 ASN__ENCODED_OK(erval);
\r
614 #define XER_ADVANCE(num_bytes) \
\r
616 size_t num = (num_bytes); \
\r
617 ptr = ((const char *)ptr) + num; \
\r
619 consumed_myself += num; \
\r
623 * Decode the XER (XML) data.
\r
626 SEQUENCE_decode_xer(const asn_codec_ctx_t *opt_codec_ctx,
\r
627 const asn_TYPE_descriptor_t *td, void **struct_ptr,
\r
628 const char *opt_mname, const void *ptr, size_t size) {
\r
630 * Bring closer parts of structure description.
\r
632 const asn_SEQUENCE_specifics_t *specs
\r
633 = (const asn_SEQUENCE_specifics_t *)td->specifics;
\r
634 asn_TYPE_member_t *elements = td->elements;
\r
635 const char *xml_tag = opt_mname ? opt_mname : td->xml_tag;
\r
638 * ... and parts of the structure being constructed.
\r
640 void *st = *struct_ptr; /* Target structure. */
\r
641 asn_struct_ctx_t *ctx; /* Decoder context */
\r
643 asn_dec_rval_t rval; /* Return value from a decoder */
\r
644 ssize_t consumed_myself = 0; /* Consumed bytes from ptr */
\r
645 size_t edx; /* Element index */
\r
648 * Create the target structure if it is not present already.
\r
651 st = *struct_ptr = CALLOC(1, specs->struct_size);
\r
652 if(st == 0) RETURN(RC_FAIL);
\r
656 * Restore parsing context.
\r
658 ctx = (asn_struct_ctx_t *)((char *)st + specs->ctx_offset);
\r
662 * Phases of XER/XML processing:
\r
663 * Phase 0: Check that the opening tag matches our expectations.
\r
664 * Phase 1: Processing body and reacting on closing tag.
\r
665 * Phase 2: Processing inner type.
\r
666 * Phase 3: Skipping unknown extensions.
\r
667 * Phase 4: PHASED OUT
\r
669 for(edx = ctx->step; ctx->phase <= 3;) {
\r
670 pxer_chunk_type_e ch_type; /* XER chunk type */
\r
671 ssize_t ch_size; /* Chunk size */
\r
672 xer_check_tag_e tcv; /* Tag check value */
\r
673 asn_TYPE_member_t *elm;
\r
676 * Go inside the inner member of a sequence.
\r
678 if(ctx->phase == 2) {
\r
679 asn_dec_rval_t tmprval;
\r
680 void *memb_ptr_dontuse; /* Pointer to the member */
\r
681 void **memb_ptr2; /* Pointer to that pointer */
\r
683 elm = &td->elements[edx];
\r
685 if(elm->flags & ATF_POINTER) {
\r
686 /* Member is a pointer to another structure */
\r
687 memb_ptr2 = (void **)((char *)st + elm->memb_offset);
\r
689 memb_ptr_dontuse = (char *)st + elm->memb_offset;
\r
690 memb_ptr2 = &memb_ptr_dontuse; /* Only use of memb_ptr_dontuse */
\r
693 if(elm->flags & ATF_OPEN_TYPE) {
\r
694 tmprval = OPEN_TYPE_xer_get(opt_codec_ctx, td, st, elm, ptr, size);
\r
696 /* Invoke the inner type decoder, m.b. multiple times */
\r
697 tmprval = elm->type->op->xer_decoder(opt_codec_ctx,
\r
698 elm->type, memb_ptr2, elm->name,
\r
701 XER_ADVANCE(tmprval.consumed);
\r
702 if(tmprval.code != RC_OK)
\r
703 RETURN(tmprval.code);
\r
704 ctx->phase = 1; /* Back to body processing */
\r
706 ASN_DEBUG("XER/SEQUENCE phase => %d, step => %d",
\r
707 ctx->phase, ctx->step);
\r
712 * Get the next part of the XML stream.
\r
714 ch_size = xer_next_token(&ctx->context, ptr, size,
\r
716 if(ch_size == -1) {
\r
722 case PXER_COMMENT: /* Got XML comment */
\r
723 case PXER_TEXT: /* Ignore free-standing text */
\r
724 XER_ADVANCE(ch_size); /* Skip silently */
\r
727 break; /* Check the rest down there */
\r
731 tcv = xer_check_tag(ptr, ch_size, xml_tag);
\r
732 ASN_DEBUG("XER/SEQUENCE: tcv = %d, ph=%d [%s]",
\r
733 tcv, ctx->phase, xml_tag);
\r
735 /* Skip the extensions section */
\r
736 if(ctx->phase == 3) {
\r
737 switch(xer_skip_unknown(tcv, &ctx->left)) {
\r
742 XER_ADVANCE(ch_size);
\r
745 XER_ADVANCE(ch_size);
\r
756 if(ctx->phase == 0) break;
\r
760 if(ctx->phase == 0) {
\r
761 if(edx >= td->elements_count ||
\r
762 /* Explicit OPTIONAL specs reaches the end */
\r
763 (edx + elements[edx].optional == td->elements_count) ||
\r
764 /* All extensions are optional */
\r
765 IN_EXTENSION_GROUP(specs, edx)) {
\r
766 XER_ADVANCE(ch_size);
\r
767 ctx->phase = 4; /* Phase out */
\r
770 ASN_DEBUG("Premature end of XER SEQUENCE");
\r
776 if(ctx->phase == 0) {
\r
777 XER_ADVANCE(ch_size);
\r
778 ctx->phase = 1; /* Processing body phase */
\r
782 case XCT_UNKNOWN_OP:
\r
783 case XCT_UNKNOWN_BO:
\r
785 ASN_DEBUG("XER/SEQUENCE: tcv=%d, ph=%d, edx=%" ASN_PRI_SIZE "",
\r
786 tcv, ctx->phase, edx);
\r
787 if(ctx->phase != 1) {
\r
788 break; /* Really unexpected */
\r
791 if(edx < td->elements_count) {
\r
793 * Search which member corresponds to this tag.
\r
796 size_t edx_end = edx + elements[edx].optional + 1;
\r
797 if(edx_end > td->elements_count)
\r
798 edx_end = td->elements_count;
\r
799 for(n = edx; n < edx_end; n++) {
\r
800 elm = &td->elements[n];
\r
801 tcv = xer_check_tag(ptr, ch_size, elm->name);
\r
806 * Process this member.
\r
808 ctx->step = edx = n;
\r
811 case XCT_UNKNOWN_OP:
\r
812 case XCT_UNKNOWN_BO:
\r
816 break; /* Phase out */
\r
823 ASN_DEBUG("Out of defined members: %" ASN_PRI_SIZE "/%u",
\r
824 edx, td->elements_count);
\r
827 /* It is expected extension */
\r
828 if(IN_EXTENSION_GROUP(specs,
\r
829 edx + (edx < td->elements_count
\r
830 ? elements[edx].optional : 0))) {
\r
831 ASN_DEBUG("Got anticipated extension at %" ASN_PRI_SIZE "",
\r
834 * Check for (XCT_BOTH or XCT_UNKNOWN_BO)
\r
835 * By using a mask. Only record a pure
\r
838 if(tcv & XCT_CLOSING) {
\r
839 /* Found </extension> without body */
\r
842 ctx->phase = 3; /* Skip ...'s */
\r
844 XER_ADVANCE(ch_size);
\r
853 ASN_DEBUG("Unexpected XML tag in SEQUENCE [%c%c%c%c%c%c]",
\r
854 size>0?((const char *)ptr)[0]:'.',
\r
855 size>1?((const char *)ptr)[1]:'.',
\r
856 size>2?((const char *)ptr)[2]:'.',
\r
857 size>3?((const char *)ptr)[3]:'.',
\r
858 size>4?((const char *)ptr)[4]:'.',
\r
859 size>5?((const char *)ptr)[5]:'.');
\r
863 ctx->phase = 4; /* "Phase out" on hard failure */
\r
868 SEQUENCE_encode_xer(const asn_TYPE_descriptor_t *td, const void *sptr,
\r
869 int ilevel, enum xer_encoder_flags_e flags,
\r
870 asn_app_consume_bytes_f *cb, void *app_key) {
\r
871 asn_enc_rval_t er = {0,0,0};
\r
872 int xcan = (flags & XER_F_CANONICAL);
\r
873 asn_TYPE_descriptor_t *tmp_def_val_td = 0;
\r
874 void *tmp_def_val = 0;
\r
877 if(!sptr) ASN__ENCODE_FAILED;
\r
881 for(edx = 0; edx < td->elements_count; edx++) {
\r
882 asn_enc_rval_t tmper = {0,0,0};
\r
883 asn_TYPE_member_t *elm = &td->elements[edx];
\r
884 const void *memb_ptr;
\r
885 const char *mname = elm->name;
\r
886 unsigned int mlen = strlen(mname);
\r
888 if(elm->flags & ATF_POINTER) {
\r
890 *(const void *const *)((const char *)sptr + elm->memb_offset);
\r
892 assert(tmp_def_val == 0);
\r
893 if(elm->default_value_set) {
\r
894 if(elm->default_value_set(&tmp_def_val)) {
\r
895 ASN__ENCODE_FAILED;
\r
897 memb_ptr = tmp_def_val;
\r
898 tmp_def_val_td = elm->type;
\r
900 } else if(elm->optional) {
\r
903 /* Mandatory element is missing */
\r
904 ASN__ENCODE_FAILED;
\r
908 memb_ptr = (const void *)((const char *)sptr + elm->memb_offset);
\r
911 if(!xcan) ASN__TEXT_INDENT(1, ilevel);
\r
912 ASN__CALLBACK3("<", 1, mname, mlen, ">", 1);
\r
914 /* Print the member itself */
\r
915 tmper = elm->type->op->xer_encoder(elm->type, memb_ptr, ilevel + 1,
\r
916 flags, cb, app_key);
\r
918 ASN_STRUCT_FREE(*tmp_def_val_td, tmp_def_val);
\r
921 if(tmper.encoded == -1) return tmper;
\r
922 er.encoded += tmper.encoded;
\r
924 ASN__CALLBACK3("</", 2, mname, mlen, ">", 1);
\r
927 if(!xcan) ASN__TEXT_INDENT(1, ilevel - 1);
\r
929 ASN__ENCODED_OK(er);
\r
931 if(tmp_def_val) ASN_STRUCT_FREE(*tmp_def_val_td, tmp_def_val);
\r
932 ASN__ENCODE_FAILED;
\r
936 SEQUENCE_print(const asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
\r
937 asn_app_consume_bytes_f *cb, void *app_key) {
\r
941 if(!sptr) return (cb("<absent>", 8, app_key) < 0) ? -1 : 0;
\r
943 /* Dump preamble */
\r
944 if(cb(td->name, strlen(td->name), app_key) < 0
\r
945 || cb(" ::= {", 6, app_key) < 0)
\r
948 for(edx = 0; edx < td->elements_count; edx++) {
\r
949 asn_TYPE_member_t *elm = &td->elements[edx];
\r
950 const void *memb_ptr;
\r
952 if(elm->flags & ATF_POINTER) {
\r
953 memb_ptr = *(const void * const *)((const char *)sptr + elm->memb_offset);
\r
955 if(elm->optional) continue;
\r
956 /* Print <absent> line */
\r
960 memb_ptr = (const void *)((const char *)sptr + elm->memb_offset);
\r
966 /* Print the member's name and stuff */
\r
967 if(cb(elm->name, strlen(elm->name), app_key) < 0
\r
968 || cb(": ", 2, app_key) < 0)
\r
971 /* Print the member itself */
\r
972 ret = elm->type->op->print_struct(elm->type, memb_ptr, ilevel + 1,
\r
974 if(ret) return ret;
\r
980 return (cb("}", 1, app_key) < 0) ? -1 : 0;
\r
984 SEQUENCE_free(const asn_TYPE_descriptor_t *td, void *sptr,
\r
985 enum asn_struct_free_method method) {
\r
987 const asn_SEQUENCE_specifics_t *specs =
\r
988 (const asn_SEQUENCE_specifics_t *)td->specifics;
\r
989 asn_struct_ctx_t *ctx; /* Decoder context */
\r
994 ASN_DEBUG("Freeing %s as SEQUENCE", td->name);
\r
996 for(edx = 0; edx < td->elements_count; edx++) {
\r
997 asn_TYPE_member_t *elm = &td->elements[edx];
\r
999 if(elm->flags & ATF_POINTER) {
\r
1000 memb_ptr = *(void **)((char *)sptr + elm->memb_offset);
\r
1002 ASN_STRUCT_FREE(*elm->type, memb_ptr);
\r
1004 memb_ptr = (void *)((char *)sptr + elm->memb_offset);
\r
1005 ASN_STRUCT_FREE_CONTENTS_ONLY(*elm->type, memb_ptr);
\r
1009 /* Clean parsing context */
\r
1010 ctx = (asn_struct_ctx_t *)((char *)sptr + specs->ctx_offset);
\r
1011 FREEMEM(ctx->ptr);
\r
1014 case ASFM_FREE_EVERYTHING:
\r
1017 case ASFM_FREE_UNDERLYING:
\r
1019 case ASFM_FREE_UNDERLYING_AND_RESET:
\r
1022 ((const asn_SEQUENCE_specifics_t *)(td->specifics))->struct_size);
\r
1028 SEQUENCE_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
\r
1029 asn_app_constraint_failed_f *ctfailcb, void *app_key) {
\r
1033 ASN__CTFAIL(app_key, td, sptr,
\r
1034 "%s: value not given (%s:%d)",
\r
1035 td->name, __FILE__, __LINE__);
\r
1040 * Iterate over structure members and check their validity.
\r
1042 for(edx = 0; edx < td->elements_count; edx++) {
\r
1043 asn_TYPE_member_t *elm = &td->elements[edx];
\r
1044 const void *memb_ptr;
\r
1046 if(elm->flags & ATF_POINTER) {
\r
1047 memb_ptr = *(const void * const *)((const char *)sptr + elm->memb_offset);
\r
1051 ASN__CTFAIL(app_key, td, sptr,
\r
1052 "%s: mandatory element %s absent (%s:%d)",
\r
1053 td->name, elm->name, __FILE__, __LINE__);
\r
1057 memb_ptr = (const void *)((const char *)sptr + elm->memb_offset);
\r
1060 if(elm->encoding_constraints.general_constraints) {
\r
1061 int ret = elm->encoding_constraints.general_constraints(elm->type, memb_ptr,
\r
1062 ctfailcb, app_key);
\r
1063 if(ret) return ret;
\r
1065 return elm->type->encoding_constraints.general_constraints(elm->type,
\r
1066 memb_ptr, ctfailcb, app_key);
\r
1073 #ifndef ASN_DISABLE_PER_SUPPORT
\r
1076 SEQUENCE_decode_uper(const asn_codec_ctx_t *opt_codec_ctx,
\r
1077 const asn_TYPE_descriptor_t *td,
\r
1078 const asn_per_constraints_t *constraints, void **sptr,
\r
1079 asn_per_data_t *pd) {
\r
1080 const asn_SEQUENCE_specifics_t *specs = (const asn_SEQUENCE_specifics_t *)td->specifics;
\r
1081 void *st = *sptr; /* Target structure. */
\r
1082 int extpresent; /* Extension additions are present */
\r
1083 uint8_t *opres; /* Presence of optional root members */
\r
1084 asn_per_data_t opmd;
\r
1085 asn_dec_rval_t rv;
\r
1088 (void)constraints;
\r
1090 if(ASN__STACK_OVERFLOW_CHECK(opt_codec_ctx))
\r
1091 ASN__DECODE_FAILED;
\r
1094 st = *sptr = CALLOC(1, specs->struct_size);
\r
1095 if(!st) ASN__DECODE_FAILED;
\r
1098 ASN_DEBUG("Decoding %s as SEQUENCE (UPER)", td->name);
\r
1100 /* Handle extensions */
\r
1101 if(specs->first_extension < 0) {
\r
1104 extpresent = per_get_few_bits(pd, 1);
\r
1105 if(extpresent < 0) ASN__DECODE_STARVED;
\r
1108 /* Prepare a place and read-in the presence bitmap */
\r
1109 memset(&opmd, 0, sizeof(opmd));
\r
1110 if(specs->roms_count) {
\r
1111 opres = (uint8_t *)MALLOC(((specs->roms_count + 7) >> 3) + 1);
\r
1112 if(!opres) ASN__DECODE_FAILED;
\r
1113 /* Get the presence map */
\r
1114 if(per_get_many_bits(pd, opres, 0, specs->roms_count)) {
\r
1116 ASN__DECODE_STARVED;
\r
1118 opmd.buffer = opres;
\r
1119 opmd.nbits = specs->roms_count;
\r
1120 ASN_DEBUG("Read in presence bitmap for %s of %d bits (%x..)",
\r
1121 td->name, specs->roms_count, *opres);
\r
1127 * Get the sequence ROOT elements.
\r
1130 edx < (specs->first_extension < 0 ? td->elements_count
\r
1131 : (size_t)specs->first_extension);
\r
1133 asn_TYPE_member_t *elm = &td->elements[edx];
\r
1134 void *memb_ptr; /* Pointer to the member */
\r
1135 void **memb_ptr2; /* Pointer to that pointer */
\r
1137 assert(!IN_EXTENSION_GROUP(specs, edx));
\r
1139 /* Fetch the pointer to this member */
\r
1140 if(elm->flags & ATF_POINTER) {
\r
1141 memb_ptr2 = (void **)((char *)st + elm->memb_offset);
\r
1143 memb_ptr = (char *)st + elm->memb_offset;
\r
1144 memb_ptr2 = &memb_ptr;
\r
1147 /* Deal with optionality */
\r
1148 if(elm->optional) {
\r
1149 int present = per_get_few_bits(&opmd, 1);
\r
1150 ASN_DEBUG("Member %s->%s is optional, p=%d (%d->%d)",
\r
1151 td->name, elm->name, present,
\r
1152 (int)opmd.nboff, (int)opmd.nbits);
\r
1153 if(present == 0) {
\r
1154 /* This element is not present */
\r
1155 if(elm->default_value_set) {
\r
1156 /* Fill-in DEFAULT */
\r
1157 if(elm->default_value_set(memb_ptr2)) {
\r
1159 ASN__DECODE_FAILED;
\r
1161 ASN_DEBUG("Filled-in default");
\r
1163 /* The member is just not present */
\r
1166 /* Fall through */
\r
1169 /* Fetch the member from the stream */
\r
1170 ASN_DEBUG("Decoding member \"%s\" in %s", elm->name, td->name);
\r
1172 if(elm->flags & ATF_OPEN_TYPE) {
\r
1173 rv = OPEN_TYPE_uper_get(opt_codec_ctx, td, st, elm, pd);
\r
1175 rv = elm->type->op->uper_decoder(opt_codec_ctx, elm->type,
\r
1176 elm->encoding_constraints.per_constraints, memb_ptr2, pd);
\r
1178 if(rv.code != RC_OK) {
\r
1179 ASN_DEBUG("Failed decode %s in %s",
\r
1180 elm->name, td->name);
\r
1186 /* Optionality map is not needed anymore */
\r
1190 * Deal with extensions.
\r
1194 uint8_t *epres; /* Presence of extension members */
\r
1195 asn_per_data_t epmd;
\r
1197 bmlength = uper_get_nslength(pd);
\r
1198 if(bmlength < 0) ASN__DECODE_STARVED;
\r
1200 ASN_DEBUG("Extensions %" ASN_PRI_SSIZE " present in %s", bmlength, td->name);
\r
1202 epres = (uint8_t *)MALLOC((bmlength + 15) >> 3);
\r
1203 if(!epres) ASN__DECODE_STARVED;
\r
1205 /* Get the extensions map */
\r
1206 if(per_get_many_bits(pd, epres, 0, bmlength)) {
\r
1208 ASN__DECODE_STARVED;
\r
1211 memset(&epmd, 0, sizeof(epmd));
\r
1212 epmd.buffer = epres;
\r
1213 epmd.nbits = bmlength;
\r
1214 ASN_DEBUG("Read in extensions bitmap for %s of %ld bits (%x..)",
\r
1215 td->name, (long)bmlength, *epres);
\r
1217 /* Go over extensions and read them in */
\r
1218 for(edx = specs->first_extension; edx < td->elements_count; edx++) {
\r
1219 asn_TYPE_member_t *elm = &td->elements[edx];
\r
1220 void *memb_ptr; /* Pointer to the member */
\r
1221 void **memb_ptr2; /* Pointer to that pointer */
\r
1224 /* Fetch the pointer to this member */
\r
1225 if(elm->flags & ATF_POINTER) {
\r
1226 memb_ptr2 = (void **)((char *)st + elm->memb_offset);
\r
1228 memb_ptr = (void *)((char *)st + elm->memb_offset);
\r
1229 memb_ptr2 = &memb_ptr;
\r
1232 present = per_get_few_bits(&epmd, 1);
\r
1233 if(present <= 0) {
\r
1234 if(present < 0) break; /* No more extensions */
\r
1238 ASN_DEBUG("Decoding member %s in %s %p", elm->name, td->name,
\r
1240 rv = uper_open_type_get(opt_codec_ctx, elm->type,
\r
1241 elm->encoding_constraints.per_constraints,
\r
1243 if(rv.code != RC_OK) {
\r
1249 /* Skip over overflow extensions which aren't present
\r
1250 * in this system's version of the protocol */
\r
1252 ASN_DEBUG("Getting overflow extensions");
\r
1253 switch(per_get_few_bits(&epmd, 1)) {
\r
1257 if(uper_open_type_skip(opt_codec_ctx, pd)) {
\r
1259 ASN__DECODE_STARVED;
\r
1261 ASN_DEBUG("Skipped overflow extension");
\r
1270 if(specs->first_extension >= 0) {
\r
1272 /* Fill DEFAULT members in extensions */
\r
1273 for(i = specs->roms_count; i < specs->roms_count + specs->aoms_count;
\r
1275 asn_TYPE_member_t *elm;
\r
1276 void **memb_ptr2; /* Pointer to member pointer */
\r
1278 edx = specs->oms[i];
\r
1279 elm = &td->elements[edx];
\r
1281 if(!elm->default_value_set) continue;
\r
1283 /* Fetch the pointer to this member */
\r
1284 if(elm->flags & ATF_POINTER) {
\r
1285 memb_ptr2 = (void **)((char *)st + elm->memb_offset);
\r
1286 if(*memb_ptr2) continue;
\r
1288 continue; /* Extensions are all optionals */
\r
1291 /* Set default value */
\r
1292 if(elm->default_value_set(memb_ptr2)) {
\r
1293 ASN__DECODE_FAILED;
\r
1304 SEQUENCE__handle_extensions(const asn_TYPE_descriptor_t *td, const void *sptr,
\r
1305 asn_per_outp_t *po1, asn_per_outp_t *po2) {
\r
1306 const asn_SEQUENCE_specifics_t *specs =
\r
1307 (const asn_SEQUENCE_specifics_t *)td->specifics;
\r
1308 int exts_present = 0;
\r
1309 int exts_count = 0;
\r
1312 if(specs->first_extension < 0) {
\r
1316 /* Find out which extensions are present */
\r
1317 for(edx = specs->first_extension; edx < td->elements_count; edx++) {
\r
1318 asn_TYPE_member_t *elm = &td->elements[edx];
\r
1319 const void *memb_ptr; /* Pointer to the member */
\r
1320 const void *const *memb_ptr2; /* Pointer to that pointer */
\r
1323 /* Fetch the pointer to this member */
\r
1324 if(elm->flags & ATF_POINTER) {
\r
1326 (const void *const *)((const char *)sptr + elm->memb_offset);
\r
1327 present = (*memb_ptr2 != 0);
\r
1329 memb_ptr = (const void *)((const char *)sptr + elm->memb_offset);
\r
1330 memb_ptr2 = &memb_ptr;
\r
1334 ASN_DEBUG("checking %s:%s (@%" ASN_PRI_SIZE ") present => %d", elm->name,
\r
1335 elm->type->name, edx, present);
\r
1337 exts_present += present;
\r
1339 /* Encode as presence marker */
\r
1340 if(po1 && per_put_few_bits(po1, present, 1)) {
\r
1343 /* Encode as open type field */
\r
1345 && uper_open_type_put(elm->type,
\r
1346 elm->encoding_constraints.per_constraints,
\r
1351 return exts_present ? exts_count : 0;
\r
1355 SEQUENCE_encode_uper(const asn_TYPE_descriptor_t *td,
\r
1356 const asn_per_constraints_t *constraints, const void *sptr,
\r
1357 asn_per_outp_t *po) {
\r
1358 const asn_SEQUENCE_specifics_t *specs
\r
1359 = (const asn_SEQUENCE_specifics_t *)td->specifics;
\r
1360 asn_enc_rval_t er = {0,0,0};
\r
1365 (void)constraints;
\r
1368 ASN__ENCODE_FAILED;
\r
1372 ASN_DEBUG("Encoding %s as SEQUENCE (UPER)", td->name);
\r
1375 * X.691#18.1 Whether structure is extensible
\r
1376 * and whether to encode extensions
\r
1378 if(specs->first_extension < 0) {
\r
1379 n_extensions = 0; /* There are no extensions to encode */
\r
1381 n_extensions = SEQUENCE__handle_extensions(td, sptr, 0, 0);
\r
1382 if(n_extensions < 0) ASN__ENCODE_FAILED;
\r
1383 if(per_put_few_bits(po, n_extensions ? 1 : 0, 1)) {
\r
1384 ASN__ENCODE_FAILED;
\r
1388 /* Encode a presence bitmap */
\r
1389 for(i = 0; i < specs->roms_count; i++) {
\r
1390 asn_TYPE_member_t *elm;
\r
1391 const void *memb_ptr; /* Pointer to the member */
\r
1392 const void *const *memb_ptr2; /* Pointer to that pointer */
\r
1395 edx = specs->oms[i];
\r
1396 elm = &td->elements[edx];
\r
1398 /* Fetch the pointer to this member */
\r
1399 if(elm->flags & ATF_POINTER) {
\r
1401 (const void *const *)((const char *)sptr + elm->memb_offset);
\r
1402 present = (*memb_ptr2 != 0);
\r
1404 memb_ptr = (const void *)((const char *)sptr + elm->memb_offset);
\r
1405 memb_ptr2 = &memb_ptr;
\r
1409 /* Eliminate default values */
\r
1410 if(present && elm->default_value_cmp
\r
1411 && elm->default_value_cmp(*memb_ptr2) == 0)
\r
1414 ASN_DEBUG("Element %s %s %s->%s is %s",
\r
1415 elm->flags & ATF_POINTER ? "ptr" : "inline",
\r
1416 elm->default_value_cmp ? "def" : "wtv",
\r
1417 td->name, elm->name, present ? "present" : "absent");
\r
1418 if(per_put_few_bits(po, present, 1))
\r
1419 ASN__ENCODE_FAILED;
\r
1423 * Encode the sequence ROOT elements.
\r
1425 ASN_DEBUG("first_extension = %d, elements = %d", specs->first_extension,
\r
1426 td->elements_count);
\r
1428 edx < ((specs->first_extension < 0) ? td->elements_count
\r
1429 : (size_t)specs->first_extension);
\r
1431 asn_TYPE_member_t *elm = &td->elements[edx];
\r
1432 const void *memb_ptr; /* Pointer to the member */
\r
1433 const void *const *memb_ptr2; /* Pointer to that pointer */
\r
1435 ASN_DEBUG("About to encode %s", elm->type->name);
\r
1437 /* Fetch the pointer to this member */
\r
1438 if(elm->flags & ATF_POINTER) {
\r
1440 (const void *const *)((const char *)sptr + elm->memb_offset);
\r
1442 ASN_DEBUG("Element %s %" ASN_PRI_SIZE " not present",
\r
1446 /* Mandatory element is missing */
\r
1447 ASN__ENCODE_FAILED;
\r
1450 memb_ptr = (const void *)((const char *)sptr + elm->memb_offset);
\r
1451 memb_ptr2 = &memb_ptr;
\r
1454 /* Eliminate default values */
\r
1455 if(elm->default_value_cmp && elm->default_value_cmp(*memb_ptr2) == 0)
\r
1458 ASN_DEBUG("Encoding %s->%s:%s", td->name, elm->name, elm->type->name);
\r
1459 er = elm->type->op->uper_encoder(
\r
1460 elm->type, elm->encoding_constraints.per_constraints, *memb_ptr2,
\r
1462 if(er.encoded == -1) return er;
\r
1465 /* No extensions to encode */
\r
1466 if(!n_extensions) ASN__ENCODED_OK(er);
\r
1468 ASN_DEBUG("Length of extensions %d bit-map", n_extensions);
\r
1469 /* #18.8. Write down the presence bit-map length. */
\r
1470 if(uper_put_nslength(po, n_extensions))
\r
1471 ASN__ENCODE_FAILED;
\r
1473 ASN_DEBUG("Bit-map of %d elements", n_extensions);
\r
1474 /* #18.7. Encoding the extensions presence bit-map. */
\r
1475 /* TODO: act upon NOTE in #18.7 for canonical PER */
\r
1476 if(SEQUENCE__handle_extensions(td, sptr, po, 0) != n_extensions)
\r
1477 ASN__ENCODE_FAILED;
\r
1479 ASN_DEBUG("Writing %d extensions", n_extensions);
\r
1480 /* #18.9. Encode extensions as open type fields. */
\r
1481 if(SEQUENCE__handle_extensions(td, sptr, 0, po) != n_extensions)
\r
1482 ASN__ENCODE_FAILED;
\r
1484 ASN__ENCODED_OK(er);
\r
1488 SEQUENCE_decode_aper(const asn_codec_ctx_t *opt_codec_ctx,
\r
1489 const asn_TYPE_descriptor_t *td,
\r
1490 const asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) {
\r
1491 const asn_SEQUENCE_specifics_t *specs = (const asn_SEQUENCE_specifics_t *)td->specifics;
\r
1492 void *st = *sptr; /* Target structure. */
\r
1493 int extpresent; /* Extension additions are present */
\r
1494 uint8_t *opres; /* Presence of optional root members */
\r
1495 asn_per_data_t opmd;
\r
1496 asn_dec_rval_t rv;
\r
1499 (void)constraints;
\r
1501 if(ASN__STACK_OVERFLOW_CHECK(opt_codec_ctx))
\r
1502 ASN__DECODE_FAILED;
\r
1505 st = *sptr = CALLOC(1, specs->struct_size);
\r
1506 if(!st) ASN__DECODE_FAILED;
\r
1509 ASN_DEBUG("Decoding %s as SEQUENCE (APER)", td->name);
\r
1511 /* Handle extensions */
\r
1512 if(specs->first_extension < 0) {
\r
1515 extpresent = per_get_few_bits(pd, 1);
\r
1516 if(extpresent < 0) ASN__DECODE_STARVED;
\r
1519 /* Prepare a place and read-in the presence bitmap */
\r
1520 memset(&opmd, 0, sizeof(opmd));
\r
1521 if(specs->roms_count) {
\r
1522 opres = (uint8_t *)MALLOC(((specs->roms_count + 7) >> 3) + 1);
\r
1523 if(!opres) ASN__DECODE_FAILED;
\r
1524 /* Get the presence map */
\r
1525 if(per_get_many_bits(pd, opres, 0, specs->roms_count)) {
\r
1527 ASN__DECODE_STARVED;
\r
1529 opmd.buffer = opres;
\r
1530 opmd.nbits = specs->roms_count;
\r
1531 ASN_DEBUG("Read in presence bitmap for %s of %d bits (%x..)",
\r
1532 td->name, specs->roms_count, *opres);
\r
1538 * Get the sequence ROOT elements.
\r
1540 for(edx = 0; edx < td->elements_count; edx++) {
\r
1541 asn_TYPE_member_t *elm = &td->elements[edx];
\r
1542 void *memb_ptr; /* Pointer to the member */
\r
1543 void **memb_ptr2; /* Pointer to that pointer */
\r
1548 if(IN_EXTENSION_GROUP(specs, edx))
\r
1551 /* Fetch the pointer to this member */
\r
1552 if(elm->flags & ATF_POINTER) {
\r
1553 memb_ptr2 = (void **)((char *)st + elm->memb_offset);
\r
1555 memb_ptr = (char *)st + elm->memb_offset;
\r
1556 memb_ptr2 = &memb_ptr;
\r
1560 padding = (8 - (pd->moved % 8)) % 8;
\r
1562 ASN_DEBUG("For element %s,offset= %ld Padding bits = %d", td->name, pd->moved, padding);
\r
1563 #if 0 /* old way of removing padding */
\r
1564 per_get_few_bits(pd, padding);
\r
1565 #else /* Experimental fix proposed by @mhanna123 */
\r
1566 if(edx != (td->elements_count-1))
\r
1567 per_get_few_bits(pd, padding);
\r
1569 if(specs->roms_count && (padding > 0))
\r
1570 ASN_DEBUG(">>>>> not skipping padding of %d bits for element:%ld out of %d", padding, edx, td->elements_count);
\r
1572 per_get_few_bits(pd, padding);
\r
1574 #endif /* dealing with padding */
\r
1576 /* Deal with optionality */
\r
1577 if(elm->optional) {
\r
1578 int present = per_get_few_bits(&opmd, 1);
\r
1579 ASN_DEBUG("Member %s->%s is optional, p=%d (%d->%d)",
\r
1580 td->name, elm->name, present,
\r
1581 (int)opmd.nboff, (int)opmd.nbits);
\r
1582 if(present == 0) {
\r
1583 /* This element is not present */
\r
1584 if(elm->default_value_set) {
\r
1585 /* Fill-in DEFAULT */
\r
1586 if(elm->default_value_set(memb_ptr2)) {
\r
1588 ASN__DECODE_FAILED;
\r
1590 ASN_DEBUG("Filled-in default");
\r
1592 /* The member is just not present */
\r
1595 /* Fall through */
\r
1598 /* Fetch the member from the stream */
\r
1599 ASN_DEBUG("Decoding member \"%s\" in %s", elm->name, td->name);
\r
1601 if(elm->flags & ATF_OPEN_TYPE) {
\r
1602 rv = OPEN_TYPE_aper_get(opt_codec_ctx, td, st, elm, pd);
\r
1604 rv = elm->type->op->aper_decoder(opt_codec_ctx, elm->type,
\r
1605 elm->encoding_constraints.per_constraints, memb_ptr2, pd);
\r
1607 if(rv.code != RC_OK) {
\r
1608 ASN_DEBUG("Failed decode %s in %s",
\r
1609 elm->name, td->name);
\r
1615 /* Optionality map is not needed anymore */
\r
1619 * Deal with extensions.
\r
1623 uint8_t *epres; /* Presence of extension members */
\r
1624 asn_per_data_t epmd;
\r
1626 bmlength = aper_get_nslength(pd);
\r
1627 if(bmlength < 0) ASN__DECODE_STARVED;
\r
1629 ASN_DEBUG("Extensions %" ASN_PRI_SSIZE " present in %s", bmlength, td->name);
\r
1631 epres = (uint8_t *)MALLOC((bmlength + 15) >> 3);
\r
1632 if(!epres) ASN__DECODE_STARVED;
\r
1634 /* Get the extensions map */
\r
1635 if(per_get_many_bits(pd, epres, 0, bmlength))
\r
1636 ASN__DECODE_STARVED;
\r
1638 memset(&epmd, 0, sizeof(epmd));
\r
1639 epmd.buffer = epres;
\r
1640 epmd.nbits = bmlength;
\r
1641 ASN_DEBUG("Read in extensions bitmap for %s of %ld bits (%x..)",
\r
1642 td->name, bmlength, *epres);
\r
1644 /* Go over extensions and read them in */
\r
1645 for(edx = specs->first_extension; edx < td->elements_count; edx++) {
\r
1646 asn_TYPE_member_t *elm = &td->elements[edx];
\r
1647 void *memb_ptr; /* Pointer to the member */
\r
1648 void **memb_ptr2; /* Pointer to that pointer */
\r
1651 if(!IN_EXTENSION_GROUP(specs, edx)) {
\r
1652 ASN_DEBUG("%ld is not extension", edx);
\r
1656 /* Fetch the pointer to this member */
\r
1657 if(elm->flags & ATF_POINTER) {
\r
1658 memb_ptr2 = (void **)((char *)st + elm->memb_offset);
\r
1660 memb_ptr = (void *)((char *)st + elm->memb_offset);
\r
1661 memb_ptr2 = &memb_ptr;
\r
1664 present = per_get_few_bits(&epmd, 1);
\r
1665 if(present <= 0) {
\r
1666 if(present < 0) break; /* No more extensions */
\r
1670 ASN_DEBUG("Decoding member %s in %s %p", elm->name, td->name, *memb_ptr2);
\r
1671 rv = aper_open_type_get(opt_codec_ctx, elm->type,
\r
1672 elm->encoding_constraints.per_constraints, memb_ptr2, pd);
\r
1673 if(rv.code != RC_OK) {
\r
1679 /* Skip over overflow extensions which aren't present
\r
1680 * in this system's version of the protocol */
\r
1682 ASN_DEBUG("Getting overflow extensions");
\r
1683 switch(per_get_few_bits(&epmd, 1)) {
\r
1689 if(aper_open_type_skip(opt_codec_ctx, pd)) {
\r
1691 ASN__DECODE_STARVED;
\r
1700 /* Fill DEFAULT members in extensions */
\r
1701 for(edx = specs->roms_count; edx < specs->roms_count
\r
1702 + specs->aoms_count; edx++) {
\r
1703 asn_TYPE_member_t *elm = &td->elements[edx];
\r
1704 void **memb_ptr2; /* Pointer to member pointer */
\r
1706 if(!elm->default_value_set) continue;
\r
1708 /* Fetch the pointer to this member */
\r
1709 if(elm->flags & ATF_POINTER) {
\r
1710 memb_ptr2 = (void **)((char *)st
\r
1711 + elm->memb_offset);
\r
1712 if(*memb_ptr2) continue;
\r
1714 continue; /* Extensions are all optionals */
\r
1717 /* Set default value */
\r
1718 if(elm->default_value_set(memb_ptr2)) {
\r
1719 ASN__DECODE_FAILED;
\r
1729 SEQUENCE_handle_extensions_aper(const asn_TYPE_descriptor_t *td,
\r
1731 asn_per_outp_t *po1, asn_per_outp_t *po2) {
\r
1732 const asn_SEQUENCE_specifics_t *specs
\r
1733 = (const asn_SEQUENCE_specifics_t *)td->specifics;
\r
1734 int exts_present = 0;
\r
1735 int exts_count = 0;
\r
1738 if(specs->first_extension < 0) {
\r
1742 /* Find out which extensions are present */
\r
1743 for(edx = specs->first_extension; edx < td->elements_count; edx++) {
\r
1744 asn_TYPE_member_t *elm = &td->elements[edx];
\r
1745 const void *memb_ptr; /* Pointer to the member */
\r
1746 const void * const *memb_ptr2; /* Pointer to that pointer */
\r
1749 if(!IN_EXTENSION_GROUP(specs, edx)) {
\r
1750 ASN_DEBUG("%s (@%ld) is not extension", elm->type->name, edx);
\r
1754 /* Fetch the pointer to this member */
\r
1755 if(elm->flags & ATF_POINTER) {
\r
1756 memb_ptr2 = (const void * const *)((const char *)sptr + elm->memb_offset);
\r
1757 present = (*memb_ptr2 != 0);
\r
1759 memb_ptr = (const void *)((const char *)sptr + elm->memb_offset);
\r
1760 memb_ptr2 = &memb_ptr;
\r
1764 ASN_DEBUG("checking %s (@%ld) present => %d",
\r
1765 elm->type->name, edx, present);
\r
1767 exts_present += present;
\r
1769 /* Encode as presence marker */
\r
1770 if(po1 && per_put_few_bits(po1, present, 1))
\r
1772 /* Encode as open type field */
\r
1773 if(po2 && present && aper_open_type_put(elm->type,
\r
1774 elm->encoding_constraints.per_constraints, *memb_ptr2, po2))
\r
1779 return exts_present ? exts_count : 0;
\r
1783 SEQUENCE_encode_aper(const asn_TYPE_descriptor_t *td,
\r
1784 const asn_per_constraints_t *constraints,
\r
1785 const void *sptr, asn_per_outp_t *po) {
\r
1786 const asn_SEQUENCE_specifics_t *specs
\r
1787 = (const asn_SEQUENCE_specifics_t *)td->specifics;
\r
1788 asn_enc_rval_t er = {0,0,0};
\r
1793 (void)constraints;
\r
1796 ASN__ENCODE_FAILED;
\r
1800 ASN_DEBUG("Encoding %s as SEQUENCE (APER)", td->name);
\r
1803 * X.691#18.1 Whether structure is extensible
\r
1804 * and whether to encode extensions
\r
1806 if(specs->first_extension < 0) {
\r
1807 n_extensions = 0; /* There are no extensions to encode */
\r
1809 n_extensions = SEQUENCE_handle_extensions_aper(td, sptr, 0, 0);
\r
1810 if(n_extensions < 0) ASN__ENCODE_FAILED;
\r
1811 if(per_put_few_bits(po, n_extensions ? 1 : 0, 1)) {
\r
1812 ASN__ENCODE_FAILED;
\r
1816 /* Encode a presence bitmap */
\r
1817 for(i = 0; i < specs->roms_count; i++) {
\r
1818 asn_TYPE_member_t *elm;
\r
1819 const void *memb_ptr; /* Pointer to the member */
\r
1820 const void * const *memb_ptr2; /* Pointer to that pointer */
\r
1823 edx = specs->oms[i];
\r
1824 elm = &td->elements[edx];
\r
1826 /* Fetch the pointer to this member */
\r
1827 if(elm->flags & ATF_POINTER) {
\r
1828 memb_ptr2 = (const void * const *)((const char *)sptr + elm->memb_offset);
\r
1829 present = (*memb_ptr2 != 0);
\r
1831 memb_ptr = (const void *)((const char *)sptr + elm->memb_offset);
\r
1832 memb_ptr2 = &memb_ptr;
\r
1836 /* Eliminate default values */
\r
1837 if(present && elm->default_value_cmp
\r
1838 && elm->default_value_cmp(memb_ptr2) == 1)
\r
1841 ASN_DEBUG("Element %s %s %s->%s is %s",
\r
1842 elm->flags & ATF_POINTER ? "ptr" : "inline",
\r
1843 elm->default_value_cmp ? "def" : "wtv",
\r
1844 td->name, elm->name, present ? "present" : "absent");
\r
1845 if(per_put_few_bits(po, present, 1))
\r
1846 ASN__ENCODE_FAILED;
\r
1850 * Encode the sequence ROOT elements.
\r
1852 ASN_DEBUG("first_extension = %d, elements = %d", specs->first_extension,
\r
1853 td->elements_count);
\r
1855 edx < ((specs->first_extension < 0) ? td->elements_count
\r
1856 : (size_t)specs->first_extension);
\r
1858 asn_TYPE_member_t *elm = &td->elements[edx];
\r
1859 const void *memb_ptr; /* Pointer to the member */
\r
1860 const void * const *memb_ptr2; /* Pointer to that pointer */
\r
1862 if(IN_EXTENSION_GROUP(specs, edx))
\r
1865 ASN_DEBUG("About to encode %s", elm->type->name);
\r
1867 /* Fetch the pointer to this member */
\r
1868 if(elm->flags & ATF_POINTER) {
\r
1869 memb_ptr2 = (const void * const *)((const char *)sptr + elm->memb_offset);
\r
1871 ASN_DEBUG("Element %s %ld not present",
\r
1875 /* Mandatory element is missing */
\r
1876 ASN__ENCODE_FAILED;
\r
1879 memb_ptr = (const void *)((const char *)sptr + elm->memb_offset);
\r
1880 memb_ptr2 = &memb_ptr;
\r
1883 /* Eliminate default values */
\r
1884 if(elm->default_value_cmp && elm->default_value_cmp(memb_ptr2) == 1)
\r
1887 ASN_DEBUG("Encoding %s->%s", td->name, elm->name);
\r
1888 er = elm->type->op->aper_encoder(elm->type, elm->encoding_constraints.per_constraints,
\r
1890 if(er.encoded == -1)
\r
1894 /* No extensions to encode */
\r
1895 if(!n_extensions) ASN__ENCODED_OK(er);
\r
1897 ASN_DEBUG("Length of %d bit-map", n_extensions);
\r
1898 /* #18.8. Write down the presence bit-map length. */
\r
1899 if(aper_put_nslength(po, n_extensions))
\r
1900 ASN__ENCODE_FAILED;
\r
1902 ASN_DEBUG("Bit-map of %d elements", n_extensions);
\r
1903 /* #18.7. Encoding the extensions presence bit-map. */
\r
1904 /* TODO: act upon NOTE in #18.7 for canonical PER */
\r
1905 if(SEQUENCE_handle_extensions_aper(td, sptr, po, 0) != n_extensions)
\r
1906 ASN__ENCODE_FAILED;
\r
1908 ASN_DEBUG("Writing %d extensions", n_extensions);
\r
1909 /* #18.9. Encode extensions as open type fields. */
\r
1910 if(SEQUENCE_handle_extensions_aper(td, sptr, 0, po) != n_extensions)
\r
1911 ASN__ENCODE_FAILED;
\r
1913 ASN__ENCODED_OK(er);
\r
1916 #endif /* ASN_DISABLE_PER_SUPPORT */
\r
1919 SEQUENCE_compare(const asn_TYPE_descriptor_t *td, const void *aptr,
\r
1920 const void *bptr) {
\r
1923 for(edx = 0; edx < td->elements_count; edx++) {
\r
1924 asn_TYPE_member_t *elm = &td->elements[edx];
\r
1925 const void *amemb;
\r
1926 const void *bmemb;
\r
1929 if(elm->flags & ATF_POINTER) {
\r
1931 *(const void *const *)((const char *)aptr + elm->memb_offset);
\r
1933 *(const void *const *)((const char *)bptr + elm->memb_offset);
\r
1935 if(!bmemb) continue;
\r
1936 if(elm->default_value_cmp
\r
1937 && elm->default_value_cmp(bmemb) == 0) {
\r
1938 /* A is absent, but B is present and equal to DEFAULT */
\r
1942 } else if(!bmemb) {
\r
1943 if(elm->default_value_cmp
\r
1944 && elm->default_value_cmp(amemb) == 0) {
\r
1945 /* B is absent, but A is present and equal to DEFAULT */
\r
1951 amemb = (const void *)((const char *)aptr + elm->memb_offset);
\r
1952 bmemb = (const void *)((const char *)bptr + elm->memb_offset);
\r
1955 ret = elm->type->op->compare_struct(elm->type, amemb, bmemb);
\r
1956 if(ret != 0) return ret;
\r
1962 asn_TYPE_operation_t asn_OP_SEQUENCE = {
\r
1966 SEQUENCE_decode_ber,
\r
1967 SEQUENCE_encode_der,
\r
1968 SEQUENCE_decode_xer,
\r
1969 SEQUENCE_encode_xer,
\r
1970 #ifdef ASN_DISABLE_OER_SUPPORT
\r
1974 SEQUENCE_decode_oer,
\r
1975 SEQUENCE_encode_oer,
\r
1976 #endif /* ASN_DISABLE_OER_SUPPORT */
\r
1977 #ifdef ASN_DISABLE_PER_SUPPORT
\r
1983 SEQUENCE_decode_uper,
\r
1984 SEQUENCE_encode_uper,
\r
1985 SEQUENCE_decode_aper,
\r
1986 SEQUENCE_encode_aper,
\r
1987 #endif /* ASN_DISABLE_PER_SUPPORT */
\r
1988 SEQUENCE_random_fill,
\r
1989 0 /* Use generic outmost tag fetcher */
\r
1993 asn_random_fill_result_t
\r
1994 SEQUENCE_random_fill(const asn_TYPE_descriptor_t *td, void **sptr,
\r
1995 const asn_encoding_constraints_t *constr,
\r
1996 size_t max_length) {
\r
1997 const asn_SEQUENCE_specifics_t *specs =
\r
1998 (const asn_SEQUENCE_specifics_t *)td->specifics;
\r
1999 asn_random_fill_result_t result_ok = {ARFILL_OK, 0};
\r
2000 asn_random_fill_result_t result_failed = {ARFILL_FAILED, 0};
\r
2001 asn_random_fill_result_t result_skipped = {ARFILL_SKIPPED, 0};
\r
2005 if(max_length == 0) return result_skipped;
\r
2010 st = CALLOC(1, specs->struct_size);
\r
2012 return result_failed;
\r
2016 for(edx = 0; edx < td->elements_count; edx++) {
\r
2017 const asn_TYPE_member_t *elm = &td->elements[edx];
\r
2018 void *memb_ptr; /* Pointer to the member */
\r
2019 void **memb_ptr2; /* Pointer to that pointer */
\r
2020 asn_random_fill_result_t tmpres;
\r
2022 if(elm->optional && asn_random_between(0, 4) == 2) {
\r
2023 /* Sometimes decide not to fill the optional value */
\r
2027 if(elm->flags & ATF_POINTER) {
\r
2028 /* Member is a pointer to another structure */
\r
2029 memb_ptr2 = (void **)((char *)st + elm->memb_offset);
\r
2031 memb_ptr = (char *)st + elm->memb_offset;
\r
2032 memb_ptr2 = &memb_ptr;
\r
2035 tmpres = elm->type->op->random_fill(
\r
2036 elm->type, memb_ptr2, &elm->encoding_constraints,
\r
2037 max_length > result_ok.length ? max_length - result_ok.length : 0);
\r
2038 switch(tmpres.code) {
\r
2040 result_ok.length += tmpres.length;
\r
2042 case ARFILL_SKIPPED:
\r
2043 assert(!(elm->flags & ATF_POINTER) || *memb_ptr2 == NULL);
\r
2045 case ARFILL_FAILED:
\r
2047 ASN_STRUCT_RESET(*td, st);
\r
2049 ASN_STRUCT_FREE(*td, st);
\r