netsukuku/src/request.h

/* This file is part of Netsukuku
 * (c) Copyright 2005 Andrea Lo Pumo aka AlpT <alpt@freaknet.org>
 *
 * This source code is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as published 
 * by the Free Software Foundation; either version 2 of the License,
 * or (at your option) any later version.
 *
 * This source code is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * Please refer to the GNU Public License for more details.
 *
 * You should have received a copy of the GNU Public License along with
 * this source code; if not, write to:
 * Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#ifndef REQUEST_H
#define REQUEST_H

#include "misc.h"

#define REQUEST_TIMEOUT		300	/* The timeout in seconds for all the 
								   requests */
#ifdef DEBUG
#undef REQUEST_TIMEOUT
#define REQUEST_TIMEOUT		20
#endif

/*
 * In this enum there are all the requests/replies op used by netsukuku 
 */
enum pkt_op {
	ECHO_ME,					/*The node requests to be echoed by the dst_node */
	ECHO_REPLY,					/*Yep, this isn't really a reply */
	GET_FREE_NODES,				/*it means: <<Get the list of free ips in your gnode, plz>> */
	GET_QSPN_ROUND,				/*<<Yo, Gimme the qspn ids and qspn times>> */

	GET_INTERNET_GWS,			/*Get Internet Gateways */
	SET_FOREIGN_ROUTE,			/* Set the route in the foreign groupnode */
	DEL_FOREIGN_ROUTE,
	NEW_BACKROUTE,				/*Tells the dst_node to use a different route to reply */
	DELAYED_BROADCAST,			/*Broadcast packet to be spread only in the dst groupnode */
	SPLIT_ROUTE,				/*This pkt advices the src_node to split the socket in two route */
	SET_NO_IDENTITY,			/*Pkt that specify to the last node in the route to change 
								   the src ip of the future incoming pkts */

	QSPN_CLOSE,					/*The qspn_pkt used to trace the entire g_node */
	QSPN_OPEN,					/*The qspn_pkt sent by the extreme nodes */
	QSPN_RFR,					/*RequestForRoute: This is used to get additional routes */
	GET_DNODEBLOCK,				/* Not used. */
	GET_DNODEIP,				/* Not used. */
	TRACER_PKT,					/*A tracer pkt. This pkt is used mainly to send only a tracer pkt.
								   Normally a bcast pkt is marked with the BCAST_TRACER_PKT flag. */
	TRACER_PKT_CONNECT,			/*This is the tracer_pkt used to connect to the dst_node.
								   In the first entry of the tcr_pkt there's the src node, in the
								   second the dst_node, the remaining are as usual */

	DEL_SNODE,					/* Not used. */
	DEL_GNODE,					/* Not used. */

	GET_INT_MAP,
	GET_EXT_MAP,
	GET_BNODE_MAP,

	ANDNA_REGISTER_HNAME,
	ANDNA_CHECK_COUNTER,		/* Check request for the counter node */
	ANDNA_RESOLVE_HNAME,
	ANDNA_RESOLVE_IP,
	ANDNA_RESOLVE_MX,
	ANDNA_GET_ANDNA_CACHE,
	ANDNA_GET_SINGLE_ACACHE,
	ANDNA_SPREAD_SACACHE,		/* Spread single andna_cache */
	ANDNA_GET_COUNT_CACHE,

	/*  *  *  Replies  *  *  */
	PUT_FREE_NODES,				/*it means: "Here it is the list of free ips in your gnode, cya" */
	PUT_QSPN_ROUND,
	PUT_INTERNET_GWS,
	PUT_DNODEIP,
	EMPTY_REPLY_SLOT,
	EMPTY_REPLY_SLOT1,
	PUT_INT_MAP,
	PUT_EXT_MAP,
	PUT_BNODE_MAP,
	ANDNA_RESOLVE_REPLY,
	ANDNA_REV_RESOLVE_REPLY,
	ANDNA_MX_RESOLVE_REPLY,
	ANDNA_PUT_COUNT_CACHE,
	ANDNA_PUT_ANDNA_CACHE,

	/*Acks */
	ACK_AFFERMATIVE,			/*Ack affermative. Everything is fine. */
	ACK_NEGATIVE				/*The request is rejected. The error is in the pkt's body. */
};

/*
 * WARNING* Keep it up to date!! *WARNING *
 */
#define TOTAL_OPS		(ACK_NEGATIVE+1)
#define TOTAL_REQUESTS          (ANDNA_GET_COUNT_CACHE+1)
#define TOTAL_REPLIES		(TOTAL_OPS-TOTAL_REQUESTS)

enum errors {
	/*Request errors */
	E_INVALID_REQUEST,
	E_ACCEPT_TBL_FULL,
	E_REQUEST_TBL_FULL,
	E_QGROUP_FULL,
	E_NTK_FULL,
	E_INVALID_SIGNATURE,
	E_CANNOT_FORWARD,

	E_ANDNA_WRONG_HASH_GNODE,
	E_ANDNA_QUEUE_FULL,
	E_ANDNA_UPDATE_TOO_EARLY,
	E_ANDNA_TOO_MANY_HNAME,
	E_ANDNA_HUPDATE_MISMATCH,
	E_ANDNA_NO_HNAME,
	E_ANDNA_CHECK_COUNTER,

	E_TOO_MANY_CONN
};
#define TOTAL_ERRORS		(E_TOO_MANY_CONN+1)

/* 
 * Request_table: It prevents requests flood and it is used in each connection.
 * Each element of the "rq" array corresponds to a request; it (the element)
 * keeps the number of requests served. If this number is equal
 * to [REQUEST]_MAXRQ, the maximum of simultaneous requests is reached.
 * 
 * Each element in rq_wait corresponds to a single request so it is formed by:
 * { [REQUEST 0]_MAXRQ elements | [REQUEST 1]_MAXRQ elements | ... };
 * rq_wait_idx keeps track of this but it must be initialized once with
 * rq_wait_idx_init().
 * Each element of rq_wait keeps the time when that request arrived. 
 * When the current time is >= [REQUEST]_WAIT+rq_wait, a new request is 
 * available and the corresponding request counter in "rq" is decremented. 
 */

#define TOTAL_MAXRQ	31
struct request_tbl {
	u_char rq[TOTAL_REQUESTS];
	time_t rq_wait[TOTAL_MAXRQ];
};
typedef struct request_tbl rq_tbl;

int rq_wait_idx[TOTAL_REQUESTS];

int update_rq_tbl_mutex;

/* 
 * Each bit of this array corresponds to a request or a reply. If the bit is 
 * set, the request or reply will be dropped, otherwise it will be executed by
 * pkts.c/pkt_exec().
 */
char filtered_op[TOTAL_OPS >> 3];
#define OP_FILTER_DROP		1
#define OP_FILTER_ALLOW		0
#define op_filter_set(op)	SET_BIT(filtered_op, (op))
#define op_filter_clr(op)	CLR_BIT(filtered_op, (op))
#define op_filter_test(op)	TEST_BIT(filtered_op, (op))
#define op_filter_reset(bit)	memset(filtered_op, (bit), sizeof(filtered_op))


/* 
 * Functions declaration starts here
 */
void rq_wait_idx_init(int *rq_wait_idx);
const u_char *rq_strerror(int err);
#define re_strerror(err) (rq_strerror((err)))
const u_char *re_to_str(u_char re);
const u_char *rq_to_str(u_char rq);
int op_verify(u_char);
int rq_verify(u_char);
int re_verify(u_char);
void update_rq_tbl(rq_tbl *);
int is_rq_full(u_char, rq_tbl *);
int find_free_rq_wait(u_char, rq_tbl *);
int add_rq(u_char, rq_tbl *);

void op_filter_reset_re(int bit);
void op_filter_reset_rq(int bit);

#endif							/*REQUEST_H */