/* Distributed Checksum Clearinghouse
 *
 * client-server and server-server protocols
 *
 * 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.137 $Revision$
 */

#ifndef DCC_PROTO_H
#define DCC_PROTO_H

#define DCC_PKT_VERSION4    4
#define	DCC_PKT_VERSION5    5
#define	DCC_PKT_VERSION6    6
#define	DCC_PKT_VERSION7    7
#define	DCC_PKT_VERSION8    8
#define	DCC_PKT_VERSION	    9		/* current */
#define	DCC_PKT_VERSION_MIN	DCC_PKT_VERSION4    /* recognized */
#define	DCC_PKT_VERSION_MAX	DCC_PKT_VERSION
#define DCC_PKT_VERSION_MIN_VALID   DCC_PKT_VERSION_MIN	/* sanity check */
#define	DCC_PKT_VERSION_MAX_VALID   0x7f


#define DCC_SRVR_PORT	6277		/* default DCC server port # */
#define DCC_GREY_PORT	6276		/* grey listing server port */


/* types of checksums */
typedef enum {
    DCC_CK_INVALID	    =0,		/* deleted from database when seen */
    DCC_CK_IP		    =1,		/* MD5 of binary source IPv6 address */
    DCC_CK_ENV_FROM	    =2,		/*  "  "  envelope Mail From value */
    DCC_CK_FROM		    =3,		/*  "  "  header From: line */
    DCC_CK_SUB		    =4,		/*  "  "  substitute header line */
    DCC_CK_MESSAGE_ID	    =5,		/*  "  "  header Message-ID: line */
    DCC_CK_RECEIVED	    =6,		/*  "  "  last header Received: line */
    DCC_CK_BODY		    =7,		/*  "  "  body */
    DCC_CK_FUZ1		    =8,		/*  "  "  filtered body */
    DCC_CK_FUZ2		    =9,		/*  "  "     "      "   */
    DCC_CK_G_MSG_R_TOTAL    =10,
#    define DCC_CK_GREY_MSG   DCC_CK_G_MSG_R_TOTAL
#    define DCC_CK_REP_TOTAL  DCC_CK_G_MSG_R_TOTAL
    DCC_CK_G_TRIPLE_R_BULK  =11,
#    define DCC_CK_GREY3      DCC_CK_G_TRIPLE_R_BULK
#    define DCC_CK_REP_BULK   DCC_CK_G_TRIPLE_R_BULK
    DCC_CK_SRVR_ID	    =12,	/* hostname for server-ID check */
    DCC_CK_ENV_TO	    =13		/* MD5 of envelope Rcpt To value */
#    define DCC_CK_FLOD_PATH  DCC_CK_ENV_TO /* flooding path in server-IDs */
} DCC_CK_TYPES;
typedef u_char DCC_CK_TYPE_B;		/* big enough */
#define DCC_CK_TYPE_FIRST   DCC_CK_IP
#define DCC_CK_TYPE_LAST    DCC_CK_ENV_TO
#define DCC_NUM_CKS	    DCC_CK_TYPE_LAST    /* # of valid types */

/* DCC_DIM_CKS dimensions arrays of checksum types including DCC_CK_INVALID
 * Beware that DCC_DIM_CKS is used in the database header. */
#define DCC_DIM_CKS	    (DCC_CK_TYPE_LAST+1)

/* record of path taken by a report */
#define DCC_NUM_FLOD_PATH ((int)(sizeof(DCC_SUM)/sizeof(DCC_SRVR_ID)))
typedef struct {
    u_char	hi, lo;
} DCC_FLOD_PATH_ID;
/* DCC_MAX_FLOD_PATH assumes that among the maximum 14 possible slots for
 * checksums in a flooded report (dimension of cks in a DB_RCD or DCC_DIM_CKS),
 *	DCC_CK_INVALID is never used
 *	DCC_CK_SRVR_ID is never used when any real checksums are present,
 * is so there is always room for 2 extra DCC_CK_FLOD_PATH entries besides
 * the natural DCC_CK_FLOD_PATH entry. */
#define DCC_MAX_FLOD_PATH_CKSUMS 3
/* This must not be too large lest reports become larger than DCC_DIM_CKS */
#define DCC_MAX_FLOD_PATH (DCC_NUM_FLOD_PATH*DCC_MAX_FLOD_PATH_CKSUMS)


/* checksums in client-server protocol */
#define	DCC_QUERY_MAX DCC_DIM_CKS	/* even to prevent structure padding */

/* Ensure that arrays of DCC_CKs contain an even number so that structures
 * containing them will have no extra structure packing */
#define DCC_COMP_DIM_CKS    ((((DCC_NUM_CKS+1)+1)/2)*2)	/* == DCC_DIM_CKS */

/* keep some checksums in the database longer than others */
#define DCC_CK_LONG_TERM(t) ((t) >= DCC_CK_FUZ1				\
			     && (t) <= DCC_CK_G_TRIPLE_R_BULK)

#define DCC_CK_IS_BODY(t) ((t) >= DCC_CK_BODY && (t) <= DCC_CK_FUZ2)

/* MD5 of greylist msg+sender+target */
#define DCC_CK_IS_GREY_MSG(g,t) ((g) && (t) == DCC_CK_G_MSG_R_TOTAL)
/* MD5 of greylisted triple */
#define DCC_CK_IS_GREY_TRIPLE(g,t) ((g) && (t) == DCC_CK_G_TRIPLE_R_BULK)
#define DCC_CK_IS_GREY(g,t) (DCC_CK_IS_GREY_MSG(g,t)			\
			     || DCC_CK_IS_GREY_TRIPLE(g,t))

/* total messages sent by an IP address */
#define DCC_CK_IS_REP_TOTAL_CMN(g,t) (!(g) && (t) == DCC_CK_G_MSG_R_TOTAL)
/* bulk messages sent by an IP address */
#define DCC_CK_IS_REP_BULK_CMN(g,t) (!(g) && (t) == DCC_CK_G_TRIPLE_R_BULK)
#define DCC_CK_IS_REP_CMN(g,t) (DCC_CK_IS_REP_TOTAL_CMN(g,t)		\
				|| DCC_CK_IS_REP_BULK_CMN(g,t))
#define DCC_CK_IS_REP_TOTAL_OP(g,t) 0
#define DCC_CK_IS_REP_BULK_OP(g,t)  0
#define DCC_CK_IS_REP_OP(g,t)	    0



typedef enum {
    DCC_OP_INVALID	=0,
    DCC_OP_NOP		=1,		/* see if the server is alive */
    DCC_OP_REPORT	=2,		/* old client reporting and querying */
    DCC_OP_QUERY	=3,		/* client querying */
    DCC_OP_ANSWER	=4,		/* server responding */
    DCC_OP_ADMN		=5,		/* control the server */
    DCC_OP_OK		=6,		/* administrative operation ok */
    DCC_OP_ERROR	=7,		/* server failing or complaining */
    DCC_OP_DELETE	=8,		/* delete some checksums */
    DCC_OP_GREY_REPORT	=9,		/* greylist report */
    DCC_OP_GREY_QUERY	=10,		/*   "   "  query */
    DCC_OP_GREY_SPAM	=11,		/* forget greylisted spammer */
    DCC_OP_GREY_WHITE	=12		/* whitelisted greylist triple */
} DCC_OPS;

typedef u_int32_t DCC_CLNT_ID;
#define DCC_ID_INVALID	    0
#define DCC_ID_ANON	    1		/* anonymous (non-paying) client */
#define DCC_ID_WHITE	    2		/* whitelisted */
#define DCC_ID_COMP	    3		/* compressed */
#define	DCC_ID_SRVR_SIMPLE  4		/* simple server */
#define DCC_ID_SRVR_REP_OK  5		/* ok to use reputations */
#define	DCC_ID_SRVR_IGNORE  6		/* ignore its flooded reports */
#define	DCC_ID_SRVR_ROGUE   7		/* crazy server */
#define DCC_ID_SRVR_TYPE(id) ((id) == DCC_ID_SRVR_SIMPLE		\
			      || (id) == DCC_ID_SRVR_REP_OK		\
			      || (id) == DCC_ID_SRVR_IGNORE		\
			      || (id) == DCC_ID_SRVR_ROGUE)
#define DCC_SRVR_ID_MIN	    100		/* below reserved for special uses */
#define	DCC_SRVR_ID_MAX	    32767	/* below are servers--must be 2**n-1 */
#define DCC_CLNT_ID_MIN	    (DCC_SRVR_ID_MAX+1)
#define DCC_CLNT_ID_MAX	    16777215
typedef u_int16_t DCC_SRVR_ID;
#define	DCC_SRVR_ID_AUTH (DCC_SRVR_ID_MAX+1)	/* client was authenticated */

/* client's identification of its transaction */
typedef u_int32_t DCC_OP_NUM;
typedef struct {
    DCC_OP_NUM	h;			/* client host ID, e.g. IP address */
    DCC_OP_NUM	p;			/* process ID, serial #, timestamp */
    DCC_OP_NUM	r;			/* report ID */
    DCC_OP_NUM	t;			/* client (re)transmission # */
} DCC_OP_NUMS;

/* The inter-DCC server flooding algorithm depends on unique-per-server
 * timestamps to detect duplicates.  That imposes a requirement on
 * timestamps that they have resolution enough to separate reports
 * from clients arriving at any single server.
 * The timestamps are 48 bits consisting of 17 bits of 8's of microseconds
 * and 31 bits of seconds.  That's sufficient for the UNIX epoch.
 * If the DCC is still around in the 2030's (and in the unlikely case that
 * 8 microseconds are still fine enough), we can make the 31 bits be
 * an offset in a bigger window.
 */
#define DCC_TS_US_RSHIFT    3
#define DCC_TS_US_MULT	    (1<<DCC_TS_US_RSHIFT)
#define DCC_TS_SECS_LSHIFT  17
#define DCC_TS_US_MASK	    ((1<<DCC_TS_SECS_LSHIFT) - 1)
typedef struct {
    u_char  b[6];
} DCC_TS;

/* The start of any DCC packet.
 *	The length and version are early, since they are the only fields
 *	constrained in future versions. */
typedef struct {
    u_int16_t	len;			/* total DCC packet length */
    u_char	pkt_vers;		/* packet protocol version */
    u_char	op;			/* one of DCC_OPS */
    /* Identify the transaction.
     *	    Each client can have many hosts, each host can be multi-homed,
     *	    and each host can be running many processes talking to the
     *	    server.  Each packet needs to be uniquely numbered, so that the
     *	    server can recognize as interchangable all of the (re)transmissions
     *	    of a single report (rid) from a client process (pid) on a single
     *	    host (hid), and the client can know which transmission (tid)
     *	    produced a given server response to maintain the client's RTT
     *	    value for the server. */
    DCC_CLNT_ID	sender;			/* client-ID or server-ID */
    DCC_OP_NUMS	op_nums;		/* op_num.t must be last */
} DCC_HDR;

typedef u_char DCC_SIGNATURE[16];

typedef struct {
    DCC_HDR	hdr;
    DCC_SIGNATURE signature;
} DCC_NOP;


/* DCC_OP_ADMN administrative requests from localhost
 *	Most of these can be changed, because the administrative tools
 *	should match the daemon. */
typedef enum {
    DCC_AOP_OK		=-1,		/* never really sent */
    DCC_AOP_STOP	= 1,		/* stop gracefully */
    DCC_AOP_DB_UNLOAD	= 2,		/* flush cache */
    DCC_AOP_FLOD	= 3,		/* start or stop flooding */
    DCC_AOP_DB_CLEAN	= 4,		/* start cleaning */
    DCC_AOP_DB_NEW	= 5,		/* finish switch to new database */
    DCC_AOP_STATS	= 6,		/* return counters--val=buffer size */
    DCC_AOP_STATS_CLEAR	= 7,		/* return and zero counters */
    DCC_AOP_TRACE_ON	= 8,
    DCC_AOP_TRACE_OFF	= 9,
    DCC_AOP_unused1	= 10,		/*	was dcc1-1-36 clients command */
    DCC_AOP_CLIENTS	= 11,		/* some client IP addresses */
    DCC_AOP_CLIENTS_ID	= 12,		/* some client IDs */
    DCC_AOP_ANON_DELAY	= 13,		/* anonymous delay parameters */
    DCC_AOP_CLOCK_CHECK	= 14
} DCC_AOPS;

/* for DCC_AOP_FLOD */
typedef enum {
    DCC_AOP_FLOD_CHECK=0,
    DCC_AOP_FLOD_SHUTDOWN,
    DCC_AOP_FLOD_HALT,
    DCC_AOP_FLOD_RESUME,
    DCC_AOP_FLOD_REWIND,
    DCC_AOP_FLOD_LIST,
    DCC_AOP_FLOD_STATS,
    DCC_AOP_FLOD_STATS_CLEAR,
#    define DCC_AOP_FLOD_STATS_ID   " server-ID %u "
    DCC_AOP_FLOD_FFWD_IN,
    DCC_AOP_FLOD_FFWD_OUT
} DCC_AOP_FLODS;

typedef struct {			/* with operation DCC_OP_ADMN */
    DCC_HDR	hdr;
    int32_t	date;			/* seconds since epoch on caller */
    u_int32_t	val1;			/* request type, buffer size, etc. */
    u_char	aop;			/* one of DCC_AOPS */
    u_char	val2;
    u_char	val3;
    u_char	val4;
#    define	 MAX_DCC_ADMN_REQ_VAL5	64
    u_char	val5[MAX_DCC_ADMN_REQ_VAL5];
    DCC_SIGNATURE signature;
} DCC_ADMN_REQ;
#define DCC_ADMN_REQ_MIN_SIZE (ISZ(DCC_ADMN_REQ) - MAX_DCC_ADMN_REQ_VAL5)


typedef u_char DCC_AOP_CLIENTS_CIDR[17];    /* IPv6 netmask and length */

/* val2 for DCC_AOP_CLIENTS or DCC_AOP_CLIENTS_ID */
#define DCC_AOP_CLIENTS_AVG		0x01	/* want averages */
#define DCC_AOP_CLIENTS_VERS		0x02	/* want protocol version */
#define DCC_AOP_CLIENTS_ANON		0x04	/* only anonymous clients */
#define DCC_AOP_CLIENTS_NON_ANON	0x08	/* non-anonymous only */

#define DCC_AOP_CLIENTS_MAX_OFFSET	((1<<24)-1)

/* scale client's response buffer size in part of val1 by this */
#define DCC_ADMIN_RESP_CLIENTS_SHIFT	5
/* limit threshold in part of val1 */
#define DCC_ADMIN_RESP_CLIENTS_MAX_THOLD    ((1<<16)-1)

/* noisy response to DCC_AOP_CLIENTS or DCC_AOP_CLIENTS_ID */
#define	DCC_ADMN_RESP_CLIENTS_BL	0x01	/* this client blacklisted */
#define	DCC_ADMN_RESP_CLIENTS_IPV6	0x02	/* address is IPv6 */
#define	DCC_ADMN_RESP_CLIENTS_SKIP	0x04	/* last_used=clients skipped */
#define	DCC_ADMN_RESP_CLIENTS_ID1	0x08	/* suppressed ID=DCC_ID_ANON */
#define DCC_ADMN_RESP_CLIENTS_VERS	0x10	/* protocol version # present */
#define DCC_ADMN_RESP_CLIENTS_LAST	0x20
#define DCC_ADMN_RESP_CLIENTS_BAD	0x40	/* naughty client */

/* worst case bytes used to describe a client */
#define DCC_ADMN_RESP_CLIENTS_MAX_SIZE	(1+1+4*4+16)

#define DCC_ADMIN_RESP_MAX_CLIENTS	(10*1000)


#ifdef DCC_PKT_VERSION6
typedef struct {
    u_char	clnt_id[4];
    u_char	last_used[4];
    u_char	requests[3];
    u_char	nops[2];
    u_char	flags;
    union {
	u_char	ipv6[16];
	u_char	ipv4[4];
    } addr;
} DCC_ADMN_RESP_CLIENTSv6;
#endif /* DCC_PKT_VERSION6 */

typedef struct {
    u_char	inflate[4];
    u_char	delay[2];
#    define	 DCC_ANON_DELAY_MAX	DCC_MAX_RTT
#    define	 DCC_ANON_DELAY_FOREVER	((u_int16_t)-1)
#    define	 DCC_NO_ANON_DELAY	((u_int16_t)-2)
} DCC_ADMN_RESP_ANON_DELAY;
typedef union {
    char	string[80*22];
    u_char	clients[1];
#ifdef DCC_PKT_VERSION6
    DCC_ADMN_RESP_CLIENTSv6 clientsV6[1];
#endif
    DCC_ADMN_RESP_ANON_DELAY anon_delay;
} DCC_ADMN_RESP_VAL;
typedef struct {
    DCC_HDR	hdr;
    DCC_ADMN_RESP_VAL val;
    DCC_SIGNATURE signature;
} DCC_ADMN_RESP;


#define DCC_TRACE_ADMN_BIT  0x0001	/* administrative requests */
#define DCC_TRACE_ANON_BIT  0x0002	/* anonymous client errors */
#define DCC_TRACE_CLNT_BIT  0x0004	/* authenticated client errors */
#define DCC_TRACE_RLIM_BIT  0x0008	/* rate limited messages */
#define DCC_TRACE_QUERY_BIT 0x0010	/* all queries and reports */
#define DCC_TRACE_RIDC_BIT  0x0020	/* RID cache messages */
#define DCC_TRACE_FLOD_BIT  0x0040	/* general inter-server flooding */
#define DCC_TRACE_FLOD2_BIT 0x0080	/* individual flooded reports */
#define DCC_TRACE_IDS_BIT   0x0100	/* monitor client- and server-IDs */
#define DCC_TRACE_BL_BIT    0x0200	/* blacklisted clients */
#define DCC_TRACE_DB_BIT    0x0400	/* odd database events */
#define DCC_TRACE_WLIST_BIT 0x0800	/* whitelisted checksums */
#define DCC_TRACE_BITS  (DCC_TRACE_ADMN_BIT | DCC_TRACE_ANON_BIT	\
			 | DCC_TRACE_CLNT_BIT | DCC_TRACE_RLIM_BIT	\
			 | DCC_TRACE_QUERY_BIT | DCC_TRACE_RIDC_BIT	\
			 | DCC_TRACE_FLOD_BIT | DCC_TRACE_FLOD2_BIT	\
			 | DCC_TRACE_IDS_BIT | DCC_TRACE_BL_BIT		\
			 | DCC_TRACE_DB_BIT | DCC_TRACE_WLIST_BIT)
#define DCC_TRACE_ON_DEF_BITS (DCC_TRACE_ANON_BIT | DCC_TRACE_CLNT_BIT)
#define DCC_TRACE_OFF_DEF_BITS (DCC_TRACE_BITS				\
				& ~(DCC_TRACE_ANON_BIT | DCC_TRACE_CLNT_BIT))


#define DCC_BRAND_MAXLEN 64
typedef char DCC_BRAND[DCC_BRAND_MAXLEN];

/* administrative or NOP ok */
typedef struct {
    DCC_HDR	hdr;
    u_char	max_pkt_vers;		/* server can handle this version */
    u_char	unused;
    u_int16_t	qdelay_ms;
    DCC_BRAND	brand;			/* identity or brandname of sender */
    DCC_SIGNATURE signature;
} DCC_OK;


typedef u_int32_t DCC_TGTS;		/* database is limited to 24 bits */
#define	DCC_TGTS_TOO_MANY   0x00fffff0	/* >= 16777200 targets */
#define	DCC_TGTS_OK	    0x00fffff1	/* certified not spam */
#define	DCC_TGTS_OK2	    0x00fffff2	/* half certified not spam */
#define DCC_TGTS_GREY_WHITE DCC_TGTS_OK2    /* whitelisted for greylisting */
#define	DCC_TGTS_DEL	    0x00fffff3	/* a deleted checksum */
#define DCC_TGTS_REP_ADJ    0x00fffff4	/* scale a reputation */
#define DCC_TGTS_OK_MX	    0x00fffff5	/* partly whitelist MX secondary */
#define DCC_TGTS_OK_MXDCC   0x00fffff6	/*	MX secondary with DCC client */
#define DCC_TGTS_SUBMIT_CLIENT 0x00fffff7   /* SMTP submission client */
#define DCC_TGTS_MAX_DB	    DCC_TGTS_REP_ADJ
#define DCC_TGTS_INVALID    0x01000000
#define DCC_TGTS_SPAM	    DCC_TGTS_INVALID
#define DCC_TGTS_REP_SPAM   0x02000000	/* reputation hit */
#define DCC_TGTS_MASK	    0x00ffffff

#define DCC_TGTS_RPT_MAX    2000
#define DCC_TGTS_FLOD_RPT_MAX (DCC_TGTS_RPT_MAX*1000)
#define BULK_THRESHOLD	    10
#define	REFLOOD_THRESHOLD   300
#define DCC_TGTS_REP_TOTAL_THOLD (BULK_THRESHOLD*2)
#define DCC_TGTS_REP_TOTAL_EXPIRE BULK_THRESHOLD

/* checksums kept by most servers */
#define DCC_CK_IS_GREY_BODY(g,t) ((g) ? ((t)==DCC_CK_BODY) : DCC_CK_IS_BODY(t))
#define DB_GLOBAL_NOKEEP(g,t) (!DCC_CK_IS_GREY_BODY(g,t)		\
			       && (t) != DCC_CK_SRVR_ID			\
			       && ((t) != DCC_CK_G_MSG_R_TOTAL || !(g))	\
			       && ((t) != DCC_CK_G_TRIPLE_R_BULK || !(g)))

/* checksums subject to thresholds */
#define DCC_CK_THOLD_OK(t)  ((t) > DCC_CK_INVALID			\
			     && (t) <= DCC_CK_G_TRIPLE_R_BULK)

#define IS_ALL_CKSUM(t)	(DCC_CK_THOLD_OK(t) && !DCC_CK_IS_REP_CMN(0, t))
#define IS_CMN_CKSUM(t)	DCC_CK_IS_BODY(t)


/* a reported checksum from a client */
typedef u_char DCC_SUM[16];		/* for now all have 16 bytes */
typedef struct {
    DCC_CK_TYPE_B type;
    u_char	len;			/* total length of this checksum */
    DCC_SUM	sum;
} DCC_CK;

/* most packets from client to server */
typedef struct {
    DCC_HDR	hdr;
    DCC_TGTS	tgts;			/* # of addressees */
    DCC_CK	cks[DCC_QUERY_MAX];	/* even to prevent structure padding */
    DCC_SIGNATURE signature;
} DCC_REPORT;

/* most responses */
typedef struct {
    DCC_TGTS	c;			/* current value, with this report */
    DCC_TGTS	p;			/* previous value, before this report */
} DCC_ANSWER_BODY_CKS;
typedef struct {
    DCC_HDR	hdr;
    DCC_ANSWER_BODY_CKS b[DCC_QUERY_MAX];
    DCC_SIGNATURE signature;
} DCC_ANSWER;

#ifdef DCC_PKT_VERSION5
typedef struct {
    DCC_HDR	hdr;
    DCC_TGTS	b[DCC_QUERY_MAX];	/* current values */
    DCC_SIGNATURE signature;
} DCC_ANSWERv5;
#endif

typedef struct {
    DCC_HDR	hdr;
    DCC_TGTS	msg;
    DCC_TGTS	triple;
    DCC_SIGNATURE signature;
} DCC_GREY_ANSWER;


/* DCC_OP_DELETE request to delete checksums */
typedef struct {
    DCC_HDR	hdr;
    int32_t	date;			/* seconds since epoch on client */
    DCC_CK	ck;
    u_char	pad[2];
    DCC_SIGNATURE signature;
} DCC_DELETE;


/* DCC_OP_GREY_SPAM restore greylist embargo */
typedef struct {
    DCC_HDR	hdr;
    DCC_CK	ip;
    DCC_CK	msg;
    DCC_CK	triple;
    DCC_SIGNATURE signature;
} DCC_GREY_SPAM;


/* error response from server to client */
typedef struct {
    DCC_HDR	hdr;
#    define	 DCC_ERROR_MSG_LEN  128
    char	msg[DCC_ERROR_MSG_LEN];
    DCC_SIGNATURE signature;
} DCC_ERROR;


typedef union {
    DCC_HDR	hdr;
    DCC_ANSWER	ans;
#ifdef DCC_PKT_VERSION5
    DCC_ANSWERv5 ans5;
#endif
    DCC_GREY_ANSWER gans;
    DCC_OK	ok;
    DCC_ERROR	error;
    DCC_ADMN_RESP resp;
    int		w[6];
} DCC_OP_RESP;




/* ************** server-to-server flooding protocol ************ */

/* This protocol is the sort of botch of a mess that results from assuming
 * a considered protocol is not necessary and then extending it. */

/* A flooding connection starts with the TCP client or connection originator
 * sending an ASCII "magic" string including a version number, the connection
 * originator's server-ID, whether SOCKS is involved, and a cryptographic
 * hash of the fixed-length message.  In the common case, the connection
 * orginator will send a flood of DCC reports.  If SOCKS is involved, the
 * connection is immediately turned around. */
#define DCC_FLOD_VERSION_STR_BASE	"DCC flod version "
#define DCC_FLOD_VERSION7		7
/* in the next version, add a length to DCC_FLOD_END */
#define DCC_FLOD_VERSION7_STR		DCC_FLOD_VERSION_STR_BASE"7"
#define DCC_FLOD_VERSION_DEF		0
#define DCC_FLOD_VERSION_CUR		DCC_FLOD_VERSION7
#define DCC_FLOD_VERSION_CUR_STR	DCC_FLOD_VERSION7_STR
typedef struct {
#    define DCC_FLOD_VERSION_STR_LEN 64
    char	str[DCC_FLOD_VERSION_STR_LEN];
    u_char	sender_srvr_id[sizeof(DCC_SRVR_ID)];
    u_char	turn;			/* 1=turn connection around for SOCKS */
    u_char	unused[3];
} DCC_FLOD_VERSION_BODY;
typedef struct {
    DCC_FLOD_VERSION_BODY body;
    char	pad[256-sizeof(DCC_FLOD_VERSION_BODY)-sizeof(DCC_SIGNATURE)];
    DCC_SIGNATURE signature;
} DCC_FLOD_VERSION_HDR;


/* flood sender's position or serial number
 *	Only the sender understands sender positions except for these
 *	special values.  However, the special values imply that the position
 *	must be big endian. */
typedef u_char DCC_FLOD_POS[8];
/* special cases sent by the receiver back to the sender */
typedef enum {
    DCC_FLOD_POS_END	    =0,		/* receiver closing with message */
    DCC_FLOD_POS_END_REQ    =1,		/* receiver wants to stop */
    DCC_FLOD_POS_NOTE	    =2,		/* receiver has a tracing message */
    DCC_FLOD_POS_COMPLAINT  =3,		/* receiver has a problem message */
    DCC_FLOD_POS_REWIND	    =4,		/* receiver's database emptied */
    DCC_FLOD_POS_FFWD_IN    =5		/* receiver wants fast-forward */
} DCC_FLOD_POS_OPS;
#define DCC_FLOD_POS_MIN    10

#define DCC_FLOD_OK_STR	    "DCC flod ok: "

/* final result sent from flood receiver to flood sender
 *	This structure always ends the TCP stream.  The length of the msg is
 *	obtain from the number of buts to the end of the stream.  It should
 *	have had an explicit length in the structure.  */
typedef struct {
    DCC_FLOD_POS pos;			/* one of DCC_FLOD_POS_* */
#    define DCC_FLOD_MAX_RESP   200
    char	msg[DCC_FLOD_MAX_RESP];	/* no '\0'; uses length to EOF */
} DCC_FLOD_END;
#define FLOD_END_OVHD ISZ(((DCC_FLOD_END*)0)->pos)

/* report forwarded among servers */
typedef struct {
    DCC_FLOD_POS pos;
    u_char	tgts[sizeof(DCC_TGTS)];
    u_char	srvr_id_auth[sizeof(DCC_SRVR_ID)];  /* receiving server */
    DCC_TS	ts;			/* date reported */
    u_char	num_cks;
    DCC_CK	cks[DCC_QUERY_MAX];
} DCC_FLOD_RPT;
#define DCC_FLOD_RPT_LEN(n) (ISZ(DCC_FLOD_RPT) - ISZ(DCC_CK)*DCC_QUERY_MAX  \
			     + ISZ(DCC_CK)*(n))

/* what can appear in the stream of flooded reports */
typedef union {
    DCC_FLOD_VERSION_HDR v;
    DCC_FLOD_END    e;
    DCC_FLOD_RPT    r;
} DCC_FLOD_STREAM;


/* a response to flooded reports */
typedef union {
    DCC_FLOD_POS    pos;
    DCC_FLOD_END    end;		/* final result */
    struct {
	DCC_FLOD_POS    op;		/* one of DCC_FLOD_POS_* */
	u_char		len;		/* total length */
	char		str[DCC_FLOD_MAX_RESP]; /* includes trailing '\0' */
    } note;
} DCC_FLOD_RESP;
#define FLOD_NOTE_OVHD (ISZ(((DCC_FLOD_RESP*)0)->note) - DCC_FLOD_MAX_RESP)


/* parts of error messages sent between flooding peers */
#define DCC_FLOD_BAD_VER_MSG	"unrecognized flod version"
#define DCC_FLOD_BAD_ID_MSG	"unauthorized ID"
#define DCC_FLOD_BAD_AUTH_MSG	"bad authentication for ID"
#define DCC_FLOD_PASSWD_ID_MSG	"unknown passwd-ID"


#endif /* DCC_PROTO_H	*/