Line data Source code
1 : #include "config.h"
2 : /* Generated from /builds/samba-team/devel/samba/source4/heimdal/lib/asn1/krb5.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 <krb5_asn1.h>
15 : #include <krb5_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 905256 : encode_NAME_TYPE(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const NAME_TYPE *data, size_t *size)
24 : {
25 905256 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
26 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
27 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
28 :
29 : {
30 905256 : int enumint = (int)*data;
31 905256 : e = der_put_integer(p, len, &enumint, &l);
32 905256 : if (e) return e;
33 905256 : p -= l; len -= l; ret += l;
34 :
35 : }
36 905256 : ;e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
37 905256 : if (e) return e;
38 905256 : p -= l; len -= l; ret += l;
39 :
40 905256 : *size = ret;
41 905256 : return 0;
42 : }
43 :
44 : int ASN1CALL
45 773741 : decode_NAME_TYPE(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, NAME_TYPE *data, size_t *size)
46 : {
47 773741 : size_t ret = 0;
48 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
49 : int e HEIMDAL_UNUSED_ATTRIBUTE;
50 :
51 773741 : memset(data, 0, sizeof(*data));
52 : {
53 : size_t Top_datalen, Top_oldlen;
54 : Der_type Top_type;
55 773741 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Integer, &Top_datalen, &l);
56 773741 : if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
57 773741 : if(e) goto fail;
58 773741 : p += l; len -= l; ret += l;
59 773741 : Top_oldlen = len;
60 773741 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
61 773741 : len = Top_datalen;
62 : {
63 : int enumint;
64 773741 : e = der_get_integer(p, len, &enumint, &l);
65 773741 : if(e) goto fail;
66 773741 : p += l; len -= l; ret += l;
67 773741 : *data = enumint;
68 : }
69 773741 : len = Top_oldlen - Top_datalen;
70 : }
71 1547482 : if(size) *size = ret;
72 754676 : return 0;
73 0 : fail:
74 0 : free_NAME_TYPE(data);
75 0 : return e;
76 : }
77 :
78 : void ASN1CALL
79 5306644 : free_NAME_TYPE(NAME_TYPE *data)
80 : {
81 5306644 : }
82 :
83 : size_t ASN1CALL
84 905256 : length_NAME_TYPE(const NAME_TYPE *data)
85 : {
86 905256 : size_t ret = 0;
87 : {
88 905256 : int enumint = *data;
89 905256 : ret += der_length_integer(&enumint);
90 : }
91 905256 : ret += 1 + der_length_len (ret);
92 905256 : return ret;
93 : }
94 :
95 : int ASN1CALL
96 3344991 : copy_NAME_TYPE(const NAME_TYPE *from, NAME_TYPE *to)
97 : {
98 3344991 : memset(to, 0, sizeof(*to));
99 3344991 : *(to) = *(from);
100 3344991 : return 0;
101 : }
102 :
103 : int ASN1CALL
104 293398 : encode_MESSAGE_TYPE(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const MESSAGE_TYPE *data, size_t *size)
105 : {
106 293398 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
107 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
108 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
109 :
110 : {
111 293398 : int enumint = (int)*data;
112 293398 : e = der_put_integer(p, len, &enumint, &l);
113 293398 : if (e) return e;
114 293398 : p -= l; len -= l; ret += l;
115 :
116 : }
117 293398 : ;e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
118 293398 : if (e) return e;
119 293398 : p -= l; len -= l; ret += l;
120 :
121 293398 : *size = ret;
122 293398 : return 0;
123 : }
124 :
125 : int ASN1CALL
126 326666 : decode_MESSAGE_TYPE(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, MESSAGE_TYPE *data, size_t *size)
127 : {
128 326666 : size_t ret = 0;
129 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
130 : int e HEIMDAL_UNUSED_ATTRIBUTE;
131 :
132 326666 : memset(data, 0, sizeof(*data));
133 : {
134 : size_t Top_datalen, Top_oldlen;
135 : Der_type Top_type;
136 326666 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Integer, &Top_datalen, &l);
137 326666 : if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
138 326666 : if(e) goto fail;
139 326666 : p += l; len -= l; ret += l;
140 326666 : Top_oldlen = len;
141 326666 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
142 326666 : len = Top_datalen;
143 : {
144 : int enumint;
145 326666 : e = der_get_integer(p, len, &enumint, &l);
146 326666 : if(e) goto fail;
147 326666 : p += l; len -= l; ret += l;
148 326666 : *data = enumint;
149 : }
150 326666 : len = Top_oldlen - Top_datalen;
151 : }
152 653332 : if(size) *size = ret;
153 319024 : return 0;
154 0 : fail:
155 0 : free_MESSAGE_TYPE(data);
156 0 : return e;
157 : }
158 :
159 : void ASN1CALL
160 781327 : free_MESSAGE_TYPE(MESSAGE_TYPE *data)
161 : {
162 781327 : }
163 :
164 : size_t ASN1CALL
165 293398 : length_MESSAGE_TYPE(const MESSAGE_TYPE *data)
166 : {
167 293398 : size_t ret = 0;
168 : {
169 293398 : int enumint = *data;
170 293398 : ret += der_length_integer(&enumint);
171 : }
172 293398 : ret += 1 + der_length_len (ret);
173 293398 : return ret;
174 : }
175 :
176 : int ASN1CALL
177 0 : copy_MESSAGE_TYPE(const MESSAGE_TYPE *from, MESSAGE_TYPE *to)
178 : {
179 0 : memset(to, 0, sizeof(*to));
180 0 : *(to) = *(from);
181 0 : return 0;
182 : }
183 :
184 : int ASN1CALL
185 144479 : encode_PADATA_TYPE(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const PADATA_TYPE *data, size_t *size)
186 : {
187 144479 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
188 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
189 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
190 :
191 : {
192 144479 : int enumint = (int)*data;
193 144479 : e = der_put_integer(p, len, &enumint, &l);
194 144479 : if (e) return e;
195 144479 : p -= l; len -= l; ret += l;
196 :
197 : }
198 144479 : ;e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
199 144479 : if (e) return e;
200 144479 : p -= l; len -= l; ret += l;
201 :
202 144479 : *size = ret;
203 144479 : return 0;
204 : }
205 :
206 : int ASN1CALL
207 155916 : decode_PADATA_TYPE(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, PADATA_TYPE *data, size_t *size)
208 : {
209 155916 : size_t ret = 0;
210 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
211 : int e HEIMDAL_UNUSED_ATTRIBUTE;
212 :
213 155916 : memset(data, 0, sizeof(*data));
214 : {
215 : size_t Top_datalen, Top_oldlen;
216 : Der_type Top_type;
217 155916 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Integer, &Top_datalen, &l);
218 155916 : if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
219 155916 : if(e) goto fail;
220 155916 : p += l; len -= l; ret += l;
221 155916 : Top_oldlen = len;
222 155916 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
223 155916 : len = Top_datalen;
224 : {
225 : int enumint;
226 155916 : e = der_get_integer(p, len, &enumint, &l);
227 155916 : if(e) goto fail;
228 155916 : p += l; len -= l; ret += l;
229 155916 : *data = enumint;
230 : }
231 155916 : len = Top_oldlen - Top_datalen;
232 : }
233 311832 : if(size) *size = ret;
234 152762 : return 0;
235 0 : fail:
236 0 : free_PADATA_TYPE(data);
237 0 : return e;
238 : }
239 :
240 : void ASN1CALL
241 292474 : free_PADATA_TYPE(PADATA_TYPE *data)
242 : {
243 292474 : }
244 :
245 : size_t ASN1CALL
246 144479 : length_PADATA_TYPE(const PADATA_TYPE *data)
247 : {
248 144479 : size_t ret = 0;
249 : {
250 144479 : int enumint = *data;
251 144479 : ret += der_length_integer(&enumint);
252 : }
253 144479 : ret += 1 + der_length_len (ret);
254 144479 : return ret;
255 : }
256 :
257 : int ASN1CALL
258 1356 : copy_PADATA_TYPE(const PADATA_TYPE *from, PADATA_TYPE *to)
259 : {
260 1356 : memset(to, 0, sizeof(*to));
261 1356 : *(to) = *(from);
262 1356 : return 0;
263 : }
264 :
265 : int ASN1CALL
266 0 : encode_AUTHDATA_TYPE(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const AUTHDATA_TYPE *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 : {
273 0 : int enumint = (int)*data;
274 0 : e = der_put_integer(p, len, &enumint, &l);
275 0 : if (e) return e;
276 0 : p -= l; len -= l; ret += l;
277 :
278 : }
279 0 : ;e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
280 0 : if (e) return e;
281 0 : p -= l; len -= l; ret += l;
282 :
283 0 : *size = ret;
284 0 : return 0;
285 : }
286 :
287 : int ASN1CALL
288 0 : decode_AUTHDATA_TYPE(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, AUTHDATA_TYPE *data, size_t *size)
289 : {
290 0 : size_t ret = 0;
291 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
292 : int e HEIMDAL_UNUSED_ATTRIBUTE;
293 :
294 0 : memset(data, 0, sizeof(*data));
295 : {
296 : size_t Top_datalen, Top_oldlen;
297 : Der_type Top_type;
298 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Integer, &Top_datalen, &l);
299 0 : if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
300 0 : if(e) goto fail;
301 0 : p += l; len -= l; ret += l;
302 0 : Top_oldlen = len;
303 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
304 0 : len = Top_datalen;
305 : {
306 : int enumint;
307 0 : e = der_get_integer(p, len, &enumint, &l);
308 0 : if(e) goto fail;
309 0 : p += l; len -= l; ret += l;
310 0 : *data = enumint;
311 : }
312 0 : len = Top_oldlen - Top_datalen;
313 : }
314 0 : if(size) *size = ret;
315 0 : return 0;
316 0 : fail:
317 0 : free_AUTHDATA_TYPE(data);
318 0 : return e;
319 : }
320 :
321 : void ASN1CALL
322 0 : free_AUTHDATA_TYPE(AUTHDATA_TYPE *data)
323 : {
324 0 : }
325 :
326 : size_t ASN1CALL
327 0 : length_AUTHDATA_TYPE(const AUTHDATA_TYPE *data)
328 : {
329 0 : size_t ret = 0;
330 : {
331 0 : int enumint = *data;
332 0 : ret += der_length_integer(&enumint);
333 : }
334 0 : ret += 1 + der_length_len (ret);
335 0 : return ret;
336 : }
337 :
338 : int ASN1CALL
339 0 : copy_AUTHDATA_TYPE(const AUTHDATA_TYPE *from, AUTHDATA_TYPE *to)
340 : {
341 0 : memset(to, 0, sizeof(*to));
342 0 : *(to) = *(from);
343 0 : return 0;
344 : }
345 :
346 : int ASN1CALL
347 133666 : encode_CKSUMTYPE(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const CKSUMTYPE *data, size_t *size)
348 : {
349 133666 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
350 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
351 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
352 :
353 : {
354 133666 : int enumint = (int)*data;
355 133666 : e = der_put_integer(p, len, &enumint, &l);
356 133666 : if (e) return e;
357 133666 : p -= l; len -= l; ret += l;
358 :
359 : }
360 133666 : ;e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
361 133666 : if (e) return e;
362 133666 : p -= l; len -= l; ret += l;
363 :
364 133666 : *size = ret;
365 133666 : return 0;
366 : }
367 :
368 : int ASN1CALL
369 102319 : decode_CKSUMTYPE(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, CKSUMTYPE *data, size_t *size)
370 : {
371 102319 : size_t ret = 0;
372 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
373 : int e HEIMDAL_UNUSED_ATTRIBUTE;
374 :
375 102319 : memset(data, 0, sizeof(*data));
376 : {
377 : size_t Top_datalen, Top_oldlen;
378 : Der_type Top_type;
379 102319 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Integer, &Top_datalen, &l);
380 102319 : if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
381 102319 : if(e) goto fail;
382 102319 : p += l; len -= l; ret += l;
383 102319 : Top_oldlen = len;
384 102319 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
385 102319 : len = Top_datalen;
386 : {
387 : int enumint;
388 102319 : e = der_get_integer(p, len, &enumint, &l);
389 102319 : if(e) goto fail;
390 102319 : p += l; len -= l; ret += l;
391 102319 : *data = enumint;
392 : }
393 102319 : len = Top_oldlen - Top_datalen;
394 : }
395 204638 : if(size) *size = ret;
396 99403 : return 0;
397 0 : fail:
398 0 : free_CKSUMTYPE(data);
399 0 : return e;
400 : }
401 :
402 : void ASN1CALL
403 1632769 : free_CKSUMTYPE(CKSUMTYPE *data)
404 : {
405 1632769 : }
406 :
407 : size_t ASN1CALL
408 133666 : length_CKSUMTYPE(const CKSUMTYPE *data)
409 : {
410 133666 : size_t ret = 0;
411 : {
412 133666 : int enumint = *data;
413 133666 : ret += der_length_integer(&enumint);
414 : }
415 133666 : ret += 1 + der_length_len (ret);
416 133666 : return ret;
417 : }
418 :
419 : int ASN1CALL
420 169376 : copy_CKSUMTYPE(const CKSUMTYPE *from, CKSUMTYPE *to)
421 : {
422 169376 : memset(to, 0, sizeof(*to));
423 169376 : *(to) = *(from);
424 169376 : return 0;
425 : }
426 :
427 : int ASN1CALL
428 1388298 : encode_ENCTYPE(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const ENCTYPE *data, size_t *size)
429 : {
430 1388298 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
431 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
432 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
433 :
434 : {
435 1388298 : int enumint = (int)*data;
436 1388298 : e = der_put_integer(p, len, &enumint, &l);
437 1388298 : if (e) return e;
438 1388298 : p -= l; len -= l; ret += l;
439 :
440 : }
441 1388298 : ;e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
442 1388298 : if (e) return e;
443 1388298 : p -= l; len -= l; ret += l;
444 :
445 1388298 : *size = ret;
446 1388298 : return 0;
447 : }
448 :
449 : int ASN1CALL
450 1066664 : decode_ENCTYPE(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, ENCTYPE *data, size_t *size)
451 : {
452 1066664 : size_t ret = 0;
453 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
454 : int e HEIMDAL_UNUSED_ATTRIBUTE;
455 :
456 1066664 : memset(data, 0, sizeof(*data));
457 : {
458 : size_t Top_datalen, Top_oldlen;
459 : Der_type Top_type;
460 1066664 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Integer, &Top_datalen, &l);
461 1066664 : if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
462 1066664 : if(e) goto fail;
463 1066664 : p += l; len -= l; ret += l;
464 1066664 : Top_oldlen = len;
465 1066664 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
466 1066664 : len = Top_datalen;
467 : {
468 : int enumint;
469 1066664 : e = der_get_integer(p, len, &enumint, &l);
470 1066664 : if(e) goto fail;
471 1066664 : p += l; len -= l; ret += l;
472 1066664 : *data = enumint;
473 : }
474 1066664 : len = Top_oldlen - Top_datalen;
475 : }
476 2133328 : if(size) *size = ret;
477 1039809 : return 0;
478 0 : fail:
479 0 : free_ENCTYPE(data);
480 0 : return e;
481 : }
482 :
483 : void ASN1CALL
484 1903729 : free_ENCTYPE(ENCTYPE *data)
485 : {
486 1903729 : }
487 :
488 : size_t ASN1CALL
489 1388298 : length_ENCTYPE(const ENCTYPE *data)
490 : {
491 1388298 : size_t ret = 0;
492 : {
493 1388298 : int enumint = *data;
494 1388298 : ret += der_length_integer(&enumint);
495 : }
496 1388298 : ret += 1 + der_length_len (ret);
497 1388298 : return ret;
498 : }
499 :
500 : int ASN1CALL
501 68152 : copy_ENCTYPE(const ENCTYPE *from, ENCTYPE *to)
502 : {
503 68152 : memset(to, 0, sizeof(*to));
504 68152 : *(to) = *(from);
505 68152 : return 0;
506 : }
507 :
508 : int ASN1CALL
509 45375 : encode_krb5uint32(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const krb5uint32 *data, size_t *size)
510 : {
511 45375 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
512 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
513 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
514 :
515 45375 : e = der_put_unsigned(p, len, data, &l);
516 45375 : if (e) return e;
517 45375 : p -= l; len -= l; ret += l;
518 :
519 45375 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
520 45375 : if (e) return e;
521 45375 : p -= l; len -= l; ret += l;
522 :
523 45375 : *size = ret;
524 45375 : return 0;
525 : }
526 :
527 : int ASN1CALL
528 43318 : decode_krb5uint32(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, krb5uint32 *data, size_t *size)
529 : {
530 43318 : size_t ret = 0;
531 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
532 : int e HEIMDAL_UNUSED_ATTRIBUTE;
533 :
534 43318 : memset(data, 0, sizeof(*data));
535 : {
536 : size_t Top_datalen, Top_oldlen;
537 : Der_type Top_type;
538 43318 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Integer, &Top_datalen, &l);
539 43318 : if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
540 43318 : if(e) goto fail;
541 43318 : p += l; len -= l; ret += l;
542 43318 : Top_oldlen = len;
543 43318 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
544 43318 : len = Top_datalen;
545 43318 : e = der_get_unsigned(p, len, data, &l);
546 43318 : if(e) goto fail;
547 43318 : p += l; len -= l; ret += l;
548 43318 : len = Top_oldlen - Top_datalen;
549 : }
550 86636 : if(size) *size = ret;
551 41746 : return 0;
552 0 : fail:
553 0 : free_krb5uint32(data);
554 0 : return e;
555 : }
556 :
557 : void ASN1CALL
558 108742 : free_krb5uint32(krb5uint32 *data)
559 : {
560 108742 : }
561 :
562 : size_t ASN1CALL
563 45375 : length_krb5uint32(const krb5uint32 *data)
564 : {
565 45375 : size_t ret = 0;
566 45375 : ret += der_length_unsigned(data);
567 45375 : ret += 1 + der_length_len (ret);
568 45375 : return ret;
569 : }
570 :
571 : int ASN1CALL
572 20134 : copy_krb5uint32(const krb5uint32 *from, krb5uint32 *to)
573 : {
574 20134 : memset(to, 0, sizeof(*to));
575 20134 : *(to) = *(from);
576 20134 : return 0;
577 : }
578 :
579 : int ASN1CALL
580 1859251 : encode_krb5int32(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const krb5int32 *data, size_t *size)
581 : {
582 1859251 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
583 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
584 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
585 :
586 1859251 : e = der_put_integer(p, len, data, &l);
587 1859251 : if (e) return e;
588 1859251 : p -= l; len -= l; ret += l;
589 :
590 1859251 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
591 1859251 : if (e) return e;
592 1859251 : p -= l; len -= l; ret += l;
593 :
594 1859251 : *size = ret;
595 1859251 : return 0;
596 : }
597 :
598 : int ASN1CALL
599 1875666 : decode_krb5int32(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, krb5int32 *data, size_t *size)
600 : {
601 1875666 : size_t ret = 0;
602 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
603 : int e HEIMDAL_UNUSED_ATTRIBUTE;
604 :
605 1875666 : memset(data, 0, sizeof(*data));
606 : {
607 : size_t Top_datalen, Top_oldlen;
608 : Der_type Top_type;
609 1875666 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Integer, &Top_datalen, &l);
610 1875666 : if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
611 1875666 : if(e) goto fail;
612 1875666 : p += l; len -= l; ret += l;
613 1875666 : Top_oldlen = len;
614 1875666 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
615 1875666 : len = Top_datalen;
616 1875666 : e = der_get_integer(p, len, data, &l);
617 1875666 : if(e) goto fail;
618 1875666 : p += l; len -= l; ret += l;
619 1875666 : len = Top_oldlen - Top_datalen;
620 : }
621 3751332 : if(size) *size = ret;
622 1825108 : return 0;
623 0 : fail:
624 0 : free_krb5int32(data);
625 0 : return e;
626 : }
627 :
628 : void ASN1CALL
629 5290166 : free_krb5int32(krb5int32 *data)
630 : {
631 5290166 : }
632 :
633 : size_t ASN1CALL
634 1859251 : length_krb5int32(const krb5int32 *data)
635 : {
636 1859251 : size_t ret = 0;
637 1859251 : ret += der_length_integer(data);
638 1859251 : ret += 1 + der_length_len (ret);
639 1859251 : return ret;
640 : }
641 :
642 : int ASN1CALL
643 4535013 : copy_krb5int32(const krb5int32 *from, krb5int32 *to)
644 : {
645 4535013 : memset(to, 0, sizeof(*to));
646 4535013 : *(to) = *(from);
647 4535013 : return 0;
648 : }
649 :
650 : int ASN1CALL
651 9804 : encode_KerberosString(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const KerberosString *data, size_t *size)
652 : {
653 9804 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
654 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
655 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
656 :
657 9804 : e = der_put_general_string(p, len, data, &l);
658 9804 : if (e) return e;
659 9804 : p -= l; len -= l; ret += l;
660 :
661 9804 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_GeneralString, &l);
662 9804 : if (e) return e;
663 9804 : p -= l; len -= l; ret += l;
664 :
665 9804 : *size = ret;
666 9804 : return 0;
667 : }
668 :
669 : int ASN1CALL
670 9336 : decode_KerberosString(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, KerberosString *data, size_t *size)
671 : {
672 9336 : size_t ret = 0;
673 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
674 : int e HEIMDAL_UNUSED_ATTRIBUTE;
675 :
676 9336 : memset(data, 0, sizeof(*data));
677 : {
678 : size_t Top_datalen, Top_oldlen;
679 : Der_type Top_type;
680 9336 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_GeneralString, &Top_datalen, &l);
681 9336 : if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
682 9336 : if(e) goto fail;
683 9336 : p += l; len -= l; ret += l;
684 9336 : Top_oldlen = len;
685 9336 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
686 9336 : len = Top_datalen;
687 9336 : e = der_get_general_string(p, len, data, &l);
688 9336 : if(e) goto fail;
689 9336 : p += l; len -= l; ret += l;
690 9336 : len = Top_oldlen - Top_datalen;
691 : }
692 18672 : if(size) *size = ret;
693 9123 : return 0;
694 0 : fail:
695 0 : free_KerberosString(data);
696 0 : return e;
697 : }
698 :
699 : void ASN1CALL
700 19140 : free_KerberosString(KerberosString *data)
701 : {
702 19140 : der_free_general_string(data);
703 19140 : }
704 :
705 : size_t ASN1CALL
706 9804 : length_KerberosString(const KerberosString *data)
707 : {
708 9804 : size_t ret = 0;
709 9804 : ret += der_length_general_string(data);
710 9804 : ret += 1 + der_length_len (ret);
711 9804 : return ret;
712 : }
713 :
714 : int ASN1CALL
715 0 : copy_KerberosString(const KerberosString *from, KerberosString *to)
716 : {
717 0 : memset(to, 0, sizeof(*to));
718 0 : if(der_copy_general_string(from, to)) goto fail;
719 0 : return 0;
720 0 : fail:
721 0 : free_KerberosString(to);
722 0 : return ENOMEM;
723 : }
724 :
725 : int ASN1CALL
726 860762 : encode_Realm(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const Realm *data, size_t *size)
727 : {
728 860762 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
729 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
730 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
731 :
732 860762 : e = der_put_general_string(p, len, data, &l);
733 860762 : if (e) return e;
734 860762 : p -= l; len -= l; ret += l;
735 :
736 860762 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_GeneralString, &l);
737 860762 : if (e) return e;
738 860762 : p -= l; len -= l; ret += l;
739 :
740 860762 : *size = ret;
741 860762 : return 0;
742 : }
743 :
744 : int ASN1CALL
745 720783 : decode_Realm(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, Realm *data, size_t *size)
746 : {
747 720783 : size_t ret = 0;
748 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
749 : int e HEIMDAL_UNUSED_ATTRIBUTE;
750 :
751 720783 : memset(data, 0, sizeof(*data));
752 : {
753 : size_t Top_datalen, Top_oldlen;
754 : Der_type Top_type;
755 720783 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_GeneralString, &Top_datalen, &l);
756 720783 : if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
757 720783 : if(e) goto fail;
758 720783 : p += l; len -= l; ret += l;
759 720783 : Top_oldlen = len;
760 720783 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
761 720783 : len = Top_datalen;
762 720783 : e = der_get_general_string(p, len, data, &l);
763 720783 : if(e) goto fail;
764 720783 : p += l; len -= l; ret += l;
765 720783 : len = Top_oldlen - Top_datalen;
766 : }
767 1441566 : if(size) *size = ret;
768 702603 : return 0;
769 0 : fail:
770 0 : free_Realm(data);
771 0 : return e;
772 : }
773 :
774 : void ASN1CALL
775 5273936 : free_Realm(Realm *data)
776 : {
777 5273936 : der_free_general_string(data);
778 5273936 : }
779 :
780 : size_t ASN1CALL
781 860762 : length_Realm(const Realm *data)
782 : {
783 860762 : size_t ret = 0;
784 860762 : ret += der_length_general_string(data);
785 860762 : ret += 1 + der_length_len (ret);
786 860762 : return ret;
787 : }
788 :
789 : int ASN1CALL
790 2695965 : copy_Realm(const Realm *from, Realm *to)
791 : {
792 2695965 : memset(to, 0, sizeof(*to));
793 2695965 : if(der_copy_general_string(from, to)) goto fail;
794 2623407 : return 0;
795 0 : fail:
796 0 : free_Realm(to);
797 0 : return ENOMEM;
798 : }
799 :
800 : int ASN1CALL
801 905256 : encode_PrincipalName(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const PrincipalName *data, size_t *size)
802 : {
803 905256 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
804 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
805 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
806 :
807 : /* name-string */
808 : {
809 905256 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
810 905256 : ret = 0;
811 2291888 : for(i = (int)(&(data)->name_string)->len - 1; i >= 0; --i) {
812 1386632 : size_t name_string_tag_tag_for_oldret = ret;
813 1386632 : ret = 0;
814 1386632 : e = der_put_general_string(p, len, &(&(data)->name_string)->val[i], &l);
815 1386632 : if (e) return e;
816 1386632 : p -= l; len -= l; ret += l;
817 :
818 1386632 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_GeneralString, &l);
819 1386632 : if (e) return e;
820 1386632 : p -= l; len -= l; ret += l;
821 :
822 1386632 : ret += name_string_tag_tag_for_oldret;
823 : }
824 905256 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
825 905256 : if (e) return e;
826 905256 : p -= l; len -= l; ret += l;
827 :
828 905256 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
829 905256 : if (e) return e;
830 905256 : p -= l; len -= l; ret += l;
831 :
832 905256 : ret += Top_tag_oldret;
833 : }
834 : /* name-type */
835 : {
836 905256 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
837 905256 : ret = 0;
838 905256 : e = encode_NAME_TYPE(p, len, &(data)->name_type, &l);
839 905256 : if (e) return e;
840 905256 : p -= l; len -= l; ret += l;
841 :
842 905256 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
843 905256 : if (e) return e;
844 905256 : p -= l; len -= l; ret += l;
845 :
846 905256 : ret += Top_tag_oldret;
847 : }
848 905256 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
849 905256 : if (e) return e;
850 905256 : p -= l; len -= l; ret += l;
851 :
852 905256 : *size = ret;
853 905256 : return 0;
854 : }
855 :
856 : int ASN1CALL
857 773741 : decode_PrincipalName(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, PrincipalName *data, size_t *size)
858 : {
859 773741 : size_t ret = 0;
860 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
861 : int e HEIMDAL_UNUSED_ATTRIBUTE;
862 :
863 773741 : memset(data, 0, sizeof(*data));
864 : {
865 : size_t Top_datalen, Top_oldlen;
866 : Der_type Top_type;
867 773741 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
868 773741 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
869 773741 : if(e) goto fail;
870 773741 : p += l; len -= l; ret += l;
871 773741 : Top_oldlen = len;
872 773741 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
873 773741 : len = Top_datalen;
874 : {
875 : size_t name_type_datalen, name_type_oldlen;
876 : Der_type name_type_type;
877 773741 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &name_type_type, 0, &name_type_datalen, &l);
878 773741 : if (e == 0 && name_type_type != CONS) { e = ASN1_BAD_ID; }
879 773741 : if(e) goto fail;
880 773741 : p += l; len -= l; ret += l;
881 773741 : name_type_oldlen = len;
882 773741 : if (name_type_datalen > len) { e = ASN1_OVERRUN; goto fail; }
883 773741 : len = name_type_datalen;
884 773741 : e = decode_NAME_TYPE(p, len, &(data)->name_type, &l);
885 773741 : if(e) goto fail;
886 773741 : p += l; len -= l; ret += l;
887 773741 : len = name_type_oldlen - name_type_datalen;
888 : }
889 : {
890 : size_t name_string_datalen, name_string_oldlen;
891 : Der_type name_string_type;
892 773741 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &name_string_type, 1, &name_string_datalen, &l);
893 1528417 : if (e == 0 && name_string_type != CONS) { e = ASN1_BAD_ID; }
894 773741 : if(e) goto fail;
895 773741 : p += l; len -= l; ret += l;
896 773741 : name_string_oldlen = len;
897 773741 : if (name_string_datalen > len) { e = ASN1_OVERRUN; goto fail; }
898 773741 : len = name_string_datalen;
899 : {
900 : size_t name_string_Tag_datalen, name_string_Tag_oldlen;
901 : Der_type name_string_Tag_type;
902 773741 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &name_string_Tag_type, UT_Sequence, &name_string_Tag_datalen, &l);
903 773741 : if (e == 0 && name_string_Tag_type != CONS) { e = ASN1_BAD_ID; }
904 773741 : if(e) goto fail;
905 773741 : p += l; len -= l; ret += l;
906 773741 : name_string_Tag_oldlen = len;
907 773741 : if (name_string_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
908 773741 : len = name_string_Tag_datalen;
909 : {
910 773741 : size_t name_string_Tag_Tag_origlen = len;
911 773741 : size_t name_string_Tag_Tag_oldret = ret;
912 773741 : size_t name_string_Tag_Tag_olen = 0;
913 : void *name_string_Tag_Tag_tmp;
914 773741 : ret = 0;
915 773741 : (&(data)->name_string)->len = 0;
916 773741 : (&(data)->name_string)->val = NULL;
917 2752064 : while(ret < name_string_Tag_Tag_origlen) {
918 1204582 : size_t name_string_Tag_Tag_nlen = name_string_Tag_Tag_olen + sizeof(*((&(data)->name_string)->val));
919 1204582 : if (name_string_Tag_Tag_olen > name_string_Tag_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
920 1204582 : name_string_Tag_Tag_olen = name_string_Tag_Tag_nlen;
921 1204582 : name_string_Tag_Tag_tmp = realloc((&(data)->name_string)->val, name_string_Tag_Tag_olen);
922 1204582 : if (name_string_Tag_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
923 1204582 : (&(data)->name_string)->val = name_string_Tag_Tag_tmp;
924 : {
925 : size_t name_string_Tag_Tag_s_of_datalen, name_string_Tag_Tag_s_of_oldlen;
926 : Der_type name_string_Tag_Tag_s_of_type;
927 1204582 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &name_string_Tag_Tag_s_of_type, UT_GeneralString, &name_string_Tag_Tag_s_of_datalen, &l);
928 1204582 : if (e == 0 && name_string_Tag_Tag_s_of_type != PRIM) { e = ASN1_BAD_ID; }
929 1204582 : if(e) goto fail;
930 1204582 : p += l; len -= l; ret += l;
931 1204582 : name_string_Tag_Tag_s_of_oldlen = len;
932 1204582 : if (name_string_Tag_Tag_s_of_datalen > len) { e = ASN1_OVERRUN; goto fail; }
933 1204582 : len = name_string_Tag_Tag_s_of_datalen;
934 1204582 : e = der_get_general_string(p, len, &(&(data)->name_string)->val[(&(data)->name_string)->len], &l);
935 1204582 : if(e) goto fail;
936 1204582 : p += l; len -= l; ret += l;
937 1204582 : len = name_string_Tag_Tag_s_of_oldlen - name_string_Tag_Tag_s_of_datalen;
938 : }
939 1204582 : (&(data)->name_string)->len++;
940 1204582 : len = name_string_Tag_Tag_origlen - ret;
941 : }
942 773741 : ret += name_string_Tag_Tag_oldret;
943 : }
944 773741 : len = name_string_Tag_oldlen - name_string_Tag_datalen;
945 : }
946 773741 : len = name_string_oldlen - name_string_datalen;
947 : }
948 773741 : len = Top_oldlen - Top_datalen;
949 : }
950 1547482 : if(size) *size = ret;
951 754676 : return 0;
952 0 : fail:
953 0 : free_PrincipalName(data);
954 0 : return e;
955 : }
956 :
957 : void ASN1CALL
958 5306644 : free_PrincipalName(PrincipalName *data)
959 : {
960 5306644 : free_NAME_TYPE(&(data)->name_type);
961 17785449 : while((&(data)->name_string)->len){
962 7172161 : der_free_general_string(&(&(data)->name_string)->val[(&(data)->name_string)->len-1]);
963 7172161 : (&(data)->name_string)->len--;
964 : }
965 5306644 : free((&(data)->name_string)->val);
966 5306644 : (&(data)->name_string)->val = NULL;
967 5306644 : }
968 :
969 : size_t ASN1CALL
970 905256 : length_PrincipalName(const PrincipalName *data)
971 : {
972 905256 : size_t ret = 0;
973 : {
974 905256 : size_t Top_tag_oldret = ret;
975 905256 : ret = 0;
976 905256 : ret += length_NAME_TYPE(&(data)->name_type);
977 905256 : ret += 1 + der_length_len (ret);
978 905256 : ret += Top_tag_oldret;
979 : }
980 : {
981 905256 : size_t Top_tag_oldret = ret;
982 905256 : ret = 0;
983 : {
984 905256 : size_t name_string_tag_tag_oldret = ret;
985 : int i;
986 905256 : ret = 0;
987 2291888 : for(i = (&(data)->name_string)->len - 1; i >= 0; --i){
988 1386632 : size_t name_string_tag_tag_for_oldret = ret;
989 1386632 : ret = 0;
990 1386632 : ret += der_length_general_string(&(&(data)->name_string)->val[i]);
991 1386632 : ret += 1 + der_length_len (ret);
992 1386632 : ret += name_string_tag_tag_for_oldret;
993 : }
994 905256 : ret += name_string_tag_tag_oldret;
995 : }
996 905256 : ret += 1 + der_length_len (ret);
997 905256 : ret += 1 + der_length_len (ret);
998 905256 : ret += Top_tag_oldret;
999 : }
1000 905256 : ret += 1 + der_length_len (ret);
1001 905256 : return ret;
1002 : }
1003 :
1004 : int ASN1CALL
1005 3344991 : copy_PrincipalName(const PrincipalName *from, PrincipalName *to)
1006 : {
1007 3344991 : memset(to, 0, sizeof(*to));
1008 3344991 : if(copy_NAME_TYPE(&(from)->name_type, &(to)->name_type)) goto fail;
1009 3344991 : if(((&(to)->name_string)->val = malloc((&(from)->name_string)->len * sizeof(*(&(to)->name_string)->val))) == NULL && (&(from)->name_string)->len != 0)
1010 0 : goto fail;
1011 8137027 : for((&(to)->name_string)->len = 0; (&(to)->name_string)->len < (&(from)->name_string)->len; (&(to)->name_string)->len++){
1012 4792036 : if(der_copy_general_string(&(&(from)->name_string)->val[(&(to)->name_string)->len], &(&(to)->name_string)->val[(&(to)->name_string)->len])) goto fail;
1013 : }
1014 3254811 : return 0;
1015 0 : fail:
1016 0 : free_PrincipalName(to);
1017 0 : return ENOMEM;
1018 : }
1019 :
1020 : int ASN1CALL
1021 104469 : encode_Principal(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const Principal *data, size_t *size)
1022 : {
1023 104469 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
1024 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1025 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
1026 :
1027 : /* realm */
1028 : {
1029 104469 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
1030 104469 : ret = 0;
1031 104469 : e = encode_Realm(p, len, &(data)->realm, &l);
1032 104469 : if (e) return e;
1033 104469 : p -= l; len -= l; ret += l;
1034 :
1035 104469 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
1036 104469 : if (e) return e;
1037 104469 : p -= l; len -= l; ret += l;
1038 :
1039 104469 : ret += Top_tag_oldret;
1040 : }
1041 : /* name */
1042 : {
1043 104469 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
1044 104469 : ret = 0;
1045 104469 : e = encode_PrincipalName(p, len, &(data)->name, &l);
1046 104469 : if (e) return e;
1047 104469 : p -= l; len -= l; ret += l;
1048 :
1049 104469 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
1050 104469 : if (e) return e;
1051 104469 : p -= l; len -= l; ret += l;
1052 :
1053 104469 : ret += Top_tag_oldret;
1054 : }
1055 104469 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
1056 104469 : if (e) return e;
1057 104469 : p -= l; len -= l; ret += l;
1058 :
1059 104469 : *size = ret;
1060 104469 : return 0;
1061 : }
1062 :
1063 : int ASN1CALL
1064 0 : decode_Principal(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, Principal *data, size_t *size)
1065 : {
1066 0 : size_t ret = 0;
1067 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1068 : int e HEIMDAL_UNUSED_ATTRIBUTE;
1069 :
1070 0 : memset(data, 0, sizeof(*data));
1071 : {
1072 : size_t Top_datalen, Top_oldlen;
1073 : Der_type Top_type;
1074 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
1075 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
1076 0 : if(e) goto fail;
1077 0 : p += l; len -= l; ret += l;
1078 0 : Top_oldlen = len;
1079 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1080 0 : len = Top_datalen;
1081 : {
1082 : size_t name_datalen, name_oldlen;
1083 : Der_type name_type;
1084 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &name_type, 0, &name_datalen, &l);
1085 0 : if (e == 0 && name_type != CONS) { e = ASN1_BAD_ID; }
1086 0 : if(e) goto fail;
1087 0 : p += l; len -= l; ret += l;
1088 0 : name_oldlen = len;
1089 0 : if (name_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1090 0 : len = name_datalen;
1091 0 : e = decode_PrincipalName(p, len, &(data)->name, &l);
1092 0 : if(e) goto fail;
1093 0 : p += l; len -= l; ret += l;
1094 0 : len = name_oldlen - name_datalen;
1095 : }
1096 : {
1097 : size_t realm_datalen, realm_oldlen;
1098 : Der_type realm_type;
1099 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &realm_type, 1, &realm_datalen, &l);
1100 0 : if (e == 0 && realm_type != CONS) { e = ASN1_BAD_ID; }
1101 0 : if(e) goto fail;
1102 0 : p += l; len -= l; ret += l;
1103 0 : realm_oldlen = len;
1104 0 : if (realm_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1105 0 : len = realm_datalen;
1106 0 : e = decode_Realm(p, len, &(data)->realm, &l);
1107 0 : if(e) goto fail;
1108 0 : p += l; len -= l; ret += l;
1109 0 : len = realm_oldlen - realm_datalen;
1110 : }
1111 0 : len = Top_oldlen - Top_datalen;
1112 : }
1113 0 : if(size) *size = ret;
1114 0 : return 0;
1115 0 : fail:
1116 0 : free_Principal(data);
1117 0 : return e;
1118 : }
1119 :
1120 : void ASN1CALL
1121 3535288 : free_Principal(Principal *data)
1122 : {
1123 3535288 : free_PrincipalName(&(data)->name);
1124 3535288 : free_Realm(&(data)->realm);
1125 3535288 : }
1126 :
1127 : size_t ASN1CALL
1128 104469 : length_Principal(const Principal *data)
1129 : {
1130 104469 : size_t ret = 0;
1131 : {
1132 104469 : size_t Top_tag_oldret = ret;
1133 104469 : ret = 0;
1134 104469 : ret += length_PrincipalName(&(data)->name);
1135 104469 : ret += 1 + der_length_len (ret);
1136 104469 : ret += Top_tag_oldret;
1137 : }
1138 : {
1139 104469 : size_t Top_tag_oldret = ret;
1140 104469 : ret = 0;
1141 104469 : ret += length_Realm(&(data)->realm);
1142 104469 : ret += 1 + der_length_len (ret);
1143 104469 : ret += Top_tag_oldret;
1144 : }
1145 104469 : ret += 1 + der_length_len (ret);
1146 104469 : return ret;
1147 : }
1148 :
1149 : int ASN1CALL
1150 2137672 : copy_Principal(const Principal *from, Principal *to)
1151 : {
1152 2137672 : memset(to, 0, sizeof(*to));
1153 2137672 : if(copy_PrincipalName(&(from)->name, &(to)->name)) goto fail;
1154 2137672 : if(copy_Realm(&(from)->realm, &(to)->realm)) goto fail;
1155 2080163 : return 0;
1156 0 : fail:
1157 0 : free_Principal(to);
1158 0 : return ENOMEM;
1159 : }
1160 :
1161 : int ASN1CALL
1162 0 : encode_Principals(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const Principals *data, size_t *size)
1163 : {
1164 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
1165 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1166 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
1167 :
1168 0 : for(i = (int)(data)->len - 1; i >= 0; --i) {
1169 0 : size_t Top_tag_for_oldret = ret;
1170 0 : ret = 0;
1171 0 : e = encode_Principal(p, len, &(data)->val[i], &l);
1172 0 : if (e) return e;
1173 0 : p -= l; len -= l; ret += l;
1174 :
1175 0 : ret += Top_tag_for_oldret;
1176 : }
1177 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
1178 0 : if (e) return e;
1179 0 : p -= l; len -= l; ret += l;
1180 :
1181 0 : *size = ret;
1182 0 : return 0;
1183 : }
1184 :
1185 : int ASN1CALL
1186 0 : decode_Principals(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, Principals *data, size_t *size)
1187 : {
1188 0 : size_t ret = 0;
1189 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1190 : int e HEIMDAL_UNUSED_ATTRIBUTE;
1191 :
1192 0 : memset(data, 0, sizeof(*data));
1193 : {
1194 : size_t Top_datalen, Top_oldlen;
1195 : Der_type Top_type;
1196 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
1197 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
1198 0 : if(e) goto fail;
1199 0 : p += l; len -= l; ret += l;
1200 0 : Top_oldlen = len;
1201 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1202 0 : len = Top_datalen;
1203 : {
1204 0 : size_t Top_Tag_origlen = len;
1205 0 : size_t Top_Tag_oldret = ret;
1206 0 : size_t Top_Tag_olen = 0;
1207 : void *Top_Tag_tmp;
1208 0 : ret = 0;
1209 0 : (data)->len = 0;
1210 0 : (data)->val = NULL;
1211 0 : while(ret < Top_Tag_origlen) {
1212 0 : size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
1213 0 : if (Top_Tag_olen > Top_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
1214 0 : Top_Tag_olen = Top_Tag_nlen;
1215 0 : Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
1216 0 : if (Top_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
1217 0 : (data)->val = Top_Tag_tmp;
1218 0 : e = decode_Principal(p, len, &(data)->val[(data)->len], &l);
1219 0 : if(e) goto fail;
1220 0 : p += l; len -= l; ret += l;
1221 0 : (data)->len++;
1222 0 : len = Top_Tag_origlen - ret;
1223 : }
1224 0 : ret += Top_Tag_oldret;
1225 : }
1226 0 : len = Top_oldlen - Top_datalen;
1227 : }
1228 0 : if(size) *size = ret;
1229 0 : return 0;
1230 0 : fail:
1231 0 : free_Principals(data);
1232 0 : return e;
1233 : }
1234 :
1235 : void ASN1CALL
1236 0 : free_Principals(Principals *data)
1237 : {
1238 0 : while((data)->len){
1239 0 : free_Principal(&(data)->val[(data)->len-1]);
1240 0 : (data)->len--;
1241 : }
1242 0 : free((data)->val);
1243 0 : (data)->val = NULL;
1244 0 : }
1245 :
1246 : size_t ASN1CALL
1247 0 : length_Principals(const Principals *data)
1248 : {
1249 0 : size_t ret = 0;
1250 : {
1251 0 : size_t Top_tag_oldret = ret;
1252 : int i;
1253 0 : ret = 0;
1254 0 : for(i = (data)->len - 1; i >= 0; --i){
1255 0 : size_t Top_tag_for_oldret = ret;
1256 0 : ret = 0;
1257 0 : ret += length_Principal(&(data)->val[i]);
1258 0 : ret += Top_tag_for_oldret;
1259 : }
1260 0 : ret += Top_tag_oldret;
1261 : }
1262 0 : ret += 1 + der_length_len (ret);
1263 0 : return ret;
1264 : }
1265 :
1266 : int ASN1CALL
1267 0 : copy_Principals(const Principals *from, Principals *to)
1268 : {
1269 0 : memset(to, 0, sizeof(*to));
1270 0 : if(((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
1271 0 : goto fail;
1272 0 : for((to)->len = 0; (to)->len < (from)->len; (to)->len++){
1273 0 : if(copy_Principal(&(from)->val[(to)->len], &(to)->val[(to)->len])) goto fail;
1274 : }
1275 0 : return 0;
1276 0 : fail:
1277 0 : free_Principals(to);
1278 0 : return ENOMEM;
1279 : }
1280 :
1281 : int ASN1CALL
1282 0 : add_Principals(Principals *data, const Principal *element)
1283 : {
1284 : int ret;
1285 : void *ptr;
1286 :
1287 0 : ptr = realloc(data->val,
1288 0 : (data->len + 1) * sizeof(data->val[0]));
1289 0 : if (ptr == NULL) return ENOMEM;
1290 0 : data->val = ptr;
1291 :
1292 0 : ret = copy_Principal(element, &data->val[data->len]);
1293 0 : if (ret) return ret;
1294 0 : data->len++;
1295 0 : return 0;
1296 : }
1297 :
1298 : int ASN1CALL
1299 0 : remove_Principals(Principals *data, unsigned int element)
1300 : {
1301 : void *ptr;
1302 :
1303 0 : if (data->len == 0 || element >= data->len)
1304 0 : return ASN1_OVERRUN;
1305 0 : free_Principal(&data->val[element]);
1306 0 : data->len--;
1307 0 : if (element < data->len)
1308 0 : memmove(&data->val[element], &data->val[element + 1],
1309 0 : sizeof(data->val[0]) * data->len);
1310 0 : ptr = realloc(data->val, data->len * sizeof(data->val[0]));
1311 0 : if (ptr != NULL || data->len == 0) data->val = ptr;
1312 0 : return 0;
1313 : }
1314 :
1315 : int ASN1CALL
1316 482 : encode_HostAddress(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const HostAddress *data, size_t *size)
1317 : {
1318 482 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
1319 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1320 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
1321 :
1322 : /* address */
1323 : {
1324 482 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
1325 482 : ret = 0;
1326 482 : e = der_put_octet_string(p, len, &(data)->address, &l);
1327 482 : if (e) return e;
1328 482 : p -= l; len -= l; ret += l;
1329 :
1330 482 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
1331 482 : if (e) return e;
1332 482 : p -= l; len -= l; ret += l;
1333 :
1334 482 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
1335 482 : if (e) return e;
1336 482 : p -= l; len -= l; ret += l;
1337 :
1338 482 : ret += Top_tag_oldret;
1339 : }
1340 : /* addr-type */
1341 : {
1342 482 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
1343 482 : ret = 0;
1344 482 : e = encode_krb5int32(p, len, &(data)->addr_type, &l);
1345 482 : if (e) return e;
1346 482 : p -= l; len -= l; ret += l;
1347 :
1348 482 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
1349 482 : if (e) return e;
1350 482 : p -= l; len -= l; ret += l;
1351 :
1352 482 : ret += Top_tag_oldret;
1353 : }
1354 482 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
1355 482 : if (e) return e;
1356 482 : p -= l; len -= l; ret += l;
1357 :
1358 482 : *size = ret;
1359 482 : return 0;
1360 : }
1361 :
1362 : int ASN1CALL
1363 506 : decode_HostAddress(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, HostAddress *data, size_t *size)
1364 : {
1365 506 : size_t ret = 0;
1366 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1367 : int e HEIMDAL_UNUSED_ATTRIBUTE;
1368 :
1369 506 : memset(data, 0, sizeof(*data));
1370 : {
1371 : size_t Top_datalen, Top_oldlen;
1372 : Der_type Top_type;
1373 506 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
1374 506 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
1375 506 : if(e) goto fail;
1376 506 : p += l; len -= l; ret += l;
1377 506 : Top_oldlen = len;
1378 506 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1379 506 : len = Top_datalen;
1380 : {
1381 : size_t addr_type_datalen, addr_type_oldlen;
1382 : Der_type addr_type_type;
1383 506 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &addr_type_type, 0, &addr_type_datalen, &l);
1384 506 : if (e == 0 && addr_type_type != CONS) { e = ASN1_BAD_ID; }
1385 506 : if(e) goto fail;
1386 506 : p += l; len -= l; ret += l;
1387 506 : addr_type_oldlen = len;
1388 506 : if (addr_type_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1389 506 : len = addr_type_datalen;
1390 506 : e = decode_krb5int32(p, len, &(data)->addr_type, &l);
1391 506 : if(e) goto fail;
1392 506 : p += l; len -= l; ret += l;
1393 506 : len = addr_type_oldlen - addr_type_datalen;
1394 : }
1395 : {
1396 : size_t address_datalen, address_oldlen;
1397 : Der_type address_type;
1398 506 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &address_type, 1, &address_datalen, &l);
1399 1012 : if (e == 0 && address_type != CONS) { e = ASN1_BAD_ID; }
1400 506 : if(e) goto fail;
1401 506 : p += l; len -= l; ret += l;
1402 506 : address_oldlen = len;
1403 506 : if (address_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1404 506 : len = address_datalen;
1405 : {
1406 : size_t address_Tag_datalen, address_Tag_oldlen;
1407 : Der_type address_Tag_type;
1408 506 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &address_Tag_type, UT_OctetString, &address_Tag_datalen, &l);
1409 506 : if (e == 0 && address_Tag_type != PRIM) { e = ASN1_BAD_ID; }
1410 506 : if(e) goto fail;
1411 506 : p += l; len -= l; ret += l;
1412 506 : address_Tag_oldlen = len;
1413 506 : if (address_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1414 506 : len = address_Tag_datalen;
1415 506 : e = der_get_octet_string(p, len, &(data)->address, &l);
1416 506 : if(e) goto fail;
1417 506 : p += l; len -= l; ret += l;
1418 506 : len = address_Tag_oldlen - address_Tag_datalen;
1419 : }
1420 506 : len = address_oldlen - address_datalen;
1421 : }
1422 506 : len = Top_oldlen - Top_datalen;
1423 : }
1424 1012 : if(size) *size = ret;
1425 506 : return 0;
1426 0 : fail:
1427 0 : free_HostAddress(data);
1428 0 : return e;
1429 : }
1430 :
1431 : void ASN1CALL
1432 782 : free_HostAddress(HostAddress *data)
1433 : {
1434 782 : free_krb5int32(&(data)->addr_type);
1435 782 : der_free_octet_string(&(data)->address);
1436 782 : }
1437 :
1438 : size_t ASN1CALL
1439 482 : length_HostAddress(const HostAddress *data)
1440 : {
1441 482 : size_t ret = 0;
1442 : {
1443 482 : size_t Top_tag_oldret = ret;
1444 482 : ret = 0;
1445 482 : ret += length_krb5int32(&(data)->addr_type);
1446 482 : ret += 1 + der_length_len (ret);
1447 482 : ret += Top_tag_oldret;
1448 : }
1449 : {
1450 482 : size_t Top_tag_oldret = ret;
1451 482 : ret = 0;
1452 482 : ret += der_length_octet_string(&(data)->address);
1453 482 : ret += 1 + der_length_len (ret);
1454 482 : ret += 1 + der_length_len (ret);
1455 482 : ret += Top_tag_oldret;
1456 : }
1457 482 : ret += 1 + der_length_len (ret);
1458 482 : return ret;
1459 : }
1460 :
1461 : int ASN1CALL
1462 282 : copy_HostAddress(const HostAddress *from, HostAddress *to)
1463 : {
1464 282 : memset(to, 0, sizeof(*to));
1465 282 : if(copy_krb5int32(&(from)->addr_type, &(to)->addr_type)) goto fail;
1466 282 : if(der_copy_octet_string(&(from)->address, &(to)->address)) goto fail;
1467 282 : return 0;
1468 0 : fail:
1469 0 : free_HostAddress(to);
1470 0 : return ENOMEM;
1471 : }
1472 :
1473 : int ASN1CALL
1474 19525 : encode_HostAddresses(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const HostAddresses *data, size_t *size)
1475 : {
1476 19525 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
1477 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1478 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
1479 :
1480 19939 : for(i = (int)(data)->len - 1; i >= 0; --i) {
1481 414 : size_t Top_tag_for_oldret = ret;
1482 414 : ret = 0;
1483 414 : e = encode_HostAddress(p, len, &(data)->val[i], &l);
1484 414 : if (e) return e;
1485 414 : p -= l; len -= l; ret += l;
1486 :
1487 414 : ret += Top_tag_for_oldret;
1488 : }
1489 19525 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
1490 19525 : if (e) return e;
1491 19525 : p -= l; len -= l; ret += l;
1492 :
1493 19525 : *size = ret;
1494 19525 : return 0;
1495 : }
1496 :
1497 : int ASN1CALL
1498 19389 : decode_HostAddresses(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, HostAddresses *data, size_t *size)
1499 : {
1500 19389 : size_t ret = 0;
1501 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1502 : int e HEIMDAL_UNUSED_ATTRIBUTE;
1503 :
1504 19389 : memset(data, 0, sizeof(*data));
1505 : {
1506 : size_t Top_datalen, Top_oldlen;
1507 : Der_type Top_type;
1508 19389 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
1509 19389 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
1510 19389 : if(e) goto fail;
1511 19389 : p += l; len -= l; ret += l;
1512 19389 : Top_oldlen = len;
1513 19389 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1514 19389 : len = Top_datalen;
1515 : {
1516 19389 : size_t Top_Tag_origlen = len;
1517 19389 : size_t Top_Tag_oldret = ret;
1518 19389 : size_t Top_Tag_olen = 0;
1519 : void *Top_Tag_tmp;
1520 19389 : ret = 0;
1521 19389 : (data)->len = 0;
1522 19389 : (data)->val = NULL;
1523 39216 : while(ret < Top_Tag_origlen) {
1524 438 : size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
1525 438 : if (Top_Tag_olen > Top_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
1526 438 : Top_Tag_olen = Top_Tag_nlen;
1527 438 : Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
1528 438 : if (Top_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
1529 438 : (data)->val = Top_Tag_tmp;
1530 438 : e = decode_HostAddress(p, len, &(data)->val[(data)->len], &l);
1531 438 : if(e) goto fail;
1532 438 : p += l; len -= l; ret += l;
1533 438 : (data)->len++;
1534 438 : len = Top_Tag_origlen - ret;
1535 : }
1536 19389 : ret += Top_Tag_oldret;
1537 : }
1538 19389 : len = Top_oldlen - Top_datalen;
1539 : }
1540 38778 : if(size) *size = ret;
1541 18651 : return 0;
1542 0 : fail:
1543 0 : free_HostAddresses(data);
1544 0 : return e;
1545 : }
1546 :
1547 : void ASN1CALL
1548 38778 : free_HostAddresses(HostAddresses *data)
1549 : {
1550 78202 : while((data)->len){
1551 646 : free_HostAddress(&(data)->val[(data)->len-1]);
1552 646 : (data)->len--;
1553 : }
1554 38778 : free((data)->val);
1555 38778 : (data)->val = NULL;
1556 38778 : }
1557 :
1558 : size_t ASN1CALL
1559 19525 : length_HostAddresses(const HostAddresses *data)
1560 : {
1561 19525 : size_t ret = 0;
1562 : {
1563 19525 : size_t Top_tag_oldret = ret;
1564 : int i;
1565 19525 : ret = 0;
1566 19939 : for(i = (data)->len - 1; i >= 0; --i){
1567 414 : size_t Top_tag_for_oldret = ret;
1568 414 : ret = 0;
1569 414 : ret += length_HostAddress(&(data)->val[i]);
1570 414 : ret += Top_tag_for_oldret;
1571 : }
1572 19525 : ret += Top_tag_oldret;
1573 : }
1574 19525 : ret += 1 + der_length_len (ret);
1575 19525 : return ret;
1576 : }
1577 :
1578 : int ASN1CALL
1579 19386 : copy_HostAddresses(const HostAddresses *from, HostAddresses *to)
1580 : {
1581 19386 : memset(to, 0, sizeof(*to));
1582 19386 : if(((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
1583 0 : goto fail;
1584 19591 : for((to)->len = 0; (to)->len < (from)->len; (to)->len++){
1585 205 : if(copy_HostAddress(&(from)->val[(to)->len], &(to)->val[(to)->len])) goto fail;
1586 : }
1587 18636 : return 0;
1588 0 : fail:
1589 0 : free_HostAddresses(to);
1590 0 : return ENOMEM;
1591 : }
1592 :
1593 : int ASN1CALL
1594 935551 : encode_KerberosTime(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const KerberosTime *data, size_t *size)
1595 : {
1596 935551 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
1597 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1598 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
1599 :
1600 935551 : e = der_put_generalized_time(p, len, data, &l);
1601 935551 : if (e) return e;
1602 935551 : p -= l; len -= l; ret += l;
1603 :
1604 935551 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_GeneralizedTime, &l);
1605 935551 : if (e) return e;
1606 935551 : p -= l; len -= l; ret += l;
1607 :
1608 935551 : *size = ret;
1609 935551 : return 0;
1610 : }
1611 :
1612 : int ASN1CALL
1613 728595 : decode_KerberosTime(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, KerberosTime *data, size_t *size)
1614 : {
1615 728595 : size_t ret = 0;
1616 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1617 : int e HEIMDAL_UNUSED_ATTRIBUTE;
1618 :
1619 728595 : memset(data, 0, sizeof(*data));
1620 : {
1621 : size_t Top_datalen, Top_oldlen;
1622 : Der_type Top_type;
1623 728595 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_GeneralizedTime, &Top_datalen, &l);
1624 728595 : if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
1625 728595 : if(e) goto fail;
1626 728595 : p += l; len -= l; ret += l;
1627 728595 : Top_oldlen = len;
1628 728595 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1629 728595 : len = Top_datalen;
1630 728595 : e = der_get_generalized_time(p, len, data, &l);
1631 728595 : if(e) goto fail;
1632 728595 : p += l; len -= l; ret += l;
1633 728595 : len = Top_oldlen - Top_datalen;
1634 : }
1635 1457190 : if(size) *size = ret;
1636 708949 : return 0;
1637 0 : fail:
1638 0 : free_KerberosTime(data);
1639 0 : return e;
1640 : }
1641 :
1642 : void ASN1CALL
1643 2090317 : free_KerberosTime(KerberosTime *data)
1644 : {
1645 2090317 : }
1646 :
1647 : size_t ASN1CALL
1648 935551 : length_KerberosTime(const KerberosTime *data)
1649 : {
1650 935551 : size_t ret = 0;
1651 935551 : ret += der_length_generalized_time(data);
1652 935551 : ret += 1 + der_length_len (ret);
1653 935551 : return ret;
1654 : }
1655 :
1656 : int ASN1CALL
1657 216347 : copy_KerberosTime(const KerberosTime *from, KerberosTime *to)
1658 : {
1659 216347 : memset(to, 0, sizeof(*to));
1660 216347 : *(to) = *(from);
1661 216347 : return 0;
1662 : }
1663 :
1664 : int ASN1CALL
1665 302482 : encode_AuthorizationDataElement(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const AuthorizationDataElement *data, size_t *size)
1666 : {
1667 302482 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
1668 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1669 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
1670 :
1671 : /* ad-data */
1672 : {
1673 302482 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
1674 302482 : ret = 0;
1675 302482 : e = der_put_octet_string(p, len, &(data)->ad_data, &l);
1676 302482 : if (e) return e;
1677 302482 : p -= l; len -= l; ret += l;
1678 :
1679 302482 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
1680 302482 : if (e) return e;
1681 302482 : p -= l; len -= l; ret += l;
1682 :
1683 302482 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
1684 302482 : if (e) return e;
1685 302482 : p -= l; len -= l; ret += l;
1686 :
1687 302482 : ret += Top_tag_oldret;
1688 : }
1689 : /* ad-type */
1690 : {
1691 302482 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
1692 302482 : ret = 0;
1693 302482 : e = encode_krb5int32(p, len, &(data)->ad_type, &l);
1694 302482 : if (e) return e;
1695 302482 : p -= l; len -= l; ret += l;
1696 :
1697 302482 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
1698 302482 : if (e) return e;
1699 302482 : p -= l; len -= l; ret += l;
1700 :
1701 302482 : ret += Top_tag_oldret;
1702 : }
1703 302482 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
1704 302482 : if (e) return e;
1705 302482 : p -= l; len -= l; ret += l;
1706 :
1707 302482 : *size = ret;
1708 302482 : return 0;
1709 : }
1710 :
1711 : int ASN1CALL
1712 329378 : decode_AuthorizationDataElement(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, AuthorizationDataElement *data, size_t *size)
1713 : {
1714 329378 : size_t ret = 0;
1715 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1716 : int e HEIMDAL_UNUSED_ATTRIBUTE;
1717 :
1718 329378 : memset(data, 0, sizeof(*data));
1719 : {
1720 : size_t Top_datalen, Top_oldlen;
1721 : Der_type Top_type;
1722 329378 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
1723 329378 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
1724 329378 : if(e) goto fail;
1725 329378 : p += l; len -= l; ret += l;
1726 329378 : Top_oldlen = len;
1727 329378 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1728 329378 : len = Top_datalen;
1729 : {
1730 : size_t ad_type_datalen, ad_type_oldlen;
1731 : Der_type ad_type_type;
1732 329378 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &ad_type_type, 0, &ad_type_datalen, &l);
1733 329378 : if (e == 0 && ad_type_type != CONS) { e = ASN1_BAD_ID; }
1734 329378 : if(e) goto fail;
1735 329378 : p += l; len -= l; ret += l;
1736 329378 : ad_type_oldlen = len;
1737 329378 : if (ad_type_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1738 329378 : len = ad_type_datalen;
1739 329378 : e = decode_krb5int32(p, len, &(data)->ad_type, &l);
1740 329378 : if(e) goto fail;
1741 329378 : p += l; len -= l; ret += l;
1742 329378 : len = ad_type_oldlen - ad_type_datalen;
1743 : }
1744 : {
1745 : size_t ad_data_datalen, ad_data_oldlen;
1746 : Der_type ad_data_type;
1747 329378 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &ad_data_type, 1, &ad_data_datalen, &l);
1748 648496 : if (e == 0 && ad_data_type != CONS) { e = ASN1_BAD_ID; }
1749 329378 : if(e) goto fail;
1750 329378 : p += l; len -= l; ret += l;
1751 329378 : ad_data_oldlen = len;
1752 329378 : if (ad_data_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1753 329378 : len = ad_data_datalen;
1754 : {
1755 : size_t ad_data_Tag_datalen, ad_data_Tag_oldlen;
1756 : Der_type ad_data_Tag_type;
1757 329378 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &ad_data_Tag_type, UT_OctetString, &ad_data_Tag_datalen, &l);
1758 329378 : if (e == 0 && ad_data_Tag_type != PRIM) { e = ASN1_BAD_ID; }
1759 329378 : if(e) goto fail;
1760 329378 : p += l; len -= l; ret += l;
1761 329378 : ad_data_Tag_oldlen = len;
1762 329378 : if (ad_data_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1763 329378 : len = ad_data_Tag_datalen;
1764 329378 : e = der_get_octet_string(p, len, &(data)->ad_data, &l);
1765 329378 : if(e) goto fail;
1766 329378 : p += l; len -= l; ret += l;
1767 329378 : len = ad_data_Tag_oldlen - ad_data_Tag_datalen;
1768 : }
1769 329378 : len = ad_data_oldlen - ad_data_datalen;
1770 : }
1771 329378 : len = Top_oldlen - Top_datalen;
1772 : }
1773 658756 : if(size) *size = ret;
1774 319118 : return 0;
1775 0 : fail:
1776 0 : free_AuthorizationDataElement(data);
1777 0 : return e;
1778 : }
1779 :
1780 : void ASN1CALL
1781 694709 : free_AuthorizationDataElement(AuthorizationDataElement *data)
1782 : {
1783 694709 : free_krb5int32(&(data)->ad_type);
1784 694709 : der_free_octet_string(&(data)->ad_data);
1785 694709 : }
1786 :
1787 : size_t ASN1CALL
1788 302482 : length_AuthorizationDataElement(const AuthorizationDataElement *data)
1789 : {
1790 302482 : size_t ret = 0;
1791 : {
1792 302482 : size_t Top_tag_oldret = ret;
1793 302482 : ret = 0;
1794 302482 : ret += length_krb5int32(&(data)->ad_type);
1795 302482 : ret += 1 + der_length_len (ret);
1796 302482 : ret += Top_tag_oldret;
1797 : }
1798 : {
1799 302482 : size_t Top_tag_oldret = ret;
1800 302482 : ret = 0;
1801 302482 : ret += der_length_octet_string(&(data)->ad_data);
1802 302482 : ret += 1 + der_length_len (ret);
1803 302482 : ret += 1 + der_length_len (ret);
1804 302482 : ret += Top_tag_oldret;
1805 : }
1806 302482 : ret += 1 + der_length_len (ret);
1807 302482 : return ret;
1808 : }
1809 :
1810 : int ASN1CALL
1811 324628 : copy_AuthorizationDataElement(const AuthorizationDataElement *from, AuthorizationDataElement *to)
1812 : {
1813 324628 : memset(to, 0, sizeof(*to));
1814 324628 : if(copy_krb5int32(&(from)->ad_type, &(to)->ad_type)) goto fail;
1815 324628 : if(der_copy_octet_string(&(from)->ad_data, &(to)->ad_data)) goto fail;
1816 315698 : return 0;
1817 0 : fail:
1818 0 : free_AuthorizationDataElement(to);
1819 0 : return ENOMEM;
1820 : }
1821 :
1822 : int ASN1CALL
1823 237586 : encode_AuthorizationData(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const AuthorizationData *data, size_t *size)
1824 : {
1825 237586 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
1826 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1827 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
1828 :
1829 540068 : for(i = (int)(data)->len - 1; i >= 0; --i) {
1830 302482 : size_t Top_tag_for_oldret = ret;
1831 302482 : ret = 0;
1832 302482 : e = encode_AuthorizationDataElement(p, len, &(data)->val[i], &l);
1833 302482 : if (e) return e;
1834 302482 : p -= l; len -= l; ret += l;
1835 :
1836 302482 : ret += Top_tag_for_oldret;
1837 : }
1838 237586 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
1839 237586 : if (e) return e;
1840 237586 : p -= l; len -= l; ret += l;
1841 :
1842 237586 : *size = ret;
1843 237586 : return 0;
1844 : }
1845 :
1846 : int ASN1CALL
1847 267516 : decode_AuthorizationData(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, AuthorizationData *data, size_t *size)
1848 : {
1849 267516 : size_t ret = 0;
1850 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1851 : int e HEIMDAL_UNUSED_ATTRIBUTE;
1852 :
1853 267516 : memset(data, 0, sizeof(*data));
1854 : {
1855 : size_t Top_datalen, Top_oldlen;
1856 : Der_type Top_type;
1857 267516 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
1858 267516 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
1859 267516 : if(e) goto fail;
1860 267516 : p += l; len -= l; ret += l;
1861 267516 : Top_oldlen = len;
1862 267516 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1863 267516 : len = Top_datalen;
1864 : {
1865 267516 : size_t Top_Tag_origlen = len;
1866 267516 : size_t Top_Tag_oldret = ret;
1867 267516 : size_t Top_Tag_olen = 0;
1868 : void *Top_Tag_tmp;
1869 267516 : ret = 0;
1870 267516 : (data)->len = 0;
1871 267516 : (data)->val = NULL;
1872 864410 : while(ret < Top_Tag_origlen) {
1873 329378 : size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
1874 329378 : if (Top_Tag_olen > Top_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
1875 329378 : Top_Tag_olen = Top_Tag_nlen;
1876 329378 : Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
1877 329378 : if (Top_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
1878 329378 : (data)->val = Top_Tag_tmp;
1879 329378 : e = decode_AuthorizationDataElement(p, len, &(data)->val[(data)->len], &l);
1880 329378 : if(e) goto fail;
1881 329378 : p += l; len -= l; ret += l;
1882 329378 : (data)->len++;
1883 329378 : len = Top_Tag_origlen - ret;
1884 : }
1885 267516 : ret += Top_Tag_oldret;
1886 : }
1887 267516 : len = Top_oldlen - Top_datalen;
1888 : }
1889 369356 : if(size) *size = ret;
1890 259083 : return 0;
1891 0 : fail:
1892 0 : free_AuthorizationData(data);
1893 0 : return e;
1894 : }
1895 :
1896 : void ASN1CALL
1897 1272923 : free_AuthorizationData(AuthorizationData *data)
1898 : {
1899 3240555 : while((data)->len){
1900 694709 : free_AuthorizationDataElement(&(data)->val[(data)->len-1]);
1901 694709 : (data)->len--;
1902 : }
1903 1272923 : free((data)->val);
1904 1272923 : (data)->val = NULL;
1905 1272923 : }
1906 :
1907 : size_t ASN1CALL
1908 237586 : length_AuthorizationData(const AuthorizationData *data)
1909 : {
1910 237586 : size_t ret = 0;
1911 : {
1912 237586 : size_t Top_tag_oldret = ret;
1913 : int i;
1914 237586 : ret = 0;
1915 540068 : for(i = (data)->len - 1; i >= 0; --i){
1916 302482 : size_t Top_tag_for_oldret = ret;
1917 302482 : ret = 0;
1918 302482 : ret += length_AuthorizationDataElement(&(data)->val[i]);
1919 302482 : ret += Top_tag_for_oldret;
1920 : }
1921 237586 : ret += Top_tag_oldret;
1922 : }
1923 237586 : ret += 1 + der_length_len (ret);
1924 237586 : return ret;
1925 : }
1926 :
1927 : int ASN1CALL
1928 595678 : copy_AuthorizationData(const AuthorizationData *from, AuthorizationData *to)
1929 : {
1930 595678 : memset(to, 0, sizeof(*to));
1931 595678 : if(((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
1932 0 : goto fail;
1933 658482 : for((to)->len = 0; (to)->len < (from)->len; (to)->len++){
1934 62804 : if(copy_AuthorizationDataElement(&(from)->val[(to)->len], &(to)->val[(to)->len])) goto fail;
1935 : }
1936 580523 : return 0;
1937 0 : fail:
1938 0 : free_AuthorizationData(to);
1939 0 : return ENOMEM;
1940 : }
1941 :
1942 : int ASN1CALL
1943 261824 : add_AuthorizationData(AuthorizationData *data, const AuthorizationDataElement *element)
1944 : {
1945 : int ret;
1946 : void *ptr;
1947 :
1948 261824 : ptr = realloc(data->val,
1949 261824 : (data->len + 1) * sizeof(data->val[0]));
1950 261824 : if (ptr == NULL) return ENOMEM;
1951 261824 : data->val = ptr;
1952 :
1953 261824 : ret = copy_AuthorizationDataElement(element, &data->val[data->len]);
1954 261824 : if (ret) return ret;
1955 261824 : data->len++;
1956 261824 : return 0;
1957 : }
1958 :
1959 : int ASN1CALL
1960 0 : remove_AuthorizationData(AuthorizationData *data, unsigned int element)
1961 : {
1962 : void *ptr;
1963 :
1964 0 : if (data->len == 0 || element >= data->len)
1965 0 : return ASN1_OVERRUN;
1966 0 : free_AuthorizationDataElement(&data->val[element]);
1967 0 : data->len--;
1968 0 : if (element < data->len)
1969 0 : memmove(&data->val[element], &data->val[element + 1],
1970 0 : sizeof(data->val[0]) * data->len);
1971 0 : ptr = realloc(data->val, data->len * sizeof(data->val[0]));
1972 0 : if (ptr != NULL || data->len == 0) data->val = ptr;
1973 0 : return 0;
1974 : }
1975 :
1976 : int ASN1CALL
1977 68110 : encode_APOptions(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const APOptions *data, size_t *size)
1978 : {
1979 68110 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
1980 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1981 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
1982 :
1983 : {
1984 68110 : unsigned char c = 0;
1985 68110 : if (len < 1) return ASN1_OVERFLOW;
1986 68110 : *p-- = c; len--; ret++;
1987 68110 : c = 0;
1988 68110 : if (len < 1) return ASN1_OVERFLOW;
1989 68110 : *p-- = c; len--; ret++;
1990 68110 : c = 0;
1991 68110 : if (len < 1) return ASN1_OVERFLOW;
1992 68110 : *p-- = c; len--; ret++;
1993 68110 : c = 0;
1994 68110 : if((data)->mutual_required) {
1995 20366 : c |= 1<<5;
1996 : }
1997 68110 : if((data)->use_session_key) {
1998 0 : c |= 1<<6;
1999 : }
2000 68110 : if((data)->reserved) {
2001 0 : c |= 1<<7;
2002 : }
2003 68110 : if (len < 1) return ASN1_OVERFLOW;
2004 68110 : *p-- = c; len--; ret++;
2005 68110 : if (len < 1) return ASN1_OVERFLOW;
2006 68110 : *p-- = 0;
2007 68110 : len -= 1;
2008 68110 : ret += 1;
2009 : }
2010 :
2011 68110 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_BitString, &l);
2012 68110 : if (e) return e;
2013 68110 : p -= l; len -= l; ret += l;
2014 :
2015 68110 : *size = ret;
2016 68110 : return 0;
2017 : }
2018 :
2019 : int ASN1CALL
2020 63408 : decode_APOptions(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, APOptions *data, size_t *size)
2021 : {
2022 63408 : size_t ret = 0;
2023 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2024 : int e HEIMDAL_UNUSED_ATTRIBUTE;
2025 :
2026 63408 : memset(data, 0, sizeof(*data));
2027 : {
2028 : size_t Top_datalen, Top_oldlen;
2029 : Der_type Top_type;
2030 63408 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_BitString, &Top_datalen, &l);
2031 63408 : if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
2032 63408 : if(e) goto fail;
2033 63408 : p += l; len -= l; ret += l;
2034 63408 : Top_oldlen = len;
2035 63408 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2036 63408 : len = Top_datalen;
2037 63408 : if (len < 1) return ASN1_OVERRUN;
2038 63408 : p++; len--; ret++;
2039 : do {
2040 63408 : if (len < 1) break;
2041 63408 : (data)->reserved = (*p >> 7) & 1;
2042 63408 : (data)->use_session_key = (*p >> 6) & 1;
2043 63408 : (data)->mutual_required = (*p >> 5) & 1;
2044 : } while(0);
2045 63408 : p += len; ret += len;
2046 63408 : len = Top_oldlen - Top_datalen;
2047 : }
2048 126816 : if(size) *size = ret;
2049 61581 : return 0;
2050 0 : fail:
2051 0 : free_APOptions(data);
2052 0 : return e;
2053 : }
2054 :
2055 : void ASN1CALL
2056 131518 : free_APOptions(APOptions *data)
2057 : {
2058 131518 : }
2059 :
2060 : size_t ASN1CALL
2061 68110 : length_APOptions(const APOptions *data)
2062 : {
2063 68110 : size_t ret = 0;
2064 68110 : ret += 5;
2065 68110 : ret += 1 + der_length_len (ret);
2066 68110 : return ret;
2067 : }
2068 :
2069 : int ASN1CALL
2070 0 : copy_APOptions(const APOptions *from, APOptions *to)
2071 : {
2072 0 : memset(to, 0, sizeof(*to));
2073 0 : *(to) = *(from);
2074 0 : return 0;
2075 : }
2076 :
2077 0 : unsigned APOptions2int(APOptions f)
2078 : {
2079 0 : unsigned r = 0;
2080 0 : if(f.reserved) r |= (1U << 0);
2081 0 : if(f.use_session_key) r |= (1U << 1);
2082 0 : if(f.mutual_required) r |= (1U << 2);
2083 0 : return r;
2084 : }
2085 :
2086 0 : APOptions int2APOptions(unsigned n)
2087 : {
2088 : APOptions flags;
2089 :
2090 0 : memset(&flags, 0, sizeof(flags));
2091 :
2092 0 : flags.reserved = (n >> 0) & 1;
2093 0 : flags.use_session_key = (n >> 1) & 1;
2094 0 : flags.mutual_required = (n >> 2) & 1;
2095 0 : return flags;
2096 : }
2097 :
2098 : static struct units APOptions_units[] = {
2099 : {"mutual-required", 1U << 2},
2100 : {"use-session-key", 1U << 1},
2101 : {"reserved", 1U << 0},
2102 : {NULL, 0}
2103 : };
2104 :
2105 0 : const struct units * asn1_APOptions_units(void){
2106 0 : return APOptions_units;
2107 : }
2108 :
2109 : int ASN1CALL
2110 151213 : encode_TicketFlags(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const TicketFlags *data, size_t *size)
2111 : {
2112 151213 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
2113 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2114 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
2115 :
2116 : {
2117 151213 : unsigned char c = 0;
2118 151213 : if (len < 1) return ASN1_OVERFLOW;
2119 151213 : *p-- = c; len--; ret++;
2120 151213 : c = 0;
2121 151213 : if (len < 1) return ASN1_OVERFLOW;
2122 151213 : *p-- = c; len--; ret++;
2123 151213 : c = 0;
2124 151213 : if((data)->enc_pa_rep) {
2125 0 : c |= 1<<0;
2126 : }
2127 151213 : if((data)->anonymous) {
2128 0 : c |= 1<<1;
2129 : }
2130 151213 : if((data)->ok_as_delegate) {
2131 89004 : c |= 1<<2;
2132 : }
2133 151213 : if((data)->transited_policy_checked) {
2134 98527 : c |= 1<<3;
2135 : }
2136 151213 : if((data)->hw_authent) {
2137 0 : c |= 1<<4;
2138 : }
2139 151213 : if((data)->pre_authent) {
2140 151213 : c |= 1<<5;
2141 : }
2142 151213 : if((data)->initial) {
2143 52686 : c |= 1<<6;
2144 : }
2145 151213 : if((data)->renewable) {
2146 340 : c |= 1<<7;
2147 : }
2148 151213 : if (len < 1) return ASN1_OVERFLOW;
2149 151213 : *p-- = c; len--; ret++;
2150 151213 : c = 0;
2151 151213 : if((data)->invalid) {
2152 0 : c |= 1<<0;
2153 : }
2154 151213 : if((data)->postdated) {
2155 0 : c |= 1<<1;
2156 : }
2157 151213 : if((data)->may_postdate) {
2158 0 : c |= 1<<2;
2159 : }
2160 151213 : if((data)->proxy) {
2161 0 : c |= 1<<3;
2162 : }
2163 151213 : if((data)->proxiable) {
2164 0 : c |= 1<<4;
2165 : }
2166 151213 : if((data)->forwarded) {
2167 57935 : c |= 1<<5;
2168 : }
2169 151213 : if((data)->forwardable) {
2170 98703 : c |= 1<<6;
2171 : }
2172 151213 : if((data)->reserved) {
2173 0 : c |= 1<<7;
2174 : }
2175 151213 : if (len < 1) return ASN1_OVERFLOW;
2176 151213 : *p-- = c; len--; ret++;
2177 151213 : if (len < 1) return ASN1_OVERFLOW;
2178 151213 : *p-- = 0;
2179 151213 : len -= 1;
2180 151213 : ret += 1;
2181 : }
2182 :
2183 151213 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_BitString, &l);
2184 151213 : if (e) return e;
2185 151213 : p -= l; len -= l; ret += l;
2186 :
2187 151213 : *size = ret;
2188 151213 : return 0;
2189 : }
2190 :
2191 : int ASN1CALL
2192 134139 : decode_TicketFlags(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, TicketFlags *data, size_t *size)
2193 : {
2194 134139 : size_t ret = 0;
2195 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2196 : int e HEIMDAL_UNUSED_ATTRIBUTE;
2197 :
2198 134139 : memset(data, 0, sizeof(*data));
2199 : {
2200 : size_t Top_datalen, Top_oldlen;
2201 : Der_type Top_type;
2202 134139 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_BitString, &Top_datalen, &l);
2203 134139 : if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
2204 134139 : if(e) goto fail;
2205 134139 : p += l; len -= l; ret += l;
2206 134139 : Top_oldlen = len;
2207 134139 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2208 134139 : len = Top_datalen;
2209 134139 : if (len < 1) return ASN1_OVERRUN;
2210 134139 : p++; len--; ret++;
2211 : do {
2212 134139 : if (len < 1) break;
2213 134139 : (data)->reserved = (*p >> 7) & 1;
2214 134139 : (data)->forwardable = (*p >> 6) & 1;
2215 134139 : (data)->forwarded = (*p >> 5) & 1;
2216 134139 : (data)->proxiable = (*p >> 4) & 1;
2217 134139 : (data)->proxy = (*p >> 3) & 1;
2218 134139 : (data)->may_postdate = (*p >> 2) & 1;
2219 134139 : (data)->postdated = (*p >> 1) & 1;
2220 134139 : (data)->invalid = (*p >> 0) & 1;
2221 134139 : p++; len--; ret++;
2222 134139 : if (len < 1) break;
2223 134139 : (data)->renewable = (*p >> 7) & 1;
2224 134139 : (data)->initial = (*p >> 6) & 1;
2225 134139 : (data)->pre_authent = (*p >> 5) & 1;
2226 134139 : (data)->hw_authent = (*p >> 4) & 1;
2227 134139 : (data)->transited_policy_checked = (*p >> 3) & 1;
2228 134139 : (data)->ok_as_delegate = (*p >> 2) & 1;
2229 134139 : (data)->anonymous = (*p >> 1) & 1;
2230 134139 : (data)->enc_pa_rep = (*p >> 0) & 1;
2231 : } while(0);
2232 134139 : p += len; ret += len;
2233 134139 : len = Top_oldlen - Top_datalen;
2234 : }
2235 268278 : if(size) *size = ret;
2236 130190 : return 0;
2237 0 : fail:
2238 0 : free_TicketFlags(data);
2239 0 : return e;
2240 : }
2241 :
2242 : void ASN1CALL
2243 329157 : free_TicketFlags(TicketFlags *data)
2244 : {
2245 329157 : }
2246 :
2247 : size_t ASN1CALL
2248 151213 : length_TicketFlags(const TicketFlags *data)
2249 : {
2250 151213 : size_t ret = 0;
2251 151213 : ret += 5;
2252 151213 : ret += 1 + der_length_len (ret);
2253 151213 : return ret;
2254 : }
2255 :
2256 : int ASN1CALL
2257 34879 : copy_TicketFlags(const TicketFlags *from, TicketFlags *to)
2258 : {
2259 34879 : memset(to, 0, sizeof(*to));
2260 34879 : *(to) = *(from);
2261 34879 : return 0;
2262 : }
2263 :
2264 1349 : unsigned TicketFlags2int(TicketFlags f)
2265 : {
2266 1349 : unsigned r = 0;
2267 1349 : if(f.reserved) r |= (1U << 0);
2268 1349 : if(f.forwardable) r |= (1U << 1);
2269 1349 : if(f.forwarded) r |= (1U << 2);
2270 1349 : if(f.proxiable) r |= (1U << 3);
2271 1349 : if(f.proxy) r |= (1U << 4);
2272 1349 : if(f.may_postdate) r |= (1U << 5);
2273 1349 : if(f.postdated) r |= (1U << 6);
2274 1349 : if(f.invalid) r |= (1U << 7);
2275 1349 : if(f.renewable) r |= (1U << 8);
2276 1349 : if(f.initial) r |= (1U << 9);
2277 1349 : if(f.pre_authent) r |= (1U << 10);
2278 1349 : if(f.hw_authent) r |= (1U << 11);
2279 1349 : if(f.transited_policy_checked) r |= (1U << 12);
2280 1349 : if(f.ok_as_delegate) r |= (1U << 13);
2281 1349 : if(f.anonymous) r |= (1U << 14);
2282 1349 : if(f.enc_pa_rep) r |= (1U << 15);
2283 1349 : return r;
2284 : }
2285 :
2286 0 : TicketFlags int2TicketFlags(unsigned n)
2287 : {
2288 : TicketFlags flags;
2289 :
2290 0 : memset(&flags, 0, sizeof(flags));
2291 :
2292 0 : flags.reserved = (n >> 0) & 1;
2293 0 : flags.forwardable = (n >> 1) & 1;
2294 0 : flags.forwarded = (n >> 2) & 1;
2295 0 : flags.proxiable = (n >> 3) & 1;
2296 0 : flags.proxy = (n >> 4) & 1;
2297 0 : flags.may_postdate = (n >> 5) & 1;
2298 0 : flags.postdated = (n >> 6) & 1;
2299 0 : flags.invalid = (n >> 7) & 1;
2300 0 : flags.renewable = (n >> 8) & 1;
2301 0 : flags.initial = (n >> 9) & 1;
2302 0 : flags.pre_authent = (n >> 10) & 1;
2303 0 : flags.hw_authent = (n >> 11) & 1;
2304 0 : flags.transited_policy_checked = (n >> 12) & 1;
2305 0 : flags.ok_as_delegate = (n >> 13) & 1;
2306 0 : flags.anonymous = (n >> 14) & 1;
2307 0 : flags.enc_pa_rep = (n >> 15) & 1;
2308 0 : return flags;
2309 : }
2310 :
2311 : static struct units TicketFlags_units[] = {
2312 : {"enc-pa-rep", 1U << 15},
2313 : {"anonymous", 1U << 14},
2314 : {"ok-as-delegate", 1U << 13},
2315 : {"transited-policy-checked", 1U << 12},
2316 : {"hw-authent", 1U << 11},
2317 : {"pre-authent", 1U << 10},
2318 : {"initial", 1U << 9},
2319 : {"renewable", 1U << 8},
2320 : {"invalid", 1U << 7},
2321 : {"postdated", 1U << 6},
2322 : {"may-postdate", 1U << 5},
2323 : {"proxy", 1U << 4},
2324 : {"proxiable", 1U << 3},
2325 : {"forwarded", 1U << 2},
2326 : {"forwardable", 1U << 1},
2327 : {"reserved", 1U << 0},
2328 : {NULL, 0}
2329 : };
2330 :
2331 0 : const struct units * asn1_TicketFlags_units(void){
2332 0 : return TicketFlags_units;
2333 : }
2334 :
2335 : int ASN1CALL
2336 167372 : encode_KDCOptions(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const KDCOptions *data, size_t *size)
2337 : {
2338 167372 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
2339 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2340 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
2341 :
2342 : {
2343 167372 : unsigned char c = 0;
2344 167372 : if((data)->validate) {
2345 0 : c |= 1<<0;
2346 : }
2347 167372 : if((data)->renew) {
2348 90 : c |= 1<<1;
2349 : }
2350 167372 : if((data)->enc_tkt_in_skey) {
2351 0 : c |= 1<<3;
2352 : }
2353 167372 : if((data)->renewable_ok) {
2354 17 : c |= 1<<4;
2355 : }
2356 167372 : if((data)->disable_transited_check) {
2357 0 : c |= 1<<5;
2358 : }
2359 167372 : if (len < 1) return ASN1_OVERFLOW;
2360 167372 : *p-- = c; len--; ret++;
2361 167372 : c = 0;
2362 167372 : if((data)->constrained_delegation) {
2363 67 : c |= 1<<7;
2364 : }
2365 167372 : if (len < 1) return ASN1_OVERFLOW;
2366 167372 : *p-- = c; len--; ret++;
2367 167372 : c = 0;
2368 167372 : if((data)->canonicalize) {
2369 97082 : c |= 1<<0;
2370 : }
2371 167372 : if((data)->request_anonymous) {
2372 67 : c |= 1<<1;
2373 : }
2374 167372 : if((data)->renewable) {
2375 240 : c |= 1<<7;
2376 : }
2377 167372 : if (len < 1) return ASN1_OVERFLOW;
2378 167372 : *p-- = c; len--; ret++;
2379 167372 : c = 0;
2380 167372 : if((data)->postdated) {
2381 1 : c |= 1<<1;
2382 : }
2383 167372 : if((data)->allow_postdate) {
2384 1 : c |= 1<<2;
2385 : }
2386 167372 : if((data)->proxy) {
2387 1 : c |= 1<<3;
2388 : }
2389 167372 : if((data)->proxiable) {
2390 1 : c |= 1<<4;
2391 : }
2392 167372 : if((data)->forwarded) {
2393 58150 : c |= 1<<5;
2394 : }
2395 167372 : if((data)->forwardable) {
2396 85821 : c |= 1<<6;
2397 : }
2398 167372 : if((data)->reserved) {
2399 1 : c |= 1<<7;
2400 : }
2401 167372 : if (len < 1) return ASN1_OVERFLOW;
2402 167372 : *p-- = c; len--; ret++;
2403 167372 : if (len < 1) return ASN1_OVERFLOW;
2404 167372 : *p-- = 0;
2405 167372 : len -= 1;
2406 167372 : ret += 1;
2407 : }
2408 :
2409 167372 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_BitString, &l);
2410 167372 : if (e) return e;
2411 167372 : p -= l; len -= l; ret += l;
2412 :
2413 167372 : *size = ret;
2414 167372 : return 0;
2415 : }
2416 :
2417 : int ASN1CALL
2418 104664 : decode_KDCOptions(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, KDCOptions *data, size_t *size)
2419 : {
2420 104664 : size_t ret = 0;
2421 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2422 : int e HEIMDAL_UNUSED_ATTRIBUTE;
2423 :
2424 104664 : memset(data, 0, sizeof(*data));
2425 : {
2426 : size_t Top_datalen, Top_oldlen;
2427 : Der_type Top_type;
2428 104664 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_BitString, &Top_datalen, &l);
2429 104664 : if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
2430 104664 : if(e) goto fail;
2431 104664 : p += l; len -= l; ret += l;
2432 104664 : Top_oldlen = len;
2433 104664 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2434 104664 : len = Top_datalen;
2435 104664 : if (len < 1) return ASN1_OVERRUN;
2436 104664 : p++; len--; ret++;
2437 : do {
2438 104664 : if (len < 1) break;
2439 104664 : (data)->reserved = (*p >> 7) & 1;
2440 104664 : (data)->forwardable = (*p >> 6) & 1;
2441 104664 : (data)->forwarded = (*p >> 5) & 1;
2442 104664 : (data)->proxiable = (*p >> 4) & 1;
2443 104664 : (data)->proxy = (*p >> 3) & 1;
2444 104664 : (data)->allow_postdate = (*p >> 2) & 1;
2445 104664 : (data)->postdated = (*p >> 1) & 1;
2446 104664 : p++; len--; ret++;
2447 104664 : if (len < 1) break;
2448 104664 : (data)->renewable = (*p >> 7) & 1;
2449 104664 : (data)->request_anonymous = (*p >> 1) & 1;
2450 104664 : (data)->canonicalize = (*p >> 0) & 1;
2451 104664 : p++; len--; ret++;
2452 104664 : if (len < 1) break;
2453 104664 : (data)->constrained_delegation = (*p >> 7) & 1;
2454 104664 : p++; len--; ret++;
2455 104664 : if (len < 1) break;
2456 104664 : (data)->disable_transited_check = (*p >> 5) & 1;
2457 104664 : (data)->renewable_ok = (*p >> 4) & 1;
2458 104664 : (data)->enc_tkt_in_skey = (*p >> 3) & 1;
2459 104664 : (data)->renew = (*p >> 1) & 1;
2460 104664 : (data)->validate = (*p >> 0) & 1;
2461 : } while(0);
2462 104664 : p += len; ret += len;
2463 104664 : len = Top_oldlen - Top_datalen;
2464 : }
2465 209328 : if(size) *size = ret;
2466 102690 : return 0;
2467 0 : fail:
2468 0 : free_KDCOptions(data);
2469 0 : return e;
2470 : }
2471 :
2472 : void ASN1CALL
2473 205672 : free_KDCOptions(KDCOptions *data)
2474 : {
2475 205672 : }
2476 :
2477 : size_t ASN1CALL
2478 167372 : length_KDCOptions(const KDCOptions *data)
2479 : {
2480 167372 : size_t ret = 0;
2481 167372 : ret += 5;
2482 167372 : ret += 1 + der_length_len (ret);
2483 167372 : return ret;
2484 : }
2485 :
2486 : int ASN1CALL
2487 0 : copy_KDCOptions(const KDCOptions *from, KDCOptions *to)
2488 : {
2489 0 : memset(to, 0, sizeof(*to));
2490 0 : *(to) = *(from);
2491 0 : return 0;
2492 : }
2493 :
2494 86360 : unsigned KDCOptions2int(KDCOptions f)
2495 : {
2496 86360 : unsigned r = 0;
2497 86360 : if(f.reserved) r |= (1U << 0);
2498 86360 : if(f.forwardable) r |= (1U << 1);
2499 86360 : if(f.forwarded) r |= (1U << 2);
2500 86360 : if(f.proxiable) r |= (1U << 3);
2501 86360 : if(f.proxy) r |= (1U << 4);
2502 86360 : if(f.allow_postdate) r |= (1U << 5);
2503 86360 : if(f.postdated) r |= (1U << 6);
2504 86360 : if(f.renewable) r |= (1U << 8);
2505 86360 : if(f.request_anonymous) r |= (1U << 14);
2506 86360 : if(f.canonicalize) r |= (1U << 15);
2507 86360 : if(f.constrained_delegation) r |= (1U << 16);
2508 86360 : if(f.disable_transited_check) r |= (1U << 26);
2509 86360 : if(f.renewable_ok) r |= (1U << 27);
2510 86360 : if(f.enc_tkt_in_skey) r |= (1U << 28);
2511 86360 : if(f.renew) r |= (1U << 30);
2512 86360 : if(f.validate) r |= (1U << 31);
2513 86360 : return r;
2514 : }
2515 :
2516 19370 : KDCOptions int2KDCOptions(unsigned n)
2517 : {
2518 : KDCOptions flags;
2519 :
2520 19370 : memset(&flags, 0, sizeof(flags));
2521 :
2522 19370 : flags.reserved = (n >> 0) & 1;
2523 19370 : flags.forwardable = (n >> 1) & 1;
2524 19370 : flags.forwarded = (n >> 2) & 1;
2525 19370 : flags.proxiable = (n >> 3) & 1;
2526 19370 : flags.proxy = (n >> 4) & 1;
2527 19370 : flags.allow_postdate = (n >> 5) & 1;
2528 19370 : flags.postdated = (n >> 6) & 1;
2529 19370 : flags.renewable = (n >> 8) & 1;
2530 19370 : flags.request_anonymous = (n >> 14) & 1;
2531 19370 : flags.canonicalize = (n >> 15) & 1;
2532 19370 : flags.constrained_delegation = (n >> 16) & 1;
2533 19370 : flags.disable_transited_check = (n >> 26) & 1;
2534 19370 : flags.renewable_ok = (n >> 27) & 1;
2535 19370 : flags.enc_tkt_in_skey = (n >> 28) & 1;
2536 19370 : flags.renew = (n >> 30) & 1;
2537 19370 : flags.validate = (n >> 31) & 1;
2538 19370 : return flags;
2539 : }
2540 :
2541 : static struct units KDCOptions_units[] = {
2542 : {"validate", 1U << 31},
2543 : {"renew", 1U << 30},
2544 : {"enc-tkt-in-skey", 1U << 28},
2545 : {"renewable-ok", 1U << 27},
2546 : {"disable-transited-check", 1U << 26},
2547 : {"constrained-delegation", 1U << 16},
2548 : {"canonicalize", 1U << 15},
2549 : {"request-anonymous", 1U << 14},
2550 : {"renewable", 1U << 8},
2551 : {"postdated", 1U << 6},
2552 : {"allow-postdate", 1U << 5},
2553 : {"proxy", 1U << 4},
2554 : {"proxiable", 1U << 3},
2555 : {"forwarded", 1U << 2},
2556 : {"forwardable", 1U << 1},
2557 : {"reserved", 1U << 0},
2558 : {NULL, 0}
2559 : };
2560 :
2561 66990 : const struct units * asn1_KDCOptions_units(void){
2562 66990 : return KDCOptions_units;
2563 : }
2564 :
2565 : int ASN1CALL
2566 66016 : encode_LR_TYPE(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const LR_TYPE *data, size_t *size)
2567 : {
2568 66016 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
2569 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2570 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
2571 :
2572 : {
2573 66016 : int enumint = (int)*data;
2574 66016 : e = der_put_integer(p, len, &enumint, &l);
2575 66016 : if (e) return e;
2576 66016 : p -= l; len -= l; ret += l;
2577 :
2578 : }
2579 66016 : ;e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
2580 66016 : if (e) return e;
2581 66016 : p -= l; len -= l; ret += l;
2582 :
2583 66016 : *size = ret;
2584 66016 : return 0;
2585 : }
2586 :
2587 : int ASN1CALL
2588 52862 : decode_LR_TYPE(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, LR_TYPE *data, size_t *size)
2589 : {
2590 52862 : size_t ret = 0;
2591 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2592 : int e HEIMDAL_UNUSED_ATTRIBUTE;
2593 :
2594 52862 : memset(data, 0, sizeof(*data));
2595 : {
2596 : size_t Top_datalen, Top_oldlen;
2597 : Der_type Top_type;
2598 52862 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Integer, &Top_datalen, &l);
2599 52862 : if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
2600 52862 : if(e) goto fail;
2601 52862 : p += l; len -= l; ret += l;
2602 52862 : Top_oldlen = len;
2603 52862 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2604 52862 : len = Top_datalen;
2605 : {
2606 : int enumint;
2607 52862 : e = der_get_integer(p, len, &enumint, &l);
2608 52862 : if(e) goto fail;
2609 52862 : p += l; len -= l; ret += l;
2610 52862 : *data = enumint;
2611 : }
2612 52862 : len = Top_oldlen - Top_datalen;
2613 : }
2614 105724 : if(size) *size = ret;
2615 51478 : return 0;
2616 0 : fail:
2617 0 : free_LR_TYPE(data);
2618 0 : return e;
2619 : }
2620 :
2621 : void ASN1CALL
2622 132252 : free_LR_TYPE(LR_TYPE *data)
2623 : {
2624 132252 : }
2625 :
2626 : size_t ASN1CALL
2627 66016 : length_LR_TYPE(const LR_TYPE *data)
2628 : {
2629 66016 : size_t ret = 0;
2630 : {
2631 66016 : int enumint = *data;
2632 66016 : ret += der_length_integer(&enumint);
2633 : }
2634 66016 : ret += 1 + der_length_len (ret);
2635 66016 : return ret;
2636 : }
2637 :
2638 : int ASN1CALL
2639 13374 : copy_LR_TYPE(const LR_TYPE *from, LR_TYPE *to)
2640 : {
2641 13374 : memset(to, 0, sizeof(*to));
2642 13374 : *(to) = *(from);
2643 13374 : return 0;
2644 : }
2645 :
2646 : int ASN1CALL
2647 66016 : encode_LastReq(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const LastReq *data, size_t *size)
2648 : {
2649 66016 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
2650 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2651 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
2652 :
2653 132032 : for(i = (int)(data)->len - 1; i >= 0; --i) {
2654 66016 : size_t Top_tag_for_oldret = ret;
2655 66016 : ret = 0;
2656 : /* lr-value */
2657 : {
2658 66016 : size_t Top_tag_S_Of_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2659 66016 : ret = 0;
2660 66016 : e = encode_KerberosTime(p, len, &(&(data)->val[i])->lr_value, &l);
2661 66016 : if (e) return e;
2662 66016 : p -= l; len -= l; ret += l;
2663 :
2664 66016 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
2665 66016 : if (e) return e;
2666 66016 : p -= l; len -= l; ret += l;
2667 :
2668 66016 : ret += Top_tag_S_Of_tag_oldret;
2669 : }
2670 : /* lr-type */
2671 : {
2672 66016 : size_t Top_tag_S_Of_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2673 66016 : ret = 0;
2674 66016 : e = encode_LR_TYPE(p, len, &(&(data)->val[i])->lr_type, &l);
2675 66016 : if (e) return e;
2676 66016 : p -= l; len -= l; ret += l;
2677 :
2678 66016 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
2679 66016 : if (e) return e;
2680 66016 : p -= l; len -= l; ret += l;
2681 :
2682 66016 : ret += Top_tag_S_Of_tag_oldret;
2683 : }
2684 66016 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
2685 66016 : if (e) return e;
2686 66016 : p -= l; len -= l; ret += l;
2687 :
2688 66016 : ret += Top_tag_for_oldret;
2689 : }
2690 66016 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
2691 66016 : if (e) return e;
2692 66016 : p -= l; len -= l; ret += l;
2693 :
2694 66016 : *size = ret;
2695 66016 : return 0;
2696 : }
2697 :
2698 : int ASN1CALL
2699 52862 : decode_LastReq(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, LastReq *data, size_t *size)
2700 : {
2701 52862 : size_t ret = 0;
2702 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2703 : int e HEIMDAL_UNUSED_ATTRIBUTE;
2704 :
2705 52862 : memset(data, 0, sizeof(*data));
2706 : {
2707 : size_t Top_datalen, Top_oldlen;
2708 : Der_type Top_type;
2709 52862 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
2710 52862 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
2711 52862 : if(e) goto fail;
2712 52862 : p += l; len -= l; ret += l;
2713 52862 : Top_oldlen = len;
2714 52862 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2715 52862 : len = Top_datalen;
2716 : {
2717 52862 : size_t Top_Tag_origlen = len;
2718 52862 : size_t Top_Tag_oldret = ret;
2719 52862 : size_t Top_Tag_olen = 0;
2720 : void *Top_Tag_tmp;
2721 52862 : ret = 0;
2722 52862 : (data)->len = 0;
2723 52862 : (data)->val = NULL;
2724 158586 : while(ret < Top_Tag_origlen) {
2725 52862 : size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
2726 52862 : if (Top_Tag_olen > Top_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
2727 52862 : Top_Tag_olen = Top_Tag_nlen;
2728 52862 : Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
2729 52862 : if (Top_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
2730 52862 : (data)->val = Top_Tag_tmp;
2731 : {
2732 : size_t Top_Tag_s_of_datalen, Top_Tag_s_of_oldlen;
2733 : Der_type Top_Tag_s_of_type;
2734 52862 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_Tag_s_of_type, UT_Sequence, &Top_Tag_s_of_datalen, &l);
2735 52862 : if (e == 0 && Top_Tag_s_of_type != CONS) { e = ASN1_BAD_ID; }
2736 52862 : if(e) goto fail;
2737 52862 : p += l; len -= l; ret += l;
2738 52862 : Top_Tag_s_of_oldlen = len;
2739 52862 : if (Top_Tag_s_of_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2740 52862 : len = Top_Tag_s_of_datalen;
2741 : {
2742 : size_t lr_type_datalen, lr_type_oldlen;
2743 : Der_type lr_type_type;
2744 52862 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &lr_type_type, 0, &lr_type_datalen, &l);
2745 52862 : if (e == 0 && lr_type_type != CONS) { e = ASN1_BAD_ID; }
2746 52862 : if(e) goto fail;
2747 52862 : p += l; len -= l; ret += l;
2748 52862 : lr_type_oldlen = len;
2749 52862 : if (lr_type_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2750 52862 : len = lr_type_datalen;
2751 52862 : e = decode_LR_TYPE(p, len, &(&(data)->val[(data)->len])->lr_type, &l);
2752 52862 : if(e) goto fail;
2753 52862 : p += l; len -= l; ret += l;
2754 52862 : len = lr_type_oldlen - lr_type_datalen;
2755 : }
2756 : {
2757 : size_t lr_value_datalen, lr_value_oldlen;
2758 : Der_type lr_value_type;
2759 52862 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &lr_value_type, 1, &lr_value_datalen, &l);
2760 104340 : if (e == 0 && lr_value_type != CONS) { e = ASN1_BAD_ID; }
2761 52862 : if(e) goto fail;
2762 52862 : p += l; len -= l; ret += l;
2763 52862 : lr_value_oldlen = len;
2764 52862 : if (lr_value_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2765 52862 : len = lr_value_datalen;
2766 52862 : e = decode_KerberosTime(p, len, &(&(data)->val[(data)->len])->lr_value, &l);
2767 52862 : if(e) goto fail;
2768 52862 : p += l; len -= l; ret += l;
2769 52862 : len = lr_value_oldlen - lr_value_datalen;
2770 : }
2771 52862 : len = Top_Tag_s_of_oldlen - Top_Tag_s_of_datalen;
2772 : }
2773 52862 : (data)->len++;
2774 52862 : len = Top_Tag_origlen - ret;
2775 : }
2776 52862 : ret += Top_Tag_oldret;
2777 : }
2778 52862 : len = Top_oldlen - Top_datalen;
2779 : }
2780 105724 : if(size) *size = ret;
2781 51478 : return 0;
2782 0 : fail:
2783 0 : free_LastReq(data);
2784 0 : return e;
2785 : }
2786 :
2787 : void ASN1CALL
2788 180046 : free_LastReq(LastReq *data)
2789 : {
2790 492344 : while((data)->len){
2791 132252 : free_LR_TYPE(&(&(data)->val[(data)->len-1])->lr_type);
2792 132252 : free_KerberosTime(&(&(data)->val[(data)->len-1])->lr_value);
2793 132252 : (data)->len--;
2794 : }
2795 180046 : free((data)->val);
2796 180046 : (data)->val = NULL;
2797 180046 : }
2798 :
2799 : size_t ASN1CALL
2800 66016 : length_LastReq(const LastReq *data)
2801 : {
2802 66016 : size_t ret = 0;
2803 : {
2804 66016 : size_t Top_tag_oldret = ret;
2805 : int i;
2806 66016 : ret = 0;
2807 132032 : for(i = (data)->len - 1; i >= 0; --i){
2808 66016 : size_t Top_tag_for_oldret = ret;
2809 66016 : ret = 0;
2810 : {
2811 66016 : size_t Top_tag_S_Of_tag_oldret = ret;
2812 66016 : ret = 0;
2813 66016 : ret += length_LR_TYPE(&(&(data)->val[i])->lr_type);
2814 66016 : ret += 1 + der_length_len (ret);
2815 66016 : ret += Top_tag_S_Of_tag_oldret;
2816 : }
2817 : {
2818 66016 : size_t Top_tag_S_Of_tag_oldret = ret;
2819 66016 : ret = 0;
2820 66016 : ret += length_KerberosTime(&(&(data)->val[i])->lr_value);
2821 66016 : ret += 1 + der_length_len (ret);
2822 66016 : ret += Top_tag_S_Of_tag_oldret;
2823 : }
2824 66016 : ret += 1 + der_length_len (ret);
2825 66016 : ret += Top_tag_for_oldret;
2826 : }
2827 66016 : ret += Top_tag_oldret;
2828 : }
2829 66016 : ret += 1 + der_length_len (ret);
2830 66016 : return ret;
2831 : }
2832 :
2833 : int ASN1CALL
2834 13374 : copy_LastReq(const LastReq *from, LastReq *to)
2835 : {
2836 13374 : memset(to, 0, sizeof(*to));
2837 13374 : if(((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
2838 0 : goto fail;
2839 26748 : for((to)->len = 0; (to)->len < (from)->len; (to)->len++){
2840 13374 : if(copy_LR_TYPE(&(&(from)->val[(to)->len])->lr_type, &(&(to)->val[(to)->len])->lr_type)) goto fail;
2841 13374 : if(copy_KerberosTime(&(&(from)->val[(to)->len])->lr_value, &(&(to)->val[(to)->len])->lr_value)) goto fail;
2842 : }
2843 13079 : return 0;
2844 0 : fail:
2845 0 : free_LastReq(to);
2846 0 : return ENOMEM;
2847 : }
2848 :
2849 : int ASN1CALL
2850 417436 : encode_EncryptedData(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const EncryptedData *data, size_t *size)
2851 : {
2852 417436 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
2853 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2854 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
2855 :
2856 : /* cipher */
2857 : {
2858 417436 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2859 417436 : ret = 0;
2860 417436 : e = der_put_octet_string(p, len, &(data)->cipher, &l);
2861 417436 : if (e) return e;
2862 417436 : p -= l; len -= l; ret += l;
2863 :
2864 417436 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
2865 417436 : if (e) return e;
2866 417436 : p -= l; len -= l; ret += l;
2867 :
2868 417436 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
2869 417436 : if (e) return e;
2870 417436 : p -= l; len -= l; ret += l;
2871 :
2872 417436 : ret += Top_tag_oldret;
2873 : }
2874 : /* kvno */
2875 417436 : if((data)->kvno) {
2876 250416 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2877 250416 : ret = 0;
2878 250416 : e = encode_krb5int32(p, len, (data)->kvno, &l);
2879 250416 : if (e) return e;
2880 250416 : p -= l; len -= l; ret += l;
2881 :
2882 250416 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
2883 250416 : if (e) return e;
2884 250416 : p -= l; len -= l; ret += l;
2885 :
2886 250416 : ret += Top_tag_oldret;
2887 : }
2888 : /* etype */
2889 : {
2890 417436 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2891 417436 : ret = 0;
2892 417436 : e = encode_ENCTYPE(p, len, &(data)->etype, &l);
2893 417436 : if (e) return e;
2894 417436 : p -= l; len -= l; ret += l;
2895 :
2896 417436 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
2897 417436 : if (e) return e;
2898 417436 : p -= l; len -= l; ret += l;
2899 :
2900 417436 : ret += Top_tag_oldret;
2901 : }
2902 417436 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
2903 417436 : if (e) return e;
2904 417436 : p -= l; len -= l; ret += l;
2905 :
2906 417436 : *size = ret;
2907 417436 : return 0;
2908 : }
2909 :
2910 : int ASN1CALL
2911 430982 : decode_EncryptedData(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, EncryptedData *data, size_t *size)
2912 : {
2913 430982 : size_t ret = 0;
2914 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2915 : int e HEIMDAL_UNUSED_ATTRIBUTE;
2916 :
2917 430982 : memset(data, 0, sizeof(*data));
2918 : {
2919 : size_t Top_datalen, Top_oldlen;
2920 : Der_type Top_type;
2921 430982 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
2922 430982 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
2923 430982 : if(e) goto fail;
2924 430982 : p += l; len -= l; ret += l;
2925 430982 : Top_oldlen = len;
2926 430982 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2927 430982 : len = Top_datalen;
2928 : {
2929 : size_t etype_datalen, etype_oldlen;
2930 : Der_type etype_type;
2931 430982 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &etype_type, 0, &etype_datalen, &l);
2932 430982 : if (e == 0 && etype_type != CONS) { e = ASN1_BAD_ID; }
2933 430982 : if(e) goto fail;
2934 430982 : p += l; len -= l; ret += l;
2935 430982 : etype_oldlen = len;
2936 430982 : if (etype_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2937 430982 : len = etype_datalen;
2938 430982 : e = decode_ENCTYPE(p, len, &(data)->etype, &l);
2939 430982 : if(e) goto fail;
2940 430982 : p += l; len -= l; ret += l;
2941 430982 : len = etype_oldlen - etype_datalen;
2942 : }
2943 : {
2944 : size_t kvno_datalen, kvno_oldlen;
2945 : Der_type kvno_type;
2946 430982 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &kvno_type, 1, &kvno_datalen, &l);
2947 674097 : if (e == 0 && kvno_type != CONS) { e = ASN1_BAD_ID; }
2948 430982 : if(e) {
2949 181034 : (data)->kvno = NULL;
2950 : } else {
2951 249948 : (data)->kvno = calloc(1, sizeof(*(data)->kvno));
2952 249948 : if ((data)->kvno == NULL) { e = ENOMEM; goto fail; }
2953 249948 : p += l; len -= l; ret += l;
2954 249948 : kvno_oldlen = len;
2955 249948 : if (kvno_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2956 249948 : len = kvno_datalen;
2957 249948 : e = decode_krb5int32(p, len, (data)->kvno, &l);
2958 249948 : if(e) goto fail;
2959 249948 : p += l; len -= l; ret += l;
2960 249948 : len = kvno_oldlen - kvno_datalen;
2961 : }
2962 : }
2963 : {
2964 : size_t cipher_datalen, cipher_oldlen;
2965 : Der_type cipher_type;
2966 430982 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &cipher_type, 2, &cipher_datalen, &l);
2967 861964 : if (e == 0 && cipher_type != CONS) { e = ASN1_BAD_ID; }
2968 430982 : if(e) goto fail;
2969 430982 : p += l; len -= l; ret += l;
2970 430982 : cipher_oldlen = len;
2971 430982 : if (cipher_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2972 430982 : len = cipher_datalen;
2973 : {
2974 : size_t cipher_Tag_datalen, cipher_Tag_oldlen;
2975 : Der_type cipher_Tag_type;
2976 430982 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &cipher_Tag_type, UT_OctetString, &cipher_Tag_datalen, &l);
2977 430982 : if (e == 0 && cipher_Tag_type != PRIM) { e = ASN1_BAD_ID; }
2978 430982 : if(e) goto fail;
2979 430982 : p += l; len -= l; ret += l;
2980 430982 : cipher_Tag_oldlen = len;
2981 430982 : if (cipher_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2982 430982 : len = cipher_Tag_datalen;
2983 430982 : e = der_get_octet_string(p, len, &(data)->cipher, &l);
2984 430982 : if(e) goto fail;
2985 430982 : p += l; len -= l; ret += l;
2986 430982 : len = cipher_Tag_oldlen - cipher_Tag_datalen;
2987 : }
2988 430982 : len = cipher_oldlen - cipher_datalen;
2989 : }
2990 430982 : len = Top_oldlen - Top_datalen;
2991 : }
2992 861964 : if(size) *size = ret;
2993 419071 : return 0;
2994 0 : fail:
2995 0 : free_EncryptedData(data);
2996 0 : return e;
2997 : }
2998 :
2999 : void ASN1CALL
3000 868225 : free_EncryptedData(EncryptedData *data)
3001 : {
3002 868225 : free_ENCTYPE(&(data)->etype);
3003 868225 : if((data)->kvno) {
3004 409589 : free_krb5int32((data)->kvno);
3005 409589 : free((data)->kvno);
3006 409589 : (data)->kvno = NULL;
3007 : }
3008 868225 : der_free_octet_string(&(data)->cipher);
3009 868225 : }
3010 :
3011 : size_t ASN1CALL
3012 417436 : length_EncryptedData(const EncryptedData *data)
3013 : {
3014 417436 : size_t ret = 0;
3015 : {
3016 417436 : size_t Top_tag_oldret = ret;
3017 417436 : ret = 0;
3018 417436 : ret += length_ENCTYPE(&(data)->etype);
3019 417436 : ret += 1 + der_length_len (ret);
3020 417436 : ret += Top_tag_oldret;
3021 : }
3022 417436 : if((data)->kvno){
3023 250416 : size_t Top_tag_oldret = ret;
3024 250416 : ret = 0;
3025 250416 : ret += length_krb5int32((data)->kvno);
3026 250416 : ret += 1 + der_length_len (ret);
3027 250416 : ret += Top_tag_oldret;
3028 : }
3029 : {
3030 417436 : size_t Top_tag_oldret = ret;
3031 417436 : ret = 0;
3032 417436 : ret += der_length_octet_string(&(data)->cipher);
3033 417436 : ret += 1 + der_length_len (ret);
3034 417436 : ret += 1 + der_length_len (ret);
3035 417436 : ret += Top_tag_oldret;
3036 : }
3037 417436 : ret += 1 + der_length_len (ret);
3038 417436 : return ret;
3039 : }
3040 :
3041 : int ASN1CALL
3042 68152 : copy_EncryptedData(const EncryptedData *from, EncryptedData *to)
3043 : {
3044 68152 : memset(to, 0, sizeof(*to));
3045 68152 : if(copy_ENCTYPE(&(from)->etype, &(to)->etype)) goto fail;
3046 68152 : if((from)->kvno) {
3047 67834 : (to)->kvno = malloc(sizeof(*(to)->kvno));
3048 67834 : if((to)->kvno == NULL) goto fail;
3049 67834 : if(copy_krb5int32((from)->kvno, (to)->kvno)) goto fail;
3050 : }else
3051 318 : (to)->kvno = NULL;
3052 68152 : if(der_copy_octet_string(&(from)->cipher, &(to)->cipher)) goto fail;
3053 66313 : return 0;
3054 0 : fail:
3055 0 : free_EncryptedData(to);
3056 0 : return ENOMEM;
3057 : }
3058 :
3059 : int ASN1CALL
3060 234017 : encode_EncryptionKey(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const EncryptionKey *data, size_t *size)
3061 : {
3062 234017 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
3063 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3064 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
3065 :
3066 : /* keyvalue */
3067 : {
3068 234017 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3069 234017 : ret = 0;
3070 234017 : e = der_put_octet_string(p, len, &(data)->keyvalue, &l);
3071 234017 : if (e) return e;
3072 234017 : p -= l; len -= l; ret += l;
3073 :
3074 234017 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
3075 234017 : if (e) return e;
3076 234017 : p -= l; len -= l; ret += l;
3077 :
3078 234017 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
3079 234017 : if (e) return e;
3080 234017 : p -= l; len -= l; ret += l;
3081 :
3082 234017 : ret += Top_tag_oldret;
3083 : }
3084 : /* keytype */
3085 : {
3086 234017 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3087 234017 : ret = 0;
3088 234017 : e = encode_krb5int32(p, len, &(data)->keytype, &l);
3089 234017 : if (e) return e;
3090 234017 : p -= l; len -= l; ret += l;
3091 :
3092 234017 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
3093 234017 : if (e) return e;
3094 234017 : p -= l; len -= l; ret += l;
3095 :
3096 234017 : ret += Top_tag_oldret;
3097 : }
3098 234017 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
3099 234017 : if (e) return e;
3100 234017 : p -= l; len -= l; ret += l;
3101 :
3102 234017 : *size = ret;
3103 234017 : return 0;
3104 : }
3105 :
3106 : int ASN1CALL
3107 215972 : decode_EncryptionKey(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, EncryptionKey *data, size_t *size)
3108 : {
3109 215972 : size_t ret = 0;
3110 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3111 : int e HEIMDAL_UNUSED_ATTRIBUTE;
3112 :
3113 215972 : memset(data, 0, sizeof(*data));
3114 : {
3115 : size_t Top_datalen, Top_oldlen;
3116 : Der_type Top_type;
3117 215972 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
3118 215972 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
3119 215972 : if(e) goto fail;
3120 215972 : p += l; len -= l; ret += l;
3121 215972 : Top_oldlen = len;
3122 215972 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3123 215972 : len = Top_datalen;
3124 : {
3125 : size_t keytype_datalen, keytype_oldlen;
3126 : Der_type keytype_type;
3127 215972 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &keytype_type, 0, &keytype_datalen, &l);
3128 215972 : if (e == 0 && keytype_type != CONS) { e = ASN1_BAD_ID; }
3129 215972 : if(e) goto fail;
3130 215972 : p += l; len -= l; ret += l;
3131 215972 : keytype_oldlen = len;
3132 215972 : if (keytype_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3133 215972 : len = keytype_datalen;
3134 215972 : e = decode_krb5int32(p, len, &(data)->keytype, &l);
3135 215972 : if(e) goto fail;
3136 215972 : p += l; len -= l; ret += l;
3137 215972 : len = keytype_oldlen - keytype_datalen;
3138 : }
3139 : {
3140 : size_t keyvalue_datalen, keyvalue_oldlen;
3141 : Der_type keyvalue_type;
3142 215972 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &keyvalue_type, 1, &keyvalue_datalen, &l);
3143 425430 : if (e == 0 && keyvalue_type != CONS) { e = ASN1_BAD_ID; }
3144 215972 : if(e) goto fail;
3145 215972 : p += l; len -= l; ret += l;
3146 215972 : keyvalue_oldlen = len;
3147 215972 : if (keyvalue_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3148 215972 : len = keyvalue_datalen;
3149 : {
3150 : size_t keyvalue_Tag_datalen, keyvalue_Tag_oldlen;
3151 : Der_type keyvalue_Tag_type;
3152 215972 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &keyvalue_Tag_type, UT_OctetString, &keyvalue_Tag_datalen, &l);
3153 215972 : if (e == 0 && keyvalue_Tag_type != PRIM) { e = ASN1_BAD_ID; }
3154 215972 : if(e) goto fail;
3155 215972 : p += l; len -= l; ret += l;
3156 215972 : keyvalue_Tag_oldlen = len;
3157 215972 : if (keyvalue_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3158 215972 : len = keyvalue_Tag_datalen;
3159 215972 : e = der_get_octet_string(p, len, &(data)->keyvalue, &l);
3160 215972 : if(e) goto fail;
3161 215972 : p += l; len -= l; ret += l;
3162 215972 : len = keyvalue_Tag_oldlen - keyvalue_Tag_datalen;
3163 : }
3164 215972 : len = keyvalue_oldlen - keyvalue_datalen;
3165 : }
3166 215972 : len = Top_oldlen - Top_datalen;
3167 : }
3168 431944 : if(size) *size = ret;
3169 209458 : return 0;
3170 0 : fail:
3171 0 : free_EncryptionKey(data);
3172 0 : return e;
3173 : }
3174 :
3175 : void ASN1CALL
3176 1318378 : free_EncryptionKey(EncryptionKey *data)
3177 : {
3178 1318378 : free_krb5int32(&(data)->keytype);
3179 1318378 : der_free_octet_string(&(data)->keyvalue);
3180 1318378 : }
3181 :
3182 : size_t ASN1CALL
3183 234017 : length_EncryptionKey(const EncryptionKey *data)
3184 : {
3185 234017 : size_t ret = 0;
3186 : {
3187 234017 : size_t Top_tag_oldret = ret;
3188 234017 : ret = 0;
3189 234017 : ret += length_krb5int32(&(data)->keytype);
3190 234017 : ret += 1 + der_length_len (ret);
3191 234017 : ret += Top_tag_oldret;
3192 : }
3193 : {
3194 234017 : size_t Top_tag_oldret = ret;
3195 234017 : ret = 0;
3196 234017 : ret += der_length_octet_string(&(data)->keyvalue);
3197 234017 : ret += 1 + der_length_len (ret);
3198 234017 : ret += 1 + der_length_len (ret);
3199 234017 : ret += Top_tag_oldret;
3200 : }
3201 234017 : ret += 1 + der_length_len (ret);
3202 234017 : return ret;
3203 : }
3204 :
3205 : int ASN1CALL
3206 3904620 : copy_EncryptionKey(const EncryptionKey *from, EncryptionKey *to)
3207 : {
3208 3904620 : memset(to, 0, sizeof(*to));
3209 3904620 : if(copy_krb5int32(&(from)->keytype, &(to)->keytype)) goto fail;
3210 3904620 : if(der_copy_octet_string(&(from)->keyvalue, &(to)->keyvalue)) goto fail;
3211 3799989 : return 0;
3212 0 : fail:
3213 0 : free_EncryptionKey(to);
3214 0 : return ENOMEM;
3215 : }
3216 :
3217 : int ASN1CALL
3218 66016 : encode_TransitedEncoding(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const TransitedEncoding *data, size_t *size)
3219 : {
3220 66016 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
3221 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3222 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
3223 :
3224 : /* contents */
3225 : {
3226 66016 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3227 66016 : ret = 0;
3228 66016 : e = der_put_octet_string(p, len, &(data)->contents, &l);
3229 66016 : if (e) return e;
3230 66016 : p -= l; len -= l; ret += l;
3231 :
3232 66016 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
3233 66016 : if (e) return e;
3234 66016 : p -= l; len -= l; ret += l;
3235 :
3236 66016 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
3237 66016 : if (e) return e;
3238 66016 : p -= l; len -= l; ret += l;
3239 :
3240 66016 : ret += Top_tag_oldret;
3241 : }
3242 : /* tr-type */
3243 : {
3244 66016 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3245 66016 : ret = 0;
3246 66016 : e = encode_krb5int32(p, len, &(data)->tr_type, &l);
3247 66016 : if (e) return e;
3248 66016 : p -= l; len -= l; ret += l;
3249 :
3250 66016 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
3251 66016 : if (e) return e;
3252 66016 : p -= l; len -= l; ret += l;
3253 :
3254 66016 : ret += Top_tag_oldret;
3255 : }
3256 66016 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
3257 66016 : if (e) return e;
3258 66016 : p -= l; len -= l; ret += l;
3259 :
3260 66016 : *size = ret;
3261 66016 : return 0;
3262 : }
3263 :
3264 : int ASN1CALL
3265 62255 : decode_TransitedEncoding(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, TransitedEncoding *data, size_t *size)
3266 : {
3267 62255 : size_t ret = 0;
3268 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3269 : int e HEIMDAL_UNUSED_ATTRIBUTE;
3270 :
3271 62255 : memset(data, 0, sizeof(*data));
3272 : {
3273 : size_t Top_datalen, Top_oldlen;
3274 : Der_type Top_type;
3275 62255 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
3276 62255 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
3277 62255 : if(e) goto fail;
3278 62255 : p += l; len -= l; ret += l;
3279 62255 : Top_oldlen = len;
3280 62255 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3281 62255 : len = Top_datalen;
3282 : {
3283 : size_t tr_type_datalen, tr_type_oldlen;
3284 : Der_type tr_type_type;
3285 62255 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &tr_type_type, 0, &tr_type_datalen, &l);
3286 62255 : if (e == 0 && tr_type_type != CONS) { e = ASN1_BAD_ID; }
3287 62255 : if(e) goto fail;
3288 62255 : p += l; len -= l; ret += l;
3289 62255 : tr_type_oldlen = len;
3290 62255 : if (tr_type_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3291 62255 : len = tr_type_datalen;
3292 62255 : e = decode_krb5int32(p, len, &(data)->tr_type, &l);
3293 62255 : if(e) goto fail;
3294 62255 : p += l; len -= l; ret += l;
3295 62255 : len = tr_type_oldlen - tr_type_datalen;
3296 : }
3297 : {
3298 : size_t contents_datalen, contents_oldlen;
3299 : Der_type contents_type;
3300 62255 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &contents_type, 1, &contents_datalen, &l);
3301 122683 : if (e == 0 && contents_type != CONS) { e = ASN1_BAD_ID; }
3302 62255 : if(e) goto fail;
3303 62255 : p += l; len -= l; ret += l;
3304 62255 : contents_oldlen = len;
3305 62255 : if (contents_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3306 62255 : len = contents_datalen;
3307 : {
3308 : size_t contents_Tag_datalen, contents_Tag_oldlen;
3309 : Der_type contents_Tag_type;
3310 62255 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &contents_Tag_type, UT_OctetString, &contents_Tag_datalen, &l);
3311 62255 : if (e == 0 && contents_Tag_type != PRIM) { e = ASN1_BAD_ID; }
3312 62255 : if(e) goto fail;
3313 62255 : p += l; len -= l; ret += l;
3314 62255 : contents_Tag_oldlen = len;
3315 62255 : if (contents_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3316 62255 : len = contents_Tag_datalen;
3317 62255 : e = der_get_octet_string(p, len, &(data)->contents, &l);
3318 62255 : if(e) goto fail;
3319 62255 : p += l; len -= l; ret += l;
3320 62255 : len = contents_Tag_oldlen - contents_Tag_datalen;
3321 : }
3322 62255 : len = contents_oldlen - contents_datalen;
3323 : }
3324 62255 : len = Top_oldlen - Top_datalen;
3325 : }
3326 124510 : if(size) *size = ret;
3327 60428 : return 0;
3328 0 : fail:
3329 0 : free_TransitedEncoding(data);
3330 0 : return e;
3331 : }
3332 :
3333 : void ASN1CALL
3334 190650 : free_TransitedEncoding(TransitedEncoding *data)
3335 : {
3336 190650 : free_krb5int32(&(data)->tr_type);
3337 190650 : der_free_octet_string(&(data)->contents);
3338 190650 : }
3339 :
3340 : size_t ASN1CALL
3341 66016 : length_TransitedEncoding(const TransitedEncoding *data)
3342 : {
3343 66016 : size_t ret = 0;
3344 : {
3345 66016 : size_t Top_tag_oldret = ret;
3346 66016 : ret = 0;
3347 66016 : ret += length_krb5int32(&(data)->tr_type);
3348 66016 : ret += 1 + der_length_len (ret);
3349 66016 : ret += Top_tag_oldret;
3350 : }
3351 : {
3352 66016 : size_t Top_tag_oldret = ret;
3353 66016 : ret = 0;
3354 66016 : ret += der_length_octet_string(&(data)->contents);
3355 66016 : ret += 1 + der_length_len (ret);
3356 66016 : ret += 1 + der_length_len (ret);
3357 66016 : ret += Top_tag_oldret;
3358 : }
3359 66016 : ret += 1 + der_length_len (ret);
3360 66016 : return ret;
3361 : }
3362 :
3363 : int ASN1CALL
3364 21505 : copy_TransitedEncoding(const TransitedEncoding *from, TransitedEncoding *to)
3365 : {
3366 21505 : memset(to, 0, sizeof(*to));
3367 21505 : if(copy_krb5int32(&(from)->tr_type, &(to)->tr_type)) goto fail;
3368 21505 : if(der_copy_octet_string(&(from)->contents, &(to)->contents)) goto fail;
3369 20767 : return 0;
3370 0 : fail:
3371 0 : free_TransitedEncoding(to);
3372 0 : return ENOMEM;
3373 : }
3374 :
3375 : int ASN1CALL
3376 225273 : encode_Ticket(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const Ticket *data, size_t *size)
3377 : {
3378 225273 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
3379 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3380 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
3381 :
3382 : /* enc-part */
3383 : {
3384 225273 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3385 225273 : ret = 0;
3386 225273 : e = encode_EncryptedData(p, len, &(data)->enc_part, &l);
3387 225273 : if (e) return e;
3388 225273 : p -= l; len -= l; ret += l;
3389 :
3390 225273 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
3391 225273 : if (e) return e;
3392 225273 : p -= l; len -= l; ret += l;
3393 :
3394 225273 : ret += Top_tag_tag_oldret;
3395 : }
3396 : /* sname */
3397 : {
3398 225273 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3399 225273 : ret = 0;
3400 225273 : e = encode_PrincipalName(p, len, &(data)->sname, &l);
3401 225273 : if (e) return e;
3402 225273 : p -= l; len -= l; ret += l;
3403 :
3404 225273 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
3405 225273 : if (e) return e;
3406 225273 : p -= l; len -= l; ret += l;
3407 :
3408 225273 : ret += Top_tag_tag_oldret;
3409 : }
3410 : /* realm */
3411 : {
3412 225273 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3413 225273 : ret = 0;
3414 225273 : e = encode_Realm(p, len, &(data)->realm, &l);
3415 225273 : if (e) return e;
3416 225273 : p -= l; len -= l; ret += l;
3417 :
3418 225273 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
3419 225273 : if (e) return e;
3420 225273 : p -= l; len -= l; ret += l;
3421 :
3422 225273 : ret += Top_tag_tag_oldret;
3423 : }
3424 : /* tkt-vno */
3425 : {
3426 225273 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3427 225273 : ret = 0;
3428 225273 : e = encode_krb5int32(p, len, &(data)->tkt_vno, &l);
3429 225273 : if (e) return e;
3430 225273 : p -= l; len -= l; ret += l;
3431 :
3432 225273 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
3433 225273 : if (e) return e;
3434 225273 : p -= l; len -= l; ret += l;
3435 :
3436 225273 : ret += Top_tag_tag_oldret;
3437 : }
3438 225273 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
3439 225273 : if (e) return e;
3440 225273 : p -= l; len -= l; ret += l;
3441 :
3442 225273 : e = der_put_length_and_tag (p, len, ret, ASN1_C_APPL, CONS, 1, &l);
3443 225273 : if (e) return e;
3444 225273 : p -= l; len -= l; ret += l;
3445 :
3446 225273 : *size = ret;
3447 225273 : return 0;
3448 : }
3449 :
3450 : int ASN1CALL
3451 234293 : decode_Ticket(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, Ticket *data, size_t *size)
3452 : {
3453 234293 : size_t ret = 0;
3454 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3455 : int e HEIMDAL_UNUSED_ATTRIBUTE;
3456 :
3457 234293 : memset(data, 0, sizeof(*data));
3458 : {
3459 : size_t Top_datalen, Top_oldlen;
3460 : Der_type Top_type;
3461 234293 : e = der_match_tag_and_length(p, len, ASN1_C_APPL, &Top_type, 1, &Top_datalen, &l);
3462 234293 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
3463 234293 : if(e) goto fail;
3464 234293 : p += l; len -= l; ret += l;
3465 234293 : Top_oldlen = len;
3466 234293 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3467 234293 : len = Top_datalen;
3468 : {
3469 : size_t Top_Tag_datalen, Top_Tag_oldlen;
3470 : Der_type Top_Tag_type;
3471 234293 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_Tag_type, UT_Sequence, &Top_Tag_datalen, &l);
3472 234293 : if (e == 0 && Top_Tag_type != CONS) { e = ASN1_BAD_ID; }
3473 234293 : if(e) goto fail;
3474 234293 : p += l; len -= l; ret += l;
3475 234293 : Top_Tag_oldlen = len;
3476 234293 : if (Top_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3477 234293 : len = Top_Tag_datalen;
3478 : {
3479 : size_t tkt_vno_datalen, tkt_vno_oldlen;
3480 : Der_type tkt_vno_type;
3481 234293 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &tkt_vno_type, 0, &tkt_vno_datalen, &l);
3482 234293 : if (e == 0 && tkt_vno_type != CONS) { e = ASN1_BAD_ID; }
3483 234293 : if(e) goto fail;
3484 234293 : p += l; len -= l; ret += l;
3485 234293 : tkt_vno_oldlen = len;
3486 234293 : if (tkt_vno_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3487 234293 : len = tkt_vno_datalen;
3488 234293 : e = decode_krb5int32(p, len, &(data)->tkt_vno, &l);
3489 234293 : if(e) goto fail;
3490 234293 : p += l; len -= l; ret += l;
3491 234293 : len = tkt_vno_oldlen - tkt_vno_datalen;
3492 : }
3493 : {
3494 : size_t realm_datalen, realm_oldlen;
3495 : Der_type realm_type;
3496 234293 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &realm_type, 1, &realm_datalen, &l);
3497 462048 : if (e == 0 && realm_type != CONS) { e = ASN1_BAD_ID; }
3498 234293 : if(e) goto fail;
3499 234293 : p += l; len -= l; ret += l;
3500 234293 : realm_oldlen = len;
3501 234293 : if (realm_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3502 234293 : len = realm_datalen;
3503 234293 : e = decode_Realm(p, len, &(data)->realm, &l);
3504 234293 : if(e) goto fail;
3505 234293 : p += l; len -= l; ret += l;
3506 234293 : len = realm_oldlen - realm_datalen;
3507 : }
3508 : {
3509 : size_t sname_datalen, sname_oldlen;
3510 : Der_type sname_type;
3511 234293 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &sname_type, 2, &sname_datalen, &l);
3512 462048 : if (e == 0 && sname_type != CONS) { e = ASN1_BAD_ID; }
3513 234293 : if(e) goto fail;
3514 234293 : p += l; len -= l; ret += l;
3515 234293 : sname_oldlen = len;
3516 234293 : if (sname_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3517 234293 : len = sname_datalen;
3518 234293 : e = decode_PrincipalName(p, len, &(data)->sname, &l);
3519 234293 : if(e) goto fail;
3520 234293 : p += l; len -= l; ret += l;
3521 234293 : len = sname_oldlen - sname_datalen;
3522 : }
3523 : {
3524 : size_t enc_part_datalen, enc_part_oldlen;
3525 : Der_type enc_part_type;
3526 234293 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &enc_part_type, 3, &enc_part_datalen, &l);
3527 462048 : if (e == 0 && enc_part_type != CONS) { e = ASN1_BAD_ID; }
3528 234293 : if(e) goto fail;
3529 234293 : p += l; len -= l; ret += l;
3530 234293 : enc_part_oldlen = len;
3531 234293 : if (enc_part_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3532 234293 : len = enc_part_datalen;
3533 234293 : e = decode_EncryptedData(p, len, &(data)->enc_part, &l);
3534 234293 : if(e) goto fail;
3535 234293 : p += l; len -= l; ret += l;
3536 234293 : len = enc_part_oldlen - enc_part_datalen;
3537 : }
3538 234293 : len = Top_Tag_oldlen - Top_Tag_datalen;
3539 : }
3540 234293 : len = Top_oldlen - Top_datalen;
3541 : }
3542 468508 : if(size) *size = ret;
3543 227755 : return 0;
3544 0 : fail:
3545 0 : free_Ticket(data);
3546 0 : return e;
3547 : }
3548 :
3549 : void ASN1CALL
3550 423964 : free_Ticket(Ticket *data)
3551 : {
3552 423964 : free_krb5int32(&(data)->tkt_vno);
3553 423964 : free_Realm(&(data)->realm);
3554 423964 : free_PrincipalName(&(data)->sname);
3555 423964 : free_EncryptedData(&(data)->enc_part);
3556 423964 : }
3557 :
3558 : size_t ASN1CALL
3559 225273 : length_Ticket(const Ticket *data)
3560 : {
3561 225273 : size_t ret = 0;
3562 : {
3563 225273 : size_t Top_tag_tag_oldret = ret;
3564 225273 : ret = 0;
3565 225273 : ret += length_krb5int32(&(data)->tkt_vno);
3566 225273 : ret += 1 + der_length_len (ret);
3567 225273 : ret += Top_tag_tag_oldret;
3568 : }
3569 : {
3570 225273 : size_t Top_tag_tag_oldret = ret;
3571 225273 : ret = 0;
3572 225273 : ret += length_Realm(&(data)->realm);
3573 225273 : ret += 1 + der_length_len (ret);
3574 225273 : ret += Top_tag_tag_oldret;
3575 : }
3576 : {
3577 225273 : size_t Top_tag_tag_oldret = ret;
3578 225273 : ret = 0;
3579 225273 : ret += length_PrincipalName(&(data)->sname);
3580 225273 : ret += 1 + der_length_len (ret);
3581 225273 : ret += Top_tag_tag_oldret;
3582 : }
3583 : {
3584 225273 : size_t Top_tag_tag_oldret = ret;
3585 225273 : ret = 0;
3586 225273 : ret += length_EncryptedData(&(data)->enc_part);
3587 225273 : ret += 1 + der_length_len (ret);
3588 225273 : ret += Top_tag_tag_oldret;
3589 : }
3590 225273 : ret += 1 + der_length_len (ret);
3591 225273 : ret += 1 + der_length_len (ret);
3592 225273 : return ret;
3593 : }
3594 :
3595 : int ASN1CALL
3596 42 : copy_Ticket(const Ticket *from, Ticket *to)
3597 : {
3598 42 : memset(to, 0, sizeof(*to));
3599 42 : if(copy_krb5int32(&(from)->tkt_vno, &(to)->tkt_vno)) goto fail;
3600 42 : if(copy_Realm(&(from)->realm, &(to)->realm)) goto fail;
3601 42 : if(copy_PrincipalName(&(from)->sname, &(to)->sname)) goto fail;
3602 42 : if(copy_EncryptedData(&(from)->enc_part, &(to)->enc_part)) goto fail;
3603 42 : return 0;
3604 0 : fail:
3605 0 : free_Ticket(to);
3606 0 : return ENOMEM;
3607 : }
3608 :
3609 : int ASN1CALL
3610 66016 : encode_EncTicketPart(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const EncTicketPart *data, size_t *size)
3611 : {
3612 66016 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
3613 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3614 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
3615 :
3616 : /* authorization-data */
3617 66016 : if((data)->authorization_data) {
3618 66016 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3619 66016 : ret = 0;
3620 66016 : e = encode_AuthorizationData(p, len, (data)->authorization_data, &l);
3621 66016 : if (e) return e;
3622 66016 : p -= l; len -= l; ret += l;
3623 :
3624 66016 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 10, &l);
3625 66016 : if (e) return e;
3626 66016 : p -= l; len -= l; ret += l;
3627 :
3628 66016 : ret += Top_tag_tag_oldret;
3629 : }
3630 : /* caddr */
3631 66016 : if((data)->caddr) {
3632 169 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3633 169 : ret = 0;
3634 169 : e = encode_HostAddresses(p, len, (data)->caddr, &l);
3635 169 : if (e) return e;
3636 169 : p -= l; len -= l; ret += l;
3637 :
3638 169 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 9, &l);
3639 169 : if (e) return e;
3640 169 : p -= l; len -= l; ret += l;
3641 :
3642 169 : ret += Top_tag_tag_oldret;
3643 : }
3644 : /* renew-till */
3645 66016 : if((data)->renew_till) {
3646 170 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3647 170 : ret = 0;
3648 170 : e = encode_KerberosTime(p, len, (data)->renew_till, &l);
3649 170 : if (e) return e;
3650 170 : p -= l; len -= l; ret += l;
3651 :
3652 170 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 8, &l);
3653 170 : if (e) return e;
3654 170 : p -= l; len -= l; ret += l;
3655 :
3656 170 : ret += Top_tag_tag_oldret;
3657 : }
3658 : /* endtime */
3659 : {
3660 66016 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3661 66016 : ret = 0;
3662 66016 : e = encode_KerberosTime(p, len, &(data)->endtime, &l);
3663 66016 : if (e) return e;
3664 66016 : p -= l; len -= l; ret += l;
3665 :
3666 66016 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 7, &l);
3667 66016 : if (e) return e;
3668 66016 : p -= l; len -= l; ret += l;
3669 :
3670 66016 : ret += Top_tag_tag_oldret;
3671 : }
3672 : /* starttime */
3673 66016 : if((data)->starttime) {
3674 39673 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3675 39673 : ret = 0;
3676 39673 : e = encode_KerberosTime(p, len, (data)->starttime, &l);
3677 39673 : if (e) return e;
3678 39673 : p -= l; len -= l; ret += l;
3679 :
3680 39673 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 6, &l);
3681 39673 : if (e) return e;
3682 39673 : p -= l; len -= l; ret += l;
3683 :
3684 39673 : ret += Top_tag_tag_oldret;
3685 : }
3686 : /* authtime */
3687 : {
3688 66016 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3689 66016 : ret = 0;
3690 66016 : e = encode_KerberosTime(p, len, &(data)->authtime, &l);
3691 66016 : if (e) return e;
3692 66016 : p -= l; len -= l; ret += l;
3693 :
3694 66016 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 5, &l);
3695 66016 : if (e) return e;
3696 66016 : p -= l; len -= l; ret += l;
3697 :
3698 66016 : ret += Top_tag_tag_oldret;
3699 : }
3700 : /* transited */
3701 : {
3702 66016 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3703 66016 : ret = 0;
3704 66016 : e = encode_TransitedEncoding(p, len, &(data)->transited, &l);
3705 66016 : if (e) return e;
3706 66016 : p -= l; len -= l; ret += l;
3707 :
3708 66016 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 4, &l);
3709 66016 : if (e) return e;
3710 66016 : p -= l; len -= l; ret += l;
3711 :
3712 66016 : ret += Top_tag_tag_oldret;
3713 : }
3714 : /* cname */
3715 : {
3716 66016 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3717 66016 : ret = 0;
3718 66016 : e = encode_PrincipalName(p, len, &(data)->cname, &l);
3719 66016 : if (e) return e;
3720 66016 : p -= l; len -= l; ret += l;
3721 :
3722 66016 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
3723 66016 : if (e) return e;
3724 66016 : p -= l; len -= l; ret += l;
3725 :
3726 66016 : ret += Top_tag_tag_oldret;
3727 : }
3728 : /* crealm */
3729 : {
3730 66016 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3731 66016 : ret = 0;
3732 66016 : e = encode_Realm(p, len, &(data)->crealm, &l);
3733 66016 : if (e) return e;
3734 66016 : p -= l; len -= l; ret += l;
3735 :
3736 66016 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
3737 66016 : if (e) return e;
3738 66016 : p -= l; len -= l; ret += l;
3739 :
3740 66016 : ret += Top_tag_tag_oldret;
3741 : }
3742 : /* key */
3743 : {
3744 66016 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3745 66016 : ret = 0;
3746 66016 : e = encode_EncryptionKey(p, len, &(data)->key, &l);
3747 66016 : if (e) return e;
3748 66016 : p -= l; len -= l; ret += l;
3749 :
3750 66016 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
3751 66016 : if (e) return e;
3752 66016 : p -= l; len -= l; ret += l;
3753 :
3754 66016 : ret += Top_tag_tag_oldret;
3755 : }
3756 : /* flags */
3757 : {
3758 66016 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3759 66016 : ret = 0;
3760 66016 : e = encode_TicketFlags(p, len, &(data)->flags, &l);
3761 66016 : if (e) return e;
3762 66016 : p -= l; len -= l; ret += l;
3763 :
3764 66016 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
3765 66016 : if (e) return e;
3766 66016 : p -= l; len -= l; ret += l;
3767 :
3768 66016 : ret += Top_tag_tag_oldret;
3769 : }
3770 66016 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
3771 66016 : if (e) return e;
3772 66016 : p -= l; len -= l; ret += l;
3773 :
3774 66016 : e = der_put_length_and_tag (p, len, ret, ASN1_C_APPL, CONS, 3, &l);
3775 66016 : if (e) return e;
3776 66016 : p -= l; len -= l; ret += l;
3777 :
3778 66016 : *size = ret;
3779 66016 : return 0;
3780 : }
3781 :
3782 : int ASN1CALL
3783 62255 : decode_EncTicketPart(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, EncTicketPart *data, size_t *size)
3784 : {
3785 62255 : size_t ret = 0;
3786 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3787 : int e HEIMDAL_UNUSED_ATTRIBUTE;
3788 :
3789 62255 : memset(data, 0, sizeof(*data));
3790 : {
3791 : size_t Top_datalen, Top_oldlen;
3792 : Der_type Top_type;
3793 62255 : e = der_match_tag_and_length(p, len, ASN1_C_APPL, &Top_type, 3, &Top_datalen, &l);
3794 62255 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
3795 62255 : if(e) goto fail;
3796 62255 : p += l; len -= l; ret += l;
3797 62255 : Top_oldlen = len;
3798 62255 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3799 62255 : len = Top_datalen;
3800 : {
3801 : size_t Top_Tag_datalen, Top_Tag_oldlen;
3802 : Der_type Top_Tag_type;
3803 62255 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_Tag_type, UT_Sequence, &Top_Tag_datalen, &l);
3804 62255 : if (e == 0 && Top_Tag_type != CONS) { e = ASN1_BAD_ID; }
3805 62255 : if(e) goto fail;
3806 62255 : p += l; len -= l; ret += l;
3807 62255 : Top_Tag_oldlen = len;
3808 62255 : if (Top_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3809 62255 : len = Top_Tag_datalen;
3810 : {
3811 : size_t flags_datalen, flags_oldlen;
3812 : Der_type flags_type;
3813 62255 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &flags_type, 0, &flags_datalen, &l);
3814 62255 : if (e == 0 && flags_type != CONS) { e = ASN1_BAD_ID; }
3815 62255 : if(e) goto fail;
3816 62255 : p += l; len -= l; ret += l;
3817 62255 : flags_oldlen = len;
3818 62255 : if (flags_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3819 62255 : len = flags_datalen;
3820 62255 : e = decode_TicketFlags(p, len, &(data)->flags, &l);
3821 62255 : if(e) goto fail;
3822 62255 : p += l; len -= l; ret += l;
3823 62255 : len = flags_oldlen - flags_datalen;
3824 : }
3825 : {
3826 : size_t key_datalen, key_oldlen;
3827 : Der_type key_type;
3828 62255 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &key_type, 1, &key_datalen, &l);
3829 122683 : if (e == 0 && key_type != CONS) { e = ASN1_BAD_ID; }
3830 62255 : if(e) goto fail;
3831 62255 : p += l; len -= l; ret += l;
3832 62255 : key_oldlen = len;
3833 62255 : if (key_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3834 62255 : len = key_datalen;
3835 62255 : e = decode_EncryptionKey(p, len, &(data)->key, &l);
3836 62255 : if(e) goto fail;
3837 62255 : p += l; len -= l; ret += l;
3838 62255 : len = key_oldlen - key_datalen;
3839 : }
3840 : {
3841 : size_t crealm_datalen, crealm_oldlen;
3842 : Der_type crealm_type;
3843 62255 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &crealm_type, 2, &crealm_datalen, &l);
3844 122683 : if (e == 0 && crealm_type != CONS) { e = ASN1_BAD_ID; }
3845 62255 : if(e) goto fail;
3846 62255 : p += l; len -= l; ret += l;
3847 62255 : crealm_oldlen = len;
3848 62255 : if (crealm_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3849 62255 : len = crealm_datalen;
3850 62255 : e = decode_Realm(p, len, &(data)->crealm, &l);
3851 62255 : if(e) goto fail;
3852 62255 : p += l; len -= l; ret += l;
3853 62255 : len = crealm_oldlen - crealm_datalen;
3854 : }
3855 : {
3856 : size_t cname_datalen, cname_oldlen;
3857 : Der_type cname_type;
3858 62255 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &cname_type, 3, &cname_datalen, &l);
3859 122683 : if (e == 0 && cname_type != CONS) { e = ASN1_BAD_ID; }
3860 62255 : if(e) goto fail;
3861 62255 : p += l; len -= l; ret += l;
3862 62255 : cname_oldlen = len;
3863 62255 : if (cname_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3864 62255 : len = cname_datalen;
3865 62255 : e = decode_PrincipalName(p, len, &(data)->cname, &l);
3866 62255 : if(e) goto fail;
3867 62255 : p += l; len -= l; ret += l;
3868 62255 : len = cname_oldlen - cname_datalen;
3869 : }
3870 : {
3871 : size_t transited_datalen, transited_oldlen;
3872 : Der_type transited_type;
3873 62255 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &transited_type, 4, &transited_datalen, &l);
3874 122683 : if (e == 0 && transited_type != CONS) { e = ASN1_BAD_ID; }
3875 62255 : if(e) goto fail;
3876 62255 : p += l; len -= l; ret += l;
3877 62255 : transited_oldlen = len;
3878 62255 : if (transited_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3879 62255 : len = transited_datalen;
3880 62255 : e = decode_TransitedEncoding(p, len, &(data)->transited, &l);
3881 62255 : if(e) goto fail;
3882 62255 : p += l; len -= l; ret += l;
3883 62255 : len = transited_oldlen - transited_datalen;
3884 : }
3885 : {
3886 : size_t authtime_datalen, authtime_oldlen;
3887 : Der_type authtime_type;
3888 62255 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &authtime_type, 5, &authtime_datalen, &l);
3889 122683 : if (e == 0 && authtime_type != CONS) { e = ASN1_BAD_ID; }
3890 62255 : if(e) goto fail;
3891 62255 : p += l; len -= l; ret += l;
3892 62255 : authtime_oldlen = len;
3893 62255 : if (authtime_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3894 62255 : len = authtime_datalen;
3895 62255 : e = decode_KerberosTime(p, len, &(data)->authtime, &l);
3896 62255 : if(e) goto fail;
3897 62255 : p += l; len -= l; ret += l;
3898 62255 : len = authtime_oldlen - authtime_datalen;
3899 : }
3900 : {
3901 : size_t starttime_datalen, starttime_oldlen;
3902 : Der_type starttime_type;
3903 62255 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &starttime_type, 6, &starttime_datalen, &l);
3904 90846 : if (e == 0 && starttime_type != CONS) { e = ASN1_BAD_ID; }
3905 62255 : if(e) {
3906 32926 : (data)->starttime = NULL;
3907 : } else {
3908 29329 : (data)->starttime = calloc(1, sizeof(*(data)->starttime));
3909 29329 : if ((data)->starttime == NULL) { e = ENOMEM; goto fail; }
3910 29329 : p += l; len -= l; ret += l;
3911 29329 : starttime_oldlen = len;
3912 29329 : if (starttime_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3913 29329 : len = starttime_datalen;
3914 29329 : e = decode_KerberosTime(p, len, (data)->starttime, &l);
3915 29329 : if(e) goto fail;
3916 29329 : p += l; len -= l; ret += l;
3917 29329 : len = starttime_oldlen - starttime_datalen;
3918 : }
3919 : }
3920 : {
3921 : size_t endtime_datalen, endtime_oldlen;
3922 : Der_type endtime_type;
3923 62255 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &endtime_type, 7, &endtime_datalen, &l);
3924 124510 : if (e == 0 && endtime_type != CONS) { e = ASN1_BAD_ID; }
3925 62255 : if(e) goto fail;
3926 62255 : p += l; len -= l; ret += l;
3927 62255 : endtime_oldlen = len;
3928 62255 : if (endtime_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3929 62255 : len = endtime_datalen;
3930 62255 : e = decode_KerberosTime(p, len, &(data)->endtime, &l);
3931 62255 : if(e) goto fail;
3932 62255 : p += l; len -= l; ret += l;
3933 62255 : len = endtime_oldlen - endtime_datalen;
3934 : }
3935 : {
3936 : size_t renew_till_datalen, renew_till_oldlen;
3937 : Der_type renew_till_type;
3938 62255 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &renew_till_type, 8, &renew_till_datalen, &l);
3939 62443 : if (e == 0 && renew_till_type != CONS) { e = ASN1_BAD_ID; }
3940 62255 : if(e) {
3941 62067 : (data)->renew_till = NULL;
3942 : } else {
3943 188 : (data)->renew_till = calloc(1, sizeof(*(data)->renew_till));
3944 188 : if ((data)->renew_till == NULL) { e = ENOMEM; goto fail; }
3945 188 : p += l; len -= l; ret += l;
3946 188 : renew_till_oldlen = len;
3947 188 : if (renew_till_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3948 188 : len = renew_till_datalen;
3949 188 : e = decode_KerberosTime(p, len, (data)->renew_till, &l);
3950 188 : if(e) goto fail;
3951 188 : p += l; len -= l; ret += l;
3952 188 : len = renew_till_oldlen - renew_till_datalen;
3953 : }
3954 : }
3955 : {
3956 : size_t caddr_datalen, caddr_oldlen;
3957 : Der_type caddr_type;
3958 62255 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &caddr_type, 9, &caddr_datalen, &l);
3959 62332 : if (e == 0 && caddr_type != CONS) { e = ASN1_BAD_ID; }
3960 62255 : if(e) {
3961 62178 : (data)->caddr = NULL;
3962 : } else {
3963 77 : (data)->caddr = calloc(1, sizeof(*(data)->caddr));
3964 77 : if ((data)->caddr == NULL) { e = ENOMEM; goto fail; }
3965 77 : p += l; len -= l; ret += l;
3966 77 : caddr_oldlen = len;
3967 77 : if (caddr_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3968 77 : len = caddr_datalen;
3969 77 : e = decode_HostAddresses(p, len, (data)->caddr, &l);
3970 77 : if(e) goto fail;
3971 77 : p += l; len -= l; ret += l;
3972 77 : len = caddr_oldlen - caddr_datalen;
3973 : }
3974 : }
3975 : {
3976 : size_t authorization_data_datalen, authorization_data_oldlen;
3977 : Der_type authorization_data_type;
3978 62255 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &authorization_data_type, 10, &authorization_data_datalen, &l);
3979 124510 : if (e == 0 && authorization_data_type != CONS) { e = ASN1_BAD_ID; }
3980 62255 : if(e) {
3981 0 : (data)->authorization_data = NULL;
3982 : } else {
3983 62255 : (data)->authorization_data = calloc(1, sizeof(*(data)->authorization_data));
3984 62255 : if ((data)->authorization_data == NULL) { e = ENOMEM; goto fail; }
3985 62255 : p += l; len -= l; ret += l;
3986 62255 : authorization_data_oldlen = len;
3987 62255 : if (authorization_data_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3988 62255 : len = authorization_data_datalen;
3989 62255 : e = decode_AuthorizationData(p, len, (data)->authorization_data, &l);
3990 62255 : if(e) goto fail;
3991 62255 : p += l; len -= l; ret += l;
3992 62255 : len = authorization_data_oldlen - authorization_data_datalen;
3993 : }
3994 : }
3995 62255 : len = Top_Tag_oldlen - Top_Tag_datalen;
3996 : }
3997 62255 : len = Top_oldlen - Top_datalen;
3998 : }
3999 124510 : if(size) *size = ret;
4000 60428 : return 0;
4001 0 : fail:
4002 0 : free_EncTicketPart(data);
4003 0 : return e;
4004 : }
4005 :
4006 : void ASN1CALL
4007 150779 : free_EncTicketPart(EncTicketPart *data)
4008 : {
4009 150779 : free_TicketFlags(&(data)->flags);
4010 150779 : free_EncryptionKey(&(data)->key);
4011 150779 : free_Realm(&(data)->crealm);
4012 150779 : free_PrincipalName(&(data)->cname);
4013 150779 : free_TransitedEncoding(&(data)->transited);
4014 150779 : free_KerberosTime(&(data)->authtime);
4015 150779 : if((data)->starttime) {
4016 50823 : free_KerberosTime((data)->starttime);
4017 50823 : free((data)->starttime);
4018 50823 : (data)->starttime = NULL;
4019 : }
4020 150779 : free_KerberosTime(&(data)->endtime);
4021 150779 : if((data)->renew_till) {
4022 328 : free_KerberosTime((data)->renew_till);
4023 328 : free((data)->renew_till);
4024 328 : (data)->renew_till = NULL;
4025 : }
4026 150779 : if((data)->caddr) {
4027 181 : free_HostAddresses((data)->caddr);
4028 181 : free((data)->caddr);
4029 181 : (data)->caddr = NULL;
4030 : }
4031 150779 : if((data)->authorization_data) {
4032 110118 : free_AuthorizationData((data)->authorization_data);
4033 110118 : free((data)->authorization_data);
4034 110118 : (data)->authorization_data = NULL;
4035 : }
4036 150779 : }
4037 :
4038 : size_t ASN1CALL
4039 66016 : length_EncTicketPart(const EncTicketPart *data)
4040 : {
4041 66016 : size_t ret = 0;
4042 : {
4043 66016 : size_t Top_tag_tag_oldret = ret;
4044 66016 : ret = 0;
4045 66016 : ret += length_TicketFlags(&(data)->flags);
4046 66016 : ret += 1 + der_length_len (ret);
4047 66016 : ret += Top_tag_tag_oldret;
4048 : }
4049 : {
4050 66016 : size_t Top_tag_tag_oldret = ret;
4051 66016 : ret = 0;
4052 66016 : ret += length_EncryptionKey(&(data)->key);
4053 66016 : ret += 1 + der_length_len (ret);
4054 66016 : ret += Top_tag_tag_oldret;
4055 : }
4056 : {
4057 66016 : size_t Top_tag_tag_oldret = ret;
4058 66016 : ret = 0;
4059 66016 : ret += length_Realm(&(data)->crealm);
4060 66016 : ret += 1 + der_length_len (ret);
4061 66016 : ret += Top_tag_tag_oldret;
4062 : }
4063 : {
4064 66016 : size_t Top_tag_tag_oldret = ret;
4065 66016 : ret = 0;
4066 66016 : ret += length_PrincipalName(&(data)->cname);
4067 66016 : ret += 1 + der_length_len (ret);
4068 66016 : ret += Top_tag_tag_oldret;
4069 : }
4070 : {
4071 66016 : size_t Top_tag_tag_oldret = ret;
4072 66016 : ret = 0;
4073 66016 : ret += length_TransitedEncoding(&(data)->transited);
4074 66016 : ret += 1 + der_length_len (ret);
4075 66016 : ret += Top_tag_tag_oldret;
4076 : }
4077 : {
4078 66016 : size_t Top_tag_tag_oldret = ret;
4079 66016 : ret = 0;
4080 66016 : ret += length_KerberosTime(&(data)->authtime);
4081 66016 : ret += 1 + der_length_len (ret);
4082 66016 : ret += Top_tag_tag_oldret;
4083 : }
4084 66016 : if((data)->starttime){
4085 39673 : size_t Top_tag_tag_oldret = ret;
4086 39673 : ret = 0;
4087 39673 : ret += length_KerberosTime((data)->starttime);
4088 39673 : ret += 1 + der_length_len (ret);
4089 39673 : ret += Top_tag_tag_oldret;
4090 : }
4091 : {
4092 66016 : size_t Top_tag_tag_oldret = ret;
4093 66016 : ret = 0;
4094 66016 : ret += length_KerberosTime(&(data)->endtime);
4095 66016 : ret += 1 + der_length_len (ret);
4096 66016 : ret += Top_tag_tag_oldret;
4097 : }
4098 66016 : if((data)->renew_till){
4099 170 : size_t Top_tag_tag_oldret = ret;
4100 170 : ret = 0;
4101 170 : ret += length_KerberosTime((data)->renew_till);
4102 170 : ret += 1 + der_length_len (ret);
4103 170 : ret += Top_tag_tag_oldret;
4104 : }
4105 66016 : if((data)->caddr){
4106 169 : size_t Top_tag_tag_oldret = ret;
4107 169 : ret = 0;
4108 169 : ret += length_HostAddresses((data)->caddr);
4109 169 : ret += 1 + der_length_len (ret);
4110 169 : ret += Top_tag_tag_oldret;
4111 : }
4112 66016 : if((data)->authorization_data){
4113 66016 : size_t Top_tag_tag_oldret = ret;
4114 66016 : ret = 0;
4115 66016 : ret += length_AuthorizationData((data)->authorization_data);
4116 66016 : ret += 1 + der_length_len (ret);
4117 66016 : ret += Top_tag_tag_oldret;
4118 : }
4119 66016 : ret += 1 + der_length_len (ret);
4120 66016 : ret += 1 + der_length_len (ret);
4121 66016 : return ret;
4122 : }
4123 :
4124 : int ASN1CALL
4125 21505 : copy_EncTicketPart(const EncTicketPart *from, EncTicketPart *to)
4126 : {
4127 21505 : memset(to, 0, sizeof(*to));
4128 21505 : if(copy_TicketFlags(&(from)->flags, &(to)->flags)) goto fail;
4129 21505 : if(copy_EncryptionKey(&(from)->key, &(to)->key)) goto fail;
4130 21505 : if(copy_Realm(&(from)->crealm, &(to)->crealm)) goto fail;
4131 21505 : if(copy_PrincipalName(&(from)->cname, &(to)->cname)) goto fail;
4132 21505 : if(copy_TransitedEncoding(&(from)->transited, &(to)->transited)) goto fail;
4133 21505 : if(copy_KerberosTime(&(from)->authtime, &(to)->authtime)) goto fail;
4134 21505 : if((from)->starttime) {
4135 21479 : (to)->starttime = malloc(sizeof(*(to)->starttime));
4136 21479 : if((to)->starttime == NULL) goto fail;
4137 21479 : if(copy_KerberosTime((from)->starttime, (to)->starttime)) goto fail;
4138 : }else
4139 26 : (to)->starttime = NULL;
4140 21505 : if(copy_KerberosTime(&(from)->endtime, &(to)->endtime)) goto fail;
4141 21505 : if((from)->renew_till) {
4142 0 : (to)->renew_till = malloc(sizeof(*(to)->renew_till));
4143 0 : if((to)->renew_till == NULL) goto fail;
4144 0 : if(copy_KerberosTime((from)->renew_till, (to)->renew_till)) goto fail;
4145 : }else
4146 21505 : (to)->renew_till = NULL;
4147 21505 : if((from)->caddr) {
4148 6 : (to)->caddr = malloc(sizeof(*(to)->caddr));
4149 6 : if((to)->caddr == NULL) goto fail;
4150 6 : if(copy_HostAddresses((from)->caddr, (to)->caddr)) goto fail;
4151 : }else
4152 21499 : (to)->caddr = NULL;
4153 21505 : if((from)->authorization_data) {
4154 21505 : (to)->authorization_data = malloc(sizeof(*(to)->authorization_data));
4155 21505 : if((to)->authorization_data == NULL) goto fail;
4156 21505 : if(copy_AuthorizationData((from)->authorization_data, (to)->authorization_data)) goto fail;
4157 : }else
4158 0 : (to)->authorization_data = NULL;
4159 20767 : return 0;
4160 0 : fail:
4161 0 : free_EncTicketPart(to);
4162 0 : return ENOMEM;
4163 : }
4164 :
4165 : int ASN1CALL
4166 133666 : encode_Checksum(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const Checksum *data, size_t *size)
4167 : {
4168 133666 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
4169 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
4170 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
4171 :
4172 : /* checksum */
4173 : {
4174 133666 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4175 133666 : ret = 0;
4176 133666 : e = der_put_octet_string(p, len, &(data)->checksum, &l);
4177 133666 : if (e) return e;
4178 133666 : p -= l; len -= l; ret += l;
4179 :
4180 133666 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
4181 133666 : if (e) return e;
4182 133666 : p -= l; len -= l; ret += l;
4183 :
4184 133666 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
4185 133666 : if (e) return e;
4186 133666 : p -= l; len -= l; ret += l;
4187 :
4188 133666 : ret += Top_tag_oldret;
4189 : }
4190 : /* cksumtype */
4191 : {
4192 133666 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4193 133666 : ret = 0;
4194 133666 : e = encode_CKSUMTYPE(p, len, &(data)->cksumtype, &l);
4195 133666 : if (e) return e;
4196 133666 : p -= l; len -= l; ret += l;
4197 :
4198 133666 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
4199 133666 : if (e) return e;
4200 133666 : p -= l; len -= l; ret += l;
4201 :
4202 133666 : ret += Top_tag_oldret;
4203 : }
4204 133666 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
4205 133666 : if (e) return e;
4206 133666 : p -= l; len -= l; ret += l;
4207 :
4208 133666 : *size = ret;
4209 133666 : return 0;
4210 : }
4211 :
4212 : int ASN1CALL
4213 102319 : decode_Checksum(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, Checksum *data, size_t *size)
4214 : {
4215 102319 : size_t ret = 0;
4216 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
4217 : int e HEIMDAL_UNUSED_ATTRIBUTE;
4218 :
4219 102319 : memset(data, 0, sizeof(*data));
4220 : {
4221 : size_t Top_datalen, Top_oldlen;
4222 : Der_type Top_type;
4223 102319 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
4224 102319 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
4225 102319 : if(e) goto fail;
4226 102319 : p += l; len -= l; ret += l;
4227 102319 : Top_oldlen = len;
4228 102319 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4229 102319 : len = Top_datalen;
4230 : {
4231 : size_t cksumtype_datalen, cksumtype_oldlen;
4232 : Der_type cksumtype_type;
4233 102319 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &cksumtype_type, 0, &cksumtype_datalen, &l);
4234 102319 : if (e == 0 && cksumtype_type != CONS) { e = ASN1_BAD_ID; }
4235 102319 : if(e) goto fail;
4236 102319 : p += l; len -= l; ret += l;
4237 102319 : cksumtype_oldlen = len;
4238 102319 : if (cksumtype_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4239 102319 : len = cksumtype_datalen;
4240 102319 : e = decode_CKSUMTYPE(p, len, &(data)->cksumtype, &l);
4241 102319 : if(e) goto fail;
4242 102319 : p += l; len -= l; ret += l;
4243 102319 : len = cksumtype_oldlen - cksumtype_datalen;
4244 : }
4245 : {
4246 : size_t checksum_datalen, checksum_oldlen;
4247 : Der_type checksum_type;
4248 102319 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &checksum_type, 1, &checksum_datalen, &l);
4249 201722 : if (e == 0 && checksum_type != CONS) { e = ASN1_BAD_ID; }
4250 102319 : if(e) goto fail;
4251 102319 : p += l; len -= l; ret += l;
4252 102319 : checksum_oldlen = len;
4253 102319 : if (checksum_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4254 102319 : len = checksum_datalen;
4255 : {
4256 : size_t checksum_Tag_datalen, checksum_Tag_oldlen;
4257 : Der_type checksum_Tag_type;
4258 102319 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &checksum_Tag_type, UT_OctetString, &checksum_Tag_datalen, &l);
4259 102319 : if (e == 0 && checksum_Tag_type != PRIM) { e = ASN1_BAD_ID; }
4260 102319 : if(e) goto fail;
4261 102319 : p += l; len -= l; ret += l;
4262 102319 : checksum_Tag_oldlen = len;
4263 102319 : if (checksum_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4264 102319 : len = checksum_Tag_datalen;
4265 102319 : e = der_get_octet_string(p, len, &(data)->checksum, &l);
4266 102319 : if(e) goto fail;
4267 102319 : p += l; len -= l; ret += l;
4268 102319 : len = checksum_Tag_oldlen - checksum_Tag_datalen;
4269 : }
4270 102319 : len = checksum_oldlen - checksum_datalen;
4271 : }
4272 102319 : len = Top_oldlen - Top_datalen;
4273 : }
4274 204638 : if(size) *size = ret;
4275 99403 : return 0;
4276 0 : fail:
4277 0 : free_Checksum(data);
4278 0 : return e;
4279 : }
4280 :
4281 : void ASN1CALL
4282 1632769 : free_Checksum(Checksum *data)
4283 : {
4284 1632769 : free_CKSUMTYPE(&(data)->cksumtype);
4285 1632769 : der_free_octet_string(&(data)->checksum);
4286 1632769 : }
4287 :
4288 : size_t ASN1CALL
4289 133666 : length_Checksum(const Checksum *data)
4290 : {
4291 133666 : size_t ret = 0;
4292 : {
4293 133666 : size_t Top_tag_oldret = ret;
4294 133666 : ret = 0;
4295 133666 : ret += length_CKSUMTYPE(&(data)->cksumtype);
4296 133666 : ret += 1 + der_length_len (ret);
4297 133666 : ret += Top_tag_oldret;
4298 : }
4299 : {
4300 133666 : size_t Top_tag_oldret = ret;
4301 133666 : ret = 0;
4302 133666 : ret += der_length_octet_string(&(data)->checksum);
4303 133666 : ret += 1 + der_length_len (ret);
4304 133666 : ret += 1 + der_length_len (ret);
4305 133666 : ret += Top_tag_oldret;
4306 : }
4307 133666 : ret += 1 + der_length_len (ret);
4308 133666 : return ret;
4309 : }
4310 :
4311 : int ASN1CALL
4312 169376 : copy_Checksum(const Checksum *from, Checksum *to)
4313 : {
4314 169376 : memset(to, 0, sizeof(*to));
4315 169376 : if(copy_CKSUMTYPE(&(from)->cksumtype, &(to)->cksumtype)) goto fail;
4316 169376 : if(der_copy_octet_string(&(from)->checksum, &(to)->checksum)) goto fail;
4317 164621 : return 0;
4318 0 : fail:
4319 0 : free_Checksum(to);
4320 0 : return ENOMEM;
4321 : }
4322 :
4323 : int ASN1CALL
4324 68110 : encode_Authenticator(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const Authenticator *data, size_t *size)
4325 : {
4326 68110 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
4327 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
4328 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
4329 :
4330 : /* authorization-data */
4331 68110 : if((data)->authorization_data) {
4332 20329 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4333 20329 : ret = 0;
4334 20329 : e = encode_AuthorizationData(p, len, (data)->authorization_data, &l);
4335 20329 : if (e) return e;
4336 20329 : p -= l; len -= l; ret += l;
4337 :
4338 20329 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 8, &l);
4339 20329 : if (e) return e;
4340 20329 : p -= l; len -= l; ret += l;
4341 :
4342 20329 : ret += Top_tag_tag_oldret;
4343 : }
4344 : /* seq-number */
4345 68110 : if((data)->seq_number) {
4346 20464 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4347 20464 : ret = 0;
4348 20464 : e = encode_krb5uint32(p, len, (data)->seq_number, &l);
4349 20464 : if (e) return e;
4350 20464 : p -= l; len -= l; ret += l;
4351 :
4352 20464 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 7, &l);
4353 20464 : if (e) return e;
4354 20464 : p -= l; len -= l; ret += l;
4355 :
4356 20464 : ret += Top_tag_tag_oldret;
4357 : }
4358 : /* subkey */
4359 68110 : if((data)->subkey) {
4360 62842 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4361 62842 : ret = 0;
4362 62842 : e = encode_EncryptionKey(p, len, (data)->subkey, &l);
4363 62842 : if (e) return e;
4364 62842 : p -= l; len -= l; ret += l;
4365 :
4366 62842 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 6, &l);
4367 62842 : if (e) return e;
4368 62842 : p -= l; len -= l; ret += l;
4369 :
4370 62842 : ret += Top_tag_tag_oldret;
4371 : }
4372 : /* ctime */
4373 : {
4374 68110 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4375 68110 : ret = 0;
4376 68110 : e = encode_KerberosTime(p, len, &(data)->ctime, &l);
4377 68110 : if (e) return e;
4378 68110 : p -= l; len -= l; ret += l;
4379 :
4380 68110 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 5, &l);
4381 68110 : if (e) return e;
4382 68110 : p -= l; len -= l; ret += l;
4383 :
4384 68110 : ret += Top_tag_tag_oldret;
4385 : }
4386 : /* cusec */
4387 : {
4388 68110 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4389 68110 : ret = 0;
4390 68110 : e = encode_krb5int32(p, len, &(data)->cusec, &l);
4391 68110 : if (e) return e;
4392 68110 : p -= l; len -= l; ret += l;
4393 :
4394 68110 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 4, &l);
4395 68110 : if (e) return e;
4396 68110 : p -= l; len -= l; ret += l;
4397 :
4398 68110 : ret += Top_tag_tag_oldret;
4399 : }
4400 : /* cksum */
4401 68110 : if((data)->cksum) {
4402 68044 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4403 68044 : ret = 0;
4404 68044 : e = encode_Checksum(p, len, (data)->cksum, &l);
4405 68044 : if (e) return e;
4406 68044 : p -= l; len -= l; ret += l;
4407 :
4408 68044 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
4409 68044 : if (e) return e;
4410 68044 : p -= l; len -= l; ret += l;
4411 :
4412 68044 : ret += Top_tag_tag_oldret;
4413 : }
4414 : /* cname */
4415 : {
4416 68110 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4417 68110 : ret = 0;
4418 68110 : e = encode_PrincipalName(p, len, &(data)->cname, &l);
4419 68110 : if (e) return e;
4420 68110 : p -= l; len -= l; ret += l;
4421 :
4422 68110 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
4423 68110 : if (e) return e;
4424 68110 : p -= l; len -= l; ret += l;
4425 :
4426 68110 : ret += Top_tag_tag_oldret;
4427 : }
4428 : /* crealm */
4429 : {
4430 68110 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4431 68110 : ret = 0;
4432 68110 : e = encode_Realm(p, len, &(data)->crealm, &l);
4433 68110 : if (e) return e;
4434 68110 : p -= l; len -= l; ret += l;
4435 :
4436 68110 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
4437 68110 : if (e) return e;
4438 68110 : p -= l; len -= l; ret += l;
4439 :
4440 68110 : ret += Top_tag_tag_oldret;
4441 : }
4442 : /* authenticator-vno */
4443 : {
4444 68110 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4445 68110 : ret = 0;
4446 68110 : e = encode_krb5int32(p, len, &(data)->authenticator_vno, &l);
4447 68110 : if (e) return e;
4448 68110 : p -= l; len -= l; ret += l;
4449 :
4450 68110 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
4451 68110 : if (e) return e;
4452 68110 : p -= l; len -= l; ret += l;
4453 :
4454 68110 : ret += Top_tag_tag_oldret;
4455 : }
4456 68110 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
4457 68110 : if (e) return e;
4458 68110 : p -= l; len -= l; ret += l;
4459 :
4460 68110 : e = der_put_length_and_tag (p, len, ret, ASN1_C_APPL, CONS, 2, &l);
4461 68110 : if (e) return e;
4462 68110 : p -= l; len -= l; ret += l;
4463 :
4464 68110 : *size = ret;
4465 68110 : return 0;
4466 : }
4467 :
4468 : int ASN1CALL
4469 62161 : decode_Authenticator(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, Authenticator *data, size_t *size)
4470 : {
4471 62161 : size_t ret = 0;
4472 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
4473 : int e HEIMDAL_UNUSED_ATTRIBUTE;
4474 :
4475 62161 : memset(data, 0, sizeof(*data));
4476 : {
4477 : size_t Top_datalen, Top_oldlen;
4478 : Der_type Top_type;
4479 62161 : e = der_match_tag_and_length(p, len, ASN1_C_APPL, &Top_type, 2, &Top_datalen, &l);
4480 62161 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
4481 62161 : if(e) goto fail;
4482 62161 : p += l; len -= l; ret += l;
4483 62161 : Top_oldlen = len;
4484 62161 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4485 62161 : len = Top_datalen;
4486 : {
4487 : size_t Top_Tag_datalen, Top_Tag_oldlen;
4488 : Der_type Top_Tag_type;
4489 62161 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_Tag_type, UT_Sequence, &Top_Tag_datalen, &l);
4490 62161 : if (e == 0 && Top_Tag_type != CONS) { e = ASN1_BAD_ID; }
4491 62161 : if(e) goto fail;
4492 62161 : p += l; len -= l; ret += l;
4493 62161 : Top_Tag_oldlen = len;
4494 62161 : if (Top_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4495 62161 : len = Top_Tag_datalen;
4496 : {
4497 : size_t authenticator_vno_datalen, authenticator_vno_oldlen;
4498 : Der_type authenticator_vno_type;
4499 62161 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &authenticator_vno_type, 0, &authenticator_vno_datalen, &l);
4500 62161 : if (e == 0 && authenticator_vno_type != CONS) { e = ASN1_BAD_ID; }
4501 62161 : if(e) goto fail;
4502 62161 : p += l; len -= l; ret += l;
4503 62161 : authenticator_vno_oldlen = len;
4504 62161 : if (authenticator_vno_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4505 62161 : len = authenticator_vno_datalen;
4506 62161 : e = decode_krb5int32(p, len, &(data)->authenticator_vno, &l);
4507 62161 : if(e) goto fail;
4508 62161 : p += l; len -= l; ret += l;
4509 62161 : len = authenticator_vno_oldlen - authenticator_vno_datalen;
4510 : }
4511 : {
4512 : size_t crealm_datalen, crealm_oldlen;
4513 : Der_type crealm_type;
4514 62161 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &crealm_type, 1, &crealm_datalen, &l);
4515 122495 : if (e == 0 && crealm_type != CONS) { e = ASN1_BAD_ID; }
4516 62161 : if(e) goto fail;
4517 62161 : p += l; len -= l; ret += l;
4518 62161 : crealm_oldlen = len;
4519 62161 : if (crealm_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4520 62161 : len = crealm_datalen;
4521 62161 : e = decode_Realm(p, len, &(data)->crealm, &l);
4522 62161 : if(e) goto fail;
4523 62161 : p += l; len -= l; ret += l;
4524 62161 : len = crealm_oldlen - crealm_datalen;
4525 : }
4526 : {
4527 : size_t cname_datalen, cname_oldlen;
4528 : Der_type cname_type;
4529 62161 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &cname_type, 2, &cname_datalen, &l);
4530 122495 : if (e == 0 && cname_type != CONS) { e = ASN1_BAD_ID; }
4531 62161 : if(e) goto fail;
4532 62161 : p += l; len -= l; ret += l;
4533 62161 : cname_oldlen = len;
4534 62161 : if (cname_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4535 62161 : len = cname_datalen;
4536 62161 : e = decode_PrincipalName(p, len, &(data)->cname, &l);
4537 62161 : if(e) goto fail;
4538 62161 : p += l; len -= l; ret += l;
4539 62161 : len = cname_oldlen - cname_datalen;
4540 : }
4541 : {
4542 : size_t cksum_datalen, cksum_oldlen;
4543 : Der_type cksum_type;
4544 62161 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &cksum_type, 3, &cksum_datalen, &l);
4545 122429 : if (e == 0 && cksum_type != CONS) { e = ASN1_BAD_ID; }
4546 62161 : if(e) {
4547 66 : (data)->cksum = NULL;
4548 : } else {
4549 62095 : (data)->cksum = calloc(1, sizeof(*(data)->cksum));
4550 62095 : if ((data)->cksum == NULL) { e = ENOMEM; goto fail; }
4551 62095 : p += l; len -= l; ret += l;
4552 62095 : cksum_oldlen = len;
4553 62095 : if (cksum_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4554 62095 : len = cksum_datalen;
4555 62095 : e = decode_Checksum(p, len, (data)->cksum, &l);
4556 62095 : if(e) goto fail;
4557 62095 : p += l; len -= l; ret += l;
4558 62095 : len = cksum_oldlen - cksum_datalen;
4559 : }
4560 : }
4561 : {
4562 : size_t cusec_datalen, cusec_oldlen;
4563 : Der_type cusec_type;
4564 62161 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &cusec_type, 4, &cusec_datalen, &l);
4565 124322 : if (e == 0 && cusec_type != CONS) { e = ASN1_BAD_ID; }
4566 62161 : if(e) goto fail;
4567 62161 : p += l; len -= l; ret += l;
4568 62161 : cusec_oldlen = len;
4569 62161 : if (cusec_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4570 62161 : len = cusec_datalen;
4571 62161 : e = decode_krb5int32(p, len, &(data)->cusec, &l);
4572 62161 : if(e) goto fail;
4573 62161 : p += l; len -= l; ret += l;
4574 62161 : len = cusec_oldlen - cusec_datalen;
4575 : }
4576 : {
4577 : size_t ctime_datalen, ctime_oldlen;
4578 : Der_type ctime_type;
4579 62161 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &ctime_type, 5, &ctime_datalen, &l);
4580 122495 : if (e == 0 && ctime_type != CONS) { e = ASN1_BAD_ID; }
4581 62161 : if(e) goto fail;
4582 62161 : p += l; len -= l; ret += l;
4583 62161 : ctime_oldlen = len;
4584 62161 : if (ctime_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4585 62161 : len = ctime_datalen;
4586 62161 : e = decode_KerberosTime(p, len, &(data)->ctime, &l);
4587 62161 : if(e) goto fail;
4588 62161 : p += l; len -= l; ret += l;
4589 62161 : len = ctime_oldlen - ctime_datalen;
4590 : }
4591 : {
4592 : size_t subkey_datalen, subkey_oldlen;
4593 : Der_type subkey_type;
4594 62161 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &subkey_type, 6, &subkey_datalen, &l);
4595 122493 : if (e == 0 && subkey_type != CONS) { e = ASN1_BAD_ID; }
4596 62161 : if(e) {
4597 2 : (data)->subkey = NULL;
4598 : } else {
4599 62159 : (data)->subkey = calloc(1, sizeof(*(data)->subkey));
4600 62159 : if ((data)->subkey == NULL) { e = ENOMEM; goto fail; }
4601 62159 : p += l; len -= l; ret += l;
4602 62159 : subkey_oldlen = len;
4603 62159 : if (subkey_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4604 62159 : len = subkey_datalen;
4605 62159 : e = decode_EncryptionKey(p, len, (data)->subkey, &l);
4606 62159 : if(e) goto fail;
4607 62159 : p += l; len -= l; ret += l;
4608 62159 : len = subkey_oldlen - subkey_datalen;
4609 : }
4610 : }
4611 : {
4612 : size_t seq_number_datalen, seq_number_oldlen;
4613 : Der_type seq_number_type;
4614 62161 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &seq_number_type, 7, &seq_number_datalen, &l);
4615 82299 : if (e == 0 && seq_number_type != CONS) { e = ASN1_BAD_ID; }
4616 62161 : if(e) {
4617 42023 : (data)->seq_number = NULL;
4618 : } else {
4619 20138 : (data)->seq_number = calloc(1, sizeof(*(data)->seq_number));
4620 20138 : if ((data)->seq_number == NULL) { e = ENOMEM; goto fail; }
4621 20138 : p += l; len -= l; ret += l;
4622 20138 : seq_number_oldlen = len;
4623 20138 : if (seq_number_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4624 20138 : len = seq_number_datalen;
4625 20138 : e = decode_krb5uint32(p, len, (data)->seq_number, &l);
4626 20138 : if(e) goto fail;
4627 20138 : p += l; len -= l; ret += l;
4628 20138 : len = seq_number_oldlen - seq_number_datalen;
4629 : }
4630 : }
4631 : {
4632 : size_t authorization_data_datalen, authorization_data_oldlen;
4633 : Der_type authorization_data_type;
4634 62161 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &authorization_data_type, 8, &authorization_data_datalen, &l);
4635 81954 : if (e == 0 && authorization_data_type != CONS) { e = ASN1_BAD_ID; }
4636 62161 : if(e) {
4637 42368 : (data)->authorization_data = NULL;
4638 : } else {
4639 19793 : (data)->authorization_data = calloc(1, sizeof(*(data)->authorization_data));
4640 19793 : if ((data)->authorization_data == NULL) { e = ENOMEM; goto fail; }
4641 19793 : p += l; len -= l; ret += l;
4642 19793 : authorization_data_oldlen = len;
4643 19793 : if (authorization_data_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4644 19793 : len = authorization_data_datalen;
4645 19793 : e = decode_AuthorizationData(p, len, (data)->authorization_data, &l);
4646 19793 : if(e) goto fail;
4647 19793 : p += l; len -= l; ret += l;
4648 19793 : len = authorization_data_oldlen - authorization_data_datalen;
4649 : }
4650 : }
4651 62161 : len = Top_Tag_oldlen - Top_Tag_datalen;
4652 : }
4653 62161 : len = Top_oldlen - Top_datalen;
4654 : }
4655 124322 : if(size) *size = ret;
4656 60334 : return 0;
4657 0 : fail:
4658 0 : free_Authenticator(data);
4659 0 : return e;
4660 : }
4661 :
4662 : void ASN1CALL
4663 333330 : free_Authenticator(Authenticator *data)
4664 : {
4665 333330 : free_krb5int32(&(data)->authenticator_vno);
4666 333330 : free_Realm(&(data)->crealm);
4667 333330 : free_PrincipalName(&(data)->cname);
4668 333330 : if((data)->cksum) {
4669 231486 : free_Checksum((data)->cksum);
4670 231486 : free((data)->cksum);
4671 231486 : (data)->cksum = NULL;
4672 : }
4673 333330 : free_krb5int32(&(data)->cusec);
4674 333330 : free_KerberosTime(&(data)->ctime);
4675 333330 : if((data)->subkey) {
4676 226344 : free_EncryptionKey((data)->subkey);
4677 226344 : free((data)->subkey);
4678 226344 : (data)->subkey = NULL;
4679 : }
4680 333330 : if((data)->seq_number) {
4681 60719 : free_krb5uint32((data)->seq_number);
4682 60719 : free((data)->seq_number);
4683 60719 : (data)->seq_number = NULL;
4684 : }
4685 333330 : if((data)->authorization_data) {
4686 59931 : free_AuthorizationData((data)->authorization_data);
4687 59931 : free((data)->authorization_data);
4688 59931 : (data)->authorization_data = NULL;
4689 : }
4690 333330 : }
4691 :
4692 : size_t ASN1CALL
4693 68110 : length_Authenticator(const Authenticator *data)
4694 : {
4695 68110 : size_t ret = 0;
4696 : {
4697 68110 : size_t Top_tag_tag_oldret = ret;
4698 68110 : ret = 0;
4699 68110 : ret += length_krb5int32(&(data)->authenticator_vno);
4700 68110 : ret += 1 + der_length_len (ret);
4701 68110 : ret += Top_tag_tag_oldret;
4702 : }
4703 : {
4704 68110 : size_t Top_tag_tag_oldret = ret;
4705 68110 : ret = 0;
4706 68110 : ret += length_Realm(&(data)->crealm);
4707 68110 : ret += 1 + der_length_len (ret);
4708 68110 : ret += Top_tag_tag_oldret;
4709 : }
4710 : {
4711 68110 : size_t Top_tag_tag_oldret = ret;
4712 68110 : ret = 0;
4713 68110 : ret += length_PrincipalName(&(data)->cname);
4714 68110 : ret += 1 + der_length_len (ret);
4715 68110 : ret += Top_tag_tag_oldret;
4716 : }
4717 68110 : if((data)->cksum){
4718 68044 : size_t Top_tag_tag_oldret = ret;
4719 68044 : ret = 0;
4720 68044 : ret += length_Checksum((data)->cksum);
4721 68044 : ret += 1 + der_length_len (ret);
4722 68044 : ret += Top_tag_tag_oldret;
4723 : }
4724 : {
4725 68110 : size_t Top_tag_tag_oldret = ret;
4726 68110 : ret = 0;
4727 68110 : ret += length_krb5int32(&(data)->cusec);
4728 68110 : ret += 1 + der_length_len (ret);
4729 68110 : ret += Top_tag_tag_oldret;
4730 : }
4731 : {
4732 68110 : size_t Top_tag_tag_oldret = ret;
4733 68110 : ret = 0;
4734 68110 : ret += length_KerberosTime(&(data)->ctime);
4735 68110 : ret += 1 + der_length_len (ret);
4736 68110 : ret += Top_tag_tag_oldret;
4737 : }
4738 68110 : if((data)->subkey){
4739 62842 : size_t Top_tag_tag_oldret = ret;
4740 62842 : ret = 0;
4741 62842 : ret += length_EncryptionKey((data)->subkey);
4742 62842 : ret += 1 + der_length_len (ret);
4743 62842 : ret += Top_tag_tag_oldret;
4744 : }
4745 68110 : if((data)->seq_number){
4746 20464 : size_t Top_tag_tag_oldret = ret;
4747 20464 : ret = 0;
4748 20464 : ret += length_krb5uint32((data)->seq_number);
4749 20464 : ret += 1 + der_length_len (ret);
4750 20464 : ret += Top_tag_tag_oldret;
4751 : }
4752 68110 : if((data)->authorization_data){
4753 20329 : size_t Top_tag_tag_oldret = ret;
4754 20329 : ret = 0;
4755 20329 : ret += length_AuthorizationData((data)->authorization_data);
4756 20329 : ret += 1 + der_length_len (ret);
4757 20329 : ret += Top_tag_tag_oldret;
4758 : }
4759 68110 : ret += 1 + der_length_len (ret);
4760 68110 : ret += 1 + der_length_len (ret);
4761 68110 : return ret;
4762 : }
4763 :
4764 : int ASN1CALL
4765 101364 : copy_Authenticator(const Authenticator *from, Authenticator *to)
4766 : {
4767 101364 : memset(to, 0, sizeof(*to));
4768 101364 : if(copy_krb5int32(&(from)->authenticator_vno, &(to)->authenticator_vno)) goto fail;
4769 101364 : if(copy_Realm(&(from)->crealm, &(to)->crealm)) goto fail;
4770 101364 : if(copy_PrincipalName(&(from)->cname, &(to)->cname)) goto fail;
4771 101364 : if((from)->cksum) {
4772 101332 : (to)->cksum = malloc(sizeof(*(to)->cksum));
4773 101332 : if((to)->cksum == NULL) goto fail;
4774 101332 : if(copy_Checksum((from)->cksum, (to)->cksum)) goto fail;
4775 : }else
4776 32 : (to)->cksum = NULL;
4777 101364 : if(copy_krb5int32(&(from)->cusec, &(to)->cusec)) goto fail;
4778 101364 : if(copy_KerberosTime(&(from)->ctime, &(to)->ctime)) goto fail;
4779 101364 : if((from)->subkey) {
4780 101360 : (to)->subkey = malloc(sizeof(*(to)->subkey));
4781 101360 : if((to)->subkey == NULL) goto fail;
4782 101360 : if(copy_EncryptionKey((from)->subkey, (to)->subkey)) goto fail;
4783 : }else
4784 4 : (to)->subkey = NULL;
4785 101364 : if((from)->seq_number) {
4786 20134 : (to)->seq_number = malloc(sizeof(*(to)->seq_number));
4787 20134 : if((to)->seq_number == NULL) goto fail;
4788 20134 : if(copy_krb5uint32((from)->seq_number, (to)->seq_number)) goto fail;
4789 : }else
4790 81230 : (to)->seq_number = NULL;
4791 101364 : if((from)->authorization_data) {
4792 19794 : (to)->authorization_data = malloc(sizeof(*(to)->authorization_data));
4793 19794 : if((to)->authorization_data == NULL) goto fail;
4794 19794 : if(copy_AuthorizationData((from)->authorization_data, (to)->authorization_data)) goto fail;
4795 : }else
4796 81570 : (to)->authorization_data = NULL;
4797 98448 : return 0;
4798 0 : fail:
4799 0 : free_Authenticator(to);
4800 0 : return ENOMEM;
4801 : }
4802 :
4803 : int ASN1CALL
4804 144479 : encode_PA_DATA(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const PA_DATA *data, size_t *size)
4805 : {
4806 144479 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
4807 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
4808 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
4809 :
4810 : /* padata-value */
4811 : {
4812 144479 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4813 144479 : ret = 0;
4814 144479 : e = der_put_octet_string(p, len, &(data)->padata_value, &l);
4815 144479 : if (e) return e;
4816 144479 : p -= l; len -= l; ret += l;
4817 :
4818 144479 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
4819 144479 : if (e) return e;
4820 144479 : p -= l; len -= l; ret += l;
4821 :
4822 144479 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
4823 144479 : if (e) return e;
4824 144479 : p -= l; len -= l; ret += l;
4825 :
4826 144479 : ret += Top_tag_oldret;
4827 : }
4828 : /* padata-type */
4829 : {
4830 144479 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4831 144479 : ret = 0;
4832 144479 : e = encode_PADATA_TYPE(p, len, &(data)->padata_type, &l);
4833 144479 : if (e) return e;
4834 144479 : p -= l; len -= l; ret += l;
4835 :
4836 144479 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
4837 144479 : if (e) return e;
4838 144479 : p -= l; len -= l; ret += l;
4839 :
4840 144479 : ret += Top_tag_oldret;
4841 : }
4842 144479 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
4843 144479 : if (e) return e;
4844 144479 : p -= l; len -= l; ret += l;
4845 :
4846 144479 : *size = ret;
4847 144479 : return 0;
4848 : }
4849 :
4850 : int ASN1CALL
4851 155916 : decode_PA_DATA(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, PA_DATA *data, size_t *size)
4852 : {
4853 155916 : size_t ret = 0;
4854 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
4855 : int e HEIMDAL_UNUSED_ATTRIBUTE;
4856 :
4857 155916 : memset(data, 0, sizeof(*data));
4858 : {
4859 : size_t Top_datalen, Top_oldlen;
4860 : Der_type Top_type;
4861 155916 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
4862 155916 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
4863 155916 : if(e) goto fail;
4864 155916 : p += l; len -= l; ret += l;
4865 155916 : Top_oldlen = len;
4866 155916 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4867 155916 : len = Top_datalen;
4868 : {
4869 : size_t padata_type_datalen, padata_type_oldlen;
4870 : Der_type padata_type_type;
4871 155916 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &padata_type_type, 1, &padata_type_datalen, &l);
4872 155916 : if (e == 0 && padata_type_type != CONS) { e = ASN1_BAD_ID; }
4873 155916 : if(e) goto fail;
4874 155916 : p += l; len -= l; ret += l;
4875 155916 : padata_type_oldlen = len;
4876 155916 : if (padata_type_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4877 155916 : len = padata_type_datalen;
4878 155916 : e = decode_PADATA_TYPE(p, len, &(data)->padata_type, &l);
4879 155916 : if(e) goto fail;
4880 155916 : p += l; len -= l; ret += l;
4881 155916 : len = padata_type_oldlen - padata_type_datalen;
4882 : }
4883 : {
4884 : size_t padata_value_datalen, padata_value_oldlen;
4885 : Der_type padata_value_type;
4886 155916 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &padata_value_type, 2, &padata_value_datalen, &l);
4887 308678 : if (e == 0 && padata_value_type != CONS) { e = ASN1_BAD_ID; }
4888 155916 : if(e) goto fail;
4889 155916 : p += l; len -= l; ret += l;
4890 155916 : padata_value_oldlen = len;
4891 155916 : if (padata_value_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4892 155916 : len = padata_value_datalen;
4893 : {
4894 : size_t padata_value_Tag_datalen, padata_value_Tag_oldlen;
4895 : Der_type padata_value_Tag_type;
4896 155916 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &padata_value_Tag_type, UT_OctetString, &padata_value_Tag_datalen, &l);
4897 155916 : if (e == 0 && padata_value_Tag_type != PRIM) { e = ASN1_BAD_ID; }
4898 155916 : if(e) goto fail;
4899 155916 : p += l; len -= l; ret += l;
4900 155916 : padata_value_Tag_oldlen = len;
4901 155916 : if (padata_value_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4902 155916 : len = padata_value_Tag_datalen;
4903 155916 : e = der_get_octet_string(p, len, &(data)->padata_value, &l);
4904 155916 : if(e) goto fail;
4905 155916 : p += l; len -= l; ret += l;
4906 155916 : len = padata_value_Tag_oldlen - padata_value_Tag_datalen;
4907 : }
4908 155916 : len = padata_value_oldlen - padata_value_datalen;
4909 : }
4910 155916 : len = Top_oldlen - Top_datalen;
4911 : }
4912 311832 : if(size) *size = ret;
4913 152762 : return 0;
4914 0 : fail:
4915 0 : free_PA_DATA(data);
4916 0 : return e;
4917 : }
4918 :
4919 : void ASN1CALL
4920 292474 : free_PA_DATA(PA_DATA *data)
4921 : {
4922 292474 : free_PADATA_TYPE(&(data)->padata_type);
4923 292474 : der_free_octet_string(&(data)->padata_value);
4924 292474 : }
4925 :
4926 : size_t ASN1CALL
4927 144479 : length_PA_DATA(const PA_DATA *data)
4928 : {
4929 144479 : size_t ret = 0;
4930 : {
4931 144479 : size_t Top_tag_oldret = ret;
4932 144479 : ret = 0;
4933 144479 : ret += length_PADATA_TYPE(&(data)->padata_type);
4934 144479 : ret += 1 + der_length_len (ret);
4935 144479 : ret += Top_tag_oldret;
4936 : }
4937 : {
4938 144479 : size_t Top_tag_oldret = ret;
4939 144479 : ret = 0;
4940 144479 : ret += der_length_octet_string(&(data)->padata_value);
4941 144479 : ret += 1 + der_length_len (ret);
4942 144479 : ret += 1 + der_length_len (ret);
4943 144479 : ret += Top_tag_oldret;
4944 : }
4945 144479 : ret += 1 + der_length_len (ret);
4946 144479 : return ret;
4947 : }
4948 :
4949 : int ASN1CALL
4950 1356 : copy_PA_DATA(const PA_DATA *from, PA_DATA *to)
4951 : {
4952 1356 : memset(to, 0, sizeof(*to));
4953 1356 : if(copy_PADATA_TYPE(&(from)->padata_type, &(to)->padata_type)) goto fail;
4954 1356 : if(der_copy_octet_string(&(from)->padata_value, &(to)->padata_value)) goto fail;
4955 1356 : return 0;
4956 0 : fail:
4957 0 : free_PA_DATA(to);
4958 0 : return ENOMEM;
4959 : }
4960 :
4961 : int ASN1CALL
4962 4900 : encode_ETYPE_INFO_ENTRY(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const ETYPE_INFO_ENTRY *data, size_t *size)
4963 : {
4964 4900 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
4965 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
4966 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
4967 :
4968 : /* salttype */
4969 4900 : if((data)->salttype) {
4970 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4971 0 : ret = 0;
4972 0 : e = encode_krb5int32(p, len, (data)->salttype, &l);
4973 0 : if (e) return e;
4974 0 : p -= l; len -= l; ret += l;
4975 :
4976 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
4977 0 : if (e) return e;
4978 0 : p -= l; len -= l; ret += l;
4979 :
4980 0 : ret += Top_tag_oldret;
4981 : }
4982 : /* salt */
4983 4900 : if((data)->salt) {
4984 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4985 0 : ret = 0;
4986 0 : e = der_put_octet_string(p, len, (data)->salt, &l);
4987 0 : if (e) return e;
4988 0 : p -= l; len -= l; ret += l;
4989 :
4990 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
4991 0 : if (e) return e;
4992 0 : p -= l; len -= l; ret += l;
4993 :
4994 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
4995 0 : if (e) return e;
4996 0 : p -= l; len -= l; ret += l;
4997 :
4998 0 : ret += Top_tag_oldret;
4999 : }
5000 : /* etype */
5001 : {
5002 4900 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
5003 4900 : ret = 0;
5004 4900 : e = encode_ENCTYPE(p, len, &(data)->etype, &l);
5005 4900 : if (e) return e;
5006 4900 : p -= l; len -= l; ret += l;
5007 :
5008 4900 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
5009 4900 : if (e) return e;
5010 4900 : p -= l; len -= l; ret += l;
5011 :
5012 4900 : ret += Top_tag_oldret;
5013 : }
5014 4900 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
5015 4900 : if (e) return e;
5016 4900 : p -= l; len -= l; ret += l;
5017 :
5018 4900 : *size = ret;
5019 4900 : return 0;
5020 : }
5021 :
5022 : int ASN1CALL
5023 0 : decode_ETYPE_INFO_ENTRY(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, ETYPE_INFO_ENTRY *data, size_t *size)
5024 : {
5025 0 : size_t ret = 0;
5026 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
5027 : int e HEIMDAL_UNUSED_ATTRIBUTE;
5028 :
5029 0 : memset(data, 0, sizeof(*data));
5030 : {
5031 : size_t Top_datalen, Top_oldlen;
5032 : Der_type Top_type;
5033 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
5034 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
5035 0 : if(e) goto fail;
5036 0 : p += l; len -= l; ret += l;
5037 0 : Top_oldlen = len;
5038 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
5039 0 : len = Top_datalen;
5040 : {
5041 : size_t etype_datalen, etype_oldlen;
5042 : Der_type etype_type;
5043 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &etype_type, 0, &etype_datalen, &l);
5044 0 : if (e == 0 && etype_type != CONS) { e = ASN1_BAD_ID; }
5045 0 : if(e) goto fail;
5046 0 : p += l; len -= l; ret += l;
5047 0 : etype_oldlen = len;
5048 0 : if (etype_datalen > len) { e = ASN1_OVERRUN; goto fail; }
5049 0 : len = etype_datalen;
5050 0 : e = decode_ENCTYPE(p, len, &(data)->etype, &l);
5051 0 : if(e) goto fail;
5052 0 : p += l; len -= l; ret += l;
5053 0 : len = etype_oldlen - etype_datalen;
5054 : }
5055 : {
5056 : size_t salt_datalen, salt_oldlen;
5057 : Der_type salt_type;
5058 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &salt_type, 1, &salt_datalen, &l);
5059 0 : if (e == 0 && salt_type != CONS) { e = ASN1_BAD_ID; }
5060 0 : if(e) {
5061 0 : (data)->salt = NULL;
5062 : } else {
5063 0 : (data)->salt = calloc(1, sizeof(*(data)->salt));
5064 0 : if ((data)->salt == NULL) { e = ENOMEM; goto fail; }
5065 0 : p += l; len -= l; ret += l;
5066 0 : salt_oldlen = len;
5067 0 : if (salt_datalen > len) { e = ASN1_OVERRUN; goto fail; }
5068 0 : len = salt_datalen;
5069 : {
5070 : size_t salt_Tag_datalen, salt_Tag_oldlen;
5071 : Der_type salt_Tag_type;
5072 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &salt_Tag_type, UT_OctetString, &salt_Tag_datalen, &l);
5073 0 : if (e == 0 && salt_Tag_type != PRIM) { e = ASN1_BAD_ID; }
5074 0 : if(e) goto fail;
5075 0 : p += l; len -= l; ret += l;
5076 0 : salt_Tag_oldlen = len;
5077 0 : if (salt_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
5078 0 : len = salt_Tag_datalen;
5079 0 : e = der_get_octet_string(p, len, (data)->salt, &l);
5080 0 : if(e) goto fail;
5081 0 : p += l; len -= l; ret += l;
5082 0 : len = salt_Tag_oldlen - salt_Tag_datalen;
5083 : }
5084 0 : len = salt_oldlen - salt_datalen;
5085 : }
5086 : }
5087 : {
5088 : size_t salttype_datalen, salttype_oldlen;
5089 : Der_type salttype_type;
5090 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &salttype_type, 2, &salttype_datalen, &l);
5091 0 : if (e == 0 && salttype_type != CONS) { e = ASN1_BAD_ID; }
5092 0 : if(e) {
5093 0 : (data)->salttype = NULL;
5094 : } else {
5095 0 : (data)->salttype = calloc(1, sizeof(*(data)->salttype));
5096 0 : if ((data)->salttype == NULL) { e = ENOMEM; goto fail; }
5097 0 : p += l; len -= l; ret += l;
5098 0 : salttype_oldlen = len;
5099 0 : if (salttype_datalen > len) { e = ASN1_OVERRUN; goto fail; }
5100 0 : len = salttype_datalen;
5101 0 : e = decode_krb5int32(p, len, (data)->salttype, &l);
5102 0 : if(e) goto fail;
5103 0 : p += l; len -= l; ret += l;
5104 0 : len = salttype_oldlen - salttype_datalen;
5105 : }
5106 : }
5107 0 : len = Top_oldlen - Top_datalen;
5108 : }
5109 0 : if(size) *size = ret;
5110 0 : return 0;
5111 0 : fail:
5112 0 : free_ETYPE_INFO_ENTRY(data);
5113 0 : return e;
5114 : }
5115 :
5116 : void ASN1CALL
5117 4900 : free_ETYPE_INFO_ENTRY(ETYPE_INFO_ENTRY *data)
5118 : {
5119 4900 : free_ENCTYPE(&(data)->etype);
5120 4900 : if((data)->salt) {
5121 0 : der_free_octet_string((data)->salt);
5122 0 : free((data)->salt);
5123 0 : (data)->salt = NULL;
5124 : }
5125 4900 : if((data)->salttype) {
5126 0 : free_krb5int32((data)->salttype);
5127 0 : free((data)->salttype);
5128 0 : (data)->salttype = NULL;
5129 : }
5130 4900 : }
5131 :
5132 : size_t ASN1CALL
5133 4900 : length_ETYPE_INFO_ENTRY(const ETYPE_INFO_ENTRY *data)
5134 : {
5135 4900 : size_t ret = 0;
5136 : {
5137 4900 : size_t Top_tag_oldret = ret;
5138 4900 : ret = 0;
5139 4900 : ret += length_ENCTYPE(&(data)->etype);
5140 4900 : ret += 1 + der_length_len (ret);
5141 4900 : ret += Top_tag_oldret;
5142 : }
5143 4900 : if((data)->salt){
5144 0 : size_t Top_tag_oldret = ret;
5145 0 : ret = 0;
5146 0 : ret += der_length_octet_string((data)->salt);
5147 0 : ret += 1 + der_length_len (ret);
5148 0 : ret += 1 + der_length_len (ret);
5149 0 : ret += Top_tag_oldret;
5150 : }
5151 4900 : if((data)->salttype){
5152 0 : size_t Top_tag_oldret = ret;
5153 0 : ret = 0;
5154 0 : ret += length_krb5int32((data)->salttype);
5155 0 : ret += 1 + der_length_len (ret);
5156 0 : ret += Top_tag_oldret;
5157 : }
5158 4900 : ret += 1 + der_length_len (ret);
5159 4900 : return ret;
5160 : }
5161 :
5162 : int ASN1CALL
5163 0 : copy_ETYPE_INFO_ENTRY(const ETYPE_INFO_ENTRY *from, ETYPE_INFO_ENTRY *to)
5164 : {
5165 0 : memset(to, 0, sizeof(*to));
5166 0 : if(copy_ENCTYPE(&(from)->etype, &(to)->etype)) goto fail;
5167 0 : if((from)->salt) {
5168 0 : (to)->salt = malloc(sizeof(*(to)->salt));
5169 0 : if((to)->salt == NULL) goto fail;
5170 0 : if(der_copy_octet_string((from)->salt, (to)->salt)) goto fail;
5171 : }else
5172 0 : (to)->salt = NULL;
5173 0 : if((from)->salttype) {
5174 0 : (to)->salttype = malloc(sizeof(*(to)->salttype));
5175 0 : if((to)->salttype == NULL) goto fail;
5176 0 : if(copy_krb5int32((from)->salttype, (to)->salttype)) goto fail;
5177 : }else
5178 0 : (to)->salttype = NULL;
5179 0 : return 0;
5180 0 : fail:
5181 0 : free_ETYPE_INFO_ENTRY(to);
5182 0 : return ENOMEM;
5183 : }
5184 :
5185 : int ASN1CALL
5186 4900 : encode_ETYPE_INFO(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const ETYPE_INFO *data, size_t *size)
5187 : {
5188 4900 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
5189 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
5190 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
5191 :
5192 9800 : for(i = (int)(data)->len - 1; i >= 0; --i) {
5193 4900 : size_t Top_tag_for_oldret = ret;
5194 4900 : ret = 0;
5195 4900 : e = encode_ETYPE_INFO_ENTRY(p, len, &(data)->val[i], &l);
5196 4900 : if (e) return e;
5197 4900 : p -= l; len -= l; ret += l;
5198 :
5199 4900 : ret += Top_tag_for_oldret;
5200 : }
5201 4900 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
5202 4900 : if (e) return e;
5203 4900 : p -= l; len -= l; ret += l;
5204 :
5205 4900 : *size = ret;
5206 4900 : return 0;
5207 : }
5208 :
5209 : int ASN1CALL
5210 0 : decode_ETYPE_INFO(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, ETYPE_INFO *data, size_t *size)
5211 : {
5212 0 : size_t ret = 0;
5213 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
5214 : int e HEIMDAL_UNUSED_ATTRIBUTE;
5215 :
5216 0 : memset(data, 0, sizeof(*data));
5217 : {
5218 : size_t Top_datalen, Top_oldlen;
5219 : Der_type Top_type;
5220 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
5221 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
5222 0 : if(e) goto fail;
5223 0 : p += l; len -= l; ret += l;
5224 0 : Top_oldlen = len;
5225 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
5226 0 : len = Top_datalen;
5227 : {
5228 0 : size_t Top_Tag_origlen = len;
5229 0 : size_t Top_Tag_oldret = ret;
5230 0 : size_t Top_Tag_olen = 0;
5231 : void *Top_Tag_tmp;
5232 0 : ret = 0;
5233 0 : (data)->len = 0;
5234 0 : (data)->val = NULL;
5235 0 : while(ret < Top_Tag_origlen) {
5236 0 : size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
5237 0 : if (Top_Tag_olen > Top_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
5238 0 : Top_Tag_olen = Top_Tag_nlen;
5239 0 : Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
5240 0 : if (Top_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
5241 0 : (data)->val = Top_Tag_tmp;
5242 0 : e = decode_ETYPE_INFO_ENTRY(p, len, &(data)->val[(data)->len], &l);
5243 0 : if(e) goto fail;
5244 0 : p += l; len -= l; ret += l;
5245 0 : (data)->len++;
5246 0 : len = Top_Tag_origlen - ret;
5247 : }
5248 0 : ret += Top_Tag_oldret;
5249 : }
5250 0 : len = Top_oldlen - Top_datalen;
5251 : }
5252 0 : if(size) *size = ret;
5253 0 : return 0;
5254 0 : fail:
5255 0 : free_ETYPE_INFO(data);
5256 0 : return e;
5257 : }
5258 :
5259 : void ASN1CALL
5260 4900 : free_ETYPE_INFO(ETYPE_INFO *data)
5261 : {
5262 14700 : while((data)->len){
5263 4900 : free_ETYPE_INFO_ENTRY(&(data)->val[(data)->len-1]);
5264 4900 : (data)->len--;
5265 : }
5266 4900 : free((data)->val);
5267 4900 : (data)->val = NULL;
5268 4900 : }
5269 :
5270 : size_t ASN1CALL
5271 4900 : length_ETYPE_INFO(const ETYPE_INFO *data)
5272 : {
5273 4900 : size_t ret = 0;
5274 : {
5275 4900 : size_t Top_tag_oldret = ret;
5276 : int i;
5277 4900 : ret = 0;
5278 9800 : for(i = (data)->len - 1; i >= 0; --i){
5279 4900 : size_t Top_tag_for_oldret = ret;
5280 4900 : ret = 0;
5281 4900 : ret += length_ETYPE_INFO_ENTRY(&(data)->val[i]);
5282 4900 : ret += Top_tag_for_oldret;
5283 : }
5284 4900 : ret += Top_tag_oldret;
5285 : }
5286 4900 : ret += 1 + der_length_len (ret);
5287 4900 : return ret;
5288 : }
5289 :
5290 : int ASN1CALL
5291 0 : copy_ETYPE_INFO(const ETYPE_INFO *from, ETYPE_INFO *to)
5292 : {
5293 0 : memset(to, 0, sizeof(*to));
5294 0 : if(((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
5295 0 : goto fail;
5296 0 : for((to)->len = 0; (to)->len < (from)->len; (to)->len++){
5297 0 : if(copy_ETYPE_INFO_ENTRY(&(from)->val[(to)->len], &(to)->val[(to)->len])) goto fail;
5298 : }
5299 0 : return 0;
5300 0 : fail:
5301 0 : free_ETYPE_INFO(to);
5302 0 : return ENOMEM;
5303 : }
5304 :
5305 : int ASN1CALL
5306 0 : add_ETYPE_INFO(ETYPE_INFO *data, const ETYPE_INFO_ENTRY *element)
5307 : {
5308 : int ret;
5309 : void *ptr;
5310 :
5311 0 : ptr = realloc(data->val,
5312 0 : (data->len + 1) * sizeof(data->val[0]));
5313 0 : if (ptr == NULL) return ENOMEM;
5314 0 : data->val = ptr;
5315 :
5316 0 : ret = copy_ETYPE_INFO_ENTRY(element, &data->val[data->len]);
5317 0 : if (ret) return ret;
5318 0 : data->len++;
5319 0 : return 0;
5320 : }
5321 :
5322 : int ASN1CALL
5323 0 : remove_ETYPE_INFO(ETYPE_INFO *data, unsigned int element)
5324 : {
5325 : void *ptr;
5326 :
5327 0 : if (data->len == 0 || element >= data->len)
5328 0 : return ASN1_OVERRUN;
5329 0 : free_ETYPE_INFO_ENTRY(&data->val[element]);
5330 0 : data->len--;
5331 0 : if (element < data->len)
5332 0 : memmove(&data->val[element], &data->val[element + 1],
5333 0 : sizeof(data->val[0]) * data->len);
5334 0 : ptr = realloc(data->val, data->len * sizeof(data->val[0]));
5335 0 : if (ptr != NULL || data->len == 0) data->val = ptr;
5336 0 : return 0;
5337 : }
5338 :
5339 : int ASN1CALL
5340 14736 : encode_ETYPE_INFO2_ENTRY(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const ETYPE_INFO2_ENTRY *data, size_t *size)
5341 : {
5342 14736 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
5343 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
5344 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
5345 :
5346 : /* s2kparams */
5347 14736 : if((data)->s2kparams) {
5348 9836 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
5349 9836 : ret = 0;
5350 9836 : e = der_put_octet_string(p, len, (data)->s2kparams, &l);
5351 9836 : if (e) return e;
5352 9836 : p -= l; len -= l; ret += l;
5353 :
5354 9836 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
5355 9836 : if (e) return e;
5356 9836 : p -= l; len -= l; ret += l;
5357 :
5358 9836 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
5359 9836 : if (e) return e;
5360 9836 : p -= l; len -= l; ret += l;
5361 :
5362 9836 : ret += Top_tag_oldret;
5363 : }
5364 : /* salt */
5365 14736 : if((data)->salt) {
5366 9804 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
5367 9804 : ret = 0;
5368 9804 : e = encode_KerberosString(p, len, (data)->salt, &l);
5369 9804 : if (e) return e;
5370 9804 : p -= l; len -= l; ret += l;
5371 :
5372 9804 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
5373 9804 : if (e) return e;
5374 9804 : p -= l; len -= l; ret += l;
5375 :
5376 9804 : ret += Top_tag_oldret;
5377 : }
5378 : /* etype */
5379 : {
5380 14736 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
5381 14736 : ret = 0;
5382 14736 : e = encode_ENCTYPE(p, len, &(data)->etype, &l);
5383 14736 : if (e) return e;
5384 14736 : p -= l; len -= l; ret += l;
5385 :
5386 14736 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
5387 14736 : if (e) return e;
5388 14736 : p -= l; len -= l; ret += l;
5389 :
5390 14736 : ret += Top_tag_oldret;
5391 : }
5392 14736 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
5393 14736 : if (e) return e;
5394 14736 : p -= l; len -= l; ret += l;
5395 :
5396 14736 : *size = ret;
5397 14736 : return 0;
5398 : }
5399 :
5400 : int ASN1CALL
5401 13627 : decode_ETYPE_INFO2_ENTRY(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, ETYPE_INFO2_ENTRY *data, size_t *size)
5402 : {
5403 13627 : size_t ret = 0;
5404 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
5405 : int e HEIMDAL_UNUSED_ATTRIBUTE;
5406 :
5407 13627 : memset(data, 0, sizeof(*data));
5408 : {
5409 : size_t Top_datalen, Top_oldlen;
5410 : Der_type Top_type;
5411 13627 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
5412 13627 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
5413 13627 : if(e) goto fail;
5414 13627 : p += l; len -= l; ret += l;
5415 13627 : Top_oldlen = len;
5416 13627 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
5417 13627 : len = Top_datalen;
5418 : {
5419 : size_t etype_datalen, etype_oldlen;
5420 : Der_type etype_type;
5421 13627 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &etype_type, 0, &etype_datalen, &l);
5422 13627 : if (e == 0 && etype_type != CONS) { e = ASN1_BAD_ID; }
5423 13627 : if(e) goto fail;
5424 13627 : p += l; len -= l; ret += l;
5425 13627 : etype_oldlen = len;
5426 13627 : if (etype_datalen > len) { e = ASN1_OVERRUN; goto fail; }
5427 13627 : len = etype_datalen;
5428 13627 : e = decode_ENCTYPE(p, len, &(data)->etype, &l);
5429 13627 : if(e) goto fail;
5430 13627 : p += l; len -= l; ret += l;
5431 13627 : len = etype_oldlen - etype_datalen;
5432 : }
5433 : {
5434 : size_t salt_datalen, salt_oldlen;
5435 : Der_type salt_type;
5436 13627 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &salt_type, 1, &salt_datalen, &l);
5437 22750 : if (e == 0 && salt_type != CONS) { e = ASN1_BAD_ID; }
5438 13627 : if(e) {
5439 4291 : (data)->salt = NULL;
5440 : } else {
5441 9336 : (data)->salt = calloc(1, sizeof(*(data)->salt));
5442 9336 : if ((data)->salt == NULL) { e = ENOMEM; goto fail; }
5443 9336 : p += l; len -= l; ret += l;
5444 9336 : salt_oldlen = len;
5445 9336 : if (salt_datalen > len) { e = ASN1_OVERRUN; goto fail; }
5446 9336 : len = salt_datalen;
5447 9336 : e = decode_KerberosString(p, len, (data)->salt, &l);
5448 9336 : if(e) goto fail;
5449 9336 : p += l; len -= l; ret += l;
5450 9336 : len = salt_oldlen - salt_datalen;
5451 : }
5452 : }
5453 : {
5454 : size_t s2kparams_datalen, s2kparams_oldlen;
5455 : Der_type s2kparams_type;
5456 13627 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &s2kparams_type, 2, &s2kparams_datalen, &l);
5457 22979 : if (e == 0 && s2kparams_type != CONS) { e = ASN1_BAD_ID; }
5458 13627 : if(e) {
5459 4275 : (data)->s2kparams = NULL;
5460 : } else {
5461 9352 : (data)->s2kparams = calloc(1, sizeof(*(data)->s2kparams));
5462 9352 : if ((data)->s2kparams == NULL) { e = ENOMEM; goto fail; }
5463 9352 : p += l; len -= l; ret += l;
5464 9352 : s2kparams_oldlen = len;
5465 9352 : if (s2kparams_datalen > len) { e = ASN1_OVERRUN; goto fail; }
5466 9352 : len = s2kparams_datalen;
5467 : {
5468 : size_t s2kparams_Tag_datalen, s2kparams_Tag_oldlen;
5469 : Der_type s2kparams_Tag_type;
5470 9352 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &s2kparams_Tag_type, UT_OctetString, &s2kparams_Tag_datalen, &l);
5471 9352 : if (e == 0 && s2kparams_Tag_type != PRIM) { e = ASN1_BAD_ID; }
5472 9352 : if(e) goto fail;
5473 9352 : p += l; len -= l; ret += l;
5474 9352 : s2kparams_Tag_oldlen = len;
5475 9352 : if (s2kparams_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
5476 9352 : len = s2kparams_Tag_datalen;
5477 9352 : e = der_get_octet_string(p, len, (data)->s2kparams, &l);
5478 9352 : if(e) goto fail;
5479 9352 : p += l; len -= l; ret += l;
5480 9352 : len = s2kparams_Tag_oldlen - s2kparams_Tag_datalen;
5481 : }
5482 9352 : len = s2kparams_oldlen - s2kparams_datalen;
5483 : }
5484 : }
5485 13627 : len = Top_oldlen - Top_datalen;
5486 : }
5487 27254 : if(size) *size = ret;
5488 13332 : return 0;
5489 0 : fail:
5490 0 : free_ETYPE_INFO2_ENTRY(data);
5491 0 : return e;
5492 : }
5493 :
5494 : void ASN1CALL
5495 28363 : free_ETYPE_INFO2_ENTRY(ETYPE_INFO2_ENTRY *data)
5496 : {
5497 28363 : free_ENCTYPE(&(data)->etype);
5498 28363 : if((data)->salt) {
5499 19140 : free_KerberosString((data)->salt);
5500 19140 : free((data)->salt);
5501 19140 : (data)->salt = NULL;
5502 : }
5503 28363 : if((data)->s2kparams) {
5504 19188 : der_free_octet_string((data)->s2kparams);
5505 19188 : free((data)->s2kparams);
5506 19188 : (data)->s2kparams = NULL;
5507 : }
5508 28363 : }
5509 :
5510 : size_t ASN1CALL
5511 14736 : length_ETYPE_INFO2_ENTRY(const ETYPE_INFO2_ENTRY *data)
5512 : {
5513 14736 : size_t ret = 0;
5514 : {
5515 14736 : size_t Top_tag_oldret = ret;
5516 14736 : ret = 0;
5517 14736 : ret += length_ENCTYPE(&(data)->etype);
5518 14736 : ret += 1 + der_length_len (ret);
5519 14736 : ret += Top_tag_oldret;
5520 : }
5521 14736 : if((data)->salt){
5522 9804 : size_t Top_tag_oldret = ret;
5523 9804 : ret = 0;
5524 9804 : ret += length_KerberosString((data)->salt);
5525 9804 : ret += 1 + der_length_len (ret);
5526 9804 : ret += Top_tag_oldret;
5527 : }
5528 14736 : if((data)->s2kparams){
5529 9836 : size_t Top_tag_oldret = ret;
5530 9836 : ret = 0;
5531 9836 : ret += der_length_octet_string((data)->s2kparams);
5532 9836 : ret += 1 + der_length_len (ret);
5533 9836 : ret += 1 + der_length_len (ret);
5534 9836 : ret += Top_tag_oldret;
5535 : }
5536 14736 : ret += 1 + der_length_len (ret);
5537 14736 : return ret;
5538 : }
5539 :
5540 : int ASN1CALL
5541 0 : copy_ETYPE_INFO2_ENTRY(const ETYPE_INFO2_ENTRY *from, ETYPE_INFO2_ENTRY *to)
5542 : {
5543 0 : memset(to, 0, sizeof(*to));
5544 0 : if(copy_ENCTYPE(&(from)->etype, &(to)->etype)) goto fail;
5545 0 : if((from)->salt) {
5546 0 : (to)->salt = malloc(sizeof(*(to)->salt));
5547 0 : if((to)->salt == NULL) goto fail;
5548 0 : if(copy_KerberosString((from)->salt, (to)->salt)) goto fail;
5549 : }else
5550 0 : (to)->salt = NULL;
5551 0 : if((from)->s2kparams) {
5552 0 : (to)->s2kparams = malloc(sizeof(*(to)->s2kparams));
5553 0 : if((to)->s2kparams == NULL) goto fail;
5554 0 : if(der_copy_octet_string((from)->s2kparams, (to)->s2kparams)) goto fail;
5555 : }else
5556 0 : (to)->s2kparams = NULL;
5557 0 : return 0;
5558 0 : fail:
5559 0 : free_ETYPE_INFO2_ENTRY(to);
5560 0 : return ENOMEM;
5561 : }
5562 :
5563 : int ASN1CALL
5564 14736 : encode_ETYPE_INFO2(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const ETYPE_INFO2 *data, size_t *size)
5565 : {
5566 14736 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
5567 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
5568 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
5569 :
5570 29472 : for(i = (int)(data)->len - 1; i >= 0; --i) {
5571 14736 : size_t Top_tag_for_oldret = ret;
5572 14736 : ret = 0;
5573 14736 : e = encode_ETYPE_INFO2_ENTRY(p, len, &(data)->val[i], &l);
5574 14736 : if (e) return e;
5575 14736 : p -= l; len -= l; ret += l;
5576 :
5577 14736 : ret += Top_tag_for_oldret;
5578 : }
5579 14736 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
5580 14736 : if (e) return e;
5581 14736 : p -= l; len -= l; ret += l;
5582 :
5583 14736 : *size = ret;
5584 14736 : return 0;
5585 : }
5586 :
5587 : int ASN1CALL
5588 13627 : decode_ETYPE_INFO2(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, ETYPE_INFO2 *data, size_t *size)
5589 : {
5590 13627 : size_t ret = 0;
5591 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
5592 : int e HEIMDAL_UNUSED_ATTRIBUTE;
5593 :
5594 13627 : memset(data, 0, sizeof(*data));
5595 : {
5596 : size_t Top_datalen, Top_oldlen;
5597 : Der_type Top_type;
5598 13627 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
5599 13627 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
5600 13627 : if(e) goto fail;
5601 13627 : p += l; len -= l; ret += l;
5602 13627 : Top_oldlen = len;
5603 13627 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
5604 13627 : len = Top_datalen;
5605 : {
5606 13627 : size_t Top_Tag_origlen = len;
5607 13627 : size_t Top_Tag_oldret = ret;
5608 13627 : size_t Top_Tag_olen = 0;
5609 : void *Top_Tag_tmp;
5610 13627 : ret = 0;
5611 13627 : (data)->len = 0;
5612 13627 : (data)->val = NULL;
5613 40881 : while(ret < Top_Tag_origlen) {
5614 13627 : size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
5615 13627 : if (Top_Tag_olen > Top_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
5616 13627 : Top_Tag_olen = Top_Tag_nlen;
5617 13627 : Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
5618 13627 : if (Top_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
5619 13627 : (data)->val = Top_Tag_tmp;
5620 13627 : e = decode_ETYPE_INFO2_ENTRY(p, len, &(data)->val[(data)->len], &l);
5621 13627 : if(e) goto fail;
5622 13627 : p += l; len -= l; ret += l;
5623 13627 : (data)->len++;
5624 13627 : len = Top_Tag_origlen - ret;
5625 : }
5626 13627 : ret += Top_Tag_oldret;
5627 : }
5628 13627 : if ((data)->len < 1) {
5629 0 : e = ASN1_MIN_CONSTRAINT; goto fail;
5630 : }
5631 13627 : len = Top_oldlen - Top_datalen;
5632 : }
5633 27254 : if(size) *size = ret;
5634 13332 : return 0;
5635 0 : fail:
5636 0 : free_ETYPE_INFO2(data);
5637 0 : return e;
5638 : }
5639 :
5640 : void ASN1CALL
5641 28363 : free_ETYPE_INFO2(ETYPE_INFO2 *data)
5642 : {
5643 85089 : while((data)->len){
5644 28363 : free_ETYPE_INFO2_ENTRY(&(data)->val[(data)->len-1]);
5645 28363 : (data)->len--;
5646 : }
5647 28363 : free((data)->val);
5648 28363 : (data)->val = NULL;
5649 28363 : }
5650 :
5651 : size_t ASN1CALL
5652 14736 : length_ETYPE_INFO2(const ETYPE_INFO2 *data)
5653 : {
5654 14736 : size_t ret = 0;
5655 : {
5656 14736 : size_t Top_tag_oldret = ret;
5657 : int i;
5658 14736 : ret = 0;
5659 29472 : for(i = (data)->len - 1; i >= 0; --i){
5660 14736 : size_t Top_tag_for_oldret = ret;
5661 14736 : ret = 0;
5662 14736 : ret += length_ETYPE_INFO2_ENTRY(&(data)->val[i]);
5663 14736 : ret += Top_tag_for_oldret;
5664 : }
5665 14736 : ret += Top_tag_oldret;
5666 : }
5667 14736 : ret += 1 + der_length_len (ret);
5668 14736 : return ret;
5669 : }
5670 :
5671 : int ASN1CALL
5672 0 : copy_ETYPE_INFO2(const ETYPE_INFO2 *from, ETYPE_INFO2 *to)
5673 : {
5674 0 : memset(to, 0, sizeof(*to));
5675 0 : if(((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
5676 0 : goto fail;
5677 0 : for((to)->len = 0; (to)->len < (from)->len; (to)->len++){
5678 0 : if(copy_ETYPE_INFO2_ENTRY(&(from)->val[(to)->len], &(to)->val[(to)->len])) goto fail;
5679 : }
5680 0 : return 0;
5681 0 : fail:
5682 0 : free_ETYPE_INFO2(to);
5683 0 : return ENOMEM;
5684 : }
5685 :
5686 : int ASN1CALL
5687 0 : add_ETYPE_INFO2(ETYPE_INFO2 *data, const ETYPE_INFO2_ENTRY *element)
5688 : {
5689 : int ret;
5690 : void *ptr;
5691 :
5692 0 : ptr = realloc(data->val,
5693 0 : (data->len + 1) * sizeof(data->val[0]));
5694 0 : if (ptr == NULL) return ENOMEM;
5695 0 : data->val = ptr;
5696 :
5697 0 : ret = copy_ETYPE_INFO2_ENTRY(element, &data->val[data->len]);
5698 0 : if (ret) return ret;
5699 0 : data->len++;
5700 0 : return 0;
5701 : }
5702 :
5703 : int ASN1CALL
5704 0 : remove_ETYPE_INFO2(ETYPE_INFO2 *data, unsigned int element)
5705 : {
5706 : void *ptr;
5707 :
5708 0 : if (data->len == 0 || element >= data->len)
5709 0 : return ASN1_OVERRUN;
5710 0 : free_ETYPE_INFO2_ENTRY(&data->val[element]);
5711 0 : data->len--;
5712 0 : if (element < data->len)
5713 0 : memmove(&data->val[element], &data->val[element + 1],
5714 0 : sizeof(data->val[0]) * data->len);
5715 0 : ptr = realloc(data->val, data->len * sizeof(data->val[0]));
5716 0 : if (ptr != NULL || data->len == 0) data->val = ptr;
5717 0 : return 0;
5718 : }
5719 :
5720 : int ASN1CALL
5721 94297 : encode_METHOD_DATA(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const METHOD_DATA *data, size_t *size)
5722 : {
5723 94297 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
5724 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
5725 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
5726 :
5727 238766 : for(i = (int)(data)->len - 1; i >= 0; --i) {
5728 144469 : size_t Top_tag_for_oldret = ret;
5729 144469 : ret = 0;
5730 144469 : e = encode_PA_DATA(p, len, &(data)->val[i], &l);
5731 144469 : if (e) return e;
5732 144469 : p -= l; len -= l; ret += l;
5733 :
5734 144469 : ret += Top_tag_for_oldret;
5735 : }
5736 94297 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
5737 94297 : if (e) return e;
5738 94297 : p -= l; len -= l; ret += l;
5739 :
5740 94297 : *size = ret;
5741 94297 : return 0;
5742 : }
5743 :
5744 : int ASN1CALL
5745 108630 : decode_METHOD_DATA(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, METHOD_DATA *data, size_t *size)
5746 : {
5747 108630 : size_t ret = 0;
5748 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
5749 : int e HEIMDAL_UNUSED_ATTRIBUTE;
5750 :
5751 108630 : memset(data, 0, sizeof(*data));
5752 : {
5753 : size_t Top_datalen, Top_oldlen;
5754 : Der_type Top_type;
5755 108630 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
5756 108630 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
5757 108630 : if(e) goto fail;
5758 108630 : p += l; len -= l; ret += l;
5759 108630 : Top_oldlen = len;
5760 108630 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
5761 108630 : len = Top_datalen;
5762 : {
5763 108630 : size_t Top_Tag_origlen = len;
5764 108630 : size_t Top_Tag_oldret = ret;
5765 108630 : size_t Top_Tag_olen = 0;
5766 : void *Top_Tag_tmp;
5767 108630 : ret = 0;
5768 108630 : (data)->len = 0;
5769 108630 : (data)->val = NULL;
5770 373176 : while(ret < Top_Tag_origlen) {
5771 155916 : size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
5772 155916 : if (Top_Tag_olen > Top_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
5773 155916 : Top_Tag_olen = Top_Tag_nlen;
5774 155916 : Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
5775 155916 : if (Top_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
5776 155916 : (data)->val = Top_Tag_tmp;
5777 155916 : e = decode_PA_DATA(p, len, &(data)->val[(data)->len], &l);
5778 155916 : if(e) goto fail;
5779 155916 : p += l; len -= l; ret += l;
5780 155916 : (data)->len++;
5781 155916 : len = Top_Tag_origlen - ret;
5782 : }
5783 108630 : ret += Top_Tag_oldret;
5784 : }
5785 108630 : len = Top_oldlen - Top_datalen;
5786 : }
5787 203633 : if(size) *size = ret;
5788 106443 : return 0;
5789 0 : fail:
5790 0 : free_METHOD_DATA(data);
5791 0 : return e;
5792 : }
5793 :
5794 : void ASN1CALL
5795 314957 : free_METHOD_DATA(METHOD_DATA *data)
5796 : {
5797 922388 : while((data)->len){
5798 292474 : free_PA_DATA(&(data)->val[(data)->len-1]);
5799 292474 : (data)->len--;
5800 : }
5801 314957 : free((data)->val);
5802 314957 : (data)->val = NULL;
5803 314957 : }
5804 :
5805 : size_t ASN1CALL
5806 94297 : length_METHOD_DATA(const METHOD_DATA *data)
5807 : {
5808 94297 : size_t ret = 0;
5809 : {
5810 94297 : size_t Top_tag_oldret = ret;
5811 : int i;
5812 94297 : ret = 0;
5813 238766 : for(i = (data)->len - 1; i >= 0; --i){
5814 144469 : size_t Top_tag_for_oldret = ret;
5815 144469 : ret = 0;
5816 144469 : ret += length_PA_DATA(&(data)->val[i]);
5817 144469 : ret += Top_tag_for_oldret;
5818 : }
5819 94297 : ret += Top_tag_oldret;
5820 : }
5821 94297 : ret += 1 + der_length_len (ret);
5822 94297 : return ret;
5823 : }
5824 :
5825 : int ASN1CALL
5826 302 : copy_METHOD_DATA(const METHOD_DATA *from, METHOD_DATA *to)
5827 : {
5828 302 : memset(to, 0, sizeof(*to));
5829 302 : if(((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
5830 0 : goto fail;
5831 604 : for((to)->len = 0; (to)->len < (from)->len; (to)->len++){
5832 302 : if(copy_PA_DATA(&(from)->val[(to)->len], &(to)->val[(to)->len])) goto fail;
5833 : }
5834 302 : return 0;
5835 0 : fail:
5836 0 : free_METHOD_DATA(to);
5837 0 : return ENOMEM;
5838 : }
5839 :
5840 : int ASN1CALL
5841 302 : add_METHOD_DATA(METHOD_DATA *data, const PA_DATA *element)
5842 : {
5843 : int ret;
5844 : void *ptr;
5845 :
5846 302 : ptr = realloc(data->val,
5847 302 : (data->len + 1) * sizeof(data->val[0]));
5848 302 : if (ptr == NULL) return ENOMEM;
5849 302 : data->val = ptr;
5850 :
5851 302 : ret = copy_PA_DATA(element, &data->val[data->len]);
5852 302 : if (ret) return ret;
5853 302 : data->len++;
5854 302 : return 0;
5855 : }
5856 :
5857 : int ASN1CALL
5858 0 : remove_METHOD_DATA(METHOD_DATA *data, unsigned int element)
5859 : {
5860 : void *ptr;
5861 :
5862 0 : if (data->len == 0 || element >= data->len)
5863 0 : return ASN1_OVERRUN;
5864 0 : free_PA_DATA(&data->val[element]);
5865 0 : data->len--;
5866 0 : if (element < data->len)
5867 0 : memmove(&data->val[element], &data->val[element + 1],
5868 0 : sizeof(data->val[0]) * data->len);
5869 0 : ptr = realloc(data->val, data->len * sizeof(data->val[0]));
5870 0 : if (ptr != NULL || data->len == 0) data->val = ptr;
5871 0 : return 0;
5872 : }
5873 :
5874 : int ASN1CALL
5875 0 : encode_TypedData(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const TypedData *data, size_t *size)
5876 : {
5877 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
5878 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
5879 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
5880 :
5881 : /* data-value */
5882 0 : if((data)->data_value) {
5883 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
5884 0 : ret = 0;
5885 0 : e = der_put_octet_string(p, len, (data)->data_value, &l);
5886 0 : if (e) return e;
5887 0 : p -= l; len -= l; ret += l;
5888 :
5889 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
5890 0 : if (e) return e;
5891 0 : p -= l; len -= l; ret += l;
5892 :
5893 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
5894 0 : if (e) return e;
5895 0 : p -= l; len -= l; ret += l;
5896 :
5897 0 : ret += Top_tag_oldret;
5898 : }
5899 : /* data-type */
5900 : {
5901 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
5902 0 : ret = 0;
5903 0 : e = encode_krb5int32(p, len, &(data)->data_type, &l);
5904 0 : if (e) return e;
5905 0 : p -= l; len -= l; ret += l;
5906 :
5907 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
5908 0 : if (e) return e;
5909 0 : p -= l; len -= l; ret += l;
5910 :
5911 0 : ret += Top_tag_oldret;
5912 : }
5913 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
5914 0 : if (e) return e;
5915 0 : p -= l; len -= l; ret += l;
5916 :
5917 0 : *size = ret;
5918 0 : return 0;
5919 : }
5920 :
5921 : int ASN1CALL
5922 0 : decode_TypedData(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, TypedData *data, size_t *size)
5923 : {
5924 0 : size_t ret = 0;
5925 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
5926 : int e HEIMDAL_UNUSED_ATTRIBUTE;
5927 :
5928 0 : memset(data, 0, sizeof(*data));
5929 : {
5930 : size_t Top_datalen, Top_oldlen;
5931 : Der_type Top_type;
5932 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
5933 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
5934 0 : if(e) goto fail;
5935 0 : p += l; len -= l; ret += l;
5936 0 : Top_oldlen = len;
5937 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
5938 0 : len = Top_datalen;
5939 : {
5940 : size_t data_type_datalen, data_type_oldlen;
5941 : Der_type data_type_type;
5942 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &data_type_type, 0, &data_type_datalen, &l);
5943 0 : if (e == 0 && data_type_type != CONS) { e = ASN1_BAD_ID; }
5944 0 : if(e) goto fail;
5945 0 : p += l; len -= l; ret += l;
5946 0 : data_type_oldlen = len;
5947 0 : if (data_type_datalen > len) { e = ASN1_OVERRUN; goto fail; }
5948 0 : len = data_type_datalen;
5949 0 : e = decode_krb5int32(p, len, &(data)->data_type, &l);
5950 0 : if(e) goto fail;
5951 0 : p += l; len -= l; ret += l;
5952 0 : len = data_type_oldlen - data_type_datalen;
5953 : }
5954 : {
5955 : size_t data_value_datalen, data_value_oldlen;
5956 : Der_type data_value_type;
5957 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &data_value_type, 1, &data_value_datalen, &l);
5958 0 : if (e == 0 && data_value_type != CONS) { e = ASN1_BAD_ID; }
5959 0 : if(e) {
5960 0 : (data)->data_value = NULL;
5961 : } else {
5962 0 : (data)->data_value = calloc(1, sizeof(*(data)->data_value));
5963 0 : if ((data)->data_value == NULL) { e = ENOMEM; goto fail; }
5964 0 : p += l; len -= l; ret += l;
5965 0 : data_value_oldlen = len;
5966 0 : if (data_value_datalen > len) { e = ASN1_OVERRUN; goto fail; }
5967 0 : len = data_value_datalen;
5968 : {
5969 : size_t data_value_Tag_datalen, data_value_Tag_oldlen;
5970 : Der_type data_value_Tag_type;
5971 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &data_value_Tag_type, UT_OctetString, &data_value_Tag_datalen, &l);
5972 0 : if (e == 0 && data_value_Tag_type != PRIM) { e = ASN1_BAD_ID; }
5973 0 : if(e) goto fail;
5974 0 : p += l; len -= l; ret += l;
5975 0 : data_value_Tag_oldlen = len;
5976 0 : if (data_value_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
5977 0 : len = data_value_Tag_datalen;
5978 0 : e = der_get_octet_string(p, len, (data)->data_value, &l);
5979 0 : if(e) goto fail;
5980 0 : p += l; len -= l; ret += l;
5981 0 : len = data_value_Tag_oldlen - data_value_Tag_datalen;
5982 : }
5983 0 : len = data_value_oldlen - data_value_datalen;
5984 : }
5985 : }
5986 0 : len = Top_oldlen - Top_datalen;
5987 : }
5988 0 : if(size) *size = ret;
5989 0 : return 0;
5990 0 : fail:
5991 0 : free_TypedData(data);
5992 0 : return e;
5993 : }
5994 :
5995 : void ASN1CALL
5996 0 : free_TypedData(TypedData *data)
5997 : {
5998 0 : free_krb5int32(&(data)->data_type);
5999 0 : if((data)->data_value) {
6000 0 : der_free_octet_string((data)->data_value);
6001 0 : free((data)->data_value);
6002 0 : (data)->data_value = NULL;
6003 : }
6004 0 : }
6005 :
6006 : size_t ASN1CALL
6007 0 : length_TypedData(const TypedData *data)
6008 : {
6009 0 : size_t ret = 0;
6010 : {
6011 0 : size_t Top_tag_oldret = ret;
6012 0 : ret = 0;
6013 0 : ret += length_krb5int32(&(data)->data_type);
6014 0 : ret += 1 + der_length_len (ret);
6015 0 : ret += Top_tag_oldret;
6016 : }
6017 0 : if((data)->data_value){
6018 0 : size_t Top_tag_oldret = ret;
6019 0 : ret = 0;
6020 0 : ret += der_length_octet_string((data)->data_value);
6021 0 : ret += 1 + der_length_len (ret);
6022 0 : ret += 1 + der_length_len (ret);
6023 0 : ret += Top_tag_oldret;
6024 : }
6025 0 : ret += 1 + der_length_len (ret);
6026 0 : return ret;
6027 : }
6028 :
6029 : int ASN1CALL
6030 0 : copy_TypedData(const TypedData *from, TypedData *to)
6031 : {
6032 0 : memset(to, 0, sizeof(*to));
6033 0 : if(copy_krb5int32(&(from)->data_type, &(to)->data_type)) goto fail;
6034 0 : if((from)->data_value) {
6035 0 : (to)->data_value = malloc(sizeof(*(to)->data_value));
6036 0 : if((to)->data_value == NULL) goto fail;
6037 0 : if(der_copy_octet_string((from)->data_value, (to)->data_value)) goto fail;
6038 : }else
6039 0 : (to)->data_value = NULL;
6040 0 : return 0;
6041 0 : fail:
6042 0 : free_TypedData(to);
6043 0 : return ENOMEM;
6044 : }
6045 :
6046 : int ASN1CALL
6047 0 : encode_TYPED_DATA(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const TYPED_DATA *data, size_t *size)
6048 : {
6049 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
6050 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
6051 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
6052 :
6053 0 : for(i = (int)(data)->len - 1; i >= 0; --i) {
6054 0 : size_t Top_tag_for_oldret = ret;
6055 0 : ret = 0;
6056 0 : e = encode_TypedData(p, len, &(data)->val[i], &l);
6057 0 : if (e) return e;
6058 0 : p -= l; len -= l; ret += l;
6059 :
6060 0 : ret += Top_tag_for_oldret;
6061 : }
6062 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
6063 0 : if (e) return e;
6064 0 : p -= l; len -= l; ret += l;
6065 :
6066 0 : *size = ret;
6067 0 : return 0;
6068 : }
6069 :
6070 : int ASN1CALL
6071 0 : decode_TYPED_DATA(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, TYPED_DATA *data, size_t *size)
6072 : {
6073 0 : size_t ret = 0;
6074 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
6075 : int e HEIMDAL_UNUSED_ATTRIBUTE;
6076 :
6077 0 : memset(data, 0, sizeof(*data));
6078 : {
6079 : size_t Top_datalen, Top_oldlen;
6080 : Der_type Top_type;
6081 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
6082 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
6083 0 : if(e) goto fail;
6084 0 : p += l; len -= l; ret += l;
6085 0 : Top_oldlen = len;
6086 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
6087 0 : len = Top_datalen;
6088 : {
6089 0 : size_t Top_Tag_origlen = len;
6090 0 : size_t Top_Tag_oldret = ret;
6091 0 : size_t Top_Tag_olen = 0;
6092 : void *Top_Tag_tmp;
6093 0 : ret = 0;
6094 0 : (data)->len = 0;
6095 0 : (data)->val = NULL;
6096 0 : while(ret < Top_Tag_origlen) {
6097 0 : size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
6098 0 : if (Top_Tag_olen > Top_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
6099 0 : Top_Tag_olen = Top_Tag_nlen;
6100 0 : Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
6101 0 : if (Top_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
6102 0 : (data)->val = Top_Tag_tmp;
6103 0 : e = decode_TypedData(p, len, &(data)->val[(data)->len], &l);
6104 0 : if(e) goto fail;
6105 0 : p += l; len -= l; ret += l;
6106 0 : (data)->len++;
6107 0 : len = Top_Tag_origlen - ret;
6108 : }
6109 0 : ret += Top_Tag_oldret;
6110 : }
6111 0 : if ((data)->len < 1) {
6112 0 : e = ASN1_MIN_CONSTRAINT; goto fail;
6113 : }
6114 0 : len = Top_oldlen - Top_datalen;
6115 : }
6116 0 : if(size) *size = ret;
6117 0 : return 0;
6118 0 : fail:
6119 0 : free_TYPED_DATA(data);
6120 0 : return e;
6121 : }
6122 :
6123 : void ASN1CALL
6124 0 : free_TYPED_DATA(TYPED_DATA *data)
6125 : {
6126 0 : while((data)->len){
6127 0 : free_TypedData(&(data)->val[(data)->len-1]);
6128 0 : (data)->len--;
6129 : }
6130 0 : free((data)->val);
6131 0 : (data)->val = NULL;
6132 0 : }
6133 :
6134 : size_t ASN1CALL
6135 0 : length_TYPED_DATA(const TYPED_DATA *data)
6136 : {
6137 0 : size_t ret = 0;
6138 : {
6139 0 : size_t Top_tag_oldret = ret;
6140 : int i;
6141 0 : ret = 0;
6142 0 : for(i = (data)->len - 1; i >= 0; --i){
6143 0 : size_t Top_tag_for_oldret = ret;
6144 0 : ret = 0;
6145 0 : ret += length_TypedData(&(data)->val[i]);
6146 0 : ret += Top_tag_for_oldret;
6147 : }
6148 0 : ret += Top_tag_oldret;
6149 : }
6150 0 : ret += 1 + der_length_len (ret);
6151 0 : return ret;
6152 : }
6153 :
6154 : int ASN1CALL
6155 0 : copy_TYPED_DATA(const TYPED_DATA *from, TYPED_DATA *to)
6156 : {
6157 0 : memset(to, 0, sizeof(*to));
6158 0 : if(((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
6159 0 : goto fail;
6160 0 : for((to)->len = 0; (to)->len < (from)->len; (to)->len++){
6161 0 : if(copy_TypedData(&(from)->val[(to)->len], &(to)->val[(to)->len])) goto fail;
6162 : }
6163 0 : return 0;
6164 0 : fail:
6165 0 : free_TYPED_DATA(to);
6166 0 : return ENOMEM;
6167 : }
6168 :
6169 : int ASN1CALL
6170 167372 : encode_KDC_REQ_BODY(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const KDC_REQ_BODY *data, size_t *size)
6171 : {
6172 167372 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
6173 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
6174 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
6175 :
6176 : /* additional-tickets */
6177 167372 : if((data)->additional_tickets) {
6178 66 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
6179 66 : ret = 0;
6180 132 : for(i = (int)((data)->additional_tickets)->len - 1; i >= 0; --i) {
6181 66 : size_t additional_tickets_tag_tag_for_oldret = ret;
6182 66 : ret = 0;
6183 66 : e = encode_Ticket(p, len, &((data)->additional_tickets)->val[i], &l);
6184 66 : if (e) return e;
6185 66 : p -= l; len -= l; ret += l;
6186 :
6187 66 : ret += additional_tickets_tag_tag_for_oldret;
6188 : }
6189 66 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
6190 66 : if (e) return e;
6191 66 : p -= l; len -= l; ret += l;
6192 :
6193 66 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 11, &l);
6194 66 : if (e) return e;
6195 66 : p -= l; len -= l; ret += l;
6196 :
6197 66 : ret += Top_tag_oldret;
6198 : }
6199 : /* enc-authorization-data */
6200 167372 : if((data)->enc_authorization_data) {
6201 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
6202 0 : ret = 0;
6203 0 : e = encode_EncryptedData(p, len, (data)->enc_authorization_data, &l);
6204 0 : if (e) return e;
6205 0 : p -= l; len -= l; ret += l;
6206 :
6207 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 10, &l);
6208 0 : if (e) return e;
6209 0 : p -= l; len -= l; ret += l;
6210 :
6211 0 : ret += Top_tag_oldret;
6212 : }
6213 : /* addresses */
6214 167372 : if((data)->addresses) {
6215 77 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
6216 77 : ret = 0;
6217 77 : e = encode_HostAddresses(p, len, (data)->addresses, &l);
6218 77 : if (e) return e;
6219 77 : p -= l; len -= l; ret += l;
6220 :
6221 77 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 9, &l);
6222 77 : if (e) return e;
6223 77 : p -= l; len -= l; ret += l;
6224 :
6225 77 : ret += Top_tag_oldret;
6226 : }
6227 : /* etype */
6228 : {
6229 167372 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
6230 167372 : ret = 0;
6231 956637 : for(i = (int)(&(data)->etype)->len - 1; i >= 0; --i) {
6232 789265 : size_t etype_tag_tag_for_oldret = ret;
6233 789265 : ret = 0;
6234 789265 : e = encode_ENCTYPE(p, len, &(&(data)->etype)->val[i], &l);
6235 789265 : if (e) return e;
6236 789265 : p -= l; len -= l; ret += l;
6237 :
6238 789265 : ret += etype_tag_tag_for_oldret;
6239 : }
6240 167372 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
6241 167372 : if (e) return e;
6242 167372 : p -= l; len -= l; ret += l;
6243 :
6244 167372 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 8, &l);
6245 167372 : if (e) return e;
6246 167372 : p -= l; len -= l; ret += l;
6247 :
6248 167372 : ret += Top_tag_oldret;
6249 : }
6250 : /* nonce */
6251 : {
6252 167372 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
6253 167372 : ret = 0;
6254 167372 : e = encode_krb5int32(p, len, &(data)->nonce, &l);
6255 167372 : if (e) return e;
6256 167372 : p -= l; len -= l; ret += l;
6257 :
6258 167372 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 7, &l);
6259 167372 : if (e) return e;
6260 167372 : p -= l; len -= l; ret += l;
6261 :
6262 167372 : ret += Top_tag_oldret;
6263 : }
6264 : /* rtime */
6265 167372 : if((data)->rtime) {
6266 132 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
6267 132 : ret = 0;
6268 132 : e = encode_KerberosTime(p, len, (data)->rtime, &l);
6269 132 : if (e) return e;
6270 132 : p -= l; len -= l; ret += l;
6271 :
6272 132 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 6, &l);
6273 132 : if (e) return e;
6274 132 : p -= l; len -= l; ret += l;
6275 :
6276 132 : ret += Top_tag_oldret;
6277 : }
6278 : /* till */
6279 167372 : if((data)->till) {
6280 167372 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
6281 167372 : ret = 0;
6282 167372 : e = encode_KerberosTime(p, len, (data)->till, &l);
6283 167372 : if (e) return e;
6284 167372 : p -= l; len -= l; ret += l;
6285 :
6286 167372 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 5, &l);
6287 167372 : if (e) return e;
6288 167372 : p -= l; len -= l; ret += l;
6289 :
6290 167372 : ret += Top_tag_oldret;
6291 : }
6292 : /* from */
6293 167372 : if((data)->from) {
6294 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
6295 0 : ret = 0;
6296 0 : e = encode_KerberosTime(p, len, (data)->from, &l);
6297 0 : if (e) return e;
6298 0 : p -= l; len -= l; ret += l;
6299 :
6300 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 4, &l);
6301 0 : if (e) return e;
6302 0 : p -= l; len -= l; ret += l;
6303 :
6304 0 : ret += Top_tag_oldret;
6305 : }
6306 : /* sname */
6307 167372 : if((data)->sname) {
6308 167369 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
6309 167369 : ret = 0;
6310 167369 : e = encode_PrincipalName(p, len, (data)->sname, &l);
6311 167369 : if (e) return e;
6312 167369 : p -= l; len -= l; ret += l;
6313 :
6314 167369 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
6315 167369 : if (e) return e;
6316 167369 : p -= l; len -= l; ret += l;
6317 :
6318 167369 : ret += Top_tag_oldret;
6319 : }
6320 : /* realm */
6321 : {
6322 167372 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
6323 167372 : ret = 0;
6324 167372 : e = encode_Realm(p, len, &(data)->realm, &l);
6325 167372 : if (e) return e;
6326 167372 : p -= l; len -= l; ret += l;
6327 :
6328 167372 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
6329 167372 : if (e) return e;
6330 167372 : p -= l; len -= l; ret += l;
6331 :
6332 167372 : ret += Top_tag_oldret;
6333 : }
6334 : /* cname */
6335 167372 : if((data)->cname) {
6336 44780 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
6337 44780 : ret = 0;
6338 44780 : e = encode_PrincipalName(p, len, (data)->cname, &l);
6339 44780 : if (e) return e;
6340 44780 : p -= l; len -= l; ret += l;
6341 :
6342 44780 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
6343 44780 : if (e) return e;
6344 44780 : p -= l; len -= l; ret += l;
6345 :
6346 44780 : ret += Top_tag_oldret;
6347 : }
6348 : /* kdc-options */
6349 : {
6350 167372 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
6351 167372 : ret = 0;
6352 167372 : e = encode_KDCOptions(p, len, &(data)->kdc_options, &l);
6353 167372 : if (e) return e;
6354 167372 : p -= l; len -= l; ret += l;
6355 :
6356 167372 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
6357 167372 : if (e) return e;
6358 167372 : p -= l; len -= l; ret += l;
6359 :
6360 167372 : ret += Top_tag_oldret;
6361 : }
6362 167372 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
6363 167372 : if (e) return e;
6364 167372 : p -= l; len -= l; ret += l;
6365 :
6366 167372 : *size = ret;
6367 167372 : return 0;
6368 : }
6369 :
6370 : int ASN1CALL
6371 104664 : decode_KDC_REQ_BODY(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, KDC_REQ_BODY *data, size_t *size)
6372 : {
6373 104664 : size_t ret = 0;
6374 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
6375 : int e HEIMDAL_UNUSED_ATTRIBUTE;
6376 :
6377 104664 : memset(data, 0, sizeof(*data));
6378 : {
6379 : size_t Top_datalen, Top_oldlen;
6380 : Der_type Top_type;
6381 104664 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
6382 104664 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
6383 104664 : if(e) goto fail;
6384 104664 : p += l; len -= l; ret += l;
6385 104664 : Top_oldlen = len;
6386 104664 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
6387 104664 : len = Top_datalen;
6388 : {
6389 : size_t kdc_options_datalen, kdc_options_oldlen;
6390 : Der_type kdc_options_type;
6391 104664 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &kdc_options_type, 0, &kdc_options_datalen, &l);
6392 104664 : if (e == 0 && kdc_options_type != CONS) { e = ASN1_BAD_ID; }
6393 104664 : if(e) goto fail;
6394 104664 : p += l; len -= l; ret += l;
6395 104664 : kdc_options_oldlen = len;
6396 104664 : if (kdc_options_datalen > len) { e = ASN1_OVERRUN; goto fail; }
6397 104664 : len = kdc_options_datalen;
6398 104664 : e = decode_KDCOptions(p, len, &(data)->kdc_options, &l);
6399 104664 : if(e) goto fail;
6400 104664 : p += l; len -= l; ret += l;
6401 104664 : len = kdc_options_oldlen - kdc_options_datalen;
6402 : }
6403 : {
6404 : size_t cname_datalen, cname_oldlen;
6405 : Der_type cname_type;
6406 104664 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &cname_type, 1, &cname_datalen, &l);
6407 157505 : if (e == 0 && cname_type != CONS) { e = ASN1_BAD_ID; }
6408 104664 : if(e) {
6409 50938 : (data)->cname = NULL;
6410 : } else {
6411 53726 : (data)->cname = calloc(1, sizeof(*(data)->cname));
6412 53726 : if ((data)->cname == NULL) { e = ENOMEM; goto fail; }
6413 53726 : p += l; len -= l; ret += l;
6414 53726 : cname_oldlen = len;
6415 53726 : if (cname_datalen > len) { e = ASN1_OVERRUN; goto fail; }
6416 53726 : len = cname_datalen;
6417 53726 : e = decode_PrincipalName(p, len, (data)->cname, &l);
6418 53726 : if(e) goto fail;
6419 53726 : p += l; len -= l; ret += l;
6420 53726 : len = cname_oldlen - cname_datalen;
6421 : }
6422 : }
6423 : {
6424 : size_t realm_datalen, realm_oldlen;
6425 : Der_type realm_type;
6426 104664 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &realm_type, 2, &realm_datalen, &l);
6427 209328 : if (e == 0 && realm_type != CONS) { e = ASN1_BAD_ID; }
6428 104664 : if(e) goto fail;
6429 104664 : p += l; len -= l; ret += l;
6430 104664 : realm_oldlen = len;
6431 104664 : if (realm_datalen > len) { e = ASN1_OVERRUN; goto fail; }
6432 104664 : len = realm_datalen;
6433 104664 : e = decode_Realm(p, len, &(data)->realm, &l);
6434 104664 : if(e) goto fail;
6435 104664 : p += l; len -= l; ret += l;
6436 104664 : len = realm_oldlen - realm_datalen;
6437 : }
6438 : {
6439 : size_t sname_datalen, sname_oldlen;
6440 : Der_type sname_type;
6441 104664 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &sname_type, 3, &sname_datalen, &l);
6442 207350 : if (e == 0 && sname_type != CONS) { e = ASN1_BAD_ID; }
6443 104664 : if(e) {
6444 4 : (data)->sname = NULL;
6445 : } else {
6446 104660 : (data)->sname = calloc(1, sizeof(*(data)->sname));
6447 104660 : if ((data)->sname == NULL) { e = ENOMEM; goto fail; }
6448 104660 : p += l; len -= l; ret += l;
6449 104660 : sname_oldlen = len;
6450 104660 : if (sname_datalen > len) { e = ASN1_OVERRUN; goto fail; }
6451 104660 : len = sname_datalen;
6452 104660 : e = decode_PrincipalName(p, len, (data)->sname, &l);
6453 104660 : if(e) goto fail;
6454 104660 : p += l; len -= l; ret += l;
6455 104660 : len = sname_oldlen - sname_datalen;
6456 : }
6457 : }
6458 : {
6459 : size_t from_datalen, from_oldlen;
6460 : Der_type from_type;
6461 104664 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &from_type, 4, &from_datalen, &l);
6462 104664 : if (e == 0 && from_type != CONS) { e = ASN1_BAD_ID; }
6463 104664 : if(e) {
6464 104664 : (data)->from = NULL;
6465 : } else {
6466 0 : (data)->from = calloc(1, sizeof(*(data)->from));
6467 0 : if ((data)->from == NULL) { e = ENOMEM; goto fail; }
6468 0 : p += l; len -= l; ret += l;
6469 0 : from_oldlen = len;
6470 0 : if (from_datalen > len) { e = ASN1_OVERRUN; goto fail; }
6471 0 : len = from_datalen;
6472 0 : e = decode_KerberosTime(p, len, (data)->from, &l);
6473 0 : if(e) goto fail;
6474 0 : p += l; len -= l; ret += l;
6475 0 : len = from_oldlen - from_datalen;
6476 : }
6477 : }
6478 : {
6479 : size_t till_datalen, till_oldlen;
6480 : Der_type till_type;
6481 104664 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &till_type, 5, &till_datalen, &l);
6482 209328 : if (e == 0 && till_type != CONS) { e = ASN1_BAD_ID; }
6483 104664 : if(e) {
6484 0 : (data)->till = NULL;
6485 : } else {
6486 104664 : (data)->till = calloc(1, sizeof(*(data)->till));
6487 104664 : if ((data)->till == NULL) { e = ENOMEM; goto fail; }
6488 104664 : p += l; len -= l; ret += l;
6489 104664 : till_oldlen = len;
6490 104664 : if (till_datalen > len) { e = ASN1_OVERRUN; goto fail; }
6491 104664 : len = till_datalen;
6492 104664 : e = decode_KerberosTime(p, len, (data)->till, &l);
6493 104664 : if(e) goto fail;
6494 104664 : p += l; len -= l; ret += l;
6495 104664 : len = till_oldlen - till_datalen;
6496 : }
6497 : }
6498 : {
6499 : size_t rtime_datalen, rtime_oldlen;
6500 : Der_type rtime_type;
6501 104664 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &rtime_type, 6, &rtime_datalen, &l);
6502 104943 : if (e == 0 && rtime_type != CONS) { e = ASN1_BAD_ID; }
6503 104664 : if(e) {
6504 104385 : (data)->rtime = NULL;
6505 : } else {
6506 279 : (data)->rtime = calloc(1, sizeof(*(data)->rtime));
6507 279 : if ((data)->rtime == NULL) { e = ENOMEM; goto fail; }
6508 279 : p += l; len -= l; ret += l;
6509 279 : rtime_oldlen = len;
6510 279 : if (rtime_datalen > len) { e = ASN1_OVERRUN; goto fail; }
6511 279 : len = rtime_datalen;
6512 279 : e = decode_KerberosTime(p, len, (data)->rtime, &l);
6513 279 : if(e) goto fail;
6514 279 : p += l; len -= l; ret += l;
6515 279 : len = rtime_oldlen - rtime_datalen;
6516 : }
6517 : }
6518 : {
6519 : size_t nonce_datalen, nonce_oldlen;
6520 : Der_type nonce_type;
6521 104664 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &nonce_type, 7, &nonce_datalen, &l);
6522 209328 : if (e == 0 && nonce_type != CONS) { e = ASN1_BAD_ID; }
6523 104664 : if(e) goto fail;
6524 104664 : p += l; len -= l; ret += l;
6525 104664 : nonce_oldlen = len;
6526 104664 : if (nonce_datalen > len) { e = ASN1_OVERRUN; goto fail; }
6527 104664 : len = nonce_datalen;
6528 104664 : e = decode_krb5int32(p, len, &(data)->nonce, &l);
6529 104664 : if(e) goto fail;
6530 104664 : p += l; len -= l; ret += l;
6531 104664 : len = nonce_oldlen - nonce_datalen;
6532 : }
6533 : {
6534 : size_t etype_datalen, etype_oldlen;
6535 : Der_type etype_type;
6536 104664 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &etype_type, 8, &etype_datalen, &l);
6537 207354 : if (e == 0 && etype_type != CONS) { e = ASN1_BAD_ID; }
6538 104664 : if(e) goto fail;
6539 104664 : p += l; len -= l; ret += l;
6540 104664 : etype_oldlen = len;
6541 104664 : if (etype_datalen > len) { e = ASN1_OVERRUN; goto fail; }
6542 104664 : len = etype_datalen;
6543 : {
6544 : size_t etype_Tag_datalen, etype_Tag_oldlen;
6545 : Der_type etype_Tag_type;
6546 104664 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &etype_Tag_type, UT_Sequence, &etype_Tag_datalen, &l);
6547 104664 : if (e == 0 && etype_Tag_type != CONS) { e = ASN1_BAD_ID; }
6548 104664 : if(e) goto fail;
6549 104664 : p += l; len -= l; ret += l;
6550 104664 : etype_Tag_oldlen = len;
6551 104664 : if (etype_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
6552 104664 : len = etype_Tag_datalen;
6553 : {
6554 104664 : size_t etype_Tag_Tag_origlen = len;
6555 104664 : size_t etype_Tag_Tag_oldret = ret;
6556 104664 : size_t etype_Tag_Tag_olen = 0;
6557 : void *etype_Tag_Tag_tmp;
6558 104664 : ret = 0;
6559 104664 : (&(data)->etype)->len = 0;
6560 104664 : (&(data)->etype)->val = NULL;
6561 697191 : while(ret < etype_Tag_Tag_origlen) {
6562 487863 : size_t etype_Tag_Tag_nlen = etype_Tag_Tag_olen + sizeof(*((&(data)->etype)->val));
6563 487863 : if (etype_Tag_Tag_olen > etype_Tag_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
6564 487863 : etype_Tag_Tag_olen = etype_Tag_Tag_nlen;
6565 487863 : etype_Tag_Tag_tmp = realloc((&(data)->etype)->val, etype_Tag_Tag_olen);
6566 487863 : if (etype_Tag_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
6567 487863 : (&(data)->etype)->val = etype_Tag_Tag_tmp;
6568 487863 : e = decode_ENCTYPE(p, len, &(&(data)->etype)->val[(&(data)->etype)->len], &l);
6569 487863 : if(e) goto fail;
6570 487863 : p += l; len -= l; ret += l;
6571 487863 : (&(data)->etype)->len++;
6572 487863 : len = etype_Tag_Tag_origlen - ret;
6573 : }
6574 104664 : ret += etype_Tag_Tag_oldret;
6575 : }
6576 104664 : len = etype_Tag_oldlen - etype_Tag_datalen;
6577 : }
6578 104664 : len = etype_oldlen - etype_datalen;
6579 : }
6580 : {
6581 : size_t addresses_datalen, addresses_oldlen;
6582 : Der_type addresses_type;
6583 104664 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &addresses_type, 9, &addresses_datalen, &l);
6584 104951 : if (e == 0 && addresses_type != CONS) { e = ASN1_BAD_ID; }
6585 104664 : if(e) {
6586 104377 : (data)->addresses = NULL;
6587 : } else {
6588 287 : (data)->addresses = calloc(1, sizeof(*(data)->addresses));
6589 287 : if ((data)->addresses == NULL) { e = ENOMEM; goto fail; }
6590 287 : p += l; len -= l; ret += l;
6591 287 : addresses_oldlen = len;
6592 287 : if (addresses_datalen > len) { e = ASN1_OVERRUN; goto fail; }
6593 287 : len = addresses_datalen;
6594 287 : e = decode_HostAddresses(p, len, (data)->addresses, &l);
6595 287 : if(e) goto fail;
6596 287 : p += l; len -= l; ret += l;
6597 287 : len = addresses_oldlen - addresses_datalen;
6598 : }
6599 : }
6600 : {
6601 : size_t enc_authorization_data_datalen, enc_authorization_data_oldlen;
6602 : Der_type enc_authorization_data_type;
6603 104664 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &enc_authorization_data_type, 10, &enc_authorization_data_datalen, &l);
6604 104664 : if (e == 0 && enc_authorization_data_type != CONS) { e = ASN1_BAD_ID; }
6605 104664 : if(e) {
6606 104664 : (data)->enc_authorization_data = NULL;
6607 : } else {
6608 0 : (data)->enc_authorization_data = calloc(1, sizeof(*(data)->enc_authorization_data));
6609 0 : if ((data)->enc_authorization_data == NULL) { e = ENOMEM; goto fail; }
6610 0 : p += l; len -= l; ret += l;
6611 0 : enc_authorization_data_oldlen = len;
6612 0 : if (enc_authorization_data_datalen > len) { e = ASN1_OVERRUN; goto fail; }
6613 0 : len = enc_authorization_data_datalen;
6614 0 : e = decode_EncryptedData(p, len, (data)->enc_authorization_data, &l);
6615 0 : if(e) goto fail;
6616 0 : p += l; len -= l; ret += l;
6617 0 : len = enc_authorization_data_oldlen - enc_authorization_data_datalen;
6618 : }
6619 : }
6620 : {
6621 : size_t additional_tickets_datalen, additional_tickets_oldlen;
6622 : Der_type additional_tickets_type;
6623 104664 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &additional_tickets_type, 11, &additional_tickets_datalen, &l);
6624 104686 : if (e == 0 && additional_tickets_type != CONS) { e = ASN1_BAD_ID; }
6625 104664 : if(e) {
6626 104642 : (data)->additional_tickets = NULL;
6627 : } else {
6628 22 : (data)->additional_tickets = calloc(1, sizeof(*(data)->additional_tickets));
6629 22 : if ((data)->additional_tickets == NULL) { e = ENOMEM; goto fail; }
6630 22 : p += l; len -= l; ret += l;
6631 22 : additional_tickets_oldlen = len;
6632 22 : if (additional_tickets_datalen > len) { e = ASN1_OVERRUN; goto fail; }
6633 22 : len = additional_tickets_datalen;
6634 : {
6635 : size_t additional_tickets_Tag_datalen, additional_tickets_Tag_oldlen;
6636 : Der_type additional_tickets_Tag_type;
6637 22 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &additional_tickets_Tag_type, UT_Sequence, &additional_tickets_Tag_datalen, &l);
6638 22 : if (e == 0 && additional_tickets_Tag_type != CONS) { e = ASN1_BAD_ID; }
6639 22 : if(e) goto fail;
6640 22 : p += l; len -= l; ret += l;
6641 22 : additional_tickets_Tag_oldlen = len;
6642 22 : if (additional_tickets_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
6643 22 : len = additional_tickets_Tag_datalen;
6644 : {
6645 22 : size_t additional_tickets_Tag_Tag_origlen = len;
6646 22 : size_t additional_tickets_Tag_Tag_oldret = ret;
6647 22 : size_t additional_tickets_Tag_Tag_olen = 0;
6648 : void *additional_tickets_Tag_Tag_tmp;
6649 22 : ret = 0;
6650 22 : ((data)->additional_tickets)->len = 0;
6651 22 : ((data)->additional_tickets)->val = NULL;
6652 66 : while(ret < additional_tickets_Tag_Tag_origlen) {
6653 22 : size_t additional_tickets_Tag_Tag_nlen = additional_tickets_Tag_Tag_olen + sizeof(*(((data)->additional_tickets)->val));
6654 22 : if (additional_tickets_Tag_Tag_olen > additional_tickets_Tag_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
6655 22 : additional_tickets_Tag_Tag_olen = additional_tickets_Tag_Tag_nlen;
6656 22 : additional_tickets_Tag_Tag_tmp = realloc(((data)->additional_tickets)->val, additional_tickets_Tag_Tag_olen);
6657 22 : if (additional_tickets_Tag_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
6658 22 : ((data)->additional_tickets)->val = additional_tickets_Tag_Tag_tmp;
6659 22 : e = decode_Ticket(p, len, &((data)->additional_tickets)->val[((data)->additional_tickets)->len], &l);
6660 22 : if(e) goto fail;
6661 22 : p += l; len -= l; ret += l;
6662 22 : ((data)->additional_tickets)->len++;
6663 22 : len = additional_tickets_Tag_Tag_origlen - ret;
6664 : }
6665 22 : ret += additional_tickets_Tag_Tag_oldret;
6666 : }
6667 22 : len = additional_tickets_Tag_oldlen - additional_tickets_Tag_datalen;
6668 : }
6669 22 : len = additional_tickets_oldlen - additional_tickets_datalen;
6670 : }
6671 : }
6672 104664 : len = Top_oldlen - Top_datalen;
6673 : }
6674 209328 : if(size) *size = ret;
6675 102690 : return 0;
6676 0 : fail:
6677 0 : free_KDC_REQ_BODY(data);
6678 0 : return e;
6679 : }
6680 :
6681 : void ASN1CALL
6682 205672 : free_KDC_REQ_BODY(KDC_REQ_BODY *data)
6683 : {
6684 205672 : free_KDCOptions(&(data)->kdc_options);
6685 205672 : if((data)->cname) {
6686 75366 : free_PrincipalName((data)->cname);
6687 75366 : free((data)->cname);
6688 75366 : (data)->cname = NULL;
6689 : }
6690 205672 : free_Realm(&(data)->realm);
6691 205672 : if((data)->sname) {
6692 163778 : free_PrincipalName((data)->sname);
6693 163778 : free((data)->sname);
6694 163778 : (data)->sname = NULL;
6695 : }
6696 205672 : if((data)->from) {
6697 0 : free_KerberosTime((data)->from);
6698 0 : free((data)->from);
6699 0 : (data)->from = NULL;
6700 : }
6701 205672 : if((data)->till) {
6702 163782 : free_KerberosTime((data)->till);
6703 163782 : free((data)->till);
6704 163782 : (data)->till = NULL;
6705 : }
6706 205672 : if((data)->rtime) {
6707 358 : free_KerberosTime((data)->rtime);
6708 358 : free((data)->rtime);
6709 358 : (data)->rtime = NULL;
6710 : }
6711 205672 : free_krb5int32(&(data)->nonce);
6712 1182302 : while((&(data)->etype)->len){
6713 770958 : free_ENCTYPE(&(&(data)->etype)->val[(&(data)->etype)->len-1]);
6714 770958 : (&(data)->etype)->len--;
6715 : }
6716 205672 : free((&(data)->etype)->val);
6717 205672 : (&(data)->etype)->val = NULL;
6718 205672 : if((data)->addresses) {
6719 290 : free_HostAddresses((data)->addresses);
6720 290 : free((data)->addresses);
6721 290 : (data)->addresses = NULL;
6722 : }
6723 205672 : if((data)->enc_authorization_data) {
6724 0 : free_EncryptedData((data)->enc_authorization_data);
6725 0 : free((data)->enc_authorization_data);
6726 0 : (data)->enc_authorization_data = NULL;
6727 : }
6728 205672 : if((data)->additional_tickets) {
6729 132 : while(((data)->additional_tickets)->len){
6730 44 : free_Ticket(&((data)->additional_tickets)->val[((data)->additional_tickets)->len-1]);
6731 44 : ((data)->additional_tickets)->len--;
6732 : }
6733 44 : free(((data)->additional_tickets)->val);
6734 44 : ((data)->additional_tickets)->val = NULL;
6735 44 : free((data)->additional_tickets);
6736 44 : (data)->additional_tickets = NULL;
6737 : }
6738 205672 : }
6739 :
6740 : size_t ASN1CALL
6741 167372 : length_KDC_REQ_BODY(const KDC_REQ_BODY *data)
6742 : {
6743 167372 : size_t ret = 0;
6744 : {
6745 167372 : size_t Top_tag_oldret = ret;
6746 167372 : ret = 0;
6747 167372 : ret += length_KDCOptions(&(data)->kdc_options);
6748 167372 : ret += 1 + der_length_len (ret);
6749 167372 : ret += Top_tag_oldret;
6750 : }
6751 167372 : if((data)->cname){
6752 44780 : size_t Top_tag_oldret = ret;
6753 44780 : ret = 0;
6754 44780 : ret += length_PrincipalName((data)->cname);
6755 44780 : ret += 1 + der_length_len (ret);
6756 44780 : ret += Top_tag_oldret;
6757 : }
6758 : {
6759 167372 : size_t Top_tag_oldret = ret;
6760 167372 : ret = 0;
6761 167372 : ret += length_Realm(&(data)->realm);
6762 167372 : ret += 1 + der_length_len (ret);
6763 167372 : ret += Top_tag_oldret;
6764 : }
6765 167372 : if((data)->sname){
6766 167369 : size_t Top_tag_oldret = ret;
6767 167369 : ret = 0;
6768 167369 : ret += length_PrincipalName((data)->sname);
6769 167369 : ret += 1 + der_length_len (ret);
6770 167369 : ret += Top_tag_oldret;
6771 : }
6772 167372 : if((data)->from){
6773 0 : size_t Top_tag_oldret = ret;
6774 0 : ret = 0;
6775 0 : ret += length_KerberosTime((data)->from);
6776 0 : ret += 1 + der_length_len (ret);
6777 0 : ret += Top_tag_oldret;
6778 : }
6779 167372 : if((data)->till){
6780 167372 : size_t Top_tag_oldret = ret;
6781 167372 : ret = 0;
6782 167372 : ret += length_KerberosTime((data)->till);
6783 167372 : ret += 1 + der_length_len (ret);
6784 167372 : ret += Top_tag_oldret;
6785 : }
6786 167372 : if((data)->rtime){
6787 132 : size_t Top_tag_oldret = ret;
6788 132 : ret = 0;
6789 132 : ret += length_KerberosTime((data)->rtime);
6790 132 : ret += 1 + der_length_len (ret);
6791 132 : ret += Top_tag_oldret;
6792 : }
6793 : {
6794 167372 : size_t Top_tag_oldret = ret;
6795 167372 : ret = 0;
6796 167372 : ret += length_krb5int32(&(data)->nonce);
6797 167372 : ret += 1 + der_length_len (ret);
6798 167372 : ret += Top_tag_oldret;
6799 : }
6800 : {
6801 167372 : size_t Top_tag_oldret = ret;
6802 167372 : ret = 0;
6803 : {
6804 167372 : size_t etype_tag_tag_oldret = ret;
6805 : int i;
6806 167372 : ret = 0;
6807 956637 : for(i = (&(data)->etype)->len - 1; i >= 0; --i){
6808 789265 : size_t etype_tag_tag_for_oldret = ret;
6809 789265 : ret = 0;
6810 789265 : ret += length_ENCTYPE(&(&(data)->etype)->val[i]);
6811 789265 : ret += etype_tag_tag_for_oldret;
6812 : }
6813 167372 : ret += etype_tag_tag_oldret;
6814 : }
6815 167372 : ret += 1 + der_length_len (ret);
6816 167372 : ret += 1 + der_length_len (ret);
6817 167372 : ret += Top_tag_oldret;
6818 : }
6819 167372 : if((data)->addresses){
6820 77 : size_t Top_tag_oldret = ret;
6821 77 : ret = 0;
6822 77 : ret += length_HostAddresses((data)->addresses);
6823 77 : ret += 1 + der_length_len (ret);
6824 77 : ret += Top_tag_oldret;
6825 : }
6826 167372 : if((data)->enc_authorization_data){
6827 0 : size_t Top_tag_oldret = ret;
6828 0 : ret = 0;
6829 0 : ret += length_EncryptedData((data)->enc_authorization_data);
6830 0 : ret += 1 + der_length_len (ret);
6831 0 : ret += Top_tag_oldret;
6832 : }
6833 167372 : if((data)->additional_tickets){
6834 66 : size_t Top_tag_oldret = ret;
6835 66 : ret = 0;
6836 : {
6837 66 : size_t additional_tickets_tag_tag_oldret = ret;
6838 : int i;
6839 66 : ret = 0;
6840 132 : for(i = ((data)->additional_tickets)->len - 1; i >= 0; --i){
6841 66 : size_t additional_tickets_tag_tag_for_oldret = ret;
6842 66 : ret = 0;
6843 66 : ret += length_Ticket(&((data)->additional_tickets)->val[i]);
6844 66 : ret += additional_tickets_tag_tag_for_oldret;
6845 : }
6846 66 : ret += additional_tickets_tag_tag_oldret;
6847 : }
6848 66 : ret += 1 + der_length_len (ret);
6849 66 : ret += 1 + der_length_len (ret);
6850 66 : ret += Top_tag_oldret;
6851 : }
6852 167372 : ret += 1 + der_length_len (ret);
6853 167372 : return ret;
6854 : }
6855 :
6856 : int ASN1CALL
6857 0 : copy_KDC_REQ_BODY(const KDC_REQ_BODY *from, KDC_REQ_BODY *to)
6858 : {
6859 0 : memset(to, 0, sizeof(*to));
6860 0 : if(copy_KDCOptions(&(from)->kdc_options, &(to)->kdc_options)) goto fail;
6861 0 : if((from)->cname) {
6862 0 : (to)->cname = malloc(sizeof(*(to)->cname));
6863 0 : if((to)->cname == NULL) goto fail;
6864 0 : if(copy_PrincipalName((from)->cname, (to)->cname)) goto fail;
6865 : }else
6866 0 : (to)->cname = NULL;
6867 0 : if(copy_Realm(&(from)->realm, &(to)->realm)) goto fail;
6868 0 : if((from)->sname) {
6869 0 : (to)->sname = malloc(sizeof(*(to)->sname));
6870 0 : if((to)->sname == NULL) goto fail;
6871 0 : if(copy_PrincipalName((from)->sname, (to)->sname)) goto fail;
6872 : }else
6873 0 : (to)->sname = NULL;
6874 0 : if((from)->from) {
6875 0 : (to)->from = malloc(sizeof(*(to)->from));
6876 0 : if((to)->from == NULL) goto fail;
6877 0 : if(copy_KerberosTime((from)->from, (to)->from)) goto fail;
6878 : }else
6879 0 : (to)->from = NULL;
6880 0 : if((from)->till) {
6881 0 : (to)->till = malloc(sizeof(*(to)->till));
6882 0 : if((to)->till == NULL) goto fail;
6883 0 : if(copy_KerberosTime((from)->till, (to)->till)) goto fail;
6884 : }else
6885 0 : (to)->till = NULL;
6886 0 : if((from)->rtime) {
6887 0 : (to)->rtime = malloc(sizeof(*(to)->rtime));
6888 0 : if((to)->rtime == NULL) goto fail;
6889 0 : if(copy_KerberosTime((from)->rtime, (to)->rtime)) goto fail;
6890 : }else
6891 0 : (to)->rtime = NULL;
6892 0 : if(copy_krb5int32(&(from)->nonce, &(to)->nonce)) goto fail;
6893 0 : if(((&(to)->etype)->val = malloc((&(from)->etype)->len * sizeof(*(&(to)->etype)->val))) == NULL && (&(from)->etype)->len != 0)
6894 0 : goto fail;
6895 0 : for((&(to)->etype)->len = 0; (&(to)->etype)->len < (&(from)->etype)->len; (&(to)->etype)->len++){
6896 0 : if(copy_ENCTYPE(&(&(from)->etype)->val[(&(to)->etype)->len], &(&(to)->etype)->val[(&(to)->etype)->len])) goto fail;
6897 : }
6898 0 : if((from)->addresses) {
6899 0 : (to)->addresses = malloc(sizeof(*(to)->addresses));
6900 0 : if((to)->addresses == NULL) goto fail;
6901 0 : if(copy_HostAddresses((from)->addresses, (to)->addresses)) goto fail;
6902 : }else
6903 0 : (to)->addresses = NULL;
6904 0 : if((from)->enc_authorization_data) {
6905 0 : (to)->enc_authorization_data = malloc(sizeof(*(to)->enc_authorization_data));
6906 0 : if((to)->enc_authorization_data == NULL) goto fail;
6907 0 : if(copy_EncryptedData((from)->enc_authorization_data, (to)->enc_authorization_data)) goto fail;
6908 : }else
6909 0 : (to)->enc_authorization_data = NULL;
6910 0 : if((from)->additional_tickets) {
6911 0 : (to)->additional_tickets = malloc(sizeof(*(to)->additional_tickets));
6912 0 : if((to)->additional_tickets == NULL) goto fail;
6913 0 : if((((to)->additional_tickets)->val = malloc(((from)->additional_tickets)->len * sizeof(*((to)->additional_tickets)->val))) == NULL && ((from)->additional_tickets)->len != 0)
6914 0 : goto fail;
6915 0 : for(((to)->additional_tickets)->len = 0; ((to)->additional_tickets)->len < ((from)->additional_tickets)->len; ((to)->additional_tickets)->len++){
6916 0 : if(copy_Ticket(&((from)->additional_tickets)->val[((to)->additional_tickets)->len], &((to)->additional_tickets)->val[((to)->additional_tickets)->len])) goto fail;
6917 : }
6918 : }else
6919 0 : (to)->additional_tickets = NULL;
6920 0 : return 0;
6921 0 : fail:
6922 0 : free_KDC_REQ_BODY(to);
6923 0 : return ENOMEM;
6924 : }
6925 :
6926 : int ASN1CALL
6927 85676 : encode_KDC_REQ(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const KDC_REQ *data, size_t *size)
6928 : {
6929 85676 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
6930 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
6931 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
6932 :
6933 : /* req-body */
6934 : {
6935 85676 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
6936 85676 : ret = 0;
6937 85676 : e = encode_KDC_REQ_BODY(p, len, &(data)->req_body, &l);
6938 85676 : if (e) return e;
6939 85676 : p -= l; len -= l; ret += l;
6940 :
6941 85676 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 4, &l);
6942 85676 : if (e) return e;
6943 85676 : p -= l; len -= l; ret += l;
6944 :
6945 85676 : ret += Top_tag_oldret;
6946 : }
6947 : /* padata */
6948 85676 : if((data)->padata) {
6949 60738 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
6950 60738 : ret = 0;
6951 60738 : e = encode_METHOD_DATA(p, len, (data)->padata, &l);
6952 60738 : if (e) return e;
6953 60738 : p -= l; len -= l; ret += l;
6954 :
6955 60738 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
6956 60738 : if (e) return e;
6957 60738 : p -= l; len -= l; ret += l;
6958 :
6959 60738 : ret += Top_tag_oldret;
6960 : }
6961 : /* msg-type */
6962 : {
6963 85676 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
6964 85676 : ret = 0;
6965 85676 : e = encode_MESSAGE_TYPE(p, len, &(data)->msg_type, &l);
6966 85676 : if (e) return e;
6967 85676 : p -= l; len -= l; ret += l;
6968 :
6969 85676 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
6970 85676 : if (e) return e;
6971 85676 : p -= l; len -= l; ret += l;
6972 :
6973 85676 : ret += Top_tag_oldret;
6974 : }
6975 : /* pvno */
6976 : {
6977 85676 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
6978 85676 : ret = 0;
6979 85676 : e = encode_krb5int32(p, len, &(data)->pvno, &l);
6980 85676 : if (e) return e;
6981 85676 : p -= l; len -= l; ret += l;
6982 :
6983 85676 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
6984 85676 : if (e) return e;
6985 85676 : p -= l; len -= l; ret += l;
6986 :
6987 85676 : ret += Top_tag_oldret;
6988 : }
6989 85676 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
6990 85676 : if (e) return e;
6991 85676 : p -= l; len -= l; ret += l;
6992 :
6993 85676 : *size = ret;
6994 85676 : return 0;
6995 : }
6996 :
6997 : int ASN1CALL
6998 104664 : decode_KDC_REQ(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, KDC_REQ *data, size_t *size)
6999 : {
7000 104664 : size_t ret = 0;
7001 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
7002 : int e HEIMDAL_UNUSED_ATTRIBUTE;
7003 :
7004 104664 : memset(data, 0, sizeof(*data));
7005 : {
7006 : size_t Top_datalen, Top_oldlen;
7007 : Der_type Top_type;
7008 104664 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
7009 104664 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
7010 104664 : if(e) goto fail;
7011 104664 : p += l; len -= l; ret += l;
7012 104664 : Top_oldlen = len;
7013 104664 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7014 104664 : len = Top_datalen;
7015 : {
7016 : size_t pvno_datalen, pvno_oldlen;
7017 : Der_type pvno_type;
7018 104664 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &pvno_type, 1, &pvno_datalen, &l);
7019 104664 : if (e == 0 && pvno_type != CONS) { e = ASN1_BAD_ID; }
7020 104664 : if(e) goto fail;
7021 104664 : p += l; len -= l; ret += l;
7022 104664 : pvno_oldlen = len;
7023 104664 : if (pvno_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7024 104664 : len = pvno_datalen;
7025 104664 : e = decode_krb5int32(p, len, &(data)->pvno, &l);
7026 104664 : if(e) goto fail;
7027 104664 : p += l; len -= l; ret += l;
7028 104664 : len = pvno_oldlen - pvno_datalen;
7029 : }
7030 : {
7031 : size_t msg_type_datalen, msg_type_oldlen;
7032 : Der_type msg_type_type;
7033 104664 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &msg_type_type, 2, &msg_type_datalen, &l);
7034 207354 : if (e == 0 && msg_type_type != CONS) { e = ASN1_BAD_ID; }
7035 104664 : if(e) goto fail;
7036 104664 : p += l; len -= l; ret += l;
7037 104664 : msg_type_oldlen = len;
7038 104664 : if (msg_type_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7039 104664 : len = msg_type_datalen;
7040 104664 : e = decode_MESSAGE_TYPE(p, len, &(data)->msg_type, &l);
7041 104664 : if(e) goto fail;
7042 104664 : p += l; len -= l; ret += l;
7043 104664 : len = msg_type_oldlen - msg_type_datalen;
7044 : }
7045 : {
7046 : size_t padata_datalen, padata_oldlen;
7047 : Der_type padata_type;
7048 104664 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &padata_type, 3, &padata_datalen, &l);
7049 188045 : if (e == 0 && padata_type != CONS) { e = ASN1_BAD_ID; }
7050 104664 : if(e) {
7051 19604 : (data)->padata = NULL;
7052 : } else {
7053 85060 : (data)->padata = calloc(1, sizeof(*(data)->padata));
7054 85060 : if ((data)->padata == NULL) { e = ENOMEM; goto fail; }
7055 85060 : p += l; len -= l; ret += l;
7056 85060 : padata_oldlen = len;
7057 85060 : if (padata_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7058 85060 : len = padata_datalen;
7059 85060 : e = decode_METHOD_DATA(p, len, (data)->padata, &l);
7060 85060 : if(e) goto fail;
7061 85060 : p += l; len -= l; ret += l;
7062 85060 : len = padata_oldlen - padata_datalen;
7063 : }
7064 : }
7065 : {
7066 : size_t req_body_datalen, req_body_oldlen;
7067 : Der_type req_body_type;
7068 104664 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &req_body_type, 4, &req_body_datalen, &l);
7069 209328 : if (e == 0 && req_body_type != CONS) { e = ASN1_BAD_ID; }
7070 104664 : if(e) goto fail;
7071 104664 : p += l; len -= l; ret += l;
7072 104664 : req_body_oldlen = len;
7073 104664 : if (req_body_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7074 104664 : len = req_body_datalen;
7075 104664 : e = decode_KDC_REQ_BODY(p, len, &(data)->req_body, &l);
7076 104664 : if(e) goto fail;
7077 104664 : p += l; len -= l; ret += l;
7078 104664 : len = req_body_oldlen - req_body_datalen;
7079 : }
7080 104664 : len = Top_oldlen - Top_datalen;
7081 : }
7082 209328 : if(size) *size = ret;
7083 102690 : return 0;
7084 0 : fail:
7085 0 : free_KDC_REQ(data);
7086 0 : return e;
7087 : }
7088 :
7089 : void ASN1CALL
7090 205672 : free_KDC_REQ(KDC_REQ *data)
7091 : {
7092 205672 : free_krb5int32(&(data)->pvno);
7093 205672 : free_MESSAGE_TYPE(&(data)->msg_type);
7094 205672 : if((data)->padata) {
7095 136657 : free_METHOD_DATA((data)->padata);
7096 136657 : free((data)->padata);
7097 136657 : (data)->padata = NULL;
7098 : }
7099 205672 : free_KDC_REQ_BODY(&(data)->req_body);
7100 205672 : }
7101 :
7102 : size_t ASN1CALL
7103 85676 : length_KDC_REQ(const KDC_REQ *data)
7104 : {
7105 85676 : size_t ret = 0;
7106 : {
7107 85676 : size_t Top_tag_oldret = ret;
7108 85676 : ret = 0;
7109 85676 : ret += length_krb5int32(&(data)->pvno);
7110 85676 : ret += 1 + der_length_len (ret);
7111 85676 : ret += Top_tag_oldret;
7112 : }
7113 : {
7114 85676 : size_t Top_tag_oldret = ret;
7115 85676 : ret = 0;
7116 85676 : ret += length_MESSAGE_TYPE(&(data)->msg_type);
7117 85676 : ret += 1 + der_length_len (ret);
7118 85676 : ret += Top_tag_oldret;
7119 : }
7120 85676 : if((data)->padata){
7121 60738 : size_t Top_tag_oldret = ret;
7122 60738 : ret = 0;
7123 60738 : ret += length_METHOD_DATA((data)->padata);
7124 60738 : ret += 1 + der_length_len (ret);
7125 60738 : ret += Top_tag_oldret;
7126 : }
7127 : {
7128 85676 : size_t Top_tag_oldret = ret;
7129 85676 : ret = 0;
7130 85676 : ret += length_KDC_REQ_BODY(&(data)->req_body);
7131 85676 : ret += 1 + der_length_len (ret);
7132 85676 : ret += Top_tag_oldret;
7133 : }
7134 85676 : ret += 1 + der_length_len (ret);
7135 85676 : return ret;
7136 : }
7137 :
7138 : int ASN1CALL
7139 0 : copy_KDC_REQ(const KDC_REQ *from, KDC_REQ *to)
7140 : {
7141 0 : memset(to, 0, sizeof(*to));
7142 0 : if(copy_krb5int32(&(from)->pvno, &(to)->pvno)) goto fail;
7143 0 : if(copy_MESSAGE_TYPE(&(from)->msg_type, &(to)->msg_type)) goto fail;
7144 0 : if((from)->padata) {
7145 0 : (to)->padata = malloc(sizeof(*(to)->padata));
7146 0 : if((to)->padata == NULL) goto fail;
7147 0 : if(copy_METHOD_DATA((from)->padata, (to)->padata)) goto fail;
7148 : }else
7149 0 : (to)->padata = NULL;
7150 0 : if(copy_KDC_REQ_BODY(&(from)->req_body, &(to)->req_body)) goto fail;
7151 0 : return 0;
7152 0 : fail:
7153 0 : free_KDC_REQ(to);
7154 0 : return ENOMEM;
7155 : }
7156 :
7157 : int ASN1CALL
7158 44706 : encode_AS_REQ(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const AS_REQ *data, size_t *size)
7159 : {
7160 44706 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
7161 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
7162 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
7163 :
7164 44706 : e = encode_KDC_REQ(p, len, data, &l);
7165 44706 : if (e) return e;
7166 44706 : p -= l; len -= l; ret += l;
7167 :
7168 44706 : e = der_put_length_and_tag (p, len, ret, ASN1_C_APPL, CONS, 10, &l);
7169 44706 : if (e) return e;
7170 44706 : p -= l; len -= l; ret += l;
7171 :
7172 44706 : *size = ret;
7173 44706 : return 0;
7174 : }
7175 :
7176 : int ASN1CALL
7177 95616 : decode_AS_REQ(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, AS_REQ *data, size_t *size)
7178 : {
7179 95616 : size_t ret = 0;
7180 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
7181 : int e HEIMDAL_UNUSED_ATTRIBUTE;
7182 :
7183 95616 : memset(data, 0, sizeof(*data));
7184 : {
7185 : size_t Top_datalen, Top_oldlen;
7186 : Der_type Top_type;
7187 95616 : e = der_match_tag_and_length(p, len, ASN1_C_APPL, &Top_type, 10, &Top_datalen, &l);
7188 95616 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
7189 136417 : if(e) goto fail;
7190 53726 : p += l; len -= l; ret += l;
7191 53726 : Top_oldlen = len;
7192 53726 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7193 53726 : len = Top_datalen;
7194 53726 : e = decode_KDC_REQ(p, len, data, &l);
7195 53726 : if(e) goto fail;
7196 53726 : p += l; len -= l; ret += l;
7197 53726 : len = Top_oldlen - Top_datalen;
7198 : }
7199 107452 : if(size) *size = ret;
7200 52841 : return 0;
7201 41890 : fail:
7202 41890 : free_AS_REQ(data);
7203 41890 : return e;
7204 : }
7205 :
7206 : void ASN1CALL
7207 117256 : free_AS_REQ(AS_REQ *data)
7208 : {
7209 117256 : free_KDC_REQ(data);
7210 117256 : }
7211 :
7212 : size_t ASN1CALL
7213 44706 : length_AS_REQ(const AS_REQ *data)
7214 : {
7215 44706 : size_t ret = 0;
7216 44706 : ret += length_KDC_REQ(data);
7217 44706 : ret += 1 + der_length_len (ret);
7218 44706 : return ret;
7219 : }
7220 :
7221 : int ASN1CALL
7222 0 : copy_AS_REQ(const AS_REQ *from, AS_REQ *to)
7223 : {
7224 0 : memset(to, 0, sizeof(*to));
7225 0 : if(copy_KDC_REQ(from, to)) goto fail;
7226 0 : return 0;
7227 0 : fail:
7228 0 : free_AS_REQ(to);
7229 0 : return ENOMEM;
7230 : }
7231 :
7232 : int ASN1CALL
7233 40970 : encode_TGS_REQ(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const TGS_REQ *data, size_t *size)
7234 : {
7235 40970 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
7236 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
7237 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
7238 :
7239 40970 : e = encode_KDC_REQ(p, len, data, &l);
7240 40970 : if (e) return e;
7241 40970 : p -= l; len -= l; ret += l;
7242 :
7243 40970 : e = der_put_length_and_tag (p, len, ret, ASN1_C_APPL, CONS, 12, &l);
7244 40970 : if (e) return e;
7245 40970 : p -= l; len -= l; ret += l;
7246 :
7247 40970 : *size = ret;
7248 40970 : return 0;
7249 : }
7250 :
7251 : int ASN1CALL
7252 50938 : decode_TGS_REQ(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, TGS_REQ *data, size_t *size)
7253 : {
7254 50938 : size_t ret = 0;
7255 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
7256 : int e HEIMDAL_UNUSED_ATTRIBUTE;
7257 :
7258 50938 : memset(data, 0, sizeof(*data));
7259 : {
7260 : size_t Top_datalen, Top_oldlen;
7261 : Der_type Top_type;
7262 50938 : e = der_match_tag_and_length(p, len, ASN1_C_APPL, &Top_type, 12, &Top_datalen, &l);
7263 50938 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
7264 50938 : if(e) goto fail;
7265 50938 : p += l; len -= l; ret += l;
7266 50938 : Top_oldlen = len;
7267 50938 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7268 50938 : len = Top_datalen;
7269 50938 : e = decode_KDC_REQ(p, len, data, &l);
7270 50938 : if(e) goto fail;
7271 50938 : p += l; len -= l; ret += l;
7272 50938 : len = Top_oldlen - Top_datalen;
7273 : }
7274 101876 : if(size) *size = ret;
7275 49849 : return 0;
7276 0 : fail:
7277 0 : free_TGS_REQ(data);
7278 0 : return e;
7279 : }
7280 :
7281 : void ASN1CALL
7282 88416 : free_TGS_REQ(TGS_REQ *data)
7283 : {
7284 88416 : free_KDC_REQ(data);
7285 88416 : }
7286 :
7287 : size_t ASN1CALL
7288 40970 : length_TGS_REQ(const TGS_REQ *data)
7289 : {
7290 40970 : size_t ret = 0;
7291 40970 : ret += length_KDC_REQ(data);
7292 40970 : ret += 1 + der_length_len (ret);
7293 40970 : return ret;
7294 : }
7295 :
7296 : int ASN1CALL
7297 0 : copy_TGS_REQ(const TGS_REQ *from, TGS_REQ *to)
7298 : {
7299 0 : memset(to, 0, sizeof(*to));
7300 0 : if(copy_KDC_REQ(from, to)) goto fail;
7301 0 : return 0;
7302 0 : fail:
7303 0 : free_TGS_REQ(to);
7304 0 : return ENOMEM;
7305 : }
7306 :
7307 : int ASN1CALL
7308 13627 : encode_PA_ENC_TS_ENC(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const PA_ENC_TS_ENC *data, size_t *size)
7309 : {
7310 13627 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
7311 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
7312 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
7313 :
7314 : /* pausec */
7315 13627 : if((data)->pausec) {
7316 13627 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
7317 13627 : ret = 0;
7318 13627 : e = encode_krb5int32(p, len, (data)->pausec, &l);
7319 13627 : if (e) return e;
7320 13627 : p -= l; len -= l; ret += l;
7321 :
7322 13627 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
7323 13627 : if (e) return e;
7324 13627 : p -= l; len -= l; ret += l;
7325 :
7326 13627 : ret += Top_tag_oldret;
7327 : }
7328 : /* patimestamp */
7329 : {
7330 13627 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
7331 13627 : ret = 0;
7332 13627 : e = encode_KerberosTime(p, len, &(data)->patimestamp, &l);
7333 13627 : if (e) return e;
7334 13627 : p -= l; len -= l; ret += l;
7335 :
7336 13627 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
7337 13627 : if (e) return e;
7338 13627 : p -= l; len -= l; ret += l;
7339 :
7340 13627 : ret += Top_tag_oldret;
7341 : }
7342 13627 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
7343 13627 : if (e) return e;
7344 13627 : p -= l; len -= l; ret += l;
7345 :
7346 13627 : *size = ret;
7347 13627 : return 0;
7348 : }
7349 :
7350 : int ASN1CALL
7351 26330 : decode_PA_ENC_TS_ENC(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, PA_ENC_TS_ENC *data, size_t *size)
7352 : {
7353 26330 : size_t ret = 0;
7354 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
7355 : int e HEIMDAL_UNUSED_ATTRIBUTE;
7356 :
7357 26330 : memset(data, 0, sizeof(*data));
7358 : {
7359 : size_t Top_datalen, Top_oldlen;
7360 : Der_type Top_type;
7361 26330 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
7362 26330 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
7363 26330 : if(e) goto fail;
7364 26330 : p += l; len -= l; ret += l;
7365 26330 : Top_oldlen = len;
7366 26330 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7367 26330 : len = Top_datalen;
7368 : {
7369 : size_t patimestamp_datalen, patimestamp_oldlen;
7370 : Der_type patimestamp_type;
7371 26330 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &patimestamp_type, 0, &patimestamp_datalen, &l);
7372 26330 : if (e == 0 && patimestamp_type != CONS) { e = ASN1_BAD_ID; }
7373 26330 : if(e) goto fail;
7374 26330 : p += l; len -= l; ret += l;
7375 26330 : patimestamp_oldlen = len;
7376 26330 : if (patimestamp_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7377 26330 : len = patimestamp_datalen;
7378 26330 : e = decode_KerberosTime(p, len, &(data)->patimestamp, &l);
7379 26330 : if(e) goto fail;
7380 26330 : p += l; len -= l; ret += l;
7381 26330 : len = patimestamp_oldlen - patimestamp_datalen;
7382 : }
7383 : {
7384 : size_t pausec_datalen, pausec_oldlen;
7385 : Der_type pausec_type;
7386 26330 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &pausec_type, 1, &pausec_datalen, &l);
7387 52070 : if (e == 0 && pausec_type != CONS) { e = ASN1_BAD_ID; }
7388 26330 : if(e) {
7389 0 : (data)->pausec = NULL;
7390 : } else {
7391 26330 : (data)->pausec = calloc(1, sizeof(*(data)->pausec));
7392 26330 : if ((data)->pausec == NULL) { e = ENOMEM; goto fail; }
7393 26330 : p += l; len -= l; ret += l;
7394 26330 : pausec_oldlen = len;
7395 26330 : if (pausec_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7396 26330 : len = pausec_datalen;
7397 26330 : e = decode_krb5int32(p, len, (data)->pausec, &l);
7398 26330 : if(e) goto fail;
7399 26330 : p += l; len -= l; ret += l;
7400 26330 : len = pausec_oldlen - pausec_datalen;
7401 : }
7402 : }
7403 26330 : len = Top_oldlen - Top_datalen;
7404 : }
7405 52660 : if(size) *size = ret;
7406 25740 : return 0;
7407 0 : fail:
7408 0 : free_PA_ENC_TS_ENC(data);
7409 0 : return e;
7410 : }
7411 :
7412 : void ASN1CALL
7413 26330 : free_PA_ENC_TS_ENC(PA_ENC_TS_ENC *data)
7414 : {
7415 26330 : free_KerberosTime(&(data)->patimestamp);
7416 26330 : if((data)->pausec) {
7417 26330 : free_krb5int32((data)->pausec);
7418 26330 : free((data)->pausec);
7419 26330 : (data)->pausec = NULL;
7420 : }
7421 26330 : }
7422 :
7423 : size_t ASN1CALL
7424 13627 : length_PA_ENC_TS_ENC(const PA_ENC_TS_ENC *data)
7425 : {
7426 13627 : size_t ret = 0;
7427 : {
7428 13627 : size_t Top_tag_oldret = ret;
7429 13627 : ret = 0;
7430 13627 : ret += length_KerberosTime(&(data)->patimestamp);
7431 13627 : ret += 1 + der_length_len (ret);
7432 13627 : ret += Top_tag_oldret;
7433 : }
7434 13627 : if((data)->pausec){
7435 13627 : size_t Top_tag_oldret = ret;
7436 13627 : ret = 0;
7437 13627 : ret += length_krb5int32((data)->pausec);
7438 13627 : ret += 1 + der_length_len (ret);
7439 13627 : ret += Top_tag_oldret;
7440 : }
7441 13627 : ret += 1 + der_length_len (ret);
7442 13627 : return ret;
7443 : }
7444 :
7445 : int ASN1CALL
7446 0 : copy_PA_ENC_TS_ENC(const PA_ENC_TS_ENC *from, PA_ENC_TS_ENC *to)
7447 : {
7448 0 : memset(to, 0, sizeof(*to));
7449 0 : if(copy_KerberosTime(&(from)->patimestamp, &(to)->patimestamp)) goto fail;
7450 0 : if((from)->pausec) {
7451 0 : (to)->pausec = malloc(sizeof(*(to)->pausec));
7452 0 : if((to)->pausec == NULL) goto fail;
7453 0 : if(copy_krb5int32((from)->pausec, (to)->pausec)) goto fail;
7454 : }else
7455 0 : (to)->pausec = NULL;
7456 0 : return 0;
7457 0 : fail:
7458 0 : free_PA_ENC_TS_ENC(to);
7459 0 : return ENOMEM;
7460 : }
7461 :
7462 : int ASN1CALL
7463 1012 : encode_PA_PAC_REQUEST(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const PA_PAC_REQUEST *data, size_t *size)
7464 : {
7465 1012 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
7466 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
7467 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
7468 :
7469 : /* include-pac */
7470 : {
7471 1012 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
7472 1012 : ret = 0;
7473 1012 : e = der_put_boolean(p, len, &(data)->include_pac, &l);
7474 1012 : if (e) return e;
7475 1012 : p -= l; len -= l; ret += l;
7476 :
7477 1012 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Boolean, &l);
7478 1012 : if (e) return e;
7479 1012 : p -= l; len -= l; ret += l;
7480 :
7481 1012 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
7482 1012 : if (e) return e;
7483 1012 : p -= l; len -= l; ret += l;
7484 :
7485 1012 : ret += Top_tag_oldret;
7486 : }
7487 1012 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
7488 1012 : if (e) return e;
7489 1012 : p -= l; len -= l; ret += l;
7490 :
7491 1012 : *size = ret;
7492 1012 : return 0;
7493 : }
7494 :
7495 : int ASN1CALL
7496 324 : decode_PA_PAC_REQUEST(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, PA_PAC_REQUEST *data, size_t *size)
7497 : {
7498 324 : size_t ret = 0;
7499 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
7500 : int e HEIMDAL_UNUSED_ATTRIBUTE;
7501 :
7502 324 : memset(data, 0, sizeof(*data));
7503 : {
7504 : size_t Top_datalen, Top_oldlen;
7505 : Der_type Top_type;
7506 324 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
7507 324 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
7508 324 : if(e) goto fail;
7509 324 : p += l; len -= l; ret += l;
7510 324 : Top_oldlen = len;
7511 324 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7512 324 : len = Top_datalen;
7513 : {
7514 : size_t include_pac_datalen, include_pac_oldlen;
7515 : Der_type include_pac_type;
7516 324 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &include_pac_type, 0, &include_pac_datalen, &l);
7517 324 : if (e == 0 && include_pac_type != CONS) { e = ASN1_BAD_ID; }
7518 324 : if(e) goto fail;
7519 324 : p += l; len -= l; ret += l;
7520 324 : include_pac_oldlen = len;
7521 324 : if (include_pac_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7522 324 : len = include_pac_datalen;
7523 : {
7524 : size_t include_pac_Tag_datalen, include_pac_Tag_oldlen;
7525 : Der_type include_pac_Tag_type;
7526 324 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &include_pac_Tag_type, UT_Boolean, &include_pac_Tag_datalen, &l);
7527 324 : if (e == 0 && include_pac_Tag_type != PRIM) { e = ASN1_BAD_ID; }
7528 324 : if(e) goto fail;
7529 324 : p += l; len -= l; ret += l;
7530 324 : include_pac_Tag_oldlen = len;
7531 324 : if (include_pac_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7532 324 : len = include_pac_Tag_datalen;
7533 324 : e = der_get_boolean(p, len, &(data)->include_pac, &l);
7534 324 : if(e) goto fail;
7535 324 : p += l; len -= l; ret += l;
7536 324 : len = include_pac_Tag_oldlen - include_pac_Tag_datalen;
7537 : }
7538 324 : len = include_pac_oldlen - include_pac_datalen;
7539 : }
7540 324 : len = Top_oldlen - Top_datalen;
7541 : }
7542 324 : if(size) *size = ret;
7543 324 : return 0;
7544 0 : fail:
7545 0 : free_PA_PAC_REQUEST(data);
7546 0 : return e;
7547 : }
7548 :
7549 : void ASN1CALL
7550 324 : free_PA_PAC_REQUEST(PA_PAC_REQUEST *data)
7551 : {
7552 324 : }
7553 :
7554 : size_t ASN1CALL
7555 1012 : length_PA_PAC_REQUEST(const PA_PAC_REQUEST *data)
7556 : {
7557 1012 : size_t ret = 0;
7558 : {
7559 1012 : size_t Top_tag_oldret = ret;
7560 1012 : ret = 0;
7561 1012 : ret += 1;
7562 1012 : ret += 1 + der_length_len (ret);
7563 1012 : ret += 1 + der_length_len (ret);
7564 1012 : ret += Top_tag_oldret;
7565 : }
7566 1012 : ret += 1 + der_length_len (ret);
7567 1012 : return ret;
7568 : }
7569 :
7570 : int ASN1CALL
7571 0 : copy_PA_PAC_REQUEST(const PA_PAC_REQUEST *from, PA_PAC_REQUEST *to)
7572 : {
7573 0 : memset(to, 0, sizeof(*to));
7574 0 : *(&(to)->include_pac) = *(&(from)->include_pac);
7575 0 : return 0;
7576 : }
7577 :
7578 : int ASN1CALL
7579 0 : encode_PROV_SRV_LOCATION(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const PROV_SRV_LOCATION *data, size_t *size)
7580 : {
7581 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
7582 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
7583 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
7584 :
7585 0 : e = der_put_general_string(p, len, data, &l);
7586 0 : if (e) return e;
7587 0 : p -= l; len -= l; ret += l;
7588 :
7589 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_GeneralString, &l);
7590 0 : if (e) return e;
7591 0 : p -= l; len -= l; ret += l;
7592 :
7593 0 : *size = ret;
7594 0 : return 0;
7595 : }
7596 :
7597 : int ASN1CALL
7598 0 : decode_PROV_SRV_LOCATION(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, PROV_SRV_LOCATION *data, size_t *size)
7599 : {
7600 0 : size_t ret = 0;
7601 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
7602 : int e HEIMDAL_UNUSED_ATTRIBUTE;
7603 :
7604 0 : memset(data, 0, sizeof(*data));
7605 : {
7606 : size_t Top_datalen, Top_oldlen;
7607 : Der_type Top_type;
7608 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_GeneralString, &Top_datalen, &l);
7609 0 : if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
7610 0 : if(e) goto fail;
7611 0 : p += l; len -= l; ret += l;
7612 0 : Top_oldlen = len;
7613 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7614 0 : len = Top_datalen;
7615 0 : e = der_get_general_string(p, len, data, &l);
7616 0 : if(e) goto fail;
7617 0 : p += l; len -= l; ret += l;
7618 0 : len = Top_oldlen - Top_datalen;
7619 : }
7620 0 : if(size) *size = ret;
7621 0 : return 0;
7622 0 : fail:
7623 0 : free_PROV_SRV_LOCATION(data);
7624 0 : return e;
7625 : }
7626 :
7627 : void ASN1CALL
7628 0 : free_PROV_SRV_LOCATION(PROV_SRV_LOCATION *data)
7629 : {
7630 0 : der_free_general_string(data);
7631 0 : }
7632 :
7633 : size_t ASN1CALL
7634 0 : length_PROV_SRV_LOCATION(const PROV_SRV_LOCATION *data)
7635 : {
7636 0 : size_t ret = 0;
7637 0 : ret += der_length_general_string(data);
7638 0 : ret += 1 + der_length_len (ret);
7639 0 : return ret;
7640 : }
7641 :
7642 : int ASN1CALL
7643 0 : copy_PROV_SRV_LOCATION(const PROV_SRV_LOCATION *from, PROV_SRV_LOCATION *to)
7644 : {
7645 0 : memset(to, 0, sizeof(*to));
7646 0 : if(der_copy_general_string(from, to)) goto fail;
7647 0 : return 0;
7648 0 : fail:
7649 0 : free_PROV_SRV_LOCATION(to);
7650 0 : return ENOMEM;
7651 : }
7652 :
7653 : int ASN1CALL
7654 66032 : encode_KDC_REP(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const KDC_REP *data, size_t *size)
7655 : {
7656 66032 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
7657 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
7658 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
7659 :
7660 : /* enc-part */
7661 : {
7662 66032 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
7663 66032 : ret = 0;
7664 66032 : e = encode_EncryptedData(p, len, &(data)->enc_part, &l);
7665 66032 : if (e) return e;
7666 66032 : p -= l; len -= l; ret += l;
7667 :
7668 66032 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 6, &l);
7669 66032 : if (e) return e;
7670 66032 : p -= l; len -= l; ret += l;
7671 :
7672 66032 : ret += Top_tag_oldret;
7673 : }
7674 : /* ticket */
7675 : {
7676 66032 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
7677 66032 : ret = 0;
7678 66032 : e = encode_Ticket(p, len, &(data)->ticket, &l);
7679 66032 : if (e) return e;
7680 66032 : p -= l; len -= l; ret += l;
7681 :
7682 66032 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 5, &l);
7683 66032 : if (e) return e;
7684 66032 : p -= l; len -= l; ret += l;
7685 :
7686 66032 : ret += Top_tag_oldret;
7687 : }
7688 : /* cname */
7689 : {
7690 66032 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
7691 66032 : ret = 0;
7692 66032 : e = encode_PrincipalName(p, len, &(data)->cname, &l);
7693 66032 : if (e) return e;
7694 66032 : p -= l; len -= l; ret += l;
7695 :
7696 66032 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 4, &l);
7697 66032 : if (e) return e;
7698 66032 : p -= l; len -= l; ret += l;
7699 :
7700 66032 : ret += Top_tag_oldret;
7701 : }
7702 : /* crealm */
7703 : {
7704 66032 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
7705 66032 : ret = 0;
7706 66032 : e = encode_Realm(p, len, &(data)->crealm, &l);
7707 66032 : if (e) return e;
7708 66032 : p -= l; len -= l; ret += l;
7709 :
7710 66032 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
7711 66032 : if (e) return e;
7712 66032 : p -= l; len -= l; ret += l;
7713 :
7714 66032 : ret += Top_tag_oldret;
7715 : }
7716 : /* padata */
7717 66032 : if((data)->padata) {
7718 18823 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
7719 18823 : ret = 0;
7720 18823 : e = encode_METHOD_DATA(p, len, (data)->padata, &l);
7721 18823 : if (e) return e;
7722 18823 : p -= l; len -= l; ret += l;
7723 :
7724 18823 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
7725 18823 : if (e) return e;
7726 18823 : p -= l; len -= l; ret += l;
7727 :
7728 18823 : ret += Top_tag_oldret;
7729 : }
7730 : /* msg-type */
7731 : {
7732 66032 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
7733 66032 : ret = 0;
7734 66032 : e = encode_MESSAGE_TYPE(p, len, &(data)->msg_type, &l);
7735 66032 : if (e) return e;
7736 66032 : p -= l; len -= l; ret += l;
7737 :
7738 66032 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
7739 66032 : if (e) return e;
7740 66032 : p -= l; len -= l; ret += l;
7741 :
7742 66032 : ret += Top_tag_oldret;
7743 : }
7744 : /* pvno */
7745 : {
7746 66032 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
7747 66032 : ret = 0;
7748 66032 : e = encode_krb5int32(p, len, &(data)->pvno, &l);
7749 66032 : if (e) return e;
7750 66032 : p -= l; len -= l; ret += l;
7751 :
7752 66032 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
7753 66032 : if (e) return e;
7754 66032 : p -= l; len -= l; ret += l;
7755 :
7756 66032 : ret += Top_tag_oldret;
7757 : }
7758 66032 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
7759 66032 : if (e) return e;
7760 66032 : p -= l; len -= l; ret += l;
7761 :
7762 66032 : *size = ret;
7763 66032 : return 0;
7764 : }
7765 :
7766 : int ASN1CALL
7767 64458 : decode_KDC_REP(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, KDC_REP *data, size_t *size)
7768 : {
7769 64458 : size_t ret = 0;
7770 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
7771 : int e HEIMDAL_UNUSED_ATTRIBUTE;
7772 :
7773 64458 : memset(data, 0, sizeof(*data));
7774 : {
7775 : size_t Top_datalen, Top_oldlen;
7776 : Der_type Top_type;
7777 64458 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
7778 64458 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
7779 64458 : if(e) goto fail;
7780 64458 : p += l; len -= l; ret += l;
7781 64458 : Top_oldlen = len;
7782 64458 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7783 64458 : len = Top_datalen;
7784 : {
7785 : size_t pvno_datalen, pvno_oldlen;
7786 : Der_type pvno_type;
7787 64458 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &pvno_type, 0, &pvno_datalen, &l);
7788 64458 : if (e == 0 && pvno_type != CONS) { e = ASN1_BAD_ID; }
7789 64458 : if(e) goto fail;
7790 64458 : p += l; len -= l; ret += l;
7791 64458 : pvno_oldlen = len;
7792 64458 : if (pvno_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7793 64458 : len = pvno_datalen;
7794 64458 : e = decode_krb5int32(p, len, &(data)->pvno, &l);
7795 64458 : if(e) goto fail;
7796 64458 : p += l; len -= l; ret += l;
7797 64458 : len = pvno_oldlen - pvno_datalen;
7798 : }
7799 : {
7800 : size_t msg_type_datalen, msg_type_oldlen;
7801 : Der_type msg_type_type;
7802 64458 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &msg_type_type, 1, &msg_type_datalen, &l);
7803 127532 : if (e == 0 && msg_type_type != CONS) { e = ASN1_BAD_ID; }
7804 64458 : if(e) goto fail;
7805 64458 : p += l; len -= l; ret += l;
7806 64458 : msg_type_oldlen = len;
7807 64458 : if (msg_type_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7808 64458 : len = msg_type_datalen;
7809 64458 : e = decode_MESSAGE_TYPE(p, len, &(data)->msg_type, &l);
7810 64458 : if(e) goto fail;
7811 64458 : p += l; len -= l; ret += l;
7812 64458 : len = msg_type_oldlen - msg_type_datalen;
7813 : }
7814 : {
7815 : size_t padata_datalen, padata_oldlen;
7816 : Der_type padata_type;
7817 64458 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &padata_type, 2, &padata_datalen, &l);
7818 74180 : if (e == 0 && padata_type != CONS) { e = ASN1_BAD_ID; }
7819 64458 : if(e) {
7820 54523 : (data)->padata = NULL;
7821 : } else {
7822 9935 : (data)->padata = calloc(1, sizeof(*(data)->padata));
7823 9935 : if ((data)->padata == NULL) { e = ENOMEM; goto fail; }
7824 9935 : p += l; len -= l; ret += l;
7825 9935 : padata_oldlen = len;
7826 9935 : if (padata_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7827 9935 : len = padata_datalen;
7828 9935 : e = decode_METHOD_DATA(p, len, (data)->padata, &l);
7829 9935 : if(e) goto fail;
7830 9935 : p += l; len -= l; ret += l;
7831 9935 : len = padata_oldlen - padata_datalen;
7832 : }
7833 : }
7834 : {
7835 : size_t crealm_datalen, crealm_oldlen;
7836 : Der_type crealm_type;
7837 64458 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &crealm_type, 3, &crealm_datalen, &l);
7838 128916 : if (e == 0 && crealm_type != CONS) { e = ASN1_BAD_ID; }
7839 64458 : if(e) goto fail;
7840 64458 : p += l; len -= l; ret += l;
7841 64458 : crealm_oldlen = len;
7842 64458 : if (crealm_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7843 64458 : len = crealm_datalen;
7844 64458 : e = decode_Realm(p, len, &(data)->crealm, &l);
7845 64458 : if(e) goto fail;
7846 64458 : p += l; len -= l; ret += l;
7847 64458 : len = crealm_oldlen - crealm_datalen;
7848 : }
7849 : {
7850 : size_t cname_datalen, cname_oldlen;
7851 : Der_type cname_type;
7852 64458 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &cname_type, 4, &cname_datalen, &l);
7853 127532 : if (e == 0 && cname_type != CONS) { e = ASN1_BAD_ID; }
7854 64458 : if(e) goto fail;
7855 64458 : p += l; len -= l; ret += l;
7856 64458 : cname_oldlen = len;
7857 64458 : if (cname_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7858 64458 : len = cname_datalen;
7859 64458 : e = decode_PrincipalName(p, len, &(data)->cname, &l);
7860 64458 : if(e) goto fail;
7861 64458 : p += l; len -= l; ret += l;
7862 64458 : len = cname_oldlen - cname_datalen;
7863 : }
7864 : {
7865 : size_t ticket_datalen, ticket_oldlen;
7866 : Der_type ticket_type;
7867 64458 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &ticket_type, 5, &ticket_datalen, &l);
7868 127532 : if (e == 0 && ticket_type != CONS) { e = ASN1_BAD_ID; }
7869 64458 : if(e) goto fail;
7870 64458 : p += l; len -= l; ret += l;
7871 64458 : ticket_oldlen = len;
7872 64458 : if (ticket_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7873 64458 : len = ticket_datalen;
7874 64458 : e = decode_Ticket(p, len, &(data)->ticket, &l);
7875 64458 : if(e) goto fail;
7876 64458 : p += l; len -= l; ret += l;
7877 64458 : len = ticket_oldlen - ticket_datalen;
7878 : }
7879 : {
7880 : size_t enc_part_datalen, enc_part_oldlen;
7881 : Der_type enc_part_type;
7882 64458 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &enc_part_type, 6, &enc_part_datalen, &l);
7883 127532 : if (e == 0 && enc_part_type != CONS) { e = ASN1_BAD_ID; }
7884 64458 : if(e) goto fail;
7885 64458 : p += l; len -= l; ret += l;
7886 64458 : enc_part_oldlen = len;
7887 64458 : if (enc_part_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7888 64458 : len = enc_part_datalen;
7889 64458 : e = decode_EncryptedData(p, len, &(data)->enc_part, &l);
7890 64458 : if(e) goto fail;
7891 64458 : p += l; len -= l; ret += l;
7892 64458 : len = enc_part_oldlen - enc_part_datalen;
7893 : }
7894 64458 : len = Top_oldlen - Top_datalen;
7895 : }
7896 128916 : if(size) *size = ret;
7897 63074 : return 0;
7898 0 : fail:
7899 0 : free_KDC_REP(data);
7900 0 : return e;
7901 : }
7902 :
7903 : void ASN1CALL
7904 185967 : free_KDC_REP(KDC_REP *data)
7905 : {
7906 185967 : free_krb5int32(&(data)->pvno);
7907 185967 : free_MESSAGE_TYPE(&(data)->msg_type);
7908 185967 : if((data)->padata) {
7909 46603 : free_METHOD_DATA((data)->padata);
7910 46603 : free((data)->padata);
7911 46603 : (data)->padata = NULL;
7912 : }
7913 185967 : free_Realm(&(data)->crealm);
7914 185967 : free_PrincipalName(&(data)->cname);
7915 185967 : free_Ticket(&(data)->ticket);
7916 185967 : free_EncryptedData(&(data)->enc_part);
7917 185967 : }
7918 :
7919 : size_t ASN1CALL
7920 66032 : length_KDC_REP(const KDC_REP *data)
7921 : {
7922 66032 : size_t ret = 0;
7923 : {
7924 66032 : size_t Top_tag_oldret = ret;
7925 66032 : ret = 0;
7926 66032 : ret += length_krb5int32(&(data)->pvno);
7927 66032 : ret += 1 + der_length_len (ret);
7928 66032 : ret += Top_tag_oldret;
7929 : }
7930 : {
7931 66032 : size_t Top_tag_oldret = ret;
7932 66032 : ret = 0;
7933 66032 : ret += length_MESSAGE_TYPE(&(data)->msg_type);
7934 66032 : ret += 1 + der_length_len (ret);
7935 66032 : ret += Top_tag_oldret;
7936 : }
7937 66032 : if((data)->padata){
7938 18823 : size_t Top_tag_oldret = ret;
7939 18823 : ret = 0;
7940 18823 : ret += length_METHOD_DATA((data)->padata);
7941 18823 : ret += 1 + der_length_len (ret);
7942 18823 : ret += Top_tag_oldret;
7943 : }
7944 : {
7945 66032 : size_t Top_tag_oldret = ret;
7946 66032 : ret = 0;
7947 66032 : ret += length_Realm(&(data)->crealm);
7948 66032 : ret += 1 + der_length_len (ret);
7949 66032 : ret += Top_tag_oldret;
7950 : }
7951 : {
7952 66032 : size_t Top_tag_oldret = ret;
7953 66032 : ret = 0;
7954 66032 : ret += length_PrincipalName(&(data)->cname);
7955 66032 : ret += 1 + der_length_len (ret);
7956 66032 : ret += Top_tag_oldret;
7957 : }
7958 : {
7959 66032 : size_t Top_tag_oldret = ret;
7960 66032 : ret = 0;
7961 66032 : ret += length_Ticket(&(data)->ticket);
7962 66032 : ret += 1 + der_length_len (ret);
7963 66032 : ret += Top_tag_oldret;
7964 : }
7965 : {
7966 66032 : size_t Top_tag_oldret = ret;
7967 66032 : ret = 0;
7968 66032 : ret += length_EncryptedData(&(data)->enc_part);
7969 66032 : ret += 1 + der_length_len (ret);
7970 66032 : ret += Top_tag_oldret;
7971 : }
7972 66032 : ret += 1 + der_length_len (ret);
7973 66032 : return ret;
7974 : }
7975 :
7976 : int ASN1CALL
7977 0 : copy_KDC_REP(const KDC_REP *from, KDC_REP *to)
7978 : {
7979 0 : memset(to, 0, sizeof(*to));
7980 0 : if(copy_krb5int32(&(from)->pvno, &(to)->pvno)) goto fail;
7981 0 : if(copy_MESSAGE_TYPE(&(from)->msg_type, &(to)->msg_type)) goto fail;
7982 0 : if((from)->padata) {
7983 0 : (to)->padata = malloc(sizeof(*(to)->padata));
7984 0 : if((to)->padata == NULL) goto fail;
7985 0 : if(copy_METHOD_DATA((from)->padata, (to)->padata)) goto fail;
7986 : }else
7987 0 : (to)->padata = NULL;
7988 0 : if(copy_Realm(&(from)->crealm, &(to)->crealm)) goto fail;
7989 0 : if(copy_PrincipalName(&(from)->cname, &(to)->cname)) goto fail;
7990 0 : if(copy_Ticket(&(from)->ticket, &(to)->ticket)) goto fail;
7991 0 : if(copy_EncryptedData(&(from)->enc_part, &(to)->enc_part)) goto fail;
7992 0 : return 0;
7993 0 : fail:
7994 0 : free_KDC_REP(to);
7995 0 : return ENOMEM;
7996 : }
7997 :
7998 : int ASN1CALL
7999 26359 : encode_AS_REP(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const AS_REP *data, size_t *size)
8000 : {
8001 26359 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
8002 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
8003 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
8004 :
8005 26359 : e = encode_KDC_REP(p, len, data, &l);
8006 26359 : if (e) return e;
8007 26359 : p -= l; len -= l; ret += l;
8008 :
8009 26359 : e = der_put_length_and_tag (p, len, ret, ASN1_C_APPL, CONS, 11, &l);
8010 26359 : if (e) return e;
8011 26359 : p -= l; len -= l; ret += l;
8012 :
8013 26359 : *size = ret;
8014 26359 : return 0;
8015 : }
8016 :
8017 : int ASN1CALL
8018 31585 : decode_AS_REP(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, AS_REP *data, size_t *size)
8019 : {
8020 31585 : size_t ret = 0;
8021 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
8022 : int e HEIMDAL_UNUSED_ATTRIBUTE;
8023 :
8024 31585 : memset(data, 0, sizeof(*data));
8025 : {
8026 : size_t Top_datalen, Top_oldlen;
8027 : Der_type Top_type;
8028 31585 : e = der_match_tag_and_length(p, len, ASN1_C_APPL, &Top_type, 11, &Top_datalen, &l);
8029 31585 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
8030 46369 : if(e) goto fail;
8031 16506 : p += l; len -= l; ret += l;
8032 16506 : Top_oldlen = len;
8033 16506 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
8034 16506 : len = Top_datalen;
8035 16506 : e = decode_KDC_REP(p, len, data, &l);
8036 16506 : if(e) goto fail;
8037 16506 : p += l; len -= l; ret += l;
8038 16506 : len = Top_oldlen - Top_datalen;
8039 : }
8040 33012 : if(size) *size = ret;
8041 16211 : return 0;
8042 15079 : fail:
8043 15079 : free_AS_REP(data);
8044 15079 : return e;
8045 : }
8046 :
8047 : void ASN1CALL
8048 97238 : free_AS_REP(AS_REP *data)
8049 : {
8050 97238 : free_KDC_REP(data);
8051 97238 : }
8052 :
8053 : size_t ASN1CALL
8054 26359 : length_AS_REP(const AS_REP *data)
8055 : {
8056 26359 : size_t ret = 0;
8057 26359 : ret += length_KDC_REP(data);
8058 26359 : ret += 1 + der_length_len (ret);
8059 26359 : return ret;
8060 : }
8061 :
8062 : int ASN1CALL
8063 0 : copy_AS_REP(const AS_REP *from, AS_REP *to)
8064 : {
8065 0 : memset(to, 0, sizeof(*to));
8066 0 : if(copy_KDC_REP(from, to)) goto fail;
8067 0 : return 0;
8068 0 : fail:
8069 0 : free_AS_REP(to);
8070 0 : return ENOMEM;
8071 : }
8072 :
8073 : int ASN1CALL
8074 39673 : encode_TGS_REP(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const TGS_REP *data, size_t *size)
8075 : {
8076 39673 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
8077 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
8078 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
8079 :
8080 39673 : e = encode_KDC_REP(p, len, data, &l);
8081 39673 : if (e) return e;
8082 39673 : p -= l; len -= l; ret += l;
8083 :
8084 39673 : e = der_put_length_and_tag (p, len, ret, ASN1_C_APPL, CONS, 13, &l);
8085 39673 : if (e) return e;
8086 39673 : p -= l; len -= l; ret += l;
8087 :
8088 39673 : *size = ret;
8089 39673 : return 0;
8090 : }
8091 :
8092 : int ASN1CALL
8093 48858 : decode_TGS_REP(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, TGS_REP *data, size_t *size)
8094 : {
8095 48858 : size_t ret = 0;
8096 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
8097 : int e HEIMDAL_UNUSED_ATTRIBUTE;
8098 :
8099 48858 : memset(data, 0, sizeof(*data));
8100 : {
8101 : size_t Top_datalen, Top_oldlen;
8102 : Der_type Top_type;
8103 48858 : e = der_match_tag_and_length(p, len, ASN1_C_APPL, &Top_type, 13, &Top_datalen, &l);
8104 48858 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
8105 49764 : if(e) goto fail;
8106 47952 : p += l; len -= l; ret += l;
8107 47952 : Top_oldlen = len;
8108 47952 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
8109 47952 : len = Top_datalen;
8110 47952 : e = decode_KDC_REP(p, len, data, &l);
8111 47952 : if(e) goto fail;
8112 47952 : p += l; len -= l; ret += l;
8113 47952 : len = Top_oldlen - Top_datalen;
8114 : }
8115 95904 : if(size) *size = ret;
8116 46863 : return 0;
8117 906 : fail:
8118 906 : free_TGS_REP(data);
8119 906 : return e;
8120 : }
8121 :
8122 : void ASN1CALL
8123 49241 : free_TGS_REP(TGS_REP *data)
8124 : {
8125 49241 : free_KDC_REP(data);
8126 49241 : }
8127 :
8128 : size_t ASN1CALL
8129 39673 : length_TGS_REP(const TGS_REP *data)
8130 : {
8131 39673 : size_t ret = 0;
8132 39673 : ret += length_KDC_REP(data);
8133 39673 : ret += 1 + der_length_len (ret);
8134 39673 : return ret;
8135 : }
8136 :
8137 : int ASN1CALL
8138 0 : copy_TGS_REP(const TGS_REP *from, TGS_REP *to)
8139 : {
8140 0 : memset(to, 0, sizeof(*to));
8141 0 : if(copy_KDC_REP(from, to)) goto fail;
8142 0 : return 0;
8143 0 : fail:
8144 0 : free_TGS_REP(to);
8145 0 : return ENOMEM;
8146 : }
8147 :
8148 : int ASN1CALL
8149 66016 : encode_EncKDCRepPart(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const EncKDCRepPart *data, size_t *size)
8150 : {
8151 66016 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
8152 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
8153 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
8154 :
8155 : /* encrypted-pa-data */
8156 66016 : if((data)->encrypted_pa_data) {
8157 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
8158 0 : ret = 0;
8159 0 : e = encode_METHOD_DATA(p, len, (data)->encrypted_pa_data, &l);
8160 0 : if (e) return e;
8161 0 : p -= l; len -= l; ret += l;
8162 :
8163 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 12, &l);
8164 0 : if (e) return e;
8165 0 : p -= l; len -= l; ret += l;
8166 :
8167 0 : ret += Top_tag_oldret;
8168 : }
8169 : /* caddr */
8170 66016 : if((data)->caddr) {
8171 98 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
8172 98 : ret = 0;
8173 98 : e = encode_HostAddresses(p, len, (data)->caddr, &l);
8174 98 : if (e) return e;
8175 98 : p -= l; len -= l; ret += l;
8176 :
8177 98 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 11, &l);
8178 98 : if (e) return e;
8179 98 : p -= l; len -= l; ret += l;
8180 :
8181 98 : ret += Top_tag_oldret;
8182 : }
8183 : /* sname */
8184 : {
8185 66016 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
8186 66016 : ret = 0;
8187 66016 : e = encode_PrincipalName(p, len, &(data)->sname, &l);
8188 66016 : if (e) return e;
8189 66016 : p -= l; len -= l; ret += l;
8190 :
8191 66016 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 10, &l);
8192 66016 : if (e) return e;
8193 66016 : p -= l; len -= l; ret += l;
8194 :
8195 66016 : ret += Top_tag_oldret;
8196 : }
8197 : /* srealm */
8198 : {
8199 66016 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
8200 66016 : ret = 0;
8201 66016 : e = encode_Realm(p, len, &(data)->srealm, &l);
8202 66016 : if (e) return e;
8203 66016 : p -= l; len -= l; ret += l;
8204 :
8205 66016 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 9, &l);
8206 66016 : if (e) return e;
8207 66016 : p -= l; len -= l; ret += l;
8208 :
8209 66016 : ret += Top_tag_oldret;
8210 : }
8211 : /* renew-till */
8212 66016 : if((data)->renew_till) {
8213 170 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
8214 170 : ret = 0;
8215 170 : e = encode_KerberosTime(p, len, (data)->renew_till, &l);
8216 170 : if (e) return e;
8217 170 : p -= l; len -= l; ret += l;
8218 :
8219 170 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 8, &l);
8220 170 : if (e) return e;
8221 170 : p -= l; len -= l; ret += l;
8222 :
8223 170 : ret += Top_tag_oldret;
8224 : }
8225 : /* endtime */
8226 : {
8227 66016 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
8228 66016 : ret = 0;
8229 66016 : e = encode_KerberosTime(p, len, &(data)->endtime, &l);
8230 66016 : if (e) return e;
8231 66016 : p -= l; len -= l; ret += l;
8232 :
8233 66016 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 7, &l);
8234 66016 : if (e) return e;
8235 66016 : p -= l; len -= l; ret += l;
8236 :
8237 66016 : ret += Top_tag_oldret;
8238 : }
8239 : /* starttime */
8240 66016 : if((data)->starttime) {
8241 39673 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
8242 39673 : ret = 0;
8243 39673 : e = encode_KerberosTime(p, len, (data)->starttime, &l);
8244 39673 : if (e) return e;
8245 39673 : p -= l; len -= l; ret += l;
8246 :
8247 39673 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 6, &l);
8248 39673 : if (e) return e;
8249 39673 : p -= l; len -= l; ret += l;
8250 :
8251 39673 : ret += Top_tag_oldret;
8252 : }
8253 : /* authtime */
8254 : {
8255 66016 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
8256 66016 : ret = 0;
8257 66016 : e = encode_KerberosTime(p, len, &(data)->authtime, &l);
8258 66016 : if (e) return e;
8259 66016 : p -= l; len -= l; ret += l;
8260 :
8261 66016 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 5, &l);
8262 66016 : if (e) return e;
8263 66016 : p -= l; len -= l; ret += l;
8264 :
8265 66016 : ret += Top_tag_oldret;
8266 : }
8267 : /* flags */
8268 : {
8269 66016 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
8270 66016 : ret = 0;
8271 66016 : e = encode_TicketFlags(p, len, &(data)->flags, &l);
8272 66016 : if (e) return e;
8273 66016 : p -= l; len -= l; ret += l;
8274 :
8275 66016 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 4, &l);
8276 66016 : if (e) return e;
8277 66016 : p -= l; len -= l; ret += l;
8278 :
8279 66016 : ret += Top_tag_oldret;
8280 : }
8281 : /* key-expiration */
8282 66016 : if((data)->key_expiration) {
8283 20867 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
8284 20867 : ret = 0;
8285 20867 : e = encode_KerberosTime(p, len, (data)->key_expiration, &l);
8286 20867 : if (e) return e;
8287 20867 : p -= l; len -= l; ret += l;
8288 :
8289 20867 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
8290 20867 : if (e) return e;
8291 20867 : p -= l; len -= l; ret += l;
8292 :
8293 20867 : ret += Top_tag_oldret;
8294 : }
8295 : /* nonce */
8296 : {
8297 66016 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
8298 66016 : ret = 0;
8299 66016 : e = encode_krb5int32(p, len, &(data)->nonce, &l);
8300 66016 : if (e) return e;
8301 66016 : p -= l; len -= l; ret += l;
8302 :
8303 66016 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
8304 66016 : if (e) return e;
8305 66016 : p -= l; len -= l; ret += l;
8306 :
8307 66016 : ret += Top_tag_oldret;
8308 : }
8309 : /* last-req */
8310 : {
8311 66016 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
8312 66016 : ret = 0;
8313 66016 : e = encode_LastReq(p, len, &(data)->last_req, &l);
8314 66016 : if (e) return e;
8315 66016 : p -= l; len -= l; ret += l;
8316 :
8317 66016 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
8318 66016 : if (e) return e;
8319 66016 : p -= l; len -= l; ret += l;
8320 :
8321 66016 : ret += Top_tag_oldret;
8322 : }
8323 : /* key */
8324 : {
8325 66016 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
8326 66016 : ret = 0;
8327 66016 : e = encode_EncryptionKey(p, len, &(data)->key, &l);
8328 66016 : if (e) return e;
8329 66016 : p -= l; len -= l; ret += l;
8330 :
8331 66016 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
8332 66016 : if (e) return e;
8333 66016 : p -= l; len -= l; ret += l;
8334 :
8335 66016 : ret += Top_tag_oldret;
8336 : }
8337 66016 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
8338 66016 : if (e) return e;
8339 66016 : p -= l; len -= l; ret += l;
8340 :
8341 66016 : *size = ret;
8342 66016 : return 0;
8343 : }
8344 :
8345 : int ASN1CALL
8346 52862 : decode_EncKDCRepPart(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, EncKDCRepPart *data, size_t *size)
8347 : {
8348 52862 : size_t ret = 0;
8349 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
8350 : int e HEIMDAL_UNUSED_ATTRIBUTE;
8351 :
8352 52862 : memset(data, 0, sizeof(*data));
8353 : {
8354 : size_t Top_datalen, Top_oldlen;
8355 : Der_type Top_type;
8356 52862 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
8357 52862 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
8358 52862 : if(e) goto fail;
8359 52862 : p += l; len -= l; ret += l;
8360 52862 : Top_oldlen = len;
8361 52862 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
8362 52862 : len = Top_datalen;
8363 : {
8364 : size_t key_datalen, key_oldlen;
8365 : Der_type key_type;
8366 52862 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &key_type, 0, &key_datalen, &l);
8367 52862 : if (e == 0 && key_type != CONS) { e = ASN1_BAD_ID; }
8368 52862 : if(e) goto fail;
8369 52862 : p += l; len -= l; ret += l;
8370 52862 : key_oldlen = len;
8371 52862 : if (key_datalen > len) { e = ASN1_OVERRUN; goto fail; }
8372 52862 : len = key_datalen;
8373 52862 : e = decode_EncryptionKey(p, len, &(data)->key, &l);
8374 52862 : if(e) goto fail;
8375 52862 : p += l; len -= l; ret += l;
8376 52862 : len = key_oldlen - key_datalen;
8377 : }
8378 : {
8379 : size_t last_req_datalen, last_req_oldlen;
8380 : Der_type last_req_type;
8381 52862 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &last_req_type, 1, &last_req_datalen, &l);
8382 104340 : if (e == 0 && last_req_type != CONS) { e = ASN1_BAD_ID; }
8383 52862 : if(e) goto fail;
8384 52862 : p += l; len -= l; ret += l;
8385 52862 : last_req_oldlen = len;
8386 52862 : if (last_req_datalen > len) { e = ASN1_OVERRUN; goto fail; }
8387 52862 : len = last_req_datalen;
8388 52862 : e = decode_LastReq(p, len, &(data)->last_req, &l);
8389 52862 : if(e) goto fail;
8390 52862 : p += l; len -= l; ret += l;
8391 52862 : len = last_req_oldlen - last_req_datalen;
8392 : }
8393 : {
8394 : size_t nonce_datalen, nonce_oldlen;
8395 : Der_type nonce_type;
8396 52862 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &nonce_type, 2, &nonce_datalen, &l);
8397 104340 : if (e == 0 && nonce_type != CONS) { e = ASN1_BAD_ID; }
8398 52862 : if(e) goto fail;
8399 52862 : p += l; len -= l; ret += l;
8400 52862 : nonce_oldlen = len;
8401 52862 : if (nonce_datalen > len) { e = ASN1_OVERRUN; goto fail; }
8402 52862 : len = nonce_datalen;
8403 52862 : e = decode_krb5int32(p, len, &(data)->nonce, &l);
8404 52862 : if(e) goto fail;
8405 52862 : p += l; len -= l; ret += l;
8406 52862 : len = nonce_oldlen - nonce_datalen;
8407 : }
8408 : {
8409 : size_t key_expiration_datalen, key_expiration_oldlen;
8410 : Der_type key_expiration_type;
8411 52862 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &key_expiration_type, 3, &key_expiration_datalen, &l);
8412 62986 : if (e == 0 && key_expiration_type != CONS) { e = ASN1_BAD_ID; }
8413 52862 : if(e) {
8414 42525 : (data)->key_expiration = NULL;
8415 : } else {
8416 10337 : (data)->key_expiration = calloc(1, sizeof(*(data)->key_expiration));
8417 10337 : if ((data)->key_expiration == NULL) { e = ENOMEM; goto fail; }
8418 10337 : p += l; len -= l; ret += l;
8419 10337 : key_expiration_oldlen = len;
8420 10337 : if (key_expiration_datalen > len) { e = ASN1_OVERRUN; goto fail; }
8421 10337 : len = key_expiration_datalen;
8422 10337 : e = decode_KerberosTime(p, len, (data)->key_expiration, &l);
8423 10337 : if(e) goto fail;
8424 10337 : p += l; len -= l; ret += l;
8425 10337 : len = key_expiration_oldlen - key_expiration_datalen;
8426 : }
8427 : }
8428 : {
8429 : size_t flags_datalen, flags_oldlen;
8430 : Der_type flags_type;
8431 52862 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &flags_type, 4, &flags_datalen, &l);
8432 105724 : if (e == 0 && flags_type != CONS) { e = ASN1_BAD_ID; }
8433 52862 : if(e) goto fail;
8434 52862 : p += l; len -= l; ret += l;
8435 52862 : flags_oldlen = len;
8436 52862 : if (flags_datalen > len) { e = ASN1_OVERRUN; goto fail; }
8437 52862 : len = flags_datalen;
8438 52862 : e = decode_TicketFlags(p, len, &(data)->flags, &l);
8439 52862 : if(e) goto fail;
8440 52862 : p += l; len -= l; ret += l;
8441 52862 : len = flags_oldlen - flags_datalen;
8442 : }
8443 : {
8444 : size_t authtime_datalen, authtime_oldlen;
8445 : Der_type authtime_type;
8446 52862 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &authtime_type, 5, &authtime_datalen, &l);
8447 104340 : if (e == 0 && authtime_type != CONS) { e = ASN1_BAD_ID; }
8448 52862 : if(e) goto fail;
8449 52862 : p += l; len -= l; ret += l;
8450 52862 : authtime_oldlen = len;
8451 52862 : if (authtime_datalen > len) { e = ASN1_OVERRUN; goto fail; }
8452 52862 : len = authtime_datalen;
8453 52862 : e = decode_KerberosTime(p, len, &(data)->authtime, &l);
8454 52862 : if(e) goto fail;
8455 52862 : p += l; len -= l; ret += l;
8456 52862 : len = authtime_oldlen - authtime_datalen;
8457 : }
8458 : {
8459 : size_t starttime_datalen, starttime_oldlen;
8460 : Der_type starttime_type;
8461 52862 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &starttime_type, 6, &starttime_datalen, &l);
8462 91261 : if (e == 0 && starttime_type != CONS) { e = ASN1_BAD_ID; }
8463 52862 : if(e) {
8464 13374 : (data)->starttime = NULL;
8465 : } else {
8466 39488 : (data)->starttime = calloc(1, sizeof(*(data)->starttime));
8467 39488 : if ((data)->starttime == NULL) { e = ENOMEM; goto fail; }
8468 39488 : p += l; len -= l; ret += l;
8469 39488 : starttime_oldlen = len;
8470 39488 : if (starttime_datalen > len) { e = ASN1_OVERRUN; goto fail; }
8471 39488 : len = starttime_datalen;
8472 39488 : e = decode_KerberosTime(p, len, (data)->starttime, &l);
8473 39488 : if(e) goto fail;
8474 39488 : p += l; len -= l; ret += l;
8475 39488 : len = starttime_oldlen - starttime_datalen;
8476 : }
8477 : }
8478 : {
8479 : size_t endtime_datalen, endtime_oldlen;
8480 : Der_type endtime_type;
8481 52862 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &endtime_type, 7, &endtime_datalen, &l);
8482 105724 : if (e == 0 && endtime_type != CONS) { e = ASN1_BAD_ID; }
8483 52862 : if(e) goto fail;
8484 52862 : p += l; len -= l; ret += l;
8485 52862 : endtime_oldlen = len;
8486 52862 : if (endtime_datalen > len) { e = ASN1_OVERRUN; goto fail; }
8487 52862 : len = endtime_datalen;
8488 52862 : e = decode_KerberosTime(p, len, &(data)->endtime, &l);
8489 52862 : if(e) goto fail;
8490 52862 : p += l; len -= l; ret += l;
8491 52862 : len = endtime_oldlen - endtime_datalen;
8492 : }
8493 : {
8494 : size_t renew_till_datalen, renew_till_oldlen;
8495 : Der_type renew_till_type;
8496 52862 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &renew_till_type, 8, &renew_till_datalen, &l);
8497 52927 : if (e == 0 && renew_till_type != CONS) { e = ASN1_BAD_ID; }
8498 52862 : if(e) {
8499 52797 : (data)->renew_till = NULL;
8500 : } else {
8501 65 : (data)->renew_till = calloc(1, sizeof(*(data)->renew_till));
8502 65 : if ((data)->renew_till == NULL) { e = ENOMEM; goto fail; }
8503 65 : p += l; len -= l; ret += l;
8504 65 : renew_till_oldlen = len;
8505 65 : if (renew_till_datalen > len) { e = ASN1_OVERRUN; goto fail; }
8506 65 : len = renew_till_datalen;
8507 65 : e = decode_KerberosTime(p, len, (data)->renew_till, &l);
8508 65 : if(e) goto fail;
8509 65 : p += l; len -= l; ret += l;
8510 65 : len = renew_till_oldlen - renew_till_datalen;
8511 : }
8512 : }
8513 : {
8514 : size_t srealm_datalen, srealm_oldlen;
8515 : Der_type srealm_type;
8516 52862 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &srealm_type, 9, &srealm_datalen, &l);
8517 105724 : if (e == 0 && srealm_type != CONS) { e = ASN1_BAD_ID; }
8518 52862 : if(e) goto fail;
8519 52862 : p += l; len -= l; ret += l;
8520 52862 : srealm_oldlen = len;
8521 52862 : if (srealm_datalen > len) { e = ASN1_OVERRUN; goto fail; }
8522 52862 : len = srealm_datalen;
8523 52862 : e = decode_Realm(p, len, &(data)->srealm, &l);
8524 52862 : if(e) goto fail;
8525 52862 : p += l; len -= l; ret += l;
8526 52862 : len = srealm_oldlen - srealm_datalen;
8527 : }
8528 : {
8529 : size_t sname_datalen, sname_oldlen;
8530 : Der_type sname_type;
8531 52862 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &sname_type, 10, &sname_datalen, &l);
8532 104340 : if (e == 0 && sname_type != CONS) { e = ASN1_BAD_ID; }
8533 52862 : if(e) goto fail;
8534 52862 : p += l; len -= l; ret += l;
8535 52862 : sname_oldlen = len;
8536 52862 : if (sname_datalen > len) { e = ASN1_OVERRUN; goto fail; }
8537 52862 : len = sname_datalen;
8538 52862 : e = decode_PrincipalName(p, len, &(data)->sname, &l);
8539 52862 : if(e) goto fail;
8540 52862 : p += l; len -= l; ret += l;
8541 52862 : len = sname_oldlen - sname_datalen;
8542 : }
8543 : {
8544 : size_t caddr_datalen, caddr_oldlen;
8545 : Der_type caddr_type;
8546 52862 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &caddr_type, 11, &caddr_datalen, &l);
8547 52865 : if (e == 0 && caddr_type != CONS) { e = ASN1_BAD_ID; }
8548 52862 : if(e) {
8549 52859 : (data)->caddr = NULL;
8550 : } else {
8551 3 : (data)->caddr = calloc(1, sizeof(*(data)->caddr));
8552 3 : if ((data)->caddr == NULL) { e = ENOMEM; goto fail; }
8553 3 : p += l; len -= l; ret += l;
8554 3 : caddr_oldlen = len;
8555 3 : if (caddr_datalen > len) { e = ASN1_OVERRUN; goto fail; }
8556 3 : len = caddr_datalen;
8557 3 : e = decode_HostAddresses(p, len, (data)->caddr, &l);
8558 3 : if(e) goto fail;
8559 3 : p += l; len -= l; ret += l;
8560 3 : len = caddr_oldlen - caddr_datalen;
8561 : }
8562 : }
8563 : {
8564 : size_t encrypted_pa_data_datalen, encrypted_pa_data_oldlen;
8565 : Der_type encrypted_pa_data_type;
8566 52862 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &encrypted_pa_data_type, 12, &encrypted_pa_data_datalen, &l);
8567 52862 : if (e == 0 && encrypted_pa_data_type != CONS) { e = ASN1_BAD_ID; }
8568 52862 : if(e) {
8569 52862 : (data)->encrypted_pa_data = NULL;
8570 : } else {
8571 0 : (data)->encrypted_pa_data = calloc(1, sizeof(*(data)->encrypted_pa_data));
8572 0 : if ((data)->encrypted_pa_data == NULL) { e = ENOMEM; goto fail; }
8573 0 : p += l; len -= l; ret += l;
8574 0 : encrypted_pa_data_oldlen = len;
8575 0 : if (encrypted_pa_data_datalen > len) { e = ASN1_OVERRUN; goto fail; }
8576 0 : len = encrypted_pa_data_datalen;
8577 0 : e = decode_METHOD_DATA(p, len, (data)->encrypted_pa_data, &l);
8578 0 : if(e) goto fail;
8579 0 : p += l; len -= l; ret += l;
8580 0 : len = encrypted_pa_data_oldlen - encrypted_pa_data_datalen;
8581 : }
8582 : }
8583 52862 : len = Top_oldlen - Top_datalen;
8584 : }
8585 105724 : if(size) *size = ret;
8586 51478 : return 0;
8587 0 : fail:
8588 0 : free_EncKDCRepPart(data);
8589 0 : return e;
8590 : }
8591 :
8592 : void ASN1CALL
8593 140175 : free_EncKDCRepPart(EncKDCRepPart *data)
8594 : {
8595 140175 : free_EncryptionKey(&(data)->key);
8596 140175 : free_LastReq(&(data)->last_req);
8597 140175 : free_krb5int32(&(data)->nonce);
8598 140175 : if((data)->key_expiration) {
8599 41541 : free_KerberosTime((data)->key_expiration);
8600 41541 : free((data)->key_expiration);
8601 41541 : (data)->key_expiration = NULL;
8602 : }
8603 140175 : free_TicketFlags(&(data)->flags);
8604 140175 : free_KerberosTime(&(data)->authtime);
8605 140175 : if((data)->starttime) {
8606 39488 : free_KerberosTime((data)->starttime);
8607 39488 : free((data)->starttime);
8608 39488 : (data)->starttime = NULL;
8609 : }
8610 140175 : free_KerberosTime(&(data)->endtime);
8611 140175 : if((data)->renew_till) {
8612 240 : free_KerberosTime((data)->renew_till);
8613 240 : free((data)->renew_till);
8614 240 : (data)->renew_till = NULL;
8615 : }
8616 140175 : free_Realm(&(data)->srealm);
8617 140175 : free_PrincipalName(&(data)->sname);
8618 140175 : if((data)->caddr) {
8619 104 : free_HostAddresses((data)->caddr);
8620 104 : free((data)->caddr);
8621 104 : (data)->caddr = NULL;
8622 : }
8623 140175 : if((data)->encrypted_pa_data) {
8624 0 : free_METHOD_DATA((data)->encrypted_pa_data);
8625 0 : free((data)->encrypted_pa_data);
8626 0 : (data)->encrypted_pa_data = NULL;
8627 : }
8628 140175 : }
8629 :
8630 : size_t ASN1CALL
8631 66016 : length_EncKDCRepPart(const EncKDCRepPart *data)
8632 : {
8633 66016 : size_t ret = 0;
8634 : {
8635 66016 : size_t Top_tag_oldret = ret;
8636 66016 : ret = 0;
8637 66016 : ret += length_EncryptionKey(&(data)->key);
8638 66016 : ret += 1 + der_length_len (ret);
8639 66016 : ret += Top_tag_oldret;
8640 : }
8641 : {
8642 66016 : size_t Top_tag_oldret = ret;
8643 66016 : ret = 0;
8644 66016 : ret += length_LastReq(&(data)->last_req);
8645 66016 : ret += 1 + der_length_len (ret);
8646 66016 : ret += Top_tag_oldret;
8647 : }
8648 : {
8649 66016 : size_t Top_tag_oldret = ret;
8650 66016 : ret = 0;
8651 66016 : ret += length_krb5int32(&(data)->nonce);
8652 66016 : ret += 1 + der_length_len (ret);
8653 66016 : ret += Top_tag_oldret;
8654 : }
8655 66016 : if((data)->key_expiration){
8656 20867 : size_t Top_tag_oldret = ret;
8657 20867 : ret = 0;
8658 20867 : ret += length_KerberosTime((data)->key_expiration);
8659 20867 : ret += 1 + der_length_len (ret);
8660 20867 : ret += Top_tag_oldret;
8661 : }
8662 : {
8663 66016 : size_t Top_tag_oldret = ret;
8664 66016 : ret = 0;
8665 66016 : ret += length_TicketFlags(&(data)->flags);
8666 66016 : ret += 1 + der_length_len (ret);
8667 66016 : ret += Top_tag_oldret;
8668 : }
8669 : {
8670 66016 : size_t Top_tag_oldret = ret;
8671 66016 : ret = 0;
8672 66016 : ret += length_KerberosTime(&(data)->authtime);
8673 66016 : ret += 1 + der_length_len (ret);
8674 66016 : ret += Top_tag_oldret;
8675 : }
8676 66016 : if((data)->starttime){
8677 39673 : size_t Top_tag_oldret = ret;
8678 39673 : ret = 0;
8679 39673 : ret += length_KerberosTime((data)->starttime);
8680 39673 : ret += 1 + der_length_len (ret);
8681 39673 : ret += Top_tag_oldret;
8682 : }
8683 : {
8684 66016 : size_t Top_tag_oldret = ret;
8685 66016 : ret = 0;
8686 66016 : ret += length_KerberosTime(&(data)->endtime);
8687 66016 : ret += 1 + der_length_len (ret);
8688 66016 : ret += Top_tag_oldret;
8689 : }
8690 66016 : if((data)->renew_till){
8691 170 : size_t Top_tag_oldret = ret;
8692 170 : ret = 0;
8693 170 : ret += length_KerberosTime((data)->renew_till);
8694 170 : ret += 1 + der_length_len (ret);
8695 170 : ret += Top_tag_oldret;
8696 : }
8697 : {
8698 66016 : size_t Top_tag_oldret = ret;
8699 66016 : ret = 0;
8700 66016 : ret += length_Realm(&(data)->srealm);
8701 66016 : ret += 1 + der_length_len (ret);
8702 66016 : ret += Top_tag_oldret;
8703 : }
8704 : {
8705 66016 : size_t Top_tag_oldret = ret;
8706 66016 : ret = 0;
8707 66016 : ret += length_PrincipalName(&(data)->sname);
8708 66016 : ret += 1 + der_length_len (ret);
8709 66016 : ret += Top_tag_oldret;
8710 : }
8711 66016 : if((data)->caddr){
8712 98 : size_t Top_tag_oldret = ret;
8713 98 : ret = 0;
8714 98 : ret += length_HostAddresses((data)->caddr);
8715 98 : ret += 1 + der_length_len (ret);
8716 98 : ret += Top_tag_oldret;
8717 : }
8718 66016 : if((data)->encrypted_pa_data){
8719 0 : size_t Top_tag_oldret = ret;
8720 0 : ret = 0;
8721 0 : ret += length_METHOD_DATA((data)->encrypted_pa_data);
8722 0 : ret += 1 + der_length_len (ret);
8723 0 : ret += Top_tag_oldret;
8724 : }
8725 66016 : ret += 1 + der_length_len (ret);
8726 66016 : return ret;
8727 : }
8728 :
8729 : int ASN1CALL
8730 13374 : copy_EncKDCRepPart(const EncKDCRepPart *from, EncKDCRepPart *to)
8731 : {
8732 13374 : memset(to, 0, sizeof(*to));
8733 13374 : if(copy_EncryptionKey(&(from)->key, &(to)->key)) goto fail;
8734 13374 : if(copy_LastReq(&(from)->last_req, &(to)->last_req)) goto fail;
8735 13374 : if(copy_krb5int32(&(from)->nonce, &(to)->nonce)) goto fail;
8736 13374 : if((from)->key_expiration) {
8737 10337 : (to)->key_expiration = malloc(sizeof(*(to)->key_expiration));
8738 10337 : if((to)->key_expiration == NULL) goto fail;
8739 10337 : if(copy_KerberosTime((from)->key_expiration, (to)->key_expiration)) goto fail;
8740 : }else
8741 3037 : (to)->key_expiration = NULL;
8742 13374 : if(copy_TicketFlags(&(from)->flags, &(to)->flags)) goto fail;
8743 13374 : if(copy_KerberosTime(&(from)->authtime, &(to)->authtime)) goto fail;
8744 13374 : if((from)->starttime) {
8745 0 : (to)->starttime = malloc(sizeof(*(to)->starttime));
8746 0 : if((to)->starttime == NULL) goto fail;
8747 0 : if(copy_KerberosTime((from)->starttime, (to)->starttime)) goto fail;
8748 : }else
8749 13374 : (to)->starttime = NULL;
8750 13374 : if(copy_KerberosTime(&(from)->endtime, &(to)->endtime)) goto fail;
8751 13374 : if((from)->renew_till) {
8752 35 : (to)->renew_till = malloc(sizeof(*(to)->renew_till));
8753 35 : if((to)->renew_till == NULL) goto fail;
8754 35 : if(copy_KerberosTime((from)->renew_till, (to)->renew_till)) goto fail;
8755 : }else
8756 13339 : (to)->renew_till = NULL;
8757 13374 : if(copy_Realm(&(from)->srealm, &(to)->srealm)) goto fail;
8758 13374 : if(copy_PrincipalName(&(from)->sname, &(to)->sname)) goto fail;
8759 13374 : if((from)->caddr) {
8760 3 : (to)->caddr = malloc(sizeof(*(to)->caddr));
8761 3 : if((to)->caddr == NULL) goto fail;
8762 3 : if(copy_HostAddresses((from)->caddr, (to)->caddr)) goto fail;
8763 : }else
8764 13371 : (to)->caddr = NULL;
8765 13374 : if((from)->encrypted_pa_data) {
8766 0 : (to)->encrypted_pa_data = malloc(sizeof(*(to)->encrypted_pa_data));
8767 0 : if((to)->encrypted_pa_data == NULL) goto fail;
8768 0 : if(copy_METHOD_DATA((from)->encrypted_pa_data, (to)->encrypted_pa_data)) goto fail;
8769 : }else
8770 13374 : (to)->encrypted_pa_data = NULL;
8771 13079 : return 0;
8772 0 : fail:
8773 0 : free_EncKDCRepPart(to);
8774 0 : return ENOMEM;
8775 : }
8776 :
8777 : int ASN1CALL
8778 26343 : encode_EncASRepPart(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const EncASRepPart *data, size_t *size)
8779 : {
8780 26343 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
8781 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
8782 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
8783 :
8784 26343 : e = encode_EncKDCRepPart(p, len, data, &l);
8785 26343 : if (e) return e;
8786 26343 : p -= l; len -= l; ret += l;
8787 :
8788 26343 : e = der_put_length_and_tag (p, len, ret, ASN1_C_APPL, CONS, 25, &l);
8789 26343 : if (e) return e;
8790 26343 : p -= l; len -= l; ret += l;
8791 :
8792 26343 : *size = ret;
8793 26343 : return 0;
8794 : }
8795 :
8796 : int ASN1CALL
8797 52862 : decode_EncASRepPart(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, EncASRepPart *data, size_t *size)
8798 : {
8799 52862 : size_t ret = 0;
8800 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
8801 : int e HEIMDAL_UNUSED_ATTRIBUTE;
8802 :
8803 52862 : memset(data, 0, sizeof(*data));
8804 : {
8805 : size_t Top_datalen, Top_oldlen;
8806 : Der_type Top_type;
8807 52862 : e = der_match_tag_and_length(p, len, ASN1_C_APPL, &Top_type, 25, &Top_datalen, &l);
8808 52862 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
8809 91261 : if(e) goto fail;
8810 13374 : p += l; len -= l; ret += l;
8811 13374 : Top_oldlen = len;
8812 13374 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
8813 13374 : len = Top_datalen;
8814 13374 : e = decode_EncKDCRepPart(p, len, data, &l);
8815 13374 : if(e) goto fail;
8816 13374 : p += l; len -= l; ret += l;
8817 13374 : len = Top_oldlen - Top_datalen;
8818 : }
8819 26748 : if(size) *size = ret;
8820 13079 : return 0;
8821 39488 : fail:
8822 39488 : free_EncASRepPart(data);
8823 39488 : return e;
8824 : }
8825 :
8826 : void ASN1CALL
8827 52862 : free_EncASRepPart(EncASRepPart *data)
8828 : {
8829 52862 : free_EncKDCRepPart(data);
8830 52862 : }
8831 :
8832 : size_t ASN1CALL
8833 26343 : length_EncASRepPart(const EncASRepPart *data)
8834 : {
8835 26343 : size_t ret = 0;
8836 26343 : ret += length_EncKDCRepPart(data);
8837 26343 : ret += 1 + der_length_len (ret);
8838 26343 : return ret;
8839 : }
8840 :
8841 : int ASN1CALL
8842 0 : copy_EncASRepPart(const EncASRepPart *from, EncASRepPart *to)
8843 : {
8844 0 : memset(to, 0, sizeof(*to));
8845 0 : if(copy_EncKDCRepPart(from, to)) goto fail;
8846 0 : return 0;
8847 0 : fail:
8848 0 : free_EncASRepPart(to);
8849 0 : return ENOMEM;
8850 : }
8851 :
8852 : int ASN1CALL
8853 39673 : encode_EncTGSRepPart(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const EncTGSRepPart *data, size_t *size)
8854 : {
8855 39673 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
8856 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
8857 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
8858 :
8859 39673 : e = encode_EncKDCRepPart(p, len, data, &l);
8860 39673 : if (e) return e;
8861 39673 : p -= l; len -= l; ret += l;
8862 :
8863 39673 : e = der_put_length_and_tag (p, len, ret, ASN1_C_APPL, CONS, 26, &l);
8864 39673 : if (e) return e;
8865 39673 : p -= l; len -= l; ret += l;
8866 :
8867 39673 : *size = ret;
8868 39673 : return 0;
8869 : }
8870 :
8871 : int ASN1CALL
8872 39488 : decode_EncTGSRepPart(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, EncTGSRepPart *data, size_t *size)
8873 : {
8874 39488 : size_t ret = 0;
8875 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
8876 : int e HEIMDAL_UNUSED_ATTRIBUTE;
8877 :
8878 39488 : memset(data, 0, sizeof(*data));
8879 : {
8880 : size_t Top_datalen, Top_oldlen;
8881 : Der_type Top_type;
8882 39488 : e = der_match_tag_and_length(p, len, ASN1_C_APPL, &Top_type, 26, &Top_datalen, &l);
8883 39488 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
8884 39488 : if(e) goto fail;
8885 39488 : p += l; len -= l; ret += l;
8886 39488 : Top_oldlen = len;
8887 39488 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
8888 39488 : len = Top_datalen;
8889 39488 : e = decode_EncKDCRepPart(p, len, data, &l);
8890 39488 : if(e) goto fail;
8891 39488 : p += l; len -= l; ret += l;
8892 39488 : len = Top_oldlen - Top_datalen;
8893 : }
8894 78976 : if(size) *size = ret;
8895 38399 : return 0;
8896 0 : fail:
8897 0 : free_EncTGSRepPart(data);
8898 0 : return e;
8899 : }
8900 :
8901 : void ASN1CALL
8902 39488 : free_EncTGSRepPart(EncTGSRepPart *data)
8903 : {
8904 39488 : free_EncKDCRepPart(data);
8905 39488 : }
8906 :
8907 : size_t ASN1CALL
8908 39673 : length_EncTGSRepPart(const EncTGSRepPart *data)
8909 : {
8910 39673 : size_t ret = 0;
8911 39673 : ret += length_EncKDCRepPart(data);
8912 39673 : ret += 1 + der_length_len (ret);
8913 39673 : return ret;
8914 : }
8915 :
8916 : int ASN1CALL
8917 0 : copy_EncTGSRepPart(const EncTGSRepPart *from, EncTGSRepPart *to)
8918 : {
8919 0 : memset(to, 0, sizeof(*to));
8920 0 : if(copy_EncKDCRepPart(from, to)) goto fail;
8921 0 : return 0;
8922 0 : fail:
8923 0 : free_EncTGSRepPart(to);
8924 0 : return ENOMEM;
8925 : }
8926 :
8927 : int ASN1CALL
8928 68110 : encode_AP_REQ(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const AP_REQ *data, size_t *size)
8929 : {
8930 68110 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
8931 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
8932 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
8933 :
8934 : /* authenticator */
8935 : {
8936 68110 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
8937 68110 : ret = 0;
8938 68110 : e = encode_EncryptedData(p, len, &(data)->authenticator, &l);
8939 68110 : if (e) return e;
8940 68110 : p -= l; len -= l; ret += l;
8941 :
8942 68110 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 4, &l);
8943 68110 : if (e) return e;
8944 68110 : p -= l; len -= l; ret += l;
8945 :
8946 68110 : ret += Top_tag_tag_oldret;
8947 : }
8948 : /* ticket */
8949 : {
8950 68110 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
8951 68110 : ret = 0;
8952 68110 : e = encode_Ticket(p, len, &(data)->ticket, &l);
8953 68110 : if (e) return e;
8954 68110 : p -= l; len -= l; ret += l;
8955 :
8956 68110 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
8957 68110 : if (e) return e;
8958 68110 : p -= l; len -= l; ret += l;
8959 :
8960 68110 : ret += Top_tag_tag_oldret;
8961 : }
8962 : /* ap-options */
8963 : {
8964 68110 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
8965 68110 : ret = 0;
8966 68110 : e = encode_APOptions(p, len, &(data)->ap_options, &l);
8967 68110 : if (e) return e;
8968 68110 : p -= l; len -= l; ret += l;
8969 :
8970 68110 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
8971 68110 : if (e) return e;
8972 68110 : p -= l; len -= l; ret += l;
8973 :
8974 68110 : ret += Top_tag_tag_oldret;
8975 : }
8976 : /* msg-type */
8977 : {
8978 68110 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
8979 68110 : ret = 0;
8980 68110 : e = encode_MESSAGE_TYPE(p, len, &(data)->msg_type, &l);
8981 68110 : if (e) return e;
8982 68110 : p -= l; len -= l; ret += l;
8983 :
8984 68110 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
8985 68110 : if (e) return e;
8986 68110 : p -= l; len -= l; ret += l;
8987 :
8988 68110 : ret += Top_tag_tag_oldret;
8989 : }
8990 : /* pvno */
8991 : {
8992 68110 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
8993 68110 : ret = 0;
8994 68110 : e = encode_krb5int32(p, len, &(data)->pvno, &l);
8995 68110 : if (e) return e;
8996 68110 : p -= l; len -= l; ret += l;
8997 :
8998 68110 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
8999 68110 : if (e) return e;
9000 68110 : p -= l; len -= l; ret += l;
9001 :
9002 68110 : ret += Top_tag_tag_oldret;
9003 : }
9004 68110 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
9005 68110 : if (e) return e;
9006 68110 : p -= l; len -= l; ret += l;
9007 :
9008 68110 : e = der_put_length_and_tag (p, len, ret, ASN1_C_APPL, CONS, 14, &l);
9009 68110 : if (e) return e;
9010 68110 : p -= l; len -= l; ret += l;
9011 :
9012 68110 : *size = ret;
9013 68110 : return 0;
9014 : }
9015 :
9016 : int ASN1CALL
9017 63408 : decode_AP_REQ(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, AP_REQ *data, size_t *size)
9018 : {
9019 63408 : size_t ret = 0;
9020 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
9021 : int e HEIMDAL_UNUSED_ATTRIBUTE;
9022 :
9023 63408 : memset(data, 0, sizeof(*data));
9024 : {
9025 : size_t Top_datalen, Top_oldlen;
9026 : Der_type Top_type;
9027 63408 : e = der_match_tag_and_length(p, len, ASN1_C_APPL, &Top_type, 14, &Top_datalen, &l);
9028 63408 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
9029 63408 : if(e) goto fail;
9030 63408 : p += l; len -= l; ret += l;
9031 63408 : Top_oldlen = len;
9032 63408 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9033 63408 : len = Top_datalen;
9034 : {
9035 : size_t Top_Tag_datalen, Top_Tag_oldlen;
9036 : Der_type Top_Tag_type;
9037 63408 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_Tag_type, UT_Sequence, &Top_Tag_datalen, &l);
9038 63408 : if (e == 0 && Top_Tag_type != CONS) { e = ASN1_BAD_ID; }
9039 63408 : if(e) goto fail;
9040 63408 : p += l; len -= l; ret += l;
9041 63408 : Top_Tag_oldlen = len;
9042 63408 : if (Top_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9043 63408 : len = Top_Tag_datalen;
9044 : {
9045 : size_t pvno_datalen, pvno_oldlen;
9046 : Der_type pvno_type;
9047 63408 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &pvno_type, 0, &pvno_datalen, &l);
9048 63408 : if (e == 0 && pvno_type != CONS) { e = ASN1_BAD_ID; }
9049 63408 : if(e) goto fail;
9050 63408 : p += l; len -= l; ret += l;
9051 63408 : pvno_oldlen = len;
9052 63408 : if (pvno_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9053 63408 : len = pvno_datalen;
9054 63408 : e = decode_krb5int32(p, len, &(data)->pvno, &l);
9055 63408 : if(e) goto fail;
9056 63408 : p += l; len -= l; ret += l;
9057 63408 : len = pvno_oldlen - pvno_datalen;
9058 : }
9059 : {
9060 : size_t msg_type_datalen, msg_type_oldlen;
9061 : Der_type msg_type_type;
9062 63408 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &msg_type_type, 1, &msg_type_datalen, &l);
9063 124989 : if (e == 0 && msg_type_type != CONS) { e = ASN1_BAD_ID; }
9064 63408 : if(e) goto fail;
9065 63408 : p += l; len -= l; ret += l;
9066 63408 : msg_type_oldlen = len;
9067 63408 : if (msg_type_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9068 63408 : len = msg_type_datalen;
9069 63408 : e = decode_MESSAGE_TYPE(p, len, &(data)->msg_type, &l);
9070 63408 : if(e) goto fail;
9071 63408 : p += l; len -= l; ret += l;
9072 63408 : len = msg_type_oldlen - msg_type_datalen;
9073 : }
9074 : {
9075 : size_t ap_options_datalen, ap_options_oldlen;
9076 : Der_type ap_options_type;
9077 63408 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &ap_options_type, 2, &ap_options_datalen, &l);
9078 124989 : if (e == 0 && ap_options_type != CONS) { e = ASN1_BAD_ID; }
9079 63408 : if(e) goto fail;
9080 63408 : p += l; len -= l; ret += l;
9081 63408 : ap_options_oldlen = len;
9082 63408 : if (ap_options_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9083 63408 : len = ap_options_datalen;
9084 63408 : e = decode_APOptions(p, len, &(data)->ap_options, &l);
9085 63408 : if(e) goto fail;
9086 63408 : p += l; len -= l; ret += l;
9087 63408 : len = ap_options_oldlen - ap_options_datalen;
9088 : }
9089 : {
9090 : size_t ticket_datalen, ticket_oldlen;
9091 : Der_type ticket_type;
9092 63408 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &ticket_type, 3, &ticket_datalen, &l);
9093 124989 : if (e == 0 && ticket_type != CONS) { e = ASN1_BAD_ID; }
9094 63408 : if(e) goto fail;
9095 63408 : p += l; len -= l; ret += l;
9096 63408 : ticket_oldlen = len;
9097 63408 : if (ticket_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9098 63408 : len = ticket_datalen;
9099 63408 : e = decode_Ticket(p, len, &(data)->ticket, &l);
9100 63408 : if(e) goto fail;
9101 63408 : p += l; len -= l; ret += l;
9102 63408 : len = ticket_oldlen - ticket_datalen;
9103 : }
9104 : {
9105 : size_t authenticator_datalen, authenticator_oldlen;
9106 : Der_type authenticator_type;
9107 63408 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &authenticator_type, 4, &authenticator_datalen, &l);
9108 124989 : if (e == 0 && authenticator_type != CONS) { e = ASN1_BAD_ID; }
9109 63408 : if(e) goto fail;
9110 63408 : p += l; len -= l; ret += l;
9111 63408 : authenticator_oldlen = len;
9112 63408 : if (authenticator_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9113 63408 : len = authenticator_datalen;
9114 63408 : e = decode_EncryptedData(p, len, &(data)->authenticator, &l);
9115 63408 : if(e) goto fail;
9116 63408 : p += l; len -= l; ret += l;
9117 63408 : len = authenticator_oldlen - authenticator_datalen;
9118 : }
9119 63408 : len = Top_Tag_oldlen - Top_Tag_datalen;
9120 : }
9121 63408 : len = Top_oldlen - Top_datalen;
9122 : }
9123 126816 : if(size) *size = ret;
9124 61581 : return 0;
9125 0 : fail:
9126 0 : free_AP_REQ(data);
9127 0 : return e;
9128 : }
9129 :
9130 : void ASN1CALL
9131 131518 : free_AP_REQ(AP_REQ *data)
9132 : {
9133 131518 : free_krb5int32(&(data)->pvno);
9134 131518 : free_MESSAGE_TYPE(&(data)->msg_type);
9135 131518 : free_APOptions(&(data)->ap_options);
9136 131518 : free_Ticket(&(data)->ticket);
9137 131518 : free_EncryptedData(&(data)->authenticator);
9138 131518 : }
9139 :
9140 : size_t ASN1CALL
9141 68110 : length_AP_REQ(const AP_REQ *data)
9142 : {
9143 68110 : size_t ret = 0;
9144 : {
9145 68110 : size_t Top_tag_tag_oldret = ret;
9146 68110 : ret = 0;
9147 68110 : ret += length_krb5int32(&(data)->pvno);
9148 68110 : ret += 1 + der_length_len (ret);
9149 68110 : ret += Top_tag_tag_oldret;
9150 : }
9151 : {
9152 68110 : size_t Top_tag_tag_oldret = ret;
9153 68110 : ret = 0;
9154 68110 : ret += length_MESSAGE_TYPE(&(data)->msg_type);
9155 68110 : ret += 1 + der_length_len (ret);
9156 68110 : ret += Top_tag_tag_oldret;
9157 : }
9158 : {
9159 68110 : size_t Top_tag_tag_oldret = ret;
9160 68110 : ret = 0;
9161 68110 : ret += length_APOptions(&(data)->ap_options);
9162 68110 : ret += 1 + der_length_len (ret);
9163 68110 : ret += Top_tag_tag_oldret;
9164 : }
9165 : {
9166 68110 : size_t Top_tag_tag_oldret = ret;
9167 68110 : ret = 0;
9168 68110 : ret += length_Ticket(&(data)->ticket);
9169 68110 : ret += 1 + der_length_len (ret);
9170 68110 : ret += Top_tag_tag_oldret;
9171 : }
9172 : {
9173 68110 : size_t Top_tag_tag_oldret = ret;
9174 68110 : ret = 0;
9175 68110 : ret += length_EncryptedData(&(data)->authenticator);
9176 68110 : ret += 1 + der_length_len (ret);
9177 68110 : ret += Top_tag_tag_oldret;
9178 : }
9179 68110 : ret += 1 + der_length_len (ret);
9180 68110 : ret += 1 + der_length_len (ret);
9181 68110 : return ret;
9182 : }
9183 :
9184 : int ASN1CALL
9185 0 : copy_AP_REQ(const AP_REQ *from, AP_REQ *to)
9186 : {
9187 0 : memset(to, 0, sizeof(*to));
9188 0 : if(copy_krb5int32(&(from)->pvno, &(to)->pvno)) goto fail;
9189 0 : if(copy_MESSAGE_TYPE(&(from)->msg_type, &(to)->msg_type)) goto fail;
9190 0 : if(copy_APOptions(&(from)->ap_options, &(to)->ap_options)) goto fail;
9191 0 : if(copy_Ticket(&(from)->ticket, &(to)->ticket)) goto fail;
9192 0 : if(copy_EncryptedData(&(from)->authenticator, &(to)->authenticator)) goto fail;
9193 0 : return 0;
9194 0 : fail:
9195 0 : free_AP_REQ(to);
9196 0 : return ENOMEM;
9197 : }
9198 :
9199 : int ASN1CALL
9200 24843 : encode_AP_REP(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const AP_REP *data, size_t *size)
9201 : {
9202 24843 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
9203 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
9204 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
9205 :
9206 : /* enc-part */
9207 : {
9208 24843 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
9209 24843 : ret = 0;
9210 24843 : e = encode_EncryptedData(p, len, &(data)->enc_part, &l);
9211 24843 : if (e) return e;
9212 24843 : p -= l; len -= l; ret += l;
9213 :
9214 24843 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
9215 24843 : if (e) return e;
9216 24843 : p -= l; len -= l; ret += l;
9217 :
9218 24843 : ret += Top_tag_tag_oldret;
9219 : }
9220 : /* msg-type */
9221 : {
9222 24843 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
9223 24843 : ret = 0;
9224 24843 : e = encode_MESSAGE_TYPE(p, len, &(data)->msg_type, &l);
9225 24843 : if (e) return e;
9226 24843 : p -= l; len -= l; ret += l;
9227 :
9228 24843 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
9229 24843 : if (e) return e;
9230 24843 : p -= l; len -= l; ret += l;
9231 :
9232 24843 : ret += Top_tag_tag_oldret;
9233 : }
9234 : /* pvno */
9235 : {
9236 24843 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
9237 24843 : ret = 0;
9238 24843 : e = encode_krb5int32(p, len, &(data)->pvno, &l);
9239 24843 : if (e) return e;
9240 24843 : p -= l; len -= l; ret += l;
9241 :
9242 24843 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
9243 24843 : if (e) return e;
9244 24843 : p -= l; len -= l; ret += l;
9245 :
9246 24843 : ret += Top_tag_tag_oldret;
9247 : }
9248 24843 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
9249 24843 : if (e) return e;
9250 24843 : p -= l; len -= l; ret += l;
9251 :
9252 24843 : e = der_put_length_and_tag (p, len, ret, ASN1_C_APPL, CONS, 15, &l);
9253 24843 : if (e) return e;
9254 24843 : p -= l; len -= l; ret += l;
9255 :
9256 24843 : *size = ret;
9257 24843 : return 0;
9258 : }
9259 :
9260 : int ASN1CALL
9261 23112 : decode_AP_REP(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, AP_REP *data, size_t *size)
9262 : {
9263 23112 : size_t ret = 0;
9264 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
9265 : int e HEIMDAL_UNUSED_ATTRIBUTE;
9266 :
9267 23112 : memset(data, 0, sizeof(*data));
9268 : {
9269 : size_t Top_datalen, Top_oldlen;
9270 : Der_type Top_type;
9271 23112 : e = der_match_tag_and_length(p, len, ASN1_C_APPL, &Top_type, 15, &Top_datalen, &l);
9272 23112 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
9273 23112 : if(e) goto fail;
9274 23112 : p += l; len -= l; ret += l;
9275 23112 : Top_oldlen = len;
9276 23112 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9277 23112 : len = Top_datalen;
9278 : {
9279 : size_t Top_Tag_datalen, Top_Tag_oldlen;
9280 : Der_type Top_Tag_type;
9281 23112 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_Tag_type, UT_Sequence, &Top_Tag_datalen, &l);
9282 23112 : if (e == 0 && Top_Tag_type != CONS) { e = ASN1_BAD_ID; }
9283 23112 : if(e) goto fail;
9284 23112 : p += l; len -= l; ret += l;
9285 23112 : Top_Tag_oldlen = len;
9286 23112 : if (Top_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9287 23112 : len = Top_Tag_datalen;
9288 : {
9289 : size_t pvno_datalen, pvno_oldlen;
9290 : Der_type pvno_type;
9291 23112 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &pvno_type, 0, &pvno_datalen, &l);
9292 23112 : if (e == 0 && pvno_type != CONS) { e = ASN1_BAD_ID; }
9293 23112 : if(e) goto fail;
9294 23112 : p += l; len -= l; ret += l;
9295 23112 : pvno_oldlen = len;
9296 23112 : if (pvno_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9297 23112 : len = pvno_datalen;
9298 23112 : e = decode_krb5int32(p, len, &(data)->pvno, &l);
9299 23112 : if(e) goto fail;
9300 23112 : p += l; len -= l; ret += l;
9301 23112 : len = pvno_oldlen - pvno_datalen;
9302 : }
9303 : {
9304 : size_t msg_type_datalen, msg_type_oldlen;
9305 : Der_type msg_type_type;
9306 23112 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &msg_type_type, 1, &msg_type_datalen, &l);
9307 45390 : if (e == 0 && msg_type_type != CONS) { e = ASN1_BAD_ID; }
9308 23112 : if(e) goto fail;
9309 23112 : p += l; len -= l; ret += l;
9310 23112 : msg_type_oldlen = len;
9311 23112 : if (msg_type_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9312 23112 : len = msg_type_datalen;
9313 23112 : e = decode_MESSAGE_TYPE(p, len, &(data)->msg_type, &l);
9314 23112 : if(e) goto fail;
9315 23112 : p += l; len -= l; ret += l;
9316 23112 : len = msg_type_oldlen - msg_type_datalen;
9317 : }
9318 : {
9319 : size_t enc_part_datalen, enc_part_oldlen;
9320 : Der_type enc_part_type;
9321 23112 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &enc_part_type, 2, &enc_part_datalen, &l);
9322 45390 : if (e == 0 && enc_part_type != CONS) { e = ASN1_BAD_ID; }
9323 23112 : if(e) goto fail;
9324 23112 : p += l; len -= l; ret += l;
9325 23112 : enc_part_oldlen = len;
9326 23112 : if (enc_part_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9327 23112 : len = enc_part_datalen;
9328 23112 : e = decode_EncryptedData(p, len, &(data)->enc_part, &l);
9329 23112 : if(e) goto fail;
9330 23112 : p += l; len -= l; ret += l;
9331 23112 : len = enc_part_oldlen - enc_part_datalen;
9332 : }
9333 23112 : len = Top_Tag_oldlen - Top_Tag_datalen;
9334 : }
9335 23112 : len = Top_oldlen - Top_datalen;
9336 : }
9337 46224 : if(size) *size = ret;
9338 22278 : return 0;
9339 0 : fail:
9340 0 : free_AP_REP(data);
9341 0 : return e;
9342 : }
9343 :
9344 : void ASN1CALL
9345 47955 : free_AP_REP(AP_REP *data)
9346 : {
9347 47955 : free_krb5int32(&(data)->pvno);
9348 47955 : free_MESSAGE_TYPE(&(data)->msg_type);
9349 47955 : free_EncryptedData(&(data)->enc_part);
9350 47955 : }
9351 :
9352 : size_t ASN1CALL
9353 24843 : length_AP_REP(const AP_REP *data)
9354 : {
9355 24843 : size_t ret = 0;
9356 : {
9357 24843 : size_t Top_tag_tag_oldret = ret;
9358 24843 : ret = 0;
9359 24843 : ret += length_krb5int32(&(data)->pvno);
9360 24843 : ret += 1 + der_length_len (ret);
9361 24843 : ret += Top_tag_tag_oldret;
9362 : }
9363 : {
9364 24843 : size_t Top_tag_tag_oldret = ret;
9365 24843 : ret = 0;
9366 24843 : ret += length_MESSAGE_TYPE(&(data)->msg_type);
9367 24843 : ret += 1 + der_length_len (ret);
9368 24843 : ret += Top_tag_tag_oldret;
9369 : }
9370 : {
9371 24843 : size_t Top_tag_tag_oldret = ret;
9372 24843 : ret = 0;
9373 24843 : ret += length_EncryptedData(&(data)->enc_part);
9374 24843 : ret += 1 + der_length_len (ret);
9375 24843 : ret += Top_tag_tag_oldret;
9376 : }
9377 24843 : ret += 1 + der_length_len (ret);
9378 24843 : ret += 1 + der_length_len (ret);
9379 24843 : return ret;
9380 : }
9381 :
9382 : int ASN1CALL
9383 0 : copy_AP_REP(const AP_REP *from, AP_REP *to)
9384 : {
9385 0 : memset(to, 0, sizeof(*to));
9386 0 : if(copy_krb5int32(&(from)->pvno, &(to)->pvno)) goto fail;
9387 0 : if(copy_MESSAGE_TYPE(&(from)->msg_type, &(to)->msg_type)) goto fail;
9388 0 : if(copy_EncryptedData(&(from)->enc_part, &(to)->enc_part)) goto fail;
9389 0 : return 0;
9390 0 : fail:
9391 0 : free_AP_REP(to);
9392 0 : return ENOMEM;
9393 : }
9394 :
9395 : int ASN1CALL
9396 24843 : encode_EncAPRepPart(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const EncAPRepPart *data, size_t *size)
9397 : {
9398 24843 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
9399 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
9400 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
9401 :
9402 : /* seq-number */
9403 24843 : if((data)->seq_number) {
9404 24843 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
9405 24843 : ret = 0;
9406 24843 : e = encode_krb5uint32(p, len, (data)->seq_number, &l);
9407 24843 : if (e) return e;
9408 24843 : p -= l; len -= l; ret += l;
9409 :
9410 24843 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
9411 24843 : if (e) return e;
9412 24843 : p -= l; len -= l; ret += l;
9413 :
9414 24843 : ret += Top_tag_tag_oldret;
9415 : }
9416 : /* subkey */
9417 24843 : if((data)->subkey) {
9418 19962 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
9419 19962 : ret = 0;
9420 19962 : e = encode_EncryptionKey(p, len, (data)->subkey, &l);
9421 19962 : if (e) return e;
9422 19962 : p -= l; len -= l; ret += l;
9423 :
9424 19962 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
9425 19962 : if (e) return e;
9426 19962 : p -= l; len -= l; ret += l;
9427 :
9428 19962 : ret += Top_tag_tag_oldret;
9429 : }
9430 : /* cusec */
9431 : {
9432 24843 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
9433 24843 : ret = 0;
9434 24843 : e = encode_krb5int32(p, len, &(data)->cusec, &l);
9435 24843 : if (e) return e;
9436 24843 : p -= l; len -= l; ret += l;
9437 :
9438 24843 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
9439 24843 : if (e) return e;
9440 24843 : p -= l; len -= l; ret += l;
9441 :
9442 24843 : ret += Top_tag_tag_oldret;
9443 : }
9444 : /* ctime */
9445 : {
9446 24843 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
9447 24843 : ret = 0;
9448 24843 : e = encode_KerberosTime(p, len, &(data)->ctime, &l);
9449 24843 : if (e) return e;
9450 24843 : p -= l; len -= l; ret += l;
9451 :
9452 24843 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
9453 24843 : if (e) return e;
9454 24843 : p -= l; len -= l; ret += l;
9455 :
9456 24843 : ret += Top_tag_tag_oldret;
9457 : }
9458 24843 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
9459 24843 : if (e) return e;
9460 24843 : p -= l; len -= l; ret += l;
9461 :
9462 24843 : e = der_put_length_and_tag (p, len, ret, ASN1_C_APPL, CONS, 27, &l);
9463 24843 : if (e) return e;
9464 24843 : p -= l; len -= l; ret += l;
9465 :
9466 24843 : *size = ret;
9467 24843 : return 0;
9468 : }
9469 :
9470 : int ASN1CALL
9471 23112 : decode_EncAPRepPart(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, EncAPRepPart *data, size_t *size)
9472 : {
9473 23112 : size_t ret = 0;
9474 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
9475 : int e HEIMDAL_UNUSED_ATTRIBUTE;
9476 :
9477 23112 : memset(data, 0, sizeof(*data));
9478 : {
9479 : size_t Top_datalen, Top_oldlen;
9480 : Der_type Top_type;
9481 23112 : e = der_match_tag_and_length(p, len, ASN1_C_APPL, &Top_type, 27, &Top_datalen, &l);
9482 23112 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
9483 23112 : if(e) goto fail;
9484 23112 : p += l; len -= l; ret += l;
9485 23112 : Top_oldlen = len;
9486 23112 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9487 23112 : len = Top_datalen;
9488 : {
9489 : size_t Top_Tag_datalen, Top_Tag_oldlen;
9490 : Der_type Top_Tag_type;
9491 23112 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_Tag_type, UT_Sequence, &Top_Tag_datalen, &l);
9492 23112 : if (e == 0 && Top_Tag_type != CONS) { e = ASN1_BAD_ID; }
9493 23112 : if(e) goto fail;
9494 23112 : p += l; len -= l; ret += l;
9495 23112 : Top_Tag_oldlen = len;
9496 23112 : if (Top_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9497 23112 : len = Top_Tag_datalen;
9498 : {
9499 : size_t ctime_datalen, ctime_oldlen;
9500 : Der_type ctime_type;
9501 23112 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &ctime_type, 0, &ctime_datalen, &l);
9502 23112 : if (e == 0 && ctime_type != CONS) { e = ASN1_BAD_ID; }
9503 23112 : if(e) goto fail;
9504 23112 : p += l; len -= l; ret += l;
9505 23112 : ctime_oldlen = len;
9506 23112 : if (ctime_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9507 23112 : len = ctime_datalen;
9508 23112 : e = decode_KerberosTime(p, len, &(data)->ctime, &l);
9509 23112 : if(e) goto fail;
9510 23112 : p += l; len -= l; ret += l;
9511 23112 : len = ctime_oldlen - ctime_datalen;
9512 : }
9513 : {
9514 : size_t cusec_datalen, cusec_oldlen;
9515 : Der_type cusec_type;
9516 23112 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &cusec_type, 1, &cusec_datalen, &l);
9517 45390 : if (e == 0 && cusec_type != CONS) { e = ASN1_BAD_ID; }
9518 23112 : if(e) goto fail;
9519 23112 : p += l; len -= l; ret += l;
9520 23112 : cusec_oldlen = len;
9521 23112 : if (cusec_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9522 23112 : len = cusec_datalen;
9523 23112 : e = decode_krb5int32(p, len, &(data)->cusec, &l);
9524 23112 : if(e) goto fail;
9525 23112 : p += l; len -= l; ret += l;
9526 23112 : len = cusec_oldlen - cusec_datalen;
9527 : }
9528 : {
9529 : size_t subkey_datalen, subkey_oldlen;
9530 : Der_type subkey_type;
9531 23112 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &subkey_type, 2, &subkey_datalen, &l);
9532 42048 : if (e == 0 && subkey_type != CONS) { e = ASN1_BAD_ID; }
9533 23112 : if(e) {
9534 3438 : (data)->subkey = NULL;
9535 : } else {
9536 19674 : (data)->subkey = calloc(1, sizeof(*(data)->subkey));
9537 19674 : if ((data)->subkey == NULL) { e = ENOMEM; goto fail; }
9538 19674 : p += l; len -= l; ret += l;
9539 19674 : subkey_oldlen = len;
9540 19674 : if (subkey_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9541 19674 : len = subkey_datalen;
9542 19674 : e = decode_EncryptionKey(p, len, (data)->subkey, &l);
9543 19674 : if(e) goto fail;
9544 19674 : p += l; len -= l; ret += l;
9545 19674 : len = subkey_oldlen - subkey_datalen;
9546 : }
9547 : }
9548 : {
9549 : size_t seq_number_datalen, seq_number_oldlen;
9550 : Der_type seq_number_type;
9551 23112 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &seq_number_type, 3, &seq_number_datalen, &l);
9552 46224 : if (e == 0 && seq_number_type != CONS) { e = ASN1_BAD_ID; }
9553 23112 : if(e) {
9554 0 : (data)->seq_number = NULL;
9555 : } else {
9556 23112 : (data)->seq_number = calloc(1, sizeof(*(data)->seq_number));
9557 23112 : if ((data)->seq_number == NULL) { e = ENOMEM; goto fail; }
9558 23112 : p += l; len -= l; ret += l;
9559 23112 : seq_number_oldlen = len;
9560 23112 : if (seq_number_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9561 23112 : len = seq_number_datalen;
9562 23112 : e = decode_krb5uint32(p, len, (data)->seq_number, &l);
9563 23112 : if(e) goto fail;
9564 23112 : p += l; len -= l; ret += l;
9565 23112 : len = seq_number_oldlen - seq_number_datalen;
9566 : }
9567 : }
9568 23112 : len = Top_Tag_oldlen - Top_Tag_datalen;
9569 : }
9570 23112 : len = Top_oldlen - Top_datalen;
9571 : }
9572 46224 : if(size) *size = ret;
9573 22278 : return 0;
9574 0 : fail:
9575 0 : free_EncAPRepPart(data);
9576 0 : return e;
9577 : }
9578 :
9579 : void ASN1CALL
9580 47955 : free_EncAPRepPart(EncAPRepPart *data)
9581 : {
9582 47955 : free_KerberosTime(&(data)->ctime);
9583 47955 : free_krb5int32(&(data)->cusec);
9584 47955 : if((data)->subkey) {
9585 39636 : free_EncryptionKey((data)->subkey);
9586 39636 : free((data)->subkey);
9587 39636 : (data)->subkey = NULL;
9588 : }
9589 47955 : if((data)->seq_number) {
9590 47955 : free_krb5uint32((data)->seq_number);
9591 47955 : free((data)->seq_number);
9592 47955 : (data)->seq_number = NULL;
9593 : }
9594 47955 : }
9595 :
9596 : size_t ASN1CALL
9597 24843 : length_EncAPRepPart(const EncAPRepPart *data)
9598 : {
9599 24843 : size_t ret = 0;
9600 : {
9601 24843 : size_t Top_tag_tag_oldret = ret;
9602 24843 : ret = 0;
9603 24843 : ret += length_KerberosTime(&(data)->ctime);
9604 24843 : ret += 1 + der_length_len (ret);
9605 24843 : ret += Top_tag_tag_oldret;
9606 : }
9607 : {
9608 24843 : size_t Top_tag_tag_oldret = ret;
9609 24843 : ret = 0;
9610 24843 : ret += length_krb5int32(&(data)->cusec);
9611 24843 : ret += 1 + der_length_len (ret);
9612 24843 : ret += Top_tag_tag_oldret;
9613 : }
9614 24843 : if((data)->subkey){
9615 19962 : size_t Top_tag_tag_oldret = ret;
9616 19962 : ret = 0;
9617 19962 : ret += length_EncryptionKey((data)->subkey);
9618 19962 : ret += 1 + der_length_len (ret);
9619 19962 : ret += Top_tag_tag_oldret;
9620 : }
9621 24843 : if((data)->seq_number){
9622 24843 : size_t Top_tag_tag_oldret = ret;
9623 24843 : ret = 0;
9624 24843 : ret += length_krb5uint32((data)->seq_number);
9625 24843 : ret += 1 + der_length_len (ret);
9626 24843 : ret += Top_tag_tag_oldret;
9627 : }
9628 24843 : ret += 1 + der_length_len (ret);
9629 24843 : ret += 1 + der_length_len (ret);
9630 24843 : return ret;
9631 : }
9632 :
9633 : int ASN1CALL
9634 0 : copy_EncAPRepPart(const EncAPRepPart *from, EncAPRepPart *to)
9635 : {
9636 0 : memset(to, 0, sizeof(*to));
9637 0 : if(copy_KerberosTime(&(from)->ctime, &(to)->ctime)) goto fail;
9638 0 : if(copy_krb5int32(&(from)->cusec, &(to)->cusec)) goto fail;
9639 0 : if((from)->subkey) {
9640 0 : (to)->subkey = malloc(sizeof(*(to)->subkey));
9641 0 : if((to)->subkey == NULL) goto fail;
9642 0 : if(copy_EncryptionKey((from)->subkey, (to)->subkey)) goto fail;
9643 : }else
9644 0 : (to)->subkey = NULL;
9645 0 : if((from)->seq_number) {
9646 0 : (to)->seq_number = malloc(sizeof(*(to)->seq_number));
9647 0 : if((to)->seq_number == NULL) goto fail;
9648 0 : if(copy_krb5uint32((from)->seq_number, (to)->seq_number)) goto fail;
9649 : }else
9650 0 : (to)->seq_number = NULL;
9651 0 : return 0;
9652 0 : fail:
9653 0 : free_EncAPRepPart(to);
9654 0 : return ENOMEM;
9655 : }
9656 :
9657 : int ASN1CALL
9658 0 : encode_KRB_SAFE_BODY(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const KRB_SAFE_BODY *data, size_t *size)
9659 : {
9660 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
9661 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
9662 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
9663 :
9664 : /* r-address */
9665 0 : if((data)->r_address) {
9666 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
9667 0 : ret = 0;
9668 0 : e = encode_HostAddress(p, len, (data)->r_address, &l);
9669 0 : if (e) return e;
9670 0 : p -= l; len -= l; ret += l;
9671 :
9672 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 5, &l);
9673 0 : if (e) return e;
9674 0 : p -= l; len -= l; ret += l;
9675 :
9676 0 : ret += Top_tag_oldret;
9677 : }
9678 : /* s-address */
9679 0 : if((data)->s_address) {
9680 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
9681 0 : ret = 0;
9682 0 : e = encode_HostAddress(p, len, (data)->s_address, &l);
9683 0 : if (e) return e;
9684 0 : p -= l; len -= l; ret += l;
9685 :
9686 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 4, &l);
9687 0 : if (e) return e;
9688 0 : p -= l; len -= l; ret += l;
9689 :
9690 0 : ret += Top_tag_oldret;
9691 : }
9692 : /* seq-number */
9693 0 : if((data)->seq_number) {
9694 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
9695 0 : ret = 0;
9696 0 : e = encode_krb5uint32(p, len, (data)->seq_number, &l);
9697 0 : if (e) return e;
9698 0 : p -= l; len -= l; ret += l;
9699 :
9700 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
9701 0 : if (e) return e;
9702 0 : p -= l; len -= l; ret += l;
9703 :
9704 0 : ret += Top_tag_oldret;
9705 : }
9706 : /* usec */
9707 0 : if((data)->usec) {
9708 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
9709 0 : ret = 0;
9710 0 : e = encode_krb5int32(p, len, (data)->usec, &l);
9711 0 : if (e) return e;
9712 0 : p -= l; len -= l; ret += l;
9713 :
9714 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
9715 0 : if (e) return e;
9716 0 : p -= l; len -= l; ret += l;
9717 :
9718 0 : ret += Top_tag_oldret;
9719 : }
9720 : /* timestamp */
9721 0 : if((data)->timestamp) {
9722 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
9723 0 : ret = 0;
9724 0 : e = encode_KerberosTime(p, len, (data)->timestamp, &l);
9725 0 : if (e) return e;
9726 0 : p -= l; len -= l; ret += l;
9727 :
9728 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
9729 0 : if (e) return e;
9730 0 : p -= l; len -= l; ret += l;
9731 :
9732 0 : ret += Top_tag_oldret;
9733 : }
9734 : /* user-data */
9735 : {
9736 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
9737 0 : ret = 0;
9738 0 : e = der_put_octet_string(p, len, &(data)->user_data, &l);
9739 0 : if (e) return e;
9740 0 : p -= l; len -= l; ret += l;
9741 :
9742 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
9743 0 : if (e) return e;
9744 0 : p -= l; len -= l; ret += l;
9745 :
9746 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
9747 0 : if (e) return e;
9748 0 : p -= l; len -= l; ret += l;
9749 :
9750 0 : ret += Top_tag_oldret;
9751 : }
9752 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
9753 0 : if (e) return e;
9754 0 : p -= l; len -= l; ret += l;
9755 :
9756 0 : *size = ret;
9757 0 : return 0;
9758 : }
9759 :
9760 : int ASN1CALL
9761 0 : decode_KRB_SAFE_BODY(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, KRB_SAFE_BODY *data, size_t *size)
9762 : {
9763 0 : size_t ret = 0;
9764 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
9765 : int e HEIMDAL_UNUSED_ATTRIBUTE;
9766 :
9767 0 : memset(data, 0, sizeof(*data));
9768 : {
9769 : size_t Top_datalen, Top_oldlen;
9770 : Der_type Top_type;
9771 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
9772 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
9773 0 : if(e) goto fail;
9774 0 : p += l; len -= l; ret += l;
9775 0 : Top_oldlen = len;
9776 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9777 0 : len = Top_datalen;
9778 : {
9779 : size_t user_data_datalen, user_data_oldlen;
9780 : Der_type user_data_type;
9781 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &user_data_type, 0, &user_data_datalen, &l);
9782 0 : if (e == 0 && user_data_type != CONS) { e = ASN1_BAD_ID; }
9783 0 : if(e) goto fail;
9784 0 : p += l; len -= l; ret += l;
9785 0 : user_data_oldlen = len;
9786 0 : if (user_data_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9787 0 : len = user_data_datalen;
9788 : {
9789 : size_t user_data_Tag_datalen, user_data_Tag_oldlen;
9790 : Der_type user_data_Tag_type;
9791 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &user_data_Tag_type, UT_OctetString, &user_data_Tag_datalen, &l);
9792 0 : if (e == 0 && user_data_Tag_type != PRIM) { e = ASN1_BAD_ID; }
9793 0 : if(e) goto fail;
9794 0 : p += l; len -= l; ret += l;
9795 0 : user_data_Tag_oldlen = len;
9796 0 : if (user_data_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9797 0 : len = user_data_Tag_datalen;
9798 0 : e = der_get_octet_string(p, len, &(data)->user_data, &l);
9799 0 : if(e) goto fail;
9800 0 : p += l; len -= l; ret += l;
9801 0 : len = user_data_Tag_oldlen - user_data_Tag_datalen;
9802 : }
9803 0 : len = user_data_oldlen - user_data_datalen;
9804 : }
9805 : {
9806 : size_t timestamp_datalen, timestamp_oldlen;
9807 : Der_type timestamp_type;
9808 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, ×tamp_type, 1, ×tamp_datalen, &l);
9809 0 : if (e == 0 && timestamp_type != CONS) { e = ASN1_BAD_ID; }
9810 0 : if(e) {
9811 0 : (data)->timestamp = NULL;
9812 : } else {
9813 0 : (data)->timestamp = calloc(1, sizeof(*(data)->timestamp));
9814 0 : if ((data)->timestamp == NULL) { e = ENOMEM; goto fail; }
9815 0 : p += l; len -= l; ret += l;
9816 0 : timestamp_oldlen = len;
9817 0 : if (timestamp_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9818 0 : len = timestamp_datalen;
9819 0 : e = decode_KerberosTime(p, len, (data)->timestamp, &l);
9820 0 : if(e) goto fail;
9821 0 : p += l; len -= l; ret += l;
9822 0 : len = timestamp_oldlen - timestamp_datalen;
9823 : }
9824 : }
9825 : {
9826 : size_t usec_datalen, usec_oldlen;
9827 : Der_type usec_type;
9828 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &usec_type, 2, &usec_datalen, &l);
9829 0 : if (e == 0 && usec_type != CONS) { e = ASN1_BAD_ID; }
9830 0 : if(e) {
9831 0 : (data)->usec = NULL;
9832 : } else {
9833 0 : (data)->usec = calloc(1, sizeof(*(data)->usec));
9834 0 : if ((data)->usec == NULL) { e = ENOMEM; goto fail; }
9835 0 : p += l; len -= l; ret += l;
9836 0 : usec_oldlen = len;
9837 0 : if (usec_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9838 0 : len = usec_datalen;
9839 0 : e = decode_krb5int32(p, len, (data)->usec, &l);
9840 0 : if(e) goto fail;
9841 0 : p += l; len -= l; ret += l;
9842 0 : len = usec_oldlen - usec_datalen;
9843 : }
9844 : }
9845 : {
9846 : size_t seq_number_datalen, seq_number_oldlen;
9847 : Der_type seq_number_type;
9848 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &seq_number_type, 3, &seq_number_datalen, &l);
9849 0 : if (e == 0 && seq_number_type != CONS) { e = ASN1_BAD_ID; }
9850 0 : if(e) {
9851 0 : (data)->seq_number = NULL;
9852 : } else {
9853 0 : (data)->seq_number = calloc(1, sizeof(*(data)->seq_number));
9854 0 : if ((data)->seq_number == NULL) { e = ENOMEM; goto fail; }
9855 0 : p += l; len -= l; ret += l;
9856 0 : seq_number_oldlen = len;
9857 0 : if (seq_number_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9858 0 : len = seq_number_datalen;
9859 0 : e = decode_krb5uint32(p, len, (data)->seq_number, &l);
9860 0 : if(e) goto fail;
9861 0 : p += l; len -= l; ret += l;
9862 0 : len = seq_number_oldlen - seq_number_datalen;
9863 : }
9864 : }
9865 : {
9866 : size_t s_address_datalen, s_address_oldlen;
9867 : Der_type s_address_type;
9868 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &s_address_type, 4, &s_address_datalen, &l);
9869 0 : if (e == 0 && s_address_type != CONS) { e = ASN1_BAD_ID; }
9870 0 : if(e) {
9871 0 : (data)->s_address = NULL;
9872 : } else {
9873 0 : (data)->s_address = calloc(1, sizeof(*(data)->s_address));
9874 0 : if ((data)->s_address == NULL) { e = ENOMEM; goto fail; }
9875 0 : p += l; len -= l; ret += l;
9876 0 : s_address_oldlen = len;
9877 0 : if (s_address_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9878 0 : len = s_address_datalen;
9879 0 : e = decode_HostAddress(p, len, (data)->s_address, &l);
9880 0 : if(e) goto fail;
9881 0 : p += l; len -= l; ret += l;
9882 0 : len = s_address_oldlen - s_address_datalen;
9883 : }
9884 : }
9885 : {
9886 : size_t r_address_datalen, r_address_oldlen;
9887 : Der_type r_address_type;
9888 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &r_address_type, 5, &r_address_datalen, &l);
9889 0 : if (e == 0 && r_address_type != CONS) { e = ASN1_BAD_ID; }
9890 0 : if(e) {
9891 0 : (data)->r_address = NULL;
9892 : } else {
9893 0 : (data)->r_address = calloc(1, sizeof(*(data)->r_address));
9894 0 : if ((data)->r_address == NULL) { e = ENOMEM; goto fail; }
9895 0 : p += l; len -= l; ret += l;
9896 0 : r_address_oldlen = len;
9897 0 : if (r_address_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9898 0 : len = r_address_datalen;
9899 0 : e = decode_HostAddress(p, len, (data)->r_address, &l);
9900 0 : if(e) goto fail;
9901 0 : p += l; len -= l; ret += l;
9902 0 : len = r_address_oldlen - r_address_datalen;
9903 : }
9904 : }
9905 0 : len = Top_oldlen - Top_datalen;
9906 : }
9907 0 : if(size) *size = ret;
9908 0 : return 0;
9909 0 : fail:
9910 0 : free_KRB_SAFE_BODY(data);
9911 0 : return e;
9912 : }
9913 :
9914 : void ASN1CALL
9915 0 : free_KRB_SAFE_BODY(KRB_SAFE_BODY *data)
9916 : {
9917 0 : der_free_octet_string(&(data)->user_data);
9918 0 : if((data)->timestamp) {
9919 0 : free_KerberosTime((data)->timestamp);
9920 0 : free((data)->timestamp);
9921 0 : (data)->timestamp = NULL;
9922 : }
9923 0 : if((data)->usec) {
9924 0 : free_krb5int32((data)->usec);
9925 0 : free((data)->usec);
9926 0 : (data)->usec = NULL;
9927 : }
9928 0 : if((data)->seq_number) {
9929 0 : free_krb5uint32((data)->seq_number);
9930 0 : free((data)->seq_number);
9931 0 : (data)->seq_number = NULL;
9932 : }
9933 0 : if((data)->s_address) {
9934 0 : free_HostAddress((data)->s_address);
9935 0 : free((data)->s_address);
9936 0 : (data)->s_address = NULL;
9937 : }
9938 0 : if((data)->r_address) {
9939 0 : free_HostAddress((data)->r_address);
9940 0 : free((data)->r_address);
9941 0 : (data)->r_address = NULL;
9942 : }
9943 0 : }
9944 :
9945 : size_t ASN1CALL
9946 0 : length_KRB_SAFE_BODY(const KRB_SAFE_BODY *data)
9947 : {
9948 0 : size_t ret = 0;
9949 : {
9950 0 : size_t Top_tag_oldret = ret;
9951 0 : ret = 0;
9952 0 : ret += der_length_octet_string(&(data)->user_data);
9953 0 : ret += 1 + der_length_len (ret);
9954 0 : ret += 1 + der_length_len (ret);
9955 0 : ret += Top_tag_oldret;
9956 : }
9957 0 : if((data)->timestamp){
9958 0 : size_t Top_tag_oldret = ret;
9959 0 : ret = 0;
9960 0 : ret += length_KerberosTime((data)->timestamp);
9961 0 : ret += 1 + der_length_len (ret);
9962 0 : ret += Top_tag_oldret;
9963 : }
9964 0 : if((data)->usec){
9965 0 : size_t Top_tag_oldret = ret;
9966 0 : ret = 0;
9967 0 : ret += length_krb5int32((data)->usec);
9968 0 : ret += 1 + der_length_len (ret);
9969 0 : ret += Top_tag_oldret;
9970 : }
9971 0 : if((data)->seq_number){
9972 0 : size_t Top_tag_oldret = ret;
9973 0 : ret = 0;
9974 0 : ret += length_krb5uint32((data)->seq_number);
9975 0 : ret += 1 + der_length_len (ret);
9976 0 : ret += Top_tag_oldret;
9977 : }
9978 0 : if((data)->s_address){
9979 0 : size_t Top_tag_oldret = ret;
9980 0 : ret = 0;
9981 0 : ret += length_HostAddress((data)->s_address);
9982 0 : ret += 1 + der_length_len (ret);
9983 0 : ret += Top_tag_oldret;
9984 : }
9985 0 : if((data)->r_address){
9986 0 : size_t Top_tag_oldret = ret;
9987 0 : ret = 0;
9988 0 : ret += length_HostAddress((data)->r_address);
9989 0 : ret += 1 + der_length_len (ret);
9990 0 : ret += Top_tag_oldret;
9991 : }
9992 0 : ret += 1 + der_length_len (ret);
9993 0 : return ret;
9994 : }
9995 :
9996 : int ASN1CALL
9997 0 : copy_KRB_SAFE_BODY(const KRB_SAFE_BODY *from, KRB_SAFE_BODY *to)
9998 : {
9999 0 : memset(to, 0, sizeof(*to));
10000 0 : if(der_copy_octet_string(&(from)->user_data, &(to)->user_data)) goto fail;
10001 0 : if((from)->timestamp) {
10002 0 : (to)->timestamp = malloc(sizeof(*(to)->timestamp));
10003 0 : if((to)->timestamp == NULL) goto fail;
10004 0 : if(copy_KerberosTime((from)->timestamp, (to)->timestamp)) goto fail;
10005 : }else
10006 0 : (to)->timestamp = NULL;
10007 0 : if((from)->usec) {
10008 0 : (to)->usec = malloc(sizeof(*(to)->usec));
10009 0 : if((to)->usec == NULL) goto fail;
10010 0 : if(copy_krb5int32((from)->usec, (to)->usec)) goto fail;
10011 : }else
10012 0 : (to)->usec = NULL;
10013 0 : if((from)->seq_number) {
10014 0 : (to)->seq_number = malloc(sizeof(*(to)->seq_number));
10015 0 : if((to)->seq_number == NULL) goto fail;
10016 0 : if(copy_krb5uint32((from)->seq_number, (to)->seq_number)) goto fail;
10017 : }else
10018 0 : (to)->seq_number = NULL;
10019 0 : if((from)->s_address) {
10020 0 : (to)->s_address = malloc(sizeof(*(to)->s_address));
10021 0 : if((to)->s_address == NULL) goto fail;
10022 0 : if(copy_HostAddress((from)->s_address, (to)->s_address)) goto fail;
10023 : }else
10024 0 : (to)->s_address = NULL;
10025 0 : if((from)->r_address) {
10026 0 : (to)->r_address = malloc(sizeof(*(to)->r_address));
10027 0 : if((to)->r_address == NULL) goto fail;
10028 0 : if(copy_HostAddress((from)->r_address, (to)->r_address)) goto fail;
10029 : }else
10030 0 : (to)->r_address = NULL;
10031 0 : return 0;
10032 0 : fail:
10033 0 : free_KRB_SAFE_BODY(to);
10034 0 : return ENOMEM;
10035 : }
10036 :
10037 : int ASN1CALL
10038 0 : encode_KRB_SAFE(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const KRB_SAFE *data, size_t *size)
10039 : {
10040 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
10041 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
10042 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
10043 :
10044 : /* cksum */
10045 : {
10046 0 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
10047 0 : ret = 0;
10048 0 : e = encode_Checksum(p, len, &(data)->cksum, &l);
10049 0 : if (e) return e;
10050 0 : p -= l; len -= l; ret += l;
10051 :
10052 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
10053 0 : if (e) return e;
10054 0 : p -= l; len -= l; ret += l;
10055 :
10056 0 : ret += Top_tag_tag_oldret;
10057 : }
10058 : /* safe-body */
10059 : {
10060 0 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
10061 0 : ret = 0;
10062 0 : e = encode_KRB_SAFE_BODY(p, len, &(data)->safe_body, &l);
10063 0 : if (e) return e;
10064 0 : p -= l; len -= l; ret += l;
10065 :
10066 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
10067 0 : if (e) return e;
10068 0 : p -= l; len -= l; ret += l;
10069 :
10070 0 : ret += Top_tag_tag_oldret;
10071 : }
10072 : /* msg-type */
10073 : {
10074 0 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
10075 0 : ret = 0;
10076 0 : e = encode_MESSAGE_TYPE(p, len, &(data)->msg_type, &l);
10077 0 : if (e) return e;
10078 0 : p -= l; len -= l; ret += l;
10079 :
10080 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
10081 0 : if (e) return e;
10082 0 : p -= l; len -= l; ret += l;
10083 :
10084 0 : ret += Top_tag_tag_oldret;
10085 : }
10086 : /* pvno */
10087 : {
10088 0 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
10089 0 : ret = 0;
10090 0 : e = encode_krb5int32(p, len, &(data)->pvno, &l);
10091 0 : if (e) return e;
10092 0 : p -= l; len -= l; ret += l;
10093 :
10094 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
10095 0 : if (e) return e;
10096 0 : p -= l; len -= l; ret += l;
10097 :
10098 0 : ret += Top_tag_tag_oldret;
10099 : }
10100 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
10101 0 : if (e) return e;
10102 0 : p -= l; len -= l; ret += l;
10103 :
10104 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_APPL, CONS, 20, &l);
10105 0 : if (e) return e;
10106 0 : p -= l; len -= l; ret += l;
10107 :
10108 0 : *size = ret;
10109 0 : return 0;
10110 : }
10111 :
10112 : int ASN1CALL
10113 0 : decode_KRB_SAFE(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, KRB_SAFE *data, size_t *size)
10114 : {
10115 0 : size_t ret = 0;
10116 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
10117 : int e HEIMDAL_UNUSED_ATTRIBUTE;
10118 :
10119 0 : memset(data, 0, sizeof(*data));
10120 : {
10121 : size_t Top_datalen, Top_oldlen;
10122 : Der_type Top_type;
10123 0 : e = der_match_tag_and_length(p, len, ASN1_C_APPL, &Top_type, 20, &Top_datalen, &l);
10124 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
10125 0 : if(e) goto fail;
10126 0 : p += l; len -= l; ret += l;
10127 0 : Top_oldlen = len;
10128 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
10129 0 : len = Top_datalen;
10130 : {
10131 : size_t Top_Tag_datalen, Top_Tag_oldlen;
10132 : Der_type Top_Tag_type;
10133 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_Tag_type, UT_Sequence, &Top_Tag_datalen, &l);
10134 0 : if (e == 0 && Top_Tag_type != CONS) { e = ASN1_BAD_ID; }
10135 0 : if(e) goto fail;
10136 0 : p += l; len -= l; ret += l;
10137 0 : Top_Tag_oldlen = len;
10138 0 : if (Top_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
10139 0 : len = Top_Tag_datalen;
10140 : {
10141 : size_t pvno_datalen, pvno_oldlen;
10142 : Der_type pvno_type;
10143 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &pvno_type, 0, &pvno_datalen, &l);
10144 0 : if (e == 0 && pvno_type != CONS) { e = ASN1_BAD_ID; }
10145 0 : if(e) goto fail;
10146 0 : p += l; len -= l; ret += l;
10147 0 : pvno_oldlen = len;
10148 0 : if (pvno_datalen > len) { e = ASN1_OVERRUN; goto fail; }
10149 0 : len = pvno_datalen;
10150 0 : e = decode_krb5int32(p, len, &(data)->pvno, &l);
10151 0 : if(e) goto fail;
10152 0 : p += l; len -= l; ret += l;
10153 0 : len = pvno_oldlen - pvno_datalen;
10154 : }
10155 : {
10156 : size_t msg_type_datalen, msg_type_oldlen;
10157 : Der_type msg_type_type;
10158 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &msg_type_type, 1, &msg_type_datalen, &l);
10159 0 : if (e == 0 && msg_type_type != CONS) { e = ASN1_BAD_ID; }
10160 0 : if(e) goto fail;
10161 0 : p += l; len -= l; ret += l;
10162 0 : msg_type_oldlen = len;
10163 0 : if (msg_type_datalen > len) { e = ASN1_OVERRUN; goto fail; }
10164 0 : len = msg_type_datalen;
10165 0 : e = decode_MESSAGE_TYPE(p, len, &(data)->msg_type, &l);
10166 0 : if(e) goto fail;
10167 0 : p += l; len -= l; ret += l;
10168 0 : len = msg_type_oldlen - msg_type_datalen;
10169 : }
10170 : {
10171 : size_t safe_body_datalen, safe_body_oldlen;
10172 : Der_type safe_body_type;
10173 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &safe_body_type, 2, &safe_body_datalen, &l);
10174 0 : if (e == 0 && safe_body_type != CONS) { e = ASN1_BAD_ID; }
10175 0 : if(e) goto fail;
10176 0 : p += l; len -= l; ret += l;
10177 0 : safe_body_oldlen = len;
10178 0 : if (safe_body_datalen > len) { e = ASN1_OVERRUN; goto fail; }
10179 0 : len = safe_body_datalen;
10180 0 : e = decode_KRB_SAFE_BODY(p, len, &(data)->safe_body, &l);
10181 0 : if(e) goto fail;
10182 0 : p += l; len -= l; ret += l;
10183 0 : len = safe_body_oldlen - safe_body_datalen;
10184 : }
10185 : {
10186 : size_t cksum_datalen, cksum_oldlen;
10187 : Der_type cksum_type;
10188 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &cksum_type, 3, &cksum_datalen, &l);
10189 0 : if (e == 0 && cksum_type != CONS) { e = ASN1_BAD_ID; }
10190 0 : if(e) goto fail;
10191 0 : p += l; len -= l; ret += l;
10192 0 : cksum_oldlen = len;
10193 0 : if (cksum_datalen > len) { e = ASN1_OVERRUN; goto fail; }
10194 0 : len = cksum_datalen;
10195 0 : e = decode_Checksum(p, len, &(data)->cksum, &l);
10196 0 : if(e) goto fail;
10197 0 : p += l; len -= l; ret += l;
10198 0 : len = cksum_oldlen - cksum_datalen;
10199 : }
10200 0 : len = Top_Tag_oldlen - Top_Tag_datalen;
10201 : }
10202 0 : len = Top_oldlen - Top_datalen;
10203 : }
10204 0 : if(size) *size = ret;
10205 0 : return 0;
10206 0 : fail:
10207 0 : free_KRB_SAFE(data);
10208 0 : return e;
10209 : }
10210 :
10211 : void ASN1CALL
10212 0 : free_KRB_SAFE(KRB_SAFE *data)
10213 : {
10214 0 : free_krb5int32(&(data)->pvno);
10215 0 : free_MESSAGE_TYPE(&(data)->msg_type);
10216 0 : free_KRB_SAFE_BODY(&(data)->safe_body);
10217 0 : free_Checksum(&(data)->cksum);
10218 0 : }
10219 :
10220 : size_t ASN1CALL
10221 0 : length_KRB_SAFE(const KRB_SAFE *data)
10222 : {
10223 0 : size_t ret = 0;
10224 : {
10225 0 : size_t Top_tag_tag_oldret = ret;
10226 0 : ret = 0;
10227 0 : ret += length_krb5int32(&(data)->pvno);
10228 0 : ret += 1 + der_length_len (ret);
10229 0 : ret += Top_tag_tag_oldret;
10230 : }
10231 : {
10232 0 : size_t Top_tag_tag_oldret = ret;
10233 0 : ret = 0;
10234 0 : ret += length_MESSAGE_TYPE(&(data)->msg_type);
10235 0 : ret += 1 + der_length_len (ret);
10236 0 : ret += Top_tag_tag_oldret;
10237 : }
10238 : {
10239 0 : size_t Top_tag_tag_oldret = ret;
10240 0 : ret = 0;
10241 0 : ret += length_KRB_SAFE_BODY(&(data)->safe_body);
10242 0 : ret += 1 + der_length_len (ret);
10243 0 : ret += Top_tag_tag_oldret;
10244 : }
10245 : {
10246 0 : size_t Top_tag_tag_oldret = ret;
10247 0 : ret = 0;
10248 0 : ret += length_Checksum(&(data)->cksum);
10249 0 : ret += 1 + der_length_len (ret);
10250 0 : ret += Top_tag_tag_oldret;
10251 : }
10252 0 : ret += 1 + der_length_len (ret);
10253 0 : ret += 1 + der_length_len (ret);
10254 0 : return ret;
10255 : }
10256 :
10257 : int ASN1CALL
10258 0 : copy_KRB_SAFE(const KRB_SAFE *from, KRB_SAFE *to)
10259 : {
10260 0 : memset(to, 0, sizeof(*to));
10261 0 : if(copy_krb5int32(&(from)->pvno, &(to)->pvno)) goto fail;
10262 0 : if(copy_MESSAGE_TYPE(&(from)->msg_type, &(to)->msg_type)) goto fail;
10263 0 : if(copy_KRB_SAFE_BODY(&(from)->safe_body, &(to)->safe_body)) goto fail;
10264 0 : if(copy_Checksum(&(from)->cksum, &(to)->cksum)) goto fail;
10265 0 : return 0;
10266 0 : fail:
10267 0 : free_KRB_SAFE(to);
10268 0 : return ENOMEM;
10269 : }
10270 :
10271 : int ASN1CALL
10272 68 : encode_KRB_PRIV(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const KRB_PRIV *data, size_t *size)
10273 : {
10274 68 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
10275 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
10276 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
10277 :
10278 : /* enc-part */
10279 : {
10280 68 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
10281 68 : ret = 0;
10282 68 : e = encode_EncryptedData(p, len, &(data)->enc_part, &l);
10283 68 : if (e) return e;
10284 68 : p -= l; len -= l; ret += l;
10285 :
10286 68 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
10287 68 : if (e) return e;
10288 68 : p -= l; len -= l; ret += l;
10289 :
10290 68 : ret += Top_tag_tag_oldret;
10291 : }
10292 : /* msg-type */
10293 : {
10294 68 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
10295 68 : ret = 0;
10296 68 : e = encode_MESSAGE_TYPE(p, len, &(data)->msg_type, &l);
10297 68 : if (e) return e;
10298 68 : p -= l; len -= l; ret += l;
10299 :
10300 68 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
10301 68 : if (e) return e;
10302 68 : p -= l; len -= l; ret += l;
10303 :
10304 68 : ret += Top_tag_tag_oldret;
10305 : }
10306 : /* pvno */
10307 : {
10308 68 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
10309 68 : ret = 0;
10310 68 : e = encode_krb5int32(p, len, &(data)->pvno, &l);
10311 68 : if (e) return e;
10312 68 : p -= l; len -= l; ret += l;
10313 :
10314 68 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
10315 68 : if (e) return e;
10316 68 : p -= l; len -= l; ret += l;
10317 :
10318 68 : ret += Top_tag_tag_oldret;
10319 : }
10320 68 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
10321 68 : if (e) return e;
10322 68 : p -= l; len -= l; ret += l;
10323 :
10324 68 : e = der_put_length_and_tag (p, len, ret, ASN1_C_APPL, CONS, 21, &l);
10325 68 : if (e) return e;
10326 68 : p -= l; len -= l; ret += l;
10327 :
10328 68 : *size = ret;
10329 68 : return 0;
10330 : }
10331 :
10332 : int ASN1CALL
10333 68 : decode_KRB_PRIV(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, KRB_PRIV *data, size_t *size)
10334 : {
10335 68 : size_t ret = 0;
10336 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
10337 : int e HEIMDAL_UNUSED_ATTRIBUTE;
10338 :
10339 68 : memset(data, 0, sizeof(*data));
10340 : {
10341 : size_t Top_datalen, Top_oldlen;
10342 : Der_type Top_type;
10343 68 : e = der_match_tag_and_length(p, len, ASN1_C_APPL, &Top_type, 21, &Top_datalen, &l);
10344 68 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
10345 68 : if(e) goto fail;
10346 68 : p += l; len -= l; ret += l;
10347 68 : Top_oldlen = len;
10348 68 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
10349 68 : len = Top_datalen;
10350 : {
10351 : size_t Top_Tag_datalen, Top_Tag_oldlen;
10352 : Der_type Top_Tag_type;
10353 68 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_Tag_type, UT_Sequence, &Top_Tag_datalen, &l);
10354 68 : if (e == 0 && Top_Tag_type != CONS) { e = ASN1_BAD_ID; }
10355 68 : if(e) goto fail;
10356 68 : p += l; len -= l; ret += l;
10357 68 : Top_Tag_oldlen = len;
10358 68 : if (Top_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
10359 68 : len = Top_Tag_datalen;
10360 : {
10361 : size_t pvno_datalen, pvno_oldlen;
10362 : Der_type pvno_type;
10363 68 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &pvno_type, 0, &pvno_datalen, &l);
10364 68 : if (e == 0 && pvno_type != CONS) { e = ASN1_BAD_ID; }
10365 68 : if(e) goto fail;
10366 68 : p += l; len -= l; ret += l;
10367 68 : pvno_oldlen = len;
10368 68 : if (pvno_datalen > len) { e = ASN1_OVERRUN; goto fail; }
10369 68 : len = pvno_datalen;
10370 68 : e = decode_krb5int32(p, len, &(data)->pvno, &l);
10371 68 : if(e) goto fail;
10372 68 : p += l; len -= l; ret += l;
10373 68 : len = pvno_oldlen - pvno_datalen;
10374 : }
10375 : {
10376 : size_t msg_type_datalen, msg_type_oldlen;
10377 : Der_type msg_type_type;
10378 68 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &msg_type_type, 1, &msg_type_datalen, &l);
10379 136 : if (e == 0 && msg_type_type != CONS) { e = ASN1_BAD_ID; }
10380 68 : if(e) goto fail;
10381 68 : p += l; len -= l; ret += l;
10382 68 : msg_type_oldlen = len;
10383 68 : if (msg_type_datalen > len) { e = ASN1_OVERRUN; goto fail; }
10384 68 : len = msg_type_datalen;
10385 68 : e = decode_MESSAGE_TYPE(p, len, &(data)->msg_type, &l);
10386 68 : if(e) goto fail;
10387 68 : p += l; len -= l; ret += l;
10388 68 : len = msg_type_oldlen - msg_type_datalen;
10389 : }
10390 : {
10391 : size_t enc_part_datalen, enc_part_oldlen;
10392 : Der_type enc_part_type;
10393 68 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &enc_part_type, 3, &enc_part_datalen, &l);
10394 136 : if (e == 0 && enc_part_type != CONS) { e = ASN1_BAD_ID; }
10395 68 : if(e) goto fail;
10396 68 : p += l; len -= l; ret += l;
10397 68 : enc_part_oldlen = len;
10398 68 : if (enc_part_datalen > len) { e = ASN1_OVERRUN; goto fail; }
10399 68 : len = enc_part_datalen;
10400 68 : e = decode_EncryptedData(p, len, &(data)->enc_part, &l);
10401 68 : if(e) goto fail;
10402 68 : p += l; len -= l; ret += l;
10403 68 : len = enc_part_oldlen - enc_part_datalen;
10404 : }
10405 68 : len = Top_Tag_oldlen - Top_Tag_datalen;
10406 : }
10407 68 : len = Top_oldlen - Top_datalen;
10408 : }
10409 136 : if(size) *size = ret;
10410 68 : return 0;
10411 0 : fail:
10412 0 : free_KRB_PRIV(data);
10413 0 : return e;
10414 : }
10415 :
10416 : void ASN1CALL
10417 68 : free_KRB_PRIV(KRB_PRIV *data)
10418 : {
10419 68 : free_krb5int32(&(data)->pvno);
10420 68 : free_MESSAGE_TYPE(&(data)->msg_type);
10421 68 : free_EncryptedData(&(data)->enc_part);
10422 68 : }
10423 :
10424 : size_t ASN1CALL
10425 68 : length_KRB_PRIV(const KRB_PRIV *data)
10426 : {
10427 68 : size_t ret = 0;
10428 : {
10429 68 : size_t Top_tag_tag_oldret = ret;
10430 68 : ret = 0;
10431 68 : ret += length_krb5int32(&(data)->pvno);
10432 68 : ret += 1 + der_length_len (ret);
10433 68 : ret += Top_tag_tag_oldret;
10434 : }
10435 : {
10436 68 : size_t Top_tag_tag_oldret = ret;
10437 68 : ret = 0;
10438 68 : ret += length_MESSAGE_TYPE(&(data)->msg_type);
10439 68 : ret += 1 + der_length_len (ret);
10440 68 : ret += Top_tag_tag_oldret;
10441 : }
10442 : {
10443 68 : size_t Top_tag_tag_oldret = ret;
10444 68 : ret = 0;
10445 68 : ret += length_EncryptedData(&(data)->enc_part);
10446 68 : ret += 1 + der_length_len (ret);
10447 68 : ret += Top_tag_tag_oldret;
10448 : }
10449 68 : ret += 1 + der_length_len (ret);
10450 68 : ret += 1 + der_length_len (ret);
10451 68 : return ret;
10452 : }
10453 :
10454 : int ASN1CALL
10455 0 : copy_KRB_PRIV(const KRB_PRIV *from, KRB_PRIV *to)
10456 : {
10457 0 : memset(to, 0, sizeof(*to));
10458 0 : if(copy_krb5int32(&(from)->pvno, &(to)->pvno)) goto fail;
10459 0 : if(copy_MESSAGE_TYPE(&(from)->msg_type, &(to)->msg_type)) goto fail;
10460 0 : if(copy_EncryptedData(&(from)->enc_part, &(to)->enc_part)) goto fail;
10461 0 : return 0;
10462 0 : fail:
10463 0 : free_KRB_PRIV(to);
10464 0 : return ENOMEM;
10465 : }
10466 :
10467 : int ASN1CALL
10468 68 : encode_EncKrbPrivPart(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const EncKrbPrivPart *data, size_t *size)
10469 : {
10470 68 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
10471 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
10472 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
10473 :
10474 : /* r-address */
10475 68 : if((data)->r_address) {
10476 0 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
10477 0 : ret = 0;
10478 0 : e = encode_HostAddress(p, len, (data)->r_address, &l);
10479 0 : if (e) return e;
10480 0 : p -= l; len -= l; ret += l;
10481 :
10482 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 5, &l);
10483 0 : if (e) return e;
10484 0 : p -= l; len -= l; ret += l;
10485 :
10486 0 : ret += Top_tag_tag_oldret;
10487 : }
10488 : /* s-address */
10489 68 : if((data)->s_address) {
10490 68 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
10491 68 : ret = 0;
10492 68 : e = encode_HostAddress(p, len, (data)->s_address, &l);
10493 68 : if (e) return e;
10494 68 : p -= l; len -= l; ret += l;
10495 :
10496 68 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 4, &l);
10497 68 : if (e) return e;
10498 68 : p -= l; len -= l; ret += l;
10499 :
10500 68 : ret += Top_tag_tag_oldret;
10501 : }
10502 : /* seq-number */
10503 68 : if((data)->seq_number) {
10504 68 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
10505 68 : ret = 0;
10506 68 : e = encode_krb5uint32(p, len, (data)->seq_number, &l);
10507 68 : if (e) return e;
10508 68 : p -= l; len -= l; ret += l;
10509 :
10510 68 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
10511 68 : if (e) return e;
10512 68 : p -= l; len -= l; ret += l;
10513 :
10514 68 : ret += Top_tag_tag_oldret;
10515 : }
10516 : /* usec */
10517 68 : if((data)->usec) {
10518 0 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
10519 0 : ret = 0;
10520 0 : e = encode_krb5int32(p, len, (data)->usec, &l);
10521 0 : if (e) return e;
10522 0 : p -= l; len -= l; ret += l;
10523 :
10524 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
10525 0 : if (e) return e;
10526 0 : p -= l; len -= l; ret += l;
10527 :
10528 0 : ret += Top_tag_tag_oldret;
10529 : }
10530 : /* timestamp */
10531 68 : if((data)->timestamp) {
10532 0 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
10533 0 : ret = 0;
10534 0 : e = encode_KerberosTime(p, len, (data)->timestamp, &l);
10535 0 : if (e) return e;
10536 0 : p -= l; len -= l; ret += l;
10537 :
10538 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
10539 0 : if (e) return e;
10540 0 : p -= l; len -= l; ret += l;
10541 :
10542 0 : ret += Top_tag_tag_oldret;
10543 : }
10544 : /* user-data */
10545 : {
10546 68 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
10547 68 : ret = 0;
10548 68 : e = der_put_octet_string(p, len, &(data)->user_data, &l);
10549 68 : if (e) return e;
10550 68 : p -= l; len -= l; ret += l;
10551 :
10552 68 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
10553 68 : if (e) return e;
10554 68 : p -= l; len -= l; ret += l;
10555 :
10556 68 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
10557 68 : if (e) return e;
10558 68 : p -= l; len -= l; ret += l;
10559 :
10560 68 : ret += Top_tag_tag_oldret;
10561 : }
10562 68 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
10563 68 : if (e) return e;
10564 68 : p -= l; len -= l; ret += l;
10565 :
10566 68 : e = der_put_length_and_tag (p, len, ret, ASN1_C_APPL, CONS, 28, &l);
10567 68 : if (e) return e;
10568 68 : p -= l; len -= l; ret += l;
10569 :
10570 68 : *size = ret;
10571 68 : return 0;
10572 : }
10573 :
10574 : int ASN1CALL
10575 68 : decode_EncKrbPrivPart(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, EncKrbPrivPart *data, size_t *size)
10576 : {
10577 68 : size_t ret = 0;
10578 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
10579 : int e HEIMDAL_UNUSED_ATTRIBUTE;
10580 :
10581 68 : memset(data, 0, sizeof(*data));
10582 : {
10583 : size_t Top_datalen, Top_oldlen;
10584 : Der_type Top_type;
10585 68 : e = der_match_tag_and_length(p, len, ASN1_C_APPL, &Top_type, 28, &Top_datalen, &l);
10586 68 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
10587 68 : if(e) goto fail;
10588 68 : p += l; len -= l; ret += l;
10589 68 : Top_oldlen = len;
10590 68 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
10591 68 : len = Top_datalen;
10592 : {
10593 : size_t Top_Tag_datalen, Top_Tag_oldlen;
10594 : Der_type Top_Tag_type;
10595 68 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_Tag_type, UT_Sequence, &Top_Tag_datalen, &l);
10596 68 : if (e == 0 && Top_Tag_type != CONS) { e = ASN1_BAD_ID; }
10597 68 : if(e) goto fail;
10598 68 : p += l; len -= l; ret += l;
10599 68 : Top_Tag_oldlen = len;
10600 68 : if (Top_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
10601 68 : len = Top_Tag_datalen;
10602 : {
10603 : size_t user_data_datalen, user_data_oldlen;
10604 : Der_type user_data_type;
10605 68 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &user_data_type, 0, &user_data_datalen, &l);
10606 68 : if (e == 0 && user_data_type != CONS) { e = ASN1_BAD_ID; }
10607 68 : if(e) goto fail;
10608 68 : p += l; len -= l; ret += l;
10609 68 : user_data_oldlen = len;
10610 68 : if (user_data_datalen > len) { e = ASN1_OVERRUN; goto fail; }
10611 68 : len = user_data_datalen;
10612 : {
10613 : size_t user_data_Tag_datalen, user_data_Tag_oldlen;
10614 : Der_type user_data_Tag_type;
10615 68 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &user_data_Tag_type, UT_OctetString, &user_data_Tag_datalen, &l);
10616 68 : if (e == 0 && user_data_Tag_type != PRIM) { e = ASN1_BAD_ID; }
10617 68 : if(e) goto fail;
10618 68 : p += l; len -= l; ret += l;
10619 68 : user_data_Tag_oldlen = len;
10620 68 : if (user_data_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
10621 68 : len = user_data_Tag_datalen;
10622 68 : e = der_get_octet_string(p, len, &(data)->user_data, &l);
10623 68 : if(e) goto fail;
10624 68 : p += l; len -= l; ret += l;
10625 68 : len = user_data_Tag_oldlen - user_data_Tag_datalen;
10626 : }
10627 68 : len = user_data_oldlen - user_data_datalen;
10628 : }
10629 : {
10630 : size_t timestamp_datalen, timestamp_oldlen;
10631 : Der_type timestamp_type;
10632 68 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, ×tamp_type, 1, ×tamp_datalen, &l);
10633 68 : if (e == 0 && timestamp_type != CONS) { e = ASN1_BAD_ID; }
10634 68 : if(e) {
10635 68 : (data)->timestamp = NULL;
10636 : } else {
10637 0 : (data)->timestamp = calloc(1, sizeof(*(data)->timestamp));
10638 0 : if ((data)->timestamp == NULL) { e = ENOMEM; goto fail; }
10639 0 : p += l; len -= l; ret += l;
10640 0 : timestamp_oldlen = len;
10641 0 : if (timestamp_datalen > len) { e = ASN1_OVERRUN; goto fail; }
10642 0 : len = timestamp_datalen;
10643 0 : e = decode_KerberosTime(p, len, (data)->timestamp, &l);
10644 0 : if(e) goto fail;
10645 0 : p += l; len -= l; ret += l;
10646 0 : len = timestamp_oldlen - timestamp_datalen;
10647 : }
10648 : }
10649 : {
10650 : size_t usec_datalen, usec_oldlen;
10651 : Der_type usec_type;
10652 68 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &usec_type, 2, &usec_datalen, &l);
10653 68 : if (e == 0 && usec_type != CONS) { e = ASN1_BAD_ID; }
10654 68 : if(e) {
10655 68 : (data)->usec = NULL;
10656 : } else {
10657 0 : (data)->usec = calloc(1, sizeof(*(data)->usec));
10658 0 : if ((data)->usec == NULL) { e = ENOMEM; goto fail; }
10659 0 : p += l; len -= l; ret += l;
10660 0 : usec_oldlen = len;
10661 0 : if (usec_datalen > len) { e = ASN1_OVERRUN; goto fail; }
10662 0 : len = usec_datalen;
10663 0 : e = decode_krb5int32(p, len, (data)->usec, &l);
10664 0 : if(e) goto fail;
10665 0 : p += l; len -= l; ret += l;
10666 0 : len = usec_oldlen - usec_datalen;
10667 : }
10668 : }
10669 : {
10670 : size_t seq_number_datalen, seq_number_oldlen;
10671 : Der_type seq_number_type;
10672 68 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &seq_number_type, 3, &seq_number_datalen, &l);
10673 136 : if (e == 0 && seq_number_type != CONS) { e = ASN1_BAD_ID; }
10674 68 : if(e) {
10675 0 : (data)->seq_number = NULL;
10676 : } else {
10677 68 : (data)->seq_number = calloc(1, sizeof(*(data)->seq_number));
10678 68 : if ((data)->seq_number == NULL) { e = ENOMEM; goto fail; }
10679 68 : p += l; len -= l; ret += l;
10680 68 : seq_number_oldlen = len;
10681 68 : if (seq_number_datalen > len) { e = ASN1_OVERRUN; goto fail; }
10682 68 : len = seq_number_datalen;
10683 68 : e = decode_krb5uint32(p, len, (data)->seq_number, &l);
10684 68 : if(e) goto fail;
10685 68 : p += l; len -= l; ret += l;
10686 68 : len = seq_number_oldlen - seq_number_datalen;
10687 : }
10688 : }
10689 : {
10690 : size_t s_address_datalen, s_address_oldlen;
10691 : Der_type s_address_type;
10692 68 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &s_address_type, 4, &s_address_datalen, &l);
10693 136 : if (e == 0 && s_address_type != CONS) { e = ASN1_BAD_ID; }
10694 68 : if(e) {
10695 0 : (data)->s_address = NULL;
10696 : } else {
10697 68 : (data)->s_address = calloc(1, sizeof(*(data)->s_address));
10698 68 : if ((data)->s_address == NULL) { e = ENOMEM; goto fail; }
10699 68 : p += l; len -= l; ret += l;
10700 68 : s_address_oldlen = len;
10701 68 : if (s_address_datalen > len) { e = ASN1_OVERRUN; goto fail; }
10702 68 : len = s_address_datalen;
10703 68 : e = decode_HostAddress(p, len, (data)->s_address, &l);
10704 68 : if(e) goto fail;
10705 68 : p += l; len -= l; ret += l;
10706 68 : len = s_address_oldlen - s_address_datalen;
10707 : }
10708 : }
10709 : {
10710 : size_t r_address_datalen, r_address_oldlen;
10711 : Der_type r_address_type;
10712 68 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &r_address_type, 5, &r_address_datalen, &l);
10713 68 : if (e == 0 && r_address_type != CONS) { e = ASN1_BAD_ID; }
10714 68 : if(e) {
10715 68 : (data)->r_address = NULL;
10716 : } else {
10717 0 : (data)->r_address = calloc(1, sizeof(*(data)->r_address));
10718 0 : if ((data)->r_address == NULL) { e = ENOMEM; goto fail; }
10719 0 : p += l; len -= l; ret += l;
10720 0 : r_address_oldlen = len;
10721 0 : if (r_address_datalen > len) { e = ASN1_OVERRUN; goto fail; }
10722 0 : len = r_address_datalen;
10723 0 : e = decode_HostAddress(p, len, (data)->r_address, &l);
10724 0 : if(e) goto fail;
10725 0 : p += l; len -= l; ret += l;
10726 0 : len = r_address_oldlen - r_address_datalen;
10727 : }
10728 : }
10729 68 : len = Top_Tag_oldlen - Top_Tag_datalen;
10730 : }
10731 68 : len = Top_oldlen - Top_datalen;
10732 : }
10733 136 : if(size) *size = ret;
10734 68 : return 0;
10735 0 : fail:
10736 0 : free_EncKrbPrivPart(data);
10737 0 : return e;
10738 : }
10739 :
10740 : void ASN1CALL
10741 68 : free_EncKrbPrivPart(EncKrbPrivPart *data)
10742 : {
10743 68 : der_free_octet_string(&(data)->user_data);
10744 68 : if((data)->timestamp) {
10745 0 : free_KerberosTime((data)->timestamp);
10746 0 : free((data)->timestamp);
10747 0 : (data)->timestamp = NULL;
10748 : }
10749 68 : if((data)->usec) {
10750 0 : free_krb5int32((data)->usec);
10751 0 : free((data)->usec);
10752 0 : (data)->usec = NULL;
10753 : }
10754 68 : if((data)->seq_number) {
10755 68 : free_krb5uint32((data)->seq_number);
10756 68 : free((data)->seq_number);
10757 68 : (data)->seq_number = NULL;
10758 : }
10759 68 : if((data)->s_address) {
10760 68 : free_HostAddress((data)->s_address);
10761 68 : free((data)->s_address);
10762 68 : (data)->s_address = NULL;
10763 : }
10764 68 : if((data)->r_address) {
10765 0 : free_HostAddress((data)->r_address);
10766 0 : free((data)->r_address);
10767 0 : (data)->r_address = NULL;
10768 : }
10769 68 : }
10770 :
10771 : size_t ASN1CALL
10772 68 : length_EncKrbPrivPart(const EncKrbPrivPart *data)
10773 : {
10774 68 : size_t ret = 0;
10775 : {
10776 68 : size_t Top_tag_tag_oldret = ret;
10777 68 : ret = 0;
10778 68 : ret += der_length_octet_string(&(data)->user_data);
10779 68 : ret += 1 + der_length_len (ret);
10780 68 : ret += 1 + der_length_len (ret);
10781 68 : ret += Top_tag_tag_oldret;
10782 : }
10783 68 : if((data)->timestamp){
10784 0 : size_t Top_tag_tag_oldret = ret;
10785 0 : ret = 0;
10786 0 : ret += length_KerberosTime((data)->timestamp);
10787 0 : ret += 1 + der_length_len (ret);
10788 0 : ret += Top_tag_tag_oldret;
10789 : }
10790 68 : if((data)->usec){
10791 0 : size_t Top_tag_tag_oldret = ret;
10792 0 : ret = 0;
10793 0 : ret += length_krb5int32((data)->usec);
10794 0 : ret += 1 + der_length_len (ret);
10795 0 : ret += Top_tag_tag_oldret;
10796 : }
10797 68 : if((data)->seq_number){
10798 68 : size_t Top_tag_tag_oldret = ret;
10799 68 : ret = 0;
10800 68 : ret += length_krb5uint32((data)->seq_number);
10801 68 : ret += 1 + der_length_len (ret);
10802 68 : ret += Top_tag_tag_oldret;
10803 : }
10804 68 : if((data)->s_address){
10805 68 : size_t Top_tag_tag_oldret = ret;
10806 68 : ret = 0;
10807 68 : ret += length_HostAddress((data)->s_address);
10808 68 : ret += 1 + der_length_len (ret);
10809 68 : ret += Top_tag_tag_oldret;
10810 : }
10811 68 : if((data)->r_address){
10812 0 : size_t Top_tag_tag_oldret = ret;
10813 0 : ret = 0;
10814 0 : ret += length_HostAddress((data)->r_address);
10815 0 : ret += 1 + der_length_len (ret);
10816 0 : ret += Top_tag_tag_oldret;
10817 : }
10818 68 : ret += 1 + der_length_len (ret);
10819 68 : ret += 1 + der_length_len (ret);
10820 68 : return ret;
10821 : }
10822 :
10823 : int ASN1CALL
10824 0 : copy_EncKrbPrivPart(const EncKrbPrivPart *from, EncKrbPrivPart *to)
10825 : {
10826 0 : memset(to, 0, sizeof(*to));
10827 0 : if(der_copy_octet_string(&(from)->user_data, &(to)->user_data)) goto fail;
10828 0 : if((from)->timestamp) {
10829 0 : (to)->timestamp = malloc(sizeof(*(to)->timestamp));
10830 0 : if((to)->timestamp == NULL) goto fail;
10831 0 : if(copy_KerberosTime((from)->timestamp, (to)->timestamp)) goto fail;
10832 : }else
10833 0 : (to)->timestamp = NULL;
10834 0 : if((from)->usec) {
10835 0 : (to)->usec = malloc(sizeof(*(to)->usec));
10836 0 : if((to)->usec == NULL) goto fail;
10837 0 : if(copy_krb5int32((from)->usec, (to)->usec)) goto fail;
10838 : }else
10839 0 : (to)->usec = NULL;
10840 0 : if((from)->seq_number) {
10841 0 : (to)->seq_number = malloc(sizeof(*(to)->seq_number));
10842 0 : if((to)->seq_number == NULL) goto fail;
10843 0 : if(copy_krb5uint32((from)->seq_number, (to)->seq_number)) goto fail;
10844 : }else
10845 0 : (to)->seq_number = NULL;
10846 0 : if((from)->s_address) {
10847 0 : (to)->s_address = malloc(sizeof(*(to)->s_address));
10848 0 : if((to)->s_address == NULL) goto fail;
10849 0 : if(copy_HostAddress((from)->s_address, (to)->s_address)) goto fail;
10850 : }else
10851 0 : (to)->s_address = NULL;
10852 0 : if((from)->r_address) {
10853 0 : (to)->r_address = malloc(sizeof(*(to)->r_address));
10854 0 : if((to)->r_address == NULL) goto fail;
10855 0 : if(copy_HostAddress((from)->r_address, (to)->r_address)) goto fail;
10856 : }else
10857 0 : (to)->r_address = NULL;
10858 0 : return 0;
10859 0 : fail:
10860 0 : free_EncKrbPrivPart(to);
10861 0 : return ENOMEM;
10862 : }
10863 :
10864 : int ASN1CALL
10865 19181 : encode_KRB_CRED(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const KRB_CRED *data, size_t *size)
10866 : {
10867 19181 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
10868 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
10869 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
10870 :
10871 : /* enc-part */
10872 : {
10873 19181 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
10874 19181 : ret = 0;
10875 19181 : e = encode_EncryptedData(p, len, &(data)->enc_part, &l);
10876 19181 : if (e) return e;
10877 19181 : p -= l; len -= l; ret += l;
10878 :
10879 19181 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
10880 19181 : if (e) return e;
10881 19181 : p -= l; len -= l; ret += l;
10882 :
10883 19181 : ret += Top_tag_tag_oldret;
10884 : }
10885 : /* tickets */
10886 : {
10887 19181 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
10888 19181 : ret = 0;
10889 38362 : for(i = (int)(&(data)->tickets)->len - 1; i >= 0; --i) {
10890 19181 : size_t tickets_tag_tag_for_oldret = ret;
10891 19181 : ret = 0;
10892 19181 : e = encode_Ticket(p, len, &(&(data)->tickets)->val[i], &l);
10893 19181 : if (e) return e;
10894 19181 : p -= l; len -= l; ret += l;
10895 :
10896 19181 : ret += tickets_tag_tag_for_oldret;
10897 : }
10898 19181 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
10899 19181 : if (e) return e;
10900 19181 : p -= l; len -= l; ret += l;
10901 :
10902 19181 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
10903 19181 : if (e) return e;
10904 19181 : p -= l; len -= l; ret += l;
10905 :
10906 19181 : ret += Top_tag_tag_oldret;
10907 : }
10908 : /* msg-type */
10909 : {
10910 19181 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
10911 19181 : ret = 0;
10912 19181 : e = encode_MESSAGE_TYPE(p, len, &(data)->msg_type, &l);
10913 19181 : if (e) return e;
10914 19181 : p -= l; len -= l; ret += l;
10915 :
10916 19181 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
10917 19181 : if (e) return e;
10918 19181 : p -= l; len -= l; ret += l;
10919 :
10920 19181 : ret += Top_tag_tag_oldret;
10921 : }
10922 : /* pvno */
10923 : {
10924 19181 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
10925 19181 : ret = 0;
10926 19181 : e = encode_krb5int32(p, len, &(data)->pvno, &l);
10927 19181 : if (e) return e;
10928 19181 : p -= l; len -= l; ret += l;
10929 :
10930 19181 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
10931 19181 : if (e) return e;
10932 19181 : p -= l; len -= l; ret += l;
10933 :
10934 19181 : ret += Top_tag_tag_oldret;
10935 : }
10936 19181 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
10937 19181 : if (e) return e;
10938 19181 : p -= l; len -= l; ret += l;
10939 :
10940 19181 : e = der_put_length_and_tag (p, len, ret, ASN1_C_APPL, CONS, 22, &l);
10941 19181 : if (e) return e;
10942 19181 : p -= l; len -= l; ret += l;
10943 :
10944 19181 : *size = ret;
10945 19181 : return 0;
10946 : }
10947 :
10948 : int ASN1CALL
10949 19022 : decode_KRB_CRED(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, KRB_CRED *data, size_t *size)
10950 : {
10951 19022 : size_t ret = 0;
10952 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
10953 : int e HEIMDAL_UNUSED_ATTRIBUTE;
10954 :
10955 19022 : memset(data, 0, sizeof(*data));
10956 : {
10957 : size_t Top_datalen, Top_oldlen;
10958 : Der_type Top_type;
10959 19022 : e = der_match_tag_and_length(p, len, ASN1_C_APPL, &Top_type, 22, &Top_datalen, &l);
10960 19022 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
10961 19022 : if(e) goto fail;
10962 19022 : p += l; len -= l; ret += l;
10963 19022 : Top_oldlen = len;
10964 19022 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
10965 19022 : len = Top_datalen;
10966 : {
10967 : size_t Top_Tag_datalen, Top_Tag_oldlen;
10968 : Der_type Top_Tag_type;
10969 19022 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_Tag_type, UT_Sequence, &Top_Tag_datalen, &l);
10970 19022 : if (e == 0 && Top_Tag_type != CONS) { e = ASN1_BAD_ID; }
10971 19022 : if(e) goto fail;
10972 19022 : p += l; len -= l; ret += l;
10973 19022 : Top_Tag_oldlen = len;
10974 19022 : if (Top_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
10975 19022 : len = Top_Tag_datalen;
10976 : {
10977 : size_t pvno_datalen, pvno_oldlen;
10978 : Der_type pvno_type;
10979 19022 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &pvno_type, 0, &pvno_datalen, &l);
10980 19022 : if (e == 0 && pvno_type != CONS) { e = ASN1_BAD_ID; }
10981 19022 : if(e) goto fail;
10982 19022 : p += l; len -= l; ret += l;
10983 19022 : pvno_oldlen = len;
10984 19022 : if (pvno_datalen > len) { e = ASN1_OVERRUN; goto fail; }
10985 19022 : len = pvno_datalen;
10986 19022 : e = decode_krb5int32(p, len, &(data)->pvno, &l);
10987 19022 : if(e) goto fail;
10988 19022 : p += l; len -= l; ret += l;
10989 19022 : len = pvno_oldlen - pvno_datalen;
10990 : }
10991 : {
10992 : size_t msg_type_datalen, msg_type_oldlen;
10993 : Der_type msg_type_type;
10994 19022 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &msg_type_type, 1, &msg_type_datalen, &l);
10995 37306 : if (e == 0 && msg_type_type != CONS) { e = ASN1_BAD_ID; }
10996 19022 : if(e) goto fail;
10997 19022 : p += l; len -= l; ret += l;
10998 19022 : msg_type_oldlen = len;
10999 19022 : if (msg_type_datalen > len) { e = ASN1_OVERRUN; goto fail; }
11000 19022 : len = msg_type_datalen;
11001 19022 : e = decode_MESSAGE_TYPE(p, len, &(data)->msg_type, &l);
11002 19022 : if(e) goto fail;
11003 19022 : p += l; len -= l; ret += l;
11004 19022 : len = msg_type_oldlen - msg_type_datalen;
11005 : }
11006 : {
11007 : size_t tickets_datalen, tickets_oldlen;
11008 : Der_type tickets_type;
11009 19022 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &tickets_type, 2, &tickets_datalen, &l);
11010 37306 : if (e == 0 && tickets_type != CONS) { e = ASN1_BAD_ID; }
11011 19022 : if(e) goto fail;
11012 19022 : p += l; len -= l; ret += l;
11013 19022 : tickets_oldlen = len;
11014 19022 : if (tickets_datalen > len) { e = ASN1_OVERRUN; goto fail; }
11015 19022 : len = tickets_datalen;
11016 : {
11017 : size_t tickets_Tag_datalen, tickets_Tag_oldlen;
11018 : Der_type tickets_Tag_type;
11019 19022 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &tickets_Tag_type, UT_Sequence, &tickets_Tag_datalen, &l);
11020 19022 : if (e == 0 && tickets_Tag_type != CONS) { e = ASN1_BAD_ID; }
11021 19022 : if(e) goto fail;
11022 19022 : p += l; len -= l; ret += l;
11023 19022 : tickets_Tag_oldlen = len;
11024 19022 : if (tickets_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
11025 19022 : len = tickets_Tag_datalen;
11026 : {
11027 19022 : size_t tickets_Tag_Tag_origlen = len;
11028 19022 : size_t tickets_Tag_Tag_oldret = ret;
11029 19022 : size_t tickets_Tag_Tag_olen = 0;
11030 : void *tickets_Tag_Tag_tmp;
11031 19022 : ret = 0;
11032 19022 : (&(data)->tickets)->len = 0;
11033 19022 : (&(data)->tickets)->val = NULL;
11034 57066 : while(ret < tickets_Tag_Tag_origlen) {
11035 19022 : size_t tickets_Tag_Tag_nlen = tickets_Tag_Tag_olen + sizeof(*((&(data)->tickets)->val));
11036 19022 : if (tickets_Tag_Tag_olen > tickets_Tag_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
11037 19022 : tickets_Tag_Tag_olen = tickets_Tag_Tag_nlen;
11038 19022 : tickets_Tag_Tag_tmp = realloc((&(data)->tickets)->val, tickets_Tag_Tag_olen);
11039 19022 : if (tickets_Tag_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
11040 19022 : (&(data)->tickets)->val = tickets_Tag_Tag_tmp;
11041 19022 : e = decode_Ticket(p, len, &(&(data)->tickets)->val[(&(data)->tickets)->len], &l);
11042 19022 : if(e) goto fail;
11043 19022 : p += l; len -= l; ret += l;
11044 19022 : (&(data)->tickets)->len++;
11045 19022 : len = tickets_Tag_Tag_origlen - ret;
11046 : }
11047 19022 : ret += tickets_Tag_Tag_oldret;
11048 : }
11049 19022 : len = tickets_Tag_oldlen - tickets_Tag_datalen;
11050 : }
11051 19022 : len = tickets_oldlen - tickets_datalen;
11052 : }
11053 : {
11054 : size_t enc_part_datalen, enc_part_oldlen;
11055 : Der_type enc_part_type;
11056 19022 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &enc_part_type, 3, &enc_part_datalen, &l);
11057 37306 : if (e == 0 && enc_part_type != CONS) { e = ASN1_BAD_ID; }
11058 19022 : if(e) goto fail;
11059 19022 : p += l; len -= l; ret += l;
11060 19022 : enc_part_oldlen = len;
11061 19022 : if (enc_part_datalen > len) { e = ASN1_OVERRUN; goto fail; }
11062 19022 : len = enc_part_datalen;
11063 19022 : e = decode_EncryptedData(p, len, &(data)->enc_part, &l);
11064 19022 : if(e) goto fail;
11065 19022 : p += l; len -= l; ret += l;
11066 19022 : len = enc_part_oldlen - enc_part_datalen;
11067 : }
11068 19022 : len = Top_Tag_oldlen - Top_Tag_datalen;
11069 : }
11070 19022 : len = Top_oldlen - Top_datalen;
11071 : }
11072 38044 : if(size) *size = ret;
11073 18284 : return 0;
11074 0 : fail:
11075 0 : free_KRB_CRED(data);
11076 0 : return e;
11077 : }
11078 :
11079 : void ASN1CALL
11080 38203 : free_KRB_CRED(KRB_CRED *data)
11081 : {
11082 38203 : free_krb5int32(&(data)->pvno);
11083 38203 : free_MESSAGE_TYPE(&(data)->msg_type);
11084 114609 : while((&(data)->tickets)->len){
11085 38203 : free_Ticket(&(&(data)->tickets)->val[(&(data)->tickets)->len-1]);
11086 38203 : (&(data)->tickets)->len--;
11087 : }
11088 38203 : free((&(data)->tickets)->val);
11089 38203 : (&(data)->tickets)->val = NULL;
11090 38203 : free_EncryptedData(&(data)->enc_part);
11091 38203 : }
11092 :
11093 : size_t ASN1CALL
11094 19181 : length_KRB_CRED(const KRB_CRED *data)
11095 : {
11096 19181 : size_t ret = 0;
11097 : {
11098 19181 : size_t Top_tag_tag_oldret = ret;
11099 19181 : ret = 0;
11100 19181 : ret += length_krb5int32(&(data)->pvno);
11101 19181 : ret += 1 + der_length_len (ret);
11102 19181 : ret += Top_tag_tag_oldret;
11103 : }
11104 : {
11105 19181 : size_t Top_tag_tag_oldret = ret;
11106 19181 : ret = 0;
11107 19181 : ret += length_MESSAGE_TYPE(&(data)->msg_type);
11108 19181 : ret += 1 + der_length_len (ret);
11109 19181 : ret += Top_tag_tag_oldret;
11110 : }
11111 : {
11112 19181 : size_t Top_tag_tag_oldret = ret;
11113 19181 : ret = 0;
11114 : {
11115 19181 : size_t tickets_tag_tag_oldret = ret;
11116 : int i;
11117 19181 : ret = 0;
11118 38362 : for(i = (&(data)->tickets)->len - 1; i >= 0; --i){
11119 19181 : size_t tickets_tag_tag_for_oldret = ret;
11120 19181 : ret = 0;
11121 19181 : ret += length_Ticket(&(&(data)->tickets)->val[i]);
11122 19181 : ret += tickets_tag_tag_for_oldret;
11123 : }
11124 19181 : ret += tickets_tag_tag_oldret;
11125 : }
11126 19181 : ret += 1 + der_length_len (ret);
11127 19181 : ret += 1 + der_length_len (ret);
11128 19181 : ret += Top_tag_tag_oldret;
11129 : }
11130 : {
11131 19181 : size_t Top_tag_tag_oldret = ret;
11132 19181 : ret = 0;
11133 19181 : ret += length_EncryptedData(&(data)->enc_part);
11134 19181 : ret += 1 + der_length_len (ret);
11135 19181 : ret += Top_tag_tag_oldret;
11136 : }
11137 19181 : ret += 1 + der_length_len (ret);
11138 19181 : ret += 1 + der_length_len (ret);
11139 19181 : return ret;
11140 : }
11141 :
11142 : int ASN1CALL
11143 0 : copy_KRB_CRED(const KRB_CRED *from, KRB_CRED *to)
11144 : {
11145 0 : memset(to, 0, sizeof(*to));
11146 0 : if(copy_krb5int32(&(from)->pvno, &(to)->pvno)) goto fail;
11147 0 : if(copy_MESSAGE_TYPE(&(from)->msg_type, &(to)->msg_type)) goto fail;
11148 0 : if(((&(to)->tickets)->val = malloc((&(from)->tickets)->len * sizeof(*(&(to)->tickets)->val))) == NULL && (&(from)->tickets)->len != 0)
11149 0 : goto fail;
11150 0 : for((&(to)->tickets)->len = 0; (&(to)->tickets)->len < (&(from)->tickets)->len; (&(to)->tickets)->len++){
11151 0 : if(copy_Ticket(&(&(from)->tickets)->val[(&(to)->tickets)->len], &(&(to)->tickets)->val[(&(to)->tickets)->len])) goto fail;
11152 : }
11153 0 : if(copy_EncryptedData(&(from)->enc_part, &(to)->enc_part)) goto fail;
11154 0 : return 0;
11155 0 : fail:
11156 0 : free_KRB_CRED(to);
11157 0 : return ENOMEM;
11158 : }
11159 :
11160 : int ASN1CALL
11161 19181 : encode_KrbCredInfo(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const KrbCredInfo *data, size_t *size)
11162 : {
11163 19181 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
11164 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
11165 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
11166 :
11167 : /* caddr */
11168 19181 : if((data)->caddr) {
11169 19181 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
11170 19181 : ret = 0;
11171 19181 : e = encode_HostAddresses(p, len, (data)->caddr, &l);
11172 19181 : if (e) return e;
11173 19181 : p -= l; len -= l; ret += l;
11174 :
11175 19181 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 10, &l);
11176 19181 : if (e) return e;
11177 19181 : p -= l; len -= l; ret += l;
11178 :
11179 19181 : ret += Top_tag_oldret;
11180 : }
11181 : /* sname */
11182 19181 : if((data)->sname) {
11183 19181 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
11184 19181 : ret = 0;
11185 19181 : e = encode_PrincipalName(p, len, (data)->sname, &l);
11186 19181 : if (e) return e;
11187 19181 : p -= l; len -= l; ret += l;
11188 :
11189 19181 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 9, &l);
11190 19181 : if (e) return e;
11191 19181 : p -= l; len -= l; ret += l;
11192 :
11193 19181 : ret += Top_tag_oldret;
11194 : }
11195 : /* srealm */
11196 19181 : if((data)->srealm) {
11197 19181 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
11198 19181 : ret = 0;
11199 19181 : e = encode_Realm(p, len, (data)->srealm, &l);
11200 19181 : if (e) return e;
11201 19181 : p -= l; len -= l; ret += l;
11202 :
11203 19181 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 8, &l);
11204 19181 : if (e) return e;
11205 19181 : p -= l; len -= l; ret += l;
11206 :
11207 19181 : ret += Top_tag_oldret;
11208 : }
11209 : /* renew-till */
11210 19181 : if((data)->renew_till) {
11211 19181 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
11212 19181 : ret = 0;
11213 19181 : e = encode_KerberosTime(p, len, (data)->renew_till, &l);
11214 19181 : if (e) return e;
11215 19181 : p -= l; len -= l; ret += l;
11216 :
11217 19181 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 7, &l);
11218 19181 : if (e) return e;
11219 19181 : p -= l; len -= l; ret += l;
11220 :
11221 19181 : ret += Top_tag_oldret;
11222 : }
11223 : /* endtime */
11224 19181 : if((data)->endtime) {
11225 19181 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
11226 19181 : ret = 0;
11227 19181 : e = encode_KerberosTime(p, len, (data)->endtime, &l);
11228 19181 : if (e) return e;
11229 19181 : p -= l; len -= l; ret += l;
11230 :
11231 19181 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 6, &l);
11232 19181 : if (e) return e;
11233 19181 : p -= l; len -= l; ret += l;
11234 :
11235 19181 : ret += Top_tag_oldret;
11236 : }
11237 : /* starttime */
11238 19181 : if((data)->starttime) {
11239 19181 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
11240 19181 : ret = 0;
11241 19181 : e = encode_KerberosTime(p, len, (data)->starttime, &l);
11242 19181 : if (e) return e;
11243 19181 : p -= l; len -= l; ret += l;
11244 :
11245 19181 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 5, &l);
11246 19181 : if (e) return e;
11247 19181 : p -= l; len -= l; ret += l;
11248 :
11249 19181 : ret += Top_tag_oldret;
11250 : }
11251 : /* authtime */
11252 19181 : if((data)->authtime) {
11253 19181 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
11254 19181 : ret = 0;
11255 19181 : e = encode_KerberosTime(p, len, (data)->authtime, &l);
11256 19181 : if (e) return e;
11257 19181 : p -= l; len -= l; ret += l;
11258 :
11259 19181 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 4, &l);
11260 19181 : if (e) return e;
11261 19181 : p -= l; len -= l; ret += l;
11262 :
11263 19181 : ret += Top_tag_oldret;
11264 : }
11265 : /* flags */
11266 19181 : if((data)->flags) {
11267 19181 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
11268 19181 : ret = 0;
11269 19181 : e = encode_TicketFlags(p, len, (data)->flags, &l);
11270 19181 : if (e) return e;
11271 19181 : p -= l; len -= l; ret += l;
11272 :
11273 19181 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
11274 19181 : if (e) return e;
11275 19181 : p -= l; len -= l; ret += l;
11276 :
11277 19181 : ret += Top_tag_oldret;
11278 : }
11279 : /* pname */
11280 19181 : if((data)->pname) {
11281 19181 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
11282 19181 : ret = 0;
11283 19181 : e = encode_PrincipalName(p, len, (data)->pname, &l);
11284 19181 : if (e) return e;
11285 19181 : p -= l; len -= l; ret += l;
11286 :
11287 19181 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
11288 19181 : if (e) return e;
11289 19181 : p -= l; len -= l; ret += l;
11290 :
11291 19181 : ret += Top_tag_oldret;
11292 : }
11293 : /* prealm */
11294 19181 : if((data)->prealm) {
11295 19181 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
11296 19181 : ret = 0;
11297 19181 : e = encode_Realm(p, len, (data)->prealm, &l);
11298 19181 : if (e) return e;
11299 19181 : p -= l; len -= l; ret += l;
11300 :
11301 19181 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
11302 19181 : if (e) return e;
11303 19181 : p -= l; len -= l; ret += l;
11304 :
11305 19181 : ret += Top_tag_oldret;
11306 : }
11307 : /* key */
11308 : {
11309 19181 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
11310 19181 : ret = 0;
11311 19181 : e = encode_EncryptionKey(p, len, &(data)->key, &l);
11312 19181 : if (e) return e;
11313 19181 : p -= l; len -= l; ret += l;
11314 :
11315 19181 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
11316 19181 : if (e) return e;
11317 19181 : p -= l; len -= l; ret += l;
11318 :
11319 19181 : ret += Top_tag_oldret;
11320 : }
11321 19181 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
11322 19181 : if (e) return e;
11323 19181 : p -= l; len -= l; ret += l;
11324 :
11325 19181 : *size = ret;
11326 19181 : return 0;
11327 : }
11328 :
11329 : int ASN1CALL
11330 19022 : decode_KrbCredInfo(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, KrbCredInfo *data, size_t *size)
11331 : {
11332 19022 : size_t ret = 0;
11333 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
11334 : int e HEIMDAL_UNUSED_ATTRIBUTE;
11335 :
11336 19022 : memset(data, 0, sizeof(*data));
11337 : {
11338 : size_t Top_datalen, Top_oldlen;
11339 : Der_type Top_type;
11340 19022 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
11341 19022 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
11342 19022 : if(e) goto fail;
11343 19022 : p += l; len -= l; ret += l;
11344 19022 : Top_oldlen = len;
11345 19022 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
11346 19022 : len = Top_datalen;
11347 : {
11348 : size_t key_datalen, key_oldlen;
11349 : Der_type key_type;
11350 19022 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &key_type, 0, &key_datalen, &l);
11351 19022 : if (e == 0 && key_type != CONS) { e = ASN1_BAD_ID; }
11352 19022 : if(e) goto fail;
11353 19022 : p += l; len -= l; ret += l;
11354 19022 : key_oldlen = len;
11355 19022 : if (key_datalen > len) { e = ASN1_OVERRUN; goto fail; }
11356 19022 : len = key_datalen;
11357 19022 : e = decode_EncryptionKey(p, len, &(data)->key, &l);
11358 19022 : if(e) goto fail;
11359 19022 : p += l; len -= l; ret += l;
11360 19022 : len = key_oldlen - key_datalen;
11361 : }
11362 : {
11363 : size_t prealm_datalen, prealm_oldlen;
11364 : Der_type prealm_type;
11365 19022 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &prealm_type, 1, &prealm_datalen, &l);
11366 37306 : if (e == 0 && prealm_type != CONS) { e = ASN1_BAD_ID; }
11367 19022 : if(e) {
11368 0 : (data)->prealm = NULL;
11369 : } else {
11370 19022 : (data)->prealm = calloc(1, sizeof(*(data)->prealm));
11371 19022 : if ((data)->prealm == NULL) { e = ENOMEM; goto fail; }
11372 19022 : p += l; len -= l; ret += l;
11373 19022 : prealm_oldlen = len;
11374 19022 : if (prealm_datalen > len) { e = ASN1_OVERRUN; goto fail; }
11375 19022 : len = prealm_datalen;
11376 19022 : e = decode_Realm(p, len, (data)->prealm, &l);
11377 19022 : if(e) goto fail;
11378 19022 : p += l; len -= l; ret += l;
11379 19022 : len = prealm_oldlen - prealm_datalen;
11380 : }
11381 : }
11382 : {
11383 : size_t pname_datalen, pname_oldlen;
11384 : Der_type pname_type;
11385 19022 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &pname_type, 2, &pname_datalen, &l);
11386 38044 : if (e == 0 && pname_type != CONS) { e = ASN1_BAD_ID; }
11387 19022 : if(e) {
11388 0 : (data)->pname = NULL;
11389 : } else {
11390 19022 : (data)->pname = calloc(1, sizeof(*(data)->pname));
11391 19022 : if ((data)->pname == NULL) { e = ENOMEM; goto fail; }
11392 19022 : p += l; len -= l; ret += l;
11393 19022 : pname_oldlen = len;
11394 19022 : if (pname_datalen > len) { e = ASN1_OVERRUN; goto fail; }
11395 19022 : len = pname_datalen;
11396 19022 : e = decode_PrincipalName(p, len, (data)->pname, &l);
11397 19022 : if(e) goto fail;
11398 19022 : p += l; len -= l; ret += l;
11399 19022 : len = pname_oldlen - pname_datalen;
11400 : }
11401 : }
11402 : {
11403 : size_t flags_datalen, flags_oldlen;
11404 : Der_type flags_type;
11405 19022 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &flags_type, 3, &flags_datalen, &l);
11406 38044 : if (e == 0 && flags_type != CONS) { e = ASN1_BAD_ID; }
11407 19022 : if(e) {
11408 0 : (data)->flags = NULL;
11409 : } else {
11410 19022 : (data)->flags = calloc(1, sizeof(*(data)->flags));
11411 19022 : if ((data)->flags == NULL) { e = ENOMEM; goto fail; }
11412 19022 : p += l; len -= l; ret += l;
11413 19022 : flags_oldlen = len;
11414 19022 : if (flags_datalen > len) { e = ASN1_OVERRUN; goto fail; }
11415 19022 : len = flags_datalen;
11416 19022 : e = decode_TicketFlags(p, len, (data)->flags, &l);
11417 19022 : if(e) goto fail;
11418 19022 : p += l; len -= l; ret += l;
11419 19022 : len = flags_oldlen - flags_datalen;
11420 : }
11421 : }
11422 : {
11423 : size_t authtime_datalen, authtime_oldlen;
11424 : Der_type authtime_type;
11425 19022 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &authtime_type, 4, &authtime_datalen, &l);
11426 38044 : if (e == 0 && authtime_type != CONS) { e = ASN1_BAD_ID; }
11427 19022 : if(e) {
11428 0 : (data)->authtime = NULL;
11429 : } else {
11430 19022 : (data)->authtime = calloc(1, sizeof(*(data)->authtime));
11431 19022 : if ((data)->authtime == NULL) { e = ENOMEM; goto fail; }
11432 19022 : p += l; len -= l; ret += l;
11433 19022 : authtime_oldlen = len;
11434 19022 : if (authtime_datalen > len) { e = ASN1_OVERRUN; goto fail; }
11435 19022 : len = authtime_datalen;
11436 19022 : e = decode_KerberosTime(p, len, (data)->authtime, &l);
11437 19022 : if(e) goto fail;
11438 19022 : p += l; len -= l; ret += l;
11439 19022 : len = authtime_oldlen - authtime_datalen;
11440 : }
11441 : }
11442 : {
11443 : size_t starttime_datalen, starttime_oldlen;
11444 : Der_type starttime_type;
11445 19022 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &starttime_type, 5, &starttime_datalen, &l);
11446 38044 : if (e == 0 && starttime_type != CONS) { e = ASN1_BAD_ID; }
11447 19022 : if(e) {
11448 0 : (data)->starttime = NULL;
11449 : } else {
11450 19022 : (data)->starttime = calloc(1, sizeof(*(data)->starttime));
11451 19022 : if ((data)->starttime == NULL) { e = ENOMEM; goto fail; }
11452 19022 : p += l; len -= l; ret += l;
11453 19022 : starttime_oldlen = len;
11454 19022 : if (starttime_datalen > len) { e = ASN1_OVERRUN; goto fail; }
11455 19022 : len = starttime_datalen;
11456 19022 : e = decode_KerberosTime(p, len, (data)->starttime, &l);
11457 19022 : if(e) goto fail;
11458 19022 : p += l; len -= l; ret += l;
11459 19022 : len = starttime_oldlen - starttime_datalen;
11460 : }
11461 : }
11462 : {
11463 : size_t endtime_datalen, endtime_oldlen;
11464 : Der_type endtime_type;
11465 19022 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &endtime_type, 6, &endtime_datalen, &l);
11466 38044 : if (e == 0 && endtime_type != CONS) { e = ASN1_BAD_ID; }
11467 19022 : if(e) {
11468 0 : (data)->endtime = NULL;
11469 : } else {
11470 19022 : (data)->endtime = calloc(1, sizeof(*(data)->endtime));
11471 19022 : if ((data)->endtime == NULL) { e = ENOMEM; goto fail; }
11472 19022 : p += l; len -= l; ret += l;
11473 19022 : endtime_oldlen = len;
11474 19022 : if (endtime_datalen > len) { e = ASN1_OVERRUN; goto fail; }
11475 19022 : len = endtime_datalen;
11476 19022 : e = decode_KerberosTime(p, len, (data)->endtime, &l);
11477 19022 : if(e) goto fail;
11478 19022 : p += l; len -= l; ret += l;
11479 19022 : len = endtime_oldlen - endtime_datalen;
11480 : }
11481 : }
11482 : {
11483 : size_t renew_till_datalen, renew_till_oldlen;
11484 : Der_type renew_till_type;
11485 19022 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &renew_till_type, 7, &renew_till_datalen, &l);
11486 38044 : if (e == 0 && renew_till_type != CONS) { e = ASN1_BAD_ID; }
11487 19022 : if(e) {
11488 0 : (data)->renew_till = NULL;
11489 : } else {
11490 19022 : (data)->renew_till = calloc(1, sizeof(*(data)->renew_till));
11491 19022 : if ((data)->renew_till == NULL) { e = ENOMEM; goto fail; }
11492 19022 : p += l; len -= l; ret += l;
11493 19022 : renew_till_oldlen = len;
11494 19022 : if (renew_till_datalen > len) { e = ASN1_OVERRUN; goto fail; }
11495 19022 : len = renew_till_datalen;
11496 19022 : e = decode_KerberosTime(p, len, (data)->renew_till, &l);
11497 19022 : if(e) goto fail;
11498 19022 : p += l; len -= l; ret += l;
11499 19022 : len = renew_till_oldlen - renew_till_datalen;
11500 : }
11501 : }
11502 : {
11503 : size_t srealm_datalen, srealm_oldlen;
11504 : Der_type srealm_type;
11505 19022 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &srealm_type, 8, &srealm_datalen, &l);
11506 38044 : if (e == 0 && srealm_type != CONS) { e = ASN1_BAD_ID; }
11507 19022 : if(e) {
11508 0 : (data)->srealm = NULL;
11509 : } else {
11510 19022 : (data)->srealm = calloc(1, sizeof(*(data)->srealm));
11511 19022 : if ((data)->srealm == NULL) { e = ENOMEM; goto fail; }
11512 19022 : p += l; len -= l; ret += l;
11513 19022 : srealm_oldlen = len;
11514 19022 : if (srealm_datalen > len) { e = ASN1_OVERRUN; goto fail; }
11515 19022 : len = srealm_datalen;
11516 19022 : e = decode_Realm(p, len, (data)->srealm, &l);
11517 19022 : if(e) goto fail;
11518 19022 : p += l; len -= l; ret += l;
11519 19022 : len = srealm_oldlen - srealm_datalen;
11520 : }
11521 : }
11522 : {
11523 : size_t sname_datalen, sname_oldlen;
11524 : Der_type sname_type;
11525 19022 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &sname_type, 9, &sname_datalen, &l);
11526 38044 : if (e == 0 && sname_type != CONS) { e = ASN1_BAD_ID; }
11527 19022 : if(e) {
11528 0 : (data)->sname = NULL;
11529 : } else {
11530 19022 : (data)->sname = calloc(1, sizeof(*(data)->sname));
11531 19022 : if ((data)->sname == NULL) { e = ENOMEM; goto fail; }
11532 19022 : p += l; len -= l; ret += l;
11533 19022 : sname_oldlen = len;
11534 19022 : if (sname_datalen > len) { e = ASN1_OVERRUN; goto fail; }
11535 19022 : len = sname_datalen;
11536 19022 : e = decode_PrincipalName(p, len, (data)->sname, &l);
11537 19022 : if(e) goto fail;
11538 19022 : p += l; len -= l; ret += l;
11539 19022 : len = sname_oldlen - sname_datalen;
11540 : }
11541 : }
11542 : {
11543 : size_t caddr_datalen, caddr_oldlen;
11544 : Der_type caddr_type;
11545 19022 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &caddr_type, 10, &caddr_datalen, &l);
11546 38044 : if (e == 0 && caddr_type != CONS) { e = ASN1_BAD_ID; }
11547 19022 : if(e) {
11548 0 : (data)->caddr = NULL;
11549 : } else {
11550 19022 : (data)->caddr = calloc(1, sizeof(*(data)->caddr));
11551 19022 : if ((data)->caddr == NULL) { e = ENOMEM; goto fail; }
11552 19022 : p += l; len -= l; ret += l;
11553 19022 : caddr_oldlen = len;
11554 19022 : if (caddr_datalen > len) { e = ASN1_OVERRUN; goto fail; }
11555 19022 : len = caddr_datalen;
11556 19022 : e = decode_HostAddresses(p, len, (data)->caddr, &l);
11557 19022 : if(e) goto fail;
11558 19022 : p += l; len -= l; ret += l;
11559 19022 : len = caddr_oldlen - caddr_datalen;
11560 : }
11561 : }
11562 19022 : len = Top_oldlen - Top_datalen;
11563 : }
11564 38044 : if(size) *size = ret;
11565 18284 : return 0;
11566 0 : fail:
11567 0 : free_KrbCredInfo(data);
11568 0 : return e;
11569 : }
11570 :
11571 : void ASN1CALL
11572 38203 : free_KrbCredInfo(KrbCredInfo *data)
11573 : {
11574 38203 : free_EncryptionKey(&(data)->key);
11575 38203 : if((data)->prealm) {
11576 38203 : free_Realm((data)->prealm);
11577 38203 : free((data)->prealm);
11578 38203 : (data)->prealm = NULL;
11579 : }
11580 38203 : if((data)->pname) {
11581 38203 : free_PrincipalName((data)->pname);
11582 38203 : free((data)->pname);
11583 38203 : (data)->pname = NULL;
11584 : }
11585 38203 : if((data)->flags) {
11586 38203 : free_TicketFlags((data)->flags);
11587 38203 : free((data)->flags);
11588 38203 : (data)->flags = NULL;
11589 : }
11590 38203 : if((data)->authtime) {
11591 38203 : free_KerberosTime((data)->authtime);
11592 38203 : free((data)->authtime);
11593 38203 : (data)->authtime = NULL;
11594 : }
11595 38203 : if((data)->starttime) {
11596 38203 : free_KerberosTime((data)->starttime);
11597 38203 : free((data)->starttime);
11598 38203 : (data)->starttime = NULL;
11599 : }
11600 38203 : if((data)->endtime) {
11601 38203 : free_KerberosTime((data)->endtime);
11602 38203 : free((data)->endtime);
11603 38203 : (data)->endtime = NULL;
11604 : }
11605 38203 : if((data)->renew_till) {
11606 38203 : free_KerberosTime((data)->renew_till);
11607 38203 : free((data)->renew_till);
11608 38203 : (data)->renew_till = NULL;
11609 : }
11610 38203 : if((data)->srealm) {
11611 38203 : free_Realm((data)->srealm);
11612 38203 : free((data)->srealm);
11613 38203 : (data)->srealm = NULL;
11614 : }
11615 38203 : if((data)->sname) {
11616 38203 : free_PrincipalName((data)->sname);
11617 38203 : free((data)->sname);
11618 38203 : (data)->sname = NULL;
11619 : }
11620 38203 : if((data)->caddr) {
11621 38203 : free_HostAddresses((data)->caddr);
11622 38203 : free((data)->caddr);
11623 38203 : (data)->caddr = NULL;
11624 : }
11625 38203 : }
11626 :
11627 : size_t ASN1CALL
11628 19181 : length_KrbCredInfo(const KrbCredInfo *data)
11629 : {
11630 19181 : size_t ret = 0;
11631 : {
11632 19181 : size_t Top_tag_oldret = ret;
11633 19181 : ret = 0;
11634 19181 : ret += length_EncryptionKey(&(data)->key);
11635 19181 : ret += 1 + der_length_len (ret);
11636 19181 : ret += Top_tag_oldret;
11637 : }
11638 19181 : if((data)->prealm){
11639 19181 : size_t Top_tag_oldret = ret;
11640 19181 : ret = 0;
11641 19181 : ret += length_Realm((data)->prealm);
11642 19181 : ret += 1 + der_length_len (ret);
11643 19181 : ret += Top_tag_oldret;
11644 : }
11645 19181 : if((data)->pname){
11646 19181 : size_t Top_tag_oldret = ret;
11647 19181 : ret = 0;
11648 19181 : ret += length_PrincipalName((data)->pname);
11649 19181 : ret += 1 + der_length_len (ret);
11650 19181 : ret += Top_tag_oldret;
11651 : }
11652 19181 : if((data)->flags){
11653 19181 : size_t Top_tag_oldret = ret;
11654 19181 : ret = 0;
11655 19181 : ret += length_TicketFlags((data)->flags);
11656 19181 : ret += 1 + der_length_len (ret);
11657 19181 : ret += Top_tag_oldret;
11658 : }
11659 19181 : if((data)->authtime){
11660 19181 : size_t Top_tag_oldret = ret;
11661 19181 : ret = 0;
11662 19181 : ret += length_KerberosTime((data)->authtime);
11663 19181 : ret += 1 + der_length_len (ret);
11664 19181 : ret += Top_tag_oldret;
11665 : }
11666 19181 : if((data)->starttime){
11667 19181 : size_t Top_tag_oldret = ret;
11668 19181 : ret = 0;
11669 19181 : ret += length_KerberosTime((data)->starttime);
11670 19181 : ret += 1 + der_length_len (ret);
11671 19181 : ret += Top_tag_oldret;
11672 : }
11673 19181 : if((data)->endtime){
11674 19181 : size_t Top_tag_oldret = ret;
11675 19181 : ret = 0;
11676 19181 : ret += length_KerberosTime((data)->endtime);
11677 19181 : ret += 1 + der_length_len (ret);
11678 19181 : ret += Top_tag_oldret;
11679 : }
11680 19181 : if((data)->renew_till){
11681 19181 : size_t Top_tag_oldret = ret;
11682 19181 : ret = 0;
11683 19181 : ret += length_KerberosTime((data)->renew_till);
11684 19181 : ret += 1 + der_length_len (ret);
11685 19181 : ret += Top_tag_oldret;
11686 : }
11687 19181 : if((data)->srealm){
11688 19181 : size_t Top_tag_oldret = ret;
11689 19181 : ret = 0;
11690 19181 : ret += length_Realm((data)->srealm);
11691 19181 : ret += 1 + der_length_len (ret);
11692 19181 : ret += Top_tag_oldret;
11693 : }
11694 19181 : if((data)->sname){
11695 19181 : size_t Top_tag_oldret = ret;
11696 19181 : ret = 0;
11697 19181 : ret += length_PrincipalName((data)->sname);
11698 19181 : ret += 1 + der_length_len (ret);
11699 19181 : ret += Top_tag_oldret;
11700 : }
11701 19181 : if((data)->caddr){
11702 19181 : size_t Top_tag_oldret = ret;
11703 19181 : ret = 0;
11704 19181 : ret += length_HostAddresses((data)->caddr);
11705 19181 : ret += 1 + der_length_len (ret);
11706 19181 : ret += Top_tag_oldret;
11707 : }
11708 19181 : ret += 1 + der_length_len (ret);
11709 19181 : return ret;
11710 : }
11711 :
11712 : int ASN1CALL
11713 0 : copy_KrbCredInfo(const KrbCredInfo *from, KrbCredInfo *to)
11714 : {
11715 0 : memset(to, 0, sizeof(*to));
11716 0 : if(copy_EncryptionKey(&(from)->key, &(to)->key)) goto fail;
11717 0 : if((from)->prealm) {
11718 0 : (to)->prealm = malloc(sizeof(*(to)->prealm));
11719 0 : if((to)->prealm == NULL) goto fail;
11720 0 : if(copy_Realm((from)->prealm, (to)->prealm)) goto fail;
11721 : }else
11722 0 : (to)->prealm = NULL;
11723 0 : if((from)->pname) {
11724 0 : (to)->pname = malloc(sizeof(*(to)->pname));
11725 0 : if((to)->pname == NULL) goto fail;
11726 0 : if(copy_PrincipalName((from)->pname, (to)->pname)) goto fail;
11727 : }else
11728 0 : (to)->pname = NULL;
11729 0 : if((from)->flags) {
11730 0 : (to)->flags = malloc(sizeof(*(to)->flags));
11731 0 : if((to)->flags == NULL) goto fail;
11732 0 : if(copy_TicketFlags((from)->flags, (to)->flags)) goto fail;
11733 : }else
11734 0 : (to)->flags = NULL;
11735 0 : if((from)->authtime) {
11736 0 : (to)->authtime = malloc(sizeof(*(to)->authtime));
11737 0 : if((to)->authtime == NULL) goto fail;
11738 0 : if(copy_KerberosTime((from)->authtime, (to)->authtime)) goto fail;
11739 : }else
11740 0 : (to)->authtime = NULL;
11741 0 : if((from)->starttime) {
11742 0 : (to)->starttime = malloc(sizeof(*(to)->starttime));
11743 0 : if((to)->starttime == NULL) goto fail;
11744 0 : if(copy_KerberosTime((from)->starttime, (to)->starttime)) goto fail;
11745 : }else
11746 0 : (to)->starttime = NULL;
11747 0 : if((from)->endtime) {
11748 0 : (to)->endtime = malloc(sizeof(*(to)->endtime));
11749 0 : if((to)->endtime == NULL) goto fail;
11750 0 : if(copy_KerberosTime((from)->endtime, (to)->endtime)) goto fail;
11751 : }else
11752 0 : (to)->endtime = NULL;
11753 0 : if((from)->renew_till) {
11754 0 : (to)->renew_till = malloc(sizeof(*(to)->renew_till));
11755 0 : if((to)->renew_till == NULL) goto fail;
11756 0 : if(copy_KerberosTime((from)->renew_till, (to)->renew_till)) goto fail;
11757 : }else
11758 0 : (to)->renew_till = NULL;
11759 0 : if((from)->srealm) {
11760 0 : (to)->srealm = malloc(sizeof(*(to)->srealm));
11761 0 : if((to)->srealm == NULL) goto fail;
11762 0 : if(copy_Realm((from)->srealm, (to)->srealm)) goto fail;
11763 : }else
11764 0 : (to)->srealm = NULL;
11765 0 : if((from)->sname) {
11766 0 : (to)->sname = malloc(sizeof(*(to)->sname));
11767 0 : if((to)->sname == NULL) goto fail;
11768 0 : if(copy_PrincipalName((from)->sname, (to)->sname)) goto fail;
11769 : }else
11770 0 : (to)->sname = NULL;
11771 0 : if((from)->caddr) {
11772 0 : (to)->caddr = malloc(sizeof(*(to)->caddr));
11773 0 : if((to)->caddr == NULL) goto fail;
11774 0 : if(copy_HostAddresses((from)->caddr, (to)->caddr)) goto fail;
11775 : }else
11776 0 : (to)->caddr = NULL;
11777 0 : return 0;
11778 0 : fail:
11779 0 : free_KrbCredInfo(to);
11780 0 : return ENOMEM;
11781 : }
11782 :
11783 : int ASN1CALL
11784 19181 : encode_EncKrbCredPart(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const EncKrbCredPart *data, size_t *size)
11785 : {
11786 19181 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
11787 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
11788 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
11789 :
11790 : /* r-address */
11791 19181 : if((data)->r_address) {
11792 0 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
11793 0 : ret = 0;
11794 0 : e = encode_HostAddress(p, len, (data)->r_address, &l);
11795 0 : if (e) return e;
11796 0 : p -= l; len -= l; ret += l;
11797 :
11798 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 5, &l);
11799 0 : if (e) return e;
11800 0 : p -= l; len -= l; ret += l;
11801 :
11802 0 : ret += Top_tag_tag_oldret;
11803 : }
11804 : /* s-address */
11805 19181 : if((data)->s_address) {
11806 0 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
11807 0 : ret = 0;
11808 0 : e = encode_HostAddress(p, len, (data)->s_address, &l);
11809 0 : if (e) return e;
11810 0 : p -= l; len -= l; ret += l;
11811 :
11812 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 4, &l);
11813 0 : if (e) return e;
11814 0 : p -= l; len -= l; ret += l;
11815 :
11816 0 : ret += Top_tag_tag_oldret;
11817 : }
11818 : /* usec */
11819 19181 : if((data)->usec) {
11820 19181 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
11821 19181 : ret = 0;
11822 19181 : e = encode_krb5int32(p, len, (data)->usec, &l);
11823 19181 : if (e) return e;
11824 19181 : p -= l; len -= l; ret += l;
11825 :
11826 19181 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
11827 19181 : if (e) return e;
11828 19181 : p -= l; len -= l; ret += l;
11829 :
11830 19181 : ret += Top_tag_tag_oldret;
11831 : }
11832 : /* timestamp */
11833 19181 : if((data)->timestamp) {
11834 19181 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
11835 19181 : ret = 0;
11836 19181 : e = encode_KerberosTime(p, len, (data)->timestamp, &l);
11837 19181 : if (e) return e;
11838 19181 : p -= l; len -= l; ret += l;
11839 :
11840 19181 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
11841 19181 : if (e) return e;
11842 19181 : p -= l; len -= l; ret += l;
11843 :
11844 19181 : ret += Top_tag_tag_oldret;
11845 : }
11846 : /* nonce */
11847 19181 : if((data)->nonce) {
11848 0 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
11849 0 : ret = 0;
11850 0 : e = encode_krb5int32(p, len, (data)->nonce, &l);
11851 0 : if (e) return e;
11852 0 : p -= l; len -= l; ret += l;
11853 :
11854 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
11855 0 : if (e) return e;
11856 0 : p -= l; len -= l; ret += l;
11857 :
11858 0 : ret += Top_tag_tag_oldret;
11859 : }
11860 : /* ticket-info */
11861 : {
11862 19181 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
11863 19181 : ret = 0;
11864 38362 : for(i = (int)(&(data)->ticket_info)->len - 1; i >= 0; --i) {
11865 19181 : size_t ticket_info_tag_tag_for_oldret = ret;
11866 19181 : ret = 0;
11867 19181 : e = encode_KrbCredInfo(p, len, &(&(data)->ticket_info)->val[i], &l);
11868 19181 : if (e) return e;
11869 19181 : p -= l; len -= l; ret += l;
11870 :
11871 19181 : ret += ticket_info_tag_tag_for_oldret;
11872 : }
11873 19181 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
11874 19181 : if (e) return e;
11875 19181 : p -= l; len -= l; ret += l;
11876 :
11877 19181 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
11878 19181 : if (e) return e;
11879 19181 : p -= l; len -= l; ret += l;
11880 :
11881 19181 : ret += Top_tag_tag_oldret;
11882 : }
11883 19181 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
11884 19181 : if (e) return e;
11885 19181 : p -= l; len -= l; ret += l;
11886 :
11887 19181 : e = der_put_length_and_tag (p, len, ret, ASN1_C_APPL, CONS, 29, &l);
11888 19181 : if (e) return e;
11889 19181 : p -= l; len -= l; ret += l;
11890 :
11891 19181 : *size = ret;
11892 19181 : return 0;
11893 : }
11894 :
11895 : int ASN1CALL
11896 19022 : decode_EncKrbCredPart(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, EncKrbCredPart *data, size_t *size)
11897 : {
11898 19022 : size_t ret = 0;
11899 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
11900 : int e HEIMDAL_UNUSED_ATTRIBUTE;
11901 :
11902 19022 : memset(data, 0, sizeof(*data));
11903 : {
11904 : size_t Top_datalen, Top_oldlen;
11905 : Der_type Top_type;
11906 19022 : e = der_match_tag_and_length(p, len, ASN1_C_APPL, &Top_type, 29, &Top_datalen, &l);
11907 19022 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
11908 19022 : if(e) goto fail;
11909 19022 : p += l; len -= l; ret += l;
11910 19022 : Top_oldlen = len;
11911 19022 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
11912 19022 : len = Top_datalen;
11913 : {
11914 : size_t Top_Tag_datalen, Top_Tag_oldlen;
11915 : Der_type Top_Tag_type;
11916 19022 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_Tag_type, UT_Sequence, &Top_Tag_datalen, &l);
11917 19022 : if (e == 0 && Top_Tag_type != CONS) { e = ASN1_BAD_ID; }
11918 19022 : if(e) goto fail;
11919 19022 : p += l; len -= l; ret += l;
11920 19022 : Top_Tag_oldlen = len;
11921 19022 : if (Top_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
11922 19022 : len = Top_Tag_datalen;
11923 : {
11924 : size_t ticket_info_datalen, ticket_info_oldlen;
11925 : Der_type ticket_info_type;
11926 19022 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &ticket_info_type, 0, &ticket_info_datalen, &l);
11927 19022 : if (e == 0 && ticket_info_type != CONS) { e = ASN1_BAD_ID; }
11928 19022 : if(e) goto fail;
11929 19022 : p += l; len -= l; ret += l;
11930 19022 : ticket_info_oldlen = len;
11931 19022 : if (ticket_info_datalen > len) { e = ASN1_OVERRUN; goto fail; }
11932 19022 : len = ticket_info_datalen;
11933 : {
11934 : size_t ticket_info_Tag_datalen, ticket_info_Tag_oldlen;
11935 : Der_type ticket_info_Tag_type;
11936 19022 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &ticket_info_Tag_type, UT_Sequence, &ticket_info_Tag_datalen, &l);
11937 19022 : if (e == 0 && ticket_info_Tag_type != CONS) { e = ASN1_BAD_ID; }
11938 19022 : if(e) goto fail;
11939 19022 : p += l; len -= l; ret += l;
11940 19022 : ticket_info_Tag_oldlen = len;
11941 19022 : if (ticket_info_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
11942 19022 : len = ticket_info_Tag_datalen;
11943 : {
11944 19022 : size_t ticket_info_Tag_Tag_origlen = len;
11945 19022 : size_t ticket_info_Tag_Tag_oldret = ret;
11946 19022 : size_t ticket_info_Tag_Tag_olen = 0;
11947 : void *ticket_info_Tag_Tag_tmp;
11948 19022 : ret = 0;
11949 19022 : (&(data)->ticket_info)->len = 0;
11950 19022 : (&(data)->ticket_info)->val = NULL;
11951 57066 : while(ret < ticket_info_Tag_Tag_origlen) {
11952 19022 : size_t ticket_info_Tag_Tag_nlen = ticket_info_Tag_Tag_olen + sizeof(*((&(data)->ticket_info)->val));
11953 19022 : if (ticket_info_Tag_Tag_olen > ticket_info_Tag_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
11954 19022 : ticket_info_Tag_Tag_olen = ticket_info_Tag_Tag_nlen;
11955 19022 : ticket_info_Tag_Tag_tmp = realloc((&(data)->ticket_info)->val, ticket_info_Tag_Tag_olen);
11956 19022 : if (ticket_info_Tag_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
11957 19022 : (&(data)->ticket_info)->val = ticket_info_Tag_Tag_tmp;
11958 19022 : e = decode_KrbCredInfo(p, len, &(&(data)->ticket_info)->val[(&(data)->ticket_info)->len], &l);
11959 19022 : if(e) goto fail;
11960 19022 : p += l; len -= l; ret += l;
11961 19022 : (&(data)->ticket_info)->len++;
11962 19022 : len = ticket_info_Tag_Tag_origlen - ret;
11963 : }
11964 19022 : ret += ticket_info_Tag_Tag_oldret;
11965 : }
11966 19022 : len = ticket_info_Tag_oldlen - ticket_info_Tag_datalen;
11967 : }
11968 19022 : len = ticket_info_oldlen - ticket_info_datalen;
11969 : }
11970 : {
11971 : size_t nonce_datalen, nonce_oldlen;
11972 : Der_type nonce_type;
11973 19022 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &nonce_type, 1, &nonce_datalen, &l);
11974 19022 : if (e == 0 && nonce_type != CONS) { e = ASN1_BAD_ID; }
11975 19022 : if(e) {
11976 19022 : (data)->nonce = NULL;
11977 : } else {
11978 0 : (data)->nonce = calloc(1, sizeof(*(data)->nonce));
11979 0 : if ((data)->nonce == NULL) { e = ENOMEM; goto fail; }
11980 0 : p += l; len -= l; ret += l;
11981 0 : nonce_oldlen = len;
11982 0 : if (nonce_datalen > len) { e = ASN1_OVERRUN; goto fail; }
11983 0 : len = nonce_datalen;
11984 0 : e = decode_krb5int32(p, len, (data)->nonce, &l);
11985 0 : if(e) goto fail;
11986 0 : p += l; len -= l; ret += l;
11987 0 : len = nonce_oldlen - nonce_datalen;
11988 : }
11989 : }
11990 : {
11991 : size_t timestamp_datalen, timestamp_oldlen;
11992 : Der_type timestamp_type;
11993 19022 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, ×tamp_type, 2, ×tamp_datalen, &l);
11994 38044 : if (e == 0 && timestamp_type != CONS) { e = ASN1_BAD_ID; }
11995 19022 : if(e) {
11996 0 : (data)->timestamp = NULL;
11997 : } else {
11998 19022 : (data)->timestamp = calloc(1, sizeof(*(data)->timestamp));
11999 19022 : if ((data)->timestamp == NULL) { e = ENOMEM; goto fail; }
12000 19022 : p += l; len -= l; ret += l;
12001 19022 : timestamp_oldlen = len;
12002 19022 : if (timestamp_datalen > len) { e = ASN1_OVERRUN; goto fail; }
12003 19022 : len = timestamp_datalen;
12004 19022 : e = decode_KerberosTime(p, len, (data)->timestamp, &l);
12005 19022 : if(e) goto fail;
12006 19022 : p += l; len -= l; ret += l;
12007 19022 : len = timestamp_oldlen - timestamp_datalen;
12008 : }
12009 : }
12010 : {
12011 : size_t usec_datalen, usec_oldlen;
12012 : Der_type usec_type;
12013 19022 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &usec_type, 3, &usec_datalen, &l);
12014 38044 : if (e == 0 && usec_type != CONS) { e = ASN1_BAD_ID; }
12015 19022 : if(e) {
12016 0 : (data)->usec = NULL;
12017 : } else {
12018 19022 : (data)->usec = calloc(1, sizeof(*(data)->usec));
12019 19022 : if ((data)->usec == NULL) { e = ENOMEM; goto fail; }
12020 19022 : p += l; len -= l; ret += l;
12021 19022 : usec_oldlen = len;
12022 19022 : if (usec_datalen > len) { e = ASN1_OVERRUN; goto fail; }
12023 19022 : len = usec_datalen;
12024 19022 : e = decode_krb5int32(p, len, (data)->usec, &l);
12025 19022 : if(e) goto fail;
12026 19022 : p += l; len -= l; ret += l;
12027 19022 : len = usec_oldlen - usec_datalen;
12028 : }
12029 : }
12030 : {
12031 : size_t s_address_datalen, s_address_oldlen;
12032 : Der_type s_address_type;
12033 19022 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &s_address_type, 4, &s_address_datalen, &l);
12034 19022 : if (e == 0 && s_address_type != CONS) { e = ASN1_BAD_ID; }
12035 19022 : if(e) {
12036 19022 : (data)->s_address = NULL;
12037 : } else {
12038 0 : (data)->s_address = calloc(1, sizeof(*(data)->s_address));
12039 0 : if ((data)->s_address == NULL) { e = ENOMEM; goto fail; }
12040 0 : p += l; len -= l; ret += l;
12041 0 : s_address_oldlen = len;
12042 0 : if (s_address_datalen > len) { e = ASN1_OVERRUN; goto fail; }
12043 0 : len = s_address_datalen;
12044 0 : e = decode_HostAddress(p, len, (data)->s_address, &l);
12045 0 : if(e) goto fail;
12046 0 : p += l; len -= l; ret += l;
12047 0 : len = s_address_oldlen - s_address_datalen;
12048 : }
12049 : }
12050 : {
12051 : size_t r_address_datalen, r_address_oldlen;
12052 : Der_type r_address_type;
12053 19022 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &r_address_type, 5, &r_address_datalen, &l);
12054 19022 : if (e == 0 && r_address_type != CONS) { e = ASN1_BAD_ID; }
12055 19022 : if(e) {
12056 19022 : (data)->r_address = NULL;
12057 : } else {
12058 0 : (data)->r_address = calloc(1, sizeof(*(data)->r_address));
12059 0 : if ((data)->r_address == NULL) { e = ENOMEM; goto fail; }
12060 0 : p += l; len -= l; ret += l;
12061 0 : r_address_oldlen = len;
12062 0 : if (r_address_datalen > len) { e = ASN1_OVERRUN; goto fail; }
12063 0 : len = r_address_datalen;
12064 0 : e = decode_HostAddress(p, len, (data)->r_address, &l);
12065 0 : if(e) goto fail;
12066 0 : p += l; len -= l; ret += l;
12067 0 : len = r_address_oldlen - r_address_datalen;
12068 : }
12069 : }
12070 19022 : len = Top_Tag_oldlen - Top_Tag_datalen;
12071 : }
12072 19022 : len = Top_oldlen - Top_datalen;
12073 : }
12074 38044 : if(size) *size = ret;
12075 18284 : return 0;
12076 0 : fail:
12077 0 : free_EncKrbCredPart(data);
12078 0 : return e;
12079 : }
12080 :
12081 : void ASN1CALL
12082 38203 : free_EncKrbCredPart(EncKrbCredPart *data)
12083 : {
12084 114609 : while((&(data)->ticket_info)->len){
12085 38203 : free_KrbCredInfo(&(&(data)->ticket_info)->val[(&(data)->ticket_info)->len-1]);
12086 38203 : (&(data)->ticket_info)->len--;
12087 : }
12088 38203 : free((&(data)->ticket_info)->val);
12089 38203 : (&(data)->ticket_info)->val = NULL;
12090 38203 : if((data)->nonce) {
12091 0 : free_krb5int32((data)->nonce);
12092 0 : free((data)->nonce);
12093 0 : (data)->nonce = NULL;
12094 : }
12095 38203 : if((data)->timestamp) {
12096 38203 : free_KerberosTime((data)->timestamp);
12097 38203 : free((data)->timestamp);
12098 38203 : (data)->timestamp = NULL;
12099 : }
12100 38203 : if((data)->usec) {
12101 38203 : free_krb5int32((data)->usec);
12102 38203 : free((data)->usec);
12103 38203 : (data)->usec = NULL;
12104 : }
12105 38203 : if((data)->s_address) {
12106 0 : free_HostAddress((data)->s_address);
12107 0 : free((data)->s_address);
12108 0 : (data)->s_address = NULL;
12109 : }
12110 38203 : if((data)->r_address) {
12111 0 : free_HostAddress((data)->r_address);
12112 0 : free((data)->r_address);
12113 0 : (data)->r_address = NULL;
12114 : }
12115 38203 : }
12116 :
12117 : size_t ASN1CALL
12118 19181 : length_EncKrbCredPart(const EncKrbCredPart *data)
12119 : {
12120 19181 : size_t ret = 0;
12121 : {
12122 19181 : size_t Top_tag_tag_oldret = ret;
12123 19181 : ret = 0;
12124 : {
12125 19181 : size_t ticket_info_tag_tag_oldret = ret;
12126 : int i;
12127 19181 : ret = 0;
12128 38362 : for(i = (&(data)->ticket_info)->len - 1; i >= 0; --i){
12129 19181 : size_t ticket_info_tag_tag_for_oldret = ret;
12130 19181 : ret = 0;
12131 19181 : ret += length_KrbCredInfo(&(&(data)->ticket_info)->val[i]);
12132 19181 : ret += ticket_info_tag_tag_for_oldret;
12133 : }
12134 19181 : ret += ticket_info_tag_tag_oldret;
12135 : }
12136 19181 : ret += 1 + der_length_len (ret);
12137 19181 : ret += 1 + der_length_len (ret);
12138 19181 : ret += Top_tag_tag_oldret;
12139 : }
12140 19181 : if((data)->nonce){
12141 0 : size_t Top_tag_tag_oldret = ret;
12142 0 : ret = 0;
12143 0 : ret += length_krb5int32((data)->nonce);
12144 0 : ret += 1 + der_length_len (ret);
12145 0 : ret += Top_tag_tag_oldret;
12146 : }
12147 19181 : if((data)->timestamp){
12148 19181 : size_t Top_tag_tag_oldret = ret;
12149 19181 : ret = 0;
12150 19181 : ret += length_KerberosTime((data)->timestamp);
12151 19181 : ret += 1 + der_length_len (ret);
12152 19181 : ret += Top_tag_tag_oldret;
12153 : }
12154 19181 : if((data)->usec){
12155 19181 : size_t Top_tag_tag_oldret = ret;
12156 19181 : ret = 0;
12157 19181 : ret += length_krb5int32((data)->usec);
12158 19181 : ret += 1 + der_length_len (ret);
12159 19181 : ret += Top_tag_tag_oldret;
12160 : }
12161 19181 : if((data)->s_address){
12162 0 : size_t Top_tag_tag_oldret = ret;
12163 0 : ret = 0;
12164 0 : ret += length_HostAddress((data)->s_address);
12165 0 : ret += 1 + der_length_len (ret);
12166 0 : ret += Top_tag_tag_oldret;
12167 : }
12168 19181 : if((data)->r_address){
12169 0 : size_t Top_tag_tag_oldret = ret;
12170 0 : ret = 0;
12171 0 : ret += length_HostAddress((data)->r_address);
12172 0 : ret += 1 + der_length_len (ret);
12173 0 : ret += Top_tag_tag_oldret;
12174 : }
12175 19181 : ret += 1 + der_length_len (ret);
12176 19181 : ret += 1 + der_length_len (ret);
12177 19181 : return ret;
12178 : }
12179 :
12180 : int ASN1CALL
12181 0 : copy_EncKrbCredPart(const EncKrbCredPart *from, EncKrbCredPart *to)
12182 : {
12183 0 : memset(to, 0, sizeof(*to));
12184 0 : if(((&(to)->ticket_info)->val = malloc((&(from)->ticket_info)->len * sizeof(*(&(to)->ticket_info)->val))) == NULL && (&(from)->ticket_info)->len != 0)
12185 0 : goto fail;
12186 0 : for((&(to)->ticket_info)->len = 0; (&(to)->ticket_info)->len < (&(from)->ticket_info)->len; (&(to)->ticket_info)->len++){
12187 0 : if(copy_KrbCredInfo(&(&(from)->ticket_info)->val[(&(to)->ticket_info)->len], &(&(to)->ticket_info)->val[(&(to)->ticket_info)->len])) goto fail;
12188 : }
12189 0 : if((from)->nonce) {
12190 0 : (to)->nonce = malloc(sizeof(*(to)->nonce));
12191 0 : if((to)->nonce == NULL) goto fail;
12192 0 : if(copy_krb5int32((from)->nonce, (to)->nonce)) goto fail;
12193 : }else
12194 0 : (to)->nonce = NULL;
12195 0 : if((from)->timestamp) {
12196 0 : (to)->timestamp = malloc(sizeof(*(to)->timestamp));
12197 0 : if((to)->timestamp == NULL) goto fail;
12198 0 : if(copy_KerberosTime((from)->timestamp, (to)->timestamp)) goto fail;
12199 : }else
12200 0 : (to)->timestamp = NULL;
12201 0 : if((from)->usec) {
12202 0 : (to)->usec = malloc(sizeof(*(to)->usec));
12203 0 : if((to)->usec == NULL) goto fail;
12204 0 : if(copy_krb5int32((from)->usec, (to)->usec)) goto fail;
12205 : }else
12206 0 : (to)->usec = NULL;
12207 0 : if((from)->s_address) {
12208 0 : (to)->s_address = malloc(sizeof(*(to)->s_address));
12209 0 : if((to)->s_address == NULL) goto fail;
12210 0 : if(copy_HostAddress((from)->s_address, (to)->s_address)) goto fail;
12211 : }else
12212 0 : (to)->s_address = NULL;
12213 0 : if((from)->r_address) {
12214 0 : (to)->r_address = malloc(sizeof(*(to)->r_address));
12215 0 : if((to)->r_address == NULL) goto fail;
12216 0 : if(copy_HostAddress((from)->r_address, (to)->r_address)) goto fail;
12217 : }else
12218 0 : (to)->r_address = NULL;
12219 0 : return 0;
12220 0 : fail:
12221 0 : free_EncKrbCredPart(to);
12222 0 : return ENOMEM;
12223 : }
12224 :
12225 : int ASN1CALL
12226 29488 : encode_KRB_ERROR(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const KRB_ERROR *data, size_t *size)
12227 : {
12228 29488 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
12229 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
12230 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
12231 :
12232 : /* e-data */
12233 29488 : if((data)->e_data) {
12234 14746 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
12235 14746 : ret = 0;
12236 14746 : e = der_put_octet_string(p, len, (data)->e_data, &l);
12237 14746 : if (e) return e;
12238 14746 : p -= l; len -= l; ret += l;
12239 :
12240 14746 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
12241 14746 : if (e) return e;
12242 14746 : p -= l; len -= l; ret += l;
12243 :
12244 14746 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 12, &l);
12245 14746 : if (e) return e;
12246 14746 : p -= l; len -= l; ret += l;
12247 :
12248 14746 : ret += Top_tag_tag_oldret;
12249 : }
12250 : /* e-text */
12251 29488 : if((data)->e_text) {
12252 27014 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
12253 27014 : ret = 0;
12254 27014 : e = der_put_general_string(p, len, (data)->e_text, &l);
12255 27014 : if (e) return e;
12256 27014 : p -= l; len -= l; ret += l;
12257 :
12258 27014 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_GeneralString, &l);
12259 27014 : if (e) return e;
12260 27014 : p -= l; len -= l; ret += l;
12261 :
12262 27014 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 11, &l);
12263 27014 : if (e) return e;
12264 27014 : p -= l; len -= l; ret += l;
12265 :
12266 27014 : ret += Top_tag_tag_oldret;
12267 : }
12268 : /* sname */
12269 : {
12270 29488 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
12271 29488 : ret = 0;
12272 29488 : e = encode_PrincipalName(p, len, &(data)->sname, &l);
12273 29488 : if (e) return e;
12274 29488 : p -= l; len -= l; ret += l;
12275 :
12276 29488 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 10, &l);
12277 29488 : if (e) return e;
12278 29488 : p -= l; len -= l; ret += l;
12279 :
12280 29488 : ret += Top_tag_tag_oldret;
12281 : }
12282 : /* realm */
12283 : {
12284 29488 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
12285 29488 : ret = 0;
12286 29488 : e = encode_Realm(p, len, &(data)->realm, &l);
12287 29488 : if (e) return e;
12288 29488 : p -= l; len -= l; ret += l;
12289 :
12290 29488 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 9, &l);
12291 29488 : if (e) return e;
12292 29488 : p -= l; len -= l; ret += l;
12293 :
12294 29488 : ret += Top_tag_tag_oldret;
12295 : }
12296 : /* cname */
12297 29488 : if((data)->cname) {
12298 28266 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
12299 28266 : ret = 0;
12300 28266 : e = encode_PrincipalName(p, len, (data)->cname, &l);
12301 28266 : if (e) return e;
12302 28266 : p -= l; len -= l; ret += l;
12303 :
12304 28266 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 8, &l);
12305 28266 : if (e) return e;
12306 28266 : p -= l; len -= l; ret += l;
12307 :
12308 28266 : ret += Top_tag_tag_oldret;
12309 : }
12310 : /* crealm */
12311 29488 : if((data)->crealm) {
12312 28549 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
12313 28549 : ret = 0;
12314 28549 : e = encode_Realm(p, len, (data)->crealm, &l);
12315 28549 : if (e) return e;
12316 28549 : p -= l; len -= l; ret += l;
12317 :
12318 28549 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 7, &l);
12319 28549 : if (e) return e;
12320 28549 : p -= l; len -= l; ret += l;
12321 :
12322 28549 : ret += Top_tag_tag_oldret;
12323 : }
12324 : /* error-code */
12325 : {
12326 29488 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
12327 29488 : ret = 0;
12328 29488 : e = encode_krb5int32(p, len, &(data)->error_code, &l);
12329 29488 : if (e) return e;
12330 29488 : p -= l; len -= l; ret += l;
12331 :
12332 29488 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 6, &l);
12333 29488 : if (e) return e;
12334 29488 : p -= l; len -= l; ret += l;
12335 :
12336 29488 : ret += Top_tag_tag_oldret;
12337 : }
12338 : /* susec */
12339 : {
12340 29488 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
12341 29488 : ret = 0;
12342 29488 : e = encode_krb5int32(p, len, &(data)->susec, &l);
12343 29488 : if (e) return e;
12344 29488 : p -= l; len -= l; ret += l;
12345 :
12346 29488 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 5, &l);
12347 29488 : if (e) return e;
12348 29488 : p -= l; len -= l; ret += l;
12349 :
12350 29488 : ret += Top_tag_tag_oldret;
12351 : }
12352 : /* stime */
12353 : {
12354 29488 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
12355 29488 : ret = 0;
12356 29488 : e = encode_KerberosTime(p, len, &(data)->stime, &l);
12357 29488 : if (e) return e;
12358 29488 : p -= l; len -= l; ret += l;
12359 :
12360 29488 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 4, &l);
12361 29488 : if (e) return e;
12362 29488 : p -= l; len -= l; ret += l;
12363 :
12364 29488 : ret += Top_tag_tag_oldret;
12365 : }
12366 : /* cusec */
12367 29488 : if((data)->cusec) {
12368 932 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
12369 932 : ret = 0;
12370 932 : e = encode_krb5int32(p, len, (data)->cusec, &l);
12371 932 : if (e) return e;
12372 932 : p -= l; len -= l; ret += l;
12373 :
12374 932 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
12375 932 : if (e) return e;
12376 932 : p -= l; len -= l; ret += l;
12377 :
12378 932 : ret += Top_tag_tag_oldret;
12379 : }
12380 : /* ctime */
12381 29488 : if((data)->ctime) {
12382 932 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
12383 932 : ret = 0;
12384 932 : e = encode_KerberosTime(p, len, (data)->ctime, &l);
12385 932 : if (e) return e;
12386 932 : p -= l; len -= l; ret += l;
12387 :
12388 932 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
12389 932 : if (e) return e;
12390 932 : p -= l; len -= l; ret += l;
12391 :
12392 932 : ret += Top_tag_tag_oldret;
12393 : }
12394 : /* msg-type */
12395 : {
12396 29488 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
12397 29488 : ret = 0;
12398 29488 : e = encode_MESSAGE_TYPE(p, len, &(data)->msg_type, &l);
12399 29488 : if (e) return e;
12400 29488 : p -= l; len -= l; ret += l;
12401 :
12402 29488 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
12403 29488 : if (e) return e;
12404 29488 : p -= l; len -= l; ret += l;
12405 :
12406 29488 : ret += Top_tag_tag_oldret;
12407 : }
12408 : /* pvno */
12409 : {
12410 29488 : size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
12411 29488 : ret = 0;
12412 29488 : e = encode_krb5int32(p, len, &(data)->pvno, &l);
12413 29488 : if (e) return e;
12414 29488 : p -= l; len -= l; ret += l;
12415 :
12416 29488 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
12417 29488 : if (e) return e;
12418 29488 : p -= l; len -= l; ret += l;
12419 :
12420 29488 : ret += Top_tag_tag_oldret;
12421 : }
12422 29488 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
12423 29488 : if (e) return e;
12424 29488 : p -= l; len -= l; ret += l;
12425 :
12426 29488 : e = der_put_length_and_tag (p, len, ret, ASN1_C_APPL, CONS, 30, &l);
12427 29488 : if (e) return e;
12428 29488 : p -= l; len -= l; ret += l;
12429 :
12430 29488 : *size = ret;
12431 29488 : return 0;
12432 : }
12433 :
12434 : int ASN1CALL
12435 110613 : decode_KRB_ERROR(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, KRB_ERROR *data, size_t *size)
12436 : {
12437 110613 : size_t ret = 0;
12438 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
12439 : int e HEIMDAL_UNUSED_ATTRIBUTE;
12440 :
12441 110613 : memset(data, 0, sizeof(*data));
12442 : {
12443 : size_t Top_datalen, Top_oldlen;
12444 : Der_type Top_type;
12445 110613 : e = der_match_tag_and_length(p, len, ASN1_C_APPL, &Top_type, 30, &Top_datalen, &l);
12446 110613 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
12447 167908 : if(e) goto fail;
12448 51934 : p += l; len -= l; ret += l;
12449 51934 : Top_oldlen = len;
12450 51934 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
12451 51934 : len = Top_datalen;
12452 : {
12453 : size_t Top_Tag_datalen, Top_Tag_oldlen;
12454 : Der_type Top_Tag_type;
12455 51934 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_Tag_type, UT_Sequence, &Top_Tag_datalen, &l);
12456 51934 : if (e == 0 && Top_Tag_type != CONS) { e = ASN1_BAD_ID; }
12457 51934 : if(e) goto fail;
12458 51934 : p += l; len -= l; ret += l;
12459 51934 : Top_Tag_oldlen = len;
12460 51934 : if (Top_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
12461 51934 : len = Top_Tag_datalen;
12462 : {
12463 : size_t pvno_datalen, pvno_oldlen;
12464 : Der_type pvno_type;
12465 51934 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &pvno_type, 0, &pvno_datalen, &l);
12466 51934 : if (e == 0 && pvno_type != CONS) { e = ASN1_BAD_ID; }
12467 51934 : if(e) goto fail;
12468 51934 : p += l; len -= l; ret += l;
12469 51934 : pvno_oldlen = len;
12470 51934 : if (pvno_datalen > len) { e = ASN1_OVERRUN; goto fail; }
12471 51934 : len = pvno_datalen;
12472 51934 : e = decode_krb5int32(p, len, &(data)->pvno, &l);
12473 51934 : if(e) goto fail;
12474 51934 : p += l; len -= l; ret += l;
12475 51934 : len = pvno_oldlen - pvno_datalen;
12476 : }
12477 : {
12478 : size_t msg_type_datalen, msg_type_oldlen;
12479 : Der_type msg_type_type;
12480 51934 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &msg_type_type, 1, &msg_type_datalen, &l);
12481 102983 : if (e == 0 && msg_type_type != CONS) { e = ASN1_BAD_ID; }
12482 51934 : if(e) goto fail;
12483 51934 : p += l; len -= l; ret += l;
12484 51934 : msg_type_oldlen = len;
12485 51934 : if (msg_type_datalen > len) { e = ASN1_OVERRUN; goto fail; }
12486 51934 : len = msg_type_datalen;
12487 51934 : e = decode_MESSAGE_TYPE(p, len, &(data)->msg_type, &l);
12488 51934 : if(e) goto fail;
12489 51934 : p += l; len -= l; ret += l;
12490 51934 : len = msg_type_oldlen - msg_type_datalen;
12491 : }
12492 : {
12493 : size_t ctime_datalen, ctime_oldlen;
12494 : Der_type ctime_type;
12495 51934 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &ctime_type, 2, &ctime_datalen, &l);
12496 54402 : if (e == 0 && ctime_type != CONS) { e = ASN1_BAD_ID; }
12497 51934 : if(e) {
12498 49466 : (data)->ctime = NULL;
12499 : } else {
12500 2468 : (data)->ctime = calloc(1, sizeof(*(data)->ctime));
12501 2468 : if ((data)->ctime == NULL) { e = ENOMEM; goto fail; }
12502 2468 : p += l; len -= l; ret += l;
12503 2468 : ctime_oldlen = len;
12504 2468 : if (ctime_datalen > len) { e = ASN1_OVERRUN; goto fail; }
12505 2468 : len = ctime_datalen;
12506 2468 : e = decode_KerberosTime(p, len, (data)->ctime, &l);
12507 2468 : if(e) goto fail;
12508 2468 : p += l; len -= l; ret += l;
12509 2468 : len = ctime_oldlen - ctime_datalen;
12510 : }
12511 : }
12512 : {
12513 : size_t cusec_datalen, cusec_oldlen;
12514 : Der_type cusec_type;
12515 51934 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &cusec_type, 3, &cusec_datalen, &l);
12516 54402 : if (e == 0 && cusec_type != CONS) { e = ASN1_BAD_ID; }
12517 51934 : if(e) {
12518 49466 : (data)->cusec = NULL;
12519 : } else {
12520 2468 : (data)->cusec = calloc(1, sizeof(*(data)->cusec));
12521 2468 : if ((data)->cusec == NULL) { e = ENOMEM; goto fail; }
12522 2468 : p += l; len -= l; ret += l;
12523 2468 : cusec_oldlen = len;
12524 2468 : if (cusec_datalen > len) { e = ASN1_OVERRUN; goto fail; }
12525 2468 : len = cusec_datalen;
12526 2468 : e = decode_krb5int32(p, len, (data)->cusec, &l);
12527 2468 : if(e) goto fail;
12528 2468 : p += l; len -= l; ret += l;
12529 2468 : len = cusec_oldlen - cusec_datalen;
12530 : }
12531 : }
12532 : {
12533 : size_t stime_datalen, stime_oldlen;
12534 : Der_type stime_type;
12535 51934 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &stime_type, 4, &stime_datalen, &l);
12536 103868 : if (e == 0 && stime_type != CONS) { e = ASN1_BAD_ID; }
12537 51934 : if(e) goto fail;
12538 51934 : p += l; len -= l; ret += l;
12539 51934 : stime_oldlen = len;
12540 51934 : if (stime_datalen > len) { e = ASN1_OVERRUN; goto fail; }
12541 51934 : len = stime_datalen;
12542 51934 : e = decode_KerberosTime(p, len, &(data)->stime, &l);
12543 51934 : if(e) goto fail;
12544 51934 : p += l; len -= l; ret += l;
12545 51934 : len = stime_oldlen - stime_datalen;
12546 : }
12547 : {
12548 : size_t susec_datalen, susec_oldlen;
12549 : Der_type susec_type;
12550 51934 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &susec_type, 5, &susec_datalen, &l);
12551 102983 : if (e == 0 && susec_type != CONS) { e = ASN1_BAD_ID; }
12552 51934 : if(e) goto fail;
12553 51934 : p += l; len -= l; ret += l;
12554 51934 : susec_oldlen = len;
12555 51934 : if (susec_datalen > len) { e = ASN1_OVERRUN; goto fail; }
12556 51934 : len = susec_datalen;
12557 51934 : e = decode_krb5int32(p, len, &(data)->susec, &l);
12558 51934 : if(e) goto fail;
12559 51934 : p += l; len -= l; ret += l;
12560 51934 : len = susec_oldlen - susec_datalen;
12561 : }
12562 : {
12563 : size_t error_code_datalen, error_code_oldlen;
12564 : Der_type error_code_type;
12565 51934 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &error_code_type, 6, &error_code_datalen, &l);
12566 102983 : if (e == 0 && error_code_type != CONS) { e = ASN1_BAD_ID; }
12567 51934 : if(e) goto fail;
12568 51934 : p += l; len -= l; ret += l;
12569 51934 : error_code_oldlen = len;
12570 51934 : if (error_code_datalen > len) { e = ASN1_OVERRUN; goto fail; }
12571 51934 : len = error_code_datalen;
12572 51934 : e = decode_krb5int32(p, len, &(data)->error_code, &l);
12573 51934 : if(e) goto fail;
12574 51934 : p += l; len -= l; ret += l;
12575 51934 : len = error_code_oldlen - error_code_datalen;
12576 : }
12577 : {
12578 : size_t crealm_datalen, crealm_oldlen;
12579 : Der_type crealm_type;
12580 51934 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &crealm_type, 7, &crealm_datalen, &l);
12581 100515 : if (e == 0 && crealm_type != CONS) { e = ASN1_BAD_ID; }
12582 51934 : if(e) {
12583 2468 : (data)->crealm = NULL;
12584 : } else {
12585 49466 : (data)->crealm = calloc(1, sizeof(*(data)->crealm));
12586 49466 : if ((data)->crealm == NULL) { e = ENOMEM; goto fail; }
12587 49466 : p += l; len -= l; ret += l;
12588 49466 : crealm_oldlen = len;
12589 49466 : if (crealm_datalen > len) { e = ASN1_OVERRUN; goto fail; }
12590 49466 : len = crealm_datalen;
12591 49466 : e = decode_Realm(p, len, (data)->crealm, &l);
12592 49466 : if(e) goto fail;
12593 49466 : p += l; len -= l; ret += l;
12594 49466 : len = crealm_oldlen - crealm_datalen;
12595 : }
12596 : }
12597 : {
12598 : size_t cname_datalen, cname_oldlen;
12599 : Der_type cname_type;
12600 51934 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &cname_type, 8, &cname_datalen, &l);
12601 100636 : if (e == 0 && cname_type != CONS) { e = ASN1_BAD_ID; }
12602 51934 : if(e) {
12603 3232 : (data)->cname = NULL;
12604 : } else {
12605 48702 : (data)->cname = calloc(1, sizeof(*(data)->cname));
12606 48702 : if ((data)->cname == NULL) { e = ENOMEM; goto fail; }
12607 48702 : p += l; len -= l; ret += l;
12608 48702 : cname_oldlen = len;
12609 48702 : if (cname_datalen > len) { e = ASN1_OVERRUN; goto fail; }
12610 48702 : len = cname_datalen;
12611 48702 : e = decode_PrincipalName(p, len, (data)->cname, &l);
12612 48702 : if(e) goto fail;
12613 48702 : p += l; len -= l; ret += l;
12614 48702 : len = cname_oldlen - cname_datalen;
12615 : }
12616 : }
12617 : {
12618 : size_t realm_datalen, realm_oldlen;
12619 : Der_type realm_type;
12620 51934 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &realm_type, 9, &realm_datalen, &l);
12621 103868 : if (e == 0 && realm_type != CONS) { e = ASN1_BAD_ID; }
12622 51934 : if(e) goto fail;
12623 51934 : p += l; len -= l; ret += l;
12624 51934 : realm_oldlen = len;
12625 51934 : if (realm_datalen > len) { e = ASN1_OVERRUN; goto fail; }
12626 51934 : len = realm_datalen;
12627 51934 : e = decode_Realm(p, len, &(data)->realm, &l);
12628 51934 : if(e) goto fail;
12629 51934 : p += l; len -= l; ret += l;
12630 51934 : len = realm_oldlen - realm_datalen;
12631 : }
12632 : {
12633 : size_t sname_datalen, sname_oldlen;
12634 : Der_type sname_type;
12635 51934 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &sname_type, 10, &sname_datalen, &l);
12636 102983 : if (e == 0 && sname_type != CONS) { e = ASN1_BAD_ID; }
12637 51934 : if(e) goto fail;
12638 51934 : p += l; len -= l; ret += l;
12639 51934 : sname_oldlen = len;
12640 51934 : if (sname_datalen > len) { e = ASN1_OVERRUN; goto fail; }
12641 51934 : len = sname_datalen;
12642 51934 : e = decode_PrincipalName(p, len, &(data)->sname, &l);
12643 51934 : if(e) goto fail;
12644 51934 : p += l; len -= l; ret += l;
12645 51934 : len = sname_oldlen - sname_datalen;
12646 : }
12647 : {
12648 : size_t e_text_datalen, e_text_oldlen;
12649 : Der_type e_text_type;
12650 51934 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &e_text_type, 11, &e_text_datalen, &l);
12651 96400 : if (e == 0 && e_text_type != CONS) { e = ASN1_BAD_ID; }
12652 51934 : if(e) {
12653 6583 : (data)->e_text = NULL;
12654 : } else {
12655 45351 : (data)->e_text = calloc(1, sizeof(*(data)->e_text));
12656 45351 : if ((data)->e_text == NULL) { e = ENOMEM; goto fail; }
12657 45351 : p += l; len -= l; ret += l;
12658 45351 : e_text_oldlen = len;
12659 45351 : if (e_text_datalen > len) { e = ASN1_OVERRUN; goto fail; }
12660 45351 : len = e_text_datalen;
12661 : {
12662 : size_t e_text_Tag_datalen, e_text_Tag_oldlen;
12663 : Der_type e_text_Tag_type;
12664 45351 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &e_text_Tag_type, UT_GeneralString, &e_text_Tag_datalen, &l);
12665 45351 : if (e == 0 && e_text_Tag_type != PRIM) { e = ASN1_BAD_ID; }
12666 45351 : if(e) goto fail;
12667 45351 : p += l; len -= l; ret += l;
12668 45351 : e_text_Tag_oldlen = len;
12669 45351 : if (e_text_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
12670 45351 : len = e_text_Tag_datalen;
12671 45351 : e = der_get_general_string(p, len, (data)->e_text, &l);
12672 45351 : if(e) goto fail;
12673 45351 : p += l; len -= l; ret += l;
12674 45351 : len = e_text_Tag_oldlen - e_text_Tag_datalen;
12675 : }
12676 45351 : len = e_text_oldlen - e_text_datalen;
12677 : }
12678 : }
12679 : {
12680 : size_t e_data_datalen, e_data_oldlen;
12681 : Der_type e_data_type;
12682 51934 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &e_data_type, 12, &e_data_datalen, &l);
12683 83102 : if (e == 0 && e_data_type != CONS) { e = ASN1_BAD_ID; }
12684 51934 : if(e) {
12685 20766 : (data)->e_data = NULL;
12686 : } else {
12687 31168 : (data)->e_data = calloc(1, sizeof(*(data)->e_data));
12688 31168 : if ((data)->e_data == NULL) { e = ENOMEM; goto fail; }
12689 31168 : p += l; len -= l; ret += l;
12690 31168 : e_data_oldlen = len;
12691 31168 : if (e_data_datalen > len) { e = ASN1_OVERRUN; goto fail; }
12692 31168 : len = e_data_datalen;
12693 : {
12694 : size_t e_data_Tag_datalen, e_data_Tag_oldlen;
12695 : Der_type e_data_Tag_type;
12696 31168 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &e_data_Tag_type, UT_OctetString, &e_data_Tag_datalen, &l);
12697 31168 : if (e == 0 && e_data_Tag_type != PRIM) { e = ASN1_BAD_ID; }
12698 31168 : if(e) goto fail;
12699 31168 : p += l; len -= l; ret += l;
12700 31168 : e_data_Tag_oldlen = len;
12701 31168 : if (e_data_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
12702 31168 : len = e_data_Tag_datalen;
12703 31168 : e = der_get_octet_string(p, len, (data)->e_data, &l);
12704 31168 : if(e) goto fail;
12705 31168 : p += l; len -= l; ret += l;
12706 31168 : len = e_data_Tag_oldlen - e_data_Tag_datalen;
12707 : }
12708 31168 : len = e_data_oldlen - e_data_datalen;
12709 : }
12710 : }
12711 51934 : len = Top_Tag_oldlen - Top_Tag_datalen;
12712 : }
12713 51934 : len = Top_oldlen - Top_datalen;
12714 : }
12715 103868 : if(size) *size = ret;
12716 51049 : return 0;
12717 58679 : fail:
12718 58679 : free_KRB_ERROR(data);
12719 58679 : return e;
12720 : }
12721 :
12722 : void ASN1CALL
12723 171944 : free_KRB_ERROR(KRB_ERROR *data)
12724 : {
12725 171944 : free_krb5int32(&(data)->pvno);
12726 171944 : free_MESSAGE_TYPE(&(data)->msg_type);
12727 171944 : if((data)->ctime) {
12728 1884 : free_KerberosTime((data)->ctime);
12729 1884 : free((data)->ctime);
12730 1884 : (data)->ctime = NULL;
12731 : }
12732 171944 : if((data)->cusec) {
12733 1884 : free_krb5int32((data)->cusec);
12734 1884 : free((data)->cusec);
12735 1884 : (data)->cusec = NULL;
12736 : }
12737 171944 : free_KerberosTime(&(data)->stime);
12738 171944 : free_krb5int32(&(data)->susec);
12739 171944 : free_krb5int32(&(data)->error_code);
12740 171944 : if((data)->crealm) {
12741 49463 : free_Realm((data)->crealm);
12742 49463 : free((data)->crealm);
12743 49463 : (data)->crealm = NULL;
12744 : }
12745 171944 : if((data)->cname) {
12746 48699 : free_PrincipalName((data)->cname);
12747 48699 : free((data)->cname);
12748 48699 : (data)->cname = NULL;
12749 : }
12750 171944 : free_Realm(&(data)->realm);
12751 171944 : free_PrincipalName(&(data)->sname);
12752 171944 : if((data)->e_text) {
12753 45351 : der_free_general_string((data)->e_text);
12754 45351 : free((data)->e_text);
12755 45351 : (data)->e_text = NULL;
12756 : }
12757 171944 : if((data)->e_data) {
12758 31168 : der_free_octet_string((data)->e_data);
12759 31168 : free((data)->e_data);
12760 31168 : (data)->e_data = NULL;
12761 : }
12762 171944 : }
12763 :
12764 : size_t ASN1CALL
12765 29488 : length_KRB_ERROR(const KRB_ERROR *data)
12766 : {
12767 29488 : size_t ret = 0;
12768 : {
12769 29488 : size_t Top_tag_tag_oldret = ret;
12770 29488 : ret = 0;
12771 29488 : ret += length_krb5int32(&(data)->pvno);
12772 29488 : ret += 1 + der_length_len (ret);
12773 29488 : ret += Top_tag_tag_oldret;
12774 : }
12775 : {
12776 29488 : size_t Top_tag_tag_oldret = ret;
12777 29488 : ret = 0;
12778 29488 : ret += length_MESSAGE_TYPE(&(data)->msg_type);
12779 29488 : ret += 1 + der_length_len (ret);
12780 29488 : ret += Top_tag_tag_oldret;
12781 : }
12782 29488 : if((data)->ctime){
12783 932 : size_t Top_tag_tag_oldret = ret;
12784 932 : ret = 0;
12785 932 : ret += length_KerberosTime((data)->ctime);
12786 932 : ret += 1 + der_length_len (ret);
12787 932 : ret += Top_tag_tag_oldret;
12788 : }
12789 29488 : if((data)->cusec){
12790 932 : size_t Top_tag_tag_oldret = ret;
12791 932 : ret = 0;
12792 932 : ret += length_krb5int32((data)->cusec);
12793 932 : ret += 1 + der_length_len (ret);
12794 932 : ret += Top_tag_tag_oldret;
12795 : }
12796 : {
12797 29488 : size_t Top_tag_tag_oldret = ret;
12798 29488 : ret = 0;
12799 29488 : ret += length_KerberosTime(&(data)->stime);
12800 29488 : ret += 1 + der_length_len (ret);
12801 29488 : ret += Top_tag_tag_oldret;
12802 : }
12803 : {
12804 29488 : size_t Top_tag_tag_oldret = ret;
12805 29488 : ret = 0;
12806 29488 : ret += length_krb5int32(&(data)->susec);
12807 29488 : ret += 1 + der_length_len (ret);
12808 29488 : ret += Top_tag_tag_oldret;
12809 : }
12810 : {
12811 29488 : size_t Top_tag_tag_oldret = ret;
12812 29488 : ret = 0;
12813 29488 : ret += length_krb5int32(&(data)->error_code);
12814 29488 : ret += 1 + der_length_len (ret);
12815 29488 : ret += Top_tag_tag_oldret;
12816 : }
12817 29488 : if((data)->crealm){
12818 28549 : size_t Top_tag_tag_oldret = ret;
12819 28549 : ret = 0;
12820 28549 : ret += length_Realm((data)->crealm);
12821 28549 : ret += 1 + der_length_len (ret);
12822 28549 : ret += Top_tag_tag_oldret;
12823 : }
12824 29488 : if((data)->cname){
12825 28266 : size_t Top_tag_tag_oldret = ret;
12826 28266 : ret = 0;
12827 28266 : ret += length_PrincipalName((data)->cname);
12828 28266 : ret += 1 + der_length_len (ret);
12829 28266 : ret += Top_tag_tag_oldret;
12830 : }
12831 : {
12832 29488 : size_t Top_tag_tag_oldret = ret;
12833 29488 : ret = 0;
12834 29488 : ret += length_Realm(&(data)->realm);
12835 29488 : ret += 1 + der_length_len (ret);
12836 29488 : ret += Top_tag_tag_oldret;
12837 : }
12838 : {
12839 29488 : size_t Top_tag_tag_oldret = ret;
12840 29488 : ret = 0;
12841 29488 : ret += length_PrincipalName(&(data)->sname);
12842 29488 : ret += 1 + der_length_len (ret);
12843 29488 : ret += Top_tag_tag_oldret;
12844 : }
12845 29488 : if((data)->e_text){
12846 27014 : size_t Top_tag_tag_oldret = ret;
12847 27014 : ret = 0;
12848 27014 : ret += der_length_general_string((data)->e_text);
12849 27014 : ret += 1 + der_length_len (ret);
12850 27014 : ret += 1 + der_length_len (ret);
12851 27014 : ret += Top_tag_tag_oldret;
12852 : }
12853 29488 : if((data)->e_data){
12854 14746 : size_t Top_tag_tag_oldret = ret;
12855 14746 : ret = 0;
12856 14746 : ret += der_length_octet_string((data)->e_data);
12857 14746 : ret += 1 + der_length_len (ret);
12858 14746 : ret += 1 + der_length_len (ret);
12859 14746 : ret += Top_tag_tag_oldret;
12860 : }
12861 29488 : ret += 1 + der_length_len (ret);
12862 29488 : ret += 1 + der_length_len (ret);
12863 29488 : return ret;
12864 : }
12865 :
12866 : int ASN1CALL
12867 0 : copy_KRB_ERROR(const KRB_ERROR *from, KRB_ERROR *to)
12868 : {
12869 0 : memset(to, 0, sizeof(*to));
12870 0 : if(copy_krb5int32(&(from)->pvno, &(to)->pvno)) goto fail;
12871 0 : if(copy_MESSAGE_TYPE(&(from)->msg_type, &(to)->msg_type)) goto fail;
12872 0 : if((from)->ctime) {
12873 0 : (to)->ctime = malloc(sizeof(*(to)->ctime));
12874 0 : if((to)->ctime == NULL) goto fail;
12875 0 : if(copy_KerberosTime((from)->ctime, (to)->ctime)) goto fail;
12876 : }else
12877 0 : (to)->ctime = NULL;
12878 0 : if((from)->cusec) {
12879 0 : (to)->cusec = malloc(sizeof(*(to)->cusec));
12880 0 : if((to)->cusec == NULL) goto fail;
12881 0 : if(copy_krb5int32((from)->cusec, (to)->cusec)) goto fail;
12882 : }else
12883 0 : (to)->cusec = NULL;
12884 0 : if(copy_KerberosTime(&(from)->stime, &(to)->stime)) goto fail;
12885 0 : if(copy_krb5int32(&(from)->susec, &(to)->susec)) goto fail;
12886 0 : if(copy_krb5int32(&(from)->error_code, &(to)->error_code)) goto fail;
12887 0 : if((from)->crealm) {
12888 0 : (to)->crealm = malloc(sizeof(*(to)->crealm));
12889 0 : if((to)->crealm == NULL) goto fail;
12890 0 : if(copy_Realm((from)->crealm, (to)->crealm)) goto fail;
12891 : }else
12892 0 : (to)->crealm = NULL;
12893 0 : if((from)->cname) {
12894 0 : (to)->cname = malloc(sizeof(*(to)->cname));
12895 0 : if((to)->cname == NULL) goto fail;
12896 0 : if(copy_PrincipalName((from)->cname, (to)->cname)) goto fail;
12897 : }else
12898 0 : (to)->cname = NULL;
12899 0 : if(copy_Realm(&(from)->realm, &(to)->realm)) goto fail;
12900 0 : if(copy_PrincipalName(&(from)->sname, &(to)->sname)) goto fail;
12901 0 : if((from)->e_text) {
12902 0 : (to)->e_text = malloc(sizeof(*(to)->e_text));
12903 0 : if((to)->e_text == NULL) goto fail;
12904 0 : if(der_copy_general_string((from)->e_text, (to)->e_text)) goto fail;
12905 : }else
12906 0 : (to)->e_text = NULL;
12907 0 : if((from)->e_data) {
12908 0 : (to)->e_data = malloc(sizeof(*(to)->e_data));
12909 0 : if((to)->e_data == NULL) goto fail;
12910 0 : if(der_copy_octet_string((from)->e_data, (to)->e_data)) goto fail;
12911 : }else
12912 0 : (to)->e_data = NULL;
12913 0 : return 0;
12914 0 : fail:
12915 0 : free_KRB_ERROR(to);
12916 0 : return ENOMEM;
12917 : }
12918 :
12919 : int ASN1CALL
12920 21 : encode_ChangePasswdDataMS(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const ChangePasswdDataMS *data, size_t *size)
12921 : {
12922 21 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
12923 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
12924 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
12925 :
12926 : /* targrealm */
12927 21 : if((data)->targrealm) {
12928 21 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
12929 21 : ret = 0;
12930 21 : e = encode_Realm(p, len, (data)->targrealm, &l);
12931 21 : if (e) return e;
12932 21 : p -= l; len -= l; ret += l;
12933 :
12934 21 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
12935 21 : if (e) return e;
12936 21 : p -= l; len -= l; ret += l;
12937 :
12938 21 : ret += Top_tag_oldret;
12939 : }
12940 : /* targname */
12941 21 : if((data)->targname) {
12942 21 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
12943 21 : ret = 0;
12944 21 : e = encode_PrincipalName(p, len, (data)->targname, &l);
12945 21 : if (e) return e;
12946 21 : p -= l; len -= l; ret += l;
12947 :
12948 21 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
12949 21 : if (e) return e;
12950 21 : p -= l; len -= l; ret += l;
12951 :
12952 21 : ret += Top_tag_oldret;
12953 : }
12954 : /* newpasswd */
12955 : {
12956 21 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
12957 21 : ret = 0;
12958 21 : e = der_put_octet_string(p, len, &(data)->newpasswd, &l);
12959 21 : if (e) return e;
12960 21 : p -= l; len -= l; ret += l;
12961 :
12962 21 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
12963 21 : if (e) return e;
12964 21 : p -= l; len -= l; ret += l;
12965 :
12966 21 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
12967 21 : if (e) return e;
12968 21 : p -= l; len -= l; ret += l;
12969 :
12970 21 : ret += Top_tag_oldret;
12971 : }
12972 21 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
12973 21 : if (e) return e;
12974 21 : p -= l; len -= l; ret += l;
12975 :
12976 21 : *size = ret;
12977 21 : return 0;
12978 : }
12979 :
12980 : int ASN1CALL
12981 21 : decode_ChangePasswdDataMS(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, ChangePasswdDataMS *data, size_t *size)
12982 : {
12983 21 : size_t ret = 0;
12984 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
12985 : int e HEIMDAL_UNUSED_ATTRIBUTE;
12986 :
12987 21 : memset(data, 0, sizeof(*data));
12988 : {
12989 : size_t Top_datalen, Top_oldlen;
12990 : Der_type Top_type;
12991 21 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
12992 21 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
12993 21 : if(e) goto fail;
12994 21 : p += l; len -= l; ret += l;
12995 21 : Top_oldlen = len;
12996 21 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
12997 21 : len = Top_datalen;
12998 : {
12999 : size_t newpasswd_datalen, newpasswd_oldlen;
13000 : Der_type newpasswd_type;
13001 21 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &newpasswd_type, 0, &newpasswd_datalen, &l);
13002 21 : if (e == 0 && newpasswd_type != CONS) { e = ASN1_BAD_ID; }
13003 21 : if(e) goto fail;
13004 21 : p += l; len -= l; ret += l;
13005 21 : newpasswd_oldlen = len;
13006 21 : if (newpasswd_datalen > len) { e = ASN1_OVERRUN; goto fail; }
13007 21 : len = newpasswd_datalen;
13008 : {
13009 : size_t newpasswd_Tag_datalen, newpasswd_Tag_oldlen;
13010 : Der_type newpasswd_Tag_type;
13011 21 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &newpasswd_Tag_type, UT_OctetString, &newpasswd_Tag_datalen, &l);
13012 21 : if (e == 0 && newpasswd_Tag_type != PRIM) { e = ASN1_BAD_ID; }
13013 21 : if(e) goto fail;
13014 21 : p += l; len -= l; ret += l;
13015 21 : newpasswd_Tag_oldlen = len;
13016 21 : if (newpasswd_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
13017 21 : len = newpasswd_Tag_datalen;
13018 21 : e = der_get_octet_string(p, len, &(data)->newpasswd, &l);
13019 21 : if(e) goto fail;
13020 21 : p += l; len -= l; ret += l;
13021 21 : len = newpasswd_Tag_oldlen - newpasswd_Tag_datalen;
13022 : }
13023 21 : len = newpasswd_oldlen - newpasswd_datalen;
13024 : }
13025 : {
13026 : size_t targname_datalen, targname_oldlen;
13027 : Der_type targname_type;
13028 21 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &targname_type, 1, &targname_datalen, &l);
13029 42 : if (e == 0 && targname_type != CONS) { e = ASN1_BAD_ID; }
13030 21 : if(e) {
13031 0 : (data)->targname = NULL;
13032 : } else {
13033 21 : (data)->targname = calloc(1, sizeof(*(data)->targname));
13034 21 : if ((data)->targname == NULL) { e = ENOMEM; goto fail; }
13035 21 : p += l; len -= l; ret += l;
13036 21 : targname_oldlen = len;
13037 21 : if (targname_datalen > len) { e = ASN1_OVERRUN; goto fail; }
13038 21 : len = targname_datalen;
13039 21 : e = decode_PrincipalName(p, len, (data)->targname, &l);
13040 21 : if(e) goto fail;
13041 21 : p += l; len -= l; ret += l;
13042 21 : len = targname_oldlen - targname_datalen;
13043 : }
13044 : }
13045 : {
13046 : size_t targrealm_datalen, targrealm_oldlen;
13047 : Der_type targrealm_type;
13048 21 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &targrealm_type, 2, &targrealm_datalen, &l);
13049 42 : if (e == 0 && targrealm_type != CONS) { e = ASN1_BAD_ID; }
13050 21 : if(e) {
13051 0 : (data)->targrealm = NULL;
13052 : } else {
13053 21 : (data)->targrealm = calloc(1, sizeof(*(data)->targrealm));
13054 21 : if ((data)->targrealm == NULL) { e = ENOMEM; goto fail; }
13055 21 : p += l; len -= l; ret += l;
13056 21 : targrealm_oldlen = len;
13057 21 : if (targrealm_datalen > len) { e = ASN1_OVERRUN; goto fail; }
13058 21 : len = targrealm_datalen;
13059 21 : e = decode_Realm(p, len, (data)->targrealm, &l);
13060 21 : if(e) goto fail;
13061 21 : p += l; len -= l; ret += l;
13062 21 : len = targrealm_oldlen - targrealm_datalen;
13063 : }
13064 : }
13065 21 : len = Top_oldlen - Top_datalen;
13066 : }
13067 42 : if(size) *size = ret;
13068 21 : return 0;
13069 0 : fail:
13070 0 : free_ChangePasswdDataMS(data);
13071 0 : return e;
13072 : }
13073 :
13074 : void ASN1CALL
13075 21 : free_ChangePasswdDataMS(ChangePasswdDataMS *data)
13076 : {
13077 21 : der_free_octet_string(&(data)->newpasswd);
13078 21 : if((data)->targname) {
13079 21 : free_PrincipalName((data)->targname);
13080 21 : free((data)->targname);
13081 21 : (data)->targname = NULL;
13082 : }
13083 21 : if((data)->targrealm) {
13084 21 : free_Realm((data)->targrealm);
13085 21 : free((data)->targrealm);
13086 21 : (data)->targrealm = NULL;
13087 : }
13088 21 : }
13089 :
13090 : size_t ASN1CALL
13091 21 : length_ChangePasswdDataMS(const ChangePasswdDataMS *data)
13092 : {
13093 21 : size_t ret = 0;
13094 : {
13095 21 : size_t Top_tag_oldret = ret;
13096 21 : ret = 0;
13097 21 : ret += der_length_octet_string(&(data)->newpasswd);
13098 21 : ret += 1 + der_length_len (ret);
13099 21 : ret += 1 + der_length_len (ret);
13100 21 : ret += Top_tag_oldret;
13101 : }
13102 21 : if((data)->targname){
13103 21 : size_t Top_tag_oldret = ret;
13104 21 : ret = 0;
13105 21 : ret += length_PrincipalName((data)->targname);
13106 21 : ret += 1 + der_length_len (ret);
13107 21 : ret += Top_tag_oldret;
13108 : }
13109 21 : if((data)->targrealm){
13110 21 : size_t Top_tag_oldret = ret;
13111 21 : ret = 0;
13112 21 : ret += length_Realm((data)->targrealm);
13113 21 : ret += 1 + der_length_len (ret);
13114 21 : ret += Top_tag_oldret;
13115 : }
13116 21 : ret += 1 + der_length_len (ret);
13117 21 : return ret;
13118 : }
13119 :
13120 : int ASN1CALL
13121 0 : copy_ChangePasswdDataMS(const ChangePasswdDataMS *from, ChangePasswdDataMS *to)
13122 : {
13123 0 : memset(to, 0, sizeof(*to));
13124 0 : if(der_copy_octet_string(&(from)->newpasswd, &(to)->newpasswd)) goto fail;
13125 0 : if((from)->targname) {
13126 0 : (to)->targname = malloc(sizeof(*(to)->targname));
13127 0 : if((to)->targname == NULL) goto fail;
13128 0 : if(copy_PrincipalName((from)->targname, (to)->targname)) goto fail;
13129 : }else
13130 0 : (to)->targname = NULL;
13131 0 : if((from)->targrealm) {
13132 0 : (to)->targrealm = malloc(sizeof(*(to)->targrealm));
13133 0 : if((to)->targrealm == NULL) goto fail;
13134 0 : if(copy_Realm((from)->targrealm, (to)->targrealm)) goto fail;
13135 : }else
13136 0 : (to)->targrealm = NULL;
13137 0 : return 0;
13138 0 : fail:
13139 0 : free_ChangePasswdDataMS(to);
13140 0 : return ENOMEM;
13141 : }
13142 :
13143 : int ASN1CALL
13144 20329 : encode_EtypeList(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const EtypeList *data, size_t *size)
13145 : {
13146 20329 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
13147 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
13148 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
13149 :
13150 117420 : for(i = (int)(data)->len - 1; i >= 0; --i) {
13151 97091 : size_t Top_tag_for_oldret = ret;
13152 97091 : ret = 0;
13153 97091 : e = encode_ENCTYPE(p, len, &(data)->val[i], &l);
13154 97091 : if (e) return e;
13155 97091 : p -= l; len -= l; ret += l;
13156 :
13157 97091 : ret += Top_tag_for_oldret;
13158 : }
13159 20329 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
13160 20329 : if (e) return e;
13161 20329 : p -= l; len -= l; ret += l;
13162 :
13163 20329 : *size = ret;
13164 20329 : return 0;
13165 : }
13166 :
13167 : int ASN1CALL
13168 19792 : decode_EtypeList(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, EtypeList *data, size_t *size)
13169 : {
13170 19792 : size_t ret = 0;
13171 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
13172 : int e HEIMDAL_UNUSED_ATTRIBUTE;
13173 :
13174 19792 : memset(data, 0, sizeof(*data));
13175 : {
13176 : size_t Top_datalen, Top_oldlen;
13177 : Der_type Top_type;
13178 19792 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
13179 19792 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
13180 19792 : if(e) goto fail;
13181 19792 : p += l; len -= l; ret += l;
13182 19792 : Top_oldlen = len;
13183 19792 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
13184 19792 : len = Top_datalen;
13185 : {
13186 19792 : size_t Top_Tag_origlen = len;
13187 19792 : size_t Top_Tag_oldret = ret;
13188 19792 : size_t Top_Tag_olen = 0;
13189 : void *Top_Tag_tmp;
13190 19792 : ret = 0;
13191 19792 : (data)->len = 0;
13192 19792 : (data)->val = NULL;
13193 134177 : while(ret < Top_Tag_origlen) {
13194 94593 : size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
13195 94593 : if (Top_Tag_olen > Top_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
13196 94593 : Top_Tag_olen = Top_Tag_nlen;
13197 94593 : Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
13198 94593 : if (Top_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
13199 94593 : (data)->val = Top_Tag_tmp;
13200 94593 : e = decode_ENCTYPE(p, len, &(data)->val[(data)->len], &l);
13201 94593 : if(e) goto fail;
13202 94593 : p += l; len -= l; ret += l;
13203 94593 : (data)->len++;
13204 94593 : len = Top_Tag_origlen - ret;
13205 : }
13206 19792 : ret += Top_Tag_oldret;
13207 : }
13208 19792 : len = Top_oldlen - Top_datalen;
13209 : }
13210 19792 : if(size) *size = ret;
13211 19054 : return 0;
13212 0 : fail:
13213 0 : free_EtypeList(data);
13214 0 : return e;
13215 : }
13216 :
13217 : void ASN1CALL
13218 82486 : free_EtypeList(EtypeList *data)
13219 : {
13220 356656 : while((data)->len){
13221 191684 : free_ENCTYPE(&(data)->val[(data)->len-1]);
13222 191684 : (data)->len--;
13223 : }
13224 82486 : free((data)->val);
13225 82486 : (data)->val = NULL;
13226 82486 : }
13227 :
13228 : size_t ASN1CALL
13229 20329 : length_EtypeList(const EtypeList *data)
13230 : {
13231 20329 : size_t ret = 0;
13232 : {
13233 20329 : size_t Top_tag_oldret = ret;
13234 : int i;
13235 20329 : ret = 0;
13236 117420 : for(i = (data)->len - 1; i >= 0; --i){
13237 97091 : size_t Top_tag_for_oldret = ret;
13238 97091 : ret = 0;
13239 97091 : ret += length_ENCTYPE(&(data)->val[i]);
13240 97091 : ret += Top_tag_for_oldret;
13241 : }
13242 20329 : ret += Top_tag_oldret;
13243 : }
13244 20329 : ret += 1 + der_length_len (ret);
13245 20329 : return ret;
13246 : }
13247 :
13248 : int ASN1CALL
13249 0 : copy_EtypeList(const EtypeList *from, EtypeList *to)
13250 : {
13251 0 : memset(to, 0, sizeof(*to));
13252 0 : if(((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
13253 0 : goto fail;
13254 0 : for((to)->len = 0; (to)->len < (from)->len; (to)->len++){
13255 0 : if(copy_ENCTYPE(&(from)->val[(to)->len], &(to)->val[(to)->len])) goto fail;
13256 : }
13257 0 : return 0;
13258 0 : fail:
13259 0 : free_EtypeList(to);
13260 0 : return ENOMEM;
13261 : }
13262 :
13263 : int ASN1CALL
13264 20329 : encode_AD_IF_RELEVANT(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const AD_IF_RELEVANT *data, size_t *size)
13265 : {
13266 20329 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
13267 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
13268 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
13269 :
13270 20329 : e = encode_AuthorizationData(p, len, data, &l);
13271 20329 : if (e) return e;
13272 20329 : p -= l; len -= l; ret += l;
13273 :
13274 20329 : *size = ret;
13275 20329 : return 0;
13276 : }
13277 :
13278 : int ASN1CALL
13279 19792 : decode_AD_IF_RELEVANT(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, AD_IF_RELEVANT *data, size_t *size)
13280 : {
13281 19792 : size_t ret = 0;
13282 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
13283 : int e HEIMDAL_UNUSED_ATTRIBUTE;
13284 :
13285 19792 : memset(data, 0, sizeof(*data));
13286 19792 : e = decode_AuthorizationData(p, len, data, &l);
13287 19792 : if(e) goto fail;
13288 19792 : p += l; len -= l; ret += l;
13289 19792 : if(size) *size = ret;
13290 19054 : return 0;
13291 0 : fail:
13292 0 : free_AD_IF_RELEVANT(data);
13293 0 : return e;
13294 : }
13295 :
13296 : void ASN1CALL
13297 19792 : free_AD_IF_RELEVANT(AD_IF_RELEVANT *data)
13298 : {
13299 19792 : free_AuthorizationData(data);
13300 19792 : }
13301 :
13302 : size_t ASN1CALL
13303 20329 : length_AD_IF_RELEVANT(const AD_IF_RELEVANT *data)
13304 : {
13305 20329 : size_t ret = 0;
13306 20329 : ret += length_AuthorizationData(data);
13307 20329 : return ret;
13308 : }
13309 :
13310 : int ASN1CALL
13311 0 : copy_AD_IF_RELEVANT(const AD_IF_RELEVANT *from, AD_IF_RELEVANT *to)
13312 : {
13313 0 : memset(to, 0, sizeof(*to));
13314 0 : if(copy_AuthorizationData(from, to)) goto fail;
13315 0 : return 0;
13316 0 : fail:
13317 0 : free_AD_IF_RELEVANT(to);
13318 0 : return ENOMEM;
13319 : }
13320 :
13321 : int ASN1CALL
13322 0 : encode_AD_KDCIssued(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const AD_KDCIssued *data, size_t *size)
13323 : {
13324 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
13325 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
13326 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
13327 :
13328 : /* elements */
13329 : {
13330 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
13331 0 : ret = 0;
13332 0 : e = encode_AuthorizationData(p, len, &(data)->elements, &l);
13333 0 : if (e) return e;
13334 0 : p -= l; len -= l; ret += l;
13335 :
13336 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
13337 0 : if (e) return e;
13338 0 : p -= l; len -= l; ret += l;
13339 :
13340 0 : ret += Top_tag_oldret;
13341 : }
13342 : /* i-sname */
13343 0 : if((data)->i_sname) {
13344 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
13345 0 : ret = 0;
13346 0 : e = encode_PrincipalName(p, len, (data)->i_sname, &l);
13347 0 : if (e) return e;
13348 0 : p -= l; len -= l; ret += l;
13349 :
13350 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
13351 0 : if (e) return e;
13352 0 : p -= l; len -= l; ret += l;
13353 :
13354 0 : ret += Top_tag_oldret;
13355 : }
13356 : /* i-realm */
13357 0 : if((data)->i_realm) {
13358 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
13359 0 : ret = 0;
13360 0 : e = encode_Realm(p, len, (data)->i_realm, &l);
13361 0 : if (e) return e;
13362 0 : p -= l; len -= l; ret += l;
13363 :
13364 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
13365 0 : if (e) return e;
13366 0 : p -= l; len -= l; ret += l;
13367 :
13368 0 : ret += Top_tag_oldret;
13369 : }
13370 : /* ad-checksum */
13371 : {
13372 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
13373 0 : ret = 0;
13374 0 : e = encode_Checksum(p, len, &(data)->ad_checksum, &l);
13375 0 : if (e) return e;
13376 0 : p -= l; len -= l; ret += l;
13377 :
13378 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
13379 0 : if (e) return e;
13380 0 : p -= l; len -= l; ret += l;
13381 :
13382 0 : ret += Top_tag_oldret;
13383 : }
13384 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
13385 0 : if (e) return e;
13386 0 : p -= l; len -= l; ret += l;
13387 :
13388 0 : *size = ret;
13389 0 : return 0;
13390 : }
13391 :
13392 : int ASN1CALL
13393 0 : decode_AD_KDCIssued(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, AD_KDCIssued *data, size_t *size)
13394 : {
13395 0 : size_t ret = 0;
13396 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
13397 : int e HEIMDAL_UNUSED_ATTRIBUTE;
13398 :
13399 0 : memset(data, 0, sizeof(*data));
13400 : {
13401 : size_t Top_datalen, Top_oldlen;
13402 : Der_type Top_type;
13403 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
13404 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
13405 0 : if(e) goto fail;
13406 0 : p += l; len -= l; ret += l;
13407 0 : Top_oldlen = len;
13408 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
13409 0 : len = Top_datalen;
13410 : {
13411 : size_t ad_checksum_datalen, ad_checksum_oldlen;
13412 : Der_type ad_checksum_type;
13413 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &ad_checksum_type, 0, &ad_checksum_datalen, &l);
13414 0 : if (e == 0 && ad_checksum_type != CONS) { e = ASN1_BAD_ID; }
13415 0 : if(e) goto fail;
13416 0 : p += l; len -= l; ret += l;
13417 0 : ad_checksum_oldlen = len;
13418 0 : if (ad_checksum_datalen > len) { e = ASN1_OVERRUN; goto fail; }
13419 0 : len = ad_checksum_datalen;
13420 0 : e = decode_Checksum(p, len, &(data)->ad_checksum, &l);
13421 0 : if(e) goto fail;
13422 0 : p += l; len -= l; ret += l;
13423 0 : len = ad_checksum_oldlen - ad_checksum_datalen;
13424 : }
13425 : {
13426 : size_t i_realm_datalen, i_realm_oldlen;
13427 : Der_type i_realm_type;
13428 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &i_realm_type, 1, &i_realm_datalen, &l);
13429 0 : if (e == 0 && i_realm_type != CONS) { e = ASN1_BAD_ID; }
13430 0 : if(e) {
13431 0 : (data)->i_realm = NULL;
13432 : } else {
13433 0 : (data)->i_realm = calloc(1, sizeof(*(data)->i_realm));
13434 0 : if ((data)->i_realm == NULL) { e = ENOMEM; goto fail; }
13435 0 : p += l; len -= l; ret += l;
13436 0 : i_realm_oldlen = len;
13437 0 : if (i_realm_datalen > len) { e = ASN1_OVERRUN; goto fail; }
13438 0 : len = i_realm_datalen;
13439 0 : e = decode_Realm(p, len, (data)->i_realm, &l);
13440 0 : if(e) goto fail;
13441 0 : p += l; len -= l; ret += l;
13442 0 : len = i_realm_oldlen - i_realm_datalen;
13443 : }
13444 : }
13445 : {
13446 : size_t i_sname_datalen, i_sname_oldlen;
13447 : Der_type i_sname_type;
13448 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &i_sname_type, 2, &i_sname_datalen, &l);
13449 0 : if (e == 0 && i_sname_type != CONS) { e = ASN1_BAD_ID; }
13450 0 : if(e) {
13451 0 : (data)->i_sname = NULL;
13452 : } else {
13453 0 : (data)->i_sname = calloc(1, sizeof(*(data)->i_sname));
13454 0 : if ((data)->i_sname == NULL) { e = ENOMEM; goto fail; }
13455 0 : p += l; len -= l; ret += l;
13456 0 : i_sname_oldlen = len;
13457 0 : if (i_sname_datalen > len) { e = ASN1_OVERRUN; goto fail; }
13458 0 : len = i_sname_datalen;
13459 0 : e = decode_PrincipalName(p, len, (data)->i_sname, &l);
13460 0 : if(e) goto fail;
13461 0 : p += l; len -= l; ret += l;
13462 0 : len = i_sname_oldlen - i_sname_datalen;
13463 : }
13464 : }
13465 : {
13466 : size_t elements_datalen, elements_oldlen;
13467 : Der_type elements_type;
13468 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &elements_type, 3, &elements_datalen, &l);
13469 0 : if (e == 0 && elements_type != CONS) { e = ASN1_BAD_ID; }
13470 0 : if(e) goto fail;
13471 0 : p += l; len -= l; ret += l;
13472 0 : elements_oldlen = len;
13473 0 : if (elements_datalen > len) { e = ASN1_OVERRUN; goto fail; }
13474 0 : len = elements_datalen;
13475 0 : e = decode_AuthorizationData(p, len, &(data)->elements, &l);
13476 0 : if(e) goto fail;
13477 0 : p += l; len -= l; ret += l;
13478 0 : len = elements_oldlen - elements_datalen;
13479 : }
13480 0 : len = Top_oldlen - Top_datalen;
13481 : }
13482 0 : if(size) *size = ret;
13483 0 : return 0;
13484 0 : fail:
13485 0 : free_AD_KDCIssued(data);
13486 0 : return e;
13487 : }
13488 :
13489 : void ASN1CALL
13490 0 : free_AD_KDCIssued(AD_KDCIssued *data)
13491 : {
13492 0 : free_Checksum(&(data)->ad_checksum);
13493 0 : if((data)->i_realm) {
13494 0 : free_Realm((data)->i_realm);
13495 0 : free((data)->i_realm);
13496 0 : (data)->i_realm = NULL;
13497 : }
13498 0 : if((data)->i_sname) {
13499 0 : free_PrincipalName((data)->i_sname);
13500 0 : free((data)->i_sname);
13501 0 : (data)->i_sname = NULL;
13502 : }
13503 0 : free_AuthorizationData(&(data)->elements);
13504 0 : }
13505 :
13506 : size_t ASN1CALL
13507 0 : length_AD_KDCIssued(const AD_KDCIssued *data)
13508 : {
13509 0 : size_t ret = 0;
13510 : {
13511 0 : size_t Top_tag_oldret = ret;
13512 0 : ret = 0;
13513 0 : ret += length_Checksum(&(data)->ad_checksum);
13514 0 : ret += 1 + der_length_len (ret);
13515 0 : ret += Top_tag_oldret;
13516 : }
13517 0 : if((data)->i_realm){
13518 0 : size_t Top_tag_oldret = ret;
13519 0 : ret = 0;
13520 0 : ret += length_Realm((data)->i_realm);
13521 0 : ret += 1 + der_length_len (ret);
13522 0 : ret += Top_tag_oldret;
13523 : }
13524 0 : if((data)->i_sname){
13525 0 : size_t Top_tag_oldret = ret;
13526 0 : ret = 0;
13527 0 : ret += length_PrincipalName((data)->i_sname);
13528 0 : ret += 1 + der_length_len (ret);
13529 0 : ret += Top_tag_oldret;
13530 : }
13531 : {
13532 0 : size_t Top_tag_oldret = ret;
13533 0 : ret = 0;
13534 0 : ret += length_AuthorizationData(&(data)->elements);
13535 0 : ret += 1 + der_length_len (ret);
13536 0 : ret += Top_tag_oldret;
13537 : }
13538 0 : ret += 1 + der_length_len (ret);
13539 0 : return ret;
13540 : }
13541 :
13542 : int ASN1CALL
13543 0 : copy_AD_KDCIssued(const AD_KDCIssued *from, AD_KDCIssued *to)
13544 : {
13545 0 : memset(to, 0, sizeof(*to));
13546 0 : if(copy_Checksum(&(from)->ad_checksum, &(to)->ad_checksum)) goto fail;
13547 0 : if((from)->i_realm) {
13548 0 : (to)->i_realm = malloc(sizeof(*(to)->i_realm));
13549 0 : if((to)->i_realm == NULL) goto fail;
13550 0 : if(copy_Realm((from)->i_realm, (to)->i_realm)) goto fail;
13551 : }else
13552 0 : (to)->i_realm = NULL;
13553 0 : if((from)->i_sname) {
13554 0 : (to)->i_sname = malloc(sizeof(*(to)->i_sname));
13555 0 : if((to)->i_sname == NULL) goto fail;
13556 0 : if(copy_PrincipalName((from)->i_sname, (to)->i_sname)) goto fail;
13557 : }else
13558 0 : (to)->i_sname = NULL;
13559 0 : if(copy_AuthorizationData(&(from)->elements, &(to)->elements)) goto fail;
13560 0 : return 0;
13561 0 : fail:
13562 0 : free_AD_KDCIssued(to);
13563 0 : return ENOMEM;
13564 : }
13565 :
13566 : int ASN1CALL
13567 0 : encode_AD_AND_OR(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const AD_AND_OR *data, size_t *size)
13568 : {
13569 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
13570 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
13571 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
13572 :
13573 : /* elements */
13574 : {
13575 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
13576 0 : ret = 0;
13577 0 : e = encode_AuthorizationData(p, len, &(data)->elements, &l);
13578 0 : if (e) return e;
13579 0 : p -= l; len -= l; ret += l;
13580 :
13581 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
13582 0 : if (e) return e;
13583 0 : p -= l; len -= l; ret += l;
13584 :
13585 0 : ret += Top_tag_oldret;
13586 : }
13587 : /* condition-count */
13588 : {
13589 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
13590 0 : ret = 0;
13591 0 : e = der_put_heim_integer(p, len, &(data)->condition_count, &l);
13592 0 : if (e) return e;
13593 0 : p -= l; len -= l; ret += l;
13594 :
13595 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
13596 0 : if (e) return e;
13597 0 : p -= l; len -= l; ret += l;
13598 :
13599 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
13600 0 : if (e) return e;
13601 0 : p -= l; len -= l; ret += l;
13602 :
13603 0 : ret += Top_tag_oldret;
13604 : }
13605 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
13606 0 : if (e) return e;
13607 0 : p -= l; len -= l; ret += l;
13608 :
13609 0 : *size = ret;
13610 0 : return 0;
13611 : }
13612 :
13613 : int ASN1CALL
13614 0 : decode_AD_AND_OR(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, AD_AND_OR *data, size_t *size)
13615 : {
13616 0 : size_t ret = 0;
13617 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
13618 : int e HEIMDAL_UNUSED_ATTRIBUTE;
13619 :
13620 0 : memset(data, 0, sizeof(*data));
13621 : {
13622 : size_t Top_datalen, Top_oldlen;
13623 : Der_type Top_type;
13624 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
13625 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
13626 0 : if(e) goto fail;
13627 0 : p += l; len -= l; ret += l;
13628 0 : Top_oldlen = len;
13629 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
13630 0 : len = Top_datalen;
13631 : {
13632 : size_t condition_count_datalen, condition_count_oldlen;
13633 : Der_type condition_count_type;
13634 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &condition_count_type, 0, &condition_count_datalen, &l);
13635 0 : if (e == 0 && condition_count_type != CONS) { e = ASN1_BAD_ID; }
13636 0 : if(e) goto fail;
13637 0 : p += l; len -= l; ret += l;
13638 0 : condition_count_oldlen = len;
13639 0 : if (condition_count_datalen > len) { e = ASN1_OVERRUN; goto fail; }
13640 0 : len = condition_count_datalen;
13641 : {
13642 : size_t condition_count_Tag_datalen, condition_count_Tag_oldlen;
13643 : Der_type condition_count_Tag_type;
13644 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &condition_count_Tag_type, UT_Integer, &condition_count_Tag_datalen, &l);
13645 0 : if (e == 0 && condition_count_Tag_type != PRIM) { e = ASN1_BAD_ID; }
13646 0 : if(e) goto fail;
13647 0 : p += l; len -= l; ret += l;
13648 0 : condition_count_Tag_oldlen = len;
13649 0 : if (condition_count_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
13650 0 : len = condition_count_Tag_datalen;
13651 0 : e = der_get_heim_integer(p, len, &(data)->condition_count, &l);
13652 0 : if(e) goto fail;
13653 0 : p += l; len -= l; ret += l;
13654 0 : len = condition_count_Tag_oldlen - condition_count_Tag_datalen;
13655 : }
13656 0 : len = condition_count_oldlen - condition_count_datalen;
13657 : }
13658 : {
13659 : size_t elements_datalen, elements_oldlen;
13660 : Der_type elements_type;
13661 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &elements_type, 1, &elements_datalen, &l);
13662 0 : if (e == 0 && elements_type != CONS) { e = ASN1_BAD_ID; }
13663 0 : if(e) goto fail;
13664 0 : p += l; len -= l; ret += l;
13665 0 : elements_oldlen = len;
13666 0 : if (elements_datalen > len) { e = ASN1_OVERRUN; goto fail; }
13667 0 : len = elements_datalen;
13668 0 : e = decode_AuthorizationData(p, len, &(data)->elements, &l);
13669 0 : if(e) goto fail;
13670 0 : p += l; len -= l; ret += l;
13671 0 : len = elements_oldlen - elements_datalen;
13672 : }
13673 0 : len = Top_oldlen - Top_datalen;
13674 : }
13675 0 : if(size) *size = ret;
13676 0 : return 0;
13677 0 : fail:
13678 0 : free_AD_AND_OR(data);
13679 0 : return e;
13680 : }
13681 :
13682 : void ASN1CALL
13683 0 : free_AD_AND_OR(AD_AND_OR *data)
13684 : {
13685 0 : der_free_heim_integer(&(data)->condition_count);
13686 0 : free_AuthorizationData(&(data)->elements);
13687 0 : }
13688 :
13689 : size_t ASN1CALL
13690 0 : length_AD_AND_OR(const AD_AND_OR *data)
13691 : {
13692 0 : size_t ret = 0;
13693 : {
13694 0 : size_t Top_tag_oldret = ret;
13695 0 : ret = 0;
13696 0 : ret += der_length_heim_integer(&(data)->condition_count);
13697 0 : ret += 1 + der_length_len (ret);
13698 0 : ret += 1 + der_length_len (ret);
13699 0 : ret += Top_tag_oldret;
13700 : }
13701 : {
13702 0 : size_t Top_tag_oldret = ret;
13703 0 : ret = 0;
13704 0 : ret += length_AuthorizationData(&(data)->elements);
13705 0 : ret += 1 + der_length_len (ret);
13706 0 : ret += Top_tag_oldret;
13707 : }
13708 0 : ret += 1 + der_length_len (ret);
13709 0 : return ret;
13710 : }
13711 :
13712 : int ASN1CALL
13713 0 : copy_AD_AND_OR(const AD_AND_OR *from, AD_AND_OR *to)
13714 : {
13715 0 : memset(to, 0, sizeof(*to));
13716 0 : if(der_copy_heim_integer(&(from)->condition_count, &(to)->condition_count)) goto fail;
13717 0 : if(copy_AuthorizationData(&(from)->elements, &(to)->elements)) goto fail;
13718 0 : return 0;
13719 0 : fail:
13720 0 : free_AD_AND_OR(to);
13721 0 : return ENOMEM;
13722 : }
13723 :
13724 : int ASN1CALL
13725 0 : encode_AD_MANDATORY_FOR_KDC(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const AD_MANDATORY_FOR_KDC *data, size_t *size)
13726 : {
13727 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
13728 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
13729 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
13730 :
13731 0 : e = encode_AuthorizationData(p, len, data, &l);
13732 0 : if (e) return e;
13733 0 : p -= l; len -= l; ret += l;
13734 :
13735 0 : *size = ret;
13736 0 : return 0;
13737 : }
13738 :
13739 : int ASN1CALL
13740 0 : decode_AD_MANDATORY_FOR_KDC(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, AD_MANDATORY_FOR_KDC *data, size_t *size)
13741 : {
13742 0 : size_t ret = 0;
13743 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
13744 : int e HEIMDAL_UNUSED_ATTRIBUTE;
13745 :
13746 0 : memset(data, 0, sizeof(*data));
13747 0 : e = decode_AuthorizationData(p, len, data, &l);
13748 0 : if(e) goto fail;
13749 0 : p += l; len -= l; ret += l;
13750 0 : if(size) *size = ret;
13751 0 : return 0;
13752 0 : fail:
13753 0 : free_AD_MANDATORY_FOR_KDC(data);
13754 0 : return e;
13755 : }
13756 :
13757 : void ASN1CALL
13758 0 : free_AD_MANDATORY_FOR_KDC(AD_MANDATORY_FOR_KDC *data)
13759 : {
13760 0 : free_AuthorizationData(data);
13761 0 : }
13762 :
13763 : size_t ASN1CALL
13764 0 : length_AD_MANDATORY_FOR_KDC(const AD_MANDATORY_FOR_KDC *data)
13765 : {
13766 0 : size_t ret = 0;
13767 0 : ret += length_AuthorizationData(data);
13768 0 : return ret;
13769 : }
13770 :
13771 : int ASN1CALL
13772 0 : copy_AD_MANDATORY_FOR_KDC(const AD_MANDATORY_FOR_KDC *from, AD_MANDATORY_FOR_KDC *to)
13773 : {
13774 0 : memset(to, 0, sizeof(*to));
13775 0 : if(copy_AuthorizationData(from, to)) goto fail;
13776 0 : return 0;
13777 0 : fail:
13778 0 : free_AD_MANDATORY_FOR_KDC(to);
13779 0 : return ENOMEM;
13780 : }
13781 :
13782 : int ASN1CALL
13783 0 : encode_PA_SAM_TYPE(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const PA_SAM_TYPE *data, size_t *size)
13784 : {
13785 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
13786 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
13787 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
13788 :
13789 : {
13790 0 : int enumint = (int)*data;
13791 0 : e = der_put_integer(p, len, &enumint, &l);
13792 0 : if (e) return e;
13793 0 : p -= l; len -= l; ret += l;
13794 :
13795 : }
13796 0 : ;e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
13797 0 : if (e) return e;
13798 0 : p -= l; len -= l; ret += l;
13799 :
13800 0 : *size = ret;
13801 0 : return 0;
13802 : }
13803 :
13804 : int ASN1CALL
13805 0 : decode_PA_SAM_TYPE(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, PA_SAM_TYPE *data, size_t *size)
13806 : {
13807 0 : size_t ret = 0;
13808 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
13809 : int e HEIMDAL_UNUSED_ATTRIBUTE;
13810 :
13811 0 : memset(data, 0, sizeof(*data));
13812 : {
13813 : size_t Top_datalen, Top_oldlen;
13814 : Der_type Top_type;
13815 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Integer, &Top_datalen, &l);
13816 0 : if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
13817 0 : if(e) goto fail;
13818 0 : p += l; len -= l; ret += l;
13819 0 : Top_oldlen = len;
13820 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
13821 0 : len = Top_datalen;
13822 : {
13823 : int enumint;
13824 0 : e = der_get_integer(p, len, &enumint, &l);
13825 0 : if(e) goto fail;
13826 0 : p += l; len -= l; ret += l;
13827 0 : *data = enumint;
13828 : }
13829 0 : len = Top_oldlen - Top_datalen;
13830 : }
13831 0 : if(size) *size = ret;
13832 0 : return 0;
13833 0 : fail:
13834 0 : free_PA_SAM_TYPE(data);
13835 0 : return e;
13836 : }
13837 :
13838 : void ASN1CALL
13839 0 : free_PA_SAM_TYPE(PA_SAM_TYPE *data)
13840 : {
13841 0 : }
13842 :
13843 : size_t ASN1CALL
13844 0 : length_PA_SAM_TYPE(const PA_SAM_TYPE *data)
13845 : {
13846 0 : size_t ret = 0;
13847 : {
13848 0 : int enumint = *data;
13849 0 : ret += der_length_integer(&enumint);
13850 : }
13851 0 : ret += 1 + der_length_len (ret);
13852 0 : return ret;
13853 : }
13854 :
13855 : int ASN1CALL
13856 0 : copy_PA_SAM_TYPE(const PA_SAM_TYPE *from, PA_SAM_TYPE *to)
13857 : {
13858 0 : memset(to, 0, sizeof(*to));
13859 0 : *(to) = *(from);
13860 0 : return 0;
13861 : }
13862 :
13863 : int ASN1CALL
13864 0 : encode_PA_SAM_REDIRECT(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const PA_SAM_REDIRECT *data, size_t *size)
13865 : {
13866 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
13867 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
13868 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
13869 :
13870 0 : e = encode_HostAddresses(p, len, data, &l);
13871 0 : if (e) return e;
13872 0 : p -= l; len -= l; ret += l;
13873 :
13874 0 : *size = ret;
13875 0 : return 0;
13876 : }
13877 :
13878 : int ASN1CALL
13879 0 : decode_PA_SAM_REDIRECT(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, PA_SAM_REDIRECT *data, size_t *size)
13880 : {
13881 0 : size_t ret = 0;
13882 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
13883 : int e HEIMDAL_UNUSED_ATTRIBUTE;
13884 :
13885 0 : memset(data, 0, sizeof(*data));
13886 0 : e = decode_HostAddresses(p, len, data, &l);
13887 0 : if(e) goto fail;
13888 0 : p += l; len -= l; ret += l;
13889 0 : if(size) *size = ret;
13890 0 : return 0;
13891 0 : fail:
13892 0 : free_PA_SAM_REDIRECT(data);
13893 0 : return e;
13894 : }
13895 :
13896 : void ASN1CALL
13897 0 : free_PA_SAM_REDIRECT(PA_SAM_REDIRECT *data)
13898 : {
13899 0 : free_HostAddresses(data);
13900 0 : }
13901 :
13902 : size_t ASN1CALL
13903 0 : length_PA_SAM_REDIRECT(const PA_SAM_REDIRECT *data)
13904 : {
13905 0 : size_t ret = 0;
13906 0 : ret += length_HostAddresses(data);
13907 0 : return ret;
13908 : }
13909 :
13910 : int ASN1CALL
13911 0 : copy_PA_SAM_REDIRECT(const PA_SAM_REDIRECT *from, PA_SAM_REDIRECT *to)
13912 : {
13913 0 : memset(to, 0, sizeof(*to));
13914 0 : if(copy_HostAddresses(from, to)) goto fail;
13915 0 : return 0;
13916 0 : fail:
13917 0 : free_PA_SAM_REDIRECT(to);
13918 0 : return ENOMEM;
13919 : }
13920 :
13921 : int ASN1CALL
13922 0 : encode_SAMFlags(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const SAMFlags *data, size_t *size)
13923 : {
13924 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
13925 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
13926 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
13927 :
13928 : {
13929 0 : unsigned char c = 0;
13930 0 : if (len < 1) return ASN1_OVERFLOW;
13931 0 : *p-- = c; len--; ret++;
13932 0 : c = 0;
13933 0 : if (len < 1) return ASN1_OVERFLOW;
13934 0 : *p-- = c; len--; ret++;
13935 0 : c = 0;
13936 0 : if (len < 1) return ASN1_OVERFLOW;
13937 0 : *p-- = c; len--; ret++;
13938 0 : c = 0;
13939 0 : if((data)->must_pk_encrypt_sad) {
13940 0 : c |= 1<<5;
13941 : }
13942 0 : if((data)->send_encrypted_sad) {
13943 0 : c |= 1<<6;
13944 : }
13945 0 : if((data)->use_sad_as_key) {
13946 0 : c |= 1<<7;
13947 : }
13948 0 : if (len < 1) return ASN1_OVERFLOW;
13949 0 : *p-- = c; len--; ret++;
13950 0 : if (len < 1) return ASN1_OVERFLOW;
13951 0 : *p-- = 0;
13952 0 : len -= 1;
13953 0 : ret += 1;
13954 : }
13955 :
13956 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_BitString, &l);
13957 0 : if (e) return e;
13958 0 : p -= l; len -= l; ret += l;
13959 :
13960 0 : *size = ret;
13961 0 : return 0;
13962 : }
13963 :
13964 : int ASN1CALL
13965 0 : decode_SAMFlags(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, SAMFlags *data, size_t *size)
13966 : {
13967 0 : size_t ret = 0;
13968 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
13969 : int e HEIMDAL_UNUSED_ATTRIBUTE;
13970 :
13971 0 : memset(data, 0, sizeof(*data));
13972 : {
13973 : size_t Top_datalen, Top_oldlen;
13974 : Der_type Top_type;
13975 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_BitString, &Top_datalen, &l);
13976 0 : if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
13977 0 : if(e) goto fail;
13978 0 : p += l; len -= l; ret += l;
13979 0 : Top_oldlen = len;
13980 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
13981 0 : len = Top_datalen;
13982 0 : if (len < 1) return ASN1_OVERRUN;
13983 0 : p++; len--; ret++;
13984 : do {
13985 0 : if (len < 1) break;
13986 0 : (data)->use_sad_as_key = (*p >> 7) & 1;
13987 0 : (data)->send_encrypted_sad = (*p >> 6) & 1;
13988 0 : (data)->must_pk_encrypt_sad = (*p >> 5) & 1;
13989 : } while(0);
13990 0 : p += len; ret += len;
13991 0 : len = Top_oldlen - Top_datalen;
13992 : }
13993 0 : if(size) *size = ret;
13994 0 : return 0;
13995 0 : fail:
13996 0 : free_SAMFlags(data);
13997 0 : return e;
13998 : }
13999 :
14000 : void ASN1CALL
14001 0 : free_SAMFlags(SAMFlags *data)
14002 : {
14003 0 : }
14004 :
14005 : size_t ASN1CALL
14006 0 : length_SAMFlags(const SAMFlags *data)
14007 : {
14008 0 : size_t ret = 0;
14009 0 : ret += 5;
14010 0 : ret += 1 + der_length_len (ret);
14011 0 : return ret;
14012 : }
14013 :
14014 : int ASN1CALL
14015 0 : copy_SAMFlags(const SAMFlags *from, SAMFlags *to)
14016 : {
14017 0 : memset(to, 0, sizeof(*to));
14018 0 : *(to) = *(from);
14019 0 : return 0;
14020 : }
14021 :
14022 0 : unsigned SAMFlags2int(SAMFlags f)
14023 : {
14024 0 : unsigned r = 0;
14025 0 : if(f.use_sad_as_key) r |= (1U << 0);
14026 0 : if(f.send_encrypted_sad) r |= (1U << 1);
14027 0 : if(f.must_pk_encrypt_sad) r |= (1U << 2);
14028 0 : return r;
14029 : }
14030 :
14031 0 : SAMFlags int2SAMFlags(unsigned n)
14032 : {
14033 : SAMFlags flags;
14034 :
14035 0 : memset(&flags, 0, sizeof(flags));
14036 :
14037 0 : flags.use_sad_as_key = (n >> 0) & 1;
14038 0 : flags.send_encrypted_sad = (n >> 1) & 1;
14039 0 : flags.must_pk_encrypt_sad = (n >> 2) & 1;
14040 0 : return flags;
14041 : }
14042 :
14043 : static struct units SAMFlags_units[] = {
14044 : {"must-pk-encrypt-sad", 1U << 2},
14045 : {"send-encrypted-sad", 1U << 1},
14046 : {"use-sad-as-key", 1U << 0},
14047 : {NULL, 0}
14048 : };
14049 :
14050 0 : const struct units * asn1_SAMFlags_units(void){
14051 0 : return SAMFlags_units;
14052 : }
14053 :
14054 : int ASN1CALL
14055 0 : encode_PA_SAM_CHALLENGE_2_BODY(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const PA_SAM_CHALLENGE_2_BODY *data, size_t *size)
14056 : {
14057 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
14058 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
14059 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
14060 :
14061 : /* sam-etype */
14062 : {
14063 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
14064 0 : ret = 0;
14065 0 : e = encode_krb5int32(p, len, &(data)->sam_etype, &l);
14066 0 : if (e) return e;
14067 0 : p -= l; len -= l; ret += l;
14068 :
14069 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 9, &l);
14070 0 : if (e) return e;
14071 0 : p -= l; len -= l; ret += l;
14072 :
14073 0 : ret += Top_tag_oldret;
14074 : }
14075 : /* sam-nonce */
14076 : {
14077 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
14078 0 : ret = 0;
14079 0 : e = encode_krb5int32(p, len, &(data)->sam_nonce, &l);
14080 0 : if (e) return e;
14081 0 : p -= l; len -= l; ret += l;
14082 :
14083 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 8, &l);
14084 0 : if (e) return e;
14085 0 : p -= l; len -= l; ret += l;
14086 :
14087 0 : ret += Top_tag_oldret;
14088 : }
14089 : /* sam-pk-for-sad */
14090 0 : if((data)->sam_pk_for_sad) {
14091 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
14092 0 : ret = 0;
14093 0 : e = encode_EncryptionKey(p, len, (data)->sam_pk_for_sad, &l);
14094 0 : if (e) return e;
14095 0 : p -= l; len -= l; ret += l;
14096 :
14097 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 7, &l);
14098 0 : if (e) return e;
14099 0 : p -= l; len -= l; ret += l;
14100 :
14101 0 : ret += Top_tag_oldret;
14102 : }
14103 : /* sam-response-prompt */
14104 0 : if((data)->sam_response_prompt) {
14105 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
14106 0 : ret = 0;
14107 0 : e = der_put_general_string(p, len, (data)->sam_response_prompt, &l);
14108 0 : if (e) return e;
14109 0 : p -= l; len -= l; ret += l;
14110 :
14111 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_GeneralString, &l);
14112 0 : if (e) return e;
14113 0 : p -= l; len -= l; ret += l;
14114 :
14115 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 6, &l);
14116 0 : if (e) return e;
14117 0 : p -= l; len -= l; ret += l;
14118 :
14119 0 : ret += Top_tag_oldret;
14120 : }
14121 : /* sam-challenge */
14122 0 : if((data)->sam_challenge) {
14123 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
14124 0 : ret = 0;
14125 0 : e = der_put_general_string(p, len, (data)->sam_challenge, &l);
14126 0 : if (e) return e;
14127 0 : p -= l; len -= l; ret += l;
14128 :
14129 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_GeneralString, &l);
14130 0 : if (e) return e;
14131 0 : p -= l; len -= l; ret += l;
14132 :
14133 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 5, &l);
14134 0 : if (e) return e;
14135 0 : p -= l; len -= l; ret += l;
14136 :
14137 0 : ret += Top_tag_oldret;
14138 : }
14139 : /* sam-challenge-label */
14140 0 : if((data)->sam_challenge_label) {
14141 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
14142 0 : ret = 0;
14143 0 : e = der_put_general_string(p, len, (data)->sam_challenge_label, &l);
14144 0 : if (e) return e;
14145 0 : p -= l; len -= l; ret += l;
14146 :
14147 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_GeneralString, &l);
14148 0 : if (e) return e;
14149 0 : p -= l; len -= l; ret += l;
14150 :
14151 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 4, &l);
14152 0 : if (e) return e;
14153 0 : p -= l; len -= l; ret += l;
14154 :
14155 0 : ret += Top_tag_oldret;
14156 : }
14157 : /* sam-track-id */
14158 0 : if((data)->sam_track_id) {
14159 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
14160 0 : ret = 0;
14161 0 : e = der_put_general_string(p, len, (data)->sam_track_id, &l);
14162 0 : if (e) return e;
14163 0 : p -= l; len -= l; ret += l;
14164 :
14165 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_GeneralString, &l);
14166 0 : if (e) return e;
14167 0 : p -= l; len -= l; ret += l;
14168 :
14169 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
14170 0 : if (e) return e;
14171 0 : p -= l; len -= l; ret += l;
14172 :
14173 0 : ret += Top_tag_oldret;
14174 : }
14175 : /* sam-type-name */
14176 0 : if((data)->sam_type_name) {
14177 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
14178 0 : ret = 0;
14179 0 : e = der_put_general_string(p, len, (data)->sam_type_name, &l);
14180 0 : if (e) return e;
14181 0 : p -= l; len -= l; ret += l;
14182 :
14183 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_GeneralString, &l);
14184 0 : if (e) return e;
14185 0 : p -= l; len -= l; ret += l;
14186 :
14187 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
14188 0 : if (e) return e;
14189 0 : p -= l; len -= l; ret += l;
14190 :
14191 0 : ret += Top_tag_oldret;
14192 : }
14193 : /* sam-flags */
14194 : {
14195 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
14196 0 : ret = 0;
14197 0 : e = encode_SAMFlags(p, len, &(data)->sam_flags, &l);
14198 0 : if (e) return e;
14199 0 : p -= l; len -= l; ret += l;
14200 :
14201 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
14202 0 : if (e) return e;
14203 0 : p -= l; len -= l; ret += l;
14204 :
14205 0 : ret += Top_tag_oldret;
14206 : }
14207 : /* sam-type */
14208 : {
14209 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
14210 0 : ret = 0;
14211 0 : e = encode_krb5int32(p, len, &(data)->sam_type, &l);
14212 0 : if (e) return e;
14213 0 : p -= l; len -= l; ret += l;
14214 :
14215 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
14216 0 : if (e) return e;
14217 0 : p -= l; len -= l; ret += l;
14218 :
14219 0 : ret += Top_tag_oldret;
14220 : }
14221 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
14222 0 : if (e) return e;
14223 0 : p -= l; len -= l; ret += l;
14224 :
14225 0 : *size = ret;
14226 0 : return 0;
14227 : }
14228 :
14229 : int ASN1CALL
14230 0 : decode_PA_SAM_CHALLENGE_2_BODY(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, PA_SAM_CHALLENGE_2_BODY *data, size_t *size)
14231 : {
14232 0 : size_t ret = 0;
14233 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
14234 : int e HEIMDAL_UNUSED_ATTRIBUTE;
14235 :
14236 0 : memset(data, 0, sizeof(*data));
14237 : {
14238 : size_t Top_datalen, Top_oldlen;
14239 : Der_type Top_type;
14240 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
14241 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
14242 0 : if(e) goto fail;
14243 0 : p += l; len -= l; ret += l;
14244 0 : Top_oldlen = len;
14245 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
14246 0 : len = Top_datalen;
14247 : {
14248 : size_t sam_type_datalen, sam_type_oldlen;
14249 : Der_type sam_type_type;
14250 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &sam_type_type, 0, &sam_type_datalen, &l);
14251 0 : if (e == 0 && sam_type_type != CONS) { e = ASN1_BAD_ID; }
14252 0 : if(e) goto fail;
14253 0 : p += l; len -= l; ret += l;
14254 0 : sam_type_oldlen = len;
14255 0 : if (sam_type_datalen > len) { e = ASN1_OVERRUN; goto fail; }
14256 0 : len = sam_type_datalen;
14257 0 : e = decode_krb5int32(p, len, &(data)->sam_type, &l);
14258 0 : if(e) goto fail;
14259 0 : p += l; len -= l; ret += l;
14260 0 : len = sam_type_oldlen - sam_type_datalen;
14261 : }
14262 : {
14263 : size_t sam_flags_datalen, sam_flags_oldlen;
14264 : Der_type sam_flags_type;
14265 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &sam_flags_type, 1, &sam_flags_datalen, &l);
14266 0 : if (e == 0 && sam_flags_type != CONS) { e = ASN1_BAD_ID; }
14267 0 : if(e) goto fail;
14268 0 : p += l; len -= l; ret += l;
14269 0 : sam_flags_oldlen = len;
14270 0 : if (sam_flags_datalen > len) { e = ASN1_OVERRUN; goto fail; }
14271 0 : len = sam_flags_datalen;
14272 0 : e = decode_SAMFlags(p, len, &(data)->sam_flags, &l);
14273 0 : if(e) goto fail;
14274 0 : p += l; len -= l; ret += l;
14275 0 : len = sam_flags_oldlen - sam_flags_datalen;
14276 : }
14277 : {
14278 : size_t sam_type_name_datalen, sam_type_name_oldlen;
14279 : Der_type sam_type_name_type;
14280 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &sam_type_name_type, 2, &sam_type_name_datalen, &l);
14281 0 : if (e == 0 && sam_type_name_type != CONS) { e = ASN1_BAD_ID; }
14282 0 : if(e) {
14283 0 : (data)->sam_type_name = NULL;
14284 : } else {
14285 0 : (data)->sam_type_name = calloc(1, sizeof(*(data)->sam_type_name));
14286 0 : if ((data)->sam_type_name == NULL) { e = ENOMEM; goto fail; }
14287 0 : p += l; len -= l; ret += l;
14288 0 : sam_type_name_oldlen = len;
14289 0 : if (sam_type_name_datalen > len) { e = ASN1_OVERRUN; goto fail; }
14290 0 : len = sam_type_name_datalen;
14291 : {
14292 : size_t sam_type_name_Tag_datalen, sam_type_name_Tag_oldlen;
14293 : Der_type sam_type_name_Tag_type;
14294 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &sam_type_name_Tag_type, UT_GeneralString, &sam_type_name_Tag_datalen, &l);
14295 0 : if (e == 0 && sam_type_name_Tag_type != PRIM) { e = ASN1_BAD_ID; }
14296 0 : if(e) goto fail;
14297 0 : p += l; len -= l; ret += l;
14298 0 : sam_type_name_Tag_oldlen = len;
14299 0 : if (sam_type_name_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
14300 0 : len = sam_type_name_Tag_datalen;
14301 0 : e = der_get_general_string(p, len, (data)->sam_type_name, &l);
14302 0 : if(e) goto fail;
14303 0 : p += l; len -= l; ret += l;
14304 0 : len = sam_type_name_Tag_oldlen - sam_type_name_Tag_datalen;
14305 : }
14306 0 : len = sam_type_name_oldlen - sam_type_name_datalen;
14307 : }
14308 : }
14309 : {
14310 : size_t sam_track_id_datalen, sam_track_id_oldlen;
14311 : Der_type sam_track_id_type;
14312 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &sam_track_id_type, 3, &sam_track_id_datalen, &l);
14313 0 : if (e == 0 && sam_track_id_type != CONS) { e = ASN1_BAD_ID; }
14314 0 : if(e) {
14315 0 : (data)->sam_track_id = NULL;
14316 : } else {
14317 0 : (data)->sam_track_id = calloc(1, sizeof(*(data)->sam_track_id));
14318 0 : if ((data)->sam_track_id == NULL) { e = ENOMEM; goto fail; }
14319 0 : p += l; len -= l; ret += l;
14320 0 : sam_track_id_oldlen = len;
14321 0 : if (sam_track_id_datalen > len) { e = ASN1_OVERRUN; goto fail; }
14322 0 : len = sam_track_id_datalen;
14323 : {
14324 : size_t sam_track_id_Tag_datalen, sam_track_id_Tag_oldlen;
14325 : Der_type sam_track_id_Tag_type;
14326 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &sam_track_id_Tag_type, UT_GeneralString, &sam_track_id_Tag_datalen, &l);
14327 0 : if (e == 0 && sam_track_id_Tag_type != PRIM) { e = ASN1_BAD_ID; }
14328 0 : if(e) goto fail;
14329 0 : p += l; len -= l; ret += l;
14330 0 : sam_track_id_Tag_oldlen = len;
14331 0 : if (sam_track_id_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
14332 0 : len = sam_track_id_Tag_datalen;
14333 0 : e = der_get_general_string(p, len, (data)->sam_track_id, &l);
14334 0 : if(e) goto fail;
14335 0 : p += l; len -= l; ret += l;
14336 0 : len = sam_track_id_Tag_oldlen - sam_track_id_Tag_datalen;
14337 : }
14338 0 : len = sam_track_id_oldlen - sam_track_id_datalen;
14339 : }
14340 : }
14341 : {
14342 : size_t sam_challenge_label_datalen, sam_challenge_label_oldlen;
14343 : Der_type sam_challenge_label_type;
14344 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &sam_challenge_label_type, 4, &sam_challenge_label_datalen, &l);
14345 0 : if (e == 0 && sam_challenge_label_type != CONS) { e = ASN1_BAD_ID; }
14346 0 : if(e) {
14347 0 : (data)->sam_challenge_label = NULL;
14348 : } else {
14349 0 : (data)->sam_challenge_label = calloc(1, sizeof(*(data)->sam_challenge_label));
14350 0 : if ((data)->sam_challenge_label == NULL) { e = ENOMEM; goto fail; }
14351 0 : p += l; len -= l; ret += l;
14352 0 : sam_challenge_label_oldlen = len;
14353 0 : if (sam_challenge_label_datalen > len) { e = ASN1_OVERRUN; goto fail; }
14354 0 : len = sam_challenge_label_datalen;
14355 : {
14356 : size_t sam_challenge_label_Tag_datalen, sam_challenge_label_Tag_oldlen;
14357 : Der_type sam_challenge_label_Tag_type;
14358 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &sam_challenge_label_Tag_type, UT_GeneralString, &sam_challenge_label_Tag_datalen, &l);
14359 0 : if (e == 0 && sam_challenge_label_Tag_type != PRIM) { e = ASN1_BAD_ID; }
14360 0 : if(e) goto fail;
14361 0 : p += l; len -= l; ret += l;
14362 0 : sam_challenge_label_Tag_oldlen = len;
14363 0 : if (sam_challenge_label_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
14364 0 : len = sam_challenge_label_Tag_datalen;
14365 0 : e = der_get_general_string(p, len, (data)->sam_challenge_label, &l);
14366 0 : if(e) goto fail;
14367 0 : p += l; len -= l; ret += l;
14368 0 : len = sam_challenge_label_Tag_oldlen - sam_challenge_label_Tag_datalen;
14369 : }
14370 0 : len = sam_challenge_label_oldlen - sam_challenge_label_datalen;
14371 : }
14372 : }
14373 : {
14374 : size_t sam_challenge_datalen, sam_challenge_oldlen;
14375 : Der_type sam_challenge_type;
14376 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &sam_challenge_type, 5, &sam_challenge_datalen, &l);
14377 0 : if (e == 0 && sam_challenge_type != CONS) { e = ASN1_BAD_ID; }
14378 0 : if(e) {
14379 0 : (data)->sam_challenge = NULL;
14380 : } else {
14381 0 : (data)->sam_challenge = calloc(1, sizeof(*(data)->sam_challenge));
14382 0 : if ((data)->sam_challenge == NULL) { e = ENOMEM; goto fail; }
14383 0 : p += l; len -= l; ret += l;
14384 0 : sam_challenge_oldlen = len;
14385 0 : if (sam_challenge_datalen > len) { e = ASN1_OVERRUN; goto fail; }
14386 0 : len = sam_challenge_datalen;
14387 : {
14388 : size_t sam_challenge_Tag_datalen, sam_challenge_Tag_oldlen;
14389 : Der_type sam_challenge_Tag_type;
14390 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &sam_challenge_Tag_type, UT_GeneralString, &sam_challenge_Tag_datalen, &l);
14391 0 : if (e == 0 && sam_challenge_Tag_type != PRIM) { e = ASN1_BAD_ID; }
14392 0 : if(e) goto fail;
14393 0 : p += l; len -= l; ret += l;
14394 0 : sam_challenge_Tag_oldlen = len;
14395 0 : if (sam_challenge_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
14396 0 : len = sam_challenge_Tag_datalen;
14397 0 : e = der_get_general_string(p, len, (data)->sam_challenge, &l);
14398 0 : if(e) goto fail;
14399 0 : p += l; len -= l; ret += l;
14400 0 : len = sam_challenge_Tag_oldlen - sam_challenge_Tag_datalen;
14401 : }
14402 0 : len = sam_challenge_oldlen - sam_challenge_datalen;
14403 : }
14404 : }
14405 : {
14406 : size_t sam_response_prompt_datalen, sam_response_prompt_oldlen;
14407 : Der_type sam_response_prompt_type;
14408 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &sam_response_prompt_type, 6, &sam_response_prompt_datalen, &l);
14409 0 : if (e == 0 && sam_response_prompt_type != CONS) { e = ASN1_BAD_ID; }
14410 0 : if(e) {
14411 0 : (data)->sam_response_prompt = NULL;
14412 : } else {
14413 0 : (data)->sam_response_prompt = calloc(1, sizeof(*(data)->sam_response_prompt));
14414 0 : if ((data)->sam_response_prompt == NULL) { e = ENOMEM; goto fail; }
14415 0 : p += l; len -= l; ret += l;
14416 0 : sam_response_prompt_oldlen = len;
14417 0 : if (sam_response_prompt_datalen > len) { e = ASN1_OVERRUN; goto fail; }
14418 0 : len = sam_response_prompt_datalen;
14419 : {
14420 : size_t sam_response_prompt_Tag_datalen, sam_response_prompt_Tag_oldlen;
14421 : Der_type sam_response_prompt_Tag_type;
14422 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &sam_response_prompt_Tag_type, UT_GeneralString, &sam_response_prompt_Tag_datalen, &l);
14423 0 : if (e == 0 && sam_response_prompt_Tag_type != PRIM) { e = ASN1_BAD_ID; }
14424 0 : if(e) goto fail;
14425 0 : p += l; len -= l; ret += l;
14426 0 : sam_response_prompt_Tag_oldlen = len;
14427 0 : if (sam_response_prompt_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
14428 0 : len = sam_response_prompt_Tag_datalen;
14429 0 : e = der_get_general_string(p, len, (data)->sam_response_prompt, &l);
14430 0 : if(e) goto fail;
14431 0 : p += l; len -= l; ret += l;
14432 0 : len = sam_response_prompt_Tag_oldlen - sam_response_prompt_Tag_datalen;
14433 : }
14434 0 : len = sam_response_prompt_oldlen - sam_response_prompt_datalen;
14435 : }
14436 : }
14437 : {
14438 : size_t sam_pk_for_sad_datalen, sam_pk_for_sad_oldlen;
14439 : Der_type sam_pk_for_sad_type;
14440 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &sam_pk_for_sad_type, 7, &sam_pk_for_sad_datalen, &l);
14441 0 : if (e == 0 && sam_pk_for_sad_type != CONS) { e = ASN1_BAD_ID; }
14442 0 : if(e) {
14443 0 : (data)->sam_pk_for_sad = NULL;
14444 : } else {
14445 0 : (data)->sam_pk_for_sad = calloc(1, sizeof(*(data)->sam_pk_for_sad));
14446 0 : if ((data)->sam_pk_for_sad == NULL) { e = ENOMEM; goto fail; }
14447 0 : p += l; len -= l; ret += l;
14448 0 : sam_pk_for_sad_oldlen = len;
14449 0 : if (sam_pk_for_sad_datalen > len) { e = ASN1_OVERRUN; goto fail; }
14450 0 : len = sam_pk_for_sad_datalen;
14451 0 : e = decode_EncryptionKey(p, len, (data)->sam_pk_for_sad, &l);
14452 0 : if(e) goto fail;
14453 0 : p += l; len -= l; ret += l;
14454 0 : len = sam_pk_for_sad_oldlen - sam_pk_for_sad_datalen;
14455 : }
14456 : }
14457 : {
14458 : size_t sam_nonce_datalen, sam_nonce_oldlen;
14459 : Der_type sam_nonce_type;
14460 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &sam_nonce_type, 8, &sam_nonce_datalen, &l);
14461 0 : if (e == 0 && sam_nonce_type != CONS) { e = ASN1_BAD_ID; }
14462 0 : if(e) goto fail;
14463 0 : p += l; len -= l; ret += l;
14464 0 : sam_nonce_oldlen = len;
14465 0 : if (sam_nonce_datalen > len) { e = ASN1_OVERRUN; goto fail; }
14466 0 : len = sam_nonce_datalen;
14467 0 : e = decode_krb5int32(p, len, &(data)->sam_nonce, &l);
14468 0 : if(e) goto fail;
14469 0 : p += l; len -= l; ret += l;
14470 0 : len = sam_nonce_oldlen - sam_nonce_datalen;
14471 : }
14472 : {
14473 : size_t sam_etype_datalen, sam_etype_oldlen;
14474 : Der_type sam_etype_type;
14475 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &sam_etype_type, 9, &sam_etype_datalen, &l);
14476 0 : if (e == 0 && sam_etype_type != CONS) { e = ASN1_BAD_ID; }
14477 0 : if(e) goto fail;
14478 0 : p += l; len -= l; ret += l;
14479 0 : sam_etype_oldlen = len;
14480 0 : if (sam_etype_datalen > len) { e = ASN1_OVERRUN; goto fail; }
14481 0 : len = sam_etype_datalen;
14482 0 : e = decode_krb5int32(p, len, &(data)->sam_etype, &l);
14483 0 : if(e) goto fail;
14484 0 : p += l; len -= l; ret += l;
14485 0 : len = sam_etype_oldlen - sam_etype_datalen;
14486 : }
14487 0 : len = Top_oldlen - Top_datalen;
14488 : }
14489 0 : if(size) *size = ret;
14490 0 : return 0;
14491 0 : fail:
14492 0 : free_PA_SAM_CHALLENGE_2_BODY(data);
14493 0 : return e;
14494 : }
14495 :
14496 : void ASN1CALL
14497 0 : free_PA_SAM_CHALLENGE_2_BODY(PA_SAM_CHALLENGE_2_BODY *data)
14498 : {
14499 0 : free_krb5int32(&(data)->sam_type);
14500 0 : free_SAMFlags(&(data)->sam_flags);
14501 0 : if((data)->sam_type_name) {
14502 0 : der_free_general_string((data)->sam_type_name);
14503 0 : free((data)->sam_type_name);
14504 0 : (data)->sam_type_name = NULL;
14505 : }
14506 0 : if((data)->sam_track_id) {
14507 0 : der_free_general_string((data)->sam_track_id);
14508 0 : free((data)->sam_track_id);
14509 0 : (data)->sam_track_id = NULL;
14510 : }
14511 0 : if((data)->sam_challenge_label) {
14512 0 : der_free_general_string((data)->sam_challenge_label);
14513 0 : free((data)->sam_challenge_label);
14514 0 : (data)->sam_challenge_label = NULL;
14515 : }
14516 0 : if((data)->sam_challenge) {
14517 0 : der_free_general_string((data)->sam_challenge);
14518 0 : free((data)->sam_challenge);
14519 0 : (data)->sam_challenge = NULL;
14520 : }
14521 0 : if((data)->sam_response_prompt) {
14522 0 : der_free_general_string((data)->sam_response_prompt);
14523 0 : free((data)->sam_response_prompt);
14524 0 : (data)->sam_response_prompt = NULL;
14525 : }
14526 0 : if((data)->sam_pk_for_sad) {
14527 0 : free_EncryptionKey((data)->sam_pk_for_sad);
14528 0 : free((data)->sam_pk_for_sad);
14529 0 : (data)->sam_pk_for_sad = NULL;
14530 : }
14531 0 : free_krb5int32(&(data)->sam_nonce);
14532 0 : free_krb5int32(&(data)->sam_etype);
14533 0 : }
14534 :
14535 : size_t ASN1CALL
14536 0 : length_PA_SAM_CHALLENGE_2_BODY(const PA_SAM_CHALLENGE_2_BODY *data)
14537 : {
14538 0 : size_t ret = 0;
14539 : {
14540 0 : size_t Top_tag_oldret = ret;
14541 0 : ret = 0;
14542 0 : ret += length_krb5int32(&(data)->sam_type);
14543 0 : ret += 1 + der_length_len (ret);
14544 0 : ret += Top_tag_oldret;
14545 : }
14546 : {
14547 0 : size_t Top_tag_oldret = ret;
14548 0 : ret = 0;
14549 0 : ret += length_SAMFlags(&(data)->sam_flags);
14550 0 : ret += 1 + der_length_len (ret);
14551 0 : ret += Top_tag_oldret;
14552 : }
14553 0 : if((data)->sam_type_name){
14554 0 : size_t Top_tag_oldret = ret;
14555 0 : ret = 0;
14556 0 : ret += der_length_general_string((data)->sam_type_name);
14557 0 : ret += 1 + der_length_len (ret);
14558 0 : ret += 1 + der_length_len (ret);
14559 0 : ret += Top_tag_oldret;
14560 : }
14561 0 : if((data)->sam_track_id){
14562 0 : size_t Top_tag_oldret = ret;
14563 0 : ret = 0;
14564 0 : ret += der_length_general_string((data)->sam_track_id);
14565 0 : ret += 1 + der_length_len (ret);
14566 0 : ret += 1 + der_length_len (ret);
14567 0 : ret += Top_tag_oldret;
14568 : }
14569 0 : if((data)->sam_challenge_label){
14570 0 : size_t Top_tag_oldret = ret;
14571 0 : ret = 0;
14572 0 : ret += der_length_general_string((data)->sam_challenge_label);
14573 0 : ret += 1 + der_length_len (ret);
14574 0 : ret += 1 + der_length_len (ret);
14575 0 : ret += Top_tag_oldret;
14576 : }
14577 0 : if((data)->sam_challenge){
14578 0 : size_t Top_tag_oldret = ret;
14579 0 : ret = 0;
14580 0 : ret += der_length_general_string((data)->sam_challenge);
14581 0 : ret += 1 + der_length_len (ret);
14582 0 : ret += 1 + der_length_len (ret);
14583 0 : ret += Top_tag_oldret;
14584 : }
14585 0 : if((data)->sam_response_prompt){
14586 0 : size_t Top_tag_oldret = ret;
14587 0 : ret = 0;
14588 0 : ret += der_length_general_string((data)->sam_response_prompt);
14589 0 : ret += 1 + der_length_len (ret);
14590 0 : ret += 1 + der_length_len (ret);
14591 0 : ret += Top_tag_oldret;
14592 : }
14593 0 : if((data)->sam_pk_for_sad){
14594 0 : size_t Top_tag_oldret = ret;
14595 0 : ret = 0;
14596 0 : ret += length_EncryptionKey((data)->sam_pk_for_sad);
14597 0 : ret += 1 + der_length_len (ret);
14598 0 : ret += Top_tag_oldret;
14599 : }
14600 : {
14601 0 : size_t Top_tag_oldret = ret;
14602 0 : ret = 0;
14603 0 : ret += length_krb5int32(&(data)->sam_nonce);
14604 0 : ret += 1 + der_length_len (ret);
14605 0 : ret += Top_tag_oldret;
14606 : }
14607 : {
14608 0 : size_t Top_tag_oldret = ret;
14609 0 : ret = 0;
14610 0 : ret += length_krb5int32(&(data)->sam_etype);
14611 0 : ret += 1 + der_length_len (ret);
14612 0 : ret += Top_tag_oldret;
14613 : }
14614 0 : ret += 1 + der_length_len (ret);
14615 0 : return ret;
14616 : }
14617 :
14618 : int ASN1CALL
14619 0 : copy_PA_SAM_CHALLENGE_2_BODY(const PA_SAM_CHALLENGE_2_BODY *from, PA_SAM_CHALLENGE_2_BODY *to)
14620 : {
14621 0 : memset(to, 0, sizeof(*to));
14622 0 : if(copy_krb5int32(&(from)->sam_type, &(to)->sam_type)) goto fail;
14623 0 : if(copy_SAMFlags(&(from)->sam_flags, &(to)->sam_flags)) goto fail;
14624 0 : if((from)->sam_type_name) {
14625 0 : (to)->sam_type_name = malloc(sizeof(*(to)->sam_type_name));
14626 0 : if((to)->sam_type_name == NULL) goto fail;
14627 0 : if(der_copy_general_string((from)->sam_type_name, (to)->sam_type_name)) goto fail;
14628 : }else
14629 0 : (to)->sam_type_name = NULL;
14630 0 : if((from)->sam_track_id) {
14631 0 : (to)->sam_track_id = malloc(sizeof(*(to)->sam_track_id));
14632 0 : if((to)->sam_track_id == NULL) goto fail;
14633 0 : if(der_copy_general_string((from)->sam_track_id, (to)->sam_track_id)) goto fail;
14634 : }else
14635 0 : (to)->sam_track_id = NULL;
14636 0 : if((from)->sam_challenge_label) {
14637 0 : (to)->sam_challenge_label = malloc(sizeof(*(to)->sam_challenge_label));
14638 0 : if((to)->sam_challenge_label == NULL) goto fail;
14639 0 : if(der_copy_general_string((from)->sam_challenge_label, (to)->sam_challenge_label)) goto fail;
14640 : }else
14641 0 : (to)->sam_challenge_label = NULL;
14642 0 : if((from)->sam_challenge) {
14643 0 : (to)->sam_challenge = malloc(sizeof(*(to)->sam_challenge));
14644 0 : if((to)->sam_challenge == NULL) goto fail;
14645 0 : if(der_copy_general_string((from)->sam_challenge, (to)->sam_challenge)) goto fail;
14646 : }else
14647 0 : (to)->sam_challenge = NULL;
14648 0 : if((from)->sam_response_prompt) {
14649 0 : (to)->sam_response_prompt = malloc(sizeof(*(to)->sam_response_prompt));
14650 0 : if((to)->sam_response_prompt == NULL) goto fail;
14651 0 : if(der_copy_general_string((from)->sam_response_prompt, (to)->sam_response_prompt)) goto fail;
14652 : }else
14653 0 : (to)->sam_response_prompt = NULL;
14654 0 : if((from)->sam_pk_for_sad) {
14655 0 : (to)->sam_pk_for_sad = malloc(sizeof(*(to)->sam_pk_for_sad));
14656 0 : if((to)->sam_pk_for_sad == NULL) goto fail;
14657 0 : if(copy_EncryptionKey((from)->sam_pk_for_sad, (to)->sam_pk_for_sad)) goto fail;
14658 : }else
14659 0 : (to)->sam_pk_for_sad = NULL;
14660 0 : if(copy_krb5int32(&(from)->sam_nonce, &(to)->sam_nonce)) goto fail;
14661 0 : if(copy_krb5int32(&(from)->sam_etype, &(to)->sam_etype)) goto fail;
14662 0 : return 0;
14663 0 : fail:
14664 0 : free_PA_SAM_CHALLENGE_2_BODY(to);
14665 0 : return ENOMEM;
14666 : }
14667 :
14668 : int ASN1CALL
14669 0 : encode_PA_SAM_CHALLENGE_2(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const PA_SAM_CHALLENGE_2 *data, size_t *size)
14670 : {
14671 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
14672 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
14673 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
14674 :
14675 : /* sam-cksum */
14676 : {
14677 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
14678 0 : ret = 0;
14679 0 : for(i = (int)(&(data)->sam_cksum)->len - 1; i >= 0; --i) {
14680 0 : size_t sam_cksum_tag_tag_for_oldret = ret;
14681 0 : ret = 0;
14682 0 : e = encode_Checksum(p, len, &(&(data)->sam_cksum)->val[i], &l);
14683 0 : if (e) return e;
14684 0 : p -= l; len -= l; ret += l;
14685 :
14686 0 : ret += sam_cksum_tag_tag_for_oldret;
14687 : }
14688 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
14689 0 : if (e) return e;
14690 0 : p -= l; len -= l; ret += l;
14691 :
14692 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
14693 0 : if (e) return e;
14694 0 : p -= l; len -= l; ret += l;
14695 :
14696 0 : ret += Top_tag_oldret;
14697 : }
14698 : /* sam-body */
14699 : {
14700 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
14701 0 : ret = 0;
14702 0 : e = encode_PA_SAM_CHALLENGE_2_BODY(p, len, &(data)->sam_body, &l);
14703 0 : if (e) return e;
14704 0 : p -= l; len -= l; ret += l;
14705 :
14706 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
14707 0 : if (e) return e;
14708 0 : p -= l; len -= l; ret += l;
14709 :
14710 0 : ret += Top_tag_oldret;
14711 : }
14712 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
14713 0 : if (e) return e;
14714 0 : p -= l; len -= l; ret += l;
14715 :
14716 0 : *size = ret;
14717 0 : return 0;
14718 : }
14719 :
14720 : int ASN1CALL
14721 0 : decode_PA_SAM_CHALLENGE_2(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, PA_SAM_CHALLENGE_2 *data, size_t *size)
14722 : {
14723 0 : size_t ret = 0;
14724 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
14725 : int e HEIMDAL_UNUSED_ATTRIBUTE;
14726 :
14727 0 : memset(data, 0, sizeof(*data));
14728 : {
14729 : size_t Top_datalen, Top_oldlen;
14730 : Der_type Top_type;
14731 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
14732 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
14733 0 : if(e) goto fail;
14734 0 : p += l; len -= l; ret += l;
14735 0 : Top_oldlen = len;
14736 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
14737 0 : len = Top_datalen;
14738 : {
14739 : size_t sam_body_datalen, sam_body_oldlen;
14740 : Der_type sam_body_type;
14741 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &sam_body_type, 0, &sam_body_datalen, &l);
14742 0 : if (e == 0 && sam_body_type != CONS) { e = ASN1_BAD_ID; }
14743 0 : if(e) goto fail;
14744 0 : p += l; len -= l; ret += l;
14745 0 : sam_body_oldlen = len;
14746 0 : if (sam_body_datalen > len) { e = ASN1_OVERRUN; goto fail; }
14747 0 : len = sam_body_datalen;
14748 0 : e = decode_PA_SAM_CHALLENGE_2_BODY(p, len, &(data)->sam_body, &l);
14749 0 : if(e) goto fail;
14750 0 : p += l; len -= l; ret += l;
14751 0 : len = sam_body_oldlen - sam_body_datalen;
14752 : }
14753 : {
14754 : size_t sam_cksum_datalen, sam_cksum_oldlen;
14755 : Der_type sam_cksum_type;
14756 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &sam_cksum_type, 1, &sam_cksum_datalen, &l);
14757 0 : if (e == 0 && sam_cksum_type != CONS) { e = ASN1_BAD_ID; }
14758 0 : if(e) goto fail;
14759 0 : p += l; len -= l; ret += l;
14760 0 : sam_cksum_oldlen = len;
14761 0 : if (sam_cksum_datalen > len) { e = ASN1_OVERRUN; goto fail; }
14762 0 : len = sam_cksum_datalen;
14763 : {
14764 : size_t sam_cksum_Tag_datalen, sam_cksum_Tag_oldlen;
14765 : Der_type sam_cksum_Tag_type;
14766 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &sam_cksum_Tag_type, UT_Sequence, &sam_cksum_Tag_datalen, &l);
14767 0 : if (e == 0 && sam_cksum_Tag_type != CONS) { e = ASN1_BAD_ID; }
14768 0 : if(e) goto fail;
14769 0 : p += l; len -= l; ret += l;
14770 0 : sam_cksum_Tag_oldlen = len;
14771 0 : if (sam_cksum_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
14772 0 : len = sam_cksum_Tag_datalen;
14773 : {
14774 0 : size_t sam_cksum_Tag_Tag_origlen = len;
14775 0 : size_t sam_cksum_Tag_Tag_oldret = ret;
14776 0 : size_t sam_cksum_Tag_Tag_olen = 0;
14777 : void *sam_cksum_Tag_Tag_tmp;
14778 0 : ret = 0;
14779 0 : (&(data)->sam_cksum)->len = 0;
14780 0 : (&(data)->sam_cksum)->val = NULL;
14781 0 : while(ret < sam_cksum_Tag_Tag_origlen) {
14782 0 : size_t sam_cksum_Tag_Tag_nlen = sam_cksum_Tag_Tag_olen + sizeof(*((&(data)->sam_cksum)->val));
14783 0 : if (sam_cksum_Tag_Tag_olen > sam_cksum_Tag_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
14784 0 : sam_cksum_Tag_Tag_olen = sam_cksum_Tag_Tag_nlen;
14785 0 : sam_cksum_Tag_Tag_tmp = realloc((&(data)->sam_cksum)->val, sam_cksum_Tag_Tag_olen);
14786 0 : if (sam_cksum_Tag_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
14787 0 : (&(data)->sam_cksum)->val = sam_cksum_Tag_Tag_tmp;
14788 0 : e = decode_Checksum(p, len, &(&(data)->sam_cksum)->val[(&(data)->sam_cksum)->len], &l);
14789 0 : if(e) goto fail;
14790 0 : p += l; len -= l; ret += l;
14791 0 : (&(data)->sam_cksum)->len++;
14792 0 : len = sam_cksum_Tag_Tag_origlen - ret;
14793 : }
14794 0 : ret += sam_cksum_Tag_Tag_oldret;
14795 : }
14796 0 : len = sam_cksum_Tag_oldlen - sam_cksum_Tag_datalen;
14797 : }
14798 0 : len = sam_cksum_oldlen - sam_cksum_datalen;
14799 : }
14800 0 : len = Top_oldlen - Top_datalen;
14801 : }
14802 0 : if(size) *size = ret;
14803 0 : return 0;
14804 0 : fail:
14805 0 : free_PA_SAM_CHALLENGE_2(data);
14806 0 : return e;
14807 : }
14808 :
14809 : void ASN1CALL
14810 0 : free_PA_SAM_CHALLENGE_2(PA_SAM_CHALLENGE_2 *data)
14811 : {
14812 0 : free_PA_SAM_CHALLENGE_2_BODY(&(data)->sam_body);
14813 0 : while((&(data)->sam_cksum)->len){
14814 0 : free_Checksum(&(&(data)->sam_cksum)->val[(&(data)->sam_cksum)->len-1]);
14815 0 : (&(data)->sam_cksum)->len--;
14816 : }
14817 0 : free((&(data)->sam_cksum)->val);
14818 0 : (&(data)->sam_cksum)->val = NULL;
14819 0 : }
14820 :
14821 : size_t ASN1CALL
14822 0 : length_PA_SAM_CHALLENGE_2(const PA_SAM_CHALLENGE_2 *data)
14823 : {
14824 0 : size_t ret = 0;
14825 : {
14826 0 : size_t Top_tag_oldret = ret;
14827 0 : ret = 0;
14828 0 : ret += length_PA_SAM_CHALLENGE_2_BODY(&(data)->sam_body);
14829 0 : ret += 1 + der_length_len (ret);
14830 0 : ret += Top_tag_oldret;
14831 : }
14832 : {
14833 0 : size_t Top_tag_oldret = ret;
14834 0 : ret = 0;
14835 : {
14836 0 : size_t sam_cksum_tag_tag_oldret = ret;
14837 : int i;
14838 0 : ret = 0;
14839 0 : for(i = (&(data)->sam_cksum)->len - 1; i >= 0; --i){
14840 0 : size_t sam_cksum_tag_tag_for_oldret = ret;
14841 0 : ret = 0;
14842 0 : ret += length_Checksum(&(&(data)->sam_cksum)->val[i]);
14843 0 : ret += sam_cksum_tag_tag_for_oldret;
14844 : }
14845 0 : ret += sam_cksum_tag_tag_oldret;
14846 : }
14847 0 : ret += 1 + der_length_len (ret);
14848 0 : ret += 1 + der_length_len (ret);
14849 0 : ret += Top_tag_oldret;
14850 : }
14851 0 : ret += 1 + der_length_len (ret);
14852 0 : return ret;
14853 : }
14854 :
14855 : int ASN1CALL
14856 0 : copy_PA_SAM_CHALLENGE_2(const PA_SAM_CHALLENGE_2 *from, PA_SAM_CHALLENGE_2 *to)
14857 : {
14858 0 : memset(to, 0, sizeof(*to));
14859 0 : if(copy_PA_SAM_CHALLENGE_2_BODY(&(from)->sam_body, &(to)->sam_body)) goto fail;
14860 0 : if(((&(to)->sam_cksum)->val = malloc((&(from)->sam_cksum)->len * sizeof(*(&(to)->sam_cksum)->val))) == NULL && (&(from)->sam_cksum)->len != 0)
14861 0 : goto fail;
14862 0 : for((&(to)->sam_cksum)->len = 0; (&(to)->sam_cksum)->len < (&(from)->sam_cksum)->len; (&(to)->sam_cksum)->len++){
14863 0 : if(copy_Checksum(&(&(from)->sam_cksum)->val[(&(to)->sam_cksum)->len], &(&(to)->sam_cksum)->val[(&(to)->sam_cksum)->len])) goto fail;
14864 : }
14865 0 : return 0;
14866 0 : fail:
14867 0 : free_PA_SAM_CHALLENGE_2(to);
14868 0 : return ENOMEM;
14869 : }
14870 :
14871 : int ASN1CALL
14872 0 : encode_PA_SAM_RESPONSE_2(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const PA_SAM_RESPONSE_2 *data, size_t *size)
14873 : {
14874 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
14875 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
14876 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
14877 :
14878 : /* sam-nonce */
14879 : {
14880 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
14881 0 : ret = 0;
14882 0 : e = encode_krb5int32(p, len, &(data)->sam_nonce, &l);
14883 0 : if (e) return e;
14884 0 : p -= l; len -= l; ret += l;
14885 :
14886 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 4, &l);
14887 0 : if (e) return e;
14888 0 : p -= l; len -= l; ret += l;
14889 :
14890 0 : ret += Top_tag_oldret;
14891 : }
14892 : /* sam-enc-nonce-or-sad */
14893 : {
14894 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
14895 0 : ret = 0;
14896 0 : e = encode_EncryptedData(p, len, &(data)->sam_enc_nonce_or_sad, &l);
14897 0 : if (e) return e;
14898 0 : p -= l; len -= l; ret += l;
14899 :
14900 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
14901 0 : if (e) return e;
14902 0 : p -= l; len -= l; ret += l;
14903 :
14904 0 : ret += Top_tag_oldret;
14905 : }
14906 : /* sam-track-id */
14907 0 : if((data)->sam_track_id) {
14908 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
14909 0 : ret = 0;
14910 0 : e = der_put_general_string(p, len, (data)->sam_track_id, &l);
14911 0 : if (e) return e;
14912 0 : p -= l; len -= l; ret += l;
14913 :
14914 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_GeneralString, &l);
14915 0 : if (e) return e;
14916 0 : p -= l; len -= l; ret += l;
14917 :
14918 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
14919 0 : if (e) return e;
14920 0 : p -= l; len -= l; ret += l;
14921 :
14922 0 : ret += Top_tag_oldret;
14923 : }
14924 : /* sam-flags */
14925 : {
14926 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
14927 0 : ret = 0;
14928 0 : e = encode_SAMFlags(p, len, &(data)->sam_flags, &l);
14929 0 : if (e) return e;
14930 0 : p -= l; len -= l; ret += l;
14931 :
14932 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
14933 0 : if (e) return e;
14934 0 : p -= l; len -= l; ret += l;
14935 :
14936 0 : ret += Top_tag_oldret;
14937 : }
14938 : /* sam-type */
14939 : {
14940 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
14941 0 : ret = 0;
14942 0 : e = encode_krb5int32(p, len, &(data)->sam_type, &l);
14943 0 : if (e) return e;
14944 0 : p -= l; len -= l; ret += l;
14945 :
14946 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
14947 0 : if (e) return e;
14948 0 : p -= l; len -= l; ret += l;
14949 :
14950 0 : ret += Top_tag_oldret;
14951 : }
14952 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
14953 0 : if (e) return e;
14954 0 : p -= l; len -= l; ret += l;
14955 :
14956 0 : *size = ret;
14957 0 : return 0;
14958 : }
14959 :
14960 : int ASN1CALL
14961 0 : decode_PA_SAM_RESPONSE_2(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, PA_SAM_RESPONSE_2 *data, size_t *size)
14962 : {
14963 0 : size_t ret = 0;
14964 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
14965 : int e HEIMDAL_UNUSED_ATTRIBUTE;
14966 :
14967 0 : memset(data, 0, sizeof(*data));
14968 : {
14969 : size_t Top_datalen, Top_oldlen;
14970 : Der_type Top_type;
14971 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
14972 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
14973 0 : if(e) goto fail;
14974 0 : p += l; len -= l; ret += l;
14975 0 : Top_oldlen = len;
14976 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
14977 0 : len = Top_datalen;
14978 : {
14979 : size_t sam_type_datalen, sam_type_oldlen;
14980 : Der_type sam_type_type;
14981 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &sam_type_type, 0, &sam_type_datalen, &l);
14982 0 : if (e == 0 && sam_type_type != CONS) { e = ASN1_BAD_ID; }
14983 0 : if(e) goto fail;
14984 0 : p += l; len -= l; ret += l;
14985 0 : sam_type_oldlen = len;
14986 0 : if (sam_type_datalen > len) { e = ASN1_OVERRUN; goto fail; }
14987 0 : len = sam_type_datalen;
14988 0 : e = decode_krb5int32(p, len, &(data)->sam_type, &l);
14989 0 : if(e) goto fail;
14990 0 : p += l; len -= l; ret += l;
14991 0 : len = sam_type_oldlen - sam_type_datalen;
14992 : }
14993 : {
14994 : size_t sam_flags_datalen, sam_flags_oldlen;
14995 : Der_type sam_flags_type;
14996 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &sam_flags_type, 1, &sam_flags_datalen, &l);
14997 0 : if (e == 0 && sam_flags_type != CONS) { e = ASN1_BAD_ID; }
14998 0 : if(e) goto fail;
14999 0 : p += l; len -= l; ret += l;
15000 0 : sam_flags_oldlen = len;
15001 0 : if (sam_flags_datalen > len) { e = ASN1_OVERRUN; goto fail; }
15002 0 : len = sam_flags_datalen;
15003 0 : e = decode_SAMFlags(p, len, &(data)->sam_flags, &l);
15004 0 : if(e) goto fail;
15005 0 : p += l; len -= l; ret += l;
15006 0 : len = sam_flags_oldlen - sam_flags_datalen;
15007 : }
15008 : {
15009 : size_t sam_track_id_datalen, sam_track_id_oldlen;
15010 : Der_type sam_track_id_type;
15011 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &sam_track_id_type, 2, &sam_track_id_datalen, &l);
15012 0 : if (e == 0 && sam_track_id_type != CONS) { e = ASN1_BAD_ID; }
15013 0 : if(e) {
15014 0 : (data)->sam_track_id = NULL;
15015 : } else {
15016 0 : (data)->sam_track_id = calloc(1, sizeof(*(data)->sam_track_id));
15017 0 : if ((data)->sam_track_id == NULL) { e = ENOMEM; goto fail; }
15018 0 : p += l; len -= l; ret += l;
15019 0 : sam_track_id_oldlen = len;
15020 0 : if (sam_track_id_datalen > len) { e = ASN1_OVERRUN; goto fail; }
15021 0 : len = sam_track_id_datalen;
15022 : {
15023 : size_t sam_track_id_Tag_datalen, sam_track_id_Tag_oldlen;
15024 : Der_type sam_track_id_Tag_type;
15025 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &sam_track_id_Tag_type, UT_GeneralString, &sam_track_id_Tag_datalen, &l);
15026 0 : if (e == 0 && sam_track_id_Tag_type != PRIM) { e = ASN1_BAD_ID; }
15027 0 : if(e) goto fail;
15028 0 : p += l; len -= l; ret += l;
15029 0 : sam_track_id_Tag_oldlen = len;
15030 0 : if (sam_track_id_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
15031 0 : len = sam_track_id_Tag_datalen;
15032 0 : e = der_get_general_string(p, len, (data)->sam_track_id, &l);
15033 0 : if(e) goto fail;
15034 0 : p += l; len -= l; ret += l;
15035 0 : len = sam_track_id_Tag_oldlen - sam_track_id_Tag_datalen;
15036 : }
15037 0 : len = sam_track_id_oldlen - sam_track_id_datalen;
15038 : }
15039 : }
15040 : {
15041 : size_t sam_enc_nonce_or_sad_datalen, sam_enc_nonce_or_sad_oldlen;
15042 : Der_type sam_enc_nonce_or_sad_type;
15043 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &sam_enc_nonce_or_sad_type, 3, &sam_enc_nonce_or_sad_datalen, &l);
15044 0 : if (e == 0 && sam_enc_nonce_or_sad_type != CONS) { e = ASN1_BAD_ID; }
15045 0 : if(e) goto fail;
15046 0 : p += l; len -= l; ret += l;
15047 0 : sam_enc_nonce_or_sad_oldlen = len;
15048 0 : if (sam_enc_nonce_or_sad_datalen > len) { e = ASN1_OVERRUN; goto fail; }
15049 0 : len = sam_enc_nonce_or_sad_datalen;
15050 0 : e = decode_EncryptedData(p, len, &(data)->sam_enc_nonce_or_sad, &l);
15051 0 : if(e) goto fail;
15052 0 : p += l; len -= l; ret += l;
15053 0 : len = sam_enc_nonce_or_sad_oldlen - sam_enc_nonce_or_sad_datalen;
15054 : }
15055 : {
15056 : size_t sam_nonce_datalen, sam_nonce_oldlen;
15057 : Der_type sam_nonce_type;
15058 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &sam_nonce_type, 4, &sam_nonce_datalen, &l);
15059 0 : if (e == 0 && sam_nonce_type != CONS) { e = ASN1_BAD_ID; }
15060 0 : if(e) goto fail;
15061 0 : p += l; len -= l; ret += l;
15062 0 : sam_nonce_oldlen = len;
15063 0 : if (sam_nonce_datalen > len) { e = ASN1_OVERRUN; goto fail; }
15064 0 : len = sam_nonce_datalen;
15065 0 : e = decode_krb5int32(p, len, &(data)->sam_nonce, &l);
15066 0 : if(e) goto fail;
15067 0 : p += l; len -= l; ret += l;
15068 0 : len = sam_nonce_oldlen - sam_nonce_datalen;
15069 : }
15070 0 : len = Top_oldlen - Top_datalen;
15071 : }
15072 0 : if(size) *size = ret;
15073 0 : return 0;
15074 0 : fail:
15075 0 : free_PA_SAM_RESPONSE_2(data);
15076 0 : return e;
15077 : }
15078 :
15079 : void ASN1CALL
15080 0 : free_PA_SAM_RESPONSE_2(PA_SAM_RESPONSE_2 *data)
15081 : {
15082 0 : free_krb5int32(&(data)->sam_type);
15083 0 : free_SAMFlags(&(data)->sam_flags);
15084 0 : if((data)->sam_track_id) {
15085 0 : der_free_general_string((data)->sam_track_id);
15086 0 : free((data)->sam_track_id);
15087 0 : (data)->sam_track_id = NULL;
15088 : }
15089 0 : free_EncryptedData(&(data)->sam_enc_nonce_or_sad);
15090 0 : free_krb5int32(&(data)->sam_nonce);
15091 0 : }
15092 :
15093 : size_t ASN1CALL
15094 0 : length_PA_SAM_RESPONSE_2(const PA_SAM_RESPONSE_2 *data)
15095 : {
15096 0 : size_t ret = 0;
15097 : {
15098 0 : size_t Top_tag_oldret = ret;
15099 0 : ret = 0;
15100 0 : ret += length_krb5int32(&(data)->sam_type);
15101 0 : ret += 1 + der_length_len (ret);
15102 0 : ret += Top_tag_oldret;
15103 : }
15104 : {
15105 0 : size_t Top_tag_oldret = ret;
15106 0 : ret = 0;
15107 0 : ret += length_SAMFlags(&(data)->sam_flags);
15108 0 : ret += 1 + der_length_len (ret);
15109 0 : ret += Top_tag_oldret;
15110 : }
15111 0 : if((data)->sam_track_id){
15112 0 : size_t Top_tag_oldret = ret;
15113 0 : ret = 0;
15114 0 : ret += der_length_general_string((data)->sam_track_id);
15115 0 : ret += 1 + der_length_len (ret);
15116 0 : ret += 1 + der_length_len (ret);
15117 0 : ret += Top_tag_oldret;
15118 : }
15119 : {
15120 0 : size_t Top_tag_oldret = ret;
15121 0 : ret = 0;
15122 0 : ret += length_EncryptedData(&(data)->sam_enc_nonce_or_sad);
15123 0 : ret += 1 + der_length_len (ret);
15124 0 : ret += Top_tag_oldret;
15125 : }
15126 : {
15127 0 : size_t Top_tag_oldret = ret;
15128 0 : ret = 0;
15129 0 : ret += length_krb5int32(&(data)->sam_nonce);
15130 0 : ret += 1 + der_length_len (ret);
15131 0 : ret += Top_tag_oldret;
15132 : }
15133 0 : ret += 1 + der_length_len (ret);
15134 0 : return ret;
15135 : }
15136 :
15137 : int ASN1CALL
15138 0 : copy_PA_SAM_RESPONSE_2(const PA_SAM_RESPONSE_2 *from, PA_SAM_RESPONSE_2 *to)
15139 : {
15140 0 : memset(to, 0, sizeof(*to));
15141 0 : if(copy_krb5int32(&(from)->sam_type, &(to)->sam_type)) goto fail;
15142 0 : if(copy_SAMFlags(&(from)->sam_flags, &(to)->sam_flags)) goto fail;
15143 0 : if((from)->sam_track_id) {
15144 0 : (to)->sam_track_id = malloc(sizeof(*(to)->sam_track_id));
15145 0 : if((to)->sam_track_id == NULL) goto fail;
15146 0 : if(der_copy_general_string((from)->sam_track_id, (to)->sam_track_id)) goto fail;
15147 : }else
15148 0 : (to)->sam_track_id = NULL;
15149 0 : if(copy_EncryptedData(&(from)->sam_enc_nonce_or_sad, &(to)->sam_enc_nonce_or_sad)) goto fail;
15150 0 : if(copy_krb5int32(&(from)->sam_nonce, &(to)->sam_nonce)) goto fail;
15151 0 : return 0;
15152 0 : fail:
15153 0 : free_PA_SAM_RESPONSE_2(to);
15154 0 : return ENOMEM;
15155 : }
15156 :
15157 : int ASN1CALL
15158 0 : encode_PA_ENC_SAM_RESPONSE_ENC(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const PA_ENC_SAM_RESPONSE_ENC *data, size_t *size)
15159 : {
15160 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
15161 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
15162 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
15163 :
15164 : /* sam-sad */
15165 0 : if((data)->sam_sad) {
15166 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
15167 0 : ret = 0;
15168 0 : e = der_put_general_string(p, len, (data)->sam_sad, &l);
15169 0 : if (e) return e;
15170 0 : p -= l; len -= l; ret += l;
15171 :
15172 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_GeneralString, &l);
15173 0 : if (e) return e;
15174 0 : p -= l; len -= l; ret += l;
15175 :
15176 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
15177 0 : if (e) return e;
15178 0 : p -= l; len -= l; ret += l;
15179 :
15180 0 : ret += Top_tag_oldret;
15181 : }
15182 : /* sam-nonce */
15183 : {
15184 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
15185 0 : ret = 0;
15186 0 : e = encode_krb5int32(p, len, &(data)->sam_nonce, &l);
15187 0 : if (e) return e;
15188 0 : p -= l; len -= l; ret += l;
15189 :
15190 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
15191 0 : if (e) return e;
15192 0 : p -= l; len -= l; ret += l;
15193 :
15194 0 : ret += Top_tag_oldret;
15195 : }
15196 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
15197 0 : if (e) return e;
15198 0 : p -= l; len -= l; ret += l;
15199 :
15200 0 : *size = ret;
15201 0 : return 0;
15202 : }
15203 :
15204 : int ASN1CALL
15205 0 : decode_PA_ENC_SAM_RESPONSE_ENC(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, PA_ENC_SAM_RESPONSE_ENC *data, size_t *size)
15206 : {
15207 0 : size_t ret = 0;
15208 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
15209 : int e HEIMDAL_UNUSED_ATTRIBUTE;
15210 :
15211 0 : memset(data, 0, sizeof(*data));
15212 : {
15213 : size_t Top_datalen, Top_oldlen;
15214 : Der_type Top_type;
15215 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
15216 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
15217 0 : if(e) goto fail;
15218 0 : p += l; len -= l; ret += l;
15219 0 : Top_oldlen = len;
15220 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
15221 0 : len = Top_datalen;
15222 : {
15223 : size_t sam_nonce_datalen, sam_nonce_oldlen;
15224 : Der_type sam_nonce_type;
15225 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &sam_nonce_type, 0, &sam_nonce_datalen, &l);
15226 0 : if (e == 0 && sam_nonce_type != CONS) { e = ASN1_BAD_ID; }
15227 0 : if(e) goto fail;
15228 0 : p += l; len -= l; ret += l;
15229 0 : sam_nonce_oldlen = len;
15230 0 : if (sam_nonce_datalen > len) { e = ASN1_OVERRUN; goto fail; }
15231 0 : len = sam_nonce_datalen;
15232 0 : e = decode_krb5int32(p, len, &(data)->sam_nonce, &l);
15233 0 : if(e) goto fail;
15234 0 : p += l; len -= l; ret += l;
15235 0 : len = sam_nonce_oldlen - sam_nonce_datalen;
15236 : }
15237 : {
15238 : size_t sam_sad_datalen, sam_sad_oldlen;
15239 : Der_type sam_sad_type;
15240 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &sam_sad_type, 1, &sam_sad_datalen, &l);
15241 0 : if (e == 0 && sam_sad_type != CONS) { e = ASN1_BAD_ID; }
15242 0 : if(e) {
15243 0 : (data)->sam_sad = NULL;
15244 : } else {
15245 0 : (data)->sam_sad = calloc(1, sizeof(*(data)->sam_sad));
15246 0 : if ((data)->sam_sad == NULL) { e = ENOMEM; goto fail; }
15247 0 : p += l; len -= l; ret += l;
15248 0 : sam_sad_oldlen = len;
15249 0 : if (sam_sad_datalen > len) { e = ASN1_OVERRUN; goto fail; }
15250 0 : len = sam_sad_datalen;
15251 : {
15252 : size_t sam_sad_Tag_datalen, sam_sad_Tag_oldlen;
15253 : Der_type sam_sad_Tag_type;
15254 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &sam_sad_Tag_type, UT_GeneralString, &sam_sad_Tag_datalen, &l);
15255 0 : if (e == 0 && sam_sad_Tag_type != PRIM) { e = ASN1_BAD_ID; }
15256 0 : if(e) goto fail;
15257 0 : p += l; len -= l; ret += l;
15258 0 : sam_sad_Tag_oldlen = len;
15259 0 : if (sam_sad_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
15260 0 : len = sam_sad_Tag_datalen;
15261 0 : e = der_get_general_string(p, len, (data)->sam_sad, &l);
15262 0 : if(e) goto fail;
15263 0 : p += l; len -= l; ret += l;
15264 0 : len = sam_sad_Tag_oldlen - sam_sad_Tag_datalen;
15265 : }
15266 0 : len = sam_sad_oldlen - sam_sad_datalen;
15267 : }
15268 : }
15269 0 : len = Top_oldlen - Top_datalen;
15270 : }
15271 0 : if(size) *size = ret;
15272 0 : return 0;
15273 0 : fail:
15274 0 : free_PA_ENC_SAM_RESPONSE_ENC(data);
15275 0 : return e;
15276 : }
15277 :
15278 : void ASN1CALL
15279 0 : free_PA_ENC_SAM_RESPONSE_ENC(PA_ENC_SAM_RESPONSE_ENC *data)
15280 : {
15281 0 : free_krb5int32(&(data)->sam_nonce);
15282 0 : if((data)->sam_sad) {
15283 0 : der_free_general_string((data)->sam_sad);
15284 0 : free((data)->sam_sad);
15285 0 : (data)->sam_sad = NULL;
15286 : }
15287 0 : }
15288 :
15289 : size_t ASN1CALL
15290 0 : length_PA_ENC_SAM_RESPONSE_ENC(const PA_ENC_SAM_RESPONSE_ENC *data)
15291 : {
15292 0 : size_t ret = 0;
15293 : {
15294 0 : size_t Top_tag_oldret = ret;
15295 0 : ret = 0;
15296 0 : ret += length_krb5int32(&(data)->sam_nonce);
15297 0 : ret += 1 + der_length_len (ret);
15298 0 : ret += Top_tag_oldret;
15299 : }
15300 0 : if((data)->sam_sad){
15301 0 : size_t Top_tag_oldret = ret;
15302 0 : ret = 0;
15303 0 : ret += der_length_general_string((data)->sam_sad);
15304 0 : ret += 1 + der_length_len (ret);
15305 0 : ret += 1 + der_length_len (ret);
15306 0 : ret += Top_tag_oldret;
15307 : }
15308 0 : ret += 1 + der_length_len (ret);
15309 0 : return ret;
15310 : }
15311 :
15312 : int ASN1CALL
15313 0 : copy_PA_ENC_SAM_RESPONSE_ENC(const PA_ENC_SAM_RESPONSE_ENC *from, PA_ENC_SAM_RESPONSE_ENC *to)
15314 : {
15315 0 : memset(to, 0, sizeof(*to));
15316 0 : if(copy_krb5int32(&(from)->sam_nonce, &(to)->sam_nonce)) goto fail;
15317 0 : if((from)->sam_sad) {
15318 0 : (to)->sam_sad = malloc(sizeof(*(to)->sam_sad));
15319 0 : if((to)->sam_sad == NULL) goto fail;
15320 0 : if(der_copy_general_string((from)->sam_sad, (to)->sam_sad)) goto fail;
15321 : }else
15322 0 : (to)->sam_sad = NULL;
15323 0 : return 0;
15324 0 : fail:
15325 0 : free_PA_ENC_SAM_RESPONSE_ENC(to);
15326 0 : return ENOMEM;
15327 : }
15328 :
15329 : int ASN1CALL
15330 752 : encode_PA_S4U2Self(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const PA_S4U2Self *data, size_t *size)
15331 : {
15332 752 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
15333 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
15334 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
15335 :
15336 : /* auth */
15337 : {
15338 752 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
15339 752 : ret = 0;
15340 752 : e = der_put_general_string(p, len, &(data)->auth, &l);
15341 752 : if (e) return e;
15342 752 : p -= l; len -= l; ret += l;
15343 :
15344 752 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_GeneralString, &l);
15345 752 : if (e) return e;
15346 752 : p -= l; len -= l; ret += l;
15347 :
15348 752 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
15349 752 : if (e) return e;
15350 752 : p -= l; len -= l; ret += l;
15351 :
15352 752 : ret += Top_tag_oldret;
15353 : }
15354 : /* cksum */
15355 : {
15356 752 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
15357 752 : ret = 0;
15358 752 : e = encode_Checksum(p, len, &(data)->cksum, &l);
15359 752 : if (e) return e;
15360 752 : p -= l; len -= l; ret += l;
15361 :
15362 752 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
15363 752 : if (e) return e;
15364 752 : p -= l; len -= l; ret += l;
15365 :
15366 752 : ret += Top_tag_oldret;
15367 : }
15368 : /* realm */
15369 : {
15370 752 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
15371 752 : ret = 0;
15372 752 : e = encode_Realm(p, len, &(data)->realm, &l);
15373 752 : if (e) return e;
15374 752 : p -= l; len -= l; ret += l;
15375 :
15376 752 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
15377 752 : if (e) return e;
15378 752 : p -= l; len -= l; ret += l;
15379 :
15380 752 : ret += Top_tag_oldret;
15381 : }
15382 : /* name */
15383 : {
15384 752 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
15385 752 : ret = 0;
15386 752 : e = encode_PrincipalName(p, len, &(data)->name, &l);
15387 752 : if (e) return e;
15388 752 : p -= l; len -= l; ret += l;
15389 :
15390 752 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
15391 752 : if (e) return e;
15392 752 : p -= l; len -= l; ret += l;
15393 :
15394 752 : ret += Top_tag_oldret;
15395 : }
15396 752 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
15397 752 : if (e) return e;
15398 752 : p -= l; len -= l; ret += l;
15399 :
15400 752 : *size = ret;
15401 752 : return 0;
15402 : }
15403 :
15404 : int ASN1CALL
15405 625 : decode_PA_S4U2Self(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, PA_S4U2Self *data, size_t *size)
15406 : {
15407 625 : size_t ret = 0;
15408 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
15409 : int e HEIMDAL_UNUSED_ATTRIBUTE;
15410 :
15411 625 : memset(data, 0, sizeof(*data));
15412 : {
15413 : size_t Top_datalen, Top_oldlen;
15414 : Der_type Top_type;
15415 625 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
15416 625 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
15417 625 : if(e) goto fail;
15418 625 : p += l; len -= l; ret += l;
15419 625 : Top_oldlen = len;
15420 625 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
15421 625 : len = Top_datalen;
15422 : {
15423 : size_t name_datalen, name_oldlen;
15424 : Der_type name_type;
15425 625 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &name_type, 0, &name_datalen, &l);
15426 625 : if (e == 0 && name_type != CONS) { e = ASN1_BAD_ID; }
15427 625 : if(e) goto fail;
15428 625 : p += l; len -= l; ret += l;
15429 625 : name_oldlen = len;
15430 625 : if (name_datalen > len) { e = ASN1_OVERRUN; goto fail; }
15431 625 : len = name_datalen;
15432 625 : e = decode_PrincipalName(p, len, &(data)->name, &l);
15433 625 : if(e) goto fail;
15434 625 : p += l; len -= l; ret += l;
15435 625 : len = name_oldlen - name_datalen;
15436 : }
15437 : {
15438 : size_t realm_datalen, realm_oldlen;
15439 : Der_type realm_type;
15440 625 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &realm_type, 1, &realm_datalen, &l);
15441 1250 : if (e == 0 && realm_type != CONS) { e = ASN1_BAD_ID; }
15442 625 : if(e) goto fail;
15443 625 : p += l; len -= l; ret += l;
15444 625 : realm_oldlen = len;
15445 625 : if (realm_datalen > len) { e = ASN1_OVERRUN; goto fail; }
15446 625 : len = realm_datalen;
15447 625 : e = decode_Realm(p, len, &(data)->realm, &l);
15448 625 : if(e) goto fail;
15449 625 : p += l; len -= l; ret += l;
15450 625 : len = realm_oldlen - realm_datalen;
15451 : }
15452 : {
15453 : size_t cksum_datalen, cksum_oldlen;
15454 : Der_type cksum_type;
15455 625 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &cksum_type, 2, &cksum_datalen, &l);
15456 1250 : if (e == 0 && cksum_type != CONS) { e = ASN1_BAD_ID; }
15457 625 : if(e) goto fail;
15458 625 : p += l; len -= l; ret += l;
15459 625 : cksum_oldlen = len;
15460 625 : if (cksum_datalen > len) { e = ASN1_OVERRUN; goto fail; }
15461 625 : len = cksum_datalen;
15462 625 : e = decode_Checksum(p, len, &(data)->cksum, &l);
15463 625 : if(e) goto fail;
15464 625 : p += l; len -= l; ret += l;
15465 625 : len = cksum_oldlen - cksum_datalen;
15466 : }
15467 : {
15468 : size_t auth_datalen, auth_oldlen;
15469 : Der_type auth_type;
15470 625 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &auth_type, 3, &auth_datalen, &l);
15471 1250 : if (e == 0 && auth_type != CONS) { e = ASN1_BAD_ID; }
15472 625 : if(e) goto fail;
15473 625 : p += l; len -= l; ret += l;
15474 625 : auth_oldlen = len;
15475 625 : if (auth_datalen > len) { e = ASN1_OVERRUN; goto fail; }
15476 625 : len = auth_datalen;
15477 : {
15478 : size_t auth_Tag_datalen, auth_Tag_oldlen;
15479 : Der_type auth_Tag_type;
15480 625 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &auth_Tag_type, UT_GeneralString, &auth_Tag_datalen, &l);
15481 625 : if (e == 0 && auth_Tag_type != PRIM) { e = ASN1_BAD_ID; }
15482 625 : if(e) goto fail;
15483 625 : p += l; len -= l; ret += l;
15484 625 : auth_Tag_oldlen = len;
15485 625 : if (auth_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
15486 625 : len = auth_Tag_datalen;
15487 625 : e = der_get_general_string(p, len, &(data)->auth, &l);
15488 625 : if(e) goto fail;
15489 625 : p += l; len -= l; ret += l;
15490 625 : len = auth_Tag_oldlen - auth_Tag_datalen;
15491 : }
15492 625 : len = auth_oldlen - auth_datalen;
15493 : }
15494 625 : len = Top_oldlen - Top_datalen;
15495 : }
15496 625 : if(size) *size = ret;
15497 625 : return 0;
15498 0 : fail:
15499 0 : free_PA_S4U2Self(data);
15500 0 : return e;
15501 : }
15502 :
15503 : void ASN1CALL
15504 625 : free_PA_S4U2Self(PA_S4U2Self *data)
15505 : {
15506 625 : free_PrincipalName(&(data)->name);
15507 625 : free_Realm(&(data)->realm);
15508 625 : free_Checksum(&(data)->cksum);
15509 625 : der_free_general_string(&(data)->auth);
15510 625 : }
15511 :
15512 : size_t ASN1CALL
15513 752 : length_PA_S4U2Self(const PA_S4U2Self *data)
15514 : {
15515 752 : size_t ret = 0;
15516 : {
15517 752 : size_t Top_tag_oldret = ret;
15518 752 : ret = 0;
15519 752 : ret += length_PrincipalName(&(data)->name);
15520 752 : ret += 1 + der_length_len (ret);
15521 752 : ret += Top_tag_oldret;
15522 : }
15523 : {
15524 752 : size_t Top_tag_oldret = ret;
15525 752 : ret = 0;
15526 752 : ret += length_Realm(&(data)->realm);
15527 752 : ret += 1 + der_length_len (ret);
15528 752 : ret += Top_tag_oldret;
15529 : }
15530 : {
15531 752 : size_t Top_tag_oldret = ret;
15532 752 : ret = 0;
15533 752 : ret += length_Checksum(&(data)->cksum);
15534 752 : ret += 1 + der_length_len (ret);
15535 752 : ret += Top_tag_oldret;
15536 : }
15537 : {
15538 752 : size_t Top_tag_oldret = ret;
15539 752 : ret = 0;
15540 752 : ret += der_length_general_string(&(data)->auth);
15541 752 : ret += 1 + der_length_len (ret);
15542 752 : ret += 1 + der_length_len (ret);
15543 752 : ret += Top_tag_oldret;
15544 : }
15545 752 : ret += 1 + der_length_len (ret);
15546 752 : return ret;
15547 : }
15548 :
15549 : int ASN1CALL
15550 0 : copy_PA_S4U2Self(const PA_S4U2Self *from, PA_S4U2Self *to)
15551 : {
15552 0 : memset(to, 0, sizeof(*to));
15553 0 : if(copy_PrincipalName(&(from)->name, &(to)->name)) goto fail;
15554 0 : if(copy_Realm(&(from)->realm, &(to)->realm)) goto fail;
15555 0 : if(copy_Checksum(&(from)->cksum, &(to)->cksum)) goto fail;
15556 0 : if(der_copy_general_string(&(from)->auth, &(to)->auth)) goto fail;
15557 0 : return 0;
15558 0 : fail:
15559 0 : free_PA_S4U2Self(to);
15560 0 : return ENOMEM;
15561 : }
15562 :
15563 : int ASN1CALL
15564 104469 : encode_KRB5SignedPathData(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const KRB5SignedPathData *data, size_t *size)
15565 : {
15566 104469 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
15567 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
15568 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
15569 :
15570 : /* method_data */
15571 104469 : if((data)->method_data) {
15572 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
15573 0 : ret = 0;
15574 0 : e = encode_METHOD_DATA(p, len, (data)->method_data, &l);
15575 0 : if (e) return e;
15576 0 : p -= l; len -= l; ret += l;
15577 :
15578 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
15579 0 : if (e) return e;
15580 0 : p -= l; len -= l; ret += l;
15581 :
15582 0 : ret += Top_tag_oldret;
15583 : }
15584 : /* delegated */
15585 104469 : if((data)->delegated) {
15586 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
15587 0 : ret = 0;
15588 0 : e = encode_Principals(p, len, (data)->delegated, &l);
15589 0 : if (e) return e;
15590 0 : p -= l; len -= l; ret += l;
15591 :
15592 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
15593 0 : if (e) return e;
15594 0 : p -= l; len -= l; ret += l;
15595 :
15596 0 : ret += Top_tag_oldret;
15597 : }
15598 : /* authtime */
15599 : {
15600 104469 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
15601 104469 : ret = 0;
15602 104469 : e = encode_KerberosTime(p, len, &(data)->authtime, &l);
15603 104469 : if (e) return e;
15604 104469 : p -= l; len -= l; ret += l;
15605 :
15606 104469 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
15607 104469 : if (e) return e;
15608 104469 : p -= l; len -= l; ret += l;
15609 :
15610 104469 : ret += Top_tag_oldret;
15611 : }
15612 : /* client */
15613 104469 : if((data)->client) {
15614 104469 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
15615 104469 : ret = 0;
15616 104469 : e = encode_Principal(p, len, (data)->client, &l);
15617 104469 : if (e) return e;
15618 104469 : p -= l; len -= l; ret += l;
15619 :
15620 104469 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
15621 104469 : if (e) return e;
15622 104469 : p -= l; len -= l; ret += l;
15623 :
15624 104469 : ret += Top_tag_oldret;
15625 : }
15626 104469 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
15627 104469 : if (e) return e;
15628 104469 : p -= l; len -= l; ret += l;
15629 :
15630 104469 : *size = ret;
15631 104469 : return 0;
15632 : }
15633 :
15634 : int ASN1CALL
15635 0 : decode_KRB5SignedPathData(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, KRB5SignedPathData *data, size_t *size)
15636 : {
15637 0 : size_t ret = 0;
15638 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
15639 : int e HEIMDAL_UNUSED_ATTRIBUTE;
15640 :
15641 0 : memset(data, 0, sizeof(*data));
15642 : {
15643 : size_t Top_datalen, Top_oldlen;
15644 : Der_type Top_type;
15645 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
15646 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
15647 0 : if(e) goto fail;
15648 0 : p += l; len -= l; ret += l;
15649 0 : Top_oldlen = len;
15650 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
15651 0 : len = Top_datalen;
15652 : {
15653 : size_t client_datalen, client_oldlen;
15654 : Der_type client_type;
15655 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &client_type, 0, &client_datalen, &l);
15656 0 : if (e == 0 && client_type != CONS) { e = ASN1_BAD_ID; }
15657 0 : if(e) {
15658 0 : (data)->client = NULL;
15659 : } else {
15660 0 : (data)->client = calloc(1, sizeof(*(data)->client));
15661 0 : if ((data)->client == NULL) { e = ENOMEM; goto fail; }
15662 0 : p += l; len -= l; ret += l;
15663 0 : client_oldlen = len;
15664 0 : if (client_datalen > len) { e = ASN1_OVERRUN; goto fail; }
15665 0 : len = client_datalen;
15666 0 : e = decode_Principal(p, len, (data)->client, &l);
15667 0 : if(e) goto fail;
15668 0 : p += l; len -= l; ret += l;
15669 0 : len = client_oldlen - client_datalen;
15670 : }
15671 : }
15672 : {
15673 : size_t authtime_datalen, authtime_oldlen;
15674 : Der_type authtime_type;
15675 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &authtime_type, 1, &authtime_datalen, &l);
15676 0 : if (e == 0 && authtime_type != CONS) { e = ASN1_BAD_ID; }
15677 0 : if(e) goto fail;
15678 0 : p += l; len -= l; ret += l;
15679 0 : authtime_oldlen = len;
15680 0 : if (authtime_datalen > len) { e = ASN1_OVERRUN; goto fail; }
15681 0 : len = authtime_datalen;
15682 0 : e = decode_KerberosTime(p, len, &(data)->authtime, &l);
15683 0 : if(e) goto fail;
15684 0 : p += l; len -= l; ret += l;
15685 0 : len = authtime_oldlen - authtime_datalen;
15686 : }
15687 : {
15688 : size_t delegated_datalen, delegated_oldlen;
15689 : Der_type delegated_type;
15690 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &delegated_type, 2, &delegated_datalen, &l);
15691 0 : if (e == 0 && delegated_type != CONS) { e = ASN1_BAD_ID; }
15692 0 : if(e) {
15693 0 : (data)->delegated = NULL;
15694 : } else {
15695 0 : (data)->delegated = calloc(1, sizeof(*(data)->delegated));
15696 0 : if ((data)->delegated == NULL) { e = ENOMEM; goto fail; }
15697 0 : p += l; len -= l; ret += l;
15698 0 : delegated_oldlen = len;
15699 0 : if (delegated_datalen > len) { e = ASN1_OVERRUN; goto fail; }
15700 0 : len = delegated_datalen;
15701 0 : e = decode_Principals(p, len, (data)->delegated, &l);
15702 0 : if(e) goto fail;
15703 0 : p += l; len -= l; ret += l;
15704 0 : len = delegated_oldlen - delegated_datalen;
15705 : }
15706 : }
15707 : {
15708 : size_t method_data_datalen, method_data_oldlen;
15709 : Der_type method_data_type;
15710 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &method_data_type, 3, &method_data_datalen, &l);
15711 0 : if (e == 0 && method_data_type != CONS) { e = ASN1_BAD_ID; }
15712 0 : if(e) {
15713 0 : (data)->method_data = NULL;
15714 : } else {
15715 0 : (data)->method_data = calloc(1, sizeof(*(data)->method_data));
15716 0 : if ((data)->method_data == NULL) { e = ENOMEM; goto fail; }
15717 0 : p += l; len -= l; ret += l;
15718 0 : method_data_oldlen = len;
15719 0 : if (method_data_datalen > len) { e = ASN1_OVERRUN; goto fail; }
15720 0 : len = method_data_datalen;
15721 0 : e = decode_METHOD_DATA(p, len, (data)->method_data, &l);
15722 0 : if(e) goto fail;
15723 0 : p += l; len -= l; ret += l;
15724 0 : len = method_data_oldlen - method_data_datalen;
15725 : }
15726 : }
15727 0 : len = Top_oldlen - Top_datalen;
15728 : }
15729 0 : if(size) *size = ret;
15730 0 : return 0;
15731 0 : fail:
15732 0 : free_KRB5SignedPathData(data);
15733 0 : return e;
15734 : }
15735 :
15736 : void ASN1CALL
15737 0 : free_KRB5SignedPathData(KRB5SignedPathData *data)
15738 : {
15739 0 : if((data)->client) {
15740 0 : free_Principal((data)->client);
15741 0 : free((data)->client);
15742 0 : (data)->client = NULL;
15743 : }
15744 0 : free_KerberosTime(&(data)->authtime);
15745 0 : if((data)->delegated) {
15746 0 : free_Principals((data)->delegated);
15747 0 : free((data)->delegated);
15748 0 : (data)->delegated = NULL;
15749 : }
15750 0 : if((data)->method_data) {
15751 0 : free_METHOD_DATA((data)->method_data);
15752 0 : free((data)->method_data);
15753 0 : (data)->method_data = NULL;
15754 : }
15755 0 : }
15756 :
15757 : size_t ASN1CALL
15758 104469 : length_KRB5SignedPathData(const KRB5SignedPathData *data)
15759 : {
15760 104469 : size_t ret = 0;
15761 104469 : if((data)->client){
15762 104469 : size_t Top_tag_oldret = ret;
15763 104469 : ret = 0;
15764 104469 : ret += length_Principal((data)->client);
15765 104469 : ret += 1 + der_length_len (ret);
15766 104469 : ret += Top_tag_oldret;
15767 : }
15768 : {
15769 104469 : size_t Top_tag_oldret = ret;
15770 104469 : ret = 0;
15771 104469 : ret += length_KerberosTime(&(data)->authtime);
15772 104469 : ret += 1 + der_length_len (ret);
15773 104469 : ret += Top_tag_oldret;
15774 : }
15775 104469 : if((data)->delegated){
15776 0 : size_t Top_tag_oldret = ret;
15777 0 : ret = 0;
15778 0 : ret += length_Principals((data)->delegated);
15779 0 : ret += 1 + der_length_len (ret);
15780 0 : ret += Top_tag_oldret;
15781 : }
15782 104469 : if((data)->method_data){
15783 0 : size_t Top_tag_oldret = ret;
15784 0 : ret = 0;
15785 0 : ret += length_METHOD_DATA((data)->method_data);
15786 0 : ret += 1 + der_length_len (ret);
15787 0 : ret += Top_tag_oldret;
15788 : }
15789 104469 : ret += 1 + der_length_len (ret);
15790 104469 : return ret;
15791 : }
15792 :
15793 : int ASN1CALL
15794 0 : copy_KRB5SignedPathData(const KRB5SignedPathData *from, KRB5SignedPathData *to)
15795 : {
15796 0 : memset(to, 0, sizeof(*to));
15797 0 : if((from)->client) {
15798 0 : (to)->client = malloc(sizeof(*(to)->client));
15799 0 : if((to)->client == NULL) goto fail;
15800 0 : if(copy_Principal((from)->client, (to)->client)) goto fail;
15801 : }else
15802 0 : (to)->client = NULL;
15803 0 : if(copy_KerberosTime(&(from)->authtime, &(to)->authtime)) goto fail;
15804 0 : if((from)->delegated) {
15805 0 : (to)->delegated = malloc(sizeof(*(to)->delegated));
15806 0 : if((to)->delegated == NULL) goto fail;
15807 0 : if(copy_Principals((from)->delegated, (to)->delegated)) goto fail;
15808 : }else
15809 0 : (to)->delegated = NULL;
15810 0 : if((from)->method_data) {
15811 0 : (to)->method_data = malloc(sizeof(*(to)->method_data));
15812 0 : if((to)->method_data == NULL) goto fail;
15813 0 : if(copy_METHOD_DATA((from)->method_data, (to)->method_data)) goto fail;
15814 : }else
15815 0 : (to)->method_data = NULL;
15816 0 : return 0;
15817 0 : fail:
15818 0 : free_KRB5SignedPathData(to);
15819 0 : return ENOMEM;
15820 : }
15821 :
15822 : int ASN1CALL
15823 64870 : encode_KRB5SignedPath(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const KRB5SignedPath *data, size_t *size)
15824 : {
15825 64870 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
15826 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
15827 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
15828 :
15829 : /* method_data */
15830 64870 : if((data)->method_data) {
15831 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
15832 0 : ret = 0;
15833 0 : e = encode_METHOD_DATA(p, len, (data)->method_data, &l);
15834 0 : if (e) return e;
15835 0 : p -= l; len -= l; ret += l;
15836 :
15837 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
15838 0 : if (e) return e;
15839 0 : p -= l; len -= l; ret += l;
15840 :
15841 0 : ret += Top_tag_oldret;
15842 : }
15843 : /* delegated */
15844 64870 : if((data)->delegated) {
15845 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
15846 0 : ret = 0;
15847 0 : e = encode_Principals(p, len, (data)->delegated, &l);
15848 0 : if (e) return e;
15849 0 : p -= l; len -= l; ret += l;
15850 :
15851 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
15852 0 : if (e) return e;
15853 0 : p -= l; len -= l; ret += l;
15854 :
15855 0 : ret += Top_tag_oldret;
15856 : }
15857 : /* cksum */
15858 : {
15859 64870 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
15860 64870 : ret = 0;
15861 64870 : e = encode_Checksum(p, len, &(data)->cksum, &l);
15862 64870 : if (e) return e;
15863 64870 : p -= l; len -= l; ret += l;
15864 :
15865 64870 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
15866 64870 : if (e) return e;
15867 64870 : p -= l; len -= l; ret += l;
15868 :
15869 64870 : ret += Top_tag_oldret;
15870 : }
15871 : /* etype */
15872 : {
15873 64870 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
15874 64870 : ret = 0;
15875 64870 : e = encode_ENCTYPE(p, len, &(data)->etype, &l);
15876 64870 : if (e) return e;
15877 64870 : p -= l; len -= l; ret += l;
15878 :
15879 64870 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
15880 64870 : if (e) return e;
15881 64870 : p -= l; len -= l; ret += l;
15882 :
15883 64870 : ret += Top_tag_oldret;
15884 : }
15885 64870 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
15886 64870 : if (e) return e;
15887 64870 : p -= l; len -= l; ret += l;
15888 :
15889 64870 : *size = ret;
15890 64870 : return 0;
15891 : }
15892 :
15893 : int ASN1CALL
15894 39599 : decode_KRB5SignedPath(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, KRB5SignedPath *data, size_t *size)
15895 : {
15896 39599 : size_t ret = 0;
15897 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
15898 : int e HEIMDAL_UNUSED_ATTRIBUTE;
15899 :
15900 39599 : memset(data, 0, sizeof(*data));
15901 : {
15902 : size_t Top_datalen, Top_oldlen;
15903 : Der_type Top_type;
15904 39599 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
15905 39599 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
15906 39599 : if(e) goto fail;
15907 39599 : p += l; len -= l; ret += l;
15908 39599 : Top_oldlen = len;
15909 39599 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
15910 39599 : len = Top_datalen;
15911 : {
15912 : size_t etype_datalen, etype_oldlen;
15913 : Der_type etype_type;
15914 39599 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &etype_type, 0, &etype_datalen, &l);
15915 39599 : if (e == 0 && etype_type != CONS) { e = ASN1_BAD_ID; }
15916 39599 : if(e) goto fail;
15917 39599 : p += l; len -= l; ret += l;
15918 39599 : etype_oldlen = len;
15919 39599 : if (etype_datalen > len) { e = ASN1_OVERRUN; goto fail; }
15920 39599 : len = etype_datalen;
15921 39599 : e = decode_ENCTYPE(p, len, &(data)->etype, &l);
15922 39599 : if(e) goto fail;
15923 39599 : p += l; len -= l; ret += l;
15924 39599 : len = etype_oldlen - etype_datalen;
15925 : }
15926 : {
15927 : size_t cksum_datalen, cksum_oldlen;
15928 : Der_type cksum_type;
15929 39599 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &cksum_type, 1, &cksum_datalen, &l);
15930 78109 : if (e == 0 && cksum_type != CONS) { e = ASN1_BAD_ID; }
15931 39599 : if(e) goto fail;
15932 39599 : p += l; len -= l; ret += l;
15933 39599 : cksum_oldlen = len;
15934 39599 : if (cksum_datalen > len) { e = ASN1_OVERRUN; goto fail; }
15935 39599 : len = cksum_datalen;
15936 39599 : e = decode_Checksum(p, len, &(data)->cksum, &l);
15937 39599 : if(e) goto fail;
15938 39599 : p += l; len -= l; ret += l;
15939 39599 : len = cksum_oldlen - cksum_datalen;
15940 : }
15941 : {
15942 : size_t delegated_datalen, delegated_oldlen;
15943 : Der_type delegated_type;
15944 39599 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &delegated_type, 2, &delegated_datalen, &l);
15945 39599 : if (e == 0 && delegated_type != CONS) { e = ASN1_BAD_ID; }
15946 39599 : if(e) {
15947 39599 : (data)->delegated = NULL;
15948 : } else {
15949 0 : (data)->delegated = calloc(1, sizeof(*(data)->delegated));
15950 0 : if ((data)->delegated == NULL) { e = ENOMEM; goto fail; }
15951 0 : p += l; len -= l; ret += l;
15952 0 : delegated_oldlen = len;
15953 0 : if (delegated_datalen > len) { e = ASN1_OVERRUN; goto fail; }
15954 0 : len = delegated_datalen;
15955 0 : e = decode_Principals(p, len, (data)->delegated, &l);
15956 0 : if(e) goto fail;
15957 0 : p += l; len -= l; ret += l;
15958 0 : len = delegated_oldlen - delegated_datalen;
15959 : }
15960 : }
15961 : {
15962 : size_t method_data_datalen, method_data_oldlen;
15963 : Der_type method_data_type;
15964 39599 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &method_data_type, 3, &method_data_datalen, &l);
15965 39599 : if (e == 0 && method_data_type != CONS) { e = ASN1_BAD_ID; }
15966 39599 : if(e) {
15967 39599 : (data)->method_data = NULL;
15968 : } else {
15969 0 : (data)->method_data = calloc(1, sizeof(*(data)->method_data));
15970 0 : if ((data)->method_data == NULL) { e = ENOMEM; goto fail; }
15971 0 : p += l; len -= l; ret += l;
15972 0 : method_data_oldlen = len;
15973 0 : if (method_data_datalen > len) { e = ASN1_OVERRUN; goto fail; }
15974 0 : len = method_data_datalen;
15975 0 : e = decode_METHOD_DATA(p, len, (data)->method_data, &l);
15976 0 : if(e) goto fail;
15977 0 : p += l; len -= l; ret += l;
15978 0 : len = method_data_oldlen - method_data_datalen;
15979 : }
15980 : }
15981 39599 : len = Top_oldlen - Top_datalen;
15982 : }
15983 39599 : if(size) *size = ret;
15984 38510 : return 0;
15985 0 : fail:
15986 0 : free_KRB5SignedPath(data);
15987 0 : return e;
15988 : }
15989 :
15990 : void ASN1CALL
15991 39599 : free_KRB5SignedPath(KRB5SignedPath *data)
15992 : {
15993 39599 : free_ENCTYPE(&(data)->etype);
15994 39599 : free_Checksum(&(data)->cksum);
15995 39599 : if((data)->delegated) {
15996 0 : free_Principals((data)->delegated);
15997 0 : free((data)->delegated);
15998 0 : (data)->delegated = NULL;
15999 : }
16000 39599 : if((data)->method_data) {
16001 0 : free_METHOD_DATA((data)->method_data);
16002 0 : free((data)->method_data);
16003 0 : (data)->method_data = NULL;
16004 : }
16005 39599 : }
16006 :
16007 : size_t ASN1CALL
16008 64870 : length_KRB5SignedPath(const KRB5SignedPath *data)
16009 : {
16010 64870 : size_t ret = 0;
16011 : {
16012 64870 : size_t Top_tag_oldret = ret;
16013 64870 : ret = 0;
16014 64870 : ret += length_ENCTYPE(&(data)->etype);
16015 64870 : ret += 1 + der_length_len (ret);
16016 64870 : ret += Top_tag_oldret;
16017 : }
16018 : {
16019 64870 : size_t Top_tag_oldret = ret;
16020 64870 : ret = 0;
16021 64870 : ret += length_Checksum(&(data)->cksum);
16022 64870 : ret += 1 + der_length_len (ret);
16023 64870 : ret += Top_tag_oldret;
16024 : }
16025 64870 : if((data)->delegated){
16026 0 : size_t Top_tag_oldret = ret;
16027 0 : ret = 0;
16028 0 : ret += length_Principals((data)->delegated);
16029 0 : ret += 1 + der_length_len (ret);
16030 0 : ret += Top_tag_oldret;
16031 : }
16032 64870 : if((data)->method_data){
16033 0 : size_t Top_tag_oldret = ret;
16034 0 : ret = 0;
16035 0 : ret += length_METHOD_DATA((data)->method_data);
16036 0 : ret += 1 + der_length_len (ret);
16037 0 : ret += Top_tag_oldret;
16038 : }
16039 64870 : ret += 1 + der_length_len (ret);
16040 64870 : return ret;
16041 : }
16042 :
16043 : int ASN1CALL
16044 0 : copy_KRB5SignedPath(const KRB5SignedPath *from, KRB5SignedPath *to)
16045 : {
16046 0 : memset(to, 0, sizeof(*to));
16047 0 : if(copy_ENCTYPE(&(from)->etype, &(to)->etype)) goto fail;
16048 0 : if(copy_Checksum(&(from)->cksum, &(to)->cksum)) goto fail;
16049 0 : if((from)->delegated) {
16050 0 : (to)->delegated = malloc(sizeof(*(to)->delegated));
16051 0 : if((to)->delegated == NULL) goto fail;
16052 0 : if(copy_Principals((from)->delegated, (to)->delegated)) goto fail;
16053 : }else
16054 0 : (to)->delegated = NULL;
16055 0 : if((from)->method_data) {
16056 0 : (to)->method_data = malloc(sizeof(*(to)->method_data));
16057 0 : if((to)->method_data == NULL) goto fail;
16058 0 : if(copy_METHOD_DATA((from)->method_data, (to)->method_data)) goto fail;
16059 : }else
16060 0 : (to)->method_data = NULL;
16061 0 : return 0;
16062 0 : fail:
16063 0 : free_KRB5SignedPath(to);
16064 0 : return ENOMEM;
16065 : }
16066 :
16067 : int ASN1CALL
16068 0 : encode_AD_LoginAlias(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const AD_LoginAlias *data, size_t *size)
16069 : {
16070 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
16071 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
16072 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
16073 :
16074 : /* checksum */
16075 : {
16076 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
16077 0 : ret = 0;
16078 0 : e = encode_Checksum(p, len, &(data)->checksum, &l);
16079 0 : if (e) return e;
16080 0 : p -= l; len -= l; ret += l;
16081 :
16082 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
16083 0 : if (e) return e;
16084 0 : p -= l; len -= l; ret += l;
16085 :
16086 0 : ret += Top_tag_oldret;
16087 : }
16088 : /* login-alias */
16089 : {
16090 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
16091 0 : ret = 0;
16092 0 : e = encode_PrincipalName(p, len, &(data)->login_alias, &l);
16093 0 : if (e) return e;
16094 0 : p -= l; len -= l; ret += l;
16095 :
16096 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
16097 0 : if (e) return e;
16098 0 : p -= l; len -= l; ret += l;
16099 :
16100 0 : ret += Top_tag_oldret;
16101 : }
16102 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
16103 0 : if (e) return e;
16104 0 : p -= l; len -= l; ret += l;
16105 :
16106 0 : *size = ret;
16107 0 : return 0;
16108 : }
16109 :
16110 : int ASN1CALL
16111 0 : decode_AD_LoginAlias(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, AD_LoginAlias *data, size_t *size)
16112 : {
16113 0 : size_t ret = 0;
16114 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
16115 : int e HEIMDAL_UNUSED_ATTRIBUTE;
16116 :
16117 0 : memset(data, 0, sizeof(*data));
16118 : {
16119 : size_t Top_datalen, Top_oldlen;
16120 : Der_type Top_type;
16121 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
16122 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
16123 0 : if(e) goto fail;
16124 0 : p += l; len -= l; ret += l;
16125 0 : Top_oldlen = len;
16126 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
16127 0 : len = Top_datalen;
16128 : {
16129 : size_t login_alias_datalen, login_alias_oldlen;
16130 : Der_type login_alias_type;
16131 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &login_alias_type, 0, &login_alias_datalen, &l);
16132 0 : if (e == 0 && login_alias_type != CONS) { e = ASN1_BAD_ID; }
16133 0 : if(e) goto fail;
16134 0 : p += l; len -= l; ret += l;
16135 0 : login_alias_oldlen = len;
16136 0 : if (login_alias_datalen > len) { e = ASN1_OVERRUN; goto fail; }
16137 0 : len = login_alias_datalen;
16138 0 : e = decode_PrincipalName(p, len, &(data)->login_alias, &l);
16139 0 : if(e) goto fail;
16140 0 : p += l; len -= l; ret += l;
16141 0 : len = login_alias_oldlen - login_alias_datalen;
16142 : }
16143 : {
16144 : size_t checksum_datalen, checksum_oldlen;
16145 : Der_type checksum_type;
16146 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &checksum_type, 1, &checksum_datalen, &l);
16147 0 : if (e == 0 && checksum_type != CONS) { e = ASN1_BAD_ID; }
16148 0 : if(e) goto fail;
16149 0 : p += l; len -= l; ret += l;
16150 0 : checksum_oldlen = len;
16151 0 : if (checksum_datalen > len) { e = ASN1_OVERRUN; goto fail; }
16152 0 : len = checksum_datalen;
16153 0 : e = decode_Checksum(p, len, &(data)->checksum, &l);
16154 0 : if(e) goto fail;
16155 0 : p += l; len -= l; ret += l;
16156 0 : len = checksum_oldlen - checksum_datalen;
16157 : }
16158 0 : len = Top_oldlen - Top_datalen;
16159 : }
16160 0 : if(size) *size = ret;
16161 0 : return 0;
16162 0 : fail:
16163 0 : free_AD_LoginAlias(data);
16164 0 : return e;
16165 : }
16166 :
16167 : void ASN1CALL
16168 0 : free_AD_LoginAlias(AD_LoginAlias *data)
16169 : {
16170 0 : free_PrincipalName(&(data)->login_alias);
16171 0 : free_Checksum(&(data)->checksum);
16172 0 : }
16173 :
16174 : size_t ASN1CALL
16175 0 : length_AD_LoginAlias(const AD_LoginAlias *data)
16176 : {
16177 0 : size_t ret = 0;
16178 : {
16179 0 : size_t Top_tag_oldret = ret;
16180 0 : ret = 0;
16181 0 : ret += length_PrincipalName(&(data)->login_alias);
16182 0 : ret += 1 + der_length_len (ret);
16183 0 : ret += Top_tag_oldret;
16184 : }
16185 : {
16186 0 : size_t Top_tag_oldret = ret;
16187 0 : ret = 0;
16188 0 : ret += length_Checksum(&(data)->checksum);
16189 0 : ret += 1 + der_length_len (ret);
16190 0 : ret += Top_tag_oldret;
16191 : }
16192 0 : ret += 1 + der_length_len (ret);
16193 0 : return ret;
16194 : }
16195 :
16196 : int ASN1CALL
16197 0 : copy_AD_LoginAlias(const AD_LoginAlias *from, AD_LoginAlias *to)
16198 : {
16199 0 : memset(to, 0, sizeof(*to));
16200 0 : if(copy_PrincipalName(&(from)->login_alias, &(to)->login_alias)) goto fail;
16201 0 : if(copy_Checksum(&(from)->checksum, &(to)->checksum)) goto fail;
16202 0 : return 0;
16203 0 : fail:
16204 0 : free_AD_LoginAlias(to);
16205 0 : return ENOMEM;
16206 : }
16207 :
16208 : int ASN1CALL
16209 0 : encode_PA_SvrReferralData(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const PA_SvrReferralData *data, size_t *size)
16210 : {
16211 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
16212 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
16213 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
16214 :
16215 : /* referred-realm */
16216 : {
16217 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
16218 0 : ret = 0;
16219 0 : e = encode_Realm(p, len, &(data)->referred_realm, &l);
16220 0 : if (e) return e;
16221 0 : p -= l; len -= l; ret += l;
16222 :
16223 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
16224 0 : if (e) return e;
16225 0 : p -= l; len -= l; ret += l;
16226 :
16227 0 : ret += Top_tag_oldret;
16228 : }
16229 : /* referred-name */
16230 0 : if((data)->referred_name) {
16231 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
16232 0 : ret = 0;
16233 0 : e = encode_PrincipalName(p, len, (data)->referred_name, &l);
16234 0 : if (e) return e;
16235 0 : p -= l; len -= l; ret += l;
16236 :
16237 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
16238 0 : if (e) return e;
16239 0 : p -= l; len -= l; ret += l;
16240 :
16241 0 : ret += Top_tag_oldret;
16242 : }
16243 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
16244 0 : if (e) return e;
16245 0 : p -= l; len -= l; ret += l;
16246 :
16247 0 : *size = ret;
16248 0 : return 0;
16249 : }
16250 :
16251 : int ASN1CALL
16252 0 : decode_PA_SvrReferralData(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, PA_SvrReferralData *data, size_t *size)
16253 : {
16254 0 : size_t ret = 0;
16255 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
16256 : int e HEIMDAL_UNUSED_ATTRIBUTE;
16257 :
16258 0 : memset(data, 0, sizeof(*data));
16259 : {
16260 : size_t Top_datalen, Top_oldlen;
16261 : Der_type Top_type;
16262 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
16263 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
16264 0 : if(e) goto fail;
16265 0 : p += l; len -= l; ret += l;
16266 0 : Top_oldlen = len;
16267 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
16268 0 : len = Top_datalen;
16269 : {
16270 : size_t referred_name_datalen, referred_name_oldlen;
16271 : Der_type referred_name_type;
16272 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &referred_name_type, 1, &referred_name_datalen, &l);
16273 0 : if (e == 0 && referred_name_type != CONS) { e = ASN1_BAD_ID; }
16274 0 : if(e) {
16275 0 : (data)->referred_name = NULL;
16276 : } else {
16277 0 : (data)->referred_name = calloc(1, sizeof(*(data)->referred_name));
16278 0 : if ((data)->referred_name == NULL) { e = ENOMEM; goto fail; }
16279 0 : p += l; len -= l; ret += l;
16280 0 : referred_name_oldlen = len;
16281 0 : if (referred_name_datalen > len) { e = ASN1_OVERRUN; goto fail; }
16282 0 : len = referred_name_datalen;
16283 0 : e = decode_PrincipalName(p, len, (data)->referred_name, &l);
16284 0 : if(e) goto fail;
16285 0 : p += l; len -= l; ret += l;
16286 0 : len = referred_name_oldlen - referred_name_datalen;
16287 : }
16288 : }
16289 : {
16290 : size_t referred_realm_datalen, referred_realm_oldlen;
16291 : Der_type referred_realm_type;
16292 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &referred_realm_type, 0, &referred_realm_datalen, &l);
16293 0 : if (e == 0 && referred_realm_type != CONS) { e = ASN1_BAD_ID; }
16294 0 : if(e) goto fail;
16295 0 : p += l; len -= l; ret += l;
16296 0 : referred_realm_oldlen = len;
16297 0 : if (referred_realm_datalen > len) { e = ASN1_OVERRUN; goto fail; }
16298 0 : len = referred_realm_datalen;
16299 0 : e = decode_Realm(p, len, &(data)->referred_realm, &l);
16300 0 : if(e) goto fail;
16301 0 : p += l; len -= l; ret += l;
16302 0 : len = referred_realm_oldlen - referred_realm_datalen;
16303 : }
16304 0 : len = Top_oldlen - Top_datalen;
16305 : }
16306 0 : if(size) *size = ret;
16307 0 : return 0;
16308 0 : fail:
16309 0 : free_PA_SvrReferralData(data);
16310 0 : return e;
16311 : }
16312 :
16313 : void ASN1CALL
16314 0 : free_PA_SvrReferralData(PA_SvrReferralData *data)
16315 : {
16316 0 : if((data)->referred_name) {
16317 0 : free_PrincipalName((data)->referred_name);
16318 0 : free((data)->referred_name);
16319 0 : (data)->referred_name = NULL;
16320 : }
16321 0 : free_Realm(&(data)->referred_realm);
16322 0 : }
16323 :
16324 : size_t ASN1CALL
16325 0 : length_PA_SvrReferralData(const PA_SvrReferralData *data)
16326 : {
16327 0 : size_t ret = 0;
16328 0 : if((data)->referred_name){
16329 0 : size_t Top_tag_oldret = ret;
16330 0 : ret = 0;
16331 0 : ret += length_PrincipalName((data)->referred_name);
16332 0 : ret += 1 + der_length_len (ret);
16333 0 : ret += Top_tag_oldret;
16334 : }
16335 : {
16336 0 : size_t Top_tag_oldret = ret;
16337 0 : ret = 0;
16338 0 : ret += length_Realm(&(data)->referred_realm);
16339 0 : ret += 1 + der_length_len (ret);
16340 0 : ret += Top_tag_oldret;
16341 : }
16342 0 : ret += 1 + der_length_len (ret);
16343 0 : return ret;
16344 : }
16345 :
16346 : int ASN1CALL
16347 0 : copy_PA_SvrReferralData(const PA_SvrReferralData *from, PA_SvrReferralData *to)
16348 : {
16349 0 : memset(to, 0, sizeof(*to));
16350 0 : if((from)->referred_name) {
16351 0 : (to)->referred_name = malloc(sizeof(*(to)->referred_name));
16352 0 : if((to)->referred_name == NULL) goto fail;
16353 0 : if(copy_PrincipalName((from)->referred_name, (to)->referred_name)) goto fail;
16354 : }else
16355 0 : (to)->referred_name = NULL;
16356 0 : if(copy_Realm(&(from)->referred_realm, &(to)->referred_realm)) goto fail;
16357 0 : return 0;
16358 0 : fail:
16359 0 : free_PA_SvrReferralData(to);
16360 0 : return ENOMEM;
16361 : }
16362 :
16363 : int ASN1CALL
16364 0 : encode_PA_SERVER_REFERRAL_DATA(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const PA_SERVER_REFERRAL_DATA *data, size_t *size)
16365 : {
16366 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
16367 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
16368 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
16369 :
16370 0 : e = encode_EncryptedData(p, len, data, &l);
16371 0 : if (e) return e;
16372 0 : p -= l; len -= l; ret += l;
16373 :
16374 0 : *size = ret;
16375 0 : return 0;
16376 : }
16377 :
16378 : int ASN1CALL
16379 0 : decode_PA_SERVER_REFERRAL_DATA(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, PA_SERVER_REFERRAL_DATA *data, size_t *size)
16380 : {
16381 0 : size_t ret = 0;
16382 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
16383 : int e HEIMDAL_UNUSED_ATTRIBUTE;
16384 :
16385 0 : memset(data, 0, sizeof(*data));
16386 0 : e = decode_EncryptedData(p, len, data, &l);
16387 0 : if(e) goto fail;
16388 0 : p += l; len -= l; ret += l;
16389 0 : if(size) *size = ret;
16390 0 : return 0;
16391 0 : fail:
16392 0 : free_PA_SERVER_REFERRAL_DATA(data);
16393 0 : return e;
16394 : }
16395 :
16396 : void ASN1CALL
16397 0 : free_PA_SERVER_REFERRAL_DATA(PA_SERVER_REFERRAL_DATA *data)
16398 : {
16399 0 : free_EncryptedData(data);
16400 0 : }
16401 :
16402 : size_t ASN1CALL
16403 0 : length_PA_SERVER_REFERRAL_DATA(const PA_SERVER_REFERRAL_DATA *data)
16404 : {
16405 0 : size_t ret = 0;
16406 0 : ret += length_EncryptedData(data);
16407 0 : return ret;
16408 : }
16409 :
16410 : int ASN1CALL
16411 0 : copy_PA_SERVER_REFERRAL_DATA(const PA_SERVER_REFERRAL_DATA *from, PA_SERVER_REFERRAL_DATA *to)
16412 : {
16413 0 : memset(to, 0, sizeof(*to));
16414 0 : if(copy_EncryptedData(from, to)) goto fail;
16415 0 : return 0;
16416 0 : fail:
16417 0 : free_PA_SERVER_REFERRAL_DATA(to);
16418 0 : return ENOMEM;
16419 : }
16420 :
16421 : int ASN1CALL
16422 302 : encode_PA_ServerReferralData(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const PA_ServerReferralData *data, size_t *size)
16423 : {
16424 302 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
16425 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
16426 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
16427 :
16428 : /* referral-valid-until */
16429 302 : if((data)->referral_valid_until) {
16430 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
16431 0 : ret = 0;
16432 0 : e = encode_KerberosTime(p, len, (data)->referral_valid_until, &l);
16433 0 : if (e) return e;
16434 0 : p -= l; len -= l; ret += l;
16435 :
16436 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
16437 0 : if (e) return e;
16438 0 : p -= l; len -= l; ret += l;
16439 :
16440 0 : ret += Top_tag_oldret;
16441 : }
16442 : /* requested-principal-name */
16443 302 : if((data)->requested_principal_name) {
16444 302 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
16445 302 : ret = 0;
16446 302 : e = encode_PrincipalName(p, len, (data)->requested_principal_name, &l);
16447 302 : if (e) return e;
16448 302 : p -= l; len -= l; ret += l;
16449 :
16450 302 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
16451 302 : if (e) return e;
16452 302 : p -= l; len -= l; ret += l;
16453 :
16454 302 : ret += Top_tag_oldret;
16455 : }
16456 : /* true-principal-name */
16457 302 : if((data)->true_principal_name) {
16458 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
16459 0 : ret = 0;
16460 0 : e = encode_PrincipalName(p, len, (data)->true_principal_name, &l);
16461 0 : if (e) return e;
16462 0 : p -= l; len -= l; ret += l;
16463 :
16464 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
16465 0 : if (e) return e;
16466 0 : p -= l; len -= l; ret += l;
16467 :
16468 0 : ret += Top_tag_oldret;
16469 : }
16470 : /* referred-realm */
16471 302 : if((data)->referred_realm) {
16472 302 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
16473 302 : ret = 0;
16474 302 : e = encode_Realm(p, len, (data)->referred_realm, &l);
16475 302 : if (e) return e;
16476 302 : p -= l; len -= l; ret += l;
16477 :
16478 302 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
16479 302 : if (e) return e;
16480 302 : p -= l; len -= l; ret += l;
16481 :
16482 302 : ret += Top_tag_oldret;
16483 : }
16484 302 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
16485 302 : if (e) return e;
16486 302 : p -= l; len -= l; ret += l;
16487 :
16488 302 : *size = ret;
16489 302 : return 0;
16490 : }
16491 :
16492 : int ASN1CALL
16493 0 : decode_PA_ServerReferralData(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, PA_ServerReferralData *data, size_t *size)
16494 : {
16495 0 : size_t ret = 0;
16496 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
16497 : int e HEIMDAL_UNUSED_ATTRIBUTE;
16498 :
16499 0 : memset(data, 0, sizeof(*data));
16500 : {
16501 : size_t Top_datalen, Top_oldlen;
16502 : Der_type Top_type;
16503 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
16504 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
16505 0 : if(e) goto fail;
16506 0 : p += l; len -= l; ret += l;
16507 0 : Top_oldlen = len;
16508 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
16509 0 : len = Top_datalen;
16510 : {
16511 : size_t referred_realm_datalen, referred_realm_oldlen;
16512 : Der_type referred_realm_type;
16513 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &referred_realm_type, 0, &referred_realm_datalen, &l);
16514 0 : if (e == 0 && referred_realm_type != CONS) { e = ASN1_BAD_ID; }
16515 0 : if(e) {
16516 0 : (data)->referred_realm = NULL;
16517 : } else {
16518 0 : (data)->referred_realm = calloc(1, sizeof(*(data)->referred_realm));
16519 0 : if ((data)->referred_realm == NULL) { e = ENOMEM; goto fail; }
16520 0 : p += l; len -= l; ret += l;
16521 0 : referred_realm_oldlen = len;
16522 0 : if (referred_realm_datalen > len) { e = ASN1_OVERRUN; goto fail; }
16523 0 : len = referred_realm_datalen;
16524 0 : e = decode_Realm(p, len, (data)->referred_realm, &l);
16525 0 : if(e) goto fail;
16526 0 : p += l; len -= l; ret += l;
16527 0 : len = referred_realm_oldlen - referred_realm_datalen;
16528 : }
16529 : }
16530 : {
16531 : size_t true_principal_name_datalen, true_principal_name_oldlen;
16532 : Der_type true_principal_name_type;
16533 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &true_principal_name_type, 1, &true_principal_name_datalen, &l);
16534 0 : if (e == 0 && true_principal_name_type != CONS) { e = ASN1_BAD_ID; }
16535 0 : if(e) {
16536 0 : (data)->true_principal_name = NULL;
16537 : } else {
16538 0 : (data)->true_principal_name = calloc(1, sizeof(*(data)->true_principal_name));
16539 0 : if ((data)->true_principal_name == NULL) { e = ENOMEM; goto fail; }
16540 0 : p += l; len -= l; ret += l;
16541 0 : true_principal_name_oldlen = len;
16542 0 : if (true_principal_name_datalen > len) { e = ASN1_OVERRUN; goto fail; }
16543 0 : len = true_principal_name_datalen;
16544 0 : e = decode_PrincipalName(p, len, (data)->true_principal_name, &l);
16545 0 : if(e) goto fail;
16546 0 : p += l; len -= l; ret += l;
16547 0 : len = true_principal_name_oldlen - true_principal_name_datalen;
16548 : }
16549 : }
16550 : {
16551 : size_t requested_principal_name_datalen, requested_principal_name_oldlen;
16552 : Der_type requested_principal_name_type;
16553 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &requested_principal_name_type, 2, &requested_principal_name_datalen, &l);
16554 0 : if (e == 0 && requested_principal_name_type != CONS) { e = ASN1_BAD_ID; }
16555 0 : if(e) {
16556 0 : (data)->requested_principal_name = NULL;
16557 : } else {
16558 0 : (data)->requested_principal_name = calloc(1, sizeof(*(data)->requested_principal_name));
16559 0 : if ((data)->requested_principal_name == NULL) { e = ENOMEM; goto fail; }
16560 0 : p += l; len -= l; ret += l;
16561 0 : requested_principal_name_oldlen = len;
16562 0 : if (requested_principal_name_datalen > len) { e = ASN1_OVERRUN; goto fail; }
16563 0 : len = requested_principal_name_datalen;
16564 0 : e = decode_PrincipalName(p, len, (data)->requested_principal_name, &l);
16565 0 : if(e) goto fail;
16566 0 : p += l; len -= l; ret += l;
16567 0 : len = requested_principal_name_oldlen - requested_principal_name_datalen;
16568 : }
16569 : }
16570 : {
16571 : size_t referral_valid_until_datalen, referral_valid_until_oldlen;
16572 : Der_type referral_valid_until_type;
16573 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &referral_valid_until_type, 3, &referral_valid_until_datalen, &l);
16574 0 : if (e == 0 && referral_valid_until_type != CONS) { e = ASN1_BAD_ID; }
16575 0 : if(e) {
16576 0 : (data)->referral_valid_until = NULL;
16577 : } else {
16578 0 : (data)->referral_valid_until = calloc(1, sizeof(*(data)->referral_valid_until));
16579 0 : if ((data)->referral_valid_until == NULL) { e = ENOMEM; goto fail; }
16580 0 : p += l; len -= l; ret += l;
16581 0 : referral_valid_until_oldlen = len;
16582 0 : if (referral_valid_until_datalen > len) { e = ASN1_OVERRUN; goto fail; }
16583 0 : len = referral_valid_until_datalen;
16584 0 : e = decode_KerberosTime(p, len, (data)->referral_valid_until, &l);
16585 0 : if(e) goto fail;
16586 0 : p += l; len -= l; ret += l;
16587 0 : len = referral_valid_until_oldlen - referral_valid_until_datalen;
16588 : }
16589 : }
16590 0 : len = Top_oldlen - Top_datalen;
16591 : }
16592 0 : if(size) *size = ret;
16593 0 : return 0;
16594 0 : fail:
16595 0 : free_PA_ServerReferralData(data);
16596 0 : return e;
16597 : }
16598 :
16599 : void ASN1CALL
16600 302 : free_PA_ServerReferralData(PA_ServerReferralData *data)
16601 : {
16602 302 : if((data)->referred_realm) {
16603 302 : free_Realm((data)->referred_realm);
16604 302 : free((data)->referred_realm);
16605 302 : (data)->referred_realm = NULL;
16606 : }
16607 302 : if((data)->true_principal_name) {
16608 0 : free_PrincipalName((data)->true_principal_name);
16609 0 : free((data)->true_principal_name);
16610 0 : (data)->true_principal_name = NULL;
16611 : }
16612 302 : if((data)->requested_principal_name) {
16613 302 : free_PrincipalName((data)->requested_principal_name);
16614 302 : free((data)->requested_principal_name);
16615 302 : (data)->requested_principal_name = NULL;
16616 : }
16617 302 : if((data)->referral_valid_until) {
16618 0 : free_KerberosTime((data)->referral_valid_until);
16619 0 : free((data)->referral_valid_until);
16620 0 : (data)->referral_valid_until = NULL;
16621 : }
16622 302 : }
16623 :
16624 : size_t ASN1CALL
16625 302 : length_PA_ServerReferralData(const PA_ServerReferralData *data)
16626 : {
16627 302 : size_t ret = 0;
16628 302 : if((data)->referred_realm){
16629 302 : size_t Top_tag_oldret = ret;
16630 302 : ret = 0;
16631 302 : ret += length_Realm((data)->referred_realm);
16632 302 : ret += 1 + der_length_len (ret);
16633 302 : ret += Top_tag_oldret;
16634 : }
16635 302 : if((data)->true_principal_name){
16636 0 : size_t Top_tag_oldret = ret;
16637 0 : ret = 0;
16638 0 : ret += length_PrincipalName((data)->true_principal_name);
16639 0 : ret += 1 + der_length_len (ret);
16640 0 : ret += Top_tag_oldret;
16641 : }
16642 302 : if((data)->requested_principal_name){
16643 302 : size_t Top_tag_oldret = ret;
16644 302 : ret = 0;
16645 302 : ret += length_PrincipalName((data)->requested_principal_name);
16646 302 : ret += 1 + der_length_len (ret);
16647 302 : ret += Top_tag_oldret;
16648 : }
16649 302 : if((data)->referral_valid_until){
16650 0 : size_t Top_tag_oldret = ret;
16651 0 : ret = 0;
16652 0 : ret += length_KerberosTime((data)->referral_valid_until);
16653 0 : ret += 1 + der_length_len (ret);
16654 0 : ret += Top_tag_oldret;
16655 : }
16656 302 : ret += 1 + der_length_len (ret);
16657 302 : return ret;
16658 : }
16659 :
16660 : int ASN1CALL
16661 0 : copy_PA_ServerReferralData(const PA_ServerReferralData *from, PA_ServerReferralData *to)
16662 : {
16663 0 : memset(to, 0, sizeof(*to));
16664 0 : if((from)->referred_realm) {
16665 0 : (to)->referred_realm = malloc(sizeof(*(to)->referred_realm));
16666 0 : if((to)->referred_realm == NULL) goto fail;
16667 0 : if(copy_Realm((from)->referred_realm, (to)->referred_realm)) goto fail;
16668 : }else
16669 0 : (to)->referred_realm = NULL;
16670 0 : if((from)->true_principal_name) {
16671 0 : (to)->true_principal_name = malloc(sizeof(*(to)->true_principal_name));
16672 0 : if((to)->true_principal_name == NULL) goto fail;
16673 0 : if(copy_PrincipalName((from)->true_principal_name, (to)->true_principal_name)) goto fail;
16674 : }else
16675 0 : (to)->true_principal_name = NULL;
16676 0 : if((from)->requested_principal_name) {
16677 0 : (to)->requested_principal_name = malloc(sizeof(*(to)->requested_principal_name));
16678 0 : if((to)->requested_principal_name == NULL) goto fail;
16679 0 : if(copy_PrincipalName((from)->requested_principal_name, (to)->requested_principal_name)) goto fail;
16680 : }else
16681 0 : (to)->requested_principal_name = NULL;
16682 0 : if((from)->referral_valid_until) {
16683 0 : (to)->referral_valid_until = malloc(sizeof(*(to)->referral_valid_until));
16684 0 : if((to)->referral_valid_until == NULL) goto fail;
16685 0 : if(copy_KerberosTime((from)->referral_valid_until, (to)->referral_valid_until)) goto fail;
16686 : }else
16687 0 : (to)->referral_valid_until = NULL;
16688 0 : return 0;
16689 0 : fail:
16690 0 : free_PA_ServerReferralData(to);
16691 0 : return ENOMEM;
16692 : }
16693 :
16694 : int ASN1CALL
16695 0 : encode_FastOptions(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const FastOptions *data, size_t *size)
16696 : {
16697 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
16698 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
16699 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
16700 :
16701 : {
16702 0 : unsigned char c = 0;
16703 0 : if (len < 1) return ASN1_OVERFLOW;
16704 0 : *p-- = c; len--; ret++;
16705 0 : c = 0;
16706 0 : if((data)->kdc_follow__referrals) {
16707 0 : c |= 1<<7;
16708 : }
16709 0 : if (len < 1) return ASN1_OVERFLOW;
16710 0 : *p-- = c; len--; ret++;
16711 0 : c = 0;
16712 0 : if (len < 1) return ASN1_OVERFLOW;
16713 0 : *p-- = c; len--; ret++;
16714 0 : c = 0;
16715 0 : if((data)->hide_client_names) {
16716 0 : c |= 1<<6;
16717 : }
16718 0 : if((data)->reserved) {
16719 0 : c |= 1<<7;
16720 : }
16721 0 : if (len < 1) return ASN1_OVERFLOW;
16722 0 : *p-- = c; len--; ret++;
16723 0 : if (len < 1) return ASN1_OVERFLOW;
16724 0 : *p-- = 0;
16725 0 : len -= 1;
16726 0 : ret += 1;
16727 : }
16728 :
16729 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_BitString, &l);
16730 0 : if (e) return e;
16731 0 : p -= l; len -= l; ret += l;
16732 :
16733 0 : *size = ret;
16734 0 : return 0;
16735 : }
16736 :
16737 : int ASN1CALL
16738 0 : decode_FastOptions(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, FastOptions *data, size_t *size)
16739 : {
16740 0 : size_t ret = 0;
16741 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
16742 : int e HEIMDAL_UNUSED_ATTRIBUTE;
16743 :
16744 0 : memset(data, 0, sizeof(*data));
16745 : {
16746 : size_t Top_datalen, Top_oldlen;
16747 : Der_type Top_type;
16748 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_BitString, &Top_datalen, &l);
16749 0 : if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
16750 0 : if(e) goto fail;
16751 0 : p += l; len -= l; ret += l;
16752 0 : Top_oldlen = len;
16753 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
16754 0 : len = Top_datalen;
16755 0 : if (len < 1) return ASN1_OVERRUN;
16756 0 : p++; len--; ret++;
16757 : do {
16758 0 : if (len < 1) break;
16759 0 : (data)->reserved = (*p >> 7) & 1;
16760 0 : (data)->hide_client_names = (*p >> 6) & 1;
16761 0 : p++; len--; ret++;
16762 0 : if (len < 1) break;
16763 0 : p++; len--; ret++;
16764 0 : if (len < 1) break;
16765 0 : (data)->kdc_follow__referrals = (*p >> 7) & 1;
16766 : } while(0);
16767 0 : p += len; ret += len;
16768 0 : len = Top_oldlen - Top_datalen;
16769 : }
16770 0 : if(size) *size = ret;
16771 0 : return 0;
16772 0 : fail:
16773 0 : free_FastOptions(data);
16774 0 : return e;
16775 : }
16776 :
16777 : void ASN1CALL
16778 0 : free_FastOptions(FastOptions *data)
16779 : {
16780 0 : }
16781 :
16782 : size_t ASN1CALL
16783 0 : length_FastOptions(const FastOptions *data)
16784 : {
16785 0 : size_t ret = 0;
16786 0 : ret += 5;
16787 0 : ret += 1 + der_length_len (ret);
16788 0 : return ret;
16789 : }
16790 :
16791 : int ASN1CALL
16792 0 : copy_FastOptions(const FastOptions *from, FastOptions *to)
16793 : {
16794 0 : memset(to, 0, sizeof(*to));
16795 0 : *(to) = *(from);
16796 0 : return 0;
16797 : }
16798 :
16799 0 : unsigned FastOptions2int(FastOptions f)
16800 : {
16801 0 : unsigned r = 0;
16802 0 : if(f.reserved) r |= (1U << 0);
16803 0 : if(f.hide_client_names) r |= (1U << 1);
16804 0 : if(f.kdc_follow__referrals) r |= (1U << 16);
16805 0 : return r;
16806 : }
16807 :
16808 0 : FastOptions int2FastOptions(unsigned n)
16809 : {
16810 : FastOptions flags;
16811 :
16812 0 : memset(&flags, 0, sizeof(flags));
16813 :
16814 0 : flags.reserved = (n >> 0) & 1;
16815 0 : flags.hide_client_names = (n >> 1) & 1;
16816 0 : flags.kdc_follow__referrals = (n >> 16) & 1;
16817 0 : return flags;
16818 : }
16819 :
16820 : static struct units FastOptions_units[] = {
16821 : {"kdc-follow--referrals", 1U << 16},
16822 : {"hide-client-names", 1U << 1},
16823 : {"reserved", 1U << 0},
16824 : {NULL, 0}
16825 : };
16826 :
16827 0 : const struct units * asn1_FastOptions_units(void){
16828 0 : return FastOptions_units;
16829 : }
16830 :
16831 : int ASN1CALL
16832 0 : encode_KrbFastReq(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const KrbFastReq *data, size_t *size)
16833 : {
16834 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
16835 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
16836 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
16837 :
16838 : /* req-body */
16839 : {
16840 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
16841 0 : ret = 0;
16842 0 : e = encode_KDC_REQ_BODY(p, len, &(data)->req_body, &l);
16843 0 : if (e) return e;
16844 0 : p -= l; len -= l; ret += l;
16845 :
16846 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
16847 0 : if (e) return e;
16848 0 : p -= l; len -= l; ret += l;
16849 :
16850 0 : ret += Top_tag_oldret;
16851 : }
16852 : /* padata */
16853 : {
16854 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
16855 0 : ret = 0;
16856 0 : for(i = (int)(&(data)->padata)->len - 1; i >= 0; --i) {
16857 0 : size_t padata_tag_tag_for_oldret = ret;
16858 0 : ret = 0;
16859 0 : e = encode_PA_DATA(p, len, &(&(data)->padata)->val[i], &l);
16860 0 : if (e) return e;
16861 0 : p -= l; len -= l; ret += l;
16862 :
16863 0 : ret += padata_tag_tag_for_oldret;
16864 : }
16865 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
16866 0 : if (e) return e;
16867 0 : p -= l; len -= l; ret += l;
16868 :
16869 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
16870 0 : if (e) return e;
16871 0 : p -= l; len -= l; ret += l;
16872 :
16873 0 : ret += Top_tag_oldret;
16874 : }
16875 : /* fast-options */
16876 : {
16877 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
16878 0 : ret = 0;
16879 0 : e = encode_FastOptions(p, len, &(data)->fast_options, &l);
16880 0 : if (e) return e;
16881 0 : p -= l; len -= l; ret += l;
16882 :
16883 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
16884 0 : if (e) return e;
16885 0 : p -= l; len -= l; ret += l;
16886 :
16887 0 : ret += Top_tag_oldret;
16888 : }
16889 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
16890 0 : if (e) return e;
16891 0 : p -= l; len -= l; ret += l;
16892 :
16893 0 : *size = ret;
16894 0 : return 0;
16895 : }
16896 :
16897 : int ASN1CALL
16898 0 : decode_KrbFastReq(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, KrbFastReq *data, size_t *size)
16899 : {
16900 0 : size_t ret = 0;
16901 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
16902 : int e HEIMDAL_UNUSED_ATTRIBUTE;
16903 :
16904 0 : memset(data, 0, sizeof(*data));
16905 : {
16906 : size_t Top_datalen, Top_oldlen;
16907 : Der_type Top_type;
16908 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
16909 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
16910 0 : if(e) goto fail;
16911 0 : p += l; len -= l; ret += l;
16912 0 : Top_oldlen = len;
16913 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
16914 0 : len = Top_datalen;
16915 : {
16916 : size_t fast_options_datalen, fast_options_oldlen;
16917 : Der_type fast_options_type;
16918 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &fast_options_type, 0, &fast_options_datalen, &l);
16919 0 : if (e == 0 && fast_options_type != CONS) { e = ASN1_BAD_ID; }
16920 0 : if(e) goto fail;
16921 0 : p += l; len -= l; ret += l;
16922 0 : fast_options_oldlen = len;
16923 0 : if (fast_options_datalen > len) { e = ASN1_OVERRUN; goto fail; }
16924 0 : len = fast_options_datalen;
16925 0 : e = decode_FastOptions(p, len, &(data)->fast_options, &l);
16926 0 : if(e) goto fail;
16927 0 : p += l; len -= l; ret += l;
16928 0 : len = fast_options_oldlen - fast_options_datalen;
16929 : }
16930 : {
16931 : size_t padata_datalen, padata_oldlen;
16932 : Der_type padata_type;
16933 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &padata_type, 1, &padata_datalen, &l);
16934 0 : if (e == 0 && padata_type != CONS) { e = ASN1_BAD_ID; }
16935 0 : if(e) goto fail;
16936 0 : p += l; len -= l; ret += l;
16937 0 : padata_oldlen = len;
16938 0 : if (padata_datalen > len) { e = ASN1_OVERRUN; goto fail; }
16939 0 : len = padata_datalen;
16940 : {
16941 : size_t padata_Tag_datalen, padata_Tag_oldlen;
16942 : Der_type padata_Tag_type;
16943 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &padata_Tag_type, UT_Sequence, &padata_Tag_datalen, &l);
16944 0 : if (e == 0 && padata_Tag_type != CONS) { e = ASN1_BAD_ID; }
16945 0 : if(e) goto fail;
16946 0 : p += l; len -= l; ret += l;
16947 0 : padata_Tag_oldlen = len;
16948 0 : if (padata_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
16949 0 : len = padata_Tag_datalen;
16950 : {
16951 0 : size_t padata_Tag_Tag_origlen = len;
16952 0 : size_t padata_Tag_Tag_oldret = ret;
16953 0 : size_t padata_Tag_Tag_olen = 0;
16954 : void *padata_Tag_Tag_tmp;
16955 0 : ret = 0;
16956 0 : (&(data)->padata)->len = 0;
16957 0 : (&(data)->padata)->val = NULL;
16958 0 : while(ret < padata_Tag_Tag_origlen) {
16959 0 : size_t padata_Tag_Tag_nlen = padata_Tag_Tag_olen + sizeof(*((&(data)->padata)->val));
16960 0 : if (padata_Tag_Tag_olen > padata_Tag_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
16961 0 : padata_Tag_Tag_olen = padata_Tag_Tag_nlen;
16962 0 : padata_Tag_Tag_tmp = realloc((&(data)->padata)->val, padata_Tag_Tag_olen);
16963 0 : if (padata_Tag_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
16964 0 : (&(data)->padata)->val = padata_Tag_Tag_tmp;
16965 0 : e = decode_PA_DATA(p, len, &(&(data)->padata)->val[(&(data)->padata)->len], &l);
16966 0 : if(e) goto fail;
16967 0 : p += l; len -= l; ret += l;
16968 0 : (&(data)->padata)->len++;
16969 0 : len = padata_Tag_Tag_origlen - ret;
16970 : }
16971 0 : ret += padata_Tag_Tag_oldret;
16972 : }
16973 0 : len = padata_Tag_oldlen - padata_Tag_datalen;
16974 : }
16975 0 : len = padata_oldlen - padata_datalen;
16976 : }
16977 : {
16978 : size_t req_body_datalen, req_body_oldlen;
16979 : Der_type req_body_type;
16980 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &req_body_type, 2, &req_body_datalen, &l);
16981 0 : if (e == 0 && req_body_type != CONS) { e = ASN1_BAD_ID; }
16982 0 : if(e) goto fail;
16983 0 : p += l; len -= l; ret += l;
16984 0 : req_body_oldlen = len;
16985 0 : if (req_body_datalen > len) { e = ASN1_OVERRUN; goto fail; }
16986 0 : len = req_body_datalen;
16987 0 : e = decode_KDC_REQ_BODY(p, len, &(data)->req_body, &l);
16988 0 : if(e) goto fail;
16989 0 : p += l; len -= l; ret += l;
16990 0 : len = req_body_oldlen - req_body_datalen;
16991 : }
16992 0 : len = Top_oldlen - Top_datalen;
16993 : }
16994 0 : if(size) *size = ret;
16995 0 : return 0;
16996 0 : fail:
16997 0 : free_KrbFastReq(data);
16998 0 : return e;
16999 : }
17000 :
17001 : void ASN1CALL
17002 0 : free_KrbFastReq(KrbFastReq *data)
17003 : {
17004 0 : free_FastOptions(&(data)->fast_options);
17005 0 : while((&(data)->padata)->len){
17006 0 : free_PA_DATA(&(&(data)->padata)->val[(&(data)->padata)->len-1]);
17007 0 : (&(data)->padata)->len--;
17008 : }
17009 0 : free((&(data)->padata)->val);
17010 0 : (&(data)->padata)->val = NULL;
17011 0 : free_KDC_REQ_BODY(&(data)->req_body);
17012 0 : }
17013 :
17014 : size_t ASN1CALL
17015 0 : length_KrbFastReq(const KrbFastReq *data)
17016 : {
17017 0 : size_t ret = 0;
17018 : {
17019 0 : size_t Top_tag_oldret = ret;
17020 0 : ret = 0;
17021 0 : ret += length_FastOptions(&(data)->fast_options);
17022 0 : ret += 1 + der_length_len (ret);
17023 0 : ret += Top_tag_oldret;
17024 : }
17025 : {
17026 0 : size_t Top_tag_oldret = ret;
17027 0 : ret = 0;
17028 : {
17029 0 : size_t padata_tag_tag_oldret = ret;
17030 : int i;
17031 0 : ret = 0;
17032 0 : for(i = (&(data)->padata)->len - 1; i >= 0; --i){
17033 0 : size_t padata_tag_tag_for_oldret = ret;
17034 0 : ret = 0;
17035 0 : ret += length_PA_DATA(&(&(data)->padata)->val[i]);
17036 0 : ret += padata_tag_tag_for_oldret;
17037 : }
17038 0 : ret += padata_tag_tag_oldret;
17039 : }
17040 0 : ret += 1 + der_length_len (ret);
17041 0 : ret += 1 + der_length_len (ret);
17042 0 : ret += Top_tag_oldret;
17043 : }
17044 : {
17045 0 : size_t Top_tag_oldret = ret;
17046 0 : ret = 0;
17047 0 : ret += length_KDC_REQ_BODY(&(data)->req_body);
17048 0 : ret += 1 + der_length_len (ret);
17049 0 : ret += Top_tag_oldret;
17050 : }
17051 0 : ret += 1 + der_length_len (ret);
17052 0 : return ret;
17053 : }
17054 :
17055 : int ASN1CALL
17056 0 : copy_KrbFastReq(const KrbFastReq *from, KrbFastReq *to)
17057 : {
17058 0 : memset(to, 0, sizeof(*to));
17059 0 : if(copy_FastOptions(&(from)->fast_options, &(to)->fast_options)) goto fail;
17060 0 : if(((&(to)->padata)->val = malloc((&(from)->padata)->len * sizeof(*(&(to)->padata)->val))) == NULL && (&(from)->padata)->len != 0)
17061 0 : goto fail;
17062 0 : for((&(to)->padata)->len = 0; (&(to)->padata)->len < (&(from)->padata)->len; (&(to)->padata)->len++){
17063 0 : if(copy_PA_DATA(&(&(from)->padata)->val[(&(to)->padata)->len], &(&(to)->padata)->val[(&(to)->padata)->len])) goto fail;
17064 : }
17065 0 : if(copy_KDC_REQ_BODY(&(from)->req_body, &(to)->req_body)) goto fail;
17066 0 : return 0;
17067 0 : fail:
17068 0 : free_KrbFastReq(to);
17069 0 : return ENOMEM;
17070 : }
17071 :
17072 : int ASN1CALL
17073 0 : encode_KrbFastArmor(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const KrbFastArmor *data, size_t *size)
17074 : {
17075 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
17076 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
17077 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
17078 :
17079 : /* armor-value */
17080 : {
17081 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
17082 0 : ret = 0;
17083 0 : e = der_put_octet_string(p, len, &(data)->armor_value, &l);
17084 0 : if (e) return e;
17085 0 : p -= l; len -= l; ret += l;
17086 :
17087 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
17088 0 : if (e) return e;
17089 0 : p -= l; len -= l; ret += l;
17090 :
17091 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
17092 0 : if (e) return e;
17093 0 : p -= l; len -= l; ret += l;
17094 :
17095 0 : ret += Top_tag_oldret;
17096 : }
17097 : /* armor-type */
17098 : {
17099 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
17100 0 : ret = 0;
17101 0 : e = encode_krb5int32(p, len, &(data)->armor_type, &l);
17102 0 : if (e) return e;
17103 0 : p -= l; len -= l; ret += l;
17104 :
17105 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
17106 0 : if (e) return e;
17107 0 : p -= l; len -= l; ret += l;
17108 :
17109 0 : ret += Top_tag_oldret;
17110 : }
17111 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
17112 0 : if (e) return e;
17113 0 : p -= l; len -= l; ret += l;
17114 :
17115 0 : *size = ret;
17116 0 : return 0;
17117 : }
17118 :
17119 : int ASN1CALL
17120 0 : decode_KrbFastArmor(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, KrbFastArmor *data, size_t *size)
17121 : {
17122 0 : size_t ret = 0;
17123 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
17124 : int e HEIMDAL_UNUSED_ATTRIBUTE;
17125 :
17126 0 : memset(data, 0, sizeof(*data));
17127 : {
17128 : size_t Top_datalen, Top_oldlen;
17129 : Der_type Top_type;
17130 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
17131 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
17132 0 : if(e) goto fail;
17133 0 : p += l; len -= l; ret += l;
17134 0 : Top_oldlen = len;
17135 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
17136 0 : len = Top_datalen;
17137 : {
17138 : size_t armor_type_datalen, armor_type_oldlen;
17139 : Der_type armor_type_type;
17140 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &armor_type_type, 0, &armor_type_datalen, &l);
17141 0 : if (e == 0 && armor_type_type != CONS) { e = ASN1_BAD_ID; }
17142 0 : if(e) goto fail;
17143 0 : p += l; len -= l; ret += l;
17144 0 : armor_type_oldlen = len;
17145 0 : if (armor_type_datalen > len) { e = ASN1_OVERRUN; goto fail; }
17146 0 : len = armor_type_datalen;
17147 0 : e = decode_krb5int32(p, len, &(data)->armor_type, &l);
17148 0 : if(e) goto fail;
17149 0 : p += l; len -= l; ret += l;
17150 0 : len = armor_type_oldlen - armor_type_datalen;
17151 : }
17152 : {
17153 : size_t armor_value_datalen, armor_value_oldlen;
17154 : Der_type armor_value_type;
17155 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &armor_value_type, 1, &armor_value_datalen, &l);
17156 0 : if (e == 0 && armor_value_type != CONS) { e = ASN1_BAD_ID; }
17157 0 : if(e) goto fail;
17158 0 : p += l; len -= l; ret += l;
17159 0 : armor_value_oldlen = len;
17160 0 : if (armor_value_datalen > len) { e = ASN1_OVERRUN; goto fail; }
17161 0 : len = armor_value_datalen;
17162 : {
17163 : size_t armor_value_Tag_datalen, armor_value_Tag_oldlen;
17164 : Der_type armor_value_Tag_type;
17165 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &armor_value_Tag_type, UT_OctetString, &armor_value_Tag_datalen, &l);
17166 0 : if (e == 0 && armor_value_Tag_type != PRIM) { e = ASN1_BAD_ID; }
17167 0 : if(e) goto fail;
17168 0 : p += l; len -= l; ret += l;
17169 0 : armor_value_Tag_oldlen = len;
17170 0 : if (armor_value_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
17171 0 : len = armor_value_Tag_datalen;
17172 0 : e = der_get_octet_string(p, len, &(data)->armor_value, &l);
17173 0 : if(e) goto fail;
17174 0 : p += l; len -= l; ret += l;
17175 0 : len = armor_value_Tag_oldlen - armor_value_Tag_datalen;
17176 : }
17177 0 : len = armor_value_oldlen - armor_value_datalen;
17178 : }
17179 0 : len = Top_oldlen - Top_datalen;
17180 : }
17181 0 : if(size) *size = ret;
17182 0 : return 0;
17183 0 : fail:
17184 0 : free_KrbFastArmor(data);
17185 0 : return e;
17186 : }
17187 :
17188 : void ASN1CALL
17189 0 : free_KrbFastArmor(KrbFastArmor *data)
17190 : {
17191 0 : free_krb5int32(&(data)->armor_type);
17192 0 : der_free_octet_string(&(data)->armor_value);
17193 0 : }
17194 :
17195 : size_t ASN1CALL
17196 0 : length_KrbFastArmor(const KrbFastArmor *data)
17197 : {
17198 0 : size_t ret = 0;
17199 : {
17200 0 : size_t Top_tag_oldret = ret;
17201 0 : ret = 0;
17202 0 : ret += length_krb5int32(&(data)->armor_type);
17203 0 : ret += 1 + der_length_len (ret);
17204 0 : ret += Top_tag_oldret;
17205 : }
17206 : {
17207 0 : size_t Top_tag_oldret = ret;
17208 0 : ret = 0;
17209 0 : ret += der_length_octet_string(&(data)->armor_value);
17210 0 : ret += 1 + der_length_len (ret);
17211 0 : ret += 1 + der_length_len (ret);
17212 0 : ret += Top_tag_oldret;
17213 : }
17214 0 : ret += 1 + der_length_len (ret);
17215 0 : return ret;
17216 : }
17217 :
17218 : int ASN1CALL
17219 0 : copy_KrbFastArmor(const KrbFastArmor *from, KrbFastArmor *to)
17220 : {
17221 0 : memset(to, 0, sizeof(*to));
17222 0 : if(copy_krb5int32(&(from)->armor_type, &(to)->armor_type)) goto fail;
17223 0 : if(der_copy_octet_string(&(from)->armor_value, &(to)->armor_value)) goto fail;
17224 0 : return 0;
17225 0 : fail:
17226 0 : free_KrbFastArmor(to);
17227 0 : return ENOMEM;
17228 : }
17229 :
17230 : int ASN1CALL
17231 0 : encode_KrbFastArmoredReq(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const KrbFastArmoredReq *data, size_t *size)
17232 : {
17233 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
17234 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
17235 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
17236 :
17237 : /* enc-fast-req */
17238 : {
17239 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
17240 0 : ret = 0;
17241 0 : e = encode_EncryptedData(p, len, &(data)->enc_fast_req, &l);
17242 0 : if (e) return e;
17243 0 : p -= l; len -= l; ret += l;
17244 :
17245 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
17246 0 : if (e) return e;
17247 0 : p -= l; len -= l; ret += l;
17248 :
17249 0 : ret += Top_tag_oldret;
17250 : }
17251 : /* req-checksum */
17252 : {
17253 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
17254 0 : ret = 0;
17255 0 : e = encode_Checksum(p, len, &(data)->req_checksum, &l);
17256 0 : if (e) return e;
17257 0 : p -= l; len -= l; ret += l;
17258 :
17259 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
17260 0 : if (e) return e;
17261 0 : p -= l; len -= l; ret += l;
17262 :
17263 0 : ret += Top_tag_oldret;
17264 : }
17265 : /* armor */
17266 0 : if((data)->armor) {
17267 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
17268 0 : ret = 0;
17269 0 : e = encode_KrbFastArmor(p, len, (data)->armor, &l);
17270 0 : if (e) return e;
17271 0 : p -= l; len -= l; ret += l;
17272 :
17273 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
17274 0 : if (e) return e;
17275 0 : p -= l; len -= l; ret += l;
17276 :
17277 0 : ret += Top_tag_oldret;
17278 : }
17279 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
17280 0 : if (e) return e;
17281 0 : p -= l; len -= l; ret += l;
17282 :
17283 0 : *size = ret;
17284 0 : return 0;
17285 : }
17286 :
17287 : int ASN1CALL
17288 0 : decode_KrbFastArmoredReq(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, KrbFastArmoredReq *data, size_t *size)
17289 : {
17290 0 : size_t ret = 0;
17291 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
17292 : int e HEIMDAL_UNUSED_ATTRIBUTE;
17293 :
17294 0 : memset(data, 0, sizeof(*data));
17295 : {
17296 : size_t Top_datalen, Top_oldlen;
17297 : Der_type Top_type;
17298 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
17299 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
17300 0 : if(e) goto fail;
17301 0 : p += l; len -= l; ret += l;
17302 0 : Top_oldlen = len;
17303 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
17304 0 : len = Top_datalen;
17305 : {
17306 : size_t armor_datalen, armor_oldlen;
17307 : Der_type armor_type;
17308 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &armor_type, 0, &armor_datalen, &l);
17309 0 : if (e == 0 && armor_type != CONS) { e = ASN1_BAD_ID; }
17310 0 : if(e) {
17311 0 : (data)->armor = NULL;
17312 : } else {
17313 0 : (data)->armor = calloc(1, sizeof(*(data)->armor));
17314 0 : if ((data)->armor == NULL) { e = ENOMEM; goto fail; }
17315 0 : p += l; len -= l; ret += l;
17316 0 : armor_oldlen = len;
17317 0 : if (armor_datalen > len) { e = ASN1_OVERRUN; goto fail; }
17318 0 : len = armor_datalen;
17319 0 : e = decode_KrbFastArmor(p, len, (data)->armor, &l);
17320 0 : if(e) goto fail;
17321 0 : p += l; len -= l; ret += l;
17322 0 : len = armor_oldlen - armor_datalen;
17323 : }
17324 : }
17325 : {
17326 : size_t req_checksum_datalen, req_checksum_oldlen;
17327 : Der_type req_checksum_type;
17328 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &req_checksum_type, 1, &req_checksum_datalen, &l);
17329 0 : if (e == 0 && req_checksum_type != CONS) { e = ASN1_BAD_ID; }
17330 0 : if(e) goto fail;
17331 0 : p += l; len -= l; ret += l;
17332 0 : req_checksum_oldlen = len;
17333 0 : if (req_checksum_datalen > len) { e = ASN1_OVERRUN; goto fail; }
17334 0 : len = req_checksum_datalen;
17335 0 : e = decode_Checksum(p, len, &(data)->req_checksum, &l);
17336 0 : if(e) goto fail;
17337 0 : p += l; len -= l; ret += l;
17338 0 : len = req_checksum_oldlen - req_checksum_datalen;
17339 : }
17340 : {
17341 : size_t enc_fast_req_datalen, enc_fast_req_oldlen;
17342 : Der_type enc_fast_req_type;
17343 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &enc_fast_req_type, 2, &enc_fast_req_datalen, &l);
17344 0 : if (e == 0 && enc_fast_req_type != CONS) { e = ASN1_BAD_ID; }
17345 0 : if(e) goto fail;
17346 0 : p += l; len -= l; ret += l;
17347 0 : enc_fast_req_oldlen = len;
17348 0 : if (enc_fast_req_datalen > len) { e = ASN1_OVERRUN; goto fail; }
17349 0 : len = enc_fast_req_datalen;
17350 0 : e = decode_EncryptedData(p, len, &(data)->enc_fast_req, &l);
17351 0 : if(e) goto fail;
17352 0 : p += l; len -= l; ret += l;
17353 0 : len = enc_fast_req_oldlen - enc_fast_req_datalen;
17354 : }
17355 0 : len = Top_oldlen - Top_datalen;
17356 : }
17357 0 : if(size) *size = ret;
17358 0 : return 0;
17359 0 : fail:
17360 0 : free_KrbFastArmoredReq(data);
17361 0 : return e;
17362 : }
17363 :
17364 : void ASN1CALL
17365 0 : free_KrbFastArmoredReq(KrbFastArmoredReq *data)
17366 : {
17367 0 : if((data)->armor) {
17368 0 : free_KrbFastArmor((data)->armor);
17369 0 : free((data)->armor);
17370 0 : (data)->armor = NULL;
17371 : }
17372 0 : free_Checksum(&(data)->req_checksum);
17373 0 : free_EncryptedData(&(data)->enc_fast_req);
17374 0 : }
17375 :
17376 : size_t ASN1CALL
17377 0 : length_KrbFastArmoredReq(const KrbFastArmoredReq *data)
17378 : {
17379 0 : size_t ret = 0;
17380 0 : if((data)->armor){
17381 0 : size_t Top_tag_oldret = ret;
17382 0 : ret = 0;
17383 0 : ret += length_KrbFastArmor((data)->armor);
17384 0 : ret += 1 + der_length_len (ret);
17385 0 : ret += Top_tag_oldret;
17386 : }
17387 : {
17388 0 : size_t Top_tag_oldret = ret;
17389 0 : ret = 0;
17390 0 : ret += length_Checksum(&(data)->req_checksum);
17391 0 : ret += 1 + der_length_len (ret);
17392 0 : ret += Top_tag_oldret;
17393 : }
17394 : {
17395 0 : size_t Top_tag_oldret = ret;
17396 0 : ret = 0;
17397 0 : ret += length_EncryptedData(&(data)->enc_fast_req);
17398 0 : ret += 1 + der_length_len (ret);
17399 0 : ret += Top_tag_oldret;
17400 : }
17401 0 : ret += 1 + der_length_len (ret);
17402 0 : return ret;
17403 : }
17404 :
17405 : int ASN1CALL
17406 0 : copy_KrbFastArmoredReq(const KrbFastArmoredReq *from, KrbFastArmoredReq *to)
17407 : {
17408 0 : memset(to, 0, sizeof(*to));
17409 0 : if((from)->armor) {
17410 0 : (to)->armor = malloc(sizeof(*(to)->armor));
17411 0 : if((to)->armor == NULL) goto fail;
17412 0 : if(copy_KrbFastArmor((from)->armor, (to)->armor)) goto fail;
17413 : }else
17414 0 : (to)->armor = NULL;
17415 0 : if(copy_Checksum(&(from)->req_checksum, &(to)->req_checksum)) goto fail;
17416 0 : if(copy_EncryptedData(&(from)->enc_fast_req, &(to)->enc_fast_req)) goto fail;
17417 0 : return 0;
17418 0 : fail:
17419 0 : free_KrbFastArmoredReq(to);
17420 0 : return ENOMEM;
17421 : }
17422 :
17423 : int ASN1CALL
17424 0 : encode_PA_FX_FAST_REQUEST(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const PA_FX_FAST_REQUEST *data, size_t *size)
17425 : {
17426 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
17427 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
17428 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
17429 :
17430 :
17431 0 : switch((data)->element) {
17432 0 : case choice_PA_FX_FAST_REQUEST_armored_data: {size_t Top_oldret = ret;
17433 0 : ret = 0;
17434 0 : e = encode_KrbFastArmoredReq(p, len, &((data))->u.armored_data, &l);
17435 0 : if (e) return e;
17436 0 : p -= l; len -= l; ret += l;
17437 :
17438 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
17439 0 : if (e) return e;
17440 0 : p -= l; len -= l; ret += l;
17441 :
17442 0 : ret += Top_oldret;
17443 0 : break;
17444 : }
17445 0 : case choice_PA_FX_FAST_REQUEST_asn1_ellipsis: {
17446 0 : if (len < (data)->u.asn1_ellipsis.length)
17447 0 : return ASN1_OVERFLOW;
17448 0 : p -= (data)->u.asn1_ellipsis.length;
17449 0 : ret += (data)->u.asn1_ellipsis.length;
17450 0 : memcpy(p + 1, (data)->u.asn1_ellipsis.data, (data)->u.asn1_ellipsis.length);
17451 0 : break;
17452 : }
17453 : };
17454 0 : *size = ret;
17455 0 : return 0;
17456 : }
17457 :
17458 : int ASN1CALL
17459 0 : decode_PA_FX_FAST_REQUEST(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, PA_FX_FAST_REQUEST *data, size_t *size)
17460 : {
17461 0 : size_t ret = 0;
17462 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
17463 : int e HEIMDAL_UNUSED_ATTRIBUTE;
17464 :
17465 0 : memset(data, 0, sizeof(*data));
17466 0 : if (der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 0, NULL) == 0) {
17467 : {
17468 : size_t armored_data_datalen, armored_data_oldlen;
17469 : Der_type armored_data_type;
17470 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &armored_data_type, 0, &armored_data_datalen, &l);
17471 0 : if (e == 0 && armored_data_type != CONS) { e = ASN1_BAD_ID; }
17472 0 : if(e) goto fail;
17473 0 : p += l; len -= l; ret += l;
17474 0 : armored_data_oldlen = len;
17475 0 : if (armored_data_datalen > len) { e = ASN1_OVERRUN; goto fail; }
17476 0 : len = armored_data_datalen;
17477 0 : e = decode_KrbFastArmoredReq(p, len, &(data)->u.armored_data, &l);
17478 0 : if(e) goto fail;
17479 0 : p += l; len -= l; ret += l;
17480 0 : len = armored_data_oldlen - armored_data_datalen;
17481 : }
17482 0 : (data)->element = choice_PA_FX_FAST_REQUEST_armored_data;
17483 : }
17484 : else {
17485 0 : (data)->u.asn1_ellipsis.data = calloc(1, len);
17486 0 : if ((data)->u.asn1_ellipsis.data == NULL) {
17487 0 : e = ENOMEM; goto fail;
17488 : }
17489 0 : (data)->u.asn1_ellipsis.length = len;
17490 0 : memcpy((data)->u.asn1_ellipsis.data, p, len);
17491 0 : (data)->element = choice_PA_FX_FAST_REQUEST_asn1_ellipsis;
17492 0 : p += len;
17493 0 : ret += len;
17494 0 : len = 0;
17495 : }
17496 0 : if(size) *size = ret;
17497 0 : return 0;
17498 0 : fail:
17499 0 : free_PA_FX_FAST_REQUEST(data);
17500 0 : return e;
17501 : }
17502 :
17503 : void ASN1CALL
17504 0 : free_PA_FX_FAST_REQUEST(PA_FX_FAST_REQUEST *data)
17505 : {
17506 0 : switch((data)->element) {
17507 0 : case choice_PA_FX_FAST_REQUEST_armored_data:
17508 0 : free_KrbFastArmoredReq(&(data)->u.armored_data);
17509 0 : break;
17510 0 : case choice_PA_FX_FAST_REQUEST_asn1_ellipsis:
17511 0 : der_free_octet_string(&(data)->u.asn1_ellipsis);
17512 0 : break;}
17513 0 : }
17514 :
17515 : size_t ASN1CALL
17516 0 : length_PA_FX_FAST_REQUEST(const PA_FX_FAST_REQUEST *data)
17517 : {
17518 0 : size_t ret = 0;
17519 0 : switch((data)->element) {
17520 0 : case choice_PA_FX_FAST_REQUEST_armored_data:
17521 : {
17522 0 : size_t Top_oldret = ret;
17523 0 : ret = 0;
17524 0 : ret += length_KrbFastArmoredReq(&(data)->u.armored_data);
17525 0 : ret += 1 + der_length_len (ret);
17526 0 : ret += Top_oldret;
17527 : }
17528 0 : break;
17529 0 : case choice_PA_FX_FAST_REQUEST_asn1_ellipsis:
17530 0 : ret += (data)->u.asn1_ellipsis.length;
17531 0 : break;
17532 : }
17533 0 : return ret;
17534 : }
17535 :
17536 : int ASN1CALL
17537 0 : copy_PA_FX_FAST_REQUEST(const PA_FX_FAST_REQUEST *from, PA_FX_FAST_REQUEST *to)
17538 : {
17539 0 : memset(to, 0, sizeof(*to));
17540 0 : (to)->element = (from)->element;
17541 0 : switch((from)->element) {
17542 0 : case choice_PA_FX_FAST_REQUEST_armored_data:
17543 0 : if(copy_KrbFastArmoredReq(&(from)->u.armored_data, &(to)->u.armored_data)) goto fail;
17544 0 : break;
17545 0 : case choice_PA_FX_FAST_REQUEST_asn1_ellipsis: {
17546 : int ret;
17547 0 : ret=der_copy_octet_string(&(from)->u.asn1_ellipsis, &(to)->u.asn1_ellipsis);
17548 0 : if (ret) goto fail;
17549 0 : break;
17550 : }
17551 : }
17552 0 : return 0;
17553 0 : fail:
17554 0 : free_PA_FX_FAST_REQUEST(to);
17555 0 : return ENOMEM;
17556 : }
17557 :
17558 : int ASN1CALL
17559 0 : encode_KrbFastFinished(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const KrbFastFinished *data, size_t *size)
17560 : {
17561 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
17562 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
17563 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
17564 :
17565 : /* ticket-checksum */
17566 : {
17567 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
17568 0 : ret = 0;
17569 0 : e = encode_Checksum(p, len, &(data)->ticket_checksum, &l);
17570 0 : if (e) return e;
17571 0 : p -= l; len -= l; ret += l;
17572 :
17573 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 5, &l);
17574 0 : if (e) return e;
17575 0 : p -= l; len -= l; ret += l;
17576 :
17577 0 : ret += Top_tag_oldret;
17578 : }
17579 : /* checksum */
17580 : {
17581 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
17582 0 : ret = 0;
17583 0 : e = encode_Checksum(p, len, &(data)->checksum, &l);
17584 0 : if (e) return e;
17585 0 : p -= l; len -= l; ret += l;
17586 :
17587 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 4, &l);
17588 0 : if (e) return e;
17589 0 : p -= l; len -= l; ret += l;
17590 :
17591 0 : ret += Top_tag_oldret;
17592 : }
17593 : /* cname */
17594 : {
17595 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
17596 0 : ret = 0;
17597 0 : e = encode_PrincipalName(p, len, &(data)->cname, &l);
17598 0 : if (e) return e;
17599 0 : p -= l; len -= l; ret += l;
17600 :
17601 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
17602 0 : if (e) return e;
17603 0 : p -= l; len -= l; ret += l;
17604 :
17605 0 : ret += Top_tag_oldret;
17606 : }
17607 : /* crealm */
17608 : {
17609 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
17610 0 : ret = 0;
17611 0 : e = encode_Realm(p, len, &(data)->crealm, &l);
17612 0 : if (e) return e;
17613 0 : p -= l; len -= l; ret += l;
17614 :
17615 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
17616 0 : if (e) return e;
17617 0 : p -= l; len -= l; ret += l;
17618 :
17619 0 : ret += Top_tag_oldret;
17620 : }
17621 : /* usec */
17622 : {
17623 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
17624 0 : ret = 0;
17625 0 : e = encode_krb5int32(p, len, &(data)->usec, &l);
17626 0 : if (e) return e;
17627 0 : p -= l; len -= l; ret += l;
17628 :
17629 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
17630 0 : if (e) return e;
17631 0 : p -= l; len -= l; ret += l;
17632 :
17633 0 : ret += Top_tag_oldret;
17634 : }
17635 : /* timestamp */
17636 : {
17637 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
17638 0 : ret = 0;
17639 0 : e = encode_KerberosTime(p, len, &(data)->timestamp, &l);
17640 0 : if (e) return e;
17641 0 : p -= l; len -= l; ret += l;
17642 :
17643 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
17644 0 : if (e) return e;
17645 0 : p -= l; len -= l; ret += l;
17646 :
17647 0 : ret += Top_tag_oldret;
17648 : }
17649 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
17650 0 : if (e) return e;
17651 0 : p -= l; len -= l; ret += l;
17652 :
17653 0 : *size = ret;
17654 0 : return 0;
17655 : }
17656 :
17657 : int ASN1CALL
17658 0 : decode_KrbFastFinished(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, KrbFastFinished *data, size_t *size)
17659 : {
17660 0 : size_t ret = 0;
17661 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
17662 : int e HEIMDAL_UNUSED_ATTRIBUTE;
17663 :
17664 0 : memset(data, 0, sizeof(*data));
17665 : {
17666 : size_t Top_datalen, Top_oldlen;
17667 : Der_type Top_type;
17668 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
17669 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
17670 0 : if(e) goto fail;
17671 0 : p += l; len -= l; ret += l;
17672 0 : Top_oldlen = len;
17673 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
17674 0 : len = Top_datalen;
17675 : {
17676 : size_t timestamp_datalen, timestamp_oldlen;
17677 : Der_type timestamp_type;
17678 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, ×tamp_type, 0, ×tamp_datalen, &l);
17679 0 : if (e == 0 && timestamp_type != CONS) { e = ASN1_BAD_ID; }
17680 0 : if(e) goto fail;
17681 0 : p += l; len -= l; ret += l;
17682 0 : timestamp_oldlen = len;
17683 0 : if (timestamp_datalen > len) { e = ASN1_OVERRUN; goto fail; }
17684 0 : len = timestamp_datalen;
17685 0 : e = decode_KerberosTime(p, len, &(data)->timestamp, &l);
17686 0 : if(e) goto fail;
17687 0 : p += l; len -= l; ret += l;
17688 0 : len = timestamp_oldlen - timestamp_datalen;
17689 : }
17690 : {
17691 : size_t usec_datalen, usec_oldlen;
17692 : Der_type usec_type;
17693 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &usec_type, 1, &usec_datalen, &l);
17694 0 : if (e == 0 && usec_type != CONS) { e = ASN1_BAD_ID; }
17695 0 : if(e) goto fail;
17696 0 : p += l; len -= l; ret += l;
17697 0 : usec_oldlen = len;
17698 0 : if (usec_datalen > len) { e = ASN1_OVERRUN; goto fail; }
17699 0 : len = usec_datalen;
17700 0 : e = decode_krb5int32(p, len, &(data)->usec, &l);
17701 0 : if(e) goto fail;
17702 0 : p += l; len -= l; ret += l;
17703 0 : len = usec_oldlen - usec_datalen;
17704 : }
17705 : {
17706 : size_t crealm_datalen, crealm_oldlen;
17707 : Der_type crealm_type;
17708 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &crealm_type, 2, &crealm_datalen, &l);
17709 0 : if (e == 0 && crealm_type != CONS) { e = ASN1_BAD_ID; }
17710 0 : if(e) goto fail;
17711 0 : p += l; len -= l; ret += l;
17712 0 : crealm_oldlen = len;
17713 0 : if (crealm_datalen > len) { e = ASN1_OVERRUN; goto fail; }
17714 0 : len = crealm_datalen;
17715 0 : e = decode_Realm(p, len, &(data)->crealm, &l);
17716 0 : if(e) goto fail;
17717 0 : p += l; len -= l; ret += l;
17718 0 : len = crealm_oldlen - crealm_datalen;
17719 : }
17720 : {
17721 : size_t cname_datalen, cname_oldlen;
17722 : Der_type cname_type;
17723 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &cname_type, 3, &cname_datalen, &l);
17724 0 : if (e == 0 && cname_type != CONS) { e = ASN1_BAD_ID; }
17725 0 : if(e) goto fail;
17726 0 : p += l; len -= l; ret += l;
17727 0 : cname_oldlen = len;
17728 0 : if (cname_datalen > len) { e = ASN1_OVERRUN; goto fail; }
17729 0 : len = cname_datalen;
17730 0 : e = decode_PrincipalName(p, len, &(data)->cname, &l);
17731 0 : if(e) goto fail;
17732 0 : p += l; len -= l; ret += l;
17733 0 : len = cname_oldlen - cname_datalen;
17734 : }
17735 : {
17736 : size_t checksum_datalen, checksum_oldlen;
17737 : Der_type checksum_type;
17738 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &checksum_type, 4, &checksum_datalen, &l);
17739 0 : if (e == 0 && checksum_type != CONS) { e = ASN1_BAD_ID; }
17740 0 : if(e) goto fail;
17741 0 : p += l; len -= l; ret += l;
17742 0 : checksum_oldlen = len;
17743 0 : if (checksum_datalen > len) { e = ASN1_OVERRUN; goto fail; }
17744 0 : len = checksum_datalen;
17745 0 : e = decode_Checksum(p, len, &(data)->checksum, &l);
17746 0 : if(e) goto fail;
17747 0 : p += l; len -= l; ret += l;
17748 0 : len = checksum_oldlen - checksum_datalen;
17749 : }
17750 : {
17751 : size_t ticket_checksum_datalen, ticket_checksum_oldlen;
17752 : Der_type ticket_checksum_type;
17753 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &ticket_checksum_type, 5, &ticket_checksum_datalen, &l);
17754 0 : if (e == 0 && ticket_checksum_type != CONS) { e = ASN1_BAD_ID; }
17755 0 : if(e) goto fail;
17756 0 : p += l; len -= l; ret += l;
17757 0 : ticket_checksum_oldlen = len;
17758 0 : if (ticket_checksum_datalen > len) { e = ASN1_OVERRUN; goto fail; }
17759 0 : len = ticket_checksum_datalen;
17760 0 : e = decode_Checksum(p, len, &(data)->ticket_checksum, &l);
17761 0 : if(e) goto fail;
17762 0 : p += l; len -= l; ret += l;
17763 0 : len = ticket_checksum_oldlen - ticket_checksum_datalen;
17764 : }
17765 0 : len = Top_oldlen - Top_datalen;
17766 : }
17767 0 : if(size) *size = ret;
17768 0 : return 0;
17769 0 : fail:
17770 0 : free_KrbFastFinished(data);
17771 0 : return e;
17772 : }
17773 :
17774 : void ASN1CALL
17775 0 : free_KrbFastFinished(KrbFastFinished *data)
17776 : {
17777 0 : free_KerberosTime(&(data)->timestamp);
17778 0 : free_krb5int32(&(data)->usec);
17779 0 : free_Realm(&(data)->crealm);
17780 0 : free_PrincipalName(&(data)->cname);
17781 0 : free_Checksum(&(data)->checksum);
17782 0 : free_Checksum(&(data)->ticket_checksum);
17783 0 : }
17784 :
17785 : size_t ASN1CALL
17786 0 : length_KrbFastFinished(const KrbFastFinished *data)
17787 : {
17788 0 : size_t ret = 0;
17789 : {
17790 0 : size_t Top_tag_oldret = ret;
17791 0 : ret = 0;
17792 0 : ret += length_KerberosTime(&(data)->timestamp);
17793 0 : ret += 1 + der_length_len (ret);
17794 0 : ret += Top_tag_oldret;
17795 : }
17796 : {
17797 0 : size_t Top_tag_oldret = ret;
17798 0 : ret = 0;
17799 0 : ret += length_krb5int32(&(data)->usec);
17800 0 : ret += 1 + der_length_len (ret);
17801 0 : ret += Top_tag_oldret;
17802 : }
17803 : {
17804 0 : size_t Top_tag_oldret = ret;
17805 0 : ret = 0;
17806 0 : ret += length_Realm(&(data)->crealm);
17807 0 : ret += 1 + der_length_len (ret);
17808 0 : ret += Top_tag_oldret;
17809 : }
17810 : {
17811 0 : size_t Top_tag_oldret = ret;
17812 0 : ret = 0;
17813 0 : ret += length_PrincipalName(&(data)->cname);
17814 0 : ret += 1 + der_length_len (ret);
17815 0 : ret += Top_tag_oldret;
17816 : }
17817 : {
17818 0 : size_t Top_tag_oldret = ret;
17819 0 : ret = 0;
17820 0 : ret += length_Checksum(&(data)->checksum);
17821 0 : ret += 1 + der_length_len (ret);
17822 0 : ret += Top_tag_oldret;
17823 : }
17824 : {
17825 0 : size_t Top_tag_oldret = ret;
17826 0 : ret = 0;
17827 0 : ret += length_Checksum(&(data)->ticket_checksum);
17828 0 : ret += 1 + der_length_len (ret);
17829 0 : ret += Top_tag_oldret;
17830 : }
17831 0 : ret += 1 + der_length_len (ret);
17832 0 : return ret;
17833 : }
17834 :
17835 : int ASN1CALL
17836 0 : copy_KrbFastFinished(const KrbFastFinished *from, KrbFastFinished *to)
17837 : {
17838 0 : memset(to, 0, sizeof(*to));
17839 0 : if(copy_KerberosTime(&(from)->timestamp, &(to)->timestamp)) goto fail;
17840 0 : if(copy_krb5int32(&(from)->usec, &(to)->usec)) goto fail;
17841 0 : if(copy_Realm(&(from)->crealm, &(to)->crealm)) goto fail;
17842 0 : if(copy_PrincipalName(&(from)->cname, &(to)->cname)) goto fail;
17843 0 : if(copy_Checksum(&(from)->checksum, &(to)->checksum)) goto fail;
17844 0 : if(copy_Checksum(&(from)->ticket_checksum, &(to)->ticket_checksum)) goto fail;
17845 0 : return 0;
17846 0 : fail:
17847 0 : free_KrbFastFinished(to);
17848 0 : return ENOMEM;
17849 : }
17850 :
17851 : int ASN1CALL
17852 0 : encode_KrbFastResponse(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const KrbFastResponse *data, size_t *size)
17853 : {
17854 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
17855 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
17856 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
17857 :
17858 : /* finished */
17859 0 : if((data)->finished) {
17860 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
17861 0 : ret = 0;
17862 0 : e = encode_KrbFastFinished(p, len, (data)->finished, &l);
17863 0 : if (e) return e;
17864 0 : p -= l; len -= l; ret += l;
17865 :
17866 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
17867 0 : if (e) return e;
17868 0 : p -= l; len -= l; ret += l;
17869 :
17870 0 : ret += Top_tag_oldret;
17871 : }
17872 : /* rep-key */
17873 0 : if((data)->rep_key) {
17874 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
17875 0 : ret = 0;
17876 0 : e = encode_EncryptionKey(p, len, (data)->rep_key, &l);
17877 0 : if (e) return e;
17878 0 : p -= l; len -= l; ret += l;
17879 :
17880 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
17881 0 : if (e) return e;
17882 0 : p -= l; len -= l; ret += l;
17883 :
17884 0 : ret += Top_tag_oldret;
17885 : }
17886 : /* padata */
17887 : {
17888 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
17889 0 : ret = 0;
17890 0 : for(i = (int)(&(data)->padata)->len - 1; i >= 0; --i) {
17891 0 : size_t padata_tag_tag_for_oldret = ret;
17892 0 : ret = 0;
17893 0 : e = encode_PA_DATA(p, len, &(&(data)->padata)->val[i], &l);
17894 0 : if (e) return e;
17895 0 : p -= l; len -= l; ret += l;
17896 :
17897 0 : ret += padata_tag_tag_for_oldret;
17898 : }
17899 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
17900 0 : if (e) return e;
17901 0 : p -= l; len -= l; ret += l;
17902 :
17903 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
17904 0 : if (e) return e;
17905 0 : p -= l; len -= l; ret += l;
17906 :
17907 0 : ret += Top_tag_oldret;
17908 : }
17909 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
17910 0 : if (e) return e;
17911 0 : p -= l; len -= l; ret += l;
17912 :
17913 0 : *size = ret;
17914 0 : return 0;
17915 : }
17916 :
17917 : int ASN1CALL
17918 0 : decode_KrbFastResponse(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, KrbFastResponse *data, size_t *size)
17919 : {
17920 0 : size_t ret = 0;
17921 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
17922 : int e HEIMDAL_UNUSED_ATTRIBUTE;
17923 :
17924 0 : memset(data, 0, sizeof(*data));
17925 : {
17926 : size_t Top_datalen, Top_oldlen;
17927 : Der_type Top_type;
17928 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
17929 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
17930 0 : if(e) goto fail;
17931 0 : p += l; len -= l; ret += l;
17932 0 : Top_oldlen = len;
17933 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
17934 0 : len = Top_datalen;
17935 : {
17936 : size_t padata_datalen, padata_oldlen;
17937 : Der_type padata_type;
17938 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &padata_type, 0, &padata_datalen, &l);
17939 0 : if (e == 0 && padata_type != CONS) { e = ASN1_BAD_ID; }
17940 0 : if(e) goto fail;
17941 0 : p += l; len -= l; ret += l;
17942 0 : padata_oldlen = len;
17943 0 : if (padata_datalen > len) { e = ASN1_OVERRUN; goto fail; }
17944 0 : len = padata_datalen;
17945 : {
17946 : size_t padata_Tag_datalen, padata_Tag_oldlen;
17947 : Der_type padata_Tag_type;
17948 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &padata_Tag_type, UT_Sequence, &padata_Tag_datalen, &l);
17949 0 : if (e == 0 && padata_Tag_type != CONS) { e = ASN1_BAD_ID; }
17950 0 : if(e) goto fail;
17951 0 : p += l; len -= l; ret += l;
17952 0 : padata_Tag_oldlen = len;
17953 0 : if (padata_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
17954 0 : len = padata_Tag_datalen;
17955 : {
17956 0 : size_t padata_Tag_Tag_origlen = len;
17957 0 : size_t padata_Tag_Tag_oldret = ret;
17958 0 : size_t padata_Tag_Tag_olen = 0;
17959 : void *padata_Tag_Tag_tmp;
17960 0 : ret = 0;
17961 0 : (&(data)->padata)->len = 0;
17962 0 : (&(data)->padata)->val = NULL;
17963 0 : while(ret < padata_Tag_Tag_origlen) {
17964 0 : size_t padata_Tag_Tag_nlen = padata_Tag_Tag_olen + sizeof(*((&(data)->padata)->val));
17965 0 : if (padata_Tag_Tag_olen > padata_Tag_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
17966 0 : padata_Tag_Tag_olen = padata_Tag_Tag_nlen;
17967 0 : padata_Tag_Tag_tmp = realloc((&(data)->padata)->val, padata_Tag_Tag_olen);
17968 0 : if (padata_Tag_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
17969 0 : (&(data)->padata)->val = padata_Tag_Tag_tmp;
17970 0 : e = decode_PA_DATA(p, len, &(&(data)->padata)->val[(&(data)->padata)->len], &l);
17971 0 : if(e) goto fail;
17972 0 : p += l; len -= l; ret += l;
17973 0 : (&(data)->padata)->len++;
17974 0 : len = padata_Tag_Tag_origlen - ret;
17975 : }
17976 0 : ret += padata_Tag_Tag_oldret;
17977 : }
17978 0 : len = padata_Tag_oldlen - padata_Tag_datalen;
17979 : }
17980 0 : len = padata_oldlen - padata_datalen;
17981 : }
17982 : {
17983 : size_t rep_key_datalen, rep_key_oldlen;
17984 : Der_type rep_key_type;
17985 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &rep_key_type, 1, &rep_key_datalen, &l);
17986 0 : if (e == 0 && rep_key_type != CONS) { e = ASN1_BAD_ID; }
17987 0 : if(e) {
17988 0 : (data)->rep_key = NULL;
17989 : } else {
17990 0 : (data)->rep_key = calloc(1, sizeof(*(data)->rep_key));
17991 0 : if ((data)->rep_key == NULL) { e = ENOMEM; goto fail; }
17992 0 : p += l; len -= l; ret += l;
17993 0 : rep_key_oldlen = len;
17994 0 : if (rep_key_datalen > len) { e = ASN1_OVERRUN; goto fail; }
17995 0 : len = rep_key_datalen;
17996 0 : e = decode_EncryptionKey(p, len, (data)->rep_key, &l);
17997 0 : if(e) goto fail;
17998 0 : p += l; len -= l; ret += l;
17999 0 : len = rep_key_oldlen - rep_key_datalen;
18000 : }
18001 : }
18002 : {
18003 : size_t finished_datalen, finished_oldlen;
18004 : Der_type finished_type;
18005 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &finished_type, 2, &finished_datalen, &l);
18006 0 : if (e == 0 && finished_type != CONS) { e = ASN1_BAD_ID; }
18007 0 : if(e) {
18008 0 : (data)->finished = NULL;
18009 : } else {
18010 0 : (data)->finished = calloc(1, sizeof(*(data)->finished));
18011 0 : if ((data)->finished == NULL) { e = ENOMEM; goto fail; }
18012 0 : p += l; len -= l; ret += l;
18013 0 : finished_oldlen = len;
18014 0 : if (finished_datalen > len) { e = ASN1_OVERRUN; goto fail; }
18015 0 : len = finished_datalen;
18016 0 : e = decode_KrbFastFinished(p, len, (data)->finished, &l);
18017 0 : if(e) goto fail;
18018 0 : p += l; len -= l; ret += l;
18019 0 : len = finished_oldlen - finished_datalen;
18020 : }
18021 : }
18022 0 : len = Top_oldlen - Top_datalen;
18023 : }
18024 0 : if(size) *size = ret;
18025 0 : return 0;
18026 0 : fail:
18027 0 : free_KrbFastResponse(data);
18028 0 : return e;
18029 : }
18030 :
18031 : void ASN1CALL
18032 0 : free_KrbFastResponse(KrbFastResponse *data)
18033 : {
18034 0 : while((&(data)->padata)->len){
18035 0 : free_PA_DATA(&(&(data)->padata)->val[(&(data)->padata)->len-1]);
18036 0 : (&(data)->padata)->len--;
18037 : }
18038 0 : free((&(data)->padata)->val);
18039 0 : (&(data)->padata)->val = NULL;
18040 0 : if((data)->rep_key) {
18041 0 : free_EncryptionKey((data)->rep_key);
18042 0 : free((data)->rep_key);
18043 0 : (data)->rep_key = NULL;
18044 : }
18045 0 : if((data)->finished) {
18046 0 : free_KrbFastFinished((data)->finished);
18047 0 : free((data)->finished);
18048 0 : (data)->finished = NULL;
18049 : }
18050 0 : }
18051 :
18052 : size_t ASN1CALL
18053 0 : length_KrbFastResponse(const KrbFastResponse *data)
18054 : {
18055 0 : size_t ret = 0;
18056 : {
18057 0 : size_t Top_tag_oldret = ret;
18058 0 : ret = 0;
18059 : {
18060 0 : size_t padata_tag_tag_oldret = ret;
18061 : int i;
18062 0 : ret = 0;
18063 0 : for(i = (&(data)->padata)->len - 1; i >= 0; --i){
18064 0 : size_t padata_tag_tag_for_oldret = ret;
18065 0 : ret = 0;
18066 0 : ret += length_PA_DATA(&(&(data)->padata)->val[i]);
18067 0 : ret += padata_tag_tag_for_oldret;
18068 : }
18069 0 : ret += padata_tag_tag_oldret;
18070 : }
18071 0 : ret += 1 + der_length_len (ret);
18072 0 : ret += 1 + der_length_len (ret);
18073 0 : ret += Top_tag_oldret;
18074 : }
18075 0 : if((data)->rep_key){
18076 0 : size_t Top_tag_oldret = ret;
18077 0 : ret = 0;
18078 0 : ret += length_EncryptionKey((data)->rep_key);
18079 0 : ret += 1 + der_length_len (ret);
18080 0 : ret += Top_tag_oldret;
18081 : }
18082 0 : if((data)->finished){
18083 0 : size_t Top_tag_oldret = ret;
18084 0 : ret = 0;
18085 0 : ret += length_KrbFastFinished((data)->finished);
18086 0 : ret += 1 + der_length_len (ret);
18087 0 : ret += Top_tag_oldret;
18088 : }
18089 0 : ret += 1 + der_length_len (ret);
18090 0 : return ret;
18091 : }
18092 :
18093 : int ASN1CALL
18094 0 : copy_KrbFastResponse(const KrbFastResponse *from, KrbFastResponse *to)
18095 : {
18096 0 : memset(to, 0, sizeof(*to));
18097 0 : if(((&(to)->padata)->val = malloc((&(from)->padata)->len * sizeof(*(&(to)->padata)->val))) == NULL && (&(from)->padata)->len != 0)
18098 0 : goto fail;
18099 0 : for((&(to)->padata)->len = 0; (&(to)->padata)->len < (&(from)->padata)->len; (&(to)->padata)->len++){
18100 0 : if(copy_PA_DATA(&(&(from)->padata)->val[(&(to)->padata)->len], &(&(to)->padata)->val[(&(to)->padata)->len])) goto fail;
18101 : }
18102 0 : if((from)->rep_key) {
18103 0 : (to)->rep_key = malloc(sizeof(*(to)->rep_key));
18104 0 : if((to)->rep_key == NULL) goto fail;
18105 0 : if(copy_EncryptionKey((from)->rep_key, (to)->rep_key)) goto fail;
18106 : }else
18107 0 : (to)->rep_key = NULL;
18108 0 : if((from)->finished) {
18109 0 : (to)->finished = malloc(sizeof(*(to)->finished));
18110 0 : if((to)->finished == NULL) goto fail;
18111 0 : if(copy_KrbFastFinished((from)->finished, (to)->finished)) goto fail;
18112 : }else
18113 0 : (to)->finished = NULL;
18114 0 : return 0;
18115 0 : fail:
18116 0 : free_KrbFastResponse(to);
18117 0 : return ENOMEM;
18118 : }
18119 :
18120 : int ASN1CALL
18121 0 : encode_KrbFastArmoredRep(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const KrbFastArmoredRep *data, size_t *size)
18122 : {
18123 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
18124 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
18125 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
18126 :
18127 : /* enc-fast-rep */
18128 : {
18129 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
18130 0 : ret = 0;
18131 0 : e = encode_EncryptedData(p, len, &(data)->enc_fast_rep, &l);
18132 0 : if (e) return e;
18133 0 : p -= l; len -= l; ret += l;
18134 :
18135 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
18136 0 : if (e) return e;
18137 0 : p -= l; len -= l; ret += l;
18138 :
18139 0 : ret += Top_tag_oldret;
18140 : }
18141 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
18142 0 : if (e) return e;
18143 0 : p -= l; len -= l; ret += l;
18144 :
18145 0 : *size = ret;
18146 0 : return 0;
18147 : }
18148 :
18149 : int ASN1CALL
18150 0 : decode_KrbFastArmoredRep(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, KrbFastArmoredRep *data, size_t *size)
18151 : {
18152 0 : size_t ret = 0;
18153 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
18154 : int e HEIMDAL_UNUSED_ATTRIBUTE;
18155 :
18156 0 : memset(data, 0, sizeof(*data));
18157 : {
18158 : size_t Top_datalen, Top_oldlen;
18159 : Der_type Top_type;
18160 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
18161 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
18162 0 : if(e) goto fail;
18163 0 : p += l; len -= l; ret += l;
18164 0 : Top_oldlen = len;
18165 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
18166 0 : len = Top_datalen;
18167 : {
18168 : size_t enc_fast_rep_datalen, enc_fast_rep_oldlen;
18169 : Der_type enc_fast_rep_type;
18170 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &enc_fast_rep_type, 0, &enc_fast_rep_datalen, &l);
18171 0 : if (e == 0 && enc_fast_rep_type != CONS) { e = ASN1_BAD_ID; }
18172 0 : if(e) goto fail;
18173 0 : p += l; len -= l; ret += l;
18174 0 : enc_fast_rep_oldlen = len;
18175 0 : if (enc_fast_rep_datalen > len) { e = ASN1_OVERRUN; goto fail; }
18176 0 : len = enc_fast_rep_datalen;
18177 0 : e = decode_EncryptedData(p, len, &(data)->enc_fast_rep, &l);
18178 0 : if(e) goto fail;
18179 0 : p += l; len -= l; ret += l;
18180 0 : len = enc_fast_rep_oldlen - enc_fast_rep_datalen;
18181 : }
18182 0 : len = Top_oldlen - Top_datalen;
18183 : }
18184 0 : if(size) *size = ret;
18185 0 : return 0;
18186 0 : fail:
18187 0 : free_KrbFastArmoredRep(data);
18188 0 : return e;
18189 : }
18190 :
18191 : void ASN1CALL
18192 0 : free_KrbFastArmoredRep(KrbFastArmoredRep *data)
18193 : {
18194 0 : free_EncryptedData(&(data)->enc_fast_rep);
18195 0 : }
18196 :
18197 : size_t ASN1CALL
18198 0 : length_KrbFastArmoredRep(const KrbFastArmoredRep *data)
18199 : {
18200 0 : size_t ret = 0;
18201 : {
18202 0 : size_t Top_tag_oldret = ret;
18203 0 : ret = 0;
18204 0 : ret += length_EncryptedData(&(data)->enc_fast_rep);
18205 0 : ret += 1 + der_length_len (ret);
18206 0 : ret += Top_tag_oldret;
18207 : }
18208 0 : ret += 1 + der_length_len (ret);
18209 0 : return ret;
18210 : }
18211 :
18212 : int ASN1CALL
18213 0 : copy_KrbFastArmoredRep(const KrbFastArmoredRep *from, KrbFastArmoredRep *to)
18214 : {
18215 0 : memset(to, 0, sizeof(*to));
18216 0 : if(copy_EncryptedData(&(from)->enc_fast_rep, &(to)->enc_fast_rep)) goto fail;
18217 0 : return 0;
18218 0 : fail:
18219 0 : free_KrbFastArmoredRep(to);
18220 0 : return ENOMEM;
18221 : }
18222 :
18223 : int ASN1CALL
18224 0 : encode_PA_FX_FAST_REPLY(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const PA_FX_FAST_REPLY *data, size_t *size)
18225 : {
18226 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
18227 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
18228 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
18229 :
18230 :
18231 0 : switch((data)->element) {
18232 0 : case choice_PA_FX_FAST_REPLY_armored_data: {size_t Top_oldret = ret;
18233 0 : ret = 0;
18234 0 : e = encode_KrbFastArmoredRep(p, len, &((data))->u.armored_data, &l);
18235 0 : if (e) return e;
18236 0 : p -= l; len -= l; ret += l;
18237 :
18238 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
18239 0 : if (e) return e;
18240 0 : p -= l; len -= l; ret += l;
18241 :
18242 0 : ret += Top_oldret;
18243 0 : break;
18244 : }
18245 0 : case choice_PA_FX_FAST_REPLY_asn1_ellipsis: {
18246 0 : if (len < (data)->u.asn1_ellipsis.length)
18247 0 : return ASN1_OVERFLOW;
18248 0 : p -= (data)->u.asn1_ellipsis.length;
18249 0 : ret += (data)->u.asn1_ellipsis.length;
18250 0 : memcpy(p + 1, (data)->u.asn1_ellipsis.data, (data)->u.asn1_ellipsis.length);
18251 0 : break;
18252 : }
18253 : };
18254 0 : *size = ret;
18255 0 : return 0;
18256 : }
18257 :
18258 : int ASN1CALL
18259 0 : decode_PA_FX_FAST_REPLY(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, PA_FX_FAST_REPLY *data, size_t *size)
18260 : {
18261 0 : size_t ret = 0;
18262 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
18263 : int e HEIMDAL_UNUSED_ATTRIBUTE;
18264 :
18265 0 : memset(data, 0, sizeof(*data));
18266 0 : if (der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 0, NULL) == 0) {
18267 : {
18268 : size_t armored_data_datalen, armored_data_oldlen;
18269 : Der_type armored_data_type;
18270 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &armored_data_type, 0, &armored_data_datalen, &l);
18271 0 : if (e == 0 && armored_data_type != CONS) { e = ASN1_BAD_ID; }
18272 0 : if(e) goto fail;
18273 0 : p += l; len -= l; ret += l;
18274 0 : armored_data_oldlen = len;
18275 0 : if (armored_data_datalen > len) { e = ASN1_OVERRUN; goto fail; }
18276 0 : len = armored_data_datalen;
18277 0 : e = decode_KrbFastArmoredRep(p, len, &(data)->u.armored_data, &l);
18278 0 : if(e) goto fail;
18279 0 : p += l; len -= l; ret += l;
18280 0 : len = armored_data_oldlen - armored_data_datalen;
18281 : }
18282 0 : (data)->element = choice_PA_FX_FAST_REPLY_armored_data;
18283 : }
18284 : else {
18285 0 : (data)->u.asn1_ellipsis.data = calloc(1, len);
18286 0 : if ((data)->u.asn1_ellipsis.data == NULL) {
18287 0 : e = ENOMEM; goto fail;
18288 : }
18289 0 : (data)->u.asn1_ellipsis.length = len;
18290 0 : memcpy((data)->u.asn1_ellipsis.data, p, len);
18291 0 : (data)->element = choice_PA_FX_FAST_REPLY_asn1_ellipsis;
18292 0 : p += len;
18293 0 : ret += len;
18294 0 : len = 0;
18295 : }
18296 0 : if(size) *size = ret;
18297 0 : return 0;
18298 0 : fail:
18299 0 : free_PA_FX_FAST_REPLY(data);
18300 0 : return e;
18301 : }
18302 :
18303 : void ASN1CALL
18304 0 : free_PA_FX_FAST_REPLY(PA_FX_FAST_REPLY *data)
18305 : {
18306 0 : switch((data)->element) {
18307 0 : case choice_PA_FX_FAST_REPLY_armored_data:
18308 0 : free_KrbFastArmoredRep(&(data)->u.armored_data);
18309 0 : break;
18310 0 : case choice_PA_FX_FAST_REPLY_asn1_ellipsis:
18311 0 : der_free_octet_string(&(data)->u.asn1_ellipsis);
18312 0 : break;}
18313 0 : }
18314 :
18315 : size_t ASN1CALL
18316 0 : length_PA_FX_FAST_REPLY(const PA_FX_FAST_REPLY *data)
18317 : {
18318 0 : size_t ret = 0;
18319 0 : switch((data)->element) {
18320 0 : case choice_PA_FX_FAST_REPLY_armored_data:
18321 : {
18322 0 : size_t Top_oldret = ret;
18323 0 : ret = 0;
18324 0 : ret += length_KrbFastArmoredRep(&(data)->u.armored_data);
18325 0 : ret += 1 + der_length_len (ret);
18326 0 : ret += Top_oldret;
18327 : }
18328 0 : break;
18329 0 : case choice_PA_FX_FAST_REPLY_asn1_ellipsis:
18330 0 : ret += (data)->u.asn1_ellipsis.length;
18331 0 : break;
18332 : }
18333 0 : return ret;
18334 : }
18335 :
18336 : int ASN1CALL
18337 0 : copy_PA_FX_FAST_REPLY(const PA_FX_FAST_REPLY *from, PA_FX_FAST_REPLY *to)
18338 : {
18339 0 : memset(to, 0, sizeof(*to));
18340 0 : (to)->element = (from)->element;
18341 0 : switch((from)->element) {
18342 0 : case choice_PA_FX_FAST_REPLY_armored_data:
18343 0 : if(copy_KrbFastArmoredRep(&(from)->u.armored_data, &(to)->u.armored_data)) goto fail;
18344 0 : break;
18345 0 : case choice_PA_FX_FAST_REPLY_asn1_ellipsis: {
18346 : int ret;
18347 0 : ret=der_copy_octet_string(&(from)->u.asn1_ellipsis, &(to)->u.asn1_ellipsis);
18348 0 : if (ret) goto fail;
18349 0 : break;
18350 : }
18351 : }
18352 0 : return 0;
18353 0 : fail:
18354 0 : free_PA_FX_FAST_REPLY(to);
18355 0 : return ENOMEM;
18356 : }
18357 :
|
