diff options
Diffstat (limited to 'src/tests/asn.1/ktest.c')
-rw-r--r-- | src/tests/asn.1/ktest.c | 1353 |
1 files changed, 511 insertions, 842 deletions
diff --git a/src/tests/asn.1/ktest.c b/src/tests/asn.1/ktest.c index 90a7c1c4d9..1580e22775 100644 --- a/src/tests/asn.1/ktest.c +++ b/src/tests/asn.1/ktest.c @@ -30,207 +30,144 @@ char *sample_principal_name = "hftsai/extra@ATHENA.MIT.EDU"; -krb5_error_code ktest_make_sample_authenticator(a) - krb5_authenticator * a; +void +ktest_make_sample_authenticator(krb5_authenticator *a) { - krb5_error_code retval; - - retval = ktest_make_sample_principal(&(a->client)); - if (retval) return retval; - a->checksum = (krb5_checksum*)calloc(1,sizeof(krb5_checksum)); - if (a->checksum == NULL) return ENOMEM; - retval = ktest_make_sample_checksum(a->checksum); - if (retval) return retval; + ktest_make_sample_principal(&a->client); + a->checksum = ealloc(sizeof(krb5_checksum)); + ktest_make_sample_checksum(a->checksum); a->cusec = SAMPLE_USEC; a->ctime = SAMPLE_TIME; - a->subkey = (krb5_keyblock*)calloc(1,sizeof(krb5_keyblock)); - if (a->subkey == NULL) return ENOMEM; - retval = ktest_make_sample_keyblock(a->subkey); - if (retval) return retval; + a->subkey = ealloc(sizeof(krb5_keyblock)); + ktest_make_sample_keyblock(a->subkey); a->seq_number = SAMPLE_SEQ_NUMBER; - retval = ktest_make_sample_authorization_data(&(a->authorization_data)); - if (retval) return retval; - - return 0; + ktest_make_sample_authorization_data(&a->authorization_data); } -krb5_error_code ktest_make_sample_principal(p) - krb5_principal * p; +void +ktest_make_sample_principal(krb5_principal *p) { - krb5_error_code retval; - - retval = krb5_parse_name(test_context, sample_principal_name, p); - return retval; + if (krb5_parse_name(test_context, sample_principal_name, p)) + abort(); } -krb5_error_code ktest_make_sample_checksum(cs) - krb5_checksum * cs; +void +ktest_make_sample_checksum(krb5_checksum *cs) { cs->checksum_type = 1; cs->length = 4; - cs->contents = (krb5_octet*)calloc(4,sizeof(krb5_octet)); - if (cs->contents == NULL) return ENOMEM; + cs->contents = ealloc(4); memcpy(cs->contents,"1234",4); - - return 0; } -krb5_error_code ktest_make_sample_keyblock(kb) - krb5_keyblock * kb; +void +ktest_make_sample_keyblock(krb5_keyblock *kb) { kb->magic = KV5M_KEYBLOCK; kb->enctype = 1; kb->length = 8; - kb->contents = (krb5_octet*)calloc(8,sizeof(krb5_octet)); - if (kb->contents == NULL) return ENOMEM; + kb->contents = ealloc(8); memcpy(kb->contents,"12345678",8); - - return 0; } -krb5_error_code ktest_make_sample_ticket(tkt) - krb5_ticket * tkt; +void +ktest_make_sample_ticket(krb5_ticket *tkt) { - krb5_error_code retval; - - retval = ktest_make_sample_principal(&(tkt->server)); - if (retval) return retval; - retval = ktest_make_sample_enc_data(&(tkt->enc_part)); - if (retval) return retval; + ktest_make_sample_principal(&tkt->server); + ktest_make_sample_enc_data(&tkt->enc_part); tkt->enc_part2 = NULL; - - return 0; } -krb5_error_code ktest_make_sample_enc_data(ed) - krb5_enc_data * ed; +void +ktest_make_sample_enc_data(krb5_enc_data *ed) { - krb5_error_code retval; - ed->kvno = 5; ed->enctype = 0; - retval = krb5_data_parse(&(ed->ciphertext),"krbASN.1 test message"); - if (retval) return retval; - - return 0; + krb5_data_parse(&ed->ciphertext, "krbASN.1 test message"); } -krb5_error_code ktest_make_sample_enc_tkt_part(etp) - krb5_enc_tkt_part * etp; +void +ktest_make_sample_enc_tkt_part(krb5_enc_tkt_part *etp) { - krb5_error_code retval; - etp->flags = SAMPLE_FLAGS; - etp->session = (krb5_keyblock*)calloc(1,sizeof(krb5_keyblock)); - if (etp->session == NULL) return ENOMEM; - retval = ktest_make_sample_keyblock(etp->session); - if (retval) return retval; - retval = ktest_make_sample_principal(&(etp->client)); - if (retval) return retval; - retval = ktest_make_sample_transited(&(etp->transited)); - if (retval) return retval; - retval = ktest_make_sample_ticket_times(&(etp->times)); - if (retval) return retval; - retval = ktest_make_sample_addresses(&(etp->caddrs)); - if (retval) return retval; - retval = ktest_make_sample_authorization_data(&(etp->authorization_data)); - if (retval) return retval; - return 0; -} - -krb5_error_code ktest_make_sample_addresses(caddrs) - krb5_address *** caddrs; -{ - asn1_error_code retval; + etp->session = ealloc(sizeof(krb5_keyblock)); + ktest_make_sample_keyblock(etp->session); + ktest_make_sample_principal(&etp->client); + ktest_make_sample_transited(&etp->transited); + ktest_make_sample_ticket_times(&etp->times); + ktest_make_sample_addresses(&etp->caddrs); + ktest_make_sample_authorization_data(&etp->authorization_data); +} + +void +ktest_make_sample_addresses(krb5_address ***caddrs) +{ int i; - *caddrs = (krb5_address**)calloc(3,sizeof(krb5_address*)); - if (*caddrs == NULL) return ENOMEM; - for (i=0; i<2; i++) { - (*caddrs)[i] = (krb5_address*)calloc(1,sizeof(krb5_address)); - if ((*caddrs)[i] == NULL) return ENOMEM; - retval = ktest_make_sample_address((*caddrs)[i]); - if (retval) return retval; + *caddrs = ealloc(3 * sizeof(krb5_address *)); + for (i = 0; i < 2; i++) { + (*caddrs)[i] = ealloc(sizeof(krb5_address)); + ktest_make_sample_address((*caddrs)[i]); } (*caddrs)[2] = NULL; - return 0; } -krb5_error_code ktest_make_sample_authorization_data(ad) - krb5_authdata *** ad; +void +ktest_make_sample_authorization_data(krb5_authdata ***ad) { - krb5_error_code retval; int i; - *ad = (krb5_authdata**)calloc(3,sizeof(krb5_authdata*)); - if (*ad == NULL) return ENOMEM; - - for (i=0; i<=1; i++) { - (*ad)[i] = (krb5_authdata*)calloc(1,sizeof(krb5_authdata)); - if ((*ad)[i] == NULL) return ENOMEM; - retval = ktest_make_sample_authdata((*ad)[i]); - if (retval) return retval; + *ad = ealloc(3 * sizeof(krb5_authdata *)); + for (i = 0; i <= 1; i++) { + (*ad)[i] = ealloc(sizeof(krb5_authdata)); + ktest_make_sample_authdata((*ad)[i]); } (*ad)[2] = NULL; - - return 0; } -krb5_error_code ktest_make_sample_transited(t) - krb5_transited * t; +void +ktest_make_sample_transited(krb5_transited *t) { t->tr_type = 1; - return krb5_data_parse(&(t->tr_contents), - "EDU,MIT.,ATHENA.,WASHINGTON.EDU,CS."); + krb5_data_parse(&t->tr_contents, "EDU,MIT.,ATHENA.,WASHINGTON.EDU,CS."); } -krb5_error_code ktest_make_sample_ticket_times(tt) - krb5_ticket_times * tt; +void +ktest_make_sample_ticket_times(krb5_ticket_times *tt) { tt->authtime = SAMPLE_TIME; tt->starttime = SAMPLE_TIME; tt->endtime = SAMPLE_TIME; tt->renew_till = SAMPLE_TIME; - return 0; } -krb5_error_code ktest_make_sample_address(a) - krb5_address * a; +void +ktest_make_sample_address(krb5_address *a) { a->addrtype = ADDRTYPE_INET; a->length = 4; - a->contents = (krb5_octet*)calloc(4,sizeof(krb5_octet)); - if (a->contents == NULL) return ENOMEM; + a->contents = ealloc(4 * sizeof(krb5_octet)); a->contents[0] = 18; a->contents[1] = 208; a->contents[2] = 0; a->contents[3] = 35; - - return 0; } -krb5_error_code ktest_make_sample_authdata(ad) - krb5_authdata * ad; +void +ktest_make_sample_authdata(krb5_authdata *ad) { ad->ad_type = 1; ad->length = 6; - ad->contents = (krb5_octet*)calloc(6,sizeof(krb5_octet)); - if (ad->contents == NULL) return ENOMEM; - memcpy(ad->contents,"foobar",6); - return 0; + ad->contents = ealloc(6 * sizeof(krb5_octet)); + memcpy(ad->contents, "foobar", 6); } -krb5_error_code ktest_make_sample_enc_kdc_rep_part(ekr) - krb5_enc_kdc_rep_part * ekr; +void +ktest_make_sample_enc_kdc_rep_part(krb5_enc_kdc_rep_part *ekr) { - krb5_error_code retval; - - ekr->session = (krb5_keyblock*)calloc(1,sizeof(krb5_keyblock)); - if (ekr->session == NULL) return ENOMEM; - retval = ktest_make_sample_keyblock(ekr->session); - if (retval) return retval; - retval = ktest_make_sample_last_req(&(ekr->last_req)); - if (retval) return retval; + ekr->session = ealloc(sizeof(krb5_keyblock)); + ktest_make_sample_keyblock(ekr->session); + ktest_make_sample_last_req(&ekr->last_req); ekr->nonce = SAMPLE_NONCE; ekr->key_exp = SAMPLE_TIME; ekr->flags = SAMPLE_FLAGS; @@ -238,180 +175,122 @@ krb5_error_code ktest_make_sample_enc_kdc_rep_part(ekr) ekr->times.starttime = SAMPLE_TIME; ekr->times.endtime = SAMPLE_TIME; ekr->times.renew_till = SAMPLE_TIME; - retval = ktest_make_sample_principal(&(ekr->server)); - if (retval) return retval; - retval = ktest_make_sample_addresses(&(ekr->caddrs)); - if (retval) return retval; - - return 0; + ktest_make_sample_principal(&ekr->server); + ktest_make_sample_addresses(&ekr->caddrs); } -krb5_error_code ktest_make_sample_last_req(lr) - krb5_last_req_entry *** lr; +void +ktest_make_sample_last_req(krb5_last_req_entry ***lr) { - krb5_error_code retval; int i; - *lr = (krb5_last_req_entry**)calloc(3,sizeof(krb5_last_req_entry*)); - if (*lr == NULL) return ENOMEM; - for (i=0; i<=1; i++) { - retval = ktest_make_sample_last_req_entry(&((*lr)[i])); - if (retval) return retval; - } + *lr = ealloc(3 * sizeof(krb5_last_req_entry *)); + for (i = 0; i <= 1; i++) + ktest_make_sample_last_req_entry(&(*lr)[i]); (*lr)[2] = NULL; - return 0; } -krb5_error_code ktest_make_sample_last_req_entry(lre) - krb5_last_req_entry ** lre; +void +ktest_make_sample_last_req_entry(krb5_last_req_entry **lre) { - *lre = (krb5_last_req_entry*)calloc(1,sizeof(krb5_last_req_entry)); - if (*lre == NULL) return ENOMEM; + *lre = ealloc(sizeof(krb5_last_req_entry)); (*lre)->lr_type = -5; (*lre)->value = SAMPLE_TIME; - return 0; } -krb5_error_code ktest_make_sample_kdc_rep(kdcr) - krb5_kdc_rep * kdcr; +void +ktest_make_sample_kdc_rep(krb5_kdc_rep *kdcr) { - krb5_error_code retval; - - retval = ktest_make_sample_pa_data_array(&(kdcr->padata)); - if (retval) return retval; - retval = ktest_make_sample_principal(&(kdcr->client)); - if (retval) return retval; - kdcr->ticket = (krb5_ticket*)calloc(1,sizeof(krb5_ticket)); - if (kdcr->ticket == NULL) return ENOMEM; - retval = ktest_make_sample_ticket(kdcr->ticket); - if (retval) return retval; - retval = ktest_make_sample_enc_data(&(kdcr->enc_part)); - if (retval) return retval; + ktest_make_sample_pa_data_array(&kdcr->padata); + ktest_make_sample_principal(&kdcr->client); + kdcr->ticket = ealloc(sizeof(krb5_ticket)); + ktest_make_sample_ticket(kdcr->ticket); + ktest_make_sample_enc_data(&kdcr->enc_part); kdcr->enc_part2 = NULL; - - return 0; } -krb5_error_code ktest_make_sample_pa_data_array(pad) - krb5_pa_data *** pad; +void +ktest_make_sample_pa_data_array(krb5_pa_data ***pad) { - krb5_error_code retval; int i; - *pad = (krb5_pa_data**)calloc(3,sizeof(krb5_pa_data*)); - if (*pad == NULL) return ENOMEM; - - for (i=0; i<=1; i++) { - (*pad)[i] = (krb5_pa_data*)calloc(1,sizeof(krb5_pa_data)); - if ((*pad)[i] == NULL) return ENOMEM; - retval = ktest_make_sample_pa_data((*pad)[i]); - if (retval) return retval; + *pad = ealloc(3 * sizeof(krb5_pa_data *)); + for (i = 0; i <= 1; i++) { + (*pad)[i] = ealloc(sizeof(krb5_pa_data)); + ktest_make_sample_pa_data((*pad)[i]); } (*pad)[2] = NULL; - - return 0; } -krb5_error_code ktest_make_sample_empty_pa_data_array(pad) - krb5_pa_data *** pad; +void +ktest_make_sample_empty_pa_data_array(krb5_pa_data ***pad) { - *pad = (krb5_pa_data**)calloc(1,sizeof(krb5_pa_data*)); - if (*pad == NULL) return ENOMEM; - + *pad = ealloc(sizeof(krb5_pa_data *)); (*pad)[0] = NULL; - - return 0; } -krb5_error_code ktest_make_sample_pa_data(pad) - krb5_pa_data * pad; +void +ktest_make_sample_pa_data(krb5_pa_data *pad) { pad->pa_type = 13; pad->length = 7; - pad->contents = (krb5_octet*)calloc(7,sizeof(krb5_octet)); - if (pad->contents == NULL) return ENOMEM; - memcpy(pad->contents,"pa-data",7); - return 0; + pad->contents = ealloc(7); + memcpy(pad->contents, "pa-data", 7); } -krb5_error_code ktest_make_sample_ap_req(ar) - krb5_ap_req * ar; +void +ktest_make_sample_ap_req(krb5_ap_req *ar) { - krb5_error_code retval; ar->ap_options = SAMPLE_FLAGS; - ar->ticket = (krb5_ticket*)calloc(1,sizeof(krb5_ticket)); - if (ar->ticket == NULL) return ENOMEM; - retval = ktest_make_sample_ticket(ar->ticket); - if (retval) return retval; - retval = ktest_make_sample_enc_data(&(ar->authenticator)); - if (retval) return retval; - return 0; + ar->ticket = ealloc(sizeof(krb5_ticket)); + ktest_make_sample_ticket(ar->ticket); + ktest_make_sample_enc_data(&(ar->authenticator)); } -krb5_error_code ktest_make_sample_ap_rep(ar) - krb5_ap_rep * ar; +void +ktest_make_sample_ap_rep(krb5_ap_rep *ar) { - return ktest_make_sample_enc_data(&(ar->enc_part)); + ktest_make_sample_enc_data(&ar->enc_part); } -krb5_error_code ktest_make_sample_ap_rep_enc_part(arep) - krb5_ap_rep_enc_part * arep; +void +ktest_make_sample_ap_rep_enc_part(krb5_ap_rep_enc_part *arep) { - krb5_error_code retval; - arep->ctime = SAMPLE_TIME; arep->cusec = SAMPLE_USEC; - arep->subkey = (krb5_keyblock*)calloc(1,sizeof(krb5_keyblock)); - if (arep->subkey == NULL) return ENOMEM; - retval = ktest_make_sample_keyblock(arep->subkey); - if (retval) return retval; + arep->subkey = ealloc(sizeof(krb5_keyblock)); + ktest_make_sample_keyblock(arep->subkey); arep->seq_number = SAMPLE_SEQ_NUMBER; - - return 0; } -krb5_error_code ktest_make_sample_kdc_req(kr) - krb5_kdc_req * kr; +void +ktest_make_sample_kdc_req(krb5_kdc_req *kr) { - krb5_error_code retval; - /* msg_type is left up to the calling procedure */ - retval = ktest_make_sample_pa_data_array(&(kr->padata)); - if (retval) return retval; + ktest_make_sample_pa_data_array(&kr->padata); kr->kdc_options = SAMPLE_FLAGS; - retval = ktest_make_sample_principal(&(kr->client)); - if (retval) return retval; - retval = ktest_make_sample_principal(&(kr->server)); - if (retval) return retval; + ktest_make_sample_principal(&(kr->client)); + ktest_make_sample_principal(&(kr->server)); kr->from = SAMPLE_TIME; kr->till = SAMPLE_TIME; kr->rtime = SAMPLE_TIME; kr->nonce = SAMPLE_NONCE; kr->nktypes = 2; - kr->ktype = (krb5_enctype*)calloc(2,sizeof(krb5_enctype)); + kr->ktype = ealloc(2 * sizeof(krb5_enctype)); kr->ktype[0] = 0; kr->ktype[1] = 1; - retval = ktest_make_sample_addresses(&(kr->addresses)); - if (retval) return retval; - retval = ktest_make_sample_enc_data(&(kr->authorization_data)); - if (retval) return retval; - retval = ktest_make_sample_authorization_data(&(kr->unenc_authdata)); - if (retval) return retval; - retval = ktest_make_sample_sequence_of_ticket(&(kr->second_ticket)); - if (retval) return retval; - return 0; + ktest_make_sample_addresses(&kr->addresses); + ktest_make_sample_enc_data(&kr->authorization_data); + ktest_make_sample_authorization_data(&kr->unenc_authdata); + ktest_make_sample_sequence_of_ticket(&kr->second_ticket); } -krb5_error_code ktest_make_sample_kdc_req_body(krb) - krb5_kdc_req * krb; +void +ktest_make_sample_kdc_req_body(krb5_kdc_req *krb) { - krb5_error_code retval; - krb->kdc_options = SAMPLE_FLAGS; - retval = ktest_make_sample_principal(&(krb->client)); - if (retval) return retval; - retval = ktest_make_sample_principal(&(krb->server)); - if (retval) return retval; + ktest_make_sample_principal(&krb->client); + ktest_make_sample_principal(&krb->server); krb->from = SAMPLE_TIME; krb->till = SAMPLE_TIME; krb->rtime = SAMPLE_TIME; @@ -420,266 +299,173 @@ krb5_error_code ktest_make_sample_kdc_req_body(krb) krb->ktype = (krb5_enctype*)calloc(2,sizeof(krb5_enctype)); krb->ktype[0] = 0; krb->ktype[1] = 1; - retval = ktest_make_sample_addresses(&(krb->addresses)); - if (retval) return retval; - retval = ktest_make_sample_enc_data(&(krb->authorization_data)); - if (retval) return retval; - retval = ktest_make_sample_authorization_data(&(krb->unenc_authdata)); - if (retval) return retval; - retval = ktest_make_sample_sequence_of_ticket(&(krb->second_ticket)); - if (retval) return retval; - return 0; + ktest_make_sample_addresses(&krb->addresses); + ktest_make_sample_enc_data(&krb->authorization_data); + ktest_make_sample_authorization_data(&krb->unenc_authdata); + ktest_make_sample_sequence_of_ticket(&krb->second_ticket); } -krb5_error_code ktest_make_sample_safe(s) - krb5_safe * s; +void +ktest_make_sample_safe(krb5_safe *s) { - krb5_error_code retval; - - retval = ktest_make_sample_data(&(s->user_data)); - if (retval) return retval; + ktest_make_sample_data(&s->user_data); s->timestamp = SAMPLE_TIME; s->usec = SAMPLE_USEC; s->seq_number = SAMPLE_SEQ_NUMBER; - s->s_address = (krb5_address*)calloc(1,sizeof(krb5_address)); - if (s->s_address == NULL) return ENOMEM; - retval = ktest_make_sample_address(s->s_address); - if (retval) return retval; - s->r_address = (krb5_address*)calloc(1,sizeof(krb5_address)); - if (s->r_address == NULL) return ENOMEM; - retval = ktest_make_sample_address(s->r_address); - if (retval) return retval; - s->checksum = (krb5_checksum*)calloc(1,sizeof(krb5_checksum)); - if (s->checksum == NULL) return ENOMEM; - retval = ktest_make_sample_checksum(s->checksum); - if (retval) return retval; - - return 0; + s->s_address = ealloc(sizeof(krb5_address)); + ktest_make_sample_address(s->s_address); + s->r_address = ealloc(sizeof(krb5_address)); + ktest_make_sample_address(s->r_address); + s->checksum = ealloc(sizeof(krb5_checksum)); + ktest_make_sample_checksum(s->checksum); } -krb5_error_code ktest_make_sample_priv(p) - krb5_priv * p; +void +ktest_make_sample_priv(krb5_priv *p) { - return ktest_make_sample_enc_data(&(p->enc_part)); + ktest_make_sample_enc_data(&p->enc_part); } -krb5_error_code ktest_make_sample_priv_enc_part(pep) - krb5_priv_enc_part * pep; +void +ktest_make_sample_priv_enc_part(krb5_priv_enc_part *pep) { - krb5_error_code retval; - retval = ktest_make_sample_data(&(pep->user_data)); - if (retval) return retval; + ktest_make_sample_data(&(pep->user_data)); pep->timestamp = SAMPLE_TIME; pep->usec = SAMPLE_USEC; pep->seq_number = SAMPLE_SEQ_NUMBER; - pep->s_address = (krb5_address*)calloc(1,sizeof(krb5_address)); - if (pep->s_address == NULL) return ENOMEM; - retval = ktest_make_sample_address(pep->s_address); - if (retval) return retval; - pep->r_address = (krb5_address*)calloc(1,sizeof(krb5_address)); - if (pep->r_address == NULL) return ENOMEM; - retval = ktest_make_sample_address(pep->r_address); - if (retval) return retval; - return 0; + pep->s_address = ealloc(sizeof(krb5_address)); + ktest_make_sample_address(pep->s_address); + pep->r_address = ealloc(sizeof(krb5_address)); + ktest_make_sample_address(pep->r_address); } -krb5_error_code ktest_make_sample_cred(c) - krb5_cred * c; +void +ktest_make_sample_cred(krb5_cred *c) { - krb5_error_code retval; - retval = ktest_make_sample_sequence_of_ticket(&(c->tickets)); - if (retval) return retval; - retval = ktest_make_sample_enc_data(&(c->enc_part)); - if (retval) return retval; - return 0; + ktest_make_sample_sequence_of_ticket(&c->tickets); + ktest_make_sample_enc_data(&c->enc_part); } -krb5_error_code ktest_make_sample_sequence_of_ticket(sot) - krb5_ticket *** sot; +void +ktest_make_sample_sequence_of_ticket(krb5_ticket ***sot) { - krb5_error_code retval; int i; - *sot = (krb5_ticket**)calloc(3,sizeof(krb5_ticket*)); - if (*sot == NULL) return ENOMEM; - for (i=0; i<2; i++) { - (*sot)[i] = (krb5_ticket*)calloc(1,sizeof(krb5_ticket)); - if ((*sot)[i] == NULL) return ENOMEM; - retval = ktest_make_sample_ticket((*sot)[i]); - if (retval) return retval; + *sot = ealloc(3 * sizeof(krb5_ticket *)); + for (i = 0; i < 2; i++) { + (*sot)[i] = ealloc(sizeof(krb5_ticket)); + ktest_make_sample_ticket((*sot)[i]); } (*sot)[2] = NULL; - - return 0; } -krb5_error_code ktest_make_sample_cred_enc_part(cep) - krb5_cred_enc_part * cep; +void +ktest_make_sample_cred_enc_part(krb5_cred_enc_part *cep) { - krb5_error_code retval; - cep->nonce = SAMPLE_NONCE; cep->timestamp = SAMPLE_TIME; cep->usec = SAMPLE_USEC; - cep->s_address = (krb5_address*)calloc(1,sizeof(krb5_address)); - if (cep->s_address == NULL) return ENOMEM; - retval = ktest_make_sample_address(cep->s_address); - if (retval) return retval; - cep->r_address = (krb5_address*)calloc(1,sizeof(krb5_address)); - if (cep->r_address == NULL) return ENOMEM; - retval = ktest_make_sample_address(cep->r_address); - if (retval) return retval; - retval = ktest_make_sequence_of_cred_info(&(cep->ticket_info)); - if (retval) return retval; - - return 0; + cep->s_address = ealloc(sizeof(krb5_address)); + ktest_make_sample_address(cep->s_address); + cep->r_address = ealloc(sizeof(krb5_address)); + ktest_make_sample_address(cep->r_address); + ktest_make_sequence_of_cred_info(&cep->ticket_info); } -krb5_error_code ktest_make_sequence_of_cred_info(soci) - krb5_cred_info *** soci; +void +ktest_make_sequence_of_cred_info(krb5_cred_info ***soci) { - krb5_error_code retval; int i; - *soci = (krb5_cred_info**)calloc(3,sizeof(krb5_cred_info*)); - if (*soci == NULL) return ENOMEM; - for (i=0; i<2; i++) { - (*soci)[i] = (krb5_cred_info*)calloc(1,sizeof(krb5_cred_info)); - if ((*soci)[i] == NULL) return ENOMEM; - retval = ktest_make_sample_cred_info((*soci)[i]); - if (retval) return retval; + *soci = ealloc(3 * sizeof(krb5_cred_info *)); + for (i = 0; i < 2; i++) { + (*soci)[i] = ealloc(sizeof(krb5_cred_info)); + ktest_make_sample_cred_info((*soci)[i]); } (*soci)[2] = NULL; - - return 0; } -krb5_error_code ktest_make_sample_cred_info(ci) - krb5_cred_info * ci; +void +ktest_make_sample_cred_info(krb5_cred_info *ci) { - krb5_error_code retval; - - ci->session = (krb5_keyblock*)calloc(1,sizeof(krb5_keyblock)); - if (ci->session == NULL) return ENOMEM; - retval = ktest_make_sample_keyblock(ci->session); - if (retval) return retval; - retval = ktest_make_sample_principal(&(ci->client)); - if (retval) return retval; - retval = ktest_make_sample_principal(&(ci->server)); - if (retval) return retval; + ci->session = ealloc(sizeof(krb5_keyblock)); + ktest_make_sample_keyblock(ci->session); + ktest_make_sample_principal(&ci->client); + ktest_make_sample_principal(&ci->server); ci->flags = SAMPLE_FLAGS; ci->times.authtime = SAMPLE_TIME; ci->times.starttime = SAMPLE_TIME; ci->times.endtime = SAMPLE_TIME; ci->times.renew_till = SAMPLE_TIME; - retval = ktest_make_sample_addresses(&(ci->caddrs)); - if (retval) return retval; - - return 0; + ktest_make_sample_addresses(&ci->caddrs); } -krb5_error_code ktest_make_sample_error(kerr) - krb5_error * kerr; +void +ktest_make_sample_error(krb5_error *kerr) { - krb5_error_code retval; - kerr->ctime = SAMPLE_TIME; kerr->cusec = SAMPLE_USEC; kerr->susec = SAMPLE_USEC; kerr->stime = SAMPLE_TIME; kerr->error = SAMPLE_ERROR; - retval = ktest_make_sample_principal(&(kerr->client)); - if (retval) return retval; - retval = ktest_make_sample_principal(&(kerr->server)); - if (retval) return retval; - retval = ktest_make_sample_data(&(kerr->text)); - if (retval) return retval; - retval = ktest_make_sample_data(&(kerr->e_data)); - if (retval) return retval; - - return 0; + ktest_make_sample_principal(&kerr->client); + ktest_make_sample_principal(&kerr->server); + ktest_make_sample_data(&kerr->text); + ktest_make_sample_data(&kerr->e_data); } -krb5_error_code ktest_make_sample_data(d) - krb5_data * d; +void +ktest_make_sample_data(krb5_data *d) { - d->data = (char*)calloc(8,sizeof(char)); - if (d->data == NULL) return ENOMEM; - d->length = 8; - memcpy(d->data,"krb5data",8); - - return 0; + krb5_data_parse(d, "krb5data"); } -krb5_error_code ktest_make_sample_passwd_phrase_element(ppe) - passwd_phrase_element * ppe; +void +ktest_make_sample_passwd_phrase_element(passwd_phrase_element *ppe) { - krb5_error_code retval; - - ppe->passwd = (krb5_data*)calloc(1,sizeof(krb5_data)); - if (ppe->passwd == NULL) return ENOMEM; - retval = ktest_make_sample_data(ppe->passwd); - if (retval) return retval; - ppe->phrase = (krb5_data*)calloc(1,sizeof(krb5_data)); - if (ppe->phrase == NULL) return ENOMEM; - retval = ktest_make_sample_data(ppe->phrase); - if (retval) return retval; - return 0; + ppe->passwd = ealloc(sizeof(krb5_data)); + ktest_make_sample_data(ppe->passwd); + ppe->phrase = ealloc(sizeof(krb5_data)); + ktest_make_sample_data(ppe->phrase); } -krb5_error_code ktest_make_sample_krb5_pwd_data(pd) - krb5_pwd_data * pd; +void +ktest_make_sample_krb5_pwd_data(krb5_pwd_data *pd) { - krb5_error_code retval; int i; pd->sequence_count = 2; - - pd->element = (passwd_phrase_element**)calloc(3,sizeof(passwd_phrase_element*)); - if (pd->element == NULL) return ENOMEM; - - for (i=0; i<=1; i++) { - pd->element[i] = (passwd_phrase_element*)calloc(1,sizeof(passwd_phrase_element)); - if (pd->element[i] == NULL) return ENOMEM; - retval = ktest_make_sample_passwd_phrase_element(pd->element[i]); - if (retval) return retval; + pd->element = ealloc(3 * sizeof(passwd_phrase_element *)); + for (i = 0; i <= 1; i++) { + pd->element[i] = ealloc(sizeof(passwd_phrase_element)); + ktest_make_sample_passwd_phrase_element(pd->element[i]); } pd->element[2] = NULL; - - return 0; } -krb5_error_code ktest_make_sample_alt_method(p) - krb5_alt_method * p; +void +ktest_make_sample_alt_method(krb5_alt_method *p) { p->method = 42; - p->data = (krb5_octet *) strdup("secret"); - if (p->data == NULL) return ENOMEM; - p->length = strlen((char *) p->data); - return 0; + p->data = (unsigned char *)estrdup("secret"); + p->length = strlen((char *)p->data); } -krb5_error_code ktest_make_sample_etype_info(p) - krb5_etype_info_entry *** p; +void +ktest_make_sample_etype_info(krb5_etype_info_entry ***p) { krb5_etype_info_entry **info; int i, len; char *str; - info = malloc(sizeof(krb5_etype_info_entry *) * 4); - if (!info) - return ENOMEM; - memset(info, 0, sizeof(krb5_etype_info_entry *) * 4); - - for (i=0; i < 3; i++) { - info[i] = malloc(sizeof(krb5_etype_info_entry)); - if (info[i] == 0) - goto memfail; + info = ealloc(4 * sizeof(krb5_etype_info_entry *)); + for (i = 0; i < 3; i++) { + info[i] = ealloc(sizeof(krb5_etype_info_entry)); info[i]->etype = i; len = asprintf(&str, "Morton's #%d", i); if (len < 0) - goto memfail; - info[i]->salt = (krb5_octet *) str; + abort(); + info[i]->salt = (krb5_octet *)str; info[i]->length = len; info[i]->s2kparams.data = NULL; info[i]->s2kparams.length = 0; @@ -689,38 +475,28 @@ krb5_error_code ktest_make_sample_etype_info(p) info[1]->length = KRB5_ETYPE_NO_SALT; info[1]->salt = 0; *p = info; - return 0; -memfail: - ktest_destroy_etype_info(info); - return ENOMEM; } -krb5_error_code ktest_make_sample_etype_info2(p) - krb5_etype_info_entry *** p; +void +ktest_make_sample_etype_info2(krb5_etype_info_entry ***p) { krb5_etype_info_entry **info; int i, len; char *str; - info = malloc(sizeof(krb5_etype_info_entry *) * 4); - if (!info) - return ENOMEM; - memset(info, 0, sizeof(krb5_etype_info_entry *) * 4); - - for (i=0; i < 3; i++) { - info[i] = malloc(sizeof(krb5_etype_info_entry)); - if (info[i] == 0) - goto memfail; + info = ealloc(4 * sizeof(krb5_etype_info_entry *)); + for (i = 0; i < 3; i++) { + info[i] = ealloc(sizeof(krb5_etype_info_entry)); info[i]->etype = i; len = asprintf(&str, "Morton's #%d", i); if (len < 0) - goto memfail; - info[i]->salt = (krb5_octet *) str; - info[i]->length = (unsigned int) len; + abort(); + info[i]->salt = (krb5_octet *)str; + info[i]->length = (unsigned int)len; len = asprintf(&info[i]->s2kparams.data, "s2k: %d", i); if (len < 0) - goto memfail; + abort(); info[i]->s2kparams.length = (unsigned int) len; info[i]->magic = KV5M_ETYPE_INFO_ENTRY; } @@ -728,285 +504,207 @@ krb5_error_code ktest_make_sample_etype_info2(p) info[1]->length = KRB5_ETYPE_NO_SALT; info[1]->salt = 0; *p = info; - return 0; -memfail: - ktest_destroy_etype_info(info); - return ENOMEM; } -krb5_error_code ktest_make_sample_pa_enc_ts(pa_enc) - krb5_pa_enc_ts * pa_enc; +void +ktest_make_sample_pa_enc_ts(krb5_pa_enc_ts *pa_enc) { pa_enc->patimestamp = SAMPLE_TIME; pa_enc->pausec = SAMPLE_USEC; - - return 0; } -krb5_error_code ktest_make_sample_sam_challenge(p) - krb5_sam_challenge * p; +void +ktest_make_sample_sam_challenge(krb5_sam_challenge *p) { - krb5_error_code retval; - p->magic = KV5M_SAM_CHALLENGE; p->sam_type = 42; /* information */ p->sam_flags = KRB5_SAM_USE_SAD_AS_KEY; /* KRB5_SAM_* values */ - p->sam_type_name.data = strdup("type name"); - if (p->sam_type_name.data == NULL) return ENOMEM; - p->sam_type_name.length = strlen(p->sam_type_name.data); - p->sam_track_id.data = 0; - p->sam_track_id.length = 0; - p->sam_challenge_label.data = strdup("challenge label"); - if (p->sam_challenge_label.data == NULL) return ENOMEM; - p->sam_challenge_label.length = strlen(p->sam_challenge_label.data); - p->sam_challenge.data = strdup("challenge ipse"); - if (p->sam_challenge.data == NULL) return ENOMEM; - p->sam_challenge.length = strlen(p->sam_challenge.data); - p->sam_response_prompt.data = strdup("response_prompt ipse"); - if (p->sam_response_prompt.data == NULL) return ENOMEM; - p->sam_response_prompt.length = strlen(p->sam_response_prompt.data); - p->sam_pk_for_sad.data = 0; - p->sam_pk_for_sad.length = 0; + krb5_data_parse(&p->sam_type_name, "type name"); + p->sam_track_id = empty_data(); + krb5_data_parse(&p->sam_challenge_label, "challenge label"); + krb5_data_parse(&p->sam_challenge, "challenge ipse"); + krb5_data_parse(&p->sam_response_prompt, "response_prompt ipse"); + p->sam_pk_for_sad = empty_data(); p->sam_nonce = 0x543210; - retval = ktest_make_sample_checksum(&p->sam_cksum); - if (retval) return retval; - - return 0; + ktest_make_sample_checksum(&p->sam_cksum); } -krb5_error_code ktest_make_sample_sam_response(p) - krb5_sam_response * p; +void +ktest_make_sample_sam_response(krb5_sam_response *p) { p->magic = KV5M_SAM_RESPONSE; p->sam_type = 42; /* information */ p->sam_flags = KRB5_SAM_USE_SAD_AS_KEY; /* KRB5_SAM_* values */ - p->sam_track_id.data = strdup("track data"); - if (p->sam_track_id.data == NULL) return ENOMEM; - p->sam_track_id.length = strlen(p->sam_track_id.data); - p->sam_enc_key.ciphertext.data = strdup("key"); - if (p->sam_enc_key.ciphertext.data == NULL) return ENOMEM; - p->sam_enc_key.ciphertext.length = strlen(p->sam_enc_key.ciphertext.data); + krb5_data_parse(&p->sam_track_id, "track data"); + krb5_data_parse(&p->sam_enc_key.ciphertext, "key"); p->sam_enc_key.enctype = ENCTYPE_DES_CBC_CRC; p->sam_enc_key.kvno = 1942; - p->sam_enc_nonce_or_ts.ciphertext.data = strdup("nonce or ts"); - if (p->sam_enc_nonce_or_ts.ciphertext.data == NULL) return ENOMEM; - p->sam_enc_nonce_or_ts.ciphertext.length = - strlen(p->sam_enc_nonce_or_ts.ciphertext.data); + krb5_data_parse(&p->sam_enc_nonce_or_ts.ciphertext, "nonce or ts"); p->sam_enc_nonce_or_ts.enctype = ENCTYPE_DES_CBC_CRC; p->sam_enc_nonce_or_ts.kvno = 3382; p->sam_nonce = 0x543210; p->sam_patimestamp = SAMPLE_TIME; - - return 0; } -krb5_error_code ktest_make_sample_sam_response_2(p) - krb5_sam_response_2 * p; + +void +ktest_make_sample_sam_response_2(krb5_sam_response_2 *p) { p->magic = KV5M_SAM_RESPONSE; p->sam_type = 43; /* information */ p->sam_flags = KRB5_SAM_USE_SAD_AS_KEY; /* KRB5_SAM_* values */ - p->sam_track_id.data = strdup("track data"); - if (p->sam_track_id.data == NULL) return ENOMEM; - p->sam_track_id.length = strlen(p->sam_track_id.data); - p->sam_enc_nonce_or_sad.ciphertext.data = strdup("nonce or sad"); - if (p->sam_enc_nonce_or_sad.ciphertext.data == NULL) return ENOMEM; - p->sam_enc_nonce_or_sad.ciphertext.length = - strlen(p->sam_enc_nonce_or_sad.ciphertext.data); + krb5_data_parse(&p->sam_track_id, "track data"); + krb5_data_parse(&p->sam_enc_nonce_or_sad.ciphertext, "nonce or sad"); p->sam_enc_nonce_or_sad.enctype = ENCTYPE_DES_CBC_CRC; p->sam_enc_nonce_or_sad.kvno = 3382; p->sam_nonce = 0x543210; - - return 0; } -krb5_error_code ktest_make_sample_sam_key(p) - krb5_sam_key *p; +void +ktest_make_sample_sam_key(krb5_sam_key *p) { p->magic = 99; - return ktest_make_sample_keyblock(&p->sam_key); + ktest_make_sample_keyblock(&p->sam_key); } -krb5_error_code ktest_make_sample_enc_sam_response_enc(p) - krb5_enc_sam_response_enc *p; +void +ktest_make_sample_enc_sam_response_enc(krb5_enc_sam_response_enc *p) { p->magic = 78; p->sam_nonce = 78634; p->sam_timestamp = 99999; p->sam_usec = 399; - p->sam_sad.data = strdup("enc_sam_response_enc"); - if (p->sam_sad.data == NULL) return ENOMEM; - p->sam_sad.length = strlen(p->sam_sad.data); - return 0; + krb5_data_parse(&p->sam_sad, "enc_sam_response_enc"); } -krb5_error_code ktest_make_sample_enc_sam_response_enc_2(p) - krb5_enc_sam_response_enc_2 *p; +void +ktest_make_sample_enc_sam_response_enc_2(krb5_enc_sam_response_enc_2 *p) { p->magic = 83; p->sam_nonce = 88; - p->sam_sad.data = strdup("enc_sam_response_enc_2"); - if (p->sam_sad.data == NULL) return ENOMEM; - p->sam_sad.length = strlen(p->sam_sad.data); - return 0; + krb5_data_parse(&p->sam_sad, "enc_sam_response_enc_2"); } -krb5_error_code ktest_make_sample_pa_s4u_x509_user(p) - krb5_pa_s4u_x509_user *p; +void +ktest_make_sample_pa_s4u_x509_user(krb5_pa_s4u_x509_user *p) { - krb5_error_code retval; krb5_s4u_userid *u = &p->user_id; + u->nonce = 13243546; - retval = ktest_make_sample_principal(&u->user); - if (retval) return retval; - u->subject_cert.data = strdup("pa_s4u_x509_user"); - if (u->subject_cert.data == NULL) return ENOMEM; - u->subject_cert.length = strlen(u->subject_cert.data); + ktest_make_sample_principal(&u->user); + krb5_data_parse(&u->subject_cert, "pa_s4u_x509_user"); u->options = 0x80000000; - retval = ktest_make_sample_checksum(&p->cksum); - if (retval) return retval; - return 0; + ktest_make_sample_checksum(&p->cksum); } -krb5_error_code ktest_make_sample_ad_kdcissued(p) - krb5_ad_kdcissued *p; +void +ktest_make_sample_ad_kdcissued(krb5_ad_kdcissued *p) { - krb5_error_code retval; - retval = ktest_make_sample_checksum(&p->ad_checksum); - if (retval) return retval; - retval = ktest_make_sample_principal(&p->i_principal); - if (retval) return retval; - retval = ktest_make_sample_authorization_data(&p->elements); - if (retval) return retval; - return retval; + ktest_make_sample_checksum(&p->ad_checksum); + ktest_make_sample_principal(&p->i_principal); + ktest_make_sample_authorization_data(&p->elements); } -krb5_error_code ktest_make_sample_ad_signedpath_data(p) - krb5_ad_signedpath_data *p; +void +ktest_make_sample_ad_signedpath_data(krb5_ad_signedpath_data *p) { - krb5_error_code retval; - retval = ktest_make_sample_principal(&p->client); - if (retval) return retval; + ktest_make_sample_principal(&p->client); p->authtime = SAMPLE_TIME; - p->delegated = k5alloc((2 * sizeof(krb5_principal)), &retval); - if (retval) return retval; - retval = ktest_make_sample_principal(&p->delegated[0]); - if (retval) return retval; + p->delegated = ealloc(2 * sizeof(krb5_principal)); + ktest_make_sample_principal(&p->delegated[0]); p->delegated[1] = NULL; - retval = ktest_make_sample_authorization_data(&p->authorization_data); - if (retval) return retval; - retval = ktest_make_sample_pa_data_array(&p->method_data); - if (retval) return retval; - return retval; + ktest_make_sample_authorization_data(&p->authorization_data); + ktest_make_sample_pa_data_array(&p->method_data); } -krb5_error_code ktest_make_sample_ad_signedpath(p) - krb5_ad_signedpath*p; +void +ktest_make_sample_ad_signedpath(krb5_ad_signedpath *p) { - krb5_error_code retval; p->enctype = 1; - retval = ktest_make_sample_checksum(&p->checksum); - if (retval) return retval; - p->delegated = k5alloc((2 * sizeof(krb5_principal)), &retval); - if (retval) return retval; + ktest_make_sample_checksum(&p->checksum); + p->delegated = ealloc(2 * sizeof(krb5_principal)); p->delegated[1] = NULL; - retval = ktest_make_sample_pa_data_array(&p->method_data); - if (retval) return retval; - return retval; + ktest_make_sample_pa_data_array(&p->method_data); } -krb5_error_code ktest_make_sample_iakerb_header(ih) - krb5_iakerb_header *ih; +void +ktest_make_sample_iakerb_header(krb5_iakerb_header *ih) { - krb5_error_code retval; - retval = ktest_make_sample_data(&(ih->target_realm)); - if (retval) return retval; - ih->cookie = k5alloc(sizeof(krb5_data), &retval); - if (retval) return retval; - retval = ktest_make_sample_data(ih->cookie); - if (retval) return retval; - return retval; + ktest_make_sample_data(&(ih->target_realm)); + ih->cookie = ealloc(sizeof(krb5_data)); + ktest_make_sample_data(ih->cookie); } -krb5_error_code ktest_make_sample_iakerb_finished(ih) - krb5_iakerb_finished *ih; +void +ktest_make_sample_iakerb_finished(krb5_iakerb_finished *ih) { - krb5_error_code retval; - retval = ktest_make_sample_checksum(&ih->checksum); - if (retval) return retval; - return retval; + ktest_make_sample_checksum(&ih->checksum); } #ifdef ENABLE_LDAP -static krb5_error_code ktest_make_sample_key_data(krb5_key_data *p, int i) +static void +ktest_make_sample_key_data(krb5_key_data *p, int i) { char *str; int len; + p->key_data_ver = 2; p->key_data_kvno = 42; len = asprintf(&str, "key%d", i); + if (len < 0) + abort(); p->key_data_type[0] = 2; p->key_data_length[0] = (unsigned int) len; - p->key_data_contents[0] = (krb5_octet *) str; + p->key_data_contents[0] = (krb5_octet *)str; len = asprintf(&str, "salt%d", i); + if (len < 0) + abort(); p->key_data_type[1] = i; p->key_data_length[1] = (unsigned int) len; - p->key_data_contents[1] = (krb5_octet *) str; - if (p->key_data_contents[0] == NULL || p->key_data_contents[1] == NULL) - return ENOMEM; - return 0; + p->key_data_contents[1] = (krb5_octet *)str; } -krb5_error_code ktest_make_sample_ldap_seqof_key_data(p) - ldap_seqof_key_data *p; +void +ktest_make_sample_ldap_seqof_key_data(ldap_seqof_key_data *p) { int i; + p->mkvno = 14; p->n_key_data = 3; p->key_data = calloc(3,sizeof(krb5_key_data)); - for (i = 0; i < 3; i++) { - krb5_error_code ret; - ret = ktest_make_sample_key_data(&p->key_data[i], i); - if (ret) return ret; - } - return 0; + for (i = 0; i < 3; i++) + ktest_make_sample_key_data(&p->key_data[i], i); } #endif -krb5_error_code ktest_make_sample_predicted_sam_response(p) - krb5_predicted_sam_response *p; +void +ktest_make_sample_predicted_sam_response(krb5_predicted_sam_response *p) { - krb5_error_code retval; - p->magic = 79; - retval = ktest_make_sample_keyblock(&p->sam_key); - if (retval) return retval; + ktest_make_sample_keyblock(&p->sam_key); p->sam_flags = 9; p->stime = 17; p->susec = 18; - retval = ktest_make_sample_principal(&p->client); - if (retval) return retval; - retval = krb5_data_parse(&p->msd, "hello"); - if (retval) return retval; - return 0; + ktest_make_sample_principal(&p->client); + krb5_data_parse(&p->msd, "hello"); } /****************************************************************/ /* destructors */ -void ktest_destroy_data(d) - krb5_data ** d; +void +ktest_destroy_data(krb5_data **d) { if (*d != NULL) { - if ((*d)->data != NULL) free((*d)->data); + free((*d)->data); free(*d); *d = NULL; } } -void ktest_empty_data(d) - krb5_data * d; +void +ktest_empty_data(krb5_data *d) { if (d->data != NULL) { free(d->data); @@ -1015,243 +713,230 @@ void ktest_empty_data(d) } } -void ktest_destroy_checksum(cs) - krb5_checksum ** cs; +void +ktest_destroy_checksum(krb5_checksum **cs) { if (*cs != NULL) { - if ((*cs)->contents != NULL) free((*cs)->contents); + free((*cs)->contents); free(*cs); *cs = NULL; } } -void ktest_empty_keyblock(kb) - krb5_keyblock * kb; +void +ktest_empty_keyblock(krb5_keyblock *kb) { if (kb != NULL) { if (kb->contents) { - free (kb->contents); + free(kb->contents); kb->contents = NULL; } } } -void ktest_destroy_keyblock(kb) - krb5_keyblock ** kb; +void +ktest_destroy_keyblock(krb5_keyblock **kb) { if (*kb != NULL) { - if ((*kb)->contents != NULL) free((*kb)->contents); + free((*kb)->contents); free(*kb); *kb = NULL; } } -void ktest_empty_authorization_data(ad) - krb5_authdata ** ad; +void +ktest_empty_authorization_data(krb5_authdata **ad) { int i; if (*ad != NULL) { for (i=0; ad[i] != NULL; i++) - ktest_destroy_authdata(&(ad[i])); + ktest_destroy_authdata(&ad[i]); } } -void ktest_destroy_authorization_data(ad) - krb5_authdata *** ad; +void +ktest_destroy_authorization_data(krb5_authdata ***ad) { ktest_empty_authorization_data(*ad); free(*ad); *ad = NULL; } -void ktest_destroy_authdata(ad) - krb5_authdata ** ad; +void +ktest_destroy_authdata(krb5_authdata **ad) { if (*ad != NULL) { - if ((*ad)->contents != NULL) free((*ad)->contents); + free((*ad)->contents); free(*ad); *ad = NULL; } } -void ktest_empty_pa_data_array(pad) - krb5_pa_data ** pad; +void +ktest_empty_pa_data_array(krb5_pa_data **pad) { int i; for (i=0; pad[i] != NULL; i++) - ktest_destroy_pa_data(&(pad[i])); + ktest_destroy_pa_data(&pad[i]); } -void ktest_destroy_pa_data_array(pad) - krb5_pa_data *** pad; +void +ktest_destroy_pa_data_array(krb5_pa_data ***pad) { ktest_empty_pa_data_array(*pad); free(*pad); *pad = NULL; } -void ktest_destroy_pa_data(pad) - krb5_pa_data ** pad; +void +ktest_destroy_pa_data(krb5_pa_data **pad) { if (*pad != NULL) { - if ((*pad)->contents != NULL) free((*pad)->contents); + free((*pad)->contents); free(*pad); *pad = NULL; } } - -void ktest_destroy_address(a) - krb5_address ** a; +void +ktest_destroy_address(krb5_address **a) { if (*a != NULL) { - if ((*a)->contents != NULL) free((*a)->contents); + free((*a)->contents); free(*a); *a = NULL; } } -void ktest_empty_addresses(a) - krb5_address ** a; +void +ktest_empty_addresses(krb5_address **a) { int i; for (i=0; a[i] != NULL; i++) - ktest_destroy_address(&(a[i])); + ktest_destroy_address(&a[i]); } -void ktest_destroy_addresses(a) - krb5_address *** a; +void +ktest_destroy_addresses(krb5_address ***a) { ktest_empty_addresses(*a); free(*a); *a = NULL; } -void ktest_destroy_principal(p) - krb5_principal * p; +void +ktest_destroy_principal(krb5_principal *p) { int i; for (i=0; i<(*p)->length; i++) - ktest_empty_data(&(((*p)->data)[i])); - ktest_empty_data(&((*p)->realm)); + ktest_empty_data(&(*p)->data[i]); + ktest_empty_data(&(*p)->realm); free((*p)->data); free(*p); *p = NULL; } -void ktest_destroy_sequence_of_integer(soi) - long ** soi; +void +ktest_destroy_sequence_of_integer(long **soi) { free(*soi); *soi = NULL; } -#if 0 -void ktest_destroy_sequence_of_enctype(soi) - krb5_enctype ** soi; -{ - free(*soi); - *soi = NULL; -} -#endif - -void ktest_destroy_sequence_of_ticket(sot) - krb5_ticket *** sot; +void +ktest_destroy_sequence_of_ticket(krb5_ticket ***sot) { int i; for (i=0; (*sot)[i] != NULL; i++) - ktest_destroy_ticket(&((*sot)[i])); + ktest_destroy_ticket(&(*sot)[i]); free(*sot); *sot = NULL; } -void ktest_destroy_ticket(tkt) - krb5_ticket ** tkt; +void +ktest_destroy_ticket(krb5_ticket **tkt) { - ktest_destroy_principal(&((*tkt)->server)); - ktest_destroy_enc_data(&((*tkt)->enc_part)); + ktest_destroy_principal(&(*tkt)->server); + ktest_destroy_enc_data(&(*tkt)->enc_part); /* ktest_empty_enc_tkt_part(((*tkt)->enc_part2));*/ free(*tkt); *tkt = NULL; } -void ktest_empty_ticket(tkt) - krb5_ticket * tkt; +void +ktest_empty_ticket(krb5_ticket *tkt) { if (tkt->server) - ktest_destroy_principal(&((tkt)->server)); - ktest_destroy_enc_data(&((tkt)->enc_part)); - if (tkt->enc_part2) { - ktest_destroy_enc_tkt_part(&(tkt->enc_part2)); - } + ktest_destroy_principal(&tkt->server); + ktest_destroy_enc_data(&tkt->enc_part); + if (tkt->enc_part2) + ktest_destroy_enc_tkt_part(&tkt->enc_part2); } -void ktest_destroy_enc_data(ed) - krb5_enc_data * ed; +void +ktest_destroy_enc_data(krb5_enc_data *ed) { - ktest_empty_data(&(ed->ciphertext)); + ktest_empty_data(&ed->ciphertext); ed->kvno = 0; } -void ktest_destroy_etype_info_entry(i) - krb5_etype_info_entry *i; +void +ktest_destroy_etype_info_entry(krb5_etype_info_entry *i) { if (i->salt) free(i->salt); - ktest_empty_data(&(i->s2kparams)); + ktest_empty_data(&i->s2kparams); free(i); } -void ktest_destroy_etype_info(info) - krb5_etype_info_entry **info; +void +ktest_destroy_etype_info(krb5_etype_info_entry **info) { int i; - for (i=0; info[i] != NULL; i++) + for (i = 0; info[i] != NULL; i++) ktest_destroy_etype_info_entry(info[i]); free(info); } - -void ktest_empty_kdc_req(kr) - krb5_kdc_req *kr; +void +ktest_empty_kdc_req(krb5_kdc_req *kr) { if (kr->padata) - ktest_destroy_pa_data_array(&(kr->padata)); + ktest_destroy_pa_data_array(&kr->padata); if (kr->client) - ktest_destroy_principal(&(kr->client)); + ktest_destroy_principal(&kr->client); if (kr->server) - ktest_destroy_principal(&(kr->server)); - if (kr->ktype) - free(kr->ktype); + ktest_destroy_principal(&kr->server); + free(kr->ktype); if (kr->addresses) - ktest_destroy_addresses(&(kr->addresses)); - ktest_destroy_enc_data(&(kr->authorization_data)); + ktest_destroy_addresses(&kr->addresses); + ktest_destroy_enc_data(&kr->authorization_data); if (kr->unenc_authdata) - ktest_destroy_authorization_data(&(kr->unenc_authdata)); + ktest_destroy_authorization_data(&kr->unenc_authdata); if (kr->second_ticket) - ktest_destroy_sequence_of_ticket(&(kr->second_ticket)); + ktest_destroy_sequence_of_ticket(&kr->second_ticket); } -void ktest_empty_kdc_rep(kr) - krb5_kdc_rep *kr; +void +ktest_empty_kdc_rep(krb5_kdc_rep *kr) { if (kr->padata) - ktest_destroy_pa_data_array(&(kr->padata)); + ktest_destroy_pa_data_array(&kr->padata); if (kr->client) - ktest_destroy_principal(&(kr->client)); + ktest_destroy_principal(&kr->client); if (kr->ticket) - ktest_destroy_ticket(&(kr->ticket)); + ktest_destroy_ticket(&kr->ticket); ktest_destroy_enc_data(&kr->enc_part); @@ -1262,38 +947,35 @@ void ktest_empty_kdc_rep(kr) } } - -void ktest_empty_authenticator(a) - krb5_authenticator * a; +void +ktest_empty_authenticator(krb5_authenticator *a) { - if (a->client) - ktest_destroy_principal(&(a->client)); + ktest_destroy_principal(&a->client); if (a->checksum) - ktest_destroy_checksum(&(a->checksum)); + ktest_destroy_checksum(&a->checksum); if (a->subkey) - ktest_destroy_keyblock(&(a->subkey)); + ktest_destroy_keyblock(&a->subkey); if (a->authorization_data) - ktest_destroy_authorization_data(&(a->authorization_data)); + ktest_destroy_authorization_data(&a->authorization_data); } -void ktest_empty_enc_tkt_part(etp) - krb5_enc_tkt_part * etp; +void +ktest_empty_enc_tkt_part(krb5_enc_tkt_part *etp) { - if (etp->session) - ktest_destroy_keyblock(&(etp->session)); + ktest_destroy_keyblock(&etp->session); if (etp->client) - ktest_destroy_principal(&(etp->client)); + ktest_destroy_principal(&etp->client); if (etp->caddrs) - ktest_destroy_addresses(&(etp->caddrs)); + ktest_destroy_addresses(&etp->caddrs); if (etp->authorization_data) - ktest_destroy_authorization_data(&(etp->authorization_data)); - ktest_destroy_transited(&(etp->transited)); + ktest_destroy_authorization_data(&etp->authorization_data); + ktest_destroy_transited(&etp->transited); } -void ktest_destroy_enc_tkt_part(etp) - krb5_enc_tkt_part ** etp; +void +ktest_destroy_enc_tkt_part(krb5_enc_tkt_part **etp) { if (*etp) { ktest_empty_enc_tkt_part(*etp); @@ -1302,256 +984,242 @@ void ktest_destroy_enc_tkt_part(etp) } } -void ktest_empty_enc_kdc_rep_part(ekr) - krb5_enc_kdc_rep_part * ekr; +void +ktest_empty_enc_kdc_rep_part(krb5_enc_kdc_rep_part *ekr) { - if (ekr->session) - ktest_destroy_keyblock(&(ekr->session)); + ktest_destroy_keyblock(&ekr->session); if (ekr->server) - ktest_destroy_principal(&(ekr->server)); + ktest_destroy_principal(&ekr->server); if (ekr->caddrs) - ktest_destroy_addresses(&(ekr->caddrs)); - ktest_destroy_last_req(&(ekr->last_req)); + ktest_destroy_addresses(&ekr->caddrs); + ktest_destroy_last_req(&ekr->last_req); } - -void ktest_destroy_transited(t) - krb5_transited * t; +void +ktest_destroy_transited(krb5_transited *t) { if (t->tr_contents.data) - ktest_empty_data(&(t->tr_contents)); + ktest_empty_data(&t->tr_contents); } - -void ktest_empty_ap_rep(ar) - krb5_ap_rep * ar; +void +ktest_empty_ap_rep(krb5_ap_rep *ar) { ktest_destroy_enc_data(&ar->enc_part); } -void ktest_empty_ap_req(ar) - krb5_ap_req * ar; +void +ktest_empty_ap_req(krb5_ap_req *ar) { - if (ar->ticket) - ktest_destroy_ticket(&(ar->ticket)); - ktest_destroy_enc_data(&(ar->authenticator)); + ktest_destroy_ticket(&ar->ticket); + ktest_destroy_enc_data(&ar->authenticator); } -void ktest_empty_cred_enc_part(cep) - krb5_cred_enc_part * cep; +void +ktest_empty_cred_enc_part(krb5_cred_enc_part *cep) { if (cep->s_address) - ktest_destroy_address(&(cep->s_address)); + ktest_destroy_address(&cep->s_address); if (cep->r_address) - ktest_destroy_address(&(cep->r_address)); + ktest_destroy_address(&cep->r_address); if (cep->ticket_info) - ktest_destroy_sequence_of_cred_info(&(cep->ticket_info)); + ktest_destroy_sequence_of_cred_info(&cep->ticket_info); } -void ktest_destroy_cred_info(ci) - krb5_cred_info ** ci; +void +ktest_destroy_cred_info(krb5_cred_info **ci) { if ((*ci)->session) - ktest_destroy_keyblock(&((*ci)->session)); + ktest_destroy_keyblock(&(*ci)->session); if ((*ci)->client) - ktest_destroy_principal(&((*ci)->client)); + ktest_destroy_principal(&(*ci)->client); if ((*ci)->server) - ktest_destroy_principal(&((*ci)->server)); + ktest_destroy_principal(&(*ci)->server); if ((*ci)->caddrs) - ktest_destroy_addresses(&((*ci)->caddrs)); + ktest_destroy_addresses(&(*ci)->caddrs); free(*ci); *ci = NULL; } -void ktest_destroy_sequence_of_cred_info(soci) - krb5_cred_info *** soci; +void +ktest_destroy_sequence_of_cred_info(krb5_cred_info ***soci) { int i; - for (i=0; (*soci)[i] != NULL; i++) - ktest_destroy_cred_info(&((*soci)[i])); + for (i = 0; (*soci)[i] != NULL; i++) + ktest_destroy_cred_info(&(*soci)[i]); free(*soci); *soci = NULL; } - -void ktest_empty_safe(s) - krb5_safe * s; +void +ktest_empty_safe(krb5_safe *s) { - ktest_empty_data(&(s->user_data)); - ktest_destroy_address(&(s->s_address)); - ktest_destroy_address(&(s->r_address)); - ktest_destroy_checksum(&(s->checksum)); + ktest_empty_data(&s->user_data); + ktest_destroy_address(&s->s_address); + ktest_destroy_address(&s->r_address); + ktest_destroy_checksum(&s->checksum); } -void ktest_empty_priv_enc_part(pep) - krb5_priv_enc_part * pep; +void +ktest_empty_priv_enc_part(krb5_priv_enc_part *pep) { - ktest_empty_data(&(pep->user_data)); - ktest_destroy_address(&(pep->s_address)); - ktest_destroy_address(&(pep->r_address)); + ktest_empty_data(&pep->user_data); + ktest_destroy_address(&pep->s_address); + ktest_destroy_address(&pep->r_address); } -void ktest_empty_priv(p) - krb5_priv * p; +void +ktest_empty_priv(krb5_priv *p) { - ktest_destroy_enc_data(&(p->enc_part)); + ktest_destroy_enc_data(&p->enc_part); } -void ktest_empty_cred(c) - krb5_cred * c; +void +ktest_empty_cred(krb5_cred *c) { - - ktest_destroy_sequence_of_ticket(&(c->tickets)); - ktest_destroy_enc_data(&(c->enc_part)); + ktest_destroy_sequence_of_ticket(&c->tickets); + ktest_destroy_enc_data(&c->enc_part); /* enc_part2 */ - } -void ktest_destroy_last_req(lr) - krb5_last_req_entry *** lr; +void +ktest_destroy_last_req(krb5_last_req_entry ***lr) { int i; if (*lr) { - for (i=0; (*lr)[i] != NULL; i++) { + for (i=0; (*lr)[i] != NULL; i++) free((*lr)[i]); - } + free(*lr); } } -void ktest_empty_error(kerr) - krb5_error * kerr; +void +ktest_empty_error(krb5_error *kerr) { if (kerr->client) - ktest_destroy_principal(&(kerr->client)); + ktest_destroy_principal(&kerr->client); if (kerr->server) - ktest_destroy_principal(&(kerr->server)); - ktest_empty_data(&(kerr->text)); - ktest_empty_data(&(kerr->e_data)); + ktest_destroy_principal(&kerr->server); + ktest_empty_data(&kerr->text); + ktest_empty_data(&kerr->e_data); } -void ktest_empty_ap_rep_enc_part(arep) - krb5_ap_rep_enc_part * arep; +void +ktest_empty_ap_rep_enc_part(krb5_ap_rep_enc_part *arep) { - ktest_destroy_keyblock(&((arep)->subkey)); + ktest_destroy_keyblock(&(arep)->subkey); } -void ktest_empty_passwd_phrase_element(ppe) - passwd_phrase_element * ppe; +void +ktest_empty_passwd_phrase_element(passwd_phrase_element *ppe) { - ktest_destroy_data(&(ppe->passwd)); - ktest_destroy_data(&(ppe->phrase)); + ktest_destroy_data(&ppe->passwd); + ktest_destroy_data(&ppe->phrase); } -void ktest_empty_pwd_data(pd) - krb5_pwd_data * pd; +void +ktest_empty_pwd_data(krb5_pwd_data *pd) { int i; - for (i=0; i <= pd->sequence_count; i++) { + for (i = 0; i <= pd->sequence_count; i++) { if (pd->element[i]) { ktest_empty_passwd_phrase_element(pd->element[i]); free(pd->element[i]); - pd->element[i] = NULL; } } free(pd->element); - } -void ktest_empty_alt_method(am) - krb5_alt_method *am; +void +ktest_empty_alt_method(krb5_alt_method *am) { - if (am->data) { - free(am->data); - am->data = NULL; - } + free(am->data); + am->data = NULL; } -void ktest_empty_sam_challenge(p) - krb5_sam_challenge * p; +void +ktest_empty_sam_challenge(krb5_sam_challenge *p) { - ktest_empty_data(&(p->sam_type_name)); - ktest_empty_data(&(p->sam_track_id)); - ktest_empty_data(&(p->sam_challenge_label)); - ktest_empty_data(&(p->sam_challenge)); - ktest_empty_data(&(p->sam_response_prompt)); - ktest_empty_data(&(p->sam_pk_for_sad)); - - if (p->sam_cksum.contents != NULL) { - free(p->sam_cksum.contents); - p->sam_cksum.contents = NULL; - } - + ktest_empty_data(&p->sam_type_name); + ktest_empty_data(&p->sam_track_id); + ktest_empty_data(&p->sam_challenge_label); + ktest_empty_data(&p->sam_challenge); + ktest_empty_data(&p->sam_response_prompt); + ktest_empty_data(&p->sam_pk_for_sad); + free(p->sam_cksum.contents); + p->sam_cksum.contents = NULL; } -void ktest_empty_sam_response(p) - krb5_sam_response * p; +void +ktest_empty_sam_response(krb5_sam_response *p) { - ktest_empty_data(&(p->sam_track_id)); - ktest_empty_data(&(p->sam_enc_key.ciphertext)); - ktest_empty_data(&(p->sam_enc_nonce_or_ts.ciphertext)); + ktest_empty_data(&p->sam_track_id); + ktest_empty_data(&p->sam_enc_key.ciphertext); + ktest_empty_data(&p->sam_enc_nonce_or_ts.ciphertext); } -void ktest_empty_sam_key(p) - krb5_sam_key *p; +void +ktest_empty_sam_key(krb5_sam_key *p) { - if (p->sam_key.contents) - free(p->sam_key.contents); + free(p->sam_key.contents); } -void ktest_empty_predicted_sam_response(p) - krb5_predicted_sam_response *p; +void +ktest_empty_predicted_sam_response(krb5_predicted_sam_response *p) { ktest_empty_keyblock(&p->sam_key); ktest_destroy_principal(&p->client); ktest_empty_data(&p->msd); } -void ktest_empty_enc_sam_response_enc(p) - krb5_enc_sam_response_enc *p; +void +ktest_empty_enc_sam_response_enc(krb5_enc_sam_response_enc *p) { ktest_empty_data(&p->sam_sad); } -void ktest_empty_sam_response_2(p) - krb5_sam_response_2 *p; +void +ktest_empty_sam_response_2(krb5_sam_response_2 *p) { ktest_empty_data(&p->sam_track_id); ktest_empty_data(&p->sam_enc_nonce_or_sad.ciphertext); } -void ktest_empty_enc_sam_response_enc_2(p) - krb5_enc_sam_response_enc_2 *p; + +void +ktest_empty_enc_sam_response_enc_2(krb5_enc_sam_response_enc_2 *p) { ktest_empty_data(&p->sam_sad); } -void ktest_empty_pa_s4u_x509_user(p) - krb5_pa_s4u_x509_user *p; +void +ktest_empty_pa_s4u_x509_user(krb5_pa_s4u_x509_user *p) { ktest_destroy_principal(&p->user_id.user); ktest_empty_data(&p->user_id.subject_cert); - if (p->cksum.contents) free(p->cksum.contents); + free(p->cksum.contents); } -void ktest_empty_ad_kdcissued(p) - krb5_ad_kdcissued *p; +void +ktest_empty_ad_kdcissued(krb5_ad_kdcissued *p) { - if (p->ad_checksum.contents) free(p->ad_checksum.contents); + free(p->ad_checksum.contents); ktest_destroy_principal(&p->i_principal); ktest_destroy_authorization_data(&p->elements); } -void ktest_empty_ad_signedpath_data(p) - krb5_ad_signedpath_data *p; +void +ktest_empty_ad_signedpath_data(krb5_ad_signedpath_data *p) { int i; + ktest_destroy_principal(&p->client); if (p->delegated != NULL) { for (i = 0; p->delegated[i] != NULL; i++) { @@ -1564,11 +1232,12 @@ void ktest_empty_ad_signedpath_data(p) ktest_destroy_authorization_data(&p->authorization_data); } -void ktest_empty_ad_signedpath(p) - krb5_ad_signedpath *p; +void +ktest_empty_ad_signedpath(krb5_ad_signedpath *p) { int i; - if (p->checksum.contents) free(p->checksum.contents); + + free(p->checksum.contents); if (p->delegated != NULL) { for (i = 0; p->delegated[i] != NULL; i++) { krb5_principal princ = p->delegated[i]; @@ -1579,25 +1248,25 @@ void ktest_empty_ad_signedpath(p) ktest_destroy_pa_data_array(&p->method_data); } -void ktest_empty_iakerb_header(p) - krb5_iakerb_header *p; +void +ktest_empty_iakerb_header(krb5_iakerb_header *p) { krb5_free_data_contents(NULL, &p->target_realm); krb5_free_data(NULL, p->cookie); } -void ktest_empty_iakerb_finished(p) - krb5_iakerb_finished *p; +void +ktest_empty_iakerb_finished(krb5_iakerb_finished *p) { krb5_free_checksum_contents(NULL, &p->checksum); } #ifdef ENABLE_LDAP -void ktest_empty_ldap_seqof_key_data(ctx, p) - krb5_context ctx; - ldap_seqof_key_data *p; +void +ktest_empty_ldap_seqof_key_data(krb5_context ctx, ldap_seqof_key_data *p) { int i; + for (i = 0; i < p->n_key_data; i++) { free(p->key_data[i].key_data_contents[0]); free(p->key_data[i].key_data_contents[1]); |