- Change dns_zone_copy to use pubkey list.
- MAGIC-number related fixes and miscellaneous defensive programing issues.
allow-transfer { any; };
allow-query { any; };
max-transfer-time-in 120; // if not set, global option is used.
+ pubkey 257 255 1 "a useless key";
+ pubkey 257 255 1 "another useless key";
};
zone "." {
1.2.3.4;
5.6.7.8;
};
+ pubkey 666 665 664 "key of the beast";
};
key sample_key { // for TSIG; supported by parser
isc_mem_t *mem = NULL;
dns_c_cbks_t callbacks;
-#if 0
+#if 1
callbacks.zonecbk = NULL;
callbacks.zonecbkuap = NULL;
callbacks.optscbk = NULL;
#include <dns/confcommon.h>
-#define CONFACL_MAGIC 0x4361636cU
-#define CONFACLTABLE_MAGIC 0x32616354U
-
-#define DNS_CONFACL_VALID(confacl) ISC_MAGIC_VALID(confacl, CONFACL_MAGIC)
-#define DNS_CONFACLTABLE_VALID(confacltable) \
- ISC_MAGIC_VALID(confacltable, CONFACLTABLE_MAGIC)
-
static isc_result_t acl_delete(isc_log_t *lctx, dns_c_acl_t **aclptr);
}
table->mem = mem;
- table->magic = CONFACLTABLE_MAGIC;
+ table->magic = DNS_C_CONFACLTABLE_MAGIC;
ISC_LIST_INIT(table->acl_list);
acltable = *table;
- REQUIRE(DNS_CONFACLTABLE_VALID(acltable));
+ REQUIRE(DNS_C_CONFACLTABLE_VALID(acltable));
dns_c_acltable_clear(lctx, acltable);
return;
}
- REQUIRE(DNS_CONFACLTABLE_VALID(table));
+ REQUIRE(DNS_C_CONFACLTABLE_VALID(table));
acl = ISC_LIST_HEAD(table->acl_list);
while (acl != NULL) {
dns_c_acl_t *tmpelem;
isc_result_t r;
- REQUIRE(DNS_CONFACLTABLE_VALID(table));
+ REQUIRE(DNS_C_CONFACLTABLE_VALID(table));
elem = ISC_LIST_HEAD(table->acl_list);
while (elem != NULL) {
{
dns_c_acl_t *elem;
- REQUIRE(DNS_CONFACLTABLE_VALID(table));
+ REQUIRE(DNS_C_CONFACLTABLE_VALID(table));
REQUIRE(retval != NULL);
REQUIRE(aclname != NULL);
REQUIRE(strlen(aclname) > 0);
}
if (elem != NULL) {
- REQUIRE(DNS_CONFACL_VALID(elem));
+ REQUIRE(DNS_C_CONFACL_VALID(elem));
*retval = elem;
}
dns_c_acl_t *acl;
dns_c_acl_t *tmpacl;
- REQUIRE(DNS_CONFACLTABLE_VALID(table));
+ REQUIRE(DNS_C_CONFACLTABLE_VALID(table));
REQUIRE(aclname != NULL);
acl = ISC_LIST_HEAD(table->acl_list);
{
dns_c_acl_t *acl;
- REQUIRE(DNS_CONFACLTABLE_VALID(table));
+ REQUIRE(DNS_C_CONFACLTABLE_VALID(table));
REQUIRE(aclname != NULL);
REQUIRE(strlen(aclname) > 0);
REQUIRE(newacl != NULL);
}
acl->mytable = table;
- acl->magic = CONFACL_MAGIC;
+ acl->magic = DNS_C_CONFACL_MAGIC;
acl->name = NULL;
acl->ipml = NULL;
acl->is_special = isspecial;
dns_c_acl_print(isc_log_t *lctx,
FILE *fp, int indent, dns_c_acl_t *acl)
{
- REQUIRE(DNS_CONFACL_VALID(acl));
+ REQUIRE(DNS_C_CONFACL_VALID(acl));
dns_c_printtabs(lctx, fp, indent);
fprintf(fp, "acl ");
{
isc_result_t res;
- REQUIRE(DNS_CONFACL_VALID(acl));
+ REQUIRE(DNS_C_CONFACL_VALID(acl));
REQUIRE(ipml != NULL);
if (acl->ipml != NULL) {
dns_c_ipmatchlist_t *newlist;
isc_result_t r;
- REQUIRE(DNS_CONFACL_VALID(acl));
+ REQUIRE(DNS_C_CONFACL_VALID(acl));
if (acl->ipml == NULL) {
newlist = NULL;
isc_result_t r;
isc_boolean_t isneg;
- REQUIRE(DNS_CONFACLTABLE_VALID(table));
+ REQUIRE(DNS_C_CONFACLTABLE_VALID(table));
if (list == NULL) {
return (ISC_R_SUCCESS);
acl = *aclptr;
- REQUIRE(DNS_CONFACL_VALID(acl));
+ REQUIRE(DNS_C_CONFACL_VALID(acl));
mem = acl->mytable->mem;
#include <dns/confctl.h>
#include <dns/confcommon.h>
-#define CONFCTL_MAGIC 0x4363746cU
-#define CONFCTLLIST_MAGIC 0x4354424cU
-
-#define DNS_CONFCTLLIST_VALID(ctllist) \
- ISC_MAGIC_VALID(ctllist, CONFCTLLIST_MAGIC)
-#define DNS_CONFCTL_VALID(ctl) ISC_MAGIC_VALID(ctl, CONFCTL_MAGIC)
-
isc_result_t
dns_c_ctrllist_new(isc_log_t *lctx,
}
newl->mem = mem;
- newl->magic = CONFCTLLIST_MAGIC;
+ newl->magic = DNS_C_CONFCTLLIST_MAGIC;
ISC_LIST_INIT(newl->elements);
return;
}
- REQUIRE(DNS_CONFCTLLIST_VALID(cl));
+ REQUIRE(DNS_C_CONFCTLLIST_VALID(cl));
if (ISC_LIST_EMPTY(cl->elements)) {
return;
clist = *list;
- REQUIRE(DNS_CONFCTLLIST_VALID(clist));
+ REQUIRE(DNS_C_CONFCTLLIST_VALID(clist));
ctrl = ISC_LIST_HEAD(clist->elements);
while (ctrl != NULL) {
return (ISC_R_NOMEMORY);
}
- ctrl->magic = CONFCTL_MAGIC;
+ ctrl->magic = DNS_C_CONFCTL_MAGIC;
ctrl->mem = mem;
ctrl->control_type = dns_c_inet_control;
ctrl->u.inet_v.addr = addr;
return (ISC_R_NOMEMORY);
}
- ctrl->magic = CONFCTL_MAGIC;
+ ctrl->magic = DNS_C_CONFCTL_MAGIC;
ctrl->mem = mem;
ctrl->control_type = dns_c_unix_control;
ctrl->u.unix_v.pathname = isc_mem_strdup(mem, path);
ctrl = *control;
- REQUIRE(DNS_CONFCTL_VALID(ctrl));
+ REQUIRE(DNS_C_CONFCTL_VALID(ctrl));
mem = ctrl->mem;
short port;
dns_c_ipmatchlist_t *iml;
- REQUIRE(DNS_CONFCTL_VALID(ctl));
+ REQUIRE(DNS_C_CONFCTL_VALID(ctl));
(void) indent;
-#define CONFIG_MAGIC 0x434f4e46U /* CONF */
-#define OPTION_MAGIC 0x4f707473U /* Opts */
-
-#define DNS_CONFCTX_VALID(ctx) ISC_MAGIC_VALID(ctx, CONFIG_MAGIC)
-#define DNS_CONFOPT_VALID(opt) ISC_MAGIC_VALID(opt, OPTION_MAGIC)
-
/*
* Bit positions in the flags fields of the dns_c_options_t structure.
*/
return (ISC_R_NOMEMORY);
}
- cfg->magic = CONFIG_MAGIC;
+ cfg->magic = DNS_C_CONFIG_MAGIC;
cfg->mem = mem;
cfg->warnings = 0;
cfg->errors = 0;
REQUIRE(cfg != NULL);
REQUIRE(*cfg != NULL);
- REQUIRE(DNS_CONFCTX_VALID(*cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(*cfg));
c = *cfg;
{
(void) lctx;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
cfg->currzone = zone; /* zone may be NULL */
{
(void) lctx;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
return (cfg->currzone);
}
{
(void) lctx;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
cfg->currview = view;
{
(void) lctx;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
return (cfg->currview);
}
FILE *fp, int indent, dns_c_ctx_t *cfg)
{
REQUIRE(fp != NULL);
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
- dns_c_logginglist_print(lctx, fp, indent, cfg->logging, ISC_FALSE);
- fprintf(fp,"\n");
+ if (cfg->logging != NULL) {
+ dns_c_logginglist_print(lctx, fp, indent,
+ cfg->logging, ISC_FALSE);
+ fprintf(fp,"\n");
+ }
+
+
+ if (cfg->keydefs != NULL) {
+ dns_c_kdeflist_print(lctx, fp, indent, cfg->keydefs);
+ fprintf(fp, "\n");
+ }
- dns_c_kdeflist_print(lctx, fp, indent, cfg->keydefs);
- fprintf(fp, "\n");
- dns_c_tkeylist_print(lctx, fp, indent, cfg->trusted_keys);
- fprintf(fp, "\n");
+ if (cfg->trusted_keys != NULL) {
+ dns_c_tkeylist_print(lctx, fp, indent, cfg->trusted_keys);
+ fprintf(fp, "\n");
+ }
+
- dns_c_acltable_print(lctx, fp, indent, cfg->acls);
- fprintf(fp,"\n");
+ if (cfg->acls != NULL) {
+ dns_c_acltable_print(lctx, fp, indent, cfg->acls);
+ fprintf(fp,"\n");
+ }
+
- dns_c_zonelist_printpreopts(lctx, fp, indent, cfg->zlist);
- fprintf(fp, "\n");
+ if (cfg->zlist != NULL) {
+ dns_c_zonelist_printpreopts(lctx, fp, indent, cfg->zlist);
+ fprintf(fp, "\n");
+ }
+
+
+ if (cfg->options != NULL) {
+ dns_c_ctx_optionsprint(lctx, fp, indent, cfg->options);
+ fprintf(fp,"\n");
+ }
- dns_c_ctx_optionsprint(lctx, fp, indent, cfg->options);
- fprintf(fp,"\n");
- dns_c_zonelist_printpostopts(lctx, fp, indent, cfg->zlist);
- fprintf(fp, "\n");
+ if (cfg->zlist != NULL) {
+ dns_c_zonelist_printpostopts(lctx, fp, indent, cfg->zlist);
+ fprintf(fp, "\n");
+ }
- dns_c_viewtable_print(lctx, fp, indent, cfg->views);
- fprintf(fp, "\n");
+ if (cfg->views != NULL) {
+ dns_c_viewtable_print(lctx, fp, indent, cfg->views);
+ fprintf(fp, "\n");
+ }
+
+
+ if (cfg->controls != NULL) {
+ dns_c_ctrllist_print(lctx, fp, indent, cfg->controls);
+ fprintf(fp, "\n");
+ }
- dns_c_ctrllist_print(lctx, fp, indent, cfg->controls);
- fprintf(fp, "\n");
- dns_c_srvlist_print(lctx, fp, indent, cfg->servers);
- fprintf(fp, "\n");
+ if (cfg->servers != NULL) {
+ dns_c_srvlist_print(lctx, fp, indent, cfg->servers);
+ fprintf(fp, "\n");
+ }
}
return;
}
- REQUIRE(DNS_CONFOPT_VALID(options));
+ REQUIRE(DNS_C_CONFOPT_VALID(options));
if (DNS_C_CHECKBIT(FORWARD_BIT, &options->setflags1)) {
dns_c_printtabs(lctx, fp, indent);
{
(void) lctx;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
REQUIRE(options != NULL);
if (cfg->options != NULL) {
- REQUIRE(DNS_CONFOPT_VALID(cfg->options));
+ REQUIRE(DNS_C_CONFOPT_VALID(cfg->options));
}
*options = cfg->options;
{
(void) lctx;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
*retval = cfg->logging;
isc_result_t res;
isc_boolean_t existed;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
existed = ISC_TF(cfg->logging != NULL);
{
(void)(lctx);
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
REQUIRE(retval != NULL);
*retval = cfg->keydefs;
{
isc_result_t res;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
if (cfg->keydefs != NULL) {
dns_c_kdeflist_delete(lctx, &cfg->keydefs);
dns_c_logchan_t *newc;
isc_result_t res;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
REQUIRE(name != NULL);
REQUIRE(chan != NULL);
REQUIRE(cfg->logging != NULL);
dns_c_logchan_t *newc;
isc_result_t res;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
REQUIRE(name != NULL);
REQUIRE(chan != NULL);
REQUIRE(cfg->logging != NULL);
dns_c_logchan_t *newc;
isc_result_t res;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
REQUIRE(name != NULL);
REQUIRE(chan != NULL);
REQUIRE(cfg->logging != NULL);
dns_c_logcat_t *newc;
isc_result_t res;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
REQUIRE(newcat != NULL);
REQUIRE(cfg->logging != NULL);
(void)lctx;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
REQUIRE(channel != NULL);
REQUIRE(cfg->logging != NULL);
isc_result_t res;
dns_c_logchan_t *chan;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
REQUIRE(name != NULL);
REQUIRE(strlen(name) > 0);
dns_c_logginglist_t *llist;
isc_result_t res;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
REQUIRE(category != NULL);
res = dns_c_ctx_getlogging(lctx, cfg, &llist);
{
isc_result_t res;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
res = make_options(lctx, cfg);
if (res != ISC_R_SUCCESS) {
{
isc_result_t res;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
res = make_options(lctx, cfg);
if (res != ISC_R_SUCCESS) {
{
isc_result_t res;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
res = make_options(lctx, cfg);
if (res != ISC_R_SUCCESS) {
{
isc_result_t res;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
res = make_options(lctx, cfg);
if (res != ISC_R_SUCCESS) {
{
isc_result_t res;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
res = make_options(lctx, cfg);
if (res != ISC_R_SUCCESS) {
{
isc_result_t res;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
res = make_options(lctx, cfg);
if (res != ISC_R_SUCCESS) {
{
isc_result_t res;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
res = make_options(lctx, cfg);
if (res != ISC_R_SUCCESS) {
{
isc_result_t res;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
res = make_options(lctx, cfg);
if (res != ISC_R_SUCCESS) {
{
isc_result_t res;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
res = make_options(lctx, cfg);
if (res != ISC_R_SUCCESS) {
{
isc_result_t res;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
res = make_options(lctx, cfg);
if (res != ISC_R_SUCCESS) {
{
isc_result_t res;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
res = make_options(lctx, cfg);
if (res != ISC_R_SUCCESS) {
{
isc_result_t res;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
res = make_options(lctx, cfg);
if (res != ISC_R_SUCCESS) {
{
isc_result_t res;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
res = make_options(lctx, cfg);
if (res != ISC_R_SUCCESS) {
{
isc_result_t res;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
res = make_options(lctx, cfg);
if (res != ISC_R_SUCCESS) {
{
isc_result_t res;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
res = make_options(lctx, cfg);
if (res != ISC_R_SUCCESS) {
{
isc_result_t res;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
res = make_options(lctx, cfg);
if (res != ISC_R_SUCCESS) {
{
isc_result_t res;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
res = make_options(lctx, cfg);
if (res != ISC_R_SUCCESS) {
{
isc_result_t res;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
res = make_options(lctx, cfg);
if (res != ISC_R_SUCCESS) {
{
isc_result_t res;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
res = make_options(lctx, cfg);
if (res != ISC_R_SUCCESS) {
{
isc_result_t res;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
res = make_options(lctx, cfg);
if (res != ISC_R_SUCCESS) {
{
isc_result_t res;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
res = make_options(lctx, cfg);
if (res != ISC_R_SUCCESS) {
{
isc_result_t res;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
res = make_options(lctx, cfg);
if (res != ISC_R_SUCCESS) {
{
isc_result_t res;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
res = make_options(lctx, cfg);
if (res != ISC_R_SUCCESS) {
{
isc_result_t res;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
res = make_options(lctx, cfg);
if (res != ISC_R_SUCCESS) {
{
isc_result_t res;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
res = make_options(lctx, cfg);
if (res != ISC_R_SUCCESS) {
{
isc_result_t res;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
res = make_options(lctx, cfg);
if (res != ISC_R_SUCCESS) {
{
isc_result_t res;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
res = make_options(lctx, cfg);
if (res != ISC_R_SUCCESS) {
{
isc_result_t res;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
res = make_options(lctx, cfg);
if (res != ISC_R_SUCCESS) {
{
isc_result_t res;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
res = make_options(lctx, cfg);
if (res != ISC_R_SUCCESS) {
{
isc_result_t res;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
res = make_options(lctx, cfg);
if (res != ISC_R_SUCCESS) {
{
isc_result_t res;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
res = make_options(lctx, cfg);
if (res != ISC_R_SUCCESS) {
{
isc_result_t res;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
res = make_options(lctx, cfg);
if (res != ISC_R_SUCCESS) {
{
isc_result_t res;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
res = make_options(lctx, cfg);
if (res != ISC_R_SUCCESS) {
{
isc_result_t res;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
res = make_options(lctx, cfg);
if (res != ISC_R_SUCCESS) {
{
isc_result_t res;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
res = make_options(lctx, cfg);
if (res != ISC_R_SUCCESS) {
{
isc_result_t res;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
res = make_options(lctx, cfg);
if (res != ISC_R_SUCCESS) {
{
isc_result_t res;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
res = make_options(lctx, cfg);
if (res != ISC_R_SUCCESS) {
{
isc_result_t res;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
res = make_options(lctx, cfg);
if (res != ISC_R_SUCCESS) {
isc_boolean_t existed;
isc_result_t res;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
res = make_options(lctx, cfg);
if (res != ISC_R_SUCCESS) {
isc_boolean_t existed;
isc_result_t res;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
res = make_options(lctx, cfg);
if (res != ISC_R_SUCCESS) {
isc_boolean_t existed;
isc_result_t res;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
res = make_options(lctx, cfg);
if (res != ISC_R_SUCCESS) {
isc_boolean_t existed = ISC_FALSE;
isc_result_t res;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
res = make_options(lctx, cfg);
if (res != ISC_R_SUCCESS) {
{
isc_result_t res;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
res = make_options(lctx, cfg);
if (res != ISC_R_SUCCESS) {
{
isc_result_t res;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
res = make_options(lctx, cfg);
if (res != ISC_R_SUCCESS) {
{
isc_result_t res;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
res = make_options(lctx, cfg);
if (res != ISC_R_SUCCESS) {
{
isc_result_t res;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
res = make_options(lctx, cfg);
if (res != ISC_R_SUCCESS) {
{
isc_result_t res;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
res = make_options(lctx, cfg);
if (res != ISC_R_SUCCESS) {
{
isc_result_t res;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
res = make_options(lctx, cfg);
if (res != ISC_R_SUCCESS) {
isc_boolean_t existed;
isc_result_t res;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
res = make_options(lctx, cfg);
if (res != ISC_R_SUCCESS) {
{
isc_result_t res;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
res = make_options(lctx, cfg);
if (res != ISC_R_SUCCESS) {
dns_c_options_t *opts;
isc_result_t res;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
res = make_options(lctx, cfg);
if (res != ISC_R_SUCCESS) {
isc_result_t res;
dns_c_options_t *opts;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
REQUIRE(port >= 0 && port <= 65535);
res = make_options(lctx, cfg);
dns_c_tkeylist_t *newl;
isc_result_t res;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
existed = (cfg->trusted_keys == NULL ? ISC_FALSE : ISC_TRUE);
(void)lctx;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
REQUIRE(retval != NULL);
if (cfg->options == NULL) {
return (ISC_R_NOTFOUND);
}
- REQUIRE(DNS_CONFOPT_VALID(cfg->options));
+ REQUIRE(DNS_C_CONFOPT_VALID(cfg->options));
*retval = cfg->options->directory;
(void)lctx;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
REQUIRE(retval != NULL);
if (cfg->options == NULL) {
return (ISC_R_NOTFOUND);
}
- REQUIRE(DNS_CONFOPT_VALID(cfg->options));
+ REQUIRE(DNS_C_CONFOPT_VALID(cfg->options));
*retval = cfg->options->version;
(void)lctx;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
REQUIRE(retval != NULL);
if (cfg->options == NULL) {
return (ISC_R_NOTFOUND);
}
- REQUIRE(DNS_CONFOPT_VALID(cfg->options));
+ REQUIRE(DNS_C_CONFOPT_VALID(cfg->options));
*retval = cfg->options->dump_filename;
(void)lctx;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
REQUIRE(retval != NULL);
if (cfg->options == NULL) {
return (ISC_R_NOTFOUND);
}
- REQUIRE(DNS_CONFOPT_VALID(cfg->options));
+ REQUIRE(DNS_C_CONFOPT_VALID(cfg->options));
*retval = cfg->options->pid_filename;
(void)lctx;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
REQUIRE(retval != NULL);
if (cfg->options == NULL) {
return (ISC_R_NOTFOUND);
}
- REQUIRE(DNS_CONFOPT_VALID(cfg->options));
+ REQUIRE(DNS_C_CONFOPT_VALID(cfg->options));
*retval = cfg->options->stats_filename;
{
(void) lctx;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
REQUIRE(retval != NULL);
if (cfg->options == NULL) {
return (ISC_R_NOTFOUND);
}
- REQUIRE(DNS_CONFOPT_VALID(cfg->options));
+ REQUIRE(DNS_C_CONFOPT_VALID(cfg->options));
*retval = cfg->options->memstats_filename;
{
(void) lctx;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
REQUIRE(retval != NULL);
if (cfg->options == NULL) {
return (ISC_R_NOTFOUND);
}
- REQUIRE(DNS_CONFOPT_VALID(cfg->options));
+ REQUIRE(DNS_C_CONFOPT_VALID(cfg->options));
*retval = cfg->options->named_xfer;
{
(void) lctx;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
REQUIRE(retval != NULL);
if (cfg->options == NULL) {
return (ISC_R_NOTFOUND);
}
- REQUIRE(DNS_CONFOPT_VALID(cfg->options));
+ REQUIRE(DNS_C_CONFOPT_VALID(cfg->options));
*retval = cfg->options->tkeydomain;
(void) lctx;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
REQUIRE(charpval != NULL);
REQUIRE(intval != NULL);
return (ISC_R_NOTFOUND);
}
- REQUIRE(DNS_CONFOPT_VALID(cfg->options));
+ REQUIRE(DNS_C_CONFOPT_VALID(cfg->options));
if (cfg->options->tkeydhkeycp == NULL) {
res = ISC_R_NOTFOUND;
dns_c_ctx_getmaxncachettl(isc_log_t *lctx,
dns_c_ctx_t *cfg, isc_uint32_t *retval)
{
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
REQUIRE(retval != NULL);
if (cfg->options == NULL) {
return (ISC_R_NOTFOUND);
}
- REQUIRE(DNS_CONFOPT_VALID(cfg->options));
+ REQUIRE(DNS_C_CONFOPT_VALID(cfg->options));
return (cfg_get_uint32(lctx, cfg->options,
&cfg->options->max_ncache_ttl,
dns_c_ctx_gettransfersin(isc_log_t *lctx,
dns_c_ctx_t *cfg, isc_int32_t *retval)
{
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
REQUIRE(retval != NULL);
if (cfg->options == NULL) {
return (ISC_R_NOTFOUND);
}
- REQUIRE(DNS_CONFOPT_VALID(cfg->options));
+ REQUIRE(DNS_C_CONFOPT_VALID(cfg->options));
return (cfg_get_int32(lctx, cfg->options,
dns_c_ctx_gettransfersperns(isc_log_t *lctx,
dns_c_ctx_t *cfg, isc_int32_t *retval)
{
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
REQUIRE(retval != NULL);
if (cfg->options == NULL) {
return (ISC_R_NOTFOUND);
}
- REQUIRE(DNS_CONFOPT_VALID(cfg->options));
+ REQUIRE(DNS_C_CONFOPT_VALID(cfg->options));
return (cfg_get_int32(lctx, cfg->options,
&cfg->options->transfers_per_ns,
dns_c_ctx_gettransfersout(isc_log_t *lctx,
dns_c_ctx_t *cfg, isc_int32_t *retval)
{
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
REQUIRE(retval != NULL);
if (cfg->options == NULL) {
return (ISC_R_NOTFOUND);
}
- REQUIRE(DNS_CONFOPT_VALID(cfg->options));
+ REQUIRE(DNS_C_CONFOPT_VALID(cfg->options));
return (cfg_get_int32(lctx, cfg->options,
&cfg->options->transfers_out,
dns_c_ctx_getmaxlogsizeixfr(isc_log_t *lctx,
dns_c_ctx_t *cfg, isc_int32_t *retval)
{
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
REQUIRE(retval != NULL);
if (cfg->options == NULL) {
return (ISC_R_NOTFOUND);
}
- REQUIRE(DNS_CONFOPT_VALID(cfg->options));
+ REQUIRE(DNS_C_CONFOPT_VALID(cfg->options));
return (cfg_get_int32(lctx, cfg->options,
&cfg->options->max_log_size_ixfr,
dns_c_ctx_getcleaninterval(isc_log_t *lctx,
dns_c_ctx_t *cfg, isc_int32_t *retval)
{
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
REQUIRE(retval != NULL);
if (cfg->options == NULL) {
return (ISC_R_NOTFOUND);
}
- REQUIRE(DNS_CONFOPT_VALID(cfg->options));
+ REQUIRE(DNS_C_CONFOPT_VALID(cfg->options));
return (cfg_get_int32(lctx, cfg->options,
&cfg->options->clean_interval,
dns_c_ctx_getinterfaceinterval(isc_log_t *lctx,
dns_c_ctx_t *cfg, isc_int32_t *retval)
{
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
REQUIRE(retval != NULL);
if (cfg->options == NULL) {
dns_c_ctx_getstatsinterval(isc_log_t *lctx,
dns_c_ctx_t *cfg, isc_int32_t *retval)
{
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
REQUIRE(retval != NULL);
if (cfg->options == NULL) {
dns_c_ctx_getheartbeatinterval(isc_log_t *lctx,
dns_c_ctx_t *cfg, isc_int32_t *retval)
{
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
REQUIRE(retval != NULL);
if (cfg->options == NULL) {
dns_c_ctx_getmaxtransfertimein(isc_log_t *lctx,
dns_c_ctx_t *cfg, isc_int32_t *retval)
{
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
REQUIRE(retval != NULL);
if (cfg->options == NULL) {
dns_c_ctx_getdatasize(isc_log_t *lctx,
dns_c_ctx_t *cfg, isc_uint32_t *retval)
{
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
REQUIRE(retval != NULL);
if (cfg->options == NULL) {
dns_c_ctx_getstacksize(isc_log_t *lctx,
dns_c_ctx_t *cfg, isc_uint32_t *retval)
{
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
REQUIRE(retval != NULL);
if (cfg->options == NULL) {
dns_c_ctx_getcoresize(isc_log_t *lctx,
dns_c_ctx_t *cfg, isc_uint32_t *retval)
{
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
REQUIRE(retval != NULL);
if (cfg->options == NULL) {
dns_c_ctx_getfiles(isc_log_t *lctx,
dns_c_ctx_t *cfg, isc_uint32_t *retval)
{
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
REQUIRE(retval != NULL);
if (cfg->options == NULL) {
dns_c_ctx_getfakeiquery(isc_log_t *lctx,
dns_c_ctx_t *cfg, isc_boolean_t *retval)
{
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
REQUIRE(retval != NULL);
if (cfg->options == NULL) {
dns_c_ctx_getrecursion(isc_log_t *lctx,
dns_c_ctx_t *cfg, isc_boolean_t *retval)
{
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
REQUIRE(retval != NULL);
if (cfg->options == NULL) {
dns_c_ctx_getfetchglue(isc_log_t *lctx,
dns_c_ctx_t *cfg, isc_boolean_t *retval)
{
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
REQUIRE(retval != NULL);
if (cfg->options == NULL) {
dns_c_ctx_getnotify(isc_log_t *lctx,
dns_c_ctx_t *cfg, isc_boolean_t *retval)
{
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
REQUIRE(retval != NULL);
if (cfg->options == NULL) {
dns_c_ctx_gethoststatistics(isc_log_t *lctx,
dns_c_ctx_t *cfg, isc_boolean_t *retval)
{
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
REQUIRE(retval != NULL);
if (cfg->options == NULL) {
dns_c_ctx_getdealloconexit(isc_log_t *lctx,
dns_c_ctx_t *cfg, isc_boolean_t *retval)
{
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
REQUIRE(retval != NULL);
if (cfg->options == NULL) {
dns_c_ctx_getuseixfr(isc_log_t *lctx,
dns_c_ctx_t *cfg, isc_boolean_t *retval)
{
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
REQUIRE(retval != NULL);
if (cfg->options == NULL) {
dns_c_ctx_getmaintainixfrbase(isc_log_t *lctx,
dns_c_ctx_t *cfg, isc_boolean_t *retval)
{
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
REQUIRE(retval != NULL);
if (cfg->options == NULL) {
dns_c_ctx_gethasoldclients(isc_log_t *lctx,
dns_c_ctx_t *cfg, isc_boolean_t *retval)
{
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
REQUIRE(retval != NULL);
if (cfg->options == NULL) {
dns_c_ctx_getauth_nx_domain(isc_log_t *lctx,
dns_c_ctx_t *cfg, isc_boolean_t *retval)
{
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
REQUIRE(retval != NULL);
if (cfg->options == NULL) {
dns_c_ctx_getmultiplecnames(isc_log_t *lctx,
dns_c_ctx_t *cfg, isc_boolean_t *retval)
{
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
REQUIRE(retval != NULL);
if (cfg->options == NULL) {
dns_c_ctx_getuseidpool(isc_log_t *lctx,
dns_c_ctx_t *cfg, isc_boolean_t *retval)
{
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
REQUIRE(retval != NULL);
if (cfg->options == NULL) {
dns_c_ctx_getrfc2308type1(isc_log_t *lctx,
dns_c_ctx_t *cfg, isc_boolean_t *retval)
{
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
REQUIRE(retval != NULL);
if (cfg->options == NULL) {
dns_c_ctx_getdialup(isc_log_t *lctx,
dns_c_ctx_t *cfg, isc_boolean_t *retval)
{
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
REQUIRE(retval != NULL);
if (cfg->options == NULL) {
(void) lctx;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
if (cfg->options == NULL) {
return (ISC_R_NOTFOUND);
{
(void) lctx;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
if (cfg->options == NULL) {
return (ISC_R_NOTFOUND);
{
(void) lctx;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
REQUIRE(retval != NULL);
if (cfg->options == NULL) {
isc_boolean_t isset = ISC_FALSE;
isc_result_t res;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
if (cfg->options == NULL) {
return (ISC_R_NOTFOUND);
dns_c_ctx_getqueryacl(isc_log_t *lctx,
dns_c_ctx_t *cfg, dns_c_ipmatchlist_t **list)
{
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
if (cfg->options == NULL) {
return (ISC_R_NOTFOUND);
dns_c_ctx_gettransferacl(isc_log_t *lctx,
dns_c_ctx_t *cfg, dns_c_ipmatchlist_t **list)
{
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
if (cfg->options == NULL) {
return (ISC_R_NOTFOUND);
dns_c_ctx_getrecursionacl(isc_log_t *lctx,
dns_c_ctx_t *cfg, dns_c_ipmatchlist_t **list)
{
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
if (cfg->options == NULL) {
return (ISC_R_NOTFOUND);
dns_c_ctx_getblackhole(isc_log_t *lctx,
dns_c_ctx_t *cfg, dns_c_ipmatchlist_t **list)
{
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
if (cfg->options == NULL) {
return (ISC_R_NOTFOUND);
dns_c_ctx_gettopology(isc_log_t *lctx,
dns_c_ctx_t *cfg, dns_c_ipmatchlist_t **list)
{
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
if (cfg->options == NULL) {
return (ISC_R_NOTFOUND);
dns_c_ctx_getsortlist(isc_log_t *lctx,
dns_c_ctx_t *cfg, dns_c_ipmatchlist_t **list)
{
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
if (cfg->options == NULL) {
return (ISC_R_NOTFOUND);
{
(void) lctx;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
if (cfg->options == NULL) {
return (ISC_R_NOTFOUND);
(void) lctx;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
if (cfg->options == NULL) {
return (ISC_R_NOTFOUND);
dns_c_ctx_getforwarders(isc_log_t *lctx,
dns_c_ctx_t *cfg, dns_c_ipmatchlist_t **list)
{
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
if (cfg->options == NULL) {
return (ISC_R_NOTFOUND);
{
(void) lctx;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
REQUIRE(retval != NULL);
if (cfg->options == NULL || cfg->options->ordering == NULL) {
{
(void) lctx;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
REQUIRE(retval != NULL);
if (cfg->trusted_keys == NULL) {
opts->tkeydhkeyi = 0;
opts->mem = mem;
- opts->magic = OPTION_MAGIC;
+ opts->magic = DNS_C_OPTION_MAGIC;
opts->flags = 0;
opts->max_ncache_ttl = 0;
return (ISC_R_SUCCESS);
}
- REQUIRE(DNS_CONFOPT_VALID(options));
+ REQUIRE(DNS_C_CONFOPT_VALID(options));
if (options->directory != NULL) {
isc_mem_free(options->mem, options->directory);
return;
}
- REQUIRE(DNS_CONFOPT_VALID(options));
+ REQUIRE(DNS_C_CONFOPT_VALID(options));
#define PRINT_INTEGER(field, bit, name, bitfield) \
if (DNS_C_CHECKBIT(bit, &options->bitfield)) { \
fprintf(fp, ";\n");
}
- dns_c_lstnlist_print(lctx, fp, indent + 1, options->listens);
-
+ if (options->listens != NULL) {
+ dns_c_lstnlist_print(lctx, fp, indent + 1,
+ options->listens);
+ }
+
dns_c_ctx_forwarderprint(lctx, fp, indent + 1, options);
- dns_c_rrsolist_print(lctx, fp, indent + 1, options->ordering);
+ if (options->ordering != NULL) {
+ dns_c_rrsolist_print(lctx, fp, indent + 1, options->ordering);
+ }
+
dns_c_printtabs(lctx, fp, indent);
fprintf(fp,"};\n");
isc_result_t res;
isc_boolean_t rval = ISC_FALSE;
- REQUIRE(DNS_CONFCTX_VALID(ctx));
+ REQUIRE(DNS_C_CONFCTX_VALID(ctx));
REQUIRE(keyname != NULL);
REQUIRE(strlen(keyname) > 0);
(void) lctx;
- REQUIRE(DNS_CONFOPT_VALID(options));
+ REQUIRE(DNS_C_CONFOPT_VALID(options));
REQUIRE(field != NULL);
p = *field;
isc_result_t res;
isc_boolean_t existed = ISC_FALSE;
- REQUIRE(DNS_CONFOPT_VALID(options));
+ REQUIRE(DNS_C_CONFOPT_VALID(options));
REQUIRE(fieldaddr != NULL);
if (*fieldaddr != NULL) {
(void) lctx;
- REQUIRE(DNS_CONFOPT_VALID(options));
+ REQUIRE(DNS_C_CONFOPT_VALID(options));
REQUIRE(setfield != NULL);
REQUIRE(fieldaddr != NULL);
REQUIRE(bitnumber < DNS_C_SETBITS_SIZE);
(void) lctx;
- REQUIRE(DNS_CONFOPT_VALID(options));
+ REQUIRE(DNS_C_CONFOPT_VALID(options));
REQUIRE(setfield != NULL);
REQUIRE(fieldaddr != NULL);
REQUIRE(bitnumber < DNS_C_SETBITS_SIZE);
(void) lctx;
- REQUIRE(DNS_CONFOPT_VALID(options));
+ REQUIRE(DNS_C_CONFOPT_VALID(options));
REQUIRE(setfield != NULL);
REQUIRE(fieldaddr != NULL);
REQUIRE(bitnumber < DNS_C_SETBITS_SIZE);
(void) lctx;
- REQUIRE(DNS_CONFOPT_VALID(options));
+ REQUIRE(DNS_C_CONFOPT_VALID(options));
REQUIRE(resval != NULL);
if (field != NULL && !ISC_LIST_EMPTY(field->elements)) {
(void) lctx;
- REQUIRE(DNS_CONFOPT_VALID(options));
+ REQUIRE(DNS_C_CONFOPT_VALID(options));
REQUIRE(result != NULL);
REQUIRE(field != NULL);
REQUIRE(setfield != NULL);
(void) lctx;
- REQUIRE(DNS_CONFOPT_VALID(options));
+ REQUIRE(DNS_C_CONFOPT_VALID(options));
REQUIRE(result != NULL);
REQUIRE(field != NULL);
REQUIRE(setfield != NULL);
(void) lctx;
- REQUIRE(DNS_CONFOPT_VALID(options));
+ REQUIRE(DNS_C_CONFOPT_VALID(options));
REQUIRE(result != NULL);
REQUIRE(field != NULL);
REQUIRE(setfield != NULL);
isc_result_t r;
static struct in_addr zeroaddr;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
isc_sockaddr_fromin(&addr, &zeroaddr, 0);
dns_c_logcat_t *cat;
dns_c_logchan_t *chan;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
REQUIRE(cfg->logging == NULL);
res = dns_c_logginglist_new(lctx, cfg->mem, &cfg->logging);
make_options(isc_log_t *lctx, dns_c_ctx_t *cfg)
{
isc_result_t res = ISC_R_SUCCESS;
- REQUIRE(DNS_CONFCTX_VALID(cfg));
+ REQUIRE(DNS_C_CONFCTX_VALID(cfg));
if (cfg->options == NULL) {
res = dns_c_ctx_optionsnew(lctx, cfg->mem, &cfg->options);
}
}
- REQUIRE(DNS_CONFOPT_VALID(cfg->options));
+ REQUIRE(DNS_C_CONFOPT_VALID(cfg->options));
return (res);
}
#include <dns/confcommon.h>
#include <dns/log.h>
-#define IPLIST_MAGIC 0x49706c73 /* Ipls */ /* dns_c_iplist */
-#define IPMDIRECT_MAGIC 0x49506d64 /* IPmd */ /* dns_c_ipmatch_direct */
-#define IPMINDIRECT_MAGIC 0x69506d69 /* iPmi */ /* dns_c_ipmatch_indirect */
-#define IPMELEM_MAGIC 0x49704d65 /* IpMe */ /* dns_c_ipmatch_element */
-#define IPMLIST_MAGIC 0x69706d6c /* ipml */ /* dns_c_ipmatchlist */
-
-#define DNS_IPLIST_VALID(ipl) ISC_MAGIC_VALID(ipl,IPLIST_MAGIC)
-#define DNS_IPDIRECT_VALID(ipmld) ISC_MAGIC_VALID(ipmld, IPMDIRECT_MAGIC)
-#define DNS_IPINDIRECT_VALID(ipmlid) ISC_MAGIC_VALID(ipmlid, IPMINDIRECT_MAGIC)
-#define DNS_IPMELEM_VALID(impe) ISC_MAGIC_VALID(impe, IPMELEM_MAGIC)
-#define DNS_IPMLIST_VALID(ipml) ISC_MAGIC_VALID(ipml, IPMLIST_MAGIC)
-
-
/* Flag for dns_c_ipmatch_element */
#define DNS_C_IPMATCH_NEGATE 0x01 /* match means deny access */
return (ISC_R_NOMEMORY);
}
- ime->magic = IPMELEM_MAGIC;
+ ime->magic = DNS_C_IPMELEM_MAGIC;
ime->type = dns_c_ipmatch_none;
ime->flags = 0;
memset(&ime->u, 0x0, sizeof ime->u);
(void) lctx;
- REQUIRE(DNS_IPMELEM_VALID(elem));
+ REQUIRE(DNS_C_IPMELEM_VALID(elem));
return (ISC_TF((elem->flags & DNS_C_IPMATCH_NEGATE) ==
DNS_C_IPMATCH_NEGATE));
elem = *ipme;
- REQUIRE(DNS_IPMELEM_VALID(elem));
+ REQUIRE(DNS_C_IPMELEM_VALID(elem));
switch (elem->type) {
case dns_c_ipmatch_localhost:
REQUIRE(mem != NULL);
REQUIRE(dest != NULL);
- REQUIRE(DNS_IPMELEM_VALID(src));
+ REQUIRE(DNS_C_IPMELEM_VALID(src));
result = dns_c_ipmatchelement_new(lctx, mem, &newel);
if (result != ISC_R_SUCCESS) {
dns_c_ipmatchelement_equal(dns_c_ipmatchelement_t *e1,
dns_c_ipmatchelement_t *e2)
{
- REQUIRE(DNS_IPMELEM_VALID(e1));
- REQUIRE(DNS_IPMELEM_VALID(e2));
+ REQUIRE(DNS_C_IPMELEM_VALID(e1));
+ REQUIRE(DNS_C_IPMELEM_VALID(e2));
if ((e1->type != e2->type) || (e1->flags != e2->flags))
return (ISC_FALSE);
REQUIRE(mem != NULL);
REQUIRE(result != NULL);
- REQUIRE(DNS_IPMLIST_VALID(iml));
+ REQUIRE(DNS_C_IPMLIST_VALID(iml));
*result = NULL;
dns_c_ipmatch_negate(isc_log_t *lctx,
dns_c_ipmatchelement_t *ipe)
{
- REQUIRE(DNS_IPMELEM_VALID(ipe));
+ REQUIRE(DNS_C_IPMELEM_VALID(ipe));
(void) lctx;
return (ISC_R_NOMEMORY);
}
- newlist->magic = IPMLIST_MAGIC;
+ newlist->magic = DNS_C_IPMLIST_MAGIC;
newlist->mem = mem;
newlist->refcount = 1;
iml = *ml;
*ml = NULL;
- REQUIRE(DNS_IPMLIST_VALID(iml));
+ REQUIRE(DNS_C_IPMLIST_VALID(iml));
INSIST(iml->refcount > 0);
iml->refcount--;
(void) lctx;
- REQUIRE(DNS_IPMLIST_VALID(source));
+ REQUIRE(DNS_C_IPMLIST_VALID(source));
INSIST(source->refcount > 0);
dns_c_ipmatchelement_t *imptmp;
isc_result_t res = ISC_R_SUCCESS;
- REQUIRE(DNS_IPMLIST_VALID(ipml));
+ REQUIRE(DNS_C_IPMLIST_VALID(ipml));
ime = ISC_LIST_HEAD(ipml->elements);
while (ime != NULL) {
REQUIRE(mem != NULL);
REQUIRE(dest != NULL);
- REQUIRE(DNS_IPMLIST_VALID(src));
+ REQUIRE(DNS_C_IPMLIST_VALID(src));
*dest = NULL;
dns_c_ipmatchlist_equal(dns_c_ipmatchlist_t *l1, dns_c_ipmatchlist_t *l2) {
dns_c_ipmatchelement_t *e1, *e2;
- REQUIRE(l1 == NULL || DNS_IPMLIST_VALID(l1));
- REQUIRE(l2 == NULL || DNS_IPMLIST_VALID(l2));
+ REQUIRE(l1 == NULL || DNS_C_IPMLIST_VALID(l1));
+ REQUIRE(l2 == NULL || DNS_C_IPMLIST_VALID(l2));
if (l1 == NULL && l2 == NULL)
return (ISC_TRUE);
dns_c_ipmatchelement_t *ime_copy;
isc_result_t result = ISC_R_SUCCESS;
- REQUIRE(DNS_IPMLIST_VALID(dest));
- REQUIRE(DNS_IPMLIST_VALID(src));
+ REQUIRE(DNS_C_IPMLIST_VALID(dest));
+ REQUIRE(DNS_C_IPMLIST_VALID(src));
ime = ISC_LIST_HEAD(src->elements);
while (ime != NULL) {
int bits;
REQUIRE(fp != NULL);
- REQUIRE(DNS_IPMELEM_VALID(ipme));
+ REQUIRE(DNS_C_IPMELEM_VALID(ipme));
if ((ipme->flags & DNS_C_IPMATCH_NEGATE) == DNS_C_IPMATCH_NEGATE) {
fputc('!', fp);
{
dns_c_ipmatchelement_t *ipme ;
- REQUIRE(DNS_IPMLIST_VALID(ml));
+ REQUIRE(DNS_C_IPMLIST_VALID(ml));
REQUIRE(fp != NULL);
/* no indent on first line. */
memset(list->ips, 0x0, bytes);
- list->magic = IPLIST_MAGIC;
+ list->magic = DNS_C_IPLIST_MAGIC;
list->size = length;
list->nextidx = 0;
list->mem = mem;
l = *list;
- REQUIRE(DNS_IPLIST_VALID(l));
+ REQUIRE(DNS_C_IPLIST_VALID(l));
INSIST(l->refcount > 0);
l->refcount--;
{
(void) lctx;
- REQUIRE(DNS_IPLIST_VALID(source));
+ REQUIRE(DNS_C_IPLIST_VALID(source));
INSIST(source->refcount > 0);
source->refcount++;
isc_uint32_t i;
REQUIRE(dest != NULL);
- REQUIRE(DNS_IPLIST_VALID(src));
+ REQUIRE(DNS_C_IPLIST_VALID(src));
res = dns_c_iplist_new(lctx, mem, src->size, &newl);
if (res != ISC_R_SUCCESS) {
dns_c_iplist_equal(dns_c_iplist_t *list1, dns_c_iplist_t *list2) {
isc_uint32_t i;
- REQUIRE(DNS_IPLIST_VALID(list1));
- REQUIRE(DNS_IPLIST_VALID(list2));
+ REQUIRE(DNS_C_IPLIST_VALID(list1));
+ REQUIRE(DNS_C_IPLIST_VALID(list2));
if (list1->nextidx != list2->nextidx)
return (ISC_FALSE);
{
isc_uint32_t i;
- REQUIRE(DNS_IPLIST_VALID(list));
+ REQUIRE(DNS_C_IPLIST_VALID(list));
fprintf(fp, "{\n");
(void) lctx;
- REQUIRE(DNS_IPLIST_VALID(list));
+ REQUIRE(DNS_C_IPLIST_VALID(list));
for (i = 0 ; i < list->nextidx ; i++) {
if (memcmp(&list->ips[i], &newaddr, sizeof newaddr) == 0) {
(void) lctx;
- REQUIRE(DNS_IPLIST_VALID(list));
+ REQUIRE(DNS_C_IPLIST_VALID(list));
for (i = 0 ; i < list->nextidx ; i++) {
if (memcmp(&list->ips[0], &newaddr, sizeof newaddr) == 0) {
#include <string.h>
#include <isc/assertions.h>
+#include <isc/magic.h>
#include <dns/result.h>
-
#include <dns/confkeys.h>
#include <dns/confcommon.h>
static isc_result_t keyid_delete(isc_log_t *lctx, 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)
}
newlist->mem = mem;
+ newlist->magic = DNS_C_KDEFLIST_MAGIC;
+
ISC_LIST_INIT(newlist->keydefs);
*list = newlist;
isc_result_t res;
REQUIRE(list != NULL);
- REQUIRE(*list != NULL);
+ REQUIRE(DNS_C_KDEFLIST_VALID(*list));
l = *list;
}
kd = tmpkd;
}
-
+
+ l->magic = 0;
isc_mem_put(l->mem, l, sizeof *l);
*list = NULL;
isc_result_t res;
REQUIRE(dest != NULL);
- REQUIRE(src != NULL);
+ REQUIRE(DNS_C_KDEFLIST_VALID(src));
res = dns_c_kdeflist_new(lctx, mem, &newlist);
if (res != ISC_R_SUCCESS) {
dns_c_kdef_t *newe;
isc_result_t res;
- REQUIRE(list != NULL);
- REQUIRE(key != NULL);
+ REQUIRE(DNS_C_KDEFLIST_VALID(list));
+ REQUIRE(DNS_C_KDEF_VALID(key));
if (copy) {
res = dns_c_kdef_copy(lctx, list->mem, &newe, key);
dns_c_kdef_t *kd;
isc_result_t r;
- REQUIRE(list != NULL);
+ REQUIRE(DNS_C_KDEFLIST_VALID(list));
REQUIRE(keyid != NULL);
+ REQUIRE(strlen(keyid) > 0);
kd = ISC_LIST_HEAD(list->keydefs);
while (kd != NULL) {
(void)lctx;
- REQUIRE(list != NULL);
+ REQUIRE(DNS_C_KDEFLIST_VALID(list));
REQUIRE(keyid != NULL);
+ REQUIRE(strlen(keyid) > 0);
kd = ISC_LIST_HEAD(list->keydefs);
while (kd != NULL) {
REQUIRE(fp != NULL);
REQUIRE(indent >= 0);
+ REQUIRE(DNS_C_KDEFLIST_VALID(list));
if (list == NULL) {
return;
(void)lctx;
- REQUIRE(list != NULL);
+ REQUIRE(DNS_C_KDEFLIST_VALID(list));
+ REQUIRE(keyid != NULL);
+ REQUIRE(name != NULL);
+ REQUIRE(strlen(name) > 0);
kd = isc_mem_get(list->mem, sizeof *kd);
if (kd == NULL) {
if (kd->keyid == NULL) {
isc_mem_put(list->mem, kd, sizeof *kd);
}
-
+
+ kd->magic = DNS_C_KDEF_MAGIC;
kd->mylist = list;
kd->algorithm = NULL;
kd->secret = NULL;
(void)lctx;
REQUIRE(keydef != NULL);
- REQUIRE(*keydef != NULL);
+ REQUIRE(DNS_C_KDEF_VALID(*keydef));
kd = *keydef;
isc_mem_free(mem, kd->secret);
}
+ kd->magic = 0;
kd->keyid = NULL;
kd->mylist = NULL;
kd->algorithm = NULL;
dns_c_kdef_t *newk;
REQUIRE(dest != NULL);
- REQUIRE(src != NULL);
+ REQUIRE(DNS_C_KDEF_VALID(src));
newk = isc_mem_get(mem, sizeof *newk);
if (newk == NULL) {
return (ISC_R_NOMEMORY);
}
+ newk->magic = DNS_C_KDEF_MAGIC;
newk->secret = newk->algorithm = newk->keyid = NULL;
newk->keyid = isc_mem_strdup(mem, src->keyid);
const char *quote = "";
REQUIRE(fp != NULL);
- REQUIRE(keydef != NULL);
+ REQUIRE(DNS_C_KDEF_VALID(keydef));
if (dns_c_need_quote(lctx, keydef->keyid)) {
quote = "\"";
{
(void)lctx;
- REQUIRE(keydef != NULL);
+ REQUIRE(DNS_C_KDEF_VALID(keydef));
+ REQUIRE(algorithm != NULL);
+ REQUIRE(strlen(algorithm) > 0);
if (keydef->algorithm != NULL) {
isc_mem_free(keydef->mylist->mem, keydef->algorithm);
{
(void)lctx;
- REQUIRE(keydef != NULL);
-
+ REQUIRE(DNS_C_KDEF_VALID(keydef));
+ REQUIRE(secret != NULL);
+ REQUIRE(strlen(secret) > 0);
+
if (keydef->secret != NULL) {
isc_mem_free(keydef->mylist->mem, keydef->secret);
}
return (ISC_R_NOMEMORY);
}
+ l->magic = DNS_C_KEYIDLIST_MAGIC;
l->mem = mem;
*list = l;
isc_result_t r;
REQUIRE(list != NULL);
- REQUIRE(*list != NULL);
+ REQUIRE(DNS_C_KEYIDLIST_VALID(*list));
l = *list;
ki = tmpki;
}
+ l->magic = 0;
isc_mem_put(l->mem, l, sizeof *l);
*list = NULL;
(void)lctx;
REQUIRE(keyid != NULL);
- REQUIRE(*keyid != NULL);
+ REQUIRE(DNS_C_KEYID_VALID(*keyid));
ki = *keyid;
isc_mem_free(ki->mylist->mem, ki->keyid);
+
+ ki->magic = 0;
isc_mem_put(ki->mylist->mem, ki, sizeof *ki);
*keyid = NULL;
dns_c_kid_t *ki;
isc_result_t r;
+ REQUIRE(DNS_C_KEYIDLIST_VALID(list));
+ REQUIRE(keyid != NULL);
+ REQUIRE(strlen(keyid) > 0);
+
dns_c_kidlist_find(lctx, list, keyid, &ki);
if (ki != NULL) {
(void)lctx;
+ REQUIRE(DNS_C_KEYIDLIST_VALID(list));
+ REQUIRE(keyid != NULL);
+ REQUIRE(strlen(keyid) > 0);
REQUIRE(retval != NULL);
iter = ISC_LIST_HEAD(list->keyids);
const char *quote;
REQUIRE(fp != NULL);
- REQUIRE(list != NULL);
+ REQUIRE(DNS_C_KEYIDLIST_VALID(list));
if (ISC_LIST_EMPTY(list->keyids)) {
return;
(void)lctx;
- REQUIRE(list != NULL);
+ REQUIRE(DNS_C_KEYIDLIST_VALID(list));
+ REQUIRE(name != NULL);
+ REQUIRE(strlen(name) > 0);
+ REQUIRE(keyid != NULL);
ki = isc_mem_get(list->mem, sizeof *ki);
if (ki == NULL) {
return (ISC_R_NOMEMORY);
}
+ ki->magic = DNS_C_KEYID_MAGIC;
ki->mylist = list;
ki->keyid = isc_mem_strdup(list->mem, name);
return (ISC_R_SUCCESS);
}
+isc_result_t
+dns_c_pklist_new(isc_log_t *lctx, 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);
+ if (newl == NULL) {
+ return (ISC_R_NOMEMORY);
+ }
+
+ newl->mem = mem;
+ newl->magic = DNS_C_PKLIST_MAGIC;
+
+ ISC_LIST_INIT(newl->keylist);
+
+ *pklist = newl;
+
+ return (ISC_R_SUCCESS);
+}
+
+
+isc_result_t
+dns_c_pklist_delete(isc_log_t *lctx, dns_c_pklist_t **list)
+{
+ dns_c_pklist_t *l;
+ dns_c_pubkey_t *pk;
+ dns_c_pubkey_t *tmppk;
+ isc_result_t r;
+
+ REQUIRE(list != NULL);
+ REQUIRE(DNS_C_PKLIST_VALID(*list));
+
+ l = *list;
+
+ pk = ISC_LIST_HEAD(l->keylist);
+ while (pk != NULL) {
+ tmppk = ISC_LIST_NEXT(pk, next);
+ ISC_LIST_UNLINK(l->keylist, pk, next);
+ r = dns_c_pubkey_delete(lctx, &pk);
+ if (r != ISC_R_SUCCESS) {
+ return (r);
+ }
+
+ pk = tmppk;
+ }
+
+ l->magic = 0;
+ isc_mem_put(l->mem, l, sizeof *l);
+
+ return (ISC_R_SUCCESS);
+}
+
+
+
+void
+dns_c_pklist_print(isc_log_t *lctx,
+ FILE *fp, int indent, dns_c_pklist_t *list)
+{
+ dns_c_pubkey_t *pk;
+
+ REQUIRE(fp != NULL);
+ REQUIRE(indent >= 0);
+
+ if (list == NULL) {
+ return;
+ }
+
+ REQUIRE(DNS_C_PKLIST_VALID(list));
+
+ pk = ISC_LIST_HEAD(list->keylist);
+ while (pk != NULL) {
+ dns_c_pubkey_print(lctx, fp, indent, pk);
+ pk = ISC_LIST_NEXT(pk, next);
+ }
+ fprintf(fp, "\n");
+}
+
+
+
+isc_result_t
+dns_c_pklist_addpubkey(isc_log_t *lctx, dns_c_pklist_t *list,
+ dns_c_pubkey_t *pkey,
+ isc_boolean_t deepcopy)
+{
+ dns_c_pubkey_t *pk;
+ isc_result_t r;
+
+ REQUIRE(DNS_C_PKLIST_VALID(list));
+ REQUIRE(DNS_C_PUBKEY_VALID(pkey));
+
+ if (deepcopy) {
+ r = dns_c_pubkey_copy(lctx, list->mem, &pk, pkey);
+ if (r != ISC_R_SUCCESS) {
+ return (r);
+ }
+ } else {
+ pk = pkey;
+ }
+
+ ISC_LIST_APPEND(list->keylist, pk, next);
+
+ return (ISC_R_SUCCESS);
+}
+
+
+isc_result_t
+dns_c_pklist_findpubkey(isc_log_t *lctx, 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);
+
+ *pubkey = NULL;
+ pk = ISC_LIST_HEAD(list->keylist);
+ while (pk != NULL) {
+ if (pk->flags == flags &&
+ pk->protocol == protocol &&
+ pk->algorithm == algorithm &&
+ strcmp(pk->key, key) == 0) {
+ *pubkey = pk;
+ pk = NULL;
+ } else {
+ pk = ISC_LIST_NEXT(pk, next);
+ }
+ }
+
+ return (*pubkey == NULL ? ISC_R_NOTFOUND : ISC_R_SUCCESS);
+}
+
+
+
+isc_result_t
+dns_c_pklist_rmpubkey(isc_log_t *lctx, dns_c_pklist_t *list,
+ isc_int32_t flags,
+ isc_int32_t protocol, isc_int32_t algorithm,
+ const char *key)
+{
+ dns_c_pubkey_t *pk;
+ isc_result_t r;
+
+ REQUIRE(DNS_C_PKLIST_VALID(list));
+ REQUIRE(key != NULL);
+ REQUIRE(strlen(key) > 0);
+
+ r = dns_c_pklist_findpubkey(lctx, 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);
+ }
+
+ return (r);
+}
+
isc_result_t
(void)lctx;
+ REQUIRE(pubkey != NULL);
+ REQUIRE(key != NULL);
+ REQUIRE(strlen(key) > 0);
+
pkey = isc_mem_get(mem, sizeof *pkey);
if (pkey == NULL) {
return (ISC_R_NOMEMORY);
}
+ pkey->magic = DNS_C_PUBKEY_MAGIC;
pkey->mem = mem;
pkey->flags = flags;
pkey->protocol = protocol;
(void)lctx;
REQUIRE(pubkey != NULL);
- REQUIRE(*pubkey != NULL);
+ REQUIRE(DNS_C_PUBKEY_VALID(*pubkey));
pkey = *pubkey;
dns_c_pubkey_t *k;
isc_result_t res;
+ REQUIRE(DNS_C_PUBKEY_VALID(src));
+ REQUIRE(dest != NULL);
+
res = dns_c_pubkey_new(lctx, mem, src->flags, src->protocol,
src->algorithm, src->key, &k);
if (res != ISC_R_SUCCESS) {
isc_boolean_t
dns_c_pubkey_equal(dns_c_pubkey_t *k1, dns_c_pubkey_t *k2) {
- if (k1 == NULL && k2 == NULL)
- return (ISC_TRUE);
- if (k1 == NULL || k2 == NULL)
- return (ISC_FALSE);
+ REQUIRE(DNS_C_PUBKEY_VALID(k1));
+ REQUIRE(DNS_C_PUBKEY_VALID(k2));
+
return (ISC_TF(k1->flags == k2->flags &&
k1->protocol == k2->protocol &&
k1->algorithm == k2->algorithm &&
FILE *fp, int indent, dns_c_pubkey_t *pubkey)
{
REQUIRE(fp != NULL);
- REQUIRE(pubkey != NULL);
+ REQUIRE(DNS_C_PUBKEY_VALID(pubkey));
- if (pubkey == NULL) {
- return;
- }
-
dns_c_printtabs(lctx, fp, indent);
fprintf(fp, "pubkey %d %d %d \"%s\";\n",
pubkey->flags, pubkey->protocol,
return (ISC_R_NOMEMORY);
}
+ nl->magic = DNS_C_TKEYLIST_MAGIC;
nl->mem = mem;
ISC_LIST_INIT(nl->tkeylist);
isc_result_t res;
REQUIRE(list != NULL);
- REQUIRE(*list != NULL);
+ REQUIRE(DNS_C_TKEYLIST_VALID(*list));
l = *list;
tkey = tmptkey;
}
+ l->magic = 0;
isc_mem_put(l->mem, l, sizeof *l);
*list = NULL;
isc_result_t res;
REQUIRE(dest != NULL);
- REQUIRE(src != NULL);
+ REQUIRE(DNS_C_TKEYLIST_VALID(src));
res = dns_c_tkeylist_new(lctx, mem, &newlist);
if (res != ISC_R_SUCCESS) {
dns_c_tkey_t *tkey;
REQUIRE(fp != NULL);
+ REQUIRE(DNS_C_TKEYLIST_VALID(list));
- if (list == NULL || ISC_LIST_EMPTY(list->tkeylist)) {
+ if (ISC_LIST_EMPTY(list->tkeylist)) {
return;
}
dns_c_tkey_t *newe;
isc_result_t res;
- REQUIRE(list != NULL);
- REQUIRE(element != NULL);
+ REQUIRE(DNS_C_TKEYLIST_VALID(list));
+ REQUIRE(DNS_C_TKEY_VALID(element));
if (copy) {
res = dns_c_tkey_copy(lctx, list->mem, &newe, element);
REQUIRE(strlen(domain) > 0);
REQUIRE(key != NULL);
REQUIRE(strlen(key) > 0);
+ REQUIRE(newkey != NULL);
newk = isc_mem_get(mem, sizeof *newk);
if (newk == NULL) {
}
newk->mem = mem;
+ newk->magic = DNS_C_TKEY_MAGIC;
newk->domain = isc_mem_strdup(mem, domain);
if (newk->domain == NULL) {
dns_c_tkey_t *tk;
REQUIRE(tkey != NULL);
- REQUIRE(*tkey != NULL);
+ REQUIRE(DNS_C_TKEY_VALID(*tkey));
tk = *tkey;
return (res);
}
+ tk->magic = 0;
isc_mem_put(tk->mem, tk, sizeof *tk);
*tkey = NULL;
isc_result_t res;
REQUIRE(dest != NULL);
- REQUIRE(src != NULL);
+ REQUIRE(DNS_C_TKEY_VALID(src));
newk = isc_mem_get(mem, sizeof *newk);
if (newk == NULL) {
return (ISC_R_NOMEMORY);
}
+ newk->magic = DNS_C_TKEY_MAGIC;
newk->domain = isc_mem_strdup(mem, src->domain);
if (newk->domain == NULL) {
isc_mem_put(mem, newk, sizeof *newk);
{
(void)lctx;
- REQUIRE(tkey != NULL);
+ REQUIRE(DNS_C_TKEY_VALID(tkey));
*flags = tkey->pubkey->flags;
{
(void)lctx;
- REQUIRE(tkey != NULL);
+ REQUIRE(DNS_C_TKEY_VALID(tkey));
*protocol = tkey->pubkey->protocol;
{
(void)lctx;
- REQUIRE(tkey != NULL);
+ REQUIRE(DNS_C_TKEY_VALID(tkey));
*algorithm = tkey->pubkey->algorithm;
(void)lctx;
REQUIRE(key != NULL);
- REQUIRE(tkey != NULL);
+ REQUIRE(DNS_C_TKEY_VALID(tkey));
*key = tkey->pubkey->key;
FILE *fp, int indent, dns_c_tkey_t *tkey)
{
REQUIRE(fp != NULL);
- REQUIRE(tkey != NULL);
+ REQUIRE(DNS_C_TKEY_VALID(tkey));
dns_c_printtabs(lctx, fp, indent);
fprintf(fp, "\"%s\" %d %d %d \"%s\";\n",
#include <string.h>
#include <isc/assertions.h>
+#include <isc/magic.h>
#include <dns/conflog.h>
#include <dns/confcommon.h>
#define UNLIM_VERSIONS (-1) /* XXX check this is right? */
-
-
/*
* Bit positions in the dns_c_logchan_t structure setflags field.
*/
-static void print_log_facility(isc_log_t *lctx, FILE *fp, int value);
-static void print_log_severity(isc_log_t *lctx, FILE *fp,
- dns_c_logseverity_t severity);
-static void print_log_category(isc_log_t *lctx, FILE *fp,
- dns_c_category_t category);
+static void print_log_facility(isc_log_t *lctx, FILE *fp,
+ int value);
+static void print_log_severity(isc_log_t *lctx, FILE *fp,
+ dns_c_logseverity_t severity);
+static void print_log_category(isc_log_t *lctx, FILE *fp,
+ dns_c_category_t category);
+static isc_boolean_t logginglist_empty(dns_c_logginglist_t *ll);
return (ISC_R_NOMEMORY);
}
+ newl->magic = DNS_C_LOGLIST_MAGIC;
newl->mem = mem;
ISC_LIST_INIT(newl->channels);
ISC_LIST_INIT(newl->categories);
isc_result_t res;
REQUIRE(list != NULL);
- REQUIRE(*list != NULL);
+ REQUIRE(DNS_C_LOGLIST_VALID(*list));
l = *list;
cat = tmpcat;
}
+ l->magic = 0;
isc_mem_put(l->mem, l, sizeof *l);
*list = NULL;
isc_result_t res;
REQUIRE(dest != NULL);
- REQUIRE(src != NULL);
+ REQUIRE(DNS_C_LOGLIST_VALID(src));
res = dns_c_logginglist_new(lctx, mem, &newl);
if (res != ISC_R_SUCCESS) {
}
+static isc_boolean_t
+logginglist_empty(dns_c_logginglist_t *ll)
+{
+ dns_c_logchan_t *logchan;
+ dns_c_logcat_t *logcat;
+
+ REQUIRE(DNS_C_LOGLIST_VALID(ll));
+
+ logchan = ISC_LIST_HEAD(ll->channels);
+ while (logchan != NULL) {
+ if (!logchan->predefined) {
+ return ISC_TRUE;
+ }
+
+ logchan = ISC_LIST_NEXT(logchan, next);
+ }
+
+ logcat = ISC_LIST_HEAD(ll->categories);
+ while (logcat != NULL) {
+ if (!logcat->predefined) {
+ return ISC_FALSE;
+ }
+ logcat = ISC_LIST_NEXT(logcat, next);
+ }
+
+ return ISC_TRUE;
+}
+
+
void
dns_c_logginglist_print(isc_log_t *lctx,
FILE *fp, int indent, dns_c_logginglist_t *ll,
dns_c_logcat_t *logcat;
REQUIRE(fp != NULL);
+ REQUIRE(DNS_C_LOGLIST_VALID(ll));
- if (ll == NULL) {
+ if (logginglist_empty(ll)) {
return;
}
isc_boolean_t existed = ISC_FALSE;
isc_boolean_t predefined = ISC_FALSE;
- REQUIRE(list != NULL);
- REQUIRE(newchan != NULL);
+ REQUIRE(DNS_C_LOGLIST_VALID(list));
+ REQUIRE(DNS_C_LOGCHAN_VALID(newchan));
if (deepcopy) {
res = dns_c_logchan_copy(lctx, list->mem, &newc, newchan);
isc_boolean_t existed = ISC_FALSE;
isc_boolean_t predefined = ISC_FALSE;
- REQUIRE(list != NULL);
- REQUIRE(newcat != NULL);
+ REQUIRE(DNS_C_LOGLIST_VALID(list));
+ REQUIRE(DNS_C_LOGCAT_VALID(newcat));
+
if (deepcopy) {
res = dns_c_logcat_copy(lctx, list->mem, &newc, newcat);
dns_c_logchan_t *logc;
isc_result_t res;
+ REQUIRE(DNS_C_LOGLIST_VALID(list));
+ REQUIRE(name != NULL);
+ REQUIRE(strlen(name) > 0);
+
res = dns_c_logginglist_chanbyname(lctx, list, name, &logc);
if (res == ISC_R_SUCCESS) {
ISC_LIST_UNLINK(list->channels, logc, next);
dns_c_logcat_t *logc;
isc_result_t res;
+ REQUIRE(DNS_C_LOGLIST_VALID(list));
+ REQUIRE(name != NULL);
+ REQUIRE(strlen(name) > 0);
+
res = dns_c_logginglist_catbyname(lctx, list, name, &logc);
if (res == ISC_R_SUCCESS) {
ISC_LIST_UNLINK(list->categories, logc, next);
(void) lctx;
- REQUIRE(list != NULL);
+ REQUIRE(DNS_C_LOGLIST_VALID(list));
REQUIRE(name != NULL);
+ REQUIRE(strlen(name) > 0);
REQUIRE(chan != NULL);
logc = ISC_LIST_HEAD(list->channels);
dns_c_category_t cattype;
isc_result_t res;
- REQUIRE(list != NULL);
+ REQUIRE(DNS_C_LOGLIST_VALID(list));
REQUIRE(name != NULL);
+ REQUIRE(strlen(name) > 0);
REQUIRE(cat != NULL);
res = dns_c_string2category(lctx, name, &cattype);
(void) lctx;
+ REQUIRE(DNS_C_LOGLIST_VALID(list));
+ REQUIRE(cat != NULL);
+
logc = ISC_LIST_HEAD(list->categories);
while (logc != NULL) {
if (logc->category == cattype) {
(void) lctx;
REQUIRE(name != NULL);
+ REQUIRE(strlen(name) > 0);
+ REQUIRE(newchan != NULL);
newc = isc_mem_get(mem, sizeof *newc);
if (newc == NULL) {
return (ISC_R_NOMEMORY);
}
+ newc->magic = DNS_C_LOGCHAN_MAGIC;
newc->mem = mem;
newc->ctype = ctype;
newc->severity = dns_c_log_info;
(void) lctx;
REQUIRE(channel != NULL);
- REQUIRE(*channel != NULL);
+ REQUIRE(DNS_C_LOGCHAN_VALID(*channel));
logc = *channel;
*channel = NULL;
+ logc->magic = 0;
isc_mem_put(logc->mem, logc, sizeof *logc);
return (ISC_R_SUCCESS);
isc_result_t res;
REQUIRE(dest != NULL);
- REQUIRE(src != NULL);
+ REQUIRE(DNS_C_LOGCHAN_VALID(src));
res = dns_c_logchan_new(lctx, mem, src->name, src->ctype, &logc);
if (res != ISC_R_SUCCESS) {
isc_boolean_t if_predef_too)
{
REQUIRE(fp != NULL);
- REQUIRE(logchan != NULL);
+ REQUIRE(DNS_C_LOGCHAN_VALID(logchan));
if (logchan->predefined && !if_predef_too) {
return;
{
isc_boolean_t existed = ISC_FALSE;
- REQUIRE(channel != NULL);
+ REQUIRE(DNS_C_LOGCHAN_VALID(channel));
REQUIRE(path != NULL);
REQUIRE(strlen(path) > 0);
{
isc_boolean_t existed;
- REQUIRE(channel != NULL);
+ REQUIRE(DNS_C_LOGCHAN_VALID(channel));
existed = DNS_C_CHECKBIT(CHAN_VERSIONS_BIT, &channel->setflags);
{
isc_boolean_t existed;
- REQUIRE(channel != NULL);
+ REQUIRE(DNS_C_LOGCHAN_VALID(channel));
if (channel->ctype != dns_c_logchan_file) {
isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
{
isc_boolean_t existed;
- REQUIRE(channel != NULL);
+ REQUIRE(DNS_C_LOGCHAN_VALID(channel));
if (channel->ctype != dns_c_logchan_syslog) {
isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
(void) lctx;
- REQUIRE(channel != NULL);
+ REQUIRE(DNS_C_LOGCHAN_VALID(channel));
existed = DNS_C_CHECKBIT(CHAN_SEVERITY_BIT, &channel->setflags);
(void) lctx;
- REQUIRE(channel != NULL);
+ REQUIRE(DNS_C_LOGCHAN_VALID(channel));
if (channel->severity == dns_c_log_debug) {
existed = DNS_C_CHECKBIT(CHAN_DEBUG_LEVEL_BIT,
(void) lctx;
- REQUIRE(channel != NULL);
+ REQUIRE(DNS_C_LOGCHAN_VALID(channel));
existed = DNS_C_CHECKBIT(CHAN_PCAT_BIT, &channel->setflags);
(void) lctx;
- REQUIRE(channel != NULL);
+ REQUIRE(DNS_C_LOGCHAN_VALID(channel));
existed = DNS_C_CHECKBIT(CHAN_PSEV_BIT, &channel->setflags);
(void) lctx;
- REQUIRE(channel != NULL);
+ REQUIRE(DNS_C_LOGCHAN_VALID(channel));
existed = DNS_C_CHECKBIT(CHAN_PTIME_BIT, &channel->setflags);
{
(void) lctx;
- REQUIRE(channel != NULL);
+ REQUIRE(DNS_C_LOGCHAN_VALID(channel));
channel->predefined = newval;
(void) lctx;
- REQUIRE(channel != NULL);
+ REQUIRE(DNS_C_LOGCHAN_VALID(channel));
REQUIRE(path != NULL);
if (channel->ctype == dns_c_logchan_file &&
(void) lctx;
- REQUIRE(channel != NULL);
+ REQUIRE(DNS_C_LOGCHAN_VALID(channel));
REQUIRE(retval != NULL);
if (channel->ctype == dns_c_logchan_file &&
(void) lctx;
- REQUIRE(channel != NULL);
+ REQUIRE(DNS_C_LOGCHAN_VALID(channel));
REQUIRE(retval != NULL);
if (channel->ctype == dns_c_logchan_file &&
(void) lctx;
- REQUIRE(channel != NULL);
+ REQUIRE(DNS_C_LOGCHAN_VALID(channel));
REQUIRE(retval != NULL);
if (channel->ctype == dns_c_logchan_syslog &&
(void) lctx;
- REQUIRE(channel != NULL);
+ REQUIRE(DNS_C_LOGCHAN_VALID(channel));
REQUIRE(retval != NULL);
if (DNS_C_CHECKBIT(CHAN_SEVERITY_BIT, &channel->setflags)) {
(void) lctx;
- REQUIRE(channel != NULL);
+ REQUIRE(DNS_C_LOGCHAN_VALID(channel));
REQUIRE(retval != NULL);
if (DNS_C_CHECKBIT(CHAN_DEBUG_LEVEL_BIT, &channel->setflags)) {
(void) lctx;
- REQUIRE(channel != NULL);
+ REQUIRE(DNS_C_LOGCHAN_VALID(channel));
REQUIRE(retval != NULL);
if (DNS_C_CHECKBIT(CHAN_PCAT_BIT, &channel->setflags)) {
(void) lctx;
- REQUIRE(channel != NULL);
+ REQUIRE(DNS_C_LOGCHAN_VALID(channel));
REQUIRE(retval != NULL);
if (DNS_C_CHECKBIT(CHAN_PSEV_BIT, &channel->setflags)) {
(void) lctx;
- REQUIRE(channel != NULL);
+ REQUIRE(DNS_C_LOGCHAN_VALID(channel));
REQUIRE(retval != NULL);
if (DNS_C_CHECKBIT(CHAN_PTIME_BIT, &channel->setflags)) {
{
(void) lctx;
- REQUIRE(channel != NULL);
+ REQUIRE(DNS_C_LOGCHAN_VALID(channel));
REQUIRE(retval != NULL);
*retval = channel->predefined;
return (ISC_R_NOMEMORY);
}
+ newc->magic = DNS_C_LOGCAT_MAGIC;
newc->mem = mem;
newc->category = cat;
newc->cnames_len = 2;
(void) lctx;
REQUIRE(logcat != NULL);
- REQUIRE(*logcat != NULL);
+ REQUIRE(DNS_C_LOGCAT_VALID(*logcat));
logc = *logcat;
if (logc == NULL) {
isc_mem_free(logc->mem, logc->channel_names[i]);
}
+ logc->magic = 0;
isc_mem_put(logc->mem, logc->channel_names,
sizeof (char *) * logc->cnames_len);
isc_mem_put(logc->mem, logc, sizeof *logc);
isc_result_t res;
REQUIRE(dest != NULL);
- REQUIRE(src != NULL);
+ REQUIRE(DNS_C_LOGCAT_VALID(src));
res = dns_c_logcat_new(lctx, mem, src->category, &newc);
if (res != ISC_R_SUCCESS) {
unsigned int i;
REQUIRE(fp != NULL);
- REQUIRE(logcat != NULL);
+ REQUIRE(DNS_C_LOGCAT_VALID(logcat));
if (logcat->predefined && !if_predef_too) {
return;
(void) lctx;
- REQUIRE(logcat != NULL);
+ REQUIRE(DNS_C_LOGCAT_VALID(logcat));
REQUIRE(name != NULL);
REQUIRE(strlen(name) > 0);
(void) lctx;
- REQUIRE(logcat != NULL);
+ REQUIRE(DNS_C_LOGCAT_VALID(logcat));
REQUIRE(name != NULL);
REQUIRE(strlen(name) > 0);
{
(void) lctx;
- REQUIRE(logcat != NULL);
+ REQUIRE(DNS_C_LOGCAT_VALID(logcat));
logcat->predefined = newval;
{
(void) lctx;
- REQUIRE(logcat != NULL);
+ REQUIRE(DNS_C_LOGCAT_VALID(logcat));
REQUIRE(retval != NULL);
*retval = logcat->predefined;
#include <config.h>
#include <isc/assertions.h>
+#include <isc/magic.h>
+
#include <dns/conflsn.h>
#include <dns/confcommon.h>
#include "confpvt.h"
-#define LISTEN_MAGIC 0x4c49534eU /* LISN */
-#define LLIST_MAGIC 0x4c6c6973U /* Llis */
-#define CHECK_LISTEN(l) REQUIRE(DNS_C_VALID_STRUCT(l,LISTEN_MAGIC))
-#define CHECK_LLIST(l) REQUIRE(DNS_C_VALID_STRUCT(l,LLIST_MAGIC))
-
-
isc_result_t
dns_c_lstnon_new(isc_log_t *lctx, isc_mem_t *mem, dns_c_lstnon_t **listen)
{
ll = isc_mem_get(mem, sizeof *ll);
ll->mem = mem;
ll->port = 0;
- ll->magic = LISTEN_MAGIC;
+ ll->magic = DNS_C_LISTEN_MAGIC;
result = dns_c_ipmatchlist_new(lctx, mem, &ll->iml);
if (result != ISC_R_SUCCESS) {
isc_result_t r;
REQUIRE(listen != NULL);
- REQUIRE(*listen != NULL);
+ REQUIRE(DNS_C_LISTEN_VALID(*listen));
lo = *listen;
- CHECK_LISTEN(lo);
-
if (lo->iml != NULL) {
r = dns_c_ipmatchlist_detach(lctx, &lo->iml);
} else
dns_c_ipmatchlist_t *iml, isc_boolean_t deepcopy)
{
isc_result_t result;
-
- REQUIRE(listen != NULL);
- REQUIRE(iml != NULL);
+
+ REQUIRE(DNS_C_LISTEN_VALID(listen));
+ REQUIRE(DNS_C_IPMLIST_VALID(iml));
if (listen->iml != NULL) {
result = dns_c_ipmatchlist_detach(lctx, &listen->iml);
}
ll->mem = mem;
- ll->magic = LLIST_MAGIC;
+ ll->magic = DNS_C_LLIST_MAGIC;
ISC_LIST_INIT(ll->elements);
*llist = ll;
isc_result_t r;
REQUIRE(llist != NULL);
- REQUIRE(*llist != NULL);
+ REQUIRE(DNS_C_LISTENLIST_VALID(*llist));
ll = *llist;
- CHECK_LLIST(ll);
-
lo = ISC_LIST_HEAD(ll->elements);
while (lo != NULL) {
lotmp = ISC_LIST_NEXT(lo, next);
lo = lotmp;
}
+ ll->magic = 0;
isc_mem_put(ll->mem, ll, sizeof *ll);
*llist = NULL;
{
dns_c_lstnon_t *lo;
- if (ll == NULL) {
- return (ISC_R_SUCCESS);
- }
+ REQUIRE(DNS_C_LISTENLIST_VALID(ll));
- CHECK_LLIST(ll);
-
lo = ISC_LIST_HEAD(ll->elements);
while (lo != NULL) {
dns_c_printtabs(lctx, fp, indent);
dns_c_lstnon_print(isc_log_t *lctx, FILE *fp, int indent, dns_c_lstnon_t *lo)
{
REQUIRE(lo != NULL);
- REQUIRE(lo->iml != NULL);
- CHECK_LISTEN(lo);
+ REQUIRE(DNS_C_LISTEN_VALID(lo));
fprintf(fp, "listen-on ");
if (lo->port != DNS_C_DEFAULTPORT) {
*/
#if !defined(lint) && !defined(SABER)
-static char rcsid[] = "$Id: confparser.y,v 1.26 1999/11/30 22:01:16 gson Exp $";
+static char rcsid[] = "$Id: confparser.y,v 1.27 1999/12/01 16:28:56 brister Exp $";
#endif /* not lint */
#include <config.h>
default:
parser_error(ISC_FALSE,
"Failed to set view allow-query.");
+ break;
}
}
| zone_stmt;
default:
parser_error(ISC_FALSE,
"Failed to set zone master port.");
+ break;
}
tmpres = dns_c_zone_setmasterips(logcontext, zone,
default:
parser_error(ISC_FALSE,
"Failed to set zone masters ips.");
+ break;
}
}
| L_TRANSFER_SOURCE maybe_wild_addr
default:
parser_error(ISC_FALSE,
"Failed to set zone transfer-source.");
+ break;
}
}
| L_CHECK_NAMES check_names_opt
default:
parser_error(ISC_FALSE,
"Failed to set zone check-names.");
+ break;
}
}
| L_ALLOW_UPDATE L_LBRACE address_match_list L_RBRACE
default:
parser_error(ISC_FALSE,
"Failed to set zone allow-update.");
+ break;
}
}
| L_ALLOW_QUERY L_LBRACE address_match_list L_RBRACE
default:
parser_error(ISC_FALSE,
"Failed to set zone allow-query.");
+ break;
}
}
| L_ALLOW_TRANSFER L_LBRACE address_match_list L_RBRACE
default:
parser_error(ISC_FALSE,
"Failed to set zone allow-transfer.");
+ break;
}
}
| L_FORWARD zone_forward_opt
default:
parser_error(ISC_FALSE,
"Failed to set zone forward.");
+ break;
}
}
| L_FORWARDERS L_LBRACE opt_zone_forwarders_list L_RBRACE
parser_error(ISC_FALSE,
"Failed to set zone "
"max-transfer-time-in.");
+ break;
}
}
| L_MAX_LOG_SIZE_IXFR L_INTEGER
default:
parser_error(ISC_FALSE,
"Failed to set zone max-ixfr-log-size.");
+ break;
}
}
| L_NOTIFY yea_or_nay
default:
parser_error(ISC_FALSE,
"Failed to set zone notify.");
+ break;
}
}
| L_MAINTAIN_IXFR_BASE yea_or_nay
default:
parser_error(ISC_FALSE,
"Failed to set zone maintain-ixfr-base.");
+ break;
}
}
| L_PUBKEY L_INTEGER L_INTEGER L_INTEGER L_QSTRING
YYABORT;
}
- tmpres = dns_c_zone_setpubkey(logcontext, zone, pubkey,
+ tmpres = dns_c_zone_addpubkey(logcontext, zone, pubkey,
ISC_FALSE);
switch (tmpres) {
- case ISC_R_EXISTS:
- parser_warning(ISC_FALSE,
- "Redefining zone pubkey.");
- break;
-
case ISC_R_SUCCESS:
/* nothing */
break;
default:
dns_c_pubkey_delete(logcontext, &pubkey);
parser_error(ISC_FALSE,
- "Failed to set zone pubkey.");
+ "Failed to add a zone pubkey.");
+ break;
}
isc_mem_free(memctx, $5);
default:
parser_error(ISC_FALSE,
"Failed to set zone also-notify.");
+ break;
}
}
| L_DIALUP yea_or_nay
default:
parser_error(ISC_FALSE,
"Failed to set zone dialup.");
+ break;
}
}
;
sizeof buffer - 1);
buffer[sizeof buffer - 1] = '\0';
}
+ break;
}
}
#define DNS_C_CHECKBIT(bit,flags) \
ISC_TF((*(flags) & ((dns_c_setbits_t)1 << (bit))) == ((dns_c_setbits_t)1 << (bit)))
-#define DNS_C_VALID_STRUCT(p,m) ((p) != NULL && (p)->magic == m)
-
-
-
#endif
#include <config.h>
#include <isc/assertions.h>
+#include <isc/magic.h>
#include <dns/confrrset.h>
#include <dns/confcommon.h>
{
dns_c_rrso_t *elem;
- REQUIRE(olist != NULL);
+ REQUIRE(DNS_C_RRSOLIST_VALID(olist));
elem = ISC_LIST_HEAD(olist->elements);
while (elem != NULL) {
dns_c_rrso_t *newelem;
isc_result_t res;
- REQUIRE(dest != NULL);
- REQUIRE(src != NULL);
+ REQUIRE(DNS_C_RRSOLIST_VALID(dest));
+ REQUIRE(DNS_C_RRSOLIST_VALID(src));
oldelem = ISC_LIST_HEAD(src->elements);
while (oldelem != NULL) {
ISC_LIST_INIT(ro->elements);
ro->mem = mem;
+ ro->magic = DNS_C_RRSOLIST_MAGIC;
*rval = ro;
return (ISC_R_NOMEMORY);
}
+ newo->magic = DNS_C_RRSO_MAGIC;
newo->mem = mem;
newo->otype = otype;
newo->oclass = oclass;
newo->name = isc_mem_strdup(mem, name);
if (newo->name == NULL) {
+ newo->magic = 0;
isc_mem_put(mem, newo, sizeof *newo);
return (ISC_R_NOMEMORY);
}
isc_result_t r;
REQUIRE(list != NULL);
- REQUIRE(*list != NULL);
+ REQUIRE(DNS_C_RRSOLIST_VALID(*list));
l = *list;
elem = q;
}
+ l->magic = 0;
isc_mem_put(l->mem, l, sizeof *l);
*list = NULL;
(void)lctx;
REQUIRE(order != NULL);
- REQUIRE(*order != NULL);
+ REQUIRE(DNS_C_RRSO_VALID(*order));
oldo = *order;
REQUIRE(oldo->name != NULL);
isc_mem_free(oldo->mem, oldo->name);
+ oldo->magic = 0;
isc_mem_put(oldo->mem, oldo, sizeof *oldo);
*order = NULL;
dns_c_rrso_t *newo;
isc_result_t res;
- REQUIRE(mem != NULL);
- REQUIRE(dest != NULL);
- REQUIRE(source != NULL);
+ REQUIRE(DNS_C_RRSO_VALID(*dest));
+ REQUIRE(DNS_C_RRSO_VALID(source));
res = dns_c_rrso_new(lctx, mem, &newo, source->oclass,
source->otype, source->name,
dns_c_rrso_t *elem;
dns_c_rrso_t *newe;
dns_result_t res;
+
+ REQUIRE(DNS_C_RRSOLIST_VALID(source));
+ REQUIRE(dest != NULL);
res = dns_c_rrsolist_new(lctx, mem, &nlist);
if (res != DNS_R_SUCCESS) {
{
dns_c_rrso_t *or;
- if (rrlist == NULL) {
- return;
- }
+ REQUIRE(DNS_C_RRSOLIST_VALID(rrlist));
if (ISC_LIST_EMPTY(rrlist->elements)) {
return;
void
dns_c_rrso_print(isc_log_t *lctx, FILE *fp, int indent, dns_c_rrso_t *order)
{
+ REQUIRE(DNS_C_RRSO_VALID(order));
+
dns_c_printtabs(lctx, fp, indent);
-
+
fputs("class ", fp);
if (order->oclass == dns_rdataclass_any) {
fputc('*', fp);
#include <string.h>
#include <isc/assertions.h>
+#include <isc/magic.h>
#include <isc/net.h>
#include <dns/confserv.h>
ISC_LIST_INIT(l->elements);
l->mem = mem;
+ l->magic = DNS_C_SRVLIST_MAGIC;
*list = l;
isc_result_t r;
REQUIRE(list != NULL);
- REQUIRE(*list != NULL);
+ REQUIRE(DNS_C_SRVLIST_VALID(*list));
l = *list;
server = stmp;
}
+
+ l->magic = 0;
isc_mem_put(l->mem, l, sizeof *l);
*list = NULL;
dns_c_srv_t *server;
REQUIRE(fp != NULL);
-
- if (servers == NULL) {
- return;
- }
+ REQUIRE(DNS_C_SRVLIST_VALID(servers));
server = ISC_LIST_HEAD(servers->elements);
while (server != NULL) {
(void) lctx;
REQUIRE(retval != NULL);
-
- if (servers == NULL) {
- return (ISC_R_NOTFOUND);
- }
+ REQUIRE(DNS_C_SRVLIST_VALID(servers));
server = ISC_LIST_HEAD(servers->elements);
while (server != NULL) {
-
if (isc_sockaddr_eqaddr(&addr, &server->address)) {
break;
}
(void) lctx;
REQUIRE(server != NULL);
- REQUIRE(mem != NULL);
serv = isc_mem_get(mem, sizeof *serv);
if (serv == NULL) {
return (ISC_R_NOMEMORY);
}
+ serv->magic = DNS_C_SRV_MAGIC;
serv->address = addr;
serv->mem = mem;
serv->bogus = ISC_FALSE;
isc_mem_t *mem;
REQUIRE(server != NULL);
- REQUIRE(*server != NULL);
+ REQUIRE(DNS_C_SRV_VALID(*server));
serv = *server;
mem = serv->mem;
serv->mem = NULL;
+ serv->magic = 0;
if (serv->keys != NULL)
dns_c_kidlist_delete(lctx, &serv->keys);
void
dns_c_srv_print(isc_log_t *lctx, FILE *fp, int indent, dns_c_srv_t *server)
{
- REQUIRE(server != NULL);
+ REQUIRE(DNS_C_SRV_VALID(server));
REQUIRE(fp != NULL);
dns_c_printtabs(lctx, fp, indent);
{
(void) lctx;
- REQUIRE(server != NULL);
+ REQUIRE(DNS_C_SRV_VALID(server));
server->bogus = newval;
DNS_C_SETBIT(BOGUS_BIT, &server->bitflags);
{
(void) lctx;
- REQUIRE(server != NULL);
+ REQUIRE(DNS_C_SRV_VALID(server));
REQUIRE(retval != NULL);
if (DNS_C_CHECKBIT(BOGUS_BIT, &server->bitflags)) {
{
(void) lctx;
- REQUIRE(server != NULL);
+ REQUIRE(DNS_C_SRV_VALID(server));
server->support_ixfr = newval;
DNS_C_SETBIT(SUPPORT_IXFR_BIT, &server->bitflags);
{
(void) lctx;
- REQUIRE(server != NULL);
+ REQUIRE(DNS_C_SRV_VALID(server));
REQUIRE(retval != NULL);
if (DNS_C_CHECKBIT(SUPPORT_IXFR_BIT, &server->bitflags)) {
{
(void) lctx;
- REQUIRE(server != NULL);
+ REQUIRE(DNS_C_SRV_VALID(server));
server->transfers = newval;
DNS_C_SETBIT(TRANSFERS_BIT, &server->bitflags);
{
(void) lctx;
- REQUIRE(server != NULL);
+ REQUIRE(DNS_C_SRV_VALID(server));
REQUIRE(retval != NULL);
if (DNS_C_CHECKBIT(TRANSFERS_BIT, &server->bitflags)) {
{
(void) lctx;
- REQUIRE(server != NULL);
+ REQUIRE(DNS_C_SRV_VALID(server));
server->transfer_format = newval;
DNS_C_SETBIT(SERVER_TRANSFER_FORMAT_BIT, &server->bitflags);
{
(void) lctx;
- REQUIRE(server != NULL);
+ REQUIRE(DNS_C_SRV_VALID(server));
REQUIRE(retval != NULL);
if (DNS_C_CHECKBIT(SERVER_TRANSFER_FORMAT_BIT, &server->bitflags)) {
#include <sys/types.h>
#include <isc/assertions.h>
+#include <isc/magic.h>
#include <isc/net.h>
+#include <dns/confacl.h>
#include <dns/confzone.h>
#include <dns/confcommon.h>
#include <dns/confview.h>
{
dns_c_viewtable_t *table;
- REQUIRE(mem != NULL);
REQUIRE(viewtable != NULL);
table = isc_mem_get(mem, sizeof *table);
return (ISC_R_NOMEMORY);
}
+ table->magic = DNS_C_VIEWTABLE_MAGIC;
table->mem = mem;
ISC_LIST_INIT(table->views);
dns_c_viewtable_t *table;
REQUIRE(viewtable != NULL);
- REQUIRE(*viewtable != NULL);
+ REQUIRE(DNS_C_VIEWTABLE_VALID(*viewtable));
table = *viewtable;
*viewtable = NULL;
dns_c_viewtable_clear(lctx, table);
+ table->magic = 0;
isc_mem_put(table->mem, table, sizeof *table);
return (ISC_R_SUCCESS);
{
(void) lctx; /* lint */
- REQUIRE(viewtable != NULL);
- REQUIRE(view != NULL);
+ REQUIRE(DNS_C_VIEWTABLE_VALID(viewtable));
+ REQUIRE(DNS_C_VIEW_VALID(view));
ISC_LIST_APPEND(viewtable->views, view, next);
}
{
(void) lctx; /* lint */
- REQUIRE(viewtable != NULL);
- REQUIRE(view != NULL);
+ REQUIRE(DNS_C_VIEWTABLE_VALID(viewtable));
+ REQUIRE(DNS_C_VIEW_VALID(view));
ISC_LIST_UNLINK(viewtable->views, view, next);
}
dns_c_view_t *tmpelem;
isc_result_t r;
- REQUIRE(table != NULL);
+ REQUIRE(DNS_C_VIEWTABLE_VALID(table));
elem = ISC_LIST_HEAD(table->views);
while (elem != NULL) {
(void) lctx; /* lint */
- REQUIRE(viewtable != NULL);
+ REQUIRE(DNS_C_VIEWTABLE_VALID(viewtable));
REQUIRE(retval != NULL);
REQUIRE(viewname != NULL);
REQUIRE(strlen(viewname) > 0);
dns_c_view_t *view;
isc_result_t res;
+ REQUIRE(DNS_C_VIEWTABLE_VALID(viewtable));
+
res = dns_c_viewtable_viewbyname(lctx, viewtable, name, &view);
if (res == ISC_R_SUCCESS) {
ISC_LIST_UNLINK(viewtable->views, view, next);
/* XXXJAB not portable -- should set each field */
memset(view, 0x0, sizeof *view);
+ view->magic = DNS_C_VIEW_MAGIC;
view->mem = mem;
view->name = isc_mem_strdup(mem, name);
if (view->name == NULL) {
REQUIRE(fp != NULL);
REQUIRE(indent >= 0);
+ REQUIRE(DNS_C_VIEWTABLE_VALID(table));
- if (table == NULL) {
- return;
- }
-
view = ISC_LIST_HEAD(table->views);
while (view != NULL) {
dns_c_view_print(lctx, fp, indent, view);
dns_c_view_print(isc_log_t *lctx,
FILE *fp, int indent, dns_c_view_t *view)
{
+ REQUIRE(DNS_C_VIEW_VALID(view));
+
dns_c_printtabs(lctx, fp, indent);
fprintf(fp, "view \"%s\" {\n", view->name);
{
isc_result_t res;
- REQUIRE(view != NULL);
- REQUIRE(ipml != NULL);
+ REQUIRE(DNS_C_VIEW_VALID(view));
+ REQUIRE(DNS_C_IPMLIST_VALID(ipml));
if (view->allowquery != NULL) {
dns_c_ipmatchlist_detach(lctx, &view->allowquery);
dns_c_ipmatchlist_t *newlist;
isc_result_t r;
+ REQUIRE(DNS_C_VIEW_VALID(view));
+ REQUIRE(DNS_C_CONFACLTABLE_VALID(acltable));
+ REQUIRE(retval != NULL);
+
if (view->allowquery == NULL) {
newlist = NULL;
r = ISC_R_SUCCESS;
dns_c_view_t *view;
REQUIRE(viewptr != NULL);
- REQUIRE(*viewptr != NULL);
+ REQUIRE(DNS_C_VIEW_VALID(*viewptr));
view = *viewptr;
if (view->allowquery != NULL)
dns_c_ipmatchlist_detach(lctx, &view->allowquery);
+ view->magic = 0;
isc_mem_put(view->mem, view, sizeof *view);
return (ISC_R_SUCCESS);
{
(void) lctx;
- REQUIRE(view != NULL);
+ REQUIRE(DNS_C_VIEW_VALID(view));
REQUIRE(retval != NULL);
*retval = view->name;
isc_result_t
dns_c_zone_setixfrtmp(isc_log_t *lctx, dns_c_zone_t *zone, const char *newval)
{
- isc_boolean_t existed;
+ isc_boolean_t existed;
char **p = NULL;
REQUIRE(zone != NULL);
isc_result_t
-dns_c_zone_setpubkey(isc_log_t *lctx, dns_c_zone_t *zone,
+dns_c_zone_addpubkey(isc_log_t *lctx, dns_c_zone_t *zone,
dns_c_pubkey_t *pubkey,
isc_boolean_t deepcopy)
{
- isc_boolean_t existed;
- dns_c_pubkey_t **p = NULL;
+ dns_c_pklist_t **p = NULL;
isc_result_t res;
- REQUIRE(zone != NULL);
-
switch (zone->ztype) {
case dns_c_zone_master:
- p = &zone->u.mzone.pubkey;
+ p = &zone->u.mzone.pubkeylist;
break;
case dns_c_zone_slave:
- p = &zone->u.szone.pubkey;
+ p = &zone->u.szone.pubkeylist;
break;
case dns_c_zone_stub:
- p = &zone->u.tzone.pubkey;
+ p = &zone->u.tzone.pubkeylist;
break;
case dns_c_zone_hint:
+#if 1
+ p = &zone->u.hzone.pubkeylist;
+#else
isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
"Hint zones do not have a pubkey field");
+#endif
return (ISC_R_FAILURE);
case dns_c_zone_forward:
return (ISC_R_FAILURE);
}
- if (*p != NULL) {
- existed = ISC_TRUE;
- dns_c_pubkey_delete(lctx, p);
- } else {
- existed = ISC_FALSE;
- }
-
- if (deepcopy) {
- res = dns_c_pubkey_copy(lctx, zone->mem, p, pubkey);
- } else {
- *p = pubkey;
- res = ISC_R_SUCCESS;
- }
-
- if (res == ISC_R_SUCCESS && existed) {
- res = ISC_R_EXISTS;
+ if (*p == NULL) {
+ res = dns_c_pklist_new(lctx, zone->mem, p);
+ if (res != ISC_R_SUCCESS) {
+ return (res);
+ }
}
+ res = dns_c_pklist_addpubkey(lctx, *p, pubkey, deepcopy);
+
return (res);
}
isc_result_t
-dns_c_zone_getpubkey(isc_log_t *lctx, dns_c_zone_t *zone,
- dns_c_pubkey_t **retval)
+dns_c_zone_getpubkeylist(isc_log_t *lctx, dns_c_zone_t *zone,
+ dns_c_pklist_t **retval)
{
- dns_c_pubkey_t *p = NULL;
+ dns_c_pklist_t *p = NULL;
isc_result_t res;
REQUIRE(zone != NULL);
switch (zone->ztype) {
case dns_c_zone_master:
- p = zone->u.mzone.pubkey;
+ p = zone->u.mzone.pubkeylist;
break;
case dns_c_zone_slave:
- p = zone->u.szone.pubkey;
+ p = zone->u.szone.pubkeylist;
break;
case dns_c_zone_stub:
- p = zone->u.tzone.pubkey;
+ p = zone->u.tzone.pubkeylist;
break;
case dns_c_zone_hint:
+#if 1
+ p = zone->u.hzone.pubkeylist;
+#else
isc_log_write(lctx, DNS_LOGCATEGORY_CONFIG,
DNS_LOGMODULE_CONFIG, ISC_LOG_CRITICAL,
"Hint zones do not have a pubkey field");
+#endif
return (ISC_R_FAILURE);
case dns_c_zone_forward:
fprintf(fp, "ixfr-tmp-file \"%s\";\n", mzone->ixfr_tmp);
}
- if (mzone->pubkey != NULL) {
+ if (mzone->pubkeylist != NULL) {
dns_c_printtabs(lctx, fp, indent);
- dns_c_pubkey_print(lctx, fp, indent, mzone->pubkey);
+ dns_c_pklist_print(lctx, fp, indent, mzone->pubkeylist);
}
if (DNS_C_CHECKBIT(MZ_FORWARD_BIT, &mzone->setflags)) {
}
- if (szone->pubkey != NULL) {
+ if (szone->pubkeylist != NULL) {
dns_c_printtabs(lctx, fp, indent);
- dns_c_pubkey_print(lctx, fp, indent, szone->pubkey);
+ dns_c_pklist_print(lctx, fp, indent, szone->pubkeylist);
}
if (DNS_C_CHECKBIT(SZ_FORWARD_BIT, &szone->setflags)) {
tzone->max_trans_time_in);
}
- if (tzone->pubkey != NULL) {
+ if (tzone->pubkeylist != NULL) {
dns_c_printtabs(lctx, fp, indent);
- dns_c_pubkey_print(lctx, fp, indent, tzone->pubkey);
+ dns_c_pklist_print(lctx, fp, indent, tzone->pubkeylist);
}
if (DNS_C_CHECKBIT(TZ_FORWARD_BIT, &tzone->setflags)) {
dns_c_nameseverity2string(lctx, hzone->check_names,
ISC_TRUE));
}
+
+ if (hzone->pubkeylist != NULL) {
+ dns_c_printtabs(lctx, fp, indent);
+ dns_c_pklist_print(lctx, fp, indent, hzone->pubkeylist);
+ }
}
mzone->also_notify = NULL;
mzone->ixfr_base = NULL;
mzone->ixfr_tmp = NULL;
- mzone->pubkey = NULL;
+ mzone->pubkeylist = NULL;
mzone->forwarders = NULL;
memset(&mzone->setflags, 0x0, sizeof (mzone->setflags));
szone->allow_query = NULL;
szone->allow_transfer = NULL;
szone->also_notify = NULL;
- szone->pubkey = NULL;
+ szone->pubkeylist = NULL;
szone->forwarders = NULL;
memset(&szone->setflags, 0x0, sizeof (szone->setflags));
tzone->allow_update = NULL;
tzone->allow_query = NULL;
tzone->allow_transfer = NULL;
- tzone->pubkey = NULL;
+ tzone->pubkeylist = NULL;
tzone->forwarders = NULL;
memset(&tzone->setflags, 0x0, sizeof (tzone->setflags));
(void) lctx;
hzone->file = NULL;
+ hzone->pubkeylist = NULL;
memset(&hzone->setflags, 0x0, sizeof (hzone->setflags));
return (ISC_R_SUCCESS);
isc_mem_free(mem, mzone->ixfr_tmp);
}
- if (mzone->pubkey != NULL)
- dns_c_pubkey_delete(lctx, &mzone->pubkey);
+ if (mzone->pubkeylist != NULL)
+ dns_c_pklist_delete(lctx, &mzone->pubkeylist);
if (mzone->forwarders != NULL)
dns_c_iplist_detach(lctx, &mzone->forwarders);
if (szone->forwarders != NULL)
dns_c_iplist_detach(lctx, &szone->forwarders);
+ if (szone->pubkeylist != NULL)
+ dns_c_pklist_delete(lctx, &szone->pubkeylist);
+
return (ISC_R_SUCCESS);
}
if (tzone->allow_transfer != NULL)
dns_c_ipmatchlist_detach(lctx, &tzone->allow_transfer);
+ if (tzone->pubkeylist != NULL)
+ dns_c_pklist_delete(lctx, &tzone->pubkeylist);
return (ISC_R_SUCCESS);
}
isc_mem_free(mem, hzone->file);
}
+ if (hzone->pubkeylist != NULL)
+ dns_c_pklist_delete(lctx, &hzone->pubkeylist);
+
return (ISC_R_SUCCESS);
}
#include <dns/confip.h>
+
+#define DNS_C_CONFACL_MAGIC 0x4361636cU
+#define DNS_C_CONFACLTABLE_MAGIC 0x32616354U
+
+#define DNS_C_CONFACL_VALID(confacl) \
+ ISC_MAGIC_VALID(confacl, DNS_C_CONFACL_MAGIC)
+#define DNS_C_CONFACLTABLE_VALID(confacltable) \
+ ISC_MAGIC_VALID(confacltable, DNS_C_CONFACLTABLE_MAGIC)
+
+
/***
*** Types
***/
#include <dns/confip.h>
+#define DNS_C_CONFCTL_MAGIC 0x4363746cU
+#define DNS_C_CONFCTLLIST_MAGIC 0x4354424cU
+
+#define DNS_C_CONFCTLLIST_VALID(ptr) \
+ ISC_MAGIC_VALID(ptr, DNS_C_CONFCTLLIST_MAGIC)
+#define DNS_C_CONFCTL_VALID(ptr) \
+ ISC_MAGIC_VALID(ptr, DNS_C_CONFCTL_MAGIC)
+
+
+
/***
*** Types
***/
#include <dns/confcache.h>
#include <dns/confresolv.h>
+#define DNS_C_CONFIG_MAGIC 0x434f4e46U /* CONF */
+#define DNS_C_OPTION_MAGIC 0x4f707473U /* Opts */
+
+#define DNS_C_CONFCTX_VALID(ptr) ISC_MAGIC_VALID(ptr, DNS_C_CONFIG_MAGIC)
+#define DNS_C_CONFOPT_VALID(ptr) ISC_MAGIC_VALID(ptr, DNS_C_OPTION_MAGIC)
+
+
/***
*** Types
#include <dns/confcommon.h>
+#define DNS_C_IPLIST_MAGIC 0x49706c73 /* Ipls */ /* dns_c_iplist */
+#define DNS_C_IPMDIRECT_MAGIC 0x49506d64 /* IPmd */ /* dns_c_ipmatch_direct */
+#define DNS_C_IPMINDIRECT_MAGIC 0x69506d69 /* iPmi */ /* dns_c_ipmatch_indirect */
+#define DNS_C_IPMELEM_MAGIC 0x49704d65 /* IpMe */ /* dns_c_ipmatch_element */
+#define DNS_C_IPMLIST_MAGIC 0x69706d6c /* ipml */ /* dns_c_ipmatchlist */
+
+#define DNS_C_IPLIST_VALID(ptr) ISC_MAGIC_VALID(ptr,DNS_C_IPLIST_MAGIC)
+#define DNS_C_IPDIRECT_VALID(ptr) ISC_MAGIC_VALID(ptr, DNS_C_IPMDIRECT_MAGIC)
+#define DNS_C_IPINDIRECT_VALID(ptr) \
+ ISC_MAGIC_VALID(ptr, DNS_C_IPMINDIRECT_MAGIC)
+#define DNS_C_IPMELEM_VALID(ptr) ISC_MAGIC_VALID(ptr, DNS_C_IPMELEM_MAGIC)
+#define DNS_C_IPMLIST_VALID(ptr) ISC_MAGIC_VALID(ptr, DNS_C_IPMLIST_MAGIC)
+
+
+
+
/***
*** Types
***/
#include <dns/log.h>
+#define DNS_C_TKEY_MAGIC 0x544b4559 /* TKEY */
+#define DNS_C_TKEYLIST_MAGIC 0x544b4c53 /* TKLS */
+#define DNS_C_PUBKEY_MAGIC 0x5055424b /* PUBK */
+#define DNS_C_PKLIST_MAGIC 0x504b4c53 /* PKLS */
+#define DNS_C_KDEF_MAGIC 0x4b444546 /* KDEF */
+#define DNS_C_KDEFLIST_MAGIC 0x4b4c5354 /* KLST */
+#define DNS_C_KEYID_MAGIC 0x4b455949 /* KEYI */
+#define DNS_C_KEYIDLIST_MAGIC 0x4b494c53 /* KILS */
+
+#define DNS_C_TKEY_VALID(ptr) ISC_MAGIC_VALID(ptr, DNS_C_TKEY_MAGIC)
+#define DNS_C_TKEYLIST_VALID(ptr) ISC_MAGIC_VALID(ptr, DNS_C_TKEYLIST_MAGIC)
+#define DNS_C_PUBKEY_VALID(ptr) ISC_MAGIC_VALID(ptr, DNS_C_PUBKEY_MAGIC)
+#define DNS_C_PKLIST_VALID(ptr) ISC_MAGIC_VALID(ptr, DNS_C_PKLIST_MAGIC)
+#define DNS_C_KDEF_VALID(ptr) ISC_MAGIC_VALID(ptr, DNS_C_KDEF_MAGIC)
+#define DNS_C_KDEFLIST_VALID(ptr) ISC_MAGIC_VALID(ptr, DNS_C_KDEFLIST_MAGIC)
+#define DNS_C_KEYID_VALID(ptr) ISC_MAGIC_VALID(ptr, DNS_C_KEYID_MAGIC)
+#define DNS_C_KEYIDLIST_VALID(ptr) ISC_MAGIC_VALID(ptr, DNS_C_KEYIDLIST_MAGIC)
+
+
/***
*** Types
typedef struct dns_c_pubkey dns_c_pubkey_t;
+typedef struct dns_c_pklist dns_c_pklist_t;
typedef struct dns_c_tkey dns_c_tkey_t;
typedef struct dns_c_tkey_list dns_c_tkeylist_t;
typedef struct dns_c_kdef dns_c_kdef_t;
/* The type for holding a trusted key value. */
struct dns_c_tkey
{
+ isc_uint32_t magic;
isc_mem_t *mem;
char *domain;
/* A list of trusted keys. */
struct dns_c_tkey_list
{
+ isc_uint32_t magic;
isc_mem_t *mem;
ISC_LIST(dns_c_tkey_t) tkeylist;
/* A public key value */
struct dns_c_pubkey
{
+ isc_uint32_t magic;
isc_mem_t *mem;
isc_int32_t flags;
isc_int32_t protocol;
isc_int32_t algorithm;
char *key;
+
+ ISC_LINK(dns_c_pubkey_t) next;
+};
+
+/* A list of pubkeys */
+struct dns_c_pklist
+{
+ isc_uint32_t magic;
+ isc_mem_t *mem;
+
+ ISC_LIST(dns_c_pubkey_t) keylist;
};
/* A private key definition from a 'key' statement */
struct dns_c_kdef
{
+ isc_uint32_t magic;
dns_c_kdeflist_t *mylist;
char *keyid;
/* A list of private keys */
struct dns_c_kdef_list
{
+ isc_uint32_t magic;
isc_mem_t *mem;
ISC_LIST(dns_c_kdef_t) keydefs;
/* A key id for in a server statement 'keys' list */
struct dns_c_kid
{
+ isc_uint32_t magic;
dns_c_kidlist_t *mylist;
char *keyid;
struct dns_c_kid_list
{
isc_mem_t *mem;
+ isc_uint32_t magic;
ISC_LIST(dns_c_kid_t) keyids;
};
*** Functions
***/
+isc_result_t 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);
+isc_result_t dns_c_pklist_addpubkey(isc_log_t *lctx, 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,
+ 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_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,
+ 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_int32_t protocol,
#include <dns/confcommon.h>
+#define DNS_C_LOGCHAN_MAGIC 0x4c434841 /* LCHA */
+#define DNS_C_LOGCAT_MAGIC 0x4c434154 /* LCAT */
+#define DNS_C_LOGLIST_MAGIC 0x4c4c5354 /* LLST */
+
+
+#define DNS_C_LOGCHAN_VALID(ptr) ISC_MAGIC_VALID(ptr, DNS_C_LOGCHAN_MAGIC)
+#define DNS_C_LOGCAT_VALID(ptr) ISC_MAGIC_VALID(ptr, DNS_C_LOGCAT_MAGIC)
+#define DNS_C_LOGLIST_VALID(ptr) ISC_MAGIC_VALID(ptr, DNS_C_LOGLIST_MAGIC)
+
/***
*** Types
/* The structure that holds the list of channel and category definitions */
struct dns_c_logging_list
{
+ isc_uint32_t magic;
isc_mem_t *mem;
-
+
ISC_LIST(dns_c_logchan_t) channels;
ISC_LIST(dns_c_logcat_t) categories;
};
/* Definition of a logging channel */
struct dns_c_logchan
{
+ isc_uint32_t magic;
isc_mem_t *mem;
char *name;
/* Structure for holding a category definition */
struct dns_c_logcat
{
+ isc_uint32_t magic;
isc_mem_t *mem;
dns_c_category_t category;
#include <dns/confip.h>
+#define DNS_C_LISTEN_MAGIC 0x4c49534eU /* LISN */
+#define DNS_C_LLIST_MAGIC 0x4c6c6973U /* Llis */
+
+#define DNS_C_LISTEN_VALID(l) ISC_MAGIC_VALID(l, DNS_C_LISTEN_MAGIC)
+#define DNS_C_LISTENLIST_VALID(l) ISC_MAGIC_VALID(l, DNS_C_LLIST_MAGIC)
+
+
+
/***
*** Types
***/
#include <dns/confcommon.h>
+#define DNS_C_RRSOLIST_MAGIC 0x5252534c /* RRSL */
+#define DNS_C_RRSO_MAGIC 0x7272736f /* rrso */
+
+#define DNS_C_RRSOLIST_VALID(ptr) ISC_MAGIC_VALID(ptr, DNS_C_RRSOLIST_MAGIC)
+#define DNS_C_RRSO_VALID(ptr) ISC_MAGIC_VALID(ptr, DNS_C_RRSO_MAGIC)
+
+
+
/***
*** Types
***/
struct dns_c_rrso
{
+ isc_uint32_t magic;
+
isc_mem_t *mem;
dns_rdataclass_t oclass;
struct dns_c_rrso_list
{
+ isc_uint32_t magic;
+
isc_mem_t *mem;
ISC_LIST(dns_c_rrso_t) elements;
#include <dns/confcommon.h>
#include <dns/confkeys.h>
+
+#define DNS_C_SRVLIST_MAGIC 0x7365524c /* seRL */
+#define DNS_C_SRV_MAGIC 0x53457276 /* SErv */
+
+#define DNS_C_SRVLIST_VALID(ptr) ISC_MAGIC_VALID(ptr, DNS_C_SRVLIST_MAGIC)
+#define DNS_C_SRV_VALID(ptr) ISC_MAGIC_VALID(ptr, DNS_C_SRV_MAGIC)
+
+
/***
*** Types
***/
struct dns_c_srv_list
{
+ isc_uint32_t magic;
+
isc_mem_t *mem;
ISC_LIST(dns_c_srv_t) elements;
struct dns_c_srv
{
+ isc_uint32_t magic;
+
isc_mem_t *mem;
isc_sockaddr_t address;
#include <dns/conflsn.h>
#include <dns/confrrset.h>
+#define DNS_C_VIEWTABLE_MAGIC 0x76497774 /* vIwt */
+#define DNS_C_VIEW_MAGIC 0x56696557 /* VieW */
+#define DNS_C_VIEWTABLE_VALID(ptr) ISC_MAGIC_VALID(ptr, DNS_C_VIEWTABLE_MAGIC)
+#define DNS_C_VIEW_VALID(ptr) ISC_MAGIC_VALID(ptr, DNS_C_VIEW_MAGIC)
/***
*** Types
***/
struct dns_c_viewtable
{
+ isc_uint32_t magic;
+
isc_mem_t *mem;
ISC_LIST(dns_c_view_t) views;
struct dns_c_view
{
+ isc_uint32_t magic;
+
isc_mem_t *mem;
char *name;
char *ixfr_tmp;
isc_int32_t max_ixfr_log;
isc_boolean_t maint_ixfr_base;
- dns_c_pubkey_t *pubkey;
+ dns_c_pklist_t *pubkeylist;
dns_c_forw_t forward;
dns_c_iplist_t *forwarders;
char *ixfr_tmp;
isc_boolean_t maint_ixfr_base;
isc_int32_t max_ixfr_log;
- dns_c_pubkey_t *pubkey;
+ dns_c_pklist_t *pubkeylist;
in_port_t master_port;
dns_c_iplist_t *master_ips;
isc_sockaddr_t transfer_source;
dns_c_ipmatchlist_t *allow_query;
dns_c_ipmatchlist_t *allow_transfer; /* should be here??? */
isc_boolean_t dialup;
- dns_c_pubkey_t *pubkey;
+ dns_c_pklist_t *pubkeylist;
in_port_t master_port;
dns_c_iplist_t *master_ips;
isc_sockaddr_t transfer_source;
{
char *file;
dns_c_severity_t check_names;
+ dns_c_pklist_t *pubkeylist;
dns_c_setbits_t setflags;
};
const char *newval);
isc_result_t dns_c_zone_setixfrtmp(isc_log_t *lctx, dns_c_zone_t *zone,
const char *newval);
-isc_result_t dns_c_zone_setpubkey(isc_log_t *lctx, dns_c_zone_t *zone,
+isc_result_t dns_c_zone_addpubkey(isc_log_t *lctx, 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,
const char **retval);
isc_result_t dns_c_zone_getixfrtmp(isc_log_t *lctx, dns_c_zone_t *zone,
const char **retval);
-isc_result_t dns_c_zone_getpubkey(isc_log_t *lctx, dns_c_zone_t *zone,
- dns_c_pubkey_t **retval);
+isc_result_t dns_c_zone_getpubkeylist(isc_log_t *lctx, 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,
in_port_t *retval);
isc_result_t dns_c_zone_getmasterips(isc_log_t *lctx, dns_c_zone_t *zone,
* SOFTWARE.
*/
- /* $Id: zone.c,v 1.36 1999/11/17 21:52:32 brister Exp $ */
+ /* $Id: zone.c,v 1.37 1999/12/01 16:28:53 brister Exp $ */
#include <config.h>
dns_c_severity_t severity;
dns_c_iplist_t *iplist = NULL;
dns_c_pubkey_t *pubkey = NULL;
+ dns_c_pklist_t *pubkeylist = NULL;
isc_uint32_t i;
isc_sockaddr_t sockaddr;
isc_int32_t xfrtime;
} else
dns_zone_clearnotify(zone);
+#if 1 /* XXX brister */
+
+ iresult = dns_c_zone_getpubkeylist(lctx, czone, &pubkeylist);
+ if (iresult == ISC_R_SUCCESS) {
+ pubkey = ISC_LIST_HEAD(pubkeylist->keylist);
+ }
+ dns_zone_setpubkey(zone, pubkey);
+
+#else
+
iresult = dns_c_zone_getpubkey(lctx, czone, &pubkey);
if (iresult == ISC_R_SUCCESS)
dns_zone_setpubkey(zone, pubkey);
else
dns_zone_setpubkey(zone, NULL);
break;
-
+
+#endif
+
case dns_c_zone_forward:
#ifdef notyet
/*
} else
dns_zone_clearqueryacl(zone);
+#if 1 /* XXX brister */
+
+ iresult = dns_c_zone_getpubkeylist(lctx, czone, &pubkeylist);
+ if (iresult == ISC_R_SUCCESS) {
+ pubkey = ISC_LIST_HEAD(pubkeylist->keylist);
+ }
+ dns_zone_setpubkey(zone, pubkey);
+
+#else
+
iresult = dns_c_zone_getpubkey(lctx, czone, &pubkey);
if (iresult == ISC_R_SUCCESS)
dns_zone_setpubkey(zone, pubkey);
else
dns_zone_setpubkey(zone, NULL);
+#endif
+
iresult = dns_c_zone_getmasterport(lctx, czone, &port);
if (iresult != ISC_R_SUCCESS)
port = 53;
} else
dns_zone_clearqueryacl(zone);
+#if 1 /* XXX brister */
+
+ iresult = dns_c_zone_getpubkeylist(lctx, czone, &pubkeylist);
+ if (iresult == ISC_R_SUCCESS) {
+ pubkey = ISC_LIST_HEAD(pubkeylist->keylist);
+ }
+ dns_zone_setpubkey(zone, pubkey);
+
+#else
+
iresult = dns_c_zone_getpubkey(lctx, czone, &pubkey);
if (iresult == ISC_R_SUCCESS)
dns_zone_setpubkey(zone, pubkey);
else
dns_zone_setpubkey(zone, NULL);
+#endif
+
iresult = dns_c_zone_getmasterport(lctx, czone, &port);
if (iresult != ISC_R_SUCCESS)
port = 53;
else
dns_zone_setchecknames(zone, dns_c_severity_fail);
+#if 1 /* XXX brister */
+
+ iresult = dns_c_zone_getpubkeylist(lctx, czone, &pubkeylist);
+ if (iresult == ISC_R_SUCCESS) {
+ pubkey = ISC_LIST_HEAD(pubkeylist->keylist);
+ }
+ dns_zone_setpubkey(zone, pubkey);
+
+#else
+
iresult = dns_c_zone_getpubkey(lctx, czone, &pubkey);
if (iresult == ISC_R_SUCCESS)
dns_zone_setpubkey(zone, pubkey);
else
dns_zone_setpubkey(zone, NULL);
break;
+
+#endif
}
return (DNS_R_SUCCESS);
projects / thirdparty / bind9.git / commitdiff
