1/* tasn_enc.c */ 2/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL 3 * project 2000. 4 */ 5/* ==================================================================== 6 * Copyright (c) 2000-2004 The OpenSSL Project. All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in 17 * the documentation and/or other materials provided with the 18 * distribution. 19 * 20 * 3. All advertising materials mentioning features or use of this 21 * software must display the following acknowledgment: 22 * "This product includes software developed by the OpenSSL Project 23 * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)" 24 * 25 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to 26 * endorse or promote products derived from this software without 27 * prior written permission. For written permission, please contact 28 * licensing@OpenSSL.org. 29 * 30 * 5. Products derived from this software may not be called "OpenSSL" 31 * nor may "OpenSSL" appear in their names without prior written 32 * permission of the OpenSSL Project. 33 * 34 * 6. Redistributions of any form whatsoever must retain the following 35 * acknowledgment: 36 * "This product includes software developed by the OpenSSL Project 37 * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)" 38 * 39 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY 40 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 41 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 42 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR 43 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 44 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 45 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 46 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 47 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 48 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 49 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 50 * OF THE POSSIBILITY OF SUCH DAMAGE. 51 * ==================================================================== 52 * 53 * This product includes cryptographic software written by Eric Young 54 * (eay@cryptsoft.com). This product includes software written by Tim 55 * Hudson (tjh@cryptsoft.com). 56 * 57 */ 58 59 60#include <stddef.h> 61#include <string.h> 62#include "cryptlib.h" 63#include <openssl/asn1.h> 64#include <openssl/asn1t.h> 65#include <openssl/objects.h> 66 67static int asn1_i2d_ex_primitive(ASN1_VALUE **pval, unsigned char **out, 68 const ASN1_ITEM *it, 69 int tag, int aclass); 70static int asn1_set_seq_out(STACK_OF(ASN1_VALUE) *sk, unsigned char **out, 71 int skcontlen, const ASN1_ITEM *item, 72 int do_sort, int iclass); 73static int asn1_template_ex_i2d(ASN1_VALUE **pval, unsigned char **out, 74 const ASN1_TEMPLATE *tt, 75 int tag, int aclass); 76static int asn1_item_flags_i2d(ASN1_VALUE *val, unsigned char **out, 77 const ASN1_ITEM *it, int flags); 78 79/* Top level i2d equivalents: the 'ndef' variant instructs the encoder 80 * to use indefinite length constructed encoding, where appropriate 81 */ 82 83int ASN1_item_ndef_i2d(ASN1_VALUE *val, unsigned char **out, 84 const ASN1_ITEM *it) 85 { 86 return asn1_item_flags_i2d(val, out, it, ASN1_TFLG_NDEF); 87 } 88 89int ASN1_item_i2d(ASN1_VALUE *val, unsigned char **out, const ASN1_ITEM *it) 90 { 91 return asn1_item_flags_i2d(val, out, it, 0); 92 } 93 94/* Encode an ASN1 item, this is use by the 95 * standard 'i2d' function. 'out' points to 96 * a buffer to output the data to. 97 * 98 * The new i2d has one additional feature. If the output 99 * buffer is NULL (i.e. *out == NULL) then a buffer is 100 * allocated and populated with the encoding. 101 */ 102 103static int asn1_item_flags_i2d(ASN1_VALUE *val, unsigned char **out, 104 const ASN1_ITEM *it, int flags) 105 { 106 if (out && !*out) 107 { 108 unsigned char *p, *buf; 109 int len; 110 len = ASN1_item_ex_i2d(&val, NULL, it, -1, flags); 111 if (len <= 0) 112 return len; 113 buf = OPENSSL_malloc(len); 114 if (!buf) 115 return -1; 116 p = buf; 117 ASN1_item_ex_i2d(&val, &p, it, -1, flags); 118 *out = buf; 119 return len; 120 } 121 122 return ASN1_item_ex_i2d(&val, out, it, -1, flags); 123 } 124 125/* Encode an item, taking care of IMPLICIT tagging (if any). 126 * This function performs the normal item handling: it can be 127 * used in external types. 128 */ 129 130int ASN1_item_ex_i2d(ASN1_VALUE **pval, unsigned char **out, 131 const ASN1_ITEM *it, int tag, int aclass) 132 { 133 const ASN1_TEMPLATE *tt = NULL; 134 unsigned char *p = NULL; 135 int i, seqcontlen, seqlen, ndef = 1; 136 const ASN1_COMPAT_FUNCS *cf; 137 const ASN1_EXTERN_FUNCS *ef; 138 const ASN1_AUX *aux = it->funcs; 139 ASN1_aux_cb *asn1_cb = 0; 140 141 if ((it->itype != ASN1_ITYPE_PRIMITIVE) && !*pval) 142 return 0; 143 144 if (aux && aux->asn1_cb) 145 asn1_cb = aux->asn1_cb; 146 147 switch(it->itype) 148 { 149 150 case ASN1_ITYPE_PRIMITIVE: 151 if (it->templates) 152 return asn1_template_ex_i2d(pval, out, it->templates, 153 tag, aclass); 154 return asn1_i2d_ex_primitive(pval, out, it, tag, aclass); 155 break; 156 157 case ASN1_ITYPE_MSTRING: 158 return asn1_i2d_ex_primitive(pval, out, it, -1, aclass); 159 160 case ASN1_ITYPE_CHOICE: 161 if (asn1_cb && !asn1_cb(ASN1_OP_I2D_PRE, pval, it, NULL)) 162 return 0; 163 i = asn1_get_choice_selector(pval, it); 164 if ((i >= 0) && (i < it->tcount)) 165 { 166 ASN1_VALUE **pchval; 167 const ASN1_TEMPLATE *chtt; 168 chtt = it->templates + i; 169 pchval = asn1_get_field_ptr(pval, chtt); 170 return asn1_template_ex_i2d(pchval, out, chtt, 171 -1, aclass); 172 } 173 /* Fixme: error condition if selector out of range */ 174 if (asn1_cb && !asn1_cb(ASN1_OP_I2D_POST, pval, it, NULL)) 175 return 0; 176 break; 177 178 case ASN1_ITYPE_EXTERN: 179 /* If new style i2d it does all the work */ 180 ef = it->funcs; 181 return ef->asn1_ex_i2d(pval, out, it, tag, aclass); 182 183 case ASN1_ITYPE_COMPAT: 184 /* old style hackery... */ 185 cf = it->funcs; 186 if (out) 187 p = *out; 188 i = cf->asn1_i2d(*pval, out); 189 /* Fixup for IMPLICIT tag: note this messes up for tags > 30, 190 * but so did the old code. Tags > 30 are very rare anyway. 191 */ 192 if (out && (tag != -1)) 193 *p = aclass | tag | (*p & V_ASN1_CONSTRUCTED); 194 return i; 195 196 case ASN1_ITYPE_NDEF_SEQUENCE: 197 /* Use indefinite length constructed if requested */ 198 if (aclass & ASN1_TFLG_NDEF) ndef = 2; 199 /* fall through */ 200 201 case ASN1_ITYPE_SEQUENCE: 202 i = asn1_enc_restore(&seqcontlen, out, pval, it); 203 /* An error occurred */ 204 if (i < 0) 205 return 0; 206 /* We have a valid cached encoding... */ 207 if (i > 0) 208 return seqcontlen; 209 /* Otherwise carry on */ 210 seqcontlen = 0; 211 /* If no IMPLICIT tagging set to SEQUENCE, UNIVERSAL */ 212 if (tag == -1) 213 { 214 tag = V_ASN1_SEQUENCE; 215 /* Retain any other flags in aclass */ 216 aclass = (aclass & ~ASN1_TFLG_TAG_CLASS) 217 | V_ASN1_UNIVERSAL; 218 } 219 if (asn1_cb && !asn1_cb(ASN1_OP_I2D_PRE, pval, it, NULL)) 220 return 0; 221 /* First work out sequence content length */ 222 for (i = 0, tt = it->templates; i < it->tcount; tt++, i++) 223 { 224 const ASN1_TEMPLATE *seqtt; 225 ASN1_VALUE **pseqval; 226 seqtt = asn1_do_adb(pval, tt, 1); 227 if (!seqtt) 228 return 0; 229 pseqval = asn1_get_field_ptr(pval, seqtt); 230 /* FIXME: check for errors in enhanced version */ 231 seqcontlen += asn1_template_ex_i2d(pseqval, NULL, seqtt, 232 -1, aclass); 233 } 234 235 seqlen = ASN1_object_size(ndef, seqcontlen, tag); 236 if (!out) 237 return seqlen; 238 /* Output SEQUENCE header */ 239 ASN1_put_object(out, ndef, seqcontlen, tag, aclass); 240 for (i = 0, tt = it->templates; i < it->tcount; tt++, i++) 241 { 242 const ASN1_TEMPLATE *seqtt; 243 ASN1_VALUE **pseqval; 244 seqtt = asn1_do_adb(pval, tt, 1); 245 if (!seqtt) 246 return 0; 247 pseqval = asn1_get_field_ptr(pval, seqtt); 248 /* FIXME: check for errors in enhanced version */ 249 asn1_template_ex_i2d(pseqval, out, seqtt, -1, aclass); 250 } 251 if (ndef == 2) 252 ASN1_put_eoc(out); 253 if (asn1_cb && !asn1_cb(ASN1_OP_I2D_POST, pval, it, NULL)) 254 return 0; 255 return seqlen; 256 257 default: 258 return 0; 259 260 } 261 return 0; 262 } 263 264int ASN1_template_i2d(ASN1_VALUE **pval, unsigned char **out, 265 const ASN1_TEMPLATE *tt) 266 { 267 return asn1_template_ex_i2d(pval, out, tt, -1, 0); 268 } 269 270static int asn1_template_ex_i2d(ASN1_VALUE **pval, unsigned char **out, 271 const ASN1_TEMPLATE *tt, int tag, int iclass) 272 { 273 int i, ret, flags, ttag, tclass, ndef; 274 flags = tt->flags; 275 /* Work out tag and class to use: tagging may come 276 * either from the template or the arguments, not both 277 * because this would create ambiguity. Additionally 278 * the iclass argument may contain some additional flags 279 * which should be noted and passed down to other levels. 280 */ 281 if (flags & ASN1_TFLG_TAG_MASK) 282 { 283 /* Error if argument and template tagging */ 284 if (tag != -1) 285 /* FIXME: error code here */ 286 return -1; 287 /* Get tagging from template */ 288 ttag = tt->tag; 289 tclass = flags & ASN1_TFLG_TAG_CLASS; 290 } 291 else if (tag != -1) 292 { 293 /* No template tagging, get from arguments */ 294 ttag = tag; 295 tclass = iclass & ASN1_TFLG_TAG_CLASS; 296 } 297 else 298 { 299 ttag = -1; 300 tclass = 0; 301 } 302 /* 303 * Remove any class mask from iflag. 304 */ 305 iclass &= ~ASN1_TFLG_TAG_CLASS; 306 307 /* At this point 'ttag' contains the outer tag to use, 308 * 'tclass' is the class and iclass is any flags passed 309 * to this function. 310 */ 311 312 /* if template and arguments require ndef, use it */ 313 if ((flags & ASN1_TFLG_NDEF) && (iclass & ASN1_TFLG_NDEF)) 314 ndef = 2; 315 else ndef = 1; 316 317 if (flags & ASN1_TFLG_SK_MASK) 318 { 319 /* SET OF, SEQUENCE OF */ 320 STACK_OF(ASN1_VALUE) *sk = (STACK_OF(ASN1_VALUE) *)*pval; 321 int isset, sktag, skaclass; 322 int skcontlen, sklen; 323 ASN1_VALUE *skitem; 324 325 if (!*pval) 326 return 0; 327 328 if (flags & ASN1_TFLG_SET_OF) 329 { 330 isset = 1; 331 /* 2 means we reorder */ 332 if (flags & ASN1_TFLG_SEQUENCE_OF) 333 isset = 2; 334 } 335 else isset = 0; 336 337 /* Work out inner tag value: if EXPLICIT 338 * or no tagging use underlying type. 339 */ 340 if ((ttag != -1) && !(flags & ASN1_TFLG_EXPTAG)) 341 { 342 sktag = ttag; 343 skaclass = tclass; 344 } 345 else 346 { 347 skaclass = V_ASN1_UNIVERSAL; 348 if (isset) 349 sktag = V_ASN1_SET; 350 else sktag = V_ASN1_SEQUENCE; 351 } 352 353 /* Determine total length of items */ 354 skcontlen = 0; 355 for (i = 0; i < sk_ASN1_VALUE_num(sk); i++) 356 { 357 skitem = sk_ASN1_VALUE_value(sk, i); 358 skcontlen += ASN1_item_ex_i2d(&skitem, NULL, 359 ASN1_ITEM_ptr(tt->item), 360 -1, iclass); 361 } 362 sklen = ASN1_object_size(ndef, skcontlen, sktag); 363 /* If EXPLICIT need length of surrounding tag */ 364 if (flags & ASN1_TFLG_EXPTAG) 365 ret = ASN1_object_size(ndef, sklen, ttag); 366 else ret = sklen; 367 368 if (!out) 369 return ret; 370 371 /* Now encode this lot... */ 372 /* EXPLICIT tag */ 373 if (flags & ASN1_TFLG_EXPTAG) 374 ASN1_put_object(out, ndef, sklen, ttag, tclass); 375 /* SET or SEQUENCE and IMPLICIT tag */ 376 ASN1_put_object(out, ndef, skcontlen, sktag, skaclass); 377 /* And the stuff itself */ 378 asn1_set_seq_out(sk, out, skcontlen, ASN1_ITEM_ptr(tt->item), 379 isset, iclass); 380 if (ndef == 2) 381 { 382 ASN1_put_eoc(out); 383 if (flags & ASN1_TFLG_EXPTAG) 384 ASN1_put_eoc(out); 385 } 386 387 return ret; 388 } 389 390 if (flags & ASN1_TFLG_EXPTAG) 391 { 392 /* EXPLICIT tagging */ 393 /* Find length of tagged item */ 394 i = ASN1_item_ex_i2d(pval, NULL, ASN1_ITEM_ptr(tt->item), 395 -1, iclass); 396 if (!i) 397 return 0; 398 /* Find length of EXPLICIT tag */ 399 ret = ASN1_object_size(ndef, i, ttag); 400 if (out) 401 { 402 /* Output tag and item */ 403 ASN1_put_object(out, ndef, i, ttag, tclass); 404 ASN1_item_ex_i2d(pval, out, ASN1_ITEM_ptr(tt->item), 405 -1, iclass); 406 if (ndef == 2) 407 ASN1_put_eoc(out); 408 } 409 return ret; 410 } 411 412 /* Either normal or IMPLICIT tagging: combine class and flags */ 413 return ASN1_item_ex_i2d(pval, out, ASN1_ITEM_ptr(tt->item), 414 ttag, tclass | iclass); 415 416} 417 418/* Temporary structure used to hold DER encoding of items for SET OF */ 419 420typedef struct { 421 unsigned char *data; 422 int length; 423 ASN1_VALUE *field; 424} DER_ENC; 425 426static int der_cmp(const void *a, const void *b) 427 { 428 const DER_ENC *d1 = a, *d2 = b; 429 int cmplen, i; 430 cmplen = (d1->length < d2->length) ? d1->length : d2->length; 431 i = memcmp(d1->data, d2->data, cmplen); 432 if (i) 433 return i; 434 return d1->length - d2->length; 435 } 436 437/* Output the content octets of SET OF or SEQUENCE OF */ 438 439static int asn1_set_seq_out(STACK_OF(ASN1_VALUE) *sk, unsigned char **out, 440 int skcontlen, const ASN1_ITEM *item, 441 int do_sort, int iclass) 442 { 443 int i; 444 ASN1_VALUE *skitem; 445 unsigned char *tmpdat = NULL, *p = NULL; 446 DER_ENC *derlst = NULL, *tder; 447 if (do_sort) 448 { 449 /* Don't need to sort less than 2 items */ 450 if (sk_ASN1_VALUE_num(sk) < 2) 451 do_sort = 0; 452 else 453 { 454 derlst = OPENSSL_malloc(sk_ASN1_VALUE_num(sk) 455 * sizeof(*derlst)); 456 if (!derlst) 457 return 0; 458 tmpdat = OPENSSL_malloc(skcontlen); 459 if (!tmpdat) 460 { 461 OPENSSL_free(derlst); 462 return 0; 463 } 464 } 465 } 466 /* If not sorting just output each item */ 467 if (!do_sort) 468 { 469 for (i = 0; i < sk_ASN1_VALUE_num(sk); i++) 470 { 471 skitem = sk_ASN1_VALUE_value(sk, i); 472 ASN1_item_ex_i2d(&skitem, out, item, -1, iclass); 473 } 474 return 1; 475 } 476 p = tmpdat; 477 478 /* Doing sort: build up a list of each member's DER encoding */ 479 for (i = 0, tder = derlst; i < sk_ASN1_VALUE_num(sk); i++, tder++) 480 { 481 skitem = sk_ASN1_VALUE_value(sk, i); 482 tder->data = p; 483 tder->length = ASN1_item_ex_i2d(&skitem, &p, item, -1, iclass); 484 tder->field = skitem; 485 } 486 487 /* Now sort them */ 488 qsort(derlst, sk_ASN1_VALUE_num(sk), sizeof(*derlst), der_cmp); 489 /* Output sorted DER encoding */ 490 p = *out; 491 for (i = 0, tder = derlst; i < sk_ASN1_VALUE_num(sk); i++, tder++) 492 { 493 memcpy(p, tder->data, tder->length); 494 p += tder->length; 495 } 496 *out = p; 497 /* If do_sort is 2 then reorder the STACK */ 498 if (do_sort == 2) 499 { 500 for (i = 0, tder = derlst; i < sk_ASN1_VALUE_num(sk); 501 i++, tder++) 502 (void)sk_ASN1_VALUE_set(sk, i, tder->field); 503 } 504 OPENSSL_free(derlst); 505 OPENSSL_free(tmpdat); 506 return 1; 507 } 508 509static int asn1_i2d_ex_primitive(ASN1_VALUE **pval, unsigned char **out, 510 const ASN1_ITEM *it, int tag, int aclass) 511 { 512 int len; 513 int utype; 514 int usetag; 515 int ndef = 0; 516 517 utype = it->utype; 518 519 /* Get length of content octets and maybe find 520 * out the underlying type. 521 */ 522 523 len = asn1_ex_i2c(pval, NULL, &utype, it); 524 525 /* If SEQUENCE, SET or OTHER then header is 526 * included in pseudo content octets so don't 527 * include tag+length. We need to check here 528 * because the call to asn1_ex_i2c() could change 529 * utype. 530 */ 531 if ((utype == V_ASN1_SEQUENCE) || (utype == V_ASN1_SET) || 532 (utype == V_ASN1_OTHER)) 533 usetag = 0; 534 else usetag = 1; 535 536 /* -1 means omit type */ 537 538 if (len == -1) 539 return 0; 540 541 /* -2 return is special meaning use ndef */ 542 if (len == -2) 543 { 544 ndef = 2; 545 len = 0; 546 } 547 548 /* If not implicitly tagged get tag from underlying type */ 549 if (tag == -1) tag = utype; 550 551 /* Output tag+length followed by content octets */ 552 if (out) 553 { 554 if (usetag) 555 ASN1_put_object(out, ndef, len, tag, aclass); 556 asn1_ex_i2c(pval, *out, &utype, it); 557 if (ndef) 558 ASN1_put_eoc(out); 559 else 560 *out += len; 561 } 562 563 if (usetag) 564 return ASN1_object_size(ndef, len, tag); 565 return len; 566 } 567 568/* Produce content octets from a structure */ 569 570int asn1_ex_i2c(ASN1_VALUE **pval, unsigned char *cout, int *putype, 571 const ASN1_ITEM *it) 572 { 573 ASN1_BOOLEAN *tbool = NULL; 574 ASN1_STRING *strtmp; 575 ASN1_OBJECT *otmp; 576 int utype; 577 const unsigned char *cont; 578 unsigned char c; 579 int len; 580 const ASN1_PRIMITIVE_FUNCS *pf; 581 pf = it->funcs; 582 if (pf && pf->prim_i2c) 583 return pf->prim_i2c(pval, cout, putype, it); 584 585 /* Should type be omitted? */ 586 if ((it->itype != ASN1_ITYPE_PRIMITIVE) 587 || (it->utype != V_ASN1_BOOLEAN)) 588 { 589 if (!*pval) return -1; 590 } 591 592 if (it->itype == ASN1_ITYPE_MSTRING) 593 { 594 /* If MSTRING type set the underlying type */ 595 strtmp = (ASN1_STRING *)*pval; 596 utype = strtmp->type; 597 *putype = utype; 598 } 599 else if (it->utype == V_ASN1_ANY) 600 { 601 /* If ANY set type and pointer to value */ 602 ASN1_TYPE *typ; 603 typ = (ASN1_TYPE *)*pval; 604 utype = typ->type; 605 *putype = utype; 606 pval = &typ->value.asn1_value; 607 } 608 else utype = *putype; 609 610 switch(utype) 611 { 612 case V_ASN1_OBJECT: 613 otmp = (ASN1_OBJECT *)*pval; 614 cont = otmp->data; 615 len = otmp->length; 616 break; 617 618 case V_ASN1_NULL: 619 cont = NULL; 620 len = 0; 621 break; 622 623 case V_ASN1_BOOLEAN: 624 tbool = (ASN1_BOOLEAN *)pval; 625 if (*tbool == -1) 626 return -1; 627 if (it->utype != V_ASN1_ANY) 628 { 629 /* Default handling if value == size field then omit */ 630 if (*tbool && (it->size > 0)) 631 return -1; 632 if (!*tbool && !it->size) 633 return -1; 634 } 635 c = (unsigned char)*tbool; 636 cont = &c; 637 len = 1; 638 break; 639 640 case V_ASN1_BIT_STRING: 641 return i2c_ASN1_BIT_STRING((ASN1_BIT_STRING *)*pval, 642 cout ? &cout : NULL); 643 break; 644 645 case V_ASN1_INTEGER: 646 case V_ASN1_NEG_INTEGER: 647 case V_ASN1_ENUMERATED: 648 case V_ASN1_NEG_ENUMERATED: 649 /* These are all have the same content format 650 * as ASN1_INTEGER 651 */ 652 return i2c_ASN1_INTEGER((ASN1_INTEGER *)*pval, 653 cout ? &cout : NULL); 654 break; 655 656 case V_ASN1_OCTET_STRING: 657 case V_ASN1_NUMERICSTRING: 658 case V_ASN1_PRINTABLESTRING: 659 case V_ASN1_T61STRING: 660 case V_ASN1_VIDEOTEXSTRING: 661 case V_ASN1_IA5STRING: 662 case V_ASN1_UTCTIME: 663 case V_ASN1_GENERALIZEDTIME: 664 case V_ASN1_GRAPHICSTRING: 665 case V_ASN1_VISIBLESTRING: 666 case V_ASN1_GENERALSTRING: 667 case V_ASN1_UNIVERSALSTRING: 668 case V_ASN1_BMPSTRING: 669 case V_ASN1_UTF8STRING: 670 case V_ASN1_SEQUENCE: 671 case V_ASN1_SET: 672 default: 673 /* All based on ASN1_STRING and handled the same */ 674 strtmp = (ASN1_STRING *)*pval; 675 /* Special handling for NDEF */ 676 if ((it->size == ASN1_TFLG_NDEF) 677 && (strtmp->flags & ASN1_STRING_FLAG_NDEF)) 678 { 679 if (cout) 680 { 681 strtmp->data = cout; 682 strtmp->length = 0; 683 } 684 /* Special return code */ 685 return -2; 686 } 687 cont = strtmp->data; 688 len = strtmp->length; 689 690 break; 691 692 } 693 if (cout && len) 694 memcpy(cout, cont, len); 695 return len; 696 } 697