spnegokrb5/asn1_NegTokenInit.c

   1 /* Generated from spnego.asn1 */
   2 /* Do not edit */
   3
   4 #include <stdio.h>
   5 #include <stdlib.h>
   6 #include <time.h>
   7 #include <string.h>
   8 #include <errno.h>
   9 #include <spnego_asn1.h>
  10 #include <asn1_err.h>
  11 #include <der.h>
  12 #include <parse_units.h>
  13
  14 #define BACK if (e) return e; p -= l; len -= l; ret += l
  15
  16 int
  17 encode_NegTokenInit(unsigned char *p, size_t len, const NegTokenInit *data, size_t *size)
  18 {
  19 size_t ret = 0;
  20 size_t l;
  21 int i, e;
  22
  23 i = 0;
  24 if((data)->mechListMIC)
  25 {
  26 int oldret = ret;
  27 ret = 0;
  28 e = encode_octet_string(p, len, (data)->mechListMIC, &l);
  29 BACK;
  30 e = der_put_length_and_tag (p, len, ret, KERB_CTXT, CONS, 3, &l);
  31 BACK;
  32 ret += oldret;
  33 }
  34 if((data)->mechToken)
  35 {
  36 int oldret = ret;
  37 ret = 0;
  38 e = encode_octet_string(p, len, (data)->mechToken, &l);
  39 BACK;
  40 e = der_put_length_and_tag (p, len, ret, KERB_CTXT, CONS, 2, &l);
  41 BACK;
  42 ret += oldret;
  43 }
  44 if((data)->reqFlags)
  45 {
  46 int oldret = ret;
  47 ret = 0;
  48 e = encode_ContextFlags(p, len, (data)->reqFlags, &l);
  49 BACK;
  50 e = der_put_length_and_tag (p, len, ret, KERB_CTXT, CONS, 1, &l);
  51 BACK;
  52 ret += oldret;
  53 }
  54 if((data)->mechTypes)
  55 {
  56 int oldret = ret;
  57 ret = 0;
  58 e = encode_MechTypeList(p, len, (data)->mechTypes, &l);
  59 BACK;
  60 e = der_put_length_and_tag (p, len, ret, KERB_CTXT, CONS, 0, &l);
  61 BACK;
  62 ret += oldret;
  63 }
  64 e = der_put_length_and_tag (p, len, ret, UNIV, CONS, UT_Sequence, &l);
  65 BACK;
  66 *size = ret;
  67 return 0;
  68 }
  69
  70 #define FORW if(e) goto fail; p += l; len -= l; ret += l
  71
  72 int
  73 decode_NegTokenInit(const unsigned char *p, size_t len, NegTokenInit *data, size_t *size)
  74 {
  75 size_t ret = 0, reallen;
  76 size_t l;
  77 int e;
  78
  79 memset(data, 0, sizeof(*data));
  80 reallen = 0;
  81 e = der_match_tag_and_length (p, len, UNIV, CONS, UT_Sequence,&reallen, &l);
  82 FORW;
  83 {
  84 int dce_fix;
  85 if((dce_fix = fix_dce(reallen, &len)) < 0)
  86 return ASN1_BAD_FORMAT;
  87 {
  88 size_t newlen, oldlen;
  89
  90 e = der_match_tag (p, len, KERB_CTXT, CONS, 0, &l);
  91 if (e)
  92 (data)->mechTypes = NULL;
  93 else {
  94 p += l;
  95 len -= l;
  96 ret += l;
  97 e = der_get_length (p, len, &newlen, &l);
  98 FORW;
  99 {
 100 int dce_fix;
 101 oldlen = len;
 102 if((dce_fix = fix_dce(newlen, &len)) < 0)return ASN1_BAD_FORMAT;
 103 (data)->mechTypes = malloc(sizeof(*(data)->mechTypes));
 104 if((data)->mechTypes == NULL) return ENOMEM;
 105 e = decode_MechTypeList(p, len, (data)->mechTypes, &l);
 106 FORW;
 107 if(dce_fix){
 108 e = der_match_tag_and_length (p, len, (Der_class)0, (Der_type)0, 0, &reallen, &l);
 109 FORW;
 110 }else
 111 len = oldlen - newlen;
 112 }
 113 }
 114 }
 115 {
 116 size_t newlen, oldlen;
 117
 118 e = der_match_tag (p, len, KERB_CTXT, CONS, 1, &l);
 119 if (e)
 120 (data)->reqFlags = NULL;
 121 else {
 122 p += l;
 123 len -= l;
 124 ret += l;
 125 e = der_get_length (p, len, &newlen, &l);
 126 FORW;
 127 {
 128 int dce_fix;
 129 oldlen = len;
 130 if((dce_fix = fix_dce(newlen, &len)) < 0)return ASN1_BAD_FORMAT;
 131 (data)->reqFlags = malloc(sizeof(*(data)->reqFlags));
 132 if((data)->reqFlags == NULL) return ENOMEM;
 133 e = decode_ContextFlags(p, len, (data)->reqFlags, &l);
 134 FORW;
 135 if(dce_fix){
 136 e = der_match_tag_and_length (p, len, (Der_class)0, (Der_type)0, 0, &reallen, &l);
 137 FORW;
 138 }else
 139 len = oldlen - newlen;
 140 }
 141 }
 142 }
 143 {
 144 size_t newlen, oldlen;
 145
 146 e = der_match_tag (p, len, KERB_CTXT, CONS, 2, &l);
 147 if (e)
 148 (data)->mechToken = NULL;
 149 else {
 150 p += l;
 151 len -= l;
 152 ret += l;
 153 e = der_get_length (p, len, &newlen, &l);
 154 FORW;
 155 {
 156 int dce_fix;
 157 oldlen = len;
 158 if((dce_fix = fix_dce(newlen, &len)) < 0)return ASN1_BAD_FORMAT;
 159 (data)->mechToken = malloc(sizeof(*(data)->mechToken));
 160 if((data)->mechToken == NULL) return ENOMEM;
 161 e = decode_octet_string(p, len, (data)->mechToken, &l);
 162 FORW;
 163 if(dce_fix){
 164 e = der_match_tag_and_length (p, len, (Der_class)0, (Der_type)0, 0, &reallen, &l);
 165 FORW;
 166 }else
 167 len = oldlen - newlen;
 168 }
 169 }
 170 }
 171 {
 172 size_t newlen, oldlen;
 173
 174 e = der_match_tag (p, len, KERB_CTXT, CONS, 3, &l);
 175 if (e)
 176 (data)->mechListMIC = NULL;
 177 else {
 178 p += l;
 179 len -= l;
 180 ret += l;
 181 e = der_get_length (p, len, &newlen, &l);
 182 FORW;
 183 {
 184 int dce_fix;
 185 oldlen = len;
 186 if((dce_fix = fix_dce(newlen, &len)) < 0)return ASN1_BAD_FORMAT;
 187 (data)->mechListMIC = malloc(sizeof(*(data)->mechListMIC));
 188 if((data)->mechListMIC == NULL) return ENOMEM;
 189 e = decode_octet_string(p, len, (data)->mechListMIC, &l);
 190 FORW;
 191 if(dce_fix){
 192 e = der_match_tag_and_length (p, len, (Der_class)0, (Der_type)0, 0, &reallen, &l);
 193 FORW;
 194 }else
 195 len = oldlen - newlen;
 196 }
 197 }
 198 }
 199 if(dce_fix){
 200 e = der_match_tag_and_length (p, len, (Der_class)0, (Der_type)0, 0, &reallen, &l);
 201 FORW;
 202 }
 203 }
 204 if(size) *size = ret;
 205 return 0;
 206 fail:
 207 free_NegTokenInit(data);
 208 return e;
 209 }
 210
 211 void
 212 free_NegTokenInit(NegTokenInit *data)
 213 {
 214 if((data)->mechTypes) {
 215 free_MechTypeList((data)->mechTypes);
 216 free((data)->mechTypes);
 217 }
 218 if((data)->reqFlags) {
 219 free_ContextFlags((data)->reqFlags);
 220 free((data)->reqFlags);
 221 }
 222 if((data)->mechToken) {
 223 free_octet_string((data)->mechToken);
 224 free((data)->mechToken);
 225 }
 226 if((data)->mechListMIC) {
 227 free_octet_string((data)->mechListMIC);
 228 free((data)->mechListMIC);
 229 }
 230 }
 231
 232 size_t
 233 length_NegTokenInit(const NegTokenInit *data)
 234 {
 235 size_t ret = 0;
 236 if((data)->mechTypes){
 237 int oldret = ret;
 238 ret = 0;
 239 ret += length_MechTypeList((data)->mechTypes);
 240 ret += 1 + length_len(ret) + oldret;
 241 }
 242 if((data)->reqFlags){
 243 int oldret = ret;
 244 ret = 0;
 245 ret += length_ContextFlags((data)->reqFlags);
 246 ret += 1 + length_len(ret) + oldret;
 247 }
 248 if((data)->mechToken){
 249 int oldret = ret;
 250 ret = 0;
 251 ret += length_octet_string((data)->mechToken);
 252 ret += 1 + length_len(ret) + oldret;
 253 }
 254 if((data)->mechListMIC){
 255 int oldret = ret;
 256 ret = 0;
 257 ret += length_octet_string((data)->mechListMIC);
 258 ret += 1 + length_len(ret) + oldret;
 259 }
 260 ret += 1 + length_len(ret);
 261 return ret;
 262 }
 263
 264 int
 265 copy_NegTokenInit(const NegTokenInit *from, NegTokenInit *to)
 266 {
 267 if((from)->mechTypes) {
 268 (to)->mechTypes = malloc(sizeof(*(to)->mechTypes));
 269 if((to)->mechTypes == NULL) return ENOMEM;
 270 if(copy_MechTypeList((from)->mechTypes, (to)->mechTypes)) return ENOMEM;
 271 }else
 272 (to)->mechTypes = NULL;
 273 if((from)->reqFlags) {
 274 (to)->reqFlags = malloc(sizeof(*(to)->reqFlags));
 275 if((to)->reqFlags == NULL) return ENOMEM;
 276 if(copy_ContextFlags((from)->reqFlags, (to)->reqFlags)) return ENOMEM;
 277 }else
 278 (to)->reqFlags = NULL;
 279 if((from)->mechToken) {
 280 (to)->mechToken = malloc(sizeof(*(to)->mechToken));
 281 if((to)->mechToken == NULL) return ENOMEM;
 282 if(copy_octet_string((from)->mechToken, (to)->mechToken)) return ENOMEM;
 283 }else
 284 (to)->mechToken = NULL;
 285 if((from)->mechListMIC) {
 286 (to)->mechListMIC = malloc(sizeof(*(to)->mechListMIC));
 287 if((to)->mechListMIC == NULL) return ENOMEM;
 288 if(copy_octet_string((from)->mechListMIC, (to)->mechListMIC)) return ENOMEM;
 289 }else
 290 (to)->mechListMIC = NULL;
 291 return 0;
 292 }
 293