nsd 4.1.15

Previous Topic Next Topic
 
classic Classic list List threaded Threaded
4 messages Options
Reply | Threaded
Open this post in threaded view
|

nsd 4.1.15

Florian Obser-2
tests, OKs?

this contains this local diff, already reported upstream

@@ -664,7 +664,7 @@ add_additional_rrsets(struct query *query, answer_type *answer,
  temp->rnode = NULL;
  temp->dname = additional->dname;
 #else
- memcpy(&temp->node, &additional->node, sizeof(rbnode_t));
+ memcpy(&temp->node, &additional->node, sizeof(rbnode_type));
  temp->node.parent = NULL;
 #endif
  temp->number = additional->number;
@@ -1113,7 +1113,7 @@ answer_authoritative(struct nsd   *nsd,
  match->rnode = NULL;
  match->dname = wildcard_child->dname;
 #else
- memcpy(&match->node, &wildcard_child->node, sizeof(rbnode_t));
+ memcpy(&match->node, &wildcard_child->node, sizeof(rbnode_type));
  match->node.parent = NULL;
 #endif
  match->parent = closest_encloser;


------------------------------------------------------------------------

diff --git axfr.c axfr.c
index 92d4f2fc0c1..6f6b0957e99 100644
--- axfr.c
+++ axfr.c
@@ -164,12 +164,12 @@ return_answer:
 query_state_type
 answer_axfr_ixfr(struct nsd *nsd, struct query *q)
 {
- acl_options_t *acl = NULL;
+ struct acl_options *acl = NULL;
  /* Is it AXFR? */
  switch (q->qtype) {
  case TYPE_AXFR:
  if (q->tcp) {
- zone_options_t* zone_opt;
+ struct zone_options* zone_opt;
  zone_opt = zone_options_find(nsd->options, q->qname);
  if(!zone_opt ||
    acl_check_incoming(zone_opt->pattern->provide_xfr, q, &acl)==-1)
diff --git configparser.y configparser.y
index 204d236b653..bf20db12c72 100644
--- configparser.y
+++ configparser.y
@@ -30,7 +30,7 @@ extern "C"
 #endif /* __cplusplus */
 
 /* these need to be global, otherwise they cannot be used inside yacc */
-extern config_parser_state_t* cfg_parser;
+extern config_parser_state_type* cfg_parser;
 
 #if 0
 #define OUTYY(s) printf s /* used ONLY when debugging */
@@ -108,15 +108,15 @@ server_ip_address: VAR_IP_ADDRESS STRING
  OUTYY(("P(server_ip_address:%s)\n", $2));
  if(cfg_parser->current_ip_address_option) {
  cfg_parser->current_ip_address_option->next =
- (ip_address_option_t*)region_alloc(
- cfg_parser->opt->region, sizeof(ip_address_option_t));
+ (ip_address_option_type*)region_alloc(
+ cfg_parser->opt->region, sizeof(ip_address_option_type));
  cfg_parser->current_ip_address_option =
  cfg_parser->current_ip_address_option->next;
  cfg_parser->current_ip_address_option->next=0;
  } else {
  cfg_parser->current_ip_address_option =
- (ip_address_option_t*)region_alloc(
- cfg_parser->opt->region, sizeof(ip_address_option_t));
+ (ip_address_option_type*)region_alloc(
+ cfg_parser->opt->region, sizeof(ip_address_option_type));
  cfg_parser->current_ip_address_option->next=0;
  cfg_parser->opt->ip_addresses = cfg_parser->current_ip_address_option;
  }
@@ -528,8 +528,8 @@ rc_control_port: VAR_CONTROL_PORT STRING
  ;
 rc_control_interface: VAR_CONTROL_INTERFACE STRING
  {
- ip_address_option_t* o = (ip_address_option_t*)region_alloc(
- cfg_parser->opt->region, sizeof(ip_address_option_t));
+ ip_address_option_type* o = (ip_address_option_type*)region_alloc(
+ cfg_parser->opt->region, sizeof(ip_address_option_type));
  OUTYY(("P(control_interface:%s)\n", $2));
  o->next = cfg_parser->opt->control_interface;
  cfg_parser->opt->control_interface = o;
@@ -706,7 +706,7 @@ zone_zonestats: VAR_ZONESTATS STRING
  ;
 zone_allow_notify: VAR_ALLOW_NOTIFY STRING STRING
  {
- acl_options_t* acl = parse_acl_info(cfg_parser->opt->region, $2, $3);
+ acl_options_type* acl = parse_acl_info(cfg_parser->opt->region, $2, $3);
  OUTYY(("P(allow_notify:%s %s)\n", $2, $3));
  if(cfg_parser->current_allow_notify)
  cfg_parser->current_allow_notify->next = acl;
@@ -729,7 +729,7 @@ zone_size_limit_xfr: VAR_SIZE_LIMIT_XFR STRING
  ;
 zone_request_xfr_data: STRING STRING
  {
- acl_options_t* acl = parse_acl_info(cfg_parser->opt->region, $1, $2);
+ acl_options_type* acl = parse_acl_info(cfg_parser->opt->region, $1, $2);
  OUTYY(("P(request_xfr:%s %s)\n", $1, $2));
  if(acl->blocked) c_error("blocked address used for request-xfr");
  if(acl->rangetype!=acl_range_single) c_error("address range used for request-xfr");
@@ -741,7 +741,7 @@ zone_request_xfr_data: STRING STRING
  }
  | VAR_AXFR STRING STRING
  {
- acl_options_t* acl = parse_acl_info(cfg_parser->opt->region, $2, $3);
+ acl_options_type* acl = parse_acl_info(cfg_parser->opt->region, $2, $3);
  acl->use_axfr_only = 1;
  OUTYY(("P(request_xfr:%s %s)\n", $2, $3));
  if(acl->blocked) c_error("blocked address used for request-xfr");
@@ -754,7 +754,7 @@ zone_request_xfr_data: STRING STRING
  }
  | VAR_UDP STRING STRING
  {
- acl_options_t* acl = parse_acl_info(cfg_parser->opt->region, $2, $3);
+ acl_options_type* acl = parse_acl_info(cfg_parser->opt->region, $2, $3);
  acl->allow_udp = 1;
  OUTYY(("P(request_xfr:%s %s)\n", $2, $3));
  if(acl->blocked) c_error("blocked address used for request-xfr");
@@ -768,7 +768,7 @@ zone_request_xfr_data: STRING STRING
  ;
 zone_notify: VAR_NOTIFY STRING STRING
  {
- acl_options_t* acl = parse_acl_info(cfg_parser->opt->region, $2, $3);
+ acl_options_type* acl = parse_acl_info(cfg_parser->opt->region, $2, $3);
  OUTYY(("P(notify:%s %s)\n", $2, $3));
  if(acl->blocked) c_error("blocked address used for notify");
  if(acl->rangetype!=acl_range_single) c_error("address range used for notify");
@@ -792,7 +792,7 @@ zone_notify_retry: VAR_NOTIFY_RETRY STRING
  ;
 zone_provide_xfr: VAR_PROVIDE_XFR STRING STRING
  {
- acl_options_t* acl = parse_acl_info(cfg_parser->opt->region, $2, $3);
+ acl_options_type* acl = parse_acl_info(cfg_parser->opt->region, $2, $3);
  OUTYY(("P(provide_xfr:%s %s)\n", $2, $3));
  if(cfg_parser->current_provide_xfr)
  cfg_parser->current_provide_xfr->next = acl;
@@ -803,7 +803,7 @@ zone_provide_xfr: VAR_PROVIDE_XFR STRING STRING
  ;
 zone_outgoing_interface: VAR_OUTGOING_INTERFACE STRING
  {
- acl_options_t* acl = parse_acl_info(cfg_parser->opt->region, $2, "NOKEY");
+ acl_options_type* acl = parse_acl_info(cfg_parser->opt->region, $2, "NOKEY");
  OUTYY(("P(outgoing_interface:%s)\n", $2));
  if(acl->rangetype!=acl_range_single) c_error("address range used for outgoing interface");
  if(cfg_parser->current_outgoing_interface)
diff --git configure configure
index 7d220882e2f..b77177afc5b 100644
--- configure
+++ configure
@@ -1,6 +1,6 @@
 #! /bin/sh
 # Guess values for system-dependent variables and create Makefiles.
-# Generated by GNU Autoconf 2.69 for NSD 4.1.14.
+# Generated by GNU Autoconf 2.69 for NSD 4.1.15.
 #
 # Report bugs to <[hidden email]>.
 #
@@ -580,8 +580,8 @@ MAKEFLAGS=
 # Identity of this package.
 PACKAGE_NAME='NSD'
 PACKAGE_TARNAME='nsd'
-PACKAGE_VERSION='4.1.14'
-PACKAGE_STRING='NSD 4.1.14'
+PACKAGE_VERSION='4.1.15'
+PACKAGE_STRING='NSD 4.1.15'
 PACKAGE_BUGREPORT='[hidden email]'
 PACKAGE_URL=''
 
@@ -1284,7 +1284,7 @@ if test "$ac_init_help" = "long"; then
   # Omit some internal or obsolete options to make the list less imposing.
   # This message is too long to be a string in the A/UX 3.1 sh.
   cat <<_ACEOF
-\`configure' configures NSD 4.1.14 to adapt to many kinds of systems.
+\`configure' configures NSD 4.1.15 to adapt to many kinds of systems.
 
 Usage: $0 [OPTION]... [VAR=VALUE]...
 
@@ -1345,7 +1345,7 @@ fi
 
 if test -n "$ac_init_help"; then
   case $ac_init_help in
-     short | recursive ) echo "Configuration of NSD 4.1.14:";;
+     short | recursive ) echo "Configuration of NSD 4.1.15:";;
    esac
   cat <<\_ACEOF
 
@@ -1491,7 +1491,7 @@ fi
 test -n "$ac_init_help" && exit $ac_status
 if $ac_init_version; then
   cat <<\_ACEOF
-NSD configure 4.1.14
+NSD configure 4.1.15
 generated by GNU Autoconf 2.69
 
 Copyright (C) 2012 Free Software Foundation, Inc.
@@ -2200,7 +2200,7 @@ cat >config.log <<_ACEOF
 This file contains any messages produced by compilers while
 running configure, to aid debugging if configure makes a mistake.
 
-It was created by NSD $as_me 4.1.14, which was
+It was created by NSD $as_me 4.1.15, which was
 generated by GNU Autoconf 2.69.  Invocation command line was
 
   $ $0 $@
@@ -9717,7 +9717,7 @@ cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
 # report actual input values of CONFIG_FILES etc. instead of their
 # values after options handling.
 ac_log="
-This file was extended by NSD $as_me 4.1.14, which was
+This file was extended by NSD $as_me 4.1.15, which was
 generated by GNU Autoconf 2.69.  Invocation command line was
 
   CONFIG_FILES    = $CONFIG_FILES
@@ -9779,7 +9779,7 @@ _ACEOF
 cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
 ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
 ac_cs_version="\\
-NSD config.status 4.1.14
+NSD config.status 4.1.15
 configured by $0, generated by GNU Autoconf 2.69,
   with options \\"\$ac_cs_config\\"
 
diff --git configure.ac configure.ac
index 029193574f0..b984cac435a 100644
--- configure.ac
+++ configure.ac
@@ -4,7 +4,7 @@ dnl
 
 sinclude(acx_nlnetlabs.m4)
 
-AC_INIT(NSD,4.1.14,[hidden email])
+AC_INIT(NSD,4.1.15,[hidden email])
 AC_CONFIG_HEADER([config.h])
 
 CFLAGS="$CFLAGS"
diff --git dbaccess.c dbaccess.c
index cc49a51a3e3..317273361b7 100644
--- dbaccess.c
+++ dbaccess.c
@@ -247,7 +247,7 @@ read_zone_data(udb_base* udb, namedb_type* db, region_type* dname_region,
 /** create a zone */
 zone_type*
 namedb_zone_create(namedb_type* db, const dname_type* dname,
- zone_options_t* zo)
+ struct zone_options* zo)
 {
  zone_type* zone = (zone_type *) region_alloc(db->region,
  sizeof(zone_type));
@@ -321,12 +321,12 @@ namedb_zone_delete(namedb_type* db, zone_type* zone)
 #ifdef HAVE_MMAP
 /** read a zone */
 static void
-read_zone(udb_base* udb, namedb_type* db, nsd_options_t* opt,
+read_zone(udb_base* udb, namedb_type* db, struct nsd_options* opt,
  region_type* dname_region, udb_ptr* z)
 {
  /* construct dname */
  const dname_type* dname = dname_make(dname_region, ZONE(z)->name, 0);
- zone_options_t* zo = dname?zone_options_find(opt, dname):NULL;
+ struct zone_options* zo = dname?zone_options_find(opt, dname):NULL;
  zone_type* zone;
  if(!dname) return;
  if(!zo) {
@@ -353,7 +353,7 @@ read_zone(udb_base* udb, namedb_type* db, nsd_options_t* opt,
 #ifdef HAVE_MMAP
 /** read zones from nsd.db */
 static void
-read_zones(udb_base* udb, namedb_type* db, nsd_options_t* opt,
+read_zones(udb_base* udb, namedb_type* db, struct nsd_options* opt,
  region_type* dname_region)
 {
  udb_ptr ztree, n, z;
@@ -378,7 +378,7 @@ read_zones(udb_base* udb, namedb_type* db, nsd_options_t* opt,
 /** try to read the udb file or fail */
 static int
 try_read_udb(namedb_type* db, int fd, const char* filename,
- nsd_options_t* opt)
+ struct nsd_options* opt)
 {
  /*
  * Temporary region used while loading domain names from the
@@ -414,7 +414,7 @@ try_read_udb(namedb_type* db, int fd, const char* filename,
 #endif /* HAVE_MMAP */
 
 struct namedb *
-namedb_open (const char* filename, nsd_options_t* opt)
+namedb_open (const char* filename, struct nsd_options* opt)
 {
  namedb_type* db;
 
@@ -653,7 +653,7 @@ namedb_read_zonefile(struct nsd* nsd, struct zone* zone, udb_base* taskudb,
 }
 
 void namedb_check_zonefile(struct nsd* nsd, udb_base* taskudb,
- udb_ptr* last_task, zone_options_t* zopt)
+ udb_ptr* last_task, struct zone_options* zopt)
 {
  zone_type* zone;
  const dname_type* dname = (const dname_type*)zopt->node.key;
@@ -665,12 +665,12 @@ void namedb_check_zonefile(struct nsd* nsd, udb_base* taskudb,
  namedb_read_zonefile(nsd, zone, taskudb, last_task);
 }
 
-void namedb_check_zonefiles(struct nsd* nsd, nsd_options_t* opt,
+void namedb_check_zonefiles(struct nsd* nsd, struct nsd_options* opt,
  udb_base* taskudb, udb_ptr* last_task)
 {
- zone_options_t* zo;
+ struct zone_options* zo;
  /* check all zones in opt, create if not exist in main db */
- RBTREE_FOR(zo, zone_options_t*, opt->zone_options) {
+ RBTREE_FOR(zo, struct zone_options*, opt->zone_options) {
  namedb_check_zonefile(nsd, taskudb, last_task, zo);
  if(nsd->signal_hint_shutdown) break;
  }
diff --git dbcreate.c dbcreate.c
index ce2149138ed..d8d4608505b 100644
--- dbcreate.c
+++ dbcreate.c
@@ -326,7 +326,7 @@ create_path_components(const char* path, int* notexist)
 }
 
 void
-namedb_write_zonefile(struct nsd* nsd, zone_options_t* zopt)
+namedb_write_zonefile(struct nsd* nsd, struct zone_options* zopt)
 {
  const char* zfile;
  int notexist = 0;
@@ -412,10 +412,10 @@ namedb_write_zonefile(struct nsd* nsd, zone_options_t* zopt)
 }
 
 void
-namedb_write_zonefiles(struct nsd* nsd, nsd_options_t* options)
+namedb_write_zonefiles(struct nsd* nsd, struct nsd_options* options)
 {
- zone_options_t* zo;
- RBTREE_FOR(zo, zone_options_t*, options->zone_options) {
+ struct zone_options* zo;
+ RBTREE_FOR(zo, struct zone_options*, options->zone_options) {
  namedb_write_zonefile(nsd, zo);
  }
 }
diff --git difffile.c difffile.c
index 6890a31db9d..720e3a5cc6e 100644
--- difffile.c
+++ difffile.c
@@ -858,10 +858,10 @@ add_RR(namedb_type* db, const dname_type* dname,
 
 static zone_type*
 find_or_create_zone(namedb_type* db, const dname_type* zone_name,
- nsd_options_t* opt, const char* zstr, const char* patname)
+ struct nsd_options* opt, const char* zstr, const char* patname)
 {
  zone_type* zone;
- zone_options_t* zopt;
+ struct zone_options* zopt;
  zone = namedb_find_zone(db, zone_name);
  if(zone) {
  return zone;
@@ -958,7 +958,7 @@ delete_zone_rrs(namedb_type* db, zone_type* zone)
 /* return value 0: syntaxerror,badIXFR, 1:OK, 2:done_and_skip_it */
 static int
 apply_ixfr(namedb_type* db, FILE *in, const char* zone, uint32_t serialno,
- nsd_options_t* opt, uint32_t seq_nr, uint32_t seq_total,
+ struct nsd_options* opt, uint32_t seq_nr, uint32_t seq_total,
  int* is_axfr, int* delete_mode, int* rr_count,
  udb_ptr* udbz, struct zone** zone_res, const char* patname, int* bytes,
  int* softfail)
@@ -1256,7 +1256,7 @@ check_for_bad_serial(namedb_type* db, const char* zone_str, uint32_t old_serial)
 
 static int
 apply_ixfr_for_zone(nsd_type* nsd, zone_type* zonedb, FILE* in,
- nsd_options_t* opt, udb_base* taskudb, udb_ptr* last_task,
+ struct nsd_options* opt, udb_base* taskudb, udb_ptr* last_task,
  uint32_t xfrfilenr)
 {
  char zone_buf[3072];
@@ -1617,7 +1617,7 @@ void* task_new_stat_info(udb_base* udb, udb_ptr* last, struct nsdst* stat,
  udb_ptr e;
  DEBUG(DEBUG_IPC,1, (LOG_INFO, "add task stat_info"));
  if(!task_create_new_elem(udb, last, &e, sizeof(struct task_list_d)+
- sizeof(*stat) + sizeof(stc_t)*child_count, NULL)) {
+ sizeof(*stat) + sizeof(stc_type)*child_count, NULL)) {
  log_msg(LOG_ERR, "tasklist: out of space, cannot add stati");
  return NULL;
  }
@@ -1665,7 +1665,7 @@ task_new_del_zone(udb_base* udb, udb_ptr* last, const dname_type* dname)
  udb_ptr_unlink(&e, udb);
 }
 
-void task_new_add_key(udb_base* udb, udb_ptr* last, key_options_t* key)
+void task_new_add_key(udb_base* udb, udb_ptr* last, struct key_options* key)
 {
  char* p;
  udb_ptr e;
@@ -1703,7 +1703,8 @@ void task_new_del_key(udb_base* udb, udb_ptr* last, const char* name)
  udb_ptr_unlink(&e, udb);
 }
 
-void task_new_add_pattern(udb_base* udb, udb_ptr* last, pattern_options_t* p)
+void task_new_add_pattern(udb_base* udb, udb_ptr* last,
+ struct pattern_options* p)
 {
  region_type* temp;
  buffer_type* buffer;
@@ -1743,7 +1744,7 @@ void task_new_del_pattern(udb_base* udb, udb_ptr* last, const char* name)
  udb_ptr_unlink(&e, udb);
 }
 
-void task_new_opt_change(udb_base* udb, udb_ptr* last, nsd_options_t* opt)
+void task_new_opt_change(udb_base* udb, udb_ptr* last, struct nsd_options* opt)
 {
  udb_ptr e;
  DEBUG(DEBUG_IPC,1, (LOG_INFO, "add task opt_change"));
@@ -1837,7 +1838,7 @@ task_process_checkzones(struct nsd* nsd, udb_base* udb, udb_ptr* last_task,
  /* on SIGHUP check if zone-text-files changed and if so,
  * reread.  When from xfrd-reload, no need to fstat the files */
  if(task->yesno) {
- zone_options_t* zo = zone_options_find(nsd->options,
+ struct zone_options* zo = zone_options_find(nsd->options,
  task->zname);
  if(zo)
  namedb_check_zonefile(nsd, udb, last_task, zo);
@@ -1851,7 +1852,7 @@ static void
 task_process_writezones(struct nsd* nsd, struct task_list_d* task)
 {
  if(task->yesno) {
- zone_options_t* zo = zone_options_find(nsd->options,
+ struct zone_options* zo = zone_options_find(nsd->options,
  task->zname);
  if(zo)
  namedb_write_zonefile(nsd, zo);
@@ -1893,7 +1894,7 @@ static void
 task_process_del_zone(struct nsd* nsd, struct task_list_d* task)
 {
  zone_type* zone;
- zone_options_t* zopt;
+ struct zone_options* zopt;
  DEBUG(DEBUG_IPC,1, (LOG_INFO, "delzone task %s", dname_to_string(
  task->zname, NULL)));
  zone = namedb_find_zone(nsd->db, task->zname);
@@ -1927,7 +1928,7 @@ task_process_del_zone(struct nsd* nsd, struct task_list_d* task)
 static void
 task_process_add_key(struct nsd* nsd, struct task_list_d* task)
 {
- key_options_t key;
+ struct key_options key;
  key.name = (char*)task->zname;
  DEBUG(DEBUG_IPC,1, (LOG_INFO, "addkey task %s", key.name));
  key.algorithm = key.name + strlen(key.name)+1;
@@ -1950,7 +1951,7 @@ task_process_add_pattern(struct nsd* nsd, struct task_list_d* task)
 {
  region_type* temp = region_create(xalloc, free);
  buffer_type buffer;
- pattern_options_t *pat;
+ struct pattern_options *pat;
  buffer_create_from(&buffer, task->zname, task->yesno);
  pat = pattern_options_unmarshal(temp, &buffer);
  DEBUG(DEBUG_IPC,1, (LOG_INFO, "addpattern task %s", pat->pname));
diff --git difffile.h difffile.h
index ae0dbff921a..f6db6e28234 100644
--- difffile.h
+++ difffile.h
@@ -119,11 +119,12 @@ void task_new_set_verbosity(udb_base* udb, udb_ptr* last, int v);
 void task_new_add_zone(udb_base* udb, udb_ptr* last, const char* zone,
  const char* pattern, unsigned zonestatid);
 void task_new_del_zone(udb_base* udb, udb_ptr* last, const dname_type* dname);
-void task_new_add_key(udb_base* udb, udb_ptr* last, key_options_t* key);
+void task_new_add_key(udb_base* udb, udb_ptr* last, struct key_options* key);
 void task_new_del_key(udb_base* udb, udb_ptr* last, const char* name);
-void task_new_add_pattern(udb_base* udb, udb_ptr* last, pattern_options_t* p);
+void task_new_add_pattern(udb_base* udb, udb_ptr* last,
+ struct pattern_options* p);
 void task_new_del_pattern(udb_base* udb, udb_ptr* last, const char* name);
-void task_new_opt_change(udb_base* udb, udb_ptr* last, nsd_options_t* opt);
+void task_new_opt_change(udb_base* udb, udb_ptr* last, struct nsd_options* opt);
 void task_new_zonestat_inc(udb_base* udb, udb_ptr* last, unsigned sz);
 int task_new_apply_xfr(udb_base* udb, udb_ptr* last, const dname_type* zone,
  uint32_t old_serial, uint32_t new_serial, uint64_t filenumber);
diff --git ipc.c ipc.c
index 8b5cba4bb88..5466239265a 100644
--- ipc.c
+++ ipc.c
@@ -24,11 +24,11 @@
 /* attempt to send NSD_STATS command to child fd */
 static void send_stat_to_child(struct main_ipc_handler_data* data, int fd);
 /* send reload request over the IPC channel */
-static void xfrd_send_reload_req(xfrd_state_t* xfrd);
+static void xfrd_send_reload_req(xfrd_state_type* xfrd);
 /* send quit request over the IPC channel */
-static void xfrd_send_quit_req(xfrd_state_t* xfrd);
+static void xfrd_send_quit_req(xfrd_state_type* xfrd);
 /* perform read part of handle ipc for xfrd */
-static void xfrd_handle_ipc_read(struct event* handler, xfrd_state_t* xfrd);
+static void xfrd_handle_ipc_read(struct event* handler, xfrd_state_type* xfrd);
 
 static void
 ipc_child_quit(struct nsd* nsd)
@@ -254,17 +254,17 @@ void
 stats_add(struct nsdst* total, struct nsdst* s)
 {
  unsigned i;
- for(i=0; i<sizeof(total->qtype)/sizeof(stc_t); i++)
+ for(i=0; i<sizeof(total->qtype)/sizeof(stc_type); i++)
  total->qtype[i] += s->qtype[i];
- for(i=0; i<sizeof(total->qclass)/sizeof(stc_t); i++)
+ for(i=0; i<sizeof(total->qclass)/sizeof(stc_type); i++)
  total->qclass[i] += s->qclass[i];
  total->qudp += s->qudp;
  total->qudp6 += s->qudp6;
  total->ctcp += s->ctcp;
  total->ctcp6 += s->ctcp6;
- for(i=0; i<sizeof(total->rcode)/sizeof(stc_t); i++)
+ for(i=0; i<sizeof(total->rcode)/sizeof(stc_type); i++)
  total->rcode[i] += s->rcode[i];
- for(i=0; i<sizeof(total->opcode)/sizeof(stc_t); i++)
+ for(i=0; i<sizeof(total->opcode)/sizeof(stc_type); i++)
  total->opcode[i] += s->opcode[i];
  total->dropped += s->dropped;
  total->truncated += s->truncated;
@@ -285,17 +285,17 @@ void
 stats_subtract(struct nsdst* total, struct nsdst* s)
 {
  unsigned i;
- for(i=0; i<sizeof(total->qtype)/sizeof(stc_t); i++)
+ for(i=0; i<sizeof(total->qtype)/sizeof(stc_type); i++)
  total->qtype[i] -= s->qtype[i];
- for(i=0; i<sizeof(total->qclass)/sizeof(stc_t); i++)
+ for(i=0; i<sizeof(total->qclass)/sizeof(stc_type); i++)
  total->qclass[i] -= s->qclass[i];
  total->qudp -= s->qudp;
  total->qudp6 -= s->qudp6;
  total->ctcp -= s->ctcp;
  total->ctcp6 -= s->ctcp6;
- for(i=0; i<sizeof(total->rcode)/sizeof(stc_t); i++)
+ for(i=0; i<sizeof(total->rcode)/sizeof(stc_type); i++)
  total->rcode[i] -= s->rcode[i];
- for(i=0; i<sizeof(total->opcode)/sizeof(stc_t); i++)
+ for(i=0; i<sizeof(total->opcode)/sizeof(stc_type); i++)
  total->opcode[i] -= s->opcode[i];
  total->dropped -= s->dropped;
  total->truncated -= s->truncated;
@@ -553,7 +553,7 @@ parent_handle_reload_command(netio_type *ATTR_UNUSED(netio),
 }
 
 static void
-xfrd_send_reload_req(xfrd_state_t* xfrd)
+xfrd_send_reload_req(xfrd_state_type* xfrd)
 {
  sig_atomic_t req = NSD_RELOAD;
  uint64_t p = xfrd->last_task->data;
@@ -598,7 +598,7 @@ ipc_xfrd_set_listening(struct xfrd_state* xfrd, short mode)
 }
 
 static void
-xfrd_send_shutdown_req(xfrd_state_t* xfrd)
+xfrd_send_shutdown_req(xfrd_state_type* xfrd)
 {
  sig_atomic_t cmd = NSD_SHUTDOWN;
  xfrd->ipc_send_blocked = 1;
@@ -612,7 +612,7 @@ xfrd_send_shutdown_req(xfrd_state_t* xfrd)
 }
 
 static void
-xfrd_send_quit_req(xfrd_state_t* xfrd)
+xfrd_send_quit_req(xfrd_state_type* xfrd)
 {
  sig_atomic_t cmd = NSD_QUIT;
  xfrd->ipc_send_blocked = 1;
@@ -626,7 +626,7 @@ xfrd_send_quit_req(xfrd_state_t* xfrd)
 }
 
 static void
-xfrd_send_stats(xfrd_state_t* xfrd)
+xfrd_send_stats(xfrd_state_type* xfrd)
 {
  sig_atomic_t cmd = NSD_STATS;
  DEBUG(DEBUG_IPC,1, (LOG_INFO, "xfrd: ipc send stats"));
@@ -640,7 +640,7 @@ xfrd_send_stats(xfrd_state_t* xfrd)
 void
 xfrd_handle_ipc(int ATTR_UNUSED(fd), short event, void* arg)
 {
- xfrd_state_t* xfrd = (xfrd_state_t*)arg;
+ xfrd_state_type* xfrd = (xfrd_state_type*)arg;
         if ((event & EV_READ))
  {
  /* first attempt to read as a signal from main
@@ -674,7 +674,7 @@ xfrd_handle_ipc(int ATTR_UNUSED(fd), short event, void* arg)
 }
 
 static void
-xfrd_handle_ipc_read(struct event* handler, xfrd_state_t* xfrd)
+xfrd_handle_ipc_read(struct event* handler, xfrd_state_type* xfrd)
 {
         sig_atomic_t cmd;
         int len;
diff --git mini_event.c mini_event.c
index c96dbbb1cef..a39d682cc51 100644
--- mini_event.c
+++ mini_event.c
@@ -166,7 +166,7 @@ handle_timeouts(struct event_base* base, struct timeval* now,
  wait->tv_sec = (time_t)-1;
 #endif
 
- while((rbnode_t*)(p = (struct event*)rbtree_first(base->times))
+ while((rbnode_type*)(p = (struct event*)rbtree_first(base->times))
  !=RBTREE_NULL) {
 #ifndef S_SPLINT_S
  if(p->ev_timeout.tv_sec > now->tv_sec ||
diff --git mini_event.h mini_event.h
index 1b4a2f2dd3e..fbc56b15f24 100644
--- mini_event.h
+++ mini_event.h
@@ -82,7 +82,7 @@ struct region;
 struct event_base
 {
  /** sorted by timeout (absolute), ptr */
- rbtree_t* times;
+ rbtree_type* times;
  /** array of 0 - maxfd of ptr to event for it */
  struct event** fds;
  /** max fd in use */
@@ -116,7 +116,7 @@ struct event_base
  */
 struct event {
  /** node in timeout rbtree */
- rbnode_t node;
+ rbnode_type node;
  /** is event already added */
  int added;
 
diff --git namedb.c namedb.c
index fd381e98d32..f59f0b76fa3 100644
--- namedb.c
+++ namedb.c
@@ -164,7 +164,7 @@ int domain_is_prehash(domain_table_type* table, domain_type* domain)
 
 /** remove domain node from NSEC3 tree in hash space */
 void
-zone_del_domain_in_hash_tree(rbtree_t* tree, rbnode_t* node)
+zone_del_domain_in_hash_tree(rbtree_type* tree, rbnode_type* node)
 {
  if(!node->key)
  return;
@@ -280,9 +280,9 @@ domain_table_deldomain(namedb_type* db, domain_type* domain)
 
 /** clear hash tree */
 void
-hash_tree_clear(rbtree_t* tree)
+hash_tree_clear(rbtree_type* tree)
 {
- rbnode_t* n;
+ rbnode_type* n;
  if(!tree) return;
 
  /* note that elements are no longer in the tree */
@@ -293,19 +293,19 @@ hash_tree_clear(rbtree_t* tree)
  tree->root = RBTREE_NULL;
 }
 
-void hash_tree_delete(region_type* region, rbtree_t* tree)
+void hash_tree_delete(region_type* region, rbtree_type* tree)
 {
- region_recycle(region, tree, sizeof(rbtree_t));
+ region_recycle(region, tree, sizeof(rbtree_type));
 }
 
 /** add domain nsec3 node to hashedspace tree */
-void zone_add_domain_in_hash_tree(region_type* region, rbtree_t** tree,
+void zone_add_domain_in_hash_tree(region_type* region, rbtree_type** tree,
  int (*cmpf)(const void*, const void*),
- domain_type* domain, rbnode_t* node)
+ domain_type* domain, rbnode_type* node)
 {
  if(!*tree)
  *tree = rbtree_create(region, cmpf);
- memset(node, 0, sizeof(rbnode_t));
+ memset(node, 0, sizeof(rbnode_type));
  node->key = domain;
  rbtree_insert(*tree, node);
 }
@@ -351,7 +351,7 @@ domain_table_create(region_type* region)
 #else
  result->names_to_domains = rbtree_create(
  region, (int (*)(const void *, const void *)) dname_compare);
- rbtree_insert(result->names_to_domains, (rbnode_t *) root);
+ rbtree_insert(result->names_to_domains, (rbnode_type *) root);
 #endif
 
  result->root = root;
@@ -382,7 +382,7 @@ domain_table_search(domain_table_type *table,
  dname->name_size, (struct radnode**)closest_match);
  *closest_match = (domain_type*)((*(struct radnode**)closest_match)->elem);
 #else
- exact = rbtree_find_less_equal(table->names_to_domains, dname, (rbnode_t **) closest_match);
+ exact = rbtree_find_less_equal(table->names_to_domains, dname, (rbnode_type **) closest_match);
 #endif
  assert(*closest_match);
 
@@ -445,7 +445,7 @@ domain_table_insert(domain_table_type* table,
  dname_name(result->dname),
  result->dname->name_size, result);
 #else
- rbtree_insert(table->names_to_domains, (rbnode_t *) result);
+ rbtree_insert(table->names_to_domains, (rbnode_type *) result);
 #endif
 
  /*
diff --git namedb.h namedb.h
index d8cefeb1af5..e2d84517854 100644
--- namedb.h
+++ namedb.h
@@ -40,7 +40,7 @@ struct domain_table
 #ifdef USE_RADIX_TREE
  struct radtree *nametree;
 #else
- rbtree_t      *names_to_domains;
+ rbtree_type      *names_to_domains;
 #endif
  domain_type* root;
  /* ptr to biggest domain.number and last in list.
@@ -63,13 +63,13 @@ struct nsec3_domain_data {
  /* NSEC3 domains to prehash, prev and next on the list or cleared */
  domain_type* prehash_prev, *prehash_next;
  /* entry in the nsec3tree (for NSEC3s in the chain in use) */
- rbnode_t nsec3_node;
+ rbnode_type nsec3_node;
  /* entry in the hashtree (for precompiled domains) */
- rbnode_t hash_node;
+ rbnode_type hash_node;
  /* entry in the wchashtree (the wildcard precompile) */
- rbnode_t wchash_node;
+ rbnode_type wchash_node;
  /* entry in the dshashtree (the parent ds precompile) */
- rbnode_t dshash_node;
+ rbnode_type dshash_node;
 
  /* nsec3 hash */
  uint8_t nsec3_hash[NSEC3_HASH_LEN];
@@ -94,7 +94,7 @@ struct domain
  struct radnode* rnode;
  const dname_type* dname;
 #else
- rbnode_t     node;
+ rbnode_type     node;
 #endif
  domain_type* parent;
  domain_type* wildcard_child_closest_match;
@@ -127,10 +127,10 @@ struct zone
  rr_type* nsec3_param; /* NSEC3PARAM RR of chain in use or NULL */
  domain_type* nsec3_last; /* last domain with nsec3, wraps */
  /* in these trees, the root contains an elem ptr to the radtree* */
- rbtree_t* nsec3tree; /* tree with relevant NSEC3 domains */
- rbtree_t* hashtree; /* tree, hashed NSEC3precompiled domains */
- rbtree_t* wchashtree; /* tree, wildcard hashed domains */
- rbtree_t* dshashtree; /* tree, ds-parent-hash domains */
+ rbtree_type* nsec3tree; /* tree with relevant NSEC3 domains */
+ rbtree_type* hashtree; /* tree, hashed NSEC3precompiled domains */
+ rbtree_type* wchashtree; /* tree, wildcard hashed domains */
+ rbtree_type* dshashtree; /* tree, ds-parent-hash domains */
 #endif
  struct zone_options* opts;
  char*        filename; /* set if read from file, which file */
@@ -223,12 +223,12 @@ domain_type *domain_table_insert(domain_table_type *table,
  const dname_type  *dname);
 
 /* put domain into nsec3 hash space tree */
-void zone_add_domain_in_hash_tree(region_type* region, rbtree_t** tree,
+void zone_add_domain_in_hash_tree(region_type* region, rbtree_type** tree,
  int (*cmpf)(const void*, const void*), domain_type* domain,
- rbnode_t* node);
-void zone_del_domain_in_hash_tree(rbtree_t* tree, rbnode_t* node);
-void hash_tree_clear(rbtree_t* tree);
-void hash_tree_delete(region_type* region, rbtree_t* tree);
+ rbnode_type* node);
+void zone_del_domain_in_hash_tree(rbtree_type* tree, rbnode_type* node);
+void hash_tree_clear(rbtree_type* tree);
+void hash_tree_delete(region_type* region, rbtree_type* tree);
 void prehash_clear(domain_table_type* table);
 void prehash_add(domain_table_type* table, domain_type* domain);
 void prehash_del(domain_table_type* table, domain_type* domain);
@@ -286,7 +286,7 @@ domain_previous(domain_type* domain)
  struct radnode* prev = radix_prev(domain->rnode);
  return prev == NULL ? NULL : (domain_type*)prev->elem;
 #else
- rbnode_t *prev = rbtree_previous((rbnode_t *) domain);
+ rbnode_type *prev = rbtree_previous((rbnode_type *) domain);
  return prev == RBTREE_NULL ? NULL : (domain_type *) prev;
 #endif
 }
@@ -298,7 +298,7 @@ domain_next(domain_type* domain)
  struct radnode* next = radix_next(domain->rnode);
  return next == NULL ? NULL : (domain_type*)next->elem;
 #else
- rbnode_t *next = rbtree_next((rbnode_t *) domain);
+ rbnode_type *next = rbtree_next((rbnode_type *) domain);
  return next == RBTREE_NULL ? NULL : (domain_type *) next;
 #endif
 }
diff --git nsd-checkconf.c nsd-checkconf.c
index 4559c3ac068..0f8b2c8e1cd 100644
--- nsd-checkconf.c
+++ nsd-checkconf.c
@@ -29,7 +29,7 @@ extern int optind;
 
 #define ZONE_GET_OUTGOING(NAME, VAR, PATTERN) \
  if (strcasecmp(#NAME, (VAR)) == 0) { \
- acl_options_t* acl; \
+ acl_options_type* acl; \
  for(acl=PATTERN->NAME; acl; acl=acl->next) \
  quote(acl->ip_address_spec); \
  return; \
@@ -176,7 +176,7 @@ quote(const char *v)
 }
 
 static void
-quotepath(nsd_options_t* opt, int final, const char *f)
+quotepath(nsd_options_type* opt, int final, const char *f)
 {
  const char* chr = opt->chroot;
 #ifdef CHROOTDIR
@@ -191,7 +191,7 @@ quotepath(nsd_options_t* opt, int final, const char *f)
 }
 
 static void
-quote_acl(acl_options_t* acl)
+quote_acl(acl_options_type* acl)
 {
  while(acl)
  {
@@ -203,7 +203,7 @@ quote_acl(acl_options_t* acl)
 }
 
 static void
-print_acl(const char* varname, acl_options_t* acl)
+print_acl(const char* varname, acl_options_type* acl)
 {
  while(acl)
  {
@@ -251,7 +251,7 @@ print_acl(const char* varname, acl_options_t* acl)
 }
 
 static void
-print_acl_ips(const char* varname, acl_options_t* acl)
+print_acl_ips(const char* varname, acl_options_type* acl)
 {
  while(acl)
  {
@@ -261,14 +261,14 @@ print_acl_ips(const char* varname, acl_options_t* acl)
 }
 
 void
-config_print_zone(nsd_options_t* opt, const char* k, int s, const char *o,
+config_print_zone(nsd_options_type* opt, const char* k, int s, const char *o,
  const char *z, const char* pat, int final)
 {
- ip_address_option_t* ip;
+ ip_address_option_type* ip;
 
  if (k) {
  /* find key */
- key_options_t* key = key_options_find(opt, k);
+ key_options_type* key = key_options_find(opt, k);
  if(key) {
  if (s) {
  quote(key->secret);
@@ -286,7 +286,7 @@ config_print_zone(nsd_options_t* opt, const char* k, int s, const char *o,
  }
 
  if (z) {
- zone_options_t* zone;
+ zone_options_type* zone;
  const dname_type *dname = dname_parse(opt->region, z);
  if(!dname) {
  printf("Could not parse zone name %s\n", z);
@@ -324,7 +324,7 @@ config_print_zone(nsd_options_t* opt, const char* k, int s, const char *o,
  printf("Zone option not handled: %s %s\n", z, o);
  exit(1);
  } else if(pat) {
- pattern_options_t* p = pattern_options_find(opt, pat);
+ pattern_options_type* p = pattern_options_find(opt, pat);
  if(!p) {
  printf("Pattern does not exist: %s\n", pat);
  exit(1);
@@ -413,14 +413,14 @@ config_print_zone(nsd_options_t* opt, const char* k, int s, const char *o,
  SERV_GET_STR(control_cert_file, o);
 
  if(strcasecmp(o, "zones") == 0) {
- zone_options_t* zone;
- RBTREE_FOR(zone, zone_options_t*, opt->zone_options)
+ zone_options_type* zone;
+ RBTREE_FOR(zone, zone_options_type*, opt->zone_options)
  quote(zone->name);
  return;
  }
  if(strcasecmp(o, "patterns") == 0) {
- pattern_options_t* p;
- RBTREE_FOR(p, pattern_options_t*, opt->patterns)
+ pattern_options_type* p;
+ RBTREE_FOR(p, pattern_options_type*, opt->patterns)
  quote(p->pname);
  return;
  }
@@ -430,7 +430,7 @@ config_print_zone(nsd_options_t* opt, const char* k, int s, const char *o,
 }
 
 /* print zone content items */
-static void print_zone_content_elems(pattern_options_t* pat)
+static void print_zone_content_elems(pattern_options_type* pat)
 {
  if(pat->zonefile)
  print_string_var("zonefile:", pat->zonefile);
@@ -465,12 +465,12 @@ static void print_zone_content_elems(pattern_options_t* pat)
 }
 
 void
-config_test_print_server(nsd_options_t* opt)
+config_test_print_server(nsd_options_type* opt)
 {
- ip_address_option_t* ip;
- key_options_t* key;
- zone_options_t* zone;
- pattern_options_t* pat;
+ ip_address_option_type* ip;
+ key_options_type* key;
+ zone_options_type* zone;
+ pattern_options_type* pat;
 
  printf("# Config settings.\n");
  printf("server:\n");
@@ -532,21 +532,21 @@ config_test_print_server(nsd_options_t* opt)
  print_string_var("control-key-file:", opt->control_key_file);
  print_string_var("control-cert-file:", opt->control_cert_file);
 
- RBTREE_FOR(key, key_options_t*, opt->keys)
+ RBTREE_FOR(key, key_options_type*, opt->keys)
  {
  printf("\nkey:\n");
  print_string_var("name:", key->name);
  print_string_var("algorithm:", key->algorithm);
  print_string_var("secret:", key->secret);
  }
- RBTREE_FOR(pat, pattern_options_t*, opt->patterns)
+ RBTREE_FOR(pat, pattern_options_type*, opt->patterns)
  {
  if(pat->implicit) continue;
  printf("\npattern:\n");
  print_string_var("name:", pat->pname);
  print_zone_content_elems(pat);
  }
- RBTREE_FOR(zone, zone_options_t*, opt->zone_options)
+ RBTREE_FOR(zone, zone_options_type*, opt->zone_options)
  {
  if(!zone->part_of_config)
  continue;
@@ -578,12 +578,12 @@ file_inside_chroot(const char* fname, const char* chr)
 }
 
 static int
-additional_checks(nsd_options_t* opt, const char* filename)
+additional_checks(nsd_options_type* opt, const char* filename)
 {
- zone_options_t* zone;
+ zone_options_type* zone;
  int errors = 0;
 
- RBTREE_FOR(zone, zone_options_t*, opt->zone_options)
+ RBTREE_FOR(zone, zone_options_type*, opt->zone_options)
  {
  const dname_type* dname = dname_parse(opt->region, zone->name); /* memory leak. */
  if(!dname) {
@@ -707,7 +707,7 @@ main(int argc, char* argv[])
  const char * conf_key = NULL; /* what key is needed */
  const char * conf_pat = NULL; /* what pattern is talked about */
  const char* configfile;
- nsd_options_t *options;
+ nsd_options_type *options;
 
  log_init("nsd-checkconf");
 
diff --git nsd-checkzone.c nsd-checkzone.c
index 95bb4e72836..c8366f99e14 100644
--- nsd-checkzone.c
+++ nsd-checkzone.c
@@ -55,7 +55,7 @@ static void
 check_zone(struct nsd* nsd, const char* name, const char* fname)
 {
  const dname_type* dname;
- zone_options_t* zo;
+ zone_options_type* zo;
  zone_type* zone;
  unsigned errors;
 
diff --git nsd-control.c nsd-control.c
index 0b482839b47..da19f02abaa 100644
--- nsd-control.c
+++ nsd-control.c
@@ -106,7 +106,7 @@ static void ssl_err(const char* s)
 
 /** setup SSL context */
 static SSL_CTX*
-setup_ctx(nsd_options_t* cfg)
+setup_ctx(struct nsd_options* cfg)
 {
  char* s_cert, *c_key, *c_cert;
  SSL_CTX* ctx;
@@ -144,7 +144,7 @@ setup_ctx(nsd_options_t* cfg)
 
 /** contact the server with TCP connect */
 static int
-contact_server(const char* svr, nsd_options_t* cfg, int statuscmd)
+contact_server(const char* svr, struct nsd_options* cfg, int statuscmd)
 {
 #ifdef INET6
  struct sockaddr_storage addr;
@@ -156,9 +156,13 @@ contact_server(const char* svr, nsd_options_t* cfg, int statuscmd)
  int port = cfg->control_port;
  /* use svr or a config entry */
  if(!svr) {
- if(cfg->control_interface)
+ if(cfg->control_interface) {
  svr = cfg->control_interface->address;
- else svr = "127.0.0.1";
+ } else if(cfg->do_ip4) {
+ svr = "127.0.0.1";
+ } else {
+ svr = "::1";
+ }
  /* config 0 addr (everything), means ask localhost */
  if(strcmp(svr, "0.0.0.0") == 0)
  svr = "127.0.0.1";
@@ -317,7 +321,7 @@ go_cmd(SSL* ssl, int argc, char* argv[])
 static int
 go(const char* cfgfile, char* svr, int argc, char* argv[])
 {
- nsd_options_t* opt;
+ struct nsd_options* opt;
  int fd, ret;
  SSL_CTX* ctx;
  SSL* ssl;
diff --git nsd-mem.c nsd-mem.c
index 105b88dad14..9383f84861a 100644
--- nsd-mem.c
+++ nsd-mem.c
@@ -139,7 +139,7 @@ print_zone_mem(struct zone_mem* z)
 }
 
 static void
-account_total(nsd_options_t* opt, struct tot_mem* t)
+account_total(struct nsd_options* opt, struct tot_mem* t)
 {
  t->opt_data = region_get_mem(opt->region);
  t->opt_unused = region_get_mem_unused(opt->region);
@@ -192,8 +192,8 @@ add_mem(struct tot_mem* t, struct zone_mem* z)
 }
 
 static void
-check_zone_mem(const char* tf, const char* df, zone_options_t* zo,
- nsd_options_t* opt, struct tot_mem* totmem)
+check_zone_mem(const char* tf, const char* df, struct zone_options* zo,
+ struct nsd_options* opt, struct tot_mem* totmem)
 {
  struct nsd nsd;
  struct namedb* db;
@@ -234,10 +234,10 @@ check_zone_mem(const char* tf, const char* df, zone_options_t* zo,
 }
 
 static void
-check_mem(nsd_options_t* opt)
+check_mem(struct nsd_options* opt)
 {
  struct tot_mem totmem;
- zone_options_t* zo;
+ struct zone_options* zo;
  char tf[512];
  char df[512];
  memset(&totmem, 0, sizeof(totmem));
@@ -247,7 +247,7 @@ check_mem(nsd_options_t* opt)
  else snprintf(df, sizeof(df), "./nsd-mem-db-%u.db", (unsigned)getpid());
 
  /* read all zones and account memory */
- RBTREE_FOR(zo, zone_options_t*, opt->zone_options) {
+ RBTREE_FOR(zo, struct zone_options*, opt->zone_options) {
  check_zone_mem(tf, df, zo, opt, &totmem);
  }
 
diff --git nsd.c nsd.c
index f9643862a44..f2cf6ccf0cb 100644
--- nsd.c
+++ nsd.c
@@ -49,7 +49,7 @@
 /* The server handler... */
 struct nsd nsd;
 static char hostname[MAXHOSTNAMELEN];
-extern config_parser_state_t* cfg_parser;
+extern config_parser_state_type* cfg_parser;
 
 static void error(const char *format, ...) ATTR_FORMAT(printf, 1, 2);
 
@@ -630,7 +630,7 @@ main(int argc, char *argv[])
 #endif /* INET6 */
  if(nsd.options->ip_addresses)
  {
- ip_address_option_t* ip = nsd.options->ip_addresses;
+ ip_address_option_type* ip = nsd.options->ip_addresses;
  while(ip) {
  add_interface(&nodes, &nsd, ip->address);
  ip = ip->next;
diff --git nsd.h nsd.h
index 290b06552b3..0090100d00b 100644
--- nsd.h
+++ nsd.h
@@ -73,7 +73,7 @@ struct daemon_remote;
 
 #ifdef BIND8_STATS
 /* Counter for statistics */
-typedef unsigned long stc_t;
+typedef unsigned long stc_type;
 
 #define LASTELEM(arr) (sizeof(arr) / sizeof(arr[0]) - 1)
 
@@ -146,7 +146,7 @@ struct nsd_child
  struct netio_handler* handler;
 
 #ifdef BIND8_STATS
- stc_t query_count;
+ stc_type query_count;
 #endif
 };
 
@@ -233,14 +233,14 @@ struct nsd
  struct nsdst {
  time_t boot;
  int period; /* Produce statistics dump every st_period seconds */
- stc_t qtype[257]; /* Counters per qtype */
- stc_t qclass[4]; /* Class IN or Class CH or other */
- stc_t qudp, qudp6; /* Number of queries udp and udp6 */
- stc_t ctcp, ctcp6; /* Number of tcp and tcp6 connections */
- stc_t rcode[17], opcode[6]; /* Rcodes & opcodes */
+ stc_type qtype[257]; /* Counters per qtype */
+ stc_type qclass[4]; /* Class IN or Class CH or other */
+ stc_type qudp, qudp6; /* Number of queries udp and udp6 */
+ stc_type ctcp, ctcp6; /* Number of tcp and tcp6 connections */
+ stc_type rcode[17], opcode[6]; /* Rcodes & opcodes */
  /* Dropped, truncated, queries for nonconfigured zone, tx errors */
- stc_t dropped, truncated, wrongzone, txerr, rxerr;
- stc_t edns, ednserr, raxfr, nona;
+ stc_type dropped, truncated, wrongzone, txerr, rxerr;
+ stc_type edns, ednserr, raxfr, nona;
  uint64_t db_disk, db_mem;
  } st;
  /* per zone stats, each an array per zone-stat-idx, stats per zone is
diff --git nsec3.c nsec3.c
index 777b9f941e4..960e7216dad 100644
--- nsec3.c
+++ nsec3.c
@@ -346,7 +346,7 @@ nsec3_chain_find_prev(struct zone* zone, struct domain* domain)
 {
  if(domain->nsec3 && domain->nsec3->nsec3_node.key) {
  /* see if there is a prev */
- rbnode_t* r = rbtree_previous(&domain->nsec3->nsec3_node);
+ rbnode_type* r = rbtree_previous(&domain->nsec3->nsec3_node);
  if(r != RBTREE_NULL) {
  /* found a previous, which is not the root-node in
  * the prehash tree (and thus points to the tree) */
@@ -464,7 +464,7 @@ int
 nsec3_find_cover(zone_type* zone, uint8_t* hash, size_t hashlen,
  domain_type** result)
 {
- rbnode_t* r = NULL;
+ rbnode_type* r = NULL;
  int exact;
  domain_type d;
  uint8_t n[48];
@@ -656,7 +656,7 @@ init_lookup_key_ds_tree(domain_type* d, uint8_t* hash)
 
 /* find first in the tree and true if the first to process it */
 static int
-process_first(rbtree_t* tree, uint8_t* hash, rbnode_t** p,
+process_first(rbtree_type* tree, uint8_t* hash, rbnode_type** p,
  void (*init)(domain_type*, uint8_t*))
 {
  domain_type d;
@@ -682,7 +682,7 @@ process_first(rbtree_t* tree, uint8_t* hash, rbnode_t** p,
 
 /* set end pointer if possible */
 static void
-process_end(rbtree_t* tree, uint8_t* hash, rbnode_t** p,
+process_end(rbtree_type* tree, uint8_t* hash, rbnode_type** p,
  void (*init)(domain_type*, uint8_t*))
 {
  domain_type d;
@@ -716,8 +716,8 @@ process_range(zone_type* zone, domain_type* start,
 {
  /* start NULL means from first in tree */
  /* end NULL means to last in tree */
- rbnode_t *p = RBTREE_NULL, *pwc = RBTREE_NULL, *pds = RBTREE_NULL;
- rbnode_t *p_end = RBTREE_NULL, *pwc_end = RBTREE_NULL, *pds_end = RBTREE_NULL;
+ rbnode_type *p = RBTREE_NULL, *pwc = RBTREE_NULL, *pds = RBTREE_NULL;
+ rbnode_type *p_end = RBTREE_NULL, *pwc_end = RBTREE_NULL, *pds_end = RBTREE_NULL;
  /* because the nodes are on the prehashlist, the domain->nsec3 is
  * already allocated, and we need not allocate it here */
  /* set start */
@@ -783,7 +783,7 @@ process_prehash_domain(domain_type* domain, zone_type* zone)
  * and set precompile pointers to point to this domain (or is_exact),
  * the first domain can be is_exact. If it is the last NSEC3, also
  * process the initial part (before the first) */
- rbnode_t* nx;
+ rbnode_type* nx;
 
  /* this domain is part of the prehash list and therefore the
  * domain->nsec3 is allocated and need not be allocated here */
@@ -855,8 +855,8 @@ nsec3_add_nonexist_proof(struct query* query, struct answer* answer,
  {
  /* exact match, hash collision */
  /* the hashed name of the query corresponds to an existing name. */
- log_msg(LOG_ERR, "nsec3 hash collision for name=%s",
- dname_to_string(to_prove, NULL));
+ VERBOSITY(3, (LOG_ERR, "nsec3 hash collision for name=%s",
+ dname_to_string(to_prove, NULL)));
  RCODE_SET(query->packet, RCODE_SERVFAIL);
  return;
  }
diff --git options.c options.c
index 8c1e58a3b90..883f154ed24 100644
--- options.c
+++ options.c
@@ -18,7 +18,7 @@
 
 #include "configyyrename.h"
 #include "configparser.h"
-config_parser_state_t* cfg_parser = 0;
+config_parser_state_type* cfg_parser = 0;
 extern FILE* c_in, *c_out;
 int c_parse(void);
 int c_lex(void);
@@ -35,11 +35,12 @@ rbtree_strcmp(const void* p1, const void* p2)
  return strcmp((const char*)p1, (const char*)p2);
 }
 
-nsd_options_t*
+struct nsd_options*
 nsd_options_create(region_type* region)
 {
- nsd_options_t* opt;
- opt = (nsd_options_t*)region_alloc(region, sizeof(nsd_options_t));
+ struct nsd_options* opt;
+ opt = (struct nsd_options*)region_alloc(region, sizeof(
+ struct nsd_options));
  opt->region = region;
  opt->zone_options = rbtree_create(region,
  (int (*)(const void *, const void *)) dname_compare);
@@ -110,40 +111,41 @@ nsd_options_create(region_type* region)
 }
 
 int
-nsd_options_insert_zone(nsd_options_t* opt, zone_options_t* zone)
+nsd_options_insert_zone(struct nsd_options* opt, struct zone_options* zone)
 {
  /* create dname for lookup */
  const dname_type* dname = dname_parse(opt->region, zone->name);
  if(!dname)
  return 0;
  zone->node.key = dname;
- if(!rbtree_insert(opt->zone_options, (rbnode_t*)zone))
+ if(!rbtree_insert(opt->zone_options, (rbnode_type*)zone))
  return 0;
  return 1;
 }
 
 int
-nsd_options_insert_pattern(nsd_options_t* opt, pattern_options_t* pat)
+nsd_options_insert_pattern(struct nsd_options* opt,
+ struct pattern_options* pat)
 {
  if(!pat->pname)
  return 0;
  pat->node.key = pat->pname;
- if(!rbtree_insert(opt->patterns, (rbnode_t*)pat))
+ if(!rbtree_insert(opt->patterns, (rbnode_type*)pat))
  return 0;
  return 1;
 }
 
 int
-parse_options_file(nsd_options_t* opt, const char* file,
+parse_options_file(struct nsd_options* opt, const char* file,
  void (*err)(void*,const char*), void* err_arg)
 {
  FILE *in = 0;
- pattern_options_t* pat;
- acl_options_t* acl;
+ struct pattern_options* pat;
+ struct acl_options* acl;
 
  if(!cfg_parser) {
- cfg_parser = (config_parser_state_t*)region_alloc(
- opt->region, sizeof(config_parser_state_t));
+ cfg_parser = (config_parser_state_type*)region_alloc(
+ opt->region, sizeof(config_parser_state_type));
  cfg_parser->chroot = 0;
  }
  cfg_parser->err = err;
@@ -212,7 +214,7 @@ parse_options_file(nsd_options_t* opt, const char* file,
  c_error("last key has no secret blob");
  key_options_insert(opt, cfg_parser->current_key);
  }
- RBTREE_FOR(pat, pattern_options_t*, opt->patterns)
+ RBTREE_FOR(pat, struct pattern_options*, opt->patterns)
  {
  /* lookup keys for acls */
  for(acl=pat->allow_notify; acl; acl=acl->next)
@@ -271,9 +273,9 @@ parse_options_file(nsd_options_t* opt, const char* file,
  return 1;
 }
 
-void options_zonestatnames_create(nsd_options_t* opt)
+void options_zonestatnames_create(struct nsd_options* opt)
 {
- zone_options_t* zopt;
+ struct zone_options* zopt;
  /* allocate "" as zonestat 0, for zones without a zonestat */
  if(!rbtree_search(opt->zonestatnames, "")) {
  struct zonestatname* n;
@@ -285,9 +287,9 @@ void options_zonestatnames_create(nsd_options_t* opt)
  exit(1);
  }
  n->id = (unsigned)(opt->zonestatnames->count);
- rbtree_insert(opt->zonestatnames, (rbnode_t*)n);
+ rbtree_insert(opt->zonestatnames, (rbnode_type*)n);
  }
- RBTREE_FOR(zopt, zone_options_t*, opt->zone_options) {
+ RBTREE_FOR(zopt, struct zone_options*, opt->zone_options) {
  /* insert into tree, so that when read in later id exists */
  (void)getzonestatid(opt, zopt);
  }
@@ -304,7 +306,7 @@ comp_zonebucket(const void* a, const void* b)
 
 /* insert free entry into zonelist free buckets */
 static void
-zone_list_free_insert(nsd_options_t* opt, int linesize, off_t off)
+zone_list_free_insert(struct nsd_options* opt, int linesize, off_t off)
 {
  struct zonelist_free* e;
  struct zonelist_bucket* b = (struct zonelist_bucket*)rbtree_search(
@@ -323,12 +325,12 @@ zone_list_free_insert(nsd_options_t* opt, int linesize, off_t off)
  opt->zonefree_number++;
 }
 
-zone_options_t*
-zone_list_zone_insert(nsd_options_t* opt, const char* nm, const char* patnm,
- int linesize, off_t off)
+struct zone_options*
+zone_list_zone_insert(struct nsd_options* opt, const char* nm,
+ const char* patnm, int linesize, off_t off)
 {
- pattern_options_t* pat = pattern_options_find(opt, patnm);
- zone_options_t* zone;
+ struct pattern_options* pat = pattern_options_find(opt, patnm);
+ struct zone_options* zone;
  if(!pat) {
  log_msg(LOG_ERR, "pattern does not exist for zone %s "
  "pattern %s", nm, patnm);
@@ -351,7 +353,7 @@ zone_list_zone_insert(nsd_options_t* opt, const char* nm, const char* patnm,
 }
 
 int
-parse_zone_list_file(nsd_options_t* opt)
+parse_zone_list_file(struct nsd_options* opt)
 {
  /* zonelist looks like this:
  # name pattern
@@ -432,7 +434,7 @@ parse_zone_list_file(nsd_options_t* opt)
 }
 
 void
-zone_options_delete(nsd_options_t* opt, zone_options_t* zone)
+zone_options_delete(struct nsd_options* opt, struct zone_options* zone)
 {
  rbtree_delete(opt->zone_options, zone->node.key);
  region_recycle(opt->region, (void*)zone->node.key, dname_total_size(
@@ -441,15 +443,15 @@ zone_options_delete(nsd_options_t* opt, zone_options_t* zone)
 }
 
 /* add a new zone to the zonelist */
-zone_options_t*
-zone_list_add(nsd_options_t* opt, const char* zname, const char* pname)
+struct zone_options*
+zone_list_add(struct nsd_options* opt, const char* zname, const char* pname)
 {
  int r;
  struct zonelist_free* e;
  struct zonelist_bucket* b;
  int linesize = 6 + strlen(zname) + strlen(pname);
  /* create zone entry */
- zone_options_t* zone = zone_list_zone_insert(opt, zname, pname,
+ struct zone_options* zone = zone_list_zone_insert(opt, zname, pname,
  linesize, 0);
  if(!zone)
  return NULL;
@@ -564,7 +566,7 @@ zone_list_add(nsd_options_t* opt, const char* zname, const char* pname)
 
 /* remove a zone on the zonelist */
 void
-zone_list_del(nsd_options_t* opt, zone_options_t* zone)
+zone_list_del(struct nsd_options* opt, struct zone_options* zone)
 {
  /* put its space onto the free entry */
  if(fseeko(opt->zonelist, zone->off, SEEK_SET) == -1) {
@@ -574,7 +576,7 @@ zone_list_del(nsd_options_t* opt, zone_options_t* zone)
  fprintf(opt->zonelist, "del");
  zone_list_free_insert(opt, zone->linesize, zone->off);
 
- /* remove zone_options_t */
+ /* remove zone_options */
  zone_options_delete(opt, zone);
 
  /* see if we need to compact: it is going to halve the zonelist */
@@ -591,7 +593,7 @@ static void
 delbucket(region_type* region, struct zonelist_bucket* b)
 {
  struct zonelist_free* e, *f;
- if(!b || (rbnode_t*)b==RBTREE_NULL)
+ if(!b || (rbnode_type*)b==RBTREE_NULL)
  return;
  delbucket(region, (struct zonelist_bucket*)b->node.left);
  delbucket(region, (struct zonelist_bucket*)b->node.right);
@@ -606,11 +608,11 @@ delbucket(region_type* region, struct zonelist_bucket* b)
 
 /* compact zonelist file */
 void
-zone_list_compact(nsd_options_t* opt)
+zone_list_compact(struct nsd_options* opt)
 {
  char outname[1024];
  FILE* out;
- zone_options_t* zone;
+ struct zone_options* zone;
  off_t off;
  int r;
  snprintf(outname, sizeof(outname), "%s~", opt->zonelistfile);
@@ -639,7 +641,7 @@ zone_list_compact(nsd_options_t* opt)
  fclose(out);
  return;
  }
- RBTREE_FOR(zone, zone_options_t*, opt->zone_options) {
+ RBTREE_FOR(zone, struct zone_options*, opt->zone_options) {
  if(zone->part_of_config)
  continue;
  r = fprintf(out, "add %s %s\n", zone->name,
@@ -669,7 +671,7 @@ zone_list_compact(nsd_options_t* opt)
  }
  fclose(opt->zonelist);
  /* set offsets */
- RBTREE_FOR(zone, zone_options_t*, opt->zone_options) {
+ RBTREE_FOR(zone, struct zone_options*, opt->zone_options) {
  if(zone->part_of_config)
  continue;
  zone->off = off;
@@ -687,7 +689,7 @@ zone_list_compact(nsd_options_t* opt)
 
 /* close zonelist file */
 void
-zone_list_close(nsd_options_t* opt)
+zone_list_close(struct nsd_options* opt)
 {
  fclose(opt->zonelist);
  opt->zonelist = NULL;
@@ -755,11 +757,12 @@ c_wrap()
         return 1;
 }
 
-zone_options_t*
+struct zone_options*
 zone_options_create(region_type* region)
 {
- zone_options_t* zone;
- zone = (zone_options_t*)region_alloc(region, sizeof(zone_options_t));
+ struct zone_options* zone;
+ zone = (struct zone_options*)region_alloc(region, sizeof(
+ struct zone_options));
  zone->node = *RBTREE_NULL;
  zone->name = 0;
  zone->pattern = 0;
@@ -771,7 +774,7 @@ zone_options_create(region_type* region)
 #define booleq(x,y) ( ((x) && (y)) || (!(x) && !(y)) )
 
 int
-acl_equal(acl_options_t* p, acl_options_t* q)
+acl_equal(struct acl_options* p, struct acl_options* q)
 {
  if(!booleq(p->use_axfr_only, q->use_axfr_only)) return 0;
  if(!booleq(p->allow_udp, q->allow_udp)) return 0;
@@ -788,7 +791,7 @@ acl_equal(acl_options_t* p, acl_options_t* q)
 }
 
 int
-acl_list_equal(acl_options_t* p, acl_options_t* q)
+acl_list_equal(struct acl_options* p, struct acl_options* q)
 {
  /* must be same and in same order */
  while(p && q) {
@@ -802,11 +805,12 @@ acl_list_equal(acl_options_t* p, acl_options_t* q)
  return 0;
 }
 
-pattern_options_t*
+struct pattern_options*
 pattern_options_create(region_type* region)
 {
- pattern_options_t* p;
- p = (pattern_options_t*)region_alloc(region, sizeof(pattern_options_t));
+ struct pattern_options* p;
+ p = (struct pattern_options*)region_alloc(region, sizeof(
+ struct pattern_options));
  p->node = *RBTREE_NULL;
  p->pname = 0;
  p->zonefile = 0;
@@ -839,7 +843,7 @@ pattern_options_create(region_type* region)
 }
 
 static void
-acl_delete(region_type* region, acl_options_t* acl)
+acl_delete(region_type* region, struct acl_options* acl)
 {
  if(acl->ip_address_spec)
  region_recycle(region, (void*)acl->ip_address_spec,
@@ -852,9 +856,9 @@ acl_delete(region_type* region, acl_options_t* acl)
 }
 
 static void
-acl_list_delete(region_type* region, acl_options_t* list)
+acl_list_delete(region_type* region, struct acl_options* list)
 {
- acl_options_t* n;
+ struct acl_options* n;
  while(list) {
  n = list->next;
  acl_delete(region, list);
@@ -863,9 +867,9 @@ acl_list_delete(region_type* region, acl_options_t* list)
 }
 
 void
-pattern_options_remove(nsd_options_t* opt, const char* name)
+pattern_options_remove(struct nsd_options* opt, const char* name)
 {
- pattern_options_t* p = (pattern_options_t*)rbtree_delete(
+ struct pattern_options* p = (struct pattern_options*)rbtree_delete(
  opt->patterns, name);
  /* delete p and its contents */
  if (!p)
@@ -885,15 +889,15 @@ pattern_options_remove(nsd_options_t* opt, const char* name)
  acl_list_delete(opt->region, p->provide_xfr);
  acl_list_delete(opt->region, p->outgoing_interface);
 
- region_recycle(opt->region, p, sizeof(pattern_options_t));
+ region_recycle(opt->region, p, sizeof(struct pattern_options));
 }
 
-static acl_options_t*
-copy_acl(region_type* region, acl_options_t* a)
+static struct acl_options*
+copy_acl(region_type* region, struct acl_options* a)
 {
- acl_options_t* b;
+ struct acl_options* b;
  if(!a) return NULL;
- b = (acl_options_t*)region_alloc(region, sizeof(*b));
+ b = (struct acl_options*)region_alloc(region, sizeof(*b));
  /* copy the whole lot */
  *b = *a;
  /* fix the pointers */
@@ -906,10 +910,10 @@ copy_acl(region_type* region, acl_options_t* a)
  return b;
 }
 
-static acl_options_t*
-copy_acl_list(nsd_options_t* opt, acl_options_t* a)
+static struct acl_options*
+copy_acl_list(struct nsd_options* opt, struct acl_options* a)
 {
- acl_options_t* b, *blast = NULL, *blist = NULL;
+ struct acl_options* b, *blast = NULL, *blist = NULL;
  while(a) {
  b = copy_acl(opt->region, a);
  /* fixup key_options */
@@ -929,8 +933,8 @@ copy_acl_list(nsd_options_t* opt, acl_options_t* a)
 }
 
 static void
-copy_changed_acl(nsd_options_t* opt, acl_options_t** orig,
- acl_options_t* anew)
+copy_changed_acl(struct nsd_options* opt, struct acl_options** orig,
+ struct acl_options* anew)
 {
  if(!acl_list_equal(*orig, anew)) {
  acl_list_delete(opt->region, *orig);
@@ -939,8 +943,8 @@ copy_changed_acl(nsd_options_t* opt, acl_options_t** orig,
 }
 
 static void
-copy_pat_fixed(region_type* region, pattern_options_t* orig,
- pattern_options_t* p)
+copy_pat_fixed(region_type* region, struct pattern_options* orig,
+ struct pattern_options* p)
 {
  orig->allow_axfr_fallback = p->allow_axfr_fallback;
  orig->allow_axfr_fallback_is_default =
@@ -969,9 +973,9 @@ copy_pat_fixed(region_type* region, pattern_options_t* orig,
 }
 
 void
-pattern_options_add_modify(nsd_options_t* opt, pattern_options_t* p)
+pattern_options_add_modify(struct nsd_options* opt, struct pattern_options* p)
 {
- pattern_options_t* orig = pattern_options_find(opt, p->pname);
+ struct pattern_options* orig = pattern_options_find(opt, p->pname);
  if(!orig) {
  /* needs to be copied to opt region */
  orig = pattern_options_create(opt->region);
@@ -1003,14 +1007,14 @@ pattern_options_add_modify(nsd_options_t* opt, pattern_options_t* p)
  }
 }
 
-pattern_options_t*
-pattern_options_find(nsd_options_t* opt, const char* name)
+struct pattern_options*
+pattern_options_find(struct nsd_options* opt, const char* name)
 {
- return (pattern_options_t*)rbtree_search(opt->patterns, name);
+ return (struct pattern_options*)rbtree_search(opt->patterns, name);
 }
 
 int
-pattern_options_equal(pattern_options_t* p, pattern_options_t* q)
+pattern_options_equal(struct pattern_options* p, struct pattern_options* q)
 {
  if(strcmp(p->pname, q->pname) != 0) return 0;
  if(!p->zonefile && q->zonefile) return 0;
@@ -1137,7 +1141,7 @@ unmarshal_str(region_type* r, struct buffer* b)
 }
 
 static void
-marshal_acl(struct buffer* b, acl_options_t* acl)
+marshal_acl(struct buffer* b, struct acl_options* acl)
 {
  buffer_reserve(b, sizeof(*acl));
  buffer_write(b, acl, sizeof(*acl));
@@ -1145,10 +1149,11 @@ marshal_acl(struct buffer* b, acl_options_t* acl)
  marshal_str(b, acl->key_name);
 }
 
-static acl_options_t*
+static struct acl_options*
 unmarshal_acl(region_type* r, struct buffer* b)
 {
- acl_options_t* acl = (acl_options_t*)region_alloc(r, sizeof(*acl));
+ struct acl_options* acl = (struct acl_options*)region_alloc(r,
+ sizeof(*acl));
  buffer_read(b, acl, sizeof(*acl));
  acl->next = NULL;
  acl->key_options = NULL;
@@ -1158,7 +1163,7 @@ unmarshal_acl(region_type* r, struct buffer* b)
 }
 
 static void
-marshal_acl_list(struct buffer* b, acl_options_t* list)
+marshal_acl_list(struct buffer* b, struct acl_options* list)
 {
  while(list) {
  marshal_u8(b, 1); /* is there a next one marker */
@@ -1168,10 +1173,10 @@ marshal_acl_list(struct buffer* b, acl_options_t* list)
  marshal_u8(b, 0); /* end of list marker */
 }
 
-static acl_options_t*
+static struct acl_options*
 unmarshal_acl_list(region_type* r, struct buffer* b)
 {
- acl_options_t* a, *last=NULL, *list=NULL;
+ struct acl_options* a, *last=NULL, *list=NULL;
  while(unmarshal_u8(b)) {
  a = unmarshal_acl(r, b);
  /* link in */
@@ -1184,7 +1189,7 @@ unmarshal_acl_list(region_type* r, struct buffer* b)
 }
 
 void
-pattern_options_marshal(struct buffer* b, pattern_options_t* p)
+pattern_options_marshal(struct buffer* b, struct pattern_options* p)
 {
  marshal_str(b, p->pname);
  marshal_str(b, p->zonefile);
@@ -1214,10 +1219,10 @@ pattern_options_marshal(struct buffer* b, pattern_options_t* p)
  marshal_u8(b, p->multi_master_check);
 }
 
-pattern_options_t*
+struct pattern_options*
 pattern_options_unmarshal(region_type* r, struct buffer* b)
 {
- pattern_options_t* p = pattern_options_create(r);
+ struct pattern_options* p = pattern_options_create(r);
  p->pname = unmarshal_str(r, b);
  p->zonefile = unmarshal_str(r, b);
  p->zonestats = unmarshal_str(r, b);
@@ -1247,31 +1252,32 @@ pattern_options_unmarshal(region_type* r, struct buffer* b)
  return p;
 }
 
-key_options_t*
+struct key_options*
 key_options_create(region_type* region)
 {
- key_options_t* key;
- key = (key_options_t*)region_alloc_zero(region, sizeof(key_options_t));
+ struct key_options* key;
+ key = (struct key_options*)region_alloc_zero(region,
+ sizeof(struct key_options));
  return key;
 }
 
 void
-key_options_insert(nsd_options_t* opt, key_options_t* key)
+key_options_insert(struct nsd_options* opt, struct key_options* key)
 {
  if(!key->name) return;
  key->node.key = key->name;
  (void)rbtree_insert(opt->keys, &key->node);
 }
 
-key_options_t*
-key_options_find(nsd_options_t* opt, const char* name)
+struct key_options*
+key_options_find(struct nsd_options* opt, const char* name)
 {
- return (key_options_t*)rbtree_search(opt->keys, name);
+ return (struct key_options*)rbtree_search(opt->keys, name);
 }
 
 /** remove tsig_key contents */
 void
-key_options_desetup(region_type* region, key_options_t* key)
+key_options_desetup(region_type* region, struct key_options* key)
 {
  /* keep tsig_key pointer so that existing references keep valid */
  if(!key->tsig_key)
@@ -1289,7 +1295,7 @@ key_options_desetup(region_type* region, key_options_t* key)
 
 /** add tsig_key contents */
 void
-key_options_setup(region_type* region, key_options_t* key)
+key_options_setup(region_type* region, struct key_options* key)
 {
  uint8_t data[16384]; /* 16KB */
  int size;
@@ -1320,9 +1326,9 @@ key_options_setup(region_type* region, key_options_t* key)
 }
 
 void
-key_options_remove(nsd_options_t* opt, const char* name)
+key_options_remove(struct nsd_options* opt, const char* name)
 {
- key_options_t* k = key_options_find(opt, name);
+ struct key_options* k = key_options_find(opt, name);
  if(!k) return;
  (void)rbtree_delete(opt->keys, name);
  if(k->name)
@@ -1341,20 +1347,20 @@ key_options_remove(nsd_options_t* opt, const char* name)
  key_options_desetup(opt->region, k);
  region_recycle(opt->region, k->tsig_key, sizeof(tsig_key_type));
  }
- region_recycle(opt->region, k, sizeof(key_options_t));
+ region_recycle(opt->region, k, sizeof(struct key_options));
 }
 
 int
-key_options_equal(key_options_t* p, key_options_t* q)
+key_options_equal(struct key_options* p, struct key_options* q)
 {
  return strcmp(p->name, q->name)==0 && strcmp(p->algorithm,
  q->algorithm)==0 && strcmp(p->secret, q->secret)==0;
 }
 
 void
-key_options_add_modify(nsd_options_t* opt, key_options_t* key)
+key_options_add_modify(struct nsd_options* opt, struct key_options* key)
 {
- key_options_t* orig = key_options_find(opt, key->name);
+ struct key_options* orig = key_options_find(opt, key->name);
  if(!orig) {
  /* needs to be copied to opt region */
  orig = key_options_create(opt->region);
@@ -1378,8 +1384,8 @@ key_options_add_modify(nsd_options_t* opt, key_options_t* key)
 }
 
 int
-acl_check_incoming(acl_options_t* acl, struct query* q,
- acl_options_t** reason)
+acl_check_incoming(struct acl_options* acl, struct query* q,
+ struct acl_options** reason)
 {
  /* check each acl element.
    if 1 blocked element matches - return -1.
@@ -1387,7 +1393,7 @@ acl_check_incoming(acl_options_t* acl, struct query* q,
    else return -1. */
  int found_match = -1;
  int number = 0;
- acl_options_t* match = 0;
+ struct acl_options* match = 0;
 
  if(reason)
  *reason = NULL;
@@ -1420,7 +1426,7 @@ acl_check_incoming(acl_options_t* acl, struct query* q,
 
 #ifdef INET6
 int
-acl_addr_matches_ipv6host(acl_options_t* acl, struct sockaddr_storage* addr_storage, unsigned int port)
+acl_addr_matches_ipv6host(struct acl_options* acl, struct sockaddr_storage* addr_storage, unsigned int port)
 {
  struct sockaddr_in6* addr = (struct sockaddr_in6*)addr_storage;
  if(acl->port != 0 && acl->port != port)
@@ -1449,7 +1455,7 @@ acl_addr_matches_ipv6host(acl_options_t* acl, struct sockaddr_storage* addr_stor
 #endif
 
 int
-acl_addr_matches_ipv4host(acl_options_t* acl, struct sockaddr_in* addr, unsigned int port)
+acl_addr_matches_ipv4host(struct acl_options* acl, struct sockaddr_in* addr, unsigned int port)
 {
  if(acl->port != 0 && acl->port != port)
  return 0;
@@ -1476,7 +1482,7 @@ acl_addr_matches_ipv4host(acl_options_t* acl, struct sockaddr_in* addr, unsigned
 }
 
 int
-acl_addr_matches_host(acl_options_t* acl, acl_options_t* host)
+acl_addr_matches_host(struct acl_options* acl, struct acl_options* host)
 {
  if(acl->is_ipv6)
  {
@@ -1499,7 +1505,7 @@ acl_addr_matches_host(acl_options_t* acl, acl_options_t* host)
 }
 
 int
-acl_addr_matches(acl_options_t* acl, struct query* q)
+acl_addr_matches(struct acl_options* acl, struct query* q)
 {
  if(acl->is_ipv6)
  {
@@ -1571,7 +1577,7 @@ acl_addr_match_range(uint32_t* minval, uint32_t* x, uint32_t* maxval, size_t sz)
 }
 
 int
-acl_key_matches(acl_options_t* acl, struct query* q)
+acl_key_matches(struct acl_options* acl, struct query* q)
 {
  if(acl->blocked)
  return 1;
@@ -1610,7 +1616,7 @@ acl_key_matches(acl_options_t* acl, struct query* q)
 }
 
 int
-acl_same_host(acl_options_t* a, acl_options_t* b)
+acl_same_host(struct acl_options* a, struct acl_options* b)
 {
  if(a->is_ipv6 && !b->is_ipv6)
  return 0;
@@ -1646,10 +1652,10 @@ acl_same_host(acl_options_t* a, acl_options_t* b)
 
 #if defined(HAVE_SSL)
 void
-key_options_tsig_add(nsd_options_t* opt)
+key_options_tsig_add(struct nsd_options* opt)
 {
- key_options_t* optkey;
- RBTREE_FOR(optkey, key_options_t*, opt->keys) {
+ struct key_options* optkey;
+ RBTREE_FOR(optkey, struct key_options*, opt->keys) {
  key_options_setup(opt->region, optkey);
  tsig_add_key(optkey->tsig_key);
  }
@@ -1657,7 +1663,7 @@ key_options_tsig_add(nsd_options_t* opt)
 #endif
 
 int
-zone_is_slave(zone_options_t* opt)
+zone_is_slave(struct zone_options* opt)
 {
  return opt && opt->pattern && opt->pattern->request_xfr != 0;
 }
@@ -1675,7 +1681,7 @@ get_char(const char* str, size_t i)
 }
 /* get end label of the zone name (or .) */
 static const char*
-get_end_label(zone_options_t* zone, int i)
+get_end_label(struct zone_options* zone, int i)
 {
  const dname_type* d = (const dname_type*)zone->node.key;
  if(i >= d->label_count) {
@@ -1706,7 +1712,7 @@ replace_str(char* str, size_t len, const char* one, const char* two)
 }
 
 const char*
-config_cook_string(zone_options_t* zone, const char* input)
+config_cook_string(struct zone_options* zone, const char* input)
 {
  static char f[1024];
  /* if not a template, return as-is */
@@ -1732,7 +1738,7 @@ config_cook_string(zone_options_t* zone, const char* input)
 }
 
 const char*
-config_make_zonefile(zone_options_t* zone, struct nsd* nsd)
+config_make_zonefile(struct zone_options* zone, struct nsd* nsd)
 {
  static char f[1024];
  /* if not a template, return as-is */
@@ -1768,14 +1774,14 @@ config_make_zonefile(zone_options_t* zone, struct nsd* nsd)
  return f;
 }
 
-zone_options_t*
-zone_options_find(nsd_options_t* opt, const struct dname* apex)
+struct zone_options*
+zone_options_find(struct nsd_options* opt, const struct dname* apex)
 {
- return (zone_options_t*) rbtree_search(opt->zone_options, apex);
+ return (struct zone_options*) rbtree_search(opt->zone_options, apex);
 }
 
-acl_options_t*
-acl_find_num(acl_options_t* acl, int num)
+struct acl_options*
+acl_find_num(struct acl_options* acl, int num)
 {
  int count = num;
  if(num < 0)
@@ -1851,11 +1857,12 @@ parse_acl_range_subnet(char* p, void* addr, int maxbits)
  }
 }
 
-acl_options_t*
+struct acl_options*
 parse_acl_info(region_type* region, char* ip, const char* key)
 {
  char* p;
- acl_options_t* acl = (acl_options_t*)region_alloc(region, sizeof(acl_options_t));
+ struct acl_options* acl = (struct acl_options*)region_alloc(region,
+ sizeof(struct acl_options));
  acl->next = 0;
  /* ip */
  acl->ip_address_spec = region_strdup(region, ip);
@@ -1917,11 +1924,12 @@ parse_acl_info(region_type* region, char* ip, const char* key)
 
 /* copy acl list at end of parser start, update current */
 static
-void append_acl(acl_options_t** start, acl_options_t** cur,
- acl_options_t* list)
+void append_acl(struct acl_options** start, struct acl_options** cur,
+ struct acl_options* list)
 {
  while(list) {
- acl_options_t* acl = copy_acl(cfg_parser->opt->region, list);
+ struct acl_options* acl = copy_acl(cfg_parser->opt->region,
+ list);
  acl->next = NULL;
  if(*cur)
  (*cur)->next = acl;
@@ -1935,8 +1943,9 @@ void
 config_apply_pattern(const char* name)
 {
  /* find the pattern */
- pattern_options_t* pat = pattern_options_find(cfg_parser->opt, name);
- pattern_options_t* a = cfg_parser->current_pattern;
+ struct pattern_options* pat = pattern_options_find(cfg_parser->opt,
+ name);
+ struct pattern_options* a = cfg_parser->current_pattern;
  if(!pat) {
  c_error_msg("could not find pattern %s", name);
  return;
@@ -1992,17 +2001,17 @@ config_apply_pattern(const char* name)
 }
 
 void
-nsd_options_destroy(nsd_options_t* opt)
+nsd_options_destroy(struct nsd_options* opt)
 {
  region_destroy(opt->region);
 }
 
-unsigned getzonestatid(nsd_options_t* opt, zone_options_t* zopt)
+unsigned getzonestatid(struct nsd_options* opt, struct zone_options* zopt)
 {
 #ifdef USE_ZONE_STATS
  const char* statname;
  struct zonestatname* n;
- rbnode_t* res;
+ rbnode_type* res;
  /* try to find the instantiated zonestat name */
  if(!zopt->pattern->zonestats || zopt->pattern->zonestats[0]==0)
  return 0; /* no zone stats */
@@ -2019,7 +2028,7 @@ unsigned getzonestatid(nsd_options_t* opt, zone_options_t* zopt)
  exit(1);
  }
  n->id = (unsigned)(opt->zonestatnames->count);
- rbtree_insert(opt->zonestatnames, (rbnode_t*)n);
+ rbtree_insert(opt->zonestatnames, (rbnode_type*)n);
  return n->id;
 #else /* USE_ZONE_STATS */
  (void)opt; (void)zopt;
diff --git options.h options.h
index d826c03fd7c..9e1d1efc3e1 100644
--- options.h
+++ options.h
@@ -20,26 +20,26 @@ struct tsig_key;
 struct buffer;
 struct nsd;
 
-typedef struct nsd_options nsd_options_t;
-typedef struct pattern_options pattern_options_t;
-typedef struct zone_options zone_options_t;
-typedef struct ipaddress_option ip_address_option_t;
-typedef struct acl_options acl_options_t;
-typedef struct key_options key_options_t;
-typedef struct config_parser_state config_parser_state_t;
+typedef struct nsd_options nsd_options_type;
+typedef struct pattern_options pattern_options_type;
+typedef struct zone_options zone_options_type;
+typedef struct ip_address_option ip_address_option_type;
+typedef struct acl_options acl_options_type;
+typedef struct key_options key_options_type;
+typedef struct config_parser_state config_parser_state_type;
 /*
  * Options global for nsd.
  */
 struct nsd_options {
  /* config file name */
  char* configfile;
- /* options for zones, by apex, contains zone_options_t */
- rbtree_t* zone_options;
- /* patterns, by name, contains pattern_options_t */
- rbtree_t* patterns;
+ /* options for zones, by apex, contains zone_options */
+ rbtree_type* zone_options;
+ /* patterns, by name, contains pattern_options */
+ rbtree_type* patterns;
 
  /* free space in zonelist file, contains zonelist_bucket */
- rbtree_t* zonefree;
+ rbtree_type* zonefree;
  /* number of free space lines in zonelist file */
  size_t zonefree_number;
  /* zonelist file if open */
@@ -51,13 +51,13 @@ struct nsd_options {
  * zonestatname with malloced key=stringname. The number of items
  * is the max statnameid, no items are freed from this.
  * kept correct in the xfrd process, and on startup. */
- rbtree_t* zonestatnames;
+ rbtree_type* zonestatnames;
 
  /* rbtree of keys defined, by name */
- rbtree_t* keys;
+ rbtree_type* keys;
 
  /* list of ip addresses to bind to (or NULL for all) */
- ip_address_option_t* ip_addresses;
+ struct ip_address_option* ip_addresses;
 
  int ip_transparent;
  int ip_freebind;
@@ -98,7 +98,7 @@ struct nsd_options {
         /** remote control section. enable toggle. */
  int control_enable;
  /** the interfaces the remote control should listen on */
- ip_address_option_t* control_interface;
+ struct ip_address_option* control_interface;
  /** port number for the control port */
  int control_port;
  /** private key file for server */
@@ -127,8 +127,8 @@ struct nsd_options {
  region_type* region;
 };
 
-struct ipaddress_option {
- ip_address_option_t* next;
+struct ip_address_option {
+ struct ip_address_option* next;
  char* address;
 };
 
@@ -136,14 +136,14 @@ struct ipaddress_option {
  * Pattern of zone options, used to contain options for zone(s).
  */
 struct pattern_options {
- rbnode_t node;
+ rbnode_type node;
  const char* pname; /* name of the pattern, key of rbtree */
  const char* zonefile;
- acl_options_t* allow_notify;
- acl_options_t* request_xfr;
- acl_options_t* notify;
- acl_options_t* provide_xfr;
- acl_options_t* outgoing_interface;
+ struct acl_options* allow_notify;
+ struct acl_options* request_xfr;
+ struct acl_options* notify;
+ struct acl_options* provide_xfr;
+ struct acl_options* outgoing_interface;
  const char* zonestats;
 #ifdef RATELIMIT
  uint16_t rrl_whitelist; /* bitmap with rrl types */
@@ -173,7 +173,7 @@ struct pattern_options {
  */
 struct zone_options {
  /* key is dname of apex */
- rbnode_t node;
+ rbnode_type node;
 
  /* is apex of the zone */
  const char* name;
@@ -182,7 +182,7 @@ struct zone_options {
  int linesize;
  /* pattern for the zone options, if zone is part_of_config, this is
  * a anonymous pattern created in-place */
- pattern_options_t* pattern;
+ struct pattern_options* pattern;
  /* zone is fixed into the main config, not in zonelist, cannot delete */
  uint8_t part_of_config;
 };
@@ -200,7 +200,7 @@ union acl_addr_storage {
  * Access control list element
  */
 struct acl_options {
- acl_options_t* next;
+ struct acl_options* next;
 
  /* options */
  time_t ixfr_disabled;
@@ -225,14 +225,14 @@ struct acl_options {
  uint8_t nokey;
  uint8_t blocked;
  const char* key_name;
- key_options_t* key_options;
+ struct key_options* key_options;
 };
 
 /*
  * Key definition
  */
 struct key_options {
- rbnode_t node; /* key of tree is name */
+ rbnode_type node; /* key of tree is name */
  char* name;
  char* algorithm;
  char* secret;
@@ -246,7 +246,7 @@ struct zonelist_free {
 };
 /** zonelist free bucket for a particular line length */
 struct zonelist_bucket {
- rbnode_t node; /* key is ptr to linesize */
+ rbnode_type node; /* key is ptr to linesize */
  int linesize;
  struct zonelist_free* list;
 };
@@ -255,7 +255,7 @@ struct zonelist_bucket {
 #define ZONEFILES_WRITE_INTERVAL 3600
 
 struct zonestatname {
- rbnode_t node; /* key is malloced string with cooked zonestat name */
+ rbnode_type node; /* key is malloced string with cooked zonestat name */
  unsigned id; /* index in nsd.zonestat array */
 };
 
@@ -268,103 +268,107 @@ struct config_parser_state {
  int line;
  int errors;
  int server_settings_seen;
- nsd_options_t* opt;
- pattern_options_t* current_pattern;
- zone_options_t* current_zone;
- key_options_t* current_key;
- ip_address_option_t* current_ip_address_option;
- acl_options_t* current_allow_notify;
- acl_options_t* current_request_xfr;
- acl_options_t* current_notify;
- acl_options_t* current_provide_xfr;
- acl_options_t* current_outgoing_interface;
+ struct nsd_options* opt;
+ struct pattern_options* current_pattern;
+ struct zone_options* current_zone;
+ struct key_options* current_key;
+ struct ip_address_option* current_ip_address_option;
+ struct acl_options* current_allow_notify;
+ struct acl_options* current_request_xfr;
+ struct acl_options* current_notify;
+ struct acl_options* current_provide_xfr;
+ struct acl_options* current_outgoing_interface;
  void (*err)(void*,const char*);
  void* err_arg;
 };
 
-extern config_parser_state_t* cfg_parser;
+extern config_parser_state_type* cfg_parser;
 
 /* region will be put in nsd_options struct. Returns empty options struct. */
-nsd_options_t* nsd_options_create(region_type* region);
+struct nsd_options* nsd_options_create(region_type* region);
 /* the number of zones that are configured */
-static inline size_t nsd_options_num_zones(nsd_options_t* opt)
+static inline size_t nsd_options_num_zones(struct nsd_options* opt)
 { return opt->zone_options->count; }
 /* insert a zone into the main options tree, returns 0 on error */
-int nsd_options_insert_zone(nsd_options_t* opt, zone_options_t* zone);
+int nsd_options_insert_zone(struct nsd_options* opt, struct zone_options* zone);
 /* insert a pattern into the main options tree, returns 0 on error */
-int nsd_options_insert_pattern(nsd_options_t* opt, pattern_options_t* pat);
+int nsd_options_insert_pattern(struct nsd_options* opt,
+ struct pattern_options* pat);
 
 /* parses options file. Returns false on failure. callback, if nonNULL,
  * gets called with error strings, default prints. */
-int parse_options_file(nsd_options_t* opt, const char* file,
+int parse_options_file(struct nsd_options* opt, const char* file,
  void (*err)(void*,const char*), void* err_arg);
-zone_options_t* zone_options_create(region_type* region);
-void zone_options_delete(nsd_options_t* opt, zone_options_t* zone);
+struct zone_options* zone_options_create(region_type* region);
+void zone_options_delete(struct nsd_options* opt, struct zone_options* zone);
 /* find a zone by apex domain name, or NULL if not found. */
-zone_options_t* zone_options_find(nsd_options_t* opt, const struct dname* apex);
-pattern_options_t* pattern_options_create(region_type* region);
-pattern_options_t* pattern_options_find(nsd_options_t* opt, const char* name);
-int pattern_options_equal(pattern_options_t* p, pattern_options_t* q);
-void pattern_options_remove(nsd_options_t* opt, const char* name);
-void pattern_options_add_modify(nsd_options_t* opt, pattern_options_t* p);
-void pattern_options_marshal(struct buffer* buffer, pattern_options_t* p);
-pattern_options_t* pattern_options_unmarshal(region_type* r, struct buffer* b);
-key_options_t* key_options_create(region_type* region);
-void key_options_insert(nsd_options_t* opt, key_options_t* key);
-key_options_t* key_options_find(nsd_options_t* opt, const char* name);
-void key_options_remove(nsd_options_t* opt, const char* name);
-int key_options_equal(key_options_t* p, key_options_t* q);
-void key_options_add_modify(nsd_options_t* opt, key_options_t* key);
+struct zone_options* zone_options_find(struct nsd_options* opt,
+ const struct dname* apex);
+struct pattern_options* pattern_options_create(region_type* region);
+struct pattern_options* pattern_options_find(struct nsd_options* opt, const char* name);
+int pattern_options_equal(struct pattern_options* p, struct pattern_options* q);
+void pattern_options_remove(struct nsd_options* opt, const char* name);
+void pattern_options_add_modify(struct nsd_options* opt,
+ struct pattern_options* p);
+void pattern_options_marshal(struct buffer* buffer, struct pattern_options* p);
+struct pattern_options* pattern_options_unmarshal(region_type* r,
+ struct buffer* b);
+struct key_options* key_options_create(region_type* region);
+void key_options_insert(struct nsd_options* opt, struct key_options* key);
+struct key_options* key_options_find(struct nsd_options* opt, const char* name);
+void key_options_remove(struct nsd_options* opt, const char* name);
+int key_options_equal(struct key_options* p, struct key_options* q);
+void key_options_add_modify(struct nsd_options* opt, struct key_options* key);
 /* read in zone list file. Returns false on failure */
-int parse_zone_list_file(nsd_options_t* opt);
+int parse_zone_list_file(struct nsd_options* opt);
 /* create zone entry and add to the zonelist file */
-zone_options_t* zone_list_add(nsd_options_t* opt, const char* zname,
+struct zone_options* zone_list_add(struct nsd_options* opt, const char* zname,
  const char* pname);
 /* create zonelist entry, do not insert in file (called by _add) */
-zone_options_t* zone_list_zone_insert(nsd_options_t* opt, const char* nm,
- const char* patnm, int linesize, off_t off);
-void zone_list_del(nsd_options_t* opt, zone_options_t* zone);
-void zone_list_compact(nsd_options_t* opt);
-void zone_list_close(nsd_options_t* opt);
+struct zone_options* zone_list_zone_insert(struct nsd_options* opt,
+ const char* nm, const char* patnm, int linesize, off_t off);
+void zone_list_del(struct nsd_options* opt, struct zone_options* zone);
+void zone_list_compact(struct nsd_options* opt);
+void zone_list_close(struct nsd_options* opt);
 
 /* create zonestat name tree , for initially created zones */
-void options_zonestatnames_create(nsd_options_t* opt);
+void options_zonestatnames_create(struct nsd_options* opt);
 /* Get zonestat id for zone options, add new entry if necessary.
  * instantiates the pattern's zonestat string */
-unsigned getzonestatid(nsd_options_t* opt, zone_options_t* zopt);
+unsigned getzonestatid(struct nsd_options* opt, struct zone_options* zopt);
 /* create string, same options as zonefile but no chroot changes */
-const char* config_cook_string(zone_options_t* zone, const char* input);
+const char* config_cook_string(struct zone_options* zone, const char* input);
 
 #if defined(HAVE_SSL)
 /* tsig must be inited, adds all keys in options to tsig. */
-void key_options_tsig_add(nsd_options_t* opt);
+void key_options_tsig_add(struct nsd_options* opt);
 #endif
 
 /* check acl list, acl number that matches if passed(0..),
  * or failure (-1) if dropped */
 /* the reason why (the acl) is returned too (or NULL) */
-int acl_check_incoming(acl_options_t* acl, struct query* q,
- acl_options_t** reason);
-int acl_addr_matches_host(acl_options_t* acl, acl_options_t* host);
-int acl_addr_matches(acl_options_t* acl, struct query* q);
-int acl_key_matches(acl_options_t* acl, struct query* q);
+int acl_check_incoming(struct acl_options* acl, struct query* q,
+ struct acl_options** reason);
+int acl_addr_matches_host(struct acl_options* acl, struct acl_options* host);
+int acl_addr_matches(struct acl_options* acl, struct query* q);
+int acl_key_matches(struct acl_options* acl, struct query* q);
 int acl_addr_match_mask(uint32_t* a, uint32_t* b, uint32_t* mask, size_t sz);
 int acl_addr_match_range(uint32_t* minval, uint32_t* x, uint32_t* maxval, size_t sz);
 
 /* returns true if acls are both from the same host */
-int acl_same_host(acl_options_t* a, acl_options_t* b);
+int acl_same_host(struct acl_options* a, struct acl_options* b);
 /* find acl by number in the list */
-acl_options_t* acl_find_num(acl_options_t* acl, int num);
+struct acl_options* acl_find_num(struct acl_options* acl, int num);
 
 /* see if two acl lists are the same (same elements in same order, or empty) */
-int acl_list_equal(acl_options_t* p, acl_options_t* q);
+int acl_list_equal(struct acl_options* p, struct acl_options* q);
 /* see if two acl are the same */
-int acl_equal(acl_options_t* p, acl_options_t* q);
+int acl_equal(struct acl_options* p, struct acl_options* q);
 
 /* see if a zone is a slave or a master zone */
-int zone_is_slave(zone_options_t* opt);
+int zone_is_slave(struct zone_options* opt);
 /* create zonefile name, returns static pointer (perhaps to options data) */
-const char* config_make_zonefile(zone_options_t* zone, struct nsd* nsd);
+const char* config_make_zonefile(struct zone_options* zone, struct nsd* nsd);
 
 #define ZONEC_PCT_TIME 5 /* seconds, then it starts to print pcts */
 #define ZONEC_PCT_COUNT 100000 /* elements before pct check is done */
@@ -372,7 +376,8 @@ const char* config_make_zonefile(zone_options_t* zone, struct nsd* nsd);
 /* parsing helpers */
 void c_error(const char* msg);
 void c_error_msg(const char* fmt, ...) ATTR_FORMAT(printf, 1, 2);
-acl_options_t* parse_acl_info(region_type* region, char* ip, const char* key);
+struct acl_options* parse_acl_info(region_type* region, char* ip,
+ const char* key);
 /* true if ipv6 address, false if ipv4 */
 int parse_acl_is_ipv6(const char* p);
 /* returns range type. mask is the 2nd part of the range */
@@ -380,7 +385,7 @@ int parse_acl_range_type(char* ip, char** mask);
 /* parses subnet mask, fills 0 mask as well */
 void parse_acl_range_subnet(char* p, void* addr, int maxbits);
 /* clean up options */
-void nsd_options_destroy(nsd_options_t* opt);
+void nsd_options_destroy(struct nsd_options* opt);
 /* replace occurrences of one with two in buf, pass length of buffer */
 void replace_str(char* buf, size_t len, const char* one, const char* two);
 /* apply pattern to the existing pattern in the parser */
diff --git query.c query.c
index fc2d45e9b86..a9317d2c794 100644
--- query.c
+++ query.c
@@ -411,10 +411,10 @@ static query_state_type
 answer_notify(struct nsd* nsd, struct query *query)
 {
  int acl_num, acl_num_xfr;
- acl_options_t *why;
+ struct acl_options *why;
  nsd_rc_type rc;
 
- zone_options_t* zone_opt;
+ struct zone_options* zone_opt;
  DEBUG(DEBUG_XFRD,1, (LOG_INFO, "got notify %s processing acl",
  dname_to_string(query->qname, NULL)));
 
@@ -664,7 +664,7 @@ add_additional_rrsets(struct query *query, answer_type *answer,
  temp->rnode = NULL;
  temp->dname = additional->dname;
 #else
- memcpy(&temp->node, &additional->node, sizeof(rbnode_t));
+ memcpy(&temp->node, &additional->node, sizeof(rbnode_type));
  temp->node.parent = NULL;
 #endif
  temp->number = additional->number;
@@ -1113,7 +1113,7 @@ answer_authoritative(struct nsd   *nsd,
  match->rnode = NULL;
  match->dname = wildcard_child->dname;
 #else
- memcpy(&match->node, &wildcard_child->node, sizeof(rbnode_t));
+ memcpy(&match->node, &wildcard_child->node, sizeof(rbnode_type));
  match->node.parent = NULL;
 #endif
  match->parent = closest_encloser;
diff --git radtree.c radtree.c
index fd003795a4a..c3ac8661a73 100644
--- radtree.c
+++ radtree.c
@@ -137,10 +137,10 @@ radnode_find_prev_from_idx(struct radnode* n, unsigned from)
  * @return false if no prefix found, not even the root "" prefix.
  */
 static int radix_find_prefix_node(struct radtree* rt, uint8_t* k,
- radstrlen_t len, struct radnode** result, radstrlen_t* respos)
+ radstrlen_type len, struct radnode** result, radstrlen_type* respos)
 {
  struct radnode* n = rt->root;
- radstrlen_t pos = 0;
+ radstrlen_type pos = 0;
  uint8_t byte;
  *respos = 0;
  *result = n;
@@ -260,7 +260,7 @@ radnode_array_space(struct region* region, struct radnode* n, uint8_t byte)
 /** create a prefix in the array strs */
 static int
 radsel_str_create(struct region* region, struct radsel* r, uint8_t* k,
- radstrlen_t pos, radstrlen_t len)
+ radstrlen_type pos, radstrlen_type len)
 {
  r->str = (uint8_t*)region_alloc(region, sizeof(uint8_t)*(len-pos));
  if(!r->str)
@@ -272,7 +272,8 @@ radsel_str_create(struct region* region, struct radsel* r, uint8_t* k,
 
 /** see if one byte string p is a prefix of another x (equality is true) */
 static int
-bstr_is_prefix(uint8_t* p, radstrlen_t plen, uint8_t* x, radstrlen_t xlen)
+bstr_is_prefix(uint8_t* p, radstrlen_type plen, uint8_t* x,
+ radstrlen_type xlen)
 {
  /* if plen is zero, it is an (empty) prefix */
  if(plen == 0)
@@ -284,8 +285,8 @@ bstr_is_prefix(uint8_t* p, radstrlen_t plen, uint8_t* x, radstrlen_t xlen)
 }
 
 /** number of bytes in common for the two strings */
-static radstrlen_t
-bstr_common(uint8_t* x, radstrlen_t xlen, uint8_t* y, radstrlen_t ylen)
+static radstrlen_type
+bstr_common(uint8_t* x, radstrlen_type xlen, uint8_t* y, radstrlen_type ylen)
 {
  unsigned i, max = ((xlen<ylen)?xlen:ylen);
  for(i=0; i<max; i++) {
@@ -297,13 +298,15 @@ bstr_common(uint8_t* x, radstrlen_t xlen, uint8_t* y, radstrlen_t ylen)
 
 
 int
-bstr_is_prefix_ext(uint8_t* p, radstrlen_t plen, uint8_t* x, radstrlen_t xlen)
+bstr_is_prefix_ext(uint8_t* p, radstrlen_type plen, uint8_t* x,
+ radstrlen_type xlen)
 {
  return bstr_is_prefix(p, plen, x, xlen);
 }
 
-radstrlen_t
-bstr_common_ext(uint8_t* x, radstrlen_t xlen, uint8_t* y, radstrlen_t ylen)
+radstrlen_type
+bstr_common_ext(uint8_t* x, radstrlen_type xlen, uint8_t* y,
+ radstrlen_type ylen)
 {
  return bstr_common(x, xlen, y, ylen);
 }
@@ -311,9 +314,9 @@ bstr_common_ext(uint8_t* x, radstrlen_t xlen, uint8_t* y, radstrlen_t ylen)
 /** allocate remainder from prefixes for a split:
  * plen: len prefix, l: longer bstring, llen: length of l. */
 static int
-radsel_prefix_remainder(struct region* region, radstrlen_t plen,
- uint8_t* l, radstrlen_t llen,
- uint8_t** s, radstrlen_t* slen)
+radsel_prefix_remainder(struct region* region, radstrlen_type plen,
+ uint8_t* l, radstrlen_type llen,
+ uint8_t** s, radstrlen_type* slen)
 {
  *slen = llen - plen;
  *s = (uint8_t*)region_alloc(region, (*slen)*sizeof(uint8_t));
@@ -334,13 +337,13 @@ radsel_prefix_remainder(struct region* region, radstrlen_t plen,
  */
 static int
 radsel_split(struct region* region, struct radsel* r, uint8_t* k,
- radstrlen_t pos, radstrlen_t len, struct radnode* add)
+ radstrlen_type pos, radstrlen_type len, struct radnode* add)
 {
  uint8_t* addstr = k+pos;
- radstrlen_t addlen = len-pos;
+ radstrlen_type addlen = len-pos;
  if(bstr_is_prefix(addstr, addlen, r->str, r->len)) {
  uint8_t* split_str=NULL, *dupstr=NULL;
- radstrlen_t split_len=0;
+ radstrlen_type split_len=0;
  /* 'add' is a prefix of r.node */
  /* also for empty addstr */
  /* set it up so that the 'add' node has r.node as child */
@@ -384,7 +387,7 @@ radsel_split(struct region* region, struct radsel* r, uint8_t* k,
  r->len = addlen;
  } else if(bstr_is_prefix(r->str, r->len, addstr, addlen)) {
  uint8_t* split_str = NULL;
- radstrlen_t split_len = 0;
+ radstrlen_type split_len = 0;
  /* r.node is a prefix of 'add' */
  /* set it up so that the 'r.node' has 'add' as child */
  /* and basically, r.node is already completely fine,
@@ -414,7 +417,7 @@ radsel_split(struct region* region, struct radsel* r, uint8_t* k,
  * key name. */
  struct radnode* com;
  uint8_t* common_str=NULL, *s1_str=NULL, *s2_str=NULL;
- radstrlen_t common_len, s1_len=0, s2_len=0;
+ radstrlen_type common_len, s1_len=0, s2_len=0;
  common_len = bstr_common(r->str, r->len, addstr, addlen);
  assert(common_len < r->len);
  assert(common_len < addlen);
@@ -486,11 +489,11 @@ radsel_split(struct region* region, struct radsel* r, uint8_t* k,
  return 1;
 }
 
-struct radnode* radix_insert(struct radtree* rt, uint8_t* k, radstrlen_t len,
-        void* elem)
+struct radnode* radix_insert(struct radtree* rt, uint8_t* k,
+ radstrlen_type len, void* elem)
 {
  struct radnode* n;
- radstrlen_t pos = 0;
+ radstrlen_type pos = 0;
  /* create new element to add */
  struct radnode* add = (struct radnode*)region_alloc_zero(rt->region,
  sizeof(*add));
@@ -620,7 +623,7 @@ radnode_cleanup_onechild(struct region* region, struct radnode* n,
  struct radnode* par)
 {
  uint8_t* join;
- radstrlen_t joinlen;
+ radstrlen_type joinlen;
  uint8_t pidx = n->pidx;
  struct radnode* child = n->array[0].node;
  /* node had one child, merge them into the parent. */
@@ -813,10 +816,11 @@ void radix_delete(struct radtree* rt, struct radnode* n)
  }
 }
 
-struct radnode* radix_search(struct radtree* rt, uint8_t* k, radstrlen_t len)
+struct radnode* radix_search(struct radtree* rt, uint8_t* k,
+ radstrlen_type len)
 {
  struct radnode* n = rt->root;
- radstrlen_t pos = 0;
+ radstrlen_type pos = 0;
  uint8_t byte;
  while(n) {
  if(pos == len)
@@ -851,11 +855,11 @@ static int ret_self_or_prev(struct radnode* n, struct radnode** result)
  return 0;
 }
 
-int radix_find_less_equal(struct radtree* rt, uint8_t* k, radstrlen_t len,
+int radix_find_less_equal(struct radtree* rt, uint8_t* k, radstrlen_type len,
         struct radnode** result)
 {
  struct radnode* n = rt->root;
- radstrlen_t pos = 0;
+ radstrlen_type pos = 0;
  uint8_t byte;
  int r;
  if(!n) {
@@ -1035,7 +1039,7 @@ static void cpy_r2d(uint8_t* to, uint8_t* from, uint8_t len)
 }
 
 /* radname code: domain to radix-bstring */
-void radname_d2r(uint8_t* k, radstrlen_t* len, const uint8_t* dname,
+void radname_d2r(uint8_t* k, radstrlen_type* len, const uint8_t* dname,
  size_t dlen)
 {
  /* the domain name is converted as follows,
@@ -1107,7 +1111,7 @@ void radname_d2r(uint8_t* k, radstrlen_t* len, const uint8_t* dname,
 }
 
 /* radname code: radix-bstring to domain */
-void radname_r2d(uint8_t* k, radstrlen_t len, uint8_t* dname, size_t* dlen)
+void radname_r2d(uint8_t* k, radstrlen_type len, uint8_t* dname, size_t* dlen)
 {
  /* find labels and push on stack */
  uint8_t* labstart[130];
@@ -1164,7 +1168,7 @@ radname_insert(struct radtree* rt, const uint8_t* d, size_t max, void* elem)
 {
  /* convert and insert */
  uint8_t radname[300];
- radstrlen_t len = (radstrlen_t)sizeof(radname);
+ radstrlen_type len = (radstrlen_type)sizeof(radname);
  if(max > sizeof(radname))
  return NULL; /* too long */
  radname_d2r(radname, &len, d, max);
@@ -1189,7 +1193,7 @@ struct radnode* radname_search(struct radtree* rt, const uint8_t* d,
  unsigned int lab, dpos, lpos;
  struct radnode* n = rt->root;
  uint8_t byte;
- radstrlen_t i;
+ radstrlen_type i;
  uint8_t b;
 
  /* search for root? it is '' */
@@ -1274,7 +1278,7 @@ int radname_find_less_equal(struct radtree* rt, const uint8_t* d, size_t max,
  unsigned int lab, dpos, lpos;
  struct radnode* n = rt->root;
  uint8_t byte;
- radstrlen_t i;
+ radstrlen_type i;
  uint8_t b;
 
  /* empty tree */
diff --git radtree.h radtree.h
index 6f54de01641..fdc58e7a903 100644
--- radtree.h
+++ radtree.h
@@ -10,7 +10,7 @@ struct radnode;
 struct region;
 
 /** length of the binary string */
-typedef uint16_t radstrlen_t;
+typedef uint16_t radstrlen_type;
 
 /**
  * The radix tree
@@ -58,7 +58,7 @@ struct radsel {
  /** additional string after the selection-byte for this edge. */
  uint8_t* str;
  /** length of the additional string for this edge */
- radstrlen_t len;
+ radstrlen_type len;
  /** node that deals with byte+str */
  struct radnode* node;
 };
@@ -99,8 +99,8 @@ void radix_tree_delete(struct radtree* rt);
  * NULL on failure - duplicate entry.
  * On success the new radix node for this element.
  */
-struct radnode* radix_insert(struct radtree* rt, uint8_t* k, radstrlen_t len,
- void* elem);
+struct radnode* radix_insert(struct radtree* rt, uint8_t* k,
+ radstrlen_type len, void* elem);
 
 /**
  * Delete element from radix tree.
@@ -117,7 +117,8 @@ void radix_delete(struct radtree* rt, struct radnode* n);
  * @param len: length of key.
  * @return the radix node or NULL if not found.
  */
-struct radnode* radix_search(struct radtree* rt, uint8_t* k, radstrlen_t len);
+struct radnode* radix_search(struct radtree* rt, uint8_t* k,
+ radstrlen_type len);
 
 /**
  * Find radix element in tree, and if not found, find the closest smaller or
@@ -129,7 +130,7 @@ struct radnode* radix_search(struct radtree* rt, uint8_t* k, radstrlen_t len);
  * smaller than the smallest key in the tree).
  * @return true if exact match, false if no match.
  */
-int radix_find_less_equal(struct radtree* rt, uint8_t* k, radstrlen_t len,
+int radix_find_less_equal(struct radtree* rt, uint8_t* k, radstrlen_type len,
  struct radnode** result);
 
 /**
@@ -174,7 +175,7 @@ struct radnode* radix_prev(struct radnode* n);
  * @param dname: the domain name to convert, in wireformat.
  * @param dlen: length of space for dname.
  */
-void radname_d2r(uint8_t* k, radstrlen_t* len, const uint8_t* dname,
+void radname_d2r(uint8_t* k, radstrlen_type* len, const uint8_t* dname,
  size_t dlen);
 
 /**
@@ -184,7 +185,7 @@ void radname_d2r(uint8_t* k, radstrlen_t* len, const uint8_t* dname,
  * @param dname: buffer to store domain name into.
  * @param dlen: length of dname (including root label).
  */
-void radname_r2d(uint8_t* k, radstrlen_t len, uint8_t* dname, size_t* dlen);
+void radname_r2d(uint8_t* k, radstrlen_type len, uint8_t* dname, size_t* dlen);
 
 /**
  * Search the radix tree using a domain name.
@@ -235,10 +236,10 @@ struct radnode* radname_insert(struct radtree* rt, const uint8_t* d,
 void radname_delete(struct radtree* rt, const uint8_t* d, size_t max);
 
 /** number of bytes in common in strings */
-radstrlen_t bstr_common_ext(uint8_t* x, radstrlen_t xlen, uint8_t* y,
- radstrlen_t ylen);
+radstrlen_type bstr_common_ext(uint8_t* x, radstrlen_type xlen, uint8_t* y,
+ radstrlen_type ylen);
 /** true if one is prefix of the other */
-int bstr_is_prefix_ext(uint8_t* p, radstrlen_t plen, uint8_t* x,
- radstrlen_t xlen);
+int bstr_is_prefix_ext(uint8_t* p, radstrlen_type plen, uint8_t* x,
+ radstrlen_type xlen);
 
 #endif /* RADTREE_H */
diff --git rbtree.c rbtree.c
index bc3840e2d6b..5d8cd4cd57a 100644
--- rbtree.c
+++ rbtree.c
@@ -17,7 +17,7 @@
 #define BLACK 0
 #define RED 1
 
-rbnode_t rbtree_null_node = {
+rbnode_type rbtree_null_node = {
  RBTREE_NULL, /* Parent.  */
  RBTREE_NULL, /* Left.  */
  RBTREE_NULL, /* Right.  */
@@ -25,10 +25,10 @@ rbnode_t rbtree_null_node = {
  BLACK /* Color.  */
 };
 
-static void rbtree_rotate_left(rbtree_t *rbtree, rbnode_t *node);
-static void rbtree_rotate_right(rbtree_t *rbtree, rbnode_t *node);
-static void rbtree_insert_fixup(rbtree_t *rbtree, rbnode_t *node);
-static void rbtree_delete_fixup(rbtree_t* rbtree, rbnode_t* child, rbnode_t* child_parent);
+static void rbtree_rotate_left(rbtree_type *rbtree, rbnode_type *node);
+static void rbtree_rotate_right(rbtree_type *rbtree, rbnode_type *node);
+static void rbtree_insert_fixup(rbtree_type *rbtree, rbnode_type *node);
+static void rbtree_delete_fixup(rbtree_type* rbtree, rbnode_type* child, rbnode_type* child_parent);
 
 /*
  * Creates a new red black tree, initializes and returns a pointer to it.
@@ -36,13 +36,13 @@ static void rbtree_delete_fixup(rbtree_t* rbtree, rbnode_t* child, rbnode_t* chi
  * Return NULL on failure.
  *
  */
-rbtree_t *
+rbtree_type *
 rbtree_create (region_type *region, int (*cmpf)(const void *, const void *))
 {
- rbtree_t *rbtree;
+ rbtree_type *rbtree;
 
  /* Allocate memory for it */
- rbtree = (rbtree_t *) region_alloc(region, sizeof(rbtree_t));
+ rbtree = (rbtree_type *) region_alloc(region, sizeof(rbtree_type));
  if (!rbtree) {
  return NULL;
  }
@@ -61,9 +61,9 @@ rbtree_create (region_type *region, int (*cmpf)(const void *, const void *))
  *
  */
 static void
-rbtree_rotate_left(rbtree_t *rbtree, rbnode_t *node)
+rbtree_rotate_left(rbtree_type *rbtree, rbnode_type *node)
 {
- rbnode_t *right = node->right;
+ rbnode_type *right = node->right;
  node->right = right->left;
  if (right->left != RBTREE_NULL)
  right->left->parent = node;
@@ -88,9 +88,9 @@ rbtree_rotate_left(rbtree_t *rbtree, rbnode_t *node)
  *
  */
 static void
-rbtree_rotate_right(rbtree_t *rbtree, rbnode_t *node)
+rbtree_rotate_right(rbtree_type *rbtree, rbnode_type *node)
 {
- rbnode_t *left = node->left;
+ rbnode_type *left = node->left;
  node->left = left->right;
  if (left->right != RBTREE_NULL)
  left->right->parent = node;
@@ -111,9 +111,9 @@ rbtree_rotate_right(rbtree_t *rbtree, rbnode_t *node)
 }
 
 static void
-rbtree_insert_fixup(rbtree_t *rbtree, rbnode_t *node)
+rbtree_insert_fixup(rbtree_type *rbtree, rbnode_type *node)
 {
- rbnode_t *uncle;
+ rbnode_type *uncle;
 
  /* While not at the root and need fixing... */
  while (node != rbtree->root && node->parent->color == RED) {
@@ -180,15 +180,15 @@ rbtree_insert_fixup(rbtree_t *rbtree, rbnode_t *node)
  * Returns NULL on failure or the pointer to the newly added node
  * otherwise.
  */
-rbnode_t *
-rbtree_insert (rbtree_t *rbtree, rbnode_t *data)
+rbnode_type *
+rbtree_insert (rbtree_type *rbtree, rbnode_type *data)
 {
  /* XXX Not necessary, but keeps compiler quiet... */
  int r = 0;
 
  /* We start at the root of the tree */
- rbnode_t *node = rbtree->root;
- rbnode_t *parent = RBTREE_NULL;
+ rbnode_type *node = rbtree->root;
+ rbnode_type *parent = RBTREE_NULL;
 
  /* Lets find the new parent... */
  while (node != RBTREE_NULL) {
@@ -232,10 +232,10 @@ rbtree_insert (rbtree_t *rbtree, rbnode_t *data)
  * Searches the red black tree, returns the data if key is found or NULL otherwise.
  *
  */
-rbnode_t *
-rbtree_search (rbtree_t *rbtree, const void *key)
+rbnode_type *
+rbtree_search (rbtree_type *rbtree, const void *key)
 {
- rbnode_t *node;
+ rbnode_type *node;
 
  if (rbtree_find_less_equal(rbtree, key, &node)) {
  return node;
@@ -250,12 +250,12 @@ static void swap_int8(uint8_t* x, uint8_t* y)
  uint8_t t = *x; *x = *y; *y = t;
 }
 
-static void swap_np(rbnode_t** x, rbnode_t** y)
+static void swap_np(rbnode_type** x, rbnode_type** y)
 {
- rbnode_t* t = *x; *x = *y; *y = t;
+ rbnode_type* t = *x; *x = *y; *y = t;
 }
 
-static void change_parent_ptr(rbtree_t* rbtree, rbnode_t* parent, rbnode_t* old, rbnode_t* new)
+static void change_parent_ptr(rbtree_type* rbtree, rbnode_type* parent, rbnode_type* old, rbnode_type* new)
 {
  if(parent == RBTREE_NULL)
  {
@@ -268,18 +268,18 @@ static void change_parent_ptr(rbtree_t* rbtree, rbnode_t* parent, rbnode_t* old,
  if(parent->left == old) parent->left = new;
  if(parent->right == old) parent->right = new;
 }
-static void change_child_ptr(rbnode_t* child, rbnode_t* old, rbnode_t* new)
+static void change_child_ptr(rbnode_type* child, rbnode_type* old, rbnode_type* new)
 {
  if(child == RBTREE_NULL) return;
  assert(child->parent == old || child->parent == new);
  if(child->parent == old) child->parent = new;
 }
 
-rbnode_t*
-rbtree_delete(rbtree_t *rbtree, const void *key)
+rbnode_type*
+rbtree_delete(rbtree_type *rbtree, const void *key)
 {
- rbnode_t *to_delete;
- rbnode_t *child;
+ rbnode_type *to_delete;
+ rbnode_type *child;
  if((to_delete = rbtree_search(rbtree, key)) == 0) return 0;
  rbtree->count--;
 
@@ -287,11 +287,11 @@ rbtree_delete(rbtree_t *rbtree, const void *key)
  if(to_delete->left != RBTREE_NULL && to_delete->right != RBTREE_NULL)
  {
  /* swap with smallest from right subtree (or largest from left) */
- rbnode_t *smright = to_delete->right;
+ rbnode_type *smright = to_delete->right;
  while(smright->left != RBTREE_NULL)
  smright = smright->left;
  /* swap the smright and to_delete elements in the tree,
- * but the rbnode_t is first part of user data struct
+ * but the rbnode_type is first part of user data struct
  * so cannot just swap the keys and data pointers. Instead
  * readjust the pointers left,right,parent */
 
@@ -353,9 +353,9 @@ rbtree_delete(rbtree_t *rbtree, const void *key)
  return to_delete;
 }
 
-static void rbtree_delete_fixup(rbtree_t* rbtree, rbnode_t* child, rbnode_t* child_parent)
+static void rbtree_delete_fixup(rbtree_type* rbtree, rbnode_type* child, rbnode_type* child_parent)
 {
- rbnode_t* sibling;
+ rbnode_type* sibling;
  int go_up = 1;
 
  /* determine sibling to the node that is one-black short */
@@ -457,10 +457,10 @@ static void rbtree_delete_fixup(rbtree_t* rbtree, rbnode_t* child, rbnode_t* chi
 }
 
 int
-rbtree_find_less_equal(rbtree_t *rbtree, const void *key, rbnode_t **result)
+rbtree_find_less_equal(rbtree_type *rbtree, const void *key, rbnode_type **result)
 {
  int r;
- rbnode_t *node;
+ rbnode_type *node;
 
  assert(result);
 
@@ -492,19 +492,19 @@ rbtree_find_less_equal(rbtree_t *rbtree, const void *key, rbnode_t **result)
  * Finds the first element in the red black tree
  *
  */
-rbnode_t *
-rbtree_first (rbtree_t *rbtree)
+rbnode_type *
+rbtree_first (rbtree_type *rbtree)
 {
- rbnode_t *node;
+ rbnode_type *node;
 
  for (node = rbtree->root; node->left != RBTREE_NULL; node = node->left);
  return node;
 }
 
-rbnode_t *
-rbtree_last (rbtree_t *rbtree)
+rbnode_type *
+rbtree_last (rbtree_type *rbtree)
 {
- rbnode_t *node;
+ rbnode_type *node;
 
  for (node = rbtree->root; node->right != RBTREE_NULL; node = node->right);
  return node;
@@ -514,10 +514,10 @@ rbtree_last (rbtree_t *rbtree)
  * Returns the next node...
  *
  */
-rbnode_t *
-rbtree_next (rbnode_t *node)
+rbnode_type *
+rbtree_next (rbnode_type *node)
 {
- rbnode_t *parent;
+ rbnode_type *parent;
 
  if (node->right != RBTREE_NULL) {
  /* One right, then keep on going left... */
@@ -533,10 +533,10 @@ rbtree_next (rbnode_t *node)
  return node;
 }
 
-rbnode_t *
-rbtree_previous(rbnode_t *node)
+rbnode_type *
+rbtree_previous(rbnode_type *node)
 {
- rbnode_t *parent;
+ rbnode_type *parent;
 
  if (node->left != RBTREE_NULL) {
  /* One left, then keep on going right... */
diff --git rbtree.h rbtree.h
index a381cf0788f..d6e54862a23 100644
--- rbtree.h
+++ rbtree.h
@@ -14,63 +14,63 @@
 
 /*
  * This structure must be the first member of the data structure in
- * the rbtree.  This allows easy casting between an rbnode_t and the
+ * the rbtree.  This allows easy casting between an rbnode_type and the
  * user data (poor man's inheritance).
  */
-typedef struct rbnode_t rbnode_t;
-struct rbnode_t {
- rbnode_t   *parent;
- rbnode_t   *left;
- rbnode_t   *right;
- const void *key;
- uint8_t    color;
+typedef struct rbnode rbnode_type;
+struct rbnode {
+ rbnode_type  *parent;
+ rbnode_type  *left;
+ rbnode_type  *right;
+ const void   *key;
+ uint8_t      color;
 };
 
 #define RBTREE_NULL &rbtree_null_node
-extern rbnode_t rbtree_null_node;
+extern rbnode_type rbtree_null_node;
 
-typedef struct rbtree_t rbtree_t;
-struct rbtree_t {
+typedef struct rbtree rbtree_type;
+struct rbtree {
  region_type *region;
 
  /* The root of the red-black tree */
- rbnode_t    *root;
+ rbnode_type *root;
 
  /* The number of the nodes in the tree */
  size_t       count;
 
  /* Current node for walks... */
- rbnode_t    *_node;
+ rbnode_type *_node;
 
  /* Key compare function. <0,0,>0 like strcmp. Return 0 on two NULL ptrs. */
  int (*cmp) (const void *, const void *);
 };
 
 /* rbtree.c */
-rbtree_t *rbtree_create(region_type *region, int (*cmpf)(const void *, const void *));
-rbnode_t *rbtree_insert(rbtree_t *rbtree, rbnode_t *data);
+rbtree_type *rbtree_create(region_type *region, int (*cmpf)(const void *, const void *));
+rbnode_type *rbtree_insert(rbtree_type *rbtree, rbnode_type *data);
 /* returns node that is now unlinked from the tree. User to delete it.
  * returns 0 if node not present */
-rbnode_t *rbtree_delete(rbtree_t *rbtree, const void *key);
-rbnode_t *rbtree_search(rbtree_t *rbtree, const void *key);
+rbnode_type *rbtree_delete(rbtree_type *rbtree, const void *key);
+rbnode_type *rbtree_search(rbtree_type *rbtree, const void *key);
 /* returns true if exact match in result. Else result points to <= element,
    or NULL if key is smaller than the smallest key. */
-int rbtree_find_less_equal(rbtree_t *rbtree, const void *key, rbnode_t **result);
-rbnode_t *rbtree_first(rbtree_t *rbtree);
-rbnode_t *rbtree_last(rbtree_t *rbtree);
-rbnode_t *rbtree_next(rbnode_t *rbtree);
-rbnode_t *rbtree_previous(rbnode_t *rbtree);
+int rbtree_find_less_equal(rbtree_type *rbtree, const void *key, rbnode_type **result);
+rbnode_type *rbtree_first(rbtree_type *rbtree);
+rbnode_type *rbtree_last(rbtree_type *rbtree);
+rbnode_type *rbtree_next(rbnode_type *rbtree);
+rbnode_type *rbtree_previous(rbnode_type *rbtree);
 
 #define RBTREE_WALK(rbtree, k, d) \
  for((rbtree)->_node = rbtree_first(rbtree);\
  (rbtree)->_node != RBTREE_NULL && ((k) = (rbtree)->_node->key) && \
  ((d) = (void *) (rbtree)->_node); (rbtree)->_node = rbtree_next((rbtree)->_node))
 
-/* call with node=variable of struct* with rbnode_t as first element.
+/* call with node=variable of struct* with rbnode_type as first element.
    with type is the type of a pointer to that struct. */
 #define RBTREE_FOR(node, type, rbtree) \
  for(node=(type)rbtree_first(rbtree); \
- (rbnode_t*)node != RBTREE_NULL; \
- node = (type)rbtree_next((rbnode_t*)node))
+ (rbnode_type*)node != RBTREE_NULL; \
+ node = (type)rbtree_next((rbnode_type*)node))
 
 #endif /* _RBTREE_H_ */
diff --git remote.c remote.c
index baa9985389a..f7c88222b68 100644
--- remote.c
+++ remote.c
@@ -227,7 +227,7 @@ timeval_subtract(struct timeval* d, const struct timeval* end,
 #endif /* BIND8_STATS */
 
 struct daemon_remote*
-daemon_remote_create(nsd_options_t* cfg)
+daemon_remote_create(struct nsd_options* cfg)
 {
  char* s_cert;
  char* s_key;
@@ -483,11 +483,11 @@ add_open(struct daemon_remote* rc, const char* ip, int nr, int noproto_is_err)
 }
 
 int
-daemon_remote_open_ports(struct daemon_remote* rc, nsd_options_t* cfg)
+daemon_remote_open_ports(struct daemon_remote* rc, struct nsd_options* cfg)
 {
  assert(cfg->control_enable && cfg->control_port);
  if(cfg->control_interface) {
- ip_address_option_t* p;
+ ip_address_option_type* p;
  for(p = cfg->control_interface; p; p = p->next) {
  if(!add_open(rc, p->address, cfg->control_port, 1)) {
  return 0;
@@ -764,8 +764,8 @@ send_ok(SSL* ssl)
 
 /** get zone argument (if any) or NULL, false on error */
 static int
-get_zone_arg(SSL* ssl, xfrd_state_t* xfrd, char* arg,
- zone_options_t** zo)
+get_zone_arg(SSL* ssl, xfrd_state_type* xfrd, char* arg,
+ struct zone_options** zo)
 {
  const dname_type* dname;
  if(!arg[0]) {
@@ -790,7 +790,7 @@ get_zone_arg(SSL* ssl, xfrd_state_t* xfrd, char* arg,
 
 /** do the stop command */
 static void
-do_stop(SSL* ssl, xfrd_state_t* xfrd)
+do_stop(SSL* ssl, xfrd_state_type* xfrd)
 {
  xfrd->need_to_send_shutdown = 1;
 
@@ -803,7 +803,7 @@ do_stop(SSL* ssl, xfrd_state_t* xfrd)
 
 /** do the log_reopen command, it only needs reload_now */
 static void
-do_log_reopen(SSL* ssl, xfrd_state_t* xfrd)
+do_log_reopen(SSL* ssl, xfrd_state_type* xfrd)
 {
  xfrd_set_reload_now(xfrd);
  send_ok(ssl);
@@ -811,9 +811,9 @@ do_log_reopen(SSL* ssl, xfrd_state_t* xfrd)
 
 /** do the reload command */
 static void
-do_reload(SSL* ssl, xfrd_state_t* xfrd, char* arg)
+do_reload(SSL* ssl, xfrd_state_type* xfrd, char* arg)
 {
- zone_options_t* zo;
+ struct zone_options* zo;
  if(!get_zone_arg(ssl, xfrd, arg, &zo))
  return;
  task_new_check_zonefiles(xfrd->nsd->task[xfrd->nsd->mytask],
@@ -824,9 +824,9 @@ do_reload(SSL* ssl, xfrd_state_t* xfrd, char* arg)
 
 /** do the write command */
 static void
-do_write(SSL* ssl, xfrd_state_t* xfrd, char* arg)
+do_write(SSL* ssl, xfrd_state_type* xfrd, char* arg)
 {
- zone_options_t* zo;
+ struct zone_options* zo;
  if(!get_zone_arg(ssl, xfrd, arg, &zo))
  return;
  task_new_write_zonefiles(xfrd->nsd->task[xfrd->nsd->mytask],
@@ -837,13 +837,13 @@ do_write(SSL* ssl, xfrd_state_t* xfrd, char* arg)
 
 /** do the notify command */
 static void
-do_notify(SSL* ssl, xfrd_state_t* xfrd, char* arg)
+do_notify(SSL* ssl, xfrd_state_type* xfrd, char* arg)
 {
- zone_options_t* zo;
+ struct zone_options* zo;
  if(!get_zone_arg(ssl, xfrd, arg, &zo))
  return;
  if(zo) {
- struct notify_zone_t* n = (struct notify_zone_t*)rbtree_search(
+ struct notify_zone* n = (struct notify_zone*)rbtree_search(
  xfrd->notify_zones, (const dname_type*)zo->node.key);
  if(n) {
  xfrd_notify_start(n, xfrd);
@@ -852,8 +852,8 @@ do_notify(SSL* ssl, xfrd_state_t* xfrd, char* arg)
  ssl_printf(ssl, "error zone does not have notify\n");
  }
  } else {
- struct notify_zone_t* n;
- RBTREE_FOR(n, struct notify_zone_t*, xfrd->notify_zones) {
+ struct notify_zone* n;
+ RBTREE_FOR(n, struct notify_zone*, xfrd->notify_zones) {
  xfrd_notify_start(n, xfrd);
  }
  send_ok(ssl);
@@ -862,14 +862,14 @@ do_notify(SSL* ssl, xfrd_state_t* xfrd, char* arg)
 
 /** do the transfer command */
 static void
-do_transfer(SSL* ssl, xfrd_state_t* xfrd, char* arg)
+do_transfer(SSL* ssl, xfrd_state_type* xfrd, char* arg)
 {
- zone_options_t* zo;
- xfrd_zone_t* zone;
+ struct zone_options* zo;
+ xfrd_zone_type* zone;
  if(!get_zone_arg(ssl, xfrd, arg, &zo))
  return;
  if(zo) {
- zone = (xfrd_zone_t*)rbtree_search(xfrd->zones, (const
+ zone = (xfrd_zone_type*)rbtree_search(xfrd->zones, (const
  dname_type*)zo->node.key);
  if(zone) {
  xfrd_handle_notify_and_start_xfr(zone, NULL);
@@ -878,7 +878,7 @@ do_transfer(SSL* ssl, xfrd_state_t* xfrd, char* arg)
  ssl_printf(ssl, "error zone not slave\n");
  }
  } else {
- RBTREE_FOR(zone, xfrd_zone_t*, xfrd->zones) {
+ RBTREE_FOR(zone, xfrd_zone_type*, xfrd->zones) {
  xfrd_handle_notify_and_start_xfr(zone, NULL);
  }
  ssl_printf(ssl, "ok, %u zones\n", (unsigned)xfrd->zones->count);
@@ -887,7 +887,7 @@ do_transfer(SSL* ssl, xfrd_state_t* xfrd, char* arg)
 
 /** force transfer a zone */
 static void
-force_transfer_zone(xfrd_zone_t* zone)
+force_transfer_zone(xfrd_zone_type* zone)
 {
  /* if in TCP transaction, stop it immediately. */
  if(zone->tcp_conn != -1)
@@ -903,14 +903,14 @@ force_transfer_zone(xfrd_zone_t* zone)
 
 /** do the force transfer command */
 static void
-do_force_transfer(SSL* ssl, xfrd_state_t* xfrd, char* arg)
+do_force_transfer(SSL* ssl, xfrd_state_type* xfrd, char* arg)
 {
- zone_options_t* zo;
- xfrd_zone_t* zone;
+ struct zone_options* zo;
+ xfrd_zone_type* zone;
  if(!get_zone_arg(ssl, xfrd, arg, &zo))
  return;
  if(zo) {
- zone = (xfrd_zone_t*)rbtree_search(xfrd->zones, (const
+ zone = (xfrd_zone_type*)rbtree_search(xfrd->zones, (const
  dname_type*)zo->node.key);
  if(zone) {
  force_transfer_zone(zone);
@@ -919,7 +919,7 @@ do_force_transfer(SSL* ssl, xfrd_state_t* xfrd, char* arg)
  ssl_printf(ssl, "error zone not slave\n");
  }
  } else {
- RBTREE_FOR(zone, xfrd_zone_t*, xfrd->zones) {
+ RBTREE_FOR(zone, xfrd_zone_type*, xfrd->zones) {
  force_transfer_zone(zone);
  }
  ssl_printf(ssl, "ok, %u zones\n", (unsigned)xfrd->zones->count);
@@ -927,7 +927,7 @@ do_force_transfer(SSL* ssl, xfrd_state_t* xfrd, char* arg)
 }
 
 static int
-print_soa_status(SSL* ssl, const char* str, xfrd_soa_t* soa, time_t acq)
+print_soa_status(SSL* ssl, const char* str, xfrd_soa_type* soa, time_t acq)
 {
  if(acq) {
  if(!ssl_printf(ssl, " %s: \"%u since %s\"\n", str,
@@ -942,11 +942,11 @@ print_soa_status(SSL* ssl, const char* str, xfrd_soa_t* soa, time_t acq)
 
 /** print zonestatus for one domain */
 static int
-print_zonestatus(SSL* ssl, xfrd_state_t* xfrd, zone_options_t* zo)
+print_zonestatus(SSL* ssl, xfrd_state_type* xfrd, struct zone_options* zo)
 {
- xfrd_zone_t* xz = (xfrd_zone_t*)rbtree_search(xfrd->zones,
+ xfrd_zone_type* xz = (xfrd_zone_type*)rbtree_search(xfrd->zones,
  (const dname_type*)zo->node.key);
- struct notify_zone_t* nz = (struct notify_zone_t*)rbtree_search(
+ struct notify_zone* nz = (struct notify_zone*)rbtree_search(
  xfrd->notify_zones, (const dname_type*)zo->node.key);
  if(!ssl_printf(ssl, "zone: %s\n", zo->name))
  return 0;
@@ -1012,14 +1012,14 @@ print_zonestatus(SSL* ssl, xfrd_state_t* xfrd, zone_options_t* zo)
 
 /** do the zonestatus command */
 static void
-do_zonestatus(SSL* ssl, xfrd_state_t* xfrd, char* arg)
+do_zonestatus(SSL* ssl, xfrd_state_type* xfrd, char* arg)
 {
- zone_options_t* zo;
+ struct zone_options* zo;
  if(!get_zone_arg(ssl, xfrd, arg, &zo))
  return;
  if(zo) (void)print_zonestatus(ssl, xfrd, zo);
  else {
- RBTREE_FOR(zo, zone_options_t*,
+ RBTREE_FOR(zo, struct zone_options*,
  xfrd->nsd->options->zone_options) {
  if(!print_zonestatus(ssl, xfrd, zo))
  return;
@@ -1067,7 +1067,7 @@ find_arg2(SSL* ssl, char* arg, char** arg2)
 
 /** do the status command */
 static void
-do_status(SSL* ssl, xfrd_state_t* xfrd)
+do_status(SSL* ssl, xfrd_state_type* xfrd)
 {
  if(!ssl_printf(ssl, "version: %s\n", PACKAGE_VERSION))
  return;
@@ -1107,7 +1107,7 @@ do_stats(struct daemon_remote* rc, int peek, struct rc_state* rs)
 
 /** see if we have more zonestatistics entries and it has to be incremented */
 static void
-zonestat_inc_ifneeded(xfrd_state_t* xfrd)
+zonestat_inc_ifneeded(xfrd_state_type* xfrd)
 {
 #ifdef USE_ZONE_STATS
  if(xfrd->nsd->options->zonestatnames->count != xfrd->zonestat_safe)
@@ -1121,10 +1121,10 @@ zonestat_inc_ifneeded(xfrd_state_t* xfrd)
 
 /** perform the addzone command for one zone */
 static int
-perform_addzone(SSL* ssl, xfrd_state_t* xfrd, char* arg)
+perform_addzone(SSL* ssl, xfrd_state_type* xfrd, char* arg)
 {
  const dname_type* dname;
- zone_options_t* zopt;
+ struct zone_options* zopt;
  char* arg2 = NULL;
  if(!find_arg2(ssl, arg, &arg2))
  return 0;
@@ -1184,10 +1184,10 @@ perform_addzone(SSL* ssl, xfrd_state_t* xfrd, char* arg)
 
 /** perform the delzone command for one zone */
 static int
-perform_delzone(SSL* ssl, xfrd_state_t* xfrd, char* arg)
+perform_delzone(SSL* ssl, xfrd_state_type* xfrd, char* arg)
 {
  const dname_type* dname;
- zone_options_t* zopt;
+ struct zone_options* zopt;
 
  dname = dname_parse(xfrd->region, arg);
  if(!dname) {
@@ -1234,7 +1234,7 @@ perform_delzone(SSL* ssl, xfrd_state_t* xfrd, char* arg)
 
 /** do the addzone command */
 static void
-do_addzone(SSL* ssl, xfrd_state_t* xfrd, char* arg)
+do_addzone(SSL* ssl, xfrd_state_type* xfrd, char* arg)
 {
  if(!perform_addzone(ssl, xfrd, arg))
  return;
@@ -1243,7 +1243,7 @@ do_addzone(SSL* ssl, xfrd_state_t* xfrd, char* arg)
 
 /** do the delzone command */
 static void
-do_delzone(SSL* ssl, xfrd_state_t* xfrd, char* arg)
+do_delzone(SSL* ssl, xfrd_state_type* xfrd, char* arg)
 {
  if(!perform_delzone(ssl, xfrd, arg))
  return;
@@ -1252,7 +1252,7 @@ do_delzone(SSL* ssl, xfrd_state_t* xfrd, char* arg)
 
 /** do the addzones command */
 static void
-do_addzones(SSL* ssl, xfrd_state_t* xfrd)
+do_addzones(SSL* ssl, xfrd_state_type* xfrd)
 {
  char buf[2048];
  int num = 0;
@@ -1274,7 +1274,7 @@ do_addzones(SSL* ssl, xfrd_state_t* xfrd)
 
 /** do the delzones command */
 static void
-do_delzones(SSL* ssl, xfrd_state_t* xfrd)
+do_delzones(SSL* ssl, xfrd_state_type* xfrd)
 {
  char buf[2048];
  int num = 0;
@@ -1296,7 +1296,7 @@ do_delzones(SSL* ssl, xfrd_state_t* xfrd)
 
 
 /** remove TSIG key from config and add task so that reload does too */
-static void remove_key(xfrd_state_t* xfrd, const char* kname)
+static void remove_key(xfrd_state_type* xfrd, const char* kname)
 {
  /* add task before deletion because the name string could be deleted */
  task_new_del_key(xfrd->nsd->task[xfrd->nsd->mytask], xfrd->last_task,
@@ -1307,7 +1307,7 @@ static void remove_key(xfrd_state_t* xfrd, const char* kname)
 }
 
 /** add TSIG key to config and add task so that reload does too */
-static void add_key(xfrd_state_t* xfrd, key_options_t* k)
+static void add_key(xfrd_state_type* xfrd, struct key_options* k)
 {
  key_options_add_modify(xfrd->nsd->options, k);
  task_new_add_key(xfrd->nsd->task[xfrd->nsd->mytask], xfrd->last_task,
@@ -1316,22 +1316,22 @@ static void add_key(xfrd_state_t* xfrd, key_options_t* k)
 }
 
 /** check if keys have changed */
-static void repat_keys(xfrd_state_t* xfrd, nsd_options_t* newopt)
+static void repat_keys(xfrd_state_type* xfrd, struct nsd_options* newopt)
 {
- nsd_options_t* oldopt = xfrd->nsd->options;
- key_options_t* k;
+ struct nsd_options* oldopt = xfrd->nsd->options;
+ struct key_options* k;
  /* find deleted keys */
- k = (key_options_t*)rbtree_first(oldopt->keys);
- while((rbnode_t*)k != RBTREE_NULL) {
- key_options_t* next = (key_options_t*)rbtree_next(
- (rbnode_t*)k);
+ k = (struct key_options*)rbtree_first(oldopt->keys);
+ while((rbnode_type*)k != RBTREE_NULL) {
+ struct key_options* next = (struct key_options*)rbtree_next(
+ (rbnode_type*)k);
  if(!key_options_find(newopt, k->name))
  remove_key(xfrd, k->name);
  k = next;
  }
  /* find added or changed keys */
- RBTREE_FOR(k, key_options_t*, newopt->keys) {
- key_options_t* origk = key_options_find(oldopt, k->name);
+ RBTREE_FOR(k, struct key_options*, newopt->keys) {
+ struct key_options* origk = key_options_find(oldopt, k->name);
  if(!origk)
  add_key(xfrd, k);
  else if(!key_options_equal(k, origk))
@@ -1341,7 +1341,7 @@ static void repat_keys(xfrd_state_t* xfrd, nsd_options_t* newopt)
 
 /** find zone given the implicit pattern */
 static const dname_type*
-parse_implicit_name(xfrd_state_t* xfrd,const char* pname)
+parse_implicit_name(xfrd_state_type* xfrd,const char* pname)
 {
  if(strncmp(pname, PATTERN_IMPLICIT_MARKER,
  strlen(PATTERN_IMPLICIT_MARKER)) != 0)
@@ -1352,10 +1352,10 @@ parse_implicit_name(xfrd_state_t* xfrd,const char* pname)
 
 /** remove cfgzone and add task so that reload does too */
 static void
-remove_cfgzone(xfrd_state_t* xfrd, const char* pname)
+remove_cfgzone(xfrd_state_type* xfrd, const char* pname)
 {
  /* dname and find the zone for the implicit pattern */
- zone_options_t* zopt = NULL;
+ struct zone_options* zopt = NULL;
  const dname_type* dname = parse_implicit_name(xfrd, pname);
  if(!dname) {
  /* should have a parseable name, but it did not */
@@ -1390,10 +1390,11 @@ remove_cfgzone(xfrd_state_t* xfrd, const char* pname)
 
 /** add cfgzone and add task so that reload does too */
 static void
-add_cfgzone(xfrd_state_t* xfrd, const char* pname)
+add_cfgzone(xfrd_state_type* xfrd, const char* pname)
 {
  /* add to our zonelist */
- zone_options_t* zopt = zone_options_create(xfrd->nsd->options->region);
+ struct zone_options* zopt = zone_options_create(
+ xfrd->nsd->options->region);
  if(!zopt)
  return;
  zopt->part_of_config = 1;
@@ -1423,7 +1424,7 @@ add_cfgzone(xfrd_state_t* xfrd, const char* pname)
 
 /** remove pattern and add task so that reload does too */
 static void
-remove_pat(xfrd_state_t* xfrd, const char* name)
+remove_pat(xfrd_state_type* xfrd, const char* name)
 {
  /* add task before deletion, because name-string could be deleted */
  task_new_del_pattern(xfrd->nsd->task[xfrd->nsd->mytask],
@@ -1434,7 +1435,7 @@ remove_pat(xfrd_state_t* xfrd, const char* name)
 
 /** add pattern and add task so that reload does too */
 static void
-add_pat(xfrd_state_t* xfrd, pattern_options_t* p)
+add_pat(xfrd_state_type* xfrd, struct pattern_options* p)
 {
  pattern_options_add_modify(xfrd->nsd->options, p);
  task_new_add_pattern(xfrd->nsd->task[xfrd->nsd->mytask],
@@ -1444,17 +1445,17 @@ add_pat(xfrd_state_t* xfrd, pattern_options_t* p)
 
 /** interrupt zones that are using changed or removed patterns */
 static void
-repat_interrupt_zones(xfrd_state_t* xfrd, nsd_options_t* newopt)
+repat_interrupt_zones(xfrd_state_type* xfrd, struct nsd_options* newopt)
 {
  /* if masterlist changed:
  *   interrupt slave zone (UDP or TCP) transfers.
  *   slave zones reset master to start of list.
  */
- xfrd_zone_t* xz;
- struct notify_zone_t* nz;
- RBTREE_FOR(xz, xfrd_zone_t*, xfrd->zones) {
- pattern_options_t* oldp = xz->zone_options->pattern;
- pattern_options_t* newp = pattern_options_find(newopt,
+ xfrd_zone_type* xz;
+ struct notify_zone* nz;
+ RBTREE_FOR(xz, xfrd_zone_type*, xfrd->zones) {
+ struct pattern_options* oldp = xz->zone_options->pattern;
+ struct pattern_options* newp = pattern_options_find(newopt,
  oldp->pname);
  if(!newp || !acl_list_equal(oldp->request_xfr,
  newp->request_xfr)) {
@@ -1476,9 +1477,9 @@ repat_interrupt_zones(xfrd_state_t* xfrd, nsd_options_t* newopt)
  *   interrupt notify that is busy.
  *   reset notify to start of list.  (clear all other reset_notify)
  */
- RBTREE_FOR(nz, struct notify_zone_t*, xfrd->notify_zones) {
- pattern_options_t* oldp = nz->options->pattern;
- pattern_options_t* newp = pattern_options_find(newopt,
+ RBTREE_FOR(nz, struct notify_zone*, xfrd->notify_zones) {
+ struct pattern_options* oldp = nz->options->pattern;
+ struct pattern_options* newp = pattern_options_find(newopt,
  oldp->pname);
  if(!newp || !acl_list_equal(oldp->notify, newp->notify)) {
  /* interrupt notify */
@@ -1498,10 +1499,10 @@ repat_interrupt_zones(xfrd_state_t* xfrd, nsd_options_t* newopt)
 
 /** for notify, after the pattern changes, restart the affected notifies */
 static void
-repat_interrupt_notify_start(xfrd_state_t* xfrd)
+repat_interrupt_notify_start(xfrd_state_type* xfrd)
 {
- struct notify_zone_t* nz;
- RBTREE_FOR(nz, struct notify_zone_t*, xfrd->notify_zones) {
+ struct notify_zone* nz;
+ RBTREE_FOR(nz, struct notify_zone*, xfrd->notify_zones) {
  if(nz->notify_restart) {
  if(nz->notify_current)
  nz->notify_current = nz->options->pattern->notify;
@@ -1515,7 +1516,7 @@ repat_interrupt_notify_start(xfrd_state_t* xfrd)
 
 /** check if patterns have changed */
 static void
-repat_patterns(xfrd_state_t* xfrd, nsd_options_t* newopt)
+repat_patterns(xfrd_state_type* xfrd, struct nsd_options* newopt)
 {
  /* zones that use changed patterns must have:
  * - their AXFR/IXFR interrupted: try again, acl may have changed.
@@ -1523,16 +1524,16 @@ repat_patterns(xfrd_state_t* xfrd, nsd_options_t* newopt)
  *   keep going.  Otherwise, stop xfer and reset TSIG.
  * - send NOTIFY reset to start of NOTIFY list (and TSIG reset).
  */
- nsd_options_t* oldopt = xfrd->nsd->options;
- pattern_options_t* p;
+ struct nsd_options* oldopt = xfrd->nsd->options;
+ struct pattern_options* p;
  int search_zones = 0;
 
  repat_interrupt_zones(xfrd, newopt);
  /* find deleted patterns */
- p = (pattern_options_t*)rbtree_first(oldopt->patterns);
- while((rbnode_t*)p != RBTREE_NULL) {
- pattern_options_t* next = (pattern_options_t*)rbtree_next(
- (rbnode_t*)p);
+ p = (struct pattern_options*)rbtree_first(oldopt->patterns);
+ while((rbnode_type*)p != RBTREE_NULL) {
+ struct pattern_options* next = (struct pattern_options*)
+ rbtree_next((rbnode_type*)p);
  if(!pattern_options_find(newopt, p->pname)) {
  if(p->implicit) {
  /* first remove its zone */
@@ -1544,8 +1545,8 @@ repat_patterns(xfrd_state_t* xfrd, nsd_options_t* newopt)
  p = next;
  }
  /* find added or changed patterns */
- RBTREE_FOR(p, pattern_options_t*, newopt->patterns) {
- pattern_options_t* origp = pattern_options_find(oldopt,
+ RBTREE_FOR(p, struct pattern_options*, newopt->patterns) {
+ struct pattern_options* origp = pattern_options_find(oldopt,
  p->pname);
  if(!origp) {
  /* no zones can use it, no zone_interrupt needed */
@@ -1567,7 +1568,7 @@ repat_patterns(xfrd_state_t* xfrd, nsd_options_t* newopt)
  parse_implicit_name(xfrd, p->pname);
  if (dname) {
  if (newstate == REPAT_SLAVE) {
- zone_options_t* zopt =
+ struct zone_options* zopt =
  zone_options_find(
  oldopt, dname);
  if (zopt) {
@@ -1590,11 +1591,11 @@ repat_patterns(xfrd_state_t* xfrd, nsd_options_t* newopt)
  }
  }
  if (search_zones) {
- zone_options_t* zone_opt;
+ struct zone_options* zone_opt;
  /* search in oldopt because 1) it contains zonelist zones,
  * and 2) you need oldopt(existing) to call xfrd_init */
- RBTREE_FOR(zone_opt, zone_options_t*, oldopt->zone_options) {
- pattern_options_t* oldp = zone_opt->pattern;
+ RBTREE_FOR(zone_opt, struct zone_options*, oldopt->zone_options) {
+ struct pattern_options* oldp = zone_opt->pattern;
  if (!oldp->implicit) {
  if (oldp->xfrd_flags == REPAT_SLAVE) {
  /* xfrd needs stable reference so get
@@ -1614,7 +1615,7 @@ repat_patterns(xfrd_state_t* xfrd, nsd_options_t* newopt)
 
 /** true if options are different that can be set via repat. */
 static int
-repat_options_changed(xfrd_state_t* xfrd, nsd_options_t* newopt)
+repat_options_changed(xfrd_state_type* xfrd, struct nsd_options* newopt)
 {
 #ifdef RATELIMIT
  if(xfrd->nsd->options->rrl_ratelimit != newopt->rrl_ratelimit)
@@ -1631,7 +1632,7 @@ repat_options_changed(xfrd_state_t* xfrd, nsd_options_t* newopt)
 
 /** check if global options have changed */
 static void
-repat_options(xfrd_state_t* xfrd, nsd_options_t* newopt)
+repat_options(xfrd_state_type* xfrd, struct nsd_options* newopt)
 {
  if(repat_options_changed(xfrd, newopt)) {
  /* update our options */
@@ -1659,10 +1660,10 @@ print_ssl_cfg_err(void* arg, const char* str)
 
 /** do the repattern command: reread config file and apply keys, patterns */
 static void
-do_repattern(SSL* ssl, xfrd_state_t* xfrd)
+do_repattern(SSL* ssl, xfrd_state_type* xfrd)
 {
  region_type* region = region_create(xalloc, free);
- nsd_options_t* opt;
+ struct nsd_options* opt;
  const char* cfgfile = xfrd->nsd->options->configfile;
 
  /* check chroot and configfile, if possible to reread */
@@ -1699,7 +1700,7 @@ do_repattern(SSL* ssl, xfrd_state_t* xfrd)
 
 /** do the serverpid command: printout pid of server process */
 static void
-do_serverpid(SSL* ssl, xfrd_state_t* xfrd)
+do_serverpid(SSL* ssl, xfrd_state_type* xfrd)
 {
  (void)ssl_printf(ssl, "%u\n", (unsigned)xfrd->reload_pid);
 }
@@ -2013,7 +2014,7 @@ print_stat_block(SSL* ssl, char* n, char* d, struct nsdst* st)
 
 #ifdef USE_ZONE_STATS
 static void
-resize_zonestat(xfrd_state_t* xfrd, size_t num)
+resize_zonestat(xfrd_state_type* xfrd, size_t num)
 {
  struct nsdst** a = xalloc_array_zero(num, sizeof(struct nsdst*));
  if(xfrd->zonestat_clear_num != 0)
@@ -2025,7 +2026,7 @@ resize_zonestat(xfrd_state_t* xfrd, size_t num)
 }
 
 static void
-zonestat_print(SSL* ssl, xfrd_state_t* xfrd, int clear)
+zonestat_print(SSL* ssl, xfrd_state_type* xfrd, int clear)
 {
  struct zonestatname* n;
  struct nsdst stat0, stat1;
@@ -2077,10 +2078,10 @@ zonestat_print(SSL* ssl, xfrd_state_t* xfrd, int clear)
 #endif /* USE_ZONE_STATS */
 
 static void
-print_stats(SSL* ssl, xfrd_state_t* xfrd, struct timeval* now, int clear)
+print_stats(SSL* ssl, xfrd_state_type* xfrd, struct timeval* now, int clear)
 {
  size_t i;
- stc_t total = 0;
+ stc_type total = 0;
  struct timeval elapsed, uptime;
 
  /* per CPU and total */
@@ -2132,7 +2133,7 @@ print_stats(SSL* ssl, xfrd_state_t* xfrd, struct timeval* now, int clear)
 }
 
 static void
-clear_stats(xfrd_state_t* xfrd)
+clear_stats(xfrd_state_type* xfrd)
 {
  size_t i;
  uint64_t dbd = xfrd->nsd->st.db_disk;
diff --git server.c server.c
index ae27312fbfc..9018031cd74 100644
--- server.c
+++ server.c
@@ -1396,7 +1396,7 @@ parent_send_stats(struct nsd* nsd, int cmdfd)
  }
  for(i=0; i<nsd->child_count; i++)
  if(!write_socket(cmdfd, &nsd->children[i].query_count,
- sizeof(stc_t))) {
+ sizeof(stc_type))) {
  log_msg(LOG_ERR, "could not write stats to reload");
  return;
  }
@@ -1406,7 +1406,7 @@ static void
 reload_do_stats(int cmdfd, struct nsd* nsd, udb_ptr* last)
 {
  struct nsdst s;
- stc_t* p;
+ stc_type* p;
  size_t i;
  if(block_read(nsd, cmdfd, &s, sizeof(s),
  RELOAD_SYNC_TIMEOUT) != sizeof(s)) {
@@ -1415,11 +1415,12 @@ reload_do_stats(int cmdfd, struct nsd* nsd, udb_ptr* last)
  }
  s.db_disk = (nsd->db->udb?nsd->db->udb->base_size:0);
  s.db_mem = region_get_mem(nsd->db->region);
- p = (stc_t*)task_new_stat_info(nsd->task[nsd->mytask], last, &s,
+ p = (stc_type*)task_new_stat_info(nsd->task[nsd->mytask], last, &s,
  nsd->child_count);
  if(!p) return;
  for(i=0; i<nsd->child_count; i++) {
- if(block_read(nsd, cmdfd, p++, sizeof(stc_t), 1)!=sizeof(stc_t))
+ if(block_read(nsd, cmdfd, p++, sizeof(stc_type), 1)!=
+ sizeof(stc_type))
  return;
  }
 }
diff --git tsig.c tsig.c
index b58191ce9b8..a7cc66ee184 100644
--- tsig.c
+++ tsig.c
@@ -23,11 +23,11 @@ static region_type *tsig_region;
 
 struct tsig_key_table
 {
- rbnode_t node; /* by dname */
+ rbnode_type node; /* by dname */
  tsig_key_type *key;
 };
 typedef struct tsig_key_table tsig_key_table_type;
-static rbtree_t *tsig_key_table;
+static rbtree_type *tsig_key_table;
 
 struct tsig_algorithm_table
 {
diff --git udbradtree.c udbradtree.c
index d9be6b9c255..4452b6ddde1 100644
--- udbradtree.c
+++ udbradtree.c
@@ -46,7 +46,8 @@ size_t size_of_lookup_ext(udb_ptr* lookup)
 }
 
 /** size needed for a lookup array like this */
-static size_t size_of_lookup_needed(uint16_t capacity, udb_radstrlen_t str_cap)
+static size_t size_of_lookup_needed(uint16_t capacity,
+ udb_radstrlen_type str_cap)
 {
  return sizeof(struct udb_radarray_d)+ ((size_t)capacity)*(
  sizeof(struct udb_radsel_d)+(size_t)str_cap);
@@ -61,7 +62,7 @@ static struct udb_radarray_d* lookup(udb_ptr* n)
 }
 
 /** get a length in the lookup array */
-static udb_radstrlen_t lookup_len(udb_ptr* n, unsigned i)
+static udb_radstrlen_type lookup_len(udb_ptr* n, unsigned i)
 {
  return lookup(n)->array[i].len;
 }
@@ -158,9 +159,9 @@ void udb_radix_tree_delete(udb_base* udb, udb_ptr* rt)
  * @return false if no prefix found, not even the root "" prefix.
  */
 static int udb_radix_find_prefix_node(udb_base* udb, udb_ptr* rt, uint8_t* k,
- udb_radstrlen_t len, udb_ptr* result, udb_radstrlen_t* respos)
+ udb_radstrlen_type len, udb_ptr* result, udb_radstrlen_type* respos)
 {
- udb_radstrlen_t pos = 0;
+ udb_radstrlen_type pos = 0;
  uint8_t byte;
  udb_ptr n;
  udb_ptr_new(&n, udb, &RADTREE(rt)->root);
@@ -207,14 +208,15 @@ static int udb_radix_find_prefix_node(udb_base* udb, udb_ptr* rt, uint8_t* k,
 }
 
 /** grow the radnode stringcapacity, copy existing elements */
-static int udb_radnode_str_grow(udb_base* udb, udb_ptr* n, udb_radstrlen_t want)
+static int udb_radnode_str_grow(udb_base* udb, udb_ptr* n,
+ udb_radstrlen_type want)
 {
  unsigned ns = ((unsigned)lookup(n)->str_cap)*2;
  unsigned i;
  udb_ptr a;
  if(want > ns)
  ns = want;
- if(ns > 65535) ns = 65535; /* MAX of udb_radstrlen_t range */
+ if(ns > 65535) ns = 65535; /* MAX of udb_radstrlen_type range */
  /* if this fails, the tree is still usable */
  if(!udb_ptr_alloc_space(&a, udb, udb_chunk_type_radarray,
  size_of_lookup_needed(lookup(n)->capacity, ns)))
@@ -280,7 +282,7 @@ static int udb_radnode_array_create(udb_base* udb, udb_ptr* n)
  /* create array */
  udb_ptr a;
  uint16_t cap = 0;
- udb_radstrlen_t len = 0;
+ udb_radstrlen_type len = 0;
  if(!udb_ptr_alloc_space(&a, udb, udb_chunk_type_radarray,
  size_of_lookup_needed(cap, len)))
  return 0;
@@ -297,7 +299,7 @@ static int udb_radnode_array_create(udb_base* udb, udb_ptr* n)
 
 /** make space in radnode for another byte, or longer strings */
 static int udb_radnode_array_space(udb_base* udb, udb_ptr* n, uint8_t byte,
- udb_radstrlen_t len)
+ udb_radstrlen_type len)
 {
  /* is there an array? */
  if(RADNODE(n)->lookup.data == 0) {
@@ -389,7 +391,8 @@ static int udb_radnode_array_space(udb_base* udb, udb_ptr* n, uint8_t byte,
 }
 
 /** make space for string size */
-static int udb_radnode_str_space(udb_base* udb, udb_ptr* n, udb_radstrlen_t len)
+static int udb_radnode_str_space(udb_base* udb, udb_ptr* n,
+ udb_radstrlen_type len)
 {
  if(RADNODE(n)->lookup.data == 0) {
  return udb_radnode_array_space(udb, n, 0, len);
@@ -404,9 +407,9 @@ static int udb_radnode_str_space(udb_base* udb, udb_ptr* n, udb_radstrlen_t len)
 
 /** copy remainder from prefixes for a split:
  * plen: len prefix, l: longer bstring, llen: length of l. */
-static void udb_radsel_prefix_remainder(udb_radstrlen_t plen,
- uint8_t* l, udb_radstrlen_t llen,
- uint8_t* s, udb_radstrlen_t* slen)
+static void udb_radsel_prefix_remainder(udb_radstrlen_type plen,
+ uint8_t* l, udb_radstrlen_type llen,
+ uint8_t* s, udb_radstrlen_type* slen)
 {
  *slen = llen - plen;
  /* assert(*slen <= lookup(n)->str_cap); */
@@ -414,34 +417,34 @@ static void udb_radsel_prefix_remainder(udb_radstrlen_t plen,
 }
 
 /** create a prefix in the array strs */
-static void udb_radsel_str_create(uint8_t* s, udb_radstrlen_t* slen,
- uint8_t* k, udb_radstrlen_t pos, udb_radstrlen_t len)
+static void udb_radsel_str_create(uint8_t* s, udb_radstrlen_type* slen,
+ uint8_t* k, udb_radstrlen_type pos, udb_radstrlen_type len)
 {
  *slen = len-pos;
  /* assert(*slen <= lookup(n)->str_cap); */
  memmove(s, k+pos, len-pos);
 }
 
-static udb_radstrlen_t
-udb_bstr_common(uint8_t* x, udb_radstrlen_t xlen,
- uint8_t* y, udb_radstrlen_t ylen)
+static udb_radstrlen_type
+udb_bstr_common(uint8_t* x, udb_radstrlen_type xlen,
+ uint8_t* y, udb_radstrlen_type ylen)
 {
- assert(sizeof(radstrlen_t) == sizeof(udb_radstrlen_t));
+ assert(sizeof(radstrlen_type) == sizeof(udb_radstrlen_type));
  return bstr_common_ext(x, xlen, y, ylen);
 }
 
 static int
-udb_bstr_is_prefix(uint8_t* p, udb_radstrlen_t plen,
- uint8_t* x, udb_radstrlen_t xlen)
+udb_bstr_is_prefix(uint8_t* p, udb_radstrlen_type plen,
+ uint8_t* x, udb_radstrlen_type xlen)
 {
- assert(sizeof(radstrlen_t) == sizeof(udb_radstrlen_t));
+ assert(sizeof(radstrlen_type) == sizeof(udb_radstrlen_type));
  return bstr_is_prefix_ext(p, plen, x, xlen);
 }
 
 /** grow array space for byte N after a string, (but if string shorter) */
 static int
 udb_radnode_array_space_strremain(udb_base* udb, udb_ptr* n,
- uint8_t* str, udb_radstrlen_t len, udb_radstrlen_t pos)
+ uint8_t* str, udb_radstrlen_type len, udb_radstrlen_type pos)
 {
  assert(pos < len);
  /* shift by one char because it goes in lookup array */
@@ -461,13 +464,13 @@ udb_radnode_array_space_strremain(udb_base* udb, udb_ptr* n,
  * @return false on alloc failure, no changes made.
  */
 static int udb_radsel_split(udb_base* udb, udb_ptr* n, uint8_t idx, uint8_t* k,
- udb_radstrlen_t pos, udb_radstrlen_t len, udb_ptr* add)
+ udb_radstrlen_type pos, udb_radstrlen_type len, udb_ptr* add)
 {
  uint8_t* addstr = k+pos;
- udb_radstrlen_t addlen = len-pos;
+ udb_radstrlen_type addlen = len-pos;
  if(udb_bstr_is_prefix(addstr, addlen, lookup_string(n, idx),
  lookup_len(n, idx))) {
- udb_radstrlen_t split_len = 0;
+ udb_radstrlen_type split_len = 0;
  /* 'add' is a prefix of r.node */
  /* also for empty addstr */
  /* set it up so that the 'add' node has r.node as child */
@@ -511,7 +514,7 @@ static int udb_radsel_split(udb_base* udb, udb_ptr* n, uint8_t idx, uint8_t* k,
  }
  } else if(udb_bstr_is_prefix(lookup_string(n, idx), lookup_len(n, idx),
  addstr, addlen)) {
- udb_radstrlen_t split_len = 0;
+ udb_radstrlen_type split_len = 0;
  udb_ptr rnode;
  /* r.node is a prefix of 'add' */
  /* set it up so that the 'r.node' has 'add' as child */
@@ -556,7 +559,7 @@ static int udb_radsel_split(udb_base* udb, udb_ptr* n, uint8_t idx, uint8_t* k,
  * We do this so that r.node stays the same pointer for its
  * key name. */
  udb_ptr com, rnode;
- udb_radstrlen_t common_len = udb_bstr_common(
+ udb_radstrlen_type common_len = udb_bstr_common(
  lookup_string(n, idx), lookup_len(n, idx),
  addstr, addlen);
  assert(common_len < lookup_len(n, idx));
@@ -633,11 +636,11 @@ static int udb_radsel_split(udb_base* udb, udb_ptr* n, uint8_t idx, uint8_t* k,
 
 uint64_t* result_data = NULL;
 udb_void udb_radix_insert(udb_base* udb, udb_ptr* rt, uint8_t* k,
-        udb_radstrlen_t len, udb_ptr* elem, udb_ptr* result)
+        udb_radstrlen_type len, udb_ptr* elem, udb_ptr* result)
 {
  udb_void ret;
  udb_ptr add, n; /* type udb_radnode_d */
- udb_radstrlen_t pos = 0;
+ udb_radstrlen_type pos = 0;
  /* create new element to add */
  if(!udb_ptr_alloc_space(&add, udb, udb_chunk_type_radnode,
  sizeof(struct udb_radnode_d))) {
@@ -778,7 +781,7 @@ udb_radnode_cleanup_onechild(udb_base* udb, udb_ptr* n)
 {
  udb_ptr par, child;
  uint8_t pidx = RADNODE(n)->pidx;
- radstrlen_t joinlen;
+ radstrlen_type joinlen;
  udb_ptr_new(&par, udb, &RADNODE(n)->parent);
  udb_ptr_new(&child, udb, &lookup(n)->array[0].node);
 
@@ -819,7 +822,7 @@ udb_radnode_cleanup_onechild(udb_base* udb, udb_ptr* n)
 /** reduce the size of radarray, does a malloc */
 static int
 udb_radarray_reduce(udb_base* udb, udb_ptr* n, uint16_t cap,
- udb_radstrlen_t strcap)
+ udb_radstrlen_type strcap)
 {
  udb_ptr a;
  unsigned i;
@@ -849,10 +852,10 @@ udb_radarray_reduce(udb_base* udb, udb_ptr* n, uint16_t cap,
 }
 
 /** find the max stringlength in the array */
-static udb_radstrlen_t udb_radarray_max_len(udb_ptr* n)
+static udb_radstrlen_type udb_radarray_max_len(udb_ptr* n)
 {
  unsigned i;
- udb_radstrlen_t maxlen = 0;
+ udb_radstrlen_type maxlen = 0;
  for(i=0; i<lookup(n)->len; i++) {
  if(lookup(n)->array[i].node.data &&
  lookup(n)->array[i].len > maxlen)
@@ -865,7 +868,7 @@ static udb_radstrlen_t udb_radarray_max_len(udb_ptr* n)
 static int
 udb_radarray_reduce_if_needed(udb_base* udb, udb_ptr* n)
 {
- udb_radstrlen_t maxlen = udb_radarray_max_len(n);
+ udb_radstrlen_type maxlen = udb_radarray_max_len(n);
  if((lookup(n)->len <= lookup(n)->capacity/2 || lookup(n)->len == 0
  || maxlen <= lookup(n)->str_cap/2 || maxlen == 0) &&
  (lookup(n)->len != lookup(n)->capacity ||
@@ -1053,12 +1056,12 @@ void udb_radix_delete(udb_base* udb, udb_ptr* rt, udb_ptr* n)
  }
 }
 
-udb_void udb_radix_search(udb_ptr* rt, uint8_t* k, udb_radstrlen_t len)
+udb_void udb_radix_search(udb_ptr* rt, uint8_t* k, udb_radstrlen_type len)
 {
  /* since we only perform reads, and no udb_mallocs or udb_frees
  * we know the pointers stay the same */
  struct udb_radnode_d* n;
- udb_radstrlen_t pos = 0;
+ udb_radstrlen_type pos = 0;
  uint8_t byte;
  void* base = *rt->base;
 
@@ -1206,10 +1209,10 @@ static int udb_ret_self_or_prev(udb_base* udb, udb_ptr* n, udb_ptr* result)
 
 
 int udb_radix_find_less_equal(udb_base* udb, udb_ptr* rt, uint8_t* k,
-        udb_radstrlen_t len, udb_ptr* result)
+        udb_radstrlen_type len, udb_ptr* result)
 {
  udb_ptr n;
- udb_radstrlen_t pos = 0;
+ udb_radstrlen_type pos = 0;
  uint8_t byte;
  int r;
  /* set result to NULL */
@@ -1411,7 +1414,7 @@ udb_void udb_radname_insert(udb_base* udb, udb_ptr* rt, const uint8_t* dname,
  size_t dlen, udb_ptr* elem, udb_ptr* result)
 {
  uint8_t k[300];
- radstrlen_t klen = (radstrlen_t)sizeof(k);
+ radstrlen_type klen = (radstrlen_type)sizeof(k);
  radname_d2r(k, &klen, dname, dlen);
  return udb_radix_insert(udb, rt, k, klen, elem, result);
 }
@@ -1421,7 +1424,7 @@ int udb_radname_search(udb_base* udb, udb_ptr* rt, const uint8_t* dname,
 {
  udb_void r;
  uint8_t k[300];
- radstrlen_t klen = (radstrlen_t)sizeof(k);
+ radstrlen_type klen = (radstrlen_type)sizeof(k);
  radname_d2r(k, &klen, dname, dlen);
  r = udb_radix_search(rt, k, klen);
  udb_ptr_init(result, udb);
diff --git udbradtree.h udbradtree.h
index 2732e73d022..b8e6186ae8b 100644
--- udbradtree.h
+++ udbradtree.h
@@ -9,7 +9,7 @@
 struct udb_radnode;
 
 /** length of the binary string */
-typedef uint16_t udb_radstrlen_t;
+typedef uint16_t udb_radstrlen_type;
 
 /**
  * The radix tree
@@ -54,7 +54,7 @@ struct udb_radnode_d {
 struct udb_radsel_d {
  /** length of the additional string for this edge,
  * additional string after the selection-byte for this edge.*/
- udb_radstrlen_t len;
+ udb_radstrlen_type len;
  /** padding for non64bit compilers to 64bit boundaries, to make
  * the udb file more portable, without this the file would work
  * on the system it is created on (which is what we promise), but
@@ -78,7 +78,7 @@ struct udb_radarray_d {
  /** capacity of the lookup array (can be larger than length) */
  uint16_t capacity;
  /** space capacity of for every string */
- udb_radstrlen_t str_cap;
+ udb_radstrlen_type str_cap;
  /** padding to 64bit alignment, just in case compiler goes mad */
  uint16_t padding;
  /** the elements (allocated contiguously after this structure) */
@@ -123,7 +123,7 @@ void udb_radix_tree_delete(udb_base* udb, udb_ptr* rt);
  * On success the new radix node for this element (udb_radnode_d).
  */
 udb_void udb_radix_insert(udb_base* udb, udb_ptr* rt, uint8_t* k,
- udb_radstrlen_t len, udb_ptr* elem, udb_ptr* result);
+ udb_radstrlen_type len, udb_ptr* elem, udb_ptr* result);
 
 /**
  * Delete element from radix tree.
@@ -142,7 +142,7 @@ void udb_radix_delete(udb_base* udb, udb_ptr* rt, udb_ptr* n);
  * @return the radix node or NULL if not found. type udb_radnode_d
  */
 udb_void udb_radix_search(udb_ptr* rt, uint8_t* k,
- udb_radstrlen_t len);
+ udb_radstrlen_type len);
 
 /**
  * Find radix element in tree, and if not found, find the closest smaller or
@@ -157,7 +157,7 @@ udb_void udb_radix_search(udb_ptr* rt, uint8_t* k,
  * @return true if exact match, false if no match.
  */
 int udb_radix_find_less_equal(udb_base* udb, udb_ptr* rt, uint8_t* k,
- udb_radstrlen_t len, udb_ptr* result);
+ udb_radstrlen_type len, udb_ptr* result);
 
 /**
  * Return the first (smallest) element in the tree.
diff --git udbzone.h udbzone.h
index 8169857a795..8c5c5325581 100644
--- udbzone.h
+++ udbzone.h
@@ -46,7 +46,7 @@ struct zone_d {
  /** number of RRs in the zone */
  uint64_t rr_count;
  /** the length of the zone name */
- udb_radstrlen_t namelen;
+ udb_radstrlen_type namelen;
  /** if the zone is expired */
  uint8_t expired;
  /** if the zone has been changed by AXFR */
@@ -62,7 +62,7 @@ struct domain_d {
  /** the list of rrsets for this name, single linked */
  udb_rel_ptr rrsets;
  /** length of the domain name */
- udb_radstrlen_t namelen;
+ udb_radstrlen_type namelen;
  /** the domain (wire uncompressed) name in DNS format */
  uint8_t name[0];
 };
diff --git util.c util.c
index db3d7ceddce..458f0946643 100644
--- util.c
+++ util.c
@@ -487,6 +487,10 @@ strtoserial(const char* nptr, const char** endptr)
  case '7':
  case '8':
  case '9':
+ if((i*10)/10 != i)
+ /* number too large, return i
+ * with *endptr != 0 as a failure*/
+ return i;
  i *= 10;
  i += (**endptr - '0');
  break;
diff --git xfrd-disk.c xfrd-disk.c
index a86240d4a57..33f1dcac248 100644
--- xfrd-disk.c
+++ xfrd-disk.c
@@ -88,7 +88,7 @@ xfrd_read_check_str(FILE* in, const char* str)
 
 static int
 xfrd_read_state_soa(FILE* in, const char* id_acquired,
- const char* id, xfrd_soa_t* soa, time_t* soatime)
+ const char* id, xfrd_soa_type* soa, time_t* soatime)
 {
  char *p;
 
@@ -188,13 +188,13 @@ xfrd_read_state(struct xfrd_state* xfrd)
 
  for(i=0; i<numzones; i++) {
  char *p;
- xfrd_zone_t* zone;
+ xfrd_zone_type* zone;
  const dname_type* dname;
  uint32_t state, masnum, nextmas, round_num, timeout, backoff;
- xfrd_soa_t soa_nsd_read, soa_disk_read, soa_notified_read;
+ xfrd_soa_type soa_nsd_read, soa_disk_read, soa_notified_read;
  time_t soa_nsd_acquired_read,
  soa_disk_acquired_read, soa_notified_acquired_read;
- xfrd_soa_t incoming_soa;
+ xfrd_soa_type incoming_soa;
  time_t incoming_acquired;
 
  if(nsd.signal_hint_shutdown) {
@@ -237,7 +237,7 @@ xfrd_read_state(struct xfrd_state* xfrd)
  return;
  }
 
- zone = (xfrd_zone_t*)rbtree_search(xfrd->zones, dname);
+ zone = (xfrd_zone_type*)rbtree_search(xfrd->zones, dname);
  if(!zone) {
  DEBUG(DEBUG_XFRD,1, (LOG_INFO, "xfrd: state file has info for not configured zone %s", p));
  continue;
@@ -407,7 +407,7 @@ static void xfrd_write_dname(FILE* out, uint8_t* dname)
 
 static void
 xfrd_write_state_soa(FILE* out, const char* id,
- xfrd_soa_t* soa, time_t soatime, const dname_type* ATTR_UNUSED(apex))
+ xfrd_soa_type* soa, time_t soatime, const dname_type* ATTR_UNUSED(apex))
 {
  fprintf(out, "\t%s_acquired: %d", id, (int)soatime);
  if(!soatime) {
@@ -440,7 +440,7 @@ xfrd_write_state_soa(FILE* out, const char* id,
 void
 xfrd_write_state(struct xfrd_state* xfrd)
 {
- rbnode_t* p;
+ rbnode_type* p;
  const char* statefile = xfrd->nsd->options->xfrdfile;
  FILE *out;
  time_t now = xfrd_time();
@@ -477,7 +477,7 @@ xfrd_write_state(struct xfrd_state* xfrd)
  fprintf(out, "\n");
  for(p = rbtree_first(xfrd->zones); p && p!=RBTREE_NULL; p=rbtree_next(p))
  {
- xfrd_zone_t* zone = (xfrd_zone_t*)p;
+ xfrd_zone_type* zone = (xfrd_zone_type*)p;
  fprintf(out, "zone: \tname: %s\n", zone->apex_str);
  fprintf(out, "\tstate: %d", (int)zone->state);
  fprintf(out, " # %s", zone->state==xfrd_zone_ok?"OK":(
diff --git xfrd-notify.c xfrd-notify.c
index eb55c507d7d..918b32142c9 100644
--- xfrd-notify.c
+++ xfrd-notify.c
@@ -20,23 +20,23 @@
 #define XFRD_NOTIFY_RETRY_TIMOUT 15 /* seconds between retries sending NOTIFY */
 
 /* start sending notifies */
-static void notify_enable(struct notify_zone_t* zone,
+static void notify_enable(struct notify_zone* zone,
  struct xfrd_soa* new_soa);
 /* setup the notify active state */
-static void setup_notify_active(struct notify_zone_t* zone);
+static void setup_notify_active(struct notify_zone* zone);
 
 /* returns if the notify send is done for the notify_current acl */
-static int xfrd_handle_notify_reply(struct notify_zone_t* zone, buffer_type* packet);
+static int xfrd_handle_notify_reply(struct notify_zone* zone, buffer_type* packet);
 
 /* handle zone notify send */
 static void xfrd_handle_notify_send(int fd, short event, void* arg);
 
-static void xfrd_notify_next(struct notify_zone_t* zone);
+static void xfrd_notify_next(struct notify_zone* zone);
 
-static void xfrd_notify_send_udp(struct notify_zone_t* zone, buffer_type* packet);
+static void xfrd_notify_send_udp(struct notify_zone* zone, buffer_type* packet);
 
 static void
-notify_send_disable(struct notify_zone_t* zone)
+notify_send_disable(struct notify_zone* zone)
 {
  zone->notify_send_enable = 0;
  event_del(&zone->notify_send_handler);
@@ -46,7 +46,7 @@ notify_send_disable(struct notify_zone_t* zone)
 }
 
 void
-notify_disable(struct notify_zone_t* zone)
+notify_disable(struct notify_zone* zone)
 {
  zone->notify_current = 0;
  /* if added, then remove */
@@ -58,7 +58,7 @@ notify_disable(struct notify_zone_t* zone)
  /* find next waiting and needy zone */
  while(xfrd->notify_waiting_first) {
  /* snip off */
- struct notify_zone_t* wz = xfrd->notify_waiting_first;
+ struct notify_zone* wz = xfrd->notify_waiting_first;
  assert(wz->is_waiting);
  wz->is_waiting = 0;
  xfrd->notify_waiting_first = wz->waiting_next;
@@ -80,11 +80,12 @@ notify_disable(struct notify_zone_t* zone)
 }
 
 void
-init_notify_send(rbtree_t* tree, region_type* region, zone_options_t* options)
+init_notify_send(rbtree_type* tree, region_type* region,
+ struct zone_options* options)
 {
- struct notify_zone_t* not = (struct notify_zone_t*)
- region_alloc(region, sizeof(struct notify_zone_t));
- memset(not, 0, sizeof(struct notify_zone_t));
+ struct notify_zone* not = (struct notify_zone*)
+ region_alloc(region, sizeof(struct notify_zone));
+ memset(not, 0, sizeof(struct notify_zone));
  not->apex = options->node.key;
  not->apex_str = options->name;
  not->node.key = not->apex;
@@ -100,14 +101,14 @@ init_notify_send(rbtree_t* tree, region_type* region, zone_options_t* options)
  not->notify_send_enable = 0;
  tsig_create_record_custom(&not->notify_tsig, NULL, 0, 0, 4);
  not->notify_current = 0;
- rbtree_insert(tree, (rbnode_t*)not);
+ rbtree_insert(tree, (rbnode_type*)not);
 }
 
 void
-xfrd_del_notify(xfrd_state_t* xfrd, const dname_type* dname)
+xfrd_del_notify(xfrd_state_type* xfrd, const dname_type* dname)
 {
  /* find it */
- struct notify_zone_t* not = (struct notify_zone_t*)rbtree_delete(
+ struct notify_zone* not = (struct notify_zone*)rbtree_delete(
  xfrd->notify_zones, dname);
  if(!not)
  return;
@@ -132,13 +133,13 @@ xfrd_del_notify(xfrd_state_t* xfrd, const dname_type* dname)
  tsig_delete_record(&not->notify_tsig, NULL);
 
  /* free it */
- region_recycle(xfrd->region, not->current_soa, sizeof(xfrd_soa_t));
+ region_recycle(xfrd->region, not->current_soa, sizeof(xfrd_soa_type));
  /* the apex is recycled when the zone_options.node.key is removed */
  region_recycle(xfrd->region, not, sizeof(*not));
 }
 
 static int
-xfrd_handle_notify_reply(struct notify_zone_t* zone, buffer_type* packet)
+xfrd_handle_notify_reply(struct notify_zone* zone, buffer_type* packet)
 {
  if((OPCODE(packet) != OPCODE_NOTIFY) ||
  (QR(packet) == 0)) {
@@ -167,7 +168,7 @@ xfrd_handle_notify_reply(struct notify_zone_t* zone, buffer_type* packet)
 }
 
 static void
-xfrd_notify_next(struct notify_zone_t* zone)
+xfrd_notify_next(struct notify_zone* zone)
 {
  /* advance to next in acl */
  zone->notify_current = zone->notify_current->next;
@@ -182,7 +183,7 @@ xfrd_notify_next(struct notify_zone_t* zone)
 }
 
 static void
-xfrd_notify_send_udp(struct notify_zone_t* zone, buffer_type* packet)
+xfrd_notify_send_udp(struct notify_zone* zone, buffer_type* packet)
 {
  int fd;
  if(zone->notify_send_enable) {
@@ -235,7 +236,7 @@ xfrd_notify_send_udp(struct notify_zone_t* zone, buffer_type* packet)
 static void
 xfrd_handle_notify_send(int fd, short event, void* arg)
 {
- struct notify_zone_t* zone = (struct notify_zone_t*)arg;
+ struct notify_zone* zone = (struct notify_zone*)arg;
  buffer_type* packet = xfrd_get_temp_buffer();
  assert(zone->notify_current);
  if(zone->is_waiting) {
@@ -272,7 +273,7 @@ xfrd_handle_notify_send(int fd, short event, void* arg)
 }
 
 static void
-setup_notify_active(struct notify_zone_t* zone)
+setup_notify_active(struct notify_zone* zone)
 {
  zone->notify_retry = 0;
  zone->notify_current = zone->options->pattern->notify;
@@ -291,16 +292,16 @@ setup_notify_active(struct notify_zone_t* zone)
 }
 
 static void
-notify_enable(struct notify_zone_t* zone, struct xfrd_soa* new_soa)
+notify_enable(struct notify_zone* zone, struct xfrd_soa* new_soa)
 {
  if(!zone->options->pattern->notify) {
  return; /* no notify acl, nothing to do */
  }
 
  if(new_soa == NULL)
- memset(zone->current_soa, 0, sizeof(xfrd_soa_t));
+ memset(zone->current_soa, 0, sizeof(xfrd_soa_type));
  else
- memcpy(zone->current_soa, new_soa, sizeof(xfrd_soa_t));
+ memcpy(zone->current_soa, new_soa, sizeof(xfrd_soa_type));
  if(zone->is_waiting)
  return;
 
@@ -325,22 +326,22 @@ notify_enable(struct notify_zone_t* zone, struct xfrd_soa* new_soa)
 }
 
 void
-xfrd_notify_start(struct notify_zone_t* zone, struct xfrd_state* xfrd)
+xfrd_notify_start(struct notify_zone* zone, struct xfrd_state* xfrd)
 {
- xfrd_zone_t* xz;
+ xfrd_zone_type* xz;
  if(zone->is_waiting || zone->notify_send_enable)
  return;
- xz = (xfrd_zone_t*)rbtree_search(xfrd->zones, zone->apex);
+ xz = (xfrd_zone_type*)rbtree_search(xfrd->zones, zone->apex);
  if(xz && xz->soa_nsd_acquired)
  notify_enable(zone, &xz->soa_nsd);
  else notify_enable(zone, NULL);
 }
 
 void
-xfrd_send_notify(rbtree_t* tree, const dname_type* apex, struct xfrd_soa* new_soa)
+xfrd_send_notify(rbtree_type* tree, const dname_type* apex, struct xfrd_soa* new_soa)
 {
  /* lookup the zone */
- struct notify_zone_t* zone = (struct notify_zone_t*)
+ struct notify_zone* zone = (struct notify_zone*)
  rbtree_search(tree, apex);
  assert(zone);
  if(zone->notify_send_enable)
@@ -350,11 +351,11 @@ xfrd_send_notify(rbtree_t* tree, const dname_type* apex, struct xfrd_soa* new_so
 }
 
 void
-notify_handle_master_zone_soainfo(rbtree_t* tree,
+notify_handle_master_zone_soainfo(rbtree_type* tree,
  const dname_type* apex, struct xfrd_soa* new_soa)
 {
  /* lookup the zone */
- struct notify_zone_t* zone = (struct notify_zone_t*)
+ struct notify_zone* zone = (struct notify_zone*)
  rbtree_search(tree, apex);
  if(!zone) return; /* got SOAINFO but zone was deleted meanwhile */
 
@@ -368,10 +369,10 @@ notify_handle_master_zone_soainfo(rbtree_t* tree,
 }
 
 void
-close_notify_fds(rbtree_t* tree)
+close_notify_fds(rbtree_type* tree)
 {
- struct notify_zone_t* zone;
- RBTREE_FOR(zone, struct notify_zone_t*, tree)
+ struct notify_zone* zone;
+ RBTREE_FOR(zone, struct notify_zone*, tree)
  {
  if(zone->notify_send_enable)
  notify_send_disable(zone);
diff --git xfrd-notify.h xfrd-notify.h
index acda34308f3..153dca5129b 100644
--- xfrd-notify.h
+++ xfrd-notify.h
@@ -36,8 +36,8 @@ struct xfrd_state;
 /**
  * This struct keeps track of outbound notifies for a zone.
  */
-struct notify_zone_t {
- rbnode_t node;
+struct notify_zone {
+ rbnode_type node;
  /* name of the zone */
  const dname_type* apex;
  const char* apex_str;
@@ -59,30 +59,30 @@ struct notify_zone_t {
  /* is this notify waiting for a socket? */
  uint8_t is_waiting;
  /* the double linked waiting list for the udp sockets */
- struct notify_zone_t* waiting_next;
- struct notify_zone_t* waiting_prev;
+ struct notify_zone* waiting_next;
+ struct notify_zone* waiting_prev;
 };
 
 /* initialise outgoing notifies */
-void init_notify_send(rbtree_t* tree, region_type* region,
+void init_notify_send(rbtree_type* tree, region_type* region,
  struct zone_options* options);
 /* delete notify zone */
 void xfrd_del_notify(struct xfrd_state* xfrd, const dname_type* dname);
 
 /* send notifications to all in the notify list */
-void xfrd_send_notify(rbtree_t* tree, const struct dname* apex,
+void xfrd_send_notify(rbtree_type* tree, const struct dname* apex,
  struct xfrd_soa* new_soa);
 /* start notifications, if not started already (does not clobber SOA) */
-void xfrd_notify_start(struct notify_zone_t* zone, struct xfrd_state* xfrd);
+void xfrd_notify_start(struct notify_zone* zone, struct xfrd_state* xfrd);
 
 /* handle soa update notify for a master zone. newsoa can be NULL.
    Makes sure that the soa (serial) has changed. Or drops notify. */
-void notify_handle_master_zone_soainfo(rbtree_t* tree,
+void notify_handle_master_zone_soainfo(rbtree_type* tree,
  const dname_type* apex, struct xfrd_soa* new_soa);
 
 /* close fds in use for notification sending */
-void close_notify_fds(rbtree_t* tree);
+void close_notify_fds(rbtree_type* tree);
 /* stop send of notify */
-void notify_disable(struct notify_zone_t* zone);
+void notify_disable(struct notify_zone* zone);
 
 #endif /* XFRD_NOTIFY_H */
diff --git xfrd-tcp.c xfrd-tcp.c
index 506b2520589..70eef515b58 100644
--- xfrd-tcp.c
+++ xfrd-tcp.c
@@ -47,11 +47,12 @@ xfrd_pipe_cmp(const void* a, const void* b)
  return (uintptr_t)x < (uintptr_t)y ? -1 : 1;
 }
 
-xfrd_tcp_set_t* xfrd_tcp_set_create(struct region* region)
+struct xfrd_tcp_set* xfrd_tcp_set_create(struct region* region)
 {
  int i;
- xfrd_tcp_set_t* tcp_set = region_alloc(region, sizeof(xfrd_tcp_set_t));
- memset(tcp_set, 0, sizeof(xfrd_tcp_set_t));
+ struct xfrd_tcp_set* tcp_set = region_alloc(region,
+ sizeof(struct xfrd_tcp_set));
+ memset(tcp_set, 0, sizeof(struct xfrd_tcp_set));
  tcp_set->tcp_count = 0;
  tcp_set->tcp_waiting_first = 0;
  tcp_set->tcp_waiting_last = 0;
@@ -99,10 +100,10 @@ xfrd_setup_packet(buffer_type* packet,
 
 static socklen_t
 #ifdef INET6
-xfrd_acl_sockaddr(acl_options_t* acl, unsigned int port,
+xfrd_acl_sockaddr(acl_options_type* acl, unsigned int port,
  struct sockaddr_storage *sck)
 #else
-xfrd_acl_sockaddr(acl_options_t* acl, unsigned int port,
+xfrd_acl_sockaddr(acl_options_type* acl, unsigned int port,
  struct sockaddr_in *sck, const char* fromto)
 #endif /* INET6 */
 {
@@ -135,9 +136,9 @@ INET6.", fromto, acl->ip_address_spec);
 
 socklen_t
 #ifdef INET6
-xfrd_acl_sockaddr_to(acl_options_t* acl, struct sockaddr_storage *to)
+xfrd_acl_sockaddr_to(acl_options_type* acl, struct sockaddr_storage *to)
 #else
-xfrd_acl_sockaddr_to(acl_options_t* acl, struct sockaddr_in *to)
+xfrd_acl_sockaddr_to(acl_options_type* acl, struct sockaddr_in *to)
 #endif /* INET6 */
 {
  unsigned int port = acl->port?acl->port:(unsigned)atoi(TCP_PORT);
@@ -150,9 +151,9 @@ xfrd_acl_sockaddr_to(acl_options_t* acl, struct sockaddr_in *to)
 
 socklen_t
 #ifdef INET6
-xfrd_acl_sockaddr_frm(acl_options_t* acl, struct sockaddr_storage *frm)
+xfrd_acl_sockaddr_frm(acl_options_type* acl, struct sockaddr_storage *frm)
 #else
-xfrd_acl_sockaddr_frm(acl_options_t* acl, struct sockaddr_in *frm)
+xfrd_acl_sockaddr_frm(acl_options_type* acl, struct sockaddr_in *frm)
 #endif /* INET6 */
 {
  unsigned int port = acl->port?acl->port:0;
@@ -193,12 +194,12 @@ xfrd_write_soa_buffer(struct buffer* packet,
  buffer_write_u16_at(packet, rdlength_pos, rdlength);
 }
 
-xfrd_tcp_t*
+struct xfrd_tcp*
 xfrd_tcp_create(region_type* region, size_t bufsize)
 {
- xfrd_tcp_t* tcp_state = (xfrd_tcp_t*)region_alloc(
- region, sizeof(xfrd_tcp_t));
- memset(tcp_state, 0, sizeof(xfrd_tcp_t));
+ struct xfrd_tcp* tcp_state = (struct xfrd_tcp*)region_alloc(
+ region, sizeof(struct xfrd_tcp));
+ memset(tcp_state, 0, sizeof(struct xfrd_tcp));
  tcp_state->packet = buffer_create(region, bufsize);
  tcp_state->fd = -1;
 
@@ -206,9 +207,9 @@ xfrd_tcp_create(region_type* region, size_t bufsize)
 }
 
 static struct xfrd_tcp_pipeline*
-pipeline_find(xfrd_tcp_set_t* set, xfrd_zone_t* zone)
+pipeline_find(struct xfrd_tcp_set* set, xfrd_zone_type* zone)
 {
- rbnode_t* sme = NULL;
+ rbnode_type* sme = NULL;
  struct xfrd_tcp_pipeline* r;
  /* smaller buf than a full pipeline with 64kb ID array, only need
  * the front part with the key info, this front part contains the
@@ -243,7 +244,7 @@ pipeline_find(xfrd_tcp_set_t* set, xfrd_zone_t* zone)
 
 /* remove zone from tcp waiting list */
 static void
-tcp_zone_waiting_list_popfirst(xfrd_tcp_set_t* set, xfrd_zone_t* zone)
+tcp_zone_waiting_list_popfirst(struct xfrd_tcp_set* set, xfrd_zone_type* zone)
 {
  assert(zone->tcp_waiting);
  set->tcp_waiting_first = zone->tcp_waiting_next;
@@ -256,7 +257,7 @@ tcp_zone_waiting_list_popfirst(xfrd_tcp_set_t* set, xfrd_zone_t* zone)
 
 /* remove zone from tcp pipe write-wait list */
 static void
-tcp_pipe_sendlist_remove(struct xfrd_tcp_pipeline* tp, xfrd_zone_t* zone)
+tcp_pipe_sendlist_remove(struct xfrd_tcp_pipeline* tp, xfrd_zone_type* zone)
 {
  if(zone->in_tcp_send) {
  if(zone->tcp_send_prev)
@@ -271,7 +272,7 @@ tcp_pipe_sendlist_remove(struct xfrd_tcp_pipeline* tp, xfrd_zone_t* zone)
 
 /* remove first from write-wait list */
 static void
-tcp_pipe_sendlist_popfirst(struct xfrd_tcp_pipeline* tp, xfrd_zone_t* zone)
+tcp_pipe_sendlist_popfirst(struct xfrd_tcp_pipeline* tp, xfrd_zone_type* zone)
 {
  tp->tcp_send_first = zone->tcp_send_next;
  if(tp->tcp_send_first)
@@ -282,7 +283,7 @@ tcp_pipe_sendlist_popfirst(struct xfrd_tcp_pipeline* tp, xfrd_zone_t* zone)
 
 /* remove zone from tcp pipe ID map */
 static void
-tcp_pipe_id_remove(struct xfrd_tcp_pipeline* tp, xfrd_zone_t* zone)
+tcp_pipe_id_remove(struct xfrd_tcp_pipeline* tp, xfrd_zone_type* zone)
 {
  assert(tp->num_unused < ID_PIPE_NUM && tp->num_unused >= 0);
  assert(tp->id[zone->query_id] == zone);
@@ -305,7 +306,7 @@ xfrd_tcp_pipe_stop(struct xfrd_tcp_pipeline* tp)
  /* these could use different lists and go to a different nextmaster*/
  for(i=0; i<ID_PIPE_NUM; i++) {
  if(tp->id[i] && tp->id[i] != TCP_NULL_SKIP) {
- xfrd_zone_t* zone = tp->id[i];
+ xfrd_zone_type* zone = tp->id[i];
  conn = zone->tcp_conn;
  zone->tcp_conn = -1;
  zone->tcp_waiting = 0;
@@ -364,8 +365,8 @@ xfrd_handle_tcp_pipe(int ATTR_UNUSED(fd), short event, void* arg)
 
 /* add a zone to the pipeline, it starts to want to write its query */
 static void
-pipeline_setup_new_zone(xfrd_tcp_set_t* set, struct xfrd_tcp_pipeline* tp,
- xfrd_zone_t* zone)
+pipeline_setup_new_zone(struct xfrd_tcp_set* set, struct xfrd_tcp_pipeline* tp,
+ xfrd_zone_type* zone)
 {
  /* assign the ID */
  int idx;
@@ -398,7 +399,7 @@ pipeline_setup_new_zone(xfrd_tcp_set_t* set, struct xfrd_tcp_pipeline* tp,
 }
 
 void
-xfrd_tcp_obtain(xfrd_tcp_set_t* set, xfrd_zone_t* zone)
+xfrd_tcp_obtain(struct xfrd_tcp_set* set, xfrd_zone_type* zone)
 {
  struct xfrd_tcp_pipeline* tp;
  assert(zone->tcp_conn == -1);
@@ -484,8 +485,8 @@ xfrd_tcp_obtain(xfrd_tcp_set_t* set, xfrd_zone_t* zone)
 }
 
 int
-xfrd_tcp_open(xfrd_tcp_set_t* set, struct xfrd_tcp_pipeline* tp,
- xfrd_zone_t* zone)
+xfrd_tcp_open(struct xfrd_tcp_set* set, struct xfrd_tcp_pipeline* tp,
+ xfrd_zone_type* zone)
 {
  int fd, family, conn;
  struct timeval tv;
@@ -521,7 +522,10 @@ xfrd_tcp_open(xfrd_tcp_set_t* set, struct xfrd_tcp_pipeline* tp,
  }
  fd = socket(family, SOCK_STREAM, IPPROTO_TCP);
  if(fd == -1) {
- log_msg(LOG_ERR, "xfrd: %s cannot create tcp socket: %s",
+ /* squelch 'Address family not supported by protocol' at low
+ * verbosity levels */
+ if(errno != EAFNOSUPPORT || verbosity > 2)
+    log_msg(LOG_ERR, "xfrd: %s cannot create tcp socket: %s",
  zone->master->ip_address_spec, strerror(errno));
  xfrd_set_refresh_now(zone);
  return 0;
@@ -583,9 +587,9 @@ xfrd_tcp_open(xfrd_tcp_set_t* set, struct xfrd_tcp_pipeline* tp,
 }
 
 void
-xfrd_tcp_setup_write_packet(struct xfrd_tcp_pipeline* tp, xfrd_zone_t* zone)
+xfrd_tcp_setup_write_packet(struct xfrd_tcp_pipeline* tp, xfrd_zone_type* zone)
 {
- xfrd_tcp_t* tcp = tp->tcp_w;
+ struct xfrd_tcp* tcp = tp->tcp_w;
  assert(zone->tcp_conn != -1);
  assert(zone->tcp_waiting == 0);
  /* start AXFR or IXFR for the zone */
@@ -625,14 +629,14 @@ xfrd_tcp_setup_write_packet(struct xfrd_tcp_pipeline* tp, xfrd_zone_t* zone)
 }
 
 static void
-tcp_conn_ready_for_reading(xfrd_tcp_t* tcp)
+tcp_conn_ready_for_reading(struct xfrd_tcp* tcp)
 {
  tcp->total_bytes = 0;
  tcp->msglen = 0;
  buffer_clear(tcp->packet);
 }
 
-int conn_write(xfrd_tcp_t* tcp)
+int conn_write(struct xfrd_tcp* tcp)
 {
  ssize_t sent;
 
@@ -686,10 +690,10 @@ int conn_write(xfrd_tcp_t* tcp)
 }
 
 void
-xfrd_tcp_write(struct xfrd_tcp_pipeline* tp, xfrd_zone_t* zone)
+xfrd_tcp_write(struct xfrd_tcp_pipeline* tp, xfrd_zone_type* zone)
 {
  int ret;
- xfrd_tcp_t* tcp = tp->tcp_w;
+ struct xfrd_tcp* tcp = tp->tcp_w;
  assert(zone->tcp_conn != -1);
  assert(zone == tp->tcp_send_first);
  /* see if for non-established connection, there is a connect error */
@@ -752,7 +756,7 @@ xfrd_tcp_write(struct xfrd_tcp_pipeline* tp, xfrd_zone_t* zone)
 }
 
 int
-conn_read(xfrd_tcp_t* tcp)
+conn_read(struct xfrd_tcp* tcp)
 {
  ssize_t received;
  /* receive leading packet length bytes */
@@ -831,8 +835,8 @@ conn_read(xfrd_tcp_t* tcp)
 void
 xfrd_tcp_read(struct xfrd_tcp_pipeline* tp)
 {
- xfrd_zone_t* zone;
- xfrd_tcp_t* tcp = tp->tcp_r;
+ xfrd_zone_type* zone;
+ struct xfrd_tcp* tcp = tp->tcp_r;
  int ret;
  enum xfrd_packet_result pkt_result;
 
@@ -906,7 +910,7 @@ xfrd_tcp_read(struct xfrd_tcp_pipeline* tp)
 }
 
 void
-xfrd_tcp_release(xfrd_tcp_set_t* set, xfrd_zone_t* zone)
+xfrd_tcp_release(struct xfrd_tcp_set* set, xfrd_zone_type* zone)
 {
  int conn = zone->tcp_conn;
  struct xfrd_tcp_pipeline* tp = set->tcp_state[conn];
@@ -955,7 +959,7 @@ xfrd_tcp_release(xfrd_tcp_set_t* set, xfrd_zone_t* zone)
 }
 
 void
-xfrd_tcp_pipe_release(xfrd_tcp_set_t* set, struct xfrd_tcp_pipeline* tp,
+xfrd_tcp_pipe_release(struct xfrd_tcp_set* set, struct xfrd_tcp_pipeline* tp,
  int conn)
 {
  DEBUG(DEBUG_XFRD,1, (LOG_INFO, "xfrd: tcp pipe released"));
@@ -980,7 +984,7 @@ xfrd_tcp_pipe_release(xfrd_tcp_set_t* set, struct xfrd_tcp_pipeline* tp,
  int i;
 
  /* pop first waiting process */
- xfrd_zone_t* zone = set->tcp_waiting_first;
+ xfrd_zone_type* zone = set->tcp_waiting_first;
  /* start it */
  assert(zone->tcp_conn == -1);
  zone->tcp_conn = conn;
diff --git xfrd-tcp.h xfrd-tcp.h
index ac3f9dc5aab..fd6918768d9 100644
--- xfrd-tcp.h
+++ xfrd-tcp.h
@@ -21,8 +21,8 @@ struct dname;
 struct acl_options;
 
 struct xfrd_tcp_pipeline;
-typedef struct xfrd_tcp xfrd_tcp_t;
-typedef struct xfrd_tcp_set xfrd_tcp_set_t;
+typedef struct xfrd_tcp xfrd_tcp_type;
+typedef struct xfrd_tcp_set xfrd_tcp_set_type;
 /*
  * A set of xfrd tcp connections.
  */
@@ -34,7 +34,7 @@ struct xfrd_tcp_set {
  /* TCP timeout. */
  int tcp_timeout;
  /* rbtree with pipelines sorted by master */
- rbtree_t* pipetree;
+ rbtree_type* pipetree;
  /* double linked list of zones waiting for a TCP connection */
  struct xfrd_zone *tcp_waiting_first, *tcp_waiting_last;
 };
@@ -78,7 +78,7 @@ struct xfrd_tcp {
  */
 struct xfrd_tcp_pipeline {
  /* the rbtree node, sorted by IP and nr of unused queries */
- rbnode_t node;
+ rbnode_type node;
  /* destination IP address */
 #ifdef INET6
  struct sockaddr_storage ip;
@@ -99,10 +99,10 @@ struct xfrd_tcp_pipeline {
  struct event handler;
 
  /* the tcp connection to use for reading */
- xfrd_tcp_t* tcp_r;
+ struct xfrd_tcp* tcp_r;
  /* the tcp connection to use for writing, if it is done successfully,
  * then the first zone from the sendlist can be removed. */
- xfrd_tcp_t* tcp_w;
+ struct xfrd_tcp* tcp_w;
  /* once a byte has been written, handshake complete */
  int connection_established;
 
@@ -125,22 +125,23 @@ struct xfrd_tcp_pipeline {
 };
 
 /* create set of tcp connections */
-xfrd_tcp_set_t* xfrd_tcp_set_create(struct region* region);
+struct xfrd_tcp_set* xfrd_tcp_set_create(struct region* region);
 
 /* init tcp state */
-xfrd_tcp_t* xfrd_tcp_create(struct region* region, size_t bufsize);
+struct xfrd_tcp* xfrd_tcp_create(struct region* region, size_t bufsize);
 /* obtain tcp connection for a zone (or wait) */
-void xfrd_tcp_obtain(xfrd_tcp_set_t* set, struct xfrd_zone* zone);
+void xfrd_tcp_obtain(struct xfrd_tcp_set* set, struct xfrd_zone* zone);
 /* release tcp connection for a zone (starts waiting) */
-void xfrd_tcp_release(xfrd_tcp_set_t* set, struct xfrd_zone* zone);
+void xfrd_tcp_release(struct xfrd_tcp_set* set, struct xfrd_zone* zone);
 /* release tcp pipe entirely (does not stop the zones inside it) */
-void xfrd_tcp_pipe_release(xfrd_tcp_set_t* set, struct xfrd_tcp_pipeline* tp,
- int conn);
+void xfrd_tcp_pipe_release(struct xfrd_tcp_set* set,
+ struct xfrd_tcp_pipeline* tp, int conn);
 /* use tcp connection to start xfr */
 void xfrd_tcp_setup_write_packet(struct xfrd_tcp_pipeline* tp,
  struct xfrd_zone* zone);
 /* initialize tcp_state for a zone. Opens the connection. true on success.*/
-int xfrd_tcp_open(xfrd_tcp_set_t* set, struct xfrd_tcp_pipeline* tp, struct xfrd_zone* zone);
+int xfrd_tcp_open(struct xfrd_tcp_set* set, struct xfrd_tcp_pipeline* tp,
+ struct xfrd_zone* zone);
 /* read data from tcp, maybe partial read */
 void xfrd_tcp_read(struct xfrd_tcp_pipeline* tp);
 /* write data to tcp, maybe a partial write */
@@ -157,7 +158,7 @@ void xfrd_handle_tcp_pipe(int fd, short event, void* arg);
  * On first call, make sure total_bytes = 0, msglen=0, buffer_clear().
  * and the packet and fd need to be set.
  */
-int conn_read(xfrd_tcp_t* conn);
+int conn_read(struct xfrd_tcp* conn);
 /*
  * Write to a stream connection (size16)+packet.
  * return value is
@@ -165,7 +166,7 @@ int conn_read(xfrd_tcp_t* conn);
  * On first call, make sure total_bytes=0, msglen=buffer_limit(),
  * buffer_flipped(). packet and fd need to be set.
  */
-int conn_write(xfrd_tcp_t* conn);
+int conn_write(struct xfrd_tcp* conn);
 
 /* setup DNS packet for a query of this type */
 void xfrd_setup_packet(struct buffer* packet,
diff --git xfrd.c xfrd.c
index 415602f014b..810ee3e2954 100644
--- xfrd.c
+++ xfrd.c
@@ -42,7 +42,7 @@
  * was lost, and need waitpid to remove their process entry. */
 
 /* the daemon state */
-xfrd_state_t* xfrd = 0;
+xfrd_state_type* xfrd = 0;
 
 /* main xfrd loop */
 static void xfrd_main(void);
@@ -56,16 +56,18 @@ static void xfrd_init_zones(void);
 static void xfrd_receive_soa(int socket, int shortsoa);
 
 /* handle incoming notification message. soa can be NULL. true if transfer needed. */
-static int xfrd_handle_incoming_notify(xfrd_zone_t* zone, xfrd_soa_t* soa);
+static int xfrd_handle_incoming_notify(xfrd_zone_type* zone,
+ xfrd_soa_type* soa);
 
 /* call with buffer just after the soa dname. returns 0 on error. */
-static int xfrd_parse_soa_info(buffer_type* packet, xfrd_soa_t* soa);
+static int xfrd_parse_soa_info(buffer_type* packet, xfrd_soa_type* soa);
 /* set the zone state to a new state (takes care of expiry messages) */
-static void xfrd_set_zone_state(xfrd_zone_t* zone, enum xfrd_zone_state new_zone_state);
+static void xfrd_set_zone_state(xfrd_zone_type* zone,
+ enum xfrd_zone_state new_zone_state);
 /* set timer for retry amount (depends on zone_state) */
-static void xfrd_set_timer_retry(xfrd_zone_t* zone);
+static void xfrd_set_timer_retry(xfrd_zone_type* zone);
 /* set timer for refresh timeout (depends on zone_state) */
-static void xfrd_set_timer_refresh(xfrd_zone_t* zone);
+static void xfrd_set_timer_refresh(xfrd_zone_type* zone);
 
 /* set reload timeout */
 static void xfrd_set_reload_timeout(void);
@@ -75,15 +77,15 @@ static void xfrd_handle_reload(int fd, short event, void* arg);
 static void xfrd_handle_child_timer(int fd, short event, void* arg);
 
 /* send ixfr request, returns fd of connection to read on */
-static int xfrd_send_ixfr_request_udp(xfrd_zone_t* zone);
+static int xfrd_send_ixfr_request_udp(xfrd_zone_type* zone);
 /* obtain udp socket slot */
-static void xfrd_udp_obtain(xfrd_zone_t* zone);
+static void xfrd_udp_obtain(xfrd_zone_type* zone);
 
 /* read data via udp */
-static void xfrd_udp_read(xfrd_zone_t* zone);
+static void xfrd_udp_read(xfrd_zone_type* zone);
 
 /* find master by notify number */
-static int find_same_master_notify(xfrd_zone_t* zone, int acl_num_nfy);
+static int find_same_master_notify(xfrd_zone_type* zone, int acl_num_nfy);
 
 /* set the write timer to activate */
 static void xfrd_write_timer_set(void);
@@ -122,8 +124,8 @@ xfrd_init(int socket, struct nsd* nsd, int shortsoa, int reload_active,
 
  region = region_create_custom(xalloc, free, DEFAULT_CHUNK_SIZE,
  DEFAULT_LARGE_OBJECT_SIZE, DEFAULT_INITIAL_CLEANUP_SIZE, 1);
- xfrd = (xfrd_state_t*)region_alloc(region, sizeof(xfrd_state_t));
- memset(xfrd, 0, sizeof(xfrd_state_t));
+ xfrd = (xfrd_state_type*)region_alloc(region, sizeof(xfrd_state_type));
+ memset(xfrd, 0, sizeof(xfrd_state_type));
  xfrd->region = region;
  xfrd->xfrd_start_time = time(0);
  xfrd->event_base = nsd_child_event_base();
@@ -221,7 +223,7 @@ xfrd_init(int socket, struct nsd* nsd, int shortsoa, int reload_active,
 static void
 xfrd_process_activated(void)
 {
- xfrd_zone_t* zone;
+ xfrd_zone_type* zone;
  while((zone = xfrd->activated_first)) {
  DEBUG(DEBUG_XFRD,1, (LOG_INFO, "xfrd zone %s activation",
  zone->apex_str));
@@ -314,7 +316,7 @@ xfrd_main(void)
 static void
 xfrd_shutdown()
 {
- xfrd_zone_t* zone;
+ xfrd_zone_type* zone;
 
  DEBUG(DEBUG_XFRD,1, (LOG_INFO, "xfrd shutdown"));
  event_del(&xfrd->ipc_handler);
@@ -336,7 +338,7 @@ xfrd_shutdown()
  daemon_remote_close(xfrd->nsd->rc); /* close sockets of rc */
 #endif
  /* close sockets */
- RBTREE_FOR(zone, xfrd_zone_t*, xfrd->zones)
+ RBTREE_FOR(zone, xfrd_zone_type*, xfrd->zones)
  {
  if(zone->event_added) {
  event_del(&zone->zone_handler);
@@ -369,7 +371,7 @@ xfrd_shutdown()
  * to clean them out */
 
  /* unlink xfr files for running transfers */
- RBTREE_FOR(zone, xfrd_zone_t*, xfrd->zones)
+ RBTREE_FOR(zone, xfrd_zone_type*, xfrd->zones)
  {
  if(zone->msg_seq_nr)
  xfrd_unlink_xfrfile(xfrd->nsd, zone->xfrfilenumber);
@@ -400,11 +402,12 @@ xfrd_clean_pending_tasks(struct nsd* nsd, udb_base* u)
 }
 
 void
-xfrd_init_slave_zone(xfrd_state_t* xfrd, zone_options_t* zone_opt)
+xfrd_init_slave_zone(xfrd_state_type* xfrd, struct zone_options* zone_opt)
 {
- xfrd_zone_t *xzone;
- xzone = (xfrd_zone_t*)region_alloc(xfrd->region, sizeof(xfrd_zone_t));
- memset(xzone, 0, sizeof(xfrd_zone_t));
+ xfrd_zone_type *xzone;
+ xzone = (xfrd_zone_type*)region_alloc(xfrd->region,
+ sizeof(xfrd_zone_type));
+ memset(xzone, 0, sizeof(xfrd_zone_type));
  xzone->apex = zone_opt->node.key;
  xzone->apex_str = zone_opt->name;
  xzone->state = xfrd_zone_refreshing;
@@ -443,13 +446,13 @@ xfrd_init_slave_zone(xfrd_state_t* xfrd, zone_options_t* zone_opt)
  xfrd_set_refresh_now(xzone);
 
  xzone->node.key = xzone->apex;
- rbtree_insert(xfrd->zones, (rbnode_t*)xzone);
+ rbtree_insert(xfrd->zones, (rbnode_type*)xzone);
 }
 
 static void
 xfrd_init_zones()
 {
- zone_options_t *zone_opt;
+ struct zone_options *zone_opt;
  assert(xfrd->zones == 0);
 
  xfrd->zones = rbtree_create(xfrd->region,
@@ -457,7 +460,7 @@ xfrd_init_zones()
  xfrd->notify_zones = rbtree_create(xfrd->region,
  (int (*)(const void *, const void *)) dname_compare);
 
- RBTREE_FOR(zone_opt, zone_options_t*, xfrd->nsd->options->zone_options)
+ RBTREE_FOR(zone_opt, struct zone_options*, xfrd->nsd->options->zone_options)
  {
  DEBUG(DEBUG_XFRD,1, (LOG_INFO, "xfrd: adding %s zone",
  zone_opt->name));
@@ -478,12 +481,12 @@ xfrd_init_zones()
 static void
 xfrd_process_soa_info_task(struct task_list_d* task)
 {
- xfrd_soa_t soa;
- xfrd_soa_t* soa_ptr = &soa;
- xfrd_zone_t* zone;
+ xfrd_soa_type soa;
+ xfrd_soa_type* soa_ptr = &soa;
+ xfrd_zone_type* zone;
  DEBUG(DEBUG_IPC,1, (LOG_INFO, "xfrd: process SOAINFO %s",
  dname_to_string(task->zname, 0)));
- zone = (xfrd_zone_t*)rbtree_search(xfrd->zones, task->zname);
+ zone = (xfrd_zone_type*)rbtree_search(xfrd->zones, task->zname);
  if(task->size <= sizeof(struct task_list_d)+dname_total_size(
  task->zname)+sizeof(uint32_t)*6 + sizeof(uint8_t)*2) {
  /* NSD has zone without any info */
@@ -540,12 +543,12 @@ xfrd_receive_soa(int socket, int shortsoa)
  sig_atomic_t cmd;
  struct udb_base* xtask = xfrd->nsd->task[xfrd->nsd->mytask];
  udb_ptr last_task, t;
- xfrd_zone_t* zone;
+ xfrd_zone_type* zone;
 
  if(!shortsoa) {
  /* put all expired zones into mytask */
  udb_ptr_init(&last_task, xtask);
- RBTREE_FOR(zone, xfrd_zone_t*, xfrd->zones) {
+ RBTREE_FOR(zone, xfrd_zone_type*, xfrd->zones) {
  if(zone->state == xfrd_zone_expired) {
  task_new_expire(xtask, &last_task, zone->apex, 1);
  }
@@ -605,7 +608,7 @@ xfrd_receive_soa(int socket, int shortsoa)
  /* for shortsoa version, do expire later */
  /* if expire notifications, put in my task and
  * schedule a reload to make sure they are processed */
- RBTREE_FOR(zone, xfrd_zone_t*, xfrd->zones) {
+ RBTREE_FOR(zone, xfrd_zone_type*, xfrd->zones) {
  if(zone->state == xfrd_zone_expired) {
  xfrd_send_expire_notification(zone);
  }
@@ -621,7 +624,7 @@ xfrd_reopen_logfile(void)
 }
 
 void
-xfrd_deactivate_zone(xfrd_zone_t* z)
+xfrd_deactivate_zone(xfrd_zone_type* z)
 {
  if(z->is_activated) {
  /* delete from activated list */
@@ -635,9 +638,9 @@ xfrd_deactivate_zone(xfrd_zone_t* z)
 }
 
 void
-xfrd_del_slave_zone(xfrd_state_t* xfrd, const dname_type* dname)
+xfrd_del_slave_zone(xfrd_state_type* xfrd, const dname_type* dname)
 {
- xfrd_zone_t* z = (xfrd_zone_t*)rbtree_delete(xfrd->zones, dname);
+ xfrd_zone_type* z = (xfrd_zone_type*)rbtree_delete(xfrd->zones, dname);
  if(!z) return;
 
  /* io */
@@ -691,7 +694,7 @@ xfrd_free_namedb(struct nsd* nsd)
 }
 
 static void
-xfrd_set_timer_refresh(xfrd_zone_t* zone)
+xfrd_set_timer_refresh(xfrd_zone_type* zone)
 {
  time_t set_refresh;
  time_t set_expire;
@@ -722,7 +725,7 @@ xfrd_set_timer_refresh(xfrd_zone_t* zone)
 }
 
 static void
-xfrd_set_timer_retry(xfrd_zone_t* zone)
+xfrd_set_timer_retry(xfrd_zone_type* zone)
 {
  time_t set_retry;
  int mult;
@@ -782,7 +785,7 @@ xfrd_set_timer_retry(xfrd_zone_t* zone)
 void
 xfrd_handle_zone(int ATTR_UNUSED(fd), short event, void* arg)
 {
- xfrd_zone_t* zone = (xfrd_zone_t*)arg;
+ xfrd_zone_type* zone = (xfrd_zone_type*)arg;
 
  if(zone->tcp_conn != -1) {
  if(event == 0) /* activated, but already in TCP, nothing to do*/
@@ -846,7 +849,7 @@ xfrd_handle_zone(int ATTR_UNUSED(fd), short event, void* arg)
 }
 
 void
-xfrd_make_request(xfrd_zone_t* zone)
+xfrd_make_request(xfrd_zone_type* zone)
 {
  if(zone->next_master != -1) {
  /* we are told to use this next master */
@@ -954,7 +957,7 @@ xfrd_make_request(xfrd_zone_t* zone)
 }
 
 static void
-xfrd_udp_obtain(xfrd_zone_t* zone)
+xfrd_udp_obtain(xfrd_zone_type* zone)
 {
  assert(zone->udp_waiting == 0);
  if(zone->tcp_conn != -1) {
@@ -1005,7 +1008,7 @@ xfrd_time()
 }
 
 void
-xfrd_copy_soa(xfrd_soa_t* soa, rr_type* rr)
+xfrd_copy_soa(xfrd_soa_type* soa, rr_type* rr)
 {
  const uint8_t* rr_ns_wire = dname_name(domain_dname(rdata_atom_domain(rr->rdatas[0])));
  uint8_t rr_ns_len = domain_dname(rdata_atom_domain(rr->rdatas[0]))->name_size;
@@ -1043,7 +1046,7 @@ xfrd_copy_soa(xfrd_soa_t* soa, rr_type* rr)
 }
 
 static void
-xfrd_set_zone_state(xfrd_zone_t* zone, enum xfrd_zone_state s)
+xfrd_set_zone_state(xfrd_zone_type* zone, enum xfrd_zone_state s)
 {
  if(s != zone->state) {
  enum xfrd_zone_state old = zone->state;
@@ -1056,7 +1059,7 @@ xfrd_set_zone_state(xfrd_zone_t* zone, enum xfrd_zone_state s)
 }
 
 void
-xfrd_set_refresh_now(xfrd_zone_t* zone)
+xfrd_set_refresh_now(xfrd_zone_type* zone)
 {
  DEBUG(DEBUG_XFRD,1, (LOG_INFO, "xfrd zone %s is activated, state %d",
  zone->apex_str, zone->state));
@@ -1072,7 +1075,7 @@ xfrd_set_refresh_now(xfrd_zone_t* zone)
 }
 
 void
-xfrd_unset_timer(xfrd_zone_t* zone)
+xfrd_unset_timer(xfrd_zone_type* zone)
 {
  assert(zone->zone_handler.ev_fd == -1);
  if(zone->event_added)
@@ -1082,7 +1085,7 @@ xfrd_unset_timer(xfrd_zone_t* zone)
 }
 
 void
-xfrd_set_timer(xfrd_zone_t* zone, time_t t)
+xfrd_set_timer(xfrd_zone_type* zone, time_t t)
 {
  int fd = zone->zone_handler.ev_fd;
  int fl = ((fd == -1)?EV_TIMEOUT:zone->zone_handler_flags);
@@ -1116,8 +1119,8 @@ xfrd_set_timer(xfrd_zone_t* zone, time_t t)
 }
 
 void
-xfrd_handle_incoming_soa(xfrd_zone_t* zone,
- xfrd_soa_t* soa, time_t acquired)
+xfrd_handle_incoming_soa(xfrd_zone_type* zone,
+ xfrd_soa_type* soa, time_t acquired)
 {
  if(soa == NULL) {
  /* nsd no longer has a zone in memory */
@@ -1199,7 +1202,7 @@ xfrd_handle_incoming_soa(xfrd_zone_t* zone,
 }
 
 void
-xfrd_send_expire_notification(xfrd_zone_t* zone)
+xfrd_send_expire_notification(xfrd_zone_type* zone)
 {
  task_new_expire(xfrd->nsd->task[xfrd->nsd->mytask], xfrd->last_task,
  zone->apex, zone->state == xfrd_zone_expired);
@@ -1225,7 +1228,7 @@ xfrd_udp_read_packet(buffer_type* packet, int fd)
 }
 
 void
-xfrd_udp_release(xfrd_zone_t* zone)
+xfrd_udp_release(xfrd_zone_type* zone)
 {
  assert(zone->udp_waiting == 0);
  if(zone->event_added)
@@ -1241,7 +1244,7 @@ xfrd_udp_release(xfrd_zone_t* zone)
  {
  while(xfrd->udp_waiting_first) {
  /* snip off waiting list */
- xfrd_zone_t* wz = xfrd->udp_waiting_first;
+ xfrd_zone_type* wz = xfrd->udp_waiting_first;
  assert(wz->udp_waiting);
  wz->udp_waiting = 0;
  xfrd->udp_waiting_first = wz->udp_waiting_next;
@@ -1281,7 +1284,7 @@ xfrd_udp_release(xfrd_zone_t* zone)
 
 /** disable ixfr for master */
 void
-xfrd_disable_ixfr(xfrd_zone_t* zone)
+xfrd_disable_ixfr(xfrd_zone_type* zone)
 {
  if(!(zone->master->ixfr_disabled &&
  (zone->master->ixfr_disabled + XFRD_NO_IXFR_CACHE) <= time(NULL))) {
@@ -1293,7 +1296,7 @@ xfrd_disable_ixfr(xfrd_zone_t* zone)
 }
 
 static void
-xfrd_udp_read(xfrd_zone_t* zone)
+xfrd_udp_read(xfrd_zone_type* zone)
 {
  DEBUG(DEBUG_XFRD,1, (LOG_INFO, "xfrd: zone %s read udp data", zone->apex_str));
  if(!xfrd_udp_read_packet(xfrd->packet, zone->zone_handler.ev_fd)) {
@@ -1355,7 +1358,8 @@ xfrd_udp_read(xfrd_zone_t* zone)
 }
 
 int
-xfrd_send_udp(acl_options_t* acl, buffer_type* packet, acl_options_t* ifc)
+xfrd_send_udp(struct acl_options* acl, buffer_type* packet,
+ struct acl_options* ifc)
 {
 #ifdef INET6
  struct sockaddr_storage to;
@@ -1409,8 +1413,8 @@ xfrd_send_udp(acl_options_t* acl, buffer_type* packet, acl_options_t* ifc)
 }
 
 int
-xfrd_bind_local_interface(int sockd, acl_options_t* ifc, acl_options_t* acl,
- int tcp)
+xfrd_bind_local_interface(int sockd, struct acl_options* ifc,
+ struct acl_options* acl, int tcp)
 {
 #ifdef SO_LINGER
  struct linger linger = {1, 0};
@@ -1487,7 +1491,7 @@ xfrd_bind_local_interface(int sockd, acl_options_t* ifc, acl_options_t* acl,
 
 void
 xfrd_tsig_sign_request(buffer_type* packet, tsig_record_type* tsig,
- acl_options_t* acl)
+ struct acl_options* acl)
 {
  tsig_algorithm_type* algo;
  assert(acl->key_options && acl->key_options->tsig_key);
@@ -1511,7 +1515,7 @@ xfrd_tsig_sign_request(buffer_type* packet, tsig_record_type* tsig,
 }
 
 static int
-xfrd_send_ixfr_request_udp(xfrd_zone_t* zone)
+xfrd_send_ixfr_request_udp(xfrd_zone_type* zone)
 {
  int fd;
 
@@ -1553,7 +1557,7 @@ xfrd_send_ixfr_request_udp(xfrd_zone_t* zone)
  return fd;
 }
 
-static int xfrd_parse_soa_info(buffer_type* packet, xfrd_soa_t* soa)
+static int xfrd_parse_soa_info(buffer_type* packet, xfrd_soa_type* soa)
 {
  if(!buffer_available(packet, 10))
  return 0;
@@ -1590,8 +1594,8 @@ static int xfrd_parse_soa_info(buffer_type* packet, xfrd_soa_t* soa)
  * (soa contents is modified by the routine)
  */
 static int
-xfrd_xfr_check_rrs(xfrd_zone_t* zone, buffer_type* packet, size_t count,
- int *done, xfrd_soa_t* soa, region_type* temp)
+xfrd_xfr_check_rrs(xfrd_zone_type* zone, buffer_type* packet, size_t count,
+ int *done, xfrd_soa_type* soa, region_type* temp)
 {
  /* first RR has already been checked */
  uint32_t tmp_serial = 0;
@@ -1697,7 +1701,7 @@ xfrd_xfr_check_rrs(xfrd_zone_t* zone, buffer_type* packet, size_t count,
 }
 
 static int
-xfrd_xfr_process_tsig(xfrd_zone_t* zone, buffer_type* packet)
+xfrd_xfr_process_tsig(xfrd_zone_type* zone, buffer_type* packet)
 {
  int have_tsig = 0;
  assert(zone && zone->master && zone->master->key_options
@@ -1753,8 +1757,8 @@ xfrd_xfr_process_tsig(xfrd_zone_t* zone, buffer_type* packet)
 
 /* parse the received packet. returns xfrd packet result code. */
 static enum xfrd_packet_result
-xfrd_parse_received_xfr_packet(xfrd_zone_t* zone, buffer_type* packet,
- xfrd_soa_t* soa)
+xfrd_parse_received_xfr_packet(xfrd_zone_type* zone, buffer_type* packet,
+ xfrd_soa_type* soa)
 {
  size_t rr_count;
  size_t qdcount = QDCOUNT(packet);
@@ -1981,9 +1985,9 @@ xfrd_pretty_time(time_t v)
 }
 
 enum xfrd_packet_result
-xfrd_handle_received_xfr_packet(xfrd_zone_t* zone, buffer_type* packet)
+xfrd_handle_received_xfr_packet(xfrd_zone_type* zone, buffer_type* packet)
 {
- xfrd_soa_t soa;
+ xfrd_soa_type soa;
  enum xfrd_packet_result res;
         uint64_t xfrfile_size;
 
@@ -2168,7 +2172,7 @@ xfrd_handle_reload(int ATTR_UNUSED(fd), short event, void* ATTR_UNUSED(arg))
 }
 
 void
-xfrd_handle_notify_and_start_xfr(xfrd_zone_t* zone, xfrd_soa_t* soa)
+xfrd_handle_notify_and_start_xfr(xfrd_zone_type* zone, xfrd_soa_type* soa)
 {
  if(xfrd_handle_incoming_notify(zone, soa)) {
  if(zone->zone_handler.ev_fd == -1 && zone->tcp_conn == -1 &&
@@ -2191,7 +2195,7 @@ xfrd_handle_passed_packet(buffer_type* packet,
  uint16_t qtype, qclass;
  const dname_type* dname;
  region_type* tempregion = region_create(xalloc, free);
- xfrd_zone_t* zone;
+ xfrd_zone_type* zone;
 
  buffer_skip(packet, QHEADERSZ);
  if(!packet_read_query_section(packet, qnamebuf, &qtype, &qclass)) {
@@ -2204,7 +2208,7 @@ xfrd_handle_passed_packet(buffer_type* packet,
    "%d", dname_to_string(dname,0), acl_num));
 
  /* find the zone */
- zone = (xfrd_zone_t*)rbtree_search(xfrd->zones, dname);
+ zone = (xfrd_zone_type*)rbtree_search(xfrd->zones, dname);
  if(!zone) {
  /* this could be because the zone has been deleted meanwhile */
  DEBUG(DEBUG_XFRD, 1, (LOG_INFO, "xfrd: incoming packet for "
@@ -2216,7 +2220,7 @@ xfrd_handle_passed_packet(buffer_type* packet,
 
  /* handle */
  if(OPCODE(packet) == OPCODE_NOTIFY) {
- xfrd_soa_t soa;
+ xfrd_soa_type soa;
  int have_soa = 0;
  int next;
  /* get serial from a SOA */
@@ -2244,7 +2248,7 @@ xfrd_handle_passed_packet(buffer_type* packet,
 }
 
 static int
-xfrd_handle_incoming_notify(xfrd_zone_t* zone, xfrd_soa_t* soa)
+xfrd_handle_incoming_notify(xfrd_zone_type* zone, xfrd_soa_type* soa)
 {
  if(soa && zone->soa_disk_acquired && zone->state != xfrd_zone_expired &&
    compare_serial(ntohl(soa->serial),ntohl(zone->soa_disk.serial)) <= 0)
@@ -2277,12 +2281,12 @@ xfrd_handle_incoming_notify(xfrd_zone_t* zone, xfrd_soa_t* soa)
 }
 
 static int
-find_same_master_notify(xfrd_zone_t* zone, int acl_num_nfy)
+find_same_master_notify(xfrd_zone_type* zone, int acl_num_nfy)
 {
- acl_options_t* nfy_acl = acl_find_num(zone->zone_options->pattern->
+ struct acl_options* nfy_acl = acl_find_num(zone->zone_options->pattern->
  allow_notify, acl_num_nfy);
  int num = 0;
- acl_options_t* master = zone->zone_options->pattern->request_xfr;
+ struct acl_options* master = zone->zone_options->pattern->request_xfr;
  if(!nfy_acl)
  return -1;
  while(master)
@@ -2299,8 +2303,8 @@ void
 xfrd_check_failed_updates()
 {
  /* see if updates have not come through */
- xfrd_zone_t* zone;
- RBTREE_FOR(zone, xfrd_zone_t*, xfrd->zones)
+ xfrd_zone_type* zone;
+ RBTREE_FOR(zone, xfrd_zone_type*, xfrd->zones)
  {
  /* zone has a disk soa, and no nsd soa or a different nsd soa */
  if(zone->soa_disk_acquired != 0 &&
@@ -2312,7 +2316,7 @@ xfrd_check_failed_updates()
  {
  /* this zone should have been loaded, since its disk
    soa time is before the time of the reload cmd. */
- xfrd_soa_t dumped_soa = zone->soa_disk;
+ xfrd_soa_type dumped_soa = zone->soa_disk;
  log_msg(LOG_ERR, "xfrd: zone %s: soa serial %u "
  "update failed, restarting "
  "transfer (notified zone)",
@@ -2351,8 +2355,8 @@ xfrd_check_failed_updates()
 void
 xfrd_prepare_zones_for_reload()
 {
- xfrd_zone_t* zone;
- RBTREE_FOR(zone, xfrd_zone_t*, xfrd->zones)
+ xfrd_zone_type* zone;
+ RBTREE_FOR(zone, xfrd_zone_type*, xfrd->zones)
  {
  /* zone has a disk soa, and no nsd soa or a different nsd soa */
  if(zone->soa_disk_acquired != 0 &&
@@ -2380,10 +2384,10 @@ xfrd_get_temp_buffer()
 #ifdef BIND8_STATS
 /** process stat info task */
 static void
-xfrd_process_stat_info_task(xfrd_state_t* xfrd, struct task_list_d* task)
+xfrd_process_stat_info_task(xfrd_state_type* xfrd, struct task_list_d* task)
 {
  size_t i;
- stc_t* p = (void*)task->zname + sizeof(struct nsdst);
+ stc_type* p = (void*)task->zname + sizeof(struct nsdst);
  stats_add(&xfrd->nsd->st, (struct nsdst*)task->zname);
  for(i=0; i<xfrd->nsd->child_count; i++) {
  xfrd->nsd->children[i].query_count += *p++;
@@ -2398,7 +2402,7 @@ xfrd_process_stat_info_task(xfrd_state_t* xfrd, struct task_list_d* task)
 #ifdef USE_ZONE_STATS
 /** process zonestat inc task */
 static void
-xfrd_process_zonestat_inc_task(xfrd_state_t* xfrd, struct task_list_d* task)
+xfrd_process_zonestat_inc_task(xfrd_state_type* xfrd, struct task_list_d* task)
 {
  xfrd->zonestat_safe = (unsigned)task->oldserial;
  zonestat_remap(xfrd->nsd, 0, xfrd->zonestat_safe*sizeof(struct nsdst));
@@ -2409,7 +2413,7 @@ xfrd_process_zonestat_inc_task(xfrd_state_t* xfrd, struct task_list_d* task)
 #endif /* USE_ZONE_STATS */
 
 static void
-xfrd_handle_taskresult(xfrd_state_t* xfrd, struct task_list_d* task)
+xfrd_handle_taskresult(xfrd_state_type* xfrd, struct task_list_d* task)
 {
 #ifndef BIND8_STATS
  (void)xfrd;
@@ -2434,7 +2438,7 @@ xfrd_handle_taskresult(xfrd_state_t* xfrd, struct task_list_d* task)
  }
 }
 
-void xfrd_process_task_result(xfrd_state_t* xfrd, struct udb_base* taskudb)
+void xfrd_process_task_result(xfrd_state_type* xfrd, struct udb_base* taskudb)
 {
  udb_ptr t;
  /* remap it for usage */
@@ -2452,7 +2456,7 @@ void xfrd_process_task_result(xfrd_state_t* xfrd, struct udb_base* taskudb)
  task_clear(taskudb);
 }
 
-void xfrd_set_reload_now(xfrd_state_t* xfrd)
+void xfrd_set_reload_now(xfrd_state_type* xfrd)
 {
  xfrd->need_to_send_reload = 1;
  if(!(xfrd->ipc_handler_flags&EV_WRITE)) {
diff --git xfrd.h xfrd.h
index b601c2aae3e..44e7ba1795a 100644
--- xfrd.h
+++ xfrd.h
@@ -32,11 +32,11 @@ struct region;
 struct buffer;
 struct xfrd_tcp;
 struct xfrd_tcp_set;
-struct notify_zone_t;
+struct notify_zone;
 struct udb_ptr;
-typedef struct xfrd_state xfrd_state_t;
-typedef struct xfrd_zone xfrd_zone_t;
-typedef struct xfrd_soa xfrd_soa_t;
+typedef struct xfrd_state xfrd_state_type;
+typedef struct xfrd_zone xfrd_zone_type;
+typedef struct xfrd_soa xfrd_soa_type;
 /*
  * The global state for the xfrd daemon process.
  * The time_t times are epochs in secs since 1970, absolute times.
@@ -105,15 +105,15 @@ struct xfrd_state {
  /* xfrd shutdown flag */
  uint8_t shutdown;
 
- /* tree of zones, by apex name, contains xfrd_zone_t*. Only secondary zones. */
- rbtree_t *zones;
+ /* tree of zones, by apex name, contains xfrd_zone_type*. Only secondary zones. */
+ rbtree_type *zones;
 
- /* tree of zones, by apex name, contains notify_zone_t*. All zones. */
- rbtree_t *notify_zones;
- /* number of notify_zone_t active using UDP socket */
+ /* tree of zones, by apex name, contains notify_zone*. All zones. */
+ rbtree_type *notify_zones;
+ /* number of notify_zone active using UDP socket */
  int notify_udp_num;
- /* first and last notify_zone_t* entries waiting for a UDP socket */
- struct notify_zone_t *notify_waiting_first, *notify_waiting_last;
+ /* first and last notify_zone* entries waiting for a UDP socket */
+ struct notify_zone *notify_waiting_first, *notify_waiting_last;
 };
 
 /*
@@ -143,7 +143,7 @@ struct xfrd_soa {
  * XFRD state for a single zone
  */
 struct xfrd_zone {
- rbnode_t node;
+ rbnode_type node;
 
  /* name of the zone */
  const dname_type* apex;
@@ -156,11 +156,11 @@ struct xfrd_zone {
  * And the time the soa was acquired (start time for timeouts).
  * If the time==0, no SOA is available.
  */
- xfrd_soa_t soa_nsd;
+ xfrd_soa_type soa_nsd;
  time_t soa_nsd_acquired;
- xfrd_soa_t soa_disk;
+ xfrd_soa_type soa_disk;
  time_t soa_disk_acquired;
- xfrd_soa_t soa_notified;
+ xfrd_soa_type soa_notified;
  time_t soa_notified_acquired;
 
  enum xfrd_zone_state {
@@ -170,12 +170,12 @@ struct xfrd_zone {
  } state;
 
  /* master to try to transfer from, number for persistence */
- acl_options_t* master;
+ struct acl_options* master;
  int master_num;
  int next_master; /* -1 or set by notify where to try next */
  /* round of xfrattempts, -1 is waiting for timeout */
  int round_num;
- zone_options_t* zone_options;
+ struct zone_options* zone_options;
  int fresh_xfr_timeout;
 
  /* handler for timeouts */
@@ -189,23 +189,23 @@ struct xfrd_zone {
  /* zone is waiting for a tcp connection */
  uint8_t tcp_waiting;
  /* next zone in waiting list */
- xfrd_zone_t* tcp_waiting_next;
- xfrd_zone_t* tcp_waiting_prev;
+ xfrd_zone_type* tcp_waiting_next;
+ xfrd_zone_type* tcp_waiting_prev;
  /* zone is in its tcp send queue */
  uint8_t in_tcp_send;
  /* next zone in tcp send queue */
- xfrd_zone_t* tcp_send_next;
- xfrd_zone_t* tcp_send_prev;
+ xfrd_zone_type* tcp_send_next;
+ xfrd_zone_type* tcp_send_prev;
  /* zone is waiting for a udp connection (tcp is preferred) */
  uint8_t udp_waiting;
  /* next zone in waiting list for UDP */
- xfrd_zone_t* udp_waiting_next;
- xfrd_zone_t* udp_waiting_prev;
+ xfrd_zone_type* udp_waiting_next;
+ xfrd_zone_type* udp_waiting_prev;
  /* zone has been activated to run now (after the other events
  * but before blocking in select again) */
  uint8_t is_activated;
- xfrd_zone_t* activated_next;
- xfrd_zone_t* activated_prev;
+ xfrd_zone_type* activated_next;
+ xfrd_zone_type* activated_prev;
 
  /* xfr message handling data */
  /* query id */
@@ -247,20 +247,20 @@ enum xfrd_packet_result {
 #define XFRD_TRANSFER_TIMEOUT_START 10 /* empty zone timeout is between x and 2*x seconds */
 #define XFRD_TRANSFER_TIMEOUT_MAX 86400 /* empty zone timeout max expbackoff */
 
-extern xfrd_state_t* xfrd;
+extern xfrd_state_type* xfrd;
 
 /* start xfrd, new start. Pass socket to server_main. */
 void xfrd_init(int socket, struct nsd* nsd, int shortsoa, int reload_active,
  pid_t nsd_pid);
 
 /* add new slave zone, dname(from zone_opt) and given options */
-void xfrd_init_slave_zone(xfrd_state_t* xfrd, zone_options_t* zone_opt);
+void xfrd_init_slave_zone(xfrd_state_type* xfrd, struct zone_options* zone_opt);
 
 /* delete slave zone */
-void xfrd_del_slave_zone(xfrd_state_t* xfrd, const dname_type* dname);
+void xfrd_del_slave_zone(xfrd_state_type* xfrd, const dname_type* dname);
 
 /* disable ixfr for a while for zone->master */
-void xfrd_disable_ixfr(xfrd_zone_t* zone);
+void xfrd_disable_ixfr(xfrd_zone_type* zone);
 
 /* get the current time epoch. Cached for speed. */
 time_t xfrd_time(void);
@@ -270,16 +270,16 @@ time_t xfrd_time(void);
  * returns enum of packet discovery results
  */
 enum xfrd_packet_result xfrd_handle_received_xfr_packet(
- xfrd_zone_t* zone, buffer_type* packet);
+ xfrd_zone_type* zone, buffer_type* packet);
 
 /* set timer to specific value */
-void xfrd_set_timer(xfrd_zone_t* zone, time_t t);
+void xfrd_set_timer(xfrd_zone_type* zone, time_t t);
 /* set refresh timer of zone to refresh at time now */
-void xfrd_set_refresh_now(xfrd_zone_t* zone);
+void xfrd_set_refresh_now(xfrd_zone_type* zone);
 /* unset the timer - no more timeouts, for when zone is queued */
-void xfrd_unset_timer(xfrd_zone_t* zone);
+void xfrd_unset_timer(xfrd_zone_type* zone);
 /* remove the 'refresh now', remove it from the activated list */
-void xfrd_deactivate_zone(xfrd_zone_t* z);
+void xfrd_deactivate_zone(xfrd_zone_type* z);
 
 /*
  * Make a new request to next master server.
@@ -288,13 +288,14 @@ void xfrd_deactivate_zone(xfrd_zone_t* z);
  * starts next round of requests if at last master.
  * if too many rounds of requests, sets timer for next retry.
  */
-void xfrd_make_request(xfrd_zone_t* zone);
+void xfrd_make_request(xfrd_zone_type* zone);
 
 /*
  * send packet via udp (returns UDP fd source socket) to acl addr.
  * returns -1 on failure.
  */
-int xfrd_send_udp(acl_options_t* acl, buffer_type* packet, acl_options_t* ifc);
+int xfrd_send_udp(struct acl_options* acl, buffer_type* packet,
+ struct acl_options* ifc);
 
 /*
  * read from udp port packet into buffer, returns 0 on failure
@@ -304,7 +305,7 @@ int xfrd_udp_read_packet(buffer_type* packet, int fd);
 /*
  * Release udp socket that a zone is using
  */
-void xfrd_udp_release(xfrd_zone_t* zone);
+void xfrd_udp_release(xfrd_zone_type* zone);
 
 /*
  * Get a static buffer for temporary use (to build a packet).
@@ -315,12 +316,12 @@ struct buffer* xfrd_get_temp_buffer(void);
  * TSIG sign outgoing request. Call if acl has a key.
  */
 void xfrd_tsig_sign_request(buffer_type* packet, struct tsig_record* tsig,
-        acl_options_t* acl);
+        struct acl_options* acl);
 
 /* handle incoming soa information (NSD is running it, time acquired=guess).
    Pass soa=NULL,acquired=now if NSD has nothing loaded for the zone
    (i.e. zonefile was deleted). */
-void xfrd_handle_incoming_soa(xfrd_zone_t* zone, xfrd_soa_t* soa,
+void xfrd_handle_incoming_soa(xfrd_zone_type* zone, xfrd_soa_type* soa,
  time_t acquired);
 /* handle a packet passed along ipc route. acl is the one that accepted
    the packet. The packet is the network blob received. acl_xfr is
@@ -335,7 +336,7 @@ void xfrd_reopen_logfile(void);
 void xfrd_free_namedb(struct nsd* nsd);
 
 /* copy SOA info from rr to soa struct. */
-void xfrd_copy_soa(xfrd_soa_t* soa, rr_type* rr);
+void xfrd_copy_soa(xfrd_soa_type* soa, rr_type* rr);
 
 /* check for failed updates - it is assumed that now the reload has
    finished, and all zone SOAs have been sent. */
@@ -348,20 +349,20 @@ void xfrd_check_failed_updates(void);
 void xfrd_prepare_zones_for_reload(void);
 
 /* Bind a local interface to a socket descriptor, return 1 on success */
-int xfrd_bind_local_interface(int sockd, acl_options_t* ifc,
- acl_options_t* acl, int tcp);
+int xfrd_bind_local_interface(int sockd, struct acl_options* ifc,
+ struct acl_options* acl, int tcp);
 
 /* process results and soa info from reload */
-void xfrd_process_task_result(xfrd_state_t* xfrd, struct udb_base* taskudb);
+void xfrd_process_task_result(xfrd_state_type* xfrd, struct udb_base* taskudb);
 
 /* set to reload right away (for user controlled reload events) */
-void xfrd_set_reload_now(xfrd_state_t* xfrd);
+void xfrd_set_reload_now(xfrd_state_type* xfrd);
 
 /* send expiry notifications to nsd */
-void xfrd_send_expire_notification(xfrd_zone_t* zone);
+void xfrd_send_expire_notification(xfrd_zone_type* zone);
 
 /* handle incoming notify (soa or NULL) and start zone xfr if necessary */
-void xfrd_handle_notify_and_start_xfr(xfrd_zone_t* zone, xfrd_soa_t* soa);
+void xfrd_handle_notify_and_start_xfr(xfrd_zone_type* zone, xfrd_soa_type* soa);
 
 /* handle zone timeout, event */
 void xfrd_handle_zone(int fd, short event, void* arg);


--
I'm not entirely sure you are real.

Reply | Threaded
Open this post in threaded view
|

Re: nsd 4.1.15

Florian Obser-2
... and in case you want to see what's actually going on,
this is without the _t conversion churn:

commit 4cfab5a8d90abb380ae6a64da825883a2f360dc1
Author: Florian Obser <[hidden email]>
Date:   Fri Feb 17 15:04:08 2017 +0100

    log at verbosity 3.

diff --git nsec3.c nsec3.c
index f24377d4259..960e7216dad 100644
--- nsec3.c
+++ nsec3.c
@@ -855,7 +855,7 @@ nsec3_add_nonexist_proof(struct query* query, struct answer* answer,
  {
  /* exact match, hash collision */
  /* the hashed name of the query corresponds to an existing name. */
- VERBOSITY(2, (LOG_ERR, "nsec3 hash collision for name=%s",
+ VERBOSITY(3, (LOG_ERR, "nsec3 hash collision for name=%s",
  dname_to_string(to_prove, NULL)));
  RCODE_SET(query->packet, RCODE_SERVFAIL);
  return;
commit da0c808f5fd4a3a6d75083e57ff83125409cf63f
Author: Florian Obser <[hidden email]>
Date:   Fri Feb 17 15:03:27 2017 +0100

    Fix that nsec3 hash collisions only reported on
     verbosity level 2.

diff --git nsec3.c nsec3.c
index cbbc560feab..f24377d4259 100644
--- nsec3.c
+++ nsec3.c
@@ -855,8 +855,8 @@ nsec3_add_nonexist_proof(struct query* query, struct answer* answer,
  {
  /* exact match, hash collision */
  /* the hashed name of the query corresponds to an existing name. */
- log_msg(LOG_ERR, "nsec3 hash collision for name=%s",
- dname_to_string(to_prove, NULL));
+ VERBOSITY(2, (LOG_ERR, "nsec3 hash collision for name=%s",
+ dname_to_string(to_prove, NULL)));
  RCODE_SET(query->packet, RCODE_SERVFAIL);
  return;
  }
commit e704b0278dff9418494b01ad18e0aca6fcd041af
Author: Florian Obser <[hidden email]>
Date:   Fri Feb 17 15:02:59 2017 +0100

    layout

diff --git rbtree.h rbtree.h
index 19330eac195..d6e54862a23 100644
--- rbtree.h
+++ rbtree.h
@@ -19,11 +19,11 @@
  */
 typedef struct rbnode rbnode_type;
 struct rbnode {
- rbnode_type   *parent;
- rbnode_type   *left;
- rbnode_type   *right;
- const void *key;
- uint8_t    color;
+ rbnode_type  *parent;
+ rbnode_type  *left;
+ rbnode_type  *right;
+ const void   *key;
+ uint8_t      color;
 };
 
 #define RBTREE_NULL &rbtree_null_node
commit 86df8159cf9786a73d4f38384aae02b9ddc0dfa9
Author: Florian Obser <[hidden email]>
Date:   Fri Feb 17 15:00:34 2017 +0100

    Fix #1195: Fix so that NSD fails on non-compliant values for Serial

diff --git util.c util.c
index db3d7ceddce..458f0946643 100644
--- util.c
+++ util.c
@@ -487,6 +487,10 @@ strtoserial(const char* nptr, const char** endptr)
  case '7':
  case '8':
  case '9':
+ if((i*10)/10 != i)
+ /* number too large, return i
+ * with *endptr != 0 as a failure*/
+ return i;
  i *= 10;
  i += (**endptr - '0');
  break;
commit 504de18c0f56c4e3b117d6c268b6ca0e7a508d9b
Author: Florian Obser <[hidden email]>
Date:   Fri Feb 17 15:00:08 2017 +0100

    Squelch zone transfer error address family not supported by protocol
    at low verbosity levels.

diff --git xfrd-tcp.c xfrd-tcp.c
index 506b2520589..bd9d64e6397 100644
--- xfrd-tcp.c
+++ xfrd-tcp.c
@@ -521,7 +521,10 @@ xfrd_tcp_open(xfrd_tcp_set_t* set, struct xfrd_tcp_pipeline* tp,
  }
  fd = socket(family, SOCK_STREAM, IPPROTO_TCP);
  if(fd == -1) {
- log_msg(LOG_ERR, "xfrd: %s cannot create tcp socket: %s",
+ /* squelch 'Address family not supported by protocol' at low
+ * verbosity levels */
+ if(errno != EAFNOSUPPORT || verbosity > 2)
+    log_msg(LOG_ERR, "xfrd: %s cannot create tcp socket: %s",
  zone->master->ip_address_spec, strerror(errno));
  xfrd_set_refresh_now(zone);
  return 0;
commit 5c1a096cdf30ff6ea39317d733dcfbc431b137d9
Author: Florian Obser <[hidden email]>
Date:   Fri Feb 17 14:59:29 2017 +0100

    Fix nsd-control and ipv6 only.

diff --git nsd-control.c nsd-control.c
index 0b482839b47..1cc54e8f4c2 100644
--- nsd-control.c
+++ nsd-control.c
@@ -156,9 +156,13 @@ contact_server(const char* svr, nsd_options_t* cfg, int statuscmd)
  int port = cfg->control_port;
  /* use svr or a config entry */
  if(!svr) {
- if(cfg->control_interface)
+ if(cfg->control_interface) {
  svr = cfg->control_interface->address;
- else svr = "127.0.0.1";
+ } else if(cfg->do_ip4) {
+ svr = "127.0.0.1";
+ } else {
+ svr = "::1";
+ }
  /* config 0 addr (everything), means ask localhost */
  if(strcmp(svr, "0.0.0.0") == 0)
  svr = "127.0.0.1";
commit 911b921ea0ca1cbf37f4acb239de495960dc4814
Author: Florian Obser <[hidden email]>
Date:   Fri Feb 17 14:58:35 2017 +0100

    tag 4.1.14 - trunk contains 4.1.15 in development.

diff --git configure.ac configure.ac
index 029193574f0..b984cac435a 100644
--- configure.ac
+++ configure.ac
@@ -4,7 +4,7 @@ dnl
 
 sinclude(acx_nlnetlabs.m4)
 
-AC_INIT(NSD,4.1.14,[hidden email])
+AC_INIT(NSD,4.1.15,[hidden email])
 AC_CONFIG_HEADER([config.h])
 
 CFLAGS="$CFLAGS"


--
I'm not entirely sure you are real.

Reply | Threaded
Open this post in threaded view
|

Re: nsd 4.1.15

Stuart Henderson
In reply to this post by Florian Obser-2
On 2017/02/17 16:04, Florian Obser wrote:
> tests, OKs?

More _t to _type (I zoned out a bit reading that diff) :-)

I didn't spot anything concerning, there's only a small real change, and it's
working for me.  OK.

Reply | Threaded
Open this post in threaded view
|

Re: nsd 4.1.15

Sebastian Benoit-3
In reply to this post by Florian Obser-2
Florian Obser([hidden email]) on 2017.02.17 19:20:41 +0000:
> ... and in case you want to see what's actually going on,
> this is without the _t conversion churn:

thanks, and ok (for the one with the type stuff)

 

> commit 4cfab5a8d90abb380ae6a64da825883a2f360dc1
> Author: Florian Obser <[hidden email]>
> Date:   Fri Feb 17 15:04:08 2017 +0100
>
>     log at verbosity 3.
>
> diff --git nsec3.c nsec3.c
> index f24377d4259..960e7216dad 100644
> --- nsec3.c
> +++ nsec3.c
> @@ -855,7 +855,7 @@ nsec3_add_nonexist_proof(struct query* query, struct answer* answer,
>   {
>   /* exact match, hash collision */
>   /* the hashed name of the query corresponds to an existing name. */
> - VERBOSITY(2, (LOG_ERR, "nsec3 hash collision for name=%s",
> + VERBOSITY(3, (LOG_ERR, "nsec3 hash collision for name=%s",
>   dname_to_string(to_prove, NULL)));
>   RCODE_SET(query->packet, RCODE_SERVFAIL);
>   return;
> commit da0c808f5fd4a3a6d75083e57ff83125409cf63f
> Author: Florian Obser <[hidden email]>
> Date:   Fri Feb 17 15:03:27 2017 +0100
>
>     Fix that nsec3 hash collisions only reported on
>      verbosity level 2.
>
> diff --git nsec3.c nsec3.c
> index cbbc560feab..f24377d4259 100644
> --- nsec3.c
> +++ nsec3.c
> @@ -855,8 +855,8 @@ nsec3_add_nonexist_proof(struct query* query, struct answer* answer,
>   {
>   /* exact match, hash collision */
>   /* the hashed name of the query corresponds to an existing name. */
> - log_msg(LOG_ERR, "nsec3 hash collision for name=%s",
> - dname_to_string(to_prove, NULL));
> + VERBOSITY(2, (LOG_ERR, "nsec3 hash collision for name=%s",
> + dname_to_string(to_prove, NULL)));
>   RCODE_SET(query->packet, RCODE_SERVFAIL);
>   return;
>   }
> commit e704b0278dff9418494b01ad18e0aca6fcd041af
> Author: Florian Obser <[hidden email]>
> Date:   Fri Feb 17 15:02:59 2017 +0100
>
>     layout
>
> diff --git rbtree.h rbtree.h
> index 19330eac195..d6e54862a23 100644
> --- rbtree.h
> +++ rbtree.h
> @@ -19,11 +19,11 @@
>   */
>  typedef struct rbnode rbnode_type;
>  struct rbnode {
> - rbnode_type   *parent;
> - rbnode_type   *left;
> - rbnode_type   *right;
> - const void *key;
> - uint8_t    color;
> + rbnode_type  *parent;
> + rbnode_type  *left;
> + rbnode_type  *right;
> + const void   *key;
> + uint8_t      color;
>  };
>  
>  #define RBTREE_NULL &rbtree_null_node
> commit 86df8159cf9786a73d4f38384aae02b9ddc0dfa9
> Author: Florian Obser <[hidden email]>
> Date:   Fri Feb 17 15:00:34 2017 +0100
>
>     Fix #1195: Fix so that NSD fails on non-compliant values for Serial
>
> diff --git util.c util.c
> index db3d7ceddce..458f0946643 100644
> --- util.c
> +++ util.c
> @@ -487,6 +487,10 @@ strtoserial(const char* nptr, const char** endptr)
>   case '7':
>   case '8':
>   case '9':
> + if((i*10)/10 != i)
> + /* number too large, return i
> + * with *endptr != 0 as a failure*/
> + return i;
>   i *= 10;
>   i += (**endptr - '0');
>   break;
> commit 504de18c0f56c4e3b117d6c268b6ca0e7a508d9b
> Author: Florian Obser <[hidden email]>
> Date:   Fri Feb 17 15:00:08 2017 +0100
>
>     Squelch zone transfer error address family not supported by protocol
>     at low verbosity levels.
>
> diff --git xfrd-tcp.c xfrd-tcp.c
> index 506b2520589..bd9d64e6397 100644
> --- xfrd-tcp.c
> +++ xfrd-tcp.c
> @@ -521,7 +521,10 @@ xfrd_tcp_open(xfrd_tcp_set_t* set, struct xfrd_tcp_pipeline* tp,
>   }
>   fd = socket(family, SOCK_STREAM, IPPROTO_TCP);
>   if(fd == -1) {
> - log_msg(LOG_ERR, "xfrd: %s cannot create tcp socket: %s",
> + /* squelch 'Address family not supported by protocol' at low
> + * verbosity levels */
> + if(errno != EAFNOSUPPORT || verbosity > 2)
> +    log_msg(LOG_ERR, "xfrd: %s cannot create tcp socket: %s",
>   zone->master->ip_address_spec, strerror(errno));
>   xfrd_set_refresh_now(zone);
>   return 0;
> commit 5c1a096cdf30ff6ea39317d733dcfbc431b137d9
> Author: Florian Obser <[hidden email]>
> Date:   Fri Feb 17 14:59:29 2017 +0100
>
>     Fix nsd-control and ipv6 only.
>
> diff --git nsd-control.c nsd-control.c
> index 0b482839b47..1cc54e8f4c2 100644
> --- nsd-control.c
> +++ nsd-control.c
> @@ -156,9 +156,13 @@ contact_server(const char* svr, nsd_options_t* cfg, int statuscmd)
>   int port = cfg->control_port;
>   /* use svr or a config entry */
>   if(!svr) {
> - if(cfg->control_interface)
> + if(cfg->control_interface) {
>   svr = cfg->control_interface->address;
> - else svr = "127.0.0.1";
> + } else if(cfg->do_ip4) {
> + svr = "127.0.0.1";
> + } else {
> + svr = "::1";
> + }
>   /* config 0 addr (everything), means ask localhost */
>   if(strcmp(svr, "0.0.0.0") == 0)
>   svr = "127.0.0.1";
> commit 911b921ea0ca1cbf37f4acb239de495960dc4814
> Author: Florian Obser <[hidden email]>
> Date:   Fri Feb 17 14:58:35 2017 +0100
>
>     tag 4.1.14 - trunk contains 4.1.15 in development.
>
> diff --git configure.ac configure.ac
> index 029193574f0..b984cac435a 100644
> --- configure.ac
> +++ configure.ac
> @@ -4,7 +4,7 @@ dnl
>  
>  sinclude(acx_nlnetlabs.m4)
>  
> -AC_INIT(NSD,4.1.14,[hidden email])
> +AC_INIT(NSD,4.1.15,[hidden email])
>  AC_CONFIG_HEADER([config.h])
>  
>  CFLAGS="$CFLAGS"
>
>
> --
> I'm not entirely sure you are real.
>