upstream/bind9
1
0
Fork 0
mirror of https://github.com/isc-projects/bind9.git synced 2026-02-10 06:13:24 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

apply the modified style

Browse source
This commit is contained in:
Evan Hunt 2020-02-13 14:44:37 -08:00
parent 0255a97473
commit e851ed0bb5
669 changed files with 35995 additions and 42219 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

149
bin/check/check-tool.c
View file

@ -67,20 +67,20 @@
goto cleanup; \
} while (0)
#define ERR_IS_CNAME 1
#define ERR_NO_ADDRESSES 2
#define ERR_IS_CNAME 1
#define ERR_NO_ADDRESSES 2
#define ERR_LOOKUP_FAILURE 3
#define ERR_EXTRA_A 4
#define ERR_EXTRA_AAAA 5
#define ERR_MISSING_GLUE 5
#define ERR_IS_MXCNAME 6
#define ERR_IS_SRVCNAME 7
#define ERR_EXTRA_A 4
#define ERR_EXTRA_AAAA 5
#define ERR_MISSING_GLUE 5
#define ERR_IS_MXCNAME 6
#define ERR_IS_SRVCNAME 7
static const char *dbtype[] = { "rbt" };
int debug = 0;
int debug = 0;
const char *journal = NULL;
bool nomerge = true;
bool nomerge = true;
#if CHECK_LOCAL
bool docheckmx = true;
bool dochecksrv = true;
@ -107,20 +107,18 @@ static isc_logcategory_t categories[] = { { "", 0 },
{ NULL, 0 } };
static isc_symtab_t *symtab = NULL;
static isc_mem_t * sym_mctx;
static isc_mem_t *sym_mctx;
static void
freekey(char *key, unsigned int type, isc_symvalue_t value, void *userarg)
{
freekey(char *key, unsigned int type, isc_symvalue_t value, void *userarg) {
UNUSED(type);
UNUSED(value);
isc_mem_free(userarg, key);
}
static void
add(char *key, int value)
{
isc_result_t result;
add(char *key, int value) {
isc_result_t result;
isc_symvalue_t symvalue;
if (sym_mctx == NULL) {
@ -146,8 +144,7 @@ add(char *key, int value)
}
static bool
logged(char *key, int value)
{
logged(char *key, int value) {
isc_result_t result;
if (symtab == NULL) {
@ -163,19 +160,18 @@ logged(char *key, int value)
static bool
checkns(dns_zone_t *zone, const dns_name_t *name, const dns_name_t *owner,
dns_rdataset_t *a, dns_rdataset_t *aaaa)
{
dns_rdataset_t *a, dns_rdataset_t *aaaa) {
dns_rdataset_t *rdataset;
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdata_t rdata = DNS_RDATA_INIT;
struct addrinfo hints, *ai, *cur;
char namebuf[DNS_NAME_FORMATSIZE + 1];
char ownerbuf[DNS_NAME_FORMATSIZE];
char namebuf[DNS_NAME_FORMATSIZE + 1];
char ownerbuf[DNS_NAME_FORMATSIZE];
char addrbuf[sizeof("xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:123.123.123.123")];
bool answer = true;
bool match;
const char *type;
void * ptr = NULL;
int result;
void *ptr = NULL;
int result;
REQUIRE(a == NULL || !dns_rdataset_isassociated(a) ||
a->type == dns_rdatatype_a);
@ -216,7 +212,8 @@ checkns(dns_zone_t *zone, const dns_name_t *name, const dns_name_t *owner,
}
if (cur != NULL && cur->ai_canonname != NULL &&
strcasecmp(cur->ai_canonname, namebuf) != 0 &&
!logged(namebuf, ERR_IS_CNAME)) {
!logged(namebuf, ERR_IS_CNAME))
{
dns_zone_log(zone, ISC_LOG_ERROR,
"%s/NS '%s' (out of zone) "
"is a CNAME '%s' (illegal)",
@ -350,8 +347,8 @@ checkmissing:
}
while (result == ISC_R_SUCCESS && !match) {
dns_rdataset_current(rdataset, &rdata);
if (memcmp(ptr, rdata.data, rdata.length) ==
0) {
if (memcmp(ptr, rdata.data, rdata.length) == 0)
{
match = true;
}
dns_rdata_reset(&rdata);
@ -379,14 +376,13 @@ checkmissing:
}
static bool
checkmx(dns_zone_t *zone, const dns_name_t *name, const dns_name_t *owner)
{
checkmx(dns_zone_t *zone, const dns_name_t *name, const dns_name_t *owner) {
struct addrinfo hints, *ai, *cur;
char namebuf[DNS_NAME_FORMATSIZE + 1];
char ownerbuf[DNS_NAME_FORMATSIZE];
int result;
int level = ISC_LOG_ERROR;
bool answer = true;
char namebuf[DNS_NAME_FORMATSIZE + 1];
char ownerbuf[DNS_NAME_FORMATSIZE];
int result;
int level = ISC_LOG_ERROR;
bool answer = true;
memset(&hints, 0, sizeof(hints));
hints.ai_flags = AI_CANONNAME;
@ -417,7 +413,8 @@ checkmx(dns_zone_t *zone, const dns_name_t *name, const dns_name_t *owner)
cur = cur->ai_next;
}
if (cur != NULL && cur->ai_canonname != NULL &&
strcasecmp(cur->ai_canonname, namebuf) != 0) {
strcasecmp(cur->ai_canonname, namebuf) != 0)
{
if ((zone_options & DNS_ZONEOPT_WARNMXCNAME) != 0) {
level = ISC_LOG_WARNING;
}
@ -465,14 +462,13 @@ checkmx(dns_zone_t *zone, const dns_name_t *name, const dns_name_t *owner)
}
static bool
checksrv(dns_zone_t *zone, const dns_name_t *name, const dns_name_t *owner)
{
checksrv(dns_zone_t *zone, const dns_name_t *name, const dns_name_t *owner) {
struct addrinfo hints, *ai, *cur;
char namebuf[DNS_NAME_FORMATSIZE + 1];
char ownerbuf[DNS_NAME_FORMATSIZE];
int result;
int level = ISC_LOG_ERROR;
bool answer = true;
char namebuf[DNS_NAME_FORMATSIZE + 1];
char ownerbuf[DNS_NAME_FORMATSIZE];
int result;
int level = ISC_LOG_ERROR;
bool answer = true;
memset(&hints, 0, sizeof(hints));
hints.ai_flags = AI_CANONNAME;
@ -503,7 +499,8 @@ checksrv(dns_zone_t *zone, const dns_name_t *name, const dns_name_t *owner)
cur = cur->ai_next;
}
if (cur != NULL && cur->ai_canonname != NULL &&
strcasecmp(cur->ai_canonname, namebuf) != 0) {
strcasecmp(cur->ai_canonname, namebuf) != 0)
{
if ((zone_options & DNS_ZONEOPT_WARNSRVCNAME) != 0) {
level = ISC_LOG_WARNING;
}
@ -551,11 +548,10 @@ checksrv(dns_zone_t *zone, const dns_name_t *name, const dns_name_t *owner)
}
isc_result_t
setup_logging(isc_mem_t *mctx, FILE *errout, isc_log_t **logp)
{
setup_logging(isc_mem_t *mctx, FILE *errout, isc_log_t **logp) {
isc_logdestination_t destination;
isc_logconfig_t * logconfig = NULL;
isc_log_t * log = NULL;
isc_logconfig_t *logconfig = NULL;
isc_log_t *log = NULL;
RUNTIME_CHECK(isc_log_create(mctx, &log, &logconfig) == ISC_R_SUCCESS);
isc_log_registercategories(log, categories);
@ -581,17 +577,16 @@ setup_logging(isc_mem_t *mctx, FILE *errout, isc_log_t **logp)
/*% scan the zone for oversize TTLs */
static isc_result_t
check_ttls(dns_zone_t *zone, dns_ttl_t maxttl)
{
isc_result_t result;
dns_db_t * db = NULL;
dns_dbversion_t * version = NULL;
dns_dbnode_t * node = NULL;
dns_dbiterator_t * dbiter = NULL;
check_ttls(dns_zone_t *zone, dns_ttl_t maxttl) {
isc_result_t result;
dns_db_t *db = NULL;
dns_dbversion_t *version = NULL;
dns_dbnode_t *node = NULL;
dns_dbiterator_t *dbiter = NULL;
dns_rdatasetiter_t *rdsiter = NULL;
dns_rdataset_t rdataset;
dns_fixedname_t fname;
dns_name_t * name;
dns_rdataset_t rdataset;
dns_fixedname_t fname;
dns_name_t *name;
name = dns_fixedname_initname(&fname);
dns_rdataset_init(&rdataset);
@ -602,7 +597,8 @@ check_ttls(dns_zone_t *zone, dns_ttl_t maxttl)
CHECK(dns_db_createiterator(db, 0, &dbiter));
for (result = dns_dbiterator_first(dbiter); result == ISC_R_SUCCESS;
result = dns_dbiterator_next(dbiter)) {
result = dns_dbiterator_next(dbiter))
{
result = dns_dbiterator_current(dbiter, &node, name);
if (result == DNS_R_NEWORIGIN) {
result = ISC_R_SUCCESS;
@ -612,11 +608,12 @@ check_ttls(dns_zone_t *zone, dns_ttl_t maxttl)
CHECK(dns_db_allrdatasets(db, node, version, 0, &rdsiter));
for (result = dns_rdatasetiter_first(rdsiter);
result == ISC_R_SUCCESS;
result = dns_rdatasetiter_next(rdsiter)) {
result = dns_rdatasetiter_next(rdsiter))
{
dns_rdatasetiter_current(rdsiter, &rdataset);
if (rdataset.ttl > maxttl) {
char nbuf[DNS_NAME_FORMATSIZE];
char tbuf[255];
char nbuf[DNS_NAME_FORMATSIZE];
char tbuf[255];
isc_buffer_t b;
isc_region_t r;
@ -672,15 +669,14 @@ cleanup:
isc_result_t
load_zone(isc_mem_t *mctx, const char *zonename, const char *filename,
dns_masterformat_t fileformat, const char *classname,
dns_ttl_t maxttl, dns_zone_t **zonep)
{
isc_result_t result;
dns_ttl_t maxttl, dns_zone_t **zonep) {
isc_result_t result;
dns_rdataclass_t rdclass;
isc_textregion_t region;
isc_buffer_t buffer;
dns_fixedname_t fixorigin;
dns_name_t * origin;
dns_zone_t * zone = NULL;
isc_buffer_t buffer;
dns_fixedname_t fixorigin;
dns_name_t *origin;
dns_zone_t *zone = NULL;
REQUIRE(zonep == NULL || *zonep == NULL);
@ -751,11 +747,10 @@ cleanup:
isc_result_t
dump_zone(const char *zonename, dns_zone_t *zone, const char *filename,
dns_masterformat_t fileformat, const dns_master_style_t *style,
const uint32_t rawversion)
{
const uint32_t rawversion) {
isc_result_t result;
FILE * output = stdout;
const char * flags;
FILE *output = stdout;
const char *flags;
flags = (fileformat == dns_masterformat_text) ? "w" : "wb";
@ -791,11 +786,10 @@ dump_zone(const char *zonename, dns_zone_t *zone, const char *filename,
#ifdef _WIN32
void
InitSockets(void)
{
WORD wVersionRequested;
InitSockets(void) {
WORD wVersionRequested;
WSADATA wsaData;
int err;
int err;
wVersionRequested = MAKEWORD(2, 0);
@ -807,8 +801,7 @@ InitSockets(void)
}
void
DestroySockets(void)
{
DestroySockets(void) {
WSACleanup();
}
#endif /* ifdef _WIN32 */

163
bin/check/named-checkconf.c
View file

@ -56,12 +56,10 @@ isc_log_t *logc = NULL;
} while (0)
/*% usage */
ISC_PLATFORM_NORETURN_PRE static void
usage(void) ISC_PLATFORM_NORETURN_POST;
ISC_PLATFORM_NORETURN_PRE static void usage(void) ISC_PLATFORM_NORETURN_POST;
static void
usage(void)
{
usage(void) {
fprintf(stderr,
"usage: %s [-chijlvz] [-p [-x]] [-t directory] "
"[named.conf]\n",
@ -71,10 +69,9 @@ usage(void)
/*% directory callback */
static isc_result_t
directory_callback(const char *clausename, const cfg_obj_t *obj, void *arg)
{
directory_callback(const char *clausename, const cfg_obj_t *obj, void *arg) {
isc_result_t result;
const char * directory;
const char *directory;
REQUIRE(strcasecmp("directory", clausename) == 0);
@ -97,8 +94,7 @@ directory_callback(const char *clausename, const cfg_obj_t *obj, void *arg)
}
static bool
get_maps(const cfg_obj_t **maps, const char *name, const cfg_obj_t **obj)
{
get_maps(const cfg_obj_t **maps, const char *name, const cfg_obj_t **obj) {
int i;
for (i = 0;; i++) {
if (maps[i] == NULL) {
@ -111,14 +107,13 @@ get_maps(const cfg_obj_t **maps, const char *name, const cfg_obj_t **obj)
}
static bool
get_checknames(const cfg_obj_t **maps, const cfg_obj_t **obj)
{
get_checknames(const cfg_obj_t **maps, const cfg_obj_t **obj) {
const cfg_listelt_t *element;
const cfg_obj_t * checknames;
const cfg_obj_t * type;
const cfg_obj_t * value;
isc_result_t result;
int i;
const cfg_obj_t *checknames;
const cfg_obj_t *type;
const cfg_obj_t *value;
isc_result_t result;
int i;
for (i = 0;; i++) {
if (maps[i] == NULL) {
@ -134,13 +129,14 @@ get_checknames(const cfg_obj_t **maps, const cfg_obj_t **obj)
return (true);
}
for (element = cfg_list_first(checknames); element != NULL;
element = cfg_list_next(element)) {
element = cfg_list_next(element))
{
value = cfg_listelt_value(element);
type = cfg_tuple_get(value, "type");
if ((strcasecmp(cfg_obj_asstring(type), "primary") !=
0) &&
(strcasecmp(cfg_obj_asstring(type), "master") !=
0)) {
(strcasecmp(cfg_obj_asstring(type), "master") != 0))
{
continue;
}
*obj = cfg_tuple_get(value, "mode");
@ -150,10 +146,9 @@ get_checknames(const cfg_obj_t **maps, const cfg_obj_t **obj)
}
static isc_result_t
configure_hint(const char *zfile, const char *zclass, isc_mem_t *mctx)
{
isc_result_t result;
dns_db_t * db = NULL;
configure_hint(const char *zfile, const char *zclass, isc_mem_t *mctx) {
isc_result_t result;
dns_db_t *db = NULL;
dns_rdataclass_t rdclass;
isc_textregion_t r;
@ -181,26 +176,25 @@ configure_hint(const char *zfile, const char *zclass, isc_mem_t *mctx)
static isc_result_t
configure_zone(const char *vclass, const char *view, const cfg_obj_t *zconfig,
const cfg_obj_t *vconfig, const cfg_obj_t *config,
isc_mem_t *mctx, bool list)
{
int i = 0;
isc_result_t result;
const char * zclass;
const char * zname;
const char * zfile = NULL;
const cfg_obj_t * maps[4];
const cfg_obj_t * mastersobj = NULL;
const cfg_obj_t * inviewobj = NULL;
const cfg_obj_t * zoptions = NULL;
const cfg_obj_t * classobj = NULL;
const cfg_obj_t * typeobj = NULL;
const cfg_obj_t * fileobj = NULL;
const cfg_obj_t * dlzobj = NULL;
const cfg_obj_t * dbobj = NULL;
const cfg_obj_t * obj = NULL;
const cfg_obj_t * fmtobj = NULL;
isc_mem_t *mctx, bool list) {
int i = 0;
isc_result_t result;
const char *zclass;
const char *zname;
const char *zfile = NULL;
const cfg_obj_t *maps[4];
const cfg_obj_t *mastersobj = NULL;
const cfg_obj_t *inviewobj = NULL;
const cfg_obj_t *zoptions = NULL;
const cfg_obj_t *classobj = NULL;
const cfg_obj_t *typeobj = NULL;
const cfg_obj_t *fileobj = NULL;
const cfg_obj_t *dlzobj = NULL;
const cfg_obj_t *dbobj = NULL;
const cfg_obj_t *obj = NULL;
const cfg_obj_t *fmtobj = NULL;
dns_masterformat_t masterformat;
dns_ttl_t maxttl = 0;
dns_ttl_t maxttl = 0;
zone_options = DNS_ZONEOPT_CHECKNS | DNS_ZONEOPT_MANYERRORS;
@ -250,7 +244,8 @@ configure_zone(const char *vclass, const char *view, const cfg_obj_t *zconfig,
*/
cfg_map_get(zoptions, "database", &dbobj);
if (dbobj != NULL && strcmp("rbt", cfg_obj_asstring(dbobj)) != 0 &&
strcmp("rbt64", cfg_obj_asstring(dbobj)) != 0) {
strcmp("rbt64", cfg_obj_asstring(dbobj)) != 0)
{
return (ISC_R_SUCCESS);
}
@ -273,7 +268,8 @@ configure_zone(const char *vclass, const char *view, const cfg_obj_t *zconfig,
return (configure_hint(zfile, zclass, mctx));
} else if ((strcasecmp(cfg_obj_asstring(typeobj), "primary") != 0) &&
(strcasecmp(cfg_obj_asstring(typeobj), "master") != 0) &&
(strcasecmp(cfg_obj_asstring(typeobj), "redirect") != 0)) {
(strcasecmp(cfg_obj_asstring(typeobj), "redirect") != 0))
{
return (ISC_R_SUCCESS);
}
@ -459,13 +455,12 @@ configure_zone(const char *vclass, const char *view, const cfg_obj_t *zconfig,
/*% configure a view */
static isc_result_t
configure_view(const char *vclass, const char *view, const cfg_obj_t *config,
const cfg_obj_t *vconfig, isc_mem_t *mctx, bool list)
{
const cfg_obj_t *vconfig, isc_mem_t *mctx, bool list) {
const cfg_listelt_t *element;
const cfg_obj_t * voptions;
const cfg_obj_t * zonelist;
isc_result_t result = ISC_R_SUCCESS;
isc_result_t tresult;
const cfg_obj_t *voptions;
const cfg_obj_t *zonelist;
isc_result_t result = ISC_R_SUCCESS;
isc_result_t tresult;
voptions = NULL;
if (vconfig != NULL) {
@ -480,7 +475,8 @@ configure_view(const char *vclass, const char *view, const cfg_obj_t *config,
}
for (element = cfg_list_first(zonelist); element != NULL;
element = cfg_list_next(element)) {
element = cfg_list_next(element))
{
const cfg_obj_t *zconfig = cfg_listelt_value(element);
tresult = configure_zone(vclass, view, zconfig, vconfig, config,
mctx, list);
@ -493,8 +489,7 @@ configure_view(const char *vclass, const char *view, const cfg_obj_t *config,
static isc_result_t
config_getclass(const cfg_obj_t *classobj, dns_rdataclass_t defclass,
dns_rdataclass_t *classp)
{
dns_rdataclass_t *classp) {
isc_textregion_t r;
if (!cfg_obj_isstring(classobj)) {
@ -508,23 +503,24 @@ config_getclass(const cfg_obj_t *classobj, dns_rdataclass_t defclass,
/*% load zones from the configuration */
static isc_result_t
load_zones_fromconfig(const cfg_obj_t *config, isc_mem_t *mctx, bool list_zones)
{
load_zones_fromconfig(const cfg_obj_t *config, isc_mem_t *mctx,
bool list_zones) {
const cfg_listelt_t *element;
const cfg_obj_t * views;
const cfg_obj_t * vconfig;
isc_result_t result = ISC_R_SUCCESS;
isc_result_t tresult;
const cfg_obj_t *views;
const cfg_obj_t *vconfig;
isc_result_t result = ISC_R_SUCCESS;
isc_result_t tresult;
views = NULL;
(void)cfg_map_get(config, "view", &views);
for (element = cfg_list_first(views); element != NULL;
element = cfg_list_next(element)) {
element = cfg_list_next(element))
{
const cfg_obj_t *classobj;
dns_rdataclass_t viewclass;
const char * vname;
char buf[sizeof("CLASS65535")];
const char *vname;
char buf[sizeof("CLASS65535")];
vconfig = cfg_listelt_value(element);
if (vconfig == NULL) {
@ -559,8 +555,7 @@ cleanup:
}
static void
output(void *closure, const char *text, int textlen)
{
output(void *closure, const char *text, int textlen) {
UNUSED(closure);
if (fwrite(text, 1, textlen, stdout) != (size_t)textlen) {
perror("fwrite");
@ -570,20 +565,19 @@ output(void *closure, const char *text, int textlen)
/*% The main processing routine */
int
main(int argc, char **argv)
{
int c;
main(int argc, char **argv) {
int c;
cfg_parser_t *parser = NULL;
cfg_obj_t * config = NULL;
const char * conffile = NULL;
isc_mem_t * mctx = NULL;
isc_result_t result;
int exit_status = 0;
bool load_zones = false;
bool list_zones = false;
bool print = false;
bool nodeprecate = false;
unsigned int flags = 0;
cfg_obj_t *config = NULL;
const char *conffile = NULL;
isc_mem_t *mctx = NULL;
isc_result_t result;
int exit_status = 0;
bool load_zones = false;
bool list_zones = false;
bool print = false;
bool nodeprecate = false;
unsigned int flags = 0;
isc_commandline_errprint = false;
@ -594,16 +588,16 @@ main(int argc, char **argv)
while ((c = isc_commandline_parse(argc, argv, CMDLINE_FLAGS)) != -1) {
switch (c) {
case 'm':
if (strcasecmp(isc_commandline_argument, "record") ==
0) {
if (strcasecmp(isc_commandline_argument, "record") == 0)
{
isc_mem_debugging |= ISC_MEM_DEBUGRECORD;
}
if (strcasecmp(isc_commandline_argument, "trace") ==
0) {
if (strcasecmp(isc_commandline_argument, "trace") == 0)
{
isc_mem_debugging |= ISC_MEM_DEBUGTRACE;
}
if (strcasecmp(isc_commandline_argument, "usage") ==
0) {
if (strcasecmp(isc_commandline_argument, "usage") == 0)
{
isc_mem_debugging |= ISC_MEM_DEBUGUSAGE;
}
if (strcasecmp(isc_commandline_argument, "size") == 0) {
@ -725,7 +719,8 @@ main(int argc, char **argv)
cfg_parser_setcallback(parser, directory_callback, NULL);
if (cfg_parse_file(parser, conffile, &cfg_type_namedconf, &config) !=
ISC_R_SUCCESS) {
ISC_R_SUCCESS)
{
exit(1);
}

78
bin/check/named-checkzone.c
View file

@ -42,13 +42,13 @@
#include "check-tool.h"
static int quiet = 0;
static isc_mem_t * mctx = NULL;
dns_zone_t * zone = NULL;
dns_zonetype_t zonetype = dns_zone_master;
static int dumpzone = 0;
static const char * output_filename;
static const char * prog_name = NULL;
static int quiet = 0;
static isc_mem_t *mctx = NULL;
dns_zone_t *zone = NULL;
dns_zonetype_t zonetype = dns_zone_master;
static int dumpzone = 0;
static const char *output_filename;
static const char *prog_name = NULL;
static const dns_master_style_t *outputstyle = NULL;
static enum { progmode_check, progmode_compile } progmode;
@ -62,12 +62,10 @@ static enum { progmode_check, progmode_compile } progmode;
} \
} while (0)
ISC_PLATFORM_NORETURN_PRE static void
usage(void) ISC_PLATFORM_NORETURN_POST;
ISC_PLATFORM_NORETURN_PRE static void usage(void) ISC_PLATFORM_NORETURN_POST;
static void
usage(void)
{
usage(void) {
fprintf(stderr,
"usage: %s [-djqvD] [-c class] "
"[-f inputformat] [-F outputformat] [-J filename] "
@ -84,8 +82,7 @@ usage(void)
}
static void
destroy(void)
{
destroy(void) {
if (zone != NULL) {
dns_zone_detach(&zone);
}
@ -93,27 +90,26 @@ destroy(void)
/*% main processing routine */
int
main(int argc, char **argv)
{
int c;
char * origin = NULL;
char * filename = NULL;
isc_log_t * lctx = NULL;
isc_result_t result;
char classname_in[] = "IN";
char * classname = classname_in;
const char * workdir = NULL;
const char * inputformatstr = NULL;
const char * outputformatstr = NULL;
dns_masterformat_t inputformat = dns_masterformat_text;
dns_masterformat_t outputformat = dns_masterformat_text;
main(int argc, char **argv) {
int c;
char *origin = NULL;
char *filename = NULL;
isc_log_t *lctx = NULL;
isc_result_t result;
char classname_in[] = "IN";
char *classname = classname_in;
const char *workdir = NULL;
const char *inputformatstr = NULL;
const char *outputformatstr = NULL;
dns_masterformat_t inputformat = dns_masterformat_text;
dns_masterformat_t outputformat = dns_masterformat_text;
dns_masterrawheader_t header;
uint32_t rawversion = 1, serialnum = 0;
dns_ttl_t maxttl = 0;
bool snset = false;
bool logdump = false;
FILE * errout = stdout;
char * endp;
uint32_t rawversion = 1, serialnum = 0;
dns_ttl_t maxttl = 0;
bool snset = false;
bool logdump = false;
FILE *errout = stdout;
char *endp;
/*
* Uncomment the following line if memory debugging is needed:
@ -153,11 +149,11 @@ main(int argc, char **argv)
/* Compilation specific defaults */
if (progmode == progmode_compile) {
zone_options |=
(DNS_ZONEOPT_CHECKNS | DNS_ZONEOPT_FATALNS |
DNS_ZONEOPT_CHECKSPF | DNS_ZONEOPT_CHECKDUPRR |
DNS_ZONEOPT_CHECKNAMES | DNS_ZONEOPT_CHECKNAMESFAIL |
DNS_ZONEOPT_CHECKWILDCARD);
zone_options |= (DNS_ZONEOPT_CHECKNS | DNS_ZONEOPT_FATALNS |
DNS_ZONEOPT_CHECKSPF | DNS_ZONEOPT_CHECKDUPRR |
DNS_ZONEOPT_CHECKNAMES |
DNS_ZONEOPT_CHECKNAMESFAIL |
DNS_ZONEOPT_CHECKWILDCARD);
} else {
zone_options |= (DNS_ZONEOPT_CHECKDUPRR | DNS_ZONEOPT_CHECKSPF);
}
@ -168,7 +164,8 @@ main(int argc, char **argv)
while ((c = isc_commandline_parse(argc, argv,
"c:df:hi:jJ:k:L:l:m:n:qr:s:t:o:vw:DF:"
"M:S:T:W:")) != EOF) {
"M:S:T:W:")) != EOF)
{
switch (c) {
case 'c':
classname = isc_commandline_argument;
@ -508,7 +505,8 @@ main(int argc, char **argv)
if (dumpzone &&
(output_filename == NULL || strcmp(output_filename, "-") == 0 ||
strcmp(output_filename, "/dev/fd/1") == 0 ||
strcmp(output_filename, "/dev/stdout") == 0)) {
strcmp(output_filename, "/dev/stdout") == 0))
{
errout = stderr;
logdump = false;
}

32
bin/confgen/ddns-confgen.c
View file

@ -48,7 +48,7 @@
#include <confgen/os.h>
#include <dst/dst.h>
#define KEYGEN_DEFAULT "tsig-key"
#define KEYGEN_DEFAULT "tsig-key"
#define CONFGEN_DEFAULT "ddns-key"
static char program[256];
@ -60,8 +60,7 @@ ISC_PLATFORM_NORETURN_PRE static void
usage(int status) ISC_PLATFORM_NORETURN_POST;
static void
usage(int status)
{
usage(int status) {
if (progmode == progmode_confgen) {
fprintf(stderr, "\
Usage:\n\
@ -84,23 +83,22 @@ Usage:\n\
}
int
main(int argc, char **argv)
{
main(int argc, char **argv) {
isc_result_t result = ISC_R_SUCCESS;
bool show_final_mem = false;
bool quiet = false;
bool show_final_mem = false;
bool quiet = false;
isc_buffer_t key_txtbuffer;
char key_txtsecret[256];
isc_mem_t * mctx = NULL;
const char * keyname = NULL;
const char * zone = NULL;
const char * self_domain = NULL;
char * keybuf = NULL;
char key_txtsecret[256];
isc_mem_t *mctx = NULL;
const char *keyname = NULL;
const char *zone = NULL;
const char *self_domain = NULL;
char *keybuf = NULL;
dns_secalg_t alg = DST_ALG_HMACSHA256;
const char * algname;
int keysize = 256;
int len = 0;
int ch;
const char *algname;
int keysize = 256;
int len = 0;
int ch;
#if USE_PKCS11
pk11_result_register();

23
bin/confgen/keygen.c
View file

@ -37,8 +37,7 @@
* Convert algorithm type to string.
*/
const char *
alg_totext(dns_secalg_t alg)
{
alg_totext(dns_secalg_t alg) {
switch (alg) {
case DST_ALG_HMACMD5:
return ("hmac-md5");
@ -61,8 +60,7 @@ alg_totext(dns_secalg_t alg)
* Convert string to algorithm type.
*/
dns_secalg_t
alg_fromtext(const char *name)
{
alg_fromtext(const char *name) {
const char *p = name;
if (strncasecmp(p, "hmac-", 5) == 0) {
p = &name[5];
@ -93,8 +91,7 @@ alg_fromtext(const char *name)
* Return default keysize for a given algorithm type.
*/
int
alg_bits(dns_secalg_t alg)
{
alg_bits(dns_secalg_t alg) {
switch (alg) {
case DST_ALG_HMACMD5:
return (128);
@ -118,13 +115,12 @@ alg_bits(dns_secalg_t alg)
*/
void
generate_key(isc_mem_t *mctx, dns_secalg_t alg, int keysize,
isc_buffer_t *key_txtbuffer)
{
isc_buffer_t *key_txtbuffer) {
isc_result_t result = ISC_R_SUCCESS;
isc_buffer_t key_rawbuffer;
isc_region_t key_rawregion;
char key_rawsecret[64];
dst_key_t * key = NULL;
char key_rawsecret[64];
dst_key_t *key = NULL;
switch (alg) {
case DST_ALG_HMACMD5:
@ -176,11 +172,10 @@ generate_key(isc_mem_t *mctx, dns_secalg_t alg, int keysize,
*/
void
write_key_file(const char *keyfile, const char *user, const char *keyname,
isc_buffer_t *secret, dns_secalg_t alg)
{
isc_buffer_t *secret, dns_secalg_t alg) {
isc_result_t result;
const char * algname = alg_totext(alg);
FILE * fd = NULL;
const char *algname = alg_totext(alg);
FILE *fd = NULL;
DO("create keyfile", isc_file_safecreate(keyfile, &fd));

53
bin/confgen/rndc-confgen.c
View file

@ -48,8 +48,8 @@
#include <pk11/site.h>
#define DEFAULT_KEYNAME "rndc-key"
#define DEFAULT_SERVER "127.0.0.1"
#define DEFAULT_PORT 953
#define DEFAULT_SERVER "127.0.0.1"
#define DEFAULT_PORT 953
static char program[256];
const char *progname;
@ -62,8 +62,7 @@ ISC_PLATFORM_NORETURN_PRE static void
usage(int status) ISC_PLATFORM_NORETURN_POST;
static void
usage(int status)
{
usage(int status) {
fprintf(stderr, "\
Usage:\n\
%s [-a] [-b bits] [-c keyfile] [-k keyname] [-p port] \
@ -83,27 +82,26 @@ Usage:\n\
}
int
main(int argc, char **argv)
{
bool show_final_mem = false;
isc_buffer_t key_txtbuffer;
char key_txtsecret[256];
isc_mem_t * mctx = NULL;
isc_result_t result = ISC_R_SUCCESS;
const char * keyname = NULL;
const char * serveraddr = NULL;
dns_secalg_t alg;
const char * algname;
char * p;
int ch;
int port;
int keysize = -1;
struct in_addr addr4_dummy;
main(int argc, char **argv) {
bool show_final_mem = false;
isc_buffer_t key_txtbuffer;
char key_txtsecret[256];
isc_mem_t *mctx = NULL;
isc_result_t result = ISC_R_SUCCESS;
const char *keyname = NULL;
const char *serveraddr = NULL;
dns_secalg_t alg;
const char *algname;
char *p;
int ch;
int port;
int keysize = -1;
struct in_addr addr4_dummy;
struct in6_addr addr6_dummy;
char * chrootdir = NULL;
char * user = NULL;
bool keyonly = false;
int len;
char *chrootdir = NULL;
char *user = NULL;
bool keyonly = false;
int len;
keydef = keyfile = RNDC_KEYFILE;
@ -121,7 +119,8 @@ main(int argc, char **argv)
isc_commandline_errprint = false;
while ((ch = isc_commandline_parse(argc, argv,
"aA:b:c:hk:Mmp:r:s:t:u:Vy")) != -1) {
"aA:b:c:hk:Mmp:r:s:t:u:Vy")) != -1)
{
switch (ch) {
case 'a':
keyonly = true;
@ -168,8 +167,8 @@ main(int argc, char **argv)
case 's':
serveraddr = isc_commandline_argument;
if (inet_pton(AF_INET, serveraddr, &addr4_dummy) != 1 &&
inet_pton(AF_INET6, serveraddr, &addr6_dummy) !=
1) {
inet_pton(AF_INET6, serveraddr, &addr6_dummy) != 1)
{
fatal("-s should be an IPv4 or IPv6 address");
}
break;

3
bin/confgen/unix/os.c
View file

@ -22,8 +22,7 @@
#include <sys/types.h>
int
set_user(FILE *fd, const char *user)
{
set_user(FILE *fd, const char *user) {
struct passwd *pw;
pw = getpwnam(user);

8
bin/confgen/util.c
View file

@ -20,12 +20,11 @@
#include <isc/print.h>
extern bool verbose;
extern bool verbose;
extern const char *progname;
void
notify(const char *fmt, ...)
{
notify(const char *fmt, ...) {
va_list ap;
if (verbose) {
@ -37,8 +36,7 @@ notify(const char *fmt, ...)
}
void
fatal(const char *format, ...)
{
fatal(const char *format, ...) {
va_list args;
fprintf(stderr, "%s: ", progname);

3
bin/confgen/win32/os.c
View file

@ -20,7 +20,6 @@
#include <sys/types.h>
int
set_user(FILE *fd, const char *user)
{
set_user(FILE *fd, const char *user) {
return (0);
}

278
bin/delv/delv.c
View file

@ -84,23 +84,23 @@
#define MAXNAME (DNS_NAME_MAXTEXT + 1)
/* Variables used internally by delv. */
char * progname;
char *progname;
static isc_mem_t *mctx = NULL;
static isc_log_t *lctx = NULL;
/* Configurables */
static char * server = NULL;
static const char * port = "53";
static char *server = NULL;
static const char *port = "53";
static isc_sockaddr_t *srcaddr4 = NULL, *srcaddr6 = NULL;
static isc_sockaddr_t a4, a6;
static char * curqname = NULL, *qname = NULL;
static bool classset = false;
static isc_sockaddr_t a4, a6;
static char *curqname = NULL, *qname = NULL;
static bool classset = false;
static dns_rdatatype_t qtype = dns_rdatatype_none;
static bool typeset = false;
static bool typeset = false;
static unsigned int styleflags = 0;
static uint32_t splitwidth = 0xffffffff;
static bool showcomments = true, showdnssec = true, showtrust = true,
static uint32_t splitwidth = 0xffffffff;
static bool showcomments = true, showdnssec = true, showtrust = true,
rrcomments = true, noclass = false, nocrypto = false, nottl = false,
multiline = false, short_form = false, print_unknown_format = false,
yaml = false;
@ -116,10 +116,10 @@ static bool use_tcp = false;
static char *anchorfile = NULL;
static char *trust_anchor = NULL;
static int num_keys = 0;
static int num_keys = 0;
static dns_fixedname_t afn;
static dns_name_t * anchor_name = NULL;
static dns_name_t *anchor_name = NULL;
/* Default bind.keys contents */
static char anchortext[] = TRUST_ANCHORS;
@ -127,15 +127,14 @@ static char anchortext[] = TRUST_ANCHORS;
/*
* Static function prototypes
*/
static isc_result_t
get_reverse(char *reverse, size_t len, char *value, bool strict);
static isc_result_t get_reverse(char *reverse, size_t len, char *value,
bool strict);
static isc_result_t
parse_uint(uint32_t *uip, const char *value, uint32_t max, const char *desc);
static isc_result_t parse_uint(uint32_t *uip, const char *value, uint32_t max,
const char *desc);
static void
usage(void)
{
usage(void) {
fputs("Usage: delv [@server] {q-opt} {d-opt} [domain] [q-type] "
"[q-class]\n"
"Where: domain is in the Domain Name System\n"
@ -206,13 +205,11 @@ usage(void)
exit(1);
}
ISC_PLATFORM_NORETURN_PRE static void
fatal(const char *format, ...)
ISC_PLATFORM_NORETURN_PRE static void fatal(const char *format, ...)
ISC_FORMAT_PRINTF(1, 2) ISC_PLATFORM_NORETURN_POST;
static void
fatal(const char *format, ...)
{
fatal(const char *format, ...) {
va_list args;
fflush(stdout);
@ -224,12 +221,10 @@ fatal(const char *format, ...)
exit(1);
}
static void
warn(const char *format, ...) ISC_FORMAT_PRINTF(1, 2);
static void warn(const char *format, ...) ISC_FORMAT_PRINTF(1, 2);
static void
warn(const char *format, ...)
{
warn(const char *format, ...) {
va_list args;
fflush(stdout);
@ -242,18 +237,16 @@ warn(const char *format, ...)
static isc_logcategory_t categories[] = { { "delv", 0 }, { NULL, 0 } };
#define LOGCATEGORY_DEFAULT (&categories[0])
#define LOGMODULE_DEFAULT (&modules[0])
#define LOGMODULE_DEFAULT (&modules[0])
static isc_logmodule_t modules[] = { { "delv", 0 }, { NULL, 0 } };
static void
delv_log(int level, const char *fmt, ...) ISC_FORMAT_PRINTF(2, 3);
static void delv_log(int level, const char *fmt, ...) ISC_FORMAT_PRINTF(2, 3);
static void
delv_log(int level, const char *fmt, ...)
{
delv_log(int level, const char *fmt, ...) {
va_list ap;
char msgbuf[2048];
char msgbuf[2048];
if (!isc_log_wouldlog(lctx, level)) {
return;
@ -270,11 +263,10 @@ delv_log(int level, const char *fmt, ...)
static int loglevel = 0;
static void
setup_logging(FILE *errout)
{
isc_result_t result;
setup_logging(FILE *errout) {
isc_result_t result;
isc_logdestination_t destination;
isc_logconfig_t * logconfig = NULL;
isc_logconfig_t *logconfig = NULL;
result = isc_log_create(mctx, &lctx, &logconfig);
if (result != ISC_R_SUCCESS) {
@ -363,8 +355,7 @@ setup_logging(FILE *errout)
}
static void
print_status(dns_rdataset_t *rdataset)
{
print_status(dns_rdataset_t *rdataset) {
char buf[1024] = { 0 };
REQUIRE(rdataset != NULL);
@ -443,15 +434,14 @@ print_status(dns_rdataset_t *rdataset)
static isc_result_t
printdata(dns_rdataset_t *rdataset, dns_name_t *owner,
dns_master_style_t *style)
{
isc_result_t result = ISC_R_SUCCESS;
dns_master_style_t *style) {
isc_result_t result = ISC_R_SUCCESS;
static dns_trust_t trust;
static bool first = true;
isc_buffer_t target;
isc_region_t r;
char * t = NULL;
int len = 2048;
static bool first = true;
isc_buffer_t target;
isc_region_t r;
char *t = NULL;
int len = 2048;
if (!dns_rdataset_isassociated(rdataset)) {
char namebuf[DNS_NAME_FORMATSIZE];
@ -481,7 +471,8 @@ printdata(dns_rdataset_t *rdataset, dns_name_t *owner,
dns_rdata_t rdata = DNS_RDATA_INIT;
for (result = dns_rdataset_first(rdataset);
result == ISC_R_SUCCESS;
result = dns_rdataset_next(rdataset)) {
result = dns_rdataset_next(rdataset))
{
if ((rdataset->attributes &
DNS_RDATASETATTR_NEGATIVE) != 0) {
continue;
@ -537,9 +528,8 @@ cleanup:
}
static isc_result_t
setup_style(dns_master_style_t **stylep)
{
isc_result_t result;
setup_style(dns_master_style_t **stylep) {
isc_result_t result;
dns_master_style_t *style = NULL;
REQUIRE(stylep != NULL && *stylep == NULL);
@ -590,11 +580,10 @@ setup_style(dns_master_style_t **stylep)
}
static isc_result_t
convert_name(dns_fixedname_t *fn, dns_name_t **name, const char *text)
{
convert_name(dns_fixedname_t *fn, dns_name_t **name, const char *text) {
isc_result_t result;
isc_buffer_t b;
dns_name_t * n;
dns_name_t *n;
unsigned int len;
REQUIRE(fn != NULL && name != NULL && text != NULL);
@ -616,21 +605,20 @@ convert_name(dns_fixedname_t *fn, dns_name_t **name, const char *text)
}
static isc_result_t
key_fromconfig(const cfg_obj_t *key, dns_client_t *client)
{
key_fromconfig(const cfg_obj_t *key, dns_client_t *client) {
dns_rdata_dnskey_t dnskey;
dns_rdata_ds_t ds;
uint32_t rdata1, rdata2, rdata3;
const char * datastr = NULL, *keynamestr = NULL, *atstr = NULL;
unsigned char data[4096];
isc_buffer_t databuf;
unsigned char rrdata[4096];
isc_buffer_t rrdatabuf;
isc_region_t r;
dns_fixedname_t fkeyname;
dns_name_t * keyname;
isc_result_t result;
bool match_root = false;
dns_rdata_ds_t ds;
uint32_t rdata1, rdata2, rdata3;
const char *datastr = NULL, *keynamestr = NULL, *atstr = NULL;
unsigned char data[4096];
isc_buffer_t databuf;
unsigned char rrdata[4096];
isc_buffer_t rrdatabuf;
isc_region_t r;
dns_fixedname_t fkeyname;
dns_name_t *keyname;
isc_result_t result;
bool match_root = false;
enum { INITIAL_KEY,
STATIC_KEY,
INITIAL_DS,
@ -790,14 +778,13 @@ cleanup:
}
static isc_result_t
load_keys(const cfg_obj_t *keys, dns_client_t *client)
{
load_keys(const cfg_obj_t *keys, dns_client_t *client) {
const cfg_listelt_t *elt, *elt2;
const cfg_obj_t * key, *keylist;
isc_result_t result = ISC_R_SUCCESS;
const cfg_obj_t *key, *keylist;
isc_result_t result = ISC_R_SUCCESS;
for (elt = cfg_list_first(keys); elt != NULL;
elt = cfg_list_next(elt)) {
for (elt = cfg_list_first(keys); elt != NULL; elt = cfg_list_next(elt))
{
keylist = cfg_listelt_value(elt);
for (elt2 = cfg_list_first(keylist); elt2 != NULL;
@ -815,15 +802,14 @@ cleanup:
}
static isc_result_t
setup_dnsseckeys(dns_client_t *client)
{
isc_result_t result;
cfg_parser_t * parser = NULL;
setup_dnsseckeys(dns_client_t *client) {
isc_result_t result;
cfg_parser_t *parser = NULL;
const cfg_obj_t *trusted_keys = NULL;
const cfg_obj_t *managed_keys = NULL;
const cfg_obj_t *trust_anchors = NULL;
cfg_obj_t * bindkeys = NULL;
const char * filename = anchorfile;
cfg_obj_t *bindkeys = NULL;
const char *filename = anchorfile;
if (!root_validation) {
return (ISC_R_SUCCESS);
@ -912,17 +898,16 @@ cleanup:
}
static isc_result_t
addserver(dns_client_t *client)
{
struct addrinfo hints, *res, *cur;
int gaierror;
struct in_addr in4;
struct in6_addr in6;
isc_sockaddr_t * sa;
addserver(dns_client_t *client) {
struct addrinfo hints, *res, *cur;
int gaierror;
struct in_addr in4;
struct in6_addr in6;
isc_sockaddr_t *sa;
isc_sockaddrlist_t servers;
uint32_t destport;
isc_result_t result;
dns_name_t * name = NULL;
uint32_t destport;
isc_result_t result;
dns_name_t *name = NULL;
result = parse_uint(&destport, port, 0xffff, "port");
if (result != ISC_R_SUCCESS) {
@ -1000,13 +985,12 @@ cleanup:
}
static isc_result_t
findserver(dns_client_t *client)
{
isc_result_t result;
irs_resconf_t * resconf = NULL;
findserver(dns_client_t *client) {
isc_result_t result;
irs_resconf_t *resconf = NULL;
isc_sockaddrlist_t *nameservers;
isc_sockaddr_t * sa, *next;
uint32_t destport;
isc_sockaddr_t *sa, *next;
uint32_t destport;
result = parse_uint(&destport, port, 0xffff, "port");
if (result != ISC_R_SUCCESS) {
@ -1076,9 +1060,8 @@ cleanup:
}
static isc_result_t
parse_uint(uint32_t *uip, const char *value, uint32_t max, const char *desc)
{
uint32_t n;
parse_uint(uint32_t *uip, const char *value, uint32_t max, const char *desc) {
uint32_t n;
isc_result_t result = isc_parse_uint32(&n, value, 10);
if (result == ISC_R_SUCCESS && n > max) {
result = ISC_R_RANGE;
@ -1093,11 +1076,10 @@ parse_uint(uint32_t *uip, const char *value, uint32_t max, const char *desc)
}
static void
plus_option(char *option)
{
plus_option(char *option) {
isc_result_t result;
char * cmd, *value, *last = NULL;
bool state = true;
char *cmd, *value, *last = NULL;
bool state = true;
INSIST(option != NULL);
@ -1311,20 +1293,19 @@ static const char *single_dash_opts = "46himv";
static const char *dash_opts = "46abcdhimpqtvx";
static bool
dash_option(char *option, char *next, bool *open_type_class)
{
char opt, *value;
isc_result_t result;
bool value_from_next;
dash_option(char *option, char *next, bool *open_type_class) {
char opt, *value;
isc_result_t result;
bool value_from_next;
isc_textregion_t tr;
dns_rdatatype_t rdtype;
dns_rdatatype_t rdtype;
dns_rdataclass_t rdclass;
char textname[MAXNAME];
struct in_addr in4;
struct in6_addr in6;
in_port_t srcport;
uint32_t num;
char * hash;
char textname[MAXNAME];
struct in_addr in4;
struct in6_addr in6;
in_port_t srcport;
uint32_t num;
char *hash;
while (strpbrk(option, single_dash_opts) == &option[0]) {
/*
@ -1516,9 +1497,8 @@ dash_option(char *option, char *next, bool *open_type_class)
* memory debugging when setting up the memory context.
*/
static void
preparse_args(int argc, char **argv)
{
bool ipv4only = false, ipv6only = false;
preparse_args(int argc, char **argv) {
bool ipv4only = false, ipv6only = false;
char *option;
for (argc--, argv++; argc > 0; argc--, argv++) {
@ -1578,13 +1558,12 @@ preparse_args(int argc, char **argv)
* should be familiar to dig users, however.
*/
static void
parse_args(int argc, char **argv)
{
isc_result_t result;
parse_args(int argc, char **argv) {
isc_result_t result;
isc_textregion_t tr;
dns_rdatatype_t rdtype;
dns_rdatatype_t rdtype;
dns_rdataclass_t rdclass;
bool open_type_class = true;
bool open_type_class = true;
for (; argc > 0; argc--, argv++) {
if (argv[0][0] == '@') {
@ -1631,8 +1610,8 @@ parse_args(int argc, char **argv)
if (result == ISC_R_SUCCESS) {
if (classset) {
warn("extra query class");
} else if (rdclass !=
dns_rdataclass_in) {
} else if (rdclass != dns_rdataclass_in)
{
warn("ignoring non-IN "
"query class");
}
@ -1666,8 +1645,7 @@ parse_args(int argc, char **argv)
}
static isc_result_t
append_str(const char *text, int len, char **p, char *end)
{
append_str(const char *text, int len, char **p, char *end) {
if (len > end - *p) {
return (ISC_R_NOSPACE);
}
@ -1677,10 +1655,9 @@ append_str(const char *text, int len, char **p, char *end)
}
static isc_result_t
reverse_octets(const char *in, char **p, char *end)
{
reverse_octets(const char *in, char **p, char *end) {
char *dot = strchr(in, '.');
int len;
int len;
if (dot != NULL) {
isc_result_t result;
result = reverse_octets(dot + 1, p, end);
@ -1699,10 +1676,9 @@ reverse_octets(const char *in, char **p, char *end)
}
static isc_result_t
get_reverse(char *reverse, size_t len, char *value, bool strict)
{
int r;
isc_result_t result;
get_reverse(char *reverse, size_t len, char *value, bool strict) {
int r;
isc_result_t result;
isc_netaddr_t addr;
addr.family = AF_INET6;
@ -1710,8 +1686,8 @@ get_reverse(char *reverse, size_t len, char *value, bool strict)
if (r > 0) {
/* This is a valid IPv6 address. */
dns_fixedname_t fname;
dns_name_t * name;
unsigned int options = 0;
dns_name_t *name;
unsigned int options = 0;
name = dns_fixedname_initname(&fname);
result = dns_byaddr_createptrname(&addr, options, name);
@ -1747,20 +1723,19 @@ get_reverse(char *reverse, size_t len, char *value, bool strict)
}
int
main(int argc, char *argv[])
{
dns_client_t * client = NULL;
isc_result_t result;
dns_fixedname_t qfn;
dns_name_t * query_name, *response_name;
char namestr[DNS_NAME_FORMATSIZE];
dns_rdataset_t * rdataset;
dns_namelist_t namelist;
unsigned int resopt, clopt;
isc_appctx_t * actx = NULL;
isc_taskmgr_t * taskmgr = NULL;
isc_socketmgr_t * socketmgr = NULL;
isc_timermgr_t * timermgr = NULL;
main(int argc, char *argv[]) {
dns_client_t *client = NULL;
isc_result_t result;
dns_fixedname_t qfn;
dns_name_t *query_name, *response_name;
char namestr[DNS_NAME_FORMATSIZE];
dns_rdataset_t *rdataset;
dns_namelist_t namelist;
unsigned int resopt, clopt;
isc_appctx_t *actx = NULL;
isc_taskmgr_t *taskmgr = NULL;
isc_socketmgr_t *socketmgr = NULL;
isc_timermgr_t *timermgr = NULL;
dns_master_style_t *style = NULL;
#ifndef WIN32
struct sigaction sa;
@ -1857,10 +1832,11 @@ main(int argc, char *argv[])
}
for (response_name = ISC_LIST_HEAD(namelist); response_name != NULL;
response_name = ISC_LIST_NEXT(response_name, link)) {
response_name = ISC_LIST_NEXT(response_name, link))
{
for (rdataset = ISC_LIST_HEAD(response_name->list);
rdataset != NULL;
rdataset = ISC_LIST_NEXT(rdataset, link)) {
rdataset != NULL; rdataset = ISC_LIST_NEXT(rdataset, link))
{
result = printdata(rdataset, response_name, style);
if (result != ISC_R_SUCCESS) {
delv_log(ISC_LOG_ERROR, "print data failed");

254
bin/dig/dig.c
View file

@ -55,9 +55,9 @@
dig_lookup_t *default_lookup = NULL;
static atomic_uintptr_t batchname = ATOMIC_VAR_INIT(0);
static FILE * batchfp = NULL;
static char * argv0;
static int addresscount = 0;
static FILE *batchfp = NULL;
static char *argv0;
static int addresscount = 0;
static char domainopt[DNS_NAME_MAXTEXT];
static char hexcookie[81];
@ -75,9 +75,8 @@ static const char *const opcodetext[] = {
};
static const char *
rcode_totext(dns_rcode_t rcode)
{
static char buf[64];
rcode_totext(dns_rcode_t rcode) {
static char buf[64];
isc_buffer_t b;
isc_result_t result;
@ -94,8 +93,7 @@ rcode_totext(dns_rcode_t rcode)
/*% print usage */
static void
print_usage(FILE *fp)
{
print_usage(FILE *fp) {
fputs("Usage: dig [@global-server] [domain] [q-type] [q-class] "
"{q-opt}\n"
" {global-d-opt} host [@local-server] {local-d-opt}\n"
@ -105,17 +103,14 @@ print_usage(FILE *fp)
#if TARGET_OS_IPHONE
static void
usage(void)
{
usage(void) {
fprintf(stderr, "Press <Help> for complete list of options\n");
}
#else /* if TARGET_OS_IPHONE */
ISC_PLATFORM_NORETURN_PRE static void
usage(void) ISC_PLATFORM_NORETURN_POST;
ISC_PLATFORM_NORETURN_PRE static void usage(void) ISC_PLATFORM_NORETURN_POST;
static void
usage(void)
{
usage(void) {
print_usage(stderr);
fputs("\nUse \"dig -h\" (or \"dig -h | more\") "
"for complete list of options\n",
@ -126,15 +121,13 @@ usage(void)
/*% version */
static void
version(void)
{
version(void) {
fputs("DiG " VERSION "\n", stderr);
}
/*% help */
static void
help(void)
{
help(void) {
print_usage(stdout);
fputs("Where: domain is in the Domain Name System\n"
" q-class is one of (in,hs,ch,...) [default: in]\n"
@ -315,10 +308,9 @@ help(void)
* Callback from dighost.c to print the received message.
*/
static void
received(unsigned int bytes, isc_sockaddr_t *from, dig_query_t *query)
{
uint64_t diff;
time_t tnow;
received(unsigned int bytes, isc_sockaddr_t *from, dig_query_t *query) {
uint64_t diff;
time_t tnow;
struct tm tmnow;
#ifdef WIN32
wchar_t time_str[100];
@ -354,12 +346,14 @@ received(unsigned int bytes, isc_sockaddr_t *from, dig_query_t *query)
* wide-character string, which strftime() handles incorrectly.
*/
if (wcsftime(time_str, sizeof(time_str) / sizeof(time_str[0]),
L"%a %b %d %H:%M:%S %Z %Y", &tmnow) > 0U) {
L"%a %b %d %H:%M:%S %Z %Y", &tmnow) > 0U)
{
printf(";; WHEN: %ls\n", time_str);
}
#else /* ifdef WIN32 */
if (strftime(time_str, sizeof(time_str),
"%a %b %d %H:%M:%S %Z %Y", &tmnow) > 0U) {
"%a %b %d %H:%M:%S %Z %Y", &tmnow) > 0U)
{
printf(";; WHEN: %s\n", time_str);
}
#endif /* ifdef WIN32 */
@ -405,8 +399,7 @@ received(unsigned int bytes, isc_sockaddr_t *from, dig_query_t *query)
* XXX print_trying
*/
static void
trying(char *frm, dig_lookup_t *lookup)
{
trying(char *frm, dig_lookup_t *lookup) {
UNUSED(frm);
UNUSED(lookup);
}
@ -415,11 +408,10 @@ trying(char *frm, dig_lookup_t *lookup)
* Internal print routine used to print short form replies.
*/
static isc_result_t
say_message(dns_rdata_t *rdata, dig_query_t *query, isc_buffer_t *buf)
{
say_message(dns_rdata_t *rdata, dig_query_t *query, isc_buffer_t *buf) {
isc_result_t result;
uint64_t diff;
char store[sizeof(" in 18446744073709551616 us.")];
uint64_t diff;
char store[sizeof(" in 18446744073709551616 us.")];
unsigned int styleflags = 0;
if (query->lookup->trace || query->lookup->ns_search_only) {
@ -471,13 +463,12 @@ say_message(dns_rdata_t *rdata, dig_query_t *query, isc_buffer_t *buf)
*/
static isc_result_t
short_answer(dns_message_t *msg, dns_messagetextflag_t flags, isc_buffer_t *buf,
dig_query_t *query)
{
dns_name_t * name;
dig_query_t *query) {
dns_name_t *name;
dns_rdataset_t *rdataset;
isc_result_t result, loopresult;
dns_name_t empty_name;
dns_rdata_t rdata = DNS_RDATA_INIT;
isc_result_t result, loopresult;
dns_name_t empty_name;
dns_rdata_t rdata = DNS_RDATA_INIT;
UNUSED(flags);
@ -494,7 +485,8 @@ short_answer(dns_message_t *msg, dns_messagetextflag_t flags, isc_buffer_t *buf,
dns_message_currentname(msg, DNS_SECTION_ANSWER, &name);
for (rdataset = ISC_LIST_HEAD(name->list); rdataset != NULL;
rdataset = ISC_LIST_NEXT(rdataset, link)) {
rdataset = ISC_LIST_NEXT(rdataset, link))
{
loopresult = dns_rdataset_first(rdataset);
while (loopresult == ISC_R_SUCCESS) {
dns_rdataset_current(rdataset, &rdata);
@ -519,17 +511,17 @@ short_answer(dns_message_t *msg, dns_messagetextflag_t flags, isc_buffer_t *buf,
}
static bool
isdotlocal(dns_message_t *msg)
{
isc_result_t result;
isdotlocal(dns_message_t *msg) {
isc_result_t result;
static unsigned char local_ndata[] = { "\005local\0" };
static unsigned char local_offsets[] = { 0, 6 };
static dns_name_t local =
DNS_NAME_INITABSOLUTE(local_ndata, local_offsets);
static dns_name_t local = DNS_NAME_INITABSOLUTE(local_ndata,
local_offsets);
for (result = dns_message_firstname(msg, DNS_SECTION_QUESTION);
result == ISC_R_SUCCESS;
result = dns_message_nextname(msg, DNS_SECTION_QUESTION)) {
result = dns_message_nextname(msg, DNS_SECTION_QUESTION))
{
dns_name_t *name = NULL;
dns_message_currentname(msg, DNS_SECTION_QUESTION, &name);
if (dns_name_issubdomain(name, &local)) {
@ -544,15 +536,14 @@ isdotlocal(dns_message_t *msg)
*/
static isc_result_t
printmessage(dig_query_t *query, const isc_buffer_t *msgbuf, dns_message_t *msg,
bool headers)
{
isc_result_t result;
bool headers) {
isc_result_t result;
dns_messagetextflag_t flags;
isc_buffer_t * buf = NULL;
unsigned int len = OUTPUTBUF;
dns_master_style_t * style = NULL;
unsigned int styleflags = 0;
bool isquery = (msg == query->lookup->sendmsg);
isc_buffer_t *buf = NULL;
unsigned int len = OUTPUTBUF;
dns_master_style_t *style = NULL;
unsigned int styleflags = 0;
bool isquery = (msg == query->lookup->sendmsg);
UNUSED(msgbuf);
@ -601,7 +592,8 @@ printmessage(dig_query_t *query, const isc_buffer_t *msgbuf, dns_message_t *msg,
}
}
if (query->lookup->multiline ||
(query->lookup->nottl && query->lookup->noclass)) {
(query->lookup->nottl && query->lookup->noclass))
{
result = dns_master_stylecreate(&style, styleflags, 24, 24, 24,
32, 80, 8, splitwidth, mctx);
} else if (query->lookup->nottl || query->lookup->noclass) {
@ -641,12 +633,12 @@ printmessage(dig_query_t *query, const isc_buffer_t *msgbuf, dns_message_t *msg,
if (yaml) {
enum { Q = 0x1, R = 0x2 }; /* Q:query; R:ecursive */
unsigned int tflag = 0;
unsigned int tflag = 0;
isc_sockaddr_t saddr;
char sockstr[ISC_SOCKADDR_FORMATSIZE];
uint16_t sport;
char * hash;
int pf;
char sockstr[ISC_SOCKADDR_FORMATSIZE];
uint16_t sport;
char *hash;
int pf;
printf("-\n");
printf(" type: MESSAGE\n");
@ -658,7 +650,8 @@ printmessage(dig_query_t *query, const isc_buffer_t *msgbuf, dns_message_t *msg,
tflag |= R;
}
} else if (((msg->flags & DNS_MESSAGEFLAG_RD) != 0) &&
((msg->flags & DNS_MESSAGEFLAG_RA) != 0)) {
((msg->flags & DNS_MESSAGEFLAG_RA) != 0))
{
tflag |= R;
}
@ -714,7 +707,8 @@ printmessage(dig_query_t *query, const isc_buffer_t *msgbuf, dns_message_t *msg,
if (query->sock != NULL &&
isc_socket_getsockname(query->sock, &saddr) ==
ISC_R_SUCCESS) {
ISC_R_SUCCESS)
{
sport = isc_sockaddr_getport(&saddr);
isc_sockaddr_format(&saddr, sockstr, sizeof(sockstr));
hash = strchr(sockstr, '#');
@ -788,7 +782,8 @@ printmessage(dig_query_t *query, const isc_buffer_t *msgbuf, dns_message_t *msg,
if (msg != query->lookup->sendmsg &&
(msg->flags & DNS_MESSAGEFLAG_RD) != 0 &&
(msg->flags & DNS_MESSAGEFLAG_RA) == 0) {
(msg->flags & DNS_MESSAGEFLAG_RA) == 0)
{
printf(";; WARNING: recursion requested "
"but not available\n");
}
@ -796,7 +791,8 @@ printmessage(dig_query_t *query, const isc_buffer_t *msgbuf, dns_message_t *msg,
if (msg != query->lookup->sendmsg &&
query->lookup->edns != -1 && msg->opt == NULL &&
(msg->rcode == dns_rcode_formerr ||
msg->rcode == dns_rcode_notimp)) {
msg->rcode == dns_rcode_notimp))
{
printf("\n;; WARNING: EDNS query returned status "
"%s - retry with '%s+noedns'\n",
rcode_totext(msg->rcode),
@ -910,11 +906,10 @@ repopulate_buffer:
* print the greeting message when the program first starts up.
*/
static void
printgreeting(int argc, char **argv, dig_lookup_t *lookup)
{
int i;
printgreeting(int argc, char **argv, dig_lookup_t *lookup) {
int i;
static bool first = true;
char append[MXNAME];
char append[MXNAME];
if (printcmd) {
snprintf(lookup->cmdline, sizeof(lookup->cmdline),
@ -953,13 +948,12 @@ printgreeting(int argc, char **argv, dig_lookup_t *lookup)
*/
static void
plus_option(char *option, bool is_batchfile, dig_lookup_t *lookup)
{
plus_option(char *option, bool is_batchfile, dig_lookup_t *lookup) {
isc_result_t result;
char * cmd, *value, *last = NULL, *code, *extra;
uint32_t num;
bool state = true;
size_t n;
char *cmd, *value, *last = NULL, *code, *extra;
uint32_t num;
bool state = true;
size_t n;
INSIST(option != NULL);
@ -1837,20 +1831,19 @@ static const char *dash_opts = "46bcdfhikmnpqrtvyx";
static bool
dash_option(char *option, char *next, dig_lookup_t **lookup,
bool *open_type_class, bool *need_clone, bool config_only, int argc,
char **argv, bool *firstarg)
{
char opt, *value, *ptr, *ptr2, *ptr3, *last;
isc_result_t result;
bool value_from_next;
char **argv, bool *firstarg) {
char opt, *value, *ptr, *ptr2, *ptr3, *last;
isc_result_t result;
bool value_from_next;
isc_textregion_t tr;
dns_rdatatype_t rdtype;
dns_rdatatype_t rdtype;
dns_rdataclass_t rdclass;
char textname[MXNAME];
struct in_addr in4;
struct in6_addr in6;
in_port_t srcport;
char * hash, *cmd;
uint32_t num;
char textname[MXNAME];
struct in_addr in4;
struct in6_addr in6;
in_port_t srcport;
char *hash, *cmd;
uint32_t num;
while (strpbrk(option, single_dash_opts) == &option[0]) {
/*
@ -2004,8 +1997,8 @@ dash_option(char *option, char *next, dig_lookup_t **lookup,
*need_clone = true;
strlcpy((*lookup)->textname, value,
sizeof((*lookup)->textname));
(*lookup)->trace_root =
((*lookup)->trace || (*lookup)->ns_search_only);
(*lookup)->trace_root = ((*lookup)->trace ||
(*lookup)->ns_search_only);
(*lookup)->new_search = true;
if (*firstarg) {
printgreeting(argc, argv, *lookup);
@ -2103,8 +2096,8 @@ dash_option(char *option, char *next, dig_lookup_t **lookup,
strlcpy((*lookup)->textname, textname,
sizeof((*lookup)->textname));
debug("looking up %s", (*lookup)->textname);
(*lookup)->trace_root =
((*lookup)->trace || (*lookup)->ns_search_only);
(*lookup)->trace_root = ((*lookup)->trace ||
(*lookup)->ns_search_only);
if (!(*lookup)->rdtypeset) {
(*lookup)->rdtype = dns_rdatatype_ptr;
}
@ -2141,11 +2134,10 @@ dash_option(char *option, char *next, dig_lookup_t **lookup,
* by its nature, so it can't be done in the main argument parser.
*/
static void
preparse_args(int argc, char **argv)
{
int rc;
preparse_args(int argc, char **argv) {
int rc;
char **rv;
char * option;
char *option;
rc = argc;
rv = argv;
@ -2207,39 +2199,38 @@ preparse_args(int argc, char **argv)
}
static int
split_batchline(char *batchline, char **bargv, int len, const char *msg)
{
int bargc;
split_batchline(char *batchline, char **bargv, int len, const char *msg) {
int bargc;
char *last = NULL;
REQUIRE(batchline != NULL);
for (bargc = 1, bargv[bargc] = strtok_r(batchline, " \t\r\n", &last);
bargc < len && bargv[bargc];
bargv[++bargc] = strtok_r(NULL, " \t\r\n", &last)) {
bargv[++bargc] = strtok_r(NULL, " \t\r\n", &last))
{
debug("%s %d: %s", msg, bargc, bargv[bargc]);
}
return (bargc);
}
static void
parse_args(bool is_batchfile, bool config_only, int argc, char **argv)
{
isc_result_t result;
parse_args(bool is_batchfile, bool config_only, int argc, char **argv) {
isc_result_t result;
isc_textregion_t tr;
bool firstarg = true;
dig_lookup_t * lookup = NULL;
dns_rdatatype_t rdtype;
bool firstarg = true;
dig_lookup_t *lookup = NULL;
dns_rdatatype_t rdtype;
dns_rdataclass_t rdclass;
bool open_type_class = true;
char batchline[MXNAME];
int bargc;
char * bargv[64];
int rc;
char ** rv;
bool open_type_class = true;
char batchline[MXNAME];
int bargc;
char *bargv[64];
int rc;
char **rv;
#ifndef NOPOSIX
char *homedir;
char rcfile[PATH_MAX];
char rcfile[PATH_MAX];
#endif /* ifndef NOPOSIX */
bool need_clone = true;
@ -2326,8 +2317,8 @@ parse_args(bool is_batchfile, bool config_only, int argc, char **argv)
return;
}
} else {
addresscount =
getaddresses(lookup, &rv[0][1], NULL);
addresscount = getaddresses(lookup, &rv[0][1],
NULL);
if (addresscount == 0) {
fatal("no valid addresses for '%s'\n",
&rv[0][1]);
@ -2340,7 +2331,8 @@ parse_args(bool is_batchfile, bool config_only, int argc, char **argv)
if (dash_option(&rv[0][1], NULL, &lookup,
&open_type_class, &need_clone,
config_only, argc, argv,
&firstarg)) {
&firstarg))
{
rc--;
rv++;
}
@ -2348,7 +2340,8 @@ parse_args(bool is_batchfile, bool config_only, int argc, char **argv)
if (dash_option(&rv[0][1], rv[1], &lookup,
&open_type_class, &need_clone,
config_only, argc, argv,
&firstarg)) {
&firstarg))
{
rc--;
rv++;
}
@ -2483,7 +2476,8 @@ parse_args(bool is_batchfile, bool config_only, int argc, char **argv)
if (fgets(batchline, sizeof(batchline), batchfp) != 0) {
debug("batch line %s", batchline);
if (batchline[0] == '\r' || batchline[0] == '\n' ||
batchline[0] == '#' || batchline[0] == ';') {
batchline[0] == '#' || batchline[0] == ';')
{
goto next_line;
}
bargc = split_batchline(batchline, bargv, 14,
@ -2525,10 +2519,9 @@ parse_args(bool is_batchfile, bool config_only, int argc, char **argv)
* for real if there's nothing in the batch file to read.
*/
static void
query_finished(void)
{
char batchline[MXNAME];
int bargc;
query_finished(void) {
char batchline[MXNAME];
int bargc;
char *bargv[16];
if (atomic_load(&batchname) == 0) {
@ -2563,8 +2556,7 @@ query_finished(void)
}
static void
dig_error(const char *format, ...)
{
dig_error(const char *format, ...) {
va_list args;
if (yaml) {
@ -2593,8 +2585,7 @@ dig_error(const char *format, ...)
}
static void
dig_warning(const char *format, ...)
{
dig_warning(const char *format, ...) {
va_list args;
if (!yaml) {
@ -2609,8 +2600,7 @@ dig_warning(const char *format, ...)
}
static void
dig_comments(dig_lookup_t *lookup, const char *format, ...)
{
dig_comments(dig_lookup_t *lookup, const char *format, ...) {
va_list args;
if (lookup->comments && !yaml) {
@ -2625,8 +2615,7 @@ dig_comments(dig_lookup_t *lookup, const char *format, ...)
}
void
dig_setup(int argc, char **argv)
{
dig_setup(int argc, char **argv) {
isc_result_t result;
ISC_LIST_INIT(lookup_list);
@ -2655,8 +2644,7 @@ dig_setup(int argc, char **argv)
}
void
dig_query_setup(bool is_batchfile, bool config_only, int argc, char **argv)
{
dig_query_setup(bool is_batchfile, bool config_only, int argc, char **argv) {
debug("dig_query_setup");
parse_args(is_batchfile, config_only, argc, argv);
@ -2672,8 +2660,7 @@ dig_query_setup(bool is_batchfile, bool config_only, int argc, char **argv)
}
void
dig_startup()
{
dig_startup() {
isc_result_t result;
debug("dig_startup()");
@ -2684,14 +2671,12 @@ dig_startup()
}
void
dig_query_start()
{
dig_query_start() {
start_lookup();
}
void
dig_shutdown()
{
dig_shutdown() {
destroy_lookup(default_lookup);
if (atomic_load(&batchname) != 0) {
if (batchfp != stdin) {
@ -2706,8 +2691,7 @@ dig_shutdown()
/*% Main processing routine for dig */
int
main(int argc, char **argv)
{
main(int argc, char **argv) {
dig_setup(argc, argv);
dig_query_setup(false, false, argc, argv);
dig_startup();

754
bin/dig/dighost.c
View file

File diff suppressed because it is too large Load diff

152
bin/dig/host.c
View file

@ -40,14 +40,14 @@
#include <dig/dig.h>
static bool short_form = true, listed_server = false;
static bool default_lookups = true;
static int seen_error = -1;
static bool list_addresses = true;
static bool list_almost_all = false;
static bool short_form = true, listed_server = false;
static bool default_lookups = true;
static int seen_error = -1;
static bool list_addresses = true;
static bool list_almost_all = false;
static dns_rdatatype_t list_type = dns_rdatatype_a;
static bool printed_server = false;
static bool ipv4only = false, ipv6only = false;
static bool printed_server = false;
static bool ipv4only = false, ipv6only = false;
static const char *opcodetext[] = { "QUERY", "IQUERY", "STATUS",
"RESERVED3", "NOTIFY", "UPDATE",
@ -65,7 +65,7 @@ static const char *rcodetext[] = { "NOERROR", "FORMERR", "SERVFAIL",
struct rtype {
unsigned int type;
const char * text;
const char *text;
};
struct rtype rtypes[] = { { 1, "has address" },
@ -85,12 +85,11 @@ struct rtype rtypes[] = { { 1, "has address" },
{ 0, NULL } };
static char *
rcode_totext(dns_rcode_t rcode)
{
rcode_totext(dns_rcode_t rcode) {
static char buf[sizeof("?65535")];
union {
const char *consttext;
char * deconsttext;
char *deconsttext;
} totext;
if (rcode >= (sizeof(rcodetext) / sizeof(rcodetext[0]))) {
@ -106,8 +105,7 @@ ISC_PLATFORM_NORETURN_PRE static void
show_usage(void) ISC_PLATFORM_NORETURN_POST;
static void
show_usage(void)
{
show_usage(void) {
fputs("Usage: host [-aCdilrTvVw] [-c class] [-N ndots] [-t type] [-W "
"time]\n"
" [-R number] [-m flag] hostname [server]\n"
@ -137,16 +135,14 @@ show_usage(void)
}
static void
host_shutdown(void)
{
host_shutdown(void) {
(void)isc_app_shutdown();
}
static void
received(unsigned int bytes, isc_sockaddr_t *from, dig_query_t *query)
{
received(unsigned int bytes, isc_sockaddr_t *from, dig_query_t *query) {
isc_time_t now;
int diff;
int diff;
if (!short_form) {
char fromtext[ISC_SOCKADDR_FORMATSIZE];
@ -159,8 +155,7 @@ received(unsigned int bytes, isc_sockaddr_t *from, dig_query_t *query)
}
static void
trying(char *frm, dig_lookup_t *lookup)
{
trying(char *frm, dig_lookup_t *lookup) {
UNUSED(lookup);
if (!short_form) {
@ -170,13 +165,12 @@ trying(char *frm, dig_lookup_t *lookup)
static void
say_message(dns_name_t *name, const char *msg, dns_rdata_t *rdata,
dig_query_t *query)
{
dig_query_t *query) {
isc_buffer_t *b = NULL;
char namestr[DNS_NAME_FORMATSIZE];
isc_region_t r;
isc_result_t result;
unsigned int bufsize = BUFSIZ;
char namestr[DNS_NAME_FORMATSIZE];
isc_region_t r;
isc_result_t result;
unsigned int bufsize = BUFSIZ;
dns_name_format(name, namestr, sizeof(namestr));
retry:
@ -202,18 +196,17 @@ retry:
static isc_result_t
printsection(dns_message_t *msg, dns_section_t sectionid,
const char *section_name, bool headers, dig_query_t *query)
{
dns_name_t * name, *print_name;
const char *section_name, bool headers, dig_query_t *query) {
dns_name_t *name, *print_name;
dns_rdataset_t *rdataset;
dns_rdata_t rdata = DNS_RDATA_INIT;
isc_buffer_t target;
isc_result_t result, loopresult;
isc_region_t r;
dns_name_t empty_name;
char tbuf[4096];
bool first;
bool no_rdata;
dns_rdata_t rdata = DNS_RDATA_INIT;
isc_buffer_t target;
isc_result_t result, loopresult;
isc_region_t r;
dns_name_t empty_name;
char tbuf[4096];
bool first;
bool no_rdata;
if (sectionid == DNS_SECTION_QUESTION) {
no_rdata = true;
@ -243,7 +236,8 @@ printsection(dns_message_t *msg, dns_section_t sectionid,
print_name = name;
for (rdataset = ISC_LIST_HEAD(name->list); rdataset != NULL;
rdataset = ISC_LIST_NEXT(rdataset, link)) {
rdataset = ISC_LIST_NEXT(rdataset, link))
{
if (query->lookup->rdtype == dns_rdatatype_axfr &&
!((!list_addresses &&
(list_type == dns_rdatatype_any ||
@ -252,13 +246,15 @@ printsection(dns_message_t *msg, dns_section_t sectionid,
(rdataset->type == dns_rdatatype_a ||
rdataset->type == dns_rdatatype_aaaa ||
rdataset->type == dns_rdatatype_ns ||
rdataset->type == dns_rdatatype_ptr)))) {
rdataset->type == dns_rdatatype_ptr))))
{
continue;
}
if (list_almost_all &&
(rdataset->type == dns_rdatatype_rrsig ||
rdataset->type == dns_rdatatype_nsec ||
rdataset->type == dns_rdatatype_nsec3)) {
rdataset->type == dns_rdatatype_nsec3))
{
continue;
}
if (!short_form) {
@ -280,7 +276,7 @@ printsection(dns_message_t *msg, dns_section_t sectionid,
loopresult = dns_rdataset_first(rdataset);
while (loopresult == ISC_R_SUCCESS) {
struct rtype *t;
const char * rtt;
const char *rtt;
char typebuf[DNS_RDATATYPE_FORMATSIZE];
char typebuf2[DNS_RDATATYPE_FORMATSIZE +
20];
@ -330,12 +326,11 @@ printsection(dns_message_t *msg, dns_section_t sectionid,
static isc_result_t
printrdata(dns_message_t *msg, dns_rdataset_t *rdataset,
const dns_name_t *owner, const char *set_name, bool headers)
{
const dns_name_t *owner, const char *set_name, bool headers) {
isc_buffer_t target;
isc_result_t result;
isc_region_t r;
char tbuf[4096];
char tbuf[4096];
UNUSED(msg);
if (headers) {
@ -355,13 +350,12 @@ printrdata(dns_message_t *msg, dns_rdataset_t *rdataset,
}
static void
chase_cnamechain(dns_message_t *msg, dns_name_t *qname)
{
isc_result_t result;
dns_rdataset_t * rdataset;
chase_cnamechain(dns_message_t *msg, dns_name_t *qname) {
isc_result_t result;
dns_rdataset_t *rdataset;
dns_rdata_cname_t cname;
dns_rdata_t rdata = DNS_RDATA_INIT;
unsigned int i = msg->counts[DNS_SECTION_ANSWER];
dns_rdata_t rdata = DNS_RDATA_INIT;
unsigned int i = msg->counts[DNS_SECTION_ANSWER];
while (i-- > 0) {
rdataset = NULL;
@ -384,13 +378,12 @@ chase_cnamechain(dns_message_t *msg, dns_name_t *qname)
static isc_result_t
printmessage(dig_query_t *query, const isc_buffer_t *msgbuf, dns_message_t *msg,
bool headers)
{
bool did_flag = false;
dns_rdataset_t * opt, *tsig = NULL;
bool headers) {
bool did_flag = false;
dns_rdataset_t *opt, *tsig = NULL;
const dns_name_t *tsigname;
isc_result_t result = ISC_R_SUCCESS;
int force_error;
isc_result_t result = ISC_R_SUCCESS;
int force_error;
UNUSED(msgbuf);
UNUSED(headers);
@ -434,10 +427,10 @@ printmessage(dig_query_t *query, const isc_buffer_t *msgbuf, dns_message_t *msg,
}
if (default_lookups && query->lookup->rdtype == dns_rdatatype_a) {
char namestr[DNS_NAME_FORMATSIZE];
dig_lookup_t * lookup;
char namestr[DNS_NAME_FORMATSIZE];
dig_lookup_t *lookup;
dns_fixedname_t fixed;
dns_name_t * name;
dns_name_t *name;
/* Add AAAA and MX lookups. */
name = dns_fixedname_initname(&fixed);
@ -518,8 +511,8 @@ printmessage(dig_query_t *query, const isc_buffer_t *msgbuf, dns_message_t *msg,
printf(";; PSEUDOSECTIONS: TSIG\n");
}
}
if (!ISC_LIST_EMPTY(msg->sections[DNS_SECTION_QUESTION]) &&
!short_form) {
if (!ISC_LIST_EMPTY(msg->sections[DNS_SECTION_QUESTION]) && !short_form)
{
printf("\n");
result = printsection(msg, DNS_SECTION_QUESTION, "QUESTION",
true, query);
@ -569,7 +562,8 @@ printmessage(dig_query_t *query, const isc_buffer_t *msgbuf, dns_message_t *msg,
}
if (short_form && !default_lookups &&
ISC_LIST_EMPTY(msg->sections[DNS_SECTION_ANSWER])) {
ISC_LIST_EMPTY(msg->sections[DNS_SECTION_ANSWER]))
{
char namestr[DNS_NAME_FORMATSIZE];
char typestr[DNS_RDATATYPE_FORMATSIZE];
dns_name_format(query->lookup->name, namestr, sizeof(namestr));
@ -585,22 +579,20 @@ static const char *optstring = "46aAc:dilnm:rst:vVwCDN:R:TUW:";
/*% version */
static void
version(void)
{
version(void) {
fputs("host " VERSION "\n", stderr);
}
static void
pre_parse_args(int argc, char **argv)
{
pre_parse_args(int argc, char **argv) {
int c;
while ((c = isc_commandline_parse(argc, argv, optstring)) != -1) {
switch (c) {
case 'm':
memdebugging = true;
if (strcasecmp("trace", isc_commandline_argument) ==
0) {
if (strcasecmp("trace", isc_commandline_argument) == 0)
{
isc_mem_debugging |= ISC_MEM_DEBUGTRACE;
} else if (strcasecmp("record",
isc_commandline_argument) == 0) {
@ -678,17 +670,16 @@ pre_parse_args(int argc, char **argv)
}
static void
parse_args(bool is_batchfile, int argc, char **argv)
{
char hostname[MXNAME];
dig_lookup_t * lookup;
int c;
char store[MXNAME];
parse_args(bool is_batchfile, int argc, char **argv) {
char hostname[MXNAME];
dig_lookup_t *lookup;
int c;
char store[MXNAME];
isc_textregion_t tr;
isc_result_t result = ISC_R_SUCCESS;
dns_rdatatype_t rdtype;
isc_result_t result = ISC_R_SUCCESS;
dns_rdatatype_t rdtype;
dns_rdataclass_t rdclass;
uint32_t serial = 0;
uint32_t serial = 0;
UNUSED(is_batchfile);
@ -870,8 +861,8 @@ parse_args(bool is_batchfile, int argc, char **argv)
}
lookup->pending = false;
if (get_reverse(store, sizeof(store), hostname, true) ==
ISC_R_SUCCESS) {
if (get_reverse(store, sizeof(store), hostname, true) == ISC_R_SUCCESS)
{
strlcpy(lookup->textname, store, sizeof(lookup->textname));
lookup->rdtype = dns_rdatatype_ptr;
lookup->rdtypeset = true;
@ -885,8 +876,7 @@ parse_args(bool is_batchfile, int argc, char **argv)
}
int
main(int argc, char **argv)
{
main(int argc, char **argv) {
isc_result_t result;
tries = 2;

4
bin/dig/include/dig/dig.h
View file

@ -38,9 +38,9 @@
#define MXSERV 20
#define MXNAME (DNS_NAME_MAXTEXT + 1)
#define MXRD 32
#define MXRD 32
/*% Buffer Size */
#define BUFSIZE 512
#define BUFSIZE 512
#define COMMSIZE 0xffff
#ifndef RESOLV_CONF
/*% location of resolve.conf */

201
bin/dig/nslookup.c
View file

@ -62,11 +62,11 @@ static bool short_form = true, tcpmode = false, tcpmode_set = false,
static bool interactive;
static bool in_use = false;
static char defclass[MXRD] = "IN";
static char deftype[MXRD] = "A";
static bool in_use = false;
static char defclass[MXRD] = "IN";
static char deftype[MXRD] = "A";
static isc_event_t *global_event = NULL;
static int query_error = 1, print_error = 0;
static int query_error = 1, print_error = 0;
static char domainopt[DNS_NAME_MAXTEXT];
@ -124,18 +124,15 @@ static const char *rtypetext[] = {
#define N_KNOWN_RRTYPES (sizeof(rtypetext) / sizeof(rtypetext[0]))
static void
flush_lookup_list(void);
static void
getinput(isc_task_t *task, isc_event_t *event);
static void flush_lookup_list(void);
static void getinput(isc_task_t *task, isc_event_t *event);
static char *
rcode_totext(dns_rcode_t rcode)
{
rcode_totext(dns_rcode_t rcode) {
static char buf[sizeof("?65535")];
union {
const char *consttext;
char * deconsttext;
char *deconsttext;
} totext;
if (rcode >= (sizeof(rcodetext) / sizeof(rcodetext[0]))) {
@ -148,8 +145,7 @@ rcode_totext(dns_rcode_t rcode)
}
static void
query_finished(void)
{
query_finished(void) {
isc_event_t *event = global_event;
flush_lookup_list();
@ -164,11 +160,10 @@ query_finished(void)
}
static void
printsoa(dns_rdata_t *rdata)
{
printsoa(dns_rdata_t *rdata) {
dns_rdata_soa_t soa;
isc_result_t result;
char namebuf[DNS_NAME_FORMATSIZE];
isc_result_t result;
char namebuf[DNS_NAME_FORMATSIZE];
result = dns_rdata_tostruct(rdata, &soa, NULL);
check_result(result, "dns_rdata_tostruct");
@ -186,8 +181,7 @@ printsoa(dns_rdata_t *rdata)
}
static void
printaddr(dns_rdata_t *rdata)
{
printaddr(dns_rdata_t *rdata) {
isc_result_t result;
char text[sizeof("ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255")];
isc_buffer_t b;
@ -200,12 +194,11 @@ printaddr(dns_rdata_t *rdata)
}
static void
printrdata(dns_rdata_t *rdata)
{
isc_result_t result;
printrdata(dns_rdata_t *rdata) {
isc_result_t result;
isc_buffer_t *b = NULL;
unsigned int size = 1024;
bool done = false;
unsigned int size = 1024;
bool done = false;
if (rdata->type < N_KNOWN_RRTYPES) {
printf("%s", rtypetext[rdata->type]);
@ -230,13 +223,12 @@ printrdata(dns_rdata_t *rdata)
static isc_result_t
printsection(dig_query_t *query, dns_message_t *msg, bool headers,
dns_section_t section)
{
isc_result_t result, loopresult;
dns_name_t * name;
dns_section_t section) {
isc_result_t result, loopresult;
dns_name_t *name;
dns_rdataset_t *rdataset = NULL;
dns_rdata_t rdata = DNS_RDATA_INIT;
char namebuf[DNS_NAME_FORMATSIZE];
dns_rdata_t rdata = DNS_RDATA_INIT;
char namebuf[DNS_NAME_FORMATSIZE];
UNUSED(query);
UNUSED(headers);
@ -253,7 +245,8 @@ printsection(dig_query_t *query, dns_message_t *msg, bool headers,
name = NULL;
dns_message_currentname(msg, section, &name);
for (rdataset = ISC_LIST_HEAD(name->list); rdataset != NULL;
rdataset = ISC_LIST_NEXT(rdataset, link)) {
rdataset = ISC_LIST_NEXT(rdataset, link))
{
loopresult = dns_rdataset_first(rdataset);
while (loopresult == ISC_R_SUCCESS) {
dns_rdataset_current(rdataset, &rdata);
@ -298,13 +291,12 @@ printsection(dig_query_t *query, dns_message_t *msg, bool headers,
static isc_result_t
detailsection(dig_query_t *query, dns_message_t *msg, bool headers,
dns_section_t section)
{
isc_result_t result, loopresult;
dns_name_t * name;
dns_section_t section) {
isc_result_t result, loopresult;
dns_name_t *name;
dns_rdataset_t *rdataset = NULL;
dns_rdata_t rdata = DNS_RDATA_INIT;
char namebuf[DNS_NAME_FORMATSIZE];
dns_rdata_t rdata = DNS_RDATA_INIT;
char namebuf[DNS_NAME_FORMATSIZE];
UNUSED(query);
@ -337,7 +329,8 @@ detailsection(dig_query_t *query, dns_message_t *msg, bool headers,
name = NULL;
dns_message_currentname(msg, section, &name);
for (rdataset = ISC_LIST_HEAD(name->list); rdataset != NULL;
rdataset = ISC_LIST_NEXT(rdataset, link)) {
rdataset = ISC_LIST_NEXT(rdataset, link))
{
if (section == DNS_SECTION_QUESTION) {
dns_name_format(name, namebuf, sizeof(namebuf));
printf("\t%s, ", namebuf);
@ -379,28 +372,25 @@ detailsection(dig_query_t *query, dns_message_t *msg, bool headers,
}
static void
received(unsigned int bytes, isc_sockaddr_t *from, dig_query_t *query)
{
received(unsigned int bytes, isc_sockaddr_t *from, dig_query_t *query) {
UNUSED(bytes);
UNUSED(from);
UNUSED(query);
}
static void
trying(char *frm, dig_lookup_t *lookup)
{
trying(char *frm, dig_lookup_t *lookup) {
UNUSED(frm);
UNUSED(lookup);
}
static void
chase_cnamechain(dns_message_t *msg, dns_name_t *qname)
{
isc_result_t result;
dns_rdataset_t * rdataset;
chase_cnamechain(dns_message_t *msg, dns_name_t *qname) {
isc_result_t result;
dns_rdataset_t *rdataset;
dns_rdata_cname_t cname;
dns_rdata_t rdata = DNS_RDATA_INIT;
unsigned int i = msg->counts[DNS_SECTION_ANSWER];
dns_rdata_t rdata = DNS_RDATA_INIT;
unsigned int i = msg->counts[DNS_SECTION_ANSWER];
while (i-- > 0) {
rdataset = NULL;
@ -423,8 +413,7 @@ chase_cnamechain(dns_message_t *msg, dns_name_t *qname)
static isc_result_t
printmessage(dig_query_t *query, const isc_buffer_t *msgbuf, dns_message_t *msg,
bool headers)
{
bool headers) {
char servtext[ISC_SOCKADDR_FORMATSIZE];
UNUSED(msgbuf);
@ -467,10 +456,10 @@ printmessage(dig_query_t *query, const isc_buffer_t *msgbuf, dns_message_t *msg,
}
if (default_lookups && query->lookup->rdtype == dns_rdatatype_a) {
char namestr[DNS_NAME_FORMATSIZE];
dig_lookup_t * lookup;
char namestr[DNS_NAME_FORMATSIZE];
dig_lookup_t *lookup;
dns_fixedname_t fixed;
dns_name_t * name;
dns_name_t *name;
/* Add AAAA lookup. */
name = dns_fixedname_initname(&fixed);
@ -490,18 +479,20 @@ printmessage(dig_query_t *query, const isc_buffer_t *msgbuf, dns_message_t *msg,
}
if ((msg->flags & DNS_MESSAGEFLAG_AA) == 0 &&
(!default_lookups || query->lookup->rdtype == dns_rdatatype_a)) {
(!default_lookups || query->lookup->rdtype == dns_rdatatype_a))
{
puts("Non-authoritative answer:");
}
if (!ISC_LIST_EMPTY(msg->sections[DNS_SECTION_ANSWER])) {
printsection(query, msg, headers, DNS_SECTION_ANSWER);
} else {
if (default_lookups &&
query->lookup->rdtype == dns_rdatatype_a) {
if (default_lookups && query->lookup->rdtype == dns_rdatatype_a)
{
a_noanswer = true;
} else if (!default_lookups ||
(query->lookup->rdtype == dns_rdatatype_aaaa &&
a_noanswer)) {
a_noanswer))
{
printf("*** Can't find %s: No answer\n",
query->lookup->textname);
}
@ -509,7 +500,8 @@ printmessage(dig_query_t *query, const isc_buffer_t *msgbuf, dns_message_t *msg,
if (((msg->flags & DNS_MESSAGEFLAG_AA) == 0) &&
(query->lookup->rdtype != dns_rdatatype_a) &&
(query->lookup->rdtype != dns_rdatatype_aaaa)) {
(query->lookup->rdtype != dns_rdatatype_aaaa))
{
puts("\nAuthoritative answers can be found from:");
printsection(query, msg, headers, DNS_SECTION_AUTHORITY);
printsection(query, msg, headers, DNS_SECTION_ADDITIONAL);
@ -518,12 +510,11 @@ printmessage(dig_query_t *query, const isc_buffer_t *msgbuf, dns_message_t *msg,
}
static void
show_settings(bool full, bool serv_only)
{
dig_server_t * srv;
isc_sockaddr_t sockaddr;
show_settings(bool full, bool serv_only) {
dig_server_t *srv;
isc_sockaddr_t sockaddr;
dig_searchlist_t *listent;
isc_result_t result;
isc_result_t result;
srv = ISC_LIST_HEAD(server_list);
@ -554,7 +545,8 @@ show_settings(bool full, bool serv_only)
printf(" querytype = %-8s\tclass = %s\n", deftype, defclass);
printf(" srchlist = ");
for (listent = ISC_LIST_HEAD(search_list); listent != NULL;
listent = ISC_LIST_NEXT(listent, link)) {
listent = ISC_LIST_NEXT(listent, link))
{
printf("%s", listent->origin);
if (ISC_LIST_NEXT(listent, link) != NULL) {
printf("/");
@ -564,11 +556,10 @@ show_settings(bool full, bool serv_only)
}
static bool
testtype(char *typetext)
{
isc_result_t result;
testtype(char *typetext) {
isc_result_t result;
isc_textregion_t tr;
dns_rdatatype_t rdtype;
dns_rdatatype_t rdtype;
tr.base = typetext;
tr.length = strlen(typetext);
@ -582,9 +573,8 @@ testtype(char *typetext)
}
static bool
testclass(char *typetext)
{
isc_result_t result;
testclass(char *typetext) {
isc_result_t result;
isc_textregion_t tr;
dns_rdataclass_t rdclass;
@ -600,9 +590,8 @@ testclass(char *typetext)
}
static void
set_port(const char *value)
{
uint32_t n;
set_port(const char *value) {
uint32_t n;
isc_result_t result = parse_uint(&n, value, 65535, "port");
if (result == ISC_R_SUCCESS) {
port = (uint16_t)n;
@ -610,9 +599,8 @@ set_port(const char *value)
}
static void
set_timeout(const char *value)
{
uint32_t n;
set_timeout(const char *value) {
uint32_t n;
isc_result_t result = parse_uint(&n, value, UINT_MAX, "timeout");
if (result == ISC_R_SUCCESS) {
timeout = n;
@ -620,9 +608,8 @@ set_timeout(const char *value)
}
static void
set_tries(const char *value)
{
uint32_t n;
set_tries(const char *value) {
uint32_t n;
isc_result_t result = parse_uint(&n, value, INT_MAX, "tries");
if (result == ISC_R_SUCCESS) {
tries = n;
@ -630,9 +617,8 @@ set_tries(const char *value)
}
static void
set_ndots(const char *value)
{
uint32_t n;
set_ndots(const char *value) {
uint32_t n;
isc_result_t result = parse_uint(&n, value, 128, "ndots");
if (result == ISC_R_SUCCESS) {
ndots = n;
@ -640,14 +626,12 @@ set_ndots(const char *value)
}
static void
version(void)
{
version(void) {
fputs("nslookup " VERSION "\n", stderr);
}
static void
setoption(char *opt)
{
setoption(char *opt) {
size_t l = strlen(opt);
#define CHECKOPT(A, N) \
@ -755,14 +739,13 @@ setoption(char *opt)
}
static void
addlookup(char *opt)
{
dig_lookup_t * lookup;
isc_result_t result;
addlookup(char *opt) {
dig_lookup_t *lookup;
isc_result_t result;
isc_textregion_t tr;
dns_rdatatype_t rdtype;
dns_rdatatype_t rdtype;
dns_rdataclass_t rdclass;
char store[MXNAME];
char store[MXNAME];
debug("addlookup()");
@ -826,8 +809,7 @@ addlookup(char *opt)
}
static void
do_next_command(char *input)
{
do_next_command(char *input) {
char *ptr, *arg, *last;
if ((ptr = strtok_r(input, " \t\r\n", &last)) == NULL) {
@ -837,7 +819,8 @@ do_next_command(char *input)
if ((strcasecmp(ptr, "set") == 0) && (arg != NULL)) {
setoption(arg);
} else if ((strcasecmp(ptr, "server") == 0) ||
(strcasecmp(ptr, "lserver") == 0)) {
(strcasecmp(ptr, "lserver") == 0))
{
isc_app_block();
set_nameserver(arg);
check_ra = false;
@ -849,7 +832,8 @@ do_next_command(char *input)
printf("The '%s' command is not yet implemented.\n", ptr);
} else if (strcasecmp(ptr, "finger") == 0 ||
strcasecmp(ptr, "root") == 0 || strcasecmp(ptr, "ls") == 0 ||
strcasecmp(ptr, "view") == 0) {
strcasecmp(ptr, "view") == 0)
{
printf("The '%s' command is not implemented.\n", ptr);
} else {
addlookup(ptr);
@ -857,8 +841,7 @@ do_next_command(char *input)
}
static void
get_next_command(void)
{
get_next_command(void) {
char *buf;
char *ptr;
@ -893,12 +876,10 @@ get_next_command(void)
isc_mem_free(mctx, buf);
}
ISC_PLATFORM_NORETURN_PRE static void
usage(void) ISC_PLATFORM_NORETURN_POST;
ISC_PLATFORM_NORETURN_PRE static void usage(void) ISC_PLATFORM_NORETURN_POST;
static void
usage(void)
{
usage(void) {
fprintf(stderr, "Usage:\n");
fprintf(stderr, " nslookup [-opt ...] # interactive mode "
"using default server\n");
@ -912,8 +893,7 @@ usage(void)
}
static void
parse_args(int argc, char **argv)
{
parse_args(int argc, char **argv) {
bool have_lookup = false;
usesearch = true;
@ -945,10 +925,9 @@ parse_args(int argc, char **argv)
}
static void
flush_lookup_list(void)
{
flush_lookup_list(void) {
dig_lookup_t *l, *lp;
dig_query_t * q, *qp;
dig_query_t *q, *qp;
dig_server_t *s, *sp;
lookup_counter = 0;
@ -986,8 +965,7 @@ flush_lookup_list(void)
}
static void
getinput(isc_task_t *task, isc_event_t *event)
{
getinput(isc_task_t *task, isc_event_t *event) {
UNUSED(task);
if (global_event == NULL) {
global_event = event;
@ -1003,8 +981,7 @@ getinput(isc_task_t *task, isc_event_t *event)
}
int
main(int argc, char **argv)
{
main(int argc, char **argv) {
isc_result_t result;
interactive = isatty(0);

294
bin/dnssec/dnssec-cds.c
View file

@ -70,14 +70,14 @@ static isc_mem_t *mctx = NULL;
/*
* The domain we are working on
*/
static const char * namestr = NULL;
static dns_fixedname_t fixed;
static dns_name_t * name = NULL;
static const char *namestr = NULL;
static dns_fixedname_t fixed;
static dns_name_t *name = NULL;
static dns_rdataclass_t rdclass = dns_rdataclass_in;
static const char * startstr = NULL; /* from which we derive notbefore */
static isc_stdtime_t notbefore = 0; /* restrict sig inception times */
static dns_rdata_rrsig_t oldestsig; /* for recording inception time */
static const char *startstr = NULL; /* from which we derive notbefore */
static isc_stdtime_t notbefore = 0; /* restrict sig inception times */
static dns_rdata_rrsig_t oldestsig; /* for recording inception time */
static int nkey; /* number of child zone DNSKEY records */
@ -114,15 +114,15 @@ static int nkey; /* number of child zone DNSKEY records */
* match.
*/
typedef struct keyinfo {
dns_rdata_t rdata;
dst_key_t * dst;
dns_rdata_t rdata;
dst_key_t *dst;
dns_secalg_t algo;
dns_keytag_t tag;
} keyinfo_t;
/* A replaceable function that can generate a DS RRset from some input */
typedef isc_result_t
ds_maker_func_t(dns_rdatalist_t *dslist, isc_buffer_t *buf, dns_rdata_t *rdata);
typedef isc_result_t ds_maker_func_t(dns_rdatalist_t *dslist, isc_buffer_t *buf,
dns_rdata_t *rdata);
static dns_rdataset_t cdnskey_set, cdnskey_sig;
static dns_rdataset_t cds_set, cds_sig;
@ -134,11 +134,10 @@ static keyinfo_t *old_key_tbl, *new_key_tbl;
isc_buffer_t *new_ds_buf = NULL; /* backing store for new_ds_set */
static void
verbose_time(int level, const char *msg, isc_stdtime_t time)
{
verbose_time(int level, const char *msg, isc_stdtime_t time) {
isc_result_t result;
isc_buffer_t timebuf;
char timestr[32];
char timestr[32];
if (verbose < level) {
return;
@ -156,8 +155,7 @@ verbose_time(int level, const char *msg, isc_stdtime_t time)
}
static void
initname(char *setname)
{
initname(char *setname) {
isc_result_t result;
isc_buffer_t buf;
@ -174,8 +172,7 @@ initname(char *setname)
static void
findset(dns_db_t *db, dns_dbnode_t *node, dns_rdatatype_t type,
dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset)
{
dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset) {
isc_result_t result;
dns_rdataset_init(rdataset);
@ -190,18 +187,16 @@ findset(dns_db_t *db, dns_dbnode_t *node, dns_rdatatype_t type,
}
static void
freeset(dns_rdataset_t *rdataset)
{
freeset(dns_rdataset_t *rdataset) {
if (dns_rdataset_isassociated(rdataset)) {
dns_rdataset_disassociate(rdataset);
}
}
static void
freelist(dns_rdataset_t *rdataset)
{
freelist(dns_rdataset_t *rdataset) {
dns_rdatalist_t *rdlist;
dns_rdata_t * rdata;
dns_rdata_t *rdata;
if (!dns_rdataset_isassociated(rdataset)) {
return;
@ -210,7 +205,8 @@ freelist(dns_rdataset_t *rdataset)
dns_rdatalist_fromrdataset(rdataset, &rdlist);
for (rdata = ISC_LIST_HEAD(rdlist->rdata); rdata != NULL;
rdata = ISC_LIST_HEAD(rdlist->rdata)) {
rdata = ISC_LIST_HEAD(rdlist->rdata))
{
ISC_LIST_UNLINK(rdlist->rdata, rdata, link);
isc_mem_put(mctx, rdata, sizeof(*rdata));
}
@ -219,8 +215,7 @@ freelist(dns_rdataset_t *rdataset)
}
static void
free_all_sets(void)
{
free_all_sets(void) {
freeset(&cdnskey_set);
freeset(&cdnskey_sig);
freeset(&cds_set);
@ -235,8 +230,7 @@ free_all_sets(void)
}
static void
load_db(const char *filename, dns_db_t **dbp, dns_dbnode_t **nodep)
{
load_db(const char *filename, dns_db_t **dbp, dns_dbnode_t **nodep) {
isc_result_t result;
result = dns_db_create(mctx, "rbt", name, dns_dbtype_zone, rdclass, 0,
@ -256,16 +250,14 @@ load_db(const char *filename, dns_db_t **dbp, dns_dbnode_t **nodep)
}
static void
free_db(dns_db_t **dbp, dns_dbnode_t **nodep)
{
free_db(dns_db_t **dbp, dns_dbnode_t **nodep) {
dns_db_detachnode(*dbp, nodep);
dns_db_detach(dbp);
}
static void
load_child_sets(const char *file)
{
dns_db_t * db = NULL;
load_child_sets(const char *file) {
dns_db_t *db = NULL;
dns_dbnode_t *node = NULL;
load_db(file, &db, &node);
@ -277,11 +269,10 @@ load_child_sets(const char *file)
static void
get_dsset_name(char *filename, size_t size, const char *path,
const char *suffix)
{
const char *suffix) {
isc_result_t result;
isc_buffer_t buf;
size_t len;
size_t len;
isc_buffer_init(&buf, filename, size);
@ -320,13 +311,12 @@ get_dsset_name(char *filename, size_t size, const char *path,
}
static void
load_parent_set(const char *path)
{
isc_result_t result;
dns_db_t * db = NULL;
load_parent_set(const char *path) {
isc_result_t result;
dns_db_t *db = NULL;
dns_dbnode_t *node = NULL;
isc_time_t modtime;
char filename[PATH_MAX + 1];
isc_time_t modtime;
char filename[PATH_MAX + 1];
get_dsset_name(filename, sizeof(filename), path, "");
@ -357,12 +347,11 @@ load_parent_set(const char *path)
#define MAX_CDS_RDATA_TEXT_SIZE DNS_RDATA_MAXLENGTH * 2
static isc_buffer_t *
formatset(dns_rdataset_t *rdataset)
{
isc_result_t result;
isc_buffer_t * buf = NULL;
formatset(dns_rdataset_t *rdataset) {
isc_result_t result;
isc_buffer_t *buf = NULL;
dns_master_style_t *style = NULL;
unsigned int styleflags;
unsigned int styleflags;
styleflags = (rdataset->ttl == 0) ? DNS_STYLEFLAG_NO_TTL : 0;
@ -393,16 +382,15 @@ formatset(dns_rdataset_t *rdataset)
static void
write_parent_set(const char *path, const char *inplace, bool nsupdate,
dns_rdataset_t *rdataset)
{
isc_result_t result;
dns_rdataset_t *rdataset) {
isc_result_t result;
isc_buffer_t *buf = NULL;
isc_region_t r;
isc_time_t filetime;
char backname[PATH_MAX + 1];
char filename[PATH_MAX + 1];
char tmpname[PATH_MAX + 1];
FILE * fp = NULL;
isc_region_t r;
isc_time_t filetime;
char backname[PATH_MAX + 1];
char filename[PATH_MAX + 1];
char tmpname[PATH_MAX + 1];
FILE *fp = NULL;
if (nsupdate && inplace == NULL) {
return;
@ -461,17 +449,17 @@ typedef enum { LOOSE, TIGHT } strictness_t;
* Find out if any (C)DS record matches a particular (C)DNSKEY.
*/
static bool
match_key_dsset(keyinfo_t *ki, dns_rdataset_t *dsset, strictness_t strictness)
{
isc_result_t result;
match_key_dsset(keyinfo_t *ki, dns_rdataset_t *dsset, strictness_t strictness) {
isc_result_t result;
unsigned char dsbuf[DNS_DS_BUFFERSIZE];
for (result = dns_rdataset_first(dsset); result == ISC_R_SUCCESS;
result = dns_rdataset_next(dsset)) {
result = dns_rdataset_next(dsset))
{
dns_rdata_ds_t ds;
dns_rdata_t dsrdata = DNS_RDATA_INIT;
dns_rdata_t newdsrdata = DNS_RDATA_INIT;
bool c;
dns_rdata_t dsrdata = DNS_RDATA_INIT;
dns_rdata_t newdsrdata = DNS_RDATA_INIT;
bool c;
dns_rdataset_current(dsset, &dsrdata);
result = dns_rdata_tostruct(&dsrdata, &ds, NULL);
@ -523,22 +511,22 @@ match_key_dsset(keyinfo_t *ki, dns_rdataset_t *dsset, strictness_t strictness)
*/
static keyinfo_t *
match_keyset_dsset(dns_rdataset_t *keyset, dns_rdataset_t *dsset,
strictness_t strictness)
{
strictness_t strictness) {
isc_result_t result;
keyinfo_t * keytable;
int i;
keyinfo_t *keytable;
int i;
nkey = dns_rdataset_count(keyset);
keytable = isc_mem_get(mctx, sizeof(keyinfo_t) * nkey);
for (result = dns_rdataset_first(keyset), i = 0;
result == ISC_R_SUCCESS; result = dns_rdataset_next(keyset), i++) {
keyinfo_t * ki;
result == ISC_R_SUCCESS; result = dns_rdataset_next(keyset), i++)
{
keyinfo_t *ki;
dns_rdata_dnskey_t dnskey;
dns_rdata_t * keyrdata;
isc_region_t r;
dns_rdata_t *keyrdata;
isc_region_t r;
INSIST(i < nkey);
ki = &keytable[i];
@ -559,8 +547,8 @@ match_keyset_dsset(dns_rdataset_t *keyset, dns_rdataset_t *dsset,
continue;
}
result =
dns_dnssec_keyfromrdata(name, keyrdata, mctx, &ki->dst);
result = dns_dnssec_keyfromrdata(name, keyrdata, mctx,
&ki->dst);
if (result != ISC_R_SUCCESS) {
vbprintf(3,
"dns_dnssec_keyfromrdata("
@ -573,12 +561,11 @@ match_keyset_dsset(dns_rdataset_t *keyset, dns_rdataset_t *dsset,
}
static void
free_keytable(keyinfo_t **keytable_p)
{
free_keytable(keyinfo_t **keytable_p) {
keyinfo_t *keytable = *keytable_p;
*keytable_p = NULL;
keyinfo_t *ki;
int i;
int i;
for (i = 0; i < nkey; i++) {
ki = &keytable[i];
@ -601,18 +588,18 @@ free_keytable(keyinfo_t **keytable_p)
*/
static dns_secalg_t *
matching_sigs(keyinfo_t *keytbl, dns_rdataset_t *rdataset,
dns_rdataset_t *sigset)
{
isc_result_t result;
dns_rdataset_t *sigset) {
isc_result_t result;
dns_secalg_t *algo;
int i;
int i;
algo = isc_mem_get(mctx, nkey);
memset(algo, 0, nkey);
for (result = dns_rdataset_first(sigset); result == ISC_R_SUCCESS;
result = dns_rdataset_next(sigset)) {
dns_rdata_t sigrdata = DNS_RDATA_INIT;
result = dns_rdataset_next(sigset))
{
dns_rdata_t sigrdata = DNS_RDATA_INIT;
dns_rdata_rrsig_t sig;
dns_rdataset_current(sigset, &sigrdata);
@ -631,7 +618,8 @@ matching_sigs(keyinfo_t *keytbl, dns_rdataset_t *rdataset,
for (i = 0; i < nkey; i++) {
keyinfo_t *ki = &keytbl[i];
if (sig.keyid != ki->tag || sig.algorithm != ki->algo ||
!dns_name_equal(&sig.signer, name)) {
!dns_name_equal(&sig.signer, name))
{
continue;
}
if (ki->dst == NULL) {
@ -663,8 +651,8 @@ matching_sigs(keyinfo_t *keytbl, dns_rdataset_t *rdataset,
* only after the signature has been verified
*/
if (oldestsig.timesigned == 0 ||
isc_serial_lt(sig.timesigned,
oldestsig.timesigned)) {
isc_serial_lt(sig.timesigned, oldestsig.timesigned))
{
verbose_time(2, "this is the oldest so far",
sig.timesigned);
oldestsig = sig;
@ -680,10 +668,9 @@ matching_sigs(keyinfo_t *keytbl, dns_rdataset_t *rdataset,
* fetched from the child zone, any working signature is enough.
*/
static bool
signed_loose(dns_secalg_t *algo)
{
signed_loose(dns_secalg_t *algo) {
bool ok = false;
int i;
int i;
for (i = 0; i < nkey; i++) {
if (algo[i] != 0) {
ok = true;
@ -700,17 +687,17 @@ signed_loose(dns_secalg_t *algo)
* RRset.
*/
static bool
signed_strict(dns_rdataset_t *dsset, dns_secalg_t *algo)
{
signed_strict(dns_rdataset_t *dsset, dns_secalg_t *algo) {
isc_result_t result;
bool all_ok = true;
bool all_ok = true;
for (result = dns_rdataset_first(dsset); result == ISC_R_SUCCESS;
result = dns_rdataset_next(dsset)) {
dns_rdata_t dsrdata = DNS_RDATA_INIT;
result = dns_rdataset_next(dsset))
{
dns_rdata_t dsrdata = DNS_RDATA_INIT;
dns_rdata_ds_t ds;
bool ds_ok;
int i;
bool ds_ok;
int i;
dns_rdataset_current(dsset, &dsrdata);
result = dns_rdata_tostruct(&dsrdata, &ds, NULL);
@ -736,8 +723,7 @@ signed_strict(dns_rdataset_t *dsset, dns_secalg_t *algo)
}
static dns_rdata_t *
rdata_get(void)
{
rdata_get(void) {
dns_rdata_t *rdata;
rdata = isc_mem_get(mctx, sizeof(*rdata));
@ -747,8 +733,7 @@ rdata_get(void)
}
static isc_result_t
rdata_put(isc_result_t result, dns_rdatalist_t *rdlist, dns_rdata_t *rdata)
{
rdata_put(isc_result_t result, dns_rdatalist_t *rdlist, dns_rdata_t *rdata) {
if (result == ISC_R_SUCCESS) {
ISC_LIST_APPEND(rdlist->rdata, rdata, link);
} else {
@ -764,11 +749,10 @@ rdata_put(isc_result_t result, dns_rdatalist_t *rdlist, dns_rdata_t *rdata)
* dns_rdata_cds_t and dns_rdata_ds_t types are aliases.
*/
static isc_result_t
ds_from_cds(dns_rdatalist_t *dslist, isc_buffer_t *buf, dns_rdata_t *cds)
{
isc_result_t result;
ds_from_cds(dns_rdatalist_t *dslist, isc_buffer_t *buf, dns_rdata_t *cds) {
isc_result_t result;
dns_rdata_ds_t ds;
dns_rdata_t * rdata;
dns_rdata_t *rdata;
rdata = rdata_get();
@ -784,10 +768,9 @@ ds_from_cds(dns_rdatalist_t *dslist, isc_buffer_t *buf, dns_rdata_t *cds)
static isc_result_t
ds_from_cdnskey(dns_rdatalist_t *dslist, isc_buffer_t *buf,
dns_rdata_t *cdnskey)
{
dns_rdata_t *cdnskey) {
isc_result_t result;
unsigned i, n;
unsigned i, n;
n = sizeof(dtype) / sizeof(dtype[0]);
for (i = 0; i < n; i++) {
@ -819,11 +802,10 @@ ds_from_cdnskey(dns_rdatalist_t *dslist, isc_buffer_t *buf,
static void
make_new_ds_set(ds_maker_func_t *ds_from_rdata, uint32_t ttl,
dns_rdataset_t *rdset)
{
dns_rdataset_t *rdset) {
unsigned int size = 16;
for (;;) {
isc_result_t result;
isc_result_t result;
dns_rdatalist_t *dslist;
dslist = isc_mem_get(mctx, sizeof(*dslist));
@ -840,10 +822,10 @@ make_new_ds_set(ds_maker_func_t *ds_from_rdata, uint32_t ttl,
isc_buffer_allocate(mctx, &new_ds_buf, size);
for (result = dns_rdataset_first(rdset);
result == ISC_R_SUCCESS;
result = dns_rdataset_next(rdset)) {
result == ISC_R_SUCCESS; result = dns_rdataset_next(rdset))
{
isc_result_t tresult;
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(rdset, &rdata);
@ -866,8 +848,7 @@ make_new_ds_set(ds_maker_func_t *ds_from_rdata, uint32_t ttl,
}
static inline int
rdata_cmp(const void *rdata1, const void *rdata2)
{
rdata_cmp(const void *rdata1, const void *rdata2) {
return (dns_rdata_compare((const dns_rdata_t *)rdata1,
(const dns_rdata_t *)rdata2));
}
@ -877,15 +858,14 @@ rdata_cmp(const void *rdata1, const void *rdata2)
* digest types.
*/
static bool
consistent_digests(dns_rdataset_t *dsset)
{
isc_result_t result;
dns_rdata_t * arrdata;
consistent_digests(dns_rdataset_t *dsset) {
isc_result_t result;
dns_rdata_t *arrdata;
dns_rdata_ds_t *ds;
dns_keytag_t key_tag;
dns_secalg_t algorithm;
bool match;
int i, j, n, d;
dns_keytag_t key_tag;
dns_secalg_t algorithm;
bool match;
int i, j, n, d;
/*
* First sort the dsset. DS rdata fields are tag, algorithm, digest,
@ -897,7 +877,8 @@ consistent_digests(dns_rdataset_t *dsset)
arrdata = isc_mem_get(mctx, n * sizeof(dns_rdata_t));
for (result = dns_rdataset_first(dsset), i = 0; result == ISC_R_SUCCESS;
result = dns_rdataset_next(dsset), i++) {
result = dns_rdataset_next(dsset), i++)
{
dns_rdata_init(&arrdata[i]);
dns_rdataset_current(dsset, &arrdata[i]);
}
@ -935,7 +916,8 @@ consistent_digests(dns_rdataset_t *dsset)
for (j = 0; j < d && i + j < n; j++) {
if (ds[i + j].key_tag != key_tag ||
ds[i + j].algorithm != algorithm ||
ds[i + j].digest_type != ds[j].digest_type) {
ds[i + j].digest_type != ds[j].digest_type)
{
match = false;
}
}
@ -952,12 +934,11 @@ consistent_digests(dns_rdataset_t *dsset)
}
static void
print_diff(const char *cmd, dns_rdataset_t *rdataset)
{
isc_buffer_t * buf;
isc_region_t r;
print_diff(const char *cmd, dns_rdataset_t *rdataset) {
isc_buffer_t *buf;
isc_region_t r;
unsigned char *nl;
size_t len;
size_t len;
buf = formatset(rdataset);
isc_buffer_usedregion(buf, &r);
@ -973,14 +954,13 @@ print_diff(const char *cmd, dns_rdataset_t *rdataset)
static void
update_diff(const char *cmd, uint32_t ttl, dns_rdataset_t *addset,
dns_rdataset_t *delset)
{
isc_result_t result;
dns_db_t * db;
dns_dbnode_t * node;
dns_rdataset_t *delset) {
isc_result_t result;
dns_db_t *db;
dns_dbnode_t *node;
dns_dbversion_t *ver;
dns_rdataset_t diffset;
uint32_t save;
dns_rdataset_t diffset;
uint32_t save;
db = NULL;
result = dns_db_create(mctx, "rbt", name, dns_dbtype_zone, rdclass, 0,
@ -1020,8 +1000,7 @@ update_diff(const char *cmd, uint32_t ttl, dns_rdataset_t *addset,
}
static void
nsdiff(uint32_t ttl, dns_rdataset_t *oldset, dns_rdataset_t *newset)
{
nsdiff(uint32_t ttl, dns_rdataset_t *oldset, dns_rdataset_t *newset) {
if (ttl == 0) {
vbprintf(1, "warning: no TTL in nsupdate script\n");
}
@ -1037,12 +1016,10 @@ nsdiff(uint32_t ttl, dns_rdataset_t *oldset, dns_rdataset_t *newset)
}
}
ISC_PLATFORM_NORETURN_PRE static void
usage(void) ISC_PLATFORM_NORETURN_POST;
ISC_PLATFORM_NORETURN_PRE static void usage(void) ISC_PLATFORM_NORETURN_POST;
static void
usage(void)
{
usage(void) {
fprintf(stderr, "Usage:\n");
fprintf(stderr,
" %s options [options] -f <file> -d <path> <domain>\n",
@ -1069,17 +1046,16 @@ usage(void)
}
int
main(int argc, char *argv[])
{
const char * child_path = NULL;
const char * ds_path = NULL;
const char * inplace = NULL;
main(int argc, char *argv[]) {
const char *child_path = NULL;
const char *ds_path = NULL;
const char *inplace = NULL;
isc_result_t result;
bool prefer_cdnskey = false;
bool nsupdate = false;
uint32_t ttl = 0;
int ch;
char * endp;
bool prefer_cdnskey = false;
bool nsupdate = false;
uint32_t ttl = 0;
int ch;
char *endp;
isc_mem_create(&mctx);
@ -1195,12 +1171,14 @@ main(int argc, char *argv[])
*/
if (!dns_rdataset_isassociated(&dnskey_set) ||
!dns_rdataset_isassociated(&dnskey_sig)) {
!dns_rdataset_isassociated(&dnskey_sig))
{
fatal("could not find signed DNSKEY RRset for %s", namestr);
}
if (dns_rdataset_isassociated(&cdnskey_set) &&
!dns_rdataset_isassociated(&cdnskey_sig)) {
!dns_rdataset_isassociated(&cdnskey_sig))
{
fatal("missing RRSIG CDNSKEY records for %s", namestr);
}
if (dns_rdataset_isassociated(&cds_set) &&
@ -1218,8 +1196,8 @@ main(int argc, char *argv[])
*/
vbprintf(1, "verify DNSKEY signature(s)\n");
if (!signed_loose(
matching_sigs(old_key_tbl, &dnskey_set, &dnskey_sig))) {
if (!signed_loose(matching_sigs(old_key_tbl, &dnskey_set, &dnskey_sig)))
{
fatal("could not validate child DNSKEY RRset for %s", namestr);
}
@ -1259,7 +1237,8 @@ main(int argc, char *argv[])
* RFC 7344 section 4.1 first paragraph
*/
if (!dns_rdataset_isassociated(&cdnskey_set) &&
!dns_rdataset_isassociated(&cds_set)) {
!dns_rdataset_isassociated(&cds_set))
{
vbprintf(1, "%s has neither CDS nor CDNSKEY records\n",
namestr);
write_parent_set(ds_path, inplace, nsupdate, &old_ds_set);
@ -1293,7 +1272,8 @@ main(int argc, char *argv[])
vbprintf(1, "verify DNSKEY signature(s)\n");
if (!signed_strict(&new_ds_set, matching_sigs(new_key_tbl, &dnskey_set,
&dnskey_sig))) {
&dnskey_sig)))
{
fatal("could not validate child DNSKEY RRset "
"with new DS records for %s",
namestr);

98
bin/dnssec/dnssec-dsfromkey.c
View file

@ -50,15 +50,14 @@
const char *program = "dnssec-dsfromkey";
static dns_rdataclass_t rdclass;
static dns_fixedname_t fixed;
static dns_name_t * name = NULL;
static isc_mem_t * mctx = NULL;
static uint32_t ttl;
static bool emitttl = false;
static dns_fixedname_t fixed;
static dns_name_t *name = NULL;
static isc_mem_t *mctx = NULL;
static uint32_t ttl;
static bool emitttl = false;
static isc_result_t
initname(char *setname)
{
initname(char *setname) {
isc_result_t result;
isc_buffer_t buf;
@ -71,9 +70,8 @@ initname(char *setname)
}
static void
db_load_from_stream(dns_db_t *db, FILE *fp)
{
isc_result_t result;
db_load_from_stream(dns_db_t *db, FILE *fp) {
isc_result_t result;
dns_rdatacallbacks_t callbacks;
dns_rdatacallbacks_init(&callbacks);
@ -95,12 +93,11 @@ db_load_from_stream(dns_db_t *db, FILE *fp)
}
static isc_result_t
loadset(const char *filename, dns_rdataset_t *rdataset)
{
isc_result_t result;
dns_db_t * db = NULL;
loadset(const char *filename, dns_rdataset_t *rdataset) {
isc_result_t result;
dns_db_t *db = NULL;
dns_dbnode_t *node = NULL;
char setname[DNS_NAME_FORMATSIZE];
char setname[DNS_NAME_FORMATSIZE];
dns_name_format(name, setname, sizeof(setname));
@ -145,10 +142,9 @@ loadset(const char *filename, dns_rdataset_t *rdataset)
}
static isc_result_t
loadkeyset(char *dirname, dns_rdataset_t *rdataset)
{
loadkeyset(char *dirname, dns_rdataset_t *rdataset) {
isc_result_t result;
char filename[PATH_MAX + 1];
char filename[PATH_MAX + 1];
isc_buffer_t buf;
dns_rdataset_init(rdataset);
@ -182,10 +178,9 @@ loadkeyset(char *dirname, dns_rdataset_t *rdataset)
static void
loadkey(char *filename, unsigned char *key_buf, unsigned int key_buf_size,
dns_rdata_t *rdata)
{
dns_rdata_t *rdata) {
isc_result_t result;
dst_key_t * key = NULL;
dst_key_t *key = NULL;
isc_buffer_t keyb;
isc_region_t r;
@ -225,12 +220,11 @@ loadkey(char *filename, unsigned char *key_buf, unsigned int key_buf_size,
}
static void
logkey(dns_rdata_t *rdata)
{
logkey(dns_rdata_t *rdata) {
isc_result_t result;
dst_key_t * key = NULL;
dst_key_t *key = NULL;
isc_buffer_t buf;
char keystr[DST_KEY_FORMATSIZE];
char keystr[DST_KEY_FORMATSIZE];
isc_buffer_init(&buf, rdata->data, rdata->length);
isc_buffer_add(&buf, rdata->length);
@ -246,16 +240,15 @@ logkey(dns_rdata_t *rdata)
}
static void
emit(dns_dsdigest_t dt, bool showall, bool cds, dns_rdata_t *rdata)
{
isc_result_t result;
unsigned char buf[DNS_DS_BUFFERSIZE];
char text_buf[DST_KEY_MAXTEXTSIZE];
char name_buf[DNS_NAME_MAXWIRE];
char class_buf[10];
isc_buffer_t textb, nameb, classb;
isc_region_t r;
dns_rdata_t ds;
emit(dns_dsdigest_t dt, bool showall, bool cds, dns_rdata_t *rdata) {
isc_result_t result;
unsigned char buf[DNS_DS_BUFFERSIZE];
char text_buf[DST_KEY_MAXTEXTSIZE];
char name_buf[DNS_NAME_MAXWIRE];
char class_buf[10];
isc_buffer_t textb, nameb, classb;
isc_region_t r;
dns_rdata_t ds;
dns_rdata_dnskey_t dnskey;
isc_buffer_init(&textb, text_buf, sizeof(text_buf));
@ -316,8 +309,7 @@ emit(dns_dsdigest_t dt, bool showall, bool cds, dns_rdata_t *rdata)
}
static void
emits(bool showall, bool cds, dns_rdata_t *rdata)
{
emits(bool showall, bool cds, dns_rdata_t *rdata) {
unsigned i, n;
n = sizeof(dtype) / sizeof(dtype[0]);
@ -328,12 +320,10 @@ emits(bool showall, bool cds, dns_rdata_t *rdata)
}
}
ISC_PLATFORM_NORETURN_PRE static void
usage(void) ISC_PLATFORM_NORETURN_POST;
ISC_PLATFORM_NORETURN_PRE static void usage(void) ISC_PLATFORM_NORETURN_POST;
static void
usage(void)
{
usage(void) {
fprintf(stderr, "Usage:\n");
fprintf(stderr, " %s [options] keyfile\n\n", program);
fprintf(stderr, " %s [options] -f zonefile [zonename]\n\n", program);
@ -363,19 +353,18 @@ usage(void)
}
int
main(int argc, char **argv)
{
char * classname = NULL;
char * filename = NULL, *dir = NULL, *namestr;
char * endp, *arg1;
int ch;
bool cds = false;
bool usekeyset = false;
bool showall = false;
isc_result_t result;
isc_log_t * log = NULL;
main(int argc, char **argv) {
char *classname = NULL;
char *filename = NULL, *dir = NULL, *namestr;
char *endp, *arg1;
int ch;
bool cds = false;
bool usekeyset = false;
bool showall = false;
isc_result_t result;
isc_log_t *log = NULL;
dns_rdataset_t rdataset;
dns_rdata_t rdata;
dns_rdata_t rdata;
dns_rdata_init(&rdata);
@ -533,7 +522,8 @@ main(int argc, char **argv)
for (result = dns_rdataset_first(&rdataset);
result == ISC_R_SUCCESS;
result = dns_rdataset_next(&rdataset)) {
result = dns_rdataset_next(&rdataset))
{
dns_rdata_init(&rdata);
dns_rdataset_current(&rdataset, &rdata);

81
bin/dnssec/dnssec-importkey.c
View file

@ -49,20 +49,19 @@
const char *program = "dnssec-importkey";
static dns_rdataclass_t rdclass;
static dns_fixedname_t fixed;
static dns_name_t * name = NULL;
static isc_mem_t * mctx = NULL;
static bool setpub = false, setdel = false;
static bool setttl = false;
static isc_stdtime_t pub = 0, del = 0;
static dns_ttl_t ttl = 0;
static isc_stdtime_t syncadd = 0, syncdel = 0;
static bool setsyncadd = false;
static bool setsyncdel = false;
static dns_fixedname_t fixed;
static dns_name_t *name = NULL;
static isc_mem_t *mctx = NULL;
static bool setpub = false, setdel = false;
static bool setttl = false;
static isc_stdtime_t pub = 0, del = 0;
static dns_ttl_t ttl = 0;
static isc_stdtime_t syncadd = 0, syncdel = 0;
static bool setsyncadd = false;
static bool setsyncdel = false;
static isc_result_t
initname(char *setname)
{
initname(char *setname) {
isc_result_t result;
isc_buffer_t buf;
@ -75,9 +74,8 @@ initname(char *setname)
}
static void
db_load_from_stream(dns_db_t *db, FILE *fp)
{
isc_result_t result;
db_load_from_stream(dns_db_t *db, FILE *fp) {
isc_result_t result;
dns_rdatacallbacks_t callbacks;
dns_rdatacallbacks_init(&callbacks);
@ -99,12 +97,11 @@ db_load_from_stream(dns_db_t *db, FILE *fp)
}
static isc_result_t
loadset(const char *filename, dns_rdataset_t *rdataset)
{
isc_result_t result;
dns_db_t * db = NULL;
loadset(const char *filename, dns_rdataset_t *rdataset) {
isc_result_t result;
dns_db_t *db = NULL;
dns_dbnode_t *node = NULL;
char setname[DNS_NAME_FORMATSIZE];
char setname[DNS_NAME_FORMATSIZE];
dns_name_format(name, setname, sizeof(setname));
@ -151,10 +148,9 @@ loadset(const char *filename, dns_rdataset_t *rdataset)
static void
loadkey(char *filename, unsigned char *key_buf, unsigned int key_buf_size,
dns_rdata_t *rdata)
{
dns_rdata_t *rdata) {
isc_result_t result;
dst_key_t * key = NULL;
dst_key_t *key = NULL;
isc_buffer_t keyb;
isc_region_t r;
@ -194,14 +190,13 @@ loadkey(char *filename, unsigned char *key_buf, unsigned int key_buf_size,
}
static void
emit(const char *dir, dns_rdata_t *rdata)
{
emit(const char *dir, dns_rdata_t *rdata) {
isc_result_t result;
char keystr[DST_KEY_FORMATSIZE];
char pubname[1024];
char priname[1024];
char keystr[DST_KEY_FORMATSIZE];
char pubname[1024];
char priname[1024];
isc_buffer_t buf;
dst_key_t * key = NULL, *tmp = NULL;
dst_key_t *key = NULL, *tmp = NULL;
isc_buffer_init(&buf, rdata->data, rdata->length);
isc_buffer_add(&buf, rdata->length);
@ -269,12 +264,10 @@ emit(const char *dir, dns_rdata_t *rdata)
dst_key_free(&key);
}
ISC_PLATFORM_NORETURN_PRE static void
usage(void) ISC_PLATFORM_NORETURN_POST;
ISC_PLATFORM_NORETURN_PRE static void usage(void) ISC_PLATFORM_NORETURN_POST;
static void
usage(void)
{
usage(void) {
fprintf(stderr, "Usage:\n");
fprintf(stderr, " %s options [-K dir] keyfile\n\n", program);
fprintf(stderr, " %s options -f file [keyname]\n\n", program);
@ -301,17 +294,16 @@ usage(void)
}
int
main(int argc, char **argv)
{
char * classname = NULL;
char * filename = NULL, *dir = NULL, *namestr;
char * endp;
int ch;
isc_result_t result;
isc_log_t * log = NULL;
main(int argc, char **argv) {
char *classname = NULL;
char *filename = NULL, *dir = NULL, *namestr;
char *endp;
int ch;
isc_result_t result;
isc_log_t *log = NULL;
dns_rdataset_t rdataset;
dns_rdata_t rdata;
isc_stdtime_t now;
dns_rdata_t rdata;
isc_stdtime_t now;
dns_rdata_init(&rdata);
isc_stdtime_get(&now);
@ -455,7 +447,8 @@ main(int argc, char **argv)
for (result = dns_rdataset_first(&rdataset);
result == ISC_R_SUCCESS;
result = dns_rdataset_next(&rdataset)) {
result = dns_rdataset_next(&rdataset))
{
dns_rdata_init(&rdata);
dns_rdataset_current(&rdataset, &rdata);
emit(dir, &rdata);

105
bin/dnssec/dnssec-keyfromlabel.c
View file

@ -46,12 +46,10 @@
const char *program = "dnssec-keyfromlabel";
ISC_PLATFORM_NORETURN_PRE static void
usage(void) ISC_PLATFORM_NORETURN_POST;
ISC_PLATFORM_NORETURN_PRE static void usage(void) ISC_PLATFORM_NORETURN_POST;
static void
usage(void)
{
usage(void) {
fprintf(stderr, "Usage:\n");
fprintf(stderr, " %s -l label [options] name\n\n", program);
fprintf(stderr, "Version: %s\n", VERSION);
@ -116,52 +114,51 @@ usage(void)
}
int
main(int argc, char **argv)
{
char * algname = NULL, *freeit = NULL;
char * nametype = NULL, *type = NULL;
const char * directory = NULL;
const char * predecessor = NULL;
dst_key_t * prevkey = NULL;
const char * engine = NULL;
char * classname = NULL;
char * endp;
dst_key_t * key = NULL;
dns_fixedname_t fname;
dns_name_t * name;
uint16_t flags = 0, kskflag = 0, revflag = 0;
dns_secalg_t alg;
bool oldstyle = false;
isc_mem_t * mctx = NULL;
int ch;
int protocol = -1, signatory = 0;
isc_result_t ret;
main(int argc, char **argv) {
char *algname = NULL, *freeit = NULL;
char *nametype = NULL, *type = NULL;
const char *directory = NULL;
const char *predecessor = NULL;
dst_key_t *prevkey = NULL;
const char *engine = NULL;
char *classname = NULL;
char *endp;
dst_key_t *key = NULL;
dns_fixedname_t fname;
dns_name_t *name;
uint16_t flags = 0, kskflag = 0, revflag = 0;
dns_secalg_t alg;
bool oldstyle = false;
isc_mem_t *mctx = NULL;
int ch;
int protocol = -1, signatory = 0;
isc_result_t ret;
isc_textregion_t r;
char filename[255];
isc_buffer_t buf;
isc_log_t * log = NULL;
char filename[255];
isc_buffer_t buf;
isc_log_t *log = NULL;
dns_rdataclass_t rdclass;
int options = DST_TYPE_PRIVATE | DST_TYPE_PUBLIC;
char * label = NULL;
dns_ttl_t ttl = 0;
isc_stdtime_t publish = 0, activate = 0, revoke = 0;
isc_stdtime_t inactive = 0, deltime = 0;
isc_stdtime_t now;
int prepub = -1;
bool setpub = false, setact = false;
bool setrev = false, setinact = false;
bool setdel = false, setttl = false;
bool unsetpub = false, unsetact = false;
bool unsetrev = false, unsetinact = false;
bool unsetdel = false;
bool genonly = false;
bool use_nsec3 = false;
bool avoid_collisions = true;
bool exact;
unsigned char c;
isc_stdtime_t syncadd = 0, syncdel = 0;
bool unsetsyncadd = false, setsyncadd = false;
bool unsetsyncdel = false, setsyncdel = false;
int options = DST_TYPE_PRIVATE | DST_TYPE_PUBLIC;
char *label = NULL;
dns_ttl_t ttl = 0;
isc_stdtime_t publish = 0, activate = 0, revoke = 0;
isc_stdtime_t inactive = 0, deltime = 0;
isc_stdtime_t now;
int prepub = -1;
bool setpub = false, setact = false;
bool setrev = false, setinact = false;
bool setdel = false, setttl = false;
bool unsetpub = false, unsetact = false;
bool unsetrev = false, unsetinact = false;
bool unsetdel = false;
bool genonly = false;
bool use_nsec3 = false;
bool avoid_collisions = true;
bool exact;
unsigned char c;
isc_stdtime_t syncadd = 0, syncdel = 0;
bool unsetsyncadd = false, setsyncadd = false;
bool unsetsyncdel = false, setsyncdel = false;
if (argc == 1) {
usage();
@ -384,7 +381,7 @@ main(int argc, char **argv)
if (strchr(label, ':') == NULL) {
char *l;
int len;
int len;
len = strlen(label) + 8;
l = isc_mem_allocate(mctx, len);
@ -467,9 +464,9 @@ main(int argc, char **argv)
}
}
} else {
char keystr[DST_KEY_FORMATSIZE];
char keystr[DST_KEY_FORMATSIZE];
isc_stdtime_t when;
int major, minor;
int major, minor;
if (prepub == -1) {
prepub = (30 * 86400);
@ -612,7 +609,8 @@ main(int argc, char **argv)
}
if ((flags & DNS_KEYFLAG_OWNERMASK) == DNS_KEYOWNER_ZONE &&
alg == DNS_KEYALG_DH) {
alg == DNS_KEYALG_DH)
{
fatal("a key with algorithm '%s' cannot be a zone key",
algname);
}
@ -694,7 +692,8 @@ main(int argc, char **argv)
} else {
if (setpub || setact || setrev || setinact || setdel ||
unsetpub || unsetact || unsetrev || unsetinact ||
unsetdel || genonly || setsyncadd || setsyncdel) {
unsetdel || genonly || setsyncadd || setsyncdel)
{
fatal("cannot use -C together with "
"-P, -A, -R, -I, -D, or -G options");
}

199
bin/dnssec/dnssec-keygen.c
View file

@ -69,33 +69,31 @@ const char *program = "dnssec-keygen";
isc_log_t *lctx = NULL;
ISC_PLATFORM_NORETURN_PRE static void
usage(void) ISC_PLATFORM_NORETURN_POST;
ISC_PLATFORM_NORETURN_PRE static void usage(void) ISC_PLATFORM_NORETURN_POST;
static void
progress(int p);
static void progress(int p);
struct keygen_ctx {
const char * predecessor;
const char * policy;
const char * configfile;
const char * directory;
char * algname;
char * nametype;
char * type;
int generator;
int protocol;
int size;
int signatory;
const char *predecessor;
const char *policy;
const char *configfile;
const char *directory;
char *algname;
char *nametype;
char *type;
int generator;
int protocol;
int size;
int signatory;
dns_rdataclass_t rdclass;
int options;
int dbits;
dns_ttl_t ttl;
uint16_t kskflag;
uint16_t revflag;
dns_secalg_t alg;
int options;
int dbits;
dns_ttl_t ttl;
uint16_t kskflag;
uint16_t revflag;
dns_secalg_t alg;
/* timing data */
int prepub;
int prepub;
isc_stdtime_t now;
isc_stdtime_t publish;
isc_stdtime_t activate;
@ -104,18 +102,18 @@ struct keygen_ctx {
isc_stdtime_t deltime;
isc_stdtime_t syncadd;
isc_stdtime_t syncdel;
bool setpub;
bool setact;
bool setinact;
bool setrev;
bool setdel;
bool setsyncadd;
bool setsyncdel;
bool unsetpub;
bool unsetact;
bool unsetinact;
bool unsetrev;
bool unsetdel;
bool setpub;
bool setact;
bool setinact;
bool setrev;
bool setdel;
bool setsyncadd;
bool setsyncdel;
bool unsetpub;
bool unsetact;
bool unsetinact;
bool unsetrev;
bool unsetdel;
/* how to generate the key */
bool setttl;
bool use_nsec3;
@ -125,15 +123,14 @@ struct keygen_ctx {
bool oldstyle;
/* state */
time_t lifetime;
bool ksk;
bool zsk;
bool ksk;
bool zsk;
};
typedef struct keygen_ctx keygen_ctx_t;
static void
usage(void)
{
usage(void) {
fprintf(stderr, "Usage:\n");
fprintf(stderr, " %s [options] name\n\n", program);
fprintf(stderr, "Version: %s\n", VERSION);
@ -223,8 +220,7 @@ usage(void)
}
static void
progress(int p)
{
progress(int p) {
char c = '*';
switch (p) {
@ -249,19 +245,19 @@ progress(int p)
static void
kasp_from_conf(cfg_obj_t *config, isc_mem_t *mctx, const char *name,
dns_kasp_t **kaspp)
{
dns_kasp_t **kaspp) {
const cfg_listelt_t *element;
const cfg_obj_t * kasps = NULL;
dns_kasp_t * kasp = NULL, *kasp_next;
isc_result_t result = ISC_R_NOTFOUND;
dns_kasplist_t kasplist;
const cfg_obj_t *kasps = NULL;
dns_kasp_t *kasp = NULL, *kasp_next;
isc_result_t result = ISC_R_NOTFOUND;
dns_kasplist_t kasplist;
ISC_LIST_INIT(kasplist);
(void)cfg_map_get(config, "dnssec-policy", &kasps);
for (element = cfg_list_first(kasps); element != NULL;
element = cfg_list_next(element)) {
element = cfg_list_next(element))
{
cfg_obj_t *kconfig = cfg_listelt_value(element);
kasp = NULL;
if (strcmp(cfg_obj_asstring(cfg_tuple_get(kconfig, "name")),
@ -294,21 +290,20 @@ kasp_from_conf(cfg_obj_t *config, isc_mem_t *mctx, const char *name,
}
static void
keygen(keygen_ctx_t *ctx, isc_mem_t *mctx, int argc, char **argv)
{
char filename[255];
char algstr[DNS_SECALG_FORMATSIZE];
uint16_t flags = 0;
int param = 0;
bool null_key = false;
bool conflict = false;
bool show_progress = false;
isc_buffer_t buf;
dns_name_t * name;
keygen(keygen_ctx_t *ctx, isc_mem_t *mctx, int argc, char **argv) {
char filename[255];
char algstr[DNS_SECALG_FORMATSIZE];
uint16_t flags = 0;
int param = 0;
bool null_key = false;
bool conflict = false;
bool show_progress = false;
isc_buffer_t buf;
dns_name_t *name;
dns_fixedname_t fname;
isc_result_t ret;
dst_key_t * key = NULL;
dst_key_t * prevkey = NULL;
isc_result_t ret;
dst_key_t *key = NULL;
dst_key_t *prevkey = NULL;
UNUSED(argc);
@ -427,9 +422,9 @@ keygen(keygen_ctx_t *ctx, isc_mem_t *mctx, int argc, char **argv)
}
}
} else {
char keystr[DST_KEY_FORMATSIZE];
char keystr[DST_KEY_FORMATSIZE];
isc_stdtime_t when;
int major, minor;
int major, minor;
if (ctx->prepub == -1) {
ctx->prepub = (30 * 86400);
@ -535,14 +530,14 @@ keygen(keygen_ctx_t *ctx, isc_mem_t *mctx, int argc, char **argv)
case DNS_KEYALG_RSASHA1:
case DNS_KEYALG_NSEC3RSASHA1:
case DNS_KEYALG_RSASHA256:
if (ctx->size != 0 &&
(ctx->size < 1024 || ctx->size > MAX_RSA)) {
if (ctx->size != 0 && (ctx->size < 1024 || ctx->size > MAX_RSA))
{
fatal("RSA key size %d out of range", ctx->size);
}
break;
case DNS_KEYALG_RSASHA512:
if (ctx->size != 0 &&
(ctx->size < 1024 || ctx->size > MAX_RSA)) {
if (ctx->size != 0 && (ctx->size < 1024 || ctx->size > MAX_RSA))
{
fatal("RSA key size %d out of range", ctx->size);
}
break;
@ -578,7 +573,8 @@ keygen(keygen_ctx_t *ctx, isc_mem_t *mctx, int argc, char **argv)
flags |= DNS_KEYOWNER_ZONE;
} else if ((ctx->options & DST_TYPE_KEY) != 0) { /* KEY */
if (strcasecmp(ctx->nametype, "host") == 0 ||
strcasecmp(ctx->nametype, "entity") == 0) {
strcasecmp(ctx->nametype, "entity") == 0)
{
flags |= DNS_KEYOWNER_ENTITY;
} else if (strcasecmp(ctx->nametype, "user") == 0) {
flags |= DNS_KEYOWNER_USER;
@ -603,7 +599,8 @@ keygen(keygen_ctx_t *ctx, isc_mem_t *mctx, int argc, char **argv)
if (ctx->protocol == -1) {
ctx->protocol = DNS_KEYPROTO_DNSSEC;
} else if ((ctx->options & DST_TYPE_KEY) == 0 &&
ctx->protocol != DNS_KEYPROTO_DNSSEC) {
ctx->protocol != DNS_KEYPROTO_DNSSEC)
{
fatal("invalid DNSKEY protocol: %d", ctx->protocol);
}
@ -617,7 +614,8 @@ keygen(keygen_ctx_t *ctx, isc_mem_t *mctx, int argc, char **argv)
}
if ((flags & DNS_KEYFLAG_OWNERMASK) == DNS_KEYOWNER_ZONE &&
ctx->alg == DNS_KEYALG_DH) {
ctx->alg == DNS_KEYALG_DH)
{
fatal("a key with algorithm %s cannot be a zone key", algstr);
}
@ -762,7 +760,8 @@ keygen(keygen_ctx_t *ctx, isc_mem_t *mctx, int argc, char **argv)
ctx->setinact || ctx->setdel || ctx->unsetpub ||
ctx->unsetact || ctx->unsetrev || ctx->unsetinact ||
ctx->unsetdel || ctx->genonly || ctx->setsyncadd ||
ctx->setsyncdel) {
ctx->setsyncdel)
{
fatal("cannot use -C together with "
"-P, -A, -R, -I, -D, or -G options");
}
@ -856,17 +855,16 @@ keygen(keygen_ctx_t *ctx, isc_mem_t *mctx, int argc, char **argv)
}
int
main(int argc, char **argv)
{
char * algname = NULL, *freeit = NULL;
char * classname = NULL;
char * endp;
isc_mem_t * mctx = NULL;
isc_result_t ret;
main(int argc, char **argv) {
char *algname = NULL, *freeit = NULL;
char *classname = NULL;
char *endp;
isc_mem_t *mctx = NULL;
isc_result_t ret;
isc_textregion_t r;
const char * engine = NULL;
unsigned char c;
int ch;
const char *engine = NULL;
unsigned char c;
int ch;
keygen_ctx_t ctx = {
.options = DST_TYPE_PRIVATE | DST_TYPE_PUBLIC,
@ -895,16 +893,16 @@ main(int argc, char **argv)
while ((ch = isc_commandline_parse(argc, argv, CMDLINE_FLAGS)) != -1) {
switch (ch) {
case 'm':
if (strcasecmp(isc_commandline_argument, "record") ==
0) {
if (strcasecmp(isc_commandline_argument, "record") == 0)
{
isc_mem_debugging |= ISC_MEM_DEBUGRECORD;
}
if (strcasecmp(isc_commandline_argument, "trace") ==
0) {
if (strcasecmp(isc_commandline_argument, "trace") == 0)
{
isc_mem_debugging |= ISC_MEM_DEBUGTRACE;
}
if (strcasecmp(isc_commandline_argument, "usage") ==
0) {
if (strcasecmp(isc_commandline_argument, "usage") == 0)
{
isc_mem_debugging |= ISC_MEM_DEBUGUSAGE;
}
if (strcasecmp(isc_commandline_argument, "size") == 0) {
@ -968,8 +966,8 @@ main(int argc, char **argv)
}
break;
case 'g':
ctx.generator =
strtol(isc_commandline_argument, &endp, 10);
ctx.generator = strtol(isc_commandline_argument, &endp,
10);
if (*endp != '\0' || ctx.generator <= 0) {
fatal("-g requires a positive number");
}
@ -998,8 +996,8 @@ main(int argc, char **argv)
case 'm':
break;
case 'p':
ctx.protocol =
strtol(isc_commandline_argument, &endp, 10);
ctx.protocol = strtol(isc_commandline_argument, &endp,
10);
if (*endp != '\0' || ctx.protocol < 0 ||
ctx.protocol > 255) {
fatal("-p must be followed by a number "
@ -1014,8 +1012,8 @@ main(int argc, char **argv)
"System random data is always used.\n");
break;
case 's':
ctx.signatory =
strtol(isc_commandline_argument, &endp, 10);
ctx.signatory = strtol(isc_commandline_argument, &endp,
10);
if (*endp != '\0' || ctx.signatory < 0 ||
ctx.signatory > 15) {
fatal("-s must be followed by a number "
@ -1027,7 +1025,8 @@ main(int argc, char **argv)
ctx.options |= DST_TYPE_KEY;
} else if (strcasecmp(isc_commandline_argument,
"DNSKE"
"Y") == 0) {
"Y") == 0)
{
/* default behavior */
} else {
fatal("unknown type '%s'",
@ -1223,7 +1222,8 @@ main(int argc, char **argv)
if (ctx.setpub || ctx.setact || ctx.setrev || ctx.setinact ||
ctx.setdel || ctx.unsetpub || ctx.unsetact ||
ctx.unsetrev || ctx.unsetinact || ctx.unsetdel ||
ctx.setsyncadd || ctx.setsyncdel) {
ctx.setsyncadd || ctx.setsyncdel)
{
fatal("cannot use -k together with "
"-P, -A, -R, -I, or -D options "
"(use dnssec-settime on keys afterwards)");
@ -1245,16 +1245,17 @@ main(int argc, char **argv)
keygen(&ctx, mctx, argc, argv);
} else {
cfg_parser_t * parser = NULL;
cfg_obj_t * config = NULL;
dns_kasp_t * kasp = NULL;
cfg_parser_t *parser = NULL;
cfg_obj_t *config = NULL;
dns_kasp_t *kasp = NULL;
dns_kasp_key_t *kaspkey = NULL;
RUNTIME_CHECK(cfg_parser_create(mctx, lctx, &parser) ==
ISC_R_SUCCESS);
if (cfg_parse_file(parser, ctx.configfile,
&cfg_type_namedconf,
&config) != ISC_R_SUCCESS) {
&config) != ISC_R_SUCCESS)
{
fatal("unable to load dnssec-policy '%s' from "
"'%s'",
ctx.policy, ctx.configfile);

33
bin/dnssec/dnssec-revoke.c
View file

@ -40,12 +40,10 @@ const char *program = "dnssec-revoke";
static isc_mem_t *mctx = NULL;
ISC_PLATFORM_NORETURN_PRE static void
usage(void) ISC_PLATFORM_NORETURN_POST;
ISC_PLATFORM_NORETURN_PRE static void usage(void) ISC_PLATFORM_NORETURN_POST;
static void
usage(void)
{
usage(void) {
fprintf(stderr, "Usage:\n");
fprintf(stderr, " %s [options] keyfile\n\n", program);
fprintf(stderr, "Version: %s\n", VERSION);
@ -72,22 +70,21 @@ usage(void)
}
int
main(int argc, char **argv)
{
main(int argc, char **argv) {
isc_result_t result;
const char * engine = NULL;
char const * filename = NULL;
char * dir = NULL;
char newname[1024], oldname[1024];
char keystr[DST_KEY_FORMATSIZE];
char * endp;
int ch;
dst_key_t * key = NULL;
uint32_t flags;
const char *engine = NULL;
char const *filename = NULL;
char *dir = NULL;
char newname[1024], oldname[1024];
char keystr[DST_KEY_FORMATSIZE];
char *endp;
int ch;
dst_key_t *key = NULL;
uint32_t flags;
isc_buffer_t buf;
bool force = false;
bool removefile = false;
bool id = false;
bool force = false;
bool removefile = false;
bool id = false;
if (argc == 1) {
usage();

135
bin/dnssec/dnssec-settime.c
View file

@ -43,12 +43,10 @@ const char *program = "dnssec-settime";
static isc_mem_t *mctx = NULL;
ISC_PLATFORM_NORETURN_PRE static void
usage(void) ISC_PLATFORM_NORETURN_POST;
ISC_PLATFORM_NORETURN_PRE static void usage(void) ISC_PLATFORM_NORETURN_POST;
static void
usage(void)
{
usage(void) {
fprintf(stderr, "Usage:\n");
fprintf(stderr, " %s [options] keyfile\n\n", program);
fprintf(stderr, "Version: %s\n", VERSION);
@ -113,10 +111,9 @@ usage(void)
}
static void
printtime(dst_key_t *key, int type, const char *tag, bool epoch, FILE *stream)
{
isc_result_t result;
const char * output = NULL;
printtime(dst_key_t *key, int type, const char *tag, bool epoch, FILE *stream) {
isc_result_t result;
const char *output = NULL;
isc_stdtime_t when;
if (tag != NULL) {
@ -136,13 +133,12 @@ printtime(dst_key_t *key, int type, const char *tag, bool epoch, FILE *stream)
}
static void
writekey(dst_key_t *key, const char *directory, bool write_state)
{
char newname[1024];
char keystr[DST_KEY_FORMATSIZE];
writekey(dst_key_t *key, const char *directory, bool write_state) {
char newname[1024];
char keystr[DST_KEY_FORMATSIZE];
isc_buffer_t buf;
isc_result_t result;
int options = DST_TYPE_PUBLIC | DST_TYPE_PRIVATE;
int options = DST_TYPE_PUBLIC | DST_TYPE_PRIVATE;
if (write_state) {
options |= DST_TYPE_STATE;
@ -184,57 +180,56 @@ writekey(dst_key_t *key, const char *directory, bool write_state)
}
int
main(int argc, char **argv)
{
isc_result_t result;
const char * engine = NULL;
const char * filename = NULL;
char * directory = NULL;
char keystr[DST_KEY_FORMATSIZE];
char * endp, *p;
int ch;
const char * predecessor = NULL;
dst_key_t * prevkey = NULL;
dst_key_t * key = NULL;
dns_name_t * name = NULL;
dns_secalg_t alg = 0;
unsigned int size = 0;
uint16_t flags = 0;
int prepub = -1;
int options;
dns_ttl_t ttl = 0;
isc_stdtime_t now;
isc_stdtime_t dstime = 0, dnskeytime = 0;
isc_stdtime_t krrsigtime = 0, zrrsigtime = 0;
isc_stdtime_t pub = 0, act = 0, rev = 0, inact = 0, del = 0;
isc_stdtime_t prevact = 0, previnact = 0, prevdel = 0;
main(int argc, char **argv) {
isc_result_t result;
const char *engine = NULL;
const char *filename = NULL;
char *directory = NULL;
char keystr[DST_KEY_FORMATSIZE];
char *endp, *p;
int ch;
const char *predecessor = NULL;
dst_key_t *prevkey = NULL;
dst_key_t *key = NULL;
dns_name_t *name = NULL;
dns_secalg_t alg = 0;
unsigned int size = 0;
uint16_t flags = 0;
int prepub = -1;
int options;
dns_ttl_t ttl = 0;
isc_stdtime_t now;
isc_stdtime_t dstime = 0, dnskeytime = 0;
isc_stdtime_t krrsigtime = 0, zrrsigtime = 0;
isc_stdtime_t pub = 0, act = 0, rev = 0, inact = 0, del = 0;
isc_stdtime_t prevact = 0, previnact = 0, prevdel = 0;
dst_key_state_t goal = DST_KEY_STATE_NA;
dst_key_state_t ds = DST_KEY_STATE_NA;
dst_key_state_t dnskey = DST_KEY_STATE_NA;
dst_key_state_t krrsig = DST_KEY_STATE_NA;
dst_key_state_t zrrsig = DST_KEY_STATE_NA;
bool setgoal = false, setds = false, setdnskey = false;
bool setkrrsig = false, setzrrsig = false;
bool setdstime = false, setdnskeytime = false;
bool setkrrsigtime = false, setzrrsigtime = false;
bool setpub = false, setact = false;
bool setrev = false, setinact = false;
bool setdel = false, setttl = false;
bool unsetpub = false, unsetact = false;
bool unsetrev = false, unsetinact = false;
bool unsetdel = false;
bool printcreate = false, printpub = false;
bool printact = false, printrev = false;
bool printinact = false, printdel = false;
bool force = false;
bool epoch = false;
bool changed = false;
bool write_state = false;
isc_log_t * log = NULL;
isc_stdtime_t syncadd = 0, syncdel = 0;
bool unsetsyncadd = false, setsyncadd = false;
bool unsetsyncdel = false, setsyncdel = false;
bool printsyncadd = false, printsyncdel = false;
bool setgoal = false, setds = false, setdnskey = false;
bool setkrrsig = false, setzrrsig = false;
bool setdstime = false, setdnskeytime = false;
bool setkrrsigtime = false, setzrrsigtime = false;
bool setpub = false, setact = false;
bool setrev = false, setinact = false;
bool setdel = false, setttl = false;
bool unsetpub = false, unsetact = false;
bool unsetrev = false, unsetinact = false;
bool unsetdel = false;
bool printcreate = false, printpub = false;
bool printact = false, printrev = false;
bool printinact = false, printdel = false;
bool force = false;
bool epoch = false;
bool changed = false;
bool write_state = false;
isc_log_t *log = NULL;
isc_stdtime_t syncadd = 0, syncdel = 0;
bool unsetsyncadd = false, setsyncadd = false;
bool unsetsyncdel = false, setsyncdel = false;
bool printsyncadd = false, printsyncdel = false;
options = DST_TYPE_PUBLIC | DST_TYPE_PRIVATE | DST_TYPE_STATE;
@ -319,7 +314,8 @@ main(int argc, char **argv)
goal = strtokeystate(isc_commandline_argument);
if (goal != DST_KEY_STATE_NA &&
goal != DST_KEY_STATE_HIDDEN &&
goal != DST_KEY_STATE_OMNIPRESENT) {
goal != DST_KEY_STATE_OMNIPRESENT)
{
fatal("-g must be either none, hidden, or "
"omnipresent");
}
@ -352,8 +348,8 @@ main(int argc, char **argv)
* We don't have to copy it here, but do it to
* simplify cleanup later
*/
directory =
isc_mem_strdup(mctx, isc_commandline_argument);
directory = isc_mem_strdup(mctx,
isc_commandline_argument);
break;
case 'k':
if (setdnskey) {
@ -545,8 +541,8 @@ main(int argc, char **argv)
fatal("Invalid keyfile %s: %s", filename,
isc_result_totext(result));
}
if (!dst_key_isprivate(prevkey) &&
!dst_key_isexternal(prevkey)) {
if (!dst_key_isprivate(prevkey) && !dst_key_isexternal(prevkey))
{
fatal("%s is not a private key", filename);
}
@ -570,8 +566,8 @@ main(int argc, char **argv)
"generating a successor.");
}
result =
dst_key_gettime(prevkey, DST_TIME_INACTIVE, &previnact);
result = dst_key_gettime(prevkey, DST_TIME_INACTIVE,
&previnact);
if (result != ISC_R_SUCCESS) {
fatal("Predecessor has no inactivation date. "
"You must set one before\n\t"
@ -647,8 +643,8 @@ main(int argc, char **argv)
}
}
result =
dst_key_fromnamedfile(filename, directory, options, mctx, &key);
result = dst_key_fromnamedfile(filename, directory, options, mctx,
&key);
if (result != ISC_R_SUCCESS) {
fatal("Invalid keyfile %s: %s", filename,
isc_result_totext(result));
@ -683,7 +679,8 @@ main(int argc, char **argv)
(dst_key_gettime(key, DST_TIME_DELETE, &prevdel) == ISC_R_SUCCESS &&
setinact && !setdel && !unsetdel && prevdel < inact) ||
(!setdel && !unsetdel && !setinact && !unsetinact && prevdel != 0 &&
prevdel < previnact)) {
prevdel < previnact))
{
fprintf(stderr,
"%s: warning: Key is scheduled to "
"be deleted before it is\n\t"

925
bin/dnssec/dnssec-signzone.c
View file

File diff suppressed because it is too large Load diff

67
bin/dnssec/dnssec-verify.c
View file

@ -68,19 +68,18 @@
const char *program = "dnssec-verify";
static isc_stdtime_t now;
static isc_mem_t * mctx = NULL;
static isc_stdtime_t now;
static isc_mem_t *mctx = NULL;
static dns_masterformat_t inputformat = dns_masterformat_text;
static dns_db_t * gdb; /* The database */
static dns_dbversion_t * gversion; /* The database version */
static dns_rdataclass_t gclass; /* The class */
static dns_name_t * gorigin; /* The database origin */
static bool ignore_kskflag = false;
static bool keyset_kskonly = false;
static dns_db_t *gdb; /* The database */
static dns_dbversion_t *gversion; /* The database version */
static dns_rdataclass_t gclass; /* The class */
static dns_name_t *gorigin; /* The database origin */
static bool ignore_kskflag = false;
static bool keyset_kskonly = false;
static void
report(const char *format, ...)
{
report(const char *format, ...) {
if (!quiet) {
va_list args;
va_start(args, format);
@ -93,13 +92,12 @@ report(const char *format, ...)
* Load the zone file from disk
*/
static void
loadzone(char *file, char *origin, dns_rdataclass_t rdclass, dns_db_t **db)
{
isc_buffer_t b;
int len;
loadzone(char *file, char *origin, dns_rdataclass_t rdclass, dns_db_t **db) {
isc_buffer_t b;
int len;
dns_fixedname_t fname;
dns_name_t * name;
isc_result_t result;
dns_name_t *name;
isc_result_t result;
len = strlen(origin);
isc_buffer_init(&b, origin, len);
@ -139,12 +137,10 @@ loadzone(char *file, char *origin, dns_rdataclass_t rdclass, dns_db_t **db)
}
}
ISC_PLATFORM_NORETURN_PRE static void
usage(void) ISC_PLATFORM_NORETURN_POST;
ISC_PLATFORM_NORETURN_PRE static void usage(void) ISC_PLATFORM_NORETURN_POST;
static void
usage(void)
{
usage(void) {
fprintf(stderr, "Usage:\n");
fprintf(stderr, "\t%s [options] zonefile [keys]\n", program);
@ -177,17 +173,16 @@ usage(void)
}
int
main(int argc, char *argv[])
{
char * origin = NULL, *file = NULL;
char * inputformatstr = NULL;
isc_result_t result;
isc_log_t * log = NULL;
const char * engine = NULL;
char * classname = NULL;
main(int argc, char *argv[]) {
char *origin = NULL, *file = NULL;
char *inputformatstr = NULL;
isc_result_t result;
isc_log_t *log = NULL;
const char *engine = NULL;
char *classname = NULL;
dns_rdataclass_t rdclass;
char * endp;
int ch;
char *endp;
int ch;
#define CMDLINE_FLAGS "c:E:hm:o:I:qv:Vxz"
@ -197,16 +192,16 @@ main(int argc, char *argv[])
while ((ch = isc_commandline_parse(argc, argv, CMDLINE_FLAGS)) != -1) {
switch (ch) {
case 'm':
if (strcasecmp(isc_commandline_argument, "record") ==
0) {
if (strcasecmp(isc_commandline_argument, "record") == 0)
{
isc_mem_debugging |= ISC_MEM_DEBUGRECORD;
}
if (strcasecmp(isc_commandline_argument, "trace") ==
0) {
if (strcasecmp(isc_commandline_argument, "trace") == 0)
{
isc_mem_debugging |= ISC_MEM_DEBUGTRACE;
}
if (strcasecmp(isc_commandline_argument, "usage") ==
0) {
if (strcasecmp(isc_commandline_argument, "usage") == 0)
{
isc_mem_debugging |= ISC_MEM_DEBUGUSAGE;
}
if (strcasecmp(isc_commandline_argument, "size") == 0) {

130
bin/dnssec/dnssectool.c
View file

@ -65,15 +65,14 @@ static const char *keystates[KEYSTATES_NVALUES] = {
"unretentive",
};
int verbose = 0;
bool quiet = false;
int verbose = 0;
bool quiet = false;
uint8_t dtype[8];
static fatalcallback_t *fatalcallback = NULL;
void
fatal(const char *format, ...)
{
fatal(const char *format, ...) {
va_list args;
fprintf(stderr, "%s: fatal: ", program);
@ -88,22 +87,19 @@ fatal(const char *format, ...)
}
void
setfatalcallback(fatalcallback_t *callback)
{
setfatalcallback(fatalcallback_t *callback) {
fatalcallback = callback;
}
void
check_result(isc_result_t result, const char *message)
{
check_result(isc_result_t result, const char *message) {
if (result != ISC_R_SUCCESS) {
fatal("%s: %s", message, isc_result_totext(result));
}
}
void
vbprintf(int level, const char *fmt, ...)
{
vbprintf(int level, const char *fmt, ...) {
va_list ap;
if (level > verbose) {
return;
@ -115,15 +111,13 @@ vbprintf(int level, const char *fmt, ...)
}
void
version(const char *name)
{
version(const char *name) {
fprintf(stderr, "%s %s\n", name, VERSION);
exit(0);
}
void
sig_format(dns_rdata_rrsig_t *sig, char *cp, unsigned int size)
{
sig_format(dns_rdata_rrsig_t *sig, char *cp, unsigned int size) {
char namestr[DNS_NAME_FORMATSIZE];
char algstr[DNS_NAME_FORMATSIZE];
@ -133,13 +127,12 @@ sig_format(dns_rdata_rrsig_t *sig, char *cp, unsigned int size)
}
void
setup_logging(isc_mem_t *mctx, isc_log_t **logp)
{
isc_result_t result;
setup_logging(isc_mem_t *mctx, isc_log_t **logp) {
isc_result_t result;
isc_logdestination_t destination;
isc_logconfig_t * logconfig = NULL;
isc_log_t * log = NULL;
int level;
isc_logconfig_t *logconfig = NULL;
isc_log_t *log = NULL;
int level;
if (verbose < 0) {
verbose = 0;
@ -189,8 +182,7 @@ setup_logging(isc_mem_t *mctx, isc_log_t **logp)
}
void
cleanup_logging(isc_log_t **logp)
{
cleanup_logging(isc_log_t **logp) {
isc_log_t *log;
REQUIRE(logp != NULL);
@ -208,8 +200,7 @@ cleanup_logging(isc_log_t **logp)
}
static isc_stdtime_t
time_units(isc_stdtime_t offset, char *suffix, const char *str)
{
time_units(isc_stdtime_t offset, char *suffix, const char *str) {
switch (suffix[0]) {
case 'Y':
case 'y':
@ -253,18 +244,16 @@ time_units(isc_stdtime_t offset, char *suffix, const char *str)
}
static inline bool
isnone(const char *str)
{
isnone(const char *str) {
return ((strcasecmp(str, "none") == 0) ||
(strcasecmp(str, "never") == 0));
}
dns_ttl_t
strtottl(const char *str)
{
strtottl(const char *str) {
const char *orig = str;
dns_ttl_t ttl;
char * endp;
dns_ttl_t ttl;
char *endp;
if (isnone(str)) {
return ((dns_ttl_t)0);
@ -279,15 +268,14 @@ strtottl(const char *str)
}
dst_key_state_t
strtokeystate(const char *str)
{
strtokeystate(const char *str) {
if (isnone(str)) {
return (DST_KEY_STATE_NA);
}
for (int i = 0; i < KEYSTATES_NVALUES; i++) {
if (keystates[i] != NULL &&
strcasecmp(str, keystates[i]) == 0) {
if (keystates[i] != NULL && strcasecmp(str, keystates[i]) == 0)
{
return ((dst_key_state_t)i);
}
}
@ -295,13 +283,12 @@ strtokeystate(const char *str)
}
isc_stdtime_t
strtotime(const char *str, int64_t now, int64_t base, bool *setp)
{
int64_t val, offset;
strtotime(const char *str, int64_t now, int64_t base, bool *setp) {
int64_t val, offset;
isc_result_t result;
const char * orig = str;
char * endp;
size_t n;
const char *orig = str;
char *endp;
size_t n;
if (isnone(str)) {
if (setp != NULL) {
@ -365,11 +352,10 @@ strtotime(const char *str, int64_t now, int64_t base, bool *setp)
}
dns_rdataclass_t
strtoclass(const char *str)
{
strtoclass(const char *str) {
isc_textregion_t r;
dns_rdataclass_t rdclass;
isc_result_t result;
isc_result_t result;
if (str == NULL) {
return (dns_rdataclass_in);
@ -384,11 +370,10 @@ strtoclass(const char *str)
}
unsigned int
strtodsdigest(const char *str)
{
strtodsdigest(const char *str) {
isc_textregion_t r;
dns_dsdigest_t alg;
isc_result_t result;
dns_dsdigest_t alg;
isc_result_t result;
DE_CONST(str, r.base);
r.length = strlen(str);
@ -400,16 +385,14 @@ strtodsdigest(const char *str)
}
static int
cmp_dtype(const void *ap, const void *bp)
{
cmp_dtype(const void *ap, const void *bp) {
int a = *(const uint8_t *)ap;
int b = *(const uint8_t *)bp;
return (a - b);
}
void
add_dtype(unsigned int dt)
{
add_dtype(unsigned int dt) {
unsigned i, n;
/* ensure there is space for a zero terminator */
@ -428,10 +411,9 @@ add_dtype(unsigned int dt)
}
isc_result_t
try_dir(const char *dirname)
{
try_dir(const char *dirname) {
isc_result_t result;
isc_dir_t d;
isc_dir_t d;
isc_dir_init(&d);
result = isc_dir_open(&d, dirname);
@ -445,8 +427,7 @@ try_dir(const char *dirname)
* Check private key version compatibility.
*/
void
check_keyversion(dst_key_t *key, char *keystr)
{
check_keyversion(dst_key_t *key, char *keystr) {
int major, minor;
dst_key_getprivateformat(key, &major, &minor);
INSIST(major <= DST_MAJOR_VERSION); /* invalid private key */
@ -464,8 +445,7 @@ check_keyversion(dst_key_t *key, char *keystr)
}
void
set_keyversion(dst_key_t *key)
{
set_keyversion(dst_key_t *key) {
int major, minor;
dst_key_getprivateformat(key, &major, &minor);
INSIST(major <= DST_MAJOR_VERSION);
@ -488,18 +468,17 @@ set_keyversion(dst_key_t *key)
bool
key_collision(dst_key_t *dstkey, dns_name_t *name, const char *dir,
isc_mem_t *mctx, bool *exact)
{
isc_result_t result;
bool conflict = false;
isc_mem_t *mctx, bool *exact) {
isc_result_t result;
bool conflict = false;
dns_dnsseckeylist_t matchkeys;
dns_dnsseckey_t * key = NULL;
uint16_t id, oldid;
uint32_t rid, roldid;
dns_secalg_t alg;
char filename[NAME_MAX];
isc_buffer_t fileb;
isc_stdtime_t now;
dns_dnsseckey_t *key = NULL;
uint16_t id, oldid;
uint32_t rid, roldid;
dns_secalg_t alg;
char filename[NAME_MAX];
isc_buffer_t fileb;
isc_stdtime_t now;
if (exact != NULL) {
*exact = false;
@ -576,8 +555,7 @@ key_collision(dst_key_t *dstkey, dns_name_t *name, const char *dir,
}
bool
isoptarg(const char *arg, char **argv, void (*usage)(void))
{
isoptarg(const char *arg, char **argv, void (*usage)(void)) {
if (!strcasecmp(isc_commandline_argument, arg)) {
if (argv[isc_commandline_index] == NULL) {
fprintf(stderr, "%s: missing argument -%c %s\n",
@ -595,11 +573,10 @@ isoptarg(const char *arg, char **argv, void (*usage)(void))
#ifdef _WIN32
void
InitSockets(void)
{
WORD wVersionRequested;
InitSockets(void) {
WORD wVersionRequested;
WSADATA wsaData;
int err;
int err;
wVersionRequested = MAKEWORD(2, 0);
@ -611,8 +588,7 @@ InitSockets(void)
}
void
DestroySockets(void)
{
DestroySockets(void) {
WSACleanup();
}
#endif /* ifdef _WIN32 */

97
bin/named/builtin.c
View file

@ -32,18 +32,12 @@
typedef struct builtin builtin_t;
static isc_result_t
do_version_lookup(dns_sdblookup_t *lookup);
static isc_result_t
do_hostname_lookup(dns_sdblookup_t *lookup);
static isc_result_t
do_authors_lookup(dns_sdblookup_t *lookup);
static isc_result_t
do_id_lookup(dns_sdblookup_t *lookup);
static isc_result_t
do_empty_lookup(dns_sdblookup_t *lookup);
static isc_result_t
do_dns64_lookup(dns_sdblookup_t *lookup);
static isc_result_t do_version_lookup(dns_sdblookup_t *lookup);
static isc_result_t do_hostname_lookup(dns_sdblookup_t *lookup);
static isc_result_t do_authors_lookup(dns_sdblookup_t *lookup);
static isc_result_t do_id_lookup(dns_sdblookup_t *lookup);
static isc_result_t do_empty_lookup(dns_sdblookup_t *lookup);
static isc_result_t do_dns64_lookup(dns_sdblookup_t *lookup);
/*
* We can't use function pointers as the db_data directly
@ -92,8 +86,7 @@ static const unsigned char hex16[256] = {
const unsigned char decimal[] = "0123456789";
static size_t
dns64_rdata(unsigned char *v, size_t start, unsigned char *rdata)
{
dns64_rdata(unsigned char *v, size_t start, unsigned char *rdata) {
size_t i, j = 0;
for (i = 0; i < 4U; i++) {
@ -124,12 +117,11 @@ dns64_rdata(unsigned char *v, size_t start, unsigned char *rdata)
static isc_result_t
dns64_cname(const dns_name_t *zone, const dns_name_t *name,
dns_sdblookup_t *lookup)
{
size_t zlen, nlen, j, len;
unsigned char v[16], n;
unsigned int i;
unsigned char rdata[sizeof("123.123.123.123.in-addr.arpa.")];
dns_sdblookup_t *lookup) {
size_t zlen, nlen, j, len;
unsigned char v[16], n;
unsigned int i;
unsigned char rdata[sizeof("123.123.123.123.in-addr.arpa.")];
unsigned char *ndata;
/*
@ -298,8 +290,7 @@ dns64_cname(const dns_name_t *zone, const dns_name_t *name,
static isc_result_t
builtin_lookup(const char *zone, const char *name, void *dbdata,
dns_sdblookup_t *lookup, dns_clientinfomethods_t *methods,
dns_clientinfo_t *clientinfo)
{
dns_clientinfo_t *clientinfo) {
builtin_t *b = (builtin_t *)dbdata;
UNUSED(zone);
@ -316,8 +307,7 @@ builtin_lookup(const char *zone, const char *name, void *dbdata,
static isc_result_t
dns64_lookup(const dns_name_t *zone, const dns_name_t *name, void *dbdata,
dns_sdblookup_t *lookup, dns_clientinfomethods_t *methods,
dns_clientinfo_t *clientinfo)
{
dns_clientinfo_t *clientinfo) {
builtin_t *b = (builtin_t *)dbdata;
UNUSED(methods);
@ -331,10 +321,9 @@ dns64_lookup(const dns_name_t *zone, const dns_name_t *name, void *dbdata,
}
static isc_result_t
put_txt(dns_sdblookup_t *lookup, const char *text)
{
put_txt(dns_sdblookup_t *lookup, const char *text) {
unsigned char buf[256];
unsigned int len = strlen(text);
unsigned int len = strlen(text);
if (len > 255) {
len = 255; /* Silently truncate */
}
@ -344,8 +333,7 @@ put_txt(dns_sdblookup_t *lookup, const char *text)
}
static isc_result_t
do_version_lookup(dns_sdblookup_t *lookup)
{
do_version_lookup(dns_sdblookup_t *lookup) {
if (named_g_server->version_set) {
if (named_g_server->version == NULL) {
return (ISC_R_SUCCESS);
@ -358,8 +346,7 @@ do_version_lookup(dns_sdblookup_t *lookup)
}
static isc_result_t
do_hostname_lookup(dns_sdblookup_t *lookup)
{
do_hostname_lookup(dns_sdblookup_t *lookup) {
if (named_g_server->hostname_set) {
if (named_g_server->hostname == NULL) {
return (ISC_R_SUCCESS);
@ -367,7 +354,7 @@ do_hostname_lookup(dns_sdblookup_t *lookup)
return (put_txt(lookup, named_g_server->hostname));
}
} else {
char buf[256];
char buf[256];
isc_result_t result = named_os_gethostname(buf, sizeof(buf));
if (result != ISC_R_SUCCESS) {
return (result);
@ -377,10 +364,9 @@ do_hostname_lookup(dns_sdblookup_t *lookup)
}
static isc_result_t
do_authors_lookup(dns_sdblookup_t *lookup)
{
isc_result_t result;
const char ** p;
do_authors_lookup(dns_sdblookup_t *lookup) {
isc_result_t result;
const char **p;
static const char *authors[] = {
"Mark Andrews", "Curtis Blackburn", "James Brister",
"Ben Cottrell", "John H. DuBois III", "Francis Dupont",
@ -408,10 +394,9 @@ do_authors_lookup(dns_sdblookup_t *lookup)
}
static isc_result_t
do_id_lookup(dns_sdblookup_t *lookup)
{
do_id_lookup(dns_sdblookup_t *lookup) {
if (named_g_server->sctx->gethostname != NULL) {
char buf[256];
char buf[256];
isc_result_t result;
result = named_g_server->sctx->gethostname(buf, sizeof(buf));
@ -427,26 +412,23 @@ do_id_lookup(dns_sdblookup_t *lookup)
}
static isc_result_t
do_dns64_lookup(dns_sdblookup_t *lookup)
{
do_dns64_lookup(dns_sdblookup_t *lookup) {
UNUSED(lookup);
return (ISC_R_SUCCESS);
}
static isc_result_t
do_empty_lookup(dns_sdblookup_t *lookup)
{
do_empty_lookup(dns_sdblookup_t *lookup) {
UNUSED(lookup);
return (ISC_R_SUCCESS);
}
static isc_result_t
builtin_authority(const char *zone, void *dbdata, dns_sdblookup_t *lookup)
{
builtin_authority(const char *zone, void *dbdata, dns_sdblookup_t *lookup) {
isc_result_t result;
const char * contact = "hostmaster";
const char * server = "@";
builtin_t * b = (builtin_t *)dbdata;
const char *contact = "hostmaster";
const char *server = "@";
builtin_t *b = (builtin_t *)dbdata;
UNUSED(zone);
UNUSED(dbdata);
@ -478,8 +460,7 @@ builtin_authority(const char *zone, void *dbdata, dns_sdblookup_t *lookup)
static isc_result_t
builtin_create(const char *zone, int argc, char **argv, void *driverdata,
void **dbdata)
{
void **dbdata) {
REQUIRE(argc >= 1);
UNUSED(zone);
@ -504,8 +485,8 @@ builtin_create(const char *zone, int argc, char **argv, void *driverdata,
} else if (strcmp(argv[0], "empty") == 0 ||
strcmp(argv[0], "dns64") == 0) {
builtin_t *empty;
char * server;
char * contact;
char *server;
char *contact;
/*
* We don't want built-in zones to fail. Fallback to
* the static configuration if memory allocation fails.
@ -548,8 +529,7 @@ builtin_create(const char *zone, int argc, char **argv, void *driverdata,
}
static void
builtin_destroy(const char *zone, void *driverdata, void **dbdata)
{
builtin_destroy(const char *zone, void *driverdata, void **dbdata) {
builtin_t *b = (builtin_t *)*dbdata;
UNUSED(zone);
@ -560,7 +540,8 @@ builtin_destroy(const char *zone, void *driverdata, void **dbdata)
*/
if (*dbdata == &version_builtin || *dbdata == &hostname_builtin ||
*dbdata == &authors_builtin || *dbdata == &id_builtin ||
*dbdata == &empty_builtin || *dbdata == &dns64_builtin) {
*dbdata == &empty_builtin || *dbdata == &dns64_builtin)
{
return;
}
@ -580,8 +561,7 @@ static dns_sdbmethods_t dns64_methods = {
};
isc_result_t
named_builtin_init(void)
{
named_builtin_init(void) {
RUNTIME_CHECK(dns_sdb_register("_builtin", &builtin_methods, NULL,
DNS_SDBFLAG_RELATIVEOWNER |
DNS_SDBFLAG_RELATIVERDATA,
@ -597,8 +577,7 @@ named_builtin_init(void)
}
void
named_builtin_deinit(void)
{
named_builtin_deinit(void) {
dns_sdb_unregister(&builtin_impl);
dns_sdb_unregister(&dns64_impl);
}

155
bin/named/config.c
View file

@ -316,8 +316,7 @@ masters " DEFAULT_IANA_ROOT_ZONE_MASTERS " {\n\
";
isc_result_t
named_config_parsedefaults(cfg_parser_t *parser, cfg_obj_t **conf)
{
named_config_parsedefaults(cfg_parser_t *parser, cfg_obj_t **conf) {
isc_buffer_t b;
isc_buffer_init(&b, defaultconf, sizeof(defaultconf) - 1);
@ -328,8 +327,7 @@ named_config_parsedefaults(cfg_parser_t *parser, cfg_obj_t **conf)
isc_result_t
named_config_get(cfg_obj_t const *const *maps, const char *name,
const cfg_obj_t **obj)
{
const cfg_obj_t **obj) {
int i;
for (i = 0;; i++) {
@ -344,13 +342,12 @@ named_config_get(cfg_obj_t const *const *maps, const char *name,
isc_result_t
named_checknames_get(const cfg_obj_t **maps, const char *which,
const cfg_obj_t **obj)
{
const cfg_obj_t **obj) {
const cfg_listelt_t *element;
const cfg_obj_t * checknames;
const cfg_obj_t * type;
const cfg_obj_t * value;
int i;
const cfg_obj_t *checknames;
const cfg_obj_t *type;
const cfg_obj_t *value;
int i;
for (i = 0;; i++) {
if (maps[i] == NULL) {
@ -367,8 +364,8 @@ named_checknames_get(const cfg_obj_t **maps, const char *which,
return (ISC_R_SUCCESS);
}
for (element = cfg_list_first(checknames);
element != NULL;
element = cfg_list_next(element)) {
element != NULL; element = cfg_list_next(element))
{
value = cfg_listelt_value(element);
type = cfg_tuple_get(value, "type");
if (strcasecmp(cfg_obj_asstring(type), which) ==
@ -382,10 +379,9 @@ named_checknames_get(const cfg_obj_t **maps, const char *which,
}
int
named_config_listcount(const cfg_obj_t *list)
{
named_config_listcount(const cfg_obj_t *list) {
const cfg_listelt_t *e;
int i = 0;
int i = 0;
for (e = cfg_list_first(list); e != NULL; e = cfg_list_next(e)) {
i++;
@ -396,10 +392,9 @@ named_config_listcount(const cfg_obj_t *list)
isc_result_t
named_config_getclass(const cfg_obj_t *classobj, dns_rdataclass_t defclass,
dns_rdataclass_t *classp)
{
dns_rdataclass_t *classp) {
isc_textregion_t r;
isc_result_t result;
isc_result_t result;
if (!cfg_obj_isstring(classobj)) {
*classp = defclass;
@ -417,10 +412,9 @@ named_config_getclass(const cfg_obj_t *classobj, dns_rdataclass_t defclass,
isc_result_t
named_config_gettype(const cfg_obj_t *typeobj, dns_rdatatype_t deftype,
dns_rdatatype_t *typep)
{
dns_rdatatype_t *typep) {
isc_textregion_t r;
isc_result_t result;
isc_result_t result;
if (!cfg_obj_isstring(typeobj)) {
*typep = deftype;
@ -437,10 +431,9 @@ named_config_gettype(const cfg_obj_t *typeobj, dns_rdatatype_t deftype,
}
dns_zonetype_t
named_config_getzonetype(const cfg_obj_t *zonetypeobj)
{
named_config_getzonetype(const cfg_obj_t *zonetypeobj) {
dns_zonetype_t ztype = dns_zone_none;
const char * str;
const char *str;
str = cfg_obj_asstring(zonetypeobj);
if (strcasecmp(str, "primary") == 0 || strcasecmp(str, "master") == 0) {
@ -467,16 +460,15 @@ isc_result_t
named_config_getiplist(const cfg_obj_t *config, const cfg_obj_t *list,
in_port_t defport, isc_mem_t *mctx,
isc_sockaddr_t **addrsp, isc_dscp_t **dscpsp,
uint32_t *countp)
{
int count, i = 0;
const cfg_obj_t * addrlist;
const cfg_obj_t * portobj, *dscpobj;
uint32_t *countp) {
int count, i = 0;
const cfg_obj_t *addrlist;
const cfg_obj_t *portobj, *dscpobj;
const cfg_listelt_t *element;
isc_sockaddr_t * addrs;
in_port_t port;
isc_dscp_t dscp = -1, *dscps = NULL;
isc_result_t result;
isc_sockaddr_t *addrs;
in_port_t port;
isc_dscp_t dscp = -1, *dscps = NULL;
isc_result_t result;
INSIST(addrsp != NULL && *addrsp == NULL);
INSIST(dscpsp == NULL || *dscpsp == NULL);
@ -522,7 +514,8 @@ named_config_getiplist(const cfg_obj_t *config, const cfg_obj_t *list,
addrs = isc_mem_get(mctx, count * sizeof(isc_sockaddr_t));
for (element = cfg_list_first(addrlist); element != NULL;
element = cfg_list_next(element), i++) {
element = cfg_list_next(element), i++)
{
const cfg_obj_t *addr;
INSIST(i < count);
addr = cfg_listelt_value(element);
@ -553,8 +546,7 @@ named_config_getiplist(const cfg_obj_t *config, const cfg_obj_t *list,
void
named_config_putiplist(isc_mem_t *mctx, isc_sockaddr_t **addrsp,
isc_dscp_t **dscpsp, uint32_t count)
{
isc_dscp_t **dscpsp, uint32_t count) {
INSIST(addrsp != NULL && *addrsp != NULL);
INSIST(dscpsp == NULL || *dscpsp != NULL);
@ -569,10 +561,9 @@ named_config_putiplist(isc_mem_t *mctx, isc_sockaddr_t **addrsp,
isc_result_t
named_config_getmastersdef(const cfg_obj_t *cctx, const char *name,
const cfg_obj_t **ret)
{
isc_result_t result;
const cfg_obj_t * masters = NULL;
const cfg_obj_t **ret) {
isc_result_t result;
const cfg_obj_t *masters = NULL;
const cfg_listelt_t *elt;
result = cfg_map_get(cctx, "masters", &masters);
@ -582,7 +573,7 @@ named_config_getmastersdef(const cfg_obj_t *cctx, const char *name,
for (elt = cfg_list_first(masters); elt != NULL;
elt = cfg_list_next(elt)) {
const cfg_obj_t *list;
const char * listname;
const char *listname;
list = cfg_listelt_value(elt);
listname = cfg_obj_asstring(cfg_tuple_get(list, "name"));
@ -597,29 +588,28 @@ named_config_getmastersdef(const cfg_obj_t *cctx, const char *name,
isc_result_t
named_config_getipandkeylist(const cfg_obj_t *config, const cfg_obj_t *list,
isc_mem_t *mctx, dns_ipkeylist_t *ipkl)
{
uint32_t addrcount = 0, dscpcount = 0, keycount = 0, i = 0;
uint32_t listcount = 0, l = 0, j;
uint32_t stackcount = 0, pushed = 0;
isc_result_t result;
isc_mem_t *mctx, dns_ipkeylist_t *ipkl) {
uint32_t addrcount = 0, dscpcount = 0, keycount = 0, i = 0;
uint32_t listcount = 0, l = 0, j;
uint32_t stackcount = 0, pushed = 0;
isc_result_t result;
const cfg_listelt_t *element;
const cfg_obj_t * addrlist;
const cfg_obj_t * portobj;
const cfg_obj_t * dscpobj;
in_port_t port;
isc_dscp_t dscp = -1;
dns_fixedname_t fname;
isc_sockaddr_t * addrs = NULL;
isc_dscp_t * dscps = NULL;
dns_name_t ** keys = NULL;
const cfg_obj_t *addrlist;
const cfg_obj_t *portobj;
const cfg_obj_t *dscpobj;
in_port_t port;
isc_dscp_t dscp = -1;
dns_fixedname_t fname;
isc_sockaddr_t *addrs = NULL;
isc_dscp_t *dscps = NULL;
dns_name_t **keys = NULL;
struct {
const char *name;
} *lists = NULL;
struct {
const cfg_listelt_t *element;
in_port_t port;
isc_dscp_t dscp;
in_port_t port;
isc_dscp_t dscp;
} *stack = NULL;
REQUIRE(ipkl != NULL);
@ -677,22 +667,22 @@ resume:
for (; element != NULL; element = cfg_list_next(element)) {
const cfg_obj_t *addr;
const cfg_obj_t *key;
const char * keystr;
isc_buffer_t b;
const char *keystr;
isc_buffer_t b;
addr = cfg_tuple_get(cfg_listelt_value(element), "masterselemen"
"t");
key = cfg_tuple_get(cfg_listelt_value(element), "key");
if (!cfg_obj_issockaddr(addr)) {
const char * listname = cfg_obj_asstring(addr);
const char *listname = cfg_obj_asstring(addr);
isc_result_t tresult;
/* Grow lists? */
if (listcount == l) {
void * tmp;
void *tmp;
uint32_t newlen = listcount + 16;
size_t newsize, oldsize;
size_t newsize, oldsize;
newsize = newlen * sizeof(*lists);
oldsize = listcount * sizeof(*lists);
@ -729,9 +719,9 @@ resume:
lists[l++].name = listname;
/* Grow stack? */
if (stackcount == pushed) {
void * tmp;
void *tmp;
uint32_t newlen = stackcount + 16;
size_t newsize, oldsize;
size_t newsize, oldsize;
newsize = newlen * sizeof(*stack);
oldsize = stackcount * sizeof(*stack);
@ -755,9 +745,9 @@ resume:
}
if (i == addrcount) {
void * tmp;
void *tmp;
uint32_t newlen = addrcount + 16;
size_t newsize, oldsize;
size_t newsize, oldsize;
newsize = newlen * sizeof(isc_sockaddr_t);
oldsize = addrcount * sizeof(isc_sockaddr_t);
@ -825,7 +815,7 @@ resume:
goto resume;
}
if (i < addrcount) {
void * tmp;
void *tmp;
size_t newsize, oldsize;
newsize = i * sizeof(isc_sockaddr_t);
@ -913,13 +903,12 @@ cleanup:
}
isc_result_t
named_config_getport(const cfg_obj_t *config, in_port_t *portp)
{
named_config_getport(const cfg_obj_t *config, in_port_t *portp) {
const cfg_obj_t *maps[3];
const cfg_obj_t *options = NULL;
const cfg_obj_t *portobj = NULL;
isc_result_t result;
int i;
isc_result_t result;
int i;
(void)cfg_map_get(config, "options", &options);
i = 0;
@ -942,11 +931,10 @@ named_config_getport(const cfg_obj_t *config, in_port_t *portp)
}
isc_result_t
named_config_getdscp(const cfg_obj_t *config, isc_dscp_t *dscpp)
{
named_config_getdscp(const cfg_obj_t *config, isc_dscp_t *dscpp) {
const cfg_obj_t *options = NULL;
const cfg_obj_t *dscpobj = NULL;
isc_result_t result;
isc_result_t result;
(void)cfg_map_get(config, "options", &options);
if (options == NULL) {
@ -978,7 +966,7 @@ struct keyalgorithms {
hmacsha384,
hmacsha512 } hmac;
unsigned int type;
uint16_t size;
uint16_t size;
} algorithms[] = { { "hmac-md5", hmacmd5, DST_ALG_HMACMD5, 128 },
{ "hmac-md5.sig-alg.reg.int", hmacmd5, DST_ALG_HMACMD5, 0 },
{ "hmac-md5.sig-alg.reg.int.", hmacmd5, DST_ALG_HMACMD5, 0 },
@ -991,25 +979,24 @@ struct keyalgorithms {
isc_result_t
named_config_getkeyalgorithm(const char *str, const dns_name_t **name,
uint16_t *digestbits)
{
uint16_t *digestbits) {
return (named_config_getkeyalgorithm2(str, name, NULL, digestbits));
}
isc_result_t
named_config_getkeyalgorithm2(const char *str, const dns_name_t **name,
unsigned int *typep, uint16_t *digestbits)
{
int i;
size_t len = 0;
uint16_t bits;
unsigned int *typep, uint16_t *digestbits) {
int i;
size_t len = 0;
uint16_t bits;
isc_result_t result;
for (i = 0; algorithms[i].str != NULL; i++) {
len = strlen(algorithms[i].str);
if (strncasecmp(algorithms[i].str, str, len) == 0 &&
(str[len] == '\0' ||
(algorithms[i].size != 0 && str[len] == '-'))) {
(algorithms[i].size != 0 && str[len] == '-')))
{
break;
}
}

41
bin/named/control.c
View file

@ -36,10 +36,9 @@
#endif /* ifdef HAVE_LIBSCF */
static isc_result_t
getcommand(isc_lex_t *lex, char **cmdp)
{
getcommand(isc_lex_t *lex, char **cmdp) {
isc_result_t result;
isc_token_t token;
isc_token_t token;
REQUIRE(cmdp != NULL && *cmdp == NULL);
@ -60,8 +59,7 @@ getcommand(isc_lex_t *lex, char **cmdp)
}
static inline bool
command_compare(const char *str, const char *command)
{
command_compare(const char *str, const char *command) {
return (strcasecmp(str, command) == 0);
}
@ -71,15 +69,14 @@ command_compare(const char *str, const char *command)
*/
isc_result_t
named_control_docommand(isccc_sexpr_t *message, bool readonly,
isc_buffer_t **text)
{
isc_buffer_t **text) {
isccc_sexpr_t *data;
char * cmdline = NULL;
char * command = NULL;
isc_result_t result;
int log_level;
isc_buffer_t src;
isc_lex_t * lex = NULL;
char *cmdline = NULL;
char *command = NULL;
isc_result_t result;
int log_level;
isc_buffer_t src;
isc_lex_t *lex = NULL;
#ifdef HAVE_LIBSCF
named_smf_want_disable = 0;
#endif /* ifdef HAVE_LIBSCF */
@ -122,7 +119,8 @@ named_control_docommand(isccc_sexpr_t *message, bool readonly,
*/
if ((command_compare(command, NAMED_COMMAND_NULL) &&
strlen(cmdline) == 4) ||
command_compare(command, NAMED_COMMAND_STATUS)) {
command_compare(command, NAMED_COMMAND_STATUS))
{
log_level = ISC_LOG_DEBUG(1);
} else {
log_level = ISC_LOG_INFO;
@ -138,7 +136,8 @@ named_control_docommand(isccc_sexpr_t *message, bool readonly,
!command_compare(command, NAMED_COMMAND_STATUS) &&
!command_compare(command, NAMED_COMMAND_SHOWZONE) &&
!command_compare(command, NAMED_COMMAND_TESTGEN) &&
!command_compare(command, NAMED_COMMAND_ZONESTATUS)) {
!command_compare(command, NAMED_COMMAND_ZONESTATUS))
{
isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_CONTROL, log_level,
"rejecting restricted control channel "
@ -204,12 +203,14 @@ named_control_docommand(isccc_sexpr_t *message, bool readonly,
isc_app_shutdown();
result = ISC_R_SUCCESS;
} else if (command_compare(command, NAMED_COMMAND_ADDZONE) ||
command_compare(command, NAMED_COMMAND_MODZONE)) {
command_compare(command, NAMED_COMMAND_MODZONE))
{
result = named_server_changezone(named_g_server, cmdline, text);
} else if (command_compare(command, NAMED_COMMAND_DELZONE)) {
result = named_server_delzone(named_g_server, lex, text);
} else if (command_compare(command, NAMED_COMMAND_DNSTAP) ||
command_compare(command, NAMED_COMMAND_DNSTAPREOPEN)) {
command_compare(command, NAMED_COMMAND_DNSTAPREOPEN))
{
result = named_server_dnstap(named_g_server, lex, text);
} else if (command_compare(command, NAMED_COMMAND_DUMPDB)) {
named_server_dumpdb(named_g_server, lex, text);
@ -225,7 +226,8 @@ named_control_docommand(isccc_sexpr_t *message, bool readonly,
} else if (command_compare(command, NAMED_COMMAND_FREEZE)) {
result = named_server_freeze(named_g_server, true, lex, text);
} else if (command_compare(command, NAMED_COMMAND_LOADKEYS) ||
command_compare(command, NAMED_COMMAND_SIGN)) {
command_compare(command, NAMED_COMMAND_SIGN))
{
result = named_server_rekey(named_g_server, lex, text);
} else if (command_compare(command, NAMED_COMMAND_MKEYS)) {
result = named_server_mkeys(named_g_server, lex, text);
@ -272,7 +274,8 @@ named_control_docommand(isccc_sexpr_t *message, bool readonly,
} else if (command_compare(command, NAMED_COMMAND_TESTGEN)) {
result = named_server_testgen(lex, text);
} else if (command_compare(command, NAMED_COMMAND_THAW) ||
command_compare(command, NAMED_COMMAND_UNFREEZE)) {
command_compare(command, NAMED_COMMAND_UNFREEZE))
{
result = named_server_freeze(named_g_server, false, lex, text);
} else if (command_compare(command, NAMED_COMMAND_TIMERPOKE)) {
isc_timermgr_poke(named_g_timermgr);

355
bin/named/controlconf.c
View file

@ -63,60 +63,57 @@ typedef struct controllistener controllistener_t;
typedef ISC_LIST(controllistener_t) controllistenerlist_t;
struct controlkey {
char * keyname;
uint32_t algorithm;
char *keyname;
uint32_t algorithm;
isc_region_t secret;
ISC_LINK(controlkey_t) link;
};
struct controlconnection {
isc_socket_t * sock;
isccc_ccmsg_t ccmsg;
bool ccmsg_valid;
bool sending;
isc_timer_t * timer;
isc_buffer_t * buffer;
isc_socket_t *sock;
isccc_ccmsg_t ccmsg;
bool ccmsg_valid;
bool sending;
isc_timer_t *timer;
isc_buffer_t *buffer;
controllistener_t *listener;
uint32_t nonce;
uint32_t nonce;
ISC_LINK(controlconnection_t) link;
};
struct controllistener {
named_controls_t * controls;
isc_mem_t * mctx;
isc_task_t * task;
isc_sockaddr_t address;
isc_socket_t * sock;
dns_acl_t * acl;
bool listening;
bool exiting;
controlkeylist_t keys;
named_controls_t *controls;
isc_mem_t *mctx;
isc_task_t *task;
isc_sockaddr_t address;
isc_socket_t *sock;
dns_acl_t *acl;
bool listening;
bool exiting;
controlkeylist_t keys;
controlconnectionlist_t connections;
isc_sockettype_t type;
uint32_t perm;
uint32_t owner;
uint32_t group;
bool readonly;
isc_sockettype_t type;
uint32_t perm;
uint32_t owner;
uint32_t group;
bool readonly;
ISC_LINK(controllistener_t) link;
};
struct named_controls {
named_server_t * server;
named_server_t *server;
controllistenerlist_t listeners;
bool shuttingdown;
isccc_symtab_t * symtab;
bool shuttingdown;
isccc_symtab_t *symtab;
};
static void
control_newconn(isc_task_t *task, isc_event_t *event);
static void
control_recvmessage(isc_task_t *task, isc_event_t *event);
static void control_newconn(isc_task_t *task, isc_event_t *event);
static void control_recvmessage(isc_task_t *task, isc_event_t *event);
#define CLOCKSKEW 300
static void
free_controlkey(controlkey_t *key, isc_mem_t *mctx)
{
free_controlkey(controlkey_t *key, isc_mem_t *mctx) {
if (key->keyname != NULL) {
isc_mem_free(mctx, key->keyname);
}
@ -127,8 +124,7 @@ free_controlkey(controlkey_t *key, isc_mem_t *mctx)
}
static void
free_controlkeylist(controlkeylist_t *keylist, isc_mem_t *mctx)
{
free_controlkeylist(controlkeylist_t *keylist, isc_mem_t *mctx) {
while (!ISC_LIST_EMPTY(*keylist)) {
controlkey_t *key = ISC_LIST_HEAD(*keylist);
ISC_LIST_UNLINK(*keylist, key, link);
@ -137,8 +133,7 @@ free_controlkeylist(controlkeylist_t *keylist, isc_mem_t *mctx)
}
static void
free_listener(controllistener_t *listener)
{
free_listener(controllistener_t *listener) {
INSIST(listener->exiting);
INSIST(!listener->listening);
INSIST(ISC_LIST_EMPTY(listener->connections));
@ -157,17 +152,16 @@ free_listener(controllistener_t *listener)
}
static void
maybe_free_listener(controllistener_t *listener)
{
maybe_free_listener(controllistener_t *listener) {
if (listener->exiting && !listener->listening &&
ISC_LIST_EMPTY(listener->connections)) {
ISC_LIST_EMPTY(listener->connections))
{
free_listener(listener);
}
}
static void
maybe_free_connection(controlconnection_t *conn)
{
maybe_free_connection(controlconnection_t *conn) {
controllistener_t *listener = conn->listener;
if (conn->buffer != NULL) {
@ -199,8 +193,7 @@ maybe_free_connection(controlconnection_t *conn)
}
static void
shutdown_listener(controllistener_t *listener)
{
shutdown_listener(controllistener_t *listener) {
controlconnection_t *conn;
controlconnection_t *next;
@ -235,13 +228,12 @@ shutdown_listener(controllistener_t *listener)
}
static bool
address_ok(isc_sockaddr_t *sockaddr, dns_acl_t *acl)
{
address_ok(isc_sockaddr_t *sockaddr, dns_acl_t *acl) {
dns_aclenv_t *env =
ns_interfacemgr_getaclenv(named_g_server->interfacemgr);
isc_netaddr_t netaddr;
isc_result_t result;
int match;
isc_result_t result;
int match;
isc_netaddr_fromsockaddr(&netaddr, sockaddr);
@ -250,8 +242,7 @@ address_ok(isc_sockaddr_t *sockaddr, dns_acl_t *acl)
}
static isc_result_t
control_accept(controllistener_t *listener)
{
control_accept(controllistener_t *listener) {
isc_result_t result;
result = isc_socket_accept(listener->sock, listener->task,
control_newconn, listener);
@ -266,8 +257,7 @@ control_accept(controllistener_t *listener)
}
static isc_result_t
control_listen(controllistener_t *listener)
{
control_listen(controllistener_t *listener) {
isc_result_t result;
result = isc_socket_listen(listener->sock, 0);
@ -280,19 +270,17 @@ control_listen(controllistener_t *listener)
}
static void
control_next(controllistener_t *listener)
{
control_next(controllistener_t *listener) {
(void)control_accept(listener);
}
static void
control_senddone(isc_task_t *task, isc_event_t *event)
{
isc_socketevent_t * sevent = (isc_socketevent_t *)event;
control_senddone(isc_task_t *task, isc_event_t *event) {
isc_socketevent_t *sevent = (isc_socketevent_t *)event;
controlconnection_t *conn = event->ev_arg;
controllistener_t * listener = conn->listener;
isc_socket_t * sock = (isc_socket_t *)sevent->ev_sender;
isc_result_t result;
controllistener_t *listener = conn->listener;
isc_socket_t *sock = (isc_socket_t *)sevent->ev_sender;
isc_result_t result;
REQUIRE(conn->sending);
@ -300,9 +288,9 @@ control_senddone(isc_task_t *task, isc_event_t *event)
conn->sending = false;
if (sevent->result != ISC_R_SUCCESS &&
sevent->result != ISC_R_CANCELED) {
char socktext[ISC_SOCKADDR_FORMATSIZE];
if (sevent->result != ISC_R_SUCCESS && sevent->result != ISC_R_CANCELED)
{
char socktext[ISC_SOCKADDR_FORMATSIZE];
isc_sockaddr_t peeraddr;
(void)isc_socket_getpeername(sock, &peeraddr);
@ -324,9 +312,8 @@ control_senddone(isc_task_t *task, isc_event_t *event)
}
static inline void
log_invalid(isccc_ccmsg_t *ccmsg, isc_result_t result)
{
char socktext[ISC_SOCKADDR_FORMATSIZE];
log_invalid(isccc_ccmsg_t *ccmsg, isc_result_t result) {
char socktext[ISC_SOCKADDR_FORMATSIZE];
isc_sockaddr_t peeraddr;
(void)isc_socket_getpeername(ccmsg->sock, &peeraddr);
@ -338,26 +325,25 @@ log_invalid(isccc_ccmsg_t *ccmsg, isc_result_t result)
}
static void
control_recvmessage(isc_task_t *task, isc_event_t *event)
{
control_recvmessage(isc_task_t *task, isc_event_t *event) {
controlconnection_t *conn = NULL;
controllistener_t * listener = NULL;
controlkey_t * key = NULL;
isccc_sexpr_t * request = NULL;
isccc_sexpr_t * response = NULL;
uint32_t algorithm;
isccc_region_t secret;
isc_stdtime_t now;
isc_buffer_t b;
isc_region_t r;
isc_buffer_t * text;
isc_result_t result;
isc_result_t eresult;
isccc_sexpr_t * _ctrl = NULL;
isccc_time_t sent;
isccc_time_t exp;
uint32_t nonce;
isccc_sexpr_t * data = NULL;
controllistener_t *listener = NULL;
controlkey_t *key = NULL;
isccc_sexpr_t *request = NULL;
isccc_sexpr_t *response = NULL;
uint32_t algorithm;
isccc_region_t secret;
isc_stdtime_t now;
isc_buffer_t b;
isc_region_t r;
isc_buffer_t *text;
isc_result_t result;
isc_result_t eresult;
isccc_sexpr_t *_ctrl = NULL;
isccc_time_t sent;
isccc_time_t exp;
uint32_t nonce;
isccc_sexpr_t *data = NULL;
REQUIRE(event->ev_type == ISCCC_EVENT_CCMSG);
@ -383,7 +369,8 @@ control_recvmessage(isc_task_t *task, isc_event_t *event)
request = NULL;
for (key = ISC_LIST_HEAD(listener->keys); key != NULL;
key = ISC_LIST_NEXT(key, link)) {
key = ISC_LIST_NEXT(key, link))
{
isccc_region_t ccregion;
ccregion.rstart = isc_buffer_base(&conn->ccmsg.buffer);
@ -460,7 +447,8 @@ control_recvmessage(isc_task_t *task, isc_event_t *event)
if (conn->nonce != 0 &&
(isccc_cc_lookupuint32(_ctrl, "_nonce", &nonce) != ISC_R_SUCCESS ||
conn->nonce != nonce)) {
conn->nonce != nonce))
{
log_invalid(&conn->ccmsg, ISCCC_R_BADAUTH);
goto cleanup_request;
}
@ -512,7 +500,8 @@ control_recvmessage(isc_task_t *task, isc_event_t *event)
_ctrl = isccc_alist_lookup(response, "_ctrl");
if (_ctrl == NULL ||
isccc_cc_defineuint32(_ctrl, "_nonce", conn->nonce) == NULL) {
isccc_cc_defineuint32(_ctrl, "_nonce", conn->nonce) == NULL)
{
goto cleanup_response;
}
@ -566,8 +555,7 @@ cleanup:
}
static void
control_timeout(isc_task_t *task, isc_event_t *event)
{
control_timeout(isc_task_t *task, isc_event_t *event) {
controlconnection_t *conn = event->ev_arg;
UNUSED(task);
@ -579,11 +567,10 @@ control_timeout(isc_task_t *task, isc_event_t *event)
}
static isc_result_t
newconnection(controllistener_t *listener, isc_socket_t *sock)
{
newconnection(controllistener_t *listener, isc_socket_t *sock) {
controlconnection_t *conn;
isc_interval_t interval;
isc_result_t result;
isc_interval_t interval;
isc_result_t result;
conn = isc_mem_get(listener->mctx, sizeof(*conn));
@ -636,13 +623,12 @@ cleanup:
}
static void
control_newconn(isc_task_t *task, isc_event_t *event)
{
control_newconn(isc_task_t *task, isc_event_t *event) {
isc_socket_newconnev_t *nevent = (isc_socket_newconnev_t *)event;
controllistener_t * listener = event->ev_arg;
isc_socket_t * sock;
isc_sockaddr_t peeraddr;
isc_result_t result;
controllistener_t *listener = event->ev_arg;
isc_socket_t *sock;
isc_sockaddr_t peeraddr;
isc_result_t result;
UNUSED(task);
@ -660,7 +646,8 @@ control_newconn(isc_task_t *task, isc_event_t *event)
isc_socket_setname(sock, "control", NULL);
(void)isc_socket_getpeername(sock, &peeraddr);
if (listener->type == isc_sockettype_tcp &&
!address_ok(&peeraddr, listener->acl)) {
!address_ok(&peeraddr, listener->acl))
{
char socktext[ISC_SOCKADDR_FORMATSIZE];
isc_sockaddr_format(&peeraddr, socktext, sizeof(socktext));
isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
@ -690,13 +677,13 @@ cleanup:
}
static void
controls_shutdown(named_controls_t *controls)
{
controls_shutdown(named_controls_t *controls) {
controllistener_t *listener;
controllistener_t *next;
for (listener = ISC_LIST_HEAD(controls->listeners); listener != NULL;
listener = next) {
listener = next)
{
/*
* This is asynchronous. As listeners shut down, they will
* call their callbacks.
@ -707,22 +694,21 @@ controls_shutdown(named_controls_t *controls)
}
void
named_controls_shutdown(named_controls_t *controls)
{
named_controls_shutdown(named_controls_t *controls) {
controls_shutdown(controls);
controls->shuttingdown = true;
}
static isc_result_t
cfgkeylist_find(const cfg_obj_t *keylist, const char *keyname,
const cfg_obj_t **objp)
{
const cfg_obj_t **objp) {
const cfg_listelt_t *element;
const char * str;
const cfg_obj_t * obj;
const char *str;
const cfg_obj_t *obj;
for (element = cfg_list_first(keylist); element != NULL;
element = cfg_list_next(element)) {
element = cfg_list_next(element))
{
obj = cfg_listelt_value(element);
str = cfg_obj_asstring(cfg_map_getname(obj));
if (strcasecmp(str, keyname) == 0) {
@ -739,16 +725,16 @@ cfgkeylist_find(const cfg_obj_t *keylist, const char *keyname,
static void
controlkeylist_fromcfg(const cfg_obj_t *keylist, isc_mem_t *mctx,
controlkeylist_t *keyids)
{
controlkeylist_t *keyids) {
const cfg_listelt_t *element;
char * newstr = NULL;
const char * str;
const cfg_obj_t * obj;
controlkey_t * key;
char *newstr = NULL;
const char *str;
const cfg_obj_t *obj;
controlkey_t *key;
for (element = cfg_list_first(keylist); element != NULL;
element = cfg_list_next(element)) {
element = cfg_list_next(element))
{
obj = cfg_listelt_value(element);
str = cfg_obj_asstring(obj);
newstr = isc_mem_strdup(mctx, str);
@ -765,13 +751,12 @@ controlkeylist_fromcfg(const cfg_obj_t *keylist, isc_mem_t *mctx,
static void
register_keys(const cfg_obj_t *control, const cfg_obj_t *keylist,
controlkeylist_t *keyids, isc_mem_t *mctx, const char *socktext)
{
controlkey_t * keyid, *next;
controlkeylist_t *keyids, isc_mem_t *mctx, const char *socktext) {
controlkey_t *keyid, *next;
const cfg_obj_t *keydef;
char secret[1024];
isc_buffer_t b;
isc_result_t result;
char secret[1024];
isc_buffer_t b;
isc_result_t result;
/*
* Find the keys corresponding to the keyids used by this listener.
@ -790,9 +775,9 @@ register_keys(const cfg_obj_t *control, const cfg_obj_t *keylist,
} else {
const cfg_obj_t *algobj = NULL;
const cfg_obj_t *secretobj = NULL;
const char * algstr = NULL;
const char * secretstr = NULL;
unsigned int algtype;
const char *algstr = NULL;
const char *secretstr = NULL;
unsigned int algtype;
(void)cfg_map_get(keydef, "algorithm", &algobj);
(void)cfg_map_get(keydef, "secret", &secretobj);
@ -803,7 +788,8 @@ register_keys(const cfg_obj_t *control, const cfg_obj_t *keylist,
if (named_config_getkeyalgorithm2(algstr, NULL,
&algtype, NULL) !=
ISC_R_SUCCESS) {
ISC_R_SUCCESS)
{
cfg_obj_log(control, named_g_lctx,
ISC_LOG_WARNING,
"unsupported algorithm '%s' in "
@ -832,8 +818,8 @@ register_keys(const cfg_obj_t *control, const cfg_obj_t *keylist,
}
keyid->secret.length = isc_buffer_usedlength(&b);
keyid->secret.base =
isc_mem_get(mctx, keyid->secret.length);
keyid->secret.base = isc_mem_get(mctx,
keyid->secret.length);
memmove(keyid->secret.base, isc_buffer_base(&b),
keyid->secret.length);
}
@ -848,20 +834,19 @@ register_keys(const cfg_obj_t *control, const cfg_obj_t *keylist,
} while (0)
static isc_result_t
get_rndckey(isc_mem_t *mctx, controlkeylist_t *keyids)
{
isc_result_t result;
cfg_parser_t * pctx = NULL;
cfg_obj_t * config = NULL;
get_rndckey(isc_mem_t *mctx, controlkeylist_t *keyids) {
isc_result_t result;
cfg_parser_t *pctx = NULL;
cfg_obj_t *config = NULL;
const cfg_obj_t *key = NULL;
const cfg_obj_t *algobj = NULL;
const cfg_obj_t *secretobj = NULL;
const char * algstr = NULL;
const char * secretstr = NULL;
controlkey_t * keyid = NULL;
char secret[1024];
unsigned int algtype;
isc_buffer_t b;
const char *algstr = NULL;
const char *secretstr = NULL;
controlkey_t *keyid = NULL;
char secret[1024];
unsigned int algtype;
isc_buffer_t b;
isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_CONTROL, ISC_LOG_INFO,
@ -876,8 +861,8 @@ get_rndckey(isc_mem_t *mctx, controlkeylist_t *keyids)
CHECK(cfg_map_get(config, "key", &key));
keyid = isc_mem_get(mctx, sizeof(*keyid));
keyid->keyname =
isc_mem_strdup(mctx, cfg_obj_asstring(cfg_map_getname(key)));
keyid->keyname = isc_mem_strdup(mctx,
cfg_obj_asstring(cfg_map_getname(key)));
keyid->secret.base = NULL;
keyid->secret.length = 0;
keyid->algorithm = DST_ALG_UNKNOWN;
@ -896,7 +881,8 @@ get_rndckey(isc_mem_t *mctx, controlkeylist_t *keyids)
secretstr = cfg_obj_asstring(secretobj);
if (named_config_getkeyalgorithm2(algstr, NULL, &algtype, NULL) !=
ISC_R_SUCCESS) {
ISC_R_SUCCESS)
{
cfg_obj_log(key, named_g_lctx, ISC_LOG_WARNING,
"unsupported algorithm '%s' in "
"key '%s' for use with command "
@ -943,9 +929,8 @@ cleanup:
static void
get_key_info(const cfg_obj_t *config, const cfg_obj_t *control,
const cfg_obj_t **global_keylistp,
const cfg_obj_t **control_keylistp)
{
isc_result_t result;
const cfg_obj_t **control_keylistp) {
isc_result_t result;
const cfg_obj_t *control_keylist = NULL;
const cfg_obj_t *global_keylist = NULL;
@ -969,18 +954,18 @@ static void
update_listener(named_controls_t *cp, controllistener_t **listenerp,
const cfg_obj_t *control, const cfg_obj_t *config,
isc_sockaddr_t *addr, cfg_aclconfctx_t *aclconfctx,
const char *socktext, isc_sockettype_t type)
{
const char *socktext, isc_sockettype_t type) {
controllistener_t *listener;
const cfg_obj_t * allow;
const cfg_obj_t * global_keylist = NULL;
const cfg_obj_t * control_keylist = NULL;
dns_acl_t * new_acl = NULL;
controlkeylist_t keys;
isc_result_t result = ISC_R_SUCCESS;
const cfg_obj_t *allow;
const cfg_obj_t *global_keylist = NULL;
const cfg_obj_t *control_keylist = NULL;
dns_acl_t *new_acl = NULL;
controlkeylist_t keys;
isc_result_t result = ISC_R_SUCCESS;
for (listener = ISC_LIST_HEAD(cp->listeners); listener != NULL;
listener = ISC_LIST_NEXT(listener, link)) {
listener = ISC_LIST_NEXT(listener, link))
{
if (isc_sockaddr_equal(addr, &listener->address)) {
break;
}
@ -1097,7 +1082,8 @@ update_listener(named_controls_t *cp, controllistener_t **listenerp,
group = cfg_obj_asuint32(cfg_tuple_get(control, "group"));
result = ISC_R_SUCCESS;
if (listener->perm != perm || listener->owner != owner ||
listener->group != group) {
listener->group != group)
{
result = isc_socket_permunix(&listener->address, perm,
owner, group);
}
@ -1120,15 +1106,14 @@ static void
add_listener(named_controls_t *cp, controllistener_t **listenerp,
const cfg_obj_t *control, const cfg_obj_t *config,
isc_sockaddr_t *addr, cfg_aclconfctx_t *aclconfctx,
const char *socktext, isc_sockettype_t type)
{
isc_mem_t * mctx = cp->server->mctx;
const char *socktext, isc_sockettype_t type) {
isc_mem_t *mctx = cp->server->mctx;
controllistener_t *listener;
const cfg_obj_t * allow;
const cfg_obj_t * global_keylist = NULL;
const cfg_obj_t * control_keylist = NULL;
dns_acl_t * new_acl = NULL;
isc_result_t result = ISC_R_SUCCESS;
const cfg_obj_t *allow;
const cfg_obj_t *global_keylist = NULL;
const cfg_obj_t *control_keylist = NULL;
dns_acl_t *new_acl = NULL;
isc_result_t result = ISC_R_SUCCESS;
listener = isc_mem_get(mctx, sizeof(*listener));
@ -1205,7 +1190,8 @@ add_listener(named_controls_t *cp, controllistener_t **listenerp,
#ifdef ISC_PLATFORM_HAVESYSUNH
(pf == AF_UNIX && isc_net_probeunix() != ISC_R_SUCCESS) ||
#endif /* ifdef ISC_PLATFORM_HAVESYSUNH */
(pf == AF_INET6 && isc_net_probeipv6() != ISC_R_SUCCESS)) {
(pf == AF_INET6 && isc_net_probeipv6() != ISC_R_SUCCESS))
{
result = ISC_R_FAMILYNOSUPPORT;
}
}
@ -1282,13 +1268,12 @@ add_listener(named_controls_t *cp, controllistener_t **listenerp,
isc_result_t
named_controls_configure(named_controls_t *cp, const cfg_obj_t *config,
cfg_aclconfctx_t *aclconfctx)
{
controllistener_t * listener;
cfg_aclconfctx_t *aclconfctx) {
controllistener_t *listener;
controllistenerlist_t new_listeners;
const cfg_obj_t * controlslist = NULL;
const cfg_listelt_t * element, *element2;
char socktext[ISC_SOCKADDR_FORMATSIZE];
const cfg_obj_t *controlslist = NULL;
const cfg_listelt_t *element, *element2;
char socktext[ISC_SOCKADDR_FORMATSIZE];
ISC_LIST_INIT(new_listeners);
@ -1307,7 +1292,8 @@ named_controls_configure(named_controls_t *cp, const cfg_obj_t *config,
*/
if (controlslist != NULL) {
for (element = cfg_list_first(controlslist); element != NULL;
element = cfg_list_next(element)) {
element = cfg_list_next(element))
{
const cfg_obj_t *controls;
const cfg_obj_t *inetcontrols = NULL;
@ -1319,10 +1305,11 @@ named_controls_configure(named_controls_t *cp, const cfg_obj_t *config,
for (element2 = cfg_list_first(inetcontrols);
element2 != NULL;
element2 = cfg_list_next(element2)) {
element2 = cfg_list_next(element2))
{
const cfg_obj_t *control;
const cfg_obj_t *obj;
isc_sockaddr_t addr;
isc_sockaddr_t addr;
/*
* The parser handles BIND 8 configuration file
@ -1376,7 +1363,8 @@ named_controls_configure(named_controls_t *cp, const cfg_obj_t *config,
}
}
for (element = cfg_list_first(controlslist); element != NULL;
element = cfg_list_next(element)) {
element = cfg_list_next(element))
{
const cfg_obj_t *controls;
const cfg_obj_t *unixcontrols = NULL;
@ -1388,11 +1376,12 @@ named_controls_configure(named_controls_t *cp, const cfg_obj_t *config,
for (element2 = cfg_list_first(unixcontrols);
element2 != NULL;
element2 = cfg_list_next(element2)) {
element2 = cfg_list_next(element2))
{
const cfg_obj_t *control;
const cfg_obj_t *path;
isc_sockaddr_t addr;
isc_result_t result;
isc_sockaddr_t addr;
isc_result_t result;
/*
* The parser handles BIND 8 configuration file
@ -1518,10 +1507,9 @@ named_controls_configure(named_controls_t *cp, const cfg_obj_t *config,
}
isc_result_t
named_controls_create(named_server_t *server, named_controls_t **ctrlsp)
{
isc_mem_t * mctx = server->mctx;
isc_result_t result;
named_controls_create(named_server_t *server, named_controls_t **ctrlsp) {
isc_mem_t *mctx = server->mctx;
isc_result_t result;
named_controls_t *controls = isc_mem_get(mctx, sizeof(*controls));
if (controls == NULL) {
@ -1541,8 +1529,7 @@ named_controls_create(named_server_t *server, named_controls_t **ctrlsp)
}
void
named_controls_destroy(named_controls_t **ctrlsp)
{
named_controls_destroy(named_controls_t **ctrlsp) {
named_controls_t *controls = *ctrlsp;
*ctrlsp = NULL;

77
bin/named/fuzz.c
View file

@ -40,9 +40,9 @@
* unthreaded version of BIND, where all thread functions are
* mocks. Since AFL for now only works on Linux it's not a problem.
*/
static pthread_cond_t cond;
static pthread_cond_t cond;
static pthread_mutex_t mutex;
static bool ready;
static bool ready;
/*
* In "client:" mode, this thread reads fuzzed query messages from AFL
@ -51,13 +51,12 @@ static bool ready;
* test named from the client side.
*/
static void *
fuzz_thread_client(void *arg)
{
char * host;
char * port;
fuzz_thread_client(void *arg) {
char *host;
char *port;
struct sockaddr_in servaddr;
int sockfd;
void * buf;
int sockfd;
void *buf;
UNUSED(arg);
@ -180,9 +179,8 @@ fuzz_thread_client(void *arg)
* named(resolver) when being fuzzed will not cache answers.
*/
static void *
fuzz_thread_resolver(void *arg)
{
char * sqtype, *shost, *sport, *rhost, *rport;
fuzz_thread_resolver(void *arg) {
char *sqtype, *shost, *sport, *rhost, *rport;
struct sockaddr_in servaddr, recaddr, recvaddr;
/*
* Query for aaaaaaaaaa.example./A in wire format with RD=1,
@ -267,15 +265,15 @@ fuzz_thread_resolver(void *arg)
0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00
};
int sockfd;
int listenfd;
int loop;
uint16_t qtype;
char * buf, *rbuf;
char * nameptr;
int sockfd;
int listenfd;
int loop;
uint16_t qtype;
char *buf, *rbuf;
char *nameptr;
unsigned int i;
uint8_t llen;
uint64_t seed;
uint8_t llen;
uint64_t seed;
UNUSED(arg);
@ -354,10 +352,10 @@ fuzz_thread_resolver(void *arg)
* the app.
*/
for (loop = 0; loop < 100000; loop++) {
ssize_t length;
ssize_t sent;
ssize_t length;
ssize_t sent;
unsigned short id;
socklen_t socklen;
socklen_t socklen;
memset(buf, 0, 12);
length = read(0, buf, 65536);
@ -450,7 +448,8 @@ fuzz_thread_resolver(void *arg)
/* Skip the name to get to the qtype */
i = 0;
while (((llen = nameptr[i]) != 0) && (i < 255) &&
(((nameptr + i + 1 + llen) - buf) < length)) {
(((nameptr + i + 1 + llen) - buf) < length))
{
i += 1 + llen;
}
@ -477,10 +476,10 @@ fuzz_thread_resolver(void *arg)
/* We might get additional questions here (e.g. for CNAME). */
for (;;) {
fd_set fds;
fd_set fds;
struct timeval tv;
int rv;
int max;
int rv;
int max;
FD_ZERO(&fds);
FD_SET(listenfd, &fds);
@ -523,7 +522,8 @@ fuzz_thread_resolver(void *arg)
/* Skip the name to get to the qtype */
i = 0;
while (((llen = nameptr[i]) != 0) && (i < 255) &&
(((nameptr + i + 1 + llen) - buf) < length)) {
(((nameptr + i + 1 + llen) - buf) < length))
{
i += 1 + llen;
}
@ -597,14 +597,13 @@ fuzz_thread_resolver(void *arg)
* client side.
*/
static void *
fuzz_thread_tcp(void *arg)
{
char * host;
char * port;
fuzz_thread_tcp(void *arg) {
char *host;
char *port;
struct sockaddr_in servaddr;
int sockfd;
char * buf;
int loop;
int sockfd;
char *buf;
int loop;
UNUSED(arg);
@ -645,8 +644,8 @@ fuzz_thread_tcp(void *arg)
for (loop = 0; loop < 100000; loop++) {
ssize_t length;
ssize_t sent;
int yes;
int r;
int yes;
int r;
if (named_g_fuzz_type == isc_fuzz_tcpclient) {
/*
@ -728,8 +727,7 @@ fuzz_thread_tcp(void *arg)
* and process the next item from AFL.
*/
void
named_fuzz_notify(void)
{
named_fuzz_notify(void) {
#ifdef ENABLE_AFL
if (getenv("AFL_CMIN")) {
named_server_flushonshutdown(named_g_server, false);
@ -749,8 +747,7 @@ named_fuzz_notify(void)
}
void
named_fuzz_setup(void)
{
named_fuzz_setup(void) {
#ifdef ENABLE_AFL
if (getenv("__AFL_PERSISTENT") || getenv("AFL_CMIN")) {
pthread_t thread;

35
bin/named/geoip.c
View file

@ -30,11 +30,10 @@ static dns_geoip_databases_t geoip_table;
static MMDB_s geoip_country, geoip_city, geoip_as, geoip_isp, geoip_domain;
static MMDB_s *
open_geoip2(const char *dir, const char *dbfile, MMDB_s *mmdb)
{
char pathbuf[PATH_MAX];
open_geoip2(const char *dir, const char *dbfile, MMDB_s *mmdb) {
char pathbuf[PATH_MAX];
unsigned int n;
int ret;
int ret;
n = snprintf(pathbuf, sizeof(pathbuf), "%s/%s", dir, dbfile);
if (n >= sizeof(pathbuf)) {
@ -63,8 +62,7 @@ open_geoip2(const char *dir, const char *dbfile, MMDB_s *mmdb)
#endif /* HAVE_GEOIP2 */
void
named_geoip_init(void)
{
named_geoip_init(void) {
#if defined(HAVE_GEOIP2)
if (named_g_geoip == NULL) {
named_g_geoip = &geoip_table;
@ -75,8 +73,7 @@ named_geoip_init(void)
}
void
named_geoip_load(char *dir)
{
named_geoip_load(char *dir) {
#if defined(HAVE_GEOIP2)
REQUIRE(dir != NULL);
@ -84,8 +81,8 @@ named_geoip_load(char *dir)
NAMED_LOGMODULE_SERVER, ISC_LOG_INFO,
"looking for GeoIP2 databases in '%s'", dir);
named_g_geoip->country =
open_geoip2(dir, "GeoIP2-Country.mmdb", &geoip_country);
named_g_geoip->country = open_geoip2(dir, "GeoIP2-Country.mmdb",
&geoip_country);
if (named_g_geoip->country == NULL) {
named_g_geoip->country = open_geoip2(
dir, "GeoLite2-Country.mmdb", &geoip_country);
@ -93,19 +90,19 @@ named_geoip_load(char *dir)
named_g_geoip->city = open_geoip2(dir, "GeoIP2-City.mmdb", &geoip_city);
if (named_g_geoip->city == NULL) {
named_g_geoip->city =
open_geoip2(dir, "GeoLite2-City.mmdb", &geoip_city);
named_g_geoip->city = open_geoip2(dir, "GeoLite2-City.mmdb",
&geoip_city);
}
named_g_geoip->as = open_geoip2(dir, "GeoIP2-ASN.mmdb", &geoip_as);
if (named_g_geoip->as == NULL) {
named_g_geoip->as =
open_geoip2(dir, "GeoLite2-ASN.mmdb", &geoip_as);
named_g_geoip->as = open_geoip2(dir, "GeoLite2-ASN.mmdb",
&geoip_as);
}
named_g_geoip->isp = open_geoip2(dir, "GeoIP2-ISP.mmdb", &geoip_isp);
named_g_geoip->domain =
open_geoip2(dir, "GeoIP2-Domain.mmdb", &geoip_domain);
named_g_geoip->domain = open_geoip2(dir, "GeoIP2-Domain.mmdb",
&geoip_domain);
#else /* if defined(HAVE_GEOIP2) */
UNUSED(dir);
@ -114,8 +111,7 @@ named_geoip_load(char *dir)
}
void
named_geoip_unload(void)
{
named_geoip_unload(void) {
#ifdef HAVE_GEOIP2
if (named_g_geoip->country != NULL) {
MMDB_close(named_g_geoip->country);
@ -141,8 +137,7 @@ named_geoip_unload(void)
}
void
named_geoip_shutdown(void)
{
named_geoip_shutdown(void) {
#ifdef HAVE_GEOIP2
named_geoip_unload();
#endif /* HAVE_GEOIP2 */

84
bin/named/include/named/control.h
View file

@ -26,49 +26,49 @@
#define NAMED_CONTROL_PORT 953
#define NAMED_COMMAND_STOP "stop"
#define NAMED_COMMAND_HALT "halt"
#define NAMED_COMMAND_RELOAD "reload"
#define NAMED_COMMAND_RECONFIG "reconfig"
#define NAMED_COMMAND_REFRESH "refresh"
#define NAMED_COMMAND_RETRANSFER "retransfer"
#define NAMED_COMMAND_DUMPSTATS "stats"
#define NAMED_COMMAND_QUERYLOG "querylog"
#define NAMED_COMMAND_DUMPDB "dumpdb"
#define NAMED_COMMAND_SECROOTS "secroots"
#define NAMED_COMMAND_TRACE "trace"
#define NAMED_COMMAND_NOTRACE "notrace"
#define NAMED_COMMAND_FLUSH "flush"
#define NAMED_COMMAND_FLUSHNAME "flushname"
#define NAMED_COMMAND_FLUSHTREE "flushtree"
#define NAMED_COMMAND_STATUS "status"
#define NAMED_COMMAND_TSIGLIST "tsig-list"
#define NAMED_COMMAND_TSIGDELETE "tsig-delete"
#define NAMED_COMMAND_FREEZE "freeze"
#define NAMED_COMMAND_UNFREEZE "unfreeze"
#define NAMED_COMMAND_THAW "thaw"
#define NAMED_COMMAND_TIMERPOKE "timerpoke"
#define NAMED_COMMAND_RECURSING "recursing"
#define NAMED_COMMAND_NULL "null"
#define NAMED_COMMAND_NOTIFY "notify"
#define NAMED_COMMAND_VALIDATION "validation"
#define NAMED_COMMAND_SCAN "scan"
#define NAMED_COMMAND_SIGN "sign"
#define NAMED_COMMAND_LOADKEYS "loadkeys"
#define NAMED_COMMAND_ADDZONE "addzone"
#define NAMED_COMMAND_MODZONE "modzone"
#define NAMED_COMMAND_DELZONE "delzone"
#define NAMED_COMMAND_SHOWZONE "showzone"
#define NAMED_COMMAND_SYNC "sync"
#define NAMED_COMMAND_SIGNING "signing"
#define NAMED_COMMAND_ZONESTATUS "zonestatus"
#define NAMED_COMMAND_NTA "nta"
#define NAMED_COMMAND_TESTGEN "testgen"
#define NAMED_COMMAND_MKEYS "managed-keys"
#define NAMED_COMMAND_STOP "stop"
#define NAMED_COMMAND_HALT "halt"
#define NAMED_COMMAND_RELOAD "reload"
#define NAMED_COMMAND_RECONFIG "reconfig"
#define NAMED_COMMAND_REFRESH "refresh"
#define NAMED_COMMAND_RETRANSFER "retransfer"
#define NAMED_COMMAND_DUMPSTATS "stats"
#define NAMED_COMMAND_QUERYLOG "querylog"
#define NAMED_COMMAND_DUMPDB "dumpdb"
#define NAMED_COMMAND_SECROOTS "secroots"
#define NAMED_COMMAND_TRACE "trace"
#define NAMED_COMMAND_NOTRACE "notrace"
#define NAMED_COMMAND_FLUSH "flush"
#define NAMED_COMMAND_FLUSHNAME "flushname"
#define NAMED_COMMAND_FLUSHTREE "flushtree"
#define NAMED_COMMAND_STATUS "status"
#define NAMED_COMMAND_TSIGLIST "tsig-list"
#define NAMED_COMMAND_TSIGDELETE "tsig-delete"
#define NAMED_COMMAND_FREEZE "freeze"
#define NAMED_COMMAND_UNFREEZE "unfreeze"
#define NAMED_COMMAND_THAW "thaw"
#define NAMED_COMMAND_TIMERPOKE "timerpoke"
#define NAMED_COMMAND_RECURSING "recursing"
#define NAMED_COMMAND_NULL "null"
#define NAMED_COMMAND_NOTIFY "notify"
#define NAMED_COMMAND_VALIDATION "validation"
#define NAMED_COMMAND_SCAN "scan"
#define NAMED_COMMAND_SIGN "sign"
#define NAMED_COMMAND_LOADKEYS "loadkeys"
#define NAMED_COMMAND_ADDZONE "addzone"
#define NAMED_COMMAND_MODZONE "modzone"
#define NAMED_COMMAND_DELZONE "delzone"
#define NAMED_COMMAND_SHOWZONE "showzone"
#define NAMED_COMMAND_SYNC "sync"
#define NAMED_COMMAND_SIGNING "signing"
#define NAMED_COMMAND_ZONESTATUS "zonestatus"
#define NAMED_COMMAND_NTA "nta"
#define NAMED_COMMAND_TESTGEN "testgen"
#define NAMED_COMMAND_MKEYS "managed-keys"
#define NAMED_COMMAND_DNSTAPREOPEN "dnstap-reopen"
#define NAMED_COMMAND_DNSTAP "dnstap"
#define NAMED_COMMAND_TCPTIMEOUTS "tcp-timeouts"
#define NAMED_COMMAND_SERVESTALE "serve-stale"
#define NAMED_COMMAND_DNSTAP "dnstap"
#define NAMED_COMMAND_TCPTIMEOUTS "tcp-timeouts"
#define NAMED_COMMAND_SERVESTALE "serve-stale"
isc_result_t
named_controls_create(named_server_t *server, named_controls_t **ctrlsp);

4
bin/named/include/named/log.h
View file

@ -29,8 +29,8 @@
*/
#define NAMED_LOGCATEGORY_GENERAL ISC_LOGCATEGORY_GENERAL
#define NAMED_LOGMODULE_MAIN (&named_g_modules[0])
#define NAMED_LOGMODULE_SERVER (&named_g_modules[1])
#define NAMED_LOGMODULE_MAIN (&named_g_modules[0])
#define NAMED_LOGMODULE_SERVER (&named_g_modules[1])
#define NAMED_LOGMODULE_CONTROL (&named_g_modules[2])
isc_result_t

6
bin/named/include/named/server.h
View file

@ -35,8 +35,8 @@
#include <named/types.h>
#define NAMED_EVENTCLASS ISC_EVENTCLASS(0x4E43)
#define NAMED_EVENT_RELOAD (NAMED_EVENTCLASS + 0)
#define NAMED_EVENTCLASS ISC_EVENTCLASS(0x4E43)
#define NAMED_EVENT_RELOAD (NAMED_EVENTCLASS + 0)
#define NAMED_EVENT_DELZONE (NAMED_EVENTCLASS + 1)
/*%
@ -112,7 +112,7 @@ struct named_server {
char *lockfile;
};
#define NAMED_SERVER_MAGIC ISC_MAGIC('S', 'V', 'E', 'R')
#define NAMED_SERVER_MAGIC ISC_MAGIC('S', 'V', 'E', 'R')
#define NAMED_SERVER_VALID(s) ISC_MAGIC_VALID(s, NAMED_SERVER_MAGIC)
void

24
bin/named/log.c
View file

@ -43,9 +43,8 @@ static isc_logmodule_t modules[] = {
};
isc_result_t
named_log_init(bool safe)
{
isc_result_t result;
named_log_init(bool safe) {
isc_result_t result;
isc_logconfig_t *lcfg = NULL;
named_g_categories = categories;
@ -96,9 +95,8 @@ cleanup:
}
isc_result_t
named_log_setdefaultchannels(isc_logconfig_t *lcfg)
{
isc_result_t result;
named_log_setdefaultchannels(isc_logconfig_t *lcfg) {
isc_result_t result;
isc_logdestination_t destination;
/*
@ -155,9 +153,8 @@ cleanup:
}
isc_result_t
named_log_setsafechannels(isc_logconfig_t *lcfg)
{
isc_result_t result;
named_log_setsafechannels(isc_logconfig_t *lcfg) {
isc_result_t result;
isc_logdestination_t destination;
if (!named_g_logstderr) {
@ -208,8 +205,7 @@ cleanup:
}
isc_result_t
named_log_setdefaultcategory(isc_logconfig_t *lcfg)
{
named_log_setdefaultcategory(isc_logconfig_t *lcfg) {
isc_result_t result = ISC_R_SUCCESS;
result = isc_log_usechannel(lcfg, "default_debug",
@ -235,8 +231,7 @@ cleanup:
}
isc_result_t
named_log_setunmatchedcategory(isc_logconfig_t *lcfg)
{
named_log_setunmatchedcategory(isc_logconfig_t *lcfg) {
isc_result_t result;
result = isc_log_usechannel(lcfg, "null", NAMED_LOGCATEGORY_UNMATCHED,
@ -245,8 +240,7 @@ named_log_setunmatchedcategory(isc_logconfig_t *lcfg)
}
void
named_log_shutdown(void)
{
named_log_shutdown(void) {
isc_log_destroy(&named_g_lctx);
isc_log_setcontext(NULL);
dns_log_setcontext(NULL);

86
bin/named/logconf.c
View file

@ -41,13 +41,12 @@
* in 'ccat' and add it to 'logconfig'.
*/
static isc_result_t
category_fromconf(const cfg_obj_t *ccat, isc_logconfig_t *logconfig)
{
isc_result_t result;
const char * catname;
isc_logcategory_t * category;
isc_logmodule_t * module;
const cfg_obj_t * destinations = NULL;
category_fromconf(const cfg_obj_t *ccat, isc_logconfig_t *logconfig) {
isc_result_t result;
const char *catname;
isc_logcategory_t *category;
isc_logmodule_t *module;
const cfg_obj_t *destinations = NULL;
const cfg_listelt_t *element = NULL;
catname = cfg_obj_asstring(cfg_tuple_get(ccat, "name"));
@ -69,9 +68,10 @@ category_fromconf(const cfg_obj_t *ccat, isc_logconfig_t *logconfig)
destinations = cfg_tuple_get(ccat, "destinations");
for (element = cfg_list_first(destinations); element != NULL;
element = cfg_list_next(element)) {
element = cfg_list_next(element))
{
const cfg_obj_t *channel = cfg_listelt_value(element);
const char * channelname = cfg_obj_asstring(channel);
const char *channelname = cfg_obj_asstring(channel);
result = isc_log_usechannel(logconfig, channelname, category,
module);
@ -91,20 +91,19 @@ category_fromconf(const cfg_obj_t *ccat, isc_logconfig_t *logconfig)
* in 'cchan' and add it to 'logconfig'.
*/
static isc_result_t
channel_fromconf(const cfg_obj_t *channel, isc_logconfig_t *logconfig)
{
isc_result_t result;
channel_fromconf(const cfg_obj_t *channel, isc_logconfig_t *logconfig) {
isc_result_t result;
isc_logdestination_t dest;
unsigned int type;
unsigned int flags = 0;
int level;
const char * channelname;
const cfg_obj_t * fileobj = NULL;
const cfg_obj_t * syslogobj = NULL;
const cfg_obj_t * nullobj = NULL;
const cfg_obj_t * stderrobj = NULL;
const cfg_obj_t * severity = NULL;
int i;
unsigned int type;
unsigned int flags = 0;
int level;
const char *channelname;
const cfg_obj_t *fileobj = NULL;
const cfg_obj_t *syslogobj = NULL;
const cfg_obj_t *nullobj = NULL;
const cfg_obj_t *stderrobj = NULL;
const cfg_obj_t *severity = NULL;
int i;
channelname = cfg_obj_asstring(cfg_map_getname(channel));
@ -143,10 +142,10 @@ channel_fromconf(const cfg_obj_t *channel, isc_logconfig_t *logconfig)
const cfg_obj_t *versionsobj = cfg_tuple_get(fileobj, "version"
"s");
const cfg_obj_t *suffixobj = cfg_tuple_get(fileobj, "suffix");
int32_t versions = ISC_LOG_ROLLNEVER;
int32_t versions = ISC_LOG_ROLLNEVER;
isc_log_rollsuffix_t suffix = isc_log_rollsuffix_increment;
isc_offset_t size = 0;
uint64_t maxoffset;
isc_offset_t size = 0;
uint64_t maxoffset;
/*
* isc_offset_t is a signed integer type, so the maximum
@ -170,17 +169,19 @@ channel_fromconf(const cfg_obj_t *channel, isc_logconfig_t *logconfig)
versions = cfg_obj_asuint32(versionsobj);
} else if (versionsobj != NULL &&
cfg_obj_isstring(versionsobj) &&
strcasecmp(cfg_obj_asstring(versionsobj),
"unlimite"
"d") == 0) {
strcasecmp(cfg_obj_asstring(versionsobj), "unlimite"
"d") == 0)
{
versions = ISC_LOG_ROLLINFINITE;
}
if (sizeobj != NULL && cfg_obj_isuint64(sizeobj) &&
cfg_obj_asuint64(sizeobj) < maxoffset) {
cfg_obj_asuint64(sizeobj) < maxoffset)
{
size = (isc_offset_t)cfg_obj_asuint64(sizeobj);
}
if (suffixobj != NULL && cfg_obj_isstring(suffixobj) &&
strcasecmp(cfg_obj_asstring(suffixobj), "timestamp") == 0) {
strcasecmp(cfg_obj_asstring(suffixobj), "timestamp") == 0)
{
suffix = isc_log_rollsuffix_timestamp;
}
@ -322,15 +323,14 @@ done:
}
isc_result_t
named_logconfig(isc_logconfig_t *logconfig, const cfg_obj_t *logstmt)
{
isc_result_t result;
const cfg_obj_t * channels = NULL;
const cfg_obj_t * categories = NULL;
named_logconfig(isc_logconfig_t *logconfig, const cfg_obj_t *logstmt) {
isc_result_t result;
const cfg_obj_t *channels = NULL;
const cfg_obj_t *categories = NULL;
const cfg_listelt_t *element;
bool default_set = false;
bool unmatched_set = false;
const cfg_obj_t * catname;
bool default_set = false;
bool unmatched_set = false;
const cfg_obj_t *catname;
if (logconfig != NULL) {
CHECK(named_log_setdefaultchannels(logconfig));
@ -338,14 +338,16 @@ named_logconfig(isc_logconfig_t *logconfig, const cfg_obj_t *logstmt)
(void)cfg_map_get(logstmt, "channel", &channels);
for (element = cfg_list_first(channels); element != NULL;
element = cfg_list_next(element)) {
element = cfg_list_next(element))
{
const cfg_obj_t *channel = cfg_listelt_value(element);
CHECK(channel_fromconf(channel, logconfig));
}
(void)cfg_map_get(logstmt, "category", &categories);
for (element = cfg_list_first(categories); element != NULL;
element = cfg_list_next(element)) {
element = cfg_list_next(element))
{
const cfg_obj_t *category = cfg_listelt_value(element);
CHECK(category_fromconf(category, logconfig));
if (!default_set) {
@ -356,8 +358,8 @@ named_logconfig(isc_logconfig_t *logconfig, const cfg_obj_t *logstmt)
}
if (!unmatched_set) {
catname = cfg_tuple_get(category, "name");
if (strcmp(cfg_obj_asstring(catname), "unmatched") ==
0) {
if (strcmp(cfg_obj_asstring(catname), "unmatched") == 0)
{
unmatched_set = true;
}
}

149
bin/named/main.c
View file

@ -112,19 +112,19 @@
#define BACKTRACE_MAXFRAME 128
#endif /* ifndef BACKTRACE_MAXFRAME */
LIBISC_EXTERNAL_DATA extern int isc_dscp_check_value;
LIBISC_EXTERNAL_DATA extern int isc_dscp_check_value;
LIBDNS_EXTERNAL_DATA extern unsigned int dns_zone_mkey_hour;
LIBDNS_EXTERNAL_DATA extern unsigned int dns_zone_mkey_day;
LIBDNS_EXTERNAL_DATA extern unsigned int dns_zone_mkey_month;
static bool want_stats = false;
static char program_name[NAME_MAX] = "named";
static char absolute_conffile[PATH_MAX];
static char saved_command_line[4096] = { 0 };
static char ellipsis[5] = { 0 };
static char version[512];
static bool want_stats = false;
static char program_name[NAME_MAX] = "named";
static char absolute_conffile[PATH_MAX];
static char saved_command_line[4096] = { 0 };
static char ellipsis[5] = { 0 };
static char version[512];
static unsigned int maxsocks = 0;
static int maxudp = 0;
static int maxudp = 0;
/*
* -T options:
@ -148,8 +148,7 @@ static bool disable6 = false;
static bool disable4 = false;
void
named_main_earlywarning(const char *format, ...)
{
named_main_earlywarning(const char *format, ...) {
va_list args;
va_start(args, format);
@ -167,8 +166,7 @@ named_main_earlywarning(const char *format, ...)
}
void
named_main_earlyfatal(const char *format, ...)
{
named_main_earlyfatal(const char *format, ...) {
va_list args;
va_start(args, format);
@ -196,13 +194,12 @@ assertion_failed(const char *file, int line, isc_assertiontype_t type,
static void
assertion_failed(const char *file, int line, isc_assertiontype_t type,
const char *cond)
{
void * tracebuf[BACKTRACE_MAXFRAME];
int i, nframes;
const char *cond) {
void *tracebuf[BACKTRACE_MAXFRAME];
int i, nframes;
isc_result_t result;
const char * logsuffix = "";
const char * fname;
const char *logsuffix = "";
const char *fname;
/*
* Handle assertion failures.
@ -271,8 +268,7 @@ library_fatal_error(const char *file, int line, const char *format,
static void
library_fatal_error(const char *file, int line, const char *format,
va_list args)
{
va_list args) {
/*
* Handle isc_error_fatal() calls from our libraries.
*/
@ -306,14 +302,13 @@ library_fatal_error(const char *file, int line, const char *format,
exit(1);
}
static void
library_unexpected_error(const char *file, int line, const char *format,
va_list args) ISC_FORMAT_PRINTF(3, 0);
static void library_unexpected_error(const char *file, int line,
const char *format, va_list args)
ISC_FORMAT_PRINTF(3, 0);
static void
library_unexpected_error(const char *file, int line, const char *format,
va_list args)
{
va_list args) {
/*
* Handle isc_error_unexpected() calls from our libraries.
*/
@ -334,8 +329,7 @@ library_unexpected_error(const char *file, int line, const char *format,
}
static void
usage(void)
{
usage(void) {
fprintf(stderr, "usage: named [-4|-6] [-c conffile] [-d debuglevel] "
"[-E engine] [-f|-g]\n"
" [-n number_of_cpus] [-p port] [-s] "
@ -346,23 +340,23 @@ usage(void)
}
static void
save_command_line(int argc, char *argv[])
{
int i;
save_command_line(int argc, char *argv[]) {
int i;
char *dst = saved_command_line;
char *eob = saved_command_line + sizeof(saved_command_line) - 1;
char *rollback = dst;
for (i = 1; i < argc && dst < eob; i++) {
char *src = argv[i];
bool quoted = false;
bool quoted = false;
rollback = dst;
*dst++ = ' ';
while (*src != '\0' && dst < eob) {
if (isalnum(*src) || *src == ',' || *src == '-' ||
*src == '_' || *src == '.' || *src == '/') {
*src == '_' || *src == '.' || *src == '/')
{
*dst++ = *src++;
} else if (isprint(*src)) {
if (dst + 2 >= eob) {
@ -391,8 +385,8 @@ save_command_line(int argc, char *argv[])
continue;
} else {
char tmp[5];
int c = snprintf(tmp, sizeof(tmp),
"\\%03o", *src++);
int c = snprintf(tmp, sizeof(tmp),
"\\%03o", *src++);
if (dst + c >= eob) {
goto add_ellipsis;
}
@ -419,10 +413,9 @@ add_ellipsis:
}
static int
parse_int(char *arg, const char *desc)
{
char * endp;
int tmp;
parse_int(char *arg, const char *desc) {
char *endp;
int tmp;
long int ltmp;
ltmp = strtol(arg, &endp, 10);
@ -437,9 +430,9 @@ parse_int(char *arg, const char *desc)
}
static struct flag_def {
const char * name;
const char *name;
unsigned int value;
bool negate;
bool negate;
} mem_debug_flags[] = { { "none", 0, false },
{ "trace", ISC_MEM_DEBUGTRACE, false },
{ "record", ISC_MEM_DEBUGRECORD, false },
@ -453,14 +446,13 @@ static struct flag_def {
{ NULL, 0, false } };
static void
set_flags(const char *arg, struct flag_def *defs, unsigned int *ret)
{
set_flags(const char *arg, struct flag_def *defs, unsigned int *ret) {
bool clear = false;
for (;;) {
const struct flag_def *def;
const char * end = strchr(arg, ',');
int arglen;
const char *end = strchr(arg, ',');
int arglen;
if (end == NULL) {
end = arg + strlen(arg);
}
@ -493,13 +485,12 @@ set_flags(const char *arg, struct flag_def *defs, unsigned int *ret)
}
static void
printversion(bool verbose)
{
printversion(bool verbose) {
char rndcconf[PATH_MAX], *dot = NULL;
#if defined(HAVE_GEOIP2)
isc_mem_t * mctx = NULL;
cfg_parser_t * parser = NULL;
cfg_obj_t * config = NULL;
isc_mem_t *mctx = NULL;
cfg_parser_t *parser = NULL;
cfg_obj_t *config = NULL;
const cfg_obj_t *defaults = NULL, *obj = NULL;
#endif /* if defined(HAVE_GEOIP2) */
@ -604,8 +595,7 @@ printversion(bool verbose)
}
static void
parse_fuzz_arg(void)
{
parse_fuzz_arg(void) {
if (!strncmp(isc_commandline_argument, "client:", 7)) {
named_g_fuzz_addr = isc_commandline_argument + 7;
named_g_fuzz_type = isc_fuzz_client;
@ -628,10 +618,9 @@ parse_fuzz_arg(void)
}
static void
parse_T_opt(char *option)
{
parse_T_opt(char *option) {
const char *p;
char * last = NULL;
char *last = NULL;
/*
* force the server to behave (or misbehave) in
* specified ways for testing purposes.
@ -716,10 +705,9 @@ parse_T_opt(char *option)
}
static void
parse_command_line(int argc, char *argv[])
{
int ch;
int port;
parse_command_line(int argc, char *argv[]) {
int ch;
int port;
const char *p;
save_command_line(argc, argv);
@ -729,8 +717,8 @@ parse_command_line(int argc, char *argv[])
* both by named and by ntservice hooks.
*/
isc_commandline_errprint = false;
while ((ch = isc_commandline_parse(argc, argv, NAMED_MAIN_ARGS)) !=
-1) {
while ((ch = isc_commandline_parse(argc, argv, NAMED_MAIN_ARGS)) != -1)
{
switch (ch) {
case '4':
if (disable4) {
@ -891,8 +879,7 @@ parse_command_line(int argc, char *argv[])
}
static isc_result_t
create_managers(void)
{
create_managers(void) {
isc_result_t result;
unsigned int socks;
@ -971,8 +958,7 @@ create_managers(void)
}
static void
destroy_managers(void)
{
destroy_managers(void) {
/*
* isc_nm_closedown() closes all active connections, freeing
* attached clients and other resources and preventing new
@ -995,12 +981,11 @@ destroy_managers(void)
}
static void
dump_symboltable(void)
{
int i;
dump_symboltable(void) {
int i;
isc_result_t result;
const char * fname;
const void * addr;
const char *fname;
const void *addr;
if (isc__backtrace_nsymbols == 0) {
return;
@ -1026,11 +1011,10 @@ dump_symboltable(void)
}
static void
setup(void)
{
isc_result_t result;
setup(void) {
isc_result_t result;
isc_resourcevalue_t old_openfiles;
ns_server_t * sctx;
ns_server_t *sctx;
#ifdef HAVE_LIBSCF
char *instance = NULL;
#endif /* ifdef HAVE_LIBSCF */
@ -1360,8 +1344,7 @@ setup(void)
}
static void
cleanup(void)
{
cleanup(void) {
destroy_managers();
if (named_g_mapped != NULL) {
@ -1398,8 +1381,7 @@ cleanup(void)
static char *memstats = NULL;
void
named_main_setmemstats(const char *filename)
{
named_main_setmemstats(const char *filename) {
/*
* Caller has to ensure locking.
*/
@ -1421,11 +1403,10 @@ named_main_setmemstats(const char *filename)
* Get FMRI for the named process.
*/
isc_result_t
named_smf_get_instance(char **ins_name, int debug, isc_mem_t *mctx)
{
named_smf_get_instance(char **ins_name, int debug, isc_mem_t *mctx) {
scf_handle_t *h = NULL;
int namelen;
char * instance;
int namelen;
char *instance;
REQUIRE(ins_name != NULL && *ins_name == NULL);
@ -1487,8 +1468,7 @@ named_smf_get_instance(char **ins_name, int debug, isc_mem_t *mctx)
/* main entry point, possibly hooked */
int
main(int argc, char *argv[])
{
main(int argc, char *argv[]) {
isc_result_t result;
#ifdef HAVE_LIBSCF
char *instance = NULL;
@ -1571,7 +1551,8 @@ main(int argc, char *argv[])
int len = strlen(named_g_chrootdir);
if (strncmp(named_g_chrootdir, named_g_conffile, len) == 0 &&
(named_g_conffile[len] == '/' ||
named_g_conffile[len] == '\\')) {
named_g_conffile[len] == '\\'))
{
named_main_earlywarning("config filename (-c %s) "
"contains chroot path (-t %s)",
named_g_conffile,

2843
bin/named/server.c
View file

File diff suppressed because it is too large Load diff

472
bin/named/statschannel.c
View file

@ -58,15 +58,15 @@
struct named_statschannel {
/* Unlocked */
isc_httpdmgr_t *httpdmgr;
isc_sockaddr_t address;
isc_mem_t * mctx;
isc_sockaddr_t address;
isc_mem_t *mctx;
/*
* Locked by channel lock: can be referenced and modified by both
* the server task and the channel task.
*/
isc_mutex_t lock;
dns_acl_t * acl;
dns_acl_t *acl;
/* Locked by server task */
ISC_LINK(struct named_statschannel) link;
@ -74,11 +74,11 @@ struct named_statschannel {
typedef struct stats_dumparg {
isc_statsformat_t type;
void * arg; /* type dependent argument */
int ncounters; /* for general statistics */
int * counterindices; /* for general statistics */
uint64_t * countervalues; /* for general statistics */
isc_result_t result;
void *arg; /* type dependent argument */
int ncounters; /* for general statistics */
int *counterindices; /* for general statistics */
uint64_t *countervalues; /* for general statistics */
isc_result_t result;
} stats_dumparg_t;
static isc_once_t once = ISC_ONCE_INIT;
@ -91,13 +91,12 @@ static isc_once_t once = ISC_ONCE_INIT;
#ifdef EXTENDED_STATS
static const char *
user_zonetype(dns_zone_t *zone)
{
user_zonetype(dns_zone_t *zone) {
dns_zonetype_t ztype;
dns_view_t * view;
dns_view_t *view;
static const struct zt {
const dns_zonetype_t type;
const char *const string;
const char *const string;
} typemap[] = { { dns_zone_none, "none" },
{ dns_zone_master, "master" },
{ dns_zone_slave, "slave" },
@ -158,18 +157,18 @@ static const char *tcpoutsizestats_xmldesc[dns_sizecounter_out_max];
static const char *dnstapstats_xmldesc[dns_dnstapcounter_max];
static const char *gluecachestats_xmldesc[dns_gluecachestatscounter_max];
#else /* if defined(EXTENDED_STATS) */
#define nsstats_xmldesc NULL
#define resstats_xmldesc NULL
#define adbstats_xmldesc NULL
#define zonestats_xmldesc NULL
#define sockstats_xmldesc NULL
#define dnssecstats_xmldesc NULL
#define udpinsizestats_xmldesc NULL
#define nsstats_xmldesc NULL
#define resstats_xmldesc NULL
#define adbstats_xmldesc NULL
#define zonestats_xmldesc NULL
#define sockstats_xmldesc NULL
#define dnssecstats_xmldesc NULL
#define udpinsizestats_xmldesc NULL
#define udpoutsizestats_xmldesc NULL
#define tcpinsizestats_xmldesc NULL
#define tcpinsizestats_xmldesc NULL
#define tcpoutsizestats_xmldesc NULL
#define dnstapstats_xmldesc NULL
#define gluecachestats_xmldesc NULL
#define dnstapstats_xmldesc NULL
#define gluecachestats_xmldesc NULL
#endif /* EXTENDED_STATS */
#define TRY0(a) \
@ -199,8 +198,7 @@ static int gluecachestats_index[dns_gluecachestatscounter_max];
static inline void
set_desc(int counter, int maxcounter, const char *fdesc, const char **fdescs,
const char *xdesc, const char **xdescs)
{
const char *xdesc, const char **xdescs) {
REQUIRE(counter < maxcounter);
REQUIRE(fdescs != NULL && fdescs[counter] == NULL);
#if defined(EXTENDED_STATS)
@ -217,8 +215,7 @@ set_desc(int counter, int maxcounter, const char *fdesc, const char **fdescs,
}
static void
init_desc(void)
{
init_desc(void) {
int i;
/* Initialize name server statistics */
@ -1313,8 +1310,7 @@ init_desc(void)
* Dump callback functions.
*/
static void
generalstat_dump(isc_statscounter_t counter, uint64_t val, void *arg)
{
generalstat_dump(isc_statscounter_t counter, uint64_t val, void *arg) {
stats_dumparg_t *dumparg = arg;
REQUIRE(counter < dumparg->ncounters);
@ -1324,15 +1320,14 @@ generalstat_dump(isc_statscounter_t counter, uint64_t val, void *arg)
static isc_result_t
dump_counters(isc_stats_t *stats, isc_statsformat_t type, void *arg,
const char *category, const char **desc, int ncounters,
int *indices, uint64_t *values, int options)
{
int i, idx;
uint64_t value;
int *indices, uint64_t *values, int options) {
int i, idx;
uint64_t value;
stats_dumparg_t dumparg;
FILE * fp;
FILE *fp;
#ifdef HAVE_LIBXML2
void *writer;
int xmlrc;
int xmlrc;
#endif /* ifdef HAVE_LIBXML2 */
#ifdef HAVE_JSON_C
json_object *job, *cat, *counter;
@ -1439,15 +1434,14 @@ error:
}
static void
rdtypestat_dump(dns_rdatastatstype_t type, uint64_t val, void *arg)
{
char typebuf[64];
const char * typestr;
rdtypestat_dump(dns_rdatastatstype_t type, uint64_t val, void *arg) {
char typebuf[64];
const char *typestr;
stats_dumparg_t *dumparg = arg;
FILE * fp;
FILE *fp;
#ifdef HAVE_LIBXML2
void *writer;
int xmlrc;
int xmlrc;
#endif /* ifdef HAVE_LIBXML2 */
#ifdef HAVE_JSON_C
json_object *zoneobj, *obj;
@ -1503,35 +1497,34 @@ error:
}
static bool
rdatastatstype_attr(dns_rdatastatstype_t type, unsigned int attr)
{
rdatastatstype_attr(dns_rdatastatstype_t type, unsigned int attr) {
return ((DNS_RDATASTATSTYPE_ATTR(type) & attr) != 0);
}
static void
rdatasetstats_dump(dns_rdatastatstype_t type, uint64_t val, void *arg)
{
rdatasetstats_dump(dns_rdatastatstype_t type, uint64_t val, void *arg) {
stats_dumparg_t *dumparg = arg;
FILE * fp;
char typebuf[64];
const char * typestr;
bool nxrrset = false;
bool stale = false;
bool ancient = false;
FILE *fp;
char typebuf[64];
const char *typestr;
bool nxrrset = false;
bool stale = false;
bool ancient = false;
#ifdef HAVE_LIBXML2
void *writer;
int xmlrc;
int xmlrc;
#endif /* ifdef HAVE_LIBXML2 */
#ifdef HAVE_JSON_C
json_object *zoneobj, *obj;
char buf[1024];
char buf[1024];
#endif /* ifdef HAVE_JSON_C */
if ((DNS_RDATASTATSTYPE_ATTR(type) &
DNS_RDATASTATSTYPE_ATTR_NXDOMAIN) != 0) {
typestr = "NXDOMAIN";
} else if ((DNS_RDATASTATSTYPE_ATTR(type) &
DNS_RDATASTATSTYPE_ATTR_OTHERTYPE) != 0) {
DNS_RDATASTATSTYPE_ATTR_OTHERTYPE) != 0)
{
typestr = "Others";
} else {
dns_rdatatype_format(DNS_RDATASTATSTYPE_BASE(type), typebuf,
@ -1591,15 +1584,14 @@ error:
}
static void
opcodestat_dump(dns_opcode_t code, uint64_t val, void *arg)
{
FILE * fp;
isc_buffer_t b;
char codebuf[64];
opcodestat_dump(dns_opcode_t code, uint64_t val, void *arg) {
FILE *fp;
isc_buffer_t b;
char codebuf[64];
stats_dumparg_t *dumparg = arg;
#ifdef HAVE_LIBXML2
void *writer;
int xmlrc;
int xmlrc;
#endif /* ifdef HAVE_LIBXML2 */
#ifdef HAVE_JSON_C
json_object *zoneobj, *obj;
@ -1648,15 +1640,14 @@ error:
}
static void
rcodestat_dump(dns_rcode_t code, uint64_t val, void *arg)
{
FILE * fp;
isc_buffer_t b;
char codebuf[64];
rcodestat_dump(dns_rcode_t code, uint64_t val, void *arg) {
FILE *fp;
isc_buffer_t b;
char codebuf[64];
stats_dumparg_t *dumparg = arg;
#ifdef HAVE_LIBXML2
void *writer;
int xmlrc;
int xmlrc;
#endif /* ifdef HAVE_LIBXML2 */
#ifdef HAVE_JSON_C
json_object *zoneobj, *obj;
@ -1706,14 +1697,13 @@ error:
#if defined(EXTENDED_STATS)
static void
dnssecsignstat_dump(dns_keytag_t tag, uint64_t val, void *arg)
{
FILE * fp;
char tagbuf[64];
dnssecsignstat_dump(dns_keytag_t tag, uint64_t val, void *arg) {
FILE *fp;
char tagbuf[64];
stats_dumparg_t *dumparg = arg;
#ifdef HAVE_LIBXML2
xmlTextWriterPtr writer;
int xmlrc;
int xmlrc;
#endif /* ifdef HAVE_LIBXML2 */
#ifdef HAVE_JSON_C
json_object *zoneobj, *obj;
@ -1763,27 +1753,26 @@ error:
/*
* Which statistics to include when rendering to XML
*/
#define STATS_XML_STATUS 0x00 /* display only common statistics */
#define STATS_XML_SERVER 0x01
#define STATS_XML_ZONES 0x02
#define STATS_XML_TASKS 0x04
#define STATS_XML_NET 0x08
#define STATS_XML_MEM 0x10
#define STATS_XML_STATUS 0x00 /* display only common statistics */
#define STATS_XML_SERVER 0x01
#define STATS_XML_ZONES 0x02
#define STATS_XML_TASKS 0x04
#define STATS_XML_NET 0x08
#define STATS_XML_MEM 0x10
#define STATS_XML_TRAFFIC 0x20
#define STATS_XML_ALL 0xff
#define STATS_XML_ALL 0xff
static isc_result_t
zone_xmlrender(dns_zone_t *zone, void *arg)
{
zone_xmlrender(dns_zone_t *zone, void *arg) {
isc_result_t result;
char buf[1024 + 32]; /* sufficiently large for zone name and class */
dns_rdataclass_t rdclass;
uint32_t serial;
xmlTextWriterPtr writer = arg;
dns_rdataclass_t rdclass;
uint32_t serial;
xmlTextWriterPtr writer = arg;
dns_zonestat_level_t statlevel;
int xmlrc;
stats_dumparg_t dumparg;
const char * ztype;
int xmlrc;
stats_dumparg_t dumparg;
const char *ztype;
statlevel = dns_zone_getstatlevel(zone);
if (statlevel == dns_zonestat_none) {
@ -1827,7 +1816,7 @@ zone_xmlrender(dns_zone_t *zone, void *arg)
dns_stats_t *rcvquerystats;
dns_stats_t *dnssecsignstats;
dns_stats_t *dnssecrefreshstats;
uint64_t nsstat_values[ns_statscounter_max];
uint64_t nsstat_values[ns_statscounter_max];
uint64_t gluecachestats_values[dns_gluecachestatscounter_max];
zonestats = dns_zone_getrequeststats(zone);
@ -1946,27 +1935,27 @@ error:
}
static isc_result_t
generatexml(named_server_t *server, uint32_t flags, int *buflen, xmlChar **buf)
{
char boottime[sizeof "yyyy-mm-ddThh:mm:ss.sssZ"];
char configtime[sizeof "yyyy-mm-ddThh:mm:ss.sssZ"];
char nowstr[sizeof "yyyy-mm-ddThh:mm:ss.sssZ"];
isc_time_t now;
generatexml(named_server_t *server, uint32_t flags, int *buflen,
xmlChar **buf) {
char boottime[sizeof "yyyy-mm-ddThh:mm:ss.sssZ"];
char configtime[sizeof "yyyy-mm-ddThh:mm:ss.sssZ"];
char nowstr[sizeof "yyyy-mm-ddThh:mm:ss.sssZ"];
isc_time_t now;
xmlTextWriterPtr writer = NULL;
xmlDocPtr doc = NULL;
int xmlrc;
dns_view_t * view;
stats_dumparg_t dumparg;
dns_stats_t * cacherrstats;
uint64_t nsstat_values[ns_statscounter_max];
uint64_t resstat_values[dns_resstatscounter_max];
uint64_t adbstat_values[dns_adbstats_max];
uint64_t zonestat_values[dns_zonestatscounter_max];
uint64_t sockstat_values[isc_sockstatscounter_max];
uint64_t udpinsizestat_values[dns_sizecounter_in_max];
uint64_t udpoutsizestat_values[dns_sizecounter_out_max];
uint64_t tcpinsizestat_values[dns_sizecounter_in_max];
uint64_t tcpoutsizestat_values[dns_sizecounter_out_max];
xmlDocPtr doc = NULL;
int xmlrc;
dns_view_t *view;
stats_dumparg_t dumparg;
dns_stats_t *cacherrstats;
uint64_t nsstat_values[ns_statscounter_max];
uint64_t resstat_values[dns_resstatscounter_max];
uint64_t adbstat_values[dns_adbstats_max];
uint64_t zonestat_values[dns_zonestatscounter_max];
uint64_t sockstat_values[isc_sockstatscounter_max];
uint64_t udpinsizestat_values[dns_sizecounter_in_max];
uint64_t udpoutsizestat_values[dns_sizecounter_out_max];
uint64_t tcpinsizestat_values[dns_sizecounter_in_max];
uint64_t tcpoutsizestat_values[dns_sizecounter_out_max];
#ifdef HAVE_DNSTAP
uint64_t dnstapstat_values[dns_dnstapcounter_max];
#endif /* ifdef HAVE_DNSTAP */
@ -2411,8 +2400,7 @@ error:
}
static void
wrap_xmlfree(isc_buffer_t *buffer, void *arg)
{
wrap_xmlfree(isc_buffer_t *buffer, void *arg) {
UNUSED(arg);
xmlFree(isc_buffer_base(buffer));
@ -2422,12 +2410,11 @@ static isc_result_t
render_xml(uint32_t flags, const char *url, isc_httpdurl_t *urlinfo,
const char *querystring, const char *headers, void *arg,
unsigned int *retcode, const char **retmsg, const char **mimetype,
isc_buffer_t *b, isc_httpdfree_t **freecb, void **freecb_args)
{
unsigned char * msg = NULL;
int msglen;
isc_buffer_t *b, isc_httpdfree_t **freecb, void **freecb_args) {
unsigned char *msg = NULL;
int msglen;
named_server_t *server = arg;
isc_result_t result;
isc_result_t result;
UNUSED(url);
UNUSED(urlinfo);
@ -2458,8 +2445,7 @@ render_xml_all(const char *url, isc_httpdurl_t *urlinfo,
const char *querystring, const char *headers, void *arg,
unsigned int *retcode, const char **retmsg,
const char **mimetype, isc_buffer_t *b, isc_httpdfree_t **freecb,
void **freecb_args)
{
void **freecb_args) {
return (render_xml(STATS_XML_ALL, url, urlinfo, querystring, headers,
arg, retcode, retmsg, mimetype, b, freecb,
freecb_args));
@ -2470,8 +2456,7 @@ render_xml_status(const char *url, isc_httpdurl_t *urlinfo,
const char *querystring, const char *headers, void *arg,
unsigned int *retcode, const char **retmsg,
const char **mimetype, isc_buffer_t *b,
isc_httpdfree_t **freecb, void **freecb_args)
{
isc_httpdfree_t **freecb, void **freecb_args) {
return (render_xml(STATS_XML_STATUS, url, urlinfo, querystring, headers,
arg, retcode, retmsg, mimetype, b, freecb,
freecb_args));
@ -2482,8 +2467,7 @@ render_xml_server(const char *url, isc_httpdurl_t *urlinfo,
const char *querystring, const char *headers, void *arg,
unsigned int *retcode, const char **retmsg,
const char **mimetype, isc_buffer_t *b,
isc_httpdfree_t **freecb, void **freecb_args)
{
isc_httpdfree_t **freecb, void **freecb_args) {
return (render_xml(STATS_XML_SERVER, url, urlinfo, querystring, headers,
arg, retcode, retmsg, mimetype, b, freecb,
freecb_args));
@ -2494,8 +2478,7 @@ render_xml_zones(const char *url, isc_httpdurl_t *urlinfo,
const char *querystring, const char *headers, void *arg,
unsigned int *retcode, const char **retmsg,
const char **mimetype, isc_buffer_t *b,
isc_httpdfree_t **freecb, void **freecb_args)
{
isc_httpdfree_t **freecb, void **freecb_args) {
return (render_xml(STATS_XML_ZONES, url, urlinfo, querystring, headers,
arg, retcode, retmsg, mimetype, b, freecb,
freecb_args));
@ -2506,8 +2489,7 @@ render_xml_net(const char *url, isc_httpdurl_t *urlinfo,
const char *querystring, const char *headers, void *arg,
unsigned int *retcode, const char **retmsg,
const char **mimetype, isc_buffer_t *b, isc_httpdfree_t **freecb,
void **freecb_args)
{
void **freecb_args) {
return (render_xml(STATS_XML_NET, url, urlinfo, querystring, headers,
arg, retcode, retmsg, mimetype, b, freecb,
freecb_args));
@ -2518,8 +2500,7 @@ render_xml_tasks(const char *url, isc_httpdurl_t *urlinfo,
const char *querystring, const char *headers, void *arg,
unsigned int *retcode, const char **retmsg,
const char **mimetype, isc_buffer_t *b,
isc_httpdfree_t **freecb, void **freecb_args)
{
isc_httpdfree_t **freecb, void **freecb_args) {
return (render_xml(STATS_XML_TASKS, url, urlinfo, querystring, headers,
arg, retcode, retmsg, mimetype, b, freecb,
freecb_args));
@ -2530,8 +2511,7 @@ render_xml_mem(const char *url, isc_httpdurl_t *urlinfo,
const char *querystring, const char *headers, void *arg,
unsigned int *retcode, const char **retmsg,
const char **mimetype, isc_buffer_t *b, isc_httpdfree_t **freecb,
void **freecb_args)
{
void **freecb_args) {
return (render_xml(STATS_XML_MEM, url, urlinfo, querystring, headers,
arg, retcode, retmsg, mimetype, b, freecb,
freecb_args));
@ -2542,8 +2522,7 @@ render_xml_traffic(const char *url, isc_httpdurl_t *urlinfo,
const char *querystring, const char *headers, void *arg,
unsigned int *retcode, const char **retmsg,
const char **mimetype, isc_buffer_t *b,
isc_httpdfree_t **freecb, void **freecb_args)
{
isc_httpdfree_t **freecb, void **freecb_args) {
return (render_xml(STATS_XML_TRAFFIC, url, urlinfo, querystring,
headers, arg, retcode, retmsg, mimetype, b, freecb,
freecb_args));
@ -2555,14 +2534,14 @@ render_xml_traffic(const char *url, isc_httpdurl_t *urlinfo,
/*
* Which statistics to include when rendering to JSON
*/
#define STATS_JSON_STATUS 0x00 /* display only common statistics */
#define STATS_JSON_SERVER 0x01
#define STATS_JSON_ZONES 0x02
#define STATS_JSON_TASKS 0x04
#define STATS_JSON_NET 0x08
#define STATS_JSON_MEM 0x10
#define STATS_JSON_STATUS 0x00 /* display only common statistics */
#define STATS_JSON_SERVER 0x01
#define STATS_JSON_ZONES 0x02
#define STATS_JSON_TASKS 0x04
#define STATS_JSON_NET 0x08
#define STATS_JSON_MEM 0x10
#define STATS_JSON_TRAFFIC 0x20
#define STATS_JSON_ALL 0xff
#define STATS_JSON_ALL 0xff
#define CHECK(m) \
do { \
@ -2580,8 +2559,7 @@ render_xml_traffic(const char *url, isc_httpdurl_t *urlinfo,
} while (0)
static void
wrap_jsonfree(isc_buffer_t *buffer, void *arg)
{
wrap_jsonfree(isc_buffer_t *buffer, void *arg) {
json_object_put(isc_buffer_base(buffer));
if (arg != NULL) {
json_object_put((json_object *)arg);
@ -2590,8 +2568,7 @@ wrap_jsonfree(isc_buffer_t *buffer, void *arg)
static json_object *
addzone(char *name, char *classname, const char *ztype, uint32_t serial,
bool add_serial)
{
bool add_serial) {
json_object *node = json_object_new_object();
if (node == NULL) {
@ -2613,17 +2590,16 @@ addzone(char *name, char *classname, const char *ztype, uint32_t serial,
}
static isc_result_t
zone_jsonrender(dns_zone_t *zone, void *arg)
{
zone_jsonrender(dns_zone_t *zone, void *arg) {
isc_result_t result = ISC_R_SUCCESS;
char buf[1024 + 32]; /* sufficiently large for zone name and class */
char classbuf[64]; /* sufficiently large for class */
char buf[1024 + 32]; /* sufficiently large for zone name and class */
char classbuf[64]; /* sufficiently large for class */
char *zone_name_only = NULL;
char *class_only = NULL;
dns_rdataclass_t rdclass;
uint32_t serial;
json_object * zonearray = (json_object *)arg;
json_object * zoneobj = NULL;
dns_rdataclass_t rdclass;
uint32_t serial;
json_object *zonearray = (json_object *)arg;
json_object *zoneobj = NULL;
dns_zonestat_level_t statlevel;
statlevel = dns_zone_getstatlevel(zone);
@ -2656,7 +2632,7 @@ zone_jsonrender(dns_zone_t *zone, void *arg)
dns_stats_t *rcvquerystats;
dns_stats_t *dnssecsignstats;
dns_stats_t *dnssecrefreshstats;
uint64_t nsstat_values[ns_statscounter_max];
uint64_t nsstat_values[ns_statscounter_max];
uint64_t gluecachestats_values[dns_gluecachestatscounter_max];
zonestats = dns_zone_getrequeststats(zone);
@ -2713,7 +2689,7 @@ zone_jsonrender(dns_zone_t *zone, void *arg)
rcvquerystats = dns_zone_getrcvquerystats(zone);
if (rcvquerystats != NULL) {
stats_dumparg_t dumparg;
json_object * counters = json_object_new_object();
json_object *counters = json_object_new_object();
CHECKMEM(counters);
dumparg.type = isc_statsformat_json;
@ -2737,7 +2713,7 @@ zone_jsonrender(dns_zone_t *zone, void *arg)
dnssecsignstats = dns_zone_getdnssecsignstats(zone);
if (dnssecsignstats != NULL) {
stats_dumparg_t dumparg;
json_object * counters = json_object_new_object();
json_object *counters = json_object_new_object();
CHECKMEM(counters);
dumparg.type = isc_statsformat_json;
@ -2762,7 +2738,7 @@ zone_jsonrender(dns_zone_t *zone, void *arg)
dnssecrefreshstats = dns_zone_getdnssecrefreshstats(zone);
if (dnssecrefreshstats != NULL) {
stats_dumparg_t dumparg;
json_object * counters = json_object_new_object();
json_object *counters = json_object_new_object();
CHECKMEM(counters);
dumparg.type = isc_statsformat_json;
@ -2798,9 +2774,8 @@ error:
static isc_result_t
generatejson(named_server_t *server, size_t *msglen, const char **msg,
json_object **rootp, uint32_t flags)
{
dns_view_t * view;
json_object **rootp, uint32_t flags) {
dns_view_t *view;
isc_result_t result = ISC_R_SUCCESS;
json_object *bindstats, *viewlist, *counters, *obj;
json_object *traffic = NULL;
@ -2808,23 +2783,23 @@ generatejson(named_server_t *server, size_t *msglen, const char **msg,
json_object *tcpreq4 = NULL, *tcpresp4 = NULL;
json_object *udpreq6 = NULL, *udpresp6 = NULL;
json_object *tcpreq6 = NULL, *tcpresp6 = NULL;
uint64_t nsstat_values[ns_statscounter_max];
uint64_t resstat_values[dns_resstatscounter_max];
uint64_t adbstat_values[dns_adbstats_max];
uint64_t zonestat_values[dns_zonestatscounter_max];
uint64_t sockstat_values[isc_sockstatscounter_max];
uint64_t udpinsizestat_values[dns_sizecounter_in_max];
uint64_t udpoutsizestat_values[dns_sizecounter_out_max];
uint64_t tcpinsizestat_values[dns_sizecounter_in_max];
uint64_t tcpoutsizestat_values[dns_sizecounter_out_max];
uint64_t nsstat_values[ns_statscounter_max];
uint64_t resstat_values[dns_resstatscounter_max];
uint64_t adbstat_values[dns_adbstats_max];
uint64_t zonestat_values[dns_zonestatscounter_max];
uint64_t sockstat_values[isc_sockstatscounter_max];
uint64_t udpinsizestat_values[dns_sizecounter_in_max];
uint64_t udpoutsizestat_values[dns_sizecounter_out_max];
uint64_t tcpinsizestat_values[dns_sizecounter_in_max];
uint64_t tcpoutsizestat_values[dns_sizecounter_out_max];
#ifdef HAVE_DNSTAP
uint64_t dnstapstat_values[dns_dnstapcounter_max];
#endif /* ifdef HAVE_DNSTAP */
stats_dumparg_t dumparg;
char boottime[sizeof "yyyy-mm-ddThh:mm:ss.sssZ"];
char configtime[sizeof "yyyy-mm-ddThh:mm:ss.sssZ"];
char nowstr[sizeof "yyyy-mm-ddThh:mm:ss.sssZ"];
isc_time_t now;
char boottime[sizeof "yyyy-mm-ddThh:mm:ss.sssZ"];
char configtime[sizeof "yyyy-mm-ddThh:mm:ss.sssZ"];
char nowstr[sizeof "yyyy-mm-ddThh:mm:ss.sssZ"];
isc_time_t now;
REQUIRE(msglen != NULL);
REQUIRE(msg != NULL && *msg == NULL);
@ -3377,14 +3352,13 @@ static isc_result_t
render_json(uint32_t flags, const char *url, isc_httpdurl_t *urlinfo,
const char *querystring, const char *headers, void *arg,
unsigned int *retcode, const char **retmsg, const char **mimetype,
isc_buffer_t *b, isc_httpdfree_t **freecb, void **freecb_args)
{
isc_result_t result;
json_object * bindstats = NULL;
isc_buffer_t *b, isc_httpdfree_t **freecb, void **freecb_args) {
isc_result_t result;
json_object *bindstats = NULL;
named_server_t *server = arg;
const char * msg = NULL;
size_t msglen = 0;
char * p;
const char *msg = NULL;
size_t msglen = 0;
char *p;
UNUSED(url);
UNUSED(urlinfo);
@ -3415,8 +3389,7 @@ render_json_all(const char *url, isc_httpdurl_t *urlinfo,
const char *querystring, const char *headers, void *arg,
unsigned int *retcode, const char **retmsg,
const char **mimetype, isc_buffer_t *b,
isc_httpdfree_t **freecb, void **freecb_args)
{
isc_httpdfree_t **freecb, void **freecb_args) {
return (render_json(STATS_JSON_ALL, url, urlinfo, querystring, headers,
arg, retcode, retmsg, mimetype, b, freecb,
freecb_args));
@ -3427,8 +3400,7 @@ render_json_status(const char *url, isc_httpdurl_t *urlinfo,
const char *querystring, const char *headers, void *arg,
unsigned int *retcode, const char **retmsg,
const char **mimetype, isc_buffer_t *b,
isc_httpdfree_t **freecb, void **freecb_args)
{
isc_httpdfree_t **freecb, void **freecb_args) {
return (render_json(STATS_JSON_STATUS, url, urlinfo, querystring,
headers, arg, retcode, retmsg, mimetype, b, freecb,
freecb_args));
@ -3439,8 +3411,7 @@ render_json_server(const char *url, isc_httpdurl_t *urlinfo,
const char *querystring, const char *headers, void *arg,
unsigned int *retcode, const char **retmsg,
const char **mimetype, isc_buffer_t *b,
isc_httpdfree_t **freecb, void **freecb_args)
{
isc_httpdfree_t **freecb, void **freecb_args) {
return (render_json(STATS_JSON_SERVER, url, urlinfo, querystring,
headers, arg, retcode, retmsg, mimetype, b, freecb,
freecb_args));
@ -3451,8 +3422,7 @@ render_json_zones(const char *url, isc_httpdurl_t *urlinfo,
const char *querystring, const char *headers, void *arg,
unsigned int *retcode, const char **retmsg,
const char **mimetype, isc_buffer_t *b,
isc_httpdfree_t **freecb, void **freecb_args)
{
isc_httpdfree_t **freecb, void **freecb_args) {
return (render_json(STATS_JSON_ZONES, url, urlinfo, querystring,
headers, arg, retcode, retmsg, mimetype, b, freecb,
freecb_args));
@ -3463,8 +3433,7 @@ render_json_mem(const char *url, isc_httpdurl_t *urlinfo,
const char *querystring, const char *headers, void *arg,
unsigned int *retcode, const char **retmsg,
const char **mimetype, isc_buffer_t *b,
isc_httpdfree_t **freecb, void **freecb_args)
{
isc_httpdfree_t **freecb, void **freecb_args) {
return (render_json(STATS_JSON_MEM, url, urlinfo, querystring, headers,
arg, retcode, retmsg, mimetype, b, freecb,
freecb_args));
@ -3475,8 +3444,7 @@ render_json_tasks(const char *url, isc_httpdurl_t *urlinfo,
const char *querystring, const char *headers, void *arg,
unsigned int *retcode, const char **retmsg,
const char **mimetype, isc_buffer_t *b,
isc_httpdfree_t **freecb, void **freecb_args)
{
isc_httpdfree_t **freecb, void **freecb_args) {
return (render_json(STATS_JSON_TASKS, url, urlinfo, querystring,
headers, arg, retcode, retmsg, mimetype, b, freecb,
freecb_args));
@ -3487,8 +3455,7 @@ render_json_net(const char *url, isc_httpdurl_t *urlinfo,
const char *querystring, const char *headers, void *arg,
unsigned int *retcode, const char **retmsg,
const char **mimetype, isc_buffer_t *b,
isc_httpdfree_t **freecb, void **freecb_args)
{
isc_httpdfree_t **freecb, void **freecb_args) {
return (render_json(STATS_JSON_NET, url, urlinfo, querystring, headers,
arg, retcode, retmsg, mimetype, b, freecb,
freecb_args));
@ -3499,8 +3466,7 @@ render_json_traffic(const char *url, isc_httpdurl_t *urlinfo,
const char *querystring, const char *headers, void *arg,
unsigned int *retcode, const char **retmsg,
const char **mimetype, isc_buffer_t *b,
isc_httpdfree_t **freecb, void **freecb_args)
{
isc_httpdfree_t **freecb, void **freecb_args) {
return (render_json(STATS_JSON_TRAFFIC, url, urlinfo, querystring,
headers, arg, retcode, retmsg, mimetype, b, freecb,
freecb_args));
@ -3512,10 +3478,9 @@ static isc_result_t
render_xsl(const char *url, isc_httpdurl_t *urlinfo, const char *querystring,
const char *headers, void *args, unsigned int *retcode,
const char **retmsg, const char **mimetype, isc_buffer_t *b,
isc_httpdfree_t **freecb, void **freecb_args)
{
isc_httpdfree_t **freecb, void **freecb_args) {
isc_result_t result;
char * _headers = NULL;
char *_headers = NULL;
UNUSED(url);
UNUSED(querystring);
@ -3526,8 +3491,8 @@ render_xsl(const char *url, isc_httpdurl_t *urlinfo, const char *querystring,
*mimetype = "text/xslt+xml";
if (urlinfo->isstatic) {
isc_time_t when;
char * line, *saveptr;
isc_time_t when;
char *line, *saveptr;
const char *if_modified_since = "If-Modified-Since: ";
_headers = strdup(headers);
@ -3537,7 +3502,8 @@ render_xsl(const char *url, isc_httpdurl_t *urlinfo, const char *querystring,
saveptr = NULL;
for (line = strtok_r(_headers, "\n", &saveptr); line;
line = strtok_r(NULL, "\n", &saveptr)) {
line = strtok_r(NULL, "\n", &saveptr))
{
if (strncasecmp(line, if_modified_since,
strlen(if_modified_since)) == 0) {
time_t t1, t2;
@ -3581,8 +3547,7 @@ end:
}
static void
shutdown_listener(named_statschannel_t *listener)
{
shutdown_listener(named_statschannel_t *listener) {
char socktext[ISC_SOCKADDR_FORMATSIZE];
isc_sockaddr_format(&listener->address, socktext, sizeof(socktext));
isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
@ -3593,14 +3558,13 @@ shutdown_listener(named_statschannel_t *listener)
}
static bool
client_ok(const isc_sockaddr_t *fromaddr, void *arg)
{
client_ok(const isc_sockaddr_t *fromaddr, void *arg) {
named_statschannel_t *listener = arg;
dns_aclenv_t * env =
dns_aclenv_t *env =
ns_interfacemgr_getaclenv(named_g_server->interfacemgr);
isc_netaddr_t netaddr;
char socktext[ISC_SOCKADDR_FORMATSIZE];
int match;
char socktext[ISC_SOCKADDR_FORMATSIZE];
int match;
REQUIRE(listener != NULL);
@ -3609,7 +3573,8 @@ client_ok(const isc_sockaddr_t *fromaddr, void *arg)
LOCK(&listener->lock);
if ((dns_acl_match(&netaddr, NULL, listener->acl, env, &match, NULL) ==
ISC_R_SUCCESS) &&
match > 0) {
match > 0)
{
UNLOCK(&listener->lock);
return (true);
}
@ -3624,8 +3589,7 @@ client_ok(const isc_sockaddr_t *fromaddr, void *arg)
}
static void
destroy_listener(void *arg)
{
destroy_listener(void *arg) {
named_statschannel_t *listener = arg;
REQUIRE(listener != NULL);
@ -3642,14 +3606,13 @@ static isc_result_t
add_listener(named_server_t *server, named_statschannel_t **listenerp,
const cfg_obj_t *listen_params, const cfg_obj_t *config,
isc_sockaddr_t *addr, cfg_aclconfctx_t *aclconfctx,
const char *socktext)
{
isc_result_t result;
const char *socktext) {
isc_result_t result;
named_statschannel_t *listener;
isc_task_t * task = NULL;
isc_socket_t * sock = NULL;
const cfg_obj_t * allow;
dns_acl_t * new_acl = NULL;
isc_task_t *task = NULL;
isc_socket_t *sock = NULL;
const cfg_obj_t *allow;
dns_acl_t *new_acl = NULL;
listener = isc_mem_get(server->mctx, sizeof(*listener));
@ -3777,15 +3740,15 @@ static void
update_listener(named_server_t *server, named_statschannel_t **listenerp,
const cfg_obj_t *listen_params, const cfg_obj_t *config,
isc_sockaddr_t *addr, cfg_aclconfctx_t *aclconfctx,
const char *socktext)
{
const char *socktext) {
named_statschannel_t *listener;
const cfg_obj_t * allow = NULL;
dns_acl_t * new_acl = NULL;
isc_result_t result = ISC_R_SUCCESS;
const cfg_obj_t *allow = NULL;
dns_acl_t *new_acl = NULL;
isc_result_t result = ISC_R_SUCCESS;
for (listener = ISC_LIST_HEAD(server->statschannels); listener != NULL;
listener = ISC_LIST_NEXT(listener, link)) {
listener = ISC_LIST_NEXT(listener, link))
{
if (isc_sockaddr_equal(addr, &listener->address)) {
break;
}
@ -3828,13 +3791,12 @@ update_listener(named_server_t *server, named_statschannel_t **listenerp,
isc_result_t
named_statschannels_configure(named_server_t *server, const cfg_obj_t *config,
cfg_aclconfctx_t *aclconfctx)
{
named_statschannel_t * listener, *listener_next;
cfg_aclconfctx_t *aclconfctx) {
named_statschannel_t *listener, *listener_next;
named_statschannellist_t new_listeners;
const cfg_obj_t * statschannellist = NULL;
const cfg_listelt_t * element, *element2;
char socktext[ISC_SOCKADDR_FORMATSIZE];
const cfg_obj_t *statschannellist = NULL;
const cfg_listelt_t *element, *element2;
char socktext[ISC_SOCKADDR_FORMATSIZE];
RUNTIME_CHECK(isc_once_do(&once, init_desc) == ISC_R_SUCCESS);
@ -3875,7 +3837,8 @@ named_statschannels_configure(named_server_t *server, const cfg_obj_t *config,
#endif /* EXTENDED_STATS */
for (element = cfg_list_first(statschannellist);
element != NULL; element = cfg_list_next(element)) {
element != NULL; element = cfg_list_next(element))
{
const cfg_obj_t *statschannel;
const cfg_obj_t *listenercfg = NULL;
@ -3887,10 +3850,11 @@ named_statschannels_configure(named_server_t *server, const cfg_obj_t *config,
for (element2 = cfg_list_first(listenercfg);
element2 != NULL;
element2 = cfg_list_next(element2)) {
element2 = cfg_list_next(element2))
{
const cfg_obj_t *listen_params;
const cfg_obj_t *obj;
isc_sockaddr_t addr;
isc_sockaddr_t addr;
listen_params = cfg_listelt_value(element2);
@ -3956,7 +3920,8 @@ named_statschannels_configure(named_server_t *server, const cfg_obj_t *config,
}
for (listener = ISC_LIST_HEAD(server->statschannels); listener != NULL;
listener = listener_next) {
listener = listener_next)
{
listener_next = ISC_LIST_NEXT(listener, link);
ISC_LIST_UNLINK(server->statschannels, listener, link);
shutdown_listener(listener);
@ -3967,8 +3932,7 @@ named_statschannels_configure(named_server_t *server, const cfg_obj_t *config,
}
void
named_statschannels_shutdown(named_server_t *server)
{
named_statschannels_shutdown(named_server_t *server) {
named_statschannel_t *listener;
while ((listener = ISC_LIST_HEAD(server->statschannels)) != NULL) {
@ -3978,19 +3942,18 @@ named_statschannels_shutdown(named_server_t *server)
}
isc_result_t
named_stats_dump(named_server_t *server, FILE *fp)
{
isc_stdtime_t now;
isc_result_t result;
dns_view_t * view;
dns_zone_t * zone, *next;
named_stats_dump(named_server_t *server, FILE *fp) {
isc_stdtime_t now;
isc_result_t result;
dns_view_t *view;
dns_zone_t *zone, *next;
stats_dumparg_t dumparg;
uint64_t nsstat_values[ns_statscounter_max];
uint64_t resstat_values[dns_resstatscounter_max];
uint64_t adbstat_values[dns_adbstats_max];
uint64_t zonestat_values[dns_zonestatscounter_max];
uint64_t sockstat_values[isc_sockstatscounter_max];
uint64_t gluecachestats_values[dns_gluecachestatscounter_max];
uint64_t nsstat_values[ns_statscounter_max];
uint64_t resstat_values[dns_resstatscounter_max];
uint64_t adbstat_values[dns_adbstats_max];
uint64_t zonestat_values[dns_zonestatscounter_max];
uint64_t sockstat_values[isc_sockstatscounter_max];
uint64_t gluecachestats_values[dns_gluecachestatscounter_max];
RUNTIME_CHECK(isc_once_do(&once, init_desc) == ISC_R_SUCCESS);
@ -4015,7 +3978,8 @@ named_stats_dump(named_server_t *server, FILE *fp)
fprintf(fp, "++ Outgoing Queries ++\n");
for (view = ISC_LIST_HEAD(server->viewlist); view != NULL;
view = ISC_LIST_NEXT(view, link)) {
view = ISC_LIST_NEXT(view, link))
{
if (view->resquerystats == NULL) {
continue;
}
@ -4045,7 +4009,8 @@ named_stats_dump(named_server_t *server, FILE *fp)
NULL, resstats_desc, dns_resstatscounter_max,
resstats_index, resstat_values, 0);
for (view = ISC_LIST_HEAD(server->viewlist); view != NULL;
view = ISC_LIST_NEXT(view, link)) {
view = ISC_LIST_NEXT(view, link))
{
if (view->resstats == NULL) {
continue;
}
@ -4062,7 +4027,8 @@ named_stats_dump(named_server_t *server, FILE *fp)
fprintf(fp, "++ Cache Statistics ++\n");
for (view = ISC_LIST_HEAD(server->viewlist); view != NULL;
view = ISC_LIST_NEXT(view, link)) {
view = ISC_LIST_NEXT(view, link))
{
if (strcmp(view->name, "_default") == 0) {
fprintf(fp, "[View: default]\n");
} else {
@ -4080,7 +4046,8 @@ named_stats_dump(named_server_t *server, FILE *fp)
fprintf(fp, "++ Cache DB RRsets ++\n");
for (view = ISC_LIST_HEAD(server->viewlist); view != NULL;
view = ISC_LIST_NEXT(view, link)) {
view = ISC_LIST_NEXT(view, link))
{
dns_stats_t *cacherrstats;
cacherrstats = dns_db_getrrsetstats(view->cachedb);
@ -4106,7 +4073,8 @@ named_stats_dump(named_server_t *server, FILE *fp)
fprintf(fp, "++ ADB stats ++\n");
for (view = ISC_LIST_HEAD(server->viewlist); view != NULL;
view = ISC_LIST_NEXT(view, link)) {
view = ISC_LIST_NEXT(view, link))
{
if (view->adbstats == NULL) {
continue;
}
@ -4129,7 +4097,8 @@ named_stats_dump(named_server_t *server, FILE *fp)
zone = NULL;
for (result = dns_zone_first(server->zonemgr, &zone);
result == ISC_R_SUCCESS;
next = NULL, result = dns_zone_next(zone, &next), zone = next) {
next = NULL, result = dns_zone_next(zone, &next), zone = next)
{
isc_stats_t *zonestats = dns_zone_getrequeststats(zone);
if (zonestats != NULL) {
char zonename[DNS_NAME_FORMATSIZE];
@ -4158,7 +4127,8 @@ named_stats_dump(named_server_t *server, FILE *fp)
zone = NULL;
for (result = dns_zone_first(server->zonemgr, &zone);
result == ISC_R_SUCCESS;
next = NULL, result = dns_zone_next(zone, &next), zone = next) {
next = NULL, result = dns_zone_next(zone, &next), zone = next)
{
isc_stats_t *gluecachestats = dns_zone_getgluecachestats(zone);
if (gluecachestats != NULL) {
char zonename[DNS_NAME_FORMATSIZE];

19
bin/named/tkeyconf.c
View file

@ -41,17 +41,16 @@
isc_result_t
named_tkeyctx_fromconfig(const cfg_obj_t *options, isc_mem_t *mctx,
dns_tkeyctx_t **tctxp)
{
isc_result_t result;
dns_tkeyctx_t * tctx = NULL;
const char * s;
uint32_t n;
dns_fixedname_t fname;
dns_name_t * name;
isc_buffer_t b;
dns_tkeyctx_t **tctxp) {
isc_result_t result;
dns_tkeyctx_t *tctx = NULL;
const char *s;
uint32_t n;
dns_fixedname_t fname;
dns_name_t *name;
isc_buffer_t b;
const cfg_obj_t *obj;
int type;
int type;
result = dns_tkeyctx_create(mctx, &tctx);
if (result != ISC_R_SUCCESS) {

51
bin/named/tsigconf.c
View file

@ -30,30 +30,30 @@
static isc_result_t
add_initial_keys(const cfg_obj_t *list, dns_tsig_keyring_t *ring,
isc_mem_t *mctx)
{
dns_tsigkey_t * tsigkey = NULL;
isc_mem_t *mctx) {
dns_tsigkey_t *tsigkey = NULL;
const cfg_listelt_t *element;
const cfg_obj_t * key = NULL;
const char * keyid = NULL;
unsigned char * secret = NULL;
int secretalloc = 0;
int secretlen = 0;
isc_result_t ret;
isc_stdtime_t now;
uint16_t bits;
const cfg_obj_t *key = NULL;
const char *keyid = NULL;
unsigned char *secret = NULL;
int secretalloc = 0;
int secretlen = 0;
isc_result_t ret;
isc_stdtime_t now;
uint16_t bits;
for (element = cfg_list_first(list); element != NULL;
element = cfg_list_next(element)) {
const cfg_obj_t * algobj = NULL;
const cfg_obj_t * secretobj = NULL;
dns_name_t keyname;
element = cfg_list_next(element))
{
const cfg_obj_t *algobj = NULL;
const cfg_obj_t *secretobj = NULL;
dns_name_t keyname;
const dns_name_t *alg;
const char * algstr;
char keynamedata[1024];
isc_buffer_t keynamesrc, keynamebuf;
const char * secretstr;
isc_buffer_t secretbuf;
const char *algstr;
char keynamedata[1024];
isc_buffer_t keynamesrc, keynamebuf;
const char *secretstr;
isc_buffer_t secretbuf;
key = cfg_listelt_value(element);
keyid = cfg_obj_asstring(cfg_map_getname(key));
@ -131,13 +131,12 @@ failure:
isc_result_t
named_tsigkeyring_fromconfig(const cfg_obj_t *config, const cfg_obj_t *vconfig,
isc_mem_t *mctx, dns_tsig_keyring_t **ringp)
{
const cfg_obj_t * maps[3];
const cfg_obj_t * keylist;
isc_mem_t *mctx, dns_tsig_keyring_t **ringp) {
const cfg_obj_t *maps[3];
const cfg_obj_t *keylist;
dns_tsig_keyring_t *ring = NULL;
isc_result_t result;
int i;
isc_result_t result;
int i;
REQUIRE(ringp != NULL && *ringp == NULL);

140
bin/named/unix/dlz_dlopen_driver.c
View file

@ -34,31 +34,31 @@
static dns_sdlzimplementation_t *dlz_dlopen = NULL;
typedef struct dlopen_data {
isc_mem_t * mctx;
char * dl_path;
char * dlzname;
void * dl_handle;
void * dbdata;
isc_mem_t *mctx;
char *dl_path;
char *dlzname;
void *dl_handle;
void *dbdata;
unsigned int flags;
isc_mutex_t lock;
int version;
bool in_configure;
isc_mutex_t lock;
int version;
bool in_configure;
dlz_dlopen_version_t * dlz_version;
dlz_dlopen_create_t * dlz_create;
dlz_dlopen_findzonedb_t * dlz_findzonedb;
dlz_dlopen_lookup_t * dlz_lookup;
dlz_dlopen_authority_t * dlz_authority;
dlz_dlopen_allnodes_t * dlz_allnodes;
dlz_dlopen_version_t *dlz_version;
dlz_dlopen_create_t *dlz_create;
dlz_dlopen_findzonedb_t *dlz_findzonedb;
dlz_dlopen_lookup_t *dlz_lookup;
dlz_dlopen_authority_t *dlz_authority;
dlz_dlopen_allnodes_t *dlz_allnodes;
dlz_dlopen_allowzonexfr_t *dlz_allowzonexfr;
dlz_dlopen_newversion_t * dlz_newversion;
dlz_dlopen_newversion_t *dlz_newversion;
dlz_dlopen_closeversion_t *dlz_closeversion;
dlz_dlopen_configure_t * dlz_configure;
dlz_dlopen_ssumatch_t * dlz_ssumatch;
dlz_dlopen_addrdataset_t * dlz_addrdataset;
dlz_dlopen_subrdataset_t * dlz_subrdataset;
dlz_dlopen_delrdataset_t * dlz_delrdataset;
dlz_dlopen_destroy_t * dlz_destroy;
dlz_dlopen_configure_t *dlz_configure;
dlz_dlopen_ssumatch_t *dlz_ssumatch;
dlz_dlopen_addrdataset_t *dlz_addrdataset;
dlz_dlopen_subrdataset_t *dlz_subrdataset;
dlz_dlopen_delrdataset_t *dlz_delrdataset;
dlz_dlopen_destroy_t *dlz_destroy;
} dlopen_data_t;
/* Modules can choose whether they are lock-safe or not. */
@ -80,8 +80,7 @@ typedef struct dlopen_data {
* Log a message at the given level.
*/
static void
dlopen_log(int level, const char *fmt, ...)
{
dlopen_log(int level, const char *fmt, ...) {
va_list ap;
va_start(ap, fmt);
isc_log_vwrite(dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DLZ,
@ -95,10 +94,9 @@ dlopen_log(int level, const char *fmt, ...)
static isc_result_t
dlopen_dlz_allnodes(const char *zone, void *driverarg, void *dbdata,
dns_sdlzallnodes_t *allnodes)
{
dns_sdlzallnodes_t *allnodes) {
dlopen_data_t *cd = (dlopen_data_t *)dbdata;
isc_result_t result;
isc_result_t result;
UNUSED(driverarg);
@ -114,10 +112,9 @@ dlopen_dlz_allnodes(const char *zone, void *driverarg, void *dbdata,
static isc_result_t
dlopen_dlz_allowzonexfr(void *driverarg, void *dbdata, const char *name,
const char *client)
{
const char *client) {
dlopen_data_t *cd = (dlopen_data_t *)dbdata;
isc_result_t result;
isc_result_t result;
UNUSED(driverarg);
@ -133,10 +130,9 @@ dlopen_dlz_allowzonexfr(void *driverarg, void *dbdata, const char *name,
static isc_result_t
dlopen_dlz_authority(const char *zone, void *driverarg, void *dbdata,
dns_sdlzlookup_t *lookup)
{
dns_sdlzlookup_t *lookup) {
dlopen_data_t *cd = (dlopen_data_t *)dbdata;
isc_result_t result;
isc_result_t result;
UNUSED(driverarg);
@ -153,10 +149,9 @@ dlopen_dlz_authority(const char *zone, void *driverarg, void *dbdata,
static isc_result_t
dlopen_dlz_findzonedb(void *driverarg, void *dbdata, const char *name,
dns_clientinfomethods_t *methods,
dns_clientinfo_t * clientinfo)
{
dns_clientinfo_t *clientinfo) {
dlopen_data_t *cd = (dlopen_data_t *)dbdata;
isc_result_t result;
isc_result_t result;
UNUSED(driverarg);
@ -170,10 +165,9 @@ static isc_result_t
dlopen_dlz_lookup(const char *zone, const char *name, void *driverarg,
void *dbdata, dns_sdlzlookup_t *lookup,
dns_clientinfomethods_t *methods,
dns_clientinfo_t * clientinfo)
{
dns_clientinfo_t *clientinfo) {
dlopen_data_t *cd = (dlopen_data_t *)dbdata;
isc_result_t result;
isc_result_t result;
UNUSED(driverarg);
@ -188,8 +182,7 @@ dlopen_dlz_lookup(const char *zone, const char *name, void *driverarg,
* Load a symbol from the library
*/
static void *
dl_load_symbol(dlopen_data_t *cd, const char *symbol, bool mandatory)
{
dl_load_symbol(dlopen_data_t *cd, const char *symbol, bool mandatory) {
void *ptr = dlsym(cd->dl_handle, symbol);
if (ptr == NULL && mandatory) {
dlopen_log(ISC_LOG_ERROR,
@ -205,12 +198,11 @@ dl_load_symbol(dlopen_data_t *cd, const char *symbol, bool mandatory)
*/
static isc_result_t
dlopen_dlz_create(const char *dlzname, unsigned int argc, char *argv[],
void *driverarg, void **dbdata)
{
void *driverarg, void **dbdata) {
dlopen_data_t *cd;
isc_mem_t * mctx = NULL;
isc_result_t result = ISC_R_FAILURE;
int dlopen_flags = 0;
isc_mem_t *mctx = NULL;
isc_result_t result = ISC_R_FAILURE;
int dlopen_flags = 0;
UNUSED(driverarg);
@ -264,15 +256,16 @@ dlopen_dlz_create(const char *dlzname, unsigned int argc, char *argv[],
/* Find the symbols */
cd->dlz_version =
(dlz_dlopen_version_t *)dl_load_symbol(cd, "dlz_version", true);
cd->dlz_create =
(dlz_dlopen_create_t *)dl_load_symbol(cd, "dlz_create", true);
cd->dlz_lookup =
(dlz_dlopen_lookup_t *)dl_load_symbol(cd, "dlz_lookup", true);
cd->dlz_create = (dlz_dlopen_create_t *)dl_load_symbol(cd, "dlz_create",
true);
cd->dlz_lookup = (dlz_dlopen_lookup_t *)dl_load_symbol(cd, "dlz_lookup",
true);
cd->dlz_findzonedb = (dlz_dlopen_findzonedb_t *)dl_load_symbol(
cd, "dlz_findzonedb", true);
if (cd->dlz_create == NULL || cd->dlz_version == NULL ||
cd->dlz_lookup == NULL || cd->dlz_findzonedb == NULL) {
cd->dlz_lookup == NULL || cd->dlz_findzonedb == NULL)
{
/* We're missing a required symbol */
result = ISC_R_FAILURE;
goto failed;
@ -304,7 +297,8 @@ dlopen_dlz_create(const char *dlzname, unsigned int argc, char *argv[],
/* Check the version of the API is the same */
cd->version = cd->dlz_version(&cd->flags);
if (cd->version < (DLZ_DLOPEN_VERSION - DLZ_DLOPEN_AGE) ||
cd->version > DLZ_DLOPEN_VERSION) {
cd->version > DLZ_DLOPEN_VERSION)
{
dlopen_log(ISC_LOG_ERROR,
"dlz_dlopen: %s: incorrect driver API version %d, "
"requires %d",
@ -359,10 +353,9 @@ failed:
* Called when bind is shutting down
*/
static void
dlopen_dlz_destroy(void *driverarg, void *dbdata)
{
dlopen_dlz_destroy(void *driverarg, void *dbdata) {
dlopen_data_t *cd = (dlopen_data_t *)dbdata;
isc_mem_t * mctx;
isc_mem_t *mctx;
UNUSED(driverarg);
@ -397,10 +390,9 @@ dlopen_dlz_destroy(void *driverarg, void *dbdata)
*/
static isc_result_t
dlopen_dlz_newversion(const char *zone, void *driverarg, void *dbdata,
void **versionp)
{
void **versionp) {
dlopen_data_t *cd = (dlopen_data_t *)dbdata;
isc_result_t result;
isc_result_t result;
UNUSED(driverarg);
@ -419,8 +411,7 @@ dlopen_dlz_newversion(const char *zone, void *driverarg, void *dbdata,
*/
static void
dlopen_dlz_closeversion(const char *zone, bool commit, void *driverarg,
void *dbdata, void **versionp)
{
void *dbdata, void **versionp) {
dlopen_data_t *cd = (dlopen_data_t *)dbdata;
UNUSED(driverarg);
@ -440,10 +431,9 @@ dlopen_dlz_closeversion(const char *zone, bool commit, void *driverarg,
*/
static isc_result_t
dlopen_dlz_configure(dns_view_t *view, dns_dlzdb_t *dlzdb, void *driverarg,
void *dbdata)
{
void *dbdata) {
dlopen_data_t *cd = (dlopen_data_t *)dbdata;
isc_result_t result;
isc_result_t result;
UNUSED(driverarg);
@ -466,10 +456,9 @@ dlopen_dlz_configure(dns_view_t *view, dns_dlzdb_t *dlzdb, void *driverarg,
static bool
dlopen_dlz_ssumatch(const char *signer, const char *name, const char *tcpaddr,
const char *type, const char *key, uint32_t keydatalen,
unsigned char *keydata, void *driverarg, void *dbdata)
{
unsigned char *keydata, void *driverarg, void *dbdata) {
dlopen_data_t *cd = (dlopen_data_t *)dbdata;
bool ret;
bool ret;
UNUSED(driverarg);
@ -490,10 +479,9 @@ dlopen_dlz_ssumatch(const char *signer, const char *name, const char *tcpaddr,
*/
static isc_result_t
dlopen_dlz_addrdataset(const char *name, const char *rdatastr, void *driverarg,
void *dbdata, void *version)
{
void *dbdata, void *version) {
dlopen_data_t *cd = (dlopen_data_t *)dbdata;
isc_result_t result;
isc_result_t result;
UNUSED(driverarg);
@ -513,10 +501,9 @@ dlopen_dlz_addrdataset(const char *name, const char *rdatastr, void *driverarg,
*/
static isc_result_t
dlopen_dlz_subrdataset(const char *name, const char *rdatastr, void *driverarg,
void *dbdata, void *version)
{
void *dbdata, void *version) {
dlopen_data_t *cd = (dlopen_data_t *)dbdata;
isc_result_t result;
isc_result_t result;
UNUSED(driverarg);
@ -536,10 +523,9 @@ dlopen_dlz_subrdataset(const char *name, const char *rdatastr, void *driverarg,
*/
static isc_result_t
dlopen_dlz_delrdataset(const char *name, const char *type, void *driverarg,
void *dbdata, void *version)
{
void *dbdata, void *version) {
dlopen_data_t *cd = (dlopen_data_t *)dbdata;
isc_result_t result;
isc_result_t result;
UNUSED(driverarg);
@ -567,8 +553,7 @@ static dns_sdlzmethods_t dlz_dlopen_methods = {
* Register driver with BIND
*/
isc_result_t
dlz_dlopen_init(isc_mem_t *mctx)
{
dlz_dlopen_init(isc_mem_t *mctx) {
#ifndef ISC_DLZ_DLOPEN
UNUSED(mctx);
return (ISC_R_NOTIMPLEMENTED);
@ -598,8 +583,7 @@ dlz_dlopen_init(isc_mem_t *mctx)
* Unregister the driver
*/
void
dlz_dlopen_clear(void)
{
dlz_dlopen_clear(void) {
#ifdef ISC_DLZ_DLOPEN
dlopen_log(2, "Unregistering DLZ_dlopen driver");
if (dlz_dlopen != NULL) {

146
bin/named/unix/os.c
View file

@ -50,16 +50,16 @@
static char *pidfile = NULL;
static char *lockfile = NULL;
static int devnullfd = -1;
static int singletonfd = -1;
static int devnullfd = -1;
static int singletonfd = -1;
#ifndef ISC_FACILITY
#define ISC_FACILITY LOG_DAEMON
#endif /* ifndef ISC_FACILITY */
static struct passwd *runas_pw = NULL;
static bool done_setuid = false;
static int dfd[2] = { -1, -1 };
static bool done_setuid = false;
static int dfd[2] = { -1, -1 };
#ifdef HAVE_SYS_CAPABILITY_H
@ -70,8 +70,7 @@ static bool non_root_caps = false;
#include <sys/prctl.h>
static void
linux_setcaps(cap_t caps)
{
linux_setcaps(cap_t caps) {
char strbuf[ISC_STRERRORSIZE];
if ((getuid() != 0 && !non_root_caps) || non_root) {
@ -133,13 +132,12 @@ linux_setcaps(cap_t caps)
while (0)
static void
linux_initialprivs(void)
{
cap_t caps;
cap_t curcaps;
linux_initialprivs(void) {
cap_t caps;
cap_t curcaps;
cap_value_t capval;
char strbuf[ISC_STRERRORSIZE];
int err;
char strbuf[ISC_STRERRORSIZE];
int err;
/*%
* We don't need most privileges, so we drop them right away.
@ -196,13 +194,12 @@ linux_initialprivs(void)
}
static void
linux_minprivs(void)
{
cap_t caps;
cap_t curcaps;
linux_minprivs(void) {
cap_t caps;
cap_t curcaps;
cap_value_t capval;
char strbuf[ISC_STRERRORSIZE];
int err;
char strbuf[ISC_STRERRORSIZE];
int err;
INIT_CAP;
/*%
@ -230,8 +227,7 @@ linux_minprivs(void)
}
static void
linux_keepcaps(void)
{
linux_keepcaps(void) {
char strbuf[ISC_STRERRORSIZE];
/*%
* Ask the kernel to allow us to keep our capabilities after we
@ -254,8 +250,7 @@ linux_keepcaps(void)
#endif /* HAVE_SYS_CAPABILITY_H */
static void
setup_syslog(const char *progname)
{
setup_syslog(const char *progname) {
int options;
options = LOG_PID;
@ -266,8 +261,7 @@ setup_syslog(const char *progname)
}
void
named_os_init(const char *progname)
{
named_os_init(const char *progname) {
setup_syslog(progname);
#ifdef HAVE_SYS_CAPABILITY_H
linux_initialprivs();
@ -278,10 +272,9 @@ named_os_init(const char *progname)
}
void
named_os_daemonize(void)
{
named_os_daemonize(void) {
pid_t pid;
char strbuf[ISC_STRERRORSIZE];
char strbuf[ISC_STRERRORSIZE];
if (pipe(dfd) == -1) {
strerror_r(errno, strbuf, sizeof(strbuf));
@ -348,8 +341,7 @@ named_os_daemonize(void)
}
void
named_os_started(void)
{
named_os_started(void) {
char buf = 0;
/*
@ -367,24 +359,22 @@ named_os_started(void)
}
void
named_os_opendevnull(void)
{
named_os_opendevnull(void) {
devnullfd = open("/dev/null", O_RDWR, 0);
}
void
named_os_closedevnull(void)
{
named_os_closedevnull(void) {
if (devnullfd != STDIN_FILENO && devnullfd != STDOUT_FILENO &&
devnullfd != STDERR_FILENO) {
devnullfd != STDERR_FILENO)
{
close(devnullfd);
devnullfd = -1;
}
}
static bool
all_digits(const char *s)
{
all_digits(const char *s) {
if (*s == '\0') {
return (false);
}
@ -398,8 +388,7 @@ all_digits(const char *s)
}
void
named_os_chroot(const char *root)
{
named_os_chroot(const char *root) {
char strbuf[ISC_STRERRORSIZE];
#ifdef HAVE_LIBSCF
named_smf_chroot = 0;
@ -425,8 +414,7 @@ named_os_chroot(const char *root)
}
void
named_os_inituserinfo(const char *username)
{
named_os_inituserinfo(const char *username) {
char strbuf[ISC_STRERRORSIZE];
if (username == NULL) {
return;
@ -452,8 +440,7 @@ named_os_inituserinfo(const char *username)
}
void
named_os_changeuser(void)
{
named_os_changeuser(void) {
char strbuf[ISC_STRERRORSIZE];
if (runas_pw == NULL || done_setuid) {
return;
@ -487,8 +474,7 @@ named_os_changeuser(void)
}
uid_t
ns_os_uid(void)
{
ns_os_uid(void) {
if (runas_pw == NULL) {
return (0);
}
@ -496,10 +482,9 @@ ns_os_uid(void)
}
void
named_os_adjustnofile(void)
{
named_os_adjustnofile(void) {
#if defined(__linux__)
isc_result_t result;
isc_result_t result;
isc_resourcevalue_t newvalue;
/*
@ -516,8 +501,7 @@ named_os_adjustnofile(void)
}
void
named_os_minprivs(void)
{
named_os_minprivs(void) {
#if defined(HAVE_SYS_CAPABILITY_H)
linux_keepcaps();
named_os_changeuser();
@ -526,9 +510,8 @@ named_os_minprivs(void)
}
static int
safe_open(const char *filename, mode_t mode, bool append)
{
int fd;
safe_open(const char *filename, mode_t mode, bool append) {
int fd;
struct stat sb;
if (stat(filename, &sb) == -1) {
@ -552,8 +535,7 @@ safe_open(const char *filename, mode_t mode, bool append)
}
static void
cleanup_pidfile(void)
{
cleanup_pidfile(void) {
int n;
if (pidfile != NULL) {
n = unlink(pidfile);
@ -566,8 +548,7 @@ cleanup_pidfile(void)
}
static void
cleanup_lockfile(void)
{
cleanup_lockfile(void) {
if (singletonfd != -1) {
close(singletonfd);
singletonfd = -1;
@ -590,10 +571,9 @@ cleanup_lockfile(void)
* nulls. The caller should copy the filename to a fresh buffer first.
*/
static int
mkdirpath(char *filename, void (*report)(const char *, ...))
{
char * slash = strrchr(filename, '/');
char strbuf[ISC_STRERRORSIZE];
mkdirpath(char *filename, void (*report)(const char *, ...)) {
char *slash = strrchr(filename, '/');
char strbuf[ISC_STRERRORSIZE];
unsigned int mode;
if (slash != NULL && slash != filename) {
@ -614,7 +594,8 @@ mkdirpath(char *filename, void (*report)(const char *, ...))
* Handle "//", "/./" and "/../" in path.
*/
if (!strcmp(slash + 1, "") || !strcmp(slash + 1, ".") ||
!strcmp(slash + 1, "..")) {
!strcmp(slash + 1, ".."))
{
*slash = '/';
return (0);
}
@ -629,7 +610,8 @@ mkdirpath(char *filename, void (*report)(const char *, ...))
}
if (runas_pw != NULL &&
chown(filename, runas_pw->pw_uid,
runas_pw->pw_gid) == -1) {
runas_pw->pw_gid) == -1)
{
strerror_r(errno, strbuf, sizeof(strbuf));
(*report)("couldn't chown '%s': %s", filename,
strbuf);
@ -645,8 +627,7 @@ error:
}
static void
setperms(uid_t uid, gid_t gid)
{
setperms(uid_t uid, gid_t gid) {
#if defined(HAVE_SETEGID) || defined(HAVE_SETRESGID)
char strbuf[ISC_STRERRORSIZE];
#endif /* if defined(HAVE_SETEGID) || defined(HAVE_SETRESGID) */
@ -694,11 +675,10 @@ setperms(uid_t uid, gid_t gid)
}
FILE *
named_os_openfile(const char *filename, mode_t mode, bool switch_user)
{
char strbuf[ISC_STRERRORSIZE], *f;
named_os_openfile(const char *filename, mode_t mode, bool switch_user) {
char strbuf[ISC_STRERRORSIZE], *f;
FILE *fp;
int fd;
int fd;
/*
* Make the containing directory if it doesn't exist.
@ -764,11 +744,10 @@ named_os_openfile(const char *filename, mode_t mode, bool switch_user)
}
void
named_os_writepidfile(const char *filename, bool first_time)
{
named_os_writepidfile(const char *filename, bool first_time) {
FILE *fh;
pid_t pid;
char strbuf[ISC_STRERRORSIZE];
char strbuf[ISC_STRERRORSIZE];
void (*report)(const char *, ...);
/*
@ -813,9 +792,8 @@ named_os_writepidfile(const char *filename, bool first_time)
}
bool
named_os_issingleton(const char *filename)
{
char strbuf[ISC_STRERRORSIZE];
named_os_issingleton(const char *filename) {
char strbuf[ISC_STRERRORSIZE];
struct flock lock;
if (singletonfd != -1) {
@ -872,16 +850,14 @@ named_os_issingleton(const char *filename)
}
void
named_os_shutdown(void)
{
named_os_shutdown(void) {
closelog();
cleanup_pidfile();
cleanup_lockfile();
}
isc_result_t
named_os_gethostname(char *buf, size_t len)
{
named_os_gethostname(char *buf, size_t len) {
int n;
n = gethostname(buf, len);
@ -889,8 +865,7 @@ named_os_gethostname(char *buf, size_t len)
}
void
named_os_shutdownmsg(char *command, isc_buffer_t *text)
{
named_os_shutdownmsg(char *command, isc_buffer_t *text) {
char *last, *ptr;
pid_t pid;
@ -913,19 +888,17 @@ named_os_shutdownmsg(char *command, isc_buffer_t *text)
}
void
named_os_tzset(void)
{
named_os_tzset(void) {
#ifdef HAVE_TZSET
tzset();
#endif /* ifdef HAVE_TZSET */
}
static char unamebuf[BUFSIZ];
static char unamebuf[BUFSIZ];
static char *unamep = NULL;
static void
getuname(void)
{
getuname(void) {
#ifdef HAVE_UNAME
struct utsname uts;
@ -944,8 +917,7 @@ getuname(void)
}
char *
named_os_uname(void)
{
named_os_uname(void) {
if (unamep == NULL) {
getuname();
}

140
bin/named/win32/dlz_dlopen_driver.c
View file

@ -32,31 +32,31 @@
static dns_sdlzimplementation_t *dlz_dlopen = NULL;
typedef struct dlopen_data {
isc_mem_t * mctx;
char * dl_path;
char * dlzname;
HMODULE dl_handle;
void * dbdata;
isc_mem_t *mctx;
char *dl_path;
char *dlzname;
HMODULE dl_handle;
void *dbdata;
unsigned int flags;
isc_mutex_t lock;
int version;
bool in_configure;
isc_mutex_t lock;
int version;
bool in_configure;
dlz_dlopen_version_t * dlz_version;
dlz_dlopen_create_t * dlz_create;
dlz_dlopen_findzonedb_t * dlz_findzonedb;
dlz_dlopen_lookup_t * dlz_lookup;
dlz_dlopen_authority_t * dlz_authority;
dlz_dlopen_allnodes_t * dlz_allnodes;
dlz_dlopen_version_t *dlz_version;
dlz_dlopen_create_t *dlz_create;
dlz_dlopen_findzonedb_t *dlz_findzonedb;
dlz_dlopen_lookup_t *dlz_lookup;
dlz_dlopen_authority_t *dlz_authority;
dlz_dlopen_allnodes_t *dlz_allnodes;
dlz_dlopen_allowzonexfr_t *dlz_allowzonexfr;
dlz_dlopen_newversion_t * dlz_newversion;
dlz_dlopen_newversion_t *dlz_newversion;
dlz_dlopen_closeversion_t *dlz_closeversion;
dlz_dlopen_configure_t * dlz_configure;
dlz_dlopen_ssumatch_t * dlz_ssumatch;
dlz_dlopen_addrdataset_t * dlz_addrdataset;
dlz_dlopen_subrdataset_t * dlz_subrdataset;
dlz_dlopen_delrdataset_t * dlz_delrdataset;
dlz_dlopen_destroy_t * dlz_destroy;
dlz_dlopen_configure_t *dlz_configure;
dlz_dlopen_ssumatch_t *dlz_ssumatch;
dlz_dlopen_addrdataset_t *dlz_addrdataset;
dlz_dlopen_subrdataset_t *dlz_subrdataset;
dlz_dlopen_delrdataset_t *dlz_delrdataset;
dlz_dlopen_destroy_t *dlz_destroy;
} dlopen_data_t;
/* Modules can choose whether they are lock-safe or not. */
@ -78,8 +78,7 @@ typedef struct dlopen_data {
* Log a message at the given level.
*/
static void
dlopen_log(int level, const char *fmt, ...)
{
dlopen_log(int level, const char *fmt, ...) {
va_list ap;
va_start(ap, fmt);
isc_log_vwrite(dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DLZ,
@ -93,10 +92,9 @@ dlopen_log(int level, const char *fmt, ...)
static isc_result_t
dlopen_dlz_allnodes(const char *zone, void *driverarg, void *dbdata,
dns_sdlzallnodes_t *allnodes)
{
dns_sdlzallnodes_t *allnodes) {
dlopen_data_t *cd = (dlopen_data_t *)dbdata;
isc_result_t result;
isc_result_t result;
UNUSED(driverarg);
@ -112,10 +110,9 @@ dlopen_dlz_allnodes(const char *zone, void *driverarg, void *dbdata,
static isc_result_t
dlopen_dlz_allowzonexfr(void *driverarg, void *dbdata, const char *name,
const char *client)
{
const char *client) {
dlopen_data_t *cd = (dlopen_data_t *)dbdata;
isc_result_t result;
isc_result_t result;
UNUSED(driverarg);
@ -131,10 +128,9 @@ dlopen_dlz_allowzonexfr(void *driverarg, void *dbdata, const char *name,
static isc_result_t
dlopen_dlz_authority(const char *zone, void *driverarg, void *dbdata,
dns_sdlzlookup_t *lookup)
{
dns_sdlzlookup_t *lookup) {
dlopen_data_t *cd = (dlopen_data_t *)dbdata;
isc_result_t result;
isc_result_t result;
UNUSED(driverarg);
@ -151,10 +147,9 @@ dlopen_dlz_authority(const char *zone, void *driverarg, void *dbdata,
static isc_result_t
dlopen_dlz_findzonedb(void *driverarg, void *dbdata, const char *name,
dns_clientinfomethods_t *methods,
dns_clientinfo_t * clientinfo)
{
dns_clientinfo_t *clientinfo) {
dlopen_data_t *cd = (dlopen_data_t *)dbdata;
isc_result_t result;
isc_result_t result;
UNUSED(driverarg);
@ -168,10 +163,9 @@ static isc_result_t
dlopen_dlz_lookup(const char *zone, const char *name, void *driverarg,
void *dbdata, dns_sdlzlookup_t *lookup,
dns_clientinfomethods_t *methods,
dns_clientinfo_t * clientinfo)
{
dns_clientinfo_t *clientinfo) {
dlopen_data_t *cd = (dlopen_data_t *)dbdata;
isc_result_t result;
isc_result_t result;
UNUSED(driverarg);
@ -186,8 +180,7 @@ dlopen_dlz_lookup(const char *zone, const char *name, void *driverarg,
* Load a symbol from the library
*/
static void *
dl_load_symbol(dlopen_data_t *cd, const char *symbol, bool mandatory)
{
dl_load_symbol(dlopen_data_t *cd, const char *symbol, bool mandatory) {
void *ptr = GetProcAddress(cd->dl_handle, symbol);
if (ptr == NULL && mandatory) {
dlopen_log(ISC_LOG_ERROR,
@ -203,12 +196,11 @@ dl_load_symbol(dlopen_data_t *cd, const char *symbol, bool mandatory)
*/
static isc_result_t
dlopen_dlz_create(const char *dlzname, unsigned int argc, char *argv[],
void *driverarg, void **dbdata)
{
void *driverarg, void **dbdata) {
dlopen_data_t *cd;
isc_mem_t * mctx = NULL;
isc_result_t result = ISC_R_FAILURE;
bool triedload = false;
isc_mem_t *mctx = NULL;
isc_result_t result = ISC_R_FAILURE;
bool triedload = false;
UNUSED(driverarg);
@ -251,15 +243,16 @@ dlopen_dlz_create(const char *dlzname, unsigned int argc, char *argv[],
/* Find the symbols */
cd->dlz_version =
(dlz_dlopen_version_t *)dl_load_symbol(cd, "dlz_version", true);
cd->dlz_create =
(dlz_dlopen_create_t *)dl_load_symbol(cd, "dlz_create", true);
cd->dlz_lookup =
(dlz_dlopen_lookup_t *)dl_load_symbol(cd, "dlz_lookup", true);
cd->dlz_create = (dlz_dlopen_create_t *)dl_load_symbol(cd, "dlz_create",
true);
cd->dlz_lookup = (dlz_dlopen_lookup_t *)dl_load_symbol(cd, "dlz_lookup",
true);
cd->dlz_findzonedb = (dlz_dlopen_findzonedb_t *)dl_load_symbol(
cd, "dlz_findzonedb", true);
if (cd->dlz_create == NULL || cd->dlz_version == NULL ||
cd->dlz_lookup == NULL || cd->dlz_findzonedb == NULL) {
cd->dlz_lookup == NULL || cd->dlz_findzonedb == NULL)
{
/* We're missing a required symbol */
result = ISC_R_FAILURE;
goto cleanup_lock;
@ -289,7 +282,8 @@ dlopen_dlz_create(const char *dlzname, unsigned int argc, char *argv[],
/* Check the version of the API is the same */
cd->version = cd->dlz_version(&cd->flags);
if (cd->version < (DLZ_DLOPEN_VERSION - DLZ_DLOPEN_AGE) ||
cd->version > DLZ_DLOPEN_VERSION) {
cd->version > DLZ_DLOPEN_VERSION)
{
dlopen_log(ISC_LOG_ERROR,
"dlz_dlopen: %s: incorrect driver API version %d, "
"requires %d",
@ -344,10 +338,9 @@ failed:
* Called when bind is shutting down
*/
static void
dlopen_dlz_destroy(void *driverarg, void *dbdata)
{
dlopen_dlz_destroy(void *driverarg, void *dbdata) {
dlopen_data_t *cd = (dlopen_data_t *)dbdata;
isc_mem_t * mctx;
isc_mem_t *mctx;
UNUSED(driverarg);
@ -380,10 +373,9 @@ dlopen_dlz_destroy(void *driverarg, void *dbdata)
*/
static isc_result_t
dlopen_dlz_newversion(const char *zone, void *driverarg, void *dbdata,
void **versionp)
{
void **versionp) {
dlopen_data_t *cd = (dlopen_data_t *)dbdata;
isc_result_t result;
isc_result_t result;
UNUSED(driverarg);
@ -402,8 +394,7 @@ dlopen_dlz_newversion(const char *zone, void *driverarg, void *dbdata,
*/
static void
dlopen_dlz_closeversion(const char *zone, bool commit, void *driverarg,
void *dbdata, void **versionp)
{
void *dbdata, void **versionp) {
dlopen_data_t *cd = (dlopen_data_t *)dbdata;
UNUSED(driverarg);
@ -423,10 +414,9 @@ dlopen_dlz_closeversion(const char *zone, bool commit, void *driverarg,
*/
static isc_result_t
dlopen_dlz_configure(dns_view_t *view, dns_dlzdb_t *dlzdb, void *driverarg,
void *dbdata)
{
void *dbdata) {
dlopen_data_t *cd = (dlopen_data_t *)dbdata;
isc_result_t result;
isc_result_t result;
UNUSED(driverarg);
@ -449,10 +439,9 @@ dlopen_dlz_configure(dns_view_t *view, dns_dlzdb_t *dlzdb, void *driverarg,
static bool
dlopen_dlz_ssumatch(const char *signer, const char *name, const char *tcpaddr,
const char *type, const char *key, uint32_t keydatalen,
unsigned char *keydata, void *driverarg, void *dbdata)
{
unsigned char *keydata, void *driverarg, void *dbdata) {
dlopen_data_t *cd = (dlopen_data_t *)dbdata;
bool ret;
bool ret;
UNUSED(driverarg);
@ -473,10 +462,9 @@ dlopen_dlz_ssumatch(const char *signer, const char *name, const char *tcpaddr,
*/
static isc_result_t
dlopen_dlz_addrdataset(const char *name, const char *rdatastr, void *driverarg,
void *dbdata, void *version)
{
void *dbdata, void *version) {
dlopen_data_t *cd = (dlopen_data_t *)dbdata;
isc_result_t result;
isc_result_t result;
UNUSED(driverarg);
@ -496,10 +484,9 @@ dlopen_dlz_addrdataset(const char *name, const char *rdatastr, void *driverarg,
*/
static isc_result_t
dlopen_dlz_subrdataset(const char *name, const char *rdatastr, void *driverarg,
void *dbdata, void *version)
{
void *dbdata, void *version) {
dlopen_data_t *cd = (dlopen_data_t *)dbdata;
isc_result_t result;
isc_result_t result;
UNUSED(driverarg);
@ -519,10 +506,9 @@ dlopen_dlz_subrdataset(const char *name, const char *rdatastr, void *driverarg,
*/
static isc_result_t
dlopen_dlz_delrdataset(const char *name, const char *type, void *driverarg,
void *dbdata, void *version)
{
void *dbdata, void *version) {
dlopen_data_t *cd = (dlopen_data_t *)dbdata;
isc_result_t result;
isc_result_t result;
UNUSED(driverarg);
@ -550,8 +536,7 @@ static dns_sdlzmethods_t dlz_dlopen_methods = {
* Register driver with BIND
*/
isc_result_t
dlz_dlopen_init(isc_mem_t *mctx)
{
dlz_dlopen_init(isc_mem_t *mctx) {
#ifndef ISC_DLZ_DLOPEN
UNUSED(mctx);
return (ISC_R_NOTIMPLEMENTED);
@ -581,8 +566,7 @@ dlz_dlopen_init(isc_mem_t *mctx)
* Unregister the driver
*/
void
dlz_dlopen_clear(void)
{
dlz_dlopen_clear(void) {
#ifdef ISC_DLZ_DLOPEN
dlopen_log(2, "Unregistering DLZ_dlopen driver");
if (dlz_dlopen != NULL) {

34
bin/named/win32/ntservice.c
View file

@ -24,23 +24,20 @@
/* Handle to SCM for updating service status */
static SERVICE_STATUS_HANDLE hServiceStatus = 0;
static BOOL foreground = FALSE;
static char ConsoleTitle[128];
static BOOL foreground = FALSE;
static char ConsoleTitle[128];
/*
* Forward declarations
*/
void
ServiceControl(DWORD dwCtrlCode);
int
bindmain(int, char *[]); /* From main.c */
void ServiceControl(DWORD dwCtrlCode);
int bindmain(int, char *[]); /* From main.c */
/*
* Initialize the Service by registering it.
*/
void
ntservice_init(void)
{
ntservice_init(void) {
if (!foreground) {
/* Register handler with the SCM */
hServiceStatus = RegisterServiceCtrlHandler(
@ -58,16 +55,14 @@ ntservice_init(void)
}
void
ntservice_shutdown(void)
{
ntservice_shutdown(void) {
UpdateSCM(SERVICE_STOPPED);
}
/*
* Routine to check if this is a service or a foreground program
*/
BOOL
ntservice_isservice(void)
{
ntservice_isservice(void) {
return (!foreground);
}
/*
@ -75,8 +70,7 @@ ntservice_isservice(void)
* to named.
*/
void
ServiceControl(DWORD dwCtrlCode)
{
ServiceControl(DWORD dwCtrlCode) {
/* Handle the requested control code */
switch (dwCtrlCode) {
case SERVICE_CONTROL_INTERROGATE:
@ -98,10 +92,9 @@ ServiceControl(DWORD dwCtrlCode)
* Tell the Service Control Manager the state of the service.
*/
void
UpdateSCM(DWORD state)
{
UpdateSCM(DWORD state) {
SERVICE_STATUS ss;
static DWORD dwState = SERVICE_STOPPED;
static DWORD dwState = SERVICE_STOPPED;
if (hServiceStatus) {
if (state) {
@ -135,14 +128,13 @@ UpdateSCM(DWORD state)
* as we need to.
*/
int
main(int argc, char *argv[])
{
main(int argc, char *argv[]) {
int rc, ch;
/* Command line users should put -f in the options. */
isc_commandline_errprint = false;
while ((ch = isc_commandline_parse(argc, argv, NAMED_MAIN_ARGS)) !=
-1) {
while ((ch = isc_commandline_parse(argc, argv, NAMED_MAIN_ARGS)) != -1)
{
switch (ch) {
case 'f':
case 'g':

120
bin/named/win32/os.c
View file

@ -37,8 +37,8 @@
static char *lockfile = NULL;
static char *pidfile = NULL;
static int devnullfd = -1;
static int lockfilefd = -1;
static int devnullfd = -1;
static int lockfilefd = -1;
static BOOL Initialized = FALSE;
@ -46,8 +46,7 @@ static char *version_error = "named requires Windows 2000 Service Pack 2 or "
"later to run correctly";
void
named_paths_init(void)
{
named_paths_init(void) {
if (!Initialized) {
isc_ntpaths_init();
}
@ -68,10 +67,10 @@ named_paths_init(void)
* warn when it isn't.
*/
static void
version_check(const char *progname)
{
version_check(const char *progname) {
if ((isc_win32os_versioncheck(4, 0, 0, 0) >= 0) &&
(isc_win32os_versioncheck(5, 0, 0, 0) < 0)) {
(isc_win32os_versioncheck(5, 0, 0, 0) < 0))
{
return; /* No problem with Version 4.0 */
}
if (isc_win32os_versioncheck(5, 0, 2, 0) < 0) {
@ -84,8 +83,7 @@ version_check(const char *progname)
}
static void
setup_syslog(const char *progname)
{
setup_syslog(const char *progname) {
int options;
options = LOG_PID;
@ -97,8 +95,7 @@ setup_syslog(const char *progname)
}
void
named_os_init(const char *progname)
{
named_os_init(const char *progname) {
named_paths_init();
setup_syslog(progname);
/*
@ -125,8 +122,7 @@ named_os_init(const char *progname)
}
void
named_os_daemonize(void)
{
named_os_daemonize(void) {
/*
* Try to set stdin, stdout, and stderr to /dev/null, but press
* on even if it fails.
@ -148,59 +144,47 @@ named_os_daemonize(void)
}
void
named_os_opendevnull(void)
{
named_os_opendevnull(void) {
devnullfd = open("NUL", O_RDWR, 0);
}
void
named_os_closedevnull(void)
{
named_os_closedevnull(void) {
if (devnullfd != _fileno(stdin) && devnullfd != _fileno(stdout) &&
devnullfd != _fileno(stderr)) {
devnullfd != _fileno(stderr))
{
close(devnullfd);
devnullfd = -1;
}
}
void
named_os_chroot(const char *root)
{
named_os_chroot(const char *root) {
if (root != NULL) {
named_main_earlyfatal("chroot(): isn't supported by Win32 API");
}
}
void
named_os_inituserinfo(const char *username)
{
}
named_os_inituserinfo(const char *username) {}
void
named_os_changeuser(void)
{
}
named_os_changeuser(void) {}
unsigned int
ns_os_uid(void)
{
ns_os_uid(void) {
return (0);
}
void
named_os_adjustnofile(void)
{
}
named_os_adjustnofile(void) {}
void
named_os_minprivs(void)
{
}
named_os_minprivs(void) {}
static int
safe_open(const char *filename, int mode, bool append)
{
int fd;
safe_open(const char *filename, int mode, bool append) {
int fd;
struct stat sb;
if (stat(filename, &sb) == -1) {
@ -221,8 +205,7 @@ safe_open(const char *filename, int mode, bool append)
}
static void
cleanup_pidfile(void)
{
cleanup_pidfile(void) {
if (pidfile != NULL) {
(void)unlink(pidfile);
free(pidfile);
@ -231,8 +214,7 @@ cleanup_pidfile(void)
}
static void
cleanup_lockfile(void)
{
cleanup_lockfile(void) {
if (lockfilefd != -1) {
close(lockfilefd);
lockfilefd = -1;
@ -250,11 +232,10 @@ cleanup_lockfile(void)
}
FILE *
named_os_openfile(const char *filename, int mode, bool switch_user)
{
char strbuf[ISC_STRERRORSIZE];
named_os_openfile(const char *filename, int mode, bool switch_user) {
char strbuf[ISC_STRERRORSIZE];
FILE *fp;
int fd;
int fd;
UNUSED(switch_user);
fd = safe_open(filename, mode, false);
@ -277,11 +258,10 @@ named_os_openfile(const char *filename, int mode, bool switch_user)
}
void
named_os_writepidfile(const char *filename, bool first_time)
{
named_os_writepidfile(const char *filename, bool first_time) {
FILE *pidlockfile;
pid_t pid;
char strbuf[ISC_STRERRORSIZE];
char strbuf[ISC_STRERRORSIZE];
void (*report)(const char *, ...);
/*
@ -329,9 +309,8 @@ named_os_writepidfile(const char *filename, bool first_time)
}
bool
named_os_issingleton(const char *filename)
{
char strbuf[ISC_STRERRORSIZE];
named_os_issingleton(const char *filename) {
char strbuf[ISC_STRERRORSIZE];
OVERLAPPED o;
if (lockfilefd != -1) {
@ -364,7 +343,8 @@ named_os_issingleton(const char *filename)
/* Expect ERROR_LOCK_VIOLATION if already locked */
if (!LockFileEx((HANDLE)_get_osfhandle(lockfilefd),
LOCKFILE_EXCLUSIVE_LOCK | LOCKFILE_FAIL_IMMEDIATELY, 0,
0, 1, &o)) {
0, 1, &o))
{
cleanup_lockfile();
return (false);
}
@ -373,8 +353,7 @@ named_os_issingleton(const char *filename)
}
void
named_os_shutdown(void)
{
named_os_shutdown(void) {
closelog();
cleanup_pidfile();
@ -388,8 +367,7 @@ named_os_shutdown(void)
}
isc_result_t
named_os_gethostname(char *buf, size_t len)
{
named_os_gethostname(char *buf, size_t len) {
int n;
n = gethostname(buf, (int)len);
@ -397,38 +375,34 @@ named_os_gethostname(char *buf, size_t len)
}
void
named_os_shutdownmsg(char *command, isc_buffer_t *text)
{
named_os_shutdownmsg(char *command, isc_buffer_t *text) {
UNUSED(command);
UNUSED(text);
}
void
named_os_tzset(void)
{
named_os_tzset(void) {
#ifdef HAVE_TZSET
tzset();
#endif /* ifdef HAVE_TZSET */
}
void
named_os_started(void)
{
named_os_started(void) {
ntservice_init();
}
static char unamebuf[BUFSIZ];
static char unamebuf[BUFSIZ];
static char *unamep = NULL;
static void
getuname(void)
{
DWORD fvilen;
char * fvi;
getuname(void) {
DWORD fvilen;
char *fvi;
VS_FIXEDFILEINFO *ffi;
UINT ffilen;
SYSTEM_INFO sysinfo;
char * arch;
UINT ffilen;
SYSTEM_INFO sysinfo;
char *arch;
fvi = NULL;
fvilen = GetFileVersionInfoSize("kernel32.dll", 0);
@ -446,7 +420,8 @@ getuname(void)
ffi = NULL;
ffilen = 0;
if ((VerQueryValue(fvi, "\\", &ffi, &ffilen) == 0) || (ffi == NULL) ||
(ffilen == 0)) {
(ffilen == 0))
{
goto err;
}
memset(&sysinfo, 0, sizeof(sysinfo));
@ -488,8 +463,7 @@ err:
* so we had to switch to the recommended way to get the Windows version.
*/
char *
named_os_uname(void)
{
named_os_uname(void) {
if (unamep == NULL) {
getuname();
}

309
bin/named/zoneconf.c
View file

@ -81,15 +81,14 @@ configure_zone_acl(const cfg_obj_t *zconfig, const cfg_obj_t *vconfig,
const cfg_obj_t *config, acl_type_t acltype,
cfg_aclconfctx_t *actx, dns_zone_t *zone,
void (*setzacl)(dns_zone_t *, dns_acl_t *),
void (*clearzacl)(dns_zone_t *))
{
isc_result_t result;
void (*clearzacl)(dns_zone_t *)) {
isc_result_t result;
const cfg_obj_t *maps[5] = { NULL, NULL, NULL, NULL, NULL };
const cfg_obj_t *aclobj = NULL;
int i = 0;
dns_acl_t ** aclp = NULL, *acl = NULL;
const char * aclname;
dns_view_t * view;
int i = 0;
dns_acl_t **aclp = NULL, *acl = NULL;
const char *aclname;
dns_view_t *view;
view = dns_zone_getview(zone);
@ -196,14 +195,13 @@ parse_acl:
*/
static isc_result_t
configure_zone_ssutable(const cfg_obj_t *zconfig, dns_zone_t *zone,
const char *zname)
{
const cfg_obj_t * updatepolicy = NULL;
const char *zname) {
const cfg_obj_t *updatepolicy = NULL;
const cfg_listelt_t *element, *element2;
dns_ssutable_t * table = NULL;
isc_mem_t * mctx = dns_zone_getmctx(zone);
bool autoddns = false;
isc_result_t result;
dns_ssutable_t *table = NULL;
isc_mem_t *mctx = dns_zone_getmctx(zone);
bool autoddns = false;
isc_result_t result;
(void)cfg_map_get(zconfig, "update-policy", &updatepolicy);
@ -213,7 +211,8 @@ configure_zone_ssutable(const cfg_obj_t *zconfig, dns_zone_t *zone,
}
if (cfg_obj_isstring(updatepolicy) &&
strcmp("local", cfg_obj_asstring(updatepolicy)) == 0) {
strcmp("local", cfg_obj_asstring(updatepolicy)) == 0)
{
autoddns = true;
updatepolicy = NULL;
}
@ -224,21 +223,22 @@ configure_zone_ssutable(const cfg_obj_t *zconfig, dns_zone_t *zone,
}
for (element = cfg_list_first(updatepolicy); element != NULL;
element = cfg_list_next(element)) {
const cfg_obj_t * stmt = cfg_listelt_value(element);
const cfg_obj_t * mode = cfg_tuple_get(stmt, "mode");
const cfg_obj_t * identity = cfg_tuple_get(stmt, "identity");
const cfg_obj_t * matchtype = cfg_tuple_get(stmt, "matchtype");
const cfg_obj_t * dname = cfg_tuple_get(stmt, "name");
const cfg_obj_t * typelist = cfg_tuple_get(stmt, "types");
const char * str;
bool grant = false;
bool usezone = false;
element = cfg_list_next(element))
{
const cfg_obj_t *stmt = cfg_listelt_value(element);
const cfg_obj_t *mode = cfg_tuple_get(stmt, "mode");
const cfg_obj_t *identity = cfg_tuple_get(stmt, "identity");
const cfg_obj_t *matchtype = cfg_tuple_get(stmt, "matchtype");
const cfg_obj_t *dname = cfg_tuple_get(stmt, "name");
const cfg_obj_t *typelist = cfg_tuple_get(stmt, "types");
const char *str;
bool grant = false;
bool usezone = false;
dns_ssumatchtype_t mtype = dns_ssumatchtype_name;
dns_fixedname_t fname, fident;
isc_buffer_t b;
dns_rdatatype_t * types;
unsigned int i, n;
dns_fixedname_t fname, fident;
isc_buffer_t b;
dns_rdatatype_t *types;
unsigned int i, n;
str = cfg_obj_asstring(mode);
if (strcasecmp(str, "grant") == 0) {
@ -295,7 +295,8 @@ configure_zone_ssutable(const cfg_obj_t *zconfig, dns_zone_t *zone,
i = 0;
for (element2 = cfg_list_first(typelist); element2 != NULL;
element2 = cfg_list_next(element2)) {
element2 = cfg_list_next(element2))
{
const cfg_obj_t *typeobj;
isc_textregion_t r;
@ -384,20 +385,20 @@ static isc_result_t
configure_staticstub_serveraddrs(const cfg_obj_t *zconfig, dns_zone_t *zone,
dns_rdatalist_t *rdatalist_ns,
dns_rdatalist_t *rdatalist_a,
dns_rdatalist_t *rdatalist_aaaa)
{
dns_rdatalist_t *rdatalist_aaaa) {
const cfg_listelt_t *element;
isc_mem_t * mctx = dns_zone_getmctx(zone);
isc_region_t region, sregion;
dns_rdata_t * rdata;
isc_result_t result = ISC_R_SUCCESS;
isc_mem_t *mctx = dns_zone_getmctx(zone);
isc_region_t region, sregion;
dns_rdata_t *rdata;
isc_result_t result = ISC_R_SUCCESS;
for (element = cfg_list_first(zconfig); element != NULL;
element = cfg_list_next(element)) {
element = cfg_list_next(element))
{
const isc_sockaddr_t *sa;
isc_netaddr_t na;
const cfg_obj_t * address = cfg_listelt_value(element);
dns_rdatalist_t * rdatalist;
isc_netaddr_t na;
const cfg_obj_t *address = cfg_listelt_value(element);
dns_rdatalist_t *rdatalist;
sa = cfg_obj_assockaddr(address);
if (isc_sockaddr_getport(sa) != 0) {
@ -467,21 +468,22 @@ configure_staticstub_serveraddrs(const cfg_obj_t *zconfig, dns_zone_t *zone,
*/
static isc_result_t
configure_staticstub_servernames(const cfg_obj_t *zconfig, dns_zone_t *zone,
dns_rdatalist_t *rdatalist, const char *zname)
{
dns_rdatalist_t *rdatalist,
const char *zname) {
const cfg_listelt_t *element;
isc_mem_t * mctx = dns_zone_getmctx(zone);
dns_rdata_t * rdata;
isc_region_t sregion, region;
isc_result_t result = ISC_R_SUCCESS;
isc_mem_t *mctx = dns_zone_getmctx(zone);
dns_rdata_t *rdata;
isc_region_t sregion, region;
isc_result_t result = ISC_R_SUCCESS;
for (element = cfg_list_first(zconfig); element != NULL;
element = cfg_list_next(element)) {
element = cfg_list_next(element))
{
const cfg_obj_t *obj;
const char * str;
dns_fixedname_t fixed_name;
dns_name_t * nsname;
isc_buffer_t b;
const char *str;
dns_fixedname_t fixed_name;
dns_name_t *nsname;
isc_buffer_t b;
obj = cfg_listelt_value(element);
str = cfg_obj_asstring(obj);
@ -525,22 +527,21 @@ configure_staticstub_servernames(const cfg_obj_t *zconfig, dns_zone_t *zone,
*/
static isc_result_t
configure_staticstub(const cfg_obj_t *zconfig, dns_zone_t *zone,
const char *zname, const char *dbtype)
{
int i = 0;
const char *zname, const char *dbtype) {
int i = 0;
const cfg_obj_t *obj;
isc_mem_t * mctx = dns_zone_getmctx(zone);
dns_db_t * db = NULL;
isc_mem_t *mctx = dns_zone_getmctx(zone);
dns_db_t *db = NULL;
dns_dbversion_t *dbversion = NULL;
dns_dbnode_t * apexnode = NULL;
dns_name_t apexname;
isc_result_t result;
dns_rdataset_t rdataset;
dns_rdatalist_t rdatalist_ns, rdatalist_a, rdatalist_aaaa;
dns_dbnode_t *apexnode = NULL;
dns_name_t apexname;
isc_result_t result;
dns_rdataset_t rdataset;
dns_rdatalist_t rdatalist_ns, rdatalist_a, rdatalist_aaaa;
dns_rdatalist_t *rdatalists[] = { &rdatalist_ns, &rdatalist_a,
&rdatalist_aaaa, NULL };
dns_rdata_t * rdata;
isc_region_t region;
dns_rdata_t *rdata;
isc_region_t region;
/* Create the DB beforehand */
RETERR(dns_db_create(mctx, dbtype, dns_zone_getorigin(zone),
@ -670,10 +671,9 @@ cleanup:
* Convert a config file zone type into a server zone type.
*/
static inline dns_zonetype_t
zonetype_fromconfig(const cfg_obj_t *map)
{
zonetype_fromconfig(const cfg_obj_t *map) {
const cfg_obj_t *obj = NULL;
isc_result_t result;
isc_result_t result;
result = cfg_map_get(map, "type", &obj);
INSIST(result == ISC_R_SUCCESS && obj != NULL);
@ -685,8 +685,7 @@ zonetype_fromconfig(const cfg_obj_t *map)
*/
static isc_result_t
strtoargvsub(isc_mem_t *mctx, char *s, unsigned int *argcp, char ***argvp,
unsigned int n)
{
unsigned int n) {
isc_result_t result;
/* Discard leading whitespace. */
@ -724,15 +723,14 @@ strtoargvsub(isc_mem_t *mctx, char *s, unsigned int *argcp, char ***argvp,
* is modified in-place.
*/
static isc_result_t
strtoargv(isc_mem_t *mctx, char *s, unsigned int *argcp, char ***argvp)
{
strtoargv(isc_mem_t *mctx, char *s, unsigned int *argcp, char ***argvp) {
return (strtoargvsub(mctx, s, argcp, argvp, 0));
}
static void
checknames(dns_zonetype_t ztype, const cfg_obj_t **maps, const cfg_obj_t **objp)
{
const char * zone = NULL;
checknames(dns_zonetype_t ztype, const cfg_obj_t **maps,
const cfg_obj_t **objp) {
const char *zone = NULL;
isc_result_t result;
switch (ztype) {
@ -761,14 +759,13 @@ checknames(dns_zonetype_t ztype, const cfg_obj_t **maps, const cfg_obj_t **objp)
*/
static bool
isself(dns_view_t *myview, dns_tsigkey_t *mykey, const isc_sockaddr_t *srcaddr,
const isc_sockaddr_t *dstaddr, dns_rdataclass_t rdclass, void *arg)
{
const isc_sockaddr_t *dstaddr, dns_rdataclass_t rdclass, void *arg) {
ns_interfacemgr_t *interfacemgr = (ns_interfacemgr_t *)arg;
dns_aclenv_t * env = ns_interfacemgr_getaclenv(interfacemgr);
dns_view_t * view;
dns_tsigkey_t * key = NULL;
isc_netaddr_t netsrc;
isc_netaddr_t netdst;
dns_aclenv_t *env = ns_interfacemgr_getaclenv(interfacemgr);
dns_view_t *view;
dns_tsigkey_t *key = NULL;
isc_netaddr_t netsrc;
isc_netaddr_t netdst;
if (interfacemgr == NULL) {
return (true);
@ -782,7 +779,8 @@ isself(dns_view_t *myview, dns_tsigkey_t *mykey, const isc_sockaddr_t *srcaddr,
isc_netaddr_fromsockaddr(&netdst, dstaddr);
for (view = ISC_LIST_HEAD(named_g_server->viewlist); view != NULL;
view = ISC_LIST_NEXT(view, link)) {
view = ISC_LIST_NEXT(view, link))
{
const dns_name_t *tsig = NULL;
if (view->matchrecursiveonly) {
@ -794,7 +792,7 @@ isself(dns_view_t *myview, dns_tsigkey_t *mykey, const isc_sockaddr_t *srcaddr,
}
if (mykey != NULL) {
bool match;
bool match;
isc_result_t result;
result = dns_view_gettsig(view, &mykey->name, &key);
@ -811,7 +809,8 @@ isself(dns_view_t *myview, dns_tsigkey_t *mykey, const isc_sockaddr_t *srcaddr,
if (dns_acl_allowed(&netsrc, tsig, view->matchclients, env) &&
dns_acl_allowed(&netdst, tsig, view->matchdestinations,
env)) {
env))
{
break;
}
}
@ -825,8 +824,7 @@ isself(dns_view_t *myview, dns_tsigkey_t *mykey, const isc_sockaddr_t *srcaddr,
*/
static dns_notifytype_t
process_notifytype(dns_notifytype_t ntype, dns_zonetype_t ztype,
const char *zname, const cfg_obj_t **maps)
{
const char *zname, const cfg_obj_t **maps) {
const cfg_obj_t *obj = NULL;
/*
@ -855,49 +853,48 @@ isc_result_t
named_zone_configure(const cfg_obj_t *config, const cfg_obj_t *vconfig,
const cfg_obj_t *zconfig, cfg_aclconfctx_t *ac,
dns_kasplist_t *kasplist, dns_zone_t *zone,
dns_zone_t *raw)
{
isc_result_t result;
const char * zname;
dns_rdataclass_t zclass;
dns_rdataclass_t vclass;
const cfg_obj_t * maps[5];
const cfg_obj_t * nodefault[4];
const cfg_obj_t * zoptions = NULL;
const cfg_obj_t * options = NULL;
const cfg_obj_t * obj;
const char * filename = NULL;
const char * kaspname = NULL;
const char * dupcheck;
dns_notifytype_t notifytype = dns_notifytype_yes;
uint32_t count;
unsigned int dbargc;
char ** dbargv;
static char default_dbtype[] = "rbt";
static char dlz_dbtype[] = "dlz";
char * cpval = default_dbtype;
isc_mem_t * mctx = dns_zone_getmctx(zone);
dns_dialuptype_t dialup = dns_dialuptype_no;
dns_zonetype_t ztype;
int i;
int32_t journal_size;
bool multi;
bool alt;
dns_view_t * view = NULL;
dns_kasp_t * kasp = NULL;
bool check = false, fail = false;
bool warn = false, ignore = false;
bool ixfrdiff;
dns_masterformat_t masterformat;
dns_zone_t *raw) {
isc_result_t result;
const char *zname;
dns_rdataclass_t zclass;
dns_rdataclass_t vclass;
const cfg_obj_t *maps[5];
const cfg_obj_t *nodefault[4];
const cfg_obj_t *zoptions = NULL;
const cfg_obj_t *options = NULL;
const cfg_obj_t *obj;
const char *filename = NULL;
const char *kaspname = NULL;
const char *dupcheck;
dns_notifytype_t notifytype = dns_notifytype_yes;
uint32_t count;
unsigned int dbargc;
char **dbargv;
static char default_dbtype[] = "rbt";
static char dlz_dbtype[] = "dlz";
char *cpval = default_dbtype;
isc_mem_t *mctx = dns_zone_getmctx(zone);
dns_dialuptype_t dialup = dns_dialuptype_no;
dns_zonetype_t ztype;
int i;
int32_t journal_size;
bool multi;
bool alt;
dns_view_t *view = NULL;
dns_kasp_t *kasp = NULL;
bool check = false, fail = false;
bool warn = false, ignore = false;
bool ixfrdiff;
dns_masterformat_t masterformat;
const dns_master_style_t *masterstyle = &dns_master_style_default;
isc_stats_t * zoneqrystats;
dns_stats_t * rcvquerystats;
dns_stats_t * dnssecsignstats;
dns_stats_t * dnssecrefreshstats;
dns_zonestat_level_t statlevel = dns_zonestat_none;
int seconds;
dns_zone_t * mayberaw = (raw != NULL) ? raw : zone;
isc_dscp_t dscp;
isc_stats_t *zoneqrystats;
dns_stats_t *rcvquerystats;
dns_stats_t *dnssecsignstats;
dns_stats_t *dnssecrefreshstats;
dns_zonestat_level_t statlevel = dns_zonestat_none;
int seconds;
dns_zone_t *mayberaw = (raw != NULL) ? raw : zone;
isc_dscp_t dscp;
i = 0;
if (zconfig != NULL) {
@ -961,7 +958,7 @@ named_zone_configure(const cfg_obj_t *config, const cfg_obj_t *vconfig,
result = cfg_map_get(zoptions, "dlz", &obj);
if (result == ISC_R_SUCCESS) {
const char *dlzname = cfg_obj_asstring(obj);
size_t len;
size_t len;
if (cpval != default_dbtype) {
isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
@ -1090,7 +1087,7 @@ named_zone_configure(const cfg_obj_t *config, const cfg_obj_t *vconfig,
if (raw != NULL && filename != NULL) {
#define SIGNED ".signed"
size_t signedlen = strlen(filename) + sizeof(SIGNED);
char * signedname;
char *signedname;
RETERR(dns_zone_setfile(raw, filename, masterformat,
masterstyle));
@ -1225,7 +1222,8 @@ named_zone_configure(const cfg_obj_t *config, const cfg_obj_t *vconfig,
* acting as masters (type "slave"), but not to stubs.
*/
if (ztype != dns_zone_stub && ztype != dns_zone_staticstub &&
ztype != dns_zone_redirect) {
ztype != dns_zone_redirect)
{
obj = NULL;
result = named_config_get(maps, "dnssec-policy", &obj);
if (result == ISC_R_SUCCESS) {
@ -1265,8 +1263,8 @@ named_zone_configure(const cfg_obj_t *config, const cfg_obj_t *vconfig,
ISC_UNREACHABLE();
}
}
notifytype =
process_notifytype(notifytype, ztype, zname, nodefault);
notifytype = process_notifytype(notifytype, ztype, zname,
nodefault);
if (raw != NULL) {
dns_zone_setnotifytype(raw, dns_notifytype_no);
}
@ -1278,7 +1276,8 @@ named_zone_configure(const cfg_obj_t *config, const cfg_obj_t *vconfig,
(notifytype == dns_notifytype_yes ||
notifytype == dns_notifytype_explicit ||
(notifytype == dns_notifytype_masteronly &&
ztype == dns_zone_master))) {
ztype == dns_zone_master)))
{
dns_ipkeylist_t ipkl;
dns_ipkeylist_init(&ipkl);
@ -1379,12 +1378,14 @@ named_zone_configure(const cfg_obj_t *config, const cfg_obj_t *vconfig,
ixfrdiff = cfg_obj_asboolean(obj);
} else if ((strcasecmp(cfg_obj_asstring(obj), "primary") == 0 ||
strcasecmp(cfg_obj_asstring(obj), "master") == 0) &&
ztype == dns_zone_master) {
ztype == dns_zone_master)
{
ixfrdiff = true;
} else if ((strcasecmp(cfg_obj_asstring(obj), "secondary") ==
0 ||
strcasecmp(cfg_obj_asstring(obj), "slave") == 0) &&
ztype == dns_zone_slave) {
ztype == dns_zone_slave)
{
ixfrdiff = true;
} else {
ixfrdiff = false;
@ -1525,8 +1526,8 @@ named_zone_configure(const cfg_obj_t *config, const cfg_obj_t *vconfig,
if (ztype == dns_zone_master || raw != NULL) {
const cfg_obj_t *validity, *resign;
bool allow = false, maint = false;
bool sigvalinsecs;
bool allow = false, maint = false;
bool sigvalinsecs;
if (kasp) {
seconds = (uint32_t)dns_kasp_sigvalidity_dnskey(kasp);
@ -1725,8 +1726,8 @@ named_zone_configure(const cfg_obj_t *config, const cfg_obj_t *vconfig,
*/
obj = NULL;
if (masterformat != dns_masterformat_map) {
result =
named_config_get(maps, "check-integrity", &obj);
result = named_config_get(maps, "check-integrity",
&obj);
INSIST(result == ISC_R_SUCCESS && obj != NULL);
dns_zone_setoption(mayberaw, DNS_ZONEOPT_CHECKINTEGRITY,
cfg_obj_asboolean(obj));
@ -1841,7 +1842,8 @@ named_zone_configure(const cfg_obj_t *config, const cfg_obj_t *vconfig,
* explicitly specified and this is a root zone mirror.
*/
if (obj == NULL && ztype == dns_zone_mirror &&
dns_name_equal(dns_zone_getorigin(zone), dns_rootname)) {
dns_name_equal(dns_zone_getorigin(zone), dns_rootname))
{
result = named_config_getmastersdef(
named_g_config, DEFAULT_IANA_ROOT_ZONE_MASTERS,
&obj);
@ -1958,8 +1960,8 @@ named_zone_configure(const cfg_obj_t *config, const cfg_obj_t *vconfig,
* on for BIND 8 compatibility.
*/
view = dns_zone_getview(zone);
if (view != NULL &&
strcmp(view->name, "_default") == 0) {
if (view != NULL && strcmp(view->name, "_default") == 0)
{
alt = true;
} else {
alt = false;
@ -1992,10 +1994,9 @@ named_zone_configure(const cfg_obj_t *config, const cfg_obj_t *vconfig,
*/
isc_result_t
named_zone_configure_writeable_dlz(dns_dlzdb_t *dlzdatabase, dns_zone_t *zone,
dns_rdataclass_t rdclass, dns_name_t *name)
{
dns_db_t * db = NULL;
isc_time_t now;
dns_rdataclass_t rdclass, dns_name_t *name) {
dns_db_t *db = NULL;
isc_time_t now;
isc_result_t result;
TIME_NOW(&now);
@ -2011,15 +2012,14 @@ named_zone_configure_writeable_dlz(dns_dlzdb_t *dlzdatabase, dns_zone_t *zone,
}
bool
named_zone_reusable(dns_zone_t *zone, const cfg_obj_t *zconfig)
{
named_zone_reusable(dns_zone_t *zone, const cfg_obj_t *zconfig) {
const cfg_obj_t *zoptions = NULL;
const cfg_obj_t *obj = NULL;
const char * cfilename;
const char * zfilename;
dns_zone_t * raw = NULL;
bool has_raw;
dns_zonetype_t ztype;
const char *cfilename;
const char *zfilename;
dns_zone_t *raw = NULL;
bool has_raw;
dns_zonetype_t ztype;
zoptions = cfg_tuple_get(zconfig, "options");
@ -2073,7 +2073,8 @@ named_zone_reusable(dns_zone_t *zone, const cfg_obj_t *zconfig)
}
if (!((cfilename == NULL && zfilename == NULL) ||
(cfilename != NULL && zfilename != NULL &&
strcmp(cfilename, zfilename) == 0))) {
strcmp(cfilename, zfilename) == 0)))
{
dns_zone_log(zone, ISC_LOG_DEBUG(1),
"not reusable: filename mismatch");
return (false);

716
bin/nsupdate/nsupdate.c
View file

File diff suppressed because it is too large Load diff

50
bin/pkcs11/pkcs11-destroy.c
View file

@ -65,25 +65,24 @@
#endif /* ifdef WIN32 */
int
main(int argc, char *argv[])
{
isc_result_t result;
CK_RV rv;
CK_SLOT_ID slot = 0;
main(int argc, char *argv[]) {
isc_result_t result;
CK_RV rv;
CK_SLOT_ID slot = 0;
CK_SESSION_HANDLE hSession;
CK_BYTE attr_id[2];
CK_OBJECT_HANDLE akey[50];
pk11_context_t pctx;
char * lib_name = NULL;
char * label = NULL;
char * pin = NULL;
int error = 0;
unsigned int id = 0, i = 0, wait = 5;
int c, errflg = 0;
CK_ULONG ulObjectCount;
CK_ATTRIBUTE search_template[] = { { CKA_ID, &attr_id,
sizeof(attr_id) } };
unsigned int j, len;
CK_BYTE attr_id[2];
CK_OBJECT_HANDLE akey[50];
pk11_context_t pctx;
char *lib_name = NULL;
char *label = NULL;
char *pin = NULL;
int error = 0;
unsigned int id = 0, i = 0, wait = 5;
int c, errflg = 0;
CK_ULONG ulObjectCount;
CK_ATTRIBUTE search_template[] = { { CKA_ID, &attr_id,
sizeof(attr_id) } };
unsigned int j, len;
while ((c = isc_commandline_parse(argc, argv, ":m:s:i:l:p:w:")) != -1) {
switch (c) {
@ -149,7 +148,8 @@ main(int argc, char *argv[])
result = pk11_get_session(&pctx, OP_ANY, false, true, true,
(const char *)pin, slot);
if (result == PK11_R_NORANDOMSERVICE ||
result == PK11_R_NODIGESTSERVICE || result == PK11_R_NOAESSERVICE) {
result == PK11_R_NODIGESTSERVICE || result == PK11_R_NOAESSERVICE)
{
fprintf(stderr, "Warning: %s\n", isc_result_totext(result));
fprintf(stderr, "This HSM will not work with BIND 9 "
"using native PKCS#11.\n");
@ -190,12 +190,12 @@ main(int argc, char *argv[])
for (i = 0; i < ulObjectCount; i++) {
CK_OBJECT_CLASS oclass = 0;
CK_BYTE labelbuf[64 + 1];
CK_BYTE idbuf[64];
CK_ATTRIBUTE attr_template[] = {
{ CKA_CLASS, &oclass, sizeof(oclass) },
{ CKA_LABEL, labelbuf, sizeof(labelbuf) - 1 },
{ CKA_ID, idbuf, sizeof(idbuf) }
CK_BYTE labelbuf[64 + 1];
CK_BYTE idbuf[64];
CK_ATTRIBUTE attr_template[] = {
{ CKA_CLASS, &oclass, sizeof(oclass) },
{ CKA_LABEL, labelbuf, sizeof(labelbuf) - 1 },
{ CKA_ID, idbuf, sizeof(idbuf) }
};
memset(labelbuf, 0, sizeof(labelbuf));

105
bin/pkcs11/pkcs11-keygen.c
View file

@ -83,15 +83,15 @@ typedef enum { key_unknown, key_rsa, key_ecc, key_ecx } key_class_t;
* Private key template: usable for most key classes without
* modificaton; override CKA_SIGN with CKA_DERIVE for DH
*/
#define PRIVATE_LABEL 0
#define PRIVATE_SIGN 1
#define PRIVATE_DERIVE 1
#define PRIVATE_TOKEN 2
#define PRIVATE_PRIVATE 3
#define PRIVATE_SENSITIVE 4
#define PRIVATE_LABEL 0
#define PRIVATE_SIGN 1
#define PRIVATE_DERIVE 1
#define PRIVATE_TOKEN 2
#define PRIVATE_PRIVATE 3
#define PRIVATE_SENSITIVE 4
#define PRIVATE_EXTRACTABLE 5
#define PRIVATE_ID 6
#define PRIVATE_ATTRS 7
#define PRIVATE_ID 6
#define PRIVATE_ATTRS 7
static CK_ATTRIBUTE private_template[] = {
{ CKA_LABEL, NULL_PTR, 0 },
{ CKA_SIGN, &truevalue, sizeof(truevalue) },
@ -105,14 +105,14 @@ static CK_ATTRIBUTE private_template[] = {
/*
* Public key template for RSA keys
*/
#define RSA_LABEL 0
#define RSA_VERIFY 1
#define RSA_TOKEN 2
#define RSA_PRIVATE 3
#define RSA_MODULUS_BITS 4
#define RSA_LABEL 0
#define RSA_VERIFY 1
#define RSA_TOKEN 2
#define RSA_PRIVATE 3
#define RSA_MODULUS_BITS 4
#define RSA_PUBLIC_EXPONENT 5
#define RSA_ID 6
#define RSA_ATTRS 7
#define RSA_ID 6
#define RSA_ATTRS 7
static CK_ATTRIBUTE rsa_template[] = {
{ CKA_LABEL, NULL_PTR, 0 },
{ CKA_VERIFY, &truevalue, sizeof(truevalue) },
@ -126,13 +126,13 @@ static CK_ATTRIBUTE rsa_template[] = {
/*
* Public key template for ECC/ECX keys
*/
#define ECC_LABEL 0
#define ECC_VERIFY 1
#define ECC_TOKEN 2
#define ECC_LABEL 0
#define ECC_VERIFY 1
#define ECC_TOKEN 2
#define ECC_PRIVATE 3
#define ECC_PARAMS 4
#define ECC_ID 5
#define ECC_ATTRS 6
#define ECC_PARAMS 4
#define ECC_ID 5
#define ECC_ATTRS 6
static CK_ATTRIBUTE ecc_template[] = {
{ CKA_LABEL, NULL_PTR, 0 },
{ CKA_VERIFY, &truevalue, sizeof(truevalue) },
@ -148,8 +148,7 @@ static CK_ATTRIBUTE ecc_template[] = {
* NSEC3RSASHA1 maps to RSA.
*/
static key_class_t
keyclass_fromtext(const char *name)
{
keyclass_fromtext(const char *name) {
if (name == NULL) {
return (key_unknown);
}
@ -158,7 +157,8 @@ keyclass_fromtext(const char *name)
strncasecmp(name, "nsec3rsa", 8) == 0) {
return (key_rsa);
} else if (strncasecmp(name, "ecc", 3) == 0 ||
strncasecmp(name, "ecdsa", 5) == 0) {
strncasecmp(name, "ecdsa", 5) == 0)
{
return (key_ecc);
} else if (strncasecmp(name, "ecx", 3) == 0 ||
strncasecmp(name, "ed", 2) == 0) {
@ -169,8 +169,7 @@ keyclass_fromtext(const char *name)
}
static void
usage(void)
{
usage(void) {
fprintf(stderr, "Usage:\n"
"\tpkcs11-keygen -a algorithm -b keysize -l label\n"
"\t [-P] [-m module] "
@ -179,33 +178,32 @@ usage(void)
}
int
main(int argc, char *argv[])
{
isc_result_t result;
CK_RV rv;
CK_SLOT_ID slot = 0;
CK_MECHANISM mech;
main(int argc, char *argv[]) {
isc_result_t result;
CK_RV rv;
CK_SLOT_ID slot = 0;
CK_MECHANISM mech;
CK_SESSION_HANDLE hSession;
char * lib_name = NULL;
char * pin = NULL;
CK_ULONG bits = 0;
CK_CHAR * label = NULL;
CK_OBJECT_HANDLE privatekey, publickey;
CK_BYTE exponent[5];
CK_ULONG expsize = 0;
pk11_context_t pctx;
int error = 0;
int c, errflg = 0;
int hide = 1, quiet = 0;
int idlen = 0, id_offset = 0;
unsigned long id = 0;
CK_BYTE idbuf[4];
CK_ULONG ulObjectCount;
CK_ATTRIBUTE search_template[] = { { CKA_LABEL, NULL_PTR, 0 } };
CK_ATTRIBUTE * public_template = NULL;
CK_ULONG public_attrcnt = 0, private_attrcnt = PRIVATE_ATTRS;
key_class_t keyclass = key_rsa;
pk11_optype_t op_type = OP_ANY;
char *lib_name = NULL;
char *pin = NULL;
CK_ULONG bits = 0;
CK_CHAR *label = NULL;
CK_OBJECT_HANDLE privatekey, publickey;
CK_BYTE exponent[5];
CK_ULONG expsize = 0;
pk11_context_t pctx;
int error = 0;
int c, errflg = 0;
int hide = 1, quiet = 0;
int idlen = 0, id_offset = 0;
unsigned long id = 0;
CK_BYTE idbuf[4];
CK_ULONG ulObjectCount;
CK_ATTRIBUTE search_template[] = { { CKA_LABEL, NULL_PTR, 0 } };
CK_ATTRIBUTE *public_template = NULL;
CK_ULONG public_attrcnt = 0, private_attrcnt = PRIVATE_ATTRS;
key_class_t keyclass = key_rsa;
pk11_optype_t op_type = OP_ANY;
#define OPTIONS ":a:b:ei:l:m:Pp:qSs:"
while ((c = isc_commandline_parse(argc, argv, OPTIONS)) != -1) {
@ -411,7 +409,8 @@ main(int argc, char *argv[])
result = pk11_get_session(&pctx, op_type, false, true, true,
(const char *)pin, slot);
if (result == PK11_R_NORANDOMSERVICE ||
result == PK11_R_NODIGESTSERVICE || result == PK11_R_NOAESSERVICE) {
result == PK11_R_NODIGESTSERVICE || result == PK11_R_NOAESSERVICE)
{
fprintf(stderr, "Warning: %s\n", isc_result_totext(result));
fprintf(stderr, "This HSM will not work with BIND 9 "
"using native PKCS#11.\n");

51
bin/pkcs11/pkcs11-list.c
View file

@ -54,24 +54,23 @@
#include <sys/types.h>
int
main(int argc, char *argv[])
{
isc_result_t result;
CK_RV rv;
CK_SLOT_ID slot = 0;
main(int argc, char *argv[]) {
isc_result_t result;
CK_RV rv;
CK_SLOT_ID slot = 0;
CK_SESSION_HANDLE hSession;
CK_BYTE attr_id[2];
CK_OBJECT_HANDLE akey[50];
pk11_context_t pctx;
char * lib_name = NULL;
char * label = NULL;
char * pin = NULL;
bool error = false, logon = true, all = false;
unsigned int i = 0, id = 0;
int c, errflg = 0;
CK_ULONG ulObjectCount;
CK_ATTRIBUTE search_template[] = { { CKA_ID, &attr_id,
sizeof(attr_id) } };
CK_BYTE attr_id[2];
CK_OBJECT_HANDLE akey[50];
pk11_context_t pctx;
char *lib_name = NULL;
char *label = NULL;
char *pin = NULL;
bool error = false, logon = true, all = false;
unsigned int i = 0, id = 0;
int c, errflg = 0;
CK_ULONG ulObjectCount;
CK_ATTRIBUTE search_template[] = { { CKA_ID, &attr_id,
sizeof(attr_id) } };
while ((c = isc_commandline_parse(argc, argv, ":m:s:i:l:p:P")) != -1) {
switch (c) {
@ -144,10 +143,11 @@ main(int argc, char *argv[])
pin = getpass("Enter Pin: ");
}
result =
pk11_get_session(&pctx, OP_ANY, false, false, logon, pin, slot);
result = pk11_get_session(&pctx, OP_ANY, false, false, logon, pin,
slot);
if (result == PK11_R_NORANDOMSERVICE ||
result == PK11_R_NODIGESTSERVICE || result == PK11_R_NOAESSERVICE) {
result == PK11_R_NODIGESTSERVICE || result == PK11_R_NOAESSERVICE)
{
fprintf(stderr, "Warning: %s\n", isc_result_totext(result));
fprintf(stderr, "This HSM will not work with BIND 9 "
"using native PKCS#11.\n");
@ -188,10 +188,10 @@ main(int argc, char *argv[])
unsigned int j, len;
CK_OBJECT_CLASS oclass = 0;
CK_BYTE labelbuf[64 + 1];
CK_BYTE idbuf[64];
CK_BBOOL extract = TRUE;
CK_BBOOL never = FALSE;
CK_BYTE labelbuf[64 + 1];
CK_BYTE idbuf[64];
CK_BBOOL extract = TRUE;
CK_BBOOL never = FALSE;
CK_ATTRIBUTE template[] = {
{ CKA_CLASS, &oclass, sizeof(oclass) },
{ CKA_LABEL, labelbuf, sizeof(labelbuf) - 1 },
@ -249,7 +249,8 @@ main(int argc, char *argv[])
oclass == CKO_SECRET_KEY) &&
pkcs_C_GetAttributeValue(hSession, akey[i],
priv_template,
2) == CKR_OK) {
2) == CKR_OK)
{
printf(" E:%s",
extract ? "true"
: (never ? "never" : "false"));

14
bin/pkcs11/pkcs11-tokens.c
View file

@ -30,12 +30,11 @@
#include <sys/types.h>
int
main(int argc, char *argv[])
{
isc_result_t result;
char * lib_name = NULL;
int c, errflg = 0;
isc_mem_t * mctx = NULL;
main(int argc, char *argv[]) {
isc_result_t result;
char *lib_name = NULL;
int c, errflg = 0;
isc_mem_t *mctx = NULL;
pk11_context_t pctx;
while ((c = isc_commandline_parse(argc, argv, ":m:v")) != -1) {
@ -76,7 +75,8 @@ main(int argc, char *argv[])
result = pk11_get_session(&pctx, OP_ANY, true, false, false, NULL, 0);
if (result == PK11_R_NORANDOMSERVICE ||
result == PK11_R_NODIGESTSERVICE || result == PK11_R_NOAESSERVICE) {
result == PK11_R_NODIGESTSERVICE || result == PK11_R_NOAESSERVICE)
{
fprintf(stderr, "Warning: %s\n", isc_result_totext(result));
fprintf(stderr, "This HSM will not work with BIND 9 "
"using native PKCS#11.\n\n");

219
bin/plugins/filter-aaaa.c
View file

@ -68,23 +68,23 @@ typedef enum { NONE = 0, FILTER = 1, BREAK_DNSSEC = 2 } filter_aaaa_t;
*/
typedef struct filter_data {
filter_aaaa_t mode;
uint32_t flags;
uint32_t flags;
} filter_data_t;
typedef struct filter_instance {
ns_plugin_t *module;
isc_mem_t * mctx;
isc_mem_t *mctx;
/*
* Memory pool for use with persistent data.
*/
isc_mempool_t *datapool;
isc_mutex_t plock;
isc_mutex_t plock;
/*
* Hash table associating a client object with its persistent data.
*/
isc_ht_t * ht;
isc_ht_t *ht;
isc_mutex_t hlock;
/*
@ -92,36 +92,36 @@ typedef struct filter_instance {
*/
filter_aaaa_t v4_aaaa;
filter_aaaa_t v6_aaaa;
dns_acl_t * aaaa_acl;
dns_acl_t *aaaa_acl;
} filter_instance_t;
/*
* Per-client flags set by this module
*/
#define FILTER_AAAA_RECURSING 0x0001 /* Recursing for A */
#define FILTER_AAAA_FILTERED 0x0002 /* AAAA was removed from answer */
#define FILTER_AAAA_FILTERED 0x0002 /* AAAA was removed from answer */
/*
* Client attribute tests.
*/
#define WANTDNSSEC(c) (((c)->attributes & NS_CLIENTATTR_WANTDNSSEC) != 0)
#define WANTDNSSEC(c) (((c)->attributes & NS_CLIENTATTR_WANTDNSSEC) != 0)
#define RECURSIONOK(c) (((c)->query.attributes & NS_QUERYATTR_RECURSIONOK) != 0)
/*
* Forward declarations of functions referenced in install_hooks().
*/
static ns_hookresult_t
filter_qctx_initialize(void *arg, void *cbdata, isc_result_t *resp);
static ns_hookresult_t
filter_respond_begin(void *arg, void *cbdata, isc_result_t *resp);
static ns_hookresult_t
filter_respond_any_found(void *arg, void *cbdata, isc_result_t *resp);
static ns_hookresult_t
filter_prep_response_begin(void *arg, void *cbdata, isc_result_t *resp);
static ns_hookresult_t
filter_query_done_send(void *arg, void *cbdata, isc_result_t *resp);
static ns_hookresult_t
filter_qctx_destroy(void *arg, void *cbdata, isc_result_t *resp);
static ns_hookresult_t filter_qctx_initialize(void *arg, void *cbdata,
isc_result_t *resp);
static ns_hookresult_t filter_respond_begin(void *arg, void *cbdata,
isc_result_t *resp);
static ns_hookresult_t filter_respond_any_found(void *arg, void *cbdata,
isc_result_t *resp);
static ns_hookresult_t filter_prep_response_begin(void *arg, void *cbdata,
isc_result_t *resp);
static ns_hookresult_t filter_query_done_send(void *arg, void *cbdata,
isc_result_t *resp);
static ns_hookresult_t filter_qctx_destroy(void *arg, void *cbdata,
isc_result_t *resp);
/*%
* Register the functions to be called at each hook point in 'hooktable', using
@ -131,8 +131,7 @@ filter_qctx_destroy(void *arg, void *cbdata, isc_result_t *resp);
*/
static void
install_hooks(ns_hooktable_t *hooktable, isc_mem_t *mctx,
filter_instance_t *inst)
{
filter_instance_t *inst) {
const ns_hook_t filter_init = {
.action = filter_qctx_initialize,
.action_data = inst,
@ -183,14 +182,12 @@ install_hooks(ns_hooktable_t *hooktable, isc_mem_t *mctx,
static const char *filter_aaaa_enums[] = { "break-dnssec", NULL };
static isc_result_t
parse_filter_aaaa(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret)
{
parse_filter_aaaa(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret) {
return (cfg_parse_enum_or_other(pctx, type, &cfg_type_boolean, ret));
}
static void
doc_filter_aaaa(cfg_printer_t *pctx, const cfg_type_t *type)
{
doc_filter_aaaa(cfg_printer_t *pctx, const cfg_type_t *type) {
cfg_doc_enum_or_other(pctx, type, &cfg_type_boolean);
}
@ -214,10 +211,9 @@ static cfg_type_t cfg_type_parameters = {
static isc_result_t
parse_filter_aaaa_on(const cfg_obj_t *param_obj, const char *param_name,
filter_aaaa_t *dstp)
{
filter_aaaa_t *dstp) {
const cfg_obj_t *obj = NULL;
isc_result_t result;
isc_result_t result;
result = cfg_map_get(param_obj, param_name, &obj);
if (result != ISC_R_SUCCESS) {
@ -241,12 +237,11 @@ parse_filter_aaaa_on(const cfg_obj_t *param_obj, const char *param_name,
static isc_result_t
check_syntax(cfg_obj_t *fmap, const void *cfg, isc_mem_t *mctx, isc_log_t *lctx,
void *actx)
{
isc_result_t result = ISC_R_SUCCESS;
void *actx) {
isc_result_t result = ISC_R_SUCCESS;
const cfg_obj_t *aclobj = NULL;
dns_acl_t * acl = NULL;
filter_aaaa_t f4 = NONE, f6 = NONE;
dns_acl_t *acl = NULL;
filter_aaaa_t f4 = NONE, f6 = NONE;
cfg_map_get(fmap, "filter-aaaa", &aclobj);
if (aclobj == NULL) {
@ -284,13 +279,12 @@ cleanup:
static isc_result_t
parse_parameters(filter_instance_t *inst, const char *parameters,
const void *cfg, const char *cfg_file, unsigned long cfg_line,
isc_mem_t *mctx, isc_log_t *lctx, void *actx)
{
isc_result_t result = ISC_R_SUCCESS;
cfg_parser_t * parser = NULL;
cfg_obj_t * param_obj = NULL;
isc_mem_t *mctx, isc_log_t *lctx, void *actx) {
isc_result_t result = ISC_R_SUCCESS;
cfg_parser_t *parser = NULL;
cfg_obj_t *param_obj = NULL;
const cfg_obj_t *obj = NULL;
isc_buffer_t b;
isc_buffer_t b;
CHECK(cfg_parser_create(mctx, lctx, &parser));
@ -341,10 +335,9 @@ cleanup:
isc_result_t
plugin_register(const char *parameters, const void *cfg, const char *cfg_file,
unsigned long cfg_line, isc_mem_t *mctx, isc_log_t *lctx,
void *actx, ns_hooktable_t *hooktable, void **instp)
{
void *actx, ns_hooktable_t *hooktable, void **instp) {
filter_instance_t *inst = NULL;
isc_result_t result;
isc_result_t result;
isc_log_write(lctx, NS_LOGCATEGORY_GENERAL, NS_LOGMODULE_HOOKS,
ISC_LOG_INFO,
@ -398,12 +391,11 @@ cleanup:
isc_result_t
plugin_check(const char *parameters, const void *cfg, const char *cfg_file,
unsigned long cfg_line, isc_mem_t *mctx, isc_log_t *lctx,
void *actx)
{
isc_result_t result = ISC_R_SUCCESS;
void *actx) {
isc_result_t result = ISC_R_SUCCESS;
cfg_parser_t *parser = NULL;
cfg_obj_t * param_obj = NULL;
isc_buffer_t b;
cfg_obj_t *param_obj = NULL;
isc_buffer_t b;
CHECK(cfg_parser_create(mctx, lctx, &parser));
@ -429,8 +421,7 @@ cleanup:
* the module when it was registered.
*/
void
plugin_destroy(void **instp)
{
plugin_destroy(void **instp) {
filter_instance_t *inst = (filter_instance_t *)*instp;
if (inst->ht != NULL) {
@ -455,8 +446,7 @@ plugin_destroy(void **instp)
* Returns plugin API version for compatibility checks.
*/
int
plugin_version(void)
{
plugin_version(void) {
return (NS_PLUGIN_VERSION);
}
@ -468,25 +458,25 @@ plugin_version(void)
* Structure describing the filtering to be applied by process_section().
*/
typedef struct section_filter {
query_ctx_t * qctx;
filter_aaaa_t mode;
dns_section_t section;
query_ctx_t *qctx;
filter_aaaa_t mode;
dns_section_t section;
const dns_name_t *name;
dns_rdatatype_t type;
bool only_if_a_exists;
dns_rdatatype_t type;
bool only_if_a_exists;
} section_filter_t;
/*
* Check whether this is an IPv4 client.
*/
static bool
is_v4_client(ns_client_t *client)
{
is_v4_client(ns_client_t *client) {
if (isc_sockaddr_pf(&client->peeraddr) == AF_INET) {
return (true);
}
if (isc_sockaddr_pf(&client->peeraddr) == AF_INET6 &&
IN6_IS_ADDR_V4MAPPED(&client->peeraddr.type.sin6.sin6_addr)) {
IN6_IS_ADDR_V4MAPPED(&client->peeraddr.type.sin6.sin6_addr))
{
return (true);
}
return (false);
@ -496,20 +486,19 @@ is_v4_client(ns_client_t *client)
* Check whether this is an IPv6 client.
*/
static bool
is_v6_client(ns_client_t *client)
{
is_v6_client(ns_client_t *client) {
if (isc_sockaddr_pf(&client->peeraddr) == AF_INET6 &&
!IN6_IS_ADDR_V4MAPPED(&client->peeraddr.type.sin6.sin6_addr)) {
!IN6_IS_ADDR_V4MAPPED(&client->peeraddr.type.sin6.sin6_addr))
{
return (true);
}
return (false);
}
static filter_data_t *
client_state_get(const query_ctx_t *qctx, filter_instance_t *inst)
{
client_state_get(const query_ctx_t *qctx, filter_instance_t *inst) {
filter_data_t *client_state = NULL;
isc_result_t result;
isc_result_t result;
LOCK(&inst->hlock);
result = isc_ht_find(inst->ht, (const unsigned char *)&qctx->client,
@ -520,10 +509,9 @@ client_state_get(const query_ctx_t *qctx, filter_instance_t *inst)
}
static void
client_state_create(const query_ctx_t *qctx, filter_instance_t *inst)
{
client_state_create(const query_ctx_t *qctx, filter_instance_t *inst) {
filter_data_t *client_state;
isc_result_t result;
isc_result_t result;
client_state = isc_mempool_get(inst->datapool);
if (client_state == NULL) {
@ -541,10 +529,9 @@ client_state_create(const query_ctx_t *qctx, filter_instance_t *inst)
}
static void
client_state_destroy(const query_ctx_t *qctx, filter_instance_t *inst)
{
client_state_destroy(const query_ctx_t *qctx, filter_instance_t *inst) {
filter_data_t *client_state = client_state_get(qctx, inst);
isc_result_t result;
isc_result_t result;
if (client_state == NULL) {
return;
@ -564,8 +551,7 @@ client_state_destroy(const query_ctx_t *qctx, filter_instance_t *inst)
* pointers and non-associated rdatasets.
*/
static void
mark_as_rendered(dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset)
{
mark_as_rendered(dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset) {
if (rdataset != NULL && dns_rdataset_isassociated(rdataset)) {
rdataset->attributes |= DNS_RDATASETATTR_RENDERED;
}
@ -585,11 +571,10 @@ mark_as_rendered(dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset)
*/
static bool
process_name(query_ctx_t *qctx, filter_aaaa_t mode, const dns_name_t *name,
dns_rdatatype_t type, bool only_if_a_exists)
{
dns_rdatatype_t type, bool only_if_a_exists) {
dns_rdataset_t *rdataset = NULL, *sigrdataset = NULL;
isc_result_t result;
bool modified = false;
isc_result_t result;
bool modified = false;
if (only_if_a_exists) {
CHECK(dns_message_findtype(name, dns_rdatatype_a, 0, NULL));
@ -601,7 +586,8 @@ process_name(query_ctx_t *qctx, filter_aaaa_t mode, const dns_name_t *name,
if (rdataset != NULL &&
(sigrdataset == NULL || !WANTDNSSEC(qctx->client) ||
mode == BREAK_DNSSEC)) {
mode == BREAK_DNSSEC))
{
/*
* An RRset of given 'type' was found at 'name' and at least
* one of the following is true:
@ -631,21 +617,21 @@ cleanup:
* process_name().
*/
static void
process_section(const section_filter_t *filter)
{
query_ctx_t * qctx = filter->qctx;
filter_aaaa_t mode = filter->mode;
dns_section_t section = filter->section;
process_section(const section_filter_t *filter) {
query_ctx_t *qctx = filter->qctx;
filter_aaaa_t mode = filter->mode;
dns_section_t section = filter->section;
const dns_name_t *name = filter->name;
dns_rdatatype_t type = filter->type;
bool only_if_a_exists = filter->only_if_a_exists;
dns_rdatatype_t type = filter->type;
bool only_if_a_exists = filter->only_if_a_exists;
dns_message_t *message = qctx->client->message;
isc_result_t result;
isc_result_t result;
for (result = dns_message_firstname(message, section);
result == ISC_R_SUCCESS;
result = dns_message_nextname(message, section)) {
result = dns_message_nextname(message, section))
{
dns_name_t *cur = NULL;
dns_message_currentname(message, section, &cur);
if (name != NULL && !dns_name_equal(name, cur)) {
@ -676,11 +662,10 @@ process_section(const section_filter_t *filter)
* object persists.
*/
static ns_hookresult_t
filter_qctx_initialize(void *arg, void *cbdata, isc_result_t *resp)
{
query_ctx_t * qctx = (query_ctx_t *)arg;
filter_qctx_initialize(void *arg, void *cbdata, isc_result_t *resp) {
query_ctx_t *qctx = (query_ctx_t *)arg;
filter_instance_t *inst = (filter_instance_t *)cbdata;
filter_data_t * client_state;
filter_data_t *client_state;
*resp = ISC_R_UNSET;
@ -698,12 +683,11 @@ filter_qctx_initialize(void *arg, void *cbdata, isc_result_t *resp)
* filter-aaaa-on-v6.
*/
static ns_hookresult_t
filter_prep_response_begin(void *arg, void *cbdata, isc_result_t *resp)
{
query_ctx_t * qctx = (query_ctx_t *)arg;
filter_prep_response_begin(void *arg, void *cbdata, isc_result_t *resp) {
query_ctx_t *qctx = (query_ctx_t *)arg;
filter_instance_t *inst = (filter_instance_t *)cbdata;
filter_data_t * client_state = client_state_get(qctx, inst);
isc_result_t result;
filter_data_t *client_state = client_state_get(qctx, inst);
isc_result_t result;
*resp = ISC_R_UNSET;
@ -715,10 +699,12 @@ filter_prep_response_begin(void *arg, void *cbdata, isc_result_t *resp)
result = ns_client_checkaclsilent(qctx->client, NULL,
inst->aaaa_acl, true);
if (result == ISC_R_SUCCESS && inst->v4_aaaa != NONE &&
is_v4_client(qctx->client)) {
is_v4_client(qctx->client))
{
client_state->mode = inst->v4_aaaa;
} else if (result == ISC_R_SUCCESS && inst->v6_aaaa != NONE &&
is_v6_client(qctx->client)) {
is_v6_client(qctx->client))
{
client_state->mode = inst->v6_aaaa;
}
}
@ -734,12 +720,11 @@ filter_prep_response_begin(void *arg, void *cbdata, isc_result_t *resp)
* queries are handled in filter_respond_any_found().)
*/
static ns_hookresult_t
filter_respond_begin(void *arg, void *cbdata, isc_result_t *resp)
{
query_ctx_t * qctx = (query_ctx_t *)arg;
filter_respond_begin(void *arg, void *cbdata, isc_result_t *resp) {
query_ctx_t *qctx = (query_ctx_t *)arg;
filter_instance_t *inst = (filter_instance_t *)cbdata;
filter_data_t * client_state = client_state_get(qctx, inst);
isc_result_t result = ISC_R_UNSET;
filter_data_t *client_state = client_state_get(qctx, inst);
isc_result_t result = ISC_R_UNSET;
*resp = ISC_R_UNSET;
@ -750,7 +735,8 @@ filter_respond_begin(void *arg, void *cbdata, isc_result_t *resp)
if (client_state->mode != BREAK_DNSSEC &&
(client_state->mode != FILTER ||
(WANTDNSSEC(qctx->client) && qctx->sigrdataset != NULL &&
dns_rdataset_isassociated(qctx->sigrdataset)))) {
dns_rdataset_isassociated(qctx->sigrdataset))))
{
return (NS_HOOK_CONTINUE);
}
@ -786,7 +772,8 @@ filter_respond_begin(void *arg, void *cbdata, isc_result_t *resp)
client_state->flags |= FILTER_AAAA_FILTERED;
} else if (!qctx->authoritative && RECURSIONOK(qctx->client) &&
(result == DNS_R_DELEGATION ||
result == ISC_R_NOTFOUND)) {
result == ISC_R_NOTFOUND))
{
/*
* This is an ugly kludge to recurse
* for the A and discard the result.
@ -805,7 +792,8 @@ filter_respond_begin(void *arg, void *cbdata, isc_result_t *resp)
}
}
} else if (qctx->qtype == dns_rdatatype_a &&
(client_state->flags & FILTER_AAAA_RECURSING) != 0) {
(client_state->flags & FILTER_AAAA_RECURSING) != 0)
{
const section_filter_t filter_answer = {
.qctx = qctx,
.mode = client_state->mode,
@ -832,11 +820,10 @@ filter_respond_begin(void *arg, void *cbdata, isc_result_t *resp)
* When answering an ANY query, remove AAAA if A is present.
*/
static ns_hookresult_t
filter_respond_any_found(void *arg, void *cbdata, isc_result_t *resp)
{
query_ctx_t * qctx = (query_ctx_t *)arg;
filter_respond_any_found(void *arg, void *cbdata, isc_result_t *resp) {
query_ctx_t *qctx = (query_ctx_t *)arg;
filter_instance_t *inst = (filter_instance_t *)cbdata;
filter_data_t * client_state = client_state_get(qctx, inst);
filter_data_t *client_state = client_state_get(qctx, inst);
*resp = ISC_R_UNSET;
@ -868,11 +855,10 @@ filter_respond_any_found(void *arg, void *cbdata, isc_result_t *resp)
* section.
*/
static ns_hookresult_t
filter_query_done_send(void *arg, void *cbdata, isc_result_t *resp)
{
query_ctx_t * qctx = (query_ctx_t *)arg;
filter_query_done_send(void *arg, void *cbdata, isc_result_t *resp) {
query_ctx_t *qctx = (query_ctx_t *)arg;
filter_instance_t *inst = (filter_instance_t *)cbdata;
filter_data_t * client_state = client_state_get(qctx, inst);
filter_data_t *client_state = client_state_get(qctx, inst);
*resp = ISC_R_UNSET;
@ -905,9 +891,8 @@ filter_query_done_send(void *arg, void *cbdata, isc_result_t *resp)
* from hash table and return it to the memory pool.
*/
static ns_hookresult_t
filter_qctx_destroy(void *arg, void *cbdata, isc_result_t *resp)
{
query_ctx_t * qctx = (query_ctx_t *)arg;
filter_qctx_destroy(void *arg, void *cbdata, isc_result_t *resp) {
query_ctx_t *qctx = (query_ctx_t *)arg;
filter_instance_t *inst = (filter_instance_t *)cbdata;
*resp = ISC_R_UNSET;

216
bin/rndc/rndc.c
View file

@ -53,46 +53,44 @@
#define SERVERADDRS 10
const char *progname;
bool verbose;
bool verbose;
static const char * admin_conffile;
static const char * admin_keyfile;
static const char * version = VERSION;
static const char * servername = NULL;
static isc_sockaddr_t serveraddrs[SERVERADDRS];
static isc_sockaddr_t local4, local6;
static bool local4set = false, local6set = false;
static int nserveraddrs;
static int currentaddr = 0;
static unsigned int remoteport = 0;
static isc_socketmgr_t * socketmgr = NULL;
static isc_buffer_t * databuf;
static isccc_ccmsg_t ccmsg;
static uint32_t algorithm;
static isccc_region_t secret;
static bool failed = false;
static bool c_flag = false;
static isc_mem_t * rndc_mctx;
static const char *admin_conffile;
static const char *admin_keyfile;
static const char *version = VERSION;
static const char *servername = NULL;
static isc_sockaddr_t serveraddrs[SERVERADDRS];
static isc_sockaddr_t local4, local6;
static bool local4set = false, local6set = false;
static int nserveraddrs;
static int currentaddr = 0;
static unsigned int remoteport = 0;
static isc_socketmgr_t *socketmgr = NULL;
static isc_buffer_t *databuf;
static isccc_ccmsg_t ccmsg;
static uint32_t algorithm;
static isccc_region_t secret;
static bool failed = false;
static bool c_flag = false;
static isc_mem_t *rndc_mctx;
static atomic_uint_fast32_t sends = ATOMIC_VAR_INIT(0);
static atomic_uint_fast32_t recvs = ATOMIC_VAR_INIT(0);
static atomic_uint_fast32_t connects = ATOMIC_VAR_INIT(0);
static char * command;
static char * args;
static char program[256];
static isc_socket_t * sock = NULL;
static uint32_t serial;
static bool quiet = false;
static bool showresult = false;
static char *command;
static char *args;
static char program[256];
static isc_socket_t *sock = NULL;
static uint32_t serial;
static bool quiet = false;
static bool showresult = false;
static void
rndc_startconnect(isc_sockaddr_t *addr, isc_task_t *task);
static void rndc_startconnect(isc_sockaddr_t *addr, isc_task_t *task);
ISC_PLATFORM_NORETURN_PRE static void
usage(int status) ISC_PLATFORM_NORETURN_POST;
static void
usage(int status)
{
usage(int status) {
fprintf(stderr, "\
Usage: %s [-b address] [-c config] [-s server] [-p port]\n\
[-k key-file ] [-y key] [-r] [-V] [-4 | -6] command\n\
@ -219,10 +217,9 @@ Version: %s\n",
#define CMDLINE_FLAGS "46b:c:hk:Mmp:qrs:Vy:"
static void
preparse_args(int argc, char **argv)
{
preparse_args(int argc, char **argv) {
bool ipv4only = false, ipv6only = false;
int ch;
int ch;
while ((ch = isc_commandline_parse(argc, argv, CMDLINE_FLAGS)) != -1) {
switch (ch) {
@ -248,14 +245,13 @@ preparse_args(int argc, char **argv)
}
static void
get_addresses(const char *host, in_port_t port)
{
get_addresses(const char *host, in_port_t port) {
isc_result_t result;
int found = 0, count;
int found = 0, count;
if (*host == '/') {
result =
isc_sockaddr_frompath(&serveraddrs[nserveraddrs], host);
result = isc_sockaddr_frompath(&serveraddrs[nserveraddrs],
host);
if (result == ISC_R_SUCCESS) {
nserveraddrs++;
}
@ -273,8 +269,7 @@ get_addresses(const char *host, in_port_t port)
}
static void
rndc_senddone(isc_task_t *task, isc_event_t *event)
{
rndc_senddone(isc_task_t *task, isc_event_t *event) {
isc_socketevent_t *sevent = (isc_socketevent_t *)event;
UNUSED(task);
@ -284,7 +279,8 @@ rndc_senddone(isc_task_t *task, isc_event_t *event)
}
isc_event_free(&event);
if (atomic_fetch_sub_release(&sends, 1) == 1 &&
atomic_load_acquire(&recvs) == 0) {
atomic_load_acquire(&recvs) == 0)
{
isc_socket_detach(&sock);
isc_task_shutdown(task);
isc_app_shutdown();
@ -292,14 +288,13 @@ rndc_senddone(isc_task_t *task, isc_event_t *event)
}
static void
rndc_recvdone(isc_task_t *task, isc_event_t *event)
{
rndc_recvdone(isc_task_t *task, isc_event_t *event) {
isccc_sexpr_t *response = NULL;
isccc_sexpr_t *data;
isccc_region_t source;
char * errormsg = NULL;
char * textmsg = NULL;
isc_result_t result;
char *errormsg = NULL;
char *textmsg = NULL;
isc_result_t result;
atomic_fetch_sub_release(&recvs, 1);
@ -369,18 +364,17 @@ rndc_recvdone(isc_task_t *task, isc_event_t *event)
}
static void
rndc_recvnonce(isc_task_t *task, isc_event_t *event)
{
rndc_recvnonce(isc_task_t *task, isc_event_t *event) {
isccc_sexpr_t *response = NULL;
isccc_sexpr_t *_ctrl;
isccc_region_t source;
isc_result_t result;
uint32_t nonce;
isc_result_t result;
uint32_t nonce;
isccc_sexpr_t *request = NULL;
isccc_time_t now;
isc_region_t r;
isccc_time_t now;
isc_region_t r;
isccc_sexpr_t *data;
isc_buffer_t b;
isc_buffer_t b;
atomic_fetch_sub_release(&recvs, 1);
@ -463,16 +457,15 @@ rndc_recvnonce(isc_task_t *task, isc_event_t *event)
}
static void
rndc_connected(isc_task_t *task, isc_event_t *event)
{
char socktext[ISC_SOCKADDR_FORMATSIZE];
rndc_connected(isc_task_t *task, isc_event_t *event) {
char socktext[ISC_SOCKADDR_FORMATSIZE];
isc_socketevent_t *sevent = (isc_socketevent_t *)event;
isccc_sexpr_t * request = NULL;
isccc_sexpr_t * data;
isccc_time_t now;
isc_region_t r;
isc_buffer_t b;
isc_result_t result;
isccc_sexpr_t *request = NULL;
isccc_sexpr_t *data;
isccc_time_t now;
isc_region_t r;
isc_buffer_t b;
isc_result_t result;
atomic_fetch_sub_release(&connects, 1);
@ -531,10 +524,9 @@ rndc_connected(isc_task_t *task, isc_event_t *event)
}
static void
rndc_startconnect(isc_sockaddr_t *addr, isc_task_t *task)
{
isc_result_t result;
int pf;
rndc_startconnect(isc_sockaddr_t *addr, isc_task_t *task) {
isc_result_t result;
int pf;
isc_sockettype_t type;
char socktext[ISC_SOCKADDR_FORMATSIZE];
@ -566,8 +558,7 @@ rndc_startconnect(isc_sockaddr_t *addr, isc_task_t *task)
}
static void
rndc_start(isc_task_t *task, isc_event_t *event)
{
rndc_start(isc_task_t *task, isc_event_t *event) {
isc_event_free(&event);
currentaddr = 0;
@ -576,28 +567,27 @@ rndc_start(isc_task_t *task, isc_event_t *event)
static void
parse_config(isc_mem_t *mctx, isc_log_t *log, const char *keyname,
cfg_parser_t **pctxp, cfg_obj_t **configp)
{
isc_result_t result;
const char * conffile = admin_conffile;
const cfg_obj_t * addresses = NULL;
const cfg_obj_t * defkey = NULL;
const cfg_obj_t * options = NULL;
const cfg_obj_t * servers = NULL;
const cfg_obj_t * server = NULL;
const cfg_obj_t * keys = NULL;
const cfg_obj_t * key = NULL;
const cfg_obj_t * defport = NULL;
const cfg_obj_t * secretobj = NULL;
const cfg_obj_t * algorithmobj = NULL;
cfg_obj_t * config = NULL;
const cfg_obj_t * address = NULL;
cfg_parser_t **pctxp, cfg_obj_t **configp) {
isc_result_t result;
const char *conffile = admin_conffile;
const cfg_obj_t *addresses = NULL;
const cfg_obj_t *defkey = NULL;
const cfg_obj_t *options = NULL;
const cfg_obj_t *servers = NULL;
const cfg_obj_t *server = NULL;
const cfg_obj_t *keys = NULL;
const cfg_obj_t *key = NULL;
const cfg_obj_t *defport = NULL;
const cfg_obj_t *secretobj = NULL;
const cfg_obj_t *algorithmobj = NULL;
cfg_obj_t *config = NULL;
const cfg_obj_t *address = NULL;
const cfg_listelt_t *elt;
const char * secretstr;
const char * algorithmstr;
static char secretarray[1024];
const cfg_type_t * conftype = &cfg_type_rndcconf;
bool key_only = false;
const char *secretstr;
const char *algorithmstr;
static char secretarray[1024];
const cfg_type_t *conftype = &cfg_type_rndcconf;
bool key_only = false;
const cfg_listelt_t *element;
if (!isc_file_exists(conffile)) {
@ -760,13 +750,14 @@ parse_config(isc_mem_t *mctx, isc_log_t *log, const char *keyname,
}
if (result == ISC_R_SUCCESS) {
for (element = cfg_list_first(addresses); element != NULL;
element = cfg_list_next(element)) {
element = cfg_list_next(element))
{
isc_sockaddr_t sa;
address = cfg_listelt_value(element);
if (!cfg_obj_issockaddr(address)) {
unsigned int myport;
const char * name;
unsigned int myport;
const char *name;
const cfg_obj_t *obj;
obj = cfg_tuple_get(address, "name");
@ -774,8 +765,8 @@ parse_config(isc_mem_t *mctx, isc_log_t *log, const char *keyname,
obj = cfg_tuple_get(address, "port");
if (cfg_obj_isuint32(obj)) {
myport = cfg_obj_asuint32(obj);
if (myport > UINT16_MAX ||
myport == 0) {
if (myport > UINT16_MAX || myport == 0)
{
fatal("port %u out of range",
myport);
}
@ -848,24 +839,23 @@ parse_config(isc_mem_t *mctx, isc_log_t *log, const char *keyname,
}
int
main(int argc, char **argv)
{
isc_result_t result = ISC_R_SUCCESS;
bool show_final_mem = false;
isc_taskmgr_t * taskmgr = NULL;
isc_task_t * task = NULL;
isc_log_t * log = NULL;
isc_logconfig_t * logconfig = NULL;
main(int argc, char **argv) {
isc_result_t result = ISC_R_SUCCESS;
bool show_final_mem = false;
isc_taskmgr_t *taskmgr = NULL;
isc_task_t *task = NULL;
isc_log_t *log = NULL;
isc_logconfig_t *logconfig = NULL;
isc_logdestination_t logdest;
cfg_parser_t * pctx = NULL;
cfg_obj_t * config = NULL;
const char * keyname = NULL;
struct in_addr in;
struct in6_addr in6;
char * p;
size_t argslen;
int ch;
int i;
cfg_parser_t *pctx = NULL;
cfg_obj_t *config = NULL;
const char *keyname = NULL;
struct in_addr in;
struct in6_addr in6;
char *p;
size_t argslen;
int ch;
int i;
result = isc_file_progname(*argv, program, sizeof(program));
if (result != ISC_R_SUCCESS) {
@ -1057,8 +1047,8 @@ main(int argc, char **argv)
}
if (atomic_load_acquire(&connects) > 0 ||
atomic_load_acquire(&sends) > 0 ||
atomic_load_acquire(&recvs) > 0) {
atomic_load_acquire(&sends) > 0 || atomic_load_acquire(&recvs) > 0)
{
isc_socket_cancel(sock, task, ISC_SOCKCANCEL_ALL);
}

8
bin/rndc/util.c
View file

@ -20,12 +20,11 @@
#include <isc/print.h>
extern bool verbose;
extern bool verbose;
extern const char *progname;
void
notify(const char *fmt, ...)
{
notify(const char *fmt, ...) {
va_list ap;
if (verbose) {
@ -37,8 +36,7 @@ notify(const char *fmt, ...)
}
void
fatal(const char *format, ...)
{
fatal(const char *format, ...) {
va_list args;
fprintf(stderr, "%s: ", progname);

36
bin/tests/cfg_test.c
View file

@ -26,8 +26,7 @@
#include <isccfg/namedconf.h>
static void
check_result(isc_result_t result, const char *format, ...)
{
check_result(isc_result_t result, const char *format, ...) {
va_list args;
if (result == ISC_R_SUCCESS) {
@ -42,15 +41,13 @@ check_result(isc_result_t result, const char *format, ...)
}
static void
output(void *closure, const char *text, int textlen)
{
output(void *closure, const char *text, int textlen) {
UNUSED(closure);
(void)fwrite(text, 1, textlen, stdout);
}
static void
usage(void)
{
usage(void) {
fprintf(stderr, "usage: cfg_test --rndc|--named "
"[--grammar] [--zonegrammar] [--active] "
"[--memstats] conffile\n");
@ -58,21 +55,20 @@ usage(void)
}
int
main(int argc, char **argv)
{
isc_result_t result;
isc_mem_t * mctx = NULL;
isc_log_t * lctx = NULL;
isc_logconfig_t * lcfg = NULL;
main(int argc, char **argv) {
isc_result_t result;
isc_mem_t *mctx = NULL;
isc_log_t *lctx = NULL;
isc_logconfig_t *lcfg = NULL;
isc_logdestination_t destination;
cfg_parser_t * pctx = NULL;
cfg_obj_t * cfg = NULL;
cfg_type_t * type = NULL;
bool grammar = false;
bool memstats = false;
char * filename = NULL;
unsigned int zonetype = 0;
unsigned int pflags = 0;
cfg_parser_t *pctx = NULL;
cfg_obj_t *cfg = NULL;
cfg_type_t *type = NULL;
bool grammar = false;
bool memstats = false;
char *filename = NULL;
unsigned int zonetype = 0;
unsigned int pflags = 0;
isc_mem_create(&mctx);

18
bin/tests/makejournal.c
View file

@ -54,11 +54,10 @@ static isc_logcategory_t categories[] = { { "", 0 },
{ NULL, 0 } };
static isc_result_t
loadzone(dns_db_t **db, const char *origin, const char *filename)
{
isc_result_t result;
loadzone(dns_db_t **db, const char *origin, const char *filename) {
isc_result_t result;
dns_fixedname_t fixed;
dns_name_t * name;
dns_name_t *name;
name = dns_fixedname_initname(&fixed);
@ -78,13 +77,12 @@ loadzone(dns_db_t **db, const char *origin, const char *filename)
}
int
main(int argc, char **argv)
{
isc_result_t result;
char * origin, *file1, *file2, *journal;
dns_db_t * olddb = NULL, *newdb = NULL;
main(int argc, char **argv) {
isc_result_t result;
char *origin, *file1, *file2, *journal;
dns_db_t *olddb = NULL, *newdb = NULL;
isc_logdestination_t destination;
isc_logconfig_t * logconfig = NULL;
isc_logconfig_t *logconfig = NULL;
if (argc != 5) {
printf("usage: %s origin file1 file2 journal\n", argv[0]);

75
bin/tests/optional/adb_test.c
View file

@ -34,35 +34,33 @@
typedef struct client client_t;
struct client {
dns_name_t name;
dns_name_t name;
const char *target;
ISC_LINK(client_t) link;
dns_adbfind_t *find;
};
static isc_mem_t * mctx = NULL;
static isc_mempool_t * cmp;
static isc_log_t * lctx;
static isc_logconfig_t * lcfg;
static isc_taskmgr_t * taskmgr;
static isc_socketmgr_t * socketmgr;
static isc_timermgr_t * timermgr;
static isc_mem_t *mctx = NULL;
static isc_mempool_t *cmp;
static isc_log_t *lctx;
static isc_logconfig_t *lcfg;
static isc_taskmgr_t *taskmgr;
static isc_socketmgr_t *socketmgr;
static isc_timermgr_t *timermgr;
static dns_dispatchmgr_t *dispatchmgr;
static isc_task_t * t1, *t2;
static dns_view_t * view;
static dns_db_t * rootdb;
static isc_task_t *t1, *t2;
static dns_view_t *view;
static dns_db_t *rootdb;
static ISC_LIST(client_t) clients;
static isc_mutex_t client_lock;
static isc_mutex_t client_lock;
static isc_stdtime_t now;
static dns_adb_t * adb;
static dns_adb_t *adb;
static void
check_result(isc_result_t result, const char *format, ...)
static void check_result(isc_result_t result, const char *format, ...)
ISC_FORMAT_PRINTF(2, 3);
static void
check_result(isc_result_t result, const char *format, ...)
{
check_result(isc_result_t result, const char *format, ...) {
va_list args;
if (result == ISC_R_SUCCESS) {
@ -77,8 +75,7 @@ check_result(isc_result_t result, const char *format, ...)
}
static client_t *
new_client(void)
{
new_client(void) {
client_t *client;
client = isc_mempool_get(cmp);
@ -91,8 +88,7 @@ new_client(void)
}
static void
free_client(client_t **c)
{
free_client(client_t **c) {
client_t *client;
INSIST(c != NULL);
@ -107,20 +103,17 @@ free_client(client_t **c)
}
static inline void
CLOCK(void)
{
CLOCK(void) {
RUNTIME_CHECK(isc_mutex_lock(&client_lock) == ISC_R_SUCCESS);
}
static inline void
CUNLOCK(void)
{
CUNLOCK(void) {
RUNTIME_CHECK(isc_mutex_unlock(&client_lock) == ISC_R_SUCCESS);
}
static void
lookup_callback(isc_task_t *task, isc_event_t *ev)
{
lookup_callback(isc_task_t *task, isc_event_t *ev) {
client_t *client;
client = ev->ev_arg;
@ -147,8 +140,7 @@ lookup_callback(isc_task_t *task, isc_event_t *ev)
}
static void
create_managers(void)
{
create_managers(void) {
isc_result_t result;
taskmgr = NULL;
@ -169,8 +161,7 @@ create_managers(void)
}
static void
create_view(void)
{
create_view(void) {
dns_cache_t *cache;
isc_result_t result;
@ -193,8 +184,8 @@ create_view(void)
dns_cache_detach(&cache);
{
unsigned int attrs;
isc_sockaddr_t any4, any6;
unsigned int attrs;
isc_sockaddr_t any4, any6;
dns_dispatch_t *disp4 = NULL;
dns_dispatch_t *disp6 = NULL;
@ -231,14 +222,13 @@ create_view(void)
}
static void
lookup(const char *target)
{
dns_name_t name;
lookup(const char *target) {
dns_name_t name;
unsigned char namedata[256];
client_t * client;
isc_buffer_t t, namebuf;
isc_result_t result;
unsigned int options;
client_t *client;
isc_buffer_t t, namebuf;
isc_result_t result;
unsigned int options;
INSIST(target != NULL);
@ -280,9 +270,8 @@ lookup(const char *target)
}
int
main(int argc, char **argv)
{
isc_result_t result;
main(int argc, char **argv) {
isc_result_t result;
isc_logdestination_t destination;
UNUSED(argc);

22
bin/tests/optional/backtrace_test.c
View file

@ -19,13 +19,12 @@
const char *expected_symbols[] = { "func3", "func2", "func1", "main" };
static int
func3()
{
void * tracebuf[16];
int i, nframes;
int error = 0;
const char * fname;
isc_result_t result;
func3() {
void *tracebuf[16];
int i, nframes;
int error = 0;
const char *fname;
isc_result_t result;
unsigned long offset;
result = isc_backtrace_gettrace(tracebuf, 16, &nframes);
@ -72,19 +71,16 @@ func3()
}
static int
func2()
{
func2() {
return (func3());
}
static int
func1()
{
func1() {
return (func2());
}
int
main()
{
main() {
return (func1());
}

47
bin/tests/optional/byaddr_test.c
View file

@ -34,11 +34,10 @@
#include <dns/view.h>
static void
done(isc_task_t *task, isc_event_t *event)
{
done(isc_task_t *task, isc_event_t *event) {
dns_byaddrevent_t *bevent;
dns_byaddr_t * byaddr;
dns_name_t * name;
dns_byaddr_t *byaddr;
dns_name_t *name;
REQUIRE(event->ev_type == DNS_EVENT_BYADDRDONE);
bevent = (dns_byaddrevent_t *)event;
@ -49,7 +48,8 @@ done(isc_task_t *task, isc_event_t *event)
if (bevent->result == ISC_R_SUCCESS) {
for (name = ISC_LIST_HEAD(bevent->names); name != NULL;
name = ISC_LIST_NEXT(name, link)) {
name = ISC_LIST_NEXT(name, link))
{
char text[DNS_NAME_FORMATSIZE];
dns_name_format(name, text, sizeof(text));
printf("%s\n", text);
@ -64,23 +64,22 @@ done(isc_task_t *task, isc_event_t *event)
}
int
main(int argc, char *argv[])
{
isc_mem_t * mctx;
bool verbose = false;
unsigned int workers = 2;
isc_taskmgr_t * taskmgr;
isc_task_t * task;
isc_timermgr_t * timermgr;
dns_view_t * view;
int ch;
isc_socketmgr_t * socketmgr;
main(int argc, char *argv[]) {
isc_mem_t *mctx;
bool verbose = false;
unsigned int workers = 2;
isc_taskmgr_t *taskmgr;
isc_task_t *task;
isc_timermgr_t *timermgr;
dns_view_t *view;
int ch;
isc_socketmgr_t *socketmgr;
dns_dispatchmgr_t *dispatchmgr;
isc_netaddr_t na;
dns_byaddr_t * byaddr;
isc_result_t result;
unsigned int options = 0;
dns_cache_t * cache;
isc_netaddr_t na;
dns_byaddr_t *byaddr;
isc_result_t result;
unsigned int options = 0;
dns_cache_t *cache;
RUNTIME_CHECK(isc_app_start() == ISC_R_SUCCESS);
@ -137,7 +136,7 @@ main(int argc, char *argv[])
&view) == ISC_R_SUCCESS);
{
unsigned int attrs;
unsigned int attrs;
dns_dispatch_t *disp4 = NULL;
dns_dispatch_t *disp6 = NULL;
@ -183,8 +182,8 @@ main(int argc, char *argv[])
}
{
struct in_addr ina;
isc_sockaddr_t sa;
struct in_addr ina;
isc_sockaddr_t sa;
isc_sockaddrlist_t sal;
ISC_LIST_INIT(sal);

73
bin/tests/optional/byname_test.c
View file

@ -34,25 +34,23 @@
#include <dns/resolver.h>
#include <dns/result.h>
static isc_mem_t * mctx = NULL;
static isc_taskmgr_t * taskmgr;
static dns_view_t * view = NULL;
static dns_adbfind_t * find = NULL;
static isc_task_t * task = NULL;
static dns_fixedname_t fixed;
static dns_fixedname_t target;
static isc_log_t * lctx;
static isc_mem_t *mctx = NULL;
static isc_taskmgr_t *taskmgr;
static dns_view_t *view = NULL;
static dns_adbfind_t *find = NULL;
static isc_task_t *task = NULL;
static dns_fixedname_t fixed;
static dns_fixedname_t target;
static isc_log_t *lctx;
static isc_logconfig_t *lcfg;
static unsigned int level = 0;
static unsigned int level = 0;
static void adb_callback(isc_task_t *task, isc_event_t *event);
static void
adb_callback(isc_task_t *task, isc_event_t *event);
static void
log_init(void)
{
log_init(void) {
isc_logdestination_t destination;
unsigned int flags;
unsigned int flags;
/*
* Setup a logging context.
@ -80,14 +78,14 @@ log_init(void)
}
static void
print_addresses(dns_adbfind_t *adbfind)
{
print_addresses(dns_adbfind_t *adbfind) {
dns_adbaddrinfo_t *address;
for (address = ISC_LIST_HEAD(adbfind->list); address != NULL;
address = ISC_LIST_NEXT(address, publink)) {
address = ISC_LIST_NEXT(address, publink))
{
isc_netaddr_t netaddr;
char text[ISC_NETADDR_FORMATSIZE];
char text[ISC_NETADDR_FORMATSIZE];
isc_netaddr_fromsockaddr(&netaddr, &address->sockaddr);
isc_netaddr_format(&netaddr, text, sizeof(text));
printf("%s\n", text);
@ -95,8 +93,7 @@ print_addresses(dns_adbfind_t *adbfind)
}
static void
print_name(dns_name_t *name)
{
print_name(dns_name_t *name) {
char text[DNS_NAME_FORMATSIZE];
dns_name_format(name, text, sizeof(text));
@ -104,10 +101,9 @@ print_name(dns_name_t *name)
}
static void
do_find(bool want_event)
{
do_find(bool want_event) {
isc_result_t result;
bool done = false;
bool done = false;
unsigned int options;
options = DNS_ADBFIND_INET | DNS_ADBFIND_INET6;
@ -163,8 +159,7 @@ do_find(bool want_event)
}
static void
adb_callback(isc_task_t *etask, isc_event_t *event)
{
adb_callback(isc_task_t *etask, isc_event_t *event) {
unsigned int type = event->ev_type;
REQUIRE(etask == task);
@ -184,24 +179,22 @@ adb_callback(isc_task_t *etask, isc_event_t *event)
}
static void
run(isc_task_t *xtask, isc_event_t *event)
{
run(isc_task_t *xtask, isc_event_t *event) {
UNUSED(xtask);
do_find(true);
isc_event_free(&event);
}
int
main(int argc, char *argv[])
{
bool verbose = false;
unsigned int workers = 2;
isc_timermgr_t * timermgr;
int ch;
isc_socketmgr_t * socketmgr;
main(int argc, char *argv[]) {
bool verbose = false;
unsigned int workers = 2;
isc_timermgr_t *timermgr;
int ch;
isc_socketmgr_t *socketmgr;
dns_dispatchmgr_t *dispatchmgr;
dns_cache_t * cache;
isc_buffer_t b;
dns_cache_t *cache;
isc_buffer_t b;
RUNTIME_CHECK(isc_app_start() == ISC_R_SUCCESS);
@ -258,7 +251,7 @@ main(int argc, char *argv[])
&view) == ISC_R_SUCCESS);
{
unsigned int attrs;
unsigned int attrs;
dns_dispatch_t *disp4 = NULL;
dns_dispatch_t *disp6 = NULL;
@ -303,8 +296,8 @@ main(int argc, char *argv[])
}
{
struct in_addr ina;
isc_sockaddr_t sa;
struct in_addr ina;
isc_sockaddr_t sa;
isc_sockaddrlist_t sal;
ISC_LIST_INIT(sal);

186
bin/tests/optional/db_test.c
View file

@ -33,35 +33,34 @@
#include <dns/rdatasetiter.h>
#include <dns/result.h>
#define MAXHOLD 100
#define MAXHOLD 100
#define MAXVERSIONS 100
typedef struct dbinfo {
dns_db_t * db;
dns_dbversion_t * version;
dns_dbversion_t * wversion;
dns_dbversion_t * rversions[MAXVERSIONS];
int rcount;
dns_dbnode_t * hold_nodes[MAXHOLD];
int hold_count;
dns_db_t *db;
dns_dbversion_t *version;
dns_dbversion_t *wversion;
dns_dbversion_t *rversions[MAXVERSIONS];
int rcount;
dns_dbnode_t *hold_nodes[MAXHOLD];
int hold_count;
dns_dbiterator_t *dbiterator;
dns_dbversion_t * iversion;
int pause_every;
bool ascending;
dns_dbversion_t *iversion;
int pause_every;
bool ascending;
ISC_LINK(struct dbinfo) link;
} dbinfo;
static isc_mem_t * mctx = NULL;
static char dbtype[128];
static isc_mem_t *mctx = NULL;
static char dbtype[128];
static dns_dbtable_t *dbtable;
static ISC_LIST(dbinfo) dbs;
static dbinfo *cache_dbi = NULL;
static int pause_every = 0;
static bool ascending = true;
static int pause_every = 0;
static bool ascending = true;
static void
print_result(const char *message, isc_result_t result)
{
print_result(const char *message, isc_result_t result) {
if (message == NULL) {
message = "";
}
@ -70,10 +69,9 @@ print_result(const char *message, isc_result_t result)
}
static void
print_rdataset(dns_name_t *name, dns_rdataset_t *rdataset)
{
print_rdataset(dns_name_t *name, dns_rdataset_t *rdataset) {
isc_buffer_t text;
char t[1000];
char t[1000];
isc_result_t result;
isc_region_t r;
@ -88,9 +86,8 @@ print_rdataset(dns_name_t *name, dns_rdataset_t *rdataset)
}
static void
print_rdatasets(dns_name_t *name, dns_rdatasetiter_t *rdsiter)
{
isc_result_t result;
print_rdatasets(dns_name_t *name, dns_rdatasetiter_t *rdsiter) {
isc_result_t result;
dns_rdataset_t rdataset;
dns_rdataset_init(&rdataset);
@ -107,14 +104,13 @@ print_rdatasets(dns_name_t *name, dns_rdatasetiter_t *rdsiter)
}
static dbinfo *
select_db(char *origintext)
{
select_db(char *origintext) {
dns_fixedname_t forigin;
dns_name_t * origin;
isc_buffer_t source;
size_t len;
dbinfo * dbi;
isc_result_t result;
dns_name_t *origin;
isc_buffer_t source;
size_t len;
dbinfo *dbi;
isc_result_t result;
if (strcasecmp(origintext, "cache") == 0) {
if (cache_dbi == NULL) {
@ -143,18 +139,17 @@ select_db(char *origintext)
}
static void
list(dbinfo *dbi, char *seektext)
{
dns_fixedname_t fname;
dns_name_t * name;
dns_dbnode_t * node;
list(dbinfo *dbi, char *seektext) {
dns_fixedname_t fname;
dns_name_t *name;
dns_dbnode_t *node;
dns_rdatasetiter_t *rdsiter;
isc_result_t result;
int i;
size_t len;
dns_fixedname_t fseekname;
dns_name_t * seekname;
isc_buffer_t source;
isc_result_t result;
int i;
size_t len;
dns_fixedname_t fseekname;
dns_name_t *seekname;
isc_buffer_t source;
name = dns_fixedname_initname(&fname);
@ -235,15 +230,14 @@ list(dbinfo *dbi, char *seektext)
}
static isc_result_t
load(const char *filename, const char *origintext, bool cache)
{
load(const char *filename, const char *origintext, bool cache) {
dns_fixedname_t forigin;
dns_name_t * origin;
isc_result_t result;
isc_buffer_t source;
size_t len;
dbinfo * dbi;
unsigned int i;
dns_name_t *origin;
isc_result_t result;
isc_buffer_t source;
size_t len;
dbinfo *dbi;
unsigned int i;
dbi = isc_mem_get(mctx, sizeof(*dbi));
@ -308,8 +302,7 @@ load(const char *filename, const char *origintext, bool cache)
}
static void
unload_all(void)
{
unload_all(void) {
dbinfo *dbi, *dbi_next;
for (dbi = ISC_LIST_HEAD(dbs); dbi != NULL; dbi = dbi_next) {
@ -334,49 +327,48 @@ unload_all(void)
}
int
main(int argc, char *argv[])
{
dns_db_t * db;
dns_dbnode_t * node;
isc_result_t result;
dns_name_t name;
dns_offsets_t offsets;
size_t len;
isc_buffer_t source, target;
char s[1000];
char b[255];
dns_rdataset_t rdataset, sigrdataset;
int ch;
dns_rdatatype_t type = 1;
bool printnode = false;
bool addmode = false;
bool delmode = false;
bool holdmode = false;
bool verbose = false;
bool done = false;
bool quiet = false;
bool time_lookups = false;
bool found_as;
bool find_zonecut = false;
bool noexact_zonecut = false;
int i, v;
main(int argc, char *argv[]) {
dns_db_t *db;
dns_dbnode_t *node;
isc_result_t result;
dns_name_t name;
dns_offsets_t offsets;
size_t len;
isc_buffer_t source, target;
char s[1000];
char b[255];
dns_rdataset_t rdataset, sigrdataset;
int ch;
dns_rdatatype_t type = 1;
bool printnode = false;
bool addmode = false;
bool delmode = false;
bool holdmode = false;
bool verbose = false;
bool done = false;
bool quiet = false;
bool time_lookups = false;
bool found_as;
bool find_zonecut = false;
bool noexact_zonecut = false;
int i, v;
dns_rdatasetiter_t *rdsiter;
char t1[256];
char t2[256];
isc_buffer_t tb1, tb2;
isc_region_t r1, r2;
dns_fixedname_t foundname;
dns_name_t * fname;
unsigned int options = 0, zcoptions;
isc_time_t start, finish;
const char * origintext;
dbinfo * dbi;
dns_dbversion_t * version;
const dns_name_t * origin;
dns_trust_t trust = 0;
unsigned int addopts;
isc_log_t * lctx = NULL;
size_t n;
char t1[256];
char t2[256];
isc_buffer_t tb1, tb2;
isc_region_t r1, r2;
dns_fixedname_t foundname;
dns_name_t *fname;
unsigned int options = 0, zcoptions;
isc_time_t start, finish;
const char *origintext;
dbinfo *dbi;
dns_dbversion_t *version;
const dns_name_t *origin;
dns_trust_t trust = 0;
unsigned int addopts;
isc_log_t *lctx = NULL;
size_t n;
dns_result_register();
@ -406,8 +398,8 @@ main(int argc, char *argv[])
}
break;
case 'g':
options |=
(DNS_DBFIND_GLUEOK | DNS_DBFIND_VALIDATEGLUE);
options |= (DNS_DBFIND_GLUEOK |
DNS_DBFIND_VALIDATEGLUE);
break;
case 'l':
RUNTIME_CHECK(isc_log_create(mctx, &lctx, NULL) ==
@ -781,8 +773,8 @@ main(int argc, char *argv[])
continue;
}
isc_buffer_init(&tb1, t1, sizeof(t1));
result =
dns_name_totext(dns_db_origin(db), false, &tb1);
result = dns_name_totext(dns_db_origin(db), false,
&tb1);
if (result != ISC_R_SUCCESS) {
printf("\n");
print_result("", result);

9
bin/tests/optional/fsaccess_test.c
View file

@ -25,12 +25,11 @@
#define PATH "/tmp/fsaccess"
int
main(void)
{
main(void) {
isc_fsaccess_t access;
isc_result_t result;
FILE * fp;
int n;
isc_result_t result;
FILE *fp;
int n;
n = remove(PATH);
if (n != 0 && errno != ENOENT) {

127
bin/tests/optional/gsstest.c
View file

@ -58,32 +58,28 @@
static dns_fixedname_t servername, gssname;
static isc_mem_t * mctx;
static isc_mem_t *mctx;
static dns_requestmgr_t *requestmgr;
static isc_sockaddr_t address;
static isc_sockaddr_t address;
static dns_tsig_keyring_t *ring;
static dns_tsigkey_t * tsigkey = NULL;
static gss_ctx_id_t gssctx;
static gss_ctx_id_t * gssctxp = &gssctx;
static dns_tsigkey_t *tsigkey = NULL;
static gss_ctx_id_t gssctx;
static gss_ctx_id_t *gssctxp = &gssctx;
#define RUNCHECK(x) RUNTIME_CHECK((x) == ISC_R_SUCCESS)
#define PORT 53
#define PORT 53
#define TIMEOUT 30
static void
initctx1(isc_task_t *task, isc_event_t *event);
static void
sendquery(isc_task_t *task, isc_event_t *event);
static void
setup();
static void initctx1(isc_task_t *task, isc_event_t *event);
static void sendquery(isc_task_t *task, isc_event_t *event);
static void setup();
static void
console(isc_task_t *task, isc_event_t *event)
{
console(isc_task_t *task, isc_event_t *event) {
char buf[32];
int c;
int c;
isc_event_t *ev = NULL;
@ -117,14 +113,13 @@ console(isc_task_t *task, isc_event_t *event)
}
static void
recvresponse(isc_task_t *task, isc_event_t *event)
{
recvresponse(isc_task_t *task, isc_event_t *event) {
dns_requestevent_t *reqev = (dns_requestevent_t *)event;
isc_result_t result, result2;
dns_message_t * query = NULL, *response = NULL;
isc_buffer_t outtoken;
isc_buffer_t outbuf;
char output[10 * 1024];
isc_result_t result, result2;
dns_message_t *query = NULL, *response = NULL;
isc_buffer_t outtoken;
isc_buffer_t outbuf;
char output[10 * 1024];
unsigned char array[DNS_NAME_MAXTEXT + 1];
isc_buffer_init(&outtoken, array, sizeof(array));
@ -180,19 +175,18 @@ end:
}
static void
sendquery(isc_task_t *task, isc_event_t *event)
{
dns_request_t * request = NULL;
dns_message_t * message = NULL;
dns_name_t * qname = NULL;
sendquery(isc_task_t *task, isc_event_t *event) {
dns_request_t *request = NULL;
dns_message_t *message = NULL;
dns_name_t *qname = NULL;
dns_rdataset_t *qrdataset = NULL;
isc_result_t result;
isc_result_t result;
dns_fixedname_t queryname;
isc_buffer_t buf;
isc_buffer_t outbuf;
char output[10 * 1024];
static char host[256];
int c;
isc_buffer_t buf;
isc_buffer_t outbuf;
char output[10 * 1024];
static char host[256];
int c;
isc_event_free(&event);
@ -263,16 +257,15 @@ end:
}
static void
initctx2(isc_task_t *task, isc_event_t *event)
{
initctx2(isc_task_t *task, isc_event_t *event) {
dns_requestevent_t *reqev = (dns_requestevent_t *)event;
isc_result_t result;
dns_message_t * query = NULL, *response = NULL;
isc_buffer_t outtoken;
unsigned char array[DNS_NAME_MAXTEXT + 1];
dns_rdataset_t * rdataset;
dns_rdatatype_t qtype;
dns_name_t * question_name;
isc_result_t result;
dns_message_t *query = NULL, *response = NULL;
isc_buffer_t outtoken;
unsigned char array[DNS_NAME_MAXTEXT + 1];
dns_rdataset_t *rdataset;
dns_rdatatype_t qtype;
dns_name_t *question_name;
UNUSED(task);
@ -345,15 +338,14 @@ end:
}
static void
initctx1(isc_task_t *task, isc_event_t *event)
{
char gssid[512];
char contextname[512];
isc_result_t result;
isc_buffer_t buf;
initctx1(isc_task_t *task, isc_event_t *event) {
char gssid[512];
char contextname[512];
isc_result_t result;
isc_buffer_t buf;
dns_message_t *query;
dns_request_t *request;
int c;
int c;
isc_event_free(&event);
@ -416,12 +408,11 @@ end:
}
static void
setup(void)
{
setup(void) {
for (;;) {
char serveraddress[512];
char serveraddress[512];
struct in_addr inaddr;
int c;
int c;
printf("Server IP => ");
c = scanf("%511s", serveraddress);
@ -439,20 +430,19 @@ setup(void)
}
int
main(int argc, char *argv[])
{
isc_taskmgr_t * taskmgr;
isc_timermgr_t * timermgr;
isc_socketmgr_t * socketmgr;
isc_socket_t * sock;
unsigned int attrs, attrmask;
isc_sockaddr_t bind_any;
dns_dispatchmgr_t * dispatchmgr;
dns_dispatch_t * dispatchv4;
dns_view_t * view;
isc_task_t * task;
isc_log_t * lctx = NULL;
isc_logconfig_t * lcfg = NULL;
main(int argc, char *argv[]) {
isc_taskmgr_t *taskmgr;
isc_timermgr_t *timermgr;
isc_socketmgr_t *socketmgr;
isc_socket_t *sock;
unsigned int attrs, attrmask;
isc_sockaddr_t bind_any;
dns_dispatchmgr_t *dispatchmgr;
dns_dispatch_t *dispatchv4;
dns_view_t *view;
isc_task_t *task;
isc_log_t *lctx = NULL;
isc_logconfig_t *lcfg = NULL;
isc_logdestination_t destination;
UNUSED(argv);
@ -560,8 +550,7 @@ main(int argc, char *argv[])
}
#else /* ifdef GSSAPI */
int
main(int argc, char *argv[])
{
main(int argc, char *argv[]) {
UNUSED(argc);
UNUSED(argv);
fprintf(stderr, "R:GSSAPIONLY\n");

13
bin/tests/optional/inter_test.c
View file

@ -19,14 +19,13 @@
#include <isc/util.h>
int
main(int argc, char **argv)
{
isc_mem_t * mctx = NULL;
main(int argc, char **argv) {
isc_mem_t *mctx = NULL;
isc_interfaceiter_t *iter = NULL;
isc_interface_t ifdata;
isc_result_t result;
const char * res;
char buf[128];
isc_interface_t ifdata;
isc_result_t result;
const char *res;
char buf[128];
UNUSED(argc);
UNUSED(argv);

21
bin/tests/optional/lex_test.c
View file

@ -23,8 +23,7 @@ isc_lex_t *lex;
isc_lexspecials_t specials;
static void
print_token(isc_token_t *tokenp, FILE *stream)
{
print_token(isc_token_t *tokenp, FILE *stream) {
switch (tokenp->type) {
case isc_tokentype_unknown:
fprintf(stream, "UNKNOWN");
@ -64,16 +63,15 @@ print_token(isc_token_t *tokenp, FILE *stream)
}
int
main(int argc, char *argv[])
{
isc_token_t token;
main(int argc, char *argv[]) {
isc_token_t token;
isc_result_t result;
int quiet = 0;
int c;
int masterfile = 1;
int stats = 0;
int quiet = 0;
int c;
int masterfile = 1;
int stats = 0;
unsigned int options = 0;
int done = 0;
int done = 0;
while ((c = isc_commandline_parse(argc, argv, "qmcs")) != -1) {
switch (c) {
@ -128,7 +126,8 @@ main(int argc, char *argv[])
while ((result = isc_lex_gettoken(lex, options, &token)) ==
ISC_R_SUCCESS &&
!done) {
!done)
{
if (!quiet) {
char *name = isc_lex_getsourcename(lex);
print_token(&token, stdout);

7
bin/tests/optional/lfsr_test.c
View file

@ -21,11 +21,10 @@
uint32_t state[1024 * 64];
int
main(int argc, char **argv)
{
main(int argc, char **argv) {
isc_lfsr_t lfsr1, lfsr2;
int i;
uint32_t temp;
int i;
uint32_t temp;
UNUSED(argc);
UNUSED(argv);

28
bin/tests/optional/log_test.c
View file

@ -21,8 +21,8 @@
#include <dns/log.h>
#define TEST_FILE "/tmp/test_log"
#define SYSLOG_FILE "/var/log/daemon.log"
#define TEST_FILE "/tmp/test_log"
#define SYSLOG_FILE "/var/log/daemon.log"
#define FILE_VERSIONS 10
char usage[] = "Usage: %s [-m] [-s syslog_logfile] [-r file_versions]\n";
@ -35,18 +35,17 @@ char usage[] = "Usage: %s [-m] [-s syslog_logfile] [-r file_versions]\n";
}
int
main(int argc, char **argv)
{
const char * progname, *syslog_file, *message;
int ch, i, file_versions, stderr_line;
bool show_final_mem = false;
isc_log_t * lctx;
isc_logconfig_t * lcfg;
isc_mem_t * mctx;
isc_result_t result;
isc_logdestination_t destination;
main(int argc, char **argv) {
const char *progname, *syslog_file, *message;
int ch, i, file_versions, stderr_line;
bool show_final_mem = false;
isc_log_t *lctx;
isc_logconfig_t *lcfg;
isc_mem_t *mctx;
isc_result_t result;
isc_logdestination_t destination;
const isc_logcategory_t *category;
const isc_logmodule_t * module;
const isc_logmodule_t *module;
progname = strrchr(*argv, '/');
if (progname != NULL) {
@ -70,7 +69,8 @@ main(int argc, char **argv)
file_versions = atoi(isc_commandline_argument);
if (file_versions < 0 &&
file_versions != ISC_LOG_ROLLNEVER &&
file_versions != ISC_LOG_ROLLINFINITE) {
file_versions != ISC_LOG_ROLLINFINITE)
{
fprintf(stderr,
"%s: file rotations must be "
"%d (ISC_LOG_ROLLNEVER),\n\t"

18
bin/tests/optional/master_test.c
View file

@ -26,9 +26,8 @@
isc_mem_t *mctx;
static isc_result_t
print_dataset(void *arg, const dns_name_t *owner, dns_rdataset_t *dataset)
{
char buf[64 * 1024];
print_dataset(void *arg, const dns_name_t *owner, dns_rdataset_t *dataset) {
char buf[64 * 1024];
isc_buffer_t target;
isc_result_t result;
@ -48,13 +47,12 @@ print_dataset(void *arg, const dns_name_t *owner, dns_rdataset_t *dataset)
}
int
main(int argc, char *argv[])
{
isc_result_t result;
dns_name_t origin;
isc_buffer_t source;
isc_buffer_t target;
unsigned char name_buf[255];
main(int argc, char *argv[]) {
isc_result_t result;
dns_name_t origin;
isc_buffer_t source;
isc_buffer_t target;
unsigned char name_buf[255];
dns_rdatacallbacks_t callbacks;
UNUSED(argc);

13
bin/tests/optional/mempool_test.c
View file

@ -15,14 +15,13 @@
isc_mem_t *mctx;
int
main(int argc, char *argv[])
{
void * items1[50];
void * items2[50];
void * tmp;
main(int argc, char *argv[]) {
void *items1[50];
void *items2[50];
void *tmp;
isc_mempool_t *mp1, *mp2;
unsigned int i, j;
isc_mutex_t lock;
unsigned int i, j;
isc_mutex_t lock;
UNUSED(argc);
UNUSED(argv);

55
bin/tests/optional/name_test.c
View file

@ -21,8 +21,7 @@
#include <dns/result.h>
static void
print_wirename(isc_region_t *name)
{
print_wirename(isc_region_t *name) {
unsigned char *ccurr, *cend;
if (name->length == 0) {
@ -38,12 +37,11 @@ print_wirename(isc_region_t *name)
}
static void
print_name(dns_name_t *name)
{
print_name(dns_name_t *name) {
isc_result_t result;
isc_buffer_t source;
isc_region_t r;
char s[1000];
char s[1000];
isc_buffer_init(&source, s, sizeof(s));
if (dns_name_countlabels(name) > 0) {
@ -64,29 +62,28 @@ print_name(dns_name_t *name)
}
int
main(int argc, char *argv[])
{
char s[1000];
isc_result_t result;
dns_fixedname_t wname, wname2, oname, compname, downname;
isc_buffer_t source;
isc_region_t r;
dns_name_t * name, *comp, *down;
main(int argc, char *argv[]) {
char s[1000];
isc_result_t result;
dns_fixedname_t wname, wname2, oname, compname, downname;
isc_buffer_t source;
isc_region_t r;
dns_name_t *name, *comp, *down;
const dns_name_t *origin;
unsigned int downcase = 0;
size_t len;
bool quiet = false;
bool concatenate = false;
bool got_name = false;
bool check_absolute = false;
bool check_wildcard = false;
bool test_downcase = false;
bool inplace = false;
bool want_split = false;
unsigned int labels, split_label = 0;
dns_fixedname_t fprefix, fsuffix;
dns_name_t * prefix, *suffix;
int ch;
unsigned int downcase = 0;
size_t len;
bool quiet = false;
bool concatenate = false;
bool got_name = false;
bool check_absolute = false;
bool check_wildcard = false;
bool test_downcase = false;
bool inplace = false;
bool want_split = false;
unsigned int labels, split_label = 0;
dns_fixedname_t fprefix, fsuffix;
dns_name_t *prefix, *suffix;
int ch;
while ((ch = isc_commandline_parse(argc, argv, "acdiqs:w")) != -1) {
switch (ch) {
@ -301,8 +298,8 @@ main(int argc, char *argv[])
}
if (comp != NULL && dns_name_countlabels(name) > 0) {
int order;
unsigned int nlabels;
int order;
unsigned int nlabels;
dns_namereln_t namereln;
namereln = dns_name_fullcompare(name, comp, &order,

46
bin/tests/optional/nsecify.c
View file

@ -30,15 +30,13 @@ ISC_PLATFORM_NORETURN_PRE static inline void
fatal(const char *message) ISC_PLATFORM_NORETURN_POST;
static inline void
fatal(const char *message)
{
fatal(const char *message) {
fprintf(stderr, "%s\n", message);
exit(1);
}
static inline void
check_result(isc_result_t result, const char *message)
{
check_result(isc_result_t result, const char *message) {
if (result != ISC_R_SUCCESS) {
fprintf(stderr, "%s: %s\n", message, isc_result_totext(result));
exit(1);
@ -46,12 +44,11 @@ check_result(isc_result_t result, const char *message)
}
static inline bool
active_node(dns_db_t *db, dns_dbversion_t *version, dns_dbnode_t *node)
{
active_node(dns_db_t *db, dns_dbversion_t *version, dns_dbnode_t *node) {
dns_rdatasetiter_t *rdsiter;
bool active = false;
isc_result_t result;
dns_rdataset_t rdataset;
bool active = false;
isc_result_t result;
dns_rdataset_t rdataset;
dns_rdataset_init(&rdataset);
rdsiter = NULL;
@ -92,10 +89,9 @@ active_node(dns_db_t *db, dns_dbversion_t *version, dns_dbnode_t *node)
static inline isc_result_t
next_active(dns_db_t *db, dns_dbversion_t *version, dns_dbiterator_t *dbiter,
dns_name_t *name, dns_dbnode_t **nodep)
{
dns_name_t *name, dns_dbnode_t **nodep) {
isc_result_t result;
bool active;
bool active;
do {
active = false;
@ -113,19 +109,18 @@ next_active(dns_db_t *db, dns_dbversion_t *version, dns_dbiterator_t *dbiter,
}
static void
nsecify(char *filename)
{
isc_result_t result;
dns_db_t * db;
dns_dbversion_t * wversion;
dns_dbnode_t * node, *nextnode;
const char * origintext;
dns_fixedname_t fname, fnextname;
dns_name_t * name, *nextname, *target;
isc_buffer_t b;
size_t len;
nsecify(char *filename) {
isc_result_t result;
dns_db_t *db;
dns_dbversion_t *wversion;
dns_dbnode_t *node, *nextnode;
const char *origintext;
dns_fixedname_t fname, fnextname;
dns_name_t *name, *nextname, *target;
isc_buffer_t b;
size_t len;
dns_dbiterator_t *dbiter;
char newfilename[1024];
char newfilename[1024];
name = dns_fixedname_initname(&fname);
nextname = dns_fixedname_initname(&fnextname);
@ -199,8 +194,7 @@ nsecify(char *filename)
}
int
main(int argc, char *argv[])
{
main(int argc, char *argv[]) {
int i;
dns_result_register();

36
bin/tests/optional/ratelimiter_test.c
View file

@ -19,17 +19,14 @@
#include <isc/util.h>
isc_ratelimiter_t *rlim = NULL;
isc_taskmgr_t * taskmgr = NULL;
isc_timermgr_t * timermgr = NULL;
isc_task_t * g_task = NULL;
isc_mem_t * mctx = NULL;
isc_taskmgr_t *taskmgr = NULL;
isc_timermgr_t *timermgr = NULL;
isc_task_t *g_task = NULL;
isc_mem_t *mctx = NULL;
static void
utick(isc_task_t *task, isc_event_t *event);
static void
shutdown_rl(isc_task_t *task, isc_event_t *event);
static void
shutdown_all(isc_task_t *task, isc_event_t *event);
static void utick(isc_task_t *task, isc_event_t *event);
static void shutdown_rl(isc_task_t *task, isc_event_t *event);
static void shutdown_all(isc_task_t *task, isc_event_t *event);
typedef struct {
int milliseconds;
@ -47,8 +44,7 @@ schedule_t schedule[] = { { 100, utick }, { 200, utick },
isc_timer_t *timers[NEVENTS];
static void
ltick(isc_task_t *task, isc_event_t *event)
{
ltick(isc_task_t *task, isc_event_t *event) {
UNUSED(task);
printf("** ltick%s **\n",
(event->ev_attributes & ISC_EVENTATTR_CANCELED) != 0 ? " ("
@ -59,8 +55,7 @@ ltick(isc_task_t *task, isc_event_t *event)
}
static void
utick(isc_task_t *task, isc_event_t *event)
{
utick(isc_task_t *task, isc_event_t *event) {
isc_result_t result;
UNUSED(task);
event->ev_action = ltick;
@ -70,8 +65,7 @@ utick(isc_task_t *task, isc_event_t *event)
}
static void
shutdown_rl(isc_task_t *task, isc_event_t *event)
{
shutdown_rl(isc_task_t *task, isc_event_t *event) {
UNUSED(task);
UNUSED(event);
printf("shutdown ratelimiter\n");
@ -79,8 +73,7 @@ shutdown_rl(isc_task_t *task, isc_event_t *event)
}
static void
shutdown_all(isc_task_t *task, isc_event_t *event)
{
shutdown_all(isc_task_t *task, isc_event_t *event) {
int i;
UNUSED(task);
UNUSED(event);
@ -93,10 +86,9 @@ shutdown_all(isc_task_t *task, isc_event_t *event)
}
int
main(int argc, char *argv[])
{
main(int argc, char *argv[]) {
isc_interval_t linterval;
int i;
int i;
UNUSED(argc);
UNUSED(argv);
@ -118,7 +110,7 @@ main(int argc, char *argv[])
for (i = 0; i < NEVENTS; i++) {
isc_interval_t uinterval;
int ms = schedule[i].milliseconds;
int ms = schedule[i].milliseconds;
isc_interval_set(&uinterval, ms / 1000, (ms % 1000) * 1000000);
timers[i] = NULL;
RUNTIME_CHECK(isc_timer_create(timermgr, isc_timertype_once,

68
bin/tests/optional/rbt_test.c
View file

@ -23,16 +23,15 @@
#include <dns/result.h>
const char *progname;
isc_mem_t * mctx;
isc_mem_t *mctx;
#define DNSNAMELEN 255
static dns_name_t *
create_name(char *s)
{
int length;
isc_result_t result;
isc_buffer_t source, target;
create_name(char *s) {
int length;
isc_result_t result;
isc_buffer_t source, target;
static dns_name_t *name;
if (s == NULL || *s == '\0') {
@ -72,8 +71,7 @@ create_name(char *s)
}
static void
delete_name(void *data, void *arg)
{
delete_name(void *data, void *arg) {
dns_name_t *name;
UNUSED(arg);
@ -82,10 +80,9 @@ delete_name(void *data, void *arg)
}
static void
print_name(dns_name_t *name)
{
print_name(dns_name_t *name) {
isc_buffer_t target;
char buffer[1024];
char buffer[1024];
isc_buffer_init(&target, buffer, sizeof(buffer));
@ -98,14 +95,13 @@ print_name(dns_name_t *name)
}
static void
detail(dns_rbt_t *rbt, dns_name_t *name)
{
dns_name_t * foundname, *origin, *fullname;
dns_fixedname_t fixedfoundname, fixedorigin, fixedfullname;
dns_rbtnode_t * node1, *node2;
detail(dns_rbt_t *rbt, dns_name_t *name) {
dns_name_t *foundname, *origin, *fullname;
dns_fixedname_t fixedfoundname, fixedorigin, fixedfullname;
dns_rbtnode_t *node1, *node2;
dns_rbtnodechain_t chain;
isc_result_t result;
bool nodes_should_match = false;
isc_result_t result;
bool nodes_should_match = false;
dns_rbtnodechain_init(&chain);
@ -155,8 +151,8 @@ detail(dns_rbt_t *rbt, dns_name_t *name)
if (result == ISC_R_SUCCESS) {
printf("\n name from dns_rbtnodechain_current: ");
result =
dns_name_concatenate(foundname, origin, fullname, NULL);
result = dns_name_concatenate(foundname, origin, fullname,
NULL);
if (result == ISC_R_SUCCESS) {
print_name(fullname);
} else {
@ -181,12 +177,11 @@ detail(dns_rbt_t *rbt, dns_name_t *name)
}
static void
iterate(dns_rbt_t *rbt, bool forward)
{
dns_name_t foundname, *origin;
iterate(dns_rbt_t *rbt, bool forward) {
dns_name_t foundname, *origin;
dns_rbtnodechain_t chain;
dns_fixedname_t fixedorigin;
isc_result_t result;
dns_fixedname_t fixedorigin;
isc_result_t result;
isc_result_t (*move)(dns_rbtnodechain_t * chain, dns_name_t * name,
dns_name_t * origin);
@ -199,8 +194,8 @@ iterate(dns_rbt_t *rbt, bool forward)
printf("iterating forward\n");
move = dns_rbtnodechain_next;
result =
dns_rbtnodechain_first(&chain, rbt, &foundname, origin);
result = dns_rbtnodechain_first(&chain, rbt, &foundname,
origin);
} else {
printf("iterating backward\n");
move = dns_rbtnodechain_prev;
@ -241,17 +236,16 @@ iterate(dns_rbt_t *rbt, bool forward)
printf("... %s\n", dns_result_totext(r));
int
main(int argc, char **argv)
{
char * command, *arg, buffer[1024];
const char * whitespace;
dns_name_t * name, *foundname;
main(int argc, char **argv) {
char *command, *arg, buffer[1024];
const char *whitespace;
dns_name_t *name, *foundname;
dns_fixedname_t fixedname;
dns_rbt_t * rbt = NULL;
int length, ch;
bool show_final_mem = false;
isc_result_t result;
void * data;
dns_rbt_t *rbt = NULL;
int length, ch;
bool show_final_mem = false;
isc_result_t result;
void *data;
progname = strrchr(*argv, '/');
if (progname != NULL) {

13
bin/tests/optional/rwlock_test.c
View file

@ -29,8 +29,7 @@ static isc_threadresult_t
#ifdef WIN32
WINAPI
#endif /* ifdef WIN32 */
run1(void *arg)
{
run1(void *arg) {
char *message = arg;
RUNTIME_CHECK(isc_rwlock_lock(&lock, isc_rwlocktype_read) ==
@ -61,8 +60,7 @@ static isc_threadresult_t
#ifdef WIN32
WINAPI
#endif /* ifdef WIN32 */
run2(void *arg)
{
run2(void *arg) {
char *message = arg;
RUNTIME_CHECK(isc_rwlock_lock(&lock, isc_rwlocktype_write) ==
@ -90,13 +88,12 @@ static isc_threadresult_t
}
int
main(int argc, char *argv[])
{
main(int argc, char *argv[]) {
unsigned int nworkers;
unsigned int i;
isc_thread_t workers[100];
char name[100];
void * dupname;
char name[100];
void *dupname;
if (argc > 1) {
nworkers = atoi(argv[1]);

7
bin/tests/optional/serial_test.c
View file

@ -17,11 +17,10 @@
#include <isc/serial.h>
int
main()
{
main() {
uint32_t a, b;
char buf[1024];
char * s, *e;
char buf[1024];
char *s, *e;
while (fgets(buf, sizeof(buf), stdin) != NULL) {
buf[sizeof(buf) - 1] = '\0';

57
bin/tests/optional/shutdown_test.c
View file

@ -23,28 +23,27 @@
#include <isc/util.h>
typedef struct {
isc_mem_t * mctx;
isc_task_t * task;
isc_mem_t *mctx;
isc_task_t *task;
isc_timer_t *timer;
unsigned int ticks;
char name[16];
bool exiting;
isc_task_t * peer;
char name[16];
bool exiting;
isc_task_t *peer;
} t_info;
#define MAX_TASKS 3
#define T2_SHUTDOWNOK (ISC_EVENTCLASS(1024) + 0)
#define MAX_TASKS 3
#define T2_SHUTDOWNOK (ISC_EVENTCLASS(1024) + 0)
#define T2_SHUTDOWNDONE (ISC_EVENTCLASS(1024) + 1)
#define FOO_EVENT (ISC_EVENTCLASS(1024) + 2)
#define FOO_EVENT (ISC_EVENTCLASS(1024) + 2)
static t_info tasks[MAX_TASKS];
static unsigned int task_count;
static isc_taskmgr_t * task_manager;
static t_info tasks[MAX_TASKS];
static unsigned int task_count;
static isc_taskmgr_t *task_manager;
static isc_timermgr_t *timer_manager;
static void
t1_shutdown(isc_task_t *task, isc_event_t *event)
{
t1_shutdown(isc_task_t *task, isc_event_t *event) {
t_info *info = event->ev_arg;
printf("task %s (%p) t1_shutdown\n", info->name, task);
@ -53,8 +52,7 @@ t1_shutdown(isc_task_t *task, isc_event_t *event)
}
static void
t2_shutdown(isc_task_t *task, isc_event_t *event)
{
t2_shutdown(isc_task_t *task, isc_event_t *event) {
t_info *info = event->ev_arg;
printf("task %s (%p) t2_shutdown\n", info->name, task);
@ -63,9 +61,8 @@ t2_shutdown(isc_task_t *task, isc_event_t *event)
}
static void
shutdown_action(isc_task_t *task, isc_event_t *event)
{
t_info * info = event->ev_arg;
shutdown_action(isc_task_t *task, isc_event_t *event) {
t_info *info = event->ev_arg;
isc_event_t *nevent;
INSIST(event->ev_type == ISC_TASKEVENT_SHUTDOWN);
@ -84,16 +81,14 @@ shutdown_action(isc_task_t *task, isc_event_t *event)
}
static void
foo_event(isc_task_t *task, isc_event_t *event)
{
foo_event(isc_task_t *task, isc_event_t *event) {
printf("task(%p) foo\n", task);
isc_event_free(&event);
}
static void
tick(isc_task_t *task, isc_event_t *event)
{
t_info * info = event->ev_arg;
tick(isc_task_t *task, isc_event_t *event) {
t_info *info = event->ev_arg;
isc_event_t *nevent;
INSIST(event->ev_type == ISC_TIMEREVENT_TICK);
@ -126,10 +121,9 @@ tick(isc_task_t *task, isc_event_t *event)
}
static t_info *
new_task(isc_mem_t *mctx, const char *name)
{
t_info * ti;
isc_time_t expires;
new_task(isc_mem_t *mctx, const char *name) {
t_info *ti;
isc_time_t expires;
isc_interval_t interval;
RUNTIME_CHECK(task_count < MAX_TASKS);
@ -161,12 +155,11 @@ new_task(isc_mem_t *mctx, const char *name)
}
int
main(int argc, char *argv[])
{
main(int argc, char *argv[]) {
unsigned int workers;
t_info * t1, *t2;
isc_task_t * task;
isc_mem_t * mctx, *mctx2;
t_info *t1, *t2;
isc_task_t *task;
isc_mem_t *mctx, *mctx2;
RUNTIME_CHECK(isc_app_start() == ISC_R_SUCCESS);

84
bin/tests/optional/sig0_test.c
View file

@ -51,24 +51,23 @@
} \
}
isc_mutex_t lock;
dst_key_t * key;
isc_mem_t * mctx;
unsigned char qdata[1024], rdata[1024];
isc_buffer_t qbuffer, rbuffer;
isc_taskmgr_t * taskmgr;
isc_task_t * task1;
isc_log_t * lctx = NULL;
isc_logconfig_t * logconfig = NULL;
isc_socket_t * s;
isc_sockaddr_t address;
char output[10 * 1024];
isc_buffer_t outbuf;
isc_mutex_t lock;
dst_key_t *key;
isc_mem_t *mctx;
unsigned char qdata[1024], rdata[1024];
isc_buffer_t qbuffer, rbuffer;
isc_taskmgr_t *taskmgr;
isc_task_t *task1;
isc_log_t *lctx = NULL;
isc_logconfig_t *logconfig = NULL;
isc_socket_t *s;
isc_sockaddr_t address;
char output[10 * 1024];
isc_buffer_t outbuf;
static const dns_master_style_t *style = &dns_master_style_debug;
static void
senddone(isc_task_t *task, isc_event_t *event)
{
senddone(isc_task_t *task, isc_event_t *event) {
isc_socketevent_t *sevent = (isc_socketevent_t *)event;
REQUIRE(sevent != NULL);
@ -81,12 +80,11 @@ senddone(isc_task_t *task, isc_event_t *event)
}
static void
recvdone(isc_task_t *task, isc_event_t *event)
{
recvdone(isc_task_t *task, isc_event_t *event) {
isc_socketevent_t *sevent = (isc_socketevent_t *)event;
isc_buffer_t source;
isc_result_t result;
dns_message_t * response;
isc_buffer_t source;
isc_result_t result;
dns_message_t *response;
REQUIRE(sevent != NULL);
REQUIRE(sevent->ev_type == ISC_SOCKEVENT_RECVDONE);
@ -120,18 +118,17 @@ recvdone(isc_task_t *task, isc_event_t *event)
}
static void
buildquery(void)
{
isc_result_t result;
buildquery(void) {
isc_result_t result;
dns_rdataset_t *question = NULL;
dns_name_t * qname = NULL;
isc_region_t r, inr;
dns_message_t * query;
char nametext[] = "host.example";
isc_buffer_t namesrc, namedst;
unsigned char namedata[256];
isc_sockaddr_t sa;
dns_compress_t cctx;
dns_name_t *qname = NULL;
isc_region_t r, inr;
dns_message_t *query;
char nametext[] = "host.example";
isc_buffer_t namesrc, namedst;
unsigned char namedata[256];
isc_sockaddr_t sa;
dns_compress_t cctx;
query = NULL;
result = dns_message_create(mctx, DNS_MESSAGE_INTENTRENDER, &query);
@ -181,8 +178,8 @@ buildquery(void)
isc_sockaddr_any(&sa);
result = isc_socket_bind(s, &sa, 0);
CHECK("isc_socket_bind", result);
result =
isc_socket_sendto(s, &r, task1, senddone, NULL, &address, NULL);
result = isc_socket_sendto(s, &r, task1, senddone, NULL, &address,
NULL);
CHECK("isc_socket_sendto", result);
inr.base = rdata;
@ -193,18 +190,17 @@ buildquery(void)
}
int
main(int argc, char *argv[])
{
bool verbose = false;
main(int argc, char *argv[]) {
bool verbose = false;
isc_socketmgr_t *socketmgr;
isc_timermgr_t * timermgr;
struct in_addr inaddr;
dns_fixedname_t fname;
dns_name_t * name;
isc_buffer_t b;
int ch;
isc_result_t result;
in_port_t port = 53;
isc_timermgr_t *timermgr;
struct in_addr inaddr;
dns_fixedname_t fname;
dns_name_t *name;
isc_buffer_t b;
int ch;
isc_result_t result;
in_port_t port = 53;
RUNTIME_CHECK(isc_app_start() == ISC_R_SUCCESS);

76
bin/tests/optional/sock_test.c
View file

@ -21,12 +21,11 @@
#include <isc/timer.h>
#include <isc/util.h>
isc_mem_t * mctx;
isc_mem_t *mctx;
isc_taskmgr_t *manager;
static void
my_shutdown(isc_task_t *task, isc_event_t *event)
{
my_shutdown(isc_task_t *task, isc_event_t *event) {
char *name = event->ev_arg;
printf("shutdown %s (%p)\n", name, task);
@ -35,9 +34,8 @@ my_shutdown(isc_task_t *task, isc_event_t *event)
}
static void
my_send(isc_task_t *task, isc_event_t *event)
{
isc_socket_t * sock;
my_send(isc_task_t *task, isc_event_t *event) {
isc_socket_t *sock;
isc_socketevent_t *dev;
sock = event->ev_sender;
@ -61,13 +59,12 @@ my_send(isc_task_t *task, isc_event_t *event)
}
static void
my_recv(isc_task_t *task, isc_event_t *event)
{
isc_socket_t * sock;
my_recv(isc_task_t *task, isc_event_t *event) {
isc_socket_t *sock;
isc_socketevent_t *dev;
isc_region_t region;
char buf[1024];
char host[256];
isc_region_t region;
char buf[1024];
char host[256];
sock = event->ev_sender;
dev = (isc_socketevent_t *)event;
@ -124,9 +121,8 @@ my_recv(isc_task_t *task, isc_event_t *event)
}
static void
my_http_get(isc_task_t *task, isc_event_t *event)
{
isc_socket_t * sock;
my_http_get(isc_task_t *task, isc_event_t *event) {
isc_socket_t *sock;
isc_socketevent_t *dev;
sock = event->ev_sender;
@ -153,12 +149,11 @@ my_http_get(isc_task_t *task, isc_event_t *event)
}
static void
my_connect(isc_task_t *task, isc_event_t *event)
{
isc_socket_t * sock;
my_connect(isc_task_t *task, isc_event_t *event) {
isc_socket_t *sock;
isc_socket_connev_t *dev;
isc_region_t region;
char buf[1024];
isc_region_t region;
char buf[1024];
sock = event->ev_sender;
dev = (isc_socket_connev_t *)event;
@ -192,13 +187,12 @@ my_connect(isc_task_t *task, isc_event_t *event)
}
static void
my_listen(isc_task_t *task, isc_event_t *event)
{
char * name = event->ev_arg;
my_listen(isc_task_t *task, isc_event_t *event) {
char *name = event->ev_arg;
isc_socket_newconnev_t *dev;
isc_region_t region;
isc_socket_t * oldsock;
isc_task_t * newtask;
isc_region_t region;
isc_socket_t *oldsock;
isc_task_t *newtask;
dev = (isc_socket_newconnev_t *)event;
@ -242,8 +236,7 @@ my_listen(isc_task_t *task, isc_event_t *event)
}
static void
timeout(isc_task_t *task, isc_event_t *event)
{
timeout(isc_task_t *task, isc_event_t *event) {
isc_socket_t *sock = event->ev_arg;
printf("Timeout, canceling IO on socket %p (task %p)\n", sock, task);
@ -259,21 +252,20 @@ static char xso1[] = "so1";
static char xso2[] = "so2";
int
main(int argc, char *argv[])
{
isc_task_t * t1, *t2;
isc_timermgr_t * timgr;
isc_time_t expires;
isc_interval_t interval;
isc_timer_t * ti1;
unsigned int workers;
main(int argc, char *argv[]) {
isc_task_t *t1, *t2;
isc_timermgr_t *timgr;
isc_time_t expires;
isc_interval_t interval;
isc_timer_t *ti1;
unsigned int workers;
isc_socketmgr_t *socketmgr;
isc_socket_t * so1, *so2;
isc_sockaddr_t sockaddr;
struct in_addr ina;
struct in6_addr in6a;
isc_result_t result;
int pf;
isc_socket_t *so1, *so2;
isc_sockaddr_t sockaddr;
struct in_addr ina;
struct in6_addr in6a;
isc_result_t result;
int pf;
if (argc > 1) {
workers = atoi(argv[1]);

22
bin/tests/optional/sym_test.c
View file

@ -18,12 +18,11 @@
#include <isc/symtab.h>
#include <isc/util.h>
isc_mem_t * mctx;
isc_mem_t *mctx;
isc_symtab_t *st;
static void
undefine_action(char *key, unsigned int type, isc_symvalue_t value, void *arg)
{
undefine_action(char *key, unsigned int type, isc_symvalue_t value, void *arg) {
UNUSED(arg);
INSIST(type == 1);
@ -32,16 +31,15 @@ undefine_action(char *key, unsigned int type, isc_symvalue_t value, void *arg)
}
int
main(int argc, char *argv[])
{
char s[1000], *cp, *key;
size_t len;
isc_result_t result;
isc_symvalue_t value;
int trace = 0;
int c;
main(int argc, char *argv[]) {
char s[1000], *cp, *key;
size_t len;
isc_result_t result;
isc_symvalue_t value;
int trace = 0;
int c;
isc_symexists_t exists_policy = isc_symexists_reject;
bool case_sensitive = false;
bool case_sensitive = false;
while ((c = isc_commandline_parse(argc, argv, "tarc")) != -1) {
switch (c) {

28
bin/tests/optional/task_test.c
View file

@ -22,9 +22,8 @@
isc_mem_t *mctx = NULL;
static void
my_callback(isc_task_t *task, isc_event_t *event)
{
int i, j;
my_callback(isc_task_t *task, isc_event_t *event) {
int i, j;
char *name = event->ev_arg;
j = 0;
@ -36,8 +35,7 @@ my_callback(isc_task_t *task, isc_event_t *event)
}
static void
my_shutdown(isc_task_t *task, isc_event_t *event)
{
my_shutdown(isc_task_t *task, isc_event_t *event) {
char *name = event->ev_arg;
printf("shutdown %s (%p)\n", name, task);
@ -45,8 +43,7 @@ my_shutdown(isc_task_t *task, isc_event_t *event)
}
static void
my_tick(isc_task_t *task, isc_event_t *event)
{
my_tick(isc_task_t *task, isc_event_t *event) {
char *name = event->ev_arg;
printf("task %p tick %s\n", task, name);
@ -61,15 +58,14 @@ static char foo[] = "foo";
static char bar[] = "bar";
int
main(int argc, char *argv[])
{
isc_taskmgr_t * manager = NULL;
isc_task_t * t1 = NULL, *t2 = NULL;
isc_task_t * t3 = NULL, *t4 = NULL;
isc_event_t * event;
unsigned int workers;
isc_timermgr_t * timgr;
isc_timer_t * ti1, *ti2;
main(int argc, char *argv[]) {
isc_taskmgr_t *manager = NULL;
isc_task_t *t1 = NULL, *t2 = NULL;
isc_task_t *t3 = NULL, *t4 = NULL;
isc_event_t *event;
unsigned int workers;
isc_timermgr_t *timgr;
isc_timer_t *ti1, *ti2;
struct isc_interval interval;
if (argc > 1) {

30
bin/tests/optional/timer_test.c
View file

@ -20,14 +20,13 @@
#include <isc/timer.h>
#include <isc/util.h>
isc_mem_t * mctx1, *mctx2, *mctx3;
isc_task_t * t1, *t2, *t3;
isc_mem_t *mctx1, *mctx2, *mctx3;
isc_task_t *t1, *t2, *t3;
isc_timer_t *ti1, *ti2, *ti3;
int tick_count = 0;
int tick_count = 0;
static void
shutdown_task(isc_task_t *task, isc_event_t *event)
{
shutdown_task(isc_task_t *task, isc_event_t *event) {
char *name = event->ev_arg;
printf("task %p shutdown %s\n", task, name);
@ -35,8 +34,7 @@ shutdown_task(isc_task_t *task, isc_event_t *event)
}
static void
tick(isc_task_t *task, isc_event_t *event)
{
tick(isc_task_t *task, isc_event_t *event) {
char *name = event->ev_arg;
INSIST(event->ev_type == ISC_TIMEREVENT_TICK);
@ -49,7 +47,7 @@ tick(isc_task_t *task, isc_event_t *event)
}
if (ti3 != NULL && tick_count == 7) {
isc_time_t expires;
isc_time_t expires;
isc_interval_t interval;
isc_interval_set(&interval, 5, 0);
@ -65,9 +63,8 @@ tick(isc_task_t *task, isc_event_t *event)
}
static void
timeout(isc_task_t *task, isc_event_t *event)
{
char * name = event->ev_arg;
timeout(isc_task_t *task, isc_event_t *event) {
char *name = event->ev_arg;
const char *type;
INSIST(event->ev_type == ISC_TIMEREVENT_IDLE ||
@ -95,13 +92,12 @@ static char two[] = "2";
static char three[] = "3";
int
main(int argc, char *argv[])
{
isc_taskmgr_t * manager = NULL;
main(int argc, char *argv[]) {
isc_taskmgr_t *manager = NULL;
isc_timermgr_t *timgr = NULL;
unsigned int workers;
isc_time_t expires, now;
isc_interval_t interval;
unsigned int workers;
isc_time_t expires, now;
isc_interval_t interval;
if (argc > 1) {
workers = atoi(argv[1]);

67
bin/tests/optional/zone_test.c
View file

@ -34,17 +34,17 @@
#include <sys/time.h>
#include <sys/types.h>
static int debug = 0;
static int quiet = 0;
static int stats = 0;
static int debug = 0;
static int quiet = 0;
static int stats = 0;
static isc_mem_t *mctx = NULL;
dns_zone_t * zone = NULL;
isc_taskmgr_t * taskmgr = NULL;
isc_timermgr_t * timermgr = NULL;
isc_socketmgr_t * socketmgr = NULL;
dns_zonemgr_t * zonemgr = NULL;
dns_zonetype_t zonetype = dns_zone_master;
isc_sockaddr_t addr;
dns_zone_t *zone = NULL;
isc_taskmgr_t *taskmgr = NULL;
isc_timermgr_t *timermgr = NULL;
isc_socketmgr_t *socketmgr = NULL;
dns_zonemgr_t *zonemgr = NULL;
dns_zonetype_t zonetype = dns_zone_master;
isc_sockaddr_t addr;
#define ERRRET(result, function) \
do { \
@ -64,23 +64,21 @@ isc_sockaddr_t addr;
(void)NULL
static void
usage(void)
{
usage(void) {
fprintf(stderr, "usage: zone_test [-dqsSM] [-c class] [-f file] "
"zone\n");
exit(1);
}
static void
setup(const char *zonename, const char *filename, const char *classname)
{
isc_result_t result;
dns_rdataclass_t rdclass;
setup(const char *zonename, const char *filename, const char *classname) {
isc_result_t result;
dns_rdataclass_t rdclass;
isc_consttextregion_t region;
isc_buffer_t buffer;
dns_fixedname_t fixorigin;
dns_name_t * origin;
const char * rbt = "rbt";
isc_buffer_t buffer;
dns_fixedname_t fixorigin;
dns_name_t *origin;
const char *rbt = "rbt";
if (debug) {
fprintf(stderr, "loading \"%s\" from \"%s\" class \"%s\"\n",
@ -128,10 +126,9 @@ setup(const char *zonename, const char *filename, const char *classname)
}
static void
print_rdataset(dns_name_t *name, dns_rdataset_t *rdataset)
{
print_rdataset(dns_name_t *name, dns_rdataset_t *rdataset) {
isc_buffer_t text;
char t[1000];
char t[1000];
isc_result_t result;
isc_region_t r;
@ -146,17 +143,16 @@ print_rdataset(dns_name_t *name, dns_rdataset_t *rdataset)
}
static void
query(void)
{
char buf[1024];
query(void) {
char buf[1024];
dns_fixedname_t name;
dns_fixedname_t found;
dns_db_t * db;
isc_buffer_t buffer;
isc_result_t result;
dns_rdataset_t rdataset;
dns_rdataset_t sigset;
fd_set rfdset = { { 0 } };
dns_db_t *db;
isc_buffer_t buffer;
isc_result_t result;
dns_rdataset_t rdataset;
dns_rdataset_t sigset;
fd_set rfdset = { { 0 } };
db = NULL;
result = dns_zone_getdb(zone, &db);
@ -237,10 +233,9 @@ query(void)
}
int
main(int argc, char **argv)
{
int c;
char * filename = NULL;
main(int argc, char **argv) {
int c;
char *filename = NULL;
const char *classname = "IN";
while ((c = isc_commandline_parse(argc, argv, "cdf:m:qsMS")) != EOF) {

54
bin/tests/pkcs11/benchmarks/create.c
View file

@ -61,14 +61,12 @@
#define CLOCK_REALTIME 0
#endif /* ifndef CLOCK_REALTIME */
static int
clock_gettime(int32_t id, struct timespec *tp);
static int clock_gettime(int32_t id, struct timespec *tp);
static int
clock_gettime(int32_t id, struct timespec *tp)
{
clock_gettime(int32_t id, struct timespec *tp) {
struct timeval tv;
int result;
int result;
UNUSED(id);
@ -82,36 +80,35 @@ clock_gettime(int32_t id, struct timespec *tp)
#endif /* ifndef HAVE_CLOCK_GETTIME */
CK_BYTE buf[1024];
char label[16];
char label[16];
static CK_BBOOL truevalue = TRUE;
static CK_BBOOL falsevalue = FALSE;
int
main(int argc, char *argv[])
{
isc_result_t result;
CK_RV rv;
CK_SLOT_ID slot = 0;
main(int argc, char *argv[]) {
isc_result_t result;
CK_RV rv;
CK_SLOT_ID slot = 0;
CK_SESSION_HANDLE hSession = CK_INVALID_HANDLE;
CK_OBJECT_HANDLE *hKey;
CK_OBJECT_CLASS kClass = CKO_DATA;
CK_ULONG len = sizeof(buf);
CK_ATTRIBUTE kTemplate[] = {
{ CKA_CLASS, &kClass, (CK_ULONG)sizeof(kClass) },
{ CKA_TOKEN, &falsevalue, (CK_ULONG)sizeof(falsevalue) },
{ CKA_PRIVATE, &falsevalue, (CK_ULONG)sizeof(falsevalue) },
{ CKA_LABEL, (CK_BYTE_PTR)label, (CK_ULONG)sizeof(label) },
{ CKA_VALUE, buf, (CK_ULONG)sizeof(buf) }
CK_OBJECT_CLASS kClass = CKO_DATA;
CK_ULONG len = sizeof(buf);
CK_ATTRIBUTE kTemplate[] = {
{ CKA_CLASS, &kClass, (CK_ULONG)sizeof(kClass) },
{ CKA_TOKEN, &falsevalue, (CK_ULONG)sizeof(falsevalue) },
{ CKA_PRIVATE, &falsevalue, (CK_ULONG)sizeof(falsevalue) },
{ CKA_LABEL, (CK_BYTE_PTR)label, (CK_ULONG)sizeof(label) },
{ CKA_VALUE, buf, (CK_ULONG)sizeof(buf) }
};
pk11_context_t pctx;
char * lib_name = NULL;
char * pin = NULL;
int error = 0;
int c, errflg = 0;
int ontoken = 0;
unsigned int count = 1000;
unsigned int i;
pk11_context_t pctx;
char *lib_name = NULL;
char *pin = NULL;
int error = 0;
int c, errflg = 0;
int ontoken = 0;
unsigned int count = 1000;
unsigned int i;
struct timespec starttime;
struct timespec endtime;
@ -176,7 +173,8 @@ main(int argc, char *argv[])
(const char *)pin, slot);
if ((result != ISC_R_SUCCESS) && (result != PK11_R_NORANDOMSERVICE) &&
(result != PK11_R_NODIGESTSERVICE) &&
(result != PK11_R_NOAESSERVICE)) {
(result != PK11_R_NOAESSERVICE))
{
fprintf(stderr, "Error initializing PKCS#11: %s\n",
isc_result_totext(result));
exit(1);

46
bin/tests/pkcs11/benchmarks/find.c
View file

@ -61,14 +61,12 @@
#define CLOCK_REALTIME 0
#endif /* ifndef CLOCK_REALTIME */
static int
clock_gettime(int32_t id, struct timespec *tp);
static int clock_gettime(int32_t id, struct timespec *tp);
static int
clock_gettime(int32_t id, struct timespec *tp)
{
clock_gettime(int32_t id, struct timespec *tp) {
struct timeval tv;
int result;
int result;
UNUSED(id);
@ -84,27 +82,26 @@ clock_gettime(int32_t id, struct timespec *tp)
CK_BYTE label[] = "foo??bar!!";
int
main(int argc, char *argv[])
{
isc_result_t result;
CK_RV rv;
CK_SLOT_ID slot = 0;
main(int argc, char *argv[]) {
isc_result_t result;
CK_RV rv;
CK_SLOT_ID slot = 0;
CK_SESSION_HANDLE hSession = CK_INVALID_HANDLE;
CK_ATTRIBUTE sTemplate[] = {
{ CKA_LABEL, label, (CK_ULONG)sizeof(label) },
CK_ATTRIBUTE sTemplate[] = {
{ CKA_LABEL, label, (CK_ULONG)sizeof(label) },
};
CK_OBJECT_HANDLE sKey = CK_INVALID_HANDLE;
CK_ULONG found = 0;
pk11_context_t pctx;
pk11_optype_t op_type = OP_RSA;
char * lib_name = NULL;
char * pin = NULL;
int error = 0;
int c, errflg = 0;
unsigned int count = 1000;
unsigned int i;
struct timespec starttime;
struct timespec endtime;
CK_ULONG found = 0;
pk11_context_t pctx;
pk11_optype_t op_type = OP_RSA;
char *lib_name = NULL;
char *pin = NULL;
int error = 0;
int c, errflg = 0;
unsigned int count = 1000;
unsigned int i;
struct timespec starttime;
struct timespec endtime;
while ((c = isc_commandline_parse(argc, argv, ":m:s:p:n:")) != -1) {
switch (c) {
@ -156,7 +153,8 @@ main(int argc, char *argv[])
(const char *)pin, slot);
if ((result != ISC_R_SUCCESS) && (result != PK11_R_NORANDOMSERVICE) &&
(result != PK11_R_NODIGESTSERVICE) &&
(result != PK11_R_NOAESSERVICE)) {
(result != PK11_R_NOAESSERVICE))
{
fprintf(stderr, "Error initializing PKCS#11: %s\n",
isc_result_totext(result));
exit(1);

66
bin/tests/pkcs11/benchmarks/genrsa.c
View file

@ -61,14 +61,12 @@
#define CLOCK_REALTIME 0
#endif /* ifndef CLOCK_REALTIME */
static int
clock_gettime(int32_t id, struct timespec *tp);
static int clock_gettime(int32_t id, struct timespec *tp);
static int
clock_gettime(int32_t id, struct timespec *tp)
{
clock_gettime(int32_t id, struct timespec *tp) {
struct timeval tv;
int result;
int result;
UNUSED(id);
@ -85,28 +83,27 @@ static CK_BBOOL truevalue = TRUE;
static CK_BBOOL falsevalue = FALSE;
int
main(int argc, char *argv[])
{
isc_result_t result;
CK_RV rv;
CK_SLOT_ID slot = 0;
main(int argc, char *argv[]) {
isc_result_t result;
CK_RV rv;
CK_SLOT_ID slot = 0;
CK_SESSION_HANDLE hSession = CK_INVALID_HANDLE;
CK_MECHANISM mech = { CKM_RSA_PKCS_KEY_PAIR_GEN, NULL, 0 };
CK_MECHANISM mech = { CKM_RSA_PKCS_KEY_PAIR_GEN, NULL, 0 };
CK_OBJECT_HANDLE *pubKey;
CK_OBJECT_HANDLE *privKey;
CK_OBJECT_CLASS pubClass = CKO_PUBLIC_KEY;
CK_OBJECT_CLASS privClass = CKO_PRIVATE_KEY;
CK_KEY_TYPE kType = CKK_RSA;
CK_ULONG bits = 1024;
CK_BYTE exponent[] = { 0x01, 0x00, 0x01 };
CK_ATTRIBUTE pubTemplate[] = {
{ CKA_CLASS, &pubClass, (CK_ULONG)sizeof(pubClass) },
{ CKA_KEY_TYPE, &kType, (CK_ULONG)sizeof(kType) },
{ CKA_TOKEN, &falsevalue, (CK_ULONG)sizeof(falsevalue) },
{ CKA_PRIVATE, &falsevalue, (CK_ULONG)sizeof(falsevalue) },
{ CKA_VERIFY, &truevalue, (CK_ULONG)sizeof(truevalue) },
{ CKA_MODULUS_BITS, &bits, (CK_ULONG)sizeof(bits) },
{ CKA_PUBLIC_EXPONENT, exponent, (CK_ULONG)sizeof(exponent) }
CK_OBJECT_CLASS pubClass = CKO_PUBLIC_KEY;
CK_OBJECT_CLASS privClass = CKO_PRIVATE_KEY;
CK_KEY_TYPE kType = CKK_RSA;
CK_ULONG bits = 1024;
CK_BYTE exponent[] = { 0x01, 0x00, 0x01 };
CK_ATTRIBUTE pubTemplate[] = {
{ CKA_CLASS, &pubClass, (CK_ULONG)sizeof(pubClass) },
{ CKA_KEY_TYPE, &kType, (CK_ULONG)sizeof(kType) },
{ CKA_TOKEN, &falsevalue, (CK_ULONG)sizeof(falsevalue) },
{ CKA_PRIVATE, &falsevalue, (CK_ULONG)sizeof(falsevalue) },
{ CKA_VERIFY, &truevalue, (CK_ULONG)sizeof(truevalue) },
{ CKA_MODULUS_BITS, &bits, (CK_ULONG)sizeof(bits) },
{ CKA_PUBLIC_EXPONENT, exponent, (CK_ULONG)sizeof(exponent) }
};
CK_ATTRIBUTE privTemplate[] = {
{ CKA_CLASS, &privClass, (CK_ULONG)sizeof(privClass) },
@ -115,15 +112,15 @@ main(int argc, char *argv[])
{ CKA_PRIVATE, &truevalue, (CK_ULONG)sizeof(truevalue) },
{ CKA_SIGN, &truevalue, (CK_ULONG)sizeof(truevalue) },
};
pk11_context_t pctx;
pk11_optype_t op_type = OP_RSA;
char * lib_name = NULL;
char * pin = NULL;
int error = 0;
int c, errflg = 0;
int ontoken = 0;
unsigned int count = 1000;
unsigned int i;
pk11_context_t pctx;
pk11_optype_t op_type = OP_RSA;
char *lib_name = NULL;
char *pin = NULL;
int error = 0;
int c, errflg = 0;
int ontoken = 0;
unsigned int count = 1000;
unsigned int i;
struct timespec starttime;
struct timespec endtime;
@ -201,7 +198,8 @@ main(int argc, char *argv[])
(const char *)pin, slot);
if ((result != ISC_R_SUCCESS) && (result != PK11_R_NORANDOMSERVICE) &&
(result != PK11_R_NODIGESTSERVICE) &&
(result != PK11_R_NOAESSERVICE)) {
(result != PK11_R_NOAESSERVICE))
{
fprintf(stderr, "Error initializing PKCS#11: %s\n",
isc_result_totext(result));
exit(1);

31
bin/tests/pkcs11/benchmarks/login.c
View file

@ -61,14 +61,12 @@
#define CLOCK_REALTIME 0
#endif /* ifndef CLOCK_REALTIME */
static int
clock_gettime(int32_t id, struct timespec *tp);
static int clock_gettime(int32_t id, struct timespec *tp);
static int
clock_gettime(int32_t id, struct timespec *tp)
{
clock_gettime(int32_t id, struct timespec *tp) {
struct timeval tv;
int result;
int result;
UNUSED(id);
@ -82,19 +80,18 @@ clock_gettime(int32_t id, struct timespec *tp)
#endif /* ifndef HAVE_CLOCK_GETTIME */
int
main(int argc, char *argv[])
{
CK_RV rv;
CK_SLOT_ID slot = 0;
main(int argc, char *argv[]) {
CK_RV rv;
CK_SLOT_ID slot = 0;
CK_SESSION_HANDLE *hSession;
CK_UTF8CHAR * pin = NULL;
char * lib_name = NULL;
int error = 0;
int c, errflg = 0;
unsigned int count = 1000;
unsigned int i, j;
struct timespec starttime;
struct timespec endtime;
CK_UTF8CHAR *pin = NULL;
char *lib_name = NULL;
int error = 0;
int c, errflg = 0;
unsigned int count = 1000;
unsigned int i, j;
struct timespec starttime;
struct timespec endtime;
while ((c = isc_commandline_parse(argc, argv, ":m:s:p:n:")) != -1) {
switch (c) {

72
bin/tests/pkcs11/benchmarks/privrsa.c
View file

@ -61,14 +61,12 @@
#define CLOCK_REALTIME 0
#endif /* ifndef CLOCK_REALTIME */
static int
clock_gettime(int32_t id, struct timespec *tp);
static int clock_gettime(int32_t id, struct timespec *tp);
static int
clock_gettime(int32_t id, struct timespec *tp)
{
clock_gettime(int32_t id, struct timespec *tp) {
struct timeval tv;
int result;
int result;
UNUSED(id);
@ -150,40 +148,39 @@ static CK_BBOOL truevalue = TRUE;
static CK_BBOOL falsevalue = FALSE;
int
main(int argc, char *argv[])
{
isc_result_t result;
CK_RV rv;
CK_SLOT_ID slot = 0;
main(int argc, char *argv[]) {
isc_result_t result;
CK_RV rv;
CK_SLOT_ID slot = 0;
CK_SESSION_HANDLE hSession = CK_INVALID_HANDLE;
CK_OBJECT_HANDLE *hKey;
CK_OBJECT_CLASS kClass = CKO_PRIVATE_KEY;
CK_KEY_TYPE kType = CKK_RSA;
CK_ATTRIBUTE kTemplate[] = {
{ CKA_CLASS, &kClass, (CK_ULONG)sizeof(kClass) },
{ CKA_KEY_TYPE, &kType, (CK_ULONG)sizeof(kType) },
{ CKA_TOKEN, &falsevalue, (CK_ULONG)sizeof(falsevalue) },
{ CKA_PRIVATE, &truevalue, (CK_ULONG)sizeof(truevalue) },
{ CKA_LABEL, (CK_BYTE_PTR)label, (CK_ULONG)sizeof(label) },
{ CKA_SIGN, &truevalue, (CK_ULONG)sizeof(truevalue) },
{ CKA_MODULUS, modulus, (CK_ULONG)sizeof(modulus) },
{ CKA_PUBLIC_EXPONENT, pubexp, (CK_ULONG)sizeof(pubexp) },
{ CKA_PRIVATE_EXPONENT, privexp, (CK_ULONG)sizeof(privexp) },
{ CKA_PRIME_1, prime1, (CK_ULONG)sizeof(prime1) },
{ CKA_PRIME_2, prime2, (CK_ULONG)sizeof(prime2) },
{ CKA_EXPONENT_1, exp_1, (CK_ULONG)sizeof(exp_1) },
{ CKA_EXPONENT_2, exp_2, (CK_ULONG)sizeof(exp_2) },
{ CKA_COEFFICIENT, coeff, (CK_ULONG)sizeof(coeff) }
CK_OBJECT_CLASS kClass = CKO_PRIVATE_KEY;
CK_KEY_TYPE kType = CKK_RSA;
CK_ATTRIBUTE kTemplate[] = {
{ CKA_CLASS, &kClass, (CK_ULONG)sizeof(kClass) },
{ CKA_KEY_TYPE, &kType, (CK_ULONG)sizeof(kType) },
{ CKA_TOKEN, &falsevalue, (CK_ULONG)sizeof(falsevalue) },
{ CKA_PRIVATE, &truevalue, (CK_ULONG)sizeof(truevalue) },
{ CKA_LABEL, (CK_BYTE_PTR)label, (CK_ULONG)sizeof(label) },
{ CKA_SIGN, &truevalue, (CK_ULONG)sizeof(truevalue) },
{ CKA_MODULUS, modulus, (CK_ULONG)sizeof(modulus) },
{ CKA_PUBLIC_EXPONENT, pubexp, (CK_ULONG)sizeof(pubexp) },
{ CKA_PRIVATE_EXPONENT, privexp, (CK_ULONG)sizeof(privexp) },
{ CKA_PRIME_1, prime1, (CK_ULONG)sizeof(prime1) },
{ CKA_PRIME_2, prime2, (CK_ULONG)sizeof(prime2) },
{ CKA_EXPONENT_1, exp_1, (CK_ULONG)sizeof(exp_1) },
{ CKA_EXPONENT_2, exp_2, (CK_ULONG)sizeof(exp_2) },
{ CKA_COEFFICIENT, coeff, (CK_ULONG)sizeof(coeff) }
};
pk11_context_t pctx;
pk11_optype_t op_type = OP_RSA;
char * lib_name = NULL;
char * pin = NULL;
int error = 0;
int c, errflg = 0;
int ontoken = 0;
unsigned int count = 1000;
unsigned int i;
pk11_context_t pctx;
pk11_optype_t op_type = OP_RSA;
char *lib_name = NULL;
char *pin = NULL;
int error = 0;
int c, errflg = 0;
int ontoken = 0;
unsigned int count = 1000;
unsigned int i;
struct timespec starttime;
struct timespec endtime;
@ -249,7 +246,8 @@ main(int argc, char *argv[])
(const char *)pin, slot);
if ((result != ISC_R_SUCCESS) && (result != PK11_R_NORANDOMSERVICE) &&
(result != PK11_R_NODIGESTSERVICE) &&
(result != PK11_R_NOAESSERVICE)) {
(result != PK11_R_NOAESSERVICE))
{
fprintf(stderr, "Error initializing PKCS#11: %s\n",
isc_result_totext(result));
free(hKey);

60
bin/tests/pkcs11/benchmarks/pubrsa.c
View file

@ -61,14 +61,12 @@
#define CLOCK_REALTIME 0
#endif /* ifndef CLOCK_REALTIME */
static int
clock_gettime(int32_t id, struct timespec *tp);
static int clock_gettime(int32_t id, struct timespec *tp);
static int
clock_gettime(int32_t id, struct timespec *tp)
{
clock_gettime(int32_t id, struct timespec *tp) {
struct timeval tv;
int result;
int result;
UNUSED(id);
@ -102,34 +100,33 @@ static CK_BBOOL truevalue = TRUE;
static CK_BBOOL falsevalue = FALSE;
int
main(int argc, char *argv[])
{
isc_result_t result;
CK_RV rv;
CK_SLOT_ID slot = 0;
main(int argc, char *argv[]) {
isc_result_t result;
CK_RV rv;
CK_SLOT_ID slot = 0;
CK_SESSION_HANDLE hSession = CK_INVALID_HANDLE;
CK_OBJECT_HANDLE *hKey;
CK_OBJECT_CLASS kClass = CKO_PUBLIC_KEY;
CK_KEY_TYPE kType = CKK_RSA;
CK_ATTRIBUTE kTemplate[] = {
{ CKA_CLASS, &kClass, (CK_ULONG)sizeof(kClass) },
{ CKA_KEY_TYPE, &kType, (CK_ULONG)sizeof(kType) },
{ CKA_TOKEN, &falsevalue, (CK_ULONG)sizeof(falsevalue) },
{ CKA_PRIVATE, &falsevalue, (CK_ULONG)sizeof(falsevalue) },
{ CKA_LABEL, (CK_BYTE_PTR)label, (CK_ULONG)sizeof(label) },
{ CKA_VERIFY, &truevalue, (CK_ULONG)sizeof(truevalue) },
{ CKA_MODULUS, modulus, (CK_ULONG)sizeof(modulus) },
{ CKA_PUBLIC_EXPONENT, exponent, (CK_ULONG)sizeof(exponent) }
CK_OBJECT_CLASS kClass = CKO_PUBLIC_KEY;
CK_KEY_TYPE kType = CKK_RSA;
CK_ATTRIBUTE kTemplate[] = {
{ CKA_CLASS, &kClass, (CK_ULONG)sizeof(kClass) },
{ CKA_KEY_TYPE, &kType, (CK_ULONG)sizeof(kType) },
{ CKA_TOKEN, &falsevalue, (CK_ULONG)sizeof(falsevalue) },
{ CKA_PRIVATE, &falsevalue, (CK_ULONG)sizeof(falsevalue) },
{ CKA_LABEL, (CK_BYTE_PTR)label, (CK_ULONG)sizeof(label) },
{ CKA_VERIFY, &truevalue, (CK_ULONG)sizeof(truevalue) },
{ CKA_MODULUS, modulus, (CK_ULONG)sizeof(modulus) },
{ CKA_PUBLIC_EXPONENT, exponent, (CK_ULONG)sizeof(exponent) }
};
pk11_context_t pctx;
pk11_optype_t op_type = OP_RSA;
char * lib_name = NULL;
char * pin = NULL;
int error = 0;
int c, errflg = 0;
int ontoken = 0;
unsigned int count = 1000;
unsigned int i;
pk11_context_t pctx;
pk11_optype_t op_type = OP_RSA;
char *lib_name = NULL;
char *pin = NULL;
int error = 0;
int c, errflg = 0;
int ontoken = 0;
unsigned int count = 1000;
unsigned int i;
struct timespec starttime;
struct timespec endtime;
@ -195,7 +192,8 @@ main(int argc, char *argv[])
(const char *)pin, slot);
if ((result != ISC_R_SUCCESS) && (result != PK11_R_NORANDOMSERVICE) &&
(result != PK11_R_NODIGESTSERVICE) &&
(result != PK11_R_NOAESSERVICE)) {
(result != PK11_R_NOAESSERVICE))
{
fprintf(stderr, "Error initializing PKCS#11: %s\n",
isc_result_totext(result));
free(hKey);

29
bin/tests/pkcs11/benchmarks/session.c
View file

@ -61,14 +61,12 @@
#define CLOCK_REALTIME 0
#endif /* ifndef CLOCK_REALTIME */
static int
clock_gettime(int32_t id, struct timespec *tp);
static int clock_gettime(int32_t id, struct timespec *tp);
static int
clock_gettime(int32_t id, struct timespec *tp)
{
clock_gettime(int32_t id, struct timespec *tp) {
struct timeval tv;
int result;
int result;
UNUSED(id);
@ -82,18 +80,17 @@ clock_gettime(int32_t id, struct timespec *tp)
#endif /* ifndef HAVE_CLOCK_GETTIME */
int
main(int argc, char *argv[])
{
CK_RV rv;
CK_SLOT_ID slot = 0;
main(int argc, char *argv[]) {
CK_RV rv;
CK_SLOT_ID slot = 0;
CK_SESSION_HANDLE *hSession;
char * lib_name = NULL;
int error = 0;
int c, errflg = 0;
unsigned int count = 1000;
unsigned int i;
struct timespec starttime;
struct timespec endtime;
char *lib_name = NULL;
int error = 0;
int c, errflg = 0;
unsigned int count = 1000;
unsigned int i;
struct timespec starttime;
struct timespec endtime;
while ((c = isc_commandline_parse(argc, argv, ":m:s:n:")) != -1) {
switch (c) {

42
bin/tests/pkcs11/benchmarks/sha1.c
View file

@ -61,14 +61,12 @@
#define CLOCK_REALTIME 0
#endif /* ifndef CLOCK_REALTIME */
static int
clock_gettime(int32_t id, struct timespec *tp);
static int clock_gettime(int32_t id, struct timespec *tp);
static int
clock_gettime(int32_t id, struct timespec *tp)
{
clock_gettime(int32_t id, struct timespec *tp) {
struct timeval tv;
int result;
int result;
UNUSED(id);
@ -84,23 +82,22 @@ clock_gettime(int32_t id, struct timespec *tp)
CK_BYTE buf[1024];
int
main(int argc, char *argv[])
{
isc_result_t result;
CK_RV rv;
CK_SLOT_ID slot = 0;
main(int argc, char *argv[]) {
isc_result_t result;
CK_RV rv;
CK_SLOT_ID slot = 0;
CK_SESSION_HANDLE hSession = CK_INVALID_HANDLE;
CK_MECHANISM mech = { CKM_SHA_1, NULL, 0 };
CK_ULONG len = sizeof(buf);
pk11_context_t pctx;
pk11_optype_t op_type = OP_DIGEST;
char * lib_name = NULL;
int error = 0;
int c, errflg = 0;
unsigned int count = 1000;
unsigned int i;
struct timespec starttime;
struct timespec endtime;
CK_MECHANISM mech = { CKM_SHA_1, NULL, 0 };
CK_ULONG len = sizeof(buf);
pk11_context_t pctx;
pk11_optype_t op_type = OP_DIGEST;
char *lib_name = NULL;
int error = 0;
int c, errflg = 0;
unsigned int count = 1000;
unsigned int i;
struct timespec starttime;
struct timespec endtime;
while ((c = isc_commandline_parse(argc, argv, ":m:s:n:")) != -1) {
switch (c) {
@ -143,7 +140,8 @@ main(int argc, char *argv[])
result = pk11_get_session(&pctx, op_type, false, false, false, NULL,
slot);
if ((result != ISC_R_SUCCESS) && (result != PK11_R_NORANDOMSERVICE) &&
(result != PK11_R_NOAESSERVICE)) {
(result != PK11_R_NOAESSERVICE))
{
fprintf(stderr, "Error initializing PKCS#11: %s\n",
isc_result_totext(result));
exit(1);

78
bin/tests/pkcs11/benchmarks/sign.c
View file

@ -61,14 +61,12 @@
#define CLOCK_REALTIME 0
#endif /* ifndef CLOCK_REALTIME */
static int
clock_gettime(int32_t id, struct timespec *tp);
static int clock_gettime(int32_t id, struct timespec *tp);
static int
clock_gettime(int32_t id, struct timespec *tp)
{
clock_gettime(int32_t id, struct timespec *tp) {
struct timeval tv;
int result;
int result;
UNUSED(id);
@ -151,42 +149,41 @@ static CK_BBOOL truevalue = TRUE;
static CK_BBOOL falsevalue = FALSE;
int
main(int argc, char *argv[])
{
isc_result_t result;
CK_RV rv;
CK_SLOT_ID slot = 0;
main(int argc, char *argv[]) {
isc_result_t result;
CK_RV rv;
CK_SLOT_ID slot = 0;
CK_SESSION_HANDLE hSession = CK_INVALID_HANDLE;
CK_ULONG len;
CK_ULONG slen;
CK_OBJECT_HANDLE hKey = CK_INVALID_HANDLE;
CK_OBJECT_CLASS kClass = CKO_PRIVATE_KEY;
CK_KEY_TYPE kType = CKK_RSA;
CK_ATTRIBUTE kTemplate[] = {
{ CKA_CLASS, &kClass, (CK_ULONG)sizeof(kClass) },
{ CKA_KEY_TYPE, &kType, (CK_ULONG)sizeof(kType) },
{ CKA_TOKEN, &falsevalue, (CK_ULONG)sizeof(falsevalue) },
{ CKA_PRIVATE, &truevalue, (CK_ULONG)sizeof(truevalue) },
{ CKA_SIGN, &truevalue, (CK_ULONG)sizeof(truevalue) },
{ CKA_MODULUS, modulus, (CK_ULONG)sizeof(modulus) },
{ CKA_PUBLIC_EXPONENT, pubexp, (CK_ULONG)sizeof(pubexp) },
{ CKA_PRIVATE_EXPONENT, privexp, (CK_ULONG)sizeof(privexp) },
{ CKA_PRIME_1, prime1, (CK_ULONG)sizeof(prime1) },
{ CKA_PRIME_2, prime2, (CK_ULONG)sizeof(prime2) },
{ CKA_EXPONENT_1, exp_1, (CK_ULONG)sizeof(exp_1) },
{ CKA_EXPONENT_2, exp_2, (CK_ULONG)sizeof(exp_2) },
{ CKA_COEFFICIENT, coeff, (CK_ULONG)sizeof(coeff) }
CK_ULONG len;
CK_ULONG slen;
CK_OBJECT_HANDLE hKey = CK_INVALID_HANDLE;
CK_OBJECT_CLASS kClass = CKO_PRIVATE_KEY;
CK_KEY_TYPE kType = CKK_RSA;
CK_ATTRIBUTE kTemplate[] = {
{ CKA_CLASS, &kClass, (CK_ULONG)sizeof(kClass) },
{ CKA_KEY_TYPE, &kType, (CK_ULONG)sizeof(kType) },
{ CKA_TOKEN, &falsevalue, (CK_ULONG)sizeof(falsevalue) },
{ CKA_PRIVATE, &truevalue, (CK_ULONG)sizeof(truevalue) },
{ CKA_SIGN, &truevalue, (CK_ULONG)sizeof(truevalue) },
{ CKA_MODULUS, modulus, (CK_ULONG)sizeof(modulus) },
{ CKA_PUBLIC_EXPONENT, pubexp, (CK_ULONG)sizeof(pubexp) },
{ CKA_PRIVATE_EXPONENT, privexp, (CK_ULONG)sizeof(privexp) },
{ CKA_PRIME_1, prime1, (CK_ULONG)sizeof(prime1) },
{ CKA_PRIME_2, prime2, (CK_ULONG)sizeof(prime2) },
{ CKA_EXPONENT_1, exp_1, (CK_ULONG)sizeof(exp_1) },
{ CKA_EXPONENT_2, exp_2, (CK_ULONG)sizeof(exp_2) },
{ CKA_COEFFICIENT, coeff, (CK_ULONG)sizeof(coeff) }
};
CK_MECHANISM mech = { CKM_SHA1_RSA_PKCS, NULL, 0 };
pk11_context_t pctx;
pk11_optype_t op_type = OP_RSA;
char * lib_name = NULL;
char * pin = NULL;
int error = 0;
int c, errflg = 0;
int ontoken = 0;
unsigned int count = 1000;
unsigned int i;
CK_MECHANISM mech = { CKM_SHA1_RSA_PKCS, NULL, 0 };
pk11_context_t pctx;
pk11_optype_t op_type = OP_RSA;
char *lib_name = NULL;
char *pin = NULL;
int error = 0;
int c, errflg = 0;
int ontoken = 0;
unsigned int count = 1000;
unsigned int i;
struct timespec starttime;
struct timespec endtime;
@ -243,7 +240,8 @@ main(int argc, char *argv[])
(const char *)pin, slot);
if ((result != ISC_R_SUCCESS) && (result != PK11_R_NORANDOMSERVICE) &&
(result != PK11_R_NODIGESTSERVICE) &&
(result != PK11_R_NOAESSERVICE)) {
(result != PK11_R_NOAESSERVICE))
{
fprintf(stderr, "Error initializing PKCS#11: %s\n",
isc_result_totext(result));
exit(1);

66
bin/tests/pkcs11/benchmarks/verify.c
View file

@ -61,14 +61,12 @@
#define CLOCK_REALTIME 0
#endif /* ifndef CLOCK_REALTIME */
static int
clock_gettime(int32_t id, struct timespec *tp);
static int clock_gettime(int32_t id, struct timespec *tp);
static int
clock_gettime(int32_t id, struct timespec *tp)
{
clock_gettime(int32_t id, struct timespec *tp) {
struct timeval tv;
int result;
int result;
UNUSED(id);
@ -103,36 +101,35 @@ static CK_BBOOL truevalue = TRUE;
static CK_BBOOL falsevalue = FALSE;
int
main(int argc, char *argv[])
{
isc_result_t result;
CK_RV rv;
CK_SLOT_ID slot = 0;
main(int argc, char *argv[]) {
isc_result_t result;
CK_RV rv;
CK_SLOT_ID slot = 0;
CK_SESSION_HANDLE hSession = CK_INVALID_HANDLE;
CK_ULONG len;
CK_ULONG slen;
CK_OBJECT_HANDLE hKey = CK_INVALID_HANDLE;
CK_OBJECT_CLASS kClass = CKO_PUBLIC_KEY;
CK_KEY_TYPE kType = CKK_RSA;
CK_ATTRIBUTE kTemplate[] = {
{ CKA_CLASS, &kClass, (CK_ULONG)sizeof(kClass) },
{ CKA_KEY_TYPE, &kType, (CK_ULONG)sizeof(kType) },
{ CKA_TOKEN, &falsevalue, (CK_ULONG)sizeof(falsevalue) },
{ CKA_PRIVATE, &falsevalue, (CK_ULONG)sizeof(falsevalue) },
{ CKA_VERIFY, &truevalue, (CK_ULONG)sizeof(truevalue) },
{ CKA_MODULUS, modulus, (CK_ULONG)sizeof(modulus) },
{ CKA_PUBLIC_EXPONENT, exponent, (CK_ULONG)sizeof(exponent) }
CK_ULONG len;
CK_ULONG slen;
CK_OBJECT_HANDLE hKey = CK_INVALID_HANDLE;
CK_OBJECT_CLASS kClass = CKO_PUBLIC_KEY;
CK_KEY_TYPE kType = CKK_RSA;
CK_ATTRIBUTE kTemplate[] = {
{ CKA_CLASS, &kClass, (CK_ULONG)sizeof(kClass) },
{ CKA_KEY_TYPE, &kType, (CK_ULONG)sizeof(kType) },
{ CKA_TOKEN, &falsevalue, (CK_ULONG)sizeof(falsevalue) },
{ CKA_PRIVATE, &falsevalue, (CK_ULONG)sizeof(falsevalue) },
{ CKA_VERIFY, &truevalue, (CK_ULONG)sizeof(truevalue) },
{ CKA_MODULUS, modulus, (CK_ULONG)sizeof(modulus) },
{ CKA_PUBLIC_EXPONENT, exponent, (CK_ULONG)sizeof(exponent) }
};
CK_MECHANISM mech = { CKM_SHA1_RSA_PKCS, NULL, 0 };
pk11_context_t pctx;
pk11_optype_t op_type = OP_RSA;
char * lib_name = NULL;
char * pin = NULL;
int error = 0;
int c, errflg = 0;
int ontoken = 0;
unsigned int count = 1000;
unsigned int i;
CK_MECHANISM mech = { CKM_SHA1_RSA_PKCS, NULL, 0 };
pk11_context_t pctx;
pk11_optype_t op_type = OP_RSA;
char *lib_name = NULL;
char *pin = NULL;
int error = 0;
int c, errflg = 0;
int ontoken = 0;
unsigned int count = 1000;
unsigned int i;
struct timespec starttime;
struct timespec endtime;
@ -189,7 +186,8 @@ main(int argc, char *argv[])
(const char *)pin, slot);
if ((result != ISC_R_SUCCESS) && (result != PK11_R_NORANDOMSERVICE) &&
(result != PK11_R_NODIGESTSERVICE) &&
(result != PK11_R_NOAESSERVICE)) {
(result != PK11_R_NOAESSERVICE))
{
fprintf(stderr, "Error initializing PKCS#11: %s\n",
isc_result_totext(result));
exit(1);

156
bin/tests/system/dlzexternal/driver.c
View file

@ -51,16 +51,15 @@
/* For this simple example, use fixed sized strings */
struct record {
char name[100];
char type[10];
char data[200];
char name[100];
char type[10];
char data[200];
dns_ttl_t ttl;
};
#define MAX_RECORDS 100
typedef void
log_t(int level, const char *fmt, ...);
typedef void log_t(int level, const char *fmt, ...);
struct dlz_example_data {
char *zone_name;
@ -73,17 +72,16 @@ struct dlz_example_data {
bool transaction_started;
/* Helper functions from the dlz_dlopen driver */
log_t * log;
dns_sdlz_putrr_t * putrr;
dns_sdlz_putnamedrr_t * putnamedrr;
log_t *log;
dns_sdlz_putrr_t *putrr;
dns_sdlz_putnamedrr_t *putnamedrr;
dns_dlz_writeablezone_t *writeable_zone;
};
static bool
single_valued(const char *type)
{
single_valued(const char *type) {
const char *single[] = { "soa", "cname", NULL };
int i;
int i;
for (i = 0; single[i]; i++) {
if (strcasecmp(single[i], type) == 0) {
@ -98,11 +96,10 @@ single_valued(const char *type)
*/
static isc_result_t
add_name(struct dlz_example_data *state, struct record *list, const char *name,
const char *type, dns_ttl_t ttl, const char *data)
{
int i;
const char *type, dns_ttl_t ttl, const char *data) {
int i;
bool single = single_valued(type);
int first_empty = -1;
int first_empty = -1;
for (i = 0; i < MAX_RECORDS; i++) {
INSIST(list[i].name != NULL);
@ -130,7 +127,8 @@ add_name(struct dlz_example_data *state, struct record *list, const char *name,
if (strlen(name) >= sizeof(list[i].name) ||
strlen(type) >= sizeof(list[i].type) ||
strlen(data) >= sizeof(list[i].data)) {
strlen(data) >= sizeof(list[i].data))
{
return (ISC_R_NOSPACE);
}
@ -153,8 +151,7 @@ add_name(struct dlz_example_data *state, struct record *list, const char *name,
*/
static isc_result_t
del_name(struct dlz_example_data *state, struct record *list, const char *name,
const char *type, dns_ttl_t ttl, const char *data)
{
const char *type, dns_ttl_t ttl, const char *data) {
int i;
UNUSED(state);
@ -162,7 +159,8 @@ del_name(struct dlz_example_data *state, struct record *list, const char *name,
for (i = 0; i < MAX_RECORDS; i++) {
if (strcasecmp(name, list[i].name) == 0 &&
strcasecmp(type, list[i].type) == 0 &&
strcasecmp(data, list[i].data) == 0 && ttl == list[i].ttl) {
strcasecmp(data, list[i].data) == 0 && ttl == list[i].ttl)
{
break;
}
}
@ -174,11 +172,10 @@ del_name(struct dlz_example_data *state, struct record *list, const char *name,
}
static isc_result_t
fmt_address(isc_sockaddr_t *addr, char *buffer, size_t size)
{
char addr_buf[INET6_ADDRSTRLEN];
fmt_address(isc_sockaddr_t *addr, char *buffer, size_t size) {
char addr_buf[INET6_ADDRSTRLEN];
const char *ret;
uint16_t port = 0;
uint16_t port = 0;
switch (addr->type.sa.sa_family) {
case AF_INET:
@ -207,8 +204,7 @@ fmt_address(isc_sockaddr_t *addr, char *buffer, size_t size)
* Return the version of the API
*/
int
dlz_version(unsigned int *flags)
{
dlz_version(unsigned int *flags) {
UNUSED(flags);
return (DLZ_DLOPEN_VERSION);
}
@ -218,8 +214,7 @@ dlz_version(unsigned int *flags)
*/
static void
b9_add_helper(struct dlz_example_data *state, const char *helper_name,
void *ptr)
{
void *ptr) {
if (strcmp(helper_name, "log") == 0) {
state->log = (log_t *)ptr;
}
@ -239,15 +234,14 @@ b9_add_helper(struct dlz_example_data *state, const char *helper_name,
*/
isc_result_t
dlz_create(const char *dlzname, unsigned int argc, char *argv[], void **dbdata,
...)
{
...) {
struct dlz_example_data *state;
const char * helper_name;
va_list ap;
char soa_data[1024];
const char * extra;
isc_result_t result;
int n;
const char *helper_name;
va_list ap;
char soa_data[1024];
const char *extra;
isc_result_t result;
int n;
UNUSED(dlzname);
@ -318,8 +312,7 @@ failure:
* Shut down the backend
*/
void
dlz_destroy(void *dbdata)
{
dlz_destroy(void *dbdata) {
struct dlz_example_data *state = (struct dlz_example_data *)dbdata;
loginfo("dlz_example: shutting down zone %s", state->zone_name);
@ -332,17 +325,17 @@ dlz_destroy(void *dbdata)
*/
isc_result_t
dlz_findzonedb(void *dbdata, const char *name, dns_clientinfomethods_t *methods,
dns_clientinfo_t *clientinfo)
{
dns_clientinfo_t *clientinfo) {
struct dlz_example_data *state = (struct dlz_example_data *)dbdata;
isc_sockaddr_t * src;
char addrbuf[100];
char absolute[1024];
isc_sockaddr_t *src;
char addrbuf[100];
char absolute[1024];
strcpy(addrbuf, "unknown");
if (methods != NULL && methods->sourceip != NULL &&
methods->version - methods->age <= DNS_CLIENTINFOMETHODS_VERSION &&
DNS_CLIENTINFOMETHODS_VERSION <= methods->version) {
DNS_CLIENTINFOMETHODS_VERSION <= methods->version)
{
methods->sourceip(clientinfo, &src);
fmt_address(src, addrbuf, sizeof(addrbuf));
}
@ -367,7 +360,8 @@ dlz_findzonedb(void *dbdata, const char *name, dns_clientinfomethods_t *methods,
* from 10.53.0.1.
*/
if (strcasecmp(name, "test.example.net") == 0 &&
strncmp(addrbuf, "10.53.0.1", 9) == 0) {
strncmp(addrbuf, "10.53.0.1", 9) == 0)
{
return (ISC_R_NOMORE);
}
@ -408,18 +402,17 @@ dlz_findzonedb(void *dbdata, const char *name, dns_clientinfomethods_t *methods,
isc_result_t
dlz_lookup(const char *zone, const char *name, void *dbdata,
dns_sdlzlookup_t *lookup, dns_clientinfomethods_t *methods,
dns_clientinfo_t *clientinfo)
{
isc_result_t result;
dns_clientinfo_t *clientinfo) {
isc_result_t result;
struct dlz_example_data *state = (struct dlz_example_data *)dbdata;
bool found = false;
void * dbversion = NULL;
isc_sockaddr_t * src;
char full_name[256];
char buf[512];
static char last[256];
static int count = 0;
int i, size;
bool found = false;
void *dbversion = NULL;
isc_sockaddr_t *src;
char full_name[256];
char buf[512];
static char last[256];
static int count = 0;
int i, size;
UNUSED(zone);
@ -438,7 +431,8 @@ dlz_lookup(const char *zone, const char *name, void *dbdata,
}
if (size < 0 || (size_t)size >= sizeof(full_name) ||
(size_t)size >= sizeof(last)) {
(size_t)size >= sizeof(last))
{
return (ISC_R_NOSPACE);
}
@ -468,8 +462,8 @@ dlz_lookup(const char *zone, const char *name, void *dbdata,
* If the DLZ only operates on 'live' data, then version
* wouldn't necessarily be needed.
*/
if (clientinfo != NULL &&
clientinfo->version >= DNS_CLIENTINFO_VERSION) {
if (clientinfo != NULL && clientinfo->version >= DNS_CLIENTINFO_VERSION)
{
dbversion = clientinfo->dbversion;
if (dbversion != NULL && *(bool *)dbversion) {
loginfo("dlz_example: lookup against live transaction");
@ -481,7 +475,8 @@ dlz_lookup(const char *zone, const char *name, void *dbdata,
if (methods != NULL && methods->sourceip != NULL &&
(methods->version - methods->age <=
DNS_CLIENTINFOMETHODS_VERSION) &&
DNS_CLIENTINFOMETHODS_VERSION <= methods->version) {
DNS_CLIENTINFOMETHODS_VERSION <= methods->version)
{
methods->sourceip(clientinfo, &src);
fmt_address(src, buf, sizeof(buf));
}
@ -550,10 +545,9 @@ dlz_lookup(const char *zone, const char *name, void *dbdata,
* See if a zone transfer is allowed
*/
isc_result_t
dlz_allowzonexfr(void *dbdata, const char *name, const char *client)
{
dlz_allowzonexfr(void *dbdata, const char *name, const char *client) {
struct dlz_example_data *state = (struct dlz_example_data *)dbdata;
isc_result_t result;
isc_result_t result;
loginfo("dlz_example: dlz_allowzonexfr called for %s", name);
@ -591,10 +585,9 @@ dlz_allowzonexfr(void *dbdata, const char *name, const char *client)
* Perform a zone transfer
*/
isc_result_t
dlz_allnodes(const char *zone, void *dbdata, dns_sdlzallnodes_t *allnodes)
{
dlz_allnodes(const char *zone, void *dbdata, dns_sdlzallnodes_t *allnodes) {
struct dlz_example_data *state = (struct dlz_example_data *)dbdata;
int i;
int i;
UNUSED(zone);
@ -623,8 +616,7 @@ dlz_allnodes(const char *zone, void *dbdata, dns_sdlzallnodes_t *allnodes)
* Start a transaction
*/
isc_result_t
dlz_newversion(const char *zone, void *dbdata, void **versionp)
{
dlz_newversion(const char *zone, void *dbdata, void **versionp) {
struct dlz_example_data *state = (struct dlz_example_data *)dbdata;
if (state->transaction_started) {
@ -643,8 +635,7 @@ dlz_newversion(const char *zone, void *dbdata, void **versionp)
* End a transaction
*/
void
dlz_closeversion(const char *zone, bool commit, void *dbdata, void **versionp)
{
dlz_closeversion(const char *zone, bool commit, void *dbdata, void **versionp) {
struct dlz_example_data *state = (struct dlz_example_data *)dbdata;
if (!state->transaction_started) {
@ -690,10 +681,9 @@ dlz_closeversion(const char *zone, bool commit, void *dbdata, void **versionp)
* Configure a writeable zone
*/
isc_result_t
dlz_configure(dns_view_t *view, dns_dlzdb_t *dlzdb, void *dbdata)
{
dlz_configure(dns_view_t *view, dns_dlzdb_t *dlzdb, void *dbdata) {
struct dlz_example_data *state = (struct dlz_example_data *)dbdata;
isc_result_t result;
isc_result_t result;
loginfo("dlz_example: starting configure");
@ -719,8 +709,7 @@ dlz_configure(dns_view_t *view, dns_dlzdb_t *dlzdb, void *dbdata)
bool
dlz_ssumatch(const char *signer, const char *name, const char *tcpaddr,
const char *type, const char *key, uint32_t keydatalen,
unsigned char *keydata, void *dbdata)
{
unsigned char *keydata, void *dbdata) {
struct dlz_example_data *state = (struct dlz_example_data *)dbdata;
UNUSED(tcpaddr);
@ -740,12 +729,11 @@ dlz_ssumatch(const char *signer, const char *name, const char *tcpaddr,
static isc_result_t
modrdataset(struct dlz_example_data *state, const char *name,
const char *rdatastr, struct record *list)
{
char * full_name, *dclass, *type, *data, *ttlstr, *buf;
char absolute[1024];
const char *rdatastr, struct record *list) {
char *full_name, *dclass, *type, *data, *ttlstr, *buf;
char absolute[1024];
isc_result_t result;
char * saveptr = NULL;
char *saveptr = NULL;
buf = strdup(rdatastr);
if (buf == NULL) {
@ -802,8 +790,7 @@ error:
isc_result_t
dlz_addrdataset(const char *name, const char *rdatastr, void *dbdata,
void *version)
{
void *version) {
struct dlz_example_data *state = (struct dlz_example_data *)dbdata;
if (version != (void *)&state->transaction_started) {
@ -817,8 +804,7 @@ dlz_addrdataset(const char *name, const char *rdatastr, void *dbdata,
isc_result_t
dlz_subrdataset(const char *name, const char *rdatastr, void *dbdata,
void *version)
{
void *version) {
struct dlz_example_data *state = (struct dlz_example_data *)dbdata;
if (version != (void *)&state->transaction_started) {
@ -831,8 +817,8 @@ dlz_subrdataset(const char *name, const char *rdatastr, void *dbdata,
}
isc_result_t
dlz_delrdataset(const char *name, const char *type, void *dbdata, void *version)
{
dlz_delrdataset(const char *name, const char *type, void *dbdata,
void *version) {
struct dlz_example_data *state = (struct dlz_example_data *)dbdata;
if (version != (void *)&state->transaction_started) {

199
bin/tests/system/dyndb/driver/db.c
View file

@ -37,8 +37,8 @@
((sampledb) != NULL && (sampledb)->common.impmagic == SAMPLEDB_MAGIC)
struct sampledb {
dns_db_t common;
isc_refcount_t refs;
dns_db_t common;
isc_refcount_t refs;
sample_instance_t *inst;
/*
@ -61,15 +61,13 @@ typedef struct sampledb sampledb_t;
* This should work as long as we use only RBTDB and nothing else.
*/
static isc_result_t
sample_name_fromnode(dns_dbnode_t *node, dns_name_t *name)
{
sample_name_fromnode(dns_dbnode_t *node, dns_name_t *name) {
dns_rbtnode_t *rbtnode = (dns_rbtnode_t *)node;
return (dns_rbt_fullnamefromnode(rbtnode, name));
}
static void
attach(dns_db_t *source, dns_db_t **targetp)
{
attach(dns_db_t *source, dns_db_t **targetp) {
sampledb_t *sampledb = (sampledb_t *)source;
REQUIRE(VALID_SAMPLEDB(sampledb));
@ -79,8 +77,7 @@ attach(dns_db_t *source, dns_db_t **targetp)
}
static void
free_sampledb(sampledb_t *sampledb)
{
free_sampledb(sampledb_t *sampledb) {
REQUIRE(VALID_SAMPLEDB(sampledb));
dns_db_detach(&sampledb->rbtdb);
@ -90,8 +87,7 @@ free_sampledb(sampledb_t *sampledb)
}
static void
detach(dns_db_t **dbp)
{
detach(dns_db_t **dbp) {
REQUIRE(dbp != NULL && VALID_SAMPLEDB((sampledb_t *)(*dbp)));
sampledb_t *sampledb = (sampledb_t *)(*dbp);
*dbp = NULL;
@ -107,8 +103,7 @@ detach(dns_db_t **dbp)
* loaded in the usual sense.
*/
static isc_result_t
beginload(dns_db_t *db, dns_rdatacallbacks_t *callbacks)
{
beginload(dns_db_t *db, dns_rdatacallbacks_t *callbacks) {
UNUSED(db);
UNUSED(callbacks);
@ -124,8 +119,7 @@ beginload(dns_db_t *db, dns_rdatacallbacks_t *callbacks)
* loaded in the usual sense.
*/
static isc_result_t
endload(dns_db_t *db, dns_rdatacallbacks_t *callbacks)
{
endload(dns_db_t *db, dns_rdatacallbacks_t *callbacks) {
UNUSED(db);
UNUSED(callbacks);
@ -136,8 +130,7 @@ endload(dns_db_t *db, dns_rdatacallbacks_t *callbacks)
}
static isc_result_t
serialize(dns_db_t *db, dns_dbversion_t *version, FILE *file)
{
serialize(dns_db_t *db, dns_dbversion_t *version, FILE *file) {
sampledb_t *sampledb = (sampledb_t *)db;
REQUIRE(VALID_SAMPLEDB(sampledb));
@ -147,8 +140,7 @@ serialize(dns_db_t *db, dns_dbversion_t *version, FILE *file)
static isc_result_t
dump(dns_db_t *db, dns_dbversion_t *version, const char *filename,
dns_masterformat_t masterformat)
{
dns_masterformat_t masterformat) {
UNUSED(db);
UNUSED(version);
UNUSED(filename);
@ -161,8 +153,7 @@ dump(dns_db_t *db, dns_dbversion_t *version, const char *filename,
}
static void
currentversion(dns_db_t *db, dns_dbversion_t **versionp)
{
currentversion(dns_db_t *db, dns_dbversion_t **versionp) {
sampledb_t *sampledb = (sampledb_t *)db;
REQUIRE(VALID_SAMPLEDB(sampledb));
@ -171,8 +162,7 @@ currentversion(dns_db_t *db, dns_dbversion_t **versionp)
}
static isc_result_t
newversion(dns_db_t *db, dns_dbversion_t **versionp)
{
newversion(dns_db_t *db, dns_dbversion_t **versionp) {
sampledb_t *sampledb = (sampledb_t *)db;
REQUIRE(VALID_SAMPLEDB(sampledb));
@ -181,8 +171,8 @@ newversion(dns_db_t *db, dns_dbversion_t **versionp)
}
static void
attachversion(dns_db_t *db, dns_dbversion_t *source, dns_dbversion_t **targetp)
{
attachversion(dns_db_t *db, dns_dbversion_t *source,
dns_dbversion_t **targetp) {
sampledb_t *sampledb = (sampledb_t *)db;
REQUIRE(VALID_SAMPLEDB(sampledb));
@ -191,8 +181,7 @@ attachversion(dns_db_t *db, dns_dbversion_t *source, dns_dbversion_t **targetp)
}
static void
closeversion(dns_db_t *db, dns_dbversion_t **versionp, bool commit)
{
closeversion(dns_db_t *db, dns_dbversion_t **versionp, bool commit) {
sampledb_t *sampledb = (sampledb_t *)db;
REQUIRE(VALID_SAMPLEDB(sampledb));
@ -202,8 +191,7 @@ closeversion(dns_db_t *db, dns_dbversion_t **versionp, bool commit)
static isc_result_t
findnode(dns_db_t *db, const dns_name_t *name, bool create,
dns_dbnode_t **nodep)
{
dns_dbnode_t **nodep) {
sampledb_t *sampledb = (sampledb_t *)db;
REQUIRE(VALID_SAMPLEDB(sampledb));
@ -215,8 +203,7 @@ static isc_result_t
find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version,
dns_rdatatype_t type, unsigned int options, isc_stdtime_t now,
dns_dbnode_t **nodep, dns_name_t *foundname, dns_rdataset_t *rdataset,
dns_rdataset_t *sigrdataset)
{
dns_rdataset_t *sigrdataset) {
sampledb_t *sampledb = (sampledb_t *)db;
REQUIRE(VALID_SAMPLEDB(sampledb));
@ -229,8 +216,7 @@ static isc_result_t
findzonecut(dns_db_t *db, const dns_name_t *name, unsigned int options,
isc_stdtime_t now, dns_dbnode_t **nodep, dns_name_t *foundname,
dns_name_t *dcname, dns_rdataset_t *rdataset,
dns_rdataset_t *sigrdataset)
{
dns_rdataset_t *sigrdataset) {
sampledb_t *sampledb = (sampledb_t *)db;
REQUIRE(VALID_SAMPLEDB(sampledb));
@ -240,8 +226,7 @@ findzonecut(dns_db_t *db, const dns_name_t *name, unsigned int options,
}
static void
attachnode(dns_db_t *db, dns_dbnode_t *source, dns_dbnode_t **targetp)
{
attachnode(dns_db_t *db, dns_dbnode_t *source, dns_dbnode_t **targetp) {
sampledb_t *sampledb = (sampledb_t *)db;
REQUIRE(VALID_SAMPLEDB(sampledb));
@ -250,8 +235,7 @@ attachnode(dns_db_t *db, dns_dbnode_t *source, dns_dbnode_t **targetp)
}
static void
detachnode(dns_db_t *db, dns_dbnode_t **targetp)
{
detachnode(dns_db_t *db, dns_dbnode_t **targetp) {
sampledb_t *sampledb = (sampledb_t *)db;
REQUIRE(VALID_SAMPLEDB(sampledb));
@ -260,8 +244,7 @@ detachnode(dns_db_t *db, dns_dbnode_t **targetp)
}
static isc_result_t
expirenode(dns_db_t *db, dns_dbnode_t *node, isc_stdtime_t now)
{
expirenode(dns_db_t *db, dns_dbnode_t *node, isc_stdtime_t now) {
sampledb_t *sampledb = (sampledb_t *)db;
REQUIRE(VALID_SAMPLEDB(sampledb));
@ -270,8 +253,7 @@ expirenode(dns_db_t *db, dns_dbnode_t *node, isc_stdtime_t now)
}
static void
printnode(dns_db_t *db, dns_dbnode_t *node, FILE *out)
{
printnode(dns_db_t *db, dns_dbnode_t *node, FILE *out) {
sampledb_t *sampledb = (sampledb_t *)db;
REQUIRE(VALID_SAMPLEDB(sampledb));
@ -280,8 +262,8 @@ printnode(dns_db_t *db, dns_dbnode_t *node, FILE *out)
}
static isc_result_t
createiterator(dns_db_t *db, unsigned int options, dns_dbiterator_t **iteratorp)
{
createiterator(dns_db_t *db, unsigned int options,
dns_dbiterator_t **iteratorp) {
sampledb_t *sampledb = (sampledb_t *)db;
REQUIRE(VALID_SAMPLEDB(sampledb));
@ -292,8 +274,7 @@ createiterator(dns_db_t *db, unsigned int options, dns_dbiterator_t **iteratorp)
static isc_result_t
findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
dns_rdatatype_t type, dns_rdatatype_t covers, isc_stdtime_t now,
dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset)
{
dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset) {
sampledb_t *sampledb = (sampledb_t *)db;
REQUIRE(VALID_SAMPLEDB(sampledb));
@ -304,8 +285,7 @@ findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
static isc_result_t
allrdatasets(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
isc_stdtime_t now, dns_rdatasetiter_t **iteratorp)
{
isc_stdtime_t now, dns_rdatasetiter_t **iteratorp) {
sampledb_t *sampledb = (sampledb_t *)db;
REQUIRE(VALID_SAMPLEDB(sampledb));
@ -317,10 +297,9 @@ allrdatasets(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
static isc_result_t
addrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
isc_stdtime_t now, dns_rdataset_t *rdataset, unsigned int options,
dns_rdataset_t *addedrdataset)
{
sampledb_t * sampledb = (sampledb_t *)db;
isc_result_t result;
dns_rdataset_t *addedrdataset) {
sampledb_t *sampledb = (sampledb_t *)db;
isc_result_t result;
dns_fixedname_t name;
REQUIRE(VALID_SAMPLEDB(sampledb));
@ -342,10 +321,9 @@ cleanup:
static isc_result_t
subtractrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
dns_rdataset_t *rdataset, unsigned int options,
dns_rdataset_t *newrdataset)
{
sampledb_t * sampledb = (sampledb_t *)db;
isc_result_t result;
dns_rdataset_t *newrdataset) {
sampledb_t *sampledb = (sampledb_t *)db;
isc_result_t result;
dns_fixedname_t name;
REQUIRE(VALID_SAMPLEDB(sampledb));
@ -374,8 +352,7 @@ cleanup:
*/
static isc_result_t
deleterdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
dns_rdatatype_t type, dns_rdatatype_t covers)
{
dns_rdatatype_t type, dns_rdatatype_t covers) {
sampledb_t *sampledb = (sampledb_t *)db;
REQUIRE(VALID_SAMPLEDB(sampledb));
@ -385,8 +362,7 @@ deleterdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
}
static bool
issecure(dns_db_t *db)
{
issecure(dns_db_t *db) {
sampledb_t *sampledb = (sampledb_t *)db;
REQUIRE(VALID_SAMPLEDB(sampledb));
@ -395,8 +371,7 @@ issecure(dns_db_t *db)
}
static unsigned int
nodecount(dns_db_t *db)
{
nodecount(dns_db_t *db) {
sampledb_t *sampledb = (sampledb_t *)db;
REQUIRE(VALID_SAMPLEDB(sampledb));
@ -409,16 +384,14 @@ nodecount(dns_db_t *db)
* Always return true.
*/
static bool
ispersistent(dns_db_t *db)
{
ispersistent(dns_db_t *db) {
UNUSED(db);
return (true);
}
static void
overmem(dns_db_t *db, bool over)
{
overmem(dns_db_t *db, bool over) {
sampledb_t *sampledb = (sampledb_t *)db;
REQUIRE(VALID_SAMPLEDB(sampledb));
@ -427,8 +400,7 @@ overmem(dns_db_t *db, bool over)
}
static void
settask(dns_db_t *db, isc_task_t *task)
{
settask(dns_db_t *db, isc_task_t *task) {
sampledb_t *sampledb = (sampledb_t *)db;
REQUIRE(VALID_SAMPLEDB(sampledb));
@ -437,8 +409,7 @@ settask(dns_db_t *db, isc_task_t *task)
}
static isc_result_t
getoriginnode(dns_db_t *db, dns_dbnode_t **nodep)
{
getoriginnode(dns_db_t *db, dns_dbnode_t **nodep) {
sampledb_t *sampledb = (sampledb_t *)db;
REQUIRE(VALID_SAMPLEDB(sampledb));
@ -447,8 +418,7 @@ getoriginnode(dns_db_t *db, dns_dbnode_t **nodep)
}
static void
transfernode(dns_db_t *db, dns_dbnode_t **sourcep, dns_dbnode_t **targetp)
{
transfernode(dns_db_t *db, dns_dbnode_t **sourcep, dns_dbnode_t **targetp) {
sampledb_t *sampledb = (sampledb_t *)db;
REQUIRE(VALID_SAMPLEDB(sampledb));
@ -459,8 +429,7 @@ transfernode(dns_db_t *db, dns_dbnode_t **sourcep, dns_dbnode_t **targetp)
static isc_result_t
getnsec3parameters(dns_db_t *db, dns_dbversion_t *version, dns_hash_t *hash,
uint8_t *flags, uint16_t *iterations, unsigned char *salt,
size_t *salt_length)
{
size_t *salt_length) {
sampledb_t *sampledb = (sampledb_t *)db;
REQUIRE(VALID_SAMPLEDB(sampledb));
@ -471,8 +440,7 @@ getnsec3parameters(dns_db_t *db, dns_dbversion_t *version, dns_hash_t *hash,
static isc_result_t
findnsec3node(dns_db_t *db, const dns_name_t *name, bool create,
dns_dbnode_t **nodep)
{
dns_dbnode_t **nodep) {
sampledb_t *sampledb = (sampledb_t *)db;
REQUIRE(VALID_SAMPLEDB(sampledb));
@ -481,8 +449,7 @@ findnsec3node(dns_db_t *db, const dns_name_t *name, bool create,
}
static isc_result_t
setsigningtime(dns_db_t *db, dns_rdataset_t *rdataset, isc_stdtime_t resign)
{
setsigningtime(dns_db_t *db, dns_rdataset_t *rdataset, isc_stdtime_t resign) {
sampledb_t *sampledb = (sampledb_t *)db;
REQUIRE(VALID_SAMPLEDB(sampledb));
@ -491,8 +458,7 @@ setsigningtime(dns_db_t *db, dns_rdataset_t *rdataset, isc_stdtime_t resign)
}
static isc_result_t
getsigningtime(dns_db_t *db, dns_rdataset_t *rdataset, dns_name_t *name)
{
getsigningtime(dns_db_t *db, dns_rdataset_t *rdataset, dns_name_t *name) {
sampledb_t *sampledb = (sampledb_t *)db;
REQUIRE(VALID_SAMPLEDB(sampledb));
@ -501,8 +467,7 @@ getsigningtime(dns_db_t *db, dns_rdataset_t *rdataset, dns_name_t *name)
}
static void
resigned(dns_db_t *db, dns_rdataset_t *rdataset, dns_dbversion_t *version)
{
resigned(dns_db_t *db, dns_rdataset_t *rdataset, dns_dbversion_t *version) {
sampledb_t *sampledb = (sampledb_t *)db;
REQUIRE(VALID_SAMPLEDB(sampledb));
@ -511,8 +476,7 @@ resigned(dns_db_t *db, dns_rdataset_t *rdataset, dns_dbversion_t *version)
}
static bool
isdnssec(dns_db_t *db)
{
isdnssec(dns_db_t *db) {
sampledb_t *sampledb = (sampledb_t *)db;
REQUIRE(VALID_SAMPLEDB(sampledb));
@ -521,8 +485,7 @@ isdnssec(dns_db_t *db)
}
static dns_stats_t *
getrrsetstats(dns_db_t *db)
{
getrrsetstats(dns_db_t *db) {
sampledb_t *sampledb = (sampledb_t *)db;
REQUIRE(VALID_SAMPLEDB(sampledb));
@ -533,8 +496,7 @@ getrrsetstats(dns_db_t *db)
static isc_result_t
findnodeext(dns_db_t *db, const dns_name_t *name, bool create,
dns_clientinfomethods_t *methods, dns_clientinfo_t *clientinfo,
dns_dbnode_t **nodep)
{
dns_dbnode_t **nodep) {
sampledb_t *sampledb = (sampledb_t *)db;
REQUIRE(VALID_SAMPLEDB(sampledb));
@ -548,8 +510,7 @@ findext(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version,
dns_rdatatype_t type, unsigned int options, isc_stdtime_t now,
dns_dbnode_t **nodep, dns_name_t *foundname,
dns_clientinfomethods_t *methods, dns_clientinfo_t *clientinfo,
dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset)
{
dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset) {
sampledb_t *sampledb = (sampledb_t *)db;
REQUIRE(VALID_SAMPLEDB(sampledb));
@ -560,8 +521,7 @@ findext(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version,
}
static isc_result_t
setcachestats(dns_db_t *db, isc_stats_t *stats)
{
setcachestats(dns_db_t *db, isc_stats_t *stats) {
sampledb_t *sampledb = (sampledb_t *)db;
REQUIRE(VALID_SAMPLEDB(sampledb));
@ -570,8 +530,7 @@ setcachestats(dns_db_t *db, isc_stats_t *stats)
}
static size_t
hashsize(dns_db_t *db)
{
hashsize(dns_db_t *db) {
sampledb_t *sampledb = (sampledb_t *)db;
REQUIRE(VALID_SAMPLEDB(sampledb));
@ -647,14 +606,13 @@ static dns_dbmethods_t sampledb_methods = {
*/
static isc_result_t
add_soa(dns_db_t *db, dns_dbversion_t *version, const dns_name_t *name,
const dns_name_t *origin, const dns_name_t *contact)
{
dns_dbnode_t * node = NULL;
dns_rdata_t rdata = DNS_RDATA_INIT;
const dns_name_t *origin, const dns_name_t *contact) {
dns_dbnode_t *node = NULL;
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdatalist_t rdatalist;
dns_rdataset_t rdataset;
isc_result_t result;
unsigned char buf[DNS_SOA_BUFFERSIZE];
dns_rdataset_t rdataset;
isc_result_t result;
unsigned char buf[DNS_SOA_BUFFERSIZE];
dns_rdataset_init(&rdataset);
dns_rdatalist_init(&rdatalist);
@ -677,16 +635,15 @@ cleanup:
static isc_result_t
add_ns(dns_db_t *db, dns_dbversion_t *version, const dns_name_t *name,
const dns_name_t *nsname)
{
dns_dbnode_t * node = NULL;
dns_rdata_ns_t ns;
dns_rdata_t rdata = DNS_RDATA_INIT;
const dns_name_t *nsname) {
dns_dbnode_t *node = NULL;
dns_rdata_ns_t ns;
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdatalist_t rdatalist;
dns_rdataset_t rdataset;
isc_result_t result;
isc_buffer_t b;
unsigned char buf[DNS_NAME_MAXWIRE];
dns_rdataset_t rdataset;
isc_result_t result;
isc_buffer_t b;
unsigned char buf[DNS_NAME_MAXWIRE];
isc_buffer_init(&b, buf, sizeof(buf));
@ -716,16 +673,15 @@ cleanup:
static isc_result_t
add_a(dns_db_t *db, dns_dbversion_t *version, const dns_name_t *name,
struct in_addr addr)
{
dns_dbnode_t * node = NULL;
struct in_addr addr) {
dns_dbnode_t *node = NULL;
dns_rdata_in_a_t a;
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdatalist_t rdatalist;
dns_rdataset_t rdataset;
isc_result_t result;
isc_buffer_t b;
unsigned char buf[DNS_NAME_MAXWIRE];
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdatalist_t rdatalist;
dns_rdataset_t rdataset;
isc_result_t result;
isc_buffer_t b;
unsigned char buf[DNS_NAME_MAXWIRE];
isc_buffer_init(&b, buf, sizeof(buf));
@ -760,12 +716,11 @@ cleanup:
isc_result_t
create_db(isc_mem_t *mctx, const dns_name_t *origin, dns_dbtype_t type,
dns_rdataclass_t rdclass, unsigned int argc, char *argv[],
void *driverarg, dns_db_t **dbp)
{
sampledb_t * sampledb = NULL;
isc_result_t result;
void *driverarg, dns_db_t **dbp) {
sampledb_t *sampledb = NULL;
isc_result_t result;
dns_dbversion_t *version = NULL;
struct in_addr a_addr;
struct in_addr a_addr;
REQUIRE(type == dns_dbtype_zone);
REQUIRE(rdclass == dns_rdataclass_in);

25
bin/tests/system/dyndb/driver/driver.c
View file

@ -31,9 +31,9 @@
#include "log.h"
#include "util.h"
dns_dyndb_destroy_t dyndb_destroy;
dns_dyndb_destroy_t dyndb_destroy;
dns_dyndb_register_t dyndb_init;
dns_dyndb_version_t dyndb_version;
dns_dyndb_version_t dyndb_version;
/*
* Driver init is called for each dyndb section in named.conf
@ -58,12 +58,11 @@ dns_dyndb_version_t dyndb_version;
isc_result_t
dyndb_init(isc_mem_t *mctx, const char *name, const char *parameters,
const char *file, unsigned long line, const dns_dyndbctx_t *dctx,
void **instp)
{
isc_result_t result;
unsigned int argc;
char ** argv = NULL;
char * s = NULL;
void **instp) {
isc_result_t result;
unsigned int argc;
char **argv = NULL;
char *s = NULL;
sample_instance_t *sample_inst = NULL;
REQUIRE(name != NULL);
@ -95,8 +94,8 @@ dyndb_init(isc_mem_t *mctx, const char *name, const char *parameters,
name, file, line);
/* Finally, create the instance. */
result =
new_sample_instance(mctx, name, argc, argv, dctx, &sample_inst);
result = new_sample_instance(mctx, name, argc, argv, dctx,
&sample_inst);
if (result != ISC_R_SUCCESS) {
log_write(ISC_LOG_ERROR,
"dyndb_init: new_sample_instance -> %s\n",
@ -134,8 +133,7 @@ cleanup:
* @param[out] instp Pointer to instance-specific data (for one dyndb section).
*/
void
dyndb_destroy(void **instp)
{
dyndb_destroy(void **instp) {
destroy_sample_instance((sample_instance_t **)instp);
}
@ -144,8 +142,7 @@ dyndb_destroy(void **instp)
* is no API mismatch betwen the driver and the caller.
*/
int
dyndb_version(unsigned int *flags)
{
dyndb_version(unsigned int *flags) {
UNUSED(flags);
return (DNS_DYNDB_VERSION);

16
bin/tests/system/dyndb/driver/instance.c
View file

@ -36,10 +36,9 @@
*/
static isc_result_t
parse_params(isc_mem_t *mctx, int argc, char **argv, dns_name_t *z1,
dns_name_t *z2)
{
dns_name_t *z2) {
isc_result_t result;
int i;
int i;
REQUIRE(argv != NULL);
REQUIRE(z1 != NULL);
@ -84,9 +83,8 @@ cleanup:
isc_result_t
new_sample_instance(isc_mem_t *mctx, const char *db_name, int argc, char **argv,
const dns_dyndbctx_t *dctx,
sample_instance_t ** sample_instp)
{
isc_result_t result;
sample_instance_t **sample_instp) {
isc_result_t result;
sample_instance_t *inst = NULL;
REQUIRE(sample_instp != NULL && *sample_instp == NULL);
@ -137,8 +135,7 @@ cleanup:
* and add them to inst->view.
*/
isc_result_t
load_sample_instance_zones(sample_instance_t *inst)
{
load_sample_instance_zones(sample_instance_t *inst) {
isc_result_t result;
result = create_zone(inst, inst->zone1_name, &inst->zone1);
@ -176,8 +173,7 @@ cleanup:
}
void
destroy_sample_instance(sample_instance_t **instp)
{
destroy_sample_instance(sample_instance_t **instp) {
sample_instance_t *inst;
REQUIRE(instp != NULL);

6
bin/tests/system/dyndb/driver/lock.c
View file

@ -29,8 +29,7 @@
* @param[in,out] statep Lock state: ISC_R_SUCCESS or ISC_R_LOCKBUSY
*/
void
run_exclusive_enter(sample_instance_t *inst, isc_result_t *statep)
{
run_exclusive_enter(sample_instance_t *inst, isc_result_t *statep) {
REQUIRE(statep != NULL);
REQUIRE(*statep == ISC_R_IGNORE);
@ -45,8 +44,7 @@ run_exclusive_enter(sample_instance_t *inst, isc_result_t *statep)
* @param[in] state Lock state as returned by run_exclusive_enter().
*/
void
run_exclusive_exit(sample_instance_t *inst, isc_result_t state)
{
run_exclusive_exit(sample_instance_t *inst, isc_result_t state) {
if (state == ISC_R_SUCCESS) {
isc_task_endexclusive(inst->task);
} else {

3
bin/tests/system/dyndb/driver/log.c
View file

@ -9,8 +9,7 @@
#include <dns/log.h>
void
log_write(int level, const char *format, ...)
{
log_write(int level, const char *format, ...) {
va_list args;
va_start(args, format);

53
bin/tests/system/dyndb/driver/syncptr.c
View file

@ -30,12 +30,12 @@
typedef struct syncptrevent syncptrevent_t;
struct syncptrevent {
ISC_EVENT_COMMON(syncptrevent_t);
isc_mem_t * mctx;
dns_zone_t * zone;
dns_diff_t diff;
isc_mem_t *mctx;
dns_zone_t *zone;
dns_diff_t diff;
dns_fixedname_t ptr_target_name; /* referenced by owner name in
* tuple */
isc_buffer_t b; /* referenced by target name in tuple */
isc_buffer_t b; /* referenced by target name in tuple */
unsigned char buf[DNS_NAME_MAXWIRE];
};
@ -47,12 +47,11 @@ struct syncptrevent {
*
*/
static void
syncptr_write(isc_task_t *task, isc_event_t *event)
{
syncptrevent_t * pevent = (syncptrevent_t *)event;
syncptr_write(isc_task_t *task, isc_event_t *event) {
syncptrevent_t *pevent = (syncptrevent_t *)event;
dns_dbversion_t *version = NULL;
dns_db_t * db = NULL;
isc_result_t result;
dns_db_t *db = NULL;
isc_result_t result;
REQUIRE(event->ev_type == SYNCPTR_WRITE_EVENT);
@ -110,11 +109,10 @@ cleanup:
*/
static isc_result_t
syncptr_find_zone(sample_instance_t *inst, dns_rdata_t *rdata, dns_name_t *name,
dns_zone_t **zone)
{
isc_result_t result;
isc_netaddr_t isc_ip; /* internal net address representation */
dns_rdata_in_a_t ipv4;
dns_zone_t **zone) {
isc_result_t result;
isc_netaddr_t isc_ip; /* internal net address representation */
dns_rdata_in_a_t ipv4;
dns_rdata_in_aaaa_t ipv6;
REQUIRE(inst != NULL);
@ -197,17 +195,16 @@ cleanup:
*/
static isc_result_t
syncptr(sample_instance_t *inst, dns_name_t *name, dns_rdata_t *addr_rdata,
dns_ttl_t ttl, dns_diffop_t op)
{
isc_result_t result;
isc_mem_t * mctx = inst->mctx;
dns_fixedname_t ptr_name;
dns_zone_t * ptr_zone = NULL;
dns_rdata_ptr_t ptr_struct;
dns_rdata_t ptr_rdata = DNS_RDATA_INIT;
dns_ttl_t ttl, dns_diffop_t op) {
isc_result_t result;
isc_mem_t *mctx = inst->mctx;
dns_fixedname_t ptr_name;
dns_zone_t *ptr_zone = NULL;
dns_rdata_ptr_t ptr_struct;
dns_rdata_t ptr_rdata = DNS_RDATA_INIT;
dns_difftuple_t *tp = NULL;
isc_task_t * task = NULL;
syncptrevent_t * pevent = NULL;
isc_task_t *task = NULL;
syncptrevent_t *pevent = NULL;
dns_fixedname_init(&ptr_name);
DNS_RDATACOMMON_INIT(&ptr_struct, dns_rdatatype_ptr, dns_rdataclass_in);
@ -291,13 +288,13 @@ cleanup:
*/
isc_result_t
syncptrs(sample_instance_t *inst, dns_name_t *name, dns_rdataset_t *rdataset,
dns_diffop_t op)
{
dns_diffop_t op) {
isc_result_t result;
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdata_t rdata = DNS_RDATA_INIT;
for (result = dns_rdataset_first(rdataset); result == ISC_R_SUCCESS;
result = dns_rdataset_next(rdataset)) {
result = dns_rdataset_next(rdataset))
{
dns_rdataset_current(rdataset, &rdata);
result = syncptr(inst, name, &rdata, rdataset->ttl, op);
if (result != ISC_R_SUCCESS && result != ISC_R_NOTFOUND) {

Some files were not shown because too many files have changed in this diff Show more