diff --git a/bin/named/server.c b/bin/named/server.c
index 38ec90d75e..663002c9ec 100644
--- a/bin/named/server.c
+++ b/bin/named/server.c
@@ -294,8 +294,7 @@ load_configuration(const char *filename) {
 		      ISC_LOG_INFO, "loading '%s'", filename);
 
 	configctx = NULL;
-	result = dns_c_parse_namedconf(ns_g_lctx,
-				       filename, ns_g_mctx, &configctx,
+	result = dns_c_parse_namedconf(filename, ns_g_mctx, &configctx,
 				       &callbacks);
 	if (result != ISC_R_SUCCESS) {
 #ifdef notyet
@@ -397,7 +396,7 @@ load_configuration(const char *filename) {
 	}
 
 	if (oconfigctx != NULL)
-		dns_c_ctx_delete(ns_g_lctx, &oconfigctx);
+		dns_c_ctx_delete(&oconfigctx);
 
 	/*
 	 * Load the TSIG information from the configuration
@@ -536,7 +535,7 @@ shutdown_server(isc_task_t *task, isc_event_t *event) {
 	/*
 	 * XXXRTH  Is this the right place to do this?
 	 */
-	dns_c_ctx_delete(ns_g_lctx, &ns_g_confctx);
+	dns_c_ctx_delete(&ns_g_confctx);
 
 	dns_tkey_destroy();
 	dns_tsig_destroy();
diff --git a/bin/tests/nconf_test.c b/bin/tests/nconf_test.c
index 174c92f469..ba53a5d97a 100644
--- a/bin/tests/nconf_test.c
+++ b/bin/tests/nconf_test.c
@@ -43,7 +43,7 @@ zonecbk(dns_c_ctx_t *ctx, dns_c_zone_t *zone, dns_c_view_t *view, void *uap)
 	(void) ctx;
 	(void) uap;
 	
-	dns_c_zone_getname(NULL, zone, &zname);
+	dns_c_zone_getname(zone, &zname);
 
 #if 0
 	if (view != NULL) {
@@ -107,7 +107,7 @@ int main (int argc, char **argv) {
 
 	RUNTIME_CHECK(isc_mem_create(0, 0, &mem) == ISC_R_SUCCESS);
 
-	if (dns_c_parse_namedconf(NULL, conffile, mem, &configctx, &callbacks) !=
+	if (dns_c_parse_namedconf(conffile, mem, &configctx, &callbacks) !=
 	    ISC_R_SUCCESS) {
 		fprintf(stderr, "parse_configuration failed.\n");
 		exit(1);
@@ -128,7 +128,7 @@ int main (int argc, char **argv) {
 		}
 	}
 	
-	dns_c_ctx_print(NULL, outfp, 0, configctx);
+	dns_c_ctx_print(outfp, 0, configctx);
 
 #if 0
 	/* Test the acl expansion */
@@ -146,7 +146,7 @@ int main (int argc, char **argv) {
 		fclose(outfp);
 	}
 
-	dns_c_ctx_delete(NULL, &configctx);
+	dns_c_ctx_delete(&configctx);
 	isc_mem_destroy(&mem);
 
 	return (0);
diff --git a/lib/dns/aml.c b/lib/dns/aml.c
index 1f6f2d581b..1eba379fe9 100644
--- a/lib/dns/aml.c
+++ b/lib/dns/aml.c
@@ -191,8 +191,7 @@ dns_aml_match(isc_sockaddr_t *reqaddr,
 #endif
 
 		case dns_c_ipmatch_acl:
-			result = dns_c_acltable_getacl(dns_lctx,
-						       acltable,
+			result = dns_c_acltable_getacl(acltable,
 						       e->u.aclname,
 						       &acl);
 			if (result == ISC_R_SUCCESS) {
@@ -233,7 +232,7 @@ dns_aml_match(isc_sockaddr_t *reqaddr,
 			break;
 
 		matched:
-			*match = dns_c_ipmatchelement_isneg(dns_lctx, e) ?
+			*match = dns_c_ipmatchelement_isneg(e) ?
 				-distance : distance;
 			if (matchelt != NULL)
 				*matchelt = e;
diff --git a/lib/dns/config/confacl.c b/lib/dns/config/confacl.c
index 9d6a898a03..9bd9f56d8b 100644
--- a/lib/dns/config/confacl.c
+++ b/lib/dns/config/confacl.c
@@ -27,13 +27,12 @@
 #include <dns/confcommon.h>
 
 
-static isc_result_t acl_delete(isc_log_t *lctx, dns_c_acl_t **aclptr);
+static isc_result_t acl_delete(dns_c_acl_t **aclptr);
 
 
 
 isc_result_t
-dns_c_acltable_new(isc_log_t *lctx,
-		   isc_mem_t *mem, dns_c_acltable_t **newtable)
+dns_c_acltable_new(isc_mem_t *mem, dns_c_acltable_t **newtable)
 {
 	dns_c_acltable_t *table;
 	
@@ -42,7 +41,7 @@ dns_c_acltable_new(isc_log_t *lctx,
 
 	table = isc_mem_get(mem, sizeof *table);
 	if (table == NULL) {
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Out of memory");
 		return (ISC_R_NOMEMORY);
@@ -60,8 +59,7 @@ dns_c_acltable_new(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_acltable_delete(isc_log_t *lctx,
-		      dns_c_acltable_t **table)
+dns_c_acltable_delete(dns_c_acltable_t **table)
 {
 	dns_c_acltable_t *acltable;
 	isc_mem_t *mem;
@@ -73,7 +71,7 @@ dns_c_acltable_delete(isc_log_t *lctx,
 
 	REQUIRE(DNS_C_CONFACLTABLE_VALID(acltable));
 
-	dns_c_acltable_clear(lctx, acltable);
+	dns_c_acltable_clear(acltable);
 
 	mem = acltable->mem;
 	
@@ -88,8 +86,7 @@ dns_c_acltable_delete(isc_log_t *lctx,
 
 
 void
-dns_c_acltable_print(isc_log_t *lctx,
-		     FILE *fp, int indent, dns_c_acltable_t *table)
+dns_c_acltable_print(FILE *fp, int indent, dns_c_acltable_t *table)
 {
 	dns_c_acl_t *acl;
 	dns_c_acl_t *acltmp;
@@ -108,7 +105,7 @@ dns_c_acltable_print(isc_log_t *lctx,
 		acltmp = ISC_LIST_NEXT(acl, next);
 		
 		if (!acl->is_special) { /* don't print specials */
-			dns_c_acl_print(lctx, fp, indent, acl);
+			dns_c_acl_print(fp, indent, acl);
 			fprintf(fp, "\n");
 		}
 
@@ -118,7 +115,7 @@ dns_c_acltable_print(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_acltable_clear(isc_log_t *lctx, dns_c_acltable_t *table)
+dns_c_acltable_clear(dns_c_acltable_t *table)
 {
 	dns_c_acl_t *elem;
 	dns_c_acl_t *tmpelem;
@@ -131,9 +128,9 @@ dns_c_acltable_clear(isc_log_t *lctx, dns_c_acltable_t *table)
 		tmpelem = ISC_LIST_NEXT(elem, next);
 		ISC_LIST_UNLINK(table->acl_list, elem, next);
 		
-		r = acl_delete(lctx, &elem);
+		r = acl_delete(&elem);
 		if (r != ISC_R_SUCCESS) {
-			isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+			isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 				      DNS_LOGMODULE_CONFIG,
 				      ISC_LOG_CRITICAL,
 				      "Failed to delete acl element.");
@@ -148,7 +145,7 @@ dns_c_acltable_clear(isc_log_t *lctx, dns_c_acltable_t *table)
 
 
 isc_result_t
-dns_c_acltable_getacl(isc_log_t *lctx, dns_c_acltable_t *table,
+dns_c_acltable_getacl(dns_c_acltable_t *table,
 		      const char *aclname, dns_c_acl_t **retval)
 {
 	dns_c_acl_t *elem;
@@ -158,7 +155,6 @@ dns_c_acltable_getacl(isc_log_t *lctx, dns_c_acltable_t *table,
 	REQUIRE(aclname != NULL);
 	REQUIRE(strlen(aclname) > 0);
 
-	(void) lctx;
 
 	elem = ISC_LIST_HEAD(table->acl_list);
 	while (elem != NULL) {
@@ -179,8 +175,7 @@ dns_c_acltable_getacl(isc_log_t *lctx, dns_c_acltable_t *table,
 
 
 isc_result_t
-dns_c_acltable_removeacl(isc_log_t *lctx,
-			 dns_c_acltable_t *table, const char *aclname)
+dns_c_acltable_removeacl(dns_c_acltable_t *table, const char *aclname)
 {
 	dns_c_acl_t *acl;
 	dns_c_acl_t *tmpacl;
@@ -193,7 +188,7 @@ dns_c_acltable_removeacl(isc_log_t *lctx,
 		tmpacl = ISC_LIST_NEXT(acl, next);
 		if (strcmp(aclname, acl->name) == 0) {
 			ISC_LIST_UNLINK(table->acl_list, acl, next);
-			acl_delete(lctx, &acl);
+			acl_delete(&acl);
 			return (ISC_R_SUCCESS);
 		}
 
@@ -205,8 +200,7 @@ dns_c_acltable_removeacl(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_acl_new(isc_log_t *lctx,
-	      dns_c_acltable_t *table, const char *aclname,
+dns_c_acl_new(dns_c_acltable_t *table, const char *aclname,
 	      isc_boolean_t isspecial, dns_c_acl_t **newacl)
 {
 	dns_c_acl_t *acl;
@@ -218,7 +212,7 @@ dns_c_acl_new(isc_log_t *lctx,
 
 	acl = isc_mem_get(table->mem, sizeof *acl);
 	if (acl == NULL) {
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Not enough memory");
 		return (ISC_R_NOMEMORY);
@@ -233,7 +227,7 @@ dns_c_acl_new(isc_log_t *lctx,
 	acl->name = isc_mem_strdup(table->mem, aclname);
 	if (acl->name == NULL) {
 		isc_mem_put(table->mem, acl, sizeof *acl);
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Not enough memory");
 		return (ISC_R_NOMEMORY);
@@ -248,12 +242,11 @@ dns_c_acl_new(isc_log_t *lctx,
 
 
 void
-dns_c_acl_print(isc_log_t *lctx,
-		FILE *fp, int indent, dns_c_acl_t *acl)
+dns_c_acl_print(FILE *fp, int indent, dns_c_acl_t *acl)
 {
 	REQUIRE(DNS_C_CONFACL_VALID(acl));
 	
-	dns_c_printtabs(lctx, fp, indent);
+	dns_c_printtabs(fp, indent);
 	fprintf(fp, "acl ");
 	if (acl->name == NULL) {
 		fprintf(fp, "anon-acl-%p ", acl);
@@ -262,10 +255,10 @@ dns_c_acl_print(isc_log_t *lctx,
 	}
 
 	if (acl->ipml != NULL) {
-		dns_c_ipmatchlist_print(lctx, fp, indent + 1, acl->ipml);
+		dns_c_ipmatchlist_print(fp, indent + 1, acl->ipml);
 	} else {
 		fprintf(fp, "{\n");
-		dns_c_printtabs(lctx, fp, indent);
+		dns_c_printtabs(fp, indent);
 		fprintf(fp, "}");
 	}
 	fprintf(fp, ";\n");
@@ -273,7 +266,7 @@ dns_c_acl_print(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_acl_setipml(isc_log_t *lctx, dns_c_acl_t *acl,
+dns_c_acl_setipml(dns_c_acl_t *acl,
 		  dns_c_ipmatchlist_t *ipml, isc_boolean_t deepcopy)
 {
 	isc_result_t res;
@@ -282,11 +275,11 @@ dns_c_acl_setipml(isc_log_t *lctx, dns_c_acl_t *acl,
 	REQUIRE(ipml != NULL);
 
 	if (acl->ipml != NULL) {
-		dns_c_ipmatchlist_detach(lctx, &acl->ipml);
+		dns_c_ipmatchlist_detach(&acl->ipml);
 	}
 
 	if (deepcopy) {
-		res = dns_c_ipmatchlist_copy(lctx, acl->mytable->mem,
+		res = dns_c_ipmatchlist_copy(acl->mytable->mem,
 					      &acl->ipml, ipml);
 	} else {
 		acl->ipml = ipml;
@@ -298,7 +291,7 @@ dns_c_acl_setipml(isc_log_t *lctx, dns_c_acl_t *acl,
 
 
 isc_result_t
-dns_c_acl_getipmlexpanded(isc_log_t *lctx, isc_mem_t *mem, dns_c_acl_t *acl,
+dns_c_acl_getipmlexpanded(isc_mem_t *mem, dns_c_acl_t *acl,
 			  dns_c_ipmatchlist_t **retval)
 {
 	dns_c_ipmatchlist_t *newlist;
@@ -310,12 +303,12 @@ dns_c_acl_getipmlexpanded(isc_log_t *lctx, isc_mem_t *mem, dns_c_acl_t *acl,
 		newlist = NULL;
 		r = ISC_R_SUCCESS;
 	} else {
-		r = dns_c_ipmatchlist_copy(lctx, mem, &newlist, acl->ipml);
+		r = dns_c_ipmatchlist_copy(mem, &newlist, acl->ipml);
 		if (r != ISC_R_SUCCESS) {
 			return (r);
 		}
 
-		r = dns_c_acl_expandacls(lctx, acl->mytable, newlist);
+		r = dns_c_acl_expandacls(acl->mytable, newlist);
 	}
 
 	*retval = newlist;
@@ -328,7 +321,7 @@ dns_c_acl_getipmlexpanded(isc_log_t *lctx, isc_mem_t *mem, dns_c_acl_t *acl,
 /* XXX this should really be a function in the confip module */
 
 isc_result_t
-dns_c_acl_expandacls(isc_log_t *lctx, dns_c_acltable_t *table,
+dns_c_acl_expandacls(dns_c_acltable_t *table,
 		     dns_c_ipmatchlist_t *list)
 {
 	dns_c_ipmatchelement_t *elem;
@@ -347,24 +340,24 @@ dns_c_acl_expandacls(isc_log_t *lctx, dns_c_acltable_t *table,
 	while (elem != NULL) {
 		switch (elem->type) {
 		case dns_c_ipmatch_indirect:
-			dns_c_acl_expandacls(lctx, table,
+			dns_c_acl_expandacls(table,
 					     elem->u.indirect.list);
 			break;
 
 		case dns_c_ipmatch_acl:
-			r = dns_c_acltable_getacl(lctx, table,
+			r = dns_c_acltable_getacl(table,
 						  elem->u.aclname, &acl);
 			if (r != ISC_R_SUCCESS) {
 				return (ISC_R_FAILURE);
 			}
 
 			if (acl->ipml != NULL) {
-				isneg = dns_c_ipmatchelement_isneg(lctx, elem);
+				isneg = dns_c_ipmatchelement_isneg(elem);
 
 				/* XXX I this should be inserted in place and 
 				 *   not appended
 				 */
-				dns_c_ipmatchlist_append(lctx, list,
+				dns_c_ipmatchlist_append(list,
 							 acl->ipml, isneg);
 			}
 
@@ -389,7 +382,7 @@ dns_c_acl_expandacls(isc_log_t *lctx, dns_c_acltable_t *table,
 
 
 static isc_result_t
-acl_delete(isc_log_t *lctx, dns_c_acl_t **aclptr)
+acl_delete(dns_c_acl_t **aclptr)
 {
 	dns_c_acl_t *acl;
 	isc_result_t res;
@@ -409,7 +402,7 @@ acl_delete(isc_log_t *lctx, dns_c_acl_t **aclptr)
 	isc_mem_free(mem, acl->name);
 
 	if (acl->ipml != NULL)
-		res = dns_c_ipmatchlist_detach(lctx, &acl->ipml);
+		res = dns_c_ipmatchlist_detach(&acl->ipml);
 	else
 		res = ISC_R_SUCCESS;
 	
diff --git a/lib/dns/config/confcache.c b/lib/dns/config/confcache.c
index 323c5496c7..04ba59b77a 100644
--- a/lib/dns/config/confcache.c
+++ b/lib/dns/config/confcache.c
@@ -22,10 +22,10 @@
 #include "confpvt.h"
 
 isc_result_t
-dns_c_cache_new(isc_log_t *lctx, isc_mem_t *mem, dns_c_cache_t **cfgcache)
+dns_c_cache_new(isc_mem_t *mem, dns_c_cache_t **cfgcache)
 {
 
-	(void) lctx; (void) mem ; (void) cfgcache; /* lint */
+	(void) mem ; (void) cfgcache; /* lint */
 
 	/* XXX nothing yet */
 	
@@ -34,9 +34,9 @@ dns_c_cache_new(isc_log_t *lctx, isc_mem_t *mem, dns_c_cache_t **cfgcache)
 
 
 isc_result_t
-dns_c_cache_delete(isc_log_t *lctx, dns_c_cache_t **cfgcache)
+dns_c_cache_delete(dns_c_cache_t **cfgcache)
 {
-	(void) lctx ; (void) cfgcache ;	/* lint */
+	(void) cfgcache ;	/* lint */
 	
 	/* XXX nothin yet */
 
diff --git a/lib/dns/config/confcommon.c b/lib/dns/config/confcommon.c
index 29da98c86d..f87e45b172 100644
--- a/lib/dns/config/confcommon.c
+++ b/lib/dns/config/confcommon.c
@@ -161,14 +161,12 @@ static void default_cfgerror(isc_result_t result, const char *fmt,
 
 
 void
-dns_c_printinunits(isc_log_t *lctx, FILE *fp, isc_uint32_t val)
+dns_c_printinunits(FILE *fp, isc_uint32_t val)
 {
 	isc_uint32_t one_gig = (1024 * 1024 * 1024);
 	isc_uint32_t one_meg = (1024 * 1024);
 	isc_uint32_t one_k = 1024;
 
-	(void) lctx;
-	
 	if (val == DNS_C_SIZE_SPEC_DEFAULT)
 		fprintf(fp, "default");
 	else if ((val % one_gig) == 0)
@@ -185,13 +183,11 @@ dns_c_printinunits(isc_log_t *lctx, FILE *fp, isc_uint32_t val)
 
 
 void
-dns_c_dataclass_tostream(isc_log_t *lctx, FILE *fp, dns_rdataclass_t rclass)
+dns_c_dataclass_tostream(FILE *fp, dns_rdataclass_t rclass)
 {
 	char buffer[64];
 	isc_buffer_t sourceb;
 
-	(void) lctx;
-	
 	isc_buffer_init(&sourceb, buffer, sizeof buffer,
 			ISC_BUFFERTYPE_GENERIC);
 	
@@ -206,13 +202,11 @@ dns_c_dataclass_tostream(isc_log_t *lctx, FILE *fp, dns_rdataclass_t rclass)
 
 
 void
-dns_c_datatype_tostream(isc_log_t *lctx, FILE *fp, dns_rdatatype_t rtype)
+dns_c_datatype_tostream(FILE *fp, dns_rdatatype_t rtype)
 {
 	char buffer[64];
 	isc_buffer_t sourceb;
 
-	(void) lctx;
-	
 	isc_buffer_init(&sourceb, buffer, sizeof buffer,
 			ISC_BUFFERTYPE_GENERIC);
 
@@ -227,11 +221,9 @@ dns_c_datatype_tostream(isc_log_t *lctx, FILE *fp, dns_rdatatype_t rtype)
 
 
 void
-dns_c_printtabs(isc_log_t *lctx, FILE *fp, int count)
+dns_c_printtabs(FILE *fp, int count)
 {
 
-	(void) lctx;
-
 	while (count > 0) {
 		fputc('\t', fp);
 		count--;
@@ -241,13 +233,11 @@ dns_c_printtabs(isc_log_t *lctx, FILE *fp, int count)
 
 
 isc_result_t
-dns_c_string2ordering(isc_log_t *lctx, char *name, dns_c_ordering_t *ordering)
+dns_c_string2ordering(char *name, dns_c_ordering_t *ordering)
 {
 	unsigned int i;
 	isc_result_t rval = ISC_R_FAILURE;
 
-	(void) lctx;
-	
 	for (i = 0 ; i < ordering_nametable_size ; i++) {
 		if (strcmp(ordering_nametable[i].strval, name) == 0) {
 			*ordering = ordering_nametable[i].val;
@@ -261,14 +251,12 @@ dns_c_string2ordering(isc_log_t *lctx, char *name, dns_c_ordering_t *ordering)
 
 
 const char *
-dns_c_ordering2string(isc_log_t *lctx, dns_c_ordering_t ordering,
+dns_c_ordering2string(dns_c_ordering_t ordering,
 		      isc_boolean_t printable)
 {
 	unsigned int i;
 	const char *rval = NULL;
 
-	(void) lctx;
-	
 	for (i = 0 ; i < ordering_nametable_size ; i++) {
 		if (ordering_nametable[i].val == ordering) {
 			rval = ordering_nametable[i].strval;
@@ -281,14 +269,12 @@ dns_c_ordering2string(isc_log_t *lctx, dns_c_ordering_t ordering,
 
 
 const char *
-dns_c_logseverity2string(isc_log_t *lctx, dns_c_logseverity_t severity,
+dns_c_logseverity2string(dns_c_logseverity_t severity,
 			 isc_boolean_t printable)
 {
 	unsigned int i;
 	const char *rval = NULL;
 
-	(void) lctx;
-	
 	for (i = 0 ; i < log_severity_nametable_size ; i++) {
 		if (log_severity_nametable[i].val == severity) {
 			rval = log_severity_nametable[i].strval;
@@ -301,14 +287,12 @@ dns_c_logseverity2string(isc_log_t *lctx, dns_c_logseverity_t severity,
 
 
 isc_result_t
-dns_c_string2logseverity(isc_log_t *lctx, const char *string,
+dns_c_string2logseverity(const char *string,
 			 dns_c_logseverity_t *result)
 {
 	unsigned int i;
 	isc_result_t rval = ISC_R_FAILURE;
 
-	(void) lctx;
-
 	REQUIRE(result != NULL);
 	
 	for (i = 0 ; i < log_severity_nametable_size ; i++) {
@@ -324,14 +308,12 @@ dns_c_string2logseverity(isc_log_t *lctx, const char *string,
 
 
 const char *
-dns_c_category2string(isc_log_t *lctx, dns_c_category_t cat,
+dns_c_category2string(dns_c_category_t cat,
 		      isc_boolean_t printable)
 {
 	unsigned int i;
 	const char *rval = NULL;
 
-	(void) lctx;
-	
 	for (i = 0 ; i < category_nametable_size ; i++) {
 		if (category_nametable[i].val == cat) {
 			rval = category_nametable[i].strval;
@@ -344,14 +326,12 @@ dns_c_category2string(isc_log_t *lctx, dns_c_category_t cat,
 
 
 isc_result_t
-dns_c_string2category(isc_log_t *lctx, const char *string,
+dns_c_string2category(const char *string,
 		      dns_c_category_t *category)
 {
 	unsigned int i;
 	isc_result_t rval = ISC_R_FAILURE;
 
-	(void) lctx;
-	
 	REQUIRE (category != NULL);
 	
 	for (i = 0 ; i < category_nametable_size ; i++) {
@@ -368,13 +348,11 @@ dns_c_string2category(isc_log_t *lctx, const char *string,
 
 
 const char *
-dns_c_facility2string(isc_log_t *lctx, int facility, isc_boolean_t printable)
+dns_c_facility2string(int facility, isc_boolean_t printable)
 {
 	int i;
 	const char *rval = NULL;
 
-	(void) lctx;
-	
 	for (i = 0 ; syslog_facil_nametable[i].strval != NULL ; i++) {
 		if (syslog_facil_nametable[i].val == facility) {
 			rval = syslog_facil_nametable[i].strval;
@@ -387,13 +365,11 @@ dns_c_facility2string(isc_log_t *lctx, int facility, isc_boolean_t printable)
 
 
 isc_result_t
-dns_c_string2facility(isc_log_t *lctx, const char *string, int *result)
+dns_c_string2facility(const char *string, int *result)
 {
 	int i;
 	isc_result_t rval = ISC_R_FAILURE;
 
-	(void) lctx;
-	
 	for (i = 0 ; syslog_facil_nametable[i].strval != NULL ; i++) {
 		if (strcmp(syslog_facil_nametable[i].strval, string) == 0) {
 			*result = syslog_facil_nametable[i].val;
@@ -407,13 +383,11 @@ dns_c_string2facility(isc_log_t *lctx, const char *string, int *result)
 
 
 const char *
-dns_c_transformat2string(isc_log_t *lctx, dns_transfer_format_t tformat,
+dns_c_transformat2string(dns_transfer_format_t tformat,
 			 isc_boolean_t printable)
 {
 	const char *rval = NULL;
 
-	(void) lctx;
-	
 	switch (tformat) {
 	case dns_one_answer:
 		rval = "one-answer";
@@ -431,13 +405,11 @@ dns_c_transformat2string(isc_log_t *lctx, dns_transfer_format_t tformat,
 
 
 const char *
-dns_c_transport2string(isc_log_t *lctx, dns_c_trans_t transport,
+dns_c_transport2string(dns_c_trans_t transport,
 		       isc_boolean_t printable)
 {
 	const char *rval = NULL;
 
-	(void) lctx;
-	
 	switch (transport) {
 	case dns_trans_primary:
 		rval = "master";
@@ -457,13 +429,11 @@ dns_c_transport2string(isc_log_t *lctx, dns_c_trans_t transport,
 
 
 const char *
-dns_c_nameseverity2string(isc_log_t *lctx, dns_c_severity_t severity,
+dns_c_nameseverity2string(dns_c_severity_t severity,
 			  isc_boolean_t printable)
 {
 	const char *rval = NULL;
 
-	(void) lctx;
-	
 	switch (severity) {
 	case dns_c_severity_ignore:
 		rval = "ignore";
@@ -483,13 +453,11 @@ dns_c_nameseverity2string(isc_log_t *lctx, dns_c_severity_t severity,
 
 
 const char *
-dns_c_forward2string(isc_log_t *lctx, dns_c_forw_t forw,
+dns_c_forward2string(dns_c_forw_t forw,
 		     isc_boolean_t printable)
 {
 	const char *rval = NULL;
 
-	(void) lctx;
-	
 	switch (forw) {
 	case dns_c_forw_only:
 		rval = "only";
@@ -514,12 +482,10 @@ dns_c_forward2string(isc_log_t *lctx, dns_c_forw_t forw,
 
 
 int
-dns_c_isanyaddr(isc_log_t *lctx, isc_sockaddr_t *inaddr)
+dns_c_isanyaddr(isc_sockaddr_t *inaddr)
 {
 	int result = 0;
 
-	(void) lctx;
-	
 	if (inaddr->type.sa.sa_family == AF_INET) {
 		if (inaddr->type.sin.sin_addr.s_addr == htonl(INADDR_ANY)) {
 			result = 1;
@@ -537,14 +503,14 @@ dns_c_isanyaddr(isc_log_t *lctx, isc_sockaddr_t *inaddr)
 
 	
 void
-dns_c_print_ipaddr(isc_log_t *lctx, FILE *fp, isc_sockaddr_t *inaddr)
+dns_c_print_ipaddr(FILE *fp, isc_sockaddr_t *inaddr)
 {
 	const char *p;
 	char tmpaddrstr[64];
 	int family = inaddr->type.sa.sa_family;
 	void *addr;
 
-	if (dns_c_isanyaddr(lctx, inaddr)) {
+	if (dns_c_isanyaddr(inaddr)) {
 		if (family == AF_INET) {
 			fprintf(fp, "*");
 		} else {
@@ -566,12 +532,10 @@ dns_c_print_ipaddr(isc_log_t *lctx, FILE *fp, isc_sockaddr_t *inaddr)
 
 
 isc_boolean_t
-dns_c_need_quote(isc_log_t *lctx, const char *string)
+dns_c_need_quote(const char *string)
 {
 	isc_boolean_t rval = ISC_FALSE;
 
-	(void) lctx;
-	
 	while (string != NULL && *string != '\0') {
 		if (!(isalnum(*string & 0xff) || *string == '_')) {
 			rval = ISC_TRUE;
diff --git a/lib/dns/config/confctl.c b/lib/dns/config/confctl.c
index 7c29dbcd9a..ce3a4ac7f0 100644
--- a/lib/dns/config/confctl.c
+++ b/lib/dns/config/confctl.c
@@ -28,16 +28,13 @@
 
 
 isc_result_t
-dns_c_ctrllist_new(isc_log_t *lctx,
-		   isc_mem_t *mem, dns_c_ctrllist_t **newlist)
+dns_c_ctrllist_new(isc_mem_t *mem, dns_c_ctrllist_t **newlist)
 {
 	dns_c_ctrllist_t *newl;
 	
 	REQUIRE(mem != NULL);
 	REQUIRE (newlist != NULL);
 
-	(void) lctx;
-	
 	newl = isc_mem_get(mem, sizeof *newl);
 	if (newl == NULL) {
 		/* XXXJAB logwrite */
@@ -57,8 +54,7 @@ dns_c_ctrllist_new(isc_log_t *lctx,
 		
 	
 void
-dns_c_ctrllist_print(isc_log_t *lctx,
-		     FILE *fp, int indent, dns_c_ctrllist_t *cl)
+dns_c_ctrllist_print(FILE *fp, int indent, dns_c_ctrllist_t *cl)
 {
 	dns_c_ctrl_t *ctl;
 
@@ -75,8 +71,8 @@ dns_c_ctrllist_print(isc_log_t *lctx,
 	fprintf(fp, "controls {\n");
 	ctl = ISC_LIST_HEAD(cl->elements);
 	while (ctl != NULL) {
-		dns_c_printtabs(lctx, fp, indent + 1);
-		dns_c_ctrl_print(lctx, fp, indent + 1, ctl);
+		dns_c_printtabs(fp, indent + 1);
+		dns_c_ctrl_print(fp, indent + 1, ctl);
 		ctl = ISC_LIST_NEXT(ctl, next);
 	}
 	fprintf(fp, "};\n");
@@ -85,8 +81,7 @@ dns_c_ctrllist_print(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctrllist_delete(isc_log_t *lctx,
-		      dns_c_ctrllist_t **list)
+dns_c_ctrllist_delete(dns_c_ctrllist_t **list)
 {
 	dns_c_ctrl_t	       *ctrl;
 	dns_c_ctrl_t	       *tmpctrl;
@@ -102,7 +97,7 @@ dns_c_ctrllist_delete(isc_log_t *lctx,
 	ctrl = ISC_LIST_HEAD(clist->elements);
 	while (ctrl != NULL) {
 		tmpctrl = ISC_LIST_NEXT(ctrl, next);
-		dns_c_ctrl_delete(lctx, &ctrl);
+		dns_c_ctrl_delete(&ctrl);
 		ctrl = tmpctrl;
 	}
 
@@ -115,7 +110,7 @@ dns_c_ctrllist_delete(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctrlinet_new(isc_log_t *lctx, isc_mem_t *mem, dns_c_ctrl_t **control,
+dns_c_ctrlinet_new(isc_mem_t *mem, dns_c_ctrl_t **control,
 		   isc_sockaddr_t addr, short port,
 		   dns_c_ipmatchlist_t *iml, isc_boolean_t copy)
 {
@@ -137,7 +132,7 @@ dns_c_ctrlinet_new(isc_log_t *lctx, isc_mem_t *mem, dns_c_ctrl_t **control,
 	ctrl->u.inet_v.port = port;
 
 	if (copy) {
-		res = dns_c_ipmatchlist_copy(lctx, mem,
+		res = dns_c_ipmatchlist_copy(mem,
 					     &ctrl->u.inet_v.matchlist, iml);
 		if (res != ISC_R_SUCCESS) {
 			isc_mem_put(mem, ctrl, sizeof *ctrl);
@@ -154,8 +149,7 @@ dns_c_ctrlinet_new(isc_log_t *lctx, isc_mem_t *mem, dns_c_ctrl_t **control,
 
 
 isc_result_t
-dns_c_ctrlunix_new(isc_log_t *lctx,
-		   isc_mem_t *mem, dns_c_ctrl_t **control,
+dns_c_ctrlunix_new(isc_mem_t *mem, dns_c_ctrl_t **control,
 		   const char *path, int perm, uid_t uid, gid_t gid)
 {
 	dns_c_ctrl_t  *ctrl;
@@ -163,8 +157,6 @@ dns_c_ctrlunix_new(isc_log_t *lctx,
 	REQUIRE(mem != NULL);
 	REQUIRE(control != NULL);
 
-	(void) lctx;
-
 	ctrl = isc_mem_get(mem, sizeof *ctrl);
 	if (ctrl == NULL) {
 		return (ISC_R_NOMEMORY);
@@ -191,8 +183,7 @@ dns_c_ctrlunix_new(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctrl_delete(isc_log_t *lctx,
-		  dns_c_ctrl_t **control)
+dns_c_ctrl_delete(dns_c_ctrl_t **control)
 {
 	isc_result_t res = ISC_R_SUCCESS;
 	isc_result_t rval;
@@ -211,8 +202,7 @@ dns_c_ctrl_delete(isc_log_t *lctx,
 	switch (ctrl->control_type) {
 	case dns_c_inet_control:
 		if (ctrl->u.inet_v.matchlist != NULL)
-			res = dns_c_ipmatchlist_detach(lctx,
-						   &ctrl->u.inet_v.matchlist);
+			res = dns_c_ipmatchlist_detach(&ctrl->u.inet_v.matchlist);
 		else
 			res = ISC_R_SUCCESS;
 		break;
@@ -236,8 +226,7 @@ dns_c_ctrl_delete(isc_log_t *lctx,
 
 
 void
-dns_c_ctrl_print(isc_log_t *lctx,
-		 FILE *fp, int indent, dns_c_ctrl_t *ctl)
+dns_c_ctrl_print(FILE *fp, int indent, dns_c_ctrl_t *ctl)
 {
 	short port;
 	dns_c_ipmatchlist_t *iml;
@@ -251,7 +240,7 @@ dns_c_ctrl_print(isc_log_t *lctx,
 		iml = ctl->u.inet_v.matchlist;
 		
 		fprintf(fp, "inet ");
-		dns_c_print_ipaddr(lctx, fp,  &ctl->u.inet_v.addr);
+		dns_c_print_ipaddr(fp,  &ctl->u.inet_v.addr);
 		
 		if (port == 0) {
 			fprintf(fp, " port *\n");
@@ -259,9 +248,9 @@ dns_c_ctrl_print(isc_log_t *lctx,
 			fprintf(fp, " port %d\n", port);
 		}
 		
-		dns_c_printtabs(lctx, fp, indent + 1);
+		dns_c_printtabs(fp, indent + 1);
 		fprintf(fp, "allow ");
-		dns_c_ipmatchlist_print(lctx, fp, indent + 2, iml);
+		dns_c_ipmatchlist_print(fp, indent + 2, iml);
 		fprintf(fp, ";\n");
 	} else {
 		/* The "#" means force a leading zero */
diff --git a/lib/dns/config/confctx.c b/lib/dns/config/confctx.c
index 03bdc87ca9..ee44451a7f 100644
--- a/lib/dns/config/confctx.c
+++ b/lib/dns/config/confctx.c
@@ -73,55 +73,54 @@
 #define RFC2308_TYPE1_BIT		35
 
 
-static isc_result_t cfg_set_iplist(isc_log_t *lctx, dns_c_options_t *options,
+static isc_result_t cfg_set_iplist(dns_c_options_t *options,
 				   dns_c_ipmatchlist_t **fieldaddr,
 				   dns_c_ipmatchlist_t *newval,
 				   isc_boolean_t copy);
-static isc_result_t cfg_set_boolean(isc_log_t *lctx, dns_c_options_t *options,
+static isc_result_t cfg_set_boolean(dns_c_options_t *options,
 				    isc_boolean_t *fieldaddr,
 				    isc_boolean_t newval,
 				    dns_c_setbits_t *setfield,
 				    isc_uint32_t bitnumber);
-static isc_result_t cfg_set_int32(isc_log_t *lctx, dns_c_options_t *options,
+static isc_result_t cfg_set_int32(dns_c_options_t *options,
 				  isc_int32_t *fieldaddr,
 				  isc_int32_t newval,
 				  dns_c_setbits_t *setfield,
 				  isc_uint32_t bitnumber);
-static isc_result_t cfg_set_uint32(isc_log_t *lctx, dns_c_options_t *options,
+static isc_result_t cfg_set_uint32(dns_c_options_t *options,
 				   isc_uint32_t *fieldaddr,
 				   isc_uint32_t newval,
 				   dns_c_setbits_t *setfield,
 				   isc_uint32_t bitnumber);
-static isc_result_t cfg_set_string(isc_log_t *lctx, dns_c_options_t *options,
+static isc_result_t cfg_set_string(dns_c_options_t *options,
 				   char **field,
 				   const char *newval);
 
-static isc_result_t cfg_get_uint32(isc_log_t *lctx, dns_c_options_t *options,
+static isc_result_t cfg_get_uint32(dns_c_options_t *options,
 				   isc_uint32_t *field,
 				   isc_uint32_t *result,
 				   dns_c_setbits_t *setfield,
 				   isc_uint32_t bitnumber);
-static isc_result_t cfg_get_int32(isc_log_t *lctx, dns_c_options_t *options,
+static isc_result_t cfg_get_int32(dns_c_options_t *options,
 				  isc_int32_t *field,
 				  isc_int32_t *result,
 				  dns_c_setbits_t *setfield,
 				  isc_uint32_t bitnumber);
-static isc_result_t cfg_get_boolean(isc_log_t *lctx, dns_c_options_t *options,
+static isc_result_t cfg_get_boolean(dns_c_options_t *options,
 				    isc_boolean_t *field,
 				    isc_boolean_t *result,
 				    dns_c_setbits_t *setfield,
 				    isc_uint32_t bitnumber);
-static isc_result_t cfg_get_iplist(isc_log_t *lctx, dns_c_options_t *options,
+static isc_result_t cfg_get_iplist(dns_c_options_t *options,
 				   dns_c_ipmatchlist_t *field,
 				   dns_c_ipmatchlist_t **resval);
-static isc_result_t acl_init(isc_log_t *lctx, dns_c_ctx_t *cfg);
-static isc_result_t logging_init (isc_log_t *lctx, dns_c_ctx_t *cfg);
-static isc_result_t  make_options(isc_log_t *lctx, dns_c_ctx_t *cfg);
+static isc_result_t acl_init(dns_c_ctx_t *cfg);
+static isc_result_t logging_init (dns_c_ctx_t *cfg);
+static isc_result_t  make_options(dns_c_ctx_t *cfg);
 
 
 isc_result_t
-dns_c_ctx_new(isc_log_t *lctx,
-	      isc_mem_t *mem, dns_c_ctx_t **ctx)
+dns_c_ctx_new(isc_mem_t *mem, dns_c_ctx_t **ctx)
 {
 	dns_c_ctx_t *cfg;
 	isc_result_t r;
@@ -152,20 +151,20 @@ dns_c_ctx_new(isc_log_t *lctx,
 	cfg->currview = NULL;
 	cfg->currzone = NULL;
 	
-	r = acl_init(lctx, cfg);
+	r = acl_init(cfg);
 	if (r != ISC_R_SUCCESS) {
 		return (r);
 	}
 
-	r = logging_init(lctx, cfg);
+	r = logging_init(cfg);
 	if (r != ISC_R_SUCCESS) {
 		return (r);
 	}
 	
 	
-	r = dns_c_ctrllist_new(lctx, mem, &cfg->controls);
+	r = dns_c_ctrllist_new(mem, &cfg->controls);
 	if (r != ISC_R_SUCCESS) {
-		dns_c_ctx_delete(lctx, &cfg);
+		dns_c_ctx_delete(&cfg);
 		return r;
 	}
 
@@ -176,8 +175,7 @@ dns_c_ctx_new(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_delete(isc_log_t *lctx,
-		 dns_c_ctx_t **cfg)
+dns_c_ctx_delete(dns_c_ctx_t **cfg)
 {
 	dns_c_ctx_t *c;
 
@@ -190,31 +188,31 @@ dns_c_ctx_delete(isc_log_t *lctx,
 	REQUIRE(c->mem != NULL);
 
 	if (c->options != NULL)
-		dns_c_ctx_optionsdelete(lctx, &c->options);
+		dns_c_ctx_optionsdelete(&c->options);
 	
 	if (c->controls != NULL)
-		dns_c_ctrllist_delete(lctx, &c->controls);
+		dns_c_ctrllist_delete(&c->controls);
 	
 	if (c->servers != NULL)
-		dns_c_srvlist_delete(lctx, &c->servers);
+		dns_c_srvlist_delete(&c->servers);
 	
 	if (c->acls != NULL)
-		dns_c_acltable_delete(lctx, &c->acls);
+		dns_c_acltable_delete(&c->acls);
 	
 	if (c->keydefs != NULL)
-		dns_c_kdeflist_delete(lctx, &c->keydefs);
+		dns_c_kdeflist_delete(&c->keydefs);
 	
 	if (c->zlist != NULL)
-		dns_c_zonelist_delete(lctx, &c->zlist);
+		dns_c_zonelist_delete(&c->zlist);
 	
 	if (c->trusted_keys != NULL)
-		dns_c_tkeylist_delete(lctx, &c->trusted_keys);
+		dns_c_tkeylist_delete(&c->trusted_keys);
 	
 	if (c->logging != NULL)
-		dns_c_logginglist_delete(lctx, &c->logging);
+		dns_c_logginglist_delete(&c->logging);
 	
 	if (c->views != NULL)
-		dns_c_viewtable_delete(lctx, &c->views);
+		dns_c_viewtable_delete(&c->views);
 	
 	isc_mem_put(c->mem, c, sizeof *c);
 	*cfg = NULL;
@@ -224,11 +222,9 @@ dns_c_ctx_delete(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_setcurrzone(isc_log_t *lctx, dns_c_ctx_t *cfg,
+dns_c_ctx_setcurrzone(dns_c_ctx_t *cfg,
 		      dns_c_zone_t *zone)
 {
-	(void) lctx;
-
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
 	cfg->currzone = zone;		/* zone may be NULL */
@@ -241,10 +237,8 @@ dns_c_ctx_setcurrzone(isc_log_t *lctx, dns_c_ctx_t *cfg,
 
 
 dns_c_zone_t *
-dns_c_ctx_getcurrzone(isc_log_t *lctx, dns_c_ctx_t *cfg)
+dns_c_ctx_getcurrzone(dns_c_ctx_t *cfg)
 {
-	(void) lctx;
-
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
 	return (cfg->currzone);
@@ -253,11 +247,9 @@ dns_c_ctx_getcurrzone(isc_log_t *lctx, dns_c_ctx_t *cfg)
 	
 
 isc_result_t
-dns_c_ctx_setcurrview(isc_log_t *lctx, dns_c_ctx_t *cfg,
+dns_c_ctx_setcurrview(dns_c_ctx_t *cfg,
 		      dns_c_view_t *view)
 {
-	(void) lctx;
-
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
 	cfg->currview = view;
@@ -270,10 +262,8 @@ dns_c_ctx_setcurrview(isc_log_t *lctx, dns_c_ctx_t *cfg,
 
 
 dns_c_view_t *
-dns_c_ctx_getcurrview(isc_log_t *lctx, dns_c_ctx_t *cfg)
+dns_c_ctx_getcurrview(dns_c_ctx_t *cfg)
 {
-	(void) lctx;
-
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
 	return (cfg->currview);
@@ -282,76 +272,74 @@ dns_c_ctx_getcurrview(isc_log_t *lctx, dns_c_ctx_t *cfg)
 	
 
 void
-dns_c_ctx_print(isc_log_t *lctx,
-		FILE *fp, int indent, dns_c_ctx_t *cfg)
+dns_c_ctx_print(FILE *fp, int indent, dns_c_ctx_t *cfg)
 {
 	REQUIRE(fp != NULL);
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
 	if (cfg->logging != NULL) {
-		dns_c_logginglist_print(lctx, fp, indent,
+		dns_c_logginglist_print(fp, indent,
 					cfg->logging, ISC_FALSE);
 		fprintf(fp,"\n");
 	}
 	
 	
 	if (cfg->keydefs != NULL) {
-		dns_c_kdeflist_print(lctx, fp, indent, cfg->keydefs);
+		dns_c_kdeflist_print(fp, indent, cfg->keydefs);
 		fprintf(fp, "\n");
 	}
 	
 
 	if (cfg->trusted_keys != NULL) {
-		dns_c_tkeylist_print(lctx, fp, indent, cfg->trusted_keys);
+		dns_c_tkeylist_print(fp, indent, cfg->trusted_keys);
 		fprintf(fp, "\n");
 	}
 	
 
 	if (cfg->acls != NULL) {
-		dns_c_acltable_print(lctx, fp, indent, cfg->acls);
+		dns_c_acltable_print(fp, indent, cfg->acls);
 		fprintf(fp,"\n");
 	}
 	
 
 	if (cfg->zlist != NULL) {
-		dns_c_zonelist_printpreopts(lctx, fp, indent, cfg->zlist);
+		dns_c_zonelist_printpreopts(fp, indent, cfg->zlist);
 		fprintf(fp, "\n");
 	}
 	
 	
 	if (cfg->options != NULL) {
-		dns_c_ctx_optionsprint(lctx, fp, indent, cfg->options);
+		dns_c_ctx_optionsprint(fp, indent, cfg->options);
 		fprintf(fp,"\n");
 	}
 	
 
 	if (cfg->zlist != NULL) {
-		dns_c_zonelist_printpostopts(lctx, fp, indent, cfg->zlist);
+		dns_c_zonelist_printpostopts(fp, indent, cfg->zlist);
 		fprintf(fp, "\n");
 	}
 
 	if (cfg->views != NULL) {
-		dns_c_viewtable_print(lctx, fp, indent, cfg->views);
+		dns_c_viewtable_print(fp, indent, cfg->views);
 		fprintf(fp, "\n");
 	}
 	
 	
 	if (cfg->controls != NULL) {
-		dns_c_ctrllist_print(lctx, fp, indent, cfg->controls);
+		dns_c_ctrllist_print(fp, indent, cfg->controls);
 		fprintf(fp, "\n");
 	}
 	
 
 	if (cfg->servers != NULL) {
-		dns_c_srvlist_print(lctx, fp, indent, cfg->servers);
+		dns_c_srvlist_print(fp, indent, cfg->servers);
 		fprintf(fp, "\n");
 	}
 }
 
 
 void
-dns_c_ctx_forwarderprint(isc_log_t *lctx,
-			 FILE *fp, int indent, dns_c_options_t *options)
+dns_c_ctx_forwarderprint(FILE *fp, int indent, dns_c_options_t *options)
 {
 	REQUIRE(fp != NULL);
 	REQUIRE(indent >= 0);
@@ -363,16 +351,15 @@ dns_c_ctx_forwarderprint(isc_log_t *lctx,
 	REQUIRE(DNS_C_CONFOPT_VALID(options));
 
 	if (DNS_C_CHECKBIT(FORWARD_BIT, &options->setflags1)) {
-		dns_c_printtabs(lctx, fp, indent);
+		dns_c_printtabs(fp, indent);
 		fprintf(fp, "forward %s;\n",
-			dns_c_forward2string(lctx,
-					     options->forward, ISC_TRUE));
+			dns_c_forward2string(options->forward, ISC_TRUE));
 	}
 
 	if (options->forwarders != NULL) {
-		dns_c_printtabs(lctx, fp, indent);
+		dns_c_printtabs(fp, indent);
 		fprintf(fp, "forwarders ");
-		dns_c_ipmatchlist_print(lctx, fp, indent + 1,
+		dns_c_ipmatchlist_print(fp, indent + 1,
 					options->forwarders);
 		fprintf(fp, ";\n");
 	}
@@ -380,11 +367,8 @@ dns_c_ctx_forwarderprint(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_getoptions(isc_log_t *lctx,
-		     dns_c_ctx_t *cfg, dns_c_options_t **options)
+dns_c_ctx_getoptions(dns_c_ctx_t *cfg, dns_c_options_t **options)
 {
-	(void) lctx;
-	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 	REQUIRE(options != NULL);
 	
@@ -400,11 +384,8 @@ dns_c_ctx_getoptions(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_getlogging(isc_log_t *lctx,
-		     dns_c_ctx_t *cfg, dns_c_logginglist_t **retval)
+dns_c_ctx_getlogging(dns_c_ctx_t *cfg, dns_c_logginglist_t **retval)
 {
-	(void) lctx;
-	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
 	*retval = cfg->logging;
@@ -414,8 +395,7 @@ dns_c_ctx_getlogging(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_setlogging(isc_log_t *lctx,
-		     dns_c_ctx_t *cfg, dns_c_logginglist_t *newval,
+dns_c_ctx_setlogging(dns_c_ctx_t *cfg, dns_c_logginglist_t *newval,
 		     isc_boolean_t deepcopy)
 {
 	dns_c_logginglist_t *ll;
@@ -427,7 +407,7 @@ dns_c_ctx_setlogging(isc_log_t *lctx,
 	existed = ISC_TF(cfg->logging != NULL);
 	
 	if (deepcopy) {
-		res = dns_c_logginglist_copy(lctx, cfg->mem, &ll, newval);
+		res = dns_c_logginglist_copy(cfg->mem, &ll, newval);
 		if (res != ISC_R_SUCCESS) {
 			return (res);
 		}
@@ -442,11 +422,9 @@ dns_c_ctx_setlogging(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_getkdeflist(isc_log_t *lctx, dns_c_ctx_t *cfg,
+dns_c_ctx_getkdeflist(dns_c_ctx_t *cfg,
                       dns_c_kdeflist_t **retval)
 {
-	(void)(lctx);
-
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
         REQUIRE(retval != NULL);
 
@@ -461,7 +439,7 @@ dns_c_ctx_getkdeflist(isc_log_t *lctx, dns_c_ctx_t *cfg,
 
 
 isc_result_t
-dns_c_ctx_setkdeflist(isc_log_t *lctx, dns_c_ctx_t *cfg,
+dns_c_ctx_setkdeflist(dns_c_ctx_t *cfg,
 		      dns_c_kdeflist_t *newval, isc_boolean_t deepcopy)
 {
 	isc_result_t res;
@@ -469,14 +447,14 @@ dns_c_ctx_setkdeflist(isc_log_t *lctx, dns_c_ctx_t *cfg,
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
 	if (cfg->keydefs != NULL) {
-		dns_c_kdeflist_delete(lctx, &cfg->keydefs);
+		dns_c_kdeflist_delete(&cfg->keydefs);
 	}
 	
 	if (newval == NULL) {
 		cfg->keydefs = NULL;
 		res = ISC_R_SUCCESS;
 	} else if (deepcopy) {
-		res = dns_c_kdeflist_copy(lctx, cfg->mem,
+		res = dns_c_kdeflist_copy(cfg->mem,
 					  &cfg->keydefs, newval);
 	} else {
 		cfg->keydefs = newval;
@@ -488,8 +466,7 @@ dns_c_ctx_setkdeflist(isc_log_t *lctx, dns_c_ctx_t *cfg,
 
 	
 isc_result_t
-dns_c_ctx_addfile_channel(isc_log_t *lctx,
-			  dns_c_ctx_t *cfg, const char *name,
+dns_c_ctx_addfile_channel(dns_c_ctx_t *cfg, const char *name,
 			  dns_c_logchan_t **chan)
 {
 	dns_c_logchan_t *newc;
@@ -500,13 +477,13 @@ dns_c_ctx_addfile_channel(isc_log_t *lctx,
 	REQUIRE(chan != NULL);
 	REQUIRE(cfg->logging != NULL);
 
-	res = dns_c_logchan_new(lctx, cfg->mem, name, dns_c_logchan_file,
+	res = dns_c_logchan_new(cfg->mem, name, dns_c_logchan_file,
 				&newc);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
 
-	res = dns_c_logginglist_addchannel(lctx, cfg->logging, newc,
+	res = dns_c_logginglist_addchannel(cfg->logging, newc,
 					   ISC_FALSE);
 
 	*chan = newc;
@@ -516,8 +493,7 @@ dns_c_ctx_addfile_channel(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_addsyslogchannel(isc_log_t *lctx,
-			   dns_c_ctx_t *cfg, const char *name,
+dns_c_ctx_addsyslogchannel(dns_c_ctx_t *cfg, const char *name,
 			   dns_c_logchan_t **chan)
 {
 	dns_c_logchan_t *newc;
@@ -528,13 +504,13 @@ dns_c_ctx_addsyslogchannel(isc_log_t *lctx,
 	REQUIRE(chan != NULL);
 	REQUIRE(cfg->logging != NULL);
 
-	res = dns_c_logchan_new(lctx, cfg->mem, name,
+	res = dns_c_logchan_new(cfg->mem, name,
 				dns_c_logchan_syslog, &newc);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
 
-	res = dns_c_logginglist_addchannel(lctx, cfg->logging, newc,
+	res = dns_c_logginglist_addchannel(cfg->logging, newc,
 					   ISC_FALSE);
 
 	*chan = newc;
@@ -544,8 +520,7 @@ dns_c_ctx_addsyslogchannel(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_addnullchannel(isc_log_t *lctx,
-			 dns_c_ctx_t *cfg, const char *name,
+dns_c_ctx_addnullchannel(dns_c_ctx_t *cfg, const char *name,
 			 dns_c_logchan_t **chan)
 {
 	dns_c_logchan_t *newc;
@@ -556,13 +531,13 @@ dns_c_ctx_addnullchannel(isc_log_t *lctx,
 	REQUIRE(chan != NULL);
 	REQUIRE(cfg->logging != NULL);
 
-	res = dns_c_logchan_new(lctx, cfg->mem, name, dns_c_logchan_null,
+	res = dns_c_logchan_new(cfg->mem, name, dns_c_logchan_null,
 				&newc);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
 
-	res = dns_c_logginglist_addchannel(lctx, cfg->logging, newc,
+	res = dns_c_logginglist_addchannel(cfg->logging, newc,
 					   ISC_FALSE);
 
 	*chan = newc;
@@ -572,8 +547,7 @@ dns_c_ctx_addnullchannel(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_addcategory(isc_log_t *lctx,
-		      dns_c_ctx_t *cfg, dns_c_category_t category,
+dns_c_ctx_addcategory(dns_c_ctx_t *cfg, dns_c_category_t category,
 		      dns_c_logcat_t **newcat)
 {
 	dns_c_logcat_t *newc;
@@ -583,12 +557,12 @@ dns_c_ctx_addcategory(isc_log_t *lctx,
 	REQUIRE(newcat != NULL);
 	REQUIRE(cfg->logging != NULL);
 
-	res = dns_c_logcat_new(lctx, cfg->mem, category, &newc);
+	res = dns_c_logcat_new(cfg->mem, category, &newc);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
 	
-	res = dns_c_logginglist_addcategory(lctx, cfg->logging, newc,
+	res = dns_c_logginglist_addcategory(cfg->logging, newc,
 					    ISC_FALSE);
 
 	*newcat = newc;
@@ -598,13 +572,10 @@ dns_c_ctx_addcategory(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_currchannel(isc_log_t *lctx,
-		      dns_c_ctx_t *cfg, dns_c_logchan_t **channel)
+dns_c_ctx_currchannel(dns_c_ctx_t *cfg, dns_c_logchan_t **channel)
 {
 	dns_c_logchan_t *newc;
 
-	(void)lctx;
-
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 	REQUIRE(channel != NULL);
 	REQUIRE(cfg->logging != NULL);
@@ -618,8 +589,7 @@ dns_c_ctx_currchannel(isc_log_t *lctx,
 
 
 isc_boolean_t
-dns_c_ctx_channeldefinedp(isc_log_t *lctx,
-			  dns_c_ctx_t *cfg, const char *name)
+dns_c_ctx_channeldefinedp(dns_c_ctx_t *cfg, const char *name)
 {
 	isc_result_t res;
 	dns_c_logchan_t *chan;
@@ -628,7 +598,7 @@ dns_c_ctx_channeldefinedp(isc_log_t *lctx,
 	REQUIRE(name != NULL);
 	REQUIRE(strlen(name) > 0);
 
-	res = dns_c_logginglist_chanbyname(lctx, cfg->logging, name, &chan);
+	res = dns_c_logginglist_chanbyname(cfg->logging, name, &chan);
 
 	return (ISC_TF(res == ISC_R_SUCCESS));
 }
@@ -636,8 +606,7 @@ dns_c_ctx_channeldefinedp(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_currcategory(isc_log_t *lctx,
-		       dns_c_ctx_t *cfg, dns_c_logcat_t **category)
+dns_c_ctx_currcategory(dns_c_ctx_t *cfg, dns_c_logcat_t **category)
 {
 	dns_c_logcat_t *newc;
 	dns_c_logginglist_t *llist;
@@ -646,7 +615,7 @@ dns_c_ctx_currcategory(isc_log_t *lctx,
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 	REQUIRE(category != NULL);
 
-	res = dns_c_ctx_getlogging(lctx, cfg, &llist);
+	res = dns_c_ctx_getlogging(cfg, &llist);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
@@ -666,191 +635,182 @@ dns_c_ctx_currcategory(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_setdirectory(isc_log_t *lctx,
-		       dns_c_ctx_t *cfg, const char *newval)
+dns_c_ctx_setdirectory(dns_c_ctx_t *cfg, const char *newval)
 {
 	isc_result_t res;
 	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
-	res = make_options(lctx, cfg);
+	res = make_options(cfg);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
 	
-	return (cfg_set_string(lctx, cfg->options,
+	return (cfg_set_string(cfg->options,
 			       &cfg->options->directory,
 			       newval));
 }
 
 
 isc_result_t
-dns_c_ctx_setversion(isc_log_t *lctx,
-		     dns_c_ctx_t *cfg, const char *newval)
+dns_c_ctx_setversion(dns_c_ctx_t *cfg, const char *newval)
 {
 	isc_result_t res;
 	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
-	res = make_options(lctx, cfg);
+	res = make_options(cfg);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
 	
-	return (cfg_set_string(lctx, cfg->options,
+	return (cfg_set_string(cfg->options,
 			       &cfg->options->version,
 			       newval));
 }
 
 
 isc_result_t
-dns_c_ctx_setdumpfilename(isc_log_t *lctx,
-			  dns_c_ctx_t *cfg, const char *newval)
+dns_c_ctx_setdumpfilename(dns_c_ctx_t *cfg, const char *newval)
 {
 	isc_result_t res;
 	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
-	res = make_options(lctx, cfg);
+	res = make_options(cfg);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
 	
-	return (cfg_set_string(lctx, cfg->options,
+	return (cfg_set_string(cfg->options,
 			       &cfg->options->dump_filename,
 			       newval));
 }
 
 
 isc_result_t
-dns_c_ctx_setpidfilename(isc_log_t *lctx,
-			 dns_c_ctx_t *cfg, const char *newval)
+dns_c_ctx_setpidfilename(dns_c_ctx_t *cfg, const char *newval)
 {
 	isc_result_t res;
 	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
-	res = make_options(lctx, cfg);
+	res = make_options(cfg);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
 	
-	return (cfg_set_string(lctx, cfg->options,
+	return (cfg_set_string(cfg->options,
 			       &cfg->options->pid_filename,
 			       newval));
 }
 
 
 isc_result_t
-dns_c_ctx_setstatsfilename(isc_log_t *lctx,
-			   dns_c_ctx_t *cfg, const char *newval)
+dns_c_ctx_setstatsfilename(dns_c_ctx_t *cfg, const char *newval)
 {
 	isc_result_t res;
 	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
-	res = make_options(lctx, cfg);
+	res = make_options(cfg);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
 	
-	return (cfg_set_string(lctx, cfg->options,
+	return (cfg_set_string(cfg->options,
 			       &cfg->options->stats_filename,
 			       newval));
 }
 
 
 isc_result_t
-dns_c_ctx_setmemstatsfilename(isc_log_t *lctx,
-			      dns_c_ctx_t *cfg, const char *newval)
+dns_c_ctx_setmemstatsfilename(dns_c_ctx_t *cfg, const char *newval)
 {
 	isc_result_t res;
 	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
-	res = make_options(lctx, cfg);
+	res = make_options(cfg);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
 	
-	return (cfg_set_string(lctx, cfg->options,
+	return (cfg_set_string(cfg->options,
 			       &cfg->options->memstats_filename,
 			       newval));
 }
 
 
 isc_result_t
-dns_c_ctx_setnamedxfer(isc_log_t *lctx,
-		       dns_c_ctx_t *cfg, const char *newval)
+dns_c_ctx_setnamedxfer(dns_c_ctx_t *cfg, const char *newval)
 {
 	isc_result_t res;
 	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
-	res = make_options(lctx, cfg);
+	res = make_options(cfg);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
 	
-	return (cfg_set_string(lctx, cfg->options,
+	return (cfg_set_string(cfg->options,
 			       &cfg->options->named_xfer,
 			       newval));
 }
 
 
 isc_result_t
-dns_c_ctx_settkeydomain(isc_log_t *lctx,
-			dns_c_ctx_t *cfg, const char *newval)
+dns_c_ctx_settkeydomain(dns_c_ctx_t *cfg, const char *newval)
 {
 	isc_result_t res;
 	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
-	res = make_options(lctx, cfg);
+	res = make_options(cfg);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
 	
-	return (cfg_set_string(lctx, cfg->options,
+	return (cfg_set_string(cfg->options,
 			       &cfg->options->tkeydomain,
 			       newval));
 }
 
 
 isc_result_t
-dns_c_ctx_settkeydhkey(isc_log_t *lctx, dns_c_ctx_t *cfg,
+dns_c_ctx_settkeydhkey(dns_c_ctx_t *cfg,
 		       const char *charval, isc_int32_t intval)
 {
 	isc_result_t res;
 	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
-	res = make_options(lctx, cfg);
+	res = make_options(cfg);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
 
 	cfg->options->tkeydhkeyi = intval;
-	return (cfg_set_string(lctx, cfg->options,
+	return (cfg_set_string(cfg->options,
 			       &cfg->options->tkeydhkeycp,
 			       charval));
 }
 
 
 isc_result_t
-dns_c_ctx_setmaxncachettl(isc_log_t *lctx,
-			  dns_c_ctx_t *cfg, isc_uint32_t newval)
+dns_c_ctx_setmaxncachettl(dns_c_ctx_t *cfg, isc_uint32_t newval)
 {
 	isc_result_t res;
 	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
-	res = make_options(lctx, cfg);
+	res = make_options(cfg);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
 	
-	return (cfg_set_uint32(lctx, cfg->options, 
+	return (cfg_set_uint32(cfg->options, 
 			       &cfg->options->max_ncache_ttl,
 			       newval,
 			       &cfg->options->setflags1,
@@ -859,19 +819,18 @@ dns_c_ctx_setmaxncachettl(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_settransfersin(isc_log_t *lctx,
-			 dns_c_ctx_t *cfg, isc_int32_t newval)
+dns_c_ctx_settransfersin(dns_c_ctx_t *cfg, isc_int32_t newval)
 {
 	isc_result_t res;
 	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
-	res = make_options(lctx, cfg);
+	res = make_options(cfg);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
 	
-	return (cfg_set_int32(lctx, cfg->options, 
+	return (cfg_set_int32(cfg->options, 
 			      &cfg->options->transfers_in,
 			      newval,
 			      &cfg->options->setflags1,
@@ -880,19 +839,18 @@ dns_c_ctx_settransfersin(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_settransfersperns(isc_log_t *lctx,
-			    dns_c_ctx_t *cfg, isc_int32_t newval)
+dns_c_ctx_settransfersperns(dns_c_ctx_t *cfg, isc_int32_t newval)
 {
 	isc_result_t res;
 	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
-	res = make_options(lctx, cfg);
+	res = make_options(cfg);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
 	
-	return (cfg_set_int32(lctx, cfg->options, 
+	return (cfg_set_int32(cfg->options, 
 			      &cfg->options->transfers_per_ns,
 			      newval,
 			      &cfg->options->setflags1,
@@ -901,19 +859,18 @@ dns_c_ctx_settransfersperns(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_settransfersout(isc_log_t *lctx,
-			  dns_c_ctx_t *cfg, isc_int32_t newval)
+dns_c_ctx_settransfersout(dns_c_ctx_t *cfg, isc_int32_t newval)
 {
 	isc_result_t res;
 	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
-	res = make_options(lctx, cfg);
+	res = make_options(cfg);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
 	
-	return (cfg_set_int32(lctx, cfg->options,
+	return (cfg_set_int32(cfg->options,
 			      &cfg->options->transfers_out,
 			      newval,
 			      &cfg->options->setflags1,
@@ -922,19 +879,18 @@ dns_c_ctx_settransfersout(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_setmaxlogsizeixfr(isc_log_t *lctx,
-			    dns_c_ctx_t *cfg, isc_int32_t newval)
+dns_c_ctx_setmaxlogsizeixfr(dns_c_ctx_t *cfg, isc_int32_t newval)
 {
 	isc_result_t res;
 	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
-	res = make_options(lctx, cfg);
+	res = make_options(cfg);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
 	
-	return (cfg_set_int32(lctx, cfg->options,
+	return (cfg_set_int32(cfg->options,
 			      &cfg->options->max_log_size_ixfr,
 			      newval,
 			      &cfg->options->setflags1,
@@ -943,19 +899,18 @@ dns_c_ctx_setmaxlogsizeixfr(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_setcleaninterval(isc_log_t *lctx,
-			   dns_c_ctx_t *cfg, isc_int32_t newval)
+dns_c_ctx_setcleaninterval(dns_c_ctx_t *cfg, isc_int32_t newval)
 {
 	isc_result_t res;
 	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
-	res = make_options(lctx, cfg);
+	res = make_options(cfg);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
 	
-	return (cfg_set_int32(lctx, cfg->options,
+	return (cfg_set_int32(cfg->options,
 			      &cfg->options->clean_interval,
 			      newval,
 			      &cfg->options->setflags1,
@@ -964,19 +919,18 @@ dns_c_ctx_setcleaninterval(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_setinterfaceinterval(isc_log_t *lctx,
-			       dns_c_ctx_t *cfg, isc_int32_t newval)
+dns_c_ctx_setinterfaceinterval(dns_c_ctx_t *cfg, isc_int32_t newval)
 {
 	isc_result_t res;
 	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
-	res = make_options(lctx, cfg);
+	res = make_options(cfg);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
 	
-	return (cfg_set_int32(lctx, cfg->options,
+	return (cfg_set_int32(cfg->options,
 			      &cfg->options->interface_interval,
 			      newval,
 			      &cfg->options->setflags1,
@@ -985,19 +939,18 @@ dns_c_ctx_setinterfaceinterval(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_setstatsinterval(isc_log_t *lctx,
-			   dns_c_ctx_t *cfg, isc_int32_t newval)
+dns_c_ctx_setstatsinterval(dns_c_ctx_t *cfg, isc_int32_t newval)
 {
 	isc_result_t res;
 	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
-	res = make_options(lctx, cfg);
+	res = make_options(cfg);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
 	
-	return (cfg_set_int32(lctx, cfg->options,
+	return (cfg_set_int32(cfg->options,
 			      &cfg->options->stats_interval,
 			      newval,
 			      &cfg->options->setflags1,
@@ -1006,19 +959,18 @@ dns_c_ctx_setstatsinterval(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_setheartbeat_interval(isc_log_t *lctx,
-				dns_c_ctx_t *cfg, isc_int32_t newval)
+dns_c_ctx_setheartbeat_interval(dns_c_ctx_t *cfg, isc_int32_t newval)
 {
 	isc_result_t res;
 	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
-	res = make_options(lctx, cfg);
+	res = make_options(cfg);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
 	
-	return (cfg_set_int32(lctx, cfg->options,
+	return (cfg_set_int32(cfg->options,
 			      &cfg->options->heartbeat_interval,
 			      newval,
 			      &cfg->options->setflags1,
@@ -1027,19 +979,18 @@ dns_c_ctx_setheartbeat_interval(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_setmaxtransfertimein(isc_log_t *lctx,
-			       dns_c_ctx_t *cfg, isc_int32_t newval)
+dns_c_ctx_setmaxtransfertimein(dns_c_ctx_t *cfg, isc_int32_t newval)
 {
 	isc_result_t res;
 	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
-	res = make_options(lctx, cfg);
+	res = make_options(cfg);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
 	
-	return (cfg_set_int32(lctx, cfg->options,
+	return (cfg_set_int32(cfg->options,
 			      &cfg->options->max_transfer_time_in,
 			      newval,
 			      &cfg->options->setflags1,
@@ -1048,19 +999,18 @@ dns_c_ctx_setmaxtransfertimein(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_setdatasize(isc_log_t *lctx,
-		      dns_c_ctx_t *cfg, isc_uint32_t newval)
+dns_c_ctx_setdatasize(dns_c_ctx_t *cfg, isc_uint32_t newval)
 {
 	isc_result_t res;
 	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
-	res = make_options(lctx, cfg);
+	res = make_options(cfg);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
 	
-	return (cfg_set_uint32(lctx, cfg->options,
+	return (cfg_set_uint32(cfg->options,
 			       &cfg->options->data_size,
 			       newval,
 			       &cfg->options->setflags1,
@@ -1069,19 +1019,18 @@ dns_c_ctx_setdatasize(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_setstacksize(isc_log_t *lctx,
-		       dns_c_ctx_t *cfg, isc_uint32_t newval)
+dns_c_ctx_setstacksize(dns_c_ctx_t *cfg, isc_uint32_t newval)
 {
 	isc_result_t res;
 	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
-	res = make_options(lctx, cfg);
+	res = make_options(cfg);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
 	
-	return (cfg_set_uint32(lctx, cfg->options,
+	return (cfg_set_uint32(cfg->options,
 			       &cfg->options->stack_size,
 			       newval,
 			       &cfg->options->setflags1,
@@ -1090,19 +1039,18 @@ dns_c_ctx_setstacksize(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_setcoresize(isc_log_t *lctx,
-		      dns_c_ctx_t *cfg, isc_uint32_t newval)
+dns_c_ctx_setcoresize(dns_c_ctx_t *cfg, isc_uint32_t newval)
 {
 	isc_result_t res;
 	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
-	res = make_options(lctx, cfg);
+	res = make_options(cfg);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
 	
-	return (cfg_set_uint32(lctx, cfg->options,
+	return (cfg_set_uint32(cfg->options,
 			       &cfg->options->core_size,
 			       newval,
 			       &cfg->options->setflags1,
@@ -1111,19 +1059,18 @@ dns_c_ctx_setcoresize(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_setfiles(isc_log_t *lctx,
-		   dns_c_ctx_t *cfg, isc_uint32_t newval)
+dns_c_ctx_setfiles(dns_c_ctx_t *cfg, isc_uint32_t newval)
 {
 	isc_result_t res;
 	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
-	res = make_options(lctx, cfg);
+	res = make_options(cfg);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
 	
-	return (cfg_set_uint32(lctx, cfg->options,
+	return (cfg_set_uint32(cfg->options,
 			       &cfg->options->files,
 			       newval,
 			       &cfg->options->setflags1,
@@ -1132,19 +1079,18 @@ dns_c_ctx_setfiles(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_setexpertmode(isc_log_t *lctx,
-			dns_c_ctx_t *cfg, isc_boolean_t newval)
+dns_c_ctx_setexpertmode(dns_c_ctx_t *cfg, isc_boolean_t newval)
 {
 	isc_result_t res;
 	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
-	res = make_options(lctx, cfg);
+	res = make_options(cfg);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
 	
-	return (cfg_set_boolean(lctx, cfg->options,
+	return (cfg_set_boolean(cfg->options,
 				&cfg->options->expert_mode,
 				newval,
 				&cfg->options->setflags1,
@@ -1153,19 +1099,18 @@ dns_c_ctx_setexpertmode(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_setfakeiquery(isc_log_t *lctx,
-			dns_c_ctx_t *cfg, isc_boolean_t newval)
+dns_c_ctx_setfakeiquery(dns_c_ctx_t *cfg, isc_boolean_t newval)
 {
 	isc_result_t res;
 	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
-	res = make_options(lctx, cfg);
+	res = make_options(cfg);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
 	
-	return (cfg_set_boolean(lctx, cfg->options,
+	return (cfg_set_boolean(cfg->options,
 				&cfg->options->fake_iquery,
 				newval,
 				&cfg->options->setflags1,
@@ -1174,19 +1119,18 @@ dns_c_ctx_setfakeiquery(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_setrecursion(isc_log_t *lctx,
-		       dns_c_ctx_t *cfg, isc_boolean_t newval)
+dns_c_ctx_setrecursion(dns_c_ctx_t *cfg, isc_boolean_t newval)
 {
 	isc_result_t res;
 	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
-	res = make_options(lctx, cfg);
+	res = make_options(cfg);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
 	
-	return (cfg_set_boolean(lctx, cfg->options,
+	return (cfg_set_boolean(cfg->options,
 				&cfg->options->recursion,
 				newval,
 				&cfg->options->setflags1,
@@ -1195,19 +1139,18 @@ dns_c_ctx_setrecursion(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_setfetchglue(isc_log_t *lctx,
-		       dns_c_ctx_t *cfg, isc_boolean_t newval)
+dns_c_ctx_setfetchglue(dns_c_ctx_t *cfg, isc_boolean_t newval)
 {
 	isc_result_t res;
 	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
-	res = make_options(lctx, cfg);
+	res = make_options(cfg);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
 	
-	return (cfg_set_boolean(lctx, cfg->options,
+	return (cfg_set_boolean(cfg->options,
 				&cfg->options->fetch_glue,
 				newval,
 				&cfg->options->setflags1,
@@ -1216,19 +1159,18 @@ dns_c_ctx_setfetchglue(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_setnotify(isc_log_t *lctx,
-		    dns_c_ctx_t *cfg, isc_boolean_t newval)
+dns_c_ctx_setnotify(dns_c_ctx_t *cfg, isc_boolean_t newval)
 {
 	isc_result_t res;
 	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
-	res = make_options(lctx, cfg);
+	res = make_options(cfg);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
 	
-	return (cfg_set_boolean(lctx, cfg->options,
+	return (cfg_set_boolean(cfg->options,
 				&cfg->options->notify,
 				newval,
 				&cfg->options->setflags1,
@@ -1237,19 +1179,18 @@ dns_c_ctx_setnotify(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_sethoststatistics(isc_log_t *lctx,
-			    dns_c_ctx_t *cfg, isc_boolean_t newval)
+dns_c_ctx_sethoststatistics(dns_c_ctx_t *cfg, isc_boolean_t newval)
 {
 	isc_result_t res;
 	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
-	res = make_options(lctx, cfg);
+	res = make_options(cfg);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
 	
-	return (cfg_set_boolean(lctx, cfg->options,
+	return (cfg_set_boolean(cfg->options,
 				&cfg->options->host_statistics,
 				newval,
 				&cfg->options->setflags1,
@@ -1258,19 +1199,18 @@ dns_c_ctx_sethoststatistics(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_setdealloconexit(isc_log_t *lctx,
-			   dns_c_ctx_t *cfg, isc_boolean_t newval)
+dns_c_ctx_setdealloconexit(dns_c_ctx_t *cfg, isc_boolean_t newval)
 {
 	isc_result_t res;
 	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
-	res = make_options(lctx, cfg);
+	res = make_options(cfg);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
 	
-	return (cfg_set_boolean(lctx, cfg->options,
+	return (cfg_set_boolean(cfg->options,
 				&cfg->options->dealloc_on_exit,
 				newval,
 				&cfg->options->setflags1,
@@ -1279,19 +1219,18 @@ dns_c_ctx_setdealloconexit(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_setuseixfr(isc_log_t *lctx,
-		     dns_c_ctx_t *cfg, isc_boolean_t newval)
+dns_c_ctx_setuseixfr(dns_c_ctx_t *cfg, isc_boolean_t newval)
 {
 	isc_result_t res;
 	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
-	res = make_options(lctx, cfg);
+	res = make_options(cfg);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
 	
-	return (cfg_set_boolean(lctx, cfg->options,
+	return (cfg_set_boolean(cfg->options,
 				&cfg->options->use_ixfr,
 				newval,
 				&cfg->options->setflags1,
@@ -1300,19 +1239,18 @@ dns_c_ctx_setuseixfr(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_setmaintainixfrbase(isc_log_t *lctx,
-			      dns_c_ctx_t *cfg, isc_boolean_t newval)
+dns_c_ctx_setmaintainixfrbase(dns_c_ctx_t *cfg, isc_boolean_t newval)
 {
 	isc_result_t res;
 	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
-	res = make_options(lctx, cfg);
+	res = make_options(cfg);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
 	
-	return (cfg_set_boolean(lctx, cfg->options,
+	return (cfg_set_boolean(cfg->options,
 				&cfg->options->maintain_ixfr_base,
 				newval,
 				&cfg->options->setflags1,
@@ -1321,19 +1259,18 @@ dns_c_ctx_setmaintainixfrbase(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_sethasoldclients(isc_log_t *lctx,
-			   dns_c_ctx_t *cfg, isc_boolean_t newval)
+dns_c_ctx_sethasoldclients(dns_c_ctx_t *cfg, isc_boolean_t newval)
 {
 	isc_result_t res;
 	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
-	res = make_options(lctx, cfg);
+	res = make_options(cfg);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
 	
-	return (cfg_set_boolean(lctx, cfg->options,
+	return (cfg_set_boolean(cfg->options,
 				&cfg->options->has_old_clients,
 				newval,
 				&cfg->options->setflags1,
@@ -1342,19 +1279,18 @@ dns_c_ctx_sethasoldclients(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_setauthnxdomain(isc_log_t *lctx,
-			  dns_c_ctx_t *cfg, isc_boolean_t newval)
+dns_c_ctx_setauthnxdomain(dns_c_ctx_t *cfg, isc_boolean_t newval)
 {
 	isc_result_t res;
 	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
-	res = make_options(lctx, cfg);
+	res = make_options(cfg);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
 	
-	return (cfg_set_boolean(lctx, cfg->options,
+	return (cfg_set_boolean(cfg->options,
 				&cfg->options->auth_nx_domain,
 				newval,
 				&cfg->options->setflags1,
@@ -1363,19 +1299,18 @@ dns_c_ctx_setauthnxdomain(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_setmultiplecnames(isc_log_t *lctx,
-			    dns_c_ctx_t *cfg, isc_boolean_t newval)
+dns_c_ctx_setmultiplecnames(dns_c_ctx_t *cfg, isc_boolean_t newval)
 {
 	isc_result_t res;
 	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
-	res = make_options(lctx, cfg);
+	res = make_options(cfg);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
 	
-	return (cfg_set_boolean(lctx, cfg->options,
+	return (cfg_set_boolean(cfg->options,
 				&cfg->options->multiple_cnames,
 				newval,
 				&cfg->options->setflags1,
@@ -1384,19 +1319,18 @@ dns_c_ctx_setmultiplecnames(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_setuseidpool(isc_log_t *lctx,
-		       dns_c_ctx_t *cfg, isc_boolean_t newval)
+dns_c_ctx_setuseidpool(dns_c_ctx_t *cfg, isc_boolean_t newval)
 {
 	isc_result_t res;
 	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
-	res = make_options(lctx, cfg);
+	res = make_options(cfg);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
 	
-	return (cfg_set_boolean(lctx, cfg->options,
+	return (cfg_set_boolean(cfg->options,
 				&cfg->options->use_id_pool,
 				newval,
 				&cfg->options->setflags1,
@@ -1405,19 +1339,18 @@ dns_c_ctx_setuseidpool(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_setrfc2308type1(isc_log_t *lctx,
-			  dns_c_ctx_t *cfg, isc_boolean_t newval)
+dns_c_ctx_setrfc2308type1(dns_c_ctx_t *cfg, isc_boolean_t newval)
 {
 	isc_result_t res;
 	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
-	res = make_options(lctx, cfg);
+	res = make_options(cfg);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
 	
-	return (cfg_set_boolean(lctx, cfg->options,
+	return (cfg_set_boolean(cfg->options,
 				&cfg->options->rfc2308_type1,
 				newval,
 				&cfg->options->setflags1,
@@ -1426,19 +1359,18 @@ dns_c_ctx_setrfc2308type1(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_setdialup(isc_log_t *lctx,
-		    dns_c_ctx_t *cfg, isc_boolean_t newval)
+dns_c_ctx_setdialup(dns_c_ctx_t *cfg, isc_boolean_t newval)
 {
 	isc_result_t res;
 	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
-	res = make_options(lctx, cfg);
+	res = make_options(cfg);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
 	
-	return (cfg_set_boolean(lctx, cfg->options,
+	return (cfg_set_boolean(cfg->options,
 				&cfg->options->dialup,
 				newval,
 				&cfg->options->setflags1,
@@ -1447,15 +1379,14 @@ dns_c_ctx_setdialup(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_setquerysourceaddr(isc_log_t *lctx,
-			     dns_c_ctx_t *cfg, isc_sockaddr_t addr)
+dns_c_ctx_setquerysourceaddr(dns_c_ctx_t *cfg, isc_sockaddr_t addr)
 {
 	isc_boolean_t existed;
 	isc_result_t res;
 	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
-	res = make_options(lctx, cfg);
+	res = make_options(cfg);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
@@ -1471,15 +1402,14 @@ dns_c_ctx_setquerysourceaddr(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_setquerysourceport(isc_log_t *lctx,
-			     dns_c_ctx_t *cfg, short port)
+dns_c_ctx_setquerysourceport(dns_c_ctx_t *cfg, short port)
 {
 	isc_boolean_t existed;
 	isc_result_t res;
 	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
-	res = make_options(lctx, cfg);
+	res = make_options(cfg);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
@@ -1495,8 +1425,7 @@ dns_c_ctx_setquerysourceport(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_settransferformat(isc_log_t *lctx,
-			    dns_c_ctx_t *cfg,
+dns_c_ctx_settransferformat(dns_c_ctx_t *cfg,
 			    dns_transfer_format_t newval)
 {
 	isc_boolean_t existed;
@@ -1504,7 +1433,7 @@ dns_c_ctx_settransferformat(isc_log_t *lctx,
 	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
-	res = make_options(lctx, cfg);
+	res = make_options(cfg);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
@@ -1520,8 +1449,7 @@ dns_c_ctx_settransferformat(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_setchecknames(isc_log_t *lctx,
-			dns_c_ctx_t *cfg,
+dns_c_ctx_setchecknames(dns_c_ctx_t *cfg,
 			dns_c_trans_t transtype,
 			dns_c_severity_t sever)
 {
@@ -1530,7 +1458,7 @@ dns_c_ctx_setchecknames(isc_log_t *lctx,
 	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
-	res = make_options(lctx, cfg);
+	res = make_options(cfg);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
@@ -1555,7 +1483,7 @@ dns_c_ctx_setchecknames(isc_log_t *lctx,
 		break;
 
 	default:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "bad transport value: %d", transtype);
 		return (ISC_R_FAILURE);
@@ -1568,22 +1496,21 @@ dns_c_ctx_setchecknames(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_setqueryacl(isc_log_t *lctx,
-		      dns_c_ctx_t *cfg, isc_boolean_t copy,
+dns_c_ctx_setqueryacl(dns_c_ctx_t *cfg, isc_boolean_t copy,
 		      dns_c_ipmatchlist_t *iml)
 {
 	isc_result_t res;
 	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
-	res = make_options(lctx, cfg);
+	res = make_options(cfg);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
 	
 	REQUIRE(iml != NULL);
 
-	res = cfg_set_iplist(lctx, cfg->options, &cfg->options->queryacl,
+	res = cfg_set_iplist(cfg->options, &cfg->options->queryacl,
 			     iml, copy);
 
 	return (res);
@@ -1591,22 +1518,21 @@ dns_c_ctx_setqueryacl(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_settransferacl(isc_log_t *lctx,
-			 dns_c_ctx_t *cfg, isc_boolean_t copy,
+dns_c_ctx_settransferacl(dns_c_ctx_t *cfg, isc_boolean_t copy,
 			 dns_c_ipmatchlist_t *iml)
 {
 	isc_result_t res;
 	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
-	res = make_options(lctx, cfg);
+	res = make_options(cfg);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
 	
 	REQUIRE(iml != NULL);
 
-	res = cfg_set_iplist(lctx, cfg->options, &cfg->options->transferacl,
+	res = cfg_set_iplist(cfg->options, &cfg->options->transferacl,
 			     iml, copy);
 
 	return (res);
@@ -1614,22 +1540,21 @@ dns_c_ctx_settransferacl(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_setrecursionacl(isc_log_t *lctx,
-			  dns_c_ctx_t *cfg, isc_boolean_t copy,
+dns_c_ctx_setrecursionacl(dns_c_ctx_t *cfg, isc_boolean_t copy,
 			  dns_c_ipmatchlist_t *iml)
 {
 	isc_result_t res;
 	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
-	res = make_options(lctx, cfg);
+	res = make_options(cfg);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
 	
 	REQUIRE(iml != NULL);
 
-	res = cfg_set_iplist(lctx, cfg->options, &cfg->options->recursionacl,
+	res = cfg_set_iplist(cfg->options, &cfg->options->recursionacl,
 			     iml, copy);
 
 	return (res);
@@ -1637,22 +1562,21 @@ dns_c_ctx_setrecursionacl(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_setblackhole(isc_log_t *lctx,
-		       dns_c_ctx_t *cfg, isc_boolean_t copy,
+dns_c_ctx_setblackhole(dns_c_ctx_t *cfg, isc_boolean_t copy,
 		       dns_c_ipmatchlist_t *iml)
 {
 	isc_result_t res;
 	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
-	res = make_options(lctx, cfg);
+	res = make_options(cfg);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
 	
 	REQUIRE(iml != NULL);
 
-	res = cfg_set_iplist(lctx, cfg->options, &cfg->options->blackhole,
+	res = cfg_set_iplist(cfg->options, &cfg->options->blackhole,
 			     iml, copy);
 
 	return (res);
@@ -1660,22 +1584,21 @@ dns_c_ctx_setblackhole(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_settopology(isc_log_t *lctx,
-		      dns_c_ctx_t *cfg, isc_boolean_t copy,
+dns_c_ctx_settopology(dns_c_ctx_t *cfg, isc_boolean_t copy,
 		      dns_c_ipmatchlist_t *iml)
 {
 	isc_result_t res;
 	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
-	res = make_options(lctx, cfg);
+	res = make_options(cfg);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
 	
 	REQUIRE(iml != NULL);
 
-	res = cfg_set_iplist(lctx, cfg->options, &cfg->options->topology,
+	res = cfg_set_iplist(cfg->options, &cfg->options->topology,
 			     iml, copy);
 
 	return (res);
@@ -1683,22 +1606,21 @@ dns_c_ctx_settopology(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_setsortlist(isc_log_t *lctx,
-		      dns_c_ctx_t *cfg, isc_boolean_t copy,
+dns_c_ctx_setsortlist(dns_c_ctx_t *cfg, isc_boolean_t copy,
 		      dns_c_ipmatchlist_t *iml)
 {
 	isc_result_t res;
 	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
-	res = make_options(lctx, cfg);
+	res = make_options(cfg);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
 	
 	REQUIRE(iml != NULL);
 
-	res = cfg_set_iplist(lctx, cfg->options, &cfg->options->sortlist,
+	res = cfg_set_iplist(cfg->options, &cfg->options->sortlist,
 			     iml, copy);
 
 	return (res);
@@ -1706,15 +1628,14 @@ dns_c_ctx_setsortlist(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_setforward(isc_log_t *lctx,
-		     dns_c_ctx_t *cfg, dns_c_forw_t forw)
+dns_c_ctx_setforward(dns_c_ctx_t *cfg, dns_c_forw_t forw)
 {
 	isc_boolean_t existed;
 	isc_result_t res;
 
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
-	res = make_options(lctx, cfg);
+	res = make_options(cfg);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
@@ -1729,20 +1650,19 @@ dns_c_ctx_setforward(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_setforwarders(isc_log_t *lctx,
-			dns_c_ctx_t *cfg, dns_c_ipmatchlist_t *iml,
+dns_c_ctx_setforwarders(dns_c_ctx_t *cfg, dns_c_ipmatchlist_t *iml,
 			isc_boolean_t copy)
 {
 	isc_result_t res;
 	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
-	res = make_options(lctx, cfg);
+	res = make_options(cfg);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
 	
-	res = cfg_set_iplist(lctx, cfg->options, &cfg->options->forwarders,
+	res = cfg_set_iplist(cfg->options, &cfg->options->forwarders,
 			     iml, copy);
 
 	return (res);
@@ -1750,8 +1670,7 @@ dns_c_ctx_setforwarders(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_setrrsetorderlist(isc_log_t *lctx,
-			    dns_c_ctx_t *cfg, isc_boolean_t copy,
+dns_c_ctx_setrrsetorderlist(dns_c_ctx_t *cfg, isc_boolean_t copy,
 			    dns_c_rrsolist_t *olist)
 {
 	isc_boolean_t existed;
@@ -1760,7 +1679,7 @@ dns_c_ctx_setrrsetorderlist(isc_log_t *lctx,
 
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
-	res = make_options(lctx, cfg);
+	res = make_options(cfg);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
@@ -1771,19 +1690,19 @@ dns_c_ctx_setrrsetorderlist(isc_log_t *lctx,
 	
 	if (copy) {
 		if (opts->ordering == NULL) {
-			res = dns_c_rrsolist_new(lctx, opts->mem,
+			res = dns_c_rrsolist_new(opts->mem,
 						 &opts->ordering);
 			if (res != ISC_R_SUCCESS) {
 				return (res);
 			}
 		} else {
-			dns_c_rrsolist_clear(lctx, opts->ordering);
+			dns_c_rrsolist_clear(opts->ordering);
 		}
 		
-		res = dns_c_rrsolist_append(lctx, opts->ordering, olist);
+		res = dns_c_rrsolist_append(opts->ordering, olist);
 	} else {
 		if (opts->ordering != NULL) {
-			dns_c_rrsolist_delete(lctx, &opts->ordering);
+			dns_c_rrsolist_delete(&opts->ordering);
 		}
 		
 		opts->ordering = olist;
@@ -1799,8 +1718,7 @@ dns_c_ctx_setrrsetorderlist(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_addlisten_on(isc_log_t *lctx,
-		       dns_c_ctx_t *cfg,int port, dns_c_ipmatchlist_t *ml,
+dns_c_ctx_addlisten_on(dns_c_ctx_t *cfg,int port, dns_c_ipmatchlist_t *ml,
 		       isc_boolean_t copy)
 {
 	dns_c_lstnon_t *lo;
@@ -1810,7 +1728,7 @@ dns_c_ctx_addlisten_on(isc_log_t *lctx,
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 	REQUIRE(port >= 0 && port <= 65535);
 
-	res = make_options(lctx, cfg);
+	res = make_options(cfg);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
@@ -1818,7 +1736,7 @@ dns_c_ctx_addlisten_on(isc_log_t *lctx,
 	opts = cfg->options;
 
 	if (opts->listens == NULL) {
-		res = dns_c_lstnlist_new(lctx, cfg->mem, &opts->listens);
+		res = dns_c_lstnlist_new(cfg->mem, &opts->listens);
 		if (res != ISC_R_SUCCESS) {
 			return (res);
 		}
@@ -1838,13 +1756,13 @@ dns_c_ctx_addlisten_on(isc_log_t *lctx,
 	}
 #endif	
 
-	res = dns_c_lstnon_new(lctx, cfg->mem, &lo);
+	res = dns_c_lstnon_new(cfg->mem, &lo);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
 	
 	lo->port = port;
-	res = dns_c_lstnon_setiml(lctx, lo, ml, copy);
+	res = dns_c_lstnon_setiml(lo, ml, copy);
 
 	ISC_LIST_APPEND(opts->listens->elements, lo, next);
 
@@ -1853,8 +1771,7 @@ dns_c_ctx_addlisten_on(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_settrustedkeys(isc_log_t *lctx,
-			 dns_c_ctx_t *cfg, dns_c_tkeylist_t *list,
+dns_c_ctx_settrustedkeys(dns_c_ctx_t *cfg, dns_c_tkeylist_t *list,
 			 isc_boolean_t copy)
 {
 	isc_boolean_t existed;
@@ -1866,14 +1783,14 @@ dns_c_ctx_settrustedkeys(isc_log_t *lctx,
 	existed = (cfg->trusted_keys == NULL ? ISC_FALSE : ISC_TRUE);
 
 	if (cfg->trusted_keys != NULL) {
-		res = dns_c_tkeylist_delete(lctx, &cfg->trusted_keys);
+		res = dns_c_tkeylist_delete(&cfg->trusted_keys);
 		if (res != ISC_R_SUCCESS) {
 			return (res);
 		}
 	}
 	
 	if (copy) {
-		res = dns_c_tkeylist_copy(lctx, cfg->mem, &newl, list);
+		res = dns_c_tkeylist_copy(cfg->mem, &newl, list);
 		if (res != ISC_R_SUCCESS) {
 			return (res);
 		}
@@ -1892,12 +1809,9 @@ dns_c_ctx_settrustedkeys(isc_log_t *lctx,
  **/
 
 isc_result_t
-dns_c_ctx_getdirectory(isc_log_t *lctx,
-		       dns_c_ctx_t *cfg, char **retval)
+dns_c_ctx_getdirectory(dns_c_ctx_t *cfg, char **retval)
 {
 
-	(void)lctx;
-	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 	REQUIRE(retval != NULL);
 
@@ -1914,12 +1828,9 @@ dns_c_ctx_getdirectory(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_getversion(isc_log_t *lctx,
-		     dns_c_ctx_t *cfg, char **retval)
+dns_c_ctx_getversion(dns_c_ctx_t *cfg, char **retval)
 {
 
-	(void)lctx;
-	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 	REQUIRE(retval != NULL);
 
@@ -1936,12 +1847,9 @@ dns_c_ctx_getversion(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_getdumpfilename(isc_log_t *lctx,
-			  dns_c_ctx_t *cfg, char **retval)
+dns_c_ctx_getdumpfilename(dns_c_ctx_t *cfg, char **retval)
 {
 
-	(void)lctx;
-	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 	REQUIRE(retval != NULL);
 
@@ -1958,12 +1866,9 @@ dns_c_ctx_getdumpfilename(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_getpidfilename(isc_log_t *lctx,
-			 dns_c_ctx_t *cfg, char **retval)
+dns_c_ctx_getpidfilename(dns_c_ctx_t *cfg, char **retval)
 {
 
-	(void)lctx;
-	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 	REQUIRE(retval != NULL);
 
@@ -1980,12 +1885,9 @@ dns_c_ctx_getpidfilename(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_getstatsfilename(isc_log_t *lctx,
-			   dns_c_ctx_t *cfg, char **retval)
+dns_c_ctx_getstatsfilename(dns_c_ctx_t *cfg, char **retval)
 {
 
-	(void)lctx;
-	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 	REQUIRE(retval != NULL);
 
@@ -2002,11 +1904,8 @@ dns_c_ctx_getstatsfilename(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_getmemstatsfilename(isc_log_t *lctx,
-			      dns_c_ctx_t *cfg, char **retval)
+dns_c_ctx_getmemstatsfilename(dns_c_ctx_t *cfg, char **retval)
 {
-	(void) lctx;
-	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 	REQUIRE(retval != NULL);
 
@@ -2023,11 +1922,8 @@ dns_c_ctx_getmemstatsfilename(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_getnamedxfer(isc_log_t *lctx,
-		       dns_c_ctx_t *cfg, char **retval)
+dns_c_ctx_getnamedxfer(dns_c_ctx_t *cfg, char **retval)
 {
-	(void) lctx;
-	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 	REQUIRE(retval != NULL);
 
@@ -2044,11 +1940,8 @@ dns_c_ctx_getnamedxfer(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_gettkeydomain(isc_log_t *lctx,
-			dns_c_ctx_t *cfg, char **retval)
+dns_c_ctx_gettkeydomain(dns_c_ctx_t *cfg, char **retval)
 {
-	(void) lctx;
-	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 	REQUIRE(retval != NULL);
 
@@ -2065,13 +1958,11 @@ dns_c_ctx_gettkeydomain(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_gettkeydhkey(isc_log_t *lctx, dns_c_ctx_t *cfg,
+dns_c_ctx_gettkeydhkey(dns_c_ctx_t *cfg,
 		       char **charpval, isc_int32_t *intval)
 {
 	isc_result_t res;
-	
-	(void) lctx;
-	
+
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 	REQUIRE(charpval != NULL);
 	REQUIRE(intval != NULL);
@@ -2095,8 +1986,7 @@ dns_c_ctx_gettkeydhkey(isc_log_t *lctx, dns_c_ctx_t *cfg,
 
 
 isc_result_t
-dns_c_ctx_getmaxncachettl(isc_log_t *lctx,
-			  dns_c_ctx_t *cfg, isc_uint32_t *retval)
+dns_c_ctx_getmaxncachettl(dns_c_ctx_t *cfg, isc_uint32_t *retval)
 {
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 	REQUIRE(retval != NULL);
@@ -2107,7 +1997,7 @@ dns_c_ctx_getmaxncachettl(isc_log_t *lctx,
 	
 	REQUIRE(DNS_C_CONFOPT_VALID(cfg->options));
 	
-	return (cfg_get_uint32(lctx, cfg->options, 
+	return (cfg_get_uint32(cfg->options, 
 			       &cfg->options->max_ncache_ttl,
 			       retval,
 			       &cfg->options->setflags1,
@@ -2116,8 +2006,7 @@ dns_c_ctx_getmaxncachettl(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_gettransfersin(isc_log_t *lctx,
-			 dns_c_ctx_t *cfg, isc_int32_t *retval)
+dns_c_ctx_gettransfersin(dns_c_ctx_t *cfg, isc_int32_t *retval)
 {
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 	REQUIRE(retval != NULL);
@@ -2129,7 +2018,7 @@ dns_c_ctx_gettransfersin(isc_log_t *lctx,
 	REQUIRE(DNS_C_CONFOPT_VALID(cfg->options));
 
 	
-	return (cfg_get_int32(lctx, cfg->options, 
+	return (cfg_get_int32(cfg->options, 
 			      &cfg->options->transfers_in,
 			      retval,
 			      &cfg->options->setflags1,
@@ -2138,8 +2027,7 @@ dns_c_ctx_gettransfersin(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_gettransfersperns(isc_log_t *lctx,
-			    dns_c_ctx_t *cfg, isc_int32_t *retval)
+dns_c_ctx_gettransfersperns(dns_c_ctx_t *cfg, isc_int32_t *retval)
 {
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 	REQUIRE(retval != NULL);
@@ -2150,7 +2038,7 @@ dns_c_ctx_gettransfersperns(isc_log_t *lctx,
 		
 	REQUIRE(DNS_C_CONFOPT_VALID(cfg->options));
 	
-	return (cfg_get_int32(lctx, cfg->options, 
+	return (cfg_get_int32(cfg->options, 
 			      &cfg->options->transfers_per_ns,
 			      retval,
 			      &cfg->options->setflags1,
@@ -2159,8 +2047,7 @@ dns_c_ctx_gettransfersperns(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_gettransfersout(isc_log_t *lctx,
-			  dns_c_ctx_t *cfg, isc_int32_t *retval)
+dns_c_ctx_gettransfersout(dns_c_ctx_t *cfg, isc_int32_t *retval)
 {
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 	REQUIRE(retval != NULL);
@@ -2171,7 +2058,7 @@ dns_c_ctx_gettransfersout(isc_log_t *lctx,
 
 	REQUIRE(DNS_C_CONFOPT_VALID(cfg->options));
 	
-	return (cfg_get_int32(lctx, cfg->options, 
+	return (cfg_get_int32(cfg->options, 
 			      &cfg->options->transfers_out,
 			      retval,
 			      &cfg->options->setflags1,
@@ -2180,8 +2067,7 @@ dns_c_ctx_gettransfersout(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_getmaxlogsizeixfr(isc_log_t *lctx,
-			    dns_c_ctx_t *cfg, isc_int32_t *retval)
+dns_c_ctx_getmaxlogsizeixfr(dns_c_ctx_t *cfg, isc_int32_t *retval)
 {
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 	REQUIRE(retval != NULL);
@@ -2192,7 +2078,7 @@ dns_c_ctx_getmaxlogsizeixfr(isc_log_t *lctx,
 	
 	REQUIRE(DNS_C_CONFOPT_VALID(cfg->options));
 
-	return (cfg_get_int32(lctx, cfg->options, 
+	return (cfg_get_int32(cfg->options, 
 			      &cfg->options->max_log_size_ixfr,
 			      retval,
 			      &cfg->options->setflags1,
@@ -2201,8 +2087,7 @@ dns_c_ctx_getmaxlogsizeixfr(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_getcleaninterval(isc_log_t *lctx,
-			   dns_c_ctx_t *cfg, isc_int32_t *retval)
+dns_c_ctx_getcleaninterval(dns_c_ctx_t *cfg, isc_int32_t *retval)
 {
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 	REQUIRE(retval != NULL);
@@ -2213,7 +2098,7 @@ dns_c_ctx_getcleaninterval(isc_log_t *lctx,
 	
 	REQUIRE(DNS_C_CONFOPT_VALID(cfg->options));
 
-	return (cfg_get_int32(lctx, cfg->options, 
+	return (cfg_get_int32(cfg->options, 
 			      &cfg->options->clean_interval,
 			      retval,
 			      &cfg->options->setflags1,
@@ -2222,8 +2107,7 @@ dns_c_ctx_getcleaninterval(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_getinterfaceinterval(isc_log_t *lctx,
-			       dns_c_ctx_t *cfg, isc_int32_t *retval)
+dns_c_ctx_getinterfaceinterval(dns_c_ctx_t *cfg, isc_int32_t *retval)
 {
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 	REQUIRE(retval != NULL);
@@ -2233,7 +2117,7 @@ dns_c_ctx_getinterfaceinterval(isc_log_t *lctx,
 	}
 	
 	
-	return (cfg_get_int32(lctx, cfg->options, 
+	return (cfg_get_int32(cfg->options, 
 			      &cfg->options->interface_interval,
 			      retval,
 			      &cfg->options->setflags1,
@@ -2242,8 +2126,7 @@ dns_c_ctx_getinterfaceinterval(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_getstatsinterval(isc_log_t *lctx,
-			   dns_c_ctx_t *cfg, isc_int32_t *retval)
+dns_c_ctx_getstatsinterval(dns_c_ctx_t *cfg, isc_int32_t *retval)
 {
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 	REQUIRE(retval != NULL);
@@ -2253,7 +2136,7 @@ dns_c_ctx_getstatsinterval(isc_log_t *lctx,
 	}
 	
 	
-	return (cfg_get_int32(lctx, cfg->options, 
+	return (cfg_get_int32(cfg->options, 
 			      &cfg->options->stats_interval,
 			      retval,
 			      &cfg->options->setflags1,
@@ -2262,8 +2145,7 @@ dns_c_ctx_getstatsinterval(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_getheartbeatinterval(isc_log_t *lctx,
-			       dns_c_ctx_t *cfg, isc_int32_t *retval)
+dns_c_ctx_getheartbeatinterval(dns_c_ctx_t *cfg, isc_int32_t *retval)
 {
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 	REQUIRE(retval != NULL);
@@ -2273,7 +2155,7 @@ dns_c_ctx_getheartbeatinterval(isc_log_t *lctx,
 	}
 	
 	
-	return (cfg_get_int32(lctx, cfg->options, 
+	return (cfg_get_int32(cfg->options, 
 			      &cfg->options->heartbeat_interval,
 			      retval,
 			      &cfg->options->setflags1,
@@ -2282,8 +2164,7 @@ dns_c_ctx_getheartbeatinterval(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_getmaxtransfertimein(isc_log_t *lctx,
-			       dns_c_ctx_t *cfg, isc_int32_t *retval)
+dns_c_ctx_getmaxtransfertimein(dns_c_ctx_t *cfg, isc_int32_t *retval)
 {
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 	REQUIRE(retval != NULL);
@@ -2293,7 +2174,7 @@ dns_c_ctx_getmaxtransfertimein(isc_log_t *lctx,
 	}
 	
 	
-	return (cfg_get_int32(lctx, cfg->options, 
+	return (cfg_get_int32(cfg->options, 
 			      &cfg->options->max_transfer_time_in,
 			      retval,
 			      &cfg->options->setflags1,
@@ -2302,8 +2183,7 @@ dns_c_ctx_getmaxtransfertimein(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_getdatasize(isc_log_t *lctx,
-		      dns_c_ctx_t *cfg, isc_uint32_t *retval)
+dns_c_ctx_getdatasize(dns_c_ctx_t *cfg, isc_uint32_t *retval)
 {
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 	REQUIRE(retval != NULL);
@@ -2313,7 +2193,7 @@ dns_c_ctx_getdatasize(isc_log_t *lctx,
 	}
 	
 	
-	return (cfg_get_uint32(lctx, cfg->options, 
+	return (cfg_get_uint32(cfg->options, 
 			       &cfg->options->data_size,
 			       retval,
 			       &cfg->options->setflags1,
@@ -2322,8 +2202,7 @@ dns_c_ctx_getdatasize(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_getstacksize(isc_log_t *lctx,
-		       dns_c_ctx_t *cfg, isc_uint32_t *retval)
+dns_c_ctx_getstacksize(dns_c_ctx_t *cfg, isc_uint32_t *retval)
 {
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 	REQUIRE(retval != NULL);
@@ -2333,7 +2212,7 @@ dns_c_ctx_getstacksize(isc_log_t *lctx,
 	}
 	
 	
-	return (cfg_get_uint32(lctx, cfg->options, 
+	return (cfg_get_uint32(cfg->options, 
 			       &cfg->options->stack_size,
 			       retval,
 			       &cfg->options->setflags1,
@@ -2342,8 +2221,7 @@ dns_c_ctx_getstacksize(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_getcoresize(isc_log_t *lctx,
-		      dns_c_ctx_t *cfg, isc_uint32_t *retval)
+dns_c_ctx_getcoresize(dns_c_ctx_t *cfg, isc_uint32_t *retval)
 {
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 	REQUIRE(retval != NULL);
@@ -2353,7 +2231,7 @@ dns_c_ctx_getcoresize(isc_log_t *lctx,
 	}
 	
 	
-	return (cfg_get_uint32(lctx, cfg->options, 
+	return (cfg_get_uint32(cfg->options, 
 			       &cfg->options->core_size,
 			       retval,
 			       &cfg->options->setflags1,
@@ -2362,8 +2240,7 @@ dns_c_ctx_getcoresize(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_getfiles(isc_log_t *lctx,
-		   dns_c_ctx_t *cfg, isc_uint32_t *retval)
+dns_c_ctx_getfiles(dns_c_ctx_t *cfg, isc_uint32_t *retval)
 {
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 	REQUIRE(retval != NULL);
@@ -2373,7 +2250,7 @@ dns_c_ctx_getfiles(isc_log_t *lctx,
 	}
 	
 	
-	return (cfg_get_uint32(lctx, cfg->options, 
+	return (cfg_get_uint32(cfg->options, 
 			       &cfg->options->files,
 			       retval,
 			       &cfg->options->setflags1,
@@ -2382,8 +2259,7 @@ dns_c_ctx_getfiles(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_getfakeiquery(isc_log_t *lctx,
-			dns_c_ctx_t *cfg, isc_boolean_t *retval)
+dns_c_ctx_getfakeiquery(dns_c_ctx_t *cfg, isc_boolean_t *retval)
 {
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 	REQUIRE(retval != NULL);
@@ -2393,7 +2269,7 @@ dns_c_ctx_getfakeiquery(isc_log_t *lctx,
 	}
 	
 	
-	return (cfg_get_boolean(lctx, cfg->options, 
+	return (cfg_get_boolean(cfg->options, 
 				&cfg->options->fake_iquery,
 				retval,
 				&cfg->options->setflags1,
@@ -2402,8 +2278,7 @@ dns_c_ctx_getfakeiquery(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_getrecursion(isc_log_t *lctx,
-		       dns_c_ctx_t *cfg, isc_boolean_t *retval)
+dns_c_ctx_getrecursion(dns_c_ctx_t *cfg, isc_boolean_t *retval)
 {
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 	REQUIRE(retval != NULL);
@@ -2413,7 +2288,7 @@ dns_c_ctx_getrecursion(isc_log_t *lctx,
 	}
 	
 	
-	return (cfg_get_boolean(lctx, cfg->options, 
+	return (cfg_get_boolean(cfg->options, 
 				&cfg->options->recursion,
 				retval,
 				&cfg->options->setflags1,
@@ -2422,8 +2297,7 @@ dns_c_ctx_getrecursion(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_getfetchglue(isc_log_t *lctx,
-		       dns_c_ctx_t *cfg, isc_boolean_t *retval)
+dns_c_ctx_getfetchglue(dns_c_ctx_t *cfg, isc_boolean_t *retval)
 {
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 	REQUIRE(retval != NULL);
@@ -2433,7 +2307,7 @@ dns_c_ctx_getfetchglue(isc_log_t *lctx,
 	}
 	
 	
-	return (cfg_get_boolean(lctx, cfg->options, 
+	return (cfg_get_boolean(cfg->options, 
 				&cfg->options->fetch_glue,
 				retval,
 				&cfg->options->setflags1,
@@ -2442,8 +2316,7 @@ dns_c_ctx_getfetchglue(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_getnotify(isc_log_t *lctx,
-		    dns_c_ctx_t *cfg, isc_boolean_t *retval)
+dns_c_ctx_getnotify(dns_c_ctx_t *cfg, isc_boolean_t *retval)
 {
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 	REQUIRE(retval != NULL);
@@ -2453,7 +2326,7 @@ dns_c_ctx_getnotify(isc_log_t *lctx,
 	}
 	
 	
-	return (cfg_get_boolean(lctx, cfg->options, 
+	return (cfg_get_boolean(cfg->options, 
 				&cfg->options->notify,
 				retval,
 				&cfg->options->setflags1,
@@ -2462,8 +2335,7 @@ dns_c_ctx_getnotify(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_gethoststatistics(isc_log_t *lctx,
-			    dns_c_ctx_t *cfg, isc_boolean_t *retval)
+dns_c_ctx_gethoststatistics(dns_c_ctx_t *cfg, isc_boolean_t *retval)
 {
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 	REQUIRE(retval != NULL);
@@ -2473,7 +2345,7 @@ dns_c_ctx_gethoststatistics(isc_log_t *lctx,
 	}
 	
 	
-	return (cfg_get_boolean(lctx, cfg->options, 
+	return (cfg_get_boolean(cfg->options, 
 				&cfg->options->host_statistics,
 				retval,
 				&cfg->options->setflags1,
@@ -2482,8 +2354,7 @@ dns_c_ctx_gethoststatistics(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_getdealloconexit(isc_log_t *lctx,
-			   dns_c_ctx_t *cfg, isc_boolean_t *retval)
+dns_c_ctx_getdealloconexit(dns_c_ctx_t *cfg, isc_boolean_t *retval)
 {
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 	REQUIRE(retval != NULL);
@@ -2493,7 +2364,7 @@ dns_c_ctx_getdealloconexit(isc_log_t *lctx,
 	}
 	
 	
-	return (cfg_get_boolean(lctx, cfg->options, 
+	return (cfg_get_boolean(cfg->options, 
 				&cfg->options->dealloc_on_exit,
 				retval,
 				&cfg->options->setflags1,
@@ -2502,8 +2373,7 @@ dns_c_ctx_getdealloconexit(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_getuseixfr(isc_log_t *lctx,
-		     dns_c_ctx_t *cfg, isc_boolean_t *retval)
+dns_c_ctx_getuseixfr(dns_c_ctx_t *cfg, isc_boolean_t *retval)
 {
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 	REQUIRE(retval != NULL);
@@ -2513,7 +2383,7 @@ dns_c_ctx_getuseixfr(isc_log_t *lctx,
 	}
 	
 	
-	return (cfg_get_boolean(lctx, cfg->options, 
+	return (cfg_get_boolean(cfg->options, 
 				&cfg->options->use_ixfr,
 				retval,
 				&cfg->options->setflags1,
@@ -2522,8 +2392,7 @@ dns_c_ctx_getuseixfr(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_getmaintainixfrbase(isc_log_t *lctx,
-			      dns_c_ctx_t *cfg, isc_boolean_t *retval)
+dns_c_ctx_getmaintainixfrbase(dns_c_ctx_t *cfg, isc_boolean_t *retval)
 {
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 	REQUIRE(retval != NULL);
@@ -2533,7 +2402,7 @@ dns_c_ctx_getmaintainixfrbase(isc_log_t *lctx,
 	}
 	
 	
-	return (cfg_get_boolean(lctx, cfg->options, 
+	return (cfg_get_boolean(cfg->options, 
 				&cfg->options->maintain_ixfr_base,
 				retval,
 				&cfg->options->setflags1,
@@ -2542,8 +2411,7 @@ dns_c_ctx_getmaintainixfrbase(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_gethasoldclients(isc_log_t *lctx,
-			   dns_c_ctx_t *cfg, isc_boolean_t *retval)
+dns_c_ctx_gethasoldclients(dns_c_ctx_t *cfg, isc_boolean_t *retval)
 {
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 	REQUIRE(retval != NULL);
@@ -2553,7 +2421,7 @@ dns_c_ctx_gethasoldclients(isc_log_t *lctx,
 	}
 	
 	
-	return (cfg_get_boolean(lctx, cfg->options, 
+	return (cfg_get_boolean(cfg->options, 
 				&cfg->options->has_old_clients,
 				retval,
 				&cfg->options->setflags1,
@@ -2562,8 +2430,7 @@ dns_c_ctx_gethasoldclients(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_getauth_nx_domain(isc_log_t *lctx,
-			    dns_c_ctx_t *cfg, isc_boolean_t *retval)
+dns_c_ctx_getauth_nx_domain(dns_c_ctx_t *cfg, isc_boolean_t *retval)
 {
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 	REQUIRE(retval != NULL);
@@ -2573,7 +2440,7 @@ dns_c_ctx_getauth_nx_domain(isc_log_t *lctx,
 	}
 	
 	
-	return (cfg_get_boolean(lctx, cfg->options, 
+	return (cfg_get_boolean(cfg->options, 
 				&cfg->options->auth_nx_domain,
 				retval,
 				&cfg->options->setflags1,
@@ -2582,8 +2449,7 @@ dns_c_ctx_getauth_nx_domain(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_getmultiplecnames(isc_log_t *lctx,
-			    dns_c_ctx_t *cfg, isc_boolean_t *retval)
+dns_c_ctx_getmultiplecnames(dns_c_ctx_t *cfg, isc_boolean_t *retval)
 {
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 	REQUIRE(retval != NULL);
@@ -2593,7 +2459,7 @@ dns_c_ctx_getmultiplecnames(isc_log_t *lctx,
 	}
 	
 	
-	return (cfg_get_boolean(lctx, cfg->options, 
+	return (cfg_get_boolean(cfg->options, 
 				&cfg->options->multiple_cnames,
 				retval,
 				&cfg->options->setflags1,
@@ -2602,8 +2468,7 @@ dns_c_ctx_getmultiplecnames(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_getuseidpool(isc_log_t *lctx,
-		       dns_c_ctx_t *cfg, isc_boolean_t *retval)
+dns_c_ctx_getuseidpool(dns_c_ctx_t *cfg, isc_boolean_t *retval)
 {
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 	REQUIRE(retval != NULL);
@@ -2613,7 +2478,7 @@ dns_c_ctx_getuseidpool(isc_log_t *lctx,
 	}
 	
 	
-	return (cfg_get_boolean(lctx, cfg->options, 
+	return (cfg_get_boolean(cfg->options, 
 				&cfg->options->use_id_pool,
 				retval,
 				&cfg->options->setflags1,
@@ -2622,8 +2487,7 @@ dns_c_ctx_getuseidpool(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_getrfc2308type1(isc_log_t *lctx,
-			  dns_c_ctx_t *cfg, isc_boolean_t *retval)
+dns_c_ctx_getrfc2308type1(dns_c_ctx_t *cfg, isc_boolean_t *retval)
 {
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 	REQUIRE(retval != NULL);
@@ -2633,7 +2497,7 @@ dns_c_ctx_getrfc2308type1(isc_log_t *lctx,
 	}
 	
 	
-	return (cfg_get_boolean(lctx, cfg->options, 
+	return (cfg_get_boolean(cfg->options, 
 				&cfg->options->rfc2308_type1,
 				retval,
 				&cfg->options->setflags1,
@@ -2642,8 +2506,7 @@ dns_c_ctx_getrfc2308type1(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_getdialup(isc_log_t *lctx,
-		    dns_c_ctx_t *cfg, isc_boolean_t *retval)
+dns_c_ctx_getdialup(dns_c_ctx_t *cfg, isc_boolean_t *retval)
 {
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 	REQUIRE(retval != NULL);
@@ -2653,7 +2516,7 @@ dns_c_ctx_getdialup(isc_log_t *lctx,
 	}
 	
 	
-	return (cfg_get_boolean(lctx, cfg->options, 
+	return (cfg_get_boolean(cfg->options, 
 				&cfg->options->dialup,
 				retval,
 				&cfg->options->setflags1,
@@ -2662,13 +2525,10 @@ dns_c_ctx_getdialup(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_getquerysourceaddr(isc_log_t *lctx,
-			     dns_c_ctx_t *cfg, isc_sockaddr_t *addr)
+dns_c_ctx_getquerysourceaddr(dns_c_ctx_t *cfg, isc_sockaddr_t *addr)
 {
 	isc_result_t res;
 
-	(void) lctx;
-	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
 	if (cfg->options == NULL) {
@@ -2689,11 +2549,8 @@ dns_c_ctx_getquerysourceaddr(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_getquerysourceport(isc_log_t *lctx,
-			     dns_c_ctx_t *cfg, short *port)
+dns_c_ctx_getquerysourceport(dns_c_ctx_t *cfg, short *port)
 {
-	(void) lctx;
-	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
 	if (cfg->options == NULL) {
@@ -2712,12 +2569,9 @@ dns_c_ctx_getquerysourceport(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_gettransferformat(isc_log_t *lctx,
-			    dns_c_ctx_t *cfg,
+dns_c_ctx_gettransferformat(dns_c_ctx_t *cfg,
 			    dns_transfer_format_t *retval)
 {
-	(void) lctx;
-	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 	REQUIRE(retval != NULL);
 
@@ -2737,8 +2591,7 @@ dns_c_ctx_gettransferformat(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_getchecknames(isc_log_t *lctx,
-			dns_c_ctx_t *cfg,
+dns_c_ctx_getchecknames(dns_c_ctx_t *cfg,
 			dns_c_trans_t transtype,
 			dns_c_severity_t *sever)
 {
@@ -2770,7 +2623,7 @@ dns_c_ctx_getchecknames(isc_log_t *lctx,
 		break;
 
 	default:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "bad transport value: %d", transtype);
 		return (ISC_R_FAILURE);
@@ -2788,8 +2641,7 @@ dns_c_ctx_getchecknames(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_getqueryacl(isc_log_t *lctx,
-		      dns_c_ctx_t *cfg, dns_c_ipmatchlist_t **list)
+dns_c_ctx_getqueryacl(dns_c_ctx_t *cfg, dns_c_ipmatchlist_t **list)
 {
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
@@ -2799,14 +2651,13 @@ dns_c_ctx_getqueryacl(isc_log_t *lctx,
 	
 	REQUIRE(list != NULL);
 
-	return (cfg_get_iplist(lctx, cfg->options, cfg->options->queryacl,
+	return (cfg_get_iplist(cfg->options, cfg->options->queryacl,
 			       list));
 }
 
 
 isc_result_t
-dns_c_ctx_gettransferacl(isc_log_t *lctx,
-			 dns_c_ctx_t *cfg, dns_c_ipmatchlist_t **list)
+dns_c_ctx_gettransferacl(dns_c_ctx_t *cfg, dns_c_ipmatchlist_t **list)
 {
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
@@ -2816,14 +2667,13 @@ dns_c_ctx_gettransferacl(isc_log_t *lctx,
 	
 	REQUIRE(list != NULL);
 
-	return (cfg_get_iplist(lctx, cfg->options,
+	return (cfg_get_iplist(cfg->options,
 			       cfg->options->transferacl, list));
 }
 
 
 isc_result_t
-dns_c_ctx_getrecursionacl(isc_log_t *lctx,
-			  dns_c_ctx_t *cfg, dns_c_ipmatchlist_t **list)
+dns_c_ctx_getrecursionacl(dns_c_ctx_t *cfg, dns_c_ipmatchlist_t **list)
 {
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
@@ -2833,14 +2683,13 @@ dns_c_ctx_getrecursionacl(isc_log_t *lctx,
 	
 	REQUIRE(list != NULL);
 
-	return (cfg_get_iplist(lctx, cfg->options, cfg->options->recursionacl,
+	return (cfg_get_iplist(cfg->options, cfg->options->recursionacl,
 			       list));
 }
 
 
 isc_result_t
-dns_c_ctx_getblackhole(isc_log_t *lctx,
-		       dns_c_ctx_t *cfg, dns_c_ipmatchlist_t **list)
+dns_c_ctx_getblackhole(dns_c_ctx_t *cfg, dns_c_ipmatchlist_t **list)
 {
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
@@ -2850,14 +2699,13 @@ dns_c_ctx_getblackhole(isc_log_t *lctx,
 	
 	REQUIRE(list != NULL);
 
-	return (cfg_get_iplist(lctx, cfg->options,
+	return (cfg_get_iplist(cfg->options,
 			       cfg->options->blackhole, list));
 }
 
 
 isc_result_t
-dns_c_ctx_gettopology(isc_log_t *lctx,
-		      dns_c_ctx_t *cfg, dns_c_ipmatchlist_t **list)
+dns_c_ctx_gettopology(dns_c_ctx_t *cfg, dns_c_ipmatchlist_t **list)
 {
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
@@ -2867,14 +2715,13 @@ dns_c_ctx_gettopology(isc_log_t *lctx,
 	
 	REQUIRE(list != NULL);
 
-	return (cfg_get_iplist(lctx, cfg->options,
+	return (cfg_get_iplist(cfg->options,
 			       cfg->options->topology, list));
 }
 
 
 isc_result_t
-dns_c_ctx_getsortlist(isc_log_t *lctx,
-		      dns_c_ctx_t *cfg, dns_c_ipmatchlist_t **list)
+dns_c_ctx_getsortlist(dns_c_ctx_t *cfg, dns_c_ipmatchlist_t **list)
 {
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
@@ -2884,17 +2731,14 @@ dns_c_ctx_getsortlist(isc_log_t *lctx,
 	
 	REQUIRE(list != NULL);
 
-	return (cfg_get_iplist(lctx, cfg->options,
+	return (cfg_get_iplist(cfg->options,
 			       cfg->options->sortlist, list));
 }
 
 
 isc_result_t
-dns_c_ctx_getlistenlist(isc_log_t *lctx,
-			dns_c_ctx_t *cfg, dns_c_lstnlist_t **ll)
+dns_c_ctx_getlistenlist(dns_c_ctx_t *cfg, dns_c_lstnlist_t **ll)
 {
-	(void) lctx;
-	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
 	if (cfg->options == NULL) {
@@ -2914,13 +2758,10 @@ dns_c_ctx_getlistenlist(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_getforward(isc_log_t *lctx,
-		     dns_c_ctx_t *cfg, dns_c_forw_t *forw)
+dns_c_ctx_getforward(dns_c_ctx_t *cfg, dns_c_forw_t *forw)
 {
 	isc_result_t res;
 
-	(void) lctx;
-	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
 	if (cfg->options == NULL) {
@@ -2941,8 +2782,7 @@ dns_c_ctx_getforward(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_getforwarders(isc_log_t *lctx,
-			dns_c_ctx_t *cfg, dns_c_ipmatchlist_t **list)
+dns_c_ctx_getforwarders(dns_c_ctx_t *cfg, dns_c_ipmatchlist_t **list)
 {
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
@@ -2952,17 +2792,14 @@ dns_c_ctx_getforwarders(isc_log_t *lctx,
 	
 	REQUIRE(list != NULL);
 
-	return (cfg_get_iplist(lctx, cfg->options,
+	return (cfg_get_iplist(cfg->options,
 			       cfg->options->forwarders, list));
 }
 
 
 isc_result_t
-dns_c_ctx_getrrsetorderlist(isc_log_t *lctx,
-			    dns_c_ctx_t *cfg, dns_c_rrsolist_t **retval)
+dns_c_ctx_getrrsetorderlist(dns_c_ctx_t *cfg, dns_c_rrsolist_t **retval)
 {
-	(void) lctx;
-	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 	REQUIRE(retval != NULL);
 
@@ -2976,11 +2813,8 @@ dns_c_ctx_getrrsetorderlist(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_gettrustedkeys(isc_log_t *lctx,
-			 dns_c_ctx_t *cfg, dns_c_tkeylist_t **retval)
+dns_c_ctx_gettrustedkeys(dns_c_ctx_t *cfg, dns_c_tkeylist_t **retval)
 {
-	(void) lctx;
-	
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 	REQUIRE(retval != NULL);
 
@@ -2995,14 +2829,11 @@ dns_c_ctx_gettrustedkeys(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_optionsnew(isc_log_t *lctx,
-		     isc_mem_t *mem, dns_c_options_t **options)
+dns_c_ctx_optionsnew(isc_mem_t *mem, dns_c_options_t **options)
 {
 	int i;
 	dns_c_options_t *opts = NULL;
 
-	(void) lctx;
-	
 	REQUIRE(mem != NULL);
 	REQUIRE(options != NULL);
 
@@ -3087,8 +2918,7 @@ dns_c_ctx_optionsnew(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ctx_optionsdelete(isc_log_t *lctx,
-			dns_c_options_t **opts)
+dns_c_ctx_optionsdelete(dns_c_options_t **opts)
 {
 	dns_c_options_t *options;
 	isc_result_t r, result;
@@ -3141,55 +2971,55 @@ dns_c_ctx_optionsdelete(isc_log_t *lctx,
 	result = ISC_R_SUCCESS;
 	
 	if (options->queryacl != NULL) {
-		r = dns_c_ipmatchlist_detach(lctx, &options->queryacl);
+		r = dns_c_ipmatchlist_detach(&options->queryacl);
 		if (r != ISC_R_SUCCESS)
 			result = r;
 	}
 	
 	if (options->transferacl != NULL) {
-		r = dns_c_ipmatchlist_detach(lctx, &options->transferacl);
+		r = dns_c_ipmatchlist_detach(&options->transferacl);
 		if (r != ISC_R_SUCCESS)
 			result = r;
 	}
 	
 	if (options->recursionacl != NULL) {
-		r = dns_c_ipmatchlist_detach(lctx, &options->recursionacl);
+		r = dns_c_ipmatchlist_detach(&options->recursionacl);
 		if (r != ISC_R_SUCCESS)
 			result = r;
 	}
 	
 	if (options->blackhole != NULL) {
-		r = dns_c_ipmatchlist_detach(lctx, &options->blackhole);
+		r = dns_c_ipmatchlist_detach(&options->blackhole);
 		if (r != ISC_R_SUCCESS)
 			result = r;
 	}
 	
 	if (options->topology != NULL) {
-		r = dns_c_ipmatchlist_detach(lctx, &options->topology);
+		r = dns_c_ipmatchlist_detach(&options->topology);
 		if (r != ISC_R_SUCCESS)
 			result = r;
 	}
 	
 	if (options->sortlist != NULL) {
-		r = dns_c_ipmatchlist_detach(lctx, &options->sortlist);
+		r = dns_c_ipmatchlist_detach(&options->sortlist);
 		if (r != ISC_R_SUCCESS)
 			result = r;
 	}
 	
 	if (options->listens != NULL) {
-		r = dns_c_lstnlist_delete(lctx, &options->listens);
+		r = dns_c_lstnlist_delete(&options->listens);
 		if (r != ISC_R_SUCCESS)
 			result = r;
 	}
 	
 	if (options->ordering != NULL) {
-		r = dns_c_rrsolist_delete(lctx, &options->ordering);
+		r = dns_c_rrsolist_delete(&options->ordering);
 		if (r != ISC_R_SUCCESS)
 			result = r;
 	}
 	
 	if (options->forwarders != NULL) {
-		r = dns_c_ipmatchlist_detach(lctx, &options->forwarders);
+		r = dns_c_ipmatchlist_detach(&options->forwarders);
 		if (r != ISC_R_SUCCESS)
 			result = r;
 	}
@@ -3204,8 +3034,7 @@ dns_c_ctx_optionsdelete(isc_log_t *lctx,
 
 
 void
-dns_c_ctx_optionsprint(isc_log_t *lctx,
-		       FILE *fp, int indent, dns_c_options_t *options)
+dns_c_ctx_optionsprint(FILE *fp, int indent, dns_c_options_t *options)
 {
 	dns_c_severity_t nameseverity;
 	
@@ -3219,45 +3048,45 @@ dns_c_ctx_optionsprint(isc_log_t *lctx,
 
 #define PRINT_INTEGER(field, bit, name, bitfield)			\
 	if (DNS_C_CHECKBIT(bit, &options->bitfield)) {			\
-		dns_c_printtabs(lctx, fp, indent + 1);			\
+		dns_c_printtabs(fp, indent + 1);			\
 		fprintf(fp, "%s %d;\n",name,(int)options->field);	\
 	}
 	
 #define PRINT_AS_MINUTES(field, bit, name, bitfield)		\
 	if (DNS_C_CHECKBIT(bit, &options->bitfield)) {		\
-		dns_c_printtabs(lctx, fp, indent + 1);		\
+		dns_c_printtabs(fp, indent + 1);		\
 		fprintf(fp, "%s %lu;\n",name,			\
 			(unsigned long)options->field / 60);	\
 	}
 
 #define PRINT_AS_BOOLEAN(field, bit, name, bitfield)		\
 	if (DNS_C_CHECKBIT(bit, &options->bitfield)) {		\
-		dns_c_printtabs(lctx, fp, indent + 1);		\
+		dns_c_printtabs(fp, indent + 1);		\
 		fprintf(fp, "%s %s;\n",name,			\
 			(options->field ? "true" : "false"));	\
 	}
 
 #define PRINT_AS_SIZE_CLAUSE(field, bit, name, bitfield)	\
 	if (DNS_C_CHECKBIT(bit, &options->bitfield)) {		\
-		dns_c_printtabs(lctx, fp, indent + 1);		\
+		dns_c_printtabs(fp, indent + 1);		\
 		fprintf(fp, "%s ",name);			\
 		if (options->field == DNS_C_SIZE_SPEC_DEFAULT) { \
 			fprintf(fp, "default");			\
 		} else {					\
-			dns_c_printinunits(lctx, fp, options->data_size); \
+			dns_c_printinunits(fp, options->data_size); \
 		}						\
 		fprintf(fp, ";\n");				\
 	}
 
 #define PRINT_CHAR_P(field, name)					\
 	if (options->field != NULL) {					\
-		dns_c_printtabs(lctx, fp, indent + 1);			\
+		dns_c_printtabs(fp, indent + 1);			\
 		fprintf(fp, "%s \"%s\";\n", name, options->field);	\
 	}
 	
 
 
-	dns_c_printtabs (lctx, fp, indent);
+	dns_c_printtabs(fp, indent);
 	fprintf (fp, "options {\n");
 
 	PRINT_CHAR_P(version, "version");
@@ -3270,7 +3099,7 @@ dns_c_ctx_optionsprint(isc_log_t *lctx,
 	PRINT_CHAR_P(tkeydomain, "tkey-domain");
 
 	if (options->tkeydhkeycp != NULL) {
-		dns_c_printtabs(lctx, fp, indent + 1);
+		dns_c_printtabs(fp, indent + 1);
 		fprintf(fp, "tkey-dhkey \"%s\" %d ;\n",
 			options->tkeydhkeycp, options->tkeydhkeyi);
 	}
@@ -3346,19 +3175,18 @@ dns_c_ctx_optionsprint(isc_log_t *lctx,
 
 
 	if (DNS_C_CHECKBIT(OPTIONS_TRANSFER_FORMAT_BIT, &options->setflags1)) {
-		dns_c_printtabs(lctx, fp, indent + 1);
+		dns_c_printtabs(fp, indent + 1);
 		fprintf(fp, "transfer-format %s;\n",
-			dns_c_transformat2string(lctx,
-						 options->transfer_format,
+			dns_c_transformat2string(options->transfer_format,
 						 ISC_TRUE));
 	}
 	
 	
 	if (DNS_C_CHECKBIT(QUERY_SOURCE_PORT_BIT, &options->setflags1) ||
 	    DNS_C_CHECKBIT(QUERY_SOURCE_ADDR_BIT, &options->setflags1)) {
-		dns_c_printtabs(lctx, fp, indent + 1);
+		dns_c_printtabs(fp, indent + 1);
 		fprintf(fp, "query-source address ");
-		dns_c_print_ipaddr(lctx, fp, &options->query_source_addr);
+		dns_c_print_ipaddr(fp, &options->query_source_addr);
 
 		if (options->query_source_port == 0) {
 			fprintf(fp, " port *");
@@ -3371,98 +3199,97 @@ dns_c_ctx_optionsprint(isc_log_t *lctx,
 
 	if (DNS_C_CHECKBIT(CHECKNAME_PRIM_BIT, &options->setflags1)) {
 		nameseverity = options->check_names[dns_trans_primary];
-		dns_c_printtabs(lctx, fp, indent + 1);
+		dns_c_printtabs(fp, indent + 1);
 		fprintf(fp, "check-names %s %s;\n",
-			dns_c_transport2string(lctx, dns_trans_primary,
+			dns_c_transport2string(dns_trans_primary,
 					       ISC_TRUE),
-			dns_c_nameseverity2string(lctx, nameseverity,
+			dns_c_nameseverity2string(nameseverity,
 						  ISC_TRUE));
 	}
 		
 	if (DNS_C_CHECKBIT(CHECKNAME_SEC_BIT, &options->setflags1)) {
 		nameseverity = options->check_names[dns_trans_secondary];
-		dns_c_printtabs(lctx, fp, indent + 1);
+		dns_c_printtabs(fp, indent + 1);
 		fprintf(fp, "check-names %s %s;\n",
-			dns_c_transport2string(lctx, dns_trans_secondary,
+			dns_c_transport2string(dns_trans_secondary,
 					       ISC_TRUE),
-			dns_c_nameseverity2string(lctx, nameseverity,
+			dns_c_nameseverity2string(nameseverity,
 						  ISC_TRUE));
 	}
 		
 	if (DNS_C_CHECKBIT(CHECKNAME_RESP_BIT, &options->setflags1)) {
 		nameseverity = options->check_names[dns_trans_response];
-		dns_c_printtabs(lctx, fp, indent + 1);
+		dns_c_printtabs(fp, indent + 1);
 		fprintf(fp, "check-names %s %s;\n",
-			dns_c_transport2string(lctx, dns_trans_response,
+			dns_c_transport2string(dns_trans_response,
 					       ISC_TRUE),
-			dns_c_nameseverity2string(lctx, nameseverity,
+			dns_c_nameseverity2string(nameseverity,
 						  ISC_TRUE));
 	}
 
 	fprintf(fp, "\n");
 	
 	if (options->queryacl != NULL) {
-		dns_c_printtabs(lctx, fp, indent + 1);
+		dns_c_printtabs(fp, indent + 1);
 		fprintf(fp, "allow-query ");
-		dns_c_ipmatchlist_print(lctx, fp, 2, options->queryacl);
+		dns_c_ipmatchlist_print(fp, 2, options->queryacl);
 		fprintf(fp, ";\n");
 	}
 
 	if (options->transferacl != NULL) {
-		dns_c_printtabs(lctx, fp, indent + 1);
+		dns_c_printtabs(fp, indent + 1);
 		fprintf(fp, "allow-transfer ");
-		dns_c_ipmatchlist_print(lctx, fp, 2, options->transferacl);
+		dns_c_ipmatchlist_print(fp, 2, options->transferacl);
 		fprintf(fp, ";\n");
 	}
 
 	if (options->recursionacl != NULL) {
-		dns_c_printtabs(lctx, fp, indent + 1);
+		dns_c_printtabs(fp, indent + 1);
 		fprintf(fp, "allow-recursion ");
-		dns_c_ipmatchlist_print(lctx, fp, 2, options->recursionacl);
+		dns_c_ipmatchlist_print(fp, 2, options->recursionacl);
 		fprintf(fp, ";\n");
 	}
 
 	if (options->blackhole != NULL) {
-		dns_c_printtabs(lctx, fp, indent + 1);
+		dns_c_printtabs(fp, indent + 1);
 		fprintf(fp, "blackhole ");
-		dns_c_ipmatchlist_print(lctx, fp, 2, options->blackhole);
+		dns_c_ipmatchlist_print(fp, 2, options->blackhole);
 		fprintf(fp, ";\n");
 	}
 
 	if (options->topology != NULL) {
-		dns_c_printtabs(lctx, fp, indent + 1);
+		dns_c_printtabs(fp, indent + 1);
 		fprintf(fp, "topology ");
-		dns_c_ipmatchlist_print(lctx, fp, 2, options->topology);
+		dns_c_ipmatchlist_print(fp, 2, options->topology);
 		fprintf(fp, ";\n");
 	}
 
 	if (options->sortlist != NULL) {
-		dns_c_printtabs(lctx, fp, indent + 1);
+		dns_c_printtabs(fp, indent + 1);
 		fprintf(fp, "sortlist ");
-		dns_c_ipmatchlist_print(lctx, fp, 2, options->sortlist);
+		dns_c_ipmatchlist_print(fp, 2, options->sortlist);
 		fprintf(fp, ";\n");
 	}
 
 	if (options->listens != NULL) {
-		dns_c_lstnlist_print(lctx, fp, indent + 1,
+		dns_c_lstnlist_print(fp, indent + 1,
 				     options->listens);
 	}
 	
-	dns_c_ctx_forwarderprint(lctx, fp, indent + 1, options);
+	dns_c_ctx_forwarderprint(fp, indent + 1, options);
 
 	if (options->ordering != NULL) {
-		dns_c_rrsolist_print(lctx, fp, indent + 1, options->ordering);
+		dns_c_rrsolist_print(fp, indent + 1, options->ordering);
 	}
 	
 
-	dns_c_printtabs(lctx, fp, indent);
+	dns_c_printtabs(fp, indent);
 	fprintf(fp,"};\n");
 }
 
 
 isc_boolean_t
-dns_c_ctx_keydefinedp(isc_log_t *lctx,
-		      dns_c_ctx_t *ctx, const char *keyname)
+dns_c_ctx_keydefinedp(dns_c_ctx_t *ctx, const char *keyname)
 {
 	dns_c_kdef_t *keyid;
 	isc_result_t res;
@@ -3473,7 +3300,7 @@ dns_c_ctx_keydefinedp(isc_log_t *lctx,
 	REQUIRE(strlen(keyname) > 0);
 	
 	if (ctx->keydefs != NULL) {
-		res = dns_c_kdeflist_find(lctx, ctx->keydefs, keyname, &keyid);
+		res = dns_c_kdeflist_find(ctx->keydefs, keyname, &keyid);
 		if (res == ISC_R_SUCCESS) {
 			rval = ISC_TRUE;
 		}
@@ -3489,14 +3316,11 @@ dns_c_ctx_keydefinedp(isc_log_t *lctx,
 
 
 static isc_result_t
-cfg_set_string(isc_log_t *lctx,
-	       dns_c_options_t *options, char **field, const char *newval)
+cfg_set_string(dns_c_options_t *options, char **field, const char *newval)
 {
 	char *p;
 	isc_boolean_t existed = ISC_FALSE;
 
-	(void) lctx;
-	
 	REQUIRE(DNS_C_CONFOPT_VALID(options));
 	REQUIRE(field != NULL);
 
@@ -3535,8 +3359,7 @@ cfg_set_string(isc_log_t *lctx,
 
 /* XXX This can get removed and replaced with set_ipmatch_list_field */
 static isc_result_t
-cfg_set_iplist(isc_log_t *lctx,
-	       dns_c_options_t *options,
+cfg_set_iplist(dns_c_options_t *options,
 	       dns_c_ipmatchlist_t **fieldaddr,
 	       dns_c_ipmatchlist_t *newval,
 	       isc_boolean_t copy)
@@ -3552,23 +3375,22 @@ cfg_set_iplist(isc_log_t *lctx,
 	}
 	
 	if (newval == NULL) {
-		res = dns_c_ipmatchlist_new(lctx, options->mem, fieldaddr);
+		res = dns_c_ipmatchlist_new(options->mem, fieldaddr);
 	} else if (copy) {
 		if (*fieldaddr != NULL) {
-			res = dns_c_ipmatchlist_empty(lctx, *fieldaddr);
+			res = dns_c_ipmatchlist_empty(*fieldaddr);
 			if (res == ISC_R_SUCCESS && newval != NULL) {
-				res = dns_c_ipmatchlist_append(lctx,
-							       *fieldaddr,
+				res = dns_c_ipmatchlist_append(*fieldaddr,
 							       newval,
 							       ISC_FALSE);
 			}
 		} else {
-			res = dns_c_ipmatchlist_copy(lctx, options->mem,
+			res = dns_c_ipmatchlist_copy(options->mem,
 						     fieldaddr, newval);
 		}
 	} else {
 		if (*fieldaddr != NULL) {
-			res = dns_c_ipmatchlist_detach(lctx, fieldaddr);
+			res = dns_c_ipmatchlist_detach(fieldaddr);
 			if (res != ISC_R_SUCCESS) {
 				return (res);
 			}
@@ -3588,8 +3410,7 @@ cfg_set_iplist(isc_log_t *lctx,
 
 
 static isc_result_t
-cfg_set_boolean(isc_log_t *lctx,
-		dns_c_options_t *options,
+cfg_set_boolean(dns_c_options_t *options,
 		isc_boolean_t *fieldaddr,
 		isc_boolean_t newval,
 		dns_c_setbits_t *setfield,
@@ -3597,8 +3418,6 @@ cfg_set_boolean(isc_log_t *lctx,
 {
 	isc_boolean_t existed;
 
-	(void) lctx;
-	
 	REQUIRE(DNS_C_CONFOPT_VALID(options));
 	REQUIRE(setfield != NULL);
 	REQUIRE(fieldaddr != NULL);
@@ -3614,8 +3433,7 @@ cfg_set_boolean(isc_log_t *lctx,
 
 
 static isc_result_t
-cfg_set_int32(isc_log_t *lctx,
-	      dns_c_options_t *options,
+cfg_set_int32(dns_c_options_t *options,
 	      isc_int32_t *fieldaddr,
 	      isc_int32_t newval,
 	      dns_c_setbits_t *setfield,
@@ -3623,8 +3441,6 @@ cfg_set_int32(isc_log_t *lctx,
 {
 	isc_boolean_t existed;
 
-	(void) lctx;
-	
 	REQUIRE(DNS_C_CONFOPT_VALID(options));
 	REQUIRE(setfield != NULL);
 	REQUIRE(fieldaddr != NULL);
@@ -3640,8 +3456,7 @@ cfg_set_int32(isc_log_t *lctx,
 
 
 static isc_result_t
-cfg_set_uint32(isc_log_t *lctx,
-	       dns_c_options_t *options,
+cfg_set_uint32(dns_c_options_t *options,
 	       isc_uint32_t *fieldaddr,
 	       isc_uint32_t newval,
 	       dns_c_setbits_t *setfield,
@@ -3649,8 +3464,6 @@ cfg_set_uint32(isc_log_t *lctx,
 {
 	isc_boolean_t existed;
 
-	(void) lctx;
-	
 	REQUIRE(DNS_C_CONFOPT_VALID(options));
 	REQUIRE(setfield != NULL);
 	REQUIRE(fieldaddr != NULL);
@@ -3666,15 +3479,12 @@ cfg_set_uint32(isc_log_t *lctx,
 
 
 static isc_result_t
-cfg_get_iplist(isc_log_t *lctx,
-	       dns_c_options_t *options,
+cfg_get_iplist(dns_c_options_t *options,
 	       dns_c_ipmatchlist_t *field,
 	       dns_c_ipmatchlist_t **resval)
 {
 	isc_result_t res;
 
-	(void) lctx;
-	
 	REQUIRE(DNS_C_CONFOPT_VALID(options));
 	REQUIRE(resval != NULL);
 
@@ -3691,8 +3501,7 @@ cfg_get_iplist(isc_log_t *lctx,
 
 
 static isc_result_t
-cfg_get_boolean(isc_log_t *lctx,
-		dns_c_options_t *options,
+cfg_get_boolean(dns_c_options_t *options,
 		isc_boolean_t *field,
 		isc_boolean_t *result,
 		dns_c_setbits_t *setfield,
@@ -3700,8 +3509,6 @@ cfg_get_boolean(isc_log_t *lctx,
 {
 	isc_result_t res;
 
-	(void) lctx;
-	
 	REQUIRE(DNS_C_CONFOPT_VALID(options));
 	REQUIRE(result != NULL);
 	REQUIRE(field != NULL);
@@ -3720,8 +3527,7 @@ cfg_get_boolean(isc_log_t *lctx,
 
 
 static isc_result_t
-cfg_get_int32(isc_log_t *lctx,
-	      dns_c_options_t *options,
+cfg_get_int32(dns_c_options_t *options,
 	      isc_int32_t *field,
 	      isc_int32_t *result,
 	      dns_c_setbits_t *setfield,
@@ -3729,8 +3535,6 @@ cfg_get_int32(isc_log_t *lctx,
 {
 	isc_result_t res;
 
-	(void) lctx;
-	
 	REQUIRE(DNS_C_CONFOPT_VALID(options));
 	REQUIRE(result != NULL);
 	REQUIRE(field != NULL);
@@ -3749,8 +3553,7 @@ cfg_get_int32(isc_log_t *lctx,
 
 
 static isc_result_t
-cfg_get_uint32(isc_log_t *lctx,
-	       dns_c_options_t *options,
+cfg_get_uint32(dns_c_options_t *options,
 	       isc_uint32_t *field,
 	       isc_uint32_t *result,
 	       dns_c_setbits_t *setfield,
@@ -3758,8 +3561,6 @@ cfg_get_uint32(isc_log_t *lctx,
 {
 	isc_result_t res;
 
-	(void) lctx;
-	
 	REQUIRE(DNS_C_CONFOPT_VALID(options));
 	REQUIRE(result != NULL);
 	REQUIRE(field != NULL);
@@ -3778,8 +3579,7 @@ cfg_get_uint32(isc_log_t *lctx,
 
 
 static isc_result_t
-acl_init(isc_log_t *lctx,
-	 dns_c_ctx_t *cfg)
+acl_init(dns_c_ctx_t *cfg)
 {
 	dns_c_ipmatchelement_t *ime;
 	dns_c_ipmatchlist_t *iml;
@@ -3792,25 +3592,25 @@ acl_init(isc_log_t *lctx,
 
 	isc_sockaddr_fromin(&addr, &zeroaddr, 0);
 
-	r = dns_c_acltable_new(lctx, cfg->mem, &cfg->acls);
+	r = dns_c_acltable_new(cfg->mem, &cfg->acls);
 	if (r != ISC_R_SUCCESS) return (r);
 
 
 	/*
 	 * The ANY acl.
 	 */
-	r = dns_c_acl_new(lctx, cfg->acls, "any", ISC_TRUE, &acl);
+	r = dns_c_acl_new(cfg->acls, "any", ISC_TRUE, &acl);
 	if (r != ISC_R_SUCCESS) return (r);
 	
-	r = dns_c_ipmatchpattern_new(lctx, cfg->mem, &ime, addr, 0);
+	r = dns_c_ipmatchpattern_new(cfg->mem, &ime, addr, 0);
 	if (r != ISC_R_SUCCESS) return (r);
 	
-	r = dns_c_ipmatchlist_new(lctx, cfg->mem, &iml);
+	r = dns_c_ipmatchlist_new(cfg->mem, &iml);
 	if (r != ISC_R_SUCCESS) return (r);
 	
 	ISC_LIST_APPEND(iml->elements, ime, next);
 
-	dns_c_acl_setipml(lctx, acl, iml, ISC_FALSE);
+	dns_c_acl_setipml(acl, iml, ISC_FALSE);
 	iml = NULL;
 	
 
@@ -3818,56 +3618,56 @@ acl_init(isc_log_t *lctx,
 	 * The NONE acl
 	 */
 
-	r = dns_c_acl_new(lctx, cfg->acls, "none", ISC_TRUE, &acl);
+	r = dns_c_acl_new(cfg->acls, "none", ISC_TRUE, &acl);
 	if (r != ISC_R_SUCCESS) return (r);
 	
-	r = dns_c_ipmatchpattern_new(lctx, cfg->mem, &ime, addr, 0);
+	r = dns_c_ipmatchpattern_new(cfg->mem, &ime, addr, 0);
 	if (r != ISC_R_SUCCESS) return (r);
 
-	dns_c_ipmatch_negate(lctx, ime);
+	dns_c_ipmatch_negate(ime);
 
-	r = dns_c_ipmatchlist_new(lctx, cfg->mem, &iml);
+	r = dns_c_ipmatchlist_new(cfg->mem, &iml);
 	if (r != ISC_R_SUCCESS) return (r);
 	
 	ISC_LIST_APPEND(iml->elements, ime, next);
 	
-	dns_c_acl_setipml(lctx, acl, iml, ISC_FALSE);
+	dns_c_acl_setipml(acl, iml, ISC_FALSE);
 	iml = NULL;
 	
 
 	/*
 	 * The LOCALHOST acl
 	 */
-	r = dns_c_acl_new(lctx, cfg->acls, "localhost", ISC_TRUE, &acl);
+	r = dns_c_acl_new(cfg->acls, "localhost", ISC_TRUE, &acl);
 	if (r != ISC_R_SUCCESS) return (r);
 	
-	r = dns_c_ipmatchlocalhost_new(lctx, cfg->mem, &ime);
+	r = dns_c_ipmatchlocalhost_new(cfg->mem, &ime);
 	if (r != ISC_R_SUCCESS) return (r);
 
-	r = dns_c_ipmatchlist_new(lctx, cfg->mem, &iml);
+	r = dns_c_ipmatchlist_new(cfg->mem, &iml);
 	if (r != ISC_R_SUCCESS) return (r);
 	
 	ISC_LIST_APPEND(iml->elements, ime, next);
 
-	dns_c_acl_setipml(lctx, acl, iml, ISC_FALSE);
+	dns_c_acl_setipml(acl, iml, ISC_FALSE);
 	iml = NULL;
 	
 	
 	/*
 	 * The LOCALNETS acl
 	 */
-	r = dns_c_acl_new(lctx, cfg->acls, "localnets", ISC_TRUE, &acl);
+	r = dns_c_acl_new(cfg->acls, "localnets", ISC_TRUE, &acl);
 	if (r != ISC_R_SUCCESS) return (r);
 	
-	r = dns_c_ipmatchlocalnets_new(lctx, cfg->mem, &ime);
+	r = dns_c_ipmatchlocalnets_new(cfg->mem, &ime);
 	if (r != ISC_R_SUCCESS) return (r);
 	
-	r = dns_c_ipmatchlist_new(lctx, cfg->mem, &iml);
+	r = dns_c_ipmatchlist_new(cfg->mem, &iml);
 	if (r != ISC_R_SUCCESS) return (r);
 	
 	ISC_LIST_APPEND(iml->elements, ime, next);
 
-	dns_c_acl_setipml(lctx, acl, iml, ISC_FALSE);
+	dns_c_acl_setipml(acl, iml, ISC_FALSE);
 	iml = NULL;
 	
 	return (ISC_R_SUCCESS);
@@ -3876,8 +3676,7 @@ acl_init(isc_log_t *lctx,
 
 
 static isc_result_t
-logging_init (isc_log_t *lctx,
-	      dns_c_ctx_t *cfg)
+logging_init (dns_c_ctx_t *cfg)
 {
 	isc_result_t res;
 	dns_c_logcat_t *cat;
@@ -3886,92 +3685,92 @@ logging_init (isc_log_t *lctx,
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 	REQUIRE(cfg->logging == NULL);
 
-	res = dns_c_logginglist_new(lctx, cfg->mem, &cfg->logging);
+	res = dns_c_logginglist_new(cfg->mem, &cfg->logging);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
 
 	/* default_syslog channel */
 	chan = NULL;
-	res = dns_c_ctx_addsyslogchannel(lctx, cfg, DNS_C_DEFAULT_SYSLOG,
+	res = dns_c_ctx_addsyslogchannel(cfg, DNS_C_DEFAULT_SYSLOG,
 					 &chan);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
-	dns_c_logchan_setpredef(lctx, chan, ISC_TRUE);
-	dns_c_logchan_setfacility(lctx, chan, LOG_DAEMON);
-	dns_c_logchan_setseverity(lctx, chan, dns_c_log_info);
+	dns_c_logchan_setpredef(chan, ISC_TRUE);
+	dns_c_logchan_setfacility(chan, LOG_DAEMON);
+	dns_c_logchan_setseverity(chan, dns_c_log_info);
 
 	
 	/* default_debug channel */
 	chan = NULL;
-	res = dns_c_ctx_addfile_channel(lctx, cfg, DNS_C_DEFAULT_DEBUG, &chan);
+	res = dns_c_ctx_addfile_channel(cfg, DNS_C_DEFAULT_DEBUG, &chan);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
-	dns_c_logchan_setpredef(lctx, chan, ISC_TRUE);
-	dns_c_logchan_setpath(lctx, chan, DNS_C_DEFAULT_DEBUG_PATH);
-	dns_c_logchan_setseverity(lctx, chan, dns_c_log_dynamic);
+	dns_c_logchan_setpredef(chan, ISC_TRUE);
+	dns_c_logchan_setpath(chan, DNS_C_DEFAULT_DEBUG_PATH);
+	dns_c_logchan_setseverity(chan, dns_c_log_dynamic);
 
 
 	/* null channel */
 	chan = NULL;
-	res = dns_c_ctx_addnullchannel(lctx, cfg, DNS_C_NULL, &chan);
-	dns_c_logchan_setpredef(lctx, chan, ISC_TRUE);
+	res = dns_c_ctx_addnullchannel(cfg, DNS_C_NULL, &chan);
+	dns_c_logchan_setpredef(chan, ISC_TRUE);
 
 
 	/* default_stderr channel */
 	chan = NULL;
-	res = dns_c_ctx_addfile_channel(lctx, cfg, DNS_C_DEFAULT_STDERR,
+	res = dns_c_ctx_addfile_channel(cfg, DNS_C_DEFAULT_STDERR,
 					&chan);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
-	dns_c_logchan_setpredef(lctx, chan, ISC_TRUE);
-	dns_c_logchan_setpath(lctx, chan, DNS_C_STDERR_PATH);
-	dns_c_logchan_setseverity(lctx, chan, dns_c_log_info);
+	dns_c_logchan_setpredef(chan, ISC_TRUE);
+	dns_c_logchan_setpath(chan, DNS_C_STDERR_PATH);
+	dns_c_logchan_setseverity(chan, dns_c_log_info);
 
 
 	/* default category */
 	cat = NULL;
-	res = dns_c_ctx_addcategory(lctx, cfg, dns_c_cat_default, &cat);
+	res = dns_c_ctx_addcategory(cfg, dns_c_cat_default, &cat);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
-	dns_c_logcat_setpredef(lctx, cat, ISC_TRUE);
-	dns_c_logcat_addname(lctx, cat, DNS_C_DEFAULT_SYSLOG);
-	dns_c_logcat_addname(lctx, cat, DNS_C_DEFAULT_DEBUG);
+	dns_c_logcat_setpredef(cat, ISC_TRUE);
+	dns_c_logcat_addname(cat, DNS_C_DEFAULT_SYSLOG);
+	dns_c_logcat_addname(cat, DNS_C_DEFAULT_DEBUG);
 	
 
 	/* panic category */
 	cat = NULL;
-	res = dns_c_ctx_addcategory(lctx, cfg, dns_c_cat_panic, &cat);
+	res = dns_c_ctx_addcategory(cfg, dns_c_cat_panic, &cat);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
-	dns_c_logcat_setpredef(lctx, cat, ISC_TRUE);
-	dns_c_logcat_addname(lctx, cat, DNS_C_DEFAULT_SYSLOG);
-	dns_c_logcat_addname(lctx, cat, DNS_C_DEFAULT_DEBUG);
+	dns_c_logcat_setpredef(cat, ISC_TRUE);
+	dns_c_logcat_addname(cat, DNS_C_DEFAULT_SYSLOG);
+	dns_c_logcat_addname(cat, DNS_C_DEFAULT_DEBUG);
 
 	
 	/* eventlib category */
 	cat = NULL;
-	res = dns_c_ctx_addcategory(lctx, cfg, dns_c_cat_eventlib, &cat);
+	res = dns_c_ctx_addcategory(cfg, dns_c_cat_eventlib, &cat);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
-	dns_c_logcat_setpredef(lctx, cat, ISC_TRUE);
-	dns_c_logcat_addname(lctx, cat, DNS_C_DEFAULT_DEBUG);
+	dns_c_logcat_setpredef(cat, ISC_TRUE);
+	dns_c_logcat_addname(cat, DNS_C_DEFAULT_DEBUG);
 
 
 	/* packet category */
 	cat = NULL;
-	res = dns_c_ctx_addcategory(lctx, cfg, dns_c_cat_packet, &cat);
+	res = dns_c_ctx_addcategory(cfg, dns_c_cat_packet, &cat);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
-	dns_c_logcat_setpredef(lctx, cat, ISC_TRUE);
-	dns_c_logcat_addname(lctx, cat, DNS_C_DEFAULT_DEBUG);
+	dns_c_logcat_setpredef(cat, ISC_TRUE);
+	dns_c_logcat_addname(cat, DNS_C_DEFAULT_DEBUG);
 	
 	return (ISC_R_SUCCESS);
 }
@@ -3979,13 +3778,13 @@ logging_init (isc_log_t *lctx,
 
 
 static isc_result_t
-make_options(isc_log_t *lctx, dns_c_ctx_t *cfg)
+make_options(dns_c_ctx_t *cfg)
 {
 	isc_result_t res = ISC_R_SUCCESS;
 	REQUIRE(DNS_C_CONFCTX_VALID(cfg));
 
 	if (cfg->options == NULL) {
-		res = dns_c_ctx_optionsnew(lctx, cfg->mem, &cfg->options);
+		res = dns_c_ctx_optionsnew(cfg->mem, &cfg->options);
 		if (res != ISC_R_SUCCESS) {
 			return (res);
 		}
diff --git a/lib/dns/config/confip.c b/lib/dns/config/confip.c
index fe57631610..c06efc96e2 100644
--- a/lib/dns/config/confip.c
+++ b/lib/dns/config/confip.c
@@ -35,13 +35,10 @@ static isc_result_t checkmask(isc_sockaddr_t *address, isc_uint32_t bits);
 static isc_result_t bits2v6mask(struct in6_addr *addr, isc_uint32_t bits);
 
 isc_result_t
-dns_c_ipmatchelement_new(isc_log_t *lctx,
-			 isc_mem_t *mem, dns_c_ipmatchelement_t **result)
+dns_c_ipmatchelement_new(isc_mem_t *mem, dns_c_ipmatchelement_t **result)
 {
 	dns_c_ipmatchelement_t *ime ;
 
-	(void) lctx;
-	
 	REQUIRE(result != NULL);
 
 	*result = NULL;
@@ -65,12 +62,9 @@ dns_c_ipmatchelement_new(isc_log_t *lctx,
 
 
 isc_boolean_t
-dns_c_ipmatchelement_isneg(isc_log_t *lctx,
-			   dns_c_ipmatchelement_t *elem)
+dns_c_ipmatchelement_isneg(dns_c_ipmatchelement_t *elem)
 {
 
-	(void) lctx;
-
 	REQUIRE(DNS_C_IPMELEM_VALID(elem));
 	
 	return (ISC_TF((elem->flags & DNS_C_IPMATCH_NEGATE) ==
@@ -79,8 +73,7 @@ dns_c_ipmatchelement_isneg(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ipmatchelement_delete(isc_log_t *lctx,
-			    isc_mem_t *mem, dns_c_ipmatchelement_t **ipme)
+dns_c_ipmatchelement_delete(isc_mem_t *mem, dns_c_ipmatchelement_t **ipme)
 {
 	dns_c_ipmatchelement_t *elem;
 	
@@ -103,7 +96,7 @@ dns_c_ipmatchelement_delete(isc_log_t *lctx,
 		INSIST(elem->u.indirect.list != NULL);
 
 		if (elem->u.indirect.list != NULL)
-			dns_c_ipmatchlist_detach(lctx, &elem->u.indirect.list);
+			dns_c_ipmatchlist_detach(&elem->u.indirect.list);
 
 		if (elem->u.indirect.refname.base != NULL) {
 			isc_mem_put(mem, elem->u.indirect.refname.base,
@@ -120,7 +113,7 @@ dns_c_ipmatchelement_delete(isc_log_t *lctx,
 		break;
 		
 	case dns_c_ipmatch_none:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "dns_ipmath_none element type");
 		return (ISC_R_FAILURE);
@@ -135,8 +128,7 @@ dns_c_ipmatchelement_delete(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ipmatchelement_copy(isc_log_t *lctx,
-			  isc_mem_t *mem,
+dns_c_ipmatchelement_copy(isc_mem_t *mem,
 			  dns_c_ipmatchelement_t **dest,
 			  dns_c_ipmatchelement_t *src)
 {
@@ -147,7 +139,7 @@ dns_c_ipmatchelement_copy(isc_log_t *lctx,
 	REQUIRE(dest != NULL);
 	REQUIRE(DNS_C_IPMELEM_VALID(src));
 		
-	result = dns_c_ipmatchelement_new(lctx, mem, &newel);
+	result = dns_c_ipmatchelement_new(mem, &newel);
 	if (result != ISC_R_SUCCESS) {
 		return (result);
 	}
@@ -162,7 +154,7 @@ dns_c_ipmatchelement_copy(isc_log_t *lctx,
 		break;
 
 	case dns_c_ipmatch_indirect:
-		result = dns_c_ipmatchlist_copy(lctx, mem,
+		result = dns_c_ipmatchlist_copy(mem,
 						&newel->u.indirect.list,
 						src->u.indirect.list);
 		break;	
@@ -182,7 +174,7 @@ dns_c_ipmatchelement_copy(isc_log_t *lctx,
 		break;
 		
 	case dns_c_ipmatch_none:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "ipmatch 'none' element type");
 		return (ISC_R_FAILURE);
@@ -235,8 +227,7 @@ dns_c_ipmatchelement_equal(dns_c_ipmatchelement_t *e1,
 }
 
 isc_result_t
-dns_c_ipmatchlocalhost_new(isc_log_t *lctx,
-			   isc_mem_t *mem, dns_c_ipmatchelement_t **result)
+dns_c_ipmatchlocalhost_new(isc_mem_t *mem, dns_c_ipmatchelement_t **result)
 {
 	dns_c_ipmatchelement_t *ime = NULL;
 	isc_result_t res;
@@ -246,7 +237,7 @@ dns_c_ipmatchlocalhost_new(isc_log_t *lctx,
 
 	*result = NULL;
 
-	res = dns_c_ipmatchelement_new(lctx, mem, &ime);
+	res = dns_c_ipmatchelement_new(mem, &ime);
 	if (res == ISC_R_SUCCESS) {
 		ime->type = dns_c_ipmatch_localhost;
 	}
@@ -258,8 +249,7 @@ dns_c_ipmatchlocalhost_new(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ipmatchlocalnets_new(isc_log_t *lctx,
-			   isc_mem_t *mem,
+dns_c_ipmatchlocalnets_new(isc_mem_t *mem,
 			   dns_c_ipmatchelement_t **result)
 {
 	dns_c_ipmatchelement_t *ime = NULL;
@@ -270,7 +260,7 @@ dns_c_ipmatchlocalnets_new(isc_log_t *lctx,
 
 	*result = NULL;
 
-	res = dns_c_ipmatchelement_new(lctx, mem, &ime);
+	res = dns_c_ipmatchelement_new(mem, &ime);
 	if (res == ISC_R_SUCCESS) {
 		ime->type = dns_c_ipmatch_localnets;
 	}
@@ -282,8 +272,7 @@ dns_c_ipmatchlocalnets_new(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ipmatchindirect_new(isc_log_t *lctx,
-			  isc_mem_t *mem,
+dns_c_ipmatchindirect_new(isc_mem_t *mem,
 			  dns_c_ipmatchelement_t **result,
 			  dns_c_ipmatchlist_t *iml,
 			  const char *name)
@@ -298,12 +287,12 @@ dns_c_ipmatchindirect_new(isc_log_t *lctx,
 
 	*result = NULL;
 
-	res = dns_c_ipmatchlist_copy(lctx, mem, &iml_copy, iml);
+	res = dns_c_ipmatchlist_copy(mem, &iml_copy, iml);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
 
-	res = dns_c_ipmatchelement_new(lctx, mem, &ime);
+	res = dns_c_ipmatchelement_new(mem, &ime);
 	if (res == ISC_R_SUCCESS) {
 		ime->type = dns_c_ipmatch_indirect;
 		ime->u.indirect.list = iml_copy;
@@ -316,7 +305,7 @@ dns_c_ipmatchindirect_new(isc_log_t *lctx,
 			strcpy(ime->u.indirect.refname.base, name);
 		}
 	} else {
-		dns_c_ipmatchlist_detach(lctx, &iml_copy);
+		dns_c_ipmatchlist_detach(&iml_copy);
 	}
 	
 	*result = ime;
@@ -326,8 +315,7 @@ dns_c_ipmatchindirect_new(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ipmatchpattern_new(isc_log_t *lctx,
-			 isc_mem_t *mem,
+dns_c_ipmatchpattern_new(isc_mem_t *mem,
 			 dns_c_ipmatchelement_t **result,
 			 isc_sockaddr_t address,
 			 isc_uint32_t maskbits)
@@ -346,7 +334,7 @@ dns_c_ipmatchpattern_new(isc_log_t *lctx,
 		return (res);
 	}
 
-	res = dns_c_ipmatchelement_new(lctx, mem, &ime);
+	res = dns_c_ipmatchelement_new(mem, &ime);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
@@ -362,8 +350,7 @@ dns_c_ipmatchpattern_new(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ipmatchkey_new(isc_log_t *lctx,
-		     isc_mem_t *mem,
+dns_c_ipmatchkey_new(isc_mem_t *mem,
 		     dns_c_ipmatchelement_t **result,
 		     const char *key)
 {
@@ -376,7 +363,7 @@ dns_c_ipmatchkey_new(isc_log_t *lctx,
 
 	*result = NULL;
 
-	res = dns_c_ipmatchelement_new(lctx, mem, &ipme);
+	res = dns_c_ipmatchelement_new(mem, &ipme);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
@@ -391,8 +378,7 @@ dns_c_ipmatchkey_new(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ipmatch_aclnew(isc_log_t *lctx,
-		     isc_mem_t *mem,
+dns_c_ipmatch_aclnew(isc_mem_t *mem,
 		     dns_c_ipmatchelement_t **result,
 		     const char *aclname)
 {
@@ -406,7 +392,7 @@ dns_c_ipmatch_aclnew(isc_log_t *lctx,
 
 	*result = NULL;
 
-	res = dns_c_ipmatchelement_new(lctx, mem, &ipme);
+	res = dns_c_ipmatchelement_new(mem, &ipme);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
@@ -421,13 +407,10 @@ dns_c_ipmatch_aclnew(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ipmatch_negate(isc_log_t *lctx,
-		     dns_c_ipmatchelement_t *ipe)
+dns_c_ipmatch_negate(dns_c_ipmatchelement_t *ipe)
 {
 	REQUIRE(DNS_C_IPMELEM_VALID(ipe));
-	
-	(void) lctx;
-	
+
 	if ((ipe->flags & DNS_C_IPMATCH_NEGATE) == DNS_C_IPMATCH_NEGATE) {
 		ipe->flags &= ~DNS_C_IPMATCH_NEGATE;
 	} else {
@@ -439,13 +422,10 @@ dns_c_ipmatch_negate(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ipmatchlist_new(isc_log_t *lctx,
-		      isc_mem_t *mem, dns_c_ipmatchlist_t **ptr)
+dns_c_ipmatchlist_new(isc_mem_t *mem, dns_c_ipmatchlist_t **ptr)
 {
 	dns_c_ipmatchlist_t *newlist;
 
-	(void) lctx;
-	
 	REQUIRE(ptr != NULL);
 	REQUIRE(mem != NULL);
 
@@ -467,8 +447,7 @@ dns_c_ipmatchlist_new(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ipmatchlist_detach(isc_log_t *lctx,
-			 dns_c_ipmatchlist_t **ml)
+dns_c_ipmatchlist_detach(dns_c_ipmatchlist_t **ml)
 {
 	dns_c_ipmatchelement_t *ime;
 	dns_c_ipmatchelement_t *iptr;
@@ -495,7 +474,7 @@ dns_c_ipmatchlist_detach(isc_log_t *lctx,
 	ime = ISC_LIST_HEAD(iml->elements);
 	while (ime != NULL) {
 		iptr = ISC_LIST_NEXT(ime, next);
-		dns_c_ipmatchelement_delete(lctx, mem, &ime);
+		dns_c_ipmatchelement_delete(mem, &ime);
 		
 		ime = iptr;
 	}
@@ -507,12 +486,10 @@ dns_c_ipmatchlist_detach(isc_log_t *lctx,
 
 
 void
-dns_c_ipmatchlist_attach(isc_log_t *lctx, dns_c_ipmatchlist_t *source,
+dns_c_ipmatchlist_attach(dns_c_ipmatchlist_t *source,
 			 dns_c_ipmatchlist_t **target)
 {
 
-	(void) lctx;
-
 	REQUIRE(DNS_C_IPMLIST_VALID(source));
 	
 	INSIST(source->refcount > 0);
@@ -523,8 +500,7 @@ dns_c_ipmatchlist_attach(isc_log_t *lctx, dns_c_ipmatchlist_t *source,
 
 
 isc_result_t
-dns_c_ipmatchlist_empty(isc_log_t *lctx,
-			dns_c_ipmatchlist_t *ipml)
+dns_c_ipmatchlist_empty(dns_c_ipmatchlist_t *ipml)
 {
 	dns_c_ipmatchelement_t *ime ;
 	dns_c_ipmatchelement_t *imptmp;
@@ -535,7 +511,7 @@ dns_c_ipmatchlist_empty(isc_log_t *lctx,
 	ime = ISC_LIST_HEAD(ipml->elements);
 	while (ime != NULL) {
 		imptmp = ISC_LIST_NEXT(ime, next);
-		res = dns_c_ipmatchelement_delete(lctx, ipml->mem, &ime);
+		res = dns_c_ipmatchelement_delete(ipml->mem, &ime);
 		if (res != ISC_R_SUCCESS) {
 			break;
 		}
@@ -547,7 +523,7 @@ dns_c_ipmatchlist_empty(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ipmatchlist_copy(isc_log_t *lctx, isc_mem_t *mem,
+dns_c_ipmatchlist_copy(isc_mem_t *mem,
 		       dns_c_ipmatchlist_t **dest, dns_c_ipmatchlist_t *src)
 {
 	dns_c_ipmatchelement_t *ime;
@@ -561,16 +537,16 @@ dns_c_ipmatchlist_copy(isc_log_t *lctx, isc_mem_t *mem,
 
 	*dest = NULL;
 
-	result = dns_c_ipmatchlist_new(lctx, mem, &newlist);
+	result = dns_c_ipmatchlist_new(mem, &newlist);
 	if (result != ISC_R_SUCCESS) {
 		return (result);
 	}
 
 	ime = ISC_LIST_HEAD(src->elements);
 	while (ime != NULL) {
-		result = dns_c_ipmatchelement_copy(lctx, mem, &ptr, ime);
+		result = dns_c_ipmatchelement_copy(mem, &ptr, ime);
 		if (result != ISC_R_SUCCESS) {
-			dns_c_ipmatchlist_detach(lctx, &newlist);
+			dns_c_ipmatchlist_detach(&newlist);
 			return (result);
 		}
 		
@@ -612,8 +588,7 @@ dns_c_ipmatchlist_equal(dns_c_ipmatchlist_t *l1, dns_c_ipmatchlist_t *l2) {
 
 
 isc_result_t
-dns_c_ipmatchlist_append(isc_log_t *lctx,
-			 dns_c_ipmatchlist_t *dest,
+dns_c_ipmatchlist_append(dns_c_ipmatchlist_t *dest,
 			 dns_c_ipmatchlist_t *src,
 			 isc_boolean_t negate)
 {
@@ -626,7 +601,7 @@ dns_c_ipmatchlist_append(isc_log_t *lctx,
 
 	ime = ISC_LIST_HEAD(src->elements);
 	while (ime != NULL) {
-		result = dns_c_ipmatchelement_copy(lctx, dest->mem,
+		result = dns_c_ipmatchelement_copy(dest->mem,
 						   &ime_copy,
 						   ime);
 		if (result != ISC_R_SUCCESS) {
@@ -634,7 +609,7 @@ dns_c_ipmatchlist_append(isc_log_t *lctx,
 		}
 
 		if (negate) {
-			dns_c_ipmatch_negate(lctx, ime_copy);
+			dns_c_ipmatch_negate(ime_copy);
 		}
 		
 		ISC_LIST_APPEND(dest->elements, ime_copy, next);
@@ -647,8 +622,7 @@ dns_c_ipmatchlist_append(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ipmatchelement_print(isc_log_t *lctx,
-			   FILE *fp, int indent,
+dns_c_ipmatchelement_print(FILE *fp, int indent,
 			   dns_c_ipmatchelement_t *ipme)
 {
 	int bits;
@@ -664,7 +638,7 @@ dns_c_ipmatchelement_print(isc_log_t *lctx,
 
 	switch (ipme->type) {
 	case dns_c_ipmatch_pattern:
-		dns_c_print_ipaddr(lctx, fp, &ipme->u.direct.address);
+		dns_c_print_ipaddr(fp, &ipme->u.direct.address);
 		
 		bits = ipme->u.direct.mask;
 		if (bits > 0) {
@@ -676,7 +650,7 @@ dns_c_ipmatchelement_print(isc_log_t *lctx,
 		if (ipme->u.indirect.refname.base != NULL) {
 			fprintf(fp, "%s", ipme->u.indirect.refname.base);
 		} else {
-			dns_c_ipmatchlist_print(lctx, fp, indent,
+			dns_c_ipmatchlist_print(fp, indent,
 						ipme->u.indirect.list);
 		}
 
@@ -695,7 +669,7 @@ dns_c_ipmatchelement_print(isc_log_t *lctx,
 		break;
 
 	case dns_c_ipmatch_none:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "dns_ipmatch_none element type");
 		return (ISC_R_FAILURE);
@@ -710,8 +684,7 @@ dns_c_ipmatchelement_print(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_ipmatchlist_print(isc_log_t *lctx,
-			FILE *fp, int indent, dns_c_ipmatchlist_t *ml)
+dns_c_ipmatchlist_print(FILE *fp, int indent, dns_c_ipmatchlist_t *ml)
 {
 	dns_c_ipmatchelement_t *ipme ;
 
@@ -722,20 +695,20 @@ dns_c_ipmatchlist_print(isc_log_t *lctx,
 	fprintf(fp, "{\n");
 	ipme = ISC_LIST_HEAD(ml->elements);
 	if (ipme == NULL) {
-		dns_c_printtabs(lctx, fp, indent);
+		dns_c_printtabs(fp, indent);
 		fprintf(fp,
 			"/* this list intentionally left blank */\n");
 	} else {
 		while (ipme != NULL) {
-			dns_c_printtabs(lctx, fp, indent);
-			dns_c_ipmatchelement_print(lctx, fp, indent + 1, ipme);
+			dns_c_printtabs(fp, indent);
+			dns_c_ipmatchelement_print(fp, indent + 1, ipme);
 			fprintf(fp, ";\n");
 			
 			ipme = ISC_LIST_NEXT(ipme, next);
 		}
 	}
 	
-	dns_c_printtabs(lctx, fp, indent - 1);
+	dns_c_printtabs(fp, indent - 1);
 	fprintf(fp, "}");
 
 	return (ISC_R_SUCCESS);
@@ -743,14 +716,11 @@ dns_c_ipmatchlist_print(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_iplist_new(isc_log_t *lctx,
-		 isc_mem_t *mem, int length, dns_c_iplist_t **newlist)
+dns_c_iplist_new(isc_mem_t *mem, int length, dns_c_iplist_t **newlist)
 {
 	dns_c_iplist_t *list;
 	size_t bytes;
 
-	(void) lctx;
-	
 	REQUIRE(mem != NULL);
 	REQUIRE(length > 0);
 	REQUIRE(newlist != NULL);
@@ -782,13 +752,10 @@ dns_c_iplist_new(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_iplist_detach(isc_log_t *lctx,
-		    dns_c_iplist_t **list)
+dns_c_iplist_detach(dns_c_iplist_t **list)
 {
 	dns_c_iplist_t *l ;
 
-	(void) lctx;
-	
 	REQUIRE(list != NULL);
 	REQUIRE(*list != NULL);
 	
@@ -811,11 +778,9 @@ dns_c_iplist_detach(isc_log_t *lctx,
 
 
 void
-dns_c_iplist_attach(isc_log_t *lctx, dns_c_iplist_t *source,
+dns_c_iplist_attach(dns_c_iplist_t *source,
 		    dns_c_iplist_t **target)
 {
-	(void) lctx;
-
 	REQUIRE(DNS_C_IPLIST_VALID(source));
 	INSIST(source->refcount > 0);
 
@@ -826,8 +791,7 @@ dns_c_iplist_attach(isc_log_t *lctx, dns_c_iplist_t *source,
 
 
 isc_result_t
-dns_c_iplist_copy(isc_log_t *lctx,
-		  isc_mem_t *mem, dns_c_iplist_t **dest, dns_c_iplist_t *src)
+dns_c_iplist_copy(isc_mem_t *mem, dns_c_iplist_t **dest, dns_c_iplist_t *src)
 {
 	dns_c_iplist_t *newl;
 	isc_result_t res;
@@ -836,7 +800,7 @@ dns_c_iplist_copy(isc_log_t *lctx,
 	REQUIRE(dest != NULL);
 	REQUIRE(DNS_C_IPLIST_VALID(src));
 
-	res = dns_c_iplist_new(lctx, mem, src->size, &newl);
+	res = dns_c_iplist_new(mem, src->size, &newl);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
@@ -871,8 +835,7 @@ dns_c_iplist_equal(dns_c_iplist_t *list1, dns_c_iplist_t *list2) {
 
 
 void
-dns_c_iplist_print(isc_log_t *lctx,
-		   FILE *fp, int indent, dns_c_iplist_t *list)
+dns_c_iplist_print(FILE *fp, int indent, dns_c_iplist_t *list)
 {
 	isc_uint32_t i;
 
@@ -881,29 +844,26 @@ dns_c_iplist_print(isc_log_t *lctx,
 	fprintf(fp, "{\n");
 
 	if (list->nextidx == 0) {
-		dns_c_printtabs(lctx, fp, indent);
+		dns_c_printtabs(fp, indent);
 		fprintf(fp, "/* no ip addresses defined */\n");
 	} else {
 		for (i = 0 ; i < list->nextidx ; i++) {
-			dns_c_printtabs(lctx, fp, indent);
-			dns_c_print_ipaddr(lctx, fp, &list->ips[i]);
+			dns_c_printtabs(fp, indent);
+			dns_c_print_ipaddr(fp, &list->ips[i]);
 			fprintf(fp, ";\n");
 		}
 	}
 	
-	dns_c_printtabs(lctx, fp, indent - 1);
+	dns_c_printtabs(fp, indent - 1);
 	fprintf(fp, "};\n");
 }
 
 
 isc_result_t
-dns_c_iplist_append(isc_log_t *lctx,
-		    dns_c_iplist_t *list, isc_sockaddr_t newaddr)
+dns_c_iplist_append(dns_c_iplist_t *list, isc_sockaddr_t newaddr)
 {
 	isc_uint32_t i;
 
-	(void) lctx;
-	
 	REQUIRE(DNS_C_IPLIST_VALID(list));
 
 	for (i = 0 ; i < list->nextidx ; i++) {
@@ -944,13 +904,10 @@ dns_c_iplist_append(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_iplist_remove(isc_log_t *lctx,
-		    dns_c_iplist_t *list, isc_sockaddr_t newaddr)
+dns_c_iplist_remove(dns_c_iplist_t *list, isc_sockaddr_t newaddr)
 {
 	isc_uint32_t i;
 
-	(void) lctx;
-	
 	REQUIRE(DNS_C_IPLIST_VALID(list));
 	
 	for (i = 0 ; i < list->nextidx ; i++) {
diff --git a/lib/dns/config/confkeys.c b/lib/dns/config/confkeys.c
index 2fd1e23d61..d111225be2 100644
--- a/lib/dns/config/confkeys.c
+++ b/lib/dns/config/confkeys.c
@@ -26,17 +26,14 @@
 #include <dns/confkeys.h>
 #include <dns/confcommon.h>
 
-static isc_result_t keyid_delete(isc_log_t *lctx, dns_c_kid_t **ki);
+static isc_result_t keyid_delete(dns_c_kid_t **ki);
 
 
 isc_result_t
-dns_c_kdeflist_new(isc_log_t *lctx,
-		   isc_mem_t *mem, dns_c_kdeflist_t **list)
+dns_c_kdeflist_new(isc_mem_t *mem, dns_c_kdeflist_t **list)
 {
 	dns_c_kdeflist_t *newlist;
 
-	(void)lctx;
-
 	REQUIRE(mem != NULL);
 	REQUIRE(list != NULL);
 
@@ -57,8 +54,7 @@ dns_c_kdeflist_new(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_kdeflist_delete(isc_log_t *lctx,
-		      dns_c_kdeflist_t **list)
+dns_c_kdeflist_delete(dns_c_kdeflist_t **list)
 {
 	dns_c_kdeflist_t *l;
 	dns_c_kdef_t *kd;
@@ -74,7 +70,7 @@ dns_c_kdeflist_delete(isc_log_t *lctx,
 	while (kd != NULL) {
 		tmpkd = ISC_LIST_NEXT(kd, next);
 		ISC_LIST_UNLINK(l->keydefs, kd, next);
-		res = dns_c_kdef_delete(lctx, &kd);
+		res = dns_c_kdef_delete(&kd);
 		if (res != ISC_R_SUCCESS) {
 			return (res);
 		}
@@ -91,8 +87,7 @@ dns_c_kdeflist_delete(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_kdeflist_copy(isc_log_t *lctx,
-		    isc_mem_t *mem, dns_c_kdeflist_t **dest,
+dns_c_kdeflist_copy(isc_mem_t *mem, dns_c_kdeflist_t **dest,
 		    dns_c_kdeflist_t *src)
 {
 	dns_c_kdeflist_t *newlist;
@@ -102,16 +97,16 @@ dns_c_kdeflist_copy(isc_log_t *lctx,
 	REQUIRE(dest != NULL);
 	REQUIRE(DNS_C_KDEFLIST_VALID(src));
 	
-	res = dns_c_kdeflist_new(lctx, mem, &newlist);
+	res = dns_c_kdeflist_new(mem, &newlist);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
 	
 	key = ISC_LIST_HEAD(src->keydefs);
 	while (key != NULL) {
-		res = dns_c_kdeflist_append(lctx, newlist, key, ISC_TRUE);
+		res = dns_c_kdeflist_append(newlist, key, ISC_TRUE);
 		if (res != ISC_R_SUCCESS) {
-			dns_c_kdeflist_delete(lctx, &newlist);
+			dns_c_kdeflist_delete(&newlist);
 			return (res);
 		}
 		
@@ -125,7 +120,7 @@ dns_c_kdeflist_copy(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_kdeflist_append(isc_log_t *lctx, dns_c_kdeflist_t *list,
+dns_c_kdeflist_append(dns_c_kdeflist_t *list,
 		      dns_c_kdef_t *key, isc_boolean_t copy)
 {
 	dns_c_kdef_t *newe;
@@ -135,7 +130,7 @@ dns_c_kdeflist_append(isc_log_t *lctx, dns_c_kdeflist_t *list,
 	REQUIRE(DNS_C_KDEF_VALID(key));
 
 	if (copy) {
-		res = dns_c_kdef_copy(lctx, list->mem, &newe, key);
+		res = dns_c_kdef_copy(list->mem, &newe, key);
 		if (res != ISC_R_SUCCESS) {
 			return (res);
 		}
@@ -151,8 +146,7 @@ dns_c_kdeflist_append(isc_log_t *lctx, dns_c_kdeflist_t *list,
 
 
 isc_result_t
-dns_c_kdeflist_undef(isc_log_t *lctx,
-		     dns_c_kdeflist_t *list, const char *keyid)
+dns_c_kdeflist_undef(dns_c_kdeflist_t *list, const char *keyid)
 {
 	dns_c_kdef_t *kd;
 	isc_result_t r;
@@ -171,7 +165,7 @@ dns_c_kdeflist_undef(isc_log_t *lctx,
 
 	if (kd != NULL) {
 		ISC_LIST_UNLINK(list->keydefs, kd, next);
-		(void)dns_c_kdef_delete(lctx, &kd);
+		(void)dns_c_kdef_delete(&kd);
 		r = ISC_R_SUCCESS;
 	} else {
 		r = ISC_R_NOTFOUND;
@@ -182,15 +176,12 @@ dns_c_kdeflist_undef(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_kdeflist_find(isc_log_t *lctx,
-		    dns_c_kdeflist_t *list, const char *keyid,
+dns_c_kdeflist_find(dns_c_kdeflist_t *list, const char *keyid,
 		    dns_c_kdef_t **retval)
 {
 	dns_c_kdef_t *kd;
 	isc_result_t r;
 
-	(void)lctx;
-
 	REQUIRE(DNS_C_KDEFLIST_VALID(list));
 	REQUIRE(keyid != NULL);
 	REQUIRE(strlen(keyid) > 0);
@@ -216,8 +207,7 @@ dns_c_kdeflist_find(isc_log_t *lctx,
 
 
 void
-dns_c_kdeflist_print(isc_log_t *lctx,
-		     FILE *fp, int indent, dns_c_kdeflist_t *list)
+dns_c_kdeflist_print(FILE *fp, int indent, dns_c_kdeflist_t *list)
 {
 	dns_c_kdef_t *kd;
 
@@ -231,7 +221,7 @@ dns_c_kdeflist_print(isc_log_t *lctx,
 	
 	kd = ISC_LIST_HEAD(list->keydefs);
 	while (kd != NULL) {
-		dns_c_kdef_print(lctx, fp, indent, kd);
+		dns_c_kdef_print(fp, indent, kd);
 		fprintf(fp, "\n");
 		kd = ISC_LIST_NEXT(kd, next);
 	}
@@ -239,14 +229,11 @@ dns_c_kdeflist_print(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_kdef_new(isc_log_t *lctx,
-	       dns_c_kdeflist_t *list, const char *name,
+dns_c_kdef_new(dns_c_kdeflist_t *list, const char *name,
 	       dns_c_kdef_t **keyid)
 {
 	dns_c_kdef_t *kd;
 
-	(void)lctx;
-
 	REQUIRE(DNS_C_KDEFLIST_VALID(list));
 	REQUIRE(keyid != NULL);
 	REQUIRE(name != NULL);
@@ -276,13 +263,11 @@ dns_c_kdef_new(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_kdef_delete(isc_log_t *lctx, dns_c_kdef_t **keydef)
+dns_c_kdef_delete(dns_c_kdef_t **keydef)
 {
 	dns_c_kdef_t *kd;
 	isc_mem_t *mem;
 
-	(void)lctx;
-
 	REQUIRE(keydef != NULL);
 	REQUIRE(DNS_C_KDEF_VALID(*keydef));
 
@@ -316,7 +301,7 @@ dns_c_kdef_delete(isc_log_t *lctx, dns_c_kdef_t **keydef)
 }
 
 isc_result_t
-dns_c_kdef_copy(isc_log_t *lctx, isc_mem_t *mem,
+dns_c_kdef_copy(isc_mem_t *mem,
 		dns_c_kdef_t **dest, dns_c_kdef_t *src)
 {
 	dns_c_kdef_t *newk;
@@ -333,19 +318,19 @@ dns_c_kdef_copy(isc_log_t *lctx, isc_mem_t *mem,
 	
 	newk->keyid = isc_mem_strdup(mem, src->keyid);
 	if (newk->keyid == NULL) {
-		dns_c_kdef_delete(lctx, &newk);
+		dns_c_kdef_delete(&newk);
 		return (ISC_R_NOMEMORY);
 	}
 	
 	newk->algorithm = isc_mem_strdup(mem, src->algorithm);
 	if (newk->algorithm == NULL) {
-		dns_c_kdef_delete(lctx, &newk);
+		dns_c_kdef_delete(&newk);
 		return (ISC_R_NOMEMORY);
 	}
 		
 	newk->secret = isc_mem_strdup(mem, src->secret);
 	if (newk->secret == NULL) {
-		dns_c_kdef_delete(lctx, &newk);
+		dns_c_kdef_delete(&newk);
 		return (ISC_R_NOMEMORY);
 	}
 
@@ -357,38 +342,34 @@ dns_c_kdef_copy(isc_log_t *lctx, isc_mem_t *mem,
 		
 
 void
-dns_c_kdef_print(isc_log_t *lctx,
-		 FILE *fp, int indent, dns_c_kdef_t *keydef)
+dns_c_kdef_print(FILE *fp, int indent, dns_c_kdef_t *keydef)
 {
 	const char *quote = "";
 	
 	REQUIRE(fp != NULL);
 	REQUIRE(DNS_C_KDEF_VALID(keydef));
 
-	if (dns_c_need_quote(lctx, keydef->keyid)) {
+	if (dns_c_need_quote(keydef->keyid)) {
 		quote = "\"";
 	}
 
-	dns_c_printtabs(lctx, fp, indent);
+	dns_c_printtabs(fp, indent);
 	fprintf(fp, "key %s%s%s {\n",quote, keydef->keyid, quote);
 
-	dns_c_printtabs(lctx, fp, indent + 1);
+	dns_c_printtabs(fp, indent + 1);
 	fprintf(fp, "algorithm \"%s\";\n",keydef->algorithm);
 
-	dns_c_printtabs(lctx, fp, indent + 1);
+	dns_c_printtabs(fp, indent + 1);
 	fprintf(fp, "secret \"%s\";\n",keydef->secret);
 
-	dns_c_printtabs(lctx, fp, indent);
+	dns_c_printtabs(fp, indent);
 	fprintf(fp, "};\n");
 }
 
 
 isc_result_t
-dns_c_kdef_setalgorithm(isc_log_t *lctx,
-			dns_c_kdef_t *keydef, const char *algorithm)
+dns_c_kdef_setalgorithm(dns_c_kdef_t *keydef, const char *algorithm)
 {
-	(void)lctx;
-	
 	REQUIRE(DNS_C_KDEF_VALID(keydef));
 	REQUIRE(algorithm != NULL);
 	REQUIRE(strlen(algorithm) > 0);
@@ -408,11 +389,8 @@ dns_c_kdef_setalgorithm(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_kdef_setsecret(isc_log_t *lctx,
-		     dns_c_kdef_t *keydef, const char *secret)
+dns_c_kdef_setsecret(dns_c_kdef_t *keydef, const char *secret)
 {
-	(void)lctx;
-	
 	REQUIRE(DNS_C_KDEF_VALID(keydef));
 	REQUIRE(secret != NULL);
 	REQUIRE(strlen(secret) > 0);
@@ -432,13 +410,10 @@ dns_c_kdef_setsecret(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_kidlist_new(isc_log_t *lctx,
-		  isc_mem_t *mem, dns_c_kidlist_t **list)
+dns_c_kidlist_new(isc_mem_t *mem, dns_c_kidlist_t **list)
 {
 	dns_c_kidlist_t *l;
 
-	(void)lctx;
-
 	l = isc_mem_get(mem, sizeof *l);
 	if (l == NULL) {
 		return (ISC_R_NOMEMORY);
@@ -455,8 +430,7 @@ dns_c_kidlist_new(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_kidlist_delete(isc_log_t *lctx,
-		     dns_c_kidlist_t **list)
+dns_c_kidlist_delete(dns_c_kidlist_t **list)
 {
 	dns_c_kidlist_t *l;
 	dns_c_kid_t *ki, *tmpki;
@@ -471,7 +445,7 @@ dns_c_kidlist_delete(isc_log_t *lctx,
 	while (ki != NULL) {
 		tmpki = ISC_LIST_NEXT(ki, next);
 		ISC_LIST_UNLINK(l->keyids, ki, next);
-		r = keyid_delete(lctx, &ki);
+		r = keyid_delete(&ki);
 		if (r != ISC_R_SUCCESS) {
 			return (r);
 		}
@@ -488,13 +462,10 @@ dns_c_kidlist_delete(isc_log_t *lctx,
 
 
 static isc_result_t
-keyid_delete(isc_log_t *lctx,
-	     dns_c_kid_t **keyid)
+keyid_delete(dns_c_kid_t **keyid)
 {
 	dns_c_kid_t *ki;
 
-	(void)lctx;
-
 	REQUIRE(keyid != NULL);
 	REQUIRE(DNS_C_KEYID_VALID(*keyid));
 	
@@ -512,8 +483,7 @@ keyid_delete(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_kidlist_undef(isc_log_t *lctx,
-		    dns_c_kidlist_t *list, const char *keyid)
+dns_c_kidlist_undef(dns_c_kidlist_t *list, const char *keyid)
 {
 	dns_c_kid_t *ki;
 	isc_result_t r;
@@ -522,11 +492,11 @@ dns_c_kidlist_undef(isc_log_t *lctx,
 	REQUIRE(keyid != NULL);
 	REQUIRE(strlen(keyid) > 0);
 	
-	dns_c_kidlist_find(lctx, list, keyid, &ki);
+	dns_c_kidlist_find(list, keyid, &ki);
 	
 	if (ki != NULL) {
 		ISC_LIST_UNLINK(list->keyids, ki, next);
-		r = keyid_delete(lctx, &ki);
+		r = keyid_delete(&ki);
 	} else {
 		r = ISC_R_SUCCESS;
 	}
@@ -536,14 +506,11 @@ dns_c_kidlist_undef(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_kidlist_find(isc_log_t *lctx,
-		   dns_c_kidlist_t *list, const char *keyid,
+dns_c_kidlist_find(dns_c_kidlist_t *list, const char *keyid,
 		   dns_c_kid_t **retval)
 {
 	dns_c_kid_t *iter;
 
-	(void)lctx;
-
 	REQUIRE(DNS_C_KEYIDLIST_VALID(list));
 	REQUIRE(keyid != NULL);
 	REQUIRE(strlen(keyid) > 0);
@@ -565,7 +532,7 @@ dns_c_kidlist_find(isc_log_t *lctx,
 
 
 void
-dns_c_kidlist_print(isc_log_t *lctx, FILE *fp, int indent,
+dns_c_kidlist_print(FILE *fp, int indent,
 		    dns_c_kidlist_t *list)
 {
 	dns_c_kid_t *iter;
@@ -578,38 +545,35 @@ dns_c_kidlist_print(isc_log_t *lctx, FILE *fp, int indent,
 		return;
 	}
 
-	dns_c_printtabs(lctx, fp, indent);
+	dns_c_printtabs(fp, indent);
 	fprintf(fp, "keys {\n");
 	iter = ISC_LIST_HEAD(list->keyids);
 	if (iter == NULL) {
-		dns_c_printtabs(lctx, fp, indent + 1);
+		dns_c_printtabs(fp, indent + 1);
 		fprintf(fp, "/* no keys defined */\n");
 	} else {
 		while (iter != NULL) {
-			if (dns_c_need_quote(lctx, iter->keyid)) {
+			if (dns_c_need_quote(iter->keyid)) {
 				quote = "\"";
 			} else {
 				quote = "";
 			}
-			dns_c_printtabs(lctx, fp, indent + 1);
+			dns_c_printtabs(fp, indent + 1);
 			fprintf(fp, "%s%s%s;\n", quote, iter->keyid, quote);
 			iter = ISC_LIST_NEXT(iter, next);
 		}
 	}
 	
-	dns_c_printtabs(lctx, fp, indent);
+	dns_c_printtabs(fp, indent);
 	fprintf(fp, "};\n");
 }
 
 
 isc_result_t
-dns_c_kid_new(isc_log_t *lctx,
-	      dns_c_kidlist_t *list, const char *name, dns_c_kid_t **keyid)
+dns_c_kid_new(dns_c_kidlist_t *list, const char *name, dns_c_kid_t **keyid)
 {
 	dns_c_kid_t *ki;
 
-	(void)lctx;
-
 	REQUIRE(DNS_C_KEYIDLIST_VALID(list));
 	REQUIRE(name != NULL);
 	REQUIRE(strlen(name) > 0);
@@ -633,12 +597,10 @@ dns_c_kid_new(isc_log_t *lctx,
 }
 
 isc_result_t
-dns_c_pklist_new(isc_log_t *lctx, isc_mem_t *mem, dns_c_pklist_t **pklist)
+dns_c_pklist_new(isc_mem_t *mem, dns_c_pklist_t **pklist)
 {
 	dns_c_pklist_t *newl;
 
-	(void) lctx;
-
 	REQUIRE(pklist != NULL);
 
 	newl = isc_mem_get(mem, sizeof *newl);
@@ -658,7 +620,7 @@ dns_c_pklist_new(isc_log_t *lctx, isc_mem_t *mem, dns_c_pklist_t **pklist)
 
 	
 isc_result_t
-dns_c_pklist_delete(isc_log_t *lctx, dns_c_pklist_t **list)
+dns_c_pklist_delete(dns_c_pklist_t **list)
 {
 	dns_c_pklist_t *l;
 	dns_c_pubkey_t *pk;
@@ -674,7 +636,7 @@ dns_c_pklist_delete(isc_log_t *lctx, dns_c_pklist_t **list)
 	while (pk != NULL) {
 		tmppk = ISC_LIST_NEXT(pk, next);
 		ISC_LIST_UNLINK(l->keylist, pk, next);
-		r = dns_c_pubkey_delete(lctx, &pk);
+		r = dns_c_pubkey_delete(&pk);
 		if (r != ISC_R_SUCCESS) {
 			return (r);
 		}
@@ -691,8 +653,7 @@ dns_c_pklist_delete(isc_log_t *lctx, dns_c_pklist_t **list)
 
 
 void
-dns_c_pklist_print(isc_log_t *lctx,
-		   FILE *fp, int indent, dns_c_pklist_t *list)
+dns_c_pklist_print(FILE *fp, int indent, dns_c_pklist_t *list)
 {
 	dns_c_pubkey_t *pk;
 
@@ -707,7 +668,7 @@ dns_c_pklist_print(isc_log_t *lctx,
 	
 	pk = ISC_LIST_HEAD(list->keylist);
 	while (pk != NULL) {
-		dns_c_pubkey_print(lctx, fp, indent, pk);
+		dns_c_pubkey_print(fp, indent, pk);
 		pk = ISC_LIST_NEXT(pk, next);
 	}
 	fprintf(fp, "\n");
@@ -716,7 +677,7 @@ dns_c_pklist_print(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_pklist_addpubkey(isc_log_t *lctx, dns_c_pklist_t *list,
+dns_c_pklist_addpubkey(dns_c_pklist_t *list,
 		       dns_c_pubkey_t *pkey,
 		       isc_boolean_t deepcopy)
 {
@@ -727,7 +688,7 @@ dns_c_pklist_addpubkey(isc_log_t *lctx, dns_c_pklist_t *list,
 	REQUIRE(DNS_C_PUBKEY_VALID(pkey));
 
 	if (deepcopy) {
-		r = dns_c_pubkey_copy(lctx, list->mem, &pk, pkey);
+		r = dns_c_pubkey_copy(list->mem, &pk, pkey);
 		if (r != ISC_R_SUCCESS) {
 			return (r);
 		}
@@ -742,15 +703,13 @@ dns_c_pklist_addpubkey(isc_log_t *lctx, dns_c_pklist_t *list,
 
 
 isc_result_t
-dns_c_pklist_findpubkey(isc_log_t *lctx, dns_c_pklist_t *list,
+dns_c_pklist_findpubkey(dns_c_pklist_t *list,
 			dns_c_pubkey_t **pubkey, isc_int32_t flags,
 			isc_int32_t protocol, isc_int32_t algorithm,
 			const char *key)
 {
 	dns_c_pubkey_t *pk;
 
-	(void) lctx;
-	
 	REQUIRE(DNS_C_PKLIST_VALID(list));
 	REQUIRE(pubkey != NULL);
 
@@ -774,7 +733,7 @@ dns_c_pklist_findpubkey(isc_log_t *lctx, dns_c_pklist_t *list,
 
 
 isc_result_t
-dns_c_pklist_rmpubkey(isc_log_t *lctx, dns_c_pklist_t *list,
+dns_c_pklist_rmpubkey(dns_c_pklist_t *list,
 		      isc_int32_t flags,
 		      isc_int32_t protocol, isc_int32_t algorithm,
 		      const char *key)
@@ -786,11 +745,11 @@ dns_c_pklist_rmpubkey(isc_log_t *lctx, dns_c_pklist_t *list,
 	REQUIRE(key != NULL);
 	REQUIRE(strlen(key) > 0);
 
-	r = dns_c_pklist_findpubkey(lctx, list, &pk, flags, protocol,
+	r = dns_c_pklist_findpubkey(list, &pk, flags, protocol,
 				    algorithm, key);
 	if (r == ISC_R_SUCCESS) {
 		ISC_LIST_UNLINK(list->keylist, pk, next);
-		r = dns_c_pubkey_delete(lctx, &pk);
+		r = dns_c_pubkey_delete(&pk);
 	}
 
 	return (r);
@@ -799,16 +758,13 @@ dns_c_pklist_rmpubkey(isc_log_t *lctx, dns_c_pklist_t *list,
 
 
 isc_result_t
-dns_c_pubkey_new(isc_log_t *lctx,
-		 isc_mem_t *mem, isc_int32_t flags,
+dns_c_pubkey_new(isc_mem_t *mem, isc_int32_t flags,
 		 isc_int32_t protocol,
 		 isc_int32_t algorithm,
 		 const char *key, dns_c_pubkey_t **pubkey)
 {
 	dns_c_pubkey_t *pkey;
 
-	(void)lctx;
-
 	REQUIRE(pubkey != NULL);
 	REQUIRE(key != NULL);
 	REQUIRE(strlen(key) > 0);
@@ -836,13 +792,10 @@ dns_c_pubkey_new(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_pubkey_delete(isc_log_t *lctx,
-		    dns_c_pubkey_t **pubkey)
+dns_c_pubkey_delete(dns_c_pubkey_t **pubkey)
 {
 	dns_c_pubkey_t *pkey;
 
-	(void)lctx;
-
 	REQUIRE(pubkey != NULL);
 	REQUIRE(DNS_C_PUBKEY_VALID(*pubkey));
 
@@ -859,8 +812,7 @@ dns_c_pubkey_delete(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_pubkey_copy(isc_log_t *lctx,
-		  isc_mem_t *mem, dns_c_pubkey_t **dest, dns_c_pubkey_t *src)
+dns_c_pubkey_copy(isc_mem_t *mem, dns_c_pubkey_t **dest, dns_c_pubkey_t *src)
 {
 	dns_c_pubkey_t *k;
 	isc_result_t res;
@@ -868,7 +820,7 @@ dns_c_pubkey_copy(isc_log_t *lctx,
 	REQUIRE(DNS_C_PUBKEY_VALID(src));
 	REQUIRE(dest != NULL);
 	
-	res = dns_c_pubkey_new(lctx, mem, src->flags, src->protocol,
+	res = dns_c_pubkey_new(mem, src->flags, src->protocol,
 			       src->algorithm, src->key, &k);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
@@ -892,13 +844,12 @@ dns_c_pubkey_equal(dns_c_pubkey_t *k1, dns_c_pubkey_t *k2) {
 }
 
 void
-dns_c_pubkey_print(isc_log_t *lctx,
-		   FILE *fp, int indent, dns_c_pubkey_t *pubkey)
+dns_c_pubkey_print(FILE *fp, int indent, dns_c_pubkey_t *pubkey)
 {
 	REQUIRE(fp != NULL);
 	REQUIRE(DNS_C_PUBKEY_VALID(pubkey));
 
-	dns_c_printtabs(lctx, fp, indent);
+	dns_c_printtabs(fp, indent);
 	fprintf(fp, "pubkey %d %d %d \"%s\";\n",
 		pubkey->flags, pubkey->protocol,
 		pubkey->algorithm, pubkey->key);
@@ -906,13 +857,10 @@ dns_c_pubkey_print(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_tkeylist_new(isc_log_t *lctx,
-		   isc_mem_t *mem, dns_c_tkeylist_t **newlist)
+dns_c_tkeylist_new(isc_mem_t *mem, dns_c_tkeylist_t **newlist)
 {
 	dns_c_tkeylist_t *nl;
 
-	(void)lctx;
-
 	REQUIRE(newlist != NULL);
 
 	nl = isc_mem_get(mem, sizeof *nl);
@@ -931,8 +879,7 @@ dns_c_tkeylist_new(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_tkeylist_delete(isc_log_t *lctx,
-		      dns_c_tkeylist_t **list)
+dns_c_tkeylist_delete(dns_c_tkeylist_t **list)
 {
 	dns_c_tkeylist_t *l;
 	dns_c_tkey_t *tkey, *tmptkey;
@@ -948,7 +895,7 @@ dns_c_tkeylist_delete(isc_log_t *lctx,
 		tmptkey = ISC_LIST_NEXT(tkey, next);
 		ISC_LIST_UNLINK(l->tkeylist, tkey, next);
 
-		res = dns_c_tkey_delete(lctx, &tkey);
+		res = dns_c_tkey_delete(&tkey);
 		if (res != ISC_R_SUCCESS) {
 			return (res);
 		}
@@ -966,8 +913,7 @@ dns_c_tkeylist_delete(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_tkeylist_copy(isc_log_t *lctx,
-		    isc_mem_t *mem, dns_c_tkeylist_t **dest,
+dns_c_tkeylist_copy(isc_mem_t *mem, dns_c_tkeylist_t **dest,
 		    dns_c_tkeylist_t *src)
 {
 	dns_c_tkeylist_t *newlist;
@@ -977,23 +923,23 @@ dns_c_tkeylist_copy(isc_log_t *lctx,
 	REQUIRE(dest != NULL);
 	REQUIRE(DNS_C_TKEYLIST_VALID(src));
 	
-	res = dns_c_tkeylist_new(lctx, mem, &newlist);
+	res = dns_c_tkeylist_new(mem, &newlist);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
 	
 	tkey = ISC_LIST_HEAD(src->tkeylist);
 	while (tkey != NULL) {
-		res = dns_c_tkey_copy(lctx, mem, &tmptkey, tkey);
+		res = dns_c_tkey_copy(mem, &tmptkey, tkey);
 		if (res != ISC_R_SUCCESS) {
-			dns_c_tkeylist_delete(lctx, &newlist);
+			dns_c_tkeylist_delete(&newlist);
 			return (res);
 		}
 
-		res = dns_c_tkeylist_append(lctx, newlist, tmptkey, ISC_FALSE);
+		res = dns_c_tkeylist_append(newlist, tmptkey, ISC_FALSE);
 		if (res != ISC_R_SUCCESS) {
-			dns_c_tkey_delete(lctx, &tmptkey);
-			dns_c_tkeylist_delete(lctx, &newlist);
+			dns_c_tkey_delete(&tmptkey);
+			dns_c_tkeylist_delete(&newlist);
 			return (res);
 		}
 		
@@ -1007,8 +953,7 @@ dns_c_tkeylist_copy(isc_log_t *lctx,
 
 
 void
-dns_c_tkeylist_print(isc_log_t *lctx,
-		     FILE *fp, int indent, dns_c_tkeylist_t *list)
+dns_c_tkeylist_print(FILE *fp, int indent, dns_c_tkeylist_t *list)
 {
 	dns_c_tkey_t *tkey;
 	
@@ -1019,21 +964,20 @@ dns_c_tkeylist_print(isc_log_t *lctx,
 		return;
 	}
 
-	dns_c_printtabs(lctx, fp, indent);
+	dns_c_printtabs(fp, indent);
 	fprintf(fp, "trusted-keys {\n");
 	tkey = ISC_LIST_HEAD(list->tkeylist);
 	while (tkey != NULL) {
-		dns_c_tkey_print(lctx, fp, indent + 1, tkey);
+		dns_c_tkey_print(fp, indent + 1, tkey);
 		tkey = ISC_LIST_NEXT(tkey, next);
 	}
-	dns_c_printtabs(lctx, fp, indent);
+	dns_c_printtabs(fp, indent);
 	fprintf(fp,"};\n");
 }
 
 
 isc_result_t
-dns_c_tkeylist_append(isc_log_t *lctx,
-		      dns_c_tkeylist_t *list, dns_c_tkey_t *element,
+dns_c_tkeylist_append(dns_c_tkeylist_t *list, dns_c_tkey_t *element,
 		      isc_boolean_t copy)
 {
 	dns_c_tkey_t *newe;
@@ -1043,7 +987,7 @@ dns_c_tkeylist_append(isc_log_t *lctx,
 	REQUIRE(DNS_C_TKEY_VALID(element));
 
 	if (copy) {
-		res = dns_c_tkey_copy(lctx, list->mem, &newe, element);
+		res = dns_c_tkey_copy(list->mem, &newe, element);
 		if (res != ISC_R_SUCCESS) {
 			return (res);
 		}
@@ -1059,8 +1003,7 @@ dns_c_tkeylist_append(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_tkey_new(isc_log_t *lctx,
-	       isc_mem_t *mem, const char *domain, isc_int32_t flags,
+dns_c_tkey_new(isc_mem_t *mem, const char *domain, isc_int32_t flags,
 	       isc_int32_t protocol, isc_int32_t algorithm,
 	       const char *key, dns_c_tkey_t **newkey)
 {
@@ -1079,7 +1022,7 @@ dns_c_tkey_new(isc_log_t *lctx,
 		return (ISC_R_NOMEMORY);
 	}
 
-	res = dns_c_pubkey_new(lctx, mem, flags, protocol,
+	res = dns_c_pubkey_new(mem, flags, protocol,
 			       algorithm, key, &pk);
 	if (res != ISC_R_SUCCESS) {
 		isc_mem_put(mem, newk, sizeof *newk);
@@ -1091,7 +1034,7 @@ dns_c_tkey_new(isc_log_t *lctx,
 
 	newk->domain = isc_mem_strdup(mem, domain);
 	if (newk->domain == NULL) {
-		dns_c_pubkey_delete(lctx, &pk);
+		dns_c_pubkey_delete(&pk);
 		isc_mem_put(mem, newk, sizeof *newk);
 		return (ISC_R_NOMEMORY);
 	}
@@ -1107,8 +1050,7 @@ dns_c_tkey_new(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_tkey_delete(isc_log_t *lctx,
-		  dns_c_tkey_t **tkey)
+dns_c_tkey_delete(dns_c_tkey_t **tkey)
 {
 	isc_result_t res;
 	dns_c_tkey_t *tk;
@@ -1120,7 +1062,7 @@ dns_c_tkey_delete(isc_log_t *lctx,
 
 	isc_mem_free(tk->mem, tk->domain);
 
-	res = dns_c_pubkey_delete(lctx, &tk->pubkey);
+	res = dns_c_pubkey_delete(&tk->pubkey);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
@@ -1135,8 +1077,7 @@ dns_c_tkey_delete(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_tkey_copy(isc_log_t *lctx,
-		isc_mem_t *mem, dns_c_tkey_t **dest, dns_c_tkey_t *src)
+dns_c_tkey_copy(isc_mem_t *mem, dns_c_tkey_t **dest, dns_c_tkey_t *src)
 {
 	dns_c_tkey_t *newk;
 	dns_c_pubkey_t *newpk;
@@ -1157,7 +1098,7 @@ dns_c_tkey_copy(isc_log_t *lctx,
 		return (ISC_R_NOMEMORY);
 	}
 
-	res = dns_c_pubkey_copy(lctx, mem, &newpk, src->pubkey);
+	res = dns_c_pubkey_copy(mem, &newpk, src->pubkey);
 	if (res != ISC_R_SUCCESS) {
 		isc_mem_free(mem, newk->domain);
 		isc_mem_put(mem, newk, sizeof *newk);
@@ -1173,11 +1114,8 @@ dns_c_tkey_copy(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_tkey_getflags(isc_log_t *lctx,
-		    dns_c_tkey_t *tkey, isc_int32_t *flags)
+dns_c_tkey_getflags(dns_c_tkey_t *tkey, isc_int32_t *flags)
 {
-	(void)lctx;
-	
 	REQUIRE(DNS_C_TKEY_VALID(tkey));
 
 	*flags = tkey->pubkey->flags;
@@ -1187,11 +1125,8 @@ dns_c_tkey_getflags(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_tkey_getprotocol(isc_log_t *lctx,
-		       dns_c_tkey_t *tkey, isc_int32_t *protocol)
+dns_c_tkey_getprotocol(dns_c_tkey_t *tkey, isc_int32_t *protocol)
 {
-	(void)lctx;
-	
 	REQUIRE(DNS_C_TKEY_VALID(tkey));
 
 	*protocol = tkey->pubkey->protocol;
@@ -1201,11 +1136,8 @@ dns_c_tkey_getprotocol(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_tkey_getalgorithm(isc_log_t *lctx,
-			dns_c_tkey_t *tkey, isc_int32_t *algorithm)
+dns_c_tkey_getalgorithm(dns_c_tkey_t *tkey, isc_int32_t *algorithm)
 {
-	(void)lctx;
-	
 	REQUIRE(DNS_C_TKEY_VALID(tkey));
 
 	*algorithm = tkey->pubkey->algorithm;
@@ -1215,11 +1147,8 @@ dns_c_tkey_getalgorithm(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_tkey_getkey(isc_log_t *lctx,
-		  dns_c_tkey_t *tkey, const char **key)
+dns_c_tkey_getkey(dns_c_tkey_t *tkey, const char **key)
 {
-	(void)lctx;
-	
 	REQUIRE(key != NULL);
 	REQUIRE(DNS_C_TKEY_VALID(tkey));
 	
@@ -1230,13 +1159,12 @@ dns_c_tkey_getkey(isc_log_t *lctx,
 
 
 void
-dns_c_tkey_print(isc_log_t *lctx,
-		 FILE *fp, int indent, dns_c_tkey_t *tkey)
+dns_c_tkey_print(FILE *fp, int indent, dns_c_tkey_t *tkey)
 {
 	REQUIRE(fp != NULL);
 	REQUIRE(DNS_C_TKEY_VALID(tkey));
 
-	dns_c_printtabs(lctx, fp, indent);
+	dns_c_printtabs(fp, indent);
 	fprintf(fp, "\"%s\" %d %d %d \"%s\";\n",
 		tkey->domain, tkey->pubkey->flags,
 		tkey->pubkey->protocol, tkey->pubkey->algorithm,
diff --git a/lib/dns/config/conflog.c b/lib/dns/config/conflog.c
index f5b96f1aaf..d909841721 100644
--- a/lib/dns/config/conflog.c
+++ b/lib/dns/config/conflog.c
@@ -46,25 +46,22 @@
 
 
 
-static void		print_log_facility(isc_log_t *lctx, FILE *fp,
+static void		print_log_facility(FILE *fp,
 					   int value);
-static void		print_log_severity(isc_log_t *lctx, FILE *fp,
+static void		print_log_severity(FILE *fp,
 					   dns_c_logseverity_t severity);
-static void		print_log_category(isc_log_t *lctx, FILE *fp,
+static void		print_log_category(FILE *fp,
 					   dns_c_category_t category);
 static isc_boolean_t	logginglist_empty(dns_c_logginglist_t *ll);
 
 
 
 isc_result_t
-dns_c_logginglist_new(isc_log_t *lctx,
-		      isc_mem_t *mem,
+dns_c_logginglist_new(isc_mem_t *mem,
 		      dns_c_logginglist_t **list)
 {
 	dns_c_logginglist_t *newl;
 
-	(void) lctx;
-	
 	REQUIRE(list != NULL);
 
 	newl = isc_mem_get(mem, sizeof *newl);
@@ -84,8 +81,7 @@ dns_c_logginglist_new(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_logginglist_delete(isc_log_t *lctx,
-			 dns_c_logginglist_t **list)
+dns_c_logginglist_delete(dns_c_logginglist_t **list)
 {
 	dns_c_logginglist_t *l;
 	dns_c_logchan_t *chan, *tmpchan;
@@ -101,7 +97,7 @@ dns_c_logginglist_delete(isc_log_t *lctx,
 	while (chan != NULL) {
 		tmpchan = ISC_LIST_NEXT(chan, next);
 		ISC_LIST_UNLINK(l->channels, chan, next);
-		res = dns_c_logchan_delete(lctx, &chan);
+		res = dns_c_logchan_delete(&chan);
 		if (res != ISC_R_SUCCESS) {
 			return (res);
 		}
@@ -113,7 +109,7 @@ dns_c_logginglist_delete(isc_log_t *lctx,
 	while (cat != NULL) {
 		tmpcat = ISC_LIST_NEXT(cat, next);
 		ISC_LIST_UNLINK(l->categories, cat, next);
-		res = dns_c_logcat_delete(lctx, &cat);
+		res = dns_c_logcat_delete(&cat);
 		if (res != ISC_R_SUCCESS) {
 			return (res);
 		}
@@ -131,8 +127,7 @@ dns_c_logginglist_delete(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_logginglist_copy(isc_log_t *lctx,
-		       isc_mem_t *mem,
+dns_c_logginglist_copy(isc_mem_t *mem,
 		       dns_c_logginglist_t **dest,
 		       dns_c_logginglist_t *src)
 {
@@ -144,16 +139,16 @@ dns_c_logginglist_copy(isc_log_t *lctx,
 	REQUIRE(dest != NULL);
 	REQUIRE(DNS_C_LOGLIST_VALID(src));
 
-	res = dns_c_logginglist_new(lctx, mem, &newl);
+	res = dns_c_logginglist_new(mem, &newl);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
 
 	logchan = ISC_LIST_HEAD(src->channels);
 	while (logchan != NULL) {
-		res = dns_c_logchan_copy(lctx, mem, &tmplogchan, logchan);
+		res = dns_c_logchan_copy(mem, &tmplogchan, logchan);
 		if (res != ISC_R_SUCCESS) {
-			dns_c_logginglist_delete(lctx, &newl);
+			dns_c_logginglist_delete(&newl);
 			return (res);
 		}
 
@@ -164,9 +159,9 @@ dns_c_logginglist_copy(isc_log_t *lctx,
 
 	logcat = ISC_LIST_HEAD(src->categories);
 	while (logcat != NULL) {
-		res = dns_c_logcat_copy(lctx, mem, &tmplogcat, logcat);
+		res = dns_c_logcat_copy(mem, &tmplogcat, logcat);
 		if (res != ISC_R_SUCCESS) {
-			dns_c_logginglist_delete(lctx, &newl);
+			dns_c_logginglist_delete(&newl);
 			return (res);
 		}
 
@@ -208,8 +203,7 @@ logginglist_empty(dns_c_logginglist_t *ll)
 
 	
 void
-dns_c_logginglist_print(isc_log_t *lctx,
-			FILE *fp, int indent, dns_c_logginglist_t *ll,
+dns_c_logginglist_print(FILE *fp, int indent, dns_c_logginglist_t *ll,
 			isc_boolean_t if_predef_too)
 {
 	dns_c_logchan_t *logchan;
@@ -222,31 +216,30 @@ dns_c_logginglist_print(isc_log_t *lctx,
 		return;
 	}
 
-	dns_c_printtabs(lctx, fp, indent);
+	dns_c_printtabs(fp, indent);
 	fprintf(fp, "logging {\n");
 	
 	logchan = ISC_LIST_HEAD(ll->channels);
 	while (logchan != NULL) {
-		dns_c_logchan_print(lctx, fp, indent + 1, logchan,
+		dns_c_logchan_print(fp, indent + 1, logchan,
 				    if_predef_too);
 		logchan = ISC_LIST_NEXT(logchan, next);
 	}
 	
 	logcat = ISC_LIST_HEAD(ll->categories);
 	while (logcat != NULL) {
-		dns_c_logcat_print(lctx, fp, indent + 1, logcat,
+		dns_c_logcat_print(fp, indent + 1, logcat,
 				   if_predef_too);
 		logcat = ISC_LIST_NEXT(logcat, next);
 	}
 	
-	dns_c_printtabs(lctx, fp, indent);
+	dns_c_printtabs(fp, indent);
 	fprintf(fp, "};\n");
 }
 
 
 isc_result_t
-dns_c_logginglist_addchannel(isc_log_t *lctx,
-			     dns_c_logginglist_t *list,
+dns_c_logginglist_addchannel(dns_c_logginglist_t *list,
 			     dns_c_logchan_t *newchan,
 			     isc_boolean_t deepcopy)
 {
@@ -259,7 +252,7 @@ dns_c_logginglist_addchannel(isc_log_t *lctx,
 	REQUIRE(DNS_C_LOGCHAN_VALID(newchan));
 
 	if (deepcopy) {
-		res = dns_c_logchan_copy(lctx, list->mem, &newc, newchan);
+		res = dns_c_logchan_copy(list->mem, &newc, newchan);
 		if (res != ISC_R_SUCCESS) {
 			return (res);
 		}
@@ -274,10 +267,10 @@ dns_c_logginglist_addchannel(isc_log_t *lctx,
 			predefined = tmpchan->predefined;
 
 			ISC_LIST_UNLINK(list->channels, tmpchan, next);
-			res = dns_c_logchan_delete(lctx, &tmpchan);
+			res = dns_c_logchan_delete(&tmpchan);
 			if (res != ISC_R_SUCCESS) {
 				if (deepcopy) {
-					dns_c_logchan_delete(lctx, &newc);
+					dns_c_logchan_delete(&newc);
 				}
 				return (res);
 			}
@@ -295,8 +288,7 @@ dns_c_logginglist_addchannel(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_logginglist_addcategory(isc_log_t *lctx,
-			      dns_c_logginglist_t *list,
+dns_c_logginglist_addcategory(dns_c_logginglist_t *list,
 			      dns_c_logcat_t *newcat,
 			      isc_boolean_t deepcopy)
 {
@@ -310,7 +302,7 @@ dns_c_logginglist_addcategory(isc_log_t *lctx,
 	
 
 	if (deepcopy) {
-		res = dns_c_logcat_copy(lctx, list->mem, &newc, newcat);
+		res = dns_c_logcat_copy(list->mem, &newc, newcat);
 		if (res != ISC_R_SUCCESS) {
 			return (res);
 		}
@@ -326,10 +318,10 @@ dns_c_logginglist_addcategory(isc_log_t *lctx,
 			predefined = tmpcat->predefined;
 			
 			ISC_LIST_UNLINK(list->categories, tmpcat, next);
-			res = dns_c_logcat_delete(lctx, &tmpcat);
+			res = dns_c_logcat_delete(&tmpcat);
 			if (res != ISC_R_SUCCESS) {
 				if (deepcopy) {
-					dns_c_logcat_delete(lctx, &newc);
+					dns_c_logcat_delete(&newc);
 				}
 				return (res);
 			}
@@ -347,8 +339,7 @@ dns_c_logginglist_addcategory(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_logginglist_delchannel(isc_log_t *lctx,
-			     dns_c_logginglist_t *list,
+dns_c_logginglist_delchannel(dns_c_logginglist_t *list,
 			     const char *name)
 {
 	dns_c_logchan_t *logc;
@@ -358,11 +349,11 @@ dns_c_logginglist_delchannel(isc_log_t *lctx,
 	REQUIRE(name != NULL);
 	REQUIRE(strlen(name) > 0);
 
-	res = dns_c_logginglist_chanbyname(lctx, list, name, &logc);
+	res = dns_c_logginglist_chanbyname(list, name, &logc);
 	if (res == ISC_R_SUCCESS) {
 		ISC_LIST_UNLINK(list->channels, logc, next);
 
-		res = dns_c_logchan_delete(lctx, &logc);
+		res = dns_c_logchan_delete(&logc);
 	}
 
 	return (res);
@@ -370,8 +361,7 @@ dns_c_logginglist_delchannel(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_logginglist_delcategory(isc_log_t *lctx,
-			      dns_c_logginglist_t *list,
+dns_c_logginglist_delcategory(dns_c_logginglist_t *list,
 			      const char *name)
 {
 	dns_c_logcat_t *logc;
@@ -381,11 +371,11 @@ dns_c_logginglist_delcategory(isc_log_t *lctx,
 	REQUIRE(name != NULL);
 	REQUIRE(strlen(name) > 0);
 
-	res = dns_c_logginglist_catbyname(lctx, list, name, &logc);
+	res = dns_c_logginglist_catbyname(list, name, &logc);
 	if (res == ISC_R_SUCCESS) {
 		ISC_LIST_UNLINK(list->categories, logc, next);
 
-		res = dns_c_logcat_delete(lctx, &logc);
+		res = dns_c_logcat_delete(&logc);
 	}
 
 	return (res);
@@ -393,15 +383,12 @@ dns_c_logginglist_delcategory(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_logginglist_chanbyname(isc_log_t *lctx,
-			     dns_c_logginglist_t *list,
+dns_c_logginglist_chanbyname(dns_c_logginglist_t *list,
 			     const char *name,
 			     dns_c_logchan_t **chan)
 {
 	dns_c_logchan_t *logc;
 
-	(void) lctx;
-	
 	REQUIRE(DNS_C_LOGLIST_VALID(list));
 	REQUIRE(name != NULL);
 	REQUIRE(strlen(name) > 0);
@@ -426,8 +413,7 @@ dns_c_logginglist_chanbyname(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_logginglist_catbyname(isc_log_t *lctx,
-			    dns_c_logginglist_t *list,
+dns_c_logginglist_catbyname(dns_c_logginglist_t *list,
 			    const char *name,
 			    dns_c_logcat_t **cat)
 {
@@ -439,25 +425,22 @@ dns_c_logginglist_catbyname(isc_log_t *lctx,
 	REQUIRE(strlen(name) > 0);
 	REQUIRE(cat != NULL);
 
-	res = dns_c_string2category(lctx, name, &cattype);
+	res = dns_c_string2category(name, &cattype);
 	if (res != ISC_R_SUCCESS) {
 		return (ISC_R_FAILURE);
 	}
 
-	return (dns_c_logginglist_catbytype(lctx, list, cattype, cat));
+	return (dns_c_logginglist_catbytype(list, cattype, cat));
 }
 
 
 isc_result_t
-dns_c_logginglist_catbytype(isc_log_t *lctx,
-			    dns_c_logginglist_t *list,
+dns_c_logginglist_catbytype(dns_c_logginglist_t *list,
 			    dns_c_category_t cattype,
 			    dns_c_logcat_t **cat)
 {
 	dns_c_logcat_t *logc;
 
-	(void) lctx;
-	
 	REQUIRE(DNS_C_LOGLIST_VALID(list));
 	REQUIRE(cat != NULL);
 
@@ -484,15 +467,12 @@ dns_c_logginglist_catbytype(isc_log_t *lctx,
 /* ************************************************************************ */
 
 isc_result_t
-dns_c_logchan_new(isc_log_t *lctx,
-		  isc_mem_t *mem, const char *name,
+dns_c_logchan_new(isc_mem_t *mem, const char *name,
 		  dns_c_logchantype_t ctype,
 		  dns_c_logchan_t **newchan)
 {
 	dns_c_logchan_t *newc;
 
-	(void) lctx;
-	
 	REQUIRE(name != NULL);
 	REQUIRE(strlen(name) > 0);
 	REQUIRE(newchan != NULL);
@@ -539,13 +519,10 @@ dns_c_logchan_new(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_logchan_delete(isc_log_t *lctx,
-		     dns_c_logchan_t **channel)
+dns_c_logchan_delete(dns_c_logchan_t **channel)
 {
 	dns_c_logchan_t *logc;
 
-	(void) lctx;
-	
 	REQUIRE(channel != NULL);
 	REQUIRE(DNS_C_LOGCHAN_VALID(*channel));
 
@@ -575,8 +552,7 @@ dns_c_logchan_delete(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_logchan_copy(isc_log_t *lctx,
-		   isc_mem_t *mem, dns_c_logchan_t **dest,
+dns_c_logchan_copy(isc_mem_t *mem, dns_c_logchan_t **dest,
 		   dns_c_logchan_t *src)
 {
 	dns_c_logchan_t *logc;
@@ -585,7 +561,7 @@ dns_c_logchan_copy(isc_log_t *lctx,
 	REQUIRE(dest != NULL);
 	REQUIRE(DNS_C_LOGCHAN_VALID(src));
 
-	res = dns_c_logchan_new(lctx, mem, src->name, src->ctype, &logc);
+	res = dns_c_logchan_new(mem, src->name, src->ctype, &logc);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
@@ -619,8 +595,7 @@ dns_c_logchan_copy(isc_log_t *lctx,
 
 
 void
-dns_c_logchan_print(isc_log_t *lctx,
-		    FILE *fp, int indent, dns_c_logchan_t *logchan,
+dns_c_logchan_print(FILE *fp, int indent, dns_c_logchan_t *logchan,
 		    isc_boolean_t if_predef_too)
 {
 	REQUIRE(fp != NULL);
@@ -630,10 +605,10 @@ dns_c_logchan_print(isc_log_t *lctx,
 		return;
 	}
 	
-	dns_c_printtabs(lctx, fp, indent);
+	dns_c_printtabs(fp, indent);
 	fprintf(fp, "channel %s {\n", logchan->name) ;
 
-	dns_c_printtabs(lctx, fp, indent + 1) ;
+	dns_c_printtabs(fp, indent + 1) ;
 	switch (logchan->ctype) {
 	case dns_c_logchan_file:
 		fprintf(fp, "file \"%s\"",
@@ -651,13 +626,13 @@ dns_c_logchan_print(isc_log_t *lctx,
 
 		if (DNS_C_CHECKBIT(CHAN_SIZE_BIT, &logchan->setflags)) {
 			fprintf(fp, " size ");
-			dns_c_printinunits(lctx, fp, logchan->u.filec.size);
+			dns_c_printinunits(fp, logchan->u.filec.size);
 		}
 		break;
 
 	case dns_c_logchan_syslog:
 		fprintf(fp, "syslog ");
-		print_log_facility(lctx, fp, logchan->u.syslogc.facility);
+		print_log_facility(fp, logchan->u.syslogc.facility);
 		break;
 
 	case dns_c_logchan_null:
@@ -667,9 +642,9 @@ dns_c_logchan_print(isc_log_t *lctx,
 	fprintf(fp, ";\n");
 
 	if (DNS_C_CHECKBIT(CHAN_SEVERITY_BIT, &logchan->setflags)) {
-		dns_c_printtabs(lctx, fp, indent + 1);
+		dns_c_printtabs(fp, indent + 1);
 		fprintf(fp, "severity ");
-		print_log_severity(lctx, fp, logchan->severity);
+		print_log_severity(fp, logchan->severity);
 		if (logchan->severity == dns_c_log_debug &&
 		    DNS_C_CHECKBIT(CHAN_DEBUG_LEVEL_BIT, &logchan->setflags)) {
 			fprintf(fp, " %d", logchan->debug_level);
@@ -678,31 +653,30 @@ dns_c_logchan_print(isc_log_t *lctx,
 	}
 
 	if (DNS_C_CHECKBIT(CHAN_PSEV_BIT, &logchan->setflags)) {
-		dns_c_printtabs(lctx, fp, indent + 1);
+		dns_c_printtabs(fp, indent + 1);
 		fprintf(fp, "print-severity %s;\n",
 			(logchan->print_severity ? "true" : "false"));
 	}
 	
 	if (DNS_C_CHECKBIT(CHAN_PCAT_BIT, &logchan->setflags)) {
-		dns_c_printtabs(lctx, fp, indent + 1);
+		dns_c_printtabs(fp, indent + 1);
 		fprintf(fp, "print-category %s;\n",
 			(logchan->print_category ? "true" : "false"));
 	}
 	
 	if (DNS_C_CHECKBIT(CHAN_PTIME_BIT, &logchan->setflags)) {
-		dns_c_printtabs(lctx, fp, indent + 1);
+		dns_c_printtabs(fp, indent + 1);
 		fprintf(fp, "print-time %s;\n",
 			(logchan->print_time ? "true" : "false"));
 	}
 
-	dns_c_printtabs(lctx, fp, indent);
+	dns_c_printtabs(fp, indent);
 	fprintf(fp, "};\n");
 }
 
 
 isc_result_t
-dns_c_logchan_setpath(isc_log_t *lctx,
-		      dns_c_logchan_t *channel, const char *path)
+dns_c_logchan_setpath(dns_c_logchan_t *channel, const char *path)
 {
 	isc_boolean_t existed = ISC_FALSE;
 
@@ -711,7 +685,7 @@ dns_c_logchan_setpath(isc_log_t *lctx,
 	REQUIRE(strlen(path) > 0);
 
 	if (channel->ctype != dns_c_logchan_file) {
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "This type of channel doesn't have a "
 			      "path field");
@@ -733,8 +707,7 @@ dns_c_logchan_setpath(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_logchan_setversions(isc_log_t *lctx,
-			  dns_c_logchan_t *channel, isc_uint32_t versions)
+dns_c_logchan_setversions(dns_c_logchan_t *channel, isc_uint32_t versions)
 {
 	isc_boolean_t existed;
 
@@ -743,7 +716,7 @@ dns_c_logchan_setversions(isc_log_t *lctx,
 	existed = DNS_C_CHECKBIT(CHAN_VERSIONS_BIT, &channel->setflags);
 
 	if (channel->ctype != dns_c_logchan_file) {
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "This type of channel doesn't have a "
 			      "version field");
@@ -758,15 +731,14 @@ dns_c_logchan_setversions(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_logchan_setsize(isc_log_t *lctx,
-		      dns_c_logchan_t *channel, isc_uint32_t size)
+dns_c_logchan_setsize(dns_c_logchan_t *channel, isc_uint32_t size)
 {
 	isc_boolean_t existed;
 
 	REQUIRE(DNS_C_LOGCHAN_VALID(channel));
 
 	if (channel->ctype != dns_c_logchan_file) {
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "This type of channel doesn't have a "
 			      "size field");
@@ -783,15 +755,14 @@ dns_c_logchan_setsize(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_logchan_setfacility(isc_log_t *lctx,
-			  dns_c_logchan_t *channel, int facility)
+dns_c_logchan_setfacility(dns_c_logchan_t *channel, int facility)
 {
 	isc_boolean_t existed;
 
 	REQUIRE(DNS_C_LOGCHAN_VALID(channel));
 
 	if (channel->ctype != dns_c_logchan_syslog) {
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "This type of channel doesn't have a "
 			      "facility field");
@@ -799,8 +770,8 @@ dns_c_logchan_setfacility(isc_log_t *lctx,
 	}
 
 	
-	if (dns_c_facility2string(lctx, facility, ISC_FALSE) == NULL) {
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+	if (dns_c_facility2string(facility, ISC_FALSE) == NULL) {
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Not a legal facility for a syslog channel: %d",
 			      facility);
@@ -818,14 +789,11 @@ dns_c_logchan_setfacility(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_logchan_setseverity(isc_log_t *lctx,
-			  dns_c_logchan_t *channel,
+dns_c_logchan_setseverity(dns_c_logchan_t *channel,
 			  dns_c_logseverity_t severity)
 {
 	isc_boolean_t existed;
 
-	(void) lctx;
-	
 	REQUIRE(DNS_C_LOGCHAN_VALID(channel));
 
 	existed = DNS_C_CHECKBIT(CHAN_SEVERITY_BIT, &channel->setflags);
@@ -838,13 +806,10 @@ dns_c_logchan_setseverity(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_logchan_setdebuglevel(isc_log_t *lctx,
-			    dns_c_logchan_t *channel, isc_int32_t level)
+dns_c_logchan_setdebuglevel(dns_c_logchan_t *channel, isc_int32_t level)
 {
 	isc_boolean_t existed;
 
-	(void) lctx;
-	
 	REQUIRE(DNS_C_LOGCHAN_VALID(channel));
 
 	if (channel->severity == dns_c_log_debug) {
@@ -862,13 +827,10 @@ dns_c_logchan_setdebuglevel(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_logchan_setprintcat(isc_log_t *lctx,
-			  dns_c_logchan_t *channel, isc_boolean_t newval)
+dns_c_logchan_setprintcat(dns_c_logchan_t *channel, isc_boolean_t newval)
 {
 	isc_boolean_t existed;
 
-	(void) lctx;
-	
 	REQUIRE(DNS_C_LOGCHAN_VALID(channel));
 
 	existed = DNS_C_CHECKBIT(CHAN_PCAT_BIT, &channel->setflags);
@@ -881,13 +843,10 @@ dns_c_logchan_setprintcat(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_logchan_setprintsev(isc_log_t *lctx,
-			  dns_c_logchan_t *channel, isc_boolean_t newval)
+dns_c_logchan_setprintsev(dns_c_logchan_t *channel, isc_boolean_t newval)
 {
 	isc_boolean_t existed;
 
-	(void) lctx;
-	
 	REQUIRE(DNS_C_LOGCHAN_VALID(channel));
 
 	existed = DNS_C_CHECKBIT(CHAN_PSEV_BIT, &channel->setflags);
@@ -900,13 +859,10 @@ dns_c_logchan_setprintsev(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_logchan_setprinttime(isc_log_t *lctx,
-			   dns_c_logchan_t *channel, isc_boolean_t newval)
+dns_c_logchan_setprinttime(dns_c_logchan_t *channel, isc_boolean_t newval)
 {
 	isc_boolean_t existed;
 
-	(void) lctx;
-	
 	REQUIRE(DNS_C_LOGCHAN_VALID(channel));
 
 	existed = DNS_C_CHECKBIT(CHAN_PTIME_BIT, &channel->setflags);
@@ -918,11 +874,8 @@ dns_c_logchan_setprinttime(isc_log_t *lctx,
 }
 
 isc_result_t
-dns_c_logchan_setpredef(isc_log_t *lctx,
-			dns_c_logchan_t *channel, isc_boolean_t newval)
+dns_c_logchan_setpredef(dns_c_logchan_t *channel, isc_boolean_t newval)
 {
-	(void) lctx;
-	
 	REQUIRE(DNS_C_LOGCHAN_VALID(channel));
 
 	channel->predefined = newval;
@@ -935,13 +888,10 @@ dns_c_logchan_setpredef(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_logchan_getpath(isc_log_t *lctx,
-		      dns_c_logchan_t *channel, const char **path)
+dns_c_logchan_getpath(dns_c_logchan_t *channel, const char **path)
 {
 	isc_result_t res;
 
-	(void) lctx;
-	
 	REQUIRE(DNS_C_LOGCHAN_VALID(channel));
 	REQUIRE(path != NULL);
 
@@ -960,13 +910,10 @@ dns_c_logchan_getpath(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_logchan_getversions(isc_log_t *lctx,
-			  dns_c_logchan_t *channel, isc_uint32_t *retval)
+dns_c_logchan_getversions(dns_c_logchan_t *channel, isc_uint32_t *retval)
 {
 	isc_result_t res;
 
-	(void) lctx;
-	
 	REQUIRE(DNS_C_LOGCHAN_VALID(channel));
 	REQUIRE(retval != NULL);
 
@@ -985,13 +932,10 @@ dns_c_logchan_getversions(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_logchan_getsize(isc_log_t *lctx,
-		      dns_c_logchan_t *channel, isc_uint32_t *retval)
+dns_c_logchan_getsize(dns_c_logchan_t *channel, isc_uint32_t *retval)
 {
 	isc_result_t res;
 
-	(void) lctx;
-	
 	REQUIRE(DNS_C_LOGCHAN_VALID(channel));
 	REQUIRE(retval != NULL);
 
@@ -1010,13 +954,10 @@ dns_c_logchan_getsize(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_logchan_getfacility(isc_log_t *lctx,
-			  dns_c_logchan_t *channel, int *retval)
+dns_c_logchan_getfacility(dns_c_logchan_t *channel, int *retval)
 {
 	isc_result_t res;
 
-	(void) lctx;
-	
 	REQUIRE(DNS_C_LOGCHAN_VALID(channel));
 	REQUIRE(retval != NULL);
 
@@ -1036,14 +977,11 @@ dns_c_logchan_getfacility(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_logchan_getseverity(isc_log_t *lctx,
-			  dns_c_logchan_t *channel,
+dns_c_logchan_getseverity(dns_c_logchan_t *channel,
 			  dns_c_logseverity_t *retval)
 {
 	isc_result_t res;
 
-	(void) lctx;
-	
 	REQUIRE(DNS_C_LOGCHAN_VALID(channel));
 	REQUIRE(retval != NULL);
 
@@ -1059,13 +997,10 @@ dns_c_logchan_getseverity(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_logchan_getdebuglevel(isc_log_t *lctx,
-			    dns_c_logchan_t *channel, isc_int32_t *retval)
+dns_c_logchan_getdebuglevel(dns_c_logchan_t *channel, isc_int32_t *retval)
 {
 	isc_result_t res;
 
-	(void) lctx;
-	
 	REQUIRE(DNS_C_LOGCHAN_VALID(channel));
 	REQUIRE(retval != NULL);
 
@@ -1081,13 +1016,10 @@ dns_c_logchan_getdebuglevel(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_logchan_getprintcat(isc_log_t *lctx,
-			  dns_c_logchan_t *channel, isc_boolean_t *retval)
+dns_c_logchan_getprintcat(dns_c_logchan_t *channel, isc_boolean_t *retval)
 {
 	isc_result_t res;
 
-	(void) lctx;
-	
 	REQUIRE(DNS_C_LOGCHAN_VALID(channel));
 	REQUIRE(retval != NULL);
 
@@ -1103,13 +1035,10 @@ dns_c_logchan_getprintcat(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_logchan_getprintsev(isc_log_t *lctx,
-			  dns_c_logchan_t *channel, isc_boolean_t *retval)
+dns_c_logchan_getprintsev(dns_c_logchan_t *channel, isc_boolean_t *retval)
 {
 	isc_result_t res;
 
-	(void) lctx;
-	
 	REQUIRE(DNS_C_LOGCHAN_VALID(channel));
 	REQUIRE(retval != NULL);
 
@@ -1126,13 +1055,10 @@ dns_c_logchan_getprintsev(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_logchan_getprinttime(isc_log_t *lctx,
-			   dns_c_logchan_t *channel, isc_boolean_t *retval)
+dns_c_logchan_getprinttime(dns_c_logchan_t *channel, isc_boolean_t *retval)
 {
 	isc_result_t res;
 
-	(void) lctx;
-	
 	REQUIRE(DNS_C_LOGCHAN_VALID(channel));
 	REQUIRE(retval != NULL);
 
@@ -1148,11 +1074,8 @@ dns_c_logchan_getprinttime(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_logchan_getpredef(isc_log_t *lctx,
-			dns_c_logchan_t *channel, isc_boolean_t *retval)
+dns_c_logchan_getpredef(dns_c_logchan_t *channel, isc_boolean_t *retval)
 {
-	(void) lctx;
-	
 	REQUIRE(DNS_C_LOGCHAN_VALID(channel));
 	REQUIRE(retval != NULL);
 
@@ -1166,14 +1089,11 @@ dns_c_logchan_getpredef(isc_log_t *lctx,
  * Logging category
  */
 isc_result_t
-dns_c_logcat_new(isc_log_t *lctx,
-		 isc_mem_t *mem, dns_c_category_t cat, dns_c_logcat_t **newlc)
+dns_c_logcat_new(isc_mem_t *mem, dns_c_category_t cat, dns_c_logcat_t **newlc)
 {
 	dns_c_logcat_t *newc;
 	unsigned int i;
 
-	(void) lctx;
-	
 	REQUIRE(newlc != NULL);
 
 	newc = isc_mem_get(mem, sizeof *newc);
@@ -1205,14 +1125,11 @@ dns_c_logcat_new(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_logcat_delete(isc_log_t *lctx,
-		    dns_c_logcat_t **logcat)
+dns_c_logcat_delete(dns_c_logcat_t **logcat)
 {
 	dns_c_logcat_t *logc;
 	unsigned int i;
 
-	(void) lctx;
-	
 	REQUIRE(logcat != NULL);
 	REQUIRE(DNS_C_LOGCAT_VALID(*logcat));
 
@@ -1239,8 +1156,7 @@ dns_c_logcat_delete(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_logcat_copy(isc_log_t *lctx,
-		  isc_mem_t *mem, dns_c_logcat_t **dest, dns_c_logcat_t *src)
+dns_c_logcat_copy(isc_mem_t *mem, dns_c_logcat_t **dest, dns_c_logcat_t *src)
 {
 	unsigned int i;
 	dns_c_logcat_t *newc;
@@ -1249,15 +1165,15 @@ dns_c_logcat_copy(isc_log_t *lctx,
 	REQUIRE(dest != NULL);
 	REQUIRE(DNS_C_LOGCAT_VALID(src));
 
-	res = dns_c_logcat_new(lctx, mem, src->category, &newc);
+	res = dns_c_logcat_new(mem, src->category, &newc);
 	if (res != ISC_R_SUCCESS) {
 		return (res);
 	}
 
 	for (i = 0 ; i < src->nextcname ; i++) {
-		res = dns_c_logcat_addname(lctx, newc, src->channel_names[i]);
+		res = dns_c_logcat_addname(newc, src->channel_names[i]);
 		if (res != ISC_R_SUCCESS) {
-			dns_c_logcat_delete(lctx, &newc);
+			dns_c_logcat_delete(&newc);
 			return (res);
 		}
 	}
@@ -1267,8 +1183,7 @@ dns_c_logcat_copy(isc_log_t *lctx,
 
 
 void
-dns_c_logcat_print(isc_log_t *lctx,
-		   FILE *fp, int indent, dns_c_logcat_t *logcat,
+dns_c_logcat_print(FILE *fp, int indent, dns_c_logcat_t *logcat,
 		   isc_boolean_t if_predef_too)
 {
 	unsigned int i;
@@ -1280,29 +1195,26 @@ dns_c_logcat_print(isc_log_t *lctx,
 		return;
 	}
 	
-	dns_c_printtabs(lctx, fp, indent);
+	dns_c_printtabs(fp, indent);
 	fprintf(fp, "category ");
-	print_log_category(lctx, fp, logcat->category);
+	print_log_category(fp, logcat->category);
 	fprintf(fp, " {\n");
 
 	for (i = 0 ; i < logcat->nextcname ; i++) {
-		dns_c_printtabs(lctx, fp, indent + 1);
+		dns_c_printtabs(fp, indent + 1);
 		fprintf(fp, "%s;\n", logcat->channel_names[i]);
 	}
 
-	dns_c_printtabs(lctx, fp, indent);
+	dns_c_printtabs(fp, indent);
 	fprintf(fp, "};\n");
 }
 
 
 isc_result_t
-dns_c_logcat_addname(isc_log_t *lctx,
-		     dns_c_logcat_t *logcat, const char *name)
+dns_c_logcat_addname(dns_c_logcat_t *logcat, const char *name)
 {
 	unsigned int i;
 
-	(void) lctx;
-	
 	REQUIRE(DNS_C_LOGCAT_VALID(logcat));
 	REQUIRE(name != NULL);
 	REQUIRE(strlen(name) > 0);
@@ -1344,14 +1256,11 @@ dns_c_logcat_addname(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_logcat_delname(isc_log_t *lctx,
-		     dns_c_logcat_t *logcat, const char *name)
+dns_c_logcat_delname(dns_c_logcat_t *logcat, const char *name)
 {
 	unsigned int i ;
 	isc_result_t res;
 
-	(void) lctx;
-	
 	REQUIRE(DNS_C_LOGCAT_VALID(logcat));
 	REQUIRE(name != NULL);
 	REQUIRE(strlen(name) > 0);
@@ -1381,11 +1290,8 @@ dns_c_logcat_delname(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_logcat_setpredef(isc_log_t *lctx,
-		       dns_c_logcat_t *logcat,isc_boolean_t newval)
+dns_c_logcat_setpredef(dns_c_logcat_t *logcat,isc_boolean_t newval)
 {
-	(void) lctx;
-	
 	REQUIRE(DNS_C_LOGCAT_VALID(logcat));
 
 	logcat->predefined = newval;
@@ -1395,11 +1301,8 @@ dns_c_logcat_setpredef(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_logcat_getpredef(isc_log_t *lctx,
-		       dns_c_logcat_t *logcat, isc_boolean_t *retval)
+dns_c_logcat_getpredef(dns_c_logcat_t *logcat, isc_boolean_t *retval)
 {
-	(void) lctx;
-	
 	REQUIRE(DNS_C_LOGCAT_VALID(logcat));
 	REQUIRE(retval != NULL);
 
@@ -1415,31 +1318,28 @@ dns_c_logcat_getpredef(isc_log_t *lctx,
 
 
 static void
-print_log_facility(isc_log_t *lctx,
-		   FILE *fp, int value)
+print_log_facility(FILE *fp, int value)
 {
 	REQUIRE(fp != NULL);
 	
-	fputs(dns_c_facility2string(lctx, value, ISC_TRUE), fp);
+	fputs(dns_c_facility2string(value, ISC_TRUE), fp);
 }
 
 
 static void
-print_log_severity(isc_log_t *lctx,
-		   FILE *fp, dns_c_logseverity_t severity)
+print_log_severity(FILE *fp, dns_c_logseverity_t severity)
 {
 	REQUIRE(fp != NULL);
 	
-	fputs(dns_c_logseverity2string(lctx, severity, ISC_TRUE), fp);
+	fputs(dns_c_logseverity2string(severity, ISC_TRUE), fp);
 }
 
 
 static void
-print_log_category(isc_log_t *lctx,
-		   FILE *fp, dns_c_category_t category)
+print_log_category(FILE *fp, dns_c_category_t category)
 {
 	REQUIRE(fp != NULL);
 
-	fputs(dns_c_category2string(lctx, category, ISC_TRUE), fp);
+	fputs(dns_c_category2string(category, ISC_TRUE), fp);
 }
 
diff --git a/lib/dns/config/conflsn.c b/lib/dns/config/conflsn.c
index 670ea7d1f6..cbd124385b 100644
--- a/lib/dns/config/conflsn.c
+++ b/lib/dns/config/conflsn.c
@@ -27,7 +27,7 @@
 
 
 isc_result_t
-dns_c_lstnon_new(isc_log_t *lctx, isc_mem_t *mem, dns_c_lstnon_t **listen)
+dns_c_lstnon_new(isc_mem_t *mem, dns_c_lstnon_t **listen)
 {
 	dns_c_lstnon_t *ll;
 	isc_result_t result;
@@ -41,7 +41,7 @@ dns_c_lstnon_new(isc_log_t *lctx, isc_mem_t *mem, dns_c_lstnon_t **listen)
 	ll->port = 0;
 	ll->magic = DNS_C_LISTEN_MAGIC;
 
-	result = dns_c_ipmatchlist_new(lctx, mem, &ll->iml);
+	result = dns_c_ipmatchlist_new(mem, &ll->iml);
 	if (result != ISC_R_SUCCESS) {
 		isc_mem_put(mem, ll, sizeof *ll);
 		return (result);
@@ -56,7 +56,7 @@ dns_c_lstnon_new(isc_log_t *lctx, isc_mem_t *mem, dns_c_lstnon_t **listen)
 
 
 isc_result_t
-dns_c_lstnon_delete(isc_log_t *lctx, dns_c_lstnon_t **listen)
+dns_c_lstnon_delete(dns_c_lstnon_t **listen)
 {
 	dns_c_lstnon_t *lo;
 	isc_result_t r;
@@ -67,7 +67,7 @@ dns_c_lstnon_delete(isc_log_t *lctx, dns_c_lstnon_t **listen)
 	lo = *listen;
 
 	if (lo->iml != NULL) {
-		r = dns_c_ipmatchlist_detach(lctx, &lo->iml);
+		r = dns_c_ipmatchlist_detach(&lo->iml);
 	} else
 		r = ISC_R_SUCCESS;
 
@@ -80,7 +80,7 @@ dns_c_lstnon_delete(isc_log_t *lctx, dns_c_lstnon_t **listen)
 
 
 isc_result_t
-dns_c_lstnon_setiml(isc_log_t *lctx, dns_c_lstnon_t *listen,
+dns_c_lstnon_setiml(dns_c_lstnon_t *listen,
 		    dns_c_ipmatchlist_t *iml, isc_boolean_t deepcopy)
 {
 	isc_result_t result;
@@ -89,7 +89,7 @@ dns_c_lstnon_setiml(isc_log_t *lctx, dns_c_lstnon_t *listen,
 	REQUIRE(DNS_C_IPMLIST_VALID(iml));
 
 	if (listen->iml != NULL) {
-		result = dns_c_ipmatchlist_detach(lctx, &listen->iml);
+		result = dns_c_ipmatchlist_detach(&listen->iml);
 		if (result != ISC_R_SUCCESS) {
 			return (result);
 		}
@@ -99,7 +99,7 @@ dns_c_lstnon_setiml(isc_log_t *lctx, dns_c_lstnon_t *listen,
 	
 
 	if (deepcopy) {
-		result = dns_c_ipmatchlist_copy(lctx, listen->mem,
+		result = dns_c_ipmatchlist_copy(listen->mem,
 						&listen->iml, iml);
 	} else {
 		listen->iml = iml;
@@ -115,12 +115,10 @@ dns_c_lstnon_setiml(isc_log_t *lctx, dns_c_lstnon_t *listen,
 
 
 isc_result_t
-dns_c_lstnlist_new(isc_log_t *lctx, isc_mem_t *mem, dns_c_lstnlist_t **llist)
+dns_c_lstnlist_new(isc_mem_t *mem, dns_c_lstnlist_t **llist)
 {
 	dns_c_lstnlist_t *ll;
 
-	(void) lctx;
-	
 	REQUIRE(llist != NULL);
 
 	*llist = NULL;
@@ -142,7 +140,7 @@ dns_c_lstnlist_new(isc_log_t *lctx, isc_mem_t *mem, dns_c_lstnlist_t **llist)
 
 
 isc_result_t
-dns_c_lstnlist_delete(isc_log_t *lctx, dns_c_lstnlist_t **llist)
+dns_c_lstnlist_delete(dns_c_lstnlist_t **llist)
 {
 	dns_c_lstnlist_t *ll;
 	dns_c_lstnon_t *lo, *lotmp;
@@ -157,7 +155,7 @@ dns_c_lstnlist_delete(isc_log_t *lctx, dns_c_lstnlist_t **llist)
 	while (lo != NULL) {
 		lotmp = ISC_LIST_NEXT(lo, next);
 		ISC_LIST_UNLINK(ll->elements, lo, next);
-		r = dns_c_lstnon_delete(lctx, &lo);
+		r = dns_c_lstnon_delete(&lo);
 		if (r != ISC_R_SUCCESS) {
 			return (r);
 		}
@@ -175,7 +173,7 @@ dns_c_lstnlist_delete(isc_log_t *lctx, dns_c_lstnlist_t **llist)
 
 
 isc_result_t
-dns_c_lstnlist_print(isc_log_t *lctx, FILE *fp, int indent,
+dns_c_lstnlist_print(FILE *fp, int indent,
 		     dns_c_lstnlist_t *ll)
 {
 	dns_c_lstnon_t *lo;
@@ -184,8 +182,8 @@ dns_c_lstnlist_print(isc_log_t *lctx, FILE *fp, int indent,
 
 	lo = ISC_LIST_HEAD(ll->elements);
 	while (lo != NULL) {
-		dns_c_printtabs(lctx, fp, indent);
-		dns_c_lstnon_print(lctx, fp, indent, lo);
+		dns_c_printtabs(fp, indent);
+		dns_c_lstnon_print(fp, indent, lo);
 		lo = ISC_LIST_NEXT(lo, next);
 		fprintf(fp, "\n");
 	}
@@ -195,7 +193,7 @@ dns_c_lstnlist_print(isc_log_t *lctx, FILE *fp, int indent,
 
 
 isc_result_t
-dns_c_lstnon_print(isc_log_t *lctx, FILE *fp, int indent, dns_c_lstnon_t *lo)
+dns_c_lstnon_print(FILE *fp, int indent, dns_c_lstnon_t *lo)
 {
 	REQUIRE(lo != NULL);
 	REQUIRE(DNS_C_LISTEN_VALID(lo));
@@ -205,7 +203,7 @@ dns_c_lstnon_print(isc_log_t *lctx, FILE *fp, int indent, dns_c_lstnon_t *lo)
 		fprintf(fp, "port %d ", lo->port);
 	}
 
-	dns_c_ipmatchlist_print(lctx, fp, indent + 1, lo->iml);
+	dns_c_ipmatchlist_print(fp, indent + 1, lo->iml);
 	fprintf(fp, ";\n");
 
 	return (ISC_R_SUCCESS);
diff --git a/lib/dns/config/confparser.y b/lib/dns/config/confparser.y
index 319aa15d1d..0f7452bdf4 100644
--- a/lib/dns/config/confparser.y
+++ b/lib/dns/config/confparser.y
@@ -17,7 +17,7 @@
  */
 
 #if !defined(lint) && !defined(SABER)
-static char rcsid[] = "$Id: confparser.y,v 1.27 1999/12/01 16:28:56 brister Exp $";
+static char rcsid[] = "$Id: confparser.y,v 1.28 1999/12/06 12:40:34 brister Exp $";
 #endif /* not lint */
 
 #include <config.h>
@@ -71,7 +71,6 @@ static isc_lex_t               *mylexer;
 static isc_symtab_t            *keywords;
 static dns_c_cbks_t            *callbacks;
 static isc_lexspecials_t        specials;
-static isc_log_t               *logcontext;
 
 #define CONF_MAX_IDENT 1024
 
@@ -366,7 +365,7 @@ options_stmt: L_OPTIONS
         {
                 dns_c_options_t *options;
 
-                tmpres = dns_c_ctx_getoptions(logcontext, currcfg, &options);
+                tmpres = dns_c_ctx_getoptions(currcfg, &options);
                 if (tmpres == ISC_R_SUCCESS) {
                         parser_error(ISC_FALSE, "Cannot redefine options");
 
@@ -374,10 +373,10 @@ options_stmt: L_OPTIONS
                          * Clean out options so rest of config won't fail
                          * or issue extra error messages
                          */
-                        dns_c_ctx_optionsdelete(logcontext, &currcfg->options);
+                        dns_c_ctx_optionsdelete(&currcfg->options);
                 }
 
-                tmpres = dns_c_ctx_optionsnew(logcontext, currcfg->mem,
+                tmpres = dns_c_ctx_optionsnew(currcfg->mem,
                                               &currcfg->options);
                 if (tmpres != ISC_R_SUCCESS) {
                         parser_error(ISC_FALSE,
@@ -391,7 +390,7 @@ options_stmt: L_OPTIONS
                         tmpres = callbacks->optscbk(currcfg,
                                                     callbacks->optscbkuap);
                         if (tmpres != ISC_R_SUCCESS) {
-				isc_log_write(logcontext,
+				isc_log_write(dns_lctx,
 					      DNS_LOGCATEGORY_CONFIG,
 					      DNS_LOGMODULE_CONFIG,
 					      ISC_LOG_CRITICAL,
@@ -411,7 +410,7 @@ options: option L_EOS
 option: /* Empty */
         | L_VERSION L_QSTRING
         {
-                tmpres = dns_c_ctx_setversion(logcontext, currcfg, $2);
+                tmpres = dns_c_ctx_setversion(currcfg, $2);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_error(ISC_FALSE, "Redefining version.");
                 } else if (tmpres != ISC_R_SUCCESS) {
@@ -425,7 +424,7 @@ option: /* Empty */
         }
         | L_DIRECTORY L_QSTRING
         {
-                tmpres = dns_c_ctx_setdirectory(logcontext, currcfg, $2);
+                tmpres = dns_c_ctx_setdirectory(currcfg, $2);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_error(ISC_FALSE, "Redefining directory");
                 } else if (tmpres != ISC_R_SUCCESS) {
@@ -439,7 +438,7 @@ option: /* Empty */
         }
         | L_NAMED_XFER L_QSTRING
         {
-                tmpres = dns_c_ctx_setnamedxfer(logcontext, currcfg, $2);
+                tmpres = dns_c_ctx_setnamedxfer(currcfg, $2);
                 
                 if (tmpres == ISC_R_EXISTS) {
                         parser_error(ISC_FALSE, "Redefining named-xfer");
@@ -453,7 +452,7 @@ option: /* Empty */
         }
         | L_TKEY_DOMAIN L_QSTRING
         {
-                tmpres = dns_c_ctx_settkeydomain(logcontext, currcfg, $2);
+                tmpres = dns_c_ctx_settkeydomain(currcfg, $2);
                 
                 if (tmpres == ISC_R_EXISTS) {
                         parser_error(ISC_FALSE, "Redefining tkey-domain");
@@ -468,7 +467,7 @@ option: /* Empty */
         }
         | L_TKEY_DHKEY L_QSTRING L_INTEGER
         {
-                tmpres = dns_c_ctx_settkeydhkey(logcontext, currcfg, $2, $3);
+                tmpres = dns_c_ctx_settkeydhkey(currcfg, $2, $3);
                 
                 if (tmpres == ISC_R_EXISTS) {
                         parser_error(ISC_FALSE, "Redefining tkey-dhkey");
@@ -482,7 +481,7 @@ option: /* Empty */
         }
         | L_PIDFILE L_QSTRING
         {
-                tmpres = dns_c_ctx_setpidfilename(logcontext, currcfg, $2);
+                tmpres = dns_c_ctx_setpidfilename(currcfg, $2);
                 
                 if (tmpres == ISC_R_EXISTS) {
                         parser_error(ISC_FALSE, "Redefining pid-file");
@@ -496,7 +495,7 @@ option: /* Empty */
         }
         | L_STATS_FILE L_QSTRING
         {
-                tmpres = dns_c_ctx_setstatsfilename(logcontext, currcfg, $2);
+                tmpres = dns_c_ctx_setstatsfilename(currcfg, $2);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_error(ISC_FALSE, "Redefining statistics-file");
                 } else if (tmpres != ISC_R_SUCCESS) {
@@ -509,8 +508,7 @@ option: /* Empty */
         }
         | L_MEMSTATS_FILE L_QSTRING
         {
-                tmpres = dns_c_ctx_setmemstatsfilename(logcontext,
-                                                       currcfg, $2);
+                tmpres = dns_c_ctx_setmemstatsfilename(currcfg, $2);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_error(ISC_FALSE,
                                      "Redefining memstatistics-file");
@@ -525,7 +523,7 @@ option: /* Empty */
         }
         | L_DUMP_FILE L_QSTRING
         {
-                tmpres = dns_c_ctx_setdumpfilename(logcontext, currcfg, $2);
+                tmpres = dns_c_ctx_setdumpfilename(currcfg, $2);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_error(ISC_FALSE, "Redefining dump-file");
                 } else if (tmpres != ISC_R_SUCCESS) {
@@ -538,49 +536,49 @@ option: /* Empty */
         }
         | L_EXPERT_MODE yea_or_nay
         {
-                tmpres = dns_c_ctx_setexpertmode(logcontext, currcfg, $2);
+                tmpres = dns_c_ctx_setexpertmode(currcfg, $2);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_error(ISC_FALSE, "Redefining fake-iquery.");
                 }
         }
         | L_FAKE_IQUERY yea_or_nay
         {
-                tmpres = dns_c_ctx_setfakeiquery(logcontext, currcfg, $2);
+                tmpres = dns_c_ctx_setfakeiquery(currcfg, $2);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_error(ISC_FALSE, "Redefining fake-iquery.");
                 }
         }
         | L_RECURSION yea_or_nay
         {
-                tmpres = dns_c_ctx_setrecursion(logcontext, currcfg, $2);
+                tmpres = dns_c_ctx_setrecursion(currcfg, $2);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_error(ISC_FALSE, "Redefining recursion");
                 }
         }
         | L_FETCH_GLUE yea_or_nay
         {
-                tmpres = dns_c_ctx_setfetchglue(logcontext, currcfg, $2);
+                tmpres = dns_c_ctx_setfetchglue(currcfg, $2);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_error(ISC_FALSE, "Redefining fetch-glue.");
                 }
         }
         | L_NOTIFY yea_or_nay
         {
-                tmpres = dns_c_ctx_setnotify(logcontext, currcfg, $2);
+                tmpres = dns_c_ctx_setnotify(currcfg, $2);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_error(ISC_FALSE, "Redefining notify.");
                 }
         }
         | L_HOSTSTATS yea_or_nay
         {
-                tmpres = dns_c_ctx_sethoststatistics(logcontext, currcfg, $2);
+                tmpres = dns_c_ctx_sethoststatistics(currcfg, $2);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_error(ISC_FALSE, "Redefining host-statistics.");
                 }
         }
         | L_DEALLOC_ON_EXIT yea_or_nay
         {
-                tmpres = dns_c_ctx_setdealloconexit(logcontext, currcfg, $2);
+                tmpres = dns_c_ctx_setdealloconexit(currcfg, $2);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_error(ISC_FALSE,
                                      "Redefining deallocate-on-exit.");
@@ -588,15 +586,14 @@ option: /* Empty */
         }
         | L_USE_IXFR yea_or_nay
         {
-                tmpres = dns_c_ctx_setuseixfr(logcontext, currcfg, $2);
+                tmpres = dns_c_ctx_setuseixfr(currcfg, $2);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_error(ISC_FALSE, "Redefining use-ixfr.");
                 }
         }
         | L_MAINTAIN_IXFR_BASE yea_or_nay
         {
-                tmpres = dns_c_ctx_setmaintainixfrbase(logcontext,
-                                                       currcfg, $2);
+                tmpres = dns_c_ctx_setmaintainixfrbase(currcfg, $2);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_error(ISC_FALSE,
                                      "Redefining maintain-ixfr-base.");
@@ -604,42 +601,42 @@ option: /* Empty */
         }
         | L_HAS_OLD_CLIENTS yea_or_nay
         {
-                tmpres = dns_c_ctx_sethasoldclients(logcontext, currcfg, $2);
+                tmpres = dns_c_ctx_sethasoldclients(currcfg, $2);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_error(ISC_FALSE, "Redefining has-old-clients.");
                 }
         }
         | L_AUTH_NXDOMAIN yea_or_nay
         {
-                tmpres = dns_c_ctx_setauthnxdomain(logcontext, currcfg, $2);
+                tmpres = dns_c_ctx_setauthnxdomain(currcfg, $2);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_error(ISC_FALSE, "Redefining auth-nxdomain.");
                 }
         }
         | L_MULTIPLE_CNAMES yea_or_nay
         {
-                tmpres = dns_c_ctx_setmultiplecnames(logcontext, currcfg, $2);
+                tmpres = dns_c_ctx_setmultiplecnames(currcfg, $2);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_error(ISC_FALSE, "Redefining multiple-cnames.");
                 }
         }
         | L_CHECK_NAMES check_names_type check_names_opt
         {
-                tmpres = dns_c_ctx_setchecknames(logcontext, currcfg, $2, $3);
+                tmpres = dns_c_ctx_setchecknames(currcfg, $2, $3);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_error(ISC_FALSE, "Redefining check-names.");
                 }
         }
         | L_USE_ID_POOL yea_or_nay
         {
-                tmpres = dns_c_ctx_setuseidpool(logcontext, currcfg, $2);
+                tmpres = dns_c_ctx_setuseidpool(currcfg, $2);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_error(ISC_FALSE, "Redefining use-id-pool.");
                 }
         }
 	| L_RFC2308_TYPE1 yea_or_nay
 	{
-		tmpres = dns_c_ctx_setrfc2308type1(logcontext, currcfg, $2);
+		tmpres = dns_c_ctx_setrfc2308type1(currcfg, $2);
 		if (tmpres == ISC_R_EXISTS) {
 			parser_error(ISC_FALSE, "Redefining rfc2308-type.");
 		}
@@ -651,8 +648,7 @@ option: /* Empty */
                                        "address-match-list empty. "
                                        "listen statement ignored.");
                 } else {
-                        tmpres = dns_c_ctx_addlisten_on(logcontext,
-                                                        currcfg, $2, $4,
+                        tmpres = dns_c_ctx_addlisten_on(currcfg, $2, $4,
                                                         ISC_FALSE);
 
                         if (tmpres != ISC_R_SUCCESS) {
@@ -664,7 +660,7 @@ option: /* Empty */
         }
         | L_FORWARD forward_opt
         {
-                tmpres = dns_c_ctx_setforward(logcontext, currcfg, $2);
+                tmpres = dns_c_ctx_setforward(currcfg, $2);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_error(ISC_FALSE,
                                      "Redefining forward");
@@ -673,15 +669,13 @@ option: /* Empty */
         | L_FORWARDERS {
                 dns_c_ipmatchlist_t *forwarders;
 
-                tmpres = dns_c_ctx_getforwarders(logcontext,
-                                                 currcfg, &forwarders);
+                tmpres = dns_c_ctx_getforwarders(currcfg, &forwarders);
                 if (tmpres != ISC_R_NOTFOUND) {
                         parser_error(ISC_FALSE,
                                      "Redefining options forwarders");
-                        dns_c_ipmatchlist_empty(logcontext, forwarders);
+                        dns_c_ipmatchlist_empty(forwarders);
                 } else {
-                        tmpres = dns_c_ipmatchlist_new(logcontext,
-                                                       currcfg->mem,
+                        tmpres = dns_c_ipmatchlist_new(currcfg->mem,
                                                        &forwarders);
                         if (tmpres != ISC_R_SUCCESS) {
                                 parser_error(ISC_FALSE,
@@ -690,8 +684,7 @@ option: /* Empty */
                                 YYABORT;
                         }
 
-                        tmpres = dns_c_ctx_setforwarders(logcontext,
-                                                         currcfg, forwarders,
+                        tmpres = dns_c_ctx_setforwarders(currcfg, forwarders,
                                                          ISC_FALSE);
                         if (tmpres != ISC_R_SUCCESS) {
                                 parser_error(ISC_FALSE,
@@ -705,7 +698,7 @@ option: /* Empty */
         {
 		if ($3 == NULL)
 			YYABORT;
-		tmpres = dns_c_ctx_setqueryacl(logcontext, currcfg,
+		tmpres = dns_c_ctx_setqueryacl(currcfg,
 					       ISC_FALSE, $3);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_error(ISC_FALSE, "Redefining allow-query list");
@@ -717,7 +710,7 @@ option: /* Empty */
         }
         | L_ALLOW_TRANSFER L_LBRACE address_match_list L_RBRACE
         {
-                tmpres = dns_c_ctx_settransferacl(logcontext, currcfg,
+                tmpres = dns_c_ctx_settransferacl(currcfg,
                                                   ISC_FALSE, $3);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_error(ISC_FALSE,
@@ -730,7 +723,7 @@ option: /* Empty */
         }
         | L_ALLOW_RECURSION L_LBRACE address_match_list L_RBRACE
         {
-                tmpres = dns_c_ctx_setrecursionacl(logcontext, currcfg,
+                tmpres = dns_c_ctx_setrecursionacl(currcfg,
                                                    ISC_FALSE, $3);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_error(ISC_FALSE,
@@ -743,7 +736,7 @@ option: /* Empty */
         }
         | L_SORTLIST  L_LBRACE address_match_list L_RBRACE
         {
-                tmpres = dns_c_ctx_setsortlist(logcontext, currcfg,
+                tmpres = dns_c_ctx_setsortlist(currcfg,
                                                ISC_FALSE, $3);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_error(ISC_FALSE, "Redefining sortlist.");
@@ -754,7 +747,7 @@ option: /* Empty */
         }
         | L_BLACKHOLE L_LBRACE address_match_list L_RBRACE
         {
-                tmpres = dns_c_ctx_setblackhole(logcontext, currcfg,
+                tmpres = dns_c_ctx_setblackhole(currcfg,
                                                 ISC_FALSE, $3);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_error(ISC_FALSE, "Redefining blackhole.");
@@ -765,7 +758,7 @@ option: /* Empty */
         }
         | L_TOPOLOGY L_LBRACE address_match_list L_RBRACE
         {
-                tmpres = dns_c_ctx_settopology(logcontext, currcfg,
+                tmpres = dns_c_ctx_settopology(currcfg,
                                                ISC_FALSE, $3);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_error(ISC_FALSE, "Redefining topology.");
@@ -778,7 +771,7 @@ option: /* Empty */
         | transfer_clause
         | L_TRANSFER_FORMAT transfer_format
         {
-                tmpres = dns_c_ctx_settransferformat(logcontext, currcfg, $2);
+                tmpres = dns_c_ctx_settransferformat(currcfg, $2);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_error(ISC_FALSE, "Redefining transfer-format.");
                 } else if (tmpres != ISC_R_SUCCESS) {
@@ -789,8 +782,7 @@ option: /* Empty */
         }
         | L_MAX_TRANSFER_TIME_IN L_INTEGER
         {
-                tmpres = dns_c_ctx_setmaxtransfertimein(logcontext,
-                                                        currcfg, $2 * 60);
+                tmpres = dns_c_ctx_setmaxtransfertimein(currcfg, $2 * 60);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_error(ISC_FALSE,
                                      "Redefining max-transfer-time-in.");
@@ -802,8 +794,7 @@ option: /* Empty */
         }
         | L_CLEAN_INTERVAL L_INTEGER
         {
-                tmpres = dns_c_ctx_setcleaninterval(logcontext,
-                                                    currcfg, $2 * 60);
+                tmpres = dns_c_ctx_setcleaninterval(currcfg, $2 * 60);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_error(ISC_FALSE,
                                      "Redefining cleaning-interval.");
@@ -815,8 +806,7 @@ option: /* Empty */
         }
         | L_INTERFACE_INTERVAL L_INTEGER
         {
-                tmpres = dns_c_ctx_setinterfaceinterval(logcontext,
-                                                        currcfg, $2 * 60);
+                tmpres = dns_c_ctx_setinterfaceinterval(currcfg, $2 * 60);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_error(ISC_FALSE,
                                      "Redefining interface-interval.");
@@ -828,7 +818,7 @@ option: /* Empty */
         }
         | L_STATS_INTERVAL L_INTEGER
         {
-                tmpres = dns_c_ctx_setstatsinterval(logcontext, currcfg,
+                tmpres = dns_c_ctx_setstatsinterval(currcfg,
                                                     $2 * 60);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_error(ISC_FALSE,
@@ -841,7 +831,7 @@ option: /* Empty */
         }
         | L_MAX_LOG_SIZE_IXFR L_INTEGER
         {
-                tmpres = dns_c_ctx_setmaxlogsizeixfr(logcontext, currcfg, $2);
+                tmpres = dns_c_ctx_setmaxlogsizeixfr(currcfg, $2);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_error(ISC_FALSE,
                                      "Redefining max-ixfr-log-size.");
@@ -853,7 +843,7 @@ option: /* Empty */
         }
         | L_MAX_NCACHE_TTL L_INTEGER
         {
-                tmpres = dns_c_ctx_setmaxncachettl(logcontext, currcfg, $2);
+                tmpres = dns_c_ctx_setmaxncachettl(currcfg, $2);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_error(ISC_FALSE,
                                      "Redefining max-ncache-ttl.");
@@ -865,8 +855,7 @@ option: /* Empty */
         }
         | L_HEARTBEAT L_INTEGER
         {
-                tmpres = dns_c_ctx_setheartbeat_interval(logcontext,
-                                                         currcfg, $2 * 60);
+                tmpres = dns_c_ctx_setheartbeat_interval(currcfg, $2 * 60);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_error(ISC_FALSE,
                                      "Redefining heartbeat-interval.");
@@ -878,7 +867,7 @@ option: /* Empty */
         }
         | L_DIALUP yea_or_nay
         {
-                tmpres = dns_c_ctx_setdialup(logcontext, currcfg, $2);
+                tmpres = dns_c_ctx_setdialup(currcfg, $2);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_error(ISC_FALSE, "Redefining dialup.");
                 } else if (tmpres != ISC_R_SUCCESS) {
@@ -890,23 +879,20 @@ option: /* Empty */
         {
                 dns_c_rrsolist_t *ordering;
 
-                tmpres = dns_c_ctx_getrrsetorderlist(logcontext,
-                                                     currcfg, &ordering);
+                tmpres = dns_c_ctx_getrrsetorderlist(currcfg, &ordering);
                 if (tmpres != ISC_R_NOTFOUND) {
                         parser_error(ISC_FALSE,
                                      "Redefining rrset-order list");
-                        dns_c_rrsolist_clear(logcontext, ordering);
+                        dns_c_rrsolist_clear(ordering);
                 } else {
-                        tmpres = dns_c_rrsolist_new(logcontext,
-                                                    currcfg->mem, &ordering);
+                        tmpres = dns_c_rrsolist_new(currcfg->mem, &ordering);
                         if (tmpres != ISC_R_SUCCESS) {
                                 parser_error(ISC_FALSE,
                                              "Failed to create rrset-order "
                                              "list");
                                 YYABORT;
                         }
-                        tmpres = dns_c_ctx_setrrsetorderlist(logcontext,
-                                                             currcfg,
+                        tmpres = dns_c_ctx_setrrsetorderlist(currcfg,
                                                              ISC_FALSE,
                                                              ordering);
                         if (tmpres != ISC_R_SUCCESS) {
@@ -935,7 +921,7 @@ control: /* Empty */
         {
                 dns_c_ctrl_t *control;
 
-                tmpres = dns_c_ctrlinet_new(logcontext, currcfg->mem, &control,
+                tmpres = dns_c_ctrlinet_new(currcfg->mem, &control,
                                             $2, $4, $7, ISC_FALSE);
                 if (tmpres != ISC_R_SUCCESS) {
                         parser_error(ISC_FALSE,
@@ -949,7 +935,7 @@ control: /* Empty */
         {
                 dns_c_ctrl_t *control;
 
-                tmpres = dns_c_ctrlunix_new(logcontext, currcfg->mem, &control,
+                tmpres = dns_c_ctrlunix_new(currcfg->mem, &control,
                                             $2, $4, $6, $8);
                 if (tmpres != ISC_R_SUCCESS) {
                         parser_error(ISC_FALSE,
@@ -1022,7 +1008,7 @@ rrset_ordering_element: ordering_class ordering_type ordering_name
                 dns_c_rrso_t *orderelem;
                 dns_c_ordering_t o;
 
-                tmpres = dns_c_string2ordering(logcontext, $5, &o);
+                tmpres = dns_c_string2ordering($5, &o);
                 if (tmpres != ISC_R_SUCCESS) {
                         parser_warning(ISC_FALSE,
                                        "Unknown ordering type ``%s''."
@@ -1030,7 +1016,7 @@ rrset_ordering_element: ordering_class ordering_type ordering_name
                         o = DNS_DEFAULT_ORDERING;
                 }
 
-                tmpres = dns_c_rrso_new(logcontext, currcfg->mem,
+                tmpres = dns_c_rrso_new(currcfg->mem,
                                         &orderelem, $1, $2, $3, o);
                 if (tmpres != ISC_R_SUCCESS) {
                         parser_error(ISC_FALSE,
@@ -1094,7 +1080,7 @@ maybe_wild_port: in_port
 
 query_source_address: L_ADDRESS maybe_wild_addr
         {
-                tmpres = dns_c_ctx_setquerysourceaddr(logcontext, currcfg, $2);
+                tmpres = dns_c_ctx_setquerysourceaddr(currcfg, $2);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_error(ISC_FALSE,
                                      "Redefining query-source address.");
@@ -1108,7 +1094,7 @@ query_source_address: L_ADDRESS maybe_wild_addr
 
 query_source_port: L_PORT maybe_wild_port
         {
-                tmpres = dns_c_ctx_setquerysourceport(logcontext, currcfg, $2);
+                tmpres = dns_c_ctx_setquerysourceport(currcfg, $2);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_error(ISC_FALSE,
                                      "Redefining query-source port.");
@@ -1226,7 +1212,7 @@ forward_opt: L_ONLY
 
 size_clause: L_DATASIZE size_spec
         {
-                tmpres = dns_c_ctx_setdatasize(logcontext, currcfg, $2);
+                tmpres = dns_c_ctx_setdatasize(currcfg, $2);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_error(ISC_FALSE, "Redefining datasize.");
                 } else if (tmpres != ISC_R_SUCCESS) {
@@ -1236,7 +1222,7 @@ size_clause: L_DATASIZE size_spec
         }
         | L_STACKSIZE size_spec
         {
-                tmpres = dns_c_ctx_setstacksize(logcontext, currcfg, $2);
+                tmpres = dns_c_ctx_setstacksize(currcfg, $2);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_error(ISC_FALSE, "Redefining stacksize.");
                 } else if (tmpres != ISC_R_SUCCESS) {
@@ -1246,7 +1232,7 @@ size_clause: L_DATASIZE size_spec
         }
         | L_CORESIZE size_spec
         {
-                tmpres = dns_c_ctx_setcoresize(logcontext, currcfg, $2);
+                tmpres = dns_c_ctx_setcoresize(currcfg, $2);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_error(ISC_FALSE, "Redefining coresize.");
                 } else if (tmpres != ISC_R_SUCCESS) {
@@ -1256,7 +1242,7 @@ size_clause: L_DATASIZE size_spec
         }
         | L_FILES size_spec
         {
-                tmpres = dns_c_ctx_setfiles(logcontext, currcfg, $2);
+                tmpres = dns_c_ctx_setfiles(currcfg, $2);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_error(ISC_FALSE, "Redefining files.");
                 } else if (tmpres != ISC_R_SUCCESS) {
@@ -1315,7 +1301,7 @@ size_spec: any_string
 
 transfer_clause: L_TRANSFERS_IN L_INTEGER
         {
-                tmpres = dns_c_ctx_settransfersin(logcontext, currcfg, $2);
+                tmpres = dns_c_ctx_settransfersin(currcfg, $2);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_error(ISC_FALSE, "Redefining transfers-in.");
                 } else if (tmpres != ISC_R_SUCCESS) {
@@ -1325,7 +1311,7 @@ transfer_clause: L_TRANSFERS_IN L_INTEGER
         }
         | L_TRANSFERS_OUT L_INTEGER
         {
-                tmpres = dns_c_ctx_settransfersout(logcontext, currcfg, $2);
+                tmpres = dns_c_ctx_settransfersout(currcfg, $2);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_error(ISC_FALSE,
                                      "Redefining transfers-out.");
@@ -1337,7 +1323,7 @@ transfer_clause: L_TRANSFERS_IN L_INTEGER
         }
         | L_TRANSFERS_PER_NS L_INTEGER
         {
-                tmpres = dns_c_ctx_settransfersperns(logcontext, currcfg, $2);
+                tmpres = dns_c_ctx_settransfersperns(currcfg, $2);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_error(ISC_FALSE,
                                      "Redefining transfers-per-ns.");
@@ -1366,7 +1352,7 @@ forwarders_in_addr: ip_address
                 INSIST(currcfg->options != NULL);
                 INSIST(currcfg->options->forwarders != NULL);
 
-                tmpres = dns_c_ipmatchpattern_new(logcontext, currcfg->mem,
+                tmpres = dns_c_ipmatchpattern_new(currcfg->mem,
                                                   &ime,
                                                   $1, 0);
                 if (tmpres != ISC_R_SUCCESS) {
@@ -1407,7 +1393,7 @@ channel_stmt:
         L_CHANNEL channel_name L_LBRACE L_FILE L_QSTRING {
                 dns_c_logchan_t *newc;
                 
-                tmpres = dns_c_ctx_addfile_channel(logcontext, currcfg,
+                tmpres = dns_c_ctx_addfile_channel(currcfg,
                                                    $2, &newc);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_warning(ISC_FALSE,
@@ -1420,7 +1406,7 @@ channel_stmt:
 
                 INSIST(newc != NULL);
 
-                tmpres = dns_c_logchan_setpath(logcontext, newc, $5);
+                tmpres = dns_c_logchan_setpath(newc, $5);
                 if (tmpres != ISC_R_SUCCESS) {
                         parser_error(ISC_FALSE,
                                      "Failed to add file channel's path.");
@@ -1433,7 +1419,7 @@ channel_stmt:
         | L_CHANNEL channel_name L_LBRACE L_SYSLOG maybe_syslog_facility {
                 dns_c_logchan_t *newc;
                 
-                tmpres = dns_c_ctx_addsyslogchannel(logcontext, currcfg,
+                tmpres = dns_c_ctx_addsyslogchannel(currcfg,
                                                     $2, &newc);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_warning(ISC_FALSE, "Redefining channel %s", $2);
@@ -1443,7 +1429,7 @@ channel_stmt:
                         YYABORT;
                 }
 
-                tmpres = dns_c_logchan_setfacility(logcontext, newc, $5);
+                tmpres = dns_c_logchan_setfacility(newc, $5);
                 if (tmpres != ISC_R_SUCCESS) {
                         parser_error(ISC_FALSE,
                                      "Can't get set channel facility.");
@@ -1454,7 +1440,7 @@ channel_stmt:
         | L_CHANNEL channel_name L_LBRACE L_NULL_OUTPUT {
                 dns_c_logchan_t *newc;
                 
-                tmpres = dns_c_ctx_addnullchannel(logcontext, currcfg,
+                tmpres = dns_c_ctx_addnullchannel(currcfg,
                                                   $2, &newc);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_warning(ISC_FALSE, "Redefining channel %s", $2);
@@ -1487,7 +1473,7 @@ optional_channel_opt_list: /* empty */
 category_stmt: L_CATEGORY category_name {
                 dns_c_logcat_t *cat;
                 
-                tmpres = dns_c_ctx_addcategory(logcontext, currcfg, $2, &cat);
+                tmpres = dns_c_ctx_addcategory(currcfg, $2, &cat);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_warning(ISC_FALSE,
                                        "Redefining category ``%s''", $2);
@@ -1505,21 +1491,21 @@ channel_severity: any_string
                 dns_c_logseverity_t severity;
                 dns_c_logchan_t *chan;
 
-                tmpres = dns_c_string2logseverity(logcontext, $1, &severity);
+                tmpres = dns_c_string2logseverity($1, &severity);
                 if (tmpres != ISC_R_SUCCESS) {
                         parser_error(ISC_FALSE,
                                      "Unknown severity ``%s''", $1);
                         YYABORT;
                 }
 
-                tmpres = dns_c_ctx_currchannel(logcontext, currcfg, &chan);
+                tmpres = dns_c_ctx_currchannel(currcfg, &chan);
                 if (tmpres != ISC_R_SUCCESS) {
                         parser_error(ISC_FALSE,
                                      "Can't get current channel.");
                         YYABORT;
                 }
 
-                tmpres = dns_c_logchan_setseverity(logcontext, chan, severity);
+                tmpres = dns_c_logchan_setseverity(chan, severity);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_warning(ISC_FALSE, "Redefining severity.");
                 } else if (tmpres != ISC_R_SUCCESS) {
@@ -1534,14 +1520,14 @@ channel_severity: any_string
         {
                 dns_c_logchan_t *chan;
 
-                tmpres = dns_c_ctx_currchannel(logcontext, currcfg, &chan);
+                tmpres = dns_c_ctx_currchannel(currcfg, &chan);
                 if (tmpres != ISC_R_SUCCESS) {
                         parser_error(ISC_FALSE,
                                      "Can't get current channel.");
                         YYABORT;
                 }
 
-                tmpres = dns_c_logchan_setseverity(logcontext, chan,
+                tmpres = dns_c_logchan_setseverity(chan,
                                                    dns_c_log_debug);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_warning(ISC_FALSE, "Redefining severity.");
@@ -1555,14 +1541,14 @@ channel_severity: any_string
         {
                 dns_c_logchan_t *chan;
 
-                tmpres = dns_c_ctx_currchannel(logcontext, currcfg, &chan);
+                tmpres = dns_c_ctx_currchannel(currcfg, &chan);
                 if (tmpres != ISC_R_SUCCESS) {
                         parser_error(ISC_FALSE,
                                      "Can't get current channel.");
                         YYABORT;
                 }
 
-                tmpres = dns_c_logchan_setseverity(logcontext, chan,
+                tmpres = dns_c_logchan_setseverity(chan,
                                                    dns_c_log_debug);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_warning(ISC_FALSE, "Redefining severity.");
@@ -1573,7 +1559,7 @@ channel_severity: any_string
                         YYABORT;
                 }
 
-                tmpres = dns_c_logchan_setdebuglevel(logcontext, chan, $2);
+                tmpres = dns_c_logchan_setdebuglevel(chan, $2);
                 if (tmpres != ISC_R_SUCCESS) {
                         parser_error(ISC_FALSE,
                                      "Can't get set channel "
@@ -1585,14 +1571,14 @@ channel_severity: any_string
         {
                 dns_c_logchan_t *chan;
 
-                tmpres = dns_c_ctx_currchannel(logcontext, currcfg, &chan);
+                tmpres = dns_c_ctx_currchannel(currcfg, &chan);
                 if (tmpres != ISC_R_SUCCESS) {
                         parser_error(ISC_FALSE,
                                      "Can't get current channel.");
                         YYABORT;
                 }
 
-                tmpres = dns_c_logchan_setseverity(logcontext, chan,
+                tmpres = dns_c_logchan_setseverity(chan,
                                                    dns_c_log_dynamic);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_warning(ISC_FALSE, "Redefining severity.");
@@ -1609,14 +1595,14 @@ version_modifier: L_VERSIONS L_INTEGER
         {
                 dns_c_logchan_t *chan;
 
-                tmpres = dns_c_ctx_currchannel(logcontext, currcfg, &chan);
+                tmpres = dns_c_ctx_currchannel(currcfg, &chan);
                 if (tmpres != ISC_R_SUCCESS) {
                         parser_error(ISC_FALSE,
                                      "Can't get current channel.");
                         YYABORT;
                 }
 
-                tmpres = dns_c_logchan_setversions(logcontext, chan, $2);
+                tmpres = dns_c_logchan_setversions(chan, $2);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_warning(ISC_FALSE, "Redefining versions.");
                 } else if (tmpres != ISC_R_SUCCESS) {
@@ -1629,14 +1615,14 @@ version_modifier: L_VERSIONS L_INTEGER
         {
                 dns_c_logchan_t *chan;
 
-                tmpres = dns_c_ctx_currchannel(logcontext, currcfg, &chan);
+                tmpres = dns_c_ctx_currchannel(currcfg, &chan);
                 if (tmpres != ISC_R_SUCCESS) {
                         parser_error(ISC_FALSE,
                                      "Can't get current channel.");
                         YYABORT;
                 }
 
-                tmpres = dns_c_logchan_setversions(logcontext, chan, -1);
+                tmpres = dns_c_logchan_setversions(chan, -1);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_warning(ISC_FALSE, "Redefining versions.");
                 } else if (tmpres != ISC_R_SUCCESS) {
@@ -1652,14 +1638,14 @@ size_modifier: L_SIZE size_spec
         {
                 dns_c_logchan_t *chan;
 
-                tmpres = dns_c_ctx_currchannel(logcontext, currcfg, &chan);
+                tmpres = dns_c_ctx_currchannel(currcfg, &chan);
                 if (tmpres != ISC_R_SUCCESS) {
                         parser_error(ISC_FALSE,
                                      "Can't get current channel.");
                         YYABORT;
                 }
 
-                tmpres = dns_c_logchan_setsize(logcontext, chan, $2);
+                tmpres = dns_c_logchan_setsize(chan, $2);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_warning(ISC_FALSE, "Redefining size.");
                 } else if (tmpres != ISC_R_SUCCESS) {
@@ -1679,7 +1665,7 @@ maybe_file_modifiers: /* nothing */
 
 facility_name: any_string
         {
-                tmpres = dns_c_string2facility(logcontext, $1, &$$);
+                tmpres = dns_c_string2facility($1, &$$);
                 if (tmpres != ISC_R_SUCCESS) {
                         parser_error(ISC_TRUE, "Unknown syslog facility.");
                         $$ = LOG_DAEMON;
@@ -1714,14 +1700,14 @@ channel_opt: L_SEVERITY channel_severity { /* nothing to do */ }
         {
                 dns_c_logchan_t *chan;
 
-                tmpres = dns_c_ctx_currchannel(logcontext, currcfg, &chan);
+                tmpres = dns_c_ctx_currchannel(currcfg, &chan);
                 if (tmpres != ISC_R_SUCCESS) {
                         parser_error(ISC_FALSE,
                                      "Can't get current channel.");
                         YYABORT;
                 }
 
-                tmpres = dns_c_logchan_setprinttime(logcontext, chan, $2);
+                tmpres = dns_c_logchan_setprinttime(chan, $2);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_warning(ISC_FALSE, "Redefining print-time.");
                 } else if (tmpres != ISC_R_SUCCESS) {
@@ -1734,14 +1720,14 @@ channel_opt: L_SEVERITY channel_severity { /* nothing to do */ }
         {
                 dns_c_logchan_t *chan;
 
-                tmpres = dns_c_ctx_currchannel(logcontext, currcfg, &chan);
+                tmpres = dns_c_ctx_currchannel(currcfg, &chan);
                 if (tmpres != ISC_R_SUCCESS) {
                         parser_error(ISC_FALSE,
                                      "Can't get current channel.");
                         YYABORT;
                 }
 
-                tmpres = dns_c_logchan_setprintcat(logcontext, chan, $2);
+                tmpres = dns_c_logchan_setprintcat(chan, $2);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_warning(ISC_FALSE,
                                        "Redefining print-category.");
@@ -1755,14 +1741,14 @@ channel_opt: L_SEVERITY channel_severity { /* nothing to do */ }
         {
                 dns_c_logchan_t *chan;
 
-                tmpres = dns_c_ctx_currchannel(logcontext, currcfg, &chan);
+                tmpres = dns_c_ctx_currchannel(currcfg, &chan);
                 if (tmpres != ISC_R_SUCCESS) {
                         parser_error(ISC_FALSE,
                                      "Can't get current channel.");
                         YYABORT;
                 }
 
-                tmpres = dns_c_logchan_setprintsev(logcontext, chan, $2);
+                tmpres = dns_c_logchan_setprintsev(chan, $2);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_warning(ISC_FALSE,
                                        "Redefining print-severity.");
@@ -1791,14 +1777,14 @@ channel: channel_name
                  * XXX validate the channel name refers to a previously
                  * defined channel
                  */
-                tmpres = dns_c_ctx_currcategory(logcontext, currcfg, &cat);
+                tmpres = dns_c_ctx_currcategory(currcfg, &cat);
                 if (tmpres != ISC_R_SUCCESS) {
                         parser_error(ISC_FALSE,
                                      "Can't get current category.");
                         YYABORT;
                 }
 
-                tmpres = dns_c_logcat_addname(logcontext, cat, $1);
+                tmpres = dns_c_logcat_addname(cat, $1);
                 if (tmpres != ISC_R_SUCCESS) {
                         parser_error(ISC_FALSE,
                                      "Can't add new name to category.");
@@ -1818,7 +1804,7 @@ category_name: any_string
         {
                 dns_c_category_t cat;
 
-                tmpres = dns_c_string2category(logcontext, $1, &cat);
+                tmpres = dns_c_string2category($1, &cat);
                 if (tmpres != ISC_R_SUCCESS) {
                         parser_error(ISC_FALSE, "Unknown category ``%s''", $1);
                         YYABORT;
@@ -1849,7 +1835,7 @@ server_stmt: L_SERVER ip_address
                 dns_c_srvlist_t *servers = currcfg->servers;
                 
                 if (servers == NULL) {
-                        tmpres = dns_c_srvlist_new(logcontext, currcfg->mem,
+                        tmpres = dns_c_srvlist_new(currcfg->mem,
                                                    &currcfg->servers);
                         if (tmpres != ISC_R_SUCCESS) {
                                 parser_error(ISC_FALSE,
@@ -1871,13 +1857,13 @@ server_stmt: L_SERVER ip_address
                                 parser_error(ISC_TRUE, "Redefining server");
                                 ISC_LIST_UNLINK(servers->elements,
                                                 server, next);
-                                dns_c_srv_delete(logcontext, &server);
+                                dns_c_srv_delete(&server);
                                 break;
                         }
                         server = tmpserver;
                 }
                 
-                tmpres = dns_c_srv_new(logcontext, currcfg->mem, $2, &server);
+                tmpres = dns_c_srv_new(currcfg->mem, $2, &server);
                 if (tmpres != ISC_R_SUCCESS) {
                         parser_error(ISC_FALSE,
                                      "Failed to create server structure");
@@ -1903,13 +1889,13 @@ server_info: L_BOGUS yea_or_nay
 
                 INSIST(server != NULL);
 
-                tmpres = dns_c_srv_getbogus(logcontext, server, &tv);
+                tmpres = dns_c_srv_getbogus(server, &tv);
                 if (tmpres != ISC_R_NOTFOUND) {
                         parser_warning(ISC_FALSE,
                                        "Redefining server bogus value");
                 }
                 
-                dns_c_srv_setbogus(logcontext, server, $2);
+                dns_c_srv_setbogus(server, $2);
         }
         | L_SUPPORT_IXFR yea_or_nay
         {
@@ -1921,13 +1907,13 @@ server_info: L_BOGUS yea_or_nay
 
                 INSIST(server != NULL);
 
-                tmpres = dns_c_srv_getsupportixfr(logcontext, server, &tv);
+                tmpres = dns_c_srv_getsupportixfr(server, &tv);
                 if(tmpres != ISC_R_NOTFOUND) {
                         parser_warning(ISC_FALSE,
                                        "Redefining server support-ixfr value");
                 }
                 
-                dns_c_srv_setsupportixfr(logcontext, server, $2);
+                dns_c_srv_setsupportixfr(server, $2);
         }
         | L_TRANSFERS L_INTEGER
         {
@@ -1939,13 +1925,13 @@ server_info: L_BOGUS yea_or_nay
 
                 INSIST(server != NULL);
 
-                tmpres = dns_c_srv_gettransfers(logcontext, server, &tv);
+                tmpres = dns_c_srv_gettransfers(server, &tv);
                 if (tmpres != ISC_R_NOTFOUND) {
                         parser_warning(ISC_FALSE,
                                        "Redefining server transfers value");
                 }
                 
-                dns_c_srv_settransfers(logcontext, server, $2);
+                dns_c_srv_settransfers(server, $2);
         }
         | L_TRANSFER_FORMAT transfer_format
         {
@@ -1957,7 +1943,7 @@ server_info: L_BOGUS yea_or_nay
 
                 INSIST(server != NULL);
 
-                tmpres = dns_c_srv_gettransferformat(logcontext, server, &tv);
+                tmpres = dns_c_srv_gettransferformat(server, &tv);
                 if (tmpres != ISC_R_NOTFOUND) {
                         parser_warning(ISC_FALSE,
                                        "Redefining server transfer-format "
@@ -1965,7 +1951,7 @@ server_info: L_BOGUS yea_or_nay
                 }
                 
 
-                dns_c_srv_settransferformat(logcontext, server, $2);
+                dns_c_srv_settransferformat(server, $2);
         }
         | L_KEYS L_LBRACE {
                 dns_c_srv_t *server;
@@ -1975,7 +1961,7 @@ server_info: L_BOGUS yea_or_nay
                 INSIST(server != NULL);
 
                 if (server->keys == NULL) {
-                        tmpres = dns_c_kidlist_new(logcontext, currcfg->mem,
+                        tmpres = dns_c_kidlist_new(currcfg->mem,
                                                    &server->keys);
                         if (tmpres != ISC_R_SUCCESS) {
                                 parser_error(ISC_FALSE,
@@ -1995,12 +1981,10 @@ address_match_list: address_match_element L_EOS
                 dns_c_ipmatchlist_t *ml = 0;
 
                 if ($1 != NULL) {
-                        tmpres = dns_c_ipmatchlist_new(logcontext,
-                                                       currcfg->mem, &ml);
+                        tmpres = dns_c_ipmatchlist_new(currcfg->mem, &ml);
                         if (tmpres != ISC_R_SUCCESS) {
                                 parser_error(ISC_FALSE, "Insufficient memory");
-                                dns_c_ipmatchelement_delete(logcontext,
-                                                            currcfg->mem,
+                                dns_c_ipmatchelement_delete(currcfg->mem,
                                                             &$1);
                                 YYABORT;
                         }
@@ -2015,12 +1999,10 @@ address_match_list: address_match_element L_EOS
                 dns_c_ipmatchlist_t *ml = $1;
                 
                 if (ml == NULL && $2 != NULL) {
-                        tmpres = dns_c_ipmatchlist_new(logcontext,
-                                                       currcfg->mem, &ml);
+                        tmpres = dns_c_ipmatchlist_new(currcfg->mem, &ml);
                         if (tmpres != ISC_R_SUCCESS) {
                                 parser_error(ISC_FALSE, "Insufficient memory");
-                                dns_c_ipmatchelement_delete(logcontext,
-                                                            currcfg->mem,
+                                dns_c_ipmatchelement_delete(currcfg->mem,
                                                             &$2);
                                 YYABORT;
                         }
@@ -2038,7 +2020,7 @@ address_match_element: address_match_simple
         | L_BANG address_match_simple
         {
                 if ($2 != NULL) {
-                        dns_c_ipmatch_negate(logcontext, $2);
+                        dns_c_ipmatch_negate($2);
                 }
                 $$ = $2;
         }
@@ -2046,14 +2028,13 @@ address_match_element: address_match_simple
         {
                 dns_c_ipmatchelement_t *ime = NULL;
 
-                if (!dns_c_ctx_keydefinedp(logcontext, currcfg, $2)) {
+                if (!dns_c_ctx_keydefinedp(currcfg, $2)) {
                         parser_error(ISC_FALSE,
                                      "Address match key element (%s) "
                                      "referenced before defined", $2);
                         YYABORT;
                 } else {
-                        tmpres = dns_c_ipmatchkey_new(logcontext,
-                                                      currcfg->mem, &ime, $2);
+                        tmpres = dns_c_ipmatchkey_new(currcfg->mem, &ime, $2);
                         if (tmpres != ISC_R_SUCCESS) {
                                 parser_error(ISC_TRUE,
                                              "Failed to create address match "
@@ -2070,7 +2051,8 @@ address_match_element: address_match_simple
 address_match_simple: ip_address
         {
                 dns_c_ipmatchelement_t *ime = NULL;
-		unsigned int prefixlen;
+		unsigned int prefixlen = 0;
+		
 		switch ($1.type.sa.sa_family) {
 		case AF_INET:
 			prefixlen = 32;
@@ -2082,8 +2064,7 @@ address_match_simple: ip_address
 			INSIST(0);
 			break;
 		}
-                tmpres = dns_c_ipmatchpattern_new(logcontext,
-                                                  currcfg->mem, &ime, $1,
+                tmpres = dns_c_ipmatchpattern_new(currcfg->mem, &ime, $1,
 						  prefixlen);
                 switch (tmpres) {
                 case ISC_R_FAILURE:
@@ -2115,8 +2096,7 @@ address_match_simple: ip_address
                                        "skipping", (int)$3);
                         $$ = NULL;
                 } else {
-                        tmpres = dns_c_ipmatchpattern_new(logcontext,
-                                                          currcfg->mem, &ime,
+                        tmpres = dns_c_ipmatchpattern_new(currcfg->mem, &ime,
                                                           $1, $3);
                         switch (tmpres) {
                         case ISC_R_FAILURE:
@@ -2160,8 +2140,7 @@ address_match_simple: ip_address
 				isc_sockaddr_fromin(&address, &ia, 0);
 				
                                 tmpres =
-                                        dns_c_ipmatchpattern_new(logcontext,
-                                                                 currcfg->mem,
+                                        dns_c_ipmatchpattern_new(currcfg->mem,
                                                                  &ime,
                                                                  address,
                                                                  $3);
@@ -2194,8 +2173,7 @@ address_match_simple: ip_address
                 dns_c_ipmatchelement_t *ime = NULL;
                 
                 if ($2 != NULL) {
-                        tmpres = dns_c_ipmatchindirect_new(logcontext,
-                                                           currcfg->mem, &ime,
+                        tmpres = dns_c_ipmatchindirect_new(currcfg->mem, &ime,
                                                            $2, NULL);
                         switch (tmpres) {
                         case ISC_R_SUCCESS:
@@ -2210,7 +2188,7 @@ address_match_simple: ip_address
                         }
                 }
 
-                dns_c_ipmatchlist_detach(logcontext, &$2);
+                dns_c_ipmatchlist_detach(&$2);
 
                 $$ = ime;
         }
@@ -2221,7 +2199,7 @@ address_name: any_string
                 dns_c_ipmatchelement_t *elem;
                 dns_c_acl_t *acl;
 
-                tmpres = dns_c_acltable_getacl(logcontext, currcfg->acls,
+                tmpres = dns_c_acltable_getacl(currcfg->acls,
                                                $1, &acl);
                 if (tmpres == ISC_R_NOTFOUND) {
                         parser_warning(ISC_FALSE,
@@ -2229,8 +2207,7 @@ address_name: any_string
                                        $1);
                         elem = NULL;
                 } else {
-                        tmpres = dns_c_ipmatch_aclnew(logcontext,
-                                                      currcfg->mem, &elem, $1);
+                        tmpres = dns_c_ipmatch_aclnew(currcfg->mem, &elem, $1);
                         if (tmpres != ISC_R_SUCCESS) {
                                 parser_error(ISC_FALSE,
                                              "Failed to create IPE-ACL");
@@ -2261,14 +2238,13 @@ key_list_element: key_ref
 
                 INSIST(currserver->keys != NULL);
 
-                if (!dns_c_ctx_keydefinedp(logcontext, currcfg, $1)) {
+                if (!dns_c_ctx_keydefinedp(currcfg, $1)) {
                         parser_error(ISC_FALSE,
                                      "Server keys key_id (%s) "
                                      "referenced before defined", $1);
                         YYABORT;
                 } else {
-                        tmpres = dns_c_kid_new(logcontext,
-                                               currserver->keys, $1, &keyid);
+                        tmpres = dns_c_kid_new(currserver->keys, $1, &keyid);
                         if (tmpres != ISC_R_SUCCESS) {
                                 parser_error(ISC_FALSE,
                                              "Failed to create keyid");
@@ -2297,7 +2273,7 @@ key_stmt: L_SEC_KEY any_string
                 dns_c_kdef_t *keydef;
                 
                 if (currcfg->keydefs == NULL) {
-                        tmpres = dns_c_kdeflist_new(logcontext, currcfg->mem,
+                        tmpres = dns_c_kdeflist_new(currcfg->mem,
                                                     &currcfg->keydefs);
                         if (tmpres != ISC_R_SUCCESS) {
                                 parser_error(ISC_FALSE,
@@ -2306,7 +2282,7 @@ key_stmt: L_SEC_KEY any_string
                         }
                 }
                 
-                tmpres = dns_c_kdef_new(logcontext, currcfg->keydefs,
+                tmpres = dns_c_kdef_new(currcfg->keydefs,
                                         $2, &keydef);
                 if (tmpres != ISC_R_SUCCESS) {
                         parser_error(ISC_FALSE,
@@ -2328,8 +2304,8 @@ key_definition: algorithm_id secret
                 keydef = ISC_LIST_TAIL(currcfg->keydefs->keydefs);
                 INSIST(keydef != NULL);
 
-                dns_c_kdef_setalgorithm(logcontext, keydef, $1);
-                dns_c_kdef_setsecret(logcontext, keydef, $2);
+                dns_c_kdef_setalgorithm(keydef, $1);
+                dns_c_kdef_setsecret(keydef, $2);
 
                 isc_mem_free(memctx, $1);
                 isc_mem_free(memctx, $2);
@@ -2343,8 +2319,8 @@ key_definition: algorithm_id secret
                 keydef = ISC_LIST_TAIL(currcfg->keydefs->keydefs);
                 INSIST(keydef != NULL);
 
-                dns_c_kdef_setsecret(logcontext, keydef, $1);
-                dns_c_kdef_setalgorithm(logcontext, keydef, $2);
+                dns_c_kdef_setsecret(keydef, $1);
+                dns_c_kdef_setalgorithm(keydef, $2);
 
                 isc_mem_free(memctx, $1);
                 isc_mem_free(memctx, $2);
@@ -2374,7 +2350,7 @@ view_stmt: L_VIEW any_string L_LBRACE
                 dns_c_view_t *view;
 
                 if (currcfg->views == NULL) {
-                        tmpres = dns_c_viewtable_new(logcontext, currcfg->mem,
+                        tmpres = dns_c_viewtable_new(currcfg->mem,
                                                      &currcfg->views);
                         if (tmpres != ISC_R_SUCCESS) {
                                 parser_error(ISC_FALSE,
@@ -2383,19 +2359,19 @@ view_stmt: L_VIEW any_string L_LBRACE
                         }
                 }
                 
-                tmpres = dns_c_view_new(logcontext, currcfg->mem, $2, &view);
+                tmpres = dns_c_view_new(currcfg->mem, $2, &view);
                 if (tmpres != ISC_R_SUCCESS) {
                         parser_error(ISC_FALSE,
                                      "Failed to create view %s", $2);
                         YYABORT;
                 }
 
-                dns_c_viewtable_addview(logcontext, currcfg->views, view);
-		dns_c_ctx_setcurrview(logcontext, currcfg, view);
+                dns_c_viewtable_addview(currcfg->views, view);
+		dns_c_ctx_setcurrview(currcfg, view);
 
 		isc_mem_free(memctx, $2);
         } optional_view_options_list L_RBRACE {
-		dns_c_ctx_setcurrview(logcontext, currcfg, NULL);
+		dns_c_ctx_setcurrview(currcfg, NULL);
         };
 
 optional_view_options_list:
@@ -2408,12 +2384,11 @@ view_options_list: view_option L_EOS
 
 view_option: L_ALLOW_QUERY L_LBRACE address_match_list L_RBRACE
         {
-                dns_c_view_t *view = dns_c_ctx_getcurrview(logcontext,
-							   currcfg);
+                dns_c_view_t *view = dns_c_ctx_getcurrview(currcfg);
 
                 INSIST(view != NULL);
 
-                tmpres = dns_c_view_setallowquery(logcontext, view, $3,
+                tmpres = dns_c_view_setallowquery(view, $3,
                                                   ISC_FALSE);
                 switch (tmpres) {
                 case ISC_R_EXISTS:
@@ -2450,7 +2425,7 @@ acl_stmt: L_ACL any_string L_LBRACE address_match_list L_RBRACE
 
                 INSIST(currcfg->acls != NULL);
                         
-                tmpres = dns_c_acl_new(logcontext, currcfg->acls,
+                tmpres = dns_c_acl_new(currcfg->acls,
                                        $2, ISC_FALSE, &acl);
                 if (tmpres != ISC_R_SUCCESS) {
                         parser_error(ISC_FALSE,
@@ -2458,7 +2433,7 @@ acl_stmt: L_ACL any_string L_LBRACE address_match_list L_RBRACE
                         YYABORT;
                 }
                 
-                dns_c_acl_setipml(logcontext, acl, $4, ISC_FALSE);
+                dns_c_acl_setipml(acl, $4, ISC_FALSE);
                         
                 isc_mem_free(memctx, $2);
         }
@@ -2484,10 +2459,10 @@ zone_stmt: L_ZONE domain_name optional_class L_LBRACE L_TYPE zone_type L_EOS
                 dns_c_zone_t *zone;
 
                 if (currcfg->zlist == NULL) {
-                        tmpres = dns_c_zonelist_new(logcontext, currcfg->mem,
+                        tmpres = dns_c_zonelist_new(currcfg->mem,
                                                     &currcfg->zlist);
                         if (tmpres != ISC_R_SUCCESS) {
-                                isc_log_write(logcontext,
+                                isc_log_write(dns_lctx,
                                               DNS_LOGCATEGORY_CONFIG,
                                               DNS_LOGMODULE_CONFIG,
                                               ISC_LOG_CRITICAL,
@@ -2497,10 +2472,10 @@ zone_stmt: L_ZONE domain_name optional_class L_LBRACE L_TYPE zone_type L_EOS
                 }
 
 		/* XXX internal name support needed! */
-                tmpres = dns_c_zone_new(logcontext, currcfg->mem,
+                tmpres = dns_c_zone_new(currcfg->mem,
                                         $6, $3, $2, $2, &zone);
                 if (tmpres != ISC_R_SUCCESS) {
-                        isc_log_write(logcontext, DNS_LOGCATEGORY_CONFIG,
+                        isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
                                       DNS_LOGMODULE_CONFIG,
                                       ISC_LOG_CRITICAL,
                                       "Error creating new zone.");
@@ -2511,28 +2486,27 @@ zone_stmt: L_ZONE domain_name optional_class L_LBRACE L_TYPE zone_type L_EOS
                         zone->afteropts = ISC_TRUE;
                 }
 
-		tmpres = dns_c_zonelist_addzone(logcontext,
-						currcfg->zlist, zone);
+		tmpres = dns_c_zonelist_addzone(currcfg->zlist, zone);
 		if (tmpres != ISC_R_SUCCESS) {
-			dns_c_zone_detach(logcontext, &zone);
-                        isc_log_write(logcontext, DNS_LOGCATEGORY_CONFIG,
+			dns_c_zone_detach(&zone);
+                        isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
                                       DNS_LOGMODULE_CONFIG,
                                       ISC_LOG_CRITICAL,
                                       "Error adding new zone to list.");
                         YYABORT;
 		}
 
-		dns_c_ctx_setcurrzone(logcontext, currcfg, zone);
+		dns_c_ctx_setcurrzone(currcfg, zone);
 		
                 isc_mem_free(memctx, $2);
         } optional_zone_options_list L_RBRACE {
                 dns_c_zone_t *zone;
 		dns_c_view_t *view;
 		
-		zone = dns_c_ctx_getcurrzone(logcontext, currcfg);
-		view = dns_c_ctx_getcurrview(logcontext, currcfg);
+		zone = dns_c_ctx_getcurrzone(currcfg);
+		view = dns_c_ctx_getcurrview(currcfg);
 		
-		dns_c_ctx_setcurrzone(logcontext, currcfg, NULL);
+		dns_c_ctx_setcurrzone(currcfg, NULL);
 
                 if (callbacks != NULL && callbacks->zonecbk != NULL) {
                         tmpres = callbacks->zonecbk(currcfg,
@@ -2540,8 +2514,7 @@ zone_stmt: L_ZONE domain_name optional_class L_LBRACE L_TYPE zone_type L_EOS
 						    view,
                                                     callbacks->zonecbkuap);
                         if (tmpres != ISC_R_SUCCESS) {
-				isc_log_write(logcontext,
-					      DNS_LOGCATEGORY_CONFIG,
+				isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 					      DNS_LOGMODULE_CONFIG,
 					      ISC_LOG_CRITICAL,
 					      "zone callback failed: %s",
@@ -2549,8 +2522,7 @@ zone_stmt: L_ZONE domain_name optional_class L_LBRACE L_TYPE zone_type L_EOS
                                 YYABORT;
                         }
 
-                        dns_c_zonelist_rmzone(logcontext,
-                                              currcfg->zlist, zone);
+                        dns_c_zonelist_rmzone(currcfg->zlist, zone);
                 }
         }
         | L_ZONE domain_name optional_class L_LBRACE zone_non_type_keywords
@@ -2640,12 +2612,11 @@ zone_non_type_keywords: L_FILE | L_FILE_IXFR | L_IXFR_TMP | L_MASTERS |
 
 zone_option: L_FILE L_QSTRING
         {
-                dns_c_zone_t *zone = dns_c_ctx_getcurrzone(logcontext,
-							   currcfg);
+                dns_c_zone_t *zone = dns_c_ctx_getcurrzone(currcfg);
 
                 INSIST(zone != NULL);
 
-                tmpres = dns_c_zone_setfile(logcontext, zone, $2);
+                tmpres = dns_c_zone_setfile(zone, $2);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_warning(ISC_FALSE,
                                        "redefining zone filename.");
@@ -2657,12 +2628,11 @@ zone_option: L_FILE L_QSTRING
         }
         | L_FILE_IXFR L_QSTRING
         {
-                dns_c_zone_t *zone = dns_c_ctx_getcurrzone(logcontext,
-							     currcfg);
+                dns_c_zone_t *zone = dns_c_ctx_getcurrzone(currcfg);
 
                 INSIST(zone != NULL);
 
-                tmpres = dns_c_zone_setixfrbase(logcontext, zone, $2);
+                tmpres = dns_c_zone_setixfrbase(zone, $2);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_warning(ISC_FALSE,
                                        "Redefining ixfr-base.");
@@ -2674,12 +2644,11 @@ zone_option: L_FILE L_QSTRING
         }
         | L_IXFR_TMP L_QSTRING
         {
-                dns_c_zone_t *zone = dns_c_ctx_getcurrzone(logcontext,
-							     currcfg);
+                dns_c_zone_t *zone = dns_c_ctx_getcurrzone(currcfg);
 
                 INSIST(zone != NULL);
 
-                tmpres = dns_c_zone_setixfrtmp(logcontext, zone, $2);
+                tmpres = dns_c_zone_setixfrtmp(zone, $2);
                 if (tmpres == ISC_R_EXISTS) {
                         parser_warning(ISC_FALSE,
                                        "Redefining ixfr-tmp-file.");
@@ -2691,12 +2660,11 @@ zone_option: L_FILE L_QSTRING
         }
         | L_MASTERS maybe_zero_port L_LBRACE master_in_addr_list L_RBRACE
         {
-                dns_c_zone_t *zone = dns_c_ctx_getcurrzone(logcontext,
-							     currcfg);
+                dns_c_zone_t *zone = dns_c_ctx_getcurrzone(currcfg);
 
                 INSIST(zone != NULL);
 
-                tmpres = dns_c_zone_setmasterport(logcontext, zone, $2);
+                tmpres = dns_c_zone_setmasterport(zone, $2);
                 switch (tmpres) {
                 case ISC_R_EXISTS:
                         parser_warning(ISC_FALSE,
@@ -2713,7 +2681,7 @@ zone_option: L_FILE L_QSTRING
 			break;
                 }
 
-                tmpres = dns_c_zone_setmasterips(logcontext, zone,
+                tmpres = dns_c_zone_setmasterips(zone,
                                                  $4, ISC_FALSE);
                 switch (tmpres) {
                 case ISC_R_EXISTS:
@@ -2733,12 +2701,11 @@ zone_option: L_FILE L_QSTRING
         }
         | L_TRANSFER_SOURCE maybe_wild_addr
         {
-                dns_c_zone_t *zone = dns_c_ctx_getcurrzone(logcontext,
-							     currcfg);
+                dns_c_zone_t *zone = dns_c_ctx_getcurrzone(currcfg);
 
                 INSIST(zone != NULL);
 
-                tmpres = dns_c_zone_settransfersource(logcontext, zone, $2);
+                tmpres = dns_c_zone_settransfersource(zone, $2);
                 switch (tmpres) {
                 case ISC_R_EXISTS:
                         parser_warning(ISC_FALSE,
@@ -2757,12 +2724,11 @@ zone_option: L_FILE L_QSTRING
         }
         | L_CHECK_NAMES check_names_opt
         {
-                dns_c_zone_t *zone = dns_c_ctx_getcurrzone(logcontext,
-							     currcfg);
+                dns_c_zone_t *zone = dns_c_ctx_getcurrzone(currcfg);
 
                 INSIST(zone != NULL);
 
-                tmpres = dns_c_zone_setchecknames(logcontext, zone, $2);
+                tmpres = dns_c_zone_setchecknames(zone, $2);
                 switch (tmpres) {
                 case ISC_R_EXISTS:
                         parser_warning(ISC_FALSE,
@@ -2781,12 +2747,11 @@ zone_option: L_FILE L_QSTRING
         }
         | L_ALLOW_UPDATE L_LBRACE address_match_list L_RBRACE
         {
-                dns_c_zone_t *zone = dns_c_ctx_getcurrzone(logcontext,
-							     currcfg);
+                dns_c_zone_t *zone = dns_c_ctx_getcurrzone(currcfg);
 
                 INSIST(zone != NULL);
 
-                tmpres = dns_c_zone_setallowupd(logcontext, zone,
+                tmpres = dns_c_zone_setallowupd(zone,
                                                 $3, ISC_FALSE);
                 switch (tmpres) {
                 case ISC_R_EXISTS:
@@ -2806,12 +2771,11 @@ zone_option: L_FILE L_QSTRING
         }
         | L_ALLOW_QUERY L_LBRACE address_match_list L_RBRACE
         {
-                dns_c_zone_t *zone = dns_c_ctx_getcurrzone(logcontext,
-							     currcfg);
+                dns_c_zone_t *zone = dns_c_ctx_getcurrzone(currcfg);
 
                 INSIST(zone != NULL);
 
-                tmpres = dns_c_zone_setallowquery(logcontext, zone,
+                tmpres = dns_c_zone_setallowquery(zone,
                                                   $3, ISC_FALSE);
                 switch (tmpres) {
                 case ISC_R_EXISTS:
@@ -2831,12 +2795,11 @@ zone_option: L_FILE L_QSTRING
         }
         | L_ALLOW_TRANSFER L_LBRACE address_match_list L_RBRACE
         {
-                dns_c_zone_t *zone = dns_c_ctx_getcurrzone(logcontext,
-							     currcfg);
+                dns_c_zone_t *zone = dns_c_ctx_getcurrzone(currcfg);
 
                 INSIST(zone != NULL);
 
-                tmpres = dns_c_zone_setallowtransfer(logcontext, zone,
+                tmpres = dns_c_zone_setallowtransfer(zone,
                                                      $3, ISC_FALSE);
                 switch (tmpres) {
                 case ISC_R_EXISTS:
@@ -2856,12 +2819,11 @@ zone_option: L_FILE L_QSTRING
         }
         | L_FORWARD zone_forward_opt
         {
-                dns_c_zone_t *zone = dns_c_ctx_getcurrzone(logcontext,
-							     currcfg);
+                dns_c_zone_t *zone = dns_c_ctx_getcurrzone(currcfg);
 
                 INSIST(zone != NULL);
 
-                tmpres = dns_c_zone_setforward(logcontext, zone, $2);
+                tmpres = dns_c_zone_setforward(zone, $2);
                 switch (tmpres) {
                 case ISC_R_EXISTS:
                         parser_warning(ISC_FALSE,
@@ -2880,14 +2842,13 @@ zone_option: L_FILE L_QSTRING
         }
         | L_FORWARDERS L_LBRACE opt_zone_forwarders_list L_RBRACE
         {
-                dns_c_zone_t *zone = dns_c_ctx_getcurrzone(logcontext,
-							   currcfg);
+                dns_c_zone_t *zone = dns_c_ctx_getcurrzone(currcfg);
                 dns_c_iplist_t *iplist;
                 
                 INSIST(zone != NULL);
 
                 if ($3 == NULL) {       /* user defined empty list */
-                        tmpres = dns_c_iplist_new(logcontext, currcfg->mem,
+                        tmpres = dns_c_iplist_new(currcfg->mem,
                                                   5, &iplist);
                         if (tmpres != ISC_R_SUCCESS) {
                                 parser_error(ISC_TRUE,
@@ -2899,7 +2860,7 @@ zone_option: L_FILE L_QSTRING
                         iplist = $3;
                 }
                 
-                tmpres = dns_c_zone_setforwarders(logcontext, zone,
+                tmpres = dns_c_zone_setforwarders(zone,
                                                   iplist, ISC_FALSE);
                 switch (tmpres) {
                 case ISC_R_EXISTS:
@@ -2914,18 +2875,17 @@ zone_option: L_FILE L_QSTRING
                 default:
                         parser_error(ISC_FALSE,
                                      "Failed to set zone forwarders.");
-			dns_c_iplist_detach(logcontext, &$3);
+			dns_c_iplist_detach(&$3);
 			break;
                 }
         }
         | L_MAX_TRANSFER_TIME_IN L_INTEGER
         {
-                dns_c_zone_t *zone = dns_c_ctx_getcurrzone(logcontext,
-							     currcfg);
+                dns_c_zone_t *zone = dns_c_ctx_getcurrzone(currcfg);
 
                 INSIST(zone != NULL);
 
-                tmpres = dns_c_zone_setmaxtranstimein(logcontext, zone, $2);
+                tmpres = dns_c_zone_setmaxtranstimein(zone, $2);
                 switch (tmpres) {
                 case ISC_R_EXISTS:
                         parser_warning(ISC_FALSE,
@@ -2946,12 +2906,11 @@ zone_option: L_FILE L_QSTRING
         }
         | L_MAX_LOG_SIZE_IXFR L_INTEGER
         {
-                dns_c_zone_t *zone = dns_c_ctx_getcurrzone(logcontext,
-							     currcfg);
+                dns_c_zone_t *zone = dns_c_ctx_getcurrzone(currcfg);
 
                 INSIST(zone != NULL);
 
-                tmpres = dns_c_zone_setmaxixfrlog(logcontext, zone, $2);
+                tmpres = dns_c_zone_setmaxixfrlog(zone, $2);
                 switch (tmpres) {
                 case ISC_R_EXISTS:
                         parser_warning(ISC_FALSE,
@@ -2970,12 +2929,11 @@ zone_option: L_FILE L_QSTRING
         }
         | L_NOTIFY yea_or_nay
         {
-                dns_c_zone_t *zone = dns_c_ctx_getcurrzone(logcontext,
-							     currcfg);
+                dns_c_zone_t *zone = dns_c_ctx_getcurrzone(currcfg);
 
                 INSIST(zone != NULL);
 
-                tmpres = dns_c_zone_setnotify(logcontext, zone, $2);
+                tmpres = dns_c_zone_setnotify(zone, $2);
                 switch (tmpres) {
                 case ISC_R_EXISTS:
                         parser_warning(ISC_FALSE,
@@ -2994,12 +2952,11 @@ zone_option: L_FILE L_QSTRING
         }
         | L_MAINTAIN_IXFR_BASE yea_or_nay
         {
-                dns_c_zone_t *zone = dns_c_ctx_getcurrzone(logcontext,
-							     currcfg);
+                dns_c_zone_t *zone = dns_c_ctx_getcurrzone(currcfg);
 
                 INSIST(zone != NULL);
 
-                tmpres = dns_c_zone_setmaintixfrbase(logcontext, zone, $2);
+                tmpres = dns_c_zone_setmaintixfrbase(zone, $2);
                 switch (tmpres) {
                 case ISC_R_EXISTS:
                         parser_warning(ISC_FALSE,
@@ -3018,13 +2975,12 @@ zone_option: L_FILE L_QSTRING
         }
         | L_PUBKEY L_INTEGER L_INTEGER L_INTEGER L_QSTRING
         {
-                dns_c_zone_t *zone = dns_c_ctx_getcurrzone(logcontext,
-							     currcfg);
+                dns_c_zone_t *zone = dns_c_ctx_getcurrzone(currcfg);
                 dns_c_pubkey_t *pubkey;
                 
                 INSIST(zone != NULL);
 
-                tmpres = dns_c_pubkey_new(logcontext, currcfg->mem, $2,
+                tmpres = dns_c_pubkey_new(currcfg->mem, $2,
                                           $3, $4, $5, &pubkey);
                 if (tmpres != ISC_R_SUCCESS) {
                         parser_error(ISC_TRUE,
@@ -3032,7 +2988,7 @@ zone_option: L_FILE L_QSTRING
                         YYABORT;
                 }
                 
-                tmpres = dns_c_zone_addpubkey(logcontext, zone, pubkey,
+                tmpres = dns_c_zone_addpubkey(zone, pubkey,
                                               ISC_FALSE);
                 switch (tmpres) {
                 case ISC_R_SUCCESS:
@@ -3040,7 +2996,7 @@ zone_option: L_FILE L_QSTRING
                         break;
 
                 default:
-                        dns_c_pubkey_delete(logcontext, &pubkey);
+                        dns_c_pubkey_delete(&pubkey);
                         parser_error(ISC_FALSE,
                                      "Failed to add a zone pubkey.");
 			break;
@@ -3050,12 +3006,11 @@ zone_option: L_FILE L_QSTRING
         }
         | L_ALSO_NOTIFY L_LBRACE notify_in_addr_list L_RBRACE
         {
-                dns_c_zone_t *zone = dns_c_ctx_getcurrzone(logcontext,
-							     currcfg);
+                dns_c_zone_t *zone = dns_c_ctx_getcurrzone(currcfg);
 
                 INSIST(zone != NULL);
 
-                tmpres = dns_c_zone_setalsonotify(logcontext, zone, $3,
+                tmpres = dns_c_zone_setalsonotify(zone, $3,
                                                   ISC_FALSE);
                 switch (tmpres) {
                 case ISC_R_EXISTS:
@@ -3075,12 +3030,11 @@ zone_option: L_FILE L_QSTRING
         }
         | L_DIALUP yea_or_nay
         {
-                dns_c_zone_t *zone = dns_c_ctx_getcurrzone(logcontext,
-							     currcfg);
+                dns_c_zone_t *zone = dns_c_ctx_getcurrzone(currcfg);
 
                 INSIST(zone != NULL);
 
-                tmpres = dns_c_zone_setdialup(logcontext, zone, $2);
+                tmpres = dns_c_zone_setdialup(zone, $2);
                 switch (tmpres) {
                 case ISC_R_EXISTS:
                         parser_warning(ISC_FALSE,
@@ -3128,7 +3082,7 @@ opt_in_addr_list: /* nothing */
         {
                 dns_c_iplist_t *list;
 
-                tmpres = dns_c_iplist_new(logcontext, currcfg->mem, 5, &list);
+                tmpres = dns_c_iplist_new(currcfg->mem, 5, &list);
                 if (tmpres != ISC_R_SUCCESS) {
                         parser_error(ISC_TRUE,
                                      "Failed to create new iplist");
@@ -3144,14 +3098,14 @@ in_addr_list: in_addr_elem L_EOS
         {
                 dns_c_iplist_t *list;
 
-                tmpres = dns_c_iplist_new(logcontext, currcfg->mem, 5, &list);
+                tmpres = dns_c_iplist_new(currcfg->mem, 5, &list);
                 if (tmpres != ISC_R_SUCCESS) {
                         parser_error(ISC_TRUE,
                                      "Failed to create new iplist");
                         YYABORT;
                 }
 
-                tmpres = dns_c_iplist_append(logcontext, list, $1);
+                tmpres = dns_c_iplist_append(list, $1);
                 if (tmpres != ISC_R_SUCCESS) {
                         parser_error(ISC_TRUE,
                                      "Failed to append master address");
@@ -3162,7 +3116,7 @@ in_addr_list: in_addr_elem L_EOS
         }
         | in_addr_list in_addr_elem L_EOS
         {
-                tmpres = dns_c_iplist_append(logcontext, $1, $2);
+                tmpres = dns_c_iplist_append($1, $2);
                 if (tmpres != ISC_R_SUCCESS) {
                         parser_error(ISC_TRUE,
                                      "Failed to append master address");
@@ -3194,14 +3148,12 @@ trusted_keys_stmt: L_TRUSTED_KEYS
         {
                 dns_c_tkeylist_t *newlist;
                 
-                tmpres = dns_c_ctx_gettrustedkeys(logcontext, currcfg,
+                tmpres = dns_c_ctx_gettrustedkeys(currcfg,
                                                   &newlist);
                 if (tmpres == ISC_R_NOTFOUND) {
-                        tmpres = dns_c_tkeylist_new(logcontext,
-                                                    currcfg->mem, &newlist);
+                        tmpres = dns_c_tkeylist_new(currcfg->mem, &newlist);
                         if (tmpres != ISC_R_SUCCESS) {
-                                isc_log_write(logcontext,
-                                              DNS_LOGCATEGORY_CONFIG,
+                                isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
                                               DNS_LOGMODULE_CONFIG,
                                               ISC_LOG_CRITICAL,
                                               "Failed to create trusted key"
@@ -3209,12 +3161,11 @@ trusted_keys_stmt: L_TRUSTED_KEYS
                                 YYABORT;
                         }
 
-                        tmpres = dns_c_ctx_settrustedkeys(logcontext, currcfg,
+                        tmpres = dns_c_ctx_settrustedkeys(currcfg,
                                                           newlist,
                                                           ISC_FALSE);
                         if (tmpres != ISC_R_SUCCESS) {
-                                isc_log_write(logcontext,
-                                              DNS_LOGCATEGORY_CONFIG,
+                                isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
                                               DNS_LOGMODULE_CONFIG,
                                               ISC_LOG_CRITICAL,
                                               "Failed to set trusted keys");
@@ -3234,29 +3185,29 @@ trusted_key: domain_name L_INTEGER L_INTEGER L_INTEGER L_QSTRING
                 dns_c_tkey_t *tkey;
                 dns_c_tkeylist_t *list;
 
-                tmpres = dns_c_ctx_gettrustedkeys(logcontext, currcfg, &list);
+                tmpres = dns_c_ctx_gettrustedkeys(currcfg, &list);
                 if (tmpres != ISC_R_SUCCESS) {
-                        isc_log_write(logcontext, DNS_LOGCATEGORY_CONFIG,
+                        isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
                                       DNS_LOGMODULE_CONFIG,
                                       ISC_LOG_CRITICAL,
                                       "No trusted key list defined!");
                         YYABORT;
                 }
 
-                tmpres = dns_c_tkey_new(logcontext, currcfg->mem, $1, $2, $3,
+                tmpres = dns_c_tkey_new(currcfg->mem, $1, $2, $3,
                                         $4, $5, &tkey);
                 if (tmpres != ISC_R_SUCCESS) {
-                        isc_log_write(logcontext, DNS_LOGCATEGORY_CONFIG,
+                        isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
                                       DNS_LOGMODULE_CONFIG,
                                       ISC_LOG_CRITICAL,
                                       "Failed to create trusted key");
                         YYABORT;
                 }
 
-                tmpres = dns_c_tkeylist_append(logcontext, list,
+                tmpres = dns_c_tkeylist_append(list,
                                                tkey, ISC_FALSE);
                 if (tmpres != ISC_R_SUCCESS) {
-                        isc_log_write(logcontext, DNS_LOGCATEGORY_CONFIG,
+                        isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
                                       DNS_LOGMODULE_CONFIG,
                                       ISC_LOG_CRITICAL,
                                       "Failed to append trusted key.");
@@ -3482,7 +3433,7 @@ init_action(void)
  */
   
 isc_result_t
-dns_c_parse_namedconf(isc_log_t *logctx, const char *filename, isc_mem_t *mem,
+dns_c_parse_namedconf(const char *filename, isc_mem_t *mem,
                       dns_c_ctx_t **configctx, dns_c_cbks_t *cbks)
 {
         isc_result_t res;
@@ -3520,10 +3471,6 @@ dns_c_parse_namedconf(isc_log_t *logctx, const char *filename, isc_mem_t *mem,
         specials['*'] = 1;
 #endif
 
-	/*
-	 * Use the logging context specified by the caller.
-	 */
-	logcontext = logctx;
 
         /*
          * This memory context is only used by the lexer routines (and must 
@@ -3533,7 +3480,7 @@ dns_c_parse_namedconf(isc_log_t *logctx, const char *filename, isc_mem_t *mem,
          */
         res = isc_mem_create(0, 0, &memctx);
         if (res != ISC_R_SUCCESS) {
-                isc_log_write(logcontext, DNS_LOGCATEGORY_CONFIG,
+                isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
                               DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
                               "%s: Error creating mem context.",
                               funcname);
@@ -3542,16 +3489,16 @@ dns_c_parse_namedconf(isc_log_t *logctx, const char *filename, isc_mem_t *mem,
 
         res = keyword_init();
         if (res != ISC_R_SUCCESS) {
-                isc_log_write(logcontext, DNS_LOGCATEGORY_CONFIG,
+                isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
                               DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
                               "%s: Error initializing keywords.",
                               funcname);
                 goto done;
         }
 
-        res = dns_c_ctx_new(logcontext, mem, &currcfg);
+        res = dns_c_ctx_new(mem, &currcfg);
         if (res != ISC_R_SUCCESS) {
-                isc_log_write(logcontext, DNS_LOGCATEGORY_CONFIG,
+                isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
                               DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
                               "%s: Error creating config context.",
                               funcname);
@@ -3560,7 +3507,7 @@ dns_c_parse_namedconf(isc_log_t *logctx, const char *filename, isc_mem_t *mem,
 
         res = isc_lex_create(memctx, CONF_MAX_IDENT, &mylexer);
         if (res != ISC_R_SUCCESS) {
-                isc_log_write(logcontext, DNS_LOGCATEGORY_CONFIG,
+                isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
                               DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
                               "%s: Error creating lexer",
                               funcname);
@@ -3574,7 +3521,7 @@ dns_c_parse_namedconf(isc_log_t *logctx, const char *filename, isc_mem_t *mem,
 
         res = isc_lex_openfile(mylexer, (char *)filename) ; /* remove const */
         if (res != ISC_R_SUCCESS) {
-                isc_log_write(logcontext, DNS_LOGCATEGORY_CONFIG,
+                isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
                               DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
                               "%s: Error opening file %s.",
                               funcname, filename);
@@ -3592,7 +3539,7 @@ dns_c_parse_namedconf(isc_log_t *logctx, const char *filename, isc_mem_t *mem,
                  */
                 isc_mem_destroy_check(memctx, ISC_FALSE);
 
-                dns_c_ctx_delete(logcontext, &currcfg);
+                dns_c_ctx_delete(&currcfg);
                 currcfg = NULL;
         } else {
                 res = ISC_R_SUCCESS;
@@ -3613,7 +3560,6 @@ dns_c_parse_namedconf(isc_log_t *logctx, const char *filename, isc_mem_t *mem,
         currcfg = NULL;
         memctx = NULL;
         mylexer = NULL;
-	logcontext = NULL;
 
         RUNTIME_CHECK(isc_mutex_unlock(&yacc_mutex) == ISC_R_SUCCESS);
 
@@ -3823,8 +3769,8 @@ parser_complain(isc_boolean_t is_warning, isc_boolean_t print_last_token,
 			    "error message would overflow");
 
         if (print_last_token) {
-		if (logcontext != NULL) {
-			isc_log_write(logcontext, DNS_LOGCATEGORY_CONFIG,
+		if (dns_lctx != NULL) {
+			isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 				       DNS_LOGMODULE_CONFIG, level,
 				       "%s%s near `%s'", where, message,
 				       token_to_text(lasttoken, lastyylval));
@@ -3833,8 +3779,8 @@ parser_complain(isc_boolean_t is_warning, isc_boolean_t print_last_token,
 				token_to_text(lasttoken, lastyylval));
 		}
         } else {
-		if (logcontext != NULL) {
-			isc_log_write(logcontext, DNS_LOGCATEGORY_CONFIG,
+		if (dns_lctx != NULL) {
+			isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 				       DNS_LOGMODULE_CONFIG, level,
 				       "%s%s", where, message);
 		} else {
diff --git a/lib/dns/config/confresolv.c b/lib/dns/config/confresolv.c
index 35adf8137c..d66cc67b25 100644
--- a/lib/dns/config/confresolv.c
+++ b/lib/dns/config/confresolv.c
@@ -22,9 +22,9 @@
 #include "confpvt.h"
 
 isc_result_t
-dns_c_resolv_new(isc_log_t *lctx, isc_mem_t *mem, dns_c_resolv_t **cfgres)
+dns_c_resolv_new(isc_mem_t *mem, dns_c_resolv_t **cfgres)
 {
-	(void)lctx ; (void) mem; (void) cfgres;
+	(void) mem; (void) cfgres;
 	
 	/* XXX nothing yet */
 
@@ -33,9 +33,9 @@ dns_c_resolv_new(isc_log_t *lctx, isc_mem_t *mem, dns_c_resolv_t **cfgres)
 
 
 isc_result_t
-dns_c_resolv_delete(isc_log_t *lctx, dns_c_resolv_t **cfgres)
+dns_c_resolv_delete(dns_c_resolv_t **cfgres)
 {
-	(void) lctx ; (void) cfgres;
+	(void) cfgres;
 	/* XXX nothin yet */
 
 	return (ISC_R_SUCCESS);
diff --git a/lib/dns/config/confrrset.c b/lib/dns/config/confrrset.c
index 69ed0b0cdf..b09744e8a5 100644
--- a/lib/dns/config/confrrset.c
+++ b/lib/dns/config/confrrset.c
@@ -25,7 +25,7 @@
 
 
 isc_result_t
-dns_c_rrsolist_clear(isc_log_t *lctx, dns_c_rrsolist_t *olist)
+dns_c_rrsolist_clear(dns_c_rrsolist_t *olist)
 {
 	dns_c_rrso_t *elem;
 	
@@ -34,7 +34,7 @@ dns_c_rrsolist_clear(isc_log_t *lctx, dns_c_rrsolist_t *olist)
 	elem = ISC_LIST_HEAD(olist->elements);
 	while (elem != NULL) {
 		ISC_LIST_UNLINK(olist->elements, elem, next);
-		dns_c_rrso_delete(lctx, &elem);
+		dns_c_rrso_delete(&elem);
 		elem = ISC_LIST_HEAD(olist->elements);
 	}
 
@@ -43,7 +43,7 @@ dns_c_rrsolist_clear(isc_log_t *lctx, dns_c_rrsolist_t *olist)
 
 
 isc_result_t
-dns_c_rrsolist_append(isc_log_t *lctx, dns_c_rrsolist_t *dest,
+dns_c_rrsolist_append(dns_c_rrsolist_t *dest,
 		      dns_c_rrsolist_t *src)
 {
 	dns_c_rrso_t *oldelem;
@@ -55,7 +55,7 @@ dns_c_rrsolist_append(isc_log_t *lctx, dns_c_rrsolist_t *dest,
 
 	oldelem = ISC_LIST_HEAD(src->elements);
 	while (oldelem != NULL) {
-		res = dns_c_rrso_copy(lctx, dest->mem, &newelem, oldelem);
+		res = dns_c_rrso_copy(dest->mem, &newelem, oldelem);
 		if (res != ISC_R_SUCCESS) {
 			return (res);
 		}
@@ -69,12 +69,10 @@ dns_c_rrsolist_append(isc_log_t *lctx, dns_c_rrsolist_t *dest,
 
 
 isc_result_t
-dns_c_rrsolist_new(isc_log_t *lctx, isc_mem_t *mem, dns_c_rrsolist_t **rval)
+dns_c_rrsolist_new(isc_mem_t *mem, dns_c_rrsolist_t **rval)
 {
 	dns_c_rrsolist_t *ro;
 
-	(void)lctx;
-	
 	ro = isc_mem_get(mem, sizeof *ro);
 	if (ro == NULL) {
 		return (ISC_R_NOMEMORY);
@@ -91,14 +89,12 @@ dns_c_rrsolist_new(isc_log_t *lctx, isc_mem_t *mem, dns_c_rrsolist_t **rval)
 
 
 isc_result_t
-dns_c_rrso_new(isc_log_t *lctx, isc_mem_t *mem, dns_c_rrso_t **res,
+dns_c_rrso_new(isc_mem_t *mem, dns_c_rrso_t **res,
 	       dns_rdataclass_t oclass,
 	       dns_rdatatype_t otype, char *name, dns_c_ordering_t ordering)
 {
 	dns_c_rrso_t *newo;
 
-	(void)lctx;
-	
 	REQUIRE(mem != NULL);
 	REQUIRE(res != NULL);
 	
@@ -132,7 +128,7 @@ dns_c_rrso_new(isc_log_t *lctx, isc_mem_t *mem, dns_c_rrso_t **res,
 
 
 isc_result_t
-dns_c_rrsolist_delete(isc_log_t *lctx, dns_c_rrsolist_t **list)
+dns_c_rrsolist_delete(dns_c_rrsolist_t **list)
 {
 	dns_c_rrso_t *elem, *q;
 	dns_c_rrsolist_t *l;
@@ -147,7 +143,7 @@ dns_c_rrsolist_delete(isc_log_t *lctx, dns_c_rrsolist_t **list)
 	while (elem != NULL) {
 		q = ISC_LIST_NEXT(elem, next);
 		ISC_LIST_UNLINK(l->elements, elem, next);
-		r = dns_c_rrso_delete(lctx, &elem);
+		r = dns_c_rrso_delete(&elem);
 		if (r != ISC_R_SUCCESS) {
 			return (r);
 		}
@@ -165,12 +161,10 @@ dns_c_rrsolist_delete(isc_log_t *lctx, dns_c_rrsolist_t **list)
 
 
 isc_result_t
-dns_c_rrso_delete(isc_log_t *lctx, dns_c_rrso_t **order)
+dns_c_rrso_delete(dns_c_rrso_t **order)
 {
 	dns_c_rrso_t *oldo;
 
-	(void)lctx;
-	
 	REQUIRE(order != NULL);
 	REQUIRE(DNS_C_RRSO_VALID(*order));
 
@@ -189,7 +183,7 @@ dns_c_rrso_delete(isc_log_t *lctx, dns_c_rrso_t **order)
 
 
 isc_result_t
-dns_c_rrso_copy(isc_log_t *lctx, isc_mem_t *mem, dns_c_rrso_t **dest,
+dns_c_rrso_copy(isc_mem_t *mem, dns_c_rrso_t **dest,
 		dns_c_rrso_t *source)
 {
 	dns_c_rrso_t *newo;
@@ -198,7 +192,7 @@ dns_c_rrso_copy(isc_log_t *lctx, isc_mem_t *mem, dns_c_rrso_t **dest,
 	REQUIRE(DNS_C_RRSO_VALID(*dest));
 	REQUIRE(DNS_C_RRSO_VALID(source));
 
-	res = dns_c_rrso_new(lctx, mem, &newo, source->oclass,
+	res = dns_c_rrso_new(mem, &newo, source->oclass,
 			     source->otype, source->name,
 			     source->ordering);
 	if (res == ISC_R_SUCCESS) {
@@ -212,7 +206,7 @@ dns_c_rrso_copy(isc_log_t *lctx, isc_mem_t *mem, dns_c_rrso_t **dest,
 
 
 isc_result_t
-dns_c_rrsolist_copy(isc_log_t *lctx, isc_mem_t *mem, dns_c_rrsolist_t **dest,
+dns_c_rrsolist_copy(isc_mem_t *mem, dns_c_rrsolist_t **dest,
 		    dns_c_rrsolist_t *source)
 
 {
@@ -224,16 +218,16 @@ dns_c_rrsolist_copy(isc_log_t *lctx, isc_mem_t *mem, dns_c_rrsolist_t **dest,
 	REQUIRE(DNS_C_RRSOLIST_VALID(source));
 	REQUIRE(dest != NULL);
 	
-	res = dns_c_rrsolist_new(lctx, mem, &nlist);
+	res = dns_c_rrsolist_new(mem, &nlist);
 	if (res != DNS_R_SUCCESS) {
 		return (res);
 	}
 	
 	elem = ISC_LIST_HEAD(source->elements);
 	while (elem != NULL) {
-		res = dns_c_rrso_copy(lctx, mem, &newe, elem);
+		res = dns_c_rrso_copy(mem, &newe, elem);
 		if (res != DNS_R_SUCCESS) {
-			dns_c_rrsolist_delete(lctx, &nlist);
+			dns_c_rrsolist_delete(&nlist);
 			return (res);
 		}
 
@@ -249,7 +243,7 @@ dns_c_rrsolist_copy(isc_log_t *lctx, isc_mem_t *mem, dns_c_rrsolist_t **dest,
 
 
 void
-dns_c_rrsolist_print(isc_log_t *lctx, FILE *fp, int indent,
+dns_c_rrsolist_print(FILE *fp, int indent,
 		     dns_c_rrsolist_t *rrlist)
 {
 	dns_c_rrso_t *or;
@@ -260,33 +254,33 @@ dns_c_rrsolist_print(isc_log_t *lctx, FILE *fp, int indent,
 		return;
 	}
 	
-	dns_c_printtabs(lctx, fp, indent);
+	dns_c_printtabs(fp, indent);
 	fprintf(fp, "rrset-order {\n");
 
 	or = ISC_LIST_HEAD(rrlist->elements);
 	while (or != NULL) {
-		dns_c_rrso_print(lctx, fp, indent + 1, or);
+		dns_c_rrso_print(fp, indent + 1, or);
 		or = ISC_LIST_NEXT(or, next);
 	}
 
-	dns_c_printtabs(lctx, fp, indent);
+	dns_c_printtabs(fp, indent);
 	fprintf(fp, "};\n");
 	
 }
 
 
 void
-dns_c_rrso_print(isc_log_t *lctx, FILE *fp, int indent, dns_c_rrso_t *order)
+dns_c_rrso_print(FILE *fp, int indent, dns_c_rrso_t *order)
 {
 	REQUIRE(DNS_C_RRSO_VALID(order));
 	
-	dns_c_printtabs(lctx, fp, indent);
+	dns_c_printtabs(fp, indent);
 	
 	fputs("class ", fp);
 	if (order->oclass == dns_rdataclass_any) {
 		fputc('*', fp);
 	} else {
-		dns_c_dataclass_tostream(lctx, fp, order->oclass);
+		dns_c_dataclass_tostream(fp, order->oclass);
 	}
 	
 
@@ -294,13 +288,13 @@ dns_c_rrso_print(isc_log_t *lctx, FILE *fp, int indent, dns_c_rrso_t *order)
 	if (order->otype == dns_rdatatype_any) {
 		fputc('*', fp);
 	} else {
-		dns_c_datatype_tostream(lctx, fp, order->otype);
+		dns_c_datatype_tostream(fp, order->otype);
 	}
 
 	fprintf(fp, " name %s", order->name);
 
 	fprintf(fp, " order %s",
-		dns_c_ordering2string(lctx, order->ordering, ISC_TRUE));
+		dns_c_ordering2string(order->ordering, ISC_TRUE));
 	
 	fputs(";\n", fp);
 }
diff --git a/lib/dns/config/confserv.c b/lib/dns/config/confserv.c
index 0a8a5753fa..74fd3934fa 100644
--- a/lib/dns/config/confserv.c
+++ b/lib/dns/config/confserv.c
@@ -41,12 +41,10 @@
 
 
 isc_result_t
-dns_c_srvlist_new(isc_log_t *lctx, isc_mem_t *mem, dns_c_srvlist_t **list)
+dns_c_srvlist_new(isc_mem_t *mem, dns_c_srvlist_t **list)
 {
 	dns_c_srvlist_t *l;
 
-	(void) lctx;
-	
 	REQUIRE(list != NULL);
 
 	l = isc_mem_get(mem, sizeof *l);
@@ -65,7 +63,7 @@ dns_c_srvlist_new(isc_log_t *lctx, isc_mem_t *mem, dns_c_srvlist_t **list)
 
 
 isc_result_t
-dns_c_srvlist_delete(isc_log_t *lctx, dns_c_srvlist_t **list)
+dns_c_srvlist_delete(dns_c_srvlist_t **list)
 {
 	dns_c_srvlist_t *l;
 	dns_c_srv_t *server, *stmp;
@@ -80,7 +78,7 @@ dns_c_srvlist_delete(isc_log_t *lctx, dns_c_srvlist_t **list)
 	while (server != NULL) {
 		stmp = ISC_LIST_NEXT(server, next);
 		ISC_LIST_UNLINK(l->elements, server, next);
-		r = dns_c_srv_delete(lctx, &server);
+		r = dns_c_srv_delete(&server);
 		if (r != ISC_R_SUCCESS) {
 			return (r);
 		}
@@ -98,7 +96,7 @@ dns_c_srvlist_delete(isc_log_t *lctx, dns_c_srvlist_t **list)
 
 
 void
-dns_c_srvlist_print(isc_log_t *lctx, FILE *fp, int indent,
+dns_c_srvlist_print(FILE *fp, int indent,
 		    dns_c_srvlist_t *servers)
 {
 	dns_c_srv_t *server;
@@ -108,7 +106,7 @@ dns_c_srvlist_print(isc_log_t *lctx, FILE *fp, int indent,
 
 	server = ISC_LIST_HEAD(servers->elements);
 	while (server != NULL) {
-		dns_c_srv_print(lctx, fp, indent, server);
+		dns_c_srv_print(fp, indent, server);
 		server = ISC_LIST_NEXT(server, next);
 		if (server != NULL) {
 			fprintf(fp, "\n");
@@ -120,14 +118,12 @@ dns_c_srvlist_print(isc_log_t *lctx, FILE *fp, int indent,
 
 
 isc_result_t
-dns_c_srvlist_servbyaddr(isc_log_t *lctx, dns_c_srvlist_t *servers,
+dns_c_srvlist_servbyaddr(dns_c_srvlist_t *servers,
 			 isc_sockaddr_t addr, dns_c_srv_t **retval)
 {
 	dns_c_srv_t *server;
 	isc_result_t res;
 
-	(void) lctx;
-	
 	REQUIRE(retval != NULL);
 	REQUIRE(DNS_C_SRVLIST_VALID(servers));
 
@@ -154,13 +150,11 @@ dns_c_srvlist_servbyaddr(isc_log_t *lctx, dns_c_srvlist_t *servers,
 
 
 isc_result_t
-dns_c_srv_new(isc_log_t *lctx, isc_mem_t *mem, isc_sockaddr_t addr,
+dns_c_srv_new(isc_mem_t *mem, isc_sockaddr_t addr,
 	      dns_c_srv_t **server)
 {
 	dns_c_srv_t *serv;
 
-	(void) lctx;
-	
 	REQUIRE(server != NULL);
 
 	serv = isc_mem_get(mem, sizeof *serv);
@@ -188,7 +182,7 @@ dns_c_srv_new(isc_log_t *lctx, isc_mem_t *mem, isc_sockaddr_t addr,
 
 
 isc_result_t
-dns_c_srv_delete(isc_log_t *lctx, dns_c_srv_t **server)
+dns_c_srv_delete(dns_c_srv_t **server)
 {
 	dns_c_srv_t *serv;
 	isc_mem_t *mem;
@@ -203,7 +197,7 @@ dns_c_srv_delete(isc_log_t *lctx, dns_c_srv_t **server)
 	serv->magic = 0;
 
 	if (serv->keys != NULL)
-		dns_c_kidlist_delete(lctx, &serv->keys);
+		dns_c_kidlist_delete(&serv->keys);
 
 	isc_mem_put(mem, serv, sizeof *serv);
 
@@ -214,54 +208,52 @@ dns_c_srv_delete(isc_log_t *lctx, dns_c_srv_t **server)
 
 
 void
-dns_c_srv_print(isc_log_t *lctx, FILE *fp, int indent, dns_c_srv_t *server)
+dns_c_srv_print(FILE *fp, int indent, dns_c_srv_t *server)
 {
 	REQUIRE(DNS_C_SRV_VALID(server));
 	REQUIRE(fp != NULL);
 
-	dns_c_printtabs(lctx, fp, indent);
+	dns_c_printtabs(fp, indent);
 	fprintf(fp, "server ");
-	dns_c_print_ipaddr(lctx, fp, &server->address);
+	dns_c_print_ipaddr(fp, &server->address);
 	fprintf(fp, " {\n");
 
 	if (DNS_C_CHECKBIT(BOGUS_BIT, &server->bitflags)) {
-		dns_c_printtabs(lctx, fp, indent + 1);
+		dns_c_printtabs(fp, indent + 1);
 		fprintf(fp, "bogus %s;\n",
 			(server->bogus ? "true" : "false"));
 	}
 
 	if (DNS_C_CHECKBIT(SERVER_TRANSFER_FORMAT_BIT, &server->bitflags)) {
-		dns_c_printtabs(lctx, fp, indent + 1);
+		dns_c_printtabs(fp, indent + 1);
 		fprintf(fp, "transfer-format %s;\n",
-			dns_c_transformat2string(lctx, server->transfer_format,
+			dns_c_transformat2string(server->transfer_format,
 						 ISC_TRUE));
 	}
 
 	if (DNS_C_CHECKBIT(TRANSFERS_BIT, &server->bitflags)) {
-		dns_c_printtabs(lctx, fp, indent + 1);
+		dns_c_printtabs(fp, indent + 1);
 		fprintf(fp, "transfers %d;\n", server->transfers);
 	}
 
 	if (DNS_C_CHECKBIT(SUPPORT_IXFR_BIT,&server->bitflags)) {
-		dns_c_printtabs(lctx, fp, indent + 1);
+		dns_c_printtabs(fp, indent + 1);
 		fprintf(fp, "support-ixfr %s;\n",
 			(server->support_ixfr ? "true" : "false"));
 	}
 
 	if (server->keys != NULL) {
-		dns_c_kidlist_print(lctx, fp, indent + 1, server->keys);
+		dns_c_kidlist_print(fp, indent + 1, server->keys);
 	}
 
-	dns_c_printtabs(lctx, fp, indent);
+	dns_c_printtabs(fp, indent);
 	fprintf(fp, "};\n");
 }
 
 
 isc_result_t
-dns_c_srv_setbogus(isc_log_t *lctx, dns_c_srv_t *server, isc_boolean_t newval)
+dns_c_srv_setbogus(dns_c_srv_t *server, isc_boolean_t newval)
 {
-	(void) lctx;
-	
 	REQUIRE(DNS_C_SRV_VALID(server));
 
 	server->bogus = newval;
@@ -272,11 +264,9 @@ dns_c_srv_setbogus(isc_log_t *lctx, dns_c_srv_t *server, isc_boolean_t newval)
 
 
 isc_result_t
-dns_c_srv_getbogus(isc_log_t *lctx, dns_c_srv_t *server,
+dns_c_srv_getbogus(dns_c_srv_t *server,
 		   isc_boolean_t *retval)
 {
-	(void) lctx;
-	
 	REQUIRE(DNS_C_SRV_VALID(server));
 	REQUIRE(retval != NULL);
 
@@ -290,11 +280,9 @@ dns_c_srv_getbogus(isc_log_t *lctx, dns_c_srv_t *server,
 
 
 isc_result_t
-dns_c_srv_setsupportixfr(isc_log_t *lctx, dns_c_srv_t *server,
+dns_c_srv_setsupportixfr(dns_c_srv_t *server,
 			 isc_boolean_t newval)
 {
-	(void) lctx;
-	
 	REQUIRE(DNS_C_SRV_VALID(server));
 
 	server->support_ixfr = newval;
@@ -304,11 +292,9 @@ dns_c_srv_setsupportixfr(isc_log_t *lctx, dns_c_srv_t *server,
 }
 
 isc_result_t
-dns_c_srv_getsupportixfr(isc_log_t *lctx, dns_c_srv_t *server,
+dns_c_srv_getsupportixfr(dns_c_srv_t *server,
 			 isc_boolean_t *retval)
 {
-	(void) lctx;
-	
 	REQUIRE(DNS_C_SRV_VALID(server));
 	REQUIRE(retval != NULL);
 
@@ -322,11 +308,9 @@ dns_c_srv_getsupportixfr(isc_log_t *lctx, dns_c_srv_t *server,
 
 
 isc_result_t
-dns_c_srv_settransfers(isc_log_t *lctx, dns_c_srv_t *server,
+dns_c_srv_settransfers(dns_c_srv_t *server,
 		       isc_int32_t newval)
 {
-	(void) lctx;
-	
 	REQUIRE(DNS_C_SRV_VALID(server));
 
 	server->transfers = newval;
@@ -337,11 +321,9 @@ dns_c_srv_settransfers(isc_log_t *lctx, dns_c_srv_t *server,
 
 
 isc_result_t
-dns_c_srv_gettransfers(isc_log_t *lctx, dns_c_srv_t *server,
+dns_c_srv_gettransfers(dns_c_srv_t *server,
 		       isc_int32_t *retval)
 {
-	(void) lctx;
-	
 	REQUIRE(DNS_C_SRV_VALID(server));
 	REQUIRE(retval != NULL);
 
@@ -355,11 +337,9 @@ dns_c_srv_gettransfers(isc_log_t *lctx, dns_c_srv_t *server,
 
 
 isc_result_t
-dns_c_srv_settransferformat(isc_log_t *lctx, dns_c_srv_t *server,
+dns_c_srv_settransferformat(dns_c_srv_t *server,
 			    dns_transfer_format_t newval)
 {
-	(void) lctx;
-	
 	REQUIRE(DNS_C_SRV_VALID(server));
 
 	server->transfer_format = newval;
@@ -370,11 +350,9 @@ dns_c_srv_settransferformat(isc_log_t *lctx, dns_c_srv_t *server,
 
 
 isc_result_t
-dns_c_srv_gettransferformat(isc_log_t *lctx, dns_c_srv_t *server,
+dns_c_srv_gettransferformat(dns_c_srv_t *server,
 			    dns_transfer_format_t *retval)
 {
-	(void) lctx;
-	
 	REQUIRE(DNS_C_SRV_VALID(server));
 	REQUIRE(retval != NULL);
 	
diff --git a/lib/dns/config/confview.c b/lib/dns/config/confview.c
index fa536757e0..0da8c4f694 100644
--- a/lib/dns/config/confview.c
+++ b/lib/dns/config/confview.c
@@ -33,8 +33,7 @@
 
 
 isc_result_t
-dns_c_viewtable_new(isc_log_t *lctx,
-		    isc_mem_t *mem, dns_c_viewtable_t **viewtable)
+dns_c_viewtable_new(isc_mem_t *mem, dns_c_viewtable_t **viewtable)
 {
 	dns_c_viewtable_t *table;
 	
@@ -42,7 +41,7 @@ dns_c_viewtable_new(isc_log_t *lctx,
 
 	table = isc_mem_get(mem, sizeof *table);
 	if (table == NULL) {
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Out of memory");
 		return (ISC_R_NOMEMORY);
@@ -60,8 +59,7 @@ dns_c_viewtable_new(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_viewtable_delete(isc_log_t *lctx,
-		       dns_c_viewtable_t **viewtable)
+dns_c_viewtable_delete(dns_c_viewtable_t **viewtable)
 {
 	dns_c_viewtable_t *table;
 	
@@ -71,7 +69,7 @@ dns_c_viewtable_delete(isc_log_t *lctx,
 	table = *viewtable;
 	*viewtable = NULL;
 	
-	dns_c_viewtable_clear(lctx, table);
+	dns_c_viewtable_clear(table);
 
 	table->magic = 0;
 	isc_mem_put(table->mem, table, sizeof *table);
@@ -81,11 +79,8 @@ dns_c_viewtable_delete(isc_log_t *lctx,
 
 
 void
-dns_c_viewtable_addview(isc_log_t *lctx,
-			dns_c_viewtable_t *viewtable, dns_c_view_t *view)
+dns_c_viewtable_addview(dns_c_viewtable_t *viewtable, dns_c_view_t *view)
 {
-	(void) lctx;			/* lint */
-	
 	REQUIRE(DNS_C_VIEWTABLE_VALID(viewtable));
 	REQUIRE(DNS_C_VIEW_VALID(view));
 	
@@ -95,11 +90,8 @@ dns_c_viewtable_addview(isc_log_t *lctx,
 
 
 void
-dns_c_viewtable_rmview(isc_log_t *lctx,
-		       dns_c_viewtable_t *viewtable, dns_c_view_t *view)
+dns_c_viewtable_rmview(dns_c_viewtable_t *viewtable, dns_c_view_t *view)
 {
-	(void) lctx;			/* lint */
-	
 	REQUIRE(DNS_C_VIEWTABLE_VALID(viewtable));
 	REQUIRE(DNS_C_VIEW_VALID(view));
 	
@@ -109,8 +101,7 @@ dns_c_viewtable_rmview(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_viewtable_clear(isc_log_t *lctx,
-		      dns_c_viewtable_t *table)
+dns_c_viewtable_clear(dns_c_viewtable_t *table)
 {
 	dns_c_view_t *elem;
 	dns_c_view_t *tmpelem;
@@ -123,9 +114,9 @@ dns_c_viewtable_clear(isc_log_t *lctx,
 		tmpelem = ISC_LIST_NEXT(elem, next);
 		ISC_LIST_UNLINK(table->views, elem, next);
 		
-		r = dns_c_view_delete(lctx, &elem);
+		r = dns_c_view_delete(&elem);
 		if (r != ISC_R_SUCCESS) {
-			isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+			isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 				      DNS_LOGMODULE_CONFIG,
 				      ISC_LOG_CRITICAL,
 				      "Failed to delete view.\n");
@@ -141,15 +132,12 @@ dns_c_viewtable_clear(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_viewtable_viewbyname(isc_log_t *lctx,
-			   dns_c_viewtable_t *viewtable,
+dns_c_viewtable_viewbyname(dns_c_viewtable_t *viewtable,
 			   const char *viewname,
 			   dns_c_view_t **retval)
 {
 	dns_c_view_t *elem;
 
-	(void) lctx;			/* lint */
-	
 	REQUIRE(DNS_C_VIEWTABLE_VALID(viewtable));
 	REQUIRE(retval != NULL);
 	REQUIRE(viewname != NULL);
@@ -174,8 +162,7 @@ dns_c_viewtable_viewbyname(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_viewtable_rmviewbyname(isc_log_t *lctx,
-			     dns_c_viewtable_t *viewtable,
+dns_c_viewtable_rmviewbyname(dns_c_viewtable_t *viewtable,
 					  const char *name)
 {
 	dns_c_view_t *view;
@@ -183,10 +170,10 @@ dns_c_viewtable_rmviewbyname(isc_log_t *lctx,
 
 	REQUIRE(DNS_C_VIEWTABLE_VALID(viewtable));
 	
-	res = dns_c_viewtable_viewbyname(lctx, viewtable, name, &view);
+	res = dns_c_viewtable_viewbyname(viewtable, name, &view);
 	if (res == ISC_R_SUCCESS) {
 		ISC_LIST_UNLINK(viewtable->views, view, next);
-		dns_c_view_delete(lctx, &view);
+		dns_c_view_delete(&view);
 	}
 
 	return (res);
@@ -195,8 +182,7 @@ dns_c_viewtable_rmviewbyname(isc_log_t *lctx,
 	
 
 isc_result_t
-dns_c_view_new(isc_log_t *lctx,
-	       isc_mem_t *mem, const char *name, dns_c_view_t **newview)
+dns_c_view_new(isc_mem_t *mem, const char *name, dns_c_view_t **newview)
 {
 	dns_c_view_t *view;
 
@@ -217,7 +203,7 @@ dns_c_view_new(isc_log_t *lctx,
 	view->name = isc_mem_strdup(mem, name);
 	if (view->name == NULL) {
 		isc_mem_put(mem, view, sizeof *view);
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Insufficient memory");
 	}
@@ -229,8 +215,7 @@ dns_c_view_new(isc_log_t *lctx,
 
 
 void
-dns_c_viewtable_print(isc_log_t *lctx,
-		      FILE *fp, int indent,
+dns_c_viewtable_print(FILE *fp, int indent,
 		      dns_c_viewtable_t *table)
 {
 	dns_c_view_t *view;
@@ -241,7 +226,7 @@ dns_c_viewtable_print(isc_log_t *lctx,
 
 	view = ISC_LIST_HEAD(table->views);
 	while (view != NULL) {
-		dns_c_view_print(lctx, fp, indent, view);
+		dns_c_view_print(fp, indent, view);
 		fprintf(fp, "\n");
 
 		view  = ISC_LIST_NEXT(view, next);
@@ -249,32 +234,30 @@ dns_c_viewtable_print(isc_log_t *lctx,
 }
 
 void
-dns_c_view_print(isc_log_t *lctx,
-		 FILE *fp, int indent, dns_c_view_t *view)
+dns_c_view_print(FILE *fp, int indent, dns_c_view_t *view)
 {
 	REQUIRE(DNS_C_VIEW_VALID(view));
 	
-	dns_c_printtabs(lctx, fp, indent);
+	dns_c_printtabs(fp, indent);
 	fprintf(fp, "view \"%s\" {\n", view->name);
 
 	if (view->allowquery != NULL) {
-		dns_c_printtabs(lctx, fp, indent + 1);
+		dns_c_printtabs(fp, indent + 1);
 		fprintf(fp, "allow-query ");
-		dns_c_ipmatchlist_print(lctx, fp, indent + 2,
+		dns_c_ipmatchlist_print(fp, indent + 2,
 					view->allowquery);
 		fprintf(fp, ";\n");
 	}
 
 	/* XXXJAB rest of view fields */
 
-	dns_c_printtabs(lctx, fp, indent);
+	dns_c_printtabs(fp, indent);
 	fprintf(fp, "};\n");
 }
 
 
 isc_result_t
-dns_c_view_setallowquery(isc_log_t *lctx,
-			 dns_c_view_t *view,
+dns_c_view_setallowquery(dns_c_view_t *view,
 			 dns_c_ipmatchlist_t *ipml,
 			 isc_boolean_t deepcopy)
 {
@@ -284,11 +267,11 @@ dns_c_view_setallowquery(isc_log_t *lctx,
 	REQUIRE(DNS_C_IPMLIST_VALID(ipml));
 
 	if (view->allowquery != NULL) {
-		dns_c_ipmatchlist_detach(lctx, &view->allowquery);
+		dns_c_ipmatchlist_detach(&view->allowquery);
 	}
 
 	if (deepcopy) {
-		res = dns_c_ipmatchlist_copy(lctx, view->mem,
+		res = dns_c_ipmatchlist_copy(view->mem,
 					     &view->allowquery, ipml);
 	} else {
 		view->allowquery = ipml;
@@ -300,8 +283,7 @@ dns_c_view_setallowquery(isc_log_t *lctx,
 	
 
 isc_result_t
-dns_c_view_getallowqueryexpanded(isc_log_t *lctx,
-				 isc_mem_t *mem,
+dns_c_view_getallowqueryexpanded(isc_mem_t *mem,
 				 dns_c_view_t *view,
 				 dns_c_acltable_t *acltable,
 				 dns_c_ipmatchlist_t **retval)
@@ -317,12 +299,12 @@ dns_c_view_getallowqueryexpanded(isc_log_t *lctx,
 		newlist = NULL;
 		r = ISC_R_SUCCESS;
 	} else {
-		r = dns_c_ipmatchlist_copy(lctx, mem, &newlist, view->allowquery);
+		r = dns_c_ipmatchlist_copy(mem, &newlist, view->allowquery);
 		if (r != ISC_R_SUCCESS) {
 			return (r);
 		}
 
-		r = dns_c_acl_expandacls(lctx, acltable, newlist);
+		r = dns_c_acl_expandacls(acltable, newlist);
 	}
 
 	*retval = newlist;
@@ -333,8 +315,7 @@ dns_c_view_getallowqueryexpanded(isc_log_t *lctx,
 
 
 isc_result_t
-dns_c_view_delete(isc_log_t *lctx,
-		  dns_c_view_t **viewptr)
+dns_c_view_delete(dns_c_view_t **viewptr)
 {
 	dns_c_view_t *view;
 	
@@ -346,7 +327,7 @@ dns_c_view_delete(isc_log_t *lctx,
 	isc_mem_free(view->mem, view->name);
 	
 	if (view->allowquery != NULL)
-		dns_c_ipmatchlist_detach(lctx, &view->allowquery);
+		dns_c_ipmatchlist_detach(&view->allowquery);
 
 	view->magic = 0;
 	isc_mem_put(view->mem, view, sizeof *view);
@@ -356,10 +337,8 @@ dns_c_view_delete(isc_log_t *lctx,
 
 	
 isc_result_t
-dns_c_view_getname(isc_log_t *lctx, dns_c_view_t *view, const char **retval)
+dns_c_view_getname(dns_c_view_t *view, const char **retval)
 {
-	(void) lctx;
-	
 	REQUIRE(DNS_C_VIEW_VALID(view));
 	REQUIRE(retval != NULL);
 
diff --git a/lib/dns/config/confzone.c b/lib/dns/config/confzone.c
index 587e10aa81..4ab7e11c0c 100644
--- a/lib/dns/config/confzone.c
+++ b/lib/dns/config/confzone.c
@@ -74,56 +74,52 @@
 
 typedef enum { zones_preopts, zones_postopts, zones_all } zone_print_type;
 
-static isc_result_t master_zone_init(isc_log_t *lctx,
-				     dns_c_masterzone_t *mzone);
-static isc_result_t slave_zone_init(isc_log_t *lctx, dns_c_slavezone_t *szone);
-static isc_result_t stub_zone_init(isc_log_t *lctx, dns_c_stubzone_t *szone);
-static isc_result_t hint_zone_init(isc_log_t *lctx, dns_c_hintzone_t *hzone);
-static isc_result_t forward_zone_init(isc_log_t *lctx,
-				      dns_c_forwardzone_t *fzone);
-static isc_result_t zone_delete(isc_log_t *lctx, dns_c_zone_t **zone);
-static isc_result_t master_zone_clear(isc_log_t *lctx, isc_mem_t *mem,
+static isc_result_t master_zone_init(dns_c_masterzone_t *mzone);
+static isc_result_t slave_zone_init(dns_c_slavezone_t *szone);
+static isc_result_t stub_zone_init(dns_c_stubzone_t *szone);
+static isc_result_t hint_zone_init(dns_c_hintzone_t *hzone);
+static isc_result_t forward_zone_init(dns_c_forwardzone_t *fzone);
+static isc_result_t zone_delete(dns_c_zone_t **zone);
+static isc_result_t master_zone_clear(isc_mem_t *mem,
 				      dns_c_masterzone_t *mzone);
-static isc_result_t slave_zone_clear(isc_log_t *lctx, isc_mem_t *mem,
+static isc_result_t slave_zone_clear(isc_mem_t *mem,
 				     dns_c_slavezone_t *szone);
-static isc_result_t stub_zone_clear(isc_log_t *lctx, isc_mem_t *mem,
+static isc_result_t stub_zone_clear(isc_mem_t *mem,
 				    dns_c_stubzone_t *szone);
-static isc_result_t forward_zone_clear(isc_log_t *lctx, isc_mem_t *mem,
+static isc_result_t forward_zone_clear(isc_mem_t *mem,
 				       dns_c_forwardzone_t *fzone);
-static isc_result_t hint_zone_clear(isc_log_t *lctx, isc_mem_t *mem,
+static isc_result_t hint_zone_clear(isc_mem_t *mem,
 				    dns_c_hintzone_t *hzone);
 
-static void	master_zone_print(isc_log_t *lctx, FILE *fp, int indent,
+static void	master_zone_print(FILE *fp, int indent,
 				  dns_c_masterzone_t *mzone);
-static void	slave_zone_print(isc_log_t *lctx, FILE *fp, int indent,
+static void	slave_zone_print(FILE *fp, int indent,
 				 dns_c_slavezone_t *szone);
-static void	stub_zone_print(isc_log_t *lctx, FILE *fp, int indent,
+static void	stub_zone_print(FILE *fp, int indent,
 				dns_c_stubzone_t *szone);
-static void	hint_zone_print(isc_log_t *lctx, FILE *fp, int indent,
+static void	hint_zone_print(FILE *fp, int indent,
 				dns_c_hintzone_t *hzone);
-static void	forward_zone_print(isc_log_t *lctx, FILE *fp, int indent,
+static void	forward_zone_print(FILE *fp, int indent,
 				   dns_c_forwardzone_t *fzone);
-static isc_result_t set_iplist_field(isc_log_t *lctx, isc_mem_t *mem,
+static isc_result_t set_iplist_field(isc_mem_t *mem,
 				     dns_c_iplist_t **dest,
 				     dns_c_iplist_t *src,
 				     isc_boolean_t deepcopy);
-static isc_result_t set_ipmatch_list_field(isc_log_t *lctx, isc_mem_t *mem,
+static isc_result_t set_ipmatch_list_field(isc_mem_t *mem,
 					   dns_c_ipmatchlist_t **dest,
 					   dns_c_ipmatchlist_t *src,
 					   isc_boolean_t deepcopy);
 
-static void zone_list_print(isc_log_t *lctx, zone_print_type zpt,
+static void zone_list_print(zone_print_type zpt,
 			    FILE *fp, int indent, dns_c_zonelist_t *list);
 
 
 
 isc_result_t
-dns_c_zonelist_new(isc_log_t *lctx, isc_mem_t *mem, dns_c_zonelist_t **zlist)
+dns_c_zonelist_new(isc_mem_t *mem, dns_c_zonelist_t **zlist)
 {
 	dns_c_zonelist_t *list;
 
-	(void)lctx;
-	
 	REQUIRE(zlist != NULL);
 
 	list = isc_mem_get(mem, sizeof *list);
@@ -142,7 +138,7 @@ dns_c_zonelist_new(isc_log_t *lctx, isc_mem_t *mem, dns_c_zonelist_t **zlist)
 
 
 isc_result_t
-dns_c_zonelist_delete(isc_log_t *lctx, dns_c_zonelist_t **zlist)
+dns_c_zonelist_delete(dns_c_zonelist_t **zlist)
 {
 	dns_c_zonelist_t *list;
 	dns_c_zonelem_t *zoneelem;
@@ -163,7 +159,7 @@ dns_c_zonelist_delete(isc_log_t *lctx, dns_c_zonelist_t **zlist)
 		zone = zoneelem->thezone;
 		isc_mem_put(list->mem, zoneelem, sizeof *zoneelem);
 		
-		res = zone_delete(lctx, &zone);
+		res = zone_delete(&zone);
 		if (res != ISC_R_SUCCESS) {
 			return (res);
 		}
@@ -177,12 +173,10 @@ dns_c_zonelist_delete(isc_log_t *lctx, dns_c_zonelist_t **zlist)
 }
 
 isc_result_t
-dns_c_zonelist_addzone(isc_log_t *lctx, dns_c_zonelist_t *zlist,
+dns_c_zonelist_addzone(dns_c_zonelist_t *zlist,
 		       dns_c_zone_t *zone)
 {
 	dns_c_zonelem_t *zoneelem;
-	
-	(void) lctx;
 
 	REQUIRE(zlist != NULL);
 	REQUIRE(zone != NULL);
@@ -204,7 +198,7 @@ dns_c_zonelist_addzone(isc_log_t *lctx, dns_c_zonelist_t *zlist,
 	
 #if 0					/* XXXJAB drop this function */
 dns_c_zone_t *
-dns_c_zonelist_currzone(isc_log_t *lctx, dns_c_zonelist_t *zlist)
+dns_c_zonelist_currzone(dns_c_zonelist_t *zlist)
 {
 	dns_c_zonelem_t *zelem;
 	
@@ -222,13 +216,11 @@ dns_c_zonelist_currzone(isc_log_t *lctx, dns_c_zonelist_t *zlist)
 	
 
 isc_result_t
-dns_c_zonelist_find(isc_log_t *lctx, dns_c_zonelist_t *zlist, const char *name,
+dns_c_zonelist_find(dns_c_zonelist_t *zlist, const char *name,
 		    dns_c_zone_t **retval)
 {
 	dns_c_zonelem_t *zoneelem;
 
-	(void)lctx;
-	
 	REQUIRE(zlist != NULL);
 	REQUIRE(name != NULL);
 	REQUIRE(strlen(name) > 0);
@@ -252,14 +244,12 @@ dns_c_zonelist_find(isc_log_t *lctx, dns_c_zonelist_t *zlist, const char *name,
 
 
 isc_result_t
-dns_c_zonelist_rmbyname(isc_log_t *lctx, dns_c_zonelist_t *zlist,
+dns_c_zonelist_rmbyname(dns_c_zonelist_t *zlist,
 			const char *name)
 {
 	dns_c_zonelem_t *zoneelem;
 	isc_result_t res;
 
-	(void) lctx;
-	
 	REQUIRE(zlist != NULL);
 	REQUIRE(name != NULL);
 
@@ -274,7 +264,7 @@ dns_c_zonelist_rmbyname(isc_log_t *lctx, dns_c_zonelist_t *zlist,
 
 	if (zoneelem != NULL) {
 		ISC_LIST_UNLINK(zlist->zones, zoneelem, next);
-		res = dns_c_zone_detach(lctx, &zoneelem->thezone);
+		res = dns_c_zone_detach(&zoneelem->thezone);
 		isc_mem_put(zlist->mem, zoneelem, sizeof *zoneelem);
 	} else {
 		res = ISC_R_NOTFOUND;
@@ -285,7 +275,7 @@ dns_c_zonelist_rmbyname(isc_log_t *lctx, dns_c_zonelist_t *zlist,
 
 
 isc_result_t
-dns_c_zonelist_rmzone(isc_log_t *lctx, dns_c_zonelist_t *zlist,
+dns_c_zonelist_rmzone(dns_c_zonelist_t *zlist,
 		      dns_c_zone_t *zone)
 {
 	dns_c_zonelem_t *zoneelem;
@@ -305,7 +295,7 @@ dns_c_zonelist_rmzone(isc_log_t *lctx, dns_c_zonelist_t *zlist,
 
 	if (zoneelem != NULL) {
 		ISC_LIST_UNLINK(zlist->zones, zoneelem, next);
-		res = dns_c_zone_detach(lctx, &zoneelem->thezone);
+		res = dns_c_zone_detach(&zoneelem->thezone);
 		isc_mem_put(zlist->mem, zoneelem, sizeof *zoneelem);
 	} else {
 		res = ISC_R_NOTFOUND;
@@ -316,32 +306,32 @@ dns_c_zonelist_rmzone(isc_log_t *lctx, dns_c_zonelist_t *zlist,
 
 
 void
-dns_c_zonelist_print(isc_log_t *lctx, FILE *fp, int indent,
+dns_c_zonelist_print(FILE *fp, int indent,
 		     dns_c_zonelist_t *list)
 {
-	zone_list_print(lctx, zones_all, fp, indent, list);
+	zone_list_print(zones_all, fp, indent, list);
 }
 
 
 void
-dns_c_zonelist_printpreopts(isc_log_t *lctx, FILE *fp, int indent,
+dns_c_zonelist_printpreopts(FILE *fp, int indent,
 			    dns_c_zonelist_t *list)
 {
-	zone_list_print(lctx, zones_preopts, fp, indent, list);
+	zone_list_print(zones_preopts, fp, indent, list);
 }
 
 
 void
-dns_c_zonelist_printpostopts(isc_log_t *lctx, FILE *fp, int indent,
+dns_c_zonelist_printpostopts(FILE *fp, int indent,
 			     dns_c_zonelist_t *list)
 {
-	zone_list_print(lctx, zones_postopts, fp, indent, list);
+	zone_list_print(zones_postopts, fp, indent, list);
 }
 
 
 
 static void
-zone_list_print(isc_log_t *lctx, zone_print_type zpt, FILE *fp, int indent,
+zone_list_print(zone_print_type zpt, FILE *fp, int indent,
 		dns_c_zonelist_t *list) 
 {
 	dns_c_zonelem_t *zoneelem;
@@ -361,7 +351,7 @@ zone_list_print(isc_log_t *lctx, zone_print_type zpt, FILE *fp, int indent,
 	zoneelem = ISC_LIST_HEAD(list->zones);
 	while (zoneelem != NULL) {
 		if (PRINTIT(zoneelem->thezone, zpt)) {
-			dns_c_zone_print(lctx, fp, indent, zoneelem->thezone);
+			dns_c_zone_print(fp, indent, zoneelem->thezone);
 		}
 		
 		zoneelem = ISC_LIST_NEXT(zoneelem, next);
@@ -381,7 +371,7 @@ zone_list_print(isc_log_t *lctx, zone_print_type zpt, FILE *fp, int indent,
 /* ************************************************************************ */
 
 isc_result_t
-dns_c_zone_new(isc_log_t *lctx, isc_mem_t *mem,
+dns_c_zone_new(isc_mem_t *mem,
 	       dns_c_zonetype_t ztype, dns_rdataclass_t zclass,
 	       const char *name, const char *internalname,
 	       dns_c_zone_t **zone)
@@ -410,23 +400,23 @@ dns_c_zone_new(isc_log_t *lctx, isc_mem_t *mem,
 
 	switch (ztype) {
 	case dns_c_zone_master:
-		res = master_zone_init(lctx, &newzone->u.mzone);
+		res = master_zone_init(&newzone->u.mzone);
 		break;
 		
 	case dns_c_zone_slave:
-		res = slave_zone_init(lctx, &newzone->u.szone);
+		res = slave_zone_init(&newzone->u.szone);
 		break;
 
 	case dns_c_zone_stub:
-		res = stub_zone_init(lctx, &newzone->u.tzone);
+		res = stub_zone_init(&newzone->u.tzone);
 		break;
 		
 	case dns_c_zone_hint:
-		res = hint_zone_init(lctx, &newzone->u.hzone);
+		res = hint_zone_init(&newzone->u.hzone);
 		break;
 		
 	case dns_c_zone_forward:
-		res = forward_zone_init(lctx, &newzone->u.fzone);
+		res = forward_zone_init(&newzone->u.fzone);
 		break;
 	}
 	
@@ -437,7 +427,7 @@ dns_c_zone_new(isc_log_t *lctx, isc_mem_t *mem,
 
 
 isc_result_t
-dns_c_zone_detach(isc_log_t *lctx, dns_c_zone_t **zone)
+dns_c_zone_detach(dns_c_zone_t **zone)
 {
 	dns_c_zone_t *zoneptr;
 	isc_result_t res = ISC_R_SUCCESS;
@@ -452,7 +442,7 @@ dns_c_zone_detach(isc_log_t *lctx, dns_c_zone_t **zone)
 	zoneptr->refcount--;
 
 	if (zoneptr->refcount == 0) {
-		res = zone_delete(lctx, &zoneptr);
+		res = zone_delete(&zoneptr);
 	}
 
 	return (res);
@@ -460,14 +450,12 @@ dns_c_zone_detach(isc_log_t *lctx, dns_c_zone_t **zone)
 
 
 void
-dns_c_zone_attach(isc_log_t *lctx, dns_c_zone_t *source,
+dns_c_zone_attach(dns_c_zone_t *source,
 		  dns_c_zone_t **target)
 {
 	REQUIRE(source != NULL);
 	REQUIRE(target != NULL);
 
-	(void) lctx;
-	
 	source->refcount++;
 
 	*target = source;
@@ -476,7 +464,7 @@ dns_c_zone_attach(isc_log_t *lctx, dns_c_zone_t *source,
 
 
 void
-dns_c_zone_print(isc_log_t *lctx, FILE *fp, int indent, dns_c_zone_t *zone)
+dns_c_zone_print(FILE *fp, int indent, dns_c_zone_t *zone)
 {
 	REQUIRE(fp != NULL);
 
@@ -484,54 +472,54 @@ dns_c_zone_print(isc_log_t *lctx, FILE *fp, int indent, dns_c_zone_t *zone)
 		return;
 	}
 
-	dns_c_printtabs(lctx, fp, indent);
+	dns_c_printtabs(fp, indent);
 	fprintf(fp, "zone \"%s\"", zone->name);
 	if (zone->zclass != dns_rdataclass_in) {
 		fputc(' ', fp);
-		dns_c_dataclass_tostream(lctx, fp, zone->zclass);
+		dns_c_dataclass_tostream(fp, zone->zclass);
 	}
 
 	fprintf(fp, " {\n");
 
 	switch (zone->ztype) {
 	case dns_c_zone_master:
-		dns_c_printtabs(lctx, fp, indent + 1);
+		dns_c_printtabs(fp, indent + 1);
 		fprintf(fp, "type master;\n");
-		master_zone_print(lctx, fp, indent + 1, &zone->u.mzone);
+		master_zone_print(fp, indent + 1, &zone->u.mzone);
 		break;
 		
 	case dns_c_zone_slave:
-		dns_c_printtabs(lctx, fp, indent + 1);
+		dns_c_printtabs(fp, indent + 1);
 		fprintf(fp, "type slave;\n");
-		slave_zone_print(lctx, fp, indent + 1, &zone->u.szone);
+		slave_zone_print(fp, indent + 1, &zone->u.szone);
 		break;
 
 	case dns_c_zone_stub:
-		dns_c_printtabs(lctx, fp, indent + 1);
+		dns_c_printtabs(fp, indent + 1);
 		fprintf(fp, "type stub;\n");
-		stub_zone_print(lctx, fp, indent + 1, &zone->u.tzone);
+		stub_zone_print(fp, indent + 1, &zone->u.tzone);
 		break;
 		
 	case dns_c_zone_hint:
-		dns_c_printtabs(lctx, fp, indent + 1);
+		dns_c_printtabs(fp, indent + 1);
 		fprintf(fp, "type hint;\n");
-		hint_zone_print(lctx, fp, indent + 1, &zone->u.hzone);
+		hint_zone_print(fp, indent + 1, &zone->u.hzone);
 		break;
 
 	case dns_c_zone_forward:
-		dns_c_printtabs(lctx, fp, indent + 1);
+		dns_c_printtabs(fp, indent + 1);
 		fprintf(fp, "type forward;\n");
-		forward_zone_print(lctx, fp, indent + 1, &zone->u.fzone);
+		forward_zone_print(fp, indent + 1, &zone->u.fzone);
 		break;
 	}
 
-	dns_c_printtabs(lctx, fp, indent);
+	dns_c_printtabs(fp, indent);
 	fprintf(fp, "};\n");
 }
 
 
 isc_result_t
-dns_c_zone_setfile(isc_log_t *lctx, dns_c_zone_t *zone, const char *newfile)
+dns_c_zone_setfile(dns_c_zone_t *zone, const char *newfile)
 {
 	char **p = NULL;
 	isc_result_t res;
@@ -556,7 +544,7 @@ dns_c_zone_setfile(isc_log_t *lctx, dns_c_zone_t *zone, const char *newfile)
 		break;
 			
 	case dns_c_zone_forward:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Forward zones do not have a file field");
 		return (ISC_R_FAILURE);
@@ -579,7 +567,7 @@ dns_c_zone_setfile(isc_log_t *lctx, dns_c_zone_t *zone, const char *newfile)
 
 
 isc_result_t
-dns_c_zone_setchecknames(isc_log_t *lctx, dns_c_zone_t *zone,
+dns_c_zone_setchecknames(dns_c_zone_t *zone,
 			 dns_c_severity_t severity)
 {
 	dns_c_severity_t *p = NULL;
@@ -587,8 +575,6 @@ dns_c_zone_setchecknames(isc_log_t *lctx, dns_c_zone_t *zone,
 	int bit = 0;
 	isc_result_t res;
 
-	(void)lctx;
-		
 	REQUIRE(zone != NULL);
 
 	switch (zone->ztype) {
@@ -637,7 +623,7 @@ dns_c_zone_setchecknames(isc_log_t *lctx, dns_c_zone_t *zone,
 
 
 isc_result_t
-dns_c_zone_setallowupd(isc_log_t *lctx, dns_c_zone_t *zone,
+dns_c_zone_setallowupd(dns_c_zone_t *zone,
 		       dns_c_ipmatchlist_t *ipml,
 		       isc_boolean_t deepcopy)
 {
@@ -662,13 +648,13 @@ dns_c_zone_setallowupd(isc_log_t *lctx, dns_c_zone_t *zone,
 		break;
 		
 	case dns_c_zone_hint:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Hint zones do not have an allow_update field");
 		return (ISC_R_FAILURE);
 			
 	case dns_c_zone_forward:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Forward zones do not have an "
 			      "allow_update field");
@@ -677,7 +663,7 @@ dns_c_zone_setallowupd(isc_log_t *lctx, dns_c_zone_t *zone,
 
 	existed = (*p != NULL ? ISC_TRUE : ISC_FALSE);
 	
-	res = set_ipmatch_list_field(lctx, zone->mem, p,
+	res = set_ipmatch_list_field(zone->mem, p,
 				     ipml, deepcopy);
 	if (res == ISC_R_SUCCESS && existed) {
 		res = ISC_R_EXISTS;
@@ -688,7 +674,7 @@ dns_c_zone_setallowupd(isc_log_t *lctx, dns_c_zone_t *zone,
 
 
 isc_result_t
-dns_c_zone_setallowquery(isc_log_t *lctx, dns_c_zone_t *zone,
+dns_c_zone_setallowquery(dns_c_zone_t *zone,
 			 dns_c_ipmatchlist_t *ipml,
 			 isc_boolean_t deepcopy)
 {
@@ -713,13 +699,13 @@ dns_c_zone_setallowquery(isc_log_t *lctx, dns_c_zone_t *zone,
 		break;
 		
 	case dns_c_zone_hint:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Hint zones do not have an allow_query field");
 		return (ISC_R_FAILURE);
 			
 	case dns_c_zone_forward:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Forward zones do not have an "
 			      "allow_query field");
@@ -728,7 +714,7 @@ dns_c_zone_setallowquery(isc_log_t *lctx, dns_c_zone_t *zone,
 
 	existed = (*p != NULL ? ISC_TRUE : ISC_FALSE);
 	
-	res = set_ipmatch_list_field(lctx, zone->mem, p,
+	res = set_ipmatch_list_field(zone->mem, p,
 				     ipml, deepcopy);
 	if (res == ISC_R_SUCCESS && existed) {
 		res = ISC_R_EXISTS;
@@ -739,7 +725,7 @@ dns_c_zone_setallowquery(isc_log_t *lctx, dns_c_zone_t *zone,
 
 
 isc_result_t
-dns_c_zone_setallowtransfer(isc_log_t *lctx, dns_c_zone_t *zone,
+dns_c_zone_setallowtransfer(dns_c_zone_t *zone,
 			    dns_c_ipmatchlist_t *ipml,
 			    isc_boolean_t deepcopy)
 {
@@ -764,14 +750,14 @@ dns_c_zone_setallowtransfer(isc_log_t *lctx, dns_c_zone_t *zone,
 		break;
 		
 	case dns_c_zone_hint:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Hint zones do not have an "
 			      "allow_transfer field");
 		return (ISC_R_FAILURE);
 			
 	case dns_c_zone_forward:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Forward zones do not have an "
 			      "allow_transfer field");
@@ -779,7 +765,7 @@ dns_c_zone_setallowtransfer(isc_log_t *lctx, dns_c_zone_t *zone,
 	}
 
 	existed = (*p != NULL ? ISC_TRUE : ISC_FALSE);
-	res = set_ipmatch_list_field(lctx, zone->mem, p,
+	res = set_ipmatch_list_field(zone->mem, p,
 				     ipml, deepcopy);
 
 	if (res == ISC_R_SUCCESS && existed) {
@@ -791,7 +777,7 @@ dns_c_zone_setallowtransfer(isc_log_t *lctx, dns_c_zone_t *zone,
 
 
 isc_result_t
-dns_c_zone_setdialup(isc_log_t *lctx, dns_c_zone_t *zone, isc_boolean_t newval)
+dns_c_zone_setdialup(dns_c_zone_t *zone, isc_boolean_t newval)
 {
 	isc_boolean_t existed = ISC_FALSE;
 
@@ -820,13 +806,13 @@ dns_c_zone_setdialup(isc_log_t *lctx, dns_c_zone_t *zone, isc_boolean_t newval)
 		break;
 
 	case dns_c_zone_hint:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Hint zones do not have a dialup field");
 		return (ISC_R_FAILURE);
 			
 	case dns_c_zone_forward:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Forward zones do not have a dialup field");
 		return (ISC_R_FAILURE);
@@ -837,7 +823,7 @@ dns_c_zone_setdialup(isc_log_t *lctx, dns_c_zone_t *zone, isc_boolean_t newval)
 
 
 isc_result_t
-dns_c_zone_setnotify(isc_log_t *lctx, dns_c_zone_t *zone, isc_boolean_t newval)
+dns_c_zone_setnotify(dns_c_zone_t *zone, isc_boolean_t newval)
 {
 	isc_boolean_t existed = ISC_FALSE;
 	
@@ -859,19 +845,19 @@ dns_c_zone_setnotify(isc_log_t *lctx, dns_c_zone_t *zone, isc_boolean_t newval)
 		break;
 		
 	case dns_c_zone_stub:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Stub zones do not have a notify field");
 		return (ISC_R_FAILURE);
 
 	case dns_c_zone_hint:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Hint zones do not have a notify field");
 		return (ISC_R_FAILURE);
 			
 	case dns_c_zone_forward:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Forward zones do not have a notify field");
 		return (ISC_R_FAILURE);
@@ -882,7 +868,7 @@ dns_c_zone_setnotify(isc_log_t *lctx, dns_c_zone_t *zone, isc_boolean_t newval)
 
 
 isc_result_t
-dns_c_zone_setmaintixfrbase(isc_log_t *lctx, dns_c_zone_t *zone,
+dns_c_zone_setmaintixfrbase(dns_c_zone_t *zone,
 			    isc_boolean_t newval)
 {
 	isc_boolean_t existed = ISC_FALSE;
@@ -905,21 +891,21 @@ dns_c_zone_setmaintixfrbase(isc_log_t *lctx, dns_c_zone_t *zone,
 		break;
 		
 	case dns_c_zone_stub:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Stub zones do not have a "
 			      "maintain-xfer-base field");
 		return (ISC_R_FAILURE);
 
 	case dns_c_zone_hint:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Hint zones do not have a "
 			      "maintain-xfer-base field");
 		return (ISC_R_FAILURE);
 			
 	case dns_c_zone_forward:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Forward zones do not have a "
 			      "maintain-xfer-base field");
@@ -931,7 +917,7 @@ dns_c_zone_setmaintixfrbase(isc_log_t *lctx, dns_c_zone_t *zone,
 
 
 isc_result_t
-dns_c_zone_setalsonotify(isc_log_t *lctx, dns_c_zone_t *zone,
+dns_c_zone_setalsonotify(dns_c_zone_t *zone,
 			 dns_c_iplist_t *newval,
 			 isc_boolean_t deepcopy)
 {
@@ -949,26 +935,26 @@ dns_c_zone_setalsonotify(isc_log_t *lctx, dns_c_zone_t *zone,
 		break;
 		
 	case dns_c_zone_stub:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Stub zones do not have a also_notify field");
 		return (ISC_R_FAILURE);
 			
 	case dns_c_zone_hint:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Hint zones do not have a also_notify field");
 		return (ISC_R_FAILURE);
 			
 	case dns_c_zone_forward:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Forward zones do not have a also_notify field");
 		return (ISC_R_FAILURE);
 	}
 
 	existed = (*p != NULL ? ISC_TRUE : ISC_FALSE);
-	res = set_iplist_field(lctx, zone->mem, p, newval, deepcopy);
+	res = set_iplist_field(zone->mem, p, newval, deepcopy);
 	if (res == ISC_R_SUCCESS && existed) {
 		res = ISC_R_EXISTS;
 	}
@@ -978,7 +964,7 @@ dns_c_zone_setalsonotify(isc_log_t *lctx, dns_c_zone_t *zone,
 
 
 isc_result_t
-dns_c_zone_setixfrbase(isc_log_t *lctx, dns_c_zone_t *zone, const char *newval)
+dns_c_zone_setixfrbase(dns_c_zone_t *zone, const char *newval)
 {
 	isc_boolean_t existed ;
 	char **p = NULL;
@@ -995,19 +981,19 @@ dns_c_zone_setixfrbase(isc_log_t *lctx, dns_c_zone_t *zone, const char *newval)
 		break;
 		
 	case dns_c_zone_stub:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Stub zones do not have a ixfr_base field");
 		return (ISC_R_FAILURE);
 
 	case dns_c_zone_hint:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Hint zones do not have a ixfr_base field");
 		return (ISC_R_FAILURE);
 			
 	case dns_c_zone_forward:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Forward zones do not have a file field");
 		return (ISC_R_FAILURE);
@@ -1030,7 +1016,7 @@ dns_c_zone_setixfrbase(isc_log_t *lctx, dns_c_zone_t *zone, const char *newval)
 
 
 isc_result_t
-dns_c_zone_setixfrtmp(isc_log_t *lctx, dns_c_zone_t *zone, const char *newval)
+dns_c_zone_setixfrtmp(dns_c_zone_t *zone, const char *newval)
 {
   isc_boolean_t existed;
 	char **p = NULL;
@@ -1047,19 +1033,19 @@ dns_c_zone_setixfrtmp(isc_log_t *lctx, dns_c_zone_t *zone, const char *newval)
 		break;
 		
 	case dns_c_zone_stub:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Stub zones do not have a ixfr_tmp field");
 		return (ISC_R_FAILURE);
 
 	case dns_c_zone_hint:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Hint zones do not have a ixfr_tmp field");
 		return (ISC_R_FAILURE);
 			
 	case dns_c_zone_forward:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Forward zones do not have a file field");
 		return (ISC_R_FAILURE);
@@ -1082,7 +1068,7 @@ dns_c_zone_setixfrtmp(isc_log_t *lctx, dns_c_zone_t *zone, const char *newval)
 
 
 isc_result_t
-dns_c_zone_addpubkey(isc_log_t *lctx, dns_c_zone_t *zone,
+dns_c_zone_addpubkey(dns_c_zone_t *zone,
 		     dns_c_pubkey_t *pubkey,
 		     isc_boolean_t deepcopy)
 {
@@ -1106,34 +1092,34 @@ dns_c_zone_addpubkey(isc_log_t *lctx, dns_c_zone_t *zone,
 #if 1
 		p = &zone->u.hzone.pubkeylist;
 #else
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Hint zones do not have a pubkey field");
 #endif 
 		return (ISC_R_FAILURE);
 			
 	case dns_c_zone_forward:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Forward zones do not have a pubkey field");
 		return (ISC_R_FAILURE);
 	}
 
 	if (*p == NULL) {
-		res = dns_c_pklist_new(lctx, zone->mem, p);
+		res = dns_c_pklist_new(zone->mem, p);
 		if (res != ISC_R_SUCCESS) {
 			return (res);
 		}
 	}
 	
-	res = dns_c_pklist_addpubkey(lctx, *p, pubkey, deepcopy);
+	res = dns_c_pklist_addpubkey(*p, pubkey, deepcopy);
 
 	return (res);
 }
 
 
 isc_result_t
-dns_c_zone_setmasterport(isc_log_t *lctx, dns_c_zone_t *zone, in_port_t port)
+dns_c_zone_setmasterport(dns_c_zone_t *zone, in_port_t port)
 {
 	isc_boolean_t existed = ISC_FALSE;
 	
@@ -1141,7 +1127,7 @@ dns_c_zone_setmasterport(isc_log_t *lctx, dns_c_zone_t *zone, in_port_t port)
 
 	switch(zone->ztype) {
 	case dns_c_zone_master:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Forward zones do not have a "
 			      "master_port field");
@@ -1162,13 +1148,13 @@ dns_c_zone_setmasterport(isc_log_t *lctx, dns_c_zone_t *zone, in_port_t port)
 		break;
 		
 	case dns_c_zone_hint:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Hint zones do not have a master_port field");
 		return (ISC_R_FAILURE);
 			
 	case dns_c_zone_forward:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Forward zones do not have a "
 			      "master_port field");
@@ -1180,7 +1166,7 @@ dns_c_zone_setmasterport(isc_log_t *lctx, dns_c_zone_t *zone, in_port_t port)
 
 
 isc_result_t
-dns_c_zone_setmasterips(isc_log_t *lctx, dns_c_zone_t *zone,
+dns_c_zone_setmasterips(dns_c_zone_t *zone,
 			dns_c_iplist_t *newval,
 			isc_boolean_t deepcopy)
 {
@@ -1190,7 +1176,7 @@ dns_c_zone_setmasterips(isc_log_t *lctx, dns_c_zone_t *zone,
 
 	switch (zone->ztype) {
 	case dns_c_zone_master:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Master zones do not have a master_ips field");
 		return (ISC_R_FAILURE);
@@ -1204,7 +1190,7 @@ dns_c_zone_setmasterips(isc_log_t *lctx, dns_c_zone_t *zone,
 		}
 		
 		existed = (*p != NULL ? ISC_TRUE : ISC_FALSE);
-		res = set_iplist_field(lctx, zone->mem, p,
+		res = set_iplist_field(zone->mem, p,
 				       newval, deepcopy);
 		if (res == ISC_R_SUCCESS && existed) {
 			res = ISC_R_EXISTS;
@@ -1212,13 +1198,13 @@ dns_c_zone_setmasterips(isc_log_t *lctx, dns_c_zone_t *zone,
 		break;
 
 	case dns_c_zone_hint:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Hint zones do not have a master_ips field");
 		return (ISC_R_FAILURE);
 			
 	case dns_c_zone_forward:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Forward zones do not have a master_ips field");
 		return (ISC_R_FAILURE);
@@ -1229,7 +1215,7 @@ dns_c_zone_setmasterips(isc_log_t *lctx, dns_c_zone_t *zone,
 
 
 isc_result_t
-dns_c_zone_settransfersource(isc_log_t *lctx, dns_c_zone_t *zone,
+dns_c_zone_settransfersource(dns_c_zone_t *zone,
 			     isc_sockaddr_t newval)
 {
 	isc_boolean_t existed = ISC_FALSE;
@@ -1238,7 +1224,7 @@ dns_c_zone_settransfersource(isc_log_t *lctx, dns_c_zone_t *zone,
 
 	switch (zone->ztype) {
 	case dns_c_zone_master:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Master zones do not have a "
 			      "transfer_source field");
@@ -1259,13 +1245,13 @@ dns_c_zone_settransfersource(isc_log_t *lctx, dns_c_zone_t *zone,
 		break;
 		
 	case dns_c_zone_hint:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Hint zones do not have a master_ips field");
 		return (ISC_R_FAILURE);
 			
 	case dns_c_zone_forward:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Forward zones do not have a master_ips field");
 		return (ISC_R_FAILURE);
@@ -1276,7 +1262,7 @@ dns_c_zone_settransfersource(isc_log_t *lctx, dns_c_zone_t *zone,
 
 
 isc_result_t
-dns_c_zone_setmaxtranstimein(isc_log_t *lctx, dns_c_zone_t *zone,
+dns_c_zone_setmaxtranstimein(dns_c_zone_t *zone,
 			     isc_int32_t newval)
 {
 	isc_boolean_t existed = ISC_FALSE;
@@ -1285,7 +1271,7 @@ dns_c_zone_setmaxtranstimein(isc_log_t *lctx, dns_c_zone_t *zone,
 
 	switch (zone->ztype) {
 	case dns_c_zone_master:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Master zones do not have a "
 			      "max_trans_time_in field");
@@ -1308,14 +1294,14 @@ dns_c_zone_setmaxtranstimein(isc_log_t *lctx, dns_c_zone_t *zone,
 		break;
 
 	case dns_c_zone_hint:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Hint zones do not have a "
 			      "max_trans_time_in field");
 		return (ISC_R_FAILURE);
 			
 	case dns_c_zone_forward:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Forward zones do not have a "
 			      "max_trans_time_in field");
@@ -1327,7 +1313,7 @@ dns_c_zone_setmaxtranstimein(isc_log_t *lctx, dns_c_zone_t *zone,
 
 
 isc_result_t
-dns_c_zone_setmaxixfrlog(isc_log_t *lctx, dns_c_zone_t *zone,
+dns_c_zone_setmaxixfrlog(dns_c_zone_t *zone,
 			 isc_int32_t newval)
 {
 	dns_c_setbits_t *bits = NULL;
@@ -1351,19 +1337,19 @@ dns_c_zone_setmaxixfrlog(isc_log_t *lctx, dns_c_zone_t *zone,
 		break;
 		
 	case dns_c_zone_stub:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Stub zones do not have a max-ixfr-log field");
 		return (ISC_R_FAILURE);
 
 	case dns_c_zone_hint:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Hint zones do not have a max-ixfr-log field");
 		return (ISC_R_FAILURE);
 			
 	case dns_c_zone_forward:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Forward zones do not have a "
 			      "max-ixfr-log field");
@@ -1384,7 +1370,7 @@ dns_c_zone_setmaxixfrlog(isc_log_t *lctx, dns_c_zone_t *zone,
 
 
 isc_result_t
-dns_c_zone_setforward(isc_log_t *lctx, dns_c_zone_t *zone, dns_c_forw_t newval)
+dns_c_zone_setforward(dns_c_zone_t *zone, dns_c_forw_t newval)
 {
 	isc_boolean_t existed = ISC_FALSE;
 	
@@ -1413,7 +1399,7 @@ dns_c_zone_setforward(isc_log_t *lctx, dns_c_zone_t *zone, dns_c_forw_t newval)
 		break;
 		
 	case dns_c_zone_hint:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Hint zones do not have a forward field");
 		return (ISC_R_FAILURE);
@@ -1431,7 +1417,7 @@ dns_c_zone_setforward(isc_log_t *lctx, dns_c_zone_t *zone, dns_c_forw_t newval)
 
 
 isc_result_t
-dns_c_zone_setforwarders(isc_log_t *lctx, dns_c_zone_t *zone,
+dns_c_zone_setforwarders(dns_c_zone_t *zone,
 			 dns_c_iplist_t *ipl,
 			 isc_boolean_t deepcopy)
 {
@@ -1459,7 +1445,7 @@ dns_c_zone_setforwarders(isc_log_t *lctx, dns_c_zone_t *zone,
 		break;
 		
 	case dns_c_zone_hint:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Hint zones do not have a forwarders field");
 		return (ISC_R_FAILURE);
@@ -1470,7 +1456,7 @@ dns_c_zone_setforwarders(isc_log_t *lctx, dns_c_zone_t *zone,
 		break;
 	}
 
-	res = set_iplist_field(lctx, zone->mem, p, ipl, deepcopy);
+	res = set_iplist_field(zone->mem, p, ipl, deepcopy);
 	if (res == ISC_R_SUCCESS && existed) {
 		res = ISC_R_EXISTS;
 	}
@@ -1480,10 +1466,8 @@ dns_c_zone_setforwarders(isc_log_t *lctx, dns_c_zone_t *zone,
 
 
 isc_result_t
-dns_c_zone_getname(isc_log_t *lctx, dns_c_zone_t *zone, const char **retval)
+dns_c_zone_getname(dns_c_zone_t *zone, const char **retval)
 {
-	(void) lctx;
-	
 	REQUIRE(zone != NULL);
 	REQUIRE(retval != NULL);
 
@@ -1494,11 +1478,9 @@ dns_c_zone_getname(isc_log_t *lctx, dns_c_zone_t *zone, const char **retval)
 
 
 isc_result_t
-dns_c_zone_getinternalname(isc_log_t *lctx, dns_c_zone_t *zone,
+dns_c_zone_getinternalname(dns_c_zone_t *zone,
 			   const char **retval)
 {
-	(void) lctx;
-	
 	REQUIRE(zone != NULL);
 	REQUIRE(retval != NULL);
 
@@ -1509,7 +1491,7 @@ dns_c_zone_getinternalname(isc_log_t *lctx, dns_c_zone_t *zone,
 
 
 isc_result_t
-dns_c_zone_getfile(isc_log_t *lctx, dns_c_zone_t *zone, const char **retval)
+dns_c_zone_getfile(dns_c_zone_t *zone, const char **retval)
 {
 	const char *p = NULL;
 	isc_result_t res;
@@ -1535,7 +1517,7 @@ dns_c_zone_getfile(isc_log_t *lctx, dns_c_zone_t *zone, const char **retval)
 		break;
 			
 	case dns_c_zone_forward:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Forward zones do not have a file field");
 		return (ISC_R_FAILURE);
@@ -1553,7 +1535,7 @@ dns_c_zone_getfile(isc_log_t *lctx, dns_c_zone_t *zone, const char **retval)
 
 
 isc_result_t
-dns_c_zone_getchecknames(isc_log_t *lctx, dns_c_zone_t *zone,
+dns_c_zone_getchecknames(dns_c_zone_t *zone,
 			 dns_c_severity_t *retval)
 {
 	dns_c_severity_t *p = NULL;
@@ -1561,8 +1543,6 @@ dns_c_zone_getchecknames(isc_log_t *lctx, dns_c_zone_t *zone,
 	int bit = 0;
 	isc_result_t res;
 
-	(void)lctx;
-		
 	REQUIRE(zone != NULL);
 	REQUIRE(retval != NULL);
 
@@ -1610,7 +1590,7 @@ dns_c_zone_getchecknames(isc_log_t *lctx, dns_c_zone_t *zone,
 
 
 isc_result_t
-dns_c_zone_getallowupd(isc_log_t *lctx, dns_c_zone_t *zone,
+dns_c_zone_getallowupd(dns_c_zone_t *zone,
 		       dns_c_ipmatchlist_t **retval)
 {
 	dns_c_ipmatchlist_t *p = NULL;
@@ -1633,13 +1613,13 @@ dns_c_zone_getallowupd(isc_log_t *lctx, dns_c_zone_t *zone,
 		break;
 		
 	case dns_c_zone_hint:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Hint zones do not have an allow_update field");
 		return (ISC_R_FAILURE);
 			
 	case dns_c_zone_forward:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Forward zones do not have an "
 			      "allow_update field");
@@ -1647,7 +1627,7 @@ dns_c_zone_getallowupd(isc_log_t *lctx, dns_c_zone_t *zone,
 	}
 
 	if (p != NULL) {
-		dns_c_ipmatchlist_attach(lctx, p, retval);
+		dns_c_ipmatchlist_attach(p, retval);
 		res = ISC_R_SUCCESS;
 	} else {
 		res = ISC_R_NOTFOUND;
@@ -1658,7 +1638,7 @@ dns_c_zone_getallowupd(isc_log_t *lctx, dns_c_zone_t *zone,
 
 
 isc_result_t
-dns_c_zone_getallowquery(isc_log_t *lctx, dns_c_zone_t *zone,
+dns_c_zone_getallowquery(dns_c_zone_t *zone,
 			 dns_c_ipmatchlist_t **retval)
 {
 	dns_c_ipmatchlist_t *p = NULL;
@@ -1681,13 +1661,13 @@ dns_c_zone_getallowquery(isc_log_t *lctx, dns_c_zone_t *zone,
 		break;
 		
 	case dns_c_zone_hint:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Hint zones do not have an allow_query field");
 		return (ISC_R_FAILURE);
 			
 	case dns_c_zone_forward:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Forward zones do not have an "
 			      "allow_query field");
@@ -1695,7 +1675,7 @@ dns_c_zone_getallowquery(isc_log_t *lctx, dns_c_zone_t *zone,
 	}
 
 	if (p != NULL) {
-		dns_c_ipmatchlist_attach(lctx, p, retval);
+		dns_c_ipmatchlist_attach(p, retval);
 		res = ISC_R_SUCCESS;
 	} else {
 		res = ISC_R_NOTFOUND;
@@ -1706,7 +1686,7 @@ dns_c_zone_getallowquery(isc_log_t *lctx, dns_c_zone_t *zone,
 
 
 isc_result_t
-dns_c_zone_getallowtransfer(isc_log_t *lctx, dns_c_zone_t *zone,
+dns_c_zone_getallowtransfer(dns_c_zone_t *zone,
 			    dns_c_ipmatchlist_t **retval)
 {
 	dns_c_ipmatchlist_t *p = NULL;
@@ -1729,14 +1709,14 @@ dns_c_zone_getallowtransfer(isc_log_t *lctx, dns_c_zone_t *zone,
 		break;
 		
 	case dns_c_zone_hint:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Hint zones do not have an "
 			      "allow_transfer field");
 		return (ISC_R_FAILURE);
 			
 	case dns_c_zone_forward:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Forward zones do not have an "
 			      "allow_transfer field");
@@ -1744,7 +1724,7 @@ dns_c_zone_getallowtransfer(isc_log_t *lctx, dns_c_zone_t *zone,
 	}
 
 	if (p != NULL) {
-		dns_c_ipmatchlist_attach(lctx, p, retval);
+		dns_c_ipmatchlist_attach(p, retval);
 		res = ISC_R_SUCCESS;
 	} else {
 		res = ISC_R_NOTFOUND;
@@ -1755,7 +1735,7 @@ dns_c_zone_getallowtransfer(isc_log_t *lctx, dns_c_zone_t *zone,
 
 
 isc_result_t
-dns_c_zone_getdialup(isc_log_t *lctx, dns_c_zone_t *zone,
+dns_c_zone_getdialup(dns_c_zone_t *zone,
 		     isc_boolean_t *retval)
 {
 	isc_result_t res = ISC_R_SUCCESS;
@@ -1792,13 +1772,13 @@ dns_c_zone_getdialup(isc_log_t *lctx, dns_c_zone_t *zone,
 		break;
 		
 	case dns_c_zone_hint:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Hint zones do not have a dialup field");
 		return (ISC_R_FAILURE);
 		
 	case dns_c_zone_forward:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Forward zones do not have a dialup field");
 		return (ISC_R_FAILURE);
@@ -1809,7 +1789,7 @@ dns_c_zone_getdialup(isc_log_t *lctx, dns_c_zone_t *zone,
 
 
 isc_result_t
-dns_c_zone_getnotify(isc_log_t *lctx, dns_c_zone_t *zone,
+dns_c_zone_getnotify(dns_c_zone_t *zone,
 		     isc_boolean_t *retval)
 {
 	isc_result_t res;
@@ -1834,19 +1814,19 @@ dns_c_zone_getnotify(isc_log_t *lctx, dns_c_zone_t *zone,
 		break;
 		
 	case dns_c_zone_stub:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Stub zones do not have a notify field");
 		return (ISC_R_FAILURE);
 			
 	case dns_c_zone_hint:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Hint zones do not have a notify field");
 		return (ISC_R_FAILURE);
 			
 	case dns_c_zone_forward:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Forward zones do not have a notify field");
 		return (ISC_R_FAILURE);
@@ -1864,7 +1844,7 @@ dns_c_zone_getnotify(isc_log_t *lctx, dns_c_zone_t *zone,
 
 
 isc_result_t
-dns_c_zone_getmaintixfrbase(isc_log_t *lctx, dns_c_zone_t *zone,
+dns_c_zone_getmaintixfrbase(dns_c_zone_t *zone,
 			    isc_boolean_t *retval)
 {
 	isc_result_t res;
@@ -1889,19 +1869,19 @@ dns_c_zone_getmaintixfrbase(isc_log_t *lctx, dns_c_zone_t *zone,
 		break;
 		
 	case dns_c_zone_stub:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Stub zones do not have a notify field");
 		return (ISC_R_FAILURE);
 			
 	case dns_c_zone_hint:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Hint zones do not have a notify field");
 		return (ISC_R_FAILURE);
 			
 	case dns_c_zone_forward:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Forward zones do not have a notify field");
 		return (ISC_R_FAILURE);
@@ -1919,7 +1899,7 @@ dns_c_zone_getmaintixfrbase(isc_log_t *lctx, dns_c_zone_t *zone,
 
 
 isc_result_t
-dns_c_zone_getalsonotify(isc_log_t *lctx, dns_c_zone_t *zone,
+dns_c_zone_getalsonotify(dns_c_zone_t *zone,
 			 dns_c_iplist_t **retval)
 {
 	dns_c_iplist_t *p = NULL;
@@ -1938,19 +1918,19 @@ dns_c_zone_getalsonotify(isc_log_t *lctx, dns_c_zone_t *zone,
 		break;
 		
 	case dns_c_zone_stub:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Stub zones do not have a also_notify field");
 		return (ISC_R_FAILURE);
 			
 	case dns_c_zone_hint:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Hint zones do not have a also_notify field");
 		return (ISC_R_FAILURE);
 			
 	case dns_c_zone_forward:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Forward zones do not have a also_notify field");
 		return (ISC_R_FAILURE);
@@ -1968,7 +1948,7 @@ dns_c_zone_getalsonotify(isc_log_t *lctx, dns_c_zone_t *zone,
 
 
 isc_result_t
-dns_c_zone_getixfrbase(isc_log_t *lctx, dns_c_zone_t *zone,
+dns_c_zone_getixfrbase(dns_c_zone_t *zone,
 		       const char **retval)
 {
 	char *p = NULL;
@@ -1987,19 +1967,19 @@ dns_c_zone_getixfrbase(isc_log_t *lctx, dns_c_zone_t *zone,
 		break;
 		
 	case dns_c_zone_stub:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Stub zones do not have a ixfr_base field");
 		return (ISC_R_FAILURE);
 			
 	case dns_c_zone_hint:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Hint zones do not have a ixfr_base field");
 		return (ISC_R_FAILURE);
 			
 	case dns_c_zone_forward:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Forward zones do not have a file field");
 		return (ISC_R_FAILURE);
@@ -2017,7 +1997,7 @@ dns_c_zone_getixfrbase(isc_log_t *lctx, dns_c_zone_t *zone,
 
 
 isc_result_t
-dns_c_zone_getixfrtmp(isc_log_t *lctx, dns_c_zone_t *zone, const char **retval)
+dns_c_zone_getixfrtmp(dns_c_zone_t *zone, const char **retval)
 {
 	char *p = NULL;
 	isc_result_t res;
@@ -2035,19 +2015,19 @@ dns_c_zone_getixfrtmp(isc_log_t *lctx, dns_c_zone_t *zone, const char **retval)
 		break;
 		
 	case dns_c_zone_stub:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Stub zones do not have a ixfr_tmp field");
 		return (ISC_R_FAILURE);
 			
 	case dns_c_zone_hint:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Hint zones do not have a ixfr_tmp field");
 		return (ISC_R_FAILURE);
 			
 	case dns_c_zone_forward:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Forward zones do not have a file field");
 		return (ISC_R_FAILURE);
@@ -2065,7 +2045,7 @@ dns_c_zone_getixfrtmp(isc_log_t *lctx, dns_c_zone_t *zone, const char **retval)
 
 
 isc_result_t
-dns_c_zone_getpubkeylist(isc_log_t *lctx, dns_c_zone_t *zone,
+dns_c_zone_getpubkeylist(dns_c_zone_t *zone,
 			 dns_c_pklist_t **retval)
 {
 	dns_c_pklist_t *p = NULL;
@@ -2091,14 +2071,14 @@ dns_c_zone_getpubkeylist(isc_log_t *lctx, dns_c_zone_t *zone,
 #if 1
 		p = zone->u.hzone.pubkeylist;
 #else	
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Hint zones do not have a pubkey field");
 #endif	
 		return (ISC_R_FAILURE);
 			
 	case dns_c_zone_forward:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Forward zones do not have a pubkey field");
 		return (ISC_R_FAILURE);
@@ -2116,7 +2096,7 @@ dns_c_zone_getpubkeylist(isc_log_t *lctx, dns_c_zone_t *zone,
 
 
 isc_result_t
-dns_c_zone_getmasterport(isc_log_t *lctx, dns_c_zone_t *zone,
+dns_c_zone_getmasterport(dns_c_zone_t *zone,
 			 in_port_t *retval)
 {
 	isc_result_t res = ISC_R_SUCCESS;
@@ -2126,7 +2106,7 @@ dns_c_zone_getmasterport(isc_log_t *lctx, dns_c_zone_t *zone,
 
 	switch(zone->ztype) {
 	case dns_c_zone_master:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Forward zones do not have a "
 			      "master_port field");
@@ -2153,13 +2133,13 @@ dns_c_zone_getmasterport(isc_log_t *lctx, dns_c_zone_t *zone,
 		break;
 
 	case dns_c_zone_hint:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Hint zones do not have a master_port field");
 		return (ISC_R_FAILURE);
 			
 	case dns_c_zone_forward:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Forward zones do not have a "
 			      "master_port field");
@@ -2171,14 +2151,14 @@ dns_c_zone_getmasterport(isc_log_t *lctx, dns_c_zone_t *zone,
 
 
 isc_result_t
-dns_c_zone_getmasterips(isc_log_t *lctx, dns_c_zone_t *zone,
+dns_c_zone_getmasterips(dns_c_zone_t *zone,
 			dns_c_iplist_t **retval)
 {
 	isc_result_t res = ISC_R_SUCCESS;
 
 	switch (zone->ztype) {
 	case dns_c_zone_master:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Master zones do not have a master_ips field");
 		return (ISC_R_FAILURE);
@@ -2202,13 +2182,13 @@ dns_c_zone_getmasterips(isc_log_t *lctx, dns_c_zone_t *zone,
 		break;
 		
 	case dns_c_zone_hint:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Hint zones do not have a master_ips field");
 		return (ISC_R_FAILURE);
 			
 	case dns_c_zone_forward:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Forward zones do not have a master_ips field");
 		return (ISC_R_FAILURE);
@@ -2219,7 +2199,7 @@ dns_c_zone_getmasterips(isc_log_t *lctx, dns_c_zone_t *zone,
 
 
 isc_result_t
-dns_c_zone_gettransfersource(isc_log_t *lctx, dns_c_zone_t *zone,
+dns_c_zone_gettransfersource(dns_c_zone_t *zone,
 			     isc_sockaddr_t *retval)
 {
 	isc_result_t res = ISC_R_SUCCESS;
@@ -2229,7 +2209,7 @@ dns_c_zone_gettransfersource(isc_log_t *lctx, dns_c_zone_t *zone,
 
 	switch (zone->ztype) {
 	case dns_c_zone_master:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Master zones do not have a "
 			      "transfer_source field");
@@ -2258,13 +2238,13 @@ dns_c_zone_gettransfersource(isc_log_t *lctx, dns_c_zone_t *zone,
 		break;
 
 	case dns_c_zone_hint:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Hint zones do not have a master_ips field");
 		return (ISC_R_FAILURE);
 			
 	case dns_c_zone_forward:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Forward zones do not have a master_ips field");
 		return (ISC_R_FAILURE);
@@ -2275,7 +2255,7 @@ dns_c_zone_gettransfersource(isc_log_t *lctx, dns_c_zone_t *zone,
 
 
 isc_result_t
-dns_c_zone_getmaxtranstimein(isc_log_t *lctx, dns_c_zone_t *zone,
+dns_c_zone_getmaxtranstimein(dns_c_zone_t *zone,
 			     isc_int32_t *retval)
 {
 	isc_result_t res = ISC_R_SUCCESS;
@@ -2285,7 +2265,7 @@ dns_c_zone_getmaxtranstimein(isc_log_t *lctx, dns_c_zone_t *zone,
 
 	switch (zone->ztype) {
 	case dns_c_zone_master:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Master zones do not have a "
 			      "max_trans_time_in field");
@@ -2312,14 +2292,14 @@ dns_c_zone_getmaxtranstimein(isc_log_t *lctx, dns_c_zone_t *zone,
 		break;
 		
 	case dns_c_zone_hint:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Hint zones do not have a "
 			      "max_trans_time_in field");
 		return (ISC_R_FAILURE);
 			
 	case dns_c_zone_forward:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Forward zones do not have a "
 			      "max_trans_time_in field");
@@ -2331,7 +2311,7 @@ dns_c_zone_getmaxtranstimein(isc_log_t *lctx, dns_c_zone_t *zone,
 
 
 isc_result_t
-dns_c_zone_getmaxixfrlog(isc_log_t *lctx, dns_c_zone_t *zone,
+dns_c_zone_getmaxixfrlog(dns_c_zone_t *zone,
 			 isc_int32_t *retval)
 {
 	isc_result_t res;
@@ -2357,19 +2337,19 @@ dns_c_zone_getmaxixfrlog(isc_log_t *lctx, dns_c_zone_t *zone,
 		break;
 		
 	case dns_c_zone_stub:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Stub zones do not have a max_ixfr_log field");
 		return (ISC_R_FAILURE);
 
 	case dns_c_zone_hint:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Hint zones do not have a max_ixfr_log field");
 		return (ISC_R_FAILURE);
 			
 	case dns_c_zone_forward:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Forward zones do not have a "
 			      "max_ixfr_log field");
@@ -2388,7 +2368,7 @@ dns_c_zone_getmaxixfrlog(isc_log_t *lctx, dns_c_zone_t *zone,
 
 
 isc_result_t
-dns_c_zone_getforward(isc_log_t *lctx, dns_c_zone_t *zone,
+dns_c_zone_getforward(dns_c_zone_t *zone,
 		      dns_c_forw_t *retval)
 {
 	isc_result_t res = ISC_R_SUCCESS;
@@ -2425,7 +2405,7 @@ dns_c_zone_getforward(isc_log_t *lctx, dns_c_zone_t *zone,
 		break;
 
 	case dns_c_zone_hint:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Hint zones do not have a forward field");
 		return (ISC_R_FAILURE);
@@ -2445,7 +2425,7 @@ dns_c_zone_getforward(isc_log_t *lctx, dns_c_zone_t *zone,
 
 
 isc_result_t
-dns_c_zone_getforwarders(isc_log_t *lctx, dns_c_zone_t *zone,
+dns_c_zone_getforwarders(dns_c_zone_t *zone,
 			 dns_c_iplist_t **retval)
 {
 	isc_result_t res = ISC_R_SUCCESS;
@@ -2485,7 +2465,7 @@ dns_c_zone_getforwarders(isc_log_t *lctx, dns_c_zone_t *zone,
 		break;
 		
 	case dns_c_zone_hint:
-		isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
+		isc_log_write(dns_lctx, DNS_LOGCATEGORY_CONFIG,
 			      DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
 			      "Hint zones do not have a forwarders field");
 		return (ISC_R_FAILURE);
@@ -2510,123 +2490,123 @@ dns_c_zone_getforwarders(isc_log_t *lctx, dns_c_zone_t *zone,
  */
 
 static void
-master_zone_print(isc_log_t *lctx, FILE *fp, int indent,
+master_zone_print(FILE *fp, int indent,
 		  dns_c_masterzone_t *mzone)
 {
 	if (mzone->file != NULL) {
-		dns_c_printtabs(lctx, fp, indent);
+		dns_c_printtabs(fp, indent);
 		fprintf(fp, "file \"%s\";\n", mzone->file);
 	}
 
 	if (DNS_C_CHECKBIT(MZ_CHECK_NAME_BIT, &mzone->setflags)) {
-		dns_c_printtabs(lctx, fp, indent);
+		dns_c_printtabs(fp, indent);
 		fprintf(fp, "check-names %s;\n",
-			dns_c_nameseverity2string(lctx, mzone->check_names,
+			dns_c_nameseverity2string(mzone->check_names,
 						  ISC_TRUE));
 	}
 
 	if (mzone->allow_update != NULL &&
 	    !ISC_LIST_EMPTY(mzone->allow_update->elements)) {
-		dns_c_printtabs(lctx, fp, indent);
+		dns_c_printtabs(fp, indent);
 		fprintf(fp, "allow-update ");
-		dns_c_ipmatchlist_print(lctx, fp, indent + 1,
+		dns_c_ipmatchlist_print(fp, indent + 1,
 					mzone->allow_update);
 		fprintf(fp, ";\n");
 	}
 
 	if (mzone->allow_query != NULL &&
 	    !ISC_LIST_EMPTY(mzone->allow_query->elements)) {
-		dns_c_printtabs(lctx, fp, indent);
+		dns_c_printtabs(fp, indent);
 		fprintf(fp, "allow-query ");
-		dns_c_ipmatchlist_print(lctx, fp, indent + 1,
+		dns_c_ipmatchlist_print(fp, indent + 1,
 					mzone->allow_query);
 		fprintf(fp, ";\n");
 	}
 
 	if (mzone->allow_transfer != NULL &&
 	    !ISC_LIST_EMPTY(mzone->allow_transfer->elements)) {
-		dns_c_printtabs(lctx, fp, indent);
+		dns_c_printtabs(fp, indent);
 		fprintf(fp, "allow-transfer ");
-		dns_c_ipmatchlist_print(lctx, fp, indent + 1,
+		dns_c_ipmatchlist_print(fp, indent + 1,
 					mzone->allow_transfer);
 		fprintf(fp, ";\n");
 	}
 
 	if (DNS_C_CHECKBIT(MZ_DIALUP_BIT, &mzone->setflags)) {
-		dns_c_printtabs(lctx, fp, indent);
+		dns_c_printtabs(fp, indent);
 		fprintf(fp, "dialup %s;\n",
 			(mzone->dialup ? "true" : "false"));
 	}
 
 	if (DNS_C_CHECKBIT(MZ_NOTIFY_BIT, &mzone->setflags)) {
-		dns_c_printtabs(lctx, fp, indent);
+		dns_c_printtabs(fp, indent);
 		fprintf(fp, "notify %s;\n",
 			(mzone->notify ? "true" : "false"));
 	}
 
 	if (mzone->also_notify != NULL) {
-		dns_c_printtabs(lctx, fp, indent);
+		dns_c_printtabs(fp, indent);
 		fprintf(fp, "also-notify ");
-		dns_c_iplist_print(lctx, fp, indent + 1, mzone->also_notify);
+		dns_c_iplist_print(fp, indent + 1, mzone->also_notify);
 	}
 
 	if (mzone->ixfr_base != NULL) {
-		dns_c_printtabs(lctx, fp, indent);
+		dns_c_printtabs(fp, indent);
 		fprintf(fp, "ixfr-base \"%s\";\n", mzone->ixfr_base);
 	}
 
 	if (mzone->ixfr_tmp != NULL) {
-		dns_c_printtabs(lctx, fp, indent);
+		dns_c_printtabs(fp, indent);
 		fprintf(fp, "ixfr-tmp-file \"%s\";\n", mzone->ixfr_tmp);
 	}
 
 	if (mzone->pubkeylist != NULL) {
-		dns_c_printtabs(lctx, fp, indent);
-		dns_c_pklist_print(lctx, fp, indent, mzone->pubkeylist);
+		dns_c_printtabs(fp, indent);
+		dns_c_pklist_print(fp, indent, mzone->pubkeylist);
 	}
 
 	if (DNS_C_CHECKBIT(MZ_FORWARD_BIT, &mzone->setflags)) {
-		dns_c_printtabs(lctx, fp, indent);
+		dns_c_printtabs(fp, indent);
 		fprintf(fp, "forward %s;\n",
-			dns_c_forward2string(lctx, mzone->forward, ISC_TRUE));
+			dns_c_forward2string(mzone->forward, ISC_TRUE));
 	}
 
 	if (mzone->forwarders != NULL && mzone->forwarders->nextidx > 0) {
-		dns_c_printtabs(lctx, fp, indent);
+		dns_c_printtabs(fp, indent);
 		fprintf(fp, "forwarders ");
-		dns_c_iplist_print(lctx, fp, indent + 1,
+		dns_c_iplist_print(fp, indent + 1,
 				   mzone->forwarders);
 	}
 }
 
 
 static void
-slave_zone_print(isc_log_t *lctx, FILE *fp, int indent,
+slave_zone_print(FILE *fp, int indent,
 		 dns_c_slavezone_t *szone)
 {
 	if (szone->file != NULL) {
-		dns_c_printtabs(lctx, fp, indent);
+		dns_c_printtabs(fp, indent);
 		fprintf(fp, "file \"%s\";\n", szone->file);
 	}
 
 	if (DNS_C_CHECKBIT(SZ_CHECK_NAME_BIT, &szone->setflags)) {
-		dns_c_printtabs(lctx, fp, indent);
+		dns_c_printtabs(fp, indent);
 		fprintf(fp, "check-names %s;\n",
-			dns_c_nameseverity2string(lctx, szone->check_names,
+			dns_c_nameseverity2string(szone->check_names,
 						  ISC_TRUE));
 	}
 
 	if (szone->ixfr_base != NULL) {
-		dns_c_printtabs(lctx, fp, indent);
+		dns_c_printtabs(fp, indent);
 		fprintf(fp, "ixfr-base \"%s\";\n", szone->ixfr_base);
 	}
 
 	if (szone->ixfr_tmp != NULL) {
-		dns_c_printtabs(lctx, fp, indent);
+		dns_c_printtabs(fp, indent);
 		fprintf(fp, "ixfr-tmp-file \"%s\";\n", szone->ixfr_tmp);
 	}
 
-	dns_c_printtabs(lctx, fp, indent);
+	dns_c_printtabs(fp, indent);
 	fprintf(fp, "masters ");
 	if (DNS_C_CHECKBIT(SZ_MASTER_PORT_BIT, &szone->setflags)) {
 		if (szone->master_port != 0) {
@@ -2637,98 +2617,98 @@ slave_zone_print(isc_log_t *lctx, FILE *fp, int indent,
 	    szone->master_ips->nextidx == 0) {
 		fprintf(fp, "{ /* none defined */ };\n");
 	} else {
-		dns_c_iplist_print(lctx, fp, indent + 1, szone->master_ips);
+		dns_c_iplist_print(fp, indent + 1, szone->master_ips);
 	}
 
 	if (szone->allow_update != NULL &&
 	    !ISC_LIST_EMPTY(szone->allow_update->elements)) {
-		dns_c_printtabs(lctx, fp, indent);
+		dns_c_printtabs(fp, indent);
 		fprintf(fp, "allow-update ");
-		dns_c_ipmatchlist_print(lctx, fp, indent + 1,
+		dns_c_ipmatchlist_print(fp, indent + 1,
 					szone->allow_update);
 		fprintf(fp, ";\n");
 	}
 
 	if (szone->allow_query != NULL &&
 	    !ISC_LIST_EMPTY(szone->allow_query->elements)) {
-		dns_c_printtabs(lctx, fp, indent);
+		dns_c_printtabs(fp, indent);
 		fprintf(fp, "allow-query ");
-		dns_c_ipmatchlist_print(lctx, fp, indent + 1,
+		dns_c_ipmatchlist_print(fp, indent + 1,
 					szone->allow_query);
 		fprintf(fp, ";\n");
 	}
 
 	if (szone->allow_transfer != NULL &&
 	    !ISC_LIST_EMPTY(szone->allow_transfer->elements)) {
-		dns_c_printtabs(lctx, fp, indent);
+		dns_c_printtabs(fp, indent);
 		fprintf(fp, "allow-transfer ");
-		dns_c_ipmatchlist_print(lctx, fp, indent + 1,
+		dns_c_ipmatchlist_print(fp, indent + 1,
 					szone->allow_transfer);
 		fprintf(fp, ";\n");
 	}
 
 	if (DNS_C_CHECKBIT(SZ_TRANSFER_SOURCE_BIT, &szone->setflags)) {
-		dns_c_printtabs(lctx, fp, indent);
+		dns_c_printtabs(fp, indent);
 		fprintf(fp, "transfer-source ");
-		dns_c_print_ipaddr(lctx, fp, &szone->transfer_source);
+		dns_c_print_ipaddr(fp, &szone->transfer_source);
 		fprintf(fp, " ;\n");
 	}
 
 	if (DNS_C_CHECKBIT(SZ_MAX_TRANS_TIME_IN_BIT, &szone->setflags)) {
-		dns_c_printtabs(lctx, fp, indent);
+		dns_c_printtabs(fp, indent);
 		fprintf(fp, "max-transfer-time-in %d;\n",
 			szone->max_trans_time_in);
 	}
 	
 	if (DNS_C_CHECKBIT(SZ_NOTIFY_BIT, &szone->setflags)) {
-		dns_c_printtabs(lctx, fp, indent);
+		dns_c_printtabs(fp, indent);
 		fprintf(fp, "notify %s;\n",
 			(szone->notify ? "true" : "false"));
 	}
 
 	if (szone->also_notify != NULL) {
-		dns_c_printtabs(lctx, fp, indent);
+		dns_c_printtabs(fp, indent);
 		fprintf(fp, "also-notify ");
-		dns_c_iplist_print(lctx, fp, indent + 1, szone->also_notify);
+		dns_c_iplist_print(fp, indent + 1, szone->also_notify);
 	}
 
 
 	if (szone->pubkeylist != NULL) {
-		dns_c_printtabs(lctx, fp, indent);
-		dns_c_pklist_print(lctx, fp, indent, szone->pubkeylist);
+		dns_c_printtabs(fp, indent);
+		dns_c_pklist_print(fp, indent, szone->pubkeylist);
 	}
 
 	if (DNS_C_CHECKBIT(SZ_FORWARD_BIT, &szone->setflags)) {
-		dns_c_printtabs(lctx, fp, indent);
+		dns_c_printtabs(fp, indent);
 		fprintf(fp, "forward %s;\n",
-			dns_c_forward2string(lctx, szone->forward, ISC_TRUE));
+			dns_c_forward2string(szone->forward, ISC_TRUE));
 	}
 
 	if (szone->forwarders != NULL && szone->forwarders->nextidx > 0) {
-		dns_c_printtabs(lctx, fp, indent);
+		dns_c_printtabs(fp, indent);
 		fprintf(fp, "forwarders ");
-		dns_c_iplist_print(lctx, fp, indent + 1,
+		dns_c_iplist_print(fp, indent + 1,
 				   szone->forwarders);
 	}
 }
 
 
 static void
-stub_zone_print(isc_log_t *lctx, FILE *fp, int indent, dns_c_stubzone_t *tzone)
+stub_zone_print(FILE *fp, int indent, dns_c_stubzone_t *tzone)
 {
 	if (tzone->file != NULL) {
-		dns_c_printtabs(lctx, fp, indent);
+		dns_c_printtabs(fp, indent);
 		fprintf(fp, "file \"%s\";\n", tzone->file);
 	}
 
 	if (DNS_C_CHECKBIT(TZ_CHECK_NAME_BIT, &tzone->setflags)) {
-		dns_c_printtabs(lctx, fp, indent);
+		dns_c_printtabs(fp, indent);
 		fprintf(fp, "check-names %s;\n",
-			dns_c_nameseverity2string(lctx, tzone->check_names,
+			dns_c_nameseverity2string(tzone->check_names,
 						  ISC_TRUE));
 	}
 
-	dns_c_printtabs(lctx, fp, indent);
+	dns_c_printtabs(fp, indent);
 	fprintf(fp, "masters ");
 	if (DNS_C_CHECKBIT(TZ_MASTER_PORT_BIT, &tzone->setflags)) {
 		if (tzone->master_port != 0) {
@@ -2739,64 +2719,64 @@ stub_zone_print(isc_log_t *lctx, FILE *fp, int indent, dns_c_stubzone_t *tzone)
 	    tzone->master_ips->nextidx == 0) {
 		fprintf(fp, "{ /* none defined */ };\n");
 	} else {
-		dns_c_iplist_print(lctx, fp, indent + 1, tzone->master_ips);
+		dns_c_iplist_print(fp, indent + 1, tzone->master_ips);
 	}
 
 	if (tzone->allow_update != NULL &&
 	    !ISC_LIST_EMPTY(tzone->allow_update->elements)) {
-		dns_c_printtabs(lctx, fp, indent);
+		dns_c_printtabs(fp, indent);
 		fprintf(fp, "allow-update ");
-		dns_c_ipmatchlist_print(lctx, fp, indent + 1,
+		dns_c_ipmatchlist_print(fp, indent + 1,
 					tzone->allow_update);
 		fprintf(fp, ";\n");
 	}
 
 	if (tzone->allow_query != NULL &&
 	    !ISC_LIST_EMPTY(tzone->allow_query->elements)) {
-		dns_c_printtabs(lctx, fp, indent);
+		dns_c_printtabs(fp, indent);
 		fprintf(fp, "allow-query ");
-		dns_c_ipmatchlist_print(lctx, fp, indent + 1,
+		dns_c_ipmatchlist_print(fp, indent + 1,
 					tzone->allow_query);
 		fprintf(fp, ";\n");
 	}
 
 	if (tzone->allow_transfer != NULL &&
 	    !ISC_LIST_EMPTY(tzone->allow_transfer->elements)) {
-		dns_c_printtabs(lctx, fp, indent);
+		dns_c_printtabs(fp, indent);
 		fprintf(fp, "allow-transfer ");
-		dns_c_ipmatchlist_print(lctx, fp, indent + 1,
+		dns_c_ipmatchlist_print(fp, indent + 1,
 					tzone->allow_transfer);
 		fprintf(fp, ";\n");
 	}
 
 	if (DNS_C_CHECKBIT(TZ_TRANSFER_SOURCE_BIT, &tzone->setflags)) {
-		dns_c_printtabs(lctx, fp, indent);
+		dns_c_printtabs(fp, indent);
 		fprintf(fp, "transfer-source ;\n");
-		dns_c_print_ipaddr(lctx, fp, &tzone->transfer_source);
+		dns_c_print_ipaddr(fp, &tzone->transfer_source);
 		fprintf(fp, ";\n");
 	}
 
 	if (DNS_C_CHECKBIT(TZ_MAX_TRANS_TIME_IN_BIT, &tzone->setflags)) {
-		dns_c_printtabs(lctx, fp, indent);
+		dns_c_printtabs(fp, indent);
 		fprintf(fp, "max-transfer-time-in %d;\n",
 			tzone->max_trans_time_in);
 	}
 	
 	if (tzone->pubkeylist != NULL) {
-		dns_c_printtabs(lctx, fp, indent);
-		dns_c_pklist_print(lctx, fp, indent, tzone->pubkeylist);
+		dns_c_printtabs(fp, indent);
+		dns_c_pklist_print(fp, indent, tzone->pubkeylist);
 	}
 
 	if (DNS_C_CHECKBIT(TZ_FORWARD_BIT, &tzone->setflags)) {
-		dns_c_printtabs(lctx, fp, indent);
+		dns_c_printtabs(fp, indent);
 		fprintf(fp, "forward %s;\n",
-			dns_c_forward2string(lctx, tzone->forward, ISC_TRUE));
+			dns_c_forward2string(tzone->forward, ISC_TRUE));
 	}
 
 	if (tzone->forwarders != NULL && tzone->forwarders->nextidx > 0) {
-		dns_c_printtabs(lctx, fp, indent);
+		dns_c_printtabs(fp, indent);
 		fprintf(fp, "forwarders ");
-		dns_c_iplist_print(lctx, fp, indent + 1,
+		dns_c_iplist_print(fp, indent + 1,
 				   tzone->forwarders);
 	}
 
@@ -2804,58 +2784,56 @@ stub_zone_print(isc_log_t *lctx, FILE *fp, int indent, dns_c_stubzone_t *tzone)
 
 
 static void
-hint_zone_print(isc_log_t *lctx, FILE *fp, int indent, dns_c_hintzone_t *hzone)
+hint_zone_print(FILE *fp, int indent, dns_c_hintzone_t *hzone)
 {
 	if (hzone->file != NULL) {
-		dns_c_printtabs(lctx, fp, indent);
+		dns_c_printtabs(fp, indent);
 		fprintf(fp, "file \"%s\";\n", hzone->file);
 	}
 
 	if (DNS_C_CHECKBIT(HZ_CHECK_NAME_BIT, &hzone->setflags)) {
-		dns_c_printtabs(lctx, fp, indent);
+		dns_c_printtabs(fp, indent);
 		fprintf(fp, "check-names %s;\n",
-			dns_c_nameseverity2string(lctx, hzone->check_names,
+			dns_c_nameseverity2string(hzone->check_names,
 						  ISC_TRUE));
 	}
 
 	if (hzone->pubkeylist != NULL) {
-		dns_c_printtabs(lctx, fp, indent);
-		dns_c_pklist_print(lctx, fp, indent, hzone->pubkeylist);
+		dns_c_printtabs(fp, indent);
+		dns_c_pklist_print(fp, indent, hzone->pubkeylist);
 	}
 }
 
 
 static void
-forward_zone_print(isc_log_t *lctx, FILE *fp, int indent,
+forward_zone_print(FILE *fp, int indent,
 		   dns_c_forwardzone_t *fzone)
 {
 	if (DNS_C_CHECKBIT(FZ_CHECK_NAME_BIT, &fzone->setflags)) {
-		dns_c_printtabs(lctx, fp, indent);
+		dns_c_printtabs(fp, indent);
 		fprintf(fp, "check-names %s;\n",
-			dns_c_nameseverity2string(lctx, fzone->check_names,
+			dns_c_nameseverity2string(fzone->check_names,
 						  ISC_TRUE));
 	}
 
 	if (DNS_C_CHECKBIT(FZ_FORWARD_BIT, &fzone->setflags)) {
-		dns_c_printtabs(lctx, fp, indent);
+		dns_c_printtabs(fp, indent);
 		fprintf(fp, "forward %s;\n",
-			dns_c_forward2string(lctx, fzone->forward, ISC_TRUE));
+			dns_c_forward2string(fzone->forward, ISC_TRUE));
 	}
 
 	if (fzone->forwarders != NULL && fzone->forwarders->nextidx > 0) {
-		dns_c_printtabs(lctx, fp, indent);
+		dns_c_printtabs(fp, indent);
 		fprintf(fp, "forwarders ");
-		dns_c_iplist_print(lctx, fp, indent + 1,
+		dns_c_iplist_print(fp, indent + 1,
 				   fzone->forwarders);
 	}
 }
 
 
 static isc_result_t
-master_zone_init(isc_log_t *lctx, dns_c_masterzone_t *mzone)
+master_zone_init(dns_c_masterzone_t *mzone)
 {
-	(void) lctx;
-	
 	mzone->file = NULL;
 	mzone->allow_update = NULL;
 	mzone->allow_query = NULL;
@@ -2873,10 +2851,8 @@ master_zone_init(isc_log_t *lctx, dns_c_masterzone_t *mzone)
 
 
 static isc_result_t
-slave_zone_init(isc_log_t *lctx, dns_c_slavezone_t *szone)
+slave_zone_init(dns_c_slavezone_t *szone)
 {
-	(void) lctx;
-	
 	szone->file = NULL;
 	szone->ixfr_base = NULL;
 	szone->ixfr_tmp = NULL;
@@ -2895,10 +2871,8 @@ slave_zone_init(isc_log_t *lctx, dns_c_slavezone_t *szone)
 
 
 static isc_result_t
-stub_zone_init(isc_log_t *lctx, dns_c_stubzone_t *tzone)
+stub_zone_init(dns_c_stubzone_t *tzone)
 {
-	(void) lctx;
-	
 	tzone->file = NULL;
 	tzone->master_ips = NULL;
 	tzone->allow_update = NULL;
@@ -2914,10 +2888,8 @@ stub_zone_init(isc_log_t *lctx, dns_c_stubzone_t *tzone)
 
 
 static isc_result_t
-hint_zone_init(isc_log_t *lctx, dns_c_hintzone_t *hzone)
+hint_zone_init(dns_c_hintzone_t *hzone)
 {
-	(void) lctx;
-	
 	hzone->file = NULL;
 	hzone->pubkeylist = NULL;
 	memset(&hzone->setflags, 0x0, sizeof (hzone->setflags));
@@ -2927,10 +2899,8 @@ hint_zone_init(isc_log_t *lctx, dns_c_hintzone_t *hzone)
 
 
 static isc_result_t
-forward_zone_init(isc_log_t *lctx, dns_c_forwardzone_t *fzone)
+forward_zone_init(dns_c_forwardzone_t *fzone)
 {
-	(void) lctx;
-	
 	fzone->forwarders = NULL;
 	memset(&fzone->setflags, 0x0, sizeof (fzone->setflags));
 
@@ -2939,7 +2909,7 @@ forward_zone_init(isc_log_t *lctx, dns_c_forwardzone_t *fzone)
 
 
 static isc_result_t
-zone_delete(isc_log_t *lctx, dns_c_zone_t **zone)
+zone_delete(dns_c_zone_t **zone)
 {
 	dns_c_zone_t *z;
 	isc_result_t res = ISC_R_SUCCESS;
@@ -2954,23 +2924,23 @@ zone_delete(isc_log_t *lctx, dns_c_zone_t **zone)
 	
 	switch(z->ztype) {
 	case dns_c_zone_master:
-		res = master_zone_clear(lctx, z->mem, &z->u.mzone);
+		res = master_zone_clear(z->mem, &z->u.mzone);
 		break;
 
 	case dns_c_zone_slave:
-		res = slave_zone_clear(lctx, z->mem, &z->u.szone);
+		res = slave_zone_clear(z->mem, &z->u.szone);
 		break;
 		
 	case dns_c_zone_stub:
-		res = stub_zone_clear(lctx, z->mem, &z->u.tzone);
+		res = stub_zone_clear(z->mem, &z->u.tzone);
 		break;
 		
 	case dns_c_zone_hint:
-		res = hint_zone_clear(lctx, z->mem, &z->u.hzone);
+		res = hint_zone_clear(z->mem, &z->u.hzone);
 		break;
 		
 	case dns_c_zone_forward:
-		res = forward_zone_clear(lctx, z->mem, &z->u.fzone);
+		res = forward_zone_clear(z->mem, &z->u.fzone);
 		break;
 	}
 
@@ -2981,7 +2951,7 @@ zone_delete(isc_log_t *lctx, dns_c_zone_t **zone)
 
 
 static isc_result_t
-master_zone_clear(isc_log_t *lctx, isc_mem_t *mem, dns_c_masterzone_t *mzone)
+master_zone_clear(isc_mem_t *mem, dns_c_masterzone_t *mzone)
 {
 	if (mzone == NULL) {
 		return (ISC_R_SUCCESS);
@@ -2992,16 +2962,16 @@ master_zone_clear(isc_log_t *lctx, isc_mem_t *mem, dns_c_masterzone_t *mzone)
 	}
 
 	if (mzone->allow_update != NULL)
-		dns_c_ipmatchlist_detach(lctx, &mzone->allow_update);
+		dns_c_ipmatchlist_detach(&mzone->allow_update);
 
 	if (mzone->allow_query != NULL)
-		dns_c_ipmatchlist_detach(lctx, &mzone->allow_query);
+		dns_c_ipmatchlist_detach(&mzone->allow_query);
 
 	if (mzone->allow_transfer != NULL)
-		dns_c_ipmatchlist_detach(lctx, &mzone->allow_transfer);
+		dns_c_ipmatchlist_detach(&mzone->allow_transfer);
 
 	if (mzone->also_notify != NULL)
-		dns_c_iplist_detach(lctx, &mzone->also_notify);
+		dns_c_iplist_detach(&mzone->also_notify);
 	
 	if (mzone->ixfr_base != NULL) {
 		isc_mem_free(mem, mzone->ixfr_base);
@@ -3012,17 +2982,17 @@ master_zone_clear(isc_log_t *lctx, isc_mem_t *mem, dns_c_masterzone_t *mzone)
 	}
 
 	if (mzone->pubkeylist != NULL)
-		dns_c_pklist_delete(lctx, &mzone->pubkeylist);
+		dns_c_pklist_delete(&mzone->pubkeylist);
 
 	if (mzone->forwarders != NULL)
-		dns_c_iplist_detach(lctx, &mzone->forwarders);
+		dns_c_iplist_detach(&mzone->forwarders);
 
 	return (ISC_R_SUCCESS);
 }
 
 
 static isc_result_t
-slave_zone_clear(isc_log_t *lctx, isc_mem_t *mem, dns_c_slavezone_t *szone)
+slave_zone_clear(isc_mem_t *mem, dns_c_slavezone_t *szone)
 {
 	if (szone == NULL) {
 		return (ISC_R_SUCCESS);
@@ -3041,25 +3011,25 @@ slave_zone_clear(isc_log_t *lctx, isc_mem_t *mem, dns_c_slavezone_t *szone)
 	}
 		
 	if (szone->master_ips != NULL)
-		dns_c_iplist_detach(lctx, &szone->master_ips);
+		dns_c_iplist_detach(&szone->master_ips);
 	
 	if (szone->allow_update != NULL)
-		dns_c_ipmatchlist_detach(lctx, &szone->allow_update);
+		dns_c_ipmatchlist_detach(&szone->allow_update);
 	
 	if (szone->allow_query != NULL)
-		dns_c_ipmatchlist_detach(lctx, &szone->allow_query);
+		dns_c_ipmatchlist_detach(&szone->allow_query);
 	
 	if (szone->allow_transfer != NULL)
-		dns_c_ipmatchlist_detach(lctx, &szone->allow_transfer);
+		dns_c_ipmatchlist_detach(&szone->allow_transfer);
 	
 	if (szone->also_notify != NULL)
-		dns_c_iplist_detach(lctx, &szone->also_notify);
+		dns_c_iplist_detach(&szone->also_notify);
 	
 	if (szone->forwarders != NULL)
-		dns_c_iplist_detach(lctx, &szone->forwarders);
+		dns_c_iplist_detach(&szone->forwarders);
 	
 	if (szone->pubkeylist != NULL)
-		dns_c_pklist_delete(lctx, &szone->pubkeylist);
+		dns_c_pklist_delete(&szone->pubkeylist);
 
 	return (ISC_R_SUCCESS);
 }
@@ -3067,7 +3037,7 @@ slave_zone_clear(isc_log_t *lctx, isc_mem_t *mem, dns_c_slavezone_t *szone)
 
 
 static isc_result_t
-stub_zone_clear(isc_log_t *lctx, isc_mem_t *mem, dns_c_stubzone_t *tzone)
+stub_zone_clear(isc_mem_t *mem, dns_c_stubzone_t *tzone)
 {
 	if (tzone == NULL) {
 		return (ISC_R_SUCCESS);
@@ -3078,26 +3048,26 @@ stub_zone_clear(isc_log_t *lctx, isc_mem_t *mem, dns_c_stubzone_t *tzone)
 	}
 
 	if (tzone->master_ips != NULL)
-		dns_c_iplist_detach(lctx, &tzone->master_ips);
+		dns_c_iplist_detach(&tzone->master_ips);
 	
 	if (tzone->allow_update != NULL)
-		dns_c_ipmatchlist_detach(lctx, &tzone->allow_update);
+		dns_c_ipmatchlist_detach(&tzone->allow_update);
 	
 	if (tzone->allow_query != NULL)
-		dns_c_ipmatchlist_detach(lctx, &tzone->allow_query);
+		dns_c_ipmatchlist_detach(&tzone->allow_query);
 	
 	if (tzone->allow_transfer != NULL)
-		dns_c_ipmatchlist_detach(lctx, &tzone->allow_transfer);
+		dns_c_ipmatchlist_detach(&tzone->allow_transfer);
 	
 	if (tzone->pubkeylist != NULL)
-		dns_c_pklist_delete(lctx, &tzone->pubkeylist);
+		dns_c_pklist_delete(&tzone->pubkeylist);
 	
 	return (ISC_R_SUCCESS);
 }
 
 
 static isc_result_t
-forward_zone_clear(isc_log_t *lctx, isc_mem_t *mem, dns_c_forwardzone_t *fzone)
+forward_zone_clear(isc_mem_t *mem, dns_c_forwardzone_t *fzone)
 {
 	if (fzone == NULL) {
 		return (ISC_R_SUCCESS);
@@ -3106,17 +3076,15 @@ forward_zone_clear(isc_log_t *lctx, isc_mem_t *mem, dns_c_forwardzone_t *fzone)
 	(void) mem;			/* lint happiness */
 	
 	if (fzone->forwarders != NULL)
-		dns_c_iplist_detach(lctx, &fzone->forwarders);
+		dns_c_iplist_detach(&fzone->forwarders);
 	
 	return (ISC_R_SUCCESS);
 }
 
 
 static isc_result_t
-hint_zone_clear(isc_log_t *lctx, isc_mem_t *mem, dns_c_hintzone_t *hzone)
+hint_zone_clear(isc_mem_t *mem, dns_c_hintzone_t *hzone)
 {
-	(void) lctx;
-	
 	if (hzone == NULL) {
 		return (ISC_R_SUCCESS);
 	}
@@ -3126,7 +3094,7 @@ hint_zone_clear(isc_log_t *lctx, isc_mem_t *mem, dns_c_hintzone_t *hzone)
 	}
 	
 	if (hzone->pubkeylist != NULL)
-		dns_c_pklist_delete(lctx, &hzone->pubkeylist);
+		dns_c_pklist_delete(&hzone->pubkeylist);
 	
 	return (ISC_R_SUCCESS);
 }
@@ -3135,21 +3103,21 @@ hint_zone_clear(isc_log_t *lctx, isc_mem_t *mem, dns_c_hintzone_t *hzone)
 /**************************************************/
 
 static isc_result_t
-set_ipmatch_list_field(isc_log_t *lctx, isc_mem_t *mem,
+set_ipmatch_list_field(isc_mem_t *mem,
 		       dns_c_ipmatchlist_t **dest, dns_c_ipmatchlist_t *src,
 		       isc_boolean_t deepcopy)
 {
 	isc_result_t res;
 	
 	if (*dest != NULL) {
-		res = dns_c_ipmatchlist_detach(lctx, dest);
+		res = dns_c_ipmatchlist_detach(dest);
 		if (res != ISC_R_SUCCESS) {
 			return (res);
 		}
 	}
 	
 	if (deepcopy) {
-		res = dns_c_ipmatchlist_copy(lctx, mem, dest, src);
+		res = dns_c_ipmatchlist_copy(mem, dest, src);
 	} else {
 		*dest = src;
 		res = ISC_R_SUCCESS;
@@ -3160,21 +3128,21 @@ set_ipmatch_list_field(isc_log_t *lctx, isc_mem_t *mem,
 
 
 static isc_result_t
-set_iplist_field(isc_log_t *lctx, isc_mem_t *mem,
+set_iplist_field(isc_mem_t *mem,
 		 dns_c_iplist_t **dest, dns_c_iplist_t *src,
 		 isc_boolean_t deepcopy)
 {
 	isc_result_t res;
 	
 	if (*dest != NULL) {
-		res = dns_c_iplist_detach(lctx, dest);
+		res = dns_c_iplist_detach(dest);
 		if (res != ISC_R_SUCCESS) {
 			return (res);
 		}
 	}
 	
 	if (deepcopy) {
-		res = dns_c_iplist_copy(lctx, mem, dest, src);
+		res = dns_c_iplist_copy(mem, dest, src);
 	} else {
 		*dest = src;
 		res = ISC_R_SUCCESS;
diff --git a/lib/dns/include/dns/confacl.h b/lib/dns/include/dns/confacl.h
index 406622744b..f901c1f21f 100644
--- a/lib/dns/include/dns/confacl.h
+++ b/lib/dns/include/dns/confacl.h
@@ -110,7 +110,7 @@ struct dns_c_acl_table
  *** Functions
  ***/
 
-isc_result_t	dns_c_acltable_new(isc_log_t *lctx, isc_mem_t *mem,
+isc_result_t	dns_c_acltable_new(isc_mem_t *mem,
 				   dns_c_acltable_t **newtable);
 
 /*
@@ -129,8 +129,7 @@ isc_result_t	dns_c_acltable_new(isc_log_t *lctx, isc_mem_t *mem,
  */
 
 
-isc_result_t	dns_c_acltable_delete(isc_log_t *lctx,
-				      dns_c_acltable_t **table);
+isc_result_t	dns_c_acltable_delete(dns_c_acltable_t **table);
 
 /*
  * Destroys the table pointed to by *TABLE and all the ACLs in it. The
@@ -146,8 +145,7 @@ isc_result_t	dns_c_acltable_delete(isc_log_t *lctx,
  */
 
 
-isc_result_t	dns_c_acltable_getacl(isc_log_t *lctx,
-				      dns_c_acltable_t *table,
+isc_result_t	dns_c_acltable_getacl(dns_c_acltable_t *table,
 				      const char *aclname,
 				      dns_c_acl_t **retval);
 
@@ -164,8 +162,7 @@ isc_result_t	dns_c_acltable_getacl(isc_log_t *lctx,
  * 
  */
 
-isc_result_t	dns_c_acltable_removeacl(isc_log_t *lctx,
-					 dns_c_acltable_t *table,
+isc_result_t	dns_c_acltable_removeacl(dns_c_acltable_t *table,
 					 const char *aclname);
 
 /*
@@ -181,7 +178,7 @@ isc_result_t	dns_c_acltable_removeacl(isc_log_t *lctx,
  * 
  */
 
-void		dns_c_acltable_print(isc_log_t *lctx, FILE *fp, int indent,
+void		dns_c_acltable_print(FILE *fp, int indent,
 				     dns_c_acltable_t *table);
 /*
  * Prints the ACL table and the ACLs in it to the give stdio stream.
@@ -196,7 +193,7 @@ void		dns_c_acltable_print(isc_log_t *lctx, FILE *fp, int indent,
 */
 
 
-isc_result_t	dns_c_acltable_clear(isc_log_t *lctx, dns_c_acltable_t *table);
+isc_result_t	dns_c_acltable_clear(dns_c_acltable_t *table);
 
 /*
  * Deletes all the acls from the table.
@@ -211,7 +208,7 @@ isc_result_t	dns_c_acltable_clear(isc_log_t *lctx, dns_c_acltable_t *table);
 
 
 
-isc_result_t	dns_c_acl_new(isc_log_t *lctx, dns_c_acltable_t *table,
+isc_result_t	dns_c_acl_new(dns_c_acltable_t *table,
 			      const char *aclname,
 			      isc_boolean_t isspecial,
 			      dns_c_acl_t **newacl);
@@ -232,7 +229,7 @@ isc_result_t	dns_c_acl_new(isc_log_t *lctx, dns_c_acltable_t *table,
  */
 
 
-void		dns_c_acl_print(isc_log_t *lctx, FILE *fp, int indent,
+void		dns_c_acl_print(FILE *fp, int indent,
 				dns_c_acl_t *acl);
 /*
  * Prints out the acl to the stdio stream. The outupt is indented by INDENT 
@@ -246,7 +243,7 @@ void		dns_c_acl_print(isc_log_t *lctx, FILE *fp, int indent,
  */
 
 
-isc_result_t	dns_c_acl_setipml(isc_log_t *lctx, dns_c_acl_t *acl,
+isc_result_t	dns_c_acl_setipml(dns_c_acl_t *acl,
 				  dns_c_ipmatchlist_t *ipml,
 				  isc_boolean_t deepcopy);
 
@@ -270,8 +267,7 @@ isc_result_t	dns_c_acl_setipml(isc_log_t *lctx, dns_c_acl_t *acl,
  */
 
 
-isc_result_t	dns_c_acl_getipmlexpanded(isc_log_t *lctx,
-					  isc_mem_t *mem, dns_c_acl_t *acl,
+isc_result_t	dns_c_acl_getipmlexpanded(isc_mem_t *mem, dns_c_acl_t *acl,
 					  dns_c_ipmatchlist_t **retval);
 
 /*
@@ -295,7 +291,7 @@ isc_result_t	dns_c_acl_getipmlexpanded(isc_log_t *lctx,
 
 
 
-isc_result_t dns_c_acl_expandacls(isc_log_t *lctx, dns_c_acltable_t *table,
+isc_result_t dns_c_acl_expandacls(dns_c_acltable_t *table,
 				  dns_c_ipmatchlist_t *list);
 
 /*
diff --git a/lib/dns/include/dns/confcache.h b/lib/dns/include/dns/confcache.h
index 4dea77b513..e02f5ffd79 100644
--- a/lib/dns/include/dns/confcache.h
+++ b/lib/dns/include/dns/confcache.h
@@ -76,8 +76,7 @@ struct dns_c_cache
  *** Functions
  ***/
 
-isc_result_t dns_c_cache_new(isc_log_t *lctx,
-			     isc_mem_t *mem, dns_c_cache_t **cfgres);
+isc_result_t dns_c_cache_new(isc_mem_t *mem, dns_c_cache_t **cfgres);
 /*
  * Creates a new cache-config object.
  *
@@ -91,7 +90,7 @@ isc_result_t dns_c_cache_new(isc_log_t *lctx,
  * 
  */
 
-isc_result_t dns_c_cache_delete(isc_log_t *lctx, dns_c_cache_t **cfgres);
+isc_result_t dns_c_cache_delete(dns_c_cache_t **cfgres);
 /*
  * Deletes the config-cache object and its contents.
  *
diff --git a/lib/dns/include/dns/confcommon.h b/lib/dns/include/dns/confcommon.h
index 7c56f1074c..4bcdb3d3da 100644
--- a/lib/dns/include/dns/confcommon.h
+++ b/lib/dns/include/dns/confcommon.h
@@ -282,29 +282,21 @@ typedef void (*dns_cfg_err_handler_t)(isc_result_t code,
  * dns_c_ordering2string((dns_c_ordering_t)0xffff,ISC_TRUE) returns the
  * value "UNKNOWN_ORDERING"
  */
-const char *		dns_c_ordering2string(isc_log_t *lctx,
-					      dns_c_ordering_t ordering,
+const char *		dns_c_ordering2string(dns_c_ordering_t ordering,
 					      isc_boolean_t printable);
-const char *		dns_c_logseverity2string(isc_log_t *lctx,
-						 dns_c_logseverity_t level,
+const char *		dns_c_logseverity2string(dns_c_logseverity_t level,
 					      isc_boolean_t printable);
-const char *		dns_c_category2string(isc_log_t *lctx,
-					      dns_c_category_t cat,
+const char *		dns_c_category2string(dns_c_category_t cat,
 					      isc_boolean_t printable);
-const char *		dns_c_facility2string(isc_log_t *lctx,
-					      int facility,
+const char *		dns_c_facility2string(int facility,
 					      isc_boolean_t printable);
-const char *		dns_c_transformat2string(isc_log_t *lctx,
-						 dns_transfer_format_t tform,
+const char *		dns_c_transformat2string(dns_transfer_format_t tform,
 						isc_boolean_t printable);
-const char *		dns_c_transport2string(isc_log_t *lctx,
-					       dns_c_trans_t transport,
+const char *		dns_c_transport2string(dns_c_trans_t transport,
 					       isc_boolean_t printable);
-const char *		dns_c_nameseverity2string(isc_log_t *lctx,
-						  dns_c_severity_t severity,
+const char *		dns_c_nameseverity2string(dns_c_severity_t severity,
 						  isc_boolean_t printable);
-const char *		dns_c_forward2string(isc_log_t *lctx,
-					     dns_c_forw_t forw,
+const char *		dns_c_forward2string(dns_c_forw_t forw,
 					     isc_boolean_t printable);
 
 /*
@@ -313,42 +305,30 @@ const char *		dns_c_forward2string(isc_log_t *lctx,
  * through the second argument and ISC_R_SUCCESS is returned. If the string
  * doesn't match a valid value then ISC_R_FAILURE is returned.
  */
-isc_result_t		dns_c_string2ordering(isc_log_t *lctx,
-					      char *name,
+isc_result_t		dns_c_string2ordering(char *name,
 					      dns_c_ordering_t *ordering);
-isc_result_t		dns_c_string2logseverity(isc_log_t *lctx,
-						 const char *string,
+isc_result_t		dns_c_string2logseverity(const char *string,
 					      dns_c_logseverity_t *result);
-isc_result_t		dns_c_string2category(isc_log_t *lctx,
-					      const char *string,
+isc_result_t		dns_c_string2category(const char *string,
 					      dns_c_category_t *category);
-isc_result_t		dns_c_string2facility(isc_log_t *lctx,
-					      const char *string, int *res);
+isc_result_t		dns_c_string2facility(const char *string, int *res);
 
 
 
-int			dns_c_isanyaddr(isc_log_t *lctx,
-					isc_sockaddr_t *inaddr);
-void 			dns_c_print_ipaddr(isc_log_t *lctx,
-					   FILE *fp, isc_sockaddr_t *addr);
-isc_boolean_t		dns_c_need_quote(isc_log_t *lctx,
-					 const char *string);
+int			dns_c_isanyaddr(isc_sockaddr_t *inaddr);
+void 			dns_c_print_ipaddr(FILE *fp, isc_sockaddr_t *addr);
+isc_boolean_t		dns_c_need_quote(const char *string);
 
-void			dns_c_printtabs(isc_log_t *lctx,
-					FILE *fp, int count); 
-void			dns_c_printinunits(isc_log_t *lctx,
-					   FILE *fp, isc_uint32_t val);
+void			dns_c_printtabs(FILE *fp, int count); 
+void			dns_c_printinunits(FILE *fp, isc_uint32_t val);
 
-void			dns_c_dataclass_tostream(isc_log_t *lctx,
-						 FILE *fp,
+void			dns_c_dataclass_tostream(FILE *fp,
 						 dns_rdataclass_t rclass);
-void			dns_c_datatype_tostream(isc_log_t *lctx,
-						FILE *fp,
+void			dns_c_datatype_tostream(FILE *fp,
 						dns_rdatatype_t rtype);
 
 #if 0					/* XXXJAB remove this */
-dns_cfg_err_handler_t	dns_c_seterrorhandler(isc_log_t *lctx,
-					      dns_cfg_err_handler_t
+dns_cfg_err_handler_t	dns_c_seterrorhandler(dns_cfg_err_handler_t
 						newhandler);
 void	 		dns_c_error(isc_result_t result, const char *fmt, ...);
 #endif
diff --git a/lib/dns/include/dns/confctl.h b/lib/dns/include/dns/confctl.h
index c025e11928..e9dd2c83bd 100644
--- a/lib/dns/include/dns/confctl.h
+++ b/lib/dns/include/dns/confctl.h
@@ -121,8 +121,7 @@ struct dns_c_ctrl_list
  ***/
 
 
-isc_result_t	dns_c_ctrlinet_new(isc_log_t *lctx,
-				   isc_mem_t *mem, dns_c_ctrl_t **control,
+isc_result_t	dns_c_ctrlinet_new(isc_mem_t *mem, dns_c_ctrl_t **control,
 				   isc_sockaddr_t addr, short port,
 				   dns_c_ipmatchlist_t *iml,
 				   isc_boolean_t copy);
@@ -141,8 +140,7 @@ isc_result_t	dns_c_ctrlinet_new(isc_log_t *lctx,
  */
 
 
-isc_result_t	dns_c_ctrlunix_new(isc_log_t *lctx,
-				   isc_mem_t *mem, dns_c_ctrl_t **control,
+isc_result_t	dns_c_ctrlunix_new(isc_mem_t *mem, dns_c_ctrl_t **control,
 				   const char *path,
 				   int perm, uid_t uid, gid_t gid);
 /*
@@ -159,8 +157,7 @@ isc_result_t	dns_c_ctrlunix_new(isc_log_t *lctx,
  */
 
 
-isc_result_t	dns_c_ctrl_delete(isc_log_t *lctx,
-				  dns_c_ctrl_t **control);
+isc_result_t	dns_c_ctrl_delete(dns_c_ctrl_t **control);
 /*
  * Deletes the object pointed to by *CONTROL. *CONTROL may be NULL.
  *
@@ -172,8 +169,7 @@ isc_result_t	dns_c_ctrl_delete(isc_log_t *lctx,
  */
 
 
-void		dns_c_ctrl_print(isc_log_t *lctx,
-				 FILE *fp, int indent, dns_c_ctrl_t *ctl);
+void		dns_c_ctrl_print(FILE *fp, int indent, dns_c_ctrl_t *ctl);
 /*
  * Prints the control object ctl in standard named.conf format. The output
  * is indented by indent number of tabs.
@@ -185,8 +181,7 @@ void		dns_c_ctrl_print(isc_log_t *lctx,
  */
 
 
-isc_result_t	dns_c_ctrllist_new(isc_log_t *lctx,
-				   isc_mem_t *mem, dns_c_ctrllist_t **newlist);
+isc_result_t	dns_c_ctrllist_new(isc_mem_t *mem, dns_c_ctrllist_t **newlist);
 /*
  * Creates a new control object list using the MEM memory manager.
  *
@@ -200,8 +195,7 @@ isc_result_t	dns_c_ctrllist_new(isc_log_t *lctx,
  */
 
 
-isc_result_t	dns_c_ctrllist_delete(isc_log_t *lctx,
-				      dns_c_ctrllist_t **list);
+isc_result_t	dns_c_ctrllist_delete(dns_c_ctrllist_t **list);
 /*
  * Deletes the control list. The value of *list may be NULL. Sets *list to
  * NULL when done.
@@ -214,7 +208,7 @@ isc_result_t	dns_c_ctrllist_delete(isc_log_t *lctx,
  *
  */
 
-void		dns_c_ctrllist_print(isc_log_t *lctx, FILE *fp, int indent,
+void		dns_c_ctrllist_print(FILE *fp, int indent,
 				     dns_c_ctrllist_t *cl);
 /*
  * Prints the control objects inside the list. The output is indented with
diff --git a/lib/dns/include/dns/confctx.h b/lib/dns/include/dns/confctx.h
index 038d3a72f8..bffb4e72ba 100644
--- a/lib/dns/include/dns/confctx.h
+++ b/lib/dns/include/dns/confctx.h
@@ -209,77 +209,56 @@ struct dns_c_options
  ***/
 
 
-isc_result_t	dns_c_ctx_new(isc_log_t *lctx,
-			      isc_mem_t *mem, dns_c_ctx_t **cfg);
-isc_result_t	dns_c_ctx_delete(isc_log_t *lctx,
-				 dns_c_ctx_t **cfg);
+isc_result_t	dns_c_ctx_new(isc_mem_t *mem, dns_c_ctx_t **cfg);
+isc_result_t	dns_c_ctx_delete(dns_c_ctx_t **cfg);
 
-void		dns_c_ctx_print(isc_log_t *lctx,
-				FILE *fp, int indent, dns_c_ctx_t *cfg);
-void		dns_c_ctx_optionsprint(isc_log_t *lctx,
-				       FILE *fp, int indent,
+void		dns_c_ctx_print(FILE *fp, int indent, dns_c_ctx_t *cfg);
+void		dns_c_ctx_optionsprint(FILE *fp, int indent,
 				       dns_c_options_t *options);
-void		dns_c_ctx_forwarderprint(isc_log_t *lctx,
-					 FILE *fp, int indent,
+void		dns_c_ctx_forwarderprint(FILE *fp, int indent,
 					 dns_c_options_t *options);
 
 
-isc_result_t	dns_c_ctx_getoptions(isc_log_t *lctx,
-				     dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_getoptions(dns_c_ctx_t *cfg,
 				     dns_c_options_t **options);
 
-isc_result_t	dns_c_ctx_setlogging(isc_log_t *lctx,
-				     dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_setlogging(dns_c_ctx_t *cfg,
 				     dns_c_logginglist_t *newval,
 				     isc_boolean_t deepcopy);
-isc_result_t	dns_c_ctx_getlogging(isc_log_t *lctx,
-				     dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_getlogging(dns_c_ctx_t *cfg,
 				     dns_c_logginglist_t **retval);
 
-isc_result_t	dns_c_ctx_getkdeflist(isc_log_t *lctx,
-                                      dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_getkdeflist(dns_c_ctx_t *cfg,
                                       dns_c_kdeflist_t **retval);
-isc_result_t	dns_c_ctx_setkdeflist(isc_log_t *lctx,
-                                      dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_setkdeflist(dns_c_ctx_t *cfg,
                                       dns_c_kdeflist_t *newval,
                                       isc_boolean_t deepcopy);
 
 
-isc_result_t	dns_c_ctx_addfile_channel(isc_log_t *lctx,
-					  dns_c_ctx_t *cfg, const char *name,
+isc_result_t	dns_c_ctx_addfile_channel(dns_c_ctx_t *cfg, const char *name,
 					  dns_c_logchan_t **chan);
-isc_result_t	dns_c_ctx_addsyslogchannel(isc_log_t *lctx,
-					   dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_addsyslogchannel(dns_c_ctx_t *cfg,
 					   const char *name,
 					   dns_c_logchan_t **chan);
-isc_result_t	dns_c_ctx_addnullchannel(isc_log_t *lctx,
-					 dns_c_ctx_t *cfg, const char *name,
+isc_result_t	dns_c_ctx_addnullchannel(dns_c_ctx_t *cfg, const char *name,
 					 dns_c_logchan_t **chan);
-isc_result_t	dns_c_ctx_addcategory(isc_log_t *lctx,
-				      dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_addcategory(dns_c_ctx_t *cfg,
 				      dns_c_category_t category,
 				      dns_c_logcat_t **newcat);
-isc_result_t	dns_c_ctx_currchannel(isc_log_t *lctx,
-				      dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_currchannel(dns_c_ctx_t *cfg,
 				      dns_c_logchan_t **channel);
-isc_result_t	dns_c_ctx_currcategory(isc_log_t *lctx,
-				       dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_currcategory(dns_c_ctx_t *cfg,
 				       dns_c_logcat_t **category);
-isc_boolean_t	dns_c_ctx_keydefinedp(isc_log_t *lctx,
-				      dns_c_ctx_t *ctx, const char *keyname);
+isc_boolean_t	dns_c_ctx_keydefinedp(dns_c_ctx_t *ctx, const char *keyname);
 
 
 
-isc_boolean_t	dns_c_ctx_channeldefinedp(isc_log_t *lctx,
-					  dns_c_ctx_t *cfg,
+isc_boolean_t	dns_c_ctx_channeldefinedp(dns_c_ctx_t *cfg,
 					  const char *name);
-isc_result_t	dns_c_ctx_optionsnew(isc_log_t *lctx,
-				     isc_mem_t *mem,
+isc_result_t	dns_c_ctx_optionsnew(isc_mem_t *mem,
 				     dns_c_options_t **options);
-isc_result_t	dns_c_ctx_optionsdelete(isc_log_t *lctx,
-					dns_c_options_t **options);
-isc_result_t	dns_c_ctx_erase_options(isc_log_t *lctx,
-					dns_c_ctx_t *cfg);
+isc_result_t	dns_c_ctx_optionsdelete(dns_c_options_t **options);
+isc_result_t	dns_c_ctx_erase_options(dns_c_ctx_t *cfg);
 
 
 
@@ -295,160 +274,108 @@ isc_result_t	dns_c_ctx_erase_options(isc_log_t *lctx,
  * functions.
  *
  */
-isc_result_t	dns_c_ctx_setcurrzone(isc_log_t *lctx,
-				      dns_c_ctx_t *cfg, dns_c_zone_t *zone);
-isc_result_t	dns_c_ctx_setcurrview(isc_log_t *lctx,
-				      dns_c_ctx_t *cfg, dns_c_view_t *view);
-isc_result_t	dns_c_ctx_setdirectory(isc_log_t *lctx,
-				       dns_c_ctx_t *cfg, const char *newval);
-isc_result_t	dns_c_ctx_setversion(isc_log_t *lctx,
-				     dns_c_ctx_t *cfg, const char *newval);
-isc_result_t	dns_c_ctx_setdumpfilename(isc_log_t *lctx,
-					  dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_setcurrzone(dns_c_ctx_t *cfg, dns_c_zone_t *zone);
+isc_result_t	dns_c_ctx_setcurrview(dns_c_ctx_t *cfg, dns_c_view_t *view);
+isc_result_t	dns_c_ctx_setdirectory(dns_c_ctx_t *cfg, const char *newval);
+isc_result_t	dns_c_ctx_setversion(dns_c_ctx_t *cfg, const char *newval);
+isc_result_t	dns_c_ctx_setdumpfilename(dns_c_ctx_t *cfg,
 					  const char *newval);
-isc_result_t	dns_c_ctx_setpidfilename(isc_log_t *lctx,
-					 dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_setpidfilename(dns_c_ctx_t *cfg,
 					 const char *newval);
-isc_result_t	dns_c_ctx_setstatsfilename(isc_log_t *lctx,
-					   dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_setstatsfilename(dns_c_ctx_t *cfg,
 					   const char *newval);
-isc_result_t	dns_c_ctx_setmemstatsfilename(isc_log_t *lctx,
-					      dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_setmemstatsfilename(dns_c_ctx_t *cfg,
 					      const char *newval);
-isc_result_t	dns_c_ctx_setnamedxfer(isc_log_t *lctx,
-				       dns_c_ctx_t *cfg, const char *newval);
-isc_result_t	dns_c_ctx_settkeydomain(isc_log_t *lctx,
-					dns_c_ctx_t *cfg, const char *newval);
-isc_result_t	dns_c_ctx_settkeydhkey(isc_log_t *lctx, dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_setnamedxfer(dns_c_ctx_t *cfg, const char *newval);
+isc_result_t	dns_c_ctx_settkeydomain(dns_c_ctx_t *cfg, const char *newval);
+isc_result_t	dns_c_ctx_settkeydhkey(dns_c_ctx_t *cfg,
 				       const char *newcpval,
 				       isc_int32_t newival);
-isc_result_t	dns_c_ctx_setmaxncachettl(isc_log_t *lctx,
-					  dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_setmaxncachettl(dns_c_ctx_t *cfg,
 					  isc_uint32_t newval);
-isc_result_t	dns_c_ctx_settransfersin(isc_log_t *lctx,
-					 dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_settransfersin(dns_c_ctx_t *cfg,
 					 isc_int32_t newval);
-isc_result_t	dns_c_ctx_settransfersperns(isc_log_t *lctx,
-					    dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_settransfersperns(dns_c_ctx_t *cfg,
 					    isc_int32_t newval);
-isc_result_t	dns_c_ctx_settransfersout(isc_log_t *lctx,
-					  dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_settransfersout(dns_c_ctx_t *cfg,
 					  isc_int32_t newval);
-isc_result_t	dns_c_ctx_setmaxlogsizeixfr(isc_log_t *lctx,
-					    dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_setmaxlogsizeixfr(dns_c_ctx_t *cfg,
 					    isc_int32_t newval);
-isc_result_t	dns_c_ctx_setcleaninterval(isc_log_t *lctx,
-					   dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_setcleaninterval(dns_c_ctx_t *cfg,
 					   isc_int32_t newval);
-isc_result_t	dns_c_ctx_setinterfaceinterval(isc_log_t *lctx,
-					       dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_setinterfaceinterval(dns_c_ctx_t *cfg,
 					       isc_int32_t newval);
-isc_result_t	dns_c_ctx_setstatsinterval(isc_log_t *lctx,
-					   dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_setstatsinterval(dns_c_ctx_t *cfg,
 					   isc_int32_t newval);
-isc_result_t	dns_c_ctx_setheartbeat_interval(isc_log_t *lctx,
-						dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_setheartbeat_interval(dns_c_ctx_t *cfg,
 						isc_int32_t newval);
-isc_result_t	dns_c_ctx_setmaxtransfertimein(isc_log_t *lctx,
-					       dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_setmaxtransfertimein(dns_c_ctx_t *cfg,
 					       isc_int32_t newval);
-isc_result_t	dns_c_ctx_setdatasize(isc_log_t *lctx,
-				      dns_c_ctx_t *cfg, isc_uint32_t newval);
-isc_result_t	dns_c_ctx_setstacksize(isc_log_t *lctx,
-				       dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_setdatasize(dns_c_ctx_t *cfg, isc_uint32_t newval);
+isc_result_t	dns_c_ctx_setstacksize(dns_c_ctx_t *cfg,
 				       isc_uint32_t newval);
-isc_result_t	dns_c_ctx_setcoresize(isc_log_t *lctx,
-				      dns_c_ctx_t *cfg, isc_uint32_t newval);
-isc_result_t	dns_c_ctx_setfiles(isc_log_t *lctx,
-				   dns_c_ctx_t *cfg, isc_uint32_t newval);
+isc_result_t	dns_c_ctx_setcoresize(dns_c_ctx_t *cfg, isc_uint32_t newval);
+isc_result_t	dns_c_ctx_setfiles(dns_c_ctx_t *cfg, isc_uint32_t newval);
 
-isc_result_t	dns_c_ctx_setexpertmode(isc_log_t *lctx,
-					dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_setexpertmode(dns_c_ctx_t *cfg,
 					isc_boolean_t newval);
-isc_result_t	dns_c_ctx_setfakeiquery(isc_log_t *lctx,
-					dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_setfakeiquery(dns_c_ctx_t *cfg,
 					isc_boolean_t newval);
-isc_result_t	dns_c_ctx_setrecursion(isc_log_t *lctx,
-				       dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_setrecursion(dns_c_ctx_t *cfg,
 				       isc_boolean_t newval);
-isc_result_t	dns_c_ctx_setfetchglue(isc_log_t *lctx,
-				       dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_setfetchglue(dns_c_ctx_t *cfg,
 				       isc_boolean_t newval);
-isc_result_t	dns_c_ctx_setnotify(isc_log_t *lctx,
-				    dns_c_ctx_t *cfg, isc_boolean_t newval);
-isc_result_t	dns_c_ctx_sethoststatistics(isc_log_t *lctx,
-					    dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_setnotify(dns_c_ctx_t *cfg, isc_boolean_t newval);
+isc_result_t	dns_c_ctx_sethoststatistics(dns_c_ctx_t *cfg,
 					    isc_boolean_t newval);
-isc_result_t	dns_c_ctx_setdealloconexit(isc_log_t *lctx,
-					   dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_setdealloconexit(dns_c_ctx_t *cfg,
 					   isc_boolean_t newval);
-isc_result_t	dns_c_ctx_setuseixfr(isc_log_t *lctx,
-				     dns_c_ctx_t *cfg, isc_boolean_t newval);
-isc_result_t	dns_c_ctx_setmaintainixfrbase(isc_log_t *lctx,
-					      dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_setuseixfr(dns_c_ctx_t *cfg, isc_boolean_t newval);
+isc_result_t	dns_c_ctx_setmaintainixfrbase(dns_c_ctx_t *cfg,
 					      isc_boolean_t newval);
-isc_result_t	dns_c_ctx_sethasoldclients(isc_log_t *lctx,
-					   dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_sethasoldclients(dns_c_ctx_t *cfg,
 					   isc_boolean_t newval);
-isc_result_t	dns_c_ctx_setauthnxdomain(isc_log_t *lctx,
-					  dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_setauthnxdomain(dns_c_ctx_t *cfg,
 					  isc_boolean_t newval);
-isc_result_t	dns_c_ctx_setmultiplecnames(isc_log_t *lctx,
-					    dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_setmultiplecnames(dns_c_ctx_t *cfg,
 					    isc_boolean_t newval);
-isc_result_t	dns_c_ctx_setuseidpool(isc_log_t *lctx,
-				       dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_setuseidpool(dns_c_ctx_t *cfg,
 				       isc_boolean_t newval);
-isc_result_t	dns_c_ctx_setrfc2308type1(isc_log_t *lctx,
-					  dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_setrfc2308type1(dns_c_ctx_t *cfg,
 					  isc_boolean_t newval);
-isc_result_t	dns_c_ctx_setdialup(isc_log_t *lctx,
-				    dns_c_ctx_t *cfg, isc_boolean_t newval);
-isc_result_t	dns_c_ctx_setquerysourceaddr(isc_log_t *lctx,
-					     dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_setdialup(dns_c_ctx_t *cfg, isc_boolean_t newval);
+isc_result_t	dns_c_ctx_setquerysourceaddr(dns_c_ctx_t *cfg,
 					     isc_sockaddr_t addr);
-isc_result_t	dns_c_ctx_setquerysourceport(isc_log_t *lctx,
-					     dns_c_ctx_t *cfg, short port);
-isc_result_t	dns_c_ctx_setchecknames(isc_log_t *lctx,
-					dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_setquerysourceport(dns_c_ctx_t *cfg, short port);
+isc_result_t	dns_c_ctx_setchecknames(dns_c_ctx_t *cfg,
 					dns_c_trans_t transtype,
 					dns_c_severity_t sever);
-isc_result_t	dns_c_ctx_settransferformat(isc_log_t *lctx,
-					    dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_settransferformat(dns_c_ctx_t *cfg,
 					    dns_transfer_format_t newval);
-isc_result_t	dns_c_ctx_setqueryacl(isc_log_t *lctx,
-				      dns_c_ctx_t *cfg, isc_boolean_t copy,
+isc_result_t	dns_c_ctx_setqueryacl(dns_c_ctx_t *cfg, isc_boolean_t copy,
 				      dns_c_ipmatchlist_t *iml);
-isc_result_t	dns_c_ctx_settransferacl(isc_log_t *lctx,
-					 dns_c_ctx_t *cfg, isc_boolean_t copy,
+isc_result_t	dns_c_ctx_settransferacl(dns_c_ctx_t *cfg, isc_boolean_t copy,
 					 dns_c_ipmatchlist_t *iml);
-isc_result_t	dns_c_ctx_setrecursionacl(isc_log_t *lctx,
-					  dns_c_ctx_t *cfg, isc_boolean_t copy,
+isc_result_t	dns_c_ctx_setrecursionacl(dns_c_ctx_t *cfg, isc_boolean_t copy,
 					  dns_c_ipmatchlist_t *iml);
-isc_result_t	dns_c_ctx_setblackhole(isc_log_t *lctx,
-				       dns_c_ctx_t *cfg, isc_boolean_t copy,
+isc_result_t	dns_c_ctx_setblackhole(dns_c_ctx_t *cfg, isc_boolean_t copy,
 				       dns_c_ipmatchlist_t *iml);
-isc_result_t	dns_c_ctx_settopology(isc_log_t *lctx,
-				      dns_c_ctx_t *cfg, isc_boolean_t copy,
+isc_result_t	dns_c_ctx_settopology(dns_c_ctx_t *cfg, isc_boolean_t copy,
 				      dns_c_ipmatchlist_t *iml);
-isc_result_t	dns_c_ctx_setsortlist(isc_log_t *lctx,
-				      dns_c_ctx_t *cfg, isc_boolean_t copy,
+isc_result_t	dns_c_ctx_setsortlist(dns_c_ctx_t *cfg, isc_boolean_t copy,
 				      dns_c_ipmatchlist_t *iml);
-isc_result_t	dns_c_ctx_setforward(isc_log_t *lctx,
-				     dns_c_ctx_t *cfg, dns_c_forw_t forw);
-isc_result_t	dns_c_ctx_setforwarders(isc_log_t *lctx, dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_setforward(dns_c_ctx_t *cfg, dns_c_forw_t forw);
+isc_result_t	dns_c_ctx_setforwarders(dns_c_ctx_t *cfg,
 					dns_c_ipmatchlist_t *iml,
 					isc_boolean_t copy);
-isc_result_t	dns_c_ctx_setrrsetorderlist(isc_log_t *lctx, dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_setrrsetorderlist(dns_c_ctx_t *cfg,
 					    isc_boolean_t copy,
 					    dns_c_rrsolist_t *olist);
 
-isc_result_t	dns_c_ctx_addlisten_on(isc_log_t *lctx,
-				       dns_c_ctx_t *cfg, int port,
+isc_result_t	dns_c_ctx_addlisten_on(dns_c_ctx_t *cfg, int port,
 				       dns_c_ipmatchlist_t *ml,
 				       isc_boolean_t copy);
-isc_result_t	dns_c_ctx_settrustedkeys(isc_log_t *lctx,
-					 dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_settrustedkeys(dns_c_ctx_t *cfg,
 					 dns_c_tkeylist_t *list,
 					 isc_boolean_t copy);
 
@@ -472,121 +399,105 @@ isc_result_t	dns_c_ctx_settrustedkeys(isc_log_t *lctx,
  */
 
 
-dns_c_zone_t   *dns_c_ctx_getcurrzone(isc_log_t *lctx, dns_c_ctx_t *cfg);
-dns_c_view_t   *dns_c_ctx_getcurrview(isc_log_t *lctx, dns_c_ctx_t *cfg);
-isc_result_t	dns_c_ctx_getdirectory(isc_log_t *lctx,
-				       dns_c_ctx_t *cfg, char **retval);
-isc_result_t	dns_c_ctx_getversion(isc_log_t *lctx,
-				     dns_c_ctx_t *cfg, char **retval);
-isc_result_t	dns_c_ctx_getdumpfilename(isc_log_t *lctx,
-					  dns_c_ctx_t *cfg, char **retval);
-isc_result_t	dns_c_ctx_getpidfilename(isc_log_t *lctx,
-					 dns_c_ctx_t *cfg, char **retval);
-isc_result_t	dns_c_ctx_getstatsfilename(isc_log_t *lctx,
-					   dns_c_ctx_t *cfg, char **retval);
-isc_result_t	dns_c_ctx_getmemstatsfilename(isc_log_t *lctx,
-					      dns_c_ctx_t *cfg,
+dns_c_zone_t   *dns_c_ctx_getcurrzone(dns_c_ctx_t *cfg);
+dns_c_view_t   *dns_c_ctx_getcurrview(dns_c_ctx_t *cfg);
+isc_result_t	dns_c_ctx_getdirectory(dns_c_ctx_t *cfg, char **retval);
+isc_result_t	dns_c_ctx_getversion(dns_c_ctx_t *cfg, char **retval);
+isc_result_t	dns_c_ctx_getdumpfilename(dns_c_ctx_t *cfg, char **retval);
+isc_result_t	dns_c_ctx_getpidfilename(dns_c_ctx_t *cfg, char **retval);
+isc_result_t	dns_c_ctx_getstatsfilename(dns_c_ctx_t *cfg, char **retval);
+isc_result_t	dns_c_ctx_getmemstatsfilename(dns_c_ctx_t *cfg,
 					      char **retval);
-isc_result_t	dns_c_ctx_getnamedxfer(isc_log_t *lctx,
-				       dns_c_ctx_t *cfg, char **retval);
-isc_result_t	dns_c_ctx_gettkeydomain(isc_log_t *lctx,
-				       dns_c_ctx_t *cfg, char **retval);
-isc_result_t	dns_c_ctx_gettkeydhkey(isc_log_t *lctx, dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_getnamedxfer(dns_c_ctx_t *cfg, char **retval);
+isc_result_t	dns_c_ctx_gettkeydomain(dns_c_ctx_t *cfg, char **retval);
+isc_result_t	dns_c_ctx_gettkeydhkey(dns_c_ctx_t *cfg,
 				       char **retcpval, isc_int32_t *retival);
-isc_result_t	dns_c_ctx_getmaxncachettl(isc_log_t *lctx, dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_getmaxncachettl(dns_c_ctx_t *cfg,
 					  isc_uint32_t *retval);
-isc_result_t	dns_c_ctx_gettransfersin(isc_log_t *lctx, dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_gettransfersin(dns_c_ctx_t *cfg,
 					 isc_int32_t *retval);
-isc_result_t	dns_c_ctx_gettransfersperns(isc_log_t *lctx, dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_gettransfersperns(dns_c_ctx_t *cfg,
 					    isc_int32_t *retval);
-isc_result_t	dns_c_ctx_gettransfersout(isc_log_t *lctx, dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_gettransfersout(dns_c_ctx_t *cfg,
 					  isc_int32_t *retval);
-isc_result_t	dns_c_ctx_getmaxlogsizeixfr(isc_log_t *lctx, dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_getmaxlogsizeixfr(dns_c_ctx_t *cfg,
 					    isc_int32_t *retval);
-isc_result_t	dns_c_ctx_getcleaninterval(isc_log_t *lctx, dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_getcleaninterval(dns_c_ctx_t *cfg,
 					   isc_int32_t *retval);
-isc_result_t	dns_c_ctx_getinterfaceinterval(isc_log_t *lctx,
-					       dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_getinterfaceinterval(dns_c_ctx_t *cfg,
 					       isc_int32_t *retval);
-isc_result_t	dns_c_ctx_getstatsinterval(isc_log_t *lctx, dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_getstatsinterval(dns_c_ctx_t *cfg,
 					   isc_int32_t *retval);
-isc_result_t	dns_c_ctx_getheartbeatinterval(isc_log_t *lctx,
-					       dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_getheartbeatinterval(dns_c_ctx_t *cfg,
 					       isc_int32_t *retval);
-isc_result_t	dns_c_ctx_getmaxtransfertimein(isc_log_t *lctx,
-					       dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_getmaxtransfertimein(dns_c_ctx_t *cfg,
 					       isc_int32_t *retval);
-isc_result_t	dns_c_ctx_getdatasize(isc_log_t *lctx, dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_getdatasize(dns_c_ctx_t *cfg,
 				      isc_uint32_t *retval);
-isc_result_t	dns_c_ctx_getstacksize(isc_log_t *lctx, dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_getstacksize(dns_c_ctx_t *cfg,
 				       isc_uint32_t *retval);
-isc_result_t	dns_c_ctx_getcoresize(isc_log_t *lctx, dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_getcoresize(dns_c_ctx_t *cfg,
 				      isc_uint32_t *retval);
-isc_result_t	dns_c_ctx_getfiles(isc_log_t *lctx,
-				   dns_c_ctx_t *cfg, isc_uint32_t *retval);
-isc_result_t	dns_c_ctx_get_expert_mode(isc_log_t *lctx, dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_getfiles(dns_c_ctx_t *cfg, isc_uint32_t *retval);
+isc_result_t	dns_c_ctx_get_expert_mode(dns_c_ctx_t *cfg,
 					  isc_boolean_t *retval);
-isc_result_t	dns_c_ctx_getfakeiquery(isc_log_t *lctx, dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_getfakeiquery(dns_c_ctx_t *cfg,
 					isc_boolean_t *retval);
-isc_result_t	dns_c_ctx_getrecursion(isc_log_t *lctx, dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_getrecursion(dns_c_ctx_t *cfg,
 				       isc_boolean_t *retval);
-isc_result_t	dns_c_ctx_getfetchglue(isc_log_t *lctx, dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_getfetchglue(dns_c_ctx_t *cfg,
 				       isc_boolean_t *retval);
-isc_result_t	dns_c_ctx_getnotify(isc_log_t *lctx,
-				    dns_c_ctx_t *cfg, isc_boolean_t *retval);
-isc_result_t	dns_c_ctx_gethoststatistics(isc_log_t *lctx, dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_getnotify(dns_c_ctx_t *cfg, isc_boolean_t *retval);
+isc_result_t	dns_c_ctx_gethoststatistics(dns_c_ctx_t *cfg,
 					    isc_boolean_t *retval);
-isc_result_t	dns_c_ctx_getdealloconexit(isc_log_t *lctx, dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_getdealloconexit(dns_c_ctx_t *cfg,
 					   isc_boolean_t *retval);
-isc_result_t	dns_c_ctx_getuseixfr(isc_log_t *lctx, dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_getuseixfr(dns_c_ctx_t *cfg,
 				     isc_boolean_t *retval);
-isc_result_t	dns_c_ctx_getmaintainixfrbase(isc_log_t *lctx,
-					      dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_getmaintainixfrbase(dns_c_ctx_t *cfg,
 					      isc_boolean_t *retval);
-isc_result_t	dns_c_ctx_gethasoldclients(isc_log_t *lctx, dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_gethasoldclients(dns_c_ctx_t *cfg,
 					   isc_boolean_t *retval);
-isc_result_t	dns_c_ctx_getauth_nx_domain(isc_log_t *lctx, dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_getauth_nx_domain(dns_c_ctx_t *cfg,
 					    isc_boolean_t *retval);
-isc_result_t	dns_c_ctx_getmultiplecnames(isc_log_t *lctx, dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_getmultiplecnames(dns_c_ctx_t *cfg,
 					    isc_boolean_t *retval);
-isc_result_t	dns_c_ctx_getuseidpool(isc_log_t *lctx, dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_getuseidpool(dns_c_ctx_t *cfg,
 				       isc_boolean_t *retval);
-isc_result_t	dns_c_ctx_getrfc2308type1(isc_log_t *lctx, dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_getrfc2308type1(dns_c_ctx_t *cfg,
 					  isc_boolean_t *retval);
-isc_result_t	dns_c_ctx_getdialup(isc_log_t *lctx,
-				    dns_c_ctx_t *cfg, isc_boolean_t *retval);
-isc_result_t	dns_c_ctx_getquerysourceaddr(isc_log_t *lctx, dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_getdialup(dns_c_ctx_t *cfg, isc_boolean_t *retval);
+isc_result_t	dns_c_ctx_getquerysourceaddr(dns_c_ctx_t *cfg,
 					     isc_sockaddr_t *addr);
-isc_result_t	dns_c_ctx_getquerysourceport(isc_log_t *lctx, dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_getquerysourceport(dns_c_ctx_t *cfg,
 					     short *port);
-isc_result_t	dns_c_ctx_getchecknames(isc_log_t *lctx, dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_getchecknames(dns_c_ctx_t *cfg,
 					dns_c_trans_t transtype,
 					dns_c_severity_t *sever);
-isc_result_t	dns_c_ctx_gettransferformat(isc_log_t *lctx, dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_gettransferformat(dns_c_ctx_t *cfg,
 					    dns_transfer_format_t *retval);
-isc_result_t	dns_c_ctx_getqueryacl(isc_log_t *lctx, dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_getqueryacl(dns_c_ctx_t *cfg,
 				      dns_c_ipmatchlist_t **list);
-isc_result_t	dns_c_ctx_gettransferacl(isc_log_t *lctx, dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_gettransferacl(dns_c_ctx_t *cfg,
 					 dns_c_ipmatchlist_t **list);
-isc_result_t	dns_c_ctx_getrecursionacl(isc_log_t *lctx, dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_getrecursionacl(dns_c_ctx_t *cfg,
 					  dns_c_ipmatchlist_t **list);
-isc_result_t	dns_c_ctx_getblackhole(isc_log_t *lctx, dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_getblackhole(dns_c_ctx_t *cfg,
 				       dns_c_ipmatchlist_t **list);
-isc_result_t	dns_c_ctx_gettopology(isc_log_t *lctx, dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_gettopology(dns_c_ctx_t *cfg,
 				      dns_c_ipmatchlist_t **list);
-isc_result_t	dns_c_ctx_getsortlist(isc_log_t *lctx, dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_getsortlist(dns_c_ctx_t *cfg,
 				      dns_c_ipmatchlist_t **list);
-isc_result_t	dns_c_ctx_getlistenlist(isc_log_t *lctx, dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_getlistenlist(dns_c_ctx_t *cfg,
 					dns_c_lstnlist_t **ll);
-isc_result_t	dns_c_ctx_getforward(isc_log_t *lctx,
-				     dns_c_ctx_t *cfg, dns_c_forw_t *forw);
-isc_result_t	dns_c_ctx_getforwarders(isc_log_t *lctx, dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_getforward(dns_c_ctx_t *cfg, dns_c_forw_t *forw);
+isc_result_t	dns_c_ctx_getforwarders(dns_c_ctx_t *cfg,
 					dns_c_ipmatchlist_t **list);
-isc_result_t	dns_c_ctx_getrrsetorderlist(isc_log_t *lctx, dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_getrrsetorderlist(dns_c_ctx_t *cfg,
 					    dns_c_rrsolist_t **olist);
-isc_result_t	dns_c_ctx_gettrustedkeys(isc_log_t *lctx, dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_gettrustedkeys(dns_c_ctx_t *cfg,
 					 dns_c_tkeylist_t **retval);
-isc_result_t	dns_c_ctx_getlogging(isc_log_t *lctx, dns_c_ctx_t *cfg,
+isc_result_t	dns_c_ctx_getlogging(dns_c_ctx_t *cfg,
 				     dns_c_logginglist_t **retval);
 
 
diff --git a/lib/dns/include/dns/confip.h b/lib/dns/include/dns/confip.h
index 2d6bdc2e18..10426f1d43 100644
--- a/lib/dns/include/dns/confip.h
+++ b/lib/dns/include/dns/confip.h
@@ -163,92 +163,66 @@ struct dns_c_ipmatch_list
  */
 
 
-isc_result_t	dns_c_ipmatchelement_new(isc_log_t *lctx,
-					 isc_mem_t *mem,
+isc_result_t	dns_c_ipmatchelement_new(isc_mem_t *mem,
 					 dns_c_ipmatchelement_t **result);
-isc_result_t	dns_c_ipmatchelement_delete(isc_log_t *lctx,
-					    isc_mem_t *mem,
+isc_result_t	dns_c_ipmatchelement_delete(isc_mem_t *mem,
 					    dns_c_ipmatchelement_t **ipme);
-isc_result_t	dns_c_ipmatchelement_copy(isc_log_t *lctx,
-					  isc_mem_t *mem,
+isc_result_t	dns_c_ipmatchelement_copy(isc_mem_t *mem,
 					  dns_c_ipmatchelement_t **dest,
 					  dns_c_ipmatchelement_t *src);
-isc_result_t	dns_c_ipmatchelement_print(isc_log_t *lctx,
-					   FILE *fp, int indent,
+isc_result_t	dns_c_ipmatchelement_print(FILE *fp, int indent,
 					   dns_c_ipmatchelement_t *ime);
-isc_boolean_t	dns_c_ipmatchelement_isneg(isc_log_t *lctx,
-					   dns_c_ipmatchelement_t *elem);
+isc_boolean_t	dns_c_ipmatchelement_isneg(dns_c_ipmatchelement_t *elem);
 
-isc_result_t	dns_c_ipmatch_negate(isc_log_t *lctx,
-				     dns_c_ipmatchelement_t *ipe);
-isc_result_t	dns_c_ipmatch_aclnew(isc_log_t *lctx,
-				     isc_mem_t *mem,
+isc_result_t	dns_c_ipmatch_negate(dns_c_ipmatchelement_t *ipe);
+isc_result_t	dns_c_ipmatch_aclnew(isc_mem_t *mem,
 				     dns_c_ipmatchelement_t **result,
 				     const char *aclname);
-isc_result_t	dns_c_ipmatchkey_new(isc_log_t *lctx,
-				     isc_mem_t *mem,
+isc_result_t	dns_c_ipmatchkey_new(isc_mem_t *mem,
 				     dns_c_ipmatchelement_t **result,
 				     const char *key);
-isc_result_t	dns_c_ipmatchlocalhost_new(isc_log_t *lctx,
-					   isc_mem_t *mem,
+isc_result_t	dns_c_ipmatchlocalhost_new(isc_mem_t *mem,
 					   dns_c_ipmatchelement_t **result); 
-isc_result_t	dns_c_ipmatchlocalnets_new(isc_log_t *lctx,
-					   isc_mem_t *mem,
+isc_result_t	dns_c_ipmatchlocalnets_new(isc_mem_t *mem,
 					   dns_c_ipmatchelement_t **result); 
-isc_result_t	dns_c_ipmatchpattern_new(isc_log_t *lctx,
-					 isc_mem_t *mem,
+isc_result_t	dns_c_ipmatchpattern_new(isc_mem_t *mem,
 					 dns_c_ipmatchelement_t **result,
 					 isc_sockaddr_t address,
 					 isc_uint32_t maskbits);
-isc_result_t	dns_c_ipmatchindirect_new(isc_log_t *lctx,
-					  isc_mem_t *mem,
+isc_result_t	dns_c_ipmatchindirect_new(isc_mem_t *mem,
 					  dns_c_ipmatchelement_t **result,
 					  dns_c_ipmatchlist_t *iml,
 					  const char *name);
 
-isc_result_t	dns_c_ipmatchlist_new(isc_log_t *lctx,
-				      isc_mem_t *mem,
+isc_result_t	dns_c_ipmatchlist_new(isc_mem_t *mem,
 				      dns_c_ipmatchlist_t **ptr);
-isc_result_t	dns_c_ipmatchlist_detach(isc_log_t *lctx,
-					 dns_c_ipmatchlist_t **ml);
-void		dns_c_ipmatchlist_attach(isc_log_t *lctx,
-					  dns_c_ipmatchlist_t *source,
+isc_result_t	dns_c_ipmatchlist_detach(dns_c_ipmatchlist_t **ml);
+void		dns_c_ipmatchlist_attach(dns_c_ipmatchlist_t *source,
 					  dns_c_ipmatchlist_t **target);
-isc_result_t	dns_c_ipmatchlist_copy(isc_log_t *lctx,
-				       isc_mem_t *mem,
+isc_result_t	dns_c_ipmatchlist_copy(isc_mem_t *mem,
 				       dns_c_ipmatchlist_t **dest,
 				       dns_c_ipmatchlist_t *src);
-isc_result_t	dns_c_ipmatchlist_empty(isc_log_t *lctx,
-					dns_c_ipmatchlist_t *ipml);
-isc_result_t	dns_c_ipmatchlist_append(isc_log_t *lctx,
-					 dns_c_ipmatchlist_t *dest,
+isc_result_t	dns_c_ipmatchlist_empty(dns_c_ipmatchlist_t *ipml);
+isc_result_t	dns_c_ipmatchlist_append(dns_c_ipmatchlist_t *dest,
 					 dns_c_ipmatchlist_t *src,
 					 isc_boolean_t negate);
-isc_result_t	dns_c_ipmatchlist_print(isc_log_t *lctx,
-					FILE *fp, int indent,
+isc_result_t	dns_c_ipmatchlist_print(FILE *fp, int indent,
 					dns_c_ipmatchlist_t *iml);
 
 
 
-isc_result_t	dns_c_iplist_new(isc_log_t *lctx,
-				 isc_mem_t *mem, int length,
+isc_result_t	dns_c_iplist_new(isc_mem_t *mem, int length,
 				 dns_c_iplist_t **newlist);
-isc_result_t	dns_c_iplist_detach(isc_log_t *lctx,
-				    dns_c_iplist_t **list);
-isc_result_t	dns_c_iplist_copy(isc_log_t *lctx,
-				  isc_mem_t *mem, dns_c_iplist_t **dest,
+isc_result_t	dns_c_iplist_detach(dns_c_iplist_t **list);
+isc_result_t	dns_c_iplist_copy(isc_mem_t *mem, dns_c_iplist_t **dest,
 				  dns_c_iplist_t *src);
-void	        dns_c_iplist_attach(isc_log_t *lctx,
-				    dns_c_iplist_t *source,
+void	        dns_c_iplist_attach(dns_c_iplist_t *source,
 				    dns_c_iplist_t **target);
-isc_result_t	dns_c_iplist_append(isc_log_t *lctx,
-				    dns_c_iplist_t *list,
+isc_result_t	dns_c_iplist_append(dns_c_iplist_t *list,
 				    isc_sockaddr_t newaddr);
-isc_result_t	dns_c_iplist_remove(isc_log_t *lctx,
-				    dns_c_iplist_t *list,
+isc_result_t	dns_c_iplist_remove(dns_c_iplist_t *list,
 				    isc_sockaddr_t newaddr);
-void		dns_c_iplist_print(isc_log_t *lctx,
-				   FILE *fp, int indent,
+void		dns_c_iplist_print(FILE *fp, int indent,
 				   dns_c_iplist_t *list);
 isc_boolean_t	dns_c_iplist_equal(dns_c_iplist_t *list1,
 				   dns_c_iplist_t *list2);
diff --git a/lib/dns/include/dns/confkeys.h b/lib/dns/include/dns/confkeys.h
index 4a7d850128..37f0e1529a 100644
--- a/lib/dns/include/dns/confkeys.h
+++ b/lib/dns/include/dns/confkeys.h
@@ -190,148 +190,114 @@ struct dns_c_kid_list
  *** Functions
  ***/
 
-isc_result_t	dns_c_pklist_new(isc_log_t *lctx, isc_mem_t *mem,
+isc_result_t	dns_c_pklist_new(isc_mem_t *mem,
                                  dns_c_pklist_t **pklist);
-isc_result_t	dns_c_pklist_delete(isc_log_t *lctx, dns_c_pklist_t **list);
-isc_result_t	dns_c_pklist_addpubkey(isc_log_t *lctx, dns_c_pklist_t *list,
+isc_result_t	dns_c_pklist_delete(dns_c_pklist_t **list);
+isc_result_t	dns_c_pklist_addpubkey(dns_c_pklist_t *list,
                                        dns_c_pubkey_t *pkey,
                                        isc_boolean_t deepcopy);
-isc_result_t	dns_c_pklist_findpubkey(isc_log_t *lctx, dns_c_pklist_t *list,
+isc_result_t	dns_c_pklist_findpubkey(dns_c_pklist_t *list,
 					dns_c_pubkey_t **pubkey,
 					isc_int32_t flags,
 					isc_int32_t protocol,
 					isc_int32_t algorithm,
 					const char *key);
-isc_result_t	dns_c_pklist_rmpubkey(isc_log_t *lctx, dns_c_pklist_t *list,
+isc_result_t	dns_c_pklist_rmpubkey(dns_c_pklist_t *list,
 				      isc_int32_t flags,
 				      isc_int32_t protocol,
 				      isc_int32_t algorithm,
 				      const char *key);
-void		dns_c_pklist_print(isc_log_t *lctx,
-				   FILE *fp, int indent,
+void		dns_c_pklist_print(FILE *fp, int indent,
 				   dns_c_pklist_t *pubkey);
 
 
 
-isc_result_t	dns_c_pubkey_new(isc_log_t *lctx,
-				 isc_mem_t *mem, isc_int32_t flags,
+isc_result_t	dns_c_pubkey_new(isc_mem_t *mem, isc_int32_t flags,
 				 isc_int32_t protocol,
 				 isc_int32_t algorithm,
 				 const char *key, dns_c_pubkey_t **pubkey);
-isc_result_t	dns_c_pubkey_delete(isc_log_t *lctx,
-				    dns_c_pubkey_t **pubkey);
-isc_result_t	dns_c_pubkey_copy(isc_log_t *lctx,
-				  isc_mem_t *mem, dns_c_pubkey_t **dest,
+isc_result_t	dns_c_pubkey_delete(dns_c_pubkey_t **pubkey);
+isc_result_t	dns_c_pubkey_copy(isc_mem_t *mem, dns_c_pubkey_t **dest,
 				  dns_c_pubkey_t *src);
 isc_boolean_t	dns_c_pubkey_equal(dns_c_pubkey_t *k1, dns_c_pubkey_t *k2);
-void		dns_c_pubkey_print(isc_log_t *lctx,
-				   FILE *fp, int indent,
+void		dns_c_pubkey_print(FILE *fp, int indent,
 				   dns_c_pubkey_t *pubkey);
 
 
-isc_result_t	dns_c_kidlist_new(isc_log_t *lctx,
-				  isc_mem_t *mem,
+isc_result_t	dns_c_kidlist_new(isc_mem_t *mem,
 				  dns_c_kidlist_t **list);
-isc_result_t	dns_c_kidlist_delete(isc_log_t *lctx,
-				     dns_c_kidlist_t **list);
-isc_result_t	dns_c_kidlist_undef(isc_log_t *lctx,
-				    dns_c_kidlist_t *list,
+isc_result_t	dns_c_kidlist_delete(dns_c_kidlist_t **list);
+isc_result_t	dns_c_kidlist_undef(dns_c_kidlist_t *list,
 				    const char *keyid);
-isc_result_t	dns_c_kidlist_find(isc_log_t *lctx,
-				   dns_c_kidlist_t *list,
+isc_result_t	dns_c_kidlist_find(dns_c_kidlist_t *list,
 				   const char *keyid,
 				   dns_c_kid_t **retval);
-void		dns_c_kidlist_print(isc_log_t *lctx,
-				    FILE *fp, int indent,
+void		dns_c_kidlist_print(FILE *fp, int indent,
 				    dns_c_kidlist_t *list);
-isc_result_t	dns_c_kid_new(isc_log_t *lctx,
-			      dns_c_kidlist_t *list, const char *name,
+isc_result_t	dns_c_kid_new(dns_c_kidlist_t *list, const char *name,
 			      dns_c_kid_t **keyid);
 
-isc_result_t	dns_c_kdeflist_new(isc_log_t *lctx,
-				   isc_mem_t *mem,
+isc_result_t	dns_c_kdeflist_new(isc_mem_t *mem,
 				   dns_c_kdeflist_t **list);
-isc_result_t	dns_c_kdeflist_delete(isc_log_t *lctx,
-				      dns_c_kdeflist_t **list);
-isc_result_t	dns_c_kdeflist_copy(isc_log_t *lctx,
-				    isc_mem_t *mem,
+isc_result_t	dns_c_kdeflist_delete(dns_c_kdeflist_t **list);
+isc_result_t	dns_c_kdeflist_copy(isc_mem_t *mem,
 				    dns_c_kdeflist_t **dest,
 				    dns_c_kdeflist_t *src);
-isc_result_t	dns_c_kdeflist_append(isc_log_t *lctx, dns_c_kdeflist_t *list,
+isc_result_t	dns_c_kdeflist_append(dns_c_kdeflist_t *list,
 				      dns_c_kdef_t *key, isc_boolean_t copy);
 
-isc_result_t	dns_c_kdeflist_undef(isc_log_t *lctx,
-				     dns_c_kdeflist_t *list,
+isc_result_t	dns_c_kdeflist_undef(dns_c_kdeflist_t *list,
 				     const char *keyid);
-isc_result_t	dns_c_kdeflist_find(isc_log_t *lctx,
-				    dns_c_kdeflist_t *list,
+isc_result_t	dns_c_kdeflist_find(dns_c_kdeflist_t *list,
 				    const char *keyid,
 				    dns_c_kdef_t **retval);
-void		dns_c_kdeflist_print(isc_log_t *lctx,
-				     FILE *fp, int indent,
+void		dns_c_kdeflist_print(FILE *fp, int indent,
 				     dns_c_kdeflist_t *list);
 
-isc_result_t	dns_c_kdef_new(isc_log_t *lctx,
-			       dns_c_kdeflist_t *list, const char *name,
+isc_result_t	dns_c_kdef_new(dns_c_kdeflist_t *list, const char *name,
 			       dns_c_kdef_t **keyid);
-isc_result_t	dns_c_kdef_delete(isc_log_t *lctx, dns_c_kdef_t **keydef);
-isc_result_t	dns_c_kdef_copy(isc_log_t *lctx, isc_mem_t *mem,
+isc_result_t	dns_c_kdef_delete(dns_c_kdef_t **keydef);
+isc_result_t	dns_c_kdef_copy(isc_mem_t *mem,
 				dns_c_kdef_t **dest, dns_c_kdef_t *src);
 
-void		dns_c_kdef_print(isc_log_t *lctx,
-				 FILE *fp, int indent, dns_c_kdef_t *keydef);
+void		dns_c_kdef_print(FILE *fp, int indent, dns_c_kdef_t *keydef);
 
 
-isc_result_t	dns_c_kdef_setalgorithm(isc_log_t *lctx,
-					dns_c_kdef_t *elem,
+isc_result_t	dns_c_kdef_setalgorithm(dns_c_kdef_t *elem,
 					const char *algorithm);
-isc_result_t	dns_c_kdef_setsecret(isc_log_t *lctx,
-				     dns_c_kdef_t *elem,
+isc_result_t	dns_c_kdef_setsecret(dns_c_kdef_t *elem,
 				     const char *secret);
 
-isc_result_t	dns_c_tkeylist_new(isc_log_t *lctx,
-				   isc_mem_t *mem,
+isc_result_t	dns_c_tkeylist_new(isc_mem_t *mem,
 				   dns_c_tkeylist_t **newlist);
-isc_result_t	dns_c_tkeylist_delete(isc_log_t *lctx,
-				      dns_c_tkeylist_t **list);
-isc_result_t	dns_c_tkeylist_copy(isc_log_t *lctx,
-				    isc_mem_t *mem,
+isc_result_t	dns_c_tkeylist_delete(dns_c_tkeylist_t **list);
+isc_result_t	dns_c_tkeylist_copy(isc_mem_t *mem,
 				    dns_c_tkeylist_t **dest,
 				    dns_c_tkeylist_t *src);
-void		dns_c_tkeylist_print(isc_log_t *lctx,
-				     FILE *fp, int indent,
+void		dns_c_tkeylist_print(FILE *fp, int indent,
 				     dns_c_tkeylist_t *list);
-isc_result_t	dns_c_tkeylist_append(isc_log_t *lctx,
-				      dns_c_tkeylist_t *list,
+isc_result_t	dns_c_tkeylist_append(dns_c_tkeylist_t *list,
 				      dns_c_tkey_t *element,
 				      isc_boolean_t copy);
 
-isc_result_t	dns_c_tkey_new(isc_log_t *lctx,
-			       isc_mem_t *mem, const char *domain,
+isc_result_t	dns_c_tkey_new(isc_mem_t *mem, const char *domain,
 			       isc_int32_t flags,
 			       isc_int32_t protocol,
 			       isc_int32_t algorithm,
 			       const char *key, dns_c_tkey_t **newkey);
-isc_result_t	dns_c_tkey_delete(isc_log_t *lctx,
-				  dns_c_tkey_t **tkey);
-isc_result_t	dns_c_tkey_copy(isc_log_t *lctx,
-				isc_mem_t *mem,
+isc_result_t	dns_c_tkey_delete(dns_c_tkey_t **tkey);
+isc_result_t	dns_c_tkey_copy(isc_mem_t *mem,
 				dns_c_tkey_t **dest, dns_c_tkey_t *src);
 
-isc_result_t	dns_c_tkey_getflags(isc_log_t *lctx,
-				    dns_c_tkey_t *tkey,
+isc_result_t	dns_c_tkey_getflags(dns_c_tkey_t *tkey,
 				    isc_int32_t *flags);
-isc_result_t	dns_c_tkey_getprotocol(isc_log_t *lctx,
-				       dns_c_tkey_t *tkey,
+isc_result_t	dns_c_tkey_getprotocol(dns_c_tkey_t *tkey,
 				       isc_int32_t *protocol);
-isc_result_t	dns_c_tkey_getalgorithm(isc_log_t *lctx,
-					dns_c_tkey_t *tkey,
+isc_result_t	dns_c_tkey_getalgorithm(dns_c_tkey_t *tkey,
 					isc_int32_t *algorithm);
-isc_result_t	dns_c_tkey_getkey(isc_log_t *lctx,
-				  dns_c_tkey_t *tkey,
+isc_result_t	dns_c_tkey_getkey(dns_c_tkey_t *tkey,
 				  const char **key);
-void		dns_c_tkey_print(isc_log_t *lctx,
-				 FILE *fp, int indent, dns_c_tkey_t *tkey);
+void		dns_c_tkey_print(FILE *fp, int indent, dns_c_tkey_t *tkey);
 
 
 
diff --git a/lib/dns/include/dns/conflog.h b/lib/dns/include/dns/conflog.h
index fa0354e3e0..c3eee5ba78 100644
--- a/lib/dns/include/dns/conflog.h
+++ b/lib/dns/include/dns/conflog.h
@@ -153,124 +153,89 @@ struct dns_c_logcat
  *** Functions
  ***/
 
-isc_result_t	dns_c_logginglist_new(isc_log_t *lctx,
-				      isc_mem_t *mem,
+isc_result_t	dns_c_logginglist_new(isc_mem_t *mem,
 				      dns_c_logginglist_t **list);
-isc_result_t	dns_c_logginglist_delete(isc_log_t *lctx,
-					 dns_c_logginglist_t **list);
-void		dns_c_logginglist_print(isc_log_t *lctx,
-					FILE *fp, int indent,
+isc_result_t	dns_c_logginglist_delete(dns_c_logginglist_t **list);
+void		dns_c_logginglist_print(FILE *fp, int indent,
 					dns_c_logginglist_t *ll,
 					isc_boolean_t if_predef_too);
-isc_result_t	dns_c_logginglist_copy(isc_log_t *lctx,
-				       isc_mem_t *mem,
+isc_result_t	dns_c_logginglist_copy(isc_mem_t *mem,
 				       dns_c_logginglist_t **dest,
 				       dns_c_logginglist_t *src);
 
-isc_result_t	dns_c_logginglist_addchannel(isc_log_t *lctx,
-					     dns_c_logginglist_t *list,
+isc_result_t	dns_c_logginglist_addchannel(dns_c_logginglist_t *list,
 					     dns_c_logchan_t *newchan,
 					     isc_boolean_t deepcopy);
-isc_result_t	dns_c_logginglist_addcategory(isc_log_t *lctx,
-					      dns_c_logginglist_t *list,
+isc_result_t	dns_c_logginglist_addcategory(dns_c_logginglist_t *list,
 					      dns_c_logcat_t *newcat,
 					      isc_boolean_t deepcopy);
-isc_result_t	dns_c_logginglist_delchannel(isc_log_t *lctx,
-					     dns_c_logginglist_t *list,
+isc_result_t	dns_c_logginglist_delchannel(dns_c_logginglist_t *list,
 					     const char *name);
-isc_result_t	dns_c_logginglist_delcategory(isc_log_t *lctx,
-					      dns_c_logginglist_t *list,
+isc_result_t	dns_c_logginglist_delcategory(dns_c_logginglist_t *list,
 					      const char *name);
 
-isc_result_t	dns_c_logginglist_chanbyname(isc_log_t *lctx,
-					     dns_c_logginglist_t *list,
+isc_result_t	dns_c_logginglist_chanbyname(dns_c_logginglist_t *list,
 					     const char *name,
 					     dns_c_logchan_t **chan);
-isc_result_t	dns_c_logginglist_catbyname(isc_log_t *lctx,
-					    dns_c_logginglist_t *list,
+isc_result_t	dns_c_logginglist_catbyname(dns_c_logginglist_t *list,
 					    const char *name,
 					    dns_c_logcat_t **cat);
-isc_result_t	dns_c_logginglist_catbytype(isc_log_t *lctx,
-					    dns_c_logginglist_t *list,
+isc_result_t	dns_c_logginglist_catbytype(dns_c_logginglist_t *list,
 					    dns_c_category_t cattype,
 					    dns_c_logcat_t **cat);
 
 
-isc_result_t	dns_c_logchan_new(isc_log_t *lctx,
-				  isc_mem_t *mem, const char *name,
+isc_result_t	dns_c_logchan_new(isc_mem_t *mem, const char *name,
 				  dns_c_logchantype_t ctype,
 				  dns_c_logchan_t **newchan);
-isc_result_t	dns_c_logchan_delete(isc_log_t *lctx,
-				     dns_c_logchan_t **channel);
-isc_result_t	dns_c_logchan_copy(isc_log_t *lctx,
-				   isc_mem_t *mem, dns_c_logchan_t **dest,
+isc_result_t	dns_c_logchan_delete(dns_c_logchan_t **channel);
+isc_result_t	dns_c_logchan_copy(isc_mem_t *mem, dns_c_logchan_t **dest,
 				   dns_c_logchan_t *src);
-void		dns_c_logchan_print(isc_log_t *lctx,
-				    FILE *fp, int indent,
+void		dns_c_logchan_print(FILE *fp, int indent,
 				    dns_c_logchan_t *logchan,
 				    isc_boolean_t if_predef_too);
 
 
-isc_result_t	dns_c_logchan_setpath(isc_log_t *lctx,
-				      dns_c_logchan_t *channel,
+isc_result_t	dns_c_logchan_setpath(dns_c_logchan_t *channel,
 				      const char *path);
-isc_result_t	dns_c_logchan_setversions(isc_log_t *lctx,
-					  dns_c_logchan_t *channel,
+isc_result_t	dns_c_logchan_setversions(dns_c_logchan_t *channel,
 					  isc_uint32_t versions);
-isc_result_t	dns_c_logchan_setsize(isc_log_t *lctx,
-				      dns_c_logchan_t *channel,
+isc_result_t	dns_c_logchan_setsize(dns_c_logchan_t *channel,
 				      isc_uint32_t size);
-isc_result_t	dns_c_logchan_setfacility(isc_log_t *lctx,
-					  dns_c_logchan_t *channel,
+isc_result_t	dns_c_logchan_setfacility(dns_c_logchan_t *channel,
 					  int facility);
-isc_result_t	dns_c_logchan_setseverity(isc_log_t *lctx,
-					  dns_c_logchan_t *channel,
+isc_result_t	dns_c_logchan_setseverity(dns_c_logchan_t *channel,
 					  dns_c_logseverity_t severity);
-isc_result_t	dns_c_logchan_setdebuglevel(isc_log_t *lctx,
-					    dns_c_logchan_t *channel,
+isc_result_t	dns_c_logchan_setdebuglevel(dns_c_logchan_t *channel,
 					    isc_int32_t level);
-isc_result_t	dns_c_logchan_setprintcat(isc_log_t *lctx,
-					  dns_c_logchan_t *channel,
+isc_result_t	dns_c_logchan_setprintcat(dns_c_logchan_t *channel,
 					  isc_boolean_t newval);
-isc_result_t	dns_c_logchan_setprintsev(isc_log_t *lctx,
-					  dns_c_logchan_t *channel,
+isc_result_t	dns_c_logchan_setprintsev(dns_c_logchan_t *channel,
 					  isc_boolean_t newval);
-isc_result_t	dns_c_logchan_setprinttime(isc_log_t *lctx,
-					   dns_c_logchan_t *channel,
+isc_result_t	dns_c_logchan_setprinttime(dns_c_logchan_t *channel,
 					   isc_boolean_t newval);
-isc_result_t	dns_c_logchan_setpredef(isc_log_t *lctx,
-					dns_c_logchan_t *channel,
+isc_result_t	dns_c_logchan_setpredef(dns_c_logchan_t *channel,
 					isc_boolean_t newval);
 
-isc_result_t	dns_c_logchan_getpath(isc_log_t *lctx,
-				      dns_c_logchan_t *channel,
+isc_result_t	dns_c_logchan_getpath(dns_c_logchan_t *channel,
 				      const char **path);
-isc_result_t	dns_c_logchan_getversions(isc_log_t *lctx,
-					  dns_c_logchan_t *channel,
+isc_result_t	dns_c_logchan_getversions(dns_c_logchan_t *channel,
 					  isc_uint32_t *versions);
-isc_result_t	dns_c_logchan_getsize(isc_log_t *lctx,
-				      dns_c_logchan_t *channel,
+isc_result_t	dns_c_logchan_getsize(dns_c_logchan_t *channel,
 				      isc_uint32_t *size);
-isc_result_t	dns_c_logchan_getfacility(isc_log_t *lctx,
-					  dns_c_logchan_t *channel,
+isc_result_t	dns_c_logchan_getfacility(dns_c_logchan_t *channel,
 					  int *facility);
-isc_result_t	dns_c_logchan_getseverity(isc_log_t *lctx,
-					  dns_c_logchan_t *channel,
+isc_result_t	dns_c_logchan_getseverity(dns_c_logchan_t *channel,
 					  dns_c_logseverity_t *severity);
-isc_result_t	dns_c_logchan_getdebuglevel(isc_log_t *lctx,
-					    dns_c_logchan_t *channel,
+isc_result_t	dns_c_logchan_getdebuglevel(dns_c_logchan_t *channel,
 					    isc_int32_t *level);
-isc_result_t	dns_c_logchan_getprintcat(isc_log_t *lctx,
-					  dns_c_logchan_t *channel,
+isc_result_t	dns_c_logchan_getprintcat(dns_c_logchan_t *channel,
 					  isc_boolean_t *retval);
-isc_result_t	dns_c_logchan_getprintsev(isc_log_t *lctx,
-					  dns_c_logchan_t *channel,
+isc_result_t	dns_c_logchan_getprintsev(dns_c_logchan_t *channel,
 					  isc_boolean_t *retval);
-isc_result_t	dns_c_logchan_getprinttime(isc_log_t *lctx,
-					   dns_c_logchan_t *channel,
+isc_result_t	dns_c_logchan_getprinttime(dns_c_logchan_t *channel,
 					   isc_boolean_t *retval);
-isc_result_t	dns_c_logchan_getpredef(isc_log_t *lctx,
-					dns_c_logchan_t *channel,
+isc_result_t	dns_c_logchan_getpredef(dns_c_logchan_t *channel,
 					isc_boolean_t *retval);
 
 
@@ -278,29 +243,21 @@ isc_result_t	dns_c_logchan_getpredef(isc_log_t *lctx,
 /*
  * Logging category
  */
-isc_result_t	dns_c_logcat_new(isc_log_t *lctx,
-				 isc_mem_t *mem, dns_c_category_t cat,
+isc_result_t	dns_c_logcat_new(isc_mem_t *mem, dns_c_category_t cat,
 				 dns_c_logcat_t **newlc);
-isc_result_t	dns_c_logcat_delete(isc_log_t *lctx,
-				    dns_c_logcat_t **logcat);
-void		dns_c_logcat_print(isc_log_t *lctx,
-				   FILE *fp, int indent,
+isc_result_t	dns_c_logcat_delete(dns_c_logcat_t **logcat);
+void		dns_c_logcat_print(FILE *fp, int indent,
 				   dns_c_logcat_t *logcat,
 				   isc_boolean_t if_predef_too);
-isc_result_t	dns_c_logcat_copy(isc_log_t *lctx,
-				  isc_mem_t *mem, dns_c_logcat_t **dest,
+isc_result_t	dns_c_logcat_copy(isc_mem_t *mem, dns_c_logcat_t **dest,
 				  dns_c_logcat_t *src);
-isc_result_t	dns_c_logcat_addname(isc_log_t *lctx,
-				     dns_c_logcat_t *logcat,
+isc_result_t	dns_c_logcat_addname(dns_c_logcat_t *logcat,
 				     const char *name);
-isc_result_t	dns_c_logcat_delname(isc_log_t *lctx,
-				     dns_c_logcat_t *logcat,
+isc_result_t	dns_c_logcat_delname(dns_c_logcat_t *logcat,
 				     const char *name);
-isc_result_t	dns_c_logcat_setpredef(isc_log_t *lctx,
-				       dns_c_logcat_t *logcat,
+isc_result_t	dns_c_logcat_setpredef(dns_c_logcat_t *logcat,
 				       isc_boolean_t newval);
-isc_result_t	dns_c_logcat_getpredef(isc_log_t *lctx,
-				       dns_c_logcat_t *logcat,
+isc_result_t	dns_c_logcat_getpredef(dns_c_logcat_t *logcat,
 					isc_boolean_t *retval);
 
 #endif /* ISC_WHATEVER_H */
diff --git a/lib/dns/include/dns/conflsn.h b/lib/dns/include/dns/conflsn.h
index 536d9cdd72..a1c46068ec 100644
--- a/lib/dns/include/dns/conflsn.h
+++ b/lib/dns/include/dns/conflsn.h
@@ -105,7 +105,7 @@ struct dns_c_lstn_list
  *** Functions
  ***/
 
-isc_result_t	dns_c_lstnlist_new(isc_log_t *lctx, isc_mem_t *mem,
+isc_result_t	dns_c_lstnlist_new(isc_mem_t *mem,
 				   dns_c_lstnlist_t **llist);
 /*
  * Creates a new dns_c_lstnlist_t structure from the allocator pointed to
@@ -120,8 +120,7 @@ isc_result_t	dns_c_lstnlist_new(isc_log_t *lctx, isc_mem_t *mem,
  *	ISC_R_NOMEMORY		on allocation failure.
  */
 
-isc_result_t	dns_c_lstnlist_delete(isc_log_t *lctx,
-				      dns_c_lstnlist_t **llist);
+isc_result_t	dns_c_lstnlist_delete(dns_c_lstnlist_t **llist);
 /*
  * Deletes the list pointed to by **LLIST, and all the elements in it.
  * Sets *LLIST to NULL when done.
@@ -134,8 +133,7 @@ isc_result_t	dns_c_lstnlist_delete(isc_log_t *lctx,
  */
 
 
-isc_result_t	dns_c_lstnlist_print(isc_log_t *lctx,
-				     FILE *fp, int indent,
+isc_result_t	dns_c_lstnlist_print(FILE *fp, int indent,
 				     dns_c_lstnlist_t *ll);
 /*
  * Prints the given the list LL to the stream FP. INDENT number of tabs
@@ -148,7 +146,7 @@ isc_result_t	dns_c_lstnlist_print(isc_log_t *lctx,
  */
 
 
-isc_result_t	dns_c_lstnon_new(isc_log_t *lctx, isc_mem_t *mem,
+isc_result_t	dns_c_lstnon_new(isc_mem_t *mem,
 				 dns_c_lstnon_t **listen);
 /*
  * Creates a new dns_c_lstnon_t structure and stores the pointer
@@ -163,8 +161,7 @@ isc_result_t	dns_c_lstnon_new(isc_log_t *lctx, isc_mem_t *mem,
  *	ISC_R_NOMEMORY on allocation failure.
  */
 
-isc_result_t	dns_c_lstnon_delete(isc_log_t *lctx,
-				    dns_c_lstnon_t **listen);
+isc_result_t	dns_c_lstnon_delete(dns_c_lstnon_t **listen);
 /*
  * Deletes the dns_c_lstnon_t structure pointed to by *LISTEN.
  *
@@ -175,8 +172,7 @@ isc_result_t	dns_c_lstnon_delete(isc_log_t *lctx,
  * Returns:
  */
 
-isc_result_t	dns_c_lstnon_setiml(isc_log_t *lctx,
-				    dns_c_lstnon_t *listen,
+isc_result_t	dns_c_lstnon_setiml(dns_c_lstnon_t *listen,
 				    dns_c_ipmatchlist_t *iml,
 				    isc_boolean_t deepcopy);
 /*
@@ -192,7 +188,7 @@ isc_result_t	dns_c_lstnon_setiml(isc_log_t *lctx,
  *	ISC_R_NOMEMORY on allocation failure.
  */
 
-isc_result_t	dns_c_lstnon_print(isc_log_t *lctx, FILE *fp, int indent,
+isc_result_t	dns_c_lstnon_print(FILE *fp, int indent,
 				   dns_c_lstnon_t *lo);
 
 
diff --git a/lib/dns/include/dns/confparser.h b/lib/dns/include/dns/confparser.h
index 3843cab257..b6f8b7315f 100644
--- a/lib/dns/include/dns/confparser.h
+++ b/lib/dns/include/dns/confparser.h
@@ -83,8 +83,7 @@ typedef struct dns_c_cbks
 } dns_c_cbks_t;
 
 
-isc_result_t dns_c_parse_namedconf(isc_log_t *logctx,
-				   const char *filename, isc_mem_t *mem,
+isc_result_t dns_c_parse_namedconf(const char *filename, isc_mem_t *mem,
 				   dns_c_ctx_t **configctx,
 				   dns_c_cbks_t *callbacks);
 
diff --git a/lib/dns/include/dns/confresolv.h b/lib/dns/include/dns/confresolv.h
index b80a47249b..1612815703 100644
--- a/lib/dns/include/dns/confresolv.h
+++ b/lib/dns/include/dns/confresolv.h
@@ -75,8 +75,7 @@ struct dns_c_resolv
  *** Functions
  ***/
 
-isc_result_t dns_c_resolv_new(isc_log_t *lctx,
-			      isc_mem_t *mem, dns_c_resolv_t **cfgres);
+isc_result_t dns_c_resolv_new(isc_mem_t *mem, dns_c_resolv_t **cfgres);
 /*
  * Creates a new resolver-config object.
  *
@@ -90,8 +89,7 @@ isc_result_t dns_c_resolv_new(isc_log_t *lctx,
  * 
  */
 
-isc_result_t dns_c_resolv_delete(isc_log_t *lctx,
-				 dns_c_resolv_t **cfgres);
+isc_result_t dns_c_resolv_delete(dns_c_resolv_t **cfgres);
 /*
  * Deletes the config-resolv object and its contents.
  *
diff --git a/lib/dns/include/dns/confrrset.h b/lib/dns/include/dns/confrrset.h
index ef631249b3..68eabc94c6 100644
--- a/lib/dns/include/dns/confrrset.h
+++ b/lib/dns/include/dns/confrrset.h
@@ -107,30 +107,29 @@ struct dns_c_rrso_list
  ***/
 
 
-isc_result_t	dns_c_rrsolist_new(isc_log_t *lctx, isc_mem_t *mem,
+isc_result_t	dns_c_rrsolist_new(isc_mem_t *mem,
 				   dns_c_rrsolist_t **rval);
-isc_result_t	dns_c_rrsolist_delete(isc_log_t *lctx,
-				      dns_c_rrsolist_t **list);
-isc_result_t	dns_c_rrsolist_copy(isc_log_t *lctx, isc_mem_t *mem,
+isc_result_t	dns_c_rrsolist_delete(dns_c_rrsolist_t **list);
+isc_result_t	dns_c_rrsolist_copy(isc_mem_t *mem,
 				    dns_c_rrsolist_t **dest,
 				    dns_c_rrsolist_t *source);
-isc_result_t	dns_c_rrsolist_clear(isc_log_t *lctx, dns_c_rrsolist_t *olist);
-isc_result_t	dns_c_rrsolist_append(isc_log_t *lctx, dns_c_rrsolist_t *dest,
+isc_result_t	dns_c_rrsolist_clear(dns_c_rrsolist_t *olist);
+isc_result_t	dns_c_rrsolist_append(dns_c_rrsolist_t *dest,
 				      dns_c_rrsolist_t *src);
 
-isc_result_t	dns_c_rrso_new(isc_log_t *lctx, isc_mem_t *mem,
+isc_result_t	dns_c_rrso_new(isc_mem_t *mem,
 			       dns_c_rrso_t **res,
 			       dns_rdataclass_t oclass,
 			       dns_rdatatype_t otype,
 			       char *name,
 			       dns_c_ordering_t ordering);
-isc_result_t	dns_c_rrso_delete(isc_log_t *lctx, dns_c_rrso_t **order);
-isc_result_t	dns_c_rrso_copy(isc_log_t *lctx, isc_mem_t *mem,
+isc_result_t	dns_c_rrso_delete(dns_c_rrso_t **order);
+isc_result_t	dns_c_rrso_copy(isc_mem_t *mem,
 				dns_c_rrso_t **dest,
 				dns_c_rrso_t *source);
-void		dns_c_rrsolist_print(isc_log_t *lctx, FILE *fp, int indent,
+void		dns_c_rrsolist_print(FILE *fp, int indent,
 				     dns_c_rrsolist_t *rrlist);
-void		dns_c_rrso_print(isc_log_t *lctx, FILE *fp, int indent,
+void		dns_c_rrso_print(FILE *fp, int indent,
 				 dns_c_rrso_t *rrlist);
 
 
diff --git a/lib/dns/include/dns/confserv.h b/lib/dns/include/dns/confserv.h
index d19391b585..fbf6d45608 100644
--- a/lib/dns/include/dns/confserv.h
+++ b/lib/dns/include/dns/confserv.h
@@ -108,48 +108,45 @@ struct dns_c_srv
  *** Functions
  ***/
 
-isc_result_t	dns_c_srvlist_new(isc_log_t *lctx, isc_mem_t *mem,
+isc_result_t	dns_c_srvlist_new(isc_mem_t *mem,
 				  dns_c_srvlist_t **list);
-isc_result_t	dns_c_srvlist_delete(isc_log_t *lctx, dns_c_srvlist_t **list);
-void		dns_c_srvlist_print(isc_log_t *lctx, FILE *fp, int indent,
+isc_result_t	dns_c_srvlist_delete(dns_c_srvlist_t **list);
+void		dns_c_srvlist_print(FILE *fp, int indent,
 				    dns_c_srvlist_t *servers);
-isc_result_t	dns_c_srvlist_servbyaddr(isc_log_t *lctx,
-					 dns_c_srvlist_t *servers,
+isc_result_t	dns_c_srvlist_servbyaddr(dns_c_srvlist_t *servers,
 					 isc_sockaddr_t addr,
 					 dns_c_srv_t **retval);
 
 
-isc_result_t	dns_c_srv_new(isc_log_t *lctx, isc_mem_t *mem,
+isc_result_t	dns_c_srv_new(isc_mem_t *mem,
 			      isc_sockaddr_t ipaddr,
 			      dns_c_srv_t **server);
-isc_result_t	dns_c_srv_delete(isc_log_t *lctx, dns_c_srv_t **server);
-void		dns_c_srv_print(isc_log_t *lctx, FILE *fp, int indent,
+isc_result_t	dns_c_srv_delete(dns_c_srv_t **server);
+void		dns_c_srv_print(FILE *fp, int indent,
 				dns_c_srv_t *server);
 
-isc_result_t	dns_c_srv_setbogus(isc_log_t *lctx, dns_c_srv_t *server,
+isc_result_t	dns_c_srv_setbogus(dns_c_srv_t *server,
 				   isc_boolean_t newval);
-isc_result_t	dns_c_srv_getbogus(isc_log_t *lctx, dns_c_srv_t *server,
+isc_result_t	dns_c_srv_getbogus(dns_c_srv_t *server,
 				   isc_boolean_t *retval);
-isc_result_t	dns_c_srv_setsupportixfr(isc_log_t *lctx, dns_c_srv_t *server,
+isc_result_t	dns_c_srv_setsupportixfr(dns_c_srv_t *server,
 					 isc_boolean_t newval);
-isc_result_t	dns_c_srv_getsupportixfr(isc_log_t *lctx, dns_c_srv_t *server,
+isc_result_t	dns_c_srv_getsupportixfr(dns_c_srv_t *server,
 					 isc_boolean_t *retval);
-isc_result_t	dns_c_srv_settransfers(isc_log_t *lctx, dns_c_srv_t *server,
+isc_result_t	dns_c_srv_settransfers(dns_c_srv_t *server,
 				       isc_int32_t newval);
-isc_result_t	dns_c_srv_gettransfers(isc_log_t *lctx, dns_c_srv_t *server,
+isc_result_t	dns_c_srv_gettransfers(dns_c_srv_t *server,
 				       isc_int32_t *retval);
-isc_result_t	dns_c_srv_settransferformat(isc_log_t *lctx,
-					    dns_c_srv_t *server,
+isc_result_t	dns_c_srv_settransferformat(dns_c_srv_t *server,
 					    dns_transfer_format_t newval);
-isc_result_t	dns_c_srv_gettransferformat(isc_log_t *lctx,
-					    dns_c_srv_t *server,
+isc_result_t	dns_c_srv_gettransferformat(dns_c_srv_t *server,
 					    dns_transfer_format_t *retval);
-isc_result_t	dns_c_srv_get_keylist(isc_log_t *lctx, dns_c_srv_t *server,
+isc_result_t	dns_c_srv_get_keylist(dns_c_srv_t *server,
 				      dns_c_kidlist_t **keylist);
 
-isc_result_t	dns_c_srv_settkeydomain(isc_log_t *lctx, dns_c_srv_t *server,
+isc_result_t	dns_c_srv_settkeydomain(dns_c_srv_t *server,
 					char *newval);
-isc_result_t	dns_c_srv_gettkeydomain(isc_log_t *lctx, dns_c_srv_t *server,
+isc_result_t	dns_c_srv_gettkeydomain(dns_c_srv_t *server,
 					char **retval);
 
 #endif /* DNS_CONFIG_CONFSERV_H */
diff --git a/lib/dns/include/dns/confview.h b/lib/dns/include/dns/confview.h
index 0f8a401db4..d90fd36e5a 100644
--- a/lib/dns/include/dns/confview.h
+++ b/lib/dns/include/dns/confview.h
@@ -158,7 +158,7 @@ struct dns_c_view
  *** Functions
  ***/
 
-isc_result_t dns_c_viewtable_new(isc_log_t *lctx, isc_mem_t *mem,
+isc_result_t dns_c_viewtable_new(isc_mem_t *mem,
 				 dns_c_viewtable_t **viewtable);
 
 /*
@@ -176,8 +176,7 @@ isc_result_t dns_c_viewtable_new(isc_log_t *lctx, isc_mem_t *mem,
  * 
  */
 
-isc_result_t dns_c_viewtable_delete(isc_log_t *lctx,
-				    dns_c_viewtable_t **viewtable);
+isc_result_t dns_c_viewtable_delete(dns_c_viewtable_t **viewtable);
 /*
  * Destroys the table pointed to by *VIEWTABLE and all the views in it. The
  * value of *VIEWTABLE can be NULL (which is a no-op).
@@ -192,7 +191,7 @@ isc_result_t dns_c_viewtable_delete(isc_log_t *lctx,
  */
 
 
-void dns_c_viewtable_addview(isc_log_t *lctx, dns_c_viewtable_t *viewtable,
+void dns_c_viewtable_addview(dns_c_viewtable_t *viewtable,
 			     dns_c_view_t *view);
 
 /*
@@ -205,7 +204,7 @@ void dns_c_viewtable_addview(isc_log_t *lctx, dns_c_viewtable_t *viewtable,
  *
  */
 
-void dns_c_viewtable_rmview(isc_log_t *lctx, dns_c_viewtable_t *viewtable,
+void dns_c_viewtable_rmview(dns_c_viewtable_t *viewtable,
 			    dns_c_view_t *view);
 
 /*
@@ -218,8 +217,7 @@ void dns_c_viewtable_rmview(isc_log_t *lctx, dns_c_viewtable_t *viewtable,
  *
  */
 
-isc_result_t dns_c_viewtable_viewbyname(isc_log_t *lctx,
-					dns_c_viewtable_t *viewtable,
+isc_result_t dns_c_viewtable_viewbyname(dns_c_viewtable_t *viewtable,
 					const char *viewname,
 					dns_c_view_t **retval);
 
@@ -236,8 +234,7 @@ isc_result_t dns_c_viewtable_viewbyname(isc_log_t *lctx,
  * 
  */
 
-isc_result_t dns_c_viewtable_rmviewbyname(isc_log_t *lctx,
-					  dns_c_viewtable_t *viewtable,
+isc_result_t dns_c_viewtable_rmviewbyname(dns_c_viewtable_t *viewtable,
 					  const char *name);
 /*
  * Removes a view from a view table. The view is looked up by name.
@@ -253,8 +250,7 @@ isc_result_t dns_c_viewtable_rmviewbyname(isc_log_t *lctx,
  */
 
 
-isc_result_t dns_c_viewtable_clear(isc_log_t *lctx,
-				   dns_c_viewtable_t *viewtable);
+isc_result_t dns_c_viewtable_clear(dns_c_viewtable_t *viewtable);
 /*
  * Removes (and deletes) all the views in the viewtable.
  *
@@ -265,7 +261,7 @@ isc_result_t dns_c_viewtable_clear(isc_log_t *lctx,
  *	ISC_R_SUCCESS		-- all is well
  */
 
-void dns_c_viewtable_print(isc_log_t *lctx, FILE *fp, int indent,
+void dns_c_viewtable_print(FILE *fp, int indent,
 			   dns_c_viewtable_t *table);
 
 /*
@@ -278,7 +274,7 @@ void dns_c_viewtable_print(isc_log_t *lctx, FILE *fp, int indent,
  */
 
 
-isc_result_t dns_c_view_new(isc_log_t *lctx, isc_mem_t *mem, const char *name,
+isc_result_t dns_c_view_new(isc_mem_t *mem, const char *name,
 			    dns_c_view_t **newview);
 /*
  * Creates a new view. The view is placed in the given viewtable.
@@ -295,7 +291,7 @@ isc_result_t dns_c_view_new(isc_log_t *lctx, isc_mem_t *mem, const char *name,
  * 
  */
 
-isc_result_t dns_c_view_delete(isc_log_t *lctx, dns_c_view_t **view);
+isc_result_t dns_c_view_delete(dns_c_view_t **view);
 /*
  * Deletes the view and its contents.
  *
@@ -307,7 +303,7 @@ isc_result_t dns_c_view_delete(isc_log_t *lctx, dns_c_view_t **view);
  * 
  */
 
-isc_result_t dns_c_view_setallowquery(isc_log_t *lctx, dns_c_view_t *view,
+isc_result_t dns_c_view_setallowquery(dns_c_view_t *view,
 				      dns_c_ipmatchlist_t *ipml,
 				      isc_boolean_t deepcopy);
 /*
@@ -329,7 +325,7 @@ isc_result_t dns_c_view_setallowquery(isc_log_t *lctx, dns_c_view_t *view,
  * 
  */
 
-isc_result_t dns_c_view_getallowqueryexpanded(isc_log_t *lctx, isc_mem_t *mem,
+isc_result_t dns_c_view_getallowqueryexpanded(isc_mem_t *mem,
 					      dns_c_view_t *view,
 					      dns_c_acltable_t *acltable,
 					      dns_c_ipmatchlist_t **retval);
@@ -354,7 +350,7 @@ isc_result_t dns_c_view_getallowqueryexpanded(isc_log_t *lctx, isc_mem_t *mem,
  */
 
 
-void dns_c_view_print(isc_log_t *lctx, FILE *fp, int indent,
+void dns_c_view_print(FILE *fp, int indent,
 		      dns_c_view_t *view);
 
 /*	
@@ -367,7 +363,7 @@ void dns_c_view_print(isc_log_t *lctx, FILE *fp, int indent,
  */
 
 
-isc_result_t dns_c_view_getname(isc_log_t *lctx, dns_c_view_t *view,
+isc_result_t dns_c_view_getname(dns_c_view_t *view,
 				const char **retval);
 
 /*
diff --git a/lib/dns/include/dns/confzone.h b/lib/dns/include/dns/confzone.h
index 4962e83658..b7fd80113c 100644
--- a/lib/dns/include/dns/confzone.h
+++ b/lib/dns/include/dns/confzone.h
@@ -216,136 +216,124 @@ struct dns_c_zone
  *** Functions
  ***/
 
-isc_result_t	dns_c_zonelist_new(isc_log_t *lctx, isc_mem_t *mem,
+isc_result_t	dns_c_zonelist_new(isc_mem_t *mem,
 				   dns_c_zonelist_t **zlist);
-isc_result_t	dns_c_zonelist_delete(isc_log_t *lctx,
-				      dns_c_zonelist_t **zlist);
+isc_result_t	dns_c_zonelist_delete(dns_c_zonelist_t **zlist);
 #if 0
-dns_c_zone_t   *dns_c_zonelist_currzone(isc_log_t *lctx,
-					dns_c_zonelist_t *zlist);
+dns_c_zone_t   *dns_c_zonelist_currzone(dns_c_zonelist_t *zlist);
 #endif
 
-isc_result_t	dns_c_zonelist_find(isc_log_t *lctx, dns_c_zonelist_t *zlist,
+isc_result_t	dns_c_zonelist_find(dns_c_zonelist_t *zlist,
 				    const char *name, dns_c_zone_t **retval);
-isc_result_t	dns_c_zonelist_rmbyname(isc_log_t *lctx,
-					dns_c_zonelist_t *zlist,
+isc_result_t	dns_c_zonelist_rmbyname(dns_c_zonelist_t *zlist,
 					const char *name);
-isc_result_t	dns_c_zonelist_addzone(isc_log_t *lctx,
-				       dns_c_zonelist_t *zlist,
+isc_result_t	dns_c_zonelist_addzone(dns_c_zonelist_t *zlist,
 				       dns_c_zone_t *zone);
-isc_result_t	dns_c_zonelist_rmzone(isc_log_t *lctx, dns_c_zonelist_t *zlist,
+isc_result_t	dns_c_zonelist_rmzone(dns_c_zonelist_t *zlist,
 				      dns_c_zone_t *zone);
-void		dns_c_zonelist_print(isc_log_t *lctx, FILE *fp, int indent,
+void		dns_c_zonelist_print(FILE *fp, int indent,
 				     dns_c_zonelist_t *list);
-void		dns_c_zonelist_printpostopts(isc_log_t *lctx, FILE *fp,
+void		dns_c_zonelist_printpostopts(FILE *fp,
 					     int indent,
 					     dns_c_zonelist_t *list);
-void		dns_c_zonelist_printpreopts(isc_log_t *lctx, FILE *fp,
+void		dns_c_zonelist_printpreopts(FILE *fp,
 					    int indent,
 					    dns_c_zonelist_t *list);
-isc_result_t	dns_c_zone_new(isc_log_t *lctx, isc_mem_t *mem,
+isc_result_t	dns_c_zone_new(isc_mem_t *mem,
 			       dns_c_zonetype_t ztype, dns_rdataclass_t zclass,
 			       const char *name, const char *internalname,
 			       dns_c_zone_t **zone);
-isc_result_t	dns_c_zone_detach(isc_log_t *lctx, dns_c_zone_t **zone);
-void		dns_c_zone_attach(isc_log_t *lctx, dns_c_zone_t *source,
+isc_result_t	dns_c_zone_detach(dns_c_zone_t **zone);
+void		dns_c_zone_attach(dns_c_zone_t *source,
 				  dns_c_zone_t **target);
-void		dns_c_zone_print(isc_log_t *lctx, FILE *fp, int indent,
+void		dns_c_zone_print(FILE *fp, int indent,
 				 dns_c_zone_t *zone);
-isc_result_t	dns_c_zone_setfile(isc_log_t *lctx, dns_c_zone_t *zone,
+isc_result_t	dns_c_zone_setfile(dns_c_zone_t *zone,
 				   const char *newfile);
-isc_result_t	dns_c_zone_setchecknames(isc_log_t *lctx, dns_c_zone_t *zone,
+isc_result_t	dns_c_zone_setchecknames(dns_c_zone_t *zone,
 					 dns_c_severity_t severity);
-isc_result_t	dns_c_zone_setallowupd(isc_log_t *lctx, dns_c_zone_t *zone,
+isc_result_t	dns_c_zone_setallowupd(dns_c_zone_t *zone,
 				       dns_c_ipmatchlist_t *ipml,
 				       isc_boolean_t deepcopy);
-isc_result_t	dns_c_zone_setallowquery(isc_log_t *lctx, dns_c_zone_t *zone,
+isc_result_t	dns_c_zone_setallowquery(dns_c_zone_t *zone,
 					 dns_c_ipmatchlist_t *ipml,
 					 isc_boolean_t deepcopy);
-isc_result_t	dns_c_zone_setallowtransfer(isc_log_t *lctx,
-					    dns_c_zone_t *zone,
+isc_result_t	dns_c_zone_setallowtransfer(dns_c_zone_t *zone,
 					    dns_c_ipmatchlist_t *ipml,
 					    isc_boolean_t deepcopy);
-isc_result_t	dns_c_zone_setdialup(isc_log_t *lctx, dns_c_zone_t *zone,
+isc_result_t	dns_c_zone_setdialup(dns_c_zone_t *zone,
 				     isc_boolean_t newval);
-isc_result_t	dns_c_zone_setnotify(isc_log_t *lctx, dns_c_zone_t *zone,
+isc_result_t	dns_c_zone_setnotify(dns_c_zone_t *zone,
 				     isc_boolean_t newval);
-isc_result_t	dns_c_zone_setmaintixfrbase(isc_log_t *lctx,
-					    dns_c_zone_t *zone,
+isc_result_t	dns_c_zone_setmaintixfrbase(dns_c_zone_t *zone,
 					    isc_boolean_t newval);
-isc_result_t	dns_c_zone_setalsonotify(isc_log_t *lctx, dns_c_zone_t *zone,
+isc_result_t	dns_c_zone_setalsonotify(dns_c_zone_t *zone,
 					 dns_c_iplist_t *newval,
 					 isc_boolean_t deepcopy);
-isc_result_t	dns_c_zone_setixfrbase(isc_log_t *lctx, dns_c_zone_t *zone,
+isc_result_t	dns_c_zone_setixfrbase(dns_c_zone_t *zone,
 				       const char *newval);
-isc_result_t	dns_c_zone_setixfrtmp(isc_log_t *lctx, dns_c_zone_t *zone,
+isc_result_t	dns_c_zone_setixfrtmp(dns_c_zone_t *zone,
 				      const char *newval);
-isc_result_t	dns_c_zone_addpubkey(isc_log_t *lctx, dns_c_zone_t *zone,
+isc_result_t	dns_c_zone_addpubkey(dns_c_zone_t *zone,
 				     dns_c_pubkey_t *pubkey,
 				     isc_boolean_t deepcopy);
-isc_result_t	dns_c_zone_setmasterport(isc_log_t *lctx, dns_c_zone_t *zone,
+isc_result_t	dns_c_zone_setmasterport(dns_c_zone_t *zone,
 					 in_port_t port);
-isc_result_t	dns_c_zone_setmasterips(isc_log_t *lctx, dns_c_zone_t *zone,
+isc_result_t	dns_c_zone_setmasterips(dns_c_zone_t *zone,
 					dns_c_iplist_t *newval,
 					isc_boolean_t deepcopy);
-isc_result_t	dns_c_zone_settransfersource(isc_log_t *lctx,
-					     dns_c_zone_t *zone,
+isc_result_t	dns_c_zone_settransfersource(dns_c_zone_t *zone,
 					     isc_sockaddr_t newval);
-isc_result_t	dns_c_zone_setmaxtranstimein(isc_log_t *lctx,
-					     dns_c_zone_t *zone,
+isc_result_t	dns_c_zone_setmaxtranstimein(dns_c_zone_t *zone,
 					     isc_int32_t newval);
-isc_result_t	dns_c_zone_setmaxixfrlog(isc_log_t *lctx, dns_c_zone_t *zone,
+isc_result_t	dns_c_zone_setmaxixfrlog(dns_c_zone_t *zone,
 					 isc_int32_t new);
-isc_result_t	dns_c_zone_setforward(isc_log_t *lctx, dns_c_zone_t *zone,
+isc_result_t	dns_c_zone_setforward(dns_c_zone_t *zone,
 				      dns_c_forw_t newval);
-isc_result_t	dns_c_zone_setforwarders(isc_log_t *lctx, dns_c_zone_t *zone,
+isc_result_t	dns_c_zone_setforwarders(dns_c_zone_t *zone,
 					 dns_c_iplist_t *ipml,
 					 isc_boolean_t deepcopy);
-isc_result_t	dns_c_zone_getname(isc_log_t *lctx, dns_c_zone_t *zone,
+isc_result_t	dns_c_zone_getname(dns_c_zone_t *zone,
 				   const char **retval);
-isc_result_t	dns_c_zone_getinternalname(isc_log_t *lctx, dns_c_zone_t *zone,
+isc_result_t	dns_c_zone_getinternalname(dns_c_zone_t *zone,
 					   const char **retval);
-isc_result_t	dns_c_zone_getfile(isc_log_t *lctx, dns_c_zone_t *zone,
+isc_result_t	dns_c_zone_getfile(dns_c_zone_t *zone,
 				   const char **retval);
-isc_result_t	dns_c_zone_getchecknames(isc_log_t *lctx, dns_c_zone_t *zone,
+isc_result_t	dns_c_zone_getchecknames(dns_c_zone_t *zone,
 					 dns_c_severity_t *retval);
-isc_result_t	dns_c_zone_getallowupd(isc_log_t *lctx, dns_c_zone_t *zone,
+isc_result_t	dns_c_zone_getallowupd(dns_c_zone_t *zone,
 				       dns_c_ipmatchlist_t **retval);
-isc_result_t	dns_c_zone_getallowquery(isc_log_t *lctx, dns_c_zone_t *zone,
+isc_result_t	dns_c_zone_getallowquery(dns_c_zone_t *zone,
 					 dns_c_ipmatchlist_t **retval);
-isc_result_t	dns_c_zone_getallowtransfer(isc_log_t *lctx,
-					    dns_c_zone_t *zone,
+isc_result_t	dns_c_zone_getallowtransfer(dns_c_zone_t *zone,
 					    dns_c_ipmatchlist_t **retval);
-isc_result_t	dns_c_zone_getdialup(isc_log_t *lctx, dns_c_zone_t *zone,
+isc_result_t	dns_c_zone_getdialup(dns_c_zone_t *zone,
 				     isc_boolean_t *retval);
-isc_result_t	dns_c_zone_getnotify(isc_log_t *lctx, dns_c_zone_t *zone,
+isc_result_t	dns_c_zone_getnotify(dns_c_zone_t *zone,
 				     isc_boolean_t *retval);
-isc_result_t	dns_c_zone_getmaintixfrbase(isc_log_t *lctx,
-					    dns_c_zone_t *zone,
+isc_result_t	dns_c_zone_getmaintixfrbase(dns_c_zone_t *zone,
 					    isc_boolean_t *retval);
-isc_result_t	dns_c_zone_getalsonotify(isc_log_t *lctx, dns_c_zone_t *zone,
+isc_result_t	dns_c_zone_getalsonotify(dns_c_zone_t *zone,
 					 dns_c_iplist_t **retval);
-isc_result_t	dns_c_zone_getixfrbase(isc_log_t *lctx, dns_c_zone_t *zone,
+isc_result_t	dns_c_zone_getixfrbase(dns_c_zone_t *zone,
 				       const char **retval);
-isc_result_t	dns_c_zone_getixfrtmp(isc_log_t *lctx, dns_c_zone_t *zone,
+isc_result_t	dns_c_zone_getixfrtmp(dns_c_zone_t *zone,
 				      const char **retval);
-isc_result_t	dns_c_zone_getpubkeylist(isc_log_t *lctx, dns_c_zone_t *zone,
+isc_result_t	dns_c_zone_getpubkeylist(dns_c_zone_t *zone,
 				     dns_c_pklist_t **retval);
-isc_result_t	dns_c_zone_getmasterport(isc_log_t *lctx, dns_c_zone_t *zone,
+isc_result_t	dns_c_zone_getmasterport(dns_c_zone_t *zone,
 					 in_port_t *retval);
-isc_result_t	dns_c_zone_getmasterips(isc_log_t *lctx, dns_c_zone_t *zone,
+isc_result_t	dns_c_zone_getmasterips(dns_c_zone_t *zone,
 					dns_c_iplist_t **retval);
-isc_result_t	dns_c_zone_gettransfersource(isc_log_t *lctx,
-					     dns_c_zone_t *zone,
+isc_result_t	dns_c_zone_gettransfersource(dns_c_zone_t *zone,
 					     isc_sockaddr_t *retval);
-isc_result_t	dns_c_zone_getmaxtranstimein(isc_log_t *lctx,
-					     dns_c_zone_t *zone,
+isc_result_t	dns_c_zone_getmaxtranstimein(dns_c_zone_t *zone,
 					     isc_int32_t *retval);
-isc_result_t	dns_c_zone_getmaxixfrlog(isc_log_t *lctx, dns_c_zone_t *zone,
+isc_result_t	dns_c_zone_getmaxixfrlog(dns_c_zone_t *zone,
 					 isc_int32_t *retval);
-isc_result_t	dns_c_zone_getforward(isc_log_t *lctx, dns_c_zone_t *zone,
+isc_result_t	dns_c_zone_getforward(dns_c_zone_t *zone,
 				      dns_c_forw_t *retval);
-isc_result_t	dns_c_zone_getforwarders(isc_log_t *lctx, dns_c_zone_t *zone,
+isc_result_t	dns_c_zone_getforwarders(dns_c_zone_t *zone,
 					 dns_c_iplist_t **retval);
 
 
diff --git a/lib/dns/tkey.c b/lib/dns/tkey.c
index 8938936743..7388344f71 100644
--- a/lib/dns/tkey.c
+++ b/lib/dns/tkey.c
@@ -16,7 +16,7 @@
  */
 
 /*
- * $Id: tkey.c,v 1.14 1999/11/05 20:19:24 halley Exp $
+ * $Id: tkey.c,v 1.15 1999/12/06 12:40:30 brister Exp $
  * Principal Author: Brian Wellington
  */
 
@@ -79,21 +79,21 @@ dns_tkey_init(isc_log_t *lctx, dns_c_ctx_t *cfg, isc_mem_t *mctx) {
 	RUNTIME_CHECK(tkey_domain == NULL);
 	RUNTIME_CHECK(tkey_dhkey == NULL);
 
-	REQUIRE(lctx != NULL);
+	REQUIRE(lctx != NULL);		/* XXX lctx is now unused. */
 	REQUIRE(mctx != NULL);
 
 	if (cfg == NULL)
 		return (ISC_R_SUCCESS);
 
 	s = NULL;
-	result = dns_c_ctx_gettkeydhkey(lctx, cfg, &s, &n);
+	result = dns_c_ctx_gettkeydhkey(cfg, &s, &n);
 	if (result == ISC_R_NOTFOUND)
 		return (ISC_R_SUCCESS);
 	RETERR(dst_key_fromfile(s, n, DNS_KEYALG_DH,
 				DST_TYPE_PUBLIC|DST_TYPE_PRIVATE,
 				mctx, &tkey_dhkey));
 	s = NULL;
-	RETERR(dns_c_ctx_gettkeydomain(lctx, cfg, &s));
+	RETERR(dns_c_ctx_gettkeydomain(cfg, &s));
 	dns_name_init(&domain, NULL);
 	tkey_domain = (dns_name_t *) isc_mem_get(mctx, sizeof(dns_name_t));
 	if (tkey_domain == NULL)
diff --git a/lib/dns/tsig.c b/lib/dns/tsig.c
index d15d75f391..8f3991b436 100644
--- a/lib/dns/tsig.c
+++ b/lib/dns/tsig.c
@@ -16,7 +16,7 @@
  */
 
 /*
- * $Id: tsig.c,v 1.33 1999/11/16 03:02:36 bwelling Exp $
+ * $Id: tsig.c,v 1.34 1999/12/06 12:40:31 brister Exp $
  * Principal Author: Brian Wellington
  */
 
@@ -1065,7 +1065,7 @@ dns_tsig_init(isc_log_t *lctx, dns_c_ctx_t *confctx, isc_mem_t *mctx) {
 	unsigned char data[32];
 	dns_c_kdeflist_t *keylist = NULL;
 
-	REQUIRE(lctx != NULL);
+	REQUIRE(lctx != NULL);		/* XXX lctx is now unused. */
 	REQUIRE(mctx != NULL);
 
         ret = isc_rwlock_init(&tsiglock, 0, 0);
@@ -1096,7 +1096,7 @@ dns_tsig_init(isc_log_t *lctx, dns_c_ctx_t *confctx, isc_mem_t *mctx) {
 		goto failure;
 
 	if (confctx != NULL) {
-		ret = dns_c_ctx_getkdeflist(lctx, confctx, &keylist);
+		ret = dns_c_ctx_getkdeflist(confctx, &keylist);
 		if (ret == ISC_R_SUCCESS)
 			ret = add_initial_keys(keylist, mctx);
 		else if (ret != ISC_R_NOTFOUND)
diff --git a/lib/dns/zone.c b/lib/dns/zone.c
index 8ed088611a..189f49ce1f 100644
--- a/lib/dns/zone.c
+++ b/lib/dns/zone.c
@@ -15,7 +15,7 @@
  * SOFTWARE.
  */
 
- /* $Id: zone.c,v 1.39 1999/12/01 18:31:09 gson Exp $ */
+ /* $Id: zone.c,v 1.40 1999/12/06 12:40:31 brister Exp $ */
 
 #include <config.h>
 
@@ -357,11 +357,11 @@ zone_free(dns_zone_t *zone) {
 	zone->check_names = dns_c_severity_ignore;
 	zone->pubkey = NULL; /* XXX detach */
 	if (zone->update_acl != NULL)
-		dns_c_ipmatchlist_detach(NULL, &zone->update_acl);
+		dns_c_ipmatchlist_detach(&zone->update_acl);
 	if (zone->query_acl != NULL)
-		dns_c_ipmatchlist_detach(NULL, &zone->query_acl);
+		dns_c_ipmatchlist_detach(&zone->query_acl);
 	if (zone->xfr_acl != NULL)
-		dns_c_ipmatchlist_detach(NULL, &zone->xfr_acl);
+		dns_c_ipmatchlist_detach(&zone->xfr_acl);
 	if (dns_name_dynamic(&zone->origin))
 		dns_name_free(&zone->origin, zone->mctx);
 
@@ -2408,7 +2408,7 @@ dns_zone_copy(isc_log_t *lctx, dns_c_ctx_t *ctx, dns_c_zone_t *czone,
 	dns_zone_setclass(zone, czone->zclass);
 
 	origin = NULL;
-	result = dns_c_zone_getname(lctx, czone, &origin);
+	result = dns_c_zone_getname(czone, &origin);
 	if (result != DNS_R_SUCCESS)
 		return (result);
 
@@ -2429,7 +2429,7 @@ dns_zone_copy(isc_log_t *lctx, dns_c_ctx_t *ctx, dns_c_zone_t *czone,
 	switch (czone->ztype) {
 	case dns_c_zone_master:
 		dns_zone_settype(zone, dns_zone_master);
-		iresult = dns_c_zone_getfile(lctx, czone, &filename);
+		iresult = dns_c_zone_getfile(czone, &filename);
 		if (iresult != ISC_R_SUCCESS)
 			return (iresult);
 
@@ -2437,46 +2437,46 @@ dns_zone_copy(isc_log_t *lctx, dns_c_ctx_t *ctx, dns_c_zone_t *czone,
 		if (result != DNS_R_SUCCESS)
 			return (iresult);
 
-		iresult = dns_c_zone_getchecknames(lctx, czone, &severity);
+		iresult = dns_c_zone_getchecknames(czone, &severity);
 		if (iresult == ISC_R_SUCCESS)
 			dns_zone_setchecknames(zone, severity);
 		else
 			dns_zone_setchecknames(zone, dns_c_severity_fail);
 
-		iresult = dns_c_zone_getallowupd(lctx, czone, &acl);
+		iresult = dns_c_zone_getallowupd(czone, &acl);
 		if (iresult == ISC_R_SUCCESS) {
 			dns_zone_setupdateacl(zone, acl);
-			dns_c_ipmatchlist_detach(lctx, &acl);
+			dns_c_ipmatchlist_detach(&acl);
 		} else
 			dns_zone_clearupdateacl(zone);
 
-		iresult = dns_c_zone_getallowquery(lctx, czone, &acl);
+		iresult = dns_c_zone_getallowquery(czone, &acl);
 		if (iresult == ISC_R_SUCCESS) {
 			dns_zone_setqueryacl(zone, acl);
-			dns_c_ipmatchlist_detach(lctx, &acl);
+			dns_c_ipmatchlist_detach(&acl);
 		} else
 			dns_zone_clearqueryacl(zone);
 
-		iresult = dns_c_zone_getallowtransfer(lctx, czone, &acl);
+		iresult = dns_c_zone_getallowtransfer(czone, &acl);
 		if (iresult == ISC_R_SUCCESS) {
 			dns_zone_setxfracl(zone, acl);
-			dns_c_ipmatchlist_detach(lctx, &acl);
+			dns_c_ipmatchlist_detach(&acl);
 		} else
 			dns_zone_clearxfracl(zone);
 
-		iresult = dns_c_zone_getdialup(lctx, czone, &boolean);
+		iresult = dns_c_zone_getdialup(czone, &boolean);
 		if (iresult == ISC_R_SUCCESS)  
 			dns_zone_setoption(zone, DNS_ZONE_O_DIALUP, boolean);
 		else
 			dns_zone_clearoption(zone, DNS_ZONE_O_DIALUP);
 
-		iresult = dns_c_zone_getnotify(lctx, czone, &boolean);
+		iresult = dns_c_zone_getnotify(czone, &boolean);
 		if (iresult == ISC_R_SUCCESS)  
 			dns_zone_setoption(zone, DNS_ZONE_O_NOTIFY, boolean);
 		else
 			dns_zone_clearoption(zone, DNS_ZONE_O_NOTIFY);
 
-		iresult = dns_c_zone_getalsonotify(lctx, czone, &iplist);
+		iresult = dns_c_zone_getalsonotify(czone, &iplist);
 		if (iresult == ISC_R_SUCCESS) {
 			for (i = 0; i < iplist->nextidx; i++) {
 				result = dns_zone_addnotify(zone,
@@ -2489,7 +2489,7 @@ dns_zone_copy(isc_log_t *lctx, dns_c_ctx_t *ctx, dns_c_zone_t *czone,
 
 #if 1					/* XXX brister */
 		
-		iresult = dns_c_zone_getpubkeylist(lctx, czone, &pubkeylist);
+		iresult = dns_c_zone_getpubkeylist(czone, &pubkeylist);
 		if (iresult == ISC_R_SUCCESS) {
 			pubkey = ISC_LIST_HEAD(pubkeylist->keylist);
 		}
@@ -2520,29 +2520,29 @@ dns_zone_copy(isc_log_t *lctx, dns_c_ctx_t *ctx, dns_c_zone_t *czone,
 
 	case dns_c_zone_slave:
 		dns_zone_settype(zone, dns_zone_slave);
-		iresult = dns_c_zone_getfile(lctx, czone, &filename);
+		iresult = dns_c_zone_getfile(czone, &filename);
 		if (iresult != ISC_R_SUCCESS)
 			return (iresult);
 		result = dns_zone_setdatabase(zone, filename);
 		if (result != DNS_R_SUCCESS)
 			return (iresult);
 
-		iresult = dns_c_zone_getchecknames(lctx, czone, &severity);
+		iresult = dns_c_zone_getchecknames(czone, &severity);
 		if (iresult == ISC_R_SUCCESS)
 			dns_zone_setchecknames(zone, severity);
 		else
 			dns_zone_setchecknames(zone, dns_c_severity_warn);
 
-		iresult = dns_c_zone_getallowquery(lctx, czone, &acl);
+		iresult = dns_c_zone_getallowquery(czone, &acl);
 		if (iresult == ISC_R_SUCCESS) {
 			dns_zone_setqueryacl(zone, acl);
-			dns_c_ipmatchlist_detach(lctx, &acl);
+			dns_c_ipmatchlist_detach(&acl);
 		} else
 			dns_zone_clearqueryacl(zone);
 
 #if 1					/* XXX brister */
 		
-		iresult = dns_c_zone_getpubkeylist(lctx, czone, &pubkeylist);
+		iresult = dns_c_zone_getpubkeylist(czone, &pubkeylist);
 		if (iresult == ISC_R_SUCCESS) {
 			pubkey = ISC_LIST_HEAD(pubkeylist->keylist);
 		}
@@ -2558,12 +2558,12 @@ dns_zone_copy(isc_log_t *lctx, dns_c_ctx_t *ctx, dns_c_zone_t *czone,
 
 #endif
 		
-		iresult = dns_c_zone_getmasterport(lctx, czone, &port);
+		iresult = dns_c_zone_getmasterport(czone, &port);
 		if (iresult != ISC_R_SUCCESS)
 			port = 53;
 		dns_zone_setmasterport(zone, port);
 
-		iresult = dns_c_zone_getmasterips(lctx, czone, &iplist);
+		iresult = dns_c_zone_getmasterips(czone, &iplist);
 		if (iresult == ISC_R_SUCCESS) {
 			for (i = 0; i < iplist->nextidx; i++) {
 				result = dns_zone_addmaster(zone,
@@ -2574,13 +2574,13 @@ dns_zone_copy(isc_log_t *lctx, dns_c_ctx_t *ctx, dns_c_zone_t *czone,
 		} else 
 			dns_zone_clearmasters(zone);
 
-		iresult = dns_c_zone_getmaxtranstimein(lctx, czone, &xfrtime);
+		iresult = dns_c_zone_getmaxtranstimein(czone, &xfrtime);
 		if (result == ISC_R_SUCCESS)
 			zone->xfrtime = xfrtime;
 		else
 			zone->xfrtime = MAX_XFER_TIME;
 
-		iresult = dns_c_zone_gettransfersource(lctx, czone, &sockaddr);
+		iresult = dns_c_zone_gettransfersource(czone, &sockaddr);
 		if (iresult == ISC_R_SUCCESS)
 			zone->xfrsource = sockaddr;
 		else
@@ -2590,29 +2590,29 @@ dns_zone_copy(isc_log_t *lctx, dns_c_ctx_t *ctx, dns_c_zone_t *czone,
 
 	case dns_c_zone_stub:
 		dns_zone_settype(zone, dns_zone_stub);
-		iresult = dns_c_zone_getfile(lctx, czone, &filename);
+		iresult = dns_c_zone_getfile(czone, &filename);
 		if (iresult != ISC_R_SUCCESS)
 			return (iresult);
 		result = dns_zone_setdatabase(zone, filename);
 		if (result != DNS_R_SUCCESS)
 			return (iresult);
 
-		iresult = dns_c_zone_getchecknames(lctx, czone, &severity);
+		iresult = dns_c_zone_getchecknames(czone, &severity);
 		if (iresult == ISC_R_SUCCESS)
 			dns_zone_setchecknames(zone, severity);
 		else
 			dns_zone_setchecknames(zone, dns_c_severity_warn);
 
-		iresult = dns_c_zone_getallowquery(lctx, czone, &acl);
+		iresult = dns_c_zone_getallowquery(czone, &acl);
 		if (iresult == ISC_R_SUCCESS) {
 			dns_zone_setqueryacl(zone, acl);
-			dns_c_ipmatchlist_detach(lctx, &acl);
+			dns_c_ipmatchlist_detach(&acl);
 		} else
 			dns_zone_clearqueryacl(zone);
 
 #if 1					/* XXX brister */
 		
-		iresult = dns_c_zone_getpubkeylist(lctx, czone, &pubkeylist);
+		iresult = dns_c_zone_getpubkeylist(czone, &pubkeylist);
 		if (iresult == ISC_R_SUCCESS) {
 			pubkey = ISC_LIST_HEAD(pubkeylist->keylist);
 		}
@@ -2628,12 +2628,12 @@ dns_zone_copy(isc_log_t *lctx, dns_c_ctx_t *ctx, dns_c_zone_t *czone,
 
 #endif	
 
-		iresult = dns_c_zone_getmasterport(lctx, czone, &port);
+		iresult = dns_c_zone_getmasterport(czone, &port);
 		if (iresult != ISC_R_SUCCESS)
 			port = 53;
 		dns_zone_setmasterport(zone, port);
 
-		iresult = dns_c_zone_getmasterips(lctx, czone, &iplist);
+		iresult = dns_c_zone_getmasterips(czone, &iplist);
 		if (iresult == ISC_R_SUCCESS) {
 			for (i = 0; i < iplist->nextidx; i++) {
 				result = dns_zone_addmaster(zone,
@@ -2644,13 +2644,13 @@ dns_zone_copy(isc_log_t *lctx, dns_c_ctx_t *ctx, dns_c_zone_t *czone,
 		} else 
 			dns_zone_clearmasters(zone);
 
-		iresult = dns_c_zone_getmaxtranstimein(lctx, czone, &xfrtime);
+		iresult = dns_c_zone_getmaxtranstimein(czone, &xfrtime);
 		if (result == ISC_R_SUCCESS)
 			zone->xfrtime = xfrtime;
 		else
 			zone->xfrtime = MAX_XFER_TIME;
 
-		iresult = dns_c_zone_gettransfersource(lctx, czone, &sockaddr);
+		iresult = dns_c_zone_gettransfersource(czone, &sockaddr);
 		if (iresult == ISC_R_SUCCESS)
 			zone->xfrsource = sockaddr;
 		else
@@ -2660,14 +2660,14 @@ dns_zone_copy(isc_log_t *lctx, dns_c_ctx_t *ctx, dns_c_zone_t *czone,
 
 	case dns_c_zone_hint:
 		dns_zone_settype(zone, dns_zone_hint);
-		iresult = dns_c_zone_getfile(lctx, czone, &filename);
+		iresult = dns_c_zone_getfile(czone, &filename);
 		if (iresult != ISC_R_SUCCESS)
 			return (iresult);
 		result = dns_zone_setdatabase(zone, filename);
 		if (result != DNS_R_SUCCESS)
 			return (result);
 
-		iresult = dns_c_zone_getchecknames(lctx, czone, &severity);
+		iresult = dns_c_zone_getchecknames(czone, &severity);
 		if (iresult == ISC_R_SUCCESS)
 			dns_zone_setchecknames(zone, severity);
 		else
@@ -2675,7 +2675,7 @@ dns_zone_copy(isc_log_t *lctx, dns_c_ctx_t *ctx, dns_c_zone_t *czone,
 
 #if 1					/* XXX brister */
 		
-		iresult = dns_c_zone_getpubkeylist(lctx, czone, &pubkeylist);
+		iresult = dns_c_zone_getpubkeylist(czone, &pubkeylist);
 		if (iresult == ISC_R_SUCCESS) {
 			pubkey = ISC_LIST_HEAD(pubkeylist->keylist);
 		}
@@ -2704,10 +2704,8 @@ dns_zone_setqueryacl(dns_zone_t *zone, dns_c_ipmatchlist_t *acl) {
 
 	LOCK(&zone->lock);
 	if (zone->query_acl != NULL)
-		dns_c_ipmatchlist_detach(NULL /* isc_log_t */,
-					 &zone->query_acl);
-	dns_c_ipmatchlist_attach(NULL /* isc_log_t */,
-				 acl, &zone->query_acl);
+		dns_c_ipmatchlist_detach(&zone->query_acl);
+	dns_c_ipmatchlist_attach(acl, &zone->query_acl);
 	UNLOCK(&zone->lock);
 }
 
@@ -2718,10 +2716,8 @@ dns_zone_setupdateacl(dns_zone_t *zone, dns_c_ipmatchlist_t *acl) {
 
 	LOCK(&zone->lock);
 	if (zone->update_acl != NULL)
-		dns_c_ipmatchlist_detach(NULL /* isc_log_t */,
-					 &zone->update_acl);
-	dns_c_ipmatchlist_attach(NULL /* isc_log_t */,
-				 acl, &zone->update_acl);
+		dns_c_ipmatchlist_detach(&zone->update_acl);
+	dns_c_ipmatchlist_attach(acl, &zone->update_acl);
 	UNLOCK(&zone->lock);
 }
 
@@ -2732,10 +2728,8 @@ dns_zone_setxfracl(dns_zone_t *zone, dns_c_ipmatchlist_t *acl) {
 
 	LOCK(&zone->lock);
 	if (zone->xfr_acl != NULL)
-		dns_c_ipmatchlist_detach(NULL /* isc_log_t */,
-					 &zone->xfr_acl);
-	dns_c_ipmatchlist_attach(NULL /* isc_log_t */,
-				 acl, &zone->xfr_acl);
+		dns_c_ipmatchlist_detach(&zone->xfr_acl);
+	dns_c_ipmatchlist_attach(acl, &zone->xfr_acl);
 	UNLOCK(&zone->lock);
 }
 
@@ -2770,8 +2764,7 @@ dns_zone_clearupdateacl(dns_zone_t *zone) {
 
 	LOCK(&zone->lock);
 	if (zone->update_acl != NULL)
-		dns_c_ipmatchlist_detach(NULL /* isc_log_t */,
-					 &zone->update_acl);
+		dns_c_ipmatchlist_detach(&zone->update_acl);
 	UNLOCK(&zone->lock);
 }
 
@@ -2782,8 +2775,7 @@ dns_zone_clearqueryacl(dns_zone_t *zone) {
 
 	LOCK(&zone->lock);
 	if (zone->query_acl != NULL)
-		dns_c_ipmatchlist_detach(NULL /* isc_log_t */,
-					 &zone->query_acl);
+		dns_c_ipmatchlist_detach(&zone->query_acl);
 	UNLOCK(&zone->lock);
 }
 
@@ -2794,8 +2786,7 @@ dns_zone_clearxfracl(dns_zone_t *zone) {
 
 	LOCK(&zone->lock);
 	if (zone->xfr_acl != NULL)
-		dns_c_ipmatchlist_detach(NULL /* isc_log_t */,
-					 &zone->xfr_acl);
+		dns_c_ipmatchlist_detach(&zone->xfr_acl);
 	UNLOCK(&zone->lock);
 }