src/rxkad/v5gen.c

   1 /* Generated from ./krb5.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 <limits.h>
  10 #include <asn1_err.h>
  11
  12 int
  13 encode_krb5int32(unsigned char *p, size_t len, const krb5int32 * data, size_t * size)
  14 {
  15     size_t ret = 0;
  16     size_t l;
  17     int i AFS_UNUSED, e;
  18
  19     i = 0;
  20     e = der_put_integer(p, len, data, &l);
  21     if (e)
  22         return e;
  23     p -= l;
  24     len -= l;
  25     ret += l;
  26
  27     e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
  28     if (e)
  29         return e;
  30     p -= l;
  31     len -= l;
  32     ret += l;
  33
  34     *size = ret;
  35     return 0;
  36 }
  37
  38 int
  39 decode_krb5int32(const unsigned char *p, size_t len, krb5int32 * data, size_t * size)
  40 {
  41     size_t ret = 0;
  42     size_t l;
  43     int e;
  44
  45     memset(data, 0, sizeof(*data));
  46     {
  47         size_t Top_datalen, Top_oldlen;
  48         Der_type Top_type;
  49         e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Integer, &Top_datalen, &l);
  50         if (e == 0 && Top_type != PRIM) {
  51             e = ASN1_BAD_ID;
  52         }
  53         if (e)
  54             goto fail;
  55         p += l;
  56         len -= l;
  57         ret += l;
  58         Top_oldlen = len;
  59         if (Top_datalen > len) {
  60             e = ASN1_OVERRUN;
  61             goto fail;
  62         }
  63         len = Top_datalen;
  64         e = der_get_integer(p, len, data, &l);
  65         if (e)
  66             goto fail;
  67         p += l;
  68         len -= l;
  69         ret += l;
  70         len = Top_oldlen - Top_datalen;
  71     }
  72     if (size)
  73         *size = ret;
  74     return 0;
  75 fail:
  76     free_krb5int32(data);
  77     return e;
  78 }
  79
  80 void
  81 free_krb5int32(krb5int32 * data)
  82 {
  83 }
  84
  85 size_t
  86 length_krb5int32(const krb5int32 * data)
  87 {
  88     size_t ret = 0;
  89     ret += der_length_integer(data);
  90     ret += 1 + der_length_len(ret);
  91     return ret;
  92 }
  93
  94 int
  95 copy_krb5int32(const krb5int32 * from, krb5int32 * to)
  96 {
  97     memset(to, 0, sizeof(*to));
  98     *(to) = *(from);
  99     return 0;
 100 }
 101
 102
 103
 104 /* Generated from ./krb5.asn1 */
 105 /* Do not edit */
 106
 107 #include <stdio.h>
 108 #include <stdlib.h>
 109 #include <time.h>
 110 #include <string.h>
 111 #include <errno.h>
 112 #include <limits.h>
 113 #include <asn1_err.h>
 114
 115 int
 116 encode_Ticket(unsigned char *p, size_t len, const Ticket * data, size_t * size)
 117 {
 118     size_t ret = 0;
 119     size_t l;
 120     int i AFS_UNUSED, e;
 121
 122     i = 0;
 123 /* enc-part */
 124     {
 125         size_t Top_tag_tag_oldret = ret;
 126         ret = 0;
 127         e = encode_EncryptedData(p, len, &(data)->enc_part, &l);
 128         if (e)
 129             return e;
 130         p -= l;
 131         len -= l;
 132         ret += l;
 133
 134         e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
 135         if (e)
 136             return e;
 137         p -= l;
 138         len -= l;
 139         ret += l;
 140
 141         ret += Top_tag_tag_oldret;
 142     }
 143 /* sname */
 144     {
 145         size_t Top_tag_tag_oldret = ret;
 146         ret = 0;
 147         e = encode_PrincipalName(p, len, &(data)->sname, &l);
 148         if (e)
 149             return e;
 150         p -= l;
 151         len -= l;
 152         ret += l;
 153
 154         e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
 155         if (e)
 156             return e;
 157         p -= l;
 158         len -= l;
 159         ret += l;
 160
 161         ret += Top_tag_tag_oldret;
 162     }
 163 /* realm */
 164     {
 165         size_t Top_tag_tag_oldret = ret;
 166         ret = 0;
 167         e = encode_Realm(p, len, &(data)->realm, &l);
 168         if (e)
 169             return e;
 170         p -= l;
 171         len -= l;
 172         ret += l;
 173
 174         e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
 175         if (e)
 176             return e;
 177         p -= l;
 178         len -= l;
 179         ret += l;
 180
 181         ret += Top_tag_tag_oldret;
 182     }
 183 /* tkt-vno */
 184     {
 185         size_t Top_tag_tag_oldret = ret;
 186         ret = 0;
 187         e = encode_krb5int32(p, len, &(data)->tkt_vno, &l);
 188         if (e)
 189             return e;
 190         p -= l;
 191         len -= l;
 192         ret += l;
 193
 194         e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
 195         if (e)
 196             return e;
 197         p -= l;
 198         len -= l;
 199         ret += l;
 200
 201         ret += Top_tag_tag_oldret;
 202     }
 203     e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
 204     if (e)
 205         return e;
 206     p -= l;
 207     len -= l;
 208     ret += l;
 209
 210     e = der_put_length_and_tag(p, len, ret, ASN1_C_APPL, CONS, 1, &l);
 211     if (e)
 212         return e;
 213     p -= l;
 214     len -= l;
 215     ret += l;
 216
 217     *size = ret;
 218     return 0;
 219 }
 220
 221 int
 222 decode_Ticket(const unsigned char *p, size_t len, Ticket * data, size_t * size)
 223 {
 224     size_t ret = 0;
 225     size_t l;
 226     int e;
 227
 228     memset(data, 0, sizeof(*data));
 229     {
 230         size_t Top_datalen, Top_oldlen;
 231         Der_type Top_type;
 232         e = der_match_tag_and_length(p, len, ASN1_C_APPL, &Top_type, 1, &Top_datalen, &l);
 233         if (e == 0 && Top_type != CONS) {
 234             e = ASN1_BAD_ID;
 235         }
 236         if (e)
 237             goto fail;
 238         p += l;
 239         len -= l;
 240         ret += l;
 241         Top_oldlen = len;
 242         if (Top_datalen > len) {
 243             e = ASN1_OVERRUN;
 244             goto fail;
 245         }
 246         len = Top_datalen;
 247         {
 248             size_t Top_Tag_datalen, Top_Tag_oldlen;
 249             Der_type Top_Tag_type;
 250             e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_Tag_type, UT_Sequence, &Top_Tag_datalen, &l);
 251             if (e == 0 && Top_Tag_type != CONS) {
 252                 e = ASN1_BAD_ID;
 253             }
 254             if (e)
 255                 goto fail;
 256             p += l;
 257             len -= l;
 258             ret += l;
 259             Top_Tag_oldlen = len;
 260             if (Top_Tag_datalen > len) {
 261                 e = ASN1_OVERRUN;
 262                 goto fail;
 263             }
 264             len = Top_Tag_datalen;
 265             {
 266                 size_t tkt_vno_datalen, tkt_vno_oldlen;
 267                 Der_type tkt_vno_type;
 268                 e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &tkt_vno_type, 0, &tkt_vno_datalen, &l);
 269                 if (e == 0 && tkt_vno_type != CONS) {
 270                     e = ASN1_BAD_ID;
 271                 }
 272                 if (e)
 273                     goto fail;
 274                 p += l;
 275                 len -= l;
 276                 ret += l;
 277                 tkt_vno_oldlen = len;
 278                 if (tkt_vno_datalen > len) {
 279                     e = ASN1_OVERRUN;
 280                     goto fail;
 281                 }
 282                 len = tkt_vno_datalen;
 283                 e = decode_krb5int32(p, len, &(data)->tkt_vno, &l);
 284                 if (e)
 285                     goto fail;
 286                 p += l;
 287                 len -= l;
 288                 ret += l;
 289                 len = tkt_vno_oldlen - tkt_vno_datalen;
 290             }
 291             {
 292                 size_t realm_datalen, realm_oldlen;
 293                 Der_type realm_type;
 294                 e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &realm_type, 1, &realm_datalen, &l);
 295                 if (e == 0 && realm_type != CONS) {
 296                     e = ASN1_BAD_ID;
 297                 }
 298                 if (e)
 299                     goto fail;
 300                 p += l;
 301                 len -= l;
 302                 ret += l;
 303                 realm_oldlen = len;
 304                 if (realm_datalen > len) {
 305                     e = ASN1_OVERRUN;
 306                     goto fail;
 307                 }
 308                 len = realm_datalen;
 309                 e = decode_Realm(p, len, &(data)->realm, &l);
 310                 if (e)
 311                     goto fail;
 312                 p += l;
 313                 len -= l;
 314                 ret += l;
 315                 len = realm_oldlen - realm_datalen;
 316             }
 317             {
 318                 size_t sname_datalen, sname_oldlen;
 319                 Der_type sname_type;
 320                 e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &sname_type, 2, &sname_datalen, &l);
 321                 if (e == 0 && sname_type != CONS) {
 322                     e = ASN1_BAD_ID;
 323                 }
 324                 if (e)
 325                     goto fail;
 326                 p += l;
 327                 len -= l;
 328                 ret += l;
 329                 sname_oldlen = len;
 330                 if (sname_datalen > len) {
 331                     e = ASN1_OVERRUN;
 332                     goto fail;
 333                 }
 334                 len = sname_datalen;
 335                 e = decode_PrincipalName(p, len, &(data)->sname, &l);
 336                 if (e)
 337                     goto fail;
 338                 p += l;
 339                 len -= l;
 340                 ret += l;
 341                 len = sname_oldlen - sname_datalen;
 342             }
 343             {
 344                 size_t enc_part_datalen, enc_part_oldlen;
 345                 Der_type enc_part_type;
 346                 e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &enc_part_type, 3, &enc_part_datalen, &l);
 347                 if (e == 0 && enc_part_type != CONS) {
 348                     e = ASN1_BAD_ID;
 349                 }
 350                 if (e)
 351                     goto fail;
 352                 p += l;
 353                 len -= l;
 354                 ret += l;
 355                 enc_part_oldlen = len;
 356                 if (enc_part_datalen > len) {
 357                     e = ASN1_OVERRUN;
 358                     goto fail;
 359                 }
 360                 len = enc_part_datalen;
 361                 e = decode_EncryptedData(p, len, &(data)->enc_part, &l);
 362                 if (e)
 363                     goto fail;
 364                 p += l;
 365                 len -= l;
 366                 ret += l;
 367                 len = enc_part_oldlen - enc_part_datalen;
 368             }
 369             len = Top_Tag_oldlen - Top_Tag_datalen;
 370         }
 371         len = Top_oldlen - Top_datalen;
 372     }
 373     if (size)
 374         *size = ret;
 375     return 0;
 376 fail:
 377     free_Ticket(data);
 378     return e;
 379 }
 380
 381 void
 382 free_Ticket(Ticket * data)
 383 {
 384     free_krb5int32(&(data)->tkt_vno);
 385     free_Realm(&(data)->realm);
 386     free_PrincipalName(&(data)->sname);
 387     free_EncryptedData(&(data)->enc_part);
 388 }
 389
 390 size_t
 391 length_Ticket(const Ticket * data)
 392 {
 393     size_t ret = 0;
 394     {
 395         size_t Top_tag_tag_oldret = ret;
 396         ret = 0;
 397         ret += length_krb5int32(&(data)->tkt_vno);
 398         ret += 1 + der_length_len(ret);
 399         ret += Top_tag_tag_oldret;
 400     }
 401     {
 402         size_t Top_tag_tag_oldret = ret;
 403         ret = 0;
 404         ret += length_Realm(&(data)->realm);
 405         ret += 1 + der_length_len(ret);
 406         ret += Top_tag_tag_oldret;
 407     }
 408     {
 409         size_t Top_tag_tag_oldret = ret;
 410         ret = 0;
 411         ret += length_PrincipalName(&(data)->sname);
 412         ret += 1 + der_length_len(ret);
 413         ret += Top_tag_tag_oldret;
 414     }
 415     {
 416         size_t Top_tag_tag_oldret = ret;
 417         ret = 0;
 418         ret += length_EncryptedData(&(data)->enc_part);
 419         ret += 1 + der_length_len(ret);
 420         ret += Top_tag_tag_oldret;
 421     }
 422     ret += 1 + der_length_len(ret);
 423     ret += 1 + der_length_len(ret);
 424     return ret;
 425 }
 426
 427 int
 428 copy_Ticket(const Ticket * from, Ticket * to)
 429 {
 430     memset(to, 0, sizeof(*to));
 431     if (copy_krb5int32(&(from)->tkt_vno, &(to)->tkt_vno))
 432         goto fail;
 433     if (copy_Realm(&(from)->realm, &(to)->realm))
 434         goto fail;
 435     if (copy_PrincipalName(&(from)->sname, &(to)->sname))
 436         goto fail;
 437     if (copy_EncryptedData(&(from)->enc_part, &(to)->enc_part))
 438         goto fail;
 439     return 0;
 440 fail:
 441     free_Ticket(to);
 442     return ENOMEM;
 443 }
 444
 445
 446
 447 /* Generated from ./krb5.asn1 */
 448 /* Do not edit */
 449
 450 #include <stdio.h>
 451 #include <stdlib.h>
 452 #include <time.h>
 453 #include <string.h>
 454 #include <errno.h>
 455 #include <limits.h>
 456 #include <asn1_err.h>
 457
 458 int
 459 encode_AuthorizationDataElement(unsigned char *p, size_t len, const AuthorizationDataElement * data, size_t * size)
 460 {
 461     size_t ret = 0;
 462     size_t l;
 463     int i AFS_UNUSED, e;
 464
 465     i = 0;
 466 /* ad-data */
 467     {
 468         size_t Top_tag_oldret = ret;
 469         ret = 0;
 470         e = der_put_octet_string(p, len, &(data)->ad_data, &l);
 471         if (e)
 472             return e;
 473         p -= l;
 474         len -= l;
 475         ret += l;
 476
 477         e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
 478         if (e)
 479             return e;
 480         p -= l;
 481         len -= l;
 482         ret += l;
 483
 484         e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
 485         if (e)
 486             return e;
 487         p -= l;
 488         len -= l;
 489         ret += l;
 490
 491         ret += Top_tag_oldret;
 492     }
 493 /* ad-type */
 494     {
 495         size_t Top_tag_oldret = ret;
 496         ret = 0;
 497         e = encode_krb5int32(p, len, &(data)->ad_type, &l);
 498         if (e)
 499             return e;
 500         p -= l;
 501         len -= l;
 502         ret += l;
 503
 504         e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
 505         if (e)
 506             return e;
 507         p -= l;
 508         len -= l;
 509         ret += l;
 510
 511         ret += Top_tag_oldret;
 512     }
 513     e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
 514     if (e)
 515         return e;
 516     p -= l;
 517     len -= l;
 518     ret += l;
 519
 520     *size = ret;
 521     return 0;
 522 }
 523
 524 int
 525 decode_AuthorizationDataElement(const unsigned char *p, size_t len, AuthorizationDataElement * data, size_t * size)
 526 {
 527     size_t ret = 0;
 528     size_t l;
 529     int e;
 530
 531     memset(data, 0, sizeof(*data));
 532     {
 533         size_t Top_datalen, Top_oldlen;
 534         Der_type Top_type;
 535         e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
 536         if (e == 0 && Top_type != CONS) {
 537             e = ASN1_BAD_ID;
 538         }
 539         if (e)
 540             goto fail;
 541         p += l;
 542         len -= l;
 543         ret += l;
 544         Top_oldlen = len;
 545         if (Top_datalen > len) {
 546             e = ASN1_OVERRUN;
 547             goto fail;
 548         }
 549         len = Top_datalen;
 550         {
 551             size_t ad_type_datalen, ad_type_oldlen;
 552             Der_type ad_type_type;
 553             e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &ad_type_type, 0, &ad_type_datalen, &l);
 554             if (e == 0 && ad_type_type != CONS) {
 555                 e = ASN1_BAD_ID;
 556             }
 557             if (e)
 558                 goto fail;
 559             p += l;
 560             len -= l;
 561             ret += l;
 562             ad_type_oldlen = len;
 563             if (ad_type_datalen > len) {
 564                 e = ASN1_OVERRUN;
 565                 goto fail;
 566             }
 567             len = ad_type_datalen;
 568             e = decode_krb5int32(p, len, &(data)->ad_type, &l);
 569             if (e)
 570                 goto fail;
 571             p += l;
 572             len -= l;
 573             ret += l;
 574             len = ad_type_oldlen - ad_type_datalen;
 575         }
 576         {
 577             size_t ad_data_datalen, ad_data_oldlen;
 578             Der_type ad_data_type;
 579             e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &ad_data_type, 1, &ad_data_datalen, &l);
 580             if (e == 0 && ad_data_type != CONS) {
 581                 e = ASN1_BAD_ID;
 582             }
 583             if (e)
 584                 goto fail;
 585             p += l;
 586             len -= l;
 587             ret += l;
 588             ad_data_oldlen = len;
 589             if (ad_data_datalen > len) {
 590                 e = ASN1_OVERRUN;
 591                 goto fail;
 592             }
 593             len = ad_data_datalen;
 594             {
 595                 size_t ad_data_Tag_datalen, ad_data_Tag_oldlen;
 596                 Der_type ad_data_Tag_type;
 597                 e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &ad_data_Tag_type, UT_OctetString, &ad_data_Tag_datalen, &l);
 598                 if (e == 0 && ad_data_Tag_type != PRIM) {
 599                     e = ASN1_BAD_ID;
 600                 }
 601                 if (e)
 602                     goto fail;
 603                 p += l;
 604                 len -= l;
 605                 ret += l;
 606                 ad_data_Tag_oldlen = len;
 607                 if (ad_data_Tag_datalen > len) {
 608                     e = ASN1_OVERRUN;
 609                     goto fail;
 610                 }
 611                 len = ad_data_Tag_datalen;
 612                 e = der_get_octet_string(p, len, &(data)->ad_data, &l);
 613                 if (e)
 614                     goto fail;
 615                 p += l;
 616                 len -= l;
 617                 ret += l;
 618                 len = ad_data_Tag_oldlen - ad_data_Tag_datalen;
 619             }
 620             len = ad_data_oldlen - ad_data_datalen;
 621         }
 622         len = Top_oldlen - Top_datalen;
 623     }
 624     if (size)
 625         *size = ret;
 626     return 0;
 627 fail:
 628     free_AuthorizationDataElement(data);
 629     return e;
 630 }
 631
 632 void
 633 free_AuthorizationDataElement(AuthorizationDataElement * data)
 634 {
 635     free_krb5int32(&(data)->ad_type);
 636     der_free_octet_string(&(data)->ad_data);
 637 }
 638
 639 size_t
 640 length_AuthorizationDataElement(const AuthorizationDataElement * data)
 641 {
 642     size_t ret = 0;
 643     {
 644         size_t Top_tag_oldret = ret;
 645         ret = 0;
 646         ret += length_krb5int32(&(data)->ad_type);
 647         ret += 1 + der_length_len(ret);
 648         ret += Top_tag_oldret;
 649     }
 650     {
 651         size_t Top_tag_oldret = ret;
 652         ret = 0;
 653         ret += der_length_octet_string(&(data)->ad_data);
 654         ret += 1 + der_length_len(ret);
 655         ret += 1 + der_length_len(ret);
 656         ret += Top_tag_oldret;
 657     }
 658     ret += 1 + der_length_len(ret);
 659     return ret;
 660 }
 661
 662 int
 663 copy_AuthorizationDataElement(const AuthorizationDataElement * from, AuthorizationDataElement * to)
 664 {
 665     memset(to, 0, sizeof(*to));
 666     if (copy_krb5int32(&(from)->ad_type, &(to)->ad_type))
 667         goto fail;
 668     if (der_copy_octet_string(&(from)->ad_data, &(to)->ad_data))
 669         goto fail;
 670     return 0;
 671 fail:
 672     free_AuthorizationDataElement(to);
 673     return ENOMEM;
 674 }
 675
 676
 677
 678 /* Generated from ./krb5.asn1 */
 679 /* Do not edit */
 680
 681 #include <stdio.h>
 682 #include <stdlib.h>
 683 #include <time.h>
 684 #include <string.h>
 685 #include <errno.h>
 686 #include <limits.h>
 687 #include <asn1_err.h>
 688
 689 int
 690 encode_EncryptedData(unsigned char *p, size_t len, const EncryptedData * data, size_t * size)
 691 {
 692     size_t ret = 0;
 693     size_t l;
 694     int i AFS_UNUSED, e;
 695
 696     i = 0;
 697 /* cipher */
 698     {
 699         size_t Top_tag_oldret = ret;
 700         ret = 0;
 701         e = der_put_octet_string(p, len, &(data)->cipher, &l);
 702         if (e)
 703             return e;
 704         p -= l;
 705         len -= l;
 706         ret += l;
 707
 708         e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
 709         if (e)
 710             return e;
 711         p -= l;
 712         len -= l;
 713         ret += l;
 714
 715         e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
 716         if (e)
 717             return e;
 718         p -= l;
 719         len -= l;
 720         ret += l;
 721
 722         ret += Top_tag_oldret;
 723     }
 724 /* kvno */
 725     if ((data)->kvno) {
 726         size_t Top_tag_oldret = ret;
 727         ret = 0;
 728         e = encode_krb5int32(p, len, (data)->kvno, &l);
 729         if (e)
 730             return e;
 731         p -= l;
 732         len -= l;
 733         ret += l;
 734
 735         e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
 736         if (e)
 737             return e;
 738         p -= l;
 739         len -= l;
 740         ret += l;
 741
 742         ret += Top_tag_oldret;
 743     }
 744 /* etype */
 745     {
 746         size_t Top_tag_oldret = ret;
 747         ret = 0;
 748         e = encode_ENCTYPE(p, len, &(data)->etype, &l);
 749         if (e)
 750             return e;
 751         p -= l;
 752         len -= l;
 753         ret += l;
 754
 755         e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
 756         if (e)
 757             return e;
 758         p -= l;
 759         len -= l;
 760         ret += l;
 761
 762         ret += Top_tag_oldret;
 763     }
 764     e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
 765     if (e)
 766         return e;
 767     p -= l;
 768     len -= l;
 769     ret += l;
 770
 771     *size = ret;
 772     return 0;
 773 }
 774
 775 int
 776 decode_EncryptedData(const unsigned char *p, size_t len, EncryptedData * data, size_t * size)
 777 {
 778     size_t ret = 0;
 779     size_t l;
 780     int e;
 781
 782     memset(data, 0, sizeof(*data));
 783     {
 784         size_t Top_datalen, Top_oldlen;
 785         Der_type Top_type;
 786         e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
 787         if (e == 0 && Top_type != CONS) {
 788             e = ASN1_BAD_ID;
 789         }
 790         if (e)
 791             goto fail;
 792         p += l;
 793         len -= l;
 794         ret += l;
 795         Top_oldlen = len;
 796         if (Top_datalen > len) {
 797             e = ASN1_OVERRUN;
 798             goto fail;
 799         }
 800         len = Top_datalen;
 801         {
 802             size_t etype_datalen, etype_oldlen;
 803             Der_type etype_type;
 804             e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &etype_type, 0, &etype_datalen, &l);
 805             if (e == 0 && etype_type != CONS) {
 806                 e = ASN1_BAD_ID;
 807             }
 808             if (e)
 809                 goto fail;
 810             p += l;
 811             len -= l;
 812             ret += l;
 813             etype_oldlen = len;
 814             if (etype_datalen > len) {
 815                 e = ASN1_OVERRUN;
 816                 goto fail;
 817             }
 818             len = etype_datalen;
 819             e = decode_ENCTYPE(p, len, &(data)->etype, &l);
 820             if (e)
 821                 goto fail;
 822             p += l;
 823             len -= l;
 824             ret += l;
 825             len = etype_oldlen - etype_datalen;
 826         }
 827         {
 828             size_t kvno_datalen, kvno_oldlen;
 829             Der_type kvno_type;
 830             e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &kvno_type, 1, &kvno_datalen, &l);
 831             if (e == 0 && kvno_type != CONS) {
 832                 e = ASN1_BAD_ID;
 833             }
 834             if (e) {
 835                 (data)->kvno = NULL;
 836             } else {
 837                 (data)->kvno = calloc(1, sizeof(*(data)->kvno));
 838                 if ((data)->kvno == NULL) {
 839                     e = ENOMEM;
 840                     goto fail;
 841                 }
 842                 p += l;
 843                 len -= l;
 844                 ret += l;
 845                 kvno_oldlen = len;
 846                 if (kvno_datalen > len) {
 847                     e = ASN1_OVERRUN;
 848                     goto fail;
 849                 }
 850                 len = kvno_datalen;
 851                 e = decode_krb5int32(p, len, (data)->kvno, &l);
 852                 if (e)
 853                     goto fail;
 854                 p += l;
 855                 len -= l;
 856                 ret += l;
 857                 len = kvno_oldlen - kvno_datalen;
 858             }
 859         }
 860         {
 861             size_t cipher_datalen, cipher_oldlen;
 862             Der_type cipher_type;
 863             e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &cipher_type, 2, &cipher_datalen, &l);
 864             if (e == 0 && cipher_type != CONS) {
 865                 e = ASN1_BAD_ID;
 866             }
 867             if (e)
 868                 goto fail;
 869             p += l;
 870             len -= l;
 871             ret += l;
 872             cipher_oldlen = len;
 873             if (cipher_datalen > len) {
 874                 e = ASN1_OVERRUN;
 875                 goto fail;
 876             }
 877             len = cipher_datalen;
 878             {
 879                 size_t cipher_Tag_datalen, cipher_Tag_oldlen;
 880                 Der_type cipher_Tag_type;
 881                 e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &cipher_Tag_type, UT_OctetString, &cipher_Tag_datalen, &l);
 882                 if (e == 0 && cipher_Tag_type != PRIM) {
 883                     e = ASN1_BAD_ID;
 884                 }
 885                 if (e)
 886                     goto fail;
 887                 p += l;
 888                 len -= l;
 889                 ret += l;
 890                 cipher_Tag_oldlen = len;
 891                 if (cipher_Tag_datalen > len) {
 892                     e = ASN1_OVERRUN;
 893                     goto fail;
 894                 }
 895                 len = cipher_Tag_datalen;
 896                 e = der_get_octet_string(p, len, &(data)->cipher, &l);
 897                 if (e)
 898                     goto fail;
 899                 p += l;
 900                 len -= l;
 901                 ret += l;
 902                 len = cipher_Tag_oldlen - cipher_Tag_datalen;
 903             }
 904             len = cipher_oldlen - cipher_datalen;
 905         }
 906         len = Top_oldlen - Top_datalen;
 907     }
 908     if (size)
 909         *size = ret;
 910     return 0;
 911 fail:
 912     free_EncryptedData(data);
 913     return e;
 914 }
 915
 916 void
 917 free_EncryptedData(EncryptedData * data)
 918 {
 919     free_ENCTYPE(&(data)->etype);
 920     if ((data)->kvno) {
 921         free_krb5int32((data)->kvno);
 922         free((data)->kvno);
 923         (data)->kvno = NULL;
 924     }
 925     der_free_octet_string(&(data)->cipher);
 926 }
 927
 928 size_t
 929 length_EncryptedData(const EncryptedData * data)
 930 {
 931     size_t ret = 0;
 932     {
 933         size_t Top_tag_oldret = ret;
 934         ret = 0;
 935         ret += length_ENCTYPE(&(data)->etype);
 936         ret += 1 + der_length_len(ret);
 937         ret += Top_tag_oldret;
 938     }
 939     if ((data)->kvno) {
 940         size_t Top_tag_oldret = ret;
 941         ret = 0;
 942         ret += length_krb5int32((data)->kvno);
 943         ret += 1 + der_length_len(ret);
 944         ret += Top_tag_oldret;
 945     } {
 946         size_t Top_tag_oldret = ret;
 947         ret = 0;
 948         ret += der_length_octet_string(&(data)->cipher);
 949         ret += 1 + der_length_len(ret);
 950         ret += 1 + der_length_len(ret);
 951         ret += Top_tag_oldret;
 952     }
 953     ret += 1 + der_length_len(ret);
 954     return ret;
 955 }
 956
 957 int
 958 copy_EncryptedData(const EncryptedData * from, EncryptedData * to)
 959 {
 960     memset(to, 0, sizeof(*to));
 961     if (copy_ENCTYPE(&(from)->etype, &(to)->etype))
 962         goto fail;
 963     if ((from)->kvno) {
 964         (to)->kvno = malloc(sizeof(*(to)->kvno));
 965         if ((to)->kvno == NULL)
 966             goto fail;
 967         if (copy_krb5int32((from)->kvno, (to)->kvno))
 968             goto fail;
 969     } else
 970         (to)->kvno = NULL;
 971     if (der_copy_octet_string(&(from)->cipher, &(to)->cipher))
 972         goto fail;
 973     return 0;
 974 fail:
 975     free_EncryptedData(to);
 976     return ENOMEM;
 977 }
 978
 979
 980
 981 /* Generated from ./krb5.asn1 */
 982 /* Do not edit */
 983
 984 #include <stdio.h>
 985 #include <stdlib.h>
 986 #include <time.h>
 987 #include <string.h>
 988 #include <errno.h>
 989 #include <limits.h>
 990 #include <asn1_err.h>
 991
 992 int
 993 encode_PrincipalName(unsigned char *p, size_t len, const PrincipalName * data, size_t * size)
 994 {
 995     size_t ret = 0;
 996     size_t l;
 997     int i, e;
 998
 999     i = 0;
1000 /* name-string */
1001     {
1002         size_t Top_tag_oldret = ret;
1003         ret = 0;
1004         for (i = (&(data)->name_string)->len - 1; i >= 0; --i) {
1005             size_t name_string_tag_tag_for_oldret = ret;
1006             ret = 0;
1007             e = der_put_general_string(p, len, &(&(data)->name_string)->val[i], &l);
1008             if (e)
1009                 return e;
1010             p -= l;
1011             len -= l;
1012             ret += l;
1013
1014             e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, PRIM, UT_GeneralString, &l);
1015             if (e)
1016                 return e;
1017             p -= l;
1018             len -= l;
1019             ret += l;
1020
1021             ret += name_string_tag_tag_for_oldret;
1022         }
1023         e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
1024         if (e)
1025             return e;
1026         p -= l;
1027         len -= l;
1028         ret += l;
1029
1030         e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
1031         if (e)
1032             return e;
1033         p -= l;
1034         len -= l;
1035         ret += l;
1036
1037         ret += Top_tag_oldret;
1038     }
1039 /* name-type */
1040     {
1041         size_t Top_tag_oldret = ret;
1042         ret = 0;
1043         e = encode_NAME_TYPE(p, len, &(data)->name_type, &l);
1044         if (e)
1045             return e;
1046         p -= l;
1047         len -= l;
1048         ret += l;
1049
1050         e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
1051         if (e)
1052             return e;
1053         p -= l;
1054         len -= l;
1055         ret += l;
1056
1057         ret += Top_tag_oldret;
1058     }
1059     e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
1060     if (e)
1061         return e;
1062     p -= l;
1063     len -= l;
1064     ret += l;
1065
1066     *size = ret;
1067     return 0;
1068 }
1069
1070 int
1071 decode_PrincipalName(const unsigned char *p, size_t len, PrincipalName * data, size_t * size)
1072 {
1073     size_t ret = 0;
1074     size_t l;
1075     int e;
1076
1077     memset(data, 0, sizeof(*data));
1078     {
1079         size_t Top_datalen, Top_oldlen;
1080         Der_type Top_type;
1081         e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
1082         if (e == 0 && Top_type != CONS) {
1083             e = ASN1_BAD_ID;
1084         }
1085         if (e)
1086             goto fail;
1087         p += l;
1088         len -= l;
1089         ret += l;
1090         Top_oldlen = len;
1091         if (Top_datalen > len) {
1092             e = ASN1_OVERRUN;
1093             goto fail;
1094         }
1095         len = Top_datalen;
1096         {
1097             size_t name_type_datalen, name_type_oldlen;
1098             Der_type name_type_type;
1099             e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &name_type_type, 0, &name_type_datalen, &l);
1100             if (e == 0 && name_type_type != CONS) {
1101                 e = ASN1_BAD_ID;
1102             }
1103             if (e)
1104                 goto fail;
1105             p += l;
1106             len -= l;
1107             ret += l;
1108             name_type_oldlen = len;
1109             if (name_type_datalen > len) {
1110                 e = ASN1_OVERRUN;
1111                 goto fail;
1112             }
1113             len = name_type_datalen;
1114             e = decode_NAME_TYPE(p, len, &(data)->name_type, &l);
1115             if (e)
1116                 goto fail;
1117             p += l;
1118             len -= l;
1119             ret += l;
1120             len = name_type_oldlen - name_type_datalen;
1121         }
1122         {
1123             size_t name_string_datalen, name_string_oldlen;
1124             Der_type name_string_type;
1125             e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &name_string_type, 1, &name_string_datalen, &l);
1126             if (e == 0 && name_string_type != CONS) {
1127                 e = ASN1_BAD_ID;
1128             }
1129             if (e)
1130                 goto fail;
1131             p += l;
1132             len -= l;
1133             ret += l;
1134             name_string_oldlen = len;
1135             if (name_string_datalen > len) {
1136                 e = ASN1_OVERRUN;
1137                 goto fail;
1138             }
1139             len = name_string_datalen;
1140             {
1141                 size_t name_string_Tag_datalen, name_string_Tag_oldlen;
1142                 Der_type name_string_Tag_type;
1143                 e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &name_string_Tag_type, UT_Sequence, &name_string_Tag_datalen, &l);
1144                 if (e == 0 && name_string_Tag_type != CONS) {
1145                     e = ASN1_BAD_ID;
1146                 }
1147                 if (e)
1148                     goto fail;
1149                 p += l;
1150                 len -= l;
1151                 ret += l;
1152                 name_string_Tag_oldlen = len;
1153                 if (name_string_Tag_datalen > len) {
1154                     e = ASN1_OVERRUN;
1155                     goto fail;
1156                 }
1157                 len = name_string_Tag_datalen;
1158                 {
1159                     size_t name_string_Tag_Tag_origlen = len;
1160                     size_t name_string_Tag_Tag_oldret = ret;
1161                     size_t name_string_Tag_Tag_olen = 0;
1162                     void *name_string_Tag_Tag_tmp;
1163                     ret = 0;
1164                     (&(data)->name_string)->len = 0;
1165                     (&(data)->name_string)->val = NULL;
1166                     while (ret < name_string_Tag_Tag_origlen) {
1167                         size_t name_string_Tag_Tag_nlen = name_string_Tag_Tag_olen + sizeof(*((&(data)->name_string)->val));
1168                         if (name_string_Tag_Tag_olen > name_string_Tag_Tag_nlen) {
1169                             e = ASN1_OVERFLOW;
1170                             goto fail;
1171                         }
1172                         name_string_Tag_Tag_olen = name_string_Tag_Tag_nlen;
1173                         name_string_Tag_Tag_tmp = realloc((&(data)->name_string)->val, name_string_Tag_Tag_olen);
1174                         if (name_string_Tag_Tag_tmp == NULL) {
1175                             e = ENOMEM;
1176                             goto fail;
1177                         }
1178                         (&(data)->name_string)->val = name_string_Tag_Tag_tmp;
1179                         {
1180                             size_t name_string_Tag_Tag_s_of_datalen, name_string_Tag_Tag_s_of_oldlen;
1181                             Der_type name_string_Tag_Tag_s_of_type;
1182                             e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &name_string_Tag_Tag_s_of_type, UT_GeneralString, &name_string_Tag_Tag_s_of_datalen, &l);
1183                             if (e == 0 && name_string_Tag_Tag_s_of_type != PRIM) {
1184                                 e = ASN1_BAD_ID;
1185                             }
1186                             if (e)
1187                                 goto fail;
1188                             p += l;
1189                             len -= l;
1190                             ret += l;
1191                             name_string_Tag_Tag_s_of_oldlen = len;
1192                             if (name_string_Tag_Tag_s_of_datalen > len) {
1193                                 e = ASN1_OVERRUN;
1194                                 goto fail;
1195                             }
1196                             len = name_string_Tag_Tag_s_of_datalen;
1197                             e = der_get_general_string(p, len, &(&(data)->name_string)->val[(&(data)->name_string)->len], &l);
1198                             if (e)
1199                                 goto fail;
1200                             p += l;
1201                             len -= l;
1202                             ret += l;
1203                             len = name_string_Tag_Tag_s_of_oldlen - name_string_Tag_Tag_s_of_datalen;
1204                         }
1205                         (&(data)->name_string)->len++;
1206                         len = name_string_Tag_Tag_origlen - ret;
1207                     }
1208                     ret += name_string_Tag_Tag_oldret;
1209                 }
1210                 len = name_string_Tag_oldlen - name_string_Tag_datalen;
1211             }
1212             len = name_string_oldlen - name_string_datalen;
1213         }
1214         len = Top_oldlen - Top_datalen;
1215     }
1216     if (size)
1217         *size = ret;
1218     return 0;
1219 fail:
1220     free_PrincipalName(data);
1221     return e;
1222 }
1223
1224 void
1225 free_PrincipalName(PrincipalName * data)
1226 {
1227     free_NAME_TYPE(&(data)->name_type);
1228     while ((&(data)->name_string)->len) {
1229         der_free_general_string(&(&(data)->name_string)->val[(&(data)->name_string)->len - 1]);
1230         (&(data)->name_string)->len--;
1231     }
1232     free((&(data)->name_string)->val);
1233     (&(data)->name_string)->val = NULL;
1234 }
1235
1236 size_t
1237 length_PrincipalName(const PrincipalName * data)
1238 {
1239     size_t ret = 0;
1240     {
1241         size_t Top_tag_oldret = ret;
1242         ret = 0;
1243         ret += length_NAME_TYPE(&(data)->name_type);
1244         ret += 1 + der_length_len(ret);
1245         ret += Top_tag_oldret;
1246     }
1247     {
1248         size_t Top_tag_oldret = ret;
1249         ret = 0;
1250         {
1251             int name_string_tag_tag_oldret = ret;
1252             int i;
1253             ret = 0;
1254             for (i = (&(data)->name_string)->len - 1; i >= 0; --i) {
1255                 int name_string_tag_tag_for_oldret = ret;
1256                 ret = 0;
1257                 ret += der_length_general_string(&(&(data)->name_string)->val[i]);
1258                 ret += 1 + der_length_len(ret);
1259                 ret += name_string_tag_tag_for_oldret;
1260             }
1261             ret += name_string_tag_tag_oldret;
1262         }
1263         ret += 1 + der_length_len(ret);
1264         ret += 1 + der_length_len(ret);
1265         ret += Top_tag_oldret;
1266     }
1267     ret += 1 + der_length_len(ret);
1268     return ret;
1269 }
1270
1271 int
1272 copy_PrincipalName(const PrincipalName * from, PrincipalName * to)
1273 {
1274     memset(to, 0, sizeof(*to));
1275     if (copy_NAME_TYPE(&(from)->name_type, &(to)->name_type))
1276         goto fail;
1277     if (((&(to)->name_string)->val = malloc((&(from)->name_string)->len * sizeof(*(&(to)->name_string)->val))) == NULL && (&(from)->name_string)->len != 0)
1278         goto fail;
1279     for ((&(to)->name_string)->len = 0; (&(to)->name_string)->len < (&(from)->name_string)->len; (&(to)->name_string)->len++) {
1280         if (der_copy_general_string(&(&(from)->name_string)->val[(&(to)->name_string)->len], &(&(to)->name_string)->val[(&(to)->name_string)->len]))
1281             goto fail;
1282     }
1283     return 0;
1284 fail:
1285     free_PrincipalName(to);
1286     return ENOMEM;
1287 }
1288
1289
1290
1291 /* Generated from ./krb5.asn1 */
1292 /* Do not edit */
1293
1294 #include <stdio.h>
1295 #include <stdlib.h>
1296 #include <time.h>
1297 #include <string.h>
1298 #include <errno.h>
1299 #include <limits.h>
1300 #include <asn1_err.h>
1301
1302 int
1303 encode_HostAddresses(unsigned char *p, size_t len, const HostAddresses * data, size_t * size)
1304 {
1305     size_t ret = 0;
1306     size_t l;
1307     int i, e;
1308
1309     i = 0;
1310     for (i = (data)->len - 1; i >= 0; --i) {
1311         size_t Top_tag_for_oldret = ret;
1312         ret = 0;
1313         e = encode_HostAddress(p, len, &(data)->val[i], &l);
1314         if (e)
1315             return e;
1316         p -= l;
1317         len -= l;
1318         ret += l;
1319
1320         ret += Top_tag_for_oldret;
1321     }
1322     e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
1323     if (e)
1324         return e;
1325     p -= l;
1326     len -= l;
1327     ret += l;
1328
1329     *size = ret;
1330     return 0;
1331 }
1332
1333 int
1334 decode_HostAddresses(const unsigned char *p, size_t len, HostAddresses * data, size_t * size)
1335 {
1336     size_t ret = 0;
1337     size_t l;
1338     int e;
1339
1340     memset(data, 0, sizeof(*data));
1341     {
1342         size_t Top_datalen, Top_oldlen;
1343         Der_type Top_type;
1344         e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
1345         if (e == 0 && Top_type != CONS) {
1346             e = ASN1_BAD_ID;
1347         }
1348         if (e)
1349             goto fail;
1350         p += l;
1351         len -= l;
1352         ret += l;
1353         Top_oldlen = len;
1354         if (Top_datalen > len) {
1355             e = ASN1_OVERRUN;
1356             goto fail;
1357         }
1358         len = Top_datalen;
1359         {
1360             size_t Top_Tag_origlen = len;
1361             size_t Top_Tag_oldret = ret;
1362             size_t Top_Tag_olen = 0;
1363             void *Top_Tag_tmp;
1364             ret = 0;
1365             (data)->len = 0;
1366             (data)->val = NULL;
1367             while (ret < Top_Tag_origlen) {
1368                 size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
1369                 if (Top_Tag_olen > Top_Tag_nlen) {
1370                     e = ASN1_OVERFLOW;
1371                     goto fail;
1372                 }
1373                 Top_Tag_olen = Top_Tag_nlen;
1374                 Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
1375                 if (Top_Tag_tmp == NULL) {
1376                     e = ENOMEM;
1377                     goto fail;
1378                 }
1379                 (data)->val = Top_Tag_tmp;
1380                 e = decode_HostAddress(p, len, &(data)->val[(data)->len], &l);
1381                 if (e)
1382                     goto fail;
1383                 p += l;
1384                 len -= l;
1385                 ret += l;
1386                 (data)->len++;
1387                 len = Top_Tag_origlen - ret;
1388             }
1389             ret += Top_Tag_oldret;
1390         }
1391         len = Top_oldlen - Top_datalen;
1392     }
1393     if (size)
1394         *size = ret;
1395     return 0;
1396 fail:
1397     free_HostAddresses(data);
1398     return e;
1399 }
1400
1401 void
1402 free_HostAddresses(HostAddresses * data)
1403 {
1404     while ((data)->len) {
1405         free_HostAddress(&(data)->val[(data)->len - 1]);
1406         (data)->len--;
1407     }
1408     free((data)->val);
1409     (data)->val = NULL;
1410 }
1411
1412 size_t
1413 length_HostAddresses(const HostAddresses * data)
1414 {
1415     size_t ret = 0;
1416     {
1417         int Top_tag_oldret = ret;
1418         int i;
1419         ret = 0;
1420         for (i = (data)->len - 1; i >= 0; --i) {
1421             int Top_tag_for_oldret = ret;
1422             ret = 0;
1423             ret += length_HostAddress(&(data)->val[i]);
1424             ret += Top_tag_for_oldret;
1425         }
1426         ret += Top_tag_oldret;
1427     }
1428     ret += 1 + der_length_len(ret);
1429     return ret;
1430 }
1431
1432 int
1433 copy_HostAddresses(const HostAddresses * from, HostAddresses * to)
1434 {
1435     memset(to, 0, sizeof(*to));
1436     if (((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
1437         goto fail;
1438     for ((to)->len = 0; (to)->len < (from)->len; (to)->len++) {
1439         if (copy_HostAddress(&(from)->val[(to)->len], &(to)->val[(to)->len]))
1440             goto fail;
1441     }
1442     return 0;
1443 fail:
1444     free_HostAddresses(to);
1445     return ENOMEM;
1446 }
1447
1448
1449
1450 /* Generated from ./krb5.asn1 */
1451 /* Do not edit */
1452
1453 #include <stdio.h>
1454 #include <stdlib.h>
1455 #include <time.h>
1456 #include <string.h>
1457 #include <errno.h>
1458 #include <limits.h>
1459 #include <asn1_err.h>
1460
1461 int
1462 encode_HostAddress(unsigned char *p, size_t len, const HostAddress * data, size_t * size)
1463 {
1464     size_t ret = 0;
1465     size_t l;
1466     int i AFS_UNUSED, e;
1467
1468     i = 0;
1469 /* address */
1470     {
1471         size_t Top_tag_oldret = ret;
1472         ret = 0;
1473         e = der_put_octet_string(p, len, &(data)->address, &l);
1474         if (e)
1475             return e;
1476         p -= l;
1477         len -= l;
1478         ret += l;
1479
1480         e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
1481         if (e)
1482             return e;
1483         p -= l;
1484         len -= l;
1485         ret += l;
1486
1487         e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
1488         if (e)
1489             return e;
1490         p -= l;
1491         len -= l;
1492         ret += l;
1493
1494         ret += Top_tag_oldret;
1495     }
1496 /* addr-type */
1497     {
1498         size_t Top_tag_oldret = ret;
1499         ret = 0;
1500         e = encode_krb5int32(p, len, &(data)->addr_type, &l);
1501         if (e)
1502             return e;
1503         p -= l;
1504         len -= l;
1505         ret += l;
1506
1507         e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
1508         if (e)
1509             return e;
1510         p -= l;
1511         len -= l;
1512         ret += l;
1513
1514         ret += Top_tag_oldret;
1515     }
1516     e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
1517     if (e)
1518         return e;
1519     p -= l;
1520     len -= l;
1521     ret += l;
1522
1523     *size = ret;
1524     return 0;
1525 }
1526
1527 int
1528 decode_HostAddress(const unsigned char *p, size_t len, HostAddress * data, size_t * size)
1529 {
1530     size_t ret = 0;
1531     size_t l;
1532     int e;
1533
1534     memset(data, 0, sizeof(*data));
1535     {
1536         size_t Top_datalen, Top_oldlen;
1537         Der_type Top_type;
1538         e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
1539         if (e == 0 && Top_type != CONS) {
1540             e = ASN1_BAD_ID;
1541         }
1542         if (e)
1543             goto fail;
1544         p += l;
1545         len -= l;
1546         ret += l;
1547         Top_oldlen = len;
1548         if (Top_datalen > len) {
1549             e = ASN1_OVERRUN;
1550             goto fail;
1551         }
1552         len = Top_datalen;
1553         {
1554             size_t addr_type_datalen, addr_type_oldlen;
1555             Der_type addr_type_type;
1556             e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &addr_type_type, 0, &addr_type_datalen, &l);
1557             if (e == 0 && addr_type_type != CONS) {
1558                 e = ASN1_BAD_ID;
1559             }
1560             if (e)
1561                 goto fail;
1562             p += l;
1563             len -= l;
1564             ret += l;
1565             addr_type_oldlen = len;
1566             if (addr_type_datalen > len) {
1567                 e = ASN1_OVERRUN;
1568                 goto fail;
1569             }
1570             len = addr_type_datalen;
1571             e = decode_krb5int32(p, len, &(data)->addr_type, &l);
1572             if (e)
1573                 goto fail;
1574             p += l;
1575             len -= l;
1576             ret += l;
1577             len = addr_type_oldlen - addr_type_datalen;
1578         }
1579         {
1580             size_t address_datalen, address_oldlen;
1581             Der_type address_type;
1582             e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &address_type, 1, &address_datalen, &l);
1583             if (e == 0 && address_type != CONS) {
1584                 e = ASN1_BAD_ID;
1585             }
1586             if (e)
1587                 goto fail;
1588             p += l;
1589             len -= l;
1590             ret += l;
1591             address_oldlen = len;
1592             if (address_datalen > len) {
1593                 e = ASN1_OVERRUN;
1594                 goto fail;
1595             }
1596             len = address_datalen;
1597             {
1598                 size_t address_Tag_datalen, address_Tag_oldlen;
1599                 Der_type address_Tag_type;
1600                 e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &address_Tag_type, UT_OctetString, &address_Tag_datalen, &l);
1601                 if (e == 0 && address_Tag_type != PRIM) {
1602                     e = ASN1_BAD_ID;
1603                 }
1604                 if (e)
1605                     goto fail;
1606                 p += l;
1607                 len -= l;
1608                 ret += l;
1609                 address_Tag_oldlen = len;
1610                 if (address_Tag_datalen > len) {
1611                     e = ASN1_OVERRUN;
1612                     goto fail;
1613                 }
1614                 len = address_Tag_datalen;
1615                 e = der_get_octet_string(p, len, &(data)->address, &l);
1616                 if (e)
1617                     goto fail;
1618                 p += l;
1619                 len -= l;
1620                 ret += l;
1621                 len = address_Tag_oldlen - address_Tag_datalen;
1622             }
1623             len = address_oldlen - address_datalen;
1624         }
1625         len = Top_oldlen - Top_datalen;
1626     }
1627     if (size)
1628         *size = ret;
1629     return 0;
1630 fail:
1631     free_HostAddress(data);
1632     return e;
1633 }
1634
1635 void
1636 free_HostAddress(HostAddress * data)
1637 {
1638     free_krb5int32(&(data)->addr_type);
1639     der_free_octet_string(&(data)->address);
1640 }
1641
1642 size_t
1643 length_HostAddress(const HostAddress * data)
1644 {
1645     size_t ret = 0;
1646     {
1647         size_t Top_tag_oldret = ret;
1648         ret = 0;
1649         ret += length_krb5int32(&(data)->addr_type);
1650         ret += 1 + der_length_len(ret);
1651         ret += Top_tag_oldret;
1652     }
1653     {
1654         size_t Top_tag_oldret = ret;
1655         ret = 0;
1656         ret += der_length_octet_string(&(data)->address);
1657         ret += 1 + der_length_len(ret);
1658         ret += 1 + der_length_len(ret);
1659         ret += Top_tag_oldret;
1660     }
1661     ret += 1 + der_length_len(ret);
1662     return ret;
1663 }
1664
1665 int
1666 copy_HostAddress(const HostAddress * from, HostAddress * to)
1667 {
1668     memset(to, 0, sizeof(*to));
1669     if (copy_krb5int32(&(from)->addr_type, &(to)->addr_type))
1670         goto fail;
1671     if (der_copy_octet_string(&(from)->address, &(to)->address))
1672         goto fail;
1673     return 0;
1674 fail:
1675     free_HostAddress(to);
1676     return ENOMEM;
1677 }
1678
1679
1680
1681 /* Generated from ./krb5.asn1 */
1682 /* Do not edit */
1683
1684 #include <stdio.h>
1685 #include <stdlib.h>
1686 #include <time.h>
1687 #include <string.h>
1688 #include <errno.h>
1689 #include <limits.h>
1690 #include <asn1_err.h>
1691
1692 int
1693 encode_AuthorizationData(unsigned char *p, size_t len, const AuthorizationData * data, size_t * size)
1694 {
1695     size_t ret = 0;
1696     size_t l;
1697     int i, e;
1698
1699     i = 0;
1700     for (i = (data)->len - 1; i >= 0; --i) {
1701         size_t Top_tag_for_oldret = ret;
1702         ret = 0;
1703         e = encode_AuthorizationDataElement(p, len, &(data)->val[i], &l);
1704         if (e)
1705             return e;
1706         p -= l;
1707         len -= l;
1708         ret += l;
1709
1710         ret += Top_tag_for_oldret;
1711     }
1712     e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
1713     if (e)
1714         return e;
1715     p -= l;
1716     len -= l;
1717     ret += l;
1718
1719     *size = ret;
1720     return 0;
1721 }
1722
1723 int
1724 decode_AuthorizationData(const unsigned char *p, size_t len, AuthorizationData * data, size_t * size)
1725 {
1726     size_t ret = 0;
1727     size_t l;
1728     int e;
1729
1730     memset(data, 0, sizeof(*data));
1731     {
1732         size_t Top_datalen, Top_oldlen;
1733         Der_type Top_type;
1734         e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
1735         if (e == 0 && Top_type != CONS) {
1736             e = ASN1_BAD_ID;
1737         }
1738         if (e)
1739             goto fail;
1740         p += l;
1741         len -= l;
1742         ret += l;
1743         Top_oldlen = len;
1744         if (Top_datalen > len) {
1745             e = ASN1_OVERRUN;
1746             goto fail;
1747         }
1748         len = Top_datalen;
1749         {
1750             size_t Top_Tag_origlen = len;
1751             size_t Top_Tag_oldret = ret;
1752             size_t Top_Tag_olen = 0;
1753             void *Top_Tag_tmp;
1754             ret = 0;
1755             (data)->len = 0;
1756             (data)->val = NULL;
1757             while (ret < Top_Tag_origlen) {
1758                 size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
1759                 if (Top_Tag_olen > Top_Tag_nlen) {
1760                     e = ASN1_OVERFLOW;
1761                     goto fail;
1762                 }
1763                 Top_Tag_olen = Top_Tag_nlen;
1764                 Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
1765                 if (Top_Tag_tmp == NULL) {
1766                     e = ENOMEM;
1767                     goto fail;
1768                 }
1769                 (data)->val = Top_Tag_tmp;
1770                 e = decode_AuthorizationDataElement(p, len, &(data)->val[(data)->len], &l);
1771                 if (e)
1772                     goto fail;
1773                 p += l;
1774                 len -= l;
1775                 ret += l;
1776                 (data)->len++;
1777                 len = Top_Tag_origlen - ret;
1778             }
1779             ret += Top_Tag_oldret;
1780         }
1781         len = Top_oldlen - Top_datalen;
1782     }
1783     if (size)
1784         *size = ret;
1785     return 0;
1786 fail:
1787     free_AuthorizationData(data);
1788     return e;
1789 }
1790
1791 void
1792 free_AuthorizationData(AuthorizationData * data)
1793 {
1794     while ((data)->len) {
1795         free_AuthorizationDataElement(&(data)->val[(data)->len - 1]);
1796         (data)->len--;
1797     }
1798     free((data)->val);
1799     (data)->val = NULL;
1800 }
1801
1802 size_t
1803 length_AuthorizationData(const AuthorizationData * data)
1804 {
1805     size_t ret = 0;
1806     {
1807         int Top_tag_oldret = ret;
1808         int i;
1809         ret = 0;
1810         for (i = (data)->len - 1; i >= 0; --i) {
1811             int Top_tag_for_oldret = ret;
1812             ret = 0;
1813             ret += length_AuthorizationDataElement(&(data)->val[i]);
1814             ret += Top_tag_for_oldret;
1815         }
1816         ret += Top_tag_oldret;
1817     }
1818     ret += 1 + der_length_len(ret);
1819     return ret;
1820 }
1821
1822 int
1823 copy_AuthorizationData(const AuthorizationData * from, AuthorizationData * to)
1824 {
1825     memset(to, 0, sizeof(*to));
1826     if (((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
1827         goto fail;
1828     for ((to)->len = 0; (to)->len < (from)->len; (to)->len++) {
1829         if (copy_AuthorizationDataElement(&(from)->val[(to)->len], &(to)->val[(to)->len]))
1830             goto fail;
1831     }
1832     return 0;
1833 fail:
1834     free_AuthorizationData(to);
1835     return ENOMEM;
1836 }
1837
1838 int
1839 add_AuthorizationData(AuthorizationData * data, const AuthorizationDataElement * element)
1840 {
1841     int ret;
1842     void *ptr;
1843
1844     ptr = realloc(data->val,
1845                   (data->len + 1) * sizeof(data->val[0]));
1846     if (ptr == NULL)
1847         return ENOMEM;
1848     data->val = ptr;
1849
1850     ret = copy_AuthorizationDataElement(element, &data->val[data->len]);
1851     if (ret)
1852         return ret;
1853     data->len++;
1854     return 0;
1855 }
1856
1857 int
1858 remove_AuthorizationData(AuthorizationData * data, unsigned int element)
1859 {
1860     void *ptr;
1861
1862     if (data->len == 0 || element >= data->len)
1863         return ASN1_OVERRUN;
1864     free_AuthorizationDataElement(&data->val[element]);
1865     data->len--;
1866     if (element < data->len)
1867         memmove(&data->val[element], &data->val[element + 1],
1868                 sizeof(data->val[0]) * data->len);
1869     ptr = realloc(data->val, data->len * sizeof(data->val[0]));
1870     if (ptr != NULL || data->len == 0)
1871         data->val = ptr;
1872     return 0;
1873 }
1874
1875
1876
1877 /* Generated from ./krb5.asn1 */
1878 /* Do not edit */
1879
1880 #include <stdio.h>
1881 #include <stdlib.h>
1882 #include <time.h>
1883 #include <string.h>
1884 #include <errno.h>
1885 #include <limits.h>
1886 #include <asn1_err.h>
1887
1888 int
1889 encode_EncTicketPart(unsigned char *p, size_t len, const EncTicketPart * data, size_t * size)
1890 {
1891     size_t ret = 0;
1892     size_t l;
1893     int i AFS_UNUSED, e;
1894
1895     i = 0;
1896 /* authorization-data */
1897     if ((data)->authorization_data) {
1898         size_t Top_tag_tag_oldret = ret;
1899         ret = 0;
1900         e = encode_AuthorizationData(p, len, (data)->authorization_data, &l);
1901         if (e)
1902             return e;
1903         p -= l;
1904         len -= l;
1905         ret += l;
1906
1907         e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 10, &l);
1908         if (e)
1909             return e;
1910         p -= l;
1911         len -= l;
1912         ret += l;
1913
1914         ret += Top_tag_tag_oldret;
1915     }
1916 /* caddr */
1917     if ((data)->caddr) {
1918         size_t Top_tag_tag_oldret = ret;
1919         ret = 0;
1920         e = encode_HostAddresses(p, len, (data)->caddr, &l);
1921         if (e)
1922             return e;
1923         p -= l;
1924         len -= l;
1925         ret += l;
1926
1927         e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 9, &l);
1928         if (e)
1929             return e;
1930         p -= l;
1931         len -= l;
1932         ret += l;
1933
1934         ret += Top_tag_tag_oldret;
1935     }
1936 /* renew-till */
1937     if ((data)->renew_till) {
1938         size_t Top_tag_tag_oldret = ret;
1939         ret = 0;
1940         e = encode_KerberosTime(p, len, (data)->renew_till, &l);
1941         if (e)
1942             return e;
1943         p -= l;
1944         len -= l;
1945         ret += l;
1946
1947         e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 8, &l);
1948         if (e)
1949             return e;
1950         p -= l;
1951         len -= l;
1952         ret += l;
1953
1954         ret += Top_tag_tag_oldret;
1955     }
1956 /* endtime */
1957     {
1958         size_t Top_tag_tag_oldret = ret;
1959         ret = 0;
1960         e = encode_KerberosTime(p, len, &(data)->endtime, &l);
1961         if (e)
1962             return e;
1963         p -= l;
1964         len -= l;
1965         ret += l;
1966
1967         e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 7, &l);
1968         if (e)
1969             return e;
1970         p -= l;
1971         len -= l;
1972         ret += l;
1973
1974         ret += Top_tag_tag_oldret;
1975     }
1976 /* starttime */
1977     if ((data)->starttime) {
1978         size_t Top_tag_tag_oldret = ret;
1979         ret = 0;
1980         e = encode_KerberosTime(p, len, (data)->starttime, &l);
1981         if (e)
1982             return e;
1983         p -= l;
1984         len -= l;
1985         ret += l;
1986
1987         e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 6, &l);
1988         if (e)
1989             return e;
1990         p -= l;
1991         len -= l;
1992         ret += l;
1993
1994         ret += Top_tag_tag_oldret;
1995     }
1996 /* authtime */
1997     {
1998         size_t Top_tag_tag_oldret = ret;
1999         ret = 0;
2000         e = encode_KerberosTime(p, len, &(data)->authtime, &l);
2001         if (e)
2002             return e;
2003         p -= l;
2004         len -= l;
2005         ret += l;
2006
2007         e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 5, &l);
2008         if (e)
2009             return e;
2010         p -= l;
2011         len -= l;
2012         ret += l;
2013
2014         ret += Top_tag_tag_oldret;
2015     }
2016 /* transited */
2017     {
2018         size_t Top_tag_tag_oldret = ret;
2019         ret = 0;
2020         e = encode_TransitedEncoding(p, len, &(data)->transited, &l);
2021         if (e)
2022             return e;
2023         p -= l;
2024         len -= l;
2025         ret += l;
2026
2027         e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 4, &l);
2028         if (e)
2029             return e;
2030         p -= l;
2031         len -= l;
2032         ret += l;
2033
2034         ret += Top_tag_tag_oldret;
2035     }
2036 /* cname */
2037     {
2038         size_t Top_tag_tag_oldret = ret;
2039         ret = 0;
2040         e = encode_PrincipalName(p, len, &(data)->cname, &l);
2041         if (e)
2042             return e;
2043         p -= l;
2044         len -= l;
2045         ret += l;
2046
2047         e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
2048         if (e)
2049             return e;
2050         p -= l;
2051         len -= l;
2052         ret += l;
2053
2054         ret += Top_tag_tag_oldret;
2055     }
2056 /* crealm */
2057     {
2058         size_t Top_tag_tag_oldret = ret;
2059         ret = 0;
2060         e = encode_Realm(p, len, &(data)->crealm, &l);
2061         if (e)
2062             return e;
2063         p -= l;
2064         len -= l;
2065         ret += l;
2066
2067         e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
2068         if (e)
2069             return e;
2070         p -= l;
2071         len -= l;
2072         ret += l;
2073
2074         ret += Top_tag_tag_oldret;
2075     }
2076 /* key */
2077     {
2078         size_t Top_tag_tag_oldret = ret;
2079         ret = 0;
2080         e = encode_EncryptionKey(p, len, &(data)->key, &l);
2081         if (e)
2082             return e;
2083         p -= l;
2084         len -= l;
2085         ret += l;
2086
2087         e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
2088         if (e)
2089             return e;
2090         p -= l;
2091         len -= l;
2092         ret += l;
2093
2094         ret += Top_tag_tag_oldret;
2095     }
2096 /* flags */
2097     {
2098         size_t Top_tag_tag_oldret = ret;
2099         ret = 0;
2100         e = encode_TicketFlags(p, len, &(data)->flags, &l);
2101         if (e)
2102             return e;
2103         p -= l;
2104         len -= l;
2105         ret += l;
2106
2107         e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
2108         if (e)
2109             return e;
2110         p -= l;
2111         len -= l;
2112         ret += l;
2113
2114         ret += Top_tag_tag_oldret;
2115     }
2116     e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
2117     if (e)
2118         return e;
2119     p -= l;
2120     len -= l;
2121     ret += l;
2122
2123     e = der_put_length_and_tag(p, len, ret, ASN1_C_APPL, CONS, 3, &l);
2124     if (e)
2125         return e;
2126     p -= l;
2127     len -= l;
2128     ret += l;
2129
2130     *size = ret;
2131     return 0;
2132 }
2133
2134 int
2135 decode_EncTicketPart(const unsigned char *p, size_t len, EncTicketPart * data, size_t * size)
2136 {
2137     size_t ret = 0;
2138     size_t l;
2139     int e;
2140
2141     memset(data, 0, sizeof(*data));
2142     {
2143         size_t Top_datalen, Top_oldlen;
2144         Der_type Top_type;
2145         e = der_match_tag_and_length(p, len, ASN1_C_APPL, &Top_type, 3, &Top_datalen, &l);
2146         if (e == 0 && Top_type != CONS) {
2147             e = ASN1_BAD_ID;
2148         }
2149         if (e)
2150             goto fail;
2151         p += l;
2152         len -= l;
2153         ret += l;
2154         Top_oldlen = len;
2155         if (Top_datalen > len) {
2156             e = ASN1_OVERRUN;
2157             goto fail;
2158         }
2159         len = Top_datalen;
2160         {
2161             size_t Top_Tag_datalen, Top_Tag_oldlen;
2162             Der_type Top_Tag_type;
2163             e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_Tag_type, UT_Sequence, &Top_Tag_datalen, &l);
2164             if (e == 0 && Top_Tag_type != CONS) {
2165                 e = ASN1_BAD_ID;
2166             }
2167             if (e)
2168                 goto fail;
2169             p += l;
2170             len -= l;
2171             ret += l;
2172             Top_Tag_oldlen = len;
2173             if (Top_Tag_datalen > len) {
2174                 e = ASN1_OVERRUN;
2175                 goto fail;
2176             }
2177             len = Top_Tag_datalen;
2178             {
2179                 size_t flags_datalen, flags_oldlen;
2180                 Der_type flags_type;
2181                 e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &flags_type, 0, &flags_datalen, &l);
2182                 if (e == 0 && flags_type != CONS) {
2183                     e = ASN1_BAD_ID;
2184                 }
2185                 if (e)
2186                     goto fail;
2187                 p += l;
2188                 len -= l;
2189                 ret += l;
2190                 flags_oldlen = len;
2191                 if (flags_datalen > len) {
2192                     e = ASN1_OVERRUN;
2193                     goto fail;
2194                 }
2195                 len = flags_datalen;
2196                 e = decode_TicketFlags(p, len, &(data)->flags, &l);
2197                 if (e)
2198                     goto fail;
2199                 p += l;
2200                 len -= l;
2201                 ret += l;
2202                 len = flags_oldlen - flags_datalen;
2203             }
2204             {
2205                 size_t key_datalen, key_oldlen;
2206                 Der_type key_type;
2207                 e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &key_type, 1, &key_datalen, &l);
2208                 if (e == 0 && key_type != CONS) {
2209                     e = ASN1_BAD_ID;
2210                 }
2211                 if (e)
2212                     goto fail;
2213                 p += l;
2214                 len -= l;
2215                 ret += l;
2216                 key_oldlen = len;
2217                 if (key_datalen > len) {
2218                     e = ASN1_OVERRUN;
2219                     goto fail;
2220                 }
2221                 len = key_datalen;
2222                 e = decode_EncryptionKey(p, len, &(data)->key, &l);
2223                 if (e)
2224                     goto fail;
2225                 p += l;
2226                 len -= l;
2227                 ret += l;
2228                 len = key_oldlen - key_datalen;
2229             }
2230             {
2231                 size_t crealm_datalen, crealm_oldlen;
2232                 Der_type crealm_type;
2233                 e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &crealm_type, 2, &crealm_datalen, &l);
2234                 if (e == 0 && crealm_type != CONS) {
2235                     e = ASN1_BAD_ID;
2236                 }
2237                 if (e)
2238                     goto fail;
2239                 p += l;
2240                 len -= l;
2241                 ret += l;
2242                 crealm_oldlen = len;
2243                 if (crealm_datalen > len) {
2244                     e = ASN1_OVERRUN;
2245                     goto fail;
2246                 }
2247                 len = crealm_datalen;
2248                 e = decode_Realm(p, len, &(data)->crealm, &l);
2249                 if (e)
2250                     goto fail;
2251                 p += l;
2252                 len -= l;
2253                 ret += l;
2254                 len = crealm_oldlen - crealm_datalen;
2255             }
2256             {
2257                 size_t cname_datalen, cname_oldlen;
2258                 Der_type cname_type;
2259                 e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &cname_type, 3, &cname_datalen, &l);
2260                 if (e == 0 && cname_type != CONS) {
2261                     e = ASN1_BAD_ID;
2262                 }
2263                 if (e)
2264                     goto fail;
2265                 p += l;
2266                 len -= l;
2267                 ret += l;
2268                 cname_oldlen = len;
2269                 if (cname_datalen > len) {
2270                     e = ASN1_OVERRUN;
2271                     goto fail;
2272                 }
2273                 len = cname_datalen;
2274                 e = decode_PrincipalName(p, len, &(data)->cname, &l);
2275                 if (e)
2276                     goto fail;
2277                 p += l;
2278                 len -= l;
2279                 ret += l;
2280                 len = cname_oldlen - cname_datalen;
2281             }
2282             {
2283                 size_t transited_datalen, transited_oldlen;
2284                 Der_type transited_type;
2285                 e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &transited_type, 4, &transited_datalen, &l);
2286                 if (e == 0 && transited_type != CONS) {
2287                     e = ASN1_BAD_ID;
2288                 }
2289                 if (e)
2290                     goto fail;
2291                 p += l;
2292                 len -= l;
2293                 ret += l;
2294                 transited_oldlen = len;
2295                 if (transited_datalen > len) {
2296                     e = ASN1_OVERRUN;
2297                     goto fail;
2298                 }
2299                 len = transited_datalen;
2300                 e = decode_TransitedEncoding(p, len, &(data)->transited, &l);
2301                 if (e)
2302                     goto fail;
2303                 p += l;
2304                 len -= l;
2305                 ret += l;
2306                 len = transited_oldlen - transited_datalen;
2307             }
2308             {
2309                 size_t authtime_datalen, authtime_oldlen;
2310                 Der_type authtime_type;
2311                 e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &authtime_type, 5, &authtime_datalen, &l);
2312                 if (e == 0 && authtime_type != CONS) {
2313                     e = ASN1_BAD_ID;
2314                 }
2315                 if (e)
2316                     goto fail;
2317                 p += l;
2318                 len -= l;
2319                 ret += l;
2320                 authtime_oldlen = len;
2321                 if (authtime_datalen > len) {
2322                     e = ASN1_OVERRUN;
2323                     goto fail;
2324                 }
2325                 len = authtime_datalen;
2326                 e = decode_KerberosTime(p, len, &(data)->authtime, &l);
2327                 if (e)
2328                     goto fail;
2329                 p += l;
2330                 len -= l;
2331                 ret += l;
2332                 len = authtime_oldlen - authtime_datalen;
2333             }
2334             {
2335                 size_t starttime_datalen, starttime_oldlen;
2336                 Der_type starttime_type;
2337                 e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &starttime_type, 6, &starttime_datalen, &l);
2338                 if (e == 0 && starttime_type != CONS) {
2339                     e = ASN1_BAD_ID;
2340                 }
2341                 if (e) {
2342                     (data)->starttime = NULL;
2343                 } else {
2344                     (data)->starttime = calloc(1, sizeof(*(data)->starttime));
2345                     if ((data)->starttime == NULL) {
2346                         e = ENOMEM;
2347                         goto fail;
2348                     }
2349                     p += l;
2350                     len -= l;
2351                     ret += l;
2352                     starttime_oldlen = len;
2353                     if (starttime_datalen > len) {
2354                         e = ASN1_OVERRUN;
2355                         goto fail;
2356                     }
2357                     len = starttime_datalen;
2358                     e = decode_KerberosTime(p, len, (data)->starttime, &l);
2359                     if (e)
2360                         goto fail;
2361                     p += l;
2362                     len -= l;
2363                     ret += l;
2364                     len = starttime_oldlen - starttime_datalen;
2365                 }
2366             }
2367             {
2368                 size_t endtime_datalen, endtime_oldlen;
2369                 Der_type endtime_type;
2370                 e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &endtime_type, 7, &endtime_datalen, &l);
2371                 if (e == 0 && endtime_type != CONS) {
2372                     e = ASN1_BAD_ID;
2373                 }
2374                 if (e)
2375                     goto fail;
2376                 p += l;
2377                 len -= l;
2378                 ret += l;
2379                 endtime_oldlen = len;
2380                 if (endtime_datalen > len) {
2381                     e = ASN1_OVERRUN;
2382                     goto fail;
2383                 }
2384                 len = endtime_datalen;
2385                 e = decode_KerberosTime(p, len, &(data)->endtime, &l);
2386                 if (e)
2387                     goto fail;
2388                 p += l;
2389                 len -= l;
2390                 ret += l;
2391                 len = endtime_oldlen - endtime_datalen;
2392             }
2393             {
2394                 size_t renew_till_datalen, renew_till_oldlen;
2395                 Der_type renew_till_type;
2396                 e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &renew_till_type, 8, &renew_till_datalen, &l);
2397                 if (e == 0 && renew_till_type != CONS) {
2398                     e = ASN1_BAD_ID;
2399                 }
2400                 if (e) {
2401                     (data)->renew_till = NULL;
2402                 } else {
2403                     (data)->renew_till = calloc(1, sizeof(*(data)->renew_till));
2404                     if ((data)->renew_till == NULL) {
2405                         e = ENOMEM;
2406                         goto fail;
2407                     }
2408                     p += l;
2409                     len -= l;
2410                     ret += l;
2411                     renew_till_oldlen = len;
2412                     if (renew_till_datalen > len) {
2413                         e = ASN1_OVERRUN;
2414                         goto fail;
2415                     }
2416                     len = renew_till_datalen;
2417                     e = decode_KerberosTime(p, len, (data)->renew_till, &l);
2418                     if (e)
2419                         goto fail;
2420                     p += l;
2421                     len -= l;
2422                     ret += l;
2423                     len = renew_till_oldlen - renew_till_datalen;
2424                 }
2425             }
2426             {
2427                 size_t caddr_datalen, caddr_oldlen;
2428                 Der_type caddr_type;
2429                 e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &caddr_type, 9, &caddr_datalen, &l);
2430                 if (e == 0 && caddr_type != CONS) {
2431                     e = ASN1_BAD_ID;
2432                 }
2433                 if (e) {
2434                     (data)->caddr = NULL;
2435                 } else {
2436                     (data)->caddr = calloc(1, sizeof(*(data)->caddr));
2437                     if ((data)->caddr == NULL) {
2438                         e = ENOMEM;
2439                         goto fail;
2440                     }
2441                     p += l;
2442                     len -= l;
2443                     ret += l;
2444                     caddr_oldlen = len;
2445                     if (caddr_datalen > len) {
2446                         e = ASN1_OVERRUN;
2447                         goto fail;
2448                     }
2449                     len = caddr_datalen;
2450                     e = decode_HostAddresses(p, len, (data)->caddr, &l);
2451                     if (e)
2452                         goto fail;
2453                     p += l;
2454                     len -= l;
2455                     ret += l;
2456                     len = caddr_oldlen - caddr_datalen;
2457                 }
2458             }
2459             {
2460                 size_t authorization_data_datalen, authorization_data_oldlen;
2461                 Der_type authorization_data_type;
2462                 e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &authorization_data_type, 10, &authorization_data_datalen, &l);
2463                 if (e == 0 && authorization_data_type != CONS) {
2464                     e = ASN1_BAD_ID;
2465                 }
2466                 if (e) {
2467                     (data)->authorization_data = NULL;
2468                 } else {
2469                     (data)->authorization_data = calloc(1, sizeof(*(data)->authorization_data));
2470                     if ((data)->authorization_data == NULL) {
2471                         e = ENOMEM;
2472                         goto fail;
2473                     }
2474                     p += l;
2475                     len -= l;
2476                     ret += l;
2477                     authorization_data_oldlen = len;
2478                     if (authorization_data_datalen > len) {
2479                         e = ASN1_OVERRUN;
2480                         goto fail;
2481                     }
2482                     len = authorization_data_datalen;
2483                     e = decode_AuthorizationData(p, len, (data)->authorization_data, &l);
2484                     if (e)
2485                         goto fail;
2486                     p += l;
2487                     len -= l;
2488                     ret += l;
2489                     len = authorization_data_oldlen - authorization_data_datalen;
2490                 }
2491             }
2492             len = Top_Tag_oldlen - Top_Tag_datalen;
2493         }
2494         len = Top_oldlen - Top_datalen;
2495     }
2496     if (size)
2497         *size = ret;
2498     return 0;
2499 fail:
2500     free_EncTicketPart(data);
2501     return e;
2502 }
2503
2504 void
2505 free_EncTicketPart(EncTicketPart * data)
2506 {
2507     free_TicketFlags(&(data)->flags);
2508     free_EncryptionKey(&(data)->key);
2509     free_Realm(&(data)->crealm);
2510     free_PrincipalName(&(data)->cname);
2511     free_TransitedEncoding(&(data)->transited);
2512     free_KerberosTime(&(data)->authtime);
2513     if ((data)->starttime) {
2514         free_KerberosTime((data)->starttime);
2515         free((data)->starttime);
2516         (data)->starttime = NULL;
2517     }
2518     free_KerberosTime(&(data)->endtime);
2519     if ((data)->renew_till) {
2520         free_KerberosTime((data)->renew_till);
2521         free((data)->renew_till);
2522         (data)->renew_till = NULL;
2523     }
2524     if ((data)->caddr) {
2525         free_HostAddresses((data)->caddr);
2526         free((data)->caddr);
2527         (data)->caddr = NULL;
2528     }
2529     if ((data)->authorization_data) {
2530         free_AuthorizationData((data)->authorization_data);
2531         free((data)->authorization_data);
2532         (data)->authorization_data = NULL;
2533     }
2534 }
2535
2536 size_t
2537 length_EncTicketPart(const EncTicketPart * data)
2538 {
2539     size_t ret = 0;
2540     {
2541         size_t Top_tag_tag_oldret = ret;
2542         ret = 0;
2543         ret += length_TicketFlags(&(data)->flags);
2544         ret += 1 + der_length_len(ret);
2545         ret += Top_tag_tag_oldret;
2546     }
2547     {
2548         size_t Top_tag_tag_oldret = ret;
2549         ret = 0;
2550         ret += length_EncryptionKey(&(data)->key);
2551         ret += 1 + der_length_len(ret);
2552         ret += Top_tag_tag_oldret;
2553     }
2554     {
2555         size_t Top_tag_tag_oldret = ret;
2556         ret = 0;
2557         ret += length_Realm(&(data)->crealm);
2558         ret += 1 + der_length_len(ret);
2559         ret += Top_tag_tag_oldret;
2560     }
2561     {
2562         size_t Top_tag_tag_oldret = ret;
2563         ret = 0;
2564         ret += length_PrincipalName(&(data)->cname);
2565         ret += 1 + der_length_len(ret);
2566         ret += Top_tag_tag_oldret;
2567     }
2568     {
2569         size_t Top_tag_tag_oldret = ret;
2570         ret = 0;
2571         ret += length_TransitedEncoding(&(data)->transited);
2572         ret += 1 + der_length_len(ret);
2573         ret += Top_tag_tag_oldret;
2574     }
2575     {
2576         size_t Top_tag_tag_oldret = ret;
2577         ret = 0;
2578         ret += length_KerberosTime(&(data)->authtime);
2579         ret += 1 + der_length_len(ret);
2580         ret += Top_tag_tag_oldret;
2581     }
2582     if ((data)->starttime) {
2583         size_t Top_tag_tag_oldret = ret;
2584         ret = 0;
2585         ret += length_KerberosTime((data)->starttime);
2586         ret += 1 + der_length_len(ret);
2587         ret += Top_tag_tag_oldret;
2588     } {
2589         size_t Top_tag_tag_oldret = ret;
2590         ret = 0;
2591         ret += length_KerberosTime(&(data)->endtime);
2592         ret += 1 + der_length_len(ret);
2593         ret += Top_tag_tag_oldret;
2594     }
2595     if ((data)->renew_till) {
2596         size_t Top_tag_tag_oldret = ret;
2597         ret = 0;
2598         ret += length_KerberosTime((data)->renew_till);
2599         ret += 1 + der_length_len(ret);
2600         ret += Top_tag_tag_oldret;
2601     }
2602     if ((data)->caddr) {
2603         size_t Top_tag_tag_oldret = ret;
2604         ret = 0;
2605         ret += length_HostAddresses((data)->caddr);
2606         ret += 1 + der_length_len(ret);
2607         ret += Top_tag_tag_oldret;
2608     }
2609     if ((data)->authorization_data) {
2610         size_t Top_tag_tag_oldret = ret;
2611         ret = 0;
2612         ret += length_AuthorizationData((data)->authorization_data);
2613         ret += 1 + der_length_len(ret);
2614         ret += Top_tag_tag_oldret;
2615     }
2616     ret += 1 + der_length_len(ret);
2617     ret += 1 + der_length_len(ret);
2618     return ret;
2619 }
2620
2621 int
2622 copy_EncTicketPart(const EncTicketPart * from, EncTicketPart * to)
2623 {
2624     memset(to, 0, sizeof(*to));
2625     if (copy_TicketFlags(&(from)->flags, &(to)->flags))
2626         goto fail;
2627     if (copy_EncryptionKey(&(from)->key, &(to)->key))
2628         goto fail;
2629     if (copy_Realm(&(from)->crealm, &(to)->crealm))
2630         goto fail;
2631     if (copy_PrincipalName(&(from)->cname, &(to)->cname))
2632         goto fail;
2633     if (copy_TransitedEncoding(&(from)->transited, &(to)->transited))
2634         goto fail;
2635     if (copy_KerberosTime(&(from)->authtime, &(to)->authtime))
2636         goto fail;
2637     if ((from)->starttime) {
2638         (to)->starttime = malloc(sizeof(*(to)->starttime));
2639         if ((to)->starttime == NULL)
2640             goto fail;
2641         if (copy_KerberosTime((from)->starttime, (to)->starttime))
2642             goto fail;
2643     } else
2644         (to)->starttime = NULL;
2645     if (copy_KerberosTime(&(from)->endtime, &(to)->endtime))
2646         goto fail;
2647     if ((from)->renew_till) {
2648         (to)->renew_till = malloc(sizeof(*(to)->renew_till));
2649         if ((to)->renew_till == NULL)
2650             goto fail;
2651         if (copy_KerberosTime((from)->renew_till, (to)->renew_till))
2652             goto fail;
2653     } else
2654         (to)->renew_till = NULL;
2655     if ((from)->caddr) {
2656         (to)->caddr = malloc(sizeof(*(to)->caddr));
2657         if ((to)->caddr == NULL)
2658             goto fail;
2659         if (copy_HostAddresses((from)->caddr, (to)->caddr))
2660             goto fail;
2661     } else
2662         (to)->caddr = NULL;
2663     if ((from)->authorization_data) {
2664         (to)->authorization_data = malloc(sizeof(*(to)->authorization_data));
2665         if ((to)->authorization_data == NULL)
2666             goto fail;
2667         if (copy_AuthorizationData((from)->authorization_data, (to)->authorization_data))
2668             goto fail;
2669     } else
2670         (to)->authorization_data = NULL;
2671     return 0;
2672 fail:
2673     free_EncTicketPart(to);
2674     return ENOMEM;
2675 }
2676
2677
2678
2679 /* Generated from ./krb5.asn1 */
2680 /* Do not edit */
2681
2682 #include <stdio.h>
2683 #include <stdlib.h>
2684 #include <time.h>
2685 #include <string.h>
2686 #include <errno.h>
2687 #include <limits.h>
2688 #include <asn1_err.h>
2689
2690 int
2691 encode_KerberosTime(unsigned char *p, size_t len, const KerberosTime * data, size_t * size)
2692 {
2693     size_t ret = 0;
2694     size_t l;
2695     int i AFS_UNUSED, e;
2696
2697     i = 0;
2698     e = der_put_generalized_time(p, len, data, &l);
2699     if (e)
2700         return e;
2701     p -= l;
2702     len -= l;
2703     ret += l;
2704
2705     e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, PRIM, UT_GeneralizedTime, &l);
2706     if (e)
2707         return e;
2708     p -= l;
2709     len -= l;
2710     ret += l;
2711
2712     *size = ret;
2713     return 0;
2714 }
2715
2716 int
2717 decode_KerberosTime(const unsigned char *p, size_t len, KerberosTime * data, size_t * size)
2718 {
2719     size_t ret = 0;
2720     size_t l;
2721     int e;
2722
2723     memset(data, 0, sizeof(*data));
2724     {
2725         size_t Top_datalen, Top_oldlen;
2726         Der_type Top_type;
2727         e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_GeneralizedTime, &Top_datalen, &l);
2728         if (e == 0 && Top_type != PRIM) {
2729             e = ASN1_BAD_ID;
2730         }
2731         if (e)
2732             goto fail;
2733         p += l;
2734         len -= l;
2735         ret += l;
2736         Top_oldlen = len;
2737         if (Top_datalen > len) {
2738             e = ASN1_OVERRUN;
2739             goto fail;
2740         }
2741         len = Top_datalen;
2742         e = der_get_generalized_time(p, len, data, &l);
2743         if (e)
2744             goto fail;
2745         p += l;
2746         len -= l;
2747         ret += l;
2748         len = Top_oldlen - Top_datalen;
2749     }
2750     if (size)
2751         *size = ret;
2752     return 0;
2753 fail:
2754     free_KerberosTime(data);
2755     return e;
2756 }
2757
2758 void
2759 free_KerberosTime(KerberosTime * data)
2760 {
2761 }
2762
2763 size_t
2764 length_KerberosTime(const KerberosTime * data)
2765 {
2766     size_t ret = 0;
2767     ret += der_length_generalized_time(data);
2768     ret += 1 + der_length_len(ret);
2769     return ret;
2770 }
2771
2772 int
2773 copy_KerberosTime(const KerberosTime * from, KerberosTime * to)
2774 {
2775     memset(to, 0, sizeof(*to));
2776     *(to) = *(from);
2777     return 0;
2778 }
2779
2780
2781
2782 /* Generated from ./krb5.asn1 */
2783 /* Do not edit */
2784
2785 #include <stdio.h>
2786 #include <stdlib.h>
2787 #include <time.h>
2788 #include <string.h>
2789 #include <errno.h>
2790 #include <limits.h>
2791 #include <asn1_err.h>
2792
2793 int
2794 encode_TransitedEncoding(unsigned char *p, size_t len, const TransitedEncoding * data, size_t * size)
2795 {
2796     size_t ret = 0;
2797     size_t l;
2798     int i AFS_UNUSED, e;
2799
2800     i = 0;
2801 /* contents */
2802     {
2803         size_t Top_tag_oldret = ret;
2804         ret = 0;
2805         e = der_put_octet_string(p, len, &(data)->contents, &l);
2806         if (e)
2807             return e;
2808         p -= l;
2809         len -= l;
2810         ret += l;
2811
2812         e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
2813         if (e)
2814             return e;
2815         p -= l;
2816         len -= l;
2817         ret += l;
2818
2819         e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
2820         if (e)
2821             return e;
2822         p -= l;
2823         len -= l;
2824         ret += l;
2825
2826         ret += Top_tag_oldret;
2827     }
2828 /* tr-type */
2829     {
2830         size_t Top_tag_oldret = ret;
2831         ret = 0;
2832         e = encode_krb5int32(p, len, &(data)->tr_type, &l);
2833         if (e)
2834             return e;
2835         p -= l;
2836         len -= l;
2837         ret += l;
2838
2839         e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
2840         if (e)
2841             return e;
2842         p -= l;
2843         len -= l;
2844         ret += l;
2845
2846         ret += Top_tag_oldret;
2847     }
2848     e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
2849     if (e)
2850         return e;
2851     p -= l;
2852     len -= l;
2853     ret += l;
2854
2855     *size = ret;
2856     return 0;
2857 }
2858
2859 int
2860 decode_TransitedEncoding(const unsigned char *p, size_t len, TransitedEncoding * data, size_t * size)
2861 {
2862     size_t ret = 0;
2863     size_t l;
2864     int e;
2865
2866     memset(data, 0, sizeof(*data));
2867     {
2868         size_t Top_datalen, Top_oldlen;
2869         Der_type Top_type;
2870         e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
2871         if (e == 0 && Top_type != CONS) {
2872             e = ASN1_BAD_ID;
2873         }
2874         if (e)
2875             goto fail;
2876         p += l;
2877         len -= l;
2878         ret += l;
2879         Top_oldlen = len;
2880         if (Top_datalen > len) {
2881             e = ASN1_OVERRUN;
2882             goto fail;
2883         }
2884         len = Top_datalen;
2885         {
2886             size_t tr_type_datalen, tr_type_oldlen;
2887             Der_type tr_type_type;
2888             e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &tr_type_type, 0, &tr_type_datalen, &l);
2889             if (e == 0 && tr_type_type != CONS) {
2890                 e = ASN1_BAD_ID;
2891             }
2892             if (e)
2893                 goto fail;
2894             p += l;
2895             len -= l;
2896             ret += l;
2897             tr_type_oldlen = len;
2898             if (tr_type_datalen > len) {
2899                 e = ASN1_OVERRUN;
2900                 goto fail;
2901             }
2902             len = tr_type_datalen;
2903             e = decode_krb5int32(p, len, &(data)->tr_type, &l);
2904             if (e)
2905                 goto fail;
2906             p += l;
2907             len -= l;
2908             ret += l;
2909             len = tr_type_oldlen - tr_type_datalen;
2910         }
2911         {
2912             size_t contents_datalen, contents_oldlen;
2913             Der_type contents_type;
2914             e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &contents_type, 1, &contents_datalen, &l);
2915             if (e == 0 && contents_type != CONS) {
2916                 e = ASN1_BAD_ID;
2917             }
2918             if (e)
2919                 goto fail;
2920             p += l;
2921             len -= l;
2922             ret += l;
2923             contents_oldlen = len;
2924             if (contents_datalen > len) {
2925                 e = ASN1_OVERRUN;
2926                 goto fail;
2927             }
2928             len = contents_datalen;
2929             {
2930                 size_t contents_Tag_datalen, contents_Tag_oldlen;
2931                 Der_type contents_Tag_type;
2932                 e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &contents_Tag_type, UT_OctetString, &contents_Tag_datalen, &l);
2933                 if (e == 0 && contents_Tag_type != PRIM) {
2934                     e = ASN1_BAD_ID;
2935                 }
2936                 if (e)
2937                     goto fail;
2938                 p += l;
2939                 len -= l;
2940                 ret += l;
2941                 contents_Tag_oldlen = len;
2942                 if (contents_Tag_datalen > len) {
2943                     e = ASN1_OVERRUN;
2944                     goto fail;
2945                 }
2946                 len = contents_Tag_datalen;
2947                 e = der_get_octet_string(p, len, &(data)->contents, &l);
2948                 if (e)
2949                     goto fail;
2950                 p += l;
2951                 len -= l;
2952                 ret += l;
2953                 len = contents_Tag_oldlen - contents_Tag_datalen;
2954             }
2955             len = contents_oldlen - contents_datalen;
2956         }
2957         len = Top_oldlen - Top_datalen;
2958     }
2959     if (size)
2960         *size = ret;
2961     return 0;
2962 fail:
2963     free_TransitedEncoding(data);
2964     return e;
2965 }
2966
2967 void
2968 free_TransitedEncoding(TransitedEncoding * data)
2969 {
2970     free_krb5int32(&(data)->tr_type);
2971     der_free_octet_string(&(data)->contents);
2972 }
2973
2974 size_t
2975 length_TransitedEncoding(const TransitedEncoding * data)
2976 {
2977     size_t ret = 0;
2978     {
2979         size_t Top_tag_oldret = ret;
2980         ret = 0;
2981         ret += length_krb5int32(&(data)->tr_type);
2982         ret += 1 + der_length_len(ret);
2983         ret += Top_tag_oldret;
2984     }
2985     {
2986         size_t Top_tag_oldret = ret;
2987         ret = 0;
2988         ret += der_length_octet_string(&(data)->contents);
2989         ret += 1 + der_length_len(ret);
2990         ret += 1 + der_length_len(ret);
2991         ret += Top_tag_oldret;
2992     }
2993     ret += 1 + der_length_len(ret);
2994     return ret;
2995 }
2996
2997 int
2998 copy_TransitedEncoding(const TransitedEncoding * from, TransitedEncoding * to)
2999 {
3000     memset(to, 0, sizeof(*to));
3001     if (copy_krb5int32(&(from)->tr_type, &(to)->tr_type))
3002         goto fail;
3003     if (der_copy_octet_string(&(from)->contents, &(to)->contents))
3004         goto fail;
3005     return 0;
3006 fail:
3007     free_TransitedEncoding(to);
3008     return ENOMEM;
3009 }
3010
3011
3012
3013 /* Generated from ./krb5.asn1 */
3014 /* Do not edit */
3015
3016 #include <stdio.h>
3017 #include <stdlib.h>
3018 #include <time.h>
3019 #include <string.h>
3020 #include <errno.h>
3021 #include <limits.h>
3022 #include <asn1_err.h>
3023
3024 int
3025 encode_EncryptionKey(unsigned char *p, size_t len, const EncryptionKey * data, size_t * size)
3026 {
3027     size_t ret = 0;
3028     size_t l;
3029     int i AFS_UNUSED, e;
3030
3031     i = 0;
3032 /* keyvalue */
3033     {
3034         size_t Top_tag_oldret = ret;
3035         ret = 0;
3036         e = der_put_octet_string(p, len, &(data)->keyvalue, &l);
3037         if (e)
3038             return e;
3039         p -= l;
3040         len -= l;
3041         ret += l;
3042
3043         e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
3044         if (e)
3045             return e;
3046         p -= l;
3047         len -= l;
3048         ret += l;
3049
3050         e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
3051         if (e)
3052             return e;
3053         p -= l;
3054         len -= l;
3055         ret += l;
3056
3057         ret += Top_tag_oldret;
3058     }
3059 /* keytype */
3060     {
3061         size_t Top_tag_oldret = ret;
3062         ret = 0;
3063         e = encode_krb5int32(p, len, &(data)->keytype, &l);
3064         if (e)
3065             return e;
3066         p -= l;
3067         len -= l;
3068         ret += l;
3069
3070         e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
3071         if (e)
3072             return e;
3073         p -= l;
3074         len -= l;
3075         ret += l;
3076
3077         ret += Top_tag_oldret;
3078     }
3079     e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
3080     if (e)
3081         return e;
3082     p -= l;
3083     len -= l;
3084     ret += l;
3085
3086     *size = ret;
3087     return 0;
3088 }
3089
3090 int
3091 decode_EncryptionKey(const unsigned char *p, size_t len, EncryptionKey * data, size_t * size)
3092 {
3093     size_t ret = 0;
3094     size_t l;
3095     int e;
3096
3097     memset(data, 0, sizeof(*data));
3098     {
3099         size_t Top_datalen, Top_oldlen;
3100         Der_type Top_type;
3101         e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
3102         if (e == 0 && Top_type != CONS) {
3103             e = ASN1_BAD_ID;
3104         }
3105         if (e)
3106             goto fail;
3107         p += l;
3108         len -= l;
3109         ret += l;
3110         Top_oldlen = len;
3111         if (Top_datalen > len) {
3112             e = ASN1_OVERRUN;
3113             goto fail;
3114         }
3115         len = Top_datalen;
3116         {
3117             size_t keytype_datalen, keytype_oldlen;
3118             Der_type keytype_type;
3119             e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &keytype_type, 0, &keytype_datalen, &l);
3120             if (e == 0 && keytype_type != CONS) {
3121                 e = ASN1_BAD_ID;
3122             }
3123             if (e)
3124                 goto fail;
3125             p += l;
3126             len -= l;
3127             ret += l;
3128             keytype_oldlen = len;
3129             if (keytype_datalen > len) {
3130                 e = ASN1_OVERRUN;
3131                 goto fail;
3132             }
3133             len = keytype_datalen;
3134             e = decode_krb5int32(p, len, &(data)->keytype, &l);
3135             if (e)
3136                 goto fail;
3137             p += l;
3138             len -= l;
3139             ret += l;
3140             len = keytype_oldlen - keytype_datalen;
3141         }
3142         {
3143             size_t keyvalue_datalen, keyvalue_oldlen;
3144             Der_type keyvalue_type;
3145             e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &keyvalue_type, 1, &keyvalue_datalen, &l);
3146             if (e == 0 && keyvalue_type != CONS) {
3147                 e = ASN1_BAD_ID;
3148             }
3149             if (e)
3150                 goto fail;
3151             p += l;
3152             len -= l;
3153             ret += l;
3154             keyvalue_oldlen = len;
3155             if (keyvalue_datalen > len) {
3156                 e = ASN1_OVERRUN;
3157                 goto fail;
3158             }
3159             len = keyvalue_datalen;
3160             {
3161                 size_t keyvalue_Tag_datalen, keyvalue_Tag_oldlen;
3162                 Der_type keyvalue_Tag_type;
3163                 e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &keyvalue_Tag_type, UT_OctetString, &keyvalue_Tag_datalen, &l);
3164                 if (e == 0 && keyvalue_Tag_type != PRIM) {
3165                     e = ASN1_BAD_ID;
3166                 }
3167                 if (e)
3168                     goto fail;
3169                 p += l;
3170                 len -= l;
3171                 ret += l;
3172                 keyvalue_Tag_oldlen = len;
3173                 if (keyvalue_Tag_datalen > len) {
3174                     e = ASN1_OVERRUN;
3175                     goto fail;
3176                 }
3177                 len = keyvalue_Tag_datalen;
3178                 e = der_get_octet_string(p, len, &(data)->keyvalue, &l);
3179                 if (e)
3180                     goto fail;
3181                 p += l;
3182                 len -= l;
3183                 ret += l;
3184                 len = keyvalue_Tag_oldlen - keyvalue_Tag_datalen;
3185             }
3186             len = keyvalue_oldlen - keyvalue_datalen;
3187         }
3188         len = Top_oldlen - Top_datalen;
3189     }
3190     if (size)
3191         *size = ret;
3192     return 0;
3193 fail:
3194     free_EncryptionKey(data);
3195     return e;
3196 }
3197
3198 void
3199 free_EncryptionKey(EncryptionKey * data)
3200 {
3201     free_krb5int32(&(data)->keytype);
3202     der_free_octet_string(&(data)->keyvalue);
3203 }
3204
3205 size_t
3206 length_EncryptionKey(const EncryptionKey * data)
3207 {
3208     size_t ret = 0;
3209     {
3210         size_t Top_tag_oldret = ret;
3211         ret = 0;
3212         ret += length_krb5int32(&(data)->keytype);
3213         ret += 1 + der_length_len(ret);
3214         ret += Top_tag_oldret;
3215     }
3216     {
3217         size_t Top_tag_oldret = ret;
3218         ret = 0;
3219         ret += der_length_octet_string(&(data)->keyvalue);
3220         ret += 1 + der_length_len(ret);
3221         ret += 1 + der_length_len(ret);
3222         ret += Top_tag_oldret;
3223     }
3224     ret += 1 + der_length_len(ret);
3225     return ret;
3226 }
3227
3228 int
3229 copy_EncryptionKey(const EncryptionKey * from, EncryptionKey * to)
3230 {
3231     memset(to, 0, sizeof(*to));
3232     if (copy_krb5int32(&(from)->keytype, &(to)->keytype))
3233         goto fail;
3234     if (der_copy_octet_string(&(from)->keyvalue, &(to)->keyvalue))
3235         goto fail;
3236     return 0;
3237 fail:
3238     free_EncryptionKey(to);
3239     return ENOMEM;
3240 }
3241
3242
3243
3244 /* Generated from ./krb5.asn1 */
3245 /* Do not edit */
3246
3247 #include <stdio.h>
3248 #include <stdlib.h>
3249 #include <time.h>
3250 #include <string.h>
3251 #include <errno.h>
3252 #include <limits.h>
3253 #include <asn1_err.h>
3254
3255 int
3256 encode_TicketFlags(unsigned char *p, size_t len, const TicketFlags * data, size_t * size)
3257 {
3258     size_t ret = 0;
3259     size_t l;
3260     int i AFS_UNUSED, e;
3261
3262     i = 0;
3263     {
3264         unsigned char c = 0;
3265         if (len < 1)
3266             return ASN1_OVERFLOW;
3267         *p-- = c;
3268         len--;
3269         ret++;
3270         c = 0;
3271         if (len < 1)
3272             return ASN1_OVERFLOW;
3273         *p-- = c;
3274         len--;
3275         ret++;
3276         c = 0;
3277         if ((data)->anonymous) {
3278             c |= 1 << 1;
3279         }
3280         if ((data)->ok_as_delegate) {
3281             c |= 1 << 2;
3282         }
3283         if ((data)->transited_policy_checked) {
3284             c |= 1 << 3;
3285         }
3286         if ((data)->hw_authent) {
3287             c |= 1 << 4;
3288         }
3289         if ((data)->pre_authent) {
3290             c |= 1 << 5;
3291         }
3292         if ((data)->initial) {
3293             c |= 1 << 6;
3294         }
3295         if ((data)->renewable) {
3296             c |= 1 << 7;
3297         }
3298         if (len < 1)
3299             return ASN1_OVERFLOW;
3300         *p-- = c;
3301         len--;
3302         ret++;
3303         c = 0;
3304         if ((data)->invalid) {
3305             c |= 1 << 0;
3306         }
3307         if ((data)->postdated) {
3308             c |= 1 << 1;
3309         }
3310         if ((data)->may_postdate) {
3311             c |= 1 << 2;
3312         }
3313         if ((data)->proxy) {
3314             c |= 1 << 3;
3315         }
3316         if ((data)->proxiable) {
3317             c |= 1 << 4;
3318         }
3319         if ((data)->forwarded) {
3320             c |= 1 << 5;
3321         }
3322         if ((data)->forwardable) {
3323             c |= 1 << 6;
3324         }
3325         if ((data)->reserved) {
3326             c |= 1 << 7;
3327         }
3328         if (len < 1)
3329             return ASN1_OVERFLOW;
3330         *p-- = c;
3331         len--;
3332         ret++;
3333         if (len < 1)
3334             return ASN1_OVERFLOW;
3335         *p-- = 0;
3336         len -= 1;
3337         ret += 1;
3338     }
3339
3340     e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, PRIM, UT_BitString, &l);
3341     if (e)
3342         return e;
3343     p -= l;
3344     len -= l;
3345     ret += l;
3346
3347     *size = ret;
3348     return 0;
3349 }
3350
3351 int
3352 decode_TicketFlags(const unsigned char *p, size_t len, TicketFlags * data, size_t * size)
3353 {
3354     size_t ret = 0;
3355     size_t l;
3356     int e;
3357
3358     memset(data, 0, sizeof(*data));
3359     {
3360         size_t Top_datalen, Top_oldlen;
3361         Der_type Top_type;
3362         e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_BitString, &Top_datalen, &l);
3363         if (e == 0 && Top_type != PRIM) {
3364             e = ASN1_BAD_ID;
3365         }
3366         if (e)
3367             goto fail;
3368         p += l;
3369         len -= l;
3370         ret += l;
3371         Top_oldlen = len;
3372         if (Top_datalen > len) {
3373             e = ASN1_OVERRUN;
3374             goto fail;
3375         }
3376         len = Top_datalen;
3377         if (len < 1)
3378             return ASN1_OVERRUN;
3379         p++;
3380         len--;
3381         ret++;
3382         do {
3383             if (len < 1)
3384                 break;
3385             (data)->reserved = (*p >> 7) & 1;
3386             (data)->forwardable = (*p >> 6) & 1;
3387             (data)->forwarded = (*p >> 5) & 1;
3388             (data)->proxiable = (*p >> 4) & 1;
3389             (data)->proxy = (*p >> 3) & 1;
3390             (data)->may_postdate = (*p >> 2) & 1;
3391             (data)->postdated = (*p >> 1) & 1;
3392             (data)->invalid = (*p >> 0) & 1;
3393             p++;
3394             len--;
3395             ret++;
3396             if (len < 1)
3397                 break;
3398             (data)->renewable = (*p >> 7) & 1;
3399             (data)->initial = (*p >> 6) & 1;
3400             (data)->pre_authent = (*p >> 5) & 1;
3401             (data)->hw_authent = (*p >> 4) & 1;
3402             (data)->transited_policy_checked = (*p >> 3) & 1;
3403             (data)->ok_as_delegate = (*p >> 2) & 1;
3404             (data)->anonymous = (*p >> 1) & 1;
3405         } while (0);
3406         p += len;
3407         ret += len;
3408         len = Top_oldlen - Top_datalen;
3409     }
3410     if (size)
3411         *size = ret;
3412     return 0;
3413 fail:
3414     free_TicketFlags(data);
3415     return e;
3416 }
3417
3418 void
3419 free_TicketFlags(TicketFlags * data)
3420 {
3421 }
3422
3423 size_t
3424 length_TicketFlags(const TicketFlags * data)
3425 {
3426     size_t ret = 0;
3427     ret += 5;
3428     ret += 1 + der_length_len(ret);
3429     return ret;
3430 }
3431
3432 int
3433 copy_TicketFlags(const TicketFlags * from, TicketFlags * to)
3434 {
3435     memset(to, 0, sizeof(*to));
3436     *(to) = *(from);
3437     return 0;
3438 }
3439
3440 unsigned
3441 TicketFlags2int(TicketFlags f)
3442 {
3443     unsigned r = 0;
3444     if (f.reserved)
3445         r |= (1U << 0);
3446     if (f.forwardable)
3447         r |= (1U << 1);
3448     if (f.forwarded)
3449         r |= (1U << 2);
3450     if (f.proxiable)
3451         r |= (1U << 3);
3452     if (f.proxy)
3453         r |= (1U << 4);
3454     if (f.may_postdate)
3455         r |= (1U << 5);
3456     if (f.postdated)
3457         r |= (1U << 6);
3458     if (f.invalid)
3459         r |= (1U << 7);
3460     if (f.renewable)
3461         r |= (1U << 8);
3462     if (f.initial)
3463         r |= (1U << 9);
3464     if (f.pre_authent)
3465         r |= (1U << 10);
3466     if (f.hw_authent)
3467         r |= (1U << 11);
3468     if (f.transited_policy_checked)
3469         r |= (1U << 12);
3470     if (f.ok_as_delegate)
3471         r |= (1U << 13);
3472     if (f.anonymous)
3473         r |= (1U << 14);
3474     return r;
3475 }
3476
3477 TicketFlags
3478 int2TicketFlags(unsigned n)
3479 {
3480     TicketFlags flags;
3481
3482     memset(&flags, 0, sizeof(flags));
3483
3484     flags.reserved = (n >> 0) & 1;
3485     flags.forwardable = (n >> 1) & 1;
3486     flags.forwarded = (n >> 2) & 1;
3487     flags.proxiable = (n >> 3) & 1;
3488     flags.proxy = (n >> 4) & 1;
3489     flags.may_postdate = (n >> 5) & 1;
3490     flags.postdated = (n >> 6) & 1;
3491     flags.invalid = (n >> 7) & 1;
3492     flags.renewable = (n >> 8) & 1;
3493     flags.initial = (n >> 9) & 1;
3494     flags.pre_authent = (n >> 10) & 1;
3495     flags.hw_authent = (n >> 11) & 1;
3496     flags.transited_policy_checked = (n >> 12) & 1;
3497     flags.ok_as_delegate = (n >> 13) & 1;
3498     flags.anonymous = (n >> 14) & 1;
3499     return flags;
3500 }
3501
3502
3503
3504
3505
3506 /* Generated from ./krb5.asn1 */
3507 /* Do not edit */
3508
3509 #include <stdio.h>
3510 #include <stdlib.h>
3511 #include <time.h>
3512 #include <string.h>
3513 #include <errno.h>
3514 #include <limits.h>
3515 #include <asn1_err.h>
3516
3517 int
3518 encode_Realm(unsigned char *p, size_t len, const Realm * data, size_t * size)
3519 {
3520     size_t ret = 0;
3521     size_t l;
3522     int i AFS_UNUSED, e;
3523
3524     i = 0;
3525     e = der_put_general_string(p, len, data, &l);
3526     if (e)
3527         return e;
3528     p -= l;
3529     len -= l;
3530     ret += l;
3531
3532     e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, PRIM, UT_GeneralString, &l);
3533     if (e)
3534         return e;
3535     p -= l;
3536     len -= l;
3537     ret += l;
3538
3539     *size = ret;
3540     return 0;
3541 }
3542
3543 int
3544 decode_Realm(const unsigned char *p, size_t len, Realm * data, size_t * size)
3545 {
3546     size_t ret = 0;
3547     size_t l;
3548     int e;
3549
3550     memset(data, 0, sizeof(*data));
3551     {
3552         size_t Top_datalen, Top_oldlen;
3553         Der_type Top_type;
3554         e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_GeneralString, &Top_datalen, &l);
3555         if (e == 0 && Top_type != PRIM) {
3556             e = ASN1_BAD_ID;
3557         }
3558         if (e)
3559             goto fail;
3560         p += l;
3561         len -= l;
3562         ret += l;
3563         Top_oldlen = len;
3564         if (Top_datalen > len) {
3565             e = ASN1_OVERRUN;
3566             goto fail;
3567         }
3568         len = Top_datalen;
3569         e = der_get_general_string(p, len, data, &l);
3570         if (e)
3571             goto fail;
3572         p += l;
3573         len -= l;
3574         ret += l;
3575         len = Top_oldlen - Top_datalen;
3576     }
3577     if (size)
3578         *size = ret;
3579     return 0;
3580 fail:
3581     free_Realm(data);
3582     return e;
3583 }
3584
3585 void
3586 free_Realm(Realm * data)
3587 {
3588     der_free_general_string(data);
3589 }
3590
3591 size_t
3592 length_Realm(const Realm * data)
3593 {
3594     size_t ret = 0;
3595     ret += der_length_general_string(data);
3596     ret += 1 + der_length_len(ret);
3597     return ret;
3598 }
3599
3600 int
3601 copy_Realm(const Realm * from, Realm * to)
3602 {
3603     memset(to, 0, sizeof(*to));
3604     if (der_copy_general_string(from, to))
3605         goto fail;
3606     return 0;
3607 fail:
3608     free_Realm(to);
3609     return ENOMEM;
3610 }
3611
3612
3613
3614 /* Generated from ./krb5.asn1 */
3615 /* Do not edit */
3616
3617 #include <stdio.h>
3618 #include <stdlib.h>
3619 #include <time.h>
3620 #include <string.h>
3621 #include <errno.h>
3622 #include <limits.h>
3623 #include <asn1_err.h>
3624
3625 int
3626 encode_ENCTYPE(unsigned char *p, size_t len, const ENCTYPE * data, size_t * size)
3627 {
3628     size_t ret = 0;
3629     size_t l;
3630     int i AFS_UNUSED, e;
3631
3632     i = 0;
3633     {
3634         int enumint = (int) *data;
3635         e = der_put_integer(p, len, &enumint, &l);
3636         if (e)
3637             return e;
3638         p -= l;
3639         len -= l;
3640         ret += l;
3641
3642     }
3643     ;
3644     e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
3645     if (e)
3646         return e;
3647     p -= l;
3648     len -= l;
3649     ret += l;
3650
3651     *size = ret;
3652     return 0;
3653 }
3654
3655 int
3656 decode_ENCTYPE(const unsigned char *p, size_t len, ENCTYPE * data, size_t * size)
3657 {
3658     size_t ret = 0;
3659     size_t l;
3660     int e;
3661
3662     memset(data, 0, sizeof(*data));
3663     {
3664         size_t Top_datalen, Top_oldlen;
3665         Der_type Top_type;
3666         e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Integer, &Top_datalen, &l);
3667         if (e == 0 && Top_type != PRIM) {
3668             e = ASN1_BAD_ID;
3669         }
3670         if (e)
3671             goto fail;
3672         p += l;
3673         len -= l;
3674         ret += l;
3675         Top_oldlen = len;
3676         if (Top_datalen > len) {
3677             e = ASN1_OVERRUN;
3678             goto fail;
3679         }
3680         len = Top_datalen;
3681         {
3682             int enumint;
3683             e = der_get_integer(p, len, &enumint, &l);
3684             if (e)
3685                 goto fail;
3686             p += l;
3687             len -= l;
3688             ret += l;
3689             *data = enumint;
3690         }
3691         len = Top_oldlen - Top_datalen;
3692     }
3693     if (size)
3694         *size = ret;
3695     return 0;
3696 fail:
3697     free_ENCTYPE(data);
3698     return e;
3699 }
3700
3701 void
3702 free_ENCTYPE(ENCTYPE * data)
3703 {
3704 }
3705
3706 size_t
3707 length_ENCTYPE(const ENCTYPE * data)
3708 {
3709     size_t ret = 0;
3710     {
3711         int enumint = *data;
3712         ret += der_length_integer(&enumint);
3713     }
3714     ret += 1 + der_length_len(ret);
3715     return ret;
3716 }
3717
3718 int
3719 copy_ENCTYPE(const ENCTYPE * from, ENCTYPE * to)
3720 {
3721     memset(to, 0, sizeof(*to));
3722     *(to) = *(from);
3723     return 0;
3724 }
3725
3726
3727
3728 /* Generated from ./krb5.asn1 */
3729 /* Do not edit */
3730
3731 #include <stdio.h>
3732 #include <stdlib.h>
3733 #include <time.h>
3734 #include <string.h>
3735 #include <errno.h>
3736 #include <limits.h>
3737 #include <asn1_err.h>
3738
3739 int
3740 encode_NAME_TYPE(unsigned char *p, size_t len, const NAME_TYPE * data, size_t * size)
3741 {
3742     size_t ret = 0;
3743     size_t l;
3744     int i AFS_UNUSED, e;
3745
3746     i = 0;
3747     {
3748         int enumint = (int) *data;
3749         e = der_put_integer(p, len, &enumint, &l);
3750         if (e)
3751             return e;
3752         p -= l;
3753         len -= l;
3754         ret += l;
3755
3756     }
3757     ;
3758     e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
3759     if (e)
3760         return e;
3761     p -= l;
3762     len -= l;
3763     ret += l;
3764
3765     *size = ret;
3766     return 0;
3767 }
3768
3769 int
3770 decode_NAME_TYPE(const unsigned char *p, size_t len, NAME_TYPE * data, size_t * size)
3771 {
3772     size_t ret = 0;
3773     size_t l;
3774     int e;
3775
3776     memset(data, 0, sizeof(*data));
3777     {
3778         size_t Top_datalen, Top_oldlen;
3779         Der_type Top_type;
3780         e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Integer, &Top_datalen, &l);
3781         if (e == 0 && Top_type != PRIM) {
3782             e = ASN1_BAD_ID;
3783         }
3784         if (e)
3785             goto fail;
3786         p += l;
3787         len -= l;
3788         ret += l;
3789         Top_oldlen = len;
3790         if (Top_datalen > len) {
3791             e = ASN1_OVERRUN;
3792             goto fail;
3793         }
3794         len = Top_datalen;
3795         {
3796             int enumint;
3797             e = der_get_integer(p, len, &enumint, &l);
3798             if (e)
3799                 goto fail;
3800             p += l;
3801             len -= l;
3802             ret += l;
3803             *data = enumint;
3804         }
3805         len = Top_oldlen - Top_datalen;
3806     }
3807     if (size)
3808         *size = ret;
3809     return 0;
3810 fail:
3811     free_NAME_TYPE(data);
3812     return e;
3813 }
3814
3815 void
3816 free_NAME_TYPE(NAME_TYPE * data)
3817 {
3818 }
3819
3820 size_t
3821 length_NAME_TYPE(const NAME_TYPE * data)
3822 {
3823     size_t ret = 0;
3824     {
3825         int enumint = *data;
3826         ret += der_length_integer(&enumint);
3827     }
3828     ret += 1 + der_length_len(ret);
3829     return ret;
3830 }
3831
3832 int
3833 copy_NAME_TYPE(const NAME_TYPE * from, NAME_TYPE * to)
3834 {
3835     memset(to, 0, sizeof(*to));
3836     *(to) = *(from);
3837     return 0;
3838 }