ChronosXYZ/netsukuku
1
0
Fork 0
mirror of https://github.com/ChronosX88/netsukuku.git synced 2024-11-22 18:22:18 +00:00
Code Issues Projects Releases Wiki Activity
6dacd92b5c
netsukuku/src/tracer.c
Kirill Sotnikov f1761cad9a git repo init
2013-09-16 13:53:25 +04:00

1545 lines
42 KiB
C
Raw Blame History

/* 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((u_int)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((u_int)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;
void *void_node;
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;
void_node=(void *)node;
} else {
gnode=gnode_from_pos(bnode, me.ext_map[_EL(blevel)]);
gnode->g.flags|=MAP_BNODE;
gnode->g.flags&=~QSPN_OLD;
void_node=(void *)&gnode->g;
}
/* 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;
void *void_map;
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);
void_map=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)]);
void_map = me.ext_map;
}
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;
}
Reference in New Issue View Git Blame Copy Permalink