notdcc: dccd/work.c comparison

comparison dccd/work.c @ 0:c7f6b056b673

First import of vendor version

author	Peter Gervai <grin@grin.hu>
date	Tue, 10 Mar 2009 13:49:58 +0100
parents
children

comparison

equal deleted inserted replaced

--1:000000000000
+:c7f6b056b673
+/* Distributed Checksum Clearinghouse
+*
+* work on a job in the 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.287 $Revision$
+*/
+#include "dccd_defs.h"
+typedef struct {
+time_t us;
+u_int   ops;
+} Q_DELAY_SEC;
+static Q_DELAY_SEC q_delays[9];
+static Q_DELAY_SEC q_delays_sum;	/* sum of all but q_delays[0] */
+static time_t q_delays_start;		/* second for q_delayw[0] */
+DCCD_STATS dccd_stats;
+u_char query_only;			/* 1=treat reports as queries */
+u_char grey_weak_body;			/* 1=ignore bodies for greylisting */
+u_char grey_weak_ip;			/* 1=a good triple whitelists addr */
+static u_char ridc_get(QUEUE *);
+/* report cache used to detect duplicate or retransmitted reports */
+static RIDC *ridc_newest, *ridc_oldest;
+static RIDC **ridc_hash;
+static int ridc_hash_len;
+static inline RIDC **
+ridc_hash_fnc(DCC_HDR *hdr)
+{
+	u_int32_t sum;
+	/* The client's (ID,RID,HID,PID) should be unique and constant for
+	 * retransmissions of a single request.  It should make a reasonable
+	 * hash value.  We cannot trust it entirely, if only because of
+	 * anonymous clients */
+	sum = hdr->sender;
+	sum += hdr->op_nums.h;
+	sum += hdr->op_nums.p;
+	sum += hdr->op_nums.r;
+	return &ridc_hash[mhash(sum, ridc_hash_len)];
+}
+static void
+ridc_ref(RIDC *ridc)
+{
+	ridc->last_used = db_time.tv_sec;
+	if (!ridc->newer)
+		return;			/* it's already newest */
+	ridc->newer->older = ridc->older;
+	if (ridc->older)
+		ridc->older->newer = ridc->newer;
+	else
+		ridc_oldest = ridc->newer;
+	ridc->older = ridc_newest;
+	ridc->newer = 0;
+	ridc_newest->newer = ridc;
+	ridc_newest = ridc;
+}
+/* get a free report cache block */
+static RIDC *
+ridc_get_free(void)
+{
+	RIDC *ridc;
+	time_t stale = db_time.tv_sec - DCC_MAX_RETRANS_DELAY_SECS;
+	for (ridc = ridc_oldest; ridc != 0; ridc = ridc->newer) {
+		if (ridc->last_used < stale) {
+			/* found one, so recycle it */
+			if (ridc->fwd)
+				ridc->fwd->bak = ridc->bak;
+			if (ridc->bak)
+				ridc->bak->fwd = ridc->fwd;
+			else if (ridc->hash)
+				*ridc->hash = ridc->fwd;
+			ridc->bak = 0;
+			ridc_ref(ridc);
+			return ridc;
+		}
+	}
+	/* there are no free blocks that are old enough to recycle */
+	return 0;
+}
+/* make some (more) RID blocks and (re)build the hash table */
+static void
+ridc_make(void)
+{
+	int new_len, old_len, j;
+	RIDC *ridc, *ridc2, **ridch, **old_ridc_hash;
+	new_len = queue_max;
+	ridc = dcc_malloc(new_len*sizeof(*ridc));
+	if (!ridc)
+		dcc_logbad(EX_OSERR, "malloc(%d RIDC blocks) failed",
+			   new_len);
+	memset(ridc, 0, new_len*sizeof(*ridc));
+	for (j = 0; j < new_len; ++j, ++ridc) {	/* make the new blocks oldest */
+		if (!ridc_oldest) {
+			ridc_oldest = ridc_newest = ridc;
+		} else {
+			ridc_oldest->older = ridc;
+			ridc->newer = ridc_oldest;
+			ridc_oldest = ridc;
+		}
+	}
+	/* rebuild and expand the hash table */
+	old_len = ridc_hash_len;
+	ridc_hash_len += new_len;
+	old_ridc_hash = ridc_hash;
+	ridc_hash = dcc_malloc(ridc_hash_len*sizeof(*ridch));
+	if (!ridc_hash)
+		dcc_logbad(EX_OSERR, "malloc(%d RIDC hash table) failed",
+			   ridc_hash_len);
+	memset(ridc_hash, 0, ridc_hash_len*sizeof(*ridch));
+	if (old_len != 0) {
+		do {
+			for (ridc = old_ridc_hash[--old_len];
+			     ridc != 0;
+			     ridc = ridc2) {
+				ridch = ridc_hash_fnc(&ridc->hdr);
+				ridc2 = ridc->fwd;
+				ridc->bak = 0;
+				ridc->hash = ridch;
+				if ((ridc->fwd = *ridch) != 0)
+					ridc->fwd->bak = ridc;
+				*ridch = ridc;
+			}
+		} while (old_len != 0);
+		dcc_free(old_ridc_hash);
+	}
+}
+/* get the report cache block for an operation */
+static u_char				/* 0=new operation, 1=retransmission */
+ridc_get(QUEUE *q)
+{
+	RIDC *ridc, **ridch;
+	for (;;) {
+		if (ridc_hash) {
+			/* look for the existing report cache block */
+			ridch = ridc_hash_fnc(&q->pkt.hdr);
+			for (ridc = *ridch; ridc; ridc = ridc->fwd) {
+				/* Reports are relatively small, so we
+				 * can afford to not trust the client's
+				 * RID to be unique.  Compare all but the
+				 * client's transmission #.
+				 * Also check client's UDP port # because
+				 * it should be unchanged regardless of
+				 * multi-homing. */
+				if (ridc->clnt_port == q->clnt_su.ipv4.sin_port
+				    && !memcmp(&ridc->hdr, &q->pkt.hdr,
+					       sizeof(ridc->hdr)
+					       - sizeof(ridc->hdr.op_nums.t))) {
+					/* found it, so make it newest */
+					ridc_ref(ridc);
+					q->ridc = ridc;
+					return 1;
+				}
+			}
+			/* the block does not already exist, so create it */
+			ridc = ridc_get_free();
+			if (ridc)
+				break;
+		}
+		/* we are out of report cache blocks, so make more */
+		ridc_make();
+		/* re-hash because our previous pointer is invalid */
+	}
+	memcpy(&ridc->hdr, &q->pkt.hdr, sizeof(ridc->hdr));
+	ridc->clnt_port = q->clnt_su.ipv4.sin_port;
+	ridc->op = DCC_OP_INVALID;
+	ridc->bad = 1;
+	ridc->len = 0;
+	ridc->hash = ridch;
+	ridc->fwd = *ridch;
+	if (ridc->fwd)
+		ridc->fwd->bak = ridc;
+	*ridch = ridc;
+	q->ridc = ridc;
+	return 0;
+}
+#define RIDC_BAD(q) {if ((q)->ridc) (q)->ridc->bad = 1;}
+/* update the average queue delay at the start of a new second */
+static void
+update_q_delay(void)
+{
+	time_t secs;
+	Q_DELAY_SEC *src, *tgt;
+	secs = db_time.tv_sec - q_delays_start;
+	if (secs == 0)
+		return;
+	/* At the start of a new second,
+	 * forget the delays for old seconds we no longer care about
+	 * and start accumulating delays for the new second
+	 * Slide accumulated delays and total operations previous seconds. */
+	q_delays_start = db_time.tv_sec;
+	q_delays_sum.us = 0;
+	q_delays_sum.ops = 0;
+	tgt = LAST(q_delays);
+	if (secs > 0 && secs < DIM(q_delays)) {
+		src = tgt - secs;
+		do {
+			q_delays_sum.us += (tgt->us = src->us);
+			q_delays_sum.ops += (tgt->ops = src->ops);
+			--tgt;
+		} while (src-- != &q_delays[0]);
+	}
+	memset(q_delays, 0, sizeof(q_delays[0]) * (tgt+1 - q_delays));
+}
+/* compute the average queue delay this client should see */
+static u_int
+avg_q_delay_ms(const QUEUE *q)
+{
+	u_int ops;
+	time_t us;
+	/* get the average service delay excluding per-client-ID delays */
+	update_q_delay();
+	ops = q_delays[0].ops + q_delays_sum.ops;
+	if (ops == 0)
+		us = 0;
+	else
+		us = (q_delays[0].us + q_delays_sum.us + ops/2) / ops;
+	/* add the per-client-ID penalty */
+	us += q->delay_us;
+	return (us + 500) / 1000;
+}
+/* get a unique timestamp */
+static void
+get_ts(DCC_TS *ts)			/* put it here */
+{
+	static struct timeval prev_time;
+	static int faked;
+	/* if we have generated a lot of fake timestamps
+	 * and our snapshot of the clock is old,
+	 * then check the clock in the hope it has ticked */
+	if (db_time.tv_usec <= prev_time.tv_usec
+	    && db_time.tv_sec == prev_time.tv_sec
+	    && faked > 100) {
+		faked = 0;
+		gettimeofday(&db_time, 0);
+	}
+	/* Try to make the next timestamp unique, but only as long
+	 * as time itself marches forward.  This must work many times
+	 * a second, or the resoltion of DCC timestaps.
+	 * Worse, the increment can exhaust values from future seconds.
+	 * Forget about it if the problem lasts for more than 5 minutes. */
+	if (db_time.tv_sec > prev_time.tv_sec
+	    || (db_time.tv_sec == prev_time.tv_sec
+		&& db_time.tv_usec > prev_time.tv_usec)
+	    || db_time.tv_sec < prev_time.tv_sec-5*60) {
+		/* either the current time is good enough or we must
+		 * give up and use it to make the timestamp */
+		prev_time = db_time;
+		faked = 0;
+	} else {
+		/* fudge the previous timestamp to make it good enough */
+		prev_time.tv_usec += DCC_TS_US_MULT;
+		if (prev_time.tv_usec >= DCC_US) {
+			prev_time.tv_usec -= DCC_US;
+			++prev_time.tv_sec;
+		}
+		++faked;
+	}
+	dcc_timeval2ts(ts, &prev_time, 0);
+}
+/* find database record for a server-ID
+*	use only db_sts.hash and db_sts.rcd2
+*	put the result in db_sts.rcd2 */
+int					/* -1=broken database 0=no record */
+find_srvr_rcd(const DCC_SUM sum, const char *str)
+{
+	DB_RCD_CK *found_ck;
+	DB_PTR prev;
+	int failsafe;
+	switch (db_lookup(dcc_emsg, DCC_CK_SRVR_ID, sum,
+			  0, MAX_HASH_ENTRIES,
+			  &db_sts.hash, &db_sts.rcd2, &found_ck)) {
+	case DB_FOUND_LATER:
+	case DB_FOUND_SYSERR:
+		DB_ERROR_MSG2(str, dcc_emsg);
+		return -1;
+	case DB_FOUND_IT:
+		/* look for a record that is neither obsolete nor deleted */
+		for (failsafe = 0; failsafe < 20; ++failsafe) {
+			if (!DB_CK_OBS(found_ck)
+			    && DB_TGTS_RCD(db_sts.rcd2.d.r) != 0)
+				return 1;
+			prev = DB_PTR_EX(found_ck->prev);
+			if (prev == DB_PTR_NULL)
+				return 0;
+			found_ck = db_map_rcd_ck(dcc_emsg, &db_sts.rcd2, prev,
+						 DCC_CK_SRVR_ID);
+			if (!found_ck) {
+				DB_ERROR_MSG2(str, dcc_emsg);
+				return -1;
+			}
+		}
+		break;
+	case DB_FOUND_EMPTY:
+	case DB_FOUND_CHAIN:
+	case DB_FOUND_INTRUDER:
+		break;
+	}
+	return 0;
+}
+/* find the database record of the type of a server
+*	use only db_sts.hash and db_sts.rcd2
+*	put the result in db_sts.rcd2 */
+int					/* -1=broken database 0=no record */
+find_srvr_rcd_type(DCC_SRVR_ID tgt_id)
+{
+	DCC_SUM srvr_id_sum;
+	if (db_failed_line)
+		return -1;
+	memset(srvr_id_sum, 0, sizeof(srvr_id_sum));
+	srvr_id_sum[0] = DCC_CK_SRVR_ID;
+	srvr_id_sum[1] = tgt_id >> 8;
+	srvr_id_sum[2] = tgt_id;
+	return find_srvr_rcd(srvr_id_sum, "checking server-ID state");
+}
+/* find the server type in the table of IDs */
+ID_TBL *
+find_srvr_type(DCC_SRVR_ID tgt_id)
+{
+	ID_TBL *tp;
+	DCC_SRVR_ID srvr_type;
+	tp = find_id_tbl(tgt_id);
+	if (!tp) {
+		/* check the database if it is not in the table */
+		if (0 >= find_srvr_rcd_type(tgt_id)) {
+			/* assume it is a simple server if there is
+			 * no declaration in the database */
+			srvr_type = DCC_ID_SRVR_SIMPLE;
+		} else {
+			srvr_type = DB_RCD_ID(db_sts.rcd2.d.r);
+			if (!DCC_ID_SRVR_TYPE(srvr_type))
+				srvr_type = DCC_ID_SRVR_SIMPLE;
+			/* the free code knows nothing about reputations */
+			if (srvr_type == DCC_ID_SRVR_REP_OK)
+				srvr_type = DCC_ID_SRVR_SIMPLE;
+		}
+		/* cache it in the table */
+		tp = add_id_tbl(tgt_id);
+		tp->srvr_type = srvr_type;
+	}
+	return tp;
+}
+/* refresh our claim to our server-ID or similar
+*	use only db_sts.hash and db_sts.rcd2 */
+void
+refresh_srvr_rcd(const DCC_SUM sum, DCC_SRVR_ID val, const char *str)
+{
+	DCC_TS old;
+	DB_RCD rcd;
+	int i;
+	/* add a new record
+	 * only if no recent record of the right value exists */
+	i = find_srvr_rcd(sum, str);
+	if (i < 0)
+		return;			/* broken database */
+	if (i > 0
+	    && DB_RCD_ID(db_sts.rcd2.d.r) == val) {
+		dcc_timeval2ts(&old, &db_time, -DCC_SRVR_ID_SECS/2);
+		if (!dcc_ts_older_ts(&db_sts.rcd2.d.r->ts, &old))
+			return;
+	}
+	memset(&rcd, 0, sizeof(rcd));
+	get_ts(&rcd.ts);
+	rcd.srvr_id_auth = val;
+	DB_TGTS_RCD_SET(&rcd, 1);
+	rcd.fgs_num_cks = 1;
+	rcd.cks[0].type_fgs = DCC_CK_SRVR_ID;
+	memcpy(rcd.cks[0].sum, sum, sizeof(DCC_SUM));
+	if (!db_add_rcd(dcc_emsg, &rcd))
+		DB_ERROR_MSG2(str, dcc_emsg);
+}
+static void
+send_resp(const QUEUE *q,
+	  DCC_HDR *hdr,			/* length in host byte order */
+	  u_char no_msg)
+{
+	u_int save_len;
+	char ob[DCC_OPBUF];
+	int len, i;
+	len = hdr->len;
+	hdr->len = htons(len);
+	/* callers must have dealt with the variations due to versions */
+	if (q->pkt.hdr.pkt_vers < DCC_PKT_VERSION_MIN)
+		hdr->pkt_vers = DCC_PKT_VERSION_MIN;
+	else if (q->pkt.hdr.pkt_vers > DCC_PKT_VERSION_MAX)
+		hdr->pkt_vers = DCC_PKT_VERSION_MAX;
+	else
+		hdr->pkt_vers = q->pkt.hdr.pkt_vers;
+	hdr->sender = htonl(my_srvr_id);
+	hdr->op_nums = q->pkt.hdr.op_nums;
+	if (q->passwd[0] != '\0') {
+		/* sign with the password that authenticated the client */
+		dcc_sign(q->passwd, sizeof(q->passwd), hdr, len);
+#ifdef DCC_PKT_VERSION8
+	} else if (q->pkt.hdr.pkt_vers <= DCC_PKT_VERSION8) {
+		/* Sign old protocol responses with the client's transaction
+		 * numbers if we do not have a good password.
+		 * This happens with anonymous clients */
+		dcc_sign((char *)&q->pkt.hdr.op_nums,
+			 sizeof(q->pkt.hdr.op_nums),
+			 hdr, len);
+#endif
+	} else {
+		memset((char *)hdr + (len-sizeof(DCC_SIGNATURE)), 0,
+		       sizeof(DCC_SIGNATURE));
+	}
+	if (q->ridc) {
+		save_len = len-sizeof(*hdr)-sizeof(DCC_SIGNATURE);
+		if (save_len > ISZ(q->ridc->result)) {
+			if (hdr->op == DCC_OP_ERROR)
+				save_len = sizeof(q->ridc->result);
+			else
+				dcc_logbad(EX_SOFTWARE, "RIDC buffer overflow");
+		}
+		q->ridc->len = save_len;
+		memcpy(&q->ridc->result, hdr+1, save_len);
+		q->ridc->op = hdr->op;
+		q->ridc->bad = 0;
+	}
+	i = sendto(q->sp->udp, hdr, len, 0,
+		   &q->clnt_su.sa, DCC_SU_LEN(&q->clnt_su));
+	if (i < 0) {
+		clnt_msg(q, "sendto(%s, %s): %s",
+			 dcc_hdr_op2str(ob, sizeof(ob), hdr), Q_CIP(q),
+			 ERROR_STR());
+	} else if (len != i) {
+		clnt_msg(q, "sendto(%s, %s)=%d instead of %d",
+			 dcc_hdr_op2str(ob, sizeof(ob), hdr), Q_CIP(q),
+			 i, len);
+	} else if (!no_msg
+		   && (dccd_tracemask & ((hdr->op == DCC_OP_ANSWER
+					  || hdr->op == DCC_OP_NOP)
+					 ? DCC_TRACE_QUERY_BIT
+					 : DCC_TRACE_ADMN_BIT))) {
+		dcc_trace_msg("sent %s to %s for %s",
+			      dcc_hdr_op2str(ob, sizeof(ob), hdr),
+			      Q_CIP(q), qop2str(q));
+	}
+}
+/* do not send an error response to a client */
+static void PATTRIB(2,3)
+forget_error(const QUEUE *q, const char *p, ...)
+{
+	va_list args;
+	RIDC_BAD(q);
+	if ((!q->flags & Q_FG_BAD_PASSWD)
+	    && !(q->rl->d.flags & RL_FG_BLS)) {
+		q->rl->d.flags |= RL_FG_BL_BAD;
+		++dccd_stats.bad_op;
+	}
+	va_start(args, p);
+	vclnt_msg(q, p, args);
+	va_end(args);
+}
+/* send an error response to a client */
+static void
+send_error(const QUEUE *q, const char *p, ...)
+{
+	DCC_ERROR buf;
+	int slen;
+	va_list args;
+	/* build and log the message */
+	va_start(args, p);
+	slen = vsnprintf(buf.msg, sizeof(buf.msg), p, args);
+	if (slen > ISZ(buf.msg)-1)
+		slen = ISZ(buf.msg)-1;
+	va_end(args);
+	clnt_msg(q, "\"%s\" sent to %s", buf.msg, Q_CIP(q));
+	/* send it */
+	buf.hdr.len = sizeof(buf)-sizeof(buf.msg)+slen+1;
+	buf.hdr.op = DCC_OP_ERROR;
+	send_resp(q, &buf.hdr, 1);
+	++dccd_stats.send_error;
+}
+#define NORESP_EMSG(q) noresp_emsg(q, __LINE__)
+static void
+noresp_emsg(const QUEUE *q, int linenum)
+{
+	dcc_error_msg("error near line %d in "DCC_VERSION" "__FILE__, linenum);
+	RIDC_BAD(q);
+}
+/* tell client that a NOP or an administrative request was ok */
+static void
+send_ok(QUEUE *q)
+{
+	DCC_OK buf;
+	time_t us;
+	memset(&buf, 0, sizeof(buf));
+	buf.max_pkt_vers = max(min(q->pkt.hdr.pkt_vers, DCC_PKT_VERSION_MAX),
+			       DCC_PKT_VERSION_MIN);
+	us = (q->delay_us + 500) / 1000;
+	buf.qdelay_ms = htons(us);
+	strncpy(buf.brand, brand, sizeof(buf.brand));
+	buf.hdr.op = DCC_OP_OK;
+	buf.hdr.len = sizeof(buf);
+	send_resp(q, &buf.hdr, 0);
+}
+static void
+repeat_resp(QUEUE *q)
+{
+	struct {
+	    DCC_HDR hdr;
+	    u_char  b[sizeof(q->ridc->result)];
+	} buf;
+	char ob[DCC_OPBUF];
+	++dccd_stats.report_retrans;
+	if (q->ridc->bad) {
+		TMSG1(RIDC, "repeat drop of %s", from_id_ip(q, 1));
+		return;
+	}
+	memcpy(&buf.hdr+1, &q->ridc->result, q->ridc->len);
+	buf.hdr.op = q->ridc->op;
+	buf.hdr.len = htons(q->ridc->len
+			    + sizeof(buf.hdr) + sizeof(DCC_SIGNATURE));
+	TMSG2(RIDC, "repeat previous answer of %s for %s",
+	      dcc_hdr_op2str(ob, sizeof(ob), &buf.hdr),
+	      from_id_ip(q, 1));
+	buf.hdr.len = ntohs(buf.hdr.len);
+	send_resp(q, &buf.hdr, 0);
+}
+/* find a checksum in the database
+*	use only db_sts.hash and db_sts.rcd2
+*	put the result in db_sts.rcd2 */
+static u_char				/* 0=broken database */
+get_ck_tgts(DCC_TGTS *tgtsp,
+	    const DB_RCD_CK **pfound_ck,
+	    u_char must_have_it,	/* 1=database broken if cksum absent */
+	    DCC_CK_TYPES type,
+	    const DCC_SUM sum)
+{
+	DB_RCD_CK *found_ck;
+	switch (db_lookup(dcc_emsg, type, sum, 0, MAX_HASH_ENTRIES,
+			  &db_sts.hash, &db_sts.rcd2, &found_ck)) {
+	case DB_FOUND_LATER:
+	case DB_FOUND_SYSERR:
+		DB_ERROR_MSG(dcc_emsg);
+		return 0;
+	case DB_FOUND_IT:
+		if (pfound_ck)
+			*pfound_ck = found_ck;
+		if (tgtsp)
+			*tgtsp = DB_TGTS_CK(found_ck);
+		break;
+	case DB_FOUND_EMPTY:
+	case DB_FOUND_CHAIN:
+	case DB_FOUND_INTRUDER:
+		if (must_have_it) {
+			db_error_msg(__LINE__,__FILE__,
+				     "missing hash entry for %s %s ",
+				     DB_TYPE2STR(type),
+				     dcc_ck2str_err(type, sum, 0));
+			return 0;
+		}
+		if (pfound_ck)
+			*pfound_ck = 0;
+		if (tgtsp)
+			*tgtsp = 0;
+		break;
+	}
+	return 1;
+}
+/* see if a count just passed a multiple of a threshold and so is
+*	worth flooding or summarizing */
+static u_char				/* 1=time to summarize this checksum */
+quick_sum_thold(DCC_CK_TYPES type,
+		DCC_TGTS rpt_tgts,	/* targets in this report */
+		DCC_TGTS ck_tgts)	/* grand total */
+{
+	static DCC_TGTS thold_mults[] = {
+	    1, 2, 3, 5, 10
+	};
+	DCC_TGTS thold;
+	DCC_TGTS mult, new_mult, old_mult;
+	int i;
+	thold = flod_tholds[type];
+	if (ck_tgts < thold
+	    || thold >= DCC_TGTS_TOO_MANY)
+		return 0;
+	if (thold == 0)
+		return 1;
+	new_mult = ck_tgts / thold;
+	old_mult = (ck_tgts - rpt_tgts) / thold;
+	for (i = 0; i < DIM(thold_mults); ++i) {
+		mult = thold_mults[i];
+		if (old_mult < mult)
+			return (new_mult >= mult);
+	}
+	return 0;
+}
+/* compute summarizable total for one checksum
+*	use  db_sts.hash, db_sts.rcd2, and *rcd_st */
+static DCC_TGTS				/* DCC_TGTS_INVALID=broken database */
+sum_total(DCC_CK_TYPES type,		/* look for this */
+	  const DCC_SUM sum,
+	  u_char must_have_it,
+	  DB_STATE *rcd_st,		/* starting here */
+	  const DB_RCD_CK *found_ck,
+	  u_char *undelay_ok,		/* 0=cannot undelay by clearing bit */
+	  DB_PTR *sum_oldest)
+{
+	DB_PTR prev;
+	DCC_TGTS rcd_tgts, sub_total;
+	int limit;
+	if (!rcd_st) {
+		if (!get_ck_tgts(0, &found_ck, must_have_it, type, sum))
+			return DCC_TGTS_INVALID;
+		if (!found_ck)
+			return 0;
+		rcd_st = &db_sts.rcd2;
+	}
+	if (sum_oldest)
+		*sum_oldest = DB_PTR_MAX;
+	sub_total = 0;
+	for (limit = 10000; limit >= 0; --limit) {
+		/* stop adding reports at the first summary or
+		 * compressed record in the hash chain */
+		if (DB_RCD_SUMRY(rcd_st->d.r)
+		    || DB_RCD_ID(rcd_st->d.r) == DCC_ID_COMP)
+			break;
+		/* honor deletions */
+		rcd_tgts = DB_TGTS_RCD(rcd_st->d.r);
+		if (rcd_tgts == 0)
+			break;
+		/* We can only summarize our own delayed reports
+		 * to keep loops in the flooding topology from
+		 * inflating totals. */
+		if (DB_RCD_DELAY(rcd_st->d.r)
+		    && DB_RCD_ID(rcd_st->d.r) == my_srvr_id) {
+			if (sum_oldest)
+				*sum_oldest = rcd_st->s.rptr;
+			sub_total = db_sum_ck(sub_total, rcd_tgts, type);
+			/* if we summarize more than one record,
+			 * then we cannot simply convert the record */
+			if (undelay_ok
+			    && db_sts.sumrcd.s.rptr != rcd_st->s.rptr)
+				*undelay_ok = 0;
+		}
+		prev = DB_PTR_EX(found_ck->prev);
+		if (prev == DB_PTR_NULL)
+			break;
+		rcd_st = &db_sts.rcd2;
+		found_ck = db_map_rcd_ck(dcc_emsg, rcd_st, prev, type);
+		if (!found_ck) {
+			DB_ERROR_MSG(dcc_emsg);
+			return 0;
+		}
+	}
+	return sub_total;
+}
+/* generate a summary record of checksum counts
+*	db_sts.sumrcd points to the record being summarize on entry
+*	    On exit db_sts.sumrcd points to the same record or the original
+*	    has been trashed and db_sts.sumrcd points to a moved copy.
+*	Use db_sts.rcd, db_sts.hash, db_sts.rcd2, db_sts.free, db_sts.tmp */
+static u_char				/* 0=sick db, 1=ok, 2=moved rcd */
+summarize_rcd(u_char dly)		/* 1=working on delayed records */
+{
+	DB_RCD new;
+	DCC_TGTS rcd_tgts, ck_tgts, new_tgts, sub_total;
+	DCC_CK_TYPES type;
+	DB_RCD_CK *cur_ck, *new_ck;
+	int cur_num_cks;
+	u_char ck_needed;		/* 0=junk cksum, 2=needed in new rcd */
+	u_char rcd_needed;		/* 1=have created rcd to add */
+	u_char undelay_ok;		/* 1=ok to remove delay bit */
+	u_char move_ok;
+	DB_PTR sum_oldest;
+	DB_PTR rcd_pos;
+	if (db_lock() < 0)
+		return 0;
+	/* For each checksum whose flooding was delayed but is now needed,
+	 * generate a fake record that will be flooded */
+	cur_num_cks = DB_NUM_CKS(db_sts.sumrcd.d.r);
+	cur_ck = db_sts.sumrcd.d.r->cks;
+	new_tgts = 0;
+	undelay_ok = (FLODS_OK()
+		      && (DB_RCD_ID(db_sts.sumrcd.d.r) == my_srvr_id));
+	move_ok = 1;
+	rcd_needed = 0;
+	new_ck = new.cks;
+	do {
+		/* Sum counts of all delayed reports for this checksum */
+		type = DB_CK_TYPE(cur_ck);
+		if (DB_TEST_NOKEEP(db_parms.nokeep_cks, type))
+			continue;
+		ck_needed = DB_CK_OBS(cur_ck) ? 0 : 1;
+		/* skip trudging through the hash table to find the
+		 * most recent instance of the checksum if we
+		 * are dealing with a new record and so already
+		 * have the most recent instance. */
+		sub_total = sum_total(type, cur_ck->sum, 1,
+				      !dly ? &db_sts.sumrcd : 0,
+				      cur_ck, &undelay_ok, &sum_oldest);
+		if (sub_total == DCC_TGTS_INVALID)
+			return 0;
+		/* Deletions and summaries between our record and the start
+		 * of the hash chain remove the need to flood this checkusm */
+		if (sub_total == 0) {
+			/* skipping a checksum in the original
+			 * record makes it impossible to move it */
+			move_ok = 0;
+			continue;
+		}
+		if (ck_needed == 1) {
+			ck_tgts = DB_TGTS_CK(cur_ck);
+			if (dly) {
+				/* Flood only 1 summary per delay period */
+				if ((flod_mmaps == 0
+				     || sum_oldest <= flod_mmaps->delay_pos)
+				    && ck_tgts >= flod_tholds[type])
+					ck_needed = 2;
+			} else {
+				/* We are considering the need for a summary
+				 * based on a report just received from a client
+				 * or by flooding */
+				if (quick_sum_thold(type, sub_total, ck_tgts))
+					ck_needed = 2;
+			}
+		}
+		if (new_ck != new.cks) {
+			/* We have already begun a summary record. */
+			if (sub_total == new_tgts) {
+				/* extend it with this checksum even if we do
+				 * not really need to flood this checksum */
+				new_ck->type_fgs = type;
+				memcpy(new_ck->sum, cur_ck->sum,
+				       sizeof(new_ck->sum));
+				++new.fgs_num_cks;
+				++new_ck;
+				if (ck_needed == 2)
+					rcd_needed = 1;
+				continue;
+			}
+			/* We cannot extend the current summary record. */
+			/* If we don't really need the checksum,
+			 * then forget the checksum. */
+			if (ck_needed != 2) {
+				/* skipping a checksum in the original
+				 * record makes it impossible to move */
+				move_ok = 0;
+				continue;
+			}
+			/* Add the current summary record to the database if
+			 * it is needed. */
+			if (rcd_needed) {
+				if (!db_add_rcd(dcc_emsg, &new)) {
+					DB_ERROR_MSG(dcc_emsg);
+					return 0;
+				}
+			}
+			/* start a new summary with this checksum. */
+			rcd_needed = 0;
+			/* having added one summary record,
+			 * we cannot undelay or move the original record */
+			undelay_ok = 0;
+		}
+		/* start a new summary record */
+		new.srvr_id_auth = my_srvr_id;
+		get_ts(&new.ts);
+		new_tgts = sub_total;
+		DB_TGTS_RCD_SET(&new, new_tgts);
+		new.fgs_num_cks = DB_RCD_FG_SUMRY+1;
+		new_ck = new.cks;
+		new_ck->type_fgs = type;
+		memcpy(new_ck->sum, cur_ck->sum, sizeof(new_ck->sum));
+		++new_ck;
+		if (ck_needed == 2)
+			rcd_needed = 1;
+	} while (++cur_ck, --cur_num_cks > 0);
+	/* finished if nothing more to summarize */
+	if (!rcd_needed) {
+		return 1;
+	}
+	/* Add the last summary record */
+	if (undelay_ok) {
+		/* If possible, instead of adding a new record,
+		 * change the preceding record to not be delayed
+		 * That is possible if the preceding record has
+		 * not yet been passed by the flooding */
+		if (db_sts.sumrcd.s.rptr >= oflods_max_cur_pos
+		    && oflods_max_cur_pos != 0) {
+			db_sts.sumrcd.d.r->fgs_num_cks &= ~DB_RCD_FG_DELAY;
+			SET_FLUSH_RCD_HDR(&db_sts.sumrcd, 1);
+			return 1;
+		}
+		/* failing that, try to move the record by making a new copy
+		 * and deleting the original */
+		if (move_ok) {
+			/* make the new record */
+			memcpy(&new, db_sts.sumrcd.d.r, DB_RCD_LEN(&new));
+			new.fgs_num_cks &= ~DB_RCD_FG_DELAY;
+			/* delete the old record */
+			DB_TGTS_RCD_SET(db_sts.sumrcd.d.r, 0);
+			/* adjust the totals in the old record so
+			 * that the totals in the new record will be right */
+			rcd_tgts = DB_TGTS_RCD(&new);
+			cur_num_cks = DB_NUM_CKS(db_sts.sumrcd.d.r);
+			cur_ck = db_sts.sumrcd.d.r->cks;
+			do {
+				new_tgts = DB_TGTS_CK(cur_ck);
+				if (new_tgts >= DCC_TGTS_TOO_MANY)
+					    continue;
+				if (new_tgts != 0)
+					new_tgts -= rcd_tgts;
+				DB_TGTS_CK_SET(cur_ck, new_tgts);
+			}  while (++cur_ck, --cur_num_cks > 0);
+			SET_FLUSH_RCD_HDR(&db_sts.sumrcd, 1);
+			rcd_pos = db_add_rcd(dcc_emsg, &new);
+			if (rcd_pos == DB_PTR_NULL) {
+				DB_ERROR_MSG(dcc_emsg);
+				return 0;
+			}
+			if (!db_map_rcd(dcc_emsg, &db_sts.sumrcd, rcd_pos, 0)) {
+				DB_ERROR_MSG(dcc_emsg);
+				return 0;
+			}
+			return 1;
+		}
+	}
+	if (!db_add_rcd(dcc_emsg, &new)) {
+		DB_ERROR_MSG(dcc_emsg);
+		return 0;
+	}
+	return 1;
+}
+/* generate a delayed summary for checksums in a record if necessary
+*	The target record is specified by db_sts.sumrcd.  It might be changed
+*	Use db_sts.hash and db_sts.rcd2 */
+u_char
+summarize_dly(void)
+{
+	DCC_CK_TYPES type;
+	const DB_RCD_CK *cur_ck;
+	int cur_num_cks;
+	DCC_TGTS ck_tgts;
+	/* look for a checksum that could be summarized */
+	cur_num_cks = DB_NUM_CKS(db_sts.sumrcd.d.r);
+	cur_ck = db_sts.sumrcd.d.r->cks;
+	do {
+		type = DB_CK_TYPE(cur_ck);
+		if (DB_TEST_NOKEEP(db_parms.nokeep_cks, type))
+			continue;
+		if (!get_ck_tgts(&ck_tgts, 0, 1, type, cur_ck->sum))
+			return 0;
+		/* nothing to do if the checksum has already been summarized */
+		if (DB_RCD_SUMRY(db_sts.rcd2.d.r))
+			continue;
+		/* spam reports are ignored or not delayed */
+		if (ck_tgts == DCC_TGTS_TOO_MANY)
+			continue;
+		/* Generate a summary for a bulk checksum
+		 * Records that are marked "delayed" are not flooded.
+		 * If a summary record is not synthesized and if the delay
+		 * marking not removed (instead of synthesizing a summary),
+		 * then the counts for a checksum will not be flooded. */
+		if (ck_tgts >= flod_tholds[type])
+			return summarize_rcd(1);
+	}  while (++cur_ck, --cur_num_cks > 0);
+	return 1;
+}
+/* See if passing on a flooded report would be worthwhile.  It is worthwhile
+*	to pass on reports of spam that have not been flooded recently
+*	and of checksums that not yet or just barely reached spam.
+*
+*	db_sts.sumrcd points to the new record */
+static u_char				/* 0=sick database */
+flod_worth(u_char *pflod,		/* set =1 if report should be flooded */
+	   const DB_RCD_CK *ck,
+	   DCC_CK_TYPES type)
+{
+	DCC_TS past;
+	DCC_TGTS total;
+	int limit;
+	DB_PTR prev;
+	/* if the total with the new report is small,
+	 * then we should flood it */
+	total = DB_TGTS_CK(ck);
+	if (total < REFLOOD_THRESHOLD) {
+		/* but only if it is not trivial.
+		 * our neighbors should not send trivial reports,
+		 * but bugs happen */
+		if (total >= BULK_THRESHOLD/2)
+			*pflod = 1;
+		return 1;
+	}
+	/* Look for a recent report for this checksum that has been
+	 * or will be flooded.  If we find one, and if the total
+	 * including it is large enough, we may not need to flood
+	 * the incoming report.  If the total is too small, we
+	 * must flood the report. */
+	dcc_timeval2ts(&past, &db_time, -summarize_delay_secs);
+	for (limit = 20; limit >= 0; --limit) {
+		prev = DB_PTR_EX(ck->prev);
+		if (prev == DB_PTR_NULL)
+			break;
+		ck = db_map_rcd_ck(dcc_emsg, &db_sts.rcd2, prev, type);
+		if (!ck) {
+			DB_ERROR_MSG(dcc_emsg);
+			return 0;
+		}
+		/* if the previous total was small,
+		 * then we must flood the new report */
+		total = DB_TGTS_CK(ck);
+		if (total < REFLOOD_THRESHOLD*4) {
+			*pflod = 1;
+			return 1;
+		}
+		/* The old total is large.
+		 * If this found old report is not very old and good,
+		 * we will flood it and so the newest needed not be flooded
+		 * and can be marked obsolete. */
+		if (!DB_CK_OBS(ck)
+		    && dcc_ts_newer_ts(&db_sts.rcd2.d.r->ts, &past))
+			return 1;
+	}
+	/* flood this one if we can't find a recent preceding report */
+	*pflod = 1;
+	return 1;
+}
+/* Add a record and deal with delaying its flooding.
+*	We will delay flooding it if its totals are not interesting.
+*	db_sts.sumrcd points to the new record on exit
+*	Use db_sts.rcd, db_sts.hash, db_sts.rcd2, db_sts.free, db_sts.tmp
+*	the database must be locked */
+u_char					/* 1=ok, delayed or not, 0=failure */
+add_dly_rcd(DB_RCD *new_rcd, u_char flod_in)
+{
+	DB_PTR rcd_pos;
+	int num_cks;
+	DB_RCD_CK *new_ck;
+	DCC_CK_TYPES type;
+	DCC_TGTS rpt_tgts, ck_tgts;
+	u_char flod_out;	/* 0=flooded in but not worth flooding out */
+	u_char useful = 0;		/* 1=worth delaying */
+	u_char summarize = 0;
+	/* put the record in the database */
+	rcd_pos = db_add_rcd(dcc_emsg, new_rcd);
+	if (rcd_pos == DB_PTR_NULL) {
+		DB_ERROR_MSG(dcc_emsg);
+		return 0;
+	}
+	if (!db_map_rcd(dcc_emsg, &db_sts.sumrcd, rcd_pos, 0)) {
+		DB_ERROR_MSG(dcc_emsg);
+		return 0;
+	}
+	/* delete requests should not be delayed */
+	rpt_tgts = DB_TGTS_RCD_RAW(db_sts.sumrcd.d.r);
+	if (rpt_tgts == DCC_TGTS_DEL)
+		return 1;
+	/* we always consider flooding our own reports
+	 * and the greylist thresholds are zilch */
+	flod_out = !flod_in || grey_on;
+	for (num_cks = DB_NUM_CKS(db_sts.sumrcd.d.r),
+	     new_ck = db_sts.sumrcd.d.r->cks;
+	     num_cks > 0;
+	     ++new_ck, --num_cks) {
+		/* ingore already obsolete reports of spam */
+		if (DB_CK_OBS(new_ck))
+			continue;
+		/* ignore checksums we won't keep and so won't be flooded */
+		type = DB_CK_TYPE(new_ck);
+		if (DB_TEST_NOKEEP(db_parms.nokeep_cks, type))
+			continue;
+		/* Server-ID declarations cannot be summarized and should
+		 * not be delayed. */
+		if (type == DCC_CK_SRVR_ID) {
+			flod_out = 1;
+			break;
+		}
+		ck_tgts = DB_TGTS_CK(new_ck);
+		if (ck_tgts == DCC_TGTS_TOO_MANY) {
+			/* This checksum has a total of TOO_MANY and so
+			 * either the report has a target count of TOO_MANY
+			 * or is a report of a checksum already known to
+			 * be spam.  Since this report of this checksum
+			 * was not marked obsolete as it was linked into the
+			 * database, it should not be delayed.  */
+			if (rpt_tgts == DCC_TGTS_TOO_MANY) {
+				/* if the report is of spam, then all of its
+				 * individual checksum totals will be
+				 * DCC_TGTS_TOO_MANY.  The checksums will be
+				 * obsolete, not kept, or the same as this.
+				 * There will be no reputation checksums. */
+				return 1;
+			}
+			/* it is worth sending on even if was not ours */
+			flod_out = 1;
+			continue;
+		}
+		/* This report has some potential value and should be delayed
+		 * instead of forgotten */
+		useful = 1;
+		/* Summarize our records for the checksums in this record
+		 * if we just passed the threshold for one checksum. */
+		if (!summarize
+		    && quick_sum_thold(type, rpt_tgts, ck_tgts))
+			summarize = 1;
+		/* If this is an incoming flooded checksum,
+		 * then pass it on if it is novel (has a low total)
+		 * or if we have not passed it on recently. */
+		if (!flod_out
+		    && !flod_worth(&flod_out, new_ck, type))
+			return 0;	/* broken database */
+	}
+	/* Reports that are reports of spam or "trimmed" or "obsolete"
+	 * noise should not be summarized or marked to be delayed.
+	 * They will be flooded or skipped by the flooder */
+	if (!useful)
+		return 1;
+	if (!flod_in) {
+		/* Delay and sooner or later summarize our own
+		 * reports of non-spam */
+		db_sts.sumrcd.d.r->fgs_num_cks |= DB_RCD_FG_DELAY;
+	} else if (!flod_out) {
+		/* We are dealing with a report flooded in from another
+		 * server that is not (yet?) worth flooding out.
+		 * We can't delay it, because we can't delay reports from
+		 * other servers, because we cannot summarize them.
+		 * Summarizing other servers' reports would allow
+		 * loops in the flooding topology to inflate the totals.
+		 * So mark it to be expired but not delayed. */
+		for (num_cks = DB_NUM_CKS(db_sts.sumrcd.d.r),
+		     new_ck = db_sts.sumrcd.d.r->cks;
+		     num_cks > 0;
+		     ++new_ck, --num_cks) {
+			new_ck->type_fgs |= DB_CK_FG_OBS;
+		}
+	}
+	/* If this record pushed us past a threshold for at least one
+	 * checksum, then try to generate a summary of our own previously
+	 * delayed reports even if this record was not our own. */
+	if (summarize
+	    && !summarize_rcd(0))
+		return 0;
+	return 1;
+}
+/* the database must be locked */
+static u_char
+add_del(const DCC_CK *del_ck)
+{
+	DB_RCD del_rcd;
+	memset(&del_rcd, 0, sizeof(del_rcd));
+	get_ts(&del_rcd.ts);
+	DB_TGTS_RCD_SET(&del_rcd, DCC_TGTS_DEL);
+	del_rcd.srvr_id_auth = my_srvr_id;
+	del_rcd.fgs_num_cks = 1;
+	del_rcd.cks[0].type_fgs = del_ck->type;
+	memcpy(del_rcd.cks[0].sum, del_ck->sum, sizeof(del_rcd.cks[0].sum));
+	if (!db_add_rcd(dcc_emsg, &del_rcd)) {
+		DB_ERROR_MSG2("add delete", dcc_emsg);
+		return 0;
+	}
+	return 1;
+}
+static const DCC_CK *
+start_work(QUEUE *q)
+{
+	const DCC_CK *ck, *ck_lim;
+	DCC_CK_TYPES type, prev_type;
+	int num_cks;
+	num_cks = q->pkt_len - (sizeof(q->pkt.r) - sizeof(q->pkt.r.cks));
+	if (num_cks < 0
+	    || num_cks > ISZ(q->pkt.r.cks)
+	    || num_cks % sizeof(DCC_CK) != 0) {
+		forget_error(q, "packet length %d wrong for %s",
+			     q->pkt_len, from_id_ip(q, 1));
+		return 0;
+	}
+	num_cks /= sizeof(DCC_CK);
+	/* send previous answer if this is a retransmission */
+	if (ridc_get(q)) {
+		repeat_resp(q);
+		return 0;
+	}
+	if (db_failed_line)		/* be silent while database bad */
+		return 0;
+	ck = q->pkt.r.cks;
+	ck_lim = &q->pkt.r.cks[num_cks];
+	/* check each checksum */
+	for (prev_type = DCC_CK_INVALID; ck < ck_lim; ++ck, prev_type = type) {
+		if (ck->len != sizeof(*ck)) {
+			forget_error(q, "unknown checksum length %d%s",
+				     ck->len, from_id_ip(q, 0));
+			return 0;
+		}
+		/* requiring that the checksums be ordered makes it easy
+		 * to check for duplicates and for bogus long packets */
+		type = ck->type;
+		if (!DCC_CK_OK_DCC_CLNT(grey_on, type)) {
+			forget_error(q, "unknown checksum %s%s",
+				     DB_TYPE2STR(type), from_id_ip(q, 0));
+			return 0;
+		}
+		if (prev_type >= type) {
+			forget_error(q, "out of order %s checksum%s",
+				     DB_TYPE2STR(ck->type), from_id_ip(q, 0));
+			return 0;
+		}
+	}
+	if (db_lock() < 0) {
+		NORESP_EMSG(q);
+		return 0;
+	}
+	return ck_lim;
+}
+/* send the response and release q */
+static void
+fin_work(const QUEUE *q, DCC_HDR *answer)
+{
+	int delay_us;
+	/* send the response */
+	answer->op = DCC_OP_ANSWER;
+	send_resp(q, answer, 0);
+	/* update the average queue delay, unless it is crazy */
+	gettimeofday(&db_time, 0);
+	delay_us = tv_diff2us(&db_time, &q->answer);
+	if (delay_us < 0)
+		return;
+	update_q_delay();
+	q_delays[0].us += delay_us;
+	++q_delays[0].ops;
+}
+/* use only db_sts.hash and db_sts.rcd2
+* release q on failure */
+static u_char
+make_answer(QUEUE *q,
+	    const DCC_CK *ck_lim,
+	    u_char have_rcd,		/* db_sts.sumrcd.d.r is new record */
+	    DCC_ANSWER *answer,
+	    DCC_TGTS gross_tgts,	/* total for this report, maybe MANY */
+	    DCC_TGTS* max_tgts)		/* statistics */
+{
+	const DCC_CK *ck;
+	DCC_TGTS c_tgts;		/* current count with this report */
+	DCC_TGTS p_tgts;		/* count before this report */
+	DCC_ANSWER_BODY_CKS *b;
+	DCC_CK_TYPES type;
+	const DB_RCD_CK *rcd_ck, *prev_rcd_ck;
+	int num_rcd_cks;
+	DB_PTR prev;
+	*max_tgts = 0;
+	if (have_rcd) {
+		rcd_ck = db_sts.sumrcd.d.r->cks;
+		num_rcd_cks = DB_NUM_CKS(db_sts.sumrcd.d.r);
+	} else {
+		num_rcd_cks = 0;
+		rcd_ck = 0;
+	}
+	b = answer->b;
+	for (ck = q->pkt.r.cks; ck < ck_lim; ++ck) {
+		type = ck->type;
+		if (num_rcd_cks > 0
+		    && type == DB_CK_TYPE(rcd_ck)) {
+			/* try to copy answer from report's new record */
+			c_tgts = DB_TGTS_CK(rcd_ck);
+			if (c_tgts < DCC_TGTS_TOO_MANY) {
+				p_tgts = c_tgts - gross_tgts;
+			} else if (prev = DB_PTR_EX(rcd_ck->prev),
+				   prev == DB_PTR_NULL) {
+				p_tgts = 0;
+			} else {
+				prev_rcd_ck = db_map_rcd_ck(dcc_emsg,
+							&db_sts.rcd2,
+							prev, type);
+				if (!prev_rcd_ck) {
+					DB_ERROR_MSG(dcc_emsg);
+					RIDC_BAD(q);
+					return 0;
+				}
+				p_tgts = DB_TGTS_CK(prev_rcd_ck);
+			}
+			--num_rcd_cks;
+			++rcd_ck;
+		} else {
+			if (!get_ck_tgts(&p_tgts, 0, 0, type, ck->sum)) {
+				NORESP_EMSG(q);
+				return 0;
+			}
+			if (DB_TEST_NOKEEP(db_parms.nokeep_cks, type)) {
+				/* uninteresting checksums have no value
+				 * unless they are whitelisted */
+				c_tgts = p_tgts;
+				if (p_tgts == 0)
+					p_tgts = DCC_TGTS_INVALID;
+			} else {
+				c_tgts = db_sum_ck(p_tgts, gross_tgts, type);
+			}
+		}
+		b->c = htonl(c_tgts);
+		b->p = htonl(p_tgts);
+#ifdef DCC_PKT_VERSION5
+		if (q->pkt.hdr.pkt_vers <= DCC_PKT_VERSION5)
+			b = (DCC_ANSWER_BODY_CKS *)&b->p;
+		else
+#endif
+		++b;
+		if (*max_tgts < c_tgts
+		    && c_tgts <= DCC_TGTS_OK2) {
+			*max_tgts = c_tgts;
+			/* Complain about failures to whitelist by
+			 * trusted clients.  The main use of this is
+			 * to detect whitelisting failures of IP addresses
+			 * such as 127.0.0.1 for reputations, and those
+			 * matter only for known clients.  */
+			if ((p_tgts >= DCC_TGTS_OK)
+			    && !(q->flags & Q_FG_UNTRUSTED))
+				TMSG4(WLIST, "%s whitelisted %s %s%s",
+				      qop2str(q),
+				      DB_TYPE2STR(type),
+				      dcc_ck2str_err(type, ck->sum, 0),
+				      from_id_ip(q, 0));
+		}
+	}
+	answer->hdr.len = (sizeof(*answer) - sizeof(answer->b)
+			   + ((char *)b - (char *)answer->b));
+	return 1;
+}
+/* release q on failure
+*	the database must be locked */
+static u_char
+do_report(QUEUE *q,
+	  DCC_TGTS tgts0, const DCC_CK *ck_lim,
+	  DCC_ANSWER *answer,
+	  DCC_TGTS *max_tgts)
+{
+	const DCC_CK *ck;
+	DCC_TGTS tgts;
+	DCC_TGTS gross_tgts;		/* DCC_TGTS_TOO_MANY if spam */
+	DB_PTR rcd_pos;
+	DB_RCD new;
+	DB_RCD_CK *new_ck;
+	DCC_CK_TYPES type;
+	char tgts_buf[DCC_XHDR_MAX_TGTS_LEN];
+	tgts = tgts0;
+	if (tgts & (DCC_TGTS_SPAM | DCC_TGTS_REP_SPAM)) {
+		tgts &= DCC_TGTS_MASK;
+		if (tgts == 0)
+			tgts = 1;
+		gross_tgts = DCC_TGTS_TOO_MANY;
+	} else if (tgts == DCC_TGTS_TOO_MANY) {
+		tgts = 1;
+		gross_tgts = DCC_TGTS_TOO_MANY;
+	} else if (tgts > DCC_TGTS_RPT_MAX) {
+		forget_error(q, "bogus target count %s%s",
+			     dcc_tgts2str(tgts_buf, sizeof(tgts_buf),
+					  tgts, grey_on),
+			     from_id_ip(q, 0));
+		return 0;
+	} else {
+		gross_tgts = tgts;
+	}
+	if (gross_tgts < 10) {
+		;
+	} else if (gross_tgts == DCC_TGTS_TOO_MANY) {
+		++dccd_stats.reportmany;
+	} else if (gross_tgts > 1000) {
+		++dccd_stats.report1000;
+	} else if (gross_tgts > 100) {
+		++dccd_stats.report100;
+	} else if (gross_tgts > 10) {
+		++dccd_stats.report10;
+	}
+	/* Get ready to add the report to the database,
+	 * and as a side effect, find the data to answer the query.
+	 * Start by creating the record to add to the database. */
+	get_ts(&new.ts);
+	new.srvr_id_auth = my_srvr_id;
+	DB_TGTS_RCD_SET(&new, gross_tgts);
+	/* copy checksums to the new record */
+	new.fgs_num_cks = 0;
+	new_ck = new.cks;
+	for (ck = q->pkt.r.cks; ck < ck_lim; ++ck) {
+		type = ck->type;
+		if (DB_TEST_NOKEEP(db_parms.nokeep_cks, type))
+			continue;
+		memcpy(new_ck->sum, ck->sum, sizeof(new_ck->sum));
+		new_ck->type_fgs = type;
+		++new_ck;
+		++new.fgs_num_cks;
+	}
+	if (!(q->flags & Q_FG_RPT_OK)) {
+		/* finished if this is a query */
+		return make_answer(q, ck_lim, 0, answer, gross_tgts,
+				   max_tgts);
+	}
+	if (new.fgs_num_cks == 0) {
+		rcd_pos = DB_PTR_NULL;
+	} else {
+		/* Add the record to the database.
+		 * That will update the totals for each checksum */
+		if (!add_dly_rcd(&new, 0)) {
+			NORESP_EMSG(q);
+			return 0;
+		}
+		rcd_pos = db_sts.sumrcd.s.rptr;
+	}
+	/* generate the response, perhaps from the new record */
+	return make_answer(q, ck_lim, rcd_pos!=DB_PTR_NULL, answer, gross_tgts,
+			   max_tgts);
+}
+/* process a single real request */
+void
+do_work(QUEUE *q)
+{
+	const DCC_CK *ck_lim;
+	DCC_ANSWER answer;
+	DCC_TGTS max_tgts, tgts;
+	ck_lim = start_work(q);
+	if (!ck_lim)
+		return;
+	tgts = 0;
+	switch (q->pkt.hdr.op) {
+	case DCC_OP_QUERY:
+		++dccd_stats.queries;
+		q->flags &= ~Q_FG_RPT_OK;
+		break;
+	case DCC_OP_REPORT:
+		if (!(q->flags & Q_FG_RPT_OK)) {
+			++dccd_stats.report_reject;
+			clnt_msg(q, "treat %s as query", from_id_ip(q, 1));
+			++dccd_stats.queries;
+		} else {
+			tgts = ntohl(q->pkt.r.tgts);
+			++dccd_stats.reports;
+		}
+		break;
+	case DCC_OP_INVALID:
+	case DCC_OP_NOP:
+	case DCC_OP_ANSWER:
+	case DCC_OP_ADMN:
+	case DCC_OP_OK:
+	case DCC_OP_ERROR:
+	case DCC_OP_DELETE:
+	case DCC_OP_GREY_REPORT:
+	case DCC_OP_GREY_QUERY:
+	case DCC_OP_GREY_SPAM:
+	case DCC_OP_GREY_WHITE:
+		dcc_logbad(EX_SOFTWARE, "impossible queued operation");
+		break;
+	}
+	if (!do_report(q, tgts, ck_lim, &answer,
+		       &max_tgts)) {
+		/* ensure that the clock ticks so rate limits don't stick */
+		gettimeofday(&db_time, 0);
+	} else {
+		/* notice the size of our answer */
+		if (max_tgts == DCC_TGTS_OK || max_tgts == DCC_TGTS_OK2) {
+			++dccd_stats.respwhite;
+		} else if (max_tgts == DCC_TGTS_TOO_MANY) {
+			++dccd_stats.respmany;
+		} else if (max_tgts > 1000) {
+			++dccd_stats.resp1000;
+		} else if (max_tgts > 100) {
+			++dccd_stats.resp100;
+		} else if (max_tgts > 10) {
+			++dccd_stats.resp10;
+		}
+		fin_work(q, &answer.hdr);
+	}
+}
+/* return 0 for a new embargo,
+*	embargo count	for an existing embargo,
+*	DCC_TGTS_TOO_MANY   no embargo
+*	DCC_TGTS_OK	    a newly expired embargo
+*	DCC_TGTS_INVALID    broken database */
+static DCC_TGTS
+search_grey(const DCC_CK *req_ck3,	/* triple checksum */
+	    const DCC_CK *req_ckb,	/* body seen with it */
+	    u_char body_known)
+{
+	DB_RCD_CK *ck3, *ckb;
+	DB_PTR prev3;
+	DCC_TS old_ts;
+	DCC_TGTS result_tgts;
+	int i;
+	/* look for the triple checksum */
+	switch (db_lookup(dcc_emsg, DCC_CK_GREY3, req_ck3->sum,
+			  0, MAX_HASH_ENTRIES,
+			  &db_sts.hash, &db_sts.rcd, &ck3)) {
+	case DB_FOUND_EMPTY:
+	case DB_FOUND_CHAIN:
+	case DB_FOUND_INTRUDER:
+		return 0;
+	case DB_FOUND_IT:
+		/* We found the triple checksum.
+		 * If it is marked ok (MANY) or deleted,
+		 * then we have our answer */
+		result_tgts = DB_TGTS_CK(ck3);
+		if (result_tgts == DCC_TGTS_TOO_MANY || result_tgts == 0)
+			return result_tgts;
+		/* Otherwise look for a report of the triple with
+		 * the right body checksum that is old enough. */
+		result_tgts = 0;
+		dcc_timeval2ts(&old_ts, &db_time, -grey_embargo);
+		for (;;) {
+			ckb = db_sts.rcd.d.r->cks;
+			for (i = DB_NUM_CKS(db_sts.rcd.d.r);
+			     i > 0;
+			     --i, ++ckb) {
+				/* try the next report in the database
+				 * if it has the wrong body checksum
+				 *
+				 * If we are weak on bodies,
+				 * act as if all reports of the triple checksums
+				 * are with the right body checksum. */
+				if (!grey_weak_body && req_ckb) {
+					if (DB_CK_TYPE(ckb) != DCC_CK_BODY)
+					    continue;
+					if (memcmp(req_ckb->sum, ckb->sum,
+						   sizeof(DCC_SUM)))
+					    break;
+				}
+				/* We found the right body checksum in
+				 * chain of the triple checksum
+				 * or we don't care.
+				 *
+				 * If the report is old enough, then
+				 * the embargo is over. */
+				if (dcc_ts_newer_ts(&old_ts,
+						    &db_sts.rcd.d.r->ts))
+					return DCC_TGTS_OK;
+				/* If it is not old enough,
+				 * then we know this is not a new embargo for
+				 * this body (i.e. the reported target count
+				 * will be >0) and we must keep looking for an
+				 * old enough report with the body checksum. */
+				++result_tgts;
+				break;
+			}
+			/* If we know the body checksum is not in the database,
+			 * then there is no profit in looking at other reports
+			 * of the triple checksum to try to find an old enough
+			 * report that is with the right body checksum.
+			 * We know this is a new embargo. */
+			if (!body_known)
+				return 0;
+			/* If we reach the end of the chain of the
+			 * triple checksum without finding an old
+			 * enough report for the right body,
+			 * then the embargo is not over. */
+			prev3 = DB_PTR_EX(ck3->prev);
+			if (prev3 == DB_PTR_NULL)
+				return result_tgts;
+			/* examine the timestamp of the preceding report
+			 * of the triple */
+			ck3 = db_map_rcd_ck(dcc_emsg, &db_sts.rcd,
+					    prev3, DCC_CK_GREY3);
+			if (!ck3)
+				return DCC_TGTS_INVALID;
+		}
+		break;
+	case DB_FOUND_LATER:
+	case DB_FOUND_SYSERR:
+		DB_ERROR_MSG(dcc_emsg);
+		return DCC_TGTS_INVALID;
+	}
+	return DCC_TGTS_INVALID;
+}
+void
+do_grey(QUEUE *q)
+{
+	DCC_OPS op;
+	DB_RCD new;
+	const DCC_CK *req, *req_lim;
+	const DCC_CK *req_ck_ip, *req_ck_triple, *req_ck_msg, *req_ck_body;
+	u_char body_known;
+	DB_RCD_CK *new_ck, *found_ck;
+	DCC_GREY_ANSWER resp;
+	DCC_TGTS tgts;
+	DCC_TGTS ip_tgts;		/* existing count for DCC_CK_IP */
+	DCC_TGTS triple_tgts;		/*   "   count for GREY_TRIPLE */
+	DCC_TGTS msg_tgts;		/*   "   count for GREY_MSG */
+	DCC_TGTS eff_msg_tgts;		/* effective value: 0=reported to DCC */
+	DCC_TGTS new_msg_tgts;		/* value after this */
+	DCC_TGTS result_tgts;		/* no embargo, ending, whitelist or # */
+	TMSG1(QUERY, "received %s", op_id_ip(q));
+	if (!ck_clnt_id(q))
+		return;
+	if (q->flags & Q_FG_UNTRUSTED) {
+		anon_msg("drop %s", from_id_ip(q, 1));
+		return;
+	}
+	/* an embargo of 0 seconds means we should only collect names */
+	op = q->pkt.hdr.op;
+	if (op == DCC_OP_GREY_REPORT && grey_embargo == 0)
+		op = DCC_OP_GREY_WHITE;
+	req_lim = start_work(q);
+	if (!req_lim)
+		return;
+	/* Require
+	 *	the body checksum,
+	 *	the checksum of the (body,sender,target),
+	 *	and the checksum of the (source,sender,target) triple.
+	 * Allow other checksums for whitelisting. */
+	ip_tgts = 0;
+	body_known = grey_weak_body;
+	req_ck_ip = 0;
+	req_ck_body = 0;
+	req_ck_triple = 0;
+	req_ck_msg = 0;
+	msg_tgts = eff_msg_tgts = 0;
+	for (req = q->pkt.r.cks; req < req_lim; ++req) {
+		/* Note our main checksums of the greylist triple and
+		 * the message body.  Search the database for it later */
+		if (DCC_CK_IS_GREY_TRIPLE(1, req->type)) {
+			req_ck_triple = req;
+			continue;
+		}
+		if (!DCC_CK_OK_GREY_CLNT(req->type))
+			continue;	/* ignore unknown checksums */
+		switch (req->type) {
+		case DCC_CK_IP:
+			req_ck_ip = req;
+			break;
+		case DCC_CK_BODY:
+			req_ck_body = req;
+			break;
+		case DCC_CK_GREY_MSG:
+			req_ck_msg = req;
+			break;
+		}
+		/* check for whitelisting and whether this is a new embargo */
+		switch (db_lookup(dcc_emsg, req->type, req->sum,
+				  0, MAX_HASH_ENTRIES,
+				  &db_sts.hash, &db_sts.rcd, &found_ck)) {
+		case DB_FOUND_LATER:
+		case DB_FOUND_SYSERR:
+			DB_ERROR_MSG(dcc_emsg);
+			RIDC_BAD(q);
+			return;
+		case DB_FOUND_IT:
+			/* ignore deleted checksums */
+			tgts = DB_TGTS_CK(found_ck);
+			if (tgts == 0)
+				continue;
+			/* honor whitelisting */
+			if (tgts == DCC_TGTS_GREY_WHITE
+			    && op != DCC_OP_GREY_WHITE) {
+				op = DCC_OP_GREY_WHITE;
+				++dccd_stats.respwhite;
+			}
+			switch (req->type) {
+			case DCC_CK_BODY:
+				/* notice if the target body exists at all */
+				body_known = 1;
+				break;
+			case DCC_CK_GREY_MSG:
+				msg_tgts = tgts;
+				if (msg_tgts != DCC_TGTS_TOO_MANY) {
+					/* this is an old embargo that has
+					 * already been reported by the client
+					 * to a normal DCC server */
+					eff_msg_tgts = 1;
+				}
+				break;
+			case DCC_CK_IP:
+				ip_tgts = tgts;
+				break;
+			default:
+				break;
+			}
+			break;
+		case DB_FOUND_EMPTY:
+		case DB_FOUND_CHAIN:
+		case DB_FOUND_INTRUDER:
+			break;
+		}
+	}
+	if (!req_ck_triple) {
+		send_error(q, "missing %s checksum for %s",
+			   DB_TYPE2STR(DCC_CK_GREY3), qop2str(q));
+		return;
+	}
+	if (op == DCC_OP_GREY_REPORT && !grey_weak_body) {
+		if (!req_ck_body) {
+			send_error(q, "missing body checksum for %s",
+				   qop2str(q));
+			return;
+		}
+		if (!req_ck_msg) {
+			send_error(q, "missing %s checksum for %s",
+				   DB_TYPE2STR(DCC_CK_GREY_MSG), qop2str(q));
+			return;
+		}
+	}
+	/* decide if the embargo should end */
+	triple_tgts = search_grey(req_ck_triple, req_ck_body, body_known);
+	if (triple_tgts == DCC_TGTS_INVALID) {
+		NORESP_EMSG(q);		/* broken database */
+		return;
+	}
+	/* End existing embargo on a newly whitelisted sender so its
+	 *	messages are logged.
+	 * Quietly prevent future embargos of whitelisted senders that have
+	 *	not been greylisted.
+	 * Honor grey_weak_ip whitelisting even after it is turned off */
+	if (triple_tgts >= DCC_TGTS_TOO_MANY) {
+		result_tgts = triple_tgts;
+	} else if (op == DCC_OP_GREY_WHITE) {
+		result_tgts = eff_msg_tgts ? DCC_TGTS_OK : DCC_TGTS_TOO_MANY;
+	} else if (ip_tgts == DCC_TGTS_TOO_MANY) {
+		result_tgts = DCC_TGTS_TOO_MANY;
+	} else {
+		result_tgts = triple_tgts;
+	}
+	if (op == DCC_OP_GREY_QUERY) {
+		++dccd_stats.queries;
+	} else if (!(q->flags & Q_FG_RPT_OK)) {
+		++dccd_stats.report_reject;
+		clnt_msg(q, "treat %s as query", from_id_ip(q, 1));
+		++dccd_stats.queries;
+	} else {
+		/* add a report for this message */
+		++dccd_stats.reports;
+		new.srvr_id_auth = my_srvr_id;
+		new_ck = new.cks;
+		new.fgs_num_cks = 0;
+		if (result_tgts < DCC_TGTS_TOO_MANY) {
+			if (req_ck_body) {
+				new_ck->type_fgs = DCC_CK_BODY;
+				memcpy(new_ck->sum, req_ck_body->sum,
+				       sizeof(new_ck->sum));
+				++new.fgs_num_cks;
+				++new_ck;
+			}
+			new_msg_tgts = 1;
+			DB_TGTS_RCD_SET(&new, 1);
+		} else {
+			/* embargo now ending (DCC_TGTS_TOO_OK)
+			 * or no embargo (DCC_TGTS_TOO_MANY) */
+			if (grey_weak_ip && req_ck_ip) {
+				new_ck->type_fgs = DCC_CK_IP;
+				memcpy(new_ck->sum, req_ck_ip->sum,
+				       sizeof(new_ck->sum));
+				++new.fgs_num_cks;
+				++new_ck;
+			}
+			new_msg_tgts = 0;
+			DB_TGTS_RCD_SET(&new, DCC_TGTS_TOO_MANY);
+		}
+		/* Include the GREY_MSG checksum in the database
+		 * record for a new embargo.
+		 * The message checksum lets an SMTP server report an
+		 * embargoed message to the DCC before the embargo is over,
+		 * but not report it more than once even if more than one
+		 * SMTP client retransmits the message.
+		 *
+		 * If the GREY_MSG checksum does not exist in the
+		 * database, then tell the DCC client the message is new
+		 * and should be reported to the DCC server.  We must put the
+		 * the _GREY_MSG into the database so we will recognize
+		 * the message as not new when it is retransmitted.
+		 *
+		 * If the GREY_MSG checksum exists and is not MANY,
+		 * then we may have a retransmission of the message
+		 * from another IP address.
+		 * We need to tell the DCC client to not report to the
+		 * DCC server. The new value for the CK_GREY_MSG checksum
+		 * should be whatever we are using for the triple checksum.
+		 *
+		 * If the existing count for the GREY_MSG checksum is
+		 * MANY, and the new value for triple checksum is not MANY,
+		 * then we have a new copy of the message and a new embargo.
+		 * We have a spammer with multiple senders instead of a
+		 * legitimate multihomed SMTP client.  We need to tell the
+		 * DCC client to report to the DCC server.  To remember
+		 * that we told the DCC client to report to the DCC server,
+		 * we must first delete the existing MANY report of the
+		 * GREY_MSG checksum. */
+		if (eff_msg_tgts != new_msg_tgts
+		    && req_ck_msg) {
+			if (msg_tgts == DCC_TGTS_TOO_MANY
+			    && !add_del(req_ck_msg)) {
+				NORESP_EMSG(q);
+				return;
+			}
+			new_ck->type_fgs = DCC_CK_GREY_MSG;
+			memcpy(new_ck->sum, req_ck_msg->sum,
+			       sizeof(new_ck->sum));
+			++new.fgs_num_cks;
+			++new_ck;
+		}
+		/* Add the triple checksum if we are not whitelisting
+		 *	by the IP address
+		 * or triple checksum is not new.
+		 * We do not want to leave any dangling triples in the
+		 * database */
+		if (!(grey_weak_ip && req_ck_ip)
+		    || result_tgts != DCC_TGTS_TOO_MANY) {
+			new_ck->type_fgs = DCC_CK_GREY3;
+			memcpy(new_ck->sum, req_ck_triple->sum,
+			       sizeof(new_ck->sum));
+			++new.fgs_num_cks;
+		}
+		get_ts(&new.ts);
+		if (!db_add_rcd(dcc_emsg, &new)) {
+			DB_ERROR_MSG(dcc_emsg);
+			RIDC_BAD(q);
+			return;
+		}
+	}
+	/* In the result sent to the DCC client,
+	 * the triple checksum is preceeded by the message checksum
+	 * with a count of 0 if this is a new embargo.
+	 * Targets of messages of new embargos should be counted among
+	 * total targets in reports sent to DCC servers.  After they
+	 * have been included in such an early report to a DCC server,
+	 * they should never be included again, except for bad reputations. */
+	resp.msg = htonl(eff_msg_tgts);
+	/* Answer SMTP DATA command greylist operations with the target
+	 * count of the triple checksum:
+	 *	DCC_TGTS_OK if the embargo is just now being removed
+	 *	DCC_TGTS_TOO_MANY if there is no current embargo
+	 *	DCC_TGTS_GREY_WHITE if whitelisted.
+	 *	embargo # otherwise */
+	resp.triple = htonl(result_tgts);
+	resp.hdr.len = sizeof(resp);
+	fin_work(q, &resp.hdr);
+}
+static time_t
+picky_time(const QUEUE *q)
+{
+	time_t ts, delta;
+	/* If the request arrived while we were asleep, then the client's
+	 * timestamp ought to be smaller than when select() finished and
+	 * we think the request arrived. */
+	ts = ntohl(q->pkt.d.date);
+	delta = ts - q->answer.tv_sec;
+	if (delta <= 0)
+		return delta;
+	/* If the request arrived while we were handling some other request,
+	 * then its timestamp can be larger than the select() wake-up time
+	 * but should not be in the future. */
+	delta = ts - db_time.tv_sec;
+	if (delta < 0)
+		delta = 0;
+	return delta;
+}
+static u_char				/* 0=refuse the bad guy, 1=continue */
+picky_admn(const QUEUE *q, u_char any_id, u_char any_time)
+{
+	time_t delta;
+	if ((q->flags & Q_FG_UNTRUSTED)
+	    || (q->clnt_id != my_srvr_id && !any_id)) {
+		forget_error(q, "drop %s", from_id_ip(q, 1));
+		return 0;
+	}
+	if (any_id && any_time)
+		return 1;
+	/* Demand a current timestamp to guard against replay attacks.
+	 * This requires that administrators have clocks close to servers',
+	 * and that network and server delays be reasonable. */
+	delta = picky_time(q);
+	if (delta < -MAX_CMD_CLOCK_SKEW || delta > MAX_CMD_CLOCK_SKEW) {
+		send_error(q, "drop %s; timestamp off by %d seconds",
+			   qop2str(q), (int)delta);
+		return 0;
+	}
+	return 1;
+}
+/* the database must be locked */
+static u_char				/* 1=ok, 0=error sent to client */
+delete_sub(QUEUE *q, DCC_CK *del_ck,
+	   u_char grey_spam)
+{
+	DB_RCD_CK *rcd_ck;
+	char buf[80];
+	DB_PTR prev;
+	DCC_TGTS tgts;
+	buf[0] = '\0';
+	switch (db_lookup(dcc_emsg, del_ck->type, del_ck->sum,
+			  0, MAX_HASH_ENTRIES,
+			  &db_sts.hash, &db_sts.rcd, &rcd_ck)) {
+	case DB_FOUND_EMPTY:
+	case DB_FOUND_CHAIN:
+	case DB_FOUND_INTRUDER:
+		/* finished if we have not greylisted the spammer */
+		if (grey_spam)
+			return 1;
+		/* ordinary deletions need a delete request added
+		 * to the database and flooded */
+		snprintf(buf, sizeof(buf), "\"%s %s\" not found to delete",
+			 DB_TYPE2STR(del_ck->type),
+			 dcc_ck2str_err(del_ck->type, del_ck->sum, 0));
+		if (del_ck->type == DCC_CK_SRVR_ID) {
+			send_error(q, "%s", buf);
+			return 0;
+		}
+		break;
+	case DB_FOUND_IT:
+		tgts = DB_TGTS_CK(rcd_ck);
+		/* handle an ordinary delete request */
+		if (!grey_spam) {
+			if (tgts == 0)
+				snprintf(buf, sizeof(buf),
+					 "%s %s already deleted",
+					 DB_TYPE2STR(del_ck->type),
+					 dcc_ck2str_err(del_ck->type,
+							del_ck->sum, 0));
+			break;
+		}
+		/* We are deleting a greylist checksum.
+		 * If we are deleting very new greylist records,
+		 * we can cheat and avoid adding to the database
+		 * by scribbling over the records.
+		 * If there is an older record that might have been flooded,
+		 * we must add a delete request to the database
+		 * that will itself be flooded. */
+		for (;;) {
+			/* finished if the target has already been deleted */
+			if (tgts == 0)
+				return 1;
+			if (db_sts.rcd.s.rptr < oflods_max_cur_pos
+			    || oflods_max_cur_pos == 0) {
+				/* We need to add a delete request, because
+				 * the record might have been flooded */
+				break;
+			}
+			prev = DB_PTR_EX(rcd_ck->prev);
+			/* try to delete the entire greylist entry
+			 * starting with the target triple checksum */
+			do {
+				/* only if the embargo is not over */
+				if (DB_TGTS_CK(rcd_ck) >= DCC_TGTS_TOO_MANY)
+					goto need_rcd;
+				DB_TGTS_CK_SET(rcd_ck, 0);
+			} while (--rcd_ck >= db_sts.rcd.d.r->cks);
+			DB_TGTS_RCD_SET(db_sts.rcd.d.r, 0);
+			SET_FLUSH_RCD_HDR(&db_sts.rcd, 1);
+			/* stop after the last record */
+			if (prev == DB_PTR_NULL)
+				return 1;
+			rcd_ck = db_map_rcd_ck(dcc_emsg, &db_sts.rcd,
+					       prev, del_ck->type);
+			if (!rcd_ck) {
+				NORESP_EMSG(q);
+				return 0;
+			}
+			tgts = DB_TGTS_CK(rcd_ck);
+		}
+need_rcd:;
+		break;
+	case DB_FOUND_LATER:
+	case DB_FOUND_SYSERR:
+		DB_ERROR_MSG(dcc_emsg);
+		RIDC_BAD(q);
+		return 0;
+	}
+	/* Add the delete request to the database even if the
+	 * checksum seems deleted or absent so that we will
+	 * flood the delete request.  This is required to ensure that
+	 * records get deleted when they are created at one DCC server
+	 * and deleted at another. */
+	if (!add_del(del_ck))
+		BUFCPY(buf, dcc_emsg);
+	if (buf[0] != '\0') {
+		send_error(q, "%s", buf);
+		return 0;
+	}
+	TMSG3(ADMN, "deleted %s %s%s",
+	      DB_TYPE2STR(del_ck->type),
+	      dcc_ck2str_err(del_ck->type, del_ck->sum, 0),
+	      from_id_ip(q, 0));
+	return 1;
+}
+void
+do_delete(QUEUE *q)
+{
+	if (!ck_clnt_srvr_id(q))
+		return;
+	if (!picky_admn(q, 0, 0))
+		return;
+	/* if we've already answered, then just repeat ourselves */
+	if (ridc_get(q)) {
+		repeat_resp(q);
+		return;
+	}
+	dcc_error_msg("received %s", op_id_ip(q));
+	++dccd_stats.admin;
+	if (q->pkt_len != sizeof(q->pkt.d)) {
+		send_error(q, "wrong packet length %d for %s",
+			   q->pkt_len, qop2str(q));
+		return;
+	}
+	if (q->pkt.d.ck.len != sizeof(q->pkt.d.ck)) {
+		send_error(q, "unknown checksum length %d", q->pkt.d.ck.len);
+		return;
+	}
+	if (!DCC_CK_OK_DB(grey_on, q->pkt.d.ck.type)) {
+		send_error(q, "unknown checkksum type %d", q->pkt.d.ck.type);
+		return;
+	}
+	if (db_lock() < 0) {
+		NORESP_EMSG(q);
+		return;
+	}
+	if (delete_sub(q, &q->pkt.d.ck, 0)) {
+		/* We need to clean the database after a deletion
+		 * to correct the totals of other checksums.
+		 * Don't bother for reputations or server-ID declarations. */
+		if (!DCC_CK_IS_REP_CMN(grey_on, q->pkt.d.ck.type)
+		    && q->pkt.d.ck.type != DCC_CK_SRVR_ID)
+			need_del_dbclean = "checksum deleted";
+		send_ok(q);
+	}
+}
+/* restore the embargo against a sender of spam */
+void
+do_grey_spam(QUEUE *q)
+{
+	TMSG1(QUERY, "received %s", op_id_ip(q));
+	if (!ck_clnt_id(q))
+		return;
+	if (q->flags & Q_FG_UNTRUSTED) {
+		anon_msg("drop %s", from_id_ip(q, 1));
+		return;
+	}
+	/* require the checksum of the (source,sender,target) triple */
+	if (q->pkt_len != sizeof(q->pkt.gs)) {
+		send_error(q, "wrong packet length %d for %s",
+			   q->pkt_len, qop2str(q));
+		return;
+	}
+	if (q->pkt.gs.triple.type != DCC_CK_GREY3) {
+		send_error(q, "%s instead of %s for %s",
+			   DB_TYPE2STR(q->pkt.gs.msg.type),
+			   DB_TYPE2STR(DCC_CK_GREY3),
+			   qop2str(q));
+		return;
+	}
+	if (q->pkt.gs.triple.len != sizeof(q->pkt.gs.triple)) {
+		send_error(q, "unknown triple checksum length %d",
+			   q->pkt.gs.ip.len);
+		return;
+	}
+	if (q->pkt.gs.msg.type != DCC_CK_GREY_MSG) {
+		send_error(q, "%s instead of %s for %s",
+			   DB_TYPE2STR(q->pkt.gs.msg.type),
+			   DB_TYPE2STR(DCC_CK_GREY_MSG),
+			   qop2str(q));
+		return;
+	}
+	if (q->pkt.gs.msg.len != sizeof(q->pkt.gs.msg)) {
+		send_error(q, "unknown msg checksum length %d",
+			   q->pkt.gs.ip.len);
+		return;
+	}
+	if (q->pkt.gs.ip.type != DCC_CK_IP) {
+		send_error(q, "%s instead of %s for %s",
+			   DB_TYPE2STR(q->pkt.gs.msg.type),
+			   DB_TYPE2STR(DCC_CK_IP),
+			   qop2str(q));
+		return;
+	}
+	if (q->pkt.gs.ip.len != sizeof(q->pkt.gs.ip)) {
+		send_error(q, "unknown IP checksum length %d",
+			   q->pkt.gs.ip.len);
+		return;
+	}
+	if (db_lock() < 0) {
+		NORESP_EMSG(q);
+		return;
+	}
+	if (delete_sub(q, &q->pkt.gs.ip, 1)
+	    && delete_sub(q, &q->pkt.gs.triple, 1)
+	    && delete_sub(q, &q->pkt.gs.msg, 1))
+		send_ok(q);
+}
+static void
+do_flod(QUEUE *q)
+{
+	DCC_ADMN_RESP check;
+	int print_len;
+	u_int32_t val, arg;
+	DCC_AOP_FLODS fop;
+	FLOD_MMAP *mp;
+	OFLOD_INFO *ofp;
+	u_char loaded, found_it;
+	val = ntohl(q->pkt.ad.val1);
+	fop = val % 256;
+	arg = val / 256;
+	if (fop != DCC_AOP_FLOD_LIST) {
+	    if (!picky_admn(q, fop == DCC_AOP_FLOD_STATS, 0))
+		    return;
+	}
+	switch (fop) {
+	case DCC_AOP_FLOD_CHECK:
+		/* `cdcc "flood check"` forces occasional defenses of
+		 * our server-ID */
+		if (host_id_next > db_time.tv_sec + 60)
+			host_id_next = db_time.tv_sec;
+		next_flods_ck = 0;
+		if (0 >= check_load_ids(0)) {
+			dcc_error_msg("%s", dcc_emsg);
+			send_error(q, "%s", dcc_emsg);
+			return;
+		}
+		flod_stats_printf(check.val.string, sizeof(check.val.string),
+				  (!FLODS_OK() || flods_st == FLODS_ST_OFF)
+				  ? 0
+				  : (flods_st != FLODS_ST_ON) ? 1
+				  : 2,
+				  oflods.total, oflods.open, iflods.open);
+		check.hdr.len = (strlen(check.val.string)
+				 + sizeof(check)-sizeof(check.val));
+		check.hdr.op = DCC_OP_ADMN;
+		send_resp(q, &check.hdr, 0);
+		flods_ck(1);
+		check_blacklist_file();
+		return;
+	case DCC_AOP_FLOD_SHUTDOWN:
+		if (ridc_get(q)) {
+			repeat_resp(q);
+			return;
+		}
+		++flods_off;
+		flods_stop("shutdown flooding", 0);
+		send_ok(q);
+		return;
+	case DCC_AOP_FLOD_HALT:
+		if (ridc_get(q)) {
+			repeat_resp(q);
+			return;
+		}
+		++flods_off;
+		flods_stop("stop flooding", 1);
+		send_ok(q);
+		return;
+	case DCC_AOP_FLOD_RESUME:
+		if (ridc_get(q)) {
+			repeat_resp(q);
+			return;
+		}
+		if (0 >= check_load_ids(0)) {
+			dcc_error_msg("%s", dcc_emsg);
+			send_error(q, "%s", dcc_emsg);
+			return;
+		}
+		if (flods_off) {
+			flods_off = 0;
+			flods_restart("resume flooding", 0);
+		}
+		send_ok(q);
+		flods_ck(0);
+		return;
+	case DCC_AOP_FLOD_REWIND:
+		if (ridc_get(q)) {
+			repeat_resp(q);
+			return;
+		}
+		if (flod_mmaps) {
+			loaded = 0;
+		} else if (!load_flod(0)) {
+			send_error(q, "too busy to rewind floods");
+			return;
+		} else {
+			loaded = 1;
+		}
+		found_it = (arg == DCC_ID_INVALID);
+		for (mp = flod_mmaps->mmaps;
+		     mp <= LAST(flod_mmaps->mmaps);
+		     ++mp) {
+			if (arg == DCC_ID_INVALID
+			    || mp->rem_id == arg) {
+				mp->flags |= FLODMAP_FG_NEED_REWIND;
+				mp->flags &= ~FLODMAP_FG_FFWD_IN;
+				dcc_trace_msg("rewind flood from server-ID %d",
+					      arg);
+				found_it = 1;
+			}
+		}
+		if (!found_it) {
+			send_error(q, "unknown server-ID %d for %s",
+				   arg, qop2str(q));
+		} else {
+			send_ok(q);
+			flods_ck(0);
+		}
+		if (loaded)
+			oflods_clear();
+		return;
+	case DCC_AOP_FLOD_LIST:
+		loaded = !flod_mmaps && load_flod(0);
+		if (flod_mmaps) {
+			print_len = flods_list(check.val.string,
+					       sizeof(check.val.string),
+					       (q->flags & Q_FG_UNTRUSTED)!=0);
+		} else {
+			/* it is not an error if map is locked, because
+			 * dbclean uses this operation to see if we are
+			 * listening */
+			print_len = snprintf(check.val.string,
+					     ISZ(check.val.string),
+					     "too busy to list floods");
+			if (print_len > ISZ(check.val.string))
+				print_len = ISZ(check.val.string);
+		}
+		check.hdr.len = (print_len
+				 + sizeof(check)-sizeof(check.val));
+		check.hdr.op = DCC_OP_ADMN;
+		send_resp(q, &check.hdr, 0);
+		if (loaded)
+			oflods_clear();
+		return;
+	case DCC_AOP_FLOD_STATS:
+	case DCC_AOP_FLOD_STATS_CLEAR:
+		print_len = flod_stats(check.val.string,
+				       sizeof(check.val.string),
+				       arg,
+				       fop == DCC_AOP_FLOD_STATS_CLEAR);
+		if (print_len < 0) {
+			send_error(q, "too busy to find flood stats");
+			return;
+		}
+		check.hdr.len = print_len + sizeof(check)-sizeof(check.val);
+		check.hdr.op = DCC_OP_ADMN;
+		send_resp(q, &check.hdr, 0);
+		flods_ck(0);
+		return;
+	case DCC_AOP_FLOD_FFWD_IN:
+	case DCC_AOP_FLOD_FFWD_OUT:
+		if (ridc_get(q)) {
+			repeat_resp(q);
+			return;
+		}
+		if (flod_mmaps) {
+			loaded = 0;
+		} else if (!load_flod(0)) {
+			send_error(q, "too busy to fast-forward floods");
+			return;
+		} else {
+			loaded = 1;
+		}
+		ofp = oflods.infos;
+		for (;;) {
+			mp = ofp->mp;
+			if (mp->rem_id == arg) {
+				/* found the target */
+				if (fop == DCC_AOP_FLOD_FFWD_OUT) {
+					ofp->cur_pos = db_csize;
+					if (ofp->soc < 0)
+					    mp->confirm_pos = db_csize;
+					dcc_trace_msg("fast forward flood to"
+						      " server-ID %d",
+						      arg);
+				} else {
+					mp->flags |= FLODMAP_FG_FFWD_IN;
+					mp->flags &= ~FLODMAP_FG_NEED_REWIND;
+				}
+				send_ok(q);
+				if (!loaded)
+					flods_ck(0);
+				break;
+			}
+			if (++ofp > LAST(oflods.infos)) {
+				send_error(q, "unknown server-ID %d for %s",
+					   arg, qop2str(q));
+				break;
+			}
+		}
+		if (loaded)
+			oflods_clear();
+		return;
+	}
+	send_error(q, "unrecognized %s value %d", qop2str(q), fop);
+}
+void
+stats_clear(void)
+{
+	OFLOD_INFO *ofp;
+	memset(&dccd_stats, 0, sizeof(dccd_stats));
+	for (ofp = oflods.infos; ofp <= LAST(oflods.infos); ++ofp) {
+		if (ofp->rem_hostname[0] == '\0')
+			continue;
+		/* The counts reported to `cdcc stats` are sums
+		 * of the dccd_stats and ofp->cnts values.  Bias
+		 * the dccd_stats values by the current ofp->cnts values
+		 * so the reported counts will be zero.  When the flooding
+		 * connection is closed, the ofp->cnts values will be added
+		 * to the dccd_stats values. */
+		dccd_stats.iflod_total -= ofp->cnts.total;
+		dccd_stats.iflod_accepted -= ofp->cnts.accepted;
+		dccd_stats.iflod_stale -= ofp->lc.stale.cur;
+		dccd_stats.iflod_dup -= ofp->lc.dup.cur;
+		dccd_stats.iflod_wlist -= ofp->lc.wlist.cur;
+		dccd_stats.iflod_not_deleted -= ofp->lc.not_deleted.cur;
+	}
+	q_delays_start = 0;
+	memset(&db_stats, 0, sizeof(db_stats));
+	dccd_stats.reset = db_time;
+}
+static u_char				/* 1=sent 0=something wrong */
+stats_send(QUEUE *q)
+{
+	DCC_ADMN_RESP stats;
+	char tbuf[80];
+	OFLOD_INFO *ofp;
+	IFLOD_INFO *ifp;
+	int oflods_connecting, iflods_connecting;
+	SCNTR iflod_total, iflod_accepted, iflod_stale;
+	SCNTR iflod_dup, iflod_wlist, iflod_not_deleted;
+	char flod_buf[60];
+	char clients_reset[40], reset_buf[36], now_buf[20];
+	int clients;
+	int age;
+	const char *client_ovf;
+	int blen, plen, len;
+	tbuf[0] = '\0';
+	if (dccd_tracemask & DCC_TRACE_ADMN_BIT)
+		strcat(tbuf, "ADMN ");
+	if (dccd_tracemask & DCC_TRACE_ANON_BIT)
+		strcat(tbuf, "ANON ");
+	if (dccd_tracemask & DCC_TRACE_CLNT_BIT)
+		strcat(tbuf, "CLNT ");
+	if (dccd_tracemask & DCC_TRACE_RLIM_BIT)
+		strcat(tbuf, "RLIM ");
+	if (dccd_tracemask & DCC_TRACE_QUERY_BIT)
+		strcat(tbuf, "QUERY ");
+	if (dccd_tracemask & DCC_TRACE_RIDC_BIT)
+		strcat(tbuf, "RIDC ");
+	if (dccd_tracemask & DCC_TRACE_FLOD_BIT)
+		strcat(tbuf, "FLOOD ");
+	if (dccd_tracemask & DCC_TRACE_FLOD2_BIT)
+		strcat(tbuf, "FLOOD2 ");
+	if (dccd_tracemask & DCC_TRACE_IDS_BIT)
+		strcat(tbuf, "IDS ");
+	if (dccd_tracemask & DCC_TRACE_BL_BIT)
+		strcat(tbuf, "BL ");
+	if (dccd_tracemask & DCC_TRACE_DB_BIT)
+		strcat(tbuf, "DB ");
+	if (dccd_tracemask & DCC_TRACE_WLIST_BIT)
+		strcat(tbuf, "WLIST ");
+	clients = clients_get(0, 0, 0, 0, 0, 0, 0);
+	if (clients >= 0) {
+		client_ovf = "";
+	} else {
+		client_ovf = ">";
+		clients = -clients;
+	}
+	age = db_time.tv_sec - clients_cleared;
+	if (age <= 24*60*60) {
+		dcc_time2str(clients_reset, sizeof(clients_reset),
+			     "since %X", clients_cleared);
+	} else if (age <= 3*24*60*60) {
+		snprintf(clients_reset, sizeof(clients_reset),
+			 "in %d hours", (age + 60*60/2) / (60*60));
+	} else {
+		snprintf(clients_reset, sizeof(clients_reset),
+			 "in %d days", (age + 24*60*60/2) / (24*60*60));
+	}
+	oflods_connecting = 0;
+	iflod_total = dccd_stats.iflod_total;
+	iflod_accepted = dccd_stats.iflod_accepted;
+	iflod_stale = dccd_stats.iflod_stale;
+	iflod_dup = dccd_stats.iflod_dup;
+	iflod_wlist = dccd_stats.iflod_wlist;
+	iflod_not_deleted = dccd_stats.iflod_not_deleted;
+	for (ofp = oflods.infos; ofp <= LAST(oflods.infos); ++ofp) {
+		if (ofp->soc >= 0 && !(ofp->flags & OFLOD_FG_CONNECTED))
+			++oflods_connecting;
+		iflod_total += ofp->cnts.total;
+		iflod_accepted += ofp->cnts.accepted;
+		iflod_stale += ofp->lc.stale.cur;
+		iflod_dup += ofp->lc.dup.cur;
+		iflod_wlist += ofp->lc.wlist.cur;
+		iflod_not_deleted += ofp->lc.not_deleted.cur;
+	}
+	iflods_connecting = 0;
+	for (ifp = iflods.infos; ifp <= LAST(iflods.infos); ++ifp) {
+		if (ifp->soc >= 0 && !(ifp->flags & IFLOD_FG_VERS_CK))
+			++iflods_connecting;
+	}
+	dcc_time2str(reset_buf, sizeof(reset_buf),"%b %d %X",
+		     dccd_stats.reset.tv_sec);
+	dcc_time2str(now_buf, sizeof(now_buf), "%b %d %X %Z",
+		     db_time.tv_sec);
+	blen = min(sizeof(stats.val.string), ntohl(q->pkt.ad.val1));
+	plen = snprintf(stats.val.string, blen,
+	    "    version "DCC_VERSION"  %s%s%stracing %s\n"
+	    "%7d hash entries %6d used "L_DWPAT(9)" DB bytes\n"
+	    "%5d ms delay  "L_DPAT" NOPs  "L_DPAT""
+	    " ADMN  "L_DPAT" query  %s%d clients %s\n",
+	    db_minimum_map ? "DB UNLOCKED  " : "",
+	    query_only ? "Q-mode  " : "",
+	    grey_on ? "greylist  " : "",
+	    tbuf[0] ? tbuf : "nothing",
+	    HADDR2LEN(db_hash_len), HADDR2LEN(db_hash_used), db_csize,
+	    avg_q_delay_ms(q),
+	    dccd_stats.nops, dccd_stats.admin, dccd_stats.queries,
+	    client_ovf, clients, clients_reset);
+	if (plen >= blen)
+		plen = blen-1;
+	blen -= plen;
+	if (grey_on) {
+		len = snprintf(&stats.val.string[plen], blen,
+	    L_DWPAT(7)" reports "L_DWPAT(2)" whitelisted\n",
+	    dccd_stats.reports,
+	    dccd_stats.respwhite);
+	} else {
+		len = snprintf(&stats.val.string[plen], blen,
+			       L_DWPAT(8)" reports "
+			       L_DWPAT(7)">10 "
+			       L_DWPAT(7)">100 "
+			       L_DWPAT(7)">1000 "
+			       L_DWPAT(7)" many\n"
+			       "         answers "L_DWPAT(7)">10 "
+			       L_DWPAT(7)">100 "
+			       L_DWPAT(7)">1000 "
+			       L_DWPAT(7)" many\n",
+	    dccd_stats.reports,
+	    (dccd_stats.report10 + dccd_stats.report100
+	     + dccd_stats.report1000 + dccd_stats.reportmany),
+	    (dccd_stats.report100 + dccd_stats.report1000
+	     + dccd_stats.reportmany),
+	    dccd_stats.report1000 + dccd_stats.reportmany,
+	    dccd_stats.reportmany,
+	    (dccd_stats.resp10 + dccd_stats.resp100
+	     + dccd_stats.resp1000 + dccd_stats.respmany),
+	    dccd_stats.resp100 + dccd_stats.resp1000 + dccd_stats.respmany,
+	    dccd_stats.resp1000 + dccd_stats.respmany,
+	    dccd_stats.respmany);
+	}
+	if (len >= blen)
+		len = blen-1;
+	blen -= len;
+	plen += len;
+	len = snprintf(&stats.val.string[plen], blen,
+	    L_DWPAT(8)" bad op "
+	    L_DWPAT(4)" passwd "
+	    L_DWPAT(6)" blist "
+	    L_DWPAT(4)" reject "
+	    L_DWPAT(6)" retrans\n",
+	    dccd_stats.bad_op, dccd_stats.bad_passwd, dccd_stats.blist,
+	    dccd_stats.send_error,  dccd_stats.report_retrans);
+	if (len >= blen)
+		len = blen-1;
+	blen -= len;
+	plen += len;
+	if (!grey_on) {
+		len = snprintf(&stats.val.string[plen], blen,
+	    L_DWPAT(8)" answers rate-limited "
+	    L_DWPAT(4)" anon "
+	    L_DWPAT(5)" reports rejected\n",
+	    dccd_stats.rl, dccd_stats.anon_rl,  dccd_stats.report_reject);
+		if (len >= blen)
+			len = blen-1;
+		blen -= len;
+		plen += len;
+	}
+	len = snprintf(&stats.val.string[plen], blen,
+	    "    %s "
+	    L_DWPAT(8)" total flooded in\n"
+	    L_DWPAT(8)" accepted "
+	    L_DWPAT(6)" stale "
+	    L_DWPAT(8)" dup  "
+	    L_DWPAT(5)" white    "
+	    L_DPAT" delete\n"
+	    L_DWPAT(8)" reports added between %s and %s",
+	    flod_stats_printf(flod_buf, sizeof(flod_buf),
+			      (db_minimum_map || flods_st == FLODS_ST_OFF) ? 0
+			      : (flods_st != FLODS_ST_ON) ? 1
+			      : 2,
+			      oflods.total,
+			      oflods.open - oflods_connecting,
+			      iflods.open - iflods_connecting),
+	    iflod_total,
+	    iflod_accepted, iflod_stale, iflod_dup,
+	    iflod_wlist, iflod_not_deleted,
+	    dccd_stats.adds+db_stats.adds, reset_buf, now_buf);
+	if (len >= blen)
+		len = blen-1;
+	blen -= len;
+	plen += len;
+	stats.hdr.len = plen + sizeof(stats)-sizeof(stats.val);
+	stats.hdr.op = DCC_OP_ADMN;
+	send_resp(q, &stats.hdr, 0);
+	return 1;
+}
+void
+timestamp_send(const QUEUE *q)
+{
+	time_t delta;
+	DCC_ADMN_RESP msg;
+	int blen, plen;
+	delta = picky_time(q);
+	blen = min(sizeof(msg.val.string), ntohl(q->pkt.ad.val1));
+	if (delta < -MAX_CMD_CLOCK_SKEW || delta > MAX_CMD_CLOCK_SKEW) {
+		if (delta < -MAX_FLOD_CLOCK_SKEW
+		    || delta > MAX_FLOD_CLOCK_SKEW) {
+			plen = snprintf(msg.val.string, blen,
+					"    clocks differ by about %d seconds"
+					"\n    which is more than the"
+					" maximum allowed for flooding, %d",
+					(int)delta, MAX_FLOD_CLOCK_SKEW);
+		} else {
+			plen = snprintf(msg.val.string, blen,
+					"    clocks differ by about %d seconds"
+					"\n    which is more than the"
+					" maximum allowed for commands, %d",
+					(int)delta, MAX_CMD_CLOCK_SKEW);
+		}
+	} else {
+		plen = snprintf(msg.val.string, blen,
+				"    clocks differ by about %d seconds",
+				(int)delta);
+	}
+	msg.hdr.len = plen + sizeof(msg)-sizeof(msg.val);
+	msg.hdr.op = DCC_OP_ADMN;
+	send_resp(q, &msg.hdr, 0);
+}
+void
+do_nop(QUEUE *q)
+{
+	/* respond immediately to even anonymous NOPs so that clients
+	 * that are confused about passwords and whether they are anonymous
+	 * do not retransmit unnecessarily */
+	TMSG1(ADMN, "received %s", op_id_ip(q));
+	++dccd_stats.nops;
+	if (!ck_clnt_srvr_id(q)) {
+		++q->rl->d.nops;
+		return;
+	}
+	++q->rl->d.nops;
+	send_ok(q);
+}
+/* deal with an adminstative request */
+void
+do_admn(QUEUE *q)
+{
+	u_int32_t val1;
+	DCC_ADMN_RESP resp;
+	int len, offset;
+	u_int32_t adelay_ms;
+	struct in6_addr addr6, mask6;
+	const struct in6_addr *addr6p, *mask6p;
+	val1 = ntohl(q->pkt.ad.val1);
+	TMSG3(ADMN, "received val2=%#x val3=%#x in %s",
+	      q->pkt.ad.val2, q->pkt.ad.val3, op_id_ip(q));
+	++dccd_stats.admin;
+	if (!ck_clnt_srvr_id(q))
+		return;
+	if (q->pkt_len != DCC_ADMN_REQ_MIN_SIZE
+	    && (q->pkt_len != (DCC_ADMN_REQ_MIN_SIZE
+			       + sizeof(DCC_AOP_CLIENTS_CIDR))
+		|| (q->pkt.ad.aop != DCC_AOP_CLIENTS
+		    && q->pkt.ad.aop != DCC_AOP_CLIENTS_ID))) {
+		send_error(q, "%s size = %d", qop2str(q), q->pkt_len);
+		return;
+	}
+	switch ((DCC_AOPS)q->pkt.ad.aop) {
+	case DCC_AOP_STOP:		/* stop gracefully */
+		if (!picky_admn(q, 0, 0))
+			return;
+		if (ridc_get(q)) {
+			repeat_resp(q);
+			return;
+		}
+		if (!stopint) {
+			stopint = -1;
+			next_flods_ck = 0;
+		}
+		send_ok(q);
+		/* fsync() or let the database be wrong	if asked */
+		if (val1 != 0)
+			stop_mode = val1;
+		return;
+	case DCC_AOP_DB_UNLOAD:
+		if (!picky_admn(q, 0, 0))
+			return;
+		/* repeat previous answer to repeated question */
+		if (ridc_get(q)) {
+			repeat_resp(q);
+			return;
+		}
+		/* unlike dbclean, dblist starts looking at the data
+		 * immediately, so we cannot answer before flushing */
+		if (val1 == 0) {
+			dcc_trace_msg("database flush started");
+			rel_db_states();
+			db_minimum_map = 1;
+			db_unload(0, 0);
+			dcc_trace_msg("database flushed; buffering off");
+		} else {
+			db_minimum_map = 0;
+			dcc_trace_msg("database buffering on");
+		}
+		send_ok(q);
+		return;
+	case DCC_AOP_FLOD:		/* control flooding */
+		do_flod(q);
+		return;
+	case DCC_AOP_DB_CLEAN:		/* start switch to new database */
+		if (!picky_admn(q, 0, 0))
+			return;
+		/* repeat previous answer to repeated question */
+		if (ridc_get(q)) {
+			repeat_resp(q);
+			return;
+		}
+		if (!flods_off || oflods.total != 0) {
+			send_error(q, "flooding not stopped before %s",
+				   qop2str(q));
+			return;
+		}
+		send_ok(q);		/* asnwer now before we stall */
+		dcc_trace_msg("database cleaning begun");
+		next_flods_ck = 0;
+		/* don't start our own cleaning */
+		del_dbclean_next = db_time.tv_sec + DEL_DBCLEAN_SECS;
+		dbclean_limit = db_time.tv_sec + dbclean_limit_secs;
+		/* Dbclean expects us to remove its separate hold on flooding
+		 * so that it will not need to talk to us after telling us
+		 * to close the old database.  This because we might stall
+		 * on some systems with lame mmap() support including BSD/OS,
+		 * for minutes in close().
+		 * It might be nice to be able to turn off flooding before
+		 * dbclean is run and have it remain off when dbclean
+		 * finishes.  However, the need for that that is very rare
+		 * and there are mysterious cases where flooding gets
+		 * turned off by dbclean and never restored. */
+		flods_off = 0;
+		/* release and unmap buffers, possibly stalling */
+		db_minimum_map = 1;
+		rel_db_states();
+		db_unload(0, 0);
+		return;
+	case DCC_AOP_DB_NEW:		/* finish switch to new database */
+		if (!picky_admn(q, 0, 0))
+			return;
+		if (ridc_get(q)) {
+			repeat_resp(q);
+			return;
+		}
+		if (!db_minimum_map) {
+			send_error(q, "%s received before %s",
+				   qop2str(q),
+				   dcc_aop2str(0, 0, DCC_AOP_DB_CLEAN, 0));
+			return;
+		}
+		/* send "ok" now because we may stall waiting to reopen */
+		send_ok(q);
+		db_close(1);
+		dccd_stats.adds += db_stats.adds;
+		if (!dccd_db_open(DB_OPEN_LOCK_WAIT))
+			dcc_logbad(dcc_ex_code,
+				   "could not restart database %s: %s",
+				   db_nm, dcc_emsg);
+		dcc_trace_msg(DCC_VERSION" database %s reopened with %s",
+			      db_nm, db_window_size_str);
+		flods_off = 0;
+		flods_restart("database reopened", 0);
+		next_flods_ck = 0;	/* possibly reap dbclean child */
+		if (0 >= check_load_ids(2))
+			dcc_error_msg("%s", dcc_emsg);
+		return;
+	case DCC_AOP_STATS:		/* return counters */
+		/* we cannot just repeat ourselves for retransmissions,
+		 * because the answer is too big to save */
+		stats_send(q);
+		return;
+	case DCC_AOP_STATS_CLEAR:	/* return and then zero counters */
+		if (!picky_admn(q, 0, 0))
+			return;
+		/* we cannot just repeat ourselves for retransmissions,
+		 * because the answer is too big to save */
+		if (stats_send(q)) {
+			clients_clear();
+			stats_clear();
+		}
+		return;
+	case DCC_AOP_TRACE_ON:
+	case DCC_AOP_TRACE_OFF:
+		if (!picky_admn(q, 0, 0))
+			return;
+		/* it is idempotent, but suppress duplicate trace messages */
+		if (ridc_get(q)) {
+			repeat_resp(q);
+			return;
+		}
+		/* log trace changes even when tracing is off */
+		if (!(DCC_TRACE_ADMN_BIT & dccd_tracemask))
+			dcc_trace_msg("received %s", op_id_ip(q));
+		if ((val1 & ~DCC_TRACE_BITS) != 0 || val1 == 0) {
+			send_error(q, "invalid trace bits %#x", val1);
+			return;
+		}
+		if (q->pkt.ad.aop == DCC_AOP_TRACE_OFF) {
+			dccd_tracemask &= ~val1;
+		} else {
+			dccd_tracemask |= val1;
+			/* do not suppress the next duplicated flood message */
+			if (val1 & DCC_TRACE_FLOD_BIT)
+				flod_trace_gen = db_time.tv_sec;
+		}
+		send_ok(q);
+		return;
+	case DCC_AOP_CLIENTS:
+	case DCC_AOP_CLIENTS_ID:
+		if (!picky_admn(q, 1, 1))
+			return;
+		/* we cannot just repeat ourselves for retransmissions,
+		 * because the answer is too big to save */
+		offset = (val1 >> 16) + (((u_int)q->pkt.ad.val4) << 16);
+		val1 &= 0xffff;
+		len = q->pkt.ad.val2;
+		if (q->pkt_len == (DCC_ADMN_REQ_MIN_SIZE
+				   + sizeof(DCC_AOP_CLIENTS_CIDR))) {
+			memcpy(&addr6, &q->pkt.ad.val5[0], sizeof(addr6));
+			dcc_bits2mask(&mask6, q->pkt.ad.val5[sizeof(addr6)]);
+			addr6p = &addr6;
+			mask6p = &mask6;
+		} else {
+			mask6p = 0;
+			addr6p = 0;
+		}
+		if (q->pkt.ad.aop == DCC_AOP_CLIENTS)
+			clients_get(&resp.val, &len, offset,
+				    val1, q->pkt.ad.val3, addr6p, mask6p);
+		else
+			clients_get_id(&resp.val, &len, offset,
+				       val1, q->pkt.ad.val3, addr6p, mask6p);
+		resp.hdr.len = len + sizeof(resp)-sizeof(resp.val);
+		resp.hdr.op = DCC_OP_ADMN;
+		send_resp(q, &resp.hdr, 0);
+		return;
+	case DCC_AOP_ANON_DELAY:
+		/* get and set the anonymous client delay
+		 *
+		 * repeat answer to identical question */
+		if (ridc_get(q)) {
+			repeat_resp(q);
+			return;
+		}
+		if (anon_off)
+			adelay_ms = DCC_ANON_DELAY_FOREVER;
+		else
+			adelay_ms = anon_delay_us/1000;
+		resp.val.anon_delay.delay[0] = adelay_ms>>8;
+		resp.val.anon_delay.delay[1] = adelay_ms;
+		if (anon_delay_inflate == DCC_ANON_INFLATE_OFF) {
+			resp.val.anon_delay.inflate[0] = 0;
+			resp.val.anon_delay.inflate[1] = 0;
+			resp.val.anon_delay.inflate[2] = 0;
+			resp.val.anon_delay.inflate[3] = 0;
+		} else {
+			resp.val.anon_delay.inflate[0] = anon_delay_inflate>>24;
+			resp.val.anon_delay.inflate[1] = anon_delay_inflate>>16;
+			resp.val.anon_delay.inflate[2] = anon_delay_inflate>>8;
+			resp.val.anon_delay.inflate[3] = anon_delay_inflate;
+		}
+		adelay_ms = (q->pkt.ad.val2<<8) + q->pkt.ad.val3;
+		if (adelay_ms != DCC_NO_ANON_DELAY
+		    && picky_admn(q, 0, 0)) {
+			if (adelay_ms == DCC_ANON_DELAY_FOREVER) {
+				anon_off = 1;
+			} else {
+				anon_off = 0;
+				if (adelay_ms > DCC_ANON_DELAY_MAX/1000)
+					adelay_ms = DCC_ANON_DELAY_MAX/1000;
+				anon_delay_us = adelay_ms*1000;
+				if (val1 == 0)
+					val1 = DCC_ANON_INFLATE_OFF;
+				anon_delay_inflate = val1;
+			}
+		}
+		resp.hdr.len = (sizeof(resp)-sizeof(resp.val)
+				+ sizeof(resp.val.anon_delay));
+		resp.hdr.op = DCC_OP_ADMN;
+		send_resp(q, &resp.hdr, 0);
+		return;
+	case DCC_AOP_CLOCK_CHECK:
+		timestamp_send(q);
+		return;
+	case DCC_AOP_OK:
+	case DCC_AOP_unused1:
+	default:
+		break;
+	}
+	send_error(q, "invalid %s", qop2str(q));
+}

Mercurial > notdcc

comparison dccd/work.c @ 0:c7f6b056b673