netsukuku/src/radar.c

/* 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.
 *
 * --
 *  
 * radar.c
 * 
 * The radar sends in broadcast a bouquet of MAX_RADAR_SCANS# packets and waits
 * for the ECHO_REPLY of the nodes which are alive. It then recollects the
 * replies and builds a small statistic, updates, if necessary, the internal 
 * maps, the bnode maps and the qspn buffer.
 * A radar is fired periodically by the radar_daemon(), which is started as a
 * thread.
 */

#include "includes.h"

#include "llist.c"
#include "endianness.h"
#include "if.h"
#include "bmap.h"
#include "route.h"
#include "request.h"
#include "pkts.h"
#include "qspn.h"
#include "radar.h"
#include "netsukuku.h"
#include "common.h"

pthread_attr_t radar_qspn_send_t_attr;

void first_init_radar(void)
{
	max_radar_wait=MAX_RADAR_WAIT;	

	pthread_attr_init(&radar_qspn_send_t_attr);
	pthread_attr_setdetachstate(&radar_qspn_send_t_attr, PTHREAD_CREATE_DETACHED);	 
	
	/* register the radar's ops in the pkt_op_table */
	add_pkt_op(ECHO_ME, SKT_BCAST, ntk_udp_radar_port, radard);
	add_pkt_op(ECHO_REPLY, SKT_UDP, ntk_udp_radar_port, radar_recv_reply);
	
	rlist=(struct rnode_list *)clist_init(&rlist_counter);
	alwd_rnodes=(struct allowed_rnode *)clist_init(&alwd_rnodes_counter);

	radar_daemon_ctl=0;
	init_radar();
}

void last_close_radar(void)
{
	close_radar();
	rnl_reset(&rlist, &rlist_counter);
}

void init_radar(void)
{
	hook_retry=0;
	my_echo_id=0;
	total_radar_scans=0;
	setzero(radar_scans, sizeof(radar_scans));
	radar_scan_mutex=0;
	
	radar_q=(struct radar_queue *)clist_init(&radar_q_counter);
	
	setzero(send_qspn_now, sizeof(u_char)*MAX_LEVELS);
}


void close_radar(void)
{
	if(radar_q_counter)
		clist_destroy(&radar_q, &radar_q_counter);
}

void reset_radar(void)
{
	if(me.cur_node->flags & MAP_HNODE) {
		free_new_node();
		rnl_reset(&rlist, &rlist_counter);
	}
	
	close_radar();
	init_radar();
}

/*
 * free_new_node
 * 
 * frees all the temporary alloced rq->node structs used at the
 * hook time.
 */
void free_new_node(void)
{
	struct radar_queue *rq;

	rq=radar_q;
	list_for(rq)
		if(rq->node && ((int)rq->node != RADQ_EXT_RNODE)) {
			xfree(rq->node);
			rq->node=0;
		}
}

/*
 * find_node_radar_q
 * 
 * returns the first radar_queue struct which has the 
 * rq->node pointer equal to `node'.
 */
struct radar_queue *find_node_radar_q(map_node *node)
{
	struct radar_queue *rq;

	rq=radar_q;
	list_for(rq)
		if(rq->node==node)
			return rq;
	return 0;
}

/*
 * find_ip_radar_q
 * 
 * returns the first radar_queue struct which has the rq->ip
 * member equal to the given `ip'.
 */
struct radar_queue *find_ip_radar_q(inet_prefix *ip)
{
	struct radar_queue *rq;

	rq=radar_q;
	list_for(rq)
		if(!memcmp(rq->ip.data, ip->data, MAX_IP_SZ))
			return rq;
		
	return 0;
}

/*
 * rnl_add
 * 
 * adds a new rnode_list struct in the `*rnlist' list. The new
 * allocated struct will be filled respectively with `rnode' and `dev'.
 * It returns the added `rnode_list' struct.
 */
struct rnode_list *rnl_add(struct rnode_list **rnlist, int *rnlist_counter, 
		map_node *rnode, interface *dev)
{
	struct rnode_list *rnl;

	rnl	       = xzalloc(sizeof(struct rnode_list));
	rnl->node      = (map_node *)rnode;
	rnl->dev[0]    = dev;
	rnl->dev_n++;

	clist_add(rnlist, rnlist_counter, rnl);
	
	return rnl;
}

/*
 * rnl_del
 * 
 * deletes the `rnl' struct from the `rnlist' rnode_list.
 * If `close_socket' is not zero, `rnl'->tcp_sk will be closed.
 */
void rnl_del(struct rnode_list **rnlist, int *rnlist_counter, 
		struct rnode_list *rnl, int close_socket)
{
	if(rnl) {
		if(close_socket && rnl->tcp_sk)
			inet_close(&rnl->tcp_sk);
		clist_del(rnlist, rnlist_counter, rnl);
	}
	if(!(*rnlist_counter))
		*rnlist=0;
}

/*
 * rnl_reset
 * 
 * reset the whole rnode_list
 */
void rnl_reset(struct rnode_list **rnlist, int *rnlist_counter)
{
	struct rnode_list *rnl=*rnlist, *next;

	list_safe_for(rnl, next)
		rnl_del(rnlist, rnlist_counter, rnl, 1);
	*rnlist=(struct rnode_list *)clist_init(rnlist_counter);
}


/*
 * rnl_del_dead_rnode
 * 
 * it removes all the rnode_list structs which are related
 * to a rnode which doesn't exist anymore in `root_node'
 * It returns the number of delete rnodes_list structs.
 */
int rnl_del_dead_rnode(struct rnode_list **rnlist, int *rnlist_counter, 
			map_node *root_node)
{
	struct rnode_list *rnl=*rnlist, *next;
	int i=0;
	
	list_safe_for(rnl, next)
		if(rnode_find(root_node, rnl->node) < 0) {
			rnl_del(rnlist, rnlist_counter, rnl, 1);
			i++;
		}

	return i;
}

/*
 * rnl_find_rpos
 * 
 * returns the first rnode_list struct, contained in
 * `rnlist', which has rnl->node equal to `node'.
 */
struct rnode_list *rnl_find_node(struct rnode_list *rnlist, map_node *node)
{
	struct rnode_list *rnl=rnlist;

	list_for(rnl)
		if(rnl->node == node)
			return rnl;

	return 0;
}

/*
 * rnl_add_dev
 * 
 * If `rnl' is 0 a new struct is added in `*rnlist' using `node'.
 * In both cases the `new_dev' is added in the rnl->dev[] array of
 * pointers (if it isn't already present there) and rnl->dev_n is
 * incremented.
 * On error -1 is returned.
 */
int rnl_add_dev(struct rnode_list **rnlist, int *rnlist_counter,
		struct rnode_list *rnl, map_node *node, interface *new_dev)
{
	int i;

	if(!rnl) {
		rnl=rnl_add(rnlist, rnlist_counter, node, new_dev);
		return 0;
	}

	if(rnl->dev_n >= MAX_INTERFACES)
		return -1;
	
	for(i=0; i<rnl->dev_n; i++)
		if(rnl->dev[i] == new_dev)
			return 0;

	rnl->dev[rnl->dev_n++]=new_dev;

	return 0;
}

/*
 * rnl_del_dev
 * 
 * It searches a pointer in the rnl->dev[] array equal to
 * `del_dev'. If it is found, it is set to 0 and rnl->dev_n is decremented,
 * otherwise 0 is returned.
 * If rnlist->dev_n is 0, the found rnlist struct is deleted from the llist.
 * On error -1 is returned.
 */
int rnl_del_dev(struct rnode_list **rnlist, int *rnlist_counter,
		struct rnode_list *rnl, interface *del_dev)
{
	int i;

	if(!rnl) 
		return 0;

	if(rnl->dev_n <= 0)
		return -1;
	
	for(i=0; i<rnl->dev_n; i++) {
		if(rnl->dev[i] == del_dev) {
			if(i == rnl->dev_n-1)
				rnl->dev[i]=0;
			else {
				rnl->dev[i]=rnl->dev[rnl->dev_n-1];
				rnl->dev[rnl->dev_n-1]=0;
			}
			rnl->dev_n--;
			break;
		}
	}

	if(!rnl->dev_n)
		rnl_del(rnlist, rnlist_counter, rnl, 1);
	
	return 0;
}

/*
 * rnl_update_devs
 * 
 * it updates the device array present in the rnode_list struct of `node'.
 * It searches in rnlist a struct which have rnlist->node == `node',
 * then it substitutes rnlist->dev with `devs' and rnlist->dev_n with `dev_n'.
 * If there is a difference between the new `devs' array and the old one, 1 is
 * returned.
 */
int rnl_update_devs(struct rnode_list **rnlist, int *rnlist_counter,
	                map_node *node, interface **devs, int dev_n)
{
	struct rnode_list *old_rnl, *new_rnl;
	int i, dev_pos, update=0;

	old_rnl=rnl_find_node(*rnlist, node);

	if(!dev_n) {
		/*
		 * The new `devs' array is empty, therefore delete old_rnl
		 */
		rnl_del(rnlist, rnlist_counter, old_rnl, 1);
		return 0;
	}

	if(old_rnl)
		/*
		 * Diff old_rnl->dev and `devs'
		 */
		for(i=0; i < dev_n; i++) {
			dev_pos = FIND_PTR(devs[i], old_rnl->dev, old_rnl->dev_n);
			if(dev_pos < 0) {
				update=1;
				break;
			}
		}
	else if(!old_rnl)
		update=1;
	
	if(update) {
		new_rnl=rnl_add(rnlist, rnlist_counter, node, devs[0]);
		for(i=1; i < dev_n; i++)
			rnl_add_dev(rnlist, rnlist_counter, new_rnl, node, devs[i]);

		new_rnl->tcp_sk = (old_rnl) ? old_rnl->tcp_sk : 0;
		rnl_del(rnlist, rnlist_counter, old_rnl, 0);
	}

	return update;
}

interface **rnl_get_dev(struct rnode_list *rnlist, map_node *node)
{
	struct rnode_list *rnl;

	rnl=rnl_find_node(rnlist, node);
	return !rnl ? 0 : rnl->dev;
}

interface *rnl_get_rand_dev(struct rnode_list *rnlist, map_node *node)
{
	struct rnode_list *rnl;

	return !(rnl=rnl_find_node(rnlist, node)) ? 
			0 : rnl->dev[rand_range(0, rnl->dev_n-1)];
}

/*
 * rnl_get_sk
 *
 * It returns the tcp socket associated to rnode `node'.
 * If the socket is set to zero, it tries to create a tcp connection to 
 * `node' to the `ntk_tcp_port' port.
 *
 * On error -1 is returned.
 */
int rnl_get_sk(struct rnode_list *rnlist, map_node *node)
{
	struct rnode_list *rnl;

	if(!(rnl=rnl_find_node(rnlist, node)))
		return -1;

	if(!rnl->tcp_sk) {
		inet_prefix to;
		int i;

		if(me.cur_node->flags & MAP_HNODE) {
			struct radar_queue *rq;

			/* If we are hooking, get the IP from the radar
			 * queue */
			if(!(rq=find_node_radar_q(rnl->node)))
				return -1;
			inet_copy(&to, &rq->ip);

		} else {
			rnodetoip((u_int)me.int_map, (u_int)node,
					me.cur_quadg.ipstart[1], &to);
		}

		/* Try to connect using the `i'th device. If it fails, try
		 * another device */
		for(i=0; i < rnl->dev_n && rnl->tcp_sk <= 0; i++)
			rnl->tcp_sk=pkt_tcp_connect(&to, ntk_tcp_port,
					rnl->dev[i]);

		/* If the socket is connected, set it to keepalive */
		if((rnl->tcp_sk = (rnl->tcp_sk <= 0) ? 0 : rnl->tcp_sk))
			set_keepalive_sk(rnl->tcp_sk);
		
	}
	
	return rnl->tcp_sk > 0 ? rnl->tcp_sk : -1;
}

/*
 * rnl_set_sk
 *
 * It sets the socket associated to rnode `node' to `sk'
 */
void rnl_set_sk(struct rnode_list *rnlist, map_node *node, int sk)
{
	struct rnode_list *rnl;

	if(!(rnl=rnl_find_node(rnlist, node)))
		return;

	rnl->tcp_sk=sk;
}

/*
 * rnl_close_all_sk
 *
 * It closes all the opened tcp_sk of the `rnlist' llist
 */
void rnl_close_all_sk(struct rnode_list *rnlist)
{
	struct rnode_list *rnl=rnlist;

	list_for(rnl)
		if(rnl->tcp_sk)
			inet_close(&rnl->tcp_sk);
}

/*
 * rnl_fill_rq
 *
 * It sets the `pkt'->sk and `pkt'->to variables.
 * The `pkt'->sk is retrieved using rnl_get_sk()
 *
 * On error -1 is returned.
 */
int rnl_fill_rq(map_node *rnode, PACKET *pkt)
{
	int tries=0;

retry:
	if(!pkt->sk && (pkt->sk=rnl_get_sk(rlist, rnode)) <= 0) {
		error(ERROR_MSG "Couldn't get the socket associated "
				"to dst_rnode", ERROR_FUNC);
		return -1;
	}

	if(inet_getpeername(pkt->sk, &pkt->to, 0) < 0) {
		tries++;
		if(tries < 2)
			goto retry;
		return -1;
	}

	return 0;
}

/*
 * rnl_send_rq
 *
 * It is a wrapper to send_rq. It is used to send or receive a packet to/from
 * the specified `rnode'.
 *
 * On error -1 is returned.
 *
 * Note: the pkt->sk must not be closed.
 */
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)
{
	int ret, tries=0;

retry:
	if(!pkt->sk && rnl_fill_rq(rnode, pkt) < 0)
		return -1;

	ret=send_rq(pkt, pkt_flags, rq, rq_id, re, check_ack, rpkt);
	if((ret == SEND_RQ_ERR_CONNECT || ret == SEND_RQ_ERR_SEND || 
		ret == SEND_RQ_ERR_RECV)) {

		/* The socket has been corrupted, set it to 0 and try again */
		inet_close(&pkt->sk);
		rnl_set_sk(rlist, rnode, 0);
		
		tries++;
		if(tries < 2)
			goto retry;
	}

	return ret;
}

/*
 * is_rnode_allowed
 * 
 * it verifies if the rnode described by the `rip' IP is 
 * present in the `alr' llist. If it is 1 is returned, otherwise 0.
 */
int is_rnode_allowed(inet_prefix rip, struct allowed_rnode *alr)
{
	int i, e, gid[MAX_LEVELS];

	iptogids(&rip, gid, FAMILY_LVLS);
	
	list_for(alr) {
		for(e=0, i=alr->min_level; i < alr->tot_level; i++)
			if(gid[i] != alr->gid[i]) {
				e=1;
				break;
			}
		if(!e)
			return 1;
	}

	return 0;
}

/*
 * new_rnode_allowed
 * 
 * add a new allowed rnode in the `alr' llist which has
 * already `*alr_counter' members. `gid', `min_lvl', and `tot_lvl' are the
 * respective field of the new allowed_rnode struct.
 */
void new_rnode_allowed(struct allowed_rnode **alr, int *alr_counter,
		int *gid, int min_lvl, int tot_lvl)
{
	struct allowed_rnode *new_alr;

	new_alr=xmalloc(sizeof(struct allowed_rnode));

	new_alr->min_level=min_lvl;
	new_alr->tot_level=tot_lvl;
	
	setzero(new_alr->gid, sizeof(int)*MAX_LEVELS);
	memcpy(&new_alr->gid[min_lvl], &gid[min_lvl], sizeof(int)*(tot_lvl-min_lvl));
	
	debug(DBG_SOFT, "new_rnode_allowed: %d, %d, %d, %d. min_lvl: %d, tot_lvl: %d", 
			gid[0], gid[1], gid[2], gid[3], min_lvl, tot_lvl);

	clist_add(alr, alr_counter, new_alr);
}

void reset_rnode_allowed(struct allowed_rnode **alr, int *alr_counter)
{
	if(*alr)
		list_destroy((*alr));
	*alr=(struct allowed_rnode *)clist_init(alr_counter);
}

/*
 * count_hooking_nodes
 * 
 * returns the number of hooking nodes, which are stored
 * in the radar_queue.
 */
int count_hooking_nodes(void) 
{
	struct radar_queue *rq;
	int total_hooking_nodes=0;

	rq=radar_q;
	list_for(rq) {
		if(!rq->node)
			continue;

		if(rq->node->flags & MAP_HNODE)
			total_hooking_nodes++;
	}
	
	return total_hooking_nodes;
}


/*
 * final_radar_queue
 * 
 * analyses the received ECHO_REPLY pkt and write the
 * average rtt of each found node in the radar_queue.
 */
void final_radar_queue(void)
{	
	struct radar_queue *rq;
	int e;
	struct timeval sum;
	u_int f_rtt;

	setzero(&sum, sizeof(struct timeval));

	rq=radar_q;
	list_for(rq) {
		if(!rq->node)
			continue;

		/* Sum the rtt of all the received pongs */
		for(e=0; e < rq->pongs; e++)
			timeradd(&rq->rtt[e], &sum, &sum);
		
		/* Add penality rtt for each pong lost */
		for(; e < MAX_RADAR_SCANS; e++)
			timeradd(&rq->rtt[e-rq->pongs], &sum, &sum);

		f_rtt=MILLISEC(sum)/MAX_RADAR_SCANS;
		MILLISEC_TO_TV(f_rtt, rq->final_rtt);
	}

	my_echo_id=0;
}

/* 
 * radar_remove_old_rnodes
 * 
 * It removes all the old rnodes ^_- It store in rnode_delete[level] the number
 * of deleted rnodes. This function is used by radar_update_map
 */
int radar_remove_old_rnodes(char *rnode_deleted) 
{
	map_node *node, *root_node, *broot_node;
	map_gnode *gnode;
	map_bnode *bnode;
	ext_rnode *e_rnode=0;
	ext_rnode_cache *erc;
	struct qspn_buffer *qb;
	struct rnode_list *rnl;
	int i, e, node_pos, bm, rnode_pos, bnode_rnode_pos, root_node_pos;
	int broot_node_pos;
	int level, blevel, external_node, total_levels, first_level;
	void *void_map, *void_gnode;

	if(!me.cur_node->links)
		return 0;

	for(i=0; i<me.cur_node->links; i++) {
		node=(map_node *)me.cur_node->r_node[i].r_node;

		if(!(node->flags & MAP_VOID))
			/* The rnode is not really dead! */
			continue;

		if(node->flags & MAP_ERNODE) {
			e_rnode=(ext_rnode *)node;
			external_node=1;
			total_levels=e_rnode->quadg.levels;
			first_level=1;
			quadg_setflags(&e_rnode->quadg, MAP_VOID);
		} else {
			external_node=0;
			total_levels=1;
			first_level=0;
		}

		for(level=first_level; level < total_levels; level++) {
			qspn_set_map_vars(level, 0, &root_node, &root_node_pos, 0);
			blevel=level-1;

			/* delete the rnode from the rnode_list */
			rnl=rnl_find_node(rlist, node);
			rnl_del(&rlist, &rlist_counter, rnl, 1);

			/*
			 * Just delete it from all the maps.
			 */
			
			if(!level && !external_node) {
				void_map=me.int_map;
				node_pos=pos_from_node(node, me.int_map);
				rnode_pos=i;
				
				debug(DBG_NORMAL, "radar: The node %d is dead", 
						node_pos);

				/* delete it from the int_map and update the gcount */
				map_node_del(node);
				qspn_dec_gcount((int*)qspn_gnode_count, level+1, 1); 
				
				/* delete the route */
				rt_update_node(0, node, 0,0,0, level); 
				
			 	send_qspn_now[level]=1;
			} else {
				void_map=me.ext_map;
				gnode=e_rnode->quadg.gnode[_EL(level)];
				
				/** delete the direct route to the ext_node */
				if(level == 1)
				  rt_update_node(&e_rnode->quadg.ipstart[0], 
						  e_rnode, 0, 0, 0, /*level=0*/ 0);
				/**/

				void_gnode=(void *)gnode;
				if(!void_gnode)
					continue;
				
				node_pos=pos_from_gnode(gnode, me.ext_map[_EL(level)]); 
				rnode_pos=g_rnode_find((map_gnode *)root_node, gnode);

				debug(DBG_NORMAL, "The ext_node (gid %d, lvl %d) is"
						" dead", e_rnode->quadg.gid[level], level);

				/* bnode_map update */
				for(e=0; blevel >= 0; blevel--) {
					qspn_set_map_vars(blevel, 0, &broot_node, &broot_node_pos, 0);
					bm=map_find_bnode(me.bnode_map[blevel], me.bmap_nodes[blevel],
							broot_node_pos);
					if(bm == -1)
						continue;

					bnode=&me.bnode_map[blevel][bm];
					bnode_rnode_pos=rnode_find(bnode, 
							(map_node *) e_rnode->quadg.gnode[_EL(level)]);
					if(bnode_rnode_pos != -1)
						rnode_del(bnode, bnode_rnode_pos);

					if(!bnode->links) {
						me.bnode_map[blevel]=map_bnode_del(me.bnode_map[blevel], 
								&me.bmap_nodes[blevel], bnode);
						broot_node->flags&=~MAP_BNODE;
					} else
						e=1;
				}
				if(!e) /* We are no more a bnode */
					me.cur_node->flags&=~MAP_BNODE;

				/* If we were the only bnode which bordered on
				 * `gnode', delete it from the map */
				if(map_find_bnode_rnode(me.bnode_map[level-1], me.bmap_nodes[level-1],
							gnode) == -1) {
					qspn_dec_gcount((int*)qspn_gnode_count, level+1, gnode->gcount);
					gmap_node_del(gnode);
					gnode_dec_seeds(&me.cur_quadg, level); /* update the seeds */
				}

				/* Delete the entries from the routing table */
				rt_update_node(0, 0, &e_rnode->quadg, 0, 0, level);
			 	
				send_qspn_now[level]=1;
			}
	
			if(rnode_pos >= 0 && root_node->links > 0)
				rnode_del(root_node, rnode_pos);

			if(!root_node->links) {
				/* We are alone in the dark. Sigh. */
				qspn_time_reset(level, level, FAMILY_LVLS);
			} else if(!external_node)
				erc_update_rnodepos(me.cur_erc, root_node, rnode_pos);

			/* Now we delete it from the qspn_buffer */
			if(qspn_b[level]) {
				qb=qspn_b[level];
				qb=qspn_b_find_rnode(qb, node);
				if(qb)
					qspn_b[level]=list_del(qspn_b[level], qb);
			}
			
			SET_BIT(rnode_deleted, level);
		}
		
		/* 
		 * Kick out the external_node from the root_node and destroy it
		 * from the ext_rnode_cache
		 */
		if(external_node) {
			/* external rnode cache update */
			erc=erc_find(me.cur_erc, e_rnode);
			if(erc)
				e_rnode_del(&me.cur_erc, &me.cur_erc_counter, erc);
			rnode_del(me.cur_node, i);
		}

		/* If the rnode we deleted from the root_node was swapped with
		 * the last rnodes, we have to inspect again the same
		 * root_node->r_node[ `i' ] rnode, because now it is another 
		 * rnode */
		if(i != (me.cur_node->links+1) - 1)
			i--;
	}

	if(!me.cur_node->links) {
		/* - Diary -
		 * Tue Mar 14 07:29:58 CET 2006
		 * Damn! All my rnodes died, I am the last survivor in this
		 * great lone land... I have to reset my memory... farewell!
		 */
		qspn_reset_counters(FAMILY_LVLS);
	}
	
	return 0;
}

/* 
 * radar_update_bmap
 *
 * updates the bnode map of the given `level' the root_node bnode in the bmap 
 * will also point to the gnode of level `gnode_level'+1 that is
 * `rq'->quadg.gnode[_EL(gnode_level+1)].
 */
void radar_update_bmap(struct radar_queue *rq, int level, int gnode_level)
{
	map_gnode *gnode;
	map_node  *root_node;
	map_rnode *rnode, rn;
	int  bm, rnode_pos, root_node_pos;
	void *void_map;

	if(level == me.cur_quadg.levels-1)
		return;

	qspn_set_map_vars(level, 0, &root_node, &root_node_pos, 0);
	void_map=me.ext_map;
	gnode=rq->quadg.gnode[_EL(gnode_level+1)];
	
	bm=map_find_bnode(me.bnode_map[level], me.bmap_nodes[level],
			root_node_pos);
	if(bm==-1) {
		bm=map_add_bnode(&me.bnode_map[level], &me.bmap_nodes[level], 
				root_node_pos, 0);
		rnode_pos=-1;
	} else
		rnode_pos=rnode_find(&me.bnode_map[level][bm], &gnode->g);
	
	if(rnode_pos == -1) {
		setzero(&rn, sizeof(map_rnode));
		rn.r_node=(int *)&gnode->g;
		rnode_add(&me.bnode_map[level][bm], &rn);
		rnode_pos=0;
	}

	rnode=&me.bnode_map[level][bm].r_node[rnode_pos];
	rnode->trtt=MILLISEC(rq->final_rtt);
}

/* 
 * radar_update_map
 * 
 * it updates the int_map and the ext_map if any bnodes are found.
 * Note that the rnodes in the map are held in a different way. First of all the qspn
 * is not applied to them (we already know how to reach them ;) and they have only
 * one rnode... ME. So me.cur_node->r_node[x].r_node->r_node[0] == me.cur_node.
 * Gotcha?
 */
void radar_update_map(void)
{
	struct qspn_buffer *qb;
	struct radar_queue *rq;
	ext_rnode_cache *erc;
	map_gnode *gnode=0;
	map_node  *node, *root_node;
	map_rnode rnn, *new_root_rnode;
	ext_rnode *e_rnode;
	
	int i, diff, rnode_pos;
	u_char rnode_added[MAX_LEVELS/8], rnode_deleted[MAX_LEVELS/8];
	int level, external_node, total_levels, root_node_pos, node_update;
	void *void_map;
	const char *ntop;
	char updated_rnodes, routes_update, devs_update;

	updated_rnodes=routes_update=devs_update=0;
	setzero(rnode_added, sizeof(rnode_added));
	setzero(rnode_deleted, sizeof(rnode_deleted));
	
	/**
	 * Let's consider all our rnodes void, in this way we'll know what
	 * rnodes will remain void after the update.
	 */
	for(i=0; i<me.cur_node->links; i++) {
		node=(map_node *)me.cur_node->r_node[i].r_node;
		node->flags|=MAP_VOID | MAP_UPDATE;
	}
	/**/

	rq=radar_q;
	list_for(rq) {
	           if(!rq->node)
			   continue;
		   if(!(me.cur_node->flags & MAP_HNODE) && (rq->flags & MAP_HNODE))
			   continue;

		   /* 
		    * We need to know if it is a node which is not in the gnode
		    * where we are (external_rnode).
		    */
		   if((int)rq->node == RADQ_EXT_RNODE) {
			   external_node=1;
			   total_levels=rq->quadg.levels;
		   } else {
			   external_node=0;
			   total_levels=1;
		   }

		   for(level=total_levels-1; level >= 0; level--) {
			   qspn_set_map_vars(level, 0, &root_node, &root_node_pos, 0);
			   node_update=devs_update=0;

			   if(!level) {
				   void_map=me.int_map;
				   node=rq->node;
			   } else {
				   /* Skip the levels where the ext_rnode belongs
				    * to our same gids */
				   if(!quadg_gids_cmp(rq->quadg, me.cur_quadg, level))
					   continue;
				   
				   /* Update only the gnodes which belongs to
				    * our same gid of the upper level, because
				    * we don't keep the internal info of the
				    * extern gnodes. */
				   if((level < rq->quadg.levels-1) &&
					quadg_gids_cmp(rq->quadg, me.cur_quadg, level+1)) {
					   rq->quadg.gnode[_EL(level)]=0;
					   continue;
				   }
				   
				   /* Ehi, we are a bnode */
				   root_node->flags|=MAP_BNODE;
				   me.cur_node->flags|=MAP_BNODE;
				   
				   void_map=me.ext_map;
				   gnode=rq->quadg.gnode[_EL(level)];
				   node=&gnode->g;
			   }

			   if(external_node && !level && me.cur_erc_counter) {
				   erc=e_rnode_find(me.cur_erc, &rq->quadg, 0);
				   if(!erc)
					   rnode_pos=-1;
				   else {
					   rnode_pos=erc->rnode_pos;
					   node=(map_node *)erc->e;
				   }
			   } else
				   rnode_pos=rnode_find(root_node, node);

			   if(rnode_pos == -1) { /* W00t, we've found a new rnode! */
				   node_update=1;
				   rnode_pos=root_node->links; 
				   
				   ntop=inet_to_str(rq->quadg.ipstart[level]);
				   if(server_opt.dbg_lvl || !level)
					   loginfo("Radar: New node found: %s, ext: %d, level: %d", 
							   ntop, external_node, level);

				   if(external_node && !level) {
					   /* 
					    * If this node we are processing is external, at level 0,
					    * in the root_node's rnodes we add a rnode which point 
					    * to a ext_rnode struct.
					    */

					   setzero(&rnn, sizeof(map_rnode));
					   e_rnode=xzalloc(sizeof(ext_rnode));

					   memcpy(&e_rnode->quadg, &rq->quadg, sizeof(quadro_group));
					   e_rnode->node.flags=MAP_BNODE | MAP_GNODE |  MAP_RNODE | 
						   MAP_ERNODE;
					   rnn.r_node=(int *)e_rnode;
					   node=rq->node=&e_rnode->node;
					   new_root_rnode=&rnn;
					  
					   /* Update the external_rnode_cache list */
					   e_rnode_add(&me.cur_erc, e_rnode, rnode_pos,
							   &me.cur_erc_counter);
				   } else {
					   /*We purge all the node's rnodes.*/
					   rnode_destroy(node);

					   /* 
					    * This node has only one rnode, 
					    * and that is the root_node.
					    */
					   setzero(&rnn, sizeof(map_rnode));
					   rnn.r_node=(int *)root_node;
					   rnode_add(node, &rnn);

					   /* It is a border node */
					   if(level)
						   node->flags|=MAP_BNODE | MAP_GNODE;
					   node->flags|=MAP_RNODE;

					   /* 
					    * Fill the rnode to be added in the
					    * root_node.
					    */
					   setzero(&rnn, sizeof(map_rnode));
					   rnn.r_node=(int *)node; 
					   new_root_rnode=&rnn;
				   }

				   /* 
				    * The new node is added in the root_node's
				    * rnodes.
				    */
				   rnode_add(root_node, new_root_rnode);
				   

				   /* Update the qspn_buffer */
				   if(!external_node || level) {
					   qb=xzalloc(sizeof(struct qspn_buffer));
					   qb->rnode=node;
					   qspn_b[level]=list_add(qspn_b[level], qb);

					   send_qspn_now[level]=1;
				   }
				   
				   /* If the new rnode wasn't present in the map, 
				    * then it is also a new node in the map, so
				    * update the seeds counter too */
				   if(!level && !external_node && (node->flags & MAP_VOID)) {
					   gnode_inc_seeds(&me.cur_quadg, level);
					   qspn_inc_gcount(qspn_gnode_count, level+1, 1);
				   }

				   SET_BIT(rnode_added, level);
			   } else {
				   /* 
				    * Nah, We have the node in the map. Let's see if 
				    * its rtt is changed
				    */

				   if(!send_qspn_now[level] && node->links) {
					   diff=abs(root_node->r_node[rnode_pos].trtt -
							   MILLISEC(rq->final_rtt));
					   if(diff >= RTT_DELTA) {
				   		   node_update=1;
						   send_qspn_now[level]=1;
						   debug(DBG_NOISE, "node %s rtt changed, diff: %d",
								   inet_to_str(rq->ip), diff);
					   }
				   }
			   }
			   
			   /* Restore the flags */
			   if(level)
				   gnode->flags&=~GMAP_VOID;
			   node->flags&=~MAP_VOID & ~MAP_UPDATE & ~QSPN_OLD;


			   /*
			    * Update the devices list of the rnode
			    */
			   if(!level) {
				  devs_update=rnl_update_devs(&rlist, &rlist_counter,
					  node, rq->dev, rq->dev_n);
				  if(devs_update)
					  routes_update++;
			   }


			   /* Nothing is really changed */
			   if(!node_update)
				   continue;
			   
			   /* Update the rtt */
		           root_node->r_node[rnode_pos].trtt=MILLISEC(rq->final_rtt);
			   
			   /* Bnode map stuff */
			   if(external_node && level) {
				   /* 
				    * All the root_node bnodes which are in the
				    * bmaps of level smaller than `level' points to
				    * the same gnode which is rq->quadg.gnode[_EL(level-1+1)].
				    * This is because the inferior levels cannot
				    * have knowledge about the bordering gnode 
				    * which is in an upper level, but it's necessary that
				    * they know which who the root_node borders on,
				    * so the get_route algorithm can descend to
				    * the inferior levels and it will still know
				    * what is the border node which is linked
				    * to the target gnode.
				    */
				   for(i=0; i < level; i++)
					   radar_update_bmap(rq, i, level-1);
				   send_qspn_now[level-1]=1;
			   }

			   if(node_update || devs_update)
				   node->flags|=MAP_UPDATE;

		   } /*for(level=0, ...)*/
		   
		   updated_rnodes++;
	} /*list_for(rq)*/

	/* Burn the deads */
	if(updated_rnodes < me.cur_node->links)
		radar_remove_old_rnodes((char*)rnode_deleted);

	/* <<keep your room tidy... order, ORDER>> */
	if(!is_bufzero(rnode_added, sizeof(rnode_added)) || 
			!is_bufzero(rnode_deleted, sizeof(rnode_deleted))) {

		/*** 
		 * qsort the rnodes of me.cur_node and me.cur_quadg comparing 
		 * their trtt */
		rnode_trtt_order(me.cur_node);

		for(i=1; i<me.cur_quadg.levels; i++)
			if(TEST_BIT(rnode_added, i) || TEST_BIT(rnode_deleted, i))
				rnode_trtt_order(&me.cur_quadg.gnode[_EL(i)]->g);
		/**/

		/* adjust the rnode_pos variables in the ext_rnode_cache list */
		erc_reorder_rnodepos(&me.cur_erc, &me.cur_erc_counter, me.cur_node);
	}

	/* Give a refresh to the kernel */
	if((!is_bufzero(rnode_added, sizeof(rnode_added)) ||
		routes_update) && !(me.cur_node->flags & MAP_HNODE))
		rt_rnodes_update(1);
}

/* 
 * add_radar_q
 * 
 * It returns the radar_q struct which handles the pkt.from node.
 * If the node is not present in the radar_q, it is added, and the
 * relative struct will be returned.
 */
struct
radar_queue *add_radar_q(PACKET pkt)
{
	map_node *rnode;
	quadro_group quadg;
	struct radar_queue *rq;
	u_int ret=0;
	int dev_pos;

	if(me.cur_node->flags & MAP_HNODE) {
		/* 
		 * We are hooking, we haven't yet an int_map, an ext_map,
		 * a stable ip, so we create fake nodes that will be delete after
		 * the hook.
		 */
		if(!(rq=find_ip_radar_q(&pkt.from))) {
			map_rnode rnn;

			rnode=xmalloc(sizeof(map_node));
			setzero(rnode, sizeof(map_node));
			setzero(&rnn, sizeof(map_rnode));

			rnn.r_node=(int *)me.cur_node;
			rnode_add(rnode, &rnn);
		} else
			rnode=rq->node;
	} 
	
	iptoquadg(pkt.from, me.ext_map, &quadg, QUADG_GID|QUADG_GNODE|QUADG_IPSTART);

	if(!(me.cur_node->flags & MAP_HNODE)) {
		iptomap((u_int)me.int_map, pkt.from, me.cur_quadg.ipstart[1], &rnode);
		ret=quadg_gids_cmp(me.cur_quadg, quadg, 1);
	}

	if(!ret)
		rq=find_node_radar_q(rnode);
	else
		rq=find_ip_radar_q(&pkt.from);
	
	if(!rq) { 
		/* 
		 * If pkt.from isn't already in the queue, add it. 
		 */

		rq=xzalloc(sizeof(struct radar_queue));
		
		if(ret)
			rq->node=(map_node *)RADQ_EXT_RNODE;
		else {
			rq->node=rnode;
			/* This pkt has been sent from another hooking
			 * node, let's remember this. */
			if(pkt.hdr.flags & HOOK_PKT)
				rq->node->flags|=MAP_HNODE;
		}

		if(pkt.hdr.flags & HOOK_PKT)
			rq->flags|=MAP_HNODE;

		inet_copy(&rq->ip, &pkt.from);
		memcpy(&rq->quadg, &quadg, sizeof(quadro_group));
		rq->dev[0] = pkt.dev;
		rq->dev_n++;
	
		clist_add(&radar_q, &radar_q_counter, rq);
	} else {
		/*
		 * Check if the input device is in the rq->dev array,
		 * if not add it.
		 */
		if(rq->dev_n < MAX_INTERFACES) {
			dev_pos=FIND_PTR(pkt.dev, rq->dev, rq->dev_n);
			if(dev_pos < 0)
				rq->dev[rq->dev_n++]=pkt.dev;
		}
	}

	return rq;
}

/* 
 * radar_exec_reply
 * 
 * It reads the received ECHO_REPLY pkt and updates the radar
 * queue, storing the calculated rtt and the other infos relative to the sender
 * node.
 */
int radar_exec_reply(PACKET pkt)
{
	struct timeval t;
	struct radar_queue *rq;
	u_int rtt_ms=0;
	int dev_pos;
	
	gettimeofday(&t, 0);

	/*
	 * Get the radar_queue struct relative to pkt.from
	 */
	rq=add_radar_q(pkt);

	dev_pos=ifs_get_pos(me.cur_ifs, me.cur_ifs_n, pkt.dev);
	if(dev_pos < 0)
		debug(DBG_NORMAL, "The 0x%x ECHO_REPLY pkt was received by a non "
				"existent interface", pkt.hdr.id);

	if(me.cur_node->flags & MAP_HNODE) {
		if(pkt.hdr.flags & HOOK_PKT) {
			u_char scanning;
			memcpy(&scanning, pkt.msg, sizeof(u_char));

			/* 
			 * If the pkt.from node has finished his scan, and we
			 * never received one of its ECHO_ME pkts, and we are
			 * still scanning, set the hook_retry.
			 */
			if(!scanning && !rq->pings && 
					(radar_scan_mutex ||
					 radar_scans[dev_pos]<=MAX_RADAR_SCANS)) {
				hook_retry=1;
			}
		}
	}

	if(rq->pongs < radar_scans[dev_pos]) {
		timersub(&t, &scan_start, &rq->rtt[(int)rq->pongs]);
		/* 
		 * Now we divide the rtt, because (t - scan_start) is the time
		 * the pkt used to reach B from A and to return to A from B
		 */
		rtt_ms=MILLISEC(rq->rtt[(int)rq->pongs])/2;
		MILLISEC_TO_TV(rtt_ms, rq->rtt[(int)rq->pongs]);

		rq->pongs++;
	}

	return 0;
}


/* 
 * radar_recv_reply
 * 
 * It handles the ECHO_REPLY pkts
 */
int radar_recv_reply(PACKET pkt)
{
	if(!my_echo_id || !radar_scan_mutex || !total_radar_scans)
		return -1;
	
	if(pkt.hdr.id != my_echo_id) {
		debug(DBG_NORMAL,"I received an ECHO_REPLY with id: 0x%x, but "
				"my current ECHO_ME is 0x%x", pkt.hdr.id, 
				my_echo_id);
		return -1;
	}

	/* 
	 * If the `alwd_rnodes_counter' counter isn't zero, verify that
	 * `pkt.from' is an allowed rnode, otherwise drop this pkt 
	 */
	if(alwd_rnodes_counter && !is_rnode_allowed(pkt.from, alwd_rnodes)) {
		debug(DBG_INSANE, "Filtering 0x%x ECHO_REPLY", pkt.hdr.id);
		return -1;
	}

	/*
	 * If the rnode is in restricted mode and we are not, drop the pkt.
	 * If we are in restricted mode and the rnode isn't, drop the pkt
	 */
	if((pkt.hdr.flags & RESTRICTED_PKT && !restricted_mode) ||
		(!(pkt.hdr.flags & RESTRICTED_PKT) && restricted_mode))
		return -1;
	
	return radar_exec_reply(pkt);
}

/* 
 * radar_qspn_send_t
 * 
 * This function is used only by radar_scan().
 * It just call the qspn_send() function. We use a thread
 * because the qspn_send() may sleep, and we don't want to halt the
 * radar_scan().
 */
void *radar_qspn_send_t(void *level)
{
	int *p;
	u_char i;

	p=(int *)level;
	i=(u_char)*p;

	xfree(p);
	qspn_send(i);

	return NULL;
}
		            
/* 
 * radar_scan
 * 
 * It starts the scan of the local area.
 *
 * It sends MAX_RADAR_SCANS packets in broadcast then it waits MAX_RADAR_WAIT
 * and in the while the echo replies are gathered. After MAX_RADAR_WAIT it 
 * stops to receive echo replies and it does a statistical analysis of the 
 * gathered echo replies, it updates the r_nodes in the map and sends a qspn 
 * round if something is changed in the map and if the `activate_qspn' argument
 * is non zero.
 *
 * It returns 1 if another radar_scan is in progress, -1 if something went
 * wrong, 0 on success.
 */
int radar_scan(int activate_qspn) 
{
	pthread_t thread;
	PACKET pkt;
	int i, d, *p;
	ssize_t err;
	u_char echo_scan;

	/* We are already doing a radar scan, that's not good */
	if(radar_scan_mutex)
		return 1;
	radar_scan_mutex=1;
	
	/*
	 * We create the PACKET 
	 */
	setzero(&pkt, sizeof(PACKET));
	inet_setip_bcast(&pkt.to, my_family);
	my_echo_id=rand();

	gettimeofday(&scan_start, 0);
	
	/*
	 * Send a bouquet of ECHO_ME pkts 
	 */
	
	if(me.cur_node->flags & MAP_HNODE) {
		pkt.hdr.sz=sizeof(u_char);
		pkt.hdr.flags|=HOOK_PKT|BCAST_PKT;
		pkt.msg=xmalloc(pkt.hdr.sz);
		debug(DBG_INSANE, "Radar scan 0x%x activated", my_echo_id);
	} else
		total_radars++;
	
	if(restricted_mode)
		pkt.hdr.flags|=RESTRICTED_PKT;

	/* Loop through the me.cur_ifs array, sending the bouquet using all the
	 * interfaces we have */
	for(d=0; d < me.cur_ifs_n; d++) {

		pkt_add_dev(&pkt, &me.cur_ifs[d], 1);
		pkt.sk=0; /* Create a new socket */
	
		/* Send MAX_RADAR_SCANS# packets using me.cur_ifs[d] as
		 * outgoing interface */
		for(i=0, echo_scan=0; i<MAX_RADAR_SCANS; i++, echo_scan++) {
			if(me.cur_node->flags & MAP_HNODE)
				memcpy(pkt.msg, &echo_scan, sizeof(u_char));

			err=send_rq(&pkt, 0, ECHO_ME, my_echo_id, 0, 0, 0);
			if(err < 0) {
				if(errno == ENODEV) {
					/* 
					 * The me.cur_ifs[d] device doesn't
					 * exist anymore. Delete it.
					 */
					fatal("The device \"%s\" has been removed",
							me.cur_ifs[d].dev_name);
					ifs_del(me.cur_ifs, &me.cur_ifs_n, d);
					d--;
				} else
					error(ERROR_MSG "Error while sending the"
						" scan 0x%x... skipping", 
						ERROR_FUNC, my_echo_id);
				break;
			}
			radar_scans[d]++;
			total_radar_scans++;
		}

		if(!radar_scans[d])
			error("radar_scan(): The scan 0x%x on the %s interface failed."
				" Not a single scan was sent", my_echo_id, 
				pkt.dev->dev_name);
	
		if(pkt.sk > 0)
			inet_close(&pkt.sk);
	}
	
	pkt_free(&pkt, 1);
	
	if(!total_radar_scans) {
		error("radar_scan(): The scan 0x%x failed. It wasn't possible "
				"to send a single scan", my_echo_id);
		return -1;
	}

	xtimer(max_radar_wait, max_radar_wait<<1, &radar_wait_counter);

	final_radar_queue();
	radar_update_map();

	if(activate_qspn)
		for(i=0; i<me.cur_quadg.levels; i++)
			if(send_qspn_now[i]) {
				p=xmalloc(sizeof(int));
				*p=i;
				/* We start a new qspn_round in the `i'-th level */
				pthread_create(&thread, &radar_qspn_send_t_attr, 
						radar_qspn_send_t, (void *)p);
			}

	if(!(me.cur_node->flags & MAP_HNODE))
		reset_radar();

	radar_scan_mutex=0;	
	return 0;
}


/* 
 * radard
 * 
 * It sends back to rpkt.from the ECHO_REPLY pkt in reply to the ECHO_ME
 * pkt received.
 */
int radard(PACKET rpkt)
{
	PACKET pkt;
	struct radar_queue *rq;
	ssize_t err;
	const char *ntop=0;
	int dev_pos;
	u_char echo_scans_count;

	if(alwd_rnodes_counter && !is_rnode_allowed(rpkt.from, alwd_rnodes)) {
		debug(DBG_INSANE, "Filtering 0x%x ECHO_ME", rpkt.hdr.id);
		return -1;
	}
	
	if((rpkt.hdr.flags & RESTRICTED_PKT && !restricted_mode) ||
		(!(rpkt.hdr.flags & RESTRICTED_PKT) && restricted_mode))
		return -1;

	dev_pos=ifs_get_pos(me.cur_ifs, me.cur_ifs_n, rpkt.dev);
	if(dev_pos < 0)
		debug(DBG_NORMAL, "The 0x%x ECHO_ME pkt was received by a non "
				"existent interface", rpkt.hdr.id);

	/* If we are hooking we reply only to others hooking nodes */
	if(me.cur_node->flags & MAP_HNODE) {
		if(rpkt.hdr.flags & HOOK_PKT) {
			memcpy(&echo_scans_count, rpkt.msg, sizeof(u_char));

			/* 
			 * So, we are hooking, but we haven't yet started the
			 * first scan or we have done less scans than rpkt.from,
			 * this means that this node, who is hooking
			 * too and sent us this rpkt, has started the hook 
			 * before us. If we are in a black zone, this flag
			 * will be used to decide which of the hooking nodes
			 * have to create the new gnode: if it is set we'll wait,
			 * the other hooking node will create the gnode, then we
			 * restart the hook. Clear?
			 */
			if(!radar_scan_mutex || echo_scans_count >= radar_scans[dev_pos])
				hook_retry=1;
		} else {
			/*debug(DBG_NOISE, "ECHO_ME pkt dropped: We are hooking");*/
			return 0;
		}
	}

	/* We create the ECHO_REPLY pkt */
	setzero(&pkt, sizeof(PACKET));
	pkt_addto(&pkt, &rpkt.from);
	pkt_addsk(&pkt, rpkt.from.family, rpkt.sk, SKT_UDP);

	if(me.cur_node->flags & MAP_HNODE) {
		/* 
		 * We attach in the ECHO_REPLY a flag that indicates if we have
		 * finished our radar_scan or not. This is usefull if we already
		 * sent all the ECHO_ME pkts of our radar scan and while we are
		 * waiting the MAX_RADAR_WAIT another node start the hooking:
		 * with this flag it can know if we came before him.
		 */
		u_char scanning=1;
		
		pkt.hdr.sz=sizeof(u_char);
		pkt.hdr.flags|=HOOK_PKT;
		pkt.msg=xmalloc(pkt.hdr.sz);
		if(radar_scans[dev_pos] == MAX_RADAR_SCANS)
			scanning=0;
		memcpy(pkt.msg, &scanning, sizeof(u_char));

		/* 
		 * W Poetry Palazzolo, the enlightening holy garden.
		 * Sat Mar 12 20:41:36 CET 2005 
		 */
	}
	
	if(restricted_mode)
		pkt.hdr.flags|=RESTRICTED_PKT;

	/* We send it */
	err=send_rq(&pkt, 0, ECHO_REPLY, rpkt.hdr.id, 0, 0, 0);
	pkt_free(&pkt, 0);
	if(err < 0) {
		error("radard(): Cannot send back the ECHO_REPLY to %s.", ntop);
		return -1;
	}

	/* 
	 * Ok, we have sent the reply, now we can update the radar_queue with
	 * calm.
	 */
	if(radar_q) {
		rq=add_radar_q(rpkt);
		rq->pings++;

#ifdef DEBUG
		if(server_opt.dbg_lvl && rq->pings==1 &&
				me.cur_node->flags & MAP_HNODE) {
			ntop=inet_to_str(pkt.to);
			debug(DBG_INSANE, "%s(0x%x) to %s", rq_to_str(ECHO_REPLY), 
					rpkt.hdr.id, ntop);
		}
#endif
	}
	return 0;
}

/* 
 * refresh_hook_root_node
 * 
 * At hooking the radar_scan doesn't have an int_map, so
 * all the nodes it found are stored in fake nodes. When we finish the hook,
 * instead, we have an int_map, so we convert all this fake nodes into real
 * nodes. To do this we modify each rq->node of the radar_queue and recall the
 * radar_update_map() func. 
 * rnode_list and qspn_b are also updated.
 * Note: the me.cur_node must be deleted prior the call of this function.
 */
int refresh_hook_root_node(void)
{
	struct radar_queue *rq;
	map_node *rnode;
	int ret;

	rq=radar_q;
	list_for(rq) {
		ret=iptomap((u_int)me.int_map, rq->ip, me.cur_quadg.ipstart[1], 
				&rnode);
		if(ret)
			rq->node=(map_node *)RADQ_EXT_RNODE;
		else
			rq->node=rnode;
	}

	radar_update_map();

	/* 
	 * Remove all the rnode_list structs which refers to the fake 
	 * rnodes.
	 */
	rnl_del_dead_rnode(&rlist, &rlist_counter, me.cur_node);

	/* Do the same for the qspn_b buffer */
	qspn_b_del_all_dead_rnodes();
	
	return 0;
}

/* 
 * radar_daemon
 * 
 * keeps the radar up until the end of the universe.
 */
void *radar_daemon(void *null)
{
	/* If `radar_daemon_ctl' is set to 0 the radar_daemon will stop.
	 * It will restart when it becomes again 1 */
	radar_daemon_ctl=1;
	
	debug(DBG_NORMAL, "Radar daemon up & running");
	for(;;) {
		while(!radar_daemon_ctl)
			sleep(1);

		radar_scan(1);
	}
}

/* 
 * radar_wait_new_scan
 * 
 * It sleeps until a new radar scan is sent 
 */
void radar_wait_new_scan(void)
{
	int old_echo_id, old_radar_wait_counter;
	
	old_echo_id=my_echo_id;
	old_radar_wait_counter=radar_wait_counter;

	for(; old_echo_id == my_echo_id; ) {
		usleep(505050);

		/* If the radar_wait_counter doesn't change, that means that
		 * the radar isn't active */
		if(radar_wait_counter == old_radar_wait_counter)
			break;
	}
}

/*EoW*/