svn rev #21970: trunk/src/tests/asn.1/
ghudson@MIT.EDU
ghudson at MIT.EDU
Wed Feb 11 15:28:42 EST 2009
http://src.mit.edu/fisheye/changelog/krb5/?cs=21970
Commit By: ghudson
Log Message:
Add a new test harness to facilitate memory leak detection in the
ASN.1 decoder routines.
Changed Files:
U trunk/src/tests/asn.1/Makefile.in
U trunk/src/tests/asn.1/deps
A trunk/src/tests/asn.1/krb5_decode_leak.c
Modified: trunk/src/tests/asn.1/Makefile.in
===================================================================
--- trunk/src/tests/asn.1/Makefile.in 2009-02-11 20:18:43 UTC (rev 21969)
+++ trunk/src/tests/asn.1/Makefile.in 2009-02-11 20:28:40 UTC (rev 21970)
@@ -9,10 +9,11 @@
RUN_SETUP = @KRB5_RUN_ENV@
SRCS= $(srcdir)/krb5_encode_test.c $(srcdir)/krb5_decode_test.c \
- $(srcdir)/ktest.c $(srcdir)/ktest_equal.c $(srcdir)/utility.c \
+ $(srcdir)/krb5_decode_leak.c $(srcdir)/ktest.c \
+ $(srcdir)/ktest_equal.c $(srcdir)/utility.c \
$(srcdir)/trval.c $(srcdir)/t_trval.c
-all:: krb5_encode_test krb5_decode_test t_trval
+all:: krb5_encode_test krb5_decode_test krb5_decode_leak t_trval
LOCALINCLUDES = -I$(srcdir)/../../lib/krb5/asn.1
@@ -26,11 +27,23 @@
krb5_decode_test: $(DECOBJS) $(KRB5_BASE_DEPLIBS)
$(CC_LINK) -o krb5_decode_test $(DECOBJS) $(KRB5_BASE_LIBS)
+LEAKOBJS = krb5_decode_leak.o ktest.o ktest_equal.o utility.o
+
+krb5_decode_leak: $(LEAKOBJS) $(KRB5_BASE_DEPLIBS)
+ $(CC_LINK) -o krb5_decode_leak $(LEAKOBJS) $(KRB5_BASE_LIBS)
+
t_trval: t_trval.o
$(CC) -o t_trval $(ALL_CFLAGS) t_trval.o
-check:: check-encode check-encode-trval check-decode
+check:: check-encode check-encode-trval check-decode check-leak
+# Does not actually test for leaks unless using valgrind or a similar
+# tool, but does exercise a bunch of code.
+check-leak: krb5_decode_leak
+ KRB5_CONFIG=$(SRCTOP)/config-files/krb5.conf ; \
+ export KRB5_CONFIG ;\
+ $(RUN_SETUP) $(VALGRIND) ./krb5_decode_leak
+
check-decode: krb5_decode_test
KRB5_CONFIG=$(SRCTOP)/config-files/krb5.conf ; \
export KRB5_CONFIG ;\
Modified: trunk/src/tests/asn.1/deps
===================================================================
--- trunk/src/tests/asn.1/deps 2009-02-11 20:18:43 UTC (rev 21969)
+++ trunk/src/tests/asn.1/deps 2009-02-11 20:28:40 UTC (rev 21970)
@@ -25,6 +25,18 @@
$(SRCTOP)/include/socket-utils.h $(SRCTOP)/lib/krb5/asn.1/asn1buf.h \
$(SRCTOP)/lib/krb5/asn.1/krbasn1.h debug.h krb5_decode_test.c \
ktest.h ktest_equal.h utility.h
+$(OUTPRE)krb5_decode_leak.$(OBJEXT): $(BUILDTOP)/include/autoconf.h \
+ $(BUILDTOP)/include/krb5/krb5.h $(BUILDTOP)/include/osconf.h \
+ $(BUILDTOP)/include/profile.h $(COM_ERR_DEPS) $(SRCTOP)/include/k5-buf.h \
+ $(SRCTOP)/include/k5-err.h $(SRCTOP)/include/k5-gmt_mktime.h \
+ $(SRCTOP)/include/k5-int-pkinit.h $(SRCTOP)/include/k5-int.h \
+ $(SRCTOP)/include/k5-platform.h $(SRCTOP)/include/k5-plugin.h \
+ $(SRCTOP)/include/k5-thread.h $(SRCTOP)/include/kdb.h \
+ $(SRCTOP)/include/krb5.h $(SRCTOP)/include/krb5/locate_plugin.h \
+ $(SRCTOP)/include/krb5/preauth_plugin.h $(SRCTOP)/include/port-sockets.h \
+ $(SRCTOP)/include/socket-utils.h $(SRCTOP)/lib/krb5/asn.1/asn1buf.h \
+ $(SRCTOP)/lib/krb5/asn.1/krbasn1.h debug.h krb5_decode_leak.c \
+ ktest.h utility.h
$(OUTPRE)ktest.$(OBJEXT): $(BUILDTOP)/include/autoconf.h \
$(BUILDTOP)/include/krb5/krb5.h $(BUILDTOP)/include/osconf.h \
$(BUILDTOP)/include/profile.h $(COM_ERR_DEPS) $(SRCTOP)/include/k5-buf.h \
Added: trunk/src/tests/asn.1/krb5_decode_leak.c
===================================================================
--- trunk/src/tests/asn.1/krb5_decode_leak.c 2009-02-11 20:18:43 UTC (rev 21969)
+++ trunk/src/tests/asn.1/krb5_decode_leak.c 2009-02-11 20:28:40 UTC (rev 21970)
@@ -0,0 +1,650 @@
+/* -*- mode: c; indent-tabs-mode: nil -*- */
+/*
+ * This program is intended to help detect memory leaks in the ASN.1
+ * decoder functions by exercising their failure paths. The setup
+ * code for the test cases is copied from krb5_encode_test.c.
+ *
+ * This code does not actually detect leaks by itself; it must be run
+ * through a leak-detection tool such as valgrind to do so. Simply
+ * running the program will exercise a bunch of ASN.1 encoder and
+ * decoder code paths but won't validate the results.
+ */
+
+#include <stdio.h>
+#include "k5-int.h"
+#include "com_err.h"
+#include "utility.h"
+
+#include "ktest.h"
+#include <string.h>
+
+#include "debug.h"
+
+krb5_context test_context;
+
+int
+main(int argc, char **argv)
+{
+ krb5_data *code;
+ krb5_error_code retval;
+ unsigned int i;
+
+ retval = krb5_init_context(&test_context);
+ if (retval) {
+ com_err(argv[0], retval, "while initializing krb5");
+ exit(1);
+ }
+ init_access(argv[0]);
+
+#define setup(value, typestring, constructor) \
+ retval = constructor(&(value)); \
+ if (retval) { \
+ com_err("krb5_decode_leak", retval, "while making sample %s", \
+ typestring); \
+ exit(1); \
+ }
+
+#define encode_run(value,type,typestring,description,encoder)
+
+ /*
+ * Encode a value. Then attempt to trigger most failure paths of
+ * the decoder function by passing in corrupt encodings, which we
+ * generate by perturbing each byte of the encoding in turn. Some
+ * of the perturbed encodings are expected to decode successfully,
+ * so we need a free function to discard successful results. Make
+ * sure to define a pointer named "tmp" of the correct type in the
+ * enclosing block.
+ */
+#define leak_test(value, encoder, decoder, freefn) \
+ retval = encoder(&(value),&(code)); \
+ if (retval) { \
+ com_err("krb5_decode_leak", retval, "while encoding"); \
+ exit(1); \
+ } \
+ for (i = 0; i < code->length; i++) { \
+ code->data[i] = (char)~((unsigned char)code->data[i]); \
+ retval = decoder(code, &tmp); \
+ code->data[i] = (char)~((unsigned char)code->data[i]); \
+ if (retval == 0) \
+ freefn(test_context, tmp); \
+ } \
+ krb5_free_data(test_context, code);
+
+ /****************************************************************/
+ /* encode_krb5_authenticator */
+ {
+ krb5_authenticator authent, *tmp;
+
+ setup(authent, "authenticator", ktest_make_sample_authenticator);
+ leak_test(authent, encode_krb5_authenticator,
+ decode_krb5_authenticator, krb5_free_authenticator);
+
+ ktest_destroy_checksum(&(authent.checksum));
+ ktest_destroy_keyblock(&(authent.subkey));
+ authent.seq_number = 0;
+ ktest_empty_authorization_data(authent.authorization_data);
+ leak_test(authent, encode_krb5_authenticator,
+ decode_krb5_authenticator, krb5_free_authenticator);
+
+ ktest_destroy_authorization_data(&(authent.authorization_data));
+ leak_test(authent, encode_krb5_authenticator,
+ decode_krb5_authenticator, krb5_free_authenticator);
+ ktest_empty_authenticator(&authent);
+ }
+
+ /****************************************************************/
+ /* encode_krb5_ticket */
+ {
+ krb5_ticket tkt, *tmp;
+
+ setup(tkt, "ticket", ktest_make_sample_ticket);
+ leak_test(tkt, encode_krb5_ticket, decode_krb5_ticket,
+ krb5_free_ticket);
+ ktest_empty_ticket(&tkt);
+ }
+
+ /****************************************************************/
+ /* encode_krb5_encryption_key */
+ {
+ krb5_keyblock keyblk, *tmp;
+
+ setup(keyblk, "keyblock", ktest_make_sample_keyblock);
+ leak_test(keyblk, encode_krb5_encryption_key,
+ decode_krb5_encryption_key, krb5_free_keyblock);
+ ktest_empty_keyblock(&keyblk);
+ }
+
+ /****************************************************************/
+ /* encode_krb5_enc_tkt_part */
+ {
+ krb5_ticket tkt;
+ krb5_enc_tkt_part *tmp;
+
+ memset(&tkt, 0, sizeof(krb5_ticket));
+ tkt.enc_part2 = calloc(1, sizeof(krb5_enc_tkt_part));
+ if (tkt.enc_part2 == NULL)
+ com_err("allocating enc_tkt_part", errno, "");
+ setup(*(tkt.enc_part2), "enc_tkt_part",
+ ktest_make_sample_enc_tkt_part);
+
+ leak_test(*(tkt.enc_part2), encode_krb5_enc_tkt_part,
+ decode_krb5_enc_tkt_part, krb5_free_enc_tkt_part);
+
+ tkt.enc_part2->times.starttime = 0;
+ tkt.enc_part2->times.renew_till = 0;
+ ktest_destroy_address(&(tkt.enc_part2->caddrs[1]));
+ ktest_destroy_address(&(tkt.enc_part2->caddrs[0]));
+ ktest_destroy_authdata(&(tkt.enc_part2->authorization_data[1]));
+ ktest_destroy_authdata(&(tkt.enc_part2->authorization_data[0]));
+
+ /* ISODE version fails on the empty caddrs field */
+ ktest_destroy_addresses(&(tkt.enc_part2->caddrs));
+ ktest_destroy_authorization_data(&(tkt.enc_part2->authorization_data));
+
+ leak_test(*(tkt.enc_part2), encode_krb5_enc_tkt_part,
+ decode_krb5_enc_tkt_part, krb5_free_enc_tkt_part);
+ ktest_empty_ticket(&tkt);
+ }
+
+ /****************************************************************/
+ /* encode_krb5_enc_kdc_rep_part */
+ {
+ krb5_kdc_rep kdcr;
+ krb5_enc_kdc_rep_part *tmp;
+
+ memset(&kdcr, 0, sizeof(kdcr));
+
+ kdcr.enc_part2 = calloc(1, sizeof(krb5_enc_kdc_rep_part));
+ if (kdcr.enc_part2 == NULL)
+ com_err("allocating enc_kdc_rep_part", errno, "");
+ setup(*(kdcr.enc_part2), "enc_kdc_rep_part",
+ ktest_make_sample_enc_kdc_rep_part);
+
+ leak_test(*(kdcr.enc_part2), encode_krb5_enc_kdc_rep_part,
+ decode_krb5_enc_kdc_rep_part, krb5_free_enc_kdc_rep_part);
+
+ kdcr.enc_part2->key_exp = 0;
+ kdcr.enc_part2->times.starttime = 0;
+ kdcr.enc_part2->flags &= ~TKT_FLG_RENEWABLE;
+ ktest_destroy_addresses(&(kdcr.enc_part2->caddrs));
+
+ leak_test(*(kdcr.enc_part2), encode_krb5_enc_kdc_rep_part,
+ decode_krb5_enc_kdc_rep_part, krb5_free_enc_kdc_rep_part);
+
+ ktest_empty_kdc_rep(&kdcr);
+ }
+
+ /****************************************************************/
+ /* encode_krb5_as_rep */
+ {
+ krb5_kdc_rep kdcr, *tmp;
+
+ setup(kdcr, "kdc_rep", ktest_make_sample_kdc_rep);
+ kdcr.msg_type = KRB5_AS_REP;
+ leak_test(kdcr, encode_krb5_as_rep, decode_krb5_as_rep,
+ krb5_free_kdc_rep);
+
+ ktest_destroy_pa_data_array(&(kdcr.padata));
+ leak_test(kdcr, encode_krb5_as_rep, decode_krb5_as_rep,
+ krb5_free_kdc_rep);
+
+ ktest_empty_kdc_rep(&kdcr);
+
+ }
+
+ /****************************************************************/
+ /* encode_krb5_tgs_rep */
+ {
+ krb5_kdc_rep kdcr, *tmp;
+
+ setup(kdcr, "kdc_rep", ktest_make_sample_kdc_rep);
+ kdcr.msg_type = KRB5_TGS_REP;
+ leak_test(kdcr, encode_krb5_tgs_rep, decode_krb5_tgs_rep,
+ krb5_free_kdc_rep);
+
+ ktest_destroy_pa_data_array(&(kdcr.padata));
+ leak_test(kdcr, encode_krb5_tgs_rep, decode_krb5_tgs_rep,
+ krb5_free_kdc_rep);
+
+ ktest_empty_kdc_rep(&kdcr);
+
+ }
+
+ /****************************************************************/
+ /* encode_krb5_ap_req */
+ {
+ krb5_ap_req apreq, *tmp;
+
+ setup(apreq, "ap_req", ktest_make_sample_ap_req);
+ leak_test(apreq, encode_krb5_ap_req, decode_krb5_ap_req,
+ krb5_free_ap_req);
+ ktest_empty_ap_req(&apreq);
+ }
+
+ /****************************************************************/
+ /* encode_krb5_ap_rep */
+ {
+ krb5_ap_rep aprep, *tmp;
+
+ setup(aprep, "ap_rep", ktest_make_sample_ap_rep);
+ leak_test(aprep, encode_krb5_ap_rep, decode_krb5_ap_rep,
+ krb5_free_ap_rep);
+ ktest_empty_ap_rep(&aprep);
+ }
+
+ /****************************************************************/
+ /* encode_krb5_ap_rep_enc_part */
+ {
+ krb5_ap_rep_enc_part apenc, *tmp;
+
+ setup(apenc, "ap_rep_enc_part", ktest_make_sample_ap_rep_enc_part);
+ leak_test(apenc, encode_krb5_ap_rep_enc_part,
+ decode_krb5_ap_rep_enc_part, krb5_free_ap_rep_enc_part);
+
+ ktest_destroy_keyblock(&(apenc.subkey));
+ apenc.seq_number = 0;
+ leak_test(apenc, encode_krb5_ap_rep_enc_part,
+ decode_krb5_ap_rep_enc_part, krb5_free_ap_rep_enc_part);
+ ktest_empty_ap_rep_enc_part(&apenc);
+ }
+
+ /****************************************************************/
+ /* encode_krb5_as_req */
+ {
+ krb5_kdc_req asreq, *tmp;
+
+ setup(asreq, "kdc_req", ktest_make_sample_kdc_req);
+ asreq.msg_type = KRB5_AS_REQ;
+ asreq.kdc_options &= ~KDC_OPT_ENC_TKT_IN_SKEY;
+ leak_test(asreq, encode_krb5_as_req, decode_krb5_as_req,
+ krb5_free_kdc_req);
+
+ ktest_destroy_pa_data_array(&(asreq.padata));
+ ktest_destroy_principal(&(asreq.client));
+#ifndef ISODE_SUCKS
+ ktest_destroy_principal(&(asreq.server));
+#endif
+ asreq.kdc_options |= KDC_OPT_ENC_TKT_IN_SKEY;
+ asreq.from = 0;
+ asreq.rtime = 0;
+ ktest_destroy_addresses(&(asreq.addresses));
+ ktest_destroy_enc_data(&(asreq.authorization_data));
+ leak_test(asreq, encode_krb5_as_req, decode_krb5_as_req,
+ krb5_free_kdc_req);
+
+ ktest_destroy_sequence_of_ticket(&(asreq.second_ticket));
+#ifndef ISODE_SUCKS
+ ktest_make_sample_principal(&(asreq.server));
+#endif
+ asreq.kdc_options &= ~KDC_OPT_ENC_TKT_IN_SKEY;
+ leak_test(asreq, encode_krb5_as_req, decode_krb5_as_req,
+ krb5_free_kdc_req);
+ ktest_empty_kdc_req(&asreq);
+ }
+
+ /****************************************************************/
+ /* encode_krb5_tgs_req */
+ {
+ krb5_kdc_req tgsreq, *tmp;
+
+ setup(tgsreq, "kdc_req", ktest_make_sample_kdc_req);
+ tgsreq.msg_type = KRB5_TGS_REQ;
+ tgsreq.kdc_options &= ~KDC_OPT_ENC_TKT_IN_SKEY;
+ leak_test(tgsreq, encode_krb5_tgs_req, decode_krb5_tgs_req,
+ krb5_free_kdc_req);
+
+ ktest_destroy_pa_data_array(&(tgsreq.padata));
+ ktest_destroy_principal(&(tgsreq.client));
+#ifndef ISODE_SUCKS
+ ktest_destroy_principal(&(tgsreq.server));
+#endif
+ tgsreq.kdc_options |= KDC_OPT_ENC_TKT_IN_SKEY;
+ tgsreq.from = 0;
+ tgsreq.rtime = 0;
+ ktest_destroy_addresses(&(tgsreq.addresses));
+ ktest_destroy_enc_data(&(tgsreq.authorization_data));
+ leak_test(tgsreq, encode_krb5_tgs_req, decode_krb5_tgs_req,
+ krb5_free_kdc_req);
+
+ ktest_destroy_sequence_of_ticket(&(tgsreq.second_ticket));
+#ifndef ISODE_SUCKS
+ ktest_make_sample_principal(&(tgsreq.server));
+#endif
+ tgsreq.kdc_options &= ~KDC_OPT_ENC_TKT_IN_SKEY;
+ leak_test(tgsreq, encode_krb5_tgs_req, decode_krb5_tgs_req,
+ krb5_free_kdc_req);
+ ktest_empty_kdc_req(&tgsreq);
+ }
+
+ /****************************************************************/
+ /* encode_krb5_kdc_req_body */
+ {
+ krb5_kdc_req kdcrb, *tmp;
+
+ memset(&kdcrb, 0, sizeof(kdcrb));
+ setup(kdcrb, "kdc_req_body", ktest_make_sample_kdc_req_body);
+ kdcrb.kdc_options &= ~KDC_OPT_ENC_TKT_IN_SKEY;
+ leak_test(kdcrb, encode_krb5_kdc_req_body, decode_krb5_kdc_req_body,
+ krb5_free_kdc_req);
+
+ ktest_destroy_principal(&(kdcrb.client));
+#ifndef ISODE_SUCKS
+ ktest_destroy_principal(&(kdcrb.server));
+#endif
+ kdcrb.kdc_options |= KDC_OPT_ENC_TKT_IN_SKEY;
+ kdcrb.from = 0;
+ kdcrb.rtime = 0;
+ ktest_destroy_addresses(&(kdcrb.addresses));
+ ktest_destroy_enc_data(&(kdcrb.authorization_data));
+ leak_test(kdcrb, encode_krb5_kdc_req_body, decode_krb5_kdc_req_body,
+ krb5_free_kdc_req);
+
+ ktest_destroy_sequence_of_ticket(&(kdcrb.second_ticket));
+#ifndef ISODE_SUCKS
+ ktest_make_sample_principal(&(kdcrb.server));
+#endif
+ kdcrb.kdc_options &= ~KDC_OPT_ENC_TKT_IN_SKEY;
+ leak_test(kdcrb, encode_krb5_kdc_req_body, decode_krb5_kdc_req_body,
+ krb5_free_kdc_req);
+ ktest_empty_kdc_req(&kdcrb);
+ }
+
+ /****************************************************************/
+ /* encode_krb5_safe */
+ {
+ krb5_safe s, *tmp;
+
+ setup(s, "safe", ktest_make_sample_safe);
+ leak_test(s, encode_krb5_safe, decode_krb5_safe, krb5_free_safe);
+
+ s.timestamp = 0;
+ /* s.usec should be opted out by the timestamp */
+ s.seq_number = 0;
+ ktest_destroy_address(&(s.r_address));
+ leak_test(s, encode_krb5_safe, decode_krb5_safe, krb5_free_safe);
+ ktest_empty_safe(&s);
+ }
+
+ /****************************************************************/
+ /* encode_krb5_priv */
+ {
+ krb5_priv p, *tmp;
+
+ setup(p, "priv", ktest_make_sample_priv);
+ leak_test(p, encode_krb5_priv, decode_krb5_priv, krb5_free_priv);
+ ktest_empty_priv(&p);
+ }
+
+ /****************************************************************/
+ /* encode_krb5_enc_priv_part */
+ {
+ krb5_priv_enc_part ep, *tmp;
+
+ setup(ep, "priv_enc_part", ktest_make_sample_priv_enc_part);
+ leak_test(ep, encode_krb5_enc_priv_part, decode_krb5_enc_priv_part,
+ krb5_free_priv_enc_part);
+
+ ep.timestamp = 0;
+ /* ep.usec should be opted out along with timestamp */
+ ep.seq_number = 0;
+ ktest_destroy_address(&(ep.r_address));
+ leak_test(ep, encode_krb5_enc_priv_part, decode_krb5_enc_priv_part,
+ krb5_free_priv_enc_part);
+ ktest_empty_priv_enc_part(&ep);
+ }
+
+ /****************************************************************/
+ /* encode_krb5_cred */
+ {
+ krb5_cred c, *tmp;
+
+ setup(c, "cred", ktest_make_sample_cred);
+ leak_test(c, encode_krb5_cred, decode_krb5_cred, krb5_free_cred);
+ ktest_empty_cred(&c);
+ }
+
+ /****************************************************************/
+ /* encode_krb5_enc_cred_part */
+ {
+ krb5_cred_enc_part cep, *tmp;
+
+ setup(cep, "cred_enc_part", ktest_make_sample_cred_enc_part);
+ leak_test(cep, encode_krb5_enc_cred_part, decode_krb5_enc_cred_part,
+ krb5_free_cred_enc_part);
+
+ ktest_destroy_principal(&(cep.ticket_info[0]->client));
+ ktest_destroy_principal(&(cep.ticket_info[0]->server));
+ cep.ticket_info[0]->flags = 0;
+ cep.ticket_info[0]->times.authtime = 0;
+ cep.ticket_info[0]->times.starttime = 0;
+ cep.ticket_info[0]->times.endtime = 0;
+ cep.ticket_info[0]->times.renew_till = 0;
+ ktest_destroy_addresses(&(cep.ticket_info[0]->caddrs));
+ cep.nonce = 0;
+ cep.timestamp = 0;
+ ktest_destroy_address(&(cep.s_address));
+ ktest_destroy_address(&(cep.r_address));
+ leak_test(cep, encode_krb5_enc_cred_part, decode_krb5_enc_cred_part,
+ krb5_free_cred_enc_part);
+ ktest_empty_cred_enc_part(&cep);
+ }
+
+ /****************************************************************/
+ /* encode_krb5_error */
+ {
+ krb5_error kerr, *tmp;
+
+ setup(kerr, "error", ktest_make_sample_error);
+ leak_test(kerr, encode_krb5_error, decode_krb5_error, krb5_free_error);
+
+ kerr.ctime = 0;
+ ktest_destroy_principal(&(kerr.client));
+ ktest_empty_data(&(kerr.text));
+ ktest_empty_data(&(kerr.e_data));
+ leak_test(kerr, encode_krb5_error, decode_krb5_error, krb5_free_error);
+
+ ktest_empty_error(&kerr);
+ }
+
+ /****************************************************************/
+ /* encode_krb5_authdata */
+ {
+ krb5_authdata **ad, **tmp;
+
+ setup(ad, "authorization_data", ktest_make_sample_authorization_data);
+ leak_test(*ad, encode_krb5_authdata, decode_krb5_authdata,
+ krb5_free_authdata);
+ ktest_destroy_authorization_data(&ad);
+ }
+
+ /****************************************************************/
+ /* encode_pwd_sequence */
+ {
+ passwd_phrase_element ppe, *tmp;
+
+ setup(ppe, "PasswdSequence", ktest_make_sample_passwd_phrase_element);
+ leak_test(ppe, encode_krb5_pwd_sequence, decode_krb5_pwd_sequence,
+ krb5_free_passwd_phrase_element);
+ ktest_empty_passwd_phrase_element(&ppe);
+ }
+
+ /****************************************************************/
+ /* encode_passwd_data */
+ {
+ krb5_pwd_data pd, *tmp;
+
+ setup(pd, "PasswdData", ktest_make_sample_krb5_pwd_data);
+ leak_test(pd, encode_krb5_pwd_data, decode_krb5_pwd_data,
+ krb5_free_pwd_data);
+ ktest_empty_pwd_data(&pd);
+ }
+
+ /****************************************************************/
+ /* encode_padata_sequence */
+ {
+ krb5_pa_data **pa, **tmp;
+
+ setup(pa, "PreauthData", ktest_make_sample_pa_data_array);
+ leak_test(*pa, encode_krb5_padata_sequence,
+ decode_krb5_padata_sequence, krb5_free_pa_data);
+ ktest_destroy_pa_data_array(&pa);
+ }
+
+ /****************************************************************/
+ /* encode_padata_sequence (empty) */
+ {
+ krb5_pa_data **pa, **tmp;
+
+ setup(pa,"EmptyPreauthData",ktest_make_sample_empty_pa_data_array);
+ leak_test(*pa, encode_krb5_padata_sequence,
+ decode_krb5_padata_sequence, krb5_free_pa_data);
+ ktest_destroy_pa_data_array(&pa);
+ }
+
+ /****************************************************************/
+ /* encode_alt_method */
+ {
+ krb5_alt_method am, *tmp;
+
+ setup(am, "AltMethod", ktest_make_sample_alt_method);
+ leak_test(am, encode_krb5_alt_method, decode_krb5_alt_method,
+ krb5_free_alt_method);
+ am.length = 0;
+ if (am.data)
+ free(am.data);
+ am.data = 0;
+ leak_test(am, encode_krb5_alt_method, decode_krb5_alt_method,
+ krb5_free_alt_method);
+ ktest_empty_alt_method(&am);
+ }
+
+ /****************************************************************/
+ /* encode_etype_info */
+ {
+ krb5_etype_info_entry **info, **tmp;
+
+ setup(info, "etype_info", ktest_make_sample_etype_info);
+ leak_test(*info, encode_krb5_etype_info, decode_krb5_etype_info,
+ krb5_free_etype_info);
+
+ ktest_destroy_etype_info_entry(info[2]); info[2] = 0;
+ ktest_destroy_etype_info_entry(info[1]); info[1] = 0;
+ leak_test(*info, encode_krb5_etype_info, decode_krb5_etype_info,
+ krb5_free_etype_info);
+
+ ktest_destroy_etype_info_entry(info[0]); info[0] = 0;
+ leak_test(*info, encode_krb5_etype_info, decode_krb5_etype_info,
+ krb5_free_etype_info);
+
+ ktest_destroy_etype_info(info);
+ }
+
+ /* encode_etype_info 2*/
+ {
+ krb5_etype_info_entry **info, **tmp;
+
+ setup(info, "etype_info2", ktest_make_sample_etype_info2);
+ leak_test(*info, encode_krb5_etype_info2, decode_krb5_etype_info2,
+ krb5_free_etype_info);
+
+ ktest_destroy_etype_info_entry(info[2]); info[2] = 0;
+ ktest_destroy_etype_info_entry(info[1]); info[1] = 0;
+ leak_test(*info, encode_krb5_etype_info2, decode_krb5_etype_info2,
+ krb5_free_etype_info);
+
+ ktest_destroy_etype_info(info);
+ }
+
+ /****************************************************************/
+ /* encode_pa_enc_ts */
+ {
+ krb5_pa_enc_ts pa_enc, *tmp;
+
+ setup(pa_enc, "pa_enc_ts", ktest_make_sample_pa_enc_ts);
+ leak_test(pa_enc, encode_krb5_pa_enc_ts, decode_krb5_pa_enc_ts,
+ krb5_free_pa_enc_ts);
+ pa_enc.pausec = 0;
+ leak_test(pa_enc, encode_krb5_pa_enc_ts, decode_krb5_pa_enc_ts,
+ krb5_free_pa_enc_ts);
+ }
+
+ /****************************************************************/
+ /* encode_enc_data */
+ {
+ krb5_enc_data enc_data, *tmp;
+
+ setup(enc_data, "enc_data", ktest_make_sample_enc_data);
+ leak_test(enc_data, encode_krb5_enc_data, decode_krb5_enc_data,
+ krb5_free_enc_data);
+ ktest_destroy_enc_data(&enc_data);
+ }
+ /****************************************************************/
+ /* encode_krb5_sam_challenge */
+ {
+ krb5_sam_challenge sam_ch, *tmp;
+
+ setup(sam_ch, "sam_challenge", ktest_make_sample_sam_challenge);
+ leak_test(sam_ch, encode_krb5_sam_challenge, decode_krb5_sam_challenge,
+ krb5_free_sam_challenge);
+ ktest_empty_sam_challenge(&sam_ch);
+ }
+ /****************************************************************/
+ /* encode_krb5_sam_response */
+ {
+ krb5_sam_response sam_ch, *tmp;
+
+ setup(sam_ch, "sam_response", ktest_make_sample_sam_response);
+ leak_test(sam_ch, encode_krb5_sam_response, decode_krb5_sam_response,
+ krb5_free_sam_response);
+ ktest_empty_sam_response(&sam_ch);
+ }
+ /****************************************************************/
+ /* encode_krb5_enc_sam_response_enc */
+ {
+ krb5_enc_sam_response_enc sam_ch, *tmp;
+
+ setup(sam_ch, "enc_sam_response_enc",
+ ktest_make_sample_enc_sam_response_enc);
+ leak_test(sam_ch, encode_krb5_enc_sam_response_enc,
+ decode_krb5_enc_sam_response_enc,
+ krb5_free_enc_sam_response_enc);
+ ktest_empty_enc_sam_response_enc(&sam_ch);
+ }
+ /****************************************************************/
+ /* encode_krb5_predicted_sam_response */
+ {
+ krb5_predicted_sam_response sam_ch, *tmp;
+
+ setup(sam_ch, "predicted_sam_response",
+ ktest_make_sample_predicted_sam_response);
+ leak_test(sam_ch, encode_krb5_predicted_sam_response,
+ decode_krb5_predicted_sam_response,
+ krb5_free_predicted_sam_response);
+ ktest_empty_predicted_sam_response(&sam_ch);
+ }
+ /****************************************************************/
+ /* encode_krb5_sam_response_2 */
+ {
+ krb5_sam_response_2 sam_ch2, *tmp;
+
+ setup(sam_ch2, "sam_response_2", ktest_make_sample_sam_response_2);
+ leak_test(sam_ch2, encode_krb5_sam_response_2,
+ decode_krb5_sam_response_2, krb5_free_sam_response_2);
+ ktest_empty_sam_response_2(&sam_ch2);
+ }
+ /****************************************************************/
+ /* encode_krb5_sam_response_enc_2 */
+ {
+ krb5_enc_sam_response_enc_2 sam_ch2, *tmp;
+
+ setup(sam_ch2, "enc_sam_response_enc_2",
+ ktest_make_sample_enc_sam_response_enc_2);
+ leak_test(sam_ch2, encode_krb5_enc_sam_response_enc_2,
+ decode_krb5_enc_sam_response_enc_2,
+ krb5_free_enc_sam_response_enc_2);
+ ktest_empty_enc_sam_response_enc_2(&sam_ch2);
+ }
+
+ krb5_free_context(test_context);
+ return 0;
+}
More information about the cvs-krb5
mailing list