text: /* Generated from spnego.asn1 */
  /* Do not edit */
  
  #ifndef __spnego_asn1_h__
  #define __spnego_asn1_h__
  
  #include <parse_units.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__ */
  