stglibs/smux.lib/constr_CHOICE.c

   1 /*
   2  * Copyright (c) 2003, 2004, 2005, 2006 Lev Walkin <vlm@lionet.info>.
   3  * All rights reserved.
   4  * Redistribution and modifications are permitted subject to BSD license.
   5  */
   6 #include <asn_internal.h>
   7 #include <constr_CHOICE.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 int _fetch_present_idx(const void *struct_ptr, int off, int size);
  66 static void _set_present_idx(void *sptr, int offset, int size, int pres);
  67
  68 /*
  69  * Tags are canonically sorted in the tag to member table.
  70  */
  71 static int
  72 _search4tag(const void *ap, const void *bp) {
  73         const asn_TYPE_tag2member_t *a = (const asn_TYPE_tag2member_t *)ap;
  74         const asn_TYPE_tag2member_t *b = (const asn_TYPE_tag2member_t *)bp;
  75
  76         int a_class = BER_TAG_CLASS(a->el_tag);
  77         int b_class = BER_TAG_CLASS(b->el_tag);
  78
  79         if(a_class == b_class) {
  80                 ber_tlv_tag_t a_value = BER_TAG_VALUE(a->el_tag);
  81                 ber_tlv_tag_t b_value = BER_TAG_VALUE(b->el_tag);
  82
  83                 if(a_value == b_value)
  84                         return 0;
  85                 else if(a_value < b_value)
  86                         return -1;
  87                 else
  88                         return 1;
  89         } else if(a_class < b_class) {
  90                 return -1;
  91         } else {
  92                 return 1;
  93         }
  94 }
  95
  96 /*
  97  * The decoder of the CHOICE type.
  98  */
  99 asn_dec_rval_t
 100 CHOICE_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 101         void **struct_ptr, const void *ptr, size_t size, int tag_mode) {
 102         /*
 103          * Bring closer parts of structure description.
 104          */
 105         asn_CHOICE_specifics_t *specs = (asn_CHOICE_specifics_t *)td->specifics;
 106         asn_TYPE_member_t *elements = td->elements;
 107
 108         /*
 109          * Parts of the structure being constructed.
 110          */
 111         void *st = *struct_ptr; /* Target structure. */
 112         asn_struct_ctx_t *ctx;  /* Decoder context */
 113
 114         ber_tlv_tag_t tlv_tag;  /* T from TLV */
 115         ssize_t tag_len;        /* Length of TLV's T */
 116         asn_dec_rval_t rval;    /* Return code from subparsers */
 117
 118         ssize_t consumed_myself = 0;    /* Consumed bytes from ptr */
 119
 120         ASN_DEBUG("Decoding %s as CHOICE", td->name);
 121
 122         /*
 123          * Create the target structure if it is not present already.
 124          */
 125         if(st == 0) {
 126                 st = *struct_ptr = CALLOC(1, specs->struct_size);
 127                 if(st == 0) {
 128                         RETURN(RC_FAIL);
 129                 }
 130         }
 131
 132         /*
 133          * Restore parsing context.
 134          */
 135         ctx = (asn_struct_ctx_t *)((char *)st + specs->ctx_offset);
 136
 137         /*
 138          * Start to parse where left previously
 139          */
 140         switch(ctx->phase) {
 141         case 0:
 142                 /*
 143                  * PHASE 0.
 144                  * Check that the set of tags associated with given structure
 145                  * perfectly fits our expectations.
 146                  */
 147
 148                 if(tag_mode || td->tags_count) {
 149                         rval = ber_check_tags(opt_codec_ctx, td, ctx, ptr, size,
 150                                 tag_mode, -1, &ctx->left, 0);
 151                         if(rval.code != RC_OK) {
 152                                 ASN_DEBUG("%s tagging check failed: %d",
 153                                         td->name, rval.code);
 154                                 return rval;
 155                         }
 156
 157                         if(ctx->left >= 0) {
 158                                 /* ?Substracted below! */
 159                                 ctx->left += rval.consumed;
 160                         }
 161                         ADVANCE(rval.consumed);
 162                 } else {
 163                         ctx->left = -1;
 164                 }
 165
 166                 NEXT_PHASE(ctx);
 167
 168                 ASN_DEBUG("Structure consumes %ld bytes, buffer %ld",
 169                         (long)ctx->left, (long)size);
 170
 171                 /* Fall through */
 172         case 1:
 173                 /*
 174                  * Fetch the T from TLV.
 175                  */
 176                 tag_len = ber_fetch_tag(ptr, LEFT, &tlv_tag);
 177                 ASN_DEBUG("In %s CHOICE tag length %d", td->name, (int)tag_len);
 178                 switch(tag_len) {
 179                 case 0: if(!SIZE_VIOLATION) RETURN(RC_WMORE);
 180                         /* Fall through */
 181                 case -1: RETURN(RC_FAIL);
 182                 }
 183
 184                 do {
 185                         asn_TYPE_tag2member_t *t2m;
 186                         asn_TYPE_tag2member_t key;
 187
 188                         key.el_tag = tlv_tag;
 189                         t2m = (asn_TYPE_tag2member_t *)bsearch(&key,
 190                                         specs->tag2el, specs->tag2el_count,
 191                                         sizeof(specs->tag2el[0]), _search4tag);
 192                         if(t2m) {
 193                                 /*
 194                                  * Found the element corresponding to the tag.
 195                                  */
 196                                 NEXT_PHASE(ctx);
 197                                 ctx->step = t2m->el_no;
 198                                 break;
 199                         } else if(specs->ext_start == -1) {
 200                                 ASN_DEBUG("Unexpected tag %s "
 201                                         "in non-extensible CHOICE %s",
 202                                         ber_tlv_tag_string(tlv_tag), td->name);
 203                                 RETURN(RC_FAIL);
 204                         } else {
 205                                 /* Skip this tag */
 206                                 ssize_t skip;
 207
 208                                 ASN_DEBUG("Skipping unknown tag %s",
 209                                         ber_tlv_tag_string(tlv_tag));
 210
 211                                 skip = ber_skip_length(opt_codec_ctx,
 212                                         BER_TLV_CONSTRUCTED(ptr),
 213                                         (const char *)ptr + tag_len,
 214                                         LEFT - tag_len);
 215
 216                                 switch(skip) {
 217                                 case 0: if(!SIZE_VIOLATION) RETURN(RC_WMORE);
 218                                         /* Fall through */
 219                                 case -1: RETURN(RC_FAIL);
 220                                 }
 221
 222                                 ADVANCE(skip + tag_len);
 223                                 RETURN(RC_OK);
 224                         }
 225                 } while(0);
 226
 227         case 2:
 228                 /*
 229                  * PHASE 2.
 230                  * Read in the element.
 231                  */
 232             do {
 233                 asn_TYPE_member_t *elm;/* CHOICE's element */
 234                 void *memb_ptr;         /* Pointer to the member */
 235                 void **memb_ptr2;       /* Pointer to that pointer */
 236
 237                 elm = &elements[ctx->step];
 238
 239                 /*
 240                  * Compute the position of the member inside a structure,
 241                  * and also a type of containment (it may be contained
 242                  * as pointer or using inline inclusion).
 243                  */
 244                 if(elm->flags & ATF_POINTER) {
 245                         /* Member is a pointer to another structure */
 246                         memb_ptr2 = (void **)((char *)st + elm->memb_offset);
 247                 } else {
 248                         /*
 249                          * A pointer to a pointer
 250                          * holding the start of the structure
 251                          */
 252                         memb_ptr = (char *)st + elm->memb_offset;
 253                         memb_ptr2 = &memb_ptr;
 254                 }
 255                 /* Set presence to be able to free it properly at any time */
 256                 _set_present_idx(st, specs->pres_offset,
 257                                 specs->pres_size, ctx->step + 1);
 258                 /*
 259                  * Invoke the member fetch routine according to member's type
 260                  */
 261                 rval = elm->type->ber_decoder(opt_codec_ctx, elm->type,
 262                                 memb_ptr2, ptr, LEFT, elm->tag_mode);
 263                 switch(rval.code) {
 264                 case RC_OK:
 265                         break;
 266                 case RC_WMORE: /* More data expected */
 267                         if(!SIZE_VIOLATION) {
 268                                 ADVANCE(rval.consumed);
 269                                 RETURN(RC_WMORE);
 270                         }
 271                         RETURN(RC_FAIL);
 272                 case RC_FAIL: /* Fatal error */
 273                         RETURN(rval.code);
 274                 } /* switch(rval) */
 275
 276                 ADVANCE(rval.consumed);
 277           } while(0);
 278
 279                 NEXT_PHASE(ctx);
 280
 281                 /* Fall through */
 282         case 3:
 283                 ASN_DEBUG("CHOICE %s Leftover: %ld, size = %ld, tm=%d, tc=%d",
 284                         td->name, (long)ctx->left, (long)size,
 285                         tag_mode, td->tags_count);
 286
 287                 if(ctx->left > 0) {
 288                         /*
 289                          * The type must be fully decoded
 290                          * by the CHOICE member-specific decoder.
 291                          */
 292                         RETURN(RC_FAIL);
 293                 }
 294
 295                 if(ctx->left == -1
 296                 && !(tag_mode || td->tags_count)) {
 297                         /*
 298                          * This is an untagged CHOICE.
 299                          * It doesn't contain nothing
 300                          * except for the member itself, including all its tags.
 301                          * The decoding is completed.
 302                          */
 303                         NEXT_PHASE(ctx);
 304                         break;
 305                 }
 306
 307                 /*
 308                  * Read in the "end of data chunks"'s.
 309                  */
 310                 while(ctx->left < 0) {
 311                         ssize_t tl;
 312
 313                         tl = ber_fetch_tag(ptr, LEFT, &tlv_tag);
 314                         switch(tl) {
 315                         case 0: if(!SIZE_VIOLATION) RETURN(RC_WMORE);
 316                                 /* Fall through */
 317                         case -1: RETURN(RC_FAIL);
 318                         }
 319
 320                         /*
 321                          * Expected <0><0>...
 322                          */
 323                         if(((const uint8_t *)ptr)[0] == 0) {
 324                                 if(LEFT < 2) {
 325                                         if(SIZE_VIOLATION)
 326                                                 RETURN(RC_FAIL);
 327                                         else
 328                                                 RETURN(RC_WMORE);
 329                                 } else if(((const uint8_t *)ptr)[1] == 0) {
 330                                         /*
 331                                          * Correctly finished with <0><0>.
 332                                          */
 333                                         ADVANCE(2);
 334                                         ctx->left++;
 335                                         continue;
 336                                 }
 337                         } else {
 338                                 ASN_DEBUG("Unexpected continuation in %s",
 339                                         td->name);
 340                                 RETURN(RC_FAIL);
 341                         }
 342
 343                         /* UNREACHABLE */
 344                 }
 345
 346                 NEXT_PHASE(ctx);
 347         case 4:
 348                 /* No meaningful work here */
 349                 break;
 350         }
 351
 352         RETURN(RC_OK);
 353 }
 354
 355 asn_enc_rval_t
 356 CHOICE_encode_der(asn_TYPE_descriptor_t *td, void *sptr,
 357                 int tag_mode, ber_tlv_tag_t tag,
 358                 asn_app_consume_bytes_f *cb, void *app_key) {
 359         asn_CHOICE_specifics_t *specs = (asn_CHOICE_specifics_t *)td->specifics;
 360         asn_TYPE_member_t *elm; /* CHOICE element */
 361         asn_enc_rval_t erval;
 362         void *memb_ptr;
 363         size_t computed_size = 0;
 364         int present;
 365
 366         if(!sptr) _ASN_ENCODE_FAILED;
 367
 368         ASN_DEBUG("%s %s as CHOICE",
 369                 cb?"Encoding":"Estimating", td->name);
 370
 371         present = _fetch_present_idx(sptr,
 372                 specs->pres_offset, specs->pres_size);
 373
 374         /*
 375          * If the structure was not initialized, it cannot be encoded:
 376          * can't deduce what to encode in the choice type.
 377          */
 378         if(present <= 0 || present > td->elements_count) {
 379                 if(present == 0 && td->elements_count == 0) {
 380                         /* The CHOICE is empty?! */
 381                         erval.encoded = 0;
 382                         _ASN_ENCODED_OK(erval);
 383                 }
 384                 _ASN_ENCODE_FAILED;
 385         }
 386
 387         /*
 388          * Seek over the present member of the structure.
 389          */
 390         elm = &td->elements[present-1];
 391         if(elm->flags & ATF_POINTER) {
 392                 memb_ptr = *(void **)((char *)sptr + elm->memb_offset);
 393                 if(memb_ptr == 0) {
 394                         if(elm->optional) {
 395                                 erval.encoded = 0;
 396                                 _ASN_ENCODED_OK(erval);
 397                         }
 398                         /* Mandatory element absent */
 399                         _ASN_ENCODE_FAILED;
 400                 }
 401         } else {
 402                 memb_ptr = (void *)((char *)sptr + elm->memb_offset);
 403         }
 404
 405         /*
 406          * If the CHOICE itself is tagged EXPLICIT:
 407          * T ::= [2] EXPLICIT CHOICE { ... }
 408          * Then emit the appropriate tags.
 409          */
 410         if(tag_mode == 1 || td->tags_count) {
 411                 /*
 412                  * For this, we need to pre-compute the member.
 413                  */
 414                 ssize_t ret;
 415
 416                 /* Encode member with its tag */
 417                 erval = elm->type->der_encoder(elm->type, memb_ptr,
 418                         elm->tag_mode, elm->tag, 0, 0);
 419                 if(erval.encoded == -1)
 420                         return erval;
 421
 422                 /* Encode CHOICE with parent or my own tag */
 423                 ret = der_write_tags(td, erval.encoded, tag_mode, 1, tag,
 424                         cb, app_key);
 425                 if(ret == -1)
 426                         _ASN_ENCODE_FAILED;
 427                 computed_size += ret;
 428         }
 429
 430         /*
 431          * Encode the single underlying member.
 432          */
 433         erval = elm->type->der_encoder(elm->type, memb_ptr,
 434                 elm->tag_mode, elm->tag, cb, app_key);
 435         if(erval.encoded == -1)
 436                 return erval;
 437
 438         ASN_DEBUG("Encoded CHOICE member in %ld bytes (+%ld)",
 439                 (long)erval.encoded, (long)computed_size);
 440
 441         erval.encoded += computed_size;
 442
 443         return erval;
 444 }
 445
 446 ber_tlv_tag_t
 447 CHOICE_outmost_tag(asn_TYPE_descriptor_t *td, const void *ptr, int tag_mode, ber_tlv_tag_t tag) {
 448         asn_CHOICE_specifics_t *specs = (asn_CHOICE_specifics_t *)td->specifics;
 449         int present;
 450
 451         assert(tag_mode == 0); (void)tag_mode;
 452         assert(tag == 0); (void)tag;
 453
 454         /*
 455          * Figure out which CHOICE element is encoded.
 456          */
 457         present = _fetch_present_idx(ptr, specs->pres_offset, specs->pres_size);
 458
 459         if(present > 0 || present <= td->elements_count) {
 460                 asn_TYPE_member_t *elm = &td->elements[present-1];
 461                 const void *memb_ptr;
 462
 463                 if(elm->flags & ATF_POINTER) {
 464                         memb_ptr = *(const void * const *)
 465                                         ((const char *)ptr + elm->memb_offset);
 466                 } else {
 467                         memb_ptr = (const void *)
 468                                         ((const char *)ptr + elm->memb_offset);
 469                 }
 470
 471                 return asn_TYPE_outmost_tag(elm->type, memb_ptr,
 472                         elm->tag_mode, elm->tag);
 473         } else {
 474                 return (ber_tlv_tag_t)-1;
 475         }
 476 }
 477
 478 int
 479 CHOICE_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
 480                 asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 481         asn_CHOICE_specifics_t *specs = (asn_CHOICE_specifics_t *)td->specifics;
 482         int present;
 483
 484         if(!sptr) {
 485                 _ASN_CTFAIL(app_key, td,
 486                         "%s: value not given (%s:%d)",
 487                         td->name, __FILE__, __LINE__);
 488                 return -1;
 489         }
 490
 491         /*
 492          * Figure out which CHOICE element is encoded.
 493          */
 494         present = _fetch_present_idx(sptr, specs->pres_offset,specs->pres_size);
 495         if(present > 0 && present <= td->elements_count) {
 496                 asn_TYPE_member_t *elm = &td->elements[present-1];
 497                 const void *memb_ptr;
 498
 499                 if(elm->flags & ATF_POINTER) {
 500                         memb_ptr = *(const void * const *)((const char *)sptr + elm->memb_offset);
 501                         if(!memb_ptr) {
 502                                 if(elm->optional)
 503                                         return 0;
 504                                 _ASN_CTFAIL(app_key, td,
 505                                         "%s: mandatory CHOICE element %s absent (%s:%d)",
 506                                         td->name, elm->name, __FILE__, __LINE__);
 507                                 return -1;
 508                         }
 509                 } else {
 510                         memb_ptr = (const void *)((const char *)sptr + elm->memb_offset);
 511                 }
 512
 513                 if(elm->memb_constraints) {
 514                         return elm->memb_constraints(elm->type, memb_ptr,
 515                                 ctfailcb, app_key);
 516                 } else {
 517                         int ret = elm->type->check_constraints(elm->type,
 518                                         memb_ptr, ctfailcb, app_key);
 519                         /*
 520                          * Cannot inherit it eralier:
 521                          * need to make sure we get the updated version.
 522                          */
 523                         elm->memb_constraints = elm->type->check_constraints;
 524                         return ret;
 525                 }
 526         } else {
 527                 _ASN_CTFAIL(app_key, td,
 528                         "%s: no CHOICE element given (%s:%d)",
 529                         td->name, __FILE__, __LINE__);
 530                 return -1;
 531         }
 532 }
 533
 534 #undef  XER_ADVANCE
 535 #define XER_ADVANCE(num_bytes)  do {                    \
 536                 size_t num = num_bytes;                 \
 537                 buf_ptr = ((const char *)buf_ptr) + num;\
 538                 size -= num;                            \
 539                 consumed_myself += num;                 \
 540         } while(0)
 541
 542 /*
 543  * Decode the XER (XML) data.
 544  */
 545 asn_dec_rval_t
 546 CHOICE_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 547         void **struct_ptr, const char *opt_mname,
 548                 const void *buf_ptr, size_t size) {
 549         /*
 550          * Bring closer parts of structure description.
 551          */
 552         asn_CHOICE_specifics_t *specs = (asn_CHOICE_specifics_t *)td->specifics;
 553         const char *xml_tag = opt_mname ? opt_mname : td->xml_tag;
 554
 555         /*
 556          * Parts of the structure being constructed.
 557          */
 558         void *st = *struct_ptr; /* Target structure. */
 559         asn_struct_ctx_t *ctx;  /* Decoder context */
 560
 561         asn_dec_rval_t rval;            /* Return value of a decoder */
 562         ssize_t consumed_myself = 0;    /* Consumed bytes from ptr */
 563         int edx;                        /* Element index */
 564
 565         /*
 566          * Create the target structure if it is not present already.
 567          */
 568         if(st == 0) {
 569                 st = *struct_ptr = CALLOC(1, specs->struct_size);
 570                 if(st == 0) RETURN(RC_FAIL);
 571         }
 572
 573         /*
 574          * Restore parsing context.
 575          */
 576         ctx = (asn_struct_ctx_t *)((char *)st + specs->ctx_offset);
 577         if(ctx->phase == 0 && !*xml_tag)
 578                 ctx->phase = 1; /* Skip the outer tag checking phase */
 579
 580         /*
 581          * Phases of XER/XML processing:
 582          * Phase 0: Check that the opening tag matches our expectations.
 583          * Phase 1: Processing body and reacting on closing tag.
 584          * Phase 2: Processing inner type.
 585          * Phase 3: Only waiting for closing tag.
 586          * Phase 4: Skipping unknown extensions.
 587          * Phase 5: PHASED OUT
 588          */
 589         for(edx = ctx->step; ctx->phase <= 4;) {
 590                 pxer_chunk_type_e ch_type;      /* XER chunk type */
 591                 ssize_t ch_size;                /* Chunk size */
 592                 xer_check_tag_e tcv;            /* Tag check value */
 593                 asn_TYPE_member_t *elm;
 594
 595                 /*
 596                  * Go inside the member.
 597                  */
 598                 if(ctx->phase == 2) {
 599                         asn_dec_rval_t tmprval;
 600                         void *memb_ptr;         /* Pointer to the member */
 601                         void **memb_ptr2;       /* Pointer to that pointer */
 602
 603                         elm = &td->elements[edx];
 604
 605                         if(elm->flags & ATF_POINTER) {
 606                                 /* Member is a pointer to another structure */
 607                                 memb_ptr2 = (void **)((char *)st
 608                                         + elm->memb_offset);
 609                         } else {
 610                                 memb_ptr = (char *)st + elm->memb_offset;
 611                                 memb_ptr2 = &memb_ptr;
 612                         }
 613
 614                         /* Start/Continue decoding the inner member */
 615                         tmprval = elm->type->xer_decoder(opt_codec_ctx,
 616                                         elm->type, memb_ptr2, elm->name,
 617                                         buf_ptr, size);
 618                         XER_ADVANCE(tmprval.consumed);
 619                         ASN_DEBUG("XER/CHOICE: itdf: [%s] code=%d",
 620                                 elm->type->name, tmprval.code);
 621                         if(tmprval.code != RC_OK)
 622                                 RETURN(tmprval.code);
 623                         assert(_fetch_present_idx(st,
 624                                 specs->pres_offset, specs->pres_size) == 0);
 625                         /* Record what we've got */
 626                         _set_present_idx(st,
 627                                 specs->pres_offset, specs->pres_size, edx + 1);
 628                         ctx->phase = 3;
 629                         /* Fall through */
 630                 }
 631
 632                 /* No need to wait for closing tag; special mode. */
 633                 if(ctx->phase == 3 && !*xml_tag) {
 634                         ctx->phase = 5; /* Phase out */
 635                         RETURN(RC_OK);
 636                 }
 637
 638                 /*
 639                  * Get the next part of the XML stream.
 640                  */
 641                 ch_size = xer_next_token(&ctx->context, buf_ptr, size, &ch_type);
 642                 switch(ch_size) {
 643                 case -1: RETURN(RC_FAIL);
 644                 case 0:  RETURN(RC_WMORE);
 645                 default:
 646                         switch(ch_type) {
 647                         case PXER_COMMENT:      /* Got XML comment */
 648                         case PXER_TEXT:         /* Ignore free-standing text */
 649                                 XER_ADVANCE(ch_size);   /* Skip silently */
 650                                 continue;
 651                         case PXER_TAG:
 652                                 break;  /* Check the rest down there */
 653                         }
 654                 }
 655
 656                 tcv = xer_check_tag(buf_ptr, ch_size, xml_tag);
 657                 ASN_DEBUG("XER/CHOICE checked [%c%c%c%c] vs [%s], tcv=%d",
 658                         ch_size>0?((const uint8_t *)buf_ptr)[0]:'?',
 659                         ch_size>1?((const uint8_t *)buf_ptr)[1]:'?',
 660                         ch_size>2?((const uint8_t *)buf_ptr)[2]:'?',
 661                         ch_size>3?((const uint8_t *)buf_ptr)[3]:'?',
 662                 xml_tag, tcv);
 663
 664                 /* Skip the extensions section */
 665                 if(ctx->phase == 4) {
 666                         ASN_DEBUG("skip_unknown(%d, %ld)",
 667                                 tcv, (long)ctx->left);
 668                         switch(xer_skip_unknown(tcv, &ctx->left)) {
 669                         case -1:
 670                                 ctx->phase = 5;
 671                                 RETURN(RC_FAIL);
 672                                 continue;
 673                         case 1:
 674                                 ctx->phase = 3;
 675                                 /* Fall through */
 676                         case 0:
 677                                 XER_ADVANCE(ch_size);
 678                                 continue;
 679                         case 2:
 680                                 ctx->phase = 3;
 681                                 break;
 682                         }
 683                 }
 684
 685                 switch(tcv) {
 686                 case XCT_BOTH:
 687                         break;  /* No CHOICE? */
 688                 case XCT_CLOSING:
 689                         if(ctx->phase != 3)
 690                                 break;
 691                         XER_ADVANCE(ch_size);
 692                         ctx->phase = 5; /* Phase out */
 693                         RETURN(RC_OK);
 694                 case XCT_OPENING:
 695                         if(ctx->phase == 0) {
 696                                 XER_ADVANCE(ch_size);
 697                                 ctx->phase = 1; /* Processing body phase */
 698                                 continue;
 699                         }
 700                         /* Fall through */
 701                 case XCT_UNKNOWN_OP:
 702                 case XCT_UNKNOWN_BO:
 703
 704                         if(ctx->phase != 1)
 705                                 break;  /* Really unexpected */
 706
 707                         /*
 708                          * Search which inner member corresponds to this tag.
 709                          */
 710                         for(edx = 0; edx < td->elements_count; edx++) {
 711                                 elm = &td->elements[edx];
 712                                 tcv = xer_check_tag(buf_ptr,ch_size,elm->name);
 713                                 switch(tcv) {
 714                                 case XCT_BOTH:
 715                                 case XCT_OPENING:
 716                                         /*
 717                                          * Process this member.
 718                                          */
 719                                         ctx->step = edx;
 720                                         ctx->phase = 2;
 721                                         break;
 722                                 case XCT_UNKNOWN_OP:
 723                                 case XCT_UNKNOWN_BO:
 724                                         continue;
 725                                 default:
 726                                         edx = td->elements_count;
 727                                         break;  /* Phase out */
 728                                 }
 729                                 break;
 730                         }
 731                         if(edx != td->elements_count)
 732                                 continue;
 733
 734                         /* It is expected extension */
 735                         if(specs->ext_start != -1) {
 736                                 ASN_DEBUG("Got anticipated extension");
 737                                 /*
 738                                  * Check for (XCT_BOTH or XCT_UNKNOWN_BO)
 739                                  * By using a mask. Only record a pure
 740                                  * <opening> tags.
 741                                  */
 742                                 if(tcv & XCT_CLOSING) {
 743                                         /* Found </extension> without body */
 744                                         ctx->phase = 3; /* Terminating */
 745                                 } else {
 746                                         ctx->left = 1;
 747                                         ctx->phase = 4; /* Skip ...'s */
 748                                 }
 749                                 XER_ADVANCE(ch_size);
 750                                 continue;
 751                         }
 752
 753                         /* Fall through */
 754                 default:
 755                         break;
 756                 }
 757
 758                 ASN_DEBUG("Unexpected XML tag [%c%c%c%c] in CHOICE [%s]"
 759                         " (ph=%d, tag=%s)",
 760                         ch_size>0?((const uint8_t *)buf_ptr)[0]:'?',
 761                         ch_size>1?((const uint8_t *)buf_ptr)[1]:'?',
 762                         ch_size>2?((const uint8_t *)buf_ptr)[2]:'?',
 763                         ch_size>3?((const uint8_t *)buf_ptr)[3]:'?',
 764                         td->name, ctx->phase, xml_tag);
 765                 break;
 766         }
 767
 768         ctx->phase = 5; /* Phase out, just in case */
 769         RETURN(RC_FAIL);
 770 }
 771
 772
 773 asn_enc_rval_t
 774 CHOICE_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
 775         int ilevel, enum xer_encoder_flags_e flags,
 776                 asn_app_consume_bytes_f *cb, void *app_key) {
 777         asn_CHOICE_specifics_t *specs=(asn_CHOICE_specifics_t *)td->specifics;
 778         asn_enc_rval_t er;
 779         int present;
 780
 781         if(!sptr)
 782                 _ASN_ENCODE_FAILED;
 783
 784         /*
 785          * Figure out which CHOICE element is encoded.
 786          */
 787         present = _fetch_present_idx(sptr, specs->pres_offset,specs->pres_size);
 788
 789         if(present <= 0 || present > td->elements_count) {
 790                 _ASN_ENCODE_FAILED;
 791         }  else {
 792                 asn_enc_rval_t tmper;
 793                 asn_TYPE_member_t *elm = &td->elements[present-1];
 794                 void *memb_ptr;
 795                 const char *mname = elm->name;
 796                 unsigned int mlen = strlen(mname);
 797
 798                 if(elm->flags & ATF_POINTER) {
 799                         memb_ptr = *(void **)((char *)sptr + elm->memb_offset);
 800                         if(!memb_ptr) _ASN_ENCODE_FAILED;
 801                 } else {
 802                         memb_ptr = (void *)((char *)sptr + elm->memb_offset);
 803                 }
 804
 805                 er.encoded = 0;
 806
 807                 if(!(flags & XER_F_CANONICAL)) _i_ASN_TEXT_INDENT(1, ilevel);
 808                 _ASN_CALLBACK3("<", 1, mname, mlen, ">", 1);
 809
 810                 tmper = elm->type->xer_encoder(elm->type, memb_ptr,
 811                                 ilevel + 1, flags, cb, app_key);
 812                 if(tmper.encoded == -1) return tmper;
 813
 814                 _ASN_CALLBACK3("</", 2, mname, mlen, ">", 1);
 815
 816                 er.encoded += 5 + (2 * mlen) + tmper.encoded;
 817         }
 818
 819         if(!(flags & XER_F_CANONICAL)) _i_ASN_TEXT_INDENT(1, ilevel - 1);
 820
 821         _ASN_ENCODED_OK(er);
 822 cb_failed:
 823         _ASN_ENCODE_FAILED;
 824 }
 825
 826 asn_dec_rval_t
 827 CHOICE_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 828         asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) {
 829         asn_CHOICE_specifics_t *specs = (asn_CHOICE_specifics_t *)td->specifics;
 830         asn_dec_rval_t rv;
 831         asn_per_constraint_t *ct;
 832         asn_TYPE_member_t *elm; /* CHOICE's element */
 833         void *memb_ptr;
 834         void **memb_ptr2;
 835         void *st = *sptr;
 836         int value;
 837
 838         if(_ASN_STACK_OVERFLOW_CHECK(opt_codec_ctx))
 839                 _ASN_DECODE_FAILED;
 840
 841         /*
 842          * Create the target structure if it is not present already.
 843          */
 844         if(!st) {
 845                 st = *sptr = CALLOC(1, specs->struct_size);
 846                 if(!st) _ASN_DECODE_FAILED;
 847         }
 848
 849         if(constraints) ct = &constraints->value;
 850         else if(td->per_constraints) ct = &td->per_constraints->value;
 851         else ct = 0;
 852
 853         if(ct && ct->flags & APC_EXTENSIBLE) {
 854                 value = per_get_few_bits(pd, 1);
 855                 if(value < 0) _ASN_DECODE_STARVED;
 856                 if(value) ct = 0;       /* Not restricted */
 857         }
 858
 859         if(ct && ct->range_bits >= 0) {
 860                 value = per_get_few_bits(pd, ct->range_bits);
 861                 if(value < 0) _ASN_DECODE_STARVED;
 862                 ASN_DEBUG("CHOICE %s got index %d in range %d",
 863                         td->name, value, ct->range_bits);
 864                 if(value > ct->upper_bound)
 865                         _ASN_DECODE_FAILED;
 866         } else {
 867                 if(specs->ext_start == -1)
 868                         _ASN_DECODE_FAILED;
 869                 value = uper_get_nsnnwn(pd);
 870                 if(value < 0) _ASN_DECODE_STARVED;
 871                 value += specs->ext_start;
 872                 if(value >= td->elements_count)
 873                         _ASN_DECODE_FAILED;
 874                 ASN_DEBUG("NOT IMPLEMENTED YET");
 875                 _ASN_DECODE_FAILED;
 876         }
 877
 878         /* Adjust if canonical order is different from natural order */
 879         if(specs->canonical_order)
 880                 value = specs->canonical_order[value];
 881
 882         /* Set presence to be able to free it later */
 883         _set_present_idx(st, specs->pres_offset, specs->pres_size, value + 1);
 884
 885         elm = &td->elements[value];
 886         if(elm->flags & ATF_POINTER) {
 887                 /* Member is a pointer to another structure */
 888                 memb_ptr2 = (void **)((char *)st + elm->memb_offset);
 889         } else {
 890                 memb_ptr = (char *)st + elm->memb_offset;
 891                 memb_ptr2 = &memb_ptr;
 892         }
 893         ASN_DEBUG("Discovered CHOICE %s encodes %s", td->name, elm->name);
 894
 895         rv = elm->type->uper_decoder(opt_codec_ctx, elm->type,
 896                         elm->per_constraints, memb_ptr2, pd);
 897         if(rv.code != RC_OK)
 898                 ASN_DEBUG("Failed to decode %s in %s (CHOICE)",
 899                         elm->name, td->name);
 900         return rv;
 901 }
 902
 903 asn_enc_rval_t
 904 CHOICE_encode_uper(asn_TYPE_descriptor_t *td,
 905         asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) {
 906         asn_CHOICE_specifics_t *specs = (asn_CHOICE_specifics_t *)td->specifics;
 907         asn_TYPE_member_t *elm; /* CHOICE's element */
 908         asn_per_constraint_t *ct;
 909         void *memb_ptr;
 910         int present;
 911
 912         if(!sptr) _ASN_ENCODE_FAILED;
 913
 914         ASN_DEBUG("Encoding %s as CHOICE", td->name);
 915
 916         if(constraints) ct = &constraints->value;
 917         else if(td->per_constraints) ct = &td->per_constraints->value;
 918         else ct = 0;
 919
 920         present = _fetch_present_idx(sptr,
 921                 specs->pres_offset, specs->pres_size);
 922
 923         /*
 924          * If the structure was not initialized properly, it cannot be encoded:
 925          * can't deduce what to encode in the choice type.
 926          */
 927         if(present <= 0 || present > td->elements_count)
 928                 _ASN_ENCODE_FAILED;
 929         else
 930                 present--;
 931
 932         /* Adjust if canonical order is different from natural order */
 933         if(specs->canonical_order)
 934                 present = specs->canonical_order[present];
 935
 936         ASN_DEBUG("Encoding %s CHOICE element %d", td->name, present);
 937
 938         if(ct && ct->range_bits >= 0) {
 939                 if(present < ct->lower_bound
 940                 || present > ct->upper_bound) {
 941                         if(ct->flags & APC_EXTENSIBLE) {
 942                                 if(per_put_few_bits(po, 1, 1))
 943                                         _ASN_ENCODE_FAILED;
 944                         } else {
 945                                 _ASN_ENCODE_FAILED;
 946                         }
 947                         ct = 0;
 948                 }
 949         }
 950         if(ct && ct->flags & APC_EXTENSIBLE)
 951                 if(per_put_few_bits(po, 0, 1))
 952                         _ASN_ENCODE_FAILED;
 953
 954         if(ct && ct->range_bits >= 0) {
 955                 if(per_put_few_bits(po, present, ct->range_bits))
 956                         _ASN_ENCODE_FAILED;
 957         } else {
 958                 if(specs->ext_start == -1)
 959                         _ASN_ENCODE_FAILED;
 960                 if(uper_put_nsnnwn(po, present - specs->ext_start))
 961                         _ASN_ENCODE_FAILED;
 962                 ASN_DEBUG("NOT IMPLEMENTED YET");
 963                 _ASN_ENCODE_FAILED;
 964         }
 965
 966         elm = &td->elements[present];
 967         if(elm->flags & ATF_POINTER) {
 968                 /* Member is a pointer to another structure */
 969                 memb_ptr = *(void **)((char *)sptr + elm->memb_offset);
 970                 if(!memb_ptr) _ASN_ENCODE_FAILED;
 971         } else {
 972                 memb_ptr = (char *)sptr + elm->memb_offset;
 973         }
 974
 975         return elm->type->uper_encoder(elm->type, elm->per_constraints,
 976                         memb_ptr, po);
 977 }
 978
 979
 980 int
 981 CHOICE_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
 982                 asn_app_consume_bytes_f *cb, void *app_key) {
 983         asn_CHOICE_specifics_t *specs = (asn_CHOICE_specifics_t *)td->specifics;
 984         int present;
 985
 986         if(!sptr) return (cb("<absent>", 8, app_key) < 0) ? -1 : 0;
 987
 988         /*
 989          * Figure out which CHOICE element is encoded.
 990          */
 991         present = _fetch_present_idx(sptr, specs->pres_offset,specs->pres_size);
 992
 993         /*
 994          * Print that element.
 995          */
 996         if(present > 0 && present <= td->elements_count) {
 997                 asn_TYPE_member_t *elm = &td->elements[present-1];
 998                 const void *memb_ptr;
 999
1000                 if(elm->flags & ATF_POINTER) {
1001                         memb_ptr = *(const void * const *)((const char *)sptr + elm->memb_offset);
1002                         if(!memb_ptr) return (cb("<absent>", 8, app_key) < 0) ? -1 : 0;
1003                 } else {
1004                         memb_ptr = (const void *)((const char *)sptr + elm->memb_offset);
1005                 }
1006
1007                 /* Print member's name and stuff */
1008                 if(0) {
1009                         if(cb(elm->name, strlen(elm->name), app_key) < 0
1010                         || cb(": ", 2, app_key) < 0)
1011                                 return -1;
1012                 }
1013
1014                 return elm->type->print_struct(elm->type, memb_ptr, ilevel,
1015                         cb, app_key);
1016         } else {
1017                 return (cb("<absent>", 8, app_key) < 0) ? -1 : 0;
1018         }
1019 }
1020
1021 void
1022 CHOICE_free(asn_TYPE_descriptor_t *td, void *ptr, int contents_only) {
1023         asn_CHOICE_specifics_t *specs = (asn_CHOICE_specifics_t *)td->specifics;
1024         int present;
1025
1026         if(!td || !ptr)
1027                 return;
1028
1029         ASN_DEBUG("Freeing %s as CHOICE", td->name);
1030
1031         /*
1032          * Figure out which CHOICE element is encoded.
1033          */
1034         present = _fetch_present_idx(ptr, specs->pres_offset, specs->pres_size);
1035
1036         /*
1037          * Free that element.
1038          */
1039         if(present > 0 && present <= td->elements_count) {
1040                 asn_TYPE_member_t *elm = &td->elements[present-1];
1041                 void *memb_ptr;
1042
1043                 if(elm->flags & ATF_POINTER) {
1044                         memb_ptr = *(void **)((char *)ptr + elm->memb_offset);
1045                         if(memb_ptr)
1046                                 ASN_STRUCT_FREE(*elm->type, memb_ptr);
1047                 } else {
1048                         memb_ptr = (void *)((char *)ptr + elm->memb_offset);
1049                         ASN_STRUCT_FREE_CONTENTS_ONLY(*elm->type, memb_ptr);
1050                 }
1051         }
1052
1053         if(!contents_only) {
1054                 FREEMEM(ptr);
1055         }
1056 }
1057
1058
1059 /*
1060  * The following functions functions offer protection against -fshort-enums,
1061  * compatible with little- and big-endian machines.
1062  * If assertion is triggered, either disable -fshort-enums, or add an entry
1063  * here with the ->pres_size of your target stracture.
1064  * Unless the target structure is packed, the ".present" member
1065  * is guaranteed to be aligned properly. ASN.1 compiler itself does not
1066  * produce packed code.
1067  */
1068 static int
1069 _fetch_present_idx(const void *struct_ptr, int pres_offset, int pres_size) {
1070         const void *present_ptr;
1071         int present;
1072
1073         present_ptr = ((const char *)struct_ptr) + pres_offset;
1074
1075         switch(pres_size) {
1076         case sizeof(int):       present =   *(const int *)present_ptr; break;
1077         case sizeof(short):     present = *(const short *)present_ptr; break;
1078         case sizeof(char):      present =  *(const char *)present_ptr; break;
1079         default:
1080                 /* ANSI C mandates enum to be equivalent to integer */
1081                 assert(pres_size != sizeof(int));
1082                 return 0;       /* If not aborted, pass back safe value */
1083         }
1084
1085         return present;
1086 }
1087
1088 static void
1089 _set_present_idx(void *struct_ptr, int pres_offset, int pres_size, int present) {
1090         void *present_ptr;
1091         present_ptr = ((char *)struct_ptr) + pres_offset;
1092
1093         switch(pres_size) {
1094         case sizeof(int):       *(int *)present_ptr   = present; break;
1095         case sizeof(short):     *(short *)present_ptr = present; break;
1096         case sizeof(char):      *(char *)present_ptr  = present; break;
1097         default:
1098                 /* ANSI C mandates enum to be equivalent to integer */
1099                 assert(pres_size != sizeof(int));
1100         }
1101 }