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 */