]> git.stg.codes - stg.git/blob - libs/smux/constr_CHOICE.c
Use std::lock_guard instead of STG_LOCKER.
[stg.git] / libs / smux / constr_CHOICE.c
1 /*
2  * Copyright (c) 2003-2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
3  * Redistribution and modifications are permitted subject to BSD license.
4  */
5 #include <asn_internal.h>
6 #include <constr_CHOICE.h>
7 #include <per_opentype.h>
8
9 /*
10  * Number of bytes left for this structure.
11  * (ctx->left) indicates the number of bytes _transferred_ for the structure.
12  * (size) contains the number of bytes in the buffer passed.
13  */
14 #define LEFT    ((size<(size_t)ctx->left)?size:(size_t)ctx->left)
15
16 /*
17  * If the subprocessor function returns with an indication that it wants
18  * more data, it may well be a fatal decoding problem, because the
19  * size is constrained by the <TLV>'s L, even if the buffer size allows
20  * reading more data.
21  * For example, consider the buffer containing the following TLVs:
22  * <T:5><L:1><V> <T:6>...
23  * The TLV length clearly indicates that one byte is expected in V, but
24  * if the V processor returns with "want more data" even if the buffer
25  * contains way more data than the V processor have seen.
26  */
27 #define SIZE_VIOLATION  (ctx->left >= 0 && (size_t)ctx->left <= size)
28
29 /*
30  * This macro "eats" the part of the buffer which is definitely "consumed",
31  * i.e. was correctly converted into local representation or rightfully skipped.
32  */
33 #undef  ADVANCE
34 #define ADVANCE(num_bytes)      do {            \
35                 size_t num = num_bytes;         \
36                 ptr = ((const char *)ptr) + num;\
37                 size -= num;                    \
38                 if(ctx->left >= 0)              \
39                         ctx->left -= num;       \
40                 consumed_myself += num;         \
41         } while(0)
42
43 /*
44  * Switch to the next phase of parsing.
45  */
46 #undef  NEXT_PHASE
47 #define NEXT_PHASE(ctx) do {                    \
48                 ctx->phase++;                   \
49                 ctx->step = 0;                  \
50         } while(0)
51
52 /*
53  * Return a standardized complex structure.
54  */
55 #undef  RETURN
56 #define RETURN(_code)   do {                    \
57                 rval.code = _code;              \
58                 rval.consumed = consumed_myself;\
59                 return rval;                    \
60         } while(0)
61
62 /*
63  * See the definitions.
64  */
65 static unsigned _fetch_present_idx(const void *struct_ptr, unsigned off,
66                                    unsigned size);
67 static void _set_present_idx(void *sptr, unsigned offset, unsigned size,
68                              unsigned pres);
69 static const void *_get_member_ptr(const asn_TYPE_descriptor_t *,
70                                    const void *sptr, asn_TYPE_member_t **elm,
71                                    unsigned *present);
72
73 /*
74  * Tags are canonically sorted in the tag to member table.
75  */
76 static int
77 _search4tag(const void *ap, const void *bp) {
78         const asn_TYPE_tag2member_t *a = (const asn_TYPE_tag2member_t *)ap;
79         const asn_TYPE_tag2member_t *b = (const asn_TYPE_tag2member_t *)bp;
80
81         int a_class = BER_TAG_CLASS(a->el_tag);
82         int b_class = BER_TAG_CLASS(b->el_tag);
83
84         if(a_class == b_class) {
85                 ber_tlv_tag_t a_value = BER_TAG_VALUE(a->el_tag);
86                 ber_tlv_tag_t b_value = BER_TAG_VALUE(b->el_tag);
87
88                 if(a_value == b_value)
89                         return 0;
90                 else if(a_value < b_value)
91                         return -1;
92                 else
93                         return 1;
94         } else if(a_class < b_class) {
95                 return -1;
96         } else {
97                 return 1;
98         }
99 }
100
101 /*
102  * The decoder of the CHOICE type.
103  */
104 asn_dec_rval_t
105 CHOICE_decode_ber(const asn_codec_ctx_t *opt_codec_ctx,
106                   const asn_TYPE_descriptor_t *td, void **struct_ptr,
107                   const void *ptr, size_t size, int tag_mode) {
108     /*
109          * Bring closer parts of structure description.
110          */
111         const asn_CHOICE_specifics_t *specs =
112                 (const asn_CHOICE_specifics_t *)td->specifics;
113         asn_TYPE_member_t *elements = td->elements;
114
115         /*
116          * Parts of the structure being constructed.
117          */
118         void *st = *struct_ptr; /* Target structure. */
119         asn_struct_ctx_t *ctx;  /* Decoder context */
120
121         ber_tlv_tag_t tlv_tag;  /* T from TLV */
122         ssize_t tag_len;        /* Length of TLV's T */
123         asn_dec_rval_t rval;    /* Return code from subparsers */
124
125         ssize_t consumed_myself = 0;    /* Consumed bytes from ptr */
126
127         ASN_DEBUG("Decoding %s as CHOICE", td->name);
128
129         /*
130          * Create the target structure if it is not present already.
131          */
132         if(st == 0) {
133                 st = *struct_ptr = CALLOC(1, specs->struct_size);
134                 if(st == 0) {
135                         RETURN(RC_FAIL);
136                 }
137         }
138
139         /*
140          * Restore parsing context.
141          */
142         ctx = (asn_struct_ctx_t *)((char *)st + specs->ctx_offset);
143         
144         /*
145          * Start to parse where left previously
146          */
147         switch(ctx->phase) {
148         case 0:
149                 /*
150                  * PHASE 0.
151                  * Check that the set of tags associated with given structure
152                  * perfectly fits our expectations.
153                  */
154
155                 if(tag_mode || td->tags_count) {
156                         rval = ber_check_tags(opt_codec_ctx, td, ctx, ptr, size,
157                                 tag_mode, -1, &ctx->left, 0);
158                         if(rval.code != RC_OK) {
159                                 ASN_DEBUG("%s tagging check failed: %d",
160                                         td->name, rval.code);
161                                 return rval;
162                         }
163
164                         if(ctx->left >= 0) {
165                                 /* ?Substracted below! */
166                                 ctx->left += rval.consumed;
167                         }
168                         ADVANCE(rval.consumed);
169                 } else {
170                         ctx->left = -1;
171                 }
172
173                 NEXT_PHASE(ctx);
174
175                 ASN_DEBUG("Structure consumes %ld bytes, buffer %ld",
176                         (long)ctx->left, (long)size);
177
178                 /* Fall through */
179         case 1:
180                 /*
181                  * Fetch the T from TLV.
182                  */
183                 tag_len = ber_fetch_tag(ptr, LEFT, &tlv_tag);
184                 ASN_DEBUG("In %s CHOICE tag length %d", td->name, (int)tag_len);
185                 switch(tag_len) {
186                 case 0: if(!SIZE_VIOLATION) RETURN(RC_WMORE);
187                         /* Fall through */
188                 case -1: RETURN(RC_FAIL);
189                 }
190
191                 do {
192                         const asn_TYPE_tag2member_t *t2m;
193                         asn_TYPE_tag2member_t key;
194
195                         key.el_tag = tlv_tag;
196                         t2m = (const asn_TYPE_tag2member_t *)bsearch(&key,
197                                         specs->tag2el, specs->tag2el_count,
198                                         sizeof(specs->tag2el[0]), _search4tag);
199                         if(t2m) {
200                                 /*
201                                  * Found the element corresponding to the tag.
202                                  */
203                                 NEXT_PHASE(ctx);
204                                 ctx->step = t2m->el_no;
205                                 break;
206                         } else if(specs->ext_start == -1) {
207                                 ASN_DEBUG("Unexpected tag %s "
208                                         "in non-extensible CHOICE %s",
209                                         ber_tlv_tag_string(tlv_tag), td->name);
210                                 RETURN(RC_FAIL);
211                         } else {
212                                 /* Skip this tag */
213                                 ssize_t skip;
214
215                                 ASN_DEBUG("Skipping unknown tag %s",
216                                         ber_tlv_tag_string(tlv_tag));
217
218                                 skip = ber_skip_length(opt_codec_ctx,
219                                         BER_TLV_CONSTRUCTED(ptr),
220                                         (const char *)ptr + tag_len,
221                                         LEFT - tag_len);
222
223                                 switch(skip) {
224                                 case 0: if(!SIZE_VIOLATION) RETURN(RC_WMORE);
225                                         /* Fall through */
226                                 case -1: RETURN(RC_FAIL);
227                                 }
228
229                                 ADVANCE(skip + tag_len);
230                                 RETURN(RC_OK);
231                         }
232                 } while(0);
233
234         case 2:
235                 /*
236                  * PHASE 2.
237                  * Read in the element.
238                  */
239             do {
240                 asn_TYPE_member_t *elm;/* CHOICE's element */
241                 void *memb_ptr;         /* Pointer to the member */
242                 void **memb_ptr2;       /* Pointer to that pointer */
243
244                 elm = &elements[ctx->step];
245
246                 /*
247                  * Compute the position of the member inside a structure,
248                  * and also a type of containment (it may be contained
249                  * as pointer or using inline inclusion).
250                  */
251                 if(elm->flags & ATF_POINTER) {
252                         /* Member is a pointer to another structure */
253                         memb_ptr2 = (void **)((char *)st + elm->memb_offset);
254                 } else {
255                         /*
256                          * A pointer to a pointer
257                          * holding the start of the structure
258                          */
259                         memb_ptr = (char *)st + elm->memb_offset;
260                         memb_ptr2 = &memb_ptr;
261                 }
262                 /* Set presence to be able to free it properly at any time */
263                 _set_present_idx(st, specs->pres_offset,
264                                 specs->pres_size, ctx->step + 1);
265                 /*
266                  * Invoke the member fetch routine according to member's type
267                  */
268                 rval = elm->type->op->ber_decoder(opt_codec_ctx, elm->type,
269                                 memb_ptr2, ptr, LEFT, elm->tag_mode);
270                 switch(rval.code) {
271                 case RC_OK:
272                         break;
273                 case RC_WMORE: /* More data expected */
274                         if(!SIZE_VIOLATION) {
275                                 ADVANCE(rval.consumed);
276                                 RETURN(RC_WMORE);
277                         }
278                         RETURN(RC_FAIL);
279                 case RC_FAIL: /* Fatal error */
280                         RETURN(rval.code);
281                 } /* switch(rval) */
282                 
283                 ADVANCE(rval.consumed);
284           } while(0);
285
286                 NEXT_PHASE(ctx);
287
288                 /* Fall through */
289         case 3:
290                 ASN_DEBUG("CHOICE %s Leftover: %ld, size = %ld, tm=%d, tc=%d",
291                         td->name, (long)ctx->left, (long)size,
292                         tag_mode, td->tags_count);
293
294                 if(ctx->left > 0) {
295                         /*
296                          * The type must be fully decoded
297                          * by the CHOICE member-specific decoder.
298                          */
299                         RETURN(RC_FAIL);
300                 }
301
302                 if(ctx->left == -1
303                 && !(tag_mode || td->tags_count)) {
304                         /*
305                          * This is an untagged CHOICE.
306                          * It doesn't contain nothing
307                          * except for the member itself, including all its tags.
308                          * The decoding is completed.
309                          */
310                         NEXT_PHASE(ctx);
311                         break;
312                 }
313
314                 /*
315                  * Read in the "end of data chunks"'s.
316                  */
317                 while(ctx->left < 0) {
318                         ssize_t tl;
319
320                         tl = ber_fetch_tag(ptr, LEFT, &tlv_tag);
321                         switch(tl) {
322                         case 0: if(!SIZE_VIOLATION) RETURN(RC_WMORE);
323                                 /* Fall through */
324                         case -1: RETURN(RC_FAIL);
325                         }
326
327                         /*
328                          * Expected <0><0>...
329                          */
330                         if(((const uint8_t *)ptr)[0] == 0) {
331                                 if(LEFT < 2) {
332                                         if(SIZE_VIOLATION)
333                                                 RETURN(RC_FAIL);
334                                         else
335                                                 RETURN(RC_WMORE);
336                                 } else if(((const uint8_t *)ptr)[1] == 0) {
337                                         /*
338                                          * Correctly finished with <0><0>.
339                                          */
340                                         ADVANCE(2);
341                                         ctx->left++;
342                                         continue;
343                                 }
344                         } else {
345                                 ASN_DEBUG("Unexpected continuation in %s",
346                                         td->name);
347                                 RETURN(RC_FAIL);
348                         }
349
350                         /* UNREACHABLE */
351                 }
352
353                 NEXT_PHASE(ctx);
354         case 4:
355                 /* No meaningful work here */
356                 break;
357         }
358         
359         RETURN(RC_OK);
360 }
361
362 asn_enc_rval_t
363 CHOICE_encode_der(const asn_TYPE_descriptor_t *td, const void *sptr,
364                   int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb,
365                   void *app_key) {
366     const asn_CHOICE_specifics_t *specs = (const asn_CHOICE_specifics_t *)td->specifics;
367         asn_TYPE_member_t *elm; /* CHOICE element */
368         asn_enc_rval_t erval;
369         const void *memb_ptr;
370         size_t computed_size = 0;
371         unsigned present;
372
373         if(!sptr) ASN__ENCODE_FAILED;
374
375         ASN_DEBUG("%s %s as CHOICE",
376                 cb?"Encoding":"Estimating", td->name);
377
378         present = _fetch_present_idx(sptr,
379                 specs->pres_offset, specs->pres_size);
380
381         /*
382          * If the structure was not initialized, it cannot be encoded:
383          * can't deduce what to encode in the choice type.
384          */
385         if(present == 0 || present > td->elements_count) {
386                 if(present == 0 && td->elements_count == 0) {
387                         /* The CHOICE is empty?! */
388                         erval.encoded = 0;
389                         ASN__ENCODED_OK(erval);
390                 }
391                 ASN__ENCODE_FAILED;
392         }
393
394         /*
395          * Seek over the present member of the structure.
396          */
397         elm = &td->elements[present-1];
398         if(elm->flags & ATF_POINTER) {
399         memb_ptr =
400             *(const void *const *)((const char *)sptr + elm->memb_offset);
401         if(memb_ptr == 0) {
402                         if(elm->optional) {
403                                 erval.encoded = 0;
404                                 ASN__ENCODED_OK(erval);
405                         }
406                         /* Mandatory element absent */
407                         ASN__ENCODE_FAILED;
408                 }
409         } else {
410         memb_ptr = (const void *)((const char *)sptr + elm->memb_offset);
411     }
412
413         /*
414          * If the CHOICE itself is tagged EXPLICIT:
415          * T ::= [2] EXPLICIT CHOICE { ... }
416          * Then emit the appropriate tags.
417          */
418         if(tag_mode == 1 || td->tags_count) {
419                 /*
420                  * For this, we need to pre-compute the member.
421                  */
422                 ssize_t ret;
423
424                 /* Encode member with its tag */
425                 erval = elm->type->op->der_encoder(elm->type, memb_ptr,
426                         elm->tag_mode, elm->tag, 0, 0);
427                 if(erval.encoded == -1)
428                         return erval;
429
430                 /* Encode CHOICE with parent or my own tag */
431                 ret = der_write_tags(td, erval.encoded, tag_mode, 1, tag,
432                         cb, app_key);
433                 if(ret == -1)
434                         ASN__ENCODE_FAILED;
435                 computed_size += ret;
436         }
437
438         /*
439          * Encode the single underlying member.
440          */
441         erval = elm->type->op->der_encoder(elm->type, memb_ptr,
442                 elm->tag_mode, elm->tag, cb, app_key);
443         if(erval.encoded == -1)
444                 return erval;
445
446         ASN_DEBUG("Encoded CHOICE member in %ld bytes (+%ld)",
447                 (long)erval.encoded, (long)computed_size);
448
449         erval.encoded += computed_size;
450
451         return erval;
452 }
453
454 ber_tlv_tag_t
455 CHOICE_outmost_tag(const asn_TYPE_descriptor_t *td, const void *ptr, int tag_mode, ber_tlv_tag_t tag) {
456         const asn_CHOICE_specifics_t *specs = (const asn_CHOICE_specifics_t *)td->specifics;
457         unsigned present;
458
459         assert(tag_mode == 0); (void)tag_mode;
460         assert(tag == 0); (void)tag;
461
462         /*
463          * Figure out which CHOICE element is encoded.
464          */
465         present = _fetch_present_idx(ptr, specs->pres_offset, specs->pres_size);
466
467         if(present > 0 && present <= td->elements_count) {
468                 const asn_TYPE_member_t *elm = &td->elements[present-1];
469                 const void *memb_ptr;
470
471                 if(elm->flags & ATF_POINTER) {
472                         memb_ptr = *(const void * const *)
473                                         ((const char *)ptr + elm->memb_offset);
474                 } else {
475                         memb_ptr = (const void *)
476                                         ((const char *)ptr + elm->memb_offset);
477                 }
478
479                 return asn_TYPE_outmost_tag(elm->type, memb_ptr,
480                         elm->tag_mode, elm->tag);
481         } else {
482                 return (ber_tlv_tag_t)-1;
483         }
484 }
485
486 int
487 CHOICE_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
488                   asn_app_constraint_failed_f *ctfailcb, void *app_key) {
489     const asn_CHOICE_specifics_t *specs =
490         (const asn_CHOICE_specifics_t *)td->specifics;
491     unsigned present;
492
493         if(!sptr) {
494                 ASN__CTFAIL(app_key, td, sptr,
495                         "%s: value not given (%s:%d)",
496                         td->name, __FILE__, __LINE__);
497                 return -1;
498         }
499
500         /*
501          * Figure out which CHOICE element is encoded.
502          */
503         present = _fetch_present_idx(sptr, specs->pres_offset,specs->pres_size);
504         if(present > 0 && present <= td->elements_count) {
505                 asn_TYPE_member_t *elm = &td->elements[present-1];
506                 const void *memb_ptr;
507
508                 if(elm->flags & ATF_POINTER) {
509                         memb_ptr = *(const void * const *)((const char *)sptr + elm->memb_offset);
510                         if(!memb_ptr) {
511                                 if(elm->optional)
512                                         return 0;
513                                 ASN__CTFAIL(app_key, td, sptr,
514                                         "%s: mandatory CHOICE element %s absent (%s:%d)",
515                                         td->name, elm->name, __FILE__, __LINE__);
516                                 return -1;
517                         }
518                 } else {
519                         memb_ptr = (const void *)((const char *)sptr + elm->memb_offset);
520                 }
521
522                 if(elm->encoding_constraints.general_constraints) {
523                         return elm->encoding_constraints.general_constraints(elm->type, memb_ptr,
524                                 ctfailcb, app_key);
525                 } else {
526                         return elm->type->encoding_constraints.general_constraints(elm->type,
527                                         memb_ptr, ctfailcb, app_key);
528                 }
529         } else {
530                 ASN__CTFAIL(app_key, td, sptr,
531                         "%s: no CHOICE element given (%s:%d)",
532                         td->name, __FILE__, __LINE__);
533                 return -1;
534         }
535 }
536
537 #undef  XER_ADVANCE
538 #define XER_ADVANCE(num_bytes)  do {                    \
539                 size_t num = num_bytes;                 \
540                 buf_ptr = (const void *)(((const char *)buf_ptr) + num); \
541                 size -= num;                            \
542                 consumed_myself += num;                 \
543         } while(0)
544
545 /*
546  * Decode the XER (XML) data.
547  */
548 asn_dec_rval_t
549 CHOICE_decode_xer(const asn_codec_ctx_t *opt_codec_ctx,
550                   const asn_TYPE_descriptor_t *td, void **struct_ptr,
551                   const char *opt_mname, const void *buf_ptr, size_t size) {
552     /*
553          * Bring closer parts of structure description.
554          */
555         const asn_CHOICE_specifics_t *specs = (const asn_CHOICE_specifics_t *)td->specifics;
556         const char *xml_tag = opt_mname ? opt_mname : td->xml_tag;
557
558         /*
559          * Parts of the structure being constructed.
560          */
561         void *st = *struct_ptr; /* Target structure. */
562         asn_struct_ctx_t *ctx;  /* Decoder context */
563
564         asn_dec_rval_t rval;            /* Return value of a decoder */
565         ssize_t consumed_myself = 0;    /* Consumed bytes from ptr */
566         size_t edx;                     /* Element index */
567
568         /*
569          * Create the target structure if it is not present already.
570          */
571         if(st == 0) {
572                 st = *struct_ptr = CALLOC(1, specs->struct_size);
573                 if(st == 0) RETURN(RC_FAIL);
574         }
575
576         /*
577          * Restore parsing context.
578          */
579         ctx = (asn_struct_ctx_t *)((char *)st + specs->ctx_offset);
580         if(ctx->phase == 0 && !*xml_tag)
581                 ctx->phase = 1; /* Skip the outer tag checking phase */
582
583         /*
584          * Phases of XER/XML processing:
585          * Phase 0: Check that the opening tag matches our expectations.
586          * Phase 1: Processing body and reacting on closing tag.
587          * Phase 2: Processing inner type.
588          * Phase 3: Only waiting for closing tag.
589          * Phase 4: Skipping unknown extensions.
590          * Phase 5: PHASED OUT
591          */
592         for(edx = ctx->step; ctx->phase <= 4;) {
593                 pxer_chunk_type_e ch_type;      /* XER chunk type */
594                 ssize_t ch_size;                /* Chunk size */
595                 xer_check_tag_e tcv;            /* Tag check value */
596                 asn_TYPE_member_t *elm;
597
598                 /*
599                  * Go inside the member.
600                  */
601                 if(ctx->phase == 2) {
602                         asn_dec_rval_t tmprval;
603                         void *memb_ptr;         /* Pointer to the member */
604                         void **memb_ptr2;       /* Pointer to that pointer */
605                         unsigned old_present;
606
607                         elm = &td->elements[edx];
608
609                         if(elm->flags & ATF_POINTER) {
610                                 /* Member is a pointer to another structure */
611                                 memb_ptr2 = (void **)((char *)st
612                                         + elm->memb_offset);
613                         } else {
614                                 memb_ptr = (char *)st + elm->memb_offset;
615                                 memb_ptr2 = &memb_ptr;
616                         }
617
618                         /* Start/Continue decoding the inner member */
619                         tmprval = elm->type->op->xer_decoder(opt_codec_ctx,
620                                         elm->type, memb_ptr2, elm->name,
621                                         buf_ptr, size);
622                         XER_ADVANCE(tmprval.consumed);
623                         ASN_DEBUG("XER/CHOICE: itdf: [%s] code=%d",
624                                 elm->type->name, tmprval.code);
625                         old_present = _fetch_present_idx(st,
626                                 specs->pres_offset, specs->pres_size);
627                         assert(old_present == 0 || old_present == edx + 1);
628                         /* Record what we've got */
629                         _set_present_idx(st,
630                                 specs->pres_offset, specs->pres_size, edx + 1);
631                         if(tmprval.code != RC_OK)
632                                 RETURN(tmprval.code);
633                         ctx->phase = 3;
634                         /* Fall through */
635                 }
636
637                 /* No need to wait for closing tag; special mode. */
638                 if(ctx->phase == 3 && !*xml_tag) {
639                         ctx->phase = 5; /* Phase out */
640                         RETURN(RC_OK);
641                 }
642
643                 /*
644                  * Get the next part of the XML stream.
645                  */
646                 ch_size = xer_next_token(&ctx->context, buf_ptr, size, &ch_type);
647                 if(ch_size == -1) {
648             RETURN(RC_FAIL);
649         } else {
650                         switch(ch_type) {
651                         case PXER_WMORE:
652                 RETURN(RC_WMORE);
653                         case PXER_COMMENT:      /* Got XML comment */
654                         case PXER_TEXT:         /* Ignore free-standing text */
655                                 XER_ADVANCE(ch_size);   /* Skip silently */
656                                 continue;
657                         case PXER_TAG:
658                                 break;  /* Check the rest down there */
659                         }
660                 }
661
662                 tcv = xer_check_tag(buf_ptr, ch_size, xml_tag);
663                 ASN_DEBUG("XER/CHOICE checked [%c%c%c%c] vs [%s], tcv=%d",
664                         ch_size>0?((const uint8_t *)buf_ptr)[0]:'?',
665                         ch_size>1?((const uint8_t *)buf_ptr)[1]:'?',
666                         ch_size>2?((const uint8_t *)buf_ptr)[2]:'?',
667                         ch_size>3?((const uint8_t *)buf_ptr)[3]:'?',
668                 xml_tag, tcv);
669
670                 /* Skip the extensions section */
671                 if(ctx->phase == 4) {
672                         ASN_DEBUG("skip_unknown(%d, %ld)",
673                                 tcv, (long)ctx->left);
674                         switch(xer_skip_unknown(tcv, &ctx->left)) {
675                         case -1:
676                                 ctx->phase = 5;
677                                 RETURN(RC_FAIL);
678                         case 1:
679                                 ctx->phase = 3;
680                                 /* Fall through */
681                         case 0:
682                                 XER_ADVANCE(ch_size);
683                                 continue;
684                         case 2:
685                                 ctx->phase = 3;
686                                 break;
687                         }
688                 }
689
690                 switch(tcv) {
691                 case XCT_BOTH:
692                         break;  /* No CHOICE? */
693                 case XCT_CLOSING:
694                         if(ctx->phase != 3)
695                                 break;
696                         XER_ADVANCE(ch_size);
697                         ctx->phase = 5; /* Phase out */
698                         RETURN(RC_OK);
699                 case XCT_OPENING:
700                         if(ctx->phase == 0) {
701                                 XER_ADVANCE(ch_size);
702                                 ctx->phase = 1; /* Processing body phase */
703                                 continue;
704                         }
705                         /* Fall through */
706                 case XCT_UNKNOWN_OP:
707                 case XCT_UNKNOWN_BO:
708
709                         if(ctx->phase != 1)
710                                 break;  /* Really unexpected */
711
712                         /*
713                          * Search which inner member corresponds to this tag.
714                          */
715                         for(edx = 0; edx < td->elements_count; edx++) {
716                                 elm = &td->elements[edx];
717                                 tcv = xer_check_tag(buf_ptr,ch_size,elm->name);
718                                 switch(tcv) {
719                                 case XCT_BOTH:
720                                 case XCT_OPENING:
721                                         /*
722                                          * Process this member.
723                                          */
724                                         ctx->step = edx;
725                                         ctx->phase = 2;
726                                         break;
727                                 case XCT_UNKNOWN_OP:
728                                 case XCT_UNKNOWN_BO:
729                                         continue;
730                                 default:
731                                         edx = td->elements_count;
732                                         break;  /* Phase out */
733                                 }
734                                 break;
735                         }
736                         if(edx != td->elements_count)
737                                 continue;
738
739                         /* It is expected extension */
740                         if(specs->ext_start != -1) {
741                                 ASN_DEBUG("Got anticipated extension");
742                                 /*
743                                  * Check for (XCT_BOTH or XCT_UNKNOWN_BO)
744                                  * By using a mask. Only record a pure
745                                  * <opening> tags.
746                                  */
747                                 if(tcv & XCT_CLOSING) {
748                                         /* Found </extension> without body */
749                                         ctx->phase = 3; /* Terminating */
750                                 } else {
751                                         ctx->left = 1;
752                                         ctx->phase = 4; /* Skip ...'s */
753                                 }
754                                 XER_ADVANCE(ch_size);
755                                 continue;
756                         }
757
758                         /* Fall through */
759                 default:
760                         break;
761                 }
762
763                 ASN_DEBUG("Unexpected XML tag [%c%c%c%c] in CHOICE [%s]"
764                         " (ph=%d, tag=%s)",
765                         ch_size>0?((const uint8_t *)buf_ptr)[0]:'?',
766                         ch_size>1?((const uint8_t *)buf_ptr)[1]:'?',
767                         ch_size>2?((const uint8_t *)buf_ptr)[2]:'?',
768                         ch_size>3?((const uint8_t *)buf_ptr)[3]:'?',
769                         td->name, ctx->phase, xml_tag);
770                 break;
771         }
772
773         ctx->phase = 5; /* Phase out, just in case */
774         RETURN(RC_FAIL);
775 }
776
777
778 asn_enc_rval_t
779 CHOICE_encode_xer(const asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
780                   enum xer_encoder_flags_e flags, asn_app_consume_bytes_f *cb,
781                   void *app_key) {
782     const asn_CHOICE_specifics_t *specs =
783         (const asn_CHOICE_specifics_t *)td->specifics;
784     asn_enc_rval_t er;
785         unsigned present;
786
787         if(!sptr)
788                 ASN__ENCODE_FAILED;
789
790         /*
791          * Figure out which CHOICE element is encoded.
792          */
793         present = _fetch_present_idx(sptr, specs->pres_offset,specs->pres_size);
794
795         if(present == 0 || present > td->elements_count) {
796                 ASN__ENCODE_FAILED;
797         }  else {
798                 asn_enc_rval_t tmper;
799                 asn_TYPE_member_t *elm = &td->elements[present-1];
800                 const void *memb_ptr;
801                 const char *mname = elm->name;
802                 unsigned int mlen = strlen(mname);
803
804                 if(elm->flags & ATF_POINTER) {
805             memb_ptr =
806                 *(const void *const *)((const char *)sptr + elm->memb_offset);
807             if(!memb_ptr) ASN__ENCODE_FAILED;
808                 } else {
809             memb_ptr = (const void *)((const char *)sptr + elm->memb_offset);
810         }
811
812         er.encoded = 0;
813
814                 if(!(flags & XER_F_CANONICAL)) ASN__TEXT_INDENT(1, ilevel);
815                 ASN__CALLBACK3("<", 1, mname, mlen, ">", 1);
816
817                 tmper = elm->type->op->xer_encoder(elm->type, memb_ptr,
818                                 ilevel + 1, flags, cb, app_key);
819                 if(tmper.encoded == -1) return tmper;
820                 er.encoded += tmper.encoded;
821
822                 ASN__CALLBACK3("</", 2, mname, mlen, ">", 1);
823         }
824
825         if(!(flags & XER_F_CANONICAL)) ASN__TEXT_INDENT(1, ilevel - 1);
826
827         ASN__ENCODED_OK(er);
828 cb_failed:
829         ASN__ENCODE_FAILED;
830 }
831
832 asn_dec_rval_t
833 CHOICE_decode_uper(const asn_codec_ctx_t *opt_codec_ctx,
834                    const asn_TYPE_descriptor_t *td,
835                    const asn_per_constraints_t *constraints, void **sptr,
836                    asn_per_data_t *pd) {
837     const asn_CHOICE_specifics_t *specs =
838         (const asn_CHOICE_specifics_t *)td->specifics;
839     asn_dec_rval_t rv;
840         const asn_per_constraint_t *ct;
841         asn_TYPE_member_t *elm; /* CHOICE's element */
842         void *memb_ptr;
843         void **memb_ptr2;
844         void *st = *sptr;
845         int value;
846
847         if(ASN__STACK_OVERFLOW_CHECK(opt_codec_ctx))
848                 ASN__DECODE_FAILED;
849
850         /*
851          * Create the target structure if it is not present already.
852          */
853         if(!st) {
854                 st = *sptr = CALLOC(1, specs->struct_size);
855                 if(!st) ASN__DECODE_FAILED;
856         }
857
858         if(constraints) ct = &constraints->value;
859         else if(td->encoding_constraints.per_constraints) ct = &td->encoding_constraints.per_constraints->value;
860         else ct = 0;
861
862         if(ct && ct->flags & APC_EXTENSIBLE) {
863                 value = per_get_few_bits(pd, 1);
864                 if(value < 0) ASN__DECODE_STARVED;
865                 if(value) ct = 0;       /* Not restricted */
866         }
867
868         if(ct && ct->range_bits >= 0) {
869                 value = per_get_few_bits(pd, ct->range_bits);
870                 if(value < 0) ASN__DECODE_STARVED;
871                 ASN_DEBUG("CHOICE %s got index %d in range %d",
872                         td->name, value, ct->range_bits);
873                 if(value > ct->upper_bound)
874                         ASN__DECODE_FAILED;
875         } else {
876                 if(specs->ext_start == -1)
877                         ASN__DECODE_FAILED;
878                 value = uper_get_nsnnwn(pd);
879                 if(value < 0) ASN__DECODE_STARVED;
880                 value += specs->ext_start;
881                 if((unsigned)value >= td->elements_count)
882                         ASN__DECODE_FAILED;
883         }
884
885         /* Adjust if canonical order is different from natural order */
886         if(specs->from_canonical_order) {
887         ASN_DEBUG("CHOICE presence from wire %d", value);
888                 value = specs->from_canonical_order[value];
889         ASN_DEBUG("CHOICE presence index effective %d", value);
890     }
891
892         /* Set presence to be able to free it later */
893         _set_present_idx(st, specs->pres_offset, specs->pres_size, value + 1);
894
895         elm = &td->elements[value];
896         if(elm->flags & ATF_POINTER) {
897                 /* Member is a pointer to another structure */
898                 memb_ptr2 = (void **)((char *)st + elm->memb_offset);
899         } else {
900                 memb_ptr = (char *)st + elm->memb_offset;
901                 memb_ptr2 = &memb_ptr;
902         }
903         ASN_DEBUG("Discovered CHOICE %s encodes %s", td->name, elm->name);
904
905         if(ct && ct->range_bits >= 0) {
906                 rv = elm->type->op->uper_decoder(opt_codec_ctx, elm->type,
907                         elm->encoding_constraints.per_constraints, memb_ptr2, pd);
908         } else {
909                 rv = uper_open_type_get(opt_codec_ctx, elm->type,
910                         elm->encoding_constraints.per_constraints, memb_ptr2, pd);
911         }
912
913         if(rv.code != RC_OK)
914                 ASN_DEBUG("Failed to decode %s in %s (CHOICE) %d",
915                         elm->name, td->name, rv.code);
916         return rv;
917 }
918
919 asn_enc_rval_t
920 CHOICE_encode_uper(const asn_TYPE_descriptor_t *td,
921                    const asn_per_constraints_t *constraints, const void *sptr,
922                    asn_per_outp_t *po) {
923     const asn_CHOICE_specifics_t *specs = (const asn_CHOICE_specifics_t *)td->specifics;
924         asn_TYPE_member_t *elm; /* CHOICE's element */
925         const asn_per_constraint_t *ct;
926         const void *memb_ptr;
927         unsigned present;
928         int present_enc;
929
930         if(!sptr) ASN__ENCODE_FAILED;
931
932         ASN_DEBUG("Encoding %s as CHOICE", td->name);
933
934         if(constraints) ct = &constraints->value;
935         else if(td->encoding_constraints.per_constraints)
936                 ct = &td->encoding_constraints.per_constraints->value;
937         else ct = 0;
938
939         present = _fetch_present_idx(sptr, specs->pres_offset, specs->pres_size);
940
941         /*
942          * If the structure was not initialized properly, it cannot be encoded:
943          * can't deduce what to encode in the choice type.
944          */
945         if(present == 0 || present > td->elements_count)
946                 ASN__ENCODE_FAILED;
947         else
948                 present--;
949
950         ASN_DEBUG("Encoding %s CHOICE element %d", td->name, present);
951
952     /* Adjust if canonical order is different from natural order */
953     if(specs->to_canonical_order)
954         present_enc = specs->to_canonical_order[present];
955     else
956         present_enc = present;
957
958     if(ct && ct->range_bits >= 0) {
959                 if(present_enc < ct->lower_bound
960                 || present_enc > ct->upper_bound) {
961                         if(ct->flags & APC_EXTENSIBLE) {
962                 ASN_DEBUG(
963                     "CHOICE member %d (enc %d) is an extension (%ld..%ld)",
964                     present, present_enc, ct->lower_bound, ct->upper_bound);
965                 if(per_put_few_bits(po, 1, 1))
966                                         ASN__ENCODE_FAILED;
967                         } else {
968                                 ASN__ENCODE_FAILED;
969                         }
970                         ct = 0;
971                 }
972         }
973         if(ct && ct->flags & APC_EXTENSIBLE) {
974         ASN_DEBUG("CHOICE member %d (enc %d) is not an extension (%ld..%ld)",
975                   present, present_enc, ct->lower_bound, ct->upper_bound);
976         if(per_put_few_bits(po, 0, 1))
977                         ASN__ENCODE_FAILED;
978     }
979
980
981         elm = &td->elements[present];
982     ASN_DEBUG("CHOICE member \"%s\" %d (as %d)", elm->name, present,
983               present_enc);
984     if(elm->flags & ATF_POINTER) {
985                 /* Member is a pointer to another structure */
986         memb_ptr =
987             *(const void *const *)((const char *)sptr + elm->memb_offset);
988         if(!memb_ptr) ASN__ENCODE_FAILED;
989         } else {
990         memb_ptr = (const char *)sptr + elm->memb_offset;
991     }
992
993     if(ct && ct->range_bits >= 0) {
994         if(per_put_few_bits(po, present_enc, ct->range_bits))
995             ASN__ENCODE_FAILED;
996
997         return elm->type->op->uper_encoder(
998             elm->type, elm->encoding_constraints.per_constraints, memb_ptr, po);
999     } else {
1000         asn_enc_rval_t rval;
1001         if(specs->ext_start == -1) ASN__ENCODE_FAILED;
1002         if(uper_put_nsnnwn(po, present_enc - specs->ext_start))
1003             ASN__ENCODE_FAILED;
1004         if(uper_open_type_put(elm->type,
1005                               elm->encoding_constraints.per_constraints,
1006                               memb_ptr, po))
1007             ASN__ENCODE_FAILED;
1008         rval.encoded = 0;
1009         ASN__ENCODED_OK(rval);
1010     }
1011 }
1012
1013
1014 int
1015 CHOICE_print(const asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
1016              asn_app_consume_bytes_f *cb, void *app_key) {
1017     const asn_CHOICE_specifics_t *specs = (const asn_CHOICE_specifics_t *)td->specifics;
1018         unsigned present;
1019
1020         if(!sptr) return (cb("<absent>", 8, app_key) < 0) ? -1 : 0;
1021
1022         /*
1023          * Figure out which CHOICE element is encoded.
1024          */
1025         present = _fetch_present_idx(sptr, specs->pres_offset,specs->pres_size);
1026
1027         /*
1028          * Print that element.
1029          */
1030         if(present > 0 && present <= td->elements_count) {
1031                 asn_TYPE_member_t *elm = &td->elements[present-1];
1032                 const void *memb_ptr;
1033
1034                 if(elm->flags & ATF_POINTER) {
1035                         memb_ptr = *(const void * const *)((const char *)sptr + elm->memb_offset);
1036                         if(!memb_ptr) return (cb("<absent>", 8, app_key) < 0) ? -1 : 0;
1037                 } else {
1038                         memb_ptr = (const void *)((const char *)sptr + elm->memb_offset);
1039                 }
1040
1041                 /* Print member's name and stuff */
1042                 if(0) {
1043                         if(cb(elm->name, strlen(elm->name), app_key) < 0
1044                         || cb(": ", 2, app_key) < 0)
1045                                 return -1;
1046                 }
1047
1048                 return elm->type->op->print_struct(elm->type, memb_ptr, ilevel,
1049                         cb, app_key);
1050         } else {
1051                 return (cb("<absent>", 8, app_key) < 0) ? -1 : 0;
1052         }
1053 }
1054
1055 void
1056 CHOICE_free(const asn_TYPE_descriptor_t *td, void *ptr,
1057             enum asn_struct_free_method method) {
1058     const asn_CHOICE_specifics_t *specs =
1059         (const asn_CHOICE_specifics_t *)td->specifics;
1060     unsigned present;
1061
1062         if(!td || !ptr)
1063                 return;
1064
1065         ASN_DEBUG("Freeing %s as CHOICE", td->name);
1066
1067         /*
1068          * Figure out which CHOICE element is encoded.
1069          */
1070         present = _fetch_present_idx(ptr, specs->pres_offset, specs->pres_size);
1071
1072         /*
1073          * Free that element.
1074          */
1075         if(present > 0 && present <= td->elements_count) {
1076                 asn_TYPE_member_t *elm = &td->elements[present-1];
1077                 void *memb_ptr;
1078
1079                 if(elm->flags & ATF_POINTER) {
1080                         memb_ptr = *(void **)((char *)ptr + elm->memb_offset);
1081                         if(memb_ptr)
1082                                 ASN_STRUCT_FREE(*elm->type, memb_ptr);
1083                 } else {
1084                         memb_ptr = (void *)((char *)ptr + elm->memb_offset);
1085                         ASN_STRUCT_FREE_CONTENTS_ONLY(*elm->type, memb_ptr);
1086                 }
1087         }
1088
1089     switch(method) {
1090     case ASFM_FREE_EVERYTHING:
1091         FREEMEM(ptr);
1092         break;
1093     case ASFM_FREE_UNDERLYING:
1094         break;
1095     case ASFM_FREE_UNDERLYING_AND_RESET:
1096         memset(ptr, 0, specs->struct_size);
1097         break;
1098     }
1099 }
1100
1101
1102 /*
1103  * The following functions functions offer protection against -fshort-enums,
1104  * compatible with little- and big-endian machines.
1105  * If assertion is triggered, either disable -fshort-enums, or add an entry
1106  * here with the ->pres_size of your target stracture.
1107  * Unless the target structure is packed, the ".present" member
1108  * is guaranteed to be aligned properly. ASN.1 compiler itself does not
1109  * produce packed code.
1110  */
1111 static unsigned
1112 _fetch_present_idx(const void *struct_ptr, unsigned pres_offset,
1113                    unsigned pres_size) {
1114     const void *present_ptr;
1115         unsigned present;
1116
1117         present_ptr = ((const char *)struct_ptr) + pres_offset;
1118
1119         switch(pres_size) {
1120         case sizeof(int):       present = *(const unsigned int *)present_ptr; break;
1121         case sizeof(short):     present = *(const unsigned short *)present_ptr; break;
1122         case sizeof(char):      present = *(const unsigned char *)present_ptr; break;
1123         default:
1124                 /* ANSI C mandates enum to be equivalent to integer */
1125                 assert(pres_size != sizeof(int));
1126                 return 0;       /* If not aborted, pass back safe value */
1127         }
1128
1129         return present;
1130 }
1131
1132 static void
1133 _set_present_idx(void *struct_ptr, unsigned pres_offset, unsigned pres_size,
1134                  unsigned present) {
1135     void *present_ptr;
1136         present_ptr = ((char *)struct_ptr) + pres_offset;
1137
1138         switch(pres_size) {
1139         case sizeof(int):       *(unsigned int *)present_ptr   = present; break;
1140         case sizeof(short):     *(unsigned short *)present_ptr = present; break;
1141         case sizeof(char):      *(unsigned char *)present_ptr  = present; break;
1142         default:
1143                 /* ANSI C mandates enum to be equivalent to integer */
1144                 assert(pres_size != sizeof(int));
1145         }
1146 }
1147
1148 static const void *
1149 _get_member_ptr(const asn_TYPE_descriptor_t *td, const void *sptr,
1150                 asn_TYPE_member_t **elm_ptr, unsigned *present_out) {
1151     const asn_CHOICE_specifics_t *specs =
1152         (const asn_CHOICE_specifics_t *)td->specifics;
1153     unsigned present;
1154
1155     if(!sptr) {
1156         *elm_ptr = NULL;
1157         *present_out = 0;
1158         return NULL;
1159     }
1160
1161     /*
1162          * Figure out which CHOICE element is encoded.
1163          */
1164         present = _fetch_present_idx(sptr, specs->pres_offset, specs->pres_size);
1165     *present_out = present;
1166
1167     /*
1168      * The presence index is intentionally 1-based to avoid
1169      * treating zeroed structure as a valid one.
1170      */
1171         if(present > 0 && present <= td->elements_count) {
1172         asn_TYPE_member_t *const elm = &td->elements[present - 1];
1173         const void *memb_ptr;
1174
1175                 if(elm->flags & ATF_POINTER) {
1176             memb_ptr =
1177                 *(const void *const *)((const char *)sptr + elm->memb_offset);
1178         } else {
1179             memb_ptr = (const void *)((const char *)sptr + elm->memb_offset);
1180         }
1181         *elm_ptr = elm;
1182         return memb_ptr;
1183     } else {
1184         *elm_ptr = NULL;
1185         return NULL;
1186     }
1187
1188 }
1189
1190 int
1191 CHOICE_compare(const asn_TYPE_descriptor_t *td, const void *aptr, const void *bptr) {
1192     asn_TYPE_member_t *aelm;
1193     asn_TYPE_member_t *belm;
1194     unsigned apresent = 0;
1195     unsigned bpresent = 0;
1196     const void *amember = _get_member_ptr(td, aptr, &aelm, &apresent);
1197     const void *bmember = _get_member_ptr(td, bptr, &belm, &bpresent);
1198
1199     if(amember && bmember) {
1200         if(apresent == bpresent) {
1201             assert(aelm == belm);
1202             return aelm->type->op->compare_struct(aelm->type, amember, bmember);
1203         } else if(apresent < bpresent) {
1204             return -1;
1205         } else {
1206             return 1;
1207         }
1208     } else if(!amember) {
1209         return -1;
1210     } else {
1211         return 1;
1212     }
1213 }
1214
1215 /*
1216  * Return the 1-based choice variant presence index.
1217  * Returns 0 in case of error.
1218  */
1219 unsigned
1220 CHOICE_variant_get_presence(const asn_TYPE_descriptor_t *td, const void *sptr) {
1221     const asn_CHOICE_specifics_t *specs =
1222         (const asn_CHOICE_specifics_t *)td->specifics;
1223     return _fetch_present_idx(sptr, specs->pres_offset, specs->pres_size);
1224 }
1225
1226 /*
1227  * Sets or resets the 1-based choice variant presence index.
1228  * In case a previous index is not zero, the currently selected structure
1229  * member is freed and zeroed-out first.
1230  * Returns 0 on success and -1 on error.
1231  */
1232 int
1233 CHOICE_variant_set_presence(const asn_TYPE_descriptor_t *td, void *sptr,
1234                             unsigned present) {
1235     const asn_CHOICE_specifics_t *specs =
1236         (const asn_CHOICE_specifics_t *)td->specifics;
1237     unsigned old_present;
1238
1239     if(!sptr) {
1240         return -1;
1241     }
1242
1243     if(present > td->elements_count)
1244         return -1;
1245
1246     old_present =
1247         _fetch_present_idx(sptr, specs->pres_offset, specs->pres_size);
1248     if(present == old_present)
1249         return 0;
1250
1251     if(old_present != 0) {
1252         assert(old_present <= td->elements_count);
1253         ASN_STRUCT_RESET(*td, sptr);
1254     }
1255
1256     _set_present_idx(sptr, specs->pres_offset, specs->pres_size, present);
1257
1258     return 0;
1259 }
1260
1261
1262 asn_random_fill_result_t
1263 CHOICE_random_fill(const asn_TYPE_descriptor_t *td, void **sptr,
1264                    const asn_encoding_constraints_t *constr,
1265                    size_t max_length) {
1266     const asn_CHOICE_specifics_t *specs =
1267         (const asn_CHOICE_specifics_t *)td->specifics;
1268     asn_random_fill_result_t res;
1269     asn_random_fill_result_t result_failed = {ARFILL_FAILED, 0};
1270     asn_random_fill_result_t result_skipped = {ARFILL_SKIPPED, 0};
1271     const asn_TYPE_member_t *elm;
1272     unsigned present;
1273     void *memb_ptr;   /* Pointer to the member */
1274     void **memb_ptr2; /* Pointer to that pointer */
1275     void *st = *sptr;
1276
1277     if(max_length == 0) return result_skipped;
1278
1279     (void)constr;
1280
1281     if(st == NULL) {
1282         st = CALLOC(1, specs->struct_size);
1283         if(st == NULL) {
1284             return result_failed;
1285         }
1286     }
1287
1288     present = asn_random_between(1, td->elements_count);
1289     elm = &td->elements[present - 1];
1290
1291         if(elm->flags & ATF_POINTER) {
1292                 /* Member is a pointer to another structure */
1293                 memb_ptr2 = (void **)((char *)st + elm->memb_offset);
1294         } else {
1295                 memb_ptr = (char *)st + elm->memb_offset;
1296                 memb_ptr2 = &memb_ptr;
1297         }
1298
1299     res = elm->type->op->random_fill(elm->type, memb_ptr2,
1300                                     &elm->encoding_constraints, max_length);
1301     _set_present_idx(st, specs->pres_offset, specs->pres_size, present);
1302     if(res.code == ARFILL_OK) {
1303         *sptr = st;
1304     } else {
1305         if(st == *sptr) {
1306             ASN_STRUCT_RESET(*td, st);
1307         } else {
1308             ASN_STRUCT_FREE(*td, st);
1309         }
1310     }
1311
1312     return res;
1313 }
1314
1315
1316 asn_TYPE_operation_t asn_OP_CHOICE = {
1317         CHOICE_free,
1318         CHOICE_print,
1319         CHOICE_compare,
1320         CHOICE_decode_ber,
1321         CHOICE_encode_der,
1322         CHOICE_decode_xer,
1323         CHOICE_encode_xer,
1324 #ifdef  ASN_DISABLE_OER_SUPPORT
1325         0,
1326         0,
1327 #else
1328         CHOICE_decode_oer,
1329         CHOICE_encode_oer,
1330 #endif  /* ASN_DISABLE_OER_SUPPORT */
1331 #ifdef ASN_DISABLE_PER_SUPPORT
1332         0,
1333         0,
1334 #else
1335         CHOICE_decode_uper,
1336         CHOICE_encode_uper,
1337 #endif  /* ASN_DISABLE_PER_SUPPORT */
1338         CHOICE_random_fill,
1339         CHOICE_outmost_tag
1340 };