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