src/tests/asn.1/krb5_encode_test.c

   1 /* -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil -*- */
   2 /* tests/asn.1/krb5_encode_test.c */
   3 /*
   4  * Copyright (C) 1994 by the Massachusetts Institute of Technology.
   5  * All rights reserved.
   6  *
   7  * Export of this software from the United States of America may
   8  *   require a specific license from the United States Government.
   9  *   It is the responsibility of any person or organization contemplating
  10  *   export to obtain such a license before exporting.
  11  *
  12  * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
  13  * distribute this software and its documentation for any purpose and
  14  * without fee is hereby granted, provided that the above copyright
  15  * notice appear in all copies and that both that copyright notice and
  16  * this permission notice appear in supporting documentation, and that
  17  * the name of M.I.T. not be used in advertising or publicity pertaining
  18  * to distribution of the software without specific, written prior
  19  * permission.  Furthermore if you modify this software you must label
  20  * your software as modified software and not distribute it in such a
  21  * fashion that it might be confused with the original M.I.T. software.
  22  * M.I.T. makes no representations about the suitability of
  23  * this software for any purpose.  It is provided "as is" without express
  24  * or implied warranty.
  25  */
  26
  27 #include <stdio.h>
  28 #include "k5-int.h"
  29 #include "com_err.h"
  30 #include "utility.h"
  31
  32 #include "ktest.h"
  33 #include <string.h>
  34
  35 #include "debug.h"
  36
  37 extern int current_appl_type;
  38
  39 krb5_context test_context;
  40 int error_count = 0;
  41 int do_trval = 0;
  42 int trval2();
  43
  44 static void encoder_print_results(code, typestring, description)
  45     krb5_data *code;
  46     char        *typestring;
  47     char        *description;
  48 {
  49     char        *code_string = NULL;
  50     krb5_error_code     retval;
  51     int r, rlen;
  52
  53     if (do_trval) {
  54         printf("encode_krb5_%s%s:\n", typestring, description);
  55         r = trval2(stdout, code->data, code->length, 0, &rlen);
  56         printf("\n\n");
  57         if (rlen < 0 || (unsigned int) rlen != code->length) {
  58             printf("Error: length mismatch: was %d, parsed %d\n",
  59                    code->length, rlen);
  60             exit(1);
  61         }
  62         if (r != 0) {
  63             printf("Error: Return from trval2 is %d.\n", r);
  64             exit(1);
  65         }
  66         current_appl_type = -1; /* Reset type */
  67     } else {
  68         retval = asn1_krb5_data_unparse(code,&(code_string));
  69         if (retval) {
  70             com_err("krb5_encode_test", retval ,
  71                     "while unparsing %s", typestring);
  72             exit(1);
  73         }
  74         printf("encode_krb5_%s%s: %s\n", typestring, description,
  75                code_string);
  76         free(code_string);
  77     }
  78     ktest_destroy_data(&code);
  79 }
  80
  81 static void PRS(argc, argv)
  82     int argc;
  83     char        **argv;
  84 {
  85     extern char *optarg;
  86     int optchar;
  87     extern int print_types, print_krb5_types, print_id_and_len,
  88         print_constructed_length, print_skip_context,
  89         print_skip_tagnum, print_context_shortcut;
  90
  91     while ((optchar = getopt(argc, argv, "tp:")) != -1) {
  92         switch(optchar) {
  93         case 't':
  94             do_trval = 1;
  95             break;
  96         case 'p':
  97             sample_principal_name = optarg;
  98             break;
  99         case '?':
 100         default:
 101             fprintf(stderr, "Usage: %s [-t] [-p principal]\n",
 102                     argv[0]);
 103             exit(1);
 104         }
 105     }
 106     print_types = 1;
 107     print_krb5_types = 1;
 108     print_id_and_len = 0;
 109     print_constructed_length = 0;
 110     print_skip_context = 1;
 111     print_skip_tagnum = 1;
 112     print_context_shortcut = 1;
 113 }
 114
 115 int
 116 main(argc, argv)
 117     int argc;
 118     char        **argv;
 119 {
 120     krb5_data *code;
 121     krb5_error_code retval;
 122
 123     PRS(argc, argv);
 124
 125     retval = krb5_init_context(&test_context);
 126     if (retval) {
 127         com_err(argv[0], retval, "while initializing krb5");
 128         exit(1);
 129     }
 130     init_access(argv[0]);
 131
 132 #define setup(value,type,typestring,constructor)                        \
 133     retval = constructor(&(value));                                     \
 134     if (retval) {                                                       \
 135         com_err("krb5_encode_test", retval, "while making sample %s", typestring); \
 136         exit(1);                                                        \
 137     }
 138
 139 #define encode_run(value,type,typestring,description,encoder)           \
 140     retval = encoder(&(value),&(code));                                 \
 141     if (retval) {                                                       \
 142         com_err("krb5_encode_test", retval,"while encoding %s", typestring); \
 143         exit(1);                                                        \
 144     }                                                                   \
 145     encoder_print_results(code, typestring, description);
 146
 147     /****************************************************************/
 148     /* encode_krb5_authenticator */
 149     {
 150         krb5_authenticator authent;
 151         setup(authent,authenticator,"authenticator",ktest_make_sample_authenticator);
 152
 153         encode_run(authent,authenticator,"authenticator","",encode_krb5_authenticator);
 154
 155         ktest_destroy_checksum(&(authent.checksum));
 156         ktest_destroy_keyblock(&(authent.subkey));
 157         authent.seq_number = 0;
 158         ktest_empty_authorization_data(authent.authorization_data);
 159         encode_run(authent,authenticator,"authenticator","(optionals empty)",encode_krb5_authenticator);
 160
 161         ktest_destroy_authorization_data(&(authent.authorization_data));
 162         encode_run(authent,authenticator,"authenticator","(optionals NULL)",encode_krb5_authenticator);
 163         ktest_empty_authenticator(&authent);
 164     }
 165
 166     /****************************************************************/
 167     /* encode_krb5_ticket */
 168     {
 169         krb5_ticket tkt;
 170         setup(tkt,ticket,"ticket",ktest_make_sample_ticket);
 171         encode_run(tkt,ticket,"ticket","",encode_krb5_ticket);
 172         ktest_empty_ticket(&tkt);
 173     }
 174
 175     /****************************************************************/
 176     /* encode_krb5_encryption_key */
 177     {
 178         krb5_keyblock keyblk;
 179         setup(keyblk,keyblock,"keyblock",ktest_make_sample_keyblock);
 180         current_appl_type = 1005;
 181         encode_run(keyblk,keyblock,"keyblock","",encode_krb5_encryption_key);
 182         ktest_empty_keyblock(&keyblk);
 183     }
 184
 185     /****************************************************************/
 186     /* encode_krb5_enc_tkt_part */
 187     {
 188         krb5_ticket tkt;
 189         memset(&tkt, 0, sizeof(krb5_ticket));
 190         tkt.enc_part2 = (krb5_enc_tkt_part*)calloc(1,sizeof(krb5_enc_tkt_part));
 191         if (tkt.enc_part2 == NULL) com_err("allocating enc_tkt_part",errno,"");
 192         setup(*(tkt.enc_part2),enc_tkt_part,"enc_tkt_part",ktest_make_sample_enc_tkt_part);
 193
 194         encode_run(*(tkt.enc_part2),enc_tkt_part,"enc_tkt_part","",encode_krb5_enc_tkt_part);
 195
 196         tkt.enc_part2->times.starttime = 0;
 197         tkt.enc_part2->times.renew_till = 0;
 198         ktest_destroy_address(&(tkt.enc_part2->caddrs[1]));
 199         ktest_destroy_address(&(tkt.enc_part2->caddrs[0]));
 200         ktest_destroy_authdata(&(tkt.enc_part2->authorization_data[1]));
 201         ktest_destroy_authdata(&(tkt.enc_part2->authorization_data[0]));
 202
 203         /* ISODE version fails on the empty caddrs field */
 204         ktest_destroy_addresses(&(tkt.enc_part2->caddrs));
 205         ktest_destroy_authorization_data(&(tkt.enc_part2->authorization_data));
 206
 207         encode_run(*(tkt.enc_part2),enc_tkt_part,"enc_tkt_part","(optionals NULL)",encode_krb5_enc_tkt_part);
 208         ktest_empty_ticket(&tkt);
 209     }
 210
 211     /****************************************************************/
 212     /* encode_krb5_enc_kdc_rep_part */
 213     {
 214         krb5_kdc_rep kdcr;
 215
 216         memset(&kdcr, 0, sizeof(kdcr));
 217
 218         kdcr.enc_part2 = (krb5_enc_kdc_rep_part*)
 219             calloc(1,sizeof(krb5_enc_kdc_rep_part));
 220         if (kdcr.enc_part2 == NULL) com_err("allocating enc_kdc_rep_part",errno,"");
 221         setup(*(kdcr.enc_part2),enc_kdc_rep_part,"enc_kdc_rep_part",ktest_make_sample_enc_kdc_rep_part);
 222
 223         encode_run(*(kdcr.enc_part2),enc_kdc_rep_part,"enc_kdc_rep_part","",encode_krb5_enc_kdc_rep_part);
 224
 225         kdcr.enc_part2->key_exp = 0;
 226         kdcr.enc_part2->times.starttime = 0;
 227         kdcr.enc_part2->flags &= ~TKT_FLG_RENEWABLE;
 228         ktest_destroy_addresses(&(kdcr.enc_part2->caddrs));
 229
 230         encode_run(*(kdcr.enc_part2),enc_kdc_rep_part,"enc_kdc_rep_part","(optionals NULL)",encode_krb5_enc_kdc_rep_part);
 231
 232         ktest_empty_kdc_rep(&kdcr);
 233     }
 234
 235     /****************************************************************/
 236     /* encode_krb5_as_rep */
 237     {
 238         krb5_kdc_rep kdcr;
 239         setup(kdcr,kdc_rep,"kdc_rep",ktest_make_sample_kdc_rep);
 240
 241 /*    kdcr.msg_type = KRB5_TGS_REP;
 242       test(encode_krb5_as_rep(&kdcr,&code) == KRB5_BADMSGTYPE,
 243       "encode_krb5_as_rep type check\n");
 244       ktest_destroy_data(&code);*/
 245
 246         kdcr.msg_type = KRB5_AS_REP;
 247         encode_run(kdcr,as_rep,"as_rep","",encode_krb5_as_rep);
 248
 249         ktest_destroy_pa_data_array(&(kdcr.padata));
 250         encode_run(kdcr,as_rep,"as_rep","(optionals NULL)",encode_krb5_as_rep);
 251
 252         ktest_empty_kdc_rep(&kdcr);
 253
 254     }
 255
 256     /****************************************************************/
 257     /* encode_krb5_tgs_rep */
 258     {
 259         krb5_kdc_rep kdcr;
 260         setup(kdcr,kdc_rep,"kdc_rep",ktest_make_sample_kdc_rep);
 261
 262 /*    kdcr.msg_type = KRB5_AS_REP;
 263       test(encode_krb5_tgs_rep(&kdcr,&code) == KRB5_BADMSGTYPE,
 264       "encode_krb5_tgs_rep type check\n");*/
 265
 266         kdcr.msg_type = KRB5_TGS_REP;
 267         encode_run(kdcr,tgs_rep,"tgs_rep","",encode_krb5_tgs_rep);
 268
 269         ktest_destroy_pa_data_array(&(kdcr.padata));
 270         encode_run(kdcr,tgs_rep,"tgs_rep","(optionals NULL)",encode_krb5_tgs_rep);
 271
 272         ktest_empty_kdc_rep(&kdcr);
 273
 274     }
 275
 276     /****************************************************************/
 277     /* encode_krb5_ap_req */
 278     {
 279         krb5_ap_req apreq;
 280         setup(apreq,ap_req,"ap_req",ktest_make_sample_ap_req);
 281         encode_run(apreq,ap_req,"ap_req","",encode_krb5_ap_req);
 282         ktest_empty_ap_req(&apreq);
 283     }
 284
 285     /****************************************************************/
 286     /* encode_krb5_ap_rep */
 287     {
 288         krb5_ap_rep aprep;
 289         setup(aprep,ap_rep,"ap_rep",ktest_make_sample_ap_rep);
 290         encode_run(aprep,ap_rep,"ap_rep","",encode_krb5_ap_rep);
 291         ktest_empty_ap_rep(&aprep);
 292     }
 293
 294     /****************************************************************/
 295     /* encode_krb5_ap_rep_enc_part */
 296     {
 297         krb5_ap_rep_enc_part apenc;
 298         setup(apenc,ap_rep_enc_part,"ap_rep_enc_part",ktest_make_sample_ap_rep_enc_part);
 299         encode_run(apenc,ap_rep_enc_part,"ap_rep_enc_part","",encode_krb5_ap_rep_enc_part);
 300
 301         ktest_destroy_keyblock(&(apenc.subkey));
 302         apenc.seq_number = 0;
 303         encode_run(apenc,ap_rep_enc_part,"ap_rep_enc_part","(optionals NULL)",encode_krb5_ap_rep_enc_part);
 304         ktest_empty_ap_rep_enc_part(&apenc);
 305     }
 306
 307     /****************************************************************/
 308     /* encode_krb5_as_req */
 309     {
 310         krb5_kdc_req asreq;
 311         setup(asreq,kdc_req,"kdc_req",ktest_make_sample_kdc_req);
 312         asreq.msg_type = KRB5_AS_REQ;
 313         asreq.kdc_options &= ~KDC_OPT_ENC_TKT_IN_SKEY;
 314         encode_run(asreq,as_req,"as_req","",encode_krb5_as_req);
 315
 316         ktest_destroy_pa_data_array(&(asreq.padata));
 317         ktest_destroy_principal(&(asreq.client));
 318 #ifndef ISODE_SUCKS
 319         ktest_destroy_principal(&(asreq.server));
 320 #endif
 321         asreq.kdc_options |= KDC_OPT_ENC_TKT_IN_SKEY;
 322         asreq.from = 0;
 323         asreq.rtime = 0;
 324         ktest_destroy_addresses(&(asreq.addresses));
 325         ktest_destroy_enc_data(&(asreq.authorization_data));
 326         encode_run(asreq,as_req,"as_req","(optionals NULL except second_ticket)",encode_krb5_as_req);
 327         ktest_destroy_sequence_of_ticket(&(asreq.second_ticket));
 328 #ifndef ISODE_SUCKS
 329         ktest_make_sample_principal(&(asreq.server));
 330 #endif
 331         asreq.kdc_options &= ~KDC_OPT_ENC_TKT_IN_SKEY;
 332         encode_run(asreq,as_req,"as_req","(optionals NULL except server)",encode_krb5_as_req);
 333         ktest_empty_kdc_req(&asreq);
 334     }
 335
 336     /****************************************************************/
 337     /* encode_krb5_tgs_req */
 338     {
 339         krb5_kdc_req tgsreq;
 340         setup(tgsreq,kdc_req,"kdc_req",ktest_make_sample_kdc_req);
 341         tgsreq.msg_type = KRB5_TGS_REQ;
 342         tgsreq.kdc_options &= ~KDC_OPT_ENC_TKT_IN_SKEY;
 343         encode_run(tgsreq,tgs_req,"tgs_req","",encode_krb5_tgs_req);
 344
 345         ktest_destroy_pa_data_array(&(tgsreq.padata));
 346         ktest_destroy_principal(&(tgsreq.client));
 347 #ifndef ISODE_SUCKS
 348         ktest_destroy_principal(&(tgsreq.server));
 349 #endif
 350         tgsreq.kdc_options |= KDC_OPT_ENC_TKT_IN_SKEY;
 351         tgsreq.from = 0;
 352         tgsreq.rtime = 0;
 353         ktest_destroy_addresses(&(tgsreq.addresses));
 354         ktest_destroy_enc_data(&(tgsreq.authorization_data));
 355         encode_run(tgsreq,tgs_req,"tgs_req","(optionals NULL except second_ticket)",encode_krb5_tgs_req);
 356
 357         ktest_destroy_sequence_of_ticket(&(tgsreq.second_ticket));
 358 #ifndef ISODE_SUCKS
 359         ktest_make_sample_principal(&(tgsreq.server));
 360 #endif
 361         tgsreq.kdc_options &= ~KDC_OPT_ENC_TKT_IN_SKEY;
 362         encode_run(tgsreq,tgs_req,"tgs_req","(optionals NULL except server)",encode_krb5_tgs_req);
 363
 364         ktest_empty_kdc_req(&tgsreq);
 365     }
 366
 367     /****************************************************************/
 368     /* encode_krb5_kdc_req_body */
 369     {
 370         krb5_kdc_req kdcrb;
 371         memset(&kdcrb, 0, sizeof(kdcrb));
 372         setup(kdcrb,kdc_req_body,"kdc_req_body",ktest_make_sample_kdc_req_body);
 373         kdcrb.kdc_options &= ~KDC_OPT_ENC_TKT_IN_SKEY;
 374         current_appl_type = 1007;       /* Force interpretation as kdc-req-body */
 375         encode_run(kdcrb,kdc_req_body,"kdc_req_body","",encode_krb5_kdc_req_body);
 376
 377         ktest_destroy_principal(&(kdcrb.client));
 378 #ifndef ISODE_SUCKS
 379         ktest_destroy_principal(&(kdcrb.server));
 380 #endif
 381         kdcrb.kdc_options |= KDC_OPT_ENC_TKT_IN_SKEY;
 382         kdcrb.from = 0;
 383         kdcrb.rtime = 0;
 384         ktest_destroy_addresses(&(kdcrb.addresses));
 385         ktest_destroy_enc_data(&(kdcrb.authorization_data));
 386         current_appl_type = 1007;       /* Force interpretation as kdc-req-body */
 387         encode_run(kdcrb,kdc_req_body,"kdc_req_body","(optionals NULL except second_ticket)",encode_krb5_kdc_req_body);
 388
 389         ktest_destroy_sequence_of_ticket(&(kdcrb.second_ticket));
 390 #ifndef ISODE_SUCKS
 391         ktest_make_sample_principal(&(kdcrb.server));
 392 #endif
 393         kdcrb.kdc_options &= ~KDC_OPT_ENC_TKT_IN_SKEY;
 394         current_appl_type = 1007;       /* Force interpretation as kdc-req-body */
 395         encode_run(kdcrb,kdc_req_body,"kdc_req_body","(optionals NULL except server)",encode_krb5_kdc_req_body);
 396
 397         ktest_empty_kdc_req(&kdcrb);
 398     }
 399
 400     /****************************************************************/
 401     /* encode_krb5_safe */
 402     {
 403         krb5_safe s;
 404         setup(s,safe,"safe",ktest_make_sample_safe);
 405         encode_run(s,safe,"safe","",encode_krb5_safe);
 406
 407         s.timestamp = 0;
 408         /* s.usec should be opted out by the timestamp */
 409         s.seq_number = 0;
 410         ktest_destroy_address(&(s.r_address));
 411         encode_run(s,safe,"safe","(optionals NULL)",encode_krb5_safe);
 412
 413         ktest_empty_safe(&s);
 414     }
 415
 416     /****************************************************************/
 417     /* encode_krb5_priv */
 418     {
 419         krb5_priv p;
 420         setup(p,priv,"priv",ktest_make_sample_priv);
 421         encode_run(p,priv,"priv","",encode_krb5_priv);
 422         ktest_empty_priv(&p);
 423     }
 424
 425     /****************************************************************/
 426     /* encode_krb5_enc_priv_part */
 427     {
 428         krb5_priv_enc_part ep;
 429         setup(ep,priv_enc_part,"priv_enc_part",ktest_make_sample_priv_enc_part);
 430         encode_run(ep,enc_priv_part,"enc_priv_part","",encode_krb5_enc_priv_part);
 431
 432         ep.timestamp = 0;
 433         /* ep.usec should be opted out along with timestamp */
 434         ep.seq_number = 0;
 435         ktest_destroy_address(&(ep.r_address));
 436         encode_run(ep,enc_priv_part,"enc_priv_part","(optionals NULL)",encode_krb5_enc_priv_part);
 437
 438         ktest_empty_priv_enc_part(&ep);
 439     }
 440
 441     /****************************************************************/
 442     /* encode_krb5_cred */
 443     {
 444         krb5_cred c;
 445         setup(c,cred,"cred",ktest_make_sample_cred);
 446         encode_run(c,cred,"cred","",encode_krb5_cred);
 447         ktest_empty_cred(&c);
 448     }
 449
 450     /****************************************************************/
 451     /* encode_krb5_enc_cred_part */
 452     {
 453         krb5_cred_enc_part cep;
 454         setup(cep,cred_enc_part,"cred_enc_part",ktest_make_sample_cred_enc_part);
 455         encode_run(cep,enc_cred_part,"enc_cred_part","",encode_krb5_enc_cred_part);
 456
 457         ktest_destroy_principal(&(cep.ticket_info[0]->client));
 458         ktest_destroy_principal(&(cep.ticket_info[0]->server));
 459         cep.ticket_info[0]->flags = 0;
 460         cep.ticket_info[0]->times.authtime = 0;
 461         cep.ticket_info[0]->times.starttime = 0;
 462         cep.ticket_info[0]->times.endtime = 0;
 463         cep.ticket_info[0]->times.renew_till = 0;
 464         ktest_destroy_addresses(&(cep.ticket_info[0]->caddrs));
 465         cep.nonce = 0;
 466         cep.timestamp = 0;
 467         ktest_destroy_address(&(cep.s_address));
 468         ktest_destroy_address(&(cep.r_address));
 469         encode_run(cep,enc_cred_part,"enc_cred_part","(optionals NULL)",encode_krb5_enc_cred_part);
 470
 471         ktest_empty_cred_enc_part(&cep);
 472     }
 473
 474     /****************************************************************/
 475     /* encode_krb5_error */
 476     {
 477         krb5_error kerr;
 478         setup(kerr,error,"error",ktest_make_sample_error);
 479         encode_run(kerr,error,"error","",encode_krb5_error);
 480
 481         kerr.ctime = 0;
 482         ktest_destroy_principal(&(kerr.client));
 483         ktest_empty_data(&(kerr.text));
 484         ktest_empty_data(&(kerr.e_data));
 485         encode_run(kerr,error,"error","(optionals NULL)",encode_krb5_error);
 486
 487         ktest_empty_error(&kerr);
 488     }
 489
 490     /****************************************************************/
 491     /* encode_krb5_authdata */
 492     {
 493         krb5_authdata **ad;
 494         setup(ad,authorization_data,"authorization_data",ktest_make_sample_authorization_data);
 495
 496         retval = encode_krb5_authdata(ad,&(code));
 497         if (retval) {
 498             com_err("encoding authorization_data",retval,"");
 499             exit(1);
 500         }
 501         current_appl_type = 1004;       /* Force type to be authdata */
 502         encoder_print_results(code, "authorization_data", "");
 503
 504         ktest_destroy_authorization_data(&ad);
 505     }
 506
 507     /****************************************************************/
 508     /* encode_pwd_sequence */
 509     {
 510         passwd_phrase_element ppe;
 511         setup(ppe,passwd_phrase_element,"PasswdSequence",ktest_make_sample_passwd_phrase_element);
 512         encode_run(ppe,passwd_phrase_element,"pwd_sequence","",encode_krb5_pwd_sequence);
 513         ktest_empty_passwd_phrase_element(&ppe);
 514     }
 515
 516     /****************************************************************/
 517     /* encode_passwd_data */
 518     {
 519         krb5_pwd_data pd;
 520         setup(pd,krb5_pwd_data,"PasswdData",ktest_make_sample_krb5_pwd_data);
 521         encode_run(pd,krb5_pwd_data,"pwd_data","",encode_krb5_pwd_data);
 522         ktest_empty_pwd_data(&pd);
 523     }
 524
 525     /****************************************************************/
 526     /* encode_padata_sequence */
 527     {
 528         krb5_pa_data **pa;
 529
 530         setup(pa,krb5_pa_data,"PreauthData",ktest_make_sample_pa_data_array);
 531         retval = encode_krb5_padata_sequence(pa,&(code));
 532         if (retval) {
 533             com_err("encoding padata_sequence",retval,"");
 534             exit(1);
 535         }
 536         encoder_print_results(code, "padata_sequence", "");
 537
 538         ktest_destroy_pa_data_array(&pa);
 539     }
 540
 541     /****************************************************************/
 542     /* encode_padata_sequence (empty) */
 543     {
 544         krb5_pa_data **pa;
 545
 546         setup(pa,krb5_pa_data,"EmptyPreauthData",ktest_make_sample_empty_pa_data_array);
 547         retval = encode_krb5_padata_sequence(pa,&(code));
 548         if (retval) {
 549             com_err("encoding padata_sequence(empty)",retval,"");
 550             exit(1);
 551         }
 552         encoder_print_results(code, "padata_sequence(empty)", "");
 553
 554         ktest_destroy_pa_data_array(&pa);
 555     }
 556
 557     /****************************************************************/
 558     /* encode_alt_method */
 559     {
 560         krb5_alt_method am;
 561         setup(am,krb5_alt_method,"AltMethod",ktest_make_sample_alt_method);
 562         encode_run(am,krb5_alt_method,"alt_method","",encode_krb5_alt_method);
 563         am.length = 0;
 564         if (am.data)
 565             free(am.data);
 566         am.data = 0;
 567         encode_run(am,krb5_alt_method,"alt_method (no data)","",
 568                    encode_krb5_alt_method);
 569         ktest_empty_alt_method(&am);
 570     }
 571
 572     /****************************************************************/
 573     /* encode_etype_info */
 574     {
 575         krb5_etype_info_entry **info;
 576
 577         setup(info,krb5_etype_info_entry **,"etype_info",
 578               ktest_make_sample_etype_info);
 579         retval = encode_krb5_etype_info(info,&(code));
 580         if (retval) {
 581             com_err("encoding etype_info",retval,"");
 582             exit(1);
 583         }
 584         encoder_print_results(code, "etype_info", "");
 585         ktest_destroy_etype_info_entry(info[2]);      info[2] = 0;
 586         ktest_destroy_etype_info_entry(info[1]);      info[1] = 0;
 587
 588         retval = encode_krb5_etype_info(info,&(code));
 589         if (retval) {
 590             com_err("encoding etype_info (only 1)",retval,"");
 591             exit(1);
 592         }
 593         encoder_print_results(code, "etype_info (only 1)", "");
 594
 595         ktest_destroy_etype_info_entry(info[0]);      info[0] = 0;
 596
 597         retval = encode_krb5_etype_info(info,&(code));
 598         if (retval) {
 599             com_err("encoding etype_info (no info)",retval,"");
 600             exit(1);
 601         }
 602         encoder_print_results(code, "etype_info (no info)", "");
 603
 604         ktest_destroy_etype_info(info);
 605     }
 606
 607     /* encode_etype_info 2*/
 608     {
 609         krb5_etype_info_entry **info;
 610
 611         setup(info,krb5_etype_info_entry **,"etype_info2",
 612               ktest_make_sample_etype_info2);
 613         retval = encode_krb5_etype_info2(info,&(code));
 614         if (retval) {
 615             com_err("encoding etype_info",retval,"");
 616             exit(1);
 617         }
 618         encoder_print_results(code, "etype_info2", "");
 619         ktest_destroy_etype_info_entry(info[2]);      info[2] = 0;
 620         ktest_destroy_etype_info_entry(info[1]);      info[1] = 0;
 621
 622         retval = encode_krb5_etype_info2(info,&(code));
 623         if (retval) {
 624             com_err("encoding etype_info (only 1)",retval,"");
 625             exit(1);
 626         }
 627         encoder_print_results(code, "etype_info2 (only 1)", "");
 628
 629         ktest_destroy_etype_info(info);
 630 /*    ktest_destroy_etype_info_entry(info[0]);      info[0] = 0;*/
 631
 632     }
 633
 634     /****************************************************************/
 635     /* encode_pa_enc_ts */
 636     {
 637         krb5_pa_enc_ts pa_enc;
 638         setup(pa_enc,krb5_pa_enc_ts,"pa_enc_ts",ktest_make_sample_pa_enc_ts);
 639         encode_run(pa_enc,krb5_pa_enc_ts,"pa_enc_ts","",encode_krb5_pa_enc_ts);
 640         pa_enc.pausec = 0;
 641         encode_run(pa_enc,krb5_pa_enc_ts,"pa_enc_ts (no usec)","",encode_krb5_pa_enc_ts);
 642     }
 643
 644     /****************************************************************/
 645     /* encode_enc_data */
 646     {
 647         krb5_enc_data enc_data;
 648         setup(enc_data,krb5_enc_data,"enc_data",ktest_make_sample_enc_data);
 649         current_appl_type = 1001;
 650         encode_run(enc_data,krb5_enc_data,"enc_data","",encode_krb5_enc_data);
 651         enc_data.kvno = 0xFF000000;
 652         current_appl_type = 1001;
 653         encode_run(enc_data,krb5_enc_data,"enc_data","(MSB-set kvno)",encode_krb5_enc_data);
 654         enc_data.kvno = 0xFFFFFFFF;
 655         current_appl_type = 1001;
 656         encode_run(enc_data,krb5_enc_data,"enc_data","(kvno=-1)",encode_krb5_enc_data);
 657         ktest_destroy_enc_data(&enc_data);
 658     }
 659     /****************************************************************/
 660     /* encode_krb5_sam_challenge */
 661     {
 662         krb5_sam_challenge sam_ch;
 663         setup(sam_ch,krb5_sam_challenge,"sam_challenge",
 664               ktest_make_sample_sam_challenge);
 665         encode_run(sam_ch,krb5_sam_challenge,"sam_challenge","",
 666                    encode_krb5_sam_challenge);
 667         ktest_empty_sam_challenge(&sam_ch);
 668     }
 669     /****************************************************************/
 670     /* encode_krb5_sam_response */
 671     {
 672         krb5_sam_response sam_ch;
 673         setup(sam_ch,krb5_sam_response,"sam_response",
 674               ktest_make_sample_sam_response);
 675         encode_run(sam_ch,krb5_sam_response,"sam_response","",
 676                    encode_krb5_sam_response);
 677         ktest_empty_sam_response(&sam_ch);
 678     }
 679     /****************************************************************/
 680     /* encode_krb5_sam_key */
 681     {
 682         krb5_sam_key sam_ch;
 683         setup(sam_ch,krb5_sam_key,"sam_key",
 684               ktest_make_sample_sam_key);
 685         encode_run(sam_ch,krb5_sam_key,"sam_key","",
 686                    encode_krb5_sam_key);
 687         ktest_empty_sam_key(&sam_ch);
 688     }
 689     /****************************************************************/
 690     /* encode_krb5_enc_sam_response_enc */
 691     {
 692         krb5_enc_sam_response_enc sam_ch;
 693         setup(sam_ch,krb5_enc_sam_response_enc,"enc_sam_response_enc",
 694               ktest_make_sample_enc_sam_response_enc);
 695         encode_run(sam_ch,krb5_enc_sam_response_enc,"enc_sam_response_enc","",
 696                    encode_krb5_enc_sam_response_enc);
 697         ktest_empty_enc_sam_response_enc(&sam_ch);
 698     }
 699     /****************************************************************/
 700     /* encode_krb5_predicted_sam_response */
 701     {
 702         krb5_predicted_sam_response sam_ch;
 703         setup(sam_ch,krb5_predicted_sam_response,"predicted_sam_response",
 704               ktest_make_sample_predicted_sam_response);
 705         encode_run(sam_ch,krb5_predicted_sam_response,"predicted_sam_response","",
 706                    encode_krb5_predicted_sam_response);
 707         ktest_empty_predicted_sam_response(&sam_ch);
 708     }
 709     /****************************************************************/
 710     /* encode_krb5_sam_response_2 */
 711     {
 712         krb5_sam_response_2 sam_ch2;
 713         setup(sam_ch2,krb5_sam_response_2,"sam_response_2",
 714               ktest_make_sample_sam_response_2);
 715         encode_run(sam_ch2,krb5_sam_response_2,"sam_response_2","",
 716                    acc.encode_krb5_sam_response_2);
 717         ktest_empty_sam_response_2(&sam_ch2);
 718     }
 719     /****************************************************************/
 720     /* encode_krb5_sam_response_enc_2 */
 721     {
 722         krb5_enc_sam_response_enc_2 sam_ch2;
 723         setup(sam_ch2,krb5_enc_sam_response_enc_2,"enc_sam_response_enc_2",
 724               ktest_make_sample_enc_sam_response_enc_2);
 725         encode_run(sam_ch2,krb5_enc_sam_response_enc_2,
 726                    "enc_sam_response_enc_2","",
 727                    acc.encode_krb5_enc_sam_response_enc_2);
 728         ktest_empty_enc_sam_response_enc_2(&sam_ch2);
 729     }
 730     /****************************************************************/
 731     /* encode_krb5_pa_s4u_x509_user */
 732     {
 733         krb5_pa_s4u_x509_user s4u;
 734         setup(s4u,krb5_pa_s4u_x509_user,"pa_s4u_x509_user",
 735               ktest_make_sample_pa_s4u_x509_user);
 736         encode_run(s4u,krb5_pa_s4u_x509_user,
 737                    "pa_s4u_x509_user","",
 738                    encode_krb5_pa_s4u_x509_user);
 739         ktest_empty_pa_s4u_x509_user(&s4u);
 740     }
 741     /****************************************************************/
 742     /* encode_krb5_ad_kdcissued */
 743     {
 744         krb5_ad_kdcissued kdci;
 745         setup(kdci,krb5_ad_kdcissued,"ad_kdcissued",
 746               ktest_make_sample_ad_kdcissued);
 747         encode_run(kdci,krb5_ad_kdcissued,
 748                    "ad_kdcissued","",
 749                    encode_krb5_ad_kdcissued);
 750         ktest_empty_ad_kdcissued(&kdci);
 751     }
 752     /****************************************************************/
 753     /* encode_krb5_ad_signedpath_data */
 754     {
 755         krb5_ad_signedpath_data spd;
 756         setup(spd,krb5_ad_signedpath_data,"ad_signedpath_data",
 757               ktest_make_sample_ad_signedpath_data);
 758         encode_run(spd,krb5_ad_signedpath_data,
 759                    "ad_signedpath_data","",
 760                    encode_krb5_ad_signedpath_data);
 761         ktest_empty_ad_signedpath_data(&spd);
 762     }
 763     /****************************************************************/
 764     /* encode_krb5_ad_signedpath */
 765     {
 766         krb5_ad_signedpath sp;
 767         setup(sp,krb5_ad_signedpath,"ad_signedpath",
 768               ktest_make_sample_ad_signedpath);
 769         encode_run(sp,krb5_ad_signedpath,
 770                    "ad_signedpath","",
 771                    encode_krb5_ad_signedpath);
 772         ktest_empty_ad_signedpath(&sp);
 773     }
 774     /****************************************************************/
 775     /* encode_krb5_iakerb_header */
 776     {
 777         krb5_iakerb_header ih;
 778         setup(ih,krb5_ad_signedpath,"iakerb_header",
 779               ktest_make_sample_iakerb_header);
 780         encode_run(ih,krb5_iakerb_header,
 781                    "iakerb_header","",
 782                    encode_krb5_iakerb_header);
 783         ktest_empty_iakerb_header(&ih);
 784     }
 785     /****************************************************************/
 786     /* encode_krb5_iakerb_finished */
 787     {
 788         krb5_iakerb_finished ih;
 789         setup(ih,krb5_ad_signedpath,"iakerb_finished",
 790               ktest_make_sample_iakerb_finished);
 791         encode_run(ih,krb5_iakerb_finished,
 792                    "iakerb_finished","",
 793                    encode_krb5_iakerb_finished);
 794         ktest_empty_iakerb_finished(&ih);
 795     }
 796 #ifdef ENABLE_LDAP
 797     {
 798         ldap_seqof_key_data skd;
 799
 800         setup(skd, ldap_seqof_key_data, "ldap_seqof_key_data",
 801               ktest_make_sample_ldap_seqof_key_data);
 802         encode_run(skd, ldap_seqof_key_data, "ldap_seqof_key_data", "",
 803                    acc.asn1_ldap_encode_sequence_of_keys);
 804         ktest_empty_ldap_seqof_key_data(test_context, &skd);
 805     }
 806 #endif
 807
 808     krb5_free_context(test_context);
 809     exit(error_count);
 810     return(error_count);
 811 }