netsukuku/src/tracer.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.
 */

#include "includes.h"

#include "common.h"
#include "request.h"
#include "pkts.h"
#include "bmap.h"
#include "radar.h"
#include "route.h"
#include "radar.h"
#include "rehook.h"
#include "tracer.h"
#include "qspn.h"
#include "igs.h"
#include "netsukuku.h"

char *tracer_pack_pkt(brdcast_hdr * bcast_hdr, tracer_hdr * trcr_hdr,
					  tracer_chunk * tracer, char *bblocks,
					  size_t bblocks_sz, int new_bblocks);

/* 
 * ip_to_rfrom: If `rip_quadg' is null, it converts the `rip' ip in a 
 * quadro_group that is stored in `new_quadg' (if it is not null), otherwise it
 * uses `rip_quadg' itself.
 * The flags passed to iptoquadg are orred whith `quadg_flags'. 
 * The rnode position of the root_node of level 0 which corresponds to 
 * the given ip is returned, if it isn't found -1 is returned.
 */
int
ip_to_rfrom(inet_prefix rip, quadro_group * rip_quadg,
			quadro_group * new_quadg, char quadg_flags)
{
	quadro_group qdg, *quadg;
	map_node *from;
	ext_rnode_cache *erc;
	int ret, external_node = 0;

	quadg = &qdg;

	if (rip_quadg) {
		quadg = rip_quadg;
	} else {
		quadg_flags |= QUADG_GID | QUADG_GNODE;
		iptoquadg(rip, me.ext_map, quadg, quadg_flags);
		if (new_quadg)
			memcpy(new_quadg, quadg, sizeof(quadro_group));
	}

	if (quadg_gids_cmp(me.cur_quadg, *quadg, 1))
		external_node = 1;

	if (!external_node) {
		iptomap((uintptr_t) me.int_map, rip, me.cur_quadg.ipstart[1], &from);
		ret = rnode_find(me.cur_node, from);
	} else {
		erc = e_rnode_find(me.cur_erc, quadg, 0);
		ret = !erc ? -1 : erc->rnode_pos;
	}

	return ret;
}

/* 
 * tracer_verify_pkt: It checks the validity of `tracer': The last entry
 * in the tracer must be a node present in our r_nodes.
 * Instead of using iptoquadg it uses `rip_quadg' if it isn't null.
 */
int
tracer_verify_pkt(tracer_chunk * tracer, u_short hops, inet_prefix rip,
				  quadro_group * rip_quadg, int level)
{
	quadro_group qdg, *quadg;
	map_node *from, *real_from, *real_gfrom;
	int retries = 0, ret;

	from = real_from = real_gfrom = 0;
	quadg = &qdg;

	if (!rip_quadg)
		iptoquadg(rip, me.ext_map, quadg, QUADG_GID | QUADG_GNODE);
	else
		quadg = rip_quadg;

	if (!quadg_gids_cmp(*quadg, me.cur_quadg, level))
		return 0;

	/* 
	 * Now, let's check if we are part of the bcast_hdr->g_node of 
	 * bcast_hdr->level. If not let's  drop it! Why the hell this pkt is 
	 * here?
	 */
	if (quadg_gids_cmp(*quadg, me.cur_quadg, level + 1)) {
		debug(DBG_INSANE, "%s:%d", ERROR_POS);
		return -1;
	}

	/*
	 * `from' has to be absolutely one of our rnodes
	 */

	if (!level) {
		iptomap((uintptr_t) me.int_map, rip, me.cur_quadg.ipstart[1],
				&real_from);
		from = node_from_pos(tracer[hops - 1].node, me.int_map);
	} else {
		real_gfrom = &quadg->gnode[_EL(level)]->g;
		from = node_from_pos(quadg->gid[0], me.int_map);
	}

	/* Look for the `from' node in the int_map. */
	if ((real_from && real_from == from) || from) {
		/* Is `from' in our rnodes? */
		for (retries = 0;
			 (ret = rnode_find(me.cur_node, from)) == -1 && !retries;
			 retries++)
			radar_wait_new_scan();
		if (ret != -1)
			return 0;
	}

	/* `from' is a gnode, look in the ext_map */
	if (level) {
		/* Look in ext_map */
		from = (map_node *) gnode_from_pos(tracer[hops - 1].node,
										   me.ext_map[_EL(level)]);
		if (!from || (real_gfrom && real_gfrom != from)) {
			debug(DBG_INSANE, "%s:%d", ERROR_POS);
			return -1;
		}

		ret =
			g_rnode_find(me.cur_quadg.gnode[_EL(level)],
						 (map_gnode *) from);
		if (ret == -1) {
			debug(DBG_INSANE, "%s:%d gnode: %d, level: %d",
				  ERROR_POS, tracer[hops - 1].node, level);
			return -1;
		}
	}

	return 0;
}

/* 
 * tracer_add_entry: Append our entry `node' to the tracer pkt `tracer' wich has 
 * `hops'. It returns the modified tracer pkt in a newly mallocated struct and
 * it increments the `*hops'.
 * If `tracer' is null it will return the new tracer_pkt.
 * On errors it returns NULL.
 */
tracer_chunk *
tracer_add_entry(void *void_map, void *void_node, tracer_chunk * tracer,
				 u_int * hops, u_char level)
{
	tracer_chunk *t;
	map_node *from;
	map_rnode *rfrom = 0;
	map_node *map, *node;
	map_gnode **ext_map, *gnode;
	int pos, new_entry_pos, last_entry_node, nhops;

	map = (map_node *) void_map;
	node = (map_node *) void_node;
	ext_map = (map_gnode **) void_map;
	gnode = (map_gnode *) void_node;

	(*hops)++;
	nhops = *hops;
	new_entry_pos = nhops - 1;
	t = xzalloc(sizeof(tracer_chunk) * nhops);

	if (tracer || nhops > 1) {
		/* 
		 * In the tracer_pkt there are already some chunks, we copy 
		 * them in the new pkt.
		 */
		memcpy(t, tracer, sizeof(tracer_chunk) * (nhops - 1));


		/* 
		 * We add, in the new entry, the rtt there is from me to the 
		 * node of the the last entry of the old tracer pkt.
		 */

		last_entry_node = tracer[nhops - 2].node;
		if (!level) {
			from = node_from_pos(last_entry_node, map);

			/* check if `from' is in our rnodes */
			if ((pos = rnode_find(me.cur_node, from)) == -1) {
				debug(DBG_INSANE, "%s:%d lvl: %d last_entry_node: %d",
					  ERROR_POS, level, last_entry_node);
				return 0;
			}

			rfrom = &me.cur_node->r_node[pos];
		} else {
			from = (map_node *) gnode_from_pos(last_entry_node,
											   ext_map[_EL(level)]);

			/* check if `from' is in our rnodes */
			if ((pos = g_rnode_find(me.cur_quadg.gnode[_EL(level)],
									(map_gnode *) from) == -1)) {
				debug(DBG_INSANE, "%s:%d lvl: %d last_entry_node: %d",
					  ERROR_POS, level, last_entry_node);
				return 0;
			}

			rfrom = &me.cur_quadg.gnode[_EL(level)]->g.r_node[pos];
		}
		t[new_entry_pos].rtt = rfrom->trtt;
	}

	/* Fill the new entry in the tracer_pkt */
	if (!level) {
		t[new_entry_pos].gcount = 1;
		t[new_entry_pos].node = pos_from_node(node, map);
	} else {
		t[new_entry_pos].gcount = qspn_gnode_count[_EL(level)];
		t[new_entry_pos].node = pos_from_gnode(gnode, ext_map[_EL(level)]);
	}

	return t;
}

/* 
 * tracer_add_rtt: Increments the rtt of the `hop'th `tracer' chunk by adding
 * the rtt of the rnode who is in the `rpos' postion in me.cur_node->r_node.
 * It returns the new rtt value on success.
 */
int
tracer_add_rtt(int rpos, tracer_chunk * tracer, u_short hop)
{
	tracer[hop].rtt += me.cur_node->r_node[rpos].trtt;
	return tracer[hop].rtt;
}

/* 
 * tracer_get_trtt: It stores in `trtt' the total round trip time needed to
 * reach the `tracer[0].node' from the me.cur_node.
 * me.cur_node->r_node[`from_rnode_pos'] is the rnode who forwarded us the pkt. 
 * If it succeeds 0 is returned.
 */
int
tracer_get_trtt(int from_rnode_pos, tracer_hdr * trcr_hdr,
				tracer_chunk * tracer, u_int * trtt)
{
	int hops, i;
	u_int trtt_ms = 0;

	*trtt = 0;

	hops = trcr_hdr->hops;
	if (!hops)
		return -1;

	/* Add the rtt of me -> from */
	trtt_ms += me.cur_node->r_node[from_rnode_pos].trtt;

	for (i = hops - 1; i >= 0; i--)
		trtt_ms += tracer[i].rtt;

	*trtt = trtt_ms;

	return 0;
}

/*
 * tracer_update_gcount: it updates `gcount_counter' by adding the sum of 
 * gcounts present in `tracer'.
 * It then updates the map_gnode.gcount counter of the gnodes present in the 
 * `ext_map' of the `level'th level.
 * It ignores all the tracer chunks < `first_hop'.
 */
void
tracer_update_gcount(tracer_hdr * trcr_hdr, tracer_chunk * tracer,
					 int first_hop, u_int * gcount_counter,
					 map_node * int_map, map_gnode ** ext_map, int level)
{
	map_node *node = 0;
	map_gnode *gnode;
	u_int hops;
	int i;

	hops = trcr_hdr->hops;
	if (!hops || first_hop >= hops || first_hop < 0)
		return;

	for (i = first_hop; i >= 0; i--) {
		if (level) {
			gnode = gnode_from_pos(tracer[i].node, ext_map[_EL(level)]);
			qspn_dec_gcount(gcount_counter, level + 1, gnode->gcount);
			gnode->gcount = tracer[i].gcount;
		} else
			node = node_from_pos(tracer[i].node, int_map);

		if (level || (!level && node->flags & MAP_VOID))
			qspn_inc_gcount(gcount_counter, level + 1, tracer[i].gcount);
	}
}

/* 
 * tracer_build_bentry: It builds the bnode_block to be added in the bnode's 
 * entry in the tracer pkt. It stores in `bnodechunk' the pointer to the 
 * first bnode_chunk and returns a pointer to the bnode_hdr.
 * `bnode_hdr' and `bnode_chunk' are on the same block of allocated memory.
 * The number of bnode_chunks is stored in `bnode_links'.
 * On errors it returns a NULL pointer.
 */
bnode_hdr *
tracer_build_bentry(void *void_map, void *void_node,
					quadro_group * node_quadg, bnode_chunk ** bnodechunk,
					int *bnode_links, u_char level)
{
	map_node *int_map, *node;
	map_gnode **ext_map, *gnode;
	map_gnode *gn;
	bnode_hdr *bhdr;
	bnode_chunk *bchunk;
	int i, bm, node_pos;
	size_t bblock_sz;
	u_char lvl;
	char *bblock;
	u_char *bnode_gid;

	int_map = (map_node *) void_map;
	node = (map_node *) void_node;
	ext_map = (map_gnode **) void_map;
	gnode = (map_gnode *) void_node;

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

	if (!level)
		node_pos = pos_from_node(node, int_map);
	else
		node_pos = pos_from_gnode(gnode, ext_map[_EL(level)]);

	bm = map_find_bnode(me.bnode_map[level], me.bmap_nodes[level],
						node_pos);
	if (bm == -1)
		goto error;

	/*This will never happen, but we know the universe is fucking bastard */
	if (!me.bnode_map[level][bm].links)
		goto error;

	bblock_sz = BNODEBLOCK_SZ(level + 1, me.bnode_map[level][bm].links);
	bblock = xzalloc(bblock_sz);

	bhdr = (bnode_hdr *) bblock;
	bhdr->bnode_levels = level + 1;

	bnode_gid = (u_char *) (bblock + sizeof(bnode_hdr));
	bchunk =
		(bnode_chunk *) (bnode_gid + sizeof(u_char) * bhdr->bnode_levels);

	for (i = 0; i < bhdr->bnode_levels; i++)
		bnode_gid[i] = node_quadg->gid[i];

	/* Fill the bnode chunks */
	for (i = 0; i < me.bnode_map[level][bm].links; i++) {
		gn = (map_gnode *) me.bnode_map[level][bm].r_node[i].r_node;
		lvl = extmap_find_level(me.ext_map, gn, me.cur_quadg.levels);

		if (lvl != level + 1)
			continue;

		bchunk[i].gnode = pos_from_gnode(gn, me.ext_map[_EL(lvl)]);
		bchunk[i].level = lvl;
		bchunk[i].rtt = me.bnode_map[level][bm].r_node[i].trtt;

		bhdr->links++;

		debug(DBG_INSANE, "tracer_build_bentry: lvl %d bchunk[%d].gnode:"
			  " %d", level, i, bchunk[i].gnode);
	}

	if (!bhdr->links) {
		xfree(bblock);
		goto error;
	}

	/* Reduce the size of the bblock to its effective size. Initially we 
	 * allocated it considering all the `me.bnode_map[level][bm].links' 
	 * links, but if bhdr->links is lesser than 
	 * me.bnode_map[level][bm].links that means they are not all added in
	 * the chunks.
	 */
	if (bhdr->links < me.bnode_map[level][bm].links) {
		bblock_sz = BNODEBLOCK_SZ(bhdr->bnode_levels, bhdr->links);
		bblock = xrealloc(bblock, bblock_sz);
		bhdr = (bnode_hdr *) bblock;
		bchunk =
			(bnode_chunk *) (bblock + BNODE_HDR_SZ(bhdr->bnode_levels));
	}

	*bnode_links = bhdr->links;
	*bnodechunk = bchunk;
	return bhdr;
  error:
	*bnode_links = 0;
	*bnodechunk = 0;
	return 0;
}

/* 
 * tracer_pkt_build: 
 * It builds a tracer_pkt and stores it in `pkt'.
 * 
 * If `trcr_hdr' or `tracer' are null, it will build a brand new tracer_pkt, 
 * otherwise it will append in the `tracer' the new entry. 
 * Tracer_pkt_build will append also the old bblock: 
 * `old_bblocks' is the number of bblocks, 
 * `old_bblock_buf' is the block of the old bblock and it is `old_bblock_sz' big. 
 * If `old_bblocks' is 0 or `old_bblock_buf' and `old_bblock_sz' are null
 * they are ignored.
 * 
 * The `pkt.hdr.op' is set to `rq', `pkt.hdr.id' to `rq_id' and the 
 * `bcast_hdr.sub_id' to `bcast_sub_id'.
 * 
 * The packet shall be sent with flood_pkt_send.
 * It returns -1 on errors. 
 */
int
tracer_pkt_build(u_char rq, int rq_id, int bcast_sub_id,
				 int gnode_id, u_char gnode_level,
				 brdcast_hdr * bcast_hdr, tracer_hdr * trcr_hdr,
				 tracer_chunk * tracer, u_short old_bblocks,
				 char *old_bblock_buf, size_t old_bblock_sz, PACKET * pkt)
{
	brdcast_hdr bh;
	tracer_hdr th;

	tracer_chunk *new_tracer = 0;
	bnode_hdr *new_bhdr = 0;
	bnode_chunk *new_bchunk = 0;
	map_node *root_node, *upper_root_node = 0;
	char *igw_pack = 0;
	void *void_map, *void_node, *p;
	size_t new_bblock_sz = 0, total_bblock_sz = 0, igw_pack_sz = 0;
	u_int hops = 0;
	int new_bblock_links = 0, new_bblocks = 0, tot_new_bblocks =
		0, tot_bblocks = 0;

	if (!trcr_hdr || !tracer || !bcast_hdr) {
		/* Brand new tracer packet */
		bcast_hdr = &bh;
		setzero(bcast_hdr, sizeof(brdcast_hdr));

		bcast_hdr->gttl = MAXGROUPNODE - 1;
		bcast_hdr->level = gnode_level + 1;
		bcast_hdr->g_node = gnode_id;

		trcr_hdr = &th;
		setzero(trcr_hdr, sizeof(tracer_hdr));
	}

	hops = trcr_hdr->hops;

	setzero(pkt, sizeof(PACKET));
	pkt->hdr.op = rq;
	pkt->hdr.id = rq_id;
	pkt->hdr.flags |= BCAST_PKT;
	bcast_hdr->flags |= BCAST_TRACER_PKT;

	if (!gnode_level) {
		void_map = (void *) me.int_map;
		root_node = me.cur_node;
		void_node = (void *) root_node;
	} else {
		void_map = (void *) me.ext_map;
		root_node = &me.cur_quadg.gnode[_EL(gnode_level)]->g;
		void_node = (void *) root_node;
	}

	if (gnode_level < me.cur_quadg.levels)
		upper_root_node = &me.cur_quadg.gnode[_EL(gnode_level + 1)]->g;


	/* 
	 * Time to append our entry in the tracer_pkt 
	 */
	new_tracer = tracer_add_entry(void_map, void_node, tracer, &hops,
								  gnode_level);
	if (!new_tracer) {
		debug(DBG_NOISE, "tracer_pkt_build: Cannot add the new"
			  " entry in the tracer_pkt");
		return -1;
	}
	if (rq == QSPN_OPEN && !trcr_hdr->first_qspn_open_chunk)
		trcr_hdr->first_qspn_open_chunk = hops;

	/* If we are a bnode we have to append the bnode_block too. */
	if (me.cur_node->flags & MAP_BNODE &&
		gnode_level < me.cur_quadg.levels - 1 &&
		upper_root_node->flags & MAP_BNODE) {

		new_bhdr = tracer_build_bentry(void_map, void_node, &me.cur_quadg,
									   &new_bchunk, &new_bblock_links,
									   gnode_level);
		if (new_bhdr) {
			tot_new_bblocks = 1;
			new_bblock_sz = BNODEBLOCK_SZ(new_bhdr->bnode_levels,
										  new_bblock_links);

			bcast_hdr->flags |= BCAST_TRACER_BBLOCK;
			trcr_hdr->flags |= TRCR_BBLOCK;
		}
	}

	if (restricted_mode &&
		((!gnode_level && server_opt.share_internet && me.inet_connected)
		 || (gnode_level && me.igws_counter[gnode_level - 1]))) {

		igw_pack =
			igw_build_bentry(gnode_level, &igw_pack_sz, &new_bblocks);

		/* Append the igw_pack after the new bblock */
		if (igw_pack) {
			total_bblock_sz = new_bblock_sz + igw_pack_sz;
			new_bhdr = xrealloc(new_bhdr, total_bblock_sz);

			tot_new_bblocks += new_bblocks;

			bcast_hdr->flags |= BCAST_TRACER_BBLOCK;
			trcr_hdr->flags |= TRCR_IGW;

			p = (char *) new_bhdr + new_bblock_sz;
			memcpy(p, igw_pack, igw_pack_sz);
		}

		new_bblock_sz += igw_pack_sz;
	}

	/*
	 * If in the old tracer_pkt is present a bblock, we append it after the 
	 * new entry.
	 */
	if (old_bblocks && old_bblock_buf && old_bblock_sz) {
		total_bblock_sz = new_bblock_sz + old_bblock_sz;
		new_bhdr = xrealloc(new_bhdr, total_bblock_sz);

		p = (char *) new_bhdr + new_bblock_sz;
		memcpy(p, old_bblock_buf, old_bblock_sz);

		bcast_hdr->flags |= BCAST_TRACER_BBLOCK;

		new_bblock_sz += old_bblock_sz;
	}

	tot_bblocks = tot_new_bblocks + old_bblocks;

	/* 
	 * Here we are really building the pkt, packing all the stuff into a
	 * single bullet.
	 */
	trcr_hdr->hops = hops;
	bcast_hdr->sub_id = bcast_sub_id;
	bcast_hdr->sz = TRACERPKT_SZ(hops) + new_bblock_sz;
	pkt->hdr.sz = BRDCAST_SZ(bcast_hdr->sz);
	pkt_addcompress(pkt);
	pkt_addtimeout(pkt, TRACER_RQ_TIMEOUT, 0, 1);
	pkt_addnonblock(pkt);

	pkt->msg = tracer_pack_pkt(bcast_hdr, trcr_hdr, new_tracer,
							   (char *) new_bhdr, new_bblock_sz,
							   tot_bblocks);

	/* Yea, finished */
	if (new_tracer)
		xfree(new_tracer);
	if (new_bhdr)
		xfree(new_bhdr);
	return 0;
}

/* 
 * tracer_pack_pkt: it packs the tracer packet.
 * 
 * If `new_bblocks' isn't zero, the first `new_bblocks'# bblocks contained in
 * `bblocks' are converted to network order.
 */
char *
tracer_pack_pkt(brdcast_hdr * bcast_hdr, tracer_hdr * trcr_hdr,
				tracer_chunk * tracer, char *bblocks, size_t bblocks_sz,
				int new_bblocks)
{
	bnode_hdr *bhdr;
	bnode_chunk *bchunk;
	size_t pkt_sz;
	char *msg, *buf;
	int i, e;

	pkt_sz = BRDCAST_SZ(TRACERPKT_SZ(trcr_hdr->hops) + bblocks_sz);

	buf = msg = xzalloc(pkt_sz);

	/* add broadcast header */
	memcpy(buf, bcast_hdr, sizeof(brdcast_hdr));
	ints_host_to_network(buf, brdcast_hdr_iinfo);
	buf += sizeof(brdcast_hdr);

	/* add the tracer header */
	memcpy(buf, trcr_hdr, sizeof(tracer_hdr));
	ints_host_to_network(buf, tracer_hdr_iinfo);
	buf += sizeof(tracer_hdr);

	/* add the tracer chunks and convert them to network order */
	for (i = 0; i < trcr_hdr->hops; i++) {
		memcpy(buf, &tracer[i], sizeof(tracer_chunk));
		ints_host_to_network(buf, tracer_chunk_iinfo);

		buf += sizeof(tracer_chunk);
	}

	/* add the bnode blocks */
	if (bblocks_sz && bblocks) {
		/* copy the whole block */
		memcpy(buf, bblocks, bblocks_sz);

		/* and convert it to network order */
		for (e = 0; e < new_bblocks; e++) {
			bhdr = (bnode_hdr *) buf;
			bchunk = (bnode_chunk *) ((char *) buf + sizeof(bnode_hdr) +
									  sizeof(u_char) * bhdr->bnode_levels);

			for (i = 0; i < bhdr->links; i++)
				ints_host_to_network(&bchunk[i], bnode_chunk_iinfo);

			buf += BNODEBLOCK_SZ(bhdr->bnode_levels, bhdr->links);
			ints_host_to_network(bhdr, bnode_hdr_iinfo);
		}
	}

	return msg;
}

/* 
 * tracer_unpack_pkt: Given a packet `rpkt' it scomposes the rpkt.msg in 
 * `new_bcast_hdr', `new_tracer_hdr', `new_tracer', 'new_bhdr', and 
 * `new_block_sz'.
 * If the `new_rip_quadg' pointer is not null, the quadro_group of the 
 * `rpk.from' ip is stored in it.
 * It returns 0 if the packet is valid, otherwise -1 is returned.
 * Note that rpkt.msg will be modified during the unpacking.
 */
int
tracer_unpack_pkt(PACKET rpkt, brdcast_hdr ** new_bcast_hdr,
				  tracer_hdr ** new_tracer_hdr, tracer_chunk ** new_tracer,
				  bnode_hdr ** new_bhdr, size_t * new_bblock_sz,
				  quadro_group * new_rip_quadg, int *real_from_rpos)
{
	brdcast_hdr *bcast_hdr;
	tracer_hdr *trcr_hdr;
	tracer_chunk *tracer;
	bnode_hdr *bhdr = 0;
	quadro_group rip_quadg;
	size_t bblock_sz = 0, tracer_sz = 0;
	int level, i;

	bcast_hdr = BRDCAST_HDR_PTR(rpkt.msg);
	ints_network_to_host(bcast_hdr, brdcast_hdr_iinfo);

	trcr_hdr = TRACER_HDR_PTR(rpkt.msg);
	ints_network_to_host(trcr_hdr, tracer_hdr_iinfo);

	tracer = TRACER_CHUNK_PTR(rpkt.msg);

	*new_bcast_hdr = 0;
	*new_tracer_hdr = 0;
	*new_tracer = 0;
	*new_bhdr = 0;
	*new_bblock_sz = 0;
	*real_from_rpos = 0;

	tracer_sz = BRDCAST_SZ(TRACERPKT_SZ(trcr_hdr->hops));
	if (tracer_sz > rpkt.hdr.sz || !trcr_hdr->hops ||
		trcr_hdr->hops > MAXGROUPNODE) {
		debug(DBG_INSANE, "%s:%d messed tracer pkt: %d, %d, %d",
			  ERROR_POS, tracer_sz, rpkt.hdr.sz, trcr_hdr->hops);
		return -1;
	}

	if (rpkt.hdr.op == QSPN_CLOSE)
		/* It can be non-zero only if it is a QSPN_OPEN */
		trcr_hdr->first_qspn_open_chunk = 0;

	/* Convert the tracer chunks to host order */
	for (i = 0; i < trcr_hdr->hops; i++)
		ints_network_to_host(&tracer[i], tracer_chunk_iinfo);

	if (rpkt.hdr.sz > tracer_sz) {
		/* There is also a bnode block in the tracer pkt */

		bblock_sz = rpkt.hdr.sz - tracer_sz;
		bhdr = (bnode_hdr *) (rpkt.msg + tracer_sz);
		if ((!(trcr_hdr->flags & TRCR_BBLOCK)
			 && !(trcr_hdr->flags & TRCR_IGW))
			|| !(bcast_hdr->flags & BCAST_TRACER_BBLOCK)) {
			debug(DBG_INSANE, ERROR_MSG "trcr_flags: %d flags: %d",
				  ERROR_POS, trcr_hdr->flags, bcast_hdr->flags);
			return -1;
		}
	}

	if ((level = bcast_hdr->level) > 0)
		level--;
	if (!(rpkt.hdr.flags & BCAST_PKT)
		|| !(bcast_hdr->flags & BCAST_TRACER_PKT) || level > FAMILY_LVLS) {
		debug(DBG_INSANE, "%s:%d", ERROR_POS);
		return -1;
	}

	/* Convert the ip in quadro_group */
	iptoquadg(rpkt.from, me.ext_map, &rip_quadg, QUADG_GID | QUADG_GNODE);
	memcpy(new_rip_quadg, &rip_quadg, sizeof(quadro_group));

	if (tracer_verify_pkt
		(tracer, trcr_hdr->hops, rpkt.from, &rip_quadg, level))
		return -1;

	*real_from_rpos = ip_to_rfrom(rpkt.from, &rip_quadg, 0, 0);
	if (*real_from_rpos < 0) {
		debug(DBG_INSANE, "%s:%d", ERROR_POS);
		return -1;
	}


	*new_bcast_hdr = bcast_hdr;
	*new_tracer_hdr = trcr_hdr;
	*new_tracer = tracer;
	*new_bhdr = bhdr;
	*new_bblock_sz = bblock_sz;
	return 0;
}

/* 
 * tracer_split_bblock: It searches from bnode_block_start to 
 * bnode_block_start+bblock_sz for bnode blocks.
 * It puts the address of the found bblock_hdr in the `bbl_hdr' (bnode block list)
 * and the address pointing to the start of the bnode_chunk in the `bbl'. The 
 * total size of all the valid bblocks considered is stored in `*bblock_found_sz'.
 * It then returns the number of bblocks found. 
 * 
 * During the splitting the bblock is modified 'cause it is converted in host
 * order.
 * Remember to xfree bbl_hdr and bbl after using tracer_split_bblock too. 
 * On error zero is returned.
 */
u_short
tracer_split_bblock(void *bnode_block_start, size_t bblock_sz,
					bnode_hdr *** bbl_hdr, bnode_chunk **** bbl,
					size_t * bblock_found_sz)
{
	bnode_hdr *bblock_hdr;
	bnode_chunk *bblock;
	bnode_hdr **bblist_hdr = 0;
	bnode_chunk ***bblist = 0;
	u_char *bnode_gid;
	size_t bsz = 0;
	int loop, e, p, x = 0;

	*bblock_found_sz = 0;
	if (!bblock_sz)
		return 0;

	for (loop = 0; loop <= 1; loop++) {
		/*
		 * The second `for' below acts in different ways for different
		 * values of `loop'.
		 * When `loop' == 0 it just counts how many valid bblocks there 
		 * are, then it allocs the right amount of memory for
		 * `bblist_hdr' and `bblist'.
		 * When `loop' == 1 it fills the `bblist_hdr' and `bblist'
		 * arrays.
		 *
		 * If we use just one loop we are forced to xrealloc
		 * `bblist_hdr' and `bblist' many times, because we don't know
		 * how many bblocks thereare. The malloc operation are slow,
		 * therefore to use only one xmalloc we prefer to count first.
		 */

		for (e = 0, x = 0; e < bblock_sz;) {
			bblock_hdr = (void *) ((char *) bnode_block_start + e);
			if (!loop)
				ints_network_to_host(bblock_hdr, bnode_hdr_iinfo);

			bnode_gid = (u_char *) bblock_hdr + sizeof(bnode_hdr);
			bblock = (bnode_chunk *) ((char *) bnode_gid +
									  (bblock_hdr->bnode_levels *
									   sizeof(u_char)));

			if (bblock_hdr->links <= 0
				|| bblock_hdr->links >= MAXGROUPNODE) {
				e += BNODEBLOCK_SZ(bblock_hdr->bnode_levels, 0);
				continue;
			}

			bsz =
				BNODEBLOCK_SZ(bblock_hdr->bnode_levels, bblock_hdr->links);

			/*Are we going far away the end of the buffer? */
			if (bblock_sz - e < bsz)
				break;

			if (loop) {
				bblist_hdr[x] = bblock_hdr;
				bblist[x] =
					xmalloc(sizeof(bnode_chunk *) * bblock_hdr->links);
				for (p = 0; p < bblock_hdr->links; p++) {
					bblist[x][p] = &bblock[p];
					ints_network_to_host(&bblock[p], bnode_chunk_iinfo);
				}
			}

			if (!loop)
				(*bblock_found_sz) += bsz;

			x++;
			e += bsz;
		}

		if (!loop) {
			if (!x)
				return 0;

			bblist_hdr = xmalloc(sizeof(bnode_hdr *) * x);
			bblist = xmalloc(sizeof(bnode_chunk *) * x);
		}
	}

	*bbl_hdr = bblist_hdr;
	*bbl = bblist;
	return x;
}

/*
 * tracer_store_bblock: stores in the bnode map the chunks of the bblock
 * starting at `bnode_block_start'.
 * In `*bblocks_found' it stores the number of bblocks considered and stores in
 * `bblocks_found_block' these bblocks. The `bblocks_found_block' remains in 
 * host order.
 * Remember to xfree(bblocks_found_block);
 * On error -1 is returned.
 */
int
tracer_store_bblock(u_char level, tracer_hdr * trcr_hdr,
					tracer_chunk * tracer, void *bnode_block_start,
					size_t bblock_sz, u_short * bblocks_found,
					char **bblocks_found_block, size_t * bblock_found_sz)
{
	map_node *node;
	map_gnode *gnode;

	bnode_hdr **bblist_hdr = 0;
	bnode_chunk ***bblist = 0;
	map_rnode rn;
	int i, e, o, f, p, bm, igws_found = 0;
	u_short bb;
	size_t found_block_sz, bsz, x;
	char *found_block;
	u_char *bnode_gid, bnode, blevel;

	/*
	 * Split the block
	 */
	bb = tracer_split_bblock(bnode_block_start, bblock_sz, &bblist_hdr,
							 &bblist, &found_block_sz);
	*bblocks_found = bb;
	if (!bb) {
		/* The bblock was malformed -_- */
		debug(DBG_NORMAL, ERROR_MSG "malformed bnode block", ERROR_POS);
		*bblock_found_sz = 0;
		*bblocks_found_block = 0;
		return -1;
	}

	/*
	 * Store the received bnode blocks 
	 */

	igws_found = x = 0;
	*bblocks_found_block = found_block = xmalloc(found_block_sz);
	for (i = 0; i < bb; i++) {

		bnode_gid = (u_char *) bblist_hdr[i] + sizeof(bnode_hdr);

		/* We update only the bmaps which are at
		 * levels where our gnodes are in common with
		 * those of the bnode, which sent us this
		 * bblock */
		for (o = level, f = 0; o >= 0; o--)
			if (bnode_gid[o] != me.cur_quadg.gid[o]) {
				f = 1;
				break;
			}
		if (!f) {
			/*
			 * bnode_gid is equal to me.cur_quadg.gid, so this 
			 * bnode block was sent by ourself, skip it. 
			 */

			debug(DBG_NORMAL, ERROR_MSG "skipping the %d bnode,"
				  "it was built by us!", ERROR_POS, i);
			goto discard_bblock;
		}

		/*
		 * Check if this bblock is an IGW. If it is, store it in
		 * me.igws
		 */
		if (bblist[i][0]->level >= FAMILY_LVLS + 1) {
			if (restricted_mode &&
				(igws_found < MAX_IGW_PER_QSPN_CHUNK &&
				 trcr_hdr->flags & TRCR_IGW)) {

				if (server_opt.use_shared_inet)
					igw_store_bblock(bblist_hdr[i], bblist[i][0], level);
				igws_found++;

				goto skip_bmap;
			} else {
				debug(DBG_NOISE, ERROR_MSG "Malforded bblock entry",
					  ERROR_POS);
				goto discard_bblock;
			}
		}

		if (!(trcr_hdr->flags & TRCR_BBLOCK)) {
			debug(DBG_NOISE, ERROR_MSG "Malforded bblock entry",
				  ERROR_POS);
			goto discard_bblock;
		}

		for (blevel = o; blevel < bblist_hdr[i]->bnode_levels; blevel++) {
			bnode = bnode_gid[blevel];

			if (!blevel) {
				node = node_from_pos(bnode, me.int_map);
				node->flags |= MAP_BNODE;
				node->flags &= ~QSPN_OLD;
			} else {
				gnode = gnode_from_pos(bnode, me.ext_map[_EL(blevel)]);
				gnode->g.flags |= MAP_BNODE;
				gnode->g.flags &= ~QSPN_OLD;
			}

			/* Let's check if we have this bnode in the bmap, if not let's 
			 * add it */
			bm = map_find_bnode(me.bnode_map[blevel],
								me.bmap_nodes[blevel], bnode);
			if (bm == -1)
				bm = map_add_bnode(&me.bnode_map[blevel],
								   &me.bmap_nodes[blevel], bnode, 0);

			/* This bnode has the BMAP_UPDATE
			 * flag set, thus this is the first
			 * time we update him during this new
			 * qspn_round and for this reason
			 * delete all its rnodes */
			if (me.bnode_map[blevel][bm].flags & BMAP_UPDATE) {
				rnode_destroy(&me.bnode_map[blevel][bm]);
				me.bnode_map[blevel][bm].flags &= ~BMAP_UPDATE;
			}

			/* Store the rnodes of the bnode */
			for (e = 0; e < bblist_hdr[i]->links; e++) {
				setzero(&rn, sizeof(map_rnode));
				debug(DBG_INSANE, "Bnode %d new link %d: gid %d lvl %d",
					  bnode, e, bblist[i][e]->gnode, bblist[i][e]->level);

				gnode = gnode_from_pos(bblist[i][e]->gnode,
									   me.
									   ext_map[_EL(bblist[i][e]->level)]);
				gnode->g.flags &= ~QSPN_OLD;

				rn.r_node = (int *) gnode;
				rn.trtt = bblist[i][e]->rtt;

				if ((p = rnode_find(&me.bnode_map[blevel][bm], gnode)) > 0) {
					/* Overwrite the current rnode */
					map_rnode_insert(&me.bnode_map[blevel][bm], p, &rn);
				} else
					/* Add a new rnode */
					rnode_add(&me.bnode_map[blevel][bm], &rn);
			}
		}
	  skip_bmap:
		/* Copy the found bblock in `bblocks_found_block' and converts
		 * it in network order */
		bsz =
			BNODEBLOCK_SZ(bblist_hdr[i]->bnode_levels,
						  bblist_hdr[i]->links);
		memcpy(found_block + x, bblist_hdr[i], bsz);
		x += bsz;
	  discard_bblock:
		xfree(bblist[i]);
	}

	*bblock_found_sz = x;

	xfree(bblist_hdr);
	xfree(bblist);

	return 0;
}

/*
 * tracer_check_node_collision: if a collision is detected between me and the
 * (g)node `node', new_rehook shall be called and 1 returned.
 * `tr_node' is the gid of `node'.
 */
int
tracer_check_node_collision(tracer_hdr * trcr, int hop, map_node * node,
							int tr_node, int tr_gcount, int level)
{
	map_gnode *gnode;
	int probable_collision = 0;
	u_int gcount;
	map_node *root_node;

	gnode = (map_gnode *) node;
	if (!level) {
		gcount = 0;
		root_node = me.cur_node;
	} else {
		gcount = tr_gcount;
		root_node = &me.cur_quadg.gnode[_EL(level)]->g;
	}

	if (node == root_node &&
		((trcr->first_qspn_open_chunk &&
		  !((trcr->first_qspn_open_chunk - 1 == hop &&
			 (root_node->flags & QSPN_OPENER)) ||
			(hop < trcr->first_qspn_open_chunk - 1)
		  )
		 ) ||
		 (!trcr->first_qspn_open_chunk &&
		  !(!hop && (root_node->flags & QSPN_STARTER))
		 )
		)
		)
		probable_collision = 1;

	if (probable_collision) {
		loginfo("%s collision detected! Checking rehook status...",
				!level ? "node" : "gnode");
		debug(DBG_NORMAL, "collision info: i: %d, starter %d opener %d",
			  hop, me.cur_node->flags & QSPN_STARTER,
			  me.cur_node->flags & QSPN_OPENER);
		new_rehook(gnode, tr_node, level, gcount);

		return 1;
	}

	return 0;
}

/* 
 * tracer_store_pkt: This is the main function used to keep the int/ext_map's
 * karma in peace.
 * It updates the internal or external map with the given tracer pkt.
 *
 * `rip' is the rnode ip. It is the last node who forwarded the tracer pkt to
 * us. `rip_quadg' is a quadro_group struct related to it.
 *
 * `trcr_hdr' is the header of the tracer pkt, while `tracer' points at the
 * start of its body.
 * 
 * The bnode blocks (if any) are unpacked and used to update the data of the
 * bordering gnodes. Read the tracer_store_bblock() description (above) to 
 * know the meaning of the other arguments.
 */
int
tracer_store_pkt(inet_prefix rip, quadro_group * rip_quadg, u_char level,
				 tracer_hdr * trcr_hdr, tracer_chunk * tracer,
				 void *bnode_block_start, size_t bblock_sz,
				 u_short * bblocks_found, char **bblocks_found_block,
				 size_t * bblock_found_sz)
{
	map_node *from, *node, *root_node;
	map_gnode *gfrom, *gnode = 0;
	map_rnode rnn;

	int i, e, x, f, diff, from_rnode_pos, skip_rfrom;
	int gfrom_rnode_pos, from_tpos;
	u_int hops, trtt_ms = 0;


	hops = trcr_hdr->hops;
	/* Nothing to store */
	if (hops <= 0)
		return 0;

	from_tpos = hops - 1;
	if (!level) {
		from = node_from_pos(tracer[from_tpos].node, me.int_map);
		root_node = me.cur_node;
	} else {
		gfrom =
			gnode_from_pos(tracer[from_tpos].node, me.ext_map[_EL(level)]);
		from = &gfrom->g;
		root_node = &me.cur_quadg.gnode[_EL(level)]->g;
	}
	from_rnode_pos = rnode_find(root_node, from);

	/* It's alive, keep it young */
	from->flags &= ~QSPN_OLD;

	if (bblock_sz && level != me.cur_quadg.levels - 1) {
		/* Well, well, we have to take care of bnode blocks, split the
		 * bblock. */
		tracer_store_bblock(level, trcr_hdr, tracer, bnode_block_start,
							bblock_sz, bblocks_found, bblocks_found_block,
							bblock_found_sz);
	}

	/* 
	 * * Store the qspn routes to reach all the nodes of the tracer pkt *
	 */

	skip_rfrom = 0;
	node = root_node;
	if (!level) {
		/* We skip the node at hops-1 which it is the `from' node. The radar() 
		 * takes care of him. */
		skip_rfrom = 1;
	} else if (from == root_node) {
		/* If tracer[hops-1].node is our gnode then we can skip it */
		skip_rfrom = 1;
		from_tpos = hops - 2;
		from_rnode_pos = ip_to_rfrom(rip, rip_quadg, 0, 0);

		if (hops > 1) {
			map_rnode rnn;

			/* 
			 * hops-2 is an rnode of hops-1, which is our gnode,
			 * so we update the `gfrom' and `from' vars and let
			 * them point to hops-2.
			 */
			gfrom = gnode_from_pos(tracer[hops - 2].node,
								   me.ext_map[_EL(level)]);
			from = &gfrom->g;
			from->flags |= MAP_GNODE | MAP_RNODE;

			gfrom_rnode_pos = rnode_find(root_node, gfrom);
			if (gfrom_rnode_pos == -1) {
				gfrom_rnode_pos = root_node->links;

				/*
				 * Add an rnode in the root_node which point to
				 * `gfrom', because it is our new (g)rnode.
				 */
				setzero(&rnn, sizeof(map_rnode));
				rnn.r_node = (int *) gfrom;
				rnode_add(root_node, &rnn);
			}
			root_node->r_node[gfrom_rnode_pos].trtt = tracer[hops - 2].rtt;
		}

		/* we are using the real from, so the root node is the one
		 * at level 0 */
		node = me.cur_node;
	} else if (me.cur_node->flags & MAP_BNODE) {
		/* If we are a bnode which borders on the `from' [g]node, then we
		 * can skip it. */
		i = map_find_bnode_rnode(me.bnode_map[level - 1],
								 me.bmap_nodes[level - 1], from);
		if (i != -1)
			skip_rfrom = 1;
	}

	if (from_tpos >= 0) {		/* Is there a rnode in the tracer ? */

		/* Update `qspn_gnode_count' */
		tracer_update_gcount(trcr_hdr, tracer, from_tpos,
							 qspn_gnode_count, me.int_map, me.ext_map,
							 level);

		/* Let's see if we have to rehook */
		new_rehook((map_gnode *) from, tracer[from_tpos].node, level,
				   tracer[from_tpos].gcount);
	}

	/* We add in the total rtt the first rtt which is me -> from */
	trtt_ms = node->r_node[from_rnode_pos].trtt;

	/* If we are skipping the rfrom, remember to sum its rtt */
	if (skip_rfrom)
		trtt_ms += tracer[hops - 1].rtt;

	for (i = (hops - skip_rfrom) - 1; i >= 0; i--) {
		if (i)
			trtt_ms += tracer[i].rtt;

		if (!level)
			node = node_from_pos(tracer[i].node, me.int_map);
		else {
			gnode = gnode_from_pos(tracer[i].node, me.ext_map[_EL(level)]);
			node = &gnode->g;

			if (tracer[i].gcount == NODES_PER_LEVEL(level))
				/* The gnode is full */
				gnode->g.flags |= GMAP_FULL;
		}

		if (tracer_check_node_collision(trcr_hdr, i, node, tracer[i].node,
										tracer[i].gcount, level))
			break;

		node->flags &= ~QSPN_OLD;

		if (node->flags & MAP_VOID) {
			/* Ehi, we hadn't this node in the map. Add it. */
			node->flags &= ~MAP_VOID;
			node->flags |= MAP_UPDATE;
			if (level)
				gnode->flags &= ~GMAP_VOID;

			gnode_inc_seeds(&me.cur_quadg, level);
			debug(DBG_INSANE, "TRCR_STORE: node %d added", tracer[i].node);
		}

		/* update the rtt of the node */
		for (e = 0, f = 0; e < node->links; e++) {
			if (node->r_node[e].r_node == (int *) from) {
				diff = abs(node->r_node[e].trtt - trtt_ms);
				if (diff >= RTT_DELTA) {
					node->r_node[e].trtt = trtt_ms;
					node->flags |= MAP_UPDATE;
				}
				f = 1;
				break;
			}
		}
		if (!f) {
			/*If the `node' doesn't have `from' in his r_nodes... let's add it */
			setzero(&rnn, sizeof(map_rnode));

			rnn.r_node = (int *) from;
			rnn.trtt = trtt_ms;

			rnode_add(node, &rnn);
			node->flags |= MAP_UPDATE;
		}

		/* ok, now the kernel needs a refresh of the routing table */
		if (node->flags & MAP_UPDATE) {
			rnode_trtt_order(node);

			if (node->links > MAXROUTES) {
				/* 
				 * If we have too many routes we purge the worst
				 * ones.
				 */
				for (x = MAXROUTES; x < node->links; x++)
					rnode_del(node, x);
			}

			debug(DBG_INSANE, "TRCR_STORE: krnl_update node %d",
				  tracer[i].node);
			rt_update_node(0, node, 0, 0, 0, level);
			node->flags &= ~MAP_UPDATE;
		}
	}
	return 0;
}


/* 
 * flood_pkt_send: This functions is used to propagate packets, in a broadcast
 * manner, in a entire gnode of a specified level.
 * It sends the `pkt' to all the nodes excluding the excluded nodes. It knows 
 * if a node is excluded by calling the `is_node_excluded' function. The 
 * second argument to this function is the node who sent the pkt and it must be
 * always excluded. The third argument is the position of the node being processed
 * in the r_node array of me.cur_node. The other arguments are described in
 * tracer.h.
 * If `is_node_excluded' returns a non 0 value, the node is considered as excluded.
 * The `from_rpos' argument is the node who sent the `pkt'.
 * It returns the number of pkts sent or -1 on errors. Note that the total pkt sent
 * should be == me.cur_node->links-the_excluded_nodes.
 * Note that `level', `sub_id', and `from_rpos' are vars used only by
 * is_node_excluded() (see tracer.h).
 */
int
flood_pkt_send(int (*is_node_excluded) (TRACER_PKT_EXCLUDE_VARS),
			   u_char level, int sub_id, int from_rpos, PACKET pkt)
{
	ext_rnode *e_rnode;
	map_node *dst_node, *node;

	ssize_t err;
	const char *ntop;
	int i, e = 0;

	/*
	 * Forward the pkt to all our r_nodes (excluding the excluded;)
	 */
	for (i = 0; i < me.cur_node->links; i++) {
		node = (map_node *) me.cur_node->r_node[i].r_node;
		if (node->flags & MAP_ERNODE) {
			e_rnode = (ext_rnode *) node;
			dst_node = (map_node *) e_rnode->quadg.gnode[_EL(level - 1)];
		} else {
			e_rnode = 0;
			dst_node = node;
		}

		if (!dst_node)
			continue;
		if (is_node_excluded
			(e_rnode, dst_node, from_rpos, i, level, sub_id))
			continue;

		/* Get the socket associated to the rnode  */
		if (rnl_fill_rq(node, &pkt) < 0)
			continue;
		if (server_opt.dbg_lvl)
			debug(DBG_INSANE, "flood_pkt_send(0x%x): %s to %s"
				  " lvl %d", pkt.hdr.id,
				  rq_to_str(pkt.hdr.op), inet_to_str(pkt.to), level - 1);

		/* Let's send the pkt */
		err = rnl_send_rq(node, &pkt, 0, pkt.hdr.op, pkt.hdr.id, 0, 0, 0);
		if (err == -1) {
			ntop = inet_to_str(pkt.to);
			error(ERROR_MSG "Cannot send the %s request"
				  " with id: %d to %s",
				  ERROR_FUNC, rq_to_str(pkt.hdr.op), pkt.hdr.id, ntop);
		} else
			e++;
	}

	pkt_free(&pkt, 0);
	return e;
}

/* * * 	Exclude functions * * *
 * These exclude function are used in conjunction with flood_pkt_send. 
 * They return 1 if the node has to be excluded, otherwise 0.
 */

/*
 * exclude_glevel: Exclude `node' if it doesn't belong to the gid (`excl_gid') of 
 * the level (`excl_level') specified.
 */
int
exclude_glevel(TRACER_PKT_EXCLUDE_VARS)
{
	/* If `node' is null we can exclude it, because it isn't a gnode
	 * of ours levels */
	if (!node)
		return 1;

	/* Ehi, if the node isn't even an external rnode, we don't exclude it. */
	if (!(node->flags & MAP_ERNODE))
		return 0;

	/* Reach the sky */
	if (excl_level == me.cur_quadg.levels)
		return 0;

	return quadg_gids_cmp(e_rnode->quadg, me.cur_quadg, excl_level);
}

/* Exclude the `from' node */
int
exclude_from(TRACER_PKT_EXCLUDE_VARS)
{
	if (pos == from_rpos)
		return 1;
	return 0;
}

/* Exclude all the nodes, except the from node */
int
exclude_all_but_notfrom(TRACER_PKT_EXCLUDE_VARS)
{
	if (!exclude_from(TRACER_PKT_EXCLUDE_VARS_NAME))
		return 1;
	return 0;
}

int
exclude_from_and_glevel(TRACER_PKT_EXCLUDE_VARS)
{
	if (exclude_glevel(TRACER_PKT_EXCLUDE_VARS_NAME) ||
		exclude_from(TRACER_PKT_EXCLUDE_VARS_NAME))
		return 1;
	return 0;
}


/* 
 * tracer_pkt_recv: It receive a TRACER_PKT or a TRACER_PKT_CONNECT, analyzes 
 * the received pkt, adds the new entry in it and forward the pkt to all 
 * the r_nodes.
 */
int
tracer_pkt_recv(PACKET rpkt)
{
	PACKET pkt;
	brdcast_hdr *bcast_hdr;
	tracer_hdr *trcr_hdr;
	tracer_chunk *tracer;
	bnode_hdr *bhdr = 0;
	map_node *from, *tracer_starter, *root_node;
	map_gnode *gfrom;
	quadro_group rip_quadg;

	int (*exclude_function) (TRACER_PKT_EXCLUDE_VARS);
	int ret_err, gid, real_from_rpos;
	u_int hops;
	size_t bblock_sz = 0, old_bblock_sz;
	u_short old_bblocks_found = 0;
	u_char level, orig_lvl;
	const char *ntop = 0;
	char *old_bblock = 0;

	ret_err = tracer_unpack_pkt(rpkt, &bcast_hdr, &trcr_hdr, &tracer,
								&bhdr, &bblock_sz, &rip_quadg,
								&real_from_rpos);
	if (ret_err) {
		ntop = inet_to_str(rpkt.from);
		debug(DBG_NOISE, "tracer_pkt_recv(): The %s sent an invalid "
			  "tracer_pkt here.", ntop);
		return -1;
	}

	hops = trcr_hdr->hops;
	gid = bcast_hdr->g_node;
	level = orig_lvl = bcast_hdr->level;
	if (!level || level == 1) {
		level = 0;
		root_node = me.cur_node;
		from = node_from_pos(tracer[hops - 1].node, me.int_map);
		tracer_starter = node_from_pos(tracer[0].node, me.int_map);
	} else {
		level--;
		root_node = &me.cur_quadg.gnode[_EL(level)]->g;
		gfrom =
			gnode_from_pos(tracer[hops - 1].node, me.ext_map[_EL(level)]);
		from = &gfrom->g;
		tracer_starter =
			(map_node *) gnode_from_pos(tracer[0].node,
										me.ext_map[_EL(level)]);
	}

	if (server_opt.dbg_lvl) {
		ntop = inet_to_str(rpkt.from);
		debug(DBG_NOISE, "Tracer_pkt(0x%x, lvl %d) received from %s",
			  rpkt.hdr.id, level, ntop);
	}

	/*
	 * This is the check for the broadcast id. If it is <= tracer_starter->brdcast
	 * the pkt is an old broadcast that still dance around.
	 */
	if (rpkt.hdr.id <= tracer_starter->brdcast) {
		debug(DBG_NOISE, "tracer_pkt_recv(): Received from %s an old "
			  "tracer_pkt broadcast: 0x%x, cur: 0x%x", ntop,
			  rpkt.hdr.id, tracer_starter->brdcast);
		return -1;
	} else
		tracer_starter->brdcast = rpkt.hdr.id;


	/* 
	 * Time to update our map
	 */
	if (rpkt.hdr.op == TRACER_PKT) {	/*This check is made because tracer_pkt_recv 
										   handles also TRACER_PKT_CONNECT pkts */

		ret_err = tracer_store_pkt(rpkt.from, &rip_quadg, level,
								   trcr_hdr, tracer, (void *) bhdr,
								   bblock_sz, &old_bblocks_found,
								   &old_bblock, &old_bblock_sz);
		if (ret_err) {
			ntop = inet_to_str(rpkt.from);
			debug(DBG_NORMAL, "tracer_pkt_recv(): Cannot store the"
				  " tracer_pkt received from %s", ntop);
		}
	}


	/* 
	 * Drop the pkt if it is bound to the contigual qspn starters and we
	 * aren't a qspn_starter
	 */
	if (bcast_hdr->flags & BCAST_TRACER_STARTERS &&
		!(root_node->flags & QSPN_STARTER))
		return 0;

	/*The forge of the packet. */
	if ((!level || ((me.cur_node->flags & MAP_BNODE) &&
					(root_node->flags & MAP_BNODE))) &&
		from != root_node) {
		tracer_pkt_build(rpkt.hdr.op, rpkt.hdr.id, bcast_hdr->sub_id,	/*IDs */
						 gid, level, bcast_hdr, trcr_hdr, tracer,	/*Received tracer_pkt */
						 old_bblocks_found, old_bblock, old_bblock_sz,	/*bnode_block */
						 &pkt);	/*Where the pkt is built */
	} else {
		/* Increment the rtt of the last gnode chunk */
		ret_err = tracer_add_rtt(real_from_rpos, tracer, hops - 1);
		if (ret_err < 0)
			debug(DBG_NOISE, "tracer_add_rtt(0x%x) hop %d failed",
				  rpkt.hdr.id, hops - 1);
		pkt_copy(&pkt, &rpkt);
		pkt_clear(&pkt);
	}


	/*... forward the tracer_pkt to our r_nodes */
	exclude_function = exclude_from_and_glevel;
	flood_pkt_send(exclude_function, orig_lvl, real_from_rpos,
				   real_from_rpos, pkt);

	if (old_bblock)
		xfree(old_bblock);
	return 0;
}

/* 
 * tracer_pkt_start: It sends only a normal tracer_pkt. This is useful after 
 * the hook, to let all the other nodes know we are alive and to give them 
 * the right route.
 */
int
tracer_pkt_start(u_char level)
{
	PACKET pkt;
	int root_node_pos;

	if (tracer_pkt_start_mutex)
		return 0;
	else
		tracer_pkt_start_mutex = 1;

	if (!level || level == 1) {
		level = 0;
		root_node_pos = pos_from_node(me.cur_node, me.int_map);
	} else
		root_node_pos = pos_from_gnode(me.cur_quadg.gnode[_EL(level)],
									   me.ext_map[_EL(level)]);

	me.cur_node->brdcast++;
	tracer_pkt_build(TRACER_PKT, me.cur_node->brdcast, root_node_pos,	/*IDs */
					 me.cur_quadg.gid[level + 1], level,	/*GnodeID and level */
					 0, 0, 0,	/*Received tracer_pkt */
					 0, 0, 0,	/*bnode_block */
					 &pkt);		/*Where the pkt is built */
	/*Diffuse the packet in all the universe! */
	debug(DBG_INSANE, "Tracer_pkt 0x%x starting.", pkt.hdr.id);
	flood_pkt_send(exclude_from_and_glevel, level + 1, -1, -1, pkt);
	tracer_pkt_start_mutex = 0;
	return 0;
}