1*de0e0e4dSAntonio Huete Jimenez /* $OpenBSD: ts_asn1.c,v 1.13 2022/07/24 08:16:47 tb Exp $ */
2f5b1c8a1SJohn Marino /* Written by Nils Larsch for the OpenSSL project 2004.
3f5b1c8a1SJohn Marino */
4f5b1c8a1SJohn Marino /* ====================================================================
5f5b1c8a1SJohn Marino * Copyright (c) 2006 The OpenSSL Project. All rights reserved.
6f5b1c8a1SJohn Marino *
7f5b1c8a1SJohn Marino * Redistribution and use in source and binary forms, with or without
8f5b1c8a1SJohn Marino * modification, are permitted provided that the following conditions
9f5b1c8a1SJohn Marino * are met:
10f5b1c8a1SJohn Marino *
11f5b1c8a1SJohn Marino * 1. Redistributions of source code must retain the above copyright
12f5b1c8a1SJohn Marino * notice, this list of conditions and the following disclaimer.
13f5b1c8a1SJohn Marino *
14f5b1c8a1SJohn Marino * 2. Redistributions in binary form must reproduce the above copyright
15f5b1c8a1SJohn Marino * notice, this list of conditions and the following disclaimer in
16f5b1c8a1SJohn Marino * the documentation and/or other materials provided with the
17f5b1c8a1SJohn Marino * distribution.
18f5b1c8a1SJohn Marino *
19f5b1c8a1SJohn Marino * 3. All advertising materials mentioning features or use of this
20f5b1c8a1SJohn Marino * software must display the following acknowledgment:
21f5b1c8a1SJohn Marino * "This product includes software developed by the OpenSSL Project
22f5b1c8a1SJohn Marino * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
23f5b1c8a1SJohn Marino *
24f5b1c8a1SJohn Marino * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
25f5b1c8a1SJohn Marino * endorse or promote products derived from this software without
26f5b1c8a1SJohn Marino * prior written permission. For written permission, please contact
27f5b1c8a1SJohn Marino * licensing@OpenSSL.org.
28f5b1c8a1SJohn Marino *
29f5b1c8a1SJohn Marino * 5. Products derived from this software may not be called "OpenSSL"
30f5b1c8a1SJohn Marino * nor may "OpenSSL" appear in their names without prior written
31f5b1c8a1SJohn Marino * permission of the OpenSSL Project.
32f5b1c8a1SJohn Marino *
33f5b1c8a1SJohn Marino * 6. Redistributions of any form whatsoever must retain the following
34f5b1c8a1SJohn Marino * acknowledgment:
35f5b1c8a1SJohn Marino * "This product includes software developed by the OpenSSL Project
36f5b1c8a1SJohn Marino * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
37f5b1c8a1SJohn Marino *
38f5b1c8a1SJohn Marino * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
39f5b1c8a1SJohn Marino * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
40f5b1c8a1SJohn Marino * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
41f5b1c8a1SJohn Marino * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
42f5b1c8a1SJohn Marino * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
43f5b1c8a1SJohn Marino * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
44f5b1c8a1SJohn Marino * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
45f5b1c8a1SJohn Marino * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
46f5b1c8a1SJohn Marino * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
47f5b1c8a1SJohn Marino * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
48f5b1c8a1SJohn Marino * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
49f5b1c8a1SJohn Marino * OF THE POSSIBILITY OF SUCH DAMAGE.
50f5b1c8a1SJohn Marino * ====================================================================
51f5b1c8a1SJohn Marino *
52f5b1c8a1SJohn Marino * This product includes cryptographic software written by Eric Young
53f5b1c8a1SJohn Marino * (eay@cryptsoft.com). This product includes software written by Tim
54f5b1c8a1SJohn Marino * Hudson (tjh@cryptsoft.com).
55f5b1c8a1SJohn Marino *
56f5b1c8a1SJohn Marino */
57f5b1c8a1SJohn Marino
58f5b1c8a1SJohn Marino #include <openssl/opensslconf.h>
59f5b1c8a1SJohn Marino
60f5b1c8a1SJohn Marino #include <openssl/ts.h>
61f5b1c8a1SJohn Marino #include <openssl/err.h>
62f5b1c8a1SJohn Marino #include <openssl/asn1t.h>
63f5b1c8a1SJohn Marino
64*de0e0e4dSAntonio Huete Jimenez #include "ts_local.h"
65*de0e0e4dSAntonio Huete Jimenez
66f5b1c8a1SJohn Marino static const ASN1_TEMPLATE TS_MSG_IMPRINT_seq_tt[] = {
67f5b1c8a1SJohn Marino {
68f5b1c8a1SJohn Marino .flags = 0,
69f5b1c8a1SJohn Marino .tag = 0,
70f5b1c8a1SJohn Marino .offset = offsetof(TS_MSG_IMPRINT, hash_algo),
71f5b1c8a1SJohn Marino .field_name = "hash_algo",
72f5b1c8a1SJohn Marino .item = &X509_ALGOR_it,
73f5b1c8a1SJohn Marino },
74f5b1c8a1SJohn Marino {
75f5b1c8a1SJohn Marino .flags = 0,
76f5b1c8a1SJohn Marino .tag = 0,
77f5b1c8a1SJohn Marino .offset = offsetof(TS_MSG_IMPRINT, hashed_msg),
78f5b1c8a1SJohn Marino .field_name = "hashed_msg",
79f5b1c8a1SJohn Marino .item = &ASN1_OCTET_STRING_it,
80f5b1c8a1SJohn Marino },
81f5b1c8a1SJohn Marino };
82f5b1c8a1SJohn Marino
83f5b1c8a1SJohn Marino const ASN1_ITEM TS_MSG_IMPRINT_it = {
84f5b1c8a1SJohn Marino .itype = ASN1_ITYPE_SEQUENCE,
85f5b1c8a1SJohn Marino .utype = V_ASN1_SEQUENCE,
86f5b1c8a1SJohn Marino .templates = TS_MSG_IMPRINT_seq_tt,
87f5b1c8a1SJohn Marino .tcount = sizeof(TS_MSG_IMPRINT_seq_tt) / sizeof(ASN1_TEMPLATE),
88f5b1c8a1SJohn Marino .funcs = NULL,
89f5b1c8a1SJohn Marino .size = sizeof(TS_MSG_IMPRINT),
90f5b1c8a1SJohn Marino .sname = "TS_MSG_IMPRINT",
91f5b1c8a1SJohn Marino };
92f5b1c8a1SJohn Marino
93f5b1c8a1SJohn Marino
94f5b1c8a1SJohn Marino TS_MSG_IMPRINT *
d2i_TS_MSG_IMPRINT(TS_MSG_IMPRINT ** a,const unsigned char ** in,long len)95f5b1c8a1SJohn Marino d2i_TS_MSG_IMPRINT(TS_MSG_IMPRINT **a, const unsigned char **in, long len)
96f5b1c8a1SJohn Marino {
97f5b1c8a1SJohn Marino return (TS_MSG_IMPRINT *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
98f5b1c8a1SJohn Marino &TS_MSG_IMPRINT_it);
99f5b1c8a1SJohn Marino }
100f5b1c8a1SJohn Marino
101f5b1c8a1SJohn Marino int
i2d_TS_MSG_IMPRINT(const TS_MSG_IMPRINT * a,unsigned char ** out)102f5b1c8a1SJohn Marino i2d_TS_MSG_IMPRINT(const TS_MSG_IMPRINT *a, unsigned char **out)
103f5b1c8a1SJohn Marino {
104f5b1c8a1SJohn Marino return ASN1_item_i2d((ASN1_VALUE *)a, out, &TS_MSG_IMPRINT_it);
105f5b1c8a1SJohn Marino }
106f5b1c8a1SJohn Marino
107f5b1c8a1SJohn Marino TS_MSG_IMPRINT *
TS_MSG_IMPRINT_new(void)108f5b1c8a1SJohn Marino TS_MSG_IMPRINT_new(void)
109f5b1c8a1SJohn Marino {
110f5b1c8a1SJohn Marino return (TS_MSG_IMPRINT *)ASN1_item_new(&TS_MSG_IMPRINT_it);
111f5b1c8a1SJohn Marino }
112f5b1c8a1SJohn Marino
113f5b1c8a1SJohn Marino void
TS_MSG_IMPRINT_free(TS_MSG_IMPRINT * a)114f5b1c8a1SJohn Marino TS_MSG_IMPRINT_free(TS_MSG_IMPRINT *a)
115f5b1c8a1SJohn Marino {
116f5b1c8a1SJohn Marino ASN1_item_free((ASN1_VALUE *)a, &TS_MSG_IMPRINT_it);
117f5b1c8a1SJohn Marino }
118f5b1c8a1SJohn Marino
119f5b1c8a1SJohn Marino TS_MSG_IMPRINT *
TS_MSG_IMPRINT_dup(TS_MSG_IMPRINT * x)120f5b1c8a1SJohn Marino TS_MSG_IMPRINT_dup(TS_MSG_IMPRINT *x)
121f5b1c8a1SJohn Marino {
122f5b1c8a1SJohn Marino return ASN1_item_dup(&TS_MSG_IMPRINT_it, x);
123f5b1c8a1SJohn Marino }
124f5b1c8a1SJohn Marino
125f5b1c8a1SJohn Marino #ifndef OPENSSL_NO_BIO
126f5b1c8a1SJohn Marino TS_MSG_IMPRINT *
d2i_TS_MSG_IMPRINT_bio(BIO * bp,TS_MSG_IMPRINT ** a)127f5b1c8a1SJohn Marino d2i_TS_MSG_IMPRINT_bio(BIO *bp, TS_MSG_IMPRINT **a)
128f5b1c8a1SJohn Marino {
12972c33676SMaxim Ag return ASN1_item_d2i_bio(&TS_MSG_IMPRINT_it, bp, a);
130f5b1c8a1SJohn Marino }
131f5b1c8a1SJohn Marino
132f5b1c8a1SJohn Marino int
i2d_TS_MSG_IMPRINT_bio(BIO * bp,TS_MSG_IMPRINT * a)133f5b1c8a1SJohn Marino i2d_TS_MSG_IMPRINT_bio(BIO *bp, TS_MSG_IMPRINT *a)
134f5b1c8a1SJohn Marino {
13572c33676SMaxim Ag return ASN1_item_i2d_bio(&TS_MSG_IMPRINT_it, bp, a);
136f5b1c8a1SJohn Marino }
137f5b1c8a1SJohn Marino #endif
138f5b1c8a1SJohn Marino
139f5b1c8a1SJohn Marino TS_MSG_IMPRINT *
d2i_TS_MSG_IMPRINT_fp(FILE * fp,TS_MSG_IMPRINT ** a)140f5b1c8a1SJohn Marino d2i_TS_MSG_IMPRINT_fp(FILE *fp, TS_MSG_IMPRINT **a)
141f5b1c8a1SJohn Marino {
14272c33676SMaxim Ag return ASN1_item_d2i_fp(&TS_MSG_IMPRINT_it, fp, a);
143f5b1c8a1SJohn Marino }
144f5b1c8a1SJohn Marino
145f5b1c8a1SJohn Marino int
i2d_TS_MSG_IMPRINT_fp(FILE * fp,TS_MSG_IMPRINT * a)146f5b1c8a1SJohn Marino i2d_TS_MSG_IMPRINT_fp(FILE *fp, TS_MSG_IMPRINT *a)
147f5b1c8a1SJohn Marino {
14872c33676SMaxim Ag return ASN1_item_i2d_fp(&TS_MSG_IMPRINT_it, fp, a);
149f5b1c8a1SJohn Marino }
150f5b1c8a1SJohn Marino
151f5b1c8a1SJohn Marino static const ASN1_TEMPLATE TS_REQ_seq_tt[] = {
152f5b1c8a1SJohn Marino {
153f5b1c8a1SJohn Marino .flags = 0,
154f5b1c8a1SJohn Marino .tag = 0,
155f5b1c8a1SJohn Marino .offset = offsetof(TS_REQ, version),
156f5b1c8a1SJohn Marino .field_name = "version",
157f5b1c8a1SJohn Marino .item = &ASN1_INTEGER_it,
158f5b1c8a1SJohn Marino },
159f5b1c8a1SJohn Marino {
160f5b1c8a1SJohn Marino .flags = 0,
161f5b1c8a1SJohn Marino .tag = 0,
162f5b1c8a1SJohn Marino .offset = offsetof(TS_REQ, msg_imprint),
163f5b1c8a1SJohn Marino .field_name = "msg_imprint",
164f5b1c8a1SJohn Marino .item = &TS_MSG_IMPRINT_it,
165f5b1c8a1SJohn Marino },
166f5b1c8a1SJohn Marino {
167f5b1c8a1SJohn Marino .flags = ASN1_TFLG_OPTIONAL,
168f5b1c8a1SJohn Marino .tag = 0,
169f5b1c8a1SJohn Marino .offset = offsetof(TS_REQ, policy_id),
170f5b1c8a1SJohn Marino .field_name = "policy_id",
171f5b1c8a1SJohn Marino .item = &ASN1_OBJECT_it,
172f5b1c8a1SJohn Marino },
173f5b1c8a1SJohn Marino {
174f5b1c8a1SJohn Marino .flags = ASN1_TFLG_OPTIONAL,
175f5b1c8a1SJohn Marino .tag = 0,
176f5b1c8a1SJohn Marino .offset = offsetof(TS_REQ, nonce),
177f5b1c8a1SJohn Marino .field_name = "nonce",
178f5b1c8a1SJohn Marino .item = &ASN1_INTEGER_it,
179f5b1c8a1SJohn Marino },
180f5b1c8a1SJohn Marino {
181f5b1c8a1SJohn Marino .flags = ASN1_TFLG_OPTIONAL,
182f5b1c8a1SJohn Marino .tag = 0,
183f5b1c8a1SJohn Marino .offset = offsetof(TS_REQ, cert_req),
184f5b1c8a1SJohn Marino .field_name = "cert_req",
185f5b1c8a1SJohn Marino .item = &ASN1_FBOOLEAN_it,
186f5b1c8a1SJohn Marino },
187f5b1c8a1SJohn Marino {
188f5b1c8a1SJohn Marino .flags = ASN1_TFLG_IMPLICIT | ASN1_TFLG_SEQUENCE_OF | ASN1_TFLG_OPTIONAL,
189f5b1c8a1SJohn Marino .tag = 0,
190f5b1c8a1SJohn Marino .offset = offsetof(TS_REQ, extensions),
191f5b1c8a1SJohn Marino .field_name = "extensions",
192f5b1c8a1SJohn Marino .item = &X509_EXTENSION_it,
193f5b1c8a1SJohn Marino },
194f5b1c8a1SJohn Marino };
195f5b1c8a1SJohn Marino
196f5b1c8a1SJohn Marino const ASN1_ITEM TS_REQ_it = {
197f5b1c8a1SJohn Marino .itype = ASN1_ITYPE_SEQUENCE,
198f5b1c8a1SJohn Marino .utype = V_ASN1_SEQUENCE,
199f5b1c8a1SJohn Marino .templates = TS_REQ_seq_tt,
200f5b1c8a1SJohn Marino .tcount = sizeof(TS_REQ_seq_tt) / sizeof(ASN1_TEMPLATE),
201f5b1c8a1SJohn Marino .funcs = NULL,
202f5b1c8a1SJohn Marino .size = sizeof(TS_REQ),
203f5b1c8a1SJohn Marino .sname = "TS_REQ",
204f5b1c8a1SJohn Marino };
205f5b1c8a1SJohn Marino
206f5b1c8a1SJohn Marino
207f5b1c8a1SJohn Marino TS_REQ *
d2i_TS_REQ(TS_REQ ** a,const unsigned char ** in,long len)208f5b1c8a1SJohn Marino d2i_TS_REQ(TS_REQ **a, const unsigned char **in, long len)
209f5b1c8a1SJohn Marino {
210f5b1c8a1SJohn Marino return (TS_REQ *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
211f5b1c8a1SJohn Marino &TS_REQ_it);
212f5b1c8a1SJohn Marino }
213f5b1c8a1SJohn Marino
214f5b1c8a1SJohn Marino int
i2d_TS_REQ(const TS_REQ * a,unsigned char ** out)215f5b1c8a1SJohn Marino i2d_TS_REQ(const TS_REQ *a, unsigned char **out)
216f5b1c8a1SJohn Marino {
217f5b1c8a1SJohn Marino return ASN1_item_i2d((ASN1_VALUE *)a, out, &TS_REQ_it);
218f5b1c8a1SJohn Marino }
219f5b1c8a1SJohn Marino
220f5b1c8a1SJohn Marino TS_REQ *
TS_REQ_new(void)221f5b1c8a1SJohn Marino TS_REQ_new(void)
222f5b1c8a1SJohn Marino {
223f5b1c8a1SJohn Marino return (TS_REQ *)ASN1_item_new(&TS_REQ_it);
224f5b1c8a1SJohn Marino }
225f5b1c8a1SJohn Marino
226f5b1c8a1SJohn Marino void
TS_REQ_free(TS_REQ * a)227f5b1c8a1SJohn Marino TS_REQ_free(TS_REQ *a)
228f5b1c8a1SJohn Marino {
229f5b1c8a1SJohn Marino ASN1_item_free((ASN1_VALUE *)a, &TS_REQ_it);
230f5b1c8a1SJohn Marino }
231f5b1c8a1SJohn Marino
232f5b1c8a1SJohn Marino TS_REQ *
TS_REQ_dup(TS_REQ * x)233f5b1c8a1SJohn Marino TS_REQ_dup(TS_REQ *x)
234f5b1c8a1SJohn Marino {
235f5b1c8a1SJohn Marino return ASN1_item_dup(&TS_REQ_it, x);
236f5b1c8a1SJohn Marino }
237f5b1c8a1SJohn Marino
238f5b1c8a1SJohn Marino #ifndef OPENSSL_NO_BIO
239f5b1c8a1SJohn Marino TS_REQ *
d2i_TS_REQ_bio(BIO * bp,TS_REQ ** a)240f5b1c8a1SJohn Marino d2i_TS_REQ_bio(BIO *bp, TS_REQ **a)
241f5b1c8a1SJohn Marino {
24272c33676SMaxim Ag return ASN1_item_d2i_bio(&TS_REQ_it, bp, a);
243f5b1c8a1SJohn Marino }
244f5b1c8a1SJohn Marino
245f5b1c8a1SJohn Marino int
i2d_TS_REQ_bio(BIO * bp,TS_REQ * a)246f5b1c8a1SJohn Marino i2d_TS_REQ_bio(BIO *bp, TS_REQ *a)
247f5b1c8a1SJohn Marino {
24872c33676SMaxim Ag return ASN1_item_i2d_bio(&TS_REQ_it, bp, a);
249f5b1c8a1SJohn Marino }
250f5b1c8a1SJohn Marino #endif
251f5b1c8a1SJohn Marino
252f5b1c8a1SJohn Marino TS_REQ *
d2i_TS_REQ_fp(FILE * fp,TS_REQ ** a)253f5b1c8a1SJohn Marino d2i_TS_REQ_fp(FILE *fp, TS_REQ **a)
254f5b1c8a1SJohn Marino {
25572c33676SMaxim Ag return ASN1_item_d2i_fp(&TS_REQ_it, fp, a);
256f5b1c8a1SJohn Marino }
257f5b1c8a1SJohn Marino
258f5b1c8a1SJohn Marino int
i2d_TS_REQ_fp(FILE * fp,TS_REQ * a)259f5b1c8a1SJohn Marino i2d_TS_REQ_fp(FILE *fp, TS_REQ *a)
260f5b1c8a1SJohn Marino {
26172c33676SMaxim Ag return ASN1_item_i2d_fp(&TS_REQ_it, fp, a);
262f5b1c8a1SJohn Marino }
263f5b1c8a1SJohn Marino
264f5b1c8a1SJohn Marino static const ASN1_TEMPLATE TS_ACCURACY_seq_tt[] = {
265f5b1c8a1SJohn Marino {
266f5b1c8a1SJohn Marino .flags = ASN1_TFLG_OPTIONAL,
267f5b1c8a1SJohn Marino .tag = 0,
268f5b1c8a1SJohn Marino .offset = offsetof(TS_ACCURACY, seconds),
269f5b1c8a1SJohn Marino .field_name = "seconds",
270f5b1c8a1SJohn Marino .item = &ASN1_INTEGER_it,
271f5b1c8a1SJohn Marino },
272f5b1c8a1SJohn Marino {
273f5b1c8a1SJohn Marino .flags = ASN1_TFLG_IMPLICIT | ASN1_TFLG_OPTIONAL,
274f5b1c8a1SJohn Marino .tag = 0,
275f5b1c8a1SJohn Marino .offset = offsetof(TS_ACCURACY, millis),
276f5b1c8a1SJohn Marino .field_name = "millis",
277f5b1c8a1SJohn Marino .item = &ASN1_INTEGER_it,
278f5b1c8a1SJohn Marino },
279f5b1c8a1SJohn Marino {
280f5b1c8a1SJohn Marino .flags = ASN1_TFLG_IMPLICIT | ASN1_TFLG_OPTIONAL,
281f5b1c8a1SJohn Marino .tag = 1,
282f5b1c8a1SJohn Marino .offset = offsetof(TS_ACCURACY, micros),
283f5b1c8a1SJohn Marino .field_name = "micros",
284f5b1c8a1SJohn Marino .item = &ASN1_INTEGER_it,
285f5b1c8a1SJohn Marino },
286f5b1c8a1SJohn Marino };
287f5b1c8a1SJohn Marino
288f5b1c8a1SJohn Marino const ASN1_ITEM TS_ACCURACY_it = {
289f5b1c8a1SJohn Marino .itype = ASN1_ITYPE_SEQUENCE,
290f5b1c8a1SJohn Marino .utype = V_ASN1_SEQUENCE,
291f5b1c8a1SJohn Marino .templates = TS_ACCURACY_seq_tt,
292f5b1c8a1SJohn Marino .tcount = sizeof(TS_ACCURACY_seq_tt) / sizeof(ASN1_TEMPLATE),
293f5b1c8a1SJohn Marino .funcs = NULL,
294f5b1c8a1SJohn Marino .size = sizeof(TS_ACCURACY),
295f5b1c8a1SJohn Marino .sname = "TS_ACCURACY",
296f5b1c8a1SJohn Marino };
297f5b1c8a1SJohn Marino
298f5b1c8a1SJohn Marino
299f5b1c8a1SJohn Marino TS_ACCURACY *
d2i_TS_ACCURACY(TS_ACCURACY ** a,const unsigned char ** in,long len)300f5b1c8a1SJohn Marino d2i_TS_ACCURACY(TS_ACCURACY **a, const unsigned char **in, long len)
301f5b1c8a1SJohn Marino {
302f5b1c8a1SJohn Marino return (TS_ACCURACY *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
303f5b1c8a1SJohn Marino &TS_ACCURACY_it);
304f5b1c8a1SJohn Marino }
305f5b1c8a1SJohn Marino
306f5b1c8a1SJohn Marino int
i2d_TS_ACCURACY(const TS_ACCURACY * a,unsigned char ** out)307f5b1c8a1SJohn Marino i2d_TS_ACCURACY(const TS_ACCURACY *a, unsigned char **out)
308f5b1c8a1SJohn Marino {
309f5b1c8a1SJohn Marino return ASN1_item_i2d((ASN1_VALUE *)a, out, &TS_ACCURACY_it);
310f5b1c8a1SJohn Marino }
311f5b1c8a1SJohn Marino
312f5b1c8a1SJohn Marino TS_ACCURACY *
TS_ACCURACY_new(void)313f5b1c8a1SJohn Marino TS_ACCURACY_new(void)
314f5b1c8a1SJohn Marino {
315f5b1c8a1SJohn Marino return (TS_ACCURACY *)ASN1_item_new(&TS_ACCURACY_it);
316f5b1c8a1SJohn Marino }
317f5b1c8a1SJohn Marino
318f5b1c8a1SJohn Marino void
TS_ACCURACY_free(TS_ACCURACY * a)319f5b1c8a1SJohn Marino TS_ACCURACY_free(TS_ACCURACY *a)
320f5b1c8a1SJohn Marino {
321f5b1c8a1SJohn Marino ASN1_item_free((ASN1_VALUE *)a, &TS_ACCURACY_it);
322f5b1c8a1SJohn Marino }
323f5b1c8a1SJohn Marino
324f5b1c8a1SJohn Marino TS_ACCURACY *
TS_ACCURACY_dup(TS_ACCURACY * x)325f5b1c8a1SJohn Marino TS_ACCURACY_dup(TS_ACCURACY *x)
326f5b1c8a1SJohn Marino {
327f5b1c8a1SJohn Marino return ASN1_item_dup(&TS_ACCURACY_it, x);
328f5b1c8a1SJohn Marino }
329f5b1c8a1SJohn Marino
330f5b1c8a1SJohn Marino static const ASN1_TEMPLATE TS_TST_INFO_seq_tt[] = {
331f5b1c8a1SJohn Marino {
332f5b1c8a1SJohn Marino .flags = 0,
333f5b1c8a1SJohn Marino .tag = 0,
334f5b1c8a1SJohn Marino .offset = offsetof(TS_TST_INFO, version),
335f5b1c8a1SJohn Marino .field_name = "version",
336f5b1c8a1SJohn Marino .item = &ASN1_INTEGER_it,
337f5b1c8a1SJohn Marino },
338f5b1c8a1SJohn Marino {
339f5b1c8a1SJohn Marino .flags = 0,
340f5b1c8a1SJohn Marino .tag = 0,
341f5b1c8a1SJohn Marino .offset = offsetof(TS_TST_INFO, policy_id),
342f5b1c8a1SJohn Marino .field_name = "policy_id",
343f5b1c8a1SJohn Marino .item = &ASN1_OBJECT_it,
344f5b1c8a1SJohn Marino },
345f5b1c8a1SJohn Marino {
346f5b1c8a1SJohn Marino .flags = 0,
347f5b1c8a1SJohn Marino .tag = 0,
348f5b1c8a1SJohn Marino .offset = offsetof(TS_TST_INFO, msg_imprint),
349f5b1c8a1SJohn Marino .field_name = "msg_imprint",
350f5b1c8a1SJohn Marino .item = &TS_MSG_IMPRINT_it,
351f5b1c8a1SJohn Marino },
352f5b1c8a1SJohn Marino {
353f5b1c8a1SJohn Marino .flags = 0,
354f5b1c8a1SJohn Marino .tag = 0,
355f5b1c8a1SJohn Marino .offset = offsetof(TS_TST_INFO, serial),
356f5b1c8a1SJohn Marino .field_name = "serial",
357f5b1c8a1SJohn Marino .item = &ASN1_INTEGER_it,
358f5b1c8a1SJohn Marino },
359f5b1c8a1SJohn Marino {
360f5b1c8a1SJohn Marino .flags = 0,
361f5b1c8a1SJohn Marino .tag = 0,
362f5b1c8a1SJohn Marino .offset = offsetof(TS_TST_INFO, time),
363f5b1c8a1SJohn Marino .field_name = "time",
364f5b1c8a1SJohn Marino .item = &ASN1_GENERALIZEDTIME_it,
365f5b1c8a1SJohn Marino },
366f5b1c8a1SJohn Marino {
367f5b1c8a1SJohn Marino .flags = ASN1_TFLG_OPTIONAL,
368f5b1c8a1SJohn Marino .tag = 0,
369f5b1c8a1SJohn Marino .offset = offsetof(TS_TST_INFO, accuracy),
370f5b1c8a1SJohn Marino .field_name = "accuracy",
371f5b1c8a1SJohn Marino .item = &TS_ACCURACY_it,
372f5b1c8a1SJohn Marino },
373f5b1c8a1SJohn Marino {
374f5b1c8a1SJohn Marino .flags = ASN1_TFLG_OPTIONAL,
375f5b1c8a1SJohn Marino .tag = 0,
376f5b1c8a1SJohn Marino .offset = offsetof(TS_TST_INFO, ordering),
377f5b1c8a1SJohn Marino .field_name = "ordering",
378f5b1c8a1SJohn Marino .item = &ASN1_FBOOLEAN_it,
379f5b1c8a1SJohn Marino },
380f5b1c8a1SJohn Marino {
381f5b1c8a1SJohn Marino .flags = ASN1_TFLG_OPTIONAL,
382f5b1c8a1SJohn Marino .tag = 0,
383f5b1c8a1SJohn Marino .offset = offsetof(TS_TST_INFO, nonce),
384f5b1c8a1SJohn Marino .field_name = "nonce",
385f5b1c8a1SJohn Marino .item = &ASN1_INTEGER_it,
386f5b1c8a1SJohn Marino },
387f5b1c8a1SJohn Marino {
388f5b1c8a1SJohn Marino .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_OPTIONAL,
389f5b1c8a1SJohn Marino .tag = 0,
390f5b1c8a1SJohn Marino .offset = offsetof(TS_TST_INFO, tsa),
391f5b1c8a1SJohn Marino .field_name = "tsa",
392f5b1c8a1SJohn Marino .item = &GENERAL_NAME_it,
393f5b1c8a1SJohn Marino },
394f5b1c8a1SJohn Marino {
395f5b1c8a1SJohn Marino .flags = ASN1_TFLG_IMPLICIT | ASN1_TFLG_SEQUENCE_OF | ASN1_TFLG_OPTIONAL,
396f5b1c8a1SJohn Marino .tag = 1,
397f5b1c8a1SJohn Marino .offset = offsetof(TS_TST_INFO, extensions),
398f5b1c8a1SJohn Marino .field_name = "extensions",
399f5b1c8a1SJohn Marino .item = &X509_EXTENSION_it,
400f5b1c8a1SJohn Marino },
401f5b1c8a1SJohn Marino };
402f5b1c8a1SJohn Marino
403f5b1c8a1SJohn Marino const ASN1_ITEM TS_TST_INFO_it = {
404f5b1c8a1SJohn Marino .itype = ASN1_ITYPE_SEQUENCE,
405f5b1c8a1SJohn Marino .utype = V_ASN1_SEQUENCE,
406f5b1c8a1SJohn Marino .templates = TS_TST_INFO_seq_tt,
407f5b1c8a1SJohn Marino .tcount = sizeof(TS_TST_INFO_seq_tt) / sizeof(ASN1_TEMPLATE),
408f5b1c8a1SJohn Marino .funcs = NULL,
409f5b1c8a1SJohn Marino .size = sizeof(TS_TST_INFO),
410f5b1c8a1SJohn Marino .sname = "TS_TST_INFO",
411f5b1c8a1SJohn Marino };
412f5b1c8a1SJohn Marino
413f5b1c8a1SJohn Marino
414f5b1c8a1SJohn Marino TS_TST_INFO *
d2i_TS_TST_INFO(TS_TST_INFO ** a,const unsigned char ** in,long len)415f5b1c8a1SJohn Marino d2i_TS_TST_INFO(TS_TST_INFO **a, const unsigned char **in, long len)
416f5b1c8a1SJohn Marino {
417f5b1c8a1SJohn Marino return (TS_TST_INFO *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
418f5b1c8a1SJohn Marino &TS_TST_INFO_it);
419f5b1c8a1SJohn Marino }
420f5b1c8a1SJohn Marino
421f5b1c8a1SJohn Marino int
i2d_TS_TST_INFO(const TS_TST_INFO * a,unsigned char ** out)422f5b1c8a1SJohn Marino i2d_TS_TST_INFO(const TS_TST_INFO *a, unsigned char **out)
423f5b1c8a1SJohn Marino {
424f5b1c8a1SJohn Marino return ASN1_item_i2d((ASN1_VALUE *)a, out, &TS_TST_INFO_it);
425f5b1c8a1SJohn Marino }
426f5b1c8a1SJohn Marino
427f5b1c8a1SJohn Marino TS_TST_INFO *
TS_TST_INFO_new(void)428f5b1c8a1SJohn Marino TS_TST_INFO_new(void)
429f5b1c8a1SJohn Marino {
430f5b1c8a1SJohn Marino return (TS_TST_INFO *)ASN1_item_new(&TS_TST_INFO_it);
431f5b1c8a1SJohn Marino }
432f5b1c8a1SJohn Marino
433f5b1c8a1SJohn Marino void
TS_TST_INFO_free(TS_TST_INFO * a)434f5b1c8a1SJohn Marino TS_TST_INFO_free(TS_TST_INFO *a)
435f5b1c8a1SJohn Marino {
436f5b1c8a1SJohn Marino ASN1_item_free((ASN1_VALUE *)a, &TS_TST_INFO_it);
437f5b1c8a1SJohn Marino }
438f5b1c8a1SJohn Marino
439f5b1c8a1SJohn Marino TS_TST_INFO *
TS_TST_INFO_dup(TS_TST_INFO * x)440f5b1c8a1SJohn Marino TS_TST_INFO_dup(TS_TST_INFO *x)
441f5b1c8a1SJohn Marino {
442f5b1c8a1SJohn Marino return ASN1_item_dup(&TS_TST_INFO_it, x);
443f5b1c8a1SJohn Marino }
444f5b1c8a1SJohn Marino
445f5b1c8a1SJohn Marino #ifndef OPENSSL_NO_BIO
446f5b1c8a1SJohn Marino TS_TST_INFO *
d2i_TS_TST_INFO_bio(BIO * bp,TS_TST_INFO ** a)447f5b1c8a1SJohn Marino d2i_TS_TST_INFO_bio(BIO *bp, TS_TST_INFO **a)
448f5b1c8a1SJohn Marino {
44972c33676SMaxim Ag return ASN1_item_d2i_bio(&TS_TST_INFO_it, bp, a);
450f5b1c8a1SJohn Marino }
451f5b1c8a1SJohn Marino
452f5b1c8a1SJohn Marino int
i2d_TS_TST_INFO_bio(BIO * bp,TS_TST_INFO * a)453f5b1c8a1SJohn Marino i2d_TS_TST_INFO_bio(BIO *bp, TS_TST_INFO *a)
454f5b1c8a1SJohn Marino {
45572c33676SMaxim Ag return ASN1_item_i2d_bio(&TS_TST_INFO_it, bp, a);
456f5b1c8a1SJohn Marino }
457f5b1c8a1SJohn Marino #endif
458f5b1c8a1SJohn Marino
459f5b1c8a1SJohn Marino TS_TST_INFO *
d2i_TS_TST_INFO_fp(FILE * fp,TS_TST_INFO ** a)460f5b1c8a1SJohn Marino d2i_TS_TST_INFO_fp(FILE *fp, TS_TST_INFO **a)
461f5b1c8a1SJohn Marino {
46272c33676SMaxim Ag return ASN1_item_d2i_fp(&TS_TST_INFO_it, fp, a);
463f5b1c8a1SJohn Marino }
464f5b1c8a1SJohn Marino
465f5b1c8a1SJohn Marino int
i2d_TS_TST_INFO_fp(FILE * fp,TS_TST_INFO * a)466f5b1c8a1SJohn Marino i2d_TS_TST_INFO_fp(FILE *fp, TS_TST_INFO *a)
467f5b1c8a1SJohn Marino {
46872c33676SMaxim Ag return ASN1_item_i2d_fp(&TS_TST_INFO_it, fp, a);
469f5b1c8a1SJohn Marino }
470f5b1c8a1SJohn Marino
471f5b1c8a1SJohn Marino static const ASN1_TEMPLATE TS_STATUS_INFO_seq_tt[] = {
472f5b1c8a1SJohn Marino {
473f5b1c8a1SJohn Marino .flags = 0,
474f5b1c8a1SJohn Marino .tag = 0,
475f5b1c8a1SJohn Marino .offset = offsetof(TS_STATUS_INFO, status),
476f5b1c8a1SJohn Marino .field_name = "status",
477f5b1c8a1SJohn Marino .item = &ASN1_INTEGER_it,
478f5b1c8a1SJohn Marino },
479f5b1c8a1SJohn Marino {
480f5b1c8a1SJohn Marino .flags = ASN1_TFLG_SEQUENCE_OF | ASN1_TFLG_OPTIONAL,
481f5b1c8a1SJohn Marino .tag = 0,
482f5b1c8a1SJohn Marino .offset = offsetof(TS_STATUS_INFO, text),
483f5b1c8a1SJohn Marino .field_name = "text",
484f5b1c8a1SJohn Marino .item = &ASN1_UTF8STRING_it,
485f5b1c8a1SJohn Marino },
486f5b1c8a1SJohn Marino {
487f5b1c8a1SJohn Marino .flags = ASN1_TFLG_OPTIONAL,
488f5b1c8a1SJohn Marino .tag = 0,
489f5b1c8a1SJohn Marino .offset = offsetof(TS_STATUS_INFO, failure_info),
490f5b1c8a1SJohn Marino .field_name = "failure_info",
491f5b1c8a1SJohn Marino .item = &ASN1_BIT_STRING_it,
492f5b1c8a1SJohn Marino },
493f5b1c8a1SJohn Marino };
494f5b1c8a1SJohn Marino
495f5b1c8a1SJohn Marino const ASN1_ITEM TS_STATUS_INFO_it = {
496f5b1c8a1SJohn Marino .itype = ASN1_ITYPE_SEQUENCE,
497f5b1c8a1SJohn Marino .utype = V_ASN1_SEQUENCE,
498f5b1c8a1SJohn Marino .templates = TS_STATUS_INFO_seq_tt,
499f5b1c8a1SJohn Marino .tcount = sizeof(TS_STATUS_INFO_seq_tt) / sizeof(ASN1_TEMPLATE),
500f5b1c8a1SJohn Marino .funcs = NULL,
501f5b1c8a1SJohn Marino .size = sizeof(TS_STATUS_INFO),
502f5b1c8a1SJohn Marino .sname = "TS_STATUS_INFO",
503f5b1c8a1SJohn Marino };
504f5b1c8a1SJohn Marino
505f5b1c8a1SJohn Marino
506f5b1c8a1SJohn Marino TS_STATUS_INFO *
d2i_TS_STATUS_INFO(TS_STATUS_INFO ** a,const unsigned char ** in,long len)507f5b1c8a1SJohn Marino d2i_TS_STATUS_INFO(TS_STATUS_INFO **a, const unsigned char **in, long len)
508f5b1c8a1SJohn Marino {
509f5b1c8a1SJohn Marino return (TS_STATUS_INFO *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
510f5b1c8a1SJohn Marino &TS_STATUS_INFO_it);
511f5b1c8a1SJohn Marino }
512f5b1c8a1SJohn Marino
513f5b1c8a1SJohn Marino int
i2d_TS_STATUS_INFO(const TS_STATUS_INFO * a,unsigned char ** out)514f5b1c8a1SJohn Marino i2d_TS_STATUS_INFO(const TS_STATUS_INFO *a, unsigned char **out)
515f5b1c8a1SJohn Marino {
516f5b1c8a1SJohn Marino return ASN1_item_i2d((ASN1_VALUE *)a, out, &TS_STATUS_INFO_it);
517f5b1c8a1SJohn Marino }
518f5b1c8a1SJohn Marino
519f5b1c8a1SJohn Marino TS_STATUS_INFO *
TS_STATUS_INFO_new(void)520f5b1c8a1SJohn Marino TS_STATUS_INFO_new(void)
521f5b1c8a1SJohn Marino {
522f5b1c8a1SJohn Marino return (TS_STATUS_INFO *)ASN1_item_new(&TS_STATUS_INFO_it);
523f5b1c8a1SJohn Marino }
524f5b1c8a1SJohn Marino
525f5b1c8a1SJohn Marino void
TS_STATUS_INFO_free(TS_STATUS_INFO * a)526f5b1c8a1SJohn Marino TS_STATUS_INFO_free(TS_STATUS_INFO *a)
527f5b1c8a1SJohn Marino {
528f5b1c8a1SJohn Marino ASN1_item_free((ASN1_VALUE *)a, &TS_STATUS_INFO_it);
529f5b1c8a1SJohn Marino }
530f5b1c8a1SJohn Marino
531f5b1c8a1SJohn Marino TS_STATUS_INFO *
TS_STATUS_INFO_dup(TS_STATUS_INFO * x)532f5b1c8a1SJohn Marino TS_STATUS_INFO_dup(TS_STATUS_INFO *x)
533f5b1c8a1SJohn Marino {
534f5b1c8a1SJohn Marino return ASN1_item_dup(&TS_STATUS_INFO_it, x);
535f5b1c8a1SJohn Marino }
536f5b1c8a1SJohn Marino
537f5b1c8a1SJohn Marino static int
ts_resp_set_tst_info(TS_RESP * a)538f5b1c8a1SJohn Marino ts_resp_set_tst_info(TS_RESP *a)
539f5b1c8a1SJohn Marino {
540f5b1c8a1SJohn Marino long status;
541f5b1c8a1SJohn Marino
542f5b1c8a1SJohn Marino status = ASN1_INTEGER_get(a->status_info->status);
543f5b1c8a1SJohn Marino
544f5b1c8a1SJohn Marino if (a->token) {
545f5b1c8a1SJohn Marino if (status != 0 && status != 1) {
54672c33676SMaxim Ag TSerror(TS_R_TOKEN_PRESENT);
547f5b1c8a1SJohn Marino return 0;
548f5b1c8a1SJohn Marino }
549f5b1c8a1SJohn Marino if (a->tst_info != NULL)
550f5b1c8a1SJohn Marino TS_TST_INFO_free(a->tst_info);
551f5b1c8a1SJohn Marino a->tst_info = PKCS7_to_TS_TST_INFO(a->token);
552f5b1c8a1SJohn Marino if (!a->tst_info) {
55372c33676SMaxim Ag TSerror(TS_R_PKCS7_TO_TS_TST_INFO_FAILED);
554f5b1c8a1SJohn Marino return 0;
555f5b1c8a1SJohn Marino }
556f5b1c8a1SJohn Marino } else if (status == 0 || status == 1) {
55772c33676SMaxim Ag TSerror(TS_R_TOKEN_NOT_PRESENT);
558f5b1c8a1SJohn Marino return 0;
559f5b1c8a1SJohn Marino }
560f5b1c8a1SJohn Marino
561f5b1c8a1SJohn Marino return 1;
562f5b1c8a1SJohn Marino }
563f5b1c8a1SJohn Marino
564f5b1c8a1SJohn Marino static int
ts_resp_cb(int op,ASN1_VALUE ** pval,const ASN1_ITEM * it,void * exarg)565f5b1c8a1SJohn Marino ts_resp_cb(int op, ASN1_VALUE **pval, const ASN1_ITEM *it, void *exarg)
566f5b1c8a1SJohn Marino {
567f5b1c8a1SJohn Marino TS_RESP *ts_resp = (TS_RESP *)*pval;
568f5b1c8a1SJohn Marino
569f5b1c8a1SJohn Marino if (op == ASN1_OP_NEW_POST) {
570f5b1c8a1SJohn Marino ts_resp->tst_info = NULL;
571f5b1c8a1SJohn Marino } else if (op == ASN1_OP_FREE_POST) {
572f5b1c8a1SJohn Marino if (ts_resp->tst_info != NULL)
573f5b1c8a1SJohn Marino TS_TST_INFO_free(ts_resp->tst_info);
574f5b1c8a1SJohn Marino } else if (op == ASN1_OP_D2I_POST) {
575f5b1c8a1SJohn Marino if (ts_resp_set_tst_info(ts_resp) == 0)
576f5b1c8a1SJohn Marino return 0;
577f5b1c8a1SJohn Marino }
578f5b1c8a1SJohn Marino return 1;
579f5b1c8a1SJohn Marino }
580f5b1c8a1SJohn Marino
581f5b1c8a1SJohn Marino static const ASN1_AUX TS_RESP_aux = {
582f5b1c8a1SJohn Marino .app_data = NULL,
583f5b1c8a1SJohn Marino .flags = 0,
584f5b1c8a1SJohn Marino .ref_offset = 0,
585f5b1c8a1SJohn Marino .ref_lock = 0,
586f5b1c8a1SJohn Marino .asn1_cb = ts_resp_cb,
587f5b1c8a1SJohn Marino .enc_offset = 0,
588f5b1c8a1SJohn Marino };
589f5b1c8a1SJohn Marino static const ASN1_TEMPLATE TS_RESP_seq_tt[] = {
590f5b1c8a1SJohn Marino {
591f5b1c8a1SJohn Marino .flags = 0,
592f5b1c8a1SJohn Marino .tag = 0,
593f5b1c8a1SJohn Marino .offset = offsetof(TS_RESP, status_info),
594f5b1c8a1SJohn Marino .field_name = "status_info",
595f5b1c8a1SJohn Marino .item = &TS_STATUS_INFO_it,
596f5b1c8a1SJohn Marino },
597f5b1c8a1SJohn Marino {
598f5b1c8a1SJohn Marino .flags = ASN1_TFLG_OPTIONAL,
599f5b1c8a1SJohn Marino .tag = 0,
600f5b1c8a1SJohn Marino .offset = offsetof(TS_RESP, token),
601f5b1c8a1SJohn Marino .field_name = "token",
602f5b1c8a1SJohn Marino .item = &PKCS7_it,
603f5b1c8a1SJohn Marino },
604f5b1c8a1SJohn Marino };
605f5b1c8a1SJohn Marino
606f5b1c8a1SJohn Marino const ASN1_ITEM TS_RESP_it = {
607f5b1c8a1SJohn Marino .itype = ASN1_ITYPE_SEQUENCE,
608f5b1c8a1SJohn Marino .utype = V_ASN1_SEQUENCE,
609f5b1c8a1SJohn Marino .templates = TS_RESP_seq_tt,
610f5b1c8a1SJohn Marino .tcount = sizeof(TS_RESP_seq_tt) / sizeof(ASN1_TEMPLATE),
611f5b1c8a1SJohn Marino .funcs = &TS_RESP_aux,
612f5b1c8a1SJohn Marino .size = sizeof(TS_RESP),
613f5b1c8a1SJohn Marino .sname = "TS_RESP",
614f5b1c8a1SJohn Marino };
615f5b1c8a1SJohn Marino
616f5b1c8a1SJohn Marino
617f5b1c8a1SJohn Marino TS_RESP *
d2i_TS_RESP(TS_RESP ** a,const unsigned char ** in,long len)618f5b1c8a1SJohn Marino d2i_TS_RESP(TS_RESP **a, const unsigned char **in, long len)
619f5b1c8a1SJohn Marino {
620f5b1c8a1SJohn Marino return (TS_RESP *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
621f5b1c8a1SJohn Marino &TS_RESP_it);
622f5b1c8a1SJohn Marino }
623f5b1c8a1SJohn Marino
624f5b1c8a1SJohn Marino int
i2d_TS_RESP(const TS_RESP * a,unsigned char ** out)625f5b1c8a1SJohn Marino i2d_TS_RESP(const TS_RESP *a, unsigned char **out)
626f5b1c8a1SJohn Marino {
627f5b1c8a1SJohn Marino return ASN1_item_i2d((ASN1_VALUE *)a, out, &TS_RESP_it);
628f5b1c8a1SJohn Marino }
629f5b1c8a1SJohn Marino
630f5b1c8a1SJohn Marino TS_RESP *
TS_RESP_new(void)631f5b1c8a1SJohn Marino TS_RESP_new(void)
632f5b1c8a1SJohn Marino {
633f5b1c8a1SJohn Marino return (TS_RESP *)ASN1_item_new(&TS_RESP_it);
634f5b1c8a1SJohn Marino }
635f5b1c8a1SJohn Marino
636f5b1c8a1SJohn Marino void
TS_RESP_free(TS_RESP * a)637f5b1c8a1SJohn Marino TS_RESP_free(TS_RESP *a)
638f5b1c8a1SJohn Marino {
639f5b1c8a1SJohn Marino ASN1_item_free((ASN1_VALUE *)a, &TS_RESP_it);
640f5b1c8a1SJohn Marino }
641f5b1c8a1SJohn Marino
642f5b1c8a1SJohn Marino TS_RESP *
TS_RESP_dup(TS_RESP * x)643f5b1c8a1SJohn Marino TS_RESP_dup(TS_RESP *x)
644f5b1c8a1SJohn Marino {
645f5b1c8a1SJohn Marino return ASN1_item_dup(&TS_RESP_it, x);
646f5b1c8a1SJohn Marino }
647f5b1c8a1SJohn Marino
648f5b1c8a1SJohn Marino #ifndef OPENSSL_NO_BIO
649f5b1c8a1SJohn Marino TS_RESP *
d2i_TS_RESP_bio(BIO * bp,TS_RESP ** a)650f5b1c8a1SJohn Marino d2i_TS_RESP_bio(BIO *bp, TS_RESP **a)
651f5b1c8a1SJohn Marino {
65272c33676SMaxim Ag return ASN1_item_d2i_bio(&TS_RESP_it, bp, a);
653f5b1c8a1SJohn Marino }
654f5b1c8a1SJohn Marino
655f5b1c8a1SJohn Marino int
i2d_TS_RESP_bio(BIO * bp,TS_RESP * a)656f5b1c8a1SJohn Marino i2d_TS_RESP_bio(BIO *bp, TS_RESP *a)
657f5b1c8a1SJohn Marino {
65872c33676SMaxim Ag return ASN1_item_i2d_bio(&TS_RESP_it, bp, a);
659f5b1c8a1SJohn Marino }
660f5b1c8a1SJohn Marino #endif
661f5b1c8a1SJohn Marino
662f5b1c8a1SJohn Marino TS_RESP *
d2i_TS_RESP_fp(FILE * fp,TS_RESP ** a)663f5b1c8a1SJohn Marino d2i_TS_RESP_fp(FILE *fp, TS_RESP **a)
664f5b1c8a1SJohn Marino {
66572c33676SMaxim Ag return ASN1_item_d2i_fp(&TS_RESP_it, fp, a);
666f5b1c8a1SJohn Marino }
667f5b1c8a1SJohn Marino
668f5b1c8a1SJohn Marino int
i2d_TS_RESP_fp(FILE * fp,TS_RESP * a)669f5b1c8a1SJohn Marino i2d_TS_RESP_fp(FILE *fp, TS_RESP *a)
670f5b1c8a1SJohn Marino {
67172c33676SMaxim Ag return ASN1_item_i2d_fp(&TS_RESP_it, fp, a);
672f5b1c8a1SJohn Marino }
673f5b1c8a1SJohn Marino
674f5b1c8a1SJohn Marino static const ASN1_TEMPLATE ESS_ISSUER_SERIAL_seq_tt[] = {
675f5b1c8a1SJohn Marino {
676f5b1c8a1SJohn Marino .flags = ASN1_TFLG_SEQUENCE_OF,
677f5b1c8a1SJohn Marino .tag = 0,
678f5b1c8a1SJohn Marino .offset = offsetof(ESS_ISSUER_SERIAL, issuer),
679f5b1c8a1SJohn Marino .field_name = "issuer",
680f5b1c8a1SJohn Marino .item = &GENERAL_NAME_it,
681f5b1c8a1SJohn Marino },
682f5b1c8a1SJohn Marino {
683f5b1c8a1SJohn Marino .flags = 0,
684f5b1c8a1SJohn Marino .tag = 0,
685f5b1c8a1SJohn Marino .offset = offsetof(ESS_ISSUER_SERIAL, serial),
686f5b1c8a1SJohn Marino .field_name = "serial",
687f5b1c8a1SJohn Marino .item = &ASN1_INTEGER_it,
688f5b1c8a1SJohn Marino },
689f5b1c8a1SJohn Marino };
690f5b1c8a1SJohn Marino
691f5b1c8a1SJohn Marino const ASN1_ITEM ESS_ISSUER_SERIAL_it = {
692f5b1c8a1SJohn Marino .itype = ASN1_ITYPE_SEQUENCE,
693f5b1c8a1SJohn Marino .utype = V_ASN1_SEQUENCE,
694f5b1c8a1SJohn Marino .templates = ESS_ISSUER_SERIAL_seq_tt,
695f5b1c8a1SJohn Marino .tcount = sizeof(ESS_ISSUER_SERIAL_seq_tt) / sizeof(ASN1_TEMPLATE),
696f5b1c8a1SJohn Marino .funcs = NULL,
697f5b1c8a1SJohn Marino .size = sizeof(ESS_ISSUER_SERIAL),
698f5b1c8a1SJohn Marino .sname = "ESS_ISSUER_SERIAL",
699f5b1c8a1SJohn Marino };
700f5b1c8a1SJohn Marino
701f5b1c8a1SJohn Marino
702f5b1c8a1SJohn Marino ESS_ISSUER_SERIAL *
d2i_ESS_ISSUER_SERIAL(ESS_ISSUER_SERIAL ** a,const unsigned char ** in,long len)703f5b1c8a1SJohn Marino d2i_ESS_ISSUER_SERIAL(ESS_ISSUER_SERIAL **a, const unsigned char **in, long len)
704f5b1c8a1SJohn Marino {
705f5b1c8a1SJohn Marino return (ESS_ISSUER_SERIAL *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
706f5b1c8a1SJohn Marino &ESS_ISSUER_SERIAL_it);
707f5b1c8a1SJohn Marino }
708f5b1c8a1SJohn Marino
709f5b1c8a1SJohn Marino int
i2d_ESS_ISSUER_SERIAL(const ESS_ISSUER_SERIAL * a,unsigned char ** out)710f5b1c8a1SJohn Marino i2d_ESS_ISSUER_SERIAL(const ESS_ISSUER_SERIAL *a, unsigned char **out)
711f5b1c8a1SJohn Marino {
712f5b1c8a1SJohn Marino return ASN1_item_i2d((ASN1_VALUE *)a, out, &ESS_ISSUER_SERIAL_it);
713f5b1c8a1SJohn Marino }
714f5b1c8a1SJohn Marino
715f5b1c8a1SJohn Marino ESS_ISSUER_SERIAL *
ESS_ISSUER_SERIAL_new(void)716f5b1c8a1SJohn Marino ESS_ISSUER_SERIAL_new(void)
717f5b1c8a1SJohn Marino {
718f5b1c8a1SJohn Marino return (ESS_ISSUER_SERIAL *)ASN1_item_new(&ESS_ISSUER_SERIAL_it);
719f5b1c8a1SJohn Marino }
720f5b1c8a1SJohn Marino
721f5b1c8a1SJohn Marino void
ESS_ISSUER_SERIAL_free(ESS_ISSUER_SERIAL * a)722f5b1c8a1SJohn Marino ESS_ISSUER_SERIAL_free(ESS_ISSUER_SERIAL *a)
723f5b1c8a1SJohn Marino {
724f5b1c8a1SJohn Marino ASN1_item_free((ASN1_VALUE *)a, &ESS_ISSUER_SERIAL_it);
725f5b1c8a1SJohn Marino }
726f5b1c8a1SJohn Marino
727f5b1c8a1SJohn Marino ESS_ISSUER_SERIAL *
ESS_ISSUER_SERIAL_dup(ESS_ISSUER_SERIAL * x)728f5b1c8a1SJohn Marino ESS_ISSUER_SERIAL_dup(ESS_ISSUER_SERIAL *x)
729f5b1c8a1SJohn Marino {
730f5b1c8a1SJohn Marino return ASN1_item_dup(&ESS_ISSUER_SERIAL_it, x);
731f5b1c8a1SJohn Marino }
732f5b1c8a1SJohn Marino
733f5b1c8a1SJohn Marino static const ASN1_TEMPLATE ESS_CERT_ID_seq_tt[] = {
734f5b1c8a1SJohn Marino {
735f5b1c8a1SJohn Marino .flags = 0,
736f5b1c8a1SJohn Marino .tag = 0,
737f5b1c8a1SJohn Marino .offset = offsetof(ESS_CERT_ID, hash),
738f5b1c8a1SJohn Marino .field_name = "hash",
739f5b1c8a1SJohn Marino .item = &ASN1_OCTET_STRING_it,
740f5b1c8a1SJohn Marino },
741f5b1c8a1SJohn Marino {
742f5b1c8a1SJohn Marino .flags = ASN1_TFLG_OPTIONAL,
743f5b1c8a1SJohn Marino .tag = 0,
744f5b1c8a1SJohn Marino .offset = offsetof(ESS_CERT_ID, issuer_serial),
745f5b1c8a1SJohn Marino .field_name = "issuer_serial",
746f5b1c8a1SJohn Marino .item = &ESS_ISSUER_SERIAL_it,
747f5b1c8a1SJohn Marino },
748f5b1c8a1SJohn Marino };
749f5b1c8a1SJohn Marino
750f5b1c8a1SJohn Marino const ASN1_ITEM ESS_CERT_ID_it = {
751f5b1c8a1SJohn Marino .itype = ASN1_ITYPE_SEQUENCE,
752f5b1c8a1SJohn Marino .utype = V_ASN1_SEQUENCE,
753f5b1c8a1SJohn Marino .templates = ESS_CERT_ID_seq_tt,
754f5b1c8a1SJohn Marino .tcount = sizeof(ESS_CERT_ID_seq_tt) / sizeof(ASN1_TEMPLATE),
755f5b1c8a1SJohn Marino .funcs = NULL,
756f5b1c8a1SJohn Marino .size = sizeof(ESS_CERT_ID),
757f5b1c8a1SJohn Marino .sname = "ESS_CERT_ID",
758f5b1c8a1SJohn Marino };
759f5b1c8a1SJohn Marino
760f5b1c8a1SJohn Marino
761f5b1c8a1SJohn Marino ESS_CERT_ID *
d2i_ESS_CERT_ID(ESS_CERT_ID ** a,const unsigned char ** in,long len)762f5b1c8a1SJohn Marino d2i_ESS_CERT_ID(ESS_CERT_ID **a, const unsigned char **in, long len)
763f5b1c8a1SJohn Marino {
764f5b1c8a1SJohn Marino return (ESS_CERT_ID *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
765f5b1c8a1SJohn Marino &ESS_CERT_ID_it);
766f5b1c8a1SJohn Marino }
767f5b1c8a1SJohn Marino
768f5b1c8a1SJohn Marino int
i2d_ESS_CERT_ID(const ESS_CERT_ID * a,unsigned char ** out)769f5b1c8a1SJohn Marino i2d_ESS_CERT_ID(const ESS_CERT_ID *a, unsigned char **out)
770f5b1c8a1SJohn Marino {
771f5b1c8a1SJohn Marino return ASN1_item_i2d((ASN1_VALUE *)a, out, &ESS_CERT_ID_it);
772f5b1c8a1SJohn Marino }
773f5b1c8a1SJohn Marino
774f5b1c8a1SJohn Marino ESS_CERT_ID *
ESS_CERT_ID_new(void)775f5b1c8a1SJohn Marino ESS_CERT_ID_new(void)
776f5b1c8a1SJohn Marino {
777f5b1c8a1SJohn Marino return (ESS_CERT_ID *)ASN1_item_new(&ESS_CERT_ID_it);
778f5b1c8a1SJohn Marino }
779f5b1c8a1SJohn Marino
780f5b1c8a1SJohn Marino void
ESS_CERT_ID_free(ESS_CERT_ID * a)781f5b1c8a1SJohn Marino ESS_CERT_ID_free(ESS_CERT_ID *a)
782f5b1c8a1SJohn Marino {
783f5b1c8a1SJohn Marino ASN1_item_free((ASN1_VALUE *)a, &ESS_CERT_ID_it);
784f5b1c8a1SJohn Marino }
785f5b1c8a1SJohn Marino
786f5b1c8a1SJohn Marino ESS_CERT_ID *
ESS_CERT_ID_dup(ESS_CERT_ID * x)787f5b1c8a1SJohn Marino ESS_CERT_ID_dup(ESS_CERT_ID *x)
788f5b1c8a1SJohn Marino {
789f5b1c8a1SJohn Marino return ASN1_item_dup(&ESS_CERT_ID_it, x);
790f5b1c8a1SJohn Marino }
791f5b1c8a1SJohn Marino
792f5b1c8a1SJohn Marino static const ASN1_TEMPLATE ESS_SIGNING_CERT_seq_tt[] = {
793f5b1c8a1SJohn Marino {
794f5b1c8a1SJohn Marino .flags = ASN1_TFLG_SEQUENCE_OF,
795f5b1c8a1SJohn Marino .tag = 0,
796f5b1c8a1SJohn Marino .offset = offsetof(ESS_SIGNING_CERT, cert_ids),
797f5b1c8a1SJohn Marino .field_name = "cert_ids",
798f5b1c8a1SJohn Marino .item = &ESS_CERT_ID_it,
799f5b1c8a1SJohn Marino },
800f5b1c8a1SJohn Marino {
801f5b1c8a1SJohn Marino .flags = ASN1_TFLG_SEQUENCE_OF | ASN1_TFLG_OPTIONAL,
802f5b1c8a1SJohn Marino .tag = 0,
803f5b1c8a1SJohn Marino .offset = offsetof(ESS_SIGNING_CERT, policy_info),
804f5b1c8a1SJohn Marino .field_name = "policy_info",
805f5b1c8a1SJohn Marino .item = &POLICYINFO_it,
806f5b1c8a1SJohn Marino },
807f5b1c8a1SJohn Marino };
808f5b1c8a1SJohn Marino
809f5b1c8a1SJohn Marino const ASN1_ITEM ESS_SIGNING_CERT_it = {
810f5b1c8a1SJohn Marino .itype = ASN1_ITYPE_SEQUENCE,
811f5b1c8a1SJohn Marino .utype = V_ASN1_SEQUENCE,
812f5b1c8a1SJohn Marino .templates = ESS_SIGNING_CERT_seq_tt,
813f5b1c8a1SJohn Marino .tcount = sizeof(ESS_SIGNING_CERT_seq_tt) / sizeof(ASN1_TEMPLATE),
814f5b1c8a1SJohn Marino .funcs = NULL,
815f5b1c8a1SJohn Marino .size = sizeof(ESS_SIGNING_CERT),
816f5b1c8a1SJohn Marino .sname = "ESS_SIGNING_CERT",
817f5b1c8a1SJohn Marino };
818f5b1c8a1SJohn Marino
819f5b1c8a1SJohn Marino
820f5b1c8a1SJohn Marino ESS_SIGNING_CERT *
d2i_ESS_SIGNING_CERT(ESS_SIGNING_CERT ** a,const unsigned char ** in,long len)821f5b1c8a1SJohn Marino d2i_ESS_SIGNING_CERT(ESS_SIGNING_CERT **a, const unsigned char **in, long len)
822f5b1c8a1SJohn Marino {
823f5b1c8a1SJohn Marino return (ESS_SIGNING_CERT *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
824f5b1c8a1SJohn Marino &ESS_SIGNING_CERT_it);
825f5b1c8a1SJohn Marino }
826f5b1c8a1SJohn Marino
827f5b1c8a1SJohn Marino int
i2d_ESS_SIGNING_CERT(const ESS_SIGNING_CERT * a,unsigned char ** out)828f5b1c8a1SJohn Marino i2d_ESS_SIGNING_CERT(const ESS_SIGNING_CERT *a, unsigned char **out)
829f5b1c8a1SJohn Marino {
830f5b1c8a1SJohn Marino return ASN1_item_i2d((ASN1_VALUE *)a, out, &ESS_SIGNING_CERT_it);
831f5b1c8a1SJohn Marino }
832f5b1c8a1SJohn Marino
833f5b1c8a1SJohn Marino ESS_SIGNING_CERT *
ESS_SIGNING_CERT_new(void)834f5b1c8a1SJohn Marino ESS_SIGNING_CERT_new(void)
835f5b1c8a1SJohn Marino {
836f5b1c8a1SJohn Marino return (ESS_SIGNING_CERT *)ASN1_item_new(&ESS_SIGNING_CERT_it);
837f5b1c8a1SJohn Marino }
838f5b1c8a1SJohn Marino
839f5b1c8a1SJohn Marino void
ESS_SIGNING_CERT_free(ESS_SIGNING_CERT * a)840f5b1c8a1SJohn Marino ESS_SIGNING_CERT_free(ESS_SIGNING_CERT *a)
841f5b1c8a1SJohn Marino {
842f5b1c8a1SJohn Marino ASN1_item_free((ASN1_VALUE *)a, &ESS_SIGNING_CERT_it);
843f5b1c8a1SJohn Marino }
844f5b1c8a1SJohn Marino
845f5b1c8a1SJohn Marino ESS_SIGNING_CERT *
ESS_SIGNING_CERT_dup(ESS_SIGNING_CERT * x)846f5b1c8a1SJohn Marino ESS_SIGNING_CERT_dup(ESS_SIGNING_CERT *x)
847f5b1c8a1SJohn Marino {
848f5b1c8a1SJohn Marino return ASN1_item_dup(&ESS_SIGNING_CERT_it, x);
849f5b1c8a1SJohn Marino }
850f5b1c8a1SJohn Marino
851*de0e0e4dSAntonio Huete Jimenez static const ASN1_TEMPLATE ESS_CERT_ID_V2_seq_tt[] = {
852*de0e0e4dSAntonio Huete Jimenez {
853*de0e0e4dSAntonio Huete Jimenez .flags = ASN1_TFLG_OPTIONAL,
854*de0e0e4dSAntonio Huete Jimenez .tag = 0,
855*de0e0e4dSAntonio Huete Jimenez .offset = offsetof(ESS_CERT_ID_V2, hash_alg),
856*de0e0e4dSAntonio Huete Jimenez .field_name = "hash_alg",
857*de0e0e4dSAntonio Huete Jimenez .item = &X509_ALGOR_it,
858*de0e0e4dSAntonio Huete Jimenez },
859*de0e0e4dSAntonio Huete Jimenez {
860*de0e0e4dSAntonio Huete Jimenez .flags = 0,
861*de0e0e4dSAntonio Huete Jimenez .tag = 0,
862*de0e0e4dSAntonio Huete Jimenez .offset = offsetof(ESS_CERT_ID_V2, hash),
863*de0e0e4dSAntonio Huete Jimenez .field_name = "hash",
864*de0e0e4dSAntonio Huete Jimenez .item = &ASN1_OCTET_STRING_it,
865*de0e0e4dSAntonio Huete Jimenez },
866*de0e0e4dSAntonio Huete Jimenez {
867*de0e0e4dSAntonio Huete Jimenez .flags = ASN1_TFLG_OPTIONAL,
868*de0e0e4dSAntonio Huete Jimenez .tag = 0,
869*de0e0e4dSAntonio Huete Jimenez .offset = offsetof(ESS_CERT_ID_V2, issuer_serial),
870*de0e0e4dSAntonio Huete Jimenez .field_name = "issuer_serial",
871*de0e0e4dSAntonio Huete Jimenez .item = &ESS_ISSUER_SERIAL_it,
872*de0e0e4dSAntonio Huete Jimenez },
873*de0e0e4dSAntonio Huete Jimenez };
874*de0e0e4dSAntonio Huete Jimenez
875*de0e0e4dSAntonio Huete Jimenez static const ASN1_ITEM ESS_CERT_ID_V2_it = {
876*de0e0e4dSAntonio Huete Jimenez .itype = ASN1_ITYPE_SEQUENCE,
877*de0e0e4dSAntonio Huete Jimenez .utype = V_ASN1_SEQUENCE,
878*de0e0e4dSAntonio Huete Jimenez .templates = ESS_CERT_ID_V2_seq_tt,
879*de0e0e4dSAntonio Huete Jimenez .tcount = sizeof(ESS_CERT_ID_V2_seq_tt) / sizeof(ASN1_TEMPLATE),
880*de0e0e4dSAntonio Huete Jimenez .funcs = NULL,
881*de0e0e4dSAntonio Huete Jimenez .size = sizeof(ESS_CERT_ID_V2),
882*de0e0e4dSAntonio Huete Jimenez .sname = "ESS_CERT_ID_V2",
883*de0e0e4dSAntonio Huete Jimenez };
884*de0e0e4dSAntonio Huete Jimenez
885*de0e0e4dSAntonio Huete Jimenez ESS_CERT_ID_V2 *
d2i_ESS_CERT_ID_V2(ESS_CERT_ID_V2 ** a,const unsigned char ** in,long len)886*de0e0e4dSAntonio Huete Jimenez d2i_ESS_CERT_ID_V2(ESS_CERT_ID_V2 **a, const unsigned char **in, long len)
887*de0e0e4dSAntonio Huete Jimenez {
888*de0e0e4dSAntonio Huete Jimenez return (ESS_CERT_ID_V2 *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
889*de0e0e4dSAntonio Huete Jimenez &ESS_CERT_ID_V2_it);
890*de0e0e4dSAntonio Huete Jimenez }
891*de0e0e4dSAntonio Huete Jimenez
892*de0e0e4dSAntonio Huete Jimenez int
i2d_ESS_CERT_ID_V2(const ESS_CERT_ID_V2 * a,unsigned char ** out)893*de0e0e4dSAntonio Huete Jimenez i2d_ESS_CERT_ID_V2(const ESS_CERT_ID_V2 *a, unsigned char **out)
894*de0e0e4dSAntonio Huete Jimenez {
895*de0e0e4dSAntonio Huete Jimenez return ASN1_item_i2d((ASN1_VALUE *)a, out, &ESS_CERT_ID_V2_it);
896*de0e0e4dSAntonio Huete Jimenez }
897*de0e0e4dSAntonio Huete Jimenez
898*de0e0e4dSAntonio Huete Jimenez ESS_CERT_ID_V2 *
ESS_CERT_ID_V2_new(void)899*de0e0e4dSAntonio Huete Jimenez ESS_CERT_ID_V2_new(void)
900*de0e0e4dSAntonio Huete Jimenez {
901*de0e0e4dSAntonio Huete Jimenez return (ESS_CERT_ID_V2 *)ASN1_item_new(&ESS_CERT_ID_V2_it);
902*de0e0e4dSAntonio Huete Jimenez }
903*de0e0e4dSAntonio Huete Jimenez
904*de0e0e4dSAntonio Huete Jimenez void
ESS_CERT_ID_V2_free(ESS_CERT_ID_V2 * a)905*de0e0e4dSAntonio Huete Jimenez ESS_CERT_ID_V2_free(ESS_CERT_ID_V2 *a)
906*de0e0e4dSAntonio Huete Jimenez {
907*de0e0e4dSAntonio Huete Jimenez ASN1_item_free((ASN1_VALUE *)a, &ESS_CERT_ID_V2_it);
908*de0e0e4dSAntonio Huete Jimenez }
909*de0e0e4dSAntonio Huete Jimenez
910*de0e0e4dSAntonio Huete Jimenez ESS_CERT_ID_V2 *
ESS_CERT_ID_V2_dup(ESS_CERT_ID_V2 * x)911*de0e0e4dSAntonio Huete Jimenez ESS_CERT_ID_V2_dup(ESS_CERT_ID_V2 *x)
912*de0e0e4dSAntonio Huete Jimenez {
913*de0e0e4dSAntonio Huete Jimenez return ASN1_item_dup(&ESS_CERT_ID_V2_it, x);
914*de0e0e4dSAntonio Huete Jimenez }
915*de0e0e4dSAntonio Huete Jimenez
916*de0e0e4dSAntonio Huete Jimenez static const ASN1_TEMPLATE ESS_SIGNING_CERT_V2_seq_tt[] = {
917*de0e0e4dSAntonio Huete Jimenez {
918*de0e0e4dSAntonio Huete Jimenez .flags = ASN1_TFLG_SEQUENCE_OF,
919*de0e0e4dSAntonio Huete Jimenez .tag = 0,
920*de0e0e4dSAntonio Huete Jimenez .offset = offsetof(ESS_SIGNING_CERT_V2, cert_ids),
921*de0e0e4dSAntonio Huete Jimenez .field_name = "cert_ids",
922*de0e0e4dSAntonio Huete Jimenez .item = &ESS_CERT_ID_V2_it,
923*de0e0e4dSAntonio Huete Jimenez },
924*de0e0e4dSAntonio Huete Jimenez {
925*de0e0e4dSAntonio Huete Jimenez .flags = ASN1_TFLG_SEQUENCE_OF | ASN1_TFLG_OPTIONAL,
926*de0e0e4dSAntonio Huete Jimenez .tag = 0,
927*de0e0e4dSAntonio Huete Jimenez .offset = offsetof(ESS_SIGNING_CERT_V2, policy_info),
928*de0e0e4dSAntonio Huete Jimenez .field_name = "policy_info",
929*de0e0e4dSAntonio Huete Jimenez .item = &POLICYINFO_it,
930*de0e0e4dSAntonio Huete Jimenez },
931*de0e0e4dSAntonio Huete Jimenez };
932*de0e0e4dSAntonio Huete Jimenez
933*de0e0e4dSAntonio Huete Jimenez static const ASN1_ITEM ESS_SIGNING_CERT_V2_it = {
934*de0e0e4dSAntonio Huete Jimenez .itype = ASN1_ITYPE_SEQUENCE,
935*de0e0e4dSAntonio Huete Jimenez .utype = V_ASN1_SEQUENCE,
936*de0e0e4dSAntonio Huete Jimenez .templates = ESS_SIGNING_CERT_V2_seq_tt,
937*de0e0e4dSAntonio Huete Jimenez .tcount = sizeof(ESS_SIGNING_CERT_V2_seq_tt) / sizeof(ASN1_TEMPLATE),
938*de0e0e4dSAntonio Huete Jimenez .funcs = NULL,
939*de0e0e4dSAntonio Huete Jimenez .size = sizeof(ESS_SIGNING_CERT_V2),
940*de0e0e4dSAntonio Huete Jimenez .sname = "ESS_SIGNING_CERT_V2",
941*de0e0e4dSAntonio Huete Jimenez };
942*de0e0e4dSAntonio Huete Jimenez
943*de0e0e4dSAntonio Huete Jimenez ESS_SIGNING_CERT_V2 *
d2i_ESS_SIGNING_CERT_V2(ESS_SIGNING_CERT_V2 ** a,const unsigned char ** in,long len)944*de0e0e4dSAntonio Huete Jimenez d2i_ESS_SIGNING_CERT_V2(ESS_SIGNING_CERT_V2 **a, const unsigned char **in, long len)
945*de0e0e4dSAntonio Huete Jimenez {
946*de0e0e4dSAntonio Huete Jimenez return (ESS_SIGNING_CERT_V2 *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
947*de0e0e4dSAntonio Huete Jimenez &ESS_SIGNING_CERT_V2_it);
948*de0e0e4dSAntonio Huete Jimenez }
949*de0e0e4dSAntonio Huete Jimenez
950*de0e0e4dSAntonio Huete Jimenez int
i2d_ESS_SIGNING_CERT_V2(const ESS_SIGNING_CERT_V2 * a,unsigned char ** out)951*de0e0e4dSAntonio Huete Jimenez i2d_ESS_SIGNING_CERT_V2(const ESS_SIGNING_CERT_V2 *a, unsigned char **out)
952*de0e0e4dSAntonio Huete Jimenez {
953*de0e0e4dSAntonio Huete Jimenez return ASN1_item_i2d((ASN1_VALUE *)a, out, &ESS_SIGNING_CERT_V2_it);
954*de0e0e4dSAntonio Huete Jimenez }
955*de0e0e4dSAntonio Huete Jimenez
956*de0e0e4dSAntonio Huete Jimenez ESS_SIGNING_CERT_V2 *
ESS_SIGNING_CERT_V2_new(void)957*de0e0e4dSAntonio Huete Jimenez ESS_SIGNING_CERT_V2_new(void)
958*de0e0e4dSAntonio Huete Jimenez {
959*de0e0e4dSAntonio Huete Jimenez return (ESS_SIGNING_CERT_V2 *)ASN1_item_new(&ESS_SIGNING_CERT_V2_it);
960*de0e0e4dSAntonio Huete Jimenez }
961*de0e0e4dSAntonio Huete Jimenez
962*de0e0e4dSAntonio Huete Jimenez void
ESS_SIGNING_CERT_V2_free(ESS_SIGNING_CERT_V2 * a)963*de0e0e4dSAntonio Huete Jimenez ESS_SIGNING_CERT_V2_free(ESS_SIGNING_CERT_V2 *a)
964*de0e0e4dSAntonio Huete Jimenez {
965*de0e0e4dSAntonio Huete Jimenez ASN1_item_free((ASN1_VALUE *)a, &ESS_SIGNING_CERT_V2_it);
966*de0e0e4dSAntonio Huete Jimenez }
967*de0e0e4dSAntonio Huete Jimenez
968*de0e0e4dSAntonio Huete Jimenez ESS_SIGNING_CERT_V2 *
ESS_SIGNING_CERT_V2_dup(ESS_SIGNING_CERT_V2 * x)969*de0e0e4dSAntonio Huete Jimenez ESS_SIGNING_CERT_V2_dup(ESS_SIGNING_CERT_V2 *x)
970*de0e0e4dSAntonio Huete Jimenez {
971*de0e0e4dSAntonio Huete Jimenez return ASN1_item_dup(&ESS_SIGNING_CERT_V2_it, x);
972*de0e0e4dSAntonio Huete Jimenez }
973*de0e0e4dSAntonio Huete Jimenez
974f5b1c8a1SJohn Marino /* Getting encapsulated TS_TST_INFO object from PKCS7. */
975f5b1c8a1SJohn Marino TS_TST_INFO *
PKCS7_to_TS_TST_INFO(PKCS7 * token)976f5b1c8a1SJohn Marino PKCS7_to_TS_TST_INFO(PKCS7 *token)
977f5b1c8a1SJohn Marino {
978f5b1c8a1SJohn Marino PKCS7_SIGNED *pkcs7_signed;
979f5b1c8a1SJohn Marino PKCS7 *enveloped;
980f5b1c8a1SJohn Marino ASN1_TYPE *tst_info_wrapper;
981f5b1c8a1SJohn Marino ASN1_OCTET_STRING *tst_info_der;
982f5b1c8a1SJohn Marino const unsigned char *p;
983f5b1c8a1SJohn Marino
984f5b1c8a1SJohn Marino if (!PKCS7_type_is_signed(token)) {
98572c33676SMaxim Ag TSerror(TS_R_BAD_PKCS7_TYPE);
986f5b1c8a1SJohn Marino return NULL;
987f5b1c8a1SJohn Marino }
988f5b1c8a1SJohn Marino
989f5b1c8a1SJohn Marino /* Content must be present. */
990f5b1c8a1SJohn Marino if (PKCS7_get_detached(token)) {
99172c33676SMaxim Ag TSerror(TS_R_DETACHED_CONTENT);
992f5b1c8a1SJohn Marino return NULL;
993f5b1c8a1SJohn Marino }
994f5b1c8a1SJohn Marino
995f5b1c8a1SJohn Marino /* We have a signed data with content. */
996f5b1c8a1SJohn Marino pkcs7_signed = token->d.sign;
997f5b1c8a1SJohn Marino enveloped = pkcs7_signed->contents;
998f5b1c8a1SJohn Marino if (OBJ_obj2nid(enveloped->type) != NID_id_smime_ct_TSTInfo) {
99972c33676SMaxim Ag TSerror(TS_R_BAD_PKCS7_TYPE);
1000f5b1c8a1SJohn Marino return NULL;
1001f5b1c8a1SJohn Marino }
1002f5b1c8a1SJohn Marino
1003f5b1c8a1SJohn Marino /* We have a DER encoded TST_INFO as the signed data. */
1004f5b1c8a1SJohn Marino tst_info_wrapper = enveloped->d.other;
1005f5b1c8a1SJohn Marino if (tst_info_wrapper->type != V_ASN1_OCTET_STRING) {
100672c33676SMaxim Ag TSerror(TS_R_BAD_TYPE);
1007f5b1c8a1SJohn Marino return NULL;
1008f5b1c8a1SJohn Marino }
1009f5b1c8a1SJohn Marino
1010f5b1c8a1SJohn Marino /* We have the correct ASN1_OCTET_STRING type. */
1011f5b1c8a1SJohn Marino tst_info_der = tst_info_wrapper->value.octet_string;
1012f5b1c8a1SJohn Marino /* At last, decode the TST_INFO. */
1013f5b1c8a1SJohn Marino p = tst_info_der->data;
1014f5b1c8a1SJohn Marino return d2i_TS_TST_INFO(NULL, &p, tst_info_der->length);
1015f5b1c8a1SJohn Marino }
1016