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