1/* Generated from digest.asn1 */
2/* Do not edit */
3
4#define ASN1_LIB
5
6#include <stdio.h>
7#include <stdlib.h>
8#include <time.h>
9#include <string.h>
10#include <errno.h>
11#include <limits.h>
12#include <krb5/krb5-types.h>
13#include "digest_asn1.h"
14#include "digest_asn1-priv.h"
15#include <krb5/asn1_err.h>
16#include <krb5/der.h>
17#include <asn1-template.h>
18
19#include <krb5/parse_units.h>
20
21int ASN1CALL
22encode_DigestTypes(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const DigestTypes *data, size_t *size)
23{
24size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
25size_t l HEIMDAL_UNUSED_ATTRIBUTE;
26int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
27
28{
29unsigned char c = 0;
30int rest = 0;
31int bit_set = 0;
32if((data)->ms_chap_v2) {
33c |= 1<<2;
34}
35if((data)->chap_md5) {
36c |= 1<<3;
37}
38if((data)->digest_md5) {
39c |= 1<<4;
40}
41if((data)->ntlm_v2) {
42c |= 1<<5;
43}
44if((data)->ntlm_v1_session) {
45c |= 1<<6;
46}
47if((data)->ntlm_v1) {
48c |= 1<<7;
49}
50if (c != 0 || bit_set) {
51if (len < 1) return ASN1_OVERFLOW;
52*p-- = c; len--; ret++;
53if (!bit_set) {
54rest = 0;
55if(c) {
56while(c) {
57if (c & 1) break;
58c = c >> 1;
59rest++;
60}
61}
62}
63}
64if (len < 1) return ASN1_OVERFLOW;
65*p-- = rest;
66len -= 1;
67ret += 1;
68}
69
70e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_BitString, &l);
71if (e) return e;
72p -= l; len -= l; ret += l;
73
74*size = ret;
75return 0;
76}
77
78int ASN1CALL
79decode_DigestTypes(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, DigestTypes *data, size_t *size)
80{
81size_t ret = 0;
82size_t l HEIMDAL_UNUSED_ATTRIBUTE;
83int e HEIMDAL_UNUSED_ATTRIBUTE;
84
85memset(data, 0, sizeof(*data));
86{
87size_t Top_datalen, Top_oldlen;
88Der_type Top_type;
89e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_BitString, &Top_datalen, &l);
90if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
91if(e) goto fail;
92p += l; len -= l; ret += l;
93Top_oldlen = len;
94if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
95len = Top_datalen;
96if (len < 1) return ASN1_OVERRUN;
97p++; len--; ret++;
98do {
99if (len < 1) break;
100(data)->ntlm_v1 = (*p >> 7) & 1;
101(data)->ntlm_v1_session = (*p >> 6) & 1;
102(data)->ntlm_v2 = (*p >> 5) & 1;
103(data)->digest_md5 = (*p >> 4) & 1;
104(data)->chap_md5 = (*p >> 3) & 1;
105(data)->ms_chap_v2 = (*p >> 2) & 1;
106} while(0);
107p += len; ret += len;
108len = Top_oldlen - Top_datalen;
109}
110if(size) *size = ret;
111return 0;
112fail:
113free_DigestTypes(data);
114return e;
115}
116
117void ASN1CALL
118free_DigestTypes(DigestTypes *data)
119{
120}
121
122size_t ASN1CALL
123length_DigestTypes(const DigestTypes *data)
124{
125size_t ret = 0;
126do {
127if((data)->ms_chap_v2) { ret += 1; break; }
128if((data)->chap_md5) { ret += 1; break; }
129if((data)->digest_md5) { ret += 1; break; }
130if((data)->ntlm_v2) { ret += 1; break; }
131if((data)->ntlm_v1_session) { ret += 1; break; }
132if((data)->ntlm_v1) { ret += 1; break; }
133} while(0);
134ret += 1;
135ret += 1 + der_length_len (ret);
136return ret;
137}
138
139int ASN1CALL
140copy_DigestTypes(const DigestTypes *from, DigestTypes *to)
141{
142memset(to, 0, sizeof(*to));
143*(to) = *(from);
144return 0;
145}
146
147unsigned DigestTypes2int(DigestTypes f)
148{
149unsigned r = 0;
150if(f.ntlm_v1) r |= (1U << 0);
151if(f.ntlm_v1_session) r |= (1U << 1);
152if(f.ntlm_v2) r |= (1U << 2);
153if(f.digest_md5) r |= (1U << 3);
154if(f.chap_md5) r |= (1U << 4);
155if(f.ms_chap_v2) r |= (1U << 5);
156return r;
157}
158
159DigestTypes int2DigestTypes(unsigned n)
160{
161 DigestTypes flags;
162
163 memset(&flags, 0, sizeof(flags));
164
165 flags.ntlm_v1 = (n >> 0) & 1;
166 flags.ntlm_v1_session = (n >> 1) & 1;
167 flags.ntlm_v2 = (n >> 2) & 1;
168 flags.digest_md5 = (n >> 3) & 1;
169 flags.chap_md5 = (n >> 4) & 1;
170 flags.ms_chap_v2 = (n >> 5) & 1;
171 return flags;
172}
173
174static struct units DigestTypes_units[] = {
175 {"ms-chap-v2", 1U << 5},
176 {"chap-md5", 1U << 4},
177 {"digest-md5", 1U << 3},
178 {"ntlm-v2", 1U << 2},
179 {"ntlm-v1-session", 1U << 1},
180 {"ntlm-v1", 1U << 0},
181 {NULL, 0}
182};
183
184const struct units * asn1_DigestTypes_units(void){
185return DigestTypes_units;
186}
187
188int ASN1CALL
189encode_DigestInit(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const DigestInit *data, size_t *size)
190{
191size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
192size_t l HEIMDAL_UNUSED_ATTRIBUTE;
193int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
194
195/* hostname */
196if((data)->hostname) {
197size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
198ret = 0;
199e = der_put_utf8string(p, len, (data)->hostname, &l);
200if (e) return e;
201p -= l; len -= l; ret += l;
202
203e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_UTF8String, &l);
204if (e) return e;
205p -= l; len -= l; ret += l;
206
207e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
208if (e) return e;
209p -= l; len -= l; ret += l;
210
211ret += Top_tag_oldret;
212}
213/* channel */
214if((data)->channel) {
215size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
216ret = 0;
217/* cb-binding */
218{
219size_t channel_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
220ret = 0;
221e = der_put_utf8string(p, len, &((data)->channel)->cb_binding, &l);
222if (e) return e;
223p -= l; len -= l; ret += l;
224
225e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_UTF8String, &l);
226if (e) return e;
227p -= l; len -= l; ret += l;
228
229ret += channel_tag_tag_oldret;
230}
231/* cb-type */
232{
233size_t channel_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
234ret = 0;
235e = der_put_utf8string(p, len, &((data)->channel)->cb_type, &l);
236if (e) return e;
237p -= l; len -= l; ret += l;
238
239e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_UTF8String, &l);
240if (e) return e;
241p -= l; len -= l; ret += l;
242
243ret += channel_tag_tag_oldret;
244}
245e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
246if (e) return e;
247p -= l; len -= l; ret += l;
248
249e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
250if (e) return e;
251p -= l; len -= l; ret += l;
252
253ret += Top_tag_oldret;
254}
255/* type */
256{
257size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
258ret = 0;
259e = der_put_utf8string(p, len, &(data)->type, &l);
260if (e) return e;
261p -= l; len -= l; ret += l;
262
263e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_UTF8String, &l);
264if (e) return e;
265p -= l; len -= l; ret += l;
266
267ret += Top_tag_oldret;
268}
269e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
270if (e) return e;
271p -= l; len -= l; ret += l;
272
273*size = ret;
274return 0;
275}
276
277int ASN1CALL
278decode_DigestInit(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, DigestInit *data, size_t *size)
279{
280size_t ret = 0;
281size_t l HEIMDAL_UNUSED_ATTRIBUTE;
282int e HEIMDAL_UNUSED_ATTRIBUTE;
283
284memset(data, 0, sizeof(*data));
285{
286size_t Top_datalen, Top_oldlen;
287Der_type Top_type;
288e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
289if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
290if(e) goto fail;
291p += l; len -= l; ret += l;
292Top_oldlen = len;
293if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
294len = Top_datalen;
295{
296size_t type_datalen, type_oldlen;
297Der_type type_type;
298e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &type_type, UT_UTF8String, &type_datalen, &l);
299if (e == 0 && type_type != PRIM) { e = ASN1_BAD_ID; }
300if(e) goto fail;
301p += l; len -= l; ret += l;
302type_oldlen = len;
303if (type_datalen > len) { e = ASN1_OVERRUN; goto fail; }
304len = type_datalen;
305e = der_get_utf8string(p, len, &(data)->type, &l);
306if(e) goto fail;
307p += l; len -= l; ret += l;
308len = type_oldlen - type_datalen;
309}
310{
311size_t channel_datalen, channel_oldlen;
312Der_type channel_type;
313e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &channel_type, 0, &channel_datalen, &l);
314if (e == 0 && channel_type != CONS) { e = ASN1_BAD_ID; }
315if(e) {
316(data)->channel = NULL;
317} else {
318(data)->channel = calloc(1, sizeof(*(data)->channel));
319if ((data)->channel == NULL) { e = ENOMEM; goto fail; }
320p += l; len -= l; ret += l;
321channel_oldlen = len;
322if (channel_datalen > len) { e = ASN1_OVERRUN; goto fail; }
323len = channel_datalen;
324{
325size_t channel_Tag_datalen, channel_Tag_oldlen;
326Der_type channel_Tag_type;
327e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &channel_Tag_type, UT_Sequence, &channel_Tag_datalen, &l);
328if (e == 0 && channel_Tag_type != CONS) { e = ASN1_BAD_ID; }
329if(e) goto fail;
330p += l; len -= l; ret += l;
331channel_Tag_oldlen = len;
332if (channel_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
333len = channel_Tag_datalen;
334{
335size_t cb_type_datalen, cb_type_oldlen;
336Der_type cb_type_type;
337e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &cb_type_type, UT_UTF8String, &cb_type_datalen, &l);
338if (e == 0 && cb_type_type != PRIM) { e = ASN1_BAD_ID; }
339if(e) goto fail;
340p += l; len -= l; ret += l;
341cb_type_oldlen = len;
342if (cb_type_datalen > len) { e = ASN1_OVERRUN; goto fail; }
343len = cb_type_datalen;
344e = der_get_utf8string(p, len, &((data)->channel)->cb_type, &l);
345if(e) goto fail;
346p += l; len -= l; ret += l;
347len = cb_type_oldlen - cb_type_datalen;
348}
349{
350size_t cb_binding_datalen, cb_binding_oldlen;
351Der_type cb_binding_type;
352e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &cb_binding_type, UT_UTF8String, &cb_binding_datalen, &l);
353if (e == 0 && cb_binding_type != PRIM) { e = ASN1_BAD_ID; }
354if(e) goto fail;
355p += l; len -= l; ret += l;
356cb_binding_oldlen = len;
357if (cb_binding_datalen > len) { e = ASN1_OVERRUN; goto fail; }
358len = cb_binding_datalen;
359e = der_get_utf8string(p, len, &((data)->channel)->cb_binding, &l);
360if(e) goto fail;
361p += l; len -= l; ret += l;
362len = cb_binding_oldlen - cb_binding_datalen;
363}
364len = channel_Tag_oldlen - channel_Tag_datalen;
365}
366len = channel_oldlen - channel_datalen;
367}
368}
369{
370size_t hostname_datalen, hostname_oldlen;
371Der_type hostname_type;
372e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &hostname_type, 1, &hostname_datalen, &l);
373if (e == 0 && hostname_type != CONS) { e = ASN1_BAD_ID; }
374if(e) {
375(data)->hostname = NULL;
376} else {
377(data)->hostname = calloc(1, sizeof(*(data)->hostname));
378if ((data)->hostname == NULL) { e = ENOMEM; goto fail; }
379p += l; len -= l; ret += l;
380hostname_oldlen = len;
381if (hostname_datalen > len) { e = ASN1_OVERRUN; goto fail; }
382len = hostname_datalen;
383{
384size_t hostname_Tag_datalen, hostname_Tag_oldlen;
385Der_type hostname_Tag_type;
386e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &hostname_Tag_type, UT_UTF8String, &hostname_Tag_datalen, &l);
387if (e == 0 && hostname_Tag_type != PRIM) { e = ASN1_BAD_ID; }
388if(e) goto fail;
389p += l; len -= l; ret += l;
390hostname_Tag_oldlen = len;
391if (hostname_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
392len = hostname_Tag_datalen;
393e = der_get_utf8string(p, len, (data)->hostname, &l);
394if(e) goto fail;
395p += l; len -= l; ret += l;
396len = hostname_Tag_oldlen - hostname_Tag_datalen;
397}
398len = hostname_oldlen - hostname_datalen;
399}
400}
401len = Top_oldlen - Top_datalen;
402}
403if(size) *size = ret;
404return 0;
405fail:
406free_DigestInit(data);
407return e;
408}
409
410void ASN1CALL
411free_DigestInit(DigestInit *data)
412{
413der_free_utf8string(&(data)->type);
414if((data)->channel) {
415der_free_utf8string(&((data)->channel)->cb_type);
416der_free_utf8string(&((data)->channel)->cb_binding);
417free((data)->channel);
418(data)->channel = NULL;
419}
420if((data)->hostname) {
421der_free_utf8string((data)->hostname);
422free((data)->hostname);
423(data)->hostname = NULL;
424}
425}
426
427size_t ASN1CALL
428length_DigestInit(const DigestInit *data)
429{
430size_t ret = 0;
431{
432size_t Top_tag_oldret = ret;
433ret = 0;
434ret += der_length_utf8string(&(data)->type);
435ret += 1 + der_length_len (ret);
436ret += Top_tag_oldret;
437}
438if((data)->channel){
439size_t Top_tag_oldret = ret;
440ret = 0;
441{
442size_t channel_tag_tag_oldret = ret;
443ret = 0;
444ret += der_length_utf8string(&((data)->channel)->cb_type);
445ret += 1 + der_length_len (ret);
446ret += channel_tag_tag_oldret;
447}
448{
449size_t channel_tag_tag_oldret = ret;
450ret = 0;
451ret += der_length_utf8string(&((data)->channel)->cb_binding);
452ret += 1 + der_length_len (ret);
453ret += channel_tag_tag_oldret;
454}
455ret += 1 + der_length_len (ret);
456ret += 1 + der_length_len (ret);
457ret += Top_tag_oldret;
458}
459if((data)->hostname){
460size_t Top_tag_oldret = ret;
461ret = 0;
462ret += der_length_utf8string((data)->hostname);
463ret += 1 + der_length_len (ret);
464ret += 1 + der_length_len (ret);
465ret += Top_tag_oldret;
466}
467ret += 1 + der_length_len (ret);
468return ret;
469}
470
471int ASN1CALL
472copy_DigestInit(const DigestInit *from, DigestInit *to)
473{
474memset(to, 0, sizeof(*to));
475if(der_copy_utf8string(&(from)->type, &(to)->type)) goto fail;
476if((from)->channel) {
477(to)->channel = malloc(sizeof(*(to)->channel));
478if((to)->channel == NULL) goto fail;
479if(der_copy_utf8string(&((from)->channel)->cb_type, &((to)->channel)->cb_type)) goto fail;
480if(der_copy_utf8string(&((from)->channel)->cb_binding, &((to)->channel)->cb_binding)) goto fail;
481}else
482(to)->channel = NULL;
483if((from)->hostname) {
484(to)->hostname = malloc(sizeof(*(to)->hostname));
485if((to)->hostname == NULL) goto fail;
486if(der_copy_utf8string((from)->hostname, (to)->hostname)) goto fail;
487}else
488(to)->hostname = NULL;
489return 0;
490fail:
491free_DigestInit(to);
492return ENOMEM;
493}
494
495int ASN1CALL
496encode_DigestInitReply(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const DigestInitReply *data, size_t *size)
497{
498size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
499size_t l HEIMDAL_UNUSED_ATTRIBUTE;
500int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
501
502/* identifier */
503if((data)->identifier) {
504size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
505ret = 0;
506e = der_put_utf8string(p, len, (data)->identifier, &l);
507if (e) return e;
508p -= l; len -= l; ret += l;
509
510e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_UTF8String, &l);
511if (e) return e;
512p -= l; len -= l; ret += l;
513
514e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
515if (e) return e;
516p -= l; len -= l; ret += l;
517
518ret += Top_tag_oldret;
519}
520/* opaque */
521{
522size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
523ret = 0;
524e = der_put_utf8string(p, len, &(data)->opaque, &l);
525if (e) return e;
526p -= l; len -= l; ret += l;
527
528e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_UTF8String, &l);
529if (e) return e;
530p -= l; len -= l; ret += l;
531
532ret += Top_tag_oldret;
533}
534/* nonce */
535{
536size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
537ret = 0;
538e = der_put_utf8string(p, len, &(data)->nonce, &l);
539if (e) return e;
540p -= l; len -= l; ret += l;
541
542e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_UTF8String, &l);
543if (e) return e;
544p -= l; len -= l; ret += l;
545
546ret += Top_tag_oldret;
547}
548e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
549if (e) return e;
550p -= l; len -= l; ret += l;
551
552*size = ret;
553return 0;
554}
555
556int ASN1CALL
557decode_DigestInitReply(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, DigestInitReply *data, size_t *size)
558{
559size_t ret = 0;
560size_t l HEIMDAL_UNUSED_ATTRIBUTE;
561int e HEIMDAL_UNUSED_ATTRIBUTE;
562
563memset(data, 0, sizeof(*data));
564{
565size_t Top_datalen, Top_oldlen;
566Der_type Top_type;
567e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
568if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
569if(e) goto fail;
570p += l; len -= l; ret += l;
571Top_oldlen = len;
572if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
573len = Top_datalen;
574{
575size_t nonce_datalen, nonce_oldlen;
576Der_type nonce_type;
577e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &nonce_type, UT_UTF8String, &nonce_datalen, &l);
578if (e == 0 && nonce_type != PRIM) { e = ASN1_BAD_ID; }
579if(e) goto fail;
580p += l; len -= l; ret += l;
581nonce_oldlen = len;
582if (nonce_datalen > len) { e = ASN1_OVERRUN; goto fail; }
583len = nonce_datalen;
584e = der_get_utf8string(p, len, &(data)->nonce, &l);
585if(e) goto fail;
586p += l; len -= l; ret += l;
587len = nonce_oldlen - nonce_datalen;
588}
589{
590size_t opaque_datalen, opaque_oldlen;
591Der_type opaque_type;
592e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &opaque_type, UT_UTF8String, &opaque_datalen, &l);
593if (e == 0 && opaque_type != PRIM) { e = ASN1_BAD_ID; }
594if(e) goto fail;
595p += l; len -= l; ret += l;
596opaque_oldlen = len;
597if (opaque_datalen > len) { e = ASN1_OVERRUN; goto fail; }
598len = opaque_datalen;
599e = der_get_utf8string(p, len, &(data)->opaque, &l);
600if(e) goto fail;
601p += l; len -= l; ret += l;
602len = opaque_oldlen - opaque_datalen;
603}
604{
605size_t identifier_datalen, identifier_oldlen;
606Der_type identifier_type;
607e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &identifier_type, 0, &identifier_datalen, &l);
608if (e == 0 && identifier_type != CONS) { e = ASN1_BAD_ID; }
609if(e) {
610(data)->identifier = NULL;
611} else {
612(data)->identifier = calloc(1, sizeof(*(data)->identifier));
613if ((data)->identifier == NULL) { e = ENOMEM; goto fail; }
614p += l; len -= l; ret += l;
615identifier_oldlen = len;
616if (identifier_datalen > len) { e = ASN1_OVERRUN; goto fail; }
617len = identifier_datalen;
618{
619size_t identifier_Tag_datalen, identifier_Tag_oldlen;
620Der_type identifier_Tag_type;
621e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &identifier_Tag_type, UT_UTF8String, &identifier_Tag_datalen, &l);
622if (e == 0 && identifier_Tag_type != PRIM) { e = ASN1_BAD_ID; }
623if(e) goto fail;
624p += l; len -= l; ret += l;
625identifier_Tag_oldlen = len;
626if (identifier_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
627len = identifier_Tag_datalen;
628e = der_get_utf8string(p, len, (data)->identifier, &l);
629if(e) goto fail;
630p += l; len -= l; ret += l;
631len = identifier_Tag_oldlen - identifier_Tag_datalen;
632}
633len = identifier_oldlen - identifier_datalen;
634}
635}
636len = Top_oldlen - Top_datalen;
637}
638if(size) *size = ret;
639return 0;
640fail:
641free_DigestInitReply(data);
642return e;
643}
644
645void ASN1CALL
646free_DigestInitReply(DigestInitReply *data)
647{
648der_free_utf8string(&(data)->nonce);
649der_free_utf8string(&(data)->opaque);
650if((data)->identifier) {
651der_free_utf8string((data)->identifier);
652free((data)->identifier);
653(data)->identifier = NULL;
654}
655}
656
657size_t ASN1CALL
658length_DigestInitReply(const DigestInitReply *data)
659{
660size_t ret = 0;
661{
662size_t Top_tag_oldret = ret;
663ret = 0;
664ret += der_length_utf8string(&(data)->nonce);
665ret += 1 + der_length_len (ret);
666ret += Top_tag_oldret;
667}
668{
669size_t Top_tag_oldret = ret;
670ret = 0;
671ret += der_length_utf8string(&(data)->opaque);
672ret += 1 + der_length_len (ret);
673ret += Top_tag_oldret;
674}
675if((data)->identifier){
676size_t Top_tag_oldret = ret;
677ret = 0;
678ret += der_length_utf8string((data)->identifier);
679ret += 1 + der_length_len (ret);
680ret += 1 + der_length_len (ret);
681ret += Top_tag_oldret;
682}
683ret += 1 + der_length_len (ret);
684return ret;
685}
686
687int ASN1CALL
688copy_DigestInitReply(const DigestInitReply *from, DigestInitReply *to)
689{
690memset(to, 0, sizeof(*to));
691if(der_copy_utf8string(&(from)->nonce, &(to)->nonce)) goto fail;
692if(der_copy_utf8string(&(from)->opaque, &(to)->opaque)) goto fail;
693if((from)->identifier) {
694(to)->identifier = malloc(sizeof(*(to)->identifier));
695if((to)->identifier == NULL) goto fail;
696if(der_copy_utf8string((from)->identifier, (to)->identifier)) goto fail;
697}else
698(to)->identifier = NULL;
699return 0;
700fail:
701free_DigestInitReply(to);
702return ENOMEM;
703}
704
705int ASN1CALL
706encode_DigestRequest(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const DigestRequest *data, size_t *size)
707{
708size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
709size_t l HEIMDAL_UNUSED_ATTRIBUTE;
710int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
711
712/* opaque */
713{
714size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
715ret = 0;
716e = der_put_utf8string(p, len, &(data)->opaque, &l);
717if (e) return e;
718p -= l; len -= l; ret += l;
719
720e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_UTF8String, &l);
721if (e) return e;
722p -= l; len -= l; ret += l;
723
724ret += Top_tag_oldret;
725}
726/* hostname */
727if((data)->hostname) {
728size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
729ret = 0;
730e = der_put_utf8string(p, len, (data)->hostname, &l);
731if (e) return e;
732p -= l; len -= l; ret += l;
733
734e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_UTF8String, &l);
735if (e) return e;
736p -= l; len -= l; ret += l;
737
738e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 9, &l);
739if (e) return e;
740p -= l; len -= l; ret += l;
741
742ret += Top_tag_oldret;
743}
744/* identifier */
745if((data)->identifier) {
746size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
747ret = 0;
748e = der_put_utf8string(p, len, (data)->identifier, &l);
749if (e) return e;
750p -= l; len -= l; ret += l;
751
752e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_UTF8String, &l);
753if (e) return e;
754p -= l; len -= l; ret += l;
755
756e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 8, &l);
757if (e) return e;
758p -= l; len -= l; ret += l;
759
760ret += Top_tag_oldret;
761}
762/* qop */
763if((data)->qop) {
764size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
765ret = 0;
766e = der_put_utf8string(p, len, (data)->qop, &l);
767if (e) return e;
768p -= l; len -= l; ret += l;
769
770e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_UTF8String, &l);
771if (e) return e;
772p -= l; len -= l; ret += l;
773
774e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 7, &l);
775if (e) return e;
776p -= l; len -= l; ret += l;
777
778ret += Top_tag_oldret;
779}
780/* nonceCount */
781if((data)->nonceCount) {
782size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
783ret = 0;
784e = der_put_utf8string(p, len, (data)->nonceCount, &l);
785if (e) return e;
786p -= l; len -= l; ret += l;
787
788e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_UTF8String, &l);
789if (e) return e;
790p -= l; len -= l; ret += l;
791
792e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 6, &l);
793if (e) return e;
794p -= l; len -= l; ret += l;
795
796ret += Top_tag_oldret;
797}
798/* clientNonce */
799if((data)->clientNonce) {
800size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
801ret = 0;
802e = der_put_utf8string(p, len, (data)->clientNonce, &l);
803if (e) return e;
804p -= l; len -= l; ret += l;
805
806e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_UTF8String, &l);
807if (e) return e;
808p -= l; len -= l; ret += l;
809
810e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 5, &l);
811if (e) return e;
812p -= l; len -= l; ret += l;
813
814ret += Top_tag_oldret;
815}
816/* serverNonce */
817{
818size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
819ret = 0;
820e = der_put_utf8string(p, len, &(data)->serverNonce, &l);
821if (e) return e;
822p -= l; len -= l; ret += l;
823
824e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_UTF8String, &l);
825if (e) return e;
826p -= l; len -= l; ret += l;
827
828ret += Top_tag_oldret;
829}
830/* uri */
831if((data)->uri) {
832size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
833ret = 0;
834e = der_put_utf8string(p, len, (data)->uri, &l);
835if (e) return e;
836p -= l; len -= l; ret += l;
837
838e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_UTF8String, &l);
839if (e) return e;
840p -= l; len -= l; ret += l;
841
842e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 4, &l);
843if (e) return e;
844p -= l; len -= l; ret += l;
845
846ret += Top_tag_oldret;
847}
848/* method */
849if((data)->method) {
850size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
851ret = 0;
852e = der_put_utf8string(p, len, (data)->method, &l);
853if (e) return e;
854p -= l; len -= l; ret += l;
855
856e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_UTF8String, &l);
857if (e) return e;
858p -= l; len -= l; ret += l;
859
860e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
861if (e) return e;
862p -= l; len -= l; ret += l;
863
864ret += Top_tag_oldret;
865}
866/* realm */
867if((data)->realm) {
868size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
869ret = 0;
870e = der_put_utf8string(p, len, (data)->realm, &l);
871if (e) return e;
872p -= l; len -= l; ret += l;
873
874e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_UTF8String, &l);
875if (e) return e;
876p -= l; len -= l; ret += l;
877
878e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
879if (e) return e;
880p -= l; len -= l; ret += l;
881
882ret += Top_tag_oldret;
883}
884/* authentication-user */
885if((data)->authentication_user) {
886size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
887ret = 0;
888e = encode_Principal(p, len, (data)->authentication_user, &l);
889if (e) return e;
890p -= l; len -= l; ret += l;
891
892e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
893if (e) return e;
894p -= l; len -= l; ret += l;
895
896ret += Top_tag_oldret;
897}
898/* authid */
899if((data)->authid) {
900size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
901ret = 0;
902e = der_put_utf8string(p, len, (data)->authid, &l);
903if (e) return e;
904p -= l; len -= l; ret += l;
905
906e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_UTF8String, &l);
907if (e) return e;
908p -= l; len -= l; ret += l;
909
910e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
911if (e) return e;
912p -= l; len -= l; ret += l;
913
914ret += Top_tag_oldret;
915}
916/* responseData */
917{
918size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
919ret = 0;
920e = der_put_utf8string(p, len, &(data)->responseData, &l);
921if (e) return e;
922p -= l; len -= l; ret += l;
923
924e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_UTF8String, &l);
925if (e) return e;
926p -= l; len -= l; ret += l;
927
928ret += Top_tag_oldret;
929}
930/* username */
931{
932size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
933ret = 0;
934e = der_put_utf8string(p, len, &(data)->username, &l);
935if (e) return e;
936p -= l; len -= l; ret += l;
937
938e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_UTF8String, &l);
939if (e) return e;
940p -= l; len -= l; ret += l;
941
942ret += Top_tag_oldret;
943}
944/* digest */
945{
946size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
947ret = 0;
948e = der_put_utf8string(p, len, &(data)->digest, &l);
949if (e) return e;
950p -= l; len -= l; ret += l;
951
952e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_UTF8String, &l);
953if (e) return e;
954p -= l; len -= l; ret += l;
955
956ret += Top_tag_oldret;
957}
958/* type */
959{
960size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
961ret = 0;
962e = der_put_utf8string(p, len, &(data)->type, &l);
963if (e) return e;
964p -= l; len -= l; ret += l;
965
966e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_UTF8String, &l);
967if (e) return e;
968p -= l; len -= l; ret += l;
969
970ret += Top_tag_oldret;
971}
972e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
973if (e) return e;
974p -= l; len -= l; ret += l;
975
976*size = ret;
977return 0;
978}
979
980int ASN1CALL
981decode_DigestRequest(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, DigestRequest *data, size_t *size)
982{
983size_t ret = 0;
984size_t l HEIMDAL_UNUSED_ATTRIBUTE;
985int e HEIMDAL_UNUSED_ATTRIBUTE;
986
987memset(data, 0, sizeof(*data));
988{
989size_t Top_datalen, Top_oldlen;
990Der_type Top_type;
991e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
992if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
993if(e) goto fail;
994p += l; len -= l; ret += l;
995Top_oldlen = len;
996if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
997len = Top_datalen;
998{
999size_t type_datalen, type_oldlen;
1000Der_type type_type;
1001e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &type_type, UT_UTF8String, &type_datalen, &l);
1002if (e == 0 && type_type != PRIM) { e = ASN1_BAD_ID; }
1003if(e) goto fail;
1004p += l; len -= l; ret += l;
1005type_oldlen = len;
1006if (type_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1007len = type_datalen;
1008e = der_get_utf8string(p, len, &(data)->type, &l);
1009if(e) goto fail;
1010p += l; len -= l; ret += l;
1011len = type_oldlen - type_datalen;
1012}
1013{
1014size_t digest_datalen, digest_oldlen;
1015Der_type digest_type;
1016e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &digest_type, UT_UTF8String, &digest_datalen, &l);
1017if (e == 0 && digest_type != PRIM) { e = ASN1_BAD_ID; }
1018if(e) goto fail;
1019p += l; len -= l; ret += l;
1020digest_oldlen = len;
1021if (digest_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1022len = digest_datalen;
1023e = der_get_utf8string(p, len, &(data)->digest, &l);
1024if(e) goto fail;
1025p += l; len -= l; ret += l;
1026len = digest_oldlen - digest_datalen;
1027}
1028{
1029size_t username_datalen, username_oldlen;
1030Der_type username_type;
1031e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &username_type, UT_UTF8String, &username_datalen, &l);
1032if (e == 0 && username_type != PRIM) { e = ASN1_BAD_ID; }
1033if(e) goto fail;
1034p += l; len -= l; ret += l;
1035username_oldlen = len;
1036if (username_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1037len = username_datalen;
1038e = der_get_utf8string(p, len, &(data)->username, &l);
1039if(e) goto fail;
1040p += l; len -= l; ret += l;
1041len = username_oldlen - username_datalen;
1042}
1043{
1044size_t responseData_datalen, responseData_oldlen;
1045Der_type responseData_type;
1046e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &responseData_type, UT_UTF8String, &responseData_datalen, &l);
1047if (e == 0 && responseData_type != PRIM) { e = ASN1_BAD_ID; }
1048if(e) goto fail;
1049p += l; len -= l; ret += l;
1050responseData_oldlen = len;
1051if (responseData_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1052len = responseData_datalen;
1053e = der_get_utf8string(p, len, &(data)->responseData, &l);
1054if(e) goto fail;
1055p += l; len -= l; ret += l;
1056len = responseData_oldlen - responseData_datalen;
1057}
1058{
1059size_t authid_datalen, authid_oldlen;
1060Der_type authid_type;
1061e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &authid_type, 0, &authid_datalen, &l);
1062if (e == 0 && authid_type != CONS) { e = ASN1_BAD_ID; }
1063if(e) {
1064(data)->authid = NULL;
1065} else {
1066(data)->authid = calloc(1, sizeof(*(data)->authid));
1067if ((data)->authid == NULL) { e = ENOMEM; goto fail; }
1068p += l; len -= l; ret += l;
1069authid_oldlen = len;
1070if (authid_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1071len = authid_datalen;
1072{
1073size_t authid_Tag_datalen, authid_Tag_oldlen;
1074Der_type authid_Tag_type;
1075e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &authid_Tag_type, UT_UTF8String, &authid_Tag_datalen, &l);
1076if (e == 0 && authid_Tag_type != PRIM) { e = ASN1_BAD_ID; }
1077if(e) goto fail;
1078p += l; len -= l; ret += l;
1079authid_Tag_oldlen = len;
1080if (authid_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1081len = authid_Tag_datalen;
1082e = der_get_utf8string(p, len, (data)->authid, &l);
1083if(e) goto fail;
1084p += l; len -= l; ret += l;
1085len = authid_Tag_oldlen - authid_Tag_datalen;
1086}
1087len = authid_oldlen - authid_datalen;
1088}
1089}
1090{
1091size_t authentication_user_datalen, authentication_user_oldlen;
1092Der_type authentication_user_type;
1093e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &authentication_user_type, 1, &authentication_user_datalen, &l);
1094if (e == 0 && authentication_user_type != CONS) { e = ASN1_BAD_ID; }
1095if(e) {
1096(data)->authentication_user = NULL;
1097} else {
1098(data)->authentication_user = calloc(1, sizeof(*(data)->authentication_user));
1099if ((data)->authentication_user == NULL) { e = ENOMEM; goto fail; }
1100p += l; len -= l; ret += l;
1101authentication_user_oldlen = len;
1102if (authentication_user_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1103len = authentication_user_datalen;
1104e = decode_Principal(p, len, (data)->authentication_user, &l);
1105if(e) goto fail;
1106p += l; len -= l; ret += l;
1107len = authentication_user_oldlen - authentication_user_datalen;
1108}
1109}
1110{
1111size_t realm_datalen, realm_oldlen;
1112Der_type realm_type;
1113e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &realm_type, 2, &realm_datalen, &l);
1114if (e == 0 && realm_type != CONS) { e = ASN1_BAD_ID; }
1115if(e) {
1116(data)->realm = NULL;
1117} else {
1118(data)->realm = calloc(1, sizeof(*(data)->realm));
1119if ((data)->realm == NULL) { e = ENOMEM; goto fail; }
1120p += l; len -= l; ret += l;
1121realm_oldlen = len;
1122if (realm_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1123len = realm_datalen;
1124{
1125size_t realm_Tag_datalen, realm_Tag_oldlen;
1126Der_type realm_Tag_type;
1127e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &realm_Tag_type, UT_UTF8String, &realm_Tag_datalen, &l);
1128if (e == 0 && realm_Tag_type != PRIM) { e = ASN1_BAD_ID; }
1129if(e) goto fail;
1130p += l; len -= l; ret += l;
1131realm_Tag_oldlen = len;
1132if (realm_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1133len = realm_Tag_datalen;
1134e = der_get_utf8string(p, len, (data)->realm, &l);
1135if(e) goto fail;
1136p += l; len -= l; ret += l;
1137len = realm_Tag_oldlen - realm_Tag_datalen;
1138}
1139len = realm_oldlen - realm_datalen;
1140}
1141}
1142{
1143size_t method_datalen, method_oldlen;
1144Der_type method_type;
1145e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &method_type, 3, &method_datalen, &l);
1146if (e == 0 && method_type != CONS) { e = ASN1_BAD_ID; }
1147if(e) {
1148(data)->method = NULL;
1149} else {
1150(data)->method = calloc(1, sizeof(*(data)->method));
1151if ((data)->method == NULL) { e = ENOMEM; goto fail; }
1152p += l; len -= l; ret += l;
1153method_oldlen = len;
1154if (method_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1155len = method_datalen;
1156{
1157size_t method_Tag_datalen, method_Tag_oldlen;
1158Der_type method_Tag_type;
1159e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &method_Tag_type, UT_UTF8String, &method_Tag_datalen, &l);
1160if (e == 0 && method_Tag_type != PRIM) { e = ASN1_BAD_ID; }
1161if(e) goto fail;
1162p += l; len -= l; ret += l;
1163method_Tag_oldlen = len;
1164if (method_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1165len = method_Tag_datalen;
1166e = der_get_utf8string(p, len, (data)->method, &l);
1167if(e) goto fail;
1168p += l; len -= l; ret += l;
1169len = method_Tag_oldlen - method_Tag_datalen;
1170}
1171len = method_oldlen - method_datalen;
1172}
1173}
1174{
1175size_t uri_datalen, uri_oldlen;
1176Der_type uri_type;
1177e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &uri_type, 4, &uri_datalen, &l);
1178if (e == 0 && uri_type != CONS) { e = ASN1_BAD_ID; }
1179if(e) {
1180(data)->uri = NULL;
1181} else {
1182(data)->uri = calloc(1, sizeof(*(data)->uri));
1183if ((data)->uri == NULL) { e = ENOMEM; goto fail; }
1184p += l; len -= l; ret += l;
1185uri_oldlen = len;
1186if (uri_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1187len = uri_datalen;
1188{
1189size_t uri_Tag_datalen, uri_Tag_oldlen;
1190Der_type uri_Tag_type;
1191e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &uri_Tag_type, UT_UTF8String, &uri_Tag_datalen, &l);
1192if (e == 0 && uri_Tag_type != PRIM) { e = ASN1_BAD_ID; }
1193if(e) goto fail;
1194p += l; len -= l; ret += l;
1195uri_Tag_oldlen = len;
1196if (uri_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1197len = uri_Tag_datalen;
1198e = der_get_utf8string(p, len, (data)->uri, &l);
1199if(e) goto fail;
1200p += l; len -= l; ret += l;
1201len = uri_Tag_oldlen - uri_Tag_datalen;
1202}
1203len = uri_oldlen - uri_datalen;
1204}
1205}
1206{
1207size_t serverNonce_datalen, serverNonce_oldlen;
1208Der_type serverNonce_type;
1209e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &serverNonce_type, UT_UTF8String, &serverNonce_datalen, &l);
1210if (e == 0 && serverNonce_type != PRIM) { e = ASN1_BAD_ID; }
1211if(e) goto fail;
1212p += l; len -= l; ret += l;
1213serverNonce_oldlen = len;
1214if (serverNonce_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1215len = serverNonce_datalen;
1216e = der_get_utf8string(p, len, &(data)->serverNonce, &l);
1217if(e) goto fail;
1218p += l; len -= l; ret += l;
1219len = serverNonce_oldlen - serverNonce_datalen;
1220}
1221{
1222size_t clientNonce_datalen, clientNonce_oldlen;
1223Der_type clientNonce_type;
1224e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &clientNonce_type, 5, &clientNonce_datalen, &l);
1225if (e == 0 && clientNonce_type != CONS) { e = ASN1_BAD_ID; }
1226if(e) {
1227(data)->clientNonce = NULL;
1228} else {
1229(data)->clientNonce = calloc(1, sizeof(*(data)->clientNonce));
1230if ((data)->clientNonce == NULL) { e = ENOMEM; goto fail; }
1231p += l; len -= l; ret += l;
1232clientNonce_oldlen = len;
1233if (clientNonce_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1234len = clientNonce_datalen;
1235{
1236size_t clientNonce_Tag_datalen, clientNonce_Tag_oldlen;
1237Der_type clientNonce_Tag_type;
1238e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &clientNonce_Tag_type, UT_UTF8String, &clientNonce_Tag_datalen, &l);
1239if (e == 0 && clientNonce_Tag_type != PRIM) { e = ASN1_BAD_ID; }
1240if(e) goto fail;
1241p += l; len -= l; ret += l;
1242clientNonce_Tag_oldlen = len;
1243if (clientNonce_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1244len = clientNonce_Tag_datalen;
1245e = der_get_utf8string(p, len, (data)->clientNonce, &l);
1246if(e) goto fail;
1247p += l; len -= l; ret += l;
1248len = clientNonce_Tag_oldlen - clientNonce_Tag_datalen;
1249}
1250len = clientNonce_oldlen - clientNonce_datalen;
1251}
1252}
1253{
1254size_t nonceCount_datalen, nonceCount_oldlen;
1255Der_type nonceCount_type;
1256e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &nonceCount_type, 6, &nonceCount_datalen, &l);
1257if (e == 0 && nonceCount_type != CONS) { e = ASN1_BAD_ID; }
1258if(e) {
1259(data)->nonceCount = NULL;
1260} else {
1261(data)->nonceCount = calloc(1, sizeof(*(data)->nonceCount));
1262if ((data)->nonceCount == NULL) { e = ENOMEM; goto fail; }
1263p += l; len -= l; ret += l;
1264nonceCount_oldlen = len;
1265if (nonceCount_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1266len = nonceCount_datalen;
1267{
1268size_t nonceCount_Tag_datalen, nonceCount_Tag_oldlen;
1269Der_type nonceCount_Tag_type;
1270e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &nonceCount_Tag_type, UT_UTF8String, &nonceCount_Tag_datalen, &l);
1271if (e == 0 && nonceCount_Tag_type != PRIM) { e = ASN1_BAD_ID; }
1272if(e) goto fail;
1273p += l; len -= l; ret += l;
1274nonceCount_Tag_oldlen = len;
1275if (nonceCount_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1276len = nonceCount_Tag_datalen;
1277e = der_get_utf8string(p, len, (data)->nonceCount, &l);
1278if(e) goto fail;
1279p += l; len -= l; ret += l;
1280len = nonceCount_Tag_oldlen - nonceCount_Tag_datalen;
1281}
1282len = nonceCount_oldlen - nonceCount_datalen;
1283}
1284}
1285{
1286size_t qop_datalen, qop_oldlen;
1287Der_type qop_type;
1288e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &qop_type, 7, &qop_datalen, &l);
1289if (e == 0 && qop_type != CONS) { e = ASN1_BAD_ID; }
1290if(e) {
1291(data)->qop = NULL;
1292} else {
1293(data)->qop = calloc(1, sizeof(*(data)->qop));
1294if ((data)->qop == NULL) { e = ENOMEM; goto fail; }
1295p += l; len -= l; ret += l;
1296qop_oldlen = len;
1297if (qop_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1298len = qop_datalen;
1299{
1300size_t qop_Tag_datalen, qop_Tag_oldlen;
1301Der_type qop_Tag_type;
1302e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &qop_Tag_type, UT_UTF8String, &qop_Tag_datalen, &l);
1303if (e == 0 && qop_Tag_type != PRIM) { e = ASN1_BAD_ID; }
1304if(e) goto fail;
1305p += l; len -= l; ret += l;
1306qop_Tag_oldlen = len;
1307if (qop_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1308len = qop_Tag_datalen;
1309e = der_get_utf8string(p, len, (data)->qop, &l);
1310if(e) goto fail;
1311p += l; len -= l; ret += l;
1312len = qop_Tag_oldlen - qop_Tag_datalen;
1313}
1314len = qop_oldlen - qop_datalen;
1315}
1316}
1317{
1318size_t identifier_datalen, identifier_oldlen;
1319Der_type identifier_type;
1320e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &identifier_type, 8, &identifier_datalen, &l);
1321if (e == 0 && identifier_type != CONS) { e = ASN1_BAD_ID; }
1322if(e) {
1323(data)->identifier = NULL;
1324} else {
1325(data)->identifier = calloc(1, sizeof(*(data)->identifier));
1326if ((data)->identifier == NULL) { e = ENOMEM; goto fail; }
1327p += l; len -= l; ret += l;
1328identifier_oldlen = len;
1329if (identifier_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1330len = identifier_datalen;
1331{
1332size_t identifier_Tag_datalen, identifier_Tag_oldlen;
1333Der_type identifier_Tag_type;
1334e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &identifier_Tag_type, UT_UTF8String, &identifier_Tag_datalen, &l);
1335if (e == 0 && identifier_Tag_type != PRIM) { e = ASN1_BAD_ID; }
1336if(e) goto fail;
1337p += l; len -= l; ret += l;
1338identifier_Tag_oldlen = len;
1339if (identifier_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1340len = identifier_Tag_datalen;
1341e = der_get_utf8string(p, len, (data)->identifier, &l);
1342if(e) goto fail;
1343p += l; len -= l; ret += l;
1344len = identifier_Tag_oldlen - identifier_Tag_datalen;
1345}
1346len = identifier_oldlen - identifier_datalen;
1347}
1348}
1349{
1350size_t hostname_datalen, hostname_oldlen;
1351Der_type hostname_type;
1352e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &hostname_type, 9, &hostname_datalen, &l);
1353if (e == 0 && hostname_type != CONS) { e = ASN1_BAD_ID; }
1354if(e) {
1355(data)->hostname = NULL;
1356} else {
1357(data)->hostname = calloc(1, sizeof(*(data)->hostname));
1358if ((data)->hostname == NULL) { e = ENOMEM; goto fail; }
1359p += l; len -= l; ret += l;
1360hostname_oldlen = len;
1361if (hostname_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1362len = hostname_datalen;
1363{
1364size_t hostname_Tag_datalen, hostname_Tag_oldlen;
1365Der_type hostname_Tag_type;
1366e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &hostname_Tag_type, UT_UTF8String, &hostname_Tag_datalen, &l);
1367if (e == 0 && hostname_Tag_type != PRIM) { e = ASN1_BAD_ID; }
1368if(e) goto fail;
1369p += l; len -= l; ret += l;
1370hostname_Tag_oldlen = len;
1371if (hostname_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1372len = hostname_Tag_datalen;
1373e = der_get_utf8string(p, len, (data)->hostname, &l);
1374if(e) goto fail;
1375p += l; len -= l; ret += l;
1376len = hostname_Tag_oldlen - hostname_Tag_datalen;
1377}
1378len = hostname_oldlen - hostname_datalen;
1379}
1380}
1381{
1382size_t opaque_datalen, opaque_oldlen;
1383Der_type opaque_type;
1384e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &opaque_type, UT_UTF8String, &opaque_datalen, &l);
1385if (e == 0 && opaque_type != PRIM) { e = ASN1_BAD_ID; }
1386if(e) goto fail;
1387p += l; len -= l; ret += l;
1388opaque_oldlen = len;
1389if (opaque_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1390len = opaque_datalen;
1391e = der_get_utf8string(p, len, &(data)->opaque, &l);
1392if(e) goto fail;
1393p += l; len -= l; ret += l;
1394len = opaque_oldlen - opaque_datalen;
1395}
1396len = Top_oldlen - Top_datalen;
1397}
1398if(size) *size = ret;
1399return 0;
1400fail:
1401free_DigestRequest(data);
1402return e;
1403}
1404
1405void ASN1CALL
1406free_DigestRequest(DigestRequest *data)
1407{
1408der_free_utf8string(&(data)->type);
1409der_free_utf8string(&(data)->digest);
1410der_free_utf8string(&(data)->username);
1411der_free_utf8string(&(data)->responseData);
1412if((data)->authid) {
1413der_free_utf8string((data)->authid);
1414free((data)->authid);
1415(data)->authid = NULL;
1416}
1417if((data)->authentication_user) {
1418free_Principal((data)->authentication_user);
1419free((data)->authentication_user);
1420(data)->authentication_user = NULL;
1421}
1422if((data)->realm) {
1423der_free_utf8string((data)->realm);
1424free((data)->realm);
1425(data)->realm = NULL;
1426}
1427if((data)->method) {
1428der_free_utf8string((data)->method);
1429free((data)->method);
1430(data)->method = NULL;
1431}
1432if((data)->uri) {
1433der_free_utf8string((data)->uri);
1434free((data)->uri);
1435(data)->uri = NULL;
1436}
1437der_free_utf8string(&(data)->serverNonce);
1438if((data)->clientNonce) {
1439der_free_utf8string((data)->clientNonce);
1440free((data)->clientNonce);
1441(data)->clientNonce = NULL;
1442}
1443if((data)->nonceCount) {
1444der_free_utf8string((data)->nonceCount);
1445free((data)->nonceCount);
1446(data)->nonceCount = NULL;
1447}
1448if((data)->qop) {
1449der_free_utf8string((data)->qop);
1450free((data)->qop);
1451(data)->qop = NULL;
1452}
1453if((data)->identifier) {
1454der_free_utf8string((data)->identifier);
1455free((data)->identifier);
1456(data)->identifier = NULL;
1457}
1458if((data)->hostname) {
1459der_free_utf8string((data)->hostname);
1460free((data)->hostname);
1461(data)->hostname = NULL;
1462}
1463der_free_utf8string(&(data)->opaque);
1464}
1465
1466size_t ASN1CALL
1467length_DigestRequest(const DigestRequest *data)
1468{
1469size_t ret = 0;
1470{
1471size_t Top_tag_oldret = ret;
1472ret = 0;
1473ret += der_length_utf8string(&(data)->type);
1474ret += 1 + der_length_len (ret);
1475ret += Top_tag_oldret;
1476}
1477{
1478size_t Top_tag_oldret = ret;
1479ret = 0;
1480ret += der_length_utf8string(&(data)->digest);
1481ret += 1 + der_length_len (ret);
1482ret += Top_tag_oldret;
1483}
1484{
1485size_t Top_tag_oldret = ret;
1486ret = 0;
1487ret += der_length_utf8string(&(data)->username);
1488ret += 1 + der_length_len (ret);
1489ret += Top_tag_oldret;
1490}
1491{
1492size_t Top_tag_oldret = ret;
1493ret = 0;
1494ret += der_length_utf8string(&(data)->responseData);
1495ret += 1 + der_length_len (ret);
1496ret += Top_tag_oldret;
1497}
1498if((data)->authid){
1499size_t Top_tag_oldret = ret;
1500ret = 0;
1501ret += der_length_utf8string((data)->authid);
1502ret += 1 + der_length_len (ret);
1503ret += 1 + der_length_len (ret);
1504ret += Top_tag_oldret;
1505}
1506if((data)->authentication_user){
1507size_t Top_tag_oldret = ret;
1508ret = 0;
1509ret += length_Principal((data)->authentication_user);
1510ret += 1 + der_length_len (ret);
1511ret += Top_tag_oldret;
1512}
1513if((data)->realm){
1514size_t Top_tag_oldret = ret;
1515ret = 0;
1516ret += der_length_utf8string((data)->realm);
1517ret += 1 + der_length_len (ret);
1518ret += 1 + der_length_len (ret);
1519ret += Top_tag_oldret;
1520}
1521if((data)->method){
1522size_t Top_tag_oldret = ret;
1523ret = 0;
1524ret += der_length_utf8string((data)->method);
1525ret += 1 + der_length_len (ret);
1526ret += 1 + der_length_len (ret);
1527ret += Top_tag_oldret;
1528}
1529if((data)->uri){
1530size_t Top_tag_oldret = ret;
1531ret = 0;
1532ret += der_length_utf8string((data)->uri);
1533ret += 1 + der_length_len (ret);
1534ret += 1 + der_length_len (ret);
1535ret += Top_tag_oldret;
1536}
1537{
1538size_t Top_tag_oldret = ret;
1539ret = 0;
1540ret += der_length_utf8string(&(data)->serverNonce);
1541ret += 1 + der_length_len (ret);
1542ret += Top_tag_oldret;
1543}
1544if((data)->clientNonce){
1545size_t Top_tag_oldret = ret;
1546ret = 0;
1547ret += der_length_utf8string((data)->clientNonce);
1548ret += 1 + der_length_len (ret);
1549ret += 1 + der_length_len (ret);
1550ret += Top_tag_oldret;
1551}
1552if((data)->nonceCount){
1553size_t Top_tag_oldret = ret;
1554ret = 0;
1555ret += der_length_utf8string((data)->nonceCount);
1556ret += 1 + der_length_len (ret);
1557ret += 1 + der_length_len (ret);
1558ret += Top_tag_oldret;
1559}
1560if((data)->qop){
1561size_t Top_tag_oldret = ret;
1562ret = 0;
1563ret += der_length_utf8string((data)->qop);
1564ret += 1 + der_length_len (ret);
1565ret += 1 + der_length_len (ret);
1566ret += Top_tag_oldret;
1567}
1568if((data)->identifier){
1569size_t Top_tag_oldret = ret;
1570ret = 0;
1571ret += der_length_utf8string((data)->identifier);
1572ret += 1 + der_length_len (ret);
1573ret += 1 + der_length_len (ret);
1574ret += Top_tag_oldret;
1575}
1576if((data)->hostname){
1577size_t Top_tag_oldret = ret;
1578ret = 0;
1579ret += der_length_utf8string((data)->hostname);
1580ret += 1 + der_length_len (ret);
1581ret += 1 + der_length_len (ret);
1582ret += Top_tag_oldret;
1583}
1584{
1585size_t Top_tag_oldret = ret;
1586ret = 0;
1587ret += der_length_utf8string(&(data)->opaque);
1588ret += 1 + der_length_len (ret);
1589ret += Top_tag_oldret;
1590}
1591ret += 1 + der_length_len (ret);
1592return ret;
1593}
1594
1595int ASN1CALL
1596copy_DigestRequest(const DigestRequest *from, DigestRequest *to)
1597{
1598memset(to, 0, sizeof(*to));
1599if(der_copy_utf8string(&(from)->type, &(to)->type)) goto fail;
1600if(der_copy_utf8string(&(from)->digest, &(to)->digest)) goto fail;
1601if(der_copy_utf8string(&(from)->username, &(to)->username)) goto fail;
1602if(der_copy_utf8string(&(from)->responseData, &(to)->responseData)) goto fail;
1603if((from)->authid) {
1604(to)->authid = malloc(sizeof(*(to)->authid));
1605if((to)->authid == NULL) goto fail;
1606if(der_copy_utf8string((from)->authid, (to)->authid)) goto fail;
1607}else
1608(to)->authid = NULL;
1609if((from)->authentication_user) {
1610(to)->authentication_user = malloc(sizeof(*(to)->authentication_user));
1611if((to)->authentication_user == NULL) goto fail;
1612if(copy_Principal((from)->authentication_user, (to)->authentication_user)) goto fail;
1613}else
1614(to)->authentication_user = NULL;
1615if((from)->realm) {
1616(to)->realm = malloc(sizeof(*(to)->realm));
1617if((to)->realm == NULL) goto fail;
1618if(der_copy_utf8string((from)->realm, (to)->realm)) goto fail;
1619}else
1620(to)->realm = NULL;
1621if((from)->method) {
1622(to)->method = malloc(sizeof(*(to)->method));
1623if((to)->method == NULL) goto fail;
1624if(der_copy_utf8string((from)->method, (to)->method)) goto fail;
1625}else
1626(to)->method = NULL;
1627if((from)->uri) {
1628(to)->uri = malloc(sizeof(*(to)->uri));
1629if((to)->uri == NULL) goto fail;
1630if(der_copy_utf8string((from)->uri, (to)->uri)) goto fail;
1631}else
1632(to)->uri = NULL;
1633if(der_copy_utf8string(&(from)->serverNonce, &(to)->serverNonce)) goto fail;
1634if((from)->clientNonce) {
1635(to)->clientNonce = malloc(sizeof(*(to)->clientNonce));
1636if((to)->clientNonce == NULL) goto fail;
1637if(der_copy_utf8string((from)->clientNonce, (to)->clientNonce)) goto fail;
1638}else
1639(to)->clientNonce = NULL;
1640if((from)->nonceCount) {
1641(to)->nonceCount = malloc(sizeof(*(to)->nonceCount));
1642if((to)->nonceCount == NULL) goto fail;
1643if(der_copy_utf8string((from)->nonceCount, (to)->nonceCount)) goto fail;
1644}else
1645(to)->nonceCount = NULL;
1646if((from)->qop) {
1647(to)->qop = malloc(sizeof(*(to)->qop));
1648if((to)->qop == NULL) goto fail;
1649if(der_copy_utf8string((from)->qop, (to)->qop)) goto fail;
1650}else
1651(to)->qop = NULL;
1652if((from)->identifier) {
1653(to)->identifier = malloc(sizeof(*(to)->identifier));
1654if((to)->identifier == NULL) goto fail;
1655if(der_copy_utf8string((from)->identifier, (to)->identifier)) goto fail;
1656}else
1657(to)->identifier = NULL;
1658if((from)->hostname) {
1659(to)->hostname = malloc(sizeof(*(to)->hostname));
1660if((to)->hostname == NULL) goto fail;
1661if(der_copy_utf8string((from)->hostname, (to)->hostname)) goto fail;
1662}else
1663(to)->hostname = NULL;
1664if(der_copy_utf8string(&(from)->opaque, &(to)->opaque)) goto fail;
1665return 0;
1666fail:
1667free_DigestRequest(to);
1668return ENOMEM;
1669}
1670
1671int ASN1CALL
1672encode_DigestError(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const DigestError *data, size_t *size)
1673{
1674size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
1675size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1676int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
1677
1678/* code */
1679{
1680size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
1681ret = 0;
1682e = der_put_integer(p, len, &(data)->code, &l);
1683if (e) return e;
1684p -= l; len -= l; ret += l;
1685
1686e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
1687if (e) return e;
1688p -= l; len -= l; ret += l;
1689
1690ret += Top_tag_oldret;
1691}
1692/* reason */
1693{
1694size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
1695ret = 0;
1696e = der_put_utf8string(p, len, &(data)->reason, &l);
1697if (e) return e;
1698p -= l; len -= l; ret += l;
1699
1700e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_UTF8String, &l);
1701if (e) return e;
1702p -= l; len -= l; ret += l;
1703
1704ret += Top_tag_oldret;
1705}
1706e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
1707if (e) return e;
1708p -= l; len -= l; ret += l;
1709
1710*size = ret;
1711return 0;
1712}
1713
1714int ASN1CALL
1715decode_DigestError(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, DigestError *data, size_t *size)
1716{
1717size_t ret = 0;
1718size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1719int e HEIMDAL_UNUSED_ATTRIBUTE;
1720
1721memset(data, 0, sizeof(*data));
1722{
1723size_t Top_datalen, Top_oldlen;
1724Der_type Top_type;
1725e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
1726if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
1727if(e) goto fail;
1728p += l; len -= l; ret += l;
1729Top_oldlen = len;
1730if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1731len = Top_datalen;
1732{
1733size_t reason_datalen, reason_oldlen;
1734Der_type reason_type;
1735e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &reason_type, UT_UTF8String, &reason_datalen, &l);
1736if (e == 0 && reason_type != PRIM) { e = ASN1_BAD_ID; }
1737if(e) goto fail;
1738p += l; len -= l; ret += l;
1739reason_oldlen = len;
1740if (reason_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1741len = reason_datalen;
1742e = der_get_utf8string(p, len, &(data)->reason, &l);
1743if(e) goto fail;
1744p += l; len -= l; ret += l;
1745len = reason_oldlen - reason_datalen;
1746}
1747{
1748size_t code_datalen, code_oldlen;
1749Der_type code_type;
1750e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &code_type, UT_Integer, &code_datalen, &l);
1751if (e == 0 && code_type != PRIM) { e = ASN1_BAD_ID; }
1752if(e) goto fail;
1753p += l; len -= l; ret += l;
1754code_oldlen = len;
1755if (code_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1756len = code_datalen;
1757e = der_get_integer(p, len, &(data)->code, &l);
1758if(e) goto fail;
1759p += l; len -= l; ret += l;
1760len = code_oldlen - code_datalen;
1761}
1762len = Top_oldlen - Top_datalen;
1763}
1764if(size) *size = ret;
1765return 0;
1766fail:
1767free_DigestError(data);
1768return e;
1769}
1770
1771void ASN1CALL
1772free_DigestError(DigestError *data)
1773{
1774der_free_utf8string(&(data)->reason);
1775}
1776
1777size_t ASN1CALL
1778length_DigestError(const DigestError *data)
1779{
1780size_t ret = 0;
1781{
1782size_t Top_tag_oldret = ret;
1783ret = 0;
1784ret += der_length_utf8string(&(data)->reason);
1785ret += 1 + der_length_len (ret);
1786ret += Top_tag_oldret;
1787}
1788{
1789size_t Top_tag_oldret = ret;
1790ret = 0;
1791ret += der_length_integer(&(data)->code);
1792ret += 1 + der_length_len (ret);
1793ret += Top_tag_oldret;
1794}
1795ret += 1 + der_length_len (ret);
1796return ret;
1797}
1798
1799int ASN1CALL
1800copy_DigestError(const DigestError *from, DigestError *to)
1801{
1802memset(to, 0, sizeof(*to));
1803if(der_copy_utf8string(&(from)->reason, &(to)->reason)) goto fail;
1804*(&(to)->code) = *(&(from)->code);
1805return 0;
1806fail:
1807free_DigestError(to);
1808return ENOMEM;
1809}
1810
1811int ASN1CALL
1812encode_DigestResponse(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const DigestResponse *data, size_t *size)
1813{
1814size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
1815size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1816int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
1817
1818/* session-key */
1819if((data)->session_key) {
1820size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
1821ret = 0;
1822e = der_put_octet_string(p, len, (data)->session_key, &l);
1823if (e) return e;
1824p -= l; len -= l; ret += l;
1825
1826e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
1827if (e) return e;
1828p -= l; len -= l; ret += l;
1829
1830e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
1831if (e) return e;
1832p -= l; len -= l; ret += l;
1833
1834ret += Top_tag_oldret;
1835}
1836/* channel */
1837if((data)->channel) {
1838size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
1839ret = 0;
1840/* cb-binding */
1841{
1842size_t channel_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
1843ret = 0;
1844e = der_put_utf8string(p, len, &((data)->channel)->cb_binding, &l);
1845if (e) return e;
1846p -= l; len -= l; ret += l;
1847
1848e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_UTF8String, &l);
1849if (e) return e;
1850p -= l; len -= l; ret += l;
1851
1852ret += channel_tag_tag_oldret;
1853}
1854/* cb-type */
1855{
1856size_t channel_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
1857ret = 0;
1858e = der_put_utf8string(p, len, &((data)->channel)->cb_type, &l);
1859if (e) return e;
1860p -= l; len -= l; ret += l;
1861
1862e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_UTF8String, &l);
1863if (e) return e;
1864p -= l; len -= l; ret += l;
1865
1866ret += channel_tag_tag_oldret;
1867}
1868e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
1869if (e) return e;
1870p -= l; len -= l; ret += l;
1871
1872e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
1873if (e) return e;
1874p -= l; len -= l; ret += l;
1875
1876ret += Top_tag_oldret;
1877}
1878/* tickets */
1879if((data)->tickets) {
1880size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
1881ret = 0;
1882for(i = (int)((data)->tickets)->len - 1; i >= 0; --i) {
1883size_t tickets_tag_tag_for_oldret = ret;
1884ret = 0;
1885e = der_put_octet_string(p, len, &((data)->tickets)->val[i], &l);
1886if (e) return e;
1887p -= l; len -= l; ret += l;
1888
1889e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
1890if (e) return e;
1891p -= l; len -= l; ret += l;
1892
1893ret += tickets_tag_tag_for_oldret;
1894}
1895e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
1896if (e) return e;
1897p -= l; len -= l; ret += l;
1898
1899e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
1900if (e) return e;
1901p -= l; len -= l; ret += l;
1902
1903ret += Top_tag_oldret;
1904}
1905/* rsp */
1906if((data)->rsp) {
1907size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
1908ret = 0;
1909e = der_put_utf8string(p, len, (data)->rsp, &l);
1910if (e) return e;
1911p -= l; len -= l; ret += l;
1912
1913e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_UTF8String, &l);
1914if (e) return e;
1915p -= l; len -= l; ret += l;
1916
1917e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
1918if (e) return e;
1919p -= l; len -= l; ret += l;
1920
1921ret += Top_tag_oldret;
1922}
1923/* success */
1924{
1925size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
1926ret = 0;
1927e = der_put_boolean(p, len, &(data)->success, &l);
1928if (e) return e;
1929p -= l; len -= l; ret += l;
1930
1931e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Boolean, &l);
1932if (e) return e;
1933p -= l; len -= l; ret += l;
1934
1935ret += Top_tag_oldret;
1936}
1937e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
1938if (e) return e;
1939p -= l; len -= l; ret += l;
1940
1941*size = ret;
1942return 0;
1943}
1944
1945int ASN1CALL
1946decode_DigestResponse(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, DigestResponse *data, size_t *size)
1947{
1948size_t ret = 0;
1949size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1950int e HEIMDAL_UNUSED_ATTRIBUTE;
1951
1952memset(data, 0, sizeof(*data));
1953{
1954size_t Top_datalen, Top_oldlen;
1955Der_type Top_type;
1956e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
1957if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
1958if(e) goto fail;
1959p += l; len -= l; ret += l;
1960Top_oldlen = len;
1961if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1962len = Top_datalen;
1963{
1964size_t success_datalen, success_oldlen;
1965Der_type success_type;
1966e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &success_type, UT_Boolean, &success_datalen, &l);
1967if (e == 0 && success_type != PRIM) { e = ASN1_BAD_ID; }
1968if(e) goto fail;
1969p += l; len -= l; ret += l;
1970success_oldlen = len;
1971if (success_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1972len = success_datalen;
1973e = der_get_boolean(p, len, &(data)->success, &l);
1974if(e) goto fail;
1975p += l; len -= l; ret += l;
1976len = success_oldlen - success_datalen;
1977}
1978{
1979size_t rsp_datalen, rsp_oldlen;
1980Der_type rsp_type;
1981e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &rsp_type, 0, &rsp_datalen, &l);
1982if (e == 0 && rsp_type != CONS) { e = ASN1_BAD_ID; }
1983if(e) {
1984(data)->rsp = NULL;
1985} else {
1986(data)->rsp = calloc(1, sizeof(*(data)->rsp));
1987if ((data)->rsp == NULL) { e = ENOMEM; goto fail; }
1988p += l; len -= l; ret += l;
1989rsp_oldlen = len;
1990if (rsp_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1991len = rsp_datalen;
1992{
1993size_t rsp_Tag_datalen, rsp_Tag_oldlen;
1994Der_type rsp_Tag_type;
1995e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &rsp_Tag_type, UT_UTF8String, &rsp_Tag_datalen, &l);
1996if (e == 0 && rsp_Tag_type != PRIM) { e = ASN1_BAD_ID; }
1997if(e) goto fail;
1998p += l; len -= l; ret += l;
1999rsp_Tag_oldlen = len;
2000if (rsp_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2001len = rsp_Tag_datalen;
2002e = der_get_utf8string(p, len, (data)->rsp, &l);
2003if(e) goto fail;
2004p += l; len -= l; ret += l;
2005len = rsp_Tag_oldlen - rsp_Tag_datalen;
2006}
2007len = rsp_oldlen - rsp_datalen;
2008}
2009}
2010{
2011size_t tickets_datalen, tickets_oldlen;
2012Der_type tickets_type;
2013e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &tickets_type, 1, &tickets_datalen, &l);
2014if (e == 0 && tickets_type != CONS) { e = ASN1_BAD_ID; }
2015if(e) {
2016(data)->tickets = NULL;
2017} else {
2018(data)->tickets = calloc(1, sizeof(*(data)->tickets));
2019if ((data)->tickets == NULL) { e = ENOMEM; goto fail; }
2020p += l; len -= l; ret += l;
2021tickets_oldlen = len;
2022if (tickets_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2023len = tickets_datalen;
2024{
2025size_t tickets_Tag_datalen, tickets_Tag_oldlen;
2026Der_type tickets_Tag_type;
2027e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &tickets_Tag_type, UT_Sequence, &tickets_Tag_datalen, &l);
2028if (e == 0 && tickets_Tag_type != CONS) { e = ASN1_BAD_ID; }
2029if(e) goto fail;
2030p += l; len -= l; ret += l;
2031tickets_Tag_oldlen = len;
2032if (tickets_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2033len = tickets_Tag_datalen;
2034{
2035size_t tickets_Tag_Tag_origlen = len;
2036size_t tickets_Tag_Tag_oldret = ret;
2037size_t tickets_Tag_Tag_olen = 0;
2038void *tickets_Tag_Tag_tmp;
2039ret = 0;
2040((data)->tickets)->len = 0;
2041((data)->tickets)->val = NULL;
2042while(ret < tickets_Tag_Tag_origlen) {
2043size_t tickets_Tag_Tag_nlen = tickets_Tag_Tag_olen + sizeof(*(((data)->tickets)->val));
2044if (tickets_Tag_Tag_olen > tickets_Tag_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
2045tickets_Tag_Tag_olen = tickets_Tag_Tag_nlen;
2046tickets_Tag_Tag_tmp = realloc(((data)->tickets)->val, tickets_Tag_Tag_olen);
2047if (tickets_Tag_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
2048((data)->tickets)->val = tickets_Tag_Tag_tmp;
2049{
2050size_t tickets_Tag_Tag_s_of_datalen, tickets_Tag_Tag_s_of_oldlen;
2051Der_type tickets_Tag_Tag_s_of_type;
2052e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &tickets_Tag_Tag_s_of_type, UT_OctetString, &tickets_Tag_Tag_s_of_datalen, &l);
2053if (e == 0 && tickets_Tag_Tag_s_of_type != PRIM) { e = ASN1_BAD_ID; }
2054if(e) goto fail;
2055p += l; len -= l; ret += l;
2056tickets_Tag_Tag_s_of_oldlen = len;
2057if (tickets_Tag_Tag_s_of_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2058len = tickets_Tag_Tag_s_of_datalen;
2059e = der_get_octet_string(p, len, &((data)->tickets)->val[((data)->tickets)->len], &l);
2060if(e) goto fail;
2061p += l; len -= l; ret += l;
2062len = tickets_Tag_Tag_s_of_oldlen - tickets_Tag_Tag_s_of_datalen;
2063}
2064((data)->tickets)->len++;
2065len = tickets_Tag_Tag_origlen - ret;
2066}
2067ret += tickets_Tag_Tag_oldret;
2068}
2069len = tickets_Tag_oldlen - tickets_Tag_datalen;
2070}
2071len = tickets_oldlen - tickets_datalen;
2072}
2073}
2074{
2075size_t channel_datalen, channel_oldlen;
2076Der_type channel_type;
2077e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &channel_type, 2, &channel_datalen, &l);
2078if (e == 0 && channel_type != CONS) { e = ASN1_BAD_ID; }
2079if(e) {
2080(data)->channel = NULL;
2081} else {
2082(data)->channel = calloc(1, sizeof(*(data)->channel));
2083if ((data)->channel == NULL) { e = ENOMEM; goto fail; }
2084p += l; len -= l; ret += l;
2085channel_oldlen = len;
2086if (channel_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2087len = channel_datalen;
2088{
2089size_t channel_Tag_datalen, channel_Tag_oldlen;
2090Der_type channel_Tag_type;
2091e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &channel_Tag_type, UT_Sequence, &channel_Tag_datalen, &l);
2092if (e == 0 && channel_Tag_type != CONS) { e = ASN1_BAD_ID; }
2093if(e) goto fail;
2094p += l; len -= l; ret += l;
2095channel_Tag_oldlen = len;
2096if (channel_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2097len = channel_Tag_datalen;
2098{
2099size_t cb_type_datalen, cb_type_oldlen;
2100Der_type cb_type_type;
2101e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &cb_type_type, UT_UTF8String, &cb_type_datalen, &l);
2102if (e == 0 && cb_type_type != PRIM) { e = ASN1_BAD_ID; }
2103if(e) goto fail;
2104p += l; len -= l; ret += l;
2105cb_type_oldlen = len;
2106if (cb_type_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2107len = cb_type_datalen;
2108e = der_get_utf8string(p, len, &((data)->channel)->cb_type, &l);
2109if(e) goto fail;
2110p += l; len -= l; ret += l;
2111len = cb_type_oldlen - cb_type_datalen;
2112}
2113{
2114size_t cb_binding_datalen, cb_binding_oldlen;
2115Der_type cb_binding_type;
2116e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &cb_binding_type, UT_UTF8String, &cb_binding_datalen, &l);
2117if (e == 0 && cb_binding_type != PRIM) { e = ASN1_BAD_ID; }
2118if(e) goto fail;
2119p += l; len -= l; ret += l;
2120cb_binding_oldlen = len;
2121if (cb_binding_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2122len = cb_binding_datalen;
2123e = der_get_utf8string(p, len, &((data)->channel)->cb_binding, &l);
2124if(e) goto fail;
2125p += l; len -= l; ret += l;
2126len = cb_binding_oldlen - cb_binding_datalen;
2127}
2128len = channel_Tag_oldlen - channel_Tag_datalen;
2129}
2130len = channel_oldlen - channel_datalen;
2131}
2132}
2133{
2134size_t session_key_datalen, session_key_oldlen;
2135Der_type session_key_type;
2136e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &session_key_type, 3, &session_key_datalen, &l);
2137if (e == 0 && session_key_type != CONS) { e = ASN1_BAD_ID; }
2138if(e) {
2139(data)->session_key = NULL;
2140} else {
2141(data)->session_key = calloc(1, sizeof(*(data)->session_key));
2142if ((data)->session_key == NULL) { e = ENOMEM; goto fail; }
2143p += l; len -= l; ret += l;
2144session_key_oldlen = len;
2145if (session_key_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2146len = session_key_datalen;
2147{
2148size_t session_key_Tag_datalen, session_key_Tag_oldlen;
2149Der_type session_key_Tag_type;
2150e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &session_key_Tag_type, UT_OctetString, &session_key_Tag_datalen, &l);
2151if (e == 0 && session_key_Tag_type != PRIM) { e = ASN1_BAD_ID; }
2152if(e) goto fail;
2153p += l; len -= l; ret += l;
2154session_key_Tag_oldlen = len;
2155if (session_key_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2156len = session_key_Tag_datalen;
2157e = der_get_octet_string(p, len, (data)->session_key, &l);
2158if(e) goto fail;
2159p += l; len -= l; ret += l;
2160len = session_key_Tag_oldlen - session_key_Tag_datalen;
2161}
2162len = session_key_oldlen - session_key_datalen;
2163}
2164}
2165len = Top_oldlen - Top_datalen;
2166}
2167if(size) *size = ret;
2168return 0;
2169fail:
2170free_DigestResponse(data);
2171return e;
2172}
2173
2174void ASN1CALL
2175free_DigestResponse(DigestResponse *data)
2176{
2177if((data)->rsp) {
2178der_free_utf8string((data)->rsp);
2179free((data)->rsp);
2180(data)->rsp = NULL;
2181}
2182if((data)->tickets) {
2183while(((data)->tickets)->len){
2184der_free_octet_string(&((data)->tickets)->val[((data)->tickets)->len-1]);
2185((data)->tickets)->len--;
2186}
2187free(((data)->tickets)->val);
2188((data)->tickets)->val = NULL;
2189free((data)->tickets);
2190(data)->tickets = NULL;
2191}
2192if((data)->channel) {
2193der_free_utf8string(&((data)->channel)->cb_type);
2194der_free_utf8string(&((data)->channel)->cb_binding);
2195free((data)->channel);
2196(data)->channel = NULL;
2197}
2198if((data)->session_key) {
2199der_free_octet_string((data)->session_key);
2200free((data)->session_key);
2201(data)->session_key = NULL;
2202}
2203}
2204
2205size_t ASN1CALL
2206length_DigestResponse(const DigestResponse *data)
2207{
2208size_t ret = 0;
2209{
2210size_t Top_tag_oldret = ret;
2211ret = 0;
2212ret += 1;
2213ret += 1 + der_length_len (ret);
2214ret += Top_tag_oldret;
2215}
2216if((data)->rsp){
2217size_t Top_tag_oldret = ret;
2218ret = 0;
2219ret += der_length_utf8string((data)->rsp);
2220ret += 1 + der_length_len (ret);
2221ret += 1 + der_length_len (ret);
2222ret += Top_tag_oldret;
2223}
2224if((data)->tickets){
2225size_t Top_tag_oldret = ret;
2226ret = 0;
2227{
2228size_t tickets_tag_tag_oldret = ret;
2229unsigned int n_tickets_tag_tag;
2230ret = 0;
2231for(n_tickets_tag_tag = ((data)->tickets)->len; n_tickets_tag_tag > 0; --n_tickets_tag_tag){
2232size_t tickets_tag_tag_for_oldret = ret;
2233ret = 0;
2234ret += der_length_octet_string(&((data)->tickets)->val[n_tickets_tag_tag - 1]);
2235ret += 1 + der_length_len (ret);
2236ret += tickets_tag_tag_for_oldret;
2237}
2238ret += tickets_tag_tag_oldret;
2239}
2240ret += 1 + der_length_len (ret);
2241ret += 1 + der_length_len (ret);
2242ret += Top_tag_oldret;
2243}
2244if((data)->channel){
2245size_t Top_tag_oldret = ret;
2246ret = 0;
2247{
2248size_t channel_tag_tag_oldret = ret;
2249ret = 0;
2250ret += der_length_utf8string(&((data)->channel)->cb_type);
2251ret += 1 + der_length_len (ret);
2252ret += channel_tag_tag_oldret;
2253}
2254{
2255size_t channel_tag_tag_oldret = ret;
2256ret = 0;
2257ret += der_length_utf8string(&((data)->channel)->cb_binding);
2258ret += 1 + der_length_len (ret);
2259ret += channel_tag_tag_oldret;
2260}
2261ret += 1 + der_length_len (ret);
2262ret += 1 + der_length_len (ret);
2263ret += Top_tag_oldret;
2264}
2265if((data)->session_key){
2266size_t Top_tag_oldret = ret;
2267ret = 0;
2268ret += der_length_octet_string((data)->session_key);
2269ret += 1 + der_length_len (ret);
2270ret += 1 + der_length_len (ret);
2271ret += Top_tag_oldret;
2272}
2273ret += 1 + der_length_len (ret);
2274return ret;
2275}
2276
2277int ASN1CALL
2278copy_DigestResponse(const DigestResponse *from, DigestResponse *to)
2279{
2280memset(to, 0, sizeof(*to));
2281*(&(to)->success) = *(&(from)->success);
2282if((from)->rsp) {
2283(to)->rsp = malloc(sizeof(*(to)->rsp));
2284if((to)->rsp == NULL) goto fail;
2285if(der_copy_utf8string((from)->rsp, (to)->rsp)) goto fail;
2286}else
2287(to)->rsp = NULL;
2288if((from)->tickets) {
2289(to)->tickets = malloc(sizeof(*(to)->tickets));
2290if((to)->tickets == NULL) goto fail;
2291if((((to)->tickets)->val = malloc(((from)->tickets)->len * sizeof(*((to)->tickets)->val))) == NULL && ((from)->tickets)->len != 0)
2292goto fail;
2293for(((to)->tickets)->len = 0; ((to)->tickets)->len < ((from)->tickets)->len; ((to)->tickets)->len++){
2294if(der_copy_octet_string(&((from)->tickets)->val[((to)->tickets)->len], &((to)->tickets)->val[((to)->tickets)->len])) goto fail;
2295}
2296}else
2297(to)->tickets = NULL;
2298if((from)->channel) {
2299(to)->channel = malloc(sizeof(*(to)->channel));
2300if((to)->channel == NULL) goto fail;
2301if(der_copy_utf8string(&((from)->channel)->cb_type, &((to)->channel)->cb_type)) goto fail;
2302if(der_copy_utf8string(&((from)->channel)->cb_binding, &((to)->channel)->cb_binding)) goto fail;
2303}else
2304(to)->channel = NULL;
2305if((from)->session_key) {
2306(to)->session_key = malloc(sizeof(*(to)->session_key));
2307if((to)->session_key == NULL) goto fail;
2308if(der_copy_octet_string((from)->session_key, (to)->session_key)) goto fail;
2309}else
2310(to)->session_key = NULL;
2311return 0;
2312fail:
2313free_DigestResponse(to);
2314return ENOMEM;
2315}
2316
2317int ASN1CALL
2318encode_NTLMInit(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const NTLMInit *data, size_t *size)
2319{
2320size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
2321size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2322int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
2323
2324/* domain */
2325if((data)->domain) {
2326size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2327ret = 0;
2328e = der_put_utf8string(p, len, (data)->domain, &l);
2329if (e) return e;
2330p -= l; len -= l; ret += l;
2331
2332e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_UTF8String, &l);
2333if (e) return e;
2334p -= l; len -= l; ret += l;
2335
2336e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
2337if (e) return e;
2338p -= l; len -= l; ret += l;
2339
2340ret += Top_tag_oldret;
2341}
2342/* hostname */
2343if((data)->hostname) {
2344size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2345ret = 0;
2346e = der_put_utf8string(p, len, (data)->hostname, &l);
2347if (e) return e;
2348p -= l; len -= l; ret += l;
2349
2350e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_UTF8String, &l);
2351if (e) return e;
2352p -= l; len -= l; ret += l;
2353
2354e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
2355if (e) return e;
2356p -= l; len -= l; ret += l;
2357
2358ret += Top_tag_oldret;
2359}
2360/* flags */
2361{
2362size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2363ret = 0;
2364e = der_put_unsigned(p, len, &(data)->flags, &l);
2365if (e) return e;
2366p -= l; len -= l; ret += l;
2367
2368e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
2369if (e) return e;
2370p -= l; len -= l; ret += l;
2371
2372e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
2373if (e) return e;
2374p -= l; len -= l; ret += l;
2375
2376ret += Top_tag_oldret;
2377}
2378e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
2379if (e) return e;
2380p -= l; len -= l; ret += l;
2381
2382*size = ret;
2383return 0;
2384}
2385
2386int ASN1CALL
2387decode_NTLMInit(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, NTLMInit *data, size_t *size)
2388{
2389size_t ret = 0;
2390size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2391int e HEIMDAL_UNUSED_ATTRIBUTE;
2392
2393memset(data, 0, sizeof(*data));
2394{
2395size_t Top_datalen, Top_oldlen;
2396Der_type Top_type;
2397e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
2398if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
2399if(e) goto fail;
2400p += l; len -= l; ret += l;
2401Top_oldlen = len;
2402if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2403len = Top_datalen;
2404{
2405size_t flags_datalen, flags_oldlen;
2406Der_type flags_type;
2407e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &flags_type, 0, &flags_datalen, &l);
2408if (e == 0 && flags_type != CONS) { e = ASN1_BAD_ID; }
2409if(e) goto fail;
2410p += l; len -= l; ret += l;
2411flags_oldlen = len;
2412if (flags_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2413len = flags_datalen;
2414{
2415size_t flags_Tag_datalen, flags_Tag_oldlen;
2416Der_type flags_Tag_type;
2417e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &flags_Tag_type, UT_Integer, &flags_Tag_datalen, &l);
2418if (e == 0 && flags_Tag_type != PRIM) { e = ASN1_BAD_ID; }
2419if(e) goto fail;
2420p += l; len -= l; ret += l;
2421flags_Tag_oldlen = len;
2422if (flags_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2423len = flags_Tag_datalen;
2424e = der_get_unsigned(p, len, &(data)->flags, &l);
2425if(e) goto fail;
2426p += l; len -= l; ret += l;
2427len = flags_Tag_oldlen - flags_Tag_datalen;
2428}
2429len = flags_oldlen - flags_datalen;
2430}
2431{
2432size_t hostname_datalen, hostname_oldlen;
2433Der_type hostname_type;
2434e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &hostname_type, 1, &hostname_datalen, &l);
2435if (e == 0 && hostname_type != CONS) { e = ASN1_BAD_ID; }
2436if(e) {
2437(data)->hostname = NULL;
2438} else {
2439(data)->hostname = calloc(1, sizeof(*(data)->hostname));
2440if ((data)->hostname == NULL) { e = ENOMEM; goto fail; }
2441p += l; len -= l; ret += l;
2442hostname_oldlen = len;
2443if (hostname_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2444len = hostname_datalen;
2445{
2446size_t hostname_Tag_datalen, hostname_Tag_oldlen;
2447Der_type hostname_Tag_type;
2448e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &hostname_Tag_type, UT_UTF8String, &hostname_Tag_datalen, &l);
2449if (e == 0 && hostname_Tag_type != PRIM) { e = ASN1_BAD_ID; }
2450if(e) goto fail;
2451p += l; len -= l; ret += l;
2452hostname_Tag_oldlen = len;
2453if (hostname_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2454len = hostname_Tag_datalen;
2455e = der_get_utf8string(p, len, (data)->hostname, &l);
2456if(e) goto fail;
2457p += l; len -= l; ret += l;
2458len = hostname_Tag_oldlen - hostname_Tag_datalen;
2459}
2460len = hostname_oldlen - hostname_datalen;
2461}
2462}
2463{
2464size_t domain_datalen, domain_oldlen;
2465Der_type domain_type;
2466e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &domain_type, 1, &domain_datalen, &l);
2467if (e == 0 && domain_type != CONS) { e = ASN1_BAD_ID; }
2468if(e) {
2469(data)->domain = NULL;
2470} else {
2471(data)->domain = calloc(1, sizeof(*(data)->domain));
2472if ((data)->domain == NULL) { e = ENOMEM; goto fail; }
2473p += l; len -= l; ret += l;
2474domain_oldlen = len;
2475if (domain_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2476len = domain_datalen;
2477{
2478size_t domain_Tag_datalen, domain_Tag_oldlen;
2479Der_type domain_Tag_type;
2480e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &domain_Tag_type, UT_UTF8String, &domain_Tag_datalen, &l);
2481if (e == 0 && domain_Tag_type != PRIM) { e = ASN1_BAD_ID; }
2482if(e) goto fail;
2483p += l; len -= l; ret += l;
2484domain_Tag_oldlen = len;
2485if (domain_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2486len = domain_Tag_datalen;
2487e = der_get_utf8string(p, len, (data)->domain, &l);
2488if(e) goto fail;
2489p += l; len -= l; ret += l;
2490len = domain_Tag_oldlen - domain_Tag_datalen;
2491}
2492len = domain_oldlen - domain_datalen;
2493}
2494}
2495len = Top_oldlen - Top_datalen;
2496}
2497if(size) *size = ret;
2498return 0;
2499fail:
2500free_NTLMInit(data);
2501return e;
2502}
2503
2504void ASN1CALL
2505free_NTLMInit(NTLMInit *data)
2506{
2507if((data)->hostname) {
2508der_free_utf8string((data)->hostname);
2509free((data)->hostname);
2510(data)->hostname = NULL;
2511}
2512if((data)->domain) {
2513der_free_utf8string((data)->domain);
2514free((data)->domain);
2515(data)->domain = NULL;
2516}
2517}
2518
2519size_t ASN1CALL
2520length_NTLMInit(const NTLMInit *data)
2521{
2522size_t ret = 0;
2523{
2524size_t Top_tag_oldret = ret;
2525ret = 0;
2526ret += der_length_unsigned(&(data)->flags);
2527ret += 1 + der_length_len (ret);
2528ret += 1 + der_length_len (ret);
2529ret += Top_tag_oldret;
2530}
2531if((data)->hostname){
2532size_t Top_tag_oldret = ret;
2533ret = 0;
2534ret += der_length_utf8string((data)->hostname);
2535ret += 1 + der_length_len (ret);
2536ret += 1 + der_length_len (ret);
2537ret += Top_tag_oldret;
2538}
2539if((data)->domain){
2540size_t Top_tag_oldret = ret;
2541ret = 0;
2542ret += der_length_utf8string((data)->domain);
2543ret += 1 + der_length_len (ret);
2544ret += 1 + der_length_len (ret);
2545ret += Top_tag_oldret;
2546}
2547ret += 1 + der_length_len (ret);
2548return ret;
2549}
2550
2551int ASN1CALL
2552copy_NTLMInit(const NTLMInit *from, NTLMInit *to)
2553{
2554memset(to, 0, sizeof(*to));
2555*(&(to)->flags) = *(&(from)->flags);
2556if((from)->hostname) {
2557(to)->hostname = malloc(sizeof(*(to)->hostname));
2558if((to)->hostname == NULL) goto fail;
2559if(der_copy_utf8string((from)->hostname, (to)->hostname)) goto fail;
2560}else
2561(to)->hostname = NULL;
2562if((from)->domain) {
2563(to)->domain = malloc(sizeof(*(to)->domain));
2564if((to)->domain == NULL) goto fail;
2565if(der_copy_utf8string((from)->domain, (to)->domain)) goto fail;
2566}else
2567(to)->domain = NULL;
2568return 0;
2569fail:
2570free_NTLMInit(to);
2571return ENOMEM;
2572}
2573
2574int ASN1CALL
2575encode_NTLMInitReply(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const NTLMInitReply *data, size_t *size)
2576{
2577size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
2578size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2579int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
2580
2581/* targetinfo */
2582if((data)->targetinfo) {
2583size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2584ret = 0;
2585e = der_put_octet_string(p, len, (data)->targetinfo, &l);
2586if (e) return e;
2587p -= l; len -= l; ret += l;
2588
2589e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
2590if (e) return e;
2591p -= l; len -= l; ret += l;
2592
2593e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 4, &l);
2594if (e) return e;
2595p -= l; len -= l; ret += l;
2596
2597ret += Top_tag_oldret;
2598}
2599/* challenge */
2600{
2601size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2602ret = 0;
2603e = der_put_octet_string(p, len, &(data)->challenge, &l);
2604if (e) return e;
2605p -= l; len -= l; ret += l;
2606
2607e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
2608if (e) return e;
2609p -= l; len -= l; ret += l;
2610
2611e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
2612if (e) return e;
2613p -= l; len -= l; ret += l;
2614
2615ret += Top_tag_oldret;
2616}
2617/* targetname */
2618{
2619size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2620ret = 0;
2621e = der_put_utf8string(p, len, &(data)->targetname, &l);
2622if (e) return e;
2623p -= l; len -= l; ret += l;
2624
2625e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_UTF8String, &l);
2626if (e) return e;
2627p -= l; len -= l; ret += l;
2628
2629e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
2630if (e) return e;
2631p -= l; len -= l; ret += l;
2632
2633ret += Top_tag_oldret;
2634}
2635/* opaque */
2636{
2637size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2638ret = 0;
2639e = der_put_octet_string(p, len, &(data)->opaque, &l);
2640if (e) return e;
2641p -= l; len -= l; ret += l;
2642
2643e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
2644if (e) return e;
2645p -= l; len -= l; ret += l;
2646
2647e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
2648if (e) return e;
2649p -= l; len -= l; ret += l;
2650
2651ret += Top_tag_oldret;
2652}
2653/* flags */
2654{
2655size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2656ret = 0;
2657e = der_put_unsigned(p, len, &(data)->flags, &l);
2658if (e) return e;
2659p -= l; len -= l; ret += l;
2660
2661e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
2662if (e) return e;
2663p -= l; len -= l; ret += l;
2664
2665e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
2666if (e) return e;
2667p -= l; len -= l; ret += l;
2668
2669ret += Top_tag_oldret;
2670}
2671e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
2672if (e) return e;
2673p -= l; len -= l; ret += l;
2674
2675*size = ret;
2676return 0;
2677}
2678
2679int ASN1CALL
2680decode_NTLMInitReply(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, NTLMInitReply *data, size_t *size)
2681{
2682size_t ret = 0;
2683size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2684int e HEIMDAL_UNUSED_ATTRIBUTE;
2685
2686memset(data, 0, sizeof(*data));
2687{
2688size_t Top_datalen, Top_oldlen;
2689Der_type Top_type;
2690e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
2691if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
2692if(e) goto fail;
2693p += l; len -= l; ret += l;
2694Top_oldlen = len;
2695if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2696len = Top_datalen;
2697{
2698size_t flags_datalen, flags_oldlen;
2699Der_type flags_type;
2700e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &flags_type, 0, &flags_datalen, &l);
2701if (e == 0 && flags_type != CONS) { e = ASN1_BAD_ID; }
2702if(e) goto fail;
2703p += l; len -= l; ret += l;
2704flags_oldlen = len;
2705if (flags_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2706len = flags_datalen;
2707{
2708size_t flags_Tag_datalen, flags_Tag_oldlen;
2709Der_type flags_Tag_type;
2710e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &flags_Tag_type, UT_Integer, &flags_Tag_datalen, &l);
2711if (e == 0 && flags_Tag_type != PRIM) { e = ASN1_BAD_ID; }
2712if(e) goto fail;
2713p += l; len -= l; ret += l;
2714flags_Tag_oldlen = len;
2715if (flags_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2716len = flags_Tag_datalen;
2717e = der_get_unsigned(p, len, &(data)->flags, &l);
2718if(e) goto fail;
2719p += l; len -= l; ret += l;
2720len = flags_Tag_oldlen - flags_Tag_datalen;
2721}
2722len = flags_oldlen - flags_datalen;
2723}
2724{
2725size_t opaque_datalen, opaque_oldlen;
2726Der_type opaque_type;
2727e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &opaque_type, 1, &opaque_datalen, &l);
2728if (e == 0 && opaque_type != CONS) { e = ASN1_BAD_ID; }
2729if(e) goto fail;
2730p += l; len -= l; ret += l;
2731opaque_oldlen = len;
2732if (opaque_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2733len = opaque_datalen;
2734{
2735size_t opaque_Tag_datalen, opaque_Tag_oldlen;
2736Der_type opaque_Tag_type;
2737e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &opaque_Tag_type, UT_OctetString, &opaque_Tag_datalen, &l);
2738if (e == 0 && opaque_Tag_type != PRIM) { e = ASN1_BAD_ID; }
2739if(e) goto fail;
2740p += l; len -= l; ret += l;
2741opaque_Tag_oldlen = len;
2742if (opaque_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2743len = opaque_Tag_datalen;
2744e = der_get_octet_string(p, len, &(data)->opaque, &l);
2745if(e) goto fail;
2746p += l; len -= l; ret += l;
2747len = opaque_Tag_oldlen - opaque_Tag_datalen;
2748}
2749len = opaque_oldlen - opaque_datalen;
2750}
2751{
2752size_t targetname_datalen, targetname_oldlen;
2753Der_type targetname_type;
2754e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &targetname_type, 2, &targetname_datalen, &l);
2755if (e == 0 && targetname_type != CONS) { e = ASN1_BAD_ID; }
2756if(e) goto fail;
2757p += l; len -= l; ret += l;
2758targetname_oldlen = len;
2759if (targetname_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2760len = targetname_datalen;
2761{
2762size_t targetname_Tag_datalen, targetname_Tag_oldlen;
2763Der_type targetname_Tag_type;
2764e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &targetname_Tag_type, UT_UTF8String, &targetname_Tag_datalen, &l);
2765if (e == 0 && targetname_Tag_type != PRIM) { e = ASN1_BAD_ID; }
2766if(e) goto fail;
2767p += l; len -= l; ret += l;
2768targetname_Tag_oldlen = len;
2769if (targetname_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2770len = targetname_Tag_datalen;
2771e = der_get_utf8string(p, len, &(data)->targetname, &l);
2772if(e) goto fail;
2773p += l; len -= l; ret += l;
2774len = targetname_Tag_oldlen - targetname_Tag_datalen;
2775}
2776len = targetname_oldlen - targetname_datalen;
2777}
2778{
2779size_t challenge_datalen, challenge_oldlen;
2780Der_type challenge_type;
2781e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &challenge_type, 3, &challenge_datalen, &l);
2782if (e == 0 && challenge_type != CONS) { e = ASN1_BAD_ID; }
2783if(e) goto fail;
2784p += l; len -= l; ret += l;
2785challenge_oldlen = len;
2786if (challenge_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2787len = challenge_datalen;
2788{
2789size_t challenge_Tag_datalen, challenge_Tag_oldlen;
2790Der_type challenge_Tag_type;
2791e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &challenge_Tag_type, UT_OctetString, &challenge_Tag_datalen, &l);
2792if (e == 0 && challenge_Tag_type != PRIM) { e = ASN1_BAD_ID; }
2793if(e) goto fail;
2794p += l; len -= l; ret += l;
2795challenge_Tag_oldlen = len;
2796if (challenge_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2797len = challenge_Tag_datalen;
2798e = der_get_octet_string(p, len, &(data)->challenge, &l);
2799if(e) goto fail;
2800p += l; len -= l; ret += l;
2801len = challenge_Tag_oldlen - challenge_Tag_datalen;
2802}
2803len = challenge_oldlen - challenge_datalen;
2804}
2805{
2806size_t targetinfo_datalen, targetinfo_oldlen;
2807Der_type targetinfo_type;
2808e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &targetinfo_type, 4, &targetinfo_datalen, &l);
2809if (e == 0 && targetinfo_type != CONS) { e = ASN1_BAD_ID; }
2810if(e) {
2811(data)->targetinfo = NULL;
2812} else {
2813(data)->targetinfo = calloc(1, sizeof(*(data)->targetinfo));
2814if ((data)->targetinfo == NULL) { e = ENOMEM; goto fail; }
2815p += l; len -= l; ret += l;
2816targetinfo_oldlen = len;
2817if (targetinfo_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2818len = targetinfo_datalen;
2819{
2820size_t targetinfo_Tag_datalen, targetinfo_Tag_oldlen;
2821Der_type targetinfo_Tag_type;
2822e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &targetinfo_Tag_type, UT_OctetString, &targetinfo_Tag_datalen, &l);
2823if (e == 0 && targetinfo_Tag_type != PRIM) { e = ASN1_BAD_ID; }
2824if(e) goto fail;
2825p += l; len -= l; ret += l;
2826targetinfo_Tag_oldlen = len;
2827if (targetinfo_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2828len = targetinfo_Tag_datalen;
2829e = der_get_octet_string(p, len, (data)->targetinfo, &l);
2830if(e) goto fail;
2831p += l; len -= l; ret += l;
2832len = targetinfo_Tag_oldlen - targetinfo_Tag_datalen;
2833}
2834len = targetinfo_oldlen - targetinfo_datalen;
2835}
2836}
2837len = Top_oldlen - Top_datalen;
2838}
2839if(size) *size = ret;
2840return 0;
2841fail:
2842free_NTLMInitReply(data);
2843return e;
2844}
2845
2846void ASN1CALL
2847free_NTLMInitReply(NTLMInitReply *data)
2848{
2849der_free_octet_string(&(data)->opaque);
2850der_free_utf8string(&(data)->targetname);
2851der_free_octet_string(&(data)->challenge);
2852if((data)->targetinfo) {
2853der_free_octet_string((data)->targetinfo);
2854free((data)->targetinfo);
2855(data)->targetinfo = NULL;
2856}
2857}
2858
2859size_t ASN1CALL
2860length_NTLMInitReply(const NTLMInitReply *data)
2861{
2862size_t ret = 0;
2863{
2864size_t Top_tag_oldret = ret;
2865ret = 0;
2866ret += der_length_unsigned(&(data)->flags);
2867ret += 1 + der_length_len (ret);
2868ret += 1 + der_length_len (ret);
2869ret += Top_tag_oldret;
2870}
2871{
2872size_t Top_tag_oldret = ret;
2873ret = 0;
2874ret += der_length_octet_string(&(data)->opaque);
2875ret += 1 + der_length_len (ret);
2876ret += 1 + der_length_len (ret);
2877ret += Top_tag_oldret;
2878}
2879{
2880size_t Top_tag_oldret = ret;
2881ret = 0;
2882ret += der_length_utf8string(&(data)->targetname);
2883ret += 1 + der_length_len (ret);
2884ret += 1 + der_length_len (ret);
2885ret += Top_tag_oldret;
2886}
2887{
2888size_t Top_tag_oldret = ret;
2889ret = 0;
2890ret += der_length_octet_string(&(data)->challenge);
2891ret += 1 + der_length_len (ret);
2892ret += 1 + der_length_len (ret);
2893ret += Top_tag_oldret;
2894}
2895if((data)->targetinfo){
2896size_t Top_tag_oldret = ret;
2897ret = 0;
2898ret += der_length_octet_string((data)->targetinfo);
2899ret += 1 + der_length_len (ret);
2900ret += 1 + der_length_len (ret);
2901ret += Top_tag_oldret;
2902}
2903ret += 1 + der_length_len (ret);
2904return ret;
2905}
2906
2907int ASN1CALL
2908copy_NTLMInitReply(const NTLMInitReply *from, NTLMInitReply *to)
2909{
2910memset(to, 0, sizeof(*to));
2911*(&(to)->flags) = *(&(from)->flags);
2912if(der_copy_octet_string(&(from)->opaque, &(to)->opaque)) goto fail;
2913if(der_copy_utf8string(&(from)->targetname, &(to)->targetname)) goto fail;
2914if(der_copy_octet_string(&(from)->challenge, &(to)->challenge)) goto fail;
2915if((from)->targetinfo) {
2916(to)->targetinfo = malloc(sizeof(*(to)->targetinfo));
2917if((to)->targetinfo == NULL) goto fail;
2918if(der_copy_octet_string((from)->targetinfo, (to)->targetinfo)) goto fail;
2919}else
2920(to)->targetinfo = NULL;
2921return 0;
2922fail:
2923free_NTLMInitReply(to);
2924return ENOMEM;
2925}
2926
2927int ASN1CALL
2928encode_NTLMRequest(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const NTLMRequest *data, size_t *size)
2929{
2930size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
2931size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2932int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
2933
2934/* sessionkey */
2935if((data)->sessionkey) {
2936size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2937ret = 0;
2938e = der_put_octet_string(p, len, (data)->sessionkey, &l);
2939if (e) return e;
2940p -= l; len -= l; ret += l;
2941
2942e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
2943if (e) return e;
2944p -= l; len -= l; ret += l;
2945
2946e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 7, &l);
2947if (e) return e;
2948p -= l; len -= l; ret += l;
2949
2950ret += Top_tag_oldret;
2951}
2952/* ntlm */
2953{
2954size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2955ret = 0;
2956e = der_put_octet_string(p, len, &(data)->ntlm, &l);
2957if (e) return e;
2958p -= l; len -= l; ret += l;
2959
2960e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
2961if (e) return e;
2962p -= l; len -= l; ret += l;
2963
2964e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 6, &l);
2965if (e) return e;
2966p -= l; len -= l; ret += l;
2967
2968ret += Top_tag_oldret;
2969}
2970/* lm */
2971{
2972size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2973ret = 0;
2974e = der_put_octet_string(p, len, &(data)->lm, &l);
2975if (e) return e;
2976p -= l; len -= l; ret += l;
2977
2978e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
2979if (e) return e;
2980p -= l; len -= l; ret += l;
2981
2982e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 5, &l);
2983if (e) return e;
2984p -= l; len -= l; ret += l;
2985
2986ret += Top_tag_oldret;
2987}
2988/* targetinfo */
2989if((data)->targetinfo) {
2990size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2991ret = 0;
2992e = der_put_octet_string(p, len, (data)->targetinfo, &l);
2993if (e) return e;
2994p -= l; len -= l; ret += l;
2995
2996e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
2997if (e) return e;
2998p -= l; len -= l; ret += l;
2999
3000e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 4, &l);
3001if (e) return e;
3002p -= l; len -= l; ret += l;
3003
3004ret += Top_tag_oldret;
3005}
3006/* targetname */
3007{
3008size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3009ret = 0;
3010e = der_put_utf8string(p, len, &(data)->targetname, &l);
3011if (e) return e;
3012p -= l; len -= l; ret += l;
3013
3014e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_UTF8String, &l);
3015if (e) return e;
3016p -= l; len -= l; ret += l;
3017
3018e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
3019if (e) return e;
3020p -= l; len -= l; ret += l;
3021
3022ret += Top_tag_oldret;
3023}
3024/* username */
3025{
3026size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3027ret = 0;
3028e = der_put_utf8string(p, len, &(data)->username, &l);
3029if (e) return e;
3030p -= l; len -= l; ret += l;
3031
3032e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_UTF8String, &l);
3033if (e) return e;
3034p -= l; len -= l; ret += l;
3035
3036e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
3037if (e) return e;
3038p -= l; len -= l; ret += l;
3039
3040ret += Top_tag_oldret;
3041}
3042/* opaque */
3043{
3044size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3045ret = 0;
3046e = der_put_octet_string(p, len, &(data)->opaque, &l);
3047if (e) return e;
3048p -= l; len -= l; ret += l;
3049
3050e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
3051if (e) return e;
3052p -= l; len -= l; ret += l;
3053
3054e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
3055if (e) return e;
3056p -= l; len -= l; ret += l;
3057
3058ret += Top_tag_oldret;
3059}
3060/* flags */
3061{
3062size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3063ret = 0;
3064e = der_put_unsigned(p, len, &(data)->flags, &l);
3065if (e) return e;
3066p -= l; len -= l; ret += l;
3067
3068e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
3069if (e) return e;
3070p -= l; len -= l; ret += l;
3071
3072e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
3073if (e) return e;
3074p -= l; len -= l; ret += l;
3075
3076ret += Top_tag_oldret;
3077}
3078e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
3079if (e) return e;
3080p -= l; len -= l; ret += l;
3081
3082*size = ret;
3083return 0;
3084}
3085
3086int ASN1CALL
3087decode_NTLMRequest(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, NTLMRequest *data, size_t *size)
3088{
3089size_t ret = 0;
3090size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3091int e HEIMDAL_UNUSED_ATTRIBUTE;
3092
3093memset(data, 0, sizeof(*data));
3094{
3095size_t Top_datalen, Top_oldlen;
3096Der_type Top_type;
3097e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
3098if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
3099if(e) goto fail;
3100p += l; len -= l; ret += l;
3101Top_oldlen = len;
3102if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3103len = Top_datalen;
3104{
3105size_t flags_datalen, flags_oldlen;
3106Der_type flags_type;
3107e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &flags_type, 0, &flags_datalen, &l);
3108if (e == 0 && flags_type != CONS) { e = ASN1_BAD_ID; }
3109if(e) goto fail;
3110p += l; len -= l; ret += l;
3111flags_oldlen = len;
3112if (flags_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3113len = flags_datalen;
3114{
3115size_t flags_Tag_datalen, flags_Tag_oldlen;
3116Der_type flags_Tag_type;
3117e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &flags_Tag_type, UT_Integer, &flags_Tag_datalen, &l);
3118if (e == 0 && flags_Tag_type != PRIM) { e = ASN1_BAD_ID; }
3119if(e) goto fail;
3120p += l; len -= l; ret += l;
3121flags_Tag_oldlen = len;
3122if (flags_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3123len = flags_Tag_datalen;
3124e = der_get_unsigned(p, len, &(data)->flags, &l);
3125if(e) goto fail;
3126p += l; len -= l; ret += l;
3127len = flags_Tag_oldlen - flags_Tag_datalen;
3128}
3129len = flags_oldlen - flags_datalen;
3130}
3131{
3132size_t opaque_datalen, opaque_oldlen;
3133Der_type opaque_type;
3134e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &opaque_type, 1, &opaque_datalen, &l);
3135if (e == 0 && opaque_type != CONS) { e = ASN1_BAD_ID; }
3136if(e) goto fail;
3137p += l; len -= l; ret += l;
3138opaque_oldlen = len;
3139if (opaque_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3140len = opaque_datalen;
3141{
3142size_t opaque_Tag_datalen, opaque_Tag_oldlen;
3143Der_type opaque_Tag_type;
3144e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &opaque_Tag_type, UT_OctetString, &opaque_Tag_datalen, &l);
3145if (e == 0 && opaque_Tag_type != PRIM) { e = ASN1_BAD_ID; }
3146if(e) goto fail;
3147p += l; len -= l; ret += l;
3148opaque_Tag_oldlen = len;
3149if (opaque_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3150len = opaque_Tag_datalen;
3151e = der_get_octet_string(p, len, &(data)->opaque, &l);
3152if(e) goto fail;
3153p += l; len -= l; ret += l;
3154len = opaque_Tag_oldlen - opaque_Tag_datalen;
3155}
3156len = opaque_oldlen - opaque_datalen;
3157}
3158{
3159size_t username_datalen, username_oldlen;
3160Der_type username_type;
3161e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &username_type, 2, &username_datalen, &l);
3162if (e == 0 && username_type != CONS) { e = ASN1_BAD_ID; }
3163if(e) goto fail;
3164p += l; len -= l; ret += l;
3165username_oldlen = len;
3166if (username_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3167len = username_datalen;
3168{
3169size_t username_Tag_datalen, username_Tag_oldlen;
3170Der_type username_Tag_type;
3171e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &username_Tag_type, UT_UTF8String, &username_Tag_datalen, &l);
3172if (e == 0 && username_Tag_type != PRIM) { e = ASN1_BAD_ID; }
3173if(e) goto fail;
3174p += l; len -= l; ret += l;
3175username_Tag_oldlen = len;
3176if (username_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3177len = username_Tag_datalen;
3178e = der_get_utf8string(p, len, &(data)->username, &l);
3179if(e) goto fail;
3180p += l; len -= l; ret += l;
3181len = username_Tag_oldlen - username_Tag_datalen;
3182}
3183len = username_oldlen - username_datalen;
3184}
3185{
3186size_t targetname_datalen, targetname_oldlen;
3187Der_type targetname_type;
3188e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &targetname_type, 3, &targetname_datalen, &l);
3189if (e == 0 && targetname_type != CONS) { e = ASN1_BAD_ID; }
3190if(e) goto fail;
3191p += l; len -= l; ret += l;
3192targetname_oldlen = len;
3193if (targetname_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3194len = targetname_datalen;
3195{
3196size_t targetname_Tag_datalen, targetname_Tag_oldlen;
3197Der_type targetname_Tag_type;
3198e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &targetname_Tag_type, UT_UTF8String, &targetname_Tag_datalen, &l);
3199if (e == 0 && targetname_Tag_type != PRIM) { e = ASN1_BAD_ID; }
3200if(e) goto fail;
3201p += l; len -= l; ret += l;
3202targetname_Tag_oldlen = len;
3203if (targetname_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3204len = targetname_Tag_datalen;
3205e = der_get_utf8string(p, len, &(data)->targetname, &l);
3206if(e) goto fail;
3207p += l; len -= l; ret += l;
3208len = targetname_Tag_oldlen - targetname_Tag_datalen;
3209}
3210len = targetname_oldlen - targetname_datalen;
3211}
3212{
3213size_t targetinfo_datalen, targetinfo_oldlen;
3214Der_type targetinfo_type;
3215e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &targetinfo_type, 4, &targetinfo_datalen, &l);
3216if (e == 0 && targetinfo_type != CONS) { e = ASN1_BAD_ID; }
3217if(e) {
3218(data)->targetinfo = NULL;
3219} else {
3220(data)->targetinfo = calloc(1, sizeof(*(data)->targetinfo));
3221if ((data)->targetinfo == NULL) { e = ENOMEM; goto fail; }
3222p += l; len -= l; ret += l;
3223targetinfo_oldlen = len;
3224if (targetinfo_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3225len = targetinfo_datalen;
3226{
3227size_t targetinfo_Tag_datalen, targetinfo_Tag_oldlen;
3228Der_type targetinfo_Tag_type;
3229e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &targetinfo_Tag_type, UT_OctetString, &targetinfo_Tag_datalen, &l);
3230if (e == 0 && targetinfo_Tag_type != PRIM) { e = ASN1_BAD_ID; }
3231if(e) goto fail;
3232p += l; len -= l; ret += l;
3233targetinfo_Tag_oldlen = len;
3234if (targetinfo_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3235len = targetinfo_Tag_datalen;
3236e = der_get_octet_string(p, len, (data)->targetinfo, &l);
3237if(e) goto fail;
3238p += l; len -= l; ret += l;
3239len = targetinfo_Tag_oldlen - targetinfo_Tag_datalen;
3240}
3241len = targetinfo_oldlen - targetinfo_datalen;
3242}
3243}
3244{
3245size_t lm_datalen, lm_oldlen;
3246Der_type lm_type;
3247e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &lm_type, 5, &lm_datalen, &l);
3248if (e == 0 && lm_type != CONS) { e = ASN1_BAD_ID; }
3249if(e) goto fail;
3250p += l; len -= l; ret += l;
3251lm_oldlen = len;
3252if (lm_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3253len = lm_datalen;
3254{
3255size_t lm_Tag_datalen, lm_Tag_oldlen;
3256Der_type lm_Tag_type;
3257e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &lm_Tag_type, UT_OctetString, &lm_Tag_datalen, &l);
3258if (e == 0 && lm_Tag_type != PRIM) { e = ASN1_BAD_ID; }
3259if(e) goto fail;
3260p += l; len -= l; ret += l;
3261lm_Tag_oldlen = len;
3262if (lm_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3263len = lm_Tag_datalen;
3264e = der_get_octet_string(p, len, &(data)->lm, &l);
3265if(e) goto fail;
3266p += l; len -= l; ret += l;
3267len = lm_Tag_oldlen - lm_Tag_datalen;
3268}
3269len = lm_oldlen - lm_datalen;
3270}
3271{
3272size_t ntlm_datalen, ntlm_oldlen;
3273Der_type ntlm_type;
3274e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &ntlm_type, 6, &ntlm_datalen, &l);
3275if (e == 0 && ntlm_type != CONS) { e = ASN1_BAD_ID; }
3276if(e) goto fail;
3277p += l; len -= l; ret += l;
3278ntlm_oldlen = len;
3279if (ntlm_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3280len = ntlm_datalen;
3281{
3282size_t ntlm_Tag_datalen, ntlm_Tag_oldlen;
3283Der_type ntlm_Tag_type;
3284e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &ntlm_Tag_type, UT_OctetString, &ntlm_Tag_datalen, &l);
3285if (e == 0 && ntlm_Tag_type != PRIM) { e = ASN1_BAD_ID; }
3286if(e) goto fail;
3287p += l; len -= l; ret += l;
3288ntlm_Tag_oldlen = len;
3289if (ntlm_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3290len = ntlm_Tag_datalen;
3291e = der_get_octet_string(p, len, &(data)->ntlm, &l);
3292if(e) goto fail;
3293p += l; len -= l; ret += l;
3294len = ntlm_Tag_oldlen - ntlm_Tag_datalen;
3295}
3296len = ntlm_oldlen - ntlm_datalen;
3297}
3298{
3299size_t sessionkey_datalen, sessionkey_oldlen;
3300Der_type sessionkey_type;
3301e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &sessionkey_type, 7, &sessionkey_datalen, &l);
3302if (e == 0 && sessionkey_type != CONS) { e = ASN1_BAD_ID; }
3303if(e) {
3304(data)->sessionkey = NULL;
3305} else {
3306(data)->sessionkey = calloc(1, sizeof(*(data)->sessionkey));
3307if ((data)->sessionkey == NULL) { e = ENOMEM; goto fail; }
3308p += l; len -= l; ret += l;
3309sessionkey_oldlen = len;
3310if (sessionkey_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3311len = sessionkey_datalen;
3312{
3313size_t sessionkey_Tag_datalen, sessionkey_Tag_oldlen;
3314Der_type sessionkey_Tag_type;
3315e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &sessionkey_Tag_type, UT_OctetString, &sessionkey_Tag_datalen, &l);
3316if (e == 0 && sessionkey_Tag_type != PRIM) { e = ASN1_BAD_ID; }
3317if(e) goto fail;
3318p += l; len -= l; ret += l;
3319sessionkey_Tag_oldlen = len;
3320if (sessionkey_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3321len = sessionkey_Tag_datalen;
3322e = der_get_octet_string(p, len, (data)->sessionkey, &l);
3323if(e) goto fail;
3324p += l; len -= l; ret += l;
3325len = sessionkey_Tag_oldlen - sessionkey_Tag_datalen;
3326}
3327len = sessionkey_oldlen - sessionkey_datalen;
3328}
3329}
3330len = Top_oldlen - Top_datalen;
3331}
3332if(size) *size = ret;
3333return 0;
3334fail:
3335free_NTLMRequest(data);
3336return e;
3337}
3338
3339void ASN1CALL
3340free_NTLMRequest(NTLMRequest *data)
3341{
3342der_free_octet_string(&(data)->opaque);
3343der_free_utf8string(&(data)->username);
3344der_free_utf8string(&(data)->targetname);
3345if((data)->targetinfo) {
3346der_free_octet_string((data)->targetinfo);
3347free((data)->targetinfo);
3348(data)->targetinfo = NULL;
3349}
3350der_free_octet_string(&(data)->lm);
3351der_free_octet_string(&(data)->ntlm);
3352if((data)->sessionkey) {
3353der_free_octet_string((data)->sessionkey);
3354free((data)->sessionkey);
3355(data)->sessionkey = NULL;
3356}
3357}
3358
3359size_t ASN1CALL
3360length_NTLMRequest(const NTLMRequest *data)
3361{
3362size_t ret = 0;
3363{
3364size_t Top_tag_oldret = ret;
3365ret = 0;
3366ret += der_length_unsigned(&(data)->flags);
3367ret += 1 + der_length_len (ret);
3368ret += 1 + der_length_len (ret);
3369ret += Top_tag_oldret;
3370}
3371{
3372size_t Top_tag_oldret = ret;
3373ret = 0;
3374ret += der_length_octet_string(&(data)->opaque);
3375ret += 1 + der_length_len (ret);
3376ret += 1 + der_length_len (ret);
3377ret += Top_tag_oldret;
3378}
3379{
3380size_t Top_tag_oldret = ret;
3381ret = 0;
3382ret += der_length_utf8string(&(data)->username);
3383ret += 1 + der_length_len (ret);
3384ret += 1 + der_length_len (ret);
3385ret += Top_tag_oldret;
3386}
3387{
3388size_t Top_tag_oldret = ret;
3389ret = 0;
3390ret += der_length_utf8string(&(data)->targetname);
3391ret += 1 + der_length_len (ret);
3392ret += 1 + der_length_len (ret);
3393ret += Top_tag_oldret;
3394}
3395if((data)->targetinfo){
3396size_t Top_tag_oldret = ret;
3397ret = 0;
3398ret += der_length_octet_string((data)->targetinfo);
3399ret += 1 + der_length_len (ret);
3400ret += 1 + der_length_len (ret);
3401ret += Top_tag_oldret;
3402}
3403{
3404size_t Top_tag_oldret = ret;
3405ret = 0;
3406ret += der_length_octet_string(&(data)->lm);
3407ret += 1 + der_length_len (ret);
3408ret += 1 + der_length_len (ret);
3409ret += Top_tag_oldret;
3410}
3411{
3412size_t Top_tag_oldret = ret;
3413ret = 0;
3414ret += der_length_octet_string(&(data)->ntlm);
3415ret += 1 + der_length_len (ret);
3416ret += 1 + der_length_len (ret);
3417ret += Top_tag_oldret;
3418}
3419if((data)->sessionkey){
3420size_t Top_tag_oldret = ret;
3421ret = 0;
3422ret += der_length_octet_string((data)->sessionkey);
3423ret += 1 + der_length_len (ret);
3424ret += 1 + der_length_len (ret);
3425ret += Top_tag_oldret;
3426}
3427ret += 1 + der_length_len (ret);
3428return ret;
3429}
3430
3431int ASN1CALL
3432copy_NTLMRequest(const NTLMRequest *from, NTLMRequest *to)
3433{
3434memset(to, 0, sizeof(*to));
3435*(&(to)->flags) = *(&(from)->flags);
3436if(der_copy_octet_string(&(from)->opaque, &(to)->opaque)) goto fail;
3437if(der_copy_utf8string(&(from)->username, &(to)->username)) goto fail;
3438if(der_copy_utf8string(&(from)->targetname, &(to)->targetname)) goto fail;
3439if((from)->targetinfo) {
3440(to)->targetinfo = malloc(sizeof(*(to)->targetinfo));
3441if((to)->targetinfo == NULL) goto fail;
3442if(der_copy_octet_string((from)->targetinfo, (to)->targetinfo)) goto fail;
3443}else
3444(to)->targetinfo = NULL;
3445if(der_copy_octet_string(&(from)->lm, &(to)->lm)) goto fail;
3446if(der_copy_octet_string(&(from)->ntlm, &(to)->ntlm)) goto fail;
3447if((from)->sessionkey) {
3448(to)->sessionkey = malloc(sizeof(*(to)->sessionkey));
3449if((to)->sessionkey == NULL) goto fail;
3450if(der_copy_octet_string((from)->sessionkey, (to)->sessionkey)) goto fail;
3451}else
3452(to)->sessionkey = NULL;
3453return 0;
3454fail:
3455free_NTLMRequest(to);
3456return ENOMEM;
3457}
3458
3459int ASN1CALL
3460encode_NTLMResponse(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const NTLMResponse *data, size_t *size)
3461{
3462size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
3463size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3464int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
3465
3466/* tickets */
3467if((data)->tickets) {
3468size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3469ret = 0;
3470for(i = (int)((data)->tickets)->len - 1; i >= 0; --i) {
3471size_t tickets_tag_tag_for_oldret = ret;
3472ret = 0;
3473e = der_put_octet_string(p, len, &((data)->tickets)->val[i], &l);
3474if (e) return e;
3475p -= l; len -= l; ret += l;
3476
3477e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
3478if (e) return e;
3479p -= l; len -= l; ret += l;
3480
3481ret += tickets_tag_tag_for_oldret;
3482}
3483e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
3484if (e) return e;
3485p -= l; len -= l; ret += l;
3486
3487e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
3488if (e) return e;
3489p -= l; len -= l; ret += l;
3490
3491ret += Top_tag_oldret;
3492}
3493/* sessionkey */
3494if((data)->sessionkey) {
3495size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3496ret = 0;
3497e = der_put_octet_string(p, len, (data)->sessionkey, &l);
3498if (e) return e;
3499p -= l; len -= l; ret += l;
3500
3501e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
3502if (e) return e;
3503p -= l; len -= l; ret += l;
3504
3505e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
3506if (e) return e;
3507p -= l; len -= l; ret += l;
3508
3509ret += Top_tag_oldret;
3510}
3511/* flags */
3512{
3513size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3514ret = 0;
3515e = der_put_unsigned(p, len, &(data)->flags, &l);
3516if (e) return e;
3517p -= l; len -= l; ret += l;
3518
3519e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
3520if (e) return e;
3521p -= l; len -= l; ret += l;
3522
3523e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
3524if (e) return e;
3525p -= l; len -= l; ret += l;
3526
3527ret += Top_tag_oldret;
3528}
3529/* success */
3530{
3531size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3532ret = 0;
3533e = der_put_boolean(p, len, &(data)->success, &l);
3534if (e) return e;
3535p -= l; len -= l; ret += l;
3536
3537e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Boolean, &l);
3538if (e) return e;
3539p -= l; len -= l; ret += l;
3540
3541e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
3542if (e) return e;
3543p -= l; len -= l; ret += l;
3544
3545ret += Top_tag_oldret;
3546}
3547e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
3548if (e) return e;
3549p -= l; len -= l; ret += l;
3550
3551*size = ret;
3552return 0;
3553}
3554
3555int ASN1CALL
3556decode_NTLMResponse(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, NTLMResponse *data, size_t *size)
3557{
3558size_t ret = 0;
3559size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3560int e HEIMDAL_UNUSED_ATTRIBUTE;
3561
3562memset(data, 0, sizeof(*data));
3563{
3564size_t Top_datalen, Top_oldlen;
3565Der_type Top_type;
3566e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
3567if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
3568if(e) goto fail;
3569p += l; len -= l; ret += l;
3570Top_oldlen = len;
3571if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3572len = Top_datalen;
3573{
3574size_t success_datalen, success_oldlen;
3575Der_type success_type;
3576e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &success_type, 0, &success_datalen, &l);
3577if (e == 0 && success_type != CONS) { e = ASN1_BAD_ID; }
3578if(e) goto fail;
3579p += l; len -= l; ret += l;
3580success_oldlen = len;
3581if (success_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3582len = success_datalen;
3583{
3584size_t success_Tag_datalen, success_Tag_oldlen;
3585Der_type success_Tag_type;
3586e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &success_Tag_type, UT_Boolean, &success_Tag_datalen, &l);
3587if (e == 0 && success_Tag_type != PRIM) { e = ASN1_BAD_ID; }
3588if(e) goto fail;
3589p += l; len -= l; ret += l;
3590success_Tag_oldlen = len;
3591if (success_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3592len = success_Tag_datalen;
3593e = der_get_boolean(p, len, &(data)->success, &l);
3594if(e) goto fail;
3595p += l; len -= l; ret += l;
3596len = success_Tag_oldlen - success_Tag_datalen;
3597}
3598len = success_oldlen - success_datalen;
3599}
3600{
3601size_t flags_datalen, flags_oldlen;
3602Der_type flags_type;
3603e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &flags_type, 1, &flags_datalen, &l);
3604if (e == 0 && flags_type != CONS) { e = ASN1_BAD_ID; }
3605if(e) goto fail;
3606p += l; len -= l; ret += l;
3607flags_oldlen = len;
3608if (flags_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3609len = flags_datalen;
3610{
3611size_t flags_Tag_datalen, flags_Tag_oldlen;
3612Der_type flags_Tag_type;
3613e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &flags_Tag_type, UT_Integer, &flags_Tag_datalen, &l);
3614if (e == 0 && flags_Tag_type != PRIM) { e = ASN1_BAD_ID; }
3615if(e) goto fail;
3616p += l; len -= l; ret += l;
3617flags_Tag_oldlen = len;
3618if (flags_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3619len = flags_Tag_datalen;
3620e = der_get_unsigned(p, len, &(data)->flags, &l);
3621if(e) goto fail;
3622p += l; len -= l; ret += l;
3623len = flags_Tag_oldlen - flags_Tag_datalen;
3624}
3625len = flags_oldlen - flags_datalen;
3626}
3627{
3628size_t sessionkey_datalen, sessionkey_oldlen;
3629Der_type sessionkey_type;
3630e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &sessionkey_type, 2, &sessionkey_datalen, &l);
3631if (e == 0 && sessionkey_type != CONS) { e = ASN1_BAD_ID; }
3632if(e) {
3633(data)->sessionkey = NULL;
3634} else {
3635(data)->sessionkey = calloc(1, sizeof(*(data)->sessionkey));
3636if ((data)->sessionkey == NULL) { e = ENOMEM; goto fail; }
3637p += l; len -= l; ret += l;
3638sessionkey_oldlen = len;
3639if (sessionkey_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3640len = sessionkey_datalen;
3641{
3642size_t sessionkey_Tag_datalen, sessionkey_Tag_oldlen;
3643Der_type sessionkey_Tag_type;
3644e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &sessionkey_Tag_type, UT_OctetString, &sessionkey_Tag_datalen, &l);
3645if (e == 0 && sessionkey_Tag_type != PRIM) { e = ASN1_BAD_ID; }
3646if(e) goto fail;
3647p += l; len -= l; ret += l;
3648sessionkey_Tag_oldlen = len;
3649if (sessionkey_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3650len = sessionkey_Tag_datalen;
3651e = der_get_octet_string(p, len, (data)->sessionkey, &l);
3652if(e) goto fail;
3653p += l; len -= l; ret += l;
3654len = sessionkey_Tag_oldlen - sessionkey_Tag_datalen;
3655}
3656len = sessionkey_oldlen - sessionkey_datalen;
3657}
3658}
3659{
3660size_t tickets_datalen, tickets_oldlen;
3661Der_type tickets_type;
3662e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &tickets_type, 3, &tickets_datalen, &l);
3663if (e == 0 && tickets_type != CONS) { e = ASN1_BAD_ID; }
3664if(e) {
3665(data)->tickets = NULL;
3666} else {
3667(data)->tickets = calloc(1, sizeof(*(data)->tickets));
3668if ((data)->tickets == NULL) { e = ENOMEM; goto fail; }
3669p += l; len -= l; ret += l;
3670tickets_oldlen = len;
3671if (tickets_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3672len = tickets_datalen;
3673{
3674size_t tickets_Tag_datalen, tickets_Tag_oldlen;
3675Der_type tickets_Tag_type;
3676e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &tickets_Tag_type, UT_Sequence, &tickets_Tag_datalen, &l);
3677if (e == 0 && tickets_Tag_type != CONS) { e = ASN1_BAD_ID; }
3678if(e) goto fail;
3679p += l; len -= l; ret += l;
3680tickets_Tag_oldlen = len;
3681if (tickets_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3682len = tickets_Tag_datalen;
3683{
3684size_t tickets_Tag_Tag_origlen = len;
3685size_t tickets_Tag_Tag_oldret = ret;
3686size_t tickets_Tag_Tag_olen = 0;
3687void *tickets_Tag_Tag_tmp;
3688ret = 0;
3689((data)->tickets)->len = 0;
3690((data)->tickets)->val = NULL;
3691while(ret < tickets_Tag_Tag_origlen) {
3692size_t tickets_Tag_Tag_nlen = tickets_Tag_Tag_olen + sizeof(*(((data)->tickets)->val));
3693if (tickets_Tag_Tag_olen > tickets_Tag_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
3694tickets_Tag_Tag_olen = tickets_Tag_Tag_nlen;
3695tickets_Tag_Tag_tmp = realloc(((data)->tickets)->val, tickets_Tag_Tag_olen);
3696if (tickets_Tag_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
3697((data)->tickets)->val = tickets_Tag_Tag_tmp;
3698{
3699size_t tickets_Tag_Tag_s_of_datalen, tickets_Tag_Tag_s_of_oldlen;
3700Der_type tickets_Tag_Tag_s_of_type;
3701e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &tickets_Tag_Tag_s_of_type, UT_OctetString, &tickets_Tag_Tag_s_of_datalen, &l);
3702if (e == 0 && tickets_Tag_Tag_s_of_type != PRIM) { e = ASN1_BAD_ID; }
3703if(e) goto fail;
3704p += l; len -= l; ret += l;
3705tickets_Tag_Tag_s_of_oldlen = len;
3706if (tickets_Tag_Tag_s_of_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3707len = tickets_Tag_Tag_s_of_datalen;
3708e = der_get_octet_string(p, len, &((data)->tickets)->val[((data)->tickets)->len], &l);
3709if(e) goto fail;
3710p += l; len -= l; ret += l;
3711len = tickets_Tag_Tag_s_of_oldlen - tickets_Tag_Tag_s_of_datalen;
3712}
3713((data)->tickets)->len++;
3714len = tickets_Tag_Tag_origlen - ret;
3715}
3716ret += tickets_Tag_Tag_oldret;
3717}
3718len = tickets_Tag_oldlen - tickets_Tag_datalen;
3719}
3720len = tickets_oldlen - tickets_datalen;
3721}
3722}
3723len = Top_oldlen - Top_datalen;
3724}
3725if(size) *size = ret;
3726return 0;
3727fail:
3728free_NTLMResponse(data);
3729return e;
3730}
3731
3732void ASN1CALL
3733free_NTLMResponse(NTLMResponse *data)
3734{
3735if((data)->sessionkey) {
3736der_free_octet_string((data)->sessionkey);
3737free((data)->sessionkey);
3738(data)->sessionkey = NULL;
3739}
3740if((data)->tickets) {
3741while(((data)->tickets)->len){
3742der_free_octet_string(&((data)->tickets)->val[((data)->tickets)->len-1]);
3743((data)->tickets)->len--;
3744}
3745free(((data)->tickets)->val);
3746((data)->tickets)->val = NULL;
3747free((data)->tickets);
3748(data)->tickets = NULL;
3749}
3750}
3751
3752size_t ASN1CALL
3753length_NTLMResponse(const NTLMResponse *data)
3754{
3755size_t ret = 0;
3756{
3757size_t Top_tag_oldret = ret;
3758ret = 0;
3759ret += 1;
3760ret += 1 + der_length_len (ret);
3761ret += 1 + der_length_len (ret);
3762ret += Top_tag_oldret;
3763}
3764{
3765size_t Top_tag_oldret = ret;
3766ret = 0;
3767ret += der_length_unsigned(&(data)->flags);
3768ret += 1 + der_length_len (ret);
3769ret += 1 + der_length_len (ret);
3770ret += Top_tag_oldret;
3771}
3772if((data)->sessionkey){
3773size_t Top_tag_oldret = ret;
3774ret = 0;
3775ret += der_length_octet_string((data)->sessionkey);
3776ret += 1 + der_length_len (ret);
3777ret += 1 + der_length_len (ret);
3778ret += Top_tag_oldret;
3779}
3780if((data)->tickets){
3781size_t Top_tag_oldret = ret;
3782ret = 0;
3783{
3784size_t tickets_tag_tag_oldret = ret;
3785unsigned int n_tickets_tag_tag;
3786ret = 0;
3787for(n_tickets_tag_tag = ((data)->tickets)->len; n_tickets_tag_tag > 0; --n_tickets_tag_tag){
3788size_t tickets_tag_tag_for_oldret = ret;
3789ret = 0;
3790ret += der_length_octet_string(&((data)->tickets)->val[n_tickets_tag_tag - 1]);
3791ret += 1 + der_length_len (ret);
3792ret += tickets_tag_tag_for_oldret;
3793}
3794ret += tickets_tag_tag_oldret;
3795}
3796ret += 1 + der_length_len (ret);
3797ret += 1 + der_length_len (ret);
3798ret += Top_tag_oldret;
3799}
3800ret += 1 + der_length_len (ret);
3801return ret;
3802}
3803
3804int ASN1CALL
3805copy_NTLMResponse(const NTLMResponse *from, NTLMResponse *to)
3806{
3807memset(to, 0, sizeof(*to));
3808*(&(to)->success) = *(&(from)->success);
3809*(&(to)->flags) = *(&(from)->flags);
3810if((from)->sessionkey) {
3811(to)->sessionkey = malloc(sizeof(*(to)->sessionkey));
3812if((to)->sessionkey == NULL) goto fail;
3813if(der_copy_octet_string((from)->sessionkey, (to)->sessionkey)) goto fail;
3814}else
3815(to)->sessionkey = NULL;
3816if((from)->tickets) {
3817(to)->tickets = malloc(sizeof(*(to)->tickets));
3818if((to)->tickets == NULL) goto fail;
3819if((((to)->tickets)->val = malloc(((from)->tickets)->len * sizeof(*((to)->tickets)->val))) == NULL && ((from)->tickets)->len != 0)
3820goto fail;
3821for(((to)->tickets)->len = 0; ((to)->tickets)->len < ((from)->tickets)->len; ((to)->tickets)->len++){
3822if(der_copy_octet_string(&((from)->tickets)->val[((to)->tickets)->len], &((to)->tickets)->val[((to)->tickets)->len])) goto fail;
3823}
3824}else
3825(to)->tickets = NULL;
3826return 0;
3827fail:
3828free_NTLMResponse(to);
3829return ENOMEM;
3830}
3831
3832int ASN1CALL
3833encode_NTLMRequest2(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const NTLMRequest2 *data, size_t *size)
3834{
3835size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
3836size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3837int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
3838
3839/* lmChallengeResponce */
3840{
3841size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3842ret = 0;
3843e = der_put_octet_string(p, len, &(data)->lmChallengeResponce, &l);
3844if (e) return e;
3845p -= l; len -= l; ret += l;
3846
3847e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
3848if (e) return e;
3849p -= l; len -= l; ret += l;
3850
3851e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 5, &l);
3852if (e) return e;
3853p -= l; len -= l; ret += l;
3854
3855ret += Top_tag_oldret;
3856}
3857/* ntChallengeResponce */
3858{
3859size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3860ret = 0;
3861e = der_put_octet_string(p, len, &(data)->ntChallengeResponce, &l);
3862if (e) return e;
3863p -= l; len -= l; ret += l;
3864
3865e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
3866if (e) return e;
3867p -= l; len -= l; ret += l;
3868
3869e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 4, &l);
3870if (e) return e;
3871p -= l; len -= l; ret += l;
3872
3873ret += Top_tag_oldret;
3874}
3875/* lmchallenge */
3876{
3877size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3878ret = 0;
3879e = der_put_octet_string(p, len, &(data)->lmchallenge, &l);
3880if (e) return e;
3881p -= l; len -= l; ret += l;
3882
3883e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
3884if (e) return e;
3885p -= l; len -= l; ret += l;
3886
3887e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
3888if (e) return e;
3889p -= l; len -= l; ret += l;
3890
3891ret += Top_tag_oldret;
3892}
3893/* flags */
3894{
3895size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3896ret = 0;
3897e = der_put_unsigned(p, len, &(data)->flags, &l);
3898if (e) return e;
3899p -= l; len -= l; ret += l;
3900
3901e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
3902if (e) return e;
3903p -= l; len -= l; ret += l;
3904
3905e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
3906if (e) return e;
3907p -= l; len -= l; ret += l;
3908
3909ret += Top_tag_oldret;
3910}
3911/* loginDomainName */
3912{
3913size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3914ret = 0;
3915e = der_put_utf8string(p, len, &(data)->loginDomainName, &l);
3916if (e) return e;
3917p -= l; len -= l; ret += l;
3918
3919e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_UTF8String, &l);
3920if (e) return e;
3921p -= l; len -= l; ret += l;
3922
3923e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
3924if (e) return e;
3925p -= l; len -= l; ret += l;
3926
3927ret += Top_tag_oldret;
3928}
3929/* loginUserName */
3930{
3931size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3932ret = 0;
3933e = der_put_utf8string(p, len, &(data)->loginUserName, &l);
3934if (e) return e;
3935p -= l; len -= l; ret += l;
3936
3937e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_UTF8String, &l);
3938if (e) return e;
3939p -= l; len -= l; ret += l;
3940
3941e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
3942if (e) return e;
3943p -= l; len -= l; ret += l;
3944
3945ret += Top_tag_oldret;
3946}
3947e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
3948if (e) return e;
3949p -= l; len -= l; ret += l;
3950
3951*size = ret;
3952return 0;
3953}
3954
3955int ASN1CALL
3956decode_NTLMRequest2(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, NTLMRequest2 *data, size_t *size)
3957{
3958size_t ret = 0;
3959size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3960int e HEIMDAL_UNUSED_ATTRIBUTE;
3961
3962memset(data, 0, sizeof(*data));
3963{
3964size_t Top_datalen, Top_oldlen;
3965Der_type Top_type;
3966e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
3967if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
3968if(e) goto fail;
3969p += l; len -= l; ret += l;
3970Top_oldlen = len;
3971if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3972len = Top_datalen;
3973{
3974size_t loginUserName_datalen, loginUserName_oldlen;
3975Der_type loginUserName_type;
3976e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &loginUserName_type, 0, &loginUserName_datalen, &l);
3977if (e == 0 && loginUserName_type != CONS) { e = ASN1_BAD_ID; }
3978if(e) goto fail;
3979p += l; len -= l; ret += l;
3980loginUserName_oldlen = len;
3981if (loginUserName_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3982len = loginUserName_datalen;
3983{
3984size_t loginUserName_Tag_datalen, loginUserName_Tag_oldlen;
3985Der_type loginUserName_Tag_type;
3986e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &loginUserName_Tag_type, UT_UTF8String, &loginUserName_Tag_datalen, &l);
3987if (e == 0 && loginUserName_Tag_type != PRIM) { e = ASN1_BAD_ID; }
3988if(e) goto fail;
3989p += l; len -= l; ret += l;
3990loginUserName_Tag_oldlen = len;
3991if (loginUserName_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3992len = loginUserName_Tag_datalen;
3993e = der_get_utf8string(p, len, &(data)->loginUserName, &l);
3994if(e) goto fail;
3995p += l; len -= l; ret += l;
3996len = loginUserName_Tag_oldlen - loginUserName_Tag_datalen;
3997}
3998len = loginUserName_oldlen - loginUserName_datalen;
3999}
4000{
4001size_t loginDomainName_datalen, loginDomainName_oldlen;
4002Der_type loginDomainName_type;
4003e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &loginDomainName_type, 1, &loginDomainName_datalen, &l);
4004if (e == 0 && loginDomainName_type != CONS) { e = ASN1_BAD_ID; }
4005if(e) goto fail;
4006p += l; len -= l; ret += l;
4007loginDomainName_oldlen = len;
4008if (loginDomainName_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4009len = loginDomainName_datalen;
4010{
4011size_t loginDomainName_Tag_datalen, loginDomainName_Tag_oldlen;
4012Der_type loginDomainName_Tag_type;
4013e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &loginDomainName_Tag_type, UT_UTF8String, &loginDomainName_Tag_datalen, &l);
4014if (e == 0 && loginDomainName_Tag_type != PRIM) { e = ASN1_BAD_ID; }
4015if(e) goto fail;
4016p += l; len -= l; ret += l;
4017loginDomainName_Tag_oldlen = len;
4018if (loginDomainName_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4019len = loginDomainName_Tag_datalen;
4020e = der_get_utf8string(p, len, &(data)->loginDomainName, &l);
4021if(e) goto fail;
4022p += l; len -= l; ret += l;
4023len = loginDomainName_Tag_oldlen - loginDomainName_Tag_datalen;
4024}
4025len = loginDomainName_oldlen - loginDomainName_datalen;
4026}
4027{
4028size_t flags_datalen, flags_oldlen;
4029Der_type flags_type;
4030e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &flags_type, 2, &flags_datalen, &l);
4031if (e == 0 && flags_type != CONS) { e = ASN1_BAD_ID; }
4032if(e) goto fail;
4033p += l; len -= l; ret += l;
4034flags_oldlen = len;
4035if (flags_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4036len = flags_datalen;
4037{
4038size_t flags_Tag_datalen, flags_Tag_oldlen;
4039Der_type flags_Tag_type;
4040e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &flags_Tag_type, UT_Integer, &flags_Tag_datalen, &l);
4041if (e == 0 && flags_Tag_type != PRIM) { e = ASN1_BAD_ID; }
4042if(e) goto fail;
4043p += l; len -= l; ret += l;
4044flags_Tag_oldlen = len;
4045if (flags_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4046len = flags_Tag_datalen;
4047e = der_get_unsigned(p, len, &(data)->flags, &l);
4048if(e) goto fail;
4049p += l; len -= l; ret += l;
4050len = flags_Tag_oldlen - flags_Tag_datalen;
4051}
4052len = flags_oldlen - flags_datalen;
4053}
4054{
4055size_t lmchallenge_datalen, lmchallenge_oldlen;
4056Der_type lmchallenge_type;
4057e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &lmchallenge_type, 3, &lmchallenge_datalen, &l);
4058if (e == 0 && lmchallenge_type != CONS) { e = ASN1_BAD_ID; }
4059if(e) goto fail;
4060p += l; len -= l; ret += l;
4061lmchallenge_oldlen = len;
4062if (lmchallenge_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4063len = lmchallenge_datalen;
4064{
4065size_t lmchallenge_Tag_datalen, lmchallenge_Tag_oldlen;
4066Der_type lmchallenge_Tag_type;
4067e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &lmchallenge_Tag_type, UT_OctetString, &lmchallenge_Tag_datalen, &l);
4068if (e == 0 && lmchallenge_Tag_type != PRIM) { e = ASN1_BAD_ID; }
4069if(e) goto fail;
4070p += l; len -= l; ret += l;
4071lmchallenge_Tag_oldlen = len;
4072if (lmchallenge_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4073len = lmchallenge_Tag_datalen;
4074e = der_get_octet_string(p, len, &(data)->lmchallenge, &l);
4075if(e) goto fail;
4076p += l; len -= l; ret += l;
4077if ((&(data)->lmchallenge)->length != 8) {
4078e = ASN1_EXACT_CONSTRAINT; goto fail;
4079}
4080len = lmchallenge_Tag_oldlen - lmchallenge_Tag_datalen;
4081}
4082len = lmchallenge_oldlen - lmchallenge_datalen;
4083}
4084{
4085size_t ntChallengeResponce_datalen, ntChallengeResponce_oldlen;
4086Der_type ntChallengeResponce_type;
4087e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &ntChallengeResponce_type, 4, &ntChallengeResponce_datalen, &l);
4088if (e == 0 && ntChallengeResponce_type != CONS) { e = ASN1_BAD_ID; }
4089if(e) goto fail;
4090p += l; len -= l; ret += l;
4091ntChallengeResponce_oldlen = len;
4092if (ntChallengeResponce_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4093len = ntChallengeResponce_datalen;
4094{
4095size_t ntChallengeResponce_Tag_datalen, ntChallengeResponce_Tag_oldlen;
4096Der_type ntChallengeResponce_Tag_type;
4097e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &ntChallengeResponce_Tag_type, UT_OctetString, &ntChallengeResponce_Tag_datalen, &l);
4098if (e == 0 && ntChallengeResponce_Tag_type != PRIM) { e = ASN1_BAD_ID; }
4099if(e) goto fail;
4100p += l; len -= l; ret += l;
4101ntChallengeResponce_Tag_oldlen = len;
4102if (ntChallengeResponce_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4103len = ntChallengeResponce_Tag_datalen;
4104e = der_get_octet_string(p, len, &(data)->ntChallengeResponce, &l);
4105if(e) goto fail;
4106p += l; len -= l; ret += l;
4107len = ntChallengeResponce_Tag_oldlen - ntChallengeResponce_Tag_datalen;
4108}
4109len = ntChallengeResponce_oldlen - ntChallengeResponce_datalen;
4110}
4111{
4112size_t lmChallengeResponce_datalen, lmChallengeResponce_oldlen;
4113Der_type lmChallengeResponce_type;
4114e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &lmChallengeResponce_type, 5, &lmChallengeResponce_datalen, &l);
4115if (e == 0 && lmChallengeResponce_type != CONS) { e = ASN1_BAD_ID; }
4116if(e) goto fail;
4117p += l; len -= l; ret += l;
4118lmChallengeResponce_oldlen = len;
4119if (lmChallengeResponce_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4120len = lmChallengeResponce_datalen;
4121{
4122size_t lmChallengeResponce_Tag_datalen, lmChallengeResponce_Tag_oldlen;
4123Der_type lmChallengeResponce_Tag_type;
4124e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &lmChallengeResponce_Tag_type, UT_OctetString, &lmChallengeResponce_Tag_datalen, &l);
4125if (e == 0 && lmChallengeResponce_Tag_type != PRIM) { e = ASN1_BAD_ID; }
4126if(e) goto fail;
4127p += l; len -= l; ret += l;
4128lmChallengeResponce_Tag_oldlen = len;
4129if (lmChallengeResponce_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4130len = lmChallengeResponce_Tag_datalen;
4131e = der_get_octet_string(p, len, &(data)->lmChallengeResponce, &l);
4132if(e) goto fail;
4133p += l; len -= l; ret += l;
4134len = lmChallengeResponce_Tag_oldlen - lmChallengeResponce_Tag_datalen;
4135}
4136len = lmChallengeResponce_oldlen - lmChallengeResponce_datalen;
4137}
4138len = Top_oldlen - Top_datalen;
4139}
4140if(size) *size = ret;
4141return 0;
4142fail:
4143free_NTLMRequest2(data);
4144return e;
4145}
4146
4147void ASN1CALL
4148free_NTLMRequest2(NTLMRequest2 *data)
4149{
4150der_free_utf8string(&(data)->loginUserName);
4151der_free_utf8string(&(data)->loginDomainName);
4152der_free_octet_string(&(data)->lmchallenge);
4153der_free_octet_string(&(data)->ntChallengeResponce);
4154der_free_octet_string(&(data)->lmChallengeResponce);
4155}
4156
4157size_t ASN1CALL
4158length_NTLMRequest2(const NTLMRequest2 *data)
4159{
4160size_t ret = 0;
4161{
4162size_t Top_tag_oldret = ret;
4163ret = 0;
4164ret += der_length_utf8string(&(data)->loginUserName);
4165ret += 1 + der_length_len (ret);
4166ret += 1 + der_length_len (ret);
4167ret += Top_tag_oldret;
4168}
4169{
4170size_t Top_tag_oldret = ret;
4171ret = 0;
4172ret += der_length_utf8string(&(data)->loginDomainName);
4173ret += 1 + der_length_len (ret);
4174ret += 1 + der_length_len (ret);
4175ret += Top_tag_oldret;
4176}
4177{
4178size_t Top_tag_oldret = ret;
4179ret = 0;
4180ret += der_length_unsigned(&(data)->flags);
4181ret += 1 + der_length_len (ret);
4182ret += 1 + der_length_len (ret);
4183ret += Top_tag_oldret;
4184}
4185{
4186size_t Top_tag_oldret = ret;
4187ret = 0;
4188ret += der_length_octet_string(&(data)->lmchallenge);
4189ret += 1 + der_length_len (ret);
4190ret += 1 + der_length_len (ret);
4191ret += Top_tag_oldret;
4192}
4193{
4194size_t Top_tag_oldret = ret;
4195ret = 0;
4196ret += der_length_octet_string(&(data)->ntChallengeResponce);
4197ret += 1 + der_length_len (ret);
4198ret += 1 + der_length_len (ret);
4199ret += Top_tag_oldret;
4200}
4201{
4202size_t Top_tag_oldret = ret;
4203ret = 0;
4204ret += der_length_octet_string(&(data)->lmChallengeResponce);
4205ret += 1 + der_length_len (ret);
4206ret += 1 + der_length_len (ret);
4207ret += Top_tag_oldret;
4208}
4209ret += 1 + der_length_len (ret);
4210return ret;
4211}
4212
4213int ASN1CALL
4214copy_NTLMRequest2(const NTLMRequest2 *from, NTLMRequest2 *to)
4215{
4216memset(to, 0, sizeof(*to));
4217if(der_copy_utf8string(&(from)->loginUserName, &(to)->loginUserName)) goto fail;
4218if(der_copy_utf8string(&(from)->loginDomainName, &(to)->loginDomainName)) goto fail;
4219*(&(to)->flags) = *(&(from)->flags);
4220if(der_copy_octet_string(&(from)->lmchallenge, &(to)->lmchallenge)) goto fail;
4221if(der_copy_octet_string(&(from)->ntChallengeResponce, &(to)->ntChallengeResponce)) goto fail;
4222if(der_copy_octet_string(&(from)->lmChallengeResponce, &(to)->lmChallengeResponce)) goto fail;
4223return 0;
4224fail:
4225free_NTLMRequest2(to);
4226return ENOMEM;
4227}
4228
4229int ASN1CALL
4230encode_NTLMReply(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const NTLMReply *data, size_t *size)
4231{
4232size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
4233size_t l HEIMDAL_UNUSED_ATTRIBUTE;
4234int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
4235
4236/* sessionkey */
4237if((data)->sessionkey) {
4238size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4239ret = 0;
4240e = der_put_octet_string(p, len, (data)->sessionkey, &l);
4241if (e) return e;
4242p -= l; len -= l; ret += l;
4243
4244e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
4245if (e) return e;
4246p -= l; len -= l; ret += l;
4247
4248e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
4249if (e) return e;
4250p -= l; len -= l; ret += l;
4251
4252ret += Top_tag_oldret;
4253}
4254/* flags */
4255{
4256size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4257ret = 0;
4258e = der_put_unsigned(p, len, &(data)->flags, &l);
4259if (e) return e;
4260p -= l; len -= l; ret += l;
4261
4262e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
4263if (e) return e;
4264p -= l; len -= l; ret += l;
4265
4266e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
4267if (e) return e;
4268p -= l; len -= l; ret += l;
4269
4270ret += Top_tag_oldret;
4271}
4272/* success */
4273{
4274size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4275ret = 0;
4276e = der_put_boolean(p, len, &(data)->success, &l);
4277if (e) return e;
4278p -= l; len -= l; ret += l;
4279
4280e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Boolean, &l);
4281if (e) return e;
4282p -= l; len -= l; ret += l;
4283
4284e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
4285if (e) return e;
4286p -= l; len -= l; ret += l;
4287
4288ret += Top_tag_oldret;
4289}
4290e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
4291if (e) return e;
4292p -= l; len -= l; ret += l;
4293
4294*size = ret;
4295return 0;
4296}
4297
4298int ASN1CALL
4299decode_NTLMReply(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, NTLMReply *data, size_t *size)
4300{
4301size_t ret = 0;
4302size_t l HEIMDAL_UNUSED_ATTRIBUTE;
4303int e HEIMDAL_UNUSED_ATTRIBUTE;
4304
4305memset(data, 0, sizeof(*data));
4306{
4307size_t Top_datalen, Top_oldlen;
4308Der_type Top_type;
4309e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
4310if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
4311if(e) goto fail;
4312p += l; len -= l; ret += l;
4313Top_oldlen = len;
4314if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4315len = Top_datalen;
4316{
4317size_t success_datalen, success_oldlen;
4318Der_type success_type;
4319e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &success_type, 0, &success_datalen, &l);
4320if (e == 0 && success_type != CONS) { e = ASN1_BAD_ID; }
4321if(e) goto fail;
4322p += l; len -= l; ret += l;
4323success_oldlen = len;
4324if (success_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4325len = success_datalen;
4326{
4327size_t success_Tag_datalen, success_Tag_oldlen;
4328Der_type success_Tag_type;
4329e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &success_Tag_type, UT_Boolean, &success_Tag_datalen, &l);
4330if (e == 0 && success_Tag_type != PRIM) { e = ASN1_BAD_ID; }
4331if(e) goto fail;
4332p += l; len -= l; ret += l;
4333success_Tag_oldlen = len;
4334if (success_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4335len = success_Tag_datalen;
4336e = der_get_boolean(p, len, &(data)->success, &l);
4337if(e) goto fail;
4338p += l; len -= l; ret += l;
4339len = success_Tag_oldlen - success_Tag_datalen;
4340}
4341len = success_oldlen - success_datalen;
4342}
4343{
4344size_t flags_datalen, flags_oldlen;
4345Der_type flags_type;
4346e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &flags_type, 1, &flags_datalen, &l);
4347if (e == 0 && flags_type != CONS) { e = ASN1_BAD_ID; }
4348if(e) goto fail;
4349p += l; len -= l; ret += l;
4350flags_oldlen = len;
4351if (flags_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4352len = flags_datalen;
4353{
4354size_t flags_Tag_datalen, flags_Tag_oldlen;
4355Der_type flags_Tag_type;
4356e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &flags_Tag_type, UT_Integer, &flags_Tag_datalen, &l);
4357if (e == 0 && flags_Tag_type != PRIM) { e = ASN1_BAD_ID; }
4358if(e) goto fail;
4359p += l; len -= l; ret += l;
4360flags_Tag_oldlen = len;
4361if (flags_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4362len = flags_Tag_datalen;
4363e = der_get_unsigned(p, len, &(data)->flags, &l);
4364if(e) goto fail;
4365p += l; len -= l; ret += l;
4366len = flags_Tag_oldlen - flags_Tag_datalen;
4367}
4368len = flags_oldlen - flags_datalen;
4369}
4370{
4371size_t sessionkey_datalen, sessionkey_oldlen;
4372Der_type sessionkey_type;
4373e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &sessionkey_type, 2, &sessionkey_datalen, &l);
4374if (e == 0 && sessionkey_type != CONS) { e = ASN1_BAD_ID; }
4375if(e) {
4376(data)->sessionkey = NULL;
4377} else {
4378(data)->sessionkey = calloc(1, sizeof(*(data)->sessionkey));
4379if ((data)->sessionkey == NULL) { e = ENOMEM; goto fail; }
4380p += l; len -= l; ret += l;
4381sessionkey_oldlen = len;
4382if (sessionkey_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4383len = sessionkey_datalen;
4384{
4385size_t sessionkey_Tag_datalen, sessionkey_Tag_oldlen;
4386Der_type sessionkey_Tag_type;
4387e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &sessionkey_Tag_type, UT_OctetString, &sessionkey_Tag_datalen, &l);
4388if (e == 0 && sessionkey_Tag_type != PRIM) { e = ASN1_BAD_ID; }
4389if(e) goto fail;
4390p += l; len -= l; ret += l;
4391sessionkey_Tag_oldlen = len;
4392if (sessionkey_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4393len = sessionkey_Tag_datalen;
4394e = der_get_octet_string(p, len, (data)->sessionkey, &l);
4395if(e) goto fail;
4396p += l; len -= l; ret += l;
4397len = sessionkey_Tag_oldlen - sessionkey_Tag_datalen;
4398}
4399len = sessionkey_oldlen - sessionkey_datalen;
4400}
4401}
4402len = Top_oldlen - Top_datalen;
4403}
4404if(size) *size = ret;
4405return 0;
4406fail:
4407free_NTLMReply(data);
4408return e;
4409}
4410
4411void ASN1CALL
4412free_NTLMReply(NTLMReply *data)
4413{
4414if((data)->sessionkey) {
4415der_free_octet_string((data)->sessionkey);
4416free((data)->sessionkey);
4417(data)->sessionkey = NULL;
4418}
4419}
4420
4421size_t ASN1CALL
4422length_NTLMReply(const NTLMReply *data)
4423{
4424size_t ret = 0;
4425{
4426size_t Top_tag_oldret = ret;
4427ret = 0;
4428ret += 1;
4429ret += 1 + der_length_len (ret);
4430ret += 1 + der_length_len (ret);
4431ret += Top_tag_oldret;
4432}
4433{
4434size_t Top_tag_oldret = ret;
4435ret = 0;
4436ret += der_length_unsigned(&(data)->flags);
4437ret += 1 + der_length_len (ret);
4438ret += 1 + der_length_len (ret);
4439ret += Top_tag_oldret;
4440}
4441if((data)->sessionkey){
4442size_t Top_tag_oldret = ret;
4443ret = 0;
4444ret += der_length_octet_string((data)->sessionkey);
4445ret += 1 + der_length_len (ret);
4446ret += 1 + der_length_len (ret);
4447ret += Top_tag_oldret;
4448}
4449ret += 1 + der_length_len (ret);
4450return ret;
4451}
4452
4453int ASN1CALL
4454copy_NTLMReply(const NTLMReply *from, NTLMReply *to)
4455{
4456memset(to, 0, sizeof(*to));
4457*(&(to)->success) = *(&(from)->success);
4458*(&(to)->flags) = *(&(from)->flags);
4459if((from)->sessionkey) {
4460(to)->sessionkey = malloc(sizeof(*(to)->sessionkey));
4461if((to)->sessionkey == NULL) goto fail;
4462if(der_copy_octet_string((from)->sessionkey, (to)->sessionkey)) goto fail;
4463}else
4464(to)->sessionkey = NULL;
4465return 0;
4466fail:
4467free_NTLMReply(to);
4468return ENOMEM;
4469}
4470
4471int ASN1CALL
4472encode_DigestReqInner(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const DigestReqInner *data, size_t *size)
4473{
4474size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
4475size_t l HEIMDAL_UNUSED_ATTRIBUTE;
4476int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
4477
4478
4479switch((data)->element) {
4480case choice_DigestReqInner_supportedMechs: {size_t Top_oldret = ret;
4481ret = 0;
4482/* NULL */
4483e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Null, &l);
4484if (e) return e;
4485p -= l; len -= l; ret += l;
4486
4487e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 4, &l);
4488if (e) return e;
4489p -= l; len -= l; ret += l;
4490
4491ret += Top_oldret;
4492break;
4493}
4494case choice_DigestReqInner_ntlmRequest: {size_t Top_oldret = ret;
4495ret = 0;
4496e = encode_NTLMRequest(p, len, &((data))->u.ntlmRequest, &l);
4497if (e) return e;
4498p -= l; len -= l; ret += l;
4499
4500e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
4501if (e) return e;
4502p -= l; len -= l; ret += l;
4503
4504ret += Top_oldret;
4505break;
4506}
4507case choice_DigestReqInner_ntlmInit: {size_t Top_oldret = ret;
4508ret = 0;
4509e = encode_NTLMInit(p, len, &((data))->u.ntlmInit, &l);
4510if (e) return e;
4511p -= l; len -= l; ret += l;
4512
4513e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
4514if (e) return e;
4515p -= l; len -= l; ret += l;
4516
4517ret += Top_oldret;
4518break;
4519}
4520case choice_DigestReqInner_digestRequest: {size_t Top_oldret = ret;
4521ret = 0;
4522e = encode_DigestRequest(p, len, &((data))->u.digestRequest, &l);
4523if (e) return e;
4524p -= l; len -= l; ret += l;
4525
4526e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
4527if (e) return e;
4528p -= l; len -= l; ret += l;
4529
4530ret += Top_oldret;
4531break;
4532}
4533case choice_DigestReqInner_init: {size_t Top_oldret = ret;
4534ret = 0;
4535e = encode_DigestInit(p, len, &((data))->u.init, &l);
4536if (e) return e;
4537p -= l; len -= l; ret += l;
4538
4539e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
4540if (e) return e;
4541p -= l; len -= l; ret += l;
4542
4543ret += Top_oldret;
4544break;
4545}
4546};
4547*size = ret;
4548return 0;
4549}
4550
4551int ASN1CALL
4552decode_DigestReqInner(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, DigestReqInner *data, size_t *size)
4553{
4554size_t ret = 0;
4555size_t l HEIMDAL_UNUSED_ATTRIBUTE;
4556int e HEIMDAL_UNUSED_ATTRIBUTE;
4557
4558memset(data, 0, sizeof(*data));
4559if (der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 0, NULL) == 0) {
4560{
4561size_t init_datalen, init_oldlen;
4562Der_type init_type;
4563e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &init_type, 0, &init_datalen, &l);
4564if (e == 0 && init_type != CONS) { e = ASN1_BAD_ID; }
4565if(e) goto fail;
4566p += l; len -= l; ret += l;
4567init_oldlen = len;
4568if (init_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4569len = init_datalen;
4570e = decode_DigestInit(p, len, &(data)->u.init, &l);
4571if(e) goto fail;
4572p += l; len -= l; ret += l;
4573len = init_oldlen - init_datalen;
4574}
4575(data)->element = choice_DigestReqInner_init;
4576}
4577else if (der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 1, NULL) == 0) {
4578{
4579size_t digestRequest_datalen, digestRequest_oldlen;
4580Der_type digestRequest_type;
4581e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &digestRequest_type, 1, &digestRequest_datalen, &l);
4582if (e == 0 && digestRequest_type != CONS) { e = ASN1_BAD_ID; }
4583if(e) goto fail;
4584p += l; len -= l; ret += l;
4585digestRequest_oldlen = len;
4586if (digestRequest_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4587len = digestRequest_datalen;
4588e = decode_DigestRequest(p, len, &(data)->u.digestRequest, &l);
4589if(e) goto fail;
4590p += l; len -= l; ret += l;
4591len = digestRequest_oldlen - digestRequest_datalen;
4592}
4593(data)->element = choice_DigestReqInner_digestRequest;
4594}
4595else if (der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 2, NULL) == 0) {
4596{
4597size_t ntlmInit_datalen, ntlmInit_oldlen;
4598Der_type ntlmInit_type;
4599e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &ntlmInit_type, 2, &ntlmInit_datalen, &l);
4600if (e == 0 && ntlmInit_type != CONS) { e = ASN1_BAD_ID; }
4601if(e) goto fail;
4602p += l; len -= l; ret += l;
4603ntlmInit_oldlen = len;
4604if (ntlmInit_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4605len = ntlmInit_datalen;
4606e = decode_NTLMInit(p, len, &(data)->u.ntlmInit, &l);
4607if(e) goto fail;
4608p += l; len -= l; ret += l;
4609len = ntlmInit_oldlen - ntlmInit_datalen;
4610}
4611(data)->element = choice_DigestReqInner_ntlmInit;
4612}
4613else if (der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 3, NULL) == 0) {
4614{
4615size_t ntlmRequest_datalen, ntlmRequest_oldlen;
4616Der_type ntlmRequest_type;
4617e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &ntlmRequest_type, 3, &ntlmRequest_datalen, &l);
4618if (e == 0 && ntlmRequest_type != CONS) { e = ASN1_BAD_ID; }
4619if(e) goto fail;
4620p += l; len -= l; ret += l;
4621ntlmRequest_oldlen = len;
4622if (ntlmRequest_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4623len = ntlmRequest_datalen;
4624e = decode_NTLMRequest(p, len, &(data)->u.ntlmRequest, &l);
4625if(e) goto fail;
4626p += l; len -= l; ret += l;
4627len = ntlmRequest_oldlen - ntlmRequest_datalen;
4628}
4629(data)->element = choice_DigestReqInner_ntlmRequest;
4630}
4631else if (der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 4, NULL) == 0) {
4632{
4633size_t supportedMechs_datalen, supportedMechs_oldlen;
4634Der_type supportedMechs_type;
4635e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &supportedMechs_type, 4, &supportedMechs_datalen, &l);
4636if (e == 0 && supportedMechs_type != CONS) { e = ASN1_BAD_ID; }
4637if(e) goto fail;
4638p += l; len -= l; ret += l;
4639supportedMechs_oldlen = len;
4640if (supportedMechs_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4641len = supportedMechs_datalen;
4642{
4643size_t supportedMechs_Tag_datalen, supportedMechs_Tag_oldlen;
4644Der_type supportedMechs_Tag_type;
4645e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &supportedMechs_Tag_type, UT_Null, &supportedMechs_Tag_datalen, &l);
4646if (e == 0 && supportedMechs_Tag_type != PRIM) { e = ASN1_BAD_ID; }
4647if(e) goto fail;
4648p += l; len -= l; ret += l;
4649supportedMechs_Tag_oldlen = len;
4650if (supportedMechs_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4651len = supportedMechs_Tag_datalen;
4652/* NULL */
4653len = supportedMechs_Tag_oldlen - supportedMechs_Tag_datalen;
4654}
4655len = supportedMechs_oldlen - supportedMechs_datalen;
4656}
4657(data)->element = choice_DigestReqInner_supportedMechs;
4658}
4659else {
4660e = ASN1_PARSE_ERROR;
4661goto fail;
4662}
4663if(size) *size = ret;
4664return 0;
4665fail:
4666free_DigestReqInner(data);
4667return e;
4668}
4669
4670void ASN1CALL
4671free_DigestReqInner(DigestReqInner *data)
4672{
4673switch((data)->element) {
4674case choice_DigestReqInner_init:
4675free_DigestInit(&(data)->u.init);
4676break;
4677case choice_DigestReqInner_digestRequest:
4678free_DigestRequest(&(data)->u.digestRequest);
4679break;
4680case choice_DigestReqInner_ntlmInit:
4681free_NTLMInit(&(data)->u.ntlmInit);
4682break;
4683case choice_DigestReqInner_ntlmRequest:
4684free_NTLMRequest(&(data)->u.ntlmRequest);
4685break;
4686case choice_DigestReqInner_supportedMechs:
4687break;
4688}
4689}
4690
4691size_t ASN1CALL
4692length_DigestReqInner(const DigestReqInner *data)
4693{
4694size_t ret = 0;
4695switch((data)->element) {
4696case choice_DigestReqInner_init:
4697{
4698size_t Top_oldret = ret;
4699ret = 0;
4700ret += length_DigestInit(&(data)->u.init);
4701ret += 1 + der_length_len (ret);
4702ret += Top_oldret;
4703}
4704break;
4705case choice_DigestReqInner_digestRequest:
4706{
4707size_t Top_oldret = ret;
4708ret = 0;
4709ret += length_DigestRequest(&(data)->u.digestRequest);
4710ret += 1 + der_length_len (ret);
4711ret += Top_oldret;
4712}
4713break;
4714case choice_DigestReqInner_ntlmInit:
4715{
4716size_t Top_oldret = ret;
4717ret = 0;
4718ret += length_NTLMInit(&(data)->u.ntlmInit);
4719ret += 1 + der_length_len (ret);
4720ret += Top_oldret;
4721}
4722break;
4723case choice_DigestReqInner_ntlmRequest:
4724{
4725size_t Top_oldret = ret;
4726ret = 0;
4727ret += length_NTLMRequest(&(data)->u.ntlmRequest);
4728ret += 1 + der_length_len (ret);
4729ret += Top_oldret;
4730}
4731break;
4732case choice_DigestReqInner_supportedMechs:
4733{
4734size_t Top_oldret = ret;
4735ret = 0;
4736/* NULL */
4737ret += 1 + der_length_len (ret);
4738ret += 1 + der_length_len (ret);
4739ret += Top_oldret;
4740}
4741break;
4742}
4743return ret;
4744}
4745
4746int ASN1CALL
4747copy_DigestReqInner(const DigestReqInner *from, DigestReqInner *to)
4748{
4749memset(to, 0, sizeof(*to));
4750(to)->element = (from)->element;
4751switch((from)->element) {
4752case choice_DigestReqInner_init:
4753if(copy_DigestInit(&(from)->u.init, &(to)->u.init)) goto fail;
4754break;
4755case choice_DigestReqInner_digestRequest:
4756if(copy_DigestRequest(&(from)->u.digestRequest, &(to)->u.digestRequest)) goto fail;
4757break;
4758case choice_DigestReqInner_ntlmInit:
4759if(copy_NTLMInit(&(from)->u.ntlmInit, &(to)->u.ntlmInit)) goto fail;
4760break;
4761case choice_DigestReqInner_ntlmRequest:
4762if(copy_NTLMRequest(&(from)->u.ntlmRequest, &(to)->u.ntlmRequest)) goto fail;
4763break;
4764case choice_DigestReqInner_supportedMechs:
4765break;
4766}
4767return 0;
4768fail:
4769free_DigestReqInner(to);
4770return ENOMEM;
4771}
4772
4773int ASN1CALL
4774encode_DigestREQ(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const DigestREQ *data, size_t *size)
4775{
4776size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
4777size_t l HEIMDAL_UNUSED_ATTRIBUTE;
4778int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
4779
4780/* innerReq */
4781{
4782size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4783ret = 0;
4784e = encode_EncryptedData(p, len, &(data)->innerReq, &l);
4785if (e) return e;
4786p -= l; len -= l; ret += l;
4787
4788e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
4789if (e) return e;
4790p -= l; len -= l; ret += l;
4791
4792ret += Top_tag_tag_oldret;
4793}
4794/* apReq */
4795{
4796size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4797ret = 0;
4798e = der_put_octet_string(p, len, &(data)->apReq, &l);
4799if (e) return e;
4800p -= l; len -= l; ret += l;
4801
4802e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
4803if (e) return e;
4804p -= l; len -= l; ret += l;
4805
4806e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
4807if (e) return e;
4808p -= l; len -= l; ret += l;
4809
4810ret += Top_tag_tag_oldret;
4811}
4812e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
4813if (e) return e;
4814p -= l; len -= l; ret += l;
4815
4816e = der_put_length_and_tag (p, len, ret, ASN1_C_APPL, CONS, 128, &l);
4817if (e) return e;
4818p -= l; len -= l; ret += l;
4819
4820*size = ret;
4821return 0;
4822}
4823
4824int ASN1CALL
4825decode_DigestREQ(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, DigestREQ *data, size_t *size)
4826{
4827size_t ret = 0;
4828size_t l HEIMDAL_UNUSED_ATTRIBUTE;
4829int e HEIMDAL_UNUSED_ATTRIBUTE;
4830
4831memset(data, 0, sizeof(*data));
4832{
4833size_t Top_datalen, Top_oldlen;
4834Der_type Top_type;
4835e = der_match_tag_and_length(p, len, ASN1_C_APPL, &Top_type, 128, &Top_datalen, &l);
4836if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
4837if(e) goto fail;
4838p += l; len -= l; ret += l;
4839Top_oldlen = len;
4840if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4841len = Top_datalen;
4842{
4843size_t Top_Tag_datalen, Top_Tag_oldlen;
4844Der_type Top_Tag_type;
4845e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_Tag_type, UT_Sequence, &Top_Tag_datalen, &l);
4846if (e == 0 && Top_Tag_type != CONS) { e = ASN1_BAD_ID; }
4847if(e) goto fail;
4848p += l; len -= l; ret += l;
4849Top_Tag_oldlen = len;
4850if (Top_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4851len = Top_Tag_datalen;
4852{
4853size_t apReq_datalen, apReq_oldlen;
4854Der_type apReq_type;
4855e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &apReq_type, 0, &apReq_datalen, &l);
4856if (e == 0 && apReq_type != CONS) { e = ASN1_BAD_ID; }
4857if(e) goto fail;
4858p += l; len -= l; ret += l;
4859apReq_oldlen = len;
4860if (apReq_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4861len = apReq_datalen;
4862{
4863size_t apReq_Tag_datalen, apReq_Tag_oldlen;
4864Der_type apReq_Tag_type;
4865e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &apReq_Tag_type, UT_OctetString, &apReq_Tag_datalen, &l);
4866if (e == 0 && apReq_Tag_type != PRIM) { e = ASN1_BAD_ID; }
4867if(e) goto fail;
4868p += l; len -= l; ret += l;
4869apReq_Tag_oldlen = len;
4870if (apReq_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4871len = apReq_Tag_datalen;
4872e = der_get_octet_string(p, len, &(data)->apReq, &l);
4873if(e) goto fail;
4874p += l; len -= l; ret += l;
4875len = apReq_Tag_oldlen - apReq_Tag_datalen;
4876}
4877len = apReq_oldlen - apReq_datalen;
4878}
4879{
4880size_t innerReq_datalen, innerReq_oldlen;
4881Der_type innerReq_type;
4882e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &innerReq_type, 1, &innerReq_datalen, &l);
4883if (e == 0 && innerReq_type != CONS) { e = ASN1_BAD_ID; }
4884if(e) goto fail;
4885p += l; len -= l; ret += l;
4886innerReq_oldlen = len;
4887if (innerReq_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4888len = innerReq_datalen;
4889e = decode_EncryptedData(p, len, &(data)->innerReq, &l);
4890if(e) goto fail;
4891p += l; len -= l; ret += l;
4892len = innerReq_oldlen - innerReq_datalen;
4893}
4894len = Top_Tag_oldlen - Top_Tag_datalen;
4895}
4896len = Top_oldlen - Top_datalen;
4897}
4898if(size) *size = ret;
4899return 0;
4900fail:
4901free_DigestREQ(data);
4902return e;
4903}
4904
4905void ASN1CALL
4906free_DigestREQ(DigestREQ *data)
4907{
4908der_free_octet_string(&(data)->apReq);
4909free_EncryptedData(&(data)->innerReq);
4910}
4911
4912size_t ASN1CALL
4913length_DigestREQ(const DigestREQ *data)
4914{
4915size_t ret = 0;
4916{
4917size_t Top_tag_tag_oldret = ret;
4918ret = 0;
4919ret += der_length_octet_string(&(data)->apReq);
4920ret += 1 + der_length_len (ret);
4921ret += 1 + der_length_len (ret);
4922ret += Top_tag_tag_oldret;
4923}
4924{
4925size_t Top_tag_tag_oldret = ret;
4926ret = 0;
4927ret += length_EncryptedData(&(data)->innerReq);
4928ret += 1 + der_length_len (ret);
4929ret += Top_tag_tag_oldret;
4930}
4931ret += 1 + der_length_len (ret);
4932ret += 3 + der_length_len (ret);
4933return ret;
4934}
4935
4936int ASN1CALL
4937copy_DigestREQ(const DigestREQ *from, DigestREQ *to)
4938{
4939memset(to, 0, sizeof(*to));
4940if(der_copy_octet_string(&(from)->apReq, &(to)->apReq)) goto fail;
4941if(copy_EncryptedData(&(from)->innerReq, &(to)->innerReq)) goto fail;
4942return 0;
4943fail:
4944free_DigestREQ(to);
4945return ENOMEM;
4946}
4947
4948int ASN1CALL
4949encode_DigestRepInner(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const DigestRepInner *data, size_t *size)
4950{
4951size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
4952size_t l HEIMDAL_UNUSED_ATTRIBUTE;
4953int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
4954
4955
4956switch((data)->element) {
4957case choice_DigestRepInner_supportedMechs: {size_t Top_oldret = ret;
4958ret = 0;
4959e = encode_DigestTypes(p, len, &((data))->u.supportedMechs, &l);
4960if (e) return e;
4961p -= l; len -= l; ret += l;
4962
4963e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 5, &l);
4964if (e) return e;
4965p -= l; len -= l; ret += l;
4966
4967ret += Top_oldret;
4968break;
4969}
4970case choice_DigestRepInner_ntlmResponse: {size_t Top_oldret = ret;
4971ret = 0;
4972e = encode_NTLMResponse(p, len, &((data))->u.ntlmResponse, &l);
4973if (e) return e;
4974p -= l; len -= l; ret += l;
4975
4976e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 4, &l);
4977if (e) return e;
4978p -= l; len -= l; ret += l;
4979
4980ret += Top_oldret;
4981break;
4982}
4983case choice_DigestRepInner_ntlmInitReply: {size_t Top_oldret = ret;
4984ret = 0;
4985e = encode_NTLMInitReply(p, len, &((data))->u.ntlmInitReply, &l);
4986if (e) return e;
4987p -= l; len -= l; ret += l;
4988
4989e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
4990if (e) return e;
4991p -= l; len -= l; ret += l;
4992
4993ret += Top_oldret;
4994break;
4995}
4996case choice_DigestRepInner_response: {size_t Top_oldret = ret;
4997ret = 0;
4998e = encode_DigestResponse(p, len, &((data))->u.response, &l);
4999if (e) return e;
5000p -= l; len -= l; ret += l;
5001
5002e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
5003if (e) return e;
5004p -= l; len -= l; ret += l;
5005
5006ret += Top_oldret;
5007break;
5008}
5009case choice_DigestRepInner_initReply: {size_t Top_oldret = ret;
5010ret = 0;
5011e = encode_DigestInitReply(p, len, &((data))->u.initReply, &l);
5012if (e) return e;
5013p -= l; len -= l; ret += l;
5014
5015e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
5016if (e) return e;
5017p -= l; len -= l; ret += l;
5018
5019ret += Top_oldret;
5020break;
5021}
5022case choice_DigestRepInner_error: {size_t Top_oldret = ret;
5023ret = 0;
5024e = encode_DigestError(p, len, &((data))->u.error, &l);
5025if (e) return e;
5026p -= l; len -= l; ret += l;
5027
5028e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
5029if (e) return e;
5030p -= l; len -= l; ret += l;
5031
5032ret += Top_oldret;
5033break;
5034}
5035case choice_DigestRepInner_asn1_ellipsis: {
5036if (len < (data)->u.asn1_ellipsis.length)
5037return ASN1_OVERFLOW;
5038p -= (data)->u.asn1_ellipsis.length;
5039ret += (data)->u.asn1_ellipsis.length;
5040memcpy(p + 1, (data)->u.asn1_ellipsis.data, (data)->u.asn1_ellipsis.length);
5041break;
5042}
5043};
5044*size = ret;
5045return 0;
5046}
5047
5048int ASN1CALL
5049decode_DigestRepInner(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, DigestRepInner *data, size_t *size)
5050{
5051size_t ret = 0;
5052size_t l HEIMDAL_UNUSED_ATTRIBUTE;
5053int e HEIMDAL_UNUSED_ATTRIBUTE;
5054
5055memset(data, 0, sizeof(*data));
5056if (der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 0, NULL) == 0) {
5057{
5058size_t error_datalen, error_oldlen;
5059Der_type error_type;
5060e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &error_type, 0, &error_datalen, &l);
5061if (e == 0 && error_type != CONS) { e = ASN1_BAD_ID; }
5062if(e) goto fail;
5063p += l; len -= l; ret += l;
5064error_oldlen = len;
5065if (error_datalen > len) { e = ASN1_OVERRUN; goto fail; }
5066len = error_datalen;
5067e = decode_DigestError(p, len, &(data)->u.error, &l);
5068if(e) goto fail;
5069p += l; len -= l; ret += l;
5070len = error_oldlen - error_datalen;
5071}
5072(data)->element = choice_DigestRepInner_error;
5073}
5074else if (der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 1, NULL) == 0) {
5075{
5076size_t initReply_datalen, initReply_oldlen;
5077Der_type initReply_type;
5078e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &initReply_type, 1, &initReply_datalen, &l);
5079if (e == 0 && initReply_type != CONS) { e = ASN1_BAD_ID; }
5080if(e) goto fail;
5081p += l; len -= l; ret += l;
5082initReply_oldlen = len;
5083if (initReply_datalen > len) { e = ASN1_OVERRUN; goto fail; }
5084len = initReply_datalen;
5085e = decode_DigestInitReply(p, len, &(data)->u.initReply, &l);
5086if(e) goto fail;
5087p += l; len -= l; ret += l;
5088len = initReply_oldlen - initReply_datalen;
5089}
5090(data)->element = choice_DigestRepInner_initReply;
5091}
5092else if (der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 2, NULL) == 0) {
5093{
5094size_t response_datalen, response_oldlen;
5095Der_type response_type;
5096e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &response_type, 2, &response_datalen, &l);
5097if (e == 0 && response_type != CONS) { e = ASN1_BAD_ID; }
5098if(e) goto fail;
5099p += l; len -= l; ret += l;
5100response_oldlen = len;
5101if (response_datalen > len) { e = ASN1_OVERRUN; goto fail; }
5102len = response_datalen;
5103e = decode_DigestResponse(p, len, &(data)->u.response, &l);
5104if(e) goto fail;
5105p += l; len -= l; ret += l;
5106len = response_oldlen - response_datalen;
5107}
5108(data)->element = choice_DigestRepInner_response;
5109}
5110else if (der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 3, NULL) == 0) {
5111{
5112size_t ntlmInitReply_datalen, ntlmInitReply_oldlen;
5113Der_type ntlmInitReply_type;
5114e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &ntlmInitReply_type, 3, &ntlmInitReply_datalen, &l);
5115if (e == 0 && ntlmInitReply_type != CONS) { e = ASN1_BAD_ID; }
5116if(e) goto fail;
5117p += l; len -= l; ret += l;
5118ntlmInitReply_oldlen = len;
5119if (ntlmInitReply_datalen > len) { e = ASN1_OVERRUN; goto fail; }
5120len = ntlmInitReply_datalen;
5121e = decode_NTLMInitReply(p, len, &(data)->u.ntlmInitReply, &l);
5122if(e) goto fail;
5123p += l; len -= l; ret += l;
5124len = ntlmInitReply_oldlen - ntlmInitReply_datalen;
5125}
5126(data)->element = choice_DigestRepInner_ntlmInitReply;
5127}
5128else if (der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 4, NULL) == 0) {
5129{
5130size_t ntlmResponse_datalen, ntlmResponse_oldlen;
5131Der_type ntlmResponse_type;
5132e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &ntlmResponse_type, 4, &ntlmResponse_datalen, &l);
5133if (e == 0 && ntlmResponse_type != CONS) { e = ASN1_BAD_ID; }
5134if(e) goto fail;
5135p += l; len -= l; ret += l;
5136ntlmResponse_oldlen = len;
5137if (ntlmResponse_datalen > len) { e = ASN1_OVERRUN; goto fail; }
5138len = ntlmResponse_datalen;
5139e = decode_NTLMResponse(p, len, &(data)->u.ntlmResponse, &l);
5140if(e) goto fail;
5141p += l; len -= l; ret += l;
5142len = ntlmResponse_oldlen - ntlmResponse_datalen;
5143}
5144(data)->element = choice_DigestRepInner_ntlmResponse;
5145}
5146else if (der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 5, NULL) == 0) {
5147{
5148size_t supportedMechs_datalen, supportedMechs_oldlen;
5149Der_type supportedMechs_type;
5150e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &supportedMechs_type, 5, &supportedMechs_datalen, &l);
5151if (e == 0 && supportedMechs_type != CONS) { e = ASN1_BAD_ID; }
5152if(e) goto fail;
5153p += l; len -= l; ret += l;
5154supportedMechs_oldlen = len;
5155if (supportedMechs_datalen > len) { e = ASN1_OVERRUN; goto fail; }
5156len = supportedMechs_datalen;
5157e = decode_DigestTypes(p, len, &(data)->u.supportedMechs, &l);
5158if(e) goto fail;
5159p += l; len -= l; ret += l;
5160len = supportedMechs_oldlen - supportedMechs_datalen;
5161}
5162(data)->element = choice_DigestRepInner_supportedMechs;
5163}
5164else {
5165(data)->u.asn1_ellipsis.data = calloc(1, len);
5166if ((data)->u.asn1_ellipsis.data == NULL) {
5167e = ENOMEM; goto fail;
5168}
5169(data)->u.asn1_ellipsis.length = len;
5170memcpy((data)->u.asn1_ellipsis.data, p, len);
5171(data)->element = choice_DigestRepInner_asn1_ellipsis;
5172p += len;
5173ret += len;
5174len = 0;
5175}
5176if(size) *size = ret;
5177return 0;
5178fail:
5179free_DigestRepInner(data);
5180return e;
5181}
5182
5183void ASN1CALL
5184free_DigestRepInner(DigestRepInner *data)
5185{
5186switch((data)->element) {
5187case choice_DigestRepInner_error:
5188free_DigestError(&(data)->u.error);
5189break;
5190case choice_DigestRepInner_initReply:
5191free_DigestInitReply(&(data)->u.initReply);
5192break;
5193case choice_DigestRepInner_response:
5194free_DigestResponse(&(data)->u.response);
5195break;
5196case choice_DigestRepInner_ntlmInitReply:
5197free_NTLMInitReply(&(data)->u.ntlmInitReply);
5198break;
5199case choice_DigestRepInner_ntlmResponse:
5200free_NTLMResponse(&(data)->u.ntlmResponse);
5201break;
5202case choice_DigestRepInner_supportedMechs:
5203free_DigestTypes(&(data)->u.supportedMechs);
5204break;
5205case choice_DigestRepInner_asn1_ellipsis:
5206der_free_octet_string(&(data)->u.asn1_ellipsis);
5207break;}
5208}
5209
5210size_t ASN1CALL
5211length_DigestRepInner(const DigestRepInner *data)
5212{
5213size_t ret = 0;
5214switch((data)->element) {
5215case choice_DigestRepInner_error:
5216{
5217size_t Top_oldret = ret;
5218ret = 0;
5219ret += length_DigestError(&(data)->u.error);
5220ret += 1 + der_length_len (ret);
5221ret += Top_oldret;
5222}
5223break;
5224case choice_DigestRepInner_initReply:
5225{
5226size_t Top_oldret = ret;
5227ret = 0;
5228ret += length_DigestInitReply(&(data)->u.initReply);
5229ret += 1 + der_length_len (ret);
5230ret += Top_oldret;
5231}
5232break;
5233case choice_DigestRepInner_response:
5234{
5235size_t Top_oldret = ret;
5236ret = 0;
5237ret += length_DigestResponse(&(data)->u.response);
5238ret += 1 + der_length_len (ret);
5239ret += Top_oldret;
5240}
5241break;
5242case choice_DigestRepInner_ntlmInitReply:
5243{
5244size_t Top_oldret = ret;
5245ret = 0;
5246ret += length_NTLMInitReply(&(data)->u.ntlmInitReply);
5247ret += 1 + der_length_len (ret);
5248ret += Top_oldret;
5249}
5250break;
5251case choice_DigestRepInner_ntlmResponse:
5252{
5253size_t Top_oldret = ret;
5254ret = 0;
5255ret += length_NTLMResponse(&(data)->u.ntlmResponse);
5256ret += 1 + der_length_len (ret);
5257ret += Top_oldret;
5258}
5259break;
5260case choice_DigestRepInner_supportedMechs:
5261{
5262size_t Top_oldret = ret;
5263ret = 0;
5264ret += length_DigestTypes(&(data)->u.supportedMechs);
5265ret += 1 + der_length_len (ret);
5266ret += Top_oldret;
5267}
5268break;
5269case choice_DigestRepInner_asn1_ellipsis:
5270ret += (data)->u.asn1_ellipsis.length;
5271break;
5272}
5273return ret;
5274}
5275
5276int ASN1CALL
5277copy_DigestRepInner(const DigestRepInner *from, DigestRepInner *to)
5278{
5279memset(to, 0, sizeof(*to));
5280(to)->element = (from)->element;
5281switch((from)->element) {
5282case choice_DigestRepInner_error:
5283if(copy_DigestError(&(from)->u.error, &(to)->u.error)) goto fail;
5284break;
5285case choice_DigestRepInner_initReply:
5286if(copy_DigestInitReply(&(from)->u.initReply, &(to)->u.initReply)) goto fail;
5287break;
5288case choice_DigestRepInner_response:
5289if(copy_DigestResponse(&(from)->u.response, &(to)->u.response)) goto fail;
5290break;
5291case choice_DigestRepInner_ntlmInitReply:
5292if(copy_NTLMInitReply(&(from)->u.ntlmInitReply, &(to)->u.ntlmInitReply)) goto fail;
5293break;
5294case choice_DigestRepInner_ntlmResponse:
5295if(copy_NTLMResponse(&(from)->u.ntlmResponse, &(to)->u.ntlmResponse)) goto fail;
5296break;
5297case choice_DigestRepInner_supportedMechs:
5298if(copy_DigestTypes(&(from)->u.supportedMechs, &(to)->u.supportedMechs)) goto fail;
5299break;
5300case choice_DigestRepInner_asn1_ellipsis: {
5301int ret;
5302ret=der_copy_octet_string(&(from)->u.asn1_ellipsis, &(to)->u.asn1_ellipsis);
5303if (ret) goto fail;
5304break;
5305}
5306}
5307return 0;
5308fail:
5309free_DigestRepInner(to);
5310return ENOMEM;
5311}
5312
5313int ASN1CALL
5314encode_DigestREP(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const DigestREP *data, size_t *size)
5315{
5316size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
5317size_t l HEIMDAL_UNUSED_ATTRIBUTE;
5318int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
5319
5320/* innerRep */
5321{
5322size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
5323ret = 0;
5324e = encode_EncryptedData(p, len, &(data)->innerRep, &l);
5325if (e) return e;
5326p -= l; len -= l; ret += l;
5327
5328e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
5329if (e) return e;
5330p -= l; len -= l; ret += l;
5331
5332ret += Top_tag_tag_oldret;
5333}
5334/* apRep */
5335{
5336size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
5337ret = 0;
5338e = der_put_octet_string(p, len, &(data)->apRep, &l);
5339if (e) return e;
5340p -= l; len -= l; ret += l;
5341
5342e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
5343if (e) return e;
5344p -= l; len -= l; ret += l;
5345
5346e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
5347if (e) return e;
5348p -= l; len -= l; ret += l;
5349
5350ret += Top_tag_tag_oldret;
5351}
5352e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
5353if (e) return e;
5354p -= l; len -= l; ret += l;
5355
5356e = der_put_length_and_tag (p, len, ret, ASN1_C_APPL, CONS, 129, &l);
5357if (e) return e;
5358p -= l; len -= l; ret += l;
5359
5360*size = ret;
5361return 0;
5362}
5363
5364int ASN1CALL
5365decode_DigestREP(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, DigestREP *data, size_t *size)
5366{
5367size_t ret = 0;
5368size_t l HEIMDAL_UNUSED_ATTRIBUTE;
5369int e HEIMDAL_UNUSED_ATTRIBUTE;
5370
5371memset(data, 0, sizeof(*data));
5372{
5373size_t Top_datalen, Top_oldlen;
5374Der_type Top_type;
5375e = der_match_tag_and_length(p, len, ASN1_C_APPL, &Top_type, 129, &Top_datalen, &l);
5376if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
5377if(e) goto fail;
5378p += l; len -= l; ret += l;
5379Top_oldlen = len;
5380if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
5381len = Top_datalen;
5382{
5383size_t Top_Tag_datalen, Top_Tag_oldlen;
5384Der_type Top_Tag_type;
5385e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_Tag_type, UT_Sequence, &Top_Tag_datalen, &l);
5386if (e == 0 && Top_Tag_type != CONS) { e = ASN1_BAD_ID; }
5387if(e) goto fail;
5388p += l; len -= l; ret += l;
5389Top_Tag_oldlen = len;
5390if (Top_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
5391len = Top_Tag_datalen;
5392{
5393size_t apRep_datalen, apRep_oldlen;
5394Der_type apRep_type;
5395e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &apRep_type, 0, &apRep_datalen, &l);
5396if (e == 0 && apRep_type != CONS) { e = ASN1_BAD_ID; }
5397if(e) goto fail;
5398p += l; len -= l; ret += l;
5399apRep_oldlen = len;
5400if (apRep_datalen > len) { e = ASN1_OVERRUN; goto fail; }
5401len = apRep_datalen;
5402{
5403size_t apRep_Tag_datalen, apRep_Tag_oldlen;
5404Der_type apRep_Tag_type;
5405e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &apRep_Tag_type, UT_OctetString, &apRep_Tag_datalen, &l);
5406if (e == 0 && apRep_Tag_type != PRIM) { e = ASN1_BAD_ID; }
5407if(e) goto fail;
5408p += l; len -= l; ret += l;
5409apRep_Tag_oldlen = len;
5410if (apRep_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
5411len = apRep_Tag_datalen;
5412e = der_get_octet_string(p, len, &(data)->apRep, &l);
5413if(e) goto fail;
5414p += l; len -= l; ret += l;
5415len = apRep_Tag_oldlen - apRep_Tag_datalen;
5416}
5417len = apRep_oldlen - apRep_datalen;
5418}
5419{
5420size_t innerRep_datalen, innerRep_oldlen;
5421Der_type innerRep_type;
5422e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &innerRep_type, 1, &innerRep_datalen, &l);
5423if (e == 0 && innerRep_type != CONS) { e = ASN1_BAD_ID; }
5424if(e) goto fail;
5425p += l; len -= l; ret += l;
5426innerRep_oldlen = len;
5427if (innerRep_datalen > len) { e = ASN1_OVERRUN; goto fail; }
5428len = innerRep_datalen;
5429e = decode_EncryptedData(p, len, &(data)->innerRep, &l);
5430if(e) goto fail;
5431p += l; len -= l; ret += l;
5432len = innerRep_oldlen - innerRep_datalen;
5433}
5434len = Top_Tag_oldlen - Top_Tag_datalen;
5435}
5436len = Top_oldlen - Top_datalen;
5437}
5438if(size) *size = ret;
5439return 0;
5440fail:
5441free_DigestREP(data);
5442return e;
5443}
5444
5445void ASN1CALL
5446free_DigestREP(DigestREP *data)
5447{
5448der_free_octet_string(&(data)->apRep);
5449free_EncryptedData(&(data)->innerRep);
5450}
5451
5452size_t ASN1CALL
5453length_DigestREP(const DigestREP *data)
5454{
5455size_t ret = 0;
5456{
5457size_t Top_tag_tag_oldret = ret;
5458ret = 0;
5459ret += der_length_octet_string(&(data)->apRep);
5460ret += 1 + der_length_len (ret);
5461ret += 1 + der_length_len (ret);
5462ret += Top_tag_tag_oldret;
5463}
5464{
5465size_t Top_tag_tag_oldret = ret;
5466ret = 0;
5467ret += length_EncryptedData(&(data)->innerRep);
5468ret += 1 + der_length_len (ret);
5469ret += Top_tag_tag_oldret;
5470}
5471ret += 1 + der_length_len (ret);
5472ret += 3 + der_length_len (ret);
5473return ret;
5474}
5475
5476int ASN1CALL
5477copy_DigestREP(const DigestREP *from, DigestREP *to)
5478{
5479memset(to, 0, sizeof(*to));
5480if(der_copy_octet_string(&(from)->apRep, &(to)->apRep)) goto fail;
5481if(copy_EncryptedData(&(from)->innerRep, &(to)->innerRep)) goto fail;
5482return 0;
5483fail:
5484free_DigestREP(to);
5485return ENOMEM;
5486}
5487
5488