Line data Source code
1 : #include "config.h"
2 : /* Generated from /builds/samba-team/devel/samba/source4/heimdal/lib/gssapi/spnego/spnego.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 <spnego_asn1.h>
15 : #include <spnego_asn1-priv.h>
16 : #include <asn1_err.h>
17 : #include <der.h>
18 : #include <der-private.h>
19 : #include <asn1-template.h>
20 : #include <parse_units.h>
21 :
22 : int ASN1CALL
23 0 : encode_MechType(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const MechType *data, size_t *size)
24 : {
25 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
26 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
27 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
28 :
29 0 : e = der_put_oid(p, len, data, &l);
30 0 : if (e) return e;
31 0 : p -= l; len -= l; ret += l;
32 :
33 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OID, &l);
34 0 : if (e) return e;
35 0 : p -= l; len -= l; ret += l;
36 :
37 0 : *size = ret;
38 0 : return 0;
39 : }
40 :
41 : int ASN1CALL
42 0 : decode_MechType(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, MechType *data, size_t *size)
43 : {
44 0 : size_t ret = 0;
45 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
46 : int e HEIMDAL_UNUSED_ATTRIBUTE;
47 :
48 0 : memset(data, 0, sizeof(*data));
49 : {
50 : size_t Top_datalen, Top_oldlen;
51 : Der_type Top_type;
52 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_OID, &Top_datalen, &l);
53 0 : if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
54 0 : if(e) goto fail;
55 0 : p += l; len -= l; ret += l;
56 0 : Top_oldlen = len;
57 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
58 0 : len = Top_datalen;
59 0 : e = der_get_oid(p, len, data, &l);
60 0 : if(e) goto fail;
61 0 : p += l; len -= l; ret += l;
62 0 : len = Top_oldlen - Top_datalen;
63 : }
64 0 : if(size) *size = ret;
65 0 : return 0;
66 0 : fail:
67 0 : free_MechType(data);
68 0 : return e;
69 : }
70 :
71 : void ASN1CALL
72 0 : free_MechType(MechType *data)
73 : {
74 0 : der_free_oid(data);
75 0 : }
76 :
77 : size_t ASN1CALL
78 0 : length_MechType(const MechType *data)
79 : {
80 0 : size_t ret = 0;
81 0 : ret += der_length_oid(data);
82 0 : ret += 1 + der_length_len (ret);
83 0 : return ret;
84 : }
85 :
86 : int ASN1CALL
87 0 : copy_MechType(const MechType *from, MechType *to)
88 : {
89 0 : memset(to, 0, sizeof(*to));
90 0 : if(der_copy_oid(from, to)) goto fail;
91 0 : return 0;
92 0 : fail:
93 0 : free_MechType(to);
94 0 : return ENOMEM;
95 : }
96 :
97 : int ASN1CALL
98 0 : encode_MechTypeList(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const MechTypeList *data, size_t *size)
99 : {
100 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
101 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
102 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
103 :
104 0 : for(i = (int)(data)->len - 1; i >= 0; --i) {
105 0 : size_t Top_tag_for_oldret = ret;
106 0 : ret = 0;
107 0 : e = encode_MechType(p, len, &(data)->val[i], &l);
108 0 : if (e) return e;
109 0 : p -= l; len -= l; ret += l;
110 :
111 0 : ret += Top_tag_for_oldret;
112 : }
113 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
114 0 : if (e) return e;
115 0 : p -= l; len -= l; ret += l;
116 :
117 0 : *size = ret;
118 0 : return 0;
119 : }
120 :
121 : int ASN1CALL
122 0 : decode_MechTypeList(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, MechTypeList *data, size_t *size)
123 : {
124 0 : size_t ret = 0;
125 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
126 : int e HEIMDAL_UNUSED_ATTRIBUTE;
127 :
128 0 : memset(data, 0, sizeof(*data));
129 : {
130 : size_t Top_datalen, Top_oldlen;
131 : Der_type Top_type;
132 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
133 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
134 0 : if(e) goto fail;
135 0 : p += l; len -= l; ret += l;
136 0 : Top_oldlen = len;
137 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
138 0 : len = Top_datalen;
139 : {
140 0 : size_t Top_Tag_origlen = len;
141 0 : size_t Top_Tag_oldret = ret;
142 0 : size_t Top_Tag_olen = 0;
143 : void *Top_Tag_tmp;
144 0 : ret = 0;
145 0 : (data)->len = 0;
146 0 : (data)->val = NULL;
147 0 : while(ret < Top_Tag_origlen) {
148 0 : size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
149 0 : if (Top_Tag_olen > Top_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
150 0 : Top_Tag_olen = Top_Tag_nlen;
151 0 : Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
152 0 : if (Top_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
153 0 : (data)->val = Top_Tag_tmp;
154 0 : e = decode_MechType(p, len, &(data)->val[(data)->len], &l);
155 0 : if(e) goto fail;
156 0 : p += l; len -= l; ret += l;
157 0 : (data)->len++;
158 0 : len = Top_Tag_origlen - ret;
159 : }
160 0 : ret += Top_Tag_oldret;
161 : }
162 0 : len = Top_oldlen - Top_datalen;
163 : }
164 0 : if(size) *size = ret;
165 0 : return 0;
166 0 : fail:
167 0 : free_MechTypeList(data);
168 0 : return e;
169 : }
170 :
171 : void ASN1CALL
172 0 : free_MechTypeList(MechTypeList *data)
173 : {
174 0 : while((data)->len){
175 0 : free_MechType(&(data)->val[(data)->len-1]);
176 0 : (data)->len--;
177 : }
178 0 : free((data)->val);
179 0 : (data)->val = NULL;
180 0 : }
181 :
182 : size_t ASN1CALL
183 0 : length_MechTypeList(const MechTypeList *data)
184 : {
185 0 : size_t ret = 0;
186 : {
187 0 : size_t Top_tag_oldret = ret;
188 : int i;
189 0 : ret = 0;
190 0 : for(i = (data)->len - 1; i >= 0; --i){
191 0 : size_t Top_tag_for_oldret = ret;
192 0 : ret = 0;
193 0 : ret += length_MechType(&(data)->val[i]);
194 0 : ret += Top_tag_for_oldret;
195 : }
196 0 : ret += Top_tag_oldret;
197 : }
198 0 : ret += 1 + der_length_len (ret);
199 0 : return ret;
200 : }
201 :
202 : int ASN1CALL
203 0 : copy_MechTypeList(const MechTypeList *from, MechTypeList *to)
204 : {
205 0 : memset(to, 0, sizeof(*to));
206 0 : if(((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
207 0 : goto fail;
208 0 : for((to)->len = 0; (to)->len < (from)->len; (to)->len++){
209 0 : if(copy_MechType(&(from)->val[(to)->len], &(to)->val[(to)->len])) goto fail;
210 : }
211 0 : return 0;
212 0 : fail:
213 0 : free_MechTypeList(to);
214 0 : return ENOMEM;
215 : }
216 :
217 : int ASN1CALL
218 0 : add_MechTypeList(MechTypeList *data, const MechType *element)
219 : {
220 : int ret;
221 : void *ptr;
222 :
223 0 : ptr = realloc(data->val,
224 0 : (data->len + 1) * sizeof(data->val[0]));
225 0 : if (ptr == NULL) return ENOMEM;
226 0 : data->val = ptr;
227 :
228 0 : ret = copy_MechType(element, &data->val[data->len]);
229 0 : if (ret) return ret;
230 0 : data->len++;
231 0 : return 0;
232 : }
233 :
234 : int ASN1CALL
235 0 : remove_MechTypeList(MechTypeList *data, unsigned int element)
236 : {
237 : void *ptr;
238 :
239 0 : if (data->len == 0 || element >= data->len)
240 0 : return ASN1_OVERRUN;
241 0 : free_MechType(&data->val[element]);
242 0 : data->len--;
243 0 : if (element < data->len)
244 0 : memmove(&data->val[element], &data->val[element + 1],
245 0 : sizeof(data->val[0]) * data->len);
246 0 : ptr = realloc(data->val, data->len * sizeof(data->val[0]));
247 0 : if (ptr != NULL || data->len == 0) data->val = ptr;
248 0 : return 0;
249 : }
250 :
251 : int ASN1CALL
252 0 : encode_ContextFlags(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const ContextFlags *data, size_t *size)
253 : {
254 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
255 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
256 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
257 :
258 : {
259 0 : unsigned char c = 0;
260 0 : int rest = 0;
261 0 : int bit_set = 0;
262 0 : if((data)->integFlag) {
263 0 : c |= 1<<1;
264 : }
265 0 : if((data)->confFlag) {
266 0 : c |= 1<<2;
267 : }
268 0 : if((data)->anonFlag) {
269 0 : c |= 1<<3;
270 : }
271 0 : if((data)->sequenceFlag) {
272 0 : c |= 1<<4;
273 : }
274 0 : if((data)->replayFlag) {
275 0 : c |= 1<<5;
276 : }
277 0 : if((data)->mutualFlag) {
278 0 : c |= 1<<6;
279 : }
280 0 : if((data)->delegFlag) {
281 0 : c |= 1<<7;
282 : }
283 0 : if (c != 0 || bit_set) {
284 0 : if (len < 1) return ASN1_OVERFLOW;
285 0 : *p-- = c; len--; ret++;
286 0 : if (!bit_set) {
287 0 : rest = 0;
288 0 : if(c) {
289 0 : while(c) {
290 0 : if (c & 1) break;
291 0 : c = c >> 1;
292 0 : rest++;
293 : }
294 : }
295 : }
296 : }
297 0 : if (len < 1) return ASN1_OVERFLOW;
298 0 : *p-- = rest;
299 0 : len -= 1;
300 0 : ret += 1;
301 : }
302 :
303 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_BitString, &l);
304 0 : if (e) return e;
305 0 : p -= l; len -= l; ret += l;
306 :
307 0 : *size = ret;
308 0 : return 0;
309 : }
310 :
311 : int ASN1CALL
312 0 : decode_ContextFlags(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, ContextFlags *data, size_t *size)
313 : {
314 0 : size_t ret = 0;
315 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
316 : int e HEIMDAL_UNUSED_ATTRIBUTE;
317 :
318 0 : memset(data, 0, sizeof(*data));
319 : {
320 : size_t Top_datalen, Top_oldlen;
321 : Der_type Top_type;
322 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_BitString, &Top_datalen, &l);
323 0 : if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
324 0 : if(e) goto fail;
325 0 : p += l; len -= l; ret += l;
326 0 : Top_oldlen = len;
327 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
328 0 : len = Top_datalen;
329 0 : if (len < 1) return ASN1_OVERRUN;
330 0 : p++; len--; ret++;
331 : do {
332 0 : if (len < 1) break;
333 0 : (data)->delegFlag = (*p >> 7) & 1;
334 0 : (data)->mutualFlag = (*p >> 6) & 1;
335 0 : (data)->replayFlag = (*p >> 5) & 1;
336 0 : (data)->sequenceFlag = (*p >> 4) & 1;
337 0 : (data)->anonFlag = (*p >> 3) & 1;
338 0 : (data)->confFlag = (*p >> 2) & 1;
339 0 : (data)->integFlag = (*p >> 1) & 1;
340 : } while(0);
341 0 : p += len; ret += len;
342 0 : len = Top_oldlen - Top_datalen;
343 : }
344 0 : if(size) *size = ret;
345 0 : return 0;
346 0 : fail:
347 0 : free_ContextFlags(data);
348 0 : return e;
349 : }
350 :
351 : void ASN1CALL
352 0 : free_ContextFlags(ContextFlags *data)
353 : {
354 0 : }
355 :
356 : size_t ASN1CALL
357 0 : length_ContextFlags(const ContextFlags *data)
358 : {
359 0 : size_t ret = 0;
360 : do {
361 0 : if((data)->integFlag) { ret += 1; break; }
362 0 : if((data)->confFlag) { ret += 1; break; }
363 0 : if((data)->anonFlag) { ret += 1; break; }
364 0 : if((data)->sequenceFlag) { ret += 1; break; }
365 0 : if((data)->replayFlag) { ret += 1; break; }
366 0 : if((data)->mutualFlag) { ret += 1; break; }
367 0 : if((data)->delegFlag) { ret += 1; break; }
368 : } while(0);
369 0 : ret += 1;
370 0 : ret += 1 + der_length_len (ret);
371 0 : return ret;
372 : }
373 :
374 : int ASN1CALL
375 0 : copy_ContextFlags(const ContextFlags *from, ContextFlags *to)
376 : {
377 0 : memset(to, 0, sizeof(*to));
378 0 : *(to) = *(from);
379 0 : return 0;
380 : }
381 :
382 0 : unsigned ContextFlags2int(ContextFlags f)
383 : {
384 0 : unsigned r = 0;
385 0 : if(f.delegFlag) r |= (1U << 0);
386 0 : if(f.mutualFlag) r |= (1U << 1);
387 0 : if(f.replayFlag) r |= (1U << 2);
388 0 : if(f.sequenceFlag) r |= (1U << 3);
389 0 : if(f.anonFlag) r |= (1U << 4);
390 0 : if(f.confFlag) r |= (1U << 5);
391 0 : if(f.integFlag) r |= (1U << 6);
392 0 : return r;
393 : }
394 :
395 0 : ContextFlags int2ContextFlags(unsigned n)
396 : {
397 : ContextFlags flags;
398 :
399 0 : memset(&flags, 0, sizeof(flags));
400 :
401 0 : flags.delegFlag = (n >> 0) & 1;
402 0 : flags.mutualFlag = (n >> 1) & 1;
403 0 : flags.replayFlag = (n >> 2) & 1;
404 0 : flags.sequenceFlag = (n >> 3) & 1;
405 0 : flags.anonFlag = (n >> 4) & 1;
406 0 : flags.confFlag = (n >> 5) & 1;
407 0 : flags.integFlag = (n >> 6) & 1;
408 0 : return flags;
409 : }
410 :
411 : static struct units ContextFlags_units[] = {
412 : {"integFlag", 1U << 6},
413 : {"confFlag", 1U << 5},
414 : {"anonFlag", 1U << 4},
415 : {"sequenceFlag", 1U << 3},
416 : {"replayFlag", 1U << 2},
417 : {"mutualFlag", 1U << 1},
418 : {"delegFlag", 1U << 0},
419 : {NULL, 0}
420 : };
421 :
422 0 : const struct units * asn1_ContextFlags_units(void){
423 0 : return ContextFlags_units;
424 : }
425 :
426 : int ASN1CALL
427 0 : encode_NegHints(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const NegHints *data, size_t *size)
428 : {
429 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
430 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
431 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
432 :
433 : /* hintAddress */
434 0 : if((data)->hintAddress) {
435 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
436 0 : ret = 0;
437 0 : e = der_put_octet_string(p, len, (data)->hintAddress, &l);
438 0 : if (e) return e;
439 0 : p -= l; len -= l; ret += l;
440 :
441 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
442 0 : if (e) return e;
443 0 : p -= l; len -= l; ret += l;
444 :
445 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
446 0 : if (e) return e;
447 0 : p -= l; len -= l; ret += l;
448 :
449 0 : ret += Top_tag_oldret;
450 : }
451 : /* hintName */
452 0 : if((data)->hintName) {
453 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
454 0 : ret = 0;
455 0 : e = der_put_general_string(p, len, (data)->hintName, &l);
456 0 : if (e) return e;
457 0 : p -= l; len -= l; ret += l;
458 :
459 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_GeneralString, &l);
460 0 : if (e) return e;
461 0 : p -= l; len -= l; ret += l;
462 :
463 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
464 0 : if (e) return e;
465 0 : p -= l; len -= l; ret += l;
466 :
467 0 : ret += Top_tag_oldret;
468 : }
469 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
470 0 : if (e) return e;
471 0 : p -= l; len -= l; ret += l;
472 :
473 0 : *size = ret;
474 0 : return 0;
475 : }
476 :
477 : int ASN1CALL
478 0 : decode_NegHints(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, NegHints *data, size_t *size)
479 : {
480 0 : size_t ret = 0;
481 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
482 : int e HEIMDAL_UNUSED_ATTRIBUTE;
483 :
484 0 : memset(data, 0, sizeof(*data));
485 : {
486 : size_t Top_datalen, Top_oldlen;
487 : Der_type Top_type;
488 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
489 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
490 0 : if(e) goto fail;
491 0 : p += l; len -= l; ret += l;
492 0 : Top_oldlen = len;
493 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
494 0 : len = Top_datalen;
495 : {
496 : size_t hintName_datalen, hintName_oldlen;
497 : Der_type hintName_type;
498 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &hintName_type, 0, &hintName_datalen, &l);
499 0 : if (e == 0 && hintName_type != CONS) { e = ASN1_BAD_ID; }
500 0 : if(e) {
501 0 : (data)->hintName = NULL;
502 : } else {
503 0 : (data)->hintName = calloc(1, sizeof(*(data)->hintName));
504 0 : if ((data)->hintName == NULL) { e = ENOMEM; goto fail; }
505 0 : p += l; len -= l; ret += l;
506 0 : hintName_oldlen = len;
507 0 : if (hintName_datalen > len) { e = ASN1_OVERRUN; goto fail; }
508 0 : len = hintName_datalen;
509 : {
510 : size_t hintName_Tag_datalen, hintName_Tag_oldlen;
511 : Der_type hintName_Tag_type;
512 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &hintName_Tag_type, UT_GeneralString, &hintName_Tag_datalen, &l);
513 0 : if (e == 0 && hintName_Tag_type != PRIM) { e = ASN1_BAD_ID; }
514 0 : if(e) goto fail;
515 0 : p += l; len -= l; ret += l;
516 0 : hintName_Tag_oldlen = len;
517 0 : if (hintName_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
518 0 : len = hintName_Tag_datalen;
519 0 : e = der_get_general_string(p, len, (data)->hintName, &l);
520 0 : if(e) goto fail;
521 0 : p += l; len -= l; ret += l;
522 0 : len = hintName_Tag_oldlen - hintName_Tag_datalen;
523 : }
524 0 : len = hintName_oldlen - hintName_datalen;
525 : }
526 : }
527 : {
528 : size_t hintAddress_datalen, hintAddress_oldlen;
529 : Der_type hintAddress_type;
530 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &hintAddress_type, 1, &hintAddress_datalen, &l);
531 0 : if (e == 0 && hintAddress_type != CONS) { e = ASN1_BAD_ID; }
532 0 : if(e) {
533 0 : (data)->hintAddress = NULL;
534 : } else {
535 0 : (data)->hintAddress = calloc(1, sizeof(*(data)->hintAddress));
536 0 : if ((data)->hintAddress == NULL) { e = ENOMEM; goto fail; }
537 0 : p += l; len -= l; ret += l;
538 0 : hintAddress_oldlen = len;
539 0 : if (hintAddress_datalen > len) { e = ASN1_OVERRUN; goto fail; }
540 0 : len = hintAddress_datalen;
541 : {
542 : size_t hintAddress_Tag_datalen, hintAddress_Tag_oldlen;
543 : Der_type hintAddress_Tag_type;
544 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &hintAddress_Tag_type, UT_OctetString, &hintAddress_Tag_datalen, &l);
545 0 : if (e == 0 && hintAddress_Tag_type != PRIM) { e = ASN1_BAD_ID; }
546 0 : if(e) goto fail;
547 0 : p += l; len -= l; ret += l;
548 0 : hintAddress_Tag_oldlen = len;
549 0 : if (hintAddress_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
550 0 : len = hintAddress_Tag_datalen;
551 0 : e = der_get_octet_string(p, len, (data)->hintAddress, &l);
552 0 : if(e) goto fail;
553 0 : p += l; len -= l; ret += l;
554 0 : len = hintAddress_Tag_oldlen - hintAddress_Tag_datalen;
555 : }
556 0 : len = hintAddress_oldlen - hintAddress_datalen;
557 : }
558 : }
559 0 : len = Top_oldlen - Top_datalen;
560 : }
561 0 : if(size) *size = ret;
562 0 : return 0;
563 0 : fail:
564 0 : free_NegHints(data);
565 0 : return e;
566 : }
567 :
568 : void ASN1CALL
569 0 : free_NegHints(NegHints *data)
570 : {
571 0 : if((data)->hintName) {
572 0 : der_free_general_string((data)->hintName);
573 0 : free((data)->hintName);
574 0 : (data)->hintName = NULL;
575 : }
576 0 : if((data)->hintAddress) {
577 0 : der_free_octet_string((data)->hintAddress);
578 0 : free((data)->hintAddress);
579 0 : (data)->hintAddress = NULL;
580 : }
581 0 : }
582 :
583 : size_t ASN1CALL
584 0 : length_NegHints(const NegHints *data)
585 : {
586 0 : size_t ret = 0;
587 0 : if((data)->hintName){
588 0 : size_t Top_tag_oldret = ret;
589 0 : ret = 0;
590 0 : ret += der_length_general_string((data)->hintName);
591 0 : ret += 1 + der_length_len (ret);
592 0 : ret += 1 + der_length_len (ret);
593 0 : ret += Top_tag_oldret;
594 : }
595 0 : if((data)->hintAddress){
596 0 : size_t Top_tag_oldret = ret;
597 0 : ret = 0;
598 0 : ret += der_length_octet_string((data)->hintAddress);
599 0 : ret += 1 + der_length_len (ret);
600 0 : ret += 1 + der_length_len (ret);
601 0 : ret += Top_tag_oldret;
602 : }
603 0 : ret += 1 + der_length_len (ret);
604 0 : return ret;
605 : }
606 :
607 : int ASN1CALL
608 0 : copy_NegHints(const NegHints *from, NegHints *to)
609 : {
610 0 : memset(to, 0, sizeof(*to));
611 0 : if((from)->hintName) {
612 0 : (to)->hintName = malloc(sizeof(*(to)->hintName));
613 0 : if((to)->hintName == NULL) goto fail;
614 0 : if(der_copy_general_string((from)->hintName, (to)->hintName)) goto fail;
615 : }else
616 0 : (to)->hintName = NULL;
617 0 : if((from)->hintAddress) {
618 0 : (to)->hintAddress = malloc(sizeof(*(to)->hintAddress));
619 0 : if((to)->hintAddress == NULL) goto fail;
620 0 : if(der_copy_octet_string((from)->hintAddress, (to)->hintAddress)) goto fail;
621 : }else
622 0 : (to)->hintAddress = NULL;
623 0 : return 0;
624 0 : fail:
625 0 : free_NegHints(to);
626 0 : return ENOMEM;
627 : }
628 :
629 : int ASN1CALL
630 0 : encode_NegTokenInitWin(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const NegTokenInitWin *data, size_t *size)
631 : {
632 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
633 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
634 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
635 :
636 : /* negHints */
637 0 : if((data)->negHints) {
638 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
639 0 : ret = 0;
640 0 : e = encode_NegHints(p, len, (data)->negHints, &l);
641 0 : if (e) return e;
642 0 : p -= l; len -= l; ret += l;
643 :
644 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
645 0 : if (e) return e;
646 0 : p -= l; len -= l; ret += l;
647 :
648 0 : ret += Top_tag_oldret;
649 : }
650 : /* mechToken */
651 0 : if((data)->mechToken) {
652 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
653 0 : ret = 0;
654 0 : e = der_put_octet_string(p, len, (data)->mechToken, &l);
655 0 : if (e) return e;
656 0 : p -= l; len -= l; ret += l;
657 :
658 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
659 0 : if (e) return e;
660 0 : p -= l; len -= l; ret += l;
661 :
662 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
663 0 : if (e) return e;
664 0 : p -= l; len -= l; ret += l;
665 :
666 0 : ret += Top_tag_oldret;
667 : }
668 : /* reqFlags */
669 0 : if((data)->reqFlags) {
670 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
671 0 : ret = 0;
672 0 : e = encode_ContextFlags(p, len, (data)->reqFlags, &l);
673 0 : if (e) return e;
674 0 : p -= l; len -= l; ret += l;
675 :
676 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
677 0 : if (e) return e;
678 0 : p -= l; len -= l; ret += l;
679 :
680 0 : ret += Top_tag_oldret;
681 : }
682 : /* mechTypes */
683 : {
684 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
685 0 : ret = 0;
686 0 : e = encode_MechTypeList(p, len, &(data)->mechTypes, &l);
687 0 : if (e) return e;
688 0 : p -= l; len -= l; ret += l;
689 :
690 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
691 0 : if (e) return e;
692 0 : p -= l; len -= l; ret += l;
693 :
694 0 : ret += Top_tag_oldret;
695 : }
696 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
697 0 : if (e) return e;
698 0 : p -= l; len -= l; ret += l;
699 :
700 0 : *size = ret;
701 0 : return 0;
702 : }
703 :
704 : int ASN1CALL
705 0 : decode_NegTokenInitWin(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, NegTokenInitWin *data, size_t *size)
706 : {
707 0 : size_t ret = 0;
708 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
709 : int e HEIMDAL_UNUSED_ATTRIBUTE;
710 :
711 0 : memset(data, 0, sizeof(*data));
712 : {
713 : size_t Top_datalen, Top_oldlen;
714 : Der_type Top_type;
715 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
716 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
717 0 : if(e) goto fail;
718 0 : p += l; len -= l; ret += l;
719 0 : Top_oldlen = len;
720 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
721 0 : len = Top_datalen;
722 : {
723 : size_t mechTypes_datalen, mechTypes_oldlen;
724 : Der_type mechTypes_type;
725 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &mechTypes_type, 0, &mechTypes_datalen, &l);
726 0 : if (e == 0 && mechTypes_type != CONS) { e = ASN1_BAD_ID; }
727 0 : if(e) goto fail;
728 0 : p += l; len -= l; ret += l;
729 0 : mechTypes_oldlen = len;
730 0 : if (mechTypes_datalen > len) { e = ASN1_OVERRUN; goto fail; }
731 0 : len = mechTypes_datalen;
732 0 : e = decode_MechTypeList(p, len, &(data)->mechTypes, &l);
733 0 : if(e) goto fail;
734 0 : p += l; len -= l; ret += l;
735 0 : len = mechTypes_oldlen - mechTypes_datalen;
736 : }
737 : {
738 : size_t reqFlags_datalen, reqFlags_oldlen;
739 : Der_type reqFlags_type;
740 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &reqFlags_type, 1, &reqFlags_datalen, &l);
741 0 : if (e == 0 && reqFlags_type != CONS) { e = ASN1_BAD_ID; }
742 0 : if(e) {
743 0 : (data)->reqFlags = NULL;
744 : } else {
745 0 : (data)->reqFlags = calloc(1, sizeof(*(data)->reqFlags));
746 0 : if ((data)->reqFlags == NULL) { e = ENOMEM; goto fail; }
747 0 : p += l; len -= l; ret += l;
748 0 : reqFlags_oldlen = len;
749 0 : if (reqFlags_datalen > len) { e = ASN1_OVERRUN; goto fail; }
750 0 : len = reqFlags_datalen;
751 0 : e = decode_ContextFlags(p, len, (data)->reqFlags, &l);
752 0 : if(e) goto fail;
753 0 : p += l; len -= l; ret += l;
754 0 : len = reqFlags_oldlen - reqFlags_datalen;
755 : }
756 : }
757 : {
758 : size_t mechToken_datalen, mechToken_oldlen;
759 : Der_type mechToken_type;
760 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &mechToken_type, 2, &mechToken_datalen, &l);
761 0 : if (e == 0 && mechToken_type != CONS) { e = ASN1_BAD_ID; }
762 0 : if(e) {
763 0 : (data)->mechToken = NULL;
764 : } else {
765 0 : (data)->mechToken = calloc(1, sizeof(*(data)->mechToken));
766 0 : if ((data)->mechToken == NULL) { e = ENOMEM; goto fail; }
767 0 : p += l; len -= l; ret += l;
768 0 : mechToken_oldlen = len;
769 0 : if (mechToken_datalen > len) { e = ASN1_OVERRUN; goto fail; }
770 0 : len = mechToken_datalen;
771 : {
772 : size_t mechToken_Tag_datalen, mechToken_Tag_oldlen;
773 : Der_type mechToken_Tag_type;
774 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &mechToken_Tag_type, UT_OctetString, &mechToken_Tag_datalen, &l);
775 0 : if (e == 0 && mechToken_Tag_type != PRIM) { e = ASN1_BAD_ID; }
776 0 : if(e) goto fail;
777 0 : p += l; len -= l; ret += l;
778 0 : mechToken_Tag_oldlen = len;
779 0 : if (mechToken_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
780 0 : len = mechToken_Tag_datalen;
781 0 : e = der_get_octet_string(p, len, (data)->mechToken, &l);
782 0 : if(e) goto fail;
783 0 : p += l; len -= l; ret += l;
784 0 : len = mechToken_Tag_oldlen - mechToken_Tag_datalen;
785 : }
786 0 : len = mechToken_oldlen - mechToken_datalen;
787 : }
788 : }
789 : {
790 : size_t negHints_datalen, negHints_oldlen;
791 : Der_type negHints_type;
792 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &negHints_type, 3, &negHints_datalen, &l);
793 0 : if (e == 0 && negHints_type != CONS) { e = ASN1_BAD_ID; }
794 0 : if(e) {
795 0 : (data)->negHints = NULL;
796 : } else {
797 0 : (data)->negHints = calloc(1, sizeof(*(data)->negHints));
798 0 : if ((data)->negHints == NULL) { e = ENOMEM; goto fail; }
799 0 : p += l; len -= l; ret += l;
800 0 : negHints_oldlen = len;
801 0 : if (negHints_datalen > len) { e = ASN1_OVERRUN; goto fail; }
802 0 : len = negHints_datalen;
803 0 : e = decode_NegHints(p, len, (data)->negHints, &l);
804 0 : if(e) goto fail;
805 0 : p += l; len -= l; ret += l;
806 0 : len = negHints_oldlen - negHints_datalen;
807 : }
808 : }
809 0 : len = Top_oldlen - Top_datalen;
810 : }
811 0 : if(size) *size = ret;
812 0 : return 0;
813 0 : fail:
814 0 : free_NegTokenInitWin(data);
815 0 : return e;
816 : }
817 :
818 : void ASN1CALL
819 0 : free_NegTokenInitWin(NegTokenInitWin *data)
820 : {
821 0 : free_MechTypeList(&(data)->mechTypes);
822 0 : if((data)->reqFlags) {
823 0 : free_ContextFlags((data)->reqFlags);
824 0 : free((data)->reqFlags);
825 0 : (data)->reqFlags = NULL;
826 : }
827 0 : if((data)->mechToken) {
828 0 : der_free_octet_string((data)->mechToken);
829 0 : free((data)->mechToken);
830 0 : (data)->mechToken = NULL;
831 : }
832 0 : if((data)->negHints) {
833 0 : free_NegHints((data)->negHints);
834 0 : free((data)->negHints);
835 0 : (data)->negHints = NULL;
836 : }
837 0 : }
838 :
839 : size_t ASN1CALL
840 0 : length_NegTokenInitWin(const NegTokenInitWin *data)
841 : {
842 0 : size_t ret = 0;
843 : {
844 0 : size_t Top_tag_oldret = ret;
845 0 : ret = 0;
846 0 : ret += length_MechTypeList(&(data)->mechTypes);
847 0 : ret += 1 + der_length_len (ret);
848 0 : ret += Top_tag_oldret;
849 : }
850 0 : if((data)->reqFlags){
851 0 : size_t Top_tag_oldret = ret;
852 0 : ret = 0;
853 0 : ret += length_ContextFlags((data)->reqFlags);
854 0 : ret += 1 + der_length_len (ret);
855 0 : ret += Top_tag_oldret;
856 : }
857 0 : if((data)->mechToken){
858 0 : size_t Top_tag_oldret = ret;
859 0 : ret = 0;
860 0 : ret += der_length_octet_string((data)->mechToken);
861 0 : ret += 1 + der_length_len (ret);
862 0 : ret += 1 + der_length_len (ret);
863 0 : ret += Top_tag_oldret;
864 : }
865 0 : if((data)->negHints){
866 0 : size_t Top_tag_oldret = ret;
867 0 : ret = 0;
868 0 : ret += length_NegHints((data)->negHints);
869 0 : ret += 1 + der_length_len (ret);
870 0 : ret += Top_tag_oldret;
871 : }
872 0 : ret += 1 + der_length_len (ret);
873 0 : return ret;
874 : }
875 :
876 : int ASN1CALL
877 0 : copy_NegTokenInitWin(const NegTokenInitWin *from, NegTokenInitWin *to)
878 : {
879 0 : memset(to, 0, sizeof(*to));
880 0 : if(copy_MechTypeList(&(from)->mechTypes, &(to)->mechTypes)) goto fail;
881 0 : if((from)->reqFlags) {
882 0 : (to)->reqFlags = malloc(sizeof(*(to)->reqFlags));
883 0 : if((to)->reqFlags == NULL) goto fail;
884 0 : if(copy_ContextFlags((from)->reqFlags, (to)->reqFlags)) goto fail;
885 : }else
886 0 : (to)->reqFlags = NULL;
887 0 : if((from)->mechToken) {
888 0 : (to)->mechToken = malloc(sizeof(*(to)->mechToken));
889 0 : if((to)->mechToken == NULL) goto fail;
890 0 : if(der_copy_octet_string((from)->mechToken, (to)->mechToken)) goto fail;
891 : }else
892 0 : (to)->mechToken = NULL;
893 0 : if((from)->negHints) {
894 0 : (to)->negHints = malloc(sizeof(*(to)->negHints));
895 0 : if((to)->negHints == NULL) goto fail;
896 0 : if(copy_NegHints((from)->negHints, (to)->negHints)) goto fail;
897 : }else
898 0 : (to)->negHints = NULL;
899 0 : return 0;
900 0 : fail:
901 0 : free_NegTokenInitWin(to);
902 0 : return ENOMEM;
903 : }
904 :
905 : int ASN1CALL
906 0 : encode_NegTokenInit(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const NegTokenInit *data, size_t *size)
907 : {
908 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
909 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
910 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
911 :
912 : /* mechListMIC */
913 0 : if((data)->mechListMIC) {
914 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
915 0 : ret = 0;
916 0 : e = der_put_octet_string(p, len, (data)->mechListMIC, &l);
917 0 : if (e) return e;
918 0 : p -= l; len -= l; ret += l;
919 :
920 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
921 0 : if (e) return e;
922 0 : p -= l; len -= l; ret += l;
923 :
924 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
925 0 : if (e) return e;
926 0 : p -= l; len -= l; ret += l;
927 :
928 0 : ret += Top_tag_oldret;
929 : }
930 : /* mechToken */
931 0 : if((data)->mechToken) {
932 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
933 0 : ret = 0;
934 0 : e = der_put_octet_string(p, len, (data)->mechToken, &l);
935 0 : if (e) return e;
936 0 : p -= l; len -= l; ret += l;
937 :
938 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
939 0 : if (e) return e;
940 0 : p -= l; len -= l; ret += l;
941 :
942 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
943 0 : if (e) return e;
944 0 : p -= l; len -= l; ret += l;
945 :
946 0 : ret += Top_tag_oldret;
947 : }
948 : /* reqFlags */
949 0 : if((data)->reqFlags) {
950 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
951 0 : ret = 0;
952 0 : e = encode_ContextFlags(p, len, (data)->reqFlags, &l);
953 0 : if (e) return e;
954 0 : p -= l; len -= l; ret += l;
955 :
956 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
957 0 : if (e) return e;
958 0 : p -= l; len -= l; ret += l;
959 :
960 0 : ret += Top_tag_oldret;
961 : }
962 : /* mechTypes */
963 : {
964 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
965 0 : ret = 0;
966 0 : e = encode_MechTypeList(p, len, &(data)->mechTypes, &l);
967 0 : if (e) return e;
968 0 : p -= l; len -= l; ret += l;
969 :
970 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
971 0 : if (e) return e;
972 0 : p -= l; len -= l; ret += l;
973 :
974 0 : ret += Top_tag_oldret;
975 : }
976 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
977 0 : if (e) return e;
978 0 : p -= l; len -= l; ret += l;
979 :
980 0 : *size = ret;
981 0 : return 0;
982 : }
983 :
984 : int ASN1CALL
985 0 : decode_NegTokenInit(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, NegTokenInit *data, size_t *size)
986 : {
987 0 : size_t ret = 0;
988 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
989 : int e HEIMDAL_UNUSED_ATTRIBUTE;
990 :
991 0 : memset(data, 0, sizeof(*data));
992 : {
993 : size_t Top_datalen, Top_oldlen;
994 : Der_type Top_type;
995 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
996 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
997 0 : if(e) goto fail;
998 0 : p += l; len -= l; ret += l;
999 0 : Top_oldlen = len;
1000 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1001 0 : len = Top_datalen;
1002 : {
1003 : size_t mechTypes_datalen, mechTypes_oldlen;
1004 : Der_type mechTypes_type;
1005 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &mechTypes_type, 0, &mechTypes_datalen, &l);
1006 0 : if (e == 0 && mechTypes_type != CONS) { e = ASN1_BAD_ID; }
1007 0 : if(e) goto fail;
1008 0 : p += l; len -= l; ret += l;
1009 0 : mechTypes_oldlen = len;
1010 0 : if (mechTypes_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1011 0 : len = mechTypes_datalen;
1012 0 : e = decode_MechTypeList(p, len, &(data)->mechTypes, &l);
1013 0 : if(e) goto fail;
1014 0 : p += l; len -= l; ret += l;
1015 0 : len = mechTypes_oldlen - mechTypes_datalen;
1016 : }
1017 : {
1018 : size_t reqFlags_datalen, reqFlags_oldlen;
1019 : Der_type reqFlags_type;
1020 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &reqFlags_type, 1, &reqFlags_datalen, &l);
1021 0 : if (e == 0 && reqFlags_type != CONS) { e = ASN1_BAD_ID; }
1022 0 : if(e) {
1023 0 : (data)->reqFlags = NULL;
1024 : } else {
1025 0 : (data)->reqFlags = calloc(1, sizeof(*(data)->reqFlags));
1026 0 : if ((data)->reqFlags == NULL) { e = ENOMEM; goto fail; }
1027 0 : p += l; len -= l; ret += l;
1028 0 : reqFlags_oldlen = len;
1029 0 : if (reqFlags_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1030 0 : len = reqFlags_datalen;
1031 0 : e = decode_ContextFlags(p, len, (data)->reqFlags, &l);
1032 0 : if(e) goto fail;
1033 0 : p += l; len -= l; ret += l;
1034 0 : len = reqFlags_oldlen - reqFlags_datalen;
1035 : }
1036 : }
1037 : {
1038 : size_t mechToken_datalen, mechToken_oldlen;
1039 : Der_type mechToken_type;
1040 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &mechToken_type, 2, &mechToken_datalen, &l);
1041 0 : if (e == 0 && mechToken_type != CONS) { e = ASN1_BAD_ID; }
1042 0 : if(e) {
1043 0 : (data)->mechToken = NULL;
1044 : } else {
1045 0 : (data)->mechToken = calloc(1, sizeof(*(data)->mechToken));
1046 0 : if ((data)->mechToken == NULL) { e = ENOMEM; goto fail; }
1047 0 : p += l; len -= l; ret += l;
1048 0 : mechToken_oldlen = len;
1049 0 : if (mechToken_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1050 0 : len = mechToken_datalen;
1051 : {
1052 : size_t mechToken_Tag_datalen, mechToken_Tag_oldlen;
1053 : Der_type mechToken_Tag_type;
1054 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &mechToken_Tag_type, UT_OctetString, &mechToken_Tag_datalen, &l);
1055 0 : if (e == 0 && mechToken_Tag_type != PRIM) { e = ASN1_BAD_ID; }
1056 0 : if(e) goto fail;
1057 0 : p += l; len -= l; ret += l;
1058 0 : mechToken_Tag_oldlen = len;
1059 0 : if (mechToken_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1060 0 : len = mechToken_Tag_datalen;
1061 0 : e = der_get_octet_string(p, len, (data)->mechToken, &l);
1062 0 : if(e) goto fail;
1063 0 : p += l; len -= l; ret += l;
1064 0 : len = mechToken_Tag_oldlen - mechToken_Tag_datalen;
1065 : }
1066 0 : len = mechToken_oldlen - mechToken_datalen;
1067 : }
1068 : }
1069 : {
1070 : size_t mechListMIC_datalen, mechListMIC_oldlen;
1071 : Der_type mechListMIC_type;
1072 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &mechListMIC_type, 3, &mechListMIC_datalen, &l);
1073 0 : if (e == 0 && mechListMIC_type != CONS) { e = ASN1_BAD_ID; }
1074 0 : if(e) {
1075 0 : (data)->mechListMIC = NULL;
1076 : } else {
1077 0 : (data)->mechListMIC = calloc(1, sizeof(*(data)->mechListMIC));
1078 0 : if ((data)->mechListMIC == NULL) { e = ENOMEM; goto fail; }
1079 0 : p += l; len -= l; ret += l;
1080 0 : mechListMIC_oldlen = len;
1081 0 : if (mechListMIC_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1082 0 : len = mechListMIC_datalen;
1083 : {
1084 : size_t mechListMIC_Tag_datalen, mechListMIC_Tag_oldlen;
1085 : Der_type mechListMIC_Tag_type;
1086 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &mechListMIC_Tag_type, UT_OctetString, &mechListMIC_Tag_datalen, &l);
1087 0 : if (e == 0 && mechListMIC_Tag_type != PRIM) { e = ASN1_BAD_ID; }
1088 0 : if(e) goto fail;
1089 0 : p += l; len -= l; ret += l;
1090 0 : mechListMIC_Tag_oldlen = len;
1091 0 : if (mechListMIC_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1092 0 : len = mechListMIC_Tag_datalen;
1093 0 : e = der_get_octet_string(p, len, (data)->mechListMIC, &l);
1094 0 : if(e) goto fail;
1095 0 : p += l; len -= l; ret += l;
1096 0 : len = mechListMIC_Tag_oldlen - mechListMIC_Tag_datalen;
1097 : }
1098 0 : len = mechListMIC_oldlen - mechListMIC_datalen;
1099 : }
1100 : }
1101 0 : len = Top_oldlen - Top_datalen;
1102 : }
1103 0 : if(size) *size = ret;
1104 0 : return 0;
1105 0 : fail:
1106 0 : free_NegTokenInit(data);
1107 0 : return e;
1108 : }
1109 :
1110 : void ASN1CALL
1111 0 : free_NegTokenInit(NegTokenInit *data)
1112 : {
1113 0 : free_MechTypeList(&(data)->mechTypes);
1114 0 : if((data)->reqFlags) {
1115 0 : free_ContextFlags((data)->reqFlags);
1116 0 : free((data)->reqFlags);
1117 0 : (data)->reqFlags = NULL;
1118 : }
1119 0 : if((data)->mechToken) {
1120 0 : der_free_octet_string((data)->mechToken);
1121 0 : free((data)->mechToken);
1122 0 : (data)->mechToken = NULL;
1123 : }
1124 0 : if((data)->mechListMIC) {
1125 0 : der_free_octet_string((data)->mechListMIC);
1126 0 : free((data)->mechListMIC);
1127 0 : (data)->mechListMIC = NULL;
1128 : }
1129 0 : }
1130 :
1131 : size_t ASN1CALL
1132 0 : length_NegTokenInit(const NegTokenInit *data)
1133 : {
1134 0 : size_t ret = 0;
1135 : {
1136 0 : size_t Top_tag_oldret = ret;
1137 0 : ret = 0;
1138 0 : ret += length_MechTypeList(&(data)->mechTypes);
1139 0 : ret += 1 + der_length_len (ret);
1140 0 : ret += Top_tag_oldret;
1141 : }
1142 0 : if((data)->reqFlags){
1143 0 : size_t Top_tag_oldret = ret;
1144 0 : ret = 0;
1145 0 : ret += length_ContextFlags((data)->reqFlags);
1146 0 : ret += 1 + der_length_len (ret);
1147 0 : ret += Top_tag_oldret;
1148 : }
1149 0 : if((data)->mechToken){
1150 0 : size_t Top_tag_oldret = ret;
1151 0 : ret = 0;
1152 0 : ret += der_length_octet_string((data)->mechToken);
1153 0 : ret += 1 + der_length_len (ret);
1154 0 : ret += 1 + der_length_len (ret);
1155 0 : ret += Top_tag_oldret;
1156 : }
1157 0 : if((data)->mechListMIC){
1158 0 : size_t Top_tag_oldret = ret;
1159 0 : ret = 0;
1160 0 : ret += der_length_octet_string((data)->mechListMIC);
1161 0 : ret += 1 + der_length_len (ret);
1162 0 : ret += 1 + der_length_len (ret);
1163 0 : ret += Top_tag_oldret;
1164 : }
1165 0 : ret += 1 + der_length_len (ret);
1166 0 : return ret;
1167 : }
1168 :
1169 : int ASN1CALL
1170 0 : copy_NegTokenInit(const NegTokenInit *from, NegTokenInit *to)
1171 : {
1172 0 : memset(to, 0, sizeof(*to));
1173 0 : if(copy_MechTypeList(&(from)->mechTypes, &(to)->mechTypes)) goto fail;
1174 0 : if((from)->reqFlags) {
1175 0 : (to)->reqFlags = malloc(sizeof(*(to)->reqFlags));
1176 0 : if((to)->reqFlags == NULL) goto fail;
1177 0 : if(copy_ContextFlags((from)->reqFlags, (to)->reqFlags)) goto fail;
1178 : }else
1179 0 : (to)->reqFlags = NULL;
1180 0 : if((from)->mechToken) {
1181 0 : (to)->mechToken = malloc(sizeof(*(to)->mechToken));
1182 0 : if((to)->mechToken == NULL) goto fail;
1183 0 : if(der_copy_octet_string((from)->mechToken, (to)->mechToken)) goto fail;
1184 : }else
1185 0 : (to)->mechToken = NULL;
1186 0 : if((from)->mechListMIC) {
1187 0 : (to)->mechListMIC = malloc(sizeof(*(to)->mechListMIC));
1188 0 : if((to)->mechListMIC == NULL) goto fail;
1189 0 : if(der_copy_octet_string((from)->mechListMIC, (to)->mechListMIC)) goto fail;
1190 : }else
1191 0 : (to)->mechListMIC = NULL;
1192 0 : return 0;
1193 0 : fail:
1194 0 : free_NegTokenInit(to);
1195 0 : return ENOMEM;
1196 : }
1197 :
1198 : int ASN1CALL
1199 0 : encode_NegTokenResp(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const NegTokenResp *data, size_t *size)
1200 : {
1201 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
1202 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1203 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
1204 :
1205 : /* mechListMIC */
1206 0 : if((data)->mechListMIC) {
1207 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
1208 0 : ret = 0;
1209 0 : e = der_put_octet_string(p, len, (data)->mechListMIC, &l);
1210 0 : if (e) return e;
1211 0 : p -= l; len -= l; ret += l;
1212 :
1213 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
1214 0 : if (e) return e;
1215 0 : p -= l; len -= l; ret += l;
1216 :
1217 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
1218 0 : if (e) return e;
1219 0 : p -= l; len -= l; ret += l;
1220 :
1221 0 : ret += Top_tag_oldret;
1222 : }
1223 : /* responseToken */
1224 0 : if((data)->responseToken) {
1225 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
1226 0 : ret = 0;
1227 0 : e = der_put_octet_string(p, len, (data)->responseToken, &l);
1228 0 : if (e) return e;
1229 0 : p -= l; len -= l; ret += l;
1230 :
1231 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
1232 0 : if (e) return e;
1233 0 : p -= l; len -= l; ret += l;
1234 :
1235 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
1236 0 : if (e) return e;
1237 0 : p -= l; len -= l; ret += l;
1238 :
1239 0 : ret += Top_tag_oldret;
1240 : }
1241 : /* supportedMech */
1242 0 : if((data)->supportedMech) {
1243 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
1244 0 : ret = 0;
1245 0 : e = encode_MechType(p, len, (data)->supportedMech, &l);
1246 0 : if (e) return e;
1247 0 : p -= l; len -= l; ret += l;
1248 :
1249 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
1250 0 : if (e) return e;
1251 0 : p -= l; len -= l; ret += l;
1252 :
1253 0 : ret += Top_tag_oldret;
1254 : }
1255 : /* negResult */
1256 0 : if((data)->negResult) {
1257 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
1258 0 : ret = 0;
1259 : {
1260 0 : int enumint = (int)*(data)->negResult;
1261 0 : e = der_put_integer(p, len, &enumint, &l);
1262 0 : if (e) return e;
1263 0 : p -= l; len -= l; ret += l;
1264 :
1265 : }
1266 0 : ;e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Enumerated, &l);
1267 0 : if (e) return e;
1268 0 : p -= l; len -= l; ret += l;
1269 :
1270 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
1271 0 : if (e) return e;
1272 0 : p -= l; len -= l; ret += l;
1273 :
1274 0 : ret += Top_tag_oldret;
1275 : }
1276 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
1277 0 : if (e) return e;
1278 0 : p -= l; len -= l; ret += l;
1279 :
1280 0 : *size = ret;
1281 0 : return 0;
1282 : }
1283 :
1284 : int ASN1CALL
1285 0 : decode_NegTokenResp(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, NegTokenResp *data, size_t *size)
1286 : {
1287 0 : size_t ret = 0;
1288 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1289 : int e HEIMDAL_UNUSED_ATTRIBUTE;
1290 :
1291 0 : memset(data, 0, sizeof(*data));
1292 : {
1293 : size_t Top_datalen, Top_oldlen;
1294 : Der_type Top_type;
1295 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
1296 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
1297 0 : if(e) goto fail;
1298 0 : p += l; len -= l; ret += l;
1299 0 : Top_oldlen = len;
1300 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1301 0 : len = Top_datalen;
1302 : {
1303 : size_t negResult_datalen, negResult_oldlen;
1304 : Der_type negResult_type;
1305 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &negResult_type, 0, &negResult_datalen, &l);
1306 0 : if (e == 0 && negResult_type != CONS) { e = ASN1_BAD_ID; }
1307 0 : if(e) {
1308 0 : (data)->negResult = NULL;
1309 : } else {
1310 0 : (data)->negResult = calloc(1, sizeof(*(data)->negResult));
1311 0 : if ((data)->negResult == NULL) { e = ENOMEM; goto fail; }
1312 0 : p += l; len -= l; ret += l;
1313 0 : negResult_oldlen = len;
1314 0 : if (negResult_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1315 0 : len = negResult_datalen;
1316 : {
1317 : size_t negResult_Tag_datalen, negResult_Tag_oldlen;
1318 : Der_type negResult_Tag_type;
1319 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &negResult_Tag_type, UT_Enumerated, &negResult_Tag_datalen, &l);
1320 0 : if (e == 0 && negResult_Tag_type != PRIM) { e = ASN1_BAD_ID; }
1321 0 : if(e) goto fail;
1322 0 : p += l; len -= l; ret += l;
1323 0 : negResult_Tag_oldlen = len;
1324 0 : if (negResult_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1325 0 : len = negResult_Tag_datalen;
1326 : {
1327 : int enumint;
1328 0 : e = der_get_integer(p, len, &enumint, &l);
1329 0 : if(e) goto fail;
1330 0 : p += l; len -= l; ret += l;
1331 0 : *(data)->negResult = enumint;
1332 : }
1333 0 : len = negResult_Tag_oldlen - negResult_Tag_datalen;
1334 : }
1335 0 : len = negResult_oldlen - negResult_datalen;
1336 : }
1337 : }
1338 : {
1339 : size_t supportedMech_datalen, supportedMech_oldlen;
1340 : Der_type supportedMech_type;
1341 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &supportedMech_type, 1, &supportedMech_datalen, &l);
1342 0 : if (e == 0 && supportedMech_type != CONS) { e = ASN1_BAD_ID; }
1343 0 : if(e) {
1344 0 : (data)->supportedMech = NULL;
1345 : } else {
1346 0 : (data)->supportedMech = calloc(1, sizeof(*(data)->supportedMech));
1347 0 : if ((data)->supportedMech == NULL) { e = ENOMEM; goto fail; }
1348 0 : p += l; len -= l; ret += l;
1349 0 : supportedMech_oldlen = len;
1350 0 : if (supportedMech_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1351 0 : len = supportedMech_datalen;
1352 0 : e = decode_MechType(p, len, (data)->supportedMech, &l);
1353 0 : if(e) goto fail;
1354 0 : p += l; len -= l; ret += l;
1355 0 : len = supportedMech_oldlen - supportedMech_datalen;
1356 : }
1357 : }
1358 : {
1359 : size_t responseToken_datalen, responseToken_oldlen;
1360 : Der_type responseToken_type;
1361 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &responseToken_type, 2, &responseToken_datalen, &l);
1362 0 : if (e == 0 && responseToken_type != CONS) { e = ASN1_BAD_ID; }
1363 0 : if(e) {
1364 0 : (data)->responseToken = NULL;
1365 : } else {
1366 0 : (data)->responseToken = calloc(1, sizeof(*(data)->responseToken));
1367 0 : if ((data)->responseToken == NULL) { e = ENOMEM; goto fail; }
1368 0 : p += l; len -= l; ret += l;
1369 0 : responseToken_oldlen = len;
1370 0 : if (responseToken_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1371 0 : len = responseToken_datalen;
1372 : {
1373 : size_t responseToken_Tag_datalen, responseToken_Tag_oldlen;
1374 : Der_type responseToken_Tag_type;
1375 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &responseToken_Tag_type, UT_OctetString, &responseToken_Tag_datalen, &l);
1376 0 : if (e == 0 && responseToken_Tag_type != PRIM) { e = ASN1_BAD_ID; }
1377 0 : if(e) goto fail;
1378 0 : p += l; len -= l; ret += l;
1379 0 : responseToken_Tag_oldlen = len;
1380 0 : if (responseToken_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1381 0 : len = responseToken_Tag_datalen;
1382 0 : e = der_get_octet_string(p, len, (data)->responseToken, &l);
1383 0 : if(e) goto fail;
1384 0 : p += l; len -= l; ret += l;
1385 0 : len = responseToken_Tag_oldlen - responseToken_Tag_datalen;
1386 : }
1387 0 : len = responseToken_oldlen - responseToken_datalen;
1388 : }
1389 : }
1390 : {
1391 : size_t mechListMIC_datalen, mechListMIC_oldlen;
1392 : Der_type mechListMIC_type;
1393 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &mechListMIC_type, 3, &mechListMIC_datalen, &l);
1394 0 : if (e == 0 && mechListMIC_type != CONS) { e = ASN1_BAD_ID; }
1395 0 : if(e) {
1396 0 : (data)->mechListMIC = NULL;
1397 : } else {
1398 0 : (data)->mechListMIC = calloc(1, sizeof(*(data)->mechListMIC));
1399 0 : if ((data)->mechListMIC == NULL) { e = ENOMEM; goto fail; }
1400 0 : p += l; len -= l; ret += l;
1401 0 : mechListMIC_oldlen = len;
1402 0 : if (mechListMIC_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1403 0 : len = mechListMIC_datalen;
1404 : {
1405 : size_t mechListMIC_Tag_datalen, mechListMIC_Tag_oldlen;
1406 : Der_type mechListMIC_Tag_type;
1407 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &mechListMIC_Tag_type, UT_OctetString, &mechListMIC_Tag_datalen, &l);
1408 0 : if (e == 0 && mechListMIC_Tag_type != PRIM) { e = ASN1_BAD_ID; }
1409 0 : if(e) goto fail;
1410 0 : p += l; len -= l; ret += l;
1411 0 : mechListMIC_Tag_oldlen = len;
1412 0 : if (mechListMIC_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1413 0 : len = mechListMIC_Tag_datalen;
1414 0 : e = der_get_octet_string(p, len, (data)->mechListMIC, &l);
1415 0 : if(e) goto fail;
1416 0 : p += l; len -= l; ret += l;
1417 0 : len = mechListMIC_Tag_oldlen - mechListMIC_Tag_datalen;
1418 : }
1419 0 : len = mechListMIC_oldlen - mechListMIC_datalen;
1420 : }
1421 : }
1422 0 : len = Top_oldlen - Top_datalen;
1423 : }
1424 0 : if(size) *size = ret;
1425 0 : return 0;
1426 0 : fail:
1427 0 : free_NegTokenResp(data);
1428 0 : return e;
1429 : }
1430 :
1431 : void ASN1CALL
1432 0 : free_NegTokenResp(NegTokenResp *data)
1433 : {
1434 0 : if((data)->negResult) {
1435 0 : free((data)->negResult);
1436 0 : (data)->negResult = NULL;
1437 : }
1438 0 : if((data)->supportedMech) {
1439 0 : free_MechType((data)->supportedMech);
1440 0 : free((data)->supportedMech);
1441 0 : (data)->supportedMech = NULL;
1442 : }
1443 0 : if((data)->responseToken) {
1444 0 : der_free_octet_string((data)->responseToken);
1445 0 : free((data)->responseToken);
1446 0 : (data)->responseToken = NULL;
1447 : }
1448 0 : if((data)->mechListMIC) {
1449 0 : der_free_octet_string((data)->mechListMIC);
1450 0 : free((data)->mechListMIC);
1451 0 : (data)->mechListMIC = NULL;
1452 : }
1453 0 : }
1454 :
1455 : size_t ASN1CALL
1456 0 : length_NegTokenResp(const NegTokenResp *data)
1457 : {
1458 0 : size_t ret = 0;
1459 0 : if((data)->negResult){
1460 0 : size_t Top_tag_oldret = ret;
1461 0 : ret = 0;
1462 : {
1463 0 : int enumint = *(data)->negResult;
1464 0 : ret += der_length_integer(&enumint);
1465 : }
1466 0 : ret += 1 + der_length_len (ret);
1467 0 : ret += 1 + der_length_len (ret);
1468 0 : ret += Top_tag_oldret;
1469 : }
1470 0 : if((data)->supportedMech){
1471 0 : size_t Top_tag_oldret = ret;
1472 0 : ret = 0;
1473 0 : ret += length_MechType((data)->supportedMech);
1474 0 : ret += 1 + der_length_len (ret);
1475 0 : ret += Top_tag_oldret;
1476 : }
1477 0 : if((data)->responseToken){
1478 0 : size_t Top_tag_oldret = ret;
1479 0 : ret = 0;
1480 0 : ret += der_length_octet_string((data)->responseToken);
1481 0 : ret += 1 + der_length_len (ret);
1482 0 : ret += 1 + der_length_len (ret);
1483 0 : ret += Top_tag_oldret;
1484 : }
1485 0 : if((data)->mechListMIC){
1486 0 : size_t Top_tag_oldret = ret;
1487 0 : ret = 0;
1488 0 : ret += der_length_octet_string((data)->mechListMIC);
1489 0 : ret += 1 + der_length_len (ret);
1490 0 : ret += 1 + der_length_len (ret);
1491 0 : ret += Top_tag_oldret;
1492 : }
1493 0 : ret += 1 + der_length_len (ret);
1494 0 : return ret;
1495 : }
1496 :
1497 : int ASN1CALL
1498 0 : copy_NegTokenResp(const NegTokenResp *from, NegTokenResp *to)
1499 : {
1500 0 : memset(to, 0, sizeof(*to));
1501 0 : if((from)->negResult) {
1502 0 : (to)->negResult = malloc(sizeof(*(to)->negResult));
1503 0 : if((to)->negResult == NULL) goto fail;
1504 0 : *((to)->negResult) = *((from)->negResult);
1505 : }else
1506 0 : (to)->negResult = NULL;
1507 0 : if((from)->supportedMech) {
1508 0 : (to)->supportedMech = malloc(sizeof(*(to)->supportedMech));
1509 0 : if((to)->supportedMech == NULL) goto fail;
1510 0 : if(copy_MechType((from)->supportedMech, (to)->supportedMech)) goto fail;
1511 : }else
1512 0 : (to)->supportedMech = NULL;
1513 0 : if((from)->responseToken) {
1514 0 : (to)->responseToken = malloc(sizeof(*(to)->responseToken));
1515 0 : if((to)->responseToken == NULL) goto fail;
1516 0 : if(der_copy_octet_string((from)->responseToken, (to)->responseToken)) goto fail;
1517 : }else
1518 0 : (to)->responseToken = NULL;
1519 0 : if((from)->mechListMIC) {
1520 0 : (to)->mechListMIC = malloc(sizeof(*(to)->mechListMIC));
1521 0 : if((to)->mechListMIC == NULL) goto fail;
1522 0 : if(der_copy_octet_string((from)->mechListMIC, (to)->mechListMIC)) goto fail;
1523 : }else
1524 0 : (to)->mechListMIC = NULL;
1525 0 : return 0;
1526 0 : fail:
1527 0 : free_NegTokenResp(to);
1528 0 : return ENOMEM;
1529 : }
1530 :
1531 : int ASN1CALL
1532 0 : encode_NegotiationToken(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const NegotiationToken *data, size_t *size)
1533 : {
1534 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
1535 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1536 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
1537 :
1538 :
1539 0 : switch((data)->element) {
1540 0 : case choice_NegotiationToken_negTokenResp: {size_t Top_oldret = ret;
1541 0 : ret = 0;
1542 0 : e = encode_NegTokenResp(p, len, &((data))->u.negTokenResp, &l);
1543 0 : if (e) return e;
1544 0 : p -= l; len -= l; ret += l;
1545 :
1546 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
1547 0 : if (e) return e;
1548 0 : p -= l; len -= l; ret += l;
1549 :
1550 0 : ret += Top_oldret;
1551 0 : break;
1552 : }
1553 0 : case choice_NegotiationToken_negTokenInit: {size_t Top_oldret = ret;
1554 0 : ret = 0;
1555 0 : e = encode_NegTokenInit(p, len, &((data))->u.negTokenInit, &l);
1556 0 : if (e) return e;
1557 0 : p -= l; len -= l; ret += l;
1558 :
1559 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
1560 0 : if (e) return e;
1561 0 : p -= l; len -= l; ret += l;
1562 :
1563 0 : ret += Top_oldret;
1564 0 : break;
1565 : }
1566 : };
1567 0 : *size = ret;
1568 0 : return 0;
1569 : }
1570 :
1571 : int ASN1CALL
1572 0 : decode_NegotiationToken(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, NegotiationToken *data, size_t *size)
1573 : {
1574 0 : size_t ret = 0;
1575 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1576 : int e HEIMDAL_UNUSED_ATTRIBUTE;
1577 :
1578 0 : memset(data, 0, sizeof(*data));
1579 0 : if (der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 0, NULL) == 0) {
1580 : {
1581 : size_t negTokenInit_datalen, negTokenInit_oldlen;
1582 : Der_type negTokenInit_type;
1583 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &negTokenInit_type, 0, &negTokenInit_datalen, &l);
1584 0 : if (e == 0 && negTokenInit_type != CONS) { e = ASN1_BAD_ID; }
1585 0 : if(e) goto fail;
1586 0 : p += l; len -= l; ret += l;
1587 0 : negTokenInit_oldlen = len;
1588 0 : if (negTokenInit_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1589 0 : len = negTokenInit_datalen;
1590 0 : e = decode_NegTokenInit(p, len, &(data)->u.negTokenInit, &l);
1591 0 : if(e) goto fail;
1592 0 : p += l; len -= l; ret += l;
1593 0 : len = negTokenInit_oldlen - negTokenInit_datalen;
1594 : }
1595 0 : (data)->element = choice_NegotiationToken_negTokenInit;
1596 : }
1597 0 : else if (der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 1, NULL) == 0) {
1598 : {
1599 : size_t negTokenResp_datalen, negTokenResp_oldlen;
1600 : Der_type negTokenResp_type;
1601 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &negTokenResp_type, 1, &negTokenResp_datalen, &l);
1602 0 : if (e == 0 && negTokenResp_type != CONS) { e = ASN1_BAD_ID; }
1603 0 : if(e) goto fail;
1604 0 : p += l; len -= l; ret += l;
1605 0 : negTokenResp_oldlen = len;
1606 0 : if (negTokenResp_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1607 0 : len = negTokenResp_datalen;
1608 0 : e = decode_NegTokenResp(p, len, &(data)->u.negTokenResp, &l);
1609 0 : if(e) goto fail;
1610 0 : p += l; len -= l; ret += l;
1611 0 : len = negTokenResp_oldlen - negTokenResp_datalen;
1612 : }
1613 0 : (data)->element = choice_NegotiationToken_negTokenResp;
1614 : }
1615 : else {
1616 0 : e = ASN1_PARSE_ERROR;
1617 0 : goto fail;
1618 : }
1619 0 : if(size) *size = ret;
1620 0 : return 0;
1621 0 : fail:
1622 0 : free_NegotiationToken(data);
1623 0 : return e;
1624 : }
1625 :
1626 : void ASN1CALL
1627 0 : free_NegotiationToken(NegotiationToken *data)
1628 : {
1629 0 : switch((data)->element) {
1630 0 : case choice_NegotiationToken_negTokenInit:
1631 0 : free_NegTokenInit(&(data)->u.negTokenInit);
1632 0 : break;
1633 0 : case choice_NegotiationToken_negTokenResp:
1634 0 : free_NegTokenResp(&(data)->u.negTokenResp);
1635 0 : break;
1636 : }
1637 0 : }
1638 :
1639 : size_t ASN1CALL
1640 0 : length_NegotiationToken(const NegotiationToken *data)
1641 : {
1642 0 : size_t ret = 0;
1643 0 : switch((data)->element) {
1644 0 : case choice_NegotiationToken_negTokenInit:
1645 : {
1646 0 : size_t Top_oldret = ret;
1647 0 : ret = 0;
1648 0 : ret += length_NegTokenInit(&(data)->u.negTokenInit);
1649 0 : ret += 1 + der_length_len (ret);
1650 0 : ret += Top_oldret;
1651 : }
1652 0 : break;
1653 0 : case choice_NegotiationToken_negTokenResp:
1654 : {
1655 0 : size_t Top_oldret = ret;
1656 0 : ret = 0;
1657 0 : ret += length_NegTokenResp(&(data)->u.negTokenResp);
1658 0 : ret += 1 + der_length_len (ret);
1659 0 : ret += Top_oldret;
1660 : }
1661 0 : break;
1662 : }
1663 0 : return ret;
1664 : }
1665 :
1666 : int ASN1CALL
1667 0 : copy_NegotiationToken(const NegotiationToken *from, NegotiationToken *to)
1668 : {
1669 0 : memset(to, 0, sizeof(*to));
1670 0 : (to)->element = (from)->element;
1671 0 : switch((from)->element) {
1672 0 : case choice_NegotiationToken_negTokenInit:
1673 0 : if(copy_NegTokenInit(&(from)->u.negTokenInit, &(to)->u.negTokenInit)) goto fail;
1674 0 : break;
1675 0 : case choice_NegotiationToken_negTokenResp:
1676 0 : if(copy_NegTokenResp(&(from)->u.negTokenResp, &(to)->u.negTokenResp)) goto fail;
1677 0 : break;
1678 : }
1679 0 : return 0;
1680 0 : fail:
1681 0 : free_NegotiationToken(to);
1682 0 : return ENOMEM;
1683 : }
1684 :
1685 : int ASN1CALL
1686 0 : encode_NegotiationTokenWin(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const NegotiationTokenWin *data, size_t *size)
1687 : {
1688 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
1689 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1690 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
1691 :
1692 :
1693 0 : switch((data)->element) {
1694 0 : case choice_NegotiationTokenWin_negTokenInit: {size_t Top_oldret = ret;
1695 0 : ret = 0;
1696 0 : e = encode_NegTokenInitWin(p, len, &((data))->u.negTokenInit, &l);
1697 0 : if (e) return e;
1698 0 : p -= l; len -= l; ret += l;
1699 :
1700 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
1701 0 : if (e) return e;
1702 0 : p -= l; len -= l; ret += l;
1703 :
1704 0 : ret += Top_oldret;
1705 0 : break;
1706 : }
1707 : };
1708 0 : *size = ret;
1709 0 : return 0;
1710 : }
1711 :
1712 : int ASN1CALL
1713 0 : decode_NegotiationTokenWin(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, NegotiationTokenWin *data, size_t *size)
1714 : {
1715 0 : size_t ret = 0;
1716 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1717 : int e HEIMDAL_UNUSED_ATTRIBUTE;
1718 :
1719 0 : memset(data, 0, sizeof(*data));
1720 0 : if (der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 0, NULL) == 0) {
1721 : {
1722 : size_t negTokenInit_datalen, negTokenInit_oldlen;
1723 : Der_type negTokenInit_type;
1724 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &negTokenInit_type, 0, &negTokenInit_datalen, &l);
1725 0 : if (e == 0 && negTokenInit_type != CONS) { e = ASN1_BAD_ID; }
1726 0 : if(e) goto fail;
1727 0 : p += l; len -= l; ret += l;
1728 0 : negTokenInit_oldlen = len;
1729 0 : if (negTokenInit_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1730 0 : len = negTokenInit_datalen;
1731 0 : e = decode_NegTokenInitWin(p, len, &(data)->u.negTokenInit, &l);
1732 0 : if(e) goto fail;
1733 0 : p += l; len -= l; ret += l;
1734 0 : len = negTokenInit_oldlen - negTokenInit_datalen;
1735 : }
1736 0 : (data)->element = choice_NegotiationTokenWin_negTokenInit;
1737 : }
1738 : else {
1739 0 : e = ASN1_PARSE_ERROR;
1740 0 : goto fail;
1741 : }
1742 0 : if(size) *size = ret;
1743 0 : return 0;
1744 0 : fail:
1745 0 : free_NegotiationTokenWin(data);
1746 0 : return e;
1747 : }
1748 :
1749 : void ASN1CALL
1750 0 : free_NegotiationTokenWin(NegotiationTokenWin *data)
1751 : {
1752 0 : switch((data)->element) {
1753 0 : case choice_NegotiationTokenWin_negTokenInit:
1754 0 : free_NegTokenInitWin(&(data)->u.negTokenInit);
1755 0 : break;
1756 : }
1757 0 : }
1758 :
1759 : size_t ASN1CALL
1760 0 : length_NegotiationTokenWin(const NegotiationTokenWin *data)
1761 : {
1762 0 : size_t ret = 0;
1763 0 : switch((data)->element) {
1764 0 : case choice_NegotiationTokenWin_negTokenInit:
1765 : {
1766 0 : size_t Top_oldret = ret;
1767 0 : ret = 0;
1768 0 : ret += length_NegTokenInitWin(&(data)->u.negTokenInit);
1769 0 : ret += 1 + der_length_len (ret);
1770 0 : ret += Top_oldret;
1771 : }
1772 0 : break;
1773 : }
1774 0 : return ret;
1775 : }
1776 :
1777 : int ASN1CALL
1778 0 : copy_NegotiationTokenWin(const NegotiationTokenWin *from, NegotiationTokenWin *to)
1779 : {
1780 0 : memset(to, 0, sizeof(*to));
1781 0 : (to)->element = (from)->element;
1782 0 : switch((from)->element) {
1783 0 : case choice_NegotiationTokenWin_negTokenInit:
1784 0 : if(copy_NegTokenInitWin(&(from)->u.negTokenInit, &(to)->u.negTokenInit)) goto fail;
1785 0 : break;
1786 : }
1787 0 : return 0;
1788 0 : fail:
1789 0 : free_NegotiationTokenWin(to);
1790 0 : return ENOMEM;
1791 : }
1792 :
|