51 #include <libxml/parser.h> 57 #include <sys/socket.h> 58 #include <sys/types.h> 63 static const char* engine_str =
"engine";
95 if (!(engine->
taskq = schedule_create())) {
101 schedule_registertask(engine->
taskq, TASK_CLASS_SIGNER, TASK_READ,
do_readzone);
103 schedule_registertask(engine->
taskq, TASK_CLASS_SIGNER, TASK_SIGN,
do_signzone);
104 schedule_registertask(engine->
taskq, TASK_CLASS_SIGNER, TASK_WRITE,
do_writezone);
111 ods_log_debug(
"[%s] start command handler", engine_str);
112 janitor_thread_create(&engine->
cmdhandler->thread_id, workerthreadclass, (janitor_runfn_t)cmdhandler_start, engine->
cmdhandler);
125 ods_log_debug(
"[%s] start dnshandler", engine_str);
135 ods_log_debug(
"[%s] stop dnshandler", engine_str);
138 ods_log_debug(
"[%s] join dnshandler", engine_str);
150 ods_log_debug(
"[%s] start xfrhandler", engine_str);
165 ods_log_debug(
"[%s] stop xfrhandler", engine_str);
168 ods_log_debug(
"[%s] join xfrhandler", engine_str);
184 ods_status status = ODS_STATUS_OK;
187 ods_log_assert(engine);
188 ods_log_assert(engine->
config);
189 ods_log_debug(
"[%s] drop privileges", engine_str);
191 ods_log_verbose(
"[%s] drop privileges to user %s, group %s",
194 ods_log_verbose(
"[%s] drop privileges to user %s", engine_str,
197 ods_log_verbose(
"[%s] drop privileges to group %s", engine_str,
201 ods_log_verbose(
"[%s] chroot to %s", engine_str,
224 ods_log_assert(engine);
225 ods_log_assert(engine->
config);
227 CHECKALLOC(engine->
workers = (worker_type**) malloc(numTotalWorkers *
sizeof(worker_type*)));
229 asprintf(&name,
"worker[%d]", i+1);
230 engine->
workers[threadCount++] = worker_create(name, engine->
taskq);
233 asprintf(&name,
"drudger[%d]", i+1);
234 engine->
workers[threadCount++] = worker_create(name, engine->
taskq);
244 ods_log_assert(engine);
245 ods_log_assert(engine->
config);
246 ods_log_debug(
"[%s] start workers", engine_str);
252 engine->
workers[threadCount]->need_to_exit = 0;
253 engine->
workers[threadCount]->context = context;
254 janitor_thread_create(&engine->
workers[threadCount]->thread_id, workerthreadclass, (janitor_runfn_t)worker_start, engine->
workers[threadCount]);
257 engine->
workers[threadCount]->need_to_exit = 0;
258 janitor_thread_create(&engine->
workers[threadCount]->thread_id, workerthreadclass, (janitor_runfn_t)
drudge, engine->
workers[threadCount]);
267 ods_log_assert(engine);
268 ods_log_assert(engine->
config);
269 ods_log_debug(
"[%s] stop workers and drudgers", engine_str);
271 for (i=0; i < numTotalWorkers; i++) {
272 engine->
workers[i]->need_to_exit = 1;
274 ods_log_debug(
"[%s] notify workers and drudgers", engine_str);
275 schedule_release_all(engine->
taskq);
277 for (i=0; i < numTotalWorkers; i++) {
278 ods_log_debug(
"[%s] join worker %d", engine_str, i+1);
279 janitor_thread_join(engine->
workers[i]->thread_id);
280 free(engine->
workers[i]->context);
293 ods_log_assert(engine);
294 ods_log_assert(engine->
config);
295 ods_log_debug(
"[%s] wake up workers", engine_str);
297 schedule_release_all(engine->
taskq);
301 signal_handler(sig_atomic_t sig)
334 ods_status status = ODS_STATUS_OK;
335 struct sigaction action;
336 int sockets[2] = {0,0};
341 ods_log_debug(
"[%s] setup signer engine", engine_str);
342 if (!engine || !engine->
config) {
343 return ODS_STATUS_ASSERT_ERR;
351 return ODS_STATUS_CMDHANDLER_ERR;
356 return ODS_STATUS_XFRHANDLER_ERR;
359 if (socketpair(AF_UNIX, SOCK_DGRAM, 0, sockets) == -1) {
360 return ODS_STATUS_XFRHANDLER_ERR;
365 if (status != ODS_STATUS_OK) {
366 ods_log_error(
"[%s] setup: unable to listen to sockets (%s)",
367 engine_str, ods_status2str(status));
368 return ODS_STATUS_XFRHANDLER_ERR;
384 ods_log_error(
"[%s] setup: unable to chdir to %s (%s)", engine_str,
386 return ODS_STATUS_CHDIR_ERR;
388 if (engine_privdrop(engine) != ODS_STATUS_OK) {
389 return ODS_STATUS_PRIVDROP_ERR;
394 ods_log_error(
"[%s] unable to pipe: %s", engine_str, strerror(errno));
395 return ODS_STATUS_PIPE_ERR;
397 switch ((engine->
pid = fork())) {
399 ods_log_error(
"[%s] setup: unable to fork daemon (%s)",
400 engine_str, strerror(errno));
401 return ODS_STATUS_FORK_ERR;
411 while (read(pipefd[0], &buff, 1) != -1) {
412 if (buff <= 1)
break;
417 ods_log_debug(
"[%s] signerd started successfully", engine_str);
420 ods_log_error(
"[%s] fail to start signerd completely", engine_str);
423 if (setsid() == -1) {
424 ods_log_error(
"[%s] setup: unable to setsid daemon (%s)",
425 engine_str, strerror(errno));
426 const char *err =
"unable to setsid daemon: ";
427 ods_writen(pipefd[1], err, strlen(err));
428 ods_writeln(pipefd[1], strerror(errno));
429 write(pipefd[1],
"\0", 1);
431 return ODS_STATUS_SETSID_ERR;
434 engine->
pid = getpid();
438 ods_writeln(pipefd[1],
"Unable to write pid file");
439 write(pipefd[1],
"\0", 1);
442 return ODS_STATUS_WRITE_PIDFILE_ERR;
445 ods_log_verbose(
"[%s] running as pid %lu", engine_str,
446 (
unsigned long) engine->
pid);
448 action.sa_handler = (void (*)(int))signal_handler;
449 sigfillset(&action.sa_mask);
451 sigaction(SIGTERM, &action, NULL);
452 sigaction(SIGHUP, &action, NULL);
453 sigaction(SIGINT, &action, NULL);
454 sigaction(SIGILL, &action, NULL);
455 sigaction(SIGUSR1, &action, NULL);
456 sigaction(SIGALRM, &action, NULL);
457 sigaction(SIGCHLD, &action, NULL);
458 action.sa_handler = SIG_IGN;
459 sigaction(SIGPIPE, &action, NULL);
461 engine_create_workers(engine);
463 engine_start_cmdhandler(engine);
464 engine_start_dnshandler(engine);
465 engine_start_xfrhandler(engine);
468 write(pipefd[1],
"\1", 1);
471 return ODS_STATUS_OK;
485 engine_start_workers(engine);
497 ods_log_debug(
"[%s] taking a break", engine_str);
502 ods_log_debug(
"[%s] signer halted", engine_str);
503 engine_stop_threads(engine);
512 set_notify_ns(
zone_type* zone,
const char* cmd)
514 const char* str = NULL;
515 const char* str2 = NULL;
518 ods_log_assert(zone);
519 ods_log_assert(zone->
name);
524 ods_log_error(
"[%s] unable to set notify ns: replace zonefile failed",
527 str2 = ods_replace(str,
"%zone", zone->
name);
530 str2 = ods_replace(cmd,
"%zone", zone->
name);
533 ods_str_trim((
char*) str2, 1);
537 while ((token = strtok((
char*) str,
" "))) {
546 ods_log_debug(
"[%s] set notify ns: %s", engine_str, zone->
notify_ns);
548 ods_log_error(
"[%s] unable to set notify ns: replace zone failed",
562 ods_log_assert(engine);
565 ods_log_assert(zone);
568 ods_log_assert(zone->
name);
573 ods_log_debug(
"[%s] add transfer handler for zone %s",
574 engine_str, zone->
name);
577 ods_log_assert(zone->xfrd);
579 &zone->xfrd->handler);
584 }
else if (zone->
xfrd) {
593 ods_log_debug(
"[%s] add notify handler for zone %s",
594 engine_str, zone->
name);
597 ods_log_assert(zone->notify);
599 &zone->notify->handler);
602 }
else if (zone->
notify) {
619 ldns_rbnode_t* node = LDNS_RBTREE_NULL;
621 ods_status status = ODS_STATUS_OK;
622 unsigned wake_up = 0;
629 ods_log_debug(
"[%s] commit zone list changes", engine_str);
632 while (node && node != LDNS_RBTREE_NULL) {
636 node = ldns_rbtree_next(node);
639 schedule_unscheduletask(engine->
taskq, schedule_WHATEVER, zone->
name);
656 if (status != ODS_STATUS_OK) {
657 ods_log_error(
"[%s] unable to load config for inbound adapter " 658 "for zone %s: %s", engine_str, zone->
name,
659 ods_status2str(status));
662 if (status != ODS_STATUS_OK) {
663 ods_log_error(
"[%s] unable to load config for outbound adapter " 664 "for zone %s: %s", engine_str, zone->
name,
665 ods_status2str(status));
668 warnings += dnsconfig_zone(engine, zone);
671 schedule_scheduletask(engine->
taskq, TASK_SIGNCONF, zone->
name, zone, &zone->
zone_lock, 0);
672 }
else if (zl_changed == ODS_STATUS_OK) {
673 schedule_scheduletask(engine->
taskq, TASK_FORCESIGNCONF, zone->
name, zone, &zone->
zone_lock, 0);
675 if (status != ODS_STATUS_OK) {
676 ods_log_crit(
"[%s] unable to schedule task for zone %s: %s",
677 engine_str, zone->
name, ods_status2str(status));
682 node = ldns_rbtree_next(node);
686 ods_log_debug(
"[%s] forward notify for all zones", engine_str);
689 }
else if (warnings) {
690 ods_log_warning(
"[%s] no dnshandler/listener configured, but zones " 691 "are configured with dns adapters: notify and zone transfer " 692 "requests will not work properly", engine_str);
707 ldns_rbnode_t* node = LDNS_RBTREE_NULL;
709 ods_status status = ODS_STATUS_OK;
710 ods_status result = ODS_STATUS_UNCHANGED;
713 ods_log_error(
"[%s] cannot recover zones: no engine or zonelist",
715 return ODS_STATUS_ERR;
717 ods_log_assert(engine);
724 while (node && node != LDNS_RBTREE_NULL) {
730 if (status == ODS_STATUS_OK) {
731 ods_log_assert(zone->
db);
737 if (status != ODS_STATUS_OK) {
738 ods_log_crit(
"[%s] unable to schedule task for zone %s: %s",
739 engine_str, zone->
name, ods_status2str(status));
740 result = ODS_STATUS_OK;
742 ods_log_debug(
"[%s] recovered zone %s", engine_str,
748 if (status != ODS_STATUS_UNCHANGED) {
749 ods_log_warning(
"[%s] unable to recover zone %s from backup," 750 " performing full sign", engine_str, zone->
name);
752 result = ODS_STATUS_OK;
755 node = ldns_rbtree_next(node);
768 engine_start(
const char* cfgfile,
int cmdline_verbosity,
int daemonize,
int info)
770 ods_status zl_changed = ODS_STATUS_UNCHANGED;
771 ods_status status = ODS_STATUS_OK;
773 engine = engine_create();
775 ods_fatal_exit(
"[%s] create failed", engine_str);
783 if (status != ODS_STATUS_OK) {
784 ods_log_error(
"[%s] cfgfile %s has errors", engine_str, cfgfile);
796 status = engine_setup();
797 if (status != ODS_STATUS_OK) {
798 ods_log_error(
"[%s] setup failed: %s", engine_str,
799 ods_status2str(status));
815 ods_log_info(
"[%s] signer reloading", engine_str);
818 ods_log_info(
"[%s] signer started (version %s), pid %u",
819 engine_str, PACKAGE_VERSION, engine->
pid);
821 char* error = hsm_get_error(NULL);
823 ods_log_error(
"[%s] %s",
"hsm", error);
826 ods_log_error(
"[%s] opening hsm failed (for engine recover)", engine_str);
829 zl_changed = engine_recover(engine);
832 if (zl_changed == ODS_STATUS_OK ||
833 zl_changed == ODS_STATUS_UNCHANGED) {
837 char* error = hsm_get_error(NULL);
839 ods_log_error(
"[%s] %s",
"hsm", error);
842 ods_log_error(
"[%s] opening hsm failed (for engine run)", engine_str);
850 ods_log_info(
"[%s] signer shutdown", engine_str);
852 engine_stop_xfrhandler(engine);
853 engine_stop_dnshandler(engine);
856 if (engine && engine->
config) {
888 for (i=0; i < (size_t) numTotalWorkers; i++) {
889 worker_cleanup(engine->
workers[i]);
894 schedule_cleanup(engine->
taskq);
void engine_config_cleanup(engineconfig_type *config)
void engine_config_print(FILE *out, engineconfig_type *config)
void tsig_handler_cleanup(void)
void zone_cleanup(zone_type *zone)
#define ODS_SE_NOTIFY_CMD
void engine_wakeup_workers(engine_type *engine)
time_t do_signzone(task_type *task, const char *zonename, void *zonearg, void *contextarg)
ods_status zone_recover2(engine_type *engine, zone_type *zone)
ods_status dnshandler_listen(dnshandler_type *dnshandler)
ods_status tsig_handler_init()
time_t do_forcereadzone(task_type *task, const char *zonename, void *zonearg, void *contextarg)
const char * zonelist_filename
void xfrhandler_cleanup(xfrhandler_type *xfrhandler)
void engine_update_zones(engine_type *engine, ods_status zl_changed)
janitor_thread_t thread_id
ods_status adapter_load_config(adapter_type *adapter)
xfrd_type * xfrd_create(xfrhandler_type *xfrhandler, zone_type *zone)
netio_handler_type dnshandler
pthread_cond_t signal_cond
void notify_cleanup(notify_type *notify)
janitor_thread_t thread_id
adapter_type * adoutbound
pthread_mutex_t zone_lock
void netio_add_handler(netio_type *netio, netio_handler_type *handler)
const char * log_filename
const char * clisock_filename
engineconfig_type * config
void dnshandler_signal(dnshandler_type *dnshandler)
xfrhandler_type * xfrhandler_create()
int engine_start(const char *cfgfile, int cmdline_verbosity, int daemonize, int info)
hsm_repository_t * repositories
void xfrhandler_start(xfrhandler_type *xfrhandler)
time_t do_forcereadsignconf(task_type *task, const char *zonename, void *zonearg, void *contextarg)
engineconfig_type * engine_config(const char *cfgfile, int cmdline_verbosity)
struct cmd_func_block ** signercommands
const char * notify_command
notify_type * notify_create(xfrhandler_type *xfrhandler, zone_type *zone)
void xfrd_cleanup(xfrd_type *xfrd, int backup)
void xfrhandler_signal(xfrhandler_type *xfrhandler)
#define EDNS_MAX_MESSAGE_LEN
cmdhandler_type * cmdhandler
void netio_remove_handler(netio_type *netio, netio_handler_type *handler)
time_t do_readsignconf(task_type *task, const char *zonename, void *zonearg, void *contextarg)
time_t do_writezone(task_type *task, const char *zonename, void *zonearg, void *contextarg)
netio_handler_type xfrhandler
pthread_mutex_t signal_lock
ods_status engine_config_check(engineconfig_type *config)
time_t do_readzone(task_type *task, const char *zonename, void *zonearg, void *contextarg)
void xfrd_set_timer_now(xfrd_type *xfrd)
void edns_init(edns_data_type *data, uint16_t max_length)
listener_type * interfaces
void zonelist_cleanup(zonelist_type *zl)
void engine_cleanup(engine_type *engine)
ods_status zonelist_update(zonelist_type *zl, const char *zlfile)
dnshandler_type * dnshandler_create(listener_type *interfaces)
void drudge(worker_type *worker)
void dnshandler_start(dnshandler_type *dnshandler)
netio_handler_type handler
netio_handler_type handler
void dnshandler_fwd_notify(dnshandler_type *dnshandler, uint8_t *pkt, size_t len)
zonelist_type * zonelist_create()
const char * pid_filename
time_t serial_disk_acquired
dnshandler_type * dnshandler
xfrhandler_type * xfrhandler
void zonelist_del_zone(zonelist_type *zlist, zone_type *zone)
void dnshandler_cleanup(dnshandler_type *dnshandler)