DestroySockets(void);
#endif /* ifdef _WIN32 */
-extern int debug;
-extern const char * journal;
-extern bool nomerge;
-extern bool docheckmx;
-extern bool docheckns;
-extern bool dochecksrv;
+extern int debug;
+extern const char *journal;
+extern bool nomerge;
+extern bool docheckmx;
+extern bool docheckns;
+extern bool dochecksrv;
extern dns_zoneopt_t zone_options;
ISC_LANG_ENDDECLS
} while (0)
/*% usage */
-ISC_PLATFORM_NORETURN_PRE static void usage(void) ISC_PLATFORM_NORETURN_POST;
+ISC_PLATFORM_NORETURN_PRE static void
+usage(void) ISC_PLATFORM_NORETURN_POST;
static void
usage(void) {
} \
} while (0)
-ISC_PLATFORM_NORETURN_PRE static void usage(void) ISC_PLATFORM_NORETURN_POST;
+ISC_PLATFORM_NORETURN_PRE static void
+usage(void) ISC_PLATFORM_NORETURN_POST;
static void
usage(void) {
/*
* Static function prototypes
*/
-static isc_result_t get_reverse(char *reverse, size_t len, char *value,
- bool strict);
+static isc_result_t
+get_reverse(char *reverse, size_t len, char *value, bool strict);
-static isc_result_t parse_uint(uint32_t *uip, const char *value, uint32_t max,
- const char *desc);
+static isc_result_t
+parse_uint(uint32_t *uip, const char *value, uint32_t max, const char *desc);
static void
usage(void) {
exit(1);
}
-ISC_PLATFORM_NORETURN_PRE static void fatal(const char *format, ...)
+ISC_PLATFORM_NORETURN_PRE static void
+fatal(const char *format, ...)
ISC_FORMAT_PRINTF(1, 2) ISC_PLATFORM_NORETURN_POST;
static void
exit(1);
}
-static void warn(const char *format, ...) ISC_FORMAT_PRINTF(1, 2);
+static void
+warn(const char *format, ...) ISC_FORMAT_PRINTF(1, 2);
static void
warn(const char *format, ...) {
static isc_logmodule_t modules[] = { { "delv", 0 }, { NULL, 0 } };
-static void delv_log(int level, const char *fmt, ...) ISC_FORMAT_PRINTF(2, 3);
+static void
+delv_log(int level, const char *fmt, ...) ISC_FORMAT_PRINTF(2, 3);
static void
delv_log(int level, const char *fmt, ...) {
fprintf(stderr, "Press <Help> for complete list of options\n");
}
#else /* if TARGET_OS_IPHONE */
-ISC_PLATFORM_NORETURN_PRE static void usage(void) ISC_PLATFORM_NORETURN_POST;
+ISC_PLATFORM_NORETURN_PRE static void
+usage(void) ISC_PLATFORM_NORETURN_POST;
static void
usage(void) {
static char servercookie[256];
#ifdef HAVE_LIBIDN2
-static void idn_locale_to_ace(const char *src, char *dst, size_t dstlen);
-static void idn_ace_to_locale(const char *src, char **dst);
-static isc_result_t idn_output_filter(isc_buffer_t *buffer,
- unsigned int used_org);
+static void
+idn_locale_to_ace(const char *src, char *dst, size_t dstlen);
+static void
+idn_ace_to_locale(const char *src, char **dst);
+static isc_result_t
+idn_output_filter(isc_buffer_t *buffer, unsigned int used_org);
#endif /* HAVE_LIBIDN2 */
isc_socket_t *keep = NULL;
/* forward declarations */
-static void cancel_lookup(dig_lookup_t *lookup);
+static void
+cancel_lookup(dig_lookup_t *lookup);
-static void recv_done(isc_task_t *task, isc_event_t *event);
+static void
+recv_done(isc_task_t *task, isc_event_t *event);
-static void send_udp(dig_query_t *query);
+static void
+send_udp(dig_query_t *query);
-static void connect_timeout(isc_task_t *task, isc_event_t *event);
+static void
+connect_timeout(isc_task_t *task, isc_event_t *event);
-static void launch_next_query(dig_query_t *query, bool include_question);
+static void
+launch_next_query(dig_query_t *query, bool include_question);
-static void check_next_lookup(dig_lookup_t *lookup);
+static void
+check_next_lookup(dig_lookup_t *lookup);
-static bool next_origin(dig_lookup_t *oldlookup);
+static bool
+next_origin(dig_lookup_t *oldlookup);
static int
count_dots(char *string) {
}
}
-static void connect_done(isc_task_t *task, isc_event_t *event);
+static void
+connect_done(isc_task_t *task, isc_event_t *event);
/*%
* Unlike send_udp, this can't be called multiple times with the same
#define N_KNOWN_RRTYPES (sizeof(rtypetext) / sizeof(rtypetext[0]))
-static void flush_lookup_list(void);
-static void getinput(isc_task_t *task, isc_event_t *event);
+static void
+flush_lookup_list(void);
+static void
+getinput(isc_task_t *task, isc_event_t *event);
static char *
rcode_totext(dns_rcode_t rcode) {
isc_mem_free(mctx, buf);
}
-ISC_PLATFORM_NORETURN_PRE static void usage(void) ISC_PLATFORM_NORETURN_POST;
+ISC_PLATFORM_NORETURN_PRE static void
+usage(void) ISC_PLATFORM_NORETURN_POST;
static void
usage(void) {
} keyinfo_t;
/* A replaceable function that can generate a DS RRset from some input */
-typedef isc_result_t ds_maker_func_t(dns_rdatalist_t *dslist, isc_buffer_t *buf,
- dns_rdata_t *rdata);
+typedef isc_result_t
+ds_maker_func_t(dns_rdatalist_t *dslist, isc_buffer_t *buf, dns_rdata_t *rdata);
static dns_rdataset_t cdnskey_set, cdnskey_sig;
static dns_rdataset_t cds_set, cds_sig;
}
}
-ISC_PLATFORM_NORETURN_PRE static void usage(void) ISC_PLATFORM_NORETURN_POST;
+ISC_PLATFORM_NORETURN_PRE static void
+usage(void) ISC_PLATFORM_NORETURN_POST;
static void
usage(void) {
}
}
-ISC_PLATFORM_NORETURN_PRE static void usage(void) ISC_PLATFORM_NORETURN_POST;
+ISC_PLATFORM_NORETURN_PRE static void
+usage(void) ISC_PLATFORM_NORETURN_POST;
static void
usage(void) {
dst_key_free(&key);
}
-ISC_PLATFORM_NORETURN_PRE static void usage(void) ISC_PLATFORM_NORETURN_POST;
+ISC_PLATFORM_NORETURN_PRE static void
+usage(void) ISC_PLATFORM_NORETURN_POST;
static void
usage(void) {
const char *program = "dnssec-keyfromlabel";
-ISC_PLATFORM_NORETURN_PRE static void usage(void) ISC_PLATFORM_NORETURN_POST;
+ISC_PLATFORM_NORETURN_PRE static void
+usage(void) ISC_PLATFORM_NORETURN_POST;
static void
usage(void) {
isc_log_t *lctx = NULL;
-ISC_PLATFORM_NORETURN_PRE static void usage(void) ISC_PLATFORM_NORETURN_POST;
+ISC_PLATFORM_NORETURN_PRE static void
+usage(void) ISC_PLATFORM_NORETURN_POST;
-static void progress(int p);
+static void
+progress(int p);
struct keygen_ctx {
const char *predecessor;
static isc_mem_t *mctx = NULL;
-ISC_PLATFORM_NORETURN_PRE static void usage(void) ISC_PLATFORM_NORETURN_POST;
+ISC_PLATFORM_NORETURN_PRE static void
+usage(void) ISC_PLATFORM_NORETURN_POST;
static void
usage(void) {
static isc_mem_t *mctx = NULL;
-ISC_PLATFORM_NORETURN_PRE static void usage(void) ISC_PLATFORM_NORETURN_POST;
+ISC_PLATFORM_NORETURN_PRE static void
+usage(void) ISC_PLATFORM_NORETURN_POST;
static void
usage(void) {
UNLOCK(&statslock); \
}
-static void sign(isc_task_t *task, isc_event_t *event);
+static void
+sign(isc_task_t *task, isc_event_t *event);
/*%
* Store a copy of 'name' in 'fzonecut' and return a pointer to that copy.
fprintf(fp, "; dnssec_signzone version " VERSION "\n");
}
-ISC_PLATFORM_NORETURN_PRE static void usage(void) ISC_PLATFORM_NORETURN_POST;
+ISC_PLATFORM_NORETURN_PRE static void
+usage(void) ISC_PLATFORM_NORETURN_POST;
static void
usage(void) {
}
}
-ISC_PLATFORM_NORETURN_PRE static void usage(void) ISC_PLATFORM_NORETURN_POST;
+ISC_PLATFORM_NORETURN_PRE static void
+usage(void) ISC_PLATFORM_NORETURN_POST;
static void
usage(void) {
/*! verbosity: set by -v and -q option in each program, defined in dnssectool.c
*/
-extern int verbose;
+extern int verbose;
extern bool quiet;
/*! program name, statically initialized in each program */
typedef struct builtin builtin_t;
-static isc_result_t do_version_lookup(dns_sdblookup_t *lookup);
-static isc_result_t do_hostname_lookup(dns_sdblookup_t *lookup);
-static isc_result_t do_authors_lookup(dns_sdblookup_t *lookup);
-static isc_result_t do_id_lookup(dns_sdblookup_t *lookup);
-static isc_result_t do_empty_lookup(dns_sdblookup_t *lookup);
-static isc_result_t do_dns64_lookup(dns_sdblookup_t *lookup);
+static isc_result_t
+do_version_lookup(dns_sdblookup_t *lookup);
+static isc_result_t
+do_hostname_lookup(dns_sdblookup_t *lookup);
+static isc_result_t
+do_authors_lookup(dns_sdblookup_t *lookup);
+static isc_result_t
+do_id_lookup(dns_sdblookup_t *lookup);
+static isc_result_t
+do_empty_lookup(dns_sdblookup_t *lookup);
+static isc_result_t
+do_dns64_lookup(dns_sdblookup_t *lookup);
/*
* We can't use function pointers as the db_data directly
isccc_symtab_t *symtab;
};
-static void control_newconn(isc_task_t *task, isc_event_t *event);
-static void control_recvmessage(isc_task_t *task, isc_event_t *event);
+static void
+control_newconn(isc_task_t *task, isc_event_t *event);
+static void
+control_recvmessage(isc_task_t *task, isc_event_t *event);
#define CLOCKSKEW 300
exit(1);
}
-static void library_unexpected_error(const char *file, int line,
- const char *format, va_list args)
- ISC_FORMAT_PRINTF(3, 0);
+static void
+library_unexpected_error(const char *file, int line, const char *format,
+ va_list args) ISC_FORMAT_PRINTF(3, 0);
static void
library_unexpected_error(const char *file, int line, const char *format,
fatal(named_server_t *server, const char *msg,
isc_result_t result) ISC_PLATFORM_NORETURN_POST;
-static void named_server_reload(isc_task_t *task, isc_event_t *event);
+static void
+named_server_reload(isc_task_t *task, isc_event_t *event);
-static isc_result_t ns_listenelt_fromconfig(const cfg_obj_t *listener,
- const cfg_obj_t *config,
- cfg_aclconfctx_t *actx,
- isc_mem_t *mctx, uint16_t family,
- ns_listenelt_t **target);
-static isc_result_t ns_listenlist_fromconfig(const cfg_obj_t *listenlist,
- const cfg_obj_t *config,
- cfg_aclconfctx_t *actx,
- isc_mem_t *mctx, uint16_t family,
- ns_listenlist_t **target);
+static isc_result_t
+ns_listenelt_fromconfig(const cfg_obj_t *listener, const cfg_obj_t *config,
+ cfg_aclconfctx_t *actx, isc_mem_t *mctx,
+ uint16_t family, ns_listenelt_t **target);
+static isc_result_t
+ns_listenlist_fromconfig(const cfg_obj_t *listenlist, const cfg_obj_t *config,
+ cfg_aclconfctx_t *actx, isc_mem_t *mctx,
+ uint16_t family, ns_listenlist_t **target);
-static isc_result_t configure_forward(const cfg_obj_t *config, dns_view_t *view,
- const dns_name_t *origin,
- const cfg_obj_t *forwarders,
- const cfg_obj_t *forwardtype);
+static isc_result_t
+configure_forward(const cfg_obj_t *config, dns_view_t *view,
+ const dns_name_t *origin, const cfg_obj_t *forwarders,
+ const cfg_obj_t *forwardtype);
-static isc_result_t configure_alternates(const cfg_obj_t *config,
- dns_view_t *view,
- const cfg_obj_t *alternates);
+static isc_result_t
+configure_alternates(const cfg_obj_t *config, dns_view_t *view,
+ const cfg_obj_t *alternates);
-static isc_result_t configure_zone(const cfg_obj_t *config,
- const cfg_obj_t *zconfig,
- const cfg_obj_t *vconfig, isc_mem_t *mctx,
- dns_view_t *view, dns_viewlist_t *viewlist,
- dns_kasplist_t *kasplist,
- cfg_aclconfctx_t *aclconf, bool added,
- bool old_rpz_ok, bool modify);
+static isc_result_t
+configure_zone(const cfg_obj_t *config, const cfg_obj_t *zconfig,
+ const cfg_obj_t *vconfig, isc_mem_t *mctx, dns_view_t *view,
+ dns_viewlist_t *viewlist, dns_kasplist_t *kasplist,
+ cfg_aclconfctx_t *aclconf, bool added, bool old_rpz_ok,
+ bool modify);
-static isc_result_t configure_newzones(dns_view_t *view, cfg_obj_t *config,
- cfg_obj_t *vconfig, isc_mem_t *mctx,
- cfg_aclconfctx_t *actx);
+static isc_result_t
+configure_newzones(dns_view_t *view, cfg_obj_t *config, cfg_obj_t *vconfig,
+ isc_mem_t *mctx, cfg_aclconfctx_t *actx);
-static isc_result_t add_keydata_zone(dns_view_t *view, const char *directory,
- isc_mem_t *mctx);
+static isc_result_t
+add_keydata_zone(dns_view_t *view, const char *directory, isc_mem_t *mctx);
-static void end_reserved_dispatches(named_server_t *server, bool all);
+static void
+end_reserved_dispatches(named_server_t *server, bool all);
-static void newzone_cfgctx_destroy(void **cfgp);
+static void
+newzone_cfgctx_destroy(void **cfgp);
-static inline isc_result_t putstr(isc_buffer_t **b, const char *str);
+static inline isc_result_t
+putstr(isc_buffer_t **b, const char *str);
-static isc_result_t putmem(isc_buffer_t **b, const char *str, size_t len);
+static isc_result_t
+putmem(isc_buffer_t **b, const char *str, size_t len);
-static isc_result_t putuint8(isc_buffer_t **b, uint8_t val);
+static isc_result_t
+putuint8(isc_buffer_t **b, uint8_t val);
-static inline isc_result_t putnull(isc_buffer_t **b);
+static inline isc_result_t
+putnull(isc_buffer_t **b);
-static int count_zones(const cfg_obj_t *conf);
+static int
+count_zones(const cfg_obj_t *conf);
#ifdef HAVE_LMDB
-static isc_result_t migrate_nzf(dns_view_t *view);
+static isc_result_t
+migrate_nzf(dns_view_t *view);
-static isc_result_t nzd_writable(dns_view_t *view);
+static isc_result_t
+nzd_writable(dns_view_t *view);
-static isc_result_t nzd_open(dns_view_t *view, unsigned int flags,
- MDB_txn **txnp, MDB_dbi *dbi);
+static isc_result_t
+nzd_open(dns_view_t *view, unsigned int flags, MDB_txn **txnp, MDB_dbi *dbi);
-static isc_result_t nzd_env_reopen(dns_view_t *view);
+static isc_result_t
+nzd_env_reopen(dns_view_t *view);
-static void nzd_env_close(dns_view_t *view);
+static void
+nzd_env_close(dns_view_t *view);
-static isc_result_t nzd_close(MDB_txn **txnp, bool commit);
+static isc_result_t
+nzd_close(MDB_txn **txnp, bool commit);
-static isc_result_t nzd_count(dns_view_t *view, int *countp);
+static isc_result_t
+nzd_count(dns_view_t *view, int *countp);
#else /* ifdef HAVE_LMDB */
-static isc_result_t nzf_append(dns_view_t *view, const cfg_obj_t *zconfig);
+static isc_result_t
+nzf_append(dns_view_t *view, const cfg_obj_t *zconfig);
#endif /* ifdef HAVE_LMDB */
/*%
#define BIND_SERVICE_NAME "named"
void
- ntservice_init();
+ntservice_init();
void UpdateSCM(DWORD);
void
ServiceControl(DWORD dwCtrlCode);
/*
* Forward declarations
*/
-void ServiceControl(DWORD dwCtrlCode);
-int bindmain(int, char *[]); /* From main.c */
+void
+ServiceControl(DWORD dwCtrlCode);
+int
+bindmain(int, char *[]); /* From main.c */
/*
* Initialize the Service by registering it.
isc_sockaddr_t *addr;
} nsu_requestinfo_t;
-static void sendrequest(isc_sockaddr_t *destaddr, dns_message_t *msg,
- dns_request_t **request);
-static void send_update(dns_name_t *zonename, isc_sockaddr_t *master);
+static void
+sendrequest(isc_sockaddr_t *destaddr, dns_message_t *msg,
+ dns_request_t **request);
+static void
+send_update(dns_name_t *zonename, isc_sockaddr_t *master);
-ISC_PLATFORM_NORETURN_PRE static void fatal(const char *format, ...)
+ISC_PLATFORM_NORETURN_PRE static void
+fatal(const char *format, ...)
ISC_FORMAT_PRINTF(1, 2) ISC_PLATFORM_NORETURN_POST;
-static void debug(const char *format, ...) ISC_FORMAT_PRINTF(1, 2);
+static void
+debug(const char *format, ...) ISC_FORMAT_PRINTF(1, 2);
-static void ddebug(const char *format, ...) ISC_FORMAT_PRINTF(1, 2);
+static void
+ddebug(const char *format, ...) ISC_FORMAT_PRINTF(1, 2);
#ifdef GSSAPI
static dns_fixedname_t fkname;
gss_ctx_id_t context;
} nsu_gssinfo_t;
-static void failed_gssrequest();
-static void start_gssrequest(dns_name_t *master);
-static void send_gssrequest(isc_sockaddr_t *destaddr, dns_message_t *msg,
- dns_request_t **request, gss_ctx_id_t context);
-static void recvgss(isc_task_t *task, isc_event_t *event);
+static void
+failed_gssrequest();
+static void
+start_gssrequest(dns_name_t *master);
+static void
+send_gssrequest(isc_sockaddr_t *destaddr, dns_message_t *msg,
+ dns_request_t **request, gss_ctx_id_t context);
+static void
+recvgss(isc_task_t *task, isc_event_t *event);
#endif /* GSSAPI */
-static void error(const char *format, ...) ISC_FORMAT_PRINTF(1, 2);
+static void
+error(const char *format, ...) ISC_FORMAT_PRINTF(1, 2);
#define STATUS_MORE (uint16_t)0
#define STATUS_SEND (uint16_t)1
/*
* Forward declarations of functions referenced in install_hooks().
*/
-static ns_hookresult_t filter_qctx_initialize(void *arg, void *cbdata,
- isc_result_t *resp);
-static ns_hookresult_t filter_respond_begin(void *arg, void *cbdata,
- isc_result_t *resp);
-static ns_hookresult_t filter_respond_any_found(void *arg, void *cbdata,
- isc_result_t *resp);
-static ns_hookresult_t filter_prep_response_begin(void *arg, void *cbdata,
- isc_result_t *resp);
-static ns_hookresult_t filter_query_done_send(void *arg, void *cbdata,
- isc_result_t *resp);
-static ns_hookresult_t filter_qctx_destroy(void *arg, void *cbdata,
- isc_result_t *resp);
+static ns_hookresult_t
+filter_qctx_initialize(void *arg, void *cbdata, isc_result_t *resp);
+static ns_hookresult_t
+filter_respond_begin(void *arg, void *cbdata, isc_result_t *resp);
+static ns_hookresult_t
+filter_respond_any_found(void *arg, void *cbdata, isc_result_t *resp);
+static ns_hookresult_t
+filter_prep_response_begin(void *arg, void *cbdata, isc_result_t *resp);
+static ns_hookresult_t
+filter_query_done_send(void *arg, void *cbdata, isc_result_t *resp);
+static ns_hookresult_t
+filter_qctx_destroy(void *arg, void *cbdata, isc_result_t *resp);
/*%
* Register the functions to be called at each hook point in 'hooktable', using
static bool quiet = false;
static bool showresult = false;
-static void rndc_startconnect(isc_sockaddr_t *addr, isc_task_t *task);
+static void
+rndc_startconnect(isc_sockaddr_t *addr, isc_task_t *task);
ISC_PLATFORM_NORETURN_PRE static void
usage(int status) ISC_PLATFORM_NORETURN_POST;
static isc_stdtime_t now;
static dns_adb_t *adb;
-static void check_result(isc_result_t result, const char *format, ...)
+static void
+check_result(isc_result_t result, const char *format, ...)
ISC_FORMAT_PRINTF(2, 3);
static void
static isc_logconfig_t *lcfg;
static unsigned int level = 0;
-static void adb_callback(isc_task_t *task, isc_event_t *event);
+static void
+adb_callback(isc_task_t *task, isc_event_t *event);
static void
log_init(void) {
#define PORT 53
#define TIMEOUT 30
-static void initctx1(isc_task_t *task, isc_event_t *event);
-static void sendquery(isc_task_t *task, isc_event_t *event);
-static void setup();
+static void
+initctx1(isc_task_t *task, isc_event_t *event);
+static void
+sendquery(isc_task_t *task, isc_event_t *event);
+static void
+setup();
static void
console(isc_task_t *task, isc_event_t *event) {
isc_task_t *g_task = NULL;
isc_mem_t *mctx = NULL;
-static void utick(isc_task_t *task, isc_event_t *event);
-static void shutdown_rl(isc_task_t *task, isc_event_t *event);
-static void shutdown_all(isc_task_t *task, isc_event_t *event);
+static void
+utick(isc_task_t *task, isc_event_t *event);
+static void
+shutdown_rl(isc_task_t *task, isc_event_t *event);
+static void
+shutdown_all(isc_task_t *task, isc_event_t *event);
typedef struct {
int milliseconds;
#define CLOCK_REALTIME 0
#endif /* ifndef CLOCK_REALTIME */
-static int clock_gettime(int32_t id, struct timespec *tp);
+static int
+clock_gettime(int32_t id, struct timespec *tp);
static int
clock_gettime(int32_t id, struct timespec *tp) {
#define CLOCK_REALTIME 0
#endif /* ifndef CLOCK_REALTIME */
-static int clock_gettime(int32_t id, struct timespec *tp);
+static int
+clock_gettime(int32_t id, struct timespec *tp);
static int
clock_gettime(int32_t id, struct timespec *tp) {
#define CLOCK_REALTIME 0
#endif /* ifndef CLOCK_REALTIME */
-static int clock_gettime(int32_t id, struct timespec *tp);
+static int
+clock_gettime(int32_t id, struct timespec *tp);
static int
clock_gettime(int32_t id, struct timespec *tp) {
#define CLOCK_REALTIME 0
#endif /* ifndef CLOCK_REALTIME */
-static int clock_gettime(int32_t id, struct timespec *tp);
+static int
+clock_gettime(int32_t id, struct timespec *tp);
static int
clock_gettime(int32_t id, struct timespec *tp) {
#define CLOCK_REALTIME 0
#endif /* ifndef CLOCK_REALTIME */
-static int clock_gettime(int32_t id, struct timespec *tp);
+static int
+clock_gettime(int32_t id, struct timespec *tp);
static int
clock_gettime(int32_t id, struct timespec *tp) {
#define CLOCK_REALTIME 0
#endif /* ifndef CLOCK_REALTIME */
-static int clock_gettime(int32_t id, struct timespec *tp);
+static int
+clock_gettime(int32_t id, struct timespec *tp);
static int
clock_gettime(int32_t id, struct timespec *tp) {
#define CLOCK_REALTIME 0
#endif /* ifndef CLOCK_REALTIME */
-static int clock_gettime(int32_t id, struct timespec *tp);
+static int
+clock_gettime(int32_t id, struct timespec *tp);
static int
clock_gettime(int32_t id, struct timespec *tp) {
#define CLOCK_REALTIME 0
#endif /* ifndef CLOCK_REALTIME */
-static int clock_gettime(int32_t id, struct timespec *tp);
+static int
+clock_gettime(int32_t id, struct timespec *tp);
static int
clock_gettime(int32_t id, struct timespec *tp) {
#define CLOCK_REALTIME 0
#endif /* ifndef CLOCK_REALTIME */
-static int clock_gettime(int32_t id, struct timespec *tp);
+static int
+clock_gettime(int32_t id, struct timespec *tp);
static int
clock_gettime(int32_t id, struct timespec *tp) {
#define CLOCK_REALTIME 0
#endif /* ifndef CLOCK_REALTIME */
-static int clock_gettime(int32_t id, struct timespec *tp);
+static int
+clock_gettime(int32_t id, struct timespec *tp);
static int
clock_gettime(int32_t id, struct timespec *tp) {
#define MAX_RECORDS 100
-typedef void log_t(int level, const char *fmt, ...);
+typedef void
+log_t(int level, const char *fmt, ...);
struct dlz_example_data {
char *zone_name;
* This header includes the declarations of entry points.
*/
-dlz_dlopen_version_t dlz_version;
-dlz_dlopen_create_t dlz_create;
-dlz_dlopen_destroy_t dlz_destroy;
-dlz_dlopen_findzonedb_t dlz_findzonedb;
-dlz_dlopen_lookup_t dlz_lookup;
+dlz_dlopen_version_t dlz_version;
+dlz_dlopen_create_t dlz_create;
+dlz_dlopen_destroy_t dlz_destroy;
+dlz_dlopen_findzonedb_t dlz_findzonedb;
+dlz_dlopen_lookup_t dlz_lookup;
dlz_dlopen_allowzonexfr_t dlz_allowzonexfr;
-dlz_dlopen_allnodes_t dlz_allnodes;
-dlz_dlopen_newversion_t dlz_newversion;
+dlz_dlopen_allnodes_t dlz_allnodes;
+dlz_dlopen_newversion_t dlz_newversion;
dlz_dlopen_closeversion_t dlz_closeversion;
-dlz_dlopen_configure_t dlz_configure;
-dlz_dlopen_ssumatch_t dlz_ssumatch;
-dlz_dlopen_addrdataset_t dlz_addrdataset;
-dlz_dlopen_subrdataset_t dlz_subrdataset;
-dlz_dlopen_delrdataset_t dlz_delrdataset;
+dlz_dlopen_configure_t dlz_configure;
+dlz_dlopen_ssumatch_t dlz_ssumatch;
+dlz_dlopen_addrdataset_t dlz_addrdataset;
+dlz_dlopen_subrdataset_t dlz_subrdataset;
+dlz_dlopen_delrdataset_t dlz_delrdataset;
#include <dns/types.h>
struct sample_instance {
- isc_mem_t * mctx;
- char * db_name;
+ isc_mem_t *mctx;
+ char *db_name;
dns_dbimplementation_t *db_imp;
/* These are needed for zone creation. */
- dns_view_t * view;
+ dns_view_t *view;
dns_zonemgr_t *zmgr;
- isc_task_t * task;
- bool exiting;
+ isc_task_t *task;
+ bool exiting;
- dns_zone_t * zone1;
+ dns_zone_t *zone1;
dns_fixedname_t zone1_fn;
- dns_name_t * zone1_name;
+ dns_name_t *zone1_name;
- dns_zone_t * zone2;
+ dns_zone_t *zone2;
dns_fixedname_t zone2_fn;
- dns_name_t * zone2_name;
+ dns_name_t *zone2_name;
};
typedef struct sample_instance sample_instance_t;
isc_result_t
new_sample_instance(isc_mem_t *mctx, const char *db_name, int argc, char **argv,
const dns_dyndbctx_t *dctx,
- sample_instance_t ** sample_instp);
+ sample_instance_t **sample_instp);
isc_result_t
load_sample_instance_zones(sample_instance_t *inst);
} librpz_emsg_t;
#endif /* ifdef USE_DNSRPS */
-static bool link_dnsrps(librpz_emsg_t *emsg);
+static bool
+link_dnsrps(librpz_emsg_t *emsg);
#define USAGE "usage: [-ap] [-n domain] [-w sec.onds]\n"
bool printmemstats = false;
bool dorender = false;
-static void process_message(isc_buffer_t *source);
+static void
+process_message(isc_buffer_t *source);
-static isc_result_t printmessage(dns_message_t *msg);
+static isc_result_t
+printmessage(dns_message_t *msg);
static inline void
CHECKRESULT(isc_result_t result, const char *msg) {
} \
} while (0)
-ISC_PLATFORM_NORETURN_PRE static void fatal(const char *format,
- ...) ISC_PLATFORM_NORETURN_POST;
+ISC_PLATFORM_NORETURN_PRE static void
+fatal(const char *format, ...) ISC_PLATFORM_NORETURN_POST;
static void
fatal(const char *format, ...) {
return;
}
-ISC_PLATFORM_NORETURN_PRE static void usage(void) ISC_PLATFORM_NORETURN_POST;
+ISC_PLATFORM_NORETURN_PRE static void
+usage(void) ISC_PLATFORM_NORETURN_POST;
static void
usage(void) {
stdout);
}
-ISC_PLATFORM_NORETURN_PRE static void fatal(const char *format, ...)
+ISC_PLATFORM_NORETURN_PRE static void
+fatal(const char *format, ...)
ISC_FORMAT_PRINTF(1, 2) ISC_PLATFORM_NORETURN_POST;
static void
static isc_lexspecials_t specials;
-ISC_PLATFORM_NORETURN_PRE static void usage(void) ISC_PLATFORM_NORETURN_POST;
+ISC_PLATFORM_NORETURN_PRE static void
+usage(void) ISC_PLATFORM_NORETURN_POST;
static void
usage(void) {
exit(0);
}
-ISC_PLATFORM_NORETURN_PRE static void fatal(const char *format,
- ...) ISC_PLATFORM_NORETURN_POST;
+ISC_PLATFORM_NORETURN_PRE static void
+fatal(const char *format, ...) ISC_PLATFORM_NORETURN_POST;
static void
fatal(const char *format, ...) {
const char *program = "nsec3hash";
-ISC_PLATFORM_NORETURN_PRE static void fatal(const char *format,
- ...) ISC_PLATFORM_NORETURN_POST;
+ISC_PLATFORM_NORETURN_PRE static void
+fatal(const char *format, ...) ISC_PLATFORM_NORETURN_POST;
static void
fatal(const char *format, ...) {
exit(1);
}
-typedef void nsec3printer(unsigned algo, unsigned flags, unsigned iters,
- const char *saltstr, const char *domain,
- const char *digest);
+typedef void
+nsec3printer(unsigned algo, unsigned flags, unsigned iters, const char *saltstr,
+ const char *domain, const char *digest);
static void
nsec3hash(nsec3printer *nsec3print, const char *algostr, const char *flagstr,
* a given account as well as the groups to which it beongs
*/
int
-GetAccountPrivileges(char * name, /* Name of Account */
- wchar_t ** PrivList, /* List of Privileges returned */
- unsigned int *PrivCount, /* Count of Privileges returned */
- char **Groups, /* List of Groups to which account belongs
- */
- unsigned int *totalGroups, /* Count of Groups returned */
+GetAccountPrivileges(char *name, /* Name of Account */
+ wchar_t **PrivList, /* List of Privileges returned */
+ unsigned int *PrivCount, /* Count of Privileges
+ returned */
+ char **Groups, /* List of Groups to which account
+ * belongs
+ */
+ unsigned int *totalGroups, /* Count of Groups returned
+ */
int maxGroups /* Maximum number of Groups to return */
);
enum { IDD = IDD_BINDINSTALL_DIALOG };
CString m_targetDir;
CString m_version;
- BOOL m_autoStart;
- BOOL m_keepFiles;
- BOOL m_toolsOnly;
+ BOOL m_autoStart;
+ BOOL m_keepFiles;
+ BOOL m_toolsOnly;
CString m_current;
- BOOL m_startOnInstall;
+ BOOL m_startOnInstall;
/*}}AFX_DATA */
/* ClassWizard generated virtual function overrides */
void
ProgramGroupRemove(TCHAR *commonPath);
- HICON m_hIcon;
+ HICON m_hIcon;
CString m_defaultDir;
CString m_etcDir;
CString m_binDir;
CString m_winSysDir;
- BOOL m_installed;
+ BOOL m_installed;
CString m_currentDir;
- BOOL m_accountExists;
- BOOL m_accountUsed;
+ BOOL m_accountExists;
+ BOOL m_accountUsed;
CString m_currentAccount;
CString m_accountName;
CString m_accountPasswordConfirm;
CString m_accountPassword;
- BOOL m_serviceExists;
+ BOOL m_serviceExists;
/* Generated message map functions */
/*{{AFX_MSG(CBINDInstallDlg) */
/* Construction */
public:
CDirBrowse(CString initialDir = "\\",
- CWnd * pParent = NULL); /* standard
+ CWnd *pParent = NULL); /* standard
* constructor
*/
CString
GetFileSubType();
private:
- CString m_filename;
- BOOL m_isValid;
- LPVOID m_versionInfo;
+ CString m_filename;
+ BOOL m_isValid;
+ LPVOID m_versionInfo;
VS_FIXEDFILEINFO *m_fixedInfo;
- DWORD m_codePage;
- DWORD m_status;
+ DWORD m_codePage;
+ DWORD m_status;
CString
QueryStringValue(CString value);
*/
#define CONCAT(a, b) a##b
-#define DNSCONF_SET_STRING(FIELD) \
- void CONCAT(DNSConf_set, FIELD)(DNSConf * cfg, const char *arg) \
- { \
- DBGPRINT("inside DNSConf_set" #FIELD "\n"); \
- \
- if (!DNSConf_initctx(cfg)) \
- return; \
- \
- if (arg == NULL) { \
- DBGPRINT("null pointer\n"); \
- CONCAT(dns_c_ctx_unset, FIELD)(cfg->confctx); \
- } else if (*arg == '\0') { \
- DBGPRINT("empty string\n"); \
- CONCAT(dns_c_ctx_unset, FIELD)(cfg->confctx); \
- } else \
- CONCAT(dns_c_ctx_set, FIELD)(cfg->confctx, arg); \
+#define DNSCONF_SET_STRING(FIELD) \
+ void CONCAT(DNSConf_set, FIELD)(DNSConf * cfg, const char *arg) { \
+ DBGPRINT("inside DNSConf_set" #FIELD "\n"); \
+ \
+ if (!DNSConf_initctx(cfg)) \
+ return; \
+ \
+ if (arg == NULL) { \
+ DBGPRINT("null pointer\n"); \
+ CONCAT(dns_c_ctx_unset, FIELD)(cfg->confctx); \
+ } else if (*arg == '\0') { \
+ DBGPRINT("empty string\n"); \
+ CONCAT(dns_c_ctx_unset, FIELD)(cfg->confctx); \
+ } else \
+ CONCAT(dns_c_ctx_set, FIELD)(cfg->confctx, arg); \
}
#define DNSCONF_GET_STRING(FIELD) \
- char *CONCAT(DNSConf_get, FIELD)(DNSConf * cfg) \
- { \
- char * result = NULL; \
+ char *CONCAT(DNSConf_get, FIELD)(DNSConf * cfg) { \
+ char *result = NULL; \
isc_result_t tmpres; \
\
if (cfg == NULL || cfg->confctx == NULL) \
/* shut up compiler warnings about no previous prototype */
-static void show_usage(void);
+static void
+show_usage(void);
-int getzone(DB *dbp, const DBT *pkey, const DBT *pdata, DBT *skey);
+int
+getzone(DB *dbp, const DBT *pkey, const DBT *pdata, DBT *skey);
-int gethost(DB *dbp, const DBT *pkey, const DBT *pdata, DBT *skey);
+int
+gethost(DB *dbp, const DBT *pkey, const DBT *pdata, DBT *skey);
-void bdb_cleanup(void);
+void
+bdb_cleanup(void);
-isc_result_t bdb_opendb(DBTYPE db_type, DB **db_out, const char *db_name,
- int flags);
+isc_result_t
+bdb_opendb(DBTYPE db_type, DB **db_out, const char *db_name, int flags);
-void put_data(bool dns_data, char *input_key, char *input_data);
+void
+put_data(bool dns_data, char *input_key, char *input_data);
-void insert_data(void);
+void
+insert_data(void);
-isc_result_t openBDB(void);
+isc_result_t
+openBDB(void);
-isc_result_t open_lexer(void);
+isc_result_t
+open_lexer(void);
-void close_lexer(void);
+void
+close_lexer(void);
-isc_result_t bulk_write(char type, DB *database, DBC *dbcursor, DBT *bdbkey,
- DBT *bdbdata);
+isc_result_t
+bulk_write(char type, DB *database, DBC *dbcursor, DBT *bdbkey, DBT *bdbdata);
-void operation_add(void);
+void
+operation_add(void);
-void operation_bulk(void);
+void
+operation_bulk(void);
-void operation_listOrDelete(bool dlt);
+void
+operation_listOrDelete(bool dlt);
/*%
* Maximum length of a single data line that
*/
static void
-show_usage(void)
-{
+show_usage(void) {
fprintf(stderr, "\n\n\
---Usage:---------------------------------------------------------------------\
\n\n\
/*% BDB callback to create zone secondary index */
int
-getzone(DB *dbp, const DBT *pkey, const DBT *pdata, DBT *skey)
-{
+getzone(DB *dbp, const DBT *pkey, const DBT *pdata, DBT *skey) {
char *token, *last;
UNUSED(dbp);
*/
int
-gethost(DB *dbp, const DBT *pkey, const DBT *pdata, DBT *skey)
-{
+gethost(DB *dbp, const DBT *pkey, const DBT *pdata, DBT *skey) {
char *token, *last;
UNUSED(dbp);
*/
void
-bdb_cleanup(void)
-{
+bdb_cleanup(void) {
/* close cursors */
if (db.cursor4 != NULL) {
db.cursor4->c_close(db.cursor4);
/*% Initializes, sets flags and then opens Berkeley databases. */
isc_result_t
-bdb_opendb(DBTYPE db_type, DB **db_out, const char *db_name, int flags)
-{
+bdb_opendb(DBTYPE db_type, DB **db_out, const char *db_name, int flags) {
int result;
int createFlag = 0;
*/
void
-put_data(bool dns_data, char *input_key, char *input_data)
-{
+put_data(bool dns_data, char *input_key, char *input_data) {
int bdbres;
DBT key, data;
}
void
-insert_data(void)
-{
+insert_data(void) {
unsigned int opt = ISC_LEXOPT_EOL | /* Want end-of-line token. */
ISC_LEXOPT_EOF | /* Want end-of-file token. */
ISC_LEXOPT_QSTRING | /* Recognize qstrings. */
}
isc_result_t
-openBDB(void)
-{
+openBDB(void) {
int bdbres;
isc_result_t result;
/*% Create & open lexer to parse input data */
isc_result_t
-open_lexer(void)
-{
+open_lexer(void) {
isc_result_t result;
/* check if we already opened the lexer, if we did, return success */
/*% Close the lexer, and cleanup memory */
void
-close_lexer(void)
-{
+close_lexer(void) {
/* If lexer is still open, close it & destroy it. */
if (lexer != NULL) {
isc_lex_close(lexer);
/*% Perform add operation */
void
-operation_add(void)
-{
+operation_add(void) {
/* check for any parameters that are not allowed during add */
checkInvalidParam(key, "k", "for add operation");
checkInvalidParam(zone, "z", "for add operation");
/*% Perform bulk insert operation */
void
-operation_bulk(void)
-{
+operation_bulk(void) {
/* check for any parameters that are not allowed during bulk */
checkInvalidParam(key, "k", "for bulk load operation");
checkInvalidParam(zone, "z", "for bulk load operation");
}
isc_result_t
-bulk_write(char type, DB *database, DBC *dbcursor, DBT *bdbkey, DBT *bdbdata)
-{
+bulk_write(char type, DB *database, DBC *dbcursor, DBT *bdbkey, DBT *bdbdata) {
int bdbres;
db_recno_t recNum;
char *retkey = NULL, *retdata;
*/
void
-operation_listOrDelete(bool dlt)
-{
+operation_listOrDelete(bool dlt) {
int bdbres = 0;
DBC *curList[3];
DBT bdbkey, bdbdata;
}
int
-main(int argc, char **argv)
-{
+main(int argc, char **argv) {
int ch;
char *endp;
/* forward reference */
-static isc_result_t bdb_findzone(void *driverarg, void *dbdata,
- const char *name,
- dns_clientinfomethods_t *methods,
- dns_clientinfo_t *clientinfo);
+static isc_result_t
+bdb_findzone(void *driverarg, void *dbdata, const char *name,
+ dns_clientinfomethods_t *methods, dns_clientinfo_t *clientinfo);
/*%
* Parses the DBT from the Berkeley DB into a parsed_data record
*/
static isc_result_t
-bdb_parse_data(char *in, parsed_data_t *pd)
-{
+bdb_parse_data(char *in, parsed_data_t *pd) {
char *endp, *ttlStr;
char *tmp = in;
char *lastchar = (char *)&tmp[strlen(tmp) + 1];
static isc_result_t
bdb_allowzonexfr(void *driverarg, void *dbdata, const char *name,
- const char *client)
-{
+ const char *client) {
isc_result_t result;
bdb_instance_t *db = (bdb_instance_t *)dbdata;
DBC *client_cursor = NULL;
static isc_result_t
bdb_allnodes(const char *zone, void *driverarg, void *dbdata,
- dns_sdlzallnodes_t *allnodes)
-{
+ dns_sdlzallnodes_t *allnodes) {
isc_result_t result = ISC_R_NOTFOUND;
bdb_instance_t *db = (bdb_instance_t *)dbdata;
DBC *zone_cursor = NULL;
*/
static void
-bdb_cleanup(bdb_instance_t *db)
-{
+bdb_cleanup(bdb_instance_t *db) {
isc_mem_t *mctx;
/* close databases */
static isc_result_t
bdb_findzone(void *driverarg, void *dbdata, const char *name,
- dns_clientinfomethods_t *methods, dns_clientinfo_t *clientinfo)
-{
+ dns_clientinfomethods_t *methods, dns_clientinfo_t *clientinfo) {
isc_result_t result;
bdb_instance_t *db = (bdb_instance_t *)dbdata;
DBC *zone_cursor = NULL;
static isc_result_t
bdb_lookup(const char *zone, const char *name, void *driverarg, void *dbdata,
dns_sdlzlookup_t *lookup, dns_clientinfomethods_t *methods,
- dns_clientinfo_t *clientinfo)
-{
+ dns_clientinfo_t *clientinfo) {
isc_result_t result = ISC_R_NOTFOUND;
bdb_instance_t *db = (bdb_instance_t *)dbdata;
DBC *zone_cursor = NULL;
static isc_result_t
bdb_opendb(DB_ENV *db_env, DBTYPE db_type, DB **db, const char *db_name,
- char *db_file, int flags)
-{
+ char *db_file, int flags) {
int result;
/* Initialize the database. */
static isc_result_t
bdb_create(const char *dlzname, unsigned int argc, char *argv[],
- void *driverarg, void **dbdata)
-{
+ void *driverarg, void **dbdata) {
isc_result_t result;
int bdbres;
bdb_instance_t *db = NULL;
}
static void
-bdb_destroy(void *driverarg, void *dbdata)
-{
+bdb_destroy(void *driverarg, void *dbdata) {
UNUSED(driverarg);
bdb_cleanup((bdb_instance_t *)dbdata);
* Wrapper around dns_sdlzregister().
*/
isc_result_t
-dlz_bdb_init(void)
-{
+dlz_bdb_init(void) {
isc_result_t result;
/*
* Wrapper around dns_sdlzunregister().
*/
void
-dlz_bdb_clear(void)
-{
+dlz_bdb_clear(void) {
/*
* Write debugging message to log
*/
/* forward reference */
-static isc_result_t bdbhpt_findzone(void *driverarg, void *dbdata,
- const char *name,
- dns_clientinfomethods_t *methods,
- dns_clientinfo_t *clientinfo);
+static isc_result_t
+bdbhpt_findzone(void *driverarg, void *dbdata, const char *name,
+ dns_clientinfomethods_t *methods, dns_clientinfo_t *clientinfo);
/*%
* Reverses a string in place.
*/
static char *
-bdbhpt_strrev(char *str)
-{
+bdbhpt_strrev(char *str) {
char *p1, *p2;
if (!str || !*str) {
*/
static isc_result_t
-bdbhpt_parse_data(char *in, bdbhpt_parsed_data_t *pd)
-{
+bdbhpt_parse_data(char *in, bdbhpt_parsed_data_t *pd) {
char *endp, *ttlStr;
char *tmp = in;
char *lastchar = (char *)&tmp[strlen(tmp)];
static isc_result_t
bdbhpt_allowzonexfr(void *driverarg, void *dbdata, const char *name,
- const char *client)
-{
+ const char *client) {
isc_result_t result;
bdbhpt_instance_t *db = (bdbhpt_instance_t *)dbdata;
DBT key, data;
static isc_result_t
bdbhpt_allnodes(const char *zone, void *driverarg, void *dbdata,
- dns_sdlzallnodes_t *allnodes)
-{
+ dns_sdlzallnodes_t *allnodes) {
isc_result_t result = ISC_R_NOTFOUND;
bdbhpt_instance_t *db = (bdbhpt_instance_t *)dbdata;
DBC *xfr_cursor = NULL;
*/
static void
-bdbhpt_cleanup(bdbhpt_instance_t *db)
-{
+bdbhpt_cleanup(bdbhpt_instance_t *db) {
isc_mem_t *mctx;
/* close databases */
static isc_result_t
bdbhpt_findzone(void *driverarg, void *dbdata, const char *name,
- dns_clientinfomethods_t *methods, dns_clientinfo_t *clientinfo)
-{
+ dns_clientinfomethods_t *methods,
+ dns_clientinfo_t *clientinfo) {
isc_result_t result;
bdbhpt_instance_t *db = (bdbhpt_instance_t *)dbdata;
DBT key, data;
static isc_result_t
bdbhpt_lookup(const char *zone, const char *name, void *driverarg, void *dbdata,
dns_sdlzlookup_t *lookup, dns_clientinfomethods_t *methods,
- dns_clientinfo_t *clientinfo)
-{
+ dns_clientinfo_t *clientinfo) {
isc_result_t result = ISC_R_NOTFOUND;
bdbhpt_instance_t *db = (bdbhpt_instance_t *)dbdata;
DBC *data_cursor = NULL;
static isc_result_t
bdbhpt_opendb(DB_ENV *db_env, DBTYPE db_type, DB **db, const char *db_name,
- char *db_file, int flags)
-{
+ char *db_file, int flags) {
int result;
/* Initialize the database. */
static isc_result_t
bdbhpt_create(const char *dlzname, unsigned int argc, char *argv[],
- void *driverarg, void **dbdata)
-{
+ void *driverarg, void **dbdata) {
isc_result_t result;
int bdbhptres;
int bdbFlags = 0;
}
static void
-bdbhpt_destroy(void *driverarg, void *dbdata)
-{
+bdbhpt_destroy(void *driverarg, void *dbdata) {
UNUSED(driverarg);
bdbhpt_cleanup((bdbhpt_instance_t *)dbdata);
* Wrapper around dns_sdlzregister().
*/
isc_result_t
-dlz_bdbhpt_init(void)
-{
+dlz_bdbhpt_init(void) {
isc_result_t result;
/*
* Wrapper around dns_sdlzunregister().
*/
void
-dlz_bdbhpt_clear(void)
-{
+dlz_bdbhpt_clear(void) {
/*
* Write debugging message to log
*/
*/
isc_result_t
-dlz_drivers_init(void)
-{
+dlz_drivers_init(void) {
isc_result_t result = ISC_R_SUCCESS;
#ifdef DLZ_STUB
*/
void
-dlz_drivers_clear(void)
-{
+dlz_drivers_clear(void) {
#ifdef DLZ_STUB
dlz_stub_clear();
#endif /* ifdef DLZ_STUB */
/* forward reference */
-static void fs_destroy(void *driverarg, void *dbdata);
+static void
+fs_destroy(void *driverarg, void *dbdata);
/*
* Private methods
*/
static bool
-is_safe(const char *input)
-{
+is_safe(const char *input) {
unsigned int i;
unsigned int len = strlen(input);
}
static void
-create_path_helper(char *out, const char *in, config_data_t *cd)
-{
+create_path_helper(char *out, const char *in, config_data_t *cd) {
char *tmpString;
char *tmpPtr;
int i;
static isc_result_t
create_path(const char *zone, const char *host, const char *client,
- config_data_t *cd, char **path)
-{
+ config_data_t *cd, char **path) {
char *tmpPath;
int pathsize;
int len;
static isc_result_t
process_dir(isc_dir_t *dir, void *passback, config_data_t *cd,
- dlist_t *dir_list, unsigned int basedirlen)
-{
+ dlist_t *dir_list, unsigned int basedirlen) {
char tmp[PATH_MAX + NAME_MAX];
int astPos;
struct stat sb;
static isc_result_t
fs_allowzonexfr(void *driverarg, void *dbdata, const char *name,
- const char *client)
-{
+ const char *client) {
isc_result_t result;
char *path;
struct stat sb;
static isc_result_t
fs_allnodes(const char *zone, void *driverarg, void *dbdata,
- dns_sdlzallnodes_t *allnodes)
-{
+ dns_sdlzallnodes_t *allnodes) {
isc_result_t result;
dlist_t *dir_list;
config_data_t *cd;
static isc_result_t
fs_findzone(void *driverarg, void *dbdata, const char *name,
- dns_clientinfomethods_t *methods, dns_clientinfo_t *clientinfo)
-{
+ dns_clientinfomethods_t *methods, dns_clientinfo_t *clientinfo) {
isc_result_t result;
char *path;
struct stat sb;
static isc_result_t
fs_lookup(const char *zone, const char *name, void *driverarg, void *dbdata,
dns_sdlzlookup_t *lookup, dns_clientinfomethods_t *methods,
- dns_clientinfo_t *clientinfo)
-{
+ dns_clientinfo_t *clientinfo) {
isc_result_t result;
char *path;
struct stat sb;
static isc_result_t
fs_create(const char *dlzname, unsigned int argc, char *argv[], void *driverarg,
- void **dbdata)
-{
+ void **dbdata) {
config_data_t *cd;
char *endp;
int len;
}
static void
-fs_destroy(void *driverarg, void *dbdata)
-{
+fs_destroy(void *driverarg, void *dbdata) {
isc_mem_t *mctx;
config_data_t *cd;
* Wrapper around dns_sdlzregister().
*/
isc_result_t
-dlz_fs_init(void)
-{
+dlz_fs_init(void) {
isc_result_t result;
/*
* Wrapper around dns_sdlzunregister().
*/
void
-dlz_fs_clear(void)
-{
+dlz_fs_clear(void) {
/*
* Write debugging message to log
*/
/* forward references */
-static isc_result_t dlz_ldap_findzone(void *driverarg, void *dbdata,
- const char *name,
- dns_clientinfomethods_t *methods,
- dns_clientinfo_t *clientinfo);
+static isc_result_t
+dlz_ldap_findzone(void *driverarg, void *dbdata, const char *name,
+ dns_clientinfomethods_t *methods,
+ dns_clientinfo_t *clientinfo);
-static void dlz_ldap_destroy(void *driverarg, void *dbdata);
+static void
+dlz_ldap_destroy(void *driverarg, void *dbdata);
/*
* Private methods
/*% checks that the LDAP URL parameters make sense */
static isc_result_t
-dlz_ldap_checkURL(char *URL, int attrCnt, const char *msg)
-{
+dlz_ldap_checkURL(char *URL, int attrCnt, const char *msg) {
isc_result_t result = ISC_R_SUCCESS;
int ldap_result;
LDAPURLDesc *ldap_url = NULL;
/*% Connects / reconnects to LDAP server */
static isc_result_t
-dlz_ldap_connect(ldap_instance_t *dbi, dbinstance_t *dbc)
-{
+dlz_ldap_connect(ldap_instance_t *dbi, dbinstance_t *dbc) {
isc_result_t result;
int ldap_result;
* multithreaded operation.
*/
static void
-ldap_destroy_dblist(db_list_t *dblist)
-{
+ldap_destroy_dblist(db_list_t *dblist) {
dbinstance_t *ndbi = NULL;
dbinstance_t *dbi = NULL;
* multithreaded operation.
*/
static dbinstance_t *
-ldap_find_avail_conn(db_list_t *dblist)
-{
+ldap_find_avail_conn(db_list_t *dblist) {
dbinstance_t *dbi = NULL;
dbinstance_t *head;
int count = 0;
static isc_result_t
ldap_process_results(LDAP *dbc, LDAPMessage *msg, char **attrs, void *ptr,
- bool allnodes)
-{
+ bool allnodes) {
isc_result_t result = ISC_R_SUCCESS;
int i = 0;
int j;
*/
static isc_result_t
ldap_get_results(const char *zone, const char *record, const char *client,
- unsigned int query, void *dbdata, void *ptr)
-{
+ unsigned int query, void *dbdata, void *ptr) {
isc_result_t result;
dbinstance_t *dbi = NULL;
char *querystring = NULL;
*/
static isc_result_t
dlz_ldap_allowzonexfr(void *driverarg, void *dbdata, const char *name,
- const char *client)
-{
+ const char *client) {
isc_result_t result;
UNUSED(driverarg);
static isc_result_t
dlz_ldap_allnodes(const char *zone, void *driverarg, void *dbdata,
- dns_sdlzallnodes_t *allnodes)
-{
+ dns_sdlzallnodes_t *allnodes) {
UNUSED(driverarg);
return (ldap_get_results(zone, NULL, NULL, ALLNODES, dbdata, allnodes));
}
static isc_result_t
dlz_ldap_authority(const char *zone, void *driverarg, void *dbdata,
- dns_sdlzlookup_t *lookup)
-{
+ dns_sdlzlookup_t *lookup) {
UNUSED(driverarg);
return (ldap_get_results(zone, NULL, NULL, AUTHORITY, dbdata, lookup));
}
static isc_result_t
dlz_ldap_findzone(void *driverarg, void *dbdata, const char *name,
dns_clientinfomethods_t *methods,
- dns_clientinfo_t *clientinfo)
-{
+ dns_clientinfo_t *clientinfo) {
UNUSED(driverarg);
UNUSED(methods);
UNUSED(clientinfo);
static isc_result_t
dlz_ldap_lookup(const char *zone, const char *name, void *driverarg,
void *dbdata, dns_sdlzlookup_t *lookup,
- dns_clientinfomethods_t *methods, dns_clientinfo_t *clientinfo)
-{
+ dns_clientinfomethods_t *methods,
+ dns_clientinfo_t *clientinfo) {
isc_result_t result;
UNUSED(driverarg);
static isc_result_t
dlz_ldap_create(const char *dlzname, unsigned int argc, char *argv[],
- void *driverarg, void **dbdata)
-{
+ void *driverarg, void **dbdata) {
isc_result_t result;
ldap_instance_t *ldap_inst = NULL;
dbinstance_t *dbi = NULL;
}
void
-dlz_ldap_destroy(void *driverarg, void *dbdata)
-{
+dlz_ldap_destroy(void *driverarg, void *dbdata) {
UNUSED(driverarg);
if (dbdata != NULL) {
* Wrapper around dns_sdlzregister().
*/
isc_result_t
-dlz_ldap_init(void)
-{
+dlz_ldap_init(void) {
isc_result_t result;
/*
* Wrapper around dns_sdlzunregister().
*/
void
-dlz_ldap_clear(void)
-{
+dlz_ldap_clear(void) {
/*
* Write debugging message to log
*/
*/
static char *
-mysqldrv_escape_string(MYSQL *mysql, const char *instr)
-{
+mysqldrv_escape_string(MYSQL *mysql, const char *instr) {
char *outstr;
unsigned int len;
static isc_result_t
mysql_get_resultset(const char *zone, const char *record, const char *client,
- unsigned int query, void *dbdata, MYSQL_RES **rs)
-{
+ unsigned int query, void *dbdata, MYSQL_RES **rs) {
isc_result_t result;
dbinstance_t *dbi = NULL;
char *querystring = NULL;
*/
static isc_result_t
-mysql_process_rs(dns_sdlzlookup_t *lookup, MYSQL_RES *rs)
-{
+mysql_process_rs(dns_sdlzlookup_t *lookup, MYSQL_RES *rs) {
isc_result_t result = ISC_R_NOTFOUND;
MYSQL_ROW row;
unsigned int fields;
static isc_result_t
mysql_findzone(void *driverarg, void *dbdata, const char *name,
- dns_clientinfomethods_t *methods, dns_clientinfo_t *clientinfo)
-{
+ dns_clientinfomethods_t *methods, dns_clientinfo_t *clientinfo) {
isc_result_t result;
MYSQL_RES *rs = NULL;
my_ulonglong rows;
/*% Determine if the client is allowed to perform a zone transfer */
static isc_result_t
mysql_allowzonexfr(void *driverarg, void *dbdata, const char *name,
- const char *client)
-{
+ const char *client) {
isc_result_t result;
MYSQL_RES *rs = NULL;
my_ulonglong rows;
*/
static isc_result_t
mysql_allnodes(const char *zone, void *driverarg, void *dbdata,
- dns_sdlzallnodes_t *allnodes)
-{
+ dns_sdlzallnodes_t *allnodes) {
isc_result_t result;
MYSQL_RES *rs = NULL;
MYSQL_ROW row;
static isc_result_t
mysql_authority(const char *zone, void *driverarg, void *dbdata,
- dns_sdlzlookup_t *lookup)
-{
+ dns_sdlzlookup_t *lookup) {
isc_result_t result;
MYSQL_RES *rs = NULL;
static isc_result_t
mysql_lookup(const char *zone, const char *name, void *driverarg, void *dbdata,
dns_sdlzlookup_t *lookup, dns_clientinfomethods_t *methods,
- dns_clientinfo_t *clientinfo)
-{
+ dns_clientinfo_t *clientinfo) {
isc_result_t result;
MYSQL_RES *rs = NULL;
*/
static isc_result_t
mysql_create(const char *dlzname, unsigned int argc, char *argv[],
- void *driverarg, void **dbdata)
-{
+ void *driverarg, void **dbdata) {
isc_result_t result;
dbinstance_t *dbi = NULL;
char *tmp = NULL;
*/
static void
-mysql_destroy(void *driverarg, void *dbdata)
-{
+mysql_destroy(void *driverarg, void *dbdata) {
dbinstance_t *dbi;
UNUSED(driverarg);
* Wrapper around dns_sdlzregister().
*/
isc_result_t
-dlz_mysql_init(void)
-{
+dlz_mysql_init(void) {
isc_result_t result;
/*
* Wrapper around dns_sdlzunregister().
*/
void
-dlz_mysql_clear(void)
-{
+dlz_mysql_clear(void) {
/*
* Write debugging message to log
*/
/* forward reference */
-static size_t odbc_makesafe(char *to, const char *from, size_t length);
+static size_t
+odbc_makesafe(char *to, const char *from, size_t length);
/*
* Private methods
*/
static SQLSMALLINT
-safeLen(void *a)
-{
+safeLen(void *a) {
if (a == NULL) {
return (0);
}
/*% propertly cleans up an odbc_instance_t */
static void
-destroy_odbc_instance(odbc_instance_t *odbc_inst)
-{
+destroy_odbc_instance(odbc_instance_t *odbc_inst) {
dbinstance_t *ndbi = NULL;
dbinstance_t *dbi = NULL;
/*% Connects to database, and creates ODBC statements */
static isc_result_t
-odbc_connect(odbc_instance_t *dbi, odbc_db_t **dbc)
-{
+odbc_connect(odbc_instance_t *dbi, odbc_db_t **dbc) {
odbc_db_t *ndb = *dbc;
SQLRETURN sqlRes;
isc_result_t result = ISC_R_SUCCESS;
*/
static dbinstance_t *
-odbc_find_avail_conn(db_list_t *dblist)
-{
+odbc_find_avail_conn(db_list_t *dblist) {
dbinstance_t *dbi = NULL;
dbinstance_t *head;
int count = 0;
*/
static char *
-odbc_escape_string(const char *instr)
-{
+odbc_escape_string(const char *instr) {
char *outstr;
unsigned int len;
*/
static size_t
-odbc_makesafe(char *to, const char *from, size_t length)
-{
+odbc_makesafe(char *to, const char *from, size_t length) {
const char *source = from;
char *target = to;
unsigned int remaining = length;
static isc_result_t
odbc_get_resultset(const char *zone, const char *record, const char *client,
- unsigned int query, void *dbdata, dbinstance_t **r_dbi)
-{
+ unsigned int query, void *dbdata, dbinstance_t **r_dbi) {
isc_result_t result;
dbinstance_t *dbi = NULL;
char *querystring = NULL;
*/
static isc_result_t
-odbc_getField(SQLHSTMT *stmnt, SQLSMALLINT field, char **data)
-{
+odbc_getField(SQLHSTMT *stmnt, SQLSMALLINT field, char **data) {
SQLLEN size;
REQUIRE(data != NULL && *data == NULL);
static isc_result_t
odbc_getManyFields(SQLHSTMT *stmnt, SQLSMALLINT startField,
- SQLSMALLINT endField, char **retData)
-{
+ SQLSMALLINT endField, char **retData) {
isc_result_t result;
SQLLEN size;
int totSize = 0;
*/
static isc_result_t
-odbc_process_rs(dns_sdlzlookup_t *lookup, dbinstance_t *dbi)
-{
+odbc_process_rs(dns_sdlzlookup_t *lookup, dbinstance_t *dbi) {
isc_result_t result;
SQLSMALLINT fields;
SQLHSTMT *stmnt;
static isc_result_t
odbc_findzone(void *driverarg, void *dbdata, const char *name,
- dns_clientinfomethods_t *methods, dns_clientinfo_t *clientinfo)
-{
+ dns_clientinfomethods_t *methods, dns_clientinfo_t *clientinfo) {
isc_result_t result;
dbinstance_t *dbi = NULL;
/*% Determine if the client is allowed to perform a zone transfer */
static isc_result_t
odbc_allowzonexfr(void *driverarg, void *dbdata, const char *name,
- const char *client)
-{
+ const char *client) {
isc_result_t result;
dbinstance_t *dbi = NULL;
static isc_result_t
odbc_allnodes(const char *zone, void *driverarg, void *dbdata,
- dns_sdlzallnodes_t *allnodes)
-{
+ dns_sdlzallnodes_t *allnodes) {
isc_result_t result;
dbinstance_t *dbi = NULL;
SQLHSTMT *stmnt;
static isc_result_t
odbc_authority(const char *zone, void *driverarg, void *dbdata,
- dns_sdlzlookup_t *lookup)
-{
+ dns_sdlzlookup_t *lookup) {
isc_result_t result;
dbinstance_t *dbi = NULL;
static isc_result_t
odbc_lookup(const char *zone, const char *name, void *driverarg, void *dbdata,
dns_sdlzlookup_t *lookup, dns_clientinfomethods_t *methods,
- dns_clientinfo_t *clientinfo)
-{
+ dns_clientinfo_t *clientinfo) {
isc_result_t result;
dbinstance_t *dbi = NULL;
*/
static isc_result_t
odbc_create(const char *dlzname, unsigned int argc, char *argv[],
- void *driverarg, void **dbdata)
-{
+ void *driverarg, void **dbdata) {
isc_result_t result;
odbc_instance_t *odbc_inst = NULL;
dbinstance_t *db = NULL;
*/
static void
-odbc_destroy(void *driverarg, void *dbdata)
-{
+odbc_destroy(void *driverarg, void *dbdata) {
UNUSED(driverarg);
destroy_odbc_instance((odbc_instance_t *)dbdata);
* Wrapper around dns_sdlzregister().
*/
isc_result_t
-dlz_odbc_init(void)
-{
+dlz_odbc_init(void) {
isc_result_t result;
/*
* Wrapper around dns_sdlzunregister().
*/
void
-dlz_odbc_clear(void)
-{
+dlz_odbc_clear(void) {
/*
* Write debugging message to log
*/
*/
static size_t
-postgres_makesafe(char *to, const char *from, size_t length)
-{
+postgres_makesafe(char *to, const char *from, size_t length) {
const char *source = from;
char *target = to;
unsigned int remaining = length;
* multithreaded operation.
*/
static void
-postgres_destroy_dblist(db_list_t *dblist)
-{
+postgres_destroy_dblist(db_list_t *dblist) {
dbinstance_t *ndbi = NULL;
dbinstance_t *dbi = NULL;
*/
static dbinstance_t *
-postgres_find_avail_conn(db_list_t *dblist)
-{
+postgres_find_avail_conn(db_list_t *dblist) {
dbinstance_t *dbi = NULL;
dbinstance_t *head;
int count = 0;
*/
static char *
-postgres_escape_string(const char *instr)
-{
+postgres_escape_string(const char *instr) {
char *outstr;
unsigned int len;
*/
static isc_result_t
postgres_get_resultset(const char *zone, const char *record, const char *client,
- unsigned int query, void *dbdata, PGresult **rs)
-{
+ unsigned int query, void *dbdata, PGresult **rs) {
isc_result_t result;
dbinstance_t *dbi = NULL;
char *querystring = NULL;
*/
static isc_result_t
-postgres_process_rs(dns_sdlzlookup_t *lookup, PGresult *rs)
-{
+postgres_process_rs(dns_sdlzlookup_t *lookup, PGresult *rs) {
isc_result_t result;
unsigned int i;
unsigned int rows;
static isc_result_t
postgres_findzone(void *driverarg, void *dbdata, const char *name,
dns_clientinfomethods_t *methods,
- dns_clientinfo_t *clientinfo)
-{
+ dns_clientinfo_t *clientinfo) {
isc_result_t result;
PGresult *rs = NULL;
unsigned int rows;
/*% Determine if the client is allowed to perform a zone transfer */
static isc_result_t
postgres_allowzonexfr(void *driverarg, void *dbdata, const char *name,
- const char *client)
-{
+ const char *client) {
isc_result_t result;
PGresult *rs = NULL;
unsigned int rows;
*/
static isc_result_t
postgres_allnodes(const char *zone, void *driverarg, void *dbdata,
- dns_sdlzallnodes_t *allnodes)
-{
+ dns_sdlzallnodes_t *allnodes) {
isc_result_t result;
PGresult *rs = NULL;
unsigned int i;
static isc_result_t
postgres_authority(const char *zone, void *driverarg, void *dbdata,
- dns_sdlzlookup_t *lookup)
-{
+ dns_sdlzlookup_t *lookup) {
isc_result_t result;
PGresult *rs = NULL;
static isc_result_t
postgres_lookup(const char *zone, const char *name, void *driverarg,
void *dbdata, dns_sdlzlookup_t *lookup,
- dns_clientinfomethods_t *methods, dns_clientinfo_t *clientinfo)
-{
+ dns_clientinfomethods_t *methods,
+ dns_clientinfo_t *clientinfo) {
isc_result_t result;
PGresult *rs = NULL;
*/
static isc_result_t
postgres_create(const char *dlzname, unsigned int argc, char *argv[],
- void *driverarg, void **dbdata)
-{
+ void *driverarg, void **dbdata) {
isc_result_t result;
dbinstance_t *dbi = NULL;
unsigned int j;
* so we really only need to clean it up since we are not using driverarg.
*/
static void
-postgres_destroy(void *driverarg, void *dbdata)
-{
+postgres_destroy(void *driverarg, void *dbdata) {
UNUSED(driverarg);
/* cleanup the list of DBI's */
postgres_destroy_dblist((db_list_t *)dbdata);
* Wrapper around dns_sdlzregister().
*/
isc_result_t
-dlz_postgres_init(void)
-{
+dlz_postgres_init(void) {
isc_result_t result;
/*
* Wrapper around dns_sdlzunregister().
*/
void
-dlz_postgres_clear(void)
-{
+dlz_postgres_clear(void) {
/*
* Write debugging message to log
*/
static isc_result_t
stub_dlz_allnodes(const char *zone, void *driverarg, void *dbdata,
- dns_sdlzallnodes_t *allnodes)
-{
+ dns_sdlzallnodes_t *allnodes) {
config_data_t *cd;
isc_result_t result;
static isc_result_t
stub_dlz_allowzonexfr(void *driverarg, void *dbdata, const char *name,
- const char *client)
-{
+ const char *client) {
config_data_t *cd;
UNUSED(driverarg);
static isc_result_t
stub_dlz_authority(const char *zone, void *driverarg, void *dbdata,
- dns_sdlzlookup_t *lookup)
-{
+ dns_sdlzlookup_t *lookup) {
isc_result_t result;
config_data_t *cd;
static isc_result_t
stub_dlz_findzonedb(void *driverarg, void *dbdata, const char *name,
dns_clientinfomethods_t *methods,
- dns_clientinfo_t *clientinfo)
-{
+ dns_clientinfo_t *clientinfo) {
config_data_t *cd;
UNUSED(driverarg);
static isc_result_t
stub_dlz_lookup(const char *zone, const char *name, void *driverarg,
void *dbdata, dns_sdlzlookup_t *lookup,
- dns_clientinfomethods_t *methods, dns_clientinfo_t *clientinfo)
-{
+ dns_clientinfomethods_t *methods,
+ dns_clientinfo_t *clientinfo) {
isc_result_t result;
config_data_t *cd;
static isc_result_t
stub_dlz_create(const char *dlzname, unsigned int argc, char *argv[],
- void *driverarg, void **dbdata)
-{
+ void *driverarg, void **dbdata) {
config_data_t *cd;
UNUSED(driverarg);
}
static void
-stub_dlz_destroy(void *driverarg, void *dbdata)
-{
+stub_dlz_destroy(void *driverarg, void *dbdata) {
config_data_t *cd;
isc_mem_t *mctx;
* Wrapper around dns_sdlzregister().
*/
isc_result_t
-dlz_stub_init(void)
-{
+dlz_stub_init(void) {
isc_result_t result;
/*
* Wrapper around dns_sdlzunregister().
*/
void
-dlz_stub_clear(void)
-{
+dlz_stub_clear(void) {
/*
* Write debugging message to log
*/
* special tokens are %zone%, %record%, %client%
*/
struct query_segment {
- void * sql;
+ void *sql;
unsigned int strlen;
- bool direct;
+ bool direct;
ISC_LINK(query_segment_t) link;
};
* make sure no two threads try to use the same DBI at a time.
*/
struct dbinstance {
- void * dbconn;
+ void *dbconn;
query_list_t *allnodes_q;
query_list_t *allowxfr_q;
query_list_t *authority_q;
query_list_t *findzone_q;
query_list_t *lookup_q;
query_list_t *countzone_q;
- char * query_buf;
- char * zone;
- char * record;
- char * client;
- isc_mem_t * mctx;
- isc_mutex_t instance_lock;
+ char *query_buf;
+ char *zone;
+ char *record;
+ char *client;
+ isc_mem_t *mctx;
+ isc_mutex_t instance_lock;
ISC_LINK(dbinstance_t) link;
};
*/
static void
-destroy_querylist(isc_mem_t *mctx, query_list_t **querylist)
-{
+destroy_querylist(isc_mem_t *mctx, query_list_t **querylist) {
query_segment_t *tseg = NULL;
query_segment_t *nseg = NULL;
static isc_result_t
build_querylist(isc_mem_t *mctx, const char *query_str, char **zone,
char **record, char **client, query_list_t **querylist,
- unsigned int flags)
-{
+ unsigned int flags) {
isc_result_t result;
bool foundzone = false;
bool foundrecord = false;
* used to be in our queries from named.conf
*/
char *
-sdlzh_build_querystring(isc_mem_t *mctx, query_list_t *querylist)
-{
+sdlzh_build_querystring(isc_mem_t *mctx, query_list_t *querylist) {
query_segment_t *tseg = NULL;
unsigned int length = 0;
char *qs = NULL;
sdlzh_build_sqldbinstance(isc_mem_t *mctx, const char *allnodes_str,
const char *allowxfr_str, const char *authority_str,
const char *findzone_str, const char *lookup_str,
- const char *countzone_str, dbinstance_t **dbi)
-{
+ const char *countzone_str, dbinstance_t **dbi) {
isc_result_t result;
dbinstance_t *db = NULL;
}
void
-sdlzh_destroy_sqldbinstance(dbinstance_t *dbi)
-{
+sdlzh_destroy_sqldbinstance(dbinstance_t *dbi) {
isc_mem_t *mctx;
/* save mctx for later */
}
char *
-sdlzh_get_parameter_value(isc_mem_t *mctx, const char *input, const char *key)
-{
+sdlzh_get_parameter_value(isc_mem_t *mctx, const char *input, const char *key) {
int keylen;
char *keystart;
char value[255];
};
static bool
-single_valued(const char *type)
-{
+single_valued(const char *type) {
const char *single[] = { "soa", "cname", NULL };
int i;
*/
static isc_result_t
add_name(struct dlz_example_data *state, struct record *list, const char *name,
- const char *type, dns_ttl_t ttl, const char *data)
-{
+ const char *type, dns_ttl_t ttl, const char *data) {
int i;
bool single = single_valued(type);
int first_empty = -1;
*/
static isc_result_t
del_name(struct dlz_example_data *state, struct record *list, const char *name,
- const char *type, dns_ttl_t ttl, const char *data)
-{
+ const char *type, dns_ttl_t ttl, const char *data) {
int i;
UNUSED(state);
}
static isc_result_t
-fmt_address(isc_sockaddr_t *addr, char *buffer, size_t size)
-{
+fmt_address(isc_sockaddr_t *addr, char *buffer, size_t size) {
char addr_buf[100];
const char *ret;
uint16_t port = 0;
* Return the version of the API
*/
int
-dlz_version(unsigned int *flags)
-{
+dlz_version(unsigned int *flags) {
UNUSED(flags);
return (DLZ_DLOPEN_VERSION);
}
*/
static void
b9_add_helper(struct dlz_example_data *state, const char *helper_name,
- void *ptr)
-{
+ void *ptr) {
if (strcmp(helper_name, "log") == 0) {
state->log = (log_t *)ptr;
}
*/
isc_result_t
dlz_create(const char *dlzname, unsigned int argc, char *argv[], void **dbdata,
- ...)
-{
+ ...) {
struct dlz_example_data *state;
const char *helper_name;
va_list ap;
* Shut down the backend
*/
void
-dlz_destroy(void *dbdata)
-{
+dlz_destroy(void *dbdata) {
struct dlz_example_data *state = (struct dlz_example_data *)dbdata;
if (state->log != NULL) {
*/
isc_result_t
dlz_findzonedb(void *dbdata, const char *name, dns_clientinfomethods_t *methods,
- dns_clientinfo_t *clientinfo)
-{
+ dns_clientinfo_t *clientinfo) {
struct dlz_example_data *state = (struct dlz_example_data *)dbdata;
isc_sockaddr_t *src;
char addrbuf[100];
isc_result_t
dlz_lookup(const char *zone, const char *name, void *dbdata,
dns_sdlzlookup_t *lookup, dns_clientinfomethods_t *methods,
- dns_clientinfo_t *clientinfo)
-{
+ dns_clientinfo_t *clientinfo) {
isc_result_t result;
struct dlz_example_data *state = (struct dlz_example_data *)dbdata;
bool found = false;
* See if a zone transfer is allowed
*/
isc_result_t
-dlz_allowzonexfr(void *dbdata, const char *name, const char *client)
-{
+dlz_allowzonexfr(void *dbdata, const char *name, const char *client) {
UNUSED(client);
/* Just say yes for all our zones */
* Perform a zone transfer
*/
isc_result_t
-dlz_allnodes(const char *zone, void *dbdata, dns_sdlzallnodes_t *allnodes)
-{
+dlz_allnodes(const char *zone, void *dbdata, dns_sdlzallnodes_t *allnodes) {
struct dlz_example_data *state = (struct dlz_example_data *)dbdata;
int i;
* Start a transaction
*/
isc_result_t
-dlz_newversion(const char *zone, void *dbdata, void **versionp)
-{
+dlz_newversion(const char *zone, void *dbdata, void **versionp) {
struct dlz_example_data *state = (struct dlz_example_data *)dbdata;
if (state->transaction_started) {
* End a transaction
*/
void
-dlz_closeversion(const char *zone, bool commit, void *dbdata, void **versionp)
-{
+dlz_closeversion(const char *zone, bool commit, void *dbdata, void **versionp) {
struct dlz_example_data *state = (struct dlz_example_data *)dbdata;
if (!state->transaction_started) {
* Configure a writeable zone
*/
isc_result_t
-dlz_configure(dns_view_t *view, dns_dlzdb_t *dlzdb, void *dbdata)
-{
+dlz_configure(dns_view_t *view, dns_dlzdb_t *dlzdb, void *dbdata) {
struct dlz_example_data *state = (struct dlz_example_data *)dbdata;
isc_result_t result;
bool
dlz_ssumatch(const char *signer, const char *name, const char *tcpaddr,
const char *type, const char *key, uint32_t keydatalen,
- unsigned char *keydata, void *dbdata)
-{
+ unsigned char *keydata, void *dbdata) {
struct dlz_example_data *state = (struct dlz_example_data *)dbdata;
UNUSED(tcpaddr);
static isc_result_t
modrdataset(struct dlz_example_data *state, const char *name,
- const char *rdatastr, struct record *list)
-{
+ const char *rdatastr, struct record *list) {
char *full_name, *dclass, *type, *data, *ttlstr, *buf;
char absolute[1024];
isc_result_t result;
isc_result_t
dlz_addrdataset(const char *name, const char *rdatastr, void *dbdata,
- void *version)
-{
+ void *version) {
struct dlz_example_data *state = (struct dlz_example_data *)dbdata;
if (version != (void *)&state->transaction_started) {
isc_result_t
dlz_subrdataset(const char *name, const char *rdatastr, void *dbdata,
- void *version)
-{
+ void *version) {
struct dlz_example_data *state = (struct dlz_example_data *)dbdata;
if (version != (void *)&state->transaction_started) {
}
isc_result_t
-dlz_delrdataset(const char *name, const char *type, void *dbdata, void *version)
-{
+dlz_delrdataset(const char *name, const char *type, void *dbdata,
+ void *version) {
struct dlz_example_data *state = (struct dlz_example_data *)dbdata;
if (version != (void *)&state->transaction_started) {
* Called when we enter the DLL
*/
__declspec(dllexport) BOOL WINAPI
- DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
-{
+ DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved) {
switch (fdwReason) {
/*
* The DLL is loading due to process
char *data;
} bdbhpt_parsed_data_t;
-static void b9_add_helper(struct bdbhpt_instance *db, const char *helper_name,
- void *ptr);
+static void
+b9_add_helper(struct bdbhpt_instance *db, const char *helper_name, void *ptr);
/*%
* Reverses a string in place.
*/
static char *
-bdbhpt_strrev(char *str)
-{
+bdbhpt_strrev(char *str) {
char *p1, *p2;
if (!str || !*str) {
*/
static isc_result_t
-bdbhpt_parse_data(log_t *log, char *in, bdbhpt_parsed_data_t *pd)
-{
+bdbhpt_parse_data(log_t *log, char *in, bdbhpt_parsed_data_t *pd) {
char *endp, *ttlStr;
char *tmp = in;
char *lastchar = (char *)&tmp[strlen(tmp)];
* See if a zone transfer is allowed
*/
isc_result_t
-dlz_allowzonexfr(void *dbdata, const char *name, const char *client)
-{
+dlz_allowzonexfr(void *dbdata, const char *name, const char *client) {
isc_result_t result;
bdbhpt_instance_t *db = (bdbhpt_instance_t *)dbdata;
DBT key, data;
* updates by a separate process).
*/
isc_result_t
-dlz_allnodes(const char *zone, void *dbdata, dns_sdlzallnodes_t *allnodes)
-{
+dlz_allnodes(const char *zone, void *dbdata, dns_sdlzallnodes_t *allnodes) {
isc_result_t result = ISC_R_NOTFOUND;
bdbhpt_instance_t *db = (bdbhpt_instance_t *)dbdata;
DBC *xfr_cursor = NULL;
* Used by bdbhpt_destroy when the driver is shutting down.
*/
static void
-bdbhpt_cleanup(bdbhpt_instance_t *db)
-{
+bdbhpt_cleanup(bdbhpt_instance_t *db) {
/* close databases */
if (db->data != NULL) {
db->data->close(db->data, 0);
*/
static isc_result_t
bdbhpt_opendb(log_t *log, DB_ENV *db_env, DBTYPE db_type, DB **db,
- const char *db_name, char *db_file, int flags)
-{
+ const char *db_name, char *db_file, int flags) {
int result;
/* Initialise the database. */
*/
isc_result_t
dlz_create(const char *dlzname, unsigned int argc, char *argv[], void **dbdata,
- ...)
-{
+ ...) {
isc_result_t result;
int bdbhptres;
int bdbFlags = 0;
* Shut down the backend
*/
void
-dlz_destroy(void *dbdata)
-{
+dlz_destroy(void *dbdata) {
struct bdbhpt_instance *db = (struct bdbhpt_instance *)dbdata;
db->log(ISC_LOG_INFO, "dlz_bdbhpt_dynamic (%s): shutting down",
* Return the version of the API
*/
int
-dlz_version(unsigned int *flags)
-{
+dlz_version(unsigned int *flags) {
UNUSED(flags);
return (DLZ_DLOPEN_VERSION);
}
* Register a helper function from the bind9 dlz_dlopen driver
*/
static void
-b9_add_helper(struct bdbhpt_instance *db, const char *helper_name, void *ptr)
-{
+b9_add_helper(struct bdbhpt_instance *db, const char *helper_name, void *ptr) {
if (strcmp(helper_name, "log") == 0) {
db->log = (log_t *)ptr;
}
*/
void
-destroy_querylist(query_list_t **querylist)
-{
+destroy_querylist(query_list_t **querylist) {
query_segment_t *tseg = NULL;
query_segment_t *nseg = NULL;
isc_result_t
build_querylist(const char *query_str, char **zone, char **record,
char **client, query_list_t **querylist, unsigned int flags,
- log_t log)
-{
+ log_t log) {
isc_result_t result;
bool foundzone = false;
bool foundrecord = false;
* used to be in our queries from named.conf
*/
char *
-build_querystring(query_list_t *querylist)
-{
+build_querystring(query_list_t *querylist) {
query_segment_t *tseg = NULL;
unsigned int length = 0;
char *qs = NULL;
build_dbinstance(const char *allnodes_str, const char *allowxfr_str,
const char *authority_str, const char *findzone_str,
const char *lookup_str, const char *countzone_str,
- dbinstance_t **dbi, log_t log)
-{
+ dbinstance_t **dbi, log_t log) {
isc_result_t result;
dbinstance_t *db = NULL;
int err;
}
void
-destroy_dbinstance(dbinstance_t *dbi)
-{
+destroy_dbinstance(dbinstance_t *dbi) {
/* destroy any query lists we created */
destroy_querylist(&dbi->allnodes_q);
destroy_querylist(&dbi->allowxfr_q);
}
char *
-get_parameter_value(const char *input, const char *key)
-{
+get_parameter_value(const char *input, const char *key) {
int keylen;
char *keystart;
char value[255];
#include <sys/types.h>
void
-dir_init(dir_t *dir)
-{
+dir_init(dir_t *dir) {
dir->entry.name[0] = '\0';
dir->entry.length = 0;
}
isc_result_t
-dir_open(dir_t *dir, const char *dirname)
-{
+dir_open(dir_t *dir, const char *dirname) {
char *p;
isc_result_t result = ISC_R_SUCCESS;
* the dir stream and reads the first file in one operation.
*/
isc_result_t
-dir_read(dir_t *dir)
-{
+dir_read(dir_t *dir) {
struct dirent *entry;
entry = readdir(dir->handle);
* \brief Close directory stream.
*/
void
-dir_close(dir_t *dir)
-{
+dir_close(dir_t *dir) {
(void)closedir(dir->handle);
dir->handle = NULL;
}
* \brief Reposition directory stream at start.
*/
isc_result_t
-dir_reset(dir_t *dir)
-{
+dir_reset(dir_t *dir) {
rewinddir(dir->handle);
return (ISC_R_SUCCESS);
#define DIR_PATHMAX 1024
typedef struct direntry {
- char name[DIR_NAMEMAX];
+ char name[DIR_NAMEMAX];
unsigned int length;
} direntry_t;
typedef struct dir {
- char dirname[DIR_PATHMAX];
+ char dirname[DIR_PATHMAX];
direntry_t entry;
- DIR * handle;
+ DIR *handle;
} dir_t;
void
/* forward reference */
-static void b9_add_helper(struct config_data *cd, const char *helper_name,
- void *ptr);
+static void
+b9_add_helper(struct config_data *cd, const char *helper_name, void *ptr);
/*
* Private methods
*/
static bool
-is_safe(const char *input)
-{
+is_safe(const char *input) {
unsigned int i;
unsigned int len = strlen(input);
}
static isc_result_t
-create_path_helper(char *out, const char *in, config_data_t *cd)
-{
+create_path_helper(char *out, const char *in, config_data_t *cd) {
char *tmpString;
char *tmpPtr;
int i;
static isc_result_t
create_path(const char *zone, const char *host, const char *client,
- config_data_t *cd, char **path)
-{
+ config_data_t *cd, char **path) {
char *tmpPath;
int pathsize;
int len;
static isc_result_t
process_dir(dir_t *dir, void *passback, config_data_t *cd, dlist_t *dir_list,
- unsigned int basedirlen)
-{
+ unsigned int basedirlen) {
char tmp[DIR_PATHMAX + DIR_NAMEMAX];
int astPos;
struct stat sb;
* DLZ methods
*/
isc_result_t
-dlz_allowzonexfr(void *dbdata, const char *name, const char *client)
-{
+dlz_allowzonexfr(void *dbdata, const char *name, const char *client) {
isc_result_t result;
char *path;
struct stat sb;
}
isc_result_t
-dlz_allnodes(const char *zone, void *dbdata, dns_sdlzallnodes_t *allnodes)
-{
+dlz_allnodes(const char *zone, void *dbdata, dns_sdlzallnodes_t *allnodes) {
isc_result_t result;
dlist_t *dir_list;
config_data_t *cd = (config_data_t *)dbdata;
isc_result_t
dlz_create(const char *dlzname, unsigned int argc, char *argv[], void **dbdata,
- ...)
-{
+ ...) {
isc_result_t result = ISC_R_NOMEMORY;
config_data_t *cd;
char *endp;
}
void
-dlz_destroy(void *dbdata)
-{
+dlz_destroy(void *dbdata) {
config_data_t *cd;
cd = (config_data_t *)dbdata;
* Return the version of the API
*/
int
-dlz_version(unsigned int *flags)
-{
+dlz_version(unsigned int *flags) {
UNUSED(flags);
return (DLZ_DLOPEN_VERSION);
}
* Register a helper function from the bind9 dlz_dlopen driver
*/
static void
-b9_add_helper(struct config_data *cd, const char *helper_name, void *ptr)
-{
+b9_add_helper(struct config_data *cd, const char *helper_name, void *ptr) {
if (strcmp(helper_name, "log") == 0) {
cd->log = (log_t *)ptr;
}
* special tokens are %zone%, %record%, %client%
*/
struct query_segment {
- void * cmd;
+ void *cmd;
unsigned int strlen;
- bool direct;
+ bool direct;
DLZ_LINK(query_segment_t) link;
};
* make sure no two threads try to use the same DBI at a time.
*/
struct dbinstance {
- void * dbconn;
+ void *dbconn;
query_list_t *allnodes_q;
query_list_t *allowxfr_q;
query_list_t *authority_q;
query_list_t *findzone_q;
query_list_t *lookup_q;
query_list_t *countzone_q;
- char * query_buf;
- char * zone;
- char * record;
- char * client;
- dlz_mutex_t lock;
+ char *query_buf;
+ char *zone;
+ char *record;
+ char *client;
+ dlz_mutex_t lock;
DLZ_LINK(dbinstance_t) link;
};
#include <netinet/in.h>
typedef unsigned int isc_result_t;
-typedef uint32_t dns_ttl_t;
+typedef uint32_t dns_ttl_t;
/*
* Define DLZ_DLOPEN_VERSION to different values to use older versions
do { \
union { \
const void *k; \
- void * v; \
+ void *v; \
} _u; \
_u.k = konst; \
var = _u.v; \
*/
typedef struct isc_sockaddr {
union {
- struct sockaddr sa;
- struct sockaddr_in sin;
+ struct sockaddr sa;
+ struct sockaddr_in sin;
struct sockaddr_in6 sin6;
#ifdef ISC_PLATFORM_HAVESYSUNH
struct sockaddr_un sunix;
#endif /* ifdef ISC_PLATFORM_HAVESYSUNH */
} type;
unsigned int length;
- void * link;
+ void *link;
} isc_sockaddr_t;
#define DNS_CLIENTINFO_VERSION 2
typedef struct dns_clientinfo {
uint16_t version;
- void * data;
- void * dbversion;
+ void *data;
+ void *dbversion;
} dns_clientinfo_t;
typedef isc_result_t (*dns_clientinfo_sourceip_t)(dns_clientinfo_t *client,
- isc_sockaddr_t ** addrp);
+ isc_sockaddr_t **addrp);
typedef isc_result_t (*dns_clientinfo_version_t)(dns_clientinfo_t *client,
- void ** addrp);
+ void **addrp);
#define DNS_CLIENTINFOMETHODS_VERSION 2
#define DNS_CLIENTINFOMETHODS_AGE 1
typedef struct dns_clientinfomethods {
- uint16_t version;
- uint16_t age;
+ uint16_t version;
+ uint16_t age;
dns_clientinfo_sourceip_t sourceip;
- dns_clientinfo_version_t dbversion;
+ dns_clientinfo_version_t dbversion;
} dns_clientinfomethods_t;
#endif /* DLZ_DLOPEN_VERSION > 1 */
/* forward references */
#if DLZ_DLOPEN_VERSION < 3
-isc_result_t dlz_findzonedb(void *dbdata, const char *name);
+isc_result_t
+dlz_findzonedb(void *dbdata, const char *name);
#else /* if DLZ_DLOPEN_VERSION < 3 */
-isc_result_t dlz_findzonedb(void *dbdata, const char *name,
- dns_clientinfomethods_t *methods,
- dns_clientinfo_t *clientinfo);
+isc_result_t
+dlz_findzonedb(void *dbdata, const char *name, dns_clientinfomethods_t *methods,
+ dns_clientinfo_t *clientinfo);
#endif /* if DLZ_DLOPEN_VERSION < 3 */
-void dlz_destroy(void *dbdata);
+void
+dlz_destroy(void *dbdata);
-static void b9_add_helper(ldap_instance_t *db, const char *helper_name,
- void *ptr);
+static void
+b9_add_helper(ldap_instance_t *db, const char *helper_name, void *ptr);
/*
* Private methods
/*% checks that the LDAP URL parameters make sense */
static isc_result_t
-ldap_checkURL(ldap_instance_t *db, char *URL, int attrCnt, const char *msg)
-{
+ldap_checkURL(ldap_instance_t *db, char *URL, int attrCnt, const char *msg) {
isc_result_t result = ISC_R_SUCCESS;
int ldap_result;
LDAPURLDesc *ldap_url = NULL;
/*% Connects / reconnects to LDAP server */
static isc_result_t
-ldap_connect(ldap_instance_t *dbi, dbinstance_t *dbc)
-{
+ldap_connect(ldap_instance_t *dbi, dbinstance_t *dbc) {
isc_result_t result;
int ldap_result;
* multithreaded operation.
*/
static void
-ldap_destroy_dblist(db_list_t *dblist)
-{
+ldap_destroy_dblist(db_list_t *dblist) {
dbinstance_t *ndbi = NULL;
dbinstance_t *dbi = NULL;
* multithreaded operation.
*/
static dbinstance_t *
-ldap_find_avail_conn(ldap_instance_t *ldap)
-{
+ldap_find_avail_conn(ldap_instance_t *ldap) {
dbinstance_t *dbi = NULL;
dbinstance_t *head;
int count = 0;
static isc_result_t
ldap_process_results(ldap_instance_t *db, LDAP *dbc, LDAPMessage *msg,
- char **attrs, void *ptr, bool allnodes)
-{
+ char **attrs, void *ptr, bool allnodes) {
isc_result_t result = ISC_R_SUCCESS;
int i = 0;
int j;
*/
static isc_result_t
ldap_get_results(const char *zone, const char *record, const char *client,
- unsigned int query, void *dbdata, void *ptr)
-{
+ unsigned int query, void *dbdata, void *ptr) {
isc_result_t result;
ldap_instance_t *db = (ldap_instance_t *)dbdata;
dbinstance_t *dbi = NULL;
* DLZ methods
*/
isc_result_t
-dlz_allowzonexfr(void *dbdata, const char *name, const char *client)
-{
+dlz_allowzonexfr(void *dbdata, const char *name, const char *client) {
isc_result_t result;
/* check to see if we are authoritative for the zone first */
}
isc_result_t
-dlz_allnodes(const char *zone, void *dbdata, dns_sdlzallnodes_t *allnodes)
-{
+dlz_allnodes(const char *zone, void *dbdata, dns_sdlzallnodes_t *allnodes) {
return (ldap_get_results(zone, NULL, NULL, ALLNODES, dbdata, allnodes));
}
isc_result_t
-dlz_authority(const char *zone, void *dbdata, dns_sdlzlookup_t *lookup)
-{
+dlz_authority(const char *zone, void *dbdata, dns_sdlzlookup_t *lookup) {
return (ldap_get_results(zone, NULL, NULL, AUTHORITY, dbdata, lookup));
}
isc_result_t
dlz_create(const char *dlzname, unsigned int argc, char *argv[], void **dbdata,
- ...)
-{
+ ...) {
isc_result_t result = ISC_R_FAILURE;
ldap_instance_t *ldap = NULL;
dbinstance_t *dbi = NULL;
}
void
-dlz_destroy(void *dbdata)
-{
+dlz_destroy(void *dbdata) {
if (dbdata != NULL) {
ldap_instance_t *db = (ldap_instance_t *)dbdata;
#if PTHREADS
* Return the version of the API
*/
int
-dlz_version(unsigned int *flags)
-{
+dlz_version(unsigned int *flags) {
*flags |= DNS_SDLZFLAG_RELATIVERDATA;
#if PTHREADS
*flags |= DNS_SDLZFLAG_THREADSAFE;
* Register a helper function from the bind9 dlz_dlopen driver
*/
static void
-b9_add_helper(ldap_instance_t *db, const char *helper_name, void *ptr)
-{
+b9_add_helper(ldap_instance_t *db, const char *helper_name, void *ptr) {
if (strcmp(helper_name, "log") == 0) {
db->log = (log_t *)ptr;
}
} mysql_instance_t;
/* forward references */
-isc_result_t dlz_findzonedb(void *dbdata, const char *name,
- dns_clientinfomethods_t *methods,
- dns_clientinfo_t *clientinfo);
+isc_result_t
+dlz_findzonedb(void *dbdata, const char *name, dns_clientinfomethods_t *methods,
+ dns_clientinfo_t *clientinfo);
-void dlz_destroy(void *dbdata);
+void
+dlz_destroy(void *dbdata);
-static void b9_add_helper(mysql_instance_t *db, const char *helper_name,
- void *ptr);
+static void
+b9_add_helper(mysql_instance_t *db, const char *helper_name, void *ptr);
/*
* Private methods
*/
void
-mysql_destroy(dbinstance_t *db)
-{
+mysql_destroy(dbinstance_t *db) {
/* release DB connection */
if (db->dbconn != NULL) {
mysql_close((MYSQL *)db->dbconn);
* multithreaded operation.
*/
static void
-mysql_destroy_dblist(db_list_t *dblist)
-{
+mysql_destroy_dblist(db_list_t *dblist) {
dbinstance_t *ndbi = NULL;
dbinstance_t *dbi = NULL;
* multithreaded operation.
*/
static dbinstance_t *
-mysql_find_avail_conn(mysql_instance_t *mysql)
-{
+mysql_find_avail_conn(mysql_instance_t *mysql) {
dbinstance_t *dbi = NULL, *head;
int count = 0;
* want special characters in the string causing problems.
*/
static char *
-mysqldrv_escape_string(MYSQL *mysql, const char *instr)
-{
+mysqldrv_escape_string(MYSQL *mysql, const char *instr) {
char *outstr;
unsigned int len;
*/
static isc_result_t
mysql_get_resultset(const char *zone, const char *record, const char *client,
- unsigned int query, void *dbdata, MYSQL_RES **rs)
-{
+ unsigned int query, void *dbdata, MYSQL_RES **rs) {
isc_result_t result;
dbinstance_t *dbi = NULL;
mysql_instance_t *db = (mysql_instance_t *)dbdata;
* into this function to minimize code.
*/
static isc_result_t
-mysql_process_rs(mysql_instance_t *db, dns_sdlzlookup_t *lookup, MYSQL_RES *rs)
-{
+mysql_process_rs(mysql_instance_t *db, dns_sdlzlookup_t *lookup,
+ MYSQL_RES *rs) {
isc_result_t result = ISC_R_NOTFOUND;
MYSQL_ROW row;
unsigned int fields;
/*% determine if the zone is supported by (in) the database */
isc_result_t
dlz_findzonedb(void *dbdata, const char *name, dns_clientinfomethods_t *methods,
- dns_clientinfo_t *clientinfo)
-{
+ dns_clientinfo_t *clientinfo) {
isc_result_t result;
MYSQL_RES *rs = NULL;
my_ulonglong rows;
/*% Determine if the client is allowed to perform a zone transfer */
isc_result_t
-dlz_allowzonexfr(void *dbdata, const char *name, const char *client)
-{
+dlz_allowzonexfr(void *dbdata, const char *name, const char *client) {
isc_result_t result;
mysql_instance_t *db = (mysql_instance_t *)dbdata;
MYSQL_RES *rs = NULL;
* query.
*/
isc_result_t
-dlz_allnodes(const char *zone, void *dbdata, dns_sdlzallnodes_t *allnodes)
-{
+dlz_allnodes(const char *zone, void *dbdata, dns_sdlzallnodes_t *allnodes) {
isc_result_t result;
mysql_instance_t *db = (mysql_instance_t *)dbdata;
MYSQL_RES *rs = NULL;
* use this function to get that information for named.
*/
isc_result_t
-dlz_authority(const char *zone, void *dbdata, dns_sdlzlookup_t *lookup)
-{
+dlz_authority(const char *zone, void *dbdata, dns_sdlzlookup_t *lookup) {
isc_result_t result;
MYSQL_RES *rs = NULL;
mysql_instance_t *db = (mysql_instance_t *)dbdata;
isc_result_t
dlz_lookup(const char *zone, const char *name, void *dbdata,
dns_sdlzlookup_t *lookup, dns_clientinfomethods_t *methods,
- dns_clientinfo_t *clientinfo)
-{
+ dns_clientinfo_t *clientinfo) {
isc_result_t result;
MYSQL_RES *rs = NULL;
mysql_instance_t *db = (mysql_instance_t *)dbdata;
*/
isc_result_t
dlz_create(const char *dlzname, unsigned int argc, char *argv[], void **dbdata,
- ...)
-{
+ ...) {
isc_result_t result = ISC_R_FAILURE;
mysql_instance_t *mysql = NULL;
dbinstance_t *dbi = NULL;
* Destroy the module.
*/
void
-dlz_destroy(void *dbdata)
-{
+dlz_destroy(void *dbdata) {
mysql_instance_t *db = (mysql_instance_t *)dbdata;
#if PTHREADS
/* cleanup the list of DBI's */
* Return the version of the API
*/
int
-dlz_version(unsigned int *flags)
-{
+dlz_version(unsigned int *flags) {
*flags |= (DNS_SDLZFLAG_RELATIVEOWNER | DNS_SDLZFLAG_RELATIVERDATA |
DNS_SDLZFLAG_THREADSAFE);
return (DLZ_DLOPEN_VERSION);
* Register a helper function from the bind9 dlz_dlopen driver
*/
static void
-b9_add_helper(mysql_instance_t *db, const char *helper_name, void *ptr)
-{
+b9_add_helper(mysql_instance_t *db, const char *helper_name, void *ptr) {
if (strcmp(helper_name, "log") == 0) {
db->log = (log_t *)ptr;
}
* Local functions
*/
static bool
-db_connect(mysql_data_t *state, mysql_instance_t *dbi)
-{
+db_connect(mysql_data_t *state, mysql_instance_t *dbi) {
MYSQL *conn;
/*
* Make sure this thread has been through 'init'
}
static mysql_instance_t *
-get_dbi(mysql_data_t *state)
-{
+get_dbi(mysql_data_t *state) {
int i;
/*
* of string 'original'
*/
static char *
-sanitize(mysql_instance_t *dbi, const char *original)
-{
+sanitize(mysql_instance_t *dbi, const char *original) {
char *s;
if (original == NULL) {
* and add the string length to the running total pointed to by 'len'.
*/
static isc_result_t
-additem(mysql_arglist_t *arglist, char **s, size_t *len)
-{
+additem(mysql_arglist_t *arglist, char **s, size_t *len) {
mysql_arg_t *item;
item = malloc(sizeof(*item));
*/
static char *
build_query(mysql_data_t *state, mysql_instance_t *dbi, const char *command,
- ...)
-{
+ ...) {
isc_result_t result;
bool localdbi = false;
mysql_arglist_t arglist;
/* Does this name end in a dot? */
static bool
-isrelative(const char *s)
-{
+isrelative(const char *s) {
if (s == NULL || s[strlen(s) - 1] == '.') {
return (false);
}
/* Return a dot if 's' doesn't already end with one */
static inline const char *
-dot(const char *s)
-{
+dot(const char *s) {
return (isrelative(s) ? "." : "");
}
* enough space).
*/
static void
-fqhn(const char *name, const char *zone, char *dest)
-{
+fqhn(const char *name, const char *zone, char *dest) {
if (dest == NULL) {
return;
}
* removes labels matching 'zone' from the end of 'name'.
*/
static char *
-relname(const char *name, const char *zone)
-{
+relname(const char *name, const char *zone) {
size_t nlen, zlen;
const char *p;
char *new;
}
static isc_result_t
-validate_txn(mysql_data_t *state, mysql_transaction_t *txn)
-{
+validate_txn(mysql_data_t *state, mysql_transaction_t *txn) {
isc_result_t result = ISC_R_FAILURE;
mysql_transaction_t *txp;
}
static isc_result_t
-db_execute(mysql_data_t *state, mysql_instance_t *dbi, const char *query)
-{
+db_execute(mysql_data_t *state, mysql_instance_t *dbi, const char *query) {
int ret;
/* Make sure this instance is connected. */
}
static MYSQL_RES *
-db_query(mysql_data_t *state, mysql_instance_t *dbi, const char *query)
-{
+db_query(mysql_data_t *state, mysql_instance_t *dbi, const char *query) {
isc_result_t result;
bool localdbi = false;
MYSQL_RES *res = NULL;
* values to the 'on the wire' packet values.
*/
static unsigned char *
-make_notify(const char *zone, int *packetlen)
-{
+make_notify(const char *zone, int *packetlen) {
int i, j;
unsigned char *packet = (unsigned char *)malloc(strlen(zone) + 18);
}
static void
-send_notify(struct sockaddr_in *addr, const unsigned char *p, const int plen)
-{
+send_notify(struct sockaddr_in *addr, const unsigned char *p, const int plen) {
int s;
addr->sin_family = AF_INET;
* Generate and send a DNS NOTIFY packet
*/
static void
-notify(mysql_data_t *state, const char *zone, int sn)
-{
+notify(mysql_data_t *state, const char *zone, int sn) {
MYSQL_RES *res;
MYSQL_ROW row;
char *query;
* used in the dlz_{add,sub,del}rdataset functions below.
*/
static mysql_record_t *
-makerecord(mysql_data_t *state, const char *name, const char *rdatastr)
-{
+makerecord(mysql_data_t *state, const char *name, const char *rdatastr) {
mysql_record_t *new_record;
char *real_name, *dclass, *type, *data, *ttlstr, *buf;
dns_ttl_t ttlvalue;
* Remember a helper function from the bind9 dlz_dlopen driver
*/
static void
-b9_add_helper(mysql_data_t *state, const char *helper_name, void *ptr)
-{
+b9_add_helper(mysql_data_t *state, const char *helper_name, void *ptr) {
if (strcmp(helper_name, "log") == 0) {
state->log = (log_t *)ptr;
}
* Return the version of the API
*/
int
-dlz_version(unsigned int *flags)
-{
+dlz_version(unsigned int *flags) {
UNUSED(flags);
*flags |= DNS_SDLZFLAG_THREADSAFE;
return (DLZ_DLOPEN_VERSION);
*/
isc_result_t
dlz_create(const char *dlzname, unsigned int argc, char *argv[], void **dbdata,
- ...)
-{
+ ...) {
mysql_data_t *state;
const char *helper_name;
va_list ap;
* Shut down the backend
*/
void
-dlz_destroy(void *dbdata)
-{
+dlz_destroy(void *dbdata) {
mysql_data_t *state = (mysql_data_t *)dbdata;
int i;
*/
isc_result_t
dlz_findzonedb(void *dbdata, const char *name, dns_clientinfomethods_t *methods,
- dns_clientinfo_t *clientinfo)
-{
+ dns_clientinfo_t *clientinfo) {
isc_result_t result = ISC_R_SUCCESS;
mysql_data_t *state = (mysql_data_t *)dbdata;
MYSQL_RES *res;
isc_result_t
dlz_lookup(const char *zone, const char *name, void *dbdata,
dns_sdlzlookup_t *lookup, dns_clientinfomethods_t *methods,
- dns_clientinfo_t *clientinfo)
-{
+ dns_clientinfo_t *clientinfo) {
isc_result_t result;
mysql_data_t *state = (mysql_data_t *)dbdata;
bool found = false;
* See if a zone transfer is allowed
*/
isc_result_t
-dlz_allowzonexfr(void *dbdata, const char *name, const char *client)
-{
+dlz_allowzonexfr(void *dbdata, const char *name, const char *client) {
mysql_data_t *state = (mysql_data_t *)dbdata;
if (state->debug && state->log != NULL) {
* Perform a zone transfer
*/
isc_result_t
-dlz_allnodes(const char *zone, void *dbdata, dns_sdlzallnodes_t *allnodes)
-{
+dlz_allnodes(const char *zone, void *dbdata, dns_sdlzallnodes_t *allnodes) {
isc_result_t result = ISC_R_SUCCESS;
mysql_data_t *state = (mysql_data_t *)dbdata;
MYSQL_RES *res;
* Start a transaction
*/
isc_result_t
-dlz_newversion(const char *zone, void *dbdata, void **versionp)
-{
+dlz_newversion(const char *zone, void *dbdata, void **versionp) {
isc_result_t result = ISC_R_FAILURE;
mysql_data_t *state = (mysql_data_t *)dbdata;
MYSQL_RES *res;
* End a transaction
*/
void
-dlz_closeversion(const char *zone, bool commit, void *dbdata, void **versionp)
-{
+dlz_closeversion(const char *zone, bool commit, void *dbdata, void **versionp) {
isc_result_t result;
mysql_data_t *state = (mysql_data_t *)dbdata;
mysql_transaction_t *txn = (mysql_transaction_t *)*versionp;
bool
dlz_ssumatch(const char *signer, const char *name, const char *tcpaddr,
const char *type, const char *key, uint32_t keydatalen,
- unsigned char *keydata, void *dbdata)
-{
+ unsigned char *keydata, void *dbdata) {
mysql_data_t *state = (mysql_data_t *)dbdata;
UNUSED(tcpaddr);
isc_result_t
dlz_addrdataset(const char *name, const char *rdatastr, void *dbdata,
- void *version)
-{
+ void *version) {
mysql_data_t *state = (mysql_data_t *)dbdata;
mysql_transaction_t *txn = (mysql_transaction_t *)version;
char *new_name, *query;
isc_result_t
dlz_subrdataset(const char *name, const char *rdatastr, void *dbdata,
- void *version)
-{
+ void *version) {
mysql_data_t *state = (mysql_data_t *)dbdata;
mysql_transaction_t *txn = (mysql_transaction_t *)version;
char *new_name, *query;
}
isc_result_t
-dlz_delrdataset(const char *name, const char *type, void *dbdata, void *version)
-{
+dlz_delrdataset(const char *name, const char *type, void *dbdata,
+ void *version) {
mysql_data_t *state = (mysql_data_t *)dbdata;
mysql_transaction_t *txn = (mysql_transaction_t *)version;
char *new_name, *query;
* the warnings.
*/
EXTERN_C void xs_init(pTHX);
-EXTERN_C void boot_DynaLoader(pTHX_ CV *cv);
-EXTERN_C void boot_DLZ_Perl__clientinfo(pTHX_ CV *cv);
-EXTERN_C void boot_DLZ_Perl(pTHX_ CV *cv);
-EXTERN_C void xs_init(pTHX)
-{
+EXTERN_C void
+boot_DynaLoader(pTHX_ CV *cv);
+EXTERN_C void
+boot_DLZ_Perl__clientinfo(pTHX_ CV *cv);
+EXTERN_C void
+boot_DLZ_Perl(pTHX_ CV *cv);
+EXTERN_C void
+xs_init(pTHX) {
char *file = __FILE__;
dXSUB_SYS;
* remember a helper function, from the bind9 dlz_dlopen driver
*/
static void
-b9_add_helper(config_data_t *state, const char *helper_name, void *ptr)
-{
+b9_add_helper(config_data_t *state, const char *helper_name, void *ptr) {
if (strcmp(helper_name, "log") == 0) {
state->log = ptr;
}
}
int
-dlz_version(unsigned int *flags)
-{
+dlz_version(unsigned int *flags) {
return (DLZ_DLOPEN_VERSION);
}
isc_result_t
-dlz_allnodes(const char *zone, void *dbdata, dns_sdlzallnodes_t *allnodes)
-{
+dlz_allnodes(const char *zone, void *dbdata, dns_sdlzallnodes_t *allnodes) {
config_data_t *cd = (config_data_t *)dbdata;
isc_result_t retval;
int rrcount, r;
}
isc_result_t
-dlz_allowzonexfr(void *dbdata, const char *name, const char *client)
-{
+dlz_allowzonexfr(void *dbdata, const char *name, const char *client) {
config_data_t *cd = (config_data_t *)dbdata;
int r;
isc_result_t retval;
isc_result_t
dlz_create(const char *dlzname, unsigned int argc, char *argv[], void **dbdata,
- ...)
-{
+ ...) {
config_data_t *cd;
char *init_args[] = { NULL, NULL };
char *perlrun[] = { "", NULL, "dlz perl", NULL };
}
void
-dlz_destroy(void *dbdata)
-{
+dlz_destroy(void *dbdata) {
config_data_t *cd = (config_data_t *)dbdata;
#ifdef MULTIPLICITY
PerlInterpreter *my_perl = cd->perl;
/* This is the only part that differs from dlz_minimal.h. */
typedef struct dlz_perl_clientinfo_opaque {
dns_clientinfomethods_t *methods;
- dns_clientinfo_t * clientinfo;
+ dns_clientinfo_t *clientinfo;
} dlz_perl_clientinfo_opaque;
} sqlite3_res_t;
/* forward references */
-isc_result_t dlz_findzonedb(void *dbdata, const char *name,
- dns_clientinfomethods_t *methods,
- dns_clientinfo_t *clientinfo);
+isc_result_t
+dlz_findzonedb(void *dbdata, const char *name, dns_clientinfomethods_t *methods,
+ dns_clientinfo_t *clientinfo);
-void dlz_destroy(void *dbdata);
+void
+dlz_destroy(void *dbdata);
-static void b9_add_helper(sqlite3_instance_t *db, const char *helper_name,
- void *ptr);
+static void
+b9_add_helper(sqlite3_instance_t *db, const char *helper_name, void *ptr);
/*
* Private methods
*/
void
-sqlite3_destroy(dbinstance_t *db)
-{
+sqlite3_destroy(dbinstance_t *db) {
/* release DB connection */
if (db->dbconn != NULL) {
sqlite3_close((sqlite3 *)db->dbconn);
* multithreaded operation.
*/
static void
-sqlite3_destroy_dblist(db_list_t *dblist)
-{
+sqlite3_destroy_dblist(db_list_t *dblist) {
dbinstance_t *ndbi = NULL;
dbinstance_t *dbi = NULL;
* multithreaded operation.
*/
static dbinstance_t *
-sqlite3_find_avail(sqlite3_instance_t *sqlite3)
-{
+sqlite3_find_avail(sqlite3_instance_t *sqlite3) {
dbinstance_t *dbi = NULL, *head;
int count = 0;
* want special characters in the string causing problems.
*/
static char *
-escape_string(const char *instr)
-{
+escape_string(const char *instr) {
char *outstr;
char *ptr;
unsigned int len;
*/
static isc_result_t
sqlite3_get_resultset(const char *zone, const char *record, const char *client,
- unsigned int query, void *dbdata, sqlite3_res_t **rsp)
-{
+ unsigned int query, void *dbdata, sqlite3_res_t **rsp) {
isc_result_t result;
dbinstance_t *dbi = NULL;
sqlite3_instance_t *db = (sqlite3_instance_t *)dbdata;
*/
char **
-sqlite3_fetch_row(sqlite3_res_t *rs)
-{
+sqlite3_fetch_row(sqlite3_res_t *rs) {
char **retval = NULL;
if (rs != NULL) {
if (rs->pnRow > 0U && rs->curRow < rs->pnRow) {
}
unsigned int
-sqlite3_num_fields(sqlite3_res_t *rs)
-{
+sqlite3_num_fields(sqlite3_res_t *rs) {
unsigned int retval = 0;
if (rs != NULL) {
retval = rs->pnColumn;
}
unsigned int
-sqlite3_num_rows(sqlite3_res_t *rs)
-{
+sqlite3_num_rows(sqlite3_res_t *rs) {
unsigned int retval = 0;
if (rs != NULL) {
retval = rs->pnRow;
}
void
-sqlite3_free_result(sqlite3_res_t *rs)
-{
+sqlite3_free_result(sqlite3_res_t *rs) {
if (rs != NULL) {
sqlite3_free_table(rs->pazResult);
free(rs);
static isc_result_t
sqlite3_process_rs(sqlite3_instance_t *db, dns_sdlzlookup_t *lookup,
- sqlite3_res_t *rs)
-{
+ sqlite3_res_t *rs) {
isc_result_t result = ISC_R_NOTFOUND;
char **row;
unsigned int fields;
/*% determine if the zone is supported by (in) the database */
isc_result_t
dlz_findzonedb(void *dbdata, const char *name, dns_clientinfomethods_t *methods,
- dns_clientinfo_t *clientinfo)
-{
+ dns_clientinfo_t *clientinfo) {
isc_result_t result;
sqlite3_res_t *rs = NULL;
sqlite3_uint64 rows;
/*% Determine if the client is allowed to perform a zone transfer */
isc_result_t
-dlz_allowzonexfr(void *dbdata, const char *name, const char *client)
-{
+dlz_allowzonexfr(void *dbdata, const char *name, const char *client) {
isc_result_t result;
sqlite3_instance_t *db = (sqlite3_instance_t *)dbdata;
sqlite3_res_t *rs = NULL;
* query.
*/
isc_result_t
-dlz_allnodes(const char *zone, void *dbdata, dns_sdlzallnodes_t *allnodes)
-{
+dlz_allnodes(const char *zone, void *dbdata, dns_sdlzallnodes_t *allnodes) {
isc_result_t result;
sqlite3_instance_t *db = (sqlite3_instance_t *)dbdata;
sqlite3_res_t *rs = NULL;
* use this function to get that information for named.
*/
isc_result_t
-dlz_authority(const char *zone, void *dbdata, dns_sdlzlookup_t *lookup)
-{
+dlz_authority(const char *zone, void *dbdata, dns_sdlzlookup_t *lookup) {
isc_result_t result;
sqlite3_res_t *rs = NULL;
sqlite3_instance_t *db = (sqlite3_instance_t *)dbdata;
isc_result_t
dlz_lookup(const char *zone, const char *name, void *dbdata,
dns_sdlzlookup_t *lookup, dns_clientinfomethods_t *methods,
- dns_clientinfo_t *clientinfo)
-{
+ dns_clientinfo_t *clientinfo) {
isc_result_t result;
sqlite3_res_t *rs = NULL;
sqlite3_instance_t *db = (sqlite3_instance_t *)dbdata;
*/
isc_result_t
dlz_create(const char *dlzname, unsigned int argc, char *argv[], void **dbdata,
- ...)
-{
+ ...) {
isc_result_t result = ISC_R_FAILURE;
sqlite3_instance_t *s3 = NULL;
dbinstance_t *dbi = NULL;
* Destroy the module.
*/
void
-dlz_destroy(void *dbdata)
-{
+dlz_destroy(void *dbdata) {
sqlite3_instance_t *db = (sqlite3_instance_t *)dbdata;
#if PTHREADS
/* cleanup the list of DBI's */
* Return the version of the API
*/
int
-dlz_version(unsigned int *flags)
-{
+dlz_version(unsigned int *flags) {
*flags |= (DNS_SDLZFLAG_RELATIVEOWNER | DNS_SDLZFLAG_RELATIVERDATA |
DNS_SDLZFLAG_THREADSAFE);
return (DLZ_DLOPEN_VERSION);
* Register a helper function from the bind9 dlz_dlopen driver
*/
static void
-b9_add_helper(sqlite3_instance_t *db, const char *helper_name, void *ptr)
-{
+b9_add_helper(sqlite3_instance_t *db, const char *helper_name, void *ptr) {
if (strcmp(helper_name, "log") == 0) {
db->log = (log_t *)ptr;
}
/*
* Forward references
*/
-static int rangematch(const char *, char, int, char **);
+static int
+rangematch(const char *, char, int, char **);
-static int fnmatch(const char *pattern, const char *string, int flags);
+static int
+fnmatch(const char *pattern, const char *string, int flags);
-static void b9_add_helper(struct config_data *cd, const char *helper_name,
- void *ptr);
+static void
+b9_add_helper(struct config_data *cd, const char *helper_name, void *ptr);
-static const char *shortest_match(const char *pattern, const char *string);
+static const char *
+shortest_match(const char *pattern, const char *string);
isc_result_t
-dlz_allnodes(const char *zone, void *dbdata, dns_sdlzallnodes_t *allnodes)
-{
+dlz_allnodes(const char *zone, void *dbdata, dns_sdlzallnodes_t *allnodes) {
config_data_t *cd = (config_data_t *)dbdata;
isc_result_t result;
char *querystring = NULL;
}
isc_result_t
-dlz_allowzonexfr(void *dbdata, const char *name, const char *client)
-{
+dlz_allowzonexfr(void *dbdata, const char *name, const char *client) {
config_data_t *cd = (config_data_t *)dbdata;
UNUSED(name);
}
isc_result_t
-dlz_authority(const char *zone, void *dbdata, dns_sdlzlookup_t *lookup)
-{
+dlz_authority(const char *zone, void *dbdata, dns_sdlzlookup_t *lookup) {
isc_result_t result;
config_data_t *cd = (config_data_t *)dbdata;
char *querystring = NULL;
}
static void
-destroy_rrlist(config_data_t *cd)
-{
+destroy_rrlist(config_data_t *cd) {
nrr_t *trec, *nrec;
nrec = DLZ_LIST_HEAD(cd->rrs_list);
isc_result_t
dlz_create(const char *dlzname, unsigned int argc, char *argv[], void **dbdata,
- ...)
-{
+ ...) {
config_data_t *cd;
char *endp;
int i, def_ttl;
}
void
-dlz_destroy(void *dbdata)
-{
+dlz_destroy(void *dbdata) {
config_data_t *cd = (config_data_t *)dbdata;
/*
* Return the version of the API
*/
int
-dlz_version(unsigned int *flags)
-{
+dlz_version(unsigned int *flags) {
UNUSED(flags);
/* XXX: ok to set DNS_SDLZFLAG_THREADSAFE here? */
return (DLZ_DLOPEN_VERSION);
* Register a helper function from the bind9 dlz_dlopen driver
*/
static void
-b9_add_helper(struct config_data *cd, const char *helper_name, void *ptr)
-{
+b9_add_helper(struct config_data *cd, const char *helper_name, void *ptr) {
if (strcmp(helper_name, "log") == 0) {
cd->log = (log_t *)ptr;
}
}
static const char *
-shortest_match(const char *pattern, const char *string)
-{
+shortest_match(const char *pattern, const char *string) {
const char *p = string;
if (pattern == NULL || p == NULL || *p == '\0') {
return (NULL);
#define RANGE_ERROR (-1)
static int
-fnmatch(const char *pattern, const char *string, int flags)
-{
+fnmatch(const char *pattern, const char *string, int flags) {
const char *stringstart;
char *newp;
char c, test;
}
static int
-rangematch(const char *pattern, char test, int flags, char **newp)
-{
+rangematch(const char *pattern, char test, int flags, char **newp) {
int negate, ok;
char c, c2;
LLVMFuzzerTestOneInput(const uint8_t *data, size_t size);
int
-LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
-{
- isc_buffer_t buf;
- isc_result_t result;
+LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+ isc_buffer_t buf;
+ isc_result_t result;
dns_fixedname_t origin;
- char * de_const;
+ char *de_const;
if (size < 5) {
return (0);
LLVMFuzzerTestOneInput(const uint8_t *data, size_t size);
static void
-nullmsg(dns_rdatacallbacks_t *cb, const char *fmt, ...)
-{
+nullmsg(dns_rdatacallbacks_t *cb, const char *fmt, ...) {
UNUSED(cb);
UNUSED(fmt);
}
int
-LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
-{
- char totext[1024];
- dns_compress_t cctx;
+LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+ char totext[1024];
+ dns_compress_t cctx;
dns_decompress_t dctx;
- dns_rdatatype_t rdtype;
+ dns_rdatatype_t rdtype;
dns_rdataclass_t rdclass;
- dns_rdatatype_t typelist[256] = { 1000 }; /* unknown */
+ dns_rdatatype_t typelist[256] = { 1000 }; /* unknown */
dns_rdataclass_t classlist[] = { dns_rdataclass_in, dns_rdataclass_hs,
dns_rdataclass_ch, dns_rdataclass_any,
60 };
- dns_rdata_t rdata1 = DNS_RDATA_INIT, rdata2 = DNS_RDATA_INIT,
+ dns_rdata_t rdata1 = DNS_RDATA_INIT, rdata2 = DNS_RDATA_INIT,
rdata3 = DNS_RDATA_INIT;
dns_rdatacallbacks_t callbacks;
- isc_buffer_t source, target;
- isc_lex_t * lex = NULL;
- isc_lexspecials_t specials;
- isc_mem_t * mctx = NULL;
- isc_result_t result;
- unsigned char fromtext[1024];
- unsigned char fromwire[1024];
- unsigned char towire[1024];
+ isc_buffer_t source, target;
+ isc_lex_t *lex = NULL;
+ isc_lexspecials_t specials;
+ isc_mem_t *mctx = NULL;
+ isc_result_t result;
+ unsigned char fromtext[1024];
+ unsigned char fromwire[1024];
+ unsigned char towire[1024];
unsigned int classes = (sizeof(classlist) / sizeof(classlist[0]));
unsigned int types = 1, flags, t;
static isc_mem_t *mctx = NULL;
-static void __attribute__((constructor)) init(void)
-{
+static void __attribute__((constructor)) init(void) {
isc_mem_create(&mctx);
RUNTIME_CHECK(dst_lib_init(mctx, NULL) == ISC_R_SUCCESS);
}
-static void __attribute__((destructor)) deinit(void)
-{
+static void __attribute__((destructor)) deinit(void) {
dst_lib_destroy();
isc_mem_destroy(&mctx);
}
#include <dirent.h>
static void
-test_all_from(const char *dirname)
-{
- DIR * dirp;
+test_all_from(const char *dirname) {
+ DIR *dirp;
struct dirent *dp;
dirp = opendir(dirname);
}
while ((dp = readdir(dirp)) != NULL) {
- char filename[strlen(dirname) + strlen(dp->d_name) + 2];
- int fd;
+ char filename[strlen(dirname) + strlen(dp->d_name) + 2];
+ int fd;
struct stat st;
- char * data;
- ssize_t n;
+ char *data;
+ ssize_t n;
if (dp->d_name[0] == '.') {
continue;
}
int
-main(int argc, char **argv)
-{
- char corpusdir[PATH_MAX];
+main(int argc, char **argv) {
+ char corpusdir[PATH_MAX];
const char *target = strrchr(argv[0], '/');
UNUSED(argc);
#elif __AFL_COMPILER
int
-main(int argc, char **argv)
-{
- int ret;
+main(int argc, char **argv) {
+ int ret;
unsigned char buf[64 * 1024];
UNUSED(argc);
#include <dst/result.h>
#include <pk11/site.h>
-static isc_result_t fileexist(const cfg_obj_t *obj, isc_symtab_t *symtab,
- bool writeable, isc_log_t *logctxlogc);
+static isc_result_t
+fileexist(const cfg_obj_t *obj, isc_symtab_t *symtab, bool writeable,
+ isc_log_t *logctxlogc);
static void
freekey(char *key, unsigned int type, isc_symvalue_t value, void *userarg) {
/*
* Internal functions (and prototypes).
*/
-static inline dns_adbname_t *new_adbname(dns_adb_t *, const dns_name_t *);
-static inline void free_adbname(dns_adb_t *, dns_adbname_t **);
-static inline dns_adbnamehook_t *new_adbnamehook(dns_adb_t *, dns_adbentry_t *);
-static inline void free_adbnamehook(dns_adb_t *, dns_adbnamehook_t **);
+static inline dns_adbname_t *
+new_adbname(dns_adb_t *, const dns_name_t *);
+static inline void
+free_adbname(dns_adb_t *, dns_adbname_t **);
+static inline dns_adbnamehook_t *
+new_adbnamehook(dns_adb_t *, dns_adbentry_t *);
+static inline void
+free_adbnamehook(dns_adb_t *, dns_adbnamehook_t **);
static inline dns_adblameinfo_t *
new_adblameinfo(dns_adb_t *, const dns_name_t *, dns_rdatatype_t);
-static inline void free_adblameinfo(dns_adb_t *, dns_adblameinfo_t **);
-static inline dns_adbentry_t *new_adbentry(dns_adb_t *);
-static inline void free_adbentry(dns_adb_t *, dns_adbentry_t **);
-static inline dns_adbfind_t *new_adbfind(dns_adb_t *);
-static inline bool free_adbfind(dns_adb_t *, dns_adbfind_t **);
-static inline dns_adbaddrinfo_t *new_adbaddrinfo(dns_adb_t *, dns_adbentry_t *,
- in_port_t);
-static inline dns_adbfetch_t *new_adbfetch(dns_adb_t *);
-static inline void free_adbfetch(dns_adb_t *, dns_adbfetch_t **);
-static inline dns_adbname_t *find_name_and_lock(dns_adb_t *, const dns_name_t *,
- unsigned int, int *);
+static inline void
+free_adblameinfo(dns_adb_t *, dns_adblameinfo_t **);
+static inline dns_adbentry_t *
+new_adbentry(dns_adb_t *);
+static inline void
+free_adbentry(dns_adb_t *, dns_adbentry_t **);
+static inline dns_adbfind_t *
+new_adbfind(dns_adb_t *);
+static inline bool
+free_adbfind(dns_adb_t *, dns_adbfind_t **);
+static inline dns_adbaddrinfo_t *
+new_adbaddrinfo(dns_adb_t *, dns_adbentry_t *, in_port_t);
+static inline dns_adbfetch_t *
+new_adbfetch(dns_adb_t *);
+static inline void
+free_adbfetch(dns_adb_t *, dns_adbfetch_t **);
+static inline dns_adbname_t *
+find_name_and_lock(dns_adb_t *, const dns_name_t *, unsigned int, int *);
static inline dns_adbentry_t *
find_entry_and_lock(dns_adb_t *, const isc_sockaddr_t *, int *, isc_stdtime_t);
-static void dump_adb(dns_adb_t *, FILE *, bool debug, isc_stdtime_t);
-static void print_dns_name(FILE *, const dns_name_t *);
-static void print_namehook_list(FILE *, const char *legend, dns_adb_t *adb,
- dns_adbnamehooklist_t *list, bool debug,
- isc_stdtime_t now);
-static void print_find_list(FILE *, dns_adbname_t *);
-static void print_fetch_list(FILE *, dns_adbname_t *);
-static inline bool dec_adb_irefcnt(dns_adb_t *);
-static inline void inc_adb_irefcnt(dns_adb_t *);
-static inline void inc_adb_erefcnt(dns_adb_t *);
-static inline void inc_entry_refcnt(dns_adb_t *, dns_adbentry_t *, bool);
-static inline bool dec_entry_refcnt(dns_adb_t *, bool, dns_adbentry_t *, bool);
-static inline void violate_locking_hierarchy(isc_mutex_t *, isc_mutex_t *);
-static bool clean_namehooks(dns_adb_t *, dns_adbnamehooklist_t *);
-static void clean_target(dns_adb_t *, dns_name_t *);
-static void clean_finds_at_name(dns_adbname_t *, isc_eventtype_t, unsigned int);
-static bool check_expire_namehooks(dns_adbname_t *, isc_stdtime_t);
-static bool check_expire_entry(dns_adb_t *, dns_adbentry_t **, isc_stdtime_t);
-static void cancel_fetches_at_name(dns_adbname_t *);
-static isc_result_t dbfind_name(dns_adbname_t *, isc_stdtime_t,
- dns_rdatatype_t);
-static isc_result_t fetch_name(dns_adbname_t *, bool, unsigned int,
- isc_counter_t *qc, dns_rdatatype_t);
-static inline void check_exit(dns_adb_t *);
-static void destroy(dns_adb_t *);
-static bool shutdown_names(dns_adb_t *);
-static bool shutdown_entries(dns_adb_t *);
-static inline void link_name(dns_adb_t *, int, dns_adbname_t *);
-static inline bool unlink_name(dns_adb_t *, dns_adbname_t *);
-static inline void link_entry(dns_adb_t *, int, dns_adbentry_t *);
-static inline bool unlink_entry(dns_adb_t *, dns_adbentry_t *);
-static bool kill_name(dns_adbname_t **, isc_eventtype_t);
-static void water(void *, int);
-static void dump_entry(FILE *, dns_adb_t *, dns_adbentry_t *, bool,
- isc_stdtime_t);
-static void adjustsrtt(dns_adbaddrinfo_t *addr, unsigned int rtt,
- unsigned int factor, isc_stdtime_t now);
-static void shutdown_task(isc_task_t *task, isc_event_t *ev);
-static void log_quota(dns_adbentry_t *entry, const char *fmt, ...)
- ISC_FORMAT_PRINTF(2, 3);
+static void
+dump_adb(dns_adb_t *, FILE *, bool debug, isc_stdtime_t);
+static void
+print_dns_name(FILE *, const dns_name_t *);
+static void
+print_namehook_list(FILE *, const char *legend, dns_adb_t *adb,
+ dns_adbnamehooklist_t *list, bool debug, isc_stdtime_t now);
+static void
+print_find_list(FILE *, dns_adbname_t *);
+static void
+print_fetch_list(FILE *, dns_adbname_t *);
+static inline bool
+dec_adb_irefcnt(dns_adb_t *);
+static inline void
+inc_adb_irefcnt(dns_adb_t *);
+static inline void
+inc_adb_erefcnt(dns_adb_t *);
+static inline void
+inc_entry_refcnt(dns_adb_t *, dns_adbentry_t *, bool);
+static inline bool
+dec_entry_refcnt(dns_adb_t *, bool, dns_adbentry_t *, bool);
+static inline void
+violate_locking_hierarchy(isc_mutex_t *, isc_mutex_t *);
+static bool
+clean_namehooks(dns_adb_t *, dns_adbnamehooklist_t *);
+static void
+clean_target(dns_adb_t *, dns_name_t *);
+static void
+clean_finds_at_name(dns_adbname_t *, isc_eventtype_t, unsigned int);
+static bool
+check_expire_namehooks(dns_adbname_t *, isc_stdtime_t);
+static bool
+check_expire_entry(dns_adb_t *, dns_adbentry_t **, isc_stdtime_t);
+static void
+cancel_fetches_at_name(dns_adbname_t *);
+static isc_result_t
+dbfind_name(dns_adbname_t *, isc_stdtime_t, dns_rdatatype_t);
+static isc_result_t
+fetch_name(dns_adbname_t *, bool, unsigned int, isc_counter_t *qc,
+ dns_rdatatype_t);
+static inline void
+check_exit(dns_adb_t *);
+static void
+destroy(dns_adb_t *);
+static bool
+shutdown_names(dns_adb_t *);
+static bool
+shutdown_entries(dns_adb_t *);
+static inline void
+link_name(dns_adb_t *, int, dns_adbname_t *);
+static inline bool
+unlink_name(dns_adb_t *, dns_adbname_t *);
+static inline void
+link_entry(dns_adb_t *, int, dns_adbentry_t *);
+static inline bool
+unlink_entry(dns_adb_t *, dns_adbentry_t *);
+static bool
+kill_name(dns_adbname_t **, isc_eventtype_t);
+static void
+water(void *, int);
+static void
+dump_entry(FILE *, dns_adb_t *, dns_adbentry_t *, bool, isc_stdtime_t);
+static void
+adjustsrtt(dns_adbaddrinfo_t *addr, unsigned int rtt, unsigned int factor,
+ isc_stdtime_t now);
+static void
+shutdown_task(isc_task_t *task, isc_event_t *ev);
+static void
+log_quota(dns_adbentry_t *entry, const char *fmt, ...) ISC_FORMAT_PRINTF(2, 3);
/*
* MUST NOT overlap DNS_ADBFIND_* flags!
DNS_R_NXRRSET, ISC_R_UNEXPECTED, ISC_R_NOTFOUND /* not YET found */
};
-static void DP(int level, const char *format, ...) ISC_FORMAT_PRINTF(2, 3);
+static void
+DP(int level, const char *format, ...) ISC_FORMAT_PRINTF(2, 3);
static void
DP(int level, const char *format, ...) {
dns_name_t name;
};
-static isc_result_t badcache_resize(dns_badcache_t *bc, isc_time_t *now,
- bool grow);
+static isc_result_t
+badcache_resize(dns_badcache_t *bc, isc_time_t *now, bool grow);
isc_result_t
dns_badcache_init(isc_mem_t *mctx, unsigned int size, dns_badcache_t **bcp) {
*** Functions
***/
-static isc_result_t cache_cleaner_init(dns_cache_t *cache,
- isc_taskmgr_t *taskmgr,
- isc_timermgr_t *timermgr,
- cache_cleaner_t *cleaner);
+static isc_result_t
+cache_cleaner_init(dns_cache_t *cache, isc_taskmgr_t *taskmgr,
+ isc_timermgr_t *timermgr, cache_cleaner_t *cleaner);
-static void incremental_cleaning_action(isc_task_t *task, isc_event_t *event);
+static void
+incremental_cleaning_action(isc_task_t *task, isc_event_t *event);
-static void cleaner_shutdown_action(isc_task_t *task, isc_event_t *event);
+static void
+cleaner_shutdown_action(isc_task_t *task, isc_event_t *event);
-static void overmem_cleaning_action(isc_task_t *task, isc_event_t *event);
+static void
+overmem_cleaning_action(isc_task_t *task, isc_event_t *event);
static inline isc_result_t
cache_create_db(dns_cache_t *cache, dns_db_t **db) {
#include <dns/callbacks.h>
#include <dns/log.h>
-static void stdio_error_warn_callback(dns_rdatacallbacks_t *, const char *, ...)
+static void
+stdio_error_warn_callback(dns_rdatacallbacks_t *, const char *, ...)
ISC_FORMAT_PRINTF(2, 3);
-static void isclog_error_callback(dns_rdatacallbacks_t *callbacks,
- const char *fmt, ...) ISC_FORMAT_PRINTF(2, 3);
+static void
+isclog_error_callback(dns_rdatacallbacks_t *callbacks, const char *fmt, ...)
+ ISC_FORMAT_PRINTF(2, 3);
-static void isclog_warn_callback(dns_rdatacallbacks_t *callbacks,
- const char *fmt, ...) ISC_FORMAT_PRINTF(2, 3);
+static void
+isclog_warn_callback(dns_rdatacallbacks_t *callbacks, const char *fmt, ...)
+ ISC_FORMAT_PRINTF(2, 3);
/*
* Private
isc_refcount_t refs;
};
-static isc_result_t catz_process_zones_entry(dns_catz_zone_t *zone,
- dns_rdataset_t *value,
- dns_label_t *mhash);
-static isc_result_t catz_process_zones_suboption(dns_catz_zone_t *zone,
- dns_rdataset_t *value,
- dns_label_t *mhash,
- dns_name_t *name);
+static isc_result_t
+catz_process_zones_entry(dns_catz_zone_t *zone, dns_rdataset_t *value,
+ dns_label_t *mhash);
+static isc_result_t
+catz_process_zones_suboption(dns_catz_zone_t *zone, dns_rdataset_t *value,
+ dns_label_t *mhash, dns_name_t *name);
/*%
* Collection of catalog zones for a view
struct updatectx *bp6;
} updatectx_t;
-static isc_result_t request_soa(updatectx_t *uctx);
-static void client_resfind(resctx_t *rctx, dns_fetchevent_t *event);
-static isc_result_t send_update(updatectx_t *uctx);
+static isc_result_t
+request_soa(updatectx_t *uctx);
+static void
+client_resfind(resctx_t *rctx, dns_fetchevent_t *event);
+static isc_result_t
+send_update(updatectx_t *uctx);
/*
* Try honoring the operating system's preferred ephemeral port range.
/*
* Statics.
*/
-static dns_dispentry_t *entry_search(dns_qid_t *, const isc_sockaddr_t *,
- dns_messageid_t, in_port_t, unsigned int);
-static bool destroy_disp_ok(dns_dispatch_t *);
-static void destroy_disp(isc_task_t *task, isc_event_t *event);
-static void destroy_dispsocket(dns_dispatch_t *, dispsocket_t **);
-static void deactivate_dispsocket(dns_dispatch_t *, dispsocket_t *);
-static void udp_exrecv(isc_task_t *, isc_event_t *);
-static void udp_shrecv(isc_task_t *, isc_event_t *);
-static void udp_recv(isc_event_t *, dns_dispatch_t *, dispsocket_t *);
-static void tcp_recv(isc_task_t *, isc_event_t *);
-static isc_result_t startrecv(dns_dispatch_t *, dispsocket_t *);
-static uint32_t dns_hash(dns_qid_t *, const isc_sockaddr_t *, dns_messageid_t,
- in_port_t);
-static void free_buffer(dns_dispatch_t *disp, void *buf, unsigned int len);
-static void *allocate_udp_buffer(dns_dispatch_t *disp);
-static inline void free_devent(dns_dispatch_t *disp, dns_dispatchevent_t *ev);
-static inline dns_dispatchevent_t *allocate_devent(dns_dispatch_t *disp);
-static void do_cancel(dns_dispatch_t *disp);
-static dns_dispentry_t *linear_first(dns_qid_t *disp);
-static dns_dispentry_t *linear_next(dns_qid_t *disp, dns_dispentry_t *resp);
-static void dispatch_free(dns_dispatch_t **dispp);
-static isc_result_t get_udpsocket(dns_dispatchmgr_t *mgr, dns_dispatch_t *disp,
- isc_socketmgr_t *sockmgr,
- const isc_sockaddr_t *localaddr,
- isc_socket_t **sockp,
- isc_socket_t *dup_socket, bool duponly);
+static dns_dispentry_t *
+entry_search(dns_qid_t *, const isc_sockaddr_t *, dns_messageid_t, in_port_t,
+ unsigned int);
+static bool
+destroy_disp_ok(dns_dispatch_t *);
+static void
+destroy_disp(isc_task_t *task, isc_event_t *event);
+static void
+destroy_dispsocket(dns_dispatch_t *, dispsocket_t **);
+static void
+deactivate_dispsocket(dns_dispatch_t *, dispsocket_t *);
+static void
+udp_exrecv(isc_task_t *, isc_event_t *);
+static void
+udp_shrecv(isc_task_t *, isc_event_t *);
+static void
+udp_recv(isc_event_t *, dns_dispatch_t *, dispsocket_t *);
+static void
+tcp_recv(isc_task_t *, isc_event_t *);
+static isc_result_t
+startrecv(dns_dispatch_t *, dispsocket_t *);
+static uint32_t
+dns_hash(dns_qid_t *, const isc_sockaddr_t *, dns_messageid_t, in_port_t);
+static void
+free_buffer(dns_dispatch_t *disp, void *buf, unsigned int len);
+static void *
+allocate_udp_buffer(dns_dispatch_t *disp);
+static inline void
+free_devent(dns_dispatch_t *disp, dns_dispatchevent_t *ev);
+static inline dns_dispatchevent_t *
+allocate_devent(dns_dispatch_t *disp);
+static void
+do_cancel(dns_dispatch_t *disp);
+static dns_dispentry_t *
+linear_first(dns_qid_t *disp);
+static dns_dispentry_t *
+linear_next(dns_qid_t *disp, dns_dispentry_t *resp);
+static void
+dispatch_free(dns_dispatch_t **dispp);
+static isc_result_t
+get_udpsocket(dns_dispatchmgr_t *mgr, dns_dispatch_t *disp,
+ isc_socketmgr_t *sockmgr, const isc_sockaddr_t *localaddr,
+ isc_socket_t **sockp, isc_socket_t *dup_socket, bool duponly);
static isc_result_t
dispatch_createudp(dns_dispatchmgr_t *mgr, isc_socketmgr_t *sockmgr,
isc_taskmgr_t *taskmgr, const isc_sockaddr_t *localaddr,
unsigned int maxrequests, unsigned int attributes,
dns_dispatch_t **dispp, isc_socket_t *dup_socket);
-static bool destroy_mgr_ok(dns_dispatchmgr_t *mgr);
-static void destroy_mgr(dns_dispatchmgr_t **mgrp);
-static isc_result_t qid_allocate(dns_dispatchmgr_t *mgr, unsigned int buckets,
- unsigned int increment, dns_qid_t **qidp,
- bool needaddrtable);
-static void qid_destroy(isc_mem_t *mctx, dns_qid_t **qidp);
-static isc_result_t open_socket(isc_socketmgr_t *mgr,
- const isc_sockaddr_t *local,
- unsigned int options, isc_socket_t **sockp,
- isc_socket_t *dup_socket, bool duponly);
-static bool portavailable(dns_dispatchmgr_t *mgr, isc_socket_t *sock,
- isc_sockaddr_t *sockaddrp);
+static bool
+destroy_mgr_ok(dns_dispatchmgr_t *mgr);
+static void
+destroy_mgr(dns_dispatchmgr_t **mgrp);
+static isc_result_t
+qid_allocate(dns_dispatchmgr_t *mgr, unsigned int buckets,
+ unsigned int increment, dns_qid_t **qidp, bool needaddrtable);
+static void
+qid_destroy(isc_mem_t *mctx, dns_qid_t **qidp);
+static isc_result_t
+open_socket(isc_socketmgr_t *mgr, const isc_sockaddr_t *local,
+ unsigned int options, isc_socket_t **sockp,
+ isc_socket_t *dup_socket, bool duponly);
+static bool
+portavailable(dns_dispatchmgr_t *mgr, isc_socket_t *sock,
+ isc_sockaddr_t *sockaddrp);
#define LVL(x) ISC_LOG_DEBUG(x)
-static void mgr_log(dns_dispatchmgr_t *mgr, int level, const char *fmt, ...)
+static void
+mgr_log(dns_dispatchmgr_t *mgr, int level, const char *fmt, ...)
ISC_FORMAT_PRINTF(3, 4);
static void
}
}
-static void dispatch_log(dns_dispatch_t *disp, int level, const char *fmt, ...)
+static void
+dispatch_log(dns_dispatch_t *disp, int level, const char *fmt, ...)
ISC_FORMAT_PRINTF(3, 4);
static void
msgbuf);
}
-static void request_log(dns_dispatch_t *disp, dns_dispentry_t *resp, int level,
- const char *fmt, ...) ISC_FORMAT_PRINTF(4, 5);
+static void
+request_log(dns_dispatch_t *disp, dns_dispentry_t *resp, int level,
+ const char *fmt, ...) ISC_FORMAT_PRINTF(4, 5);
static void
request_log(dns_dispatch_t *disp, dns_dispentry_t *resp, int level,
#define TYPE_SIGN 0
#define TYPE_VERIFY 1
-static isc_result_t digest_callback(void *arg, isc_region_t *data);
+static isc_result_t
+digest_callback(void *arg, isc_region_t *data);
-static int rdata_compare_wrapper(const void *rdata1, const void *rdata2);
+static int
+rdata_compare_wrapper(const void *rdata1, const void *rdata2);
-static isc_result_t rdataset_to_sortedarray(dns_rdataset_t *set,
- isc_mem_t *mctx,
- dns_rdata_t **rdata, int *nrdata);
+static isc_result_t
+rdataset_to_sortedarray(dns_rdataset_t *set, isc_mem_t *mctx,
+ dns_rdata_t **rdata, int *nrdata);
static isc_result_t
digest_callback(void *arg, isc_region_t *data) {
static bool dst_initialized = false;
-void gss_log(int level, const char *fmt, ...) ISC_FORMAT_PRINTF(2, 3);
+void
+gss_log(int level, const char *fmt, ...) ISC_FORMAT_PRINTF(2, 3);
/*
* Static functions.
*/
-static dst_key_t *get_key_struct(const dns_name_t *name, unsigned int alg,
- unsigned int flags, unsigned int protocol,
- unsigned int bits, dns_rdataclass_t rdclass,
- dns_ttl_t ttl, isc_mem_t *mctx);
-static isc_result_t write_public_key(const dst_key_t *key, int type,
- const char *directory);
-static isc_result_t write_key_state(const dst_key_t *key, int type,
- const char *directory);
-static isc_result_t buildfilename(dns_name_t *name, dns_keytag_t id,
- unsigned int alg, unsigned int type,
- const char *directory, isc_buffer_t *out);
-static isc_result_t computeid(dst_key_t *key);
-static isc_result_t frombuffer(const dns_name_t *name, unsigned int alg,
- unsigned int flags, unsigned int protocol,
- dns_rdataclass_t rdclass, isc_buffer_t *source,
- isc_mem_t *mctx, dst_key_t **keyp);
-
-static isc_result_t algorithm_status(unsigned int alg);
-
-static isc_result_t addsuffix(char *filename, int len, const char *dirname,
- const char *ofilename, const char *suffix);
+static dst_key_t *
+get_key_struct(const dns_name_t *name, unsigned int alg, unsigned int flags,
+ unsigned int protocol, unsigned int bits,
+ dns_rdataclass_t rdclass, dns_ttl_t ttl, isc_mem_t *mctx);
+static isc_result_t
+write_public_key(const dst_key_t *key, int type, const char *directory);
+static isc_result_t
+write_key_state(const dst_key_t *key, int type, const char *directory);
+static isc_result_t
+buildfilename(dns_name_t *name, dns_keytag_t id, unsigned int alg,
+ unsigned int type, const char *directory, isc_buffer_t *out);
+static isc_result_t
+computeid(dst_key_t *key);
+static isc_result_t
+frombuffer(const dns_name_t *name, unsigned int alg, unsigned int flags,
+ unsigned int protocol, dns_rdataclass_t rdclass,
+ isc_buffer_t *source, isc_mem_t *mctx, dst_key_t **keyp);
+
+static isc_result_t
+algorithm_status(unsigned int alg);
+
+static isc_result_t
+addsuffix(char *filename, int len, const char *dirname, const char *ofilename,
+ const char *suffix);
#define RETERR(x) \
do { \
/*% DST Key Structure */
struct dst_key {
- unsigned int magic;
+ unsigned int magic;
isc_refcount_t refs;
- dns_name_t * key_name; /*%< name of the key */
- unsigned int key_size; /*%< size of the key in bits */
- unsigned int key_proto; /*%< protocols this key is used for
+ dns_name_t *key_name; /*%< name of the key */
+ unsigned int key_size; /*%< size of the key in bits */
+ unsigned int key_proto; /*%< protocols this key is used for
* */
unsigned int key_alg; /*%< algorithm of the key */
- uint32_t key_flags; /*%< flags of the public key */
- uint16_t key_id; /*%< identifier of the key */
- uint16_t key_rid; /*%< identifier of the key when
+ uint32_t key_flags; /*%< flags of the public key */
+ uint16_t key_id; /*%< identifier of the key */
+ uint16_t key_rid; /*%< identifier of the key when
* revoked */
- uint16_t key_bits; /*%< hmac digest bits */
+ uint16_t key_bits; /*%< hmac digest bits */
dns_rdataclass_t key_class; /*%< class of the key record */
- dns_ttl_t key_ttl; /*%< default/initial dnskey ttl */
- isc_mem_t * mctx; /*%< memory context */
- char * engine; /*%< engine name (HSM) */
- char * label; /*%< engine label (HSM) */
+ dns_ttl_t key_ttl; /*%< default/initial dnskey ttl */
+ isc_mem_t *mctx; /*%< memory context */
+ char *engine; /*%< engine name (HSM) */
+ char *label; /*%< engine label (HSM) */
union {
- void * generic;
+ void *generic;
gss_ctx_id_t gssctx;
- DH * dh;
+ DH *dh;
#if USE_OPENSSL
EVP_PKEY *pkey;
#endif /* if USE_OPENSSL */
dst_hmac_key_t *hmac_key;
} keydata; /*%< pointer to key in crypto pkg fmt */
- isc_stdtime_t times[DST_MAX_TIMES + 1]; /*%< timing metadata */
- bool timeset[DST_MAX_TIMES + 1]; /*%< data set? */
+ isc_stdtime_t times[DST_MAX_TIMES + 1]; /*%< timing metadata */
+ bool timeset[DST_MAX_TIMES + 1]; /*%< data set? */
uint32_t nums[DST_MAX_NUMERIC + 1]; /*%< numeric metadata
* */
int fmt_minor; /*%< private key format, minor version
* */
- dst_func_t * func; /*%< crypto package specific functions */
+ dst_func_t *func; /*%< crypto package specific functions */
isc_buffer_t *key_tkeytoken; /*%< TKEY token data */
};
struct dst_context {
- unsigned int magic;
- dst_use_t use;
- dst_key_t * key;
- isc_mem_t * mctx;
+ unsigned int magic;
+ dst_use_t use;
+ dst_key_t *key;
+ isc_mem_t *mctx;
isc_logcategory_t *category;
union {
- void * generic;
+ void *generic;
dst_gssapi_signverifyctx_t *gssctx;
- isc_hmac_t * hmac_ctx;
- EVP_MD_CTX * evp_md_ctx;
+ isc_hmac_t *hmac_ctx;
+ EVP_MD_CTX *evp_md_ctx;
#if USE_PKCS11
pk11_context_t *pk11_ctx;
#endif /* if USE_PKCS11 */
const isc_region_t *sig);
isc_result_t (*computesecret)(const dst_key_t *pub,
const dst_key_t *priv,
- isc_buffer_t * secret);
+ isc_buffer_t *secret);
bool (*compare)(const dst_key_t *key1, const dst_key_t *key2);
bool (*paramcompare)(const dst_key_t *key1, const dst_key_t *key2);
isc_result_t (*generate)(dst_key_t *key, int parms,
typedef struct dst_private_element dst_private_element_t;
struct dst_private {
- unsigned short nelements;
+ unsigned short nelements;
dst_private_element_t elements[MAXFIELDS];
};
#define NXDOMAIN(header) (((header)->attributes & RDATASET_ATTR_NXDOMAIN) != 0)
#define NEGATIVE(header) (((header)->attributes & RDATASET_ATTR_NEGATIVE) != 0)
-static isc_result_t dns_ecdb_create(isc_mem_t *mctx, const dns_name_t *origin,
- dns_dbtype_t type, dns_rdataclass_t rdclass,
- unsigned int argc, char *argv[],
- void *driverarg, dns_db_t **dbp);
-
-static void rdataset_disassociate(dns_rdataset_t *rdataset);
-static isc_result_t rdataset_first(dns_rdataset_t *rdataset);
-static isc_result_t rdataset_next(dns_rdataset_t *rdataset);
-static void rdataset_current(dns_rdataset_t *rdataset, dns_rdata_t *rdata);
-static void rdataset_clone(dns_rdataset_t *source, dns_rdataset_t *target);
-static unsigned int rdataset_count(dns_rdataset_t *rdataset);
-static void rdataset_settrust(dns_rdataset_t *rdataset, dns_trust_t trust);
+static isc_result_t
+dns_ecdb_create(isc_mem_t *mctx, const dns_name_t *origin, dns_dbtype_t type,
+ dns_rdataclass_t rdclass, unsigned int argc, char *argv[],
+ void *driverarg, dns_db_t **dbp);
+
+static void
+rdataset_disassociate(dns_rdataset_t *rdataset);
+static isc_result_t
+rdataset_first(dns_rdataset_t *rdataset);
+static isc_result_t
+rdataset_next(dns_rdataset_t *rdataset);
+static void
+rdataset_current(dns_rdataset_t *rdataset, dns_rdata_t *rdata);
+static void
+rdataset_clone(dns_rdataset_t *source, dns_rdataset_t *target);
+static unsigned int
+rdataset_count(dns_rdataset_t *rdataset);
+static void
+rdataset_settrust(dns_rdataset_t *rdataset, dns_trust_t trust);
static dns_rdatasetmethods_t rdataset_methods = {
rdataset_disassociate,
rdatasetheader_t *current;
} ecdb_rdatasetiter_t;
-static void rdatasetiter_destroy(dns_rdatasetiter_t **iteratorp);
-static isc_result_t rdatasetiter_first(dns_rdatasetiter_t *iterator);
-static isc_result_t rdatasetiter_next(dns_rdatasetiter_t *iterator);
-static void rdatasetiter_current(dns_rdatasetiter_t *iterator,
- dns_rdataset_t *rdataset);
+static void
+rdatasetiter_destroy(dns_rdatasetiter_t **iteratorp);
+static isc_result_t
+rdatasetiter_first(dns_rdatasetiter_t *iterator);
+static isc_result_t
+rdatasetiter_next(dns_rdatasetiter_t *iterator);
+static void
+rdatasetiter_current(dns_rdatasetiter_t *iterator, dns_rdataset_t *rdataset);
static dns_rdatasetitermethods_t rdatasetiter_methods = {
rdatasetiter_destroy, rdatasetiter_first, rdatasetiter_next,
#define FWDTABLEMAGIC ISC_MAGIC('F', 'w', 'd', 'T')
#define VALID_FWDTABLE(ft) ISC_MAGIC_VALID(ft, FWDTABLEMAGIC)
-static void auto_detach(void *, void *);
+static void
+auto_detach(void *, void *);
isc_result_t
dns_fwdtable_create(isc_mem_t *mctx, dns_fwdtable_t **fwdtablep) {
#define isc_commandline_argument optarg
typedef struct {
- DIR * handle;
+ DIR *handle;
char *filename;
} isc_dir_t;
int
isc_commandline_parse(int argc, char *const *argv, const char *options) {
static char *place = ENDOPT;
- char * option; /* Index into *options of option. */
+ char *option; /* Index into *options of option. */
/*
* Update scanning pointer, either because a reset was requested or
}
typedef struct {
- HANDLE handle;
+ HANDLE handle;
WIN32_FIND_DATA find_data;
- bool first_file;
- char * filename;
+ bool first_file;
+ char *filename;
} isc_dir_t;
bool
static int maxtype = -1;
-static char *upper(char *);
-static char *funname(const char *, char *);
-static void doswitch(const char *, const char *, const char *, const char *,
- const char *, const char *);
-static void add(int, const char *, int, const char *, const char *);
-static void sd(int, const char *, const char *, char);
-static void insert_into_typenames(int, const char *, const char *);
+static char *
+upper(char *);
+static char *
+funname(const char *, char *);
+static void
+doswitch(const char *, const char *, const char *, const char *, const char *,
+ const char *);
+static void
+add(int, const char *, int, const char *, const char *);
+static void
+sd(int, const char *, const char *, char);
+static void
+insert_into_typenames(int, const char *, const char *);
/*%
* If you use more than 10 of these in, say, a printf(), you'll have problems.
return (ISC_R_SUCCESS); \
}
-static isc_result_t hmac_fromdns(isc_md_type_t type, dst_key_t *key,
- isc_buffer_t *data);
+static isc_result_t
+hmac_fromdns(isc_md_type_t type, dst_key_t *key, isc_buffer_t *data);
struct dst_hmac_key {
uint8_t key[ISC_MAX_BLOCK_SIZE];
#include <dns/acl.h>
-static void destroy_iptable(dns_iptable_t *dtab);
+static void
+destroy_iptable(dns_iptable_t *dtab);
/*
* Create a new IP table and the underlying radix structure
#define JOURNAL_SERIALSET 0x01U
-static isc_result_t index_to_disk(dns_journal_t *);
+static isc_result_t
+index_to_disk(dns_journal_t *);
static inline uint32_t
decode_uint32(unsigned char *p) {
* when we reach the serial number that was current when the IXFR started.
*/
-static isc_result_t read_one_rr(dns_journal_t *j);
+static isc_result_t
+read_one_rr(dns_journal_t *j);
/*
* Make sure the buffer 'b' is has at least 'size' bytes
#define MAX_RESTARTS 16
-static void lookup_find(dns_lookup_t *lookup, dns_fetchevent_t *event);
+static void
+lookup_find(dns_lookup_t *lookup, dns_fetchevent_t *event);
static void
fetch_done(isc_task_t *task, isc_event_t *event) {
#define DNS_AS_STR(t) ((t).value.as_textregion.base)
-static isc_result_t openfile_text(dns_loadctx_t *lctx, const char *master_file);
+static isc_result_t
+openfile_text(dns_loadctx_t *lctx, const char *master_file);
-static isc_result_t load_text(dns_loadctx_t *lctx);
+static isc_result_t
+load_text(dns_loadctx_t *lctx);
-static isc_result_t openfile_raw(dns_loadctx_t *lctx, const char *master_file);
+static isc_result_t
+openfile_raw(dns_loadctx_t *lctx, const char *master_file);
-static isc_result_t load_raw(dns_loadctx_t *lctx);
+static isc_result_t
+load_raw(dns_loadctx_t *lctx);
-static isc_result_t openfile_map(dns_loadctx_t *lctx, const char *master_file);
+static isc_result_t
+openfile_map(dns_loadctx_t *lctx, const char *master_file);
-static isc_result_t load_map(dns_loadctx_t *lctx);
+static isc_result_t
+load_map(dns_loadctx_t *lctx);
-static isc_result_t pushfile(const char *master_file, dns_name_t *origin,
- dns_loadctx_t *lctx);
+static isc_result_t
+pushfile(const char *master_file, dns_name_t *origin, dns_loadctx_t *lctx);
-static isc_result_t commit(dns_rdatacallbacks_t *, dns_loadctx_t *,
- rdatalist_head_t *, dns_name_t *, const char *,
- unsigned int);
+static isc_result_t
+commit(dns_rdatacallbacks_t *, dns_loadctx_t *, rdatalist_head_t *,
+ dns_name_t *, const char *, unsigned int);
-static bool is_glue(rdatalist_head_t *, dns_name_t *);
+static bool
+is_glue(rdatalist_head_t *, dns_name_t *);
-static dns_rdatalist_t *grow_rdatalist(int, dns_rdatalist_t *, int,
- rdatalist_head_t *, rdatalist_head_t *,
- isc_mem_t *mctx);
+static dns_rdatalist_t *
+grow_rdatalist(int, dns_rdatalist_t *, int, rdatalist_head_t *,
+ rdatalist_head_t *, isc_mem_t *mctx);
-static dns_rdata_t *grow_rdata(int, dns_rdata_t *, int, rdatalist_head_t *,
- rdatalist_head_t *, isc_mem_t *);
+static dns_rdata_t *
+grow_rdata(int, dns_rdata_t *, int, rdatalist_head_t *, rdatalist_head_t *,
+ isc_mem_t *);
-static void load_quantum(isc_task_t *task, isc_event_t *event);
+static void
+load_quantum(isc_task_t *task, isc_event_t *event);
-static isc_result_t task_send(dns_loadctx_t *lctx);
+static isc_result_t
+task_send(dns_loadctx_t *lctx);
-static void loadctx_destroy(dns_loadctx_t *lctx);
+static void
+loadctx_destroy(dns_loadctx_t *lctx);
#define GETTOKENERR(lexer, options, token, eol, err) \
do { \
*/
static const int initial_buffer_length = 1200;
-static isc_result_t dumptostreaminc(dns_dumpctx_t *dctx);
+static isc_result_t
+dumptostreaminc(dns_dumpctx_t *dctx);
static void
dumpctx_destroy(dns_dumpctx_t *dctx) {
ISC_LINK(dns_msgblock_t) link;
}; /* dynamically sized */
-static inline dns_msgblock_t *msgblock_allocate(isc_mem_t *, unsigned int,
- unsigned int);
+static inline dns_msgblock_t *
+msgblock_allocate(isc_mem_t *, unsigned int, unsigned int);
#define msgblock_get(block, type) \
((type *)msgblock_internalget(block, sizeof(type)))
-static inline void *msgblock_internalget(dns_msgblock_t *, unsigned int);
+static inline void *
+msgblock_internalget(dns_msgblock_t *, unsigned int);
-static inline void msgblock_reset(dns_msgblock_t *);
+static inline void
+msgblock_reset(dns_msgblock_t *);
-static inline void msgblock_free(isc_mem_t *, dns_msgblock_t *, unsigned int);
+static inline void
+msgblock_free(isc_mem_t *, dns_msgblock_t *, unsigned int);
-static void logfmtpacket(dns_message_t *message, const char *description,
- const isc_sockaddr_t *address,
- isc_logcategory_t *category, isc_logmodule_t *module,
- const dns_master_style_t *style, int level,
- isc_mem_t *mctx);
+static void
+logfmtpacket(dns_message_t *message, const char *description,
+ const isc_sockaddr_t *address, isc_logcategory_t *category,
+ isc_logmodule_t *module, const dns_master_style_t *style,
+ int level, isc_mem_t *mctx);
/*
* Allocate a new dns_msgblock_t, and return a pointer to it. If no memory
*/
ISC_THREAD_LOCAL dns_name_totextfilter_t *totext_filter_proc = NULL;
-static void set_offsets(const dns_name_t *name, unsigned char *offsets,
- dns_name_t *set_name);
+static void
+set_offsets(const dns_name_t *name, unsigned char *offsets,
+ dns_name_t *set_name);
void
dns_name_init(dns_name_t *name, unsigned char *offsets) {
*
*/
-static isc_result_t addoptout(dns_message_t *message, dns_db_t *cache,
- dns_dbnode_t *node, dns_rdatatype_t covers,
- isc_stdtime_t now, dns_ttl_t minttl,
- dns_ttl_t maxttl, bool optout, bool secure,
- dns_rdataset_t *addedrdataset);
+static isc_result_t
+addoptout(dns_message_t *message, dns_db_t *cache, dns_dbnode_t *node,
+ dns_rdatatype_t covers, isc_stdtime_t now, dns_ttl_t minttl,
+ dns_ttl_t maxttl, bool optout, bool secure,
+ dns_rdataset_t *addedrdataset);
static inline isc_result_t
copy_rdataset(dns_rdataset_t *rdataset, isc_buffer_t *buffer) {
"83655D23DCA3AD961C62F356208552BB9ED529077096966D" \
"670C354E4ABC9804F1746C08CA237327FFFFFFFFFFFFFFFF"
-static isc_result_t openssldh_todns(const dst_key_t *key, isc_buffer_t *data);
+static isc_result_t
+openssldh_todns(const dst_key_t *key, isc_buffer_t *data);
static BIGNUM *bn2 = NULL, *bn768 = NULL, *bn1024 = NULL, *bn1536 = NULL;
}
#endif /* !HAVE_ECDSA_SIG_GET0 */
-static isc_result_t opensslecdsa_todns(const dst_key_t *key,
- isc_buffer_t *data);
+static isc_result_t
+opensslecdsa_todns(const dst_key_t *key, isc_buffer_t *data);
static isc_result_t
opensslecdsa_createctx(dst_key_t *key, dst_context_t *dctx) {
#endif /* HAVE_OPENSSL_ED448 */
-static isc_result_t openssleddsa_todns(const dst_key_t *key,
- isc_buffer_t *data);
+static isc_result_t
+openssleddsa_todns(const dst_key_t *key, isc_buffer_t *data);
static isc_result_t
openssleddsa_createctx(dst_key_t *key, dst_context_t *dctx) {
#endif /* !HAVE_RSA_SET0_KEY */
-static isc_result_t opensslrsa_todns(const dst_key_t *key, isc_buffer_t *data);
+static isc_result_t
+opensslrsa_todns(const dst_key_t *key, isc_buffer_t *data);
static isc_result_t
opensslrsa_createctx(dst_key_t *key, dst_context_t *dctx) {
#define SERVER_PADDING_BIT 16
#define REQUEST_TCP_KEEPALIVE_BIT 17
-static void peerlist_delete(dns_peerlist_t **list);
+static void
+peerlist_delete(dns_peerlist_t **list);
-static void peer_delete(dns_peer_t **peer);
+static void
+peer_delete(dns_peer_t **peer);
isc_result_t
dns_peerlist_new(isc_mem_t *mem, dns_peerlist_t **list) {
static CK_BBOOL truevalue = TRUE;
static CK_BBOOL falsevalue = FALSE;
-static isc_result_t pkcs11ecdsa_todns(const dst_key_t *key, isc_buffer_t *data);
-static void pkcs11ecdsa_destroy(dst_key_t *key);
-static isc_result_t pkcs11ecdsa_fetch(dst_key_t *key, const char *engine,
- const char *label, dst_key_t *pub);
+static isc_result_t
+pkcs11ecdsa_todns(const dst_key_t *key, isc_buffer_t *data);
+static void
+pkcs11ecdsa_destroy(dst_key_t *key);
+static isc_result_t
+pkcs11ecdsa_fetch(dst_key_t *key, const char *engine, const char *label,
+ dst_key_t *pub);
static isc_result_t
pkcs11ecdsa_createctx(dst_key_t *key, dst_context_t *dctx) {
static CK_BBOOL truevalue = TRUE;
static CK_BBOOL falsevalue = FALSE;
-static isc_result_t pkcs11eddsa_todns(const dst_key_t *key, isc_buffer_t *data);
-static void pkcs11eddsa_destroy(dst_key_t *key);
-static isc_result_t pkcs11eddsa_fetch(dst_key_t *key, const char *engine,
- const char *label, dst_key_t *pub);
+static isc_result_t
+pkcs11eddsa_todns(const dst_key_t *key, isc_buffer_t *data);
+static void
+pkcs11eddsa_destroy(dst_key_t *key);
+static isc_result_t
+pkcs11eddsa_fetch(dst_key_t *key, const char *engine, const char *label,
+ dst_key_t *pub);
static isc_result_t
pkcs11eddsa_createctx(dst_key_t *key, dst_context_t *dctx) {
static CK_BBOOL truevalue = TRUE;
static CK_BBOOL falsevalue = FALSE;
-static isc_result_t pkcs11rsa_todns(const dst_key_t *key, isc_buffer_t *data);
-static void pkcs11rsa_destroy(dst_key_t *key);
-static isc_result_t pkcs11rsa_fetch(dst_key_t *key, const char *engine,
- const char *label, dst_key_t *pub);
+static isc_result_t
+pkcs11rsa_todns(const dst_key_t *key, isc_buffer_t *data);
+static void
+pkcs11rsa_destroy(dst_key_t *key);
+static isc_result_t
+pkcs11rsa_fetch(dst_key_t *key, const char *engine, const char *label,
+ dst_key_t *pub);
#ifndef PK11_RSA_PKCS_REPLACE
* and fseeked, not to a pipe or stream
*/
-static isc_result_t dns_rbt_zero_header(FILE *file);
+static isc_result_t
+dns_rbt_zero_header(FILE *file);
-static isc_result_t write_header(FILE *file, dns_rbt_t *rbt,
- uint64_t first_node_offset, uint64_t crc);
+static isc_result_t
+write_header(FILE *file, dns_rbt_t *rbt, uint64_t first_node_offset,
+ uint64_t crc);
-static bool match_header_version(file_header_t *header);
+static bool
+match_header_version(file_header_t *header);
-static isc_result_t serialize_node(FILE *file, dns_rbtnode_t *node,
- uintptr_t left, uintptr_t right,
- uintptr_t down, uintptr_t parent,
- uintptr_t data, uint64_t *crc);
+static isc_result_t
+serialize_node(FILE *file, dns_rbtnode_t *node, uintptr_t left, uintptr_t right,
+ uintptr_t down, uintptr_t parent, uintptr_t data, uint64_t *crc);
-static isc_result_t serialize_nodes(FILE *file, dns_rbtnode_t *node,
- uintptr_t parent,
- dns_rbtdatawriter_t datawriter,
- void *writer_arg, uintptr_t *where,
- uint64_t *crc);
+static isc_result_t
+serialize_nodes(FILE *file, dns_rbtnode_t *node, uintptr_t parent,
+ dns_rbtdatawriter_t datawriter, void *writer_arg,
+ uintptr_t *where, uint64_t *crc);
/*
* The following functions allow you to get the actual address of a pointer
/*
* A little something to help out in GDB.
*/
-dns_name_t Name(dns_rbtnode_t *node);
+dns_name_t
+Name(dns_rbtnode_t *node);
dns_name_t
Name(dns_rbtnode_t *node) {
dns_name_t name;
/*
* Forward declarations.
*/
-static isc_result_t create_node(isc_mem_t *mctx, const dns_name_t *name,
- dns_rbtnode_t **nodep);
+static isc_result_t
+create_node(isc_mem_t *mctx, const dns_name_t *name, dns_rbtnode_t **nodep);
-static isc_result_t inithash(dns_rbt_t *rbt);
+static isc_result_t
+inithash(dns_rbt_t *rbt);
-static inline void hash_node(dns_rbt_t *rbt, dns_rbtnode_t *node,
- const dns_name_t *name);
+static inline void
+hash_node(dns_rbt_t *rbt, dns_rbtnode_t *node, const dns_name_t *name);
-static inline void unhash_node(dns_rbt_t *rbt, dns_rbtnode_t *node);
+static inline void
+unhash_node(dns_rbt_t *rbt, dns_rbtnode_t *node);
-static void rehash(dns_rbt_t *rbt, unsigned int newcount);
+static void
+rehash(dns_rbt_t *rbt, unsigned int newcount);
-static inline void rotate_left(dns_rbtnode_t *node, dns_rbtnode_t **rootp);
-static inline void rotate_right(dns_rbtnode_t *node, dns_rbtnode_t **rootp);
+static inline void
+rotate_left(dns_rbtnode_t *node, dns_rbtnode_t **rootp);
+static inline void
+rotate_right(dns_rbtnode_t *node, dns_rbtnode_t **rootp);
-static void addonlevel(dns_rbtnode_t *node, dns_rbtnode_t *current, int order,
- dns_rbtnode_t **rootp);
+static void
+addonlevel(dns_rbtnode_t *node, dns_rbtnode_t *current, int order,
+ dns_rbtnode_t **rootp);
-static void deletefromlevel(dns_rbtnode_t *item, dns_rbtnode_t **rootp);
+static void
+deletefromlevel(dns_rbtnode_t *item, dns_rbtnode_t **rootp);
-static isc_result_t treefix(dns_rbt_t *rbt, void *base, size_t size,
- dns_rbtnode_t *n, const dns_name_t *name,
- dns_rbtdatafixer_t datafixer, void *fixer_arg,
- uint64_t *crc);
+static isc_result_t
+treefix(dns_rbt_t *rbt, void *base, size_t size, dns_rbtnode_t *n,
+ const dns_name_t *name, dns_rbtdatafixer_t datafixer, void *fixer_arg,
+ uint64_t *crc);
-static void deletetreeflat(dns_rbt_t *rbt, unsigned int quantum, bool unhash,
- dns_rbtnode_t **nodep);
+static void
+deletetreeflat(dns_rbt_t *rbt, unsigned int quantum, bool unhash,
+ dns_rbtnode_t **nodep);
-static void printnodename(dns_rbtnode_t *node, bool quoted, FILE *f);
+static void
+printnodename(dns_rbtnode_t *node, bool quoted, FILE *f);
-static void freenode(dns_rbt_t *rbt, dns_rbtnode_t **nodep);
+static void
+freenode(dns_rbt_t *rbt, dns_rbtnode_t **nodep);
static isc_result_t
dns_rbt_zero_header(FILE *file) {
isc_stdtime_t now;
} rbtdb_load_t;
-static void delete_callback(void *data, void *arg);
-static void rdataset_disassociate(dns_rdataset_t *rdataset);
-static isc_result_t rdataset_first(dns_rdataset_t *rdataset);
-static isc_result_t rdataset_next(dns_rdataset_t *rdataset);
-static void rdataset_current(dns_rdataset_t *rdataset, dns_rdata_t *rdata);
-static void rdataset_clone(dns_rdataset_t *source, dns_rdataset_t *target);
-static unsigned int rdataset_count(dns_rdataset_t *rdataset);
-static isc_result_t rdataset_getnoqname(dns_rdataset_t *rdataset,
- dns_name_t *name, dns_rdataset_t *neg,
- dns_rdataset_t *negsig);
-static isc_result_t rdataset_getclosest(dns_rdataset_t *rdataset,
- dns_name_t *name, dns_rdataset_t *neg,
- dns_rdataset_t *negsig);
-static inline bool need_headerupdate(rdatasetheader_t *header,
- isc_stdtime_t now);
-static void update_header(dns_rbtdb_t *rbtdb, rdatasetheader_t *header,
- isc_stdtime_t now);
-static void expire_header(dns_rbtdb_t *rbtdb, rdatasetheader_t *header,
- bool tree_locked, expire_t reason);
-static void overmem_purge(dns_rbtdb_t *rbtdb, unsigned int locknum_start,
- isc_stdtime_t now, bool tree_locked);
-static isc_result_t resign_insert(dns_rbtdb_t *rbtdb, int idx,
- rdatasetheader_t *newheader);
-static void resign_delete(dns_rbtdb_t *rbtdb, rbtdb_version_t *version,
- rdatasetheader_t *header);
-static void prune_tree(isc_task_t *task, isc_event_t *event);
-static void rdataset_settrust(dns_rdataset_t *rdataset, dns_trust_t trust);
-static void rdataset_expire(dns_rdataset_t *rdataset);
-static void rdataset_clearprefetch(dns_rdataset_t *rdataset);
-static void rdataset_setownercase(dns_rdataset_t *rdataset,
- const dns_name_t *name);
-static void rdataset_getownercase(const dns_rdataset_t *rdataset,
- dns_name_t *name);
-static isc_result_t rdataset_addglue(dns_rdataset_t *rdataset,
- dns_dbversion_t *version,
- dns_message_t *msg);
-static void free_gluetable(rbtdb_version_t *version);
+static void
+delete_callback(void *data, void *arg);
+static void
+rdataset_disassociate(dns_rdataset_t *rdataset);
+static isc_result_t
+rdataset_first(dns_rdataset_t *rdataset);
+static isc_result_t
+rdataset_next(dns_rdataset_t *rdataset);
+static void
+rdataset_current(dns_rdataset_t *rdataset, dns_rdata_t *rdata);
+static void
+rdataset_clone(dns_rdataset_t *source, dns_rdataset_t *target);
+static unsigned int
+rdataset_count(dns_rdataset_t *rdataset);
+static isc_result_t
+rdataset_getnoqname(dns_rdataset_t *rdataset, dns_name_t *name,
+ dns_rdataset_t *neg, dns_rdataset_t *negsig);
+static isc_result_t
+rdataset_getclosest(dns_rdataset_t *rdataset, dns_name_t *name,
+ dns_rdataset_t *neg, dns_rdataset_t *negsig);
+static inline bool
+need_headerupdate(rdatasetheader_t *header, isc_stdtime_t now);
+static void
+update_header(dns_rbtdb_t *rbtdb, rdatasetheader_t *header, isc_stdtime_t now);
+static void
+expire_header(dns_rbtdb_t *rbtdb, rdatasetheader_t *header, bool tree_locked,
+ expire_t reason);
+static void
+overmem_purge(dns_rbtdb_t *rbtdb, unsigned int locknum_start, isc_stdtime_t now,
+ bool tree_locked);
+static isc_result_t
+resign_insert(dns_rbtdb_t *rbtdb, int idx, rdatasetheader_t *newheader);
+static void
+resign_delete(dns_rbtdb_t *rbtdb, rbtdb_version_t *version,
+ rdatasetheader_t *header);
+static void
+prune_tree(isc_task_t *task, isc_event_t *event);
+static void
+rdataset_settrust(dns_rdataset_t *rdataset, dns_trust_t trust);
+static void
+rdataset_expire(dns_rdataset_t *rdataset);
+static void
+rdataset_clearprefetch(dns_rdataset_t *rdataset);
+static void
+rdataset_setownercase(dns_rdataset_t *rdataset, const dns_name_t *name);
+static void
+rdataset_getownercase(const dns_rdataset_t *rdataset, dns_name_t *name);
+static isc_result_t
+rdataset_addglue(dns_rdataset_t *rdataset, dns_dbversion_t *version,
+ dns_message_t *msg);
+static void
+free_gluetable(rbtdb_version_t *version);
static dns_rdatasetmethods_t rdataset_methods = { rdataset_disassociate,
rdataset_first,
NULL /* addglue */
};
-static void rdatasetiter_destroy(dns_rdatasetiter_t **iteratorp);
-static isc_result_t rdatasetiter_first(dns_rdatasetiter_t *iterator);
-static isc_result_t rdatasetiter_next(dns_rdatasetiter_t *iterator);
-static void rdatasetiter_current(dns_rdatasetiter_t *iterator,
- dns_rdataset_t *rdataset);
+static void
+rdatasetiter_destroy(dns_rdatasetiter_t **iteratorp);
+static isc_result_t
+rdatasetiter_first(dns_rdatasetiter_t *iterator);
+static isc_result_t
+rdatasetiter_next(dns_rdatasetiter_t *iterator);
+static void
+rdatasetiter_current(dns_rdatasetiter_t *iterator, dns_rdataset_t *rdataset);
static dns_rdatasetitermethods_t rdatasetiter_methods = {
rdatasetiter_destroy, rdatasetiter_first, rdatasetiter_next,
* the address of either "chain" or "nsec3chain", depending on which RBT is
* being traversed at given time.
*/
-static void dbiterator_destroy(dns_dbiterator_t **iteratorp);
-static isc_result_t dbiterator_first(dns_dbiterator_t *iterator);
-static isc_result_t dbiterator_last(dns_dbiterator_t *iterator);
-static isc_result_t dbiterator_seek(dns_dbiterator_t *iterator,
- const dns_name_t *name);
-static isc_result_t dbiterator_prev(dns_dbiterator_t *iterator);
-static isc_result_t dbiterator_next(dns_dbiterator_t *iterator);
-static isc_result_t dbiterator_current(dns_dbiterator_t *iterator,
- dns_dbnode_t **nodep, dns_name_t *name);
-static isc_result_t dbiterator_pause(dns_dbiterator_t *iterator);
-static isc_result_t dbiterator_origin(dns_dbiterator_t *iterator,
- dns_name_t *name);
+static void
+dbiterator_destroy(dns_dbiterator_t **iteratorp);
+static isc_result_t
+dbiterator_first(dns_dbiterator_t *iterator);
+static isc_result_t
+dbiterator_last(dns_dbiterator_t *iterator);
+static isc_result_t
+dbiterator_seek(dns_dbiterator_t *iterator, const dns_name_t *name);
+static isc_result_t
+dbiterator_prev(dns_dbiterator_t *iterator);
+static isc_result_t
+dbiterator_next(dns_dbiterator_t *iterator);
+static isc_result_t
+dbiterator_current(dns_dbiterator_t *iterator, dns_dbnode_t **nodep,
+ dns_name_t *name);
+static isc_result_t
+dbiterator_pause(dns_dbiterator_t *iterator);
+static isc_result_t
+dbiterator_origin(dns_dbiterator_t *iterator, dns_name_t *name);
static dns_dbiteratormethods_t dbiterator_methods = {
dbiterator_destroy, dbiterator_first, dbiterator_last,
#define IS_STUB(rbtdb) (((rbtdb)->common.attributes & DNS_DBATTR_STUB) != 0)
#define IS_CACHE(rbtdb) (((rbtdb)->common.attributes & DNS_DBATTR_CACHE) != 0)
-static void free_rbtdb(dns_rbtdb_t *rbtdb, bool log, isc_event_t *event);
-static void overmem(dns_db_t *db, bool over);
-static void setnsec3parameters(dns_db_t *db, rbtdb_version_t *version);
-static void setownercase(rdatasetheader_t *header, const dns_name_t *name);
+static void
+free_rbtdb(dns_rbtdb_t *rbtdb, bool log, isc_event_t *event);
+static void
+overmem(dns_db_t *db, bool over);
+static void
+setnsec3parameters(dns_db_t *db, rbtdb_version_t *version);
+static void
+setownercase(rdatasetheader_t *header, const dns_name_t *name);
-static bool match_header_version(rbtdb_file_header_t *header);
+static bool
+match_header_version(rbtdb_file_header_t *header);
/* Pad to 32 bytes */
static char FILE_VERSION[32] = "\0";
const char *linebreak; /*%< Line break string. */
} dns_rdata_textctx_t;
-static isc_result_t txt_totext(isc_region_t *source, bool quote,
- isc_buffer_t *target);
+static isc_result_t
+txt_totext(isc_region_t *source, bool quote, isc_buffer_t *target);
-static isc_result_t txt_fromtext(isc_textregion_t *source,
- isc_buffer_t *target);
+static isc_result_t
+txt_fromtext(isc_textregion_t *source, isc_buffer_t *target);
-static isc_result_t txt_fromwire(isc_buffer_t *source, isc_buffer_t *target);
+static isc_result_t
+txt_fromwire(isc_buffer_t *source, isc_buffer_t *target);
-static isc_result_t multitxt_totext(isc_region_t *source, isc_buffer_t *target);
+static isc_result_t
+multitxt_totext(isc_region_t *source, isc_buffer_t *target);
-static isc_result_t multitxt_fromtext(isc_textregion_t *source,
- isc_buffer_t *target);
+static isc_result_t
+multitxt_fromtext(isc_textregion_t *source, isc_buffer_t *target);
-static bool name_prefix(dns_name_t *name, const dns_name_t *origin,
- dns_name_t *target);
+static bool
+name_prefix(dns_name_t *name, const dns_name_t *origin, dns_name_t *target);
-static unsigned int name_length(const dns_name_t *name);
+static unsigned int
+name_length(const dns_name_t *name);
-static isc_result_t str_totext(const char *source, isc_buffer_t *target);
+static isc_result_t
+str_totext(const char *source, isc_buffer_t *target);
-static isc_result_t inet_totext(int af, isc_region_t *src,
- isc_buffer_t *target);
+static isc_result_t
+inet_totext(int af, isc_region_t *src, isc_buffer_t *target);
-static bool buffer_empty(isc_buffer_t *source);
+static bool
+buffer_empty(isc_buffer_t *source);
-static void buffer_fromregion(isc_buffer_t *buffer, isc_region_t *region);
+static void
+buffer_fromregion(isc_buffer_t *buffer, isc_region_t *region);
-static isc_result_t uint32_tobuffer(uint32_t, isc_buffer_t *target);
+static isc_result_t
+uint32_tobuffer(uint32_t, isc_buffer_t *target);
-static isc_result_t uint16_tobuffer(uint32_t, isc_buffer_t *target);
+static isc_result_t
+uint16_tobuffer(uint32_t, isc_buffer_t *target);
-static isc_result_t uint8_tobuffer(uint32_t, isc_buffer_t *target);
+static isc_result_t
+uint8_tobuffer(uint32_t, isc_buffer_t *target);
-static isc_result_t name_tobuffer(const dns_name_t *name, isc_buffer_t *target);
+static isc_result_t
+name_tobuffer(const dns_name_t *name, isc_buffer_t *target);
-static uint32_t uint32_fromregion(isc_region_t *region);
+static uint32_t
+uint32_fromregion(isc_region_t *region);
-static uint16_t uint16_fromregion(isc_region_t *region);
+static uint16_t
+uint16_fromregion(isc_region_t *region);
-static uint8_t uint8_fromregion(isc_region_t *region);
+static uint8_t
+uint8_fromregion(isc_region_t *region);
-static uint8_t uint8_consume_fromregion(isc_region_t *region);
+static uint8_t
+uint8_consume_fromregion(isc_region_t *region);
-static isc_result_t mem_tobuffer(isc_buffer_t *target, void *base,
- unsigned int length);
+static isc_result_t
+mem_tobuffer(isc_buffer_t *target, void *base, unsigned int length);
-static int hexvalue(char value);
+static int
+hexvalue(char value);
-static int decvalue(char value);
+static int
+decvalue(char value);
-static void default_fromtext_callback(dns_rdatacallbacks_t *callbacks,
- const char *, ...)
+static void
+default_fromtext_callback(dns_rdatacallbacks_t *callbacks, const char *, ...)
ISC_FORMAT_PRINTF(2, 3);
static void
dns_rdatacallbacks_t *callbacks, const char *name,
unsigned long line, isc_token_t *token, isc_result_t result);
-static void fromtext_warneof(isc_lex_t *lexer, dns_rdatacallbacks_t *callbacks);
+static void
+fromtext_warneof(isc_lex_t *lexer, dns_rdatacallbacks_t *callbacks);
-static isc_result_t rdata_totext(dns_rdata_t *rdata, dns_rdata_textctx_t *tctx,
- isc_buffer_t *target);
+static isc_result_t
+rdata_totext(dns_rdata_t *rdata, dns_rdata_textctx_t *tctx,
+ isc_buffer_t *target);
-static void warn_badname(const dns_name_t *name, isc_lex_t *lexer,
- dns_rdatacallbacks_t *callbacks);
+static void
+warn_badname(const dns_name_t *name, isc_lex_t *lexer,
+ dns_rdatacallbacks_t *callbacks);
-static void warn_badmx(isc_token_t *token, isc_lex_t *lexer,
- dns_rdatacallbacks_t *callbacks);
+static void
+warn_badmx(isc_token_t *token, isc_lex_t *lexer,
+ dns_rdatacallbacks_t *callbacks);
-static uint16_t uint16_consume_fromregion(isc_region_t *region);
+static uint16_t
+uint16_consume_fromregion(isc_region_t *region);
-static isc_result_t unknown_totext(dns_rdata_t *rdata,
- dns_rdata_textctx_t *tctx,
- isc_buffer_t *target);
+static isc_result_t
+unknown_totext(dns_rdata_t *rdata, dns_rdata_textctx_t *tctx,
+ isc_buffer_t *target);
static inline isc_result_t generic_fromtext_key(ARGS_FROMTEXT);
static void generic_freestruct_txt(ARGS_FREESTRUCT);
-static isc_result_t generic_txt_first(dns_rdata_txt_t *txt);
+static isc_result_t
+generic_txt_first(dns_rdata_txt_t *txt);
-static isc_result_t generic_txt_next(dns_rdata_txt_t *txt);
+static isc_result_t
+generic_txt_next(dns_rdata_txt_t *txt);
-static isc_result_t generic_txt_current(dns_rdata_txt_t *txt,
- dns_rdata_txt_string_t *string);
+static isc_result_t
+generic_txt_current(dns_rdata_txt_t *txt, dns_rdata_txt_string_t *string);
static isc_result_t generic_totext_ds(ARGS_TOTEXT);
/*% RFC2845 */
typedef struct dns_rdata_any_tsig {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- dns_name_t algorithm;
- uint64_t timesigned;
- uint16_t fudge;
- uint16_t siglen;
- unsigned char * signature;
- uint16_t originalid;
- uint16_t error;
- uint16_t otherlen;
- unsigned char * other;
+ isc_mem_t *mctx;
+ dns_name_t algorithm;
+ uint64_t timesigned;
+ uint16_t fudge;
+ uint16_t siglen;
+ unsigned char *signature;
+ uint16_t originalid;
+ uint16_t error;
+ uint16_t otherlen;
+ unsigned char *other;
} dns_rdata_any_tsig_t;
#endif /* ANY_255_TSIG_250_H */
typedef struct dns_rdata_ch_a {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- dns_name_t ch_addr_dom; /* ch-addr domain for back mapping
- * */
- ch_addr_t ch_addr; /* chaos address (16 bit) network
- * order */
+ isc_mem_t *mctx;
+ dns_name_t ch_addr_dom; /* ch-addr domain for back mapping
+ * */
+ ch_addr_t ch_addr; /* chaos address (16 bit) network
+ * order */
} dns_rdata_ch_a_t;
#endif /* CH_3_A_1_H */
typedef struct dns_rdata_afsdb {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- uint16_t subtype;
- dns_name_t server;
+ isc_mem_t *mctx;
+ uint16_t subtype;
+ dns_name_t server;
} dns_rdata_afsdb_t;
#endif /* GENERIC_AFSDB_18_H */
typedef struct dns_rdata_amtrelay {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- uint8_t precedence;
- bool discovery;
- uint8_t gateway_type;
- struct in_addr in_addr; /* gateway type 1 */
- struct in6_addr in6_addr; /* gateway type 2 */
- dns_name_t gateway; /* gateway type 3 */
- unsigned char * data; /* gateway type > 3 */
- uint16_t length;
+ isc_mem_t *mctx;
+ uint8_t precedence;
+ bool discovery;
+ uint8_t gateway_type;
+ struct in_addr in_addr; /* gateway type 1 */
+ struct in6_addr in6_addr; /* gateway type 2 */
+ dns_name_t gateway; /* gateway type 3 */
+ unsigned char *data; /* gateway type > 3 */
+ uint16_t length;
} dns_rdata_amtrelay_t;
#endif /* GENERIC_AMTRELAY_260_H */
typedef struct dns_rdata_avc {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- unsigned char * data;
- uint16_t length;
+ isc_mem_t *mctx;
+ unsigned char *data;
+ uint16_t length;
/* private */
uint16_t offset;
} dns_rdata_avc_t;
typedef struct dns_rdata_caa {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- uint8_t flags;
- unsigned char * tag;
- uint8_t tag_len;
- unsigned char * value;
- uint16_t value_len;
+ isc_mem_t *mctx;
+ uint8_t flags;
+ unsigned char *tag;
+ uint8_t tag_len;
+ unsigned char *value;
+ uint16_t value_len;
} dns_rdata_caa_t;
#endif /* GENERIC_CAA_257_H */
/*% RFC2538 */
typedef struct dns_rdata_cert {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- uint16_t type;
- uint16_t key_tag;
- uint8_t algorithm;
- uint16_t length;
- unsigned char * certificate;
+ isc_mem_t *mctx;
+ uint16_t type;
+ uint16_t key_tag;
+ uint8_t algorithm;
+ uint16_t length;
+ unsigned char *certificate;
} dns_rdata_cert_t;
#endif /* GENERIC_CERT_37_H */
typedef struct dns_rdata_cname {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- dns_name_t cname;
+ isc_mem_t *mctx;
+ dns_name_t cname;
} dns_rdata_cname_t;
#endif /* GENERIC_CNAME_5_H */
typedef struct dns_rdata_csync {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- uint32_t serial;
- uint16_t flags;
- unsigned char * typebits;
- uint16_t len;
+ isc_mem_t *mctx;
+ uint32_t serial;
+ uint16_t flags;
+ unsigned char *typebits;
+ uint16_t len;
} dns_rdata_csync_t;
#endif /* GENERIC_CSYNC_62_H */
typedef struct dns_rdata_dname {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- dns_name_t dname;
+ isc_mem_t *mctx;
+ dns_name_t dname;
} dns_rdata_dname_t;
#endif /* GENERIC_DNAME_39_H */
typedef struct dns_rdata_doa {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- unsigned char * mediatype;
- unsigned char * data;
- uint32_t enterprise;
- uint32_t type;
- uint16_t data_len;
- uint8_t location;
- uint8_t mediatype_len;
+ isc_mem_t *mctx;
+ unsigned char *mediatype;
+ unsigned char *data;
+ uint32_t enterprise;
+ uint32_t type;
+ uint16_t data_len;
+ uint8_t location;
+ uint8_t mediatype_len;
} dns_rdata_doa_t;
#endif /* GENERIC_DOA_259_H */
* \brief per draft-ietf-dnsext-delegation-signer-05.txt */
typedef struct dns_rdata_ds {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- uint16_t key_tag;
- dns_secalg_t algorithm;
- dns_dsdigest_t digest_type;
- uint16_t length;
- unsigned char * digest;
+ isc_mem_t *mctx;
+ uint16_t key_tag;
+ dns_secalg_t algorithm;
+ dns_dsdigest_t digest_type;
+ uint16_t length;
+ unsigned char *digest;
} dns_rdata_ds_t;
#endif /* GENERIC_DS_43_H */
typedef struct dns_rdata_eui48 {
dns_rdatacommon_t common;
- unsigned char eui48[6];
+ unsigned char eui48[6];
} dns_rdata_eui48_t;
#endif /* GENERIC_EUI48_10k_H */
typedef struct dns_rdata_eui64 {
dns_rdatacommon_t common;
- unsigned char eui64[8];
+ unsigned char eui64[8];
} dns_rdata_eui64_t;
#endif /* GENERIC_EUI64_10k_H */
typedef struct dns_rdata_gpos {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- char * longitude;
- char * latitude;
- char * altitude;
- uint8_t long_len;
- uint8_t lat_len;
- uint8_t alt_len;
+ isc_mem_t *mctx;
+ char *longitude;
+ char *latitude;
+ char *altitude;
+ uint8_t long_len;
+ uint8_t lat_len;
+ uint8_t alt_len;
} dns_rdata_gpos_t;
#endif /* GENERIC_GPOS_27_H */
typedef struct dns_rdata_hinfo {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- char * cpu;
- char * os;
- uint8_t cpu_len;
- uint8_t os_len;
+ isc_mem_t *mctx;
+ char *cpu;
+ char *os;
+ uint8_t cpu_len;
+ uint8_t os_len;
} dns_rdata_hinfo_t;
#endif /* GENERIC_HINFO_13_H */
typedef struct dns_rdata_hip {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- unsigned char * hit;
- unsigned char * key;
- unsigned char * servers;
- uint8_t algorithm;
- uint8_t hit_len;
- uint16_t key_len;
- uint16_t servers_len;
+ isc_mem_t *mctx;
+ unsigned char *hit;
+ unsigned char *key;
+ unsigned char *servers;
+ uint8_t algorithm;
+ uint8_t hit_len;
+ uint16_t key_len;
+ uint16_t servers_len;
/* Private */
uint16_t offset;
} dns_rdata_hip_t;
typedef struct dns_rdata_ipseckey {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- uint8_t precedence;
- uint8_t gateway_type;
- uint8_t algorithm;
- struct in_addr in_addr; /* gateway type 1 */
- struct in6_addr in6_addr; /* gateway type 2 */
- dns_name_t gateway; /* gateway type 3 */
- unsigned char * key;
- uint16_t keylength;
+ isc_mem_t *mctx;
+ uint8_t precedence;
+ uint8_t gateway_type;
+ uint8_t algorithm;
+ struct in_addr in_addr; /* gateway type 1 */
+ struct in6_addr in6_addr; /* gateway type 2 */
+ dns_name_t gateway; /* gateway type 3 */
+ unsigned char *key;
+ uint16_t keylength;
} dns_rdata_ipseckey_t;
#endif /* GENERIC_IPSECKEY_45_H */
typedef struct dns_rdata_isdn {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- char * isdn;
- char * subaddress;
- uint8_t isdn_len;
- uint8_t subaddress_len;
+ isc_mem_t *mctx;
+ char *isdn;
+ char *subaddress;
+ uint8_t isdn_len;
+ uint8_t subaddress_len;
} dns_rdata_isdn_t;
#endif /* GENERIC_ISDN_20_H */
typedef struct dns_rdata_key {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- uint16_t flags;
- dns_secproto_t protocol;
- dns_secalg_t algorithm;
- uint16_t datalen;
- unsigned char * data;
+ isc_mem_t *mctx;
+ uint16_t flags;
+ dns_secproto_t protocol;
+ dns_secalg_t algorithm;
+ uint16_t datalen;
+ unsigned char *data;
} dns_rdata_key_t;
#endif /* GENERIC_KEY_25_H */
typedef struct dns_rdata_keydata {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- uint32_t refresh; /* Timer for refreshing data */
- uint32_t addhd; /* Hold-down timer for adding */
- uint32_t removehd; /* Hold-down timer for removing */
- uint16_t flags; /* Copy of DNSKEY_48 */
- dns_secproto_t protocol;
- dns_secalg_t algorithm;
- uint16_t datalen;
- unsigned char * data;
+ isc_mem_t *mctx;
+ uint32_t refresh; /* Timer for refreshing data */
+ uint32_t addhd; /* Hold-down timer for adding */
+ uint32_t removehd; /* Hold-down timer for removing */
+ uint16_t flags; /* Copy of DNSKEY_48 */
+ dns_secproto_t protocol;
+ dns_secalg_t algorithm;
+ uint16_t datalen;
+ unsigned char *data;
} dns_rdata_keydata_t;
#endif /* GENERIC_KEYDATA_65533_H */
typedef struct dns_rdata_l32 {
dns_rdatacommon_t common;
- uint16_t pref;
- struct in_addr l32;
+ uint16_t pref;
+ struct in_addr l32;
} dns_rdata_l32_t;
#endif /* GENERIC_L32_105_H */
typedef struct dns_rdata_l64 {
dns_rdatacommon_t common;
- uint16_t pref;
- unsigned char l64[8];
+ uint16_t pref;
+ unsigned char l64[8];
} dns_rdata_l64_t;
#endif /* GENERIC_L64_106_H */
* \brief Per RFC1876 */
typedef struct dns_rdata_loc_0 {
- uint8_t version; /* must be first and zero */
- uint8_t size;
- uint8_t horizontal;
- uint8_t vertical;
+ uint8_t version; /* must be first and zero */
+ uint8_t size;
+ uint8_t horizontal;
+ uint8_t vertical;
uint32_t latitude;
uint32_t longitude;
uint32_t altitude;
typedef struct dns_rdata_lp {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- uint16_t pref;
- dns_name_t lp;
+ isc_mem_t *mctx;
+ uint16_t pref;
+ dns_name_t lp;
} dns_rdata_lp_t;
#endif /* GENERIC_LP_107_H */
typedef struct dns_rdata_mb {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- dns_name_t mb;
+ isc_mem_t *mctx;
+ dns_name_t mb;
} dns_rdata_mb_t;
#endif /* GENERIC_MB_7_H */
typedef struct dns_rdata_md {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- dns_name_t md;
+ isc_mem_t *mctx;
+ dns_name_t md;
} dns_rdata_md_t;
#endif /* GENERIC_MD_3_H */
typedef struct dns_rdata_mf {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- dns_name_t mf;
+ isc_mem_t *mctx;
+ dns_name_t mf;
} dns_rdata_mf_t;
#endif /* GENERIC_MF_4_H */
typedef struct dns_rdata_mg {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- dns_name_t mg;
+ isc_mem_t *mctx;
+ dns_name_t mg;
} dns_rdata_mg_t;
#endif /* GENERIC_MG_8_H */
typedef struct dns_rdata_minfo {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- dns_name_t rmailbox;
- dns_name_t emailbox;
+ isc_mem_t *mctx;
+ dns_name_t rmailbox;
+ dns_name_t emailbox;
} dns_rdata_minfo_t;
#endif /* GENERIC_MINFO_14_H */
typedef struct dns_rdata_mr {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- dns_name_t mr;
+ isc_mem_t *mctx;
+ dns_name_t mr;
} dns_rdata_mr_t;
#endif /* GENERIC_MR_9_H */
typedef struct dns_rdata_mx {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- uint16_t pref;
- dns_name_t mx;
+ isc_mem_t *mctx;
+ uint16_t pref;
+ dns_name_t mx;
} dns_rdata_mx_t;
#endif /* GENERIC_MX_15_H */
typedef struct dns_rdata_naptr {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- uint16_t order;
- uint16_t preference;
- char * flags;
- uint8_t flags_len;
- char * service;
- uint8_t service_len;
- char * regexp;
- uint8_t regexp_len;
- dns_name_t replacement;
+ isc_mem_t *mctx;
+ uint16_t order;
+ uint16_t preference;
+ char *flags;
+ uint8_t flags_len;
+ char *service;
+ uint8_t service_len;
+ char *regexp;
+ uint8_t regexp_len;
+ dns_name_t replacement;
} dns_rdata_naptr_t;
#endif /* GENERIC_NAPTR_35_H */
typedef struct dns_rdata_nid {
dns_rdatacommon_t common;
- uint16_t pref;
- unsigned char nid[8];
+ uint16_t pref;
+ unsigned char nid[8];
} dns_rdata_nid_t;
#endif /* GENERIC_NID_104_H */
typedef struct dns_rdata_ns {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- dns_name_t name;
+ isc_mem_t *mctx;
+ dns_name_t name;
} dns_rdata_ns_t;
#endif /* GENERIC_NS_2_H */
typedef struct dns_rdata_nsec3 {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- dns_hash_t hash;
- unsigned char flags;
- dns_iterations_t iterations;
- unsigned char salt_length;
- unsigned char next_length;
- uint16_t len;
- unsigned char * salt;
- unsigned char * next;
- unsigned char * typebits;
+ isc_mem_t *mctx;
+ dns_hash_t hash;
+ unsigned char flags;
+ dns_iterations_t iterations;
+ unsigned char salt_length;
+ unsigned char next_length;
+ uint16_t len;
+ unsigned char *salt;
+ unsigned char *next;
+ unsigned char *typebits;
} dns_rdata_nsec3_t;
/*
typedef struct dns_rdata_nsec3param {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- dns_hash_t hash;
- unsigned char flags; /* DNS_NSEC3FLAG_* */
- dns_iterations_t iterations;
- unsigned char salt_length;
- unsigned char * salt;
+ isc_mem_t *mctx;
+ dns_hash_t hash;
+ unsigned char flags; /* DNS_NSEC3FLAG_* */
+ dns_iterations_t iterations;
+ unsigned char salt_length;
+ unsigned char *salt;
} dns_rdata_nsec3param_t;
#endif /* GENERIC_NSEC3PARAM_51_H */
typedef struct dns_rdata_nsec {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- dns_name_t next;
- unsigned char * typebits;
- uint16_t len;
+ isc_mem_t *mctx;
+ dns_name_t next;
+ unsigned char *typebits;
+ uint16_t len;
} dns_rdata_nsec_t;
#endif /* GENERIC_NSEC_47_H */
typedef struct dns_rdata_null {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- uint16_t length;
- unsigned char * data;
+ isc_mem_t *mctx;
+ uint16_t length;
+ unsigned char *data;
} dns_rdata_null_t;
#endif /* GENERIC_NULL_10_H */
typedef struct dns_rdata_nxt {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- dns_name_t next;
- unsigned char * typebits;
- uint16_t len;
+ isc_mem_t *mctx;
+ dns_name_t next;
+ unsigned char *typebits;
+ uint16_t len;
} dns_rdata_nxt_t;
#endif /* GENERIC_NXT_30_H */
typedef struct dns_rdata_openpgpkey {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- uint16_t length;
- unsigned char * keyring;
+ isc_mem_t *mctx;
+ uint16_t length;
+ unsigned char *keyring;
} dns_rdata_openpgpkey_t;
#endif /* GENERIC_OPENPGPKEY_61_H */
* \brief Per RFC2671 */
typedef struct dns_rdata_opt_opcode {
- uint16_t opcode;
- uint16_t length;
+ uint16_t opcode;
+ uint16_t length;
unsigned char *data;
} dns_rdata_opt_opcode_t;
typedef struct dns_rdata_opt {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- unsigned char * options;
- uint16_t length;
+ isc_mem_t *mctx;
+ unsigned char *options;
+ uint16_t length;
/* private */
uint16_t offset;
} dns_rdata_opt_t;
typedef struct dns_rdata_ #{
dns_rdatacommon_t common;
- isc_mem_t * mctx; /* if required */
- /* type & class specific elements */
+ isc_mem_t *mctx; /* if required */
+ /* type & class specific elements */
}
dns_rdata_ #_t;
typedef struct dns_rdata_ptr {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- dns_name_t ptr;
+ isc_mem_t *mctx;
+ dns_name_t ptr;
} dns_rdata_ptr_t;
#endif /* GENERIC_PTR_12_H */
typedef struct dns_rdata_rp {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- dns_name_t mail;
- dns_name_t text;
+ isc_mem_t *mctx;
+ dns_name_t mail;
+ dns_name_t text;
} dns_rdata_rp_t;
#endif /* GENERIC_RP_17_H */
* \brief Per RFC2535 */
typedef struct dns_rdata_rrsig {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- dns_rdatatype_t covered;
- dns_secalg_t algorithm;
- uint8_t labels;
- uint32_t originalttl;
- uint32_t timeexpire;
- uint32_t timesigned;
- uint16_t keyid;
- dns_name_t signer;
- uint16_t siglen;
- unsigned char * signature;
+ isc_mem_t *mctx;
+ dns_rdatatype_t covered;
+ dns_secalg_t algorithm;
+ uint8_t labels;
+ uint32_t originalttl;
+ uint32_t timeexpire;
+ uint32_t timesigned;
+ uint16_t keyid;
+ dns_name_t signer;
+ uint16_t siglen;
+ unsigned char *signature;
} dns_rdata_rrsig_t;
#endif /* GENERIC_DNSSIG_46_H */
typedef struct dns_rdata_rt {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- uint16_t preference;
- dns_name_t host;
+ isc_mem_t *mctx;
+ uint16_t preference;
+ dns_name_t host;
} dns_rdata_rt_t;
#endif /* GENERIC_RT_21_H */
typedef struct dns_rdata_sig_t {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- dns_rdatatype_t covered;
- dns_secalg_t algorithm;
- uint8_t labels;
- uint32_t originalttl;
- uint32_t timeexpire;
- uint32_t timesigned;
- uint16_t keyid;
- dns_name_t signer;
- uint16_t siglen;
- unsigned char * signature;
+ isc_mem_t *mctx;
+ dns_rdatatype_t covered;
+ dns_secalg_t algorithm;
+ uint8_t labels;
+ uint32_t originalttl;
+ uint32_t timeexpire;
+ uint32_t timesigned;
+ uint16_t keyid;
+ dns_name_t signer;
+ uint16_t siglen;
+ unsigned char *signature;
} dns_rdata_sig_t;
#endif /* GENERIC_SIG_24_H */
typedef struct dns_rdata_sink_t {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- uint8_t meaning;
- uint8_t coding;
- uint8_t subcoding;
- uint16_t datalen;
- unsigned char * data;
+ isc_mem_t *mctx;
+ uint8_t meaning;
+ uint8_t coding;
+ uint8_t subcoding;
+ uint16_t datalen;
+ unsigned char *data;
} dns_rdata_sink_t;
#endif /* GENERIC_SINK_40_H */
typedef struct dns_rdata_soa {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- dns_name_t origin;
- dns_name_t contact;
- uint32_t serial; /*%< host order */
- uint32_t refresh; /*%< host order */
- uint32_t retry; /*%< host order */
- uint32_t expire; /*%< host order */
- uint32_t minimum; /*%< host order */
+ isc_mem_t *mctx;
+ dns_name_t origin;
+ dns_name_t contact;
+ uint32_t serial; /*%< host order */
+ uint32_t refresh; /*%< host order */
+ uint32_t retry; /*%< host order */
+ uint32_t expire; /*%< host order */
+ uint32_t minimum; /*%< host order */
} dns_rdata_soa_t;
#endif /* GENERIC_SOA_6_H */
#define GENERIC_SPF_99_H 1
typedef struct dns_rdata_spf_string {
- uint8_t length;
+ uint8_t length;
unsigned char *data;
} dns_rdata_spf_string_t;
typedef struct dns_rdata_spf {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- unsigned char * txt;
- uint16_t txt_len;
+ isc_mem_t *mctx;
+ unsigned char *txt;
+ uint16_t txt_len;
/* private */
uint16_t offset;
} dns_rdata_spf_t;
typedef struct dns_rdata_sshfp {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- uint8_t algorithm;
- uint8_t digest_type;
- uint16_t length;
- unsigned char * digest;
+ isc_mem_t *mctx;
+ uint8_t algorithm;
+ uint8_t digest_type;
+ uint16_t length;
+ unsigned char *digest;
} dns_rdata_sshfp_t;
#endif /* GENERIC_SSHFP_44_H */
typedef struct dns_rdata_talink {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- dns_name_t prev;
- dns_name_t next;
+ isc_mem_t *mctx;
+ dns_name_t prev;
+ dns_name_t next;
} dns_rdata_talink_t;
#endif /* GENERIC_TALINK_58_H */
typedef struct dns_rdata_tkey {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- dns_name_t algorithm;
- uint32_t inception;
- uint32_t expire;
- uint16_t mode;
- uint16_t error;
- uint16_t keylen;
- unsigned char * key;
- uint16_t otherlen;
- unsigned char * other;
+ isc_mem_t *mctx;
+ dns_name_t algorithm;
+ uint32_t inception;
+ uint32_t expire;
+ uint16_t mode;
+ uint16_t error;
+ uint16_t keylen;
+ unsigned char *key;
+ uint16_t otherlen;
+ unsigned char *other;
} dns_rdata_tkey_t;
#endif /* GENERIC_TKEY_249_H */
*/
typedef struct dns_rdata_tlsa {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- uint8_t usage;
- uint8_t selector;
- uint8_t match;
- uint16_t length;
- unsigned char * data;
+ isc_mem_t *mctx;
+ uint8_t usage;
+ uint8_t selector;
+ uint8_t match;
+ uint16_t length;
+ unsigned char *data;
} dns_rdata_tlsa_t;
#endif /* GENERIC_TLSA_52_H */
#define GENERIC_TXT_16_H 1
typedef struct dns_rdata_txt_string {
- uint8_t length;
+ uint8_t length;
unsigned char *data;
} dns_rdata_txt_string_t;
typedef struct dns_rdata_txt {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- unsigned char * txt;
- uint16_t txt_len;
+ isc_mem_t *mctx;
+ unsigned char *txt;
+ uint16_t txt_len;
/* private */
uint16_t offset;
} dns_rdata_txt_t;
typedef struct dns_rdata_uri {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- uint16_t priority;
- uint16_t weight;
- unsigned char * target;
- uint16_t tgt_len;
+ isc_mem_t *mctx;
+ uint16_t priority;
+ uint16_t weight;
+ unsigned char *target;
+ uint16_t tgt_len;
} dns_rdata_uri_t;
#endif /* GENERIC_URI_256_H */
typedef struct dns_rdata_x25 {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- unsigned char * x25;
- uint8_t x25_len;
+ isc_mem_t *mctx;
+ unsigned char *x25;
+ uint8_t x25_len;
} dns_rdata_x25_t;
#endif /* GENERIC_X25_19_H */
*/
typedef struct dns_rdata_zonemd {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- uint32_t serial;
- uint8_t digest_type;
- uint8_t reserved;
- unsigned char * digest;
- uint16_t length;
+ isc_mem_t *mctx;
+ uint32_t serial;
+ uint8_t digest_type;
+ uint8_t reserved;
+ unsigned char *digest;
+ uint16_t length;
} dns_rdata_zonemd_t;
#endif /* GENERIC_ZONEMD_63_H */
typedef struct dns_rdata_hs_a {
dns_rdatacommon_t common;
- struct in_addr in_addr;
+ struct in_addr in_addr;
} dns_rdata_hs_a_t;
#endif /* HS_4_A_1_H */
typedef struct dns_rdata_in_a6 {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- dns_name_t prefix;
- uint8_t prefixlen;
- struct in6_addr in6_addr;
+ isc_mem_t *mctx;
+ dns_name_t prefix;
+ uint8_t prefixlen;
+ struct in6_addr in6_addr;
} dns_rdata_in_a6_t;
#endif /* IN_1_A6_38_H */
typedef struct dns_rdata_in_a {
dns_rdatacommon_t common;
- struct in_addr in_addr;
+ struct in_addr in_addr;
} dns_rdata_in_a_t;
#endif /* IN_1_A_1_H */
typedef struct dns_rdata_in_aaaa {
dns_rdatacommon_t common;
- struct in6_addr in6_addr;
+ struct in6_addr in6_addr;
} dns_rdata_in_aaaa_t;
#endif /* IN_1_AAAA_28_H */
#define IN_1_APL_42_H 1
typedef struct dns_rdata_apl_ent {
- bool negative;
- uint16_t family;
- uint8_t prefix;
- uint8_t length;
+ bool negative;
+ uint16_t family;
+ uint8_t prefix;
+ uint8_t length;
unsigned char *data;
} dns_rdata_apl_ent_t;
typedef struct dns_rdata_in_apl {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
+ isc_mem_t *mctx;
/* type & class specific elements */
unsigned char *apl;
- uint16_t apl_len;
+ uint16_t apl_len;
/* private */
uint16_t offset;
} dns_rdata_in_apl_t;
typedef struct dns_rdata_in_atma {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- unsigned char format;
- unsigned char * atma;
- uint16_t atma_len;
+ isc_mem_t *mctx;
+ unsigned char format;
+ unsigned char *atma;
+ uint16_t atma_len;
} dns_rdata_in_atma_t;
#endif /* IN_1_ATMA_22_H */
typedef struct dns_rdata_in_dhcid {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- unsigned char * dhcid;
- unsigned int length;
+ isc_mem_t *mctx;
+ unsigned char *dhcid;
+ unsigned int length;
} dns_rdata_in_dhcid_t;
#endif /* IN_1_DHCID_49_H */
typedef struct dns_rdata_in_eid {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- unsigned char * eid;
- uint16_t eid_len;
+ isc_mem_t *mctx;
+ unsigned char *eid;
+ uint16_t eid_len;
} dns_rdata_in_eid_t;
#endif /* IN_1_EID_31_H */
typedef struct dns_rdata_in_kx {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- uint16_t preference;
- dns_name_t exchange;
+ isc_mem_t *mctx;
+ uint16_t preference;
+ dns_name_t exchange;
} dns_rdata_in_kx_t;
#endif /* IN_1_KX_36_H */
typedef struct dns_rdata_in_nimloc {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- unsigned char * nimloc;
- uint16_t nimloc_len;
+ isc_mem_t *mctx;
+ unsigned char *nimloc;
+ uint16_t nimloc_len;
} dns_rdata_in_nimloc_t;
#endif /* IN_1_NIMLOC_32_H */
typedef struct dns_rdata_in_nsap_ptr {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- dns_name_t owner;
+ isc_mem_t *mctx;
+ dns_name_t owner;
} dns_rdata_in_nsap_ptr_t;
#endif /* IN_1_NSAP_PTR_23_H */
typedef struct dns_rdata_in_nsap {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- unsigned char * nsap;
- uint16_t nsap_len;
+ isc_mem_t *mctx;
+ unsigned char *nsap;
+ uint16_t nsap_len;
} dns_rdata_in_nsap_t;
#endif /* IN_1_NSAP_22_H */
typedef struct dns_rdata_in_px {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- uint16_t preference;
- dns_name_t map822;
- dns_name_t mapx400;
+ isc_mem_t *mctx;
+ uint16_t preference;
+ dns_name_t map822;
+ dns_name_t mapx400;
} dns_rdata_in_px_t;
#endif /* IN_1_PX_26_H */
typedef struct dns_rdata_in_srv {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- uint16_t priority;
- uint16_t weight;
- uint16_t port;
- dns_name_t target;
+ isc_mem_t *mctx;
+ uint16_t priority;
+ uint16_t weight;
+ uint16_t port;
+ dns_name_t target;
} dns_rdata_in_srv_t;
#endif /* IN_1_SRV_33_H */
typedef struct dns_rdata_in_wks {
dns_rdatacommon_t common;
- isc_mem_t * mctx;
- struct in_addr in_addr;
- uint16_t protocol;
- unsigned char * map;
- uint16_t map_len;
+ isc_mem_t *mctx;
+ struct in_addr in_addr;
+ uint16_t protocol;
+ unsigned char *map;
+ uint16_t map_len;
} dns_rdata_in_wks_t;
#endif /* IN_1_WKS_11_H */
typedef struct dns_rdatacommon {
dns_rdataclass_t rdclass;
- dns_rdatatype_t rdtype;
+ dns_rdatatype_t rdtype;
ISC_LINK(struct dns_rdatacommon) link;
} dns_rdatacommon_t;
*** Forward
***/
-static void mgr_destroy(dns_requestmgr_t *requestmgr);
-static void mgr_shutdown(dns_requestmgr_t *requestmgr);
-static unsigned int mgr_gethash(dns_requestmgr_t *requestmgr);
-static void send_shutdown_events(dns_requestmgr_t *requestmgr);
-
-static isc_result_t req_render(dns_message_t *message, isc_buffer_t **buffer,
- unsigned int options, isc_mem_t *mctx);
-static void req_senddone(isc_task_t *task, isc_event_t *event);
-static void req_response(isc_task_t *task, isc_event_t *event);
-static void req_timeout(isc_task_t *task, isc_event_t *event);
-static isc_socket_t *req_getsocket(dns_request_t *request);
-static void req_connected(isc_task_t *task, isc_event_t *event);
-static void req_sendevent(dns_request_t *request, isc_result_t result);
-static void req_cancel(dns_request_t *request);
-static void req_destroy(dns_request_t *request);
-static void req_log(int level, const char *fmt, ...) ISC_FORMAT_PRINTF(2, 3);
-static void do_cancel(isc_task_t *task, isc_event_t *event);
+static void
+mgr_destroy(dns_requestmgr_t *requestmgr);
+static void
+mgr_shutdown(dns_requestmgr_t *requestmgr);
+static unsigned int
+mgr_gethash(dns_requestmgr_t *requestmgr);
+static void
+send_shutdown_events(dns_requestmgr_t *requestmgr);
+
+static isc_result_t
+req_render(dns_message_t *message, isc_buffer_t **buffer, unsigned int options,
+ isc_mem_t *mctx);
+static void
+req_senddone(isc_task_t *task, isc_event_t *event);
+static void
+req_response(isc_task_t *task, isc_event_t *event);
+static void
+req_timeout(isc_task_t *task, isc_event_t *event);
+static isc_socket_t *
+req_getsocket(dns_request_t *request);
+static void
+req_connected(isc_task_t *task, isc_event_t *event);
+static void
+req_sendevent(dns_request_t *request, isc_result_t result);
+static void
+req_cancel(dns_request_t *request);
+static void
+req_destroy(dns_request_t *request);
+static void
+req_log(int level, const char *fmt, ...) ISC_FORMAT_PRINTF(2, 3);
+static void
+do_cancel(isc_task_t *task, isc_event_t *event);
/***
*** Public
static const dns_name_t underscore_name =
DNS_NAME_INITNONABSOLUTE(underscore_data, underscore_offsets);
-static void destroy(dns_resolver_t *res);
-static void empty_bucket(dns_resolver_t *res);
-static isc_result_t resquery_send(resquery_t *query);
-static void resquery_response(isc_task_t *task, isc_event_t *event);
-static void resquery_connected(isc_task_t *task, isc_event_t *event);
-static void fctx_try(fetchctx_t *fctx, bool retrying, bool badcache);
-static isc_result_t fctx_minimize_qname(fetchctx_t *fctx);
-static void fctx_destroy(fetchctx_t *fctx);
-static bool fctx_unlink(fetchctx_t *fctx);
+static void
+destroy(dns_resolver_t *res);
+static void
+empty_bucket(dns_resolver_t *res);
+static isc_result_t
+resquery_send(resquery_t *query);
+static void
+resquery_response(isc_task_t *task, isc_event_t *event);
+static void
+resquery_connected(isc_task_t *task, isc_event_t *event);
+static void
+fctx_try(fetchctx_t *fctx, bool retrying, bool badcache);
+static isc_result_t
+fctx_minimize_qname(fetchctx_t *fctx);
+static void
+fctx_destroy(fetchctx_t *fctx);
+static bool
+fctx_unlink(fetchctx_t *fctx);
static isc_result_t
ncache_adderesult(dns_message_t *message, dns_db_t *cache, dns_dbnode_t *node,
dns_rdatatype_t covers, isc_stdtime_t now, dns_ttl_t minttl,
dns_ttl_t maxttl, bool optout, bool secure,
dns_rdataset_t *ardataset, isc_result_t *eresultp);
-static void validated(isc_task_t *task, isc_event_t *event);
-static bool maybe_destroy(fetchctx_t *fctx, bool locked);
-static void add_bad(fetchctx_t *fctx, dns_adbaddrinfo_t *addrinfo,
- isc_result_t reason, badnstype_t badtype);
-static inline isc_result_t findnoqname(fetchctx_t *fctx, dns_name_t *name,
- dns_rdatatype_t type,
- dns_name_t **noqname);
-static void fctx_increference(fetchctx_t *fctx);
-static bool fctx_decreference(fetchctx_t *fctx);
-static void resume_qmin(isc_task_t *task, isc_event_t *event);
+static void
+validated(isc_task_t *task, isc_event_t *event);
+static bool
+maybe_destroy(fetchctx_t *fctx, bool locked);
+static void
+add_bad(fetchctx_t *fctx, dns_adbaddrinfo_t *addrinfo, isc_result_t reason,
+ badnstype_t badtype);
+static inline isc_result_t
+findnoqname(fetchctx_t *fctx, dns_name_t *name, dns_rdatatype_t type,
+ dns_name_t **noqname);
+static void
+fctx_increference(fetchctx_t *fctx);
+static bool
+fctx_decreference(fetchctx_t *fctx);
+static void
+resume_qmin(isc_task_t *task, isc_event_t *event);
/*%
* The structure and functions defined below implement the resolver
dns_rdataset_t *opt; /* OPT rdataset */
} respctx_t;
-static void rctx_respinit(isc_task_t *task, dns_dispatchevent_t *devent,
- resquery_t *query, fetchctx_t *fctx, respctx_t *rctx);
+static void
+rctx_respinit(isc_task_t *task, dns_dispatchevent_t *devent, resquery_t *query,
+ fetchctx_t *fctx, respctx_t *rctx);
-static void rctx_answer_init(respctx_t *rctx);
+static void
+rctx_answer_init(respctx_t *rctx);
-static void rctx_answer_scan(respctx_t *rctx);
+static void
+rctx_answer_scan(respctx_t *rctx);
-static void rctx_authority_positive(respctx_t *rctx);
+static void
+rctx_authority_positive(respctx_t *rctx);
-static isc_result_t rctx_answer_any(respctx_t *rctx);
+static isc_result_t
+rctx_answer_any(respctx_t *rctx);
-static isc_result_t rctx_answer_match(respctx_t *rctx);
+static isc_result_t
+rctx_answer_match(respctx_t *rctx);
-static isc_result_t rctx_answer_cname(respctx_t *rctx);
+static isc_result_t
+rctx_answer_cname(respctx_t *rctx);
-static isc_result_t rctx_answer_dname(respctx_t *rctx);
+static isc_result_t
+rctx_answer_dname(respctx_t *rctx);
-static isc_result_t rctx_answer_positive(respctx_t *rctx);
+static isc_result_t
+rctx_answer_positive(respctx_t *rctx);
-static isc_result_t rctx_authority_negative(respctx_t *rctx);
+static isc_result_t
+rctx_authority_negative(respctx_t *rctx);
-static isc_result_t rctx_authority_dnssec(respctx_t *rctx);
+static isc_result_t
+rctx_authority_dnssec(respctx_t *rctx);
-static void rctx_additional(respctx_t *rctx);
+static void
+rctx_additional(respctx_t *rctx);
-static isc_result_t rctx_referral(respctx_t *rctx);
+static isc_result_t
+rctx_referral(respctx_t *rctx);
-static isc_result_t rctx_answer_none(respctx_t *rctx);
+static isc_result_t
+rctx_answer_none(respctx_t *rctx);
-static void rctx_nextserver(respctx_t *rctx, dns_adbaddrinfo_t *addrinfo,
- isc_result_t result);
+static void
+rctx_nextserver(respctx_t *rctx, dns_adbaddrinfo_t *addrinfo,
+ isc_result_t result);
-static void rctx_resend(respctx_t *rctx, dns_adbaddrinfo_t *addrinfo);
+static void
+rctx_resend(respctx_t *rctx, dns_adbaddrinfo_t *addrinfo);
-static void rctx_next(respctx_t *rctx);
+static void
+rctx_next(respctx_t *rctx);
-static void rctx_chaseds(respctx_t *rctx, dns_adbaddrinfo_t *addrinfo,
- isc_result_t result);
+static void
+rctx_chaseds(respctx_t *rctx, dns_adbaddrinfo_t *addrinfo, isc_result_t result);
-static void rctx_done(respctx_t *rctx, isc_result_t result);
+static void
+rctx_done(respctx_t *rctx, isc_result_t result);
-static void rctx_logpacket(respctx_t *rctx);
+static void
+rctx_logpacket(respctx_t *rctx);
-static void rctx_opt(respctx_t *rctx);
+static void
+rctx_opt(respctx_t *rctx);
-static void rctx_edns(respctx_t *rctx);
+static void
+rctx_edns(respctx_t *rctx);
-static isc_result_t rctx_parse(respctx_t *rctx);
+static isc_result_t
+rctx_parse(respctx_t *rctx);
-static isc_result_t rctx_badserver(respctx_t *rctx, isc_result_t result);
+static isc_result_t
+rctx_badserver(respctx_t *rctx, isc_result_t result);
-static isc_result_t rctx_answer(respctx_t *rctx);
+static isc_result_t
+rctx_answer(respctx_t *rctx);
-static isc_result_t rctx_lameserver(respctx_t *rctx);
+static isc_result_t
+rctx_lameserver(respctx_t *rctx);
-static isc_result_t rctx_dispfail(respctx_t *rctx);
+static isc_result_t
+rctx_dispfail(respctx_t *rctx);
-static void rctx_delonly_zone(respctx_t *rctx);
+static void
+rctx_delonly_zone(respctx_t *rctx);
-static void rctx_ncache(respctx_t *rctx);
+static void
+rctx_ncache(respctx_t *rctx);
/*%
* Increment resolver-related statistics counters.
*/
#define DNS_RPZ_QUANTUM 1024
-static void dns_rpz_update_from_db(dns_rpz_zone_t *rpz);
+static void
+dns_rpz_update_from_db(dns_rpz_zone_t *rpz);
-static void dns_rpz_update_taskaction(isc_task_t *task, isc_event_t *event);
+static void
+dns_rpz_update_taskaction(isc_task_t *task, isc_event_t *event);
/*
* Use a private definition of IPv6 addresses because s6_addr32 is not
dns_rpz_nm_zbits_t wild;
};
-static void rpz_detach(dns_rpz_zone_t **rpzp);
+static void
+rpz_detach(dns_rpz_zone_t **rpzp);
-static void rpz_detach_rpzs(dns_rpz_zones_t **rpzsp);
+static void
+rpz_detach_rpzs(dns_rpz_zones_t **rpzsp);
#if 0
/*
#include <dns/rrl.h>
#include <dns/view.h>
-static void log_end(dns_rrl_t *rrl, dns_rrl_entry_t *e, bool early,
- char *log_buf, unsigned int log_buf_len);
+static void
+log_end(dns_rrl_t *rrl, dns_rrl_entry_t *e, bool early, char *log_buf,
+ unsigned int log_buf_len);
/*
* Get a modulus for a hash function that is tolerably likely to be
static int dummy;
-static isc_result_t dns_sdb_create(isc_mem_t *mctx, const dns_name_t *origin,
- dns_dbtype_t type, dns_rdataclass_t rdclass,
- unsigned int argc, char *argv[],
- void *driverarg, dns_db_t **dbp);
-
-static isc_result_t findrdataset(dns_db_t *db, dns_dbnode_t *node,
- dns_dbversion_t *version, dns_rdatatype_t type,
- dns_rdatatype_t covers, isc_stdtime_t now,
- dns_rdataset_t *rdataset,
- dns_rdataset_t *sigrdataset);
-
-static isc_result_t createnode(dns_sdb_t *sdb, dns_sdbnode_t **nodep);
-
-static void destroynode(dns_sdbnode_t *node);
-
-static void detachnode(dns_db_t *db, dns_dbnode_t **targetp);
-
-static void list_tordataset(dns_rdatalist_t *rdatalist, dns_db_t *db,
- dns_dbnode_t *node, dns_rdataset_t *rdataset);
-
-static void dbiterator_destroy(dns_dbiterator_t **iteratorp);
-static isc_result_t dbiterator_first(dns_dbiterator_t *iterator);
-static isc_result_t dbiterator_last(dns_dbiterator_t *iterator);
-static isc_result_t dbiterator_seek(dns_dbiterator_t *iterator,
- const dns_name_t *name);
-static isc_result_t dbiterator_prev(dns_dbiterator_t *iterator);
-static isc_result_t dbiterator_next(dns_dbiterator_t *iterator);
-static isc_result_t dbiterator_current(dns_dbiterator_t *iterator,
- dns_dbnode_t **nodep, dns_name_t *name);
-static isc_result_t dbiterator_pause(dns_dbiterator_t *iterator);
-static isc_result_t dbiterator_origin(dns_dbiterator_t *iterator,
- dns_name_t *name);
+static isc_result_t
+dns_sdb_create(isc_mem_t *mctx, const dns_name_t *origin, dns_dbtype_t type,
+ dns_rdataclass_t rdclass, unsigned int argc, char *argv[],
+ void *driverarg, dns_db_t **dbp);
+
+static isc_result_t
+findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
+ dns_rdatatype_t type, dns_rdatatype_t covers, isc_stdtime_t now,
+ dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset);
+
+static isc_result_t
+createnode(dns_sdb_t *sdb, dns_sdbnode_t **nodep);
+
+static void
+destroynode(dns_sdbnode_t *node);
+
+static void
+detachnode(dns_db_t *db, dns_dbnode_t **targetp);
+
+static void
+list_tordataset(dns_rdatalist_t *rdatalist, dns_db_t *db, dns_dbnode_t *node,
+ dns_rdataset_t *rdataset);
+
+static void
+dbiterator_destroy(dns_dbiterator_t **iteratorp);
+static isc_result_t
+dbiterator_first(dns_dbiterator_t *iterator);
+static isc_result_t
+dbiterator_last(dns_dbiterator_t *iterator);
+static isc_result_t
+dbiterator_seek(dns_dbiterator_t *iterator, const dns_name_t *name);
+static isc_result_t
+dbiterator_prev(dns_dbiterator_t *iterator);
+static isc_result_t
+dbiterator_next(dns_dbiterator_t *iterator);
+static isc_result_t
+dbiterator_current(dns_dbiterator_t *iterator, dns_dbnode_t **nodep,
+ dns_name_t *name);
+static isc_result_t
+dbiterator_pause(dns_dbiterator_t *iterator);
+static isc_result_t
+dbiterator_origin(dns_dbiterator_t *iterator, dns_name_t *name);
static dns_dbiteratormethods_t dbiterator_methods = {
dbiterator_destroy, dbiterator_first, dbiterator_last,
dbiterator_current, dbiterator_pause, dbiterator_origin
};
-static void rdatasetiter_destroy(dns_rdatasetiter_t **iteratorp);
-static isc_result_t rdatasetiter_first(dns_rdatasetiter_t *iterator);
-static isc_result_t rdatasetiter_next(dns_rdatasetiter_t *iterator);
-static void rdatasetiter_current(dns_rdatasetiter_t *iterator,
- dns_rdataset_t *rdataset);
+static void
+rdatasetiter_destroy(dns_rdatasetiter_t **iteratorp);
+static isc_result_t
+rdatasetiter_first(dns_rdatasetiter_t *iterator);
+static isc_result_t
+rdatasetiter_next(dns_rdatasetiter_t *iterator);
+static void
+rdatasetiter_current(dns_rdatasetiter_t *iterator, dns_rdataset_t *rdataset);
static dns_rdatasetitermethods_t rdatasetiter_methods = {
rdatasetiter_destroy, rdatasetiter_first, rdatasetiter_next,
/*
* Forward references.
*/
-static isc_result_t getnodedata(dns_db_t *db, const dns_name_t *name,
- bool create, unsigned int options,
- dns_clientinfomethods_t *methods,
- dns_clientinfo_t *clientinfo,
- dns_dbnode_t **nodep);
-
-static void list_tordataset(dns_rdatalist_t *rdatalist, dns_db_t *db,
- dns_dbnode_t *node, dns_rdataset_t *rdataset);
-
-static void detachnode(dns_db_t *db, dns_dbnode_t **targetp);
-
-static void dbiterator_destroy(dns_dbiterator_t **iteratorp);
-static isc_result_t dbiterator_first(dns_dbiterator_t *iterator);
-static isc_result_t dbiterator_last(dns_dbiterator_t *iterator);
-static isc_result_t dbiterator_seek(dns_dbiterator_t *iterator,
- const dns_name_t *name);
-static isc_result_t dbiterator_prev(dns_dbiterator_t *iterator);
-static isc_result_t dbiterator_next(dns_dbiterator_t *iterator);
-static isc_result_t dbiterator_current(dns_dbiterator_t *iterator,
- dns_dbnode_t **nodep, dns_name_t *name);
-static isc_result_t dbiterator_pause(dns_dbiterator_t *iterator);
-static isc_result_t dbiterator_origin(dns_dbiterator_t *iterator,
- dns_name_t *name);
+static isc_result_t
+getnodedata(dns_db_t *db, const dns_name_t *name, bool create,
+ unsigned int options, dns_clientinfomethods_t *methods,
+ dns_clientinfo_t *clientinfo, dns_dbnode_t **nodep);
+
+static void
+list_tordataset(dns_rdatalist_t *rdatalist, dns_db_t *db, dns_dbnode_t *node,
+ dns_rdataset_t *rdataset);
+
+static void
+detachnode(dns_db_t *db, dns_dbnode_t **targetp);
+
+static void
+dbiterator_destroy(dns_dbiterator_t **iteratorp);
+static isc_result_t
+dbiterator_first(dns_dbiterator_t *iterator);
+static isc_result_t
+dbiterator_last(dns_dbiterator_t *iterator);
+static isc_result_t
+dbiterator_seek(dns_dbiterator_t *iterator, const dns_name_t *name);
+static isc_result_t
+dbiterator_prev(dns_dbiterator_t *iterator);
+static isc_result_t
+dbiterator_next(dns_dbiterator_t *iterator);
+static isc_result_t
+dbiterator_current(dns_dbiterator_t *iterator, dns_dbnode_t **nodep,
+ dns_name_t *name);
+static isc_result_t
+dbiterator_pause(dns_dbiterator_t *iterator);
+static isc_result_t
+dbiterator_origin(dns_dbiterator_t *iterator, dns_name_t *name);
static dns_dbiteratormethods_t dbiterator_methods = {
dbiterator_destroy, dbiterator_first, dbiterator_last,
#define ASN1_INDEFINITE 0xdce0deed
-static int der_get_length(const unsigned char *p, size_t len, size_t *val,
- size_t *size);
+static int
+der_get_length(const unsigned char *p, size_t len, size_t *val, size_t *size);
-static int der_get_octet_string(const unsigned char *p, size_t len,
- octet_string *data, size_t *size);
-static int der_get_oid(const unsigned char *p, size_t len, oid *data,
- size_t *size);
-static int der_get_tag(const unsigned char *p, size_t len, Der_class *xclass,
- Der_type *type, int *tag, size_t *size);
+static int
+der_get_octet_string(const unsigned char *p, size_t len, octet_string *data,
+ size_t *size);
+static int
+der_get_oid(const unsigned char *p, size_t len, oid *data, size_t *size);
+static int
+der_get_tag(const unsigned char *p, size_t len, Der_class *xclass,
+ Der_type *type, int *tag, size_t *size);
-static int der_match_tag(const unsigned char *p, size_t len, Der_class xclass,
- Der_type type, int tag, size_t *size);
-static int der_match_tag_and_length(const unsigned char *p, size_t len,
- Der_class xclass, Der_type type, int tag,
- size_t *length_ret, size_t *size);
+static int
+der_match_tag(const unsigned char *p, size_t len, Der_class xclass,
+ Der_type type, int tag, size_t *size);
+static int
+der_match_tag_and_length(const unsigned char *p, size_t len, Der_class xclass,
+ Der_type type, int tag, size_t *length_ret,
+ size_t *size);
-static int decode_oid(const unsigned char *p, size_t len, oid *k, size_t *size);
+static int
+decode_oid(const unsigned char *p, size_t len, oid *k, size_t *size);
-static int decode_enumerated(const unsigned char *p, size_t len, void *num,
- size_t *size);
+static int
+decode_enumerated(const unsigned char *p, size_t len, void *num, size_t *size);
-static int decode_octet_string(const unsigned char *, size_t, octet_string *,
- size_t *);
+static int
+decode_octet_string(const unsigned char *, size_t, octet_string *, size_t *);
-static int der_put_int(unsigned char *p, size_t len, int val, size_t *);
+static int
+der_put_int(unsigned char *p, size_t len, int val, size_t *);
-static int der_put_length(unsigned char *p, size_t len, size_t val, size_t *);
+static int
+der_put_length(unsigned char *p, size_t len, size_t val, size_t *);
-static int der_put_octet_string(unsigned char *p, size_t len,
- const octet_string *data, size_t *);
-static int der_put_oid(unsigned char *p, size_t len, const oid *data,
- size_t *size);
-static int der_put_tag(unsigned char *p, size_t len, Der_class xclass,
- Der_type type, int tag, size_t *);
-static int der_put_length_and_tag(unsigned char *, size_t, size_t, Der_class,
- Der_type, int, size_t *);
+static int
+der_put_octet_string(unsigned char *p, size_t len, const octet_string *data,
+ size_t *);
+static int
+der_put_oid(unsigned char *p, size_t len, const oid *data, size_t *size);
+static int
+der_put_tag(unsigned char *p, size_t len, Der_class xclass, Der_type type,
+ int tag, size_t *);
+static int
+der_put_length_and_tag(unsigned char *, size_t, size_t, Der_class, Der_type,
+ int, size_t *);
-static int encode_enumerated(unsigned char *p, size_t len, const void *data,
- size_t *);
+static int
+encode_enumerated(unsigned char *p, size_t len, const void *data, size_t *);
-static int encode_octet_string(unsigned char *p, size_t len,
- const octet_string *k, size_t *);
-static int encode_oid(unsigned char *p, size_t len, const oid *k, size_t *);
+static int
+encode_octet_string(unsigned char *p, size_t len, const octet_string *k,
+ size_t *);
+static int
+encode_oid(unsigned char *p, size_t len, const oid *k, size_t *);
-static void free_octet_string(octet_string *k);
+static void
+free_octet_string(octet_string *k);
-static void free_oid(oid *k);
+static void
+free_oid(oid *k);
-static size_t length_len(size_t len);
+static size_t
+length_len(size_t len);
-static int fix_dce(size_t reallen, size_t *len);
+static int
+fix_dce(size_t reallen, size_t *len);
/*
* Include stuff generated by the ASN.1 compiler.
/* spnegokrb5_locl.h */
-static OM_uint32 gssapi_spnego_encapsulate(OM_uint32 *, unsigned char *, size_t,
- gss_buffer_t, const gss_OID);
+static OM_uint32
+gssapi_spnego_encapsulate(OM_uint32 *, unsigned char *, size_t, gss_buffer_t,
+ const gss_OID);
-static OM_uint32 gssapi_spnego_decapsulate(OM_uint32 *, gss_buffer_t,
- unsigned char **, size_t *,
- const gss_OID);
+static OM_uint32
+gssapi_spnego_decapsulate(OM_uint32 *, gss_buffer_t, unsigned char **, size_t *,
+ const gss_OID);
/* mod_auth_kerb.c */
typedef oid MechType;
-static int encode_MechType(unsigned char *, size_t, const MechType *, size_t *);
-static int decode_MechType(const unsigned char *, size_t, MechType *, size_t *);
-static void free_MechType(MechType *);
+static int
+encode_MechType(unsigned char *, size_t, const MechType *, size_t *);
+static int
+decode_MechType(const unsigned char *, size_t, MechType *, size_t *);
+static void
+free_MechType(MechType *);
/* unused declaration: length_MechType */
/* unused declaration: copy_MechType */
MechType *val;
} MechTypeList;
-static int encode_MechTypeList(unsigned char *, size_t, const MechTypeList *,
- size_t *);
-static int decode_MechTypeList(const unsigned char *, size_t, MechTypeList *,
- size_t *);
-static void free_MechTypeList(MechTypeList *);
+static int
+encode_MechTypeList(unsigned char *, size_t, const MechTypeList *, size_t *);
+static int
+decode_MechTypeList(const unsigned char *, size_t, MechTypeList *, size_t *);
+static void
+free_MechTypeList(MechTypeList *);
/* unused declaration: length_MechTypeList */
/* unused declaration: copy_MechTypeList */
unsigned int integFlag : 1;
} ContextFlags;
-static int encode_ContextFlags(unsigned char *, size_t, const ContextFlags *,
- size_t *);
-static int decode_ContextFlags(const unsigned char *, size_t, ContextFlags *,
- size_t *);
-static void free_ContextFlags(ContextFlags *);
+static int
+encode_ContextFlags(unsigned char *, size_t, const ContextFlags *, size_t *);
+static int
+decode_ContextFlags(const unsigned char *, size_t, ContextFlags *, size_t *);
+static void
+free_ContextFlags(ContextFlags *);
/* unused declaration: length_ContextFlags */
/* unused declaration: copy_ContextFlags */
/* unused declaration: ContextFlags2int */
octet_string *mechListMIC;
} NegTokenInit;
-static int encode_NegTokenInit(unsigned char *, size_t, const NegTokenInit *,
- size_t *);
-static int decode_NegTokenInit(const unsigned char *, size_t, NegTokenInit *,
- size_t *);
-static void free_NegTokenInit(NegTokenInit *);
+static int
+encode_NegTokenInit(unsigned char *, size_t, const NegTokenInit *, size_t *);
+static int
+decode_NegTokenInit(const unsigned char *, size_t, NegTokenInit *, size_t *);
+static void
+free_NegTokenInit(NegTokenInit *);
/* unused declaration: length_NegTokenInit */
/* unused declaration: copy_NegTokenInit */
octet_string *mechListMIC;
} NegTokenResp;
-static int encode_NegTokenResp(unsigned char *, size_t, const NegTokenResp *,
- size_t *);
-static int decode_NegTokenResp(const unsigned char *, size_t, NegTokenResp *,
- size_t *);
-static void free_NegTokenResp(NegTokenResp *);
+static int
+encode_NegTokenResp(unsigned char *, size_t, const NegTokenResp *, size_t *);
+static int
+decode_NegTokenResp(const unsigned char *, size_t, NegTokenResp *, size_t *);
+static void
+free_NegTokenResp(NegTokenResp *);
/* unused declaration: length_NegTokenResp */
/* unused declaration: copy_NegTokenResp */
#define TCPMSG_MAGIC ISC_MAGIC('T', 'C', 'P', 'm')
#define VALID_TCPMSG(foo) ISC_MAGIC_VALID(foo, TCPMSG_MAGIC)
-static void recv_length(isc_task_t *, isc_event_t *);
-static void recv_message(isc_task_t *, isc_event_t *);
+static void
+recv_length(isc_task_t *, isc_event_t *);
+static void
+recv_message(isc_task_t *, isc_event_t *);
static void
recv_length(isc_task_t *task, isc_event_t *ev_in) {
typedef struct {
dns_diffop_t op;
- const char * owner;
- dns_ttl_t ttl;
- const char * type;
- const char * rdata;
+ const char *owner;
+ dns_ttl_t ttl;
+ const char *type;
+ const char *rdata;
} zonechange_t;
#define ZONECHANGE_SENTINEL \
0, NULL, 0, NULL, NULL \
}
-extern isc_mem_t * dt_mctx;
-extern isc_log_t * lctx;
-extern isc_taskmgr_t * taskmgr;
-extern isc_task_t * maintask;
-extern isc_timermgr_t * timermgr;
+extern isc_mem_t *dt_mctx;
+extern isc_log_t *lctx;
+extern isc_taskmgr_t *taskmgr;
+extern isc_task_t *maintask;
+extern isc_timermgr_t *timermgr;
extern isc_socketmgr_t *socketmgr;
-extern dns_zonemgr_t * zonemgr;
-extern bool app_running;
-extern int ncpus;
-extern bool debug_mem_record;
+extern dns_zonemgr_t *zonemgr;
+extern bool app_running;
+extern int ncpus;
+extern bool debug_mem_record;
isc_result_t
dns_test_begin(FILE *logfile, bool create_managers);
static MMDB_s geoip_country, geoip_city, geoip_as, geoip_isp, geoip_domain;
-static void load_geoip(const char *dir);
-static void close_geoip(void);
+static void
+load_geoip(const char *dir);
+static void
+close_geoip(void);
static int
_setup(void **state) {
dns_rdatacallbacks_t callbacks;
char *include_file = NULL;
-static void rawdata_callback(dns_zone_t *zone, dns_masterrawheader_t *header);
+static void
+rawdata_callback(dns_zone_t *zone, dns_masterrawheader_t *header);
static isc_result_t
add_callback(void *arg, const dns_name_t *owner, dns_rdataset_t *dataset) {
goto failure; \
} while (0)
-static void tkey_log(const char *fmt, ...) ISC_FORMAT_PRINTF(1, 2);
+static void
+tkey_log(const char *fmt, ...) ISC_FORMAT_PRINTF(1, 2);
static void
tkey_log(const char *fmt, ...) {
{ &hmacsha384, DST_ALG_HMACSHA384 },
{ &hmacsha512, DST_ALG_HMACSHA512 } };
-static isc_result_t tsig_verify_tcp(isc_buffer_t *source, dns_message_t *msg);
+static isc_result_t
+tsig_verify_tcp(isc_buffer_t *source, dns_message_t *msg);
-static void tsig_log(dns_tsigkey_t *key, int level, const char *fmt, ...)
+static void
+tsig_log(dns_tsigkey_t *key, int level, const char *fmt, ...)
ISC_FORMAT_PRINTF(3, 4);
-static void cleanup_ring(dns_tsig_keyring_t *ring);
-static void tsigkey_free(dns_tsigkey_t *key);
+static void
+cleanup_ring(dns_tsig_keyring_t *ring);
+static void
+tsigkey_free(dns_tsigkey_t *key);
bool
dns__tsig_algvalid(unsigned int alg) {
return ((_r)); \
} while (0)
-static isc_result_t bind_ttl(isc_textregion_t *source, uint32_t *ttl);
+static isc_result_t
+bind_ttl(isc_textregion_t *source, uint32_t *ttl);
/*
* Helper for dns_ttl_totext().
/**************************************************************************/
-static void update_log(dns_update_log_t *callback, dns_zone_t *zone, int level,
- const char *fmt, ...) ISC_FORMAT_PRINTF(4, 5);
+static void
+update_log(dns_update_log_t *callback, dns_zone_t *zone, int level,
+ const char *fmt, ...) ISC_FORMAT_PRINTF(4, 5);
static void
update_log(dns_update_log_t *callback, dns_zone_t *zone, int level,
/*%
* Function type for foreach_rrset() iterator actions.
*/
-typedef isc_result_t rrset_func(void *data, dns_rdataset_t *rrset);
+typedef isc_result_t
+rrset_func(void *data, dns_rdataset_t *rrset);
/*%
* Function type for foreach_rr() iterator actions.
*/
-typedef isc_result_t rr_func(void *data, rr_t *rr);
+typedef isc_result_t
+rr_func(void *data, rr_t *rr);
/*%
* Internal context struct for foreach_node_rr().
* Function type for predicate functions that compare a database RR 'db_rr'
* against an update RR 'update_rr'.
*/
-typedef bool rr_predicate(dns_rdata_t *update_rr, dns_rdata_t *db_rr);
+typedef bool
+rr_predicate(dns_rdata_t *update_rr, dns_rdata_t *db_rr);
/*%
* Helper function for rrset_exists().
#define NEGATIVE(r) (((r)->attributes & DNS_RDATASETATTR_NEGATIVE) != 0)
#define NXDOMAIN(r) (((r)->attributes & DNS_RDATASETATTR_NXDOMAIN) != 0)
-static void destroy(dns_validator_t *val);
+static void
+destroy(dns_validator_t *val);
-static isc_result_t select_signing_key(dns_validator_t *val,
- dns_rdataset_t *rdataset);
+static isc_result_t
+select_signing_key(dns_validator_t *val, dns_rdataset_t *rdataset);
-static isc_result_t validate_answer(dns_validator_t *val, bool resume);
+static isc_result_t
+validate_answer(dns_validator_t *val, bool resume);
-static isc_result_t validate_dnskey(dns_validator_t *val);
+static isc_result_t
+validate_dnskey(dns_validator_t *val);
-static isc_result_t validate_nx(dns_validator_t *val, bool resume);
+static isc_result_t
+validate_nx(dns_validator_t *val, bool resume);
-static isc_result_t proveunsecure(dns_validator_t *val, bool have_ds,
- bool resume);
+static isc_result_t
+proveunsecure(dns_validator_t *val, bool have_ds, bool resume);
-static void validator_logv(dns_validator_t *val, isc_logcategory_t *category,
- isc_logmodule_t *module, int level, const char *fmt,
- va_list ap) ISC_FORMAT_PRINTF(5, 0);
+static void
+validator_logv(dns_validator_t *val, isc_logcategory_t *category,
+ isc_logmodule_t *module, int level, const char *fmt, va_list ap)
+ ISC_FORMAT_PRINTF(5, 0);
-static void validator_log(void *val, int level, const char *fmt, ...)
+static void
+validator_log(void *val, int level, const char *fmt, ...)
ISC_FORMAT_PRINTF(3, 4);
-static void validator_logcreate(dns_validator_t *val, dns_name_t *name,
- dns_rdatatype_t type, const char *caller,
- const char *operation);
+static void
+validator_logcreate(dns_validator_t *val, dns_name_t *name,
+ dns_rdatatype_t type, const char *caller,
+ const char *operation);
/*%
* Ensure the validator's rdatasets are marked as expired.
#define DNS_VIEW_DELONLYHASH 111
#define DNS_VIEW_FAILCACHESIZE 1021
-static void resolver_shutdown(isc_task_t *task, isc_event_t *event);
-static void adb_shutdown(isc_task_t *task, isc_event_t *event);
-static void req_shutdown(isc_task_t *task, isc_event_t *event);
+static void
+resolver_shutdown(isc_task_t *task, isc_event_t *event);
+static void
+adb_shutdown(isc_task_t *task, isc_event_t *event);
+static void
+req_shutdown(isc_task_t *task, isc_event_t *event);
isc_result_t
dns_view_create(isc_mem_t *mctx, dns_rdataclass_t rdclass, const char *name,
const isc_sockaddr_t *sourceaddr, isc_dscp_t dscp,
dns_tsigkey_t *tsigkey, dns_xfrin_ctx_t **xfrp);
-static isc_result_t axfr_init(dns_xfrin_ctx_t *xfr);
-static isc_result_t axfr_makedb(dns_xfrin_ctx_t *xfr, dns_db_t **dbp);
-static isc_result_t axfr_putdata(dns_xfrin_ctx_t *xfr, dns_diffop_t op,
- dns_name_t *name, dns_ttl_t ttl,
- dns_rdata_t *rdata);
-static isc_result_t axfr_apply(dns_xfrin_ctx_t *xfr);
-static isc_result_t axfr_commit(dns_xfrin_ctx_t *xfr);
-static isc_result_t axfr_finalize(dns_xfrin_ctx_t *xfr);
-
-static isc_result_t ixfr_init(dns_xfrin_ctx_t *xfr);
-static isc_result_t ixfr_apply(dns_xfrin_ctx_t *xfr);
-static isc_result_t ixfr_putdata(dns_xfrin_ctx_t *xfr, dns_diffop_t op,
- dns_name_t *name, dns_ttl_t ttl,
- dns_rdata_t *rdata);
-static isc_result_t ixfr_commit(dns_xfrin_ctx_t *xfr);
-
-static isc_result_t xfr_rr(dns_xfrin_ctx_t *xfr, dns_name_t *name, uint32_t ttl,
- dns_rdata_t *rdata);
-
-static isc_result_t xfrin_start(dns_xfrin_ctx_t *xfr);
-
-static void xfrin_connect_done(isc_task_t *task, isc_event_t *event);
-static isc_result_t xfrin_send_request(dns_xfrin_ctx_t *xfr);
-static void xfrin_send_done(isc_task_t *task, isc_event_t *event);
-static void xfrin_recv_done(isc_task_t *task, isc_event_t *event);
-static void xfrin_timeout(isc_task_t *task, isc_event_t *event);
-
-static void maybe_free(dns_xfrin_ctx_t *xfr);
-
-static void xfrin_fail(dns_xfrin_ctx_t *xfr, isc_result_t result,
- const char *msg);
-static isc_result_t render(dns_message_t *msg, isc_mem_t *mctx,
- isc_buffer_t *buf);
-
-static void xfrin_logv(int level, const char *zonetext,
- const isc_sockaddr_t *masteraddr, const char *fmt,
- va_list ap) ISC_FORMAT_PRINTF(4, 0);
-
-static void xfrin_log1(int level, const char *zonetext,
- const isc_sockaddr_t *masteraddr, const char *fmt, ...)
- ISC_FORMAT_PRINTF(4, 5);
-
-static void xfrin_log(dns_xfrin_ctx_t *xfr, int level, const char *fmt, ...)
+static isc_result_t
+axfr_init(dns_xfrin_ctx_t *xfr);
+static isc_result_t
+axfr_makedb(dns_xfrin_ctx_t *xfr, dns_db_t **dbp);
+static isc_result_t
+axfr_putdata(dns_xfrin_ctx_t *xfr, dns_diffop_t op, dns_name_t *name,
+ dns_ttl_t ttl, dns_rdata_t *rdata);
+static isc_result_t
+axfr_apply(dns_xfrin_ctx_t *xfr);
+static isc_result_t
+axfr_commit(dns_xfrin_ctx_t *xfr);
+static isc_result_t
+axfr_finalize(dns_xfrin_ctx_t *xfr);
+
+static isc_result_t
+ixfr_init(dns_xfrin_ctx_t *xfr);
+static isc_result_t
+ixfr_apply(dns_xfrin_ctx_t *xfr);
+static isc_result_t
+ixfr_putdata(dns_xfrin_ctx_t *xfr, dns_diffop_t op, dns_name_t *name,
+ dns_ttl_t ttl, dns_rdata_t *rdata);
+static isc_result_t
+ixfr_commit(dns_xfrin_ctx_t *xfr);
+
+static isc_result_t
+xfr_rr(dns_xfrin_ctx_t *xfr, dns_name_t *name, uint32_t ttl,
+ dns_rdata_t *rdata);
+
+static isc_result_t
+xfrin_start(dns_xfrin_ctx_t *xfr);
+
+static void
+xfrin_connect_done(isc_task_t *task, isc_event_t *event);
+static isc_result_t
+xfrin_send_request(dns_xfrin_ctx_t *xfr);
+static void
+xfrin_send_done(isc_task_t *task, isc_event_t *event);
+static void
+xfrin_recv_done(isc_task_t *task, isc_event_t *event);
+static void
+xfrin_timeout(isc_task_t *task, isc_event_t *event);
+
+static void
+maybe_free(dns_xfrin_ctx_t *xfr);
+
+static void
+xfrin_fail(dns_xfrin_ctx_t *xfr, isc_result_t result, const char *msg);
+static isc_result_t
+render(dns_message_t *msg, isc_mem_t *mctx, isc_buffer_t *buf);
+
+static void
+xfrin_logv(int level, const char *zonetext, const isc_sockaddr_t *masteraddr,
+ const char *fmt, va_list ap) ISC_FORMAT_PRINTF(4, 0);
+
+static void
+xfrin_log1(int level, const char *zonetext, const isc_sockaddr_t *masteraddr,
+ const char *fmt, ...) ISC_FORMAT_PRINTF(4, 5);
+
+static void
+xfrin_log(dns_xfrin_ctx_t *xfr, int level, const char *fmt, ...)
ISC_FORMAT_PRINTF(3, 4);
/**************************************************************************/
#define SEND_BUFFER_SIZE 2048
-static void zone_settimer(dns_zone_t *, isc_time_t *);
-static void cancel_refresh(dns_zone_t *);
-static void zone_debuglog(dns_zone_t *zone, const char *, int debuglevel,
- const char *msg, ...) ISC_FORMAT_PRINTF(4, 5);
-static void notify_log(dns_zone_t *zone, int level, const char *fmt, ...)
+static void
+zone_settimer(dns_zone_t *, isc_time_t *);
+static void
+cancel_refresh(dns_zone_t *);
+static void
+zone_debuglog(dns_zone_t *zone, const char *, int debuglevel, const char *msg,
+ ...) ISC_FORMAT_PRINTF(4, 5);
+static void
+notify_log(dns_zone_t *zone, int level, const char *fmt, ...)
ISC_FORMAT_PRINTF(3, 4);
-static void dnssec_log(dns_zone_t *zone, int level, const char *fmt, ...)
+static void
+dnssec_log(dns_zone_t *zone, int level, const char *fmt, ...)
ISC_FORMAT_PRINTF(3, 4);
-static void queue_xfrin(dns_zone_t *zone);
-static isc_result_t update_one_rr(dns_db_t *db, dns_dbversion_t *ver,
- dns_diff_t *diff, dns_diffop_t op,
- dns_name_t *name, dns_ttl_t ttl,
- dns_rdata_t *rdata);
-static void zone_unload(dns_zone_t *zone);
-static void zone_expire(dns_zone_t *zone);
-static void zone_iattach(dns_zone_t *source, dns_zone_t **target);
-static void zone_idetach(dns_zone_t **zonep);
-static isc_result_t zone_replacedb(dns_zone_t *zone, dns_db_t *db, bool dump);
-static inline void zone_attachdb(dns_zone_t *zone, dns_db_t *db);
-static inline void zone_detachdb(dns_zone_t *zone);
-static isc_result_t default_journal(dns_zone_t *zone);
-static void zone_xfrdone(dns_zone_t *zone, isc_result_t result);
-static isc_result_t zone_postload(dns_zone_t *zone, dns_db_t *db,
- isc_time_t loadtime, isc_result_t result);
-static void zone_needdump(dns_zone_t *zone, unsigned int delay);
-static void zone_shutdown(isc_task_t *, isc_event_t *);
-static void zone_loaddone(void *arg, isc_result_t result);
-static isc_result_t zone_startload(dns_db_t *db, dns_zone_t *zone,
- isc_time_t loadtime);
-static void zone_namerd_tostr(dns_zone_t *zone, char *buf, size_t length);
-static void zone_name_tostr(dns_zone_t *zone, char *buf, size_t length);
-static void zone_rdclass_tostr(dns_zone_t *zone, char *buf, size_t length);
-static void zone_viewname_tostr(dns_zone_t *zone, char *buf, size_t length);
-static isc_result_t zone_send_secureserial(dns_zone_t *zone, uint32_t serial);
-static void refresh_callback(isc_task_t *, isc_event_t *);
-static void stub_callback(isc_task_t *, isc_event_t *);
-static void queue_soa_query(dns_zone_t *zone);
-static void soa_query(isc_task_t *, isc_event_t *);
-static void ns_query(dns_zone_t *zone, dns_rdataset_t *soardataset,
- dns_stub_t *stub);
-static int message_count(dns_message_t *msg, dns_section_t section,
- dns_rdatatype_t type);
-static void notify_cancel(dns_zone_t *zone);
-static void notify_find_address(dns_notify_t *notify);
-static void notify_send(dns_notify_t *notify);
-static isc_result_t notify_createmessage(dns_zone_t *zone, unsigned int flags,
- dns_message_t **messagep);
-static void notify_done(isc_task_t *task, isc_event_t *event);
-static void notify_send_toaddr(isc_task_t *task, isc_event_t *event);
-static isc_result_t zone_dump(dns_zone_t *, bool);
-static void got_transfer_quota(isc_task_t *task, isc_event_t *event);
-static isc_result_t zmgr_start_xfrin_ifquota(dns_zonemgr_t *zmgr,
- dns_zone_t *zone);
-static void zmgr_resume_xfrs(dns_zonemgr_t *zmgr, bool multi);
-static void zonemgr_free(dns_zonemgr_t *zmgr);
-static isc_result_t zonemgr_getio(dns_zonemgr_t *zmgr, bool high,
- isc_task_t *task, isc_taskaction_t action,
- void *arg, dns_io_t **iop);
-static void zonemgr_putio(dns_io_t **iop);
-static void zonemgr_cancelio(dns_io_t *io);
-static void rss_post(dns_zone_t *, isc_event_t *);
-
-static isc_result_t zone_get_from_db(dns_zone_t *zone, dns_db_t *db,
- unsigned int *nscount,
- unsigned int *soacount, uint32_t *serial,
- uint32_t *refresh, uint32_t *retry,
- uint32_t *expire, uint32_t *minimum,
- unsigned int *errors);
-
-static void zone_freedbargs(dns_zone_t *zone);
-static void forward_callback(isc_task_t *task, isc_event_t *event);
-static void zone_saveunique(dns_zone_t *zone, const char *path,
- const char *templat);
-static void zone_maintenance(dns_zone_t *zone);
-static void zone_notify(dns_zone_t *zone, isc_time_t *now);
-static void dump_done(void *arg, isc_result_t result);
-static isc_result_t zone_signwithkey(dns_zone_t *zone, dns_secalg_t algorithm,
- uint16_t keyid, bool deleteit);
-static isc_result_t delete_nsec(dns_db_t *db, dns_dbversion_t *ver,
- dns_dbnode_t *node, dns_name_t *name,
- dns_diff_t *diff);
-static void zone_rekey(dns_zone_t *zone);
-static isc_result_t zone_send_securedb(dns_zone_t *zone, dns_db_t *db);
-static void setrl(isc_ratelimiter_t *rl, unsigned int *rate,
- unsigned int value);
+static void
+queue_xfrin(dns_zone_t *zone);
+static isc_result_t
+update_one_rr(dns_db_t *db, dns_dbversion_t *ver, dns_diff_t *diff,
+ dns_diffop_t op, dns_name_t *name, dns_ttl_t ttl,
+ dns_rdata_t *rdata);
+static void
+zone_unload(dns_zone_t *zone);
+static void
+zone_expire(dns_zone_t *zone);
+static void
+zone_iattach(dns_zone_t *source, dns_zone_t **target);
+static void
+zone_idetach(dns_zone_t **zonep);
+static isc_result_t
+zone_replacedb(dns_zone_t *zone, dns_db_t *db, bool dump);
+static inline void
+zone_attachdb(dns_zone_t *zone, dns_db_t *db);
+static inline void
+zone_detachdb(dns_zone_t *zone);
+static isc_result_t
+default_journal(dns_zone_t *zone);
+static void
+zone_xfrdone(dns_zone_t *zone, isc_result_t result);
+static isc_result_t
+zone_postload(dns_zone_t *zone, dns_db_t *db, isc_time_t loadtime,
+ isc_result_t result);
+static void
+zone_needdump(dns_zone_t *zone, unsigned int delay);
+static void
+zone_shutdown(isc_task_t *, isc_event_t *);
+static void
+zone_loaddone(void *arg, isc_result_t result);
+static isc_result_t
+zone_startload(dns_db_t *db, dns_zone_t *zone, isc_time_t loadtime);
+static void
+zone_namerd_tostr(dns_zone_t *zone, char *buf, size_t length);
+static void
+zone_name_tostr(dns_zone_t *zone, char *buf, size_t length);
+static void
+zone_rdclass_tostr(dns_zone_t *zone, char *buf, size_t length);
+static void
+zone_viewname_tostr(dns_zone_t *zone, char *buf, size_t length);
+static isc_result_t
+zone_send_secureserial(dns_zone_t *zone, uint32_t serial);
+static void
+refresh_callback(isc_task_t *, isc_event_t *);
+static void
+stub_callback(isc_task_t *, isc_event_t *);
+static void
+queue_soa_query(dns_zone_t *zone);
+static void
+soa_query(isc_task_t *, isc_event_t *);
+static void
+ns_query(dns_zone_t *zone, dns_rdataset_t *soardataset, dns_stub_t *stub);
+static int
+message_count(dns_message_t *msg, dns_section_t section, dns_rdatatype_t type);
+static void
+notify_cancel(dns_zone_t *zone);
+static void
+notify_find_address(dns_notify_t *notify);
+static void
+notify_send(dns_notify_t *notify);
+static isc_result_t
+notify_createmessage(dns_zone_t *zone, unsigned int flags,
+ dns_message_t **messagep);
+static void
+notify_done(isc_task_t *task, isc_event_t *event);
+static void
+notify_send_toaddr(isc_task_t *task, isc_event_t *event);
+static isc_result_t
+zone_dump(dns_zone_t *, bool);
+static void
+got_transfer_quota(isc_task_t *task, isc_event_t *event);
+static isc_result_t
+zmgr_start_xfrin_ifquota(dns_zonemgr_t *zmgr, dns_zone_t *zone);
+static void
+zmgr_resume_xfrs(dns_zonemgr_t *zmgr, bool multi);
+static void
+zonemgr_free(dns_zonemgr_t *zmgr);
+static isc_result_t
+zonemgr_getio(dns_zonemgr_t *zmgr, bool high, isc_task_t *task,
+ isc_taskaction_t action, void *arg, dns_io_t **iop);
+static void
+zonemgr_putio(dns_io_t **iop);
+static void
+zonemgr_cancelio(dns_io_t *io);
+static void
+rss_post(dns_zone_t *, isc_event_t *);
+
+static isc_result_t
+zone_get_from_db(dns_zone_t *zone, dns_db_t *db, unsigned int *nscount,
+ unsigned int *soacount, uint32_t *serial, uint32_t *refresh,
+ uint32_t *retry, uint32_t *expire, uint32_t *minimum,
+ unsigned int *errors);
+
+static void
+zone_freedbargs(dns_zone_t *zone);
+static void
+forward_callback(isc_task_t *task, isc_event_t *event);
+static void
+zone_saveunique(dns_zone_t *zone, const char *path, const char *templat);
+static void
+zone_maintenance(dns_zone_t *zone);
+static void
+zone_notify(dns_zone_t *zone, isc_time_t *now);
+static void
+dump_done(void *arg, isc_result_t result);
+static isc_result_t
+zone_signwithkey(dns_zone_t *zone, dns_secalg_t algorithm, uint16_t keyid,
+ bool deleteit);
+static isc_result_t
+delete_nsec(dns_db_t *db, dns_dbversion_t *ver, dns_dbnode_t *node,
+ dns_name_t *name, dns_diff_t *diff);
+static void
+zone_rekey(dns_zone_t *zone);
+static isc_result_t
+zone_send_securedb(dns_zone_t *zone, dns_db_t *db);
+static void
+setrl(isc_ratelimiter_t *rl, unsigned int *rate, unsigned int value);
#define ENTER zone_debuglog(zone, me, 1, "enter")
typedef struct {
dns_diff_t *diff;
- bool offline;
+ bool offline;
} dns__zonediff_t;
isc_result_t
#define ZTMAGIC ISC_MAGIC('Z', 'T', 'b', 'l')
#define VALID_ZT(zt) ISC_MAGIC_VALID(zt, ZTMAGIC)
-static void auto_detach(void *, void *);
+static void
+auto_detach(void *, void *);
-static isc_result_t load(dns_zone_t *zone, void *uap);
+static isc_result_t
+load(dns_zone_t *zone, void *uap);
-static isc_result_t asyncload(dns_zone_t *zone, void *callback);
+static isc_result_t
+asyncload(dns_zone_t *zone, void *callback);
-static isc_result_t freezezones(dns_zone_t *zone, void *uap);
+static isc_result_t
+freezezones(dns_zone_t *zone, void *uap);
-static isc_result_t doneloading(dns_zt_t *zt, dns_zone_t *zone,
- isc_task_t *task);
+static isc_result_t
+doneloading(dns_zt_t *zt, dns_zone_t *zone, isc_task_t *task);
isc_result_t
dns_zt_create(isc_mem_t *mctx, dns_rdataclass_t rdclass, dns_zt_t **ztp) {
/*! \struct addrinfo
*/
-static struct addrinfo *ai_concat(struct addrinfo *ai1, struct addrinfo *ai2),
+static struct addrinfo *
+ai_concat(struct addrinfo *ai1, struct addrinfo *ai2),
*ai_reverse(struct addrinfo *oai),
*ai_clone(struct addrinfo *oai, int family),
*ai_alloc(int family, int addrlen);
#ifdef AF_LOCAL
-static int get_local(const char *name, int socktype, struct addrinfo **res);
+static int
+get_local(const char *name, int socktype, struct addrinfo **res);
#endif /* ifdef AF_LOCAL */
-static int resolve_name(int family, const char *hostname, int flags,
- struct addrinfo **aip, int socktype, int port);
+static int
+resolve_name(int family, const char *hostname, int flags, struct addrinfo **aip,
+ int socktype, int port);
-static int add_ipv4(const char *hostname, int flags, struct addrinfo **aip,
- int socktype, int port);
-static int add_ipv6(const char *hostname, int flags, struct addrinfo **aip,
- int socktype, int port);
-static void set_order(int, int (**)(const char *, int, struct addrinfo **, int,
- int));
-static void _freeaddrinfo(struct addrinfo *ai);
+static int
+add_ipv4(const char *hostname, int flags, struct addrinfo **aip, int socktype,
+ int port);
+static int
+add_ipv6(const char *hostname, int flags, struct addrinfo **aip, int socktype,
+ int port);
+static void
+set_order(int, int (**)(const char *, int, struct addrinfo **, int, int));
+static void
+_freeaddrinfo(struct addrinfo *ai);
#define FOUND_IPV4 0x1
#define FOUND_IPV6 0x2
uint8_t ndots;
};
-static isc_result_t resconf_parsenameserver(irs_resconf_t *conf, FILE *fp);
-static isc_result_t resconf_parsedomain(irs_resconf_t *conf, FILE *fp);
-static isc_result_t resconf_parsesearch(irs_resconf_t *conf, FILE *fp);
-static isc_result_t resconf_parsesortlist(irs_resconf_t *conf, FILE *fp);
-static isc_result_t resconf_parseoption(irs_resconf_t *ctx, FILE *fp);
+static isc_result_t
+resconf_parsenameserver(irs_resconf_t *conf, FILE *fp);
+static isc_result_t
+resconf_parsedomain(irs_resconf_t *conf, FILE *fp);
+static isc_result_t
+resconf_parsesearch(irs_resconf_t *conf, FILE *fp);
+static isc_result_t
+resconf_parsesortlist(irs_resconf_t *conf, FILE *fp);
+static isc_result_t
+resconf_parseoption(irs_resconf_t *ctx, FILE *fp);
#if HAVE_GET_WIN32_NAMESERVERS
-static isc_result_t get_win32_nameservers(irs_resconf_t *conf);
+static isc_result_t
+get_win32_nameservers(irs_resconf_t *conf);
#endif /* if HAVE_GET_WIN32_NAMESERVERS */
/*!
#ifdef ISC_IRS_NEEDADDRINFO
struct addrinfo {
- int ai_flags; /* AI_PASSIVE, AI_CANONNAME */
- int ai_family; /* PF_xxx */
- int ai_socktype; /* SOCK_xxx */
- int ai_protocol; /* 0 or IPPROTO_xxx for IPv4 and
- * IPv6 */
- size_t ai_addrlen; /* Length of ai_addr */
- char * ai_canonname; /* Canonical name for hostname */
- struct sockaddr *ai_addr; /* Binary address */
- struct addrinfo *ai_next; /* Next structure in linked list */
+ int ai_flags; /* AI_PASSIVE, AI_CANONNAME */
+ int ai_family; /* PF_xxx */
+ int ai_socktype; /* SOCK_xxx */
+ int ai_protocol; /* 0 or IPPROTO_xxx for IPv4 and
+ * IPv6 */
+ size_t ai_addrlen; /* Length of ai_addr */
+ char *ai_canonname; /* Canonical name for hostname */
+ struct sockaddr *ai_addr; /* Binary address */
+ struct addrinfo *ai_next; /* Next structure in linked list */
};
#endif /* ifdef ISC_IRS_NEEDADDRINFO */
/*%
* Forward.
*/
-static void default_callback(const char *, int, isc_assertiontype_t,
- const char *);
+static void
+default_callback(const char *, int, isc_assertiontype_t, const char *);
static isc_assertioncallback_t isc_assertion_failed_cb = default_callback;
return (ISC_R_SUCCESS);
}
#elif defined(BACKTRACE_GCC)
-extern int _Unwind_Backtrace(void *fn, void *a);
-extern void *_Unwind_GetIP(void *ctx);
+extern int
+_Unwind_Backtrace(void *fn, void *a);
+extern void *
+_Unwind_GetIP(void *ctx);
typedef struct {
void **result;
* These static functions are also present in lib/dns/rdata.c. I'm not
* sure where they should go. -- bwelling
*/
-static isc_result_t str_totext(const char *source, isc_buffer_t *target);
+static isc_result_t
+str_totext(const char *source, isc_buffer_t *target);
-static isc_result_t mem_tobuffer(isc_buffer_t *target, void *base,
- unsigned int length);
+static isc_result_t
+mem_tobuffer(isc_buffer_t *target, void *base, unsigned int length);
/*@}*/
* These static functions are also present in lib/dns/rdata.c. I'm not
* sure where they should go. -- bwelling
*/
-static isc_result_t str_totext(const char *source, isc_buffer_t *target);
+static isc_result_t
+str_totext(const char *source, isc_buffer_t *target);
-static isc_result_t mem_tobuffer(isc_buffer_t *target, void *base,
- unsigned int length);
+static isc_result_t
+mem_tobuffer(isc_buffer_t *target, void *base, unsigned int length);
static const char base64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvw"
"xyz0123456789+/=";
#include <isc/print.h>
/*% Default unexpected callback. */
-static void default_unexpected_callback(const char *, int, const char *,
- va_list) ISC_FORMAT_PRINTF(3, 0);
+static void
+default_unexpected_callback(const char *, int, const char *, va_list)
+ ISC_FORMAT_PRINTF(3, 0);
/*% Default fatal callback. */
-static void default_fatal_callback(const char *, int, const char *, va_list)
+static void
+default_fatal_callback(const char *, int, const char *, va_list)
ISC_FORMAT_PRINTF(3, 0);
/*% unexpected_callback */
/*
* BEW: These static functions are copied from lib/dns/rdata.c.
*/
-static isc_result_t str_totext(const char *source, isc_buffer_t *target);
+static isc_result_t
+str_totext(const char *source, isc_buffer_t *target);
-static isc_result_t mem_tobuffer(isc_buffer_t *target, void *base,
- unsigned int length);
+static isc_result_t
+mem_tobuffer(isc_buffer_t *target, void *base, unsigned int length);
static const char hex[] = "0123456789ABCDEF";
#define ISC_HTTPD_SETSEND(c) ((c)->state = ISC_HTTPD_STATESEND)
#define ISC_HTTPD_SETSENDDONE(c) ((c)->state = ISC_HTTPD_STATESENDDONE)
-static void isc_httpd_accept(isc_task_t *, isc_event_t *);
-static void isc_httpd_recvdone(isc_task_t *, isc_event_t *);
-static void isc_httpd_senddone(isc_task_t *, isc_event_t *);
-static isc_result_t process_request(isc_httpd_t *, int);
-static isc_result_t grow_headerspace(isc_httpd_t *);
-static void reset_client(isc_httpd_t *httpd);
+static void
+isc_httpd_accept(isc_task_t *, isc_event_t *);
+static void
+isc_httpd_recvdone(isc_task_t *, isc_event_t *);
+static void
+isc_httpd_senddone(isc_task_t *, isc_event_t *);
+static isc_result_t
+process_request(isc_httpd_t *, int);
+static isc_result_t
+grow_headerspace(isc_httpd_t *);
+static void
+reset_client(isc_httpd_t *httpd);
static isc_httpdaction_t render_404;
static isc_httpdaction_t render_500;
static void (*finishhook)(void) = NULL;
#endif /* ENABLE_AFL */
-static void maybe_destroy_httpd(isc_httpd_t *);
-static void destroy_httpd(isc_httpd_t *);
-static void maybe_destroy_httpdmgr(isc_httpdmgr_t *);
-static void destroy_httpdmgr(isc_httpdmgr_t *);
+static void
+maybe_destroy_httpd(isc_httpd_t *);
+static void
+destroy_httpd(isc_httpd_t *);
+static void
+maybe_destroy_httpdmgr(isc_httpdmgr_t *);
+static void
+destroy_httpdmgr(isc_httpdmgr_t *);
-static void isc_httpdmgr_attach(isc_httpdmgr_t *, isc_httpdmgr_t **);
-static void isc_httpdmgr_detach(isc_httpdmgr_t **);
+static void
+isc_httpdmgr_attach(isc_httpdmgr_t *, isc_httpdmgr_t **);
+static void
+isc_httpdmgr_detach(isc_httpdmgr_t **);
static void
maybe_destroy_httpd(isc_httpd_t *httpd) {
/*!
* Forward declarations.
*/
-static isc_result_t assignchannel(isc_logconfig_t *lcfg,
- unsigned int category_id,
- const isc_logmodule_t *module,
- isc_logchannel_t *channel);
+static isc_result_t
+assignchannel(isc_logconfig_t *lcfg, unsigned int category_id,
+ const isc_logmodule_t *module, isc_logchannel_t *channel);
-static isc_result_t sync_channellist(isc_logconfig_t *lcfg);
+static isc_result_t
+sync_channellist(isc_logconfig_t *lcfg);
-static isc_result_t greatest_version(isc_logfile_t *file, int versions,
- int *greatest);
+static isc_result_t
+greatest_version(isc_logfile_t *file, int versions, int *greatest);
-static void isc_log_doit(isc_log_t *lctx, isc_logcategory_t *category,
- isc_logmodule_t *module, int level, bool write_once,
- const char *format, va_list args)
- ISC_FORMAT_PRINTF(6, 0);
+static void
+isc_log_doit(isc_log_t *lctx, isc_logcategory_t *category,
+ isc_logmodule_t *module, int level, bool write_once,
+ const char *format, va_list args) ISC_FORMAT_PRINTF(6, 0);
/*@{*/
/*!
delete_trace_entry(a, b, c, d, e); \
} while (0)
-static void print_active(isc__mem_t *ctx, FILE *out);
+static void
+print_active(isc__mem_t *ctx, FILE *out);
#endif /* ISC_MEM_TRACKLINES */
-static void *isc___mem_get(isc_mem_t *ctx, size_t size FLARG);
-static void isc___mem_put(isc_mem_t *ctx, void *ptr, size_t size FLARG);
-static void isc___mem_putanddetach(isc_mem_t **ctxp, void *ptr,
- size_t size FLARG);
-static void *isc___mem_allocate(isc_mem_t *ctx, size_t size FLARG);
-static void *isc___mem_reallocate(isc_mem_t *ctx, void *ptr, size_t size FLARG);
-static char *isc___mem_strdup(isc_mem_t *mctx, const char *s FLARG);
-static void isc___mem_free(isc_mem_t *ctx, void *ptr FLARG);
+static void *
+isc___mem_get(isc_mem_t *ctx, size_t size FLARG);
+static void
+isc___mem_put(isc_mem_t *ctx, void *ptr, size_t size FLARG);
+static void
+isc___mem_putanddetach(isc_mem_t **ctxp, void *ptr, size_t size FLARG);
+static void *
+isc___mem_allocate(isc_mem_t *ctx, size_t size FLARG);
+static void *
+isc___mem_reallocate(isc_mem_t *ctx, void *ptr, size_t size FLARG);
+static char *
+isc___mem_strdup(isc_mem_t *mctx, const char *s FLARG);
+static void
+isc___mem_free(isc_mem_t *ctx, void *ptr FLARG);
static isc_memmethods_t memmethods = {
isc___mem_get, isc___mem_put, isc___mem_putanddetach,
* Single network event loop worker.
*/
typedef struct isc__networker {
- isc_nm_t * mgr;
- int id; /* thread id */
- uv_loop_t loop; /* libuv loop structure */
+ isc_nm_t *mgr;
+ int id; /* thread id */
+ uv_loop_t loop; /* libuv loop structure */
uv_async_t async; /* async channel to send
* data to this networker */
- isc_mutex_t lock;
+ isc_mutex_t lock;
isc_condition_t cond;
- bool paused;
- bool finished;
- isc_thread_t thread;
- isc_queue_t * ievents; /* incoming async events */
- isc_queue_t * ievents_prio; /* priority async events
- * used for listening etc.
- * can be processed while
- * worker is paused */
- isc_refcount_t references;
+ bool paused;
+ bool finished;
+ isc_thread_t thread;
+ isc_queue_t *ievents; /* incoming async events */
+ isc_queue_t *ievents_prio; /* priority async events
+ * used for listening etc.
+ * can be processed while
+ * worker is paused */
+ isc_refcount_t references;
atomic_int_fast64_t pktcount;
- char recvbuf[65536];
- bool recvbuf_inuse;
+ char recvbuf[65536];
+ bool recvbuf_inuse;
} isc__networker_t;
/*
typedef void (*isc__nm_closecb)(isc_nmhandle_t *);
struct isc_nmhandle {
- int magic;
+ int magic;
isc_refcount_t references;
/*
* the socket.
*/
isc_nmsocket_t *sock;
- size_t ah_pos; /* Position in the socket's
- * 'active handles' array */
+ size_t ah_pos; /* Position in the socket's
+ * 'active handles' array */
/*
* The handle is 'inflight' if netmgr is not currently processing
*/
atomic_bool inflight;
- isc_sockaddr_t peer;
- isc_sockaddr_t local;
+ isc_sockaddr_t peer;
+ isc_sockaddr_t local;
isc_nm_opaquecb_t doreset; /* reset extra callback, external */
isc_nm_opaquecb_t dofree; /* free extra callback, external */
- void * opaque;
- char extra[];
+ void *opaque;
+ char extra[];
};
/*
*/
typedef union {
isc_nm_recv_cb_t recv;
- isc_nm_cb_t accept;
+ isc_nm_cb_t accept;
} isc__nm_readcb_t;
typedef union {
typedef union {
isc_nm_recv_cb_t recv;
- isc_nm_cb_t accept;
- isc_nm_cb_t send;
- isc_nm_cb_t connect;
+ isc_nm_cb_t accept;
+ isc_nm_cb_t send;
+ isc_nm_cb_t connect;
} isc__nm_cb_t;
/*
#define VALID_UVREQ(t) ISC_MAGIC_VALID(t, UVREQ_MAGIC)
typedef struct isc__nm_uvreq {
- int magic;
+ int magic;
isc_nmsocket_t *sock;
isc_nmhandle_t *handle;
- uv_buf_t uvbuf; /* translated isc_region_t, to be
- * sent or received */
- isc_sockaddr_t local; /* local address */
- isc_sockaddr_t peer; /* peer address */
- isc__nm_cb_t cb; /* callback */
- void * cbarg; /* callback argument */
- uv_pipe_t ipc; /* used for sending socket
- * uv_handles to other threads */
+ uv_buf_t uvbuf; /* translated isc_region_t, to be
+ * sent or received */
+ isc_sockaddr_t local; /* local address */
+ isc_sockaddr_t peer; /* peer address */
+ isc__nm_cb_t cb; /* callback */
+ void *cbarg; /* callback argument */
+ uv_pipe_t ipc; /* used for sending socket
+ * uv_handles to other threads */
union {
- uv_req_t req;
+ uv_req_t req;
uv_getaddrinfo_t getaddrinfo;
uv_getnameinfo_t getnameinfo;
- uv_shutdown_t shutdown;
- uv_write_t write;
- uv_connect_t connect;
- uv_udp_send_t udp_send;
- uv_fs_t fs;
- uv_work_t work;
+ uv_shutdown_t shutdown;
+ uv_write_t write;
+ uv_connect_t connect;
+ uv_udp_send_t udp_send;
+ uv_fs_t fs;
+ uv_work_t work;
} uv_req;
} isc__nm_uvreq_t;
typedef struct isc__netievent__socket {
isc__netievent_type type;
- isc_nmsocket_t * sock;
+ isc_nmsocket_t *sock;
} isc__netievent__socket_t;
typedef isc__netievent__socket_t isc__netievent_udplisten_t;
typedef struct isc__netievent__socket_req {
isc__netievent_type type;
- isc_nmsocket_t * sock;
- isc__nm_uvreq_t * req;
+ isc_nmsocket_t *sock;
+ isc__nm_uvreq_t *req;
} isc__netievent__socket_req_t;
typedef isc__netievent__socket_req_t isc__netievent_tcpconnect_t;
typedef isc__netievent__socket_req_t isc__netievent_tcpsend_t;
typedef struct isc__netievent__socket_streaminfo {
- isc__netievent_type type;
- isc_nmsocket_t * sock;
+ isc__netievent_type type;
+ isc_nmsocket_t *sock;
isc_uv_stream_info_t streaminfo;
} isc__netievent__socket_streaminfo_t;
typedef struct isc__netievent__socket_handle {
isc__netievent_type type;
- isc_nmsocket_t * sock;
- isc_nmhandle_t * handle;
+ isc_nmsocket_t *sock;
+ isc_nmhandle_t *handle;
} isc__netievent__socket_handle_t;
typedef isc__netievent__socket_handle_t isc__netievent_closecb_t;
typedef struct isc__netievent_udpsend {
isc__netievent_type type;
- isc_nmsocket_t * sock;
- isc_sockaddr_t peer;
- isc__nm_uvreq_t * req;
+ isc_nmsocket_t *sock;
+ isc_sockaddr_t peer;
+ isc__nm_uvreq_t *req;
} isc__netievent_udpsend_t;
typedef struct isc__netievent {
typedef isc__netievent_t isc__netievent_stop_t;
typedef union {
- isc__netievent_t ni;
- isc__netievent__socket_t nis;
- isc__netievent__socket_req_t nisr;
- isc__netievent_udpsend_t nius;
+ isc__netievent_t ni;
+ isc__netievent__socket_t nis;
+ isc__netievent__socket_req_t nisr;
+ isc__netievent_udpsend_t nius;
isc__netievent__socket_streaminfo_t niss;
} isc__netievent_storage_t;
#define VALID_NM(t) ISC_MAGIC_VALID(t, NM_MAGIC)
struct isc_nm {
- int magic;
- isc_refcount_t references;
- isc_mem_t * mctx;
- uint32_t nworkers;
- isc_mutex_t lock;
- isc_condition_t wkstatecond;
+ int magic;
+ isc_refcount_t references;
+ isc_mem_t *mctx;
+ uint32_t nworkers;
+ isc_mutex_t lock;
+ isc_condition_t wkstatecond;
isc__networker_t *workers;
isc_stats_t *stats;
isc_mempool_t *reqpool;
- isc_mutex_t reqlock;
+ isc_mutex_t reqlock;
isc_mempool_t *evpool;
- isc_mutex_t evlock;
+ isc_mutex_t evlock;
atomic_uint_fast32_t workers_running;
atomic_uint_fast32_t workers_paused;
atomic_uint_fast32_t maxudp;
- atomic_bool paused;
+ atomic_bool paused;
/*
* Acive connections are being closed and new connections are
struct isc_nmsocket {
/*% Unlocked, RO */
- int magic;
- int tid;
+ int magic;
+ int tid;
isc_nmsocket_type type;
- isc_nm_t * mgr;
+ isc_nm_t *mgr;
/*% Parent socket for multithreaded listeners */
isc_nmsocket_t *parent;
/*% Listener socket this connection was accepted on */
*/
isc_quota_t *quota;
isc_quota_t *pquota;
- bool overquota;
+ bool overquota;
/*%
* Socket statistics
* TCP read timeout timer.
*/
uv_timer_t timer;
- bool timer_initialized;
- uint64_t read_timeout;
+ bool timer_initialized;
+ uint64_t read_timeout;
/*% outer socket is for 'wrapped' sockets - e.g. tcpdns in tcp */
isc_nmsocket_t *outer;
/*% Child sockets for multi-socket setups */
isc_nmsocket_t *children;
- int nchildren;
- isc_nmiface_t * iface;
+ int nchildren;
+ isc_nmiface_t *iface;
isc_nmhandle_t *tcphandle;
/*% Extra data allocated at the end of each isc_nmhandle_t */
int backlog;
/*% libuv data */
- uv_os_sock_t fd;
+ uv_os_sock_t fd;
union uv_any_handle uv_handle;
/*% Peer address */
* If active==false but closed==false, that means the socket
* is closing.
*/
- atomic_bool closed;
- atomic_bool listening;
- atomic_bool listen_error;
+ atomic_bool closed;
+ atomic_bool listening;
+ atomic_bool listen_error;
isc_refcount_t references;
/*%
* for the number of running children to reach zero during
* shutdown.
*/
- isc_mutex_t lock;
+ isc_mutex_t lock;
isc_condition_t cond;
/*%
* future.
*/
atomic_int_fast32_t ah;
- size_t ah_size;
- size_t * ah_frees;
- isc_nmhandle_t ** ah_handles;
+ size_t ah_size;
+ size_t *ah_frees;
+ isc_nmhandle_t **ah_handles;
/*% Buffer for TCPDNS processing */
- size_t buf_size;
- size_t buf_len;
+ size_t buf_size;
+ size_t buf_len;
unsigned char *buf;
/*%
isc_nm_opaquecb_t closehandle_cb;
isc__nm_readcb_t rcb;
- void * rcbarg;
+ void *rcbarg;
isc__nm_cb_t accept_cb;
- void * accept_cbarg;
+ void *accept_cbarg;
};
bool
ISC_THREAD_LOCAL int isc__nm_tid_v = ISC_NETMGR_TID_UNKNOWN;
-static void nmsocket_maybe_destroy(isc_nmsocket_t *sock);
-static void nmhandle_free(isc_nmsocket_t *sock, isc_nmhandle_t *handle);
-static isc_threadresult_t nm_thread(isc_threadarg_t worker0);
-static void async_cb(uv_async_t *handle);
-static void process_queue(isc__networker_t *worker, isc_queue_t *queue);
+static void
+nmsocket_maybe_destroy(isc_nmsocket_t *sock);
+static void
+nmhandle_free(isc_nmsocket_t *sock, isc_nmhandle_t *handle);
+static isc_threadresult_t
+nm_thread(isc_threadarg_t worker0);
+static void
+async_cb(uv_async_t *handle);
+static void
+process_queue(isc__networker_t *worker, isc_queue_t *queue);
int
isc_nm_tid() {
#include "netmgr-int.h"
#include "uv-compat.h"
-static int tcp_connect_direct(isc_nmsocket_t *sock, isc__nm_uvreq_t *req);
+static int
+tcp_connect_direct(isc_nmsocket_t *sock, isc__nm_uvreq_t *req);
-static void tcp_close_direct(isc_nmsocket_t *sock);
+static void
+tcp_close_direct(isc_nmsocket_t *sock);
-static isc_result_t tcp_send_direct(isc_nmsocket_t *sock, isc__nm_uvreq_t *req);
-static void tcp_connect_cb(uv_connect_t *uvreq, int status);
+static isc_result_t
+tcp_send_direct(isc_nmsocket_t *sock, isc__nm_uvreq_t *req);
+static void
+tcp_connect_cb(uv_connect_t *uvreq, int status);
-static void tcp_connection_cb(uv_stream_t *server, int status);
+static void
+tcp_connection_cb(uv_stream_t *server, int status);
-static void read_cb(uv_stream_t *stream, ssize_t nread, const uv_buf_t *buf);
+static void
+read_cb(uv_stream_t *stream, ssize_t nread, const uv_buf_t *buf);
-static void tcp_close_cb(uv_handle_t *uvhandle);
+static void
+tcp_close_cb(uv_handle_t *uvhandle);
-static void stoplistening(isc_nmsocket_t *sock);
-static void tcp_listenclose_cb(uv_handle_t *handle);
+static void
+stoplistening(isc_nmsocket_t *sock);
+static void
+tcp_listenclose_cb(uv_handle_t *handle);
static int
tcp_connect_direct(isc_nmsocket_t *sock, isc__nm_uvreq_t *req) {
* changed in the future.
*/
-static void dnslisten_readcb(isc_nmhandle_t *handle, isc_region_t *region,
- void *arg);
+static void
+dnslisten_readcb(isc_nmhandle_t *handle, isc_region_t *region, void *arg);
-static void resume_processing(void *arg);
+static void
+resume_processing(void *arg);
static inline size_t
dnslen(unsigned char *base) {
#include "netmgr-int.h"
#include "uv-compat.h"
-static isc_result_t udp_send_direct(isc_nmsocket_t *sock, isc__nm_uvreq_t *req,
- isc_sockaddr_t *peer);
+static isc_result_t
+udp_send_direct(isc_nmsocket_t *sock, isc__nm_uvreq_t *req,
+ isc_sockaddr_t *peer);
-static void udp_recv_cb(uv_udp_t *handle, ssize_t nrecv, const uv_buf_t *buf,
- const struct sockaddr *addr, unsigned flags);
+static void
+udp_recv_cb(uv_udp_t *handle, ssize_t nrecv, const uv_buf_t *buf,
+ const struct sockaddr *addr, unsigned flags);
-static void udp_send_cb(uv_udp_send_t *req, int status);
+static void
+udp_send_cb(uv_udp_send_t *req, int status);
isc_result_t
isc_nm_listenudp(isc_nm_t *mgr, isc_nmiface_t *iface, isc_nm_recv_cb_t cb,
* libuv hasn't changed.
*/
-int uv__tcp_xfer_import(uv_tcp_t *tcp, uv__ipc_socket_xfer_type_t xfer_type,
- uv__ipc_socket_xfer_info_t *xfer_info);
+int
+uv__tcp_xfer_import(uv_tcp_t *tcp, uv__ipc_socket_xfer_type_t xfer_type,
+ uv__ipc_socket_xfer_info_t *xfer_info);
-int uv__tcp_xfer_export(uv_tcp_t *handle, int target_pid,
- uv__ipc_socket_xfer_type_t *xfer_type,
- uv__ipc_socket_xfer_info_t *xfer_info);
+int
+uv__tcp_xfer_export(uv_tcp_t *handle, int target_pid,
+ uv__ipc_socket_xfer_type_t *xfer_type,
+ uv__ipc_socket_xfer_info_t *xfer_info);
int
isc_uv_export(uv_stream_t *stream, isc_uv_stream_info_t *info) {
static pk11_token_t *best_ecdsa_token;
static pk11_token_t *best_eddsa_token;
-static isc_result_t free_all_sessions(void);
-static isc_result_t free_session_list(pk11_sessionlist_t *slist);
-static isc_result_t setup_session(pk11_session_t *sp, pk11_token_t *token,
- bool rw);
-static void scan_slots(void);
-static isc_result_t token_login(pk11_session_t *sp);
-static char *percent_decode(char *x, size_t *len);
-static bool pk11strcmp(const char *x, size_t lenx, const char *y, size_t leny);
-static CK_ATTRIBUTE *push_attribute(pk11_object_t *obj, isc_mem_t *mctx,
- size_t len);
+static isc_result_t
+free_all_sessions(void);
+static isc_result_t
+free_session_list(pk11_sessionlist_t *slist);
+static isc_result_t
+setup_session(pk11_session_t *sp, pk11_token_t *token, bool rw);
+static void
+scan_slots(void);
+static isc_result_t
+token_login(pk11_session_t *sp);
+static char *
+percent_decode(char *x, size_t *len);
+static bool
+pk11strcmp(const char *x, size_t lenx, const char *y, size_t leny);
+static CK_ATTRIBUTE *
+push_attribute(pk11_object_t *obj, isc_mem_t *mctx, size_t len);
static isc_mutex_t alloclock;
static isc_mutex_t sessionlock;
typedef struct isc_mutexstats isc_mutexstats_t;
typedef struct {
- pthread_mutex_t mutex; /*%< The actual mutex. */
+ pthread_mutex_t mutex; /*%< The actual mutex. */
isc_mutexstats_t *stats; /*%< Mutex statistics. */
} isc_mutex_t;
#else /* if ISC_MUTEX_PROFILE */
ISC_LANG_BEGINDECLS
typedef pthread_t isc_thread_t;
-typedef void * isc_threadresult_t;
-typedef void * isc_threadarg_t;
+typedef void *isc_threadresult_t;
+typedef void *isc_threadarg_t;
typedef isc_threadresult_t (*isc_threadfunc_t)(isc_threadarg_t);
void
#define BIT_TEST(f, b) (((f) & (b)) != 0)
-static isc_result_t _new_prefix(isc_mem_t *mctx, isc_prefix_t **target,
- int family, void *dest, int bitlen);
+static isc_result_t
+_new_prefix(isc_mem_t *mctx, isc_prefix_t **target, int family, void *dest,
+ int bitlen);
-static void _deref_prefix(isc_prefix_t *prefix);
+static void
+_deref_prefix(isc_prefix_t *prefix);
-static isc_result_t _ref_prefix(isc_mem_t *mctx, isc_prefix_t **target,
- isc_prefix_t *prefix);
+static isc_result_t
+_ref_prefix(isc_mem_t *mctx, isc_prefix_t **target, isc_prefix_t *prefix);
-static int _comp_with_mask(void *addr, void *dest, u_int mask);
+static int
+_comp_with_mask(void *addr, void *dest, u_int mask);
-static void _clear_radix(isc_radix_tree_t *radix, isc_radix_destroyfunc_t func);
+static void
+_clear_radix(isc_radix_tree_t *radix, isc_radix_destroyfunc_t func);
static isc_result_t
_new_prefix(isc_mem_t *mctx, isc_prefix_t **target, int family, void *dest,
#define ISC_RATELIMITEREVENT_SHUTDOWN (ISC_EVENTCLASS_RATELIMITER + 1)
-static void ratelimiter_tick(isc_task_t *task, isc_event_t *event);
+static void
+ratelimiter_tick(isc_task_t *task, isc_event_t *event);
-static void ratelimiter_shutdowncomplete(isc_task_t *task, isc_event_t *event);
+static void
+ratelimiter_shutdowncomplete(isc_task_t *task, isc_event_t *event);
isc_result_t
isc_ratelimiter_create(isc_mem_t *mctx, isc_timermgr_t *timermgr,
#define isc_rwlock_pause()
#endif /* if defined(_MSC_VER) */
-static isc_result_t isc__rwlock_lock(isc_rwlock_t *rwl, isc_rwlocktype_t type);
+static isc_result_t
+isc__rwlock_lock(isc_rwlock_t *rwl, isc_rwlocktype_t type);
#ifdef ISC_RWLOCK_TRACE
#include <stdio.h> /* Required for fprintf/stderr. */
isc__task_t *excl;
};
-void isc__taskmgr_pause(isc_taskmgr_t *manager0);
-void isc__taskmgr_resume(isc_taskmgr_t *manager0);
+void
+isc__taskmgr_pause(isc_taskmgr_t *manager0);
+void
+isc__taskmgr_resume(isc_taskmgr_t *manager0);
#define DEFAULT_DEFAULT_QUANTUM 25
#define FINISHED(m) \
* unit tests etc.
*/
-bool isc_task_purgeevent(isc_task_t *task0, isc_event_t *event);
-void isc_taskmgr_setexcltask(isc_taskmgr_t *mgr0, isc_task_t *task0);
-isc_result_t isc_taskmgr_excltask(isc_taskmgr_t *mgr0, isc_task_t **taskp);
-static inline bool empty_readyq(isc__taskmgr_t *manager, int c);
+bool
+isc_task_purgeevent(isc_task_t *task0, isc_event_t *event);
+void
+isc_taskmgr_setexcltask(isc_taskmgr_t *mgr0, isc_task_t *task0);
+isc_result_t
+isc_taskmgr_excltask(isc_taskmgr_t *mgr0, isc_task_t **taskp);
+static inline bool
+empty_readyq(isc__taskmgr_t *manager, int c);
-static inline isc__task_t *pop_readyq(isc__taskmgr_t *manager, int c);
+static inline isc__task_t *
+pop_readyq(isc__taskmgr_t *manager, int c);
-static inline void push_readyq(isc__taskmgr_t *manager, isc__task_t *task,
- int c);
+static inline void
+push_readyq(isc__taskmgr_t *manager, isc__task_t *task, int c);
-static inline void wake_all_queues(isc__taskmgr_t *manager);
+static inline void
+wake_all_queues(isc__taskmgr_t *manager);
/***
*** Tasks.
* Test data from NIST KAT
*/
-isc_result_t tohexstr(unsigned char *d, char *out);
+isc_result_t
+tohexstr(unsigned char *d, char *out);
-size_t fromhexstr(const char *in, unsigned char *d);
+size_t
+fromhexstr(const char *in, unsigned char *d);
unsigned char plaintext[3 * ISC_AES_BLOCK_LENGTH];
unsigned char ciphertext[ISC_AES_BLOCK_LENGTH];
goto cleanup; \
} while (0)
-extern isc_mem_t * test_mctx;
-extern isc_log_t * test_lctx;
-extern isc_taskmgr_t * taskmgr;
-extern isc_timermgr_t * timermgr;
+extern isc_mem_t *test_mctx;
+extern isc_log_t *test_lctx;
+extern isc_taskmgr_t *taskmgr;
+extern isc_timermgr_t *timermgr;
extern isc_socketmgr_t *socketmgr;
-extern isc_nm_t * netmgr;
-extern int ncpus;
+extern isc_nm_t *netmgr;
+extern int ncpus;
isc_result_t
isc_test_begin(FILE *logfile, bool start_managers, unsigned int workers);
static double big = 4.503599627370496e15;
static double biginv = 2.22044604925031308085e-16;
-static double igamc(double a, double x);
-static double igam(double a, double x);
+static double
+igamc(double a, double x);
+static double
+igam(double a, double x);
/* Set to true (or use -v option) for verbose output */
static bool verbose = false;
#include <isc/siphash.h>
-void native_isc_siphash24(const uint8_t *, const uint8_t *, const size_t,
- uint8_t *);
+void
+native_isc_siphash24(const uint8_t *, const uint8_t *, const size_t, uint8_t *);
#if HAVE_OPENSSL_SIPHASH
-void openssl_isc_siphash24(const uint8_t *, const uint8_t *, const size_t,
- uint8_t *);
+void
+openssl_isc_siphash24(const uint8_t *, const uint8_t *, const size_t,
+ uint8_t *);
#undef HAVE_OPENSSL_SIPHASH
#define isc_siphash24 native_isc_siphash24
isc_heap_t *heap;
};
-void isc_timermgr_poke(isc_timermgr_t *manager0);
+void
+isc_timermgr_poke(isc_timermgr_t *manager0);
static inline isc_result_t
schedule(isc__timer_t *timer, isc_time_t *now, bool signal_ok) {
/*% Directory Entry */
typedef struct isc_direntry {
- char name[NAME_MAX];
+ char name[NAME_MAX];
unsigned int length;
} isc_direntry_t;
/*% Directory */
typedef struct isc_dir {
- unsigned int magic;
- char dirname[PATH_MAX];
+ unsigned int magic;
+ char dirname[PATH_MAX];
isc_direntry_t entry;
- DIR * handle;
+ DIR *handle;
} isc_dir_t;
ISC_LANG_BEGINDECLS
typedef enum memory_order memory_order;
-typedef int_fast32_t atomic_int_fast32_t;
+typedef int_fast32_t atomic_int_fast32_t;
typedef uint_fast32_t atomic_uint_fast32_t;
-typedef int_fast64_t atomic_int_fast64_t;
+typedef int_fast64_t atomic_int_fast64_t;
typedef uint_fast64_t atomic_uint_fast64_t;
-typedef bool atomic_bool;
+typedef bool atomic_bool;
typedef uint_fast64_t atomic_uintptr_t;
#define ISC_IF_INET6_SZ \
sizeof("00000000000000000000000000000001 01 80 10 80 " \
"XXXXXXloXXXXXXXX\n")
-static isc_result_t linux_if_inet6_next(isc_interfaceiter_t *);
-static isc_result_t linux_if_inet6_current(isc_interfaceiter_t *);
-static void linux_if_inet6_first(isc_interfaceiter_t *iter);
+static isc_result_t
+linux_if_inet6_next(isc_interfaceiter_t *);
+static isc_result_t
+linux_if_inet6_current(isc_interfaceiter_t *);
+static void
+linux_if_inet6_first(isc_interfaceiter_t *iter);
#endif /* ifdef __linux */
#include "ifiter_getifaddrs.c"
#define MAXSCATTERGATHER_RECV (ISC_SOCKET_MAXSCATTERGATHER)
#endif /* ifdef ISC_PLATFORM_RECVOVERFLOW */
-static isc_result_t socket_create(isc_socketmgr_t *manager0, int pf,
- isc_sockettype_t type, isc_socket_t **socketp,
- isc_socket_t *dup_socket);
-static void send_recvdone_event(isc__socket_t *, isc_socketevent_t **);
-static void send_senddone_event(isc__socket_t *, isc_socketevent_t **);
-static void send_connectdone_event(isc__socket_t *, isc_socket_connev_t **);
-static void free_socket(isc__socket_t **);
-static isc_result_t allocate_socket(isc__socketmgr_t *, isc_sockettype_t,
- isc__socket_t **);
-static void destroy(isc__socket_t **);
-static void internal_accept(isc__socket_t *);
-static void internal_connect(isc__socket_t *);
-static void internal_recv(isc__socket_t *);
-static void internal_send(isc__socket_t *);
-static void process_cmsg(isc__socket_t *, struct msghdr *, isc_socketevent_t *);
-static void build_msghdr_send(isc__socket_t *, char *, isc_socketevent_t *,
- struct msghdr *, struct iovec *, size_t *);
-static void build_msghdr_recv(isc__socket_t *, char *, isc_socketevent_t *,
- struct msghdr *, struct iovec *, size_t *);
-static bool process_ctlfd(isc__socketthread_t *thread);
-static void setdscp(isc__socket_t *sock, isc_dscp_t dscp);
+static isc_result_t
+socket_create(isc_socketmgr_t *manager0, int pf, isc_sockettype_t type,
+ isc_socket_t **socketp, isc_socket_t *dup_socket);
+static void
+send_recvdone_event(isc__socket_t *, isc_socketevent_t **);
+static void
+send_senddone_event(isc__socket_t *, isc_socketevent_t **);
+static void
+send_connectdone_event(isc__socket_t *, isc_socket_connev_t **);
+static void
+free_socket(isc__socket_t **);
+static isc_result_t
+allocate_socket(isc__socketmgr_t *, isc_sockettype_t, isc__socket_t **);
+static void
+destroy(isc__socket_t **);
+static void
+internal_accept(isc__socket_t *);
+static void
+internal_connect(isc__socket_t *);
+static void
+internal_recv(isc__socket_t *);
+static void
+internal_send(isc__socket_t *);
+static void
+process_cmsg(isc__socket_t *, struct msghdr *, isc_socketevent_t *);
+static void
+build_msghdr_send(isc__socket_t *, char *, isc_socketevent_t *, struct msghdr *,
+ struct iovec *, size_t *);
+static void
+build_msghdr_recv(isc__socket_t *, char *, isc_socketevent_t *, struct msghdr *,
+ struct iovec *, size_t *);
+static bool
+process_ctlfd(isc__socketthread_t *thread);
+static void
+setdscp(isc__socket_t *sock, isc_dscp_t dscp);
#define SELECT_POKE_SHUTDOWN (-1)
#define SELECT_POKE_NOTHING (-2)
isc_sockstatscounter_rawactive
};
-static int gen_threadid(isc__socket_t *sock);
+static int
+gen_threadid(isc__socket_t *sock);
static int
gen_threadid(isc__socket_t *sock) {
return (sock->fd % sock->manager->nthreads);
}
-static void manager_log(isc__socketmgr_t *sockmgr, isc_logcategory_t *category,
- isc_logmodule_t *module, int level, const char *fmt,
- ...) ISC_FORMAT_PRINTF(5, 6);
+static void
+manager_log(isc__socketmgr_t *sockmgr, isc_logcategory_t *category,
+ isc_logmodule_t *module, int level, const char *fmt, ...)
+ ISC_FORMAT_PRINTF(5, 6);
static void
manager_log(isc__socketmgr_t *sockmgr, isc_logcategory_t *category,
isc_logmodule_t *module, int level, const char *fmt, ...) {
sockmgr, msgbuf);
}
-static void thread_log(isc__socketthread_t *thread, isc_logcategory_t *category,
- isc_logmodule_t *module, int level, const char *fmt, ...)
+static void
+thread_log(isc__socketthread_t *thread, isc_logcategory_t *category,
+ isc_logmodule_t *module, int level, const char *fmt, ...)
ISC_FORMAT_PRINTF(5, 6);
static void
thread_log(isc__socketthread_t *thread, isc_logcategory_t *category,
thread->threadid, msgbuf);
}
-static void socket_log(isc__socket_t *sock, const isc_sockaddr_t *address,
- isc_logcategory_t *category, isc_logmodule_t *module,
- int level, const char *fmt, ...) ISC_FORMAT_PRINTF(6, 7);
+static void
+socket_log(isc__socket_t *sock, const isc_sockaddr_t *address,
+ isc_logcategory_t *category, isc_logmodule_t *module, int level,
+ const char *fmt, ...) ISC_FORMAT_PRINTF(6, 7);
static void
socket_log(isc__socket_t *sock, const isc_sockaddr_t *address,
isc_logcategory_t *category, isc_logmodule_t *module, int level,
#define ISC_DIR_MAGIC ISC_MAGIC('D', 'I', 'R', '*')
#define VALID_DIR(dir) ISC_MAGIC_VALID(dir, ISC_DIR_MAGIC)
-static isc_result_t start_directory(isc_dir_t *p);
+static isc_result_t
+start_directory(isc_dir_t *p);
void
isc_dir_init(isc_dir_t *dir) {
struct isc_condition_thread {
unsigned long th;
- HANDLE handle[2];
+ HANDLE handle[2];
ISC_LINK(isc_condition_thread_t) link;
};
typedef struct isc_condition {
- HANDLE events[2];
+ HANDLE events[2];
unsigned int waiters;
ISC_LIST(isc_condition_thread_t) threadlist;
} isc_condition_t;
#include <isc/result.h>
typedef struct {
- char name[NAME_MAX];
- unsigned int length;
+ char name[NAME_MAX];
+ unsigned int length;
WIN32_FIND_DATA find_data;
} isc_direntry_t;
typedef struct {
- unsigned int magic;
- char dirname[PATH_MAX];
+ unsigned int magic;
+ char dirname[PATH_MAX];
isc_direntry_t entry;
- bool entry_filled;
- HANDLE search_handle;
+ bool entry_filled;
+ HANDLE search_handle;
} isc_dir_t;
ISC_LANG_BEGINDECLS
atomic_compare_exchange_strong_explicit8(atomic_int_fast8_t *obj,
int8_t *expected, int8_t desired,
memory_order succ, memory_order fail) {
- bool __r;
+ bool __r;
int8_t __v;
UNUSED(succ);
int32_t *expected, int32_t desired,
memory_order succ,
memory_order fail) {
- bool __r;
+ bool __r;
int32_t __v;
UNUSED(succ);
int64_t *expected, int64_t desired,
memory_order succ,
memory_order fail) {
- bool __r;
+ bool __r;
int64_t __v;
UNUSED(succ);
}
typedef HANDLE isc_thread_t;
-typedef DWORD isc_threadresult_t;
-typedef void * isc_threadarg_t;
+typedef DWORD isc_threadresult_t;
+typedef void *isc_threadarg_t;
typedef isc_threadresult_t(WINAPI *isc_threadfunc_t)(isc_threadarg_t);
#define isc_thread_self (unsigned long)GetCurrentThreadId
#include <sys/types.h>
-void InitSockets(void);
+void
+InitSockets(void);
/* Common utility functions */
static isc_result_t ipv6only_result = ISC_R_NOTFOUND;
static isc_result_t ipv6pktinfo_result = ISC_R_NOTFOUND;
-void InitSockets(void);
+void
+InitSockets(void);
static isc_result_t
try_proto(int domain) {
#if _MSC_VER < 1600
struct addrinfo {
- int ai_flags; /* AI_PASSIVE, AI_CANONNAME */
- int ai_family; /* PF_xxx */
- int ai_socktype; /* SOCK_xxx */
- int ai_protocol; /* 0 or IPPROTO_xxx for IPv4 and
- * IPv6 */
- size_t ai_addrlen; /* Length of ai_addr */
- char * ai_canonname; /* Canonical name for hostname */
- struct sockaddr *ai_addr; /* Binary address */
- struct addrinfo *ai_next; /* Next structure in linked list */
+ int ai_flags; /* AI_PASSIVE, AI_CANONNAME */
+ int ai_family; /* PF_xxx */
+ int ai_socktype; /* SOCK_xxx */
+ int ai_protocol; /* 0 or IPPROTO_xxx for IPv4 and
+ * IPv6 */
+ size_t ai_addrlen; /* Length of ai_addr */
+ char *ai_canonname; /* Canonical name for hostname */
+ struct sockaddr *ai_addr; /* Binary address */
+ struct addrinfo *ai_next; /* Next structure in linked list */
};
#endif /* if _MSC_VER < 1600 */
* Structures for getrrsetbyname()
*/
struct rdatainfo {
- unsigned int rdi_length;
+ unsigned int rdi_length;
unsigned char *rdi_data;
};
struct rrsetinfo {
- unsigned int rri_flags;
- int rri_rdclass;
- int rri_rdtype;
- unsigned int rri_ttl;
- unsigned int rri_nrdatas;
- unsigned int rri_nsigs;
- char * rri_name;
+ unsigned int rri_flags;
+ int rri_rdclass;
+ int rri_rdtype;
+ unsigned int rri_ttl;
+ unsigned int rri_nrdatas;
+ unsigned int rri_nsigs;
+ char *rri_name;
struct rdatainfo *rri_rdatas;
struct rdatainfo *rri_sigs;
};
do { \
} while (0)
#endif /* ifdef ISC_SOCKET_CONSISTENCY_CHECKS */
-static void consistent(isc_socket_t *sock);
+static void
+consistent(isc_socket_t *sock);
/*
* Define this macro to control the behavior of connection
#define MAXSCATTERGATHER_SEND (ISC_SOCKET_MAXSCATTERGATHER)
#define MAXSCATTERGATHER_RECV (ISC_SOCKET_MAXSCATTERGATHER)
-static isc_result_t socket_create(isc_socketmgr_t *manager0, int pf,
- isc_sockettype_t type, isc_socket_t **socketp,
- isc_socket_t *dup_socket);
-static isc_threadresult_t WINAPI SocketIoThread(LPVOID ThreadContext);
-static void maybe_free_socket(isc_socket_t **, int);
-static void free_socket(isc_socket_t **, int);
-static bool senddone_is_active(isc_socket_t *sock, isc_socketevent_t *dev);
-static bool acceptdone_is_active(isc_socket_t *sock,
- isc_socket_newconnev_t *dev);
-static bool connectdone_is_active(isc_socket_t *sock, isc_socket_connev_t *dev);
-static void send_recvdone_event(isc_socket_t *sock, isc_socketevent_t **dev);
-static void send_senddone_event(isc_socket_t *sock, isc_socketevent_t **dev);
-static void send_acceptdone_event(isc_socket_t *sock,
- isc_socket_newconnev_t **adev);
-static void send_connectdone_event(isc_socket_t *sock,
- isc_socket_connev_t **cdev);
-static void send_recvdone_abort(isc_socket_t *sock, isc_result_t result);
-static void send_connectdone_abort(isc_socket_t *sock, isc_result_t result);
-static void queue_receive_event(isc_socket_t *sock, isc_task_t *task,
- isc_socketevent_t *dev);
-static void queue_receive_request(isc_socket_t *sock);
+static isc_result_t
+socket_create(isc_socketmgr_t *manager0, int pf, isc_sockettype_t type,
+ isc_socket_t **socketp, isc_socket_t *dup_socket);
+static isc_threadresult_t WINAPI
+SocketIoThread(LPVOID ThreadContext);
+static void
+maybe_free_socket(isc_socket_t **, int);
+static void
+free_socket(isc_socket_t **, int);
+static bool
+senddone_is_active(isc_socket_t *sock, isc_socketevent_t *dev);
+static bool
+acceptdone_is_active(isc_socket_t *sock, isc_socket_newconnev_t *dev);
+static bool
+connectdone_is_active(isc_socket_t *sock, isc_socket_connev_t *dev);
+static void
+send_recvdone_event(isc_socket_t *sock, isc_socketevent_t **dev);
+static void
+send_senddone_event(isc_socket_t *sock, isc_socketevent_t **dev);
+static void
+send_acceptdone_event(isc_socket_t *sock, isc_socket_newconnev_t **adev);
+static void
+send_connectdone_event(isc_socket_t *sock, isc_socket_connev_t **cdev);
+static void
+send_recvdone_abort(isc_socket_t *sock, isc_result_t result);
+static void
+send_connectdone_abort(isc_socket_t *sock, isc_result_t result);
+static void
+queue_receive_event(isc_socket_t *sock, isc_task_t *task,
+ isc_socketevent_t *dev);
+static void
+queue_receive_request(isc_socket_t *sock);
/*
* This is used to dump the contents of the sock structure
}
}
-static void socket_log(int lineno, isc_socket_t *sock,
- const isc_sockaddr_t *address,
- isc_logcategory_t *category, isc_logmodule_t *module,
- int level, const char *fmt, ...)
- ISC_FORMAT_PRINTF(10, 11);
+static void
+socket_log(int lineno, isc_socket_t *sock, const isc_sockaddr_t *address,
+ isc_logcategory_t *category, isc_logmodule_t *module, int level,
+ const char *fmt, ...) ISC_FORMAT_PRINTF(10, 11);
/* This function will add an entry to the I/O completion port
* that will signal the I/O thread to exit (gracefully)
#define HSHA_OFFSET 22 /*%< 21 = 6 + 1 + 4 + 5 + 1 + 4 + 1 */
#define HSHA_LENGTH 88
-static isc_result_t table_towire(isccc_sexpr_t *alist, isc_buffer_t **buffer);
+static isc_result_t
+table_towire(isccc_sexpr_t *alist, isc_buffer_t **buffer);
-static isc_result_t list_towire(isccc_sexpr_t *alist, isc_buffer_t **buffer);
+static isc_result_t
+list_towire(isccc_sexpr_t *alist, isc_buffer_t **buffer);
static isc_result_t
value_towire(isccc_sexpr_t *elt, isc_buffer_t **buffer) {
return (ISC_R_SUCCESS);
}
-static isc_result_t table_fromwire(isccc_region_t *source,
- isccc_region_t *secret, uint32_t algorithm,
- isccc_sexpr_t **alistp);
+static isc_result_t
+table_fromwire(isccc_region_t *source, isccc_region_t *secret,
+ uint32_t algorithm, isccc_sexpr_t **alistp);
-static isc_result_t list_fromwire(isccc_region_t *source,
- isccc_sexpr_t **listp);
+static isc_result_t
+list_fromwire(isccc_region_t *source, isccc_sexpr_t **listp);
static isc_result_t
value_fromwire(isccc_region_t *source, isccc_sexpr_t **valuep) {
#define CCMSG_MAGIC ISC_MAGIC('C', 'C', 'm', 's')
#define VALID_CCMSG(foo) ISC_MAGIC_VALID(foo, CCMSG_MAGIC)
-static void recv_length(isc_task_t *, isc_event_t *);
-static void recv_message(isc_task_t *, isc_event_t *);
+static void
+recv_length(isc_task_t *, isc_event_t *);
+static void
+recv_message(isc_task_t *, isc_event_t *);
static void
recv_length(isc_task_t *task, isc_event_t *ev_in) {
* Forward declarations of static functions.
*/
-static isc_result_t parse_keyvalue(cfg_parser_t *pctx, const cfg_type_t *type,
- cfg_obj_t **ret);
+static isc_result_t
+parse_keyvalue(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret);
-static isc_result_t parse_optional_keyvalue(cfg_parser_t *pctx,
- const cfg_type_t *type,
- cfg_obj_t **ret);
+static isc_result_t
+parse_optional_keyvalue(cfg_parser_t *pctx, const cfg_type_t *type,
+ cfg_obj_t **ret);
-static isc_result_t parse_updatepolicy(cfg_parser_t *pctx,
- const cfg_type_t *type, cfg_obj_t **ret);
-static void print_updatepolicy(cfg_printer_t *pctx, const cfg_obj_t *obj);
+static isc_result_t
+parse_updatepolicy(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret);
+static void
+print_updatepolicy(cfg_printer_t *pctx, const cfg_obj_t *obj);
-static void doc_updatepolicy(cfg_printer_t *pctx, const cfg_type_t *type);
+static void
+doc_updatepolicy(cfg_printer_t *pctx, const cfg_type_t *type);
-static void print_keyvalue(cfg_printer_t *pctx, const cfg_obj_t *obj);
+static void
+print_keyvalue(cfg_printer_t *pctx, const cfg_obj_t *obj);
-static void doc_keyvalue(cfg_printer_t *pctx, const cfg_type_t *type);
+static void
+doc_keyvalue(cfg_printer_t *pctx, const cfg_type_t *type);
-static void doc_optional_keyvalue(cfg_printer_t *pctx, const cfg_type_t *type);
+static void
+doc_optional_keyvalue(cfg_printer_t *pctx, const cfg_type_t *type);
static cfg_type_t cfg_type_acl;
static cfg_type_t cfg_type_bracketed_dscpsockaddrlist;
* Forward declarations of static functions.
*/
-static void free_tuple(cfg_parser_t *pctx, cfg_obj_t *obj);
+static void
+free_tuple(cfg_parser_t *pctx, cfg_obj_t *obj);
-static isc_result_t parse_list(cfg_parser_t *pctx, const cfg_type_t *type,
- cfg_obj_t **ret);
+static isc_result_t
+parse_list(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret);
-static void print_list(cfg_printer_t *pctx, const cfg_obj_t *obj);
+static void
+print_list(cfg_printer_t *pctx, const cfg_obj_t *obj);
-static void free_list(cfg_parser_t *pctx, cfg_obj_t *obj);
+static void
+free_list(cfg_parser_t *pctx, cfg_obj_t *obj);
-static isc_result_t create_listelt(cfg_parser_t *pctx, cfg_listelt_t **eltp);
+static isc_result_t
+create_listelt(cfg_parser_t *pctx, cfg_listelt_t **eltp);
-static isc_result_t create_string(cfg_parser_t *pctx, const char *contents,
- const cfg_type_t *type, cfg_obj_t **ret);
+static isc_result_t
+create_string(cfg_parser_t *pctx, const char *contents, const cfg_type_t *type,
+ cfg_obj_t **ret);
-static void free_string(cfg_parser_t *pctx, cfg_obj_t *obj);
+static void
+free_string(cfg_parser_t *pctx, cfg_obj_t *obj);
-static isc_result_t create_map(cfg_parser_t *pctx, const cfg_type_t *type,
- cfg_obj_t **objp);
+static isc_result_t
+create_map(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **objp);
-static void free_map(cfg_parser_t *pctx, cfg_obj_t *obj);
+static void
+free_map(cfg_parser_t *pctx, cfg_obj_t *obj);
-static isc_result_t parse_symtab_elt(cfg_parser_t *pctx, const char *name,
- cfg_type_t *elttype, isc_symtab_t *symtab,
- bool callback);
+static isc_result_t
+parse_symtab_elt(cfg_parser_t *pctx, const char *name, cfg_type_t *elttype,
+ isc_symtab_t *symtab, bool callback);
-static void free_noop(cfg_parser_t *pctx, cfg_obj_t *obj);
+static void
+free_noop(cfg_parser_t *pctx, cfg_obj_t *obj);
-static isc_result_t cfg_getstringtoken(cfg_parser_t *pctx);
+static isc_result_t
+cfg_getstringtoken(cfg_parser_t *pctx);
-static void parser_complain(cfg_parser_t *pctx, bool is_warning,
- unsigned int flags, const char *format,
- va_list args);
+static void
+parser_complain(cfg_parser_t *pctx, bool is_warning, unsigned int flags,
+ const char *format, va_list args);
#if defined(HAVE_GEOIP2)
-static isc_result_t parse_geoip(cfg_parser_t *pctx, const cfg_type_t *type,
- cfg_obj_t **ret);
+static isc_result_t
+parse_geoip(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret);
-static void print_geoip(cfg_printer_t *pctx, const cfg_obj_t *obj);
+static void
+print_geoip(cfg_printer_t *pctx, const cfg_obj_t *obj);
-static void doc_geoip(cfg_printer_t *pctx, const cfg_type_t *type);
+static void
+doc_geoip(cfg_printer_t *pctx, const cfg_type_t *type);
#endif /* HAVE_GEOIP2 */
/*
LIBNS_EXTERNAL_DATA atomic_uint_fast64_t ns_client_requests;
#endif /* if defined(_WIN32) && !defined(_WIN64) */
-static void clientmgr_attach(ns_clientmgr_t *source, ns_clientmgr_t **targetp);
-static void clientmgr_detach(ns_clientmgr_t **mp);
-static void clientmgr_destroy(ns_clientmgr_t *manager);
-static void ns_client_endrequest(ns_client_t *client);
-static void ns_client_dumpmessage(ns_client_t *client, const char *reason);
-static void compute_cookie(ns_client_t *client, uint32_t when, uint32_t nonce,
- const unsigned char *secret, isc_buffer_t *buf);
-static void get_clientmctx(ns_clientmgr_t *manager, isc_mem_t **mctxp);
+static void
+clientmgr_attach(ns_clientmgr_t *source, ns_clientmgr_t **targetp);
+static void
+clientmgr_detach(ns_clientmgr_t **mp);
+static void
+clientmgr_destroy(ns_clientmgr_t *manager);
+static void
+ns_client_endrequest(ns_client_t *client);
+static void
+ns_client_dumpmessage(ns_client_t *client, const char *reason);
+static void
+compute_cookie(ns_client_t *client, uint32_t when, uint32_t nonce,
+ const unsigned char *secret, isc_buffer_t *buf);
+static void
+get_clientmctx(ns_clientmgr_t *manager, isc_mem_t **mctxp);
void
ns_client_recursing(ns_client_t *client) {
#endif /* ifdef USE_ROUTE_SOCKET */
};
-static void purge_old_interfaces(ns_interfacemgr_t *mgr);
+static void
+purge_old_interfaces(ns_interfacemgr_t *mgr);
-static void clearlistenon(ns_interfacemgr_t *mgr);
+static void
+clearlistenon(ns_interfacemgr_t *mgr);
#ifdef USE_ROUTE_SOCKET
static void
#include <ns/listenlist.h>
-static void destroy(ns_listenlist_t *list);
+static void
+destroy(ns_listenlist_t *list);
isc_result_t
ns_listenelt_create(isc_mem_t *mctx, in_port_t port, isc_dscp_t dscp,
} while (0)
#define RESTORE(a, b) SAVE(a, b)
-static bool validate(ns_client_t *client, dns_db_t *db, dns_name_t *name,
- dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset);
+static bool
+validate(ns_client_t *client, dns_db_t *db, dns_name_t *name,
+ dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset);
static void
query_findclosestnsec3(dns_name_t *qname, dns_db_t *db,
dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset,
dns_name_t *fname, bool exact, dns_name_t *found);
-static inline void log_queryerror(ns_client_t *client, isc_result_t result,
- int line, int level);
+static inline void
+log_queryerror(ns_client_t *client, isc_result_t result, int line, int level);
-static void rpz_st_clear(ns_client_t *client);
+static void
+rpz_st_clear(ns_client_t *client);
-static bool rpz_ck_dnssec(ns_client_t *client, isc_result_t qresult,
- dns_rdataset_t *rdataset,
- dns_rdataset_t *sigrdataset);
+static bool
+rpz_ck_dnssec(ns_client_t *client, isc_result_t qresult,
+ dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset);
-static void log_noexistnodata(void *val, int level, const char *fmt, ...)
+static void
+log_noexistnodata(void *val, int level, const char *fmt, ...)
ISC_FORMAT_PRINTF(3, 4);
/*
* plugins.)
*/
-static void query_trace(query_ctx_t *qctx);
+static void
+query_trace(query_ctx_t *qctx);
-static void qctx_init(ns_client_t *client, dns_fetchevent_t *event,
- dns_rdatatype_t qtype, query_ctx_t *qctx);
+static void
+qctx_init(ns_client_t *client, dns_fetchevent_t *event, dns_rdatatype_t qtype,
+ query_ctx_t *qctx);
-static isc_result_t query_setup(ns_client_t *client, dns_rdatatype_t qtype);
+static isc_result_t
+query_setup(ns_client_t *client, dns_rdatatype_t qtype);
-static isc_result_t query_lookup(query_ctx_t *qctx);
+static isc_result_t
+query_lookup(query_ctx_t *qctx);
-static void fetch_callback(isc_task_t *task, isc_event_t *event);
+static void
+fetch_callback(isc_task_t *task, isc_event_t *event);
-static void recparam_update(ns_query_recparam_t *param, dns_rdatatype_t qtype,
- const dns_name_t *qname, const dns_name_t *qdomain);
+static void
+recparam_update(ns_query_recparam_t *param, dns_rdatatype_t qtype,
+ const dns_name_t *qname, const dns_name_t *qdomain);
-static isc_result_t query_resume(query_ctx_t *qctx);
+static isc_result_t
+query_resume(query_ctx_t *qctx);
-static isc_result_t query_checkrrl(query_ctx_t *qctx, isc_result_t result);
+static isc_result_t
+query_checkrrl(query_ctx_t *qctx, isc_result_t result);
-static isc_result_t query_checkrpz(query_ctx_t *qctx, isc_result_t result);
+static isc_result_t
+query_checkrpz(query_ctx_t *qctx, isc_result_t result);
-static isc_result_t query_rpzcname(query_ctx_t *qctx, dns_name_t *cname);
+static isc_result_t
+query_rpzcname(query_ctx_t *qctx, dns_name_t *cname);
-static isc_result_t query_gotanswer(query_ctx_t *qctx, isc_result_t result);
+static isc_result_t
+query_gotanswer(query_ctx_t *qctx, isc_result_t result);
-static void query_addnoqnameproof(query_ctx_t *qctx);
+static void
+query_addnoqnameproof(query_ctx_t *qctx);
-static isc_result_t query_respond_any(query_ctx_t *qctx);
+static isc_result_t
+query_respond_any(query_ctx_t *qctx);
-static isc_result_t query_respond(query_ctx_t *qctx);
+static isc_result_t
+query_respond(query_ctx_t *qctx);
-static isc_result_t query_dns64(query_ctx_t *qctx);
+static isc_result_t
+query_dns64(query_ctx_t *qctx);
-static void query_filter64(query_ctx_t *qctx);
+static void
+query_filter64(query_ctx_t *qctx);
-static isc_result_t query_notfound(query_ctx_t *qctx);
+static isc_result_t
+query_notfound(query_ctx_t *qctx);
-static isc_result_t query_zone_delegation(query_ctx_t *qctx);
+static isc_result_t
+query_zone_delegation(query_ctx_t *qctx);
-static isc_result_t query_delegation(query_ctx_t *qctx);
+static isc_result_t
+query_delegation(query_ctx_t *qctx);
-static isc_result_t query_delegation_recurse(query_ctx_t *qctx);
+static isc_result_t
+query_delegation_recurse(query_ctx_t *qctx);
-static void query_addds(query_ctx_t *qctx);
+static void
+query_addds(query_ctx_t *qctx);
-static isc_result_t query_nodata(query_ctx_t *qctx, isc_result_t result);
+static isc_result_t
+query_nodata(query_ctx_t *qctx, isc_result_t result);
-static isc_result_t query_sign_nodata(query_ctx_t *qctx);
+static isc_result_t
+query_sign_nodata(query_ctx_t *qctx);
-static void query_addnxrrsetnsec(query_ctx_t *qctx);
+static void
+query_addnxrrsetnsec(query_ctx_t *qctx);
-static isc_result_t query_nxdomain(query_ctx_t *qctx, bool empty_wild);
+static isc_result_t
+query_nxdomain(query_ctx_t *qctx, bool empty_wild);
-static isc_result_t query_redirect(query_ctx_t *qctx);
+static isc_result_t
+query_redirect(query_ctx_t *qctx);
-static isc_result_t query_ncache(query_ctx_t *qctx, isc_result_t result);
+static isc_result_t
+query_ncache(query_ctx_t *qctx, isc_result_t result);
-static isc_result_t query_coveringnsec(query_ctx_t *qctx);
+static isc_result_t
+query_coveringnsec(query_ctx_t *qctx);
-static isc_result_t query_zerottl_refetch(query_ctx_t *qctx);
+static isc_result_t
+query_zerottl_refetch(query_ctx_t *qctx);
-static isc_result_t query_cname(query_ctx_t *qctx);
+static isc_result_t
+query_cname(query_ctx_t *qctx);
-static isc_result_t query_dname(query_ctx_t *qctx);
+static isc_result_t
+query_dname(query_ctx_t *qctx);
-static isc_result_t query_addcname(query_ctx_t *qctx, dns_trust_t trust,
- dns_ttl_t ttl);
+static isc_result_t
+query_addcname(query_ctx_t *qctx, dns_trust_t trust, dns_ttl_t ttl);
-static isc_result_t query_prepresponse(query_ctx_t *qctx);
+static isc_result_t
+query_prepresponse(query_ctx_t *qctx);
-static isc_result_t query_addsoa(query_ctx_t *qctx, unsigned int override_ttl,
- dns_section_t section);
+static isc_result_t
+query_addsoa(query_ctx_t *qctx, unsigned int override_ttl,
+ dns_section_t section);
-static isc_result_t query_addns(query_ctx_t *qctx);
+static isc_result_t
+query_addns(query_ctx_t *qctx);
-static void query_addbestns(query_ctx_t *qctx);
+static void
+query_addbestns(query_ctx_t *qctx);
-static void query_addwildcardproof(query_ctx_t *qctx, bool ispositive,
- bool nodata);
+static void
+query_addwildcardproof(query_ctx_t *qctx, bool ispositive, bool nodata);
-static void query_addauth(query_ctx_t *qctx);
+static void
+query_addauth(query_ctx_t *qctx);
/*
* Increment query statistics counters.
atomic_uint_fast32_t client_refs[32];
atomic_uintptr_t client_addrs[32];
-void __wrap_isc_nmhandle_unref(isc_nmhandle_t *handle);
+void
+__wrap_isc_nmhandle_unref(isc_nmhandle_t *handle);
void
__wrap_isc_nmhandle_unref(isc_nmhandle_t *handle) {
typedef struct ns_test_id {
const char *description;
- int lineno;
+ int lineno;
} ns_test_id_t;
#define NS_TEST_ID(desc) \
goto cleanup; \
} while (0)
-extern isc_mem_t * mctx;
-extern isc_log_t * lctx;
-extern isc_taskmgr_t * taskmgr;
-extern isc_task_t * maintask;
-extern isc_timermgr_t * timermgr;
-extern isc_socketmgr_t * socketmgr;
-extern dns_zonemgr_t * zonemgr;
+extern isc_mem_t *mctx;
+extern isc_log_t *lctx;
+extern isc_taskmgr_t *taskmgr;
+extern isc_task_t *maintask;
+extern isc_timermgr_t *timermgr;
+extern isc_socketmgr_t *socketmgr;
+extern dns_zonemgr_t *zonemgr;
extern dns_dispatchmgr_t *dispatchmgr;
-extern ns_clientmgr_t * clientmgr;
+extern ns_clientmgr_t *clientmgr;
extern ns_interfacemgr_t *interfacemgr;
-extern ns_server_t * sctx;
-extern bool app_running;
-extern int ncpus;
-extern bool debug_mem_record;
+extern ns_server_t *sctx;
+extern bool app_running;
+extern int ncpus;
+extern bool debug_mem_record;
isc_result_t
ns_test_begin(FILE *logfile, bool create_managers);
* Structure containing parameters for ns_test_qctx_create().
*/
typedef struct ns_test_qctx_create_params {
- const char * qname;
+ const char *qname;
dns_rdatatype_t qtype;
- unsigned int qflags;
- bool with_cache;
+ unsigned int qflags;
+ bool with_cache;
} ns_test_qctx_create_params_t;
/*%
*/
isc_result_t
ns_test_qctx_create(const ns_test_qctx_create_params_t *params,
- query_ctx_t ** qctxp);
+ query_ctx_t **qctxp);
/*%
* Destroy a query context created by ns_test_qctx_create().
#include <isc/types.h>
#include <isc/util.h>
-ISC_PLATFORM_NORETURN_PRE void _fail(const char *const file,
- const int line) ISC_PLATFORM_NORETURN_POST;
+ISC_PLATFORM_NORETURN_PRE void
+_fail(const char *const file, const int line) ISC_PLATFORM_NORETURN_POST;
#include <ns/hooks.h>
* can't be used.
*/
-extern void __wrap_isc_nmhandle_unref(isc_nmhandle_t *handle);
+extern void
+__wrap_isc_nmhandle_unref(isc_nmhandle_t *handle);
void
isc_nmhandle_unref(isc_nmhandle_t *handle) {
* Forward declarations.
*/
-static void update_action(isc_task_t *task, isc_event_t *event);
-static void updatedone_action(isc_task_t *task, isc_event_t *event);
-static isc_result_t send_forward_event(ns_client_t *client, dns_zone_t *zone);
-static void forward_done(isc_task_t *task, isc_event_t *event);
-static isc_result_t add_rr_prepare_action(void *data, rr_t *rr);
+static void
+update_action(isc_task_t *task, isc_event_t *event);
+static void
+updatedone_action(isc_task_t *task, isc_event_t *event);
+static isc_result_t
+send_forward_event(ns_client_t *client, dns_zone_t *zone);
+static void
+forward_done(isc_task_t *task, isc_event_t *event);
+static isc_result_t
+add_rr_prepare_action(void *data, rr_t *rr);
/**************************************************************************/
-static void update_log(ns_client_t *client, dns_zone_t *zone, int level,
- const char *fmt, ...) ISC_FORMAT_PRINTF(4, 5);
+static void
+update_log(ns_client_t *client, dns_zone_t *zone, int level, const char *fmt,
+ ...) ISC_FORMAT_PRINTF(4, 5);
static void
update_log(ns_client_t *client, dns_zone_t *zone, int level, const char *fmt,
/*%
* Function type for foreach_rrset() iterator actions.
*/
-typedef isc_result_t rrset_func(void *data, dns_rdataset_t *rrset);
+typedef isc_result_t
+rrset_func(void *data, dns_rdataset_t *rrset);
/*%
* Function type for foreach_rr() iterator actions.
*/
-typedef isc_result_t rr_func(void *data, rr_t *rr);
+typedef isc_result_t
+rr_func(void *data, rr_t *rr);
/*%
* Internal context struct for foreach_node_rr().
* Function type for predicate functions that compare a database RR 'db_rr'
* against an update RR 'update_rr'.
*/
-typedef bool rr_predicate(dns_rdata_t *update_rr, dns_rdata_t *db_rr);
+typedef bool
+rr_predicate(dns_rdata_t *update_rr, dns_rdata_t *db_rr);
/*%
* Helper function for rrset_exists().
} ixfr_rrstream_t;
/* Forward declarations. */
-static void ixfr_rrstream_destroy(rrstream_t **sp);
+static void
+ixfr_rrstream_destroy(rrstream_t **sp);
static rrstream_methods_t ixfr_rrstream_methods;
/*
* Forward declarations.
*/
-static void axfr_rrstream_destroy(rrstream_t **rsp);
+static void
+axfr_rrstream_destroy(rrstream_t **rsp);
static rrstream_methods_t axfr_rrstream_methods;
/*
* Forward declarations.
*/
-static void soa_rrstream_destroy(rrstream_t **rsp);
+static void
+soa_rrstream_destroy(rrstream_t **rsp);
static rrstream_methods_t soa_rrstream_methods;
/*
* Forward declarations.
*/
-static void compound_rrstream_destroy(rrstream_t **rsp);
+static void
+compound_rrstream_destroy(rrstream_t **rsp);
-static isc_result_t compound_rrstream_next(rrstream_t *rs);
+static isc_result_t
+compound_rrstream_next(rrstream_t *rs);
static rrstream_methods_t compound_rrstream_methods;
struct xfr_stats stats; /*%< Transfer statistics */
} xfrout_ctx_t;
-static void xfrout_ctx_create(isc_mem_t *mctx, ns_client_t *client,
- unsigned int id, dns_name_t *qname,
- dns_rdatatype_t qtype, dns_rdataclass_t qclass,
- dns_zone_t *zone, dns_db_t *db,
- dns_dbversion_t *ver, isc_quota_t *quota,
- rrstream_t *stream, dns_tsigkey_t *tsigkey,
- isc_buffer_t *lasttsig, bool verified_tsig,
- unsigned int maxtime, unsigned int idletime,
- bool many_answers, xfrout_ctx_t **xfrp);
+static void
+xfrout_ctx_create(isc_mem_t *mctx, ns_client_t *client, unsigned int id,
+ dns_name_t *qname, dns_rdatatype_t qtype,
+ dns_rdataclass_t qclass, dns_zone_t *zone, dns_db_t *db,
+ dns_dbversion_t *ver, isc_quota_t *quota, rrstream_t *stream,
+ dns_tsigkey_t *tsigkey, isc_buffer_t *lasttsig,
+ bool verified_tsig, unsigned int maxtime,
+ unsigned int idletime, bool many_answers,
+ xfrout_ctx_t **xfrp);
-static void sendstream(xfrout_ctx_t *xfr);
+static void
+sendstream(xfrout_ctx_t *xfr);
-static void xfrout_senddone(isc_nmhandle_t *handle, isc_result_t result,
- void *arg);
+static void
+xfrout_senddone(isc_nmhandle_t *handle, isc_result_t result, void *arg);
-static void xfrout_fail(xfrout_ctx_t *xfr, isc_result_t result,
- const char *msg);
+static void
+xfrout_fail(xfrout_ctx_t *xfr, isc_result_t result, const char *msg);
-static void xfrout_maybe_destroy(xfrout_ctx_t *xfr);
+static void
+xfrout_maybe_destroy(xfrout_ctx_t *xfr);
-static void xfrout_ctx_destroy(xfrout_ctx_t **xfrp);
+static void
+xfrout_ctx_destroy(xfrout_ctx_t **xfrp);
-static void xfrout_client_shutdown(void *arg, isc_result_t result);
+static void
+xfrout_client_shutdown(void *arg, isc_result_t result);
-static void xfrout_log1(ns_client_t *client, dns_name_t *zonename,
- dns_rdataclass_t rdclass, int level, const char *fmt,
- ...) ISC_FORMAT_PRINTF(5, 6);
+static void
+xfrout_log1(ns_client_t *client, dns_name_t *zonename, dns_rdataclass_t rdclass,
+ int level, const char *fmt, ...) ISC_FORMAT_PRINTF(5, 6);
-static void xfrout_log(xfrout_ctx_t *xfr, int level, const char *fmt, ...)
+static void
+xfrout_log(xfrout_ctx_t *xfr, int level, const char *fmt, ...)
ISC_FORMAT_PRINTF(3, 4);
/**************************************************************************/
* <client>: transfer of <zone>: <message>
*/
-static void xfrout_logv(ns_client_t *client, dns_name_t *zonename,
- dns_rdataclass_t rdclass, int level, const char *fmt,
- va_list ap) ISC_FORMAT_PRINTF(5, 0);
+static void
+xfrout_logv(ns_client_t *client, dns_name_t *zonename, dns_rdataclass_t rdclass,
+ int level, const char *fmt, va_list ap) ISC_FORMAT_PRINTF(5, 0);
static void
xfrout_logv(ns_client_t *client, dns_name_t *zonename, dns_rdataclass_t rdclass,
static const char *qlabels[] = { "www.", "ftp.", NULL };
static struct probe_trans probes[MAX_PROBES];
-static isc_result_t probe_domain(struct probe_trans *trans);
-static void reset_probe(struct probe_trans *trans);
-static isc_result_t fetch_nsaddress(struct probe_trans *trans);
-static isc_result_t probe_name(struct probe_trans *trans, dns_rdatatype_t type);
+static isc_result_t
+probe_domain(struct probe_trans *trans);
+static void
+reset_probe(struct probe_trans *trans);
+static isc_result_t
+fetch_nsaddress(struct probe_trans *trans);
+static isc_result_t
+probe_name(struct probe_trans *trans, dns_rdatatype_t type);
/* Dump an rdataset for debug */
static isc_result_t
return (result);
}
-ISC_PLATFORM_NORETURN_PRE static void usage(void) ISC_PLATFORM_NORETURN_POST;
+ISC_PLATFORM_NORETURN_PRE static void
+usage(void) ISC_PLATFORM_NORETURN_POST;
static void
usage(void) {
return (ISC_R_SUCCESS);
}
-ISC_PLATFORM_NORETURN_PRE static void usage(void) ISC_PLATFORM_NORETURN_POST;
+ISC_PLATFORM_NORETURN_PRE static void
+usage(void) ISC_PLATFORM_NORETURN_POST;
static void
usage(void) {
static struct query_trans query_array[MAX_QUERIES];
-static isc_result_t dispatch_query(struct query_trans *trans);
+static isc_result_t
+dispatch_query(struct query_trans *trans);
static void
ctxs_destroy(isc_mem_t **mctxp, isc_appctx_t **actxp, isc_taskmgr_t **taskmgrp,
return (result);
}
-ISC_PLATFORM_NORETURN_PRE static void usage(void) ISC_PLATFORM_NORETURN_POST;
+ISC_PLATFORM_NORETURN_PRE static void
+usage(void) ISC_PLATFORM_NORETURN_POST;
static void
usage(void) {
static isc_mem_t *mctx;
static dns_fixedname_t fixedqname;
-ISC_PLATFORM_NORETURN_PRE static void usage(void) ISC_PLATFORM_NORETURN_POST;
+ISC_PLATFORM_NORETURN_PRE static void
+usage(void) ISC_PLATFORM_NORETURN_POST;
static void
usage(void) {
static const char *port = "53";
-static void setup_tsec(char *keyfile, isc_mem_t *mctx);
-static void update_addordelete(isc_mem_t *mctx, char *cmdline, bool isdelete,
- dns_name_t *name);
-static void evaluate_prereq(isc_mem_t *mctx, char *cmdline, dns_name_t *name);
+static void
+setup_tsec(char *keyfile, isc_mem_t *mctx);
+static void
+update_addordelete(isc_mem_t *mctx, char *cmdline, bool isdelete,
+ dns_name_t *name);
+static void
+evaluate_prereq(isc_mem_t *mctx, char *cmdline, dns_name_t *name);
-ISC_PLATFORM_NORETURN_PRE static void usage(void) ISC_PLATFORM_NORETURN_POST;
+ISC_PLATFORM_NORETURN_PRE static void
+usage(void) ISC_PLATFORM_NORETURN_POST;
static void
usage(void) {
* See https://scan.coverity.com/models
*/
-#define FLARG , const char *file, unsigned int line
+#define FLARG , const char *file, unsigned int line
#define FLARG_PASS , file, line
int condition;
void *
-isc__mem_get(void *mem, unsigned int size FLARG)
-{
+isc__mem_get(void *mem, unsigned int size FLARG) {
if (!mem) {
__coverity_panic__();
}
}
void
-isc__mem_put(void *mem, void *ptr, unsigned int size FLARG)
-{
+isc__mem_put(void *mem, void *ptr, unsigned int size FLARG) {
if (!mem) {
__coverity_panic__();
}
}
void
-isc__mem_putanddetach(void *mem, void *ptr, unsigned int size FLARG)
-{
+isc__mem_putanddetach(void *mem, void *ptr, unsigned int size FLARG) {
if (!mem) {
__coverity_panic__();
}
}
void *
-isc__mem_allocate(void *mem, unsigned int size FLARG)
-{
+isc__mem_allocate(void *mem, unsigned int size FLARG) {
if (!mem) {
__coverity_panic__();
}
memcpy(void *s1, const void *s2, size_t n);
void *
-isc__mem_reallocate(void *mem, void *ptr, size_t size FLARG)
-{
- char * p = (char *)0;
+isc__mem_reallocate(void *mem, void *ptr, size_t size FLARG) {
+ char *p = (char *)0;
size_t l;
if (!mem) {
}
void
-isc__mem_free(void *mem, void *ptr FLARG)
-{
+isc__mem_free(void *mem, void *ptr FLARG) {
if (!mem) {
__coverity_panic__();
}
strlen(const char *);
void *
-isc__mem_strdup(void *mem, char *s FLARG)
-{
+isc__mem_strdup(void *mem, char *s FLARG) {
void *d;
if (!mem) {
__coverity_panic__();
}
void *
-isc__mempool_get(void *mem FLARG)
-{
+isc__mempool_get(void *mem FLARG) {
unsigned int size;
if (!mem) {
__coverity_panic__();
}
void
-isc__mempool_put(void *mem, void *ptr FLARG)
-{
+isc__mempool_put(void *mem, void *ptr FLARG) {
if (!mem) {
__coverity_panic__();
}
void
_assert_true(const LargestIntegralType result, const char *const expression,
- const char *const file, const int line)
-{
+ const char *const file, const int line) {
if (!result) {
__coverity_panic__();
}
projects / thirdparty / bind9.git / commitdiff
