spnegokrb5/asn1_NegTokenTarg.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_NegTokenTarg(unsigned char *p, size_t len, const NegTokenTarg *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)->responseToken)
  35 {
  36 int oldret = ret;
  37 ret = 0;
  38 e = encode_octet_string(p, len, (data)->responseToken, &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)->supportedMech)
  45 {
  46 int oldret = ret;
  47 ret = 0;
  48 e = encode_MechType(p, len, (data)->supportedMech, &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)->negResult)
  55 {
  56 int oldret = ret;
  57 ret = 0;
  58 e = encode_enumerated(p, len, (data)->negResult, &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_NegTokenTarg(const unsigned char *p, size_t len, NegTokenTarg *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)->negResult = 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)->negResult = malloc(sizeof(*(data)->negResult));
 104 if((data)->negResult == NULL) return ENOMEM;
 105 e = decode_enumerated(p, len, (data)->negResult, &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)->supportedMech = 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)->supportedMech = malloc(sizeof(*(data)->supportedMech));
 132 if((data)->supportedMech == NULL) return ENOMEM;
 133 e = decode_MechType(p, len, (data)->supportedMech, &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)->responseToken = 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)->responseToken = malloc(sizeof(*(data)->responseToken));
 160 if((data)->responseToken == NULL) return ENOMEM;
 161 e = decode_octet_string(p, len, (data)->responseToken, &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_NegTokenTarg(data);
 208 return e;
 209 }
 210
 211 void
 212 free_NegTokenTarg(NegTokenTarg *data)
 213 {
 214 if((data)->negResult) {
 215 free((data)->negResult);
 216 }
 217 if((data)->supportedMech) {
 218 free_MechType((data)->supportedMech);
 219 free((data)->supportedMech);
 220 }
 221 if((data)->responseToken) {
 222 free_octet_string((data)->responseToken);
 223 free((data)->responseToken);
 224 }
 225 if((data)->mechListMIC) {
 226 free_octet_string((data)->mechListMIC);
 227 free((data)->mechListMIC);
 228 }
 229 }
 230
 231 size_t
 232 length_NegTokenTarg(const NegTokenTarg *data)
 233 {
 234 size_t ret = 0;
 235 if((data)->negResult){
 236 int oldret = ret;
 237 ret = 0;
 238 ret += length_enumerated((data)->negResult);
 239 ret += 1 + length_len(ret) + oldret;
 240 }
 241 if((data)->supportedMech){
 242 int oldret = ret;
 243 ret = 0;
 244 ret += length_MechType((data)->supportedMech);
 245 ret += 1 + length_len(ret) + oldret;
 246 }
 247 if((data)->responseToken){
 248 int oldret = ret;
 249 ret = 0;
 250 ret += length_octet_string((data)->responseToken);
 251 ret += 1 + length_len(ret) + oldret;
 252 }
 253 if((data)->mechListMIC){
 254 int oldret = ret;
 255 ret = 0;
 256 ret += length_octet_string((data)->mechListMIC);
 257 ret += 1 + length_len(ret) + oldret;
 258 }
 259 ret += 1 + length_len(ret);
 260 return ret;
 261 }
 262
 263 int
 264 copy_NegTokenTarg(const NegTokenTarg *from, NegTokenTarg *to)
 265 {
 266 if((from)->negResult) {
 267 (to)->negResult = malloc(sizeof(*(to)->negResult));
 268 if((to)->negResult == NULL) return ENOMEM;
 269 *((to)->negResult) = *((from)->negResult);
 270 }else
 271 (to)->negResult = NULL;
 272 if((from)->supportedMech) {
 273 (to)->supportedMech = malloc(sizeof(*(to)->supportedMech));
 274 if((to)->supportedMech == NULL) return ENOMEM;
 275 if(copy_MechType((from)->supportedMech, (to)->supportedMech)) return ENOMEM;
 276 }else
 277 (to)->supportedMech = NULL;
 278 if((from)->responseToken) {
 279 (to)->responseToken = malloc(sizeof(*(to)->responseToken));
 280 if((to)->responseToken == NULL) return ENOMEM;
 281 if(copy_octet_string((from)->responseToken, (to)->responseToken)) return ENOMEM;
 282 }else
 283 (to)->responseToken = NULL;
 284 if((from)->mechListMIC) {
 285 (to)->mechListMIC = malloc(sizeof(*(to)->mechListMIC));
 286 if((to)->mechListMIC == NULL) return ENOMEM;
 287 if(copy_octet_string((from)->mechListMIC, (to)->mechListMIC)) return ENOMEM;
 288 }else
 289 (to)->mechListMIC = NULL;
 290 return 0;
 291 }
 292