diff options
Diffstat (limited to 'usr.sbin/nsd/server.c')
| -rw-r--r-- | usr.sbin/nsd/server.c | 1409 |
1 files changed, 900 insertions, 509 deletions
diff --git a/usr.sbin/nsd/server.c b/usr.sbin/nsd/server.c index 7aecf03e650..33b3fb88666 100644 --- a/usr.sbin/nsd/server.c +++ b/usr.sbin/nsd/server.c @@ -1,7 +1,7 @@ /* * server.c -- nsd(8) network input/output * - * Copyright (c) 2001-2011, NLnet Labs. All rights reserved. + * Copyright (c) 2001-2006, NLnet Labs. All rights reserved. * * See LICENSE for the license. * @@ -33,6 +33,11 @@ #ifndef SHUT_WR #define SHUT_WR 1 #endif +#ifndef USE_MINI_EVENT +#include <event.h> +#else +#include "mini_event.h" +#endif #include <openssl/rand.h> @@ -41,12 +46,17 @@ #include "netio.h" #include "xfrd.h" #include "xfrd-tcp.h" +#include "xfrd-disk.h" #include "difffile.h" #include "nsec3.h" #include "ipc.h" +#include "udb.h" +#include "remote.h" #include "lookup3.h" #include "rrl.h" +#define RELOAD_SYNC_TIMEOUT 25 /* seconds */ + /* * Data for the UDP handlers. */ @@ -57,19 +67,33 @@ struct udp_handler_data query_type *query; }; -/* - * Data for the TCP accept handlers. Most data is simply passed along - * to the TCP connection handler. - */ struct tcp_accept_handler_data { struct nsd *nsd; struct nsd_socket *socket; - size_t tcp_accept_handler_count; - netio_handler_type *tcp_accept_handlers; + int event_added; + struct event event; }; -int slowaccept; -struct timespec slowaccept_timeout; +/* + * These globals are used to enable the TCP accept handlers + * when the number of TCP connection drops below the maximum + * number of TCP connections. + */ +static size_t tcp_accept_handler_count; +static struct tcp_accept_handler_data* tcp_accept_handlers; + +static struct event slowaccept_event; +static int slowaccept; + +#ifndef NONBLOCKING_IS_BROKEN +# define NUM_RECV_PER_SELECT 100 +#endif + +#if (!defined(NONBLOCKING_IS_BROKEN) && defined(HAVE_RECVMMSG)) +struct mmsghdr msgs[NUM_RECV_PER_SELECT]; +struct iovec iovecs[NUM_RECV_PER_SELECT]; +struct query *queries[NUM_RECV_PER_SELECT]; +#endif /* * Data for the TCP connection handlers. @@ -104,14 +128,6 @@ struct tcp_handler_data query_type* query; /* - * These fields are used to enable the TCP accept handlers - * when the number of TCP connection drops below the maximum - * number of TCP connections. - */ - size_t tcp_accept_handler_count; - netio_handler_type *tcp_accept_handlers; - - /* * The query_state is used to remember if we are performing an * AXFR, if we're done processing, or if we should discard the * query and connection. @@ -119,6 +135,11 @@ struct tcp_handler_data query_state_type query_state; /* + * The event for the file descriptor and tcp timeout + */ + struct event event; + + /* * The bytes_transmitted field is used to remember the number * of bytes transmitted when receiving or sending a DNS * packet. The count includes the two additional bytes used @@ -135,9 +156,7 @@ struct tcp_handler_data /* * Handle incoming queries on the UDP server sockets. */ -static void handle_udp(netio_type *netio, - netio_handler_type *handler, - netio_event_types_type event_types); +static void handle_udp(int fd, short event, void* arg); /* * Handle incoming connections on the TCP sockets. These handlers @@ -148,27 +167,21 @@ static void handle_udp(netio_type *netio, * NETIO_EVENT_NONE type. This is done using the function * configure_tcp_accept_handlers. */ -static void handle_tcp_accept(netio_type *netio, - netio_handler_type *handler, - netio_event_types_type event_types); +static void handle_tcp_accept(int fd, short event, void* arg); /* * Handle incoming queries on a TCP connection. The TCP connections * are configured to be non-blocking and the handler may be called * multiple times before a complete query is received. */ -static void handle_tcp_reading(netio_type *netio, - netio_handler_type *handler, - netio_event_types_type event_types); +static void handle_tcp_reading(int fd, short event, void* arg); /* * Handle outgoing responses on a TCP connection. The TCP connections * are configured to be non-blocking and the handler may be called * multiple times before a complete response is sent. */ -static void handle_tcp_writing(netio_type *netio, - netio_handler_type *handler, - netio_event_types_type event_types); +static void handle_tcp_writing(int fd, short event, void* arg); /* * Send all children the quit nonblocking, then close pipe. @@ -183,18 +196,9 @@ static void set_children_stats(struct nsd* nsd); #endif /* BIND8_STATS */ /* - * Change the event types the HANDLERS are interested in to - * EVENT_TYPES. + * Change the event types the HANDLERS are interested in to EVENT_TYPES. */ -static void configure_handler_event_types(size_t count, - netio_handler_type *handlers, - netio_event_types_type event_types); - -/* - * start xfrdaemon (again). - */ -static pid_t -server_start_xfrd(struct nsd *nsd, netio_handler_type* handler); +static void configure_handler_event_types(short event_types); static uint16_t *compressed_dname_offsets = 0; static uint32_t compression_table_capacity = 0; @@ -252,6 +256,9 @@ restart_child_servers(struct nsd *nsd, region_type* region, netio_type* netio, default: /* SERVER MAIN */ close(nsd->children[i].parent_fd); nsd->children[i].parent_fd = -1; + if (fcntl(nsd->children[i].child_fd, F_SETFL, O_NONBLOCK) == -1) { + log_msg(LOG_ERR, "cannot fcntl pipe: %s", strerror(errno)); + } if(!nsd->children[i].handler) { ipc_data = (struct main_ipc_handler_data*) region_alloc( @@ -265,8 +272,6 @@ restart_child_servers(struct nsd *nsd, region_type* region, netio_type* netio, ipc_data->got_bytes = 0; ipc_data->total_bytes = 0; ipc_data->acl_num = 0; - ipc_data->busy_writing_zone_state = 0; - ipc_data->write_conn = xfrd_tcp_create(region); nsd->children[i].handler = (struct netio_handler*) region_alloc( region, sizeof(struct netio_handler)); nsd->children[i].handler->fd = nsd->children[i].child_fd; @@ -280,25 +285,32 @@ restart_child_servers(struct nsd *nsd, region_type* region, netio_type* netio, ipc_data = (struct main_ipc_handler_data*) nsd->children[i].handler->user_data; ipc_data->forward_mode = 0; - ipc_data->busy_writing_zone_state = 0; /* restart - update fd */ nsd->children[i].handler->fd = nsd->children[i].child_fd; break; case 0: /* CHILD */ + /* the child need not be able to access the + * nsd.db file */ + namedb_close_udb(nsd->db); nsd->pid = 0; nsd->child_count = 0; nsd->server_kind = nsd->children[i].kind; nsd->this_child = &nsd->children[i]; /* remove signal flags inherited from parent the parent will handle them. */ + nsd->signal_hint_reload_hup = 0; nsd->signal_hint_reload = 0; nsd->signal_hint_child = 0; nsd->signal_hint_quit = 0; nsd->signal_hint_shutdown = 0; nsd->signal_hint_stats = 0; nsd->signal_hint_statsusr = 0; + close(*xfrd_sock_p); close(nsd->this_child->child_fd); nsd->this_child->child_fd = -1; + if (fcntl(nsd->this_child->parent_fd, F_SETFL, O_NONBLOCK) == -1) { + log_msg(LOG_ERR, "cannot fcntl pipe: %s", strerror(errno)); + } server_child(nsd); /* NOTREACH */ exit(0); @@ -384,6 +396,60 @@ server_init(struct nsd *nsd) return -1; } +#if defined(SO_RCVBUF) || defined(SO_SNDBUF) + if(1) { + int rcv = 1*1024*1024; + int snd = 1*1024*1024; + +#ifdef SO_RCVBUF +# ifdef SO_RCVBUFFORCE + if(setsockopt(nsd->udp[i].s, SOL_SOCKET, SO_RCVBUFFORCE, (void*)&rcv, + (socklen_t)sizeof(rcv)) < 0) { + if(errno != EPERM && errno != ENOBUFS) { + log_msg(LOG_ERR, "setsockopt(..., SO_RCVBUFFORCE, " + "...) failed: %s", strerror(errno)); + return -1; + } +# else + if(1) { +# endif /* SO_RCVBUFFORCE */ + if(setsockopt(nsd->udp[i].s, SOL_SOCKET, SO_RCVBUF, (void*)&rcv, + (socklen_t)sizeof(rcv)) < 0) { + if(errno != ENOBUFS) { + log_msg(LOG_ERR, "setsockopt(..., SO_RCVBUF, " + "...) failed: %s", strerror(errno)); + return -1; + } + } + } +#endif /* SO_RCVBUF */ + +#ifdef SO_SNDBUF +# ifdef SO_SNDBUFFORCE + if(setsockopt(nsd->udp[i].s, SOL_SOCKET, SO_SNDBUFFORCE, (void*)&snd, + (socklen_t)sizeof(snd)) < 0) { + if(errno != EPERM && errno != ENOBUFS) { + log_msg(LOG_ERR, "setsockopt(..., SO_SNDBUFFORCE, " + "...) failed: %s", strerror(errno)); + return -1; + } +# else + if(1) { +# endif /* SO_SNDBUFFORCE */ + if(setsockopt(nsd->udp[i].s, SOL_SOCKET, SO_SNDBUF, (void*)&snd, + (socklen_t)sizeof(snd)) < 0) { + if(errno != ENOBUFS) { + log_msg(LOG_ERR, "setsockopt(..., SO_SNDBUF, " + "...) failed: %s", strerror(errno)); + return -1; + } + } + } +#endif /* SO_SNDBUF */ + + } +#endif /* defined(SO_RCVBUF) || defined(SO_SNDBUF) */ + #if defined(INET6) if (nsd->udp[i].addr->ai_family == AF_INET6) { # if defined(IPV6_V6ONLY) @@ -596,21 +662,19 @@ server_prepare(struct nsd *nsd) #endif /* RATELIMIT */ /* Open the database... */ - if ((nsd->db = namedb_open(nsd->dbfile, nsd->options, nsd->child_count)) == NULL) { + if ((nsd->db = namedb_open(nsd->dbfile, nsd->options)) == NULL) { log_msg(LOG_ERR, "unable to open the database %s: %s", nsd->dbfile, strerror(errno)); + unlink(nsd->task[0]->fname); + unlink(nsd->task[1]->fname); + xfrd_del_tempdir(nsd); return -1; } - - /* Read diff file */ - if(!diff_read_file(nsd->db, nsd->options, NULL, nsd->child_count)) { - log_msg(LOG_ERR, "The diff file contains errors. Will continue " - "without it"); - } - -#ifdef NSEC3 - prehash(nsd->db, 0); -#endif + /* check if zone files have been modified */ + /* NULL for taskudb because we send soainfo in a moment, batched up, + * for all zones */ + if(nsd->options->zonefiles_check) + namedb_check_zonefiles(nsd->db, nsd->options, NULL, NULL); compression_table_capacity = 0; initialize_dname_compression_tables(nsd); @@ -685,62 +749,199 @@ server_shutdown(struct nsd *nsd) } } - log_finalize(); tsig_finalize(); +#ifdef HAVE_SSL + daemon_remote_delete(nsd->rc); /* ssl-delete secret keys */ +#endif +#if 0 /* OS collects memory pages */ nsd_options_destroy(nsd->options); region_destroy(nsd->region); - +#endif + log_finalize(); exit(0); } -static pid_t -server_start_xfrd(struct nsd *nsd, netio_handler_type* handler) +void +server_prepare_xfrd(struct nsd* nsd) +{ + char tmpfile[256]; + /* create task mmaps */ + nsd->mytask = 0; + snprintf(tmpfile, sizeof(tmpfile), "%snsd.%u.task.0", + nsd->options->xfrdir, (unsigned)getpid()); + nsd->task[0] = task_file_create(tmpfile); + if(!nsd->task[0]) + exit(1); + snprintf(tmpfile, sizeof(tmpfile), "%snsd.%u.task.1", + nsd->options->xfrdir, (unsigned)getpid()); + nsd->task[1] = task_file_create(tmpfile); + if(!nsd->task[1]) { + unlink(nsd->task[0]->fname); + exit(1); + } + assert(udb_base_get_userdata(nsd->task[0])->data == 0); + assert(udb_base_get_userdata(nsd->task[1])->data == 0); + /* create xfrd listener structure */ + nsd->xfrd_listener = region_alloc(nsd->region, + sizeof(netio_handler_type)); + nsd->xfrd_listener->user_data = (struct ipc_handler_conn_data*) + region_alloc(nsd->region, sizeof(struct ipc_handler_conn_data)); + nsd->xfrd_listener->fd = -1; + ((struct ipc_handler_conn_data*)nsd->xfrd_listener->user_data)->nsd = + nsd; + ((struct ipc_handler_conn_data*)nsd->xfrd_listener->user_data)->conn = + xfrd_tcp_create(nsd->region, QIOBUFSZ); +} + + +void +server_start_xfrd(struct nsd *nsd, int del_db, int reload_active) { pid_t pid; int sockets[2] = {0,0}; - zone_type* zone; struct ipc_handler_conn_data *data; - /* no need to send updates for zones, because xfrd will read from fork-memory */ - for(zone = nsd->db->zones; zone; zone=zone->next) { - zone->updated = 0; - } - if(handler->fd != -1) - close(handler->fd); + if(nsd->xfrd_listener->fd != -1) + close(nsd->xfrd_listener->fd); + if(del_db) { + /* recreate taskdb that xfrd was using, it may be corrupt */ + /* we (or reload) use nsd->mytask, and xfrd uses the other */ + char* tmpfile = nsd->task[1-nsd->mytask]->fname; + nsd->task[1-nsd->mytask]->fname = NULL; + /* free alloc already, so udb does not shrink itself */ + udb_alloc_delete(nsd->task[1-nsd->mytask]->alloc); + nsd->task[1-nsd->mytask]->alloc = NULL; + udb_base_free(nsd->task[1-nsd->mytask]); + /* create new file, overwrite the old one */ + nsd->task[1-nsd->mytask] = task_file_create(tmpfile); + free(tmpfile); + } if (socketpair(AF_UNIX, SOCK_STREAM, 0, sockets) == -1) { log_msg(LOG_ERR, "startxfrd failed on socketpair: %s", strerror(errno)); - return -1; + return; } pid = fork(); switch (pid) { case -1: log_msg(LOG_ERR, "fork xfrd failed: %s", strerror(errno)); break; - case 0: - /* CHILD: close first socket, use second one */ + default: + /* PARENT: close first socket, use second one */ close(sockets[0]); - xfrd_init(sockets[1], nsd); + if (fcntl(sockets[1], F_SETFL, O_NONBLOCK) == -1) { + log_msg(LOG_ERR, "cannot fcntl pipe: %s", strerror(errno)); + } + if(del_db) xfrd_free_namedb(nsd); + /* use other task than I am using, since if xfrd died and is + * restarted, the reload is using nsd->mytask */ + nsd->mytask = 1 - nsd->mytask; + xfrd_init(sockets[1], nsd, del_db, reload_active); /* ENOTREACH */ break; - default: - /* PARENT: close second socket, use first one */ + case 0: + /* CHILD: close second socket, use first one */ close(sockets[1]); - handler->fd = sockets[0]; + if (fcntl(sockets[0], F_SETFL, O_NONBLOCK) == -1) { + log_msg(LOG_ERR, "cannot fcntl pipe: %s", strerror(errno)); + } + nsd->xfrd_listener->fd = sockets[0]; break; } - /* PARENT only */ - handler->timeout = NULL; - handler->event_types = NETIO_EVENT_READ; - handler->event_handler = parent_handle_xfrd_command; + /* server-parent only */ + nsd->xfrd_listener->timeout = NULL; + nsd->xfrd_listener->event_types = NETIO_EVENT_READ; + nsd->xfrd_listener->event_handler = parent_handle_xfrd_command; /* clear ongoing ipc reads */ - data = (struct ipc_handler_conn_data *) handler->user_data; + data = (struct ipc_handler_conn_data *) nsd->xfrd_listener->user_data; data->conn->is_reading = 0; - return pid; +} + +/** add all soainfo to taskdb */ +static void +add_all_soa_to_task(struct nsd* nsd, struct udb_base* taskudb) +{ + struct radnode* n; + udb_ptr task_last; /* last task, mytask is empty so NULL */ + /* add all SOA INFO to mytask */ + udb_ptr_init(&task_last, taskudb); + for(n=radix_first(nsd->db->zonetree); n; n=radix_next(n)) { + task_new_soainfo(taskudb, &task_last, (zone_type*)n->elem); + } + udb_ptr_unlink(&task_last, taskudb); +} + +void +server_send_soa_xfrd(struct nsd* nsd, int shortsoa) +{ + /* normally this exchanges the SOA from nsd->xfrd and the expire back. + * parent fills one taskdb with soas, xfrd fills other with expires. + * then they exchange and process. + * shortsoa: xfrd crashes and needs to be restarted and one taskdb + * may be in use by reload. Fill SOA in taskdb and give to xfrd. + * expire notifications can be sent back via a normal reload later + * (xfrd will wait for current running reload to finish if any). + */ + sig_atomic_t cmd = 0; +#ifdef BIND8_STATS + pid_t mypid; +#endif + int xfrd_sock = nsd->xfrd_listener->fd; + struct udb_base* taskudb = nsd->task[nsd->mytask]; + udb_ptr t; + if(shortsoa) { + /* put SOA in xfrd task because mytask may be in use */ + taskudb = nsd->task[1-nsd->mytask]; + } + + add_all_soa_to_task(nsd, taskudb); + if(!shortsoa) { + /* wait for xfrd to signal task is ready, RELOAD signal */ + if(block_read(nsd, xfrd_sock, &cmd, sizeof(cmd), -1) != sizeof(cmd) || + cmd != NSD_RELOAD) { + log_msg(LOG_ERR, "did not get start signal from xfrd"); + exit(1); + } + } + /* give xfrd our task, signal it with RELOAD_DONE */ + task_process_sync(taskudb); + cmd = NSD_RELOAD_DONE; + if(!write_socket(xfrd_sock, &cmd, sizeof(cmd))) { + log_msg(LOG_ERR, "problems sending soa end from reload %d to xfrd: %s", + (int)nsd->pid, strerror(errno)); + } +#ifdef BIND8_STATS + mypid = getpid(); + if(!write_socket(nsd->xfrd_listener->fd, &mypid, sizeof(mypid))) { + log_msg(LOG_ERR, "problems sending reloadpid to xfrd: %s", + strerror(errno)); + } +#endif + + if(!shortsoa) { + /* process the xfrd task works (expiry data) */ + nsd->mytask = 1 - nsd->mytask; + taskudb = nsd->task[nsd->mytask]; + task_remap(taskudb); + udb_ptr_new(&t, taskudb, udb_base_get_userdata(taskudb)); + while(!udb_ptr_is_null(&t)) { + task_process_expire(nsd->db, TASKLIST(&t)); + udb_ptr_set_rptr(&t, taskudb, &TASKLIST(&t)->next); + } + udb_ptr_unlink(&t, taskudb); + task_clear(taskudb); + + /* tell xfrd that the task is emptied, signal with RELOAD_DONE */ + cmd = NSD_RELOAD_DONE; + if(!write_socket(xfrd_sock, &cmd, sizeof(cmd))) { + log_msg(LOG_ERR, "problems sending soa end from reload %d to xfrd: %s", + (int)nsd->pid, strerror(errno)); + } + } } /* pass timeout=-1 for blocking. Returns size, 0, -1(err), or -2(timeout) */ -static ssize_t +ssize_t block_read(struct nsd* nsd, int s, void* p, ssize_t sz, int timeout) { uint8_t* buf = (uint8_t*) p; @@ -795,58 +996,121 @@ block_read(struct nsd* nsd, int s, void* p, ssize_t sz, int timeout) return total; } +static void +reload_process_tasks(struct nsd* nsd, udb_ptr* last_task, int cmdsocket) +{ + sig_atomic_t cmd = NSD_QUIT_SYNC; + udb_ptr t, next; + udb_base* u = nsd->task[nsd->mytask]; + udb_ptr_init(&next, u); + udb_ptr_new(&t, u, udb_base_get_userdata(u)); + udb_base_set_userdata(u, 0); + while(!udb_ptr_is_null(&t)) { + /* store next in list so this one can be deleted or reused */ + udb_ptr_set_rptr(&next, u, &TASKLIST(&t)->next); + udb_rptr_zero(&TASKLIST(&t)->next, u); + + /* process task t */ + /* append results for task t and update last_task */ + task_process_in_reload(nsd, u, last_task, &t); + + /* go to next */ + udb_ptr_set_ptr(&t, u, &next); + + /* if the parent has quit, we must quit too, poll the fd for cmds */ + if(block_read(nsd, cmdsocket, &cmd, sizeof(cmd), 0) == sizeof(cmd)) { + DEBUG(DEBUG_IPC,1, (LOG_INFO, "reload: ipc command from main %d", (int)cmd)); + if(cmd == NSD_QUIT) { + DEBUG(DEBUG_IPC,1, (LOG_INFO, "reload: quit to follow nsd")); + /* sync to disk (if needed) */ + udb_base_sync(nsd->db->udb, 0); + /* unlink files of remainder of tasks */ + while(!udb_ptr_is_null(&t)) { + if(TASKLIST(&t)->task_type == task_apply_xfr) { + xfrd_unlink_xfrfile(nsd, TASKLIST(&t)->yesno); + } + udb_ptr_set_rptr(&t, u, &TASKLIST(&t)->next); + } + udb_ptr_unlink(&t, u); + udb_ptr_unlink(&next, u); + exit(0); + } + } + + } + udb_ptr_unlink(&t, u); + udb_ptr_unlink(&next, u); +} + +#ifdef BIND8_STATS +static void +parent_send_stats(struct nsd* nsd, int cmdfd) +{ + size_t i; + if(!write_socket(cmdfd, &nsd->st, sizeof(nsd->st))) { + log_msg(LOG_ERR, "could not write stats to reload"); + return; + } + for(i=0; i<nsd->child_count; i++) + if(!write_socket(cmdfd, &nsd->children[i].query_count, + sizeof(stc_t))) { + log_msg(LOG_ERR, "could not write stats to reload"); + return; + } +} + +static void +reload_do_stats(int cmdfd, struct nsd* nsd, udb_ptr* last) +{ + struct nsdst s; + stc_t* p; + size_t i; + if(block_read(nsd, cmdfd, &s, sizeof(s), + RELOAD_SYNC_TIMEOUT) != sizeof(s)) { + log_msg(LOG_ERR, "could not read stats from oldpar"); + return; + } + s.db_disk = nsd->db->udb->base_size; + s.db_mem = region_get_mem(nsd->db->region); + p = (stc_t*)task_new_stat_info(nsd->task[nsd->mytask], last, &s, + nsd->child_count); + if(!p) return; + for(i=0; i<nsd->child_count; i++) { + if(block_read(nsd, cmdfd, p++, sizeof(stc_t), 1)!=sizeof(stc_t)) + return; + } +} +#endif /* BIND8_STATS */ + /* * Reload the database, stop parent, re-fork children and continue. * as server_main. */ static void server_reload(struct nsd *nsd, region_type* server_region, netio_type* netio, - int cmdsocket, int* xfrd_sock_p) + int cmdsocket) { - pid_t old_pid; +#ifdef BIND8_STATS + pid_t mypid; +#endif sig_atomic_t cmd = NSD_QUIT_SYNC; - zone_type* zone; - int xfrd_sock = *xfrd_sock_p; int ret; + udb_ptr last_task; + + /* see what tasks we got from xfrd */ + task_remap(nsd->task[nsd->mytask]); + udb_ptr_init(&last_task, nsd->task[nsd->mytask]); + reload_process_tasks(nsd, &last_task, cmdsocket); - if(db_crc_different(nsd->db) == 0) { - DEBUG(DEBUG_XFRD,1, (LOG_INFO, - "CRC the same. skipping %s.", nsd->db->filename)); - } else { - DEBUG(DEBUG_XFRD,1, (LOG_INFO, - "CRC different. reread of %s.", nsd->db->filename)); - namedb_close(nsd->db); - if ((nsd->db = namedb_open(nsd->dbfile, nsd->options, - nsd->child_count)) == NULL) { - log_msg(LOG_ERR, "unable to reload the database: %s", strerror(errno)); - exit(1); - } -#if defined(NSEC3) && !defined(FULL_PREHASH) - prehash(nsd->db, 0); -#endif - } - if(!diff_read_file(nsd->db, nsd->options, NULL, nsd->child_count)) { - log_msg(LOG_ERR, "unable to load the diff file: %s", nsd->options->difffile); - exit(1); - } - log_msg(LOG_INFO, "memory recyclebin holds %lu bytes", (unsigned long) - region_get_recycle_size(nsd->db->region)); #ifndef NDEBUG if(nsd_debug_level >= 1) region_log_stats(nsd->db->region); #endif /* NDEBUG */ -#ifdef NSEC3 -#ifdef FULL_PREHASH - prehash(nsd->db, 1); -#endif /* FULL_PREHASH */ -#endif /* NSEC3 */ + /* sync to disk (if needed) */ + udb_base_sync(nsd->db->udb, 0); initialize_dname_compression_tables(nsd); - /* Get our new process id */ - old_pid = nsd->pid; - nsd->pid = getpid(); - #ifdef BIND8_STATS /* Restart dumping stats if required. */ time(&nsd->st.boot); @@ -854,38 +1118,29 @@ server_reload(struct nsd *nsd, region_type* server_region, netio_type* netio, #endif /* Start new child processes */ - if (server_start_children(nsd, server_region, netio, xfrd_sock_p) != 0) { - send_children_quit(nsd); /* no wait required */ + if (server_start_children(nsd, server_region, netio, &nsd-> + xfrd_listener->fd) != 0) { + send_children_quit(nsd); exit(1); } /* if the parent has quit, we must quit too, poll the fd for cmds */ if(block_read(nsd, cmdsocket, &cmd, sizeof(cmd), 0) == sizeof(cmd)) { - DEBUG(DEBUG_IPC,1, (LOG_INFO, "reload: ipc command from main %d", cmd)); + DEBUG(DEBUG_IPC,1, (LOG_INFO, "reload: ipc command from main %d", (int)cmd)); if(cmd == NSD_QUIT) { DEBUG(DEBUG_IPC,1, (LOG_INFO, "reload: quit to follow nsd")); - send_children_quit(nsd); /* no wait required */ + send_children_quit(nsd); exit(0); } } - /* Overwrite pid before closing old parent, to avoid race condition: - * - parent process already closed - * - pidfile still contains old_pid - * - control script contacts parent process, using contents of pidfile - */ - if (writepid(nsd) == -1) { - log_msg(LOG_ERR, "cannot overwrite the pidfile %s: %s", nsd->pidfile, strerror(errno)); - } - -#define RELOAD_SYNC_TIMEOUT 25 /* seconds */ /* Send quit command to parent: blocking, wait for receipt. */ do { DEBUG(DEBUG_IPC,1, (LOG_INFO, "reload: ipc send quit to main")); if (!write_socket(cmdsocket, &cmd, sizeof(cmd))) { - log_msg(LOG_ERR, "problems sending command from reload %d to oldnsd %d: %s", - (int)nsd->pid, (int)old_pid, strerror(errno)); + log_msg(LOG_ERR, "problems sending command from reload to oldnsd: %s", + strerror(errno)); } /* blocking: wait for parent to really quit. (it sends RELOAD as ack) */ DEBUG(DEBUG_IPC,1, (LOG_INFO, "reload: ipc wait for ack main")); @@ -903,77 +1158,29 @@ server_reload(struct nsd *nsd, region_type* server_region, netio_type* netio, if(cmd == NSD_QUIT) { /* small race condition possible here, parent got quit cmd. */ send_children_quit(nsd); - unlinkpid(nsd->pidfile); exit(1); } assert(ret==-1 || ret == 0 || cmd == NSD_RELOAD); - - /* inform xfrd of new SOAs */ - cmd = NSD_SOA_BEGIN; - if(!write_socket(xfrd_sock, &cmd, sizeof(cmd))) { - log_msg(LOG_ERR, "problems sending soa begin from reload %d to xfrd: %s", - (int)nsd->pid, strerror(errno)); - } - for(zone= nsd->db->zones; zone; zone = zone->next) { - uint16_t sz; - const dname_type *dname_ns=0, *dname_em=0; - if(zone->updated == 0) - continue; - DEBUG(DEBUG_IPC,1, (LOG_INFO, "nsd: sending soa info for zone %s", - dname_to_string(domain_dname(zone->apex),0))); - cmd = NSD_SOA_INFO; - sz = dname_total_size(domain_dname(zone->apex)); - if(zone->soa_rrset) { - dname_ns = domain_dname( - rdata_atom_domain(zone->soa_rrset->rrs[0].rdatas[0])); - dname_em = domain_dname( - rdata_atom_domain(zone->soa_rrset->rrs[0].rdatas[1])); - sz += sizeof(uint32_t)*6 + sizeof(uint8_t)*2 - + dname_ns->name_size + dname_em->name_size; - } - sz = htons(sz); - /* use blocking writes */ - if(!write_socket(xfrd_sock, &cmd, sizeof(cmd)) || - !write_socket(xfrd_sock, &sz, sizeof(sz)) || - !write_socket(xfrd_sock, domain_dname(zone->apex), - dname_total_size(domain_dname(zone->apex)))) - { - log_msg(LOG_ERR, "problems sending soa info from reload %d to xfrd: %s", - (int)nsd->pid, strerror(errno)); - } - if(zone->soa_rrset) { - uint32_t ttl = htonl(zone->soa_rrset->rrs[0].ttl); - assert(dname_ns && dname_em); - assert(zone->soa_rrset->rr_count > 0); - assert(rrset_rrtype(zone->soa_rrset) == TYPE_SOA); - assert(zone->soa_rrset->rrs[0].rdata_count == 7); - if(!write_socket(xfrd_sock, &ttl, sizeof(uint32_t)) - || !write_socket(xfrd_sock, &dname_ns->name_size, sizeof(uint8_t)) - || !write_socket(xfrd_sock, dname_name(dname_ns), dname_ns->name_size) - || !write_socket(xfrd_sock, &dname_em->name_size, sizeof(uint8_t)) - || !write_socket(xfrd_sock, dname_name(dname_em), dname_em->name_size) - || !write_socket(xfrd_sock, rdata_atom_data( - zone->soa_rrset->rrs[0].rdatas[2]), sizeof(uint32_t)) - || !write_socket(xfrd_sock, rdata_atom_data( - zone->soa_rrset->rrs[0].rdatas[3]), sizeof(uint32_t)) - || !write_socket(xfrd_sock, rdata_atom_data( - zone->soa_rrset->rrs[0].rdatas[4]), sizeof(uint32_t)) - || !write_socket(xfrd_sock, rdata_atom_data( - zone->soa_rrset->rrs[0].rdatas[5]), sizeof(uint32_t)) - || !write_socket(xfrd_sock, rdata_atom_data( - zone->soa_rrset->rrs[0].rdatas[6]), sizeof(uint32_t))) - { - log_msg(LOG_ERR, "problems sending soa info from reload %d to xfrd: %s", - (int)nsd->pid, strerror(errno)); - } - } - zone->updated = 0; +#ifdef BIND8_STATS + reload_do_stats(cmdsocket, nsd, &last_task); +#endif + udb_ptr_unlink(&last_task, nsd->task[nsd->mytask]); + task_process_sync(nsd->task[nsd->mytask]); + + /* send soainfo to the xfrd process, signal it that reload is done, + * it picks up the taskudb */ + cmd = NSD_RELOAD_DONE; + if(!write_socket(nsd->xfrd_listener->fd, &cmd, sizeof(cmd))) { + log_msg(LOG_ERR, "problems sending reload_done xfrd: %s", + strerror(errno)); } - cmd = NSD_SOA_END; - if(!write_socket(xfrd_sock, &cmd, sizeof(cmd))) { - log_msg(LOG_ERR, "problems sending soa end from reload %d to xfrd: %s", - (int)nsd->pid, strerror(errno)); +#ifdef BIND8_STATS + mypid = getpid(); + if(!write_socket(nsd->xfrd_listener->fd, &mypid, sizeof(mypid))) { + log_msg(LOG_ERR, "problems sending reloadpid to xfrd: %s", + strerror(errno)); } +#endif /* try to reopen file */ if (nsd->file_rotation_ok) @@ -1004,6 +1211,10 @@ server_signal_mode(struct nsd *nsd) nsd->signal_hint_reload = 0; return NSD_RELOAD; } + else if(nsd->signal_hint_reload_hup) { + nsd->signal_hint_reload_hup = 0; + return NSD_RELOAD_REQ; + } else if(nsd->signal_hint_stats) { nsd->signal_hint_stats = 0; #ifdef BIND8_STATS @@ -1028,37 +1239,23 @@ server_main(struct nsd *nsd) region_type *server_region = region_create(xalloc, free); netio_type *netio = netio_create(server_region); netio_handler_type reload_listener; - netio_handler_type xfrd_listener; int reload_sockets[2] = {-1, -1}; struct timespec timeout_spec; - int fd; int status; pid_t child_pid; pid_t reload_pid = -1; - pid_t xfrd_pid = -1; sig_atomic_t mode; -#ifdef RATELIMIT - rrl_init((nsd->this_child - nsd->children)/sizeof(nsd->children[0])); -#endif - /* Ensure we are the main process */ assert(nsd->server_kind == NSD_SERVER_MAIN); - xfrd_listener.user_data = (struct ipc_handler_conn_data*)region_alloc( - server_region, sizeof(struct ipc_handler_conn_data)); - xfrd_listener.fd = -1; - ((struct ipc_handler_conn_data*)xfrd_listener.user_data)->nsd = nsd; - ((struct ipc_handler_conn_data*)xfrd_listener.user_data)->conn = - xfrd_tcp_create(server_region); - - /* Start the XFRD process */ - xfrd_pid = server_start_xfrd(nsd, &xfrd_listener); - netio_add_handler(netio, &xfrd_listener); + /* Add listener for the XFRD process */ + netio_add_handler(netio, nsd->xfrd_listener); /* Start the child processes that handle incoming queries */ - if (server_start_children(nsd, server_region, netio, &xfrd_listener.fd) != 0) { - send_children_quit(nsd); /* no wait required */ + if (server_start_children(nsd, server_region, netio, + &nsd->xfrd_listener->fd) != 0) { + send_children_quit(nsd); exit(1); } reload_listener.fd = -1; @@ -1087,27 +1284,34 @@ server_main(struct nsd *nsd) "server %d died unexpectedly with status %d, restarting", (int) child_pid, status); restart_child_servers(nsd, server_region, netio, - &xfrd_listener.fd); + &nsd->xfrd_listener->fd); } else if (child_pid == reload_pid) { - sig_atomic_t cmd = NSD_SOA_END; + sig_atomic_t cmd = NSD_RELOAD_DONE; +#ifdef BIND8_STATS + pid_t mypid; +#endif log_msg(LOG_WARNING, "Reload process %d failed with status %d, continuing with old database", (int) child_pid, status); reload_pid = -1; - if(reload_listener.fd > 0) close(reload_listener.fd); + if(reload_listener.fd != -1) close(reload_listener.fd); reload_listener.fd = -1; reload_listener.event_types = NETIO_EVENT_NONE; + task_process_sync(nsd->task[nsd->mytask]); /* inform xfrd reload attempt ended */ - if(!write_socket(xfrd_listener.fd, &cmd, sizeof(cmd))) { + if(!write_socket(nsd->xfrd_listener->fd, + &cmd, sizeof(cmd)) == -1) { log_msg(LOG_ERR, "problems " "sending SOAEND to xfrd: %s", strerror(errno)); } - } else if (child_pid == xfrd_pid) { - log_msg(LOG_WARNING, - "xfrd process %d failed with status %d, restarting ", - (int) child_pid, status); - xfrd_pid = server_start_xfrd(nsd, &xfrd_listener); +#ifdef BIND8_STATS + mypid = getpid(); + if(!write_socket(nsd->xfrd_listener->fd, &mypid, sizeof(mypid))) { + log_msg(LOG_ERR, "problems sending reloadpid to xfrd: %s", + strerror(errno)); + } +#endif } else { log_msg(LOG_WARNING, "Unknown child %d terminated with status %d", @@ -1135,18 +1339,30 @@ server_main(struct nsd *nsd) } break; + case NSD_RELOAD_REQ: { + sig_atomic_t cmd = NSD_RELOAD_REQ; + log_msg(LOG_WARNING, "SIGHUP received, reloading..."); + DEBUG(DEBUG_IPC,1, (LOG_INFO, + "main: ipc send reload_req to xfrd")); + if(!write_socket(nsd->xfrd_listener->fd, + &cmd, sizeof(cmd))) { + log_msg(LOG_ERR, "server_main: could not send " + "reload_req to xfrd: %s", strerror(errno)); + } + nsd->mode = NSD_RUN; + } break; case NSD_RELOAD: /* Continue to run nsd after reload */ nsd->mode = NSD_RUN; - + DEBUG(DEBUG_IPC,1, (LOG_INFO, "reloading...")); if (reload_pid != -1) { log_msg(LOG_WARNING, "Reload already in progress (pid = %d)", (int) reload_pid); break; } - log_msg(LOG_WARNING, "signal received, reloading..."); - + /* switch the mytask to keep track of who owns task*/ + nsd->mytask = 1 - nsd->mytask; if (socketpair(AF_UNIX, SOCK_STREAM, 0, reload_sockets) == -1) { log_msg(LOG_ERR, "reload failed on socketpair: %s", strerror(errno)); reload_pid = -1; @@ -1163,12 +1379,13 @@ server_main(struct nsd *nsd) /* CHILD */ close(reload_sockets[0]); server_reload(nsd, server_region, netio, - reload_sockets[1], &xfrd_listener.fd); + reload_sockets[1]); DEBUG(DEBUG_IPC,2, (LOG_INFO, "Reload exited to become new main")); close(reload_sockets[1]); DEBUG(DEBUG_IPC,2, (LOG_INFO, "Reload closed")); /* drop stale xfrd ipc data */ - ((struct ipc_handler_conn_data*)xfrd_listener.user_data) + ((struct ipc_handler_conn_data*)nsd-> + xfrd_listener->user_data) ->conn->is_reading = 0; reload_pid = -1; reload_listener.fd = -1; @@ -1196,7 +1413,8 @@ server_main(struct nsd *nsd) /* stop xfrd ipc writes in progress */ DEBUG(DEBUG_IPC,1, (LOG_INFO, "main: ipc send indication reload")); - if(!write_socket(xfrd_listener.fd, &cmd, sizeof(cmd))) { + if(!write_socket(nsd->xfrd_listener->fd, + &cmd, sizeof(cmd))) { log_msg(LOG_ERR, "server_main: could not send reload " "indication to xfrd: %s", strerror(errno)); } @@ -1216,19 +1434,23 @@ server_main(struct nsd *nsd) log_msg(LOG_ERR, "server_main: " "could not ack quit: %s", strerror(errno)); } +#ifdef BIND8_STATS + parent_send_stats(nsd, reload_listener.fd); +#endif /* BIND8_STATS */ close(reload_listener.fd); } + DEBUG(DEBUG_IPC,1, (LOG_INFO, "server_main: shutdown sequence")); /* only quit children after xfrd has acked */ - send_children_quit(nsd); /* no wait required */ + send_children_quit(nsd); - namedb_fd_close(nsd->db); +#if 0 /* OS collects memory pages */ region_destroy(server_region); +#endif server_shutdown(nsd); /* ENOTREACH */ break; case NSD_SHUTDOWN: - send_children_quit_and_wait(nsd); log_msg(LOG_WARNING, "signal received, shutting down..."); break; case NSD_REAP_CHILDREN: @@ -1242,20 +1464,24 @@ server_main(struct nsd *nsd) nsd->mode = NSD_RUN; break; default: - log_msg(LOG_WARNING, "NSD main server mode invalid: %d", nsd->mode); + log_msg(LOG_WARNING, "NSD main server mode invalid: %d", (int)nsd->mode); nsd->mode = NSD_RUN; break; } } - /* Truncate the pid file. */ - if ((fd = open(nsd->pidfile, O_WRONLY | O_TRUNC, 0644)) == -1) { - log_msg(LOG_ERR, "can not truncate the pid file %s: %s", nsd->pidfile, strerror(errno)); - } else { - close(fd); - } + /* close opened ports to avoid race with restart of nsd */ + server_close_all_sockets(nsd->udp, nsd->ifs); + server_close_all_sockets(nsd->tcp, nsd->ifs); +#ifdef HAVE_SSL + daemon_remote_close(nsd->rc); +#endif + send_children_quit_and_wait(nsd); + /* Unlink it if possible... */ unlinkpid(nsd->pidfile); + unlink(nsd->task[0]->fname); + unlink(nsd->task[1]->fname); if(reload_listener.fd != -1) { sig_atomic_t cmd = NSD_QUIT; @@ -1268,22 +1494,24 @@ server_main(struct nsd *nsd) fsync(reload_listener.fd); close(reload_listener.fd); } - if(xfrd_listener.fd != -1) { + if(nsd->xfrd_listener->fd != -1) { /* complete quit, stop xfrd */ sig_atomic_t cmd = NSD_QUIT; DEBUG(DEBUG_IPC,1, (LOG_INFO, "main: ipc send quit to xfrd")); - if(!write_socket(xfrd_listener.fd, &cmd, sizeof(cmd))) { + if(!write_socket(nsd->xfrd_listener->fd, &cmd, sizeof(cmd))) { log_msg(LOG_ERR, "server_main: could not send quit to xfrd: %s", strerror(errno)); } - fsync(xfrd_listener.fd); - close(xfrd_listener.fd); - (void)kill(xfrd_pid, SIGTERM); + fsync(nsd->xfrd_listener->fd); + close(nsd->xfrd_listener->fd); + (void)kill(nsd->pid, SIGTERM); } + xfrd_del_tempdir(nsd); - namedb_fd_close(nsd->db); +#if 0 /* OS collects memory pages */ region_destroy(server_region); +#endif server_shutdown(nsd); } @@ -1293,6 +1521,44 @@ server_process_query(struct nsd *nsd, struct query *query) return query_process(query, nsd); } +static query_state_type +server_process_query_udp(struct nsd *nsd, struct query *query) +{ +#ifdef RATELIMIT + if(query_process(query, nsd) != QUERY_DISCARDED) { + if(rrl_process_query(query)) + return rrl_slip(query); + else return QUERY_PROCESSED; + } + return QUERY_DISCARDED; +#else + return query_process(query, nsd); +#endif +} + +struct event_base* +nsd_child_event_base(void) +{ + struct event_base* base; +#ifdef USE_MINI_EVENT + static time_t secs; + static struct timeval now; + base = event_init(&secs, &now); +#else +# if defined(HAVE_EV_LOOP) || defined(HAVE_EV_DEFAULT_LOOP) + /* libev */ + base = (struct event_base *)ev_default_loop(EVFLAG_AUTO); +# else + /* libevent */ +# ifdef HAVE_EVENT_BASE_NEW + base = event_base_new(); +# else + base = event_init(); +# endif +# endif +#endif + return base; +} /* * Serve DNS requests. @@ -1302,11 +1568,19 @@ server_child(struct nsd *nsd) { size_t i; region_type *server_region = region_create(xalloc, free); - netio_type *netio = netio_create(server_region); - netio_handler_type *tcp_accept_handlers; + struct event_base* event_base = nsd_child_event_base(); query_type *udp_query; sig_atomic_t mode; + if(!event_base) { + log_msg(LOG_ERR, "nsd server could not create event base"); + exit(1); + } + +#ifdef RATELIMIT + rrl_init((nsd->this_child - nsd->children)/sizeof(nsd->children[0])); +#endif + assert(nsd->server_kind != NSD_SERVER_MAIN); DEBUG(DEBUG_IPC, 2, (LOG_INFO, "child process started")); @@ -1318,29 +1592,45 @@ server_child(struct nsd *nsd) } if (nsd->this_child && nsd->this_child->parent_fd != -1) { - netio_handler_type *handler; - - handler = (netio_handler_type *) region_alloc( - server_region, sizeof(netio_handler_type)); - handler->fd = nsd->this_child->parent_fd; - handler->timeout = NULL; - handler->user_data = (struct ipc_handler_conn_data*)region_alloc( + struct event *handler; + struct ipc_handler_conn_data* user_data = + (struct ipc_handler_conn_data*)region_alloc( server_region, sizeof(struct ipc_handler_conn_data)); - ((struct ipc_handler_conn_data*)handler->user_data)->nsd = nsd; - ((struct ipc_handler_conn_data*)handler->user_data)->conn = - xfrd_tcp_create(server_region); - handler->event_types = NETIO_EVENT_READ; - handler->event_handler = child_handle_parent_command; - netio_add_handler(netio, handler); + user_data->nsd = nsd; + user_data->conn = xfrd_tcp_create(server_region, QIOBUFSZ); + + handler = (struct event*) region_alloc( + server_region, sizeof(*handler)); + event_set(handler, nsd->this_child->parent_fd, EV_PERSIST| + EV_READ, child_handle_parent_command, user_data); + if(event_base_set(event_base, handler) != 0) + log_msg(LOG_ERR, "nsd ipcchild: event_base_set failed"); + if(event_add(handler, NULL) != 0) + log_msg(LOG_ERR, "nsd ipcchild: event_add failed"); } if (nsd->server_kind & NSD_SERVER_UDP) { +#if (defined(NONBLOCKING_IS_BROKEN) || !defined(HAVE_RECVMMSG)) udp_query = query_create(server_region, compressed_dname_offsets, compression_table_size); - +#else + udp_query = NULL; + memset(msgs, 0, sizeof(msgs)); + for (i = 0; i < NUM_RECV_PER_SELECT; i++) { + queries[i] = query_create(server_region, + compressed_dname_offsets, compression_table_size); + query_reset(queries[i], UDP_MAX_MESSAGE_LEN, 0); + iovecs[i].iov_base = buffer_begin(queries[i]->packet); + iovecs[i].iov_len = buffer_remaining(queries[i]->packet);; + msgs[i].msg_hdr.msg_iov = &iovecs[i]; + msgs[i].msg_hdr.msg_iovlen = 1; + msgs[i].msg_hdr.msg_name = &queries[i]->addr; + msgs[i].msg_hdr.msg_namelen = queries[i]->addrlen; + } +#endif for (i = 0; i < nsd->ifs; ++i) { struct udp_handler_data *data; - netio_handler_type *handler; + struct event *handler; data = (struct udp_handler_data *) region_alloc( server_region, @@ -1349,14 +1639,14 @@ server_child(struct nsd *nsd) data->nsd = nsd; data->socket = &nsd->udp[i]; - handler = (netio_handler_type *) region_alloc( - server_region, sizeof(netio_handler_type)); - handler->fd = nsd->udp[i].s; - handler->timeout = NULL; - handler->user_data = data; - handler->event_types = NETIO_EVENT_READ; - handler->event_handler = handle_udp; - netio_add_handler(netio, handler); + handler = (struct event*) region_alloc( + server_region, sizeof(*handler)); + event_set(handler, nsd->udp[i].s, EV_PERSIST|EV_READ, + handle_udp, data); + if(event_base_set(event_base, handler) != 0) + log_msg(LOG_ERR, "nsd udp: event_base_set failed"); + if(event_add(handler, NULL) != 0) + log_msg(LOG_ERR, "nsd udp: event_add failed"); } } @@ -1365,30 +1655,25 @@ server_child(struct nsd *nsd) * and disable them based on the current number of active TCP * connections. */ - tcp_accept_handlers = (netio_handler_type *) region_alloc( - server_region, nsd->ifs * sizeof(netio_handler_type)); + tcp_accept_handler_count = nsd->ifs; + tcp_accept_handlers = (struct tcp_accept_handler_data*) region_alloc( + server_region, nsd->ifs * sizeof(*tcp_accept_handlers)); if (nsd->server_kind & NSD_SERVER_TCP) { for (i = 0; i < nsd->ifs; ++i) { - struct tcp_accept_handler_data *data; - netio_handler_type *handler; - - data = (struct tcp_accept_handler_data *) region_alloc( - server_region, - sizeof(struct tcp_accept_handler_data)); + struct event *handler = &tcp_accept_handlers[i].event; + struct tcp_accept_handler_data* data = + &tcp_accept_handlers[i]; data->nsd = nsd; data->socket = &nsd->tcp[i]; - data->tcp_accept_handler_count = nsd->ifs; - data->tcp_accept_handlers = tcp_accept_handlers; - - handler = &tcp_accept_handlers[i]; - handler->fd = nsd->tcp[i].s; - handler->timeout = NULL; - handler->user_data = data; - handler->event_types = NETIO_EVENT_READ | NETIO_EVENT_ACCEPT; - handler->event_handler = handle_tcp_accept; - netio_add_handler(netio, handler); + event_set(handler, nsd->tcp[i].s, EV_PERSIST|EV_READ, + handle_tcp_accept, data); + if(event_base_set(event_base, handler) != 0) + log_msg(LOG_ERR, "nsd tcp: event_base_set failed"); + if(event_add(handler, NULL) != 0) + log_msg(LOG_ERR, "nsd tcp: event_add failed"); + data->event_added = 1; } - } + } else tcp_accept_handler_count = 0; /* The main loop... */ while ((mode = nsd->mode) != NSD_QUIT) { @@ -1425,9 +1710,9 @@ server_child(struct nsd *nsd) } else if(mode == NSD_RUN) { /* Wait for a query... */ - if (netio_dispatch(netio, NULL, NULL) == -1) { + if(event_base_loop(event_base, EVLOOP_ONCE) == -1) { if (errno != EINTR) { - log_msg(LOG_ERR, "netio_dispatch failed: %s", strerror(errno)); + log_msg(LOG_ERR, "dispatch failed: %s", strerror(errno)); break; } } @@ -1435,7 +1720,7 @@ server_child(struct nsd *nsd) /* ignore here, quit */ } else { log_msg(LOG_ERR, "mode bad value %d, back to service.", - mode); + (int)mode); nsd->mode = NSD_RUN; } } @@ -1444,96 +1729,208 @@ server_child(struct nsd *nsd) bind8_stats(nsd); #endif /* BIND8_STATS */ - namedb_fd_close(nsd->db); +#if 0 /* OS collects memory pages */ + event_base_free(event_base); region_destroy(server_region); - server_shutdown(nsd); -} - -static query_state_type -server_process_query_udp(struct nsd *nsd, struct query *query) -{ -#ifdef RATELIMIT - if(query_process(query, nsd) != QUERY_DISCARDED) { - if(rrl_process_query(query)) - return rrl_slip(query); - else return QUERY_PROCESSED; - } - return QUERY_DISCARDED; -#else - return query_process(query, nsd); #endif + server_shutdown(nsd); } +#if defined(HAVE_SENDMMSG) && !defined(NONBLOCKING_IS_BROKEN) && defined(HAVE_RECVMMSG) static void -handle_udp(netio_type *ATTR_UNUSED(netio), - netio_handler_type *handler, - netio_event_types_type event_types) +handle_udp(int fd, short event, void* arg) { - struct udp_handler_data *data - = (struct udp_handler_data *) handler->user_data; - int received, sent; - struct query *q = data->query; + struct udp_handler_data *data = (struct udp_handler_data *) arg; + int received, sent, recvcount, i; + struct query *q; - if (!(event_types & NETIO_EVENT_READ)) { + if (!(event & EV_READ)) { return; } + recvcount = recvmmsg(fd, msgs, NUM_RECV_PER_SELECT, 0, NULL); + /* this printf strangely gave a performance increase on Linux */ + /* printf("recvcount %d \n", recvcount); */ + if (recvcount == -1) { + if (errno != EAGAIN && errno != EINTR) { + log_msg(LOG_ERR, "recvmmsg failed: %s", strerror(errno)); + STATUP(data->nsd, rxerr); + } + /* Simply no data available */ + return; + } + for (i = 0; i < recvcount; i++) { + loopstart: + received = msgs[i].msg_len; + q = queries[i]; + if (received == -1) { + log_msg(LOG_ERR, "recvmmsg %d failed %s", i, strerror( + msgs[i].msg_hdr.msg_flags)); + STATUP(data->nsd, rxerr); + query_reset(queries[i], UDP_MAX_MESSAGE_LEN, 0); + iovecs[i].iov_len = buffer_remaining(q->packet); + goto swap_drop; + } - /* Account... */ + /* Account... */ + if (data->socket->addr->ai_family == AF_INET) { + STATUP(data->nsd, qudp); + } else if (data->socket->addr->ai_family == AF_INET6) { + STATUP(data->nsd, qudp6); + } + + buffer_skip(q->packet, received); + buffer_flip(q->packet); + + /* Process and answer the query... */ + if (server_process_query_udp(data->nsd, q) != QUERY_DISCARDED) { + if (RCODE(q->packet) == RCODE_OK && !AA(q->packet)) { + STATUP(data->nsd, nona); + } + + /* Add EDNS0 and TSIG info if necessary. */ + query_add_optional(q, data->nsd); + + buffer_flip(q->packet); + iovecs[i].iov_len = buffer_remaining(q->packet); #ifdef BIND8_STATS - if (data->socket->addr->ai_family == AF_INET) { - STATUP(data->nsd, qudp); - } else if (data->socket->addr->ai_family == AF_INET6) { - STATUP(data->nsd, qudp6); + /* Account the rcode & TC... */ + STATUP2(data->nsd, rcode, RCODE(q->packet)); + if (TC(q->packet)) + STATUP(data->nsd, truncated); +#endif /* BIND8_STATS */ + } else { + query_reset(queries[i], UDP_MAX_MESSAGE_LEN, 0); + iovecs[i].iov_len = buffer_remaining(q->packet); + swap_drop: + STATUP(data->nsd, dropped); + if(i != recvcount-1) { + /* swap with last and decrease recvcount */ + struct mmsghdr mtmp = msgs[i]; + struct iovec iotmp = iovecs[i]; + recvcount--; + msgs[i] = msgs[recvcount]; + iovecs[i] = iovecs[recvcount]; + queries[i] = queries[recvcount]; + msgs[recvcount] = mtmp; + iovecs[recvcount] = iotmp; + queries[recvcount] = q; + msgs[i].msg_hdr.msg_iov = &iovecs[i]; + msgs[recvcount].msg_hdr.msg_iov = &iovecs[recvcount]; + goto loopstart; + } else { recvcount --; } + } } -#endif - /* Initialize the query... */ - query_reset(q, UDP_MAX_MESSAGE_LEN, 0); + /* send until all are sent */ + i = 0; + while(i<recvcount) { + sent = sendmmsg(fd, &msgs[i], recvcount-i, 0); + if(sent == -1) { + log_msg(LOG_ERR, "sendmmsg failed: %s", strerror(errno)); +#ifdef BIND8_STATS + data->nsd->st.txerr += recvcount-i; +#endif /* BIND8_STATS */ + break; + } + i += sent; + } + for(i=0; i<recvcount; i++) { + query_reset(queries[i], UDP_MAX_MESSAGE_LEN, 0); + iovecs[i].iov_len = buffer_remaining(queries[i]->packet); + } +} - received = recvfrom(handler->fd, - buffer_begin(q->packet), - buffer_remaining(q->packet), - 0, - (struct sockaddr *)&q->addr, - &q->addrlen); - if (received == -1) { +#else /* defined(HAVE_SENDMMSG) && !defined(NONBLOCKING_IS_BROKEN) && defined(HAVE_RECVMMSG) */ + +static void +handle_udp(int fd, short event, void* arg) +{ + struct udp_handler_data *data = (struct udp_handler_data *) arg; + int received, sent; +#ifndef NONBLOCKING_IS_BROKEN +#ifdef HAVE_RECVMMSG + int recvcount; +#endif /* HAVE_RECVMMSG */ + int i; +#endif /* NONBLOCKING_IS_BROKEN */ + struct query *q; +#if (defined(NONBLOCKING_IS_BROKEN) || !defined(HAVE_RECVMMSG)) + q = data->query; +#endif + + if (!(event & EV_READ)) { + return; + } +#ifndef NONBLOCKING_IS_BROKEN +#ifdef HAVE_RECVMMSG + recvcount = recvmmsg(fd, msgs, NUM_RECV_PER_SELECT, 0, NULL); + /* this printf strangely gave a performance increase on Linux */ + /* printf("recvcount %d \n", recvcount); */ + if (recvcount == -1) { if (errno != EAGAIN && errno != EINTR) { - log_msg(LOG_ERR, "recvfrom failed: %s", strerror(errno)); + log_msg(LOG_ERR, "recvmmsg failed: %s", strerror(errno)); STATUP(data->nsd, rxerr); - /* No zone statup */ } - } else { + /* Simply no data available */ + return; + } + for (i = 0; i < recvcount; i++) { + received = msgs[i].msg_len; + msgs[i].msg_hdr.msg_namelen = queries[i]->addrlen; + if (received == -1) { + log_msg(LOG_ERR, "recvmmsg failed"); + STATUP(data->nsd, rxerr); + /* the error can be found in msgs[i].msg_hdr.msg_flags */ + query_reset(queries[i], UDP_MAX_MESSAGE_LEN, 0); + continue; + } + q = queries[i]; +#else + for(i=0; i<NUM_RECV_PER_SELECT; i++) { +#endif /* HAVE_RECVMMSG */ +#endif /* NONBLOCKING_IS_BROKEN */ + +#if (defined(NONBLOCKING_IS_BROKEN) || !defined(HAVE_RECVMMSG)) + /* Initialize the query... */ + query_reset(q, UDP_MAX_MESSAGE_LEN, 0); + + received = recvfrom(fd, + buffer_begin(q->packet), + buffer_remaining(q->packet), + 0, + (struct sockaddr *)&q->addr, + &q->addrlen); + if (received == -1) { + if (errno != EAGAIN && errno != EINTR) { + log_msg(LOG_ERR, "recvfrom failed: %s", strerror(errno)); + STATUP(data->nsd, rxerr); + } + return; + } +#endif /* NONBLOCKING_IS_BROKEN || !HAVE_RECVMMSG */ + + /* Account... */ + if (data->socket->addr->ai_family == AF_INET) { + STATUP(data->nsd, qudp); + } else if (data->socket->addr->ai_family == AF_INET6) { + STATUP(data->nsd, qudp6); + } + buffer_skip(q->packet, received); buffer_flip(q->packet); /* Process and answer the query... */ if (server_process_query_udp(data->nsd, q) != QUERY_DISCARDED) { -#ifdef BIND8_STATS if (RCODE(q->packet) == RCODE_OK && !AA(q->packet)) { STATUP(data->nsd, nona); -# ifdef USE_ZONE_STATS - if (q->zone) - ZTATUP(q->zone, nona); -# endif } -# ifdef USE_ZONE_STATS - if (q->zone) { - if (data->socket->addr->ai_family == AF_INET) { - ZTATUP(q->zone, qudp); - } else if (data->socket->addr->ai_family == AF_INET6) { - ZTATUP(q->zone, qudp6); - } - } -# endif -#endif - /* Add EDNS0 and TSIG info if necessary. */ query_add_optional(q, data->nsd); buffer_flip(q->packet); - sent = sendto(handler->fd, + sent = sendto(fd, buffer_begin(q->packet), buffer_remaining(q->packet), 0, @@ -1542,62 +1939,43 @@ handle_udp(netio_type *ATTR_UNUSED(netio), if (sent == -1) { log_msg(LOG_ERR, "sendto failed: %s", strerror(errno)); STATUP(data->nsd, txerr); - -#ifdef USE_ZONE_STATS - if (q->zone) - ZTATUP(q->zone, txerr); -#endif } else if ((size_t) sent != buffer_remaining(q->packet)) { log_msg(LOG_ERR, "sent %d in place of %d bytes", sent, (int) buffer_remaining(q->packet)); -#ifdef BIND8_STATS } else { +#ifdef BIND8_STATS /* Account the rcode & TC... */ STATUP2(data->nsd, rcode, RCODE(q->packet)); -# ifdef USE_ZONE_STATS - if (q->zone) - ZTATUP2(q->zone, rcode, RCODE(q->packet)); -# endif - if (TC(q->packet)) { + if (TC(q->packet)) STATUP(data->nsd, truncated); -# ifdef USE_ZONE_STATS - if (q->zone) - ZTATUP(q->zone, truncated); -# endif - } #endif /* BIND8_STATS */ } -#ifdef BIND8_STATS } else { STATUP(data->nsd, dropped); -# ifdef USE_ZONE_STATS - if (q->zone) { - ZTATUP(q->zone, dropped); - } -# endif -#endif } +#ifndef NONBLOCKING_IS_BROKEN +#ifdef HAVE_RECVMMSG + query_reset(queries[i], UDP_MAX_MESSAGE_LEN, 0); +#endif } +#endif } +#endif /* defined(HAVE_SENDMMSG) && !defined(NONBLOCKING_IS_BROKEN) && defined(HAVE_RECVMMSG) */ static void -cleanup_tcp_handler(netio_type *netio, netio_handler_type *handler) +cleanup_tcp_handler(struct tcp_handler_data* data) { - struct tcp_handler_data *data - = (struct tcp_handler_data *) handler->user_data; - netio_remove_handler(netio, handler); - close(handler->fd); - slowaccept = 0; + event_del(&data->event); + close(data->event.ev_fd); /* * Enable the TCP accept handlers when the current number of * TCP connections is about to drop below the maximum number * of TCP connections. */ - if (data->nsd->current_tcp_count == data->nsd->maximum_tcp_count) { - configure_handler_event_types(data->tcp_accept_handler_count, - data->tcp_accept_handlers, - NETIO_EVENT_READ); + if (slowaccept || data->nsd->current_tcp_count == data->nsd->maximum_tcp_count) { + configure_handler_event_types(EV_READ|EV_PERSIST); + slowaccept = 0; } --data->nsd->current_tcp_count; assert(data->nsd->current_tcp_count >= 0); @@ -1606,28 +1984,27 @@ cleanup_tcp_handler(netio_type *netio, netio_handler_type *handler) } static void -handle_tcp_reading(netio_type *netio, - netio_handler_type *handler, - netio_event_types_type event_types) +handle_tcp_reading(int fd, short event, void* arg) { - struct tcp_handler_data *data - = (struct tcp_handler_data *) handler->user_data; + struct tcp_handler_data *data = (struct tcp_handler_data *) arg; ssize_t received; + struct event_base* ev_base; + struct timeval timeout; - if (event_types & NETIO_EVENT_TIMEOUT) { + if ((event & EV_TIMEOUT)) { /* Connection timed out. */ - cleanup_tcp_handler(netio, handler); + cleanup_tcp_handler(data); return; } if (data->nsd->tcp_query_count > 0 && data->query_count >= data->nsd->tcp_query_count) { /* No more queries allowed on this tcp connection. */ - cleanup_tcp_handler(netio, handler); + cleanup_tcp_handler(data); return; } - assert(event_types & NETIO_EVENT_READ); + assert((event & EV_READ)); if (data->bytes_transmitted == 0) { query_reset(data->query, TCP_MAX_MESSAGE_LEN, 1); @@ -1637,7 +2014,7 @@ handle_tcp_reading(netio_type *netio, * Check if we received the leading packet length bytes yet. */ if (data->bytes_transmitted < sizeof(uint16_t)) { - received = read(handler->fd, + received = read(fd, (char *) &data->query->tcplen + data->bytes_transmitted, sizeof(uint16_t) - data->bytes_transmitted); @@ -1649,16 +2026,18 @@ handle_tcp_reading(netio_type *netio, */ return; } else { + char buf[48]; + addr2str(&data->query->addr, buf, sizeof(buf)); #ifdef ECONNRESET if (verbosity >= 2 || errno != ECONNRESET) #endif /* ECONNRESET */ - log_msg(LOG_ERR, "failed reading from tcp: %s", strerror(errno)); - cleanup_tcp_handler(netio, handler); + log_msg(LOG_ERR, "failed reading from %s tcp: %s", buf, strerror(errno)); + cleanup_tcp_handler(data); return; } } else if (received == 0) { /* EOF */ - cleanup_tcp_handler(netio, handler); + cleanup_tcp_handler(data); return; } @@ -1685,13 +2064,13 @@ handle_tcp_reading(netio_type *netio, */ if (data->query->tcplen < QHEADERSZ + 1 + sizeof(uint16_t) + sizeof(uint16_t)) { VERBOSITY(2, (LOG_WARNING, "packet too small, dropping tcp connection")); - cleanup_tcp_handler(netio, handler); + cleanup_tcp_handler(data); return; } if (data->query->tcplen > data->query->maxlen) { VERBOSITY(2, (LOG_WARNING, "insufficient tcp buffer, dropping connection")); - cleanup_tcp_handler(netio, handler); + cleanup_tcp_handler(data); return; } @@ -1701,7 +2080,7 @@ handle_tcp_reading(netio_type *netio, assert(buffer_remaining(data->query->packet) > 0); /* Read the (remaining) query data. */ - received = read(handler->fd, + received = read(fd, buffer_current(data->query->packet), buffer_remaining(data->query->packet)); if (received == -1) { @@ -1712,16 +2091,18 @@ handle_tcp_reading(netio_type *netio, */ return; } else { + char buf[48]; + addr2str(&data->query->addr, buf, sizeof(buf)); #ifdef ECONNRESET if (verbosity >= 2 || errno != ECONNRESET) #endif /* ECONNRESET */ - log_msg(LOG_ERR, "failed reading from tcp: %s", strerror(errno)); - cleanup_tcp_handler(netio, handler); + log_msg(LOG_ERR, "failed reading from %s tcp: %s", buf, strerror(errno)); + cleanup_tcp_handler(data); return; } } else if (received == 0) { /* EOF */ - cleanup_tcp_handler(netio, handler); + cleanup_tcp_handler(data); return; } @@ -1738,17 +2119,15 @@ handle_tcp_reading(netio_type *netio, assert(buffer_position(data->query->packet) == data->query->tcplen); /* Account... */ -#ifdef BIND8_STATS -# ifndef INET6 - STATUP(data->nsd, ctcp); -# else +#ifndef INET6 + STATUP(data->nsd, ctcp); +#else if (data->query->addr.ss_family == AF_INET) { STATUP(data->nsd, ctcp); } else if (data->query->addr.ss_family == AF_INET6) { STATUP(data->nsd, ctcp6); } -# endif -#endif /* BIND8_STATS */ +#endif /* We have a complete query, process it. */ @@ -1760,42 +2139,16 @@ handle_tcp_reading(netio_type *netio, if (data->query_state == QUERY_DISCARDED) { /* Drop the packet and the entire connection... */ STATUP(data->nsd, dropped); -#if defined(BIND8_STATS) && defined(USE_ZONE_STATS) - if (data->query->zone) { - ZTATUP(data->query->zone, dropped); - } -#endif - cleanup_tcp_handler(netio, handler); + cleanup_tcp_handler(data); return; } -#ifdef BIND8_STATS if (RCODE(data->query->packet) == RCODE_OK && !AA(data->query->packet)) { STATUP(data->nsd, nona); -# ifdef USE_ZONE_STATS - if (data->query->zone) - ZTATUP(data->query->zone, nona); -# endif } -# ifdef USE_ZONE_STATS - if (data->query->zone) { -# ifndef INET6 - ZTATUP(data->query->zone, ctcp); -# else - if (data->query->addr.ss_family == AF_INET) { - ZTATUP(data->query->zone, ctcp); - } else if (data->query->addr.ss_family == AF_INET6) { - ZTATUP(data->query->zone, ctcp6); - } -# endif - } -# endif /* USE_ZONE_STATS */ - -#endif /* BIND8_STATS */ - query_add_optional(data->query, data->nsd); /* Switch to the tcp write handler. */ @@ -1803,31 +2156,37 @@ handle_tcp_reading(netio_type *netio, data->query->tcplen = buffer_remaining(data->query->packet); data->bytes_transmitted = 0; - handler->timeout->tv_sec = data->nsd->tcp_timeout; - handler->timeout->tv_nsec = 0L; - timespec_add(handler->timeout, netio_current_time(netio)); - - handler->event_types = NETIO_EVENT_WRITE | NETIO_EVENT_TIMEOUT; - handler->event_handler = handle_tcp_writing; + timeout.tv_sec = data->nsd->tcp_timeout; + timeout.tv_usec = 0L; + + ev_base = data->event.ev_base; + event_del(&data->event); + event_set(&data->event, fd, EV_PERSIST | EV_WRITE | EV_TIMEOUT, + handle_tcp_writing, data); + if(event_base_set(ev_base, &data->event) != 0) + log_msg(LOG_ERR, "event base set tcpr failed"); + if(event_add(&data->event, &timeout) != 0) + log_msg(LOG_ERR, "event add tcpr failed"); + /* see if we can write the answer right away(usually so,EAGAIN ifnot)*/ + handle_tcp_writing(fd, EV_WRITE, data); } static void -handle_tcp_writing(netio_type *netio, - netio_handler_type *handler, - netio_event_types_type event_types) +handle_tcp_writing(int fd, short event, void* arg) { - struct tcp_handler_data *data - = (struct tcp_handler_data *) handler->user_data; + struct tcp_handler_data *data = (struct tcp_handler_data *) arg; ssize_t sent; struct query *q = data->query; + struct timeval timeout; + struct event_base* ev_base; - if (event_types & NETIO_EVENT_TIMEOUT) { + if ((event & EV_TIMEOUT)) { /* Connection timed out. */ - cleanup_tcp_handler(netio, handler); + cleanup_tcp_handler(data); return; } - assert(event_types & NETIO_EVENT_WRITE); + assert((event & EV_WRITE)); if (data->bytes_transmitted < sizeof(q->tcplen)) { /* Writing the response packet length. */ @@ -1838,9 +2197,9 @@ handle_tcp_writing(netio_type *netio, iov[0].iov_len = sizeof(n_tcplen) - data->bytes_transmitted; iov[1].iov_base = buffer_begin(q->packet); iov[1].iov_len = buffer_limit(q->packet); - sent = writev(handler->fd, iov, 2); + sent = writev(fd, iov, 2); #else /* HAVE_WRITEV */ - sent = write(handler->fd, + sent = write(fd, (const char *) &n_tcplen + data->bytes_transmitted, sizeof(n_tcplen) - data->bytes_transmitted); #endif /* HAVE_WRITEV */ @@ -1856,10 +2215,10 @@ handle_tcp_writing(netio_type *netio, if(verbosity >= 2 || errno != ECONNRESET) #endif /* ECONNRESET */ #ifdef EPIPE - if(verbosity >= 2 || errno != EPIPE) + if(verbosity >= 2 || errno != EPIPE) #endif /* EPIPE 'broken pipe' */ - log_msg(LOG_ERR, "failed writing to tcp: %s", strerror(errno)); - cleanup_tcp_handler(netio, handler); + log_msg(LOG_ERR, "failed writing to tcp: %s", strerror(errno)); + cleanup_tcp_handler(data); return; } } @@ -1878,9 +2237,9 @@ handle_tcp_writing(netio_type *netio, /* handle potential 'packet done' code */ goto packet_could_be_done; #endif - } - - sent = write(handler->fd, + } + + sent = write(fd, buffer_current(q->packet), buffer_remaining(q->packet)); if (sent == -1) { @@ -1895,10 +2254,10 @@ handle_tcp_writing(netio_type *netio, if(verbosity >= 2 || errno != ECONNRESET) #endif /* ECONNRESET */ #ifdef EPIPE - if(verbosity >= 2 || errno != EPIPE) + if(verbosity >= 2 || errno != EPIPE) #endif /* EPIPE 'broken pipe' */ log_msg(LOG_ERR, "failed writing to tcp: %s", strerror(errno)); - cleanup_tcp_handler(netio, handler); + cleanup_tcp_handler(data); return; } } @@ -1930,9 +2289,16 @@ handle_tcp_writing(netio_type *netio, q->tcplen = buffer_remaining(q->packet); data->bytes_transmitted = 0; /* Reset timeout. */ - handler->timeout->tv_sec = data->nsd->tcp_timeout; - handler->timeout->tv_nsec = 0; - timespec_add(handler->timeout, netio_current_time(netio)); + timeout.tv_sec = data->nsd->tcp_timeout; + timeout.tv_usec = 0L; + ev_base = data->event.ev_base; + event_del(&data->event); + event_set(&data->event, fd, EV_PERSIST | EV_WRITE | EV_TIMEOUT, + handle_tcp_writing, data); + if(event_base_set(ev_base, &data->event) != 0) + log_msg(LOG_ERR, "event base set tcpw failed"); + if(event_add(&data->event, &timeout) != 0) + log_msg(LOG_ERR, "event add tcpw failed"); /* * Write data if/when the socket is writable @@ -1949,44 +2315,56 @@ handle_tcp_writing(netio_type *netio, if (data->nsd->tcp_query_count > 0 && data->query_count >= data->nsd->tcp_query_count) { - (void) shutdown(handler->fd, SHUT_WR); + (void) shutdown(fd, SHUT_WR); } data->bytes_transmitted = 0; - handler->timeout->tv_sec = data->nsd->tcp_timeout; - handler->timeout->tv_nsec = 0; - timespec_add(handler->timeout, netio_current_time(netio)); - - handler->event_types = NETIO_EVENT_READ | NETIO_EVENT_TIMEOUT; - handler->event_handler = handle_tcp_reading; + timeout.tv_sec = data->nsd->tcp_timeout; + timeout.tv_usec = 0L; + ev_base = data->event.ev_base; + event_del(&data->event); + event_set(&data->event, fd, EV_PERSIST | EV_READ | EV_TIMEOUT, + handle_tcp_reading, data); + if(event_base_set(ev_base, &data->event) != 0) + log_msg(LOG_ERR, "event base set tcpw failed"); + if(event_add(&data->event, &timeout) != 0) + log_msg(LOG_ERR, "event add tcpw failed"); } +static void +handle_slowaccept_timeout(int ATTR_UNUSED(fd), short ATTR_UNUSED(event), + void* ATTR_UNUSED(arg)) +{ + if(slowaccept) { + configure_handler_event_types(EV_PERSIST | EV_READ); + slowaccept = 0; + } +} + /* * Handle an incoming TCP connection. The connection is accepted and - * a new TCP reader event handler is added to NETIO. The TCP handler + * a new TCP reader event handler is added. The TCP handler * is responsible for cleanup when the connection is closed. */ static void -handle_tcp_accept(netio_type *netio, - netio_handler_type *handler, - netio_event_types_type event_types) +handle_tcp_accept(int fd, short event, void* arg) { struct tcp_accept_handler_data *data - = (struct tcp_accept_handler_data *) handler->user_data; + = (struct tcp_accept_handler_data *) arg; int s; struct tcp_handler_data *tcp_data; region_type *tcp_region; - netio_handler_type *tcp_handler; #ifdef INET6 struct sockaddr_storage addr; #else struct sockaddr_in addr; #endif socklen_t addrlen; + struct timeval timeout; - if (!(event_types & NETIO_EVENT_READ)) { + if (!(event & EV_READ)) { return; } @@ -1996,7 +2374,7 @@ handle_tcp_accept(netio_type *netio, /* Accept it... */ addrlen = sizeof(addr); - s = accept(handler->fd, (struct sockaddr *) &addr, &addrlen); + s = accept(fd, (struct sockaddr *) &addr, &addrlen); if (s == -1) { /** * EMFILE and ENFILE is a signal that the limit of open @@ -2006,9 +2384,16 @@ handle_tcp_accept(netio_type *netio, */ if (errno == EMFILE || errno == ENFILE) { if (!slowaccept) { - slowaccept_timeout.tv_sec = NETIO_SLOW_ACCEPT_TIMEOUT; - slowaccept_timeout.tv_nsec = 0L; - timespec_add(&slowaccept_timeout, netio_current_time(netio)); + /* disable accept events */ + struct timeval tv; + configure_handler_event_types(0); + tv.tv_sec = SLOW_ACCEPT_TIMEOUT; + tv.tv_usec = 0L; + event_set(&slowaccept_event, -1, EV_TIMEOUT, + handle_slowaccept_timeout, NULL); + (void)event_base_set(data->event.ev_base, + &slowaccept_event); + (void)event_add(&slowaccept_event, &tv); slowaccept = 1; /* We don't want to spam the logs here */ } @@ -2045,28 +2430,20 @@ handle_tcp_accept(netio_type *netio, tcp_data->nsd = data->nsd; tcp_data->query_count = 0; - tcp_data->tcp_accept_handler_count = data->tcp_accept_handler_count; - tcp_data->tcp_accept_handlers = data->tcp_accept_handlers; - tcp_data->query_state = QUERY_PROCESSED; tcp_data->bytes_transmitted = 0; memcpy(&tcp_data->query->addr, &addr, addrlen); tcp_data->query->addrlen = addrlen; - tcp_handler = (netio_handler_type *) region_alloc( - tcp_region, sizeof(netio_handler_type)); - tcp_handler->fd = s; - tcp_handler->timeout = (struct timespec *) region_alloc( - tcp_region, sizeof(struct timespec)); - tcp_handler->timeout->tv_sec = data->nsd->tcp_timeout; - tcp_handler->timeout->tv_nsec = 0L; - timespec_add(tcp_handler->timeout, netio_current_time(netio)); + timeout.tv_sec = data->nsd->tcp_timeout; + timeout.tv_usec = 0; - tcp_handler->user_data = tcp_data; - tcp_handler->event_types = NETIO_EVENT_READ | NETIO_EVENT_TIMEOUT; - tcp_handler->event_handler = handle_tcp_reading; - - netio_add_handler(netio, tcp_handler); + event_set(&tcp_data->event, s, EV_PERSIST | EV_READ | EV_TIMEOUT, + handle_tcp_reading, tcp_data); + if(event_base_set(data->event.ev_base, &tcp_data->event) != 0) + log_msg(LOG_ERR, "cannot set tcp event base"); + if(event_add(&tcp_data->event, &timeout) != 0) + log_msg(LOG_ERR, "cannot set tcp event base"); /* * Keep track of the total number of TCP handlers installed so @@ -2075,9 +2452,7 @@ handle_tcp_accept(netio_type *netio, */ ++data->nsd->current_tcp_count; if (data->nsd->current_tcp_count == data->nsd->maximum_tcp_count) { - configure_handler_event_types(data->tcp_accept_handler_count, - data->tcp_accept_handlers, - NETIO_EVENT_NONE); + configure_handler_event_types(0); } } @@ -2098,7 +2473,6 @@ send_children_command(struct nsd* nsd, sig_atomic_t command, int timeout) (int) nsd->children[i].pid, strerror(errno)); } else if (timeout > 0) { - /* wait for reply */ (void)block_read(NULL, nsd->children[i].child_fd, &command, sizeof(command), timeout); @@ -2113,6 +2487,7 @@ send_children_command(struct nsd* nsd, sig_atomic_t command, int timeout) static void send_children_quit(struct nsd* nsd) { + DEBUG(DEBUG_IPC, 1, (LOG_INFO, "send children quit")); send_children_command(nsd, NSD_QUIT, 0); } @@ -2138,15 +2513,31 @@ set_children_stats(struct nsd* nsd) #endif /* BIND8_STATS */ static void -configure_handler_event_types(size_t count, - netio_handler_type *handlers, - netio_event_types_type event_types) +configure_handler_event_types(short event_types) { size_t i; - assert(handlers); - - for (i = 0; i < count; ++i) { - handlers[i].event_types = event_types; + for (i = 0; i < tcp_accept_handler_count; ++i) { + struct event* handler = &tcp_accept_handlers[i].event; + if(event_types) { + /* reassign */ + int fd = handler->ev_fd; + struct event_base* base = handler->ev_base; + if(tcp_accept_handlers[i].event_added) + event_del(handler); + event_set(handler, fd, event_types, + handle_tcp_accept, &tcp_accept_handlers[i]); + if(event_base_set(base, handler) != 0) + log_msg(LOG_ERR, "conhand: cannot event_base"); + if(event_add(handler, NULL) != 0) + log_msg(LOG_ERR, "conhand: cannot event_add"); + tcp_accept_handlers[i].event_added = 1; + } else { + /* remove */ + if(tcp_accept_handlers[i].event_added) { + event_del(handler); + tcp_accept_handlers[i].event_added = 0; + } + } } } |