upstream/bind9
1
0
Fork 0
mirror of https://github.com/isc-projects/bind9.git synced 2026-06-11 07:40:00 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

Change config API to not take a isc_log_t but use dns_lctx extern.

Browse source
This commit is contained in:
James Brister 1999-12-06 12:40:39 +00:00
parent ce84c593e8
commit 1ce5dcf1c8
36 changed files with 1857 additions and 2725 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
bin/named/server.c
View file

@ -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();

8
bin/tests/nconf_test.c
View file

@ -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);

5
lib/dns/aml.c
View file

@ -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;

73
lib/dns/config/confacl.c
View file

@ -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;

8
lib/dns/config/confcache.c
View file

@ -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 */

76
lib/dns/config/confcommon.c
View file

@ -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;

41
lib/dns/config/confctl.c
View file

@ -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 */

1075
lib/dns/config/confctx.c
View file

File diff suppressed because it is too large Load diff

161
lib/dns/config/confip.c
View file

@ -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++) {

252
lib/dns/config/confkeys.c
View file

@ -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,

298
lib/dns/config/conflog.c
View file

@ -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);
}

32
lib/dns/config/conflsn.c
View file

@ -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);

506
lib/dns/config/confparser.y
View file

File diff suppressed because it is too large Load diff

8
lib/dns/config/confresolv.c
View file

@ -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);

54
lib/dns/config/confrrset.c
View file

@ -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);
}

76
lib/dns/config/confserv.c
View file

@ -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);

83
lib/dns/config/confview.c
View file

@ -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);

674
lib/dns/config/confzone.c
View file

File diff suppressed because it is too large Load diff

26
lib/dns/include/dns/confacl.h
View file

@ -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);
/*

5
lib/dns/include/dns/confcache.h
View file

@ -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.
*

60
lib/dns/include/dns/confcommon.h
View file

@ -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

20
lib/dns/include/dns/confctl.h
View file

@ -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

353
lib/dns/include/dns/confctx.h
View file

@ -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);

78
lib/dns/include/dns/confip.h
View file

@ -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);

118
lib/dns/include/dns/confkeys.h
View file

@ -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);

129
lib/dns/include/dns/conflog.h
View file

@ -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 */

18
lib/dns/include/dns/conflsn.h
View file

@ -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);

3
lib/dns/include/dns/confparser.h
View file

@ -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);

6
lib/dns/include/dns/confresolv.h
View file

@ -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.
*

21
lib/dns/include/dns/confrrset.h
View file

@ -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);

39
lib/dns/include/dns/confserv.h
View file

@ -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 */

32
lib/dns/include/dns/confview.h
View file

@ -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);
/*

120
lib/dns/include/dns/confzone.h
View file

@ -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);

8
lib/dns/tkey.c
View file

@ -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)

6
lib/dns/tsig.c
View file

@ -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)

103
lib/dns/zone.c
View file

@ -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);
}