95033f265b28b4d8002eb37c663452980c28b26e
[openssl.git] / 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         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)