src/rxkad/v5gen.h

   1 /* Generated from /home/lha/src/cvs/heimdal/lib/asn1/k5.asn1 */
   2 /* Do not edit */
   3
   4 #ifndef __krb5_asn1_h__
   5 #define __krb5_asn1_h__
   6
   7 #include <stddef.h>
   8 #include <time.h>
   9
  10 #ifndef __asn1_common_definitions__
  11 #define __asn1_common_definitions__
  12
  13 typedef struct octet_string {
  14     size_t length;
  15     void *data;
  16 } octet_string;
  17
  18 typedef char *general_string;
  19
  20 typedef struct oid {
  21     size_t length;
  22     unsigned *components;
  23 } oid;
  24
  25 #define ASN1_MALLOC_ENCODE(T, B, BL, S, L, R)                  \
  26   do {                                                         \
  27     (BL) = length_##T((S));                                    \
  28     (B) = malloc((BL));                                        \
  29     if((B) == NULL) {                                          \
  30       (R) = ENOMEM;                                            \
  31     } else {                                                   \
  32       (R) = encode_##T(((unsigned char*)(B)) + (BL) - 1, (BL), \
  33                        (S), (L));                              \
  34       if((R) != 0) {                                           \
  35         free((B));                                             \
  36         (B) = NULL;                                            \
  37       }                                                        \
  38     }                                                          \
  39   } while (0)
  40
  41 #endif
  42
  43 /*
  44 NAME-TYPE ::= INTEGER
  45 */
  46
  47 typedef enum NAME_TYPE {
  48     KRB5_NT_UNKNOWN = 0,
  49     KRB5_NT_PRINCIPAL = 1,
  50     KRB5_NT_SRV_INST = 2,
  51     KRB5_NT_SRV_HST = 3,
  52     KRB5_NT_SRV_XHST = 4,
  53     KRB5_NT_UID = 5,
  54     KRB5_NT_X500_PRINCIPAL = 6
  55 } NAME_TYPE;
  56
  57 int encode_NAME_TYPE(unsigned char *, size_t, const NAME_TYPE *, size_t *);
  58 int decode_NAME_TYPE(const unsigned char *, size_t, NAME_TYPE *, size_t *);
  59 void free_NAME_TYPE(NAME_TYPE *);
  60 size_t length_NAME_TYPE(const NAME_TYPE *);
  61 int copy_NAME_TYPE(const NAME_TYPE *, NAME_TYPE *);
  62
  63
  64 /*
  65 MESSAGE-TYPE ::= INTEGER
  66 */
  67
  68 typedef enum MESSAGE_TYPE {
  69     krb_as_req = 10,
  70     krb_as_rep = 11,
  71     krb_tgs_req = 12,
  72     krb_tgs_rep = 13,
  73     krb_ap_req = 14,
  74     krb_ap_rep = 15,
  75     krb_safe = 20,
  76     krb_priv = 21,
  77     krb_cred = 22,
  78     krb_error = 30
  79 } MESSAGE_TYPE;
  80
  81 int encode_MESSAGE_TYPE(unsigned char *, size_t, const MESSAGE_TYPE *,
  82                         size_t *);
  83 int decode_MESSAGE_TYPE(const unsigned char *, size_t, MESSAGE_TYPE *,
  84                         size_t *);
  85 void free_MESSAGE_TYPE(MESSAGE_TYPE *);
  86 size_t length_MESSAGE_TYPE(const MESSAGE_TYPE *);
  87 int copy_MESSAGE_TYPE(const MESSAGE_TYPE *, MESSAGE_TYPE *);
  88
  89
  90 /*
  91 PADATA-TYPE ::= INTEGER
  92 */
  93
  94 typedef enum PADATA_TYPE {
  95     KRB5_PADATA_NONE = 0,
  96     KRB5_PADATA_TGS_REQ = 1,
  97     KRB5_PADATA_AP_REQ = 1,
  98     KRB5_PADATA_ENC_TIMESTAMP = 2,
  99     KRB5_PADATA_PW_SALT = 3,
 100     KRB5_PADATA_ENC_UNIX_TIME = 5,
 101     KRB5_PADATA_SANDIA_SECUREID = 6,
 102     KRB5_PADATA_SESAME = 7,
 103     KRB5_PADATA_OSF_DCE = 8,
 104     KRB5_PADATA_CYBERSAFE_SECUREID = 9,
 105     KRB5_PADATA_AFS3_SALT = 10,
 106     KRB5_PADATA_ETYPE_INFO = 11,
 107     KRB5_PADATA_SAM_CHALLENGE = 12,
 108     KRB5_PADATA_SAM_RESPONSE = 13,
 109     KRB5_PADATA_PK_AS_REQ = 14,
 110     KRB5_PADATA_PK_AS_REP = 15,
 111     KRB5_PADATA_PK_AS_SIGN = 16,
 112     KRB5_PADATA_PK_KEY_REQ = 17,
 113     KRB5_PADATA_PK_KEY_REP = 18,
 114     KRB5_PADATA_USE_SPECIFIED_KVNO = 20,
 115     KRB5_PADATA_SAM_REDIRECT = 21,
 116     KRB5_PADATA_GET_FROM_TYPED_DATA = 22,
 117     KRB5_PADATA_SAM_ETYPE_INFO = 23
 118 } PADATA_TYPE;
 119
 120 int encode_PADATA_TYPE(unsigned char *, size_t, const PADATA_TYPE *,
 121                        size_t *);
 122 int decode_PADATA_TYPE(const unsigned char *, size_t, PADATA_TYPE *,
 123                        size_t *);
 124 void free_PADATA_TYPE(PADATA_TYPE *);
 125 size_t length_PADATA_TYPE(const PADATA_TYPE *);
 126 int copy_PADATA_TYPE(const PADATA_TYPE *, PADATA_TYPE *);
 127
 128
 129 /*
 130 CKSUMTYPE ::= INTEGER
 131 */
 132
 133 typedef enum CKSUMTYPE {
 134     CKSUMTYPE_NONE = 0,
 135     CKSUMTYPE_CRC32 = 1,
 136     CKSUMTYPE_RSA_MD4 = 2,
 137     CKSUMTYPE_RSA_MD4_DES = 3,
 138     CKSUMTYPE_DES_MAC = 4,
 139     CKSUMTYPE_DES_MAC_K = 5,
 140     CKSUMTYPE_RSA_MD4_DES_K = 6,
 141     CKSUMTYPE_RSA_MD5 = 7,
 142     CKSUMTYPE_RSA_MD5_DES = 8,
 143     CKSUMTYPE_RSA_MD5_DES3 = 9,
 144     CKSUMTYPE_HMAC_SHA1_DES3 = 12,
 145     CKSUMTYPE_SHA1 = 1000,
 146     CKSUMTYPE_GSSAPI = 32771,
 147     CKSUMTYPE_HMAC_MD5 = -138,
 148     CKSUMTYPE_HMAC_MD5_ENC = -1138
 149 } CKSUMTYPE;
 150
 151 int encode_CKSUMTYPE(unsigned char *, size_t, const CKSUMTYPE *, size_t *);
 152 int decode_CKSUMTYPE(const unsigned char *, size_t, CKSUMTYPE *, size_t *);
 153 void free_CKSUMTYPE(CKSUMTYPE *);
 154 size_t length_CKSUMTYPE(const CKSUMTYPE *);
 155 int copy_CKSUMTYPE(const CKSUMTYPE *, CKSUMTYPE *);
 156
 157
 158 /*
 159 ENCTYPE ::= INTEGER
 160 */
 161
 162 typedef enum ENCTYPE {
 163     ETYPE_NULL = 0,
 164     ETYPE_DES_CBC_CRC = 1,
 165     ETYPE_DES_CBC_MD4 = 2,
 166     ETYPE_DES_CBC_MD5 = 3,
 167     ETYPE_DES3_CBC_MD5 = 5,
 168     ETYPE_OLD_DES3_CBC_SHA1 = 7,
 169     ETYPE_SIGN_DSA_GENERATE = 8,
 170     ETYPE_ENCRYPT_RSA_PRIV = 9,
 171     ETYPE_ENCRYPT_RSA_PUB = 10,
 172     ETYPE_DES3_CBC_SHA1 = 16,
 173     ETYPE_ARCFOUR_HMAC_MD5 = 23,
 174     ETYPE_ARCFOUR_HMAC_MD5_56 = 24,
 175     ETYPE_ENCTYPE_PK_CROSS = 48,
 176     ETYPE_DES_CBC_NONE = -4096,
 177     ETYPE_DES3_CBC_NONE = -4097,
 178     ETYPE_DES_CFB64_NONE = -4098,
 179     ETYPE_DES_PCBC_NONE = -4099
 180 } ENCTYPE;
 181
 182 int encode_ENCTYPE(unsigned char *, size_t, const ENCTYPE *, size_t *);
 183 int decode_ENCTYPE(const unsigned char *, size_t, ENCTYPE *, size_t *);
 184 void free_ENCTYPE(ENCTYPE *);
 185 size_t length_ENCTYPE(const ENCTYPE *);
 186 int copy_ENCTYPE(const ENCTYPE *, ENCTYPE *);
 187
 188
 189 /*
 190 UNSIGNED ::= UNSIGNED INTEGER
 191 */
 192
 193 typedef unsigned int UNSIGNED;
 194
 195 int encode_UNSIGNED(unsigned char *, size_t, const UNSIGNED *, size_t *);
 196 int decode_UNSIGNED(const unsigned char *, size_t, UNSIGNED *, size_t *);
 197 void free_UNSIGNED(UNSIGNED *);
 198 size_t length_UNSIGNED(const UNSIGNED *);
 199 int copy_UNSIGNED(const UNSIGNED *, UNSIGNED *);
 200
 201
 202 /*
 203 Realm ::= GeneralString
 204 */
 205
 206 typedef general_string Realm;
 207
 208 int encode_Realm(unsigned char *, size_t, const Realm *, size_t *);
 209 int decode_Realm(const unsigned char *, size_t, Realm *, size_t *);
 210 void free_Realm(Realm *);
 211 size_t length_Realm(const Realm *);
 212 int copy_Realm(const Realm *, Realm *);
 213
 214
 215 /*
 216 PrincipalName ::= SEQUENCE {
 217   name-type[0]    NAME-TYPE,
 218   name-string[1]  SEQUENCE OF GeneralString
 219 }
 220 */
 221
 222 typedef struct PrincipalName {
 223     NAME_TYPE name_type;
 224     struct {
 225         unsigned int len;
 226         general_string *val;
 227     } name_string;
 228 } PrincipalName;
 229
 230 int encode_PrincipalName(unsigned char *, size_t, const PrincipalName *,
 231                          size_t *);
 232 int decode_PrincipalName(const unsigned char *, size_t, PrincipalName *,
 233                          size_t *);
 234 void free_PrincipalName(PrincipalName *);
 235 size_t length_PrincipalName(const PrincipalName *);
 236 int copy_PrincipalName(const PrincipalName *, PrincipalName *);
 237
 238
 239 /*
 240 Principal ::= SEQUENCE {
 241   name[0]         PrincipalName,
 242   realm[1]        Realm
 243 }
 244 */
 245
 246 typedef struct Principal {
 247     PrincipalName name;
 248     Realm realm;
 249 } Principal;
 250
 251 int encode_Principal(unsigned char *, size_t, const Principal *, size_t *);
 252 int decode_Principal(const unsigned char *, size_t, Principal *, size_t *);
 253 void free_Principal(Principal *);
 254 size_t length_Principal(const Principal *);
 255 int copy_Principal(const Principal *, Principal *);
 256
 257
 258 /*
 259 HostAddress ::= SEQUENCE {
 260   addr-type[0]    INTEGER,
 261   address[1]      OCTET STRING
 262 }
 263 */
 264
 265 typedef struct HostAddress {
 266     int addr_type;
 267     octet_string address;
 268 } HostAddress;
 269
 270 int encode_HostAddress(unsigned char *, size_t, const HostAddress *,
 271                        size_t *);
 272 int decode_HostAddress(const unsigned char *, size_t, HostAddress *,
 273                        size_t *);
 274 void free_HostAddress(HostAddress *);
 275 size_t length_HostAddress(const HostAddress *);
 276 int copy_HostAddress(const HostAddress *, HostAddress *);
 277
 278
 279 /*
 280 HostAddresses ::= SEQUENCE OF HostAddress
 281 */
 282
 283 typedef struct HostAddresses {
 284     unsigned int len;
 285     HostAddress *val;
 286 } HostAddresses;
 287
 288 int encode_HostAddresses(unsigned char *, size_t, const HostAddresses *,
 289                          size_t *);
 290 int decode_HostAddresses(const unsigned char *, size_t, HostAddresses *,
 291                          size_t *);
 292 void free_HostAddresses(HostAddresses *);
 293 size_t length_HostAddresses(const HostAddresses *);
 294 int copy_HostAddresses(const HostAddresses *, HostAddresses *);
 295
 296
 297 /*
 298 KerberosTime ::= GeneralizedTime
 299 */
 300
 301 typedef time_t KerberosTime;
 302
 303 int encode_KerberosTime(unsigned char *, size_t, const KerberosTime *,
 304                         size_t *);
 305 int decode_KerberosTime(const unsigned char *, size_t, KerberosTime *,
 306                         size_t *);
 307 void free_KerberosTime(KerberosTime *);
 308 size_t length_KerberosTime(const KerberosTime *);
 309 int copy_KerberosTime(const KerberosTime *, KerberosTime *);
 310
 311
 312 /*
 313 AuthorizationData ::= SEQUENCE OF SEQUENCE {
 314   ad-type[0]      INTEGER,
 315   ad-data[1]      OCTET STRING
 316 }
 317 */
 318
 319 typedef struct AuthorizationData {
 320     unsigned int len;
 321     struct {
 322         int ad_type;
 323         octet_string ad_data;
 324     } *val;
 325 } AuthorizationData;
 326
 327 int encode_AuthorizationData(unsigned char *, size_t,
 328                              const AuthorizationData *, size_t *);
 329 int decode_AuthorizationData(const unsigned char *, size_t,
 330                              AuthorizationData *, size_t *);
 331 void free_AuthorizationData(AuthorizationData *);
 332 size_t length_AuthorizationData(const AuthorizationData *);
 333 int copy_AuthorizationData(const AuthorizationData *, AuthorizationData *);
 334
 335
 336 /*
 337 APOptions ::= BIT STRING {
 338   reserved(0),
 339   use-session-key(1),
 340   mutual-required(2)
 341 }
 342 */
 343
 344 typedef struct APOptions {
 345     unsigned int reserved:1;
 346     unsigned int use_session_key:1;
 347     unsigned int mutual_required:1;
 348 } APOptions;
 349
 350
 351 int encode_APOptions(unsigned char *, size_t, const APOptions *, size_t *);
 352 int decode_APOptions(const unsigned char *, size_t, APOptions *, size_t *);
 353 void free_APOptions(APOptions *);
 354 size_t length_APOptions(const APOptions *);
 355 int copy_APOptions(const APOptions *, APOptions *);
 356 unsigned APOptions2int(APOptions);
 357 APOptions int2APOptions(unsigned);
 358
 359 /*
 360 TicketFlags ::= BIT STRING {
 361   reserved(0),
 362   forwardable(1),
 363   forwarded(2),
 364   proxiable(3),
 365   proxy(4),
 366   may-postdate(5),
 367   postdated(6),
 368   invalid(7),
 369   renewable(8),
 370   initial(9),
 371   pre-authent(10),
 372   hw-authent(11),
 373   transited-policy-checked(12),
 374   ok-as-delegate(13),
 375   anonymous(14)
 376 }
 377 */
 378
 379 typedef struct TicketFlags {
 380     unsigned int reserved:1;
 381     unsigned int forwardable:1;
 382     unsigned int forwarded:1;
 383     unsigned int proxiable:1;
 384     unsigned int proxy:1;
 385     unsigned int may_postdate:1;
 386     unsigned int postdated:1;
 387     unsigned int invalid:1;
 388     unsigned int renewable:1;
 389     unsigned int initial:1;
 390     unsigned int pre_authent:1;
 391     unsigned int hw_authent:1;
 392     unsigned int transited_policy_checked:1;
 393     unsigned int ok_as_delegate:1;
 394     unsigned int anonymous:1;
 395 } TicketFlags;
 396
 397
 398 int encode_TicketFlags(unsigned char *, size_t, const TicketFlags *,
 399                        size_t *);
 400 int decode_TicketFlags(const unsigned char *, size_t, TicketFlags *,
 401                        size_t *);
 402 void free_TicketFlags(TicketFlags *);
 403 size_t length_TicketFlags(const TicketFlags *);
 404 int copy_TicketFlags(const TicketFlags *, TicketFlags *);
 405 unsigned TicketFlags2int(TicketFlags);
 406 TicketFlags int2TicketFlags(unsigned);
 407
 408 /*
 409 KDCOptions ::= BIT STRING {
 410   reserved(0),
 411   forwardable(1),
 412   forwarded(2),
 413   proxiable(3),
 414   proxy(4),
 415   allow-postdate(5),
 416   postdated(6),
 417   unused7(7),
 418   renewable(8),
 419   unused9(9),
 420   unused10(10),
 421   unused11(11),
 422   request-anonymous(14),
 423   canonicalize(15),
 424   disable-transited-check(26),
 425   renewable-ok(27),
 426   enc-tkt-in-skey(28),
 427   renew(30),
 428   validate(31)
 429 }
 430 */
 431
 432 typedef struct KDCOptions {
 433     unsigned int reserved:1;
 434     unsigned int forwardable:1;
 435     unsigned int forwarded:1;
 436     unsigned int proxiable:1;
 437     unsigned int proxy:1;
 438     unsigned int allow_postdate:1;
 439     unsigned int postdated:1;
 440     unsigned int unused7:1;
 441     unsigned int renewable:1;
 442     unsigned int unused9:1;
 443     unsigned int unused10:1;
 444     unsigned int unused11:1;
 445     unsigned int request_anonymous:1;
 446     unsigned int canonicalize:1;
 447     unsigned int disable_transited_check:1;
 448     unsigned int renewable_ok:1;
 449     unsigned int enc_tkt_in_skey:1;
 450     unsigned int renew:1;
 451     unsigned int validate:1;
 452 } KDCOptions;
 453
 454
 455 int encode_KDCOptions(unsigned char *, size_t, const KDCOptions *, size_t *);
 456 int decode_KDCOptions(const unsigned char *, size_t, KDCOptions *, size_t *);
 457 void free_KDCOptions(KDCOptions *);
 458 size_t length_KDCOptions(const KDCOptions *);
 459 int copy_KDCOptions(const KDCOptions *, KDCOptions *);
 460 unsigned KDCOptions2int(KDCOptions);
 461 KDCOptions int2KDCOptions(unsigned);
 462
 463 /*
 464 LR-TYPE ::= INTEGER
 465 */
 466
 467 typedef enum LR_TYPE {
 468     LR_NONE = 0,
 469     LR_INITIAL_TGT = 1,
 470     LR_INITIAL = 2,
 471     LR_ISSUE_USE_TGT = 3,
 472     LR_RENEWAL = 4,
 473     LR_REQUEST = 5,
 474     LR_PW_EXPTIME = 6,
 475     LR_ACCT_EXPTIME = 7
 476 } LR_TYPE;
 477
 478 int encode_LR_TYPE(unsigned char *, size_t, const LR_TYPE *, size_t *);
 479 int decode_LR_TYPE(const unsigned char *, size_t, LR_TYPE *, size_t *);
 480 void free_LR_TYPE(LR_TYPE *);
 481 size_t length_LR_TYPE(const LR_TYPE *);
 482 int copy_LR_TYPE(const LR_TYPE *, LR_TYPE *);
 483
 484
 485 /*
 486 LastReq ::= SEQUENCE OF SEQUENCE {
 487   lr-type[0]      LR-TYPE,
 488   lr-value[1]     KerberosTime
 489 }
 490 */
 491
 492 typedef struct LastReq {
 493     unsigned int len;
 494     struct {
 495         LR_TYPE lr_type;
 496         KerberosTime lr_value;
 497     } *val;
 498 } LastReq;
 499
 500 int encode_LastReq(unsigned char *, size_t, const LastReq *, size_t *);
 501 int decode_LastReq(const unsigned char *, size_t, LastReq *, size_t *);
 502 void free_LastReq(LastReq *);
 503 size_t length_LastReq(const LastReq *);
 504 int copy_LastReq(const LastReq *, LastReq *);
 505
 506
 507 /*
 508 EncryptedData ::= SEQUENCE {
 509   etype[0]        ENCTYPE,
 510   kvno[1]         INTEGER OPTIONAL,
 511   cipher[2]       OCTET STRING
 512 }
 513 */
 514
 515 typedef struct EncryptedData {
 516     ENCTYPE etype;
 517     int *kvno;
 518     octet_string cipher;
 519 } EncryptedData;
 520
 521 int encode_EncryptedData(unsigned char *, size_t, const EncryptedData *,
 522                          size_t *);
 523 int decode_EncryptedData(const unsigned char *, size_t, EncryptedData *,
 524                          size_t *);
 525 void free_EncryptedData(EncryptedData *);
 526 size_t length_EncryptedData(const EncryptedData *);
 527 int copy_EncryptedData(const EncryptedData *, EncryptedData *);
 528
 529
 530 /*
 531 EncryptionKey ::= SEQUENCE {
 532   keytype[0]      INTEGER,
 533   keyvalue[1]     OCTET STRING
 534 }
 535 */
 536
 537 typedef struct EncryptionKey {
 538     int keytype;
 539     octet_string keyvalue;
 540 } EncryptionKey;
 541
 542 int encode_EncryptionKey(unsigned char *, size_t, const EncryptionKey *,
 543                          size_t *);
 544 int decode_EncryptionKey(const unsigned char *, size_t, EncryptionKey *,
 545                          size_t *);
 546 void free_EncryptionKey(EncryptionKey *);
 547 size_t length_EncryptionKey(const EncryptionKey *);
 548 int copy_EncryptionKey(const EncryptionKey *, EncryptionKey *);
 549
 550
 551 /*
 552 TransitedEncoding ::= SEQUENCE {
 553   tr-type[0]      INTEGER,
 554   contents[1]     OCTET STRING
 555 }
 556 */
 557
 558 typedef struct TransitedEncoding {
 559     int tr_type;
 560     octet_string contents;
 561 } TransitedEncoding;
 562
 563 int encode_TransitedEncoding(unsigned char *, size_t,
 564                              const TransitedEncoding *, size_t *);
 565 int decode_TransitedEncoding(const unsigned char *, size_t,
 566                              TransitedEncoding *, size_t *);
 567 void free_TransitedEncoding(TransitedEncoding *);
 568 size_t length_TransitedEncoding(const TransitedEncoding *);
 569 int copy_TransitedEncoding(const TransitedEncoding *, TransitedEncoding *);
 570
 571
 572 /*
 573 Ticket ::= [APPLICATION 1] SEQUENCE {
 574   tkt-vno[0]      INTEGER,
 575   realm[1]        Realm,
 576   sname[2]        PrincipalName,
 577   enc-part[3]     EncryptedData
 578 }
 579 */
 580
 581 typedef struct {
 582     int tkt_vno;
 583     Realm realm;
 584     PrincipalName sname;
 585     EncryptedData enc_part;
 586 } Ticket;
 587
 588 int encode_Ticket(unsigned char *, size_t, const Ticket *, size_t *);
 589 int decode_Ticket(const unsigned char *, size_t, Ticket *, size_t *);
 590 void free_Ticket(Ticket *);
 591 size_t length_Ticket(const Ticket *);
 592 int copy_Ticket(const Ticket *, Ticket *);
 593
 594
 595 /*
 596 EncTicketPart ::= [APPLICATION 3] SEQUENCE {
 597   flags[0]                TicketFlags,
 598   key[1]                  EncryptionKey,
 599   crealm[2]               Realm,
 600   cname[3]                PrincipalName,
 601   transited[4]            TransitedEncoding,
 602   authtime[5]             KerberosTime,
 603   starttime[6]            KerberosTime OPTIONAL,
 604   endtime[7]              KerberosTime,
 605   renew-till[8]           KerberosTime OPTIONAL,
 606   caddr[9]                HostAddresses OPTIONAL,
 607   authorization-data[10]  AuthorizationData OPTIONAL
 608 }
 609 */
 610
 611 typedef struct {
 612     TicketFlags flags;
 613     EncryptionKey key;
 614     Realm crealm;
 615     PrincipalName cname;
 616     TransitedEncoding transited;
 617     KerberosTime authtime;
 618     KerberosTime *starttime;
 619     KerberosTime endtime;
 620     KerberosTime *renew_till;
 621     HostAddresses *caddr;
 622     AuthorizationData *authorization_data;
 623 } EncTicketPart;
 624
 625 int encode_EncTicketPart(unsigned char *, size_t, const EncTicketPart *,
 626                          size_t *);
 627 int decode_EncTicketPart(const unsigned char *, size_t, EncTicketPart *,
 628                          size_t *);
 629 void free_EncTicketPart(EncTicketPart *);
 630 size_t length_EncTicketPart(const EncTicketPart *);
 631 int copy_EncTicketPart(const EncTicketPart *, EncTicketPart *);
 632
 633
 634 /*
 635 Checksum ::= SEQUENCE {
 636   cksumtype[0]    CKSUMTYPE,
 637   checksum[1]     OCTET STRING
 638 }
 639 */
 640
 641 typedef struct Checksum {
 642     CKSUMTYPE cksumtype;
 643     octet_string checksum;
 644 } Checksum;
 645
 646 int encode_Checksum(unsigned char *, size_t, const Checksum *, size_t *);
 647 int decode_Checksum(const unsigned char *, size_t, Checksum *, size_t *);
 648 void free_Checksum(Checksum *);
 649 size_t length_Checksum(const Checksum *);
 650 int copy_Checksum(const Checksum *, Checksum *);
 651
 652
 653 /*
 654 Authenticator ::= [APPLICATION 2] SEQUENCE {
 655   authenticator-vno[0]   INTEGER,
 656   crealm[1]              Realm,
 657   cname[2]               PrincipalName,
 658   cksum[3]               Checksum OPTIONAL,
 659   cusec[4]               INTEGER,
 660   ctime[5]               KerberosTime,
 661   subkey[6]              EncryptionKey OPTIONAL,
 662   seq-number[7]          UNSIGNED OPTIONAL,
 663   authorization-data[8]  AuthorizationData OPTIONAL
 664 }
 665 */
 666
 667 typedef struct {
 668     int authenticator_vno;
 669     Realm crealm;
 670     PrincipalName cname;
 671     Checksum *cksum;
 672     int cusec;
 673     KerberosTime ctime;
 674     EncryptionKey *subkey;
 675     UNSIGNED *seq_number;
 676     AuthorizationData *authorization_data;
 677 } Authenticator;
 678
 679 int encode_Authenticator(unsigned char *, size_t, const Authenticator *,
 680                          size_t *);
 681 int decode_Authenticator(const unsigned char *, size_t, Authenticator *,
 682                          size_t *);
 683 void free_Authenticator(Authenticator *);
 684 size_t length_Authenticator(const Authenticator *);
 685 int copy_Authenticator(const Authenticator *, Authenticator *);
 686
 687
 688 /*
 689 PA-DATA ::= SEQUENCE {
 690   padata-type[1]   PADATA-TYPE,
 691   padata-value[2]  OCTET STRING
 692 }
 693 */
 694
 695 typedef struct PA_DATA {
 696     PADATA_TYPE padata_type;
 697     octet_string padata_value;
 698 } PA_DATA;
 699
 700 int encode_PA_DATA(unsigned char *, size_t, const PA_DATA *, size_t *);
 701 int decode_PA_DATA(const unsigned char *, size_t, PA_DATA *, size_t *);
 702 void free_PA_DATA(PA_DATA *);
 703 size_t length_PA_DATA(const PA_DATA *);
 704 int copy_PA_DATA(const PA_DATA *, PA_DATA *);
 705
 706
 707 /*
 708 ETYPE-INFO-ENTRY ::= SEQUENCE {
 709   etype[0]        ENCTYPE,
 710   salt[1]         OCTET STRING OPTIONAL,
 711   salttype[2]     INTEGER OPTIONAL
 712 }
 713 */
 714
 715 typedef struct ETYPE_INFO_ENTRY {
 716     ENCTYPE etype;
 717     octet_string *salt;
 718     int *salttype;
 719 } ETYPE_INFO_ENTRY;
 720
 721 int encode_ETYPE_INFO_ENTRY(unsigned char *, size_t, const ETYPE_INFO_ENTRY *,
 722                             size_t *);
 723 int decode_ETYPE_INFO_ENTRY(const unsigned char *, size_t, ETYPE_INFO_ENTRY *,
 724                             size_t *);
 725 void free_ETYPE_INFO_ENTRY(ETYPE_INFO_ENTRY *);
 726 size_t length_ETYPE_INFO_ENTRY(const ETYPE_INFO_ENTRY *);
 727 int copy_ETYPE_INFO_ENTRY(const ETYPE_INFO_ENTRY *, ETYPE_INFO_ENTRY *);
 728
 729
 730 /*
 731 ETYPE-INFO ::= SEQUENCE OF ETYPE-INFO-ENTRY
 732 */
 733
 734 typedef struct ETYPE_INFO {
 735     unsigned int len;
 736     ETYPE_INFO_ENTRY *val;
 737 } ETYPE_INFO;
 738
 739 int encode_ETYPE_INFO(unsigned char *, size_t, const ETYPE_INFO *, size_t *);
 740 int decode_ETYPE_INFO(const unsigned char *, size_t, ETYPE_INFO *, size_t *);
 741 void free_ETYPE_INFO(ETYPE_INFO *);
 742 size_t length_ETYPE_INFO(const ETYPE_INFO *);
 743 int copy_ETYPE_INFO(const ETYPE_INFO *, ETYPE_INFO *);
 744
 745
 746 /*
 747 METHOD-DATA ::= SEQUENCE OF PA-DATA
 748 */
 749
 750 typedef struct METHOD_DATA {
 751     unsigned int len;
 752     PA_DATA *val;
 753 } METHOD_DATA;
 754
 755 int encode_METHOD_DATA(unsigned char *, size_t, const METHOD_DATA *,
 756                        size_t *);
 757 int decode_METHOD_DATA(const unsigned char *, size_t, METHOD_DATA *,
 758                        size_t *);
 759 void free_METHOD_DATA(METHOD_DATA *);
 760 size_t length_METHOD_DATA(const METHOD_DATA *);
 761 int copy_METHOD_DATA(const METHOD_DATA *, METHOD_DATA *);
 762
 763
 764 /*
 765 KDC-REQ-BODY ::= SEQUENCE {
 766   kdc-options[0]              KDCOptions,
 767   cname[1]                    PrincipalName OPTIONAL,
 768   realm[2]                    Realm,
 769   sname[3]                    PrincipalName OPTIONAL,
 770   from[4]                     KerberosTime OPTIONAL,
 771   till[5]                     KerberosTime OPTIONAL,
 772   rtime[6]                    KerberosTime OPTIONAL,
 773   nonce[7]                    INTEGER,
 774   etype[8]                    SEQUENCE OF ENCTYPE,
 775   addresses[9]                HostAddresses OPTIONAL,
 776   enc-authorization-data[10]  EncryptedData OPTIONAL,
 777   additional-tickets[11]      SEQUENCE OF Ticket OPTIONAL
 778 }
 779 */
 780
 781 typedef struct KDC_REQ_BODY {
 782     KDCOptions kdc_options;
 783     PrincipalName *cname;
 784     Realm realm;
 785     PrincipalName *sname;
 786     KerberosTime *from;
 787     KerberosTime *till;
 788     KerberosTime *rtime;
 789     int nonce;
 790     struct {
 791         unsigned int len;
 792         ENCTYPE *val;
 793     } etype;
 794     HostAddresses *addresses;
 795     EncryptedData *enc_authorization_data;
 796     struct {
 797         unsigned int len;
 798         Ticket *val;
 799     } *additional_tickets;
 800 } KDC_REQ_BODY;
 801
 802 int encode_KDC_REQ_BODY(unsigned char *, size_t, const KDC_REQ_BODY *,
 803                         size_t *);
 804 int decode_KDC_REQ_BODY(const unsigned char *, size_t, KDC_REQ_BODY *,
 805                         size_t *);
 806 void free_KDC_REQ_BODY(KDC_REQ_BODY *);
 807 size_t length_KDC_REQ_BODY(const KDC_REQ_BODY *);
 808 int copy_KDC_REQ_BODY(const KDC_REQ_BODY *, KDC_REQ_BODY *);
 809
 810
 811 /*
 812 KDC-REQ ::= SEQUENCE {
 813   pvno[1]         INTEGER,
 814   msg-type[2]     MESSAGE-TYPE,
 815   padata[3]       METHOD-DATA OPTIONAL,
 816   req-body[4]     KDC-REQ-BODY
 817 }
 818 */
 819
 820 typedef struct KDC_REQ {
 821     int pvno;
 822     MESSAGE_TYPE msg_type;
 823     METHOD_DATA *padata;
 824     KDC_REQ_BODY req_body;
 825 } KDC_REQ;
 826
 827 int encode_KDC_REQ(unsigned char *, size_t, const KDC_REQ *, size_t *);
 828 int decode_KDC_REQ(const unsigned char *, size_t, KDC_REQ *, size_t *);
 829 void free_KDC_REQ(KDC_REQ *);
 830 size_t length_KDC_REQ(const KDC_REQ *);
 831 int copy_KDC_REQ(const KDC_REQ *, KDC_REQ *);
 832
 833
 834 /*
 835 AS-REQ ::= [APPLICATION 10] KDC-REQ
 836 */
 837
 838 typedef KDC_REQ AS_REQ;
 839
 840 int encode_AS_REQ(unsigned char *, size_t, const AS_REQ *, size_t *);
 841 int decode_AS_REQ(const unsigned char *, size_t, AS_REQ *, size_t *);
 842 void free_AS_REQ(AS_REQ *);
 843 size_t length_AS_REQ(const AS_REQ *);
 844 int copy_AS_REQ(const AS_REQ *, AS_REQ *);
 845
 846
 847 /*
 848 TGS-REQ ::= [APPLICATION 12] KDC-REQ
 849 */
 850
 851 typedef KDC_REQ TGS_REQ;
 852
 853 int encode_TGS_REQ(unsigned char *, size_t, const TGS_REQ *, size_t *);
 854 int decode_TGS_REQ(const unsigned char *, size_t, TGS_REQ *, size_t *);
 855 void free_TGS_REQ(TGS_REQ *);
 856 size_t length_TGS_REQ(const TGS_REQ *);
 857 int copy_TGS_REQ(const TGS_REQ *, TGS_REQ *);
 858
 859
 860 /*
 861 PA-ENC-TS-ENC ::= SEQUENCE {
 862   patimestamp[0]  KerberosTime,
 863   pausec[1]       INTEGER OPTIONAL
 864 }
 865 */
 866
 867 typedef struct PA_ENC_TS_ENC {
 868     KerberosTime patimestamp;
 869     int *pausec;
 870 } PA_ENC_TS_ENC;
 871
 872 int encode_PA_ENC_TS_ENC(unsigned char *, size_t, const PA_ENC_TS_ENC *,
 873                          size_t *);
 874 int decode_PA_ENC_TS_ENC(const unsigned char *, size_t, PA_ENC_TS_ENC *,
 875                          size_t *);
 876 void free_PA_ENC_TS_ENC(PA_ENC_TS_ENC *);
 877 size_t length_PA_ENC_TS_ENC(const PA_ENC_TS_ENC *);
 878 int copy_PA_ENC_TS_ENC(const PA_ENC_TS_ENC *, PA_ENC_TS_ENC *);
 879
 880
 881 /*
 882 KDC-REP ::= SEQUENCE {
 883   pvno[0]         INTEGER,
 884   msg-type[1]     MESSAGE-TYPE,
 885   padata[2]       METHOD-DATA OPTIONAL,
 886   crealm[3]       Realm,
 887   cname[4]        PrincipalName,
 888   ticket[5]       Ticket,
 889   enc-part[6]     EncryptedData
 890 }
 891 */
 892
 893 typedef struct KDC_REP {
 894     int pvno;
 895     MESSAGE_TYPE msg_type;
 896     METHOD_DATA *padata;
 897     Realm crealm;
 898     PrincipalName cname;
 899     Ticket ticket;
 900     EncryptedData enc_part;
 901 } KDC_REP;
 902
 903 int encode_KDC_REP(unsigned char *, size_t, const KDC_REP *, size_t *);
 904 int decode_KDC_REP(const unsigned char *, size_t, KDC_REP *, size_t *);
 905 void free_KDC_REP(KDC_REP *);
 906 size_t length_KDC_REP(const KDC_REP *);
 907 int copy_KDC_REP(const KDC_REP *, KDC_REP *);
 908
 909
 910 /*
 911 AS-REP ::= [APPLICATION 11] KDC-REP
 912 */
 913
 914 typedef KDC_REP AS_REP;
 915
 916 int encode_AS_REP(unsigned char *, size_t, const AS_REP *, size_t *);
 917 int decode_AS_REP(const unsigned char *, size_t, AS_REP *, size_t *);
 918 void free_AS_REP(AS_REP *);
 919 size_t length_AS_REP(const AS_REP *);
 920 int copy_AS_REP(const AS_REP *, AS_REP *);
 921
 922
 923 /*
 924 TGS-REP ::= [APPLICATION 13] KDC-REP
 925 */
 926
 927 typedef KDC_REP TGS_REP;
 928
 929 int encode_TGS_REP(unsigned char *, size_t, const TGS_REP *, size_t *);
 930 int decode_TGS_REP(const unsigned char *, size_t, TGS_REP *, size_t *);
 931 void free_TGS_REP(TGS_REP *);
 932 size_t length_TGS_REP(const TGS_REP *);
 933 int copy_TGS_REP(const TGS_REP *, TGS_REP *);
 934
 935
 936 /*
 937 EncKDCRepPart ::= SEQUENCE {
 938   key[0]             EncryptionKey,
 939   last-req[1]        LastReq,
 940   nonce[2]           INTEGER,
 941   key-expiration[3]  KerberosTime OPTIONAL,
 942   flags[4]           TicketFlags,
 943   authtime[5]        KerberosTime,
 944   starttime[6]       KerberosTime OPTIONAL,
 945   endtime[7]         KerberosTime,
 946   renew-till[8]      KerberosTime OPTIONAL,
 947   srealm[9]          Realm,
 948   sname[10]          PrincipalName,
 949   caddr[11]          HostAddresses OPTIONAL
 950 }
 951 */
 952
 953 typedef struct EncKDCRepPart {
 954     EncryptionKey key;
 955     LastReq last_req;
 956     int nonce;
 957     KerberosTime *key_expiration;
 958     TicketFlags flags;
 959     KerberosTime authtime;
 960     KerberosTime *starttime;
 961     KerberosTime endtime;
 962     KerberosTime *renew_till;
 963     Realm srealm;
 964     PrincipalName sname;
 965     HostAddresses *caddr;
 966 } EncKDCRepPart;
 967
 968 int encode_EncKDCRepPart(unsigned char *, size_t, const EncKDCRepPart *,
 969                          size_t *);
 970 int decode_EncKDCRepPart(const unsigned char *, size_t, EncKDCRepPart *,
 971                          size_t *);
 972 void free_EncKDCRepPart(EncKDCRepPart *);
 973 size_t length_EncKDCRepPart(const EncKDCRepPart *);
 974 int copy_EncKDCRepPart(const EncKDCRepPart *, EncKDCRepPart *);
 975
 976
 977 /*
 978 EncASRepPart ::= [APPLICATION 25] EncKDCRepPart
 979 */
 980
 981 typedef EncKDCRepPart EncASRepPart;
 982
 983 int encode_EncASRepPart(unsigned char *, size_t, const EncASRepPart *,
 984                         size_t *);
 985 int decode_EncASRepPart(const unsigned char *, size_t, EncASRepPart *,
 986                         size_t *);
 987 void free_EncASRepPart(EncASRepPart *);
 988 size_t length_EncASRepPart(const EncASRepPart *);
 989 int copy_EncASRepPart(const EncASRepPart *, EncASRepPart *);
 990
 991
 992 /*
 993 EncTGSRepPart ::= [APPLICATION 26] EncKDCRepPart
 994 */
 995
 996 typedef EncKDCRepPart EncTGSRepPart;
 997
 998 int encode_EncTGSRepPart(unsigned char *, size_t, const EncTGSRepPart *,
 999                          size_t *);
1000 int decode_EncTGSRepPart(const unsigned char *, size_t, EncTGSRepPart *,
1001                          size_t *);
1002 void free_EncTGSRepPart(EncTGSRepPart *);
1003 size_t length_EncTGSRepPart(const EncTGSRepPart *);
1004 int copy_EncTGSRepPart(const EncTGSRepPart *, EncTGSRepPart *);
1005
1006
1007 /*
1008 AP-REQ ::= [APPLICATION 14] SEQUENCE {
1009   pvno[0]           INTEGER,
1010   msg-type[1]       MESSAGE-TYPE,
1011   ap-options[2]     APOptions,
1012   ticket[3]         Ticket,
1013   authenticator[4]  EncryptedData
1014 }
1015 */
1016
1017 typedef struct {
1018     int pvno;
1019     MESSAGE_TYPE msg_type;
1020     APOptions ap_options;
1021     Ticket ticket;
1022     EncryptedData authenticator;
1023 } AP_REQ;
1024
1025 int encode_AP_REQ(unsigned char *, size_t, const AP_REQ *, size_t *);
1026 int decode_AP_REQ(const unsigned char *, size_t, AP_REQ *, size_t *);
1027 void free_AP_REQ(AP_REQ *);
1028 size_t length_AP_REQ(const AP_REQ *);
1029 int copy_AP_REQ(const AP_REQ *, AP_REQ *);
1030
1031
1032 /*
1033 AP-REP ::= [APPLICATION 15] SEQUENCE {
1034   pvno[0]         INTEGER,
1035   msg-type[1]     MESSAGE-TYPE,
1036   enc-part[2]     EncryptedData
1037 }
1038 */
1039
1040 typedef struct {
1041     int pvno;
1042     MESSAGE_TYPE msg_type;
1043     EncryptedData enc_part;
1044 } AP_REP;
1045
1046 int encode_AP_REP(unsigned char *, size_t, const AP_REP *, size_t *);
1047 int decode_AP_REP(const unsigned char *, size_t, AP_REP *, size_t *);
1048 void free_AP_REP(AP_REP *);
1049 size_t length_AP_REP(const AP_REP *);
1050 int copy_AP_REP(const AP_REP *, AP_REP *);
1051
1052
1053 /*
1054 EncAPRepPart ::= [APPLICATION 27] SEQUENCE {
1055   ctime[0]        KerberosTime,
1056   cusec[1]        INTEGER,
1057   subkey[2]       EncryptionKey OPTIONAL,
1058   seq-number[3]   UNSIGNED OPTIONAL
1059 }
1060 */
1061
1062 typedef struct {
1063     KerberosTime ctime;
1064     int cusec;
1065     EncryptionKey *subkey;
1066     UNSIGNED *seq_number;
1067 } EncAPRepPart;
1068
1069 int encode_EncAPRepPart(unsigned char *, size_t, const EncAPRepPart *,
1070                         size_t *);
1071 int decode_EncAPRepPart(const unsigned char *, size_t, EncAPRepPart *,
1072                         size_t *);
1073 void free_EncAPRepPart(EncAPRepPart *);
1074 size_t length_EncAPRepPart(const EncAPRepPart *);
1075 int copy_EncAPRepPart(const EncAPRepPart *, EncAPRepPart *);
1076
1077
1078 /*
1079 KRB-SAFE-BODY ::= SEQUENCE {
1080   user-data[0]    OCTET STRING,
1081   timestamp[1]    KerberosTime OPTIONAL,
1082   usec[2]         INTEGER OPTIONAL,
1083   seq-number[3]   UNSIGNED OPTIONAL,
1084   s-address[4]    HostAddress OPTIONAL,
1085   r-address[5]    HostAddress OPTIONAL
1086 }
1087 */
1088
1089 typedef struct KRB_SAFE_BODY {
1090     octet_string user_data;
1091     KerberosTime *timestamp;
1092     int *usec;
1093     UNSIGNED *seq_number;
1094     HostAddress *s_address;
1095     HostAddress *r_address;
1096 } KRB_SAFE_BODY;
1097
1098 int encode_KRB_SAFE_BODY(unsigned char *, size_t, const KRB_SAFE_BODY *,
1099                          size_t *);
1100 int decode_KRB_SAFE_BODY(const unsigned char *, size_t, KRB_SAFE_BODY *,
1101                          size_t *);
1102 void free_KRB_SAFE_BODY(KRB_SAFE_BODY *);
1103 size_t length_KRB_SAFE_BODY(const KRB_SAFE_BODY *);
1104 int copy_KRB_SAFE_BODY(const KRB_SAFE_BODY *, KRB_SAFE_BODY *);
1105
1106
1107 /*
1108 KRB-SAFE ::= [APPLICATION 20] SEQUENCE {
1109   pvno[0]         INTEGER,
1110   msg-type[1]     MESSAGE-TYPE,
1111   safe-body[2]    KRB-SAFE-BODY,
1112   cksum[3]        Checksum
1113 }
1114 */
1115
1116 typedef struct {
1117     int pvno;
1118     MESSAGE_TYPE msg_type;
1119     KRB_SAFE_BODY safe_body;
1120     Checksum cksum;
1121 } KRB_SAFE;
1122
1123 int encode_KRB_SAFE(unsigned char *, size_t, const KRB_SAFE *, size_t *);
1124 int decode_KRB_SAFE(const unsigned char *, size_t, KRB_SAFE *, size_t *);
1125 void free_KRB_SAFE(KRB_SAFE *);
1126 size_t length_KRB_SAFE(const KRB_SAFE *);
1127 int copy_KRB_SAFE(const KRB_SAFE *, KRB_SAFE *);
1128
1129
1130 /*
1131 KRB-PRIV ::= [APPLICATION 21] SEQUENCE {
1132   pvno[0]         INTEGER,
1133   msg-type[1]     MESSAGE-TYPE,
1134   enc-part[3]     EncryptedData
1135 }
1136 */
1137
1138 typedef struct {
1139     int pvno;
1140     MESSAGE_TYPE msg_type;
1141     EncryptedData enc_part;
1142 } KRB_PRIV;
1143
1144 int encode_KRB_PRIV(unsigned char *, size_t, const KRB_PRIV *, size_t *);
1145 int decode_KRB_PRIV(const unsigned char *, size_t, KRB_PRIV *, size_t *);
1146 void free_KRB_PRIV(KRB_PRIV *);
1147 size_t length_KRB_PRIV(const KRB_PRIV *);
1148 int copy_KRB_PRIV(const KRB_PRIV *, KRB_PRIV *);
1149
1150
1151 /*
1152 EncKrbPrivPart ::= [APPLICATION 28] SEQUENCE {
1153   user-data[0]    OCTET STRING,
1154   timestamp[1]    KerberosTime OPTIONAL,
1155   usec[2]         INTEGER OPTIONAL,
1156   seq-number[3]   UNSIGNED OPTIONAL,
1157   s-address[4]    HostAddress OPTIONAL,
1158   r-address[5]    HostAddress OPTIONAL
1159 }
1160 */
1161
1162 typedef struct {
1163     octet_string user_data;
1164     KerberosTime *timestamp;
1165     int *usec;
1166     UNSIGNED *seq_number;
1167     HostAddress *s_address;
1168     HostAddress *r_address;
1169 } EncKrbPrivPart;
1170
1171 int encode_EncKrbPrivPart(unsigned char *, size_t, const EncKrbPrivPart *,
1172                           size_t *);
1173 int decode_EncKrbPrivPart(const unsigned char *, size_t, EncKrbPrivPart *,
1174                           size_t *);
1175 void free_EncKrbPrivPart(EncKrbPrivPart *);
1176 size_t length_EncKrbPrivPart(const EncKrbPrivPart *);
1177 int copy_EncKrbPrivPart(const EncKrbPrivPart *, EncKrbPrivPart *);
1178
1179
1180 /*
1181 KRB-CRED ::= [APPLICATION 22] SEQUENCE {
1182   pvno[0]         INTEGER,
1183   msg-type[1]     MESSAGE-TYPE,
1184   tickets[2]      SEQUENCE OF Ticket,
1185   enc-part[3]     EncryptedData
1186 }
1187 */
1188
1189 typedef struct {
1190     int pvno;
1191     MESSAGE_TYPE msg_type;
1192     struct {
1193         unsigned int len;
1194         Ticket *val;
1195     } tickets;
1196     EncryptedData enc_part;
1197 } KRB_CRED;
1198
1199 int encode_KRB_CRED(unsigned char *, size_t, const KRB_CRED *, size_t *);
1200 int decode_KRB_CRED(const unsigned char *, size_t, KRB_CRED *, size_t *);
1201 void free_KRB_CRED(KRB_CRED *);
1202 size_t length_KRB_CRED(const KRB_CRED *);
1203 int copy_KRB_CRED(const KRB_CRED *, KRB_CRED *);
1204
1205
1206 /*
1207 KrbCredInfo ::= SEQUENCE {
1208   key[0]          EncryptionKey,
1209   prealm[1]       Realm OPTIONAL,
1210   pname[2]        PrincipalName OPTIONAL,
1211   flags[3]        TicketFlags OPTIONAL,
1212   authtime[4]     KerberosTime OPTIONAL,
1213   starttime[5]    KerberosTime OPTIONAL,
1214   endtime[6]      KerberosTime OPTIONAL,
1215   renew-till[7]   KerberosTime OPTIONAL,
1216   srealm[8]       Realm OPTIONAL,
1217   sname[9]        PrincipalName OPTIONAL,
1218   caddr[10]       HostAddresses OPTIONAL
1219 }
1220 */
1221
1222 typedef struct KrbCredInfo {
1223     EncryptionKey key;
1224     Realm *prealm;
1225     PrincipalName *pname;
1226     TicketFlags *flags;
1227     KerberosTime *authtime;
1228     KerberosTime *starttime;
1229     KerberosTime *endtime;
1230     KerberosTime *renew_till;
1231     Realm *srealm;
1232     PrincipalName *sname;
1233     HostAddresses *caddr;
1234 } KrbCredInfo;
1235
1236 int encode_KrbCredInfo(unsigned char *, size_t, const KrbCredInfo *,
1237                        size_t *);
1238 int decode_KrbCredInfo(const unsigned char *, size_t, KrbCredInfo *,
1239                        size_t *);
1240 void free_KrbCredInfo(KrbCredInfo *);
1241 size_t length_KrbCredInfo(const KrbCredInfo *);
1242 int copy_KrbCredInfo(const KrbCredInfo *, KrbCredInfo *);
1243
1244
1245 /*
1246 EncKrbCredPart ::= [APPLICATION 29] SEQUENCE {
1247   ticket-info[0]  SEQUENCE OF KrbCredInfo,
1248   nonce[1]        INTEGER OPTIONAL,
1249   timestamp[2]    KerberosTime OPTIONAL,
1250   usec[3]         INTEGER OPTIONAL,
1251   s-address[4]    HostAddress OPTIONAL,
1252   r-address[5]    HostAddress OPTIONAL
1253 }
1254 */
1255
1256 typedef struct {
1257     struct {
1258         unsigned int len;
1259         KrbCredInfo *val;
1260     } ticket_info;
1261     int *nonce;
1262     KerberosTime *timestamp;
1263     int *usec;
1264     HostAddress *s_address;
1265     HostAddress *r_address;
1266 } EncKrbCredPart;
1267
1268 int encode_EncKrbCredPart(unsigned char *, size_t, const EncKrbCredPart *,
1269                           size_t *);
1270 int decode_EncKrbCredPart(const unsigned char *, size_t, EncKrbCredPart *,
1271                           size_t *);
1272 void free_EncKrbCredPart(EncKrbCredPart *);
1273 size_t length_EncKrbCredPart(const EncKrbCredPart *);
1274 int copy_EncKrbCredPart(const EncKrbCredPart *, EncKrbCredPart *);
1275
1276
1277 /*
1278 KRB-ERROR ::= [APPLICATION 30] SEQUENCE {
1279   pvno[0]         INTEGER,
1280   msg-type[1]     MESSAGE-TYPE,
1281   ctime[2]        KerberosTime OPTIONAL,
1282   cusec[3]        INTEGER OPTIONAL,
1283   stime[4]        KerberosTime,
1284   susec[5]        INTEGER,
1285   error-code[6]   INTEGER,
1286   crealm[7]       Realm OPTIONAL,
1287   cname[8]        PrincipalName OPTIONAL,
1288   realm[9]        Realm,
1289   sname[10]       PrincipalName,
1290   e-text[11]      GeneralString OPTIONAL,
1291   e-data[12]      OCTET STRING OPTIONAL
1292 }
1293 */
1294
1295 typedef struct {
1296     int pvno;
1297     MESSAGE_TYPE msg_type;
1298     KerberosTime *ctime;
1299     int *cusec;
1300     KerberosTime stime;
1301     int susec;
1302     int error_code;
1303     Realm *crealm;
1304     PrincipalName *cname;
1305     Realm realm;
1306     PrincipalName sname;
1307     general_string *e_text;
1308     octet_string *e_data;
1309 } KRB_ERROR;
1310
1311 int encode_KRB_ERROR(unsigned char *, size_t, const KRB_ERROR *, size_t *);
1312 int decode_KRB_ERROR(const unsigned char *, size_t, KRB_ERROR *, size_t *);
1313 void free_KRB_ERROR(KRB_ERROR *);
1314 size_t length_KRB_ERROR(const KRB_ERROR *);
1315 int copy_KRB_ERROR(const KRB_ERROR *, KRB_ERROR *);
1316
1317
1318 enum { pvno = 5 };
1319
1320 enum { DOMAIN_X500_COMPRESS = 1 };
1321
1322 #endif /* __krb5_asn1_h__ */