2 * Copyright (C) 2006, 2007 Internet Systems Consortium, Inc. ("ISC")
4 * Permission to use, copy, modify, and/or distribute this software for any
5 * purpose with or without fee is hereby granted, provided that the above
6 * copyright notice and this permission notice appear in all copies.
8 * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
9 * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
10 * AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
11 * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
12 * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
13 * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
14 * PERFORMANCE OF THIS SOFTWARE.
17 /* $Id: spnego_asn1.c,v 1.4 2007/06/19 23:47:16 tbox Exp $ */
20 * \brief Method routines generated from SPNEGO ASN.1 module.
21 * See spnego_asn1.pl for details. Do not edit.
24 /* Generated from spnego.asn1 */
31 #ifndef __asn1_common_definitions__
32 #define __asn1_common_definitions__
34 typedef struct octet_string {
39 typedef char *general_string;
41 typedef char *utf8_string;
48 #define ASN1_MALLOC_ENCODE(T, B, BL, S, L, R) \
50 (BL) = length_##T((S)); \
55 (R) = encode_##T(((unsigned char*)(B)) + (BL) - 1, (BL), \
67 * MechType ::= OBJECT IDENTIFIER
72 static int encode_MechType(unsigned char *, size_t, const MechType *, size_t *);
73 static int decode_MechType(const unsigned char *, size_t, MechType *, size_t *);
74 static void free_MechType(MechType *);
75 /* unused declaration: length_MechType */
76 /* unused declaration: copy_MechType */
80 * MechTypeList ::= SEQUENCE OF MechType
83 typedef struct MechTypeList {
88 static int encode_MechTypeList(unsigned char *, size_t, const MechTypeList *, size_t *);
89 static int decode_MechTypeList(const unsigned char *, size_t, MechTypeList *, size_t *);
90 static void free_MechTypeList(MechTypeList *);
91 /* unused declaration: length_MechTypeList */
92 /* unused declaration: copy_MechTypeList */
96 * ContextFlags ::= BIT STRING { delegFlag(0), mutualFlag(1), replayFlag(2),
97 * sequenceFlag(3), anonFlag(4), confFlag(5), integFlag(6) }
100 typedef struct ContextFlags {
101 unsigned int delegFlag:1;
102 unsigned int mutualFlag:1;
103 unsigned int replayFlag:1;
104 unsigned int sequenceFlag:1;
105 unsigned int anonFlag:1;
106 unsigned int confFlag:1;
107 unsigned int integFlag:1;
111 static int encode_ContextFlags(unsigned char *, size_t, const ContextFlags *, size_t *);
112 static int decode_ContextFlags(const unsigned char *, size_t, ContextFlags *, size_t *);
113 static void free_ContextFlags(ContextFlags *);
114 /* unused declaration: length_ContextFlags */
115 /* unused declaration: copy_ContextFlags */
116 /* unused declaration: ContextFlags2int */
117 /* unused declaration: int2ContextFlags */
118 /* unused declaration: asn1_ContextFlags_units */
121 * NegTokenInit ::= SEQUENCE { mechTypes[0] MechTypeList, reqFlags[1]
122 * ContextFlags OPTIONAL, mechToken[2] OCTET STRING OPTIONAL,
123 * mechListMIC[3] OCTET STRING OPTIONAL }
126 typedef struct NegTokenInit {
127 MechTypeList mechTypes;
128 ContextFlags *reqFlags;
129 octet_string *mechToken;
130 octet_string *mechListMIC;
133 static int encode_NegTokenInit(unsigned char *, size_t, const NegTokenInit *, size_t *);
134 static int decode_NegTokenInit(const unsigned char *, size_t, NegTokenInit *, size_t *);
135 static void free_NegTokenInit(NegTokenInit *);
136 /* unused declaration: length_NegTokenInit */
137 /* unused declaration: copy_NegTokenInit */
141 * NegTokenResp ::= SEQUENCE { negState[0] ENUMERATED {
142 * accept-completed(0), accept-incomplete(1), reject(2), request-mic(3) }
143 * OPTIONAL, supportedMech[1] MechType OPTIONAL, responseToken[2] OCTET
144 * STRING OPTIONAL, mechListMIC[3] OCTET STRING OPTIONAL }
147 typedef struct NegTokenResp {
149 accept_completed = 0,
150 accept_incomplete = 1,
155 MechType *supportedMech;
156 octet_string *responseToken;
157 octet_string *mechListMIC;
160 static int encode_NegTokenResp(unsigned char *, size_t, const NegTokenResp *, size_t *);
161 static int decode_NegTokenResp(const unsigned char *, size_t, NegTokenResp *, size_t *);
162 static void free_NegTokenResp(NegTokenResp *);
163 /* unused declaration: length_NegTokenResp */
164 /* unused declaration: copy_NegTokenResp */
169 #endif /* __asn1_h__ */
170 /* Generated from spnego.asn1 */
174 #define BACK if (e) return e; p -= l; len -= l; ret += l
177 encode_MechType(unsigned char *p, size_t len, const MechType * data, size_t * size)
184 e = encode_oid(p, len, data, &l);
190 #define FORW if(e) goto fail; p += l; len -= l; ret += l
193 decode_MechType(const unsigned char *p, size_t len, MechType * data, size_t * size)
195 size_t ret = 0, reallen;
199 memset(data, 0, sizeof(*data));
201 e = decode_oid(p, len, data, &l);
212 free_MechType(MechType * data)
217 /* unused function: length_MechType */
220 /* unused function: copy_MechType */
222 /* Generated from spnego.asn1 */
226 #define BACK if (e) return e; p -= l; len -= l; ret += l
229 encode_MechTypeList(unsigned char *p, size_t len, const MechTypeList * data, size_t * size)
236 for (i = (data)->len - 1; i >= 0; --i) {
239 e = encode_MechType(p, len, &(data)->val[i], &l);
243 e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
249 #define FORW if(e) goto fail; p += l; len -= l; ret += l
252 decode_MechTypeList(const unsigned char *p, size_t len, MechTypeList * data, size_t * size)
254 size_t ret = 0, reallen;
258 memset(data, 0, sizeof(*data));
260 e = der_match_tag_and_length(p, len, ASN1_C_UNIV, CONS, UT_Sequence, &reallen, &l);
266 size_t origlen = len;
271 while (ret < origlen) {
273 (data)->val = realloc((data)->val, sizeof(*((data)->val)) * (data)->len);
274 e = decode_MechType(p, len, &(data)->val[(data)->len - 1], &l);
284 free_MechTypeList(data);
289 free_MechTypeList(MechTypeList * data)
291 while ((data)->len) {
292 free_MechType(&(data)->val[(data)->len - 1]);
299 /* unused function: length_MechTypeList */
302 /* unused function: copy_MechTypeList */
304 /* Generated from spnego.asn1 */
308 #define BACK if (e) return e; p -= l; len -= l; ret += l
311 encode_ContextFlags(unsigned char *p, size_t len, const ContextFlags * data, size_t * size)
338 if (data->sequenceFlag)
340 if (data->replayFlag)
342 if (data->mutualFlag)
352 e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, PRIM, UT_BitString, &l);
358 #define FORW if(e) goto fail; p += l; len -= l; ret += l
361 decode_ContextFlags(const unsigned char *p, size_t len, ContextFlags * data, size_t * size)
363 size_t ret = 0, reallen;
367 memset(data, 0, sizeof(*data));
369 e = der_match_tag_and_length(p, len, ASN1_C_UNIV, PRIM, UT_BitString, &reallen, &l);
377 data->delegFlag = (*p >> 7) & 1;
378 data->mutualFlag = (*p >> 6) & 1;
379 data->replayFlag = (*p >> 5) & 1;
380 data->sequenceFlag = (*p >> 4) & 1;
381 data->anonFlag = (*p >> 3) & 1;
382 data->confFlag = (*p >> 2) & 1;
383 data->integFlag = (*p >> 1) & 1;
391 free_ContextFlags(data);
396 free_ContextFlags(ContextFlags * data)
401 /* unused function: length_ContextFlags */
404 /* unused function: copy_ContextFlags */
407 /* unused function: ContextFlags2int */
410 /* unused function: int2ContextFlags */
413 /* unused variable: ContextFlags_units */
415 /* unused function: asn1_ContextFlags_units */
417 /* Generated from spnego.asn1 */
421 #define BACK if (e) return e; p -= l; len -= l; ret += l
424 encode_NegTokenInit(unsigned char *p, size_t len, const NegTokenInit * data, size_t * size)
431 if ((data)->mechListMIC) {
434 e = encode_octet_string(p, len, (data)->mechListMIC, &l);
436 e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
440 if ((data)->mechToken) {
443 e = encode_octet_string(p, len, (data)->mechToken, &l);
445 e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
449 if ((data)->reqFlags) {
452 e = encode_ContextFlags(p, len, (data)->reqFlags, &l);
454 e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
460 e = encode_MechTypeList(p, len, &(data)->mechTypes, &l);
462 e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
466 e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
472 #define FORW if(e) goto fail; p += l; len -= l; ret += l
475 decode_NegTokenInit(const unsigned char *p, size_t len, NegTokenInit * data, size_t * size)
477 size_t ret = 0, reallen;
481 memset(data, 0, sizeof(*data));
483 e = der_match_tag_and_length(p, len, ASN1_C_UNIV, CONS, UT_Sequence, &reallen, &l);
487 if ((dce_fix = fix_dce(reallen, &len)) < 0)
488 return ASN1_BAD_FORMAT;
490 size_t newlen, oldlen;
492 e = der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 0, &l);
499 e = der_get_length(p, len, &newlen, &l);
504 if ((dce_fix = fix_dce(newlen, &len)) < 0)
505 return ASN1_BAD_FORMAT;
506 e = decode_MechTypeList(p, len, &(data)->mechTypes, &l);
509 e = der_match_tag_and_length(p, len, (Der_class) 0, (Der_type) 0, 0, &reallen, &l);
512 len = oldlen - newlen;
517 size_t newlen, oldlen;
519 e = der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 1, &l);
521 (data)->reqFlags = NULL;
526 e = der_get_length(p, len, &newlen, &l);
531 if ((dce_fix = fix_dce(newlen, &len)) < 0)
532 return ASN1_BAD_FORMAT;
533 (data)->reqFlags = malloc(sizeof(*(data)->reqFlags));
534 if ((data)->reqFlags == NULL)
536 e = decode_ContextFlags(p, len, (data)->reqFlags, &l);
539 e = der_match_tag_and_length(p, len, (Der_class) 0, (Der_type) 0, 0, &reallen, &l);
542 len = oldlen - newlen;
547 size_t newlen, oldlen;
549 e = der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 2, &l);
551 (data)->mechToken = NULL;
556 e = der_get_length(p, len, &newlen, &l);
561 if ((dce_fix = fix_dce(newlen, &len)) < 0)
562 return ASN1_BAD_FORMAT;
563 (data)->mechToken = malloc(sizeof(*(data)->mechToken));
564 if ((data)->mechToken == NULL)
566 e = decode_octet_string(p, len, (data)->mechToken, &l);
569 e = der_match_tag_and_length(p, len, (Der_class) 0, (Der_type) 0, 0, &reallen, &l);
572 len = oldlen - newlen;
577 size_t newlen, oldlen;
579 e = der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 3, &l);
581 (data)->mechListMIC = NULL;
586 e = der_get_length(p, len, &newlen, &l);
591 if ((dce_fix = fix_dce(newlen, &len)) < 0)
592 return ASN1_BAD_FORMAT;
593 (data)->mechListMIC = malloc(sizeof(*(data)->mechListMIC));
594 if ((data)->mechListMIC == NULL)
596 e = decode_octet_string(p, len, (data)->mechListMIC, &l);
599 e = der_match_tag_and_length(p, len, (Der_class) 0, (Der_type) 0, 0, &reallen, &l);
602 len = oldlen - newlen;
607 e = der_match_tag_and_length(p, len, (Der_class) 0, (Der_type) 0, 0, &reallen, &l);
615 free_NegTokenInit(data);
620 free_NegTokenInit(NegTokenInit * data)
622 free_MechTypeList(&(data)->mechTypes);
623 if ((data)->reqFlags) {
624 free_ContextFlags((data)->reqFlags);
625 free((data)->reqFlags);
626 (data)->reqFlags = NULL;
628 if ((data)->mechToken) {
629 free_octet_string((data)->mechToken);
630 free((data)->mechToken);
631 (data)->mechToken = NULL;
633 if ((data)->mechListMIC) {
634 free_octet_string((data)->mechListMIC);
635 free((data)->mechListMIC);
636 (data)->mechListMIC = NULL;
640 /* unused function: length_NegTokenInit */
643 /* unused function: copy_NegTokenInit */
645 /* Generated from spnego.asn1 */
649 #define BACK if (e) return e; p -= l; len -= l; ret += l
652 encode_NegTokenResp(unsigned char *p, size_t len, const NegTokenResp * data, size_t * size)
659 if ((data)->mechListMIC) {
662 e = encode_octet_string(p, len, (data)->mechListMIC, &l);
664 e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
668 if ((data)->responseToken) {
671 e = encode_octet_string(p, len, (data)->responseToken, &l);
673 e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
677 if ((data)->supportedMech) {
680 e = encode_MechType(p, len, (data)->supportedMech, &l);
682 e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
686 if ((data)->negState) {
689 e = encode_enumerated(p, len, (data)->negState, &l);
691 e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
695 e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
701 #define FORW if(e) goto fail; p += l; len -= l; ret += l
704 decode_NegTokenResp(const unsigned char *p, size_t len, NegTokenResp * data, size_t * size)
706 size_t ret = 0, reallen;
710 memset(data, 0, sizeof(*data));
712 e = der_match_tag_and_length(p, len, ASN1_C_UNIV, CONS, UT_Sequence, &reallen, &l);
716 if ((dce_fix = fix_dce(reallen, &len)) < 0)
717 return ASN1_BAD_FORMAT;
719 size_t newlen, oldlen;
721 e = der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 0, &l);
723 (data)->negState = NULL;
728 e = der_get_length(p, len, &newlen, &l);
733 if ((dce_fix = fix_dce(newlen, &len)) < 0)
734 return ASN1_BAD_FORMAT;
735 (data)->negState = malloc(sizeof(*(data)->negState));
736 if ((data)->negState == NULL)
738 e = decode_enumerated(p, len, (data)->negState, &l);
741 e = der_match_tag_and_length(p, len, (Der_class) 0, (Der_type) 0, 0, &reallen, &l);
744 len = oldlen - newlen;
749 size_t newlen, oldlen;
751 e = der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 1, &l);
753 (data)->supportedMech = NULL;
758 e = der_get_length(p, len, &newlen, &l);
763 if ((dce_fix = fix_dce(newlen, &len)) < 0)
764 return ASN1_BAD_FORMAT;
765 (data)->supportedMech = malloc(sizeof(*(data)->supportedMech));
766 if ((data)->supportedMech == NULL)
768 e = decode_MechType(p, len, (data)->supportedMech, &l);
771 e = der_match_tag_and_length(p, len, (Der_class) 0, (Der_type) 0, 0, &reallen, &l);
774 len = oldlen - newlen;
779 size_t newlen, oldlen;
781 e = der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 2, &l);
783 (data)->responseToken = NULL;
788 e = der_get_length(p, len, &newlen, &l);
793 if ((dce_fix = fix_dce(newlen, &len)) < 0)
794 return ASN1_BAD_FORMAT;
795 (data)->responseToken = malloc(sizeof(*(data)->responseToken));
796 if ((data)->responseToken == NULL)
798 e = decode_octet_string(p, len, (data)->responseToken, &l);
801 e = der_match_tag_and_length(p, len, (Der_class) 0, (Der_type) 0, 0, &reallen, &l);
804 len = oldlen - newlen;
809 size_t newlen, oldlen;
811 e = der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 3, &l);
813 (data)->mechListMIC = NULL;
818 e = der_get_length(p, len, &newlen, &l);
823 if ((dce_fix = fix_dce(newlen, &len)) < 0)
824 return ASN1_BAD_FORMAT;
825 (data)->mechListMIC = malloc(sizeof(*(data)->mechListMIC));
826 if ((data)->mechListMIC == NULL)
828 e = decode_octet_string(p, len, (data)->mechListMIC, &l);
831 e = der_match_tag_and_length(p, len, (Der_class) 0, (Der_type) 0, 0, &reallen, &l);
834 len = oldlen - newlen;
839 e = der_match_tag_and_length(p, len, (Der_class) 0, (Der_type) 0, 0, &reallen, &l);
847 free_NegTokenResp(data);
852 free_NegTokenResp(NegTokenResp * data)
854 if ((data)->negState) {
855 free((data)->negState);
856 (data)->negState = NULL;
858 if ((data)->supportedMech) {
859 free_MechType((data)->supportedMech);
860 free((data)->supportedMech);
861 (data)->supportedMech = NULL;
863 if ((data)->responseToken) {
864 free_octet_string((data)->responseToken);
865 free((data)->responseToken);
866 (data)->responseToken = NULL;
868 if ((data)->mechListMIC) {
869 free_octet_string((data)->mechListMIC);
870 free((data)->mechListMIC);
871 (data)->mechListMIC = NULL;
875 /* unused function: length_NegTokenResp */
878 /* unused function: copy_NegTokenResp */
880 /* Generated from spnego.asn1 */
885 /* unused variable: asn1_NegotiationToken_dummy_holder */