b680dea6dcf871ff5b568240bb601afe218749de
[openssl.git] / include / openssl / asn1t.h
1 /*
2  * Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL project
3  * 2000.
4  */
5 /* ====================================================================
6  * Copyright (c) 2000-2005 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 #ifndef HEADER_ASN1T_H
59 # define HEADER_ASN1T_H
60
61 # include <stddef.h>
62 # include <openssl/e_os2.h>
63 # include <openssl/asn1.h>
64
65 # ifdef OPENSSL_BUILD_SHLIBCRYPTO
66 #  undef OPENSSL_EXTERN
67 #  define OPENSSL_EXTERN OPENSSL_EXPORT
68 # endif
69
70 /* ASN1 template defines, structures and functions */
71
72 #ifdef  __cplusplus
73 extern "C" {
74 #endif
75
76 # ifndef OPENSSL_EXPORT_VAR_AS_FUNCTION
77
78 /* Macro to obtain ASN1_ADB pointer from a type (only used internally) */
79 #  define ASN1_ADB_ptr(iptr) ((const ASN1_ADB *)(iptr))
80
81 /* Macros for start and end of ASN1_ITEM definition */
82
83 #  define ASN1_ITEM_start(itname) \
84         OPENSSL_GLOBAL const ASN1_ITEM itname##_it = {
85
86 #  define static_ASN1_ITEM_start(itname) \
87         static const ASN1_ITEM itname##_it = {
88
89 #  define ASN1_ITEM_end(itname)                 \
90                 };
91
92 # else
93
94 /* Macro to obtain ASN1_ADB pointer from a type (only used internally) */
95 #  define ASN1_ADB_ptr(iptr) ((const ASN1_ADB *)(iptr()))
96
97 /* Macros for start and end of ASN1_ITEM definition */
98
99 #  define ASN1_ITEM_start(itname) \
100         const ASN1_ITEM * itname##_it(void) \
101         { \
102                 static const ASN1_ITEM local_it = {
103
104 #  define static_ASN1_ITEM_start(itname) \
105         static ASN1_ITEM_start(itname)
106
107 #  define ASN1_ITEM_end(itname) \
108                 }; \
109         return &local_it; \
110         }
111
112 # endif
113
114 /* Macros to aid ASN1 template writing */
115
116 # define ASN1_ITEM_TEMPLATE(tname) \
117         static const ASN1_TEMPLATE tname##_item_tt
118
119 # define ASN1_ITEM_TEMPLATE_END(tname) \
120         ;\
121         ASN1_ITEM_start(tname) \
122                 ASN1_ITYPE_PRIMITIVE,\
123                 -1,\
124                 &tname##_item_tt,\
125                 0,\
126                 NULL,\
127                 0,\
128                 #tname \
129         ASN1_ITEM_end(tname)
130 # define static_ASN1_ITEM_TEMPLATE_END(tname) \
131         ;\
132         static_ASN1_ITEM_start(tname) \
133                 ASN1_ITYPE_PRIMITIVE,\
134                 -1,\
135                 &tname##_item_tt,\
136                 0,\
137                 NULL,\
138                 0,\
139                 #tname \
140         ASN1_ITEM_end(tname)
141
142 /* This is a ASN1 type which just embeds a template */
143
144 /*-
145  * This pair helps declare a SEQUENCE. We can do:
146  *
147  *      ASN1_SEQUENCE(stname) = {
148  *              ... SEQUENCE components ...
149  *      } ASN1_SEQUENCE_END(stname)
150  *
151  *      This will produce an ASN1_ITEM called stname_it
152  *      for a structure called stname.
153  *
154  *      If you want the same structure but a different
155  *      name then use:
156  *
157  *      ASN1_SEQUENCE(itname) = {
158  *              ... SEQUENCE components ...
159  *      } ASN1_SEQUENCE_END_name(stname, itname)
160  *
161  *      This will create an item called itname_it using
162  *      a structure called stname.
163  */
164
165 # define ASN1_SEQUENCE(tname) \
166         static const ASN1_TEMPLATE tname##_seq_tt[]
167
168 # define ASN1_SEQUENCE_END(stname) ASN1_SEQUENCE_END_name(stname, stname)
169
170 # define static_ASN1_SEQUENCE_END(stname) static_ASN1_SEQUENCE_END_name(stname, stname)
171
172 # define ASN1_SEQUENCE_END_name(stname, tname) \
173         ;\
174         ASN1_ITEM_start(tname) \
175                 ASN1_ITYPE_SEQUENCE,\
176                 V_ASN1_SEQUENCE,\
177                 tname##_seq_tt,\
178                 sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\
179                 NULL,\
180                 sizeof(stname),\
181                 #stname \
182         ASN1_ITEM_end(tname)
183
184 # define static_ASN1_SEQUENCE_END_name(stname, tname) \
185         ;\
186         static_ASN1_ITEM_start(tname) \
187                 ASN1_ITYPE_SEQUENCE,\
188                 V_ASN1_SEQUENCE,\
189                 tname##_seq_tt,\
190                 sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\
191                 NULL,\
192                 sizeof(stname),\
193                 #stname \
194         ASN1_ITEM_end(tname)
195
196 # define ASN1_NDEF_SEQUENCE(tname) \
197         ASN1_SEQUENCE(tname)
198
199 # define ASN1_NDEF_SEQUENCE_cb(tname, cb) \
200         ASN1_SEQUENCE_cb(tname, cb)
201
202 # define ASN1_SEQUENCE_cb(tname, cb) \
203         static const ASN1_AUX tname##_aux = {NULL, 0, 0, 0, cb, 0}; \
204         ASN1_SEQUENCE(tname)
205
206 # define ASN1_BROKEN_SEQUENCE(tname) \
207         static const ASN1_AUX tname##_aux = {NULL, ASN1_AFLG_BROKEN, 0, 0, 0, 0}; \
208         ASN1_SEQUENCE(tname)
209
210 # define ASN1_SEQUENCE_ref(tname, cb) \
211         static const ASN1_AUX tname##_aux = {NULL, ASN1_AFLG_REFCOUNT, offsetof(tname, references), offsetof(tname, lock), cb, 0}; \
212         ASN1_SEQUENCE(tname)
213
214 # define ASN1_SEQUENCE_enc(tname, enc, cb) \
215         static const ASN1_AUX tname##_aux = {NULL, ASN1_AFLG_ENCODING, 0, 0, cb, offsetof(tname, enc)}; \
216         ASN1_SEQUENCE(tname)
217
218 # define ASN1_NDEF_SEQUENCE_END(tname) \
219         ;\
220         ASN1_ITEM_start(tname) \
221                 ASN1_ITYPE_NDEF_SEQUENCE,\
222                 V_ASN1_SEQUENCE,\
223                 tname##_seq_tt,\
224                 sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\
225                 NULL,\
226                 sizeof(tname),\
227                 #tname \
228         ASN1_ITEM_end(tname)
229 # define static_ASN1_NDEF_SEQUENCE_END(tname) \
230         ;\
231         static_ASN1_ITEM_start(tname)                   \
232                 ASN1_ITYPE_NDEF_SEQUENCE,\
233                 V_ASN1_SEQUENCE,\
234                 tname##_seq_tt,\
235                 sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\
236                 NULL,\
237                 sizeof(tname),\
238                 #tname \
239         ASN1_ITEM_end(tname)
240
241 # define ASN1_BROKEN_SEQUENCE_END(stname) ASN1_SEQUENCE_END_ref(stname, stname)
242 # define static_ASN1_BROKEN_SEQUENCE_END(stname) \
243         static_ASN1_SEQUENCE_END_ref(stname, stname)
244
245 # define ASN1_SEQUENCE_END_enc(stname, tname) ASN1_SEQUENCE_END_ref(stname, tname)
246
247 # define ASN1_SEQUENCE_END_cb(stname, tname) ASN1_SEQUENCE_END_ref(stname, tname)
248 # define static_ASN1_SEQUENCE_END_cb(stname, tname) static_ASN1_SEQUENCE_END_ref(stname, tname)
249
250 # define ASN1_SEQUENCE_END_ref(stname, tname) \
251         ;\
252         ASN1_ITEM_start(tname) \
253                 ASN1_ITYPE_SEQUENCE,\
254                 V_ASN1_SEQUENCE,\
255                 tname##_seq_tt,\
256                 sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\
257                 &tname##_aux,\
258                 sizeof(stname),\
259                 #stname \
260         ASN1_ITEM_end(tname)
261 # define static_ASN1_SEQUENCE_END_ref(stname, tname) \
262         ;\
263         static_ASN1_ITEM_start(tname) \
264                 ASN1_ITYPE_SEQUENCE,\
265                 V_ASN1_SEQUENCE,\
266                 tname##_seq_tt,\
267                 sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\
268                 &tname##_aux,\
269                 sizeof(stname),\
270                 #stname \
271         ASN1_ITEM_end(tname)
272
273 # define ASN1_NDEF_SEQUENCE_END_cb(stname, tname) \
274         ;\
275         ASN1_ITEM_start(tname) \
276                 ASN1_ITYPE_NDEF_SEQUENCE,\
277                 V_ASN1_SEQUENCE,\
278                 tname##_seq_tt,\
279                 sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\
280                 &tname##_aux,\
281                 sizeof(stname),\
282                 #stname \
283         ASN1_ITEM_end(tname)
284
285 /*-
286  * This pair helps declare a CHOICE type. We can do:
287  *
288  *      ASN1_CHOICE(chname) = {
289  *              ... CHOICE options ...
290  *      ASN1_CHOICE_END(chname)
291  *
292  *      This will produce an ASN1_ITEM called chname_it
293  *      for a structure called chname. The structure
294  *      definition must look like this:
295  *      typedef struct {
296  *              int type;
297  *              union {
298  *                      ASN1_SOMETHING *opt1;
299  *                      ASN1_SOMEOTHER *opt2;
300  *              } value;
301  *      } chname;
302  *
303  *      the name of the selector must be 'type'.
304  *      to use an alternative selector name use the
305  *      ASN1_CHOICE_END_selector() version.
306  */
307
308 # define ASN1_CHOICE(tname) \
309         static const ASN1_TEMPLATE tname##_ch_tt[]
310
311 # define ASN1_CHOICE_cb(tname, cb) \
312         static const ASN1_AUX tname##_aux = {NULL, 0, 0, 0, cb, 0}; \
313         ASN1_CHOICE(tname)
314
315 # define ASN1_CHOICE_END(stname) ASN1_CHOICE_END_name(stname, stname)
316
317 # define static_ASN1_CHOICE_END(stname) static_ASN1_CHOICE_END_name(stname, stname)
318
319 # define ASN1_CHOICE_END_name(stname, tname) ASN1_CHOICE_END_selector(stname, tname, type)
320
321 # define static_ASN1_CHOICE_END_name(stname, tname) static_ASN1_CHOICE_END_selector(stname, tname, type)
322
323 # define ASN1_CHOICE_END_selector(stname, tname, selname) \
324         ;\
325         ASN1_ITEM_start(tname) \
326                 ASN1_ITYPE_CHOICE,\
327                 offsetof(stname,selname) ,\
328                 tname##_ch_tt,\
329                 sizeof(tname##_ch_tt) / sizeof(ASN1_TEMPLATE),\
330                 NULL,\
331                 sizeof(stname),\
332                 #stname \
333         ASN1_ITEM_end(tname)
334
335 # define static_ASN1_CHOICE_END_selector(stname, tname, selname) \
336         ;\
337         static_ASN1_ITEM_start(tname) \
338                 ASN1_ITYPE_CHOICE,\
339                 offsetof(stname,selname) ,\
340                 tname##_ch_tt,\
341                 sizeof(tname##_ch_tt) / sizeof(ASN1_TEMPLATE),\
342                 NULL,\
343                 sizeof(stname),\
344                 #stname \
345         ASN1_ITEM_end(tname)
346
347 # define ASN1_CHOICE_END_cb(stname, tname, selname) \
348         ;\
349         ASN1_ITEM_start(tname) \
350                 ASN1_ITYPE_CHOICE,\
351                 offsetof(stname,selname) ,\
352                 tname##_ch_tt,\
353                 sizeof(tname##_ch_tt) / sizeof(ASN1_TEMPLATE),\
354                 &tname##_aux,\
355                 sizeof(stname),\
356                 #stname \
357         ASN1_ITEM_end(tname)
358
359 /* This helps with the template wrapper form of ASN1_ITEM */
360
361 # define ASN1_EX_TEMPLATE_TYPE(flags, tag, name, type) { \
362         (flags), (tag), 0,\
363         #name, ASN1_ITEM_ref(type) }
364
365 /* These help with SEQUENCE or CHOICE components */
366
367 /* used to declare other types */
368
369 # define ASN1_EX_TYPE(flags, tag, stname, field, type) { \
370         (flags), (tag), offsetof(stname, field),\
371         #field, ASN1_ITEM_ref(type) }
372
373 /* implicit and explicit helper macros */
374
375 # define ASN1_IMP_EX(stname, field, type, tag, ex) \
376                 ASN1_EX_TYPE(ASN1_TFLG_IMPLICIT | ex, tag, stname, field, type)
377
378 # define ASN1_EXP_EX(stname, field, type, tag, ex) \
379                 ASN1_EX_TYPE(ASN1_TFLG_EXPLICIT | ex, tag, stname, field, type)
380
381 /* Any defined by macros: the field used is in the table itself */
382
383 # ifndef OPENSSL_EXPORT_VAR_AS_FUNCTION
384 #  define ASN1_ADB_OBJECT(tblname) { ASN1_TFLG_ADB_OID, -1, 0, #tblname, (const ASN1_ITEM *)&(tblname##_adb) }
385 #  define ASN1_ADB_INTEGER(tblname) { ASN1_TFLG_ADB_INT, -1, 0, #tblname, (const ASN1_ITEM *)&(tblname##_adb) }
386 # else
387 #  define ASN1_ADB_OBJECT(tblname) { ASN1_TFLG_ADB_OID, -1, 0, #tblname, tblname##_adb }
388 #  define ASN1_ADB_INTEGER(tblname) { ASN1_TFLG_ADB_INT, -1, 0, #tblname, tblname##_adb }
389 # endif
390 /* Plain simple type */
391 # define ASN1_SIMPLE(stname, field, type) ASN1_EX_TYPE(0,0, stname, field, type)
392 /* Embedded simple type */
393 # define ASN1_EMBED(stname, field, type) ASN1_EX_TYPE(ASN1_TFLG_EMBED,0, stname, field, type)
394
395 /* OPTIONAL simple type */
396 # define ASN1_OPT(stname, field, type) ASN1_EX_TYPE(ASN1_TFLG_OPTIONAL, 0, stname, field, type)
397
398 /* IMPLICIT tagged simple type */
399 # define ASN1_IMP(stname, field, type, tag) ASN1_IMP_EX(stname, field, type, tag, 0)
400
401 /* IMPLICIT tagged OPTIONAL simple type */
402 # define ASN1_IMP_OPT(stname, field, type, tag) ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL)
403
404 /* Same as above but EXPLICIT */
405
406 # define ASN1_EXP(stname, field, type, tag) ASN1_EXP_EX(stname, field, type, tag, 0)
407 # define ASN1_EXP_OPT(stname, field, type, tag) ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL)
408
409 /* SEQUENCE OF type */
410 # define ASN1_SEQUENCE_OF(stname, field, type) \
411                 ASN1_EX_TYPE(ASN1_TFLG_SEQUENCE_OF, 0, stname, field, type)
412
413 /* OPTIONAL SEQUENCE OF */
414 # define ASN1_SEQUENCE_OF_OPT(stname, field, type) \
415                 ASN1_EX_TYPE(ASN1_TFLG_SEQUENCE_OF|ASN1_TFLG_OPTIONAL, 0, stname, field, type)
416
417 /* Same as above but for SET OF */
418
419 # define ASN1_SET_OF(stname, field, type) \
420                 ASN1_EX_TYPE(ASN1_TFLG_SET_OF, 0, stname, field, type)
421
422 # define ASN1_SET_OF_OPT(stname, field, type) \
423                 ASN1_EX_TYPE(ASN1_TFLG_SET_OF|ASN1_TFLG_OPTIONAL, 0, stname, field, type)
424
425 /* Finally compound types of SEQUENCE, SET, IMPLICIT, EXPLICIT and OPTIONAL */
426
427 # define ASN1_IMP_SET_OF(stname, field, type, tag) \
428                         ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF)
429
430 # define ASN1_EXP_SET_OF(stname, field, type, tag) \
431                         ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF)
432
433 # define ASN1_IMP_SET_OF_OPT(stname, field, type, tag) \
434                         ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF|ASN1_TFLG_OPTIONAL)
435
436 # define ASN1_EXP_SET_OF_OPT(stname, field, type, tag) \
437                         ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF|ASN1_TFLG_OPTIONAL)
438
439 # define ASN1_IMP_SEQUENCE_OF(stname, field, type, tag) \
440                         ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF)
441
442 # define ASN1_IMP_SEQUENCE_OF_OPT(stname, field, type, tag) \
443                         ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF|ASN1_TFLG_OPTIONAL)
444
445 # define ASN1_EXP_SEQUENCE_OF(stname, field, type, tag) \
446                         ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF)
447
448 # define ASN1_EXP_SEQUENCE_OF_OPT(stname, field, type, tag) \
449                         ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF|ASN1_TFLG_OPTIONAL)
450
451 /* EXPLICIT using indefinite length constructed form */
452 # define ASN1_NDEF_EXP(stname, field, type, tag) \
453                         ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_NDEF)
454
455 /* EXPLICIT OPTIONAL using indefinite length constructed form */
456 # define ASN1_NDEF_EXP_OPT(stname, field, type, tag) \
457                         ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL|ASN1_TFLG_NDEF)
458
459 /* Macros for the ASN1_ADB structure */
460
461 # define ASN1_ADB(name) \
462         static const ASN1_ADB_TABLE name##_adbtbl[]
463
464 # ifndef OPENSSL_EXPORT_VAR_AS_FUNCTION
465
466 #  define ASN1_ADB_END(name, flags, field, adb_cb, def, none) \
467         ;\
468         static const ASN1_ADB name##_adb = {\
469                 flags,\
470                 offsetof(name, field),\
471                 adb_cb,\
472                 name##_adbtbl,\
473                 sizeof(name##_adbtbl) / sizeof(ASN1_ADB_TABLE),\
474                 def,\
475                 none\
476         }
477
478 # else
479
480 #  define ASN1_ADB_END(name, flags, field, adb_cb, def, none) \
481         ;\
482         static const ASN1_ITEM *name##_adb(void) \
483         { \
484         static const ASN1_ADB internal_adb = \
485                 {\
486                 flags,\
487                 offsetof(name, field),\
488                 adb_cb,\
489                 name##_adbtbl,\
490                 sizeof(name##_adbtbl) / sizeof(ASN1_ADB_TABLE),\
491                 def,\
492                 none\
493                 }; \
494                 return (const ASN1_ITEM *) &internal_adb; \
495         } \
496         void dummy_function(void)
497
498 # endif
499
500 # define ADB_ENTRY(val, template) {val, template}
501
502 # define ASN1_ADB_TEMPLATE(name) \
503         static const ASN1_TEMPLATE name##_tt
504
505 /*
506  * This is the ASN1 template structure that defines a wrapper round the
507  * actual type. It determines the actual position of the field in the value
508  * structure, various flags such as OPTIONAL and the field name.
509  */
510
511 struct ASN1_TEMPLATE_st {
512     unsigned long flags;        /* Various flags */
513     long tag;                   /* tag, not used if no tagging */
514     unsigned long offset;       /* Offset of this field in structure */
515     const char *field_name;     /* Field name */
516     ASN1_ITEM_EXP *item;        /* Relevant ASN1_ITEM or ASN1_ADB */
517 };
518
519 /* Macro to extract ASN1_ITEM and ASN1_ADB pointer from ASN1_TEMPLATE */
520
521 # define ASN1_TEMPLATE_item(t) (t->item_ptr)
522 # define ASN1_TEMPLATE_adb(t) (t->item_ptr)
523
524 typedef struct ASN1_ADB_TABLE_st ASN1_ADB_TABLE;
525 typedef struct ASN1_ADB_st ASN1_ADB;
526
527 struct ASN1_ADB_st {
528     unsigned long flags;        /* Various flags */
529     unsigned long offset;       /* Offset of selector field */
530     int (*adb_cb)(long *psel);  /* Application callback */
531     const ASN1_ADB_TABLE *tbl;  /* Table of possible types */
532     long tblcount;              /* Number of entries in tbl */
533     const ASN1_TEMPLATE *default_tt; /* Type to use if no match */
534     const ASN1_TEMPLATE *null_tt; /* Type to use if selector is NULL */
535 };
536
537 struct ASN1_ADB_TABLE_st {
538     long value;                 /* NID for an object or value for an int */
539     const ASN1_TEMPLATE tt;     /* item for this value */
540 };
541
542 /* template flags */
543
544 /* Field is optional */
545 # define ASN1_TFLG_OPTIONAL      (0x1)
546
547 /* Field is a SET OF */
548 # define ASN1_TFLG_SET_OF        (0x1 << 1)
549
550 /* Field is a SEQUENCE OF */
551 # define ASN1_TFLG_SEQUENCE_OF   (0x2 << 1)
552
553 /*
554  * Special case: this refers to a SET OF that will be sorted into DER order
555  * when encoded *and* the corresponding STACK will be modified to match the
556  * new order.
557  */
558 # define ASN1_TFLG_SET_ORDER     (0x3 << 1)
559
560 /* Mask for SET OF or SEQUENCE OF */
561 # define ASN1_TFLG_SK_MASK       (0x3 << 1)
562
563 /*
564  * These flags mean the tag should be taken from the tag field. If EXPLICIT
565  * then the underlying type is used for the inner tag.
566  */
567
568 /* IMPLICIT tagging */
569 # define ASN1_TFLG_IMPTAG        (0x1 << 3)
570
571 /* EXPLICIT tagging, inner tag from underlying type */
572 # define ASN1_TFLG_EXPTAG        (0x2 << 3)
573
574 # define ASN1_TFLG_TAG_MASK      (0x3 << 3)
575
576 /* context specific IMPLICIT */
577 # define ASN1_TFLG_IMPLICIT      ASN1_TFLG_IMPTAG|ASN1_TFLG_CONTEXT
578
579 /* context specific EXPLICIT */
580 # define ASN1_TFLG_EXPLICIT      ASN1_TFLG_EXPTAG|ASN1_TFLG_CONTEXT
581
582 /*
583  * If tagging is in force these determine the type of tag to use. Otherwise
584  * the tag is determined by the underlying type. These values reflect the
585  * actual octet format.
586  */
587
588 /* Universal tag */
589 # define ASN1_TFLG_UNIVERSAL     (0x0<<6)
590 /* Application tag */
591 # define ASN1_TFLG_APPLICATION   (0x1<<6)
592 /* Context specific tag */
593 # define ASN1_TFLG_CONTEXT       (0x2<<6)
594 /* Private tag */
595 # define ASN1_TFLG_PRIVATE       (0x3<<6)
596
597 # define ASN1_TFLG_TAG_CLASS     (0x3<<6)
598
599 /*
600  * These are for ANY DEFINED BY type. In this case the 'item' field points to
601  * an ASN1_ADB structure which contains a table of values to decode the
602  * relevant type
603  */
604
605 # define ASN1_TFLG_ADB_MASK      (0x3<<8)
606
607 # define ASN1_TFLG_ADB_OID       (0x1<<8)
608
609 # define ASN1_TFLG_ADB_INT       (0x1<<9)
610
611 /*
612  * This flag when present in a SEQUENCE OF, SET OF or EXPLICIT causes
613  * indefinite length constructed encoding to be used if required.
614  */
615
616 # define ASN1_TFLG_NDEF          (0x1<<11)
617
618 /* Field is embedded and not a pointer */
619 # define ASN1_TFLG_EMBED         (0x1 << 12)
620
621 /* This is the actual ASN1 item itself */
622
623 struct ASN1_ITEM_st {
624     char itype;                 /* The item type, primitive, SEQUENCE, CHOICE
625                                  * or extern */
626     long utype;                 /* underlying type */
627     const ASN1_TEMPLATE *templates; /* If SEQUENCE or CHOICE this contains
628                                      * the contents */
629     long tcount;                /* Number of templates if SEQUENCE or CHOICE */
630     const void *funcs;          /* functions that handle this type */
631     long size;                  /* Structure size (usually) */
632     const char *sname;          /* Structure name */
633 };
634
635 /*-
636  * These are values for the itype field and
637  * determine how the type is interpreted.
638  *
639  * For PRIMITIVE types the underlying type
640  * determines the behaviour if items is NULL.
641  *
642  * Otherwise templates must contain a single
643  * template and the type is treated in the
644  * same way as the type specified in the template.
645  *
646  * For SEQUENCE types the templates field points
647  * to the members, the size field is the
648  * structure size.
649  *
650  * For CHOICE types the templates field points
651  * to each possible member (typically a union)
652  * and the 'size' field is the offset of the
653  * selector.
654  *
655  * The 'funcs' field is used for application
656  * specific functions.
657  *
658  * The EXTERN type uses a new style d2i/i2d.
659  * The new style should be used where possible
660  * because it avoids things like the d2i IMPLICIT
661  * hack.
662  *
663  * MSTRING is a multiple string type, it is used
664  * for a CHOICE of character strings where the
665  * actual strings all occupy an ASN1_STRING
666  * structure. In this case the 'utype' field
667  * has a special meaning, it is used as a mask
668  * of acceptable types using the B_ASN1 constants.
669  *
670  * NDEF_SEQUENCE is the same as SEQUENCE except
671  * that it will use indefinite length constructed
672  * encoding if requested.
673  *
674  */
675
676 # define ASN1_ITYPE_PRIMITIVE            0x0
677
678 # define ASN1_ITYPE_SEQUENCE             0x1
679
680 # define ASN1_ITYPE_CHOICE               0x2
681
682 # define ASN1_ITYPE_EXTERN               0x4
683
684 # define ASN1_ITYPE_MSTRING              0x5
685
686 # define ASN1_ITYPE_NDEF_SEQUENCE        0x6
687
688 /*
689  * Cache for ASN1 tag and length, so we don't keep re-reading it for things
690  * like CHOICE
691  */
692
693 struct ASN1_TLC_st {
694     char valid;                 /* Values below are valid */
695     int ret;                    /* return value */
696     long plen;                  /* length */
697     int ptag;                   /* class value */
698     int pclass;                 /* class value */
699     int hdrlen;                 /* header length */
700 };
701
702 /* Typedefs for ASN1 function pointers */
703
704 typedef ASN1_VALUE *ASN1_new_func(void);
705 typedef void ASN1_free_func(ASN1_VALUE *a);
706 typedef ASN1_VALUE *ASN1_d2i_func(ASN1_VALUE **a, const unsigned char **in,
707                                   long length);
708 typedef int ASN1_i2d_func(ASN1_VALUE *a, unsigned char **in);
709
710 typedef int ASN1_ex_d2i(ASN1_VALUE **pval, const unsigned char **in, long len,
711                         const ASN1_ITEM *it, int tag, int aclass, char opt,
712                         ASN1_TLC *ctx);
713
714 typedef int ASN1_ex_i2d(ASN1_VALUE **pval, unsigned char **out,
715                         const ASN1_ITEM *it, int tag, int aclass);
716 typedef int ASN1_ex_new_func(ASN1_VALUE **pval, const ASN1_ITEM *it);
717 typedef void ASN1_ex_free_func(ASN1_VALUE **pval, const ASN1_ITEM *it);
718
719 typedef int ASN1_ex_print_func(BIO *out, ASN1_VALUE **pval,
720                                int indent, const char *fname,
721                                const ASN1_PCTX *pctx);
722
723 typedef int ASN1_primitive_i2c(ASN1_VALUE **pval, unsigned char *cont,
724                                int *putype, const ASN1_ITEM *it);
725 typedef int ASN1_primitive_c2i(ASN1_VALUE **pval, const unsigned char *cont,
726                                int len, int utype, char *free_cont,
727                                const ASN1_ITEM *it);
728 typedef int ASN1_primitive_print(BIO *out, ASN1_VALUE **pval,
729                                  const ASN1_ITEM *it, int indent,
730                                  const ASN1_PCTX *pctx);
731
732 typedef struct ASN1_EXTERN_FUNCS_st {
733     void *app_data;
734     ASN1_ex_new_func *asn1_ex_new;
735     ASN1_ex_free_func *asn1_ex_free;
736     ASN1_ex_free_func *asn1_ex_clear;
737     ASN1_ex_d2i *asn1_ex_d2i;
738     ASN1_ex_i2d *asn1_ex_i2d;
739     ASN1_ex_print_func *asn1_ex_print;
740 } ASN1_EXTERN_FUNCS;
741
742 typedef struct ASN1_PRIMITIVE_FUNCS_st {
743     void *app_data;
744     unsigned long flags;
745     ASN1_ex_new_func *prim_new;
746     ASN1_ex_free_func *prim_free;
747     ASN1_ex_free_func *prim_clear;
748     ASN1_primitive_c2i *prim_c2i;
749     ASN1_primitive_i2c *prim_i2c;
750     ASN1_primitive_print *prim_print;
751 } ASN1_PRIMITIVE_FUNCS;
752
753 /*
754  * This is the ASN1_AUX structure: it handles various miscellaneous
755  * requirements. For example the use of reference counts and an informational
756  * callback. The "informational callback" is called at various points during
757  * the ASN1 encoding and decoding. It can be used to provide minor
758  * customisation of the structures used. This is most useful where the
759  * supplied routines *almost* do the right thing but need some extra help at
760  * a few points. If the callback returns zero then it is assumed a fatal
761  * error has occurred and the main operation should be abandoned. If major
762  * changes in the default behaviour are required then an external type is
763  * more appropriate.
764  */
765
766 typedef int ASN1_aux_cb(int operation, ASN1_VALUE **in, const ASN1_ITEM *it,
767                         void *exarg);
768
769 typedef struct ASN1_AUX_st {
770     void *app_data;
771     int flags;
772     int ref_offset;             /* Offset of reference value */
773     int ref_lock;               /* Lock type to use */
774     ASN1_aux_cb *asn1_cb;
775     int enc_offset;             /* Offset of ASN1_ENCODING structure */
776 } ASN1_AUX;
777
778 /* For print related callbacks exarg points to this structure */
779 typedef struct ASN1_PRINT_ARG_st {
780     BIO *out;
781     int indent;
782     const ASN1_PCTX *pctx;
783 } ASN1_PRINT_ARG;
784
785 /* For streaming related callbacks exarg points to this structure */
786 typedef struct ASN1_STREAM_ARG_st {
787     /* BIO to stream through */
788     BIO *out;
789     /* BIO with filters appended */
790     BIO *ndef_bio;
791     /* Streaming I/O boundary */
792     unsigned char **boundary;
793 } ASN1_STREAM_ARG;
794
795 /* Flags in ASN1_AUX */
796
797 /* Use a reference count */
798 # define ASN1_AFLG_REFCOUNT      1
799 /* Save the encoding of structure (useful for signatures) */
800 # define ASN1_AFLG_ENCODING      2
801 /* The Sequence length is invalid */
802 # define ASN1_AFLG_BROKEN        4
803
804 /* operation values for asn1_cb */
805
806 # define ASN1_OP_NEW_PRE         0
807 # define ASN1_OP_NEW_POST        1
808 # define ASN1_OP_FREE_PRE        2
809 # define ASN1_OP_FREE_POST       3
810 # define ASN1_OP_D2I_PRE         4
811 # define ASN1_OP_D2I_POST        5
812 # define ASN1_OP_I2D_PRE         6
813 # define ASN1_OP_I2D_POST        7
814 # define ASN1_OP_PRINT_PRE       8
815 # define ASN1_OP_PRINT_POST      9
816 # define ASN1_OP_STREAM_PRE      10
817 # define ASN1_OP_STREAM_POST     11
818 # define ASN1_OP_DETACHED_PRE    12
819 # define ASN1_OP_DETACHED_POST   13
820
821 /* Macro to implement a primitive type */
822 # define IMPLEMENT_ASN1_TYPE(stname) IMPLEMENT_ASN1_TYPE_ex(stname, stname, 0)
823 # define IMPLEMENT_ASN1_TYPE_ex(itname, vname, ex) \
824                                 ASN1_ITEM_start(itname) \
825                                         ASN1_ITYPE_PRIMITIVE, V_##vname, NULL, 0, NULL, ex, #itname \
826                                 ASN1_ITEM_end(itname)
827
828 /* Macro to implement a multi string type */
829 # define IMPLEMENT_ASN1_MSTRING(itname, mask) \
830                                 ASN1_ITEM_start(itname) \
831                                         ASN1_ITYPE_MSTRING, mask, NULL, 0, NULL, sizeof(ASN1_STRING), #itname \
832                                 ASN1_ITEM_end(itname)
833
834 # define IMPLEMENT_EXTERN_ASN1(sname, tag, fptrs) \
835         ASN1_ITEM_start(sname) \
836                 ASN1_ITYPE_EXTERN, \
837                 tag, \
838                 NULL, \
839                 0, \
840                 &fptrs, \
841                 0, \
842                 #sname \
843         ASN1_ITEM_end(sname)
844
845 /* Macro to implement standard functions in terms of ASN1_ITEM structures */
846
847 # define IMPLEMENT_ASN1_FUNCTIONS(stname) IMPLEMENT_ASN1_FUNCTIONS_fname(stname, stname, stname)
848
849 # define IMPLEMENT_ASN1_FUNCTIONS_name(stname, itname) IMPLEMENT_ASN1_FUNCTIONS_fname(stname, itname, itname)
850
851 # define IMPLEMENT_ASN1_FUNCTIONS_ENCODE_name(stname, itname) \
852                         IMPLEMENT_ASN1_FUNCTIONS_ENCODE_fname(stname, itname, itname)
853
854 # define IMPLEMENT_STATIC_ASN1_ALLOC_FUNCTIONS(stname) \
855                 IMPLEMENT_ASN1_ALLOC_FUNCTIONS_pfname(static, stname, stname, stname)
856
857 # define IMPLEMENT_ASN1_ALLOC_FUNCTIONS(stname) \
858                 IMPLEMENT_ASN1_ALLOC_FUNCTIONS_fname(stname, stname, stname)
859
860 # define IMPLEMENT_ASN1_ALLOC_FUNCTIONS_pfname(pre, stname, itname, fname) \
861         pre stname *fname##_new(void) \
862         { \
863                 return (stname *)ASN1_item_new(ASN1_ITEM_rptr(itname)); \
864         } \
865         pre void fname##_free(stname *a) \
866         { \
867                 ASN1_item_free((ASN1_VALUE *)a, ASN1_ITEM_rptr(itname)); \
868         }
869
870 # define IMPLEMENT_ASN1_ALLOC_FUNCTIONS_fname(stname, itname, fname) \
871         stname *fname##_new(void) \
872         { \
873                 return (stname *)ASN1_item_new(ASN1_ITEM_rptr(itname)); \
874         } \
875         void fname##_free(stname *a) \
876         { \
877                 ASN1_item_free((ASN1_VALUE *)a, ASN1_ITEM_rptr(itname)); \
878         }
879
880 # define IMPLEMENT_ASN1_FUNCTIONS_fname(stname, itname, fname) \
881         IMPLEMENT_ASN1_ENCODE_FUNCTIONS_fname(stname, itname, fname) \
882         IMPLEMENT_ASN1_ALLOC_FUNCTIONS_fname(stname, itname, fname)
883
884 # define IMPLEMENT_ASN1_ENCODE_FUNCTIONS_fname(stname, itname, fname) \
885         stname *d2i_##fname(stname **a, const unsigned char **in, long len) \
886         { \
887                 return (stname *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, ASN1_ITEM_rptr(itname));\
888         } \
889         int i2d_##fname(stname *a, unsigned char **out) \
890         { \
891                 return ASN1_item_i2d((ASN1_VALUE *)a, out, ASN1_ITEM_rptr(itname));\
892         }
893
894 # define IMPLEMENT_ASN1_NDEF_FUNCTION(stname) \
895         int i2d_##stname##_NDEF(stname *a, unsigned char **out) \
896         { \
897                 return ASN1_item_ndef_i2d((ASN1_VALUE *)a, out, ASN1_ITEM_rptr(stname));\
898         }
899
900 # define IMPLEMENT_STATIC_ASN1_ENCODE_FUNCTIONS(stname) \
901         static stname *d2i_##stname(stname **a, \
902                                    const unsigned char **in, long len) \
903         { \
904                 return (stname *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, \
905                                                ASN1_ITEM_rptr(stname)); \
906         } \
907         static int i2d_##stname(stname *a, unsigned char **out) \
908         { \
909                 return ASN1_item_i2d((ASN1_VALUE *)a, out, \
910                                      ASN1_ITEM_rptr(stname)); \
911         }
912
913 /*
914  * This includes evil casts to remove const: they will go away when full ASN1
915  * constification is done.
916  */
917 # define IMPLEMENT_ASN1_ENCODE_FUNCTIONS_const_fname(stname, itname, fname) \
918         stname *d2i_##fname(stname **a, const unsigned char **in, long len) \
919         { \
920                 return (stname *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, ASN1_ITEM_rptr(itname));\
921         } \
922         int i2d_##fname(const stname *a, unsigned char **out) \
923         { \
924                 return ASN1_item_i2d((ASN1_VALUE *)a, out, ASN1_ITEM_rptr(itname));\
925         }
926
927 # define IMPLEMENT_ASN1_DUP_FUNCTION(stname) \
928         stname * stname##_dup(stname *x) \
929         { \
930         return ASN1_item_dup(ASN1_ITEM_rptr(stname), x); \
931         }
932
933 # define IMPLEMENT_ASN1_PRINT_FUNCTION(stname) \
934         IMPLEMENT_ASN1_PRINT_FUNCTION_fname(stname, stname, stname)
935
936 # define IMPLEMENT_ASN1_PRINT_FUNCTION_fname(stname, itname, fname) \
937         int fname##_print_ctx(BIO *out, stname *x, int indent, \
938                                                 const ASN1_PCTX *pctx) \
939         { \
940                 return ASN1_item_print(out, (ASN1_VALUE *)x, indent, \
941                         ASN1_ITEM_rptr(itname), pctx); \
942         }
943
944 # define IMPLEMENT_ASN1_FUNCTIONS_const(name) \
945                 IMPLEMENT_ASN1_FUNCTIONS_const_fname(name, name, name)
946
947 # define IMPLEMENT_ASN1_FUNCTIONS_const_fname(stname, itname, fname) \
948         IMPLEMENT_ASN1_ENCODE_FUNCTIONS_const_fname(stname, itname, fname) \
949         IMPLEMENT_ASN1_ALLOC_FUNCTIONS_fname(stname, itname, fname)
950
951 /* external definitions for primitive types */
952
953 DECLARE_ASN1_ITEM(ASN1_BOOLEAN)
954 DECLARE_ASN1_ITEM(ASN1_TBOOLEAN)
955 DECLARE_ASN1_ITEM(ASN1_FBOOLEAN)
956 DECLARE_ASN1_ITEM(ASN1_SEQUENCE)
957 DECLARE_ASN1_ITEM(CBIGNUM)
958 DECLARE_ASN1_ITEM(BIGNUM)
959 DECLARE_ASN1_ITEM(LONG)
960 DECLARE_ASN1_ITEM(ZLONG)
961
962 DEFINE_STACK_OF(ASN1_VALUE)
963
964 /* Functions used internally by the ASN1 code */
965
966 int ASN1_item_ex_new(ASN1_VALUE **pval, const ASN1_ITEM *it);
967 void ASN1_item_ex_free(ASN1_VALUE **pval, const ASN1_ITEM *it);
968
969 int ASN1_item_ex_d2i(ASN1_VALUE **pval, const unsigned char **in, long len,
970                      const ASN1_ITEM *it, int tag, int aclass, char opt,
971                      ASN1_TLC *ctx);
972
973 int ASN1_item_ex_i2d(ASN1_VALUE **pval, unsigned char **out,
974                      const ASN1_ITEM *it, int tag, int aclass);
975
976 #ifdef  __cplusplus
977 }
978 #endif
979 #endif