Added wrapping calls (gss_init_sec_context_spnego() and gss_accept_sec_context_spnego...

[mod_auth_kerb.git] / spnegokrb5 / spnego_asn1.h

diff --git a/spnegokrb5/spnego_asn1.h b/spnegokrb5/spnego_asn1.h
new file mode 100644 (file)
index 0000000..a58fe46
--- /dev/null
+++ b/spnegokrb5/spnego_asn1.h
@@ -0,0 +1,159 @@
+/* Generated from spnego.asn1 */
+/* Do not edit */
+
+#ifndef __spnego_asn1_h__
+#define __spnego_asn1_h__
+
+#include <stddef.h>
+#include <time.h>
+
+#ifndef __asn1_common_definitions__
+#define __asn1_common_definitions__
+
+typedef struct octet_string {
+  size_t length;
+  void *data;
+} octet_string;
+
+typedef char *general_string;
+
+typedef struct oid {
+  size_t length;
+  unsigned *components;
+} oid;
+
+#define ASN1_MALLOC_ENCODE(T, B, BL, S, L, R)                  \
+  do {                                                         \
+    (BL) = length_##T((S));                                    \
+    (B) = malloc((BL));                                        \
+    if((B) == NULL) {                                          \
+      (R) = ENOMEM;                                            \
+    } else {                                                   \
+      (R) = encode_##T(((unsigned char*)(B)) + (BL) - 1, (BL), \
+                       (S), (L));                              \
+      if((R) != 0) {                                           \
+        free((B));                                             \
+        (B) = NULL;                                            \
+      }                                                        \
+    }                                                          \
+  } while (0)
+
+#endif
+
+/*
+MechType ::= OBJECT IDENTIFIER
+*/
+
+typedef oid MechType;
+
+int    encode_MechType(unsigned char *, size_t, const MechType *, size_t *);
+int    decode_MechType(const unsigned char *, size_t, MechType *, size_t *);
+void   free_MechType  (MechType *);
+size_t length_MechType(const MechType *);
+int    copy_MechType  (const MechType *, MechType *);
+
+
+/*
+MechTypeList ::= SEQUENCE OF MechType
+*/
+
+typedef struct MechTypeList {
+  unsigned int len;
+  MechType *val;
+} MechTypeList;
+
+int    encode_MechTypeList(unsigned char *, size_t, const MechTypeList *, size_t *);
+int    decode_MechTypeList(const unsigned char *, size_t, MechTypeList *, size_t *);
+void   free_MechTypeList  (MechTypeList *);
+size_t length_MechTypeList(const MechTypeList *);
+int    copy_MechTypeList  (const MechTypeList *, MechTypeList *);
+
+
+/*
+ContextFlags ::= BIT STRING {
+  delegFlag(0),
+  mutualFlag(1),
+  replayFlag(2),
+  sequenceFlag(3),
+  anonFlag(4),
+  confFlag(5),
+  integFlag(6)
+}
+*/
+
+typedef struct ContextFlags {
+  unsigned int delegFlag:1;
+  unsigned int mutualFlag:1;
+  unsigned int replayFlag:1;
+  unsigned int sequenceFlag:1;
+  unsigned int anonFlag:1;
+  unsigned int confFlag:1;
+  unsigned int integFlag:1;
+} ContextFlags;
+
+
+int    encode_ContextFlags(unsigned char *, size_t, const ContextFlags *, size_t *);
+int    decode_ContextFlags(const unsigned char *, size_t, ContextFlags *, size_t *);
+void   free_ContextFlags  (ContextFlags *);
+size_t length_ContextFlags(const ContextFlags *);
+int    copy_ContextFlags  (const ContextFlags *, ContextFlags *);
+unsigned ContextFlags2int(ContextFlags);
+ContextFlags int2ContextFlags(unsigned);
+extern struct units ContextFlags_units[];
+
+/*
+NegTokenInit ::= SEQUENCE {
+  mechTypes[0]    MechTypeList OPTIONAL,
+  reqFlags[1]     ContextFlags OPTIONAL,
+  mechToken[2]    OCTET STRING OPTIONAL,
+  mechListMIC[3]  OCTET STRING OPTIONAL
+}
+*/
+
+typedef struct NegTokenInit {
+  MechTypeList *mechTypes;
+  ContextFlags *reqFlags;
+  octet_string *mechToken;
+  octet_string *mechListMIC;
+} NegTokenInit;
+
+int    encode_NegTokenInit(unsigned char *, size_t, const NegTokenInit *, size_t *);
+int    decode_NegTokenInit(const unsigned char *, size_t, NegTokenInit *, size_t *);
+void   free_NegTokenInit  (NegTokenInit *);
+size_t length_NegTokenInit(const NegTokenInit *);
+int    copy_NegTokenInit  (const NegTokenInit *, NegTokenInit *);
+
+
+/*
+NegTokenTarg ::= SEQUENCE {
+  negResult[0]      ENUMERATED {
+    accept_completed(0),
+    accept_incomplete(1),
+    reject(2)
+  } OPTIONAL,
+  supportedMech[1]  MechType OPTIONAL,
+  responseToken[2]  OCTET STRING OPTIONAL,
+  mechListMIC[3]    OCTET STRING OPTIONAL
+}
+*/
+
+typedef struct NegTokenTarg {
+  enum  {
+    accept_completed = 0,
+    accept_incomplete = 1,
+    reject = 2
+  } *negResult;
+
+  MechType *supportedMech;
+  octet_string *responseToken;
+  octet_string *mechListMIC;
+} NegTokenTarg;
+
+int    encode_NegTokenTarg(unsigned char *, size_t, const NegTokenTarg *, size_t *);
+int    decode_NegTokenTarg(const unsigned char *, size_t, NegTokenTarg *, size_t *);
+void   free_NegTokenTarg  (NegTokenTarg *);
+size_t length_NegTokenTarg(const NegTokenTarg *);
+int    copy_NegTokenTarg  (const NegTokenTarg *, NegTokenTarg *);
+
+
+#endif /* __spnego_asn1_h__ */