|
108
|
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 |
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 |
const static 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 |
const static 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_SEQUENCE_cb(tname, cb) \
|
|
|
170 |
const static ASN1_AUX tname##_aux = {NULL, 0, 0, 0, cb, 0}; \
|
|
|
171 |
ASN1_SEQUENCE(tname)
|
|
|
172 |
|
|
|
173 |
#define ASN1_BROKEN_SEQUENCE(tname) \
|
|
|
174 |
const static ASN1_AUX tname##_aux = {NULL, ASN1_AFLG_BROKEN, 0, 0, 0, 0}; \
|
|
|
175 |
ASN1_SEQUENCE(tname)
|
|
|
176 |
|
|
|
177 |
#define ASN1_SEQUENCE_ref(tname, cb, lck) \
|
|
|
178 |
const static ASN1_AUX tname##_aux = {NULL, ASN1_AFLG_REFCOUNT, offsetof(tname, references), lck, cb, 0}; \
|
|
|
179 |
ASN1_SEQUENCE(tname)
|
|
|
180 |
|
|
|
181 |
#define ASN1_SEQUENCE_enc(tname, enc, cb) \
|
|
|
182 |
const static ASN1_AUX tname##_aux = {NULL, ASN1_AFLG_ENCODING, 0, 0, cb, offsetof(tname, enc)}; \
|
|
|
183 |
ASN1_SEQUENCE(tname)
|
|
|
184 |
|
|
|
185 |
#define ASN1_BROKEN_SEQUENCE_END(stname) ASN1_SEQUENCE_END_ref(stname, stname)
|
|
|
186 |
|
|
|
187 |
#define ASN1_SEQUENCE_END_enc(stname, tname) ASN1_SEQUENCE_END_ref(stname, tname)
|
|
|
188 |
|
|
|
189 |
#define ASN1_SEQUENCE_END_cb(stname, tname) ASN1_SEQUENCE_END_ref(stname, tname)
|
|
|
190 |
|
|
|
191 |
#define ASN1_SEQUENCE_END_ref(stname, tname) \
|
|
|
192 |
;\
|
|
|
193 |
ASN1_ITEM_start(tname) \
|
|
|
194 |
ASN1_ITYPE_SEQUENCE,\
|
|
|
195 |
V_ASN1_SEQUENCE,\
|
|
|
196 |
tname##_seq_tt,\
|
|
|
197 |
sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\
|
|
|
198 |
&tname##_aux,\
|
|
|
199 |
sizeof(stname),\
|
|
|
200 |
#stname \
|
|
|
201 |
ASN1_ITEM_end(tname)
|
|
|
202 |
|
|
|
203 |
|
|
|
204 |
/* This pair helps declare a CHOICE type. We can do:
|
|
|
205 |
*
|
|
|
206 |
* ASN1_CHOICE(chname) = {
|
|
|
207 |
* ... CHOICE options ...
|
|
|
208 |
* ASN1_CHOICE_END(chname)
|
|
|
209 |
*
|
|
|
210 |
* This will produce an ASN1_ITEM called chname_it
|
|
|
211 |
* for a structure called chname. The structure
|
|
|
212 |
* definition must look like this:
|
|
|
213 |
* typedef struct {
|
|
|
214 |
* int type;
|
|
|
215 |
* union {
|
|
|
216 |
* ASN1_SOMETHING *opt1;
|
|
|
217 |
* ASN1_SOMEOTHER *opt2;
|
|
|
218 |
* } value;
|
|
|
219 |
* } chname;
|
|
|
220 |
*
|
|
|
221 |
* the name of the selector must be 'type'.
|
|
|
222 |
* to use an alternative selector name use the
|
|
|
223 |
* ASN1_CHOICE_END_selector() version.
|
|
|
224 |
*/
|
|
|
225 |
|
|
|
226 |
#define ASN1_CHOICE(tname) \
|
|
|
227 |
const static ASN1_TEMPLATE tname##_ch_tt[]
|
|
|
228 |
|
|
|
229 |
#define ASN1_CHOICE_cb(tname, cb) \
|
|
|
230 |
const static ASN1_AUX tname##_aux = {NULL, 0, 0, 0, cb, 0}; \
|
|
|
231 |
ASN1_CHOICE(tname)
|
|
|
232 |
|
|
|
233 |
#define ASN1_CHOICE_END(stname) ASN1_CHOICE_END_name(stname, stname)
|
|
|
234 |
|
|
|
235 |
#define ASN1_CHOICE_END_name(stname, tname) ASN1_CHOICE_END_selector(stname, tname, type)
|
|
|
236 |
|
|
|
237 |
#define ASN1_CHOICE_END_selector(stname, tname, selname) \
|
|
|
238 |
;\
|
|
|
239 |
ASN1_ITEM_start(tname) \
|
|
|
240 |
ASN1_ITYPE_CHOICE,\
|
|
|
241 |
offsetof(stname,selname) ,\
|
|
|
242 |
tname##_ch_tt,\
|
|
|
243 |
sizeof(tname##_ch_tt) / sizeof(ASN1_TEMPLATE),\
|
|
|
244 |
NULL,\
|
|
|
245 |
sizeof(stname),\
|
|
|
246 |
#stname \
|
|
|
247 |
ASN1_ITEM_end(tname)
|
|
|
248 |
|
|
|
249 |
#define ASN1_CHOICE_END_cb(stname, tname, selname) \
|
|
|
250 |
;\
|
|
|
251 |
ASN1_ITEM_start(tname) \
|
|
|
252 |
ASN1_ITYPE_CHOICE,\
|
|
|
253 |
offsetof(stname,selname) ,\
|
|
|
254 |
tname##_ch_tt,\
|
|
|
255 |
sizeof(tname##_ch_tt) / sizeof(ASN1_TEMPLATE),\
|
|
|
256 |
&tname##_aux,\
|
|
|
257 |
sizeof(stname),\
|
|
|
258 |
#stname \
|
|
|
259 |
ASN1_ITEM_end(tname)
|
|
|
260 |
|
|
|
261 |
/* This helps with the template wrapper form of ASN1_ITEM */
|
|
|
262 |
|
|
|
263 |
#define ASN1_EX_TEMPLATE_TYPE(flags, tag, name, type) { \
|
|
|
264 |
(flags), (tag), 0,\
|
|
|
265 |
#name, ASN1_ITEM_ref(type) }
|
|
|
266 |
|
|
|
267 |
/* These help with SEQUENCE or CHOICE components */
|
|
|
268 |
|
|
|
269 |
/* used to declare other types */
|
|
|
270 |
|
|
|
271 |
#define ASN1_EX_TYPE(flags, tag, stname, field, type) { \
|
|
|
272 |
(flags), (tag), offsetof(stname, field),\
|
|
|
273 |
#field, ASN1_ITEM_ref(type) }
|
|
|
274 |
|
|
|
275 |
/* used when the structure is combined with the parent */
|
|
|
276 |
|
|
|
277 |
#define ASN1_EX_COMBINE(flags, tag, type) { \
|
|
|
278 |
(flags)|ASN1_TFLG_COMBINE, (tag), 0, NULL, ASN1_ITEM_ref(type) }
|
|
|
279 |
|
|
|
280 |
/* implicit and explicit helper macros */
|
|
|
281 |
|
|
|
282 |
#define ASN1_IMP_EX(stname, field, type, tag, ex) \
|
|
|
283 |
ASN1_EX_TYPE(ASN1_TFLG_IMPLICIT | ex, tag, stname, field, type)
|
|
|
284 |
|
|
|
285 |
#define ASN1_EXP_EX(stname, field, type, tag, ex) \
|
|
|
286 |
ASN1_EX_TYPE(ASN1_TFLG_EXPLICIT | ex, tag, stname, field, type)
|
|
|
287 |
|
|
|
288 |
/* Any defined by macros: the field used is in the table itself */
|
|
|
289 |
|
|
|
290 |
#ifndef OPENSSL_EXPORT_VAR_AS_FUNCTION
|
|
|
291 |
#define ASN1_ADB_OBJECT(tblname) { ASN1_TFLG_ADB_OID, -1, 0, #tblname, (const ASN1_ITEM *)&(tblname##_adb) }
|
|
|
292 |
#define ASN1_ADB_INTEGER(tblname) { ASN1_TFLG_ADB_INT, -1, 0, #tblname, (const ASN1_ITEM *)&(tblname##_adb) }
|
|
|
293 |
#else
|
|
|
294 |
#define ASN1_ADB_OBJECT(tblname) { ASN1_TFLG_ADB_OID, -1, 0, #tblname, tblname##_adb }
|
|
|
295 |
#define ASN1_ADB_INTEGER(tblname) { ASN1_TFLG_ADB_INT, -1, 0, #tblname, tblname##_adb }
|
|
|
296 |
#endif
|
|
|
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 |
/* Macros for the ASN1_ADB structure */
|
|
|
357 |
|
|
|
358 |
#define ASN1_ADB(name) \
|
|
|
359 |
const static ASN1_ADB_TABLE name##_adbtbl[]
|
|
|
360 |
|
|
|
361 |
#ifndef OPENSSL_EXPORT_VAR_AS_FUNCTION
|
|
|
362 |
|
|
|
363 |
#define ASN1_ADB_END(name, flags, field, app_table, def, none) \
|
|
|
364 |
;\
|
|
|
365 |
const static ASN1_ADB name##_adb = {\
|
|
|
366 |
flags,\
|
|
|
367 |
offsetof(name, field),\
|
|
|
368 |
app_table,\
|
|
|
369 |
name##_adbtbl,\
|
|
|
370 |
sizeof(name##_adbtbl) / sizeof(ASN1_ADB_TABLE),\
|
|
|
371 |
def,\
|
|
|
372 |
none\
|
|
|
373 |
}
|
|
|
374 |
|
|
|
375 |
#else
|
|
|
376 |
|
|
|
377 |
#define ASN1_ADB_END(name, flags, field, app_table, def, none) \
|
|
|
378 |
;\
|
|
|
379 |
const static ASN1_ITEM *name##_adb(void) \
|
|
|
380 |
{ \
|
|
|
381 |
const static ASN1_ADB internal_adb = \
|
|
|
382 |
{\
|
|
|
383 |
flags,\
|
|
|
384 |
offsetof(name, field),\
|
|
|
385 |
app_table,\
|
|
|
386 |
name##_adbtbl,\
|
|
|
387 |
sizeof(name##_adbtbl) / sizeof(ASN1_ADB_TABLE),\
|
|
|
388 |
def,\
|
|
|
389 |
none\
|
|
|
390 |
}; \
|
|
|
391 |
return (const ASN1_ITEM *) &internal_adb; \
|
|
|
392 |
} \
|
|
|
393 |
void dummy_function(void)
|
|
|
394 |
|
|
|
395 |
#endif
|
|
|
396 |
|
|
|
397 |
#define ADB_ENTRY(val, template) {val, template}
|
|
|
398 |
|
|
|
399 |
#define ASN1_ADB_TEMPLATE(name) \
|
|
|
400 |
const static ASN1_TEMPLATE name##_tt
|
|
|
401 |
|
|
|
402 |
/* This is the ASN1 template structure that defines
|
|
|
403 |
* a wrapper round the actual type. It determines the
|
|
|
404 |
* actual position of the field in the value structure,
|
|
|
405 |
* various flags such as OPTIONAL and the field name.
|
|
|
406 |
*/
|
|
|
407 |
|
|
|
408 |
struct ASN1_TEMPLATE_st {
|
|
|
409 |
unsigned long flags; /* Various flags */
|
|
|
410 |
long tag; /* tag, not used if no tagging */
|
|
|
411 |
unsigned long offset; /* Offset of this field in structure */
|
|
|
412 |
#ifndef NO_ASN1_FIELD_NAMES
|
|
|
413 |
char *field_name; /* Field name */
|
|
|
414 |
#endif
|
|
|
415 |
ASN1_ITEM_EXP *item; /* Relevant ASN1_ITEM or ASN1_ADB */
|
|
|
416 |
};
|
|
|
417 |
|
|
|
418 |
/* Macro to extract ASN1_ITEM and ASN1_ADB pointer from ASN1_TEMPLATE */
|
|
|
419 |
|
|
|
420 |
#define ASN1_TEMPLATE_item(t) (t->item_ptr)
|
|
|
421 |
#define ASN1_TEMPLATE_adb(t) (t->item_ptr)
|
|
|
422 |
|
|
|
423 |
typedef struct ASN1_ADB_TABLE_st ASN1_ADB_TABLE;
|
|
|
424 |
typedef struct ASN1_ADB_st ASN1_ADB;
|
|
|
425 |
|
|
|
426 |
struct ASN1_ADB_st {
|
|
|
427 |
unsigned long flags; /* Various flags */
|
|
|
428 |
unsigned long offset; /* Offset of selector field */
|
|
|
429 |
STACK_OF(ASN1_ADB_TABLE) **app_items; /* Application defined items */
|
|
|
430 |
const ASN1_ADB_TABLE *tbl; /* Table of possible types */
|
|
|
431 |
long tblcount; /* Number of entries in tbl */
|
|
|
432 |
const ASN1_TEMPLATE *default_tt; /* Type to use if no match */
|
|
|
433 |
const ASN1_TEMPLATE *null_tt; /* Type to use if selector is NULL */
|
|
|
434 |
};
|
|
|
435 |
|
|
|
436 |
struct ASN1_ADB_TABLE_st {
|
|
|
437 |
long value; /* NID for an object or value for an int */
|
|
|
438 |
const ASN1_TEMPLATE tt; /* item for this value */
|
|
|
439 |
};
|
|
|
440 |
|
|
|
441 |
/* template flags */
|
|
|
442 |
|
|
|
443 |
/* Field is optional */
|
|
|
444 |
#define ASN1_TFLG_OPTIONAL (0x1)
|
|
|
445 |
|
|
|
446 |
/* Field is a SET OF */
|
|
|
447 |
#define ASN1_TFLG_SET_OF (0x1 << 1)
|
|
|
448 |
|
|
|
449 |
/* Field is a SEQUENCE OF */
|
|
|
450 |
#define ASN1_TFLG_SEQUENCE_OF (0x2 << 1)
|
|
|
451 |
|
|
|
452 |
/* Special case: this refers to a SET OF that
|
|
|
453 |
* will be sorted into DER order when encoded *and*
|
|
|
454 |
* the corresponding STACK will be modified to match
|
|
|
455 |
* the new order.
|
|
|
456 |
*/
|
|
|
457 |
#define ASN1_TFLG_SET_ORDER (0x3 << 1)
|
|
|
458 |
|
|
|
459 |
/* Mask for SET OF or SEQUENCE OF */
|
|
|
460 |
#define ASN1_TFLG_SK_MASK (0x3 << 1)
|
|
|
461 |
|
|
|
462 |
/* These flags mean the tag should be taken from the
|
|
|
463 |
* tag field. If EXPLICIT then the underlying type
|
|
|
464 |
* is used for the inner tag.
|
|
|
465 |
*/
|
|
|
466 |
|
|
|
467 |
/* IMPLICIT tagging */
|
|
|
468 |
#define ASN1_TFLG_IMPTAG (0x1 << 3)
|
|
|
469 |
|
|
|
470 |
|
|
|
471 |
/* EXPLICIT tagging, inner tag from underlying type */
|
|
|
472 |
#define ASN1_TFLG_EXPTAG (0x2 << 3)
|
|
|
473 |
|
|
|
474 |
#define ASN1_TFLG_TAG_MASK (0x3 << 3)
|
|
|
475 |
|
|
|
476 |
/* context specific IMPLICIT */
|
|
|
477 |
#define ASN1_TFLG_IMPLICIT ASN1_TFLG_IMPTAG|ASN1_TFLG_CONTEXT
|
|
|
478 |
|
|
|
479 |
/* context specific EXPLICIT */
|
|
|
480 |
#define ASN1_TFLG_EXPLICIT ASN1_TFLG_EXPTAG|ASN1_TFLG_CONTEXT
|
|
|
481 |
|
|
|
482 |
/* If tagging is in force these determine the
|
|
|
483 |
* type of tag to use. Otherwise the tag is
|
|
|
484 |
* determined by the underlying type. These
|
|
|
485 |
* values reflect the actual octet format.
|
|
|
486 |
*/
|
|
|
487 |
|
|
|
488 |
/* Universal tag */
|
|
|
489 |
#define ASN1_TFLG_UNIVERSAL (0x0<<6)
|
|
|
490 |
/* Application tag */
|
|
|
491 |
#define ASN1_TFLG_APPLICATION (0x1<<6)
|
|
|
492 |
/* Context specific tag */
|
|
|
493 |
#define ASN1_TFLG_CONTEXT (0x2<<6)
|
|
|
494 |
/* Private tag */
|
|
|
495 |
#define ASN1_TFLG_PRIVATE (0x3<<6)
|
|
|
496 |
|
|
|
497 |
#define ASN1_TFLG_TAG_CLASS (0x3<<6)
|
|
|
498 |
|
|
|
499 |
/* These are for ANY DEFINED BY type. In this case
|
|
|
500 |
* the 'item' field points to an ASN1_ADB structure
|
|
|
501 |
* which contains a table of values to decode the
|
|
|
502 |
* relevant type
|
|
|
503 |
*/
|
|
|
504 |
|
|
|
505 |
#define ASN1_TFLG_ADB_MASK (0x3<<8)
|
|
|
506 |
|
|
|
507 |
#define ASN1_TFLG_ADB_OID (0x1<<8)
|
|
|
508 |
|
|
|
509 |
#define ASN1_TFLG_ADB_INT (0x1<<9)
|
|
|
510 |
|
|
|
511 |
/* This flag means a parent structure is passed
|
|
|
512 |
* instead of the field: this is useful is a
|
|
|
513 |
* SEQUENCE is being combined with a CHOICE for
|
|
|
514 |
* example. Since this means the structure and
|
|
|
515 |
* item name will differ we need to use the
|
|
|
516 |
* ASN1_CHOICE_END_name() macro for example.
|
|
|
517 |
*/
|
|
|
518 |
|
|
|
519 |
#define ASN1_TFLG_COMBINE (0x1<<10)
|
|
|
520 |
|
|
|
521 |
/* This is the actual ASN1 item itself */
|
|
|
522 |
|
|
|
523 |
struct ASN1_ITEM_st {
|
|
|
524 |
char itype; /* The item type, primitive, SEQUENCE, CHOICE or extern */
|
|
|
525 |
long utype; /* underlying type */
|
|
|
526 |
const ASN1_TEMPLATE *templates; /* If SEQUENCE or CHOICE this contains the contents */
|
|
|
527 |
long tcount; /* Number of templates if SEQUENCE or CHOICE */
|
|
|
528 |
const void *funcs; /* functions that handle this type */
|
|
|
529 |
long size; /* Structure size (usually)*/
|
|
|
530 |
#ifndef NO_ASN1_FIELD_NAMES
|
|
|
531 |
const char *sname; /* Structure name */
|
|
|
532 |
#endif
|
|
|
533 |
};
|
|
|
534 |
|
|
|
535 |
/* These are values for the itype field and
|
|
|
536 |
* determine how the type is interpreted.
|
|
|
537 |
*
|
|
|
538 |
* For PRIMITIVE types the underlying type
|
|
|
539 |
* determines the behaviour if items is NULL.
|
|
|
540 |
*
|
|
|
541 |
* Otherwise templates must contain a single
|
|
|
542 |
* template and the type is treated in the
|
|
|
543 |
* same way as the type specified in the template.
|
|
|
544 |
*
|
|
|
545 |
* For SEQUENCE types the templates field points
|
|
|
546 |
* to the members, the size field is the
|
|
|
547 |
* structure size.
|
|
|
548 |
*
|
|
|
549 |
* For CHOICE types the templates field points
|
|
|
550 |
* to each possible member (typically a union)
|
|
|
551 |
* and the 'size' field is the offset of the
|
|
|
552 |
* selector.
|
|
|
553 |
*
|
|
|
554 |
* The 'funcs' field is used for application
|
|
|
555 |
* specific functions.
|
|
|
556 |
*
|
|
|
557 |
* For COMPAT types the funcs field gives a
|
|
|
558 |
* set of functions that handle this type, this
|
|
|
559 |
* supports the old d2i, i2d convention.
|
|
|
560 |
*
|
|
|
561 |
* The EXTERN type uses a new style d2i/i2d.
|
|
|
562 |
* The new style should be used where possible
|
|
|
563 |
* because it avoids things like the d2i IMPLICIT
|
|
|
564 |
* hack.
|
|
|
565 |
*
|
|
|
566 |
* MSTRING is a multiple string type, it is used
|
|
|
567 |
* for a CHOICE of character strings where the
|
|
|
568 |
* actual strings all occupy an ASN1_STRING
|
|
|
569 |
* structure. In this case the 'utype' field
|
|
|
570 |
* has a special meaning, it is used as a mask
|
|
|
571 |
* of acceptable types using the B_ASN1 constants.
|
|
|
572 |
*
|
|
|
573 |
*/
|
|
|
574 |
|
|
|
575 |
#define ASN1_ITYPE_PRIMITIVE 0x0
|
|
|
576 |
|
|
|
577 |
#define ASN1_ITYPE_SEQUENCE 0x1
|
|
|
578 |
|
|
|
579 |
#define ASN1_ITYPE_CHOICE 0x2
|
|
|
580 |
|
|
|
581 |
#define ASN1_ITYPE_COMPAT 0x3
|
|
|
582 |
|
|
|
583 |
#define ASN1_ITYPE_EXTERN 0x4
|
|
|
584 |
|
|
|
585 |
#define ASN1_ITYPE_MSTRING 0x5
|
|
|
586 |
|
|
|
587 |
/* Cache for ASN1 tag and length, so we
|
|
|
588 |
* don't keep re-reading it for things
|
|
|
589 |
* like CHOICE
|
|
|
590 |
*/
|
|
|
591 |
|
|
|
592 |
struct ASN1_TLC_st{
|
|
|
593 |
char valid; /* Values below are valid */
|
|
|
594 |
int ret; /* return value */
|
|
|
595 |
long plen; /* length */
|
|
|
596 |
int ptag; /* class value */
|
|
|
597 |
int pclass; /* class value */
|
|
|
598 |
int hdrlen; /* header length */
|
|
|
599 |
};
|
|
|
600 |
|
|
|
601 |
/* Typedefs for ASN1 function pointers */
|
|
|
602 |
|
|
|
603 |
typedef ASN1_VALUE * ASN1_new_func(void);
|
|
|
604 |
typedef void ASN1_free_func(ASN1_VALUE *a);
|
|
|
605 |
typedef ASN1_VALUE * ASN1_d2i_func(ASN1_VALUE **a, unsigned char ** in, long length);
|
|
|
606 |
typedef int ASN1_i2d_func(ASN1_VALUE * a, unsigned char **in);
|
|
|
607 |
|
|
|
608 |
typedef int ASN1_ex_d2i(ASN1_VALUE **pval, unsigned char **in, long len, const ASN1_ITEM *it,
|
|
|
609 |
int tag, int aclass, char opt, ASN1_TLC *ctx);
|
|
|
610 |
|
|
|
611 |
typedef int ASN1_ex_i2d(ASN1_VALUE **pval, unsigned char **out, const ASN1_ITEM *it, int tag, int aclass);
|
|
|
612 |
typedef int ASN1_ex_new_func(ASN1_VALUE **pval, const ASN1_ITEM *it);
|
|
|
613 |
typedef void ASN1_ex_free_func(ASN1_VALUE **pval, const ASN1_ITEM *it);
|
|
|
614 |
|
|
|
615 |
typedef int ASN1_primitive_i2c(ASN1_VALUE **pval, unsigned char *cont, int *putype, const ASN1_ITEM *it);
|
|
|
616 |
typedef int ASN1_primitive_c2i(ASN1_VALUE **pval, unsigned char *cont, int len, int utype, char *free_cont, const ASN1_ITEM *it);
|
|
|
617 |
|
|
|
618 |
typedef struct ASN1_COMPAT_FUNCS_st {
|
|
|
619 |
ASN1_new_func *asn1_new;
|
|
|
620 |
ASN1_free_func *asn1_free;
|
|
|
621 |
ASN1_d2i_func *asn1_d2i;
|
|
|
622 |
ASN1_i2d_func *asn1_i2d;
|
|
|
623 |
} ASN1_COMPAT_FUNCS;
|
|
|
624 |
|
|
|
625 |
typedef struct ASN1_EXTERN_FUNCS_st {
|
|
|
626 |
void *app_data;
|
|
|
627 |
ASN1_ex_new_func *asn1_ex_new;
|
|
|
628 |
ASN1_ex_free_func *asn1_ex_free;
|
|
|
629 |
ASN1_ex_free_func *asn1_ex_clear;
|
|
|
630 |
ASN1_ex_d2i *asn1_ex_d2i;
|
|
|
631 |
ASN1_ex_i2d *asn1_ex_i2d;
|
|
|
632 |
} ASN1_EXTERN_FUNCS;
|
|
|
633 |
|
|
|
634 |
typedef struct ASN1_PRIMITIVE_FUNCS_st {
|
|
|
635 |
void *app_data;
|
|
|
636 |
unsigned long flags;
|
|
|
637 |
ASN1_ex_new_func *prim_new;
|
|
|
638 |
ASN1_ex_free_func *prim_free;
|
|
|
639 |
ASN1_ex_free_func *prim_clear;
|
|
|
640 |
ASN1_primitive_c2i *prim_c2i;
|
|
|
641 |
ASN1_primitive_i2c *prim_i2c;
|
|
|
642 |
} ASN1_PRIMITIVE_FUNCS;
|
|
|
643 |
|
|
|
644 |
/* This is the ASN1_AUX structure: it handles various
|
|
|
645 |
* miscellaneous requirements. For example the use of
|
|
|
646 |
* reference counts and an informational callback.
|
|
|
647 |
*
|
|
|
648 |
* The "informational callback" is called at various
|
|
|
649 |
* points during the ASN1 encoding and decoding. It can
|
|
|
650 |
* be used to provide minor customisation of the structures
|
|
|
651 |
* used. This is most useful where the supplied routines
|
|
|
652 |
* *almost* do the right thing but need some extra help
|
|
|
653 |
* at a few points. If the callback returns zero then
|
|
|
654 |
* it is assumed a fatal error has occurred and the
|
|
|
655 |
* main operation should be abandoned.
|
|
|
656 |
*
|
|
|
657 |
* If major changes in the default behaviour are required
|
|
|
658 |
* then an external type is more appropriate.
|
|
|
659 |
*/
|
|
|
660 |
|
|
|
661 |
typedef int ASN1_aux_cb(int operation, ASN1_VALUE **in, const ASN1_ITEM *it);
|
|
|
662 |
|
|
|
663 |
typedef struct ASN1_AUX_st {
|
|
|
664 |
void *app_data;
|
|
|
665 |
int flags;
|
|
|
666 |
int ref_offset; /* Offset of reference value */
|
|
|
667 |
int ref_lock; /* Lock type to use */
|
|
|
668 |
ASN1_aux_cb *asn1_cb;
|
|
|
669 |
int enc_offset; /* Offset of ASN1_ENCODING structure */
|
|
|
670 |
} ASN1_AUX;
|
|
|
671 |
|
|
|
672 |
/* Flags in ASN1_AUX */
|
|
|
673 |
|
|
|
674 |
/* Use a reference count */
|
|
|
675 |
#define ASN1_AFLG_REFCOUNT 1
|
|
|
676 |
/* Save the encoding of structure (useful for signatures) */
|
|
|
677 |
#define ASN1_AFLG_ENCODING 2
|
|
|
678 |
/* The Sequence length is invalid */
|
|
|
679 |
#define ASN1_AFLG_BROKEN 4
|
|
|
680 |
|
|
|
681 |
/* operation values for asn1_cb */
|
|
|
682 |
|
|
|
683 |
#define ASN1_OP_NEW_PRE 0
|
|
|
684 |
#define ASN1_OP_NEW_POST 1
|
|
|
685 |
#define ASN1_OP_FREE_PRE 2
|
|
|
686 |
#define ASN1_OP_FREE_POST 3
|
|
|
687 |
#define ASN1_OP_D2I_PRE 4
|
|
|
688 |
#define ASN1_OP_D2I_POST 5
|
|
|
689 |
#define ASN1_OP_I2D_PRE 6
|
|
|
690 |
#define ASN1_OP_I2D_POST 7
|
|
|
691 |
|
|
|
692 |
/* Macro to implement a primitive type */
|
|
|
693 |
#define IMPLEMENT_ASN1_TYPE(stname) IMPLEMENT_ASN1_TYPE_ex(stname, stname, 0)
|
|
|
694 |
#define IMPLEMENT_ASN1_TYPE_ex(itname, vname, ex) \
|
|
|
695 |
ASN1_ITEM_start(itname) \
|
|
|
696 |
ASN1_ITYPE_PRIMITIVE, V_##vname, NULL, 0, NULL, ex, #itname \
|
|
|
697 |
ASN1_ITEM_end(itname)
|
|
|
698 |
|
|
|
699 |
/* Macro to implement a multi string type */
|
|
|
700 |
#define IMPLEMENT_ASN1_MSTRING(itname, mask) \
|
|
|
701 |
ASN1_ITEM_start(itname) \
|
|
|
702 |
ASN1_ITYPE_MSTRING, mask, NULL, 0, NULL, sizeof(ASN1_STRING), #itname \
|
|
|
703 |
ASN1_ITEM_end(itname)
|
|
|
704 |
|
|
|
705 |
/* Macro to implement an ASN1_ITEM in terms of old style funcs */
|
|
|
706 |
|
|
|
707 |
#define IMPLEMENT_COMPAT_ASN1(sname) IMPLEMENT_COMPAT_ASN1_type(sname, V_ASN1_SEQUENCE)
|
|
|
708 |
|
|
|
709 |
#define IMPLEMENT_COMPAT_ASN1_type(sname, tag) \
|
|
|
710 |
static const ASN1_COMPAT_FUNCS sname##_ff = { \
|
|
|
711 |
(ASN1_new_func *)sname##_new, \
|
|
|
712 |
(ASN1_free_func *)sname##_free, \
|
|
|
713 |
(ASN1_d2i_func *)d2i_##sname, \
|
|
|
714 |
(ASN1_i2d_func *)i2d_##sname, \
|
|
|
715 |
}; \
|
|
|
716 |
ASN1_ITEM_start(sname) \
|
|
|
717 |
ASN1_ITYPE_COMPAT, \
|
|
|
718 |
tag, \
|
|
|
719 |
NULL, \
|
|
|
720 |
0, \
|
|
|
721 |
&sname##_ff, \
|
|
|
722 |
0, \
|
|
|
723 |
#sname \
|
|
|
724 |
ASN1_ITEM_end(sname)
|
|
|
725 |
|
|
|
726 |
#define IMPLEMENT_EXTERN_ASN1(sname, tag, fptrs) \
|
|
|
727 |
ASN1_ITEM_start(sname) \
|
|
|
728 |
ASN1_ITYPE_EXTERN, \
|
|
|
729 |
tag, \
|
|
|
730 |
NULL, \
|
|
|
731 |
0, \
|
|
|
732 |
&fptrs, \
|
|
|
733 |
0, \
|
|
|
734 |
#sname \
|
|
|
735 |
ASN1_ITEM_end(sname)
|
|
|
736 |
|
|
|
737 |
/* Macro to implement standard functions in terms of ASN1_ITEM structures */
|
|
|
738 |
|
|
|
739 |
#define IMPLEMENT_ASN1_FUNCTIONS(stname) IMPLEMENT_ASN1_FUNCTIONS_fname(stname, stname, stname)
|
|
|
740 |
|
|
|
741 |
#define IMPLEMENT_ASN1_FUNCTIONS_name(stname, itname) IMPLEMENT_ASN1_FUNCTIONS_fname(stname, itname, itname)
|
|
|
742 |
|
|
|
743 |
#define IMPLEMENT_ASN1_FUNCTIONS_ENCODE_name(stname, itname) \
|
|
|
744 |
IMPLEMENT_ASN1_FUNCTIONS_ENCODE_fname(stname, itname, itname)
|
|
|
745 |
|
|
|
746 |
#define IMPLEMENT_ASN1_ALLOC_FUNCTIONS_fname(stname, itname, fname) \
|
|
|
747 |
stname *fname##_new(void) \
|
|
|
748 |
{ \
|
|
|
749 |
return (stname *)ASN1_item_new(ASN1_ITEM_rptr(itname)); \
|
|
|
750 |
} \
|
|
|
751 |
void fname##_free(stname *a) \
|
|
|
752 |
{ \
|
|
|
753 |
ASN1_item_free((ASN1_VALUE *)a, ASN1_ITEM_rptr(itname)); \
|
|
|
754 |
}
|
|
|
755 |
|
|
|
756 |
#define IMPLEMENT_ASN1_FUNCTIONS_fname(stname, itname, fname) \
|
|
|
757 |
IMPLEMENT_ASN1_ENCODE_FUNCTIONS_fname(stname, itname, fname) \
|
|
|
758 |
IMPLEMENT_ASN1_ALLOC_FUNCTIONS_fname(stname, itname, fname)
|
|
|
759 |
|
|
|
760 |
#define IMPLEMENT_ASN1_ENCODE_FUNCTIONS_fname(stname, itname, fname) \
|
|
|
761 |
stname *d2i_##fname(stname **a, unsigned char **in, long len) \
|
|
|
762 |
{ \
|
|
|
763 |
return (stname *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, ASN1_ITEM_rptr(itname));\
|
|
|
764 |
} \
|
|
|
765 |
int i2d_##fname(stname *a, unsigned char **out) \
|
|
|
766 |
{ \
|
|
|
767 |
return ASN1_item_i2d((ASN1_VALUE *)a, out, ASN1_ITEM_rptr(itname));\
|
|
|
768 |
}
|
|
|
769 |
|
|
|
770 |
/* This includes evil casts to remove const: they will go away when full
|
|
|
771 |
* ASN1 constification is done.
|
|
|
772 |
*/
|
|
|
773 |
#define IMPLEMENT_ASN1_ENCODE_FUNCTIONS_const_fname(stname, itname, fname) \
|
|
|
774 |
stname *d2i_##fname(stname **a, const unsigned char **in, long len) \
|
|
|
775 |
{ \
|
|
|
776 |
return (stname *)ASN1_item_d2i((ASN1_VALUE **)a, (unsigned char **)in, len, ASN1_ITEM_rptr(itname));\
|
|
|
777 |
} \
|
|
|
778 |
int i2d_##fname(const stname *a, unsigned char **out) \
|
|
|
779 |
{ \
|
|
|
780 |
return ASN1_item_i2d((ASN1_VALUE *)a, out, ASN1_ITEM_rptr(itname));\
|
|
|
781 |
}
|
|
|
782 |
|
|
|
783 |
#define IMPLEMENT_ASN1_DUP_FUNCTION(stname) \
|
|
|
784 |
stname * stname##_dup(stname *x) \
|
|
|
785 |
{ \
|
|
|
786 |
return ASN1_item_dup(ASN1_ITEM_rptr(stname), x); \
|
|
|
787 |
}
|
|
|
788 |
|
|
|
789 |
#define IMPLEMENT_ASN1_FUNCTIONS_const(name) \
|
|
|
790 |
IMPLEMENT_ASN1_FUNCTIONS_const_fname(name, name, name)
|
|
|
791 |
|
|
|
792 |
#define IMPLEMENT_ASN1_FUNCTIONS_const_fname(stname, itname, fname) \
|
|
|
793 |
IMPLEMENT_ASN1_ENCODE_FUNCTIONS_const_fname(stname, itname, fname) \
|
|
|
794 |
IMPLEMENT_ASN1_ALLOC_FUNCTIONS_fname(stname, itname, fname)
|
|
|
795 |
|
|
|
796 |
/* external definitions for primitive types */
|
|
|
797 |
|
|
|
798 |
DECLARE_ASN1_ITEM(ASN1_BOOLEAN)
|
|
|
799 |
DECLARE_ASN1_ITEM(ASN1_TBOOLEAN)
|
|
|
800 |
DECLARE_ASN1_ITEM(ASN1_FBOOLEAN)
|
|
|
801 |
DECLARE_ASN1_ITEM(ASN1_ANY)
|
|
|
802 |
DECLARE_ASN1_ITEM(ASN1_SEQUENCE)
|
|
|
803 |
DECLARE_ASN1_ITEM(CBIGNUM)
|
|
|
804 |
DECLARE_ASN1_ITEM(BIGNUM)
|
|
|
805 |
DECLARE_ASN1_ITEM(LONG)
|
|
|
806 |
DECLARE_ASN1_ITEM(ZLONG)
|
|
|
807 |
|
|
|
808 |
DECLARE_STACK_OF(ASN1_VALUE)
|
|
|
809 |
|
|
|
810 |
/* Functions used internally by the ASN1 code */
|
|
|
811 |
|
|
|
812 |
int ASN1_item_ex_new(ASN1_VALUE **pval, const ASN1_ITEM *it);
|
|
|
813 |
void ASN1_item_ex_free(ASN1_VALUE **pval, const ASN1_ITEM *it);
|
|
|
814 |
int ASN1_template_new(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt);
|
|
|
815 |
int ASN1_primitive_new(ASN1_VALUE **pval, const ASN1_ITEM *it);
|
|
|
816 |
|
|
|
817 |
void ASN1_template_free(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt);
|
|
|
818 |
int ASN1_template_d2i(ASN1_VALUE **pval, unsigned char **in, long len, const ASN1_TEMPLATE *tt);
|
|
|
819 |
int ASN1_item_ex_d2i(ASN1_VALUE **pval, unsigned char **in, long len, const ASN1_ITEM *it,
|
|
|
820 |
int tag, int aclass, char opt, ASN1_TLC *ctx);
|
|
|
821 |
|
|
|
822 |
int ASN1_item_ex_i2d(ASN1_VALUE **pval, unsigned char **out, const ASN1_ITEM *it, int tag, int aclass);
|
|
|
823 |
int ASN1_template_i2d(ASN1_VALUE **pval, unsigned char **out, const ASN1_TEMPLATE *tt);
|
|
|
824 |
void ASN1_primitive_free(ASN1_VALUE **pval, const ASN1_ITEM *it);
|
|
|
825 |
|
|
|
826 |
int asn1_ex_i2c(ASN1_VALUE **pval, unsigned char *cont, int *putype, const ASN1_ITEM *it);
|
|
|
827 |
int asn1_ex_c2i(ASN1_VALUE **pval, unsigned char *cont, int len, int utype, char *free_cont, const ASN1_ITEM *it);
|
|
|
828 |
|
|
|
829 |
int asn1_get_choice_selector(ASN1_VALUE **pval, const ASN1_ITEM *it);
|
|
|
830 |
int asn1_set_choice_selector(ASN1_VALUE **pval, int value, const ASN1_ITEM *it);
|
|
|
831 |
|
|
|
832 |
ASN1_VALUE ** asn1_get_field_ptr(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt);
|
|
|
833 |
|
|
|
834 |
const ASN1_TEMPLATE *asn1_do_adb(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt, int nullerr);
|
|
|
835 |
|
|
|
836 |
int asn1_do_lock(ASN1_VALUE **pval, int op, const ASN1_ITEM *it);
|
|
|
837 |
|
|
|
838 |
void asn1_enc_init(ASN1_VALUE **pval, const ASN1_ITEM *it);
|
|
|
839 |
void asn1_enc_free(ASN1_VALUE **pval, const ASN1_ITEM *it);
|
|
|
840 |
int asn1_enc_restore(int *len, unsigned char **out, ASN1_VALUE **pval, const ASN1_ITEM *it);
|
|
|
841 |
int asn1_enc_save(ASN1_VALUE **pval, unsigned char *in, int inlen, const ASN1_ITEM *it);
|
|
|
842 |
|
|
|
843 |
#ifdef __cplusplus
|
|
|
844 |
}
|
|
|
845 |
#endif
|
|
|
846 |
#endif
|
|
|
847 |
|