/* Distributed Checksum Clearinghouse
 *
 * server
 *
 * Copyright (c) 2008 by Rhyolite Software, LLC
 *
 * This agreement is not applicable to any entity which sells anti-spam
 * solutions to others or provides an anti-spam solution as part of a
 * security solution sold to other entities, or to a private network
 * which employs the DCC or uses data provided by operation of the DCC
 * but does not provide corresponding data to other users.
 *
 * Permission to use, copy, modify, and distribute this software without
 * changes for any purpose with or without fee is hereby granted, provided
 * that the above copyright notice and this permission notice appear in all
 * copies and any distributed versions or copies are either unchanged
 * or not called anything similar to "DCC" or "Distributed Checksum
 * Clearinghouse".
 *
 * Parties not eligible to receive a license under this agreement can
 * obtain a commercial license to use DCC by contacting Rhyolite Software
 * at sales@rhyolite.com.
 *
 * A commercial license would be for Distributed Checksum and Reputation
 * Clearinghouse software.  That software includes additional features.  This
 * free license for Distributed ChecksumClearinghouse Software does not in any
 * way grant permision to use Distributed Checksum and Reputation Clearinghouse
 * software
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND RHYOLITE SOFTWARE, LLC DISCLAIMS ALL
 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL RHYOLITE SOFTWARE, LLC
 * BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES
 * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
 * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
 * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
 * SOFTWARE.
 *
 * Rhyolite Software DCC 1.3.103-1.297 $Revision$
 */

#include "dccd_defs.h"
#include <signal.h>			/* for Linux and SunOS */
#include <sys/uio.h>
#include <sys/wait.h>
#include "dcc_ifaddrs.h"

DCC_EMSG dcc_emsg;

static const char *homedir;
static char *aargs[10];
static char **aarg = &aargs[0];
static DCC_PATH dbclean_def = DCC_LIBEXECDIR"/dbclean";
static char *dbclean = dbclean_def;
static pid_t dbclean_pid = -1;
static char *addr_str;			/* an IP address for dbclean */
static char dbclean_str[] = "dbclean";
#define MAX_DBCLEAN_FLAGS 50
static char dbclean_flags[MAX_DBCLEAN_FLAGS+1] = "-Pq";
static int dbclean_flags_len = LITZ("-Pq");
static const char *dbclean_argv[20] = {dbclean_str, dbclean_flags};
static int dbclean_argc = 2;
static char dbclean_args_str[200];
static int dbclean_args_str_len;

/* do not try to run dbclean too often */
time_t dbclean_limit_secs = DBCLEAN_LIMIT_SECS;
static time_t dbclean_failed;

static double wfix_quiet_rate = 1.0;	/* max load that allows window fixing */
static double wfix_busy_rate;		/* measured active rate */
static double wfix_rate_change = 0.4;	/* rate reduction to this allows fix */
static DB_PTR wfix_size;
static u_char wfix_size_set = 0;
DBCLEAN_WFIX_STATE dbclean_wfix_state = WFIX_DELAY;
static double wfix_ops;
static time_t wfix_check_start;
static time_t dbclean_wfix_secs;	/* window fixing timer */
#define WFIX_POST_CLEAN_SECS (6*60*60)	/* do not fix it soon after cleaning */
#define WFIX_PRE_CLEAN_SECS (2*60*60)	/*	or just before cleaning */
#define WFIX_RECHECK_SECS   (15*60)	/* between checks for window overflow */
#define WFIX_QUIET_SECS	    (5*60)	/* waiting for clients to flee */
#define	WFIX_MEASURE_SECS   (5*60)	/* counting clients */
#define WFIX_MAX_SECS	(WFIX_PRE_CLEAN_SECS+WFIX_POST_CLEAN_SECS)

const char *need_del_dbclean;
time_t del_dbclean_next;
time_t dbclean_limit;
static time_t clean_fake_secs;		/* timer for missing cron job */
static time_t clean_last_secs;

u_long dccd_tracemask = DCC_TRACE_ON_DEF_BITS;

u_char background = 1;
int stopint;				/* !=0 if stopping or received signal */

static time_t flods_ck_secs = FLODS_CK_SECS;

const char *brand = "";

static char *my_srvr_id_str;
DCC_SRVR_ID my_srvr_id;

u_char use_ipv6 = 0;
u_int16_t def_port;			/* default port #, network byte order */
typedef struct port_list {
    struct port_list *fwd;
    u_int16_t	port;			/* network byte order */
} PORT_LIST;
static PORT_LIST *ports;
SRVR_SOC *srvr_socs;
static SRVR_SOC **srvr_socs_end = &srvr_socs;
int srvr_rcvbuf = 1024*1024;

#ifdef USE_DBCLEAN_F
static u_char db_mode = DB_OPEN_MMAP_WRITE;
#else
static u_char db_mode = 0;
#endif

int grey_embargo = DEF_GREY_EMBARGO;	/* seconds to delay new traffic */
int grey_window = DEF_GREY_WINDOW;	/* wait as long as this */
int grey_white = DEF_GREY_WHITE;	/* remember this long */

char our_hostname[MAXHOSTNAMELEN];
DCC_SUM host_id_sum;			/* advertised with our server-ID */
time_t host_id_next, host_id_last;	/* when to advertise */

u_char anon_off;			/* turn off anonymous access */
time_t anon_delay_us = DCC_ANON_DELAY_US_DEF;   /* delay anonymous clients */
u_int anon_delay_inflate = DCC_ANON_INFLATE_OFF;

u_char stop_mode;			/* 0=normal 1=reboot 2=with/DB clean */

static int total_ops;
static QUEUE *queue_free;
static QUEUE *queue_head;

/* assume or hope we can handle 500 requests/second */
int queue_max = 500*DCC_MAX_RTT_SECS;	/* ultimate bound on queue size */
static int queue_max_cur;		/* current upper bound */
static int queue_cur;			/* current queue size */

struct timeval wake_time;		/* when we awoke from select() */
struct timeval req_recv_time;		/* when request arrived */

DCC_TS future;				/* timestamp sanity */


static DB_NOKEEP_CKS set_new_nokeep_cks, reset_new_nokeep_cks;

DCC_TGTS flod_tholds[DCC_DIM_CKS];	/* flood at or after these thresholds */

static const char *parse_rl_rate(RL_RATE *, float, const char *, const char *);
static void add_dbclean_flag(char);
static void add_dbclean_arg(const char *);
static void check_dbclean(int);
static void run_dbclean(const char *, const char *);
static void sigterm(int);
static void sighup(int);
static void stop_children(void);
static u_char get_if_changes(u_char);
static SRVR_SOC *add_srvr_soc(u_char, int, const void *, u_int16_t);
static int open_srvr_socs(int);
static void wfix_later(time_t);
static void recv_job(void) NRATTRIB;
static u_char new_job(SRVR_SOC *);
static void NRATTRIB dccd_quit(int, const char *, ...) PATTRIB(2,3);

static void
usage(const char* barg)
{
	static const char str[] = {
	    "usage: [-64dVbfFQ] -i server-ID [-n brand] [-h homedir]\n"
	    "   [-I [host-ID][,user]] [-a [server-addr][,server-port]]"
	    " [-q qsize]\n"
	    "   [-G [on,][weak-body,][weak-IP,]embargo],[window],[white]]\n"
	    "   [-W [rate][,chg][,dbsize]] [-K [no-]type] [-T tracemode]\n"
	    "   [-u anon-delay[,inflate] [-C dbclean]"
	    " [-L ltype,facility.level]\n"
	    "   [-R [RL_SUB],[RL_FREE],[RL_ALL_FREE],[RL_BUGS]]"
	};
	static u_char complained;

	if (!complained) {
		if (barg)
			dcc_error_msg("unrecognized \"%s\"\nusage: %s\n..."
				      " continuing",
				      barg, str);
		else
			dcc_error_msg("%s\n... continuing", str);
		complained = 1;
	}
}


int NRATTRIB
main(int argc, char **argv)
{
	char *p;
	const char *rest;
	u_char print_version = 0;
	DCC_CK_TYPES type;
	DCC_SOCKU *sup;
	u_int16_t port;
	int new_embargo, new_window, new_white;
	int error, i;
	const char *cp;
	double d1, d2;
	u_long l;

	dcc_syslog_init(1, argv[0], 0);

	if (DCC_DIM_CKS != DCC_COMP_DIM_CKS)
		dcc_logbad(EX_SOFTWARE,
			   "DCC_DIM_CKS != DCC_COMP_DIM_CKS;"
			   " check uses of both");

	/* get first bytes of our hostname to name our server-ID */
	memset(our_hostname, 0, sizeof(our_hostname));
	if (0 > gethostname(our_hostname, sizeof(our_hostname)-1))
		dcc_logbad(EX_NOHOST, "gethostname(): %s", ERROR_STR());
	our_hostname[sizeof(our_hostname)-1] = '\0';
	if (our_hostname[0] == '\0')
		dcc_logbad(EX_NOHOST, "null hostname from gethostname()");
	strncpy((char *)host_id_sum, our_hostname, sizeof(host_id_sum));

	parse_rl_rate(&rl_sub_rate, 0.5, "RL_SUB", "400");
	parse_rl_rate(&rl_anon_rate, RL_AVG_SECS, "RL_ANON", "50");
	parse_rl_rate(&rl_all_anon_rate, 0.5, "RL_ALL_ANON", "600");
	parse_rl_rate(&rl_bugs_rate, RL_AVG_SECS, "RL_BUGS", "0.1");

	/* this must match DCCD_GETOPTS in cron-dccd.in */
	while ((i = getopt(argc, argv,
			   "64dVbfFQi:n:h:a:I:q:G:t:W:K:T:u:C:L:R:")) != -1) {
		switch (i) {
		case '6':
#ifndef NO_IPV6
			use_ipv6 = 2;
#endif
			break;
		case '4':
			use_ipv6 = 0;
			break;

		case 'd':
			add_dbclean_flag('d');
			++db_debug;
			break;

		case 'V':
			fprintf(stderr, DCC_VERSION"\n");
			print_version = 1;
			break;

		case 'b':
			background = 0;
			break;

		case 'f':
			db_mode &= ~DB_OPEN_MMAP_WRITE;
			add_dbclean_flag('f');
			break;

		case 'F':
			db_mode |= DB_OPEN_MMAP_WRITE;
			add_dbclean_flag('F');
			break;

		case 'Q':
			query_only = 1;
			break;

		case 'i':
			my_srvr_id_str = optarg;
			if (!dcc_get_srvr_id(dcc_emsg, &my_srvr_id,
					     my_srvr_id_str, 0, 0, 0))
				dcc_logbad(dcc_ex_code, "%s", dcc_emsg);
			add_dbclean_arg("-i");
			add_dbclean_arg(my_srvr_id_str);
			break;

		case 'n':
			/* RFC 2822 says "values between 33 and 126" */
			cp = optarg;
			while (*cp >= 33 && *cp <= 126 && *cp != ':')
				++cp;
			if (cp == optarg
			    || (cp - optarg) > ISZ(DCC_BRAND)
			    || *cp != '\0') {
				dcc_error_msg("invalid brand name \"-n %s\"",
					      optarg);
			} else {
				brand = optarg;
			}
			break;

		case 'h':
			homedir = optarg;
			/* tell dbclean "-h ." because we will already
			 * be there and that allows our -h to be relative */
			add_dbclean_arg("-h.");
			break;

		case 'I':
			p = strchr(optarg, ',');
			if (p) {
				*p++ = '\0';
				dcc_daemon_su(p);
				if (*optarg == '\0')
					break;
			}
			if (*optarg != '\0')
				strncpy((char *)host_id_sum, optarg,
					sizeof(host_id_sum));
			break;

		case 'a':
			/* postpone checking host names until we know -6 */
			if (aarg > LAST(aargs)) {
				dcc_error_msg("too many -a args");
				break;
			}
			optarg += strspn(optarg, DCC_WHITESPACE);
			*aarg++ = optarg;
			break;

		case 'q':
			l = strtoul(optarg, &p, 10);
			if (*p != '\0' || l < 2 || l > 1000) {
				dcc_error_msg("invalid queue length \"%s\"",
					      optarg);
			} else {
				queue_max = l;
			}
			break;

		case 'G':
			grey_on = 1;
			dcc_syslog_init(1, argv[0], " grey");
			add_dbclean_arg("-Gon");
			/* handle leading "on" "weak-body", and "weak-IP" */
			rest = optarg;
			while (*rest) {
				if (dcc_ck_word_comma(&rest, "weak-body")
				    || dcc_ck_word_comma(&rest, "weak_body")
				    || dcc_ck_word_comma(&rest, "weak")) {
					grey_weak_body = 1;
					continue;
				}
				if (dcc_ck_word_comma(&rest, "weak-IP")
				    || dcc_ck_word_comma(&rest, "weak_IP")) {
					grey_weak_ip = 1;
					continue;
				}
				if (!dcc_ck_word_comma(&rest, "on"))
					break;
			}
			new_embargo = dcc_get_secs(rest, &rest,
						   0, MAX_GREY_EMBARGO,
						   grey_embargo);
			if (new_embargo < 0) {
				dcc_error_msg("invalid greylist embargo"
					      " \"-G %s\"", optarg);
				break;
			}
			new_window = dcc_get_secs(rest, &rest,
						  new_embargo, MAX_GREY_WINDOW,
						  max(new_embargo,grey_window));
			if (new_window < 0) {
				dcc_error_msg("invalid greylist wait time"
					      " \"-G %s\"", optarg);
				break;
			}
			new_white = dcc_get_secs(rest, &rest,
						 new_window, MAX_GREY_WHITE,
						 max(new_window, grey_white));
			if (new_white < 0 || *rest != '\0') {
				dcc_error_msg("invalid greylist whitelist time"
					      " \"-G %s\"", optarg);
				break;
			}
			grey_embargo = new_embargo;
			grey_window = new_window;
			grey_white = new_white;
			break;

		case 't':		/* obsolete */
			break;

		case 'W':
			p = optarg;
			if (*p == '\0') {
				dcc_error_msg("unrecognized"
					      " \"-W %s\"", optarg);
				break;
			}
			d1 = wfix_quiet_rate;
			if (*p != '\0' && *p != ',') {
				d1 = strtod(p, &p);
				if ((*p != '\0' && *p != ',')
				    || d1 < 0.0 || d1 > 1000*1000.0) {
					dcc_error_msg("bad quiet rate in"
						      " \"-W %s\"", optarg);
					break;
				}
			}
			if (*p == ',')
				++p;
			d2 = wfix_rate_change;
			if (*p != '\0' && *p != ',') {
				d1 = strtod(p, &p);
				if ((*p != '\0' && *p != ',')
				    || d1 < 0.0 || d1 > 1000*1000.0) {
					dcc_error_msg("bad rate change in"
						      " \"-W %s\"", optarg);
					break;
				}
			}
			if (*p == ',')
				++p;
			l = wfix_size/(1024*1024);
			if (*p != '\0') {
				l = strtoul(p, &p, 10);
				if ((*p != '\0' || l < DB_MIN_MIN_MBYTE
				     || l > MAX_MAX_DB_MBYTE)
				    && l != wfix_size) {
					dcc_error_msg("bad database size in"
						      " \"-W %s\"", optarg);
					break;
				}
			}
			wfix_quiet_rate = d1;
			wfix_rate_change = d2;
			if (wfix_size/(1024*1024) != l) {
				wfix_size = ((DB_PTR)l)*(1024*1024);
				wfix_size_set = 1;
			}
			break;

		case 'K':
			if (!strcasecmp(optarg, "all")) {
				reset_new_nokeep_cks = -1;
				break;
			}
			if (!CLITCMP(optarg, "no-")) {
				optarg += LITZ("no-");
				i = 0;
			} else {
				i = 1;
			}
			type = dcc_str2type_db(optarg, -1);
			if (type == DCC_CK_INVALID) {
				dcc_error_msg("bad checksum type in"
					      " \"-K %s\"", optarg);
				break;
			}
			if (i)
				DB_SET_NOKEEP(reset_new_nokeep_cks, type);
			else
				DB_SET_NOKEEP(set_new_nokeep_cks, type);
			break;

		case 'T':
			if (!strcasecmp(optarg, "ADMN")) {
				dccd_tracemask |= DCC_TRACE_ADMN_BIT;
			} else if (!strcasecmp(optarg, "ANON")) {
				dccd_tracemask |= DCC_TRACE_ANON_BIT;
			} else if (!strcasecmp(optarg, "CLNT")) {
				dccd_tracemask |= DCC_TRACE_CLNT_BIT;
			} else if (!strcasecmp(optarg, "RLIM")) {
				dccd_tracemask |= DCC_TRACE_RLIM_BIT;
			} else if (!strcasecmp(optarg, "QUERY")) {
				dccd_tracemask |= DCC_TRACE_QUERY_BIT;
			} else if (!strcasecmp(optarg, "RIDC")) {
				dccd_tracemask |= DCC_TRACE_RIDC_BIT;
			} else if (!strcasecmp(optarg, "FLOOD")) {
				dccd_tracemask |= DCC_TRACE_FLOD_BIT;
			} else if (!strcasecmp(optarg, "FLOOD2")) {
				dccd_tracemask |= DCC_TRACE_FLOD2_BIT;
			} else if (!strcasecmp(optarg, "IDS")) {
				dccd_tracemask |= DCC_TRACE_IDS_BIT;
			} else if (!strcasecmp(optarg, "BL")) {
				dccd_tracemask |= DCC_TRACE_BL_BIT;
			} else if (!strcasecmp(optarg, "DB")) {
				dccd_tracemask |= DCC_TRACE_DB_BIT;
			} else if (!strcasecmp(optarg, "WLIST")) {
				dccd_tracemask |= DCC_TRACE_WLIST_BIT;
			} else {
				dcc_error_msg("invalid trace mode \"%s\"",
					      optarg);
			}
			break;

		case 'u':
			i = parse_dccd_delay(dcc_emsg, &anon_delay_us,
					     &anon_delay_inflate, optarg,
					     0, 0);
			if (!i) {
				dcc_error_msg("%s", dcc_emsg);
			} else if (i == 2) {
				anon_off = 1;
			} else {
				anon_off = 0;
			}
			break;

		case 'C':
			if (*optarg == '\0') {
				dcc_error_msg("no path to dbclean \"-C %s\"",
					      optarg);
				break;
			}
			/* capture the path to the dbclean program */
			dbclean = optarg;
			/* capture any args following the program */
			for (p = strpbrk(optarg, DCC_WHITESPACE);
			     p != 0;
			     p = strpbrk(p, DCC_WHITESPACE)) {
				*p++ = '\0';
				p += strspn(p, DCC_WHITESPACE);
				if (*p == '\0')
					break;
				add_dbclean_arg(p);
			}
			break;

		case 'L':
			if (dcc_parse_log_opt(optarg)) {
				add_dbclean_arg("-L");
				add_dbclean_arg(optarg);
			}
			break;

		case 'R':
			rest = parse_rl_rate(&rl_sub_rate, -1.0,
					     "RL_SUB", optarg);
			rest = parse_rl_rate(&rl_anon_rate, -1.0,
					     "RL_ANON", rest);
			rest = parse_rl_rate(&rl_all_anon_rate, -1.0,
					     "RL_ALL_ANON", rest);
			rest = parse_rl_rate(&rl_bugs_rate, -1.0,
					     "RL_BUGS", rest);
			break;

		default:
			usage(optopt2str(optopt));
		}
	}
	argc -= optind;
	argv += optind;
	if (argc != 0)
		usage(argv[0]);

	if (my_srvr_id == DCC_ID_INVALID) {
		if (print_version)
			exit(EX_OK);
		dcc_logbad(EX_USAGE, "server-ID not set with -i");
	}

	if (grey_on) {
		anon_off = 1;
		dccd_tracemask |= DCC_TRACE_IDS_BIT;
	}

	/* parse addresses after we know whether -6 was among the args */
	for (aarg = &aargs[0]; aarg <= LAST(aargs) && *aarg; ++aarg) {
		char hostname[DCC_MAXDOMAINLEN];

		addr_str = *aarg;
		rest = dcc_parse_nm_port(dcc_emsg, *aarg, 0,
					 hostname, sizeof(hostname),
					 &port, 0, 0, 0, 0);
		if (!rest) {
			dcc_error_msg("%s", dcc_emsg);
			continue;
		}
		rest += strspn(rest, DCC_WHITESPACE);
		if (*rest != '\0')
			dcc_error_msg("unrecognized port number in"
				      "\"-a %s\"", *aarg);
		if (hostname[0] == '\0') {
			PORT_LIST *pport = dcc_malloc(sizeof(*pport));
			pport->port = port;
			pport->fwd = ports;
			ports = pport;
			continue;
		}
		if (!strcmp(hostname, "@")) {
			++addr_str;	/* "" but not a const */
			add_srvr_soc(SRVR_SOC_ADDR, AF_UNSPEC, 0, port);
			continue;
		}
		dcc_host_lock();
		if (!dcc_get_host(hostname, use_ipv6 ? 2 : 0, &error)) {
			dcc_host_unlock();
			dcc_error_msg("%s: %s",
				      *aarg, DCC_HSTRERROR(error));
			continue;
		}
		for (sup = dcc_hostaddrs; sup < dcc_hostaddrs_end; ++sup) {
			if (sup->sa.sa_family == AF_INET)
				add_srvr_soc(SRVR_SOC_ADDR, AF_INET,
					     &sup->ipv4.sin_addr, port);
			else
				add_srvr_soc(SRVR_SOC_ADDR, AF_INET6,
					     &sup->ipv6.sin6_addr, port);
		}
		dcc_host_unlock();
	}
	if (addr_str) {
		/* tell dbclean about one "-a addr" */
		add_dbclean_arg("-a");
		add_dbclean_arg(addr_str);
	}

	dcc_clnt_unthread_init();
	if (!dcc_cdhome(dcc_emsg, homedir, 0))
		dcc_logbad(dcc_ex_code, "%s", dcc_emsg);

	i = check_load_ids(1);
	if (i < 0)
		dcc_logbad(dcc_ex_code, "%s", dcc_emsg);
	else if (!i)
		dcc_error_msg("%s", dcc_emsg);

	if (!def_port)
		def_port = DCC_GREY2PORT(grey_on);
	if (!srvr_socs && !ports) {
		ports = dcc_malloc(sizeof(*ports));
		ports->fwd = 0;
		ports->port = def_port;
	}
	get_if_changes(db_debug != 0);

	/* make initial attempt to open the server UDP sockets
	 * This also sets use_ipv6 to 0 or 1 if it is still 2 */
	if (open_srvr_socs(45) <= 0)
		dcc_logbad(EX_OSERR, "failed to open any server sockets");

	add_dbclean_flag(use_ipv6 == 0 ? '4' : '6');

	if (background) {
		if (0 > daemon(1, 0))
			dcc_logbad(EX_OSERR, "daemon(): %s", ERROR_STR());
	}

	if (!background)
		signal(SIGHUP, sigterm);    /* SIGHUP fatal during debugging */
	else
		signal(SIGHUP, sighup);	/* speed configuration check */
	signal(SIGTERM, sigterm);
	signal(SIGINT, sigterm);
	signal(SIGPIPE, SIG_IGN);
#ifdef SIGXFSZ
	signal(SIGXFSZ, SIG_IGN);
#endif

	atexit(stop_children);

	gettimeofday(&db_time, 0);
	wake_time = db_time;

	flod_mmap_path_set();

	/* open the database, and try once to fix it */
	if (!dccd_db_open(DB_OPEN_LOCK_NOWAIT)) {
		dcc_error_msg("%s", dcc_emsg);
		run_dbclean("SRbad", "database initially broken");
		check_dbclean(0);	/* stall until dbclean finishes */
		if (!dccd_db_open(DB_OPEN_LOCK_NOWAIT)) {
			dcc_error_msg("%s", dcc_emsg);
			dcc_logbad(EX_NOINPUT,
				   "could not start database %s", db_nm);
		}
	}
	/* do not start if dbclean is running */
	if (!lock_dbclean(dcc_emsg, db_nm))
		dcc_logbad(dcc_ex_code, "%s: dbclean already running?",
			   dcc_emsg);
	unlock_dbclean();

	flod_trace_gen = db_time.tv_sec;
	host_id_next = db_time.tv_sec + DCC_SRVR_ID_SECS_ST;
	check_blacklist_file();
	flods_init();
	clients_load();
	stats_clear();
	if (flod_mmaps != 0
	    && flod_mmaps->dccd_stats.reset.tv_sec != 0) {
		memcpy(&dccd_stats, &flod_mmaps->dccd_stats,
		       sizeof(dccd_stats));
	}
	dcc_trace_msg(DCC_VERSION" listening to port %d  %s  %s",
		      ntohs(srvr_socs->arg_port),
		      dcc_homedir, db_window_size_str);

	recv_job();
}



static SRVR_SOC *			/* 0 or new entry */
add_srvr_soc(u_char flags,
	     int family,		/* AF_UNSPEC or 0 if addrp==0 */
	     const void *addrp,		/* 0, *in_addr, or *in6_addr */
	     u_int16_t port)
{
	DCC_SOCKU su;
	SRVR_SOC *sp;

	dcc_mk_su(&su, family, addrp, port);
	for (sp = srvr_socs; sp; sp = sp->fwd) {
		if (sp->arg_family == family
		    && sp->arg_port == port
		    && !memcmp(&sp->arg_addr, addrp,
			       ((family == AF_INET)
				? sizeof(sp->arg_addr.in4)
				: sizeof(sp->arg_addr.in6))))
			return sp;
	}

	sp = dcc_malloc(sizeof(*sp));
	memset(sp, 0, sizeof(*sp));
	sp->flags = flags;
	sp->udp = -1;
	sp->listen = -1;
	sp->su = su;
	sp->arg_family = family;
	if (addrp)
		memcpy(&sp->arg_addr, addrp,
		       ((family == AF_INET)
			? sizeof(sp->arg_addr.in4)
			: sizeof(sp->arg_addr.in6)));
	sp->arg_port = port;

	*srvr_socs_end = sp;
	srvr_socs_end = &sp->fwd;

	return sp;
}



static int				/* # of sockets opened */
open_srvr_socs(int retry_secs)
{
	static u_char srvr_rcvbuf_set = 0;
	int *retry_secsp;
	u_char family;
	SRVR_SOC *sp;
	int i;
	int num_socs = 0;

	if (stopint)
		return -1;

	retry_secsp = retry_secs ? &retry_secs : 0;

	for (sp = srvr_socs; sp; sp = sp->fwd) {
		if (sp->udp >= 0) {
			++num_socs;
			continue;
		}

		/* resolve default port number if we finally know it */
		if (!sp->arg_port)
			sp->arg_port = def_port;

		family = sp->arg_family;

		/* create the UDP socket
		 * If we are using INADDR_ANY
		 * and do not yet know if IPv6 works, just try it */
		if (family == AF_UNSPEC
		    && use_ipv6 == 2) {
			dcc_mk_su(&sp->su, AF_INET6,
				  &sp->arg_addr, sp->arg_port);
			i = dcc_udp_bind(dcc_emsg, &sp->udp,
					 &sp->su, retry_secsp);
			if (i == 0) {
				dcc_error_msg("%s", dcc_emsg);
				/* still don't know about IPv6 */
				continue;
			}
			if (i > 0) {
				/* we finished an INADDR_ANY socket
				 * and learned that IPv6 works */
				use_ipv6 = 1;
				continue;
			}
			/* we know or guess that IPv6 does not work */
			use_ipv6 = 0;
		}

		if (family == AF_UNSPEC) {
			/* using INADDR_ANY but now know whether IPv6 works */
			family = use_ipv6 ? AF_INET6 : AF_INET;
		} else if (family == AF_INET6 && use_ipv6 == 2) {
			/* don't know if IPv6 works but have an IPv6 address */
			use_ipv6 = 1;
		}

		dcc_mk_su(&sp->su, family, &sp->arg_addr, sp->arg_port);
		if (0 >= dcc_udp_bind(dcc_emsg, &sp->udp,
				      &sp->su, retry_secsp)) {
			dcc_error_msg("%s", dcc_emsg);
			continue;
		}

		/* set socket receive buffer size as large as possible */
		for (;;) {
			if (!setsockopt(sp->udp, SOL_SOCKET, SO_RCVBUF,
					&srvr_rcvbuf, sizeof(srvr_rcvbuf)))
				break;
			if (srvr_rcvbuf_set || srvr_rcvbuf <= 4096) {
				dcc_error_msg("setsockopt(%s,SO_RCVBUF=%d): %s",
					      dcc_su2str_err(&sp->su),
					      srvr_rcvbuf,
					      ERROR_STR());
				break;
			}
			srvr_rcvbuf -= 4096;
		}
		srvr_rcvbuf_set = 1;

		++num_socs;
	}

	/* Finally decide the IPv6 issue if we found no sign of IPv6 */
	if (use_ipv6 == 2)
		use_ipv6 = 0;

	return num_socs;
}



/* get ready to bind to all local IP addreses */
static u_char				/* 1=added an interface */
add_ifs(u_char not_quiet)
{
	u_char added;
	SRVR_SOC *sp;
	PORT_LIST *pport;
#ifdef HAVE_GETIFADDRS
	struct ifaddrs *ifap0, *ifap;
	int num_ifs;
#endif

	if (!ports)
		return 0;

	added = 0;

#ifdef HAVE_GETIFADDRS
	if (0 > getifaddrs(&ifap0)) {
		dcc_error_msg("getifaddrs(): %s", ERROR_STR());
		ifap0 = 0;
	}

	num_ifs = 0;
	for (pport = ports; pport; pport = pport->fwd) {
		const SRVR_SOC *listener = 0;

		for (ifap = ifap0; ifap; ifap = ifap->ifa_next) {
			if (!(ifap->ifa_flags & IFF_UP))
				continue;
			if (!ifap->ifa_addr)
				continue;
			switch (ifap->ifa_addr->sa_family) {
			case AF_INET:
				++num_ifs;
				sp = add_srvr_soc(SRVR_SOC_IF | SRVR_SOC_NEW,
						  ifap->ifa_addr->sa_family,
						  &((struct sockaddr_in *)ifap
						    ->ifa_addr)->sin_addr,
						  pport->port);
				break;
			case AF_INET6:
				if (use_ipv6 == 0)
					continue;
				if (use_ipv6 == 2)
					use_ipv6 = 1;
				++num_ifs;
				sp = add_srvr_soc(SRVR_SOC_IF | SRVR_SOC_NEW,
						  ifap->ifa_addr->sa_family,
						  &((struct sockaddr_in6*)ifap
						    ->ifa_addr)->sin6_addr,
						  pport->port);
				break;
			default:
				continue;
			}
			if (sp->flags & SRVR_SOC_NEW) {
				added = 1;
				if (not_quiet)
					dcc_trace_msg("start listening on %s",
						      dcc_su2str_err(&sp->su));
			}
			sp->flags &= ~(SRVR_SOC_MARK | SRVR_SOC_NEW);

			/* interfaces can have duplicate addresses */
			if (listener == sp)
				continue;
			if (!listener) {
				listener = sp;
				if (!(sp->flags & SRVR_SOC_LISTEN)) {
					sp->flags |= SRVR_SOC_LISTEN;
					added = 1;
				}
			} else {
				if (sp->flags & SRVR_SOC_LISTEN) {
					sp->flags &= ~SRVR_SOC_LISTEN;
					added = 1;
				}
			}
		}
	}
#ifdef HAVE_FREEIFADDRS
	/* since this is done only a few times when HAVE_FREEIFADDRS is not
	 * defined, don't worry if we cannot release the list of interfaces */
	freeifaddrs(ifap0);
#endif

	if (num_ifs > 0)
		return added;
#endif /* HAVE_GETIFADDRS */

	/* if we got no joy from getifaddrs(), use INADDR_ANY */
	for (pport = ports; pport; pport = pport->fwd) {
		sp = add_srvr_soc(SRVR_SOC_IF | SRVR_SOC_LISTEN | SRVR_SOC_NEW,
				  AF_UNSPEC, 0, pport->port);
		if (sp->flags & SRVR_SOC_NEW) {
			added = 1;
			if (not_quiet)
				dcc_trace_msg("fallback listen on %s",
					      dcc_su2str_err(&sp->su));
		}
		sp->flags &= ~(SRVR_SOC_MARK | SRVR_SOC_NEW);
	}

	return added;
}



/* deal with changes to network interfaces */
static u_char				/* 1=something changed */
get_if_changes(u_char not_quiet)
{
	SRVR_SOC *sp, **spp;
	u_char changed;

	for (sp = srvr_socs; sp; sp = sp->fwd) {
		if (sp->flags & SRVR_SOC_IF)
			sp->flags |= SRVR_SOC_MARK;
	}

	changed = add_ifs(not_quiet);

	spp = &srvr_socs;
	while ((sp = *spp) != 0) {
		/* an interface recognized by add_srvr_soc() will have
		 * its SRVR_SOC_MARK cleared */
		if (!(sp->flags & SRVR_SOC_MARK)) {
			spp = &sp->fwd;
			continue;
		}

		/* forget interfaces that have disappeared */
		dcc_trace_msg("stop listening on %s", dcc_su2str_err(&sp->su));
		changed = 1;
		if (srvr_socs_end == &sp->fwd)
			srvr_socs_end = spp;
		*spp = sp->fwd;
		if (sp->udp >= 0)
			close(sp->udp);
		if (sp->listen >= 0)
			close(sp->listen);
		dcc_free(sp);
	}

	return changed;
}



static const char *
parse_rl_rate(RL_RATE *rate, float penalty_secs,
	      const char *label, const char *arg)
{
	char *p;
	int per_sec, hi;

	if (penalty_secs >= 0.0)
		rate->penalty_secs = penalty_secs;

	if (*arg == '\0')
		return arg;

	if (*arg == ',')
		return ++arg;

	per_sec = strtod(arg, &p) * RL_SCALE;
	hi = per_sec*RL_AVG_SECS;
	if ((*p != '\0' && *p != ',')
	    || hi < RL_SCALE || per_sec > RL_MAX_CREDITS) {
		dcc_error_msg("invalid %s value in \"%s\"",
			      label, arg);
		return "";
	}

	/* maximum events/second * RL_SCALE */
	rate->per_sec = per_sec;

	/* maximum allowed accumulated credits */
	rate->hi = hi;

	/* minimum credit account balance */
	rate->lo = -per_sec * rate->penalty_secs;

	return (*p == ',') ? p+1 : p;
}



static void
add_dbclean_flag(char flag)
{
	if (dbclean_flags_len >= MAX_DBCLEAN_FLAGS)
		dcc_logbad(EX_SOFTWARE, "too many flags for dbclean");
	dbclean_flags[dbclean_flags_len++] = flag;
}



static void
add_dbclean_arg(const char *arg)
{
	int i;

	if (dbclean_argc >= DIM(dbclean_argv)-2)
		dcc_logbad(EX_SOFTWARE, "too many args for dbclean");
	dbclean_argv[dbclean_argc++] = arg;
	i = snprintf(dbclean_args_str+dbclean_args_str_len,
		     sizeof(dbclean_args_str)-dbclean_args_str_len,
		     " %s", arg);
	dbclean_args_str_len += i;
	if (dbclean_args_str_len >= ISZ(dbclean_args_str)-2)
		dcc_logbad(EX_SOFTWARE, "too many args for dbclean");
}



/* check effort to repair database */
static void
check_dbclean(int options)
{
	int status;
	pid_t pid;
	u_char ok;

	if (dbclean_pid < 0)
		return;

	pid = waitpid(dbclean_pid, &status, options);
	if (pid != dbclean_pid)
		return;

	dbclean_pid = -1;

	/* do not try failing dbclean too often */
#if defined(WIFEXITED) && defined(WEXITSTATUS) && defined(WTERMSIG) && defined(WIFSIGNALED)
	ok = 1;
	if (WIFSIGNALED(status)) {
		dcc_error_msg("dbclean exited with signal %d",
			      WTERMSIG(status));
		ok = 0;
	} else if (WIFEXITED(status)) {
		status = WEXITSTATUS(status);
		if (status != EX_OK) {
			if (status > 100 && status < 130)
				dcc_error_msg("dbclean stopped after signal %d",
					      status-100);
			else
				dcc_error_msg("dbclean exited with status %d",
					      status);
			ok = 0;
		}
	}
#else
	ok = (status == EX_OK);
#endif
	if (ok) {
		dbclean_failed = 0;
		dbclean_limit_secs = DBCLEAN_LIMIT_SECS;
	} else {
		dbclean_failed = db_time.tv_sec;
		dbclean_limit_secs *= 2;
		if (dbclean_limit_secs > DEL_DBCLEAN_SECS)
			dbclean_limit_secs = DEL_DBCLEAN_SECS;
	}

	/* don't restart dbclean until after it has stopped running
	 * and cooled for a while */
	dbclean_limit = db_time.tv_sec + dbclean_limit_secs;
}



/* try to repair the database */
static void
run_dbclean(const char *mode,		/* combination of '', R, S, and W */
	    const char *reason)
{
	int i;

	check_dbclean(0);		/* wait until previous ends */

	wfix_later(WFIX_RECHECK_SECS);

	i = snprintf(&dbclean_flags[dbclean_flags_len],
		     ISZ(dbclean_flags)-dbclean_flags_len, "%s",
		     mode);
	if (i+dbclean_flags_len >= ISZ(dbclean_flags))
		dcc_logbad(EX_SOFTWARE, "too many flags for dbclean");

	dbclean_pid = fork();
	if (dbclean_pid < 0) {
		dcc_error_msg("dbclean fork(): %s", ERROR_STR());
	} else if (dbclean_pid == 0) {
		dcc_trace_msg("%s; starting `%s %s%s`",
			      reason, dbclean, dbclean_flags, dbclean_args_str);
		execv(dbclean, (char **)dbclean_argv);
		dcc_error_msg("execv(%s %s%s): %s",
			      dbclean, dbclean_flags, dbclean_args_str,
			      ERROR_STR());
		exit(-1);
	}

	need_del_dbclean = 0;
	dbclean_limit = db_time.tv_sec + dbclean_limit_secs;
}



static void
close_srvr_socs(void)
{
	SRVR_SOC *sp;

	for (sp = srvr_socs; sp; sp = sp->fwd) {
		if (sp->udp >= 0) {
			close(sp->udp);
			sp->udp = -1;
		}
		iflod_listen_close(sp);
	}
}



/* close files and otherwise clean up after being forked as a helper */
void
after_fork(void)
{
	IFLOD_INFO *ifp;
	OFLOD_INFO *ofp;

	resolve_hosts_pid = -1;
	dbclean_pid = -1;

	close_srvr_socs();
	for (ifp = iflods.infos; ifp <= LAST(iflods.infos); ++ifp) {
		if (ifp->soc >= 0)
			close(ifp->soc);
	}
	for (ofp = oflods.infos; ofp <= LAST(oflods.infos); ++ofp) {
		if (ofp->soc >= 0)
			close(ofp->soc);
	}

	signal(SIGHUP, SIG_DFL);
	signal(SIGTERM, SIG_DFL);
	signal(SIGINT, SIG_DFL);
	signal(SIGPIPE, SIG_DFL);
#ifdef SIGXFSZ
	signal(SIGXFSZ, SIG_DFL);
#endif
}



/* do not worry about cleaning to fix a window overflow for a while */
static void
wfix_later(time_t delay)
{
	dbclean_wfix_state = WFIX_DELAY;
	dbclean_wfix_secs = db_time.tv_sec + delay;
}



static double
wfix_measure(u_char force)
{
	double secs;

	secs = db_time.tv_sec - wfix_check_start;
	if (force || secs <= 0.0 || secs > WFIX_MEASURE_SECS*2
	    || total_ops < wfix_ops) {
		wfix_check_start = db_time.tv_sec;
		dbclean_wfix_secs = db_time.tv_sec + WFIX_MEASURE_SECS;
		wfix_ops = total_ops;
		return -1.0;
	}
	return (total_ops - wfix_ops) / secs;
}



static u_char				/* 1=need dbclean now */
wfix(char *reason, u_int reason_len)
{
	double rate;
	struct timeval sn;
	time_t next_clean;

	/* stop everything if dbclean is running */
	if (db_minimum_map || wfix_quiet_rate <= 0.0) {
		wfix_later(WFIX_RECHECK_SECS);
		return 0;
	}

	switch (dbclean_wfix_state) {
	case WFIX_DELAY:		/* just checking */
		if (!DB_IS_TIME(dbclean_wfix_secs, WFIX_MAX_SECS))
			return 0;

		/* no quick cleaning soon after the database was created,
		 * cleaned or repaired */
		dcc_ts2timeval(&sn, &db_parms.sn);
		if (sn.tv_sec > db_time.tv_sec)
			sn.tv_sec = 0;
		if (sn.tv_sec < dbclean_failed
		    && dbclean_failed <= db_time.tv_sec)
			sn.tv_sec = dbclean_failed;
		if (sn.tv_sec <= db_time.tv_sec) {
			dbclean_wfix_secs = sn.tv_sec + WFIX_POST_CLEAN_SECS;
			if (!DB_IS_TIME(dbclean_wfix_secs, WFIX_MAX_SECS))
				return 0;
		}

		/* check later if dbclean might run soon */
		next_clean = clean_fake_secs;
		if (db_time.tv_sec >= next_clean - WFIX_PRE_CLEAN_SECS) {
			dbclean_wfix_secs = next_clean + WFIX_POST_CLEAN_SECS;
			if (!DB_IS_TIME(dbclean_wfix_secs, WFIX_MAX_SECS))
				return 0;
		}
		next_clean = clean_last_secs + 24*60*60;
		if (db_time.tv_sec >= next_clean - WFIX_PRE_CLEAN_SECS) {
			dbclean_wfix_secs = next_clean + WFIX_POST_CLEAN_SECS;
			if (!DB_IS_TIME(dbclean_wfix_secs, WFIX_MAX_SECS))
				return 0;
		}

		/* check later if the database is not too large now */
		if (db_fsize + db_hash_fsize
		    < (wfix_size_set ? wfix_size : db_max_rss)) {
			wfix_later(WFIX_RECHECK_SECS);
			break;
		}
		/* the database is too big, so try to chase the clients
		 * to the other DCC server (if any) */
		dbclean_wfix_state = WFIX_BUSY;
		wfix_measure(1);
		break;

	case WFIX_BUSY:
		rate = wfix_measure(0);
		if (rate >= 0.0) {
			wfix_busy_rate = rate;
			dbclean_wfix_state = WFIX_QUIET;
			dbclean_wfix_secs = db_time.tv_sec + WFIX_QUIET_SECS;
		}
		break;

	case WFIX_QUIET:		/* waiting for clients to flee */
		dbclean_wfix_state = WFIX_CHECK;
		wfix_measure(1);
		break;

	case WFIX_CHECK:		/* counting clients */
		rate = wfix_measure(0);
		if (rate < 0.0)
			break;
		if (rate <= wfix_quiet_rate
		    || rate <= wfix_busy_rate * wfix_rate_change) {
			snprintf(reason, reason_len,
				 "database size "L_DPAT">"L_DPAT
				 "; load changed from %0.1f to %0.1f",
				 db_fsize + db_hash_fsize,
				 wfix_size_set ? wfix_size : db_max_rss,
				 wfix_busy_rate, rate);
			return 1;
		}
		/* Other DCC servers did not take over the load. Maybe later */
		if (db_debug)
			dcc_trace_msg("database size "L_DPAT" > "L_DPAT
				      ", but load changed from %0.1f to %0.1f",
				      db_fsize + db_hash_fsize,
				      wfix_size_set ? wfix_size : db_max_rss,
				      wfix_busy_rate, rate);
		wfix_later(WFIX_RECHECK_SECS);
		break;
	}

	return 0;
}



/* check for changes or other interesting events when the flood timer expires */
static time_t				/* microseconds to wait */
check_changes(void)
{
	static time_t misc_timer, files_timer;
	time_t secs;
	DB_HADDR hash_free;
	const char *mode;
	const char *reason;
	char reason_buf[100];

	reason = 0;
	mode = 0;

	if (db_failed_line) {
		snprintf(reason_buf, sizeof(reason_buf),
			 "database broken at line %d in %s "DCC_VERSION,
			 db_failed_line, db_failed_file);
		reason = reason_buf;
		mode = "Rbad";

	} else if ((hash_free
		    = db_hash_len - db_hash_used) < MIN_CLEAN_HASH_ENTRIES
		   || hash_free < db_hash_len/20) {
		/* try to expand the hash table when there are only
		 * a few free slots or the load factor rises above .95 */
		if (hash_free < MIN_HASH_ENTRIES)
			snprintf(reason_buf, sizeof(reason_buf),
				 "%d free hash entries",
				 hash_free);
		else
			snprintf(reason_buf, sizeof(reason_buf),
				 "%d free hash entries among %d total",
				 hash_free, db_hash_len);
		reason = reason_buf;
		mode = "Rhash";

	} else {
		/* check nothing else if it is not yet time */
		secs = next_flods_ck - db_time.tv_sec;
		if (secs > 0 && secs <= flods_ck_secs)
			return secs * DCC_US;
	}

	next_flods_ck = db_time.tv_sec + flods_ck_secs;

	/* do not make some checks too often even when flood checking is
	 * being rushed */
	if (DB_IS_TIME(misc_timer, MISC_CK_SECS)) {
		misc_timer = db_time.tv_sec + MISC_CK_SECS;

		/* shrink our memory footprint
		 * if we are so idle that we don't have anything to flush */
		if (db_need_flush_secs == 0) {
			if (db_unload(0, 1) == 1) {
				rel_db_states();
				db_unload(0, 1);
			}
		}

		if (DB_IS_TIME(files_timer, 30)) {
			files_timer = db_time.tv_sec + 30;

			if (0 >= check_load_ids(0))
				dcc_error_msg("check/reload: %s", dcc_emsg);

			check_blacklist_file();

#ifdef HAVE_GETIFADDRS
			/* check for network interface changes, but only
			 * if we can release the result of getifaddrs() */
			if (get_if_changes(1)) {
				int socs = open_srvr_socs(0);
				if (!socs)
					bad_stop("no server sockets");
				else if (socs > 0)
					flods_restart("new network interfaces",
						      1);
			}
#endif
		}

		if (DB_IS_TIME(need_clients_save, CLIENTS_SAVE_SECS))
			clients_save();

		/* sound a claim to our server-ID if the database is locked */
		if (DB_IS_TIME(host_id_next, DCC_SRVR_ID_SECS)
		    && DB_IS_LOCKED()
		    &&!db_failed_line ) {
			refresh_srvr_rcd(host_id_sum, my_srvr_id,
					 "adding server-ID claim");

			if (!db_failed_line ) {
				host_id_last = db_time.tv_sec;
				host_id_next = host_id_last + DCC_SRVR_ID_SECS;
			}
		}
	}

	/* note when hash expansion finishes and collect a zombie */
	check_dbclean(WNOHANG);

	if (reason != 0) {
		;

	} else if (DB_IS_TIME(clean_fake_secs, 3*24*60*60)
		   && (!db_minimum_map
		       || DB_IS_TIME(clean_last_secs+2*24*60*60, 4*24*60*60))) {
		reason = "work around broken cron job";
		mode = "Rcron";

	} else if (need_del_dbclean != 0
		   && DB_IS_TIME(del_dbclean_next, DEL_DBCLEAN_SECS)) {
		/* the deletion of a report needs to be cleaned up */
		reason = need_del_dbclean;
		mode = "Rdel";

	} else if (DB_IS_TIME(dbclean_wfix_secs, WFIX_MAX_SECS)
		   && wfix(reason_buf, sizeof(reason_buf))) {
		reason = reason_buf;
		mode = "Rquick";
	}

	if (reason) {
		if (!DB_IS_TIME(dbclean_limit, dbclean_limit_secs)) {
			if (next_flods_ck > dbclean_limit)
				next_flods_ck = dbclean_limit;
		} else if (dbclean_pid < 0) {
			run_dbclean(mode, reason);
		} else {
			RUSH_NEXT_FLODS_CK();
		}
	} else {
		flods_ck(0);
	}

	/* we probably delayed */
	gettimeofday(&db_time, 0);

	secs = next_flods_ck - db_time.tv_sec;
	return secs >= 0 ? secs*DCC_US : 0;
}



static void NRATTRIB
recv_job(void)
{
	fd_set rfds, *prfds, wfds, *pwfds;
#	define PFD_SET(_fd0,_fds) {int _fd = _fd0;	    \
		p##_fds = &_fds; FD_SET(_fd,p##_fds);	    \
		if (max_fd < _fd) max_fd = _fd;}
	int max_fd, nfds;
	IFLOD_INFO *ifp;
	OFLOD_INFO *ofp;
	struct timeval delay;
	time_t delay_us, slept_us, was_too_busy, us;
	struct timeval iflods_read, busy_time, extra_time;
	u_char db_has_failed;
#	define QUANTUM (DCC_US/10)	/* try to use only ~50% of the system */
	SRVR_SOC *sp;
	QUEUE *q;
	int bad_select;
	u_char worked;
	int fd, i;

	bad_select = 3;
	was_too_busy = 0;
	gettimeofday(&db_time, 0);
	iflods_read = db_time;
	busy_time = db_time;
	extra_time = db_time;
	delay_us = flods_ck_secs*DCC_US;
	db_has_failed = 0;
	for (;;) {
		dcc_emsg[0] = '\0';

		if (stopint) {
			flods_ck_secs = SHUTDOWN_DELAY;
			if (flods_off < 100000) {
				flods_off = 100000;
				flods_stop("server stopping", 0);
				check_dbclean(WNOHANG);
				if (dbclean_pid > 0) {
					kill(dbclean_pid, SIGINT);
					usleep(100*1000);
				}
				/* get started flushing the database while
				 * we wait for flooding to stop */
				rel_db_states();
				db_minimum_map = 1;
				db_unload(0, 2);
			}
			/* get serious when the floods have stopped */
			if (oflods.total == 0) {
				if (stopint < 0)
					dccd_quit(0, "gracefully stopping%s",
						  stop_mode == 1
						  ? " for reboot"
						  : stop_mode == 2
						  ? " cleanly"
						  : "");
				dccd_quit(stopint | 128,
					  "exiting with signal %d", stopint);
			}
		}

		if (db_has_failed != db_failed_line) {
			db_has_failed = db_failed_line;
			if (db_failed_line) {
				++flods_off;
				flods_stop("database corrupt", 1);
				rel_db_states();
				db_unload(0, 2);
				db_unlock();
			}
		}

		FD_ZERO(&rfds);
		prfds = 0;
		FD_ZERO(&wfds);
		pwfds = 0;
		max_fd = -1;

		/* look for client requests */
		for (sp = srvr_socs; sp; sp = sp->fwd) {
			if (sp->udp >= 0)
				PFD_SET(sp->udp, rfds);
		}

		if (was_too_busy > 0)
			was_too_busy = QUANTUM - tv_diff2us(&db_time,
							&busy_time);
		if (was_too_busy > 0
		    && (tv_diff2us(&db_time, &extra_time)
			< min(30, min(KEEPALIVE_IN, KEEPALIVE_OUT)/2))
		    && FLODS_OK()) {
			/* if we have been too busy,
			 * then do nothing extra for a while */
			if (delay_us > was_too_busy)
				delay_us = was_too_busy;
		} else {
			extra_time = db_time;

			/* Accept new incoming flood connections
			 * if flooding is on
			 * and we don't already have too many floods. */
			if (iflods.open < DCCD_MAX_FLOODS) {
				for (sp = srvr_socs; sp; sp = sp->fwd) {
					if (sp->listen >= 0)
					    PFD_SET(sp->listen, rfds);
				}
			}

			/* pump floods out */
			for (ofp = oflods.infos, i = 0;
			     i < oflods.open;
			     ++ofp) {
				if (ofp->soc < 0)
					continue;
				++i;
				if (ofp->flags & OFLOD_FG_CONNECTED) {
					PFD_SET(ofp->soc, rfds);
					if (!(ofp->flags & OFLOD_FG_EAGAIN)
					    && ofp->obuf_len != 0)
					    PFD_SET(ofp->soc, wfds);
				} else {
					PFD_SET(ofp->soc, wfds);
				}
			}

			/* pump floods in */
			for (ifp = iflods.infos, i = 0;
			     i < iflods.open;
			     ++ifp) {
				if (ifp->soc < 0)
					continue;
				++i;
				if (ifp->flags & IFLOD_FG_CONNECTED) {
					PFD_SET(ifp->soc, rfds);
				} else {
					PFD_SET(ifp->soc, wfds);
				}
			}
		}

		/* push data to the disk */
		if (db_need_flush_secs != 0) {
			if (DB_IS_TIME(db_need_flush_secs,
				       max(DB_URGENT_NEED_FLUSH_SECS,
					   DB_NEED_FLUSH_SECS))) {
				db_flush_needed();
				gettimeofday(&db_time, 0);
			}
			us = db_need_flush_secs - db_time.tv_sec;
			if (us >= 0) {
				us *= DCC_US;
				if (delay_us > us)
					delay_us = us;
			}
		}

		/* let dbclean run if we have run out of work
		 * or if we have been holding the lock for 0.1 seconds*/
		if (db_minimum_map
		    && DB_IS_LOCKED()
		    && (delay_us != 0
			|| tv_diff2us(&db_time, &db_locked) >= DCC_US/10)) {
			db_unlock();
		}

		/* delay until it is time to answer the oldest anonymous
		 * request or something else that needs doing */
		delay.tv_sec = delay_us/DCC_US;
		delay.tv_usec = delay_us%DCC_US;
		nfds = select(max_fd+1, prfds, pwfds, 0, &delay);
		if (nfds < 0) {
			if (errno != EINTR) {
				if (--bad_select < 0)
					bad_stop("give up after select(): %s",
						 ERROR_STR());
				else
					dcc_error_msg("select(): %s",
						      ERROR_STR());
			}
			/* ignore EINTR but recompute timers */
			FD_ZERO(&rfds);
			FD_ZERO(&wfds);
		} else {
			bad_select = 3;
		}

		gettimeofday(&wake_time, 0);
		slept_us = tv_diff2us(&wake_time, &db_time);
		if (slept_us >= 500) {
			/* If select() paused for at least 0.5 millisecond,
			 * then the waiting request has just now arrived. */
			req_recv_time = wake_time;
		} else {
			/* If select() did not pause, then assume the waiting
			 * requests arrived when we were half finished working
			 * on flooding and other work besides ordinary requests
			 * before calling select(). */
			tv_add_us(&req_recv_time,
				  tv_diff2us(&wake_time, &req_recv_time) / 2);
		}
		db_time = wake_time;

		worked = 0;
		for (sp = srvr_socs; sp; sp = sp->fwd) {
			/* queue a new anonymous request
			 * or answer a new authenticated request */
			fd = sp->udp;
			if (fd >= 0 && FD_ISSET(fd, &rfds)) {
				--nfds;
				worked = 1;
				while (new_job(sp))
					continue;
			}

			/* start a new incoming flood */
			fd = sp->listen;
			if (fd >= 0 && FD_ISSET(fd, &rfds)) {
				--nfds;
				worked = 1;
				iflod_start(sp);
			}
		}
		if (worked)
			gettimeofday(&db_time, 0);
		/* reset request receipt clock for next time */
		req_recv_time = db_time;

		/* Accept new flood data or start new SOCKS floods.
		 * Listen to all peers to prevent starvation */
		worked = 0;
		for (ifp = iflods.infos, i = 0;
		     nfds > 0 && i < iflods.open;
		     ++ifp) {
			if (ifp->soc < 0)
				continue;
			++i;
			if (FD_ISSET(ifp->soc, &rfds)
			    || FD_ISSET(ifp->soc, &wfds)) {
				--nfds;
				iflod_read(ifp);
				worked = 1;
			}
		}
		if (worked) {
			gettimeofday(&db_time, 0);
			iflods_read = db_time;
		} else if (was_too_busy <= 0) {
			/* if incoming floods have been quiet for
			 * awhile, then assume flooding has caught up
			 * after having been turned off */
			if (tv_diff2us(&wake_time, &iflods_read) > 2*DCC_US)
				iflods_ok_timer = db_time.tv_sec;
		}

		/* pump output flood data and receive confirmations
		 * talk to all peers to prevent starvation */
		worked = 0;
		for (ofp = oflods.infos, i = 0;
		     nfds > 0 && i < oflods.open;
		     ++ofp) {
			if (ofp->soc < 0)
				continue;
			++i;
			if (FD_ISSET(ofp->soc, &rfds)) {
				--nfds;
				oflod_read(ofp);
				if (ofp->soc < 0)
					continue;
			}
			if (FD_ISSET(ofp->soc, &wfds)) {
				--nfds;
				oflod_write(ofp);
				worked = 1;
			}
		}
		if (worked)
			gettimeofday(&db_time, 0);

		/* process delayed jobs when their times arrive */
		worked = 0;
		for (;;) {
			q = queue_head;
			if (!q) {
				delay_us = flods_ck_secs*DCC_US;
				break;
			}

			/* decide whether this job's time has come
			 * while defending against time jumps */
			delay_us = tv_diff2us(&q->answer, &db_time);
			if (delay_us >= 1000
			    && delay_us <= DCC_MAX_RTT
			    && !stopint)
				break;  /* not yet time for next job */

			queue_head = q->later;
			if (queue_head)
				queue_head->earlier = 0;
			--queue_cur;
			do_work(q);
			worked = 1;
			free_q(q);
		}
		if (worked)
			gettimeofday(&db_time, 0);

		/* check configuration changes etc. */
		us = check_changes();
		if (delay_us >= us)
			delay_us = us;

		us = tv_diff2us(&db_time, &wake_time);
		if (us >= QUANTUM && !stopint) {
			gettimeofday(&db_time, 0);
			busy_time = db_time;
			was_too_busy = QUANTUM;
		}
	}
}



static void
add_queue(QUEUE *q)
{
	QUEUE *qnext, **qp;

	TMSG1(QUERY, "received %s", op_id_ip(q));
	if (!ck_clnt_id(q)) {
		free_q(q);
		return;
	}

	++total_ops;

	/* immediately process requests from authenticated clients
	 * if flooding is working */
	if (q->delay_us == 0) {
		do_work(q);
		free_q(q);
		return;
	}

	/* don't let the queue of delayed requests get too large */
	if (queue_cur >= queue_max) {
		clnt_msg(q, "drop excess queued %s", op_id_ip(q));
		free_q(q);
		return;
	}

	tv_add_us(&q->answer, q->delay_us);

	/* add the new job to the queue */
	++queue_cur;
	qp = &queue_head;
	for (;;) {
		qnext = *qp;
		if (!qnext) {
			*qp = q;
			break;
		}
		if (qnext->answer.tv_sec > q->answer.tv_sec
		    || (qnext->answer.tv_sec == q->answer.tv_sec
			&& qnext->answer.tv_usec > q->answer.tv_usec)) {
			q->later = qnext;
			qnext->earlier = q;
			*qp = q;
			break;
		}
		q->earlier = qnext;
		qp = &qnext->later;
	}
}



/* get a new job in a datagram */
static u_char				/* 1=call again */
new_job(SRVR_SOC *sp)
{
	QUEUE *q;
	static struct iovec iov = {0, sizeof(q->pkt)};
	static struct msghdr msg;
	int i, j;

	/* Find a free queue entry for the job.
	 * Because we don't check for incoming jobs unless we think the
	 * queue is not full, there must always be a free entry or
	 * permission to make more entries. */
	q = queue_free;
	if (q) {
		queue_free = q->later;
	} else {
		i = 16;
		q = dcc_malloc(i * sizeof(*q));
		if (!q)
			dcc_logbad(EX_UNAVAILABLE,
				   "malloc(%d queue entries) failed", i);
		queue_max_cur += i;
		/* put all but the last new queue entry on the free list */
		while (--i > 0) {
			q->later = queue_free;
			queue_free = q;
			++q;
		}
	}

	memset(q, 0, sizeof(*q));
	q->sp = sp;
	iov.iov_base = (char *)&q->pkt;
	msg.msg_name = (void *)&q->clnt_su;
	msg.msg_namelen = sizeof(q->clnt_su);
	msg.msg_iov = &iov;
	msg.msg_iovlen = 1;
	i = recvmsg(sp->udp, &msg, 0);
	if (i < 0) {
		/* ignore some results of ICMP unreachables for UDP
		 * retransmissions seen on some platforms */
		if (DCC_BLOCK_ERROR()) {
			;
		} else if (UNREACHABLE_ERRORS()) {
			TMSG2(QUERY, "recvmsg(%s): %s",
			      dcc_su2str_err(&sp->su), ERROR_STR());
		} else {
			dcc_error_msg("recvmsg(%s): %s",
				      dcc_su2str_err(&sp->su), ERROR_STR());
		}
		free_q(q);
		return 0;
	}
	if (q->clnt_su.sa.sa_family != sp->su.sa.sa_family
	    && !dcc_ipv4sutoipv6(&q->clnt_su, &q->clnt_su)) {
		dcc_error_msg("recvmsg address family %d instead of %d",
			      q->clnt_su.sa.sa_family,
			      sp->su.sa.sa_family);
		free_q(q);
		return 1;
	}

	if (DCC_SU_PORT(&q->clnt_su) == 0) {
		drop_msg(q, "source port 0");
		free_q(q);
		return 1;
	}

	q->pkt_len = i;
	if (i < ISZ(DCC_HDR)) {
		drop_msg(q, "short request of %d bytes", i);
		free_q(q);
		return 1;
	}
	j = ntohs(q->pkt.hdr.len);
	if (j != i) {
		drop_msg(q, "request with header length %d instead of %d",
			 j, i);
		free_q(q);
		return 1;
	}

	if (q->pkt.hdr.pkt_vers > DCC_PKT_VERSION_MAX_VALID
	    || q->pkt.hdr.pkt_vers < DCC_PKT_VERSION_MIN_VALID
	    || ((q->pkt.hdr.pkt_vers > DCC_PKT_VERSION_MAX
		 || q->pkt.hdr.pkt_vers < DCC_PKT_VERSION_MIN)
		&& q->pkt.hdr.op != DCC_OP_NOP)) {
		drop_msg(q, "%s in unrecognized protocol version #%d",
			 qop2str(q), q->pkt.hdr.pkt_vers);
		free_q(q);
		return 1;
	}

	q->answer = req_recv_time;

	switch ((DCC_OPS)q->pkt.hdr.op) {
	case DCC_OP_NOP:
		do_nop(q);
		free_q(q);
		return 1;

	case DCC_OP_REPORT:
		if (db_parms.flags & DB_PARM_FG_GREY)
			break;		/* not valid for greylist servers */
		add_queue(q);
		return 1;

	case DCC_OP_QUERY:
		add_queue(q);
		return 1;

	case DCC_OP_ADMN:
		do_admn(q);
		free_q(q);
		return 1;

	case DCC_OP_DELETE:
		do_delete(q);
		free_q(q);
		return 1;

	case DCC_OP_GREY_REPORT:
	case DCC_OP_GREY_QUERY:
	case DCC_OP_GREY_WHITE:
		if (!(db_parms.flags & DB_PARM_FG_GREY))
			break;		/* valid only for greylist servers */
		do_grey(q);
		free_q(q);
		return 1;

	case DCC_OP_GREY_SPAM:
		if (!(db_parms.flags & DB_PARM_FG_GREY))
			break;		/* valid only for greylist servers */
		do_grey_spam(q);
		free_q(q);
		return 1;

	case DCC_OP_INVALID:
	case DCC_OP_ANSWER:
	case DCC_OP_OK:
	case DCC_OP_ERROR:
		break;
	}

	drop_msg(q, "invalid %s", op_id_ip(q));
	free_q(q);
	return 1;
}



void
free_q(QUEUE *q)
{
	if (q->rl)
		--q->rl->ref_cnt;
	q->later = queue_free;
	queue_free = q;
}



u_char
dccd_db_open(u_char lock_mode)
{
	DCC_CK_TYPES type;
	time_t clean_secs;
	DCC_TGTS tgts;
	int i;

	if (!db_open(dcc_emsg, -1, 0, 0, lock_mode | db_mode))
		return 0;

	if (grey_on) {
		/* for greylisting, ignore the args an silently impose our
		 * notion of which checksums to keep and flooding thresholds */
		db_parms.nokeep_cks = def_nokeep_cks();
		if (grey_weak_ip)
			DB_RESET_NOKEEP(db_parms.nokeep_cks, DCC_CK_IP);

		for (type = DCC_CK_TYPE_FIRST;
		     type <= DCC_CK_TYPE_LAST;
		     ++type) {
			if (type == DCC_CK_SRVR_ID) {
				flod_tholds[type] = 1;
				continue;
			}

			if (DB_TEST_NOKEEP(db_parms.nokeep_cks, type))
				flod_tholds[type] = DCC_TGTS_INVALID;
			else
				flod_tholds[type] = 1;

			if (DCC_CK_IS_GREY_TRIPLE(grey_on,type)
			    || type == DCC_CK_IP) {
				db_parms.ex_secs[type].all = grey_window;
				db_parms.ex_secs[type].spam = grey_white;
			} else if (type == DCC_CK_BODY
				   || DCC_CK_IS_GREY_MSG(grey_on,type)) {
				db_parms.ex_secs[type].all = grey_window;
				db_parms.ex_secs[type].spam = grey_window;
			} else {
				db_parms.ex_secs[type].all = 1;
				db_parms.ex_secs[type].spam = 1;
			}
		}

		summarize_delay_secs = grey_embargo - FLODS_CK_SECS*2;

	} else {
		/* impose our notion of which normal checksums to keep */
		DB_SET_NOKEEP(set_new_nokeep_cks, DCC_CK_FLOD_PATH);
		DB_SET_NOKEEP(set_new_nokeep_cks, DCC_CK_INVALID);
		DB_SET_NOKEEP(set_new_nokeep_cks, DCC_CK_REP_TOTAL);
		DB_SET_NOKEEP(set_new_nokeep_cks, DCC_CK_REP_BULK);
		db_parms.nokeep_cks = ((def_nokeep_cks()
					& ~reset_new_nokeep_cks)
				       | set_new_nokeep_cks);

		for (type = DCC_CK_TYPE_FIRST;
		     type <= DCC_CK_TYPE_LAST;
		     ++type) {
			if (type == DCC_CK_SRVR_ID) {
				flod_tholds[type] = 1;
				continue;
			}

			if (type == DCC_CK_REP_TOTAL)
				tgts = DCC_TGTS_INVALID;
			if (DB_TEST_NOKEEP(db_parms.nokeep_cks, type))
				tgts = DCC_TGTS_INVALID;
			else if (DCC_CK_IS_REP_CMN(0, type))
				tgts = DCC_TGTS_INVALID;
			else
				tgts = BULK_THRESHOLD;
			flod_tholds[type] = tgts;
		}

		/* We should not delay reports or summaries so much that
		 * dbclean might expire them before we can summarize them. */
		summarize_delay_secs = DCC_OLD_SPAM_SECS;
		for (type = DCC_CK_TYPE_FIRST;
		     type <= DCC_CK_TYPE_LAST;
		     ++type) {
			if (DB_TEST_NOKEEP(db_parms.nokeep_cks, type))
				continue;
			i = db_parms.ex_secs[type].spam;
			if (i != 0 && summarize_delay_secs > i)
				summarize_delay_secs = i;
		}
	}
	if (summarize_delay_secs < 1)
		summarize_delay_secs = 1;

	/* adjust the thresholds after possible changes to kept checksums */
	set_db_tholds(db_parms.nokeep_cks);

	/* If we instead of cron asked for the last cleaning, make a note
	 * to clean the database during the graveyard shift.
	 * Otherwise the database will bloat while the cron job is broken.
	 *
	 * Compute 1 day + 45 minutes after cron should have last cleaned the
	 *	database, if it has been cleaned by cron within the last 3 days
	 * or the quarter hour when it was last cleaned by this mechanism
	 *	provided that was between local midnight and 05:00
	 * or 3 minutes past a random quarter hour beteen midnight and 05:00 */
	if (db_parms.cleaned_cron >= db_time.tv_sec - 3*24*60*60
	    && db_parms.cleaned_cron <= db_time.tv_sec) {
		clean_last_secs = db_parms.cleaned_cron;
		/* failsafe cleaning for the greylist database starts 15 minutes
		 * before the main database */
		clean_secs = clean_last_secs + 45*60 - grey_on*15*60;
	} else {
		struct tm tm;

		clean_last_secs = db_parms.cleaned;
		if (clean_last_secs >= db_time.tv_sec)
			clean_last_secs = 0;
		clean_secs = clean_last_secs;

		/* if the previous time for this mechanism is not good,
		 * pick a new random time */
		dcc_localtime(clean_secs, &tm);
		if (clean_secs == 0 || tm.tm_hour < 1 || tm.tm_hour >= 5) {
			int rnum = (u_int)(db_time.tv_sec + db_time.tv_usec
					   + my_srvr_id - grey_on) % 23;
			tm.tm_hour = ((rnum / 4) % 4) + 1;
			tm.tm_min = (rnum % 4) * 15;
			clean_secs = mktime(&tm);
		}
	}
	/* round down to a quarter hour to prevent creep due to inevitiable
	 * delays in cron or this mechanism starting dbclean */
	clean_secs -= clean_secs % (15*60);
	clean_secs %= (24*60*60);	/* failsafe cleaning target minute */

	/* compute the next scheduled failsafe cleaning. */
	clean_fake_secs = db_time.tv_sec - (db_time.tv_sec % (24*60*60));
	clean_fake_secs += clean_secs;
	if (clean_fake_secs <= db_time.tv_sec)
		clean_fake_secs += 24*60*60;

	/* The next failsafe cleaning should happen a day after the
	 * most recent cron or failsafe cleaning, modulo the delay before
	 * dbclean starts */
	while (clean_fake_secs <= clean_last_secs + 24*60*60 - 60*60)
		clean_fake_secs += 24*60*60;

	/* Do not failsafe clean during the first 48 hours after the
	 * database was created to give the cron job a chance.
	 * We do not want failsafe cleaning to ever be running when the
	 * cron job tries to start. */
	while (clean_fake_secs <= db_parms.cleared + 2*24*60*60
	       && db_parms.cleared <= db_time.tv_sec)
		clean_fake_secs += 24*60*60;

	total_ops = 0;

	/* push our thresholds and flags to the file */
	return db_flush_parms(0);
}



/* clean shut down */
static void NRATTRIB
dccd_quit(int exitcode, const char *p, ...)
{
	va_list args;

	if (stop_mode == 1)
		db_stop();
	else if (stop_mode == 2)
		make_clean(2);
	db_unlock();

	va_start(args, p);
	if (exitcode)
		dcc_verror_msg(p, args);
	else
		dcc_vtrace_msg(p, args);
	va_end(args);

	/* db_close() can take a long time, so close some things early. */
	stop_children();
	check_dbclean(WNOHANG);
	clients_save();

#ifdef HAVE_COHERENT_MMAP
	/* If mmap() is not coherent, do not call close_srvr_socs() but
	 * keep the UDP sockets open to prevent another server from starting
	 * until we have flushed our buffers to prevent problems on systems
	 * that lack inter-process coherent mmap() */
	if (!(db_mode & DB_OPEN_MMAP_WRITE))
		close_srvr_socs();
#endif
	db_close(1);

	if (exitcode)
		dcc_error_msg("stopped");
	else
		dcc_trace_msg("stopped");
	exit(exitcode);
}



/* watch for fatal signals */
static void
sigterm(int sig)
{
	stopint = sig;
	stop_mode = 1;
	next_flods_ck = 0;
	(void)signal(sig, SIG_DFL);	/* catch it only once */
}



/* SIGHUP hurries checking the configuration files */
static void
sighup(int sig UATTRIB)
{
	next_flods_ck = 0;
}



/* emergency shutdown but close the database cleanly */
void
bad_stop(const char *pat, ...)
{
	va_list args;

	if (stopint)
		return;

	va_start(args, pat);
	dcc_verror_msg(pat, args);
	va_end(args);

	stopint = -1;
	next_flods_ck = 0;
}



static void
stop_children(void)
{
	if (resolve_hosts_pid > 0)
		kill(resolve_hosts_pid, SIGKILL);

	if (dbclean_pid > 0)
		kill(dbclean_pid, SIGKILL);
}