Line data Source code
1 : #include "config.h"
2 : /* Generated from /builds/samba-team/devel/samba/source4/heimdal/lib/hdb/hdb.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 <hdb_asn1.h>
15 : #include <hdb_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 0 : encode_Salt(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const Salt *data, size_t *size)
24 : {
25 0 : 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 : /* opaque */
30 0 : if((data)->opaque) {
31 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
32 0 : ret = 0;
33 0 : e = der_put_octet_string(p, len, (data)->opaque, &l);
34 0 : if (e) return e;
35 0 : p -= l; len -= l; ret += l;
36 :
37 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
38 0 : if (e) return e;
39 0 : p -= l; len -= l; ret += l;
40 :
41 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
42 0 : if (e) return e;
43 0 : p -= l; len -= l; ret += l;
44 :
45 0 : ret += Top_tag_oldret;
46 : }
47 : /* salt */
48 : {
49 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
50 0 : ret = 0;
51 0 : e = der_put_octet_string(p, len, &(data)->salt, &l);
52 0 : if (e) return e;
53 0 : p -= l; len -= l; ret += l;
54 :
55 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
56 0 : if (e) return e;
57 0 : p -= l; len -= l; ret += l;
58 :
59 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
60 0 : if (e) return e;
61 0 : p -= l; len -= l; ret += l;
62 :
63 0 : ret += Top_tag_oldret;
64 : }
65 : /* type */
66 : {
67 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
68 0 : ret = 0;
69 0 : e = der_put_unsigned(p, len, &(data)->type, &l);
70 0 : if (e) return e;
71 0 : p -= l; len -= l; ret += l;
72 :
73 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
74 0 : if (e) return e;
75 0 : p -= l; len -= l; ret += l;
76 :
77 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
78 0 : if (e) return e;
79 0 : p -= l; len -= l; ret += l;
80 :
81 0 : ret += Top_tag_oldret;
82 : }
83 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
84 0 : if (e) return e;
85 0 : p -= l; len -= l; ret += l;
86 :
87 0 : *size = ret;
88 0 : return 0;
89 : }
90 :
91 : int ASN1CALL
92 0 : decode_Salt(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, Salt *data, size_t *size)
93 : {
94 0 : size_t ret = 0;
95 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
96 : int e HEIMDAL_UNUSED_ATTRIBUTE;
97 :
98 0 : memset(data, 0, sizeof(*data));
99 : {
100 : size_t Top_datalen, Top_oldlen;
101 : Der_type Top_type;
102 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
103 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
104 0 : if(e) goto fail;
105 0 : p += l; len -= l; ret += l;
106 0 : Top_oldlen = len;
107 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
108 0 : len = Top_datalen;
109 : {
110 : size_t type_datalen, type_oldlen;
111 : Der_type type_type;
112 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &type_type, 0, &type_datalen, &l);
113 0 : if (e == 0 && type_type != CONS) { e = ASN1_BAD_ID; }
114 0 : if(e) goto fail;
115 0 : p += l; len -= l; ret += l;
116 0 : type_oldlen = len;
117 0 : if (type_datalen > len) { e = ASN1_OVERRUN; goto fail; }
118 0 : len = type_datalen;
119 : {
120 : size_t type_Tag_datalen, type_Tag_oldlen;
121 : Der_type type_Tag_type;
122 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &type_Tag_type, UT_Integer, &type_Tag_datalen, &l);
123 0 : if (e == 0 && type_Tag_type != PRIM) { e = ASN1_BAD_ID; }
124 0 : if(e) goto fail;
125 0 : p += l; len -= l; ret += l;
126 0 : type_Tag_oldlen = len;
127 0 : if (type_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
128 0 : len = type_Tag_datalen;
129 0 : e = der_get_unsigned(p, len, &(data)->type, &l);
130 0 : if(e) goto fail;
131 0 : p += l; len -= l; ret += l;
132 0 : len = type_Tag_oldlen - type_Tag_datalen;
133 : }
134 0 : len = type_oldlen - type_datalen;
135 : }
136 : {
137 : size_t salt_datalen, salt_oldlen;
138 : Der_type salt_type;
139 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &salt_type, 1, &salt_datalen, &l);
140 0 : if (e == 0 && salt_type != CONS) { e = ASN1_BAD_ID; }
141 0 : if(e) goto fail;
142 0 : p += l; len -= l; ret += l;
143 0 : salt_oldlen = len;
144 0 : if (salt_datalen > len) { e = ASN1_OVERRUN; goto fail; }
145 0 : len = salt_datalen;
146 : {
147 : size_t salt_Tag_datalen, salt_Tag_oldlen;
148 : Der_type salt_Tag_type;
149 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &salt_Tag_type, UT_OctetString, &salt_Tag_datalen, &l);
150 0 : if (e == 0 && salt_Tag_type != PRIM) { e = ASN1_BAD_ID; }
151 0 : if(e) goto fail;
152 0 : p += l; len -= l; ret += l;
153 0 : salt_Tag_oldlen = len;
154 0 : if (salt_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
155 0 : len = salt_Tag_datalen;
156 0 : e = der_get_octet_string(p, len, &(data)->salt, &l);
157 0 : if(e) goto fail;
158 0 : p += l; len -= l; ret += l;
159 0 : len = salt_Tag_oldlen - salt_Tag_datalen;
160 : }
161 0 : len = salt_oldlen - salt_datalen;
162 : }
163 : {
164 : size_t opaque_datalen, opaque_oldlen;
165 : Der_type opaque_type;
166 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &opaque_type, 2, &opaque_datalen, &l);
167 0 : if (e == 0 && opaque_type != CONS) { e = ASN1_BAD_ID; }
168 0 : if(e) {
169 0 : (data)->opaque = NULL;
170 : } else {
171 0 : (data)->opaque = calloc(1, sizeof(*(data)->opaque));
172 0 : if ((data)->opaque == NULL) { e = ENOMEM; goto fail; }
173 0 : p += l; len -= l; ret += l;
174 0 : opaque_oldlen = len;
175 0 : if (opaque_datalen > len) { e = ASN1_OVERRUN; goto fail; }
176 0 : len = opaque_datalen;
177 : {
178 : size_t opaque_Tag_datalen, opaque_Tag_oldlen;
179 : Der_type opaque_Tag_type;
180 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &opaque_Tag_type, UT_OctetString, &opaque_Tag_datalen, &l);
181 0 : if (e == 0 && opaque_Tag_type != PRIM) { e = ASN1_BAD_ID; }
182 0 : if(e) goto fail;
183 0 : p += l; len -= l; ret += l;
184 0 : opaque_Tag_oldlen = len;
185 0 : if (opaque_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
186 0 : len = opaque_Tag_datalen;
187 0 : e = der_get_octet_string(p, len, (data)->opaque, &l);
188 0 : if(e) goto fail;
189 0 : p += l; len -= l; ret += l;
190 0 : len = opaque_Tag_oldlen - opaque_Tag_datalen;
191 : }
192 0 : len = opaque_oldlen - opaque_datalen;
193 : }
194 : }
195 0 : len = Top_oldlen - Top_datalen;
196 : }
197 0 : if(size) *size = ret;
198 0 : return 0;
199 0 : fail:
200 0 : free_Salt(data);
201 0 : return e;
202 : }
203 :
204 : void ASN1CALL
205 439376 : free_Salt(Salt *data)
206 : {
207 439376 : der_free_octet_string(&(data)->salt);
208 439376 : if((data)->opaque) {
209 0 : der_free_octet_string((data)->opaque);
210 0 : free((data)->opaque);
211 0 : (data)->opaque = NULL;
212 : }
213 439376 : }
214 :
215 : size_t ASN1CALL
216 0 : length_Salt(const Salt *data)
217 : {
218 0 : size_t ret = 0;
219 : {
220 0 : size_t Top_tag_oldret = ret;
221 0 : ret = 0;
222 0 : ret += der_length_unsigned(&(data)->type);
223 0 : ret += 1 + der_length_len (ret);
224 0 : ret += 1 + der_length_len (ret);
225 0 : ret += Top_tag_oldret;
226 : }
227 : {
228 0 : size_t Top_tag_oldret = ret;
229 0 : ret = 0;
230 0 : ret += der_length_octet_string(&(data)->salt);
231 0 : ret += 1 + der_length_len (ret);
232 0 : ret += 1 + der_length_len (ret);
233 0 : ret += Top_tag_oldret;
234 : }
235 0 : if((data)->opaque){
236 0 : size_t Top_tag_oldret = ret;
237 0 : ret = 0;
238 0 : ret += der_length_octet_string((data)->opaque);
239 0 : ret += 1 + der_length_len (ret);
240 0 : ret += 1 + der_length_len (ret);
241 0 : ret += Top_tag_oldret;
242 : }
243 0 : ret += 1 + der_length_len (ret);
244 0 : return ret;
245 : }
246 :
247 : int ASN1CALL
248 0 : copy_Salt(const Salt *from, Salt *to)
249 : {
250 0 : memset(to, 0, sizeof(*to));
251 0 : *(&(to)->type) = *(&(from)->type);
252 0 : if(der_copy_octet_string(&(from)->salt, &(to)->salt)) goto fail;
253 0 : if((from)->opaque) {
254 0 : (to)->opaque = malloc(sizeof(*(to)->opaque));
255 0 : if((to)->opaque == NULL) goto fail;
256 0 : if(der_copy_octet_string((from)->opaque, (to)->opaque)) goto fail;
257 : }else
258 0 : (to)->opaque = NULL;
259 0 : return 0;
260 0 : fail:
261 0 : free_Salt(to);
262 0 : return ENOMEM;
263 : }
264 :
265 : int ASN1CALL
266 0 : encode_Key(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const Key *data, size_t *size)
267 : {
268 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
269 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
270 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
271 :
272 : /* salt */
273 0 : if((data)->salt) {
274 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
275 0 : ret = 0;
276 0 : e = encode_Salt(p, len, (data)->salt, &l);
277 0 : if (e) return e;
278 0 : p -= l; len -= l; ret += l;
279 :
280 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
281 0 : if (e) return e;
282 0 : p -= l; len -= l; ret += l;
283 :
284 0 : ret += Top_tag_oldret;
285 : }
286 : /* key */
287 : {
288 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
289 0 : ret = 0;
290 0 : e = encode_EncryptionKey(p, len, &(data)->key, &l);
291 0 : if (e) return e;
292 0 : p -= l; len -= l; ret += l;
293 :
294 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
295 0 : if (e) return e;
296 0 : p -= l; len -= l; ret += l;
297 :
298 0 : ret += Top_tag_oldret;
299 : }
300 : /* mkvno */
301 0 : if((data)->mkvno) {
302 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
303 0 : ret = 0;
304 0 : e = der_put_unsigned(p, len, (data)->mkvno, &l);
305 0 : if (e) return e;
306 0 : p -= l; len -= l; ret += l;
307 :
308 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
309 0 : if (e) return e;
310 0 : p -= l; len -= l; ret += l;
311 :
312 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
313 0 : if (e) return e;
314 0 : p -= l; len -= l; ret += l;
315 :
316 0 : ret += Top_tag_oldret;
317 : }
318 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
319 0 : if (e) return e;
320 0 : p -= l; len -= l; ret += l;
321 :
322 0 : *size = ret;
323 0 : return 0;
324 : }
325 :
326 : int ASN1CALL
327 0 : decode_Key(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, Key *data, size_t *size)
328 : {
329 0 : size_t ret = 0;
330 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
331 : int e HEIMDAL_UNUSED_ATTRIBUTE;
332 :
333 0 : memset(data, 0, sizeof(*data));
334 : {
335 : size_t Top_datalen, Top_oldlen;
336 : Der_type Top_type;
337 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
338 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
339 0 : if(e) goto fail;
340 0 : p += l; len -= l; ret += l;
341 0 : Top_oldlen = len;
342 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
343 0 : len = Top_datalen;
344 : {
345 : size_t mkvno_datalen, mkvno_oldlen;
346 : Der_type mkvno_type;
347 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &mkvno_type, 0, &mkvno_datalen, &l);
348 0 : if (e == 0 && mkvno_type != CONS) { e = ASN1_BAD_ID; }
349 0 : if(e) {
350 0 : (data)->mkvno = NULL;
351 : } else {
352 0 : (data)->mkvno = calloc(1, sizeof(*(data)->mkvno));
353 0 : if ((data)->mkvno == NULL) { e = ENOMEM; goto fail; }
354 0 : p += l; len -= l; ret += l;
355 0 : mkvno_oldlen = len;
356 0 : if (mkvno_datalen > len) { e = ASN1_OVERRUN; goto fail; }
357 0 : len = mkvno_datalen;
358 : {
359 : size_t mkvno_Tag_datalen, mkvno_Tag_oldlen;
360 : Der_type mkvno_Tag_type;
361 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &mkvno_Tag_type, UT_Integer, &mkvno_Tag_datalen, &l);
362 0 : if (e == 0 && mkvno_Tag_type != PRIM) { e = ASN1_BAD_ID; }
363 0 : if(e) goto fail;
364 0 : p += l; len -= l; ret += l;
365 0 : mkvno_Tag_oldlen = len;
366 0 : if (mkvno_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
367 0 : len = mkvno_Tag_datalen;
368 0 : e = der_get_unsigned(p, len, (data)->mkvno, &l);
369 0 : if(e) goto fail;
370 0 : p += l; len -= l; ret += l;
371 0 : len = mkvno_Tag_oldlen - mkvno_Tag_datalen;
372 : }
373 0 : len = mkvno_oldlen - mkvno_datalen;
374 : }
375 : }
376 : {
377 : size_t key_datalen, key_oldlen;
378 : Der_type key_type;
379 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &key_type, 1, &key_datalen, &l);
380 0 : if (e == 0 && key_type != CONS) { e = ASN1_BAD_ID; }
381 0 : if(e) goto fail;
382 0 : p += l; len -= l; ret += l;
383 0 : key_oldlen = len;
384 0 : if (key_datalen > len) { e = ASN1_OVERRUN; goto fail; }
385 0 : len = key_datalen;
386 0 : e = decode_EncryptionKey(p, len, &(data)->key, &l);
387 0 : if(e) goto fail;
388 0 : p += l; len -= l; ret += l;
389 0 : len = key_oldlen - key_datalen;
390 : }
391 : {
392 : size_t salt_datalen, salt_oldlen;
393 : Der_type salt_type;
394 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &salt_type, 2, &salt_datalen, &l);
395 0 : if (e == 0 && salt_type != CONS) { e = ASN1_BAD_ID; }
396 0 : if(e) {
397 0 : (data)->salt = NULL;
398 : } else {
399 0 : (data)->salt = calloc(1, sizeof(*(data)->salt));
400 0 : if ((data)->salt == NULL) { e = ENOMEM; goto fail; }
401 0 : p += l; len -= l; ret += l;
402 0 : salt_oldlen = len;
403 0 : if (salt_datalen > len) { e = ASN1_OVERRUN; goto fail; }
404 0 : len = salt_datalen;
405 0 : e = decode_Salt(p, len, (data)->salt, &l);
406 0 : if(e) goto fail;
407 0 : p += l; len -= l; ret += l;
408 0 : len = salt_oldlen - salt_datalen;
409 : }
410 : }
411 0 : len = Top_oldlen - Top_datalen;
412 : }
413 0 : if(size) *size = ret;
414 0 : return 0;
415 0 : fail:
416 0 : free_Key(data);
417 0 : return e;
418 : }
419 :
420 : void ASN1CALL
421 683370 : free_Key(Key *data)
422 : {
423 683370 : if((data)->mkvno) {
424 0 : free((data)->mkvno);
425 0 : (data)->mkvno = NULL;
426 : }
427 683370 : free_EncryptionKey(&(data)->key);
428 683370 : if((data)->salt) {
429 439376 : free_Salt((data)->salt);
430 439376 : free((data)->salt);
431 439376 : (data)->salt = NULL;
432 : }
433 683370 : }
434 :
435 : size_t ASN1CALL
436 0 : length_Key(const Key *data)
437 : {
438 0 : size_t ret = 0;
439 0 : if((data)->mkvno){
440 0 : size_t Top_tag_oldret = ret;
441 0 : ret = 0;
442 0 : ret += der_length_unsigned((data)->mkvno);
443 0 : ret += 1 + der_length_len (ret);
444 0 : ret += 1 + der_length_len (ret);
445 0 : ret += Top_tag_oldret;
446 : }
447 : {
448 0 : size_t Top_tag_oldret = ret;
449 0 : ret = 0;
450 0 : ret += length_EncryptionKey(&(data)->key);
451 0 : ret += 1 + der_length_len (ret);
452 0 : ret += Top_tag_oldret;
453 : }
454 0 : if((data)->salt){
455 0 : size_t Top_tag_oldret = ret;
456 0 : ret = 0;
457 0 : ret += length_Salt((data)->salt);
458 0 : ret += 1 + der_length_len (ret);
459 0 : ret += Top_tag_oldret;
460 : }
461 0 : ret += 1 + der_length_len (ret);
462 0 : return ret;
463 : }
464 :
465 : int ASN1CALL
466 0 : copy_Key(const Key *from, Key *to)
467 : {
468 0 : memset(to, 0, sizeof(*to));
469 0 : if((from)->mkvno) {
470 0 : (to)->mkvno = malloc(sizeof(*(to)->mkvno));
471 0 : if((to)->mkvno == NULL) goto fail;
472 0 : *((to)->mkvno) = *((from)->mkvno);
473 : }else
474 0 : (to)->mkvno = NULL;
475 0 : if(copy_EncryptionKey(&(from)->key, &(to)->key)) goto fail;
476 0 : if((from)->salt) {
477 0 : (to)->salt = malloc(sizeof(*(to)->salt));
478 0 : if((to)->salt == NULL) goto fail;
479 0 : if(copy_Salt((from)->salt, (to)->salt)) goto fail;
480 : }else
481 0 : (to)->salt = NULL;
482 0 : return 0;
483 0 : fail:
484 0 : free_Key(to);
485 0 : return ENOMEM;
486 : }
487 :
488 : int ASN1CALL
489 0 : encode_Event(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const Event *data, size_t *size)
490 : {
491 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
492 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
493 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
494 :
495 : /* principal */
496 0 : if((data)->principal) {
497 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
498 0 : ret = 0;
499 0 : e = encode_Principal(p, len, (data)->principal, &l);
500 0 : if (e) return e;
501 0 : p -= l; len -= l; ret += l;
502 :
503 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
504 0 : if (e) return e;
505 0 : p -= l; len -= l; ret += l;
506 :
507 0 : ret += Top_tag_oldret;
508 : }
509 : /* time */
510 : {
511 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
512 0 : ret = 0;
513 0 : e = encode_KerberosTime(p, len, &(data)->time, &l);
514 0 : if (e) return e;
515 0 : p -= l; len -= l; ret += l;
516 :
517 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
518 0 : if (e) return e;
519 0 : p -= l; len -= l; ret += l;
520 :
521 0 : ret += Top_tag_oldret;
522 : }
523 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
524 0 : if (e) return e;
525 0 : p -= l; len -= l; ret += l;
526 :
527 0 : *size = ret;
528 0 : return 0;
529 : }
530 :
531 : int ASN1CALL
532 0 : decode_Event(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, Event *data, size_t *size)
533 : {
534 0 : size_t ret = 0;
535 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
536 : int e HEIMDAL_UNUSED_ATTRIBUTE;
537 :
538 0 : memset(data, 0, sizeof(*data));
539 : {
540 : size_t Top_datalen, Top_oldlen;
541 : Der_type Top_type;
542 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
543 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
544 0 : if(e) goto fail;
545 0 : p += l; len -= l; ret += l;
546 0 : Top_oldlen = len;
547 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
548 0 : len = Top_datalen;
549 : {
550 : size_t time_datalen, time_oldlen;
551 : Der_type time_type;
552 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &time_type, 0, &time_datalen, &l);
553 0 : if (e == 0 && time_type != CONS) { e = ASN1_BAD_ID; }
554 0 : if(e) goto fail;
555 0 : p += l; len -= l; ret += l;
556 0 : time_oldlen = len;
557 0 : if (time_datalen > len) { e = ASN1_OVERRUN; goto fail; }
558 0 : len = time_datalen;
559 0 : e = decode_KerberosTime(p, len, &(data)->time, &l);
560 0 : if(e) goto fail;
561 0 : p += l; len -= l; ret += l;
562 0 : len = time_oldlen - time_datalen;
563 : }
564 : {
565 : size_t principal_datalen, principal_oldlen;
566 : Der_type principal_type;
567 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &principal_type, 1, &principal_datalen, &l);
568 0 : if (e == 0 && principal_type != CONS) { e = ASN1_BAD_ID; }
569 0 : if(e) {
570 0 : (data)->principal = NULL;
571 : } else {
572 0 : (data)->principal = calloc(1, sizeof(*(data)->principal));
573 0 : if ((data)->principal == NULL) { e = ENOMEM; goto fail; }
574 0 : p += l; len -= l; ret += l;
575 0 : principal_oldlen = len;
576 0 : if (principal_datalen > len) { e = ASN1_OVERRUN; goto fail; }
577 0 : len = principal_datalen;
578 0 : e = decode_Principal(p, len, (data)->principal, &l);
579 0 : if(e) goto fail;
580 0 : p += l; len -= l; ret += l;
581 0 : len = principal_oldlen - principal_datalen;
582 : }
583 : }
584 0 : len = Top_oldlen - Top_datalen;
585 : }
586 0 : if(size) *size = ret;
587 0 : return 0;
588 0 : fail:
589 0 : free_Event(data);
590 0 : return e;
591 : }
592 :
593 : void ASN1CALL
594 244004 : free_Event(Event *data)
595 : {
596 244004 : free_KerberosTime(&(data)->time);
597 244004 : if((data)->principal) {
598 907 : free_Principal((data)->principal);
599 907 : free((data)->principal);
600 907 : (data)->principal = NULL;
601 : }
602 244004 : }
603 :
604 : size_t ASN1CALL
605 0 : length_Event(const Event *data)
606 : {
607 0 : size_t ret = 0;
608 : {
609 0 : size_t Top_tag_oldret = ret;
610 0 : ret = 0;
611 0 : ret += length_KerberosTime(&(data)->time);
612 0 : ret += 1 + der_length_len (ret);
613 0 : ret += Top_tag_oldret;
614 : }
615 0 : if((data)->principal){
616 0 : size_t Top_tag_oldret = ret;
617 0 : ret = 0;
618 0 : ret += length_Principal((data)->principal);
619 0 : ret += 1 + der_length_len (ret);
620 0 : ret += Top_tag_oldret;
621 : }
622 0 : ret += 1 + der_length_len (ret);
623 0 : return ret;
624 : }
625 :
626 : int ASN1CALL
627 0 : copy_Event(const Event *from, Event *to)
628 : {
629 0 : memset(to, 0, sizeof(*to));
630 0 : if(copy_KerberosTime(&(from)->time, &(to)->time)) goto fail;
631 0 : if((from)->principal) {
632 0 : (to)->principal = malloc(sizeof(*(to)->principal));
633 0 : if((to)->principal == NULL) goto fail;
634 0 : if(copy_Principal((from)->principal, (to)->principal)) goto fail;
635 : }else
636 0 : (to)->principal = NULL;
637 0 : return 0;
638 0 : fail:
639 0 : free_Event(to);
640 0 : return ENOMEM;
641 : }
642 :
643 : int ASN1CALL
644 0 : encode_HDBFlags(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const HDBFlags *data, size_t *size)
645 : {
646 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
647 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
648 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
649 :
650 : {
651 0 : unsigned char c = 0;
652 0 : int rest = 0;
653 0 : int bit_set = 0;
654 0 : if((data)->do_not_store) {
655 0 : c |= 1<<0;
656 : }
657 0 : if (c != 0 || bit_set) {
658 0 : if (len < 1) return ASN1_OVERFLOW;
659 0 : *p-- = c; len--; ret++;
660 0 : if (!bit_set) {
661 0 : rest = 0;
662 0 : while(c) {
663 0 : if (c & 1) break;
664 0 : c = c >> 1;
665 0 : rest++;
666 : }
667 0 : bit_set = 1;
668 : }
669 : }
670 0 : c = 0;
671 0 : if((data)->locked_out) {
672 0 : c |= 1<<6;
673 : }
674 0 : if((data)->allow_digest) {
675 0 : c |= 1<<7;
676 : }
677 0 : if (c != 0 || bit_set) {
678 0 : if (len < 1) return ASN1_OVERFLOW;
679 0 : *p-- = c; len--; ret++;
680 0 : if (!bit_set) {
681 0 : rest = 0;
682 0 : while(c) {
683 0 : if (c & 1) break;
684 0 : c = c >> 1;
685 0 : rest++;
686 : }
687 0 : bit_set = 1;
688 : }
689 : }
690 0 : c = 0;
691 0 : if((data)->allow_kerberos4) {
692 0 : c |= 1<<0;
693 : }
694 0 : if((data)->trusted_for_delegation) {
695 0 : c |= 1<<1;
696 : }
697 0 : if((data)->immutable) {
698 0 : c |= 1<<2;
699 : }
700 0 : if((data)->user_to_user) {
701 0 : c |= 1<<3;
702 : }
703 0 : if((data)->ok_as_delegate) {
704 0 : c |= 1<<4;
705 : }
706 0 : if((data)->require_hwauth) {
707 0 : c |= 1<<5;
708 : }
709 0 : if((data)->change_pw) {
710 0 : c |= 1<<6;
711 : }
712 0 : if((data)->require_preauth) {
713 0 : c |= 1<<7;
714 : }
715 0 : if (c != 0 || bit_set) {
716 0 : if (len < 1) return ASN1_OVERFLOW;
717 0 : *p-- = c; len--; ret++;
718 0 : if (!bit_set) {
719 0 : rest = 0;
720 0 : while(c) {
721 0 : if (c & 1) break;
722 0 : c = c >> 1;
723 0 : rest++;
724 : }
725 0 : bit_set = 1;
726 : }
727 : }
728 0 : c = 0;
729 0 : if((data)->invalid) {
730 0 : c |= 1<<0;
731 : }
732 0 : if((data)->client) {
733 0 : c |= 1<<1;
734 : }
735 0 : if((data)->server) {
736 0 : c |= 1<<2;
737 : }
738 0 : if((data)->postdate) {
739 0 : c |= 1<<3;
740 : }
741 0 : if((data)->renewable) {
742 0 : c |= 1<<4;
743 : }
744 0 : if((data)->proxiable) {
745 0 : c |= 1<<5;
746 : }
747 0 : if((data)->forwardable) {
748 0 : c |= 1<<6;
749 : }
750 0 : if((data)->initial) {
751 0 : c |= 1<<7;
752 : }
753 0 : if (c != 0 || bit_set) {
754 0 : if (len < 1) return ASN1_OVERFLOW;
755 0 : *p-- = c; len--; ret++;
756 0 : if (!bit_set) {
757 0 : rest = 0;
758 0 : if(c) {
759 0 : while(c) {
760 0 : if (c & 1) break;
761 0 : c = c >> 1;
762 0 : rest++;
763 : }
764 : }
765 : }
766 : }
767 0 : if (len < 1) return ASN1_OVERFLOW;
768 0 : *p-- = rest;
769 0 : len -= 1;
770 0 : ret += 1;
771 : }
772 :
773 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_BitString, &l);
774 0 : if (e) return e;
775 0 : p -= l; len -= l; ret += l;
776 :
777 0 : *size = ret;
778 0 : return 0;
779 : }
780 :
781 : int ASN1CALL
782 0 : decode_HDBFlags(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, HDBFlags *data, size_t *size)
783 : {
784 0 : size_t ret = 0;
785 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
786 : int e HEIMDAL_UNUSED_ATTRIBUTE;
787 :
788 0 : memset(data, 0, sizeof(*data));
789 : {
790 : size_t Top_datalen, Top_oldlen;
791 : Der_type Top_type;
792 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_BitString, &Top_datalen, &l);
793 0 : if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
794 0 : if(e) goto fail;
795 0 : p += l; len -= l; ret += l;
796 0 : Top_oldlen = len;
797 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
798 0 : len = Top_datalen;
799 0 : if (len < 1) return ASN1_OVERRUN;
800 0 : p++; len--; ret++;
801 : do {
802 0 : if (len < 1) break;
803 0 : (data)->initial = (*p >> 7) & 1;
804 0 : (data)->forwardable = (*p >> 6) & 1;
805 0 : (data)->proxiable = (*p >> 5) & 1;
806 0 : (data)->renewable = (*p >> 4) & 1;
807 0 : (data)->postdate = (*p >> 3) & 1;
808 0 : (data)->server = (*p >> 2) & 1;
809 0 : (data)->client = (*p >> 1) & 1;
810 0 : (data)->invalid = (*p >> 0) & 1;
811 0 : p++; len--; ret++;
812 0 : if (len < 1) break;
813 0 : (data)->require_preauth = (*p >> 7) & 1;
814 0 : (data)->change_pw = (*p >> 6) & 1;
815 0 : (data)->require_hwauth = (*p >> 5) & 1;
816 0 : (data)->ok_as_delegate = (*p >> 4) & 1;
817 0 : (data)->user_to_user = (*p >> 3) & 1;
818 0 : (data)->immutable = (*p >> 2) & 1;
819 0 : (data)->trusted_for_delegation = (*p >> 1) & 1;
820 0 : (data)->allow_kerberos4 = (*p >> 0) & 1;
821 0 : p++; len--; ret++;
822 0 : if (len < 1) break;
823 0 : (data)->allow_digest = (*p >> 7) & 1;
824 0 : (data)->locked_out = (*p >> 6) & 1;
825 0 : p++; len--; ret++;
826 0 : if (len < 1) break;
827 0 : (data)->do_not_store = (*p >> 0) & 1;
828 : } while(0);
829 0 : p += len; ret += len;
830 0 : len = Top_oldlen - Top_datalen;
831 : }
832 0 : if(size) *size = ret;
833 0 : return 0;
834 0 : fail:
835 0 : free_HDBFlags(data);
836 0 : return e;
837 : }
838 :
839 : void ASN1CALL
840 244004 : free_HDBFlags(HDBFlags *data)
841 : {
842 244004 : }
843 :
844 : size_t ASN1CALL
845 0 : length_HDBFlags(const HDBFlags *data)
846 : {
847 0 : size_t ret = 0;
848 : do {
849 0 : if((data)->do_not_store) { ret += 4; break; }
850 0 : if((data)->locked_out) { ret += 3; break; }
851 0 : if((data)->allow_digest) { ret += 3; break; }
852 0 : if((data)->allow_kerberos4) { ret += 2; break; }
853 0 : if((data)->trusted_for_delegation) { ret += 2; break; }
854 0 : if((data)->immutable) { ret += 2; break; }
855 0 : if((data)->user_to_user) { ret += 2; break; }
856 0 : if((data)->ok_as_delegate) { ret += 2; break; }
857 0 : if((data)->require_hwauth) { ret += 2; break; }
858 0 : if((data)->change_pw) { ret += 2; break; }
859 0 : if((data)->require_preauth) { ret += 2; break; }
860 0 : if((data)->invalid) { ret += 1; break; }
861 0 : if((data)->client) { ret += 1; break; }
862 0 : if((data)->server) { ret += 1; break; }
863 0 : if((data)->postdate) { ret += 1; break; }
864 0 : if((data)->renewable) { ret += 1; break; }
865 0 : if((data)->proxiable) { ret += 1; break; }
866 0 : if((data)->forwardable) { ret += 1; break; }
867 0 : if((data)->initial) { ret += 1; break; }
868 : } while(0);
869 0 : ret += 1;
870 0 : ret += 1 + der_length_len (ret);
871 0 : return ret;
872 : }
873 :
874 : int ASN1CALL
875 0 : copy_HDBFlags(const HDBFlags *from, HDBFlags *to)
876 : {
877 0 : memset(to, 0, sizeof(*to));
878 0 : *(to) = *(from);
879 0 : return 0;
880 : }
881 :
882 0 : unsigned HDBFlags2int(HDBFlags f)
883 : {
884 0 : unsigned r = 0;
885 0 : if(f.initial) r |= (1U << 0);
886 0 : if(f.forwardable) r |= (1U << 1);
887 0 : if(f.proxiable) r |= (1U << 2);
888 0 : if(f.renewable) r |= (1U << 3);
889 0 : if(f.postdate) r |= (1U << 4);
890 0 : if(f.server) r |= (1U << 5);
891 0 : if(f.client) r |= (1U << 6);
892 0 : if(f.invalid) r |= (1U << 7);
893 0 : if(f.require_preauth) r |= (1U << 8);
894 0 : if(f.change_pw) r |= (1U << 9);
895 0 : if(f.require_hwauth) r |= (1U << 10);
896 0 : if(f.ok_as_delegate) r |= (1U << 11);
897 0 : if(f.user_to_user) r |= (1U << 12);
898 0 : if(f.immutable) r |= (1U << 13);
899 0 : if(f.trusted_for_delegation) r |= (1U << 14);
900 0 : if(f.allow_kerberos4) r |= (1U << 15);
901 0 : if(f.allow_digest) r |= (1U << 16);
902 0 : if(f.locked_out) r |= (1U << 17);
903 0 : if(f.do_not_store) r |= (1U << 31);
904 0 : return r;
905 : }
906 :
907 0 : HDBFlags int2HDBFlags(unsigned n)
908 : {
909 : HDBFlags flags;
910 :
911 0 : memset(&flags, 0, sizeof(flags));
912 :
913 0 : flags.initial = (n >> 0) & 1;
914 0 : flags.forwardable = (n >> 1) & 1;
915 0 : flags.proxiable = (n >> 2) & 1;
916 0 : flags.renewable = (n >> 3) & 1;
917 0 : flags.postdate = (n >> 4) & 1;
918 0 : flags.server = (n >> 5) & 1;
919 0 : flags.client = (n >> 6) & 1;
920 0 : flags.invalid = (n >> 7) & 1;
921 0 : flags.require_preauth = (n >> 8) & 1;
922 0 : flags.change_pw = (n >> 9) & 1;
923 0 : flags.require_hwauth = (n >> 10) & 1;
924 0 : flags.ok_as_delegate = (n >> 11) & 1;
925 0 : flags.user_to_user = (n >> 12) & 1;
926 0 : flags.immutable = (n >> 13) & 1;
927 0 : flags.trusted_for_delegation = (n >> 14) & 1;
928 0 : flags.allow_kerberos4 = (n >> 15) & 1;
929 0 : flags.allow_digest = (n >> 16) & 1;
930 0 : flags.locked_out = (n >> 17) & 1;
931 0 : flags.do_not_store = (n >> 31) & 1;
932 0 : return flags;
933 : }
934 :
935 : static struct units HDBFlags_units[] = {
936 : {"do-not-store", 1U << 31},
937 : {"locked-out", 1U << 17},
938 : {"allow-digest", 1U << 16},
939 : {"allow-kerberos4", 1U << 15},
940 : {"trusted-for-delegation", 1U << 14},
941 : {"immutable", 1U << 13},
942 : {"user-to-user", 1U << 12},
943 : {"ok-as-delegate", 1U << 11},
944 : {"require-hwauth", 1U << 10},
945 : {"change-pw", 1U << 9},
946 : {"require-preauth", 1U << 8},
947 : {"invalid", 1U << 7},
948 : {"client", 1U << 6},
949 : {"server", 1U << 5},
950 : {"postdate", 1U << 4},
951 : {"renewable", 1U << 3},
952 : {"proxiable", 1U << 2},
953 : {"forwardable", 1U << 1},
954 : {"initial", 1U << 0},
955 : {NULL, 0}
956 : };
957 :
958 0 : const struct units * asn1_HDBFlags_units(void){
959 0 : return HDBFlags_units;
960 : }
961 :
962 : int ASN1CALL
963 0 : encode_GENERATION(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const GENERATION *data, size_t *size)
964 : {
965 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
966 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
967 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
968 :
969 : /* gen */
970 : {
971 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
972 0 : ret = 0;
973 0 : e = der_put_unsigned(p, len, &(data)->gen, &l);
974 0 : if (e) return e;
975 0 : p -= l; len -= l; ret += l;
976 :
977 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
978 0 : if (e) return e;
979 0 : p -= l; len -= l; ret += l;
980 :
981 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
982 0 : if (e) return e;
983 0 : p -= l; len -= l; ret += l;
984 :
985 0 : ret += Top_tag_oldret;
986 : }
987 : /* usec */
988 : {
989 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
990 0 : ret = 0;
991 0 : e = der_put_unsigned(p, len, &(data)->usec, &l);
992 0 : if (e) return e;
993 0 : p -= l; len -= l; ret += l;
994 :
995 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
996 0 : if (e) return e;
997 0 : p -= l; len -= l; ret += l;
998 :
999 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
1000 0 : if (e) return e;
1001 0 : p -= l; len -= l; ret += l;
1002 :
1003 0 : ret += Top_tag_oldret;
1004 : }
1005 : /* time */
1006 : {
1007 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
1008 0 : ret = 0;
1009 0 : e = encode_KerberosTime(p, len, &(data)->time, &l);
1010 0 : if (e) return e;
1011 0 : p -= l; len -= l; ret += l;
1012 :
1013 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
1014 0 : if (e) return e;
1015 0 : p -= l; len -= l; ret += l;
1016 :
1017 0 : ret += Top_tag_oldret;
1018 : }
1019 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
1020 0 : if (e) return e;
1021 0 : p -= l; len -= l; ret += l;
1022 :
1023 0 : *size = ret;
1024 0 : return 0;
1025 : }
1026 :
1027 : int ASN1CALL
1028 0 : decode_GENERATION(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, GENERATION *data, size_t *size)
1029 : {
1030 0 : size_t ret = 0;
1031 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1032 : int e HEIMDAL_UNUSED_ATTRIBUTE;
1033 :
1034 0 : memset(data, 0, sizeof(*data));
1035 : {
1036 : size_t Top_datalen, Top_oldlen;
1037 : Der_type Top_type;
1038 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
1039 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
1040 0 : if(e) goto fail;
1041 0 : p += l; len -= l; ret += l;
1042 0 : Top_oldlen = len;
1043 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1044 0 : len = Top_datalen;
1045 : {
1046 : size_t time_datalen, time_oldlen;
1047 : Der_type time_type;
1048 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &time_type, 0, &time_datalen, &l);
1049 0 : if (e == 0 && time_type != CONS) { e = ASN1_BAD_ID; }
1050 0 : if(e) goto fail;
1051 0 : p += l; len -= l; ret += l;
1052 0 : time_oldlen = len;
1053 0 : if (time_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1054 0 : len = time_datalen;
1055 0 : e = decode_KerberosTime(p, len, &(data)->time, &l);
1056 0 : if(e) goto fail;
1057 0 : p += l; len -= l; ret += l;
1058 0 : len = time_oldlen - time_datalen;
1059 : }
1060 : {
1061 : size_t usec_datalen, usec_oldlen;
1062 : Der_type usec_type;
1063 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &usec_type, 1, &usec_datalen, &l);
1064 0 : if (e == 0 && usec_type != CONS) { e = ASN1_BAD_ID; }
1065 0 : if(e) goto fail;
1066 0 : p += l; len -= l; ret += l;
1067 0 : usec_oldlen = len;
1068 0 : if (usec_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1069 0 : len = usec_datalen;
1070 : {
1071 : size_t usec_Tag_datalen, usec_Tag_oldlen;
1072 : Der_type usec_Tag_type;
1073 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &usec_Tag_type, UT_Integer, &usec_Tag_datalen, &l);
1074 0 : if (e == 0 && usec_Tag_type != PRIM) { e = ASN1_BAD_ID; }
1075 0 : if(e) goto fail;
1076 0 : p += l; len -= l; ret += l;
1077 0 : usec_Tag_oldlen = len;
1078 0 : if (usec_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1079 0 : len = usec_Tag_datalen;
1080 0 : e = der_get_unsigned(p, len, &(data)->usec, &l);
1081 0 : if(e) goto fail;
1082 0 : p += l; len -= l; ret += l;
1083 0 : len = usec_Tag_oldlen - usec_Tag_datalen;
1084 : }
1085 0 : len = usec_oldlen - usec_datalen;
1086 : }
1087 : {
1088 : size_t gen_datalen, gen_oldlen;
1089 : Der_type gen_type;
1090 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &gen_type, 2, &gen_datalen, &l);
1091 0 : if (e == 0 && gen_type != CONS) { e = ASN1_BAD_ID; }
1092 0 : if(e) goto fail;
1093 0 : p += l; len -= l; ret += l;
1094 0 : gen_oldlen = len;
1095 0 : if (gen_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1096 0 : len = gen_datalen;
1097 : {
1098 : size_t gen_Tag_datalen, gen_Tag_oldlen;
1099 : Der_type gen_Tag_type;
1100 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &gen_Tag_type, UT_Integer, &gen_Tag_datalen, &l);
1101 0 : if (e == 0 && gen_Tag_type != PRIM) { e = ASN1_BAD_ID; }
1102 0 : if(e) goto fail;
1103 0 : p += l; len -= l; ret += l;
1104 0 : gen_Tag_oldlen = len;
1105 0 : if (gen_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1106 0 : len = gen_Tag_datalen;
1107 0 : e = der_get_unsigned(p, len, &(data)->gen, &l);
1108 0 : if(e) goto fail;
1109 0 : p += l; len -= l; ret += l;
1110 0 : len = gen_Tag_oldlen - gen_Tag_datalen;
1111 : }
1112 0 : len = gen_oldlen - gen_datalen;
1113 : }
1114 0 : len = Top_oldlen - Top_datalen;
1115 : }
1116 0 : if(size) *size = ret;
1117 0 : return 0;
1118 0 : fail:
1119 0 : free_GENERATION(data);
1120 0 : return e;
1121 : }
1122 :
1123 : void ASN1CALL
1124 0 : free_GENERATION(GENERATION *data)
1125 : {
1126 0 : free_KerberosTime(&(data)->time);
1127 0 : }
1128 :
1129 : size_t ASN1CALL
1130 0 : length_GENERATION(const GENERATION *data)
1131 : {
1132 0 : size_t ret = 0;
1133 : {
1134 0 : size_t Top_tag_oldret = ret;
1135 0 : ret = 0;
1136 0 : ret += length_KerberosTime(&(data)->time);
1137 0 : ret += 1 + der_length_len (ret);
1138 0 : ret += Top_tag_oldret;
1139 : }
1140 : {
1141 0 : size_t Top_tag_oldret = ret;
1142 0 : ret = 0;
1143 0 : ret += der_length_unsigned(&(data)->usec);
1144 0 : ret += 1 + der_length_len (ret);
1145 0 : ret += 1 + der_length_len (ret);
1146 0 : ret += Top_tag_oldret;
1147 : }
1148 : {
1149 0 : size_t Top_tag_oldret = ret;
1150 0 : ret = 0;
1151 0 : ret += der_length_unsigned(&(data)->gen);
1152 0 : ret += 1 + der_length_len (ret);
1153 0 : ret += 1 + der_length_len (ret);
1154 0 : ret += Top_tag_oldret;
1155 : }
1156 0 : ret += 1 + der_length_len (ret);
1157 0 : return ret;
1158 : }
1159 :
1160 : int ASN1CALL
1161 0 : copy_GENERATION(const GENERATION *from, GENERATION *to)
1162 : {
1163 0 : memset(to, 0, sizeof(*to));
1164 0 : if(copy_KerberosTime(&(from)->time, &(to)->time)) goto fail;
1165 0 : *(&(to)->usec) = *(&(from)->usec);
1166 0 : *(&(to)->gen) = *(&(from)->gen);
1167 0 : return 0;
1168 0 : fail:
1169 0 : free_GENERATION(to);
1170 0 : return ENOMEM;
1171 : }
1172 :
1173 : int ASN1CALL
1174 0 : encode_HDB_Ext_PKINIT_acl(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const HDB_Ext_PKINIT_acl *data, size_t *size)
1175 : {
1176 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
1177 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1178 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
1179 :
1180 0 : for(i = (int)(data)->len - 1; i >= 0; --i) {
1181 0 : size_t Top_tag_for_oldret = ret;
1182 0 : ret = 0;
1183 : /* anchor */
1184 0 : if((&(data)->val[i])->anchor) {
1185 0 : size_t Top_tag_S_Of_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
1186 0 : ret = 0;
1187 0 : e = der_put_utf8string(p, len, (&(data)->val[i])->anchor, &l);
1188 0 : if (e) return e;
1189 0 : p -= l; len -= l; ret += l;
1190 :
1191 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_UTF8String, &l);
1192 0 : if (e) return e;
1193 0 : p -= l; len -= l; ret += l;
1194 :
1195 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
1196 0 : if (e) return e;
1197 0 : p -= l; len -= l; ret += l;
1198 :
1199 0 : ret += Top_tag_S_Of_tag_oldret;
1200 : }
1201 : /* issuer */
1202 0 : if((&(data)->val[i])->issuer) {
1203 0 : size_t Top_tag_S_Of_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
1204 0 : ret = 0;
1205 0 : e = der_put_utf8string(p, len, (&(data)->val[i])->issuer, &l);
1206 0 : if (e) return e;
1207 0 : p -= l; len -= l; ret += l;
1208 :
1209 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_UTF8String, &l);
1210 0 : if (e) return e;
1211 0 : p -= l; len -= l; ret += l;
1212 :
1213 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
1214 0 : if (e) return e;
1215 0 : p -= l; len -= l; ret += l;
1216 :
1217 0 : ret += Top_tag_S_Of_tag_oldret;
1218 : }
1219 : /* subject */
1220 : {
1221 0 : size_t Top_tag_S_Of_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
1222 0 : ret = 0;
1223 0 : e = der_put_utf8string(p, len, &(&(data)->val[i])->subject, &l);
1224 0 : if (e) return e;
1225 0 : p -= l; len -= l; ret += l;
1226 :
1227 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_UTF8String, &l);
1228 0 : if (e) return e;
1229 0 : p -= l; len -= l; ret += l;
1230 :
1231 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
1232 0 : if (e) return e;
1233 0 : p -= l; len -= l; ret += l;
1234 :
1235 0 : ret += Top_tag_S_Of_tag_oldret;
1236 : }
1237 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
1238 0 : if (e) return e;
1239 0 : p -= l; len -= l; ret += l;
1240 :
1241 0 : ret += Top_tag_for_oldret;
1242 : }
1243 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
1244 0 : if (e) return e;
1245 0 : p -= l; len -= l; ret += l;
1246 :
1247 0 : *size = ret;
1248 0 : return 0;
1249 : }
1250 :
1251 : int ASN1CALL
1252 0 : decode_HDB_Ext_PKINIT_acl(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, HDB_Ext_PKINIT_acl *data, size_t *size)
1253 : {
1254 0 : size_t ret = 0;
1255 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1256 : int e HEIMDAL_UNUSED_ATTRIBUTE;
1257 :
1258 0 : memset(data, 0, sizeof(*data));
1259 : {
1260 : size_t Top_datalen, Top_oldlen;
1261 : Der_type Top_type;
1262 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
1263 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
1264 0 : if(e) goto fail;
1265 0 : p += l; len -= l; ret += l;
1266 0 : Top_oldlen = len;
1267 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1268 0 : len = Top_datalen;
1269 : {
1270 0 : size_t Top_Tag_origlen = len;
1271 0 : size_t Top_Tag_oldret = ret;
1272 0 : size_t Top_Tag_olen = 0;
1273 : void *Top_Tag_tmp;
1274 0 : ret = 0;
1275 0 : (data)->len = 0;
1276 0 : (data)->val = NULL;
1277 0 : while(ret < Top_Tag_origlen) {
1278 0 : size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
1279 0 : if (Top_Tag_olen > Top_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
1280 0 : Top_Tag_olen = Top_Tag_nlen;
1281 0 : Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
1282 0 : if (Top_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
1283 0 : (data)->val = Top_Tag_tmp;
1284 : {
1285 : size_t Top_Tag_s_of_datalen, Top_Tag_s_of_oldlen;
1286 : Der_type Top_Tag_s_of_type;
1287 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_Tag_s_of_type, UT_Sequence, &Top_Tag_s_of_datalen, &l);
1288 0 : if (e == 0 && Top_Tag_s_of_type != CONS) { e = ASN1_BAD_ID; }
1289 0 : if(e) goto fail;
1290 0 : p += l; len -= l; ret += l;
1291 0 : Top_Tag_s_of_oldlen = len;
1292 0 : if (Top_Tag_s_of_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1293 0 : len = Top_Tag_s_of_datalen;
1294 : {
1295 : size_t subject_datalen, subject_oldlen;
1296 : Der_type subject_type;
1297 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &subject_type, 0, &subject_datalen, &l);
1298 0 : if (e == 0 && subject_type != CONS) { e = ASN1_BAD_ID; }
1299 0 : if(e) goto fail;
1300 0 : p += l; len -= l; ret += l;
1301 0 : subject_oldlen = len;
1302 0 : if (subject_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1303 0 : len = subject_datalen;
1304 : {
1305 : size_t subject_Tag_datalen, subject_Tag_oldlen;
1306 : Der_type subject_Tag_type;
1307 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &subject_Tag_type, UT_UTF8String, &subject_Tag_datalen, &l);
1308 0 : if (e == 0 && subject_Tag_type != PRIM) { e = ASN1_BAD_ID; }
1309 0 : if(e) goto fail;
1310 0 : p += l; len -= l; ret += l;
1311 0 : subject_Tag_oldlen = len;
1312 0 : if (subject_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1313 0 : len = subject_Tag_datalen;
1314 0 : e = der_get_utf8string(p, len, &(&(data)->val[(data)->len])->subject, &l);
1315 0 : if(e) goto fail;
1316 0 : p += l; len -= l; ret += l;
1317 0 : len = subject_Tag_oldlen - subject_Tag_datalen;
1318 : }
1319 0 : len = subject_oldlen - subject_datalen;
1320 : }
1321 : {
1322 : size_t issuer_datalen, issuer_oldlen;
1323 : Der_type issuer_type;
1324 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &issuer_type, 1, &issuer_datalen, &l);
1325 0 : if (e == 0 && issuer_type != CONS) { e = ASN1_BAD_ID; }
1326 0 : if(e) {
1327 0 : (&(data)->val[(data)->len])->issuer = NULL;
1328 : } else {
1329 0 : (&(data)->val[(data)->len])->issuer = calloc(1, sizeof(*(&(data)->val[(data)->len])->issuer));
1330 0 : if ((&(data)->val[(data)->len])->issuer == NULL) { e = ENOMEM; goto fail; }
1331 0 : p += l; len -= l; ret += l;
1332 0 : issuer_oldlen = len;
1333 0 : if (issuer_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1334 0 : len = issuer_datalen;
1335 : {
1336 : size_t issuer_Tag_datalen, issuer_Tag_oldlen;
1337 : Der_type issuer_Tag_type;
1338 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &issuer_Tag_type, UT_UTF8String, &issuer_Tag_datalen, &l);
1339 0 : if (e == 0 && issuer_Tag_type != PRIM) { e = ASN1_BAD_ID; }
1340 0 : if(e) goto fail;
1341 0 : p += l; len -= l; ret += l;
1342 0 : issuer_Tag_oldlen = len;
1343 0 : if (issuer_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1344 0 : len = issuer_Tag_datalen;
1345 0 : e = der_get_utf8string(p, len, (&(data)->val[(data)->len])->issuer, &l);
1346 0 : if(e) goto fail;
1347 0 : p += l; len -= l; ret += l;
1348 0 : len = issuer_Tag_oldlen - issuer_Tag_datalen;
1349 : }
1350 0 : len = issuer_oldlen - issuer_datalen;
1351 : }
1352 : }
1353 : {
1354 : size_t anchor_datalen, anchor_oldlen;
1355 : Der_type anchor_type;
1356 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &anchor_type, 2, &anchor_datalen, &l);
1357 0 : if (e == 0 && anchor_type != CONS) { e = ASN1_BAD_ID; }
1358 0 : if(e) {
1359 0 : (&(data)->val[(data)->len])->anchor = NULL;
1360 : } else {
1361 0 : (&(data)->val[(data)->len])->anchor = calloc(1, sizeof(*(&(data)->val[(data)->len])->anchor));
1362 0 : if ((&(data)->val[(data)->len])->anchor == NULL) { e = ENOMEM; goto fail; }
1363 0 : p += l; len -= l; ret += l;
1364 0 : anchor_oldlen = len;
1365 0 : if (anchor_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1366 0 : len = anchor_datalen;
1367 : {
1368 : size_t anchor_Tag_datalen, anchor_Tag_oldlen;
1369 : Der_type anchor_Tag_type;
1370 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &anchor_Tag_type, UT_UTF8String, &anchor_Tag_datalen, &l);
1371 0 : if (e == 0 && anchor_Tag_type != PRIM) { e = ASN1_BAD_ID; }
1372 0 : if(e) goto fail;
1373 0 : p += l; len -= l; ret += l;
1374 0 : anchor_Tag_oldlen = len;
1375 0 : if (anchor_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1376 0 : len = anchor_Tag_datalen;
1377 0 : e = der_get_utf8string(p, len, (&(data)->val[(data)->len])->anchor, &l);
1378 0 : if(e) goto fail;
1379 0 : p += l; len -= l; ret += l;
1380 0 : len = anchor_Tag_oldlen - anchor_Tag_datalen;
1381 : }
1382 0 : len = anchor_oldlen - anchor_datalen;
1383 : }
1384 : }
1385 0 : len = Top_Tag_s_of_oldlen - Top_Tag_s_of_datalen;
1386 : }
1387 0 : (data)->len++;
1388 0 : len = Top_Tag_origlen - ret;
1389 : }
1390 0 : ret += Top_Tag_oldret;
1391 : }
1392 0 : len = Top_oldlen - Top_datalen;
1393 : }
1394 0 : if(size) *size = ret;
1395 0 : return 0;
1396 0 : fail:
1397 0 : free_HDB_Ext_PKINIT_acl(data);
1398 0 : return e;
1399 : }
1400 :
1401 : void ASN1CALL
1402 0 : free_HDB_Ext_PKINIT_acl(HDB_Ext_PKINIT_acl *data)
1403 : {
1404 0 : while((data)->len){
1405 0 : der_free_utf8string(&(&(data)->val[(data)->len-1])->subject);
1406 0 : if((&(data)->val[(data)->len-1])->issuer) {
1407 0 : der_free_utf8string((&(data)->val[(data)->len-1])->issuer);
1408 0 : free((&(data)->val[(data)->len-1])->issuer);
1409 0 : (&(data)->val[(data)->len-1])->issuer = NULL;
1410 : }
1411 0 : if((&(data)->val[(data)->len-1])->anchor) {
1412 0 : der_free_utf8string((&(data)->val[(data)->len-1])->anchor);
1413 0 : free((&(data)->val[(data)->len-1])->anchor);
1414 0 : (&(data)->val[(data)->len-1])->anchor = NULL;
1415 : }
1416 0 : (data)->len--;
1417 : }
1418 0 : free((data)->val);
1419 0 : (data)->val = NULL;
1420 0 : }
1421 :
1422 : size_t ASN1CALL
1423 0 : length_HDB_Ext_PKINIT_acl(const HDB_Ext_PKINIT_acl *data)
1424 : {
1425 0 : size_t ret = 0;
1426 : {
1427 0 : size_t Top_tag_oldret = ret;
1428 : int i;
1429 0 : ret = 0;
1430 0 : for(i = (data)->len - 1; i >= 0; --i){
1431 0 : size_t Top_tag_for_oldret = ret;
1432 0 : ret = 0;
1433 : {
1434 0 : size_t Top_tag_S_Of_tag_oldret = ret;
1435 0 : ret = 0;
1436 0 : ret += der_length_utf8string(&(&(data)->val[i])->subject);
1437 0 : ret += 1 + der_length_len (ret);
1438 0 : ret += 1 + der_length_len (ret);
1439 0 : ret += Top_tag_S_Of_tag_oldret;
1440 : }
1441 0 : if((&(data)->val[i])->issuer){
1442 0 : size_t Top_tag_S_Of_tag_oldret = ret;
1443 0 : ret = 0;
1444 0 : ret += der_length_utf8string((&(data)->val[i])->issuer);
1445 0 : ret += 1 + der_length_len (ret);
1446 0 : ret += 1 + der_length_len (ret);
1447 0 : ret += Top_tag_S_Of_tag_oldret;
1448 : }
1449 0 : if((&(data)->val[i])->anchor){
1450 0 : size_t Top_tag_S_Of_tag_oldret = ret;
1451 0 : ret = 0;
1452 0 : ret += der_length_utf8string((&(data)->val[i])->anchor);
1453 0 : ret += 1 + der_length_len (ret);
1454 0 : ret += 1 + der_length_len (ret);
1455 0 : ret += Top_tag_S_Of_tag_oldret;
1456 : }
1457 0 : ret += 1 + der_length_len (ret);
1458 0 : ret += Top_tag_for_oldret;
1459 : }
1460 0 : ret += Top_tag_oldret;
1461 : }
1462 0 : ret += 1 + der_length_len (ret);
1463 0 : return ret;
1464 : }
1465 :
1466 : int ASN1CALL
1467 0 : copy_HDB_Ext_PKINIT_acl(const HDB_Ext_PKINIT_acl *from, HDB_Ext_PKINIT_acl *to)
1468 : {
1469 0 : memset(to, 0, sizeof(*to));
1470 0 : if(((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
1471 0 : goto fail;
1472 0 : for((to)->len = 0; (to)->len < (from)->len; (to)->len++){
1473 0 : if(der_copy_utf8string(&(&(from)->val[(to)->len])->subject, &(&(to)->val[(to)->len])->subject)) goto fail;
1474 0 : if((&(from)->val[(to)->len])->issuer) {
1475 0 : (&(to)->val[(to)->len])->issuer = malloc(sizeof(*(&(to)->val[(to)->len])->issuer));
1476 0 : if((&(to)->val[(to)->len])->issuer == NULL) goto fail;
1477 0 : if(der_copy_utf8string((&(from)->val[(to)->len])->issuer, (&(to)->val[(to)->len])->issuer)) goto fail;
1478 : }else
1479 0 : (&(to)->val[(to)->len])->issuer = NULL;
1480 0 : if((&(from)->val[(to)->len])->anchor) {
1481 0 : (&(to)->val[(to)->len])->anchor = malloc(sizeof(*(&(to)->val[(to)->len])->anchor));
1482 0 : if((&(to)->val[(to)->len])->anchor == NULL) goto fail;
1483 0 : if(der_copy_utf8string((&(from)->val[(to)->len])->anchor, (&(to)->val[(to)->len])->anchor)) goto fail;
1484 : }else
1485 0 : (&(to)->val[(to)->len])->anchor = NULL;
1486 : }
1487 0 : return 0;
1488 0 : fail:
1489 0 : free_HDB_Ext_PKINIT_acl(to);
1490 0 : return ENOMEM;
1491 : }
1492 :
1493 : int ASN1CALL
1494 0 : encode_HDB_Ext_PKINIT_hash(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const HDB_Ext_PKINIT_hash *data, size_t *size)
1495 : {
1496 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
1497 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1498 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
1499 :
1500 0 : for(i = (int)(data)->len - 1; i >= 0; --i) {
1501 0 : size_t Top_tag_for_oldret = ret;
1502 0 : ret = 0;
1503 : /* digest */
1504 : {
1505 0 : size_t Top_tag_S_Of_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
1506 0 : ret = 0;
1507 0 : e = der_put_octet_string(p, len, &(&(data)->val[i])->digest, &l);
1508 0 : if (e) return e;
1509 0 : p -= l; len -= l; ret += l;
1510 :
1511 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
1512 0 : if (e) return e;
1513 0 : p -= l; len -= l; ret += l;
1514 :
1515 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
1516 0 : if (e) return e;
1517 0 : p -= l; len -= l; ret += l;
1518 :
1519 0 : ret += Top_tag_S_Of_tag_oldret;
1520 : }
1521 : /* digest-type */
1522 : {
1523 0 : size_t Top_tag_S_Of_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
1524 0 : ret = 0;
1525 0 : e = der_put_oid(p, len, &(&(data)->val[i])->digest_type, &l);
1526 0 : if (e) return e;
1527 0 : p -= l; len -= l; ret += l;
1528 :
1529 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OID, &l);
1530 0 : if (e) return e;
1531 0 : p -= l; len -= l; ret += l;
1532 :
1533 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
1534 0 : if (e) return e;
1535 0 : p -= l; len -= l; ret += l;
1536 :
1537 0 : ret += Top_tag_S_Of_tag_oldret;
1538 : }
1539 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
1540 0 : if (e) return e;
1541 0 : p -= l; len -= l; ret += l;
1542 :
1543 0 : ret += Top_tag_for_oldret;
1544 : }
1545 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
1546 0 : if (e) return e;
1547 0 : p -= l; len -= l; ret += l;
1548 :
1549 0 : *size = ret;
1550 0 : return 0;
1551 : }
1552 :
1553 : int ASN1CALL
1554 0 : decode_HDB_Ext_PKINIT_hash(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, HDB_Ext_PKINIT_hash *data, size_t *size)
1555 : {
1556 0 : size_t ret = 0;
1557 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1558 : int e HEIMDAL_UNUSED_ATTRIBUTE;
1559 :
1560 0 : memset(data, 0, sizeof(*data));
1561 : {
1562 : size_t Top_datalen, Top_oldlen;
1563 : Der_type Top_type;
1564 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
1565 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
1566 0 : if(e) goto fail;
1567 0 : p += l; len -= l; ret += l;
1568 0 : Top_oldlen = len;
1569 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1570 0 : len = Top_datalen;
1571 : {
1572 0 : size_t Top_Tag_origlen = len;
1573 0 : size_t Top_Tag_oldret = ret;
1574 0 : size_t Top_Tag_olen = 0;
1575 : void *Top_Tag_tmp;
1576 0 : ret = 0;
1577 0 : (data)->len = 0;
1578 0 : (data)->val = NULL;
1579 0 : while(ret < Top_Tag_origlen) {
1580 0 : size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
1581 0 : if (Top_Tag_olen > Top_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
1582 0 : Top_Tag_olen = Top_Tag_nlen;
1583 0 : Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
1584 0 : if (Top_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
1585 0 : (data)->val = Top_Tag_tmp;
1586 : {
1587 : size_t Top_Tag_s_of_datalen, Top_Tag_s_of_oldlen;
1588 : Der_type Top_Tag_s_of_type;
1589 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_Tag_s_of_type, UT_Sequence, &Top_Tag_s_of_datalen, &l);
1590 0 : if (e == 0 && Top_Tag_s_of_type != CONS) { e = ASN1_BAD_ID; }
1591 0 : if(e) goto fail;
1592 0 : p += l; len -= l; ret += l;
1593 0 : Top_Tag_s_of_oldlen = len;
1594 0 : if (Top_Tag_s_of_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1595 0 : len = Top_Tag_s_of_datalen;
1596 : {
1597 : size_t digest_type_datalen, digest_type_oldlen;
1598 : Der_type digest_type_type;
1599 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &digest_type_type, 0, &digest_type_datalen, &l);
1600 0 : if (e == 0 && digest_type_type != CONS) { e = ASN1_BAD_ID; }
1601 0 : if(e) goto fail;
1602 0 : p += l; len -= l; ret += l;
1603 0 : digest_type_oldlen = len;
1604 0 : if (digest_type_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1605 0 : len = digest_type_datalen;
1606 : {
1607 : size_t digest_type_Tag_datalen, digest_type_Tag_oldlen;
1608 : Der_type digest_type_Tag_type;
1609 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &digest_type_Tag_type, UT_OID, &digest_type_Tag_datalen, &l);
1610 0 : if (e == 0 && digest_type_Tag_type != PRIM) { e = ASN1_BAD_ID; }
1611 0 : if(e) goto fail;
1612 0 : p += l; len -= l; ret += l;
1613 0 : digest_type_Tag_oldlen = len;
1614 0 : if (digest_type_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1615 0 : len = digest_type_Tag_datalen;
1616 0 : e = der_get_oid(p, len, &(&(data)->val[(data)->len])->digest_type, &l);
1617 0 : if(e) goto fail;
1618 0 : p += l; len -= l; ret += l;
1619 0 : len = digest_type_Tag_oldlen - digest_type_Tag_datalen;
1620 : }
1621 0 : len = digest_type_oldlen - digest_type_datalen;
1622 : }
1623 : {
1624 : size_t digest_datalen, digest_oldlen;
1625 : Der_type digest_type;
1626 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &digest_type, 1, &digest_datalen, &l);
1627 0 : if (e == 0 && digest_type != CONS) { e = ASN1_BAD_ID; }
1628 0 : if(e) goto fail;
1629 0 : p += l; len -= l; ret += l;
1630 0 : digest_oldlen = len;
1631 0 : if (digest_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1632 0 : len = digest_datalen;
1633 : {
1634 : size_t digest_Tag_datalen, digest_Tag_oldlen;
1635 : Der_type digest_Tag_type;
1636 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &digest_Tag_type, UT_OctetString, &digest_Tag_datalen, &l);
1637 0 : if (e == 0 && digest_Tag_type != PRIM) { e = ASN1_BAD_ID; }
1638 0 : if(e) goto fail;
1639 0 : p += l; len -= l; ret += l;
1640 0 : digest_Tag_oldlen = len;
1641 0 : if (digest_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1642 0 : len = digest_Tag_datalen;
1643 0 : e = der_get_octet_string(p, len, &(&(data)->val[(data)->len])->digest, &l);
1644 0 : if(e) goto fail;
1645 0 : p += l; len -= l; ret += l;
1646 0 : len = digest_Tag_oldlen - digest_Tag_datalen;
1647 : }
1648 0 : len = digest_oldlen - digest_datalen;
1649 : }
1650 0 : len = Top_Tag_s_of_oldlen - Top_Tag_s_of_datalen;
1651 : }
1652 0 : (data)->len++;
1653 0 : len = Top_Tag_origlen - ret;
1654 : }
1655 0 : ret += Top_Tag_oldret;
1656 : }
1657 0 : len = Top_oldlen - Top_datalen;
1658 : }
1659 0 : if(size) *size = ret;
1660 0 : return 0;
1661 0 : fail:
1662 0 : free_HDB_Ext_PKINIT_hash(data);
1663 0 : return e;
1664 : }
1665 :
1666 : void ASN1CALL
1667 0 : free_HDB_Ext_PKINIT_hash(HDB_Ext_PKINIT_hash *data)
1668 : {
1669 0 : while((data)->len){
1670 0 : der_free_oid(&(&(data)->val[(data)->len-1])->digest_type);
1671 0 : der_free_octet_string(&(&(data)->val[(data)->len-1])->digest);
1672 0 : (data)->len--;
1673 : }
1674 0 : free((data)->val);
1675 0 : (data)->val = NULL;
1676 0 : }
1677 :
1678 : size_t ASN1CALL
1679 0 : length_HDB_Ext_PKINIT_hash(const HDB_Ext_PKINIT_hash *data)
1680 : {
1681 0 : size_t ret = 0;
1682 : {
1683 0 : size_t Top_tag_oldret = ret;
1684 : int i;
1685 0 : ret = 0;
1686 0 : for(i = (data)->len - 1; i >= 0; --i){
1687 0 : size_t Top_tag_for_oldret = ret;
1688 0 : ret = 0;
1689 : {
1690 0 : size_t Top_tag_S_Of_tag_oldret = ret;
1691 0 : ret = 0;
1692 0 : ret += der_length_oid(&(&(data)->val[i])->digest_type);
1693 0 : ret += 1 + der_length_len (ret);
1694 0 : ret += 1 + der_length_len (ret);
1695 0 : ret += Top_tag_S_Of_tag_oldret;
1696 : }
1697 : {
1698 0 : size_t Top_tag_S_Of_tag_oldret = ret;
1699 0 : ret = 0;
1700 0 : ret += der_length_octet_string(&(&(data)->val[i])->digest);
1701 0 : ret += 1 + der_length_len (ret);
1702 0 : ret += 1 + der_length_len (ret);
1703 0 : ret += Top_tag_S_Of_tag_oldret;
1704 : }
1705 0 : ret += 1 + der_length_len (ret);
1706 0 : ret += Top_tag_for_oldret;
1707 : }
1708 0 : ret += Top_tag_oldret;
1709 : }
1710 0 : ret += 1 + der_length_len (ret);
1711 0 : return ret;
1712 : }
1713 :
1714 : int ASN1CALL
1715 0 : copy_HDB_Ext_PKINIT_hash(const HDB_Ext_PKINIT_hash *from, HDB_Ext_PKINIT_hash *to)
1716 : {
1717 0 : memset(to, 0, sizeof(*to));
1718 0 : if(((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
1719 0 : goto fail;
1720 0 : for((to)->len = 0; (to)->len < (from)->len; (to)->len++){
1721 0 : if(der_copy_oid(&(&(from)->val[(to)->len])->digest_type, &(&(to)->val[(to)->len])->digest_type)) goto fail;
1722 0 : if(der_copy_octet_string(&(&(from)->val[(to)->len])->digest, &(&(to)->val[(to)->len])->digest)) goto fail;
1723 : }
1724 0 : return 0;
1725 0 : fail:
1726 0 : free_HDB_Ext_PKINIT_hash(to);
1727 0 : return ENOMEM;
1728 : }
1729 :
1730 : int ASN1CALL
1731 0 : encode_HDB_Ext_PKINIT_cert(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const HDB_Ext_PKINIT_cert *data, size_t *size)
1732 : {
1733 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
1734 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1735 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
1736 :
1737 0 : for(i = (int)(data)->len - 1; i >= 0; --i) {
1738 0 : size_t Top_tag_for_oldret = ret;
1739 0 : ret = 0;
1740 : /* cert */
1741 : {
1742 0 : size_t Top_tag_S_Of_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
1743 0 : ret = 0;
1744 0 : e = der_put_octet_string(p, len, &(&(data)->val[i])->cert, &l);
1745 0 : if (e) return e;
1746 0 : p -= l; len -= l; ret += l;
1747 :
1748 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
1749 0 : if (e) return e;
1750 0 : p -= l; len -= l; ret += l;
1751 :
1752 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
1753 0 : if (e) return e;
1754 0 : p -= l; len -= l; ret += l;
1755 :
1756 0 : ret += Top_tag_S_Of_tag_oldret;
1757 : }
1758 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
1759 0 : if (e) return e;
1760 0 : p -= l; len -= l; ret += l;
1761 :
1762 0 : ret += Top_tag_for_oldret;
1763 : }
1764 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
1765 0 : if (e) return e;
1766 0 : p -= l; len -= l; ret += l;
1767 :
1768 0 : *size = ret;
1769 0 : return 0;
1770 : }
1771 :
1772 : int ASN1CALL
1773 0 : decode_HDB_Ext_PKINIT_cert(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, HDB_Ext_PKINIT_cert *data, size_t *size)
1774 : {
1775 0 : size_t ret = 0;
1776 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1777 : int e HEIMDAL_UNUSED_ATTRIBUTE;
1778 :
1779 0 : memset(data, 0, sizeof(*data));
1780 : {
1781 : size_t Top_datalen, Top_oldlen;
1782 : Der_type Top_type;
1783 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
1784 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
1785 0 : if(e) goto fail;
1786 0 : p += l; len -= l; ret += l;
1787 0 : Top_oldlen = len;
1788 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1789 0 : len = Top_datalen;
1790 : {
1791 0 : size_t Top_Tag_origlen = len;
1792 0 : size_t Top_Tag_oldret = ret;
1793 0 : size_t Top_Tag_olen = 0;
1794 : void *Top_Tag_tmp;
1795 0 : ret = 0;
1796 0 : (data)->len = 0;
1797 0 : (data)->val = NULL;
1798 0 : while(ret < Top_Tag_origlen) {
1799 0 : size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
1800 0 : if (Top_Tag_olen > Top_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
1801 0 : Top_Tag_olen = Top_Tag_nlen;
1802 0 : Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
1803 0 : if (Top_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
1804 0 : (data)->val = Top_Tag_tmp;
1805 : {
1806 : size_t Top_Tag_s_of_datalen, Top_Tag_s_of_oldlen;
1807 : Der_type Top_Tag_s_of_type;
1808 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_Tag_s_of_type, UT_Sequence, &Top_Tag_s_of_datalen, &l);
1809 0 : if (e == 0 && Top_Tag_s_of_type != CONS) { e = ASN1_BAD_ID; }
1810 0 : if(e) goto fail;
1811 0 : p += l; len -= l; ret += l;
1812 0 : Top_Tag_s_of_oldlen = len;
1813 0 : if (Top_Tag_s_of_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1814 0 : len = Top_Tag_s_of_datalen;
1815 : {
1816 : size_t cert_datalen, cert_oldlen;
1817 : Der_type cert_type;
1818 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &cert_type, 0, &cert_datalen, &l);
1819 0 : if (e == 0 && cert_type != CONS) { e = ASN1_BAD_ID; }
1820 0 : if(e) goto fail;
1821 0 : p += l; len -= l; ret += l;
1822 0 : cert_oldlen = len;
1823 0 : if (cert_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1824 0 : len = cert_datalen;
1825 : {
1826 : size_t cert_Tag_datalen, cert_Tag_oldlen;
1827 : Der_type cert_Tag_type;
1828 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &cert_Tag_type, UT_OctetString, &cert_Tag_datalen, &l);
1829 0 : if (e == 0 && cert_Tag_type != PRIM) { e = ASN1_BAD_ID; }
1830 0 : if(e) goto fail;
1831 0 : p += l; len -= l; ret += l;
1832 0 : cert_Tag_oldlen = len;
1833 0 : if (cert_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1834 0 : len = cert_Tag_datalen;
1835 0 : e = der_get_octet_string(p, len, &(&(data)->val[(data)->len])->cert, &l);
1836 0 : if(e) goto fail;
1837 0 : p += l; len -= l; ret += l;
1838 0 : len = cert_Tag_oldlen - cert_Tag_datalen;
1839 : }
1840 0 : len = cert_oldlen - cert_datalen;
1841 : }
1842 0 : len = Top_Tag_s_of_oldlen - Top_Tag_s_of_datalen;
1843 : }
1844 0 : (data)->len++;
1845 0 : len = Top_Tag_origlen - ret;
1846 : }
1847 0 : ret += Top_Tag_oldret;
1848 : }
1849 0 : len = Top_oldlen - Top_datalen;
1850 : }
1851 0 : if(size) *size = ret;
1852 0 : return 0;
1853 0 : fail:
1854 0 : free_HDB_Ext_PKINIT_cert(data);
1855 0 : return e;
1856 : }
1857 :
1858 : void ASN1CALL
1859 0 : free_HDB_Ext_PKINIT_cert(HDB_Ext_PKINIT_cert *data)
1860 : {
1861 0 : while((data)->len){
1862 0 : der_free_octet_string(&(&(data)->val[(data)->len-1])->cert);
1863 0 : (data)->len--;
1864 : }
1865 0 : free((data)->val);
1866 0 : (data)->val = NULL;
1867 0 : }
1868 :
1869 : size_t ASN1CALL
1870 0 : length_HDB_Ext_PKINIT_cert(const HDB_Ext_PKINIT_cert *data)
1871 : {
1872 0 : size_t ret = 0;
1873 : {
1874 0 : size_t Top_tag_oldret = ret;
1875 : int i;
1876 0 : ret = 0;
1877 0 : for(i = (data)->len - 1; i >= 0; --i){
1878 0 : size_t Top_tag_for_oldret = ret;
1879 0 : ret = 0;
1880 : {
1881 0 : size_t Top_tag_S_Of_tag_oldret = ret;
1882 0 : ret = 0;
1883 0 : ret += der_length_octet_string(&(&(data)->val[i])->cert);
1884 0 : ret += 1 + der_length_len (ret);
1885 0 : ret += 1 + der_length_len (ret);
1886 0 : ret += Top_tag_S_Of_tag_oldret;
1887 : }
1888 0 : ret += 1 + der_length_len (ret);
1889 0 : ret += Top_tag_for_oldret;
1890 : }
1891 0 : ret += Top_tag_oldret;
1892 : }
1893 0 : ret += 1 + der_length_len (ret);
1894 0 : return ret;
1895 : }
1896 :
1897 : int ASN1CALL
1898 0 : copy_HDB_Ext_PKINIT_cert(const HDB_Ext_PKINIT_cert *from, HDB_Ext_PKINIT_cert *to)
1899 : {
1900 0 : memset(to, 0, sizeof(*to));
1901 0 : if(((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
1902 0 : goto fail;
1903 0 : for((to)->len = 0; (to)->len < (from)->len; (to)->len++){
1904 0 : if(der_copy_octet_string(&(&(from)->val[(to)->len])->cert, &(&(to)->val[(to)->len])->cert)) goto fail;
1905 : }
1906 0 : return 0;
1907 0 : fail:
1908 0 : free_HDB_Ext_PKINIT_cert(to);
1909 0 : return ENOMEM;
1910 : }
1911 :
1912 : int ASN1CALL
1913 0 : encode_HDB_Ext_Constrained_delegation_acl(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const HDB_Ext_Constrained_delegation_acl *data, size_t *size)
1914 : {
1915 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
1916 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1917 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
1918 :
1919 0 : for(i = (int)(data)->len - 1; i >= 0; --i) {
1920 0 : size_t Top_tag_for_oldret = ret;
1921 0 : ret = 0;
1922 0 : e = encode_Principal(p, len, &(data)->val[i], &l);
1923 0 : if (e) return e;
1924 0 : p -= l; len -= l; ret += l;
1925 :
1926 0 : ret += Top_tag_for_oldret;
1927 : }
1928 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &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_HDB_Ext_Constrained_delegation_acl(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, HDB_Ext_Constrained_delegation_acl *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_Sequence, &Top_datalen, &l);
1948 0 : if (e == 0 && Top_type != CONS) { 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 : {
1955 0 : size_t Top_Tag_origlen = len;
1956 0 : size_t Top_Tag_oldret = ret;
1957 0 : size_t Top_Tag_olen = 0;
1958 : void *Top_Tag_tmp;
1959 0 : ret = 0;
1960 0 : (data)->len = 0;
1961 0 : (data)->val = NULL;
1962 0 : while(ret < Top_Tag_origlen) {
1963 0 : size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
1964 0 : if (Top_Tag_olen > Top_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
1965 0 : Top_Tag_olen = Top_Tag_nlen;
1966 0 : Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
1967 0 : if (Top_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
1968 0 : (data)->val = Top_Tag_tmp;
1969 0 : e = decode_Principal(p, len, &(data)->val[(data)->len], &l);
1970 0 : if(e) goto fail;
1971 0 : p += l; len -= l; ret += l;
1972 0 : (data)->len++;
1973 0 : len = Top_Tag_origlen - ret;
1974 : }
1975 0 : ret += Top_Tag_oldret;
1976 : }
1977 0 : len = Top_oldlen - Top_datalen;
1978 : }
1979 0 : if(size) *size = ret;
1980 0 : return 0;
1981 0 : fail:
1982 0 : free_HDB_Ext_Constrained_delegation_acl(data);
1983 0 : return e;
1984 : }
1985 :
1986 : void ASN1CALL
1987 0 : free_HDB_Ext_Constrained_delegation_acl(HDB_Ext_Constrained_delegation_acl *data)
1988 : {
1989 0 : while((data)->len){
1990 0 : free_Principal(&(data)->val[(data)->len-1]);
1991 0 : (data)->len--;
1992 : }
1993 0 : free((data)->val);
1994 0 : (data)->val = NULL;
1995 0 : }
1996 :
1997 : size_t ASN1CALL
1998 0 : length_HDB_Ext_Constrained_delegation_acl(const HDB_Ext_Constrained_delegation_acl *data)
1999 : {
2000 0 : size_t ret = 0;
2001 : {
2002 0 : size_t Top_tag_oldret = ret;
2003 : int i;
2004 0 : ret = 0;
2005 0 : for(i = (data)->len - 1; i >= 0; --i){
2006 0 : size_t Top_tag_for_oldret = ret;
2007 0 : ret = 0;
2008 0 : ret += length_Principal(&(data)->val[i]);
2009 0 : ret += Top_tag_for_oldret;
2010 : }
2011 0 : ret += Top_tag_oldret;
2012 : }
2013 0 : ret += 1 + der_length_len (ret);
2014 0 : return ret;
2015 : }
2016 :
2017 : int ASN1CALL
2018 0 : copy_HDB_Ext_Constrained_delegation_acl(const HDB_Ext_Constrained_delegation_acl *from, HDB_Ext_Constrained_delegation_acl *to)
2019 : {
2020 0 : memset(to, 0, sizeof(*to));
2021 0 : if(((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
2022 0 : goto fail;
2023 0 : for((to)->len = 0; (to)->len < (from)->len; (to)->len++){
2024 0 : if(copy_Principal(&(from)->val[(to)->len], &(to)->val[(to)->len])) goto fail;
2025 : }
2026 0 : return 0;
2027 0 : fail:
2028 0 : free_HDB_Ext_Constrained_delegation_acl(to);
2029 0 : return ENOMEM;
2030 : }
2031 :
2032 : int ASN1CALL
2033 0 : encode_HDB_Ext_Lan_Manager_OWF(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const HDB_Ext_Lan_Manager_OWF *data, size_t *size)
2034 : {
2035 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
2036 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2037 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
2038 :
2039 0 : e = der_put_octet_string(p, len, data, &l);
2040 0 : if (e) return e;
2041 0 : p -= l; len -= l; ret += l;
2042 :
2043 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
2044 0 : if (e) return e;
2045 0 : p -= l; len -= l; ret += l;
2046 :
2047 0 : *size = ret;
2048 0 : return 0;
2049 : }
2050 :
2051 : int ASN1CALL
2052 0 : decode_HDB_Ext_Lan_Manager_OWF(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, HDB_Ext_Lan_Manager_OWF *data, size_t *size)
2053 : {
2054 0 : size_t ret = 0;
2055 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2056 : int e HEIMDAL_UNUSED_ATTRIBUTE;
2057 :
2058 0 : memset(data, 0, sizeof(*data));
2059 : {
2060 : size_t Top_datalen, Top_oldlen;
2061 : Der_type Top_type;
2062 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_OctetString, &Top_datalen, &l);
2063 0 : if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
2064 0 : if(e) goto fail;
2065 0 : p += l; len -= l; ret += l;
2066 0 : Top_oldlen = len;
2067 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2068 0 : len = Top_datalen;
2069 0 : e = der_get_octet_string(p, len, data, &l);
2070 0 : if(e) goto fail;
2071 0 : p += l; len -= l; ret += l;
2072 0 : len = Top_oldlen - Top_datalen;
2073 : }
2074 0 : if(size) *size = ret;
2075 0 : return 0;
2076 0 : fail:
2077 0 : free_HDB_Ext_Lan_Manager_OWF(data);
2078 0 : return e;
2079 : }
2080 :
2081 : void ASN1CALL
2082 0 : free_HDB_Ext_Lan_Manager_OWF(HDB_Ext_Lan_Manager_OWF *data)
2083 : {
2084 0 : der_free_octet_string(data);
2085 0 : }
2086 :
2087 : size_t ASN1CALL
2088 0 : length_HDB_Ext_Lan_Manager_OWF(const HDB_Ext_Lan_Manager_OWF *data)
2089 : {
2090 0 : size_t ret = 0;
2091 0 : ret += der_length_octet_string(data);
2092 0 : ret += 1 + der_length_len (ret);
2093 0 : return ret;
2094 : }
2095 :
2096 : int ASN1CALL
2097 0 : copy_HDB_Ext_Lan_Manager_OWF(const HDB_Ext_Lan_Manager_OWF *from, HDB_Ext_Lan_Manager_OWF *to)
2098 : {
2099 0 : memset(to, 0, sizeof(*to));
2100 0 : if(der_copy_octet_string(from, to)) goto fail;
2101 0 : return 0;
2102 0 : fail:
2103 0 : free_HDB_Ext_Lan_Manager_OWF(to);
2104 0 : return ENOMEM;
2105 : }
2106 :
2107 : int ASN1CALL
2108 0 : encode_HDB_Ext_Password(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const HDB_Ext_Password *data, size_t *size)
2109 : {
2110 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
2111 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2112 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
2113 :
2114 : /* password */
2115 : {
2116 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2117 0 : ret = 0;
2118 0 : e = der_put_octet_string(p, len, &(data)->password, &l);
2119 0 : if (e) return e;
2120 0 : p -= l; len -= l; ret += l;
2121 :
2122 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
2123 0 : if (e) return e;
2124 0 : p -= l; len -= l; ret += l;
2125 :
2126 0 : ret += Top_tag_oldret;
2127 : }
2128 : /* mkvno */
2129 0 : if((data)->mkvno) {
2130 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2131 0 : ret = 0;
2132 0 : e = der_put_unsigned(p, len, (data)->mkvno, &l);
2133 0 : if (e) return e;
2134 0 : p -= l; len -= l; ret += l;
2135 :
2136 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
2137 0 : if (e) return e;
2138 0 : p -= l; len -= l; ret += l;
2139 :
2140 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
2141 0 : if (e) return e;
2142 0 : p -= l; len -= l; ret += l;
2143 :
2144 0 : ret += Top_tag_oldret;
2145 : }
2146 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
2147 0 : if (e) return e;
2148 0 : p -= l; len -= l; ret += l;
2149 :
2150 0 : *size = ret;
2151 0 : return 0;
2152 : }
2153 :
2154 : int ASN1CALL
2155 0 : decode_HDB_Ext_Password(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, HDB_Ext_Password *data, size_t *size)
2156 : {
2157 0 : size_t ret = 0;
2158 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2159 : int e HEIMDAL_UNUSED_ATTRIBUTE;
2160 :
2161 0 : memset(data, 0, sizeof(*data));
2162 : {
2163 : size_t Top_datalen, Top_oldlen;
2164 : Der_type Top_type;
2165 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
2166 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
2167 0 : if(e) goto fail;
2168 0 : p += l; len -= l; ret += l;
2169 0 : Top_oldlen = len;
2170 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2171 0 : len = Top_datalen;
2172 : {
2173 : size_t mkvno_datalen, mkvno_oldlen;
2174 : Der_type mkvno_type;
2175 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &mkvno_type, 0, &mkvno_datalen, &l);
2176 0 : if (e == 0 && mkvno_type != CONS) { e = ASN1_BAD_ID; }
2177 0 : if(e) {
2178 0 : (data)->mkvno = NULL;
2179 : } else {
2180 0 : (data)->mkvno = calloc(1, sizeof(*(data)->mkvno));
2181 0 : if ((data)->mkvno == NULL) { e = ENOMEM; goto fail; }
2182 0 : p += l; len -= l; ret += l;
2183 0 : mkvno_oldlen = len;
2184 0 : if (mkvno_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2185 0 : len = mkvno_datalen;
2186 : {
2187 : size_t mkvno_Tag_datalen, mkvno_Tag_oldlen;
2188 : Der_type mkvno_Tag_type;
2189 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &mkvno_Tag_type, UT_Integer, &mkvno_Tag_datalen, &l);
2190 0 : if (e == 0 && mkvno_Tag_type != PRIM) { e = ASN1_BAD_ID; }
2191 0 : if(e) goto fail;
2192 0 : p += l; len -= l; ret += l;
2193 0 : mkvno_Tag_oldlen = len;
2194 0 : if (mkvno_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2195 0 : len = mkvno_Tag_datalen;
2196 0 : e = der_get_unsigned(p, len, (data)->mkvno, &l);
2197 0 : if(e) goto fail;
2198 0 : p += l; len -= l; ret += l;
2199 0 : len = mkvno_Tag_oldlen - mkvno_Tag_datalen;
2200 : }
2201 0 : len = mkvno_oldlen - mkvno_datalen;
2202 : }
2203 : }
2204 : {
2205 : size_t password_datalen, password_oldlen;
2206 : Der_type password_type;
2207 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &password_type, UT_OctetString, &password_datalen, &l);
2208 0 : if (e == 0 && password_type != PRIM) { e = ASN1_BAD_ID; }
2209 0 : if(e) goto fail;
2210 0 : p += l; len -= l; ret += l;
2211 0 : password_oldlen = len;
2212 0 : if (password_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2213 0 : len = password_datalen;
2214 0 : e = der_get_octet_string(p, len, &(data)->password, &l);
2215 0 : if(e) goto fail;
2216 0 : p += l; len -= l; ret += l;
2217 0 : len = password_oldlen - password_datalen;
2218 : }
2219 0 : len = Top_oldlen - Top_datalen;
2220 : }
2221 0 : if(size) *size = ret;
2222 0 : return 0;
2223 0 : fail:
2224 0 : free_HDB_Ext_Password(data);
2225 0 : return e;
2226 : }
2227 :
2228 : void ASN1CALL
2229 0 : free_HDB_Ext_Password(HDB_Ext_Password *data)
2230 : {
2231 0 : if((data)->mkvno) {
2232 0 : free((data)->mkvno);
2233 0 : (data)->mkvno = NULL;
2234 : }
2235 0 : der_free_octet_string(&(data)->password);
2236 0 : }
2237 :
2238 : size_t ASN1CALL
2239 0 : length_HDB_Ext_Password(const HDB_Ext_Password *data)
2240 : {
2241 0 : size_t ret = 0;
2242 0 : if((data)->mkvno){
2243 0 : size_t Top_tag_oldret = ret;
2244 0 : ret = 0;
2245 0 : ret += der_length_unsigned((data)->mkvno);
2246 0 : ret += 1 + der_length_len (ret);
2247 0 : ret += 1 + der_length_len (ret);
2248 0 : ret += Top_tag_oldret;
2249 : }
2250 : {
2251 0 : size_t Top_tag_oldret = ret;
2252 0 : ret = 0;
2253 0 : ret += der_length_octet_string(&(data)->password);
2254 0 : ret += 1 + der_length_len (ret);
2255 0 : ret += Top_tag_oldret;
2256 : }
2257 0 : ret += 1 + der_length_len (ret);
2258 0 : return ret;
2259 : }
2260 :
2261 : int ASN1CALL
2262 0 : copy_HDB_Ext_Password(const HDB_Ext_Password *from, HDB_Ext_Password *to)
2263 : {
2264 0 : memset(to, 0, sizeof(*to));
2265 0 : if((from)->mkvno) {
2266 0 : (to)->mkvno = malloc(sizeof(*(to)->mkvno));
2267 0 : if((to)->mkvno == NULL) goto fail;
2268 0 : *((to)->mkvno) = *((from)->mkvno);
2269 : }else
2270 0 : (to)->mkvno = NULL;
2271 0 : if(der_copy_octet_string(&(from)->password, &(to)->password)) goto fail;
2272 0 : return 0;
2273 0 : fail:
2274 0 : free_HDB_Ext_Password(to);
2275 0 : return ENOMEM;
2276 : }
2277 :
2278 : int ASN1CALL
2279 0 : encode_HDB_Ext_Aliases(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const HDB_Ext_Aliases *data, size_t *size)
2280 : {
2281 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
2282 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2283 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
2284 :
2285 : /* aliases */
2286 : {
2287 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2288 0 : ret = 0;
2289 0 : for(i = (int)(&(data)->aliases)->len - 1; i >= 0; --i) {
2290 0 : size_t aliases_tag_tag_for_oldret = ret;
2291 0 : ret = 0;
2292 0 : e = encode_Principal(p, len, &(&(data)->aliases)->val[i], &l);
2293 0 : if (e) return e;
2294 0 : p -= l; len -= l; ret += l;
2295 :
2296 0 : ret += aliases_tag_tag_for_oldret;
2297 : }
2298 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
2299 0 : if (e) return e;
2300 0 : p -= l; len -= l; ret += l;
2301 :
2302 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
2303 0 : if (e) return e;
2304 0 : p -= l; len -= l; ret += l;
2305 :
2306 0 : ret += Top_tag_oldret;
2307 : }
2308 : /* case-insensitive */
2309 : {
2310 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2311 0 : ret = 0;
2312 0 : e = der_put_boolean(p, len, &(data)->case_insensitive, &l);
2313 0 : if (e) return e;
2314 0 : p -= l; len -= l; ret += l;
2315 :
2316 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Boolean, &l);
2317 0 : if (e) return e;
2318 0 : p -= l; len -= l; ret += l;
2319 :
2320 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
2321 0 : if (e) return e;
2322 0 : p -= l; len -= l; ret += l;
2323 :
2324 0 : ret += Top_tag_oldret;
2325 : }
2326 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
2327 0 : if (e) return e;
2328 0 : p -= l; len -= l; ret += l;
2329 :
2330 0 : *size = ret;
2331 0 : return 0;
2332 : }
2333 :
2334 : int ASN1CALL
2335 0 : decode_HDB_Ext_Aliases(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, HDB_Ext_Aliases *data, size_t *size)
2336 : {
2337 0 : size_t ret = 0;
2338 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2339 : int e HEIMDAL_UNUSED_ATTRIBUTE;
2340 :
2341 0 : memset(data, 0, sizeof(*data));
2342 : {
2343 : size_t Top_datalen, Top_oldlen;
2344 : Der_type Top_type;
2345 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
2346 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
2347 0 : if(e) goto fail;
2348 0 : p += l; len -= l; ret += l;
2349 0 : Top_oldlen = len;
2350 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2351 0 : len = Top_datalen;
2352 : {
2353 : size_t case_insensitive_datalen, case_insensitive_oldlen;
2354 : Der_type case_insensitive_type;
2355 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &case_insensitive_type, 0, &case_insensitive_datalen, &l);
2356 0 : if (e == 0 && case_insensitive_type != CONS) { e = ASN1_BAD_ID; }
2357 0 : if(e) goto fail;
2358 0 : p += l; len -= l; ret += l;
2359 0 : case_insensitive_oldlen = len;
2360 0 : if (case_insensitive_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2361 0 : len = case_insensitive_datalen;
2362 : {
2363 : size_t case_insensitive_Tag_datalen, case_insensitive_Tag_oldlen;
2364 : Der_type case_insensitive_Tag_type;
2365 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &case_insensitive_Tag_type, UT_Boolean, &case_insensitive_Tag_datalen, &l);
2366 0 : if (e == 0 && case_insensitive_Tag_type != PRIM) { e = ASN1_BAD_ID; }
2367 0 : if(e) goto fail;
2368 0 : p += l; len -= l; ret += l;
2369 0 : case_insensitive_Tag_oldlen = len;
2370 0 : if (case_insensitive_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2371 0 : len = case_insensitive_Tag_datalen;
2372 0 : e = der_get_boolean(p, len, &(data)->case_insensitive, &l);
2373 0 : if(e) goto fail;
2374 0 : p += l; len -= l; ret += l;
2375 0 : len = case_insensitive_Tag_oldlen - case_insensitive_Tag_datalen;
2376 : }
2377 0 : len = case_insensitive_oldlen - case_insensitive_datalen;
2378 : }
2379 : {
2380 : size_t aliases_datalen, aliases_oldlen;
2381 : Der_type aliases_type;
2382 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &aliases_type, 1, &aliases_datalen, &l);
2383 0 : if (e == 0 && aliases_type != CONS) { e = ASN1_BAD_ID; }
2384 0 : if(e) goto fail;
2385 0 : p += l; len -= l; ret += l;
2386 0 : aliases_oldlen = len;
2387 0 : if (aliases_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2388 0 : len = aliases_datalen;
2389 : {
2390 : size_t aliases_Tag_datalen, aliases_Tag_oldlen;
2391 : Der_type aliases_Tag_type;
2392 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &aliases_Tag_type, UT_Sequence, &aliases_Tag_datalen, &l);
2393 0 : if (e == 0 && aliases_Tag_type != CONS) { e = ASN1_BAD_ID; }
2394 0 : if(e) goto fail;
2395 0 : p += l; len -= l; ret += l;
2396 0 : aliases_Tag_oldlen = len;
2397 0 : if (aliases_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2398 0 : len = aliases_Tag_datalen;
2399 : {
2400 0 : size_t aliases_Tag_Tag_origlen = len;
2401 0 : size_t aliases_Tag_Tag_oldret = ret;
2402 0 : size_t aliases_Tag_Tag_olen = 0;
2403 : void *aliases_Tag_Tag_tmp;
2404 0 : ret = 0;
2405 0 : (&(data)->aliases)->len = 0;
2406 0 : (&(data)->aliases)->val = NULL;
2407 0 : while(ret < aliases_Tag_Tag_origlen) {
2408 0 : size_t aliases_Tag_Tag_nlen = aliases_Tag_Tag_olen + sizeof(*((&(data)->aliases)->val));
2409 0 : if (aliases_Tag_Tag_olen > aliases_Tag_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
2410 0 : aliases_Tag_Tag_olen = aliases_Tag_Tag_nlen;
2411 0 : aliases_Tag_Tag_tmp = realloc((&(data)->aliases)->val, aliases_Tag_Tag_olen);
2412 0 : if (aliases_Tag_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
2413 0 : (&(data)->aliases)->val = aliases_Tag_Tag_tmp;
2414 0 : e = decode_Principal(p, len, &(&(data)->aliases)->val[(&(data)->aliases)->len], &l);
2415 0 : if(e) goto fail;
2416 0 : p += l; len -= l; ret += l;
2417 0 : (&(data)->aliases)->len++;
2418 0 : len = aliases_Tag_Tag_origlen - ret;
2419 : }
2420 0 : ret += aliases_Tag_Tag_oldret;
2421 : }
2422 0 : len = aliases_Tag_oldlen - aliases_Tag_datalen;
2423 : }
2424 0 : len = aliases_oldlen - aliases_datalen;
2425 : }
2426 0 : len = Top_oldlen - Top_datalen;
2427 : }
2428 0 : if(size) *size = ret;
2429 0 : return 0;
2430 0 : fail:
2431 0 : free_HDB_Ext_Aliases(data);
2432 0 : return e;
2433 : }
2434 :
2435 : void ASN1CALL
2436 0 : free_HDB_Ext_Aliases(HDB_Ext_Aliases *data)
2437 : {
2438 0 : while((&(data)->aliases)->len){
2439 0 : free_Principal(&(&(data)->aliases)->val[(&(data)->aliases)->len-1]);
2440 0 : (&(data)->aliases)->len--;
2441 : }
2442 0 : free((&(data)->aliases)->val);
2443 0 : (&(data)->aliases)->val = NULL;
2444 0 : }
2445 :
2446 : size_t ASN1CALL
2447 0 : length_HDB_Ext_Aliases(const HDB_Ext_Aliases *data)
2448 : {
2449 0 : size_t ret = 0;
2450 : {
2451 0 : size_t Top_tag_oldret = ret;
2452 0 : ret = 0;
2453 0 : ret += 1;
2454 0 : ret += 1 + der_length_len (ret);
2455 0 : ret += 1 + der_length_len (ret);
2456 0 : ret += Top_tag_oldret;
2457 : }
2458 : {
2459 0 : size_t Top_tag_oldret = ret;
2460 0 : ret = 0;
2461 : {
2462 0 : size_t aliases_tag_tag_oldret = ret;
2463 : int i;
2464 0 : ret = 0;
2465 0 : for(i = (&(data)->aliases)->len - 1; i >= 0; --i){
2466 0 : size_t aliases_tag_tag_for_oldret = ret;
2467 0 : ret = 0;
2468 0 : ret += length_Principal(&(&(data)->aliases)->val[i]);
2469 0 : ret += aliases_tag_tag_for_oldret;
2470 : }
2471 0 : ret += aliases_tag_tag_oldret;
2472 : }
2473 0 : ret += 1 + der_length_len (ret);
2474 0 : ret += 1 + der_length_len (ret);
2475 0 : ret += Top_tag_oldret;
2476 : }
2477 0 : ret += 1 + der_length_len (ret);
2478 0 : return ret;
2479 : }
2480 :
2481 : int ASN1CALL
2482 0 : copy_HDB_Ext_Aliases(const HDB_Ext_Aliases *from, HDB_Ext_Aliases *to)
2483 : {
2484 0 : memset(to, 0, sizeof(*to));
2485 0 : *(&(to)->case_insensitive) = *(&(from)->case_insensitive);
2486 0 : if(((&(to)->aliases)->val = malloc((&(from)->aliases)->len * sizeof(*(&(to)->aliases)->val))) == NULL && (&(from)->aliases)->len != 0)
2487 0 : goto fail;
2488 0 : for((&(to)->aliases)->len = 0; (&(to)->aliases)->len < (&(from)->aliases)->len; (&(to)->aliases)->len++){
2489 0 : if(copy_Principal(&(&(from)->aliases)->val[(&(to)->aliases)->len], &(&(to)->aliases)->val[(&(to)->aliases)->len])) goto fail;
2490 : }
2491 0 : return 0;
2492 0 : fail:
2493 0 : free_HDB_Ext_Aliases(to);
2494 0 : return ENOMEM;
2495 : }
2496 :
2497 : int ASN1CALL
2498 0 : encode_Keys(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const Keys *data, size_t *size)
2499 : {
2500 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
2501 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2502 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
2503 :
2504 0 : for(i = (int)(data)->len - 1; i >= 0; --i) {
2505 0 : size_t Top_tag_for_oldret = ret;
2506 0 : ret = 0;
2507 0 : e = encode_Key(p, len, &(data)->val[i], &l);
2508 0 : if (e) return e;
2509 0 : p -= l; len -= l; ret += l;
2510 :
2511 0 : ret += Top_tag_for_oldret;
2512 : }
2513 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
2514 0 : if (e) return e;
2515 0 : p -= l; len -= l; ret += l;
2516 :
2517 0 : *size = ret;
2518 0 : return 0;
2519 : }
2520 :
2521 : int ASN1CALL
2522 0 : decode_Keys(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, Keys *data, size_t *size)
2523 : {
2524 0 : size_t ret = 0;
2525 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2526 : int e HEIMDAL_UNUSED_ATTRIBUTE;
2527 :
2528 0 : memset(data, 0, sizeof(*data));
2529 : {
2530 : size_t Top_datalen, Top_oldlen;
2531 : Der_type Top_type;
2532 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
2533 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
2534 0 : if(e) goto fail;
2535 0 : p += l; len -= l; ret += l;
2536 0 : Top_oldlen = len;
2537 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2538 0 : len = Top_datalen;
2539 : {
2540 0 : size_t Top_Tag_origlen = len;
2541 0 : size_t Top_Tag_oldret = ret;
2542 0 : size_t Top_Tag_olen = 0;
2543 : void *Top_Tag_tmp;
2544 0 : ret = 0;
2545 0 : (data)->len = 0;
2546 0 : (data)->val = NULL;
2547 0 : while(ret < Top_Tag_origlen) {
2548 0 : size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
2549 0 : if (Top_Tag_olen > Top_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
2550 0 : Top_Tag_olen = Top_Tag_nlen;
2551 0 : Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
2552 0 : if (Top_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
2553 0 : (data)->val = Top_Tag_tmp;
2554 0 : e = decode_Key(p, len, &(data)->val[(data)->len], &l);
2555 0 : if(e) goto fail;
2556 0 : p += l; len -= l; ret += l;
2557 0 : (data)->len++;
2558 0 : len = Top_Tag_origlen - ret;
2559 : }
2560 0 : ret += Top_Tag_oldret;
2561 : }
2562 0 : len = Top_oldlen - Top_datalen;
2563 : }
2564 0 : if(size) *size = ret;
2565 0 : return 0;
2566 0 : fail:
2567 0 : free_Keys(data);
2568 0 : return e;
2569 : }
2570 :
2571 : void ASN1CALL
2572 244004 : free_Keys(Keys *data)
2573 : {
2574 1171378 : while((data)->len){
2575 683370 : free_Key(&(data)->val[(data)->len-1]);
2576 683370 : (data)->len--;
2577 : }
2578 244004 : free((data)->val);
2579 244004 : (data)->val = NULL;
2580 244004 : }
2581 :
2582 : size_t ASN1CALL
2583 0 : length_Keys(const Keys *data)
2584 : {
2585 0 : size_t ret = 0;
2586 : {
2587 0 : size_t Top_tag_oldret = ret;
2588 : int i;
2589 0 : ret = 0;
2590 0 : for(i = (data)->len - 1; i >= 0; --i){
2591 0 : size_t Top_tag_for_oldret = ret;
2592 0 : ret = 0;
2593 0 : ret += length_Key(&(data)->val[i]);
2594 0 : ret += Top_tag_for_oldret;
2595 : }
2596 0 : ret += Top_tag_oldret;
2597 : }
2598 0 : ret += 1 + der_length_len (ret);
2599 0 : return ret;
2600 : }
2601 :
2602 : int ASN1CALL
2603 0 : copy_Keys(const Keys *from, Keys *to)
2604 : {
2605 0 : memset(to, 0, sizeof(*to));
2606 0 : if(((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
2607 0 : goto fail;
2608 0 : for((to)->len = 0; (to)->len < (from)->len; (to)->len++){
2609 0 : if(copy_Key(&(from)->val[(to)->len], &(to)->val[(to)->len])) goto fail;
2610 : }
2611 0 : return 0;
2612 0 : fail:
2613 0 : free_Keys(to);
2614 0 : return ENOMEM;
2615 : }
2616 :
2617 : int ASN1CALL
2618 0 : add_Keys(Keys *data, const Key *element)
2619 : {
2620 : int ret;
2621 : void *ptr;
2622 :
2623 0 : ptr = realloc(data->val,
2624 0 : (data->len + 1) * sizeof(data->val[0]));
2625 0 : if (ptr == NULL) return ENOMEM;
2626 0 : data->val = ptr;
2627 :
2628 0 : ret = copy_Key(element, &data->val[data->len]);
2629 0 : if (ret) return ret;
2630 0 : data->len++;
2631 0 : return 0;
2632 : }
2633 :
2634 : int ASN1CALL
2635 0 : remove_Keys(Keys *data, unsigned int element)
2636 : {
2637 : void *ptr;
2638 :
2639 0 : if (data->len == 0 || element >= data->len)
2640 0 : return ASN1_OVERRUN;
2641 0 : free_Key(&data->val[element]);
2642 0 : data->len--;
2643 0 : if (element < data->len)
2644 0 : memmove(&data->val[element], &data->val[element + 1],
2645 0 : sizeof(data->val[0]) * data->len);
2646 0 : ptr = realloc(data->val, data->len * sizeof(data->val[0]));
2647 0 : if (ptr != NULL || data->len == 0) data->val = ptr;
2648 0 : return 0;
2649 : }
2650 :
2651 : int ASN1CALL
2652 0 : encode_hdb_keyset(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const hdb_keyset *data, size_t *size)
2653 : {
2654 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
2655 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2656 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
2657 :
2658 : /* set-time */
2659 0 : if((data)->set_time) {
2660 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2661 0 : ret = 0;
2662 0 : e = encode_KerberosTime(p, len, (data)->set_time, &l);
2663 0 : if (e) return e;
2664 0 : p -= l; len -= l; ret += l;
2665 :
2666 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
2667 0 : if (e) return e;
2668 0 : p -= l; len -= l; ret += l;
2669 :
2670 0 : ret += Top_tag_oldret;
2671 : }
2672 : /* keys */
2673 : {
2674 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2675 0 : ret = 0;
2676 0 : e = encode_Keys(p, len, &(data)->keys, &l);
2677 0 : if (e) return e;
2678 0 : p -= l; len -= l; ret += l;
2679 :
2680 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
2681 0 : if (e) return e;
2682 0 : p -= l; len -= l; ret += l;
2683 :
2684 0 : ret += Top_tag_oldret;
2685 : }
2686 : /* kvno */
2687 : {
2688 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2689 0 : ret = 0;
2690 0 : e = der_put_unsigned(p, len, &(data)->kvno, &l);
2691 0 : if (e) return e;
2692 0 : p -= l; len -= l; ret += l;
2693 :
2694 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
2695 0 : if (e) return e;
2696 0 : p -= l; len -= l; ret += l;
2697 :
2698 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
2699 0 : if (e) return e;
2700 0 : p -= l; len -= l; ret += l;
2701 :
2702 0 : ret += Top_tag_oldret;
2703 : }
2704 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
2705 0 : if (e) return e;
2706 0 : p -= l; len -= l; ret += l;
2707 :
2708 0 : *size = ret;
2709 0 : return 0;
2710 : }
2711 :
2712 : int ASN1CALL
2713 0 : decode_hdb_keyset(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, hdb_keyset *data, size_t *size)
2714 : {
2715 0 : size_t ret = 0;
2716 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2717 : int e HEIMDAL_UNUSED_ATTRIBUTE;
2718 :
2719 0 : memset(data, 0, sizeof(*data));
2720 : {
2721 : size_t Top_datalen, Top_oldlen;
2722 : Der_type Top_type;
2723 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
2724 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
2725 0 : if(e) goto fail;
2726 0 : p += l; len -= l; ret += l;
2727 0 : Top_oldlen = len;
2728 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2729 0 : len = Top_datalen;
2730 : {
2731 : size_t kvno_datalen, kvno_oldlen;
2732 : Der_type kvno_type;
2733 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &kvno_type, 0, &kvno_datalen, &l);
2734 0 : if (e == 0 && kvno_type != CONS) { e = ASN1_BAD_ID; }
2735 0 : if(e) goto fail;
2736 0 : p += l; len -= l; ret += l;
2737 0 : kvno_oldlen = len;
2738 0 : if (kvno_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2739 0 : len = kvno_datalen;
2740 : {
2741 : size_t kvno_Tag_datalen, kvno_Tag_oldlen;
2742 : Der_type kvno_Tag_type;
2743 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &kvno_Tag_type, UT_Integer, &kvno_Tag_datalen, &l);
2744 0 : if (e == 0 && kvno_Tag_type != PRIM) { e = ASN1_BAD_ID; }
2745 0 : if(e) goto fail;
2746 0 : p += l; len -= l; ret += l;
2747 0 : kvno_Tag_oldlen = len;
2748 0 : if (kvno_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2749 0 : len = kvno_Tag_datalen;
2750 0 : e = der_get_unsigned(p, len, &(data)->kvno, &l);
2751 0 : if(e) goto fail;
2752 0 : p += l; len -= l; ret += l;
2753 0 : len = kvno_Tag_oldlen - kvno_Tag_datalen;
2754 : }
2755 0 : len = kvno_oldlen - kvno_datalen;
2756 : }
2757 : {
2758 : size_t keys_datalen, keys_oldlen;
2759 : Der_type keys_type;
2760 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &keys_type, 1, &keys_datalen, &l);
2761 0 : if (e == 0 && keys_type != CONS) { e = ASN1_BAD_ID; }
2762 0 : if(e) goto fail;
2763 0 : p += l; len -= l; ret += l;
2764 0 : keys_oldlen = len;
2765 0 : if (keys_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2766 0 : len = keys_datalen;
2767 0 : e = decode_Keys(p, len, &(data)->keys, &l);
2768 0 : if(e) goto fail;
2769 0 : p += l; len -= l; ret += l;
2770 0 : len = keys_oldlen - keys_datalen;
2771 : }
2772 : {
2773 : size_t set_time_datalen, set_time_oldlen;
2774 : Der_type set_time_type;
2775 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &set_time_type, 2, &set_time_datalen, &l);
2776 0 : if (e == 0 && set_time_type != CONS) { e = ASN1_BAD_ID; }
2777 0 : if(e) {
2778 0 : (data)->set_time = NULL;
2779 : } else {
2780 0 : (data)->set_time = calloc(1, sizeof(*(data)->set_time));
2781 0 : if ((data)->set_time == NULL) { e = ENOMEM; goto fail; }
2782 0 : p += l; len -= l; ret += l;
2783 0 : set_time_oldlen = len;
2784 0 : if (set_time_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2785 0 : len = set_time_datalen;
2786 0 : e = decode_KerberosTime(p, len, (data)->set_time, &l);
2787 0 : if(e) goto fail;
2788 0 : p += l; len -= l; ret += l;
2789 0 : len = set_time_oldlen - set_time_datalen;
2790 : }
2791 : }
2792 0 : len = Top_oldlen - Top_datalen;
2793 : }
2794 0 : if(size) *size = ret;
2795 0 : return 0;
2796 0 : fail:
2797 0 : free_hdb_keyset(data);
2798 0 : return e;
2799 : }
2800 :
2801 : void ASN1CALL
2802 0 : free_hdb_keyset(hdb_keyset *data)
2803 : {
2804 0 : free_Keys(&(data)->keys);
2805 0 : if((data)->set_time) {
2806 0 : free_KerberosTime((data)->set_time);
2807 0 : free((data)->set_time);
2808 0 : (data)->set_time = NULL;
2809 : }
2810 0 : }
2811 :
2812 : size_t ASN1CALL
2813 0 : length_hdb_keyset(const hdb_keyset *data)
2814 : {
2815 0 : size_t ret = 0;
2816 : {
2817 0 : size_t Top_tag_oldret = ret;
2818 0 : ret = 0;
2819 0 : ret += der_length_unsigned(&(data)->kvno);
2820 0 : ret += 1 + der_length_len (ret);
2821 0 : ret += 1 + der_length_len (ret);
2822 0 : ret += Top_tag_oldret;
2823 : }
2824 : {
2825 0 : size_t Top_tag_oldret = ret;
2826 0 : ret = 0;
2827 0 : ret += length_Keys(&(data)->keys);
2828 0 : ret += 1 + der_length_len (ret);
2829 0 : ret += Top_tag_oldret;
2830 : }
2831 0 : if((data)->set_time){
2832 0 : size_t Top_tag_oldret = ret;
2833 0 : ret = 0;
2834 0 : ret += length_KerberosTime((data)->set_time);
2835 0 : ret += 1 + der_length_len (ret);
2836 0 : ret += Top_tag_oldret;
2837 : }
2838 0 : ret += 1 + der_length_len (ret);
2839 0 : return ret;
2840 : }
2841 :
2842 : int ASN1CALL
2843 0 : copy_hdb_keyset(const hdb_keyset *from, hdb_keyset *to)
2844 : {
2845 0 : memset(to, 0, sizeof(*to));
2846 0 : *(&(to)->kvno) = *(&(from)->kvno);
2847 0 : if(copy_Keys(&(from)->keys, &(to)->keys)) goto fail;
2848 0 : if((from)->set_time) {
2849 0 : (to)->set_time = malloc(sizeof(*(to)->set_time));
2850 0 : if((to)->set_time == NULL) goto fail;
2851 0 : if(copy_KerberosTime((from)->set_time, (to)->set_time)) goto fail;
2852 : }else
2853 0 : (to)->set_time = NULL;
2854 0 : return 0;
2855 0 : fail:
2856 0 : free_hdb_keyset(to);
2857 0 : return ENOMEM;
2858 : }
2859 :
2860 : int ASN1CALL
2861 0 : encode_HDB_Ext_KeySet(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const HDB_Ext_KeySet *data, size_t *size)
2862 : {
2863 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
2864 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2865 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
2866 :
2867 0 : for(i = (int)(data)->len - 1; i >= 0; --i) {
2868 0 : size_t Top_tag_for_oldret = ret;
2869 0 : ret = 0;
2870 0 : e = encode_hdb_keyset(p, len, &(data)->val[i], &l);
2871 0 : if (e) return e;
2872 0 : p -= l; len -= l; ret += l;
2873 :
2874 0 : ret += Top_tag_for_oldret;
2875 : }
2876 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
2877 0 : if (e) return e;
2878 0 : p -= l; len -= l; ret += l;
2879 :
2880 0 : *size = ret;
2881 0 : return 0;
2882 : }
2883 :
2884 : int ASN1CALL
2885 0 : decode_HDB_Ext_KeySet(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, HDB_Ext_KeySet *data, size_t *size)
2886 : {
2887 0 : size_t ret = 0;
2888 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2889 : int e HEIMDAL_UNUSED_ATTRIBUTE;
2890 :
2891 0 : memset(data, 0, sizeof(*data));
2892 : {
2893 : size_t Top_datalen, Top_oldlen;
2894 : Der_type Top_type;
2895 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
2896 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
2897 0 : if(e) goto fail;
2898 0 : p += l; len -= l; ret += l;
2899 0 : Top_oldlen = len;
2900 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2901 0 : len = Top_datalen;
2902 : {
2903 0 : size_t Top_Tag_origlen = len;
2904 0 : size_t Top_Tag_oldret = ret;
2905 0 : size_t Top_Tag_olen = 0;
2906 : void *Top_Tag_tmp;
2907 0 : ret = 0;
2908 0 : (data)->len = 0;
2909 0 : (data)->val = NULL;
2910 0 : while(ret < Top_Tag_origlen) {
2911 0 : size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
2912 0 : if (Top_Tag_olen > Top_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
2913 0 : Top_Tag_olen = Top_Tag_nlen;
2914 0 : Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
2915 0 : if (Top_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
2916 0 : (data)->val = Top_Tag_tmp;
2917 0 : e = decode_hdb_keyset(p, len, &(data)->val[(data)->len], &l);
2918 0 : if(e) goto fail;
2919 0 : p += l; len -= l; ret += l;
2920 0 : (data)->len++;
2921 0 : len = Top_Tag_origlen - ret;
2922 : }
2923 0 : ret += Top_Tag_oldret;
2924 : }
2925 0 : len = Top_oldlen - Top_datalen;
2926 : }
2927 0 : if(size) *size = ret;
2928 0 : return 0;
2929 0 : fail:
2930 0 : free_HDB_Ext_KeySet(data);
2931 0 : return e;
2932 : }
2933 :
2934 : void ASN1CALL
2935 0 : free_HDB_Ext_KeySet(HDB_Ext_KeySet *data)
2936 : {
2937 0 : while((data)->len){
2938 0 : free_hdb_keyset(&(data)->val[(data)->len-1]);
2939 0 : (data)->len--;
2940 : }
2941 0 : free((data)->val);
2942 0 : (data)->val = NULL;
2943 0 : }
2944 :
2945 : size_t ASN1CALL
2946 0 : length_HDB_Ext_KeySet(const HDB_Ext_KeySet *data)
2947 : {
2948 0 : size_t ret = 0;
2949 : {
2950 0 : size_t Top_tag_oldret = ret;
2951 : int i;
2952 0 : ret = 0;
2953 0 : for(i = (data)->len - 1; i >= 0; --i){
2954 0 : size_t Top_tag_for_oldret = ret;
2955 0 : ret = 0;
2956 0 : ret += length_hdb_keyset(&(data)->val[i]);
2957 0 : ret += Top_tag_for_oldret;
2958 : }
2959 0 : ret += Top_tag_oldret;
2960 : }
2961 0 : ret += 1 + der_length_len (ret);
2962 0 : return ret;
2963 : }
2964 :
2965 : int ASN1CALL
2966 0 : copy_HDB_Ext_KeySet(const HDB_Ext_KeySet *from, HDB_Ext_KeySet *to)
2967 : {
2968 0 : memset(to, 0, sizeof(*to));
2969 0 : if(((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
2970 0 : goto fail;
2971 0 : for((to)->len = 0; (to)->len < (from)->len; (to)->len++){
2972 0 : if(copy_hdb_keyset(&(from)->val[(to)->len], &(to)->val[(to)->len])) goto fail;
2973 : }
2974 0 : return 0;
2975 0 : fail:
2976 0 : free_HDB_Ext_KeySet(to);
2977 0 : return ENOMEM;
2978 : }
2979 :
2980 : int ASN1CALL
2981 0 : add_HDB_Ext_KeySet(HDB_Ext_KeySet *data, const hdb_keyset *element)
2982 : {
2983 : int ret;
2984 : void *ptr;
2985 :
2986 0 : ptr = realloc(data->val,
2987 0 : (data->len + 1) * sizeof(data->val[0]));
2988 0 : if (ptr == NULL) return ENOMEM;
2989 0 : data->val = ptr;
2990 :
2991 0 : ret = copy_hdb_keyset(element, &data->val[data->len]);
2992 0 : if (ret) return ret;
2993 0 : data->len++;
2994 0 : return 0;
2995 : }
2996 :
2997 : int ASN1CALL
2998 0 : remove_HDB_Ext_KeySet(HDB_Ext_KeySet *data, unsigned int element)
2999 : {
3000 : void *ptr;
3001 :
3002 0 : if (data->len == 0 || element >= data->len)
3003 0 : return ASN1_OVERRUN;
3004 0 : free_hdb_keyset(&data->val[element]);
3005 0 : data->len--;
3006 0 : if (element < data->len)
3007 0 : memmove(&data->val[element], &data->val[element + 1],
3008 0 : sizeof(data->val[0]) * data->len);
3009 0 : ptr = realloc(data->val, data->len * sizeof(data->val[0]));
3010 0 : if (ptr != NULL || data->len == 0) data->val = ptr;
3011 0 : return 0;
3012 : }
3013 :
3014 : int ASN1CALL
3015 0 : encode_HDB_extension(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const HDB_extension *data, size_t *size)
3016 : {
3017 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
3018 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3019 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
3020 :
3021 : /* data */
3022 : {
3023 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3024 0 : ret = 0;
3025 :
3026 0 : switch((&(data)->data)->element) {
3027 0 : case choice_HDB_extension_data_policy: {size_t data_tag_oldret = ret;
3028 0 : ret = 0;
3029 0 : e = der_put_utf8string(p, len, &((&(data)->data))->u.policy, &l);
3030 0 : if (e) return e;
3031 0 : p -= l; len -= l; ret += l;
3032 :
3033 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_UTF8String, &l);
3034 0 : if (e) return e;
3035 0 : p -= l; len -= l; ret += l;
3036 :
3037 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 12, &l);
3038 0 : if (e) return e;
3039 0 : p -= l; len -= l; ret += l;
3040 :
3041 0 : ret += data_tag_oldret;
3042 0 : break;
3043 : }
3044 0 : case choice_HDB_extension_data_hist_kvno_diff_svc: {size_t data_tag_oldret = ret;
3045 0 : ret = 0;
3046 0 : e = der_put_unsigned(p, len, &((&(data)->data))->u.hist_kvno_diff_svc, &l);
3047 0 : if (e) return e;
3048 0 : p -= l; len -= l; ret += l;
3049 :
3050 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
3051 0 : if (e) return e;
3052 0 : p -= l; len -= l; ret += l;
3053 :
3054 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 11, &l);
3055 0 : if (e) return e;
3056 0 : p -= l; len -= l; ret += l;
3057 :
3058 0 : ret += data_tag_oldret;
3059 0 : break;
3060 : }
3061 0 : case choice_HDB_extension_data_hist_kvno_diff_clnt: {size_t data_tag_oldret = ret;
3062 0 : ret = 0;
3063 0 : e = der_put_unsigned(p, len, &((&(data)->data))->u.hist_kvno_diff_clnt, &l);
3064 0 : if (e) return e;
3065 0 : p -= l; len -= l; ret += l;
3066 :
3067 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
3068 0 : if (e) return e;
3069 0 : p -= l; len -= l; ret += l;
3070 :
3071 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 10, &l);
3072 0 : if (e) return e;
3073 0 : p -= l; len -= l; ret += l;
3074 :
3075 0 : ret += data_tag_oldret;
3076 0 : break;
3077 : }
3078 0 : case choice_HDB_extension_data_hist_keys: {size_t data_tag_oldret = ret;
3079 0 : ret = 0;
3080 0 : e = encode_HDB_Ext_KeySet(p, len, &((&(data)->data))->u.hist_keys, &l);
3081 0 : if (e) return e;
3082 0 : p -= l; len -= l; ret += l;
3083 :
3084 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 9, &l);
3085 0 : if (e) return e;
3086 0 : p -= l; len -= l; ret += l;
3087 :
3088 0 : ret += data_tag_oldret;
3089 0 : break;
3090 : }
3091 0 : case choice_HDB_extension_data_pkinit_cert: {size_t data_tag_oldret = ret;
3092 0 : ret = 0;
3093 0 : e = encode_HDB_Ext_PKINIT_cert(p, len, &((&(data)->data))->u.pkinit_cert, &l);
3094 0 : if (e) return e;
3095 0 : p -= l; len -= l; ret += l;
3096 :
3097 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 8, &l);
3098 0 : if (e) return e;
3099 0 : p -= l; len -= l; ret += l;
3100 :
3101 0 : ret += data_tag_oldret;
3102 0 : break;
3103 : }
3104 0 : case choice_HDB_extension_data_last_pw_change: {size_t data_tag_oldret = ret;
3105 0 : ret = 0;
3106 0 : e = encode_KerberosTime(p, len, &((&(data)->data))->u.last_pw_change, &l);
3107 0 : if (e) return e;
3108 0 : p -= l; len -= l; ret += l;
3109 :
3110 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 7, &l);
3111 0 : if (e) return e;
3112 0 : p -= l; len -= l; ret += l;
3113 :
3114 0 : ret += data_tag_oldret;
3115 0 : break;
3116 : }
3117 0 : case choice_HDB_extension_data_aliases: {size_t data_tag_oldret = ret;
3118 0 : ret = 0;
3119 0 : e = encode_HDB_Ext_Aliases(p, len, &((&(data)->data))->u.aliases, &l);
3120 0 : if (e) return e;
3121 0 : p -= l; len -= l; ret += l;
3122 :
3123 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 6, &l);
3124 0 : if (e) return e;
3125 0 : p -= l; len -= l; ret += l;
3126 :
3127 0 : ret += data_tag_oldret;
3128 0 : break;
3129 : }
3130 0 : case choice_HDB_extension_data_password: {size_t data_tag_oldret = ret;
3131 0 : ret = 0;
3132 0 : e = encode_HDB_Ext_Password(p, len, &((&(data)->data))->u.password, &l);
3133 0 : if (e) return e;
3134 0 : p -= l; len -= l; ret += l;
3135 :
3136 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 5, &l);
3137 0 : if (e) return e;
3138 0 : p -= l; len -= l; ret += l;
3139 :
3140 0 : ret += data_tag_oldret;
3141 0 : break;
3142 : }
3143 0 : case choice_HDB_extension_data_lm_owf: {size_t data_tag_oldret = ret;
3144 0 : ret = 0;
3145 0 : e = encode_HDB_Ext_Lan_Manager_OWF(p, len, &((&(data)->data))->u.lm_owf, &l);
3146 0 : if (e) return e;
3147 0 : p -= l; len -= l; ret += l;
3148 :
3149 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 4, &l);
3150 0 : if (e) return e;
3151 0 : p -= l; len -= l; ret += l;
3152 :
3153 0 : ret += data_tag_oldret;
3154 0 : break;
3155 : }
3156 0 : case choice_HDB_extension_data_allowed_to_delegate_to: {size_t data_tag_oldret = ret;
3157 0 : ret = 0;
3158 0 : e = encode_HDB_Ext_Constrained_delegation_acl(p, len, &((&(data)->data))->u.allowed_to_delegate_to, &l);
3159 0 : if (e) return e;
3160 0 : p -= l; len -= l; ret += l;
3161 :
3162 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
3163 0 : if (e) return e;
3164 0 : p -= l; len -= l; ret += l;
3165 :
3166 0 : ret += data_tag_oldret;
3167 0 : break;
3168 : }
3169 0 : case choice_HDB_extension_data_pkinit_cert_hash: {size_t data_tag_oldret = ret;
3170 0 : ret = 0;
3171 0 : e = encode_HDB_Ext_PKINIT_hash(p, len, &((&(data)->data))->u.pkinit_cert_hash, &l);
3172 0 : if (e) return e;
3173 0 : p -= l; len -= l; ret += l;
3174 :
3175 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
3176 0 : if (e) return e;
3177 0 : p -= l; len -= l; ret += l;
3178 :
3179 0 : ret += data_tag_oldret;
3180 0 : break;
3181 : }
3182 0 : case choice_HDB_extension_data_pkinit_acl: {size_t data_tag_oldret = ret;
3183 0 : ret = 0;
3184 0 : e = encode_HDB_Ext_PKINIT_acl(p, len, &((&(data)->data))->u.pkinit_acl, &l);
3185 0 : if (e) return e;
3186 0 : p -= l; len -= l; ret += l;
3187 :
3188 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
3189 0 : if (e) return e;
3190 0 : p -= l; len -= l; ret += l;
3191 :
3192 0 : ret += data_tag_oldret;
3193 0 : break;
3194 : }
3195 0 : case choice_HDB_extension_data_asn1_ellipsis: {
3196 0 : if (len < (&(data)->data)->u.asn1_ellipsis.length)
3197 0 : return ASN1_OVERFLOW;
3198 0 : p -= (&(data)->data)->u.asn1_ellipsis.length;
3199 0 : ret += (&(data)->data)->u.asn1_ellipsis.length;
3200 0 : memcpy(p + 1, (&(data)->data)->u.asn1_ellipsis.data, (&(data)->data)->u.asn1_ellipsis.length);
3201 0 : break;
3202 : }
3203 : };
3204 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
3205 0 : if (e) return e;
3206 0 : p -= l; len -= l; ret += l;
3207 :
3208 0 : ret += Top_tag_oldret;
3209 : }
3210 : /* mandatory */
3211 : {
3212 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3213 0 : ret = 0;
3214 0 : e = der_put_boolean(p, len, &(data)->mandatory, &l);
3215 0 : if (e) return e;
3216 0 : p -= l; len -= l; ret += l;
3217 :
3218 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Boolean, &l);
3219 0 : if (e) return e;
3220 0 : p -= l; len -= l; ret += l;
3221 :
3222 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
3223 0 : if (e) return e;
3224 0 : p -= l; len -= l; ret += l;
3225 :
3226 0 : ret += Top_tag_oldret;
3227 : }
3228 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
3229 0 : if (e) return e;
3230 0 : p -= l; len -= l; ret += l;
3231 :
3232 0 : *size = ret;
3233 0 : return 0;
3234 : }
3235 :
3236 : int ASN1CALL
3237 0 : decode_HDB_extension(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, HDB_extension *data, size_t *size)
3238 : {
3239 0 : size_t ret = 0;
3240 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3241 : int e HEIMDAL_UNUSED_ATTRIBUTE;
3242 :
3243 0 : memset(data, 0, sizeof(*data));
3244 : {
3245 : size_t Top_datalen, Top_oldlen;
3246 : Der_type Top_type;
3247 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
3248 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
3249 0 : if(e) goto fail;
3250 0 : p += l; len -= l; ret += l;
3251 0 : Top_oldlen = len;
3252 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3253 0 : len = Top_datalen;
3254 : {
3255 : size_t mandatory_datalen, mandatory_oldlen;
3256 : Der_type mandatory_type;
3257 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &mandatory_type, 0, &mandatory_datalen, &l);
3258 0 : if (e == 0 && mandatory_type != CONS) { e = ASN1_BAD_ID; }
3259 0 : if(e) goto fail;
3260 0 : p += l; len -= l; ret += l;
3261 0 : mandatory_oldlen = len;
3262 0 : if (mandatory_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3263 0 : len = mandatory_datalen;
3264 : {
3265 : size_t mandatory_Tag_datalen, mandatory_Tag_oldlen;
3266 : Der_type mandatory_Tag_type;
3267 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &mandatory_Tag_type, UT_Boolean, &mandatory_Tag_datalen, &l);
3268 0 : if (e == 0 && mandatory_Tag_type != PRIM) { e = ASN1_BAD_ID; }
3269 0 : if(e) goto fail;
3270 0 : p += l; len -= l; ret += l;
3271 0 : mandatory_Tag_oldlen = len;
3272 0 : if (mandatory_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3273 0 : len = mandatory_Tag_datalen;
3274 0 : e = der_get_boolean(p, len, &(data)->mandatory, &l);
3275 0 : if(e) goto fail;
3276 0 : p += l; len -= l; ret += l;
3277 0 : len = mandatory_Tag_oldlen - mandatory_Tag_datalen;
3278 : }
3279 0 : len = mandatory_oldlen - mandatory_datalen;
3280 : }
3281 : {
3282 : size_t data_datalen, data_oldlen;
3283 : Der_type data_type;
3284 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &data_type, 1, &data_datalen, &l);
3285 0 : if (e == 0 && data_type != CONS) { e = ASN1_BAD_ID; }
3286 0 : if(e) goto fail;
3287 0 : p += l; len -= l; ret += l;
3288 0 : data_oldlen = len;
3289 0 : if (data_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3290 0 : len = data_datalen;
3291 0 : if (der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 0, NULL) == 0) {
3292 : {
3293 : size_t pkinit_acl_datalen, pkinit_acl_oldlen;
3294 : Der_type pkinit_acl_type;
3295 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &pkinit_acl_type, 0, &pkinit_acl_datalen, &l);
3296 0 : if (e == 0 && pkinit_acl_type != CONS) { e = ASN1_BAD_ID; }
3297 0 : if(e) goto fail;
3298 0 : p += l; len -= l; ret += l;
3299 0 : pkinit_acl_oldlen = len;
3300 0 : if (pkinit_acl_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3301 0 : len = pkinit_acl_datalen;
3302 0 : e = decode_HDB_Ext_PKINIT_acl(p, len, &(&(data)->data)->u.pkinit_acl, &l);
3303 0 : if(e) goto fail;
3304 0 : p += l; len -= l; ret += l;
3305 0 : len = pkinit_acl_oldlen - pkinit_acl_datalen;
3306 : }
3307 0 : (&(data)->data)->element = choice_HDB_extension_data_pkinit_acl;
3308 : }
3309 0 : else if (der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 1, NULL) == 0) {
3310 : {
3311 : size_t pkinit_cert_hash_datalen, pkinit_cert_hash_oldlen;
3312 : Der_type pkinit_cert_hash_type;
3313 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &pkinit_cert_hash_type, 1, &pkinit_cert_hash_datalen, &l);
3314 0 : if (e == 0 && pkinit_cert_hash_type != CONS) { e = ASN1_BAD_ID; }
3315 0 : if(e) goto fail;
3316 0 : p += l; len -= l; ret += l;
3317 0 : pkinit_cert_hash_oldlen = len;
3318 0 : if (pkinit_cert_hash_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3319 0 : len = pkinit_cert_hash_datalen;
3320 0 : e = decode_HDB_Ext_PKINIT_hash(p, len, &(&(data)->data)->u.pkinit_cert_hash, &l);
3321 0 : if(e) goto fail;
3322 0 : p += l; len -= l; ret += l;
3323 0 : len = pkinit_cert_hash_oldlen - pkinit_cert_hash_datalen;
3324 : }
3325 0 : (&(data)->data)->element = choice_HDB_extension_data_pkinit_cert_hash;
3326 : }
3327 0 : else if (der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 2, NULL) == 0) {
3328 : {
3329 : size_t allowed_to_delegate_to_datalen, allowed_to_delegate_to_oldlen;
3330 : Der_type allowed_to_delegate_to_type;
3331 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &allowed_to_delegate_to_type, 2, &allowed_to_delegate_to_datalen, &l);
3332 0 : if (e == 0 && allowed_to_delegate_to_type != CONS) { e = ASN1_BAD_ID; }
3333 0 : if(e) goto fail;
3334 0 : p += l; len -= l; ret += l;
3335 0 : allowed_to_delegate_to_oldlen = len;
3336 0 : if (allowed_to_delegate_to_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3337 0 : len = allowed_to_delegate_to_datalen;
3338 0 : e = decode_HDB_Ext_Constrained_delegation_acl(p, len, &(&(data)->data)->u.allowed_to_delegate_to, &l);
3339 0 : if(e) goto fail;
3340 0 : p += l; len -= l; ret += l;
3341 0 : len = allowed_to_delegate_to_oldlen - allowed_to_delegate_to_datalen;
3342 : }
3343 0 : (&(data)->data)->element = choice_HDB_extension_data_allowed_to_delegate_to;
3344 : }
3345 0 : else if (der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 4, NULL) == 0) {
3346 : {
3347 : size_t lm_owf_datalen, lm_owf_oldlen;
3348 : Der_type lm_owf_type;
3349 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &lm_owf_type, 4, &lm_owf_datalen, &l);
3350 0 : if (e == 0 && lm_owf_type != CONS) { e = ASN1_BAD_ID; }
3351 0 : if(e) goto fail;
3352 0 : p += l; len -= l; ret += l;
3353 0 : lm_owf_oldlen = len;
3354 0 : if (lm_owf_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3355 0 : len = lm_owf_datalen;
3356 0 : e = decode_HDB_Ext_Lan_Manager_OWF(p, len, &(&(data)->data)->u.lm_owf, &l);
3357 0 : if(e) goto fail;
3358 0 : p += l; len -= l; ret += l;
3359 0 : len = lm_owf_oldlen - lm_owf_datalen;
3360 : }
3361 0 : (&(data)->data)->element = choice_HDB_extension_data_lm_owf;
3362 : }
3363 0 : else if (der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 5, NULL) == 0) {
3364 : {
3365 : size_t password_datalen, password_oldlen;
3366 : Der_type password_type;
3367 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &password_type, 5, &password_datalen, &l);
3368 0 : if (e == 0 && password_type != CONS) { e = ASN1_BAD_ID; }
3369 0 : if(e) goto fail;
3370 0 : p += l; len -= l; ret += l;
3371 0 : password_oldlen = len;
3372 0 : if (password_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3373 0 : len = password_datalen;
3374 0 : e = decode_HDB_Ext_Password(p, len, &(&(data)->data)->u.password, &l);
3375 0 : if(e) goto fail;
3376 0 : p += l; len -= l; ret += l;
3377 0 : len = password_oldlen - password_datalen;
3378 : }
3379 0 : (&(data)->data)->element = choice_HDB_extension_data_password;
3380 : }
3381 0 : else if (der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 6, NULL) == 0) {
3382 : {
3383 : size_t aliases_datalen, aliases_oldlen;
3384 : Der_type aliases_type;
3385 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &aliases_type, 6, &aliases_datalen, &l);
3386 0 : if (e == 0 && aliases_type != CONS) { e = ASN1_BAD_ID; }
3387 0 : if(e) goto fail;
3388 0 : p += l; len -= l; ret += l;
3389 0 : aliases_oldlen = len;
3390 0 : if (aliases_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3391 0 : len = aliases_datalen;
3392 0 : e = decode_HDB_Ext_Aliases(p, len, &(&(data)->data)->u.aliases, &l);
3393 0 : if(e) goto fail;
3394 0 : p += l; len -= l; ret += l;
3395 0 : len = aliases_oldlen - aliases_datalen;
3396 : }
3397 0 : (&(data)->data)->element = choice_HDB_extension_data_aliases;
3398 : }
3399 0 : else if (der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 7, NULL) == 0) {
3400 : {
3401 : size_t last_pw_change_datalen, last_pw_change_oldlen;
3402 : Der_type last_pw_change_type;
3403 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &last_pw_change_type, 7, &last_pw_change_datalen, &l);
3404 0 : if (e == 0 && last_pw_change_type != CONS) { e = ASN1_BAD_ID; }
3405 0 : if(e) goto fail;
3406 0 : p += l; len -= l; ret += l;
3407 0 : last_pw_change_oldlen = len;
3408 0 : if (last_pw_change_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3409 0 : len = last_pw_change_datalen;
3410 0 : e = decode_KerberosTime(p, len, &(&(data)->data)->u.last_pw_change, &l);
3411 0 : if(e) goto fail;
3412 0 : p += l; len -= l; ret += l;
3413 0 : len = last_pw_change_oldlen - last_pw_change_datalen;
3414 : }
3415 0 : (&(data)->data)->element = choice_HDB_extension_data_last_pw_change;
3416 : }
3417 0 : else if (der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 8, NULL) == 0) {
3418 : {
3419 : size_t pkinit_cert_datalen, pkinit_cert_oldlen;
3420 : Der_type pkinit_cert_type;
3421 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &pkinit_cert_type, 8, &pkinit_cert_datalen, &l);
3422 0 : if (e == 0 && pkinit_cert_type != CONS) { e = ASN1_BAD_ID; }
3423 0 : if(e) goto fail;
3424 0 : p += l; len -= l; ret += l;
3425 0 : pkinit_cert_oldlen = len;
3426 0 : if (pkinit_cert_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3427 0 : len = pkinit_cert_datalen;
3428 0 : e = decode_HDB_Ext_PKINIT_cert(p, len, &(&(data)->data)->u.pkinit_cert, &l);
3429 0 : if(e) goto fail;
3430 0 : p += l; len -= l; ret += l;
3431 0 : len = pkinit_cert_oldlen - pkinit_cert_datalen;
3432 : }
3433 0 : (&(data)->data)->element = choice_HDB_extension_data_pkinit_cert;
3434 : }
3435 0 : else if (der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 9, NULL) == 0) {
3436 : {
3437 : size_t hist_keys_datalen, hist_keys_oldlen;
3438 : Der_type hist_keys_type;
3439 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &hist_keys_type, 9, &hist_keys_datalen, &l);
3440 0 : if (e == 0 && hist_keys_type != CONS) { e = ASN1_BAD_ID; }
3441 0 : if(e) goto fail;
3442 0 : p += l; len -= l; ret += l;
3443 0 : hist_keys_oldlen = len;
3444 0 : if (hist_keys_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3445 0 : len = hist_keys_datalen;
3446 0 : e = decode_HDB_Ext_KeySet(p, len, &(&(data)->data)->u.hist_keys, &l);
3447 0 : if(e) goto fail;
3448 0 : p += l; len -= l; ret += l;
3449 0 : len = hist_keys_oldlen - hist_keys_datalen;
3450 : }
3451 0 : (&(data)->data)->element = choice_HDB_extension_data_hist_keys;
3452 : }
3453 0 : else if (der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 10, NULL) == 0) {
3454 : {
3455 : size_t hist_kvno_diff_clnt_datalen, hist_kvno_diff_clnt_oldlen;
3456 : Der_type hist_kvno_diff_clnt_type;
3457 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &hist_kvno_diff_clnt_type, 10, &hist_kvno_diff_clnt_datalen, &l);
3458 0 : if (e == 0 && hist_kvno_diff_clnt_type != CONS) { e = ASN1_BAD_ID; }
3459 0 : if(e) goto fail;
3460 0 : p += l; len -= l; ret += l;
3461 0 : hist_kvno_diff_clnt_oldlen = len;
3462 0 : if (hist_kvno_diff_clnt_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3463 0 : len = hist_kvno_diff_clnt_datalen;
3464 : {
3465 : size_t hist_kvno_diff_clnt_Tag_datalen, hist_kvno_diff_clnt_Tag_oldlen;
3466 : Der_type hist_kvno_diff_clnt_Tag_type;
3467 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &hist_kvno_diff_clnt_Tag_type, UT_Integer, &hist_kvno_diff_clnt_Tag_datalen, &l);
3468 0 : if (e == 0 && hist_kvno_diff_clnt_Tag_type != PRIM) { e = ASN1_BAD_ID; }
3469 0 : if(e) goto fail;
3470 0 : p += l; len -= l; ret += l;
3471 0 : hist_kvno_diff_clnt_Tag_oldlen = len;
3472 0 : if (hist_kvno_diff_clnt_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3473 0 : len = hist_kvno_diff_clnt_Tag_datalen;
3474 0 : e = der_get_unsigned(p, len, &(&(data)->data)->u.hist_kvno_diff_clnt, &l);
3475 0 : if(e) goto fail;
3476 0 : p += l; len -= l; ret += l;
3477 0 : len = hist_kvno_diff_clnt_Tag_oldlen - hist_kvno_diff_clnt_Tag_datalen;
3478 : }
3479 0 : len = hist_kvno_diff_clnt_oldlen - hist_kvno_diff_clnt_datalen;
3480 : }
3481 0 : (&(data)->data)->element = choice_HDB_extension_data_hist_kvno_diff_clnt;
3482 : }
3483 0 : else if (der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 11, NULL) == 0) {
3484 : {
3485 : size_t hist_kvno_diff_svc_datalen, hist_kvno_diff_svc_oldlen;
3486 : Der_type hist_kvno_diff_svc_type;
3487 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &hist_kvno_diff_svc_type, 11, &hist_kvno_diff_svc_datalen, &l);
3488 0 : if (e == 0 && hist_kvno_diff_svc_type != CONS) { e = ASN1_BAD_ID; }
3489 0 : if(e) goto fail;
3490 0 : p += l; len -= l; ret += l;
3491 0 : hist_kvno_diff_svc_oldlen = len;
3492 0 : if (hist_kvno_diff_svc_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3493 0 : len = hist_kvno_diff_svc_datalen;
3494 : {
3495 : size_t hist_kvno_diff_svc_Tag_datalen, hist_kvno_diff_svc_Tag_oldlen;
3496 : Der_type hist_kvno_diff_svc_Tag_type;
3497 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &hist_kvno_diff_svc_Tag_type, UT_Integer, &hist_kvno_diff_svc_Tag_datalen, &l);
3498 0 : if (e == 0 && hist_kvno_diff_svc_Tag_type != PRIM) { e = ASN1_BAD_ID; }
3499 0 : if(e) goto fail;
3500 0 : p += l; len -= l; ret += l;
3501 0 : hist_kvno_diff_svc_Tag_oldlen = len;
3502 0 : if (hist_kvno_diff_svc_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3503 0 : len = hist_kvno_diff_svc_Tag_datalen;
3504 0 : e = der_get_unsigned(p, len, &(&(data)->data)->u.hist_kvno_diff_svc, &l);
3505 0 : if(e) goto fail;
3506 0 : p += l; len -= l; ret += l;
3507 0 : len = hist_kvno_diff_svc_Tag_oldlen - hist_kvno_diff_svc_Tag_datalen;
3508 : }
3509 0 : len = hist_kvno_diff_svc_oldlen - hist_kvno_diff_svc_datalen;
3510 : }
3511 0 : (&(data)->data)->element = choice_HDB_extension_data_hist_kvno_diff_svc;
3512 : }
3513 0 : else if (der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 12, NULL) == 0) {
3514 : {
3515 : size_t policy_datalen, policy_oldlen;
3516 : Der_type policy_type;
3517 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &policy_type, 12, &policy_datalen, &l);
3518 0 : if (e == 0 && policy_type != CONS) { e = ASN1_BAD_ID; }
3519 0 : if(e) goto fail;
3520 0 : p += l; len -= l; ret += l;
3521 0 : policy_oldlen = len;
3522 0 : if (policy_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3523 0 : len = policy_datalen;
3524 : {
3525 : size_t policy_Tag_datalen, policy_Tag_oldlen;
3526 : Der_type policy_Tag_type;
3527 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &policy_Tag_type, UT_UTF8String, &policy_Tag_datalen, &l);
3528 0 : if (e == 0 && policy_Tag_type != PRIM) { e = ASN1_BAD_ID; }
3529 0 : if(e) goto fail;
3530 0 : p += l; len -= l; ret += l;
3531 0 : policy_Tag_oldlen = len;
3532 0 : if (policy_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3533 0 : len = policy_Tag_datalen;
3534 0 : e = der_get_utf8string(p, len, &(&(data)->data)->u.policy, &l);
3535 0 : if(e) goto fail;
3536 0 : p += l; len -= l; ret += l;
3537 0 : len = policy_Tag_oldlen - policy_Tag_datalen;
3538 : }
3539 0 : len = policy_oldlen - policy_datalen;
3540 : }
3541 0 : (&(data)->data)->element = choice_HDB_extension_data_policy;
3542 : }
3543 : else {
3544 0 : (&(data)->data)->u.asn1_ellipsis.data = calloc(1, len);
3545 0 : if ((&(data)->data)->u.asn1_ellipsis.data == NULL) {
3546 0 : e = ENOMEM; goto fail;
3547 : }
3548 0 : (&(data)->data)->u.asn1_ellipsis.length = len;
3549 0 : memcpy((&(data)->data)->u.asn1_ellipsis.data, p, len);
3550 0 : (&(data)->data)->element = choice_HDB_extension_data_asn1_ellipsis;
3551 0 : p += len;
3552 0 : ret += len;
3553 0 : len = 0;
3554 : }
3555 0 : len = data_oldlen - data_datalen;
3556 : }
3557 0 : len = Top_oldlen - Top_datalen;
3558 : }
3559 0 : if(size) *size = ret;
3560 0 : return 0;
3561 0 : fail:
3562 0 : free_HDB_extension(data);
3563 0 : return e;
3564 : }
3565 :
3566 : void ASN1CALL
3567 0 : free_HDB_extension(HDB_extension *data)
3568 : {
3569 0 : switch((&(data)->data)->element) {
3570 0 : case choice_HDB_extension_data_pkinit_acl:
3571 0 : free_HDB_Ext_PKINIT_acl(&(&(data)->data)->u.pkinit_acl);
3572 0 : break;
3573 0 : case choice_HDB_extension_data_pkinit_cert_hash:
3574 0 : free_HDB_Ext_PKINIT_hash(&(&(data)->data)->u.pkinit_cert_hash);
3575 0 : break;
3576 0 : case choice_HDB_extension_data_allowed_to_delegate_to:
3577 0 : free_HDB_Ext_Constrained_delegation_acl(&(&(data)->data)->u.allowed_to_delegate_to);
3578 0 : break;
3579 0 : case choice_HDB_extension_data_lm_owf:
3580 0 : free_HDB_Ext_Lan_Manager_OWF(&(&(data)->data)->u.lm_owf);
3581 0 : break;
3582 0 : case choice_HDB_extension_data_password:
3583 0 : free_HDB_Ext_Password(&(&(data)->data)->u.password);
3584 0 : break;
3585 0 : case choice_HDB_extension_data_aliases:
3586 0 : free_HDB_Ext_Aliases(&(&(data)->data)->u.aliases);
3587 0 : break;
3588 0 : case choice_HDB_extension_data_last_pw_change:
3589 0 : free_KerberosTime(&(&(data)->data)->u.last_pw_change);
3590 0 : break;
3591 0 : case choice_HDB_extension_data_pkinit_cert:
3592 0 : free_HDB_Ext_PKINIT_cert(&(&(data)->data)->u.pkinit_cert);
3593 0 : break;
3594 0 : case choice_HDB_extension_data_hist_keys:
3595 0 : free_HDB_Ext_KeySet(&(&(data)->data)->u.hist_keys);
3596 0 : break;
3597 0 : case choice_HDB_extension_data_hist_kvno_diff_clnt:
3598 0 : break;
3599 0 : case choice_HDB_extension_data_hist_kvno_diff_svc:
3600 0 : break;
3601 0 : case choice_HDB_extension_data_policy:
3602 0 : der_free_utf8string(&(&(data)->data)->u.policy);
3603 0 : break;
3604 0 : case choice_HDB_extension_data_asn1_ellipsis:
3605 0 : der_free_octet_string(&(&(data)->data)->u.asn1_ellipsis);
3606 0 : break;}
3607 0 : }
3608 :
3609 : size_t ASN1CALL
3610 0 : length_HDB_extension(const HDB_extension *data)
3611 : {
3612 0 : size_t ret = 0;
3613 : {
3614 0 : size_t Top_tag_oldret = ret;
3615 0 : ret = 0;
3616 0 : ret += 1;
3617 0 : ret += 1 + der_length_len (ret);
3618 0 : ret += 1 + der_length_len (ret);
3619 0 : ret += Top_tag_oldret;
3620 : }
3621 : {
3622 0 : size_t Top_tag_oldret = ret;
3623 0 : ret = 0;
3624 0 : switch((&(data)->data)->element) {
3625 0 : case choice_HDB_extension_data_pkinit_acl:
3626 : {
3627 0 : size_t data_tag_oldret = ret;
3628 0 : ret = 0;
3629 0 : ret += length_HDB_Ext_PKINIT_acl(&(&(data)->data)->u.pkinit_acl);
3630 0 : ret += 1 + der_length_len (ret);
3631 0 : ret += data_tag_oldret;
3632 : }
3633 0 : break;
3634 0 : case choice_HDB_extension_data_pkinit_cert_hash:
3635 : {
3636 0 : size_t data_tag_oldret = ret;
3637 0 : ret = 0;
3638 0 : ret += length_HDB_Ext_PKINIT_hash(&(&(data)->data)->u.pkinit_cert_hash);
3639 0 : ret += 1 + der_length_len (ret);
3640 0 : ret += data_tag_oldret;
3641 : }
3642 0 : break;
3643 0 : case choice_HDB_extension_data_allowed_to_delegate_to:
3644 : {
3645 0 : size_t data_tag_oldret = ret;
3646 0 : ret = 0;
3647 0 : ret += length_HDB_Ext_Constrained_delegation_acl(&(&(data)->data)->u.allowed_to_delegate_to);
3648 0 : ret += 1 + der_length_len (ret);
3649 0 : ret += data_tag_oldret;
3650 : }
3651 0 : break;
3652 0 : case choice_HDB_extension_data_lm_owf:
3653 : {
3654 0 : size_t data_tag_oldret = ret;
3655 0 : ret = 0;
3656 0 : ret += length_HDB_Ext_Lan_Manager_OWF(&(&(data)->data)->u.lm_owf);
3657 0 : ret += 1 + der_length_len (ret);
3658 0 : ret += data_tag_oldret;
3659 : }
3660 0 : break;
3661 0 : case choice_HDB_extension_data_password:
3662 : {
3663 0 : size_t data_tag_oldret = ret;
3664 0 : ret = 0;
3665 0 : ret += length_HDB_Ext_Password(&(&(data)->data)->u.password);
3666 0 : ret += 1 + der_length_len (ret);
3667 0 : ret += data_tag_oldret;
3668 : }
3669 0 : break;
3670 0 : case choice_HDB_extension_data_aliases:
3671 : {
3672 0 : size_t data_tag_oldret = ret;
3673 0 : ret = 0;
3674 0 : ret += length_HDB_Ext_Aliases(&(&(data)->data)->u.aliases);
3675 0 : ret += 1 + der_length_len (ret);
3676 0 : ret += data_tag_oldret;
3677 : }
3678 0 : break;
3679 0 : case choice_HDB_extension_data_last_pw_change:
3680 : {
3681 0 : size_t data_tag_oldret = ret;
3682 0 : ret = 0;
3683 0 : ret += length_KerberosTime(&(&(data)->data)->u.last_pw_change);
3684 0 : ret += 1 + der_length_len (ret);
3685 0 : ret += data_tag_oldret;
3686 : }
3687 0 : break;
3688 0 : case choice_HDB_extension_data_pkinit_cert:
3689 : {
3690 0 : size_t data_tag_oldret = ret;
3691 0 : ret = 0;
3692 0 : ret += length_HDB_Ext_PKINIT_cert(&(&(data)->data)->u.pkinit_cert);
3693 0 : ret += 1 + der_length_len (ret);
3694 0 : ret += data_tag_oldret;
3695 : }
3696 0 : break;
3697 0 : case choice_HDB_extension_data_hist_keys:
3698 : {
3699 0 : size_t data_tag_oldret = ret;
3700 0 : ret = 0;
3701 0 : ret += length_HDB_Ext_KeySet(&(&(data)->data)->u.hist_keys);
3702 0 : ret += 1 + der_length_len (ret);
3703 0 : ret += data_tag_oldret;
3704 : }
3705 0 : break;
3706 0 : case choice_HDB_extension_data_hist_kvno_diff_clnt:
3707 : {
3708 0 : size_t data_tag_oldret = ret;
3709 0 : ret = 0;
3710 0 : ret += der_length_unsigned(&(&(data)->data)->u.hist_kvno_diff_clnt);
3711 0 : ret += 1 + der_length_len (ret);
3712 0 : ret += 1 + der_length_len (ret);
3713 0 : ret += data_tag_oldret;
3714 : }
3715 0 : break;
3716 0 : case choice_HDB_extension_data_hist_kvno_diff_svc:
3717 : {
3718 0 : size_t data_tag_oldret = ret;
3719 0 : ret = 0;
3720 0 : ret += der_length_unsigned(&(&(data)->data)->u.hist_kvno_diff_svc);
3721 0 : ret += 1 + der_length_len (ret);
3722 0 : ret += 1 + der_length_len (ret);
3723 0 : ret += data_tag_oldret;
3724 : }
3725 0 : break;
3726 0 : case choice_HDB_extension_data_policy:
3727 : {
3728 0 : size_t data_tag_oldret = ret;
3729 0 : ret = 0;
3730 0 : ret += der_length_utf8string(&(&(data)->data)->u.policy);
3731 0 : ret += 1 + der_length_len (ret);
3732 0 : ret += 1 + der_length_len (ret);
3733 0 : ret += data_tag_oldret;
3734 : }
3735 0 : break;
3736 0 : case choice_HDB_extension_data_asn1_ellipsis:
3737 0 : ret += (&(data)->data)->u.asn1_ellipsis.length;
3738 0 : break;
3739 : }
3740 0 : ret += 1 + der_length_len (ret);
3741 0 : ret += Top_tag_oldret;
3742 : }
3743 0 : ret += 1 + der_length_len (ret);
3744 0 : return ret;
3745 : }
3746 :
3747 : int ASN1CALL
3748 0 : copy_HDB_extension(const HDB_extension *from, HDB_extension *to)
3749 : {
3750 0 : memset(to, 0, sizeof(*to));
3751 0 : *(&(to)->mandatory) = *(&(from)->mandatory);
3752 0 : (&(to)->data)->element = (&(from)->data)->element;
3753 0 : switch((&(from)->data)->element) {
3754 0 : case choice_HDB_extension_data_pkinit_acl:
3755 0 : if(copy_HDB_Ext_PKINIT_acl(&(&(from)->data)->u.pkinit_acl, &(&(to)->data)->u.pkinit_acl)) goto fail;
3756 0 : break;
3757 0 : case choice_HDB_extension_data_pkinit_cert_hash:
3758 0 : if(copy_HDB_Ext_PKINIT_hash(&(&(from)->data)->u.pkinit_cert_hash, &(&(to)->data)->u.pkinit_cert_hash)) goto fail;
3759 0 : break;
3760 0 : case choice_HDB_extension_data_allowed_to_delegate_to:
3761 0 : if(copy_HDB_Ext_Constrained_delegation_acl(&(&(from)->data)->u.allowed_to_delegate_to, &(&(to)->data)->u.allowed_to_delegate_to)) goto fail;
3762 0 : break;
3763 0 : case choice_HDB_extension_data_lm_owf:
3764 0 : if(copy_HDB_Ext_Lan_Manager_OWF(&(&(from)->data)->u.lm_owf, &(&(to)->data)->u.lm_owf)) goto fail;
3765 0 : break;
3766 0 : case choice_HDB_extension_data_password:
3767 0 : if(copy_HDB_Ext_Password(&(&(from)->data)->u.password, &(&(to)->data)->u.password)) goto fail;
3768 0 : break;
3769 0 : case choice_HDB_extension_data_aliases:
3770 0 : if(copy_HDB_Ext_Aliases(&(&(from)->data)->u.aliases, &(&(to)->data)->u.aliases)) goto fail;
3771 0 : break;
3772 0 : case choice_HDB_extension_data_last_pw_change:
3773 0 : if(copy_KerberosTime(&(&(from)->data)->u.last_pw_change, &(&(to)->data)->u.last_pw_change)) goto fail;
3774 0 : break;
3775 0 : case choice_HDB_extension_data_pkinit_cert:
3776 0 : if(copy_HDB_Ext_PKINIT_cert(&(&(from)->data)->u.pkinit_cert, &(&(to)->data)->u.pkinit_cert)) goto fail;
3777 0 : break;
3778 0 : case choice_HDB_extension_data_hist_keys:
3779 0 : if(copy_HDB_Ext_KeySet(&(&(from)->data)->u.hist_keys, &(&(to)->data)->u.hist_keys)) goto fail;
3780 0 : break;
3781 0 : case choice_HDB_extension_data_hist_kvno_diff_clnt:
3782 0 : *(&(&(to)->data)->u.hist_kvno_diff_clnt) = *(&(&(from)->data)->u.hist_kvno_diff_clnt);
3783 0 : break;
3784 0 : case choice_HDB_extension_data_hist_kvno_diff_svc:
3785 0 : *(&(&(to)->data)->u.hist_kvno_diff_svc) = *(&(&(from)->data)->u.hist_kvno_diff_svc);
3786 0 : break;
3787 0 : case choice_HDB_extension_data_policy:
3788 0 : if(der_copy_utf8string(&(&(from)->data)->u.policy, &(&(to)->data)->u.policy)) goto fail;
3789 0 : break;
3790 0 : case choice_HDB_extension_data_asn1_ellipsis: {
3791 : int ret;
3792 0 : ret=der_copy_octet_string(&(&(from)->data)->u.asn1_ellipsis, &(&(to)->data)->u.asn1_ellipsis);
3793 0 : if (ret) goto fail;
3794 0 : break;
3795 : }
3796 : }
3797 0 : return 0;
3798 0 : fail:
3799 0 : free_HDB_extension(to);
3800 0 : return ENOMEM;
3801 : }
3802 :
3803 : int ASN1CALL
3804 0 : encode_HDB_extensions(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const HDB_extensions *data, size_t *size)
3805 : {
3806 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
3807 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3808 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
3809 :
3810 0 : for(i = (int)(data)->len - 1; i >= 0; --i) {
3811 0 : size_t Top_tag_for_oldret = ret;
3812 0 : ret = 0;
3813 0 : e = encode_HDB_extension(p, len, &(data)->val[i], &l);
3814 0 : if (e) return e;
3815 0 : p -= l; len -= l; ret += l;
3816 :
3817 0 : ret += Top_tag_for_oldret;
3818 : }
3819 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
3820 0 : if (e) return e;
3821 0 : p -= l; len -= l; ret += l;
3822 :
3823 0 : *size = ret;
3824 0 : return 0;
3825 : }
3826 :
3827 : int ASN1CALL
3828 0 : decode_HDB_extensions(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, HDB_extensions *data, size_t *size)
3829 : {
3830 0 : size_t ret = 0;
3831 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3832 : int e HEIMDAL_UNUSED_ATTRIBUTE;
3833 :
3834 0 : memset(data, 0, sizeof(*data));
3835 : {
3836 : size_t Top_datalen, Top_oldlen;
3837 : Der_type Top_type;
3838 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
3839 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
3840 0 : if(e) goto fail;
3841 0 : p += l; len -= l; ret += l;
3842 0 : Top_oldlen = len;
3843 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3844 0 : len = Top_datalen;
3845 : {
3846 0 : size_t Top_Tag_origlen = len;
3847 0 : size_t Top_Tag_oldret = ret;
3848 0 : size_t Top_Tag_olen = 0;
3849 : void *Top_Tag_tmp;
3850 0 : ret = 0;
3851 0 : (data)->len = 0;
3852 0 : (data)->val = NULL;
3853 0 : while(ret < Top_Tag_origlen) {
3854 0 : size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
3855 0 : if (Top_Tag_olen > Top_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
3856 0 : Top_Tag_olen = Top_Tag_nlen;
3857 0 : Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
3858 0 : if (Top_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
3859 0 : (data)->val = Top_Tag_tmp;
3860 0 : e = decode_HDB_extension(p, len, &(data)->val[(data)->len], &l);
3861 0 : if(e) goto fail;
3862 0 : p += l; len -= l; ret += l;
3863 0 : (data)->len++;
3864 0 : len = Top_Tag_origlen - ret;
3865 : }
3866 0 : ret += Top_Tag_oldret;
3867 : }
3868 0 : len = Top_oldlen - Top_datalen;
3869 : }
3870 0 : if(size) *size = ret;
3871 0 : return 0;
3872 0 : fail:
3873 0 : free_HDB_extensions(data);
3874 0 : return e;
3875 : }
3876 :
3877 : void ASN1CALL
3878 0 : free_HDB_extensions(HDB_extensions *data)
3879 : {
3880 0 : while((data)->len){
3881 0 : free_HDB_extension(&(data)->val[(data)->len-1]);
3882 0 : (data)->len--;
3883 : }
3884 0 : free((data)->val);
3885 0 : (data)->val = NULL;
3886 0 : }
3887 :
3888 : size_t ASN1CALL
3889 0 : length_HDB_extensions(const HDB_extensions *data)
3890 : {
3891 0 : size_t ret = 0;
3892 : {
3893 0 : size_t Top_tag_oldret = ret;
3894 : int i;
3895 0 : ret = 0;
3896 0 : for(i = (data)->len - 1; i >= 0; --i){
3897 0 : size_t Top_tag_for_oldret = ret;
3898 0 : ret = 0;
3899 0 : ret += length_HDB_extension(&(data)->val[i]);
3900 0 : ret += Top_tag_for_oldret;
3901 : }
3902 0 : ret += Top_tag_oldret;
3903 : }
3904 0 : ret += 1 + der_length_len (ret);
3905 0 : return ret;
3906 : }
3907 :
3908 : int ASN1CALL
3909 0 : copy_HDB_extensions(const HDB_extensions *from, HDB_extensions *to)
3910 : {
3911 0 : memset(to, 0, sizeof(*to));
3912 0 : if(((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
3913 0 : goto fail;
3914 0 : for((to)->len = 0; (to)->len < (from)->len; (to)->len++){
3915 0 : if(copy_HDB_extension(&(from)->val[(to)->len], &(to)->val[(to)->len])) goto fail;
3916 : }
3917 0 : return 0;
3918 0 : fail:
3919 0 : free_HDB_extensions(to);
3920 0 : return ENOMEM;
3921 : }
3922 :
3923 : int ASN1CALL
3924 0 : encode_hdb_entry(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const hdb_entry *data, size_t *size)
3925 : {
3926 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
3927 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3928 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
3929 :
3930 : /* extensions */
3931 0 : if((data)->extensions) {
3932 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3933 0 : ret = 0;
3934 0 : e = encode_HDB_extensions(p, len, (data)->extensions, &l);
3935 0 : if (e) return e;
3936 0 : p -= l; len -= l; ret += l;
3937 :
3938 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 13, &l);
3939 0 : if (e) return e;
3940 0 : p -= l; len -= l; ret += l;
3941 :
3942 0 : ret += Top_tag_oldret;
3943 : }
3944 : /* generation */
3945 0 : if((data)->generation) {
3946 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3947 0 : ret = 0;
3948 0 : e = encode_GENERATION(p, len, (data)->generation, &l);
3949 0 : if (e) return e;
3950 0 : p -= l; len -= l; ret += l;
3951 :
3952 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 12, &l);
3953 0 : if (e) return e;
3954 0 : p -= l; len -= l; ret += l;
3955 :
3956 0 : ret += Top_tag_oldret;
3957 : }
3958 : /* etypes */
3959 0 : if((data)->etypes) {
3960 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3961 0 : ret = 0;
3962 0 : for(i = (int)((data)->etypes)->len - 1; i >= 0; --i) {
3963 0 : size_t etypes_tag_tag_for_oldret = ret;
3964 0 : ret = 0;
3965 0 : e = der_put_unsigned(p, len, &((data)->etypes)->val[i], &l);
3966 0 : if (e) return e;
3967 0 : p -= l; len -= l; ret += l;
3968 :
3969 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
3970 0 : if (e) return e;
3971 0 : p -= l; len -= l; ret += l;
3972 :
3973 0 : ret += etypes_tag_tag_for_oldret;
3974 : }
3975 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
3976 0 : if (e) return e;
3977 0 : p -= l; len -= l; ret += l;
3978 :
3979 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 11, &l);
3980 0 : if (e) return e;
3981 0 : p -= l; len -= l; ret += l;
3982 :
3983 0 : ret += Top_tag_oldret;
3984 : }
3985 : /* flags */
3986 : {
3987 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3988 0 : ret = 0;
3989 0 : e = encode_HDBFlags(p, len, &(data)->flags, &l);
3990 0 : if (e) return e;
3991 0 : p -= l; len -= l; ret += l;
3992 :
3993 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 10, &l);
3994 0 : if (e) return e;
3995 0 : p -= l; len -= l; ret += l;
3996 :
3997 0 : ret += Top_tag_oldret;
3998 : }
3999 : /* max-renew */
4000 0 : if((data)->max_renew) {
4001 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4002 0 : ret = 0;
4003 0 : e = der_put_unsigned(p, len, (data)->max_renew, &l);
4004 0 : if (e) return e;
4005 0 : p -= l; len -= l; ret += l;
4006 :
4007 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
4008 0 : if (e) return e;
4009 0 : p -= l; len -= l; ret += l;
4010 :
4011 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 9, &l);
4012 0 : if (e) return e;
4013 0 : p -= l; len -= l; ret += l;
4014 :
4015 0 : ret += Top_tag_oldret;
4016 : }
4017 : /* max-life */
4018 0 : if((data)->max_life) {
4019 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4020 0 : ret = 0;
4021 0 : e = der_put_unsigned(p, len, (data)->max_life, &l);
4022 0 : if (e) return e;
4023 0 : p -= l; len -= l; ret += l;
4024 :
4025 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
4026 0 : if (e) return e;
4027 0 : p -= l; len -= l; ret += l;
4028 :
4029 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 8, &l);
4030 0 : if (e) return e;
4031 0 : p -= l; len -= l; ret += l;
4032 :
4033 0 : ret += Top_tag_oldret;
4034 : }
4035 : /* pw-end */
4036 0 : if((data)->pw_end) {
4037 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4038 0 : ret = 0;
4039 0 : e = encode_KerberosTime(p, len, (data)->pw_end, &l);
4040 0 : if (e) return e;
4041 0 : p -= l; len -= l; ret += l;
4042 :
4043 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 7, &l);
4044 0 : if (e) return e;
4045 0 : p -= l; len -= l; ret += l;
4046 :
4047 0 : ret += Top_tag_oldret;
4048 : }
4049 : /* valid-end */
4050 0 : if((data)->valid_end) {
4051 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4052 0 : ret = 0;
4053 0 : e = encode_KerberosTime(p, len, (data)->valid_end, &l);
4054 0 : if (e) return e;
4055 0 : p -= l; len -= l; ret += l;
4056 :
4057 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 6, &l);
4058 0 : if (e) return e;
4059 0 : p -= l; len -= l; ret += l;
4060 :
4061 0 : ret += Top_tag_oldret;
4062 : }
4063 : /* valid-start */
4064 0 : if((data)->valid_start) {
4065 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4066 0 : ret = 0;
4067 0 : e = encode_KerberosTime(p, len, (data)->valid_start, &l);
4068 0 : if (e) return e;
4069 0 : p -= l; len -= l; ret += l;
4070 :
4071 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 5, &l);
4072 0 : if (e) return e;
4073 0 : p -= l; len -= l; ret += l;
4074 :
4075 0 : ret += Top_tag_oldret;
4076 : }
4077 : /* modified-by */
4078 0 : if((data)->modified_by) {
4079 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4080 0 : ret = 0;
4081 0 : e = encode_Event(p, len, (data)->modified_by, &l);
4082 0 : if (e) return e;
4083 0 : p -= l; len -= l; ret += l;
4084 :
4085 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 4, &l);
4086 0 : if (e) return e;
4087 0 : p -= l; len -= l; ret += l;
4088 :
4089 0 : ret += Top_tag_oldret;
4090 : }
4091 : /* created-by */
4092 : {
4093 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4094 0 : ret = 0;
4095 0 : e = encode_Event(p, len, &(data)->created_by, &l);
4096 0 : if (e) return e;
4097 0 : p -= l; len -= l; ret += l;
4098 :
4099 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
4100 0 : if (e) return e;
4101 0 : p -= l; len -= l; ret += l;
4102 :
4103 0 : ret += Top_tag_oldret;
4104 : }
4105 : /* keys */
4106 : {
4107 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4108 0 : ret = 0;
4109 0 : e = encode_Keys(p, len, &(data)->keys, &l);
4110 0 : if (e) return e;
4111 0 : p -= l; len -= l; ret += l;
4112 :
4113 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
4114 0 : if (e) return e;
4115 0 : p -= l; len -= l; ret += l;
4116 :
4117 0 : ret += Top_tag_oldret;
4118 : }
4119 : /* kvno */
4120 : {
4121 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4122 0 : ret = 0;
4123 0 : e = der_put_unsigned(p, len, &(data)->kvno, &l);
4124 0 : if (e) return e;
4125 0 : p -= l; len -= l; ret += l;
4126 :
4127 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
4128 0 : if (e) return e;
4129 0 : p -= l; len -= l; ret += l;
4130 :
4131 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
4132 0 : if (e) return e;
4133 0 : p -= l; len -= l; ret += l;
4134 :
4135 0 : ret += Top_tag_oldret;
4136 : }
4137 : /* principal */
4138 0 : if((data)->principal) {
4139 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4140 0 : ret = 0;
4141 0 : e = encode_Principal(p, len, (data)->principal, &l);
4142 0 : if (e) return e;
4143 0 : p -= l; len -= l; ret += l;
4144 :
4145 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
4146 0 : if (e) return e;
4147 0 : p -= l; len -= l; ret += l;
4148 :
4149 0 : ret += Top_tag_oldret;
4150 : }
4151 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
4152 0 : if (e) return e;
4153 0 : p -= l; len -= l; ret += l;
4154 :
4155 0 : *size = ret;
4156 0 : return 0;
4157 : }
4158 :
4159 : int ASN1CALL
4160 0 : decode_hdb_entry(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, hdb_entry *data, size_t *size)
4161 : {
4162 0 : size_t ret = 0;
4163 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
4164 : int e HEIMDAL_UNUSED_ATTRIBUTE;
4165 :
4166 0 : memset(data, 0, sizeof(*data));
4167 : {
4168 : size_t Top_datalen, Top_oldlen;
4169 : Der_type Top_type;
4170 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
4171 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
4172 0 : if(e) goto fail;
4173 0 : p += l; len -= l; ret += l;
4174 0 : Top_oldlen = len;
4175 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4176 0 : len = Top_datalen;
4177 : {
4178 : size_t principal_datalen, principal_oldlen;
4179 : Der_type principal_type;
4180 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &principal_type, 0, &principal_datalen, &l);
4181 0 : if (e == 0 && principal_type != CONS) { e = ASN1_BAD_ID; }
4182 0 : if(e) {
4183 0 : (data)->principal = NULL;
4184 : } else {
4185 0 : (data)->principal = calloc(1, sizeof(*(data)->principal));
4186 0 : if ((data)->principal == NULL) { e = ENOMEM; goto fail; }
4187 0 : p += l; len -= l; ret += l;
4188 0 : principal_oldlen = len;
4189 0 : if (principal_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4190 0 : len = principal_datalen;
4191 0 : e = decode_Principal(p, len, (data)->principal, &l);
4192 0 : if(e) goto fail;
4193 0 : p += l; len -= l; ret += l;
4194 0 : len = principal_oldlen - principal_datalen;
4195 : }
4196 : }
4197 : {
4198 : size_t kvno_datalen, kvno_oldlen;
4199 : Der_type kvno_type;
4200 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &kvno_type, 1, &kvno_datalen, &l);
4201 0 : if (e == 0 && kvno_type != CONS) { e = ASN1_BAD_ID; }
4202 0 : if(e) goto fail;
4203 0 : p += l; len -= l; ret += l;
4204 0 : kvno_oldlen = len;
4205 0 : if (kvno_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4206 0 : len = kvno_datalen;
4207 : {
4208 : size_t kvno_Tag_datalen, kvno_Tag_oldlen;
4209 : Der_type kvno_Tag_type;
4210 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &kvno_Tag_type, UT_Integer, &kvno_Tag_datalen, &l);
4211 0 : if (e == 0 && kvno_Tag_type != PRIM) { e = ASN1_BAD_ID; }
4212 0 : if(e) goto fail;
4213 0 : p += l; len -= l; ret += l;
4214 0 : kvno_Tag_oldlen = len;
4215 0 : if (kvno_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4216 0 : len = kvno_Tag_datalen;
4217 0 : e = der_get_unsigned(p, len, &(data)->kvno, &l);
4218 0 : if(e) goto fail;
4219 0 : p += l; len -= l; ret += l;
4220 0 : len = kvno_Tag_oldlen - kvno_Tag_datalen;
4221 : }
4222 0 : len = kvno_oldlen - kvno_datalen;
4223 : }
4224 : {
4225 : size_t keys_datalen, keys_oldlen;
4226 : Der_type keys_type;
4227 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &keys_type, 2, &keys_datalen, &l);
4228 0 : if (e == 0 && keys_type != CONS) { e = ASN1_BAD_ID; }
4229 0 : if(e) goto fail;
4230 0 : p += l; len -= l; ret += l;
4231 0 : keys_oldlen = len;
4232 0 : if (keys_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4233 0 : len = keys_datalen;
4234 0 : e = decode_Keys(p, len, &(data)->keys, &l);
4235 0 : if(e) goto fail;
4236 0 : p += l; len -= l; ret += l;
4237 0 : len = keys_oldlen - keys_datalen;
4238 : }
4239 : {
4240 : size_t created_by_datalen, created_by_oldlen;
4241 : Der_type created_by_type;
4242 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &created_by_type, 3, &created_by_datalen, &l);
4243 0 : if (e == 0 && created_by_type != CONS) { e = ASN1_BAD_ID; }
4244 0 : if(e) goto fail;
4245 0 : p += l; len -= l; ret += l;
4246 0 : created_by_oldlen = len;
4247 0 : if (created_by_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4248 0 : len = created_by_datalen;
4249 0 : e = decode_Event(p, len, &(data)->created_by, &l);
4250 0 : if(e) goto fail;
4251 0 : p += l; len -= l; ret += l;
4252 0 : len = created_by_oldlen - created_by_datalen;
4253 : }
4254 : {
4255 : size_t modified_by_datalen, modified_by_oldlen;
4256 : Der_type modified_by_type;
4257 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &modified_by_type, 4, &modified_by_datalen, &l);
4258 0 : if (e == 0 && modified_by_type != CONS) { e = ASN1_BAD_ID; }
4259 0 : if(e) {
4260 0 : (data)->modified_by = NULL;
4261 : } else {
4262 0 : (data)->modified_by = calloc(1, sizeof(*(data)->modified_by));
4263 0 : if ((data)->modified_by == NULL) { e = ENOMEM; goto fail; }
4264 0 : p += l; len -= l; ret += l;
4265 0 : modified_by_oldlen = len;
4266 0 : if (modified_by_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4267 0 : len = modified_by_datalen;
4268 0 : e = decode_Event(p, len, (data)->modified_by, &l);
4269 0 : if(e) goto fail;
4270 0 : p += l; len -= l; ret += l;
4271 0 : len = modified_by_oldlen - modified_by_datalen;
4272 : }
4273 : }
4274 : {
4275 : size_t valid_start_datalen, valid_start_oldlen;
4276 : Der_type valid_start_type;
4277 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &valid_start_type, 5, &valid_start_datalen, &l);
4278 0 : if (e == 0 && valid_start_type != CONS) { e = ASN1_BAD_ID; }
4279 0 : if(e) {
4280 0 : (data)->valid_start = NULL;
4281 : } else {
4282 0 : (data)->valid_start = calloc(1, sizeof(*(data)->valid_start));
4283 0 : if ((data)->valid_start == NULL) { e = ENOMEM; goto fail; }
4284 0 : p += l; len -= l; ret += l;
4285 0 : valid_start_oldlen = len;
4286 0 : if (valid_start_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4287 0 : len = valid_start_datalen;
4288 0 : e = decode_KerberosTime(p, len, (data)->valid_start, &l);
4289 0 : if(e) goto fail;
4290 0 : p += l; len -= l; ret += l;
4291 0 : len = valid_start_oldlen - valid_start_datalen;
4292 : }
4293 : }
4294 : {
4295 : size_t valid_end_datalen, valid_end_oldlen;
4296 : Der_type valid_end_type;
4297 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &valid_end_type, 6, &valid_end_datalen, &l);
4298 0 : if (e == 0 && valid_end_type != CONS) { e = ASN1_BAD_ID; }
4299 0 : if(e) {
4300 0 : (data)->valid_end = NULL;
4301 : } else {
4302 0 : (data)->valid_end = calloc(1, sizeof(*(data)->valid_end));
4303 0 : if ((data)->valid_end == NULL) { e = ENOMEM; goto fail; }
4304 0 : p += l; len -= l; ret += l;
4305 0 : valid_end_oldlen = len;
4306 0 : if (valid_end_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4307 0 : len = valid_end_datalen;
4308 0 : e = decode_KerberosTime(p, len, (data)->valid_end, &l);
4309 0 : if(e) goto fail;
4310 0 : p += l; len -= l; ret += l;
4311 0 : len = valid_end_oldlen - valid_end_datalen;
4312 : }
4313 : }
4314 : {
4315 : size_t pw_end_datalen, pw_end_oldlen;
4316 : Der_type pw_end_type;
4317 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &pw_end_type, 7, &pw_end_datalen, &l);
4318 0 : if (e == 0 && pw_end_type != CONS) { e = ASN1_BAD_ID; }
4319 0 : if(e) {
4320 0 : (data)->pw_end = NULL;
4321 : } else {
4322 0 : (data)->pw_end = calloc(1, sizeof(*(data)->pw_end));
4323 0 : if ((data)->pw_end == NULL) { e = ENOMEM; goto fail; }
4324 0 : p += l; len -= l; ret += l;
4325 0 : pw_end_oldlen = len;
4326 0 : if (pw_end_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4327 0 : len = pw_end_datalen;
4328 0 : e = decode_KerberosTime(p, len, (data)->pw_end, &l);
4329 0 : if(e) goto fail;
4330 0 : p += l; len -= l; ret += l;
4331 0 : len = pw_end_oldlen - pw_end_datalen;
4332 : }
4333 : }
4334 : {
4335 : size_t max_life_datalen, max_life_oldlen;
4336 : Der_type max_life_type;
4337 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &max_life_type, 8, &max_life_datalen, &l);
4338 0 : if (e == 0 && max_life_type != CONS) { e = ASN1_BAD_ID; }
4339 0 : if(e) {
4340 0 : (data)->max_life = NULL;
4341 : } else {
4342 0 : (data)->max_life = calloc(1, sizeof(*(data)->max_life));
4343 0 : if ((data)->max_life == NULL) { e = ENOMEM; goto fail; }
4344 0 : p += l; len -= l; ret += l;
4345 0 : max_life_oldlen = len;
4346 0 : if (max_life_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4347 0 : len = max_life_datalen;
4348 : {
4349 : size_t max_life_Tag_datalen, max_life_Tag_oldlen;
4350 : Der_type max_life_Tag_type;
4351 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &max_life_Tag_type, UT_Integer, &max_life_Tag_datalen, &l);
4352 0 : if (e == 0 && max_life_Tag_type != PRIM) { e = ASN1_BAD_ID; }
4353 0 : if(e) goto fail;
4354 0 : p += l; len -= l; ret += l;
4355 0 : max_life_Tag_oldlen = len;
4356 0 : if (max_life_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4357 0 : len = max_life_Tag_datalen;
4358 0 : e = der_get_unsigned(p, len, (data)->max_life, &l);
4359 0 : if(e) goto fail;
4360 0 : p += l; len -= l; ret += l;
4361 0 : len = max_life_Tag_oldlen - max_life_Tag_datalen;
4362 : }
4363 0 : len = max_life_oldlen - max_life_datalen;
4364 : }
4365 : }
4366 : {
4367 : size_t max_renew_datalen, max_renew_oldlen;
4368 : Der_type max_renew_type;
4369 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &max_renew_type, 9, &max_renew_datalen, &l);
4370 0 : if (e == 0 && max_renew_type != CONS) { e = ASN1_BAD_ID; }
4371 0 : if(e) {
4372 0 : (data)->max_renew = NULL;
4373 : } else {
4374 0 : (data)->max_renew = calloc(1, sizeof(*(data)->max_renew));
4375 0 : if ((data)->max_renew == NULL) { e = ENOMEM; goto fail; }
4376 0 : p += l; len -= l; ret += l;
4377 0 : max_renew_oldlen = len;
4378 0 : if (max_renew_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4379 0 : len = max_renew_datalen;
4380 : {
4381 : size_t max_renew_Tag_datalen, max_renew_Tag_oldlen;
4382 : Der_type max_renew_Tag_type;
4383 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &max_renew_Tag_type, UT_Integer, &max_renew_Tag_datalen, &l);
4384 0 : if (e == 0 && max_renew_Tag_type != PRIM) { e = ASN1_BAD_ID; }
4385 0 : if(e) goto fail;
4386 0 : p += l; len -= l; ret += l;
4387 0 : max_renew_Tag_oldlen = len;
4388 0 : if (max_renew_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4389 0 : len = max_renew_Tag_datalen;
4390 0 : e = der_get_unsigned(p, len, (data)->max_renew, &l);
4391 0 : if(e) goto fail;
4392 0 : p += l; len -= l; ret += l;
4393 0 : len = max_renew_Tag_oldlen - max_renew_Tag_datalen;
4394 : }
4395 0 : len = max_renew_oldlen - max_renew_datalen;
4396 : }
4397 : }
4398 : {
4399 : size_t flags_datalen, flags_oldlen;
4400 : Der_type flags_type;
4401 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &flags_type, 10, &flags_datalen, &l);
4402 0 : if (e == 0 && flags_type != CONS) { e = ASN1_BAD_ID; }
4403 0 : if(e) goto fail;
4404 0 : p += l; len -= l; ret += l;
4405 0 : flags_oldlen = len;
4406 0 : if (flags_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4407 0 : len = flags_datalen;
4408 0 : e = decode_HDBFlags(p, len, &(data)->flags, &l);
4409 0 : if(e) goto fail;
4410 0 : p += l; len -= l; ret += l;
4411 0 : len = flags_oldlen - flags_datalen;
4412 : }
4413 : {
4414 : size_t etypes_datalen, etypes_oldlen;
4415 : Der_type etypes_type;
4416 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &etypes_type, 11, &etypes_datalen, &l);
4417 0 : if (e == 0 && etypes_type != CONS) { e = ASN1_BAD_ID; }
4418 0 : if(e) {
4419 0 : (data)->etypes = NULL;
4420 : } else {
4421 0 : (data)->etypes = calloc(1, sizeof(*(data)->etypes));
4422 0 : if ((data)->etypes == NULL) { e = ENOMEM; goto fail; }
4423 0 : p += l; len -= l; ret += l;
4424 0 : etypes_oldlen = len;
4425 0 : if (etypes_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4426 0 : len = etypes_datalen;
4427 : {
4428 : size_t etypes_Tag_datalen, etypes_Tag_oldlen;
4429 : Der_type etypes_Tag_type;
4430 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &etypes_Tag_type, UT_Sequence, &etypes_Tag_datalen, &l);
4431 0 : if (e == 0 && etypes_Tag_type != CONS) { e = ASN1_BAD_ID; }
4432 0 : if(e) goto fail;
4433 0 : p += l; len -= l; ret += l;
4434 0 : etypes_Tag_oldlen = len;
4435 0 : if (etypes_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4436 0 : len = etypes_Tag_datalen;
4437 : {
4438 0 : size_t etypes_Tag_Tag_origlen = len;
4439 0 : size_t etypes_Tag_Tag_oldret = ret;
4440 0 : size_t etypes_Tag_Tag_olen = 0;
4441 : void *etypes_Tag_Tag_tmp;
4442 0 : ret = 0;
4443 0 : ((data)->etypes)->len = 0;
4444 0 : ((data)->etypes)->val = NULL;
4445 0 : while(ret < etypes_Tag_Tag_origlen) {
4446 0 : size_t etypes_Tag_Tag_nlen = etypes_Tag_Tag_olen + sizeof(*(((data)->etypes)->val));
4447 0 : if (etypes_Tag_Tag_olen > etypes_Tag_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
4448 0 : etypes_Tag_Tag_olen = etypes_Tag_Tag_nlen;
4449 0 : etypes_Tag_Tag_tmp = realloc(((data)->etypes)->val, etypes_Tag_Tag_olen);
4450 0 : if (etypes_Tag_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
4451 0 : ((data)->etypes)->val = etypes_Tag_Tag_tmp;
4452 : {
4453 : size_t etypes_Tag_Tag_s_of_datalen, etypes_Tag_Tag_s_of_oldlen;
4454 : Der_type etypes_Tag_Tag_s_of_type;
4455 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &etypes_Tag_Tag_s_of_type, UT_Integer, &etypes_Tag_Tag_s_of_datalen, &l);
4456 0 : if (e == 0 && etypes_Tag_Tag_s_of_type != PRIM) { e = ASN1_BAD_ID; }
4457 0 : if(e) goto fail;
4458 0 : p += l; len -= l; ret += l;
4459 0 : etypes_Tag_Tag_s_of_oldlen = len;
4460 0 : if (etypes_Tag_Tag_s_of_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4461 0 : len = etypes_Tag_Tag_s_of_datalen;
4462 0 : e = der_get_unsigned(p, len, &((data)->etypes)->val[((data)->etypes)->len], &l);
4463 0 : if(e) goto fail;
4464 0 : p += l; len -= l; ret += l;
4465 0 : len = etypes_Tag_Tag_s_of_oldlen - etypes_Tag_Tag_s_of_datalen;
4466 : }
4467 0 : ((data)->etypes)->len++;
4468 0 : len = etypes_Tag_Tag_origlen - ret;
4469 : }
4470 0 : ret += etypes_Tag_Tag_oldret;
4471 : }
4472 0 : len = etypes_Tag_oldlen - etypes_Tag_datalen;
4473 : }
4474 0 : len = etypes_oldlen - etypes_datalen;
4475 : }
4476 : }
4477 : {
4478 : size_t generation_datalen, generation_oldlen;
4479 : Der_type generation_type;
4480 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &generation_type, 12, &generation_datalen, &l);
4481 0 : if (e == 0 && generation_type != CONS) { e = ASN1_BAD_ID; }
4482 0 : if(e) {
4483 0 : (data)->generation = NULL;
4484 : } else {
4485 0 : (data)->generation = calloc(1, sizeof(*(data)->generation));
4486 0 : if ((data)->generation == NULL) { e = ENOMEM; goto fail; }
4487 0 : p += l; len -= l; ret += l;
4488 0 : generation_oldlen = len;
4489 0 : if (generation_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4490 0 : len = generation_datalen;
4491 0 : e = decode_GENERATION(p, len, (data)->generation, &l);
4492 0 : if(e) goto fail;
4493 0 : p += l; len -= l; ret += l;
4494 0 : len = generation_oldlen - generation_datalen;
4495 : }
4496 : }
4497 : {
4498 : size_t extensions_datalen, extensions_oldlen;
4499 : Der_type extensions_type;
4500 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &extensions_type, 13, &extensions_datalen, &l);
4501 0 : if (e == 0 && extensions_type != CONS) { e = ASN1_BAD_ID; }
4502 0 : if(e) {
4503 0 : (data)->extensions = NULL;
4504 : } else {
4505 0 : (data)->extensions = calloc(1, sizeof(*(data)->extensions));
4506 0 : if ((data)->extensions == NULL) { e = ENOMEM; goto fail; }
4507 0 : p += l; len -= l; ret += l;
4508 0 : extensions_oldlen = len;
4509 0 : if (extensions_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4510 0 : len = extensions_datalen;
4511 0 : e = decode_HDB_extensions(p, len, (data)->extensions, &l);
4512 0 : if(e) goto fail;
4513 0 : p += l; len -= l; ret += l;
4514 0 : len = extensions_oldlen - extensions_datalen;
4515 : }
4516 : }
4517 0 : len = Top_oldlen - Top_datalen;
4518 : }
4519 0 : if(size) *size = ret;
4520 0 : return 0;
4521 0 : fail:
4522 0 : free_hdb_entry(data);
4523 0 : return e;
4524 : }
4525 :
4526 : void ASN1CALL
4527 244004 : free_hdb_entry(hdb_entry *data)
4528 : {
4529 244004 : if((data)->principal) {
4530 244004 : free_Principal((data)->principal);
4531 244004 : free((data)->principal);
4532 244004 : (data)->principal = NULL;
4533 : }
4534 244004 : free_Keys(&(data)->keys);
4535 244004 : free_Event(&(data)->created_by);
4536 244004 : if((data)->modified_by) {
4537 0 : free_Event((data)->modified_by);
4538 0 : free((data)->modified_by);
4539 0 : (data)->modified_by = NULL;
4540 : }
4541 244004 : if((data)->valid_start) {
4542 0 : free_KerberosTime((data)->valid_start);
4543 0 : free((data)->valid_start);
4544 0 : (data)->valid_start = NULL;
4545 : }
4546 244004 : if((data)->valid_end) {
4547 0 : free_KerberosTime((data)->valid_end);
4548 0 : free((data)->valid_end);
4549 0 : (data)->valid_end = NULL;
4550 : }
4551 244004 : if((data)->pw_end) {
4552 63061 : free_KerberosTime((data)->pw_end);
4553 63061 : free((data)->pw_end);
4554 63061 : (data)->pw_end = NULL;
4555 : }
4556 244004 : if((data)->max_life) {
4557 242814 : free((data)->max_life);
4558 242814 : (data)->max_life = NULL;
4559 : }
4560 244004 : if((data)->max_renew) {
4561 242814 : free((data)->max_renew);
4562 242814 : (data)->max_renew = NULL;
4563 : }
4564 244004 : free_HDBFlags(&(data)->flags);
4565 244004 : if((data)->etypes) {
4566 1164686 : while(((data)->etypes)->len){
4567 683370 : ((data)->etypes)->len--;
4568 : }
4569 243721 : free(((data)->etypes)->val);
4570 243721 : ((data)->etypes)->val = NULL;
4571 243721 : free((data)->etypes);
4572 243721 : (data)->etypes = NULL;
4573 : }
4574 244004 : if((data)->generation) {
4575 0 : free_GENERATION((data)->generation);
4576 0 : free((data)->generation);
4577 0 : (data)->generation = NULL;
4578 : }
4579 244004 : if((data)->extensions) {
4580 0 : free_HDB_extensions((data)->extensions);
4581 0 : free((data)->extensions);
4582 0 : (data)->extensions = NULL;
4583 : }
4584 244004 : }
4585 :
4586 : size_t ASN1CALL
4587 0 : length_hdb_entry(const hdb_entry *data)
4588 : {
4589 0 : size_t ret = 0;
4590 0 : if((data)->principal){
4591 0 : size_t Top_tag_oldret = ret;
4592 0 : ret = 0;
4593 0 : ret += length_Principal((data)->principal);
4594 0 : ret += 1 + der_length_len (ret);
4595 0 : ret += Top_tag_oldret;
4596 : }
4597 : {
4598 0 : size_t Top_tag_oldret = ret;
4599 0 : ret = 0;
4600 0 : ret += der_length_unsigned(&(data)->kvno);
4601 0 : ret += 1 + der_length_len (ret);
4602 0 : ret += 1 + der_length_len (ret);
4603 0 : ret += Top_tag_oldret;
4604 : }
4605 : {
4606 0 : size_t Top_tag_oldret = ret;
4607 0 : ret = 0;
4608 0 : ret += length_Keys(&(data)->keys);
4609 0 : ret += 1 + der_length_len (ret);
4610 0 : ret += Top_tag_oldret;
4611 : }
4612 : {
4613 0 : size_t Top_tag_oldret = ret;
4614 0 : ret = 0;
4615 0 : ret += length_Event(&(data)->created_by);
4616 0 : ret += 1 + der_length_len (ret);
4617 0 : ret += Top_tag_oldret;
4618 : }
4619 0 : if((data)->modified_by){
4620 0 : size_t Top_tag_oldret = ret;
4621 0 : ret = 0;
4622 0 : ret += length_Event((data)->modified_by);
4623 0 : ret += 1 + der_length_len (ret);
4624 0 : ret += Top_tag_oldret;
4625 : }
4626 0 : if((data)->valid_start){
4627 0 : size_t Top_tag_oldret = ret;
4628 0 : ret = 0;
4629 0 : ret += length_KerberosTime((data)->valid_start);
4630 0 : ret += 1 + der_length_len (ret);
4631 0 : ret += Top_tag_oldret;
4632 : }
4633 0 : if((data)->valid_end){
4634 0 : size_t Top_tag_oldret = ret;
4635 0 : ret = 0;
4636 0 : ret += length_KerberosTime((data)->valid_end);
4637 0 : ret += 1 + der_length_len (ret);
4638 0 : ret += Top_tag_oldret;
4639 : }
4640 0 : if((data)->pw_end){
4641 0 : size_t Top_tag_oldret = ret;
4642 0 : ret = 0;
4643 0 : ret += length_KerberosTime((data)->pw_end);
4644 0 : ret += 1 + der_length_len (ret);
4645 0 : ret += Top_tag_oldret;
4646 : }
4647 0 : if((data)->max_life){
4648 0 : size_t Top_tag_oldret = ret;
4649 0 : ret = 0;
4650 0 : ret += der_length_unsigned((data)->max_life);
4651 0 : ret += 1 + der_length_len (ret);
4652 0 : ret += 1 + der_length_len (ret);
4653 0 : ret += Top_tag_oldret;
4654 : }
4655 0 : if((data)->max_renew){
4656 0 : size_t Top_tag_oldret = ret;
4657 0 : ret = 0;
4658 0 : ret += der_length_unsigned((data)->max_renew);
4659 0 : ret += 1 + der_length_len (ret);
4660 0 : ret += 1 + der_length_len (ret);
4661 0 : ret += Top_tag_oldret;
4662 : }
4663 : {
4664 0 : size_t Top_tag_oldret = ret;
4665 0 : ret = 0;
4666 0 : ret += length_HDBFlags(&(data)->flags);
4667 0 : ret += 1 + der_length_len (ret);
4668 0 : ret += Top_tag_oldret;
4669 : }
4670 0 : if((data)->etypes){
4671 0 : size_t Top_tag_oldret = ret;
4672 0 : ret = 0;
4673 : {
4674 0 : size_t etypes_tag_tag_oldret = ret;
4675 : int i;
4676 0 : ret = 0;
4677 0 : for(i = ((data)->etypes)->len - 1; i >= 0; --i){
4678 0 : size_t etypes_tag_tag_for_oldret = ret;
4679 0 : ret = 0;
4680 0 : ret += der_length_unsigned(&((data)->etypes)->val[i]);
4681 0 : ret += 1 + der_length_len (ret);
4682 0 : ret += etypes_tag_tag_for_oldret;
4683 : }
4684 0 : ret += etypes_tag_tag_oldret;
4685 : }
4686 0 : ret += 1 + der_length_len (ret);
4687 0 : ret += 1 + der_length_len (ret);
4688 0 : ret += Top_tag_oldret;
4689 : }
4690 0 : if((data)->generation){
4691 0 : size_t Top_tag_oldret = ret;
4692 0 : ret = 0;
4693 0 : ret += length_GENERATION((data)->generation);
4694 0 : ret += 1 + der_length_len (ret);
4695 0 : ret += Top_tag_oldret;
4696 : }
4697 0 : if((data)->extensions){
4698 0 : size_t Top_tag_oldret = ret;
4699 0 : ret = 0;
4700 0 : ret += length_HDB_extensions((data)->extensions);
4701 0 : ret += 1 + der_length_len (ret);
4702 0 : ret += Top_tag_oldret;
4703 : }
4704 0 : ret += 1 + der_length_len (ret);
4705 0 : return ret;
4706 : }
4707 :
4708 : int ASN1CALL
4709 0 : copy_hdb_entry(const hdb_entry *from, hdb_entry *to)
4710 : {
4711 0 : memset(to, 0, sizeof(*to));
4712 0 : if((from)->principal) {
4713 0 : (to)->principal = malloc(sizeof(*(to)->principal));
4714 0 : if((to)->principal == NULL) goto fail;
4715 0 : if(copy_Principal((from)->principal, (to)->principal)) goto fail;
4716 : }else
4717 0 : (to)->principal = NULL;
4718 0 : *(&(to)->kvno) = *(&(from)->kvno);
4719 0 : if(copy_Keys(&(from)->keys, &(to)->keys)) goto fail;
4720 0 : if(copy_Event(&(from)->created_by, &(to)->created_by)) goto fail;
4721 0 : if((from)->modified_by) {
4722 0 : (to)->modified_by = malloc(sizeof(*(to)->modified_by));
4723 0 : if((to)->modified_by == NULL) goto fail;
4724 0 : if(copy_Event((from)->modified_by, (to)->modified_by)) goto fail;
4725 : }else
4726 0 : (to)->modified_by = NULL;
4727 0 : if((from)->valid_start) {
4728 0 : (to)->valid_start = malloc(sizeof(*(to)->valid_start));
4729 0 : if((to)->valid_start == NULL) goto fail;
4730 0 : if(copy_KerberosTime((from)->valid_start, (to)->valid_start)) goto fail;
4731 : }else
4732 0 : (to)->valid_start = NULL;
4733 0 : if((from)->valid_end) {
4734 0 : (to)->valid_end = malloc(sizeof(*(to)->valid_end));
4735 0 : if((to)->valid_end == NULL) goto fail;
4736 0 : if(copy_KerberosTime((from)->valid_end, (to)->valid_end)) goto fail;
4737 : }else
4738 0 : (to)->valid_end = NULL;
4739 0 : if((from)->pw_end) {
4740 0 : (to)->pw_end = malloc(sizeof(*(to)->pw_end));
4741 0 : if((to)->pw_end == NULL) goto fail;
4742 0 : if(copy_KerberosTime((from)->pw_end, (to)->pw_end)) goto fail;
4743 : }else
4744 0 : (to)->pw_end = NULL;
4745 0 : if((from)->max_life) {
4746 0 : (to)->max_life = malloc(sizeof(*(to)->max_life));
4747 0 : if((to)->max_life == NULL) goto fail;
4748 0 : *((to)->max_life) = *((from)->max_life);
4749 : }else
4750 0 : (to)->max_life = NULL;
4751 0 : if((from)->max_renew) {
4752 0 : (to)->max_renew = malloc(sizeof(*(to)->max_renew));
4753 0 : if((to)->max_renew == NULL) goto fail;
4754 0 : *((to)->max_renew) = *((from)->max_renew);
4755 : }else
4756 0 : (to)->max_renew = NULL;
4757 0 : if(copy_HDBFlags(&(from)->flags, &(to)->flags)) goto fail;
4758 0 : if((from)->etypes) {
4759 0 : (to)->etypes = malloc(sizeof(*(to)->etypes));
4760 0 : if((to)->etypes == NULL) goto fail;
4761 0 : if((((to)->etypes)->val = malloc(((from)->etypes)->len * sizeof(*((to)->etypes)->val))) == NULL && ((from)->etypes)->len != 0)
4762 0 : goto fail;
4763 0 : for(((to)->etypes)->len = 0; ((to)->etypes)->len < ((from)->etypes)->len; ((to)->etypes)->len++){
4764 0 : *(&((to)->etypes)->val[((to)->etypes)->len]) = *(&((from)->etypes)->val[((to)->etypes)->len]);
4765 : }
4766 : }else
4767 0 : (to)->etypes = NULL;
4768 0 : if((from)->generation) {
4769 0 : (to)->generation = malloc(sizeof(*(to)->generation));
4770 0 : if((to)->generation == NULL) goto fail;
4771 0 : if(copy_GENERATION((from)->generation, (to)->generation)) goto fail;
4772 : }else
4773 0 : (to)->generation = NULL;
4774 0 : if((from)->extensions) {
4775 0 : (to)->extensions = malloc(sizeof(*(to)->extensions));
4776 0 : if((to)->extensions == NULL) goto fail;
4777 0 : if(copy_HDB_extensions((from)->extensions, (to)->extensions)) goto fail;
4778 : }else
4779 0 : (to)->extensions = NULL;
4780 0 : return 0;
4781 0 : fail:
4782 0 : free_hdb_entry(to);
4783 0 : return ENOMEM;
4784 : }
4785 :
4786 : int ASN1CALL
4787 0 : encode_hdb_entry_alias(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const hdb_entry_alias *data, size_t *size)
4788 : {
4789 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
4790 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
4791 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
4792 :
4793 : /* principal */
4794 0 : if((data)->principal) {
4795 0 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4796 0 : ret = 0;
4797 0 : e = encode_Principal(p, len, (data)->principal, &l);
4798 0 : if (e) return e;
4799 0 : p -= l; len -= l; ret += l;
4800 :
4801 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
4802 0 : if (e) return e;
4803 0 : p -= l; len -= l; ret += l;
4804 :
4805 0 : ret += Top_tag_tag_oldret;
4806 : }
4807 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
4808 0 : if (e) return e;
4809 0 : p -= l; len -= l; ret += l;
4810 :
4811 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_APPL, CONS, 0, &l);
4812 0 : if (e) return e;
4813 0 : p -= l; len -= l; ret += l;
4814 :
4815 0 : *size = ret;
4816 0 : return 0;
4817 : }
4818 :
4819 : int ASN1CALL
4820 0 : decode_hdb_entry_alias(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, hdb_entry_alias *data, size_t *size)
4821 : {
4822 0 : size_t ret = 0;
4823 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
4824 : int e HEIMDAL_UNUSED_ATTRIBUTE;
4825 :
4826 0 : memset(data, 0, sizeof(*data));
4827 : {
4828 : size_t Top_datalen, Top_oldlen;
4829 : Der_type Top_type;
4830 0 : e = der_match_tag_and_length(p, len, ASN1_C_APPL, &Top_type, 0, &Top_datalen, &l);
4831 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
4832 0 : if(e) goto fail;
4833 0 : p += l; len -= l; ret += l;
4834 0 : Top_oldlen = len;
4835 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4836 0 : len = Top_datalen;
4837 : {
4838 : size_t Top_Tag_datalen, Top_Tag_oldlen;
4839 : Der_type Top_Tag_type;
4840 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_Tag_type, UT_Sequence, &Top_Tag_datalen, &l);
4841 0 : if (e == 0 && Top_Tag_type != CONS) { e = ASN1_BAD_ID; }
4842 0 : if(e) goto fail;
4843 0 : p += l; len -= l; ret += l;
4844 0 : Top_Tag_oldlen = len;
4845 0 : if (Top_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4846 0 : len = Top_Tag_datalen;
4847 : {
4848 : size_t principal_datalen, principal_oldlen;
4849 : Der_type principal_type;
4850 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &principal_type, 0, &principal_datalen, &l);
4851 0 : if (e == 0 && principal_type != CONS) { e = ASN1_BAD_ID; }
4852 0 : if(e) {
4853 0 : (data)->principal = NULL;
4854 : } else {
4855 0 : (data)->principal = calloc(1, sizeof(*(data)->principal));
4856 0 : if ((data)->principal == NULL) { e = ENOMEM; goto fail; }
4857 0 : p += l; len -= l; ret += l;
4858 0 : principal_oldlen = len;
4859 0 : if (principal_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4860 0 : len = principal_datalen;
4861 0 : e = decode_Principal(p, len, (data)->principal, &l);
4862 0 : if(e) goto fail;
4863 0 : p += l; len -= l; ret += l;
4864 0 : len = principal_oldlen - principal_datalen;
4865 : }
4866 : }
4867 0 : len = Top_Tag_oldlen - Top_Tag_datalen;
4868 : }
4869 0 : len = Top_oldlen - Top_datalen;
4870 : }
4871 0 : if(size) *size = ret;
4872 0 : return 0;
4873 0 : fail:
4874 0 : free_hdb_entry_alias(data);
4875 0 : return e;
4876 : }
4877 :
4878 : void ASN1CALL
4879 0 : free_hdb_entry_alias(hdb_entry_alias *data)
4880 : {
4881 0 : if((data)->principal) {
4882 0 : free_Principal((data)->principal);
4883 0 : free((data)->principal);
4884 0 : (data)->principal = NULL;
4885 : }
4886 0 : }
4887 :
4888 : size_t ASN1CALL
4889 0 : length_hdb_entry_alias(const hdb_entry_alias *data)
4890 : {
4891 0 : size_t ret = 0;
4892 0 : if((data)->principal){
4893 0 : size_t Top_tag_tag_oldret = ret;
4894 0 : ret = 0;
4895 0 : ret += length_Principal((data)->principal);
4896 0 : ret += 1 + der_length_len (ret);
4897 0 : ret += Top_tag_tag_oldret;
4898 : }
4899 0 : ret += 1 + der_length_len (ret);
4900 0 : ret += 1 + der_length_len (ret);
4901 0 : return ret;
4902 : }
4903 :
4904 : int ASN1CALL
4905 0 : copy_hdb_entry_alias(const hdb_entry_alias *from, hdb_entry_alias *to)
4906 : {
4907 0 : memset(to, 0, sizeof(*to));
4908 0 : if((from)->principal) {
4909 0 : (to)->principal = malloc(sizeof(*(to)->principal));
4910 0 : if((to)->principal == NULL) goto fail;
4911 0 : if(copy_Principal((from)->principal, (to)->principal)) goto fail;
4912 : }else
4913 0 : (to)->principal = NULL;
4914 0 : return 0;
4915 0 : fail:
4916 0 : free_hdb_entry_alias(to);
4917 0 : return ENOMEM;
4918 : }
4919 :
|
