spnegokrb5/spnego_asn1.h

   1 /* Generated from spnego.asn1 */
   2 /* Do not edit */
   3
   4 #ifndef __spnego_asn1_h__
   5 #define __spnego_asn1_h__
   6
   7 #include <stddef.h>
   8 #include <time.h>
   9
  10 #ifndef __asn1_common_definitions__
  11 #define __asn1_common_definitions__
  12
  13 typedef struct octet_string {
  14   size_t length;
  15   void *data;
  16 } octet_string;
  17
  18 typedef char *general_string;
  19
  20 typedef struct oid {
  21   size_t length;
  22   unsigned *components;
  23 } oid;
  24
  25 #define ASN1_MALLOC_ENCODE(T, B, BL, S, L, R)                  \
  26   do {                                                         \
  27     (BL) = length_##T((S));                                    \
  28     (B) = malloc((BL));                                        \
  29     if((B) == NULL) {                                          \
  30       (R) = ENOMEM;                                            \
  31     } else {                                                   \
  32       (R) = encode_##T(((unsigned char*)(B)) + (BL) - 1, (BL), \
  33                        (S), (L));                              \
  34       if((R) != 0) {                                           \
  35         free((B));                                             \
  36         (B) = NULL;                                            \
  37       }                                                        \
  38     }                                                          \
  39   } while (0)
  40
  41 #endif
  42
  43 /*
  44 MechType ::= OBJECT IDENTIFIER
  45 */
  46
  47 typedef oid MechType;
  48
  49 int    encode_MechType(unsigned char *, size_t, const MechType *, size_t *);
  50 int    decode_MechType(const unsigned char *, size_t, MechType *, size_t *);
  51 void   free_MechType  (MechType *);
  52 size_t length_MechType(const MechType *);
  53 int    copy_MechType  (const MechType *, MechType *);
  54
  55
  56 /*
  57 MechTypeList ::= SEQUENCE OF MechType
  58 */
  59
  60 typedef struct MechTypeList {
  61   unsigned int len;
  62   MechType *val;
  63 } MechTypeList;
  64
  65 int    encode_MechTypeList(unsigned char *, size_t, const MechTypeList *, size_t *);
  66 int    decode_MechTypeList(const unsigned char *, size_t, MechTypeList *, size_t *);
  67 void   free_MechTypeList  (MechTypeList *);
  68 size_t length_MechTypeList(const MechTypeList *);
  69 int    copy_MechTypeList  (const MechTypeList *, MechTypeList *);
  70
  71
  72 /*
  73 ContextFlags ::= BIT STRING {
  74   delegFlag(0),
  75   mutualFlag(1),
  76   replayFlag(2),
  77   sequenceFlag(3),
  78   anonFlag(4),
  79   confFlag(5),
  80   integFlag(6)
  81 }
  82 */
  83
  84 typedef struct ContextFlags {
  85   unsigned int delegFlag:1;
  86   unsigned int mutualFlag:1;
  87   unsigned int replayFlag:1;
  88   unsigned int sequenceFlag:1;
  89   unsigned int anonFlag:1;
  90   unsigned int confFlag:1;
  91   unsigned int integFlag:1;
  92 } ContextFlags;
  93
  94
  95 int    encode_ContextFlags(unsigned char *, size_t, const ContextFlags *, size_t *);
  96 int    decode_ContextFlags(const unsigned char *, size_t, ContextFlags *, size_t *);
  97 void   free_ContextFlags  (ContextFlags *);
  98 size_t length_ContextFlags(const ContextFlags *);
  99 int    copy_ContextFlags  (const ContextFlags *, ContextFlags *);
 100 unsigned ContextFlags2int(ContextFlags);
 101 ContextFlags int2ContextFlags(unsigned);
 102 /* XXX causes problem on some platforms
 103 extern struct units ContextFlags_units[];
 104 */
 105
 106 /*
 107 NegTokenInit ::= SEQUENCE {
 108   mechTypes[0]    MechTypeList OPTIONAL,
 109   reqFlags[1]     ContextFlags OPTIONAL,
 110   mechToken[2]    OCTET STRING OPTIONAL,
 111   mechListMIC[3]  OCTET STRING OPTIONAL
 112 }
 113 */
 114
 115 typedef struct NegTokenInit {
 116   MechTypeList *mechTypes;
 117   ContextFlags *reqFlags;
 118   octet_string *mechToken;
 119   octet_string *mechListMIC;
 120 } NegTokenInit;
 121
 122 int    encode_NegTokenInit(unsigned char *, size_t, const NegTokenInit *, size_t *);
 123 int    decode_NegTokenInit(const unsigned char *, size_t, NegTokenInit *, size_t *);
 124 void   free_NegTokenInit  (NegTokenInit *);
 125 size_t length_NegTokenInit(const NegTokenInit *);
 126 int    copy_NegTokenInit  (const NegTokenInit *, NegTokenInit *);
 127
 128
 129 /*
 130 NegTokenTarg ::= SEQUENCE {
 131   negResult[0]      ENUMERATED {
 132     accept_completed(0),
 133     accept_incomplete(1),
 134     reject(2)
 135   } OPTIONAL,
 136   supportedMech[1]  MechType OPTIONAL,
 137   responseToken[2]  OCTET STRING OPTIONAL,
 138   mechListMIC[3]    OCTET STRING OPTIONAL
 139 }
 140 */
 141
 142 typedef struct NegTokenTarg {
 143   enum  {
 144     accept_completed = 0,
 145     accept_incomplete = 1,
 146     reject = 2
 147   } *negResult;
 148
 149   MechType *supportedMech;
 150   octet_string *responseToken;
 151   octet_string *mechListMIC;
 152 } NegTokenTarg;
 153
 154 int    encode_NegTokenTarg(unsigned char *, size_t, const NegTokenTarg *, size_t *);
 155 int    decode_NegTokenTarg(const unsigned char *, size_t, NegTokenTarg *, size_t *);
 156 void   free_NegTokenTarg  (NegTokenTarg *);
 157 size_t length_NegTokenTarg(const NegTokenTarg *);
 158 int    copy_NegTokenTarg  (const NegTokenTarg *, NegTokenTarg *);
 159
 160
 161 #endif /* __spnego_asn1_h__ */