Line data Source code
1 : #include "config.h"
2 : /* Generated from /builds/samba-team/devel/samba/source4/heimdal/lib/asn1/rfc2459.asn1 */
3 : /* Do not edit */
4 :
5 : #define ASN1_LIB
6 :
7 : #include <stdio.h>
8 : #include <stdlib.h>
9 : #include <time.h>
10 : #include <string.h>
11 : #include <errno.h>
12 : #include <limits.h>
13 : #include <krb5-types.h>
14 : #include <rfc2459_asn1.h>
15 : #include <rfc2459_asn1-priv.h>
16 : #include <asn1_err.h>
17 : #include <der.h>
18 : #include <der-private.h>
19 : #include <asn1-template.h>
20 : #include <parse_units.h>
21 :
22 : int ASN1CALL
23 66 : encode_Version(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const Version *data, size_t *size)
24 : {
25 66 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
26 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
27 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
28 :
29 : {
30 66 : int enumint = (int)*data;
31 66 : e = der_put_integer(p, len, &enumint, &l);
32 66 : if (e) return e;
33 66 : p -= l; len -= l; ret += l;
34 :
35 : }
36 66 : ;e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
37 66 : if (e) return e;
38 66 : p -= l; len -= l; ret += l;
39 :
40 66 : *size = ret;
41 66 : return 0;
42 : }
43 :
44 : int ASN1CALL
45 248 : decode_Version(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, Version *data, size_t *size)
46 : {
47 248 : size_t ret = 0;
48 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
49 : int e HEIMDAL_UNUSED_ATTRIBUTE;
50 :
51 248 : memset(data, 0, sizeof(*data));
52 : {
53 : size_t Top_datalen, Top_oldlen;
54 : Der_type Top_type;
55 248 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Integer, &Top_datalen, &l);
56 248 : if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
57 248 : if(e) goto fail;
58 248 : p += l; len -= l; ret += l;
59 248 : Top_oldlen = len;
60 248 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
61 248 : len = Top_datalen;
62 : {
63 : int enumint;
64 248 : e = der_get_integer(p, len, &enumint, &l);
65 248 : if(e) goto fail;
66 248 : p += l; len -= l; ret += l;
67 248 : *data = enumint;
68 : }
69 248 : len = Top_oldlen - Top_datalen;
70 : }
71 496 : if(size) *size = ret;
72 232 : return 0;
73 0 : fail:
74 0 : free_Version(data);
75 0 : return e;
76 : }
77 :
78 : void ASN1CALL
79 378 : free_Version(Version *data)
80 : {
81 378 : }
82 :
83 : size_t ASN1CALL
84 66 : length_Version(const Version *data)
85 : {
86 66 : size_t ret = 0;
87 : {
88 66 : int enumint = *data;
89 66 : ret += der_length_integer(&enumint);
90 : }
91 66 : ret += 1 + der_length_len (ret);
92 66 : return ret;
93 : }
94 :
95 : int ASN1CALL
96 248 : copy_Version(const Version *from, Version *to)
97 : {
98 248 : memset(to, 0, sizeof(*to));
99 248 : *(to) = *(from);
100 248 : return 0;
101 : }
102 :
103 : static unsigned oid_id_pkcs_1_variable_num[6] = {1, 2, 840, 113549, 1, 1 };
104 : const heim_oid asn1_oid_id_pkcs_1 = { 6, oid_id_pkcs_1_variable_num };
105 :
106 : static unsigned oid_id_pkcs1_rsaEncryption_variable_num[7] = {1, 2, 840, 113549, 1, 1, 1 };
107 : const heim_oid asn1_oid_id_pkcs1_rsaEncryption = { 7, oid_id_pkcs1_rsaEncryption_variable_num };
108 :
109 : static unsigned oid_id_pkcs1_md2WithRSAEncryption_variable_num[7] = {1, 2, 840, 113549, 1, 1, 2 };
110 : const heim_oid asn1_oid_id_pkcs1_md2WithRSAEncryption = { 7, oid_id_pkcs1_md2WithRSAEncryption_variable_num };
111 :
112 : static unsigned oid_id_pkcs1_md5WithRSAEncryption_variable_num[7] = {1, 2, 840, 113549, 1, 1, 4 };
113 : const heim_oid asn1_oid_id_pkcs1_md5WithRSAEncryption = { 7, oid_id_pkcs1_md5WithRSAEncryption_variable_num };
114 :
115 : static unsigned oid_id_pkcs1_sha1WithRSAEncryption_variable_num[7] = {1, 2, 840, 113549, 1, 1, 5 };
116 : const heim_oid asn1_oid_id_pkcs1_sha1WithRSAEncryption = { 7, oid_id_pkcs1_sha1WithRSAEncryption_variable_num };
117 :
118 : static unsigned oid_id_pkcs1_sha256WithRSAEncryption_variable_num[7] = {1, 2, 840, 113549, 1, 1, 11 };
119 : const heim_oid asn1_oid_id_pkcs1_sha256WithRSAEncryption = { 7, oid_id_pkcs1_sha256WithRSAEncryption_variable_num };
120 :
121 : static unsigned oid_id_pkcs1_sha384WithRSAEncryption_variable_num[7] = {1, 2, 840, 113549, 1, 1, 12 };
122 : const heim_oid asn1_oid_id_pkcs1_sha384WithRSAEncryption = { 7, oid_id_pkcs1_sha384WithRSAEncryption_variable_num };
123 :
124 : static unsigned oid_id_pkcs1_sha512WithRSAEncryption_variable_num[7] = {1, 2, 840, 113549, 1, 1, 13 };
125 : const heim_oid asn1_oid_id_pkcs1_sha512WithRSAEncryption = { 7, oid_id_pkcs1_sha512WithRSAEncryption_variable_num };
126 :
127 : static unsigned oid_id_heim_rsa_pkcs1_x509_variable_num[6] = {1, 2, 752, 43, 16, 1 };
128 : const heim_oid asn1_oid_id_heim_rsa_pkcs1_x509 = { 6, oid_id_heim_rsa_pkcs1_x509_variable_num };
129 :
130 : static unsigned oid_id_pkcs_2_variable_num[6] = {1, 2, 840, 113549, 1, 2 };
131 : const heim_oid asn1_oid_id_pkcs_2 = { 6, oid_id_pkcs_2_variable_num };
132 :
133 : static unsigned oid_id_pkcs2_md2_variable_num[7] = {1, 2, 840, 113549, 1, 2, 2 };
134 : const heim_oid asn1_oid_id_pkcs2_md2 = { 7, oid_id_pkcs2_md2_variable_num };
135 :
136 : static unsigned oid_id_pkcs2_md4_variable_num[7] = {1, 2, 840, 113549, 1, 2, 4 };
137 : const heim_oid asn1_oid_id_pkcs2_md4 = { 7, oid_id_pkcs2_md4_variable_num };
138 :
139 : static unsigned oid_id_pkcs2_md5_variable_num[7] = {1, 2, 840, 113549, 1, 2, 5 };
140 : const heim_oid asn1_oid_id_pkcs2_md5 = { 7, oid_id_pkcs2_md5_variable_num };
141 :
142 : static unsigned oid_id_rsa_digestAlgorithm_variable_num[5] = {1, 2, 840, 113549, 2 };
143 : const heim_oid asn1_oid_id_rsa_digestAlgorithm = { 5, oid_id_rsa_digestAlgorithm_variable_num };
144 :
145 : static unsigned oid_id_rsa_digest_md2_variable_num[6] = {1, 2, 840, 113549, 2, 2 };
146 : const heim_oid asn1_oid_id_rsa_digest_md2 = { 6, oid_id_rsa_digest_md2_variable_num };
147 :
148 : static unsigned oid_id_rsa_digest_md4_variable_num[6] = {1, 2, 840, 113549, 2, 4 };
149 : const heim_oid asn1_oid_id_rsa_digest_md4 = { 6, oid_id_rsa_digest_md4_variable_num };
150 :
151 : static unsigned oid_id_rsa_digest_md5_variable_num[6] = {1, 2, 840, 113549, 2, 5 };
152 : const heim_oid asn1_oid_id_rsa_digest_md5 = { 6, oid_id_rsa_digest_md5_variable_num };
153 :
154 : static unsigned oid_id_pkcs_3_variable_num[6] = {1, 2, 840, 113549, 1, 3 };
155 : const heim_oid asn1_oid_id_pkcs_3 = { 6, oid_id_pkcs_3_variable_num };
156 :
157 : static unsigned oid_id_pkcs3_rc2_cbc_variable_num[7] = {1, 2, 840, 113549, 1, 3, 2 };
158 : const heim_oid asn1_oid_id_pkcs3_rc2_cbc = { 7, oid_id_pkcs3_rc2_cbc_variable_num };
159 :
160 : static unsigned oid_id_pkcs3_rc4_variable_num[7] = {1, 2, 840, 113549, 1, 3, 4 };
161 : const heim_oid asn1_oid_id_pkcs3_rc4 = { 7, oid_id_pkcs3_rc4_variable_num };
162 :
163 : static unsigned oid_id_pkcs3_des_ede3_cbc_variable_num[7] = {1, 2, 840, 113549, 1, 3, 7 };
164 : const heim_oid asn1_oid_id_pkcs3_des_ede3_cbc = { 7, oid_id_pkcs3_des_ede3_cbc_variable_num };
165 :
166 : static unsigned oid_id_rsadsi_encalg_variable_num[5] = {1, 2, 840, 113549, 3 };
167 : const heim_oid asn1_oid_id_rsadsi_encalg = { 5, oid_id_rsadsi_encalg_variable_num };
168 :
169 : static unsigned oid_id_rsadsi_rc2_cbc_variable_num[6] = {1, 2, 840, 113549, 3, 2 };
170 : const heim_oid asn1_oid_id_rsadsi_rc2_cbc = { 6, oid_id_rsadsi_rc2_cbc_variable_num };
171 :
172 : static unsigned oid_id_rsadsi_des_ede3_cbc_variable_num[6] = {1, 2, 840, 113549, 3, 7 };
173 : const heim_oid asn1_oid_id_rsadsi_des_ede3_cbc = { 6, oid_id_rsadsi_des_ede3_cbc_variable_num };
174 :
175 : static unsigned oid_id_secsig_sha_1_variable_num[6] = {1, 3, 14, 3, 2, 26 };
176 : const heim_oid asn1_oid_id_secsig_sha_1 = { 6, oid_id_secsig_sha_1_variable_num };
177 :
178 : static unsigned oid_id_secsig_sha_1WithRSAEncryption_variable_num[6] = {1, 3, 14, 3, 2, 29 };
179 : const heim_oid asn1_oid_id_secsig_sha_1WithRSAEncryption = { 6, oid_id_secsig_sha_1WithRSAEncryption_variable_num };
180 :
181 : static unsigned oid_id_nistAlgorithm_variable_num[7] = {2, 16, 840, 1, 101, 3, 4 };
182 : const heim_oid asn1_oid_id_nistAlgorithm = { 7, oid_id_nistAlgorithm_variable_num };
183 :
184 : static unsigned oid_id_nist_aes_algs_variable_num[8] = {2, 16, 840, 1, 101, 3, 4, 1 };
185 : const heim_oid asn1_oid_id_nist_aes_algs = { 8, oid_id_nist_aes_algs_variable_num };
186 :
187 : static unsigned oid_id_aes_128_cbc_variable_num[9] = {2, 16, 840, 1, 101, 3, 4, 1, 2 };
188 : const heim_oid asn1_oid_id_aes_128_cbc = { 9, oid_id_aes_128_cbc_variable_num };
189 :
190 : static unsigned oid_id_aes_192_cbc_variable_num[9] = {2, 16, 840, 1, 101, 3, 4, 1, 22 };
191 : const heim_oid asn1_oid_id_aes_192_cbc = { 9, oid_id_aes_192_cbc_variable_num };
192 :
193 : static unsigned oid_id_aes_256_cbc_variable_num[9] = {2, 16, 840, 1, 101, 3, 4, 1, 42 };
194 : const heim_oid asn1_oid_id_aes_256_cbc = { 9, oid_id_aes_256_cbc_variable_num };
195 :
196 : static unsigned oid_id_nist_sha_algs_variable_num[8] = {2, 16, 840, 1, 101, 3, 4, 2 };
197 : const heim_oid asn1_oid_id_nist_sha_algs = { 8, oid_id_nist_sha_algs_variable_num };
198 :
199 : static unsigned oid_id_sha256_variable_num[9] = {2, 16, 840, 1, 101, 3, 4, 2, 1 };
200 : const heim_oid asn1_oid_id_sha256 = { 9, oid_id_sha256_variable_num };
201 :
202 : static unsigned oid_id_sha224_variable_num[9] = {2, 16, 840, 1, 101, 3, 4, 2, 4 };
203 : const heim_oid asn1_oid_id_sha224 = { 9, oid_id_sha224_variable_num };
204 :
205 : static unsigned oid_id_sha384_variable_num[9] = {2, 16, 840, 1, 101, 3, 4, 2, 2 };
206 : const heim_oid asn1_oid_id_sha384 = { 9, oid_id_sha384_variable_num };
207 :
208 : static unsigned oid_id_sha512_variable_num[9] = {2, 16, 840, 1, 101, 3, 4, 2, 3 };
209 : const heim_oid asn1_oid_id_sha512 = { 9, oid_id_sha512_variable_num };
210 :
211 : static unsigned oid_id_dhpublicnumber_variable_num[6] = {1, 2, 840, 10046, 2, 1 };
212 : const heim_oid asn1_oid_id_dhpublicnumber = { 6, oid_id_dhpublicnumber_variable_num };
213 :
214 : static unsigned oid_id_ecPublicKey_variable_num[6] = {1, 2, 840, 10045, 2, 1 };
215 : const heim_oid asn1_oid_id_ecPublicKey = { 6, oid_id_ecPublicKey_variable_num };
216 :
217 : static unsigned oid_id_ecDH_variable_num[5] = {1, 3, 132, 1, 12 };
218 : const heim_oid asn1_oid_id_ecDH = { 5, oid_id_ecDH_variable_num };
219 :
220 : static unsigned oid_id_ecMQV_variable_num[5] = {1, 3, 132, 1, 13 };
221 : const heim_oid asn1_oid_id_ecMQV = { 5, oid_id_ecMQV_variable_num };
222 :
223 : static unsigned oid_id_ecdsa_with_SHA256_variable_num[7] = {1, 2, 840, 10045, 4, 3, 2 };
224 : const heim_oid asn1_oid_id_ecdsa_with_SHA256 = { 7, oid_id_ecdsa_with_SHA256_variable_num };
225 :
226 : static unsigned oid_id_ecdsa_with_SHA1_variable_num[6] = {1, 2, 840, 10045, 4, 1 };
227 : const heim_oid asn1_oid_id_ecdsa_with_SHA1 = { 6, oid_id_ecdsa_with_SHA1_variable_num };
228 :
229 : static unsigned oid_id_ec_group_secp256r1_variable_num[7] = {1, 2, 840, 10045, 3, 1, 7 };
230 : const heim_oid asn1_oid_id_ec_group_secp256r1 = { 7, oid_id_ec_group_secp256r1_variable_num };
231 :
232 : static unsigned oid_id_ec_group_secp160r1_variable_num[5] = {1, 3, 132, 0, 8 };
233 : const heim_oid asn1_oid_id_ec_group_secp160r1 = { 5, oid_id_ec_group_secp160r1_variable_num };
234 :
235 : static unsigned oid_id_ec_group_secp160r2_variable_num[5] = {1, 3, 132, 0, 30 };
236 : const heim_oid asn1_oid_id_ec_group_secp160r2 = { 5, oid_id_ec_group_secp160r2_variable_num };
237 :
238 : static unsigned oid_id_x9_57_variable_num[5] = {1, 2, 840, 10046, 4 };
239 : const heim_oid asn1_oid_id_x9_57 = { 5, oid_id_x9_57_variable_num };
240 :
241 : static unsigned oid_id_dsa_variable_num[6] = {1, 2, 840, 10046, 4, 1 };
242 : const heim_oid asn1_oid_id_dsa = { 6, oid_id_dsa_variable_num };
243 :
244 : static unsigned oid_id_dsa_with_sha1_variable_num[6] = {1, 2, 840, 10046, 4, 3 };
245 : const heim_oid asn1_oid_id_dsa_with_sha1 = { 6, oid_id_dsa_with_sha1_variable_num };
246 :
247 : static unsigned oid_id_x520_at_variable_num[3] = {2, 5, 4 };
248 : const heim_oid asn1_oid_id_x520_at = { 3, oid_id_x520_at_variable_num };
249 :
250 : static unsigned oid_id_at_commonName_variable_num[4] = {2, 5, 4, 3 };
251 : const heim_oid asn1_oid_id_at_commonName = { 4, oid_id_at_commonName_variable_num };
252 :
253 : static unsigned oid_id_at_surname_variable_num[4] = {2, 5, 4, 4 };
254 : const heim_oid asn1_oid_id_at_surname = { 4, oid_id_at_surname_variable_num };
255 :
256 : static unsigned oid_id_at_serialNumber_variable_num[4] = {2, 5, 4, 5 };
257 : const heim_oid asn1_oid_id_at_serialNumber = { 4, oid_id_at_serialNumber_variable_num };
258 :
259 : static unsigned oid_id_at_countryName_variable_num[4] = {2, 5, 4, 6 };
260 : const heim_oid asn1_oid_id_at_countryName = { 4, oid_id_at_countryName_variable_num };
261 :
262 : static unsigned oid_id_at_localityName_variable_num[4] = {2, 5, 4, 7 };
263 : const heim_oid asn1_oid_id_at_localityName = { 4, oid_id_at_localityName_variable_num };
264 :
265 : static unsigned oid_id_at_stateOrProvinceName_variable_num[4] = {2, 5, 4, 8 };
266 : const heim_oid asn1_oid_id_at_stateOrProvinceName = { 4, oid_id_at_stateOrProvinceName_variable_num };
267 :
268 : static unsigned oid_id_at_streetAddress_variable_num[4] = {2, 5, 4, 9 };
269 : const heim_oid asn1_oid_id_at_streetAddress = { 4, oid_id_at_streetAddress_variable_num };
270 :
271 : static unsigned oid_id_at_organizationName_variable_num[4] = {2, 5, 4, 10 };
272 : const heim_oid asn1_oid_id_at_organizationName = { 4, oid_id_at_organizationName_variable_num };
273 :
274 : static unsigned oid_id_at_organizationalUnitName_variable_num[4] = {2, 5, 4, 11 };
275 : const heim_oid asn1_oid_id_at_organizationalUnitName = { 4, oid_id_at_organizationalUnitName_variable_num };
276 :
277 : static unsigned oid_id_at_name_variable_num[4] = {2, 5, 4, 41 };
278 : const heim_oid asn1_oid_id_at_name = { 4, oid_id_at_name_variable_num };
279 :
280 : static unsigned oid_id_at_givenName_variable_num[4] = {2, 5, 4, 42 };
281 : const heim_oid asn1_oid_id_at_givenName = { 4, oid_id_at_givenName_variable_num };
282 :
283 : static unsigned oid_id_at_initials_variable_num[4] = {2, 5, 4, 43 };
284 : const heim_oid asn1_oid_id_at_initials = { 4, oid_id_at_initials_variable_num };
285 :
286 : static unsigned oid_id_at_generationQualifier_variable_num[4] = {2, 5, 4, 44 };
287 : const heim_oid asn1_oid_id_at_generationQualifier = { 4, oid_id_at_generationQualifier_variable_num };
288 :
289 : static unsigned oid_id_at_pseudonym_variable_num[4] = {2, 5, 4, 65 };
290 : const heim_oid asn1_oid_id_at_pseudonym = { 4, oid_id_at_pseudonym_variable_num };
291 :
292 : static unsigned oid_id_Userid_variable_num[7] = {0, 9, 2342, 19200300, 100, 1, 1 };
293 : const heim_oid asn1_oid_id_Userid = { 7, oid_id_Userid_variable_num };
294 :
295 : static unsigned oid_id_domainComponent_variable_num[7] = {0, 9, 2342, 19200300, 100, 1, 25 };
296 : const heim_oid asn1_oid_id_domainComponent = { 7, oid_id_domainComponent_variable_num };
297 :
298 : static unsigned oid_id_x509_ce_variable_num[3] = {2, 5, 29 };
299 : const heim_oid asn1_oid_id_x509_ce = { 3, oid_id_x509_ce_variable_num };
300 :
301 : int ASN1CALL
302 1142 : encode_AlgorithmIdentifier(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const AlgorithmIdentifier *data, size_t *size)
303 : {
304 1142 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
305 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
306 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
307 :
308 : /* parameters */
309 1142 : if((data)->parameters) {
310 702 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
311 702 : ret = 0;
312 702 : e = encode_heim_any(p, len, (data)->parameters, &l);
313 702 : if (e) return e;
314 702 : p -= l; len -= l; ret += l;
315 :
316 702 : ret += Top_tag_oldret;
317 : }
318 : /* algorithm */
319 : {
320 1142 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
321 1142 : ret = 0;
322 1142 : e = der_put_oid(p, len, &(data)->algorithm, &l);
323 1142 : if (e) return e;
324 1142 : p -= l; len -= l; ret += l;
325 :
326 1142 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OID, &l);
327 1142 : if (e) return e;
328 1142 : p -= l; len -= l; ret += l;
329 :
330 1142 : ret += Top_tag_oldret;
331 : }
332 1142 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
333 1142 : if (e) return e;
334 1142 : p -= l; len -= l; ret += l;
335 :
336 1142 : *size = ret;
337 1142 : return 0;
338 : }
339 :
340 : int ASN1CALL
341 1682 : decode_AlgorithmIdentifier(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, AlgorithmIdentifier *data, size_t *size)
342 : {
343 1682 : size_t ret = 0;
344 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
345 : int e HEIMDAL_UNUSED_ATTRIBUTE;
346 :
347 1682 : memset(data, 0, sizeof(*data));
348 : {
349 : size_t Top_datalen, Top_oldlen;
350 : Der_type Top_type;
351 1682 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
352 1682 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
353 1682 : if(e) goto fail;
354 1682 : p += l; len -= l; ret += l;
355 1682 : Top_oldlen = len;
356 1682 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
357 1682 : len = Top_datalen;
358 : {
359 : size_t algorithm_datalen, algorithm_oldlen;
360 : Der_type algorithm_type;
361 1682 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &algorithm_type, UT_OID, &algorithm_datalen, &l);
362 1682 : if (e == 0 && algorithm_type != PRIM) { e = ASN1_BAD_ID; }
363 1682 : if(e) goto fail;
364 1682 : p += l; len -= l; ret += l;
365 1682 : algorithm_oldlen = len;
366 1682 : if (algorithm_datalen > len) { e = ASN1_OVERRUN; goto fail; }
367 1682 : len = algorithm_datalen;
368 1682 : e = der_get_oid(p, len, &(data)->algorithm, &l);
369 1682 : if(e) goto fail;
370 1682 : p += l; len -= l; ret += l;
371 1682 : len = algorithm_oldlen - algorithm_datalen;
372 : }
373 1682 : (data)->parameters = calloc(1, sizeof(*(data)->parameters));
374 1682 : if ((data)->parameters == NULL) goto fail;
375 1682 : e = decode_heim_any(p, len, (data)->parameters, &l);
376 1682 : if(e) {
377 374 : free((data)->parameters);
378 374 : (data)->parameters = NULL;
379 : } else {
380 1308 : p += l; len -= l; ret += l;
381 : }
382 1682 : len = Top_oldlen - Top_datalen;
383 : }
384 3364 : if(size) *size = ret;
385 1634 : return 0;
386 0 : fail:
387 0 : free_AlgorithmIdentifier(data);
388 0 : return e;
389 : }
390 :
391 : void ASN1CALL
392 3816 : free_AlgorithmIdentifier(AlgorithmIdentifier *data)
393 : {
394 3816 : der_free_oid(&(data)->algorithm);
395 3816 : if((data)->parameters) {
396 2468 : free_heim_any((data)->parameters);
397 2468 : free((data)->parameters);
398 2468 : (data)->parameters = NULL;
399 : }
400 3816 : }
401 :
402 : size_t ASN1CALL
403 1340 : length_AlgorithmIdentifier(const AlgorithmIdentifier *data)
404 : {
405 1340 : size_t ret = 0;
406 : {
407 1340 : size_t Top_tag_oldret = ret;
408 1340 : ret = 0;
409 1340 : ret += der_length_oid(&(data)->algorithm);
410 1340 : ret += 1 + der_length_len (ret);
411 1340 : ret += Top_tag_oldret;
412 : }
413 1340 : if((data)->parameters){
414 900 : size_t Top_tag_oldret = ret;
415 900 : ret = 0;
416 900 : ret += length_heim_any((data)->parameters);
417 900 : ret += Top_tag_oldret;
418 : }
419 1340 : ret += 1 + der_length_len (ret);
420 1340 : return ret;
421 : }
422 :
423 : int ASN1CALL
424 2316 : copy_AlgorithmIdentifier(const AlgorithmIdentifier *from, AlgorithmIdentifier *to)
425 : {
426 2316 : memset(to, 0, sizeof(*to));
427 2316 : if(der_copy_oid(&(from)->algorithm, &(to)->algorithm)) goto fail;
428 2316 : if((from)->parameters) {
429 1342 : (to)->parameters = malloc(sizeof(*(to)->parameters));
430 1342 : if((to)->parameters == NULL) goto fail;
431 1342 : if(copy_heim_any((from)->parameters, (to)->parameters)) goto fail;
432 : }else
433 974 : (to)->parameters = NULL;
434 2260 : return 0;
435 0 : fail:
436 0 : free_AlgorithmIdentifier(to);
437 0 : return ENOMEM;
438 : }
439 :
440 : int ASN1CALL
441 1522 : encode_AttributeType(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const AttributeType *data, size_t *size)
442 : {
443 1522 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
444 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
445 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
446 :
447 1522 : e = der_put_oid(p, len, data, &l);
448 1522 : if (e) return e;
449 1522 : p -= l; len -= l; ret += l;
450 :
451 1522 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OID, &l);
452 1522 : if (e) return e;
453 1522 : p -= l; len -= l; ret += l;
454 :
455 1522 : *size = ret;
456 1522 : return 0;
457 : }
458 :
459 : int ASN1CALL
460 3676 : decode_AttributeType(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, AttributeType *data, size_t *size)
461 : {
462 3676 : size_t ret = 0;
463 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
464 : int e HEIMDAL_UNUSED_ATTRIBUTE;
465 :
466 3676 : memset(data, 0, sizeof(*data));
467 : {
468 : size_t Top_datalen, Top_oldlen;
469 : Der_type Top_type;
470 3676 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_OID, &Top_datalen, &l);
471 3676 : if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
472 3676 : if(e) goto fail;
473 3676 : p += l; len -= l; ret += l;
474 3676 : Top_oldlen = len;
475 3676 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
476 3676 : len = Top_datalen;
477 3676 : e = der_get_oid(p, len, data, &l);
478 3676 : if(e) goto fail;
479 3676 : p += l; len -= l; ret += l;
480 3676 : len = Top_oldlen - Top_datalen;
481 : }
482 7352 : if(size) *size = ret;
483 3460 : return 0;
484 0 : fail:
485 0 : free_AttributeType(data);
486 0 : return e;
487 : }
488 :
489 : void ASN1CALL
490 7216 : free_AttributeType(AttributeType *data)
491 : {
492 7216 : der_free_oid(data);
493 7216 : }
494 :
495 : size_t ASN1CALL
496 3176 : length_AttributeType(const AttributeType *data)
497 : {
498 3176 : size_t ret = 0;
499 3176 : ret += der_length_oid(data);
500 3176 : ret += 1 + der_length_len (ret);
501 3176 : return ret;
502 : }
503 :
504 : int ASN1CALL
505 4996 : copy_AttributeType(const AttributeType *from, AttributeType *to)
506 : {
507 4996 : memset(to, 0, sizeof(*to));
508 4996 : if(der_copy_oid(from, to)) goto fail;
509 4780 : return 0;
510 0 : fail:
511 0 : free_AttributeType(to);
512 0 : return ENOMEM;
513 : }
514 :
515 : int ASN1CALL
516 0 : encode_AttributeValue(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const AttributeValue *data, size_t *size)
517 : {
518 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
519 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
520 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
521 :
522 0 : e = encode_heim_any(p, len, data, &l);
523 0 : if (e) return e;
524 0 : p -= l; len -= l; ret += l;
525 :
526 0 : *size = ret;
527 0 : return 0;
528 : }
529 :
530 : int ASN1CALL
531 0 : decode_AttributeValue(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, AttributeValue *data, size_t *size)
532 : {
533 0 : size_t ret = 0;
534 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
535 : int e HEIMDAL_UNUSED_ATTRIBUTE;
536 :
537 0 : memset(data, 0, sizeof(*data));
538 0 : e = decode_heim_any(p, len, data, &l);
539 0 : if(e) goto fail;
540 0 : p += l; len -= l; ret += l;
541 0 : if(size) *size = ret;
542 0 : return 0;
543 0 : fail:
544 0 : free_AttributeValue(data);
545 0 : return e;
546 : }
547 :
548 : void ASN1CALL
549 0 : free_AttributeValue(AttributeValue *data)
550 : {
551 0 : free_heim_any(data);
552 0 : }
553 :
554 : size_t ASN1CALL
555 0 : length_AttributeValue(const AttributeValue *data)
556 : {
557 0 : size_t ret = 0;
558 0 : ret += length_heim_any(data);
559 0 : return ret;
560 : }
561 :
562 : int ASN1CALL
563 0 : copy_AttributeValue(const AttributeValue *from, AttributeValue *to)
564 : {
565 0 : memset(to, 0, sizeof(*to));
566 0 : if(copy_heim_any(from, to)) goto fail;
567 0 : return 0;
568 0 : fail:
569 0 : free_AttributeValue(to);
570 0 : return ENOMEM;
571 : }
572 :
573 : int ASN1CALL
574 1138 : encode_DirectoryString(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const DirectoryString *data, size_t *size)
575 : {
576 1138 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
577 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
578 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
579 :
580 :
581 1138 : switch((data)->element) {
582 0 : case choice_DirectoryString_bmpString: {size_t Top_oldret = ret;
583 0 : ret = 0;
584 0 : e = der_put_bmp_string(p, len, &((data))->u.bmpString, &l);
585 0 : if (e) return e;
586 0 : p -= l; len -= l; ret += l;
587 :
588 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_BMPString, &l);
589 0 : if (e) return e;
590 0 : p -= l; len -= l; ret += l;
591 :
592 0 : ret += Top_oldret;
593 0 : break;
594 : }
595 794 : case choice_DirectoryString_utf8String: {size_t Top_oldret = ret;
596 794 : ret = 0;
597 794 : e = der_put_utf8string(p, len, &((data))->u.utf8String, &l);
598 794 : if (e) return e;
599 794 : p -= l; len -= l; ret += l;
600 :
601 794 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_UTF8String, &l);
602 794 : if (e) return e;
603 794 : p -= l; len -= l; ret += l;
604 :
605 794 : ret += Top_oldret;
606 794 : break;
607 : }
608 0 : case choice_DirectoryString_universalString: {size_t Top_oldret = ret;
609 0 : ret = 0;
610 0 : e = der_put_universal_string(p, len, &((data))->u.universalString, &l);
611 0 : if (e) return e;
612 0 : p -= l; len -= l; ret += l;
613 :
614 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_GraphicString, &l);
615 0 : if (e) return e;
616 0 : p -= l; len -= l; ret += l;
617 :
618 0 : ret += Top_oldret;
619 0 : break;
620 : }
621 172 : case choice_DirectoryString_printableString: {size_t Top_oldret = ret;
622 172 : ret = 0;
623 172 : e = der_put_printable_string(p, len, &((data))->u.printableString, &l);
624 172 : if (e) return e;
625 172 : p -= l; len -= l; ret += l;
626 :
627 172 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_PrintableString, &l);
628 172 : if (e) return e;
629 172 : p -= l; len -= l; ret += l;
630 :
631 172 : ret += Top_oldret;
632 172 : break;
633 : }
634 0 : case choice_DirectoryString_teletexString: {size_t Top_oldret = ret;
635 0 : ret = 0;
636 0 : e = der_put_general_string(p, len, &((data))->u.teletexString, &l);
637 0 : if (e) return e;
638 0 : p -= l; len -= l; ret += l;
639 :
640 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_TeletexString, &l);
641 0 : if (e) return e;
642 0 : p -= l; len -= l; ret += l;
643 :
644 0 : ret += Top_oldret;
645 0 : break;
646 : }
647 172 : case choice_DirectoryString_ia5String: {size_t Top_oldret = ret;
648 172 : ret = 0;
649 172 : e = der_put_ia5_string(p, len, &((data))->u.ia5String, &l);
650 172 : if (e) return e;
651 172 : p -= l; len -= l; ret += l;
652 :
653 172 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_IA5String, &l);
654 172 : if (e) return e;
655 172 : p -= l; len -= l; ret += l;
656 :
657 172 : ret += Top_oldret;
658 172 : break;
659 : }
660 : };
661 1138 : *size = ret;
662 1138 : return 0;
663 : }
664 :
665 : int ASN1CALL
666 3556 : decode_DirectoryString(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, DirectoryString *data, size_t *size)
667 : {
668 3556 : size_t ret = 0;
669 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
670 : int e HEIMDAL_UNUSED_ATTRIBUTE;
671 :
672 3556 : memset(data, 0, sizeof(*data));
673 3556 : if (der_match_tag(p, len, ASN1_C_UNIV, PRIM, UT_IA5String, NULL) == 0) {
674 : {
675 : size_t ia5String_datalen, ia5String_oldlen;
676 : Der_type ia5String_type;
677 530 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &ia5String_type, UT_IA5String, &ia5String_datalen, &l);
678 530 : if (e == 0 && ia5String_type != PRIM) { e = ASN1_BAD_ID; }
679 530 : if(e) goto fail;
680 530 : p += l; len -= l; ret += l;
681 530 : ia5String_oldlen = len;
682 530 : if (ia5String_datalen > len) { e = ASN1_OVERRUN; goto fail; }
683 530 : len = ia5String_datalen;
684 530 : e = der_get_ia5_string(p, len, &(data)->u.ia5String, &l);
685 530 : if(e) goto fail;
686 530 : p += l; len -= l; ret += l;
687 530 : len = ia5String_oldlen - ia5String_datalen;
688 : }
689 530 : (data)->element = choice_DirectoryString_ia5String;
690 : }
691 3026 : else if (der_match_tag(p, len, ASN1_C_UNIV, PRIM, UT_TeletexString, NULL) == 0) {
692 : {
693 : size_t teletexString_datalen, teletexString_oldlen;
694 : Der_type teletexString_type;
695 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &teletexString_type, UT_TeletexString, &teletexString_datalen, &l);
696 0 : if (e == 0 && teletexString_type != PRIM) { e = ASN1_BAD_ID; }
697 0 : if(e) goto fail;
698 0 : p += l; len -= l; ret += l;
699 0 : teletexString_oldlen = len;
700 0 : if (teletexString_datalen > len) { e = ASN1_OVERRUN; goto fail; }
701 0 : len = teletexString_datalen;
702 0 : e = der_get_general_string(p, len, &(data)->u.teletexString, &l);
703 0 : if(e) goto fail;
704 0 : p += l; len -= l; ret += l;
705 0 : len = teletexString_oldlen - teletexString_datalen;
706 : }
707 0 : (data)->element = choice_DirectoryString_teletexString;
708 : }
709 3026 : else if (der_match_tag(p, len, ASN1_C_UNIV, PRIM, UT_PrintableString, NULL) == 0) {
710 : {
711 : size_t printableString_datalen, printableString_oldlen;
712 : Der_type printableString_type;
713 530 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &printableString_type, UT_PrintableString, &printableString_datalen, &l);
714 530 : if (e == 0 && printableString_type != PRIM) { e = ASN1_BAD_ID; }
715 530 : if(e) goto fail;
716 530 : p += l; len -= l; ret += l;
717 530 : printableString_oldlen = len;
718 530 : if (printableString_datalen > len) { e = ASN1_OVERRUN; goto fail; }
719 530 : len = printableString_datalen;
720 530 : e = der_get_printable_string(p, len, &(data)->u.printableString, &l);
721 530 : if(e) goto fail;
722 530 : p += l; len -= l; ret += l;
723 530 : len = printableString_oldlen - printableString_datalen;
724 : }
725 530 : (data)->element = choice_DirectoryString_printableString;
726 : }
727 2496 : else if (der_match_tag(p, len, ASN1_C_UNIV, PRIM, UT_GraphicString, NULL) == 0) {
728 : {
729 : size_t universalString_datalen, universalString_oldlen;
730 : Der_type universalString_type;
731 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &universalString_type, UT_GraphicString, &universalString_datalen, &l);
732 0 : if (e == 0 && universalString_type != PRIM) { e = ASN1_BAD_ID; }
733 0 : if(e) goto fail;
734 0 : p += l; len -= l; ret += l;
735 0 : universalString_oldlen = len;
736 0 : if (universalString_datalen > len) { e = ASN1_OVERRUN; goto fail; }
737 0 : len = universalString_datalen;
738 0 : e = der_get_universal_string(p, len, &(data)->u.universalString, &l);
739 0 : if(e) goto fail;
740 0 : p += l; len -= l; ret += l;
741 0 : len = universalString_oldlen - universalString_datalen;
742 : }
743 0 : (data)->element = choice_DirectoryString_universalString;
744 : }
745 2496 : else if (der_match_tag(p, len, ASN1_C_UNIV, PRIM, UT_UTF8String, NULL) == 0) {
746 : {
747 : size_t utf8String_datalen, utf8String_oldlen;
748 : Der_type utf8String_type;
749 2496 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &utf8String_type, UT_UTF8String, &utf8String_datalen, &l);
750 2496 : if (e == 0 && utf8String_type != PRIM) { e = ASN1_BAD_ID; }
751 2496 : if(e) goto fail;
752 2496 : p += l; len -= l; ret += l;
753 2496 : utf8String_oldlen = len;
754 2496 : if (utf8String_datalen > len) { e = ASN1_OVERRUN; goto fail; }
755 2496 : len = utf8String_datalen;
756 2496 : e = der_get_utf8string(p, len, &(data)->u.utf8String, &l);
757 2496 : if(e) goto fail;
758 2496 : p += l; len -= l; ret += l;
759 2496 : len = utf8String_oldlen - utf8String_datalen;
760 : }
761 2496 : (data)->element = choice_DirectoryString_utf8String;
762 : }
763 0 : else if (der_match_tag(p, len, ASN1_C_UNIV, PRIM, UT_BMPString, NULL) == 0) {
764 : {
765 : size_t bmpString_datalen, bmpString_oldlen;
766 : Der_type bmpString_type;
767 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &bmpString_type, UT_BMPString, &bmpString_datalen, &l);
768 0 : if (e == 0 && bmpString_type != PRIM) { e = ASN1_BAD_ID; }
769 0 : if(e) goto fail;
770 0 : p += l; len -= l; ret += l;
771 0 : bmpString_oldlen = len;
772 0 : if (bmpString_datalen > len) { e = ASN1_OVERRUN; goto fail; }
773 0 : len = bmpString_datalen;
774 0 : e = der_get_bmp_string(p, len, &(data)->u.bmpString, &l);
775 0 : if(e) goto fail;
776 0 : p += l; len -= l; ret += l;
777 0 : len = bmpString_oldlen - bmpString_datalen;
778 : }
779 0 : (data)->element = choice_DirectoryString_bmpString;
780 : }
781 : else {
782 0 : e = ASN1_PARSE_ERROR;
783 0 : goto fail;
784 : }
785 3556 : if(size) *size = ret;
786 3340 : return 0;
787 0 : fail:
788 0 : free_DirectoryString(data);
789 0 : return e;
790 : }
791 :
792 : void ASN1CALL
793 6964 : free_DirectoryString(DirectoryString *data)
794 : {
795 6964 : switch((data)->element) {
796 1044 : case choice_DirectoryString_ia5String:
797 1044 : der_free_ia5_string(&(data)->u.ia5String);
798 1044 : break;
799 0 : case choice_DirectoryString_teletexString:
800 0 : der_free_general_string(&(data)->u.teletexString);
801 0 : break;
802 1044 : case choice_DirectoryString_printableString:
803 1044 : der_free_printable_string(&(data)->u.printableString);
804 1044 : break;
805 0 : case choice_DirectoryString_universalString:
806 0 : der_free_universal_string(&(data)->u.universalString);
807 0 : break;
808 4876 : case choice_DirectoryString_utf8String:
809 4876 : der_free_utf8string(&(data)->u.utf8String);
810 4876 : break;
811 0 : case choice_DirectoryString_bmpString:
812 0 : der_free_bmp_string(&(data)->u.bmpString);
813 0 : break;
814 : }
815 6964 : }
816 :
817 : size_t ASN1CALL
818 2276 : length_DirectoryString(const DirectoryString *data)
819 : {
820 2276 : size_t ret = 0;
821 2276 : switch((data)->element) {
822 344 : case choice_DirectoryString_ia5String:
823 : {
824 344 : size_t Top_oldret = ret;
825 344 : ret = 0;
826 344 : ret += der_length_ia5_string(&(data)->u.ia5String);
827 344 : ret += 1 + der_length_len (ret);
828 344 : ret += Top_oldret;
829 : }
830 344 : break;
831 0 : case choice_DirectoryString_teletexString:
832 : {
833 0 : size_t Top_oldret = ret;
834 0 : ret = 0;
835 0 : ret += der_length_general_string(&(data)->u.teletexString);
836 0 : ret += 1 + der_length_len (ret);
837 0 : ret += Top_oldret;
838 : }
839 0 : break;
840 344 : case choice_DirectoryString_printableString:
841 : {
842 344 : size_t Top_oldret = ret;
843 344 : ret = 0;
844 344 : ret += der_length_printable_string(&(data)->u.printableString);
845 344 : ret += 1 + der_length_len (ret);
846 344 : ret += Top_oldret;
847 : }
848 344 : break;
849 0 : case choice_DirectoryString_universalString:
850 : {
851 0 : size_t Top_oldret = ret;
852 0 : ret = 0;
853 0 : ret += der_length_universal_string(&(data)->u.universalString);
854 0 : ret += 1 + der_length_len (ret);
855 0 : ret += Top_oldret;
856 : }
857 0 : break;
858 1588 : case choice_DirectoryString_utf8String:
859 : {
860 1588 : size_t Top_oldret = ret;
861 1588 : ret = 0;
862 1588 : ret += der_length_utf8string(&(data)->u.utf8String);
863 1588 : ret += 1 + der_length_len (ret);
864 1588 : ret += Top_oldret;
865 : }
866 1588 : break;
867 0 : case choice_DirectoryString_bmpString:
868 : {
869 0 : size_t Top_oldret = ret;
870 0 : ret = 0;
871 0 : ret += der_length_bmp_string(&(data)->u.bmpString);
872 0 : ret += 1 + der_length_len (ret);
873 0 : ret += Top_oldret;
874 : }
875 0 : break;
876 : }
877 2276 : return ret;
878 : }
879 :
880 : int ASN1CALL
881 4996 : copy_DirectoryString(const DirectoryString *from, DirectoryString *to)
882 : {
883 4996 : memset(to, 0, sizeof(*to));
884 4996 : (to)->element = (from)->element;
885 4996 : switch((from)->element) {
886 750 : case choice_DirectoryString_ia5String:
887 750 : if(der_copy_ia5_string(&(from)->u.ia5String, &(to)->u.ia5String)) goto fail;
888 718 : break;
889 0 : case choice_DirectoryString_teletexString:
890 0 : if(der_copy_general_string(&(from)->u.teletexString, &(to)->u.teletexString)) goto fail;
891 0 : break;
892 750 : case choice_DirectoryString_printableString:
893 750 : if(der_copy_printable_string(&(from)->u.printableString, &(to)->u.printableString)) goto fail;
894 718 : break;
895 0 : case choice_DirectoryString_universalString:
896 0 : if(der_copy_universal_string(&(from)->u.universalString, &(to)->u.universalString)) goto fail;
897 0 : break;
898 3496 : case choice_DirectoryString_utf8String:
899 3496 : if(der_copy_utf8string(&(from)->u.utf8String, &(to)->u.utf8String)) goto fail;
900 3344 : break;
901 0 : case choice_DirectoryString_bmpString:
902 0 : if(der_copy_bmp_string(&(from)->u.bmpString, &(to)->u.bmpString)) goto fail;
903 0 : break;
904 : }
905 4780 : return 0;
906 0 : fail:
907 0 : free_DirectoryString(to);
908 0 : return ENOMEM;
909 : }
910 :
911 : int ASN1CALL
912 384 : encode_Attribute(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const Attribute *data, size_t *size)
913 : {
914 384 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
915 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
916 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
917 :
918 : /* value */
919 : {
920 384 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
921 384 : ret = 0;
922 : {
923 : struct heim_octet_string *val;
924 384 : size_t elen = 0, totallen = 0;
925 384 : int eret = 0;
926 384 : if ((&(data)->value)->len > UINT_MAX/sizeof(val[0]))
927 0 : return ERANGE;
928 384 : val = malloc(sizeof(val[0]) * (&(data)->value)->len);
929 384 : if (val == NULL && (&(data)->value)->len != 0) return ENOMEM;
930 768 : for(i = 0; i < (int)(&(data)->value)->len; i++) {
931 384 : ASN1_MALLOC_ENCODE(heim_any, val[i].data, val[i].length, &(&(data)->value)->val[i], &elen, eret);
932 384 : if(eret) {
933 0 : i--;
934 0 : while (i >= 0) {
935 0 : free(val[i].data);
936 0 : i--;
937 : }
938 0 : free(val);
939 0 : return eret;
940 : }
941 384 : totallen += elen;
942 : }
943 384 : if (totallen > len) {
944 0 : for (i = 0; i < (int)(&(data)->value)->len; i++) {
945 0 : free(val[i].data);
946 : }
947 0 : free(val);
948 0 : return ASN1_OVERFLOW;
949 : }
950 384 : qsort(val, (&(data)->value)->len, sizeof(val[0]), _heim_der_set_sort);
951 768 : for(i = (int)(&(data)->value)->len - 1; i >= 0; --i) {
952 384 : p -= val[i].length;
953 384 : ret += val[i].length;
954 384 : memcpy(p + 1, val[i].data, val[i].length);
955 384 : free(val[i].data);
956 : }
957 384 : free(val);
958 : }
959 384 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Set, &l);
960 384 : if (e) return e;
961 384 : p -= l; len -= l; ret += l;
962 :
963 384 : ret += Top_tag_oldret;
964 : }
965 : /* type */
966 : {
967 384 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
968 384 : ret = 0;
969 384 : e = encode_AttributeType(p, len, &(data)->type, &l);
970 384 : if (e) return e;
971 384 : p -= l; len -= l; ret += l;
972 :
973 384 : ret += Top_tag_oldret;
974 : }
975 384 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
976 384 : if (e) return e;
977 384 : p -= l; len -= l; ret += l;
978 :
979 384 : *size = ret;
980 384 : return 0;
981 : }
982 :
983 : int ASN1CALL
984 120 : decode_Attribute(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, Attribute *data, size_t *size)
985 : {
986 120 : size_t ret = 0;
987 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
988 : int e HEIMDAL_UNUSED_ATTRIBUTE;
989 :
990 120 : memset(data, 0, sizeof(*data));
991 : {
992 : size_t Top_datalen, Top_oldlen;
993 : Der_type Top_type;
994 120 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
995 120 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
996 120 : if(e) goto fail;
997 120 : p += l; len -= l; ret += l;
998 120 : Top_oldlen = len;
999 120 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1000 120 : len = Top_datalen;
1001 120 : e = decode_AttributeType(p, len, &(data)->type, &l);
1002 120 : if(e) goto fail;
1003 120 : p += l; len -= l; ret += l;
1004 : {
1005 : size_t value_datalen, value_oldlen;
1006 : Der_type value_type;
1007 120 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &value_type, UT_Set, &value_datalen, &l);
1008 120 : if (e == 0 && value_type != CONS) { e = ASN1_BAD_ID; }
1009 120 : if(e) goto fail;
1010 120 : p += l; len -= l; ret += l;
1011 120 : value_oldlen = len;
1012 120 : if (value_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1013 120 : len = value_datalen;
1014 : {
1015 120 : size_t value_Tag_origlen = len;
1016 120 : size_t value_Tag_oldret = ret;
1017 120 : size_t value_Tag_olen = 0;
1018 : void *value_Tag_tmp;
1019 120 : ret = 0;
1020 120 : (&(data)->value)->len = 0;
1021 120 : (&(data)->value)->val = NULL;
1022 360 : while(ret < value_Tag_origlen) {
1023 120 : size_t value_Tag_nlen = value_Tag_olen + sizeof(*((&(data)->value)->val));
1024 120 : if (value_Tag_olen > value_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
1025 120 : value_Tag_olen = value_Tag_nlen;
1026 120 : value_Tag_tmp = realloc((&(data)->value)->val, value_Tag_olen);
1027 120 : if (value_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
1028 120 : (&(data)->value)->val = value_Tag_tmp;
1029 120 : e = decode_heim_any(p, len, &(&(data)->value)->val[(&(data)->value)->len], &l);
1030 120 : if(e) goto fail;
1031 120 : p += l; len -= l; ret += l;
1032 120 : (&(data)->value)->len++;
1033 120 : len = value_Tag_origlen - ret;
1034 : }
1035 120 : ret += value_Tag_oldret;
1036 : }
1037 120 : len = value_oldlen - value_datalen;
1038 : }
1039 120 : len = Top_oldlen - Top_datalen;
1040 : }
1041 240 : if(size) *size = ret;
1042 120 : return 0;
1043 0 : fail:
1044 0 : free_Attribute(data);
1045 0 : return e;
1046 : }
1047 :
1048 : void ASN1CALL
1049 252 : free_Attribute(Attribute *data)
1050 : {
1051 252 : free_AttributeType(&(data)->type);
1052 756 : while((&(data)->value)->len){
1053 252 : free_heim_any(&(&(data)->value)->val[(&(data)->value)->len-1]);
1054 252 : (&(data)->value)->len--;
1055 : }
1056 252 : free((&(data)->value)->val);
1057 252 : (&(data)->value)->val = NULL;
1058 252 : }
1059 :
1060 : size_t ASN1CALL
1061 900 : length_Attribute(const Attribute *data)
1062 : {
1063 900 : size_t ret = 0;
1064 : {
1065 900 : size_t Top_tag_oldret = ret;
1066 900 : ret = 0;
1067 900 : ret += length_AttributeType(&(data)->type);
1068 900 : ret += Top_tag_oldret;
1069 : }
1070 : {
1071 900 : size_t Top_tag_oldret = ret;
1072 900 : ret = 0;
1073 : {
1074 900 : size_t value_tag_oldret = ret;
1075 : int i;
1076 900 : ret = 0;
1077 1800 : for(i = (&(data)->value)->len - 1; i >= 0; --i){
1078 900 : size_t value_tag_for_oldret = ret;
1079 900 : ret = 0;
1080 900 : ret += length_heim_any(&(&(data)->value)->val[i]);
1081 900 : ret += value_tag_for_oldret;
1082 : }
1083 900 : ret += value_tag_oldret;
1084 : }
1085 900 : ret += 1 + der_length_len (ret);
1086 900 : ret += Top_tag_oldret;
1087 : }
1088 900 : ret += 1 + der_length_len (ret);
1089 900 : return ret;
1090 : }
1091 :
1092 : int ASN1CALL
1093 0 : copy_Attribute(const Attribute *from, Attribute *to)
1094 : {
1095 0 : memset(to, 0, sizeof(*to));
1096 0 : if(copy_AttributeType(&(from)->type, &(to)->type)) goto fail;
1097 0 : if(((&(to)->value)->val = malloc((&(from)->value)->len * sizeof(*(&(to)->value)->val))) == NULL && (&(from)->value)->len != 0)
1098 0 : goto fail;
1099 0 : for((&(to)->value)->len = 0; (&(to)->value)->len < (&(from)->value)->len; (&(to)->value)->len++){
1100 0 : if(copy_heim_any(&(&(from)->value)->val[(&(to)->value)->len], &(&(to)->value)->val[(&(to)->value)->len])) goto fail;
1101 : }
1102 0 : return 0;
1103 0 : fail:
1104 0 : free_Attribute(to);
1105 0 : return ENOMEM;
1106 : }
1107 :
1108 : int ASN1CALL
1109 1138 : encode_AttributeTypeAndValue(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const AttributeTypeAndValue *data, size_t *size)
1110 : {
1111 1138 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
1112 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1113 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
1114 :
1115 : /* value */
1116 : {
1117 1138 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
1118 1138 : ret = 0;
1119 1138 : e = encode_DirectoryString(p, len, &(data)->value, &l);
1120 1138 : if (e) return e;
1121 1138 : p -= l; len -= l; ret += l;
1122 :
1123 1138 : ret += Top_tag_oldret;
1124 : }
1125 : /* type */
1126 : {
1127 1138 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
1128 1138 : ret = 0;
1129 1138 : e = encode_AttributeType(p, len, &(data)->type, &l);
1130 1138 : if (e) return e;
1131 1138 : p -= l; len -= l; ret += l;
1132 :
1133 1138 : ret += Top_tag_oldret;
1134 : }
1135 1138 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
1136 1138 : if (e) return e;
1137 1138 : p -= l; len -= l; ret += l;
1138 :
1139 1138 : *size = ret;
1140 1138 : return 0;
1141 : }
1142 :
1143 : int ASN1CALL
1144 3556 : decode_AttributeTypeAndValue(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, AttributeTypeAndValue *data, size_t *size)
1145 : {
1146 3556 : size_t ret = 0;
1147 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1148 : int e HEIMDAL_UNUSED_ATTRIBUTE;
1149 :
1150 3556 : memset(data, 0, sizeof(*data));
1151 : {
1152 : size_t Top_datalen, Top_oldlen;
1153 : Der_type Top_type;
1154 3556 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
1155 3556 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
1156 3556 : if(e) goto fail;
1157 3556 : p += l; len -= l; ret += l;
1158 3556 : Top_oldlen = len;
1159 3556 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1160 3556 : len = Top_datalen;
1161 3556 : e = decode_AttributeType(p, len, &(data)->type, &l);
1162 3556 : if(e) goto fail;
1163 3556 : p += l; len -= l; ret += l;
1164 3556 : e = decode_DirectoryString(p, len, &(data)->value, &l);
1165 3556 : if(e) goto fail;
1166 3556 : p += l; len -= l; ret += l;
1167 3556 : len = Top_oldlen - Top_datalen;
1168 : }
1169 7112 : if(size) *size = ret;
1170 3340 : return 0;
1171 0 : fail:
1172 0 : free_AttributeTypeAndValue(data);
1173 0 : return e;
1174 : }
1175 :
1176 : void ASN1CALL
1177 6964 : free_AttributeTypeAndValue(AttributeTypeAndValue *data)
1178 : {
1179 6964 : free_AttributeType(&(data)->type);
1180 6964 : free_DirectoryString(&(data)->value);
1181 6964 : }
1182 :
1183 : size_t ASN1CALL
1184 2276 : length_AttributeTypeAndValue(const AttributeTypeAndValue *data)
1185 : {
1186 2276 : size_t ret = 0;
1187 : {
1188 2276 : size_t Top_tag_oldret = ret;
1189 2276 : ret = 0;
1190 2276 : ret += length_AttributeType(&(data)->type);
1191 2276 : ret += Top_tag_oldret;
1192 : }
1193 : {
1194 2276 : size_t Top_tag_oldret = ret;
1195 2276 : ret = 0;
1196 2276 : ret += length_DirectoryString(&(data)->value);
1197 2276 : ret += Top_tag_oldret;
1198 : }
1199 2276 : ret += 1 + der_length_len (ret);
1200 2276 : return ret;
1201 : }
1202 :
1203 : int ASN1CALL
1204 4996 : copy_AttributeTypeAndValue(const AttributeTypeAndValue *from, AttributeTypeAndValue *to)
1205 : {
1206 4996 : memset(to, 0, sizeof(*to));
1207 4996 : if(copy_AttributeType(&(from)->type, &(to)->type)) goto fail;
1208 4996 : if(copy_DirectoryString(&(from)->value, &(to)->value)) goto fail;
1209 4780 : return 0;
1210 0 : fail:
1211 0 : free_AttributeTypeAndValue(to);
1212 0 : return ENOMEM;
1213 : }
1214 :
1215 : int ASN1CALL
1216 1138 : encode_RelativeDistinguishedName(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const RelativeDistinguishedName *data, size_t *size)
1217 : {
1218 1138 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
1219 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1220 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
1221 :
1222 : {
1223 : struct heim_octet_string *val;
1224 1138 : size_t elen = 0, totallen = 0;
1225 1138 : int eret = 0;
1226 1138 : if ((data)->len > UINT_MAX/sizeof(val[0]))
1227 0 : return ERANGE;
1228 1138 : val = malloc(sizeof(val[0]) * (data)->len);
1229 1138 : if (val == NULL && (data)->len != 0) return ENOMEM;
1230 2276 : for(i = 0; i < (int)(data)->len; i++) {
1231 1138 : ASN1_MALLOC_ENCODE(AttributeTypeAndValue, val[i].data, val[i].length, &(data)->val[i], &elen, eret);
1232 1138 : if(eret) {
1233 0 : i--;
1234 0 : while (i >= 0) {
1235 0 : free(val[i].data);
1236 0 : i--;
1237 : }
1238 0 : free(val);
1239 0 : return eret;
1240 : }
1241 1138 : totallen += elen;
1242 : }
1243 1138 : if (totallen > len) {
1244 0 : for (i = 0; i < (int)(data)->len; i++) {
1245 0 : free(val[i].data);
1246 : }
1247 0 : free(val);
1248 0 : return ASN1_OVERFLOW;
1249 : }
1250 1138 : qsort(val, (data)->len, sizeof(val[0]), _heim_der_set_sort);
1251 2276 : for(i = (int)(data)->len - 1; i >= 0; --i) {
1252 1138 : p -= val[i].length;
1253 1138 : ret += val[i].length;
1254 1138 : memcpy(p + 1, val[i].data, val[i].length);
1255 1138 : free(val[i].data);
1256 : }
1257 1138 : free(val);
1258 : }
1259 1138 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Set, &l);
1260 1138 : if (e) return e;
1261 1138 : p -= l; len -= l; ret += l;
1262 :
1263 1138 : *size = ret;
1264 1138 : return 0;
1265 : }
1266 :
1267 : int ASN1CALL
1268 3556 : decode_RelativeDistinguishedName(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, RelativeDistinguishedName *data, size_t *size)
1269 : {
1270 3556 : size_t ret = 0;
1271 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1272 : int e HEIMDAL_UNUSED_ATTRIBUTE;
1273 :
1274 3556 : memset(data, 0, sizeof(*data));
1275 : {
1276 : size_t Top_datalen, Top_oldlen;
1277 : Der_type Top_type;
1278 3556 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Set, &Top_datalen, &l);
1279 3556 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
1280 3556 : if(e) goto fail;
1281 3556 : p += l; len -= l; ret += l;
1282 3556 : Top_oldlen = len;
1283 3556 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1284 3556 : len = Top_datalen;
1285 : {
1286 3556 : size_t Top_Tag_origlen = len;
1287 3556 : size_t Top_Tag_oldret = ret;
1288 3556 : size_t Top_Tag_olen = 0;
1289 : void *Top_Tag_tmp;
1290 3556 : ret = 0;
1291 3556 : (data)->len = 0;
1292 3556 : (data)->val = NULL;
1293 10668 : while(ret < Top_Tag_origlen) {
1294 3556 : size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
1295 3556 : if (Top_Tag_olen > Top_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
1296 3556 : Top_Tag_olen = Top_Tag_nlen;
1297 3556 : Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
1298 3556 : if (Top_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
1299 3556 : (data)->val = Top_Tag_tmp;
1300 3556 : e = decode_AttributeTypeAndValue(p, len, &(data)->val[(data)->len], &l);
1301 3556 : if(e) goto fail;
1302 3556 : p += l; len -= l; ret += l;
1303 3556 : (data)->len++;
1304 3556 : len = Top_Tag_origlen - ret;
1305 : }
1306 3556 : ret += Top_Tag_oldret;
1307 : }
1308 3556 : len = Top_oldlen - Top_datalen;
1309 : }
1310 7112 : if(size) *size = ret;
1311 3340 : return 0;
1312 0 : fail:
1313 0 : free_RelativeDistinguishedName(data);
1314 0 : return e;
1315 : }
1316 :
1317 : void ASN1CALL
1318 6964 : free_RelativeDistinguishedName(RelativeDistinguishedName *data)
1319 : {
1320 20892 : while((data)->len){
1321 6964 : free_AttributeTypeAndValue(&(data)->val[(data)->len-1]);
1322 6964 : (data)->len--;
1323 : }
1324 6964 : free((data)->val);
1325 6964 : (data)->val = NULL;
1326 6964 : }
1327 :
1328 : size_t ASN1CALL
1329 1138 : length_RelativeDistinguishedName(const RelativeDistinguishedName *data)
1330 : {
1331 1138 : size_t ret = 0;
1332 : {
1333 1138 : size_t Top_tag_oldret = ret;
1334 : int i;
1335 1138 : ret = 0;
1336 2276 : for(i = (data)->len - 1; i >= 0; --i){
1337 1138 : size_t Top_tag_for_oldret = ret;
1338 1138 : ret = 0;
1339 1138 : ret += length_AttributeTypeAndValue(&(data)->val[i]);
1340 1138 : ret += Top_tag_for_oldret;
1341 : }
1342 1138 : ret += Top_tag_oldret;
1343 : }
1344 1138 : ret += 1 + der_length_len (ret);
1345 1138 : return ret;
1346 : }
1347 :
1348 : int ASN1CALL
1349 4996 : copy_RelativeDistinguishedName(const RelativeDistinguishedName *from, RelativeDistinguishedName *to)
1350 : {
1351 4996 : memset(to, 0, sizeof(*to));
1352 4996 : if(((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
1353 0 : goto fail;
1354 9992 : for((to)->len = 0; (to)->len < (from)->len; (to)->len++){
1355 4996 : if(copy_AttributeTypeAndValue(&(from)->val[(to)->len], &(to)->val[(to)->len])) goto fail;
1356 : }
1357 4780 : return 0;
1358 0 : fail:
1359 0 : free_RelativeDistinguishedName(to);
1360 0 : return ENOMEM;
1361 : }
1362 :
1363 : int ASN1CALL
1364 172 : encode_RDNSequence(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const RDNSequence *data, size_t *size)
1365 : {
1366 172 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
1367 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1368 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
1369 :
1370 1310 : for(i = (int)(data)->len - 1; i >= 0; --i) {
1371 1138 : size_t Top_tag_for_oldret = ret;
1372 1138 : ret = 0;
1373 1138 : e = encode_RelativeDistinguishedName(p, len, &(data)->val[i], &l);
1374 1138 : if (e) return e;
1375 1138 : p -= l; len -= l; ret += l;
1376 :
1377 1138 : ret += Top_tag_for_oldret;
1378 : }
1379 172 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
1380 172 : if (e) return e;
1381 172 : p -= l; len -= l; ret += l;
1382 :
1383 172 : *size = ret;
1384 172 : return 0;
1385 : }
1386 :
1387 : int ASN1CALL
1388 530 : decode_RDNSequence(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, RDNSequence *data, size_t *size)
1389 : {
1390 530 : size_t ret = 0;
1391 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1392 : int e HEIMDAL_UNUSED_ATTRIBUTE;
1393 :
1394 530 : memset(data, 0, sizeof(*data));
1395 : {
1396 : size_t Top_datalen, Top_oldlen;
1397 : Der_type Top_type;
1398 530 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
1399 530 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
1400 530 : if(e) goto fail;
1401 530 : p += l; len -= l; ret += l;
1402 530 : Top_oldlen = len;
1403 530 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1404 530 : len = Top_datalen;
1405 : {
1406 530 : size_t Top_Tag_origlen = len;
1407 530 : size_t Top_Tag_oldret = ret;
1408 530 : size_t Top_Tag_olen = 0;
1409 : void *Top_Tag_tmp;
1410 530 : ret = 0;
1411 530 : (data)->len = 0;
1412 530 : (data)->val = NULL;
1413 4616 : while(ret < Top_Tag_origlen) {
1414 3556 : size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
1415 3556 : if (Top_Tag_olen > Top_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
1416 3556 : Top_Tag_olen = Top_Tag_nlen;
1417 3556 : Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
1418 3556 : if (Top_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
1419 3556 : (data)->val = Top_Tag_tmp;
1420 3556 : e = decode_RelativeDistinguishedName(p, len, &(data)->val[(data)->len], &l);
1421 3556 : if(e) goto fail;
1422 3556 : p += l; len -= l; ret += l;
1423 3556 : (data)->len++;
1424 3556 : len = Top_Tag_origlen - ret;
1425 : }
1426 530 : ret += Top_Tag_oldret;
1427 : }
1428 530 : len = Top_oldlen - Top_datalen;
1429 : }
1430 1060 : if(size) *size = ret;
1431 498 : return 0;
1432 0 : fail:
1433 0 : free_RDNSequence(data);
1434 0 : return e;
1435 : }
1436 :
1437 : void ASN1CALL
1438 1044 : free_RDNSequence(RDNSequence *data)
1439 : {
1440 9052 : while((data)->len){
1441 6964 : free_RelativeDistinguishedName(&(data)->val[(data)->len-1]);
1442 6964 : (data)->len--;
1443 : }
1444 1044 : free((data)->val);
1445 1044 : (data)->val = NULL;
1446 1044 : }
1447 :
1448 : size_t ASN1CALL
1449 172 : length_RDNSequence(const RDNSequence *data)
1450 : {
1451 172 : size_t ret = 0;
1452 : {
1453 172 : size_t Top_tag_oldret = ret;
1454 : int i;
1455 172 : ret = 0;
1456 1310 : for(i = (data)->len - 1; i >= 0; --i){
1457 1138 : size_t Top_tag_for_oldret = ret;
1458 1138 : ret = 0;
1459 1138 : ret += length_RelativeDistinguishedName(&(data)->val[i]);
1460 1138 : ret += Top_tag_for_oldret;
1461 : }
1462 172 : ret += Top_tag_oldret;
1463 : }
1464 172 : ret += 1 + der_length_len (ret);
1465 172 : return ret;
1466 : }
1467 :
1468 : int ASN1CALL
1469 750 : copy_RDNSequence(const RDNSequence *from, RDNSequence *to)
1470 : {
1471 750 : memset(to, 0, sizeof(*to));
1472 750 : if(((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
1473 0 : goto fail;
1474 5746 : for((to)->len = 0; (to)->len < (from)->len; (to)->len++){
1475 4996 : if(copy_RelativeDistinguishedName(&(from)->val[(to)->len], &(to)->val[(to)->len])) goto fail;
1476 : }
1477 718 : return 0;
1478 0 : fail:
1479 0 : free_RDNSequence(to);
1480 0 : return ENOMEM;
1481 : }
1482 :
1483 : int ASN1CALL
1484 172 : encode_Name(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const Name *data, size_t *size)
1485 : {
1486 172 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
1487 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1488 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
1489 :
1490 :
1491 172 : switch((data)->element) {
1492 172 : case choice_Name_rdnSequence: {size_t Top_oldret = ret;
1493 172 : ret = 0;
1494 172 : e = encode_RDNSequence(p, len, &((data))->u.rdnSequence, &l);
1495 172 : if (e) return e;
1496 172 : p -= l; len -= l; ret += l;
1497 :
1498 172 : ret += Top_oldret;
1499 172 : break;
1500 : }
1501 : };
1502 172 : *size = ret;
1503 172 : return 0;
1504 : }
1505 :
1506 : int ASN1CALL
1507 530 : decode_Name(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, Name *data, size_t *size)
1508 : {
1509 530 : size_t ret = 0;
1510 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1511 : int e HEIMDAL_UNUSED_ATTRIBUTE;
1512 530 : const unsigned char *begin = p;
1513 :
1514 530 : memset(data, 0, sizeof(*data));
1515 530 : if (der_match_tag(p, len, ASN1_C_UNIV, CONS, UT_Sequence, NULL) == 0) {
1516 530 : e = decode_RDNSequence(p, len, &(data)->u.rdnSequence, &l);
1517 530 : if(e) goto fail;
1518 530 : p += l; len -= l; ret += l;
1519 530 : (data)->element = choice_Name_rdnSequence;
1520 : }
1521 : else {
1522 0 : e = ASN1_PARSE_ERROR;
1523 0 : goto fail;
1524 : }
1525 530 : data->_save.data = calloc(1, ret);
1526 530 : if (data->_save.data == NULL) {
1527 0 : e = ENOMEM; goto fail;
1528 : }
1529 530 : data->_save.length = ret;
1530 562 : memcpy(data->_save.data, begin, ret);
1531 530 : if(size) *size = ret;
1532 498 : return 0;
1533 0 : fail:
1534 0 : free_Name(data);
1535 0 : return e;
1536 : }
1537 :
1538 : void ASN1CALL
1539 1104 : free_Name(Name *data)
1540 : {
1541 1104 : der_free_octet_string(&data->_save);
1542 1104 : switch((data)->element) {
1543 1044 : case choice_Name_rdnSequence:
1544 1044 : free_RDNSequence(&(data)->u.rdnSequence);
1545 1044 : break;
1546 : }
1547 1104 : }
1548 :
1549 : size_t ASN1CALL
1550 172 : length_Name(const Name *data)
1551 : {
1552 172 : size_t ret = 0;
1553 172 : switch((data)->element) {
1554 172 : case choice_Name_rdnSequence:
1555 : {
1556 172 : size_t Top_oldret = ret;
1557 172 : ret = 0;
1558 172 : ret += length_RDNSequence(&(data)->u.rdnSequence);
1559 172 : ret += Top_oldret;
1560 : }
1561 172 : break;
1562 : }
1563 172 : return ret;
1564 : }
1565 :
1566 : int ASN1CALL
1567 750 : copy_Name(const Name *from, Name *to)
1568 : {
1569 750 : memset(to, 0, sizeof(*to));
1570 : { int ret;
1571 750 : ret = der_copy_octet_string(&(from)->_save, &(to)->_save);
1572 750 : if (ret) goto fail;
1573 : }
1574 750 : (to)->element = (from)->element;
1575 750 : switch((from)->element) {
1576 750 : case choice_Name_rdnSequence:
1577 750 : if(copy_RDNSequence(&(from)->u.rdnSequence, &(to)->u.rdnSequence)) goto fail;
1578 718 : break;
1579 : }
1580 718 : return 0;
1581 0 : fail:
1582 0 : free_Name(to);
1583 0 : return ENOMEM;
1584 : }
1585 :
1586 : int ASN1CALL
1587 106 : encode_CertificateSerialNumber(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const CertificateSerialNumber *data, size_t *size)
1588 : {
1589 106 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
1590 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1591 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
1592 :
1593 106 : e = der_put_heim_integer(p, len, data, &l);
1594 106 : if (e) return e;
1595 106 : p -= l; len -= l; ret += l;
1596 :
1597 106 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
1598 106 : if (e) return e;
1599 106 : p -= l; len -= l; ret += l;
1600 :
1601 106 : *size = ret;
1602 106 : return 0;
1603 : }
1604 :
1605 : int ASN1CALL
1606 282 : decode_CertificateSerialNumber(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, CertificateSerialNumber *data, size_t *size)
1607 : {
1608 282 : size_t ret = 0;
1609 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1610 : int e HEIMDAL_UNUSED_ATTRIBUTE;
1611 :
1612 282 : memset(data, 0, sizeof(*data));
1613 : {
1614 : size_t Top_datalen, Top_oldlen;
1615 : Der_type Top_type;
1616 282 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Integer, &Top_datalen, &l);
1617 282 : if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
1618 282 : if(e) goto fail;
1619 282 : p += l; len -= l; ret += l;
1620 282 : Top_oldlen = len;
1621 282 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1622 282 : len = Top_datalen;
1623 282 : e = der_get_heim_integer(p, len, data, &l);
1624 282 : if(e) goto fail;
1625 282 : p += l; len -= l; ret += l;
1626 282 : len = Top_oldlen - Top_datalen;
1627 : }
1628 564 : if(size) *size = ret;
1629 266 : return 0;
1630 0 : fail:
1631 0 : free_CertificateSerialNumber(data);
1632 0 : return e;
1633 : }
1634 :
1635 : void ASN1CALL
1636 452 : free_CertificateSerialNumber(CertificateSerialNumber *data)
1637 : {
1638 452 : der_free_heim_integer(data);
1639 452 : }
1640 :
1641 : size_t ASN1CALL
1642 106 : length_CertificateSerialNumber(const CertificateSerialNumber *data)
1643 : {
1644 106 : size_t ret = 0;
1645 106 : ret += der_length_heim_integer(data);
1646 106 : ret += 1 + der_length_len (ret);
1647 106 : return ret;
1648 : }
1649 :
1650 : int ASN1CALL
1651 248 : copy_CertificateSerialNumber(const CertificateSerialNumber *from, CertificateSerialNumber *to)
1652 : {
1653 248 : memset(to, 0, sizeof(*to));
1654 248 : if(der_copy_heim_integer(from, to)) goto fail;
1655 232 : return 0;
1656 0 : fail:
1657 0 : free_CertificateSerialNumber(to);
1658 0 : return ENOMEM;
1659 : }
1660 :
1661 : int ASN1CALL
1662 132 : encode_Time(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const Time *data, size_t *size)
1663 : {
1664 132 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
1665 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1666 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
1667 :
1668 :
1669 132 : switch((data)->element) {
1670 0 : case choice_Time_generalTime: {size_t Top_oldret = ret;
1671 0 : ret = 0;
1672 0 : e = der_put_generalized_time(p, len, &((data))->u.generalTime, &l);
1673 0 : if (e) return e;
1674 0 : p -= l; len -= l; ret += l;
1675 :
1676 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_GeneralizedTime, &l);
1677 0 : if (e) return e;
1678 0 : p -= l; len -= l; ret += l;
1679 :
1680 0 : ret += Top_oldret;
1681 0 : break;
1682 : }
1683 132 : case choice_Time_utcTime: {size_t Top_oldret = ret;
1684 132 : ret = 0;
1685 132 : e = der_put_utctime(p, len, &((data))->u.utcTime, &l);
1686 132 : if (e) return e;
1687 132 : p -= l; len -= l; ret += l;
1688 :
1689 132 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_UTCTime, &l);
1690 132 : if (e) return e;
1691 132 : p -= l; len -= l; ret += l;
1692 :
1693 132 : ret += Top_oldret;
1694 132 : break;
1695 : }
1696 : };
1697 132 : *size = ret;
1698 132 : return 0;
1699 : }
1700 :
1701 : int ASN1CALL
1702 496 : decode_Time(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, Time *data, size_t *size)
1703 : {
1704 496 : size_t ret = 0;
1705 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1706 : int e HEIMDAL_UNUSED_ATTRIBUTE;
1707 :
1708 496 : memset(data, 0, sizeof(*data));
1709 496 : if (der_match_tag(p, len, ASN1_C_UNIV, PRIM, UT_UTCTime, NULL) == 0) {
1710 : {
1711 : size_t utcTime_datalen, utcTime_oldlen;
1712 : Der_type utcTime_type;
1713 496 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &utcTime_type, UT_UTCTime, &utcTime_datalen, &l);
1714 496 : if (e == 0 && utcTime_type != PRIM) { e = ASN1_BAD_ID; }
1715 496 : if(e) goto fail;
1716 496 : p += l; len -= l; ret += l;
1717 496 : utcTime_oldlen = len;
1718 496 : if (utcTime_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1719 496 : len = utcTime_datalen;
1720 496 : e = der_get_utctime(p, len, &(data)->u.utcTime, &l);
1721 496 : if(e) goto fail;
1722 496 : p += l; len -= l; ret += l;
1723 496 : len = utcTime_oldlen - utcTime_datalen;
1724 : }
1725 496 : (data)->element = choice_Time_utcTime;
1726 : }
1727 0 : else if (der_match_tag(p, len, ASN1_C_UNIV, PRIM, UT_GeneralizedTime, NULL) == 0) {
1728 : {
1729 : size_t generalTime_datalen, generalTime_oldlen;
1730 : Der_type generalTime_type;
1731 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &generalTime_type, UT_GeneralizedTime, &generalTime_datalen, &l);
1732 0 : if (e == 0 && generalTime_type != PRIM) { e = ASN1_BAD_ID; }
1733 0 : if(e) goto fail;
1734 0 : p += l; len -= l; ret += l;
1735 0 : generalTime_oldlen = len;
1736 0 : if (generalTime_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1737 0 : len = generalTime_datalen;
1738 0 : e = der_get_generalized_time(p, len, &(data)->u.generalTime, &l);
1739 0 : if(e) goto fail;
1740 0 : p += l; len -= l; ret += l;
1741 0 : len = generalTime_oldlen - generalTime_datalen;
1742 : }
1743 0 : (data)->element = choice_Time_generalTime;
1744 : }
1745 : else {
1746 0 : e = ASN1_PARSE_ERROR;
1747 0 : goto fail;
1748 : }
1749 496 : if(size) *size = ret;
1750 464 : return 0;
1751 0 : fail:
1752 0 : free_Time(data);
1753 0 : return e;
1754 : }
1755 :
1756 : void ASN1CALL
1757 756 : free_Time(Time *data)
1758 : {
1759 724 : switch((data)->element) {
1760 724 : case choice_Time_utcTime:
1761 724 : break;
1762 0 : case choice_Time_generalTime:
1763 0 : break;
1764 : }
1765 756 : }
1766 :
1767 : size_t ASN1CALL
1768 132 : length_Time(const Time *data)
1769 : {
1770 132 : size_t ret = 0;
1771 132 : switch((data)->element) {
1772 132 : case choice_Time_utcTime:
1773 : {
1774 132 : size_t Top_oldret = ret;
1775 132 : ret = 0;
1776 132 : ret += der_length_utctime(&(data)->u.utcTime);
1777 132 : ret += 1 + der_length_len (ret);
1778 132 : ret += Top_oldret;
1779 : }
1780 132 : break;
1781 0 : case choice_Time_generalTime:
1782 : {
1783 0 : size_t Top_oldret = ret;
1784 0 : ret = 0;
1785 0 : ret += der_length_generalized_time(&(data)->u.generalTime);
1786 0 : ret += 1 + der_length_len (ret);
1787 0 : ret += Top_oldret;
1788 : }
1789 0 : break;
1790 : }
1791 132 : return ret;
1792 : }
1793 :
1794 : int ASN1CALL
1795 496 : copy_Time(const Time *from, Time *to)
1796 : {
1797 496 : memset(to, 0, sizeof(*to));
1798 496 : (to)->element = (from)->element;
1799 496 : switch((from)->element) {
1800 496 : case choice_Time_utcTime:
1801 496 : *(&(to)->u.utcTime) = *(&(from)->u.utcTime);
1802 496 : break;
1803 0 : case choice_Time_generalTime:
1804 0 : *(&(to)->u.generalTime) = *(&(from)->u.generalTime);
1805 0 : break;
1806 : }
1807 496 : return 0;
1808 : }
1809 :
1810 : int ASN1CALL
1811 66 : encode_Validity(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const Validity *data, size_t *size)
1812 : {
1813 66 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
1814 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1815 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
1816 :
1817 : /* notAfter */
1818 : {
1819 66 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
1820 66 : ret = 0;
1821 66 : e = encode_Time(p, len, &(data)->notAfter, &l);
1822 66 : if (e) return e;
1823 66 : p -= l; len -= l; ret += l;
1824 :
1825 66 : ret += Top_tag_oldret;
1826 : }
1827 : /* notBefore */
1828 : {
1829 66 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
1830 66 : ret = 0;
1831 66 : e = encode_Time(p, len, &(data)->notBefore, &l);
1832 66 : if (e) return e;
1833 66 : p -= l; len -= l; ret += l;
1834 :
1835 66 : ret += Top_tag_oldret;
1836 : }
1837 66 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
1838 66 : if (e) return e;
1839 66 : p -= l; len -= l; ret += l;
1840 :
1841 66 : *size = ret;
1842 66 : return 0;
1843 : }
1844 :
1845 : int ASN1CALL
1846 248 : decode_Validity(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, Validity *data, size_t *size)
1847 : {
1848 248 : size_t ret = 0;
1849 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1850 : int e HEIMDAL_UNUSED_ATTRIBUTE;
1851 :
1852 248 : memset(data, 0, sizeof(*data));
1853 : {
1854 : size_t Top_datalen, Top_oldlen;
1855 : Der_type Top_type;
1856 248 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
1857 248 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
1858 248 : if(e) goto fail;
1859 248 : p += l; len -= l; ret += l;
1860 248 : Top_oldlen = len;
1861 248 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1862 248 : len = Top_datalen;
1863 248 : e = decode_Time(p, len, &(data)->notBefore, &l);
1864 248 : if(e) goto fail;
1865 248 : p += l; len -= l; ret += l;
1866 248 : e = decode_Time(p, len, &(data)->notAfter, &l);
1867 248 : if(e) goto fail;
1868 248 : p += l; len -= l; ret += l;
1869 248 : len = Top_oldlen - Top_datalen;
1870 : }
1871 496 : if(size) *size = ret;
1872 232 : return 0;
1873 0 : fail:
1874 0 : free_Validity(data);
1875 0 : return e;
1876 : }
1877 :
1878 : void ASN1CALL
1879 378 : free_Validity(Validity *data)
1880 : {
1881 378 : free_Time(&(data)->notBefore);
1882 378 : free_Time(&(data)->notAfter);
1883 378 : }
1884 :
1885 : size_t ASN1CALL
1886 66 : length_Validity(const Validity *data)
1887 : {
1888 66 : size_t ret = 0;
1889 : {
1890 66 : size_t Top_tag_oldret = ret;
1891 66 : ret = 0;
1892 66 : ret += length_Time(&(data)->notBefore);
1893 66 : ret += Top_tag_oldret;
1894 : }
1895 : {
1896 66 : size_t Top_tag_oldret = ret;
1897 66 : ret = 0;
1898 66 : ret += length_Time(&(data)->notAfter);
1899 66 : ret += Top_tag_oldret;
1900 : }
1901 66 : ret += 1 + der_length_len (ret);
1902 66 : return ret;
1903 : }
1904 :
1905 : int ASN1CALL
1906 248 : copy_Validity(const Validity *from, Validity *to)
1907 : {
1908 248 : memset(to, 0, sizeof(*to));
1909 248 : if(copy_Time(&(from)->notBefore, &(to)->notBefore)) goto fail;
1910 248 : if(copy_Time(&(from)->notAfter, &(to)->notAfter)) goto fail;
1911 232 : return 0;
1912 0 : fail:
1913 0 : free_Validity(to);
1914 0 : return ENOMEM;
1915 : }
1916 :
1917 : int ASN1CALL
1918 0 : encode_UniqueIdentifier(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const UniqueIdentifier *data, size_t *size)
1919 : {
1920 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
1921 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1922 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
1923 :
1924 0 : e = der_put_bit_string(p, len, data, &l);
1925 0 : if (e) return e;
1926 0 : p -= l; len -= l; ret += l;
1927 :
1928 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_BitString, &l);
1929 0 : if (e) return e;
1930 0 : p -= l; len -= l; ret += l;
1931 :
1932 0 : *size = ret;
1933 0 : return 0;
1934 : }
1935 :
1936 : int ASN1CALL
1937 0 : decode_UniqueIdentifier(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, UniqueIdentifier *data, size_t *size)
1938 : {
1939 0 : size_t ret = 0;
1940 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1941 : int e HEIMDAL_UNUSED_ATTRIBUTE;
1942 :
1943 0 : memset(data, 0, sizeof(*data));
1944 : {
1945 : size_t Top_datalen, Top_oldlen;
1946 : Der_type Top_type;
1947 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_BitString, &Top_datalen, &l);
1948 0 : if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
1949 0 : if(e) goto fail;
1950 0 : p += l; len -= l; ret += l;
1951 0 : Top_oldlen = len;
1952 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1953 0 : len = Top_datalen;
1954 0 : e = der_get_bit_string(p, len, data, &l);
1955 0 : if(e) goto fail;
1956 0 : p += l; len -= l; ret += l;
1957 0 : len = Top_oldlen - Top_datalen;
1958 : }
1959 0 : if(size) *size = ret;
1960 0 : return 0;
1961 0 : fail:
1962 0 : free_UniqueIdentifier(data);
1963 0 : return e;
1964 : }
1965 :
1966 : void ASN1CALL
1967 0 : free_UniqueIdentifier(UniqueIdentifier *data)
1968 : {
1969 0 : der_free_bit_string(data);
1970 0 : }
1971 :
1972 : size_t ASN1CALL
1973 0 : length_UniqueIdentifier(const UniqueIdentifier *data)
1974 : {
1975 0 : size_t ret = 0;
1976 0 : ret += der_length_bit_string(data);
1977 0 : ret += 1 + der_length_len (ret);
1978 0 : return ret;
1979 : }
1980 :
1981 : int ASN1CALL
1982 0 : copy_UniqueIdentifier(const UniqueIdentifier *from, UniqueIdentifier *to)
1983 : {
1984 0 : memset(to, 0, sizeof(*to));
1985 0 : if(der_copy_bit_string(from, to)) goto fail;
1986 0 : return 0;
1987 0 : fail:
1988 0 : free_UniqueIdentifier(to);
1989 0 : return ENOMEM;
1990 : }
1991 :
1992 : int ASN1CALL
1993 106 : encode_SubjectPublicKeyInfo(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const SubjectPublicKeyInfo *data, size_t *size)
1994 : {
1995 106 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
1996 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1997 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
1998 :
1999 : /* subjectPublicKey */
2000 : {
2001 106 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2002 106 : ret = 0;
2003 106 : e = der_put_bit_string(p, len, &(data)->subjectPublicKey, &l);
2004 106 : if (e) return e;
2005 106 : p -= l; len -= l; ret += l;
2006 :
2007 106 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_BitString, &l);
2008 106 : if (e) return e;
2009 106 : p -= l; len -= l; ret += l;
2010 :
2011 106 : ret += Top_tag_oldret;
2012 : }
2013 : /* algorithm */
2014 : {
2015 106 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2016 106 : ret = 0;
2017 106 : e = encode_AlgorithmIdentifier(p, len, &(data)->algorithm, &l);
2018 106 : if (e) return e;
2019 106 : p -= l; len -= l; ret += l;
2020 :
2021 106 : ret += Top_tag_oldret;
2022 : }
2023 106 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
2024 106 : if (e) return e;
2025 106 : p -= l; len -= l; ret += l;
2026 :
2027 106 : *size = ret;
2028 106 : return 0;
2029 : }
2030 :
2031 : int ASN1CALL
2032 282 : decode_SubjectPublicKeyInfo(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, SubjectPublicKeyInfo *data, size_t *size)
2033 : {
2034 282 : size_t ret = 0;
2035 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2036 : int e HEIMDAL_UNUSED_ATTRIBUTE;
2037 :
2038 282 : memset(data, 0, sizeof(*data));
2039 : {
2040 : size_t Top_datalen, Top_oldlen;
2041 : Der_type Top_type;
2042 282 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
2043 282 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
2044 282 : if(e) goto fail;
2045 282 : p += l; len -= l; ret += l;
2046 282 : Top_oldlen = len;
2047 282 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2048 282 : len = Top_datalen;
2049 282 : e = decode_AlgorithmIdentifier(p, len, &(data)->algorithm, &l);
2050 282 : if(e) goto fail;
2051 282 : p += l; len -= l; ret += l;
2052 : {
2053 : size_t subjectPublicKey_datalen, subjectPublicKey_oldlen;
2054 : Der_type subjectPublicKey_type;
2055 282 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &subjectPublicKey_type, UT_BitString, &subjectPublicKey_datalen, &l);
2056 282 : if (e == 0 && subjectPublicKey_type != PRIM) { e = ASN1_BAD_ID; }
2057 282 : if(e) goto fail;
2058 282 : p += l; len -= l; ret += l;
2059 282 : subjectPublicKey_oldlen = len;
2060 282 : if (subjectPublicKey_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2061 282 : len = subjectPublicKey_datalen;
2062 282 : e = der_get_bit_string(p, len, &(data)->subjectPublicKey, &l);
2063 282 : if(e) goto fail;
2064 282 : p += l; len -= l; ret += l;
2065 282 : len = subjectPublicKey_oldlen - subjectPublicKey_datalen;
2066 : }
2067 282 : len = Top_oldlen - Top_datalen;
2068 : }
2069 564 : if(size) *size = ret;
2070 266 : return 0;
2071 0 : fail:
2072 0 : free_SubjectPublicKeyInfo(data);
2073 0 : return e;
2074 : }
2075 :
2076 : void ASN1CALL
2077 452 : free_SubjectPublicKeyInfo(SubjectPublicKeyInfo *data)
2078 : {
2079 452 : free_AlgorithmIdentifier(&(data)->algorithm);
2080 452 : der_free_bit_string(&(data)->subjectPublicKey);
2081 452 : }
2082 :
2083 : size_t ASN1CALL
2084 106 : length_SubjectPublicKeyInfo(const SubjectPublicKeyInfo *data)
2085 : {
2086 106 : size_t ret = 0;
2087 : {
2088 106 : size_t Top_tag_oldret = ret;
2089 106 : ret = 0;
2090 106 : ret += length_AlgorithmIdentifier(&(data)->algorithm);
2091 106 : ret += Top_tag_oldret;
2092 : }
2093 : {
2094 106 : size_t Top_tag_oldret = ret;
2095 106 : ret = 0;
2096 106 : ret += der_length_bit_string(&(data)->subjectPublicKey);
2097 106 : ret += 1 + der_length_len (ret);
2098 106 : ret += Top_tag_oldret;
2099 : }
2100 106 : ret += 1 + der_length_len (ret);
2101 106 : return ret;
2102 : }
2103 :
2104 : int ASN1CALL
2105 248 : copy_SubjectPublicKeyInfo(const SubjectPublicKeyInfo *from, SubjectPublicKeyInfo *to)
2106 : {
2107 248 : memset(to, 0, sizeof(*to));
2108 248 : if(copy_AlgorithmIdentifier(&(from)->algorithm, &(to)->algorithm)) goto fail;
2109 248 : if(der_copy_bit_string(&(from)->subjectPublicKey, &(to)->subjectPublicKey)) goto fail;
2110 232 : return 0;
2111 0 : fail:
2112 0 : free_SubjectPublicKeyInfo(to);
2113 0 : return ENOMEM;
2114 : }
2115 :
2116 : int ASN1CALL
2117 726 : encode_Extension(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const Extension *data, size_t *size)
2118 : {
2119 726 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
2120 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2121 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
2122 :
2123 : /* extnValue */
2124 : {
2125 726 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2126 726 : ret = 0;
2127 726 : e = der_put_octet_string(p, len, &(data)->extnValue, &l);
2128 726 : if (e) return e;
2129 726 : p -= l; len -= l; ret += l;
2130 :
2131 726 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
2132 726 : if (e) return e;
2133 726 : p -= l; len -= l; ret += l;
2134 :
2135 726 : ret += Top_tag_oldret;
2136 : }
2137 : /* critical */
2138 726 : if((data)->critical) {
2139 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2140 0 : ret = 0;
2141 0 : e = der_put_boolean(p, len, (data)->critical, &l);
2142 0 : if (e) return e;
2143 0 : p -= l; len -= l; ret += l;
2144 :
2145 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Boolean, &l);
2146 0 : if (e) return e;
2147 0 : p -= l; len -= l; ret += l;
2148 :
2149 0 : ret += Top_tag_oldret;
2150 : }
2151 : /* extnID */
2152 : {
2153 726 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2154 726 : ret = 0;
2155 726 : e = der_put_oid(p, len, &(data)->extnID, &l);
2156 726 : if (e) return e;
2157 726 : p -= l; len -= l; ret += l;
2158 :
2159 726 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OID, &l);
2160 726 : if (e) return e;
2161 726 : p -= l; len -= l; ret += l;
2162 :
2163 726 : ret += Top_tag_oldret;
2164 : }
2165 726 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
2166 726 : if (e) return e;
2167 726 : p -= l; len -= l; ret += l;
2168 :
2169 726 : *size = ret;
2170 726 : return 0;
2171 : }
2172 :
2173 : int ASN1CALL
2174 2446 : decode_Extension(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, Extension *data, size_t *size)
2175 : {
2176 2446 : size_t ret = 0;
2177 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2178 : int e HEIMDAL_UNUSED_ATTRIBUTE;
2179 :
2180 2446 : memset(data, 0, sizeof(*data));
2181 : {
2182 : size_t Top_datalen, Top_oldlen;
2183 : Der_type Top_type;
2184 2446 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
2185 2446 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
2186 2446 : if(e) goto fail;
2187 2446 : p += l; len -= l; ret += l;
2188 2446 : Top_oldlen = len;
2189 2446 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2190 2446 : len = Top_datalen;
2191 : {
2192 : size_t extnID_datalen, extnID_oldlen;
2193 : Der_type extnID_type;
2194 2446 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &extnID_type, UT_OID, &extnID_datalen, &l);
2195 2446 : if (e == 0 && extnID_type != PRIM) { e = ASN1_BAD_ID; }
2196 2446 : if(e) goto fail;
2197 2446 : p += l; len -= l; ret += l;
2198 2446 : extnID_oldlen = len;
2199 2446 : if (extnID_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2200 2446 : len = extnID_datalen;
2201 2446 : e = der_get_oid(p, len, &(data)->extnID, &l);
2202 2446 : if(e) goto fail;
2203 2446 : p += l; len -= l; ret += l;
2204 2446 : len = extnID_oldlen - extnID_datalen;
2205 : }
2206 : {
2207 : size_t critical_datalen, critical_oldlen;
2208 : Der_type critical_type;
2209 2446 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &critical_type, UT_Boolean, &critical_datalen, &l);
2210 2446 : if (e == 0 && critical_type != PRIM) { e = ASN1_BAD_ID; }
2211 2446 : if(e) {
2212 2446 : (data)->critical = NULL;
2213 : } else {
2214 0 : (data)->critical = calloc(1, sizeof(*(data)->critical));
2215 0 : if ((data)->critical == NULL) { e = ENOMEM; goto fail; }
2216 0 : p += l; len -= l; ret += l;
2217 0 : critical_oldlen = len;
2218 0 : if (critical_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2219 0 : len = critical_datalen;
2220 0 : e = der_get_boolean(p, len, (data)->critical, &l);
2221 0 : if(e) goto fail;
2222 0 : p += l; len -= l; ret += l;
2223 0 : len = critical_oldlen - critical_datalen;
2224 : }
2225 : }
2226 : {
2227 : size_t extnValue_datalen, extnValue_oldlen;
2228 : Der_type extnValue_type;
2229 2446 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &extnValue_type, UT_OctetString, &extnValue_datalen, &l);
2230 4892 : if (e == 0 && extnValue_type != PRIM) { e = ASN1_BAD_ID; }
2231 2446 : if(e) goto fail;
2232 2446 : p += l; len -= l; ret += l;
2233 2446 : extnValue_oldlen = len;
2234 2446 : if (extnValue_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2235 2446 : len = extnValue_datalen;
2236 2446 : e = der_get_octet_string(p, len, &(data)->extnValue, &l);
2237 2446 : if(e) goto fail;
2238 2446 : p += l; len -= l; ret += l;
2239 2446 : len = extnValue_oldlen - extnValue_datalen;
2240 : }
2241 2446 : len = Top_oldlen - Top_datalen;
2242 : }
2243 4892 : if(size) *size = ret;
2244 2294 : return 0;
2245 0 : fail:
2246 0 : free_Extension(data);
2247 0 : return e;
2248 : }
2249 :
2250 : void ASN1CALL
2251 3756 : free_Extension(Extension *data)
2252 : {
2253 3756 : der_free_oid(&(data)->extnID);
2254 3756 : if((data)->critical) {
2255 0 : free((data)->critical);
2256 0 : (data)->critical = NULL;
2257 : }
2258 3756 : der_free_octet_string(&(data)->extnValue);
2259 3756 : }
2260 :
2261 : size_t ASN1CALL
2262 726 : length_Extension(const Extension *data)
2263 : {
2264 726 : size_t ret = 0;
2265 : {
2266 726 : size_t Top_tag_oldret = ret;
2267 726 : ret = 0;
2268 726 : ret += der_length_oid(&(data)->extnID);
2269 726 : ret += 1 + der_length_len (ret);
2270 726 : ret += Top_tag_oldret;
2271 : }
2272 726 : if((data)->critical){
2273 0 : size_t Top_tag_oldret = ret;
2274 0 : ret = 0;
2275 0 : ret += 1;
2276 0 : ret += 1 + der_length_len (ret);
2277 0 : ret += Top_tag_oldret;
2278 : }
2279 : {
2280 726 : size_t Top_tag_oldret = ret;
2281 726 : ret = 0;
2282 726 : ret += der_length_octet_string(&(data)->extnValue);
2283 726 : ret += 1 + der_length_len (ret);
2284 726 : ret += Top_tag_oldret;
2285 : }
2286 726 : ret += 1 + der_length_len (ret);
2287 726 : return ret;
2288 : }
2289 :
2290 : int ASN1CALL
2291 2446 : copy_Extension(const Extension *from, Extension *to)
2292 : {
2293 2446 : memset(to, 0, sizeof(*to));
2294 2446 : if(der_copy_oid(&(from)->extnID, &(to)->extnID)) goto fail;
2295 2446 : if((from)->critical) {
2296 0 : (to)->critical = malloc(sizeof(*(to)->critical));
2297 0 : if((to)->critical == NULL) goto fail;
2298 0 : *((to)->critical) = *((from)->critical);
2299 : }else
2300 2446 : (to)->critical = NULL;
2301 2446 : if(der_copy_octet_string(&(from)->extnValue, &(to)->extnValue)) goto fail;
2302 2294 : return 0;
2303 0 : fail:
2304 0 : free_Extension(to);
2305 0 : return ENOMEM;
2306 : }
2307 :
2308 : int ASN1CALL
2309 66 : encode_Extensions(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const Extensions *data, size_t *size)
2310 : {
2311 66 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
2312 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2313 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
2314 :
2315 792 : for(i = (int)(data)->len - 1; i >= 0; --i) {
2316 726 : size_t Top_tag_for_oldret = ret;
2317 726 : ret = 0;
2318 726 : e = encode_Extension(p, len, &(data)->val[i], &l);
2319 726 : if (e) return e;
2320 726 : p -= l; len -= l; ret += l;
2321 :
2322 726 : ret += Top_tag_for_oldret;
2323 : }
2324 66 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
2325 66 : if (e) return e;
2326 66 : p -= l; len -= l; ret += l;
2327 :
2328 66 : *size = ret;
2329 66 : return 0;
2330 : }
2331 :
2332 : int ASN1CALL
2333 248 : decode_Extensions(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, Extensions *data, size_t *size)
2334 : {
2335 248 : size_t ret = 0;
2336 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2337 : int e HEIMDAL_UNUSED_ATTRIBUTE;
2338 :
2339 248 : memset(data, 0, sizeof(*data));
2340 : {
2341 : size_t Top_datalen, Top_oldlen;
2342 : Der_type Top_type;
2343 248 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
2344 248 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
2345 248 : if(e) goto fail;
2346 248 : p += l; len -= l; ret += l;
2347 248 : Top_oldlen = len;
2348 248 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2349 248 : len = Top_datalen;
2350 : {
2351 248 : size_t Top_Tag_origlen = len;
2352 248 : size_t Top_Tag_oldret = ret;
2353 248 : size_t Top_Tag_olen = 0;
2354 : void *Top_Tag_tmp;
2355 248 : ret = 0;
2356 248 : (data)->len = 0;
2357 248 : (data)->val = NULL;
2358 2942 : while(ret < Top_Tag_origlen) {
2359 2446 : size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
2360 2446 : if (Top_Tag_olen > Top_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
2361 2446 : Top_Tag_olen = Top_Tag_nlen;
2362 2446 : Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
2363 2446 : if (Top_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
2364 2446 : (data)->val = Top_Tag_tmp;
2365 2446 : e = decode_Extension(p, len, &(data)->val[(data)->len], &l);
2366 2446 : if(e) goto fail;
2367 2446 : p += l; len -= l; ret += l;
2368 2446 : (data)->len++;
2369 2446 : len = Top_Tag_origlen - ret;
2370 : }
2371 248 : ret += Top_Tag_oldret;
2372 : }
2373 248 : if ((data)->len < 1) {
2374 0 : e = ASN1_MIN_CONSTRAINT; goto fail;
2375 : }
2376 248 : len = Top_oldlen - Top_datalen;
2377 : }
2378 496 : if(size) *size = ret;
2379 232 : return 0;
2380 0 : fail:
2381 0 : free_Extensions(data);
2382 0 : return e;
2383 : }
2384 :
2385 : void ASN1CALL
2386 378 : free_Extensions(Extensions *data)
2387 : {
2388 4512 : while((data)->len){
2389 3756 : free_Extension(&(data)->val[(data)->len-1]);
2390 3756 : (data)->len--;
2391 : }
2392 378 : free((data)->val);
2393 378 : (data)->val = NULL;
2394 378 : }
2395 :
2396 : size_t ASN1CALL
2397 66 : length_Extensions(const Extensions *data)
2398 : {
2399 66 : size_t ret = 0;
2400 : {
2401 66 : size_t Top_tag_oldret = ret;
2402 : int i;
2403 66 : ret = 0;
2404 792 : for(i = (data)->len - 1; i >= 0; --i){
2405 726 : size_t Top_tag_for_oldret = ret;
2406 726 : ret = 0;
2407 726 : ret += length_Extension(&(data)->val[i]);
2408 726 : ret += Top_tag_for_oldret;
2409 : }
2410 66 : ret += Top_tag_oldret;
2411 : }
2412 66 : ret += 1 + der_length_len (ret);
2413 66 : return ret;
2414 : }
2415 :
2416 : int ASN1CALL
2417 248 : copy_Extensions(const Extensions *from, Extensions *to)
2418 : {
2419 248 : memset(to, 0, sizeof(*to));
2420 248 : if(((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
2421 0 : goto fail;
2422 2694 : for((to)->len = 0; (to)->len < (from)->len; (to)->len++){
2423 2446 : if(copy_Extension(&(from)->val[(to)->len], &(to)->val[(to)->len])) goto fail;
2424 : }
2425 232 : return 0;
2426 0 : fail:
2427 0 : free_Extensions(to);
2428 0 : return ENOMEM;
2429 : }
2430 :
2431 : int ASN1CALL
2432 0 : add_Extensions(Extensions *data, const Extension *element)
2433 : {
2434 : int ret;
2435 : void *ptr;
2436 :
2437 0 : ptr = realloc(data->val,
2438 0 : (data->len + 1) * sizeof(data->val[0]));
2439 0 : if (ptr == NULL) return ENOMEM;
2440 0 : data->val = ptr;
2441 :
2442 0 : ret = copy_Extension(element, &data->val[data->len]);
2443 0 : if (ret) return ret;
2444 0 : data->len++;
2445 0 : return 0;
2446 : }
2447 :
2448 : int ASN1CALL
2449 0 : remove_Extensions(Extensions *data, unsigned int element)
2450 : {
2451 : void *ptr;
2452 :
2453 0 : if (data->len == 0 || element >= data->len)
2454 0 : return ASN1_OVERRUN;
2455 0 : free_Extension(&data->val[element]);
2456 0 : data->len--;
2457 0 : if (element < data->len)
2458 0 : memmove(&data->val[element], &data->val[element + 1],
2459 0 : sizeof(data->val[0]) * data->len);
2460 0 : ptr = realloc(data->val, data->len * sizeof(data->val[0]));
2461 0 : if (ptr != NULL || data->len == 0) data->val = ptr;
2462 0 : return 0;
2463 : }
2464 :
2465 : int ASN1CALL
2466 66 : encode_TBSCertificate(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const TBSCertificate *data, size_t *size)
2467 : {
2468 66 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
2469 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2470 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
2471 :
2472 : /* extensions */
2473 66 : if((data)->extensions) {
2474 66 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2475 66 : ret = 0;
2476 66 : e = encode_Extensions(p, len, (data)->extensions, &l);
2477 66 : if (e) return e;
2478 66 : p -= l; len -= l; ret += l;
2479 :
2480 66 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
2481 66 : if (e) return e;
2482 66 : p -= l; len -= l; ret += l;
2483 :
2484 66 : ret += Top_tag_oldret;
2485 : }
2486 : /* subjectUniqueID */
2487 66 : if((data)->subjectUniqueID) {
2488 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2489 0 : ret = 0;
2490 0 : e = der_put_bit_string(p, len, (data)->subjectUniqueID, &l);
2491 0 : if (e) return e;
2492 0 : p -= l; len -= l; ret += l;
2493 :
2494 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, PRIM, 2, &l);
2495 0 : if (e) return e;
2496 0 : p -= l; len -= l; ret += l;
2497 :
2498 0 : ret += Top_tag_oldret;
2499 : }
2500 : /* issuerUniqueID */
2501 66 : if((data)->issuerUniqueID) {
2502 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2503 0 : ret = 0;
2504 0 : e = der_put_bit_string(p, len, (data)->issuerUniqueID, &l);
2505 0 : if (e) return e;
2506 0 : p -= l; len -= l; ret += l;
2507 :
2508 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, PRIM, 1, &l);
2509 0 : if (e) return e;
2510 0 : p -= l; len -= l; ret += l;
2511 :
2512 0 : ret += Top_tag_oldret;
2513 : }
2514 : /* subjectPublicKeyInfo */
2515 : {
2516 66 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2517 66 : ret = 0;
2518 66 : e = encode_SubjectPublicKeyInfo(p, len, &(data)->subjectPublicKeyInfo, &l);
2519 66 : if (e) return e;
2520 66 : p -= l; len -= l; ret += l;
2521 :
2522 66 : ret += Top_tag_oldret;
2523 : }
2524 : /* subject */
2525 : {
2526 66 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2527 66 : ret = 0;
2528 66 : e = encode_Name(p, len, &(data)->subject, &l);
2529 66 : if (e) return e;
2530 66 : p -= l; len -= l; ret += l;
2531 :
2532 66 : ret += Top_tag_oldret;
2533 : }
2534 : /* validity */
2535 : {
2536 66 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2537 66 : ret = 0;
2538 66 : e = encode_Validity(p, len, &(data)->validity, &l);
2539 66 : if (e) return e;
2540 66 : p -= l; len -= l; ret += l;
2541 :
2542 66 : ret += Top_tag_oldret;
2543 : }
2544 : /* issuer */
2545 : {
2546 66 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2547 66 : ret = 0;
2548 66 : e = encode_Name(p, len, &(data)->issuer, &l);
2549 66 : if (e) return e;
2550 66 : p -= l; len -= l; ret += l;
2551 :
2552 66 : ret += Top_tag_oldret;
2553 : }
2554 : /* signature */
2555 : {
2556 66 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2557 66 : ret = 0;
2558 66 : e = encode_AlgorithmIdentifier(p, len, &(data)->signature, &l);
2559 66 : if (e) return e;
2560 66 : p -= l; len -= l; ret += l;
2561 :
2562 66 : ret += Top_tag_oldret;
2563 : }
2564 : /* serialNumber */
2565 : {
2566 66 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2567 66 : ret = 0;
2568 66 : e = encode_CertificateSerialNumber(p, len, &(data)->serialNumber, &l);
2569 66 : if (e) return e;
2570 66 : p -= l; len -= l; ret += l;
2571 :
2572 66 : ret += Top_tag_oldret;
2573 : }
2574 : /* version */
2575 66 : if((data)->version) {
2576 66 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2577 66 : ret = 0;
2578 66 : e = encode_Version(p, len, (data)->version, &l);
2579 66 : if (e) return e;
2580 66 : p -= l; len -= l; ret += l;
2581 :
2582 66 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
2583 66 : if (e) return e;
2584 66 : p -= l; len -= l; ret += l;
2585 :
2586 66 : ret += Top_tag_oldret;
2587 : }
2588 66 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
2589 66 : if (e) return e;
2590 66 : p -= l; len -= l; ret += l;
2591 :
2592 66 : *size = ret;
2593 66 : return 0;
2594 : }
2595 :
2596 : int ASN1CALL
2597 248 : decode_TBSCertificate(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, TBSCertificate *data, size_t *size)
2598 : {
2599 248 : size_t ret = 0;
2600 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2601 : int e HEIMDAL_UNUSED_ATTRIBUTE;
2602 248 : const unsigned char *begin = p;
2603 :
2604 248 : memset(data, 0, sizeof(*data));
2605 : {
2606 : size_t Top_datalen, Top_oldlen;
2607 : Der_type Top_type;
2608 248 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
2609 248 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
2610 248 : if(e) goto fail;
2611 248 : p += l; len -= l; ret += l;
2612 248 : Top_oldlen = len;
2613 248 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2614 248 : len = Top_datalen;
2615 : {
2616 : size_t version_datalen, version_oldlen;
2617 : Der_type version_type;
2618 248 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &version_type, 0, &version_datalen, &l);
2619 248 : if (e == 0 && version_type != CONS) { e = ASN1_BAD_ID; }
2620 248 : if(e) {
2621 0 : (data)->version = NULL;
2622 : } else {
2623 248 : (data)->version = calloc(1, sizeof(*(data)->version));
2624 248 : if ((data)->version == NULL) { e = ENOMEM; goto fail; }
2625 248 : p += l; len -= l; ret += l;
2626 248 : version_oldlen = len;
2627 248 : if (version_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2628 248 : len = version_datalen;
2629 248 : e = decode_Version(p, len, (data)->version, &l);
2630 248 : if(e) goto fail;
2631 248 : p += l; len -= l; ret += l;
2632 248 : len = version_oldlen - version_datalen;
2633 : }
2634 : }
2635 248 : e = decode_CertificateSerialNumber(p, len, &(data)->serialNumber, &l);
2636 248 : if(e) goto fail;
2637 248 : p += l; len -= l; ret += l;
2638 248 : e = decode_AlgorithmIdentifier(p, len, &(data)->signature, &l);
2639 248 : if(e) goto fail;
2640 248 : p += l; len -= l; ret += l;
2641 248 : e = decode_Name(p, len, &(data)->issuer, &l);
2642 248 : if(e) goto fail;
2643 248 : p += l; len -= l; ret += l;
2644 248 : e = decode_Validity(p, len, &(data)->validity, &l);
2645 248 : if(e) goto fail;
2646 248 : p += l; len -= l; ret += l;
2647 248 : e = decode_Name(p, len, &(data)->subject, &l);
2648 248 : if(e) goto fail;
2649 248 : p += l; len -= l; ret += l;
2650 248 : e = decode_SubjectPublicKeyInfo(p, len, &(data)->subjectPublicKeyInfo, &l);
2651 248 : if(e) goto fail;
2652 248 : p += l; len -= l; ret += l;
2653 : {
2654 : size_t issuerUniqueID_datalen, issuerUniqueID_oldlen;
2655 : Der_type issuerUniqueID_type;
2656 248 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &issuerUniqueID_type, 1, &issuerUniqueID_datalen, &l);
2657 248 : if (e == 0 && issuerUniqueID_type != PRIM) { e = ASN1_BAD_ID; }
2658 248 : if(e) {
2659 248 : (data)->issuerUniqueID = NULL;
2660 : } else {
2661 0 : (data)->issuerUniqueID = calloc(1, sizeof(*(data)->issuerUniqueID));
2662 0 : if ((data)->issuerUniqueID == NULL) { e = ENOMEM; goto fail; }
2663 0 : p += l; len -= l; ret += l;
2664 0 : issuerUniqueID_oldlen = len;
2665 0 : if (issuerUniqueID_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2666 0 : len = issuerUniqueID_datalen;
2667 0 : e = der_get_bit_string(p, len, (data)->issuerUniqueID, &l);
2668 0 : if(e) goto fail;
2669 0 : p += l; len -= l; ret += l;
2670 0 : len = issuerUniqueID_oldlen - issuerUniqueID_datalen;
2671 : }
2672 : }
2673 : {
2674 : size_t subjectUniqueID_datalen, subjectUniqueID_oldlen;
2675 : Der_type subjectUniqueID_type;
2676 248 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &subjectUniqueID_type, 2, &subjectUniqueID_datalen, &l);
2677 248 : if (e == 0 && subjectUniqueID_type != PRIM) { e = ASN1_BAD_ID; }
2678 248 : if(e) {
2679 248 : (data)->subjectUniqueID = NULL;
2680 : } else {
2681 0 : (data)->subjectUniqueID = calloc(1, sizeof(*(data)->subjectUniqueID));
2682 0 : if ((data)->subjectUniqueID == NULL) { e = ENOMEM; goto fail; }
2683 0 : p += l; len -= l; ret += l;
2684 0 : subjectUniqueID_oldlen = len;
2685 0 : if (subjectUniqueID_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2686 0 : len = subjectUniqueID_datalen;
2687 0 : e = der_get_bit_string(p, len, (data)->subjectUniqueID, &l);
2688 0 : if(e) goto fail;
2689 0 : p += l; len -= l; ret += l;
2690 0 : len = subjectUniqueID_oldlen - subjectUniqueID_datalen;
2691 : }
2692 : }
2693 : {
2694 : size_t extensions_datalen, extensions_oldlen;
2695 : Der_type extensions_type;
2696 248 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &extensions_type, 3, &extensions_datalen, &l);
2697 496 : if (e == 0 && extensions_type != CONS) { e = ASN1_BAD_ID; }
2698 248 : if(e) {
2699 0 : (data)->extensions = NULL;
2700 : } else {
2701 248 : (data)->extensions = calloc(1, sizeof(*(data)->extensions));
2702 248 : if ((data)->extensions == NULL) { e = ENOMEM; goto fail; }
2703 248 : p += l; len -= l; ret += l;
2704 248 : extensions_oldlen = len;
2705 248 : if (extensions_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2706 248 : len = extensions_datalen;
2707 248 : e = decode_Extensions(p, len, (data)->extensions, &l);
2708 248 : if(e) goto fail;
2709 248 : p += l; len -= l; ret += l;
2710 248 : len = extensions_oldlen - extensions_datalen;
2711 : }
2712 : }
2713 248 : len = Top_oldlen - Top_datalen;
2714 : }
2715 248 : data->_save.data = calloc(1, ret);
2716 248 : if (data->_save.data == NULL) {
2717 0 : e = ENOMEM; goto fail;
2718 : }
2719 248 : data->_save.length = ret;
2720 264 : memcpy(data->_save.data, begin, ret);
2721 248 : if(size) *size = ret;
2722 232 : return 0;
2723 0 : fail:
2724 0 : free_TBSCertificate(data);
2725 0 : return e;
2726 : }
2727 :
2728 : void ASN1CALL
2729 378 : free_TBSCertificate(TBSCertificate *data)
2730 : {
2731 378 : der_free_octet_string(&data->_save);
2732 378 : if((data)->version) {
2733 378 : free_Version((data)->version);
2734 378 : free((data)->version);
2735 378 : (data)->version = NULL;
2736 : }
2737 378 : free_CertificateSerialNumber(&(data)->serialNumber);
2738 378 : free_AlgorithmIdentifier(&(data)->signature);
2739 378 : free_Name(&(data)->issuer);
2740 378 : free_Validity(&(data)->validity);
2741 378 : free_Name(&(data)->subject);
2742 378 : free_SubjectPublicKeyInfo(&(data)->subjectPublicKeyInfo);
2743 378 : if((data)->issuerUniqueID) {
2744 0 : der_free_bit_string((data)->issuerUniqueID);
2745 0 : free((data)->issuerUniqueID);
2746 0 : (data)->issuerUniqueID = NULL;
2747 : }
2748 378 : if((data)->subjectUniqueID) {
2749 0 : der_free_bit_string((data)->subjectUniqueID);
2750 0 : free((data)->subjectUniqueID);
2751 0 : (data)->subjectUniqueID = NULL;
2752 : }
2753 378 : if((data)->extensions) {
2754 378 : free_Extensions((data)->extensions);
2755 378 : free((data)->extensions);
2756 378 : (data)->extensions = NULL;
2757 : }
2758 378 : }
2759 :
2760 : size_t ASN1CALL
2761 66 : length_TBSCertificate(const TBSCertificate *data)
2762 : {
2763 66 : size_t ret = 0;
2764 66 : if((data)->version){
2765 66 : size_t Top_tag_oldret = ret;
2766 66 : ret = 0;
2767 66 : ret += length_Version((data)->version);
2768 66 : ret += 1 + der_length_len (ret);
2769 66 : ret += Top_tag_oldret;
2770 : }
2771 : {
2772 66 : size_t Top_tag_oldret = ret;
2773 66 : ret = 0;
2774 66 : ret += length_CertificateSerialNumber(&(data)->serialNumber);
2775 66 : ret += Top_tag_oldret;
2776 : }
2777 : {
2778 66 : size_t Top_tag_oldret = ret;
2779 66 : ret = 0;
2780 66 : ret += length_AlgorithmIdentifier(&(data)->signature);
2781 66 : ret += Top_tag_oldret;
2782 : }
2783 : {
2784 66 : size_t Top_tag_oldret = ret;
2785 66 : ret = 0;
2786 66 : ret += length_Name(&(data)->issuer);
2787 66 : ret += Top_tag_oldret;
2788 : }
2789 : {
2790 66 : size_t Top_tag_oldret = ret;
2791 66 : ret = 0;
2792 66 : ret += length_Validity(&(data)->validity);
2793 66 : ret += Top_tag_oldret;
2794 : }
2795 : {
2796 66 : size_t Top_tag_oldret = ret;
2797 66 : ret = 0;
2798 66 : ret += length_Name(&(data)->subject);
2799 66 : ret += Top_tag_oldret;
2800 : }
2801 : {
2802 66 : size_t Top_tag_oldret = ret;
2803 66 : ret = 0;
2804 66 : ret += length_SubjectPublicKeyInfo(&(data)->subjectPublicKeyInfo);
2805 66 : ret += Top_tag_oldret;
2806 : }
2807 66 : if((data)->issuerUniqueID){
2808 0 : size_t Top_tag_oldret = ret;
2809 0 : ret = 0;
2810 0 : ret += der_length_bit_string((data)->issuerUniqueID);
2811 0 : ret += 1 + der_length_len (ret);
2812 0 : ret += Top_tag_oldret;
2813 : }
2814 66 : if((data)->subjectUniqueID){
2815 0 : size_t Top_tag_oldret = ret;
2816 0 : ret = 0;
2817 0 : ret += der_length_bit_string((data)->subjectUniqueID);
2818 0 : ret += 1 + der_length_len (ret);
2819 0 : ret += Top_tag_oldret;
2820 : }
2821 66 : if((data)->extensions){
2822 66 : size_t Top_tag_oldret = ret;
2823 66 : ret = 0;
2824 66 : ret += length_Extensions((data)->extensions);
2825 66 : ret += 1 + der_length_len (ret);
2826 66 : ret += Top_tag_oldret;
2827 : }
2828 66 : ret += 1 + der_length_len (ret);
2829 66 : return ret;
2830 : }
2831 :
2832 : int ASN1CALL
2833 248 : copy_TBSCertificate(const TBSCertificate *from, TBSCertificate *to)
2834 : {
2835 248 : memset(to, 0, sizeof(*to));
2836 : { int ret;
2837 248 : ret = der_copy_octet_string(&(from)->_save, &(to)->_save);
2838 248 : if (ret) goto fail;
2839 : }
2840 248 : if((from)->version) {
2841 248 : (to)->version = malloc(sizeof(*(to)->version));
2842 248 : if((to)->version == NULL) goto fail;
2843 248 : if(copy_Version((from)->version, (to)->version)) goto fail;
2844 : }else
2845 0 : (to)->version = NULL;
2846 248 : if(copy_CertificateSerialNumber(&(from)->serialNumber, &(to)->serialNumber)) goto fail;
2847 248 : if(copy_AlgorithmIdentifier(&(from)->signature, &(to)->signature)) goto fail;
2848 248 : if(copy_Name(&(from)->issuer, &(to)->issuer)) goto fail;
2849 248 : if(copy_Validity(&(from)->validity, &(to)->validity)) goto fail;
2850 248 : if(copy_Name(&(from)->subject, &(to)->subject)) goto fail;
2851 248 : if(copy_SubjectPublicKeyInfo(&(from)->subjectPublicKeyInfo, &(to)->subjectPublicKeyInfo)) goto fail;
2852 248 : if((from)->issuerUniqueID) {
2853 0 : (to)->issuerUniqueID = malloc(sizeof(*(to)->issuerUniqueID));
2854 0 : if((to)->issuerUniqueID == NULL) goto fail;
2855 0 : if(der_copy_bit_string((from)->issuerUniqueID, (to)->issuerUniqueID)) goto fail;
2856 : }else
2857 248 : (to)->issuerUniqueID = NULL;
2858 248 : if((from)->subjectUniqueID) {
2859 0 : (to)->subjectUniqueID = malloc(sizeof(*(to)->subjectUniqueID));
2860 0 : if((to)->subjectUniqueID == NULL) goto fail;
2861 0 : if(der_copy_bit_string((from)->subjectUniqueID, (to)->subjectUniqueID)) goto fail;
2862 : }else
2863 248 : (to)->subjectUniqueID = NULL;
2864 248 : if((from)->extensions) {
2865 248 : (to)->extensions = malloc(sizeof(*(to)->extensions));
2866 248 : if((to)->extensions == NULL) goto fail;
2867 248 : if(copy_Extensions((from)->extensions, (to)->extensions)) goto fail;
2868 : }else
2869 0 : (to)->extensions = NULL;
2870 232 : return 0;
2871 0 : fail:
2872 0 : free_TBSCertificate(to);
2873 0 : return ENOMEM;
2874 : }
2875 :
2876 : int ASN1CALL
2877 66 : encode_Certificate(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const Certificate *data, size_t *size)
2878 : {
2879 66 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
2880 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2881 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
2882 :
2883 : /* signatureValue */
2884 : {
2885 66 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2886 66 : ret = 0;
2887 66 : e = der_put_bit_string(p, len, &(data)->signatureValue, &l);
2888 66 : if (e) return e;
2889 66 : p -= l; len -= l; ret += l;
2890 :
2891 66 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_BitString, &l);
2892 66 : if (e) return e;
2893 66 : p -= l; len -= l; ret += l;
2894 :
2895 66 : ret += Top_tag_oldret;
2896 : }
2897 : /* signatureAlgorithm */
2898 : {
2899 66 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2900 66 : ret = 0;
2901 66 : e = encode_AlgorithmIdentifier(p, len, &(data)->signatureAlgorithm, &l);
2902 66 : if (e) return e;
2903 66 : p -= l; len -= l; ret += l;
2904 :
2905 66 : ret += Top_tag_oldret;
2906 : }
2907 : /* tbsCertificate */
2908 : {
2909 66 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2910 66 : ret = 0;
2911 66 : e = encode_TBSCertificate(p, len, &(data)->tbsCertificate, &l);
2912 66 : if (e) return e;
2913 66 : p -= l; len -= l; ret += l;
2914 :
2915 66 : ret += Top_tag_oldret;
2916 : }
2917 66 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
2918 66 : if (e) return e;
2919 66 : p -= l; len -= l; ret += l;
2920 :
2921 66 : *size = ret;
2922 66 : return 0;
2923 : }
2924 :
2925 : int ASN1CALL
2926 248 : decode_Certificate(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, Certificate *data, size_t *size)
2927 : {
2928 248 : size_t ret = 0;
2929 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2930 : int e HEIMDAL_UNUSED_ATTRIBUTE;
2931 :
2932 248 : memset(data, 0, sizeof(*data));
2933 : {
2934 : size_t Top_datalen, Top_oldlen;
2935 : Der_type Top_type;
2936 248 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
2937 248 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
2938 248 : if(e) goto fail;
2939 248 : p += l; len -= l; ret += l;
2940 248 : Top_oldlen = len;
2941 248 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2942 248 : len = Top_datalen;
2943 248 : e = decode_TBSCertificate(p, len, &(data)->tbsCertificate, &l);
2944 248 : if(e) goto fail;
2945 248 : p += l; len -= l; ret += l;
2946 248 : e = decode_AlgorithmIdentifier(p, len, &(data)->signatureAlgorithm, &l);
2947 248 : if(e) goto fail;
2948 248 : p += l; len -= l; ret += l;
2949 : {
2950 : size_t signatureValue_datalen, signatureValue_oldlen;
2951 : Der_type signatureValue_type;
2952 248 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &signatureValue_type, UT_BitString, &signatureValue_datalen, &l);
2953 248 : if (e == 0 && signatureValue_type != PRIM) { e = ASN1_BAD_ID; }
2954 248 : if(e) goto fail;
2955 248 : p += l; len -= l; ret += l;
2956 248 : signatureValue_oldlen = len;
2957 248 : if (signatureValue_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2958 248 : len = signatureValue_datalen;
2959 248 : e = der_get_bit_string(p, len, &(data)->signatureValue, &l);
2960 248 : if(e) goto fail;
2961 248 : p += l; len -= l; ret += l;
2962 248 : len = signatureValue_oldlen - signatureValue_datalen;
2963 : }
2964 248 : len = Top_oldlen - Top_datalen;
2965 : }
2966 496 : if(size) *size = ret;
2967 232 : return 0;
2968 0 : fail:
2969 0 : free_Certificate(data);
2970 0 : return e;
2971 : }
2972 :
2973 : void ASN1CALL
2974 378 : free_Certificate(Certificate *data)
2975 : {
2976 378 : free_TBSCertificate(&(data)->tbsCertificate);
2977 378 : free_AlgorithmIdentifier(&(data)->signatureAlgorithm);
2978 378 : der_free_bit_string(&(data)->signatureValue);
2979 378 : }
2980 :
2981 : size_t ASN1CALL
2982 66 : length_Certificate(const Certificate *data)
2983 : {
2984 66 : size_t ret = 0;
2985 : {
2986 66 : size_t Top_tag_oldret = ret;
2987 66 : ret = 0;
2988 66 : ret += length_TBSCertificate(&(data)->tbsCertificate);
2989 66 : ret += Top_tag_oldret;
2990 : }
2991 : {
2992 66 : size_t Top_tag_oldret = ret;
2993 66 : ret = 0;
2994 66 : ret += length_AlgorithmIdentifier(&(data)->signatureAlgorithm);
2995 66 : ret += Top_tag_oldret;
2996 : }
2997 : {
2998 66 : size_t Top_tag_oldret = ret;
2999 66 : ret = 0;
3000 66 : ret += der_length_bit_string(&(data)->signatureValue);
3001 66 : ret += 1 + der_length_len (ret);
3002 66 : ret += Top_tag_oldret;
3003 : }
3004 66 : ret += 1 + der_length_len (ret);
3005 66 : return ret;
3006 : }
3007 :
3008 : int ASN1CALL
3009 248 : copy_Certificate(const Certificate *from, Certificate *to)
3010 : {
3011 248 : memset(to, 0, sizeof(*to));
3012 248 : if(copy_TBSCertificate(&(from)->tbsCertificate, &(to)->tbsCertificate)) goto fail;
3013 248 : if(copy_AlgorithmIdentifier(&(from)->signatureAlgorithm, &(to)->signatureAlgorithm)) goto fail;
3014 248 : if(der_copy_bit_string(&(from)->signatureValue, &(to)->signatureValue)) goto fail;
3015 232 : return 0;
3016 0 : fail:
3017 0 : free_Certificate(to);
3018 0 : return ENOMEM;
3019 : }
3020 :
3021 : int ASN1CALL
3022 0 : encode_Certificates(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const Certificates *data, size_t *size)
3023 : {
3024 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
3025 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3026 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
3027 :
3028 0 : for(i = (int)(data)->len - 1; i >= 0; --i) {
3029 0 : size_t Top_tag_for_oldret = ret;
3030 0 : ret = 0;
3031 0 : e = encode_Certificate(p, len, &(data)->val[i], &l);
3032 0 : if (e) return e;
3033 0 : p -= l; len -= l; ret += l;
3034 :
3035 0 : ret += Top_tag_for_oldret;
3036 : }
3037 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
3038 0 : if (e) return e;
3039 0 : p -= l; len -= l; ret += l;
3040 :
3041 0 : *size = ret;
3042 0 : return 0;
3043 : }
3044 :
3045 : int ASN1CALL
3046 0 : decode_Certificates(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, Certificates *data, size_t *size)
3047 : {
3048 0 : size_t ret = 0;
3049 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3050 : int e HEIMDAL_UNUSED_ATTRIBUTE;
3051 :
3052 0 : memset(data, 0, sizeof(*data));
3053 : {
3054 : size_t Top_datalen, Top_oldlen;
3055 : Der_type Top_type;
3056 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
3057 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
3058 0 : if(e) goto fail;
3059 0 : p += l; len -= l; ret += l;
3060 0 : Top_oldlen = len;
3061 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3062 0 : len = Top_datalen;
3063 : {
3064 0 : size_t Top_Tag_origlen = len;
3065 0 : size_t Top_Tag_oldret = ret;
3066 0 : size_t Top_Tag_olen = 0;
3067 : void *Top_Tag_tmp;
3068 0 : ret = 0;
3069 0 : (data)->len = 0;
3070 0 : (data)->val = NULL;
3071 0 : while(ret < Top_Tag_origlen) {
3072 0 : size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
3073 0 : if (Top_Tag_olen > Top_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
3074 0 : Top_Tag_olen = Top_Tag_nlen;
3075 0 : Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
3076 0 : if (Top_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
3077 0 : (data)->val = Top_Tag_tmp;
3078 0 : e = decode_Certificate(p, len, &(data)->val[(data)->len], &l);
3079 0 : if(e) goto fail;
3080 0 : p += l; len -= l; ret += l;
3081 0 : (data)->len++;
3082 0 : len = Top_Tag_origlen - ret;
3083 : }
3084 0 : ret += Top_Tag_oldret;
3085 : }
3086 0 : len = Top_oldlen - Top_datalen;
3087 : }
3088 0 : if(size) *size = ret;
3089 0 : return 0;
3090 0 : fail:
3091 0 : free_Certificates(data);
3092 0 : return e;
3093 : }
3094 :
3095 : void ASN1CALL
3096 0 : free_Certificates(Certificates *data)
3097 : {
3098 0 : while((data)->len){
3099 0 : free_Certificate(&(data)->val[(data)->len-1]);
3100 0 : (data)->len--;
3101 : }
3102 0 : free((data)->val);
3103 0 : (data)->val = NULL;
3104 0 : }
3105 :
3106 : size_t ASN1CALL
3107 0 : length_Certificates(const Certificates *data)
3108 : {
3109 0 : size_t ret = 0;
3110 : {
3111 0 : size_t Top_tag_oldret = ret;
3112 : int i;
3113 0 : ret = 0;
3114 0 : for(i = (data)->len - 1; i >= 0; --i){
3115 0 : size_t Top_tag_for_oldret = ret;
3116 0 : ret = 0;
3117 0 : ret += length_Certificate(&(data)->val[i]);
3118 0 : ret += Top_tag_for_oldret;
3119 : }
3120 0 : ret += Top_tag_oldret;
3121 : }
3122 0 : ret += 1 + der_length_len (ret);
3123 0 : return ret;
3124 : }
3125 :
3126 : int ASN1CALL
3127 0 : copy_Certificates(const Certificates *from, Certificates *to)
3128 : {
3129 0 : memset(to, 0, sizeof(*to));
3130 0 : if(((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
3131 0 : goto fail;
3132 0 : for((to)->len = 0; (to)->len < (from)->len; (to)->len++){
3133 0 : if(copy_Certificate(&(from)->val[(to)->len], &(to)->val[(to)->len])) goto fail;
3134 : }
3135 0 : return 0;
3136 0 : fail:
3137 0 : free_Certificates(to);
3138 0 : return ENOMEM;
3139 : }
3140 :
3141 : int ASN1CALL
3142 0 : encode_ValidationParms(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const ValidationParms *data, size_t *size)
3143 : {
3144 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
3145 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3146 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
3147 :
3148 : /* pgenCounter */
3149 : {
3150 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3151 0 : ret = 0;
3152 0 : e = der_put_heim_integer(p, len, &(data)->pgenCounter, &l);
3153 0 : if (e) return e;
3154 0 : p -= l; len -= l; ret += l;
3155 :
3156 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
3157 0 : if (e) return e;
3158 0 : p -= l; len -= l; ret += l;
3159 :
3160 0 : ret += Top_tag_oldret;
3161 : }
3162 : /* seed */
3163 : {
3164 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3165 0 : ret = 0;
3166 0 : e = der_put_bit_string(p, len, &(data)->seed, &l);
3167 0 : if (e) return e;
3168 0 : p -= l; len -= l; ret += l;
3169 :
3170 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_BitString, &l);
3171 0 : if (e) return e;
3172 0 : p -= l; len -= l; ret += l;
3173 :
3174 0 : ret += Top_tag_oldret;
3175 : }
3176 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
3177 0 : if (e) return e;
3178 0 : p -= l; len -= l; ret += l;
3179 :
3180 0 : *size = ret;
3181 0 : return 0;
3182 : }
3183 :
3184 : int ASN1CALL
3185 34 : decode_ValidationParms(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, ValidationParms *data, size_t *size)
3186 : {
3187 34 : size_t ret = 0;
3188 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3189 : int e HEIMDAL_UNUSED_ATTRIBUTE;
3190 :
3191 34 : memset(data, 0, sizeof(*data));
3192 : {
3193 : size_t Top_datalen, Top_oldlen;
3194 : Der_type Top_type;
3195 34 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
3196 34 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
3197 68 : if(e) goto fail;
3198 0 : p += l; len -= l; ret += l;
3199 0 : Top_oldlen = len;
3200 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3201 0 : len = Top_datalen;
3202 : {
3203 : size_t seed_datalen, seed_oldlen;
3204 : Der_type seed_type;
3205 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &seed_type, UT_BitString, &seed_datalen, &l);
3206 0 : if (e == 0 && seed_type != PRIM) { e = ASN1_BAD_ID; }
3207 0 : if(e) goto fail;
3208 0 : p += l; len -= l; ret += l;
3209 0 : seed_oldlen = len;
3210 0 : if (seed_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3211 0 : len = seed_datalen;
3212 0 : e = der_get_bit_string(p, len, &(data)->seed, &l);
3213 0 : if(e) goto fail;
3214 0 : p += l; len -= l; ret += l;
3215 0 : len = seed_oldlen - seed_datalen;
3216 : }
3217 : {
3218 : size_t pgenCounter_datalen, pgenCounter_oldlen;
3219 : Der_type pgenCounter_type;
3220 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &pgenCounter_type, UT_Integer, &pgenCounter_datalen, &l);
3221 0 : if (e == 0 && pgenCounter_type != PRIM) { e = ASN1_BAD_ID; }
3222 0 : if(e) goto fail;
3223 0 : p += l; len -= l; ret += l;
3224 0 : pgenCounter_oldlen = len;
3225 0 : if (pgenCounter_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3226 0 : len = pgenCounter_datalen;
3227 0 : e = der_get_heim_integer(p, len, &(data)->pgenCounter, &l);
3228 0 : if(e) goto fail;
3229 0 : p += l; len -= l; ret += l;
3230 0 : len = pgenCounter_oldlen - pgenCounter_datalen;
3231 : }
3232 0 : len = Top_oldlen - Top_datalen;
3233 : }
3234 0 : if(size) *size = ret;
3235 0 : return 0;
3236 34 : fail:
3237 34 : free_ValidationParms(data);
3238 34 : return e;
3239 : }
3240 :
3241 : void ASN1CALL
3242 34 : free_ValidationParms(ValidationParms *data)
3243 : {
3244 34 : der_free_bit_string(&(data)->seed);
3245 34 : der_free_heim_integer(&(data)->pgenCounter);
3246 34 : }
3247 :
3248 : size_t ASN1CALL
3249 0 : length_ValidationParms(const ValidationParms *data)
3250 : {
3251 0 : size_t ret = 0;
3252 : {
3253 0 : size_t Top_tag_oldret = ret;
3254 0 : ret = 0;
3255 0 : ret += der_length_bit_string(&(data)->seed);
3256 0 : ret += 1 + der_length_len (ret);
3257 0 : ret += Top_tag_oldret;
3258 : }
3259 : {
3260 0 : size_t Top_tag_oldret = ret;
3261 0 : ret = 0;
3262 0 : ret += der_length_heim_integer(&(data)->pgenCounter);
3263 0 : ret += 1 + der_length_len (ret);
3264 0 : ret += Top_tag_oldret;
3265 : }
3266 0 : ret += 1 + der_length_len (ret);
3267 0 : return ret;
3268 : }
3269 :
3270 : int ASN1CALL
3271 0 : copy_ValidationParms(const ValidationParms *from, ValidationParms *to)
3272 : {
3273 0 : memset(to, 0, sizeof(*to));
3274 0 : if(der_copy_bit_string(&(from)->seed, &(to)->seed)) goto fail;
3275 0 : if(der_copy_heim_integer(&(from)->pgenCounter, &(to)->pgenCounter)) goto fail;
3276 0 : return 0;
3277 0 : fail:
3278 0 : free_ValidationParms(to);
3279 0 : return ENOMEM;
3280 : }
3281 :
3282 : int ASN1CALL
3283 40 : encode_DomainParameters(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const DomainParameters *data, size_t *size)
3284 : {
3285 40 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
3286 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3287 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
3288 :
3289 : /* validationParms */
3290 40 : if((data)->validationParms) {
3291 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3292 0 : ret = 0;
3293 0 : e = encode_ValidationParms(p, len, (data)->validationParms, &l);
3294 0 : if (e) return e;
3295 0 : p -= l; len -= l; ret += l;
3296 :
3297 0 : ret += Top_tag_oldret;
3298 : }
3299 : /* j */
3300 40 : if((data)->j) {
3301 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3302 0 : ret = 0;
3303 0 : e = der_put_heim_integer(p, len, (data)->j, &l);
3304 0 : if (e) return e;
3305 0 : p -= l; len -= l; ret += l;
3306 :
3307 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
3308 0 : if (e) return e;
3309 0 : p -= l; len -= l; ret += l;
3310 :
3311 0 : ret += Top_tag_oldret;
3312 : }
3313 : /* q */
3314 40 : if((data)->q) {
3315 40 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3316 40 : ret = 0;
3317 40 : e = der_put_heim_integer(p, len, (data)->q, &l);
3318 40 : if (e) return e;
3319 40 : p -= l; len -= l; ret += l;
3320 :
3321 40 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
3322 40 : if (e) return e;
3323 40 : p -= l; len -= l; ret += l;
3324 :
3325 40 : ret += Top_tag_oldret;
3326 : }
3327 : /* g */
3328 : {
3329 40 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3330 40 : ret = 0;
3331 40 : e = der_put_heim_integer(p, len, &(data)->g, &l);
3332 40 : if (e) return e;
3333 40 : p -= l; len -= l; ret += l;
3334 :
3335 40 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
3336 40 : if (e) return e;
3337 40 : p -= l; len -= l; ret += l;
3338 :
3339 40 : ret += Top_tag_oldret;
3340 : }
3341 : /* p */
3342 : {
3343 40 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3344 40 : ret = 0;
3345 40 : e = der_put_heim_integer(p, len, &(data)->p, &l);
3346 40 : if (e) return e;
3347 40 : p -= l; len -= l; ret += l;
3348 :
3349 40 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
3350 40 : if (e) return e;
3351 40 : p -= l; len -= l; ret += l;
3352 :
3353 40 : ret += Top_tag_oldret;
3354 : }
3355 40 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
3356 40 : if (e) return e;
3357 40 : p -= l; len -= l; ret += l;
3358 :
3359 40 : *size = ret;
3360 40 : return 0;
3361 : }
3362 :
3363 : int ASN1CALL
3364 34 : decode_DomainParameters(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, DomainParameters *data, size_t *size)
3365 : {
3366 34 : size_t ret = 0;
3367 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3368 : int e HEIMDAL_UNUSED_ATTRIBUTE;
3369 :
3370 34 : memset(data, 0, sizeof(*data));
3371 : {
3372 : size_t Top_datalen, Top_oldlen;
3373 : Der_type Top_type;
3374 34 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
3375 34 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
3376 34 : if(e) goto fail;
3377 34 : p += l; len -= l; ret += l;
3378 34 : Top_oldlen = len;
3379 34 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3380 34 : len = Top_datalen;
3381 : {
3382 : size_t p_datalen, p_oldlen;
3383 : Der_type p_type;
3384 34 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &p_type, UT_Integer, &p_datalen, &l);
3385 34 : if (e == 0 && p_type != PRIM) { e = ASN1_BAD_ID; }
3386 34 : if(e) goto fail;
3387 34 : p += l; len -= l; ret += l;
3388 34 : p_oldlen = len;
3389 34 : if (p_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3390 34 : len = p_datalen;
3391 34 : e = der_get_heim_integer(p, len, &(data)->p, &l);
3392 34 : if(e) goto fail;
3393 34 : p += l; len -= l; ret += l;
3394 34 : len = p_oldlen - p_datalen;
3395 : }
3396 : {
3397 : size_t g_datalen, g_oldlen;
3398 : Der_type g_type;
3399 34 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &g_type, UT_Integer, &g_datalen, &l);
3400 68 : if (e == 0 && g_type != PRIM) { e = ASN1_BAD_ID; }
3401 34 : if(e) goto fail;
3402 34 : p += l; len -= l; ret += l;
3403 34 : g_oldlen = len;
3404 34 : if (g_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3405 34 : len = g_datalen;
3406 34 : e = der_get_heim_integer(p, len, &(data)->g, &l);
3407 34 : if(e) goto fail;
3408 34 : p += l; len -= l; ret += l;
3409 34 : len = g_oldlen - g_datalen;
3410 : }
3411 : {
3412 : size_t q_datalen, q_oldlen;
3413 : Der_type q_type;
3414 34 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &q_type, UT_Integer, &q_datalen, &l);
3415 68 : if (e == 0 && q_type != PRIM) { e = ASN1_BAD_ID; }
3416 34 : if(e) {
3417 0 : (data)->q = NULL;
3418 : } else {
3419 34 : (data)->q = calloc(1, sizeof(*(data)->q));
3420 34 : if ((data)->q == NULL) { e = ENOMEM; goto fail; }
3421 34 : p += l; len -= l; ret += l;
3422 34 : q_oldlen = len;
3423 34 : if (q_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3424 34 : len = q_datalen;
3425 34 : e = der_get_heim_integer(p, len, (data)->q, &l);
3426 34 : if(e) goto fail;
3427 34 : p += l; len -= l; ret += l;
3428 34 : len = q_oldlen - q_datalen;
3429 : }
3430 : }
3431 : {
3432 : size_t j_datalen, j_oldlen;
3433 : Der_type j_type;
3434 34 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &j_type, UT_Integer, &j_datalen, &l);
3435 34 : if (e == 0 && j_type != PRIM) { e = ASN1_BAD_ID; }
3436 34 : if(e) {
3437 34 : (data)->j = NULL;
3438 : } else {
3439 0 : (data)->j = calloc(1, sizeof(*(data)->j));
3440 0 : if ((data)->j == NULL) { e = ENOMEM; goto fail; }
3441 0 : p += l; len -= l; ret += l;
3442 0 : j_oldlen = len;
3443 0 : if (j_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3444 0 : len = j_datalen;
3445 0 : e = der_get_heim_integer(p, len, (data)->j, &l);
3446 0 : if(e) goto fail;
3447 0 : p += l; len -= l; ret += l;
3448 0 : len = j_oldlen - j_datalen;
3449 : }
3450 : }
3451 34 : (data)->validationParms = calloc(1, sizeof(*(data)->validationParms));
3452 34 : if ((data)->validationParms == NULL) goto fail;
3453 34 : e = decode_ValidationParms(p, len, (data)->validationParms, &l);
3454 34 : if(e) {
3455 34 : free((data)->validationParms);
3456 34 : (data)->validationParms = NULL;
3457 : } else {
3458 0 : p += l; len -= l; ret += l;
3459 : }
3460 34 : len = Top_oldlen - Top_datalen;
3461 : }
3462 34 : if(size) *size = ret;
3463 34 : return 0;
3464 0 : fail:
3465 0 : free_DomainParameters(data);
3466 0 : return e;
3467 : }
3468 :
3469 : void ASN1CALL
3470 74 : free_DomainParameters(DomainParameters *data)
3471 : {
3472 74 : der_free_heim_integer(&(data)->p);
3473 74 : der_free_heim_integer(&(data)->g);
3474 74 : if((data)->q) {
3475 74 : der_free_heim_integer((data)->q);
3476 74 : free((data)->q);
3477 74 : (data)->q = NULL;
3478 : }
3479 74 : if((data)->j) {
3480 0 : der_free_heim_integer((data)->j);
3481 0 : free((data)->j);
3482 0 : (data)->j = NULL;
3483 : }
3484 74 : if((data)->validationParms) {
3485 0 : free_ValidationParms((data)->validationParms);
3486 0 : free((data)->validationParms);
3487 0 : (data)->validationParms = NULL;
3488 : }
3489 74 : }
3490 :
3491 : size_t ASN1CALL
3492 40 : length_DomainParameters(const DomainParameters *data)
3493 : {
3494 40 : size_t ret = 0;
3495 : {
3496 40 : size_t Top_tag_oldret = ret;
3497 40 : ret = 0;
3498 40 : ret += der_length_heim_integer(&(data)->p);
3499 40 : ret += 1 + der_length_len (ret);
3500 40 : ret += Top_tag_oldret;
3501 : }
3502 : {
3503 40 : size_t Top_tag_oldret = ret;
3504 40 : ret = 0;
3505 40 : ret += der_length_heim_integer(&(data)->g);
3506 40 : ret += 1 + der_length_len (ret);
3507 40 : ret += Top_tag_oldret;
3508 : }
3509 40 : if((data)->q){
3510 40 : size_t Top_tag_oldret = ret;
3511 40 : ret = 0;
3512 40 : ret += der_length_heim_integer((data)->q);
3513 40 : ret += 1 + der_length_len (ret);
3514 40 : ret += Top_tag_oldret;
3515 : }
3516 40 : if((data)->j){
3517 0 : size_t Top_tag_oldret = ret;
3518 0 : ret = 0;
3519 0 : ret += der_length_heim_integer((data)->j);
3520 0 : ret += 1 + der_length_len (ret);
3521 0 : ret += Top_tag_oldret;
3522 : }
3523 40 : if((data)->validationParms){
3524 0 : size_t Top_tag_oldret = ret;
3525 0 : ret = 0;
3526 0 : ret += length_ValidationParms((data)->validationParms);
3527 0 : ret += Top_tag_oldret;
3528 : }
3529 40 : ret += 1 + der_length_len (ret);
3530 40 : return ret;
3531 : }
3532 :
3533 : int ASN1CALL
3534 0 : copy_DomainParameters(const DomainParameters *from, DomainParameters *to)
3535 : {
3536 0 : memset(to, 0, sizeof(*to));
3537 0 : if(der_copy_heim_integer(&(from)->p, &(to)->p)) goto fail;
3538 0 : if(der_copy_heim_integer(&(from)->g, &(to)->g)) goto fail;
3539 0 : if((from)->q) {
3540 0 : (to)->q = malloc(sizeof(*(to)->q));
3541 0 : if((to)->q == NULL) goto fail;
3542 0 : if(der_copy_heim_integer((from)->q, (to)->q)) goto fail;
3543 : }else
3544 0 : (to)->q = NULL;
3545 0 : if((from)->j) {
3546 0 : (to)->j = malloc(sizeof(*(to)->j));
3547 0 : if((to)->j == NULL) goto fail;
3548 0 : if(der_copy_heim_integer((from)->j, (to)->j)) goto fail;
3549 : }else
3550 0 : (to)->j = NULL;
3551 0 : if((from)->validationParms) {
3552 0 : (to)->validationParms = malloc(sizeof(*(to)->validationParms));
3553 0 : if((to)->validationParms == NULL) goto fail;
3554 0 : if(copy_ValidationParms((from)->validationParms, (to)->validationParms)) goto fail;
3555 : }else
3556 0 : (to)->validationParms = NULL;
3557 0 : return 0;
3558 0 : fail:
3559 0 : free_DomainParameters(to);
3560 0 : return ENOMEM;
3561 : }
3562 :
3563 : int ASN1CALL
3564 0 : encode_DHParameter(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const DHParameter *data, size_t *size)
3565 : {
3566 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
3567 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3568 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
3569 :
3570 : /* privateValueLength */
3571 0 : if((data)->privateValueLength) {
3572 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3573 0 : ret = 0;
3574 0 : e = der_put_heim_integer(p, len, (data)->privateValueLength, &l);
3575 0 : if (e) return e;
3576 0 : p -= l; len -= l; ret += l;
3577 :
3578 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
3579 0 : if (e) return e;
3580 0 : p -= l; len -= l; ret += l;
3581 :
3582 0 : ret += Top_tag_oldret;
3583 : }
3584 : /* base */
3585 : {
3586 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3587 0 : ret = 0;
3588 0 : e = der_put_heim_integer(p, len, &(data)->base, &l);
3589 0 : if (e) return e;
3590 0 : p -= l; len -= l; ret += l;
3591 :
3592 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
3593 0 : if (e) return e;
3594 0 : p -= l; len -= l; ret += l;
3595 :
3596 0 : ret += Top_tag_oldret;
3597 : }
3598 : /* prime */
3599 : {
3600 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3601 0 : ret = 0;
3602 0 : e = der_put_heim_integer(p, len, &(data)->prime, &l);
3603 0 : if (e) return e;
3604 0 : p -= l; len -= l; ret += l;
3605 :
3606 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
3607 0 : if (e) return e;
3608 0 : p -= l; len -= l; ret += l;
3609 :
3610 0 : ret += Top_tag_oldret;
3611 : }
3612 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
3613 0 : if (e) return e;
3614 0 : p -= l; len -= l; ret += l;
3615 :
3616 0 : *size = ret;
3617 0 : return 0;
3618 : }
3619 :
3620 : int ASN1CALL
3621 0 : decode_DHParameter(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, DHParameter *data, size_t *size)
3622 : {
3623 0 : size_t ret = 0;
3624 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3625 : int e HEIMDAL_UNUSED_ATTRIBUTE;
3626 :
3627 0 : memset(data, 0, sizeof(*data));
3628 : {
3629 : size_t Top_datalen, Top_oldlen;
3630 : Der_type Top_type;
3631 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
3632 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
3633 0 : if(e) goto fail;
3634 0 : p += l; len -= l; ret += l;
3635 0 : Top_oldlen = len;
3636 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3637 0 : len = Top_datalen;
3638 : {
3639 : size_t prime_datalen, prime_oldlen;
3640 : Der_type prime_type;
3641 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &prime_type, UT_Integer, &prime_datalen, &l);
3642 0 : if (e == 0 && prime_type != PRIM) { e = ASN1_BAD_ID; }
3643 0 : if(e) goto fail;
3644 0 : p += l; len -= l; ret += l;
3645 0 : prime_oldlen = len;
3646 0 : if (prime_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3647 0 : len = prime_datalen;
3648 0 : e = der_get_heim_integer(p, len, &(data)->prime, &l);
3649 0 : if(e) goto fail;
3650 0 : p += l; len -= l; ret += l;
3651 0 : len = prime_oldlen - prime_datalen;
3652 : }
3653 : {
3654 : size_t base_datalen, base_oldlen;
3655 : Der_type base_type;
3656 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &base_type, UT_Integer, &base_datalen, &l);
3657 0 : if (e == 0 && base_type != PRIM) { e = ASN1_BAD_ID; }
3658 0 : if(e) goto fail;
3659 0 : p += l; len -= l; ret += l;
3660 0 : base_oldlen = len;
3661 0 : if (base_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3662 0 : len = base_datalen;
3663 0 : e = der_get_heim_integer(p, len, &(data)->base, &l);
3664 0 : if(e) goto fail;
3665 0 : p += l; len -= l; ret += l;
3666 0 : len = base_oldlen - base_datalen;
3667 : }
3668 : {
3669 : size_t privateValueLength_datalen, privateValueLength_oldlen;
3670 : Der_type privateValueLength_type;
3671 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &privateValueLength_type, UT_Integer, &privateValueLength_datalen, &l);
3672 0 : if (e == 0 && privateValueLength_type != PRIM) { e = ASN1_BAD_ID; }
3673 0 : if(e) {
3674 0 : (data)->privateValueLength = NULL;
3675 : } else {
3676 0 : (data)->privateValueLength = calloc(1, sizeof(*(data)->privateValueLength));
3677 0 : if ((data)->privateValueLength == NULL) { e = ENOMEM; goto fail; }
3678 0 : p += l; len -= l; ret += l;
3679 0 : privateValueLength_oldlen = len;
3680 0 : if (privateValueLength_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3681 0 : len = privateValueLength_datalen;
3682 0 : e = der_get_heim_integer(p, len, (data)->privateValueLength, &l);
3683 0 : if(e) goto fail;
3684 0 : p += l; len -= l; ret += l;
3685 0 : len = privateValueLength_oldlen - privateValueLength_datalen;
3686 : }
3687 : }
3688 0 : len = Top_oldlen - Top_datalen;
3689 : }
3690 0 : if(size) *size = ret;
3691 0 : return 0;
3692 0 : fail:
3693 0 : free_DHParameter(data);
3694 0 : return e;
3695 : }
3696 :
3697 : void ASN1CALL
3698 0 : free_DHParameter(DHParameter *data)
3699 : {
3700 0 : der_free_heim_integer(&(data)->prime);
3701 0 : der_free_heim_integer(&(data)->base);
3702 0 : if((data)->privateValueLength) {
3703 0 : der_free_heim_integer((data)->privateValueLength);
3704 0 : free((data)->privateValueLength);
3705 0 : (data)->privateValueLength = NULL;
3706 : }
3707 0 : }
3708 :
3709 : size_t ASN1CALL
3710 0 : length_DHParameter(const DHParameter *data)
3711 : {
3712 0 : size_t ret = 0;
3713 : {
3714 0 : size_t Top_tag_oldret = ret;
3715 0 : ret = 0;
3716 0 : ret += der_length_heim_integer(&(data)->prime);
3717 0 : ret += 1 + der_length_len (ret);
3718 0 : ret += Top_tag_oldret;
3719 : }
3720 : {
3721 0 : size_t Top_tag_oldret = ret;
3722 0 : ret = 0;
3723 0 : ret += der_length_heim_integer(&(data)->base);
3724 0 : ret += 1 + der_length_len (ret);
3725 0 : ret += Top_tag_oldret;
3726 : }
3727 0 : if((data)->privateValueLength){
3728 0 : size_t Top_tag_oldret = ret;
3729 0 : ret = 0;
3730 0 : ret += der_length_heim_integer((data)->privateValueLength);
3731 0 : ret += 1 + der_length_len (ret);
3732 0 : ret += Top_tag_oldret;
3733 : }
3734 0 : ret += 1 + der_length_len (ret);
3735 0 : return ret;
3736 : }
3737 :
3738 : int ASN1CALL
3739 0 : copy_DHParameter(const DHParameter *from, DHParameter *to)
3740 : {
3741 0 : memset(to, 0, sizeof(*to));
3742 0 : if(der_copy_heim_integer(&(from)->prime, &(to)->prime)) goto fail;
3743 0 : if(der_copy_heim_integer(&(from)->base, &(to)->base)) goto fail;
3744 0 : if((from)->privateValueLength) {
3745 0 : (to)->privateValueLength = malloc(sizeof(*(to)->privateValueLength));
3746 0 : if((to)->privateValueLength == NULL) goto fail;
3747 0 : if(der_copy_heim_integer((from)->privateValueLength, (to)->privateValueLength)) goto fail;
3748 : }else
3749 0 : (to)->privateValueLength = NULL;
3750 0 : return 0;
3751 0 : fail:
3752 0 : free_DHParameter(to);
3753 0 : return ENOMEM;
3754 : }
3755 :
3756 : int ASN1CALL
3757 66 : encode_DHPublicKey(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const DHPublicKey *data, size_t *size)
3758 : {
3759 66 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
3760 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3761 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
3762 :
3763 66 : e = der_put_heim_integer(p, len, data, &l);
3764 66 : if (e) return e;
3765 66 : p -= l; len -= l; ret += l;
3766 :
3767 66 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
3768 66 : if (e) return e;
3769 66 : p -= l; len -= l; ret += l;
3770 :
3771 66 : *size = ret;
3772 66 : return 0;
3773 : }
3774 :
3775 : int ASN1CALL
3776 60 : decode_DHPublicKey(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, DHPublicKey *data, size_t *size)
3777 : {
3778 60 : size_t ret = 0;
3779 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3780 : int e HEIMDAL_UNUSED_ATTRIBUTE;
3781 :
3782 60 : memset(data, 0, sizeof(*data));
3783 : {
3784 : size_t Top_datalen, Top_oldlen;
3785 : Der_type Top_type;
3786 60 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Integer, &Top_datalen, &l);
3787 60 : if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
3788 60 : if(e) goto fail;
3789 60 : p += l; len -= l; ret += l;
3790 60 : Top_oldlen = len;
3791 60 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3792 60 : len = Top_datalen;
3793 60 : e = der_get_heim_integer(p, len, data, &l);
3794 60 : if(e) goto fail;
3795 60 : p += l; len -= l; ret += l;
3796 60 : len = Top_oldlen - Top_datalen;
3797 : }
3798 94 : if(size) *size = ret;
3799 60 : return 0;
3800 0 : fail:
3801 0 : free_DHPublicKey(data);
3802 0 : return e;
3803 : }
3804 :
3805 : void ASN1CALL
3806 26 : free_DHPublicKey(DHPublicKey *data)
3807 : {
3808 26 : der_free_heim_integer(data);
3809 26 : }
3810 :
3811 : size_t ASN1CALL
3812 66 : length_DHPublicKey(const DHPublicKey *data)
3813 : {
3814 66 : size_t ret = 0;
3815 66 : ret += der_length_heim_integer(data);
3816 66 : ret += 1 + der_length_len (ret);
3817 66 : return ret;
3818 : }
3819 :
3820 : int ASN1CALL
3821 0 : copy_DHPublicKey(const DHPublicKey *from, DHPublicKey *to)
3822 : {
3823 0 : memset(to, 0, sizeof(*to));
3824 0 : if(der_copy_heim_integer(from, to)) goto fail;
3825 0 : return 0;
3826 0 : fail:
3827 0 : free_DHPublicKey(to);
3828 0 : return ENOMEM;
3829 : }
3830 :
3831 : int ASN1CALL
3832 0 : encode_OtherName(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const OtherName *data, size_t *size)
3833 : {
3834 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
3835 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3836 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
3837 :
3838 : /* value */
3839 : {
3840 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3841 0 : ret = 0;
3842 0 : e = encode_heim_any(p, len, &(data)->value, &l);
3843 0 : if (e) return e;
3844 0 : p -= l; len -= l; ret += l;
3845 :
3846 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
3847 0 : if (e) return e;
3848 0 : p -= l; len -= l; ret += l;
3849 :
3850 0 : ret += Top_tag_oldret;
3851 : }
3852 : /* type-id */
3853 : {
3854 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3855 0 : ret = 0;
3856 0 : e = der_put_oid(p, len, &(data)->type_id, &l);
3857 0 : if (e) return e;
3858 0 : p -= l; len -= l; ret += l;
3859 :
3860 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OID, &l);
3861 0 : if (e) return e;
3862 0 : p -= l; len -= l; ret += l;
3863 :
3864 0 : ret += Top_tag_oldret;
3865 : }
3866 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
3867 0 : if (e) return e;
3868 0 : p -= l; len -= l; ret += l;
3869 :
3870 0 : *size = ret;
3871 0 : return 0;
3872 : }
3873 :
3874 : int ASN1CALL
3875 0 : decode_OtherName(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, OtherName *data, size_t *size)
3876 : {
3877 0 : size_t ret = 0;
3878 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3879 : int e HEIMDAL_UNUSED_ATTRIBUTE;
3880 :
3881 0 : memset(data, 0, sizeof(*data));
3882 : {
3883 : size_t Top_datalen, Top_oldlen;
3884 : Der_type Top_type;
3885 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
3886 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
3887 0 : if(e) goto fail;
3888 0 : p += l; len -= l; ret += l;
3889 0 : Top_oldlen = len;
3890 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3891 0 : len = Top_datalen;
3892 : {
3893 : size_t type_id_datalen, type_id_oldlen;
3894 : Der_type type_id_type;
3895 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &type_id_type, UT_OID, &type_id_datalen, &l);
3896 0 : if (e == 0 && type_id_type != PRIM) { e = ASN1_BAD_ID; }
3897 0 : if(e) goto fail;
3898 0 : p += l; len -= l; ret += l;
3899 0 : type_id_oldlen = len;
3900 0 : if (type_id_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3901 0 : len = type_id_datalen;
3902 0 : e = der_get_oid(p, len, &(data)->type_id, &l);
3903 0 : if(e) goto fail;
3904 0 : p += l; len -= l; ret += l;
3905 0 : len = type_id_oldlen - type_id_datalen;
3906 : }
3907 : {
3908 : size_t value_datalen, value_oldlen;
3909 : Der_type value_type;
3910 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &value_type, 0, &value_datalen, &l);
3911 0 : if (e == 0 && value_type != CONS) { e = ASN1_BAD_ID; }
3912 0 : if(e) goto fail;
3913 0 : p += l; len -= l; ret += l;
3914 0 : value_oldlen = len;
3915 0 : if (value_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3916 0 : len = value_datalen;
3917 0 : e = decode_heim_any(p, len, &(data)->value, &l);
3918 0 : if(e) goto fail;
3919 0 : p += l; len -= l; ret += l;
3920 0 : len = value_oldlen - value_datalen;
3921 : }
3922 0 : len = Top_oldlen - Top_datalen;
3923 : }
3924 0 : if(size) *size = ret;
3925 0 : return 0;
3926 0 : fail:
3927 0 : free_OtherName(data);
3928 0 : return e;
3929 : }
3930 :
3931 : void ASN1CALL
3932 0 : free_OtherName(OtherName *data)
3933 : {
3934 0 : der_free_oid(&(data)->type_id);
3935 0 : free_heim_any(&(data)->value);
3936 0 : }
3937 :
3938 : size_t ASN1CALL
3939 0 : length_OtherName(const OtherName *data)
3940 : {
3941 0 : size_t ret = 0;
3942 : {
3943 0 : size_t Top_tag_oldret = ret;
3944 0 : ret = 0;
3945 0 : ret += der_length_oid(&(data)->type_id);
3946 0 : ret += 1 + der_length_len (ret);
3947 0 : ret += Top_tag_oldret;
3948 : }
3949 : {
3950 0 : size_t Top_tag_oldret = ret;
3951 0 : ret = 0;
3952 0 : ret += length_heim_any(&(data)->value);
3953 0 : ret += 1 + der_length_len (ret);
3954 0 : ret += Top_tag_oldret;
3955 : }
3956 0 : ret += 1 + der_length_len (ret);
3957 0 : return ret;
3958 : }
3959 :
3960 : int ASN1CALL
3961 0 : copy_OtherName(const OtherName *from, OtherName *to)
3962 : {
3963 0 : memset(to, 0, sizeof(*to));
3964 0 : if(der_copy_oid(&(from)->type_id, &(to)->type_id)) goto fail;
3965 0 : if(copy_heim_any(&(from)->value, &(to)->value)) goto fail;
3966 0 : return 0;
3967 0 : fail:
3968 0 : free_OtherName(to);
3969 0 : return ENOMEM;
3970 : }
3971 :
3972 : int ASN1CALL
3973 0 : encode_GeneralName(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const GeneralName *data, size_t *size)
3974 : {
3975 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
3976 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3977 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
3978 :
3979 :
3980 0 : switch((data)->element) {
3981 0 : case choice_GeneralName_registeredID: {size_t Top_oldret = ret;
3982 0 : ret = 0;
3983 0 : e = der_put_oid(p, len, &((data))->u.registeredID, &l);
3984 0 : if (e) return e;
3985 0 : p -= l; len -= l; ret += l;
3986 :
3987 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, PRIM, 8, &l);
3988 0 : if (e) return e;
3989 0 : p -= l; len -= l; ret += l;
3990 :
3991 0 : ret += Top_oldret;
3992 0 : break;
3993 : }
3994 0 : case choice_GeneralName_iPAddress: {size_t Top_oldret = ret;
3995 0 : ret = 0;
3996 0 : e = der_put_octet_string(p, len, &((data))->u.iPAddress, &l);
3997 0 : if (e) return e;
3998 0 : p -= l; len -= l; ret += l;
3999 :
4000 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, PRIM, 7, &l);
4001 0 : if (e) return e;
4002 0 : p -= l; len -= l; ret += l;
4003 :
4004 0 : ret += Top_oldret;
4005 0 : break;
4006 : }
4007 0 : case choice_GeneralName_uniformResourceIdentifier: {size_t Top_oldret = ret;
4008 0 : ret = 0;
4009 0 : e = der_put_ia5_string(p, len, &((data))->u.uniformResourceIdentifier, &l);
4010 0 : if (e) return e;
4011 0 : p -= l; len -= l; ret += l;
4012 :
4013 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, PRIM, 6, &l);
4014 0 : if (e) return e;
4015 0 : p -= l; len -= l; ret += l;
4016 :
4017 0 : ret += Top_oldret;
4018 0 : break;
4019 : }
4020 0 : case choice_GeneralName_directoryName: {size_t Top_oldret = ret;
4021 0 : ret = 0;
4022 :
4023 0 : switch((&((data))->u.directoryName)->element) {
4024 0 : case choice_GeneralName_directoryName_rdnSequence: {size_t directoryName_tag_oldret = ret;
4025 0 : ret = 0;
4026 0 : e = encode_RDNSequence(p, len, &((&((data))->u.directoryName))->u.rdnSequence, &l);
4027 0 : if (e) return e;
4028 0 : p -= l; len -= l; ret += l;
4029 :
4030 0 : ret += directoryName_tag_oldret;
4031 0 : break;
4032 : }
4033 : };
4034 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 4, &l);
4035 0 : if (e) return e;
4036 0 : p -= l; len -= l; ret += l;
4037 :
4038 0 : ret += Top_oldret;
4039 0 : break;
4040 : }
4041 0 : case choice_GeneralName_dNSName: {size_t Top_oldret = ret;
4042 0 : ret = 0;
4043 0 : e = der_put_ia5_string(p, len, &((data))->u.dNSName, &l);
4044 0 : if (e) return e;
4045 0 : p -= l; len -= l; ret += l;
4046 :
4047 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, PRIM, 2, &l);
4048 0 : if (e) return e;
4049 0 : p -= l; len -= l; ret += l;
4050 :
4051 0 : ret += Top_oldret;
4052 0 : break;
4053 : }
4054 0 : case choice_GeneralName_rfc822Name: {size_t Top_oldret = ret;
4055 0 : ret = 0;
4056 0 : e = der_put_ia5_string(p, len, &((data))->u.rfc822Name, &l);
4057 0 : if (e) return e;
4058 0 : p -= l; len -= l; ret += l;
4059 :
4060 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, PRIM, 1, &l);
4061 0 : if (e) return e;
4062 0 : p -= l; len -= l; ret += l;
4063 :
4064 0 : ret += Top_oldret;
4065 0 : break;
4066 : }
4067 0 : case choice_GeneralName_otherName: {size_t Top_oldret = ret;
4068 0 : ret = 0;
4069 : /* value */
4070 : {
4071 0 : size_t otherName_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4072 0 : ret = 0;
4073 0 : e = encode_heim_any(p, len, &(&((data))->u.otherName)->value, &l);
4074 0 : if (e) return e;
4075 0 : p -= l; len -= l; ret += l;
4076 :
4077 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
4078 0 : if (e) return e;
4079 0 : p -= l; len -= l; ret += l;
4080 :
4081 0 : ret += otherName_tag_oldret;
4082 : }
4083 : /* type-id */
4084 : {
4085 0 : size_t otherName_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4086 0 : ret = 0;
4087 0 : e = der_put_oid(p, len, &(&((data))->u.otherName)->type_id, &l);
4088 0 : if (e) return e;
4089 0 : p -= l; len -= l; ret += l;
4090 :
4091 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OID, &l);
4092 0 : if (e) return e;
4093 0 : p -= l; len -= l; ret += l;
4094 :
4095 0 : ret += otherName_tag_oldret;
4096 : }
4097 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
4098 0 : if (e) return e;
4099 0 : p -= l; len -= l; ret += l;
4100 :
4101 0 : ret += Top_oldret;
4102 0 : break;
4103 : }
4104 : };
4105 0 : *size = ret;
4106 0 : return 0;
4107 : }
4108 :
4109 : int ASN1CALL
4110 176 : decode_GeneralName(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, GeneralName *data, size_t *size)
4111 : {
4112 176 : size_t ret = 0;
4113 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
4114 : int e HEIMDAL_UNUSED_ATTRIBUTE;
4115 :
4116 176 : memset(data, 0, sizeof(*data));
4117 176 : if (der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 0, NULL) == 0) {
4118 : {
4119 : size_t otherName_datalen, otherName_oldlen;
4120 : Der_type otherName_type;
4121 88 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &otherName_type, 0, &otherName_datalen, &l);
4122 88 : if (e == 0 && otherName_type != CONS) { e = ASN1_BAD_ID; }
4123 88 : if(e) goto fail;
4124 88 : p += l; len -= l; ret += l;
4125 88 : otherName_oldlen = len;
4126 88 : if (otherName_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4127 88 : len = otherName_datalen;
4128 : {
4129 : size_t type_id_datalen, type_id_oldlen;
4130 : Der_type type_id_type;
4131 88 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &type_id_type, UT_OID, &type_id_datalen, &l);
4132 88 : if (e == 0 && type_id_type != PRIM) { e = ASN1_BAD_ID; }
4133 88 : if(e) goto fail;
4134 88 : p += l; len -= l; ret += l;
4135 88 : type_id_oldlen = len;
4136 88 : if (type_id_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4137 88 : len = type_id_datalen;
4138 88 : e = der_get_oid(p, len, &(&(data)->u.otherName)->type_id, &l);
4139 88 : if(e) goto fail;
4140 88 : p += l; len -= l; ret += l;
4141 88 : len = type_id_oldlen - type_id_datalen;
4142 : }
4143 : {
4144 : size_t value_datalen, value_oldlen;
4145 : Der_type value_type;
4146 88 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &value_type, 0, &value_datalen, &l);
4147 176 : if (e == 0 && value_type != CONS) { e = ASN1_BAD_ID; }
4148 88 : if(e) goto fail;
4149 88 : p += l; len -= l; ret += l;
4150 88 : value_oldlen = len;
4151 88 : if (value_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4152 88 : len = value_datalen;
4153 88 : e = decode_heim_any(p, len, &(&(data)->u.otherName)->value, &l);
4154 88 : if(e) goto fail;
4155 88 : p += l; len -= l; ret += l;
4156 88 : len = value_oldlen - value_datalen;
4157 : }
4158 88 : len = otherName_oldlen - otherName_datalen;
4159 : }
4160 88 : (data)->element = choice_GeneralName_otherName;
4161 : }
4162 88 : else if (der_match_tag(p, len, ASN1_C_CONTEXT, PRIM, 1, NULL) == 0) {
4163 : {
4164 : size_t rfc822Name_datalen, rfc822Name_oldlen;
4165 : Der_type rfc822Name_type;
4166 88 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &rfc822Name_type, 1, &rfc822Name_datalen, &l);
4167 88 : if (e == 0 && rfc822Name_type != PRIM) { e = ASN1_BAD_ID; }
4168 88 : if(e) goto fail;
4169 88 : p += l; len -= l; ret += l;
4170 88 : rfc822Name_oldlen = len;
4171 88 : if (rfc822Name_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4172 88 : len = rfc822Name_datalen;
4173 88 : e = der_get_ia5_string(p, len, &(data)->u.rfc822Name, &l);
4174 88 : if(e) goto fail;
4175 88 : p += l; len -= l; ret += l;
4176 88 : len = rfc822Name_oldlen - rfc822Name_datalen;
4177 : }
4178 88 : (data)->element = choice_GeneralName_rfc822Name;
4179 : }
4180 0 : else if (der_match_tag(p, len, ASN1_C_CONTEXT, PRIM, 2, NULL) == 0) {
4181 : {
4182 : size_t dNSName_datalen, dNSName_oldlen;
4183 : Der_type dNSName_type;
4184 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &dNSName_type, 2, &dNSName_datalen, &l);
4185 0 : if (e == 0 && dNSName_type != PRIM) { e = ASN1_BAD_ID; }
4186 0 : if(e) goto fail;
4187 0 : p += l; len -= l; ret += l;
4188 0 : dNSName_oldlen = len;
4189 0 : if (dNSName_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4190 0 : len = dNSName_datalen;
4191 0 : e = der_get_ia5_string(p, len, &(data)->u.dNSName, &l);
4192 0 : if(e) goto fail;
4193 0 : p += l; len -= l; ret += l;
4194 0 : len = dNSName_oldlen - dNSName_datalen;
4195 : }
4196 0 : (data)->element = choice_GeneralName_dNSName;
4197 : }
4198 0 : else if (der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 4, NULL) == 0) {
4199 : {
4200 : size_t directoryName_datalen, directoryName_oldlen;
4201 : Der_type directoryName_type;
4202 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &directoryName_type, 4, &directoryName_datalen, &l);
4203 0 : if (e == 0 && directoryName_type != CONS) { e = ASN1_BAD_ID; }
4204 0 : if(e) goto fail;
4205 0 : p += l; len -= l; ret += l;
4206 0 : directoryName_oldlen = len;
4207 0 : if (directoryName_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4208 0 : len = directoryName_datalen;
4209 0 : if (der_match_tag(p, len, ASN1_C_UNIV, CONS, UT_Sequence, NULL) == 0) {
4210 0 : e = decode_RDNSequence(p, len, &(&(data)->u.directoryName)->u.rdnSequence, &l);
4211 0 : if(e) goto fail;
4212 0 : p += l; len -= l; ret += l;
4213 0 : (&(data)->u.directoryName)->element = choice_GeneralName_directoryName_rdnSequence;
4214 : }
4215 : else {
4216 0 : e = ASN1_PARSE_ERROR;
4217 0 : goto fail;
4218 : }
4219 0 : len = directoryName_oldlen - directoryName_datalen;
4220 : }
4221 0 : (data)->element = choice_GeneralName_directoryName;
4222 : }
4223 0 : else if (der_match_tag(p, len, ASN1_C_CONTEXT, PRIM, 6, NULL) == 0) {
4224 : {
4225 : size_t uniformResourceIdentifier_datalen, uniformResourceIdentifier_oldlen;
4226 : Der_type uniformResourceIdentifier_type;
4227 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &uniformResourceIdentifier_type, 6, &uniformResourceIdentifier_datalen, &l);
4228 0 : if (e == 0 && uniformResourceIdentifier_type != PRIM) { e = ASN1_BAD_ID; }
4229 0 : if(e) goto fail;
4230 0 : p += l; len -= l; ret += l;
4231 0 : uniformResourceIdentifier_oldlen = len;
4232 0 : if (uniformResourceIdentifier_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4233 0 : len = uniformResourceIdentifier_datalen;
4234 0 : e = der_get_ia5_string(p, len, &(data)->u.uniformResourceIdentifier, &l);
4235 0 : if(e) goto fail;
4236 0 : p += l; len -= l; ret += l;
4237 0 : len = uniformResourceIdentifier_oldlen - uniformResourceIdentifier_datalen;
4238 : }
4239 0 : (data)->element = choice_GeneralName_uniformResourceIdentifier;
4240 : }
4241 0 : else if (der_match_tag(p, len, ASN1_C_CONTEXT, PRIM, 7, NULL) == 0) {
4242 : {
4243 : size_t iPAddress_datalen, iPAddress_oldlen;
4244 : Der_type iPAddress_type;
4245 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &iPAddress_type, 7, &iPAddress_datalen, &l);
4246 0 : if (e == 0 && iPAddress_type != PRIM) { e = ASN1_BAD_ID; }
4247 0 : if(e) goto fail;
4248 0 : p += l; len -= l; ret += l;
4249 0 : iPAddress_oldlen = len;
4250 0 : if (iPAddress_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4251 0 : len = iPAddress_datalen;
4252 0 : e = der_get_octet_string(p, len, &(data)->u.iPAddress, &l);
4253 0 : if(e) goto fail;
4254 0 : p += l; len -= l; ret += l;
4255 0 : len = iPAddress_oldlen - iPAddress_datalen;
4256 : }
4257 0 : (data)->element = choice_GeneralName_iPAddress;
4258 : }
4259 0 : else if (der_match_tag(p, len, ASN1_C_CONTEXT, PRIM, 8, NULL) == 0) {
4260 : {
4261 : size_t registeredID_datalen, registeredID_oldlen;
4262 : Der_type registeredID_type;
4263 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, ®isteredID_type, 8, ®isteredID_datalen, &l);
4264 0 : if (e == 0 && registeredID_type != PRIM) { e = ASN1_BAD_ID; }
4265 0 : if(e) goto fail;
4266 0 : p += l; len -= l; ret += l;
4267 0 : registeredID_oldlen = len;
4268 0 : if (registeredID_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4269 0 : len = registeredID_datalen;
4270 0 : e = der_get_oid(p, len, &(data)->u.registeredID, &l);
4271 0 : if(e) goto fail;
4272 0 : p += l; len -= l; ret += l;
4273 0 : len = registeredID_oldlen - registeredID_datalen;
4274 : }
4275 0 : (data)->element = choice_GeneralName_registeredID;
4276 : }
4277 : else {
4278 0 : e = ASN1_PARSE_ERROR;
4279 0 : goto fail;
4280 : }
4281 176 : if(size) *size = ret;
4282 176 : return 0;
4283 0 : fail:
4284 0 : free_GeneralName(data);
4285 0 : return e;
4286 : }
4287 :
4288 : void ASN1CALL
4289 176 : free_GeneralName(GeneralName *data)
4290 : {
4291 176 : switch((data)->element) {
4292 88 : case choice_GeneralName_otherName:
4293 88 : der_free_oid(&(&(data)->u.otherName)->type_id);
4294 88 : free_heim_any(&(&(data)->u.otherName)->value);
4295 88 : break;
4296 88 : case choice_GeneralName_rfc822Name:
4297 88 : der_free_ia5_string(&(data)->u.rfc822Name);
4298 88 : break;
4299 0 : case choice_GeneralName_dNSName:
4300 0 : der_free_ia5_string(&(data)->u.dNSName);
4301 0 : break;
4302 0 : case choice_GeneralName_directoryName:
4303 0 : switch((&(data)->u.directoryName)->element) {
4304 0 : case choice_GeneralName_directoryName_rdnSequence:
4305 0 : free_RDNSequence(&(&(data)->u.directoryName)->u.rdnSequence);
4306 0 : break;
4307 : }
4308 0 : break;
4309 0 : case choice_GeneralName_uniformResourceIdentifier:
4310 0 : der_free_ia5_string(&(data)->u.uniformResourceIdentifier);
4311 0 : break;
4312 0 : case choice_GeneralName_iPAddress:
4313 0 : der_free_octet_string(&(data)->u.iPAddress);
4314 0 : break;
4315 0 : case choice_GeneralName_registeredID:
4316 0 : der_free_oid(&(data)->u.registeredID);
4317 0 : break;
4318 : }
4319 176 : }
4320 :
4321 : size_t ASN1CALL
4322 0 : length_GeneralName(const GeneralName *data)
4323 : {
4324 0 : size_t ret = 0;
4325 0 : switch((data)->element) {
4326 0 : case choice_GeneralName_otherName:
4327 : {
4328 0 : size_t Top_oldret = ret;
4329 0 : ret = 0;
4330 : {
4331 0 : size_t otherName_tag_oldret = ret;
4332 0 : ret = 0;
4333 0 : ret += der_length_oid(&(&(data)->u.otherName)->type_id);
4334 0 : ret += 1 + der_length_len (ret);
4335 0 : ret += otherName_tag_oldret;
4336 : }
4337 : {
4338 0 : size_t otherName_tag_oldret = ret;
4339 0 : ret = 0;
4340 0 : ret += length_heim_any(&(&(data)->u.otherName)->value);
4341 0 : ret += 1 + der_length_len (ret);
4342 0 : ret += otherName_tag_oldret;
4343 : }
4344 0 : ret += 1 + der_length_len (ret);
4345 0 : ret += Top_oldret;
4346 : }
4347 0 : break;
4348 0 : case choice_GeneralName_rfc822Name:
4349 : {
4350 0 : size_t Top_oldret = ret;
4351 0 : ret = 0;
4352 0 : ret += der_length_ia5_string(&(data)->u.rfc822Name);
4353 0 : ret += 1 + der_length_len (ret);
4354 0 : ret += Top_oldret;
4355 : }
4356 0 : break;
4357 0 : case choice_GeneralName_dNSName:
4358 : {
4359 0 : size_t Top_oldret = ret;
4360 0 : ret = 0;
4361 0 : ret += der_length_ia5_string(&(data)->u.dNSName);
4362 0 : ret += 1 + der_length_len (ret);
4363 0 : ret += Top_oldret;
4364 : }
4365 0 : break;
4366 0 : case choice_GeneralName_directoryName:
4367 : {
4368 0 : size_t Top_oldret = ret;
4369 0 : ret = 0;
4370 0 : switch((&(data)->u.directoryName)->element) {
4371 0 : case choice_GeneralName_directoryName_rdnSequence:
4372 : {
4373 0 : size_t directoryName_tag_oldret = ret;
4374 0 : ret = 0;
4375 0 : ret += length_RDNSequence(&(&(data)->u.directoryName)->u.rdnSequence);
4376 0 : ret += directoryName_tag_oldret;
4377 : }
4378 0 : break;
4379 : }
4380 0 : ret += 1 + der_length_len (ret);
4381 0 : ret += Top_oldret;
4382 : }
4383 0 : break;
4384 0 : case choice_GeneralName_uniformResourceIdentifier:
4385 : {
4386 0 : size_t Top_oldret = ret;
4387 0 : ret = 0;
4388 0 : ret += der_length_ia5_string(&(data)->u.uniformResourceIdentifier);
4389 0 : ret += 1 + der_length_len (ret);
4390 0 : ret += Top_oldret;
4391 : }
4392 0 : break;
4393 0 : case choice_GeneralName_iPAddress:
4394 : {
4395 0 : size_t Top_oldret = ret;
4396 0 : ret = 0;
4397 0 : ret += der_length_octet_string(&(data)->u.iPAddress);
4398 0 : ret += 1 + der_length_len (ret);
4399 0 : ret += Top_oldret;
4400 : }
4401 0 : break;
4402 0 : case choice_GeneralName_registeredID:
4403 : {
4404 0 : size_t Top_oldret = ret;
4405 0 : ret = 0;
4406 0 : ret += der_length_oid(&(data)->u.registeredID);
4407 0 : ret += 1 + der_length_len (ret);
4408 0 : ret += Top_oldret;
4409 : }
4410 0 : break;
4411 : }
4412 0 : return ret;
4413 : }
4414 :
4415 : int ASN1CALL
4416 0 : copy_GeneralName(const GeneralName *from, GeneralName *to)
4417 : {
4418 0 : memset(to, 0, sizeof(*to));
4419 0 : (to)->element = (from)->element;
4420 0 : switch((from)->element) {
4421 0 : case choice_GeneralName_otherName:
4422 0 : if(der_copy_oid(&(&(from)->u.otherName)->type_id, &(&(to)->u.otherName)->type_id)) goto fail;
4423 0 : if(copy_heim_any(&(&(from)->u.otherName)->value, &(&(to)->u.otherName)->value)) goto fail;
4424 0 : break;
4425 0 : case choice_GeneralName_rfc822Name:
4426 0 : if(der_copy_ia5_string(&(from)->u.rfc822Name, &(to)->u.rfc822Name)) goto fail;
4427 0 : break;
4428 0 : case choice_GeneralName_dNSName:
4429 0 : if(der_copy_ia5_string(&(from)->u.dNSName, &(to)->u.dNSName)) goto fail;
4430 0 : break;
4431 0 : case choice_GeneralName_directoryName:
4432 0 : (&(to)->u.directoryName)->element = (&(from)->u.directoryName)->element;
4433 0 : switch((&(from)->u.directoryName)->element) {
4434 0 : case choice_GeneralName_directoryName_rdnSequence:
4435 0 : if(copy_RDNSequence(&(&(from)->u.directoryName)->u.rdnSequence, &(&(to)->u.directoryName)->u.rdnSequence)) goto fail;
4436 0 : break;
4437 : }
4438 0 : break;
4439 0 : case choice_GeneralName_uniformResourceIdentifier:
4440 0 : if(der_copy_ia5_string(&(from)->u.uniformResourceIdentifier, &(to)->u.uniformResourceIdentifier)) goto fail;
4441 0 : break;
4442 0 : case choice_GeneralName_iPAddress:
4443 0 : if(der_copy_octet_string(&(from)->u.iPAddress, &(to)->u.iPAddress)) goto fail;
4444 0 : break;
4445 0 : case choice_GeneralName_registeredID:
4446 0 : if(der_copy_oid(&(from)->u.registeredID, &(to)->u.registeredID)) goto fail;
4447 0 : break;
4448 : }
4449 0 : return 0;
4450 0 : fail:
4451 0 : free_GeneralName(to);
4452 0 : return ENOMEM;
4453 : }
4454 :
4455 : int ASN1CALL
4456 0 : encode_GeneralNames(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const GeneralNames *data, size_t *size)
4457 : {
4458 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
4459 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
4460 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
4461 :
4462 0 : for(i = (int)(data)->len - 1; i >= 0; --i) {
4463 0 : size_t Top_tag_for_oldret = ret;
4464 0 : ret = 0;
4465 0 : e = encode_GeneralName(p, len, &(data)->val[i], &l);
4466 0 : if (e) return e;
4467 0 : p -= l; len -= l; ret += l;
4468 :
4469 0 : ret += Top_tag_for_oldret;
4470 : }
4471 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
4472 0 : if (e) return e;
4473 0 : p -= l; len -= l; ret += l;
4474 :
4475 0 : *size = ret;
4476 0 : return 0;
4477 : }
4478 :
4479 : int ASN1CALL
4480 88 : decode_GeneralNames(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, GeneralNames *data, size_t *size)
4481 : {
4482 88 : size_t ret = 0;
4483 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
4484 : int e HEIMDAL_UNUSED_ATTRIBUTE;
4485 :
4486 88 : memset(data, 0, sizeof(*data));
4487 : {
4488 : size_t Top_datalen, Top_oldlen;
4489 : Der_type Top_type;
4490 88 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
4491 88 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
4492 88 : if(e) goto fail;
4493 88 : p += l; len -= l; ret += l;
4494 88 : Top_oldlen = len;
4495 88 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4496 88 : len = Top_datalen;
4497 : {
4498 88 : size_t Top_Tag_origlen = len;
4499 88 : size_t Top_Tag_oldret = ret;
4500 88 : size_t Top_Tag_olen = 0;
4501 : void *Top_Tag_tmp;
4502 88 : ret = 0;
4503 88 : (data)->len = 0;
4504 88 : (data)->val = NULL;
4505 352 : while(ret < Top_Tag_origlen) {
4506 176 : size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
4507 176 : if (Top_Tag_olen > Top_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
4508 176 : Top_Tag_olen = Top_Tag_nlen;
4509 176 : Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
4510 176 : if (Top_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
4511 176 : (data)->val = Top_Tag_tmp;
4512 176 : e = decode_GeneralName(p, len, &(data)->val[(data)->len], &l);
4513 176 : if(e) goto fail;
4514 176 : p += l; len -= l; ret += l;
4515 176 : (data)->len++;
4516 176 : len = Top_Tag_origlen - ret;
4517 : }
4518 88 : ret += Top_Tag_oldret;
4519 : }
4520 88 : if ((data)->len < 1) {
4521 0 : e = ASN1_MIN_CONSTRAINT; goto fail;
4522 : }
4523 88 : len = Top_oldlen - Top_datalen;
4524 : }
4525 176 : if(size) *size = ret;
4526 88 : return 0;
4527 0 : fail:
4528 0 : free_GeneralNames(data);
4529 0 : return e;
4530 : }
4531 :
4532 : void ASN1CALL
4533 88 : free_GeneralNames(GeneralNames *data)
4534 : {
4535 352 : while((data)->len){
4536 176 : free_GeneralName(&(data)->val[(data)->len-1]);
4537 176 : (data)->len--;
4538 : }
4539 88 : free((data)->val);
4540 88 : (data)->val = NULL;
4541 88 : }
4542 :
4543 : size_t ASN1CALL
4544 0 : length_GeneralNames(const GeneralNames *data)
4545 : {
4546 0 : size_t ret = 0;
4547 : {
4548 0 : size_t Top_tag_oldret = ret;
4549 : int i;
4550 0 : ret = 0;
4551 0 : for(i = (data)->len - 1; i >= 0; --i){
4552 0 : size_t Top_tag_for_oldret = ret;
4553 0 : ret = 0;
4554 0 : ret += length_GeneralName(&(data)->val[i]);
4555 0 : ret += Top_tag_for_oldret;
4556 : }
4557 0 : ret += Top_tag_oldret;
4558 : }
4559 0 : ret += 1 + der_length_len (ret);
4560 0 : return ret;
4561 : }
4562 :
4563 : int ASN1CALL
4564 0 : copy_GeneralNames(const GeneralNames *from, GeneralNames *to)
4565 : {
4566 0 : memset(to, 0, sizeof(*to));
4567 0 : if(((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
4568 0 : goto fail;
4569 0 : for((to)->len = 0; (to)->len < (from)->len; (to)->len++){
4570 0 : if(copy_GeneralName(&(from)->val[(to)->len], &(to)->val[(to)->len])) goto fail;
4571 : }
4572 0 : return 0;
4573 0 : fail:
4574 0 : free_GeneralNames(to);
4575 0 : return ENOMEM;
4576 : }
4577 :
4578 : int ASN1CALL
4579 0 : add_GeneralNames(GeneralNames *data, const GeneralName *element)
4580 : {
4581 : int ret;
4582 : void *ptr;
4583 :
4584 0 : ptr = realloc(data->val,
4585 0 : (data->len + 1) * sizeof(data->val[0]));
4586 0 : if (ptr == NULL) return ENOMEM;
4587 0 : data->val = ptr;
4588 :
4589 0 : ret = copy_GeneralName(element, &data->val[data->len]);
4590 0 : if (ret) return ret;
4591 0 : data->len++;
4592 0 : return 0;
4593 : }
4594 :
4595 : int ASN1CALL
4596 0 : remove_GeneralNames(GeneralNames *data, unsigned int element)
4597 : {
4598 : void *ptr;
4599 :
4600 0 : if (data->len == 0 || element >= data->len)
4601 0 : return ASN1_OVERRUN;
4602 0 : free_GeneralName(&data->val[element]);
4603 0 : data->len--;
4604 0 : if (element < data->len)
4605 0 : memmove(&data->val[element], &data->val[element + 1],
4606 0 : sizeof(data->val[0]) * data->len);
4607 0 : ptr = realloc(data->val, data->len * sizeof(data->val[0]));
4608 0 : if (ptr != NULL || data->len == 0) data->val = ptr;
4609 0 : return 0;
4610 : }
4611 :
4612 : static unsigned oid_id_x509_ce_keyUsage_variable_num[4] = {2, 5, 29, 15 };
4613 : const heim_oid asn1_oid_id_x509_ce_keyUsage = { 4, oid_id_x509_ce_keyUsage_variable_num };
4614 :
4615 : int ASN1CALL
4616 0 : encode_KeyUsage(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const KeyUsage *data, size_t *size)
4617 : {
4618 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
4619 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
4620 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
4621 :
4622 : {
4623 0 : unsigned char c = 0;
4624 0 : int rest = 0;
4625 0 : int bit_set = 0;
4626 0 : if((data)->decipherOnly) {
4627 0 : c |= 1<<7;
4628 : }
4629 0 : if (c != 0 || bit_set) {
4630 0 : if (len < 1) return ASN1_OVERFLOW;
4631 0 : *p-- = c; len--; ret++;
4632 0 : if (!bit_set) {
4633 0 : rest = 0;
4634 0 : while(c) {
4635 0 : if (c & 1) break;
4636 0 : c = c >> 1;
4637 0 : rest++;
4638 : }
4639 0 : bit_set = 1;
4640 : }
4641 : }
4642 0 : c = 0;
4643 0 : if((data)->encipherOnly) {
4644 0 : c |= 1<<0;
4645 : }
4646 0 : if((data)->cRLSign) {
4647 0 : c |= 1<<1;
4648 : }
4649 0 : if((data)->keyCertSign) {
4650 0 : c |= 1<<2;
4651 : }
4652 0 : if((data)->keyAgreement) {
4653 0 : c |= 1<<3;
4654 : }
4655 0 : if((data)->dataEncipherment) {
4656 0 : c |= 1<<4;
4657 : }
4658 0 : if((data)->keyEncipherment) {
4659 0 : c |= 1<<5;
4660 : }
4661 0 : if((data)->nonRepudiation) {
4662 0 : c |= 1<<6;
4663 : }
4664 0 : if((data)->digitalSignature) {
4665 0 : c |= 1<<7;
4666 : }
4667 0 : if (c != 0 || bit_set) {
4668 0 : if (len < 1) return ASN1_OVERFLOW;
4669 0 : *p-- = c; len--; ret++;
4670 0 : if (!bit_set) {
4671 0 : rest = 0;
4672 0 : if(c) {
4673 0 : while(c) {
4674 0 : if (c & 1) break;
4675 0 : c = c >> 1;
4676 0 : rest++;
4677 : }
4678 : }
4679 : }
4680 : }
4681 0 : if (len < 1) return ASN1_OVERFLOW;
4682 0 : *p-- = rest;
4683 0 : len -= 1;
4684 0 : ret += 1;
4685 : }
4686 :
4687 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_BitString, &l);
4688 0 : if (e) return e;
4689 0 : p -= l; len -= l; ret += l;
4690 :
4691 0 : *size = ret;
4692 0 : return 0;
4693 : }
4694 :
4695 : int ASN1CALL
4696 210 : decode_KeyUsage(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, KeyUsage *data, size_t *size)
4697 : {
4698 210 : size_t ret = 0;
4699 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
4700 : int e HEIMDAL_UNUSED_ATTRIBUTE;
4701 :
4702 210 : memset(data, 0, sizeof(*data));
4703 : {
4704 : size_t Top_datalen, Top_oldlen;
4705 : Der_type Top_type;
4706 210 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_BitString, &Top_datalen, &l);
4707 210 : if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
4708 210 : if(e) goto fail;
4709 210 : p += l; len -= l; ret += l;
4710 210 : Top_oldlen = len;
4711 210 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4712 210 : len = Top_datalen;
4713 210 : if (len < 1) return ASN1_OVERRUN;
4714 210 : p++; len--; ret++;
4715 : do {
4716 210 : if (len < 1) break;
4717 210 : (data)->digitalSignature = (*p >> 7) & 1;
4718 210 : (data)->nonRepudiation = (*p >> 6) & 1;
4719 210 : (data)->keyEncipherment = (*p >> 5) & 1;
4720 210 : (data)->dataEncipherment = (*p >> 4) & 1;
4721 210 : (data)->keyAgreement = (*p >> 3) & 1;
4722 210 : (data)->keyCertSign = (*p >> 2) & 1;
4723 210 : (data)->cRLSign = (*p >> 1) & 1;
4724 210 : (data)->encipherOnly = (*p >> 0) & 1;
4725 210 : p++; len--; ret++;
4726 210 : if (len < 1) break;
4727 0 : (data)->decipherOnly = (*p >> 7) & 1;
4728 : } while(0);
4729 210 : p += len; ret += len;
4730 210 : len = Top_oldlen - Top_datalen;
4731 : }
4732 420 : if(size) *size = ret;
4733 210 : return 0;
4734 0 : fail:
4735 0 : free_KeyUsage(data);
4736 0 : return e;
4737 : }
4738 :
4739 : void ASN1CALL
4740 0 : free_KeyUsage(KeyUsage *data)
4741 : {
4742 0 : }
4743 :
4744 : size_t ASN1CALL
4745 0 : length_KeyUsage(const KeyUsage *data)
4746 : {
4747 0 : size_t ret = 0;
4748 : do {
4749 0 : if((data)->decipherOnly) { ret += 2; break; }
4750 0 : if((data)->encipherOnly) { ret += 1; break; }
4751 0 : if((data)->cRLSign) { ret += 1; break; }
4752 0 : if((data)->keyCertSign) { ret += 1; break; }
4753 0 : if((data)->keyAgreement) { ret += 1; break; }
4754 0 : if((data)->dataEncipherment) { ret += 1; break; }
4755 0 : if((data)->keyEncipherment) { ret += 1; break; }
4756 0 : if((data)->nonRepudiation) { ret += 1; break; }
4757 0 : if((data)->digitalSignature) { ret += 1; break; }
4758 : } while(0);
4759 0 : ret += 1;
4760 0 : ret += 1 + der_length_len (ret);
4761 0 : return ret;
4762 : }
4763 :
4764 : int ASN1CALL
4765 0 : copy_KeyUsage(const KeyUsage *from, KeyUsage *to)
4766 : {
4767 0 : memset(to, 0, sizeof(*to));
4768 0 : *(to) = *(from);
4769 0 : return 0;
4770 : }
4771 :
4772 210 : unsigned KeyUsage2int(KeyUsage f)
4773 : {
4774 210 : unsigned r = 0;
4775 210 : if(f.digitalSignature) r |= (1U << 0);
4776 210 : if(f.nonRepudiation) r |= (1U << 1);
4777 210 : if(f.keyEncipherment) r |= (1U << 2);
4778 210 : if(f.dataEncipherment) r |= (1U << 3);
4779 210 : if(f.keyAgreement) r |= (1U << 4);
4780 210 : if(f.keyCertSign) r |= (1U << 5);
4781 210 : if(f.cRLSign) r |= (1U << 6);
4782 210 : if(f.encipherOnly) r |= (1U << 7);
4783 210 : if(f.decipherOnly) r |= (1U << 8);
4784 210 : return r;
4785 : }
4786 :
4787 0 : KeyUsage int2KeyUsage(unsigned n)
4788 : {
4789 : KeyUsage flags;
4790 :
4791 0 : memset(&flags, 0, sizeof(flags));
4792 :
4793 0 : flags.digitalSignature = (n >> 0) & 1;
4794 0 : flags.nonRepudiation = (n >> 1) & 1;
4795 0 : flags.keyEncipherment = (n >> 2) & 1;
4796 0 : flags.dataEncipherment = (n >> 3) & 1;
4797 0 : flags.keyAgreement = (n >> 4) & 1;
4798 0 : flags.keyCertSign = (n >> 5) & 1;
4799 0 : flags.cRLSign = (n >> 6) & 1;
4800 0 : flags.encipherOnly = (n >> 7) & 1;
4801 0 : flags.decipherOnly = (n >> 8) & 1;
4802 0 : return flags;
4803 : }
4804 :
4805 : static struct units KeyUsage_units[] = {
4806 : {"decipherOnly", 1U << 8},
4807 : {"encipherOnly", 1U << 7},
4808 : {"cRLSign", 1U << 6},
4809 : {"keyCertSign", 1U << 5},
4810 : {"keyAgreement", 1U << 4},
4811 : {"dataEncipherment", 1U << 3},
4812 : {"keyEncipherment", 1U << 2},
4813 : {"nonRepudiation", 1U << 1},
4814 : {"digitalSignature", 1U << 0},
4815 : {NULL, 0}
4816 : };
4817 :
4818 0 : const struct units * asn1_KeyUsage_units(void){
4819 0 : return KeyUsage_units;
4820 : }
4821 :
4822 : static unsigned oid_id_x509_ce_authorityKeyIdentifier_variable_num[4] = {2, 5, 29, 35 };
4823 : const heim_oid asn1_oid_id_x509_ce_authorityKeyIdentifier = { 4, oid_id_x509_ce_authorityKeyIdentifier_variable_num };
4824 :
4825 : int ASN1CALL
4826 66 : encode_KeyIdentifier(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const KeyIdentifier *data, size_t *size)
4827 : {
4828 66 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
4829 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
4830 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
4831 :
4832 66 : e = der_put_octet_string(p, len, data, &l);
4833 66 : if (e) return e;
4834 66 : p -= l; len -= l; ret += l;
4835 :
4836 66 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
4837 66 : if (e) return e;
4838 66 : p -= l; len -= l; ret += l;
4839 :
4840 66 : *size = ret;
4841 66 : return 0;
4842 : }
4843 :
4844 : int ASN1CALL
4845 246 : decode_KeyIdentifier(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, KeyIdentifier *data, size_t *size)
4846 : {
4847 246 : size_t ret = 0;
4848 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
4849 : int e HEIMDAL_UNUSED_ATTRIBUTE;
4850 :
4851 246 : memset(data, 0, sizeof(*data));
4852 : {
4853 : size_t Top_datalen, Top_oldlen;
4854 : Der_type Top_type;
4855 246 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_OctetString, &Top_datalen, &l);
4856 246 : if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
4857 246 : if(e) goto fail;
4858 246 : p += l; len -= l; ret += l;
4859 246 : Top_oldlen = len;
4860 246 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4861 246 : len = Top_datalen;
4862 246 : e = der_get_octet_string(p, len, data, &l);
4863 246 : if(e) goto fail;
4864 246 : p += l; len -= l; ret += l;
4865 246 : len = Top_oldlen - Top_datalen;
4866 : }
4867 492 : if(size) *size = ret;
4868 246 : return 0;
4869 0 : fail:
4870 0 : free_KeyIdentifier(data);
4871 0 : return e;
4872 : }
4873 :
4874 : void ASN1CALL
4875 246 : free_KeyIdentifier(KeyIdentifier *data)
4876 : {
4877 246 : der_free_octet_string(data);
4878 246 : }
4879 :
4880 : size_t ASN1CALL
4881 132 : length_KeyIdentifier(const KeyIdentifier *data)
4882 : {
4883 132 : size_t ret = 0;
4884 132 : ret += der_length_octet_string(data);
4885 132 : ret += 1 + der_length_len (ret);
4886 132 : return ret;
4887 : }
4888 :
4889 : int ASN1CALL
4890 0 : copy_KeyIdentifier(const KeyIdentifier *from, KeyIdentifier *to)
4891 : {
4892 0 : memset(to, 0, sizeof(*to));
4893 0 : if(der_copy_octet_string(from, to)) goto fail;
4894 0 : return 0;
4895 0 : fail:
4896 0 : free_KeyIdentifier(to);
4897 0 : return ENOMEM;
4898 : }
4899 :
4900 : int ASN1CALL
4901 0 : encode_AuthorityKeyIdentifier(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const AuthorityKeyIdentifier *data, size_t *size)
4902 : {
4903 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
4904 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
4905 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
4906 :
4907 : /* authorityCertSerialNumber */
4908 0 : if((data)->authorityCertSerialNumber) {
4909 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4910 0 : ret = 0;
4911 0 : e = der_put_heim_integer(p, len, (data)->authorityCertSerialNumber, &l);
4912 0 : if (e) return e;
4913 0 : p -= l; len -= l; ret += l;
4914 :
4915 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, PRIM, 2, &l);
4916 0 : if (e) return e;
4917 0 : p -= l; len -= l; ret += l;
4918 :
4919 0 : ret += Top_tag_oldret;
4920 : }
4921 : /* authorityCertIssuer */
4922 0 : if((data)->authorityCertIssuer) {
4923 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4924 0 : ret = 0;
4925 0 : for(i = (int)((data)->authorityCertIssuer)->len - 1; i >= 0; --i) {
4926 0 : size_t authorityCertIssuer_tag_for_oldret = ret;
4927 0 : ret = 0;
4928 0 : e = encode_GeneralName(p, len, &((data)->authorityCertIssuer)->val[i], &l);
4929 0 : if (e) return e;
4930 0 : p -= l; len -= l; ret += l;
4931 :
4932 0 : ret += authorityCertIssuer_tag_for_oldret;
4933 : }
4934 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
4935 0 : if (e) return e;
4936 0 : p -= l; len -= l; ret += l;
4937 :
4938 0 : ret += Top_tag_oldret;
4939 : }
4940 : /* keyIdentifier */
4941 0 : if((data)->keyIdentifier) {
4942 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4943 0 : ret = 0;
4944 0 : e = der_put_octet_string(p, len, (data)->keyIdentifier, &l);
4945 0 : if (e) return e;
4946 0 : p -= l; len -= l; ret += l;
4947 :
4948 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, PRIM, 0, &l);
4949 0 : if (e) return e;
4950 0 : p -= l; len -= l; ret += l;
4951 :
4952 0 : ret += Top_tag_oldret;
4953 : }
4954 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
4955 0 : if (e) return e;
4956 0 : p -= l; len -= l; ret += l;
4957 :
4958 0 : *size = ret;
4959 0 : return 0;
4960 : }
4961 :
4962 : int ASN1CALL
4963 60 : decode_AuthorityKeyIdentifier(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, AuthorityKeyIdentifier *data, size_t *size)
4964 : {
4965 60 : size_t ret = 0;
4966 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
4967 : int e HEIMDAL_UNUSED_ATTRIBUTE;
4968 :
4969 60 : memset(data, 0, sizeof(*data));
4970 : {
4971 : size_t Top_datalen, Top_oldlen;
4972 : Der_type Top_type;
4973 60 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
4974 60 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
4975 60 : if(e) goto fail;
4976 60 : p += l; len -= l; ret += l;
4977 60 : Top_oldlen = len;
4978 60 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4979 60 : len = Top_datalen;
4980 : {
4981 : size_t keyIdentifier_datalen, keyIdentifier_oldlen;
4982 : Der_type keyIdentifier_type;
4983 60 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &keyIdentifier_type, 0, &keyIdentifier_datalen, &l);
4984 60 : if (e == 0 && keyIdentifier_type != PRIM) { e = ASN1_BAD_ID; }
4985 60 : if(e) {
4986 0 : (data)->keyIdentifier = NULL;
4987 : } else {
4988 60 : (data)->keyIdentifier = calloc(1, sizeof(*(data)->keyIdentifier));
4989 60 : if ((data)->keyIdentifier == NULL) { e = ENOMEM; goto fail; }
4990 60 : p += l; len -= l; ret += l;
4991 60 : keyIdentifier_oldlen = len;
4992 60 : if (keyIdentifier_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4993 60 : len = keyIdentifier_datalen;
4994 60 : e = der_get_octet_string(p, len, (data)->keyIdentifier, &l);
4995 60 : if(e) goto fail;
4996 60 : p += l; len -= l; ret += l;
4997 60 : len = keyIdentifier_oldlen - keyIdentifier_datalen;
4998 : }
4999 : }
5000 : {
5001 : size_t authorityCertIssuer_datalen, authorityCertIssuer_oldlen;
5002 : Der_type authorityCertIssuer_type;
5003 60 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &authorityCertIssuer_type, 1, &authorityCertIssuer_datalen, &l);
5004 60 : if (e == 0 && authorityCertIssuer_type != CONS) { e = ASN1_BAD_ID; }
5005 60 : if(e) {
5006 60 : (data)->authorityCertIssuer = NULL;
5007 : } else {
5008 0 : (data)->authorityCertIssuer = calloc(1, sizeof(*(data)->authorityCertIssuer));
5009 0 : if ((data)->authorityCertIssuer == NULL) { e = ENOMEM; goto fail; }
5010 0 : p += l; len -= l; ret += l;
5011 0 : authorityCertIssuer_oldlen = len;
5012 0 : if (authorityCertIssuer_datalen > len) { e = ASN1_OVERRUN; goto fail; }
5013 0 : len = authorityCertIssuer_datalen;
5014 : {
5015 0 : size_t authorityCertIssuer_Tag_origlen = len;
5016 0 : size_t authorityCertIssuer_Tag_oldret = ret;
5017 0 : size_t authorityCertIssuer_Tag_olen = 0;
5018 : void *authorityCertIssuer_Tag_tmp;
5019 0 : ret = 0;
5020 0 : ((data)->authorityCertIssuer)->len = 0;
5021 0 : ((data)->authorityCertIssuer)->val = NULL;
5022 0 : while(ret < authorityCertIssuer_Tag_origlen) {
5023 0 : size_t authorityCertIssuer_Tag_nlen = authorityCertIssuer_Tag_olen + sizeof(*(((data)->authorityCertIssuer)->val));
5024 0 : if (authorityCertIssuer_Tag_olen > authorityCertIssuer_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
5025 0 : authorityCertIssuer_Tag_olen = authorityCertIssuer_Tag_nlen;
5026 0 : authorityCertIssuer_Tag_tmp = realloc(((data)->authorityCertIssuer)->val, authorityCertIssuer_Tag_olen);
5027 0 : if (authorityCertIssuer_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
5028 0 : ((data)->authorityCertIssuer)->val = authorityCertIssuer_Tag_tmp;
5029 0 : e = decode_GeneralName(p, len, &((data)->authorityCertIssuer)->val[((data)->authorityCertIssuer)->len], &l);
5030 0 : if(e) goto fail;
5031 0 : p += l; len -= l; ret += l;
5032 0 : ((data)->authorityCertIssuer)->len++;
5033 0 : len = authorityCertIssuer_Tag_origlen - ret;
5034 : }
5035 0 : ret += authorityCertIssuer_Tag_oldret;
5036 : }
5037 0 : len = authorityCertIssuer_oldlen - authorityCertIssuer_datalen;
5038 : }
5039 : }
5040 : {
5041 : size_t authorityCertSerialNumber_datalen, authorityCertSerialNumber_oldlen;
5042 : Der_type authorityCertSerialNumber_type;
5043 60 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &authorityCertSerialNumber_type, 2, &authorityCertSerialNumber_datalen, &l);
5044 60 : if (e == 0 && authorityCertSerialNumber_type != PRIM) { e = ASN1_BAD_ID; }
5045 60 : if(e) {
5046 60 : (data)->authorityCertSerialNumber = NULL;
5047 : } else {
5048 0 : (data)->authorityCertSerialNumber = calloc(1, sizeof(*(data)->authorityCertSerialNumber));
5049 0 : if ((data)->authorityCertSerialNumber == NULL) { e = ENOMEM; goto fail; }
5050 0 : p += l; len -= l; ret += l;
5051 0 : authorityCertSerialNumber_oldlen = len;
5052 0 : if (authorityCertSerialNumber_datalen > len) { e = ASN1_OVERRUN; goto fail; }
5053 0 : len = authorityCertSerialNumber_datalen;
5054 0 : e = der_get_heim_integer(p, len, (data)->authorityCertSerialNumber, &l);
5055 0 : if(e) goto fail;
5056 0 : p += l; len -= l; ret += l;
5057 0 : len = authorityCertSerialNumber_oldlen - authorityCertSerialNumber_datalen;
5058 : }
5059 : }
5060 60 : len = Top_oldlen - Top_datalen;
5061 : }
5062 120 : if(size) *size = ret;
5063 60 : return 0;
5064 0 : fail:
5065 0 : free_AuthorityKeyIdentifier(data);
5066 0 : return e;
5067 : }
5068 :
5069 : void ASN1CALL
5070 186 : free_AuthorityKeyIdentifier(AuthorityKeyIdentifier *data)
5071 : {
5072 186 : if((data)->keyIdentifier) {
5073 60 : der_free_octet_string((data)->keyIdentifier);
5074 60 : free((data)->keyIdentifier);
5075 60 : (data)->keyIdentifier = NULL;
5076 : }
5077 186 : if((data)->authorityCertIssuer) {
5078 0 : while(((data)->authorityCertIssuer)->len){
5079 0 : free_GeneralName(&((data)->authorityCertIssuer)->val[((data)->authorityCertIssuer)->len-1]);
5080 0 : ((data)->authorityCertIssuer)->len--;
5081 : }
5082 0 : free(((data)->authorityCertIssuer)->val);
5083 0 : ((data)->authorityCertIssuer)->val = NULL;
5084 0 : free((data)->authorityCertIssuer);
5085 0 : (data)->authorityCertIssuer = NULL;
5086 : }
5087 186 : if((data)->authorityCertSerialNumber) {
5088 0 : der_free_heim_integer((data)->authorityCertSerialNumber);
5089 0 : free((data)->authorityCertSerialNumber);
5090 0 : (data)->authorityCertSerialNumber = NULL;
5091 : }
5092 186 : }
5093 :
5094 : size_t ASN1CALL
5095 0 : length_AuthorityKeyIdentifier(const AuthorityKeyIdentifier *data)
5096 : {
5097 0 : size_t ret = 0;
5098 0 : if((data)->keyIdentifier){
5099 0 : size_t Top_tag_oldret = ret;
5100 0 : ret = 0;
5101 0 : ret += der_length_octet_string((data)->keyIdentifier);
5102 0 : ret += 1 + der_length_len (ret);
5103 0 : ret += Top_tag_oldret;
5104 : }
5105 0 : if((data)->authorityCertIssuer){
5106 0 : size_t Top_tag_oldret = ret;
5107 0 : ret = 0;
5108 : {
5109 0 : size_t authorityCertIssuer_tag_oldret = ret;
5110 : int i;
5111 0 : ret = 0;
5112 0 : for(i = ((data)->authorityCertIssuer)->len - 1; i >= 0; --i){
5113 0 : size_t authorityCertIssuer_tag_for_oldret = ret;
5114 0 : ret = 0;
5115 0 : ret += length_GeneralName(&((data)->authorityCertIssuer)->val[i]);
5116 0 : ret += authorityCertIssuer_tag_for_oldret;
5117 : }
5118 0 : ret += authorityCertIssuer_tag_oldret;
5119 : }
5120 0 : ret += 1 + der_length_len (ret);
5121 0 : ret += Top_tag_oldret;
5122 : }
5123 0 : if((data)->authorityCertSerialNumber){
5124 0 : size_t Top_tag_oldret = ret;
5125 0 : ret = 0;
5126 0 : ret += der_length_heim_integer((data)->authorityCertSerialNumber);
5127 0 : ret += 1 + der_length_len (ret);
5128 0 : ret += Top_tag_oldret;
5129 : }
5130 0 : ret += 1 + der_length_len (ret);
5131 0 : return ret;
5132 : }
5133 :
5134 : int ASN1CALL
5135 0 : copy_AuthorityKeyIdentifier(const AuthorityKeyIdentifier *from, AuthorityKeyIdentifier *to)
5136 : {
5137 0 : memset(to, 0, sizeof(*to));
5138 0 : if((from)->keyIdentifier) {
5139 0 : (to)->keyIdentifier = malloc(sizeof(*(to)->keyIdentifier));
5140 0 : if((to)->keyIdentifier == NULL) goto fail;
5141 0 : if(der_copy_octet_string((from)->keyIdentifier, (to)->keyIdentifier)) goto fail;
5142 : }else
5143 0 : (to)->keyIdentifier = NULL;
5144 0 : if((from)->authorityCertIssuer) {
5145 0 : (to)->authorityCertIssuer = malloc(sizeof(*(to)->authorityCertIssuer));
5146 0 : if((to)->authorityCertIssuer == NULL) goto fail;
5147 0 : if((((to)->authorityCertIssuer)->val = malloc(((from)->authorityCertIssuer)->len * sizeof(*((to)->authorityCertIssuer)->val))) == NULL && ((from)->authorityCertIssuer)->len != 0)
5148 0 : goto fail;
5149 0 : for(((to)->authorityCertIssuer)->len = 0; ((to)->authorityCertIssuer)->len < ((from)->authorityCertIssuer)->len; ((to)->authorityCertIssuer)->len++){
5150 0 : if(copy_GeneralName(&((from)->authorityCertIssuer)->val[((to)->authorityCertIssuer)->len], &((to)->authorityCertIssuer)->val[((to)->authorityCertIssuer)->len])) goto fail;
5151 : }
5152 : }else
5153 0 : (to)->authorityCertIssuer = NULL;
5154 0 : if((from)->authorityCertSerialNumber) {
5155 0 : (to)->authorityCertSerialNumber = malloc(sizeof(*(to)->authorityCertSerialNumber));
5156 0 : if((to)->authorityCertSerialNumber == NULL) goto fail;
5157 0 : if(der_copy_heim_integer((from)->authorityCertSerialNumber, (to)->authorityCertSerialNumber)) goto fail;
5158 : }else
5159 0 : (to)->authorityCertSerialNumber = NULL;
5160 0 : return 0;
5161 0 : fail:
5162 0 : free_AuthorityKeyIdentifier(to);
5163 0 : return ENOMEM;
5164 : }
5165 :
5166 : static unsigned oid_id_x509_ce_subjectKeyIdentifier_variable_num[4] = {2, 5, 29, 14 };
5167 : const heim_oid asn1_oid_id_x509_ce_subjectKeyIdentifier = { 4, oid_id_x509_ce_subjectKeyIdentifier_variable_num };
5168 :
5169 : int ASN1CALL
5170 66 : encode_SubjectKeyIdentifier(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const SubjectKeyIdentifier *data, size_t *size)
5171 : {
5172 66 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
5173 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
5174 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
5175 :
5176 66 : e = encode_KeyIdentifier(p, len, data, &l);
5177 66 : if (e) return e;
5178 66 : p -= l; len -= l; ret += l;
5179 :
5180 66 : *size = ret;
5181 66 : return 0;
5182 : }
5183 :
5184 : int ASN1CALL
5185 246 : decode_SubjectKeyIdentifier(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, SubjectKeyIdentifier *data, size_t *size)
5186 : {
5187 246 : size_t ret = 0;
5188 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
5189 : int e HEIMDAL_UNUSED_ATTRIBUTE;
5190 :
5191 246 : memset(data, 0, sizeof(*data));
5192 246 : e = decode_KeyIdentifier(p, len, data, &l);
5193 246 : if(e) goto fail;
5194 246 : p += l; len -= l; ret += l;
5195 246 : if(size) *size = ret;
5196 246 : return 0;
5197 0 : fail:
5198 0 : free_SubjectKeyIdentifier(data);
5199 0 : return e;
5200 : }
5201 :
5202 : void ASN1CALL
5203 246 : free_SubjectKeyIdentifier(SubjectKeyIdentifier *data)
5204 : {
5205 246 : free_KeyIdentifier(data);
5206 246 : }
5207 :
5208 : size_t ASN1CALL
5209 132 : length_SubjectKeyIdentifier(const SubjectKeyIdentifier *data)
5210 : {
5211 132 : size_t ret = 0;
5212 132 : ret += length_KeyIdentifier(data);
5213 132 : return ret;
5214 : }
5215 :
5216 : int ASN1CALL
5217 0 : copy_SubjectKeyIdentifier(const SubjectKeyIdentifier *from, SubjectKeyIdentifier *to)
5218 : {
5219 0 : memset(to, 0, sizeof(*to));
5220 0 : if(copy_KeyIdentifier(from, to)) goto fail;
5221 0 : return 0;
5222 0 : fail:
5223 0 : free_SubjectKeyIdentifier(to);
5224 0 : return ENOMEM;
5225 : }
5226 :
5227 : static unsigned oid_id_x509_ce_basicConstraints_variable_num[4] = {2, 5, 29, 19 };
5228 : const heim_oid asn1_oid_id_x509_ce_basicConstraints = { 4, oid_id_x509_ce_basicConstraints_variable_num };
5229 :
5230 : int ASN1CALL
5231 0 : encode_BasicConstraints(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const BasicConstraints *data, size_t *size)
5232 : {
5233 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
5234 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
5235 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
5236 :
5237 : /* pathLenConstraint */
5238 0 : if((data)->pathLenConstraint) {
5239 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
5240 0 : ret = 0;
5241 0 : e = der_put_unsigned(p, len, (data)->pathLenConstraint, &l);
5242 0 : if (e) return e;
5243 0 : p -= l; len -= l; ret += l;
5244 :
5245 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
5246 0 : if (e) return e;
5247 0 : p -= l; len -= l; ret += l;
5248 :
5249 0 : ret += Top_tag_oldret;
5250 : }
5251 : /* cA */
5252 0 : if((data)->cA) {
5253 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
5254 0 : ret = 0;
5255 0 : e = der_put_boolean(p, len, (data)->cA, &l);
5256 0 : if (e) return e;
5257 0 : p -= l; len -= l; ret += l;
5258 :
5259 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Boolean, &l);
5260 0 : if (e) return e;
5261 0 : p -= l; len -= l; ret += l;
5262 :
5263 0 : ret += Top_tag_oldret;
5264 : }
5265 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
5266 0 : if (e) return e;
5267 0 : p -= l; len -= l; ret += l;
5268 :
5269 0 : *size = ret;
5270 0 : return 0;
5271 : }
5272 :
5273 : int ASN1CALL
5274 120 : decode_BasicConstraints(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, BasicConstraints *data, size_t *size)
5275 : {
5276 120 : size_t ret = 0;
5277 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
5278 : int e HEIMDAL_UNUSED_ATTRIBUTE;
5279 :
5280 120 : memset(data, 0, sizeof(*data));
5281 : {
5282 : size_t Top_datalen, Top_oldlen;
5283 : Der_type Top_type;
5284 120 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
5285 120 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
5286 120 : if(e) goto fail;
5287 120 : p += l; len -= l; ret += l;
5288 120 : Top_oldlen = len;
5289 120 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
5290 120 : len = Top_datalen;
5291 : {
5292 : size_t cA_datalen, cA_oldlen;
5293 : Der_type cA_type;
5294 120 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &cA_type, UT_Boolean, &cA_datalen, &l);
5295 120 : if (e == 0 && cA_type != PRIM) { e = ASN1_BAD_ID; }
5296 120 : if(e) {
5297 60 : (data)->cA = NULL;
5298 : } else {
5299 60 : (data)->cA = calloc(1, sizeof(*(data)->cA));
5300 60 : if ((data)->cA == NULL) { e = ENOMEM; goto fail; }
5301 60 : p += l; len -= l; ret += l;
5302 60 : cA_oldlen = len;
5303 60 : if (cA_datalen > len) { e = ASN1_OVERRUN; goto fail; }
5304 60 : len = cA_datalen;
5305 60 : e = der_get_boolean(p, len, (data)->cA, &l);
5306 60 : if(e) goto fail;
5307 60 : p += l; len -= l; ret += l;
5308 60 : len = cA_oldlen - cA_datalen;
5309 : }
5310 : }
5311 : {
5312 : size_t pathLenConstraint_datalen, pathLenConstraint_oldlen;
5313 : Der_type pathLenConstraint_type;
5314 120 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &pathLenConstraint_type, UT_Integer, &pathLenConstraint_datalen, &l);
5315 120 : if (e == 0 && pathLenConstraint_type != PRIM) { e = ASN1_BAD_ID; }
5316 120 : if(e) {
5317 120 : (data)->pathLenConstraint = NULL;
5318 : } else {
5319 0 : (data)->pathLenConstraint = calloc(1, sizeof(*(data)->pathLenConstraint));
5320 0 : if ((data)->pathLenConstraint == NULL) { e = ENOMEM; goto fail; }
5321 0 : p += l; len -= l; ret += l;
5322 0 : pathLenConstraint_oldlen = len;
5323 0 : if (pathLenConstraint_datalen > len) { e = ASN1_OVERRUN; goto fail; }
5324 0 : len = pathLenConstraint_datalen;
5325 0 : e = der_get_unsigned(p, len, (data)->pathLenConstraint, &l);
5326 0 : if(e) goto fail;
5327 0 : p += l; len -= l; ret += l;
5328 0 : len = pathLenConstraint_oldlen - pathLenConstraint_datalen;
5329 : }
5330 : }
5331 120 : len = Top_oldlen - Top_datalen;
5332 : }
5333 240 : if(size) *size = ret;
5334 120 : return 0;
5335 0 : fail:
5336 0 : free_BasicConstraints(data);
5337 0 : return e;
5338 : }
5339 :
5340 : void ASN1CALL
5341 120 : free_BasicConstraints(BasicConstraints *data)
5342 : {
5343 120 : if((data)->cA) {
5344 60 : free((data)->cA);
5345 60 : (data)->cA = NULL;
5346 : }
5347 120 : if((data)->pathLenConstraint) {
5348 0 : free((data)->pathLenConstraint);
5349 0 : (data)->pathLenConstraint = NULL;
5350 : }
5351 120 : }
5352 :
5353 : size_t ASN1CALL
5354 0 : length_BasicConstraints(const BasicConstraints *data)
5355 : {
5356 0 : size_t ret = 0;
5357 0 : if((data)->cA){
5358 0 : size_t Top_tag_oldret = ret;
5359 0 : ret = 0;
5360 0 : ret += 1;
5361 0 : ret += 1 + der_length_len (ret);
5362 0 : ret += Top_tag_oldret;
5363 : }
5364 0 : if((data)->pathLenConstraint){
5365 0 : size_t Top_tag_oldret = ret;
5366 0 : ret = 0;
5367 0 : ret += der_length_unsigned((data)->pathLenConstraint);
5368 0 : ret += 1 + der_length_len (ret);
5369 0 : ret += Top_tag_oldret;
5370 : }
5371 0 : ret += 1 + der_length_len (ret);
5372 0 : return ret;
5373 : }
5374 :
5375 : int ASN1CALL
5376 0 : copy_BasicConstraints(const BasicConstraints *from, BasicConstraints *to)
5377 : {
5378 0 : memset(to, 0, sizeof(*to));
5379 0 : if((from)->cA) {
5380 0 : (to)->cA = malloc(sizeof(*(to)->cA));
5381 0 : if((to)->cA == NULL) goto fail;
5382 0 : *((to)->cA) = *((from)->cA);
5383 : }else
5384 0 : (to)->cA = NULL;
5385 0 : if((from)->pathLenConstraint) {
5386 0 : (to)->pathLenConstraint = malloc(sizeof(*(to)->pathLenConstraint));
5387 0 : if((to)->pathLenConstraint == NULL) goto fail;
5388 0 : *((to)->pathLenConstraint) = *((from)->pathLenConstraint);
5389 : }else
5390 0 : (to)->pathLenConstraint = NULL;
5391 0 : return 0;
5392 0 : fail:
5393 0 : free_BasicConstraints(to);
5394 0 : return ENOMEM;
5395 : }
5396 :
5397 : static unsigned oid_id_x509_ce_nameConstraints_variable_num[4] = {2, 5, 29, 30 };
5398 : const heim_oid asn1_oid_id_x509_ce_nameConstraints = { 4, oid_id_x509_ce_nameConstraints_variable_num };
5399 :
5400 : int ASN1CALL
5401 0 : encode_BaseDistance(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const BaseDistance *data, size_t *size)
5402 : {
5403 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
5404 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
5405 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
5406 :
5407 0 : e = der_put_heim_integer(p, len, data, &l);
5408 0 : if (e) return e;
5409 0 : p -= l; len -= l; ret += l;
5410 :
5411 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
5412 0 : if (e) return e;
5413 0 : p -= l; len -= l; ret += l;
5414 :
5415 0 : *size = ret;
5416 0 : return 0;
5417 : }
5418 :
5419 : int ASN1CALL
5420 0 : decode_BaseDistance(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, BaseDistance *data, size_t *size)
5421 : {
5422 0 : size_t ret = 0;
5423 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
5424 : int e HEIMDAL_UNUSED_ATTRIBUTE;
5425 :
5426 0 : memset(data, 0, sizeof(*data));
5427 : {
5428 : size_t Top_datalen, Top_oldlen;
5429 : Der_type Top_type;
5430 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Integer, &Top_datalen, &l);
5431 0 : if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
5432 0 : if(e) goto fail;
5433 0 : p += l; len -= l; ret += l;
5434 0 : Top_oldlen = len;
5435 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
5436 0 : len = Top_datalen;
5437 0 : e = der_get_heim_integer(p, len, data, &l);
5438 0 : if(e) goto fail;
5439 0 : p += l; len -= l; ret += l;
5440 0 : len = Top_oldlen - Top_datalen;
5441 : }
5442 0 : if(size) *size = ret;
5443 0 : return 0;
5444 0 : fail:
5445 0 : free_BaseDistance(data);
5446 0 : return e;
5447 : }
5448 :
5449 : void ASN1CALL
5450 0 : free_BaseDistance(BaseDistance *data)
5451 : {
5452 0 : der_free_heim_integer(data);
5453 0 : }
5454 :
5455 : size_t ASN1CALL
5456 0 : length_BaseDistance(const BaseDistance *data)
5457 : {
5458 0 : size_t ret = 0;
5459 0 : ret += der_length_heim_integer(data);
5460 0 : ret += 1 + der_length_len (ret);
5461 0 : return ret;
5462 : }
5463 :
5464 : int ASN1CALL
5465 0 : copy_BaseDistance(const BaseDistance *from, BaseDistance *to)
5466 : {
5467 0 : memset(to, 0, sizeof(*to));
5468 0 : if(der_copy_heim_integer(from, to)) goto fail;
5469 0 : return 0;
5470 0 : fail:
5471 0 : free_BaseDistance(to);
5472 0 : return ENOMEM;
5473 : }
5474 :
5475 : int ASN1CALL
5476 0 : encode_GeneralSubtree(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const GeneralSubtree *data, size_t *size)
5477 : {
5478 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
5479 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
5480 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
5481 :
5482 : /* maximum */
5483 0 : if((data)->maximum) {
5484 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
5485 0 : ret = 0;
5486 0 : e = der_put_heim_integer(p, len, (data)->maximum, &l);
5487 0 : if (e) return e;
5488 0 : p -= l; len -= l; ret += l;
5489 :
5490 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, PRIM, 1, &l);
5491 0 : if (e) return e;
5492 0 : p -= l; len -= l; ret += l;
5493 :
5494 0 : ret += Top_tag_oldret;
5495 : }
5496 : /* minimum */
5497 0 : if((data)->minimum) {
5498 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
5499 0 : ret = 0;
5500 0 : e = der_put_heim_integer(p, len, (data)->minimum, &l);
5501 0 : if (e) return e;
5502 0 : p -= l; len -= l; ret += l;
5503 :
5504 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, PRIM, 0, &l);
5505 0 : if (e) return e;
5506 0 : p -= l; len -= l; ret += l;
5507 :
5508 0 : ret += Top_tag_oldret;
5509 : }
5510 : /* base */
5511 : {
5512 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
5513 0 : ret = 0;
5514 0 : e = encode_GeneralName(p, len, &(data)->base, &l);
5515 0 : if (e) return e;
5516 0 : p -= l; len -= l; ret += l;
5517 :
5518 0 : ret += Top_tag_oldret;
5519 : }
5520 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
5521 0 : if (e) return e;
5522 0 : p -= l; len -= l; ret += l;
5523 :
5524 0 : *size = ret;
5525 0 : return 0;
5526 : }
5527 :
5528 : int ASN1CALL
5529 0 : decode_GeneralSubtree(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, GeneralSubtree *data, size_t *size)
5530 : {
5531 0 : size_t ret = 0;
5532 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
5533 : int e HEIMDAL_UNUSED_ATTRIBUTE;
5534 :
5535 0 : memset(data, 0, sizeof(*data));
5536 : {
5537 : size_t Top_datalen, Top_oldlen;
5538 : Der_type Top_type;
5539 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
5540 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
5541 0 : if(e) goto fail;
5542 0 : p += l; len -= l; ret += l;
5543 0 : Top_oldlen = len;
5544 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
5545 0 : len = Top_datalen;
5546 0 : e = decode_GeneralName(p, len, &(data)->base, &l);
5547 0 : if(e) goto fail;
5548 0 : p += l; len -= l; ret += l;
5549 : {
5550 : size_t minimum_datalen, minimum_oldlen;
5551 : Der_type minimum_type;
5552 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &minimum_type, 0, &minimum_datalen, &l);
5553 0 : if (e == 0 && minimum_type != PRIM) { e = ASN1_BAD_ID; }
5554 0 : if(e) {
5555 0 : (data)->minimum = NULL;
5556 : } else {
5557 0 : (data)->minimum = calloc(1, sizeof(*(data)->minimum));
5558 0 : if ((data)->minimum == NULL) { e = ENOMEM; goto fail; }
5559 0 : p += l; len -= l; ret += l;
5560 0 : minimum_oldlen = len;
5561 0 : if (minimum_datalen > len) { e = ASN1_OVERRUN; goto fail; }
5562 0 : len = minimum_datalen;
5563 0 : e = der_get_heim_integer(p, len, (data)->minimum, &l);
5564 0 : if(e) goto fail;
5565 0 : p += l; len -= l; ret += l;
5566 0 : len = minimum_oldlen - minimum_datalen;
5567 : }
5568 : }
5569 : {
5570 : size_t maximum_datalen, maximum_oldlen;
5571 : Der_type maximum_type;
5572 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &maximum_type, 1, &maximum_datalen, &l);
5573 0 : if (e == 0 && maximum_type != PRIM) { e = ASN1_BAD_ID; }
5574 0 : if(e) {
5575 0 : (data)->maximum = NULL;
5576 : } else {
5577 0 : (data)->maximum = calloc(1, sizeof(*(data)->maximum));
5578 0 : if ((data)->maximum == NULL) { e = ENOMEM; goto fail; }
5579 0 : p += l; len -= l; ret += l;
5580 0 : maximum_oldlen = len;
5581 0 : if (maximum_datalen > len) { e = ASN1_OVERRUN; goto fail; }
5582 0 : len = maximum_datalen;
5583 0 : e = der_get_heim_integer(p, len, (data)->maximum, &l);
5584 0 : if(e) goto fail;
5585 0 : p += l; len -= l; ret += l;
5586 0 : len = maximum_oldlen - maximum_datalen;
5587 : }
5588 : }
5589 0 : len = Top_oldlen - Top_datalen;
5590 : }
5591 0 : if(size) *size = ret;
5592 0 : return 0;
5593 0 : fail:
5594 0 : free_GeneralSubtree(data);
5595 0 : return e;
5596 : }
5597 :
5598 : void ASN1CALL
5599 0 : free_GeneralSubtree(GeneralSubtree *data)
5600 : {
5601 0 : free_GeneralName(&(data)->base);
5602 0 : if((data)->minimum) {
5603 0 : der_free_heim_integer((data)->minimum);
5604 0 : free((data)->minimum);
5605 0 : (data)->minimum = NULL;
5606 : }
5607 0 : if((data)->maximum) {
5608 0 : der_free_heim_integer((data)->maximum);
5609 0 : free((data)->maximum);
5610 0 : (data)->maximum = NULL;
5611 : }
5612 0 : }
5613 :
5614 : size_t ASN1CALL
5615 0 : length_GeneralSubtree(const GeneralSubtree *data)
5616 : {
5617 0 : size_t ret = 0;
5618 : {
5619 0 : size_t Top_tag_oldret = ret;
5620 0 : ret = 0;
5621 0 : ret += length_GeneralName(&(data)->base);
5622 0 : ret += Top_tag_oldret;
5623 : }
5624 0 : if((data)->minimum){
5625 0 : size_t Top_tag_oldret = ret;
5626 0 : ret = 0;
5627 0 : ret += der_length_heim_integer((data)->minimum);
5628 0 : ret += 1 + der_length_len (ret);
5629 0 : ret += Top_tag_oldret;
5630 : }
5631 0 : if((data)->maximum){
5632 0 : size_t Top_tag_oldret = ret;
5633 0 : ret = 0;
5634 0 : ret += der_length_heim_integer((data)->maximum);
5635 0 : ret += 1 + der_length_len (ret);
5636 0 : ret += Top_tag_oldret;
5637 : }
5638 0 : ret += 1 + der_length_len (ret);
5639 0 : return ret;
5640 : }
5641 :
5642 : int ASN1CALL
5643 0 : copy_GeneralSubtree(const GeneralSubtree *from, GeneralSubtree *to)
5644 : {
5645 0 : memset(to, 0, sizeof(*to));
5646 0 : if(copy_GeneralName(&(from)->base, &(to)->base)) goto fail;
5647 0 : if((from)->minimum) {
5648 0 : (to)->minimum = malloc(sizeof(*(to)->minimum));
5649 0 : if((to)->minimum == NULL) goto fail;
5650 0 : if(der_copy_heim_integer((from)->minimum, (to)->minimum)) goto fail;
5651 : }else
5652 0 : (to)->minimum = NULL;
5653 0 : if((from)->maximum) {
5654 0 : (to)->maximum = malloc(sizeof(*(to)->maximum));
5655 0 : if((to)->maximum == NULL) goto fail;
5656 0 : if(der_copy_heim_integer((from)->maximum, (to)->maximum)) goto fail;
5657 : }else
5658 0 : (to)->maximum = NULL;
5659 0 : return 0;
5660 0 : fail:
5661 0 : free_GeneralSubtree(to);
5662 0 : return ENOMEM;
5663 : }
5664 :
5665 : int ASN1CALL
5666 0 : encode_GeneralSubtrees(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const GeneralSubtrees *data, size_t *size)
5667 : {
5668 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
5669 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
5670 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
5671 :
5672 0 : for(i = (int)(data)->len - 1; i >= 0; --i) {
5673 0 : size_t Top_tag_for_oldret = ret;
5674 0 : ret = 0;
5675 0 : e = encode_GeneralSubtree(p, len, &(data)->val[i], &l);
5676 0 : if (e) return e;
5677 0 : p -= l; len -= l; ret += l;
5678 :
5679 0 : ret += Top_tag_for_oldret;
5680 : }
5681 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
5682 0 : if (e) return e;
5683 0 : p -= l; len -= l; ret += l;
5684 :
5685 0 : *size = ret;
5686 0 : return 0;
5687 : }
5688 :
5689 : int ASN1CALL
5690 0 : decode_GeneralSubtrees(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, GeneralSubtrees *data, size_t *size)
5691 : {
5692 0 : size_t ret = 0;
5693 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
5694 : int e HEIMDAL_UNUSED_ATTRIBUTE;
5695 :
5696 0 : memset(data, 0, sizeof(*data));
5697 : {
5698 : size_t Top_datalen, Top_oldlen;
5699 : Der_type Top_type;
5700 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
5701 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
5702 0 : if(e) goto fail;
5703 0 : p += l; len -= l; ret += l;
5704 0 : Top_oldlen = len;
5705 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
5706 0 : len = Top_datalen;
5707 : {
5708 0 : size_t Top_Tag_origlen = len;
5709 0 : size_t Top_Tag_oldret = ret;
5710 0 : size_t Top_Tag_olen = 0;
5711 : void *Top_Tag_tmp;
5712 0 : ret = 0;
5713 0 : (data)->len = 0;
5714 0 : (data)->val = NULL;
5715 0 : while(ret < Top_Tag_origlen) {
5716 0 : size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
5717 0 : if (Top_Tag_olen > Top_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
5718 0 : Top_Tag_olen = Top_Tag_nlen;
5719 0 : Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
5720 0 : if (Top_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
5721 0 : (data)->val = Top_Tag_tmp;
5722 0 : e = decode_GeneralSubtree(p, len, &(data)->val[(data)->len], &l);
5723 0 : if(e) goto fail;
5724 0 : p += l; len -= l; ret += l;
5725 0 : (data)->len++;
5726 0 : len = Top_Tag_origlen - ret;
5727 : }
5728 0 : ret += Top_Tag_oldret;
5729 : }
5730 0 : len = Top_oldlen - Top_datalen;
5731 : }
5732 0 : if(size) *size = ret;
5733 0 : return 0;
5734 0 : fail:
5735 0 : free_GeneralSubtrees(data);
5736 0 : return e;
5737 : }
5738 :
5739 : void ASN1CALL
5740 0 : free_GeneralSubtrees(GeneralSubtrees *data)
5741 : {
5742 0 : while((data)->len){
5743 0 : free_GeneralSubtree(&(data)->val[(data)->len-1]);
5744 0 : (data)->len--;
5745 : }
5746 0 : free((data)->val);
5747 0 : (data)->val = NULL;
5748 0 : }
5749 :
5750 : size_t ASN1CALL
5751 0 : length_GeneralSubtrees(const GeneralSubtrees *data)
5752 : {
5753 0 : size_t ret = 0;
5754 : {
5755 0 : size_t Top_tag_oldret = ret;
5756 : int i;
5757 0 : ret = 0;
5758 0 : for(i = (data)->len - 1; i >= 0; --i){
5759 0 : size_t Top_tag_for_oldret = ret;
5760 0 : ret = 0;
5761 0 : ret += length_GeneralSubtree(&(data)->val[i]);
5762 0 : ret += Top_tag_for_oldret;
5763 : }
5764 0 : ret += Top_tag_oldret;
5765 : }
5766 0 : ret += 1 + der_length_len (ret);
5767 0 : return ret;
5768 : }
5769 :
5770 : int ASN1CALL
5771 0 : copy_GeneralSubtrees(const GeneralSubtrees *from, GeneralSubtrees *to)
5772 : {
5773 0 : memset(to, 0, sizeof(*to));
5774 0 : if(((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
5775 0 : goto fail;
5776 0 : for((to)->len = 0; (to)->len < (from)->len; (to)->len++){
5777 0 : if(copy_GeneralSubtree(&(from)->val[(to)->len], &(to)->val[(to)->len])) goto fail;
5778 : }
5779 0 : return 0;
5780 0 : fail:
5781 0 : free_GeneralSubtrees(to);
5782 0 : return ENOMEM;
5783 : }
5784 :
5785 : int ASN1CALL
5786 0 : encode_NameConstraints(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const NameConstraints *data, size_t *size)
5787 : {
5788 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
5789 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
5790 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
5791 :
5792 : /* excludedSubtrees */
5793 0 : if((data)->excludedSubtrees) {
5794 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
5795 0 : ret = 0;
5796 0 : for(i = (int)((data)->excludedSubtrees)->len - 1; i >= 0; --i) {
5797 0 : size_t excludedSubtrees_tag_for_oldret = ret;
5798 0 : ret = 0;
5799 0 : e = encode_GeneralSubtree(p, len, &((data)->excludedSubtrees)->val[i], &l);
5800 0 : if (e) return e;
5801 0 : p -= l; len -= l; ret += l;
5802 :
5803 0 : ret += excludedSubtrees_tag_for_oldret;
5804 : }
5805 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
5806 0 : if (e) return e;
5807 0 : p -= l; len -= l; ret += l;
5808 :
5809 0 : ret += Top_tag_oldret;
5810 : }
5811 : /* permittedSubtrees */
5812 0 : if((data)->permittedSubtrees) {
5813 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
5814 0 : ret = 0;
5815 0 : for(i = (int)((data)->permittedSubtrees)->len - 1; i >= 0; --i) {
5816 0 : size_t permittedSubtrees_tag_for_oldret = ret;
5817 0 : ret = 0;
5818 0 : e = encode_GeneralSubtree(p, len, &((data)->permittedSubtrees)->val[i], &l);
5819 0 : if (e) return e;
5820 0 : p -= l; len -= l; ret += l;
5821 :
5822 0 : ret += permittedSubtrees_tag_for_oldret;
5823 : }
5824 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
5825 0 : if (e) return e;
5826 0 : p -= l; len -= l; ret += l;
5827 :
5828 0 : ret += Top_tag_oldret;
5829 : }
5830 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
5831 0 : if (e) return e;
5832 0 : p -= l; len -= l; ret += l;
5833 :
5834 0 : *size = ret;
5835 0 : return 0;
5836 : }
5837 :
5838 : int ASN1CALL
5839 0 : decode_NameConstraints(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, NameConstraints *data, size_t *size)
5840 : {
5841 0 : size_t ret = 0;
5842 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
5843 : int e HEIMDAL_UNUSED_ATTRIBUTE;
5844 :
5845 0 : memset(data, 0, sizeof(*data));
5846 : {
5847 : size_t Top_datalen, Top_oldlen;
5848 : Der_type Top_type;
5849 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
5850 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
5851 0 : if(e) goto fail;
5852 0 : p += l; len -= l; ret += l;
5853 0 : Top_oldlen = len;
5854 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
5855 0 : len = Top_datalen;
5856 : {
5857 : size_t permittedSubtrees_datalen, permittedSubtrees_oldlen;
5858 : Der_type permittedSubtrees_type;
5859 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &permittedSubtrees_type, 0, &permittedSubtrees_datalen, &l);
5860 0 : if (e == 0 && permittedSubtrees_type != CONS) { e = ASN1_BAD_ID; }
5861 0 : if(e) {
5862 0 : (data)->permittedSubtrees = NULL;
5863 : } else {
5864 0 : (data)->permittedSubtrees = calloc(1, sizeof(*(data)->permittedSubtrees));
5865 0 : if ((data)->permittedSubtrees == NULL) { e = ENOMEM; goto fail; }
5866 0 : p += l; len -= l; ret += l;
5867 0 : permittedSubtrees_oldlen = len;
5868 0 : if (permittedSubtrees_datalen > len) { e = ASN1_OVERRUN; goto fail; }
5869 0 : len = permittedSubtrees_datalen;
5870 : {
5871 0 : size_t permittedSubtrees_Tag_origlen = len;
5872 0 : size_t permittedSubtrees_Tag_oldret = ret;
5873 0 : size_t permittedSubtrees_Tag_olen = 0;
5874 : void *permittedSubtrees_Tag_tmp;
5875 0 : ret = 0;
5876 0 : ((data)->permittedSubtrees)->len = 0;
5877 0 : ((data)->permittedSubtrees)->val = NULL;
5878 0 : while(ret < permittedSubtrees_Tag_origlen) {
5879 0 : size_t permittedSubtrees_Tag_nlen = permittedSubtrees_Tag_olen + sizeof(*(((data)->permittedSubtrees)->val));
5880 0 : if (permittedSubtrees_Tag_olen > permittedSubtrees_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
5881 0 : permittedSubtrees_Tag_olen = permittedSubtrees_Tag_nlen;
5882 0 : permittedSubtrees_Tag_tmp = realloc(((data)->permittedSubtrees)->val, permittedSubtrees_Tag_olen);
5883 0 : if (permittedSubtrees_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
5884 0 : ((data)->permittedSubtrees)->val = permittedSubtrees_Tag_tmp;
5885 0 : e = decode_GeneralSubtree(p, len, &((data)->permittedSubtrees)->val[((data)->permittedSubtrees)->len], &l);
5886 0 : if(e) goto fail;
5887 0 : p += l; len -= l; ret += l;
5888 0 : ((data)->permittedSubtrees)->len++;
5889 0 : len = permittedSubtrees_Tag_origlen - ret;
5890 : }
5891 0 : ret += permittedSubtrees_Tag_oldret;
5892 : }
5893 0 : len = permittedSubtrees_oldlen - permittedSubtrees_datalen;
5894 : }
5895 : }
5896 : {
5897 : size_t excludedSubtrees_datalen, excludedSubtrees_oldlen;
5898 : Der_type excludedSubtrees_type;
5899 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &excludedSubtrees_type, 1, &excludedSubtrees_datalen, &l);
5900 0 : if (e == 0 && excludedSubtrees_type != CONS) { e = ASN1_BAD_ID; }
5901 0 : if(e) {
5902 0 : (data)->excludedSubtrees = NULL;
5903 : } else {
5904 0 : (data)->excludedSubtrees = calloc(1, sizeof(*(data)->excludedSubtrees));
5905 0 : if ((data)->excludedSubtrees == NULL) { e = ENOMEM; goto fail; }
5906 0 : p += l; len -= l; ret += l;
5907 0 : excludedSubtrees_oldlen = len;
5908 0 : if (excludedSubtrees_datalen > len) { e = ASN1_OVERRUN; goto fail; }
5909 0 : len = excludedSubtrees_datalen;
5910 : {
5911 0 : size_t excludedSubtrees_Tag_origlen = len;
5912 0 : size_t excludedSubtrees_Tag_oldret = ret;
5913 0 : size_t excludedSubtrees_Tag_olen = 0;
5914 : void *excludedSubtrees_Tag_tmp;
5915 0 : ret = 0;
5916 0 : ((data)->excludedSubtrees)->len = 0;
5917 0 : ((data)->excludedSubtrees)->val = NULL;
5918 0 : while(ret < excludedSubtrees_Tag_origlen) {
5919 0 : size_t excludedSubtrees_Tag_nlen = excludedSubtrees_Tag_olen + sizeof(*(((data)->excludedSubtrees)->val));
5920 0 : if (excludedSubtrees_Tag_olen > excludedSubtrees_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
5921 0 : excludedSubtrees_Tag_olen = excludedSubtrees_Tag_nlen;
5922 0 : excludedSubtrees_Tag_tmp = realloc(((data)->excludedSubtrees)->val, excludedSubtrees_Tag_olen);
5923 0 : if (excludedSubtrees_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
5924 0 : ((data)->excludedSubtrees)->val = excludedSubtrees_Tag_tmp;
5925 0 : e = decode_GeneralSubtree(p, len, &((data)->excludedSubtrees)->val[((data)->excludedSubtrees)->len], &l);
5926 0 : if(e) goto fail;
5927 0 : p += l; len -= l; ret += l;
5928 0 : ((data)->excludedSubtrees)->len++;
5929 0 : len = excludedSubtrees_Tag_origlen - ret;
5930 : }
5931 0 : ret += excludedSubtrees_Tag_oldret;
5932 : }
5933 0 : len = excludedSubtrees_oldlen - excludedSubtrees_datalen;
5934 : }
5935 : }
5936 0 : len = Top_oldlen - Top_datalen;
5937 : }
5938 0 : if(size) *size = ret;
5939 0 : return 0;
5940 0 : fail:
5941 0 : free_NameConstraints(data);
5942 0 : return e;
5943 : }
5944 :
5945 : void ASN1CALL
5946 0 : free_NameConstraints(NameConstraints *data)
5947 : {
5948 0 : if((data)->permittedSubtrees) {
5949 0 : while(((data)->permittedSubtrees)->len){
5950 0 : free_GeneralSubtree(&((data)->permittedSubtrees)->val[((data)->permittedSubtrees)->len-1]);
5951 0 : ((data)->permittedSubtrees)->len--;
5952 : }
5953 0 : free(((data)->permittedSubtrees)->val);
5954 0 : ((data)->permittedSubtrees)->val = NULL;
5955 0 : free((data)->permittedSubtrees);
5956 0 : (data)->permittedSubtrees = NULL;
5957 : }
5958 0 : if((data)->excludedSubtrees) {
5959 0 : while(((data)->excludedSubtrees)->len){
5960 0 : free_GeneralSubtree(&((data)->excludedSubtrees)->val[((data)->excludedSubtrees)->len-1]);
5961 0 : ((data)->excludedSubtrees)->len--;
5962 : }
5963 0 : free(((data)->excludedSubtrees)->val);
5964 0 : ((data)->excludedSubtrees)->val = NULL;
5965 0 : free((data)->excludedSubtrees);
5966 0 : (data)->excludedSubtrees = NULL;
5967 : }
5968 0 : }
5969 :
5970 : size_t ASN1CALL
5971 0 : length_NameConstraints(const NameConstraints *data)
5972 : {
5973 0 : size_t ret = 0;
5974 0 : if((data)->permittedSubtrees){
5975 0 : size_t Top_tag_oldret = ret;
5976 0 : ret = 0;
5977 : {
5978 0 : size_t permittedSubtrees_tag_oldret = ret;
5979 : int i;
5980 0 : ret = 0;
5981 0 : for(i = ((data)->permittedSubtrees)->len - 1; i >= 0; --i){
5982 0 : size_t permittedSubtrees_tag_for_oldret = ret;
5983 0 : ret = 0;
5984 0 : ret += length_GeneralSubtree(&((data)->permittedSubtrees)->val[i]);
5985 0 : ret += permittedSubtrees_tag_for_oldret;
5986 : }
5987 0 : ret += permittedSubtrees_tag_oldret;
5988 : }
5989 0 : ret += 1 + der_length_len (ret);
5990 0 : ret += Top_tag_oldret;
5991 : }
5992 0 : if((data)->excludedSubtrees){
5993 0 : size_t Top_tag_oldret = ret;
5994 0 : ret = 0;
5995 : {
5996 0 : size_t excludedSubtrees_tag_oldret = ret;
5997 : int i;
5998 0 : ret = 0;
5999 0 : for(i = ((data)->excludedSubtrees)->len - 1; i >= 0; --i){
6000 0 : size_t excludedSubtrees_tag_for_oldret = ret;
6001 0 : ret = 0;
6002 0 : ret += length_GeneralSubtree(&((data)->excludedSubtrees)->val[i]);
6003 0 : ret += excludedSubtrees_tag_for_oldret;
6004 : }
6005 0 : ret += excludedSubtrees_tag_oldret;
6006 : }
6007 0 : ret += 1 + der_length_len (ret);
6008 0 : ret += Top_tag_oldret;
6009 : }
6010 0 : ret += 1 + der_length_len (ret);
6011 0 : return ret;
6012 : }
6013 :
6014 : int ASN1CALL
6015 0 : copy_NameConstraints(const NameConstraints *from, NameConstraints *to)
6016 : {
6017 0 : memset(to, 0, sizeof(*to));
6018 0 : if((from)->permittedSubtrees) {
6019 0 : (to)->permittedSubtrees = malloc(sizeof(*(to)->permittedSubtrees));
6020 0 : if((to)->permittedSubtrees == NULL) goto fail;
6021 0 : if((((to)->permittedSubtrees)->val = malloc(((from)->permittedSubtrees)->len * sizeof(*((to)->permittedSubtrees)->val))) == NULL && ((from)->permittedSubtrees)->len != 0)
6022 0 : goto fail;
6023 0 : for(((to)->permittedSubtrees)->len = 0; ((to)->permittedSubtrees)->len < ((from)->permittedSubtrees)->len; ((to)->permittedSubtrees)->len++){
6024 0 : if(copy_GeneralSubtree(&((from)->permittedSubtrees)->val[((to)->permittedSubtrees)->len], &((to)->permittedSubtrees)->val[((to)->permittedSubtrees)->len])) goto fail;
6025 : }
6026 : }else
6027 0 : (to)->permittedSubtrees = NULL;
6028 0 : if((from)->excludedSubtrees) {
6029 0 : (to)->excludedSubtrees = malloc(sizeof(*(to)->excludedSubtrees));
6030 0 : if((to)->excludedSubtrees == NULL) goto fail;
6031 0 : if((((to)->excludedSubtrees)->val = malloc(((from)->excludedSubtrees)->len * sizeof(*((to)->excludedSubtrees)->val))) == NULL && ((from)->excludedSubtrees)->len != 0)
6032 0 : goto fail;
6033 0 : for(((to)->excludedSubtrees)->len = 0; ((to)->excludedSubtrees)->len < ((from)->excludedSubtrees)->len; ((to)->excludedSubtrees)->len++){
6034 0 : if(copy_GeneralSubtree(&((from)->excludedSubtrees)->val[((to)->excludedSubtrees)->len], &((to)->excludedSubtrees)->val[((to)->excludedSubtrees)->len])) goto fail;
6035 : }
6036 : }else
6037 0 : (to)->excludedSubtrees = NULL;
6038 0 : return 0;
6039 0 : fail:
6040 0 : free_NameConstraints(to);
6041 0 : return ENOMEM;
6042 : }
6043 :
6044 : static unsigned oid_id_x509_ce_privateKeyUsagePeriod_variable_num[4] = {2, 5, 29, 16 };
6045 : const heim_oid asn1_oid_id_x509_ce_privateKeyUsagePeriod = { 4, oid_id_x509_ce_privateKeyUsagePeriod_variable_num };
6046 :
6047 : static unsigned oid_id_x509_ce_certificatePolicies_variable_num[4] = {2, 5, 29, 32 };
6048 : const heim_oid asn1_oid_id_x509_ce_certificatePolicies = { 4, oid_id_x509_ce_certificatePolicies_variable_num };
6049 :
6050 : static unsigned oid_id_x509_ce_policyMappings_variable_num[4] = {2, 5, 29, 33 };
6051 : const heim_oid asn1_oid_id_x509_ce_policyMappings = { 4, oid_id_x509_ce_policyMappings_variable_num };
6052 :
6053 : static unsigned oid_id_x509_ce_subjectAltName_variable_num[4] = {2, 5, 29, 17 };
6054 : const heim_oid asn1_oid_id_x509_ce_subjectAltName = { 4, oid_id_x509_ce_subjectAltName_variable_num };
6055 :
6056 : static unsigned oid_id_x509_ce_issuerAltName_variable_num[4] = {2, 5, 29, 18 };
6057 : const heim_oid asn1_oid_id_x509_ce_issuerAltName = { 4, oid_id_x509_ce_issuerAltName_variable_num };
6058 :
6059 : static unsigned oid_id_x509_ce_subjectDirectoryAttributes_variable_num[4] = {2, 5, 29, 9 };
6060 : const heim_oid asn1_oid_id_x509_ce_subjectDirectoryAttributes = { 4, oid_id_x509_ce_subjectDirectoryAttributes_variable_num };
6061 :
6062 : static unsigned oid_id_x509_ce_policyConstraints_variable_num[4] = {2, 5, 29, 36 };
6063 : const heim_oid asn1_oid_id_x509_ce_policyConstraints = { 4, oid_id_x509_ce_policyConstraints_variable_num };
6064 :
6065 : static unsigned oid_id_x509_ce_extKeyUsage_variable_num[4] = {2, 5, 29, 37 };
6066 : const heim_oid asn1_oid_id_x509_ce_extKeyUsage = { 4, oid_id_x509_ce_extKeyUsage_variable_num };
6067 :
6068 : int ASN1CALL
6069 0 : encode_ExtKeyUsage(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const ExtKeyUsage *data, size_t *size)
6070 : {
6071 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
6072 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
6073 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
6074 :
6075 0 : for(i = (int)(data)->len - 1; i >= 0; --i) {
6076 0 : size_t Top_tag_for_oldret = ret;
6077 0 : ret = 0;
6078 0 : e = der_put_oid(p, len, &(data)->val[i], &l);
6079 0 : if (e) return e;
6080 0 : p -= l; len -= l; ret += l;
6081 :
6082 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OID, &l);
6083 0 : if (e) return e;
6084 0 : p -= l; len -= l; ret += l;
6085 :
6086 0 : ret += Top_tag_for_oldret;
6087 : }
6088 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
6089 0 : if (e) return e;
6090 0 : p -= l; len -= l; ret += l;
6091 :
6092 0 : *size = ret;
6093 0 : return 0;
6094 : }
6095 :
6096 : int ASN1CALL
6097 154 : decode_ExtKeyUsage(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, ExtKeyUsage *data, size_t *size)
6098 : {
6099 154 : size_t ret = 0;
6100 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
6101 : int e HEIMDAL_UNUSED_ATTRIBUTE;
6102 :
6103 154 : memset(data, 0, sizeof(*data));
6104 : {
6105 : size_t Top_datalen, Top_oldlen;
6106 : Der_type Top_type;
6107 154 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
6108 154 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
6109 154 : if(e) goto fail;
6110 154 : p += l; len -= l; ret += l;
6111 154 : Top_oldlen = len;
6112 154 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
6113 154 : len = Top_datalen;
6114 : {
6115 154 : size_t Top_Tag_origlen = len;
6116 154 : size_t Top_Tag_oldret = ret;
6117 154 : size_t Top_Tag_olen = 0;
6118 : void *Top_Tag_tmp;
6119 154 : ret = 0;
6120 154 : (data)->len = 0;
6121 154 : (data)->val = NULL;
6122 680 : while(ret < Top_Tag_origlen) {
6123 372 : size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
6124 372 : if (Top_Tag_olen > Top_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
6125 372 : Top_Tag_olen = Top_Tag_nlen;
6126 372 : Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
6127 372 : if (Top_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
6128 372 : (data)->val = Top_Tag_tmp;
6129 : {
6130 : size_t Top_Tag_s_of_datalen, Top_Tag_s_of_oldlen;
6131 : Der_type Top_Tag_s_of_type;
6132 372 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_Tag_s_of_type, UT_OID, &Top_Tag_s_of_datalen, &l);
6133 372 : if (e == 0 && Top_Tag_s_of_type != PRIM) { e = ASN1_BAD_ID; }
6134 372 : if(e) goto fail;
6135 372 : p += l; len -= l; ret += l;
6136 372 : Top_Tag_s_of_oldlen = len;
6137 372 : if (Top_Tag_s_of_datalen > len) { e = ASN1_OVERRUN; goto fail; }
6138 372 : len = Top_Tag_s_of_datalen;
6139 372 : e = der_get_oid(p, len, &(data)->val[(data)->len], &l);
6140 372 : if(e) goto fail;
6141 372 : p += l; len -= l; ret += l;
6142 372 : len = Top_Tag_s_of_oldlen - Top_Tag_s_of_datalen;
6143 : }
6144 372 : (data)->len++;
6145 372 : len = Top_Tag_origlen - ret;
6146 : }
6147 154 : ret += Top_Tag_oldret;
6148 : }
6149 154 : len = Top_oldlen - Top_datalen;
6150 : }
6151 308 : if(size) *size = ret;
6152 146 : return 0;
6153 0 : fail:
6154 0 : free_ExtKeyUsage(data);
6155 0 : return e;
6156 : }
6157 :
6158 : void ASN1CALL
6159 154 : free_ExtKeyUsage(ExtKeyUsage *data)
6160 : {
6161 680 : while((data)->len){
6162 372 : der_free_oid(&(data)->val[(data)->len-1]);
6163 372 : (data)->len--;
6164 : }
6165 154 : free((data)->val);
6166 154 : (data)->val = NULL;
6167 154 : }
6168 :
6169 : size_t ASN1CALL
6170 0 : length_ExtKeyUsage(const ExtKeyUsage *data)
6171 : {
6172 0 : size_t ret = 0;
6173 : {
6174 0 : size_t Top_tag_oldret = ret;
6175 : int i;
6176 0 : ret = 0;
6177 0 : for(i = (data)->len - 1; i >= 0; --i){
6178 0 : size_t Top_tag_for_oldret = ret;
6179 0 : ret = 0;
6180 0 : ret += der_length_oid(&(data)->val[i]);
6181 0 : ret += 1 + der_length_len (ret);
6182 0 : ret += Top_tag_for_oldret;
6183 : }
6184 0 : ret += Top_tag_oldret;
6185 : }
6186 0 : ret += 1 + der_length_len (ret);
6187 0 : return ret;
6188 : }
6189 :
6190 : int ASN1CALL
6191 0 : copy_ExtKeyUsage(const ExtKeyUsage *from, ExtKeyUsage *to)
6192 : {
6193 0 : memset(to, 0, sizeof(*to));
6194 0 : if(((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
6195 0 : goto fail;
6196 0 : for((to)->len = 0; (to)->len < (from)->len; (to)->len++){
6197 0 : if(der_copy_oid(&(from)->val[(to)->len], &(to)->val[(to)->len])) goto fail;
6198 : }
6199 0 : return 0;
6200 0 : fail:
6201 0 : free_ExtKeyUsage(to);
6202 0 : return ENOMEM;
6203 : }
6204 :
6205 : static unsigned oid_id_x509_ce_cRLDistributionPoints_variable_num[4] = {2, 5, 29, 31 };
6206 : const heim_oid asn1_oid_id_x509_ce_cRLDistributionPoints = { 4, oid_id_x509_ce_cRLDistributionPoints_variable_num };
6207 :
6208 : static unsigned oid_id_x509_ce_deltaCRLIndicator_variable_num[4] = {2, 5, 29, 27 };
6209 : const heim_oid asn1_oid_id_x509_ce_deltaCRLIndicator = { 4, oid_id_x509_ce_deltaCRLIndicator_variable_num };
6210 :
6211 : static unsigned oid_id_x509_ce_issuingDistributionPoint_variable_num[4] = {2, 5, 29, 28 };
6212 : const heim_oid asn1_oid_id_x509_ce_issuingDistributionPoint = { 4, oid_id_x509_ce_issuingDistributionPoint_variable_num };
6213 :
6214 : static unsigned oid_id_x509_ce_holdInstructionCode_variable_num[4] = {2, 5, 29, 23 };
6215 : const heim_oid asn1_oid_id_x509_ce_holdInstructionCode = { 4, oid_id_x509_ce_holdInstructionCode_variable_num };
6216 :
6217 : static unsigned oid_id_x509_ce_invalidityDate_variable_num[4] = {2, 5, 29, 24 };
6218 : const heim_oid asn1_oid_id_x509_ce_invalidityDate = { 4, oid_id_x509_ce_invalidityDate_variable_num };
6219 :
6220 : static unsigned oid_id_x509_ce_certificateIssuer_variable_num[4] = {2, 5, 29, 29 };
6221 : const heim_oid asn1_oid_id_x509_ce_certificateIssuer = { 4, oid_id_x509_ce_certificateIssuer_variable_num };
6222 :
6223 : static unsigned oid_id_x509_ce_inhibitAnyPolicy_variable_num[4] = {2, 5, 29, 54 };
6224 : const heim_oid asn1_oid_id_x509_ce_inhibitAnyPolicy = { 4, oid_id_x509_ce_inhibitAnyPolicy_variable_num };
6225 :
6226 : int ASN1CALL
6227 0 : encode_DistributionPointReasonFlags(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const DistributionPointReasonFlags *data, size_t *size)
6228 : {
6229 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
6230 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
6231 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
6232 :
6233 : {
6234 0 : unsigned char c = 0;
6235 0 : int rest = 0;
6236 0 : int bit_set = 0;
6237 0 : if((data)->aACompromise) {
6238 0 : c |= 1<<7;
6239 : }
6240 0 : if (c != 0 || bit_set) {
6241 0 : if (len < 1) return ASN1_OVERFLOW;
6242 0 : *p-- = c; len--; ret++;
6243 0 : if (!bit_set) {
6244 0 : rest = 0;
6245 0 : while(c) {
6246 0 : if (c & 1) break;
6247 0 : c = c >> 1;
6248 0 : rest++;
6249 : }
6250 0 : bit_set = 1;
6251 : }
6252 : }
6253 0 : c = 0;
6254 0 : if((data)->privilegeWithdrawn) {
6255 0 : c |= 1<<0;
6256 : }
6257 0 : if((data)->certificateHold) {
6258 0 : c |= 1<<1;
6259 : }
6260 0 : if((data)->cessationOfOperation) {
6261 0 : c |= 1<<2;
6262 : }
6263 0 : if((data)->superseded) {
6264 0 : c |= 1<<3;
6265 : }
6266 0 : if((data)->affiliationChanged) {
6267 0 : c |= 1<<4;
6268 : }
6269 0 : if((data)->cACompromise) {
6270 0 : c |= 1<<5;
6271 : }
6272 0 : if((data)->keyCompromise) {
6273 0 : c |= 1<<6;
6274 : }
6275 0 : if((data)->unused) {
6276 0 : c |= 1<<7;
6277 : }
6278 0 : if (c != 0 || bit_set) {
6279 0 : if (len < 1) return ASN1_OVERFLOW;
6280 0 : *p-- = c; len--; ret++;
6281 0 : if (!bit_set) {
6282 0 : rest = 0;
6283 0 : if(c) {
6284 0 : while(c) {
6285 0 : if (c & 1) break;
6286 0 : c = c >> 1;
6287 0 : rest++;
6288 : }
6289 : }
6290 : }
6291 : }
6292 0 : if (len < 1) return ASN1_OVERFLOW;
6293 0 : *p-- = rest;
6294 0 : len -= 1;
6295 0 : ret += 1;
6296 : }
6297 :
6298 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_BitString, &l);
6299 0 : if (e) return e;
6300 0 : p -= l; len -= l; ret += l;
6301 :
6302 0 : *size = ret;
6303 0 : return 0;
6304 : }
6305 :
6306 : int ASN1CALL
6307 0 : decode_DistributionPointReasonFlags(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, DistributionPointReasonFlags *data, size_t *size)
6308 : {
6309 0 : size_t ret = 0;
6310 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
6311 : int e HEIMDAL_UNUSED_ATTRIBUTE;
6312 :
6313 0 : memset(data, 0, sizeof(*data));
6314 : {
6315 : size_t Top_datalen, Top_oldlen;
6316 : Der_type Top_type;
6317 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_BitString, &Top_datalen, &l);
6318 0 : if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
6319 0 : if(e) goto fail;
6320 0 : p += l; len -= l; ret += l;
6321 0 : Top_oldlen = len;
6322 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
6323 0 : len = Top_datalen;
6324 0 : if (len < 1) return ASN1_OVERRUN;
6325 0 : p++; len--; ret++;
6326 : do {
6327 0 : if (len < 1) break;
6328 0 : (data)->unused = (*p >> 7) & 1;
6329 0 : (data)->keyCompromise = (*p >> 6) & 1;
6330 0 : (data)->cACompromise = (*p >> 5) & 1;
6331 0 : (data)->affiliationChanged = (*p >> 4) & 1;
6332 0 : (data)->superseded = (*p >> 3) & 1;
6333 0 : (data)->cessationOfOperation = (*p >> 2) & 1;
6334 0 : (data)->certificateHold = (*p >> 1) & 1;
6335 0 : (data)->privilegeWithdrawn = (*p >> 0) & 1;
6336 0 : p++; len--; ret++;
6337 0 : if (len < 1) break;
6338 0 : (data)->aACompromise = (*p >> 7) & 1;
6339 : } while(0);
6340 0 : p += len; ret += len;
6341 0 : len = Top_oldlen - Top_datalen;
6342 : }
6343 0 : if(size) *size = ret;
6344 0 : return 0;
6345 0 : fail:
6346 0 : free_DistributionPointReasonFlags(data);
6347 0 : return e;
6348 : }
6349 :
6350 : void ASN1CALL
6351 0 : free_DistributionPointReasonFlags(DistributionPointReasonFlags *data)
6352 : {
6353 0 : }
6354 :
6355 : size_t ASN1CALL
6356 0 : length_DistributionPointReasonFlags(const DistributionPointReasonFlags *data)
6357 : {
6358 0 : size_t ret = 0;
6359 : do {
6360 0 : if((data)->aACompromise) { ret += 2; break; }
6361 0 : if((data)->privilegeWithdrawn) { ret += 1; break; }
6362 0 : if((data)->certificateHold) { ret += 1; break; }
6363 0 : if((data)->cessationOfOperation) { ret += 1; break; }
6364 0 : if((data)->superseded) { ret += 1; break; }
6365 0 : if((data)->affiliationChanged) { ret += 1; break; }
6366 0 : if((data)->cACompromise) { ret += 1; break; }
6367 0 : if((data)->keyCompromise) { ret += 1; break; }
6368 0 : if((data)->unused) { ret += 1; break; }
6369 : } while(0);
6370 0 : ret += 1;
6371 0 : ret += 1 + der_length_len (ret);
6372 0 : return ret;
6373 : }
6374 :
6375 : int ASN1CALL
6376 0 : copy_DistributionPointReasonFlags(const DistributionPointReasonFlags *from, DistributionPointReasonFlags *to)
6377 : {
6378 0 : memset(to, 0, sizeof(*to));
6379 0 : *(to) = *(from);
6380 0 : return 0;
6381 : }
6382 :
6383 0 : unsigned DistributionPointReasonFlags2int(DistributionPointReasonFlags f)
6384 : {
6385 0 : unsigned r = 0;
6386 0 : if(f.unused) r |= (1U << 0);
6387 0 : if(f.keyCompromise) r |= (1U << 1);
6388 0 : if(f.cACompromise) r |= (1U << 2);
6389 0 : if(f.affiliationChanged) r |= (1U << 3);
6390 0 : if(f.superseded) r |= (1U << 4);
6391 0 : if(f.cessationOfOperation) r |= (1U << 5);
6392 0 : if(f.certificateHold) r |= (1U << 6);
6393 0 : if(f.privilegeWithdrawn) r |= (1U << 7);
6394 0 : if(f.aACompromise) r |= (1U << 8);
6395 0 : return r;
6396 : }
6397 :
6398 0 : DistributionPointReasonFlags int2DistributionPointReasonFlags(unsigned n)
6399 : {
6400 : DistributionPointReasonFlags flags;
6401 :
6402 0 : memset(&flags, 0, sizeof(flags));
6403 :
6404 0 : flags.unused = (n >> 0) & 1;
6405 0 : flags.keyCompromise = (n >> 1) & 1;
6406 0 : flags.cACompromise = (n >> 2) & 1;
6407 0 : flags.affiliationChanged = (n >> 3) & 1;
6408 0 : flags.superseded = (n >> 4) & 1;
6409 0 : flags.cessationOfOperation = (n >> 5) & 1;
6410 0 : flags.certificateHold = (n >> 6) & 1;
6411 0 : flags.privilegeWithdrawn = (n >> 7) & 1;
6412 0 : flags.aACompromise = (n >> 8) & 1;
6413 0 : return flags;
6414 : }
6415 :
6416 : static struct units DistributionPointReasonFlags_units[] = {
6417 : {"aACompromise", 1U << 8},
6418 : {"privilegeWithdrawn", 1U << 7},
6419 : {"certificateHold", 1U << 6},
6420 : {"cessationOfOperation", 1U << 5},
6421 : {"superseded", 1U << 4},
6422 : {"affiliationChanged", 1U << 3},
6423 : {"cACompromise", 1U << 2},
6424 : {"keyCompromise", 1U << 1},
6425 : {"unused", 1U << 0},
6426 : {NULL, 0}
6427 : };
6428 :
6429 0 : const struct units * asn1_DistributionPointReasonFlags_units(void){
6430 0 : return DistributionPointReasonFlags_units;
6431 : }
6432 :
6433 : int ASN1CALL
6434 0 : encode_DistributionPointName(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const DistributionPointName *data, size_t *size)
6435 : {
6436 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
6437 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
6438 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
6439 :
6440 :
6441 0 : switch((data)->element) {
6442 0 : case choice_DistributionPointName_nameRelativeToCRLIssuer: {size_t Top_oldret = ret;
6443 0 : ret = 0;
6444 0 : e = encode_RelativeDistinguishedName(p, len, &((data))->u.nameRelativeToCRLIssuer, &l);
6445 0 : if (e) return e;
6446 0 : p -= l; len -= l; ret += l;
6447 :
6448 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
6449 0 : if (e) return e;
6450 0 : p -= l; len -= l; ret += l;
6451 :
6452 0 : ret += Top_oldret;
6453 0 : break;
6454 : }
6455 0 : case choice_DistributionPointName_fullName: {size_t Top_oldret = ret;
6456 0 : ret = 0;
6457 0 : for(i = (int)(&((data))->u.fullName)->len - 1; i >= 0; --i) {
6458 0 : size_t fullName_tag_for_oldret = ret;
6459 0 : ret = 0;
6460 0 : e = encode_GeneralName(p, len, &(&((data))->u.fullName)->val[i], &l);
6461 0 : if (e) return e;
6462 0 : p -= l; len -= l; ret += l;
6463 :
6464 0 : ret += fullName_tag_for_oldret;
6465 : }
6466 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
6467 0 : if (e) return e;
6468 0 : p -= l; len -= l; ret += l;
6469 :
6470 0 : ret += Top_oldret;
6471 0 : break;
6472 : }
6473 : };
6474 0 : *size = ret;
6475 0 : return 0;
6476 : }
6477 :
6478 : int ASN1CALL
6479 0 : decode_DistributionPointName(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, DistributionPointName *data, size_t *size)
6480 : {
6481 0 : size_t ret = 0;
6482 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
6483 : int e HEIMDAL_UNUSED_ATTRIBUTE;
6484 :
6485 0 : memset(data, 0, sizeof(*data));
6486 0 : if (der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 0, NULL) == 0) {
6487 : {
6488 : size_t fullName_datalen, fullName_oldlen;
6489 : Der_type fullName_type;
6490 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &fullName_type, 0, &fullName_datalen, &l);
6491 0 : if (e == 0 && fullName_type != CONS) { e = ASN1_BAD_ID; }
6492 0 : if(e) goto fail;
6493 0 : p += l; len -= l; ret += l;
6494 0 : fullName_oldlen = len;
6495 0 : if (fullName_datalen > len) { e = ASN1_OVERRUN; goto fail; }
6496 0 : len = fullName_datalen;
6497 : {
6498 0 : size_t fullName_Tag_origlen = len;
6499 0 : size_t fullName_Tag_oldret = ret;
6500 0 : size_t fullName_Tag_olen = 0;
6501 : void *fullName_Tag_tmp;
6502 0 : ret = 0;
6503 0 : (&(data)->u.fullName)->len = 0;
6504 0 : (&(data)->u.fullName)->val = NULL;
6505 0 : while(ret < fullName_Tag_origlen) {
6506 0 : size_t fullName_Tag_nlen = fullName_Tag_olen + sizeof(*((&(data)->u.fullName)->val));
6507 0 : if (fullName_Tag_olen > fullName_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
6508 0 : fullName_Tag_olen = fullName_Tag_nlen;
6509 0 : fullName_Tag_tmp = realloc((&(data)->u.fullName)->val, fullName_Tag_olen);
6510 0 : if (fullName_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
6511 0 : (&(data)->u.fullName)->val = fullName_Tag_tmp;
6512 0 : e = decode_GeneralName(p, len, &(&(data)->u.fullName)->val[(&(data)->u.fullName)->len], &l);
6513 0 : if(e) goto fail;
6514 0 : p += l; len -= l; ret += l;
6515 0 : (&(data)->u.fullName)->len++;
6516 0 : len = fullName_Tag_origlen - ret;
6517 : }
6518 0 : ret += fullName_Tag_oldret;
6519 : }
6520 0 : if ((&(data)->u.fullName)->len < 1) {
6521 0 : e = ASN1_MIN_CONSTRAINT; goto fail;
6522 : }
6523 0 : len = fullName_oldlen - fullName_datalen;
6524 : }
6525 0 : (data)->element = choice_DistributionPointName_fullName;
6526 : }
6527 0 : else if (der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 1, NULL) == 0) {
6528 : {
6529 : size_t nameRelativeToCRLIssuer_datalen, nameRelativeToCRLIssuer_oldlen;
6530 : Der_type nameRelativeToCRLIssuer_type;
6531 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &nameRelativeToCRLIssuer_type, 1, &nameRelativeToCRLIssuer_datalen, &l);
6532 0 : if (e == 0 && nameRelativeToCRLIssuer_type != CONS) { e = ASN1_BAD_ID; }
6533 0 : if(e) goto fail;
6534 0 : p += l; len -= l; ret += l;
6535 0 : nameRelativeToCRLIssuer_oldlen = len;
6536 0 : if (nameRelativeToCRLIssuer_datalen > len) { e = ASN1_OVERRUN; goto fail; }
6537 0 : len = nameRelativeToCRLIssuer_datalen;
6538 0 : e = decode_RelativeDistinguishedName(p, len, &(data)->u.nameRelativeToCRLIssuer, &l);
6539 0 : if(e) goto fail;
6540 0 : p += l; len -= l; ret += l;
6541 0 : len = nameRelativeToCRLIssuer_oldlen - nameRelativeToCRLIssuer_datalen;
6542 : }
6543 0 : (data)->element = choice_DistributionPointName_nameRelativeToCRLIssuer;
6544 : }
6545 : else {
6546 0 : e = ASN1_PARSE_ERROR;
6547 0 : goto fail;
6548 : }
6549 0 : if(size) *size = ret;
6550 0 : return 0;
6551 0 : fail:
6552 0 : free_DistributionPointName(data);
6553 0 : return e;
6554 : }
6555 :
6556 : void ASN1CALL
6557 0 : free_DistributionPointName(DistributionPointName *data)
6558 : {
6559 0 : switch((data)->element) {
6560 0 : case choice_DistributionPointName_fullName:
6561 0 : while((&(data)->u.fullName)->len){
6562 0 : free_GeneralName(&(&(data)->u.fullName)->val[(&(data)->u.fullName)->len-1]);
6563 0 : (&(data)->u.fullName)->len--;
6564 : }
6565 0 : free((&(data)->u.fullName)->val);
6566 0 : (&(data)->u.fullName)->val = NULL;
6567 0 : break;
6568 0 : case choice_DistributionPointName_nameRelativeToCRLIssuer:
6569 0 : free_RelativeDistinguishedName(&(data)->u.nameRelativeToCRLIssuer);
6570 0 : break;
6571 : }
6572 0 : }
6573 :
6574 : size_t ASN1CALL
6575 0 : length_DistributionPointName(const DistributionPointName *data)
6576 : {
6577 0 : size_t ret = 0;
6578 0 : switch((data)->element) {
6579 0 : case choice_DistributionPointName_fullName:
6580 : {
6581 0 : size_t Top_oldret = ret;
6582 0 : ret = 0;
6583 : {
6584 0 : size_t fullName_tag_oldret = ret;
6585 : int i;
6586 0 : ret = 0;
6587 0 : for(i = (&(data)->u.fullName)->len - 1; i >= 0; --i){
6588 0 : size_t fullName_tag_for_oldret = ret;
6589 0 : ret = 0;
6590 0 : ret += length_GeneralName(&(&(data)->u.fullName)->val[i]);
6591 0 : ret += fullName_tag_for_oldret;
6592 : }
6593 0 : ret += fullName_tag_oldret;
6594 : }
6595 0 : ret += 1 + der_length_len (ret);
6596 0 : ret += Top_oldret;
6597 : }
6598 0 : break;
6599 0 : case choice_DistributionPointName_nameRelativeToCRLIssuer:
6600 : {
6601 0 : size_t Top_oldret = ret;
6602 0 : ret = 0;
6603 0 : ret += length_RelativeDistinguishedName(&(data)->u.nameRelativeToCRLIssuer);
6604 0 : ret += 1 + der_length_len (ret);
6605 0 : ret += Top_oldret;
6606 : }
6607 0 : break;
6608 : }
6609 0 : return ret;
6610 : }
6611 :
6612 : int ASN1CALL
6613 0 : copy_DistributionPointName(const DistributionPointName *from, DistributionPointName *to)
6614 : {
6615 0 : memset(to, 0, sizeof(*to));
6616 0 : (to)->element = (from)->element;
6617 0 : switch((from)->element) {
6618 0 : case choice_DistributionPointName_fullName:
6619 0 : if(((&(to)->u.fullName)->val = malloc((&(from)->u.fullName)->len * sizeof(*(&(to)->u.fullName)->val))) == NULL && (&(from)->u.fullName)->len != 0)
6620 0 : goto fail;
6621 0 : for((&(to)->u.fullName)->len = 0; (&(to)->u.fullName)->len < (&(from)->u.fullName)->len; (&(to)->u.fullName)->len++){
6622 0 : if(copy_GeneralName(&(&(from)->u.fullName)->val[(&(to)->u.fullName)->len], &(&(to)->u.fullName)->val[(&(to)->u.fullName)->len])) goto fail;
6623 : }
6624 0 : break;
6625 0 : case choice_DistributionPointName_nameRelativeToCRLIssuer:
6626 0 : if(copy_RelativeDistinguishedName(&(from)->u.nameRelativeToCRLIssuer, &(to)->u.nameRelativeToCRLIssuer)) goto fail;
6627 0 : break;
6628 : }
6629 0 : return 0;
6630 0 : fail:
6631 0 : free_DistributionPointName(to);
6632 0 : return ENOMEM;
6633 : }
6634 :
6635 : int ASN1CALL
6636 0 : encode_DistributionPoint(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const DistributionPoint *data, size_t *size)
6637 : {
6638 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
6639 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
6640 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
6641 :
6642 : /* cRLIssuer */
6643 0 : if((data)->cRLIssuer) {
6644 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
6645 0 : ret = 0;
6646 0 : e = encode_heim_any(p, len, (data)->cRLIssuer, &l);
6647 0 : if (e) return e;
6648 0 : p -= l; len -= l; ret += l;
6649 :
6650 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
6651 0 : if (e) return e;
6652 0 : p -= l; len -= l; ret += l;
6653 :
6654 0 : ret += Top_tag_oldret;
6655 : }
6656 : /* reasons */
6657 0 : if((data)->reasons) {
6658 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
6659 0 : ret = 0;
6660 0 : e = encode_heim_any(p, len, (data)->reasons, &l);
6661 0 : if (e) return e;
6662 0 : p -= l; len -= l; ret += l;
6663 :
6664 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
6665 0 : if (e) return e;
6666 0 : p -= l; len -= l; ret += l;
6667 :
6668 0 : ret += Top_tag_oldret;
6669 : }
6670 : /* distributionPoint */
6671 0 : if((data)->distributionPoint) {
6672 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
6673 0 : ret = 0;
6674 0 : e = encode_heim_any(p, len, (data)->distributionPoint, &l);
6675 0 : if (e) return e;
6676 0 : p -= l; len -= l; ret += l;
6677 :
6678 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
6679 0 : if (e) return e;
6680 0 : p -= l; len -= l; ret += l;
6681 :
6682 0 : ret += Top_tag_oldret;
6683 : }
6684 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
6685 0 : if (e) return e;
6686 0 : p -= l; len -= l; ret += l;
6687 :
6688 0 : *size = ret;
6689 0 : return 0;
6690 : }
6691 :
6692 : int ASN1CALL
6693 0 : decode_DistributionPoint(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, DistributionPoint *data, size_t *size)
6694 : {
6695 0 : size_t ret = 0;
6696 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
6697 : int e HEIMDAL_UNUSED_ATTRIBUTE;
6698 :
6699 0 : memset(data, 0, sizeof(*data));
6700 : {
6701 : size_t Top_datalen, Top_oldlen;
6702 : Der_type Top_type;
6703 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
6704 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
6705 0 : if(e) goto fail;
6706 0 : p += l; len -= l; ret += l;
6707 0 : Top_oldlen = len;
6708 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
6709 0 : len = Top_datalen;
6710 : {
6711 : size_t distributionPoint_datalen, distributionPoint_oldlen;
6712 : Der_type distributionPoint_type;
6713 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &distributionPoint_type, 0, &distributionPoint_datalen, &l);
6714 0 : if (e == 0 && distributionPoint_type != CONS) { e = ASN1_BAD_ID; }
6715 0 : if(e) {
6716 0 : (data)->distributionPoint = NULL;
6717 : } else {
6718 0 : (data)->distributionPoint = calloc(1, sizeof(*(data)->distributionPoint));
6719 0 : if ((data)->distributionPoint == NULL) { e = ENOMEM; goto fail; }
6720 0 : p += l; len -= l; ret += l;
6721 0 : distributionPoint_oldlen = len;
6722 0 : if (distributionPoint_datalen > len) { e = ASN1_OVERRUN; goto fail; }
6723 0 : len = distributionPoint_datalen;
6724 0 : e = decode_heim_any(p, len, (data)->distributionPoint, &l);
6725 0 : if(e) goto fail;
6726 0 : p += l; len -= l; ret += l;
6727 0 : len = distributionPoint_oldlen - distributionPoint_datalen;
6728 : }
6729 : }
6730 : {
6731 : size_t reasons_datalen, reasons_oldlen;
6732 : Der_type reasons_type;
6733 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &reasons_type, 1, &reasons_datalen, &l);
6734 0 : if (e == 0 && reasons_type != CONS) { e = ASN1_BAD_ID; }
6735 0 : if(e) {
6736 0 : (data)->reasons = NULL;
6737 : } else {
6738 0 : (data)->reasons = calloc(1, sizeof(*(data)->reasons));
6739 0 : if ((data)->reasons == NULL) { e = ENOMEM; goto fail; }
6740 0 : p += l; len -= l; ret += l;
6741 0 : reasons_oldlen = len;
6742 0 : if (reasons_datalen > len) { e = ASN1_OVERRUN; goto fail; }
6743 0 : len = reasons_datalen;
6744 0 : e = decode_heim_any(p, len, (data)->reasons, &l);
6745 0 : if(e) goto fail;
6746 0 : p += l; len -= l; ret += l;
6747 0 : len = reasons_oldlen - reasons_datalen;
6748 : }
6749 : }
6750 : {
6751 : size_t cRLIssuer_datalen, cRLIssuer_oldlen;
6752 : Der_type cRLIssuer_type;
6753 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &cRLIssuer_type, 2, &cRLIssuer_datalen, &l);
6754 0 : if (e == 0 && cRLIssuer_type != CONS) { e = ASN1_BAD_ID; }
6755 0 : if(e) {
6756 0 : (data)->cRLIssuer = NULL;
6757 : } else {
6758 0 : (data)->cRLIssuer = calloc(1, sizeof(*(data)->cRLIssuer));
6759 0 : if ((data)->cRLIssuer == NULL) { e = ENOMEM; goto fail; }
6760 0 : p += l; len -= l; ret += l;
6761 0 : cRLIssuer_oldlen = len;
6762 0 : if (cRLIssuer_datalen > len) { e = ASN1_OVERRUN; goto fail; }
6763 0 : len = cRLIssuer_datalen;
6764 0 : e = decode_heim_any(p, len, (data)->cRLIssuer, &l);
6765 0 : if(e) goto fail;
6766 0 : p += l; len -= l; ret += l;
6767 0 : len = cRLIssuer_oldlen - cRLIssuer_datalen;
6768 : }
6769 : }
6770 0 : len = Top_oldlen - Top_datalen;
6771 : }
6772 0 : if(size) *size = ret;
6773 0 : return 0;
6774 0 : fail:
6775 0 : free_DistributionPoint(data);
6776 0 : return e;
6777 : }
6778 :
6779 : void ASN1CALL
6780 0 : free_DistributionPoint(DistributionPoint *data)
6781 : {
6782 0 : if((data)->distributionPoint) {
6783 0 : free_heim_any((data)->distributionPoint);
6784 0 : free((data)->distributionPoint);
6785 0 : (data)->distributionPoint = NULL;
6786 : }
6787 0 : if((data)->reasons) {
6788 0 : free_heim_any((data)->reasons);
6789 0 : free((data)->reasons);
6790 0 : (data)->reasons = NULL;
6791 : }
6792 0 : if((data)->cRLIssuer) {
6793 0 : free_heim_any((data)->cRLIssuer);
6794 0 : free((data)->cRLIssuer);
6795 0 : (data)->cRLIssuer = NULL;
6796 : }
6797 0 : }
6798 :
6799 : size_t ASN1CALL
6800 0 : length_DistributionPoint(const DistributionPoint *data)
6801 : {
6802 0 : size_t ret = 0;
6803 0 : if((data)->distributionPoint){
6804 0 : size_t Top_tag_oldret = ret;
6805 0 : ret = 0;
6806 0 : ret += length_heim_any((data)->distributionPoint);
6807 0 : ret += 1 + der_length_len (ret);
6808 0 : ret += Top_tag_oldret;
6809 : }
6810 0 : if((data)->reasons){
6811 0 : size_t Top_tag_oldret = ret;
6812 0 : ret = 0;
6813 0 : ret += length_heim_any((data)->reasons);
6814 0 : ret += 1 + der_length_len (ret);
6815 0 : ret += Top_tag_oldret;
6816 : }
6817 0 : if((data)->cRLIssuer){
6818 0 : size_t Top_tag_oldret = ret;
6819 0 : ret = 0;
6820 0 : ret += length_heim_any((data)->cRLIssuer);
6821 0 : ret += 1 + der_length_len (ret);
6822 0 : ret += Top_tag_oldret;
6823 : }
6824 0 : ret += 1 + der_length_len (ret);
6825 0 : return ret;
6826 : }
6827 :
6828 : int ASN1CALL
6829 0 : copy_DistributionPoint(const DistributionPoint *from, DistributionPoint *to)
6830 : {
6831 0 : memset(to, 0, sizeof(*to));
6832 0 : if((from)->distributionPoint) {
6833 0 : (to)->distributionPoint = malloc(sizeof(*(to)->distributionPoint));
6834 0 : if((to)->distributionPoint == NULL) goto fail;
6835 0 : if(copy_heim_any((from)->distributionPoint, (to)->distributionPoint)) goto fail;
6836 : }else
6837 0 : (to)->distributionPoint = NULL;
6838 0 : if((from)->reasons) {
6839 0 : (to)->reasons = malloc(sizeof(*(to)->reasons));
6840 0 : if((to)->reasons == NULL) goto fail;
6841 0 : if(copy_heim_any((from)->reasons, (to)->reasons)) goto fail;
6842 : }else
6843 0 : (to)->reasons = NULL;
6844 0 : if((from)->cRLIssuer) {
6845 0 : (to)->cRLIssuer = malloc(sizeof(*(to)->cRLIssuer));
6846 0 : if((to)->cRLIssuer == NULL) goto fail;
6847 0 : if(copy_heim_any((from)->cRLIssuer, (to)->cRLIssuer)) goto fail;
6848 : }else
6849 0 : (to)->cRLIssuer = NULL;
6850 0 : return 0;
6851 0 : fail:
6852 0 : free_DistributionPoint(to);
6853 0 : return ENOMEM;
6854 : }
6855 :
6856 : int ASN1CALL
6857 0 : encode_CRLDistributionPoints(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const CRLDistributionPoints *data, size_t *size)
6858 : {
6859 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
6860 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
6861 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
6862 :
6863 0 : for(i = (int)(data)->len - 1; i >= 0; --i) {
6864 0 : size_t Top_tag_for_oldret = ret;
6865 0 : ret = 0;
6866 0 : e = encode_DistributionPoint(p, len, &(data)->val[i], &l);
6867 0 : if (e) return e;
6868 0 : p -= l; len -= l; ret += l;
6869 :
6870 0 : ret += Top_tag_for_oldret;
6871 : }
6872 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
6873 0 : if (e) return e;
6874 0 : p -= l; len -= l; ret += l;
6875 :
6876 0 : *size = ret;
6877 0 : return 0;
6878 : }
6879 :
6880 : int ASN1CALL
6881 0 : decode_CRLDistributionPoints(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, CRLDistributionPoints *data, size_t *size)
6882 : {
6883 0 : size_t ret = 0;
6884 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
6885 : int e HEIMDAL_UNUSED_ATTRIBUTE;
6886 :
6887 0 : memset(data, 0, sizeof(*data));
6888 : {
6889 : size_t Top_datalen, Top_oldlen;
6890 : Der_type Top_type;
6891 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
6892 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
6893 0 : if(e) goto fail;
6894 0 : p += l; len -= l; ret += l;
6895 0 : Top_oldlen = len;
6896 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
6897 0 : len = Top_datalen;
6898 : {
6899 0 : size_t Top_Tag_origlen = len;
6900 0 : size_t Top_Tag_oldret = ret;
6901 0 : size_t Top_Tag_olen = 0;
6902 : void *Top_Tag_tmp;
6903 0 : ret = 0;
6904 0 : (data)->len = 0;
6905 0 : (data)->val = NULL;
6906 0 : while(ret < Top_Tag_origlen) {
6907 0 : size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
6908 0 : if (Top_Tag_olen > Top_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
6909 0 : Top_Tag_olen = Top_Tag_nlen;
6910 0 : Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
6911 0 : if (Top_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
6912 0 : (data)->val = Top_Tag_tmp;
6913 0 : e = decode_DistributionPoint(p, len, &(data)->val[(data)->len], &l);
6914 0 : if(e) goto fail;
6915 0 : p += l; len -= l; ret += l;
6916 0 : (data)->len++;
6917 0 : len = Top_Tag_origlen - ret;
6918 : }
6919 0 : ret += Top_Tag_oldret;
6920 : }
6921 0 : if ((data)->len < 1) {
6922 0 : e = ASN1_MIN_CONSTRAINT; goto fail;
6923 : }
6924 0 : len = Top_oldlen - Top_datalen;
6925 : }
6926 0 : if(size) *size = ret;
6927 0 : return 0;
6928 0 : fail:
6929 0 : free_CRLDistributionPoints(data);
6930 0 : return e;
6931 : }
6932 :
6933 : void ASN1CALL
6934 0 : free_CRLDistributionPoints(CRLDistributionPoints *data)
6935 : {
6936 0 : while((data)->len){
6937 0 : free_DistributionPoint(&(data)->val[(data)->len-1]);
6938 0 : (data)->len--;
6939 : }
6940 0 : free((data)->val);
6941 0 : (data)->val = NULL;
6942 0 : }
6943 :
6944 : size_t ASN1CALL
6945 0 : length_CRLDistributionPoints(const CRLDistributionPoints *data)
6946 : {
6947 0 : size_t ret = 0;
6948 : {
6949 0 : size_t Top_tag_oldret = ret;
6950 : int i;
6951 0 : ret = 0;
6952 0 : for(i = (data)->len - 1; i >= 0; --i){
6953 0 : size_t Top_tag_for_oldret = ret;
6954 0 : ret = 0;
6955 0 : ret += length_DistributionPoint(&(data)->val[i]);
6956 0 : ret += Top_tag_for_oldret;
6957 : }
6958 0 : ret += Top_tag_oldret;
6959 : }
6960 0 : ret += 1 + der_length_len (ret);
6961 0 : return ret;
6962 : }
6963 :
6964 : int ASN1CALL
6965 0 : copy_CRLDistributionPoints(const CRLDistributionPoints *from, CRLDistributionPoints *to)
6966 : {
6967 0 : memset(to, 0, sizeof(*to));
6968 0 : if(((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
6969 0 : goto fail;
6970 0 : for((to)->len = 0; (to)->len < (from)->len; (to)->len++){
6971 0 : if(copy_DistributionPoint(&(from)->val[(to)->len], &(to)->val[(to)->len])) goto fail;
6972 : }
6973 0 : return 0;
6974 0 : fail:
6975 0 : free_CRLDistributionPoints(to);
6976 0 : return ENOMEM;
6977 : }
6978 :
6979 : int ASN1CALL
6980 0 : add_CRLDistributionPoints(CRLDistributionPoints *data, const DistributionPoint *element)
6981 : {
6982 : int ret;
6983 : void *ptr;
6984 :
6985 0 : ptr = realloc(data->val,
6986 0 : (data->len + 1) * sizeof(data->val[0]));
6987 0 : if (ptr == NULL) return ENOMEM;
6988 0 : data->val = ptr;
6989 :
6990 0 : ret = copy_DistributionPoint(element, &data->val[data->len]);
6991 0 : if (ret) return ret;
6992 0 : data->len++;
6993 0 : return 0;
6994 : }
6995 :
6996 : int ASN1CALL
6997 0 : remove_CRLDistributionPoints(CRLDistributionPoints *data, unsigned int element)
6998 : {
6999 : void *ptr;
7000 :
7001 0 : if (data->len == 0 || element >= data->len)
7002 0 : return ASN1_OVERRUN;
7003 0 : free_DistributionPoint(&data->val[element]);
7004 0 : data->len--;
7005 0 : if (element < data->len)
7006 0 : memmove(&data->val[element], &data->val[element + 1],
7007 0 : sizeof(data->val[0]) * data->len);
7008 0 : ptr = realloc(data->val, data->len * sizeof(data->val[0]));
7009 0 : if (ptr != NULL || data->len == 0) data->val = ptr;
7010 0 : return 0;
7011 : }
7012 :
7013 : int ASN1CALL
7014 0 : encode_DSASigValue(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const DSASigValue *data, size_t *size)
7015 : {
7016 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
7017 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
7018 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
7019 :
7020 : /* s */
7021 : {
7022 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
7023 0 : ret = 0;
7024 0 : e = der_put_heim_integer(p, len, &(data)->s, &l);
7025 0 : if (e) return e;
7026 0 : p -= l; len -= l; ret += l;
7027 :
7028 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
7029 0 : if (e) return e;
7030 0 : p -= l; len -= l; ret += l;
7031 :
7032 0 : ret += Top_tag_oldret;
7033 : }
7034 : /* r */
7035 : {
7036 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
7037 0 : ret = 0;
7038 0 : e = der_put_heim_integer(p, len, &(data)->r, &l);
7039 0 : if (e) return e;
7040 0 : p -= l; len -= l; ret += l;
7041 :
7042 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
7043 0 : if (e) return e;
7044 0 : p -= l; len -= l; ret += l;
7045 :
7046 0 : ret += Top_tag_oldret;
7047 : }
7048 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
7049 0 : if (e) return e;
7050 0 : p -= l; len -= l; ret += l;
7051 :
7052 0 : *size = ret;
7053 0 : return 0;
7054 : }
7055 :
7056 : int ASN1CALL
7057 0 : decode_DSASigValue(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, DSASigValue *data, size_t *size)
7058 : {
7059 0 : size_t ret = 0;
7060 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
7061 : int e HEIMDAL_UNUSED_ATTRIBUTE;
7062 :
7063 0 : memset(data, 0, sizeof(*data));
7064 : {
7065 : size_t Top_datalen, Top_oldlen;
7066 : Der_type Top_type;
7067 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
7068 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
7069 0 : if(e) goto fail;
7070 0 : p += l; len -= l; ret += l;
7071 0 : Top_oldlen = len;
7072 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7073 0 : len = Top_datalen;
7074 : {
7075 : size_t r_datalen, r_oldlen;
7076 : Der_type r_type;
7077 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &r_type, UT_Integer, &r_datalen, &l);
7078 0 : if (e == 0 && r_type != PRIM) { e = ASN1_BAD_ID; }
7079 0 : if(e) goto fail;
7080 0 : p += l; len -= l; ret += l;
7081 0 : r_oldlen = len;
7082 0 : if (r_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7083 0 : len = r_datalen;
7084 0 : e = der_get_heim_integer(p, len, &(data)->r, &l);
7085 0 : if(e) goto fail;
7086 0 : p += l; len -= l; ret += l;
7087 0 : len = r_oldlen - r_datalen;
7088 : }
7089 : {
7090 : size_t s_datalen, s_oldlen;
7091 : Der_type s_type;
7092 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &s_type, UT_Integer, &s_datalen, &l);
7093 0 : if (e == 0 && s_type != PRIM) { e = ASN1_BAD_ID; }
7094 0 : if(e) goto fail;
7095 0 : p += l; len -= l; ret += l;
7096 0 : s_oldlen = len;
7097 0 : if (s_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7098 0 : len = s_datalen;
7099 0 : e = der_get_heim_integer(p, len, &(data)->s, &l);
7100 0 : if(e) goto fail;
7101 0 : p += l; len -= l; ret += l;
7102 0 : len = s_oldlen - s_datalen;
7103 : }
7104 0 : len = Top_oldlen - Top_datalen;
7105 : }
7106 0 : if(size) *size = ret;
7107 0 : return 0;
7108 0 : fail:
7109 0 : free_DSASigValue(data);
7110 0 : return e;
7111 : }
7112 :
7113 : void ASN1CALL
7114 0 : free_DSASigValue(DSASigValue *data)
7115 : {
7116 0 : der_free_heim_integer(&(data)->r);
7117 0 : der_free_heim_integer(&(data)->s);
7118 0 : }
7119 :
7120 : size_t ASN1CALL
7121 0 : length_DSASigValue(const DSASigValue *data)
7122 : {
7123 0 : size_t ret = 0;
7124 : {
7125 0 : size_t Top_tag_oldret = ret;
7126 0 : ret = 0;
7127 0 : ret += der_length_heim_integer(&(data)->r);
7128 0 : ret += 1 + der_length_len (ret);
7129 0 : ret += Top_tag_oldret;
7130 : }
7131 : {
7132 0 : size_t Top_tag_oldret = ret;
7133 0 : ret = 0;
7134 0 : ret += der_length_heim_integer(&(data)->s);
7135 0 : ret += 1 + der_length_len (ret);
7136 0 : ret += Top_tag_oldret;
7137 : }
7138 0 : ret += 1 + der_length_len (ret);
7139 0 : return ret;
7140 : }
7141 :
7142 : int ASN1CALL
7143 0 : copy_DSASigValue(const DSASigValue *from, DSASigValue *to)
7144 : {
7145 0 : memset(to, 0, sizeof(*to));
7146 0 : if(der_copy_heim_integer(&(from)->r, &(to)->r)) goto fail;
7147 0 : if(der_copy_heim_integer(&(from)->s, &(to)->s)) goto fail;
7148 0 : return 0;
7149 0 : fail:
7150 0 : free_DSASigValue(to);
7151 0 : return ENOMEM;
7152 : }
7153 :
7154 : int ASN1CALL
7155 0 : encode_DSAPublicKey(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const DSAPublicKey *data, size_t *size)
7156 : {
7157 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
7158 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
7159 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
7160 :
7161 0 : e = der_put_heim_integer(p, len, data, &l);
7162 0 : if (e) return e;
7163 0 : p -= l; len -= l; ret += l;
7164 :
7165 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
7166 0 : if (e) return e;
7167 0 : p -= l; len -= l; ret += l;
7168 :
7169 0 : *size = ret;
7170 0 : return 0;
7171 : }
7172 :
7173 : int ASN1CALL
7174 0 : decode_DSAPublicKey(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, DSAPublicKey *data, size_t *size)
7175 : {
7176 0 : size_t ret = 0;
7177 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
7178 : int e HEIMDAL_UNUSED_ATTRIBUTE;
7179 :
7180 0 : memset(data, 0, sizeof(*data));
7181 : {
7182 : size_t Top_datalen, Top_oldlen;
7183 : Der_type Top_type;
7184 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Integer, &Top_datalen, &l);
7185 0 : if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
7186 0 : if(e) goto fail;
7187 0 : p += l; len -= l; ret += l;
7188 0 : Top_oldlen = len;
7189 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7190 0 : len = Top_datalen;
7191 0 : e = der_get_heim_integer(p, len, data, &l);
7192 0 : if(e) goto fail;
7193 0 : p += l; len -= l; ret += l;
7194 0 : len = Top_oldlen - Top_datalen;
7195 : }
7196 0 : if(size) *size = ret;
7197 0 : return 0;
7198 0 : fail:
7199 0 : free_DSAPublicKey(data);
7200 0 : return e;
7201 : }
7202 :
7203 : void ASN1CALL
7204 0 : free_DSAPublicKey(DSAPublicKey *data)
7205 : {
7206 0 : der_free_heim_integer(data);
7207 0 : }
7208 :
7209 : size_t ASN1CALL
7210 0 : length_DSAPublicKey(const DSAPublicKey *data)
7211 : {
7212 0 : size_t ret = 0;
7213 0 : ret += der_length_heim_integer(data);
7214 0 : ret += 1 + der_length_len (ret);
7215 0 : return ret;
7216 : }
7217 :
7218 : int ASN1CALL
7219 0 : copy_DSAPublicKey(const DSAPublicKey *from, DSAPublicKey *to)
7220 : {
7221 0 : memset(to, 0, sizeof(*to));
7222 0 : if(der_copy_heim_integer(from, to)) goto fail;
7223 0 : return 0;
7224 0 : fail:
7225 0 : free_DSAPublicKey(to);
7226 0 : return ENOMEM;
7227 : }
7228 :
7229 : int ASN1CALL
7230 0 : encode_DSAParams(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const DSAParams *data, size_t *size)
7231 : {
7232 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
7233 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
7234 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
7235 :
7236 : /* g */
7237 : {
7238 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
7239 0 : ret = 0;
7240 0 : e = der_put_heim_integer(p, len, &(data)->g, &l);
7241 0 : if (e) return e;
7242 0 : p -= l; len -= l; ret += l;
7243 :
7244 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
7245 0 : if (e) return e;
7246 0 : p -= l; len -= l; ret += l;
7247 :
7248 0 : ret += Top_tag_oldret;
7249 : }
7250 : /* q */
7251 : {
7252 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
7253 0 : ret = 0;
7254 0 : e = der_put_heim_integer(p, len, &(data)->q, &l);
7255 0 : if (e) return e;
7256 0 : p -= l; len -= l; ret += l;
7257 :
7258 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
7259 0 : if (e) return e;
7260 0 : p -= l; len -= l; ret += l;
7261 :
7262 0 : ret += Top_tag_oldret;
7263 : }
7264 : /* p */
7265 : {
7266 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
7267 0 : ret = 0;
7268 0 : e = der_put_heim_integer(p, len, &(data)->p, &l);
7269 0 : if (e) return e;
7270 0 : p -= l; len -= l; ret += l;
7271 :
7272 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
7273 0 : if (e) return e;
7274 0 : p -= l; len -= l; ret += l;
7275 :
7276 0 : ret += Top_tag_oldret;
7277 : }
7278 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
7279 0 : if (e) return e;
7280 0 : p -= l; len -= l; ret += l;
7281 :
7282 0 : *size = ret;
7283 0 : return 0;
7284 : }
7285 :
7286 : int ASN1CALL
7287 0 : decode_DSAParams(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, DSAParams *data, size_t *size)
7288 : {
7289 0 : size_t ret = 0;
7290 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
7291 : int e HEIMDAL_UNUSED_ATTRIBUTE;
7292 :
7293 0 : memset(data, 0, sizeof(*data));
7294 : {
7295 : size_t Top_datalen, Top_oldlen;
7296 : Der_type Top_type;
7297 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
7298 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
7299 0 : if(e) goto fail;
7300 0 : p += l; len -= l; ret += l;
7301 0 : Top_oldlen = len;
7302 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7303 0 : len = Top_datalen;
7304 : {
7305 : size_t p_datalen, p_oldlen;
7306 : Der_type p_type;
7307 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &p_type, UT_Integer, &p_datalen, &l);
7308 0 : if (e == 0 && p_type != PRIM) { e = ASN1_BAD_ID; }
7309 0 : if(e) goto fail;
7310 0 : p += l; len -= l; ret += l;
7311 0 : p_oldlen = len;
7312 0 : if (p_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7313 0 : len = p_datalen;
7314 0 : e = der_get_heim_integer(p, len, &(data)->p, &l);
7315 0 : if(e) goto fail;
7316 0 : p += l; len -= l; ret += l;
7317 0 : len = p_oldlen - p_datalen;
7318 : }
7319 : {
7320 : size_t q_datalen, q_oldlen;
7321 : Der_type q_type;
7322 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &q_type, UT_Integer, &q_datalen, &l);
7323 0 : if (e == 0 && q_type != PRIM) { e = ASN1_BAD_ID; }
7324 0 : if(e) goto fail;
7325 0 : p += l; len -= l; ret += l;
7326 0 : q_oldlen = len;
7327 0 : if (q_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7328 0 : len = q_datalen;
7329 0 : e = der_get_heim_integer(p, len, &(data)->q, &l);
7330 0 : if(e) goto fail;
7331 0 : p += l; len -= l; ret += l;
7332 0 : len = q_oldlen - q_datalen;
7333 : }
7334 : {
7335 : size_t g_datalen, g_oldlen;
7336 : Der_type g_type;
7337 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &g_type, UT_Integer, &g_datalen, &l);
7338 0 : if (e == 0 && g_type != PRIM) { e = ASN1_BAD_ID; }
7339 0 : if(e) goto fail;
7340 0 : p += l; len -= l; ret += l;
7341 0 : g_oldlen = len;
7342 0 : if (g_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7343 0 : len = g_datalen;
7344 0 : e = der_get_heim_integer(p, len, &(data)->g, &l);
7345 0 : if(e) goto fail;
7346 0 : p += l; len -= l; ret += l;
7347 0 : len = g_oldlen - g_datalen;
7348 : }
7349 0 : len = Top_oldlen - Top_datalen;
7350 : }
7351 0 : if(size) *size = ret;
7352 0 : return 0;
7353 0 : fail:
7354 0 : free_DSAParams(data);
7355 0 : return e;
7356 : }
7357 :
7358 : void ASN1CALL
7359 0 : free_DSAParams(DSAParams *data)
7360 : {
7361 0 : der_free_heim_integer(&(data)->p);
7362 0 : der_free_heim_integer(&(data)->q);
7363 0 : der_free_heim_integer(&(data)->g);
7364 0 : }
7365 :
7366 : size_t ASN1CALL
7367 0 : length_DSAParams(const DSAParams *data)
7368 : {
7369 0 : size_t ret = 0;
7370 : {
7371 0 : size_t Top_tag_oldret = ret;
7372 0 : ret = 0;
7373 0 : ret += der_length_heim_integer(&(data)->p);
7374 0 : ret += 1 + der_length_len (ret);
7375 0 : ret += Top_tag_oldret;
7376 : }
7377 : {
7378 0 : size_t Top_tag_oldret = ret;
7379 0 : ret = 0;
7380 0 : ret += der_length_heim_integer(&(data)->q);
7381 0 : ret += 1 + der_length_len (ret);
7382 0 : ret += Top_tag_oldret;
7383 : }
7384 : {
7385 0 : size_t Top_tag_oldret = ret;
7386 0 : ret = 0;
7387 0 : ret += der_length_heim_integer(&(data)->g);
7388 0 : ret += 1 + der_length_len (ret);
7389 0 : ret += Top_tag_oldret;
7390 : }
7391 0 : ret += 1 + der_length_len (ret);
7392 0 : return ret;
7393 : }
7394 :
7395 : int ASN1CALL
7396 0 : copy_DSAParams(const DSAParams *from, DSAParams *to)
7397 : {
7398 0 : memset(to, 0, sizeof(*to));
7399 0 : if(der_copy_heim_integer(&(from)->p, &(to)->p)) goto fail;
7400 0 : if(der_copy_heim_integer(&(from)->q, &(to)->q)) goto fail;
7401 0 : if(der_copy_heim_integer(&(from)->g, &(to)->g)) goto fail;
7402 0 : return 0;
7403 0 : fail:
7404 0 : free_DSAParams(to);
7405 0 : return ENOMEM;
7406 : }
7407 :
7408 : int ASN1CALL
7409 0 : encode_ECPoint(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const ECPoint *data, size_t *size)
7410 : {
7411 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
7412 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
7413 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
7414 :
7415 0 : e = der_put_octet_string(p, len, data, &l);
7416 0 : if (e) return e;
7417 0 : p -= l; len -= l; ret += l;
7418 :
7419 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
7420 0 : if (e) return e;
7421 0 : p -= l; len -= l; ret += l;
7422 :
7423 0 : *size = ret;
7424 0 : return 0;
7425 : }
7426 :
7427 : int ASN1CALL
7428 0 : decode_ECPoint(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, ECPoint *data, size_t *size)
7429 : {
7430 0 : size_t ret = 0;
7431 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
7432 : int e HEIMDAL_UNUSED_ATTRIBUTE;
7433 :
7434 0 : memset(data, 0, sizeof(*data));
7435 : {
7436 : size_t Top_datalen, Top_oldlen;
7437 : Der_type Top_type;
7438 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_OctetString, &Top_datalen, &l);
7439 0 : if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
7440 0 : if(e) goto fail;
7441 0 : p += l; len -= l; ret += l;
7442 0 : Top_oldlen = len;
7443 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7444 0 : len = Top_datalen;
7445 0 : e = der_get_octet_string(p, len, data, &l);
7446 0 : if(e) goto fail;
7447 0 : p += l; len -= l; ret += l;
7448 0 : len = Top_oldlen - Top_datalen;
7449 : }
7450 0 : if(size) *size = ret;
7451 0 : return 0;
7452 0 : fail:
7453 0 : free_ECPoint(data);
7454 0 : return e;
7455 : }
7456 :
7457 : void ASN1CALL
7458 0 : free_ECPoint(ECPoint *data)
7459 : {
7460 0 : der_free_octet_string(data);
7461 0 : }
7462 :
7463 : size_t ASN1CALL
7464 0 : length_ECPoint(const ECPoint *data)
7465 : {
7466 0 : size_t ret = 0;
7467 0 : ret += der_length_octet_string(data);
7468 0 : ret += 1 + der_length_len (ret);
7469 0 : return ret;
7470 : }
7471 :
7472 : int ASN1CALL
7473 0 : copy_ECPoint(const ECPoint *from, ECPoint *to)
7474 : {
7475 0 : memset(to, 0, sizeof(*to));
7476 0 : if(der_copy_octet_string(from, to)) goto fail;
7477 0 : return 0;
7478 0 : fail:
7479 0 : free_ECPoint(to);
7480 0 : return ENOMEM;
7481 : }
7482 :
7483 : int ASN1CALL
7484 0 : encode_ECParameters(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const ECParameters *data, size_t *size)
7485 : {
7486 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
7487 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
7488 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
7489 :
7490 :
7491 0 : switch((data)->element) {
7492 0 : case choice_ECParameters_namedCurve: {size_t Top_oldret = ret;
7493 0 : ret = 0;
7494 0 : e = der_put_oid(p, len, &((data))->u.namedCurve, &l);
7495 0 : if (e) return e;
7496 0 : p -= l; len -= l; ret += l;
7497 :
7498 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OID, &l);
7499 0 : if (e) return e;
7500 0 : p -= l; len -= l; ret += l;
7501 :
7502 0 : ret += Top_oldret;
7503 0 : break;
7504 : }
7505 : };
7506 0 : *size = ret;
7507 0 : return 0;
7508 : }
7509 :
7510 : int ASN1CALL
7511 0 : decode_ECParameters(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, ECParameters *data, size_t *size)
7512 : {
7513 0 : size_t ret = 0;
7514 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
7515 : int e HEIMDAL_UNUSED_ATTRIBUTE;
7516 :
7517 0 : memset(data, 0, sizeof(*data));
7518 0 : if (der_match_tag(p, len, ASN1_C_UNIV, PRIM, UT_OID, NULL) == 0) {
7519 : {
7520 : size_t namedCurve_datalen, namedCurve_oldlen;
7521 : Der_type namedCurve_type;
7522 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &namedCurve_type, UT_OID, &namedCurve_datalen, &l);
7523 0 : if (e == 0 && namedCurve_type != PRIM) { e = ASN1_BAD_ID; }
7524 0 : if(e) goto fail;
7525 0 : p += l; len -= l; ret += l;
7526 0 : namedCurve_oldlen = len;
7527 0 : if (namedCurve_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7528 0 : len = namedCurve_datalen;
7529 0 : e = der_get_oid(p, len, &(data)->u.namedCurve, &l);
7530 0 : if(e) goto fail;
7531 0 : p += l; len -= l; ret += l;
7532 0 : len = namedCurve_oldlen - namedCurve_datalen;
7533 : }
7534 0 : (data)->element = choice_ECParameters_namedCurve;
7535 : }
7536 : else {
7537 0 : e = ASN1_PARSE_ERROR;
7538 0 : goto fail;
7539 : }
7540 0 : if(size) *size = ret;
7541 0 : return 0;
7542 0 : fail:
7543 0 : free_ECParameters(data);
7544 0 : return e;
7545 : }
7546 :
7547 : void ASN1CALL
7548 0 : free_ECParameters(ECParameters *data)
7549 : {
7550 0 : switch((data)->element) {
7551 0 : case choice_ECParameters_namedCurve:
7552 0 : der_free_oid(&(data)->u.namedCurve);
7553 0 : break;
7554 : }
7555 0 : }
7556 :
7557 : size_t ASN1CALL
7558 0 : length_ECParameters(const ECParameters *data)
7559 : {
7560 0 : size_t ret = 0;
7561 0 : switch((data)->element) {
7562 0 : case choice_ECParameters_namedCurve:
7563 : {
7564 0 : size_t Top_oldret = ret;
7565 0 : ret = 0;
7566 0 : ret += der_length_oid(&(data)->u.namedCurve);
7567 0 : ret += 1 + der_length_len (ret);
7568 0 : ret += Top_oldret;
7569 : }
7570 0 : break;
7571 : }
7572 0 : return ret;
7573 : }
7574 :
7575 : int ASN1CALL
7576 0 : copy_ECParameters(const ECParameters *from, ECParameters *to)
7577 : {
7578 0 : memset(to, 0, sizeof(*to));
7579 0 : (to)->element = (from)->element;
7580 0 : switch((from)->element) {
7581 0 : case choice_ECParameters_namedCurve:
7582 0 : if(der_copy_oid(&(from)->u.namedCurve, &(to)->u.namedCurve)) goto fail;
7583 0 : break;
7584 : }
7585 0 : return 0;
7586 0 : fail:
7587 0 : free_ECParameters(to);
7588 0 : return ENOMEM;
7589 : }
7590 :
7591 : int ASN1CALL
7592 0 : encode_ECDSA_Sig_Value(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const ECDSA_Sig_Value *data, size_t *size)
7593 : {
7594 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
7595 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
7596 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
7597 :
7598 : /* s */
7599 : {
7600 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
7601 0 : ret = 0;
7602 0 : e = der_put_heim_integer(p, len, &(data)->s, &l);
7603 0 : if (e) return e;
7604 0 : p -= l; len -= l; ret += l;
7605 :
7606 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
7607 0 : if (e) return e;
7608 0 : p -= l; len -= l; ret += l;
7609 :
7610 0 : ret += Top_tag_oldret;
7611 : }
7612 : /* r */
7613 : {
7614 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
7615 0 : ret = 0;
7616 0 : e = der_put_heim_integer(p, len, &(data)->r, &l);
7617 0 : if (e) return e;
7618 0 : p -= l; len -= l; ret += l;
7619 :
7620 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
7621 0 : if (e) return e;
7622 0 : p -= l; len -= l; ret += l;
7623 :
7624 0 : ret += Top_tag_oldret;
7625 : }
7626 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
7627 0 : if (e) return e;
7628 0 : p -= l; len -= l; ret += l;
7629 :
7630 0 : *size = ret;
7631 0 : return 0;
7632 : }
7633 :
7634 : int ASN1CALL
7635 0 : decode_ECDSA_Sig_Value(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, ECDSA_Sig_Value *data, size_t *size)
7636 : {
7637 0 : size_t ret = 0;
7638 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
7639 : int e HEIMDAL_UNUSED_ATTRIBUTE;
7640 :
7641 0 : memset(data, 0, sizeof(*data));
7642 : {
7643 : size_t Top_datalen, Top_oldlen;
7644 : Der_type Top_type;
7645 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
7646 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
7647 0 : if(e) goto fail;
7648 0 : p += l; len -= l; ret += l;
7649 0 : Top_oldlen = len;
7650 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7651 0 : len = Top_datalen;
7652 : {
7653 : size_t r_datalen, r_oldlen;
7654 : Der_type r_type;
7655 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &r_type, UT_Integer, &r_datalen, &l);
7656 0 : if (e == 0 && r_type != PRIM) { e = ASN1_BAD_ID; }
7657 0 : if(e) goto fail;
7658 0 : p += l; len -= l; ret += l;
7659 0 : r_oldlen = len;
7660 0 : if (r_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7661 0 : len = r_datalen;
7662 0 : e = der_get_heim_integer(p, len, &(data)->r, &l);
7663 0 : if(e) goto fail;
7664 0 : p += l; len -= l; ret += l;
7665 0 : len = r_oldlen - r_datalen;
7666 : }
7667 : {
7668 : size_t s_datalen, s_oldlen;
7669 : Der_type s_type;
7670 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &s_type, UT_Integer, &s_datalen, &l);
7671 0 : if (e == 0 && s_type != PRIM) { e = ASN1_BAD_ID; }
7672 0 : if(e) goto fail;
7673 0 : p += l; len -= l; ret += l;
7674 0 : s_oldlen = len;
7675 0 : if (s_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7676 0 : len = s_datalen;
7677 0 : e = der_get_heim_integer(p, len, &(data)->s, &l);
7678 0 : if(e) goto fail;
7679 0 : p += l; len -= l; ret += l;
7680 0 : len = s_oldlen - s_datalen;
7681 : }
7682 0 : len = Top_oldlen - Top_datalen;
7683 : }
7684 0 : if(size) *size = ret;
7685 0 : return 0;
7686 0 : fail:
7687 0 : free_ECDSA_Sig_Value(data);
7688 0 : return e;
7689 : }
7690 :
7691 : void ASN1CALL
7692 0 : free_ECDSA_Sig_Value(ECDSA_Sig_Value *data)
7693 : {
7694 0 : der_free_heim_integer(&(data)->r);
7695 0 : der_free_heim_integer(&(data)->s);
7696 0 : }
7697 :
7698 : size_t ASN1CALL
7699 0 : length_ECDSA_Sig_Value(const ECDSA_Sig_Value *data)
7700 : {
7701 0 : size_t ret = 0;
7702 : {
7703 0 : size_t Top_tag_oldret = ret;
7704 0 : ret = 0;
7705 0 : ret += der_length_heim_integer(&(data)->r);
7706 0 : ret += 1 + der_length_len (ret);
7707 0 : ret += Top_tag_oldret;
7708 : }
7709 : {
7710 0 : size_t Top_tag_oldret = ret;
7711 0 : ret = 0;
7712 0 : ret += der_length_heim_integer(&(data)->s);
7713 0 : ret += 1 + der_length_len (ret);
7714 0 : ret += Top_tag_oldret;
7715 : }
7716 0 : ret += 1 + der_length_len (ret);
7717 0 : return ret;
7718 : }
7719 :
7720 : int ASN1CALL
7721 0 : copy_ECDSA_Sig_Value(const ECDSA_Sig_Value *from, ECDSA_Sig_Value *to)
7722 : {
7723 0 : memset(to, 0, sizeof(*to));
7724 0 : if(der_copy_heim_integer(&(from)->r, &(to)->r)) goto fail;
7725 0 : if(der_copy_heim_integer(&(from)->s, &(to)->s)) goto fail;
7726 0 : return 0;
7727 0 : fail:
7728 0 : free_ECDSA_Sig_Value(to);
7729 0 : return ENOMEM;
7730 : }
7731 :
7732 : int ASN1CALL
7733 0 : encode_RSAPublicKey(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const RSAPublicKey *data, size_t *size)
7734 : {
7735 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
7736 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
7737 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
7738 :
7739 : /* publicExponent */
7740 : {
7741 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
7742 0 : ret = 0;
7743 0 : e = der_put_heim_integer(p, len, &(data)->publicExponent, &l);
7744 0 : if (e) return e;
7745 0 : p -= l; len -= l; ret += l;
7746 :
7747 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
7748 0 : if (e) return e;
7749 0 : p -= l; len -= l; ret += l;
7750 :
7751 0 : ret += Top_tag_oldret;
7752 : }
7753 : /* modulus */
7754 : {
7755 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
7756 0 : ret = 0;
7757 0 : e = der_put_heim_integer(p, len, &(data)->modulus, &l);
7758 0 : if (e) return e;
7759 0 : p -= l; len -= l; ret += l;
7760 :
7761 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
7762 0 : if (e) return e;
7763 0 : p -= l; len -= l; ret += l;
7764 :
7765 0 : ret += Top_tag_oldret;
7766 : }
7767 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
7768 0 : if (e) return e;
7769 0 : p -= l; len -= l; ret += l;
7770 :
7771 0 : *size = ret;
7772 0 : return 0;
7773 : }
7774 :
7775 : int ASN1CALL
7776 274 : decode_RSAPublicKey(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, RSAPublicKey *data, size_t *size)
7777 : {
7778 274 : size_t ret = 0;
7779 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
7780 : int e HEIMDAL_UNUSED_ATTRIBUTE;
7781 :
7782 274 : memset(data, 0, sizeof(*data));
7783 : {
7784 : size_t Top_datalen, Top_oldlen;
7785 : Der_type Top_type;
7786 274 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
7787 274 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
7788 274 : if(e) goto fail;
7789 274 : p += l; len -= l; ret += l;
7790 274 : Top_oldlen = len;
7791 274 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7792 274 : len = Top_datalen;
7793 : {
7794 : size_t modulus_datalen, modulus_oldlen;
7795 : Der_type modulus_type;
7796 274 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &modulus_type, UT_Integer, &modulus_datalen, &l);
7797 274 : if (e == 0 && modulus_type != PRIM) { e = ASN1_BAD_ID; }
7798 274 : if(e) goto fail;
7799 274 : p += l; len -= l; ret += l;
7800 274 : modulus_oldlen = len;
7801 274 : if (modulus_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7802 274 : len = modulus_datalen;
7803 274 : e = der_get_heim_integer(p, len, &(data)->modulus, &l);
7804 274 : if(e) goto fail;
7805 274 : p += l; len -= l; ret += l;
7806 274 : len = modulus_oldlen - modulus_datalen;
7807 : }
7808 : {
7809 : size_t publicExponent_datalen, publicExponent_oldlen;
7810 : Der_type publicExponent_type;
7811 274 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &publicExponent_type, UT_Integer, &publicExponent_datalen, &l);
7812 540 : if (e == 0 && publicExponent_type != PRIM) { e = ASN1_BAD_ID; }
7813 274 : if(e) goto fail;
7814 274 : p += l; len -= l; ret += l;
7815 274 : publicExponent_oldlen = len;
7816 274 : if (publicExponent_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7817 274 : len = publicExponent_datalen;
7818 274 : e = der_get_heim_integer(p, len, &(data)->publicExponent, &l);
7819 274 : if(e) goto fail;
7820 274 : p += l; len -= l; ret += l;
7821 274 : len = publicExponent_oldlen - publicExponent_datalen;
7822 : }
7823 274 : len = Top_oldlen - Top_datalen;
7824 : }
7825 548 : if(size) *size = ret;
7826 266 : return 0;
7827 0 : fail:
7828 0 : free_RSAPublicKey(data);
7829 0 : return e;
7830 : }
7831 :
7832 : void ASN1CALL
7833 274 : free_RSAPublicKey(RSAPublicKey *data)
7834 : {
7835 274 : der_free_heim_integer(&(data)->modulus);
7836 274 : der_free_heim_integer(&(data)->publicExponent);
7837 274 : }
7838 :
7839 : size_t ASN1CALL
7840 0 : length_RSAPublicKey(const RSAPublicKey *data)
7841 : {
7842 0 : size_t ret = 0;
7843 : {
7844 0 : size_t Top_tag_oldret = ret;
7845 0 : ret = 0;
7846 0 : ret += der_length_heim_integer(&(data)->modulus);
7847 0 : ret += 1 + der_length_len (ret);
7848 0 : ret += Top_tag_oldret;
7849 : }
7850 : {
7851 0 : size_t Top_tag_oldret = ret;
7852 0 : ret = 0;
7853 0 : ret += der_length_heim_integer(&(data)->publicExponent);
7854 0 : ret += 1 + der_length_len (ret);
7855 0 : ret += Top_tag_oldret;
7856 : }
7857 0 : ret += 1 + der_length_len (ret);
7858 0 : return ret;
7859 : }
7860 :
7861 : int ASN1CALL
7862 0 : copy_RSAPublicKey(const RSAPublicKey *from, RSAPublicKey *to)
7863 : {
7864 0 : memset(to, 0, sizeof(*to));
7865 0 : if(der_copy_heim_integer(&(from)->modulus, &(to)->modulus)) goto fail;
7866 0 : if(der_copy_heim_integer(&(from)->publicExponent, &(to)->publicExponent)) goto fail;
7867 0 : return 0;
7868 0 : fail:
7869 0 : free_RSAPublicKey(to);
7870 0 : return ENOMEM;
7871 : }
7872 :
7873 : int ASN1CALL
7874 0 : encode_RSAPrivateKey(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const RSAPrivateKey *data, size_t *size)
7875 : {
7876 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
7877 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
7878 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
7879 :
7880 : /* coefficient */
7881 : {
7882 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
7883 0 : ret = 0;
7884 0 : e = der_put_heim_integer(p, len, &(data)->coefficient, &l);
7885 0 : if (e) return e;
7886 0 : p -= l; len -= l; ret += l;
7887 :
7888 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
7889 0 : if (e) return e;
7890 0 : p -= l; len -= l; ret += l;
7891 :
7892 0 : ret += Top_tag_oldret;
7893 : }
7894 : /* exponent2 */
7895 : {
7896 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
7897 0 : ret = 0;
7898 0 : e = der_put_heim_integer(p, len, &(data)->exponent2, &l);
7899 0 : if (e) return e;
7900 0 : p -= l; len -= l; ret += l;
7901 :
7902 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
7903 0 : if (e) return e;
7904 0 : p -= l; len -= l; ret += l;
7905 :
7906 0 : ret += Top_tag_oldret;
7907 : }
7908 : /* exponent1 */
7909 : {
7910 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
7911 0 : ret = 0;
7912 0 : e = der_put_heim_integer(p, len, &(data)->exponent1, &l);
7913 0 : if (e) return e;
7914 0 : p -= l; len -= l; ret += l;
7915 :
7916 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
7917 0 : if (e) return e;
7918 0 : p -= l; len -= l; ret += l;
7919 :
7920 0 : ret += Top_tag_oldret;
7921 : }
7922 : /* prime2 */
7923 : {
7924 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
7925 0 : ret = 0;
7926 0 : e = der_put_heim_integer(p, len, &(data)->prime2, &l);
7927 0 : if (e) return e;
7928 0 : p -= l; len -= l; ret += l;
7929 :
7930 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
7931 0 : if (e) return e;
7932 0 : p -= l; len -= l; ret += l;
7933 :
7934 0 : ret += Top_tag_oldret;
7935 : }
7936 : /* prime1 */
7937 : {
7938 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
7939 0 : ret = 0;
7940 0 : e = der_put_heim_integer(p, len, &(data)->prime1, &l);
7941 0 : if (e) return e;
7942 0 : p -= l; len -= l; ret += l;
7943 :
7944 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
7945 0 : if (e) return e;
7946 0 : p -= l; len -= l; ret += l;
7947 :
7948 0 : ret += Top_tag_oldret;
7949 : }
7950 : /* privateExponent */
7951 : {
7952 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
7953 0 : ret = 0;
7954 0 : e = der_put_heim_integer(p, len, &(data)->privateExponent, &l);
7955 0 : if (e) return e;
7956 0 : p -= l; len -= l; ret += l;
7957 :
7958 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
7959 0 : if (e) return e;
7960 0 : p -= l; len -= l; ret += l;
7961 :
7962 0 : ret += Top_tag_oldret;
7963 : }
7964 : /* publicExponent */
7965 : {
7966 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
7967 0 : ret = 0;
7968 0 : e = der_put_heim_integer(p, len, &(data)->publicExponent, &l);
7969 0 : if (e) return e;
7970 0 : p -= l; len -= l; ret += l;
7971 :
7972 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
7973 0 : if (e) return e;
7974 0 : p -= l; len -= l; ret += l;
7975 :
7976 0 : ret += Top_tag_oldret;
7977 : }
7978 : /* modulus */
7979 : {
7980 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
7981 0 : ret = 0;
7982 0 : e = der_put_heim_integer(p, len, &(data)->modulus, &l);
7983 0 : if (e) return e;
7984 0 : p -= l; len -= l; ret += l;
7985 :
7986 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
7987 0 : if (e) return e;
7988 0 : p -= l; len -= l; ret += l;
7989 :
7990 0 : ret += Top_tag_oldret;
7991 : }
7992 : /* version */
7993 : {
7994 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
7995 0 : ret = 0;
7996 0 : e = der_put_unsigned(p, len, &(data)->version, &l);
7997 0 : if (e) return e;
7998 0 : p -= l; len -= l; ret += l;
7999 :
8000 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
8001 0 : if (e) return e;
8002 0 : p -= l; len -= l; ret += l;
8003 :
8004 0 : ret += Top_tag_oldret;
8005 : }
8006 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
8007 0 : if (e) return e;
8008 0 : p -= l; len -= l; ret += l;
8009 :
8010 0 : *size = ret;
8011 0 : return 0;
8012 : }
8013 :
8014 : int ASN1CALL
8015 94 : decode_RSAPrivateKey(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, RSAPrivateKey *data, size_t *size)
8016 : {
8017 94 : size_t ret = 0;
8018 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
8019 : int e HEIMDAL_UNUSED_ATTRIBUTE;
8020 :
8021 94 : memset(data, 0, sizeof(*data));
8022 : {
8023 : size_t Top_datalen, Top_oldlen;
8024 : Der_type Top_type;
8025 94 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
8026 94 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
8027 94 : if(e) goto fail;
8028 94 : p += l; len -= l; ret += l;
8029 94 : Top_oldlen = len;
8030 94 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
8031 94 : len = Top_datalen;
8032 : {
8033 : size_t version_datalen, version_oldlen;
8034 : Der_type version_type;
8035 94 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &version_type, UT_Integer, &version_datalen, &l);
8036 94 : if (e == 0 && version_type != PRIM) { e = ASN1_BAD_ID; }
8037 94 : if(e) goto fail;
8038 94 : p += l; len -= l; ret += l;
8039 94 : version_oldlen = len;
8040 94 : if (version_datalen > len) { e = ASN1_OVERRUN; goto fail; }
8041 94 : len = version_datalen;
8042 94 : e = der_get_unsigned(p, len, &(data)->version, &l);
8043 94 : if(e) goto fail;
8044 94 : p += l; len -= l; ret += l;
8045 94 : len = version_oldlen - version_datalen;
8046 : }
8047 : {
8048 : size_t modulus_datalen, modulus_oldlen;
8049 : Der_type modulus_type;
8050 94 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &modulus_type, UT_Integer, &modulus_datalen, &l);
8051 180 : if (e == 0 && modulus_type != PRIM) { e = ASN1_BAD_ID; }
8052 94 : if(e) goto fail;
8053 94 : p += l; len -= l; ret += l;
8054 94 : modulus_oldlen = len;
8055 94 : if (modulus_datalen > len) { e = ASN1_OVERRUN; goto fail; }
8056 94 : len = modulus_datalen;
8057 94 : e = der_get_heim_integer(p, len, &(data)->modulus, &l);
8058 94 : if(e) goto fail;
8059 94 : p += l; len -= l; ret += l;
8060 94 : len = modulus_oldlen - modulus_datalen;
8061 : }
8062 : {
8063 : size_t publicExponent_datalen, publicExponent_oldlen;
8064 : Der_type publicExponent_type;
8065 94 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &publicExponent_type, UT_Integer, &publicExponent_datalen, &l);
8066 180 : if (e == 0 && publicExponent_type != PRIM) { e = ASN1_BAD_ID; }
8067 94 : if(e) goto fail;
8068 94 : p += l; len -= l; ret += l;
8069 94 : publicExponent_oldlen = len;
8070 94 : if (publicExponent_datalen > len) { e = ASN1_OVERRUN; goto fail; }
8071 94 : len = publicExponent_datalen;
8072 94 : e = der_get_heim_integer(p, len, &(data)->publicExponent, &l);
8073 94 : if(e) goto fail;
8074 94 : p += l; len -= l; ret += l;
8075 94 : len = publicExponent_oldlen - publicExponent_datalen;
8076 : }
8077 : {
8078 : size_t privateExponent_datalen, privateExponent_oldlen;
8079 : Der_type privateExponent_type;
8080 94 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &privateExponent_type, UT_Integer, &privateExponent_datalen, &l);
8081 180 : if (e == 0 && privateExponent_type != PRIM) { e = ASN1_BAD_ID; }
8082 94 : if(e) goto fail;
8083 94 : p += l; len -= l; ret += l;
8084 94 : privateExponent_oldlen = len;
8085 94 : if (privateExponent_datalen > len) { e = ASN1_OVERRUN; goto fail; }
8086 94 : len = privateExponent_datalen;
8087 94 : e = der_get_heim_integer(p, len, &(data)->privateExponent, &l);
8088 94 : if(e) goto fail;
8089 94 : p += l; len -= l; ret += l;
8090 94 : len = privateExponent_oldlen - privateExponent_datalen;
8091 : }
8092 : {
8093 : size_t prime1_datalen, prime1_oldlen;
8094 : Der_type prime1_type;
8095 94 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &prime1_type, UT_Integer, &prime1_datalen, &l);
8096 180 : if (e == 0 && prime1_type != PRIM) { e = ASN1_BAD_ID; }
8097 94 : if(e) goto fail;
8098 94 : p += l; len -= l; ret += l;
8099 94 : prime1_oldlen = len;
8100 94 : if (prime1_datalen > len) { e = ASN1_OVERRUN; goto fail; }
8101 94 : len = prime1_datalen;
8102 94 : e = der_get_heim_integer(p, len, &(data)->prime1, &l);
8103 94 : if(e) goto fail;
8104 94 : p += l; len -= l; ret += l;
8105 94 : len = prime1_oldlen - prime1_datalen;
8106 : }
8107 : {
8108 : size_t prime2_datalen, prime2_oldlen;
8109 : Der_type prime2_type;
8110 94 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &prime2_type, UT_Integer, &prime2_datalen, &l);
8111 180 : if (e == 0 && prime2_type != PRIM) { e = ASN1_BAD_ID; }
8112 94 : if(e) goto fail;
8113 94 : p += l; len -= l; ret += l;
8114 94 : prime2_oldlen = len;
8115 94 : if (prime2_datalen > len) { e = ASN1_OVERRUN; goto fail; }
8116 94 : len = prime2_datalen;
8117 94 : e = der_get_heim_integer(p, len, &(data)->prime2, &l);
8118 94 : if(e) goto fail;
8119 94 : p += l; len -= l; ret += l;
8120 94 : len = prime2_oldlen - prime2_datalen;
8121 : }
8122 : {
8123 : size_t exponent1_datalen, exponent1_oldlen;
8124 : Der_type exponent1_type;
8125 94 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &exponent1_type, UT_Integer, &exponent1_datalen, &l);
8126 180 : if (e == 0 && exponent1_type != PRIM) { e = ASN1_BAD_ID; }
8127 94 : if(e) goto fail;
8128 94 : p += l; len -= l; ret += l;
8129 94 : exponent1_oldlen = len;
8130 94 : if (exponent1_datalen > len) { e = ASN1_OVERRUN; goto fail; }
8131 94 : len = exponent1_datalen;
8132 94 : e = der_get_heim_integer(p, len, &(data)->exponent1, &l);
8133 94 : if(e) goto fail;
8134 94 : p += l; len -= l; ret += l;
8135 94 : len = exponent1_oldlen - exponent1_datalen;
8136 : }
8137 : {
8138 : size_t exponent2_datalen, exponent2_oldlen;
8139 : Der_type exponent2_type;
8140 94 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &exponent2_type, UT_Integer, &exponent2_datalen, &l);
8141 180 : if (e == 0 && exponent2_type != PRIM) { e = ASN1_BAD_ID; }
8142 94 : if(e) goto fail;
8143 94 : p += l; len -= l; ret += l;
8144 94 : exponent2_oldlen = len;
8145 94 : if (exponent2_datalen > len) { e = ASN1_OVERRUN; goto fail; }
8146 94 : len = exponent2_datalen;
8147 94 : e = der_get_heim_integer(p, len, &(data)->exponent2, &l);
8148 94 : if(e) goto fail;
8149 94 : p += l; len -= l; ret += l;
8150 94 : len = exponent2_oldlen - exponent2_datalen;
8151 : }
8152 : {
8153 : size_t coefficient_datalen, coefficient_oldlen;
8154 : Der_type coefficient_type;
8155 94 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &coefficient_type, UT_Integer, &coefficient_datalen, &l);
8156 180 : if (e == 0 && coefficient_type != PRIM) { e = ASN1_BAD_ID; }
8157 94 : if(e) goto fail;
8158 94 : p += l; len -= l; ret += l;
8159 94 : coefficient_oldlen = len;
8160 94 : if (coefficient_datalen > len) { e = ASN1_OVERRUN; goto fail; }
8161 94 : len = coefficient_datalen;
8162 94 : e = der_get_heim_integer(p, len, &(data)->coefficient, &l);
8163 94 : if(e) goto fail;
8164 94 : p += l; len -= l; ret += l;
8165 94 : len = coefficient_oldlen - coefficient_datalen;
8166 : }
8167 94 : len = Top_oldlen - Top_datalen;
8168 : }
8169 188 : if(size) *size = ret;
8170 86 : return 0;
8171 0 : fail:
8172 0 : free_RSAPrivateKey(data);
8173 0 : return e;
8174 : }
8175 :
8176 : void ASN1CALL
8177 94 : free_RSAPrivateKey(RSAPrivateKey *data)
8178 : {
8179 94 : der_free_heim_integer(&(data)->modulus);
8180 94 : der_free_heim_integer(&(data)->publicExponent);
8181 94 : der_free_heim_integer(&(data)->privateExponent);
8182 94 : der_free_heim_integer(&(data)->prime1);
8183 94 : der_free_heim_integer(&(data)->prime2);
8184 94 : der_free_heim_integer(&(data)->exponent1);
8185 94 : der_free_heim_integer(&(data)->exponent2);
8186 94 : der_free_heim_integer(&(data)->coefficient);
8187 94 : }
8188 :
8189 : size_t ASN1CALL
8190 0 : length_RSAPrivateKey(const RSAPrivateKey *data)
8191 : {
8192 0 : size_t ret = 0;
8193 : {
8194 0 : size_t Top_tag_oldret = ret;
8195 0 : ret = 0;
8196 0 : ret += der_length_unsigned(&(data)->version);
8197 0 : ret += 1 + der_length_len (ret);
8198 0 : ret += Top_tag_oldret;
8199 : }
8200 : {
8201 0 : size_t Top_tag_oldret = ret;
8202 0 : ret = 0;
8203 0 : ret += der_length_heim_integer(&(data)->modulus);
8204 0 : ret += 1 + der_length_len (ret);
8205 0 : ret += Top_tag_oldret;
8206 : }
8207 : {
8208 0 : size_t Top_tag_oldret = ret;
8209 0 : ret = 0;
8210 0 : ret += der_length_heim_integer(&(data)->publicExponent);
8211 0 : ret += 1 + der_length_len (ret);
8212 0 : ret += Top_tag_oldret;
8213 : }
8214 : {
8215 0 : size_t Top_tag_oldret = ret;
8216 0 : ret = 0;
8217 0 : ret += der_length_heim_integer(&(data)->privateExponent);
8218 0 : ret += 1 + der_length_len (ret);
8219 0 : ret += Top_tag_oldret;
8220 : }
8221 : {
8222 0 : size_t Top_tag_oldret = ret;
8223 0 : ret = 0;
8224 0 : ret += der_length_heim_integer(&(data)->prime1);
8225 0 : ret += 1 + der_length_len (ret);
8226 0 : ret += Top_tag_oldret;
8227 : }
8228 : {
8229 0 : size_t Top_tag_oldret = ret;
8230 0 : ret = 0;
8231 0 : ret += der_length_heim_integer(&(data)->prime2);
8232 0 : ret += 1 + der_length_len (ret);
8233 0 : ret += Top_tag_oldret;
8234 : }
8235 : {
8236 0 : size_t Top_tag_oldret = ret;
8237 0 : ret = 0;
8238 0 : ret += der_length_heim_integer(&(data)->exponent1);
8239 0 : ret += 1 + der_length_len (ret);
8240 0 : ret += Top_tag_oldret;
8241 : }
8242 : {
8243 0 : size_t Top_tag_oldret = ret;
8244 0 : ret = 0;
8245 0 : ret += der_length_heim_integer(&(data)->exponent2);
8246 0 : ret += 1 + der_length_len (ret);
8247 0 : ret += Top_tag_oldret;
8248 : }
8249 : {
8250 0 : size_t Top_tag_oldret = ret;
8251 0 : ret = 0;
8252 0 : ret += der_length_heim_integer(&(data)->coefficient);
8253 0 : ret += 1 + der_length_len (ret);
8254 0 : ret += Top_tag_oldret;
8255 : }
8256 0 : ret += 1 + der_length_len (ret);
8257 0 : return ret;
8258 : }
8259 :
8260 : int ASN1CALL
8261 0 : copy_RSAPrivateKey(const RSAPrivateKey *from, RSAPrivateKey *to)
8262 : {
8263 0 : memset(to, 0, sizeof(*to));
8264 0 : *(&(to)->version) = *(&(from)->version);
8265 0 : if(der_copy_heim_integer(&(from)->modulus, &(to)->modulus)) goto fail;
8266 0 : if(der_copy_heim_integer(&(from)->publicExponent, &(to)->publicExponent)) goto fail;
8267 0 : if(der_copy_heim_integer(&(from)->privateExponent, &(to)->privateExponent)) goto fail;
8268 0 : if(der_copy_heim_integer(&(from)->prime1, &(to)->prime1)) goto fail;
8269 0 : if(der_copy_heim_integer(&(from)->prime2, &(to)->prime2)) goto fail;
8270 0 : if(der_copy_heim_integer(&(from)->exponent1, &(to)->exponent1)) goto fail;
8271 0 : if(der_copy_heim_integer(&(from)->exponent2, &(to)->exponent2)) goto fail;
8272 0 : if(der_copy_heim_integer(&(from)->coefficient, &(to)->coefficient)) goto fail;
8273 0 : return 0;
8274 0 : fail:
8275 0 : free_RSAPrivateKey(to);
8276 0 : return ENOMEM;
8277 : }
8278 :
8279 : int ASN1CALL
8280 66 : encode_DigestInfo(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const DigestInfo *data, size_t *size)
8281 : {
8282 66 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
8283 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
8284 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
8285 :
8286 : /* digest */
8287 : {
8288 66 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
8289 66 : ret = 0;
8290 66 : e = der_put_octet_string(p, len, &(data)->digest, &l);
8291 66 : if (e) return e;
8292 66 : p -= l; len -= l; ret += l;
8293 :
8294 66 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
8295 66 : if (e) return e;
8296 66 : p -= l; len -= l; ret += l;
8297 :
8298 66 : ret += Top_tag_oldret;
8299 : }
8300 : /* digestAlgorithm */
8301 : {
8302 66 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
8303 66 : ret = 0;
8304 66 : e = encode_AlgorithmIdentifier(p, len, &(data)->digestAlgorithm, &l);
8305 66 : if (e) return e;
8306 66 : p -= l; len -= l; ret += l;
8307 :
8308 66 : ret += Top_tag_oldret;
8309 : }
8310 66 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
8311 66 : if (e) return e;
8312 66 : p -= l; len -= l; ret += l;
8313 :
8314 66 : *size = ret;
8315 66 : return 0;
8316 : }
8317 :
8318 : int ASN1CALL
8319 180 : decode_DigestInfo(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, DigestInfo *data, size_t *size)
8320 : {
8321 180 : size_t ret = 0;
8322 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
8323 : int e HEIMDAL_UNUSED_ATTRIBUTE;
8324 :
8325 180 : memset(data, 0, sizeof(*data));
8326 : {
8327 : size_t Top_datalen, Top_oldlen;
8328 : Der_type Top_type;
8329 180 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
8330 180 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
8331 180 : if(e) goto fail;
8332 180 : p += l; len -= l; ret += l;
8333 180 : Top_oldlen = len;
8334 180 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
8335 180 : len = Top_datalen;
8336 180 : e = decode_AlgorithmIdentifier(p, len, &(data)->digestAlgorithm, &l);
8337 180 : if(e) goto fail;
8338 180 : p += l; len -= l; ret += l;
8339 : {
8340 : size_t digest_datalen, digest_oldlen;
8341 : Der_type digest_type;
8342 180 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &digest_type, UT_OctetString, &digest_datalen, &l);
8343 180 : if (e == 0 && digest_type != PRIM) { e = ASN1_BAD_ID; }
8344 180 : if(e) goto fail;
8345 180 : p += l; len -= l; ret += l;
8346 180 : digest_oldlen = len;
8347 180 : if (digest_datalen > len) { e = ASN1_OVERRUN; goto fail; }
8348 180 : len = digest_datalen;
8349 180 : e = der_get_octet_string(p, len, &(data)->digest, &l);
8350 180 : if(e) goto fail;
8351 180 : p += l; len -= l; ret += l;
8352 180 : len = digest_oldlen - digest_datalen;
8353 : }
8354 180 : len = Top_oldlen - Top_datalen;
8355 : }
8356 360 : if(size) *size = ret;
8357 180 : return 0;
8358 0 : fail:
8359 0 : free_DigestInfo(data);
8360 0 : return e;
8361 : }
8362 :
8363 : void ASN1CALL
8364 246 : free_DigestInfo(DigestInfo *data)
8365 : {
8366 246 : free_AlgorithmIdentifier(&(data)->digestAlgorithm);
8367 246 : der_free_octet_string(&(data)->digest);
8368 246 : }
8369 :
8370 : size_t ASN1CALL
8371 66 : length_DigestInfo(const DigestInfo *data)
8372 : {
8373 66 : size_t ret = 0;
8374 : {
8375 66 : size_t Top_tag_oldret = ret;
8376 66 : ret = 0;
8377 66 : ret += length_AlgorithmIdentifier(&(data)->digestAlgorithm);
8378 66 : ret += Top_tag_oldret;
8379 : }
8380 : {
8381 66 : size_t Top_tag_oldret = ret;
8382 66 : ret = 0;
8383 66 : ret += der_length_octet_string(&(data)->digest);
8384 66 : ret += 1 + der_length_len (ret);
8385 66 : ret += Top_tag_oldret;
8386 : }
8387 66 : ret += 1 + der_length_len (ret);
8388 66 : return ret;
8389 : }
8390 :
8391 : int ASN1CALL
8392 0 : copy_DigestInfo(const DigestInfo *from, DigestInfo *to)
8393 : {
8394 0 : memset(to, 0, sizeof(*to));
8395 0 : if(copy_AlgorithmIdentifier(&(from)->digestAlgorithm, &(to)->digestAlgorithm)) goto fail;
8396 0 : if(der_copy_octet_string(&(from)->digest, &(to)->digest)) goto fail;
8397 0 : return 0;
8398 0 : fail:
8399 0 : free_DigestInfo(to);
8400 0 : return ENOMEM;
8401 : }
8402 :
8403 : int ASN1CALL
8404 0 : encode_TBSCRLCertList(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const TBSCRLCertList *data, size_t *size)
8405 : {
8406 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
8407 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
8408 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
8409 :
8410 : /* crlExtensions */
8411 0 : if((data)->crlExtensions) {
8412 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
8413 0 : ret = 0;
8414 0 : e = encode_Extensions(p, len, (data)->crlExtensions, &l);
8415 0 : if (e) return e;
8416 0 : p -= l; len -= l; ret += l;
8417 :
8418 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
8419 0 : if (e) return e;
8420 0 : p -= l; len -= l; ret += l;
8421 :
8422 0 : ret += Top_tag_oldret;
8423 : }
8424 : /* revokedCertificates */
8425 0 : if((data)->revokedCertificates) {
8426 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
8427 0 : ret = 0;
8428 0 : for(i = (int)((data)->revokedCertificates)->len - 1; i >= 0; --i) {
8429 0 : size_t revokedCertificates_tag_for_oldret = ret;
8430 0 : ret = 0;
8431 : /* crlEntryExtensions */
8432 0 : if((&((data)->revokedCertificates)->val[i])->crlEntryExtensions) {
8433 0 : size_t revokedCertificates_tag_S_Of_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
8434 0 : ret = 0;
8435 0 : e = encode_Extensions(p, len, (&((data)->revokedCertificates)->val[i])->crlEntryExtensions, &l);
8436 0 : if (e) return e;
8437 0 : p -= l; len -= l; ret += l;
8438 :
8439 0 : ret += revokedCertificates_tag_S_Of_tag_oldret;
8440 : }
8441 : /* revocationDate */
8442 : {
8443 0 : size_t revokedCertificates_tag_S_Of_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
8444 0 : ret = 0;
8445 0 : e = encode_Time(p, len, &(&((data)->revokedCertificates)->val[i])->revocationDate, &l);
8446 0 : if (e) return e;
8447 0 : p -= l; len -= l; ret += l;
8448 :
8449 0 : ret += revokedCertificates_tag_S_Of_tag_oldret;
8450 : }
8451 : /* userCertificate */
8452 : {
8453 0 : size_t revokedCertificates_tag_S_Of_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
8454 0 : ret = 0;
8455 0 : e = encode_CertificateSerialNumber(p, len, &(&((data)->revokedCertificates)->val[i])->userCertificate, &l);
8456 0 : if (e) return e;
8457 0 : p -= l; len -= l; ret += l;
8458 :
8459 0 : ret += revokedCertificates_tag_S_Of_tag_oldret;
8460 : }
8461 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
8462 0 : if (e) return e;
8463 0 : p -= l; len -= l; ret += l;
8464 :
8465 0 : ret += revokedCertificates_tag_for_oldret;
8466 : }
8467 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
8468 0 : if (e) return e;
8469 0 : p -= l; len -= l; ret += l;
8470 :
8471 0 : ret += Top_tag_oldret;
8472 : }
8473 : /* nextUpdate */
8474 0 : if((data)->nextUpdate) {
8475 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
8476 0 : ret = 0;
8477 0 : e = encode_Time(p, len, (data)->nextUpdate, &l);
8478 0 : if (e) return e;
8479 0 : p -= l; len -= l; ret += l;
8480 :
8481 0 : ret += Top_tag_oldret;
8482 : }
8483 : /* thisUpdate */
8484 : {
8485 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
8486 0 : ret = 0;
8487 0 : e = encode_Time(p, len, &(data)->thisUpdate, &l);
8488 0 : if (e) return e;
8489 0 : p -= l; len -= l; ret += l;
8490 :
8491 0 : ret += Top_tag_oldret;
8492 : }
8493 : /* issuer */
8494 : {
8495 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
8496 0 : ret = 0;
8497 0 : e = encode_Name(p, len, &(data)->issuer, &l);
8498 0 : if (e) return e;
8499 0 : p -= l; len -= l; ret += l;
8500 :
8501 0 : ret += Top_tag_oldret;
8502 : }
8503 : /* signature */
8504 : {
8505 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
8506 0 : ret = 0;
8507 0 : e = encode_AlgorithmIdentifier(p, len, &(data)->signature, &l);
8508 0 : if (e) return e;
8509 0 : p -= l; len -= l; ret += l;
8510 :
8511 0 : ret += Top_tag_oldret;
8512 : }
8513 : /* version */
8514 0 : if((data)->version) {
8515 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
8516 0 : ret = 0;
8517 0 : e = encode_Version(p, len, (data)->version, &l);
8518 0 : if (e) return e;
8519 0 : p -= l; len -= l; ret += l;
8520 :
8521 0 : ret += Top_tag_oldret;
8522 : }
8523 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
8524 0 : if (e) return e;
8525 0 : p -= l; len -= l; ret += l;
8526 :
8527 0 : *size = ret;
8528 0 : return 0;
8529 : }
8530 :
8531 : int ASN1CALL
8532 0 : decode_TBSCRLCertList(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, TBSCRLCertList *data, size_t *size)
8533 : {
8534 0 : size_t ret = 0;
8535 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
8536 : int e HEIMDAL_UNUSED_ATTRIBUTE;
8537 0 : const unsigned char *begin = p;
8538 :
8539 0 : memset(data, 0, sizeof(*data));
8540 : {
8541 : size_t Top_datalen, Top_oldlen;
8542 : Der_type Top_type;
8543 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
8544 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
8545 0 : if(e) goto fail;
8546 0 : p += l; len -= l; ret += l;
8547 0 : Top_oldlen = len;
8548 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
8549 0 : len = Top_datalen;
8550 0 : (data)->version = calloc(1, sizeof(*(data)->version));
8551 0 : if ((data)->version == NULL) goto fail;
8552 0 : e = decode_Version(p, len, (data)->version, &l);
8553 0 : if(e) {
8554 0 : free((data)->version);
8555 0 : (data)->version = NULL;
8556 : } else {
8557 0 : p += l; len -= l; ret += l;
8558 : }
8559 0 : e = decode_AlgorithmIdentifier(p, len, &(data)->signature, &l);
8560 0 : if(e) goto fail;
8561 0 : p += l; len -= l; ret += l;
8562 0 : e = decode_Name(p, len, &(data)->issuer, &l);
8563 0 : if(e) goto fail;
8564 0 : p += l; len -= l; ret += l;
8565 0 : e = decode_Time(p, len, &(data)->thisUpdate, &l);
8566 0 : if(e) goto fail;
8567 0 : p += l; len -= l; ret += l;
8568 0 : (data)->nextUpdate = calloc(1, sizeof(*(data)->nextUpdate));
8569 0 : if ((data)->nextUpdate == NULL) goto fail;
8570 0 : e = decode_Time(p, len, (data)->nextUpdate, &l);
8571 0 : if(e) {
8572 0 : free((data)->nextUpdate);
8573 0 : (data)->nextUpdate = NULL;
8574 : } else {
8575 0 : p += l; len -= l; ret += l;
8576 : }
8577 : {
8578 : size_t revokedCertificates_datalen, revokedCertificates_oldlen;
8579 : Der_type revokedCertificates_type;
8580 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &revokedCertificates_type, UT_Sequence, &revokedCertificates_datalen, &l);
8581 0 : if (e == 0 && revokedCertificates_type != CONS) { e = ASN1_BAD_ID; }
8582 0 : if(e) {
8583 0 : (data)->revokedCertificates = NULL;
8584 : } else {
8585 0 : (data)->revokedCertificates = calloc(1, sizeof(*(data)->revokedCertificates));
8586 0 : if ((data)->revokedCertificates == NULL) { e = ENOMEM; goto fail; }
8587 0 : p += l; len -= l; ret += l;
8588 0 : revokedCertificates_oldlen = len;
8589 0 : if (revokedCertificates_datalen > len) { e = ASN1_OVERRUN; goto fail; }
8590 0 : len = revokedCertificates_datalen;
8591 : {
8592 0 : size_t revokedCertificates_Tag_origlen = len;
8593 0 : size_t revokedCertificates_Tag_oldret = ret;
8594 0 : size_t revokedCertificates_Tag_olen = 0;
8595 : void *revokedCertificates_Tag_tmp;
8596 0 : ret = 0;
8597 0 : ((data)->revokedCertificates)->len = 0;
8598 0 : ((data)->revokedCertificates)->val = NULL;
8599 0 : while(ret < revokedCertificates_Tag_origlen) {
8600 0 : size_t revokedCertificates_Tag_nlen = revokedCertificates_Tag_olen + sizeof(*(((data)->revokedCertificates)->val));
8601 0 : if (revokedCertificates_Tag_olen > revokedCertificates_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
8602 0 : revokedCertificates_Tag_olen = revokedCertificates_Tag_nlen;
8603 0 : revokedCertificates_Tag_tmp = realloc(((data)->revokedCertificates)->val, revokedCertificates_Tag_olen);
8604 0 : if (revokedCertificates_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
8605 0 : ((data)->revokedCertificates)->val = revokedCertificates_Tag_tmp;
8606 : {
8607 : size_t revokedCertificates_Tag_s_of_datalen, revokedCertificates_Tag_s_of_oldlen;
8608 : Der_type revokedCertificates_Tag_s_of_type;
8609 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &revokedCertificates_Tag_s_of_type, UT_Sequence, &revokedCertificates_Tag_s_of_datalen, &l);
8610 0 : if (e == 0 && revokedCertificates_Tag_s_of_type != CONS) { e = ASN1_BAD_ID; }
8611 0 : if(e) goto fail;
8612 0 : p += l; len -= l; ret += l;
8613 0 : revokedCertificates_Tag_s_of_oldlen = len;
8614 0 : if (revokedCertificates_Tag_s_of_datalen > len) { e = ASN1_OVERRUN; goto fail; }
8615 0 : len = revokedCertificates_Tag_s_of_datalen;
8616 0 : e = decode_CertificateSerialNumber(p, len, &(&((data)->revokedCertificates)->val[((data)->revokedCertificates)->len])->userCertificate, &l);
8617 0 : if(e) goto fail;
8618 0 : p += l; len -= l; ret += l;
8619 0 : e = decode_Time(p, len, &(&((data)->revokedCertificates)->val[((data)->revokedCertificates)->len])->revocationDate, &l);
8620 0 : if(e) goto fail;
8621 0 : p += l; len -= l; ret += l;
8622 0 : (&((data)->revokedCertificates)->val[((data)->revokedCertificates)->len])->crlEntryExtensions = calloc(1, sizeof(*(&((data)->revokedCertificates)->val[((data)->revokedCertificates)->len])->crlEntryExtensions));
8623 0 : if ((&((data)->revokedCertificates)->val[((data)->revokedCertificates)->len])->crlEntryExtensions == NULL) goto fail;
8624 0 : e = decode_Extensions(p, len, (&((data)->revokedCertificates)->val[((data)->revokedCertificates)->len])->crlEntryExtensions, &l);
8625 0 : if(e) {
8626 0 : free((&((data)->revokedCertificates)->val[((data)->revokedCertificates)->len])->crlEntryExtensions);
8627 0 : (&((data)->revokedCertificates)->val[((data)->revokedCertificates)->len])->crlEntryExtensions = NULL;
8628 : } else {
8629 0 : p += l; len -= l; ret += l;
8630 : }
8631 0 : len = revokedCertificates_Tag_s_of_oldlen - revokedCertificates_Tag_s_of_datalen;
8632 : }
8633 0 : ((data)->revokedCertificates)->len++;
8634 0 : len = revokedCertificates_Tag_origlen - ret;
8635 : }
8636 0 : ret += revokedCertificates_Tag_oldret;
8637 : }
8638 0 : len = revokedCertificates_oldlen - revokedCertificates_datalen;
8639 : }
8640 : }
8641 : {
8642 : size_t crlExtensions_datalen, crlExtensions_oldlen;
8643 : Der_type crlExtensions_type;
8644 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &crlExtensions_type, 0, &crlExtensions_datalen, &l);
8645 0 : if (e == 0 && crlExtensions_type != CONS) { e = ASN1_BAD_ID; }
8646 0 : if(e) {
8647 0 : (data)->crlExtensions = NULL;
8648 : } else {
8649 0 : (data)->crlExtensions = calloc(1, sizeof(*(data)->crlExtensions));
8650 0 : if ((data)->crlExtensions == NULL) { e = ENOMEM; goto fail; }
8651 0 : p += l; len -= l; ret += l;
8652 0 : crlExtensions_oldlen = len;
8653 0 : if (crlExtensions_datalen > len) { e = ASN1_OVERRUN; goto fail; }
8654 0 : len = crlExtensions_datalen;
8655 0 : e = decode_Extensions(p, len, (data)->crlExtensions, &l);
8656 0 : if(e) goto fail;
8657 0 : p += l; len -= l; ret += l;
8658 0 : len = crlExtensions_oldlen - crlExtensions_datalen;
8659 : }
8660 : }
8661 0 : len = Top_oldlen - Top_datalen;
8662 : }
8663 0 : data->_save.data = calloc(1, ret);
8664 0 : if (data->_save.data == NULL) {
8665 0 : e = ENOMEM; goto fail;
8666 : }
8667 0 : data->_save.length = ret;
8668 0 : memcpy(data->_save.data, begin, ret);
8669 0 : if(size) *size = ret;
8670 0 : return 0;
8671 0 : fail:
8672 0 : free_TBSCRLCertList(data);
8673 0 : return e;
8674 : }
8675 :
8676 : void ASN1CALL
8677 0 : free_TBSCRLCertList(TBSCRLCertList *data)
8678 : {
8679 0 : der_free_octet_string(&data->_save);
8680 0 : if((data)->version) {
8681 0 : free_Version((data)->version);
8682 0 : free((data)->version);
8683 0 : (data)->version = NULL;
8684 : }
8685 0 : free_AlgorithmIdentifier(&(data)->signature);
8686 0 : free_Name(&(data)->issuer);
8687 0 : free_Time(&(data)->thisUpdate);
8688 0 : if((data)->nextUpdate) {
8689 0 : free_Time((data)->nextUpdate);
8690 0 : free((data)->nextUpdate);
8691 0 : (data)->nextUpdate = NULL;
8692 : }
8693 0 : if((data)->revokedCertificates) {
8694 0 : while(((data)->revokedCertificates)->len){
8695 0 : free_CertificateSerialNumber(&(&((data)->revokedCertificates)->val[((data)->revokedCertificates)->len-1])->userCertificate);
8696 0 : free_Time(&(&((data)->revokedCertificates)->val[((data)->revokedCertificates)->len-1])->revocationDate);
8697 0 : if((&((data)->revokedCertificates)->val[((data)->revokedCertificates)->len-1])->crlEntryExtensions) {
8698 0 : free_Extensions((&((data)->revokedCertificates)->val[((data)->revokedCertificates)->len-1])->crlEntryExtensions);
8699 0 : free((&((data)->revokedCertificates)->val[((data)->revokedCertificates)->len-1])->crlEntryExtensions);
8700 0 : (&((data)->revokedCertificates)->val[((data)->revokedCertificates)->len-1])->crlEntryExtensions = NULL;
8701 : }
8702 0 : ((data)->revokedCertificates)->len--;
8703 : }
8704 0 : free(((data)->revokedCertificates)->val);
8705 0 : ((data)->revokedCertificates)->val = NULL;
8706 0 : free((data)->revokedCertificates);
8707 0 : (data)->revokedCertificates = NULL;
8708 : }
8709 0 : if((data)->crlExtensions) {
8710 0 : free_Extensions((data)->crlExtensions);
8711 0 : free((data)->crlExtensions);
8712 0 : (data)->crlExtensions = NULL;
8713 : }
8714 0 : }
8715 :
8716 : size_t ASN1CALL
8717 0 : length_TBSCRLCertList(const TBSCRLCertList *data)
8718 : {
8719 0 : size_t ret = 0;
8720 0 : if((data)->version){
8721 0 : size_t Top_tag_oldret = ret;
8722 0 : ret = 0;
8723 0 : ret += length_Version((data)->version);
8724 0 : ret += Top_tag_oldret;
8725 : }
8726 : {
8727 0 : size_t Top_tag_oldret = ret;
8728 0 : ret = 0;
8729 0 : ret += length_AlgorithmIdentifier(&(data)->signature);
8730 0 : ret += Top_tag_oldret;
8731 : }
8732 : {
8733 0 : size_t Top_tag_oldret = ret;
8734 0 : ret = 0;
8735 0 : ret += length_Name(&(data)->issuer);
8736 0 : ret += Top_tag_oldret;
8737 : }
8738 : {
8739 0 : size_t Top_tag_oldret = ret;
8740 0 : ret = 0;
8741 0 : ret += length_Time(&(data)->thisUpdate);
8742 0 : ret += Top_tag_oldret;
8743 : }
8744 0 : if((data)->nextUpdate){
8745 0 : size_t Top_tag_oldret = ret;
8746 0 : ret = 0;
8747 0 : ret += length_Time((data)->nextUpdate);
8748 0 : ret += Top_tag_oldret;
8749 : }
8750 0 : if((data)->revokedCertificates){
8751 0 : size_t Top_tag_oldret = ret;
8752 0 : ret = 0;
8753 : {
8754 0 : size_t revokedCertificates_tag_oldret = ret;
8755 : int i;
8756 0 : ret = 0;
8757 0 : for(i = ((data)->revokedCertificates)->len - 1; i >= 0; --i){
8758 0 : size_t revokedCertificates_tag_for_oldret = ret;
8759 0 : ret = 0;
8760 : {
8761 0 : size_t revokedCertificates_tag_S_Of_tag_oldret = ret;
8762 0 : ret = 0;
8763 0 : ret += length_CertificateSerialNumber(&(&((data)->revokedCertificates)->val[i])->userCertificate);
8764 0 : ret += revokedCertificates_tag_S_Of_tag_oldret;
8765 : }
8766 : {
8767 0 : size_t revokedCertificates_tag_S_Of_tag_oldret = ret;
8768 0 : ret = 0;
8769 0 : ret += length_Time(&(&((data)->revokedCertificates)->val[i])->revocationDate);
8770 0 : ret += revokedCertificates_tag_S_Of_tag_oldret;
8771 : }
8772 0 : if((&((data)->revokedCertificates)->val[i])->crlEntryExtensions){
8773 0 : size_t revokedCertificates_tag_S_Of_tag_oldret = ret;
8774 0 : ret = 0;
8775 0 : ret += length_Extensions((&((data)->revokedCertificates)->val[i])->crlEntryExtensions);
8776 0 : ret += revokedCertificates_tag_S_Of_tag_oldret;
8777 : }
8778 0 : ret += 1 + der_length_len (ret);
8779 0 : ret += revokedCertificates_tag_for_oldret;
8780 : }
8781 0 : ret += revokedCertificates_tag_oldret;
8782 : }
8783 0 : ret += 1 + der_length_len (ret);
8784 0 : ret += Top_tag_oldret;
8785 : }
8786 0 : if((data)->crlExtensions){
8787 0 : size_t Top_tag_oldret = ret;
8788 0 : ret = 0;
8789 0 : ret += length_Extensions((data)->crlExtensions);
8790 0 : ret += 1 + der_length_len (ret);
8791 0 : ret += Top_tag_oldret;
8792 : }
8793 0 : ret += 1 + der_length_len (ret);
8794 0 : return ret;
8795 : }
8796 :
8797 : int ASN1CALL
8798 0 : copy_TBSCRLCertList(const TBSCRLCertList *from, TBSCRLCertList *to)
8799 : {
8800 0 : memset(to, 0, sizeof(*to));
8801 : { int ret;
8802 0 : ret = der_copy_octet_string(&(from)->_save, &(to)->_save);
8803 0 : if (ret) goto fail;
8804 : }
8805 0 : if((from)->version) {
8806 0 : (to)->version = malloc(sizeof(*(to)->version));
8807 0 : if((to)->version == NULL) goto fail;
8808 0 : if(copy_Version((from)->version, (to)->version)) goto fail;
8809 : }else
8810 0 : (to)->version = NULL;
8811 0 : if(copy_AlgorithmIdentifier(&(from)->signature, &(to)->signature)) goto fail;
8812 0 : if(copy_Name(&(from)->issuer, &(to)->issuer)) goto fail;
8813 0 : if(copy_Time(&(from)->thisUpdate, &(to)->thisUpdate)) goto fail;
8814 0 : if((from)->nextUpdate) {
8815 0 : (to)->nextUpdate = malloc(sizeof(*(to)->nextUpdate));
8816 0 : if((to)->nextUpdate == NULL) goto fail;
8817 0 : if(copy_Time((from)->nextUpdate, (to)->nextUpdate)) goto fail;
8818 : }else
8819 0 : (to)->nextUpdate = NULL;
8820 0 : if((from)->revokedCertificates) {
8821 0 : (to)->revokedCertificates = malloc(sizeof(*(to)->revokedCertificates));
8822 0 : if((to)->revokedCertificates == NULL) goto fail;
8823 0 : if((((to)->revokedCertificates)->val = malloc(((from)->revokedCertificates)->len * sizeof(*((to)->revokedCertificates)->val))) == NULL && ((from)->revokedCertificates)->len != 0)
8824 0 : goto fail;
8825 0 : for(((to)->revokedCertificates)->len = 0; ((to)->revokedCertificates)->len < ((from)->revokedCertificates)->len; ((to)->revokedCertificates)->len++){
8826 0 : if(copy_CertificateSerialNumber(&(&((from)->revokedCertificates)->val[((to)->revokedCertificates)->len])->userCertificate, &(&((to)->revokedCertificates)->val[((to)->revokedCertificates)->len])->userCertificate)) goto fail;
8827 0 : if(copy_Time(&(&((from)->revokedCertificates)->val[((to)->revokedCertificates)->len])->revocationDate, &(&((to)->revokedCertificates)->val[((to)->revokedCertificates)->len])->revocationDate)) goto fail;
8828 0 : if((&((from)->revokedCertificates)->val[((to)->revokedCertificates)->len])->crlEntryExtensions) {
8829 0 : (&((to)->revokedCertificates)->val[((to)->revokedCertificates)->len])->crlEntryExtensions = malloc(sizeof(*(&((to)->revokedCertificates)->val[((to)->revokedCertificates)->len])->crlEntryExtensions));
8830 0 : if((&((to)->revokedCertificates)->val[((to)->revokedCertificates)->len])->crlEntryExtensions == NULL) goto fail;
8831 0 : if(copy_Extensions((&((from)->revokedCertificates)->val[((to)->revokedCertificates)->len])->crlEntryExtensions, (&((to)->revokedCertificates)->val[((to)->revokedCertificates)->len])->crlEntryExtensions)) goto fail;
8832 : }else
8833 0 : (&((to)->revokedCertificates)->val[((to)->revokedCertificates)->len])->crlEntryExtensions = NULL;
8834 : }
8835 : }else
8836 0 : (to)->revokedCertificates = NULL;
8837 0 : if((from)->crlExtensions) {
8838 0 : (to)->crlExtensions = malloc(sizeof(*(to)->crlExtensions));
8839 0 : if((to)->crlExtensions == NULL) goto fail;
8840 0 : if(copy_Extensions((from)->crlExtensions, (to)->crlExtensions)) goto fail;
8841 : }else
8842 0 : (to)->crlExtensions = NULL;
8843 0 : return 0;
8844 0 : fail:
8845 0 : free_TBSCRLCertList(to);
8846 0 : return ENOMEM;
8847 : }
8848 :
8849 : int ASN1CALL
8850 0 : encode_CRLCertificateList(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const CRLCertificateList *data, size_t *size)
8851 : {
8852 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
8853 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
8854 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
8855 :
8856 : /* signatureValue */
8857 : {
8858 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
8859 0 : ret = 0;
8860 0 : e = der_put_bit_string(p, len, &(data)->signatureValue, &l);
8861 0 : if (e) return e;
8862 0 : p -= l; len -= l; ret += l;
8863 :
8864 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_BitString, &l);
8865 0 : if (e) return e;
8866 0 : p -= l; len -= l; ret += l;
8867 :
8868 0 : ret += Top_tag_oldret;
8869 : }
8870 : /* signatureAlgorithm */
8871 : {
8872 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
8873 0 : ret = 0;
8874 0 : e = encode_AlgorithmIdentifier(p, len, &(data)->signatureAlgorithm, &l);
8875 0 : if (e) return e;
8876 0 : p -= l; len -= l; ret += l;
8877 :
8878 0 : ret += Top_tag_oldret;
8879 : }
8880 : /* tbsCertList */
8881 : {
8882 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
8883 0 : ret = 0;
8884 0 : e = encode_TBSCRLCertList(p, len, &(data)->tbsCertList, &l);
8885 0 : if (e) return e;
8886 0 : p -= l; len -= l; ret += l;
8887 :
8888 0 : ret += Top_tag_oldret;
8889 : }
8890 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
8891 0 : if (e) return e;
8892 0 : p -= l; len -= l; ret += l;
8893 :
8894 0 : *size = ret;
8895 0 : return 0;
8896 : }
8897 :
8898 : int ASN1CALL
8899 0 : decode_CRLCertificateList(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, CRLCertificateList *data, size_t *size)
8900 : {
8901 0 : size_t ret = 0;
8902 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
8903 : int e HEIMDAL_UNUSED_ATTRIBUTE;
8904 :
8905 0 : memset(data, 0, sizeof(*data));
8906 : {
8907 : size_t Top_datalen, Top_oldlen;
8908 : Der_type Top_type;
8909 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
8910 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
8911 0 : if(e) goto fail;
8912 0 : p += l; len -= l; ret += l;
8913 0 : Top_oldlen = len;
8914 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
8915 0 : len = Top_datalen;
8916 0 : e = decode_TBSCRLCertList(p, len, &(data)->tbsCertList, &l);
8917 0 : if(e) goto fail;
8918 0 : p += l; len -= l; ret += l;
8919 0 : e = decode_AlgorithmIdentifier(p, len, &(data)->signatureAlgorithm, &l);
8920 0 : if(e) goto fail;
8921 0 : p += l; len -= l; ret += l;
8922 : {
8923 : size_t signatureValue_datalen, signatureValue_oldlen;
8924 : Der_type signatureValue_type;
8925 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &signatureValue_type, UT_BitString, &signatureValue_datalen, &l);
8926 0 : if (e == 0 && signatureValue_type != PRIM) { e = ASN1_BAD_ID; }
8927 0 : if(e) goto fail;
8928 0 : p += l; len -= l; ret += l;
8929 0 : signatureValue_oldlen = len;
8930 0 : if (signatureValue_datalen > len) { e = ASN1_OVERRUN; goto fail; }
8931 0 : len = signatureValue_datalen;
8932 0 : e = der_get_bit_string(p, len, &(data)->signatureValue, &l);
8933 0 : if(e) goto fail;
8934 0 : p += l; len -= l; ret += l;
8935 0 : len = signatureValue_oldlen - signatureValue_datalen;
8936 : }
8937 0 : len = Top_oldlen - Top_datalen;
8938 : }
8939 0 : if(size) *size = ret;
8940 0 : return 0;
8941 0 : fail:
8942 0 : free_CRLCertificateList(data);
8943 0 : return e;
8944 : }
8945 :
8946 : void ASN1CALL
8947 0 : free_CRLCertificateList(CRLCertificateList *data)
8948 : {
8949 0 : free_TBSCRLCertList(&(data)->tbsCertList);
8950 0 : free_AlgorithmIdentifier(&(data)->signatureAlgorithm);
8951 0 : der_free_bit_string(&(data)->signatureValue);
8952 0 : }
8953 :
8954 : size_t ASN1CALL
8955 0 : length_CRLCertificateList(const CRLCertificateList *data)
8956 : {
8957 0 : size_t ret = 0;
8958 : {
8959 0 : size_t Top_tag_oldret = ret;
8960 0 : ret = 0;
8961 0 : ret += length_TBSCRLCertList(&(data)->tbsCertList);
8962 0 : ret += Top_tag_oldret;
8963 : }
8964 : {
8965 0 : size_t Top_tag_oldret = ret;
8966 0 : ret = 0;
8967 0 : ret += length_AlgorithmIdentifier(&(data)->signatureAlgorithm);
8968 0 : ret += Top_tag_oldret;
8969 : }
8970 : {
8971 0 : size_t Top_tag_oldret = ret;
8972 0 : ret = 0;
8973 0 : ret += der_length_bit_string(&(data)->signatureValue);
8974 0 : ret += 1 + der_length_len (ret);
8975 0 : ret += Top_tag_oldret;
8976 : }
8977 0 : ret += 1 + der_length_len (ret);
8978 0 : return ret;
8979 : }
8980 :
8981 : int ASN1CALL
8982 0 : copy_CRLCertificateList(const CRLCertificateList *from, CRLCertificateList *to)
8983 : {
8984 0 : memset(to, 0, sizeof(*to));
8985 0 : if(copy_TBSCRLCertList(&(from)->tbsCertList, &(to)->tbsCertList)) goto fail;
8986 0 : if(copy_AlgorithmIdentifier(&(from)->signatureAlgorithm, &(to)->signatureAlgorithm)) goto fail;
8987 0 : if(der_copy_bit_string(&(from)->signatureValue, &(to)->signatureValue)) goto fail;
8988 0 : return 0;
8989 0 : fail:
8990 0 : free_CRLCertificateList(to);
8991 0 : return ENOMEM;
8992 : }
8993 :
8994 : static unsigned oid_id_x509_ce_cRLNumber_variable_num[4] = {2, 5, 29, 20 };
8995 : const heim_oid asn1_oid_id_x509_ce_cRLNumber = { 4, oid_id_x509_ce_cRLNumber_variable_num };
8996 :
8997 : static unsigned oid_id_x509_ce_freshestCRL_variable_num[4] = {2, 5, 29, 46 };
8998 : const heim_oid asn1_oid_id_x509_ce_freshestCRL = { 4, oid_id_x509_ce_freshestCRL_variable_num };
8999 :
9000 : static unsigned oid_id_x509_ce_cRLReason_variable_num[4] = {2, 5, 29, 21 };
9001 : const heim_oid asn1_oid_id_x509_ce_cRLReason = { 4, oid_id_x509_ce_cRLReason_variable_num };
9002 :
9003 : int ASN1CALL
9004 0 : encode_CRLReason(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const CRLReason *data, size_t *size)
9005 : {
9006 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
9007 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
9008 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
9009 :
9010 : {
9011 0 : int enumint = (int)*data;
9012 0 : e = der_put_integer(p, len, &enumint, &l);
9013 0 : if (e) return e;
9014 0 : p -= l; len -= l; ret += l;
9015 :
9016 : }
9017 0 : ;e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Enumerated, &l);
9018 0 : if (e) return e;
9019 0 : p -= l; len -= l; ret += l;
9020 :
9021 0 : *size = ret;
9022 0 : return 0;
9023 : }
9024 :
9025 : int ASN1CALL
9026 0 : decode_CRLReason(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, CRLReason *data, size_t *size)
9027 : {
9028 0 : size_t ret = 0;
9029 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
9030 : int e HEIMDAL_UNUSED_ATTRIBUTE;
9031 :
9032 0 : memset(data, 0, sizeof(*data));
9033 : {
9034 : size_t Top_datalen, Top_oldlen;
9035 : Der_type Top_type;
9036 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Enumerated, &Top_datalen, &l);
9037 0 : if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
9038 0 : if(e) goto fail;
9039 0 : p += l; len -= l; ret += l;
9040 0 : Top_oldlen = len;
9041 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9042 0 : len = Top_datalen;
9043 : {
9044 : int enumint;
9045 0 : e = der_get_integer(p, len, &enumint, &l);
9046 0 : if(e) goto fail;
9047 0 : p += l; len -= l; ret += l;
9048 0 : *data = enumint;
9049 : }
9050 0 : len = Top_oldlen - Top_datalen;
9051 : }
9052 0 : if(size) *size = ret;
9053 0 : return 0;
9054 0 : fail:
9055 0 : free_CRLReason(data);
9056 0 : return e;
9057 : }
9058 :
9059 : void ASN1CALL
9060 0 : free_CRLReason(CRLReason *data)
9061 : {
9062 0 : }
9063 :
9064 : size_t ASN1CALL
9065 0 : length_CRLReason(const CRLReason *data)
9066 : {
9067 0 : size_t ret = 0;
9068 : {
9069 0 : int enumint = *data;
9070 0 : ret += der_length_integer(&enumint);
9071 : }
9072 0 : ret += 1 + der_length_len (ret);
9073 0 : return ret;
9074 : }
9075 :
9076 : int ASN1CALL
9077 0 : copy_CRLReason(const CRLReason *from, CRLReason *to)
9078 : {
9079 0 : memset(to, 0, sizeof(*to));
9080 0 : *(to) = *(from);
9081 0 : return 0;
9082 : }
9083 :
9084 : int ASN1CALL
9085 0 : encode_PKIXXmppAddr(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const PKIXXmppAddr *data, size_t *size)
9086 : {
9087 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
9088 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
9089 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
9090 :
9091 0 : e = der_put_utf8string(p, len, data, &l);
9092 0 : if (e) return e;
9093 0 : p -= l; len -= l; ret += l;
9094 :
9095 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_UTF8String, &l);
9096 0 : if (e) return e;
9097 0 : p -= l; len -= l; ret += l;
9098 :
9099 0 : *size = ret;
9100 0 : return 0;
9101 : }
9102 :
9103 : int ASN1CALL
9104 0 : decode_PKIXXmppAddr(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, PKIXXmppAddr *data, size_t *size)
9105 : {
9106 0 : size_t ret = 0;
9107 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
9108 : int e HEIMDAL_UNUSED_ATTRIBUTE;
9109 :
9110 0 : memset(data, 0, sizeof(*data));
9111 : {
9112 : size_t Top_datalen, Top_oldlen;
9113 : Der_type Top_type;
9114 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_UTF8String, &Top_datalen, &l);
9115 0 : if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
9116 0 : if(e) goto fail;
9117 0 : p += l; len -= l; ret += l;
9118 0 : Top_oldlen = len;
9119 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9120 0 : len = Top_datalen;
9121 0 : e = der_get_utf8string(p, len, data, &l);
9122 0 : if(e) goto fail;
9123 0 : p += l; len -= l; ret += l;
9124 0 : len = Top_oldlen - Top_datalen;
9125 : }
9126 0 : if(size) *size = ret;
9127 0 : return 0;
9128 0 : fail:
9129 0 : free_PKIXXmppAddr(data);
9130 0 : return e;
9131 : }
9132 :
9133 : void ASN1CALL
9134 0 : free_PKIXXmppAddr(PKIXXmppAddr *data)
9135 : {
9136 0 : der_free_utf8string(data);
9137 0 : }
9138 :
9139 : size_t ASN1CALL
9140 0 : length_PKIXXmppAddr(const PKIXXmppAddr *data)
9141 : {
9142 0 : size_t ret = 0;
9143 0 : ret += der_length_utf8string(data);
9144 0 : ret += 1 + der_length_len (ret);
9145 0 : return ret;
9146 : }
9147 :
9148 : int ASN1CALL
9149 0 : copy_PKIXXmppAddr(const PKIXXmppAddr *from, PKIXXmppAddr *to)
9150 : {
9151 0 : memset(to, 0, sizeof(*to));
9152 0 : if(der_copy_utf8string(from, to)) goto fail;
9153 0 : return 0;
9154 0 : fail:
9155 0 : free_PKIXXmppAddr(to);
9156 0 : return ENOMEM;
9157 : }
9158 :
9159 : static unsigned oid_id_pkix_variable_num[7] = {1, 3, 6, 1, 5, 5, 7 };
9160 : const heim_oid asn1_oid_id_pkix = { 7, oid_id_pkix_variable_num };
9161 :
9162 : static unsigned oid_id_pkix_on_variable_num[8] = {1, 3, 6, 1, 5, 5, 7, 8 };
9163 : const heim_oid asn1_oid_id_pkix_on = { 8, oid_id_pkix_on_variable_num };
9164 :
9165 : static unsigned oid_id_pkix_on_xmppAddr_variable_num[9] = {1, 3, 6, 1, 5, 5, 7, 8, 5 };
9166 : const heim_oid asn1_oid_id_pkix_on_xmppAddr = { 9, oid_id_pkix_on_xmppAddr_variable_num };
9167 :
9168 : static unsigned oid_id_pkix_on_dnsSRV_variable_num[9] = {1, 3, 6, 1, 5, 5, 7, 8, 7 };
9169 : const heim_oid asn1_oid_id_pkix_on_dnsSRV = { 9, oid_id_pkix_on_dnsSRV_variable_num };
9170 :
9171 : static unsigned oid_id_pkix_kp_variable_num[8] = {1, 3, 6, 1, 5, 5, 7, 3 };
9172 : const heim_oid asn1_oid_id_pkix_kp = { 8, oid_id_pkix_kp_variable_num };
9173 :
9174 : static unsigned oid_id_pkix_kp_serverAuth_variable_num[9] = {1, 3, 6, 1, 5, 5, 7, 3, 1 };
9175 : const heim_oid asn1_oid_id_pkix_kp_serverAuth = { 9, oid_id_pkix_kp_serverAuth_variable_num };
9176 :
9177 : static unsigned oid_id_pkix_kp_clientAuth_variable_num[9] = {1, 3, 6, 1, 5, 5, 7, 3, 2 };
9178 : const heim_oid asn1_oid_id_pkix_kp_clientAuth = { 9, oid_id_pkix_kp_clientAuth_variable_num };
9179 :
9180 : static unsigned oid_id_pkix_kp_emailProtection_variable_num[9] = {1, 3, 6, 1, 5, 5, 7, 3, 4 };
9181 : const heim_oid asn1_oid_id_pkix_kp_emailProtection = { 9, oid_id_pkix_kp_emailProtection_variable_num };
9182 :
9183 : static unsigned oid_id_pkix_kp_timeStamping_variable_num[9] = {1, 3, 6, 1, 5, 5, 7, 3, 8 };
9184 : const heim_oid asn1_oid_id_pkix_kp_timeStamping = { 9, oid_id_pkix_kp_timeStamping_variable_num };
9185 :
9186 : static unsigned oid_id_pkix_kp_OCSPSigning_variable_num[9] = {1, 3, 6, 1, 5, 5, 7, 3, 9 };
9187 : const heim_oid asn1_oid_id_pkix_kp_OCSPSigning = { 9, oid_id_pkix_kp_OCSPSigning_variable_num };
9188 :
9189 : static unsigned oid_id_pkix_pe_variable_num[8] = {1, 3, 6, 1, 5, 5, 7, 1 };
9190 : const heim_oid asn1_oid_id_pkix_pe = { 8, oid_id_pkix_pe_variable_num };
9191 :
9192 : static unsigned oid_id_pkix_pe_authorityInfoAccess_variable_num[9] = {1, 3, 6, 1, 5, 5, 7, 1, 1 };
9193 : const heim_oid asn1_oid_id_pkix_pe_authorityInfoAccess = { 9, oid_id_pkix_pe_authorityInfoAccess_variable_num };
9194 :
9195 : int ASN1CALL
9196 0 : encode_AccessDescription(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const AccessDescription *data, size_t *size)
9197 : {
9198 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
9199 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
9200 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
9201 :
9202 : /* accessLocation */
9203 : {
9204 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
9205 0 : ret = 0;
9206 0 : e = encode_GeneralName(p, len, &(data)->accessLocation, &l);
9207 0 : if (e) return e;
9208 0 : p -= l; len -= l; ret += l;
9209 :
9210 0 : ret += Top_tag_oldret;
9211 : }
9212 : /* accessMethod */
9213 : {
9214 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
9215 0 : ret = 0;
9216 0 : e = der_put_oid(p, len, &(data)->accessMethod, &l);
9217 0 : if (e) return e;
9218 0 : p -= l; len -= l; ret += l;
9219 :
9220 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OID, &l);
9221 0 : if (e) return e;
9222 0 : p -= l; len -= l; ret += l;
9223 :
9224 0 : ret += Top_tag_oldret;
9225 : }
9226 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
9227 0 : if (e) return e;
9228 0 : p -= l; len -= l; ret += l;
9229 :
9230 0 : *size = ret;
9231 0 : return 0;
9232 : }
9233 :
9234 : int ASN1CALL
9235 0 : decode_AccessDescription(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, AccessDescription *data, size_t *size)
9236 : {
9237 0 : size_t ret = 0;
9238 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
9239 : int e HEIMDAL_UNUSED_ATTRIBUTE;
9240 :
9241 0 : memset(data, 0, sizeof(*data));
9242 : {
9243 : size_t Top_datalen, Top_oldlen;
9244 : Der_type Top_type;
9245 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
9246 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
9247 0 : if(e) goto fail;
9248 0 : p += l; len -= l; ret += l;
9249 0 : Top_oldlen = len;
9250 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9251 0 : len = Top_datalen;
9252 : {
9253 : size_t accessMethod_datalen, accessMethod_oldlen;
9254 : Der_type accessMethod_type;
9255 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &accessMethod_type, UT_OID, &accessMethod_datalen, &l);
9256 0 : if (e == 0 && accessMethod_type != PRIM) { e = ASN1_BAD_ID; }
9257 0 : if(e) goto fail;
9258 0 : p += l; len -= l; ret += l;
9259 0 : accessMethod_oldlen = len;
9260 0 : if (accessMethod_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9261 0 : len = accessMethod_datalen;
9262 0 : e = der_get_oid(p, len, &(data)->accessMethod, &l);
9263 0 : if(e) goto fail;
9264 0 : p += l; len -= l; ret += l;
9265 0 : len = accessMethod_oldlen - accessMethod_datalen;
9266 : }
9267 0 : e = decode_GeneralName(p, len, &(data)->accessLocation, &l);
9268 0 : if(e) goto fail;
9269 0 : p += l; len -= l; ret += l;
9270 0 : len = Top_oldlen - Top_datalen;
9271 : }
9272 0 : if(size) *size = ret;
9273 0 : return 0;
9274 0 : fail:
9275 0 : free_AccessDescription(data);
9276 0 : return e;
9277 : }
9278 :
9279 : void ASN1CALL
9280 0 : free_AccessDescription(AccessDescription *data)
9281 : {
9282 0 : der_free_oid(&(data)->accessMethod);
9283 0 : free_GeneralName(&(data)->accessLocation);
9284 0 : }
9285 :
9286 : size_t ASN1CALL
9287 0 : length_AccessDescription(const AccessDescription *data)
9288 : {
9289 0 : size_t ret = 0;
9290 : {
9291 0 : size_t Top_tag_oldret = ret;
9292 0 : ret = 0;
9293 0 : ret += der_length_oid(&(data)->accessMethod);
9294 0 : ret += 1 + der_length_len (ret);
9295 0 : ret += Top_tag_oldret;
9296 : }
9297 : {
9298 0 : size_t Top_tag_oldret = ret;
9299 0 : ret = 0;
9300 0 : ret += length_GeneralName(&(data)->accessLocation);
9301 0 : ret += Top_tag_oldret;
9302 : }
9303 0 : ret += 1 + der_length_len (ret);
9304 0 : return ret;
9305 : }
9306 :
9307 : int ASN1CALL
9308 0 : copy_AccessDescription(const AccessDescription *from, AccessDescription *to)
9309 : {
9310 0 : memset(to, 0, sizeof(*to));
9311 0 : if(der_copy_oid(&(from)->accessMethod, &(to)->accessMethod)) goto fail;
9312 0 : if(copy_GeneralName(&(from)->accessLocation, &(to)->accessLocation)) goto fail;
9313 0 : return 0;
9314 0 : fail:
9315 0 : free_AccessDescription(to);
9316 0 : return ENOMEM;
9317 : }
9318 :
9319 : int ASN1CALL
9320 0 : encode_AuthorityInfoAccessSyntax(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const AuthorityInfoAccessSyntax *data, size_t *size)
9321 : {
9322 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
9323 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
9324 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
9325 :
9326 0 : for(i = (int)(data)->len - 1; i >= 0; --i) {
9327 0 : size_t Top_tag_for_oldret = ret;
9328 0 : ret = 0;
9329 0 : e = encode_AccessDescription(p, len, &(data)->val[i], &l);
9330 0 : if (e) return e;
9331 0 : p -= l; len -= l; ret += l;
9332 :
9333 0 : ret += Top_tag_for_oldret;
9334 : }
9335 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
9336 0 : if (e) return e;
9337 0 : p -= l; len -= l; ret += l;
9338 :
9339 0 : *size = ret;
9340 0 : return 0;
9341 : }
9342 :
9343 : int ASN1CALL
9344 0 : decode_AuthorityInfoAccessSyntax(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, AuthorityInfoAccessSyntax *data, size_t *size)
9345 : {
9346 0 : size_t ret = 0;
9347 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
9348 : int e HEIMDAL_UNUSED_ATTRIBUTE;
9349 :
9350 0 : memset(data, 0, sizeof(*data));
9351 : {
9352 : size_t Top_datalen, Top_oldlen;
9353 : Der_type Top_type;
9354 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
9355 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
9356 0 : if(e) goto fail;
9357 0 : p += l; len -= l; ret += l;
9358 0 : Top_oldlen = len;
9359 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9360 0 : len = Top_datalen;
9361 : {
9362 0 : size_t Top_Tag_origlen = len;
9363 0 : size_t Top_Tag_oldret = ret;
9364 0 : size_t Top_Tag_olen = 0;
9365 : void *Top_Tag_tmp;
9366 0 : ret = 0;
9367 0 : (data)->len = 0;
9368 0 : (data)->val = NULL;
9369 0 : while(ret < Top_Tag_origlen) {
9370 0 : size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
9371 0 : if (Top_Tag_olen > Top_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
9372 0 : Top_Tag_olen = Top_Tag_nlen;
9373 0 : Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
9374 0 : if (Top_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
9375 0 : (data)->val = Top_Tag_tmp;
9376 0 : e = decode_AccessDescription(p, len, &(data)->val[(data)->len], &l);
9377 0 : if(e) goto fail;
9378 0 : p += l; len -= l; ret += l;
9379 0 : (data)->len++;
9380 0 : len = Top_Tag_origlen - ret;
9381 : }
9382 0 : ret += Top_Tag_oldret;
9383 : }
9384 0 : if ((data)->len < 1) {
9385 0 : e = ASN1_MIN_CONSTRAINT; goto fail;
9386 : }
9387 0 : len = Top_oldlen - Top_datalen;
9388 : }
9389 0 : if(size) *size = ret;
9390 0 : return 0;
9391 0 : fail:
9392 0 : free_AuthorityInfoAccessSyntax(data);
9393 0 : return e;
9394 : }
9395 :
9396 : void ASN1CALL
9397 0 : free_AuthorityInfoAccessSyntax(AuthorityInfoAccessSyntax *data)
9398 : {
9399 0 : while((data)->len){
9400 0 : free_AccessDescription(&(data)->val[(data)->len-1]);
9401 0 : (data)->len--;
9402 : }
9403 0 : free((data)->val);
9404 0 : (data)->val = NULL;
9405 0 : }
9406 :
9407 : size_t ASN1CALL
9408 0 : length_AuthorityInfoAccessSyntax(const AuthorityInfoAccessSyntax *data)
9409 : {
9410 0 : size_t ret = 0;
9411 : {
9412 0 : size_t Top_tag_oldret = ret;
9413 : int i;
9414 0 : ret = 0;
9415 0 : for(i = (data)->len - 1; i >= 0; --i){
9416 0 : size_t Top_tag_for_oldret = ret;
9417 0 : ret = 0;
9418 0 : ret += length_AccessDescription(&(data)->val[i]);
9419 0 : ret += Top_tag_for_oldret;
9420 : }
9421 0 : ret += Top_tag_oldret;
9422 : }
9423 0 : ret += 1 + der_length_len (ret);
9424 0 : return ret;
9425 : }
9426 :
9427 : int ASN1CALL
9428 0 : copy_AuthorityInfoAccessSyntax(const AuthorityInfoAccessSyntax *from, AuthorityInfoAccessSyntax *to)
9429 : {
9430 0 : memset(to, 0, sizeof(*to));
9431 0 : if(((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
9432 0 : goto fail;
9433 0 : for((to)->len = 0; (to)->len < (from)->len; (to)->len++){
9434 0 : if(copy_AccessDescription(&(from)->val[(to)->len], &(to)->val[(to)->len])) goto fail;
9435 : }
9436 0 : return 0;
9437 0 : fail:
9438 0 : free_AuthorityInfoAccessSyntax(to);
9439 0 : return ENOMEM;
9440 : }
9441 :
9442 : static unsigned oid_id_pkix_pe_proxyCertInfo_variable_num[9] = {1, 3, 6, 1, 5, 5, 7, 1, 14 };
9443 : const heim_oid asn1_oid_id_pkix_pe_proxyCertInfo = { 9, oid_id_pkix_pe_proxyCertInfo_variable_num };
9444 :
9445 : static unsigned oid_id_pkix_ppl_variable_num[8] = {1, 3, 6, 1, 5, 5, 7, 21 };
9446 : const heim_oid asn1_oid_id_pkix_ppl = { 8, oid_id_pkix_ppl_variable_num };
9447 :
9448 : static unsigned oid_id_pkix_ppl_anyLanguage_variable_num[9] = {1, 3, 6, 1, 5, 5, 7, 21, 0 };
9449 : const heim_oid asn1_oid_id_pkix_ppl_anyLanguage = { 9, oid_id_pkix_ppl_anyLanguage_variable_num };
9450 :
9451 : static unsigned oid_id_pkix_ppl_inheritAll_variable_num[9] = {1, 3, 6, 1, 5, 5, 7, 21, 1 };
9452 : const heim_oid asn1_oid_id_pkix_ppl_inheritAll = { 9, oid_id_pkix_ppl_inheritAll_variable_num };
9453 :
9454 : static unsigned oid_id_pkix_ppl_independent_variable_num[9] = {1, 3, 6, 1, 5, 5, 7, 21, 2 };
9455 : const heim_oid asn1_oid_id_pkix_ppl_independent = { 9, oid_id_pkix_ppl_independent_variable_num };
9456 :
9457 : int ASN1CALL
9458 0 : encode_ProxyPolicy(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const ProxyPolicy *data, size_t *size)
9459 : {
9460 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
9461 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
9462 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
9463 :
9464 : /* policy */
9465 0 : if((data)->policy) {
9466 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
9467 0 : ret = 0;
9468 0 : e = der_put_octet_string(p, len, (data)->policy, &l);
9469 0 : if (e) return e;
9470 0 : p -= l; len -= l; ret += l;
9471 :
9472 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
9473 0 : if (e) return e;
9474 0 : p -= l; len -= l; ret += l;
9475 :
9476 0 : ret += Top_tag_oldret;
9477 : }
9478 : /* policyLanguage */
9479 : {
9480 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
9481 0 : ret = 0;
9482 0 : e = der_put_oid(p, len, &(data)->policyLanguage, &l);
9483 0 : if (e) return e;
9484 0 : p -= l; len -= l; ret += l;
9485 :
9486 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OID, &l);
9487 0 : if (e) return e;
9488 0 : p -= l; len -= l; ret += l;
9489 :
9490 0 : ret += Top_tag_oldret;
9491 : }
9492 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
9493 0 : if (e) return e;
9494 0 : p -= l; len -= l; ret += l;
9495 :
9496 0 : *size = ret;
9497 0 : return 0;
9498 : }
9499 :
9500 : int ASN1CALL
9501 0 : decode_ProxyPolicy(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, ProxyPolicy *data, size_t *size)
9502 : {
9503 0 : size_t ret = 0;
9504 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
9505 : int e HEIMDAL_UNUSED_ATTRIBUTE;
9506 :
9507 0 : memset(data, 0, sizeof(*data));
9508 : {
9509 : size_t Top_datalen, Top_oldlen;
9510 : Der_type Top_type;
9511 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
9512 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
9513 0 : if(e) goto fail;
9514 0 : p += l; len -= l; ret += l;
9515 0 : Top_oldlen = len;
9516 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9517 0 : len = Top_datalen;
9518 : {
9519 : size_t policyLanguage_datalen, policyLanguage_oldlen;
9520 : Der_type policyLanguage_type;
9521 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &policyLanguage_type, UT_OID, &policyLanguage_datalen, &l);
9522 0 : if (e == 0 && policyLanguage_type != PRIM) { e = ASN1_BAD_ID; }
9523 0 : if(e) goto fail;
9524 0 : p += l; len -= l; ret += l;
9525 0 : policyLanguage_oldlen = len;
9526 0 : if (policyLanguage_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9527 0 : len = policyLanguage_datalen;
9528 0 : e = der_get_oid(p, len, &(data)->policyLanguage, &l);
9529 0 : if(e) goto fail;
9530 0 : p += l; len -= l; ret += l;
9531 0 : len = policyLanguage_oldlen - policyLanguage_datalen;
9532 : }
9533 : {
9534 : size_t policy_datalen, policy_oldlen;
9535 : Der_type policy_type;
9536 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &policy_type, UT_OctetString, &policy_datalen, &l);
9537 0 : if (e == 0 && policy_type != PRIM) { e = ASN1_BAD_ID; }
9538 0 : if(e) {
9539 0 : (data)->policy = NULL;
9540 : } else {
9541 0 : (data)->policy = calloc(1, sizeof(*(data)->policy));
9542 0 : if ((data)->policy == NULL) { e = ENOMEM; goto fail; }
9543 0 : p += l; len -= l; ret += l;
9544 0 : policy_oldlen = len;
9545 0 : if (policy_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9546 0 : len = policy_datalen;
9547 0 : e = der_get_octet_string(p, len, (data)->policy, &l);
9548 0 : if(e) goto fail;
9549 0 : p += l; len -= l; ret += l;
9550 0 : len = policy_oldlen - policy_datalen;
9551 : }
9552 : }
9553 0 : len = Top_oldlen - Top_datalen;
9554 : }
9555 0 : if(size) *size = ret;
9556 0 : return 0;
9557 0 : fail:
9558 0 : free_ProxyPolicy(data);
9559 0 : return e;
9560 : }
9561 :
9562 : void ASN1CALL
9563 0 : free_ProxyPolicy(ProxyPolicy *data)
9564 : {
9565 0 : der_free_oid(&(data)->policyLanguage);
9566 0 : if((data)->policy) {
9567 0 : der_free_octet_string((data)->policy);
9568 0 : free((data)->policy);
9569 0 : (data)->policy = NULL;
9570 : }
9571 0 : }
9572 :
9573 : size_t ASN1CALL
9574 0 : length_ProxyPolicy(const ProxyPolicy *data)
9575 : {
9576 0 : size_t ret = 0;
9577 : {
9578 0 : size_t Top_tag_oldret = ret;
9579 0 : ret = 0;
9580 0 : ret += der_length_oid(&(data)->policyLanguage);
9581 0 : ret += 1 + der_length_len (ret);
9582 0 : ret += Top_tag_oldret;
9583 : }
9584 0 : if((data)->policy){
9585 0 : size_t Top_tag_oldret = ret;
9586 0 : ret = 0;
9587 0 : ret += der_length_octet_string((data)->policy);
9588 0 : ret += 1 + der_length_len (ret);
9589 0 : ret += Top_tag_oldret;
9590 : }
9591 0 : ret += 1 + der_length_len (ret);
9592 0 : return ret;
9593 : }
9594 :
9595 : int ASN1CALL
9596 0 : copy_ProxyPolicy(const ProxyPolicy *from, ProxyPolicy *to)
9597 : {
9598 0 : memset(to, 0, sizeof(*to));
9599 0 : if(der_copy_oid(&(from)->policyLanguage, &(to)->policyLanguage)) goto fail;
9600 0 : if((from)->policy) {
9601 0 : (to)->policy = malloc(sizeof(*(to)->policy));
9602 0 : if((to)->policy == NULL) goto fail;
9603 0 : if(der_copy_octet_string((from)->policy, (to)->policy)) goto fail;
9604 : }else
9605 0 : (to)->policy = NULL;
9606 0 : return 0;
9607 0 : fail:
9608 0 : free_ProxyPolicy(to);
9609 0 : return ENOMEM;
9610 : }
9611 :
9612 : int ASN1CALL
9613 0 : encode_ProxyCertInfo(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const ProxyCertInfo *data, size_t *size)
9614 : {
9615 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
9616 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
9617 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
9618 :
9619 : /* proxyPolicy */
9620 : {
9621 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
9622 0 : ret = 0;
9623 0 : e = encode_ProxyPolicy(p, len, &(data)->proxyPolicy, &l);
9624 0 : if (e) return e;
9625 0 : p -= l; len -= l; ret += l;
9626 :
9627 0 : ret += Top_tag_oldret;
9628 : }
9629 : /* pCPathLenConstraint */
9630 0 : if((data)->pCPathLenConstraint) {
9631 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
9632 0 : ret = 0;
9633 0 : e = der_put_unsigned(p, len, (data)->pCPathLenConstraint, &l);
9634 0 : if (e) return e;
9635 0 : p -= l; len -= l; ret += l;
9636 :
9637 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
9638 0 : if (e) return e;
9639 0 : p -= l; len -= l; ret += l;
9640 :
9641 0 : ret += Top_tag_oldret;
9642 : }
9643 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
9644 0 : if (e) return e;
9645 0 : p -= l; len -= l; ret += l;
9646 :
9647 0 : *size = ret;
9648 0 : return 0;
9649 : }
9650 :
9651 : int ASN1CALL
9652 0 : decode_ProxyCertInfo(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, ProxyCertInfo *data, size_t *size)
9653 : {
9654 0 : size_t ret = 0;
9655 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
9656 : int e HEIMDAL_UNUSED_ATTRIBUTE;
9657 :
9658 0 : memset(data, 0, sizeof(*data));
9659 : {
9660 : size_t Top_datalen, Top_oldlen;
9661 : Der_type Top_type;
9662 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
9663 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
9664 0 : if(e) goto fail;
9665 0 : p += l; len -= l; ret += l;
9666 0 : Top_oldlen = len;
9667 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9668 0 : len = Top_datalen;
9669 : {
9670 : size_t pCPathLenConstraint_datalen, pCPathLenConstraint_oldlen;
9671 : Der_type pCPathLenConstraint_type;
9672 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &pCPathLenConstraint_type, UT_Integer, &pCPathLenConstraint_datalen, &l);
9673 0 : if (e == 0 && pCPathLenConstraint_type != PRIM) { e = ASN1_BAD_ID; }
9674 0 : if(e) {
9675 0 : (data)->pCPathLenConstraint = NULL;
9676 : } else {
9677 0 : (data)->pCPathLenConstraint = calloc(1, sizeof(*(data)->pCPathLenConstraint));
9678 0 : if ((data)->pCPathLenConstraint == NULL) { e = ENOMEM; goto fail; }
9679 0 : p += l; len -= l; ret += l;
9680 0 : pCPathLenConstraint_oldlen = len;
9681 0 : if (pCPathLenConstraint_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9682 0 : len = pCPathLenConstraint_datalen;
9683 0 : e = der_get_unsigned(p, len, (data)->pCPathLenConstraint, &l);
9684 0 : if(e) goto fail;
9685 0 : p += l; len -= l; ret += l;
9686 0 : len = pCPathLenConstraint_oldlen - pCPathLenConstraint_datalen;
9687 : }
9688 : }
9689 0 : e = decode_ProxyPolicy(p, len, &(data)->proxyPolicy, &l);
9690 0 : if(e) goto fail;
9691 0 : p += l; len -= l; ret += l;
9692 0 : len = Top_oldlen - Top_datalen;
9693 : }
9694 0 : if(size) *size = ret;
9695 0 : return 0;
9696 0 : fail:
9697 0 : free_ProxyCertInfo(data);
9698 0 : return e;
9699 : }
9700 :
9701 : void ASN1CALL
9702 0 : free_ProxyCertInfo(ProxyCertInfo *data)
9703 : {
9704 0 : if((data)->pCPathLenConstraint) {
9705 0 : free((data)->pCPathLenConstraint);
9706 0 : (data)->pCPathLenConstraint = NULL;
9707 : }
9708 0 : free_ProxyPolicy(&(data)->proxyPolicy);
9709 0 : }
9710 :
9711 : size_t ASN1CALL
9712 0 : length_ProxyCertInfo(const ProxyCertInfo *data)
9713 : {
9714 0 : size_t ret = 0;
9715 0 : if((data)->pCPathLenConstraint){
9716 0 : size_t Top_tag_oldret = ret;
9717 0 : ret = 0;
9718 0 : ret += der_length_unsigned((data)->pCPathLenConstraint);
9719 0 : ret += 1 + der_length_len (ret);
9720 0 : ret += Top_tag_oldret;
9721 : }
9722 : {
9723 0 : size_t Top_tag_oldret = ret;
9724 0 : ret = 0;
9725 0 : ret += length_ProxyPolicy(&(data)->proxyPolicy);
9726 0 : ret += Top_tag_oldret;
9727 : }
9728 0 : ret += 1 + der_length_len (ret);
9729 0 : return ret;
9730 : }
9731 :
9732 : int ASN1CALL
9733 0 : copy_ProxyCertInfo(const ProxyCertInfo *from, ProxyCertInfo *to)
9734 : {
9735 0 : memset(to, 0, sizeof(*to));
9736 0 : if((from)->pCPathLenConstraint) {
9737 0 : (to)->pCPathLenConstraint = malloc(sizeof(*(to)->pCPathLenConstraint));
9738 0 : if((to)->pCPathLenConstraint == NULL) goto fail;
9739 0 : *((to)->pCPathLenConstraint) = *((from)->pCPathLenConstraint);
9740 : }else
9741 0 : (to)->pCPathLenConstraint = NULL;
9742 0 : if(copy_ProxyPolicy(&(from)->proxyPolicy, &(to)->proxyPolicy)) goto fail;
9743 0 : return 0;
9744 0 : fail:
9745 0 : free_ProxyCertInfo(to);
9746 0 : return ENOMEM;
9747 : }
9748 :
9749 : static unsigned oid_id_uspkicommon_card_id_variable_num[8] = {2, 16, 840, 1, 101, 3, 6, 6 };
9750 : const heim_oid asn1_oid_id_uspkicommon_card_id = { 8, oid_id_uspkicommon_card_id_variable_num };
9751 :
9752 : static unsigned oid_id_uspkicommon_piv_interim_variable_num[9] = {2, 16, 840, 1, 101, 3, 6, 9, 1 };
9753 : const heim_oid asn1_oid_id_uspkicommon_piv_interim = { 9, oid_id_uspkicommon_piv_interim_variable_num };
9754 :
9755 : static unsigned oid_id_netscape_variable_num[5] = {2, 16, 840, 1, 113730 };
9756 : const heim_oid asn1_oid_id_netscape = { 5, oid_id_netscape_variable_num };
9757 :
9758 : static unsigned oid_id_netscape_cert_comment_variable_num[7] = {2, 16, 840, 1, 113730, 1, 13 };
9759 : const heim_oid asn1_oid_id_netscape_cert_comment = { 7, oid_id_netscape_cert_comment_variable_num };
9760 :
9761 : static unsigned oid_id_ms_cert_enroll_domaincontroller_variable_num[9] = {1, 3, 6, 1, 4, 1, 311, 20, 2 };
9762 : const heim_oid asn1_oid_id_ms_cert_enroll_domaincontroller = { 9, oid_id_ms_cert_enroll_domaincontroller_variable_num };
9763 :
9764 : static unsigned oid_id_ms_client_authentication_variable_num[9] = {1, 3, 6, 1, 5, 5, 7, 3, 2 };
9765 : const heim_oid asn1_oid_id_ms_client_authentication = { 9, oid_id_ms_client_authentication_variable_num };
9766 :
|