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