asn1c_defs/all-defs/constr_SET_OF.c

   1 /*\r
   2  * Copyright (c) 2003-2017 Lev Walkin <vlm@lionet.info>.\r
   3  * All rights reserved.\r
   4  * Redistribution and modifications are permitted subject to BSD license.\r
   5  */\r
   6 #include <asn_internal.h>\r
   7 #include <constr_SET_OF.h>\r
   8 #include <asn_SET_OF.h>\r
   9 \r
  10 /*\r
  11  * Number of bytes left for this structure.\r
  12  * (ctx->left) indicates the number of bytes _transferred_ for the structure.\r
  13  * (size) contains the number of bytes in the buffer passed.\r
  14  */\r
  15 #define LEFT    ((size<(size_t)ctx->left)?size:(size_t)ctx->left)\r
  16 \r
  17 /*\r
  18  * If the subprocessor function returns with an indication that it wants\r
  19  * more data, it may well be a fatal decoding problem, because the\r
  20  * size is constrained by the <TLV>'s L, even if the buffer size allows\r
  21  * reading more data.\r
  22  * For example, consider the buffer containing the following TLVs:\r
  23  * <T:5><L:1><V> <T:6>...\r
  24  * The TLV length clearly indicates that one byte is expected in V, but\r
  25  * if the V processor returns with "want more data" even if the buffer\r
  26  * contains way more data than the V processor have seen.\r
  27  */\r
  28 #define SIZE_VIOLATION  (ctx->left >= 0 && (size_t)ctx->left <= size)\r
  29 \r
  30 /*\r
  31  * This macro "eats" the part of the buffer which is definitely "consumed",\r
  32  * i.e. was correctly converted into local representation or rightfully skipped.\r
  33  */\r
  34 #undef  ADVANCE\r
  35 #define ADVANCE(num_bytes)      do {            \\r
  36                 size_t num = num_bytes;         \\r
  37                 ptr = ((const char *)ptr) + num;\\r
  38                 size -= num;                    \\r
  39                 if(ctx->left >= 0)              \\r
  40                         ctx->left -= num;       \\r
  41                 consumed_myself += num;         \\r
  42         } while(0)\r
  43 \r
  44 /*\r
  45  * Switch to the next phase of parsing.\r
  46  */\r
  47 #undef  NEXT_PHASE\r
  48 #undef  PHASE_OUT\r
  49 #define NEXT_PHASE(ctx) do {                    \\r
  50                 ctx->phase++;                   \\r
  51                 ctx->step = 0;                  \\r
  52         } while(0)\r
  53 #define PHASE_OUT(ctx)  do { ctx->phase = 10; } while(0)\r
  54 \r
  55 /*\r
  56  * Return a standardized complex structure.\r
  57  */\r
  58 #undef  RETURN\r
  59 #define RETURN(_code)   do {                    \\r
  60                 rval.code = _code;              \\r
  61                 rval.consumed = consumed_myself;\\r
  62                 return rval;                    \\r
  63         } while(0)\r
  64 \r
  65 /*\r
  66  * The decoder of the SET OF type.\r
  67  */\r
  68 asn_dec_rval_t\r
  69 SET_OF_decode_ber(const asn_codec_ctx_t *opt_codec_ctx,\r
  70                   const asn_TYPE_descriptor_t *td, void **struct_ptr,\r
  71                   const void *ptr, size_t size, int tag_mode) {\r
  72     /*\r
  73          * Bring closer parts of structure description.\r
  74          */\r
  75         const asn_SET_OF_specifics_t *specs = (const asn_SET_OF_specifics_t *)td->specifics;\r
  76     const asn_TYPE_member_t *elm = td->elements; /* Single one */\r
  77 \r
  78     /*\r
  79          * Parts of the structure being constructed.\r
  80          */\r
  81         void *st = *struct_ptr; /* Target structure. */\r
  82         asn_struct_ctx_t *ctx;  /* Decoder context */\r
  83 \r
  84         ber_tlv_tag_t tlv_tag;  /* T from TLV */\r
  85         asn_dec_rval_t rval;    /* Return code from subparsers */\r
  86 \r
  87         ssize_t consumed_myself = 0;    /* Consumed bytes from ptr */\r
  88 \r
  89         ASN_DEBUG("Decoding %s as SET OF", td->name);\r
  90         \r
  91         /*\r
  92          * Create the target structure if it is not present already.\r
  93          */\r
  94         if(st == 0) {\r
  95                 st = *struct_ptr = CALLOC(1, specs->struct_size);\r
  96                 if(st == 0) {\r
  97                         RETURN(RC_FAIL);\r
  98                 }\r
  99         }\r
 100 \r
 101         /*\r
 102          * Restore parsing context.\r
 103          */\r
 104         ctx = (asn_struct_ctx_t *)((char *)st + specs->ctx_offset);\r
 105         \r
 106         /*\r
 107          * Start to parse where left previously\r
 108          */\r
 109         switch(ctx->phase) {\r
 110         case 0:\r
 111                 /*\r
 112                  * PHASE 0.\r
 113                  * Check that the set of tags associated with given structure\r
 114                  * perfectly fits our expectations.\r
 115                  */\r
 116 \r
 117                 rval = ber_check_tags(opt_codec_ctx, td, ctx, ptr, size,\r
 118                         tag_mode, 1, &ctx->left, 0);\r
 119                 if(rval.code != RC_OK) {\r
 120                         ASN_DEBUG("%s tagging check failed: %d",\r
 121                                 td->name, rval.code);\r
 122                         return rval;\r
 123                 }\r
 124 \r
 125                 if(ctx->left >= 0)\r
 126                         ctx->left += rval.consumed; /* ?Substracted below! */\r
 127                 ADVANCE(rval.consumed);\r
 128 \r
 129                 ASN_DEBUG("Structure consumes %ld bytes, "\r
 130                         "buffer %ld", (long)ctx->left, (long)size);\r
 131 \r
 132                 NEXT_PHASE(ctx);\r
 133                 /* Fall through */\r
 134         case 1:\r
 135                 /*\r
 136                  * PHASE 1.\r
 137                  * From the place where we've left it previously,\r
 138                  * try to decode the next item.\r
 139                  */\r
 140           for(;; ctx->step = 0) {\r
 141                 ssize_t tag_len;        /* Length of TLV's T */\r
 142 \r
 143                 if(ctx->step & 1)\r
 144                         goto microphase2;\r
 145 \r
 146                 /*\r
 147                  * MICROPHASE 1: Synchronize decoding.\r
 148                  */\r
 149 \r
 150                 if(ctx->left == 0) {\r
 151                         ASN_DEBUG("End of SET OF %s", td->name);\r
 152                         /*\r
 153                          * No more things to decode.\r
 154                          * Exit out of here.\r
 155                          */\r
 156                         PHASE_OUT(ctx);\r
 157                         RETURN(RC_OK);\r
 158                 }\r
 159 \r
 160                 /*\r
 161                  * Fetch the T from TLV.\r
 162                  */\r
 163                 tag_len = ber_fetch_tag(ptr, LEFT, &tlv_tag);\r
 164                 switch(tag_len) {\r
 165                 case 0: if(!SIZE_VIOLATION) RETURN(RC_WMORE);\r
 166                         /* Fall through */\r
 167                 case -1: RETURN(RC_FAIL);\r
 168                 }\r
 169 \r
 170                 if(ctx->left < 0 && ((const uint8_t *)ptr)[0] == 0) {\r
 171                         if(LEFT < 2) {\r
 172                                 if(SIZE_VIOLATION)\r
 173                                         RETURN(RC_FAIL);\r
 174                                 else\r
 175                                         RETURN(RC_WMORE);\r
 176                         } else if(((const uint8_t *)ptr)[1] == 0) {\r
 177                                 /*\r
 178                                  * Found the terminator of the\r
 179                                  * indefinite length structure.\r
 180                                  */\r
 181                                 break;\r
 182                         }\r
 183                 }\r
 184 \r
 185                 /* Outmost tag may be unknown and cannot be fetched/compared */\r
 186                 if(elm->tag != (ber_tlv_tag_t)-1) {\r
 187                     if(BER_TAGS_EQUAL(tlv_tag, elm->tag)) {\r
 188                         /*\r
 189                          * The new list member of expected type has arrived.\r
 190                          */\r
 191                     } else {\r
 192                         ASN_DEBUG("Unexpected tag %s fixed SET OF %s",\r
 193                                 ber_tlv_tag_string(tlv_tag), td->name);\r
 194                         ASN_DEBUG("%s SET OF has tag %s",\r
 195                                 td->name, ber_tlv_tag_string(elm->tag));\r
 196                         RETURN(RC_FAIL);\r
 197                     }\r
 198                 }\r
 199 \r
 200                 /*\r
 201                  * MICROPHASE 2: Invoke the member-specific decoder.\r
 202                  */\r
 203                 ctx->step |= 1;         /* Confirm entering next microphase */\r
 204         microphase2:\r
 205                 \r
 206                 /*\r
 207                  * Invoke the member fetch routine according to member's type\r
 208                  */\r
 209                 rval = elm->type->op->ber_decoder(opt_codec_ctx,\r
 210                                 elm->type, &ctx->ptr, ptr, LEFT, 0);\r
 211                 ASN_DEBUG("In %s SET OF %s code %d consumed %d",\r
 212                         td->name, elm->type->name,\r
 213                         rval.code, (int)rval.consumed);\r
 214                 switch(rval.code) {\r
 215                 case RC_OK:\r
 216                         {\r
 217                                 asn_anonymous_set_ *list = _A_SET_FROM_VOID(st);\r
 218                                 if(ASN_SET_ADD(list, ctx->ptr) != 0)\r
 219                                         RETURN(RC_FAIL);\r
 220                                 else\r
 221                                         ctx->ptr = 0;\r
 222                         }\r
 223                         break;\r
 224                 case RC_WMORE: /* More data expected */\r
 225                         if(!SIZE_VIOLATION) {\r
 226                                 ADVANCE(rval.consumed);\r
 227                                 RETURN(RC_WMORE);\r
 228                         }\r
 229                         /* Fall through */\r
 230                 case RC_FAIL: /* Fatal error */\r
 231                         ASN_STRUCT_FREE(*elm->type, ctx->ptr);\r
 232                         ctx->ptr = 0;\r
 233                         RETURN(RC_FAIL);\r
 234                 } /* switch(rval) */\r
 235                 \r
 236                 ADVANCE(rval.consumed);\r
 237           }     /* for(all list members) */\r
 238 \r
 239                 NEXT_PHASE(ctx);\r
 240         case 2:\r
 241                 /*\r
 242                  * Read in all "end of content" TLVs.\r
 243                  */\r
 244                 while(ctx->left < 0) {\r
 245                         if(LEFT < 2) {\r
 246                                 if(LEFT > 0 && ((const char *)ptr)[0] != 0) {\r
 247                                         /* Unexpected tag */\r
 248                                         RETURN(RC_FAIL);\r
 249                                 } else {\r
 250                                         RETURN(RC_WMORE);\r
 251                                 }\r
 252                         }\r
 253                         if(((const char *)ptr)[0] == 0\r
 254                         && ((const char *)ptr)[1] == 0) {\r
 255                                 ADVANCE(2);\r
 256                                 ctx->left++;\r
 257                         } else {\r
 258                                 RETURN(RC_FAIL);\r
 259                         }\r
 260                 }\r
 261 \r
 262                 PHASE_OUT(ctx);\r
 263         }\r
 264         \r
 265         RETURN(RC_OK);\r
 266 }\r
 267 \r
 268 /*\r
 269  * Internally visible buffer holding a single encoded element.\r
 270  */\r
 271 struct _el_buffer {\r
 272         uint8_t *buf;\r
 273         size_t length;\r
 274         size_t allocated_size;\r
 275     unsigned bits_unused;\r
 276 };\r
 277 /* Append bytes to the above structure */\r
 278 static int _el_addbytes(const void *buffer, size_t size, void *el_buf_ptr) {\r
 279     struct _el_buffer *el_buf = (struct _el_buffer *)el_buf_ptr;\r
 280 \r
 281     if(el_buf->length + size > el_buf->allocated_size) {\r
 282         size_t new_size = el_buf->allocated_size ? el_buf->allocated_size : 8;\r
 283         void *p;\r
 284 \r
 285         do {\r
 286             new_size <<= 2;\r
 287         } while(el_buf->length + size > new_size);\r
 288 \r
 289         p = REALLOC(el_buf->buf, new_size);\r
 290         if(p) {\r
 291             el_buf->buf = p;\r
 292             el_buf->allocated_size = new_size;\r
 293         } else {\r
 294             return -1;\r
 295         }\r
 296     }\r
 297 \r
 298     memcpy(el_buf->buf + el_buf->length, buffer, size);\r
 299 \r
 300     el_buf->length += size;\r
 301     return 0;\r
 302 }\r
 303 \r
 304 static void assert_unused_bits(const struct _el_buffer* p) {\r
 305     if(p->length) {\r
 306         assert((p->buf[p->length-1] & ~(0xff << p->bits_unused)) == 0);\r
 307     } else {\r
 308         assert(p->bits_unused == 0);\r
 309     }\r
 310 }\r
 311 \r
 312 static int _el_buf_cmp(const void *ap, const void *bp) {\r
 313     const struct _el_buffer *a = (const struct _el_buffer *)ap;\r
 314     const struct _el_buffer *b = (const struct _el_buffer *)bp;\r
 315     size_t common_len;\r
 316     int ret = 0;\r
 317 \r
 318     if(a->length < b->length)\r
 319         common_len = a->length;\r
 320     else\r
 321         common_len = b->length;\r
 322 \r
 323     if (a->buf && b->buf) {\r
 324         ret = memcmp(a->buf, b->buf, common_len);\r
 325     }\r
 326     if(ret == 0) {\r
 327         if(a->length < b->length)\r
 328             ret = -1;\r
 329         else if(a->length > b->length)\r
 330             ret = 1;\r
 331         /* Ignore unused bits. */\r
 332         assert_unused_bits(a);\r
 333         assert_unused_bits(b);\r
 334     }\r
 335 \r
 336     return ret;\r
 337 }\r
 338 \r
 339 static void\r
 340 SET_OF__encode_sorted_free(struct _el_buffer *el_buf, size_t count) {\r
 341     size_t i;\r
 342 \r
 343     for(i = 0; i < count; i++) {\r
 344         FREEMEM(el_buf[i].buf);\r
 345     }\r
 346 \r
 347     FREEMEM(el_buf);\r
 348 }\r
 349 \r
 350 enum SET_OF__encode_method {\r
 351     SOES_DER,   /* Distinguished Encoding Rules */\r
 352     SOES_CUPER  /* Canonical Unaligned Packed Encoding Rules */\r
 353 };\r
 354 \r
 355 static struct _el_buffer *\r
 356 SET_OF__encode_sorted(const asn_TYPE_member_t *elm,\r
 357                       const asn_anonymous_set_ *list,\r
 358                       enum SET_OF__encode_method method) {\r
 359     struct _el_buffer *encoded_els;\r
 360     int edx;\r
 361 \r
 362     encoded_els =\r
 363         (struct _el_buffer *)CALLOC(list->count, sizeof(encoded_els[0]));\r
 364     if(encoded_els == NULL) {\r
 365         return NULL;\r
 366     }\r
 367 \r
 368         /*\r
 369          * Encode all members.\r
 370          */\r
 371     for(edx = 0; edx < list->count; edx++) {\r
 372         const void *memb_ptr = list->array[edx];\r
 373         struct _el_buffer *encoding_el = &encoded_els[edx];\r
 374         asn_enc_rval_t erval = {0,0,0};\r
 375 \r
 376         if(!memb_ptr) break;\r
 377 \r
 378         /*\r
 379                  * Encode the member into the prepared space.\r
 380                  */\r
 381         switch(method) {\r
 382         case SOES_DER:\r
 383             erval = elm->type->op->der_encoder(elm->type, memb_ptr, 0, elm->tag,\r
 384                                                _el_addbytes, encoding_el);\r
 385             break;\r
 386         case SOES_CUPER:\r
 387             erval = uper_encode(elm->type,\r
 388                                 elm->encoding_constraints.per_constraints,\r
 389                                 memb_ptr, _el_addbytes, encoding_el);\r
 390             if(erval.encoded != -1) {\r
 391                 size_t extra_bits = erval.encoded % 8;\r
 392                 assert(encoding_el->length == (size_t)(erval.encoded + 7) / 8);\r
 393                 encoding_el->bits_unused = (8 - extra_bits) & 0x7;\r
 394             }\r
 395             break;\r
 396         default:\r
 397             assert(!"Unreachable");\r
 398             break;\r
 399         }\r
 400         if(erval.encoded < 0) break;\r
 401         }\r
 402 \r
 403     if(edx == list->count) {\r
 404         /*\r
 405          * Sort the encoded elements according to their encoding.\r
 406          */\r
 407         qsort(encoded_els, list->count, sizeof(encoded_els[0]), _el_buf_cmp);\r
 408 \r
 409         return encoded_els;\r
 410     } else {\r
 411         SET_OF__encode_sorted_free(encoded_els, edx);\r
 412         return NULL;\r
 413     }\r
 414 }\r
 415 \r
 416 \r
 417 /*\r
 418  * The DER encoder of the SET OF type.\r
 419  */\r
 420 asn_enc_rval_t\r
 421 SET_OF_encode_der(const asn_TYPE_descriptor_t *td, const void *sptr,\r
 422                   int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb,\r
 423                   void *app_key) {\r
 424     const asn_TYPE_member_t *elm = td->elements;\r
 425     const asn_anonymous_set_ *list = _A_CSET_FROM_VOID(sptr);\r
 426     size_t computed_size = 0;\r
 427     ssize_t encoding_size = 0;\r
 428     struct _el_buffer *encoded_els;\r
 429     int edx;\r
 430 \r
 431         ASN_DEBUG("Estimating size for SET OF %s", td->name);\r
 432 \r
 433     /*\r
 434      * Gather the length of the underlying members sequence.\r
 435      */\r
 436     for(edx = 0; edx < list->count; edx++) {\r
 437         void *memb_ptr = list->array[edx];\r
 438         asn_enc_rval_t erval = {0,0,0};\r
 439 \r
 440         if(!memb_ptr) ASN__ENCODE_FAILED;\r
 441 \r
 442         erval =\r
 443             elm->type->op->der_encoder(elm->type, memb_ptr, 0, elm->tag, 0, 0);\r
 444         if(erval.encoded == -1) return erval;\r
 445         computed_size += erval.encoded;\r
 446         }\r
 447 \r
 448 \r
 449     /*\r
 450      * Encode the TLV for the sequence itself.\r
 451      */\r
 452     encoding_size =\r
 453         der_write_tags(td, computed_size, tag_mode, 1, tag, cb, app_key);\r
 454     if(encoding_size < 0) {\r
 455         ASN__ENCODE_FAILED;\r
 456     }\r
 457     computed_size += encoding_size;\r
 458 \r
 459     if(!cb || list->count == 0) {\r
 460         asn_enc_rval_t erval = {0,0,0};\r
 461         erval.encoded = computed_size;\r
 462         ASN__ENCODED_OK(erval);\r
 463     }\r
 464 \r
 465     ASN_DEBUG("Encoding members of %s SET OF", td->name);\r
 466 \r
 467     /*\r
 468      * DER mandates dynamic sorting of the SET OF elements\r
 469      * according to their encodings. Build an array of the\r
 470      * encoded elements.\r
 471      */\r
 472     encoded_els = SET_OF__encode_sorted(elm, list, SOES_DER);\r
 473 \r
 474     /*\r
 475      * Report encoded elements to the application.\r
 476      * Dispose of temporary sorted members table.\r
 477      */\r
 478     for(edx = 0; edx < list->count; edx++) {\r
 479         struct _el_buffer *encoded_el = &encoded_els[edx];\r
 480         /* Report encoded chunks to the application */\r
 481         if(cb(encoded_el->buf, encoded_el->length, app_key) < 0) {\r
 482             break;\r
 483         } else {\r
 484             encoding_size += encoded_el->length;\r
 485         }\r
 486     }\r
 487 \r
 488     SET_OF__encode_sorted_free(encoded_els, list->count);\r
 489 \r
 490     if(edx == list->count) {\r
 491         asn_enc_rval_t erval = {0,0,0};\r
 492         assert(computed_size == (size_t)encoding_size);\r
 493         erval.encoded = computed_size;\r
 494         ASN__ENCODED_OK(erval);\r
 495     } else {\r
 496         ASN__ENCODE_FAILED;\r
 497     }\r
 498 }\r
 499 \r
 500 #undef  XER_ADVANCE\r
 501 #define XER_ADVANCE(num_bytes)  do {                    \\r
 502                 size_t num = num_bytes;                 \\r
 503                 buf_ptr = ((const char *)buf_ptr) + num;\\r
 504                 size -= num;                            \\r
 505                 consumed_myself += num;                 \\r
 506         } while(0)\r
 507 \r
 508 /*\r
 509  * Decode the XER (XML) data.\r
 510  */\r
 511 asn_dec_rval_t\r
 512 SET_OF_decode_xer(const asn_codec_ctx_t *opt_codec_ctx,\r
 513                   const asn_TYPE_descriptor_t *td, void **struct_ptr,\r
 514                   const char *opt_mname, const void *buf_ptr, size_t size) {\r
 515     /*\r
 516          * Bring closer parts of structure description.\r
 517          */\r
 518         const asn_SET_OF_specifics_t *specs = (const asn_SET_OF_specifics_t *)td->specifics;\r
 519         const asn_TYPE_member_t *element = td->elements;\r
 520         const char *elm_tag;\r
 521         const char *xml_tag = opt_mname ? opt_mname : td->xml_tag;\r
 522 \r
 523         /*\r
 524          * ... and parts of the structure being constructed.\r
 525          */\r
 526         void *st = *struct_ptr; /* Target structure. */\r
 527         asn_struct_ctx_t *ctx;  /* Decoder context */\r
 528 \r
 529         asn_dec_rval_t rval = {RC_OK, 0};/* Return value from a decoder */\r
 530         ssize_t consumed_myself = 0;    /* Consumed bytes from ptr */\r
 531 \r
 532         /*\r
 533          * Create the target structure if it is not present already.\r
 534          */\r
 535         if(st == 0) {\r
 536                 st = *struct_ptr = CALLOC(1, specs->struct_size);\r
 537                 if(st == 0) RETURN(RC_FAIL);\r
 538         }\r
 539 \r
 540         /* Which tag is expected for the downstream */\r
 541         if(specs->as_XMLValueList) {\r
 542                 elm_tag = (specs->as_XMLValueList == 1) ? 0 : "";\r
 543         } else {\r
 544                 elm_tag = (*element->name)\r
 545                                 ? element->name : element->type->xml_tag;\r
 546         }\r
 547 \r
 548         /*\r
 549          * Restore parsing context.\r
 550          */\r
 551         ctx = (asn_struct_ctx_t *)((char *)st + specs->ctx_offset);\r
 552 \r
 553         /*\r
 554          * Phases of XER/XML processing:\r
 555          * Phase 0: Check that the opening tag matches our expectations.\r
 556          * Phase 1: Processing body and reacting on closing tag.\r
 557          * Phase 2: Processing inner type.\r
 558          */\r
 559         for(; ctx->phase <= 2;) {\r
 560                 pxer_chunk_type_e ch_type;      /* XER chunk type */\r
 561                 ssize_t ch_size;                /* Chunk size */\r
 562                 xer_check_tag_e tcv;            /* Tag check value */\r
 563 \r
 564                 /*\r
 565                  * Go inside the inner member of a set.\r
 566                  */\r
 567                 if(ctx->phase == 2) {\r
 568                         asn_dec_rval_t tmprval = {RC_OK, 0};\r
 569 \r
 570                         /* Invoke the inner type decoder, m.b. multiple times */\r
 571                         ASN_DEBUG("XER/SET OF element [%s]", elm_tag);\r
 572                         tmprval = element->type->op->xer_decoder(opt_codec_ctx,\r
 573                                         element->type, &ctx->ptr, elm_tag,\r
 574                                         buf_ptr, size);\r
 575                         if(tmprval.code == RC_OK) {\r
 576                                 asn_anonymous_set_ *list = _A_SET_FROM_VOID(st);\r
 577                                 if(ASN_SET_ADD(list, ctx->ptr) != 0)\r
 578                                         RETURN(RC_FAIL);\r
 579                                 ctx->ptr = 0;\r
 580                                 XER_ADVANCE(tmprval.consumed);\r
 581                         } else {\r
 582                                 XER_ADVANCE(tmprval.consumed);\r
 583                                 RETURN(tmprval.code);\r
 584                         }\r
 585                         ctx->phase = 1; /* Back to body processing */\r
 586                         ASN_DEBUG("XER/SET OF phase => %d", ctx->phase);\r
 587                         /* Fall through */\r
 588                 }\r
 589 \r
 590                 /*\r
 591                  * Get the next part of the XML stream.\r
 592                  */\r
 593                 ch_size = xer_next_token(&ctx->context,\r
 594                         buf_ptr, size, &ch_type);\r
 595                 if(ch_size == -1) {\r
 596             RETURN(RC_FAIL);\r
 597         } else {\r
 598                         switch(ch_type) {\r
 599             case PXER_WMORE:\r
 600                 RETURN(RC_WMORE);\r
 601                         case PXER_COMMENT:      /* Got XML comment */\r
 602                         case PXER_TEXT:         /* Ignore free-standing text */\r
 603                                 XER_ADVANCE(ch_size);   /* Skip silently */\r
 604                                 continue;\r
 605                         case PXER_TAG:\r
 606                                 break;  /* Check the rest down there */\r
 607                         }\r
 608                 }\r
 609 \r
 610                 tcv = xer_check_tag(buf_ptr, ch_size, xml_tag);\r
 611                 ASN_DEBUG("XER/SET OF: tcv = %d, ph=%d t=%s",\r
 612                         tcv, ctx->phase, xml_tag);\r
 613                 switch(tcv) {\r
 614                 case XCT_CLOSING:\r
 615                         if(ctx->phase == 0) break;\r
 616                         ctx->phase = 0;\r
 617                         /* Fall through */\r
 618                 case XCT_BOTH:\r
 619                         if(ctx->phase == 0) {\r
 620                                 /* No more things to decode */\r
 621                                 XER_ADVANCE(ch_size);\r
 622                                 ctx->phase = 3; /* Phase out */\r
 623                                 RETURN(RC_OK);\r
 624                         }\r
 625                         /* Fall through */\r
 626                 case XCT_OPENING:\r
 627                         if(ctx->phase == 0) {\r
 628                                 XER_ADVANCE(ch_size);\r
 629                                 ctx->phase = 1; /* Processing body phase */\r
 630                                 continue;\r
 631                         }\r
 632                         /* Fall through */\r
 633                 case XCT_UNKNOWN_OP:\r
 634                 case XCT_UNKNOWN_BO:\r
 635 \r
 636                         ASN_DEBUG("XER/SET OF: tcv=%d, ph=%d", tcv, ctx->phase);\r
 637                         if(ctx->phase == 1) {\r
 638                                 /*\r
 639                                  * Process a single possible member.\r
 640                                  */\r
 641                                 ctx->phase = 2;\r
 642                                 continue;\r
 643                         }\r
 644                         /* Fall through */\r
 645                 default:\r
 646                         break;\r
 647                 }\r
 648 \r
 649                 ASN_DEBUG("Unexpected XML tag in SET OF");\r
 650                 break;\r
 651         }\r
 652 \r
 653         ctx->phase = 3; /* "Phase out" on hard failure */\r
 654         RETURN(RC_FAIL);\r
 655 }\r
 656 \r
 657 \r
 658 \r
 659 typedef struct xer_tmp_enc_s {\r
 660         void *buffer;\r
 661         size_t offset;\r
 662         size_t size;\r
 663 } xer_tmp_enc_t;\r
 664 static int\r
 665 SET_OF_encode_xer_callback(const void *buffer, size_t size, void *key) {\r
 666         xer_tmp_enc_t *t = (xer_tmp_enc_t *)key;\r
 667         if(t->offset + size >= t->size) {\r
 668                 size_t newsize = (t->size << 2) + size;\r
 669                 void *p = REALLOC(t->buffer, newsize);\r
 670                 if(!p) return -1;\r
 671                 t->buffer = p;\r
 672                 t->size = newsize;\r
 673         }\r
 674         memcpy((char *)t->buffer + t->offset, buffer, size);\r
 675         t->offset += size;\r
 676         return 0;\r
 677 }\r
 678 static int\r
 679 SET_OF_xer_order(const void *aptr, const void *bptr) {\r
 680         const xer_tmp_enc_t *a = (const xer_tmp_enc_t *)aptr;\r
 681         const xer_tmp_enc_t *b = (const xer_tmp_enc_t *)bptr;\r
 682         size_t minlen = a->offset;\r
 683         int ret;\r
 684         if(b->offset < minlen) minlen = b->offset;\r
 685         /* Well-formed UTF-8 has this nice lexicographical property... */\r
 686         ret = memcmp(a->buffer, b->buffer, minlen);\r
 687         if(ret != 0) return ret;\r
 688         if(a->offset == b->offset)\r
 689                 return 0;\r
 690         if(a->offset == minlen)\r
 691                 return -1;\r
 692         return 1;\r
 693 }\r
 694 \r
 695 \r
 696 asn_enc_rval_t\r
 697 SET_OF_encode_xer(const asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,\r
 698                   enum xer_encoder_flags_e flags, asn_app_consume_bytes_f *cb,\r
 699                   void *app_key) {\r
 700     asn_enc_rval_t er = {0,0,0};\r
 701         const asn_SET_OF_specifics_t *specs = (const asn_SET_OF_specifics_t *)td->specifics;\r
 702         const asn_TYPE_member_t *elm = td->elements;\r
 703     const asn_anonymous_set_ *list = _A_CSET_FROM_VOID(sptr);\r
 704     const char *mname = specs->as_XMLValueList\r
 705                 ? 0 : ((*elm->name) ? elm->name : elm->type->xml_tag);\r
 706         size_t mlen = mname ? strlen(mname) : 0;\r
 707         int xcan = (flags & XER_F_CANONICAL);\r
 708         xer_tmp_enc_t *encs = 0;\r
 709         size_t encs_count = 0;\r
 710         void *original_app_key = app_key;\r
 711         asn_app_consume_bytes_f *original_cb = cb;\r
 712         int i;\r
 713 \r
 714         if(!sptr) ASN__ENCODE_FAILED;\r
 715 \r
 716         if(xcan) {\r
 717                 encs = (xer_tmp_enc_t *)MALLOC(list->count * sizeof(encs[0]));\r
 718                 if(!encs) ASN__ENCODE_FAILED;\r
 719                 cb = SET_OF_encode_xer_callback;\r
 720         }\r
 721 \r
 722         er.encoded = 0;\r
 723 \r
 724         for(i = 0; i < list->count; i++) {\r
 725                 asn_enc_rval_t tmper = {0,0,0};\r
 726 \r
 727                 void *memb_ptr = list->array[i];\r
 728                 if(!memb_ptr) continue;\r
 729 \r
 730                 if(encs) {\r
 731                         memset(&encs[encs_count], 0, sizeof(encs[0]));\r
 732                         app_key = &encs[encs_count];\r
 733                         encs_count++;\r
 734                 }\r
 735 \r
 736                 if(mname) {\r
 737                         if(!xcan) ASN__TEXT_INDENT(1, ilevel);\r
 738                         ASN__CALLBACK3("<", 1, mname, mlen, ">", 1);\r
 739                 }\r
 740 \r
 741                 if(!xcan && specs->as_XMLValueList == 1)\r
 742                         ASN__TEXT_INDENT(1, ilevel + 1);\r
 743                 tmper = elm->type->op->xer_encoder(elm->type, memb_ptr,\r
 744                                 ilevel + (specs->as_XMLValueList != 2),\r
 745                                 flags, cb, app_key);\r
 746                 if(tmper.encoded == -1) return tmper;\r
 747                 er.encoded += tmper.encoded;\r
 748                 if(tmper.encoded == 0 && specs->as_XMLValueList) {\r
 749                         const char *name = elm->type->xml_tag;\r
 750                         size_t len = strlen(name);\r
 751                         ASN__CALLBACK3("<", 1, name, len, "/>", 2);\r
 752                 }\r
 753 \r
 754                 if(mname) {\r
 755                         ASN__CALLBACK3("</", 2, mname, mlen, ">", 1);\r
 756                 }\r
 757 \r
 758         }\r
 759 \r
 760         if(!xcan) ASN__TEXT_INDENT(1, ilevel - 1);\r
 761 \r
 762         if(encs) {\r
 763                 xer_tmp_enc_t *enc = encs;\r
 764                 xer_tmp_enc_t *end = encs + encs_count;\r
 765                 ssize_t control_size = 0;\r
 766 \r
 767                 er.encoded = 0;\r
 768                 cb = original_cb;\r
 769                 app_key = original_app_key;\r
 770                 qsort(encs, encs_count, sizeof(encs[0]), SET_OF_xer_order);\r
 771 \r
 772                 for(; enc < end; enc++) {\r
 773                         ASN__CALLBACK(enc->buffer, enc->offset);\r
 774                         FREEMEM(enc->buffer);\r
 775                         enc->buffer = 0;\r
 776                         control_size += enc->offset;\r
 777                 }\r
 778                 assert(control_size == er.encoded);\r
 779         }\r
 780 \r
 781         goto cleanup;\r
 782 cb_failed:\r
 783         ASN__ENCODE_FAILED;\r
 784 cleanup:\r
 785         if(encs) {\r
 786                 size_t n;\r
 787                 for(n = 0; n < encs_count; n++) {\r
 788                         FREEMEM(encs[n].buffer);\r
 789                 }\r
 790                 FREEMEM(encs);\r
 791         }\r
 792         ASN__ENCODED_OK(er);\r
 793 }\r
 794 \r
 795 int\r
 796 SET_OF_print(const asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,\r
 797              asn_app_consume_bytes_f *cb, void *app_key) {\r
 798     asn_TYPE_member_t *elm = td->elements;\r
 799         const asn_anonymous_set_ *list = _A_CSET_FROM_VOID(sptr);\r
 800         int ret;\r
 801         int i;\r
 802 \r
 803         if(!sptr) return (cb("<absent>", 8, app_key) < 0) ? -1 : 0;\r
 804 \r
 805         /* Dump preamble */\r
 806         if(cb(td->name, strlen(td->name), app_key) < 0\r
 807         || cb(" ::= {", 6, app_key) < 0)\r
 808                 return -1;\r
 809 \r
 810         for(i = 0; i < list->count; i++) {\r
 811                 const void *memb_ptr = list->array[i];\r
 812                 if(!memb_ptr) continue;\r
 813 \r
 814                 _i_INDENT(1);\r
 815 \r
 816                 ret = elm->type->op->print_struct(elm->type, memb_ptr,\r
 817                         ilevel + 1, cb, app_key);\r
 818                 if(ret) return ret;\r
 819         }\r
 820 \r
 821         ilevel--;\r
 822         _i_INDENT(1);\r
 823 \r
 824         return (cb("}", 1, app_key) < 0) ? -1 : 0;\r
 825 }\r
 826 \r
 827 void\r
 828 SET_OF_free(const asn_TYPE_descriptor_t *td, void *ptr,\r
 829             enum asn_struct_free_method method) {\r
 830     if(td && ptr) {\r
 831                 const asn_SET_OF_specifics_t *specs;\r
 832                 asn_TYPE_member_t *elm = td->elements;\r
 833                 asn_anonymous_set_ *list = _A_SET_FROM_VOID(ptr);\r
 834                 asn_struct_ctx_t *ctx;  /* Decoder context */\r
 835                 int i;\r
 836 \r
 837                 /*\r
 838                  * Could not use set_of_empty() because of (*free)\r
 839                  * incompatibility.\r
 840                  */\r
 841                 for(i = 0; i < list->count; i++) {\r
 842                         void *memb_ptr = list->array[i];\r
 843                         if(memb_ptr)\r
 844                         ASN_STRUCT_FREE(*elm->type, memb_ptr);\r
 845                 }\r
 846                 list->count = 0;        /* No meaningful elements left */\r
 847 \r
 848                 asn_set_empty(list);    /* Remove (list->array) */\r
 849 \r
 850                 specs = (const asn_SET_OF_specifics_t *)td->specifics;\r
 851                 ctx = (asn_struct_ctx_t *)((char *)ptr + specs->ctx_offset);\r
 852                 if(ctx->ptr) {\r
 853                         ASN_STRUCT_FREE(*elm->type, ctx->ptr);\r
 854                         ctx->ptr = 0;\r
 855                 }\r
 856 \r
 857         switch(method) {\r
 858         case ASFM_FREE_EVERYTHING:\r
 859             FREEMEM(ptr);\r
 860             break;\r
 861         case ASFM_FREE_UNDERLYING:\r
 862             break;\r
 863         case ASFM_FREE_UNDERLYING_AND_RESET:\r
 864             memset(ptr, 0, specs->struct_size);\r
 865             break;\r
 866         }\r
 867     }\r
 868 }\r
 869 \r
 870 int\r
 871 SET_OF_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,\r
 872                   asn_app_constraint_failed_f *ctfailcb, void *app_key) {\r
 873     const asn_TYPE_member_t *elm = td->elements;\r
 874         asn_constr_check_f *constr;\r
 875         const asn_anonymous_set_ *list = _A_CSET_FROM_VOID(sptr);\r
 876         int i;\r
 877 \r
 878         if(!sptr) {\r
 879                 ASN__CTFAIL(app_key, td, sptr,\r
 880                         "%s: value not given (%s:%d)",\r
 881                         td->name, __FILE__, __LINE__);\r
 882                 return -1;\r
 883         }\r
 884 \r
 885         constr = elm->encoding_constraints.general_constraints;\r
 886         if(!constr) constr = elm->type->encoding_constraints.general_constraints;\r
 887 \r
 888         /*\r
 889          * Iterate over the members of an array.\r
 890          * Validate each in turn, until one fails.\r
 891          */\r
 892         for(i = 0; i < list->count; i++) {\r
 893                 const void *memb_ptr = list->array[i];\r
 894                 int ret;\r
 895 \r
 896                 if(!memb_ptr) continue;\r
 897 \r
 898                 ret = constr(elm->type, memb_ptr, ctfailcb, app_key);\r
 899                 if(ret) return ret;\r
 900         }\r
 901 \r
 902         return 0;\r
 903 }\r
 904 \r
 905 #ifndef ASN_DISABLE_PER_SUPPORT\r
 906 \r
 907 asn_dec_rval_t\r
 908 SET_OF_decode_uper(const asn_codec_ctx_t *opt_codec_ctx,\r
 909                    const asn_TYPE_descriptor_t *td,\r
 910                    const asn_per_constraints_t *constraints, void **sptr,\r
 911                    asn_per_data_t *pd) {\r
 912     asn_dec_rval_t rv = {RC_OK, 0};\r
 913         const asn_SET_OF_specifics_t *specs = (const asn_SET_OF_specifics_t *)td->specifics;\r
 914     const asn_TYPE_member_t *elm = td->elements; /* Single one */\r
 915     void *st = *sptr;\r
 916         asn_anonymous_set_ *list;\r
 917         const asn_per_constraint_t *ct;\r
 918         int repeat = 0;\r
 919         ssize_t nelems;\r
 920 \r
 921         if(ASN__STACK_OVERFLOW_CHECK(opt_codec_ctx))\r
 922                 ASN__DECODE_FAILED;\r
 923 \r
 924         /*\r
 925          * Create the target structure if it is not present already.\r
 926          */\r
 927         if(!st) {\r
 928                 st = *sptr = CALLOC(1, specs->struct_size);\r
 929                 if(!st) ASN__DECODE_FAILED;\r
 930         }                                                                       \r
 931         list = _A_SET_FROM_VOID(st);\r
 932 \r
 933         /* Figure out which constraints to use */\r
 934         if(constraints) ct = &constraints->size;\r
 935         else if(td->encoding_constraints.per_constraints)\r
 936                 ct = &td->encoding_constraints.per_constraints->size;\r
 937         else ct = 0;\r
 938 \r
 939         if(ct && ct->flags & APC_EXTENSIBLE) {\r
 940                 int value = per_get_few_bits(pd, 1);\r
 941                 if(value < 0) ASN__DECODE_STARVED;\r
 942                 if(value) ct = 0;       /* Not restricted! */\r
 943         }\r
 944 \r
 945         if(ct && ct->effective_bits >= 0) {\r
 946                 /* X.691, #19.5: No length determinant */\r
 947                 nelems = per_get_few_bits(pd, ct->effective_bits);\r
 948                 ASN_DEBUG("Preparing to fetch %ld+%ld elements from %s",\r
 949                         (long)nelems, ct->lower_bound, td->name);\r
 950                 if(nelems < 0)  ASN__DECODE_STARVED;\r
 951                 nelems += ct->lower_bound;\r
 952         } else {\r
 953                 nelems = -1;\r
 954         }\r
 955 \r
 956         do {\r
 957                 int i;\r
 958                 if(nelems < 0) {\r
 959                         nelems = uper_get_length(pd, -1, 0, &repeat);\r
 960             ASN_DEBUG("Got to decode %" ASN_PRI_SSIZE " elements (eff %d)",\r
 961                       nelems, (int)(ct ? ct->effective_bits : -1));\r
 962             if(nelems < 0) ASN__DECODE_STARVED;\r
 963                 }\r
 964 \r
 965                 for(i = 0; i < nelems; i++) {\r
 966                         void *ptr = 0;\r
 967                         ASN_DEBUG("SET OF %s decoding", elm->type->name);\r
 968                         rv = elm->type->op->uper_decoder(opt_codec_ctx, elm->type,\r
 969                                 elm->encoding_constraints.per_constraints, &ptr, pd);\r
 970                         ASN_DEBUG("%s SET OF %s decoded %d, %p",\r
 971                                 td->name, elm->type->name, rv.code, ptr);\r
 972                         if(rv.code == RC_OK) {\r
 973                                 if(ASN_SET_ADD(list, ptr) == 0) {\r
 974                     if(rv.consumed == 0 && nelems > 200) {\r
 975                         /* Protect from SET OF NULL compression bombs. */\r
 976                         ASN__DECODE_FAILED;\r
 977                     }\r
 978                                         continue;\r
 979                 }\r
 980                                 ASN_DEBUG("Failed to add element into %s",\r
 981                                         td->name);\r
 982                                 /* Fall through */\r
 983                                 rv.code = RC_FAIL;\r
 984                         } else {\r
 985                                 ASN_DEBUG("Failed decoding %s of %s (SET OF)",\r
 986                                         elm->type->name, td->name);\r
 987                         }\r
 988                         if(ptr) ASN_STRUCT_FREE(*elm->type, ptr);\r
 989                         return rv;\r
 990                 }\r
 991 \r
 992                 nelems = -1;    /* Allow uper_get_length() */\r
 993         } while(repeat);\r
 994 \r
 995         ASN_DEBUG("Decoded %s as SET OF", td->name);\r
 996 \r
 997         rv.code = RC_OK;\r
 998         rv.consumed = 0;\r
 999         return rv;\r
1000 }\r
1001 \r
1002 asn_enc_rval_t\r
1003 SET_OF_encode_uper(const asn_TYPE_descriptor_t *td,\r
1004                    const asn_per_constraints_t *constraints, const void *sptr,\r
1005                    asn_per_outp_t *po) {\r
1006     const asn_anonymous_set_ *list;\r
1007     const asn_per_constraint_t *ct;\r
1008     const asn_TYPE_member_t *elm = td->elements;\r
1009     struct _el_buffer *encoded_els;\r
1010     asn_enc_rval_t er = {0,0,0};\r
1011     size_t encoded_edx;\r
1012 \r
1013     if(!sptr) ASN__ENCODE_FAILED;\r
1014 \r
1015     list = _A_CSET_FROM_VOID(sptr);\r
1016 \r
1017     er.encoded = 0;\r
1018 \r
1019     ASN_DEBUG("Encoding %s as SEQUENCE OF (%d)", td->name, list->count);\r
1020 \r
1021     if(constraints) ct = &constraints->size;\r
1022     else if(td->encoding_constraints.per_constraints)\r
1023         ct = &td->encoding_constraints.per_constraints->size;\r
1024     else ct = 0;\r
1025 \r
1026     /* If extensible constraint, check if size is in root */\r
1027     if(ct) {\r
1028         int not_in_root =\r
1029             (list->count < ct->lower_bound || list->count > ct->upper_bound);\r
1030         ASN_DEBUG("lb %ld ub %ld %s", ct->lower_bound, ct->upper_bound,\r
1031                   ct->flags & APC_EXTENSIBLE ? "ext" : "fix");\r
1032         if(ct->flags & APC_EXTENSIBLE) {\r
1033             /* Declare whether size is in extension root */\r
1034             if(per_put_few_bits(po, not_in_root, 1)) ASN__ENCODE_FAILED;\r
1035             if(not_in_root) ct = 0;\r
1036         } else if(not_in_root && ct->effective_bits >= 0) {\r
1037             ASN__ENCODE_FAILED;\r
1038         }\r
1039 \r
1040     }\r
1041 \r
1042     if(ct && ct->effective_bits >= 0) {\r
1043         /* X.691, #19.5: No length determinant */\r
1044         if(per_put_few_bits(po, list->count - ct->lower_bound,\r
1045                             ct->effective_bits))\r
1046             ASN__ENCODE_FAILED;\r
1047     } else if(list->count == 0) {\r
1048         /* When the list is empty add only the length determinant\r
1049          * X.691, #20.6 and #11.9.4.1\r
1050          */\r
1051         if (uper_put_length(po, 0, 0)) {\r
1052             ASN__ENCODE_FAILED;\r
1053         }\r
1054         ASN__ENCODED_OK(er);\r
1055     }\r
1056 \r
1057 \r
1058     /*\r
1059      * Canonical UPER #22.1 mandates dynamic sorting of the SET OF elements\r
1060      * according to their encodings. Build an array of the encoded elements.\r
1061      */\r
1062     encoded_els = SET_OF__encode_sorted(elm, list, SOES_CUPER);\r
1063 \r
1064     for(encoded_edx = 0; (ssize_t)encoded_edx < list->count;) {\r
1065         ssize_t may_encode;\r
1066         size_t edx;\r
1067         int need_eom = 0;\r
1068 \r
1069         if(ct && ct->effective_bits >= 0) {\r
1070             may_encode = list->count;\r
1071         } else {\r
1072             may_encode =\r
1073                 uper_put_length(po, list->count - encoded_edx, &need_eom);\r
1074             if(may_encode < 0) ASN__ENCODE_FAILED;\r
1075         }\r
1076 \r
1077         for(edx = encoded_edx; edx < encoded_edx + may_encode; edx++) {\r
1078             const struct _el_buffer *el = &encoded_els[edx];\r
1079             if(asn_put_many_bits(po, el->buf,\r
1080                                  (8 * el->length) - el->bits_unused) < 0) {\r
1081                 break;\r
1082             }\r
1083         }\r
1084 \r
1085         if(need_eom && uper_put_length(po, 0, 0))\r
1086             ASN__ENCODE_FAILED; /* End of Message length */\r
1087 \r
1088         encoded_edx += may_encode;\r
1089     }\r
1090 \r
1091     SET_OF__encode_sorted_free(encoded_els, list->count);\r
1092 \r
1093     if((ssize_t)encoded_edx == list->count) {\r
1094         ASN__ENCODED_OK(er);\r
1095     } else {\r
1096         ASN__ENCODE_FAILED;\r
1097     }\r
1098 }\r
1099 \r
1100 asn_dec_rval_t\r
1101 SET_OF_decode_aper(const asn_codec_ctx_t *opt_codec_ctx,\r
1102                    const asn_TYPE_descriptor_t *td,\r
1103                    const asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) {\r
1104         asn_dec_rval_t rv = {RC_OK, 0};\r
1105         const asn_SET_OF_specifics_t *specs = (const asn_SET_OF_specifics_t *)td->specifics;\r
1106         const asn_TYPE_member_t *elm = td->elements; /* Single one */\r
1107         void *st = *sptr;\r
1108         asn_anonymous_set_ *list;\r
1109         const asn_per_constraint_t *ct;\r
1110         int repeat = 0;\r
1111         ssize_t nelems;\r
1112 \r
1113         if(ASN__STACK_OVERFLOW_CHECK(opt_codec_ctx))\r
1114                 ASN__DECODE_FAILED;\r
1115 \r
1116         /*\r
1117          * Create the target structure if it is not present already.\r
1118          */\r
1119         if(!st) {\r
1120                 st = *sptr = CALLOC(1, specs->struct_size);\r
1121                 if(!st) ASN__DECODE_FAILED;\r
1122         }\r
1123         list = _A_SET_FROM_VOID(st);\r
1124 \r
1125         /* Figure out which constraints to use */\r
1126         if(constraints) ct = &constraints->size;\r
1127         else if(td->encoding_constraints.per_constraints)\r
1128                 ct = &td->encoding_constraints.per_constraints->size;\r
1129         else ct = 0;\r
1130 \r
1131         if(ct && ct->flags & APC_EXTENSIBLE) {\r
1132                 int value = per_get_few_bits(pd, 1);\r
1133                 if(value < 0) ASN__DECODE_STARVED;\r
1134                 if(value) ct = 0;       /* Not restricted! */\r
1135         }\r
1136 \r
1137         if(ct && ct->effective_bits >= 0) {\r
1138                 /* X.691, #19.5: No length determinant */\r
1139                 nelems = aper_get_nsnnwn(pd, ct->upper_bound - ct->lower_bound + 1);\r
1140                 ASN_DEBUG("Preparing to fetch %ld+%ld elements from %s",\r
1141                           (long)nelems, ct->lower_bound, td->name);\r
1142                 if(nelems < 0)  ASN__DECODE_STARVED;\r
1143                 nelems += ct->lower_bound;\r
1144         } else {\r
1145                 nelems = -1;\r
1146         }\r
1147 \r
1148         do {\r
1149                 int i;\r
1150                 if(nelems < 0) {\r
1151                         nelems = aper_get_length(pd, ct ? ct->upper_bound - ct->lower_bound + 1 : -1,\r
1152                                                  ct ? ct->effective_bits : -1, &repeat);\r
1153                         ASN_DEBUG("Got to decode %d elements (eff %d)",\r
1154                                   (int)nelems, (int)(ct ? ct->effective_bits : -1));\r
1155                         if(nelems < 0) ASN__DECODE_STARVED;\r
1156                 }\r
1157 \r
1158                 for(i = 0; i < nelems; i++) {\r
1159                         void *ptr = 0;\r
1160                         ASN_DEBUG("SET OF %s decoding", elm->type->name);\r
1161                         rv = elm->type->op->aper_decoder(opt_codec_ctx, elm->type,\r
1162                                                          elm->encoding_constraints.per_constraints, &ptr, pd);\r
1163                         ASN_DEBUG("%s SET OF %s decoded %d, %p",\r
1164                                   td->name, elm->type->name, rv.code, ptr);\r
1165                         if(rv.code == RC_OK) {\r
1166                                 if(ASN_SET_ADD(list, ptr) == 0)\r
1167                                         continue;\r
1168                                 ASN_DEBUG("Failed to add element into %s",\r
1169                                           td->name);\r
1170                                 /* Fall through */\r
1171                                 rv.code = RC_FAIL;\r
1172                         } else {\r
1173                                 ASN_DEBUG("Failed decoding %s of %s (SET OF)",\r
1174                                           elm->type->name, td->name);\r
1175                         }\r
1176                         if(ptr) ASN_STRUCT_FREE(*elm->type, ptr);\r
1177                         return rv;\r
1178                 }\r
1179 \r
1180                 nelems = -1;    /* Allow uper_get_length() */\r
1181         } while(repeat);\r
1182 \r
1183         ASN_DEBUG("Decoded %s as SET OF", td->name);\r
1184 \r
1185         rv.code = RC_OK;\r
1186         rv.consumed = 0;\r
1187         return rv;\r
1188 }\r
1189 \r
1190 #endif  /* ASN_DISABLE_PER_SUPPORT */\r
1191 \r
1192 struct comparable_ptr {\r
1193     const asn_TYPE_descriptor_t *td;\r
1194     const void *sptr;\r
1195 };\r
1196 \r
1197 static int\r
1198 SET_OF__compare_cb(const void *aptr, const void *bptr) {\r
1199     const struct comparable_ptr *a = aptr;\r
1200     const struct comparable_ptr *b = bptr;\r
1201     assert(a->td == b->td);\r
1202     return a->td->op->compare_struct(a->td, a->sptr, b->sptr);\r
1203 }\r
1204 \r
1205 int\r
1206 SET_OF_compare(const asn_TYPE_descriptor_t *td, const void *aptr,\r
1207                const void *bptr) {\r
1208     const asn_anonymous_set_ *a = _A_CSET_FROM_VOID(aptr);\r
1209     const asn_anonymous_set_ *b = _A_CSET_FROM_VOID(bptr);\r
1210 \r
1211     if(a && b) {\r
1212         struct comparable_ptr *asorted;\r
1213         struct comparable_ptr *bsorted;\r
1214         ssize_t common_length;\r
1215         ssize_t idx;\r
1216 \r
1217         if(a->count == 0) {\r
1218             if(b->count) return -1;\r
1219             return 0;\r
1220         } else if(b->count == 0) {\r
1221             return 1;\r
1222         }\r
1223 \r
1224         asorted = MALLOC(a->count * sizeof(asorted[0]));\r
1225         bsorted = MALLOC(b->count * sizeof(bsorted[0]));\r
1226         if(!asorted || !bsorted) {\r
1227             FREEMEM(asorted);\r
1228             FREEMEM(bsorted);\r
1229             return -1;\r
1230         }\r
1231 \r
1232         for(idx = 0; idx < a->count; idx++) {\r
1233             asorted[idx].td = td->elements->type;\r
1234             asorted[idx].sptr = a->array[idx];\r
1235         }\r
1236 \r
1237         for(idx = 0; idx < b->count; idx++) {\r
1238             bsorted[idx].td = td->elements->type;\r
1239             bsorted[idx].sptr = b->array[idx];\r
1240         }\r
1241 \r
1242         qsort(asorted, a->count, sizeof(asorted[0]), SET_OF__compare_cb);\r
1243         qsort(bsorted, b->count, sizeof(bsorted[0]), SET_OF__compare_cb);\r
1244 \r
1245         common_length = (a->count < b->count ? a->count : b->count);\r
1246         for(idx = 0; idx < common_length; idx++) {\r
1247             int ret = td->elements->type->op->compare_struct(\r
1248                 td->elements->type, asorted[idx].sptr, bsorted[idx].sptr);\r
1249             if(ret) {\r
1250                 FREEMEM(asorted);\r
1251                 FREEMEM(bsorted);\r
1252                 return ret;\r
1253             }\r
1254         }\r
1255 \r
1256         FREEMEM(asorted);\r
1257         FREEMEM(bsorted);\r
1258 \r
1259         if(idx < b->count) /* more elements in b */\r
1260             return -1;     /* a is shorter, so put it first */\r
1261         if(idx < a->count) return 1;\r
1262     } else if(!a) {\r
1263         return -1;\r
1264     } else if(!b) {\r
1265         return 1;\r
1266     }\r
1267 \r
1268         return 0;\r
1269 }\r
1270 \r
1271 \r
1272 asn_TYPE_operation_t asn_OP_SET_OF = {\r
1273         SET_OF_free,\r
1274         SET_OF_print,\r
1275         SET_OF_compare,\r
1276         SET_OF_decode_ber,\r
1277         SET_OF_encode_der,\r
1278         SET_OF_decode_xer,\r
1279         SET_OF_encode_xer,\r
1280 #ifdef ASN_DISABLE_OER_SUPPORT\r
1281         0,\r
1282         0,\r
1283 #else\r
1284         SET_OF_decode_oer,\r
1285         SET_OF_encode_oer,\r
1286 #endif\r
1287 #ifdef ASN_DISABLE_PER_SUPPORT\r
1288         0,\r
1289         0,\r
1290         0,\r
1291         0,\r
1292 #else\r
1293         SET_OF_decode_uper,\r
1294         SET_OF_encode_uper,\r
1295         SET_OF_decode_aper,\r
1296         0,      /* SET_OF_encode_aper */\r
1297 #endif /* ASN_DISABLE_PER_SUPPORT */\r
1298         SET_OF_random_fill,\r
1299         0       /* Use generic outmost tag fetcher */\r
1300 };\r
1301 \r
1302 \r
1303 asn_random_fill_result_t\r
1304 SET_OF_random_fill(const asn_TYPE_descriptor_t *td, void **sptr,\r
1305                    const asn_encoding_constraints_t *constraints,\r
1306                    size_t max_length) {\r
1307     const asn_SET_OF_specifics_t *specs =\r
1308         (const asn_SET_OF_specifics_t *)td->specifics;\r
1309     asn_random_fill_result_t res_ok = {ARFILL_OK, 0};\r
1310     asn_random_fill_result_t result_failed = {ARFILL_FAILED, 0};\r
1311     asn_random_fill_result_t result_skipped = {ARFILL_SKIPPED, 0};\r
1312     const asn_TYPE_member_t *elm = td->elements;\r
1313     void *st = *sptr;\r
1314     long max_elements = 5;\r
1315     long slb = 0;   /* Lower size bound */\r
1316     long sub = 0;   /* Upper size bound */\r
1317     size_t rnd_len;\r
1318 \r
1319     if(max_length == 0) return result_skipped;\r
1320 \r
1321     if(st == NULL) {\r
1322         st = (*sptr = CALLOC(1, specs->struct_size));\r
1323         if(st == NULL) {\r
1324             return result_failed;\r
1325         }\r
1326     }\r
1327 \r
1328     switch(asn_random_between(0, 6)) {\r
1329     case 0: max_elements = 0; break;\r
1330     case 1: max_elements = 1; break;\r
1331     case 2: max_elements = 5; break;\r
1332     case 3: max_elements = max_length; break;\r
1333     case 4: max_elements = max_length / 2; break;\r
1334     case 5: max_elements = max_length / 4; break;\r
1335     default: break;\r
1336     }\r
1337     sub = slb + max_elements;\r
1338 \r
1339     if(!constraints || !constraints->per_constraints)\r
1340         constraints = &td->encoding_constraints;\r
1341     if(constraints->per_constraints) {\r
1342         const asn_per_constraint_t *pc = &constraints->per_constraints->size;\r
1343         if(pc->flags & APC_SEMI_CONSTRAINED) {\r
1344             slb = pc->lower_bound;\r
1345             sub = pc->lower_bound + max_elements;\r
1346         } else if(pc->flags & APC_CONSTRAINED) {\r
1347             slb = pc->lower_bound;\r
1348             sub = pc->upper_bound;\r
1349             if(sub - slb > max_elements) sub = slb + max_elements;\r
1350         }\r
1351     }\r
1352 \r
1353     /* Bias towards edges of allowed space */\r
1354     switch(asn_random_between(-1, 4)) {\r
1355     default:\r
1356     case -1:\r
1357         /* Prepare lengths somewhat outside of constrained range. */\r
1358         if(constraints->per_constraints\r
1359            && (constraints->per_constraints->size.flags & APC_EXTENSIBLE)) {\r
1360             switch(asn_random_between(0, 5)) {\r
1361             default:\r
1362             case 0:\r
1363                 rnd_len = 0;\r
1364                 break;\r
1365             case 1:\r
1366                 if(slb > 0) {\r
1367                     rnd_len = slb - 1;\r
1368                 } else {\r
1369                     rnd_len = 0;\r
1370                 }\r
1371                 break;\r
1372             case 2:\r
1373                 rnd_len = asn_random_between(0, slb);\r
1374                 break;\r
1375             case 3:\r
1376                 if(sub < (ssize_t)max_length) {\r
1377                     rnd_len = sub + 1;\r
1378                 } else {\r
1379                     rnd_len = max_length;\r
1380                 }\r
1381                 break;\r
1382             case 4:\r
1383                 if(sub < (ssize_t)max_length) {\r
1384                     rnd_len = asn_random_between(sub + 1, max_length);\r
1385                 } else {\r
1386                     rnd_len = max_length;\r
1387                 }\r
1388                 break;\r
1389             case 5:\r
1390                 rnd_len = max_length;\r
1391                 break;\r
1392             }\r
1393             break;\r
1394         }\r
1395         /* Fall through */\r
1396     case 0:\r
1397         rnd_len = asn_random_between(slb, sub);\r
1398         break;\r
1399     case 1:\r
1400         if(slb < sub) {\r
1401             rnd_len = asn_random_between(slb + 1, sub);\r
1402             break;\r
1403         }\r
1404         /* Fall through */\r
1405     case 2:\r
1406         rnd_len = asn_random_between(slb, slb);\r
1407         break;\r
1408     case 3:\r
1409         if(slb < sub) {\r
1410             rnd_len = asn_random_between(slb, sub - 1);\r
1411             break;\r
1412         }\r
1413         /* Fall through */\r
1414     case 4:\r
1415         rnd_len = asn_random_between(sub, sub);\r
1416         break;\r
1417     }\r
1418 \r
1419     for(; rnd_len > 0; rnd_len--) {\r
1420         asn_anonymous_set_ *list = _A_SET_FROM_VOID(st);\r
1421         void *ptr = 0;\r
1422         asn_random_fill_result_t tmpres = elm->type->op->random_fill(\r
1423             elm->type, &ptr, &elm->encoding_constraints,\r
1424             (max_length > res_ok.length ? max_length - res_ok.length : 0)\r
1425                 / rnd_len);\r
1426         switch(tmpres.code) {\r
1427         case ARFILL_OK:\r
1428             ASN_SET_ADD(list, ptr);\r
1429             res_ok.length += tmpres.length;\r
1430             break;\r
1431         case ARFILL_SKIPPED:\r
1432             break;\r
1433         case ARFILL_FAILED:\r
1434             assert(ptr == 0);\r
1435             return tmpres;\r
1436         }\r
1437     }\r
1438 \r
1439     return res_ok;\r
1440 }\r
1441 \r