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