/* This file is part of Netsukuku * (c) Copyright 2005 Andrea Lo Pumo aka AlpT * * 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; }