1 /* $OpenBSD: ocsp_asn.c,v 1.12 2024/07/08 14:53:11 beck Exp $ */
2 /* Written by Dr Stephen N Henson (steve@openssl.org) 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 #include <openssl/asn1.h>
59 #include <openssl/asn1t.h>
60 #include <openssl/ocsp.h>
61
62 #include "ocsp_local.h"
63
64 static const ASN1_TEMPLATE OCSP_SIGNATURE_seq_tt[] = {
65 {
66 .flags = 0,
67 .tag = 0,
68 .offset = offsetof(OCSP_SIGNATURE, signatureAlgorithm),
69 .field_name = "signatureAlgorithm",
70 .item = &X509_ALGOR_it,
71 },
72 {
73 .flags = 0,
74 .tag = 0,
75 .offset = offsetof(OCSP_SIGNATURE, signature),
76 .field_name = "signature",
77 .item = &ASN1_BIT_STRING_it,
78 },
79 {
80 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_SEQUENCE_OF | ASN1_TFLG_OPTIONAL,
81 .tag = 0,
82 .offset = offsetof(OCSP_SIGNATURE, certs),
83 .field_name = "certs",
84 .item = &X509_it,
85 },
86 };
87
88 const ASN1_ITEM OCSP_SIGNATURE_it = {
89 .itype = ASN1_ITYPE_SEQUENCE,
90 .utype = V_ASN1_SEQUENCE,
91 .templates = OCSP_SIGNATURE_seq_tt,
92 .tcount = sizeof(OCSP_SIGNATURE_seq_tt) / sizeof(ASN1_TEMPLATE),
93 .funcs = NULL,
94 .size = sizeof(OCSP_SIGNATURE),
95 .sname = "OCSP_SIGNATURE",
96 };
97 LCRYPTO_ALIAS(OCSP_SIGNATURE_it);
98
99
100 OCSP_SIGNATURE *
d2i_OCSP_SIGNATURE(OCSP_SIGNATURE ** a,const unsigned char ** in,long len)101 d2i_OCSP_SIGNATURE(OCSP_SIGNATURE **a, const unsigned char **in, long len)
102 {
103 return (OCSP_SIGNATURE *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
104 &OCSP_SIGNATURE_it);
105 }
106 LCRYPTO_ALIAS(d2i_OCSP_SIGNATURE);
107
108 int
i2d_OCSP_SIGNATURE(OCSP_SIGNATURE * a,unsigned char ** out)109 i2d_OCSP_SIGNATURE(OCSP_SIGNATURE *a, unsigned char **out)
110 {
111 return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_SIGNATURE_it);
112 }
113 LCRYPTO_ALIAS(i2d_OCSP_SIGNATURE);
114
115 OCSP_SIGNATURE *
OCSP_SIGNATURE_new(void)116 OCSP_SIGNATURE_new(void)
117 {
118 return (OCSP_SIGNATURE *)ASN1_item_new(&OCSP_SIGNATURE_it);
119 }
120 LCRYPTO_ALIAS(OCSP_SIGNATURE_new);
121
122 void
OCSP_SIGNATURE_free(OCSP_SIGNATURE * a)123 OCSP_SIGNATURE_free(OCSP_SIGNATURE *a)
124 {
125 ASN1_item_free((ASN1_VALUE *)a, &OCSP_SIGNATURE_it);
126 }
127 LCRYPTO_ALIAS(OCSP_SIGNATURE_free);
128
129 static const ASN1_TEMPLATE OCSP_CERTID_seq_tt[] = {
130 {
131 .flags = 0,
132 .tag = 0,
133 .offset = offsetof(OCSP_CERTID, hashAlgorithm),
134 .field_name = "hashAlgorithm",
135 .item = &X509_ALGOR_it,
136 },
137 {
138 .flags = 0,
139 .tag = 0,
140 .offset = offsetof(OCSP_CERTID, issuerNameHash),
141 .field_name = "issuerNameHash",
142 .item = &ASN1_OCTET_STRING_it,
143 },
144 {
145 .flags = 0,
146 .tag = 0,
147 .offset = offsetof(OCSP_CERTID, issuerKeyHash),
148 .field_name = "issuerKeyHash",
149 .item = &ASN1_OCTET_STRING_it,
150 },
151 {
152 .flags = 0,
153 .tag = 0,
154 .offset = offsetof(OCSP_CERTID, serialNumber),
155 .field_name = "serialNumber",
156 .item = &ASN1_INTEGER_it,
157 },
158 };
159
160 const ASN1_ITEM OCSP_CERTID_it = {
161 .itype = ASN1_ITYPE_SEQUENCE,
162 .utype = V_ASN1_SEQUENCE,
163 .templates = OCSP_CERTID_seq_tt,
164 .tcount = sizeof(OCSP_CERTID_seq_tt) / sizeof(ASN1_TEMPLATE),
165 .funcs = NULL,
166 .size = sizeof(OCSP_CERTID),
167 .sname = "OCSP_CERTID",
168 };
169 LCRYPTO_ALIAS(OCSP_CERTID_it);
170
171
172 OCSP_CERTID *
d2i_OCSP_CERTID(OCSP_CERTID ** a,const unsigned char ** in,long len)173 d2i_OCSP_CERTID(OCSP_CERTID **a, const unsigned char **in, long len)
174 {
175 return (OCSP_CERTID *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
176 &OCSP_CERTID_it);
177 }
178 LCRYPTO_ALIAS(d2i_OCSP_CERTID);
179
180 int
i2d_OCSP_CERTID(OCSP_CERTID * a,unsigned char ** out)181 i2d_OCSP_CERTID(OCSP_CERTID *a, unsigned char **out)
182 {
183 return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_CERTID_it);
184 }
185 LCRYPTO_ALIAS(i2d_OCSP_CERTID);
186
187 OCSP_CERTID *
OCSP_CERTID_new(void)188 OCSP_CERTID_new(void)
189 {
190 return (OCSP_CERTID *)ASN1_item_new(&OCSP_CERTID_it);
191 }
192 LCRYPTO_ALIAS(OCSP_CERTID_new);
193
194 void
OCSP_CERTID_free(OCSP_CERTID * a)195 OCSP_CERTID_free(OCSP_CERTID *a)
196 {
197 ASN1_item_free((ASN1_VALUE *)a, &OCSP_CERTID_it);
198 }
199 LCRYPTO_ALIAS(OCSP_CERTID_free);
200
201 static const ASN1_TEMPLATE OCSP_ONEREQ_seq_tt[] = {
202 {
203 .flags = 0,
204 .tag = 0,
205 .offset = offsetof(OCSP_ONEREQ, reqCert),
206 .field_name = "reqCert",
207 .item = &OCSP_CERTID_it,
208 },
209 {
210 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_SEQUENCE_OF | ASN1_TFLG_OPTIONAL,
211 .tag = 0,
212 .offset = offsetof(OCSP_ONEREQ, singleRequestExtensions),
213 .field_name = "singleRequestExtensions",
214 .item = &X509_EXTENSION_it,
215 },
216 };
217
218 const ASN1_ITEM OCSP_ONEREQ_it = {
219 .itype = ASN1_ITYPE_SEQUENCE,
220 .utype = V_ASN1_SEQUENCE,
221 .templates = OCSP_ONEREQ_seq_tt,
222 .tcount = sizeof(OCSP_ONEREQ_seq_tt) / sizeof(ASN1_TEMPLATE),
223 .funcs = NULL,
224 .size = sizeof(OCSP_ONEREQ),
225 .sname = "OCSP_ONEREQ",
226 };
227 LCRYPTO_ALIAS(OCSP_ONEREQ_it);
228
229
230 OCSP_ONEREQ *
d2i_OCSP_ONEREQ(OCSP_ONEREQ ** a,const unsigned char ** in,long len)231 d2i_OCSP_ONEREQ(OCSP_ONEREQ **a, const unsigned char **in, long len)
232 {
233 return (OCSP_ONEREQ *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
234 &OCSP_ONEREQ_it);
235 }
236 LCRYPTO_ALIAS(d2i_OCSP_ONEREQ);
237
238 int
i2d_OCSP_ONEREQ(OCSP_ONEREQ * a,unsigned char ** out)239 i2d_OCSP_ONEREQ(OCSP_ONEREQ *a, unsigned char **out)
240 {
241 return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_ONEREQ_it);
242 }
243 LCRYPTO_ALIAS(i2d_OCSP_ONEREQ);
244
245 OCSP_ONEREQ *
OCSP_ONEREQ_new(void)246 OCSP_ONEREQ_new(void)
247 {
248 return (OCSP_ONEREQ *)ASN1_item_new(&OCSP_ONEREQ_it);
249 }
250 LCRYPTO_ALIAS(OCSP_ONEREQ_new);
251
252 void
OCSP_ONEREQ_free(OCSP_ONEREQ * a)253 OCSP_ONEREQ_free(OCSP_ONEREQ *a)
254 {
255 ASN1_item_free((ASN1_VALUE *)a, &OCSP_ONEREQ_it);
256 }
257 LCRYPTO_ALIAS(OCSP_ONEREQ_free);
258
259 static const ASN1_TEMPLATE OCSP_REQINFO_seq_tt[] = {
260 {
261 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_OPTIONAL,
262 .tag = 0,
263 .offset = offsetof(OCSP_REQINFO, version),
264 .field_name = "version",
265 .item = &ASN1_INTEGER_it,
266 },
267 {
268 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_OPTIONAL,
269 .tag = 1,
270 .offset = offsetof(OCSP_REQINFO, requestorName),
271 .field_name = "requestorName",
272 .item = &GENERAL_NAME_it,
273 },
274 {
275 .flags = ASN1_TFLG_SEQUENCE_OF,
276 .tag = 0,
277 .offset = offsetof(OCSP_REQINFO, requestList),
278 .field_name = "requestList",
279 .item = &OCSP_ONEREQ_it,
280 },
281 {
282 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_SEQUENCE_OF | ASN1_TFLG_OPTIONAL,
283 .tag = 2,
284 .offset = offsetof(OCSP_REQINFO, requestExtensions),
285 .field_name = "requestExtensions",
286 .item = &X509_EXTENSION_it,
287 },
288 };
289
290 const ASN1_ITEM OCSP_REQINFO_it = {
291 .itype = ASN1_ITYPE_SEQUENCE,
292 .utype = V_ASN1_SEQUENCE,
293 .templates = OCSP_REQINFO_seq_tt,
294 .tcount = sizeof(OCSP_REQINFO_seq_tt) / sizeof(ASN1_TEMPLATE),
295 .funcs = NULL,
296 .size = sizeof(OCSP_REQINFO),
297 .sname = "OCSP_REQINFO",
298 };
299 LCRYPTO_ALIAS(OCSP_REQINFO_it);
300
301
302 OCSP_REQINFO *
d2i_OCSP_REQINFO(OCSP_REQINFO ** a,const unsigned char ** in,long len)303 d2i_OCSP_REQINFO(OCSP_REQINFO **a, const unsigned char **in, long len)
304 {
305 return (OCSP_REQINFO *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
306 &OCSP_REQINFO_it);
307 }
308 LCRYPTO_ALIAS(d2i_OCSP_REQINFO);
309
310 int
i2d_OCSP_REQINFO(OCSP_REQINFO * a,unsigned char ** out)311 i2d_OCSP_REQINFO(OCSP_REQINFO *a, unsigned char **out)
312 {
313 return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_REQINFO_it);
314 }
315 LCRYPTO_ALIAS(i2d_OCSP_REQINFO);
316
317 OCSP_REQINFO *
OCSP_REQINFO_new(void)318 OCSP_REQINFO_new(void)
319 {
320 return (OCSP_REQINFO *)ASN1_item_new(&OCSP_REQINFO_it);
321 }
322 LCRYPTO_ALIAS(OCSP_REQINFO_new);
323
324 void
OCSP_REQINFO_free(OCSP_REQINFO * a)325 OCSP_REQINFO_free(OCSP_REQINFO *a)
326 {
327 ASN1_item_free((ASN1_VALUE *)a, &OCSP_REQINFO_it);
328 }
329 LCRYPTO_ALIAS(OCSP_REQINFO_free);
330
331 static const ASN1_TEMPLATE OCSP_REQUEST_seq_tt[] = {
332 {
333 .flags = 0,
334 .tag = 0,
335 .offset = offsetof(OCSP_REQUEST, tbsRequest),
336 .field_name = "tbsRequest",
337 .item = &OCSP_REQINFO_it,
338 },
339 {
340 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_OPTIONAL,
341 .tag = 0,
342 .offset = offsetof(OCSP_REQUEST, optionalSignature),
343 .field_name = "optionalSignature",
344 .item = &OCSP_SIGNATURE_it,
345 },
346 };
347
348 const ASN1_ITEM OCSP_REQUEST_it = {
349 .itype = ASN1_ITYPE_SEQUENCE,
350 .utype = V_ASN1_SEQUENCE,
351 .templates = OCSP_REQUEST_seq_tt,
352 .tcount = sizeof(OCSP_REQUEST_seq_tt) / sizeof(ASN1_TEMPLATE),
353 .funcs = NULL,
354 .size = sizeof(OCSP_REQUEST),
355 .sname = "OCSP_REQUEST",
356 };
357 LCRYPTO_ALIAS(OCSP_REQUEST_it);
358
359 OCSP_REQUEST *
d2i_OCSP_REQUEST(OCSP_REQUEST ** a,const unsigned char ** in,long len)360 d2i_OCSP_REQUEST(OCSP_REQUEST **a, const unsigned char **in, long len)
361 {
362 return (OCSP_REQUEST *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
363 &OCSP_REQUEST_it);
364 }
365 LCRYPTO_ALIAS(d2i_OCSP_REQUEST);
366
367 int
i2d_OCSP_REQUEST(OCSP_REQUEST * a,unsigned char ** out)368 i2d_OCSP_REQUEST(OCSP_REQUEST *a, unsigned char **out)
369 {
370 return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_REQUEST_it);
371 }
372 LCRYPTO_ALIAS(i2d_OCSP_REQUEST);
373
374 OCSP_REQUEST *
d2i_OCSP_REQUEST_bio(BIO * bp,OCSP_REQUEST ** a)375 d2i_OCSP_REQUEST_bio(BIO *bp, OCSP_REQUEST **a)
376 {
377 return ASN1_item_d2i_bio(&OCSP_REQUEST_it, bp, a);
378 }
379 LCRYPTO_ALIAS(d2i_OCSP_REQUEST_bio);
380
381 int
i2d_OCSP_REQUEST_bio(BIO * bp,OCSP_REQUEST * a)382 i2d_OCSP_REQUEST_bio(BIO *bp, OCSP_REQUEST *a)
383 {
384 return ASN1_item_i2d_bio(&OCSP_REQUEST_it, bp, a);
385 }
386 LCRYPTO_ALIAS(i2d_OCSP_REQUEST_bio);
387
388 OCSP_REQUEST *
OCSP_REQUEST_new(void)389 OCSP_REQUEST_new(void)
390 {
391 return (OCSP_REQUEST *)ASN1_item_new(&OCSP_REQUEST_it);
392 }
393 LCRYPTO_ALIAS(OCSP_REQUEST_new);
394
395 void
OCSP_REQUEST_free(OCSP_REQUEST * a)396 OCSP_REQUEST_free(OCSP_REQUEST *a)
397 {
398 ASN1_item_free((ASN1_VALUE *)a, &OCSP_REQUEST_it);
399 }
400 LCRYPTO_ALIAS(OCSP_REQUEST_free);
401
402 /* OCSP_RESPONSE templates */
403
404 static const ASN1_TEMPLATE OCSP_RESPBYTES_seq_tt[] = {
405 {
406 .flags = 0,
407 .tag = 0,
408 .offset = offsetof(OCSP_RESPBYTES, responseType),
409 .field_name = "responseType",
410 .item = &ASN1_OBJECT_it,
411 },
412 {
413 .flags = 0,
414 .tag = 0,
415 .offset = offsetof(OCSP_RESPBYTES, response),
416 .field_name = "response",
417 .item = &ASN1_OCTET_STRING_it,
418 },
419 };
420
421 const ASN1_ITEM OCSP_RESPBYTES_it = {
422 .itype = ASN1_ITYPE_SEQUENCE,
423 .utype = V_ASN1_SEQUENCE,
424 .templates = OCSP_RESPBYTES_seq_tt,
425 .tcount = sizeof(OCSP_RESPBYTES_seq_tt) / sizeof(ASN1_TEMPLATE),
426 .funcs = NULL,
427 .size = sizeof(OCSP_RESPBYTES),
428 .sname = "OCSP_RESPBYTES",
429 };
430 LCRYPTO_ALIAS(OCSP_RESPBYTES_it);
431
432
433 OCSP_RESPBYTES *
d2i_OCSP_RESPBYTES(OCSP_RESPBYTES ** a,const unsigned char ** in,long len)434 d2i_OCSP_RESPBYTES(OCSP_RESPBYTES **a, const unsigned char **in, long len)
435 {
436 return (OCSP_RESPBYTES *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
437 &OCSP_RESPBYTES_it);
438 }
439 LCRYPTO_ALIAS(d2i_OCSP_RESPBYTES);
440
441 int
i2d_OCSP_RESPBYTES(OCSP_RESPBYTES * a,unsigned char ** out)442 i2d_OCSP_RESPBYTES(OCSP_RESPBYTES *a, unsigned char **out)
443 {
444 return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_RESPBYTES_it);
445 }
446 LCRYPTO_ALIAS(i2d_OCSP_RESPBYTES);
447
448 OCSP_RESPBYTES *
OCSP_RESPBYTES_new(void)449 OCSP_RESPBYTES_new(void)
450 {
451 return (OCSP_RESPBYTES *)ASN1_item_new(&OCSP_RESPBYTES_it);
452 }
453 LCRYPTO_ALIAS(OCSP_RESPBYTES_new);
454
455 void
OCSP_RESPBYTES_free(OCSP_RESPBYTES * a)456 OCSP_RESPBYTES_free(OCSP_RESPBYTES *a)
457 {
458 ASN1_item_free((ASN1_VALUE *)a, &OCSP_RESPBYTES_it);
459 }
460 LCRYPTO_ALIAS(OCSP_RESPBYTES_free);
461
462 static const ASN1_TEMPLATE OCSP_RESPONSE_seq_tt[] = {
463 {
464 .flags = 0,
465 .tag = 0,
466 .offset = offsetof(OCSP_RESPONSE, responseStatus),
467 .field_name = "responseStatus",
468 .item = &ASN1_ENUMERATED_it,
469 },
470 {
471 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_OPTIONAL,
472 .tag = 0,
473 .offset = offsetof(OCSP_RESPONSE, responseBytes),
474 .field_name = "responseBytes",
475 .item = &OCSP_RESPBYTES_it,
476 },
477 };
478
479 const ASN1_ITEM OCSP_RESPONSE_it = {
480 .itype = ASN1_ITYPE_SEQUENCE,
481 .utype = V_ASN1_SEQUENCE,
482 .templates = OCSP_RESPONSE_seq_tt,
483 .tcount = sizeof(OCSP_RESPONSE_seq_tt) / sizeof(ASN1_TEMPLATE),
484 .funcs = NULL,
485 .size = sizeof(OCSP_RESPONSE),
486 .sname = "OCSP_RESPONSE",
487 };
488 LCRYPTO_ALIAS(OCSP_RESPONSE_it);
489
490
491 OCSP_RESPONSE *
d2i_OCSP_RESPONSE(OCSP_RESPONSE ** a,const unsigned char ** in,long len)492 d2i_OCSP_RESPONSE(OCSP_RESPONSE **a, const unsigned char **in, long len)
493 {
494 return (OCSP_RESPONSE *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
495 &OCSP_RESPONSE_it);
496 }
497 LCRYPTO_ALIAS(d2i_OCSP_RESPONSE);
498
499 int
i2d_OCSP_RESPONSE(OCSP_RESPONSE * a,unsigned char ** out)500 i2d_OCSP_RESPONSE(OCSP_RESPONSE *a, unsigned char **out)
501 {
502 return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_RESPONSE_it);
503 }
504 LCRYPTO_ALIAS(i2d_OCSP_RESPONSE);
505
506 OCSP_RESPONSE *
d2i_OCSP_RESPONSE_bio(BIO * bp,OCSP_RESPONSE ** a)507 d2i_OCSP_RESPONSE_bio(BIO *bp, OCSP_RESPONSE **a)
508 {
509 return ASN1_item_d2i_bio(&OCSP_RESPONSE_it, bp, a);
510 }
511 LCRYPTO_ALIAS(d2i_OCSP_RESPONSE_bio);
512
513 int
i2d_OCSP_RESPONSE_bio(BIO * bp,OCSP_RESPONSE * a)514 i2d_OCSP_RESPONSE_bio(BIO *bp, OCSP_RESPONSE *a)
515 {
516 return ASN1_item_i2d_bio(&OCSP_RESPONSE_it, bp, a);
517 }
518 LCRYPTO_ALIAS(i2d_OCSP_RESPONSE_bio);
519
520 OCSP_RESPONSE *
OCSP_RESPONSE_new(void)521 OCSP_RESPONSE_new(void)
522 {
523 return (OCSP_RESPONSE *)ASN1_item_new(&OCSP_RESPONSE_it);
524 }
525 LCRYPTO_ALIAS(OCSP_RESPONSE_new);
526
527 void
OCSP_RESPONSE_free(OCSP_RESPONSE * a)528 OCSP_RESPONSE_free(OCSP_RESPONSE *a)
529 {
530 ASN1_item_free((ASN1_VALUE *)a, &OCSP_RESPONSE_it);
531 }
532 LCRYPTO_ALIAS(OCSP_RESPONSE_free);
533
534 static const ASN1_TEMPLATE OCSP_RESPID_ch_tt[] = {
535 {
536 .flags = ASN1_TFLG_EXPLICIT,
537 .tag = 1,
538 .offset = offsetof(OCSP_RESPID, value.byName),
539 .field_name = "value.byName",
540 .item = &X509_NAME_it,
541 },
542 {
543 .flags = ASN1_TFLG_EXPLICIT,
544 .tag = 2,
545 .offset = offsetof(OCSP_RESPID, value.byKey),
546 .field_name = "value.byKey",
547 .item = &ASN1_OCTET_STRING_it,
548 },
549 };
550
551 const ASN1_ITEM OCSP_RESPID_it = {
552 .itype = ASN1_ITYPE_CHOICE,
553 .utype = offsetof(OCSP_RESPID, type),
554 .templates = OCSP_RESPID_ch_tt,
555 .tcount = sizeof(OCSP_RESPID_ch_tt) / sizeof(ASN1_TEMPLATE),
556 .funcs = NULL,
557 .size = sizeof(OCSP_RESPID),
558 .sname = "OCSP_RESPID",
559 };
560 LCRYPTO_ALIAS(OCSP_RESPID_it);
561
562
563 OCSP_RESPID *
d2i_OCSP_RESPID(OCSP_RESPID ** a,const unsigned char ** in,long len)564 d2i_OCSP_RESPID(OCSP_RESPID **a, const unsigned char **in, long len)
565 {
566 return (OCSP_RESPID *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
567 &OCSP_RESPID_it);
568 }
569 LCRYPTO_ALIAS(d2i_OCSP_RESPID);
570
571 int
i2d_OCSP_RESPID(OCSP_RESPID * a,unsigned char ** out)572 i2d_OCSP_RESPID(OCSP_RESPID *a, unsigned char **out)
573 {
574 return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_RESPID_it);
575 }
576 LCRYPTO_ALIAS(i2d_OCSP_RESPID);
577
578 OCSP_RESPID *
OCSP_RESPID_new(void)579 OCSP_RESPID_new(void)
580 {
581 return (OCSP_RESPID *)ASN1_item_new(&OCSP_RESPID_it);
582 }
583 LCRYPTO_ALIAS(OCSP_RESPID_new);
584
585 void
OCSP_RESPID_free(OCSP_RESPID * a)586 OCSP_RESPID_free(OCSP_RESPID *a)
587 {
588 ASN1_item_free((ASN1_VALUE *)a, &OCSP_RESPID_it);
589 }
590 LCRYPTO_ALIAS(OCSP_RESPID_free);
591
592 static const ASN1_TEMPLATE OCSP_REVOKEDINFO_seq_tt[] = {
593 {
594 .flags = 0,
595 .tag = 0,
596 .offset = offsetof(OCSP_REVOKEDINFO, revocationTime),
597 .field_name = "revocationTime",
598 .item = &ASN1_GENERALIZEDTIME_it,
599 },
600 {
601 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_OPTIONAL,
602 .tag = 0,
603 .offset = offsetof(OCSP_REVOKEDINFO, revocationReason),
604 .field_name = "revocationReason",
605 .item = &ASN1_ENUMERATED_it,
606 },
607 };
608
609 const ASN1_ITEM OCSP_REVOKEDINFO_it = {
610 .itype = ASN1_ITYPE_SEQUENCE,
611 .utype = V_ASN1_SEQUENCE,
612 .templates = OCSP_REVOKEDINFO_seq_tt,
613 .tcount = sizeof(OCSP_REVOKEDINFO_seq_tt) / sizeof(ASN1_TEMPLATE),
614 .funcs = NULL,
615 .size = sizeof(OCSP_REVOKEDINFO),
616 .sname = "OCSP_REVOKEDINFO",
617 };
618 LCRYPTO_ALIAS(OCSP_REVOKEDINFO_it);
619
620
621 OCSP_REVOKEDINFO *
d2i_OCSP_REVOKEDINFO(OCSP_REVOKEDINFO ** a,const unsigned char ** in,long len)622 d2i_OCSP_REVOKEDINFO(OCSP_REVOKEDINFO **a, const unsigned char **in, long len)
623 {
624 return (OCSP_REVOKEDINFO *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
625 &OCSP_REVOKEDINFO_it);
626 }
627 LCRYPTO_ALIAS(d2i_OCSP_REVOKEDINFO);
628
629 int
i2d_OCSP_REVOKEDINFO(OCSP_REVOKEDINFO * a,unsigned char ** out)630 i2d_OCSP_REVOKEDINFO(OCSP_REVOKEDINFO *a, unsigned char **out)
631 {
632 return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_REVOKEDINFO_it);
633 }
634 LCRYPTO_ALIAS(i2d_OCSP_REVOKEDINFO);
635
636 OCSP_REVOKEDINFO *
OCSP_REVOKEDINFO_new(void)637 OCSP_REVOKEDINFO_new(void)
638 {
639 return (OCSP_REVOKEDINFO *)ASN1_item_new(&OCSP_REVOKEDINFO_it);
640 }
641 LCRYPTO_ALIAS(OCSP_REVOKEDINFO_new);
642
643 void
OCSP_REVOKEDINFO_free(OCSP_REVOKEDINFO * a)644 OCSP_REVOKEDINFO_free(OCSP_REVOKEDINFO *a)
645 {
646 ASN1_item_free((ASN1_VALUE *)a, &OCSP_REVOKEDINFO_it);
647 }
648 LCRYPTO_ALIAS(OCSP_REVOKEDINFO_free);
649
650 static const ASN1_TEMPLATE OCSP_CERTSTATUS_ch_tt[] = {
651 {
652 .flags = ASN1_TFLG_IMPLICIT,
653 .tag = 0,
654 .offset = offsetof(OCSP_CERTSTATUS, value.good),
655 .field_name = "value.good",
656 .item = &ASN1_NULL_it,
657 },
658 {
659 .flags = ASN1_TFLG_IMPLICIT,
660 .tag = 1,
661 .offset = offsetof(OCSP_CERTSTATUS, value.revoked),
662 .field_name = "value.revoked",
663 .item = &OCSP_REVOKEDINFO_it,
664 },
665 {
666 .flags = ASN1_TFLG_IMPLICIT,
667 .tag = 2,
668 .offset = offsetof(OCSP_CERTSTATUS, value.unknown),
669 .field_name = "value.unknown",
670 .item = &ASN1_NULL_it,
671 },
672 };
673
674 const ASN1_ITEM OCSP_CERTSTATUS_it = {
675 .itype = ASN1_ITYPE_CHOICE,
676 .utype = offsetof(OCSP_CERTSTATUS, type),
677 .templates = OCSP_CERTSTATUS_ch_tt,
678 .tcount = sizeof(OCSP_CERTSTATUS_ch_tt) / sizeof(ASN1_TEMPLATE),
679 .funcs = NULL,
680 .size = sizeof(OCSP_CERTSTATUS),
681 .sname = "OCSP_CERTSTATUS",
682 };
683 LCRYPTO_ALIAS(OCSP_CERTSTATUS_it);
684
685
686 OCSP_CERTSTATUS *
d2i_OCSP_CERTSTATUS(OCSP_CERTSTATUS ** a,const unsigned char ** in,long len)687 d2i_OCSP_CERTSTATUS(OCSP_CERTSTATUS **a, const unsigned char **in, long len)
688 {
689 return (OCSP_CERTSTATUS *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
690 &OCSP_CERTSTATUS_it);
691 }
692 LCRYPTO_ALIAS(d2i_OCSP_CERTSTATUS);
693
694 int
i2d_OCSP_CERTSTATUS(OCSP_CERTSTATUS * a,unsigned char ** out)695 i2d_OCSP_CERTSTATUS(OCSP_CERTSTATUS *a, unsigned char **out)
696 {
697 return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_CERTSTATUS_it);
698 }
699 LCRYPTO_ALIAS(i2d_OCSP_CERTSTATUS);
700
701 OCSP_CERTSTATUS *
OCSP_CERTSTATUS_new(void)702 OCSP_CERTSTATUS_new(void)
703 {
704 return (OCSP_CERTSTATUS *)ASN1_item_new(&OCSP_CERTSTATUS_it);
705 }
706 LCRYPTO_ALIAS(OCSP_CERTSTATUS_new);
707
708 void
OCSP_CERTSTATUS_free(OCSP_CERTSTATUS * a)709 OCSP_CERTSTATUS_free(OCSP_CERTSTATUS *a)
710 {
711 ASN1_item_free((ASN1_VALUE *)a, &OCSP_CERTSTATUS_it);
712 }
713 LCRYPTO_ALIAS(OCSP_CERTSTATUS_free);
714
715 static const ASN1_TEMPLATE OCSP_SINGLERESP_seq_tt[] = {
716 {
717 .flags = 0,
718 .tag = 0,
719 .offset = offsetof(OCSP_SINGLERESP, certId),
720 .field_name = "certId",
721 .item = &OCSP_CERTID_it,
722 },
723 {
724 .flags = 0,
725 .tag = 0,
726 .offset = offsetof(OCSP_SINGLERESP, certStatus),
727 .field_name = "certStatus",
728 .item = &OCSP_CERTSTATUS_it,
729 },
730 {
731 .flags = 0,
732 .tag = 0,
733 .offset = offsetof(OCSP_SINGLERESP, thisUpdate),
734 .field_name = "thisUpdate",
735 .item = &ASN1_GENERALIZEDTIME_it,
736 },
737 {
738 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_OPTIONAL,
739 .tag = 0,
740 .offset = offsetof(OCSP_SINGLERESP, nextUpdate),
741 .field_name = "nextUpdate",
742 .item = &ASN1_GENERALIZEDTIME_it,
743 },
744 {
745 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_SEQUENCE_OF | ASN1_TFLG_OPTIONAL,
746 .tag = 1,
747 .offset = offsetof(OCSP_SINGLERESP, singleExtensions),
748 .field_name = "singleExtensions",
749 .item = &X509_EXTENSION_it,
750 },
751 };
752
753 const ASN1_ITEM OCSP_SINGLERESP_it = {
754 .itype = ASN1_ITYPE_SEQUENCE,
755 .utype = V_ASN1_SEQUENCE,
756 .templates = OCSP_SINGLERESP_seq_tt,
757 .tcount = sizeof(OCSP_SINGLERESP_seq_tt) / sizeof(ASN1_TEMPLATE),
758 .funcs = NULL,
759 .size = sizeof(OCSP_SINGLERESP),
760 .sname = "OCSP_SINGLERESP",
761 };
762 LCRYPTO_ALIAS(OCSP_SINGLERESP_it);
763
764
765 OCSP_SINGLERESP *
d2i_OCSP_SINGLERESP(OCSP_SINGLERESP ** a,const unsigned char ** in,long len)766 d2i_OCSP_SINGLERESP(OCSP_SINGLERESP **a, const unsigned char **in, long len)
767 {
768 return (OCSP_SINGLERESP *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
769 &OCSP_SINGLERESP_it);
770 }
771 LCRYPTO_ALIAS(d2i_OCSP_SINGLERESP);
772
773 int
i2d_OCSP_SINGLERESP(OCSP_SINGLERESP * a,unsigned char ** out)774 i2d_OCSP_SINGLERESP(OCSP_SINGLERESP *a, unsigned char **out)
775 {
776 return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_SINGLERESP_it);
777 }
778 LCRYPTO_ALIAS(i2d_OCSP_SINGLERESP);
779
780 OCSP_SINGLERESP *
OCSP_SINGLERESP_new(void)781 OCSP_SINGLERESP_new(void)
782 {
783 return (OCSP_SINGLERESP *)ASN1_item_new(&OCSP_SINGLERESP_it);
784 }
785 LCRYPTO_ALIAS(OCSP_SINGLERESP_new);
786
787 void
OCSP_SINGLERESP_free(OCSP_SINGLERESP * a)788 OCSP_SINGLERESP_free(OCSP_SINGLERESP *a)
789 {
790 ASN1_item_free((ASN1_VALUE *)a, &OCSP_SINGLERESP_it);
791 }
792 LCRYPTO_ALIAS(OCSP_SINGLERESP_free);
793
794 static const ASN1_TEMPLATE OCSP_RESPDATA_seq_tt[] = {
795 {
796 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_OPTIONAL,
797 .tag = 0,
798 .offset = offsetof(OCSP_RESPDATA, version),
799 .field_name = "version",
800 .item = &ASN1_INTEGER_it,
801 },
802 {
803 .flags = 0,
804 .tag = 0,
805 .offset = offsetof(OCSP_RESPDATA, responderId),
806 .field_name = "responderId",
807 .item = &OCSP_RESPID_it,
808 },
809 {
810 .flags = 0,
811 .tag = 0,
812 .offset = offsetof(OCSP_RESPDATA, producedAt),
813 .field_name = "producedAt",
814 .item = &ASN1_GENERALIZEDTIME_it,
815 },
816 {
817 .flags = ASN1_TFLG_SEQUENCE_OF,
818 .tag = 0,
819 .offset = offsetof(OCSP_RESPDATA, responses),
820 .field_name = "responses",
821 .item = &OCSP_SINGLERESP_it,
822 },
823 {
824 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_SEQUENCE_OF | ASN1_TFLG_OPTIONAL,
825 .tag = 1,
826 .offset = offsetof(OCSP_RESPDATA, responseExtensions),
827 .field_name = "responseExtensions",
828 .item = &X509_EXTENSION_it,
829 },
830 };
831
832 const ASN1_ITEM OCSP_RESPDATA_it = {
833 .itype = ASN1_ITYPE_SEQUENCE,
834 .utype = V_ASN1_SEQUENCE,
835 .templates = OCSP_RESPDATA_seq_tt,
836 .tcount = sizeof(OCSP_RESPDATA_seq_tt) / sizeof(ASN1_TEMPLATE),
837 .funcs = NULL,
838 .size = sizeof(OCSP_RESPDATA),
839 .sname = "OCSP_RESPDATA",
840 };
841 LCRYPTO_ALIAS(OCSP_RESPDATA_it);
842
843
844 OCSP_RESPDATA *
d2i_OCSP_RESPDATA(OCSP_RESPDATA ** a,const unsigned char ** in,long len)845 d2i_OCSP_RESPDATA(OCSP_RESPDATA **a, const unsigned char **in, long len)
846 {
847 return (OCSP_RESPDATA *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
848 &OCSP_RESPDATA_it);
849 }
850 LCRYPTO_ALIAS(d2i_OCSP_RESPDATA);
851
852 int
i2d_OCSP_RESPDATA(OCSP_RESPDATA * a,unsigned char ** out)853 i2d_OCSP_RESPDATA(OCSP_RESPDATA *a, unsigned char **out)
854 {
855 return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_RESPDATA_it);
856 }
857 LCRYPTO_ALIAS(i2d_OCSP_RESPDATA);
858
859 OCSP_RESPDATA *
OCSP_RESPDATA_new(void)860 OCSP_RESPDATA_new(void)
861 {
862 return (OCSP_RESPDATA *)ASN1_item_new(&OCSP_RESPDATA_it);
863 }
864 LCRYPTO_ALIAS(OCSP_RESPDATA_new);
865
866 void
OCSP_RESPDATA_free(OCSP_RESPDATA * a)867 OCSP_RESPDATA_free(OCSP_RESPDATA *a)
868 {
869 ASN1_item_free((ASN1_VALUE *)a, &OCSP_RESPDATA_it);
870 }
871 LCRYPTO_ALIAS(OCSP_RESPDATA_free);
872
873 static const ASN1_TEMPLATE OCSP_BASICRESP_seq_tt[] = {
874 {
875 .flags = 0,
876 .tag = 0,
877 .offset = offsetof(OCSP_BASICRESP, tbsResponseData),
878 .field_name = "tbsResponseData",
879 .item = &OCSP_RESPDATA_it,
880 },
881 {
882 .flags = 0,
883 .tag = 0,
884 .offset = offsetof(OCSP_BASICRESP, signatureAlgorithm),
885 .field_name = "signatureAlgorithm",
886 .item = &X509_ALGOR_it,
887 },
888 {
889 .flags = 0,
890 .tag = 0,
891 .offset = offsetof(OCSP_BASICRESP, signature),
892 .field_name = "signature",
893 .item = &ASN1_BIT_STRING_it,
894 },
895 {
896 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_SEQUENCE_OF | ASN1_TFLG_OPTIONAL,
897 .tag = 0,
898 .offset = offsetof(OCSP_BASICRESP, certs),
899 .field_name = "certs",
900 .item = &X509_it,
901 },
902 };
903
904 const ASN1_ITEM OCSP_BASICRESP_it = {
905 .itype = ASN1_ITYPE_SEQUENCE,
906 .utype = V_ASN1_SEQUENCE,
907 .templates = OCSP_BASICRESP_seq_tt,
908 .tcount = sizeof(OCSP_BASICRESP_seq_tt) / sizeof(ASN1_TEMPLATE),
909 .funcs = NULL,
910 .size = sizeof(OCSP_BASICRESP),
911 .sname = "OCSP_BASICRESP",
912 };
913 LCRYPTO_ALIAS(OCSP_BASICRESP_it);
914
915
916 OCSP_BASICRESP *
d2i_OCSP_BASICRESP(OCSP_BASICRESP ** a,const unsigned char ** in,long len)917 d2i_OCSP_BASICRESP(OCSP_BASICRESP **a, const unsigned char **in, long len)
918 {
919 return (OCSP_BASICRESP *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
920 &OCSP_BASICRESP_it);
921 }
922 LCRYPTO_ALIAS(d2i_OCSP_BASICRESP);
923
924 int
i2d_OCSP_BASICRESP(OCSP_BASICRESP * a,unsigned char ** out)925 i2d_OCSP_BASICRESP(OCSP_BASICRESP *a, unsigned char **out)
926 {
927 return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_BASICRESP_it);
928 }
929 LCRYPTO_ALIAS(i2d_OCSP_BASICRESP);
930
931 OCSP_BASICRESP *
OCSP_BASICRESP_new(void)932 OCSP_BASICRESP_new(void)
933 {
934 return (OCSP_BASICRESP *)ASN1_item_new(&OCSP_BASICRESP_it);
935 }
936 LCRYPTO_ALIAS(OCSP_BASICRESP_new);
937
938 void
OCSP_BASICRESP_free(OCSP_BASICRESP * a)939 OCSP_BASICRESP_free(OCSP_BASICRESP *a)
940 {
941 ASN1_item_free((ASN1_VALUE *)a, &OCSP_BASICRESP_it);
942 }
943 LCRYPTO_ALIAS(OCSP_BASICRESP_free);
944
945 static const ASN1_TEMPLATE OCSP_CRLID_seq_tt[] = {
946 {
947 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_OPTIONAL,
948 .tag = 0,
949 .offset = offsetof(OCSP_CRLID, crlUrl),
950 .field_name = "crlUrl",
951 .item = &ASN1_IA5STRING_it,
952 },
953 {
954 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_OPTIONAL,
955 .tag = 1,
956 .offset = offsetof(OCSP_CRLID, crlNum),
957 .field_name = "crlNum",
958 .item = &ASN1_INTEGER_it,
959 },
960 {
961 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_OPTIONAL,
962 .tag = 2,
963 .offset = offsetof(OCSP_CRLID, crlTime),
964 .field_name = "crlTime",
965 .item = &ASN1_GENERALIZEDTIME_it,
966 },
967 };
968
969 const ASN1_ITEM OCSP_CRLID_it = {
970 .itype = ASN1_ITYPE_SEQUENCE,
971 .utype = V_ASN1_SEQUENCE,
972 .templates = OCSP_CRLID_seq_tt,
973 .tcount = sizeof(OCSP_CRLID_seq_tt) / sizeof(ASN1_TEMPLATE),
974 .funcs = NULL,
975 .size = sizeof(OCSP_CRLID),
976 .sname = "OCSP_CRLID",
977 };
978 LCRYPTO_ALIAS(OCSP_CRLID_it);
979
980
981 OCSP_CRLID *
d2i_OCSP_CRLID(OCSP_CRLID ** a,const unsigned char ** in,long len)982 d2i_OCSP_CRLID(OCSP_CRLID **a, const unsigned char **in, long len)
983 {
984 return (OCSP_CRLID *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
985 &OCSP_CRLID_it);
986 }
987 LCRYPTO_ALIAS(d2i_OCSP_CRLID);
988
989 int
i2d_OCSP_CRLID(OCSP_CRLID * a,unsigned char ** out)990 i2d_OCSP_CRLID(OCSP_CRLID *a, unsigned char **out)
991 {
992 return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_CRLID_it);
993 }
994 LCRYPTO_ALIAS(i2d_OCSP_CRLID);
995
996 OCSP_CRLID *
OCSP_CRLID_new(void)997 OCSP_CRLID_new(void)
998 {
999 return (OCSP_CRLID *)ASN1_item_new(&OCSP_CRLID_it);
1000 }
1001 LCRYPTO_ALIAS(OCSP_CRLID_new);
1002
1003 void
OCSP_CRLID_free(OCSP_CRLID * a)1004 OCSP_CRLID_free(OCSP_CRLID *a)
1005 {
1006 ASN1_item_free((ASN1_VALUE *)a, &OCSP_CRLID_it);
1007 }
1008 LCRYPTO_ALIAS(OCSP_CRLID_free);
1009
1010 static const ASN1_TEMPLATE OCSP_SERVICELOC_seq_tt[] = {
1011 {
1012 .flags = 0,
1013 .tag = 0,
1014 .offset = offsetof(OCSP_SERVICELOC, issuer),
1015 .field_name = "issuer",
1016 .item = &X509_NAME_it,
1017 },
1018 {
1019 .flags = ASN1_TFLG_SEQUENCE_OF | ASN1_TFLG_OPTIONAL,
1020 .tag = 0,
1021 .offset = offsetof(OCSP_SERVICELOC, locator),
1022 .field_name = "locator",
1023 .item = &ACCESS_DESCRIPTION_it,
1024 },
1025 };
1026
1027 const ASN1_ITEM OCSP_SERVICELOC_it = {
1028 .itype = ASN1_ITYPE_SEQUENCE,
1029 .utype = V_ASN1_SEQUENCE,
1030 .templates = OCSP_SERVICELOC_seq_tt,
1031 .tcount = sizeof(OCSP_SERVICELOC_seq_tt) / sizeof(ASN1_TEMPLATE),
1032 .funcs = NULL,
1033 .size = sizeof(OCSP_SERVICELOC),
1034 .sname = "OCSP_SERVICELOC",
1035 };
1036 LCRYPTO_ALIAS(OCSP_SERVICELOC_it);
1037
1038
1039 OCSP_SERVICELOC *
d2i_OCSP_SERVICELOC(OCSP_SERVICELOC ** a,const unsigned char ** in,long len)1040 d2i_OCSP_SERVICELOC(OCSP_SERVICELOC **a, const unsigned char **in, long len)
1041 {
1042 return (OCSP_SERVICELOC *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
1043 &OCSP_SERVICELOC_it);
1044 }
1045 LCRYPTO_ALIAS(d2i_OCSP_SERVICELOC);
1046
1047 int
i2d_OCSP_SERVICELOC(OCSP_SERVICELOC * a,unsigned char ** out)1048 i2d_OCSP_SERVICELOC(OCSP_SERVICELOC *a, unsigned char **out)
1049 {
1050 return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_SERVICELOC_it);
1051 }
1052 LCRYPTO_ALIAS(i2d_OCSP_SERVICELOC);
1053
1054 OCSP_SERVICELOC *
OCSP_SERVICELOC_new(void)1055 OCSP_SERVICELOC_new(void)
1056 {
1057 return (OCSP_SERVICELOC *)ASN1_item_new(&OCSP_SERVICELOC_it);
1058 }
1059 LCRYPTO_ALIAS(OCSP_SERVICELOC_new);
1060
1061 void
OCSP_SERVICELOC_free(OCSP_SERVICELOC * a)1062 OCSP_SERVICELOC_free(OCSP_SERVICELOC *a)
1063 {
1064 ASN1_item_free((ASN1_VALUE *)a, &OCSP_SERVICELOC_it);
1065 }
1066 LCRYPTO_ALIAS(OCSP_SERVICELOC_free);
1067