netsukuku/src/radar.h

/* This file is part of Netsukuku
 * (c) Copyright 2004 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 RADAR_H
#define RADAR_H

#define MAX_RADAR_SCANS		16
#define MAX_RADAR_WAIT		5	/*How much we wait to store the received
					  ECHO_REPLY pkts and then to close the
					  current radar session*/
#define RTT_DELTA		1000	/*If the change delta of the new rtt is
					  >= RTT_DELTA, the qspn_q.send_qspn 
					  will be set. (It's in millisec)*/

#ifdef DEBUG		
#undef MAX_RADAR_WAIT
#define MAX_RADAR_WAIT          3
#endif

int max_radar_wait;
int radar_wait_counter;			/* During the scan, it is incremented 
					   every 500 ms */

int radar_scans[MAX_INTERFACES];	/* How many ECHO_ME pkts we sent on 
					   each interface */
int total_radar_scans;			/* The sum of all the values of the 
					   `radar_scans' array */
int radar_scan_mutex;			/* A flag to see if we are already 
					   doing a scan */
int my_echo_id;			
u_char send_qspn_now[MAX_LEVELS];	/* Shall we send the qspn in level? 
					   If yes send_qspn_now[level] is 
					   != 0*/
int hook_retry;				/* If we've seen, while hooking, a 
					   node who was trying to hook before 
					   us, `hook_retry' is set to 1.*/
int radar_daemon_ctl;			/* If it is set to 0 the radar_daemon 
					   will stop until it becomes again 1*/
int total_radars;			/* Stupid statistic */

#define RADQ_VOID_RNODE		0
#define RADQ_EXT_RNODE		1

struct radar_queue
{
	LLIST_HDR	(struct radar_queue);

	inet_prefix	ip;			/*Node's ip*/
	interface	*dev[MAX_INTERFACES];	/*The pointers to the interface structs, present 
						  in me.cur_ifs, of the device where we got the 
						  node's pongs */
	int		dev_n;			/* Number of devices */
	
	map_node       *node;			/*The node we are pinging*/
	quadro_group	quadg;			/*Node's data for the ext_map*/
	u_short		flags;
				
	char 		pings;			/*The total ECHO_ME pkts received from this node*/
	char 		pongs;			/*The total pongs (ECHO_REPLY) received from this node*/
	struct timeval 	rtt[MAX_RADAR_SCANS];	/*The round rtt of each pong*/
	struct timeval 	final_rtt;		/*When all the rtt is filled, or when MAX_RADAR_WAIT
						  is expired, final_rtt will keep the average of all
						  the rtts */
};
struct radar_queue *radar_q;	/*the start of the linked list of radar_queue*/
int radar_q_counter;

struct timeval scan_start;	/*the start of the scan*/

/*
 * rnode_list keeps the list of all the rnodes. It is used to know on what
 * interface can be reached a wanted rnode.
 */
struct rnode_list
{
	LLIST_HDR	(struct rnode_list);

	map_node	*node;			/* The node which is pointed by this 
						   rnode */
	interface       *dev[MAX_INTERFACES];	/* The pointers to the interface structs
						   (in me.cur_ifs), which cointains the
						   devices which links ourself with this rnode. */
	int		dev_n;

	int		tcp_sk;			/* The direct tcp connection to this rnode uses
						   this socket. */
};
struct rnode_list *rlist;
int rlist_counter;

/*
 * When this list isn't empty, the radar will receive only the ECHO_REPLY sent
 * from rnodes which are in the allowed_rnode list.
 */
struct allowed_rnode
{
	LLIST_HDR	(struct allowed_rnode);
	
	/* 
	 * In order to see if the rnode X is part of this list we compare all
	 * its gids in the range of gids[min_level] and gids[tot_level-1] with
	 * the allowed_rnode.gid array.
	 */
	u_char 		min_level;
	u_char		tot_level;
	u_int		gid[MAX_LEVELS];
};
struct allowed_rnode *alwd_rnodes;
int alwd_rnodes_counter;

/* 
 * The ECHO_ME pkt:
 * It is just a normal pkt which contains in the body (pkt.msg) one 
 * u_char echo_scans_count, var. This is the number of scans sent.
 */

/*
 * During the hooking the ECHO_REPLY body pkt is one u_char which is set to 0
 * if we already finished our scans.
 */

/* * * Functions declaration * * */
void first_init_radar(void);
void last_close_radar(void);
void init_radar(void);
void close_radar(void);
void reset_radar(void);
void free_new_node(void);

struct radar_queue *find_node_radar_q(map_node *node);
struct radar_queue *find_ip_radar_q(inet_prefix *ip);
int count_hooking_nodes(void);

void rnl_reset(struct rnode_list **rnlist, int *rnlist_counter);
interface **rnl_get_dev(struct rnode_list *rnlist, map_node *node);
interface *rnl_get_rand_dev(struct rnode_list *rnlist, map_node *node);
int rnl_get_sk(struct rnode_list *rnlist, map_node *node);
void rnl_close_all_sk(struct rnode_list *rnlist);
int rnl_fill_rq(map_node *rnode, PACKET *pkt);
int rnl_send_rq(map_node *rnode, 
		PACKET *pkt, int pkt_flags, u_char rq, int rq_id, u_char re, 
		int check_ack, PACKET *rpkt);

void new_rnode_allowed(struct allowed_rnode **alr, int *alr_counter,
		int *gid, int min_lvl, int max_lvl);
void reset_rnode_allowed(struct allowed_rnode **alr, int *alr_counter);

void final_radar_queue(void);
void radar_update_map(void);

struct radar_queue *add_radar_q(PACKET pkt);
int radar_exec_reply(PACKET pkt);
int radar_scan(int activate_qspn);
int radard(PACKET rpkt);
int radar_recv_reply(PACKET pkt);
void *radar_daemon(void *null);
void radar_wait_new_scan(void);

int refresh_hook_root_node(void);

#endif /*RADAR_H*/