Removed all references to DECLARG and OLDDECLARG.

Added krb5_context to all krb5_*() routines.

git-svn-id: svn://anonsvn.mit.edu/krb5/trunk@4815 dc483132-0cff-0310-8789-dd5450dbe970

12 files changed, 441 insertions, 455 deletions

diff --git a/src/tests/asn.1/ChangeLog b/src/tests/asn.1/ChangeLog
index f6d0099155..de99565492 100644
--- a/src/tests/asn.1/ChangeLog
+++ b/src/tests/asn.1/ChangeLog
@@ -1,3 +1,7 @@
+Fri Jan 13 15:23:47 1995  Chris Provenzano (proven@mit.edu)
+
+    * Added krb5_context to all krb5_routines
+
 Fri Nov 18 16:29:01 1994  Theodore Y. Ts'o  (tytso@dcl)
 
 	* ktest.c (ktest_make_sample_keybloc): Add magic numbers for
diff --git a/src/tests/asn.1/krb5_decode_test.c b/src/tests/asn.1/krb5_decode_test.c
index 8383f11abc..c56dc8e7bb 100644
--- a/src/tests/asn.1/krb5_decode_test.c
+++ b/src/tests/asn.1/krb5_decode_test.c
@@ -8,6 +8,7 @@
 #include "debug.h"
 #include <string.h>
 
+krb5_context test_context;
 int error_count = 0;
 
 void main()
@@ -15,7 +16,8 @@ void main()
   krb5_data code;
   krb5_error_code retval;
   
-  krb5_init_ets();
+  krb5_init_context(&test_context);
+  krb5_init_ets(test_context);
   
 #define setup(type,typestring,constructor)\
   type ref, *var;\
diff --git a/src/tests/asn.1/krb5_encode_test.c b/src/tests/asn.1/krb5_encode_test.c
index 1dc9bea3c0..c821aa338a 100644
--- a/src/tests/asn.1/krb5_encode_test.c
+++ b/src/tests/asn.1/krb5_encode_test.c
@@ -9,6 +9,7 @@
 
 #include "debug.h"
 
+krb5_context test_context;
 int error_count = 0;
 int do_trval = 0;
 
@@ -85,7 +86,8 @@ void main(argc, argv)
 
   PRS(argc, argv);
   
-  krb5_init_ets();
+  krb5_init_context(&test_context);
+  krb5_init_ets(test_context);
   
 #define setup(value,type,typestring,constructor)\
   retval = constructor(&(value));\
diff --git a/src/tests/asn.1/ktest.c b/src/tests/asn.1/ktest.c
index b4e9dac098..b3a1c53632 100644
--- a/src/tests/asn.1/ktest.c
+++ b/src/tests/asn.1/ktest.c
@@ -2,8 +2,8 @@
 #include "utility.h"
 #include <stdlib.h>
 
-krb5_error_code ktest_make_sample_authenticator(DECLARG(krb5_authenticator *, a))
-     OLDDECLARG(krb5_authenticator *, a)
+krb5_error_code ktest_make_sample_authenticator(a)
+     krb5_authenticator * a;
 {
   krb5_error_code retval;
 
@@ -26,8 +26,8 @@ krb5_error_code ktest_make_sample_authenticator(DECLARG(krb5_authenticator *, a)
   return 0;
 }
 
-krb5_error_code ktest_make_sample_principal(DECLARG(krb5_principal *, p))
-     OLDDECLARG(krb5_principal *, p)
+krb5_error_code ktest_make_sample_principal(p)
+     krb5_principal * p;
 {
   krb5_error_code retval;
 
@@ -49,8 +49,8 @@ krb5_error_code ktest_make_sample_principal(DECLARG(krb5_principal *, p))
   return 0;
 }
 
-krb5_error_code ktest_make_sample_checksum(DECLARG(krb5_checksum *, cs))
-     OLDDECLARG(krb5_checksum *, cs)
+krb5_error_code ktest_make_sample_checksum(cs)
+     krb5_checksum * cs;
 {
   cs->checksum_type = 1;
   cs->length = 4;
@@ -61,8 +61,8 @@ krb5_error_code ktest_make_sample_checksum(DECLARG(krb5_checksum *, cs))
   return 0;
 }
 
-krb5_error_code ktest_make_sample_keyblock(DECLARG(krb5_keyblock *, kb))
-     OLDDECLARG(krb5_keyblock *, kb)
+krb5_error_code ktest_make_sample_keyblock(kb)
+     krb5_keyblock * kb;
 {
   kb->magic = KV5M_KEYBLOCK;
   kb->etype = ETYPE_UNKNOWN;
@@ -75,8 +75,8 @@ krb5_error_code ktest_make_sample_keyblock(DECLARG(krb5_keyblock *, kb))
   return 0;
 }
 
-krb5_error_code ktest_make_sample_ticket(DECLARG(krb5_ticket *, tkt))
-     OLDDECLARG(krb5_ticket *, tkt)
+krb5_error_code ktest_make_sample_ticket(tkt)
+     krb5_ticket * tkt;
 {
   krb5_error_code retval;
 
@@ -88,8 +88,8 @@ krb5_error_code ktest_make_sample_ticket(DECLARG(krb5_ticket *, tkt))
   return 0;
 }
 
-krb5_error_code ktest_make_sample_enc_data(DECLARG(krb5_enc_data *, ed))
-     OLDDECLARG(krb5_enc_data *, ed)
+krb5_error_code ktest_make_sample_enc_data(ed)
+     krb5_enc_data * ed;
 {
   krb5_error_code retval;
 
@@ -101,8 +101,8 @@ krb5_error_code ktest_make_sample_enc_data(DECLARG(krb5_enc_data *, ed))
   return 0;
 }
 
-krb5_error_code ktest_make_sample_enc_tkt_part(DECLARG(krb5_enc_tkt_part *, etp))
-     OLDDECLARG(krb5_enc_tkt_part *, etp)
+krb5_error_code ktest_make_sample_enc_tkt_part(etp)
+     krb5_enc_tkt_part * etp;
 {
   krb5_error_code retval;
 
@@ -124,8 +124,8 @@ krb5_error_code ktest_make_sample_enc_tkt_part(DECLARG(krb5_enc_tkt_part *, etp)
   return 0;
 }
 
-krb5_error_code ktest_make_sample_addresses(DECLARG(krb5_address ***, caddrs))
-     OLDDECLARG(krb5_address ***, caddrs)
+krb5_error_code ktest_make_sample_addresses(caddrs)
+     krb5_address *** caddrs;
 {
   asn1_error_code retval;
   int i;
@@ -142,8 +142,8 @@ krb5_error_code ktest_make_sample_addresses(DECLARG(krb5_address ***, caddrs))
   return 0;
 }
 
-krb5_error_code ktest_make_sample_authorization_data(DECLARG(krb5_authdata ***, ad))
-     OLDDECLARG(krb5_authdata ***, ad)
+krb5_error_code ktest_make_sample_authorization_data(ad)
+     krb5_authdata *** ad;
 {
   krb5_error_code retval;
   int i;
@@ -162,16 +162,16 @@ krb5_error_code ktest_make_sample_authorization_data(DECLARG(krb5_authdata ***,
   return 0;
 }
 
-krb5_error_code ktest_make_sample_transited(DECLARG(krb5_transited *, t))
-     OLDDECLARG(krb5_transited *, t)
+krb5_error_code ktest_make_sample_transited(t)
+     krb5_transited * t;
 {
   t->tr_type = 1;
   return krb5_data_parse(&(t->tr_contents),
 			 "EDU,MIT.,ATHENA.,WASHINGTON.EDU,CS.");
 }
 
-krb5_error_code ktest_make_sample_ticket_times(DECLARG(krb5_ticket_times *, tt))
-     OLDDECLARG(krb5_ticket_times *, tt)
+krb5_error_code ktest_make_sample_ticket_times(tt)
+     krb5_ticket_times * tt;
 {
   tt->authtime = SAMPLE_TIME;
   tt->starttime = SAMPLE_TIME;
@@ -180,8 +180,8 @@ krb5_error_code ktest_make_sample_ticket_times(DECLARG(krb5_ticket_times *, tt))
   return 0;
 }
 
-krb5_error_code ktest_make_sample_address(DECLARG(krb5_address *, a))
-     OLDDECLARG(krb5_address *, a)
+krb5_error_code ktest_make_sample_address(a)
+     krb5_address * a;
 {
   a->addrtype = ADDRTYPE_INET;
   a->length = 4;
@@ -195,8 +195,8 @@ krb5_error_code ktest_make_sample_address(DECLARG(krb5_address *, a))
   return 0;
 }
 
-krb5_error_code ktest_make_sample_authdata(DECLARG(krb5_authdata *, ad))
-     OLDDECLARG(krb5_authdata *, ad)
+krb5_error_code ktest_make_sample_authdata(ad)
+     krb5_authdata * ad;
 {
   ad->ad_type = 1;
   ad->length = 6;
@@ -206,8 +206,8 @@ krb5_error_code ktest_make_sample_authdata(DECLARG(krb5_authdata *, ad))
   return 0;
 }
 
-krb5_error_code ktest_make_sample_enc_kdc_rep_part(DECLARG(krb5_enc_kdc_rep_part *, ekr))
-     OLDDECLARG(krb5_enc_kdc_rep_part *, ekr)
+krb5_error_code ktest_make_sample_enc_kdc_rep_part(ekr)
+     krb5_enc_kdc_rep_part * ekr;
 {
   krb5_error_code retval;
 
@@ -232,8 +232,8 @@ krb5_error_code ktest_make_sample_enc_kdc_rep_part(DECLARG(krb5_enc_kdc_rep_part
   return 0;
 }
 
-krb5_error_code ktest_make_sample_last_req(DECLARG(krb5_last_req_entry ***, lr))
-     OLDDECLARG(krb5_last_req_entry ***, lr)
+krb5_error_code ktest_make_sample_last_req(lr)
+     krb5_last_req_entry *** lr;
 {
   krb5_error_code retval;
   int i;
@@ -250,8 +250,8 @@ krb5_error_code ktest_make_sample_last_req(DECLARG(krb5_last_req_entry ***, lr))
   return 0;
 }
 
-krb5_error_code ktest_make_sample_last_req_entry(DECLARG(krb5_last_req_entry **, lre))
-     OLDDECLARG(krb5_last_req_entry **, lre)
+krb5_error_code ktest_make_sample_last_req_entry(lre)
+     krb5_last_req_entry ** lre;
 {
   *lre = (krb5_last_req_entry*)calloc(1,sizeof(krb5_last_req_entry));
   if(*lre == NULL) return ENOMEM;
@@ -260,8 +260,8 @@ krb5_error_code ktest_make_sample_last_req_entry(DECLARG(krb5_last_req_entry **,
   return 0;
 }
 
-krb5_error_code ktest_make_sample_kdc_rep(DECLARG(krb5_kdc_rep *, kdcr))
-     OLDDECLARG(krb5_kdc_rep *, kdcr)
+krb5_error_code ktest_make_sample_kdc_rep(kdcr)
+     krb5_kdc_rep * kdcr;
 {
   krb5_error_code retval;
 
@@ -280,8 +280,8 @@ krb5_error_code ktest_make_sample_kdc_rep(DECLARG(krb5_kdc_rep *, kdcr))
   return 0;
 }
 
-krb5_error_code ktest_make_sample_pa_data_array(DECLARG(krb5_pa_data ***, pad))
-     OLDDECLARG(krb5_pa_data ***, pad)
+krb5_error_code ktest_make_sample_pa_data_array(pad)
+     krb5_pa_data *** pad;
 {
   krb5_error_code retval;
   int i;
@@ -300,8 +300,8 @@ krb5_error_code ktest_make_sample_pa_data_array(DECLARG(krb5_pa_data ***, pad))
   return 0;
 }
 
-krb5_error_code ktest_make_sample_pa_data(DECLARG(krb5_pa_data *, pad))
-     OLDDECLARG(krb5_pa_data *, pad)
+krb5_error_code ktest_make_sample_pa_data(pad)
+     krb5_pa_data * pad;
 {
   pad->pa_type = 13;
   pad->length = 7;
@@ -311,8 +311,8 @@ krb5_error_code ktest_make_sample_pa_data(DECLARG(krb5_pa_data *, pad))
   return 0;
 }
 
-krb5_error_code ktest_make_sample_ap_req(DECLARG(krb5_ap_req *, ar))
-     OLDDECLARG(krb5_ap_req *, ar)
+krb5_error_code ktest_make_sample_ap_req(ar)
+     krb5_ap_req * ar;
 {
   krb5_error_code retval;
   ar->ap_options = SAMPLE_FLAGS;
@@ -325,14 +325,14 @@ krb5_error_code ktest_make_sample_ap_req(DECLARG(krb5_ap_req *, ar))
   return 0;
 }
 
-krb5_error_code ktest_make_sample_ap_rep(DECLARG(krb5_ap_rep *, ar))
-     OLDDECLARG(krb5_ap_rep *, ar)
+krb5_error_code ktest_make_sample_ap_rep(ar)
+     krb5_ap_rep * ar;
 {
   return ktest_make_sample_enc_data(&(ar->enc_part));
 }
 
-krb5_error_code ktest_make_sample_ap_rep_enc_part(DECLARG(krb5_ap_rep_enc_part *, arep))
-     OLDDECLARG(krb5_ap_rep_enc_part *, arep)
+krb5_error_code ktest_make_sample_ap_rep_enc_part(arep)
+     krb5_ap_rep_enc_part * arep;
 {
   krb5_error_code retval;
 
@@ -347,8 +347,8 @@ krb5_error_code ktest_make_sample_ap_rep_enc_part(DECLARG(krb5_ap_rep_enc_part *
   return 0;
 }
 
-krb5_error_code ktest_make_sample_kdc_req(DECLARG(krb5_kdc_req *, kr))
-     OLDDECLARG(krb5_kdc_req *, kr)
+krb5_error_code ktest_make_sample_kdc_req(kr)
+     krb5_kdc_req * kr;
 {
   krb5_error_code retval;
 
@@ -379,8 +379,8 @@ krb5_error_code ktest_make_sample_kdc_req(DECLARG(krb5_kdc_req *, kr))
   return 0;
 }
 
-krb5_error_code ktest_make_sample_kdc_req_body(DECLARG(krb5_kdc_req *, krb))
-     OLDDECLARG(krb5_kdc_req *, krb)
+krb5_error_code ktest_make_sample_kdc_req_body(krb)
+     krb5_kdc_req * krb;
 {
   krb5_error_code retval;
 
@@ -408,8 +408,8 @@ krb5_error_code ktest_make_sample_kdc_req_body(DECLARG(krb5_kdc_req *, krb))
   return 0;
 }
   
-krb5_error_code ktest_make_sample_safe(DECLARG(krb5_safe *, s))
-     OLDDECLARG(krb5_safe *, s)
+krb5_error_code ktest_make_sample_safe(s)
+     krb5_safe * s;
 {
   krb5_error_code retval;
 
@@ -434,14 +434,14 @@ krb5_error_code ktest_make_sample_safe(DECLARG(krb5_safe *, s))
   return 0;
 }
 
-krb5_error_code ktest_make_sample_priv(DECLARG(krb5_priv *, p))
-     OLDDECLARG(krb5_priv *, p)
+krb5_error_code ktest_make_sample_priv(p)
+     krb5_priv * p;
 {
   return ktest_make_sample_enc_data(&(p->enc_part));
 }
 
-krb5_error_code ktest_make_sample_priv_enc_part(DECLARG(krb5_priv_enc_part *, pep))
-     OLDDECLARG(krb5_priv_enc_part *, pep)
+krb5_error_code ktest_make_sample_priv_enc_part(pep)
+     krb5_priv_enc_part * pep;
 {
   krb5_error_code retval;
   retval = ktest_make_sample_data(&(pep->user_data));
@@ -460,8 +460,8 @@ krb5_error_code ktest_make_sample_priv_enc_part(DECLARG(krb5_priv_enc_part *, pe
   return 0;
 }
 
-krb5_error_code ktest_make_sample_cred(DECLARG(krb5_cred *, c))
-     OLDDECLARG(krb5_cred *, c)
+krb5_error_code ktest_make_sample_cred(c)
+     krb5_cred * c;
 {
   krb5_error_code retval;
   retval = ktest_make_sample_sequence_of_ticket(&(c->tickets));
@@ -471,8 +471,8 @@ krb5_error_code ktest_make_sample_cred(DECLARG(krb5_cred *, c))
   return 0;
 }
 
-krb5_error_code ktest_make_sample_sequence_of_ticket(DECLARG(krb5_ticket ***, sot))
-     OLDDECLARG(krb5_ticket ***, sot)
+krb5_error_code ktest_make_sample_sequence_of_ticket(sot)
+     krb5_ticket *** sot;
 {
   krb5_error_code retval;
   int i;
@@ -490,8 +490,8 @@ krb5_error_code ktest_make_sample_sequence_of_ticket(DECLARG(krb5_ticket ***, so
   return 0;
 }
 
-krb5_error_code ktest_make_sample_cred_enc_part(DECLARG(krb5_cred_enc_part *, cep))
-     OLDDECLARG(krb5_cred_enc_part *, cep)
+krb5_error_code ktest_make_sample_cred_enc_part(cep)
+     krb5_cred_enc_part * cep;
 {
   krb5_error_code retval;
 
@@ -512,8 +512,8 @@ krb5_error_code ktest_make_sample_cred_enc_part(DECLARG(krb5_cred_enc_part *, ce
   return 0;
 }
 
-krb5_error_code ktest_make_sequence_of_cred_info(DECLARG(krb5_cred_info ***, soci))
-     OLDDECLARG(krb5_cred_info ***, soci)
+krb5_error_code ktest_make_sequence_of_cred_info(soci)
+     krb5_cred_info *** soci;
 {
   krb5_error_code retval;
   int i;
@@ -531,8 +531,8 @@ krb5_error_code ktest_make_sequence_of_cred_info(DECLARG(krb5_cred_info ***, soc
   return 0;
 }
 
-krb5_error_code ktest_make_sample_cred_info(DECLARG(krb5_cred_info *, ci))
-     OLDDECLARG(krb5_cred_info *, ci)
+krb5_error_code ktest_make_sample_cred_info(ci)
+     krb5_cred_info * ci;
 {
   krb5_error_code retval;
 
@@ -555,8 +555,8 @@ krb5_error_code ktest_make_sample_cred_info(DECLARG(krb5_cred_info *, ci))
   return 0;
 }
 
-krb5_error_code ktest_make_sample_error(DECLARG(krb5_error *, kerr))
-     OLDDECLARG(krb5_error *, kerr)
+krb5_error_code ktest_make_sample_error(kerr)
+     krb5_error * kerr;
 {
   krb5_error_code retval;
 
@@ -577,8 +577,8 @@ krb5_error_code ktest_make_sample_error(DECLARG(krb5_error *, kerr))
   return 0;
 }
 
-krb5_error_code ktest_make_sample_data(DECLARG(krb5_data *, d))
-     OLDDECLARG(krb5_data *, d)
+krb5_error_code ktest_make_sample_data(d)
+     krb5_data * d;
 {
   d->data = (char*)calloc(8,sizeof(char));
   if(d->data == NULL) return ENOMEM;
@@ -588,8 +588,8 @@ krb5_error_code ktest_make_sample_data(DECLARG(krb5_data *, d))
   return 0;
 }
 
-krb5_error_code ktest_make_sample_passwd_phrase_element(DECLARG(passwd_phrase_element *, ppe))
-     OLDDECLARG(passwd_phrase_element *, ppe)
+krb5_error_code ktest_make_sample_passwd_phrase_element(ppe)
+     passwd_phrase_element * ppe;
 {
   krb5_error_code retval;
 
@@ -604,8 +604,8 @@ krb5_error_code ktest_make_sample_passwd_phrase_element(DECLARG(passwd_phrase_el
   return 0;
 }
 
-krb5_error_code ktest_make_sample_krb5_pwd_data(DECLARG(krb5_pwd_data *, pd))
-     OLDDECLARG(krb5_pwd_data *, pd)
+krb5_error_code ktest_make_sample_krb5_pwd_data(pd)
+     krb5_pwd_data * pd;
 {
   krb5_error_code retval;
   int i;
@@ -630,8 +630,8 @@ krb5_error_code ktest_make_sample_krb5_pwd_data(DECLARG(krb5_pwd_data *, pd))
 /****************************************************************/
 /* destructors */
 
-void ktest_destroy_data(DECLARG(krb5_data **, d))
-     OLDDECLARG(krb5_data **, d)
+void ktest_destroy_data(d)
+     krb5_data ** d;
 {
   if(*d != NULL){
     if((*d)->data != NULL) free((*d)->data);
@@ -640,8 +640,8 @@ void ktest_destroy_data(DECLARG(krb5_data **, d))
   }
 }
 
-void ktest_empty_data(DECLARG(krb5_data *, d))
-     OLDDECLARG(krb5_data *, d)
+void ktest_empty_data(d)
+     krb5_data * d;
 {
   if(d->data != NULL){
     free(d->data);
@@ -650,8 +650,8 @@ void ktest_empty_data(DECLARG(krb5_data *, d))
   }
 }  
 
-void ktest_destroy_checksum(DECLARG(krb5_checksum **, cs))
-     OLDDECLARG(krb5_checksum **, cs)
+void ktest_destroy_checksum(cs)
+     krb5_checksum ** cs;
 {
   if(*cs != NULL){
     if((*cs)->contents != NULL) free((*cs)->contents);
@@ -660,8 +660,8 @@ void ktest_destroy_checksum(DECLARG(krb5_checksum **, cs))
   }
 }
 
-void ktest_destroy_keyblock(DECLARG(krb5_keyblock **, kb))
-     OLDDECLARG(krb5_keyblock **, kb)
+void ktest_destroy_keyblock(kb)
+     krb5_keyblock ** kb;
 {
   if(*kb != NULL){
     if((*kb)->contents != NULL) free((*kb)->contents);
@@ -670,8 +670,8 @@ void ktest_destroy_keyblock(DECLARG(krb5_keyblock **, kb))
   }
 }
 
-void ktest_empty_authorization_data(DECLARG(krb5_authdata **, ad))
-     OLDDECLARG(krb5_authdata **, ad)
+void ktest_empty_authorization_data(ad)
+     krb5_authdata ** ad;
 {
   int i;
 
@@ -679,16 +679,16 @@ void ktest_empty_authorization_data(DECLARG(krb5_authdata **, ad))
     ktest_destroy_authdata(&(ad[i]));
 }
 
-void ktest_destroy_authorization_data(DECLARG(krb5_authdata ***, ad))
-     OLDDECLARG(krb5_authdata ***, ad)
+void ktest_destroy_authorization_data(ad)
+     krb5_authdata *** ad;
 {
   ktest_empty_authorization_data(*ad);
   free(*ad);
   *ad = NULL;
 }
 
-void ktest_destroy_authdata(DECLARG(krb5_authdata **, ad))
-     OLDDECLARG(krb5_authdata **, ad)
+void ktest_destroy_authdata(ad)
+     krb5_authdata ** ad;
 {
   if(*ad != NULL){
     if((*ad)->contents != NULL) free((*ad)->contents);
@@ -697,8 +697,8 @@ void ktest_destroy_authdata(DECLARG(krb5_authdata **, ad))
   }
 }
 
-void ktest_empty_pa_data_array(DECLARG(krb5_pa_data **, pad))
-     OLDDECLARG(krb5_pa_data **, pad)
+void ktest_empty_pa_data_array(pad)
+     krb5_pa_data ** pad;
 {
   int i;
 
@@ -706,16 +706,16 @@ void ktest_empty_pa_data_array(DECLARG(krb5_pa_data **, pad))
     ktest_destroy_pa_data(&(pad[i]));
 }
 
-void ktest_destroy_pa_data_array(DECLARG(krb5_pa_data ***, pad))
-     OLDDECLARG(krb5_pa_data ***, pad)
+void ktest_destroy_pa_data_array(pad)
+     krb5_pa_data *** pad;
 {
   ktest_empty_pa_data_array(*pad);
   free(*pad);
   *pad = NULL;
 }
 
-void ktest_destroy_pa_data(DECLARG(krb5_pa_data **, pad))
-     OLDDECLARG(krb5_pa_data **, pad)
+void ktest_destroy_pa_data(pad)
+     krb5_pa_data ** pad;
 {
   if(*pad != NULL){
     if((*pad)->contents != NULL) free((*pad)->contents);
@@ -725,8 +725,8 @@ void ktest_destroy_pa_data(DECLARG(krb5_pa_data **, pad))
 }
 
 
-void ktest_destroy_address(DECLARG(krb5_address **, a))
-     OLDDECLARG(krb5_address **, a)
+void ktest_destroy_address(a)
+     krb5_address ** a;
 {
   if(*a != NULL){
     if((*a)->contents != NULL) free((*a)->contents);
@@ -735,8 +735,8 @@ void ktest_destroy_address(DECLARG(krb5_address **, a))
   }
 }
 
-void ktest_empty_addresses(DECLARG(krb5_address **, a))
-     OLDDECLARG(krb5_address **, a)
+void ktest_empty_addresses(a)
+     krb5_address ** a;
 {
   int i;
 
@@ -744,16 +744,16 @@ void ktest_empty_addresses(DECLARG(krb5_address **, a))
     ktest_destroy_address(&(a[i]));
 }  
 
-void ktest_destroy_addresses(DECLARG(krb5_address ***, a))
-     OLDDECLARG(krb5_address ***, a)
+void ktest_destroy_addresses(a)
+     krb5_address *** a;
 {
   ktest_empty_addresses(*a);
   free(*a);
   *a = NULL;
 }
 
-void ktest_destroy_principal(DECLARG(krb5_principal *, p))
-     OLDDECLARG(krb5_principal *, p)
+void ktest_destroy_principal(p)
+     krb5_principal * p;
 {
   int i;
 
@@ -763,22 +763,22 @@ void ktest_destroy_principal(DECLARG(krb5_principal *, p))
   *p = NULL;
 }
 
-void ktest_destroy_sequence_of_integer(DECLARG(long **, soi))
-     OLDDECLARG(long **, soi)
+void ktest_destroy_sequence_of_integer(soi)
+     long ** soi;
 {
   free(*soi);
   *soi = NULL;
 }
 
-void ktest_destroy_sequence_of_enctype(DECLARG(krb5_enctype **, soi))
-     OLDDECLARG(krb5_enctype **, soi)
+void ktest_destroy_sequence_of_enctype(soi)
+     krb5_enctype ** soi;
 {
   free(*soi);
   *soi = NULL;
 }
 
-void ktest_destroy_sequence_of_ticket(DECLARG(krb5_ticket ***, sot))
-     OLDDECLARG(krb5_ticket ***, sot)
+void ktest_destroy_sequence_of_ticket(sot)
+     krb5_ticket *** sot;
 {
   int i;
 
@@ -788,8 +788,8 @@ void ktest_destroy_sequence_of_ticket(DECLARG(krb5_ticket ***, sot))
   *sot = NULL;
 }
 
-void ktest_destroy_ticket(DECLARG(krb5_ticket **, tkt))
-     OLDDECLARG(krb5_ticket **, tkt)
+void ktest_destroy_ticket(tkt)
+     krb5_ticket ** tkt;
 {
   ktest_destroy_principal(&((*tkt)->server));
   ktest_destroy_enc_data(&((*tkt)->enc_part));
@@ -797,8 +797,8 @@ void ktest_destroy_ticket(DECLARG(krb5_ticket **, tkt))
   *tkt = NULL;
 }  
 
-void ktest_destroy_enc_data(DECLARG(krb5_enc_data *, ed))
-     OLDDECLARG(krb5_enc_data *, ed)
+void ktest_destroy_enc_data(ed)
+     krb5_enc_data * ed;
 {
   ktest_empty_data(&(ed->ciphertext));
   ed->kvno = 0;
diff --git a/src/tests/asn.1/ktest_equal.c b/src/tests/asn.1/ktest_equal.c
index 10a076440c..cfa6eb07d1 100644
--- a/src/tests/asn.1/ktest_equal.c
+++ b/src/tests/asn.1/ktest_equal.c
@@ -18,10 +18,9 @@ comparator(ref->field,var->field)
 ((ref->length == var->length) && \
  comparator(ref->length,ref->field,var->field))
 
-int ktest_equal_authenticator(DECLARG(krb5_authenticator *, ref),
-			      DECLARG(krb5_authenticator *, var))
-     OLDDECLARG(krb5_authenticator *, ref)
-     OLDDECLARG(krb5_authenticator *, var)
+int ktest_equal_authenticator(ref, var)
+     krb5_authenticator * ref;
+     krb5_authenticator * var;
 {
   int p=TRUE;
   if(ref==var) return TRUE;
@@ -36,10 +35,9 @@ int ktest_equal_authenticator(DECLARG(krb5_authenticator *, ref),
   return p;
 }
 
-int ktest_equal_principal_data(DECLARG(krb5_principal_data *, ref),
-			       DECLARG(krb5_principal_data *, var))
-     OLDDECLARG(krb5_principal_data *, ref)
-     OLDDECLARG(krb5_principal_data *, var)
+int ktest_equal_principal_data(ref, var)
+     krb5_principal_data * ref;
+     krb5_principal_data * var;
 {
   if(ref==var) return TRUE;
   else if(ref == NULL || var == NULL) return FALSE;
@@ -48,10 +46,9 @@ int ktest_equal_principal_data(DECLARG(krb5_principal_data *, ref),
 	 scalar_equal(type));
 }
 
-int ktest_equal_authdata(DECLARG(krb5_authdata *, ref),
-			 DECLARG(krb5_authdata *, var))
-     OLDDECLARG(krb5_authdata *, ref)
-     OLDDECLARG(krb5_authdata *, var)
+int ktest_equal_authdata(ref, var)
+     krb5_authdata * ref;
+     krb5_authdata * var;
 {
   if(ref==var) return TRUE;
   else if(ref == NULL || var == NULL) return FALSE;
@@ -59,40 +56,36 @@ int ktest_equal_authdata(DECLARG(krb5_authdata *, ref),
 	 len_equal(length,contents,ktest_equal_array_of_octet));
 }
 
-int ktest_equal_checksum(DECLARG(krb5_checksum *, ref),
-			 DECLARG(krb5_checksum *, var))
-     OLDDECLARG(krb5_checksum *, ref)
-     OLDDECLARG(krb5_checksum *, var)
+int ktest_equal_checksum(ref, var)
+     krb5_checksum * ref;
+     krb5_checksum * var;
 {
   if(ref==var) return TRUE;
   else if(ref == NULL || var == NULL) return FALSE;
   return(scalar_equal(checksum_type) && len_equal(length,contents,ktest_equal_array_of_octet));
 }
 
-int ktest_equal_keyblock(DECLARG(krb5_keyblock *, ref),
-			 DECLARG(krb5_keyblock *, var))
-     OLDDECLARG(krb5_keyblock *, ref)
-     OLDDECLARG(krb5_keyblock *, var)
+int ktest_equal_keyblock(ref, var)
+     krb5_keyblock * ref;
+     krb5_keyblock * var;
 {
   if(ref==var) return TRUE;
   else if(ref == NULL || var == NULL) return FALSE;
   return(scalar_equal(keytype) && len_equal(length,contents,ktest_equal_array_of_octet));
 }
 
-int ktest_equal_data(DECLARG(krb5_data *, ref),
-		     DECLARG(krb5_data *, var))
-     OLDDECLARG(krb5_data *, ref)
-     OLDDECLARG(krb5_data *, var)
+int ktest_equal_data(ref, var)
+     krb5_data * ref;
+     krb5_data * var;
 {
   if(ref==var) return TRUE;
   else if(ref == NULL || var == NULL) return FALSE;
   return(len_equal(length,data,ktest_equal_array_of_char));
 }
 
-int ktest_equal_ticket(DECLARG(krb5_ticket *, ref),
-		       DECLARG(krb5_ticket *, var))
-     OLDDECLARG(krb5_ticket *, ref)
-     OLDDECLARG(krb5_ticket *, var)
+int ktest_equal_ticket(ref, var)
+     krb5_ticket * ref;
+     krb5_ticket * var;
 {
   int p=TRUE;
   if(ref==var) return TRUE;
@@ -103,10 +96,9 @@ int ktest_equal_ticket(DECLARG(krb5_ticket *, ref),
   return p;
 }
 
-int ktest_equal_enc_data(DECLARG(krb5_enc_data *, ref),
-			 DECLARG(krb5_enc_data *, var))
-     OLDDECLARG(krb5_enc_data *, ref)
-     OLDDECLARG(krb5_enc_data *, var)
+int ktest_equal_enc_data(ref, var)
+     krb5_enc_data * ref;
+     krb5_enc_data * var;
 {
   int p=TRUE;
   if(ref==var) return TRUE;
@@ -117,10 +109,9 @@ int ktest_equal_enc_data(DECLARG(krb5_enc_data *, ref),
   return p;
 }
 
-int ktest_equal_encryption_key(DECLARG(krb5_keyblock *, ref),
-			       DECLARG(krb5_keyblock *, var))
-     OLDDECLARG(krb5_keyblock *, ref)
-     OLDDECLARG(krb5_keyblock *, var)
+int ktest_equal_encryption_key(ref, var)
+     krb5_keyblock * ref;
+     krb5_keyblock * var;
 {
   int p=TRUE;
   if(ref==var) return TRUE;
@@ -130,10 +121,9 @@ int ktest_equal_encryption_key(DECLARG(krb5_keyblock *, ref),
   return p;
 }
 
-int ktest_equal_enc_tkt_part(DECLARG(krb5_enc_tkt_part *, ref),
-			     DECLARG(krb5_enc_tkt_part *, var))
-     OLDDECLARG(krb5_enc_tkt_part *, ref)
-     OLDDECLARG(krb5_enc_tkt_part *, var)
+int ktest_equal_enc_tkt_part(ref, var)
+     krb5_enc_tkt_part * ref;
+     krb5_enc_tkt_part * var;
 {
   int p=TRUE;
   if(ref==var) return TRUE;
@@ -148,10 +138,9 @@ int ktest_equal_enc_tkt_part(DECLARG(krb5_enc_tkt_part *, ref),
   return p;
 }
 
-int ktest_equal_transited(DECLARG(krb5_transited *, ref),
-			  DECLARG(krb5_transited *, var))
-     OLDDECLARG(krb5_transited *, ref)
-     OLDDECLARG(krb5_transited *, var)
+int ktest_equal_transited(ref, var)
+     krb5_transited * ref;
+     krb5_transited * var;
 {
   int p=TRUE;
   if(ref==var) return TRUE;
@@ -161,10 +150,9 @@ int ktest_equal_transited(DECLARG(krb5_transited *, ref),
   return p;
 }
 
-int ktest_equal_ticket_times(DECLARG(krb5_ticket_times *, ref),
-			     DECLARG(krb5_ticket_times *, var))
-     OLDDECLARG(krb5_ticket_times *, ref)
-     OLDDECLARG(krb5_ticket_times *, var)
+int ktest_equal_ticket_times(ref, var)
+     krb5_ticket_times * ref;
+     krb5_ticket_times * var;
 {
   int p=TRUE;
   if(ref==var) return TRUE;
@@ -176,10 +164,9 @@ int ktest_equal_ticket_times(DECLARG(krb5_ticket_times *, ref),
   return p;
 }
 
-int ktest_equal_address(DECLARG(krb5_address *, ref),
-			DECLARG(krb5_address *, var))
-     OLDDECLARG(krb5_address *, ref)
-     OLDDECLARG(krb5_address *, var)
+int ktest_equal_address(ref, var)
+     krb5_address * ref;
+     krb5_address * var;
 {
   int p=TRUE;
   if(ref==var) return TRUE;
@@ -189,10 +176,9 @@ int ktest_equal_address(DECLARG(krb5_address *, ref),
   return p;
 }
 
-int ktest_equal_enc_kdc_rep_part(DECLARG(krb5_enc_kdc_rep_part *, ref),
-				 DECLARG(krb5_enc_kdc_rep_part *, var))
-     OLDDECLARG(krb5_enc_kdc_rep_part *, ref)
-     OLDDECLARG(krb5_enc_kdc_rep_part *, var)
+int ktest_equal_enc_kdc_rep_part(ref, var)
+     krb5_enc_kdc_rep_part * ref;
+     krb5_enc_kdc_rep_part * var;
 {
   int p=TRUE;
   if(ref==var) return TRUE;
@@ -208,10 +194,9 @@ int ktest_equal_enc_kdc_rep_part(DECLARG(krb5_enc_kdc_rep_part *, ref),
   return p;
 }
 
-int ktest_equal_priv(DECLARG(krb5_priv *, ref),
-		     DECLARG(krb5_priv *, var))
-     OLDDECLARG(krb5_priv *, ref)
-     OLDDECLARG(krb5_priv *, var)
+int ktest_equal_priv(ref, var)
+     krb5_priv * ref;
+     krb5_priv * var;
 {
   int p=TRUE;
   if(ref==var) return TRUE;
@@ -220,10 +205,9 @@ int ktest_equal_priv(DECLARG(krb5_priv *, ref),
   return p;
 }
 
-int ktest_equal_cred(DECLARG(krb5_cred *, ref),
-		     DECLARG(krb5_cred *, var))
-     OLDDECLARG(krb5_cred *, ref)
-     OLDDECLARG(krb5_cred *, var)
+int ktest_equal_cred(ref, var)
+     krb5_cred * ref;
+     krb5_cred * var;
 {
   int p=TRUE;
   if(ref==var) return TRUE;
@@ -233,10 +217,9 @@ int ktest_equal_cred(DECLARG(krb5_cred *, ref),
   return p;
 }
 
-int ktest_equal_error(DECLARG(krb5_error *, ref),
-		      DECLARG(krb5_error *, var))
-     OLDDECLARG(krb5_error *, ref)
-     OLDDECLARG(krb5_error *, var)
+int ktest_equal_error(ref, var)
+     krb5_error * ref;
+     krb5_error * var;
 {
   int p=TRUE;
   if(ref==var) return TRUE;
@@ -253,10 +236,9 @@ int ktest_equal_error(DECLARG(krb5_error *, ref),
   return p;
 }
 
-int ktest_equal_ap_req(DECLARG(krb5_ap_req *, ref),
-		       DECLARG(krb5_ap_req *, var))
-     OLDDECLARG(krb5_ap_req *, ref)
-     OLDDECLARG(krb5_ap_req *, var)
+int ktest_equal_ap_req(ref, var)
+     krb5_ap_req * ref;
+     krb5_ap_req * var;
 {
   int p=TRUE;
   if(ref==var) return TRUE;
@@ -267,10 +249,9 @@ int ktest_equal_ap_req(DECLARG(krb5_ap_req *, ref),
   return p;
 }
 
-int ktest_equal_ap_rep(DECLARG(krb5_ap_rep *, ref),
-		       DECLARG(krb5_ap_rep *, var))
-     OLDDECLARG(krb5_ap_rep *, ref)
-     OLDDECLARG(krb5_ap_rep *, var)
+int ktest_equal_ap_rep(ref, var)
+     krb5_ap_rep * ref;
+     krb5_ap_rep * var;
 {
   int p=TRUE;
   if(ref==var) return TRUE;
@@ -279,10 +260,9 @@ int ktest_equal_ap_rep(DECLARG(krb5_ap_rep *, ref),
   return p;
 }
 
-int ktest_equal_ap_rep_enc_part(DECLARG(krb5_ap_rep_enc_part *, ref),
-				DECLARG(krb5_ap_rep_enc_part *, var))
-     OLDDECLARG(krb5_ap_rep_enc_part *, ref)
-     OLDDECLARG(krb5_ap_rep_enc_part *, var)
+int ktest_equal_ap_rep_enc_part(ref, var)
+     krb5_ap_rep_enc_part * ref;
+     krb5_ap_rep_enc_part * var;
 {
   int p=TRUE;
   if(ref==var) return TRUE;
@@ -294,10 +274,9 @@ int ktest_equal_ap_rep_enc_part(DECLARG(krb5_ap_rep_enc_part *, ref),
   return p;
 }
 
-int ktest_equal_safe(DECLARG(krb5_safe *, ref),
-		     DECLARG(krb5_safe *, var))
-     OLDDECLARG(krb5_safe *, ref)
-     OLDDECLARG(krb5_safe *, var)
+int ktest_equal_safe(ref, var)
+     krb5_safe * ref;
+     krb5_safe * var;
 {
   int p=TRUE;
   if(ref==var) return TRUE;
@@ -313,10 +292,9 @@ int ktest_equal_safe(DECLARG(krb5_safe *, ref),
 }
 
 
-int ktest_equal_enc_cred_part(DECLARG(krb5_cred_enc_part *, ref),
-			      DECLARG(krb5_cred_enc_part *, var))
-     OLDDECLARG(krb5_cred_enc_part *, ref)
-     OLDDECLARG(krb5_cred_enc_part *, var)
+int ktest_equal_enc_cred_part(ref, var)
+     krb5_cred_enc_part * ref;
+     krb5_cred_enc_part * var;
 {
   int p=TRUE;
   if(ref==var) return TRUE;
@@ -330,10 +308,9 @@ int ktest_equal_enc_cred_part(DECLARG(krb5_cred_enc_part *, ref),
   return p;
 }
 
-int ktest_equal_enc_priv_part(DECLARG(krb5_priv_enc_part *, ref),
-			      DECLARG(krb5_priv_enc_part *, var))
-     OLDDECLARG(krb5_priv_enc_part *, ref)
-     OLDDECLARG(krb5_priv_enc_part *, var)
+int ktest_equal_enc_priv_part(ref, var)
+     krb5_priv_enc_part * ref;
+     krb5_priv_enc_part * var;
 {
   int p=TRUE;
   if(ref==var) return TRUE;
@@ -347,10 +324,9 @@ int ktest_equal_enc_priv_part(DECLARG(krb5_priv_enc_part *, ref),
   return p;
 }
 
-int ktest_equal_as_rep(DECLARG(krb5_kdc_rep *, ref),
-		       DECLARG(krb5_kdc_rep *, var))
-     OLDDECLARG(krb5_kdc_rep *, ref)
-     OLDDECLARG(krb5_kdc_rep *, var)
+int ktest_equal_as_rep(ref, var)
+     krb5_kdc_rep * ref;
+     krb5_kdc_rep * var;
 {
   int p=TRUE;
   if(ref==var) return TRUE;
@@ -364,18 +340,16 @@ int ktest_equal_as_rep(DECLARG(krb5_kdc_rep *, ref),
   return p;
 }
 
-int ktest_equal_tgs_rep(DECLARG(krb5_kdc_rep *, ref),
-			DECLARG(krb5_kdc_rep *, var))
-     OLDDECLARG(krb5_kdc_rep *, ref)
-     OLDDECLARG(krb5_kdc_rep *, var)
+int ktest_equal_tgs_rep(ref, var)
+     krb5_kdc_rep * ref;
+     krb5_kdc_rep * var;
 {
   return ktest_equal_as_rep(ref,var);
 }
 
-int ktest_equal_as_req(DECLARG(krb5_kdc_req *, ref),
-		       DECLARG(krb5_kdc_req *, var))
-     OLDDECLARG(krb5_kdc_req *, ref)
-     OLDDECLARG(krb5_kdc_req *, var)
+int ktest_equal_as_req(ref, var)
+     krb5_kdc_req * ref;
+     krb5_kdc_req * var;
 {
   int p=TRUE;
   if(ref==var) return TRUE;
@@ -397,18 +371,16 @@ int ktest_equal_as_req(DECLARG(krb5_kdc_req *, ref),
   return p;
 }
 
-int ktest_equal_tgs_req(DECLARG(krb5_kdc_req *, ref),
-			DECLARG(krb5_kdc_req *, var))
-     OLDDECLARG(krb5_kdc_req *, ref)
-     OLDDECLARG(krb5_kdc_req *, var)
+int ktest_equal_tgs_req(ref, var)
+     krb5_kdc_req * ref;
+     krb5_kdc_req * var;
 {
   return ktest_equal_as_req(ref,var);
 }
 
-int ktest_equal_kdc_req_body(DECLARG(krb5_kdc_req *, ref),
-			     DECLARG(krb5_kdc_req *, var))
-     OLDDECLARG(krb5_kdc_req *, ref)
-     OLDDECLARG(krb5_kdc_req *, var)
+int ktest_equal_kdc_req_body(ref, var)
+     krb5_kdc_req * ref;
+     krb5_kdc_req * var;
 {
   int p=TRUE;
   if(ref==var) return TRUE;
@@ -428,10 +400,9 @@ int ktest_equal_kdc_req_body(DECLARG(krb5_kdc_req *, ref),
   return p;
 }
 
-int ktest_equal_last_req_entry(DECLARG(krb5_last_req_entry *, ref),
-			       DECLARG(krb5_last_req_entry *, var))
-     OLDDECLARG(krb5_last_req_entry *, ref)
-     OLDDECLARG(krb5_last_req_entry *, var)
+int ktest_equal_last_req_entry(ref, var)
+     krb5_last_req_entry * ref;
+     krb5_last_req_entry * var;
 {
   int p=TRUE;
   if(ref==var) return TRUE;
@@ -441,10 +412,9 @@ int ktest_equal_last_req_entry(DECLARG(krb5_last_req_entry *, ref),
   return p;
 }
 
-int ktest_equal_pa_data(DECLARG(krb5_pa_data *, ref),
-			DECLARG(krb5_pa_data *, var))
-     OLDDECLARG(krb5_pa_data *, ref)
-     OLDDECLARG(krb5_pa_data *, var)
+int ktest_equal_pa_data(ref, var)
+     krb5_pa_data * ref;
+     krb5_pa_data * var;
 {
   int p=TRUE;
   if(ref==var) return TRUE;
@@ -454,10 +424,9 @@ int ktest_equal_pa_data(DECLARG(krb5_pa_data *, ref),
   return p;
 }
 
-int ktest_equal_cred_info(DECLARG(krb5_cred_info *, ref),
-			  DECLARG(krb5_cred_info *, var))
-     OLDDECLARG(krb5_cred_info *, ref)
-     OLDDECLARG(krb5_cred_info *, var)
+int ktest_equal_cred_info(ref, var)
+     krb5_cred_info * ref;
+     krb5_cred_info * var;
 {
   int p=TRUE;
   if(ref==var) return TRUE;
@@ -472,10 +441,9 @@ int ktest_equal_cred_info(DECLARG(krb5_cred_info *, ref),
   return p;
 }
 
-int ktest_equal_passwd_phrase_element(DECLARG(passwd_phrase_element *, ref),
-				      DECLARG(passwd_phrase_element *, var))
-     OLDDECLARG(passwd_phrase_element *, ref)
-     OLDDECLARG(passwd_phrase_element *, var)
+int ktest_equal_passwd_phrase_element(ref, var)
+     passwd_phrase_element * ref;
+     passwd_phrase_element * var;
 {
   int p=TRUE;
   if(ref==var) return TRUE;
@@ -485,10 +453,9 @@ int ktest_equal_passwd_phrase_element(DECLARG(passwd_phrase_element *, ref),
   return p;
 }
 
-int ktest_equal_krb5_pwd_data(DECLARG(krb5_pwd_data *, ref),
-			      DECLARG(krb5_pwd_data *, var))
-     OLDDECLARG(krb5_pwd_data *, ref)
-     OLDDECLARG(krb5_pwd_data *, var)
+int ktest_equal_krb5_pwd_data(ref, var)
+     krb5_pwd_data * ref;
+     krb5_pwd_data * var;
 {
   int p=TRUE;
   if(ref==var) return TRUE;
@@ -500,12 +467,10 @@ int ktest_equal_krb5_pwd_data(DECLARG(krb5_pwd_data *, ref),
 
 /**** arrays ****************************************************************/
 
-int ktest_equal_array_of_data(DECLARG(const int , length),
-			      DECLARG(krb5_data *, ref),
-			      DECLARG(krb5_data *, var))
-     OLDDECLARG(const int , length)
-     OLDDECLARG(krb5_data *, ref)
-     OLDDECLARG(krb5_data *, var)
+int ktest_equal_array_of_data(length, ref, var)
+     const int length;
+     krb5_data * ref;
+     krb5_data * var;
 {
   int i,p=TRUE;
 
@@ -517,12 +482,10 @@ int ktest_equal_array_of_data(DECLARG(const int , length),
   return p;
 }
 
-int ktest_equal_array_of_octet(DECLARG(const int , length),
-			       DECLARG(krb5_octet *, ref),
-			       DECLARG(krb5_octet *, var))
-     OLDDECLARG(const int , length)
-     OLDDECLARG(krb5_octet *, ref)
-     OLDDECLARG(krb5_octet *, var)
+int ktest_equal_array_of_octet(length, ref, var)
+     const int length;
+     krb5_octet * ref;
+     krb5_octet * var;
 {
   int i, p=TRUE;
 
@@ -533,12 +496,10 @@ int ktest_equal_array_of_octet(DECLARG(const int , length),
   return p;
 }
 
-int ktest_equal_array_of_char(DECLARG(const int , length),
-			      DECLARG(char *, ref),
-			      DECLARG(char *, var))
-     OLDDECLARG(const int , length)
-     OLDDECLARG(char *, ref)
-     OLDDECLARG(char *, var)
+int ktest_equal_array_of_char(length, ref, var)
+     const int length;
+     char * ref;
+     char * var;
 {
   int i, p=TRUE;
 
@@ -549,12 +510,10 @@ int ktest_equal_array_of_char(DECLARG(const int , length),
   return p;
 }
 
-int ktest_equal_array_of_enctype(DECLARG(const int , length),
-				 DECLARG(krb5_enctype *, ref),
-				 DECLARG(krb5_enctype *, var))
-     OLDDECLARG(const int , length)
-     OLDDECLARG(krb5_enctype *, ref)
-     OLDDECLARG(krb5_enctype *, var)
+int ktest_equal_array_of_enctype(length, ref, var)
+     const int length;
+     krb5_enctype * ref;
+     krb5_enctype * var;
 {
   int i, p=TRUE;
 
@@ -576,58 +535,51 @@ for(i=0; ref[i] != NULL && var[i] != NULL; i++)\
 if(ref[i] == NULL && var[i] == NULL) return p;\
 else return FALSE
 
-int ktest_equal_authorization_data(DECLARG(krb5_authdata **, ref),
-				   DECLARG(krb5_authdata **, var))
-     OLDDECLARG(krb5_authdata **, ref)
-     OLDDECLARG(krb5_authdata **, var)
+int ktest_equal_authorization_data(ref, var)
+     krb5_authdata ** ref;
+     krb5_authdata ** var;
 {
   array_compare(ktest_equal_authdata);
 }
 
-int ktest_equal_addresses(DECLARG(krb5_address **, ref),
-			  DECLARG(krb5_address **, var))
-     OLDDECLARG(krb5_address **, ref)
-     OLDDECLARG(krb5_address **, var)
+int ktest_equal_addresses(ref, var)
+     krb5_address ** ref;
+     krb5_address ** var;
 {
   array_compare(ktest_equal_address);
 }
 
-int ktest_equal_last_req(DECLARG(krb5_last_req_entry **, ref),
-			 DECLARG(krb5_last_req_entry **, var))
-     OLDDECLARG(krb5_last_req_entry **, ref)
-     OLDDECLARG(krb5_last_req_entry **, var)
+int ktest_equal_last_req(ref, var)
+     krb5_last_req_entry ** ref;
+     krb5_last_req_entry ** var;
 {
   array_compare(ktest_equal_last_req_entry);
 }
 
-int ktest_equal_sequence_of_ticket(DECLARG(krb5_ticket **, ref),
-				   DECLARG(krb5_ticket **, var))
-     OLDDECLARG(krb5_ticket **, ref)
-     OLDDECLARG(krb5_ticket **, var)
+int ktest_equal_sequence_of_ticket(ref, var)
+     krb5_ticket ** ref;
+     krb5_ticket ** var;
 {
   array_compare(ktest_equal_ticket);
 }
 
-int ktest_equal_sequence_of_pa_data(DECLARG(krb5_pa_data **, ref),
-				    DECLARG(krb5_pa_data **, var))
-     OLDDECLARG(krb5_pa_data **, ref)
-     OLDDECLARG(krb5_pa_data **, var)
+int ktest_equal_sequence_of_pa_data(ref, var)
+     krb5_pa_data ** ref;
+     krb5_pa_data ** var;
 {
   array_compare(ktest_equal_pa_data);
 }
 
-int ktest_equal_sequence_of_cred_info(DECLARG(krb5_cred_info **, ref),
-				      DECLARG(krb5_cred_info **, var))
-     OLDDECLARG(krb5_cred_info **, ref)
-     OLDDECLARG(krb5_cred_info **, var)
+int ktest_equal_sequence_of_cred_info(ref, var)
+     krb5_cred_info ** ref;
+     krb5_cred_info ** var;
 {
   array_compare(ktest_equal_cred_info);
 }
 
-int ktest_equal_array_of_passwd_phrase_element(DECLARG(passwd_phrase_element **, ref),
-					       DECLARG(passwd_phrase_element **, var))
-     OLDDECLARG(passwd_phrase_element **, ref)
-     OLDDECLARG(passwd_phrase_element **, var)
+int ktest_equal_array_of_passwd_phrase_element(ref, var)
+     passwd_phrase_element ** ref;
+     passwd_phrase_element ** var;
 {
   array_compare(ktest_equal_passwd_phrase_element);
 }
diff --git a/src/tests/asn.1/utility.c b/src/tests/asn.1/utility.c
index b8b3af4fe2..6f911e370b 100644
--- a/src/tests/asn.1/utility.c
+++ b/src/tests/asn.1/utility.c
@@ -5,10 +5,9 @@
 
 char hexchar PROTOTYPE((const unsigned int digit));
 
-asn1_error_code asn1_krb5_data_unparse(DECLARG(const krb5_data *, code),
-				       DECLARG(char **, s))
-     OLDDECLARG(const krb5_data *, code)
-     OLDDECLARG(char **, s)
+asn1_error_code asn1_krb5_data_unparse(code, s)
+     const krb5_data * code;
+     char ** s;
 {
   if(*s != NULL) free(*s);
   
@@ -35,8 +34,8 @@ asn1_error_code asn1_krb5_data_unparse(DECLARG(const krb5_data *, code),
   return 0;
 }
 
-char hexchar(DECLARG(const unsigned int , digit))
-     OLDDECLARG(const unsigned int , digit)
+char hexchar(digit)
+     const unsigned int digit;
 {
   if(digit<=9)
     return '0'+digit;
@@ -46,10 +45,9 @@ char hexchar(DECLARG(const unsigned int , digit))
     return 'X';
 }
 
-krb5_error_code krb5_data_parse(DECLARG(krb5_data *, d),
-				DECLARG(const char *, s))
-     OLDDECLARG(krb5_data *, d)
-     OLDDECLARG(const char *, s)
+krb5_error_code krb5_data_parse(d, s)
+     krb5_data * d;
+     const char * s;
 {
   /*if(d->data != NULL){
     free(d->data);
@@ -62,10 +60,9 @@ krb5_error_code krb5_data_parse(DECLARG(krb5_data *, d),
   return 0;
 }
 
-krb5_error_code krb5_data_hex_parse(DECLARG(krb5_data *, d),
-				    DECLARG(const char *, s))
-     OLDDECLARG(krb5_data *, d)
-     OLDDECLARG(const char *, s)
+krb5_error_code krb5_data_hex_parse(d, s)
+     krb5_data * d;
+     const char * s;
 {
   int i, digit;
   char *pos;
@@ -87,8 +84,8 @@ krb5_error_code krb5_data_hex_parse(DECLARG(krb5_data *, d),
 }
 
 #if 0
-void asn1buf_print(DECLARG(const asn1buf *, buf))
-     OLDDECLARG(const asn1buf *, buf)
+void asn1buf_print(buf)
+     const asn1buf * buf;
 {
   asn1buf bufcopy;
   char *s=NULL;
diff --git a/src/tests/create/ChangeLog b/src/tests/create/ChangeLog
index 179840f24f..6b4908f26d 100644
--- a/src/tests/create/ChangeLog
+++ b/src/tests/create/ChangeLog
@@ -1,3 +1,7 @@
+Fri Jan 13 15:23:47 1995  Chris Provenzano (proven@mit.edu)
+
+    * Added krb5_context to all krb5_routines
+
 Sun Oct 23 00:50:07 1994    (tytso@rsx-11)
 
 	* kdb5_mkdums.c (add_princ): Create principals with correct realm
diff --git a/src/tests/create/kdb5_mkdums.c b/src/tests/create/kdb5_mkdums.c
index f4fea5110d..db0b19ac70 100644
--- a/src/tests/create/kdb5_mkdums.c
+++ b/src/tests/create/kdb5_mkdums.c
@@ -76,6 +76,7 @@ krb5_principal master_princ;
 krb5_db_entry master_entry;
 krb5_encrypt_block master_encblock;
 krb5_pointer master_random;
+krb5_context test_context;
 
 static char *progname;
 static char *cur_realm = 0;
@@ -87,7 +88,7 @@ static krb5_boolean dbactive = FALSE;
 void
 quit()
 {
-    krb5_error_code retval = krb5_db_fini();
+    krb5_error_code retval = krb5_db_fini(test_context);
     memset((char *)master_keyblock.contents, 0, master_keyblock.length);
     if (retval) {
 	com_err(progname, retval, "while closing database");
@@ -96,7 +97,7 @@ quit()
     exit(0);
 }
 
-void add_princ PROTOTYPE((char *));
+void add_princ PROTOTYPE((krb5_context, char *));
 
 void
 main(argc, argv)
@@ -118,7 +119,8 @@ char *argv[];
     char *suffix = 0;
     int depth;
 
-    krb5_init_ets();
+    krb5_init_context(&test_context);
+    krb5_init_ets(test_context);
 
     if (strrchr(argv[0], '/'))
 	argv[0] = strrchr(argv[0], '/')+1;
@@ -173,7 +175,7 @@ char *argv[];
     if (!(num_to_create && suffix)) usage(progname, 1);
 
 
-    if (retval = krb5_kt_register(&krb5_ktf_writable_ops)) {
+    if (retval = krb5_kt_register(test_context, &krb5_ktf_writable_ops)) {
 	com_err(progname, retval,
 		"while registering writable key table functions");
 	exit(1);
@@ -196,14 +198,14 @@ char *argv[];
 		"while setting up etype %d", etype);
 	exit(1);
     }
-    krb5_use_cstype(&master_encblock, etype);
+    krb5_use_cstype(test_context, &master_encblock, etype);
     csentry = master_encblock.crypto_entry;
 
     if (!dbname)
 	dbname = DEFAULT_KDB_FILE;	/* XXX? */
 
     if (!cur_realm) {
-	if (retval = krb5_get_default_realm(&cur_realm)) {
+	if (retval = krb5_get_default_realm(test_context, &cur_realm)) {
 	    com_err(progname, retval, "while retrieving default realm name");
 	    exit(1);
 	}	    
@@ -218,20 +220,20 @@ char *argv[];
       (void) sprintf(suffix, "%d", n);
       (void) sprintf(tmp, "%s-DEPTH-1", principal_string);
       str_newprinc = tmp;
-      add_princ(str_newprinc);
+      add_princ(test_context, str_newprinc);
 
       for (i = 2; i <= depth; i++) {
 	tmp2[0] = '\0';
 	(void) sprintf(tmp2, "/%s-DEPTH-%d", principal_string, i);
 	strcat(tmp, tmp2);
 	str_newprinc = tmp;
-	add_princ(str_newprinc);
+	add_princ(test_context, str_newprinc);
       }
     }
 
     (void) (*csentry->finish_key)(&master_encblock);
     (void) (*csentry->finish_random_key)(&master_random);
-    retval = krb5_db_fini();
+    retval = krb5_db_fini(test_context);
     memset((char *)master_keyblock.contents, 0, master_keyblock.length);
     if (retval && retval != KRB5_KDB_DBNOTINITED) {
 	com_err(progname, retval, "while closing database");
@@ -241,8 +243,9 @@ char *argv[];
 }
 
 void
-add_princ(DECLARG(char *, str_newprinc))
-OLDDECLARG(char *, str_newprinc)
+add_princ(context, str_newprinc)
+    krb5_context context;
+    char * str_newprinc;
 {
     krb5_error_code retval;
     krb5_db_entry newentry;
@@ -254,7 +257,7 @@ OLDDECLARG(char *, str_newprinc)
 
     sprintf(princ_name, "%s@%s", str_newprinc, cur_realm);
     
-    if (retval = krb5_parse_name(princ_name, &newprinc)) {
+    if (retval = krb5_parse_name(context, princ_name, &newprinc)) {
       com_err(progname, retval, "while parsing '%s'", princ_name);
       return;
     }
@@ -262,22 +265,19 @@ OLDDECLARG(char *, str_newprinc)
     pwd.data = princ_name;  /* must be able to regenerate */
     pwd.length = strlen(princ_name);
 
-    if (retval = krb5_principal2salt(newprinc, &salt)) {
+    if (retval = krb5_principal2salt(context, newprinc, &salt)) {
 	com_err(progname, retval, "while converting principal to salt for '%s'", princ_name);
 	return;
     }
 
-    retval = krb5_string_to_key(&master_encblock, master_keyblock.keytype,
-				&key,
-				&pwd,
-				&salt);
+    retval = krb5_string_to_key(context, &master_encblock, 
+				master_keyblock.keytype, &key, &pwd, &salt);
     if (retval) {
 	com_err(progname, retval, "while converting password to key for '%s'", princ_name);
 	return;
     }
 
-    retval = krb5_kdb_encrypt_key(&master_encblock,
-				  &key,
+    retval = krb5_kdb_encrypt_key(context, &master_encblock, &key,
 				  &newentry.key);
     if (retval) {
 	com_err(progname, retval, "while encrypting key for '%s'", princ_name);
@@ -294,7 +294,7 @@ OLDDECLARG(char *, str_newprinc)
     newentry.expiration = mblock.expiration;
     newentry.pw_expiration = mblock.expiration;
     newentry.mod_name = master_princ;
-    if (retval = krb5_timeofday(&newentry.mod_date)) {
+    if (retval = krb5_timeofday(context, &newentry.mod_date)) {
 	com_err(progname, retval, "while fetching date");
 	memset((char *)newentry.key.contents, 0, newentry.key.length);
 	free((char *)newentry.key.contents);
@@ -309,7 +309,7 @@ OLDDECLARG(char *, str_newprinc)
     newentry.alt_salt_length = 0;
     newentry.alt_salt = 0;
     
-    retval = krb5_db_put_principal(&newentry, &one);
+    retval = krb5_db_put_principal(context, &newentry, &one);
     if (retval) {
 	com_err(progname, retval, "while storing principal date");
 	free((char *)newentry.key.contents);
@@ -339,14 +339,14 @@ char *dbname;
 
     csentry = master_encblock.crypto_entry;
 
-    if (retval = krb5_db_set_name(dbname)) {
+    if (retval = krb5_db_set_name(test_context, dbname)) {
 	com_err(pname, retval, "while setting active database to '%s'",
 		dbname);
 	return(1);
     }
     /* assemble & parse the master key name */
 
-    if (retval = krb5_db_setup_mkey_name(mkey_name, cur_realm, 0,
+    if (retval = krb5_db_setup_mkey_name(test_context, mkey_name, cur_realm, 0,
 					 &master_princ)) {
 	com_err(pname, retval, "while setting up master key name");
 	return(1);
@@ -354,12 +354,12 @@ char *dbname;
     if (mkey_password) {
 	pwd.data = mkey_password;
 	pwd.length = strlen(mkey_password);
-	retval = krb5_principal2salt(master_princ, &scratch);
+	retval = krb5_principal2salt(test_context, master_princ, &scratch);
 	if (retval) {
 	    com_err(pname, retval, "while calculated master key salt");
 	    return(1);
 	}
-	retval = krb5_string_to_key(&master_encblock, master_keyblock.keytype,
+	retval = krb5_string_to_key(test_context, &master_encblock, master_keyblock.keytype,
 				    &master_keyblock, &pwd, &scratch);
 	if (retval) {
 	    com_err(pname, retval,
@@ -368,51 +368,51 @@ char *dbname;
 	}
 	free(scratch.data);
     } else {
-	if (retval = krb5_db_fetch_mkey(master_princ, &master_encblock,
+	if (retval = krb5_db_fetch_mkey(test_context, master_princ, &master_encblock,
 					manual_mkey, FALSE, 0,
 					&master_keyblock)) {
 	    com_err(pname, retval, "while reading master key");
 	    return(1);
 	}
     }
-    if (retval = krb5_db_init()) {
+    if (retval = krb5_db_init(test_context)) {
 	com_err(pname, retval, "while initializing database");
 	return(1);
     }
-    if (retval = krb5_db_verify_master_key(master_princ, &master_keyblock,
+    if (retval = krb5_db_verify_master_key(test_context, master_princ, &master_keyblock,
 					   &master_encblock)) {
 	com_err(pname, retval, "while verifying master key");
-	(void) krb5_db_fini();
+	(void) krb5_db_fini(test_context);
 	return(1);
     }
     nentries = 1;
-    if (retval = krb5_db_get_principal(master_princ, &master_entry, &nentries,
-				       &more)) {
+    if (retval = krb5_db_get_principal(test_context, master_princ, 
+				       &master_entry, &nentries, &more)) {
 	com_err(pname, retval, "while retrieving master entry");
-	(void) krb5_db_fini();
+	(void) krb5_db_fini(test_context);
 	return(1);
     } else if (more) {
 	com_err(pname, KRB5KDC_ERR_PRINCIPAL_NOT_UNIQUE,
 		"while retrieving master entry");
-	(void) krb5_db_fini();
+	(void) krb5_db_fini(test_context);
 	return(1);
     } else if (!nentries) {
 	com_err(pname, KRB5_KDB_NOENTRY, "while retrieving master entry");
-	(void) krb5_db_fini();
+	(void) krb5_db_fini(test_context);
 	return(1);
     }
 
     if (retval = (*csentry->process_key)(&master_encblock,
 					 &master_keyblock)) {
 	com_err(pname, retval, "while processing master key");
-	(void) krb5_db_fini();
+	(void) krb5_db_fini(test_context);
 	return(1);
     }
     if (retval = (*csentry->init_random_key)(&master_keyblock,
 					     &master_random)) {
 	com_err(pname, retval, "while initializing random key generator");
 	(void) (*csentry->finish_key)(&master_encblock);
-	(void) krb5_db_fini();
+	(void) krb5_db_fini(test_context);
 	return(1);
     }
     mblock.max_life = master_entry.max_life;
@@ -421,7 +421,7 @@ char *dbname;
     /* don't set flags, master has some extra restrictions */
     mblock.mkvno = master_entry.kvno;
 
-    krb5_db_free_principal(&master_entry, nentries);
+    krb5_db_free_principal(test_context, &master_entry, nentries);
     dbactive = TRUE;
     return 0;
 }
diff --git a/src/tests/hammer/ChangeLog b/src/tests/hammer/ChangeLog
index be5d863b1e..eb780f9db6 100644
--- a/src/tests/hammer/ChangeLog
+++ b/src/tests/hammer/ChangeLog
@@ -1,3 +1,7 @@
+Fri Jan 13 15:23:47 1995  Chris Provenzano (proven@mit.edu)
+
+    * Added krb5_context to all krb5_routines
+
 Tue Nov  8 17:53:40 1994  Theodore Y. Ts'o  (tytso@dcl)
 
 	* kdc5_hammer.c (get_server_key): Use the published interface to
diff --git a/src/tests/hammer/kdc5_hammer.c b/src/tests/hammer/kdc5_hammer.c
index 0fcf4d0991..d7b0239a17 100644
--- a/src/tests/hammer/kdc5_hammer.c
+++ b/src/tests/hammer/kdc5_hammer.c
@@ -60,14 +60,19 @@ krb5_data tgtname = {
     KRB5_TGS_NAME
 };
 
-int verify_cs_pair PROTOTYPE((char *,
-			      krb5_principal,
-			      char *,
-			      int, int, int,
-			      krb5_ccache));
-int get_tgt PROTOTYPE((char *,
-		       krb5_principal *,
-		       krb5_ccache));
+int verify_cs_pair 
+	PROTOTYPE((krb5_context,
+		   char *,
+		   krb5_principal,
+		   char *,
+		   int, int, int,
+		   krb5_ccache));
+
+int get_tgt 
+	PROTOTYPE((krb5_context,
+		   char *,
+		   krb5_principal *,
+		   krb5_ccache));
 
 static void
 usage(who, status)
@@ -85,6 +90,7 @@ int status;
 
 static krb5_enctype etype = 0xffff;
 static krb5_preauthtype patype = KRB5_PADATA_NONE;
+static krb5_context test_context;
 static krb5_keytype keytype;
 
 void
@@ -105,7 +111,8 @@ main(argc, argv)
     krb5_principal client_princ;
     krb5_error_code retval;
 
-    krb5_init_ets();
+    krb5_init_context(&test_context);
+    krb5_init_ets(test_context);
 
     if (strrchr(argv[0], '/'))
 	prog = strrchr(argv[0], '/')+1;
@@ -157,7 +164,7 @@ main(argc, argv)
 	    if (ccache == NULL) {
 		cache_name = optarg;
 		
-		code = krb5_cc_resolve (cache_name, &ccache);
+		code = krb5_cc_resolve (test_context, cache_name, &ccache);
 		if (code != 0) {
 		    com_err (prog, code, "resolving %s", cache_name);
 		    errflg++;
@@ -180,7 +187,7 @@ main(argc, argv)
 	keytype = DEFAULT_KDC_KEYTYPE;
 
     if (!cur_realm) {
-	if (retval = krb5_get_default_realm(&cur_realm)) {
+	if (retval = krb5_get_default_realm(test_context, &cur_realm)) {
 	    com_err(prog, retval, "while retrieving default realm name");
 	    exit(1);
 	}	    
@@ -202,7 +209,7 @@ main(argc, argv)
     }
 
     if (ccache == NULL) {
-	if (code = krb5_cc_default(&ccache)) {
+	if (code = krb5_cc_default(test_context, &ccache)) {
 	    com_err(prog, code, "while getting default ccache");
 	    exit(1);
 	}
@@ -226,7 +233,7 @@ main(argc, argv)
 	  strcat(ctmp, ctmp2);
 	  sprintf(client, "%s@%s", ctmp, cur_realm);
 
-	  if (get_tgt (client, &client_princ, ccache)) {
+	  if (get_tgt (test_context, client, &client_princ, ccache)) {
 	    errors++;
 	    n_tried++;
 	    continue;
@@ -240,11 +247,12 @@ main(argc, argv)
 			   prefix, n, j);
 	    strcat(stmp, stmp2);
 	    sprintf(server, "%s@%s", stmp, cur_realm);
-	    if (verify_cs_pair(client, client_princ, server, n, i, j, ccache))
+	    if (verify_cs_pair(test_context, client, client_princ, 
+			       server, n, i, j, ccache))
 	      errors++;
 	    n_tried++;
 	  }
-	  krb5_free_principal(client_princ);
+	  krb5_free_principal(test_context, client_princ);
 	}
       }
     }
@@ -253,14 +261,12 @@ main(argc, argv)
 
        
 #include <krb5/widen.h>
-krb5_error_code get_server_key(DECLARG(krb5_pointer,keyprocarg),
-			       DECLARG(krb5_principal,princ),
-			       DECLARG(krb5_kvno,vno),
-			       DECLARG(krb5_keyblock **,key))
-OLDDECLARG(krb5_pointer,keyprocarg)
-OLDDECLARG(krb5_principal,princ)
-OLDDECLARG(krb5_kvno,vno)
-OLDDECLARG(krb5_keyblock **,key)
+krb5_error_code get_server_key(context, keyprocarg, princ, vno, key)
+    krb5_context context;
+    krb5_pointer keyprocarg;
+    krb5_principal princ;
+    krb5_kvno vno;
+    krb5_keyblock ** key;
 #include <krb5/narrow.h>
 {
   krb5_encrypt_block eblock;
@@ -270,7 +276,7 @@ OLDDECLARG(krb5_keyblock **,key)
   /* Jon Rochlis asks: Does this belong here or in libos or something? */
   /* John Kohl replies: not really; it's not a generally useful function */
 
-  code = krb5_unparse_name(princ, &princ_str);
+  code = krb5_unparse_name(context, princ, &princ_str);
   if (code) {
     com_err (prog, code, "while unparsing server name");
     return(code);
@@ -284,7 +290,7 @@ OLDDECLARG(krb5_keyblock **,key)
   pwd.data = princ_str;
   pwd.length = strlen(princ_str);
   
-  if (code = krb5_principal2salt(princ, &salt)) {
+  if (code = krb5_principal2salt(context, princ, &salt)) {
     com_err(prog, code, "while converting principal to salt for '%s'", princ_str);
     goto errout;
   }
@@ -295,8 +301,8 @@ OLDDECLARG(krb5_keyblock **,key)
     com_err(prog, code, "while allocating key for server %s", princ_str);
     goto errout;
   }    
-  krb5_use_keytype(&eblock, keytype);
-  code = krb5_string_to_key(&eblock, keytype, *key, &pwd, &salt);
+  krb5_use_keytype(context, &eblock, keytype);
+  code = krb5_string_to_key(context, &eblock, keytype, *key, &pwd, &salt);
   if (code)
     goto errout;
 
@@ -311,13 +317,14 @@ out:
 
 }
 
-int verify_cs_pair(p_client_str, p_client, p_server_str, p_num, 
+int verify_cs_pair(context, p_client_str, p_client, p_server_str, p_num, 
 		   c_depth, s_depth, ccache)
-     char *p_client_str;
-     krb5_principal p_client;
-     char *p_server_str;
-     int p_num, c_depth, s_depth;
-     krb5_ccache ccache;
+    krb5_context context;
+    char *p_client_str;
+    krb5_principal p_client;
+    char *p_server_str;
+    int p_num, c_depth, s_depth;
+    krb5_ccache ccache;
 {
     krb5_error_code code;
     krb5_principal server;
@@ -332,46 +339,49 @@ int verify_cs_pair(p_client_str, p_client, p_server_str, p_num,
       fprintf(stderr, "\tclient %s for server %s\n", p_client_str, 
 	      p_server_str);
 
-    if (code = krb5_parse_name (p_server_str, &server)) {
+    if (code = krb5_parse_name (context, p_server_str, &server)) {
       com_err (prog, code, "when parsing name %s", p_server_str);
       return(-1);
     }
 
     /* test the checksum stuff? */
-    if (code = krb5_mk_req(server, 0, 0, ccache, &request_data)) {
+    if (code = krb5_mk_req(context, server, 0, 0, ccache, &request_data)) {
 	com_err(prog, code, "while preparing AP_REQ for %s", p_server_str);
 	return(-1);
     }
 
-    if (code = krb5_rd_req(&request_data, server, 0, 0, get_server_key, 0, 0, 
-			   &authdat)) {
+    if (code = krb5_rd_req(context, &request_data, server, 0, 0, 
+			   get_server_key, 0, 0, &authdat)) {
 	com_err(prog, code, "while decoding AP_REQ for %s", p_server_str);
 	return(-1);
     }
 
-    if (!krb5_principal_compare(authdat->authenticator->client, p_client)) {
-      code = krb5_unparse_name(authdat->authenticator->client, &returned_client);
+    if (!krb5_principal_compare(context, authdat->authenticator->client, 
+				p_client)) {
+      code = krb5_unparse_name(context, authdat->authenticator->client, 
+			       &returned_client);
       if (code)
 	com_err (prog, code, 
 		 "Client not as expected, but cannot unparse client name");
       else
 	com_err (prog, 0, "Client not as expected (%s).", returned_client);
-      krb5_free_tkt_authent(authdat);
+      krb5_free_tkt_authent(context, authdat);
       free(returned_client);
       return(-1);
     }
 
-    krb5_free_tkt_authent(authdat);
-    krb5_free_principal(server);
+    krb5_free_tkt_authent(context, authdat);
+    krb5_free_principal(context, server);
     if (request_data.data) krb5_xfree(request_data.data);
 
     return(0);
 }
 
-int get_tgt (p_client_str, p_client, ccache)
-     char *p_client_str;
-     krb5_principal *p_client;
-     krb5_ccache ccache;
+int get_tgt (context, p_client_str, p_client, ccache)
+    krb5_context context;
+    char *p_client_str;
+    krb5_principal *p_client;
+    krb5_ccache ccache;
 {
     char *cache_name = NULL;		/* -f option */
     long lifetime = KRB5_DEFAULT_LIFE;	/* -l option */
@@ -385,27 +395,27 @@ int get_tgt (p_client_str, p_client, ccache)
     if (!brief)
       fprintf(stderr, "\tgetting TGT for %s\n", p_client_str);
 
-    if (code = krb5_timeofday(&start)) {
+    if (code = krb5_timeofday(context, &start)) {
 	com_err(prog, code, "while getting time of day");
 	return(-1);
     }
 
     memset((char *)&my_creds, 0, sizeof(my_creds));
     
-    if (code = krb5_parse_name (p_client_str, p_client)) {
+    if (code = krb5_parse_name (context, p_client_str, p_client)) {
 	com_err (prog, code, "when parsing name %s", p_client_str);
 	return(-1);
     }
 
 
-    if (code = krb5_build_principal_ext(&tgt_server,
-					krb5_princ_realm(*p_client)->length,
-					krb5_princ_realm(*p_client)->data,
-					tgtname.length,
-					tgtname.data,
-					krb5_princ_realm(*p_client)->length,
-					krb5_princ_realm(*p_client)->data,
-					0)) {
+    if (code = krb5_build_principal_ext(context, &tgt_server,
+				krb5_princ_realm(context, *p_client)->length,
+				krb5_princ_realm(context, *p_client)->data,
+				tgtname.length,
+				tgtname.data,
+				krb5_princ_realm(context, *p_client)->length,
+				krb5_princ_realm(context, *p_client)->data,
+				0)) {
 	com_err(prog, code, "when setting up tgt principal");
 	return(-1);
     }
@@ -419,9 +429,10 @@ int get_tgt (p_client_str, p_client, ccache)
     my_creds.client = *p_client;
     my_creds.server = tgt_server;
 
-    krb5_cc_destroy(ccache);  /* ugh, I'd much rather just delete the credential */
+    /* ugh, I'd much rather just delete the credential */
+    krb5_cc_destroy(context, ccache);  
 
-    code = krb5_cc_initialize (ccache, *p_client);
+    code = krb5_cc_initialize (context, ccache, *p_client);
     if (code != 0) {
 	com_err (prog, code, "when initializing cache %s",
 		 cache_name?cache_name:"");
@@ -433,7 +444,7 @@ int get_tgt (p_client_str, p_client, ccache)
     my_creds.times.endtime = start + lifetime;
     my_creds.times.renew_till = 0;
 
-    code = krb5_get_in_tkt_with_password(options, my_addresses,
+    code = krb5_get_in_tkt_with_password(context, options, my_addresses,
 					 patype,
 					 etype,
 					 keytype,
@@ -441,9 +452,9 @@ int get_tgt (p_client_str, p_client, ccache)
 					 ccache,
 					 &my_creds, 0);
     my_creds.server = my_creds.client = 0;
-    krb5_free_principal(tgt_server);
-    krb5_free_addresses(my_addresses);
-    krb5_free_cred_contents(&my_creds);
+    krb5_free_principal(context, tgt_server);
+    krb5_free_addresses(context, my_addresses);
+    krb5_free_cred_contents(context, &my_creds);
     if (code != 0) {
 	com_err (prog, code, "while getting initial credentials");
 	return(-1);
diff --git a/src/tests/verify/ChangeLog b/src/tests/verify/ChangeLog
index e809cc837a..914490a789 100644
--- a/src/tests/verify/ChangeLog
+++ b/src/tests/verify/ChangeLog
@@ -1,3 +1,7 @@
+Fri Jan 13 15:23:47 1995  Chris Provenzano (proven@mit.edu)
+
+    * Added krb5_context to all krb5_routines
+
 Sun Oct 23 00:50:42 1994    (tytso@rsx-11)
 
 	* kdb5_verify.c (check_princ): Check principals with the correct
diff --git a/src/tests/verify/kdb5_verify.c b/src/tests/verify/kdb5_verify.c
index 6c5d37a7c6..d66c3cb280 100644
--- a/src/tests/verify/kdb5_verify.c
+++ b/src/tests/verify/kdb5_verify.c
@@ -56,7 +56,7 @@ struct mblock {
     0
 };
 
-int set_dbname_help PROTOTYPE((char *, char *));
+int set_dbname_help PROTOTYPE((krb5_context, char *, char *));
 
 static void
 usage(who, status)
@@ -86,9 +86,10 @@ static krb5_boolean manual_mkey = FALSE;
 static krb5_boolean dbactive = FALSE;
 
 void
-quit()
+quit(context)
+    krb5_context context;
 {
-    krb5_error_code retval = krb5_db_fini();
+    krb5_error_code retval = krb5_db_fini(context);
     memset((char *)master_keyblock.contents, 0, master_keyblock.length);
     if (retval) {
 	com_err(progname, retval, "while closing database");
@@ -97,7 +98,7 @@ quit()
     exit(0);
 }
 
-int check_princ PROTOTYPE((char *));
+int check_princ PROTOTYPE((krb5_context, char *));
 
 void
 main(argc, argv)
@@ -108,6 +109,7 @@ char *argv[];
     int optchar, i, n;
     char tmp[4096], tmp2[BUFSIZ], *str_princ;
 
+    krb5_context context;
     krb5_error_code retval;
     char *dbname = 0;
     int keytypedone = 0;
@@ -118,7 +120,8 @@ char *argv[];
     char *suffix = 0;
     int depth, errors;
 
-    krb5_init_ets();
+    krb5_init_context(&context);
+    krb5_init_ets(context);
 
     if (strrchr(argv[0], '/'))
 	argv[0] = strrchr(argv[0], '/')+1;
@@ -189,19 +192,19 @@ char *argv[];
 		"while setting up etype %d", etype);
 	exit(1);
     }
-    krb5_use_cstype(&master_encblock, etype);
+    krb5_use_cstype(context, &master_encblock, etype);
     csentry = master_encblock.crypto_entry;
 
     if (!dbname)
 	dbname = DEFAULT_KDB_FILE;	/* XXX? */
 
     if (!cur_realm) {
-	if (retval = krb5_get_default_realm(&cur_realm)) {
+	if (retval = krb5_get_default_realm(context, &cur_realm)) {
 	    com_err(progname, retval, "while retrieving default realm name");
 	    exit(1);
 	}	    
     }
-    if (retval = set_dbname_help(progname, dbname))
+    if (retval = set_dbname_help(context, progname, dbname))
 	exit(retval);
 
     errors = 0;
@@ -215,14 +218,14 @@ char *argv[];
       (void) sprintf(suffix, "%d", n);
       (void) sprintf(tmp, "%s-DEPTH-1", principal_string);
       str_princ = tmp;
-      if (check_princ(str_princ)) errors++;
+      if (check_princ(context, str_princ)) errors++;
 
       for (i = 2; i <= depth; i++) {
 	tmp2[0] = '\0';
 	(void) sprintf(tmp2, "/%s-DEPTH-%d", principal_string, i);
 	strcat(tmp, tmp2);
 	str_princ = tmp;
-	if (check_princ(str_princ)) errors++;
+	if (check_princ(context, str_princ)) errors++;
       }
     }
 
@@ -233,7 +236,7 @@ char *argv[];
 
     (void) (*csentry->finish_key)(&master_encblock);
     (void) (*csentry->finish_random_key)(&master_random);
-    retval = krb5_db_fini();
+    retval = krb5_db_fini(context);
     memset((char *)master_keyblock.contents, 0, master_keyblock.length);
     if (retval && retval != KRB5_KDB_DBNOTINITED) {
 	com_err(progname, retval, "while closing database");
@@ -243,8 +246,9 @@ char *argv[];
 }
 
 int
-check_princ(DECLARG(char *, str_princ))
-OLDDECLARG(char *, str_princ)
+check_princ(context, str_princ)
+    krb5_context context;
+    char * str_princ;
 {
     krb5_error_code retval;
     krb5_db_entry kdbe;
@@ -260,7 +264,7 @@ OLDDECLARG(char *, str_princ)
 
     fprintf(stderr, "\t%s ...\n", princ_name);
 
-    if (retval = krb5_parse_name(princ_name, &princ)) {
+    if (retval = krb5_parse_name(context, princ_name, &princ)) {
       com_err(progname, retval, "while parsing '%s'", princ_name);
       goto out;
     }
@@ -268,12 +272,12 @@ OLDDECLARG(char *, str_princ)
     pwd.data = princ_name;  /* must be able to regenerate */
     pwd.length = strlen(princ_name);
 
-    if (retval = krb5_principal2salt(princ, &salt)) {
+    if (retval = krb5_principal2salt(context, princ, &salt)) {
 	com_err(progname, retval, "while converting principal to salt for '%s'", princ_name);
 	goto out;
     }
 
-    retval = krb5_string_to_key(&master_encblock, master_keyblock.keytype,
+    retval = krb5_string_to_key(context, &master_encblock, master_keyblock.keytype,
 				&pwd_key,
 				&pwd,
 				&salt);
@@ -282,7 +286,7 @@ OLDDECLARG(char *, str_princ)
 	goto out;
     }
 
-    if (retval = krb5_db_get_principal(princ, &kdbe, &nprincs, &more)) {
+    if (retval = krb5_db_get_principal(context,princ, &kdbe, &nprincs, &more)) {
       com_err(progname, retval, "while attempting to verify principal's existence");
       goto out;
     }
@@ -293,7 +297,7 @@ OLDDECLARG(char *, str_princ)
       goto errout;
     }
 
-    retval = krb5_kdb_decrypt_key(&master_encblock,
+    retval = krb5_kdb_decrypt_key(context, &master_encblock,
 				  &kdbe.key,
 				  &db_key);
     if (retval) {
@@ -306,7 +310,7 @@ OLDDECLARG(char *, str_princ)
       fprintf (stderr, "\tKey types do not agree (%d expected, %d from db)\n",
 	       pwd_key.keytype, db_key.keytype);
 errout:
-      krb5_db_free_principal(&kdbe, nprincs);
+      krb5_db_free_principal(context, &kdbe, nprincs);
       return(-1);
     }
     else {
@@ -350,7 +354,7 @@ errout:
       goto errout;
     }
 
-    if (retval = krb5_unparse_name(kdbe.mod_name, &str_mod_name))
+    if (retval = krb5_unparse_name(context, kdbe.mod_name, &str_mod_name))
       com_err(progname, retval, "while unparsing mode name");
     else {
       if (strcmp(str_mod_name, str_master_princ) != 0) {
@@ -369,15 +373,16 @@ errout:
     }
 
     out:
-    krb5_db_free_principal(&kdbe, nprincs);
+    krb5_db_free_principal(context, &kdbe, nprincs);
 
     return(0);
 }
 
 int
-set_dbname_help(pname, dbname)
-char *pname;
-char *dbname;
+set_dbname_help(context, pname, dbname)
+    krb5_context context;
+    char *pname;
+    char *dbname;
 {
     krb5_error_code retval;
     int nentries;
@@ -387,14 +392,14 @@ char *dbname;
 
     csentry = master_encblock.crypto_entry;
 
-    if (retval = krb5_db_set_name(dbname)) {
+    if (retval = krb5_db_set_name(context, dbname)) {
 	com_err(pname, retval, "while setting active database to '%s'",
 		dbname);
 	return(1);
     }
     /* assemble & parse the master key name */
 
-    if (retval = krb5_db_setup_mkey_name(mkey_name, cur_realm, 0,
+    if (retval = krb5_db_setup_mkey_name(context, mkey_name, cur_realm, 0,
 					 &master_princ)) {
 	com_err(pname, retval, "while setting up master key name");
 	return(1);
@@ -402,13 +407,14 @@ char *dbname;
     if (mkey_password) {
 	pwd.data = mkey_password;
 	pwd.length = strlen(mkey_password);
-	retval = krb5_principal2salt(master_princ, &scratch);
+	retval = krb5_principal2salt(context, master_princ, &scratch);
 	if (retval) {
 	    com_err(pname, retval, "while calculated master key salt");
 	    return(1);
 	}
-	retval = krb5_string_to_key(&master_encblock, master_keyblock.keytype,
-				    &master_keyblock, &pwd, &scratch);
+	retval = krb5_string_to_key(context, &master_encblock, 
+				    master_keyblock.keytype, &master_keyblock,
+				    &pwd, &scratch);
 	if (retval) {
 	    com_err(pname, retval,
 		    "while transforming master key from password");
@@ -416,57 +422,57 @@ char *dbname;
 	}
 	free(scratch.data);
     } else {
-	if (retval = krb5_db_fetch_mkey(master_princ, &master_encblock,
+	if (retval = krb5_db_fetch_mkey(context, master_princ, &master_encblock,
 					manual_mkey, FALSE, 0,
 					&master_keyblock)) {
 	    com_err(pname, retval, "while reading master key");
 	    return(1);
 	}
     }
-    if (retval = krb5_db_init()) {
+    if (retval = krb5_db_init(context )) {
 	com_err(pname, retval, "while initializing database");
 	return(1);
     }
-    if (retval = krb5_db_verify_master_key(master_princ, &master_keyblock,
-					   &master_encblock)) {
+    if (retval = krb5_db_verify_master_key(context, master_princ, 
+					   &master_keyblock,&master_encblock)) {
 	com_err(pname, retval, "while verifying master key");
-	(void) krb5_db_fini();
+	(void) krb5_db_fini(context);
 	return(1);
     }
     nentries = 1;
-    if (retval = krb5_db_get_principal(master_princ, &master_entry, &nentries,
-				       &more)) {
+    if (retval = krb5_db_get_principal(context, master_princ, &master_entry, 
+				       &nentries, &more)) {
 	com_err(pname, retval, "while retrieving master entry");
-	(void) krb5_db_fini();
+	(void) krb5_db_fini(context);
 	return(1);
     } else if (more) {
 	com_err(pname, KRB5KDC_ERR_PRINCIPAL_NOT_UNIQUE,
 		"while retrieving master entry");
-	(void) krb5_db_fini();
+	(void) krb5_db_fini(context);
 	return(1);
     } else if (!nentries) {
 	com_err(pname, KRB5_KDB_NOENTRY, "while retrieving master entry");
-	(void) krb5_db_fini();
+	(void) krb5_db_fini(context);
 	return(1);
     }
 
-    if (retval = krb5_unparse_name(master_princ, &str_master_princ)) {
+    if (retval = krb5_unparse_name(context, master_princ, &str_master_princ)) {
       com_err(pname, retval, "while unparsing master principal");
-      krb5_db_fini();
+      krb5_db_fini(context);
       return(1);
     }
 
     if (retval = (*csentry->process_key)(&master_encblock,
 					 &master_keyblock)) {
 	com_err(pname, retval, "while processing master key");
-	(void) krb5_db_fini();
+	(void) krb5_db_fini(context);
 	return(1);
     }
     if (retval = (*csentry->init_random_key)(&master_keyblock,
 					     &master_random)) {
 	com_err(pname, retval, "while initializing random key generator");
 	(void) (*csentry->finish_key)(&master_encblock);
-	(void) krb5_db_fini();
+	(void) krb5_db_fini(context);
 	return(1);
     }
     mblock.max_life = master_entry.max_life;
@@ -475,7 +481,7 @@ char *dbname;
     /* don't set flags, master has some extra restrictions */
     mblock.mkvno = master_entry.kvno;
 
-    krb5_db_free_principal(&master_entry, nentries);
+    krb5_db_free_principal(context, &master_entry, nentries);
     dbactive = TRUE;
     return 0;
 }