src/rxkad/v5gen.c

   1 /* Generated from /home/lha/src/cvs/heimdal/lib/asn1/k5.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 <asn1_err.h>
  10
  11 #define BACK if (e) return e; p -= l; len -= l; ret += l
  12
  13 int
  14 encode_Ticket(unsigned char *p, size_t len, const Ticket *data, size_t *size)
  15 {
  16 size_t ret = 0;
  17 size_t l;
  18 int i, e;
  19
  20 i = 0;
  21 {
  22 int oldret = ret;
  23 ret = 0;
  24 e = encode_EncryptedData(p, len, &(data)->enc_part, &l);
  25 BACK;
  26 e = der_put_length_and_tag (p, len, ret, Der_CONTEXT, CONS, 3, &l);
  27 BACK;
  28 ret += oldret;
  29 }
  30 {
  31 int oldret = ret;
  32 ret = 0;
  33 e = encode_PrincipalName(p, len, &(data)->sname, &l);
  34 BACK;
  35 e = der_put_length_and_tag (p, len, ret, Der_CONTEXT, CONS, 2, &l);
  36 BACK;
  37 ret += oldret;
  38 }
  39 {
  40 int oldret = ret;
  41 ret = 0;
  42 e = encode_Realm(p, len, &(data)->realm, &l);
  43 BACK;
  44 e = der_put_length_and_tag (p, len, ret, Der_CONTEXT, CONS, 1, &l);
  45 BACK;
  46 ret += oldret;
  47 }
  48 {
  49 int oldret = ret;
  50 ret = 0;
  51 e = encode_integer(p, len, &(data)->tkt_vno, &l);
  52 BACK;
  53 e = der_put_length_and_tag (p, len, ret, Der_CONTEXT, CONS, 0, &l);
  54 BACK;
  55 ret += oldret;
  56 }
  57 e = der_put_length_and_tag (p, len, ret, UNIV, CONS, UT_Sequence, &l);
  58 BACK;
  59 e = der_put_length_and_tag (p, len, ret, APPL, CONS, 1, &l);
  60 BACK;
  61 *size = ret;
  62 return 0;
  63 }
  64
  65 #define FORW if(e) goto fail; p += l; len -= l; ret += l
  66
  67 int
  68 decode_Ticket(const unsigned char *p, size_t len, Ticket *data, size_t *size)
  69 {
  70 size_t ret = 0, reallen;
  71 size_t l;
  72 int e;
  73
  74 memset(data, 0, sizeof(*data));
  75 reallen = 0;
  76 e = der_match_tag_and_length (p, len, APPL, CONS, 1, &reallen, &l);
  77 FORW;
  78 {
  79 int dce_fix;
  80 if((dce_fix = fix_dce(reallen, &len)) < 0)
  81 return ASN1_BAD_FORMAT;
  82 e = der_match_tag_and_length (p, len, UNIV, CONS, UT_Sequence,&reallen, &l);
  83 FORW;
  84 {
  85 int dce_fix;
  86 if((dce_fix = fix_dce(reallen, &len)) < 0)
  87 return ASN1_BAD_FORMAT;
  88 {
  89 size_t newlen, oldlen;
  90
  91 e = der_match_tag (p, len, Der_CONTEXT, CONS, 0, &l);
  92 if (e)
  93 return e;
  94 else {
  95 p += l;
  96 len -= l;
  97 ret += l;
  98 e = der_get_length (p, len, &newlen, &l);
  99 FORW;
 100 {
 101 int dce_fix;
 102 oldlen = len;
 103 if((dce_fix = fix_dce(newlen, &len)) < 0)return ASN1_BAD_FORMAT;
 104 e = decode_integer(p, len, &(data)->tkt_vno, &l);
 105 FORW;
 106 if(dce_fix){
 107 e = der_match_tag_and_length (p, len, (Der_class)0, (Der_type)0, 0, &reallen, &l);
 108 FORW;
 109 }else
 110 len = oldlen - newlen;
 111 }
 112 }
 113 }
 114 {
 115 size_t newlen, oldlen;
 116
 117 e = der_match_tag (p, len, Der_CONTEXT, CONS, 1, &l);
 118 if (e)
 119 return e;
 120 else {
 121 p += l;
 122 len -= l;
 123 ret += l;
 124 e = der_get_length (p, len, &newlen, &l);
 125 FORW;
 126 {
 127 int dce_fix;
 128 oldlen = len;
 129 if((dce_fix = fix_dce(newlen, &len)) < 0)return ASN1_BAD_FORMAT;
 130 e = decode_Realm(p, len, &(data)->realm, &l);
 131 FORW;
 132 if(dce_fix){
 133 e = der_match_tag_and_length (p, len, (Der_class)0, (Der_type)0, 0, &reallen, &l);
 134 FORW;
 135 }else
 136 len = oldlen - newlen;
 137 }
 138 }
 139 }
 140 {
 141 size_t newlen, oldlen;
 142
 143 e = der_match_tag (p, len, Der_CONTEXT, CONS, 2, &l);
 144 if (e)
 145 return e;
 146 else {
 147 p += l;
 148 len -= l;
 149 ret += l;
 150 e = der_get_length (p, len, &newlen, &l);
 151 FORW;
 152 {
 153 int dce_fix;
 154 oldlen = len;
 155 if((dce_fix = fix_dce(newlen, &len)) < 0)return ASN1_BAD_FORMAT;
 156 e = decode_PrincipalName(p, len, &(data)->sname, &l);
 157 FORW;
 158 if(dce_fix){
 159 e = der_match_tag_and_length (p, len, (Der_class)0, (Der_type)0, 0, &reallen, &l);
 160 FORW;
 161 }else
 162 len = oldlen - newlen;
 163 }
 164 }
 165 }
 166 {
 167 size_t newlen, oldlen;
 168
 169 e = der_match_tag (p, len, Der_CONTEXT, CONS, 3, &l);
 170 if (e)
 171 return e;
 172 else {
 173 p += l;
 174 len -= l;
 175 ret += l;
 176 e = der_get_length (p, len, &newlen, &l);
 177 FORW;
 178 {
 179 int dce_fix;
 180 oldlen = len;
 181 if((dce_fix = fix_dce(newlen, &len)) < 0)return ASN1_BAD_FORMAT;
 182 e = decode_EncryptedData(p, len, &(data)->enc_part, &l);
 183 FORW;
 184 if(dce_fix){
 185 e = der_match_tag_and_length (p, len, (Der_class)0, (Der_type)0, 0, &reallen, &l);
 186 FORW;
 187 }else
 188 len = oldlen - newlen;
 189 }
 190 }
 191 }
 192 if(dce_fix){
 193 e = der_match_tag_and_length (p, len, (Der_class)0, (Der_type)0, 0, &reallen, &l);
 194 FORW;
 195 }
 196 }
 197 if(dce_fix){
 198 e = der_match_tag_and_length (p, len, (Der_class)0, (Der_type)0, 0, &reallen, &l);
 199 FORW;
 200 }
 201 }
 202 if(size) *size = ret;
 203 return 0;
 204 fail:
 205 free_Ticket(data);
 206 return e;
 207 }
 208
 209 void
 210 free_Ticket(Ticket *data)
 211 {
 212 free_Realm(&(data)->realm);
 213 free_PrincipalName(&(data)->sname);
 214 free_EncryptedData(&(data)->enc_part);
 215 }
 216
 217 size_t
 218 length_Ticket(const Ticket *data)
 219 {
 220 size_t ret = 0;
 221 {
 222 int oldret = ret;
 223 ret = 0;
 224 ret += length_integer(&(data)->tkt_vno);
 225 ret += 1 + length_len(ret) + oldret;
 226 }
 227 {
 228 int oldret = ret;
 229 ret = 0;
 230 ret += length_Realm(&(data)->realm);
 231 ret += 1 + length_len(ret) + oldret;
 232 }
 233 {
 234 int oldret = ret;
 235 ret = 0;
 236 ret += length_PrincipalName(&(data)->sname);
 237 ret += 1 + length_len(ret) + oldret;
 238 }
 239 {
 240 int oldret = ret;
 241 ret = 0;
 242 ret += length_EncryptedData(&(data)->enc_part);
 243 ret += 1 + length_len(ret) + oldret;
 244 }
 245 ret += 1 + length_len(ret);
 246 ret += 1 + length_len (ret);
 247 return ret;
 248 }
 249
 250 int
 251 copy_Ticket(const Ticket *from, Ticket *to)
 252 {
 253 *(&(to)->tkt_vno) = *(&(from)->tkt_vno);
 254 if(copy_Realm(&(from)->realm, &(to)->realm)) return ENOMEM;
 255 if(copy_PrincipalName(&(from)->sname, &(to)->sname)) return ENOMEM;
 256 if(copy_EncryptedData(&(from)->enc_part, &(to)->enc_part)) return ENOMEM;
 257 return 0;
 258 }
 259
 260 /* Generated from /home/lha/src/cvs/heimdal/lib/asn1/k5.asn1 */
 261 /* Do not edit */
 262
 263 #include <stdio.h>
 264 #include <stdlib.h>
 265 #include <time.h>
 266 #include <string.h>
 267 #include <errno.h>
 268 #include <asn1_err.h>
 269
 270 #define BACK if (e) return e; p -= l; len -= l; ret += l
 271
 272 int
 273 encode_EncryptedData(unsigned char *p, size_t len, const EncryptedData *data, size_t *size)
 274 {
 275 size_t ret = 0;
 276 size_t l;
 277 int i, e;
 278
 279 i = 0;
 280 {
 281 int oldret = ret;
 282 ret = 0;
 283 e = encode_octet_string(p, len, &(data)->cipher, &l);
 284 BACK;
 285 e = der_put_length_and_tag (p, len, ret, Der_CONTEXT, CONS, 2, &l);
 286 BACK;
 287 ret += oldret;
 288 }
 289 if((data)->kvno)
 290 {
 291 int oldret = ret;
 292 ret = 0;
 293 e = encode_integer(p, len, (data)->kvno, &l);
 294 BACK;
 295 e = der_put_length_and_tag (p, len, ret, Der_CONTEXT, CONS, 1, &l);
 296 BACK;
 297 ret += oldret;
 298 }
 299 {
 300 int oldret = ret;
 301 ret = 0;
 302 e = encode_ENCTYPE(p, len, &(data)->etype, &l);
 303 BACK;
 304 e = der_put_length_and_tag (p, len, ret, Der_CONTEXT, CONS, 0, &l);
 305 BACK;
 306 ret += oldret;
 307 }
 308 e = der_put_length_and_tag (p, len, ret, UNIV, CONS, UT_Sequence, &l);
 309 BACK;
 310 *size = ret;
 311 return 0;
 312 }
 313
 314 #define FORW if(e) goto fail; p += l; len -= l; ret += l
 315
 316 int
 317 decode_EncryptedData(const unsigned char *p, size_t len, EncryptedData *data, size_t *size)
 318 {
 319 size_t ret = 0, reallen;
 320 size_t l;
 321 int e;
 322
 323 memset(data, 0, sizeof(*data));
 324 reallen = 0;
 325 e = der_match_tag_and_length (p, len, UNIV, CONS, UT_Sequence,&reallen, &l);
 326 FORW;
 327 {
 328 int dce_fix;
 329 if((dce_fix = fix_dce(reallen, &len)) < 0)
 330 return ASN1_BAD_FORMAT;
 331 {
 332 size_t newlen, oldlen;
 333
 334 e = der_match_tag (p, len, Der_CONTEXT, CONS, 0, &l);
 335 if (e)
 336 return e;
 337 else {
 338 p += l;
 339 len -= l;
 340 ret += l;
 341 e = der_get_length (p, len, &newlen, &l);
 342 FORW;
 343 {
 344 int dce_fix;
 345 oldlen = len;
 346 if((dce_fix = fix_dce(newlen, &len)) < 0)return ASN1_BAD_FORMAT;
 347 e = decode_ENCTYPE(p, len, &(data)->etype, &l);
 348 FORW;
 349 if(dce_fix){
 350 e = der_match_tag_and_length (p, len, (Der_class)0, (Der_type)0, 0, &reallen, &l);
 351 FORW;
 352 }else
 353 len = oldlen - newlen;
 354 }
 355 }
 356 }
 357 {
 358 size_t newlen, oldlen;
 359
 360 e = der_match_tag (p, len, Der_CONTEXT, CONS, 1, &l);
 361 if (e)
 362 (data)->kvno = NULL;
 363 else {
 364 p += l;
 365 len -= l;
 366 ret += l;
 367 e = der_get_length (p, len, &newlen, &l);
 368 FORW;
 369 {
 370 int dce_fix;
 371 oldlen = len;
 372 if((dce_fix = fix_dce(newlen, &len)) < 0)return ASN1_BAD_FORMAT;
 373 (data)->kvno = malloc(sizeof(*(data)->kvno));
 374 if((data)->kvno == NULL) return ENOMEM;
 375 e = decode_integer(p, len, (data)->kvno, &l);
 376 FORW;
 377 if(dce_fix){
 378 e = der_match_tag_and_length (p, len, (Der_class)0, (Der_type)0, 0, &reallen, &l);
 379 FORW;
 380 }else
 381 len = oldlen - newlen;
 382 }
 383 }
 384 }
 385 {
 386 size_t newlen, oldlen;
 387
 388 e = der_match_tag (p, len, Der_CONTEXT, CONS, 2, &l);
 389 if (e)
 390 return e;
 391 else {
 392 p += l;
 393 len -= l;
 394 ret += l;
 395 e = der_get_length (p, len, &newlen, &l);
 396 FORW;
 397 {
 398 int dce_fix;
 399 oldlen = len;
 400 if((dce_fix = fix_dce(newlen, &len)) < 0)return ASN1_BAD_FORMAT;
 401 e = decode_octet_string(p, len, &(data)->cipher, &l);
 402 FORW;
 403 if(dce_fix){
 404 e = der_match_tag_and_length (p, len, (Der_class)0, (Der_type)0, 0, &reallen, &l);
 405 FORW;
 406 }else
 407 len = oldlen - newlen;
 408 }
 409 }
 410 }
 411 if(dce_fix){
 412 e = der_match_tag_and_length (p, len, (Der_class)0, (Der_type)0, 0, &reallen, &l);
 413 FORW;
 414 }
 415 }
 416 if(size) *size = ret;
 417 return 0;
 418 fail:
 419 free_EncryptedData(data);
 420 return e;
 421 }
 422
 423 void
 424 free_EncryptedData(EncryptedData *data)
 425 {
 426 free_ENCTYPE(&(data)->etype);
 427 if((data)->kvno) {
 428 free((data)->kvno);
 429 }
 430 free_octet_string(&(data)->cipher);
 431 }
 432
 433 size_t
 434 length_EncryptedData(const EncryptedData *data)
 435 {
 436 size_t ret = 0;
 437 {
 438 int oldret = ret;
 439 ret = 0;
 440 ret += length_ENCTYPE(&(data)->etype);
 441 ret += 1 + length_len(ret) + oldret;
 442 }
 443 if((data)->kvno){
 444 int oldret = ret;
 445 ret = 0;
 446 ret += length_integer((data)->kvno);
 447 ret += 1 + length_len(ret) + oldret;
 448 }
 449 {
 450 int oldret = ret;
 451 ret = 0;
 452 ret += length_octet_string(&(data)->cipher);
 453 ret += 1 + length_len(ret) + oldret;
 454 }
 455 ret += 1 + length_len(ret);
 456 return ret;
 457 }
 458
 459 int
 460 copy_EncryptedData(const EncryptedData *from, EncryptedData *to)
 461 {
 462 if(copy_ENCTYPE(&(from)->etype, &(to)->etype)) return ENOMEM;
 463 if((from)->kvno) {
 464 (to)->kvno = malloc(sizeof(*(to)->kvno));
 465 if((to)->kvno == NULL) return ENOMEM;
 466 *((to)->kvno) = *((from)->kvno);
 467 }else
 468 (to)->kvno = NULL;
 469 if(copy_octet_string(&(from)->cipher, &(to)->cipher)) return ENOMEM;
 470 return 0;
 471 }
 472
 473 /* Generated from /home/lha/src/cvs/heimdal/lib/asn1/k5.asn1 */
 474 /* Do not edit */
 475
 476 #include <stdio.h>
 477 #include <stdlib.h>
 478 #include <time.h>
 479 #include <string.h>
 480 #include <errno.h>
 481 #include <asn1_err.h>
 482
 483 #define BACK if (e) return e; p -= l; len -= l; ret += l
 484
 485 int
 486 encode_PrincipalName(unsigned char *p, size_t len, const PrincipalName *data, size_t *size)
 487 {
 488 size_t ret = 0;
 489 size_t l;
 490 int i, e;
 491
 492 i = 0;
 493 {
 494 int oldret = ret;
 495 ret = 0;
 496 for(i = (&(data)->name_string)->len - 1; i >= 0; --i) {
 497 int oldret = ret;
 498 ret = 0;
 499 e = encode_general_string(p, len, &(&(data)->name_string)->val[i], &l);
 500 BACK;
 501 ret += oldret;
 502 }
 503 e = der_put_length_and_tag (p, len, ret, UNIV, CONS, UT_Sequence, &l);
 504 BACK;
 505 e = der_put_length_and_tag (p, len, ret, Der_CONTEXT, CONS, 1, &l);
 506 BACK;
 507 ret += oldret;
 508 }
 509 {
 510 int oldret = ret;
 511 ret = 0;
 512 e = encode_NAME_TYPE(p, len, &(data)->name_type, &l);
 513 BACK;
 514 e = der_put_length_and_tag (p, len, ret, Der_CONTEXT, CONS, 0, &l);
 515 BACK;
 516 ret += oldret;
 517 }
 518 e = der_put_length_and_tag (p, len, ret, UNIV, CONS, UT_Sequence, &l);
 519 BACK;
 520 *size = ret;
 521 return 0;
 522 }
 523
 524 #define FORW if(e) goto fail; p += l; len -= l; ret += l
 525
 526 int
 527 decode_PrincipalName(const unsigned char *p, size_t len, PrincipalName *data, size_t *size)
 528 {
 529 size_t ret = 0, reallen;
 530 size_t l;
 531 int e;
 532
 533 memset(data, 0, sizeof(*data));
 534 reallen = 0;
 535 e = der_match_tag_and_length (p, len, UNIV, CONS, UT_Sequence,&reallen, &l);
 536 FORW;
 537 {
 538 int dce_fix;
 539 if((dce_fix = fix_dce(reallen, &len)) < 0)
 540 return ASN1_BAD_FORMAT;
 541 {
 542 size_t newlen, oldlen;
 543
 544 e = der_match_tag (p, len, Der_CONTEXT, CONS, 0, &l);
 545 if (e)
 546 return e;
 547 else {
 548 p += l;
 549 len -= l;
 550 ret += l;
 551 e = der_get_length (p, len, &newlen, &l);
 552 FORW;
 553 {
 554 int dce_fix;
 555 oldlen = len;
 556 if((dce_fix = fix_dce(newlen, &len)) < 0)return ASN1_BAD_FORMAT;
 557 e = decode_NAME_TYPE(p, len, &(data)->name_type, &l);
 558 FORW;
 559 if(dce_fix){
 560 e = der_match_tag_and_length (p, len, (Der_class)0, (Der_type)0, 0, &reallen, &l);
 561 FORW;
 562 }else
 563 len = oldlen - newlen;
 564 }
 565 }
 566 }
 567 {
 568 size_t newlen, oldlen;
 569
 570 e = der_match_tag (p, len, Der_CONTEXT, CONS, 1, &l);
 571 if (e)
 572 return e;
 573 else {
 574 p += l;
 575 len -= l;
 576 ret += l;
 577 e = der_get_length (p, len, &newlen, &l);
 578 FORW;
 579 {
 580 int dce_fix;
 581 oldlen = len;
 582 if((dce_fix = fix_dce(newlen, &len)) < 0)return ASN1_BAD_FORMAT;
 583 e = der_match_tag_and_length (p, len, UNIV, CONS, UT_Sequence,&reallen, &l);
 584 FORW;
 585 if(len < reallen)
 586 return ASN1_OVERRUN;
 587 len = reallen;
 588 {
 589 size_t origlen = len;
 590 int oldret = ret;
 591 ret = 0;
 592 (&(data)->name_string)->len = 0;
 593 (&(data)->name_string)->val = NULL;
 594 while(ret < origlen) {
 595 (&(data)->name_string)->len++;
 596 (&(data)->name_string)->val = realloc((&(data)->name_string)->val, sizeof(*((&(data)->name_string)->val)) * (&(data)->name_string)->len);
 597 e = decode_general_string(p, len, &(&(data)->name_string)->val[(&(data)->name_string)->len-1], &l);
 598 FORW;
 599 len = origlen - ret;
 600 }
 601 ret += oldret;
 602 }
 603 if(dce_fix){
 604 e = der_match_tag_and_length (p, len, (Der_class)0, (Der_type)0, 0, &reallen, &l);
 605 FORW;
 606 }else
 607 len = oldlen - newlen;
 608 }
 609 }
 610 }
 611 if(dce_fix){
 612 e = der_match_tag_and_length (p, len, (Der_class)0, (Der_type)0, 0, &reallen, &l);
 613 FORW;
 614 }
 615 }
 616 if(size) *size = ret;
 617 return 0;
 618 fail:
 619 free_PrincipalName(data);
 620 return e;
 621 }
 622
 623 void
 624 free_PrincipalName(PrincipalName *data)
 625 {
 626 free_NAME_TYPE(&(data)->name_type);
 627 while((&(data)->name_string)->len){
 628 free_general_string(&(&(data)->name_string)->val[(&(data)->name_string)->len-1]);
 629 (&(data)->name_string)->len--;
 630 }
 631 free((&(data)->name_string)->val);
 632 }
 633
 634 size_t
 635 length_PrincipalName(const PrincipalName *data)
 636 {
 637 size_t ret = 0;
 638 {
 639 int oldret = ret;
 640 ret = 0;
 641 ret += length_NAME_TYPE(&(data)->name_type);
 642 ret += 1 + length_len(ret) + oldret;
 643 }
 644 {
 645 int oldret = ret;
 646 ret = 0;
 647 {
 648 int oldret = ret;
 649 int i;
 650 ret = 0;
 651 for(i = (&(data)->name_string)->len - 1; i >= 0; --i){
 652 ret += length_general_string(&(&(data)->name_string)->val[i]);
 653 }
 654 ret += 1 + length_len(ret) + oldret;
 655 }
 656 ret += 1 + length_len(ret) + oldret;
 657 }
 658 ret += 1 + length_len(ret);
 659 return ret;
 660 }
 661
 662 int
 663 copy_PrincipalName(const PrincipalName *from, PrincipalName *to)
 664 {
 665 if(copy_NAME_TYPE(&(from)->name_type, &(to)->name_type)) return ENOMEM;
 666 if(((&(to)->name_string)->val = malloc((&(from)->name_string)->len * sizeof(*(&(to)->name_string)->val))) == NULL && (&(from)->name_string)->len != 0)
 667 return ENOMEM;
 668 for((&(to)->name_string)->len = 0; (&(to)->name_string)->len < (&(from)->name_string)->len; (&(to)->name_string)->len++){
 669 if(copy_general_string(&(&(from)->name_string)->val[(&(to)->name_string)->len], &(&(to)->name_string)->val[(&(to)->name_string)->len])) return ENOMEM;
 670 }
 671 return 0;
 672 }
 673
 674 /* Generated from /home/lha/src/cvs/heimdal/lib/asn1/k5.asn1 */
 675 /* Do not edit */
 676
 677 #include <stdio.h>
 678 #include <stdlib.h>
 679 #include <time.h>
 680 #include <string.h>
 681 #include <errno.h>
 682 #include <asn1_err.h>
 683
 684 #define BACK if (e) return e; p -= l; len -= l; ret += l
 685
 686 int
 687 encode_HostAddresses(unsigned char *p, size_t len, const HostAddresses *data, size_t *size)
 688 {
 689 size_t ret = 0;
 690 size_t l;
 691 int i, e;
 692
 693 i = 0;
 694 for(i = (data)->len - 1; i >= 0; --i) {
 695 int oldret = ret;
 696 ret = 0;
 697 e = encode_HostAddress(p, len, &(data)->val[i], &l);
 698 BACK;
 699 ret += oldret;
 700 }
 701 e = der_put_length_and_tag (p, len, ret, UNIV, CONS, UT_Sequence, &l);
 702 BACK;
 703 *size = ret;
 704 return 0;
 705 }
 706
 707 #define FORW if(e) goto fail; p += l; len -= l; ret += l
 708
 709 int
 710 decode_HostAddresses(const unsigned char *p, size_t len, HostAddresses *data, size_t *size)
 711 {
 712 size_t ret = 0, reallen;
 713 size_t l;
 714 int e;
 715
 716 memset(data, 0, sizeof(*data));
 717 reallen = 0;
 718 e = der_match_tag_and_length (p, len, UNIV, CONS, UT_Sequence,&reallen, &l);
 719 FORW;
 720 if(len < reallen)
 721 return ASN1_OVERRUN;
 722 len = reallen;
 723 {
 724 size_t origlen = len;
 725 int oldret = ret;
 726 ret = 0;
 727 (data)->len = 0;
 728 (data)->val = NULL;
 729 while(ret < origlen) {
 730 (data)->len++;
 731 (data)->val = realloc((data)->val, sizeof(*((data)->val)) * (data)->len);
 732 e = decode_HostAddress(p, len, &(data)->val[(data)->len-1], &l);
 733 FORW;
 734 len = origlen - ret;
 735 }
 736 ret += oldret;
 737 }
 738 if(size) *size = ret;
 739 return 0;
 740 fail:
 741 free_HostAddresses(data);
 742 return e;
 743 }
 744
 745 void
 746 free_HostAddresses(HostAddresses *data)
 747 {
 748 while((data)->len){
 749 free_HostAddress(&(data)->val[(data)->len-1]);
 750 (data)->len--;
 751 }
 752 free((data)->val);
 753 }
 754
 755 size_t
 756 length_HostAddresses(const HostAddresses *data)
 757 {
 758 size_t ret = 0;
 759 {
 760 int oldret = ret;
 761 int i;
 762 ret = 0;
 763 for(i = (data)->len - 1; i >= 0; --i){
 764 ret += length_HostAddress(&(data)->val[i]);
 765 }
 766 ret += 1 + length_len(ret) + oldret;
 767 }
 768 return ret;
 769 }
 770
 771 int
 772 copy_HostAddresses(const HostAddresses *from, HostAddresses *to)
 773 {
 774 if(((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
 775 return ENOMEM;
 776 for((to)->len = 0; (to)->len < (from)->len; (to)->len++){
 777 if(copy_HostAddress(&(from)->val[(to)->len], &(to)->val[(to)->len])) return ENOMEM;
 778 }
 779 return 0;
 780 }
 781
 782 /* Generated from /home/lha/src/cvs/heimdal/lib/asn1/k5.asn1 */
 783 /* Do not edit */
 784
 785 #include <stdio.h>
 786 #include <stdlib.h>
 787 #include <time.h>
 788 #include <string.h>
 789 #include <errno.h>
 790 #include <asn1_err.h>
 791
 792 #define BACK if (e) return e; p -= l; len -= l; ret += l
 793
 794 int
 795 encode_HostAddress(unsigned char *p, size_t len, const HostAddress *data, size_t *size)
 796 {
 797 size_t ret = 0;
 798 size_t l;
 799 int i, e;
 800
 801 i = 0;
 802 {
 803 int oldret = ret;
 804 ret = 0;
 805 e = encode_octet_string(p, len, &(data)->address, &l);
 806 BACK;
 807 e = der_put_length_and_tag (p, len, ret, Der_CONTEXT, CONS, 1, &l);
 808 BACK;
 809 ret += oldret;
 810 }
 811 {
 812 int oldret = ret;
 813 ret = 0;
 814 e = encode_integer(p, len, &(data)->addr_type, &l);
 815 BACK;
 816 e = der_put_length_and_tag (p, len, ret, Der_CONTEXT, CONS, 0, &l);
 817 BACK;
 818 ret += oldret;
 819 }
 820 e = der_put_length_and_tag (p, len, ret, UNIV, CONS, UT_Sequence, &l);
 821 BACK;
 822 *size = ret;
 823 return 0;
 824 }
 825
 826 #define FORW if(e) goto fail; p += l; len -= l; ret += l
 827
 828 int
 829 decode_HostAddress(const unsigned char *p, size_t len, HostAddress *data, size_t *size)
 830 {
 831 size_t ret = 0, reallen;
 832 size_t l;
 833 int e;
 834
 835 memset(data, 0, sizeof(*data));
 836 reallen = 0;
 837 e = der_match_tag_and_length (p, len, UNIV, CONS, UT_Sequence,&reallen, &l);
 838 FORW;
 839 {
 840 int dce_fix;
 841 if((dce_fix = fix_dce(reallen, &len)) < 0)
 842 return ASN1_BAD_FORMAT;
 843 {
 844 size_t newlen, oldlen;
 845
 846 e = der_match_tag (p, len, Der_CONTEXT, CONS, 0, &l);
 847 if (e)
 848 return e;
 849 else {
 850 p += l;
 851 len -= l;
 852 ret += l;
 853 e = der_get_length (p, len, &newlen, &l);
 854 FORW;
 855 {
 856 int dce_fix;
 857 oldlen = len;
 858 if((dce_fix = fix_dce(newlen, &len)) < 0)return ASN1_BAD_FORMAT;
 859 e = decode_integer(p, len, &(data)->addr_type, &l);
 860 FORW;
 861 if(dce_fix){
 862 e = der_match_tag_and_length (p, len, (Der_class)0, (Der_type)0, 0, &reallen, &l);
 863 FORW;
 864 }else
 865 len = oldlen - newlen;
 866 }
 867 }
 868 }
 869 {
 870 size_t newlen, oldlen;
 871
 872 e = der_match_tag (p, len, Der_CONTEXT, CONS, 1, &l);
 873 if (e)
 874 return e;
 875 else {
 876 p += l;
 877 len -= l;
 878 ret += l;
 879 e = der_get_length (p, len, &newlen, &l);
 880 FORW;
 881 {
 882 int dce_fix;
 883 oldlen = len;
 884 if((dce_fix = fix_dce(newlen, &len)) < 0)return ASN1_BAD_FORMAT;
 885 e = decode_octet_string(p, len, &(data)->address, &l);
 886 FORW;
 887 if(dce_fix){
 888 e = der_match_tag_and_length (p, len, (Der_class)0, (Der_type)0, 0, &reallen, &l);
 889 FORW;
 890 }else
 891 len = oldlen - newlen;
 892 }
 893 }
 894 }
 895 if(dce_fix){
 896 e = der_match_tag_and_length (p, len, (Der_class)0, (Der_type)0, 0, &reallen, &l);
 897 FORW;
 898 }
 899 }
 900 if(size) *size = ret;
 901 return 0;
 902 fail:
 903 free_HostAddress(data);
 904 return e;
 905 }
 906
 907 void
 908 free_HostAddress(HostAddress *data)
 909 {
 910 free_octet_string(&(data)->address);
 911 }
 912
 913 size_t
 914 length_HostAddress(const HostAddress *data)
 915 {
 916 size_t ret = 0;
 917 {
 918 int oldret = ret;
 919 ret = 0;
 920 ret += length_integer(&(data)->addr_type);
 921 ret += 1 + length_len(ret) + oldret;
 922 }
 923 {
 924 int oldret = ret;
 925 ret = 0;
 926 ret += length_octet_string(&(data)->address);
 927 ret += 1 + length_len(ret) + oldret;
 928 }
 929 ret += 1 + length_len(ret);
 930 return ret;
 931 }
 932
 933 int
 934 copy_HostAddress(const HostAddress *from, HostAddress *to)
 935 {
 936 *(&(to)->addr_type) = *(&(from)->addr_type);
 937 if(copy_octet_string(&(from)->address, &(to)->address)) return ENOMEM;
 938 return 0;
 939 }
 940
 941 /* Generated from /home/lha/src/cvs/heimdal/lib/asn1/k5.asn1 */
 942 /* Do not edit */
 943
 944 #include <stdio.h>
 945 #include <stdlib.h>
 946 #include <time.h>
 947 #include <string.h>
 948 #include <errno.h>
 949 #include <asn1_err.h>
 950
 951 #define BACK if (e) return e; p -= l; len -= l; ret += l
 952
 953 int
 954 encode_AuthorizationData(unsigned char *p, size_t len, const AuthorizationData *data, size_t *size)
 955 {
 956 size_t ret = 0;
 957 size_t l;
 958 int i, e;
 959
 960 i = 0;
 961 for(i = (data)->len - 1; i >= 0; --i) {
 962 int oldret = ret;
 963 ret = 0;
 964 {
 965 int oldret = ret;
 966 ret = 0;
 967 e = encode_octet_string(p, len, &(&(data)->val[i])->ad_data, &l);
 968 BACK;
 969 e = der_put_length_and_tag (p, len, ret, Der_CONTEXT, CONS, 1, &l);
 970 BACK;
 971 ret += oldret;
 972 }
 973 {
 974 int oldret = ret;
 975 ret = 0;
 976 e = encode_integer(p, len, &(&(data)->val[i])->ad_type, &l);
 977 BACK;
 978 e = der_put_length_and_tag (p, len, ret, Der_CONTEXT, CONS, 0, &l);
 979 BACK;
 980 ret += oldret;
 981 }
 982 e = der_put_length_and_tag (p, len, ret, UNIV, CONS, UT_Sequence, &l);
 983 BACK;
 984 ret += oldret;
 985 }
 986 e = der_put_length_and_tag (p, len, ret, UNIV, CONS, UT_Sequence, &l);
 987 BACK;
 988 *size = ret;
 989 return 0;
 990 }
 991
 992 #define FORW if(e) goto fail; p += l; len -= l; ret += l
 993
 994 int
 995 decode_AuthorizationData(const unsigned char *p, size_t len, AuthorizationData *data, size_t *size)
 996 {
 997 size_t ret = 0, reallen;
 998 size_t l;
 999 int e;
1000
1001 memset(data, 0, sizeof(*data));
1002 reallen = 0;
1003 e = der_match_tag_and_length (p, len, UNIV, CONS, UT_Sequence,&reallen, &l);
1004 FORW;
1005 if(len < reallen)
1006 return ASN1_OVERRUN;
1007 len = reallen;
1008 {
1009 size_t origlen = len;
1010 int oldret = ret;
1011 ret = 0;
1012 (data)->len = 0;
1013 (data)->val = NULL;
1014 while(ret < origlen) {
1015 (data)->len++;
1016 (data)->val = realloc((data)->val, sizeof(*((data)->val)) * (data)->len);
1017 e = der_match_tag_and_length (p, len, UNIV, CONS, UT_Sequence,&reallen, &l);
1018 FORW;
1019 {
1020 int dce_fix;
1021 if((dce_fix = fix_dce(reallen, &len)) < 0)
1022 return ASN1_BAD_FORMAT;
1023 {
1024 size_t newlen, oldlen;
1025
1026 e = der_match_tag (p, len, Der_CONTEXT, CONS, 0, &l);
1027 if (e)
1028 return e;
1029 else {
1030 p += l;
1031 len -= l;
1032 ret += l;
1033 e = der_get_length (p, len, &newlen, &l);
1034 FORW;
1035 {
1036 int dce_fix;
1037 oldlen = len;
1038 if((dce_fix = fix_dce(newlen, &len)) < 0)return ASN1_BAD_FORMAT;
1039 e = decode_integer(p, len, &(&(data)->val[(data)->len-1])->ad_type, &l);
1040 FORW;
1041 if(dce_fix){
1042 e = der_match_tag_and_length (p, len, (Der_class)0, (Der_type)0, 0, &reallen, &l);
1043 FORW;
1044 }else
1045 len = oldlen - newlen;
1046 }
1047 }
1048 }
1049 {
1050 size_t newlen, oldlen;
1051
1052 e = der_match_tag (p, len, Der_CONTEXT, CONS, 1, &l);
1053 if (e)
1054 return e;
1055 else {
1056 p += l;
1057 len -= l;
1058 ret += l;
1059 e = der_get_length (p, len, &newlen, &l);
1060 FORW;
1061 {
1062 int dce_fix;
1063 oldlen = len;
1064 if((dce_fix = fix_dce(newlen, &len)) < 0)return ASN1_BAD_FORMAT;
1065 e = decode_octet_string(p, len, &(&(data)->val[(data)->len-1])->ad_data, &l);
1066 FORW;
1067 if(dce_fix){
1068 e = der_match_tag_and_length (p, len, (Der_class)0, (Der_type)0, 0, &reallen, &l);
1069 FORW;
1070 }else
1071 len = oldlen - newlen;
1072 }
1073 }
1074 }
1075 if(dce_fix){
1076 e = der_match_tag_and_length (p, len, (Der_class)0, (Der_type)0, 0, &reallen, &l);
1077 FORW;
1078 }
1079 }
1080 len = origlen - ret;
1081 }
1082 ret += oldret;
1083 }
1084 if(size) *size = ret;
1085 return 0;
1086 fail:
1087 free_AuthorizationData(data);
1088 return e;
1089 }
1090
1091 void
1092 free_AuthorizationData(AuthorizationData *data)
1093 {
1094 while((data)->len){
1095 free_octet_string(&(&(data)->val[(data)->len-1])->ad_data);
1096 (data)->len--;
1097 }
1098 free((data)->val);
1099 }
1100
1101 size_t
1102 length_AuthorizationData(const AuthorizationData *data)
1103 {
1104 size_t ret = 0;
1105 {
1106 int oldret = ret;
1107 int i;
1108 ret = 0;
1109 for(i = (data)->len - 1; i >= 0; --i){
1110 {
1111 int oldret = ret;
1112 ret = 0;
1113 ret += length_integer(&(&(data)->val[i])->ad_type);
1114 ret += 1 + length_len(ret) + oldret;
1115 }
1116 {
1117 int oldret = ret;
1118 ret = 0;
1119 ret += length_octet_string(&(&(data)->val[i])->ad_data);
1120 ret += 1 + length_len(ret) + oldret;
1121 }
1122 ret += 1 + length_len(ret);
1123 }
1124 ret += 1 + length_len(ret) + oldret;
1125 }
1126 return ret;
1127 }
1128
1129 int
1130 copy_AuthorizationData(const AuthorizationData *from, AuthorizationData *to)
1131 {
1132 if(((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
1133 return ENOMEM;
1134 for((to)->len = 0; (to)->len < (from)->len; (to)->len++){
1135 *(&(&(to)->val[(to)->len])->ad_type) = *(&(&(from)->val[(to)->len])->ad_type);
1136 if(copy_octet_string(&(&(from)->val[(to)->len])->ad_data, &(&(to)->val[(to)->len])->ad_data)) return ENOMEM;
1137 }
1138 return 0;
1139 }
1140
1141 /* Generated from /home/lha/src/cvs/heimdal/lib/asn1/k5.asn1 */
1142 /* Do not edit */
1143
1144 #include <stdio.h>
1145 #include <stdlib.h>
1146 #include <time.h>
1147 #include <string.h>
1148 #include <errno.h>
1149 #include <asn1_err.h>
1150
1151 #define BACK if (e) return e; p -= l; len -= l; ret += l
1152
1153 int
1154 encode_EncTicketPart(unsigned char *p, size_t len, const EncTicketPart *data, size_t *size)
1155 {
1156 size_t ret = 0;
1157 size_t l;
1158 int i, e;
1159
1160 i = 0;
1161 if((data)->authorization_data)
1162 {
1163 int oldret = ret;
1164 ret = 0;
1165 e = encode_AuthorizationData(p, len, (data)->authorization_data, &l);
1166 BACK;
1167 e = der_put_length_and_tag (p, len, ret, Der_CONTEXT, CONS, 10, &l);
1168 BACK;
1169 ret += oldret;
1170 }
1171 if((data)->caddr)
1172 {
1173 int oldret = ret;
1174 ret = 0;
1175 e = encode_HostAddresses(p, len, (data)->caddr, &l);
1176 BACK;
1177 e = der_put_length_and_tag (p, len, ret, Der_CONTEXT, CONS, 9, &l);
1178 BACK;
1179 ret += oldret;
1180 }
1181 if((data)->renew_till)
1182 {
1183 int oldret = ret;
1184 ret = 0;
1185 e = encode_KerberosTime(p, len, (data)->renew_till, &l);
1186 BACK;
1187 e = der_put_length_and_tag (p, len, ret, Der_CONTEXT, CONS, 8, &l);
1188 BACK;
1189 ret += oldret;
1190 }
1191 {
1192 int oldret = ret;
1193 ret = 0;
1194 e = encode_KerberosTime(p, len, &(data)->endtime, &l);
1195 BACK;
1196 e = der_put_length_and_tag (p, len, ret, Der_CONTEXT, CONS, 7, &l);
1197 BACK;
1198 ret += oldret;
1199 }
1200 if((data)->starttime)
1201 {
1202 int oldret = ret;
1203 ret = 0;
1204 e = encode_KerberosTime(p, len, (data)->starttime, &l);
1205 BACK;
1206 e = der_put_length_and_tag (p, len, ret, Der_CONTEXT, CONS, 6, &l);
1207 BACK;
1208 ret += oldret;
1209 }
1210 {
1211 int oldret = ret;
1212 ret = 0;
1213 e = encode_KerberosTime(p, len, &(data)->authtime, &l);
1214 BACK;
1215 e = der_put_length_and_tag (p, len, ret, Der_CONTEXT, CONS, 5, &l);
1216 BACK;
1217 ret += oldret;
1218 }
1219 {
1220 int oldret = ret;
1221 ret = 0;
1222 e = encode_TransitedEncoding(p, len, &(data)->transited, &l);
1223 BACK;
1224 e = der_put_length_and_tag (p, len, ret, Der_CONTEXT, CONS, 4, &l);
1225 BACK;
1226 ret += oldret;
1227 }
1228 {
1229 int oldret = ret;
1230 ret = 0;
1231 e = encode_PrincipalName(p, len, &(data)->cname, &l);
1232 BACK;
1233 e = der_put_length_and_tag (p, len, ret, Der_CONTEXT, CONS, 3, &l);
1234 BACK;
1235 ret += oldret;
1236 }
1237 {
1238 int oldret = ret;
1239 ret = 0;
1240 e = encode_Realm(p, len, &(data)->crealm, &l);
1241 BACK;
1242 e = der_put_length_and_tag (p, len, ret, Der_CONTEXT, CONS, 2, &l);
1243 BACK;
1244 ret += oldret;
1245 }
1246 {
1247 int oldret = ret;
1248 ret = 0;
1249 e = encode_EncryptionKey(p, len, &(data)->key, &l);
1250 BACK;
1251 e = der_put_length_and_tag (p, len, ret, Der_CONTEXT, CONS, 1, &l);
1252 BACK;
1253 ret += oldret;
1254 }
1255 {
1256 int oldret = ret;
1257 ret = 0;
1258 e = encode_TicketFlags(p, len, &(data)->flags, &l);
1259 BACK;
1260 e = der_put_length_and_tag (p, len, ret, Der_CONTEXT, CONS, 0, &l);
1261 BACK;
1262 ret += oldret;
1263 }
1264 e = der_put_length_and_tag (p, len, ret, UNIV, CONS, UT_Sequence, &l);
1265 BACK;
1266 e = der_put_length_and_tag (p, len, ret, APPL, CONS, 3, &l);
1267 BACK;
1268 *size = ret;
1269 return 0;
1270 }
1271
1272 #define FORW if(e) goto fail; p += l; len -= l; ret += l
1273
1274 int
1275 decode_EncTicketPart(const unsigned char *p, size_t len, EncTicketPart *data, size_t *size)
1276 {
1277 size_t ret = 0, reallen;
1278 size_t l;
1279 int e;
1280
1281 memset(data, 0, sizeof(*data));
1282 reallen = 0;
1283 e = der_match_tag_and_length (p, len, APPL, CONS, 3, &reallen, &l);
1284 FORW;
1285 {
1286 int dce_fix;
1287 if((dce_fix = fix_dce(reallen, &len)) < 0)
1288 return ASN1_BAD_FORMAT;
1289 e = der_match_tag_and_length (p, len, UNIV, CONS, UT_Sequence,&reallen, &l);
1290 FORW;
1291 {
1292 int dce_fix;
1293 if((dce_fix = fix_dce(reallen, &len)) < 0)
1294 return ASN1_BAD_FORMAT;
1295 {
1296 size_t newlen, oldlen;
1297
1298 e = der_match_tag (p, len, Der_CONTEXT, CONS, 0, &l);
1299 if (e)
1300 return e;
1301 else {
1302 p += l;
1303 len -= l;
1304 ret += l;
1305 e = der_get_length (p, len, &newlen, &l);
1306 FORW;
1307 {
1308 int dce_fix;
1309 oldlen = len;
1310 if((dce_fix = fix_dce(newlen, &len)) < 0)return ASN1_BAD_FORMAT;
1311 e = decode_TicketFlags(p, len, &(data)->flags, &l);
1312 FORW;
1313 if(dce_fix){
1314 e = der_match_tag_and_length (p, len, (Der_class)0, (Der_type)0, 0, &reallen, &l);
1315 FORW;
1316 }else
1317 len = oldlen - newlen;
1318 }
1319 }
1320 }
1321 {
1322 size_t newlen, oldlen;
1323
1324 e = der_match_tag (p, len, Der_CONTEXT, CONS, 1, &l);
1325 if (e)
1326 return e;
1327 else {
1328 p += l;
1329 len -= l;
1330 ret += l;
1331 e = der_get_length (p, len, &newlen, &l);
1332 FORW;
1333 {
1334 int dce_fix;
1335 oldlen = len;
1336 if((dce_fix = fix_dce(newlen, &len)) < 0)return ASN1_BAD_FORMAT;
1337 e = decode_EncryptionKey(p, len, &(data)->key, &l);
1338 FORW;
1339 if(dce_fix){
1340 e = der_match_tag_and_length (p, len, (Der_class)0, (Der_type)0, 0, &reallen, &l);
1341 FORW;
1342 }else
1343 len = oldlen - newlen;
1344 }
1345 }
1346 }
1347 {
1348 size_t newlen, oldlen;
1349
1350 e = der_match_tag (p, len, Der_CONTEXT, CONS, 2, &l);
1351 if (e)
1352 return e;
1353 else {
1354 p += l;
1355 len -= l;
1356 ret += l;
1357 e = der_get_length (p, len, &newlen, &l);
1358 FORW;
1359 {
1360 int dce_fix;
1361 oldlen = len;
1362 if((dce_fix = fix_dce(newlen, &len)) < 0)return ASN1_BAD_FORMAT;
1363 e = decode_Realm(p, len, &(data)->crealm, &l);
1364 FORW;
1365 if(dce_fix){
1366 e = der_match_tag_and_length (p, len, (Der_class)0, (Der_type)0, 0, &reallen, &l);
1367 FORW;
1368 }else
1369 len = oldlen - newlen;
1370 }
1371 }
1372 }
1373 {
1374 size_t newlen, oldlen;
1375
1376 e = der_match_tag (p, len, Der_CONTEXT, CONS, 3, &l);
1377 if (e)
1378 return e;
1379 else {
1380 p += l;
1381 len -= l;
1382 ret += l;
1383 e = der_get_length (p, len, &newlen, &l);
1384 FORW;
1385 {
1386 int dce_fix;
1387 oldlen = len;
1388 if((dce_fix = fix_dce(newlen, &len)) < 0)return ASN1_BAD_FORMAT;
1389 e = decode_PrincipalName(p, len, &(data)->cname, &l);
1390 FORW;
1391 if(dce_fix){
1392 e = der_match_tag_and_length (p, len, (Der_class)0, (Der_type)0, 0, &reallen, &l);
1393 FORW;
1394 }else
1395 len = oldlen - newlen;
1396 }
1397 }
1398 }
1399 {
1400 size_t newlen, oldlen;
1401
1402 e = der_match_tag (p, len, Der_CONTEXT, CONS, 4, &l);
1403 if (e)
1404 return e;
1405 else {
1406 p += l;
1407 len -= l;
1408 ret += l;
1409 e = der_get_length (p, len, &newlen, &l);
1410 FORW;
1411 {
1412 int dce_fix;
1413 oldlen = len;
1414 if((dce_fix = fix_dce(newlen, &len)) < 0)return ASN1_BAD_FORMAT;
1415 e = decode_TransitedEncoding(p, len, &(data)->transited, &l);
1416 FORW;
1417 if(dce_fix){
1418 e = der_match_tag_and_length (p, len, (Der_class)0, (Der_type)0, 0, &reallen, &l);
1419 FORW;
1420 }else
1421 len = oldlen - newlen;
1422 }
1423 }
1424 }
1425 {
1426 size_t newlen, oldlen;
1427
1428 e = der_match_tag (p, len, Der_CONTEXT, CONS, 5, &l);
1429 if (e)
1430 return e;
1431 else {
1432 p += l;
1433 len -= l;
1434 ret += l;
1435 e = der_get_length (p, len, &newlen, &l);
1436 FORW;
1437 {
1438 int dce_fix;
1439 oldlen = len;
1440 if((dce_fix = fix_dce(newlen, &len)) < 0)return ASN1_BAD_FORMAT;
1441 e = decode_KerberosTime(p, len, &(data)->authtime, &l);
1442 FORW;
1443 if(dce_fix){
1444 e = der_match_tag_and_length (p, len, (Der_class)0, (Der_type)0, 0, &reallen, &l);
1445 FORW;
1446 }else
1447 len = oldlen - newlen;
1448 }
1449 }
1450 }
1451 {
1452 size_t newlen, oldlen;
1453
1454 e = der_match_tag (p, len, Der_CONTEXT, CONS, 6, &l);
1455 if (e)
1456 (data)->starttime = NULL;
1457 else {
1458 p += l;
1459 len -= l;
1460 ret += l;
1461 e = der_get_length (p, len, &newlen, &l);
1462 FORW;
1463 {
1464 int dce_fix;
1465 oldlen = len;
1466 if((dce_fix = fix_dce(newlen, &len)) < 0)return ASN1_BAD_FORMAT;
1467 (data)->starttime = malloc(sizeof(*(data)->starttime));
1468 if((data)->starttime == NULL) return ENOMEM;
1469 e = decode_KerberosTime(p, len, (data)->starttime, &l);
1470 FORW;
1471 if(dce_fix){
1472 e = der_match_tag_and_length (p, len, (Der_class)0, (Der_type)0, 0, &reallen, &l);
1473 FORW;
1474 }else
1475 len = oldlen - newlen;
1476 }
1477 }
1478 }
1479 {
1480 size_t newlen, oldlen;
1481
1482 e = der_match_tag (p, len, Der_CONTEXT, CONS, 7, &l);
1483 if (e)
1484 return e;
1485 else {
1486 p += l;
1487 len -= l;
1488 ret += l;
1489 e = der_get_length (p, len, &newlen, &l);
1490 FORW;
1491 {
1492 int dce_fix;
1493 oldlen = len;
1494 if((dce_fix = fix_dce(newlen, &len)) < 0)return ASN1_BAD_FORMAT;
1495 e = decode_KerberosTime(p, len, &(data)->endtime, &l);
1496 FORW;
1497 if(dce_fix){
1498 e = der_match_tag_and_length (p, len, (Der_class)0, (Der_type)0, 0, &reallen, &l);
1499 FORW;
1500 }else
1501 len = oldlen - newlen;
1502 }
1503 }
1504 }
1505 {
1506 size_t newlen, oldlen;
1507
1508 e = der_match_tag (p, len, Der_CONTEXT, CONS, 8, &l);
1509 if (e)
1510 (data)->renew_till = NULL;
1511 else {
1512 p += l;
1513 len -= l;
1514 ret += l;
1515 e = der_get_length (p, len, &newlen, &l);
1516 FORW;
1517 {
1518 int dce_fix;
1519 oldlen = len;
1520 if((dce_fix = fix_dce(newlen, &len)) < 0)return ASN1_BAD_FORMAT;
1521 (data)->renew_till = malloc(sizeof(*(data)->renew_till));
1522 if((data)->renew_till == NULL) return ENOMEM;
1523 e = decode_KerberosTime(p, len, (data)->renew_till, &l);
1524 FORW;
1525 if(dce_fix){
1526 e = der_match_tag_and_length (p, len, (Der_class)0, (Der_type)0, 0, &reallen, &l);
1527 FORW;
1528 }else
1529 len = oldlen - newlen;
1530 }
1531 }
1532 }
1533 {
1534 size_t newlen, oldlen;
1535
1536 e = der_match_tag (p, len, Der_CONTEXT, CONS, 9, &l);
1537 if (e)
1538 (data)->caddr = NULL;
1539 else {
1540 p += l;
1541 len -= l;
1542 ret += l;
1543 e = der_get_length (p, len, &newlen, &l);
1544 FORW;
1545 {
1546 int dce_fix;
1547 oldlen = len;
1548 if((dce_fix = fix_dce(newlen, &len)) < 0)return ASN1_BAD_FORMAT;
1549 (data)->caddr = malloc(sizeof(*(data)->caddr));
1550 if((data)->caddr == NULL) return ENOMEM;
1551 e = decode_HostAddresses(p, len, (data)->caddr, &l);
1552 FORW;
1553 if(dce_fix){
1554 e = der_match_tag_and_length (p, len, (Der_class)0, (Der_type)0, 0, &reallen, &l);
1555 FORW;
1556 }else
1557 len = oldlen - newlen;
1558 }
1559 }
1560 }
1561 {
1562 size_t newlen, oldlen;
1563
1564 e = der_match_tag (p, len, Der_CONTEXT, CONS, 10, &l);
1565 if (e)
1566 (data)->authorization_data = NULL;
1567 else {
1568 p += l;
1569 len -= l;
1570 ret += l;
1571 e = der_get_length (p, len, &newlen, &l);
1572 FORW;
1573 {
1574 int dce_fix;
1575 oldlen = len;
1576 if((dce_fix = fix_dce(newlen, &len)) < 0)return ASN1_BAD_FORMAT;
1577 (data)->authorization_data = malloc(sizeof(*(data)->authorization_data));
1578 if((data)->authorization_data == NULL) return ENOMEM;
1579 e = decode_AuthorizationData(p, len, (data)->authorization_data, &l);
1580 FORW;
1581 if(dce_fix){
1582 e = der_match_tag_and_length (p, len, (Der_class)0, (Der_type)0, 0, &reallen, &l);
1583 FORW;
1584 }else
1585 len = oldlen - newlen;
1586 }
1587 }
1588 }
1589 if(dce_fix){
1590 e = der_match_tag_and_length (p, len, (Der_class)0, (Der_type)0, 0, &reallen, &l);
1591 FORW;
1592 }
1593 }
1594 if(dce_fix){
1595 e = der_match_tag_and_length (p, len, (Der_class)0, (Der_type)0, 0, &reallen, &l);
1596 FORW;
1597 }
1598 }
1599 if(size) *size = ret;
1600 return 0;
1601 fail:
1602 free_EncTicketPart(data);
1603 return e;
1604 }
1605
1606 void
1607 free_EncTicketPart(EncTicketPart *data)
1608 {
1609 free_TicketFlags(&(data)->flags);
1610 free_EncryptionKey(&(data)->key);
1611 free_Realm(&(data)->crealm);
1612 free_PrincipalName(&(data)->cname);
1613 free_TransitedEncoding(&(data)->transited);
1614 free_KerberosTime(&(data)->authtime);
1615 if((data)->starttime) {
1616 free_KerberosTime((data)->starttime);
1617 free((data)->starttime);
1618 }
1619 free_KerberosTime(&(data)->endtime);
1620 if((data)->renew_till) {
1621 free_KerberosTime((data)->renew_till);
1622 free((data)->renew_till);
1623 }
1624 if((data)->caddr) {
1625 free_HostAddresses((data)->caddr);
1626 free((data)->caddr);
1627 }
1628 if((data)->authorization_data) {
1629 free_AuthorizationData((data)->authorization_data);
1630 free((data)->authorization_data);
1631 }
1632 }
1633
1634 size_t
1635 length_EncTicketPart(const EncTicketPart *data)
1636 {
1637 size_t ret = 0;
1638 {
1639 int oldret = ret;
1640 ret = 0;
1641 ret += length_TicketFlags(&(data)->flags);
1642 ret += 1 + length_len(ret) + oldret;
1643 }
1644 {
1645 int oldret = ret;
1646 ret = 0;
1647 ret += length_EncryptionKey(&(data)->key);
1648 ret += 1 + length_len(ret) + oldret;
1649 }
1650 {
1651 int oldret = ret;
1652 ret = 0;
1653 ret += length_Realm(&(data)->crealm);
1654 ret += 1 + length_len(ret) + oldret;
1655 }
1656 {
1657 int oldret = ret;
1658 ret = 0;
1659 ret += length_PrincipalName(&(data)->cname);
1660 ret += 1 + length_len(ret) + oldret;
1661 }
1662 {
1663 int oldret = ret;
1664 ret = 0;
1665 ret += length_TransitedEncoding(&(data)->transited);
1666 ret += 1 + length_len(ret) + oldret;
1667 }
1668 {
1669 int oldret = ret;
1670 ret = 0;
1671 ret += length_KerberosTime(&(data)->authtime);
1672 ret += 1 + length_len(ret) + oldret;
1673 }
1674 if((data)->starttime){
1675 int oldret = ret;
1676 ret = 0;
1677 ret += length_KerberosTime((data)->starttime);
1678 ret += 1 + length_len(ret) + oldret;
1679 }
1680 {
1681 int oldret = ret;
1682 ret = 0;
1683 ret += length_KerberosTime(&(data)->endtime);
1684 ret += 1 + length_len(ret) + oldret;
1685 }
1686 if((data)->renew_till){
1687 int oldret = ret;
1688 ret = 0;
1689 ret += length_KerberosTime((data)->renew_till);
1690 ret += 1 + length_len(ret) + oldret;
1691 }
1692 if((data)->caddr){
1693 int oldret = ret;
1694 ret = 0;
1695 ret += length_HostAddresses((data)->caddr);
1696 ret += 1 + length_len(ret) + oldret;
1697 }
1698 if((data)->authorization_data){
1699 int oldret = ret;
1700 ret = 0;
1701 ret += length_AuthorizationData((data)->authorization_data);
1702 ret += 1 + length_len(ret) + oldret;
1703 }
1704 ret += 1 + length_len(ret);
1705 ret += 1 + length_len (ret);
1706 return ret;
1707 }
1708
1709 int
1710 copy_EncTicketPart(const EncTicketPart *from, EncTicketPart *to)
1711 {
1712 if(copy_TicketFlags(&(from)->flags, &(to)->flags)) return ENOMEM;
1713 if(copy_EncryptionKey(&(from)->key, &(to)->key)) return ENOMEM;
1714 if(copy_Realm(&(from)->crealm, &(to)->crealm)) return ENOMEM;
1715 if(copy_PrincipalName(&(from)->cname, &(to)->cname)) return ENOMEM;
1716 if(copy_TransitedEncoding(&(from)->transited, &(to)->transited)) return ENOMEM;
1717 if(copy_KerberosTime(&(from)->authtime, &(to)->authtime)) return ENOMEM;
1718 if((from)->starttime) {
1719 (to)->starttime = malloc(sizeof(*(to)->starttime));
1720 if((to)->starttime == NULL) return ENOMEM;
1721 if(copy_KerberosTime((from)->starttime, (to)->starttime)) return ENOMEM;
1722 }else
1723 (to)->starttime = NULL;
1724 if(copy_KerberosTime(&(from)->endtime, &(to)->endtime)) return ENOMEM;
1725 if((from)->renew_till) {
1726 (to)->renew_till = malloc(sizeof(*(to)->renew_till));
1727 if((to)->renew_till == NULL) return ENOMEM;
1728 if(copy_KerberosTime((from)->renew_till, (to)->renew_till)) return ENOMEM;
1729 }else
1730 (to)->renew_till = NULL;
1731 if((from)->caddr) {
1732 (to)->caddr = malloc(sizeof(*(to)->caddr));
1733 if((to)->caddr == NULL) return ENOMEM;
1734 if(copy_HostAddresses((from)->caddr, (to)->caddr)) return ENOMEM;
1735 }else
1736 (to)->caddr = NULL;
1737 if((from)->authorization_data) {
1738 (to)->authorization_data = malloc(sizeof(*(to)->authorization_data));
1739 if((to)->authorization_data == NULL) return ENOMEM;
1740 if(copy_AuthorizationData((from)->authorization_data, (to)->authorization_data)) return ENOMEM;
1741 }else
1742 (to)->authorization_data = NULL;
1743 return 0;
1744 }
1745
1746 /* Generated from /home/lha/src/cvs/heimdal/lib/asn1/k5.asn1 */
1747 /* Do not edit */
1748
1749 #include <stdio.h>
1750 #include <stdlib.h>
1751 #include <time.h>
1752 #include <string.h>
1753 #include <errno.h>
1754 #include <asn1_err.h>
1755
1756 #define BACK if (e) return e; p -= l; len -= l; ret += l
1757
1758 int
1759 encode_KerberosTime(unsigned char *p, size_t len, const KerberosTime *data, size_t *size)
1760 {
1761 size_t ret = 0;
1762 size_t l;
1763 int i, e;
1764
1765 i = 0;
1766 e = encode_generalized_time(p, len, data, &l);
1767 BACK;
1768 *size = ret;
1769 return 0;
1770 }
1771
1772 #define FORW if(e) goto fail; p += l; len -= l; ret += l
1773
1774 int
1775 decode_KerberosTime(const unsigned char *p, size_t len, KerberosTime *data, size_t *size)
1776 {
1777 size_t ret = 0, reallen;
1778 size_t l;
1779 int e;
1780
1781 memset(data, 0, sizeof(*data));
1782 reallen = 0;
1783 e = decode_generalized_time(p, len, data, &l);
1784 FORW;
1785 if(size) *size = ret;
1786 return 0;
1787 fail:
1788 free_KerberosTime(data);
1789 return e;
1790 }
1791
1792 void
1793 free_KerberosTime(KerberosTime *data)
1794 {
1795 }
1796
1797 size_t
1798 length_KerberosTime(const KerberosTime *data)
1799 {
1800 size_t ret = 0;
1801 ret += length_generalized_time(data);
1802 return ret;
1803 }
1804
1805 int
1806 copy_KerberosTime(const KerberosTime *from, KerberosTime *to)
1807 {
1808 *(to) = *(from);
1809 return 0;
1810 }
1811
1812 /* Generated from /home/lha/src/cvs/heimdal/lib/asn1/k5.asn1 */
1813 /* Do not edit */
1814
1815 #include <stdio.h>
1816 #include <stdlib.h>
1817 #include <time.h>
1818 #include <string.h>
1819 #include <errno.h>
1820 #include <asn1_err.h>
1821
1822 #define BACK if (e) return e; p -= l; len -= l; ret += l
1823
1824 int
1825 encode_TransitedEncoding(unsigned char *p, size_t len, const TransitedEncoding *data, size_t *size)
1826 {
1827 size_t ret = 0;
1828 size_t l;
1829 int i, e;
1830
1831 i = 0;
1832 {
1833 int oldret = ret;
1834 ret = 0;
1835 e = encode_octet_string(p, len, &(data)->contents, &l);
1836 BACK;
1837 e = der_put_length_and_tag (p, len, ret, Der_CONTEXT, CONS, 1, &l);
1838 BACK;
1839 ret += oldret;
1840 }
1841 {
1842 int oldret = ret;
1843 ret = 0;
1844 e = encode_integer(p, len, &(data)->tr_type, &l);
1845 BACK;
1846 e = der_put_length_and_tag (p, len, ret, Der_CONTEXT, CONS, 0, &l);
1847 BACK;
1848 ret += oldret;
1849 }
1850 e = der_put_length_and_tag (p, len, ret, UNIV, CONS, UT_Sequence, &l);
1851 BACK;
1852 *size = ret;
1853 return 0;
1854 }
1855
1856 #define FORW if(e) goto fail; p += l; len -= l; ret += l
1857
1858 int
1859 decode_TransitedEncoding(const unsigned char *p, size_t len, TransitedEncoding *data, size_t *size)
1860 {
1861 size_t ret = 0, reallen;
1862 size_t l;
1863 int e;
1864
1865 memset(data, 0, sizeof(*data));
1866 reallen = 0;
1867 e = der_match_tag_and_length (p, len, UNIV, CONS, UT_Sequence,&reallen, &l);
1868 FORW;
1869 {
1870 int dce_fix;
1871 if((dce_fix = fix_dce(reallen, &len)) < 0)
1872 return ASN1_BAD_FORMAT;
1873 {
1874 size_t newlen, oldlen;
1875
1876 e = der_match_tag (p, len, Der_CONTEXT, CONS, 0, &l);
1877 if (e)
1878 return e;
1879 else {
1880 p += l;
1881 len -= l;
1882 ret += l;
1883 e = der_get_length (p, len, &newlen, &l);
1884 FORW;
1885 {
1886 int dce_fix;
1887 oldlen = len;
1888 if((dce_fix = fix_dce(newlen, &len)) < 0)return ASN1_BAD_FORMAT;
1889 e = decode_integer(p, len, &(data)->tr_type, &l);
1890 FORW;
1891 if(dce_fix){
1892 e = der_match_tag_and_length (p, len, (Der_class)0, (Der_type)0, 0, &reallen, &l);
1893 FORW;
1894 }else
1895 len = oldlen - newlen;
1896 }
1897 }
1898 }
1899 {
1900 size_t newlen, oldlen;
1901
1902 e = der_match_tag (p, len, Der_CONTEXT, CONS, 1, &l);
1903 if (e)
1904 return e;
1905 else {
1906 p += l;
1907 len -= l;
1908 ret += l;
1909 e = der_get_length (p, len, &newlen, &l);
1910 FORW;
1911 {
1912 int dce_fix;
1913 oldlen = len;
1914 if((dce_fix = fix_dce(newlen, &len)) < 0)return ASN1_BAD_FORMAT;
1915 e = decode_octet_string(p, len, &(data)->contents, &l);
1916 FORW;
1917 if(dce_fix){
1918 e = der_match_tag_and_length (p, len, (Der_class)0, (Der_type)0, 0, &reallen, &l);
1919 FORW;
1920 }else
1921 len = oldlen - newlen;
1922 }
1923 }
1924 }
1925 if(dce_fix){
1926 e = der_match_tag_and_length (p, len, (Der_class)0, (Der_type)0, 0, &reallen, &l);
1927 FORW;
1928 }
1929 }
1930 if(size) *size = ret;
1931 return 0;
1932 fail:
1933 free_TransitedEncoding(data);
1934 return e;
1935 }
1936
1937 void
1938 free_TransitedEncoding(TransitedEncoding *data)
1939 {
1940 free_octet_string(&(data)->contents);
1941 }
1942
1943 size_t
1944 length_TransitedEncoding(const TransitedEncoding *data)
1945 {
1946 size_t ret = 0;
1947 {
1948 int oldret = ret;
1949 ret = 0;
1950 ret += length_integer(&(data)->tr_type);
1951 ret += 1 + length_len(ret) + oldret;
1952 }
1953 {
1954 int oldret = ret;
1955 ret = 0;
1956 ret += length_octet_string(&(data)->contents);
1957 ret += 1 + length_len(ret) + oldret;
1958 }
1959 ret += 1 + length_len(ret);
1960 return ret;
1961 }
1962
1963 int
1964 copy_TransitedEncoding(const TransitedEncoding *from, TransitedEncoding *to)
1965 {
1966 *(&(to)->tr_type) = *(&(from)->tr_type);
1967 if(copy_octet_string(&(from)->contents, &(to)->contents)) return ENOMEM;
1968 return 0;
1969 }
1970
1971 /* Generated from /home/lha/src/cvs/heimdal/lib/asn1/k5.asn1 */
1972 /* Do not edit */
1973
1974 #include <stdio.h>
1975 #include <stdlib.h>
1976 #include <time.h>
1977 #include <string.h>
1978 #include <errno.h>
1979 #include <asn1_err.h>
1980
1981 #define BACK if (e) return e; p -= l; len -= l; ret += l
1982
1983 int
1984 encode_EncryptionKey(unsigned char *p, size_t len, const EncryptionKey *data, size_t *size)
1985 {
1986 size_t ret = 0;
1987 size_t l;
1988 int i, e;
1989
1990 i = 0;
1991 {
1992 int oldret = ret;
1993 ret = 0;
1994 e = encode_octet_string(p, len, &(data)->keyvalue, &l);
1995 BACK;
1996 e = der_put_length_and_tag (p, len, ret, Der_CONTEXT, CONS, 1, &l);
1997 BACK;
1998 ret += oldret;
1999 }
2000 {
2001 int oldret = ret;
2002 ret = 0;
2003 e = encode_integer(p, len, &(data)->keytype, &l);
2004 BACK;
2005 e = der_put_length_and_tag (p, len, ret, Der_CONTEXT, CONS, 0, &l);
2006 BACK;
2007 ret += oldret;
2008 }
2009 e = der_put_length_and_tag (p, len, ret, UNIV, CONS, UT_Sequence, &l);
2010 BACK;
2011 *size = ret;
2012 return 0;
2013 }
2014
2015 #define FORW if(e) goto fail; p += l; len -= l; ret += l
2016
2017 int
2018 decode_EncryptionKey(const unsigned char *p, size_t len, EncryptionKey *data, size_t *size)
2019 {
2020 size_t ret = 0, reallen;
2021 size_t l;
2022 int e;
2023
2024 memset(data, 0, sizeof(*data));
2025 reallen = 0;
2026 e = der_match_tag_and_length (p, len, UNIV, CONS, UT_Sequence,&reallen, &l);
2027 FORW;
2028 {
2029 int dce_fix;
2030 if((dce_fix = fix_dce(reallen, &len)) < 0)
2031 return ASN1_BAD_FORMAT;
2032 {
2033 size_t newlen, oldlen;
2034
2035 e = der_match_tag (p, len, Der_CONTEXT, CONS, 0, &l);
2036 if (e)
2037 return e;
2038 else {
2039 p += l;
2040 len -= l;
2041 ret += l;
2042 e = der_get_length (p, len, &newlen, &l);
2043 FORW;
2044 {
2045 int dce_fix;
2046 oldlen = len;
2047 if((dce_fix = fix_dce(newlen, &len)) < 0)return ASN1_BAD_FORMAT;
2048 e = decode_integer(p, len, &(data)->keytype, &l);
2049 FORW;
2050 if(dce_fix){
2051 e = der_match_tag_and_length (p, len, (Der_class)0, (Der_type)0, 0, &reallen, &l);
2052 FORW;
2053 }else
2054 len = oldlen - newlen;
2055 }
2056 }
2057 }
2058 {
2059 size_t newlen, oldlen;
2060
2061 e = der_match_tag (p, len, Der_CONTEXT, CONS, 1, &l);
2062 if (e)
2063 return e;
2064 else {
2065 p += l;
2066 len -= l;
2067 ret += l;
2068 e = der_get_length (p, len, &newlen, &l);
2069 FORW;
2070 {
2071 int dce_fix;
2072 oldlen = len;
2073 if((dce_fix = fix_dce(newlen, &len)) < 0)return ASN1_BAD_FORMAT;
2074 e = decode_octet_string(p, len, &(data)->keyvalue, &l);
2075 FORW;
2076 if(dce_fix){
2077 e = der_match_tag_and_length (p, len, (Der_class)0, (Der_type)0, 0, &reallen, &l);
2078 FORW;
2079 }else
2080 len = oldlen - newlen;
2081 }
2082 }
2083 }
2084 if(dce_fix){
2085 e = der_match_tag_and_length (p, len, (Der_class)0, (Der_type)0, 0, &reallen, &l);
2086 FORW;
2087 }
2088 }
2089 if(size) *size = ret;
2090 return 0;
2091 fail:
2092 free_EncryptionKey(data);
2093 return e;
2094 }
2095
2096 void
2097 free_EncryptionKey(EncryptionKey *data)
2098 {
2099 free_octet_string(&(data)->keyvalue);
2100 }
2101
2102 size_t
2103 length_EncryptionKey(const EncryptionKey *data)
2104 {
2105 size_t ret = 0;
2106 {
2107 int oldret = ret;
2108 ret = 0;
2109 ret += length_integer(&(data)->keytype);
2110 ret += 1 + length_len(ret) + oldret;
2111 }
2112 {
2113 int oldret = ret;
2114 ret = 0;
2115 ret += length_octet_string(&(data)->keyvalue);
2116 ret += 1 + length_len(ret) + oldret;
2117 }
2118 ret += 1 + length_len(ret);
2119 return ret;
2120 }
2121
2122 int
2123 copy_EncryptionKey(const EncryptionKey *from, EncryptionKey *to)
2124 {
2125 *(&(to)->keytype) = *(&(from)->keytype);
2126 if(copy_octet_string(&(from)->keyvalue, &(to)->keyvalue)) return ENOMEM;
2127 return 0;
2128 }
2129
2130 /* Generated from /home/lha/src/cvs/heimdal/lib/asn1/k5.asn1 */
2131 /* Do not edit */
2132
2133 #include <stdio.h>
2134 #include <stdlib.h>
2135 #include <time.h>
2136 #include <string.h>
2137 #include <errno.h>
2138 #include <asn1_err.h>
2139
2140 #define BACK if (e) return e; p -= l; len -= l; ret += l
2141
2142 int
2143 encode_TicketFlags(unsigned char *p, size_t len, const TicketFlags *data, size_t *size)
2144 {
2145 size_t ret = 0;
2146 size_t l;
2147 int i, e;
2148
2149 i = 0;
2150 {
2151 unsigned char c = 0;
2152 *p-- = c; len--; ret++;
2153 c = 0;
2154 *p-- = c; len--; ret++;
2155 c = 0;
2156 if(data->anonymous) c |= 1<<1;
2157 if(data->ok_as_delegate) c |= 1<<2;
2158 if(data->transited_policy_checked) c |= 1<<3;
2159 if(data->hw_authent) c |= 1<<4;
2160 if(data->pre_authent) c |= 1<<5;
2161 if(data->initial) c |= 1<<6;
2162 if(data->renewable) c |= 1<<7;
2163 *p-- = c; len--; ret++;
2164 c = 0;
2165 if(data->invalid) c |= 1<<0;
2166 if(data->postdated) c |= 1<<1;
2167 if(data->may_postdate) c |= 1<<2;
2168 if(data->proxy) c |= 1<<3;
2169 if(data->proxiable) c |= 1<<4;
2170 if(data->forwarded) c |= 1<<5;
2171 if(data->forwardable) c |= 1<<6;
2172 if(data->reserved) c |= 1<<7;
2173 *p-- = c;
2174 *p-- = 0;
2175 len -= 2;
2176 ret += 2;
2177 }
2178
2179 e = der_put_length_and_tag (p, len, ret, UNIV, PRIM,UT_BitString, &l);
2180 BACK;
2181 *size = ret;
2182 return 0;
2183 }
2184
2185 #define FORW if(e) goto fail; p += l; len -= l; ret += l
2186
2187 int
2188 decode_TicketFlags(const unsigned char *p, size_t len, TicketFlags *data, size_t *size)
2189 {
2190 size_t ret = 0, reallen;
2191 size_t l;
2192 int e;
2193
2194 memset(data, 0, sizeof(*data));
2195 reallen = 0;
2196 e = der_match_tag_and_length (p, len, UNIV, PRIM, UT_BitString,&reallen, &l);
2197 FORW;
2198 if(len < reallen)
2199 return ASN1_OVERRUN;
2200 p++;
2201 len--;
2202 reallen--;
2203 ret++;
2204 data->reserved = (*p >> 7) & 1;
2205 data->forwardable = (*p >> 6) & 1;
2206 data->forwarded = (*p >> 5) & 1;
2207 data->proxiable = (*p >> 4) & 1;
2208 data->proxy = (*p >> 3) & 1;
2209 data->may_postdate = (*p >> 2) & 1;
2210 data->postdated = (*p >> 1) & 1;
2211 data->invalid = (*p >> 0) & 1;
2212 p++; len--; reallen--; ret++;
2213 data->renewable = (*p >> 7) & 1;
2214 data->initial = (*p >> 6) & 1;
2215 data->pre_authent = (*p >> 5) & 1;
2216 data->hw_authent = (*p >> 4) & 1;
2217 data->transited_policy_checked = (*p >> 3) & 1;
2218 data->ok_as_delegate = (*p >> 2) & 1;
2219 data->anonymous = (*p >> 1) & 1;
2220 p += reallen; len -= reallen; ret += reallen;
2221 if(size) *size = ret;
2222 return 0;
2223 fail:
2224 free_TicketFlags(data);
2225 return e;
2226 }
2227
2228 void
2229 free_TicketFlags(TicketFlags *data)
2230 {
2231 }
2232
2233 size_t
2234 length_TicketFlags(const TicketFlags *data)
2235 {
2236 size_t ret = 0;
2237 ret += 7;
2238 return ret;
2239 }
2240
2241 int
2242 copy_TicketFlags(const TicketFlags *from, TicketFlags *to)
2243 {
2244 *(to) = *(from);
2245 return 0;
2246 }
2247
2248 unsigned TicketFlags2int(TicketFlags f)
2249 {
2250 unsigned r = 0;
2251 if(f.reserved) r |= (1U << 0);
2252 if(f.forwardable) r |= (1U << 1);
2253 if(f.forwarded) r |= (1U << 2);
2254 if(f.proxiable) r |= (1U << 3);
2255 if(f.proxy) r |= (1U << 4);
2256 if(f.may_postdate) r |= (1U << 5);
2257 if(f.postdated) r |= (1U << 6);
2258 if(f.invalid) r |= (1U << 7);
2259 if(f.renewable) r |= (1U << 8);
2260 if(f.initial) r |= (1U << 9);
2261 if(f.pre_authent) r |= (1U << 10);
2262 if(f.hw_authent) r |= (1U << 11);
2263 if(f.transited_policy_checked) r |= (1U << 12);
2264 if(f.ok_as_delegate) r |= (1U << 13);
2265 if(f.anonymous) r |= (1U << 14);
2266 return r;
2267 }
2268
2269 TicketFlags int2TicketFlags(unsigned n)
2270 {
2271         TicketFlags flags;
2272
2273         flags.reserved = (n >> 0) & 1;
2274         flags.forwardable = (n >> 1) & 1;
2275         flags.forwarded = (n >> 2) & 1;
2276         flags.proxiable = (n >> 3) & 1;
2277         flags.proxy = (n >> 4) & 1;
2278         flags.may_postdate = (n >> 5) & 1;
2279         flags.postdated = (n >> 6) & 1;
2280         flags.invalid = (n >> 7) & 1;
2281         flags.renewable = (n >> 8) & 1;
2282         flags.initial = (n >> 9) & 1;
2283         flags.pre_authent = (n >> 10) & 1;
2284         flags.hw_authent = (n >> 11) & 1;
2285         flags.transited_policy_checked = (n >> 12) & 1;
2286         flags.ok_as_delegate = (n >> 13) & 1;
2287         flags.anonymous = (n >> 14) & 1;
2288         return flags;
2289 }
2290
2291
2292 /* Generated from /home/lha/src/cvs/heimdal/lib/asn1/k5.asn1 */
2293 /* Do not edit */
2294
2295 #include <stdio.h>
2296 #include <stdlib.h>
2297 #include <time.h>
2298 #include <string.h>
2299 #include <errno.h>
2300 #include <asn1_err.h>
2301
2302 #define BACK if (e) return e; p -= l; len -= l; ret += l
2303
2304 int
2305 encode_Realm(unsigned char *p, size_t len, const Realm *data, size_t *size)
2306 {
2307 size_t ret = 0;
2308 size_t l;
2309 int i, e;
2310
2311 i = 0;
2312 e = encode_general_string(p, len, data, &l);
2313 BACK;
2314 *size = ret;
2315 return 0;
2316 }
2317
2318 #define FORW if(e) goto fail; p += l; len -= l; ret += l
2319
2320 int
2321 decode_Realm(const unsigned char *p, size_t len, Realm *data, size_t *size)
2322 {
2323 size_t ret = 0, reallen;
2324 size_t l;
2325 int e;
2326
2327 memset(data, 0, sizeof(*data));
2328 reallen = 0;
2329 e = decode_general_string(p, len, data, &l);
2330 FORW;
2331 if(size) *size = ret;
2332 return 0;
2333 fail:
2334 free_Realm(data);
2335 return e;
2336 }
2337
2338 void
2339 free_Realm(Realm *data)
2340 {
2341 free_general_string(data);
2342 }
2343
2344 size_t
2345 length_Realm(const Realm *data)
2346 {
2347 size_t ret = 0;
2348 ret += length_general_string(data);
2349 return ret;
2350 }
2351
2352 int
2353 copy_Realm(const Realm *from, Realm *to)
2354 {
2355 if(copy_general_string(from, to)) return ENOMEM;
2356 return 0;
2357 }
2358
2359 /* Generated from /home/lha/src/cvs/heimdal/lib/asn1/k5.asn1 */
2360 /* Do not edit */
2361
2362 #include <stdio.h>
2363 #include <stdlib.h>
2364 #include <time.h>
2365 #include <string.h>
2366 #include <errno.h>
2367 #include <asn1_err.h>
2368
2369 #define BACK if (e) return e; p -= l; len -= l; ret += l
2370
2371 int
2372 encode_ENCTYPE(unsigned char *p, size_t len, const ENCTYPE *data, size_t *size)
2373 {
2374 size_t ret = 0;
2375 size_t l;
2376 int i, e;
2377
2378 i = 0;
2379 e = encode_integer(p, len, (const int*)data, &l);
2380 BACK;
2381 *size = ret;
2382 return 0;
2383 }
2384
2385 #define FORW if(e) goto fail; p += l; len -= l; ret += l
2386
2387 int
2388 decode_ENCTYPE(const unsigned char *p, size_t len, ENCTYPE *data, size_t *size)
2389 {
2390 size_t ret = 0, reallen;
2391 size_t l;
2392 int e;
2393
2394 memset(data, 0, sizeof(*data));
2395 reallen = 0;
2396 e = decode_integer(p, len, (int*)data, &l);
2397 FORW;
2398 if(size) *size = ret;
2399 return 0;
2400 fail:
2401 free_ENCTYPE(data);
2402 return e;
2403 }
2404
2405 void
2406 free_ENCTYPE(ENCTYPE *data)
2407 {
2408 }
2409
2410 size_t
2411 length_ENCTYPE(const ENCTYPE *data)
2412 {
2413 size_t ret = 0;
2414 ret += length_integer((const int*)data);
2415 return ret;
2416 }
2417
2418 int
2419 copy_ENCTYPE(const ENCTYPE *from, ENCTYPE *to)
2420 {
2421 *(to) = *(from);
2422 return 0;
2423 }
2424
2425 /* Generated from /home/lha/src/cvs/heimdal/lib/asn1/k5.asn1 */
2426 /* Do not edit */
2427
2428 #include <stdio.h>
2429 #include <stdlib.h>
2430 #include <time.h>
2431 #include <string.h>
2432 #include <errno.h>
2433 #include <asn1_err.h>
2434
2435 #define BACK if (e) return e; p -= l; len -= l; ret += l
2436
2437 int
2438 encode_NAME_TYPE(unsigned char *p, size_t len, const NAME_TYPE *data, size_t *size)
2439 {
2440 size_t ret = 0;
2441 size_t l;
2442 int i, e;
2443
2444 i = 0;
2445 e = encode_integer(p, len, (const int*)data, &l);
2446 BACK;
2447 *size = ret;
2448 return 0;
2449 }
2450
2451 #define FORW if(e) goto fail; p += l; len -= l; ret += l
2452
2453 int
2454 decode_NAME_TYPE(const unsigned char *p, size_t len, NAME_TYPE *data, size_t *size)
2455 {
2456 size_t ret = 0, reallen;
2457 size_t l;
2458 int e;
2459
2460 memset(data, 0, sizeof(*data));
2461 reallen = 0;
2462 e = decode_integer(p, len, (int*)data, &l);
2463 FORW;
2464 if(size) *size = ret;
2465 return 0;
2466 fail:
2467 free_NAME_TYPE(data);
2468 return e;
2469 }
2470
2471 void
2472 free_NAME_TYPE(NAME_TYPE *data)
2473 {
2474 }
2475
2476 size_t
2477 length_NAME_TYPE(const NAME_TYPE *data)
2478 {
2479 size_t ret = 0;
2480 ret += length_integer((const int*)data);
2481 return ret;
2482 }
2483
2484 int
2485 copy_NAME_TYPE(const NAME_TYPE *from, NAME_TYPE *to)
2486 {
2487 *(to) = *(from);
2488 return 0;
2489 }
2490