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 */