src/tests/asn.1/ktest_equal.c

   1 /* -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil -*- */
   2 /* tests/asn.1/ktest_equal.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 <stdlib.h>
  28 #include <stdio.h>
  29 #include "ktest_equal.h"
  30
  31 #define FALSE 0
  32 #define TRUE 1
  33
  34 #define struct_equal(field,comparator)          \
  35     comparator(&(ref->field),&(var->field))
  36
  37 #define ptr_equal(field,comparator)             \
  38     comparator(ref->field,var->field)
  39
  40 #define scalar_equal(field)                     \
  41     ((ref->field) == (var->field))
  42
  43 #define len_equal(length,field,comparator)              \
  44     ((ref->length == var->length) &&                    \
  45      comparator(ref->length,ref->field,var->field))
  46
  47 int
  48 ktest_equal_authenticator(krb5_authenticator *ref, krb5_authenticator *var)
  49 {
  50     int p = TRUE;
  51
  52     if (ref == var) return TRUE;
  53     else if (ref == NULL || var == NULL) return FALSE;
  54     p = p && ptr_equal(client,ktest_equal_principal_data);
  55     p = p && ptr_equal(checksum,ktest_equal_checksum);
  56     p = p && scalar_equal(cusec);
  57     p = p && scalar_equal(ctime);
  58     p = p && ptr_equal(subkey,ktest_equal_keyblock);
  59     p = p && scalar_equal(seq_number);
  60     p = p && ptr_equal(authorization_data,ktest_equal_authorization_data);
  61     return p;
  62 }
  63
  64 int
  65 ktest_equal_principal_data(krb5_principal_data *ref, krb5_principal_data *var)
  66 {
  67     if (ref == var) return TRUE;
  68     else if (ref == NULL || var == NULL) return FALSE;
  69     return(struct_equal(realm,ktest_equal_data) &&
  70            len_equal(length,data,ktest_equal_array_of_data) &&
  71            scalar_equal(type));
  72 }
  73
  74 int
  75 ktest_equal_authdata(krb5_authdata *ref, krb5_authdata *var)
  76 {
  77     if (ref == var) return TRUE;
  78     else if (ref == NULL || var == NULL) return FALSE;
  79     return(scalar_equal(ad_type) &&
  80            len_equal(length,contents,ktest_equal_array_of_octet));
  81 }
  82
  83 int
  84 ktest_equal_checksum(krb5_checksum *ref, krb5_checksum *var)
  85 {
  86     if (ref == var) return TRUE;
  87     else if (ref == NULL || var == NULL) return FALSE;
  88     return(scalar_equal(checksum_type) && len_equal(length,contents,ktest_equal_array_of_octet));
  89 }
  90
  91 int
  92 ktest_equal_keyblock(krb5_keyblock *ref, krb5_keyblock *var)
  93 {
  94     if (ref == var) return TRUE;
  95     else if (ref == NULL || var == NULL) return FALSE;
  96     return(scalar_equal(enctype) && len_equal(length,contents,ktest_equal_array_of_octet));
  97 }
  98
  99 int
 100 ktest_equal_data(krb5_data *ref, krb5_data *var)
 101 {
 102     if (ref == var) return TRUE;
 103     else if (ref == NULL || var == NULL) return FALSE;
 104     return(len_equal(length,data,ktest_equal_array_of_char));
 105 }
 106
 107 int
 108 ktest_equal_ticket(krb5_ticket *ref, krb5_ticket *var)
 109 {
 110     int p = TRUE;
 111     if (ref == var) return TRUE;
 112     else if (ref == NULL || var == NULL) return FALSE;
 113     p = p && ptr_equal(server,ktest_equal_principal_data);
 114     p = p && struct_equal(enc_part,ktest_equal_enc_data);
 115     /* enc_part2 is irrelevant, as far as the ASN.1 code is concerned */
 116     return p;
 117 }
 118
 119 int
 120 ktest_equal_enc_data(krb5_enc_data *ref, krb5_enc_data *var)
 121 {
 122     int p = TRUE;
 123     if (ref == var) return TRUE;
 124     else if (ref == NULL || var == NULL) return FALSE;
 125     p = p && scalar_equal(enctype);
 126     p = p && scalar_equal(kvno);
 127     p = p && struct_equal(ciphertext,ktest_equal_data);
 128     return p;
 129 }
 130
 131 int
 132 ktest_equal_encryption_key(krb5_keyblock *ref, krb5_keyblock *var)
 133 {
 134     int p = TRUE;
 135     if (ref == var) return TRUE;
 136     else if (ref == NULL || var == NULL) return FALSE;
 137     p = p && scalar_equal(enctype);
 138     p = p && len_equal(length,contents,ktest_equal_array_of_octet);
 139     return p;
 140 }
 141
 142 int
 143 ktest_equal_enc_tkt_part(krb5_enc_tkt_part *ref, krb5_enc_tkt_part *var)
 144 {
 145     int p = TRUE;
 146     if (ref == var) return TRUE;
 147     else if (ref == NULL || var == NULL) return FALSE;
 148     p = p && scalar_equal(flags);
 149     p = p && ptr_equal(session,ktest_equal_encryption_key);
 150     p = p && ptr_equal(client,ktest_equal_principal_data);
 151     p = p && struct_equal(transited,ktest_equal_transited);
 152     p = p && struct_equal(times,ktest_equal_ticket_times);
 153     p = p && ptr_equal(caddrs,ktest_equal_addresses);
 154     p = p && ptr_equal(authorization_data,ktest_equal_authorization_data);
 155     return p;
 156 }
 157
 158 int
 159 ktest_equal_transited(krb5_transited *ref, krb5_transited *var)
 160 {
 161     int p = TRUE;
 162     if (ref == var) return TRUE;
 163     else if (ref == NULL || var == NULL) return FALSE;
 164     p = p && scalar_equal(tr_type);
 165     p = p && struct_equal(tr_contents,ktest_equal_data);
 166     return p;
 167 }
 168
 169 int
 170 ktest_equal_ticket_times(krb5_ticket_times *ref, krb5_ticket_times *var)
 171 {
 172     int p = TRUE;
 173     if (ref == var) return TRUE;
 174     else if (ref == NULL || var == NULL) return FALSE;
 175     p = p && scalar_equal(authtime);
 176     p = p && scalar_equal(starttime);
 177     p = p && scalar_equal(endtime);
 178     p = p && scalar_equal(renew_till);
 179     return p;
 180 }
 181
 182 int
 183 ktest_equal_address(krb5_address *ref, krb5_address *var)
 184 {
 185     int p = TRUE;
 186     if (ref == var) return TRUE;
 187     else if (ref == NULL || var == NULL) return FALSE;
 188     p = p && scalar_equal(addrtype);
 189     p = p && len_equal(length,contents,ktest_equal_array_of_octet);
 190     return p;
 191 }
 192
 193 int
 194 ktest_equal_enc_kdc_rep_part(krb5_enc_kdc_rep_part *ref,
 195                              krb5_enc_kdc_rep_part *var)
 196 {
 197     int p = TRUE;
 198     if (ref == var) return TRUE;
 199     else if (ref == NULL || var == NULL) return FALSE;
 200     p = p && ptr_equal(session,ktest_equal_keyblock);
 201     p = p && ptr_equal(last_req,ktest_equal_last_req);
 202     p = p && scalar_equal(nonce);
 203     p = p && scalar_equal(key_exp);
 204     p = p && scalar_equal(flags);
 205     p = p && struct_equal(times,ktest_equal_ticket_times);
 206     p = p && ptr_equal(server,ktest_equal_principal_data);
 207     p = p && ptr_equal(caddrs,ktest_equal_addresses);
 208     return p;
 209 }
 210
 211 int
 212 ktest_equal_priv(krb5_priv *ref, krb5_priv *var)
 213 {
 214     int p = TRUE;
 215     if (ref == var) return TRUE;
 216     else if (ref == NULL || var == NULL) return FALSE;
 217     p = p && struct_equal(enc_part,ktest_equal_enc_data);
 218     return p;
 219 }
 220
 221 int
 222 ktest_equal_cred(krb5_cred *ref, krb5_cred *var)
 223 {
 224     int p = TRUE;
 225     if (ref == var) return TRUE;
 226     else if (ref == NULL || var == NULL) return FALSE;
 227     p = p && ptr_equal(tickets,ktest_equal_sequence_of_ticket);
 228     p = p && struct_equal(enc_part,ktest_equal_enc_data);
 229     return p;
 230 }
 231
 232 int
 233 ktest_equal_error(krb5_error *ref, krb5_error *var)
 234 {
 235     int p = TRUE;
 236     if (ref == var) return TRUE;
 237     else if (ref == NULL || var == NULL) return FALSE;
 238     p = p && scalar_equal(ctime);
 239     p = p && scalar_equal(cusec);
 240     p = p && scalar_equal(susec);
 241     p = p && scalar_equal(stime);
 242     p = p && scalar_equal(error);
 243     p = p && ptr_equal(client,ktest_equal_principal_data);
 244     p = p && ptr_equal(server,ktest_equal_principal_data);
 245     p = p && struct_equal(text,ktest_equal_data);
 246     p = p && struct_equal(e_data,ktest_equal_data);
 247     return p;
 248 }
 249
 250 int
 251 ktest_equal_ap_req(krb5_ap_req *ref, krb5_ap_req *var)
 252 {
 253     int p = TRUE;
 254     if (ref == var) return TRUE;
 255     else if (ref == NULL || var == NULL) return FALSE;
 256     p = p && scalar_equal(ap_options);
 257     p = p && ptr_equal(ticket,ktest_equal_ticket);
 258     p = p && struct_equal(authenticator,ktest_equal_enc_data);
 259     return p;
 260 }
 261
 262 int
 263 ktest_equal_ap_rep(krb5_ap_rep *ref, krb5_ap_rep *var)
 264 {
 265     int p = TRUE;
 266     if (ref == var) return TRUE;
 267     else if (ref == NULL || var == NULL) return FALSE;
 268     p = p && struct_equal(enc_part,ktest_equal_enc_data);
 269     return p;
 270 }
 271
 272 int
 273 ktest_equal_ap_rep_enc_part(krb5_ap_rep_enc_part *ref,
 274                             krb5_ap_rep_enc_part *var)
 275 {
 276     int p = TRUE;
 277     if (ref == var) return TRUE;
 278     else if (ref == NULL || var == NULL) return FALSE;
 279     p = p && scalar_equal(ctime);
 280     p = p && scalar_equal(cusec);
 281     p = p && ptr_equal(subkey,ktest_equal_encryption_key);
 282     p = p && scalar_equal(seq_number);
 283     return p;
 284 }
 285
 286 int
 287 ktest_equal_safe(krb5_safe *ref, krb5_safe *var)
 288 {
 289     int p = TRUE;
 290     if (ref == var) return TRUE;
 291     else if (ref == NULL || var == NULL) return FALSE;
 292     p = p && struct_equal(user_data,ktest_equal_data);
 293     p = p && scalar_equal(timestamp);
 294     p = p && scalar_equal(usec);
 295     p = p && scalar_equal(seq_number);
 296     p = p && ptr_equal(s_address,ktest_equal_address);
 297     p = p && ptr_equal(r_address,ktest_equal_address);
 298     p = p && ptr_equal(checksum,ktest_equal_checksum);
 299     return p;
 300 }
 301
 302
 303 int
 304 ktest_equal_enc_cred_part(krb5_cred_enc_part *ref, krb5_cred_enc_part *var)
 305 {
 306     int p = TRUE;
 307     if (ref == var) return TRUE;
 308     else if (ref == NULL || var == NULL) return FALSE;
 309     p = p && scalar_equal(nonce);
 310     p = p && scalar_equal(timestamp);
 311     p = p && scalar_equal(usec);
 312     p = p && ptr_equal(s_address,ktest_equal_address);
 313     p = p && ptr_equal(r_address,ktest_equal_address);
 314     p = p && ptr_equal(ticket_info,ktest_equal_sequence_of_cred_info);
 315     return p;
 316 }
 317
 318 int
 319 ktest_equal_enc_priv_part(krb5_priv_enc_part *ref, krb5_priv_enc_part *var)
 320 {
 321     int p = TRUE;
 322     if (ref == var) return TRUE;
 323     else if (ref == NULL || var == NULL) return FALSE;
 324     p = p && struct_equal(user_data,ktest_equal_data);
 325     p = p && scalar_equal(timestamp);
 326     p = p && scalar_equal(usec);
 327     p = p && scalar_equal(seq_number);
 328     p = p && ptr_equal(s_address,ktest_equal_address);
 329     p = p && ptr_equal(r_address,ktest_equal_address);
 330     return p;
 331 }
 332
 333 int
 334 ktest_equal_as_rep(krb5_kdc_rep *ref, krb5_kdc_rep *var)
 335 {
 336     int p = TRUE;
 337     if (ref == var) return TRUE;
 338     else if (ref == NULL || var == NULL) return FALSE;
 339     p = p && scalar_equal(msg_type);
 340     p = p && ptr_equal(padata,ktest_equal_sequence_of_pa_data);
 341     p = p && ptr_equal(client,ktest_equal_principal_data);
 342     p = p && ptr_equal(ticket,ktest_equal_ticket);
 343     p = p && struct_equal(enc_part,ktest_equal_enc_data);
 344     p = p && ptr_equal(enc_part2,ktest_equal_enc_kdc_rep_part);
 345     return p;
 346 }
 347
 348 int
 349 ktest_equal_tgs_rep(krb5_kdc_rep *ref, krb5_kdc_rep *var)
 350 {
 351     return ktest_equal_as_rep(ref,var);
 352 }
 353
 354 int
 355 ktest_equal_as_req(krb5_kdc_req *ref, krb5_kdc_req *var)
 356 {
 357     int p = TRUE;
 358     if (ref == var) return TRUE;
 359     else if (ref == NULL || var == NULL) return FALSE;
 360     p = p && scalar_equal(msg_type);
 361     p = p && ptr_equal(padata,ktest_equal_sequence_of_pa_data);
 362     p = p && scalar_equal(kdc_options);
 363     p = p && ptr_equal(client,ktest_equal_principal_data);
 364     p = p && ptr_equal(server,ktest_equal_principal_data);
 365     p = p && scalar_equal(from);
 366     p = p && scalar_equal(till);
 367     p = p && scalar_equal(rtime);
 368     p = p && scalar_equal(nonce);
 369     p = p && len_equal(nktypes,ktype,ktest_equal_array_of_enctype);
 370     p = p && ptr_equal(addresses,ktest_equal_addresses);
 371     p = p && struct_equal(authorization_data,ktest_equal_enc_data);
 372 /* This field isn't actually in the ASN.1 encoding. */
 373 /* p = p && ptr_equal(unenc_authdata,ktest_equal_authorization_data); */
 374     return p;
 375 }
 376
 377 int
 378 ktest_equal_tgs_req(krb5_kdc_req *ref, krb5_kdc_req *var)
 379 {
 380     return ktest_equal_as_req(ref,var);
 381 }
 382
 383 int
 384 ktest_equal_kdc_req_body(krb5_kdc_req *ref, krb5_kdc_req *var)
 385 {
 386     int p = TRUE;
 387     if (ref == var) return TRUE;
 388     else if (ref == NULL || var == NULL) return FALSE;
 389     p = p && scalar_equal(kdc_options);
 390     p = p && ptr_equal(client,ktest_equal_principal_data);
 391     p = p && ptr_equal(server,ktest_equal_principal_data);
 392     p = p && scalar_equal(from);
 393     p = p && scalar_equal(till);
 394     p = p && scalar_equal(rtime);
 395     p = p && scalar_equal(nonce);
 396     p = p && len_equal(nktypes,ktype,ktest_equal_array_of_enctype);
 397     p = p && ptr_equal(addresses,ktest_equal_addresses);
 398     p = p && struct_equal(authorization_data,ktest_equal_enc_data);
 399     /* This isn't part of the ASN.1 encoding. */
 400     /* p = p && ptr_equal(unenc_authdata,ktest_equal_authorization_data); */
 401     return p;
 402 }
 403
 404 int
 405 ktest_equal_last_req_entry(krb5_last_req_entry *ref, krb5_last_req_entry *var)
 406 {
 407     int p = TRUE;
 408     if (ref == var) return TRUE;
 409     else if (ref == NULL || var == NULL) return FALSE;
 410     p = p && scalar_equal(lr_type);
 411     p = p && scalar_equal(value);
 412     return p;
 413 }
 414
 415 int
 416 ktest_equal_pa_data(krb5_pa_data *ref, krb5_pa_data *var)
 417 {
 418     int p = TRUE;
 419     if (ref == var) return TRUE;
 420     else if (ref == NULL || var == NULL) return FALSE;
 421     p = p && scalar_equal(pa_type);
 422     p = p && len_equal(length,contents,ktest_equal_array_of_octet);
 423     return p;
 424 }
 425
 426 int
 427 ktest_equal_cred_info(krb5_cred_info *ref, krb5_cred_info *var)
 428 {
 429     int p = TRUE;
 430     if (ref == var) return TRUE;
 431     else if (ref == NULL || var == NULL) return FALSE;
 432     p = p && ptr_equal(session,ktest_equal_keyblock);
 433     p = p && ptr_equal(client,ktest_equal_principal_data);
 434     p = p && ptr_equal(server,ktest_equal_principal_data);
 435     p = p && scalar_equal(flags);
 436     p = p && struct_equal(times,ktest_equal_ticket_times);
 437     p = p && ptr_equal(caddrs,ktest_equal_addresses);
 438
 439     return p;
 440 }
 441
 442 int
 443 ktest_equal_krb5_etype_info_entry(krb5_etype_info_entry *ref,
 444                                   krb5_etype_info_entry *var)
 445 {
 446     if (ref->etype != var->etype)
 447         return FALSE;
 448     if (ref->length != var->length)
 449         return FALSE;
 450     if (ref->length > 0 && ref->length != KRB5_ETYPE_NO_SALT)
 451         if (memcmp(ref->salt, var->salt, ref->length) != 0)
 452             return FALSE;
 453     return TRUE;
 454 }
 455
 456 int
 457 ktest_equal_krb5_pa_enc_ts(krb5_pa_enc_ts *ref, krb5_pa_enc_ts *var)
 458 {
 459     int p = TRUE;
 460     if (ref == var) return TRUE;
 461     else if (ref == NULL || var == NULL) return FALSE;
 462     p = p && scalar_equal(patimestamp);
 463     p = p && scalar_equal(pausec);
 464     return p;
 465 }
 466
 467 #define equal_str(f) struct_equal(f,ktest_equal_data)
 468
 469 int
 470 ktest_equal_sam_challenge_2_body(krb5_sam_challenge_2_body *ref,
 471                                  krb5_sam_challenge_2_body *var)
 472 {
 473     int p = TRUE;
 474     if (ref == var) return TRUE;
 475     else if (ref == NULL || var == NULL) return FALSE;
 476     p = p && scalar_equal(sam_type);
 477     p = p && scalar_equal(sam_flags);
 478     p = p && equal_str(sam_type_name);
 479     p = p && equal_str(sam_track_id);
 480     p = p && equal_str(sam_challenge_label);
 481     p = p && equal_str(sam_challenge);
 482     p = p && equal_str(sam_response_prompt);
 483     p = p && equal_str(sam_pk_for_sad);
 484     p = p && scalar_equal(sam_nonce);
 485     p = p && scalar_equal(sam_etype);
 486     return p;
 487 }
 488
 489 int
 490 ktest_equal_sam_challenge_2(krb5_sam_challenge_2 *ref,
 491                             krb5_sam_challenge_2 *var)
 492 {
 493     int p = TRUE;
 494     if (ref == var) return TRUE;
 495     else if (ref == NULL || var == NULL) return FALSE;
 496     p = p && equal_str(sam_challenge_2_body);
 497     p = p && ptr_equal(sam_cksum,ktest_equal_sequence_of_checksum);
 498     return p;
 499 }
 500
 501 int
 502 ktest_equal_pa_for_user(krb5_pa_for_user *ref, krb5_pa_for_user *var)
 503 {
 504     int p = TRUE;
 505     if (ref == var) return TRUE;
 506     else if (ref == NULL || var == NULL) return FALSE;
 507     p = p && ptr_equal(user, ktest_equal_principal_data);
 508     p = p && struct_equal(cksum, ktest_equal_checksum);
 509     p = p && equal_str(auth_package);
 510     return p;
 511 }
 512
 513 int
 514 ktest_equal_pa_s4u_x509_user(krb5_pa_s4u_x509_user *ref,
 515                              krb5_pa_s4u_x509_user *var)
 516 {
 517     int p = TRUE;
 518     if (ref == var) return TRUE;
 519     else if (ref == NULL || var == NULL) return FALSE;
 520     p = p && scalar_equal(user_id.nonce);
 521     p = p && ptr_equal(user_id.user,ktest_equal_principal_data);
 522     p = p && struct_equal(user_id.subject_cert,ktest_equal_data);
 523     p = p && scalar_equal(user_id.options);
 524     p = p && struct_equal(cksum,ktest_equal_checksum);
 525     return p;
 526 }
 527
 528 int
 529 ktest_equal_ad_kdcissued(krb5_ad_kdcissued *ref, krb5_ad_kdcissued *var)
 530 {
 531     int p = TRUE;
 532     if (ref == var) return TRUE;
 533     else if (ref == NULL || var == NULL) return FALSE;
 534     p = p && struct_equal(ad_checksum,ktest_equal_checksum);
 535     p = p && ptr_equal(i_principal,ktest_equal_principal_data);
 536     p = p && ptr_equal(elements,ktest_equal_authorization_data);
 537     return p;
 538 }
 539
 540 int
 541 ktest_equal_ad_signedpath_data(krb5_ad_signedpath_data *ref,
 542                                krb5_ad_signedpath_data *var)
 543 {
 544     int p = TRUE;
 545     if (ref == var) return TRUE;
 546     else if (ref == NULL || var == NULL) return FALSE;
 547     p = p && ptr_equal(client,ktest_equal_principal_data);
 548     p = p && scalar_equal(authtime);
 549     p = p && ptr_equal(delegated,ktest_equal_sequence_of_principal);
 550     p = p && ptr_equal(method_data,ktest_equal_sequence_of_pa_data);
 551     p = p && ptr_equal(authorization_data,ktest_equal_authorization_data);
 552     return p;
 553 }
 554
 555 int
 556 ktest_equal_ad_signedpath(krb5_ad_signedpath *ref, krb5_ad_signedpath *var)
 557 {
 558     int p = TRUE;
 559     if (ref == var) return TRUE;
 560     else if (ref == NULL || var == NULL) return FALSE;
 561     p = p && scalar_equal(enctype);
 562     p = p && struct_equal(checksum,ktest_equal_checksum);
 563     p = p && ptr_equal(delegated,ktest_equal_sequence_of_principal);
 564     p = p && ptr_equal(method_data,ktest_equal_sequence_of_pa_data);
 565     return p;
 566 }
 567
 568 int
 569 ktest_equal_iakerb_header(krb5_iakerb_header *ref, krb5_iakerb_header *var)
 570 {
 571     int p = TRUE;
 572     if (ref == var) return TRUE;
 573     else if (ref == NULL || var == NULL) return FALSE;
 574     p = p && struct_equal(target_realm,ktest_equal_data);
 575     p = p && ptr_equal(cookie,ktest_equal_data);
 576     return p;
 577 }
 578
 579 int
 580 ktest_equal_iakerb_finished(krb5_iakerb_finished *ref,
 581                             krb5_iakerb_finished *var)
 582 {
 583     int p = TRUE;
 584     if (ref == var) return TRUE;
 585     else if (ref == NULL || var == NULL) return FALSE;
 586     p = p && struct_equal(checksum,ktest_equal_checksum);
 587     return p;
 588 }
 589
 590 static int
 591 ktest_equal_fast_finished(krb5_fast_finished *ref, krb5_fast_finished *var)
 592 {
 593     int p = TRUE;
 594     if (ref == var) return TRUE;
 595     else if (ref == NULL || var == NULL) return FALSE;
 596     p = p && scalar_equal(timestamp);
 597     p = p && scalar_equal(usec);
 598     p = p && ptr_equal(client, ktest_equal_principal_data);
 599     p = p && struct_equal(ticket_checksum, ktest_equal_checksum);
 600     return p;
 601 }
 602
 603 int
 604 ktest_equal_fast_response(krb5_fast_response *ref, krb5_fast_response *var)
 605 {
 606     int p = TRUE;
 607     if (ref == var) return TRUE;
 608     else if (ref == NULL || var == NULL) return FALSE;
 609     p = p && ptr_equal(padata, ktest_equal_sequence_of_pa_data);
 610     p = p && ptr_equal(strengthen_key, ktest_equal_keyblock);
 611     p = p && ptr_equal(finished, ktest_equal_fast_finished);
 612     p = p && scalar_equal(nonce);
 613     return p;
 614 }
 615
 616 #ifdef ENABLE_LDAP
 617 static int
 618 equal_key_data(krb5_key_data *ref, krb5_key_data *var)
 619 {
 620     int p = TRUE;
 621     if (ref == var) return TRUE;
 622     else if (ref == NULL || var == NULL) return FALSE;
 623     p = p && scalar_equal(key_data_ver);
 624     p = p && scalar_equal(key_data_kvno);
 625     p = p && scalar_equal(key_data_type[0]);
 626     p = p && scalar_equal(key_data_type[1]);
 627     p = p && len_equal(key_data_length[0],key_data_contents[0],
 628                    ktest_equal_array_of_octet);
 629     p = p && len_equal(key_data_length[1],key_data_contents[1],
 630                    ktest_equal_array_of_octet);
 631     return p;
 632 }
 633
 634 static int
 635 equal_key_data_array(int n, krb5_key_data *ref, krb5_key_data *val)
 636 {
 637     int i, p = TRUE;
 638     for (i = 0; i < n; i++) {
 639         p = p && equal_key_data(ref+i, val+i);
 640     }
 641     return p;
 642 }
 643
 644 int
 645 ktest_equal_ldap_sequence_of_keys(ldap_seqof_key_data *ref,
 646                                   ldap_seqof_key_data *var)
 647 {
 648     int p = TRUE;
 649     if (ref == var) return TRUE;
 650     else if (ref == NULL || var == NULL) return FALSE;
 651     p = p && scalar_equal(mkvno);
 652     p = p && len_equal(n_key_data,key_data,equal_key_data_array);
 653     return p;
 654 }
 655 #endif
 656
 657 /**** arrays ****************************************************************/
 658
 659 int
 660 ktest_equal_array_of_data(int length, krb5_data *ref, krb5_data *var)
 661 {
 662     int i,p = TRUE;
 663
 664     if (ref == var) return TRUE;
 665     else if (ref == NULL || var == NULL) return FALSE;
 666     for (i=0; i<(length); i++) {
 667         p = p && ktest_equal_data(&(ref[i]),&(var[i]));
 668     }
 669     return p;
 670 }
 671
 672 int
 673 ktest_equal_array_of_octet(unsigned int length, krb5_octet *ref,
 674                            krb5_octet *var)
 675 {
 676     unsigned int i, p = TRUE;
 677
 678     if (ref == var) return TRUE;
 679     else if (ref == NULL || var == NULL) return FALSE;
 680     for (i=0; i<length; i++)
 681         p = p && (ref[i] == var[i]);
 682     return p;
 683 }
 684
 685 int
 686 ktest_equal_array_of_char(unsigned int length, char *ref, char *var)
 687 {
 688     unsigned int i, p = TRUE;
 689
 690     if (ref == var) return TRUE;
 691     else if (ref == NULL || var == NULL) return FALSE;
 692     for (i=0; i<length; i++)
 693         p = p && (ref[i] == var[i]);
 694     return p;
 695 }
 696
 697 int
 698 ktest_equal_array_of_enctype(int length, krb5_enctype *ref, krb5_enctype *var)
 699 {
 700     int i, p = TRUE;
 701
 702     if (ref == var) return TRUE;
 703     else if (ref == NULL || var == NULL) return FALSE;
 704     for (i=0; i<length; i++)
 705         p = p && (ref[i] == var[i]);
 706     return p;
 707 }
 708
 709 #define array_compare(comparator)                       \
 710     int i,p = TRUE;                                       \
 711     if (ref == var) return TRUE;                          \
 712     if (!ref || !ref[0])                                \
 713         return (!var || !var[0]);                       \
 714     if (!var || !var[0]) return FALSE;                  \
 715     for (i=0; ref[i] != NULL && var[i] != NULL; i++)    \
 716         p = p && comparator(ref[i],var[i]);             \
 717     if (ref[i] == NULL && var[i] == NULL) return p;     \
 718     else return FALSE
 719
 720 int
 721 ktest_equal_authorization_data(krb5_authdata **ref, krb5_authdata **var)
 722 {
 723     array_compare(ktest_equal_authdata);
 724 }
 725
 726 int
 727 ktest_equal_addresses(krb5_address **ref, krb5_address **var)
 728 {
 729     array_compare(ktest_equal_address);
 730 }
 731
 732 int
 733 ktest_equal_last_req(krb5_last_req_entry **ref, krb5_last_req_entry **var)
 734 {
 735     array_compare(ktest_equal_last_req_entry);
 736 }
 737
 738 int
 739 ktest_equal_sequence_of_ticket(krb5_ticket **ref, krb5_ticket **var)
 740 {
 741     array_compare(ktest_equal_ticket);
 742 }
 743
 744 int
 745 ktest_equal_sequence_of_pa_data(krb5_pa_data **ref, krb5_pa_data **var)
 746 {
 747     array_compare(ktest_equal_pa_data);
 748 }
 749
 750 int
 751 ktest_equal_sequence_of_cred_info(krb5_cred_info **ref, krb5_cred_info **var)
 752 {
 753     array_compare(ktest_equal_cred_info);
 754 }
 755
 756 int
 757 ktest_equal_sequence_of_principal(krb5_principal *ref, krb5_principal *var)
 758 {
 759     array_compare(ktest_equal_principal_data);
 760 }
 761
 762 int
 763 ktest_equal_etype_info(krb5_etype_info_entry **ref, krb5_etype_info_entry **var)
 764 {
 765     array_compare(ktest_equal_krb5_etype_info_entry);
 766 }
 767
 768 int
 769 ktest_equal_sequence_of_checksum(krb5_checksum **ref, krb5_checksum **var)
 770 {
 771     array_compare(ktest_equal_checksum);
 772 }