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 "conf.h"
  62 #include "asn1.h"
  63 #include "asn1_mac.h"
  64 #include "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         err:
 213         POLICYINFO_free(pol);
 214         return NULL;
 215
 216         merr:
 217         X509V3err(X509V3_F_POLICY_SECTION,ERR_R_MALLOC_FAILURE);
 218         POLICYINFO_free(pol);
 219         return NULL;
 220
 221 }
 222
 223 static POLICYQUALINFO *notice_section(X509V3_CTX *ctx, STACK *unot)
 224 {
 225         int i;
 226         CONF_VALUE *cnf;
 227         USERNOTICE *not;
 228         POLICYQUALINFO *qual;
 229         if(!(qual = POLICYQUALINFO_new())) goto merr;
 230         qual->pqualid = OBJ_nid2obj(NID_id_qt_unotice);
 231         if(!(not = USERNOTICE_new())) goto merr;
 232         qual->d.usernotice = not;
 233         for(i = 0; i < sk_num(unot); i++) {
 234                 cnf = (CONF_VALUE *)sk_value(unot, i);
 235                 if(!strcmp(cnf->name, "explicitText")) {
 236                         not->exptext = ASN1_VISIBLESTRING_new();
 237                         if(!ASN1_STRING_set(not->exptext, cnf->value,
 238                                                  strlen(cnf->value))) goto merr;
 239                 } else if(!strcmp(cnf->name, "organization")) {
 240                         NOTICEREF *nref;
 241                         if(!not->noticeref) {
 242                                 if(!(nref = NOTICEREF_new())) goto merr;
 243                                 not->noticeref = nref;
 244                         } else nref = not->noticeref;
 245                         nref->organization = ASN1_VISIBLESTRING_new();
 246                         if(!ASN1_STRING_set(nref->organization, cnf->value,
 247                                                  strlen(cnf->value))) goto merr;
 248                 } else if(!strcmp(cnf->name, "noticeNumbers")) {
 249                         NOTICEREF *nref;
 250                         STACK *nos;
 251                         if(!not->noticeref) {
 252                                 if(!(nref = NOTICEREF_new())) goto merr;
 253                                 not->noticeref = nref;
 254                         } else nref = not->noticeref;
 255                         nos = X509V3_parse_list(cnf->value);
 256                         if(!nos || !sk_num(nos)) {
 257                                 X509V3err(X509V3_F_NOTICE_SECTION,X509V3_R_INVALID_NUMBERS);
 258                                 X509V3_conf_err(cnf);
 259                                 goto err;
 260                         }
 261                         nref->noticenos = nref_nos(nos);
 262                         sk_pop_free(nos, X509V3_conf_free);
 263                         if(!nref->noticenos) goto err;
 264                 } else {
 265                         X509V3err(X509V3_F_NOTICE_SECTION,X509V3_R_INVALID_OPTION);
 266
 267                         X509V3_conf_err(cnf);
 268                         goto err;
 269                 }
 270         }
 271
 272         if(not->noticeref &&
 273               (!not->noticeref->noticenos || !not->noticeref->organization)) {
 274                         X509V3err(X509V3_F_NOTICE_SECTION,X509V3_R_NEED_ORGANIZATION_AND_NUMBERS);
 275                         goto err;
 276         }
 277
 278         return qual;
 279
 280         err:
 281         POLICYQUALINFO_free(qual);
 282         return NULL;
 283
 284         merr:
 285         X509V3err(X509V3_F_NOTICE_SECTION,ERR_R_MALLOC_FAILURE);
 286         POLICYQUALINFO_free(qual);
 287         return NULL;
 288 }
 289
 290 static STACK *nref_nos(STACK *nos)
 291 {
 292         STACK *nnums;
 293         CONF_VALUE *cnf;
 294         ASN1_INTEGER *aint;
 295         int i;
 296         if(!(nnums = sk_new_null())) goto merr;
 297         for(i = 0; i < sk_num(nos); i++) {
 298                 cnf = (CONF_VALUE *)sk_value(nos, i);
 299                 if(!(aint = s2i_ASN1_INTEGER(NULL, cnf->name))) {
 300                         X509V3err(X509V3_F_NREF_NOS,X509V3_R_INVALID_NUMBER);
 301                         goto err;
 302                 }
 303                 if(!sk_push(nnums, (char *)aint)) goto merr;
 304         }
 305         return nnums;
 306
 307         err:
 308         sk_pop_free(nnums, ASN1_STRING_free);
 309         return NULL;
 310
 311         merr:
 312         X509V3err(X509V3_F_NOTICE_SECTION,ERR_R_MALLOC_FAILURE);
 313         sk_pop_free(nnums, ASN1_STRING_free);
 314         return NULL;
 315 }
 316
 317
 318 static int i2r_certpol(X509V3_EXT_METHOD *method, STACK_OF(POLICYINFO) *pol,
 319                 BIO *out, int indent)
 320 {
 321         int i;
 322         POLICYINFO *pinfo;
 323         /* First print out the policy OIDs */
 324         for(i = 0; i < sk_POLICYINFO_num(pol); i++) {
 325                 pinfo = sk_POLICYINFO_value(pol, i);
 326                 BIO_printf(out, "%*sPolicy: ", indent, "");
 327                 i2a_ASN1_OBJECT(out, pinfo->policyid);
 328                 BIO_puts(out, "\n");
 329                 if(pinfo->qualifiers)
 330                          print_qualifiers(out, pinfo->qualifiers, indent + 2);
 331         }
 332         return 1;
 333 }
 334
 335
 336 int i2d_CERTIFICATEPOLICIES(STACK_OF(POLICYINFO) *a, unsigned char **pp)
 337 {
 338
 339 return i2d_ASN1_SET_OF_POLICYINFO(a, pp, i2d_POLICYINFO, V_ASN1_SEQUENCE,
 340                                                  V_ASN1_UNIVERSAL, IS_SEQUENCE);}
 341
 342 STACK_OF(POLICYINFO) *CERTIFICATEPOLICIES_new(void)
 343 {
 344         return sk_POLICYINFO_new_null();
 345 }
 346
 347 void CERTIFICATEPOLICIES_free(STACK_OF(POLICYINFO) *a)
 348 {
 349         sk_POLICYINFO_pop_free(a, POLICYINFO_free);
 350 }
 351
 352 STACK_OF(POLICYINFO) *d2i_CERTIFICATEPOLICIES(STACK_OF(POLICYINFO) **a,
 353                 unsigned char **pp,long length)
 354 {
 355 return d2i_ASN1_SET_OF_POLICYINFO(a, pp, length, d2i_POLICYINFO,
 356                          POLICYINFO_free, V_ASN1_SEQUENCE, V_ASN1_UNIVERSAL);
 357
 358 }
 359
 360 IMPLEMENT_STACK_OF(POLICYINFO)
 361 IMPLEMENT_ASN1_SET_OF(POLICYINFO)
 362
 363 int i2d_POLICYINFO(POLICYINFO *a, unsigned char **pp)
 364 {
 365         M_ASN1_I2D_vars(a);
 366
 367         M_ASN1_I2D_len (a->policyid, i2d_ASN1_OBJECT);
 368         M_ASN1_I2D_len_SEQUENCE_type(POLICYQUALINFO, a->qualifiers,
 369                                                          i2d_POLICYQUALINFO);
 370
 371         M_ASN1_I2D_seq_total();
 372
 373         M_ASN1_I2D_put (a->policyid, i2d_ASN1_OBJECT);
 374         M_ASN1_I2D_put_SEQUENCE_type(POLICYQUALINFO, a->qualifiers,
 375                                                          i2d_POLICYQUALINFO);
 376
 377         M_ASN1_I2D_finish();
 378 }
 379
 380 POLICYINFO *POLICYINFO_new(void)
 381 {
 382         POLICYINFO *ret=NULL;
 383         ASN1_CTX c;
 384         M_ASN1_New_Malloc(ret, POLICYINFO);
 385         ret->policyid = NULL;
 386         ret->qualifiers = NULL;
 387         return (ret);
 388         M_ASN1_New_Error(ASN1_F_POLICYINFO_NEW);
 389 }
 390
 391 POLICYINFO *d2i_POLICYINFO(POLICYINFO **a, unsigned char **pp,long length)
 392 {
 393         M_ASN1_D2I_vars(a,POLICYINFO *,POLICYINFO_new);
 394         M_ASN1_D2I_Init();
 395         M_ASN1_D2I_start_sequence();
 396         M_ASN1_D2I_get(ret->policyid, d2i_ASN1_OBJECT);
 397         if(!M_ASN1_D2I_end_sequence()) {
 398                 M_ASN1_D2I_get_seq_type (POLICYQUALINFO, ret->qualifiers,
 399                                  d2i_POLICYQUALINFO, POLICYQUALINFO_free);
 400         }
 401         M_ASN1_D2I_Finish(a, POLICYINFO_free, ASN1_F_D2I_POLICYINFO);
 402 }
 403
 404 void POLICYINFO_free(POLICYINFO *a)
 405 {
 406         if (a == NULL) return;
 407         ASN1_OBJECT_free(a->policyid);
 408         sk_POLICYQUALINFO_pop_free(a->qualifiers, POLICYQUALINFO_free);
 409         Free (a);
 410 }
 411
 412 static void print_qualifiers(BIO *out, STACK_OF(POLICYQUALINFO) *quals,
 413                 int indent)
 414 {
 415         POLICYQUALINFO *qualinfo;
 416         int i;
 417         for(i = 0; i < sk_POLICYQUALINFO_num(quals); i++) {
 418                 qualinfo = sk_POLICYQUALINFO_value(quals, i);
 419                 switch(OBJ_obj2nid(qualinfo->pqualid))
 420                 {
 421                         case NID_id_qt_cps:
 422                         BIO_printf(out, "%*sCPS: %s\n", indent, "",
 423                                                 qualinfo->d.cpsuri->data);
 424                         break;
 425
 426                         case NID_id_qt_unotice:
 427                         BIO_printf(out, "%*sUser Notice:\n", indent, "");
 428                         print_notice(out, qualinfo->d.usernotice, indent + 2);
 429                         break;
 430
 431                         default:
 432                         BIO_printf(out, "%*sUnknown Qualifier: ",
 433                                                          indent + 2, "");
 434
 435                         i2a_ASN1_OBJECT(out, qualinfo->pqualid);
 436                         BIO_puts(out, "\n");
 437                         break;
 438                 }
 439         }
 440 }
 441
 442 static void print_notice(BIO *out, USERNOTICE *notice, int indent)
 443 {
 444         int i;
 445         if(notice->noticeref) {
 446                 NOTICEREF *ref;
 447                 ref = notice->noticeref;
 448                 BIO_printf(out, "%*sOrganization: %s\n", indent, "",
 449                                                  ref->organization->data);
 450                 BIO_printf(out, "%*sNumber%s: ", indent, "",
 451                                  (sk_num(ref->noticenos) > 1) ? "s" : "");
 452                 for(i = 0; i < sk_num(ref->noticenos); i++) {
 453                         ASN1_INTEGER *num;
 454                         char *tmp;
 455                         num = (ASN1_INTEGER *)sk_value(ref->noticenos, i);
 456                         if(i) BIO_puts(out, ", ");
 457                         tmp = i2s_ASN1_INTEGER(NULL, num);
 458                         BIO_puts(out, tmp);
 459                         Free(tmp);
 460                 }
 461                 BIO_puts(out, "\n");
 462         }
 463         if(notice->exptext)
 464                 BIO_printf(out, "%*sExplicit Text: %s\n", indent, "",
 465                                                          notice->exptext->data);
 466 }
 467
 468
 469
 470 int i2d_POLICYQUALINFO(POLICYQUALINFO *a, unsigned char **pp)
 471 {
 472         M_ASN1_I2D_vars(a);
 473
 474         M_ASN1_I2D_len (a->pqualid, i2d_ASN1_OBJECT);
 475         switch(OBJ_obj2nid(a->pqualid)) {
 476                 case NID_id_qt_cps:
 477                 M_ASN1_I2D_len(a->d.cpsuri, i2d_ASN1_IA5STRING);
 478                 break;
 479
 480                 case NID_id_qt_unotice:
 481                 M_ASN1_I2D_len(a->d.usernotice, i2d_USERNOTICE);
 482                 break;
 483
 484                 default:
 485                 M_ASN1_I2D_len(a->d.other, i2d_ASN1_TYPE);
 486                 break;
 487         }
 488
 489         M_ASN1_I2D_seq_total();
 490
 491         M_ASN1_I2D_put (a->pqualid, i2d_ASN1_OBJECT);
 492         switch(OBJ_obj2nid(a->pqualid)) {
 493                 case NID_id_qt_cps:
 494                 M_ASN1_I2D_put(a->d.cpsuri, i2d_ASN1_IA5STRING);
 495                 break;
 496
 497                 case NID_id_qt_unotice:
 498                 M_ASN1_I2D_put(a->d.usernotice, i2d_USERNOTICE);
 499                 break;
 500
 501                 default:
 502                 M_ASN1_I2D_put(a->d.other, i2d_ASN1_TYPE);
 503                 break;
 504         }
 505
 506         M_ASN1_I2D_finish();
 507 }
 508
 509 POLICYQUALINFO *POLICYQUALINFO_new(void)
 510 {
 511         POLICYQUALINFO *ret=NULL;
 512         ASN1_CTX c;
 513         M_ASN1_New_Malloc(ret, POLICYQUALINFO);
 514         ret->pqualid = NULL;
 515         ret->d.other = NULL;
 516         return (ret);
 517         M_ASN1_New_Error(ASN1_F_POLICYQUALINFO_NEW);
 518 }
 519
 520 POLICYQUALINFO *d2i_POLICYQUALINFO(POLICYQUALINFO **a, unsigned char **pp,
 521                 long length)
 522 {
 523         M_ASN1_D2I_vars(a,POLICYQUALINFO *,POLICYQUALINFO_new);
 524         M_ASN1_D2I_Init();
 525         M_ASN1_D2I_start_sequence();
 526         M_ASN1_D2I_get (ret->pqualid, d2i_ASN1_OBJECT);
 527         switch(OBJ_obj2nid(ret->pqualid)) {
 528                 case NID_id_qt_cps:
 529                 M_ASN1_D2I_get(ret->d.cpsuri, d2i_ASN1_IA5STRING);
 530                 break;
 531
 532                 case NID_id_qt_unotice:
 533                 M_ASN1_D2I_get(ret->d.usernotice, d2i_USERNOTICE);
 534                 break;
 535
 536                 default:
 537                 M_ASN1_D2I_get(ret->d.other, d2i_ASN1_TYPE);
 538                 break;
 539         }
 540         M_ASN1_D2I_Finish(a, POLICYQUALINFO_free, ASN1_F_D2I_POLICYQUALINFO);
 541 }
 542
 543 void POLICYQUALINFO_free(POLICYQUALINFO *a)
 544 {
 545         if (a == NULL) return;
 546         switch(OBJ_obj2nid(a->pqualid)) {
 547                 case NID_id_qt_cps:
 548                 ASN1_IA5STRING_free(a->d.cpsuri);
 549                 break;
 550
 551                 case NID_id_qt_unotice:
 552                 USERNOTICE_free(a->d.usernotice);
 553                 break;
 554
 555                 default:
 556                 ASN1_TYPE_free(a->d.other);
 557                 break;
 558         }
 559
 560         ASN1_OBJECT_free(a->pqualid);
 561         Free (a);
 562 }
 563
 564 int i2d_USERNOTICE(USERNOTICE *a, unsigned char **pp)
 565 {
 566         M_ASN1_I2D_vars(a);
 567
 568         M_ASN1_I2D_len (a->noticeref, i2d_NOTICEREF);
 569         M_ASN1_I2D_len (a->exptext, i2d_DISPLAYTEXT);
 570
 571         M_ASN1_I2D_seq_total();
 572
 573         M_ASN1_I2D_put (a->noticeref, i2d_NOTICEREF);
 574         M_ASN1_I2D_put (a->exptext, i2d_DISPLAYTEXT);
 575
 576         M_ASN1_I2D_finish();
 577 }
 578
 579 USERNOTICE *USERNOTICE_new(void)
 580 {
 581         USERNOTICE *ret=NULL;
 582         ASN1_CTX c;
 583         M_ASN1_New_Malloc(ret, USERNOTICE);
 584         ret->noticeref = NULL;
 585         ret->exptext = NULL;
 586         return (ret);
 587         M_ASN1_New_Error(ASN1_F_USERNOTICE_NEW);
 588 }
 589
 590 USERNOTICE *d2i_USERNOTICE(USERNOTICE **a, unsigned char **pp,long length)
 591 {
 592         M_ASN1_D2I_vars(a,USERNOTICE *,USERNOTICE_new);
 593         M_ASN1_D2I_Init();
 594         M_ASN1_D2I_start_sequence();
 595         M_ASN1_D2I_get_opt(ret->noticeref, d2i_NOTICEREF, V_ASN1_SEQUENCE);
 596         if (!M_ASN1_D2I_end_sequence()) {
 597                 M_ASN1_D2I_get(ret->exptext, d2i_DISPLAYTEXT);
 598         }
 599         M_ASN1_D2I_Finish(a, USERNOTICE_free, ASN1_F_D2I_USERNOTICE);
 600 }
 601
 602 void USERNOTICE_free(USERNOTICE *a)
 603 {
 604         if (a == NULL) return;
 605         NOTICEREF_free(a->noticeref);
 606         DISPLAYTEXT_free(a->exptext);
 607         Free (a);
 608 }
 609
 610 int i2d_NOTICEREF(NOTICEREF *a, unsigned char **pp)
 611 {
 612         M_ASN1_I2D_vars(a);
 613
 614         M_ASN1_I2D_len (a->organization, i2d_DISPLAYTEXT);
 615         M_ASN1_I2D_len_SEQUENCE(a->noticenos, i2d_ASN1_INTEGER);
 616
 617         M_ASN1_I2D_seq_total();
 618
 619         M_ASN1_I2D_put (a->organization, i2d_DISPLAYTEXT);
 620         M_ASN1_I2D_put_SEQUENCE(a->noticenos, i2d_ASN1_INTEGER);
 621
 622         M_ASN1_I2D_finish();
 623 }
 624
 625 NOTICEREF *NOTICEREF_new(void)
 626 {
 627         NOTICEREF *ret=NULL;
 628         ASN1_CTX c;
 629         M_ASN1_New_Malloc(ret, NOTICEREF);
 630         ret->organization = NULL;
 631         ret->noticenos = NULL;
 632         return (ret);
 633         M_ASN1_New_Error(ASN1_F_NOTICEREF_NEW);
 634 }
 635
 636 NOTICEREF *d2i_NOTICEREF(NOTICEREF **a, unsigned char **pp,long length)
 637 {
 638         M_ASN1_D2I_vars(a,NOTICEREF *,NOTICEREF_new);
 639         M_ASN1_D2I_Init();
 640         M_ASN1_D2I_start_sequence();
 641         /* This is to cope with some broken encodings that use IA5STRING for
 642          * the organization field
 643          */
 644         M_ASN1_D2I_get_opt(ret->organization, d2i_ASN1_IA5STRING,
 645                                                          V_ASN1_IA5STRING);
 646         if(!ret->organization) {
 647                  M_ASN1_D2I_get(ret->organization, d2i_DISPLAYTEXT);
 648         }
 649         M_ASN1_D2I_get_seq(ret->noticenos, d2i_ASN1_INTEGER, ASN1_STRING_free);
 650         M_ASN1_D2I_Finish(a, NOTICEREF_free, ASN1_F_D2I_NOTICEREF);
 651 }
 652
 653 void NOTICEREF_free(NOTICEREF *a)
 654 {
 655         if (a == NULL) return;
 656         DISPLAYTEXT_free(a->organization);
 657         sk_pop_free(a->noticenos, ASN1_STRING_free);
 658         Free (a);
 659 }
 660
 661 IMPLEMENT_STACK_OF(POLICYQUALINFO)
 662 IMPLEMENT_ASN1_SET_OF(POLICYQUALINFO)