crypto/x509v3/v3_cpols.c

   1 /* v3_cpols.c */
   2 /* Written by Dr Stephen N Henson (shenson@bigfoot.com) for the OpenSSL
   3  * project 1999.
   4  */
   5 /* ====================================================================
   6  * Copyright (c) 1999 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 #include <stdio.h>
  60 #include "cryptlib.h"
  61 #include <openssl/conf.h>
  62 #include <openssl/asn1.h>
  63 #include <openssl/asn1_mac.h>
  64 #include <openssl/x509v3.h>
  65
  66 /* Certificate policies extension support: this one is a bit complex... */
  67
  68 static int i2r_certpol(X509V3_EXT_METHOD *method, STACK_OF(POLICYINFO) *pol, BIO *out, int indent);
  69 static STACK_OF(POLICYINFO) *r2i_certpol(X509V3_EXT_METHOD *method, X509V3_CTX *ctx, char *value);
  70 static void print_qualifiers(BIO *out, STACK_OF(POLICYQUALINFO) *quals, int indent);
  71 static void print_notice(BIO *out, USERNOTICE *notice, int indent);
  72 static POLICYINFO *policy_section(X509V3_CTX *ctx, STACK *polstrs);
  73 static POLICYQUALINFO *notice_section(X509V3_CTX *ctx, STACK *unot);
  74 static STACK *nref_nos(STACK *nos);
  75
  76 X509V3_EXT_METHOD v3_cpols = {
  77 NID_certificate_policies, 0,
  78 (X509V3_EXT_NEW)CERTIFICATEPOLICIES_new,
  79 CERTIFICATEPOLICIES_free,
  80 (X509V3_EXT_D2I)d2i_CERTIFICATEPOLICIES,
  81 i2d_CERTIFICATEPOLICIES,
  82 NULL, NULL,
  83 NULL, NULL,
  84 (X509V3_EXT_I2R)i2r_certpol,
  85 (X509V3_EXT_R2I)r2i_certpol,
  86 NULL
  87 };
  88
  89
  90 /*
  91  * ASN1err(ASN1_F_POLICYINFO_NEW,ERR_R_MALLOC_FAILURE);
  92  * ASN1err(ASN1_F_D2I_POLICYINFO,ERR_R_MALLOC_FAILURE);
  93  * ASN1err(ASN1_F_POLICYQUALINFO_NEW,ERR_R_MALLOC_FAILURE);
  94  * ASN1err(ASN1_F_D2I_POLICYQUALINFO,ERR_R_MALLOC_FAILURE);
  95  * ASN1err(ASN1_F_USERNOTICE_NEW,ERR_R_MALLOC_FAILURE);
  96  * ASN1err(ASN1_F_D2I_USERNOTICE,ERR_R_MALLOC_FAILURE);
  97  * ASN1err(ASN1_F_NOTICEREF_NEW,ERR_R_MALLOC_FAILURE);
  98  * ASN1err(ASN1_F_D2I_NOTICEREF,ERR_R_MALLOC_FAILURE);
  99  */
 100
 101 static STACK_OF(POLICYINFO) *r2i_certpol(X509V3_EXT_METHOD *method,
 102                 X509V3_CTX *ctx, char *value)
 103 {
 104         STACK_OF(POLICYINFO) *pols = NULL;
 105         char *pstr;
 106         POLICYINFO *pol;
 107         ASN1_OBJECT *pobj;
 108         STACK *vals;
 109         CONF_VALUE *cnf;
 110         int i;
 111         pols = sk_POLICYINFO_new_null();
 112         vals =  X509V3_parse_list(value);
 113         for(i = 0; i < sk_num(vals); i++) {
 114                 cnf = (CONF_VALUE *)sk_value(vals, i);
 115                 if(cnf->value || !cnf->name ) {
 116                         X509V3err(X509V3_F_R2I_CERTPOL,X509V3_R_INVALID_POLICY_IDENTIFIER);
 117                         X509V3_conf_err(cnf);
 118                         goto err;
 119                 }
 120                 pstr = cnf->name;
 121                 if(*pstr == '@') {
 122                         STACK *polsect;
 123                         polsect = X509V3_get_section(ctx, pstr + 1);
 124                         if(!polsect) {
 125                                 X509V3err(X509V3_F_R2I_CERTPOL,X509V3_R_INVALID_SECTION);
 126
 127                                 X509V3_conf_err(cnf);
 128                                 goto err;
 129                         }
 130                         pol = policy_section(ctx, polsect);
 131                         X509V3_section_free(ctx, polsect);
 132                         if(!pol) goto err;
 133                 } else {
 134                         if(!(pobj = OBJ_txt2obj(cnf->name, 0))) {
 135                                 X509V3err(X509V3_F_R2I_CERTPOL,X509V3_R_INVALID_OBJECT_IDENTIFIER);
 136                                 X509V3_conf_err(cnf);
 137                                 goto err;
 138                         }
 139                         pol = POLICYINFO_new();
 140                         pol->policyid = pobj;
 141                 }
 142                 sk_POLICYINFO_push(pols, pol);
 143         }
 144         sk_pop_free(vals, X509V3_conf_free);
 145         return pols;
 146         err:
 147         sk_POLICYINFO_pop_free(pols, POLICYINFO_free);
 148         return NULL;
 149 }
 150
 151 static POLICYINFO *policy_section(X509V3_CTX *ctx, STACK *polstrs)
 152 {
 153         int i;
 154         CONF_VALUE *cnf;
 155         POLICYINFO *pol;
 156         POLICYQUALINFO *qual;
 157         if(!(pol = POLICYINFO_new())) goto merr;
 158         for(i = 0; i < sk_num(polstrs); i++) {
 159                 cnf = (CONF_VALUE *)sk_value(polstrs, i);
 160                 if(!strcmp(cnf->name, "policyIdentifier")) {
 161                         ASN1_OBJECT *pobj;
 162                         if(!(pobj = OBJ_txt2obj(cnf->value, 0))) {
 163                                 X509V3err(X509V3_F_POLICY_SECTION,X509V3_R_INVALID_OBJECT_IDENTIFIER);
 164                                 X509V3_conf_err(cnf);
 165                                 goto err;
 166                         }
 167                         pol->policyid = pobj;
 168
 169                 } else if(!name_cmp(cnf->name, "CPS")) {
 170                         if(!pol->qualifiers) pol->qualifiers =
 171                                                  sk_POLICYQUALINFO_new_null();
 172                         if(!(qual = POLICYQUALINFO_new())) goto merr;
 173                         if(!sk_POLICYQUALINFO_push(pol->qualifiers, qual))
 174                                                                  goto merr;
 175                         qual->pqualid = OBJ_nid2obj(NID_id_qt_cps);
 176                         qual->d.cpsuri = ASN1_IA5STRING_new();
 177                         if(!ASN1_STRING_set(qual->d.cpsuri, cnf->value,
 178                                                  strlen(cnf->value))) goto merr;
 179                 } else if(!name_cmp(cnf->name, "userNotice")) {
 180                         STACK *unot;
 181                         if(*cnf->value != '@') {
 182                                 X509V3err(X509V3_F_POLICY_SECTION,X509V3_R_EXPECTED_A_SECTION_NAME);
 183                                 X509V3_conf_err(cnf);
 184                                 goto err;
 185                         }
 186                         unot = X509V3_get_section(ctx, cnf->value + 1);
 187                         if(!unot) {
 188                                 X509V3err(X509V3_F_POLICY_SECTION,X509V3_R_INVALID_SECTION);
 189
 190                                 X509V3_conf_err(cnf);
 191                                 goto err;
 192                         }
 193                         qual = notice_section(ctx, unot);
 194                         X509V3_section_free(ctx, unot);
 195                         if(!qual) goto err;
 196                         if(!sk_POLICYQUALINFO_push(pol->qualifiers, qual))
 197                                                                  goto merr;
 198                 } else {
 199                         X509V3err(X509V3_F_POLICY_SECTION,X509V3_R_INVALID_OPTION);
 200
 201                         X509V3_conf_err(cnf);
 202                         goto err;
 203                 }
 204         }
 205         if(!pol->policyid) {
 206                 X509V3err(X509V3_F_POLICY_SECTION,X509V3_R_NO_POLICY_IDENTIFIER);
 207                 goto err;
 208         }
 209
 210         return pol;
 211
 212         merr:
 213         X509V3err(X509V3_F_POLICY_SECTION,ERR_R_MALLOC_FAILURE);
 214
 215         err:
 216         POLICYINFO_free(pol);
 217         return NULL;
 218
 219
 220 }
 221
 222 static POLICYQUALINFO *notice_section(X509V3_CTX *ctx, STACK *unot)
 223 {
 224         int i;
 225         CONF_VALUE *cnf;
 226         USERNOTICE *not;
 227         POLICYQUALINFO *qual;
 228         if(!(qual = POLICYQUALINFO_new())) goto merr;
 229         qual->pqualid = OBJ_nid2obj(NID_id_qt_unotice);
 230         if(!(not = USERNOTICE_new())) goto merr;
 231         qual->d.usernotice = not;
 232         for(i = 0; i < sk_num(unot); i++) {
 233                 cnf = (CONF_VALUE *)sk_value(unot, i);
 234                 if(!strcmp(cnf->name, "explicitText")) {
 235                         not->exptext = ASN1_VISIBLESTRING_new();
 236                         if(!ASN1_STRING_set(not->exptext, cnf->value,
 237                                                  strlen(cnf->value))) goto merr;
 238                 } else if(!strcmp(cnf->name, "organization")) {
 239                         NOTICEREF *nref;
 240                         if(!not->noticeref) {
 241                                 if(!(nref = NOTICEREF_new())) goto merr;
 242                                 not->noticeref = nref;
 243                         } else nref = not->noticeref;
 244                         nref->organization = ASN1_VISIBLESTRING_new();
 245                         if(!ASN1_STRING_set(nref->organization, cnf->value,
 246                                                  strlen(cnf->value))) goto merr;
 247                 } else if(!strcmp(cnf->name, "noticeNumbers")) {
 248                         NOTICEREF *nref;
 249                         STACK *nos;
 250                         if(!not->noticeref) {
 251                                 if(!(nref = NOTICEREF_new())) goto merr;
 252                                 not->noticeref = nref;
 253                         } else nref = not->noticeref;
 254                         nos = X509V3_parse_list(cnf->value);
 255                         if(!nos || !sk_num(nos)) {
 256                                 X509V3err(X509V3_F_NOTICE_SECTION,X509V3_R_INVALID_NUMBERS);
 257                                 X509V3_conf_err(cnf);
 258                                 goto err;
 259                         }
 260                         nref->noticenos = nref_nos(nos);
 261                         sk_pop_free(nos, X509V3_conf_free);
 262                         if(!nref->noticenos) goto err;
 263                 } else {
 264                         X509V3err(X509V3_F_NOTICE_SECTION,X509V3_R_INVALID_OPTION);
 265
 266                         X509V3_conf_err(cnf);
 267                         goto err;
 268                 }
 269         }
 270
 271         if(not->noticeref &&
 272               (!not->noticeref->noticenos || !not->noticeref->organization)) {
 273                         X509V3err(X509V3_F_NOTICE_SECTION,X509V3_R_NEED_ORGANIZATION_AND_NUMBERS);
 274                         goto err;
 275         }
 276
 277         return qual;
 278
 279         merr:
 280         X509V3err(X509V3_F_NOTICE_SECTION,ERR_R_MALLOC_FAILURE);
 281
 282         err:
 283         POLICYQUALINFO_free(qual);
 284         return NULL;
 285 }
 286
 287 static STACK *nref_nos(STACK *nos)
 288 {
 289         STACK *nnums;
 290         CONF_VALUE *cnf;
 291         ASN1_INTEGER *aint;
 292         int i;
 293         if(!(nnums = sk_new_null())) goto merr;
 294         for(i = 0; i < sk_num(nos); i++) {
 295                 cnf = (CONF_VALUE *)sk_value(nos, i);
 296                 if(!(aint = s2i_ASN1_INTEGER(NULL, cnf->name))) {
 297                         X509V3err(X509V3_F_NREF_NOS,X509V3_R_INVALID_NUMBER);
 298                         goto err;
 299                 }
 300                 if(!sk_push(nnums, (char *)aint)) goto merr;
 301         }
 302         return nnums;
 303
 304         merr:
 305         X509V3err(X509V3_F_NOTICE_SECTION,ERR_R_MALLOC_FAILURE);
 306
 307         err:
 308         sk_pop_free(nnums, ASN1_STRING_free);
 309         return NULL;
 310 }
 311
 312
 313 static int i2r_certpol(X509V3_EXT_METHOD *method, STACK_OF(POLICYINFO) *pol,
 314                 BIO *out, int indent)
 315 {
 316         int i;
 317         POLICYINFO *pinfo;
 318         /* First print out the policy OIDs */
 319         for(i = 0; i < sk_POLICYINFO_num(pol); i++) {
 320                 pinfo = sk_POLICYINFO_value(pol, i);
 321                 BIO_printf(out, "%*sPolicy: ", indent, "");
 322                 i2a_ASN1_OBJECT(out, pinfo->policyid);
 323                 BIO_puts(out, "\n");
 324                 if(pinfo->qualifiers)
 325                          print_qualifiers(out, pinfo->qualifiers, indent + 2);
 326         }
 327         return 1;
 328 }
 329
 330
 331 int i2d_CERTIFICATEPOLICIES(STACK_OF(POLICYINFO) *a, unsigned char **pp)
 332 {
 333
 334 return i2d_ASN1_SET_OF_POLICYINFO(a, pp, i2d_POLICYINFO, V_ASN1_SEQUENCE,
 335                                                  V_ASN1_UNIVERSAL, IS_SEQUENCE);}
 336
 337 STACK_OF(POLICYINFO) *CERTIFICATEPOLICIES_new(void)
 338 {
 339         return sk_POLICYINFO_new_null();
 340 }
 341
 342 void CERTIFICATEPOLICIES_free(STACK_OF(POLICYINFO) *a)
 343 {
 344         sk_POLICYINFO_pop_free(a, POLICYINFO_free);
 345 }
 346
 347 STACK_OF(POLICYINFO) *d2i_CERTIFICATEPOLICIES(STACK_OF(POLICYINFO) **a,
 348                 unsigned char **pp,long length)
 349 {
 350 return d2i_ASN1_SET_OF_POLICYINFO(a, pp, length, d2i_POLICYINFO,
 351                          POLICYINFO_free, V_ASN1_SEQUENCE, V_ASN1_UNIVERSAL);
 352
 353 }
 354
 355 IMPLEMENT_STACK_OF(POLICYINFO)
 356 IMPLEMENT_ASN1_SET_OF(POLICYINFO)
 357
 358 int i2d_POLICYINFO(POLICYINFO *a, unsigned char **pp)
 359 {
 360         M_ASN1_I2D_vars(a);
 361
 362         M_ASN1_I2D_len (a->policyid, i2d_ASN1_OBJECT);
 363         M_ASN1_I2D_len_SEQUENCE_type(POLICYQUALINFO, a->qualifiers,
 364                                                          i2d_POLICYQUALINFO);
 365
 366         M_ASN1_I2D_seq_total();
 367
 368         M_ASN1_I2D_put (a->policyid, i2d_ASN1_OBJECT);
 369         M_ASN1_I2D_put_SEQUENCE_type(POLICYQUALINFO, a->qualifiers,
 370                                                          i2d_POLICYQUALINFO);
 371
 372         M_ASN1_I2D_finish();
 373 }
 374
 375 POLICYINFO *POLICYINFO_new(void)
 376 {
 377         POLICYINFO *ret=NULL;
 378         ASN1_CTX c;
 379         M_ASN1_New_Malloc(ret, POLICYINFO);
 380         ret->policyid = NULL;
 381         ret->qualifiers = NULL;
 382         return (ret);
 383         M_ASN1_New_Error(ASN1_F_POLICYINFO_NEW);
 384 }
 385
 386 POLICYINFO *d2i_POLICYINFO(POLICYINFO **a, unsigned char **pp,long length)
 387 {
 388         M_ASN1_D2I_vars(a,POLICYINFO *,POLICYINFO_new);
 389         M_ASN1_D2I_Init();
 390         M_ASN1_D2I_start_sequence();
 391         M_ASN1_D2I_get(ret->policyid, d2i_ASN1_OBJECT);
 392         if(!M_ASN1_D2I_end_sequence()) {
 393                 M_ASN1_D2I_get_seq_type (POLICYQUALINFO, ret->qualifiers,
 394                                  d2i_POLICYQUALINFO, POLICYQUALINFO_free);
 395         }
 396         M_ASN1_D2I_Finish(a, POLICYINFO_free, ASN1_F_D2I_POLICYINFO);
 397 }
 398
 399 void POLICYINFO_free(POLICYINFO *a)
 400 {
 401         if (a == NULL) return;
 402         ASN1_OBJECT_free(a->policyid);
 403         sk_POLICYQUALINFO_pop_free(a->qualifiers, POLICYQUALINFO_free);
 404         Free (a);
 405 }
 406
 407 static void print_qualifiers(BIO *out, STACK_OF(POLICYQUALINFO) *quals,
 408                 int indent)
 409 {
 410         POLICYQUALINFO *qualinfo;
 411         int i;
 412         for(i = 0; i < sk_POLICYQUALINFO_num(quals); i++) {
 413                 qualinfo = sk_POLICYQUALINFO_value(quals, i);
 414                 switch(OBJ_obj2nid(qualinfo->pqualid))
 415                 {
 416                         case NID_id_qt_cps:
 417                         BIO_printf(out, "%*sCPS: %s\n", indent, "",
 418                                                 qualinfo->d.cpsuri->data);
 419                         break;
 420
 421                         case NID_id_qt_unotice:
 422                         BIO_printf(out, "%*sUser Notice:\n", indent, "");
 423                         print_notice(out, qualinfo->d.usernotice, indent + 2);
 424                         break;
 425
 426                         default:
 427                         BIO_printf(out, "%*sUnknown Qualifier: ",
 428                                                          indent + 2, "");
 429
 430                         i2a_ASN1_OBJECT(out, qualinfo->pqualid);
 431                         BIO_puts(out, "\n");
 432                         break;
 433                 }
 434         }
 435 }
 436
 437 static void print_notice(BIO *out, USERNOTICE *notice, int indent)
 438 {
 439         int i;
 440         if(notice->noticeref) {
 441                 NOTICEREF *ref;
 442                 ref = notice->noticeref;
 443                 BIO_printf(out, "%*sOrganization: %s\n", indent, "",
 444                                                  ref->organization->data);
 445                 BIO_printf(out, "%*sNumber%s: ", indent, "",
 446                                  (sk_num(ref->noticenos) > 1) ? "s" : "");
 447                 for(i = 0; i < sk_num(ref->noticenos); i++) {
 448                         ASN1_INTEGER *num;
 449                         char *tmp;
 450                         num = (ASN1_INTEGER *)sk_value(ref->noticenos, i);
 451                         if(i) BIO_puts(out, ", ");
 452                         tmp = i2s_ASN1_INTEGER(NULL, num);
 453                         BIO_puts(out, tmp);
 454                         Free(tmp);
 455                 }
 456                 BIO_puts(out, "\n");
 457         }
 458         if(notice->exptext)
 459                 BIO_printf(out, "%*sExplicit Text: %s\n", indent, "",
 460                                                          notice->exptext->data);
 461 }
 462
 463
 464
 465 int i2d_POLICYQUALINFO(POLICYQUALINFO *a, unsigned char **pp)
 466 {
 467         M_ASN1_I2D_vars(a);
 468
 469         M_ASN1_I2D_len (a->pqualid, i2d_ASN1_OBJECT);
 470         switch(OBJ_obj2nid(a->pqualid)) {
 471                 case NID_id_qt_cps:
 472                 M_ASN1_I2D_len(a->d.cpsuri, i2d_ASN1_IA5STRING);
 473                 break;
 474
 475                 case NID_id_qt_unotice:
 476                 M_ASN1_I2D_len(a->d.usernotice, i2d_USERNOTICE);
 477                 break;
 478
 479                 default:
 480                 M_ASN1_I2D_len(a->d.other, i2d_ASN1_TYPE);
 481                 break;
 482         }
 483
 484         M_ASN1_I2D_seq_total();
 485
 486         M_ASN1_I2D_put (a->pqualid, i2d_ASN1_OBJECT);
 487         switch(OBJ_obj2nid(a->pqualid)) {
 488                 case NID_id_qt_cps:
 489                 M_ASN1_I2D_put(a->d.cpsuri, i2d_ASN1_IA5STRING);
 490                 break;
 491
 492                 case NID_id_qt_unotice:
 493                 M_ASN1_I2D_put(a->d.usernotice, i2d_USERNOTICE);
 494                 break;
 495
 496                 default:
 497                 M_ASN1_I2D_put(a->d.other, i2d_ASN1_TYPE);
 498                 break;
 499         }
 500
 501         M_ASN1_I2D_finish();
 502 }
 503
 504 POLICYQUALINFO *POLICYQUALINFO_new(void)
 505 {
 506         POLICYQUALINFO *ret=NULL;
 507         ASN1_CTX c;
 508         M_ASN1_New_Malloc(ret, POLICYQUALINFO);
 509         ret->pqualid = NULL;
 510         ret->d.other = NULL;
 511         return (ret);
 512         M_ASN1_New_Error(ASN1_F_POLICYQUALINFO_NEW);
 513 }
 514
 515 POLICYQUALINFO *d2i_POLICYQUALINFO(POLICYQUALINFO **a, unsigned char **pp,
 516                 long length)
 517 {
 518         M_ASN1_D2I_vars(a,POLICYQUALINFO *,POLICYQUALINFO_new);
 519         M_ASN1_D2I_Init();
 520         M_ASN1_D2I_start_sequence();
 521         M_ASN1_D2I_get (ret->pqualid, d2i_ASN1_OBJECT);
 522         switch(OBJ_obj2nid(ret->pqualid)) {
 523                 case NID_id_qt_cps:
 524                 M_ASN1_D2I_get(ret->d.cpsuri, d2i_ASN1_IA5STRING);
 525                 break;
 526
 527                 case NID_id_qt_unotice:
 528                 M_ASN1_D2I_get(ret->d.usernotice, d2i_USERNOTICE);
 529                 break;
 530
 531                 default:
 532                 M_ASN1_D2I_get(ret->d.other, d2i_ASN1_TYPE);
 533                 break;
 534         }
 535         M_ASN1_D2I_Finish(a, POLICYQUALINFO_free, ASN1_F_D2I_POLICYQUALINFO);
 536 }
 537
 538 void POLICYQUALINFO_free(POLICYQUALINFO *a)
 539 {
 540         if (a == NULL) return;
 541         switch(OBJ_obj2nid(a->pqualid)) {
 542                 case NID_id_qt_cps:
 543                 ASN1_IA5STRING_free(a->d.cpsuri);
 544                 break;
 545
 546                 case NID_id_qt_unotice:
 547                 USERNOTICE_free(a->d.usernotice);
 548                 break;
 549
 550                 default:
 551                 ASN1_TYPE_free(a->d.other);
 552                 break;
 553         }
 554
 555         ASN1_OBJECT_free(a->pqualid);
 556         Free (a);
 557 }
 558
 559 int i2d_USERNOTICE(USERNOTICE *a, unsigned char **pp)
 560 {
 561         M_ASN1_I2D_vars(a);
 562
 563         M_ASN1_I2D_len (a->noticeref, i2d_NOTICEREF);
 564         M_ASN1_I2D_len (a->exptext, i2d_DISPLAYTEXT);
 565
 566         M_ASN1_I2D_seq_total();
 567
 568         M_ASN1_I2D_put (a->noticeref, i2d_NOTICEREF);
 569         M_ASN1_I2D_put (a->exptext, i2d_DISPLAYTEXT);
 570
 571         M_ASN1_I2D_finish();
 572 }
 573
 574 USERNOTICE *USERNOTICE_new(void)
 575 {
 576         USERNOTICE *ret=NULL;
 577         ASN1_CTX c;
 578         M_ASN1_New_Malloc(ret, USERNOTICE);
 579         ret->noticeref = NULL;
 580         ret->exptext = NULL;
 581         return (ret);
 582         M_ASN1_New_Error(ASN1_F_USERNOTICE_NEW);
 583 }
 584
 585 USERNOTICE *d2i_USERNOTICE(USERNOTICE **a, unsigned char **pp,long length)
 586 {
 587         M_ASN1_D2I_vars(a,USERNOTICE *,USERNOTICE_new);
 588         M_ASN1_D2I_Init();
 589         M_ASN1_D2I_start_sequence();
 590         M_ASN1_D2I_get_opt(ret->noticeref, d2i_NOTICEREF, V_ASN1_SEQUENCE);
 591         if (!M_ASN1_D2I_end_sequence()) {
 592                 M_ASN1_D2I_get(ret->exptext, d2i_DISPLAYTEXT);
 593         }
 594         M_ASN1_D2I_Finish(a, USERNOTICE_free, ASN1_F_D2I_USERNOTICE);
 595 }
 596
 597 void USERNOTICE_free(USERNOTICE *a)
 598 {
 599         if (a == NULL) return;
 600         NOTICEREF_free(a->noticeref);
 601         DISPLAYTEXT_free(a->exptext);
 602         Free (a);
 603 }
 604
 605 int i2d_NOTICEREF(NOTICEREF *a, unsigned char **pp)
 606 {
 607         M_ASN1_I2D_vars(a);
 608
 609         M_ASN1_I2D_len (a->organization, i2d_DISPLAYTEXT);
 610         M_ASN1_I2D_len_SEQUENCE(a->noticenos, i2d_ASN1_INTEGER);
 611
 612         M_ASN1_I2D_seq_total();
 613
 614         M_ASN1_I2D_put (a->organization, i2d_DISPLAYTEXT);
 615         M_ASN1_I2D_put_SEQUENCE(a->noticenos, i2d_ASN1_INTEGER);
 616
 617         M_ASN1_I2D_finish();
 618 }
 619
 620 NOTICEREF *NOTICEREF_new(void)
 621 {
 622         NOTICEREF *ret=NULL;
 623         ASN1_CTX c;
 624         M_ASN1_New_Malloc(ret, NOTICEREF);
 625         ret->organization = NULL;
 626         ret->noticenos = NULL;
 627         return (ret);
 628         M_ASN1_New_Error(ASN1_F_NOTICEREF_NEW);
 629 }
 630
 631 NOTICEREF *d2i_NOTICEREF(NOTICEREF **a, unsigned char **pp,long length)
 632 {
 633         M_ASN1_D2I_vars(a,NOTICEREF *,NOTICEREF_new);
 634         M_ASN1_D2I_Init();
 635         M_ASN1_D2I_start_sequence();
 636         /* This is to cope with some broken encodings that use IA5STRING for
 637          * the organization field
 638          */
 639         M_ASN1_D2I_get_opt(ret->organization, d2i_ASN1_IA5STRING,
 640                                                          V_ASN1_IA5STRING);
 641         if(!ret->organization) {
 642                  M_ASN1_D2I_get(ret->organization, d2i_DISPLAYTEXT);
 643         }
 644         M_ASN1_D2I_get_seq(ret->noticenos, d2i_ASN1_INTEGER, ASN1_STRING_free);
 645         M_ASN1_D2I_Finish(a, NOTICEREF_free, ASN1_F_D2I_NOTICEREF);
 646 }
 647
 648 void NOTICEREF_free(NOTICEREF *a)
 649 {
 650         if (a == NULL) return;
 651         DISPLAYTEXT_free(a->organization);
 652         sk_pop_free(a->noticenos, ASN1_STRING_free);
 653         Free (a);
 654 }
 655
 656 IMPLEMENT_STACK_OF(POLICYQUALINFO)
 657 IMPLEMENT_ASN1_SET_OF(POLICYQUALINFO)