• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
2  * project 2000.
3  */
4 /* ====================================================================
5  * Copyright (c) 2000-2005 The OpenSSL Project.  All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  *
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  *
14  * 2. Redistributions in binary form must reproduce the above copyright
15  *    notice, this list of conditions and the following disclaimer in
16  *    the documentation and/or other materials provided with the
17  *    distribution.
18  *
19  * 3. All advertising materials mentioning features or use of this
20  *    software must display the following acknowledgment:
21  *    "This product includes software developed by the OpenSSL Project
22  *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
23  *
24  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
25  *    endorse or promote products derived from this software without
26  *    prior written permission. For written permission, please contact
27  *    licensing@OpenSSL.org.
28  *
29  * 5. Products derived from this software may not be called "OpenSSL"
30  *    nor may "OpenSSL" appear in their names without prior written
31  *    permission of the OpenSSL Project.
32  *
33  * 6. Redistributions of any form whatsoever must retain the following
34  *    acknowledgment:
35  *    "This product includes software developed by the OpenSSL Project
36  *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
37  *
38  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
39  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
40  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
41  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
42  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
43  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
44  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
45  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
46  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
47  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
48  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
49  * OF THE POSSIBILITY OF SUCH DAMAGE.
50  * ====================================================================
51  *
52  * This product includes cryptographic software written by Eric Young
53  * (eay@cryptsoft.com).  This product includes software written by Tim
54  * Hudson (tjh@cryptsoft.com).
55  *
56  */
57 #ifndef HEADER_ASN1T_H
58 #define HEADER_ASN1T_H
59 
60 #include <openssl/base.h>
61 #include <openssl/asn1.h>
62 
63 #ifdef  __cplusplus
64 extern "C" {
65 #endif
66 
67 
68 /* Legacy ASN.1 library template definitions.
69  *
70  * This header is used to define new types in OpenSSL's ASN.1 implementation. It
71  * is deprecated and will be unexported from the library. Use the new |CBS| and
72  * |CBB| library in <openssl/bytestring.h> instead. */
73 
74 
75 /* Macro to obtain ASN1_ADB pointer from a type (only used internally) */
76 #define ASN1_ADB_ptr(iptr) ((const ASN1_ADB *)(iptr))
77 
78 
79 /* Macros for start and end of ASN1_ITEM definition */
80 
81 #define ASN1_ITEM_start(itname) \
82 	const ASN1_ITEM itname##_it = {
83 
84 #define ASN1_ITEM_end(itname) \
85 		};
86 
87 /* Macros to aid ASN1 template writing */
88 
89 #define ASN1_ITEM_TEMPLATE(tname) \
90 	static const ASN1_TEMPLATE tname##_item_tt
91 
92 #define ASN1_ITEM_TEMPLATE_END(tname) \
93 	;\
94 	ASN1_ITEM_start(tname) \
95 		ASN1_ITYPE_PRIMITIVE,\
96 		-1,\
97 		&tname##_item_tt,\
98 		0,\
99 		NULL,\
100 		0,\
101 		#tname \
102 	ASN1_ITEM_end(tname)
103 
104 
105 /* This is a ASN1 type which just embeds a template */
106 
107 /* This pair helps declare a SEQUENCE. We can do:
108  *
109  * 	ASN1_SEQUENCE(stname) = {
110  * 		... SEQUENCE components ...
111  * 	} ASN1_SEQUENCE_END(stname)
112  *
113  * 	This will produce an ASN1_ITEM called stname_it
114  *	for a structure called stname.
115  *
116  * 	If you want the same structure but a different
117  *	name then use:
118  *
119  * 	ASN1_SEQUENCE(itname) = {
120  * 		... SEQUENCE components ...
121  * 	} ASN1_SEQUENCE_END_name(stname, itname)
122  *
123  *	This will create an item called itname_it using
124  *	a structure called stname.
125  */
126 
127 #define ASN1_SEQUENCE(tname) \
128 	static const ASN1_TEMPLATE tname##_seq_tt[]
129 
130 #define ASN1_SEQUENCE_END(stname) ASN1_SEQUENCE_END_name(stname, stname)
131 
132 #define ASN1_SEQUENCE_END_name(stname, tname) \
133 	;\
134 	ASN1_ITEM_start(tname) \
135 		ASN1_ITYPE_SEQUENCE,\
136 		V_ASN1_SEQUENCE,\
137 		tname##_seq_tt,\
138 		sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\
139 		NULL,\
140 		sizeof(stname),\
141 		#stname \
142 	ASN1_ITEM_end(tname)
143 
144 #define ASN1_NDEF_SEQUENCE(tname) \
145 	ASN1_SEQUENCE(tname)
146 
147 #define ASN1_NDEF_SEQUENCE_cb(tname, cb) \
148 	ASN1_SEQUENCE_cb(tname, cb)
149 
150 #define ASN1_SEQUENCE_cb(tname, cb) \
151 	static const ASN1_AUX tname##_aux = {NULL, 0, 0, cb, 0}; \
152 	ASN1_SEQUENCE(tname)
153 
154 #define ASN1_BROKEN_SEQUENCE(tname) \
155 	static const ASN1_AUX tname##_aux = {NULL, ASN1_AFLG_BROKEN, 0, 0, 0}; \
156 	ASN1_SEQUENCE(tname)
157 
158 #define ASN1_SEQUENCE_ref(tname, cb) \
159 	static const ASN1_AUX tname##_aux = {NULL, ASN1_AFLG_REFCOUNT, offsetof(tname, references), cb, 0}; \
160 	ASN1_SEQUENCE(tname)
161 
162 #define ASN1_SEQUENCE_enc(tname, enc, cb) \
163 	static const ASN1_AUX tname##_aux = {NULL, ASN1_AFLG_ENCODING, 0, cb, offsetof(tname, enc)}; \
164 	ASN1_SEQUENCE(tname)
165 
166 #define ASN1_NDEF_SEQUENCE_END(tname) \
167 	;\
168 	ASN1_ITEM_start(tname) \
169 		ASN1_ITYPE_NDEF_SEQUENCE,\
170 		V_ASN1_SEQUENCE,\
171 		tname##_seq_tt,\
172 		sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\
173 		NULL,\
174 		sizeof(tname),\
175 		#tname \
176 	ASN1_ITEM_end(tname)
177 
178 #define ASN1_BROKEN_SEQUENCE_END(stname) ASN1_SEQUENCE_END_ref(stname, stname)
179 
180 #define ASN1_SEQUENCE_END_enc(stname, tname) ASN1_SEQUENCE_END_ref(stname, tname)
181 
182 #define ASN1_SEQUENCE_END_cb(stname, tname) ASN1_SEQUENCE_END_ref(stname, tname)
183 
184 #define ASN1_SEQUENCE_END_ref(stname, tname) \
185 	;\
186 	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 		&tname##_aux,\
192 		sizeof(stname),\
193 		#stname \
194 	ASN1_ITEM_end(tname)
195 
196 #define ASN1_NDEF_SEQUENCE_END_cb(stname, tname) \
197 	;\
198 	ASN1_ITEM_start(tname) \
199 		ASN1_ITYPE_NDEF_SEQUENCE,\
200 		V_ASN1_SEQUENCE,\
201 		tname##_seq_tt,\
202 		sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\
203 		&tname##_aux,\
204 		sizeof(stname),\
205 		#stname \
206 	ASN1_ITEM_end(tname)
207 
208 
209 /* This pair helps declare a CHOICE type. We can do:
210  *
211  * 	ASN1_CHOICE(chname) = {
212  * 		... CHOICE options ...
213  * 	ASN1_CHOICE_END(chname)
214  *
215  * 	This will produce an ASN1_ITEM called chname_it
216  *	for a structure called chname. The structure
217  *	definition must look like this:
218  *	typedef struct {
219  *		int type;
220  *		union {
221  *			ASN1_SOMETHING *opt1;
222  *			ASN1_SOMEOTHER *opt2;
223  *		} value;
224  *	} chname;
225  *
226  *	the name of the selector must be 'type'.
227  * 	to use an alternative selector name use the
228  *      ASN1_CHOICE_END_selector() version.
229  */
230 
231 #define ASN1_CHOICE(tname) \
232 	static const ASN1_TEMPLATE tname##_ch_tt[]
233 
234 #define ASN1_CHOICE_cb(tname, cb) \
235 	static const ASN1_AUX tname##_aux = {NULL, 0, 0, cb, 0}; \
236 	ASN1_CHOICE(tname)
237 
238 #define ASN1_CHOICE_END(stname) ASN1_CHOICE_END_name(stname, stname)
239 
240 #define ASN1_CHOICE_END_name(stname, tname) ASN1_CHOICE_END_selector(stname, tname, type)
241 
242 #define ASN1_CHOICE_END_selector(stname, tname, selname) \
243 	;\
244 	ASN1_ITEM_start(tname) \
245 		ASN1_ITYPE_CHOICE,\
246 		offsetof(stname,selname) ,\
247 		tname##_ch_tt,\
248 		sizeof(tname##_ch_tt) / sizeof(ASN1_TEMPLATE),\
249 		NULL,\
250 		sizeof(stname),\
251 		#stname \
252 	ASN1_ITEM_end(tname)
253 
254 #define ASN1_CHOICE_END_cb(stname, tname, selname) \
255 	;\
256 	ASN1_ITEM_start(tname) \
257 		ASN1_ITYPE_CHOICE,\
258 		offsetof(stname,selname) ,\
259 		tname##_ch_tt,\
260 		sizeof(tname##_ch_tt) / sizeof(ASN1_TEMPLATE),\
261 		&tname##_aux,\
262 		sizeof(stname),\
263 		#stname \
264 	ASN1_ITEM_end(tname)
265 
266 /* This helps with the template wrapper form of ASN1_ITEM */
267 
268 #define ASN1_EX_TEMPLATE_TYPE(flags, tag, name, type) { \
269 	(flags), (tag), 0,\
270 	#name, ASN1_ITEM_ref(type) }
271 
272 /* These help with SEQUENCE or CHOICE components */
273 
274 /* used to declare other types */
275 
276 #define ASN1_EX_TYPE(flags, tag, stname, field, type) { \
277 	(flags), (tag), offsetof(stname, field),\
278 	#field, ASN1_ITEM_ref(type) }
279 
280 /* used when the structure is combined with the parent */
281 
282 #define ASN1_EX_COMBINE(flags, tag, type) { \
283 	(flags)|ASN1_TFLG_COMBINE, (tag), 0, NULL, ASN1_ITEM_ref(type) }
284 
285 /* implicit and explicit helper macros */
286 
287 #define ASN1_IMP_EX(stname, field, type, tag, ex) \
288 		ASN1_EX_TYPE(ASN1_TFLG_IMPLICIT | ex, tag, stname, field, type)
289 
290 #define ASN1_EXP_EX(stname, field, type, tag, ex) \
291 		ASN1_EX_TYPE(ASN1_TFLG_EXPLICIT | ex, tag, stname, field, type)
292 
293 /* Any defined by macros: the field used is in the table itself */
294 
295 #define ASN1_ADB_OBJECT(tblname) { ASN1_TFLG_ADB_OID, -1, 0, #tblname, (const ASN1_ITEM *)&(tblname##_adb) }
296 #define ASN1_ADB_INTEGER(tblname) { ASN1_TFLG_ADB_INT, -1, 0, #tblname, (const ASN1_ITEM *)&(tblname##_adb) }
297 /* Plain simple type */
298 #define ASN1_SIMPLE(stname, field, type) ASN1_EX_TYPE(0,0, stname, field, type)
299 
300 /* OPTIONAL simple type */
301 #define ASN1_OPT(stname, field, type) ASN1_EX_TYPE(ASN1_TFLG_OPTIONAL, 0, stname, field, type)
302 
303 /* IMPLICIT tagged simple type */
304 #define ASN1_IMP(stname, field, type, tag) ASN1_IMP_EX(stname, field, type, tag, 0)
305 
306 /* IMPLICIT tagged OPTIONAL simple type */
307 #define ASN1_IMP_OPT(stname, field, type, tag) ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL)
308 
309 /* Same as above but EXPLICIT */
310 
311 #define ASN1_EXP(stname, field, type, tag) ASN1_EXP_EX(stname, field, type, tag, 0)
312 #define ASN1_EXP_OPT(stname, field, type, tag) ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL)
313 
314 /* SEQUENCE OF type */
315 #define ASN1_SEQUENCE_OF(stname, field, type) \
316 		ASN1_EX_TYPE(ASN1_TFLG_SEQUENCE_OF, 0, stname, field, type)
317 
318 /* OPTIONAL SEQUENCE OF */
319 #define ASN1_SEQUENCE_OF_OPT(stname, field, type) \
320 		ASN1_EX_TYPE(ASN1_TFLG_SEQUENCE_OF|ASN1_TFLG_OPTIONAL, 0, stname, field, type)
321 
322 /* Same as above but for SET OF */
323 
324 #define ASN1_SET_OF(stname, field, type) \
325 		ASN1_EX_TYPE(ASN1_TFLG_SET_OF, 0, stname, field, type)
326 
327 #define ASN1_SET_OF_OPT(stname, field, type) \
328 		ASN1_EX_TYPE(ASN1_TFLG_SET_OF|ASN1_TFLG_OPTIONAL, 0, stname, field, type)
329 
330 /* Finally compound types of SEQUENCE, SET, IMPLICIT, EXPLICIT and OPTIONAL */
331 
332 #define ASN1_IMP_SET_OF(stname, field, type, tag) \
333 			ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF)
334 
335 #define ASN1_EXP_SET_OF(stname, field, type, tag) \
336 			ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF)
337 
338 #define ASN1_IMP_SET_OF_OPT(stname, field, type, tag) \
339 			ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF|ASN1_TFLG_OPTIONAL)
340 
341 #define ASN1_EXP_SET_OF_OPT(stname, field, type, tag) \
342 			ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF|ASN1_TFLG_OPTIONAL)
343 
344 #define ASN1_IMP_SEQUENCE_OF(stname, field, type, tag) \
345 			ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF)
346 
347 #define ASN1_IMP_SEQUENCE_OF_OPT(stname, field, type, tag) \
348 			ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF|ASN1_TFLG_OPTIONAL)
349 
350 #define ASN1_EXP_SEQUENCE_OF(stname, field, type, tag) \
351 			ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF)
352 
353 #define ASN1_EXP_SEQUENCE_OF_OPT(stname, field, type, tag) \
354 			ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF|ASN1_TFLG_OPTIONAL)
355 
356 /* EXPLICIT using indefinite length constructed form */
357 #define ASN1_NDEF_EXP(stname, field, type, tag) \
358 			ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_NDEF)
359 
360 /* EXPLICIT OPTIONAL using indefinite length constructed form */
361 #define ASN1_NDEF_EXP_OPT(stname, field, type, tag) \
362 			ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL|ASN1_TFLG_NDEF)
363 
364 /* Macros for the ASN1_ADB structure */
365 
366 #define ASN1_ADB(name) \
367 	static const ASN1_ADB_TABLE name##_adbtbl[]
368 
369 #define ASN1_ADB_END(name, flags, field, app_table, def, none) \
370 	;\
371 	static const ASN1_ADB name##_adb = {\
372 		flags,\
373 		offsetof(name, field),\
374 		app_table,\
375 		name##_adbtbl,\
376 		sizeof(name##_adbtbl) / sizeof(ASN1_ADB_TABLE),\
377 		def,\
378 		none\
379 	}
380 
381 #define ADB_ENTRY(val, template) {val, template}
382 
383 #define ASN1_ADB_TEMPLATE(name) \
384 	static const ASN1_TEMPLATE name##_tt
385 
386 /* This is the ASN1 template structure that defines
387  * a wrapper round the actual type. It determines the
388  * actual position of the field in the value structure,
389  * various flags such as OPTIONAL and the field name.
390  */
391 
392 struct ASN1_TEMPLATE_st {
393 unsigned long flags;		/* Various flags */
394 long tag;			/* tag, not used if no tagging */
395 unsigned long offset;		/* Offset of this field in structure */
396 #ifndef NO_ASN1_FIELD_NAMES
397 const char *field_name;		/* Field name */
398 #endif
399 ASN1_ITEM_EXP *item;		/* Relevant ASN1_ITEM or ASN1_ADB */
400 };
401 
402 /* Macro to extract ASN1_ITEM and ASN1_ADB pointer from ASN1_TEMPLATE */
403 
404 #define ASN1_TEMPLATE_item(t) (t->item_ptr)
405 #define ASN1_TEMPLATE_adb(t) (t->item_ptr)
406 
407 typedef struct ASN1_ADB_TABLE_st ASN1_ADB_TABLE;
408 typedef struct ASN1_ADB_st ASN1_ADB;
409 
410 typedef struct asn1_must_be_null_st ASN1_MUST_BE_NULL;
411 
412 struct ASN1_ADB_st {
413 	unsigned long flags;	/* Various flags */
414 	unsigned long offset;	/* Offset of selector field */
415 	ASN1_MUST_BE_NULL *unused;
416 	const ASN1_ADB_TABLE *tbl;	/* Table of possible types */
417 	long tblcount;		/* Number of entries in tbl */
418 	const ASN1_TEMPLATE *default_tt;  /* Type to use if no match */
419 	const ASN1_TEMPLATE *null_tt;  /* Type to use if selector is NULL */
420 };
421 
422 struct ASN1_ADB_TABLE_st {
423 	long value;		/* NID for an object or value for an int */
424 	const ASN1_TEMPLATE tt;		/* item for this value */
425 };
426 
427 /* template flags */
428 
429 /* Field is optional */
430 #define ASN1_TFLG_OPTIONAL	(0x1)
431 
432 /* Field is a SET OF */
433 #define ASN1_TFLG_SET_OF	(0x1 << 1)
434 
435 /* Field is a SEQUENCE OF */
436 #define ASN1_TFLG_SEQUENCE_OF	(0x2 << 1)
437 
438 /* Special case: this refers to a SET OF that
439  * will be sorted into DER order when encoded *and*
440  * the corresponding STACK will be modified to match
441  * the new order.
442  */
443 #define ASN1_TFLG_SET_ORDER	(0x3 << 1)
444 
445 /* Mask for SET OF or SEQUENCE OF */
446 #define ASN1_TFLG_SK_MASK	(0x3 << 1)
447 
448 /* These flags mean the tag should be taken from the
449  * tag field. If EXPLICIT then the underlying type
450  * is used for the inner tag.
451  */
452 
453 /* IMPLICIT tagging */
454 #define ASN1_TFLG_IMPTAG	(0x1 << 3)
455 
456 
457 /* EXPLICIT tagging, inner tag from underlying type */
458 #define ASN1_TFLG_EXPTAG	(0x2 << 3)
459 
460 #define ASN1_TFLG_TAG_MASK	(0x3 << 3)
461 
462 /* context specific IMPLICIT */
463 #define ASN1_TFLG_IMPLICIT	ASN1_TFLG_IMPTAG|ASN1_TFLG_CONTEXT
464 
465 /* context specific EXPLICIT */
466 #define ASN1_TFLG_EXPLICIT	ASN1_TFLG_EXPTAG|ASN1_TFLG_CONTEXT
467 
468 /* If tagging is in force these determine the
469  * type of tag to use. Otherwise the tag is
470  * determined by the underlying type. These
471  * values reflect the actual octet format.
472  */
473 
474 /* Universal tag */
475 #define ASN1_TFLG_UNIVERSAL	(0x0<<6)
476 /* Application tag */
477 #define ASN1_TFLG_APPLICATION	(0x1<<6)
478 /* Context specific tag */
479 #define ASN1_TFLG_CONTEXT	(0x2<<6)
480 /* Private tag */
481 #define ASN1_TFLG_PRIVATE	(0x3<<6)
482 
483 #define ASN1_TFLG_TAG_CLASS	(0x3<<6)
484 
485 /* These are for ANY DEFINED BY type. In this case
486  * the 'item' field points to an ASN1_ADB structure
487  * which contains a table of values to decode the
488  * relevant type
489  */
490 
491 #define ASN1_TFLG_ADB_MASK	(0x3<<8)
492 
493 #define ASN1_TFLG_ADB_OID	(0x1<<8)
494 
495 #define ASN1_TFLG_ADB_INT	(0x1<<9)
496 
497 /* This flag means a parent structure is passed
498  * instead of the field: this is useful is a
499  * SEQUENCE is being combined with a CHOICE for
500  * example. Since this means the structure and
501  * item name will differ we need to use the
502  * ASN1_CHOICE_END_name() macro for example.
503  */
504 
505 #define ASN1_TFLG_COMBINE	(0x1<<10)
506 
507 /* This flag when present in a SEQUENCE OF, SET OF
508  * or EXPLICIT causes indefinite length constructed
509  * encoding to be used if required.
510  */
511 
512 #define ASN1_TFLG_NDEF		(0x1<<11)
513 
514 /* This is the actual ASN1 item itself */
515 
516 struct ASN1_ITEM_st {
517 char itype;			/* The item type, primitive, SEQUENCE, CHOICE or extern */
518 long utype;			/* underlying type */
519 const ASN1_TEMPLATE *templates;	/* If SEQUENCE or CHOICE this contains the contents */
520 long tcount;			/* Number of templates if SEQUENCE or CHOICE */
521 const void *funcs;		/* functions that handle this type */
522 long size;			/* Structure size (usually)*/
523 #ifndef NO_ASN1_FIELD_NAMES
524 const char *sname;		/* Structure name */
525 #endif
526 };
527 
528 /* These are values for the itype field and
529  * determine how the type is interpreted.
530  *
531  * For PRIMITIVE types the underlying type
532  * determines the behaviour if items is NULL.
533  *
534  * Otherwise templates must contain a single
535  * template and the type is treated in the
536  * same way as the type specified in the template.
537  *
538  * For SEQUENCE types the templates field points
539  * to the members, the size field is the
540  * structure size.
541  *
542  * For CHOICE types the templates field points
543  * to each possible member (typically a union)
544  * and the 'size' field is the offset of the
545  * selector.
546  *
547  * The 'funcs' field is used for application
548  * specific functions.
549  *
550  * For COMPAT types the funcs field gives a
551  * set of functions that handle this type, this
552  * supports the old d2i, i2d convention.
553  *
554  * The EXTERN type uses a new style d2i/i2d.
555  * The new style should be used where possible
556  * because it avoids things like the d2i IMPLICIT
557  * hack.
558  *
559  * MSTRING is a multiple string type, it is used
560  * for a CHOICE of character strings where the
561  * actual strings all occupy an ASN1_STRING
562  * structure. In this case the 'utype' field
563  * has a special meaning, it is used as a mask
564  * of acceptable types using the B_ASN1 constants.
565  *
566  * NDEF_SEQUENCE is the same as SEQUENCE except
567  * that it will use indefinite length constructed
568  * encoding if requested.
569  *
570  */
571 
572 #define ASN1_ITYPE_PRIMITIVE		0x0
573 
574 #define ASN1_ITYPE_SEQUENCE		0x1
575 
576 #define ASN1_ITYPE_CHOICE		0x2
577 
578 #define ASN1_ITYPE_COMPAT		0x3
579 
580 #define ASN1_ITYPE_EXTERN		0x4
581 
582 #define ASN1_ITYPE_MSTRING		0x5
583 
584 #define ASN1_ITYPE_NDEF_SEQUENCE	0x6
585 
586 /* Cache for ASN1 tag and length, so we
587  * don't keep re-reading it for things
588  * like CHOICE
589  */
590 
591 struct ASN1_TLC_st{
592 	char valid;	/* Values below are valid */
593 	int ret;	/* return value */
594 	long plen;	/* length */
595 	int ptag;	/* class value */
596 	int pclass;	/* class value */
597 	int hdrlen;	/* header length */
598 };
599 
600 /* Typedefs for ASN1 function pointers */
601 
602 typedef ASN1_VALUE * ASN1_new_func(void);
603 typedef void ASN1_free_func(ASN1_VALUE *a);
604 typedef ASN1_VALUE * ASN1_d2i_func(ASN1_VALUE **a, const unsigned char ** in, long length);
605 typedef int ASN1_i2d_func(ASN1_VALUE * a, unsigned char **in);
606 
607 typedef int ASN1_ex_d2i(ASN1_VALUE **pval, const unsigned char **in, long len, const ASN1_ITEM *it,
608 					int tag, int aclass, char opt, ASN1_TLC *ctx);
609 
610 typedef int ASN1_ex_i2d(ASN1_VALUE **pval, unsigned char **out, const ASN1_ITEM *it, int tag, int aclass);
611 typedef int ASN1_ex_new_func(ASN1_VALUE **pval, const ASN1_ITEM *it);
612 typedef void ASN1_ex_free_func(ASN1_VALUE **pval, const ASN1_ITEM *it);
613 
614 typedef int ASN1_ex_print_func(BIO *out, ASN1_VALUE **pval,
615 						int indent, const char *fname,
616 						const ASN1_PCTX *pctx);
617 
618 typedef int ASN1_primitive_i2c(ASN1_VALUE **pval, unsigned char *cont, int *putype, const ASN1_ITEM *it);
619 typedef int ASN1_primitive_c2i(ASN1_VALUE **pval, const unsigned char *cont, int len, int utype, char *free_cont, const ASN1_ITEM *it);
620 typedef int ASN1_primitive_print(BIO *out, ASN1_VALUE **pval, const ASN1_ITEM *it, int indent, const ASN1_PCTX *pctx);
621 
622 typedef struct ASN1_COMPAT_FUNCS_st {
623 	ASN1_new_func *asn1_new;
624 	ASN1_free_func *asn1_free;
625 	ASN1_d2i_func *asn1_d2i;
626 	ASN1_i2d_func *asn1_i2d;
627 } ASN1_COMPAT_FUNCS;
628 
629 typedef struct ASN1_EXTERN_FUNCS_st {
630 	void *app_data;
631 	ASN1_ex_new_func *asn1_ex_new;
632 	ASN1_ex_free_func *asn1_ex_free;
633 	ASN1_ex_free_func *asn1_ex_clear;
634 	ASN1_ex_d2i *asn1_ex_d2i;
635 	ASN1_ex_i2d *asn1_ex_i2d;
636 	/* asn1_ex_print is unused. */
637 	ASN1_ex_print_func *asn1_ex_print;
638 } ASN1_EXTERN_FUNCS;
639 
640 typedef struct ASN1_PRIMITIVE_FUNCS_st {
641 	void *app_data;
642 	unsigned long flags;
643 	ASN1_ex_new_func *prim_new;
644 	ASN1_ex_free_func *prim_free;
645 	ASN1_ex_free_func *prim_clear;
646 	ASN1_primitive_c2i *prim_c2i;
647 	ASN1_primitive_i2c *prim_i2c;
648 	ASN1_primitive_print *prim_print;
649 } ASN1_PRIMITIVE_FUNCS;
650 
651 /* This is the ASN1_AUX structure: it handles various
652  * miscellaneous requirements. For example the use of
653  * reference counts and an informational callback.
654  *
655  * The "informational callback" is called at various
656  * points during the ASN1 encoding and decoding. It can
657  * be used to provide minor customisation of the structures
658  * used. This is most useful where the supplied routines
659  * *almost* do the right thing but need some extra help
660  * at a few points. If the callback returns zero then
661  * it is assumed a fatal error has occurred and the
662  * main operation should be abandoned.
663  *
664  * If major changes in the default behaviour are required
665  * then an external type is more appropriate.
666  */
667 
668 typedef int ASN1_aux_cb(int operation, ASN1_VALUE **in, const ASN1_ITEM *it,
669 				void *exarg);
670 
671 typedef struct ASN1_AUX_st {
672 	void *app_data;
673 	int flags;
674 	int ref_offset;		/* Offset of reference value */
675 	ASN1_aux_cb *asn1_cb;
676 	int enc_offset;		/* Offset of ASN1_ENCODING structure */
677 } ASN1_AUX;
678 
679 /* For print related callbacks exarg points to this structure */
680 typedef struct ASN1_PRINT_ARG_st {
681 	BIO *out;
682 	int indent;
683 	const ASN1_PCTX *pctx;
684 } ASN1_PRINT_ARG;
685 
686 /* For streaming related callbacks exarg points to this structure */
687 typedef struct ASN1_STREAM_ARG_st {
688 	/* BIO to stream through */
689 	BIO *out;
690 	/* BIO with filters appended */
691 	BIO *ndef_bio;
692 	/* Streaming I/O boundary */
693 	unsigned char **boundary;
694 } ASN1_STREAM_ARG;
695 
696 /* Flags in ASN1_AUX */
697 
698 /* Use a reference count */
699 #define ASN1_AFLG_REFCOUNT	1
700 /* Save the encoding of structure (useful for signatures) */
701 #define ASN1_AFLG_ENCODING	2
702 /* The Sequence length is invalid */
703 #define ASN1_AFLG_BROKEN	4
704 
705 /* operation values for asn1_cb */
706 
707 #define ASN1_OP_NEW_PRE		0
708 #define ASN1_OP_NEW_POST	1
709 #define ASN1_OP_FREE_PRE	2
710 #define ASN1_OP_FREE_POST	3
711 #define ASN1_OP_D2I_PRE		4
712 #define ASN1_OP_D2I_POST	5
713 #define ASN1_OP_I2D_PRE		6
714 #define ASN1_OP_I2D_POST	7
715 #define ASN1_OP_PRINT_PRE	8
716 #define ASN1_OP_PRINT_POST	9
717 #define ASN1_OP_STREAM_PRE	10
718 #define ASN1_OP_STREAM_POST	11
719 #define ASN1_OP_DETACHED_PRE	12
720 #define ASN1_OP_DETACHED_POST	13
721 
722 /* Macro to implement a primitive type */
723 #define IMPLEMENT_ASN1_TYPE(stname) IMPLEMENT_ASN1_TYPE_ex(stname, stname, 0)
724 #define IMPLEMENT_ASN1_TYPE_ex(itname, vname, ex) \
725 				ASN1_ITEM_start(itname) \
726 					ASN1_ITYPE_PRIMITIVE, V_##vname, NULL, 0, NULL, ex, #itname \
727 				ASN1_ITEM_end(itname)
728 
729 /* Macro to implement a multi string type */
730 #define IMPLEMENT_ASN1_MSTRING(itname, mask) \
731 				ASN1_ITEM_start(itname) \
732 					ASN1_ITYPE_MSTRING, mask, NULL, 0, NULL, sizeof(ASN1_STRING), #itname \
733 				ASN1_ITEM_end(itname)
734 
735 /* Macro to implement an ASN1_ITEM in terms of old style funcs */
736 
737 #define IMPLEMENT_COMPAT_ASN1(sname) IMPLEMENT_COMPAT_ASN1_type(sname, V_ASN1_SEQUENCE)
738 
739 #define IMPLEMENT_COMPAT_ASN1_type(sname, tag) \
740 	static const ASN1_COMPAT_FUNCS sname##_ff = { \
741 		(ASN1_new_func *)sname##_new, \
742 		(ASN1_free_func *)sname##_free, \
743 		(ASN1_d2i_func *)d2i_##sname, \
744 		(ASN1_i2d_func *)i2d_##sname, \
745 	}; \
746 	ASN1_ITEM_start(sname) \
747 		ASN1_ITYPE_COMPAT, \
748 		tag, \
749 		NULL, \
750 		0, \
751 		&sname##_ff, \
752 		0, \
753 		#sname \
754 	ASN1_ITEM_end(sname)
755 
756 #define IMPLEMENT_EXTERN_ASN1(sname, tag, fptrs) \
757 	ASN1_ITEM_start(sname) \
758 		ASN1_ITYPE_EXTERN, \
759 		tag, \
760 		NULL, \
761 		0, \
762 		&fptrs, \
763 		0, \
764 		#sname \
765 	ASN1_ITEM_end(sname)
766 
767 /* Macro to implement standard functions in terms of ASN1_ITEM structures */
768 
769 #define IMPLEMENT_ASN1_FUNCTIONS(stname) IMPLEMENT_ASN1_FUNCTIONS_fname(stname, stname, stname)
770 
771 #define IMPLEMENT_ASN1_FUNCTIONS_name(stname, itname) IMPLEMENT_ASN1_FUNCTIONS_fname(stname, itname, itname)
772 
773 #define IMPLEMENT_ASN1_FUNCTIONS_ENCODE_name(stname, itname) \
774 			IMPLEMENT_ASN1_FUNCTIONS_ENCODE_fname(stname, itname, itname)
775 
776 #define IMPLEMENT_STATIC_ASN1_ALLOC_FUNCTIONS(stname) \
777 		IMPLEMENT_ASN1_ALLOC_FUNCTIONS_pfname(static, stname, stname, stname)
778 
779 #define IMPLEMENT_ASN1_ALLOC_FUNCTIONS(stname) \
780 		IMPLEMENT_ASN1_ALLOC_FUNCTIONS_fname(stname, stname, stname)
781 
782 #define IMPLEMENT_ASN1_ALLOC_FUNCTIONS_pfname(pre, stname, itname, fname) \
783 	pre stname *fname##_new(void) \
784 	{ \
785 		return (stname *)ASN1_item_new(ASN1_ITEM_rptr(itname)); \
786 	} \
787 	pre void fname##_free(stname *a) \
788 	{ \
789 		ASN1_item_free((ASN1_VALUE *)a, ASN1_ITEM_rptr(itname)); \
790 	}
791 
792 #define IMPLEMENT_ASN1_ALLOC_FUNCTIONS_fname(stname, itname, fname) \
793 	stname *fname##_new(void) \
794 	{ \
795 		return (stname *)ASN1_item_new(ASN1_ITEM_rptr(itname)); \
796 	} \
797 	void fname##_free(stname *a) \
798 	{ \
799 		ASN1_item_free((ASN1_VALUE *)a, ASN1_ITEM_rptr(itname)); \
800 	}
801 
802 #define IMPLEMENT_ASN1_FUNCTIONS_fname(stname, itname, fname) \
803 	IMPLEMENT_ASN1_ENCODE_FUNCTIONS_fname(stname, itname, fname) \
804 	IMPLEMENT_ASN1_ALLOC_FUNCTIONS_fname(stname, itname, fname)
805 
806 #define IMPLEMENT_ASN1_ENCODE_FUNCTIONS_fname(stname, itname, fname) \
807 	stname *d2i_##fname(stname **a, const unsigned char **in, long len) \
808 	{ \
809 		return (stname *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, ASN1_ITEM_rptr(itname));\
810 	} \
811 	int i2d_##fname(stname *a, unsigned char **out) \
812 	{ \
813 		return ASN1_item_i2d((ASN1_VALUE *)a, out, ASN1_ITEM_rptr(itname));\
814 	}
815 
816 #define IMPLEMENT_ASN1_NDEF_FUNCTION(stname) \
817 	int i2d_##stname##_NDEF(stname *a, unsigned char **out) \
818 	{ \
819 		return ASN1_item_ndef_i2d((ASN1_VALUE *)a, out, ASN1_ITEM_rptr(stname));\
820 	}
821 
822 /* This includes evil casts to remove const: they will go away when full
823  * ASN1 constification is done.
824  */
825 #define IMPLEMENT_ASN1_ENCODE_FUNCTIONS_const_fname(stname, itname, fname) \
826 	stname *d2i_##fname(stname **a, const unsigned char **in, long len) \
827 	{ \
828 		return (stname *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, ASN1_ITEM_rptr(itname));\
829 	} \
830 	int i2d_##fname(const stname *a, unsigned char **out) \
831 	{ \
832 		return ASN1_item_i2d((ASN1_VALUE *)a, out, ASN1_ITEM_rptr(itname));\
833 	}
834 
835 #define IMPLEMENT_ASN1_DUP_FUNCTION(stname) \
836 	stname * stname##_dup(stname *x) \
837         { \
838         return ASN1_item_dup(ASN1_ITEM_rptr(stname), x); \
839         }
840 
841 #define IMPLEMENT_ASN1_FUNCTIONS_const(name) \
842 		IMPLEMENT_ASN1_FUNCTIONS_const_fname(name, name, name)
843 
844 #define IMPLEMENT_ASN1_FUNCTIONS_const_fname(stname, itname, fname) \
845 	IMPLEMENT_ASN1_ENCODE_FUNCTIONS_const_fname(stname, itname, fname) \
846 	IMPLEMENT_ASN1_ALLOC_FUNCTIONS_fname(stname, itname, fname)
847 
848 /* external definitions for primitive types */
849 
850 DECLARE_ASN1_ITEM(ASN1_BOOLEAN)
851 DECLARE_ASN1_ITEM(ASN1_TBOOLEAN)
852 DECLARE_ASN1_ITEM(ASN1_FBOOLEAN)
853 DECLARE_ASN1_ITEM(ASN1_SEQUENCE)
854 
855 DEFINE_STACK_OF(ASN1_VALUE)
856 
857 /* Functions used internally by the ASN1 code */
858 
859 int ASN1_item_ex_new(ASN1_VALUE **pval, const ASN1_ITEM *it);
860 void ASN1_item_ex_free(ASN1_VALUE **pval, const ASN1_ITEM *it);
861 int ASN1_template_new(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt);
862 int ASN1_primitive_new(ASN1_VALUE **pval, const ASN1_ITEM *it);
863 
864 void ASN1_template_free(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt);
865 int ASN1_template_d2i(ASN1_VALUE **pval, const unsigned char **in, long len, const ASN1_TEMPLATE *tt);
866 int ASN1_item_ex_d2i(ASN1_VALUE **pval, const unsigned char **in, long len, const ASN1_ITEM *it,
867 				int tag, int aclass, char opt, ASN1_TLC *ctx);
868 
869 int ASN1_item_ex_i2d(ASN1_VALUE **pval, unsigned char **out, const ASN1_ITEM *it, int tag, int aclass);
870 int ASN1_template_i2d(ASN1_VALUE **pval, unsigned char **out, const ASN1_TEMPLATE *tt);
871 void ASN1_primitive_free(ASN1_VALUE **pval, const ASN1_ITEM *it);
872 
873 int asn1_ex_i2c(ASN1_VALUE **pval, unsigned char *cont, int *putype, const ASN1_ITEM *it);
874 int asn1_ex_c2i(ASN1_VALUE **pval, const unsigned char *cont, int len, int utype, char *free_cont, const ASN1_ITEM *it);
875 
876 int asn1_get_choice_selector(ASN1_VALUE **pval, const ASN1_ITEM *it);
877 int asn1_set_choice_selector(ASN1_VALUE **pval, int value, const ASN1_ITEM *it);
878 
879 ASN1_VALUE ** asn1_get_field_ptr(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt);
880 
881 const ASN1_TEMPLATE *asn1_do_adb(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt, int nullerr);
882 
883 void asn1_refcount_set_one(ASN1_VALUE **pval, const ASN1_ITEM *it);
884 int asn1_refcount_dec_and_test_zero(ASN1_VALUE **pval, const ASN1_ITEM *it);
885 
886 void asn1_enc_init(ASN1_VALUE **pval, const ASN1_ITEM *it);
887 void asn1_enc_free(ASN1_VALUE **pval, const ASN1_ITEM *it);
888 int asn1_enc_restore(int *len, unsigned char **out, ASN1_VALUE **pval, const ASN1_ITEM *it);
889 int asn1_enc_save(ASN1_VALUE **pval, const unsigned char *in, int inlen, const ASN1_ITEM *it);
890 
891 #ifdef  __cplusplus
892 }
893 #endif
894 #endif
895