netsukuku/src/bmap.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.
 *
 * --
 * bmap.c:
 * Border node map code.
 */

#include "includes.h"

#include "common.h"
#include "inet.h"
#include "endianness.h"
#include "map.h"
#include "gmap.h"
#include "bmap.h"

void bmap_levels_init(u_char levels, map_bnode ***bmap, u_int **bmap_nodes)
{
	*bmap=xmalloc(sizeof(map_bnode *) * levels);
	*bmap_nodes=(u_int *)xmalloc(sizeof(u_int) * levels);

	setzero(*bmap, sizeof(map_bnode *) * levels);
	bmap_counter_reset(levels, *bmap_nodes);
}

void bmap_levels_free(map_bnode **bmap, u_int *bmap_nodes)
{
	xfree(bmap);
	xfree(bmap_nodes);
}

void bmap_counter_init(u_char levels, u_int **bnodes_closed, u_int **bnodes_opened)
{
	*bnodes_closed=(u_int *)xmalloc(sizeof(u_int) * levels);
	*bnodes_opened=(u_int *)xmalloc(sizeof(u_int) * levels);
	
	bmap_counter_reset(levels, *bnodes_closed);
	bmap_counter_reset(levels, *bnodes_opened);
}

void bmap_counter_free(u_int *bnodes_closed, u_int *bnodes_opened)
{
	xfree(bnodes_closed);
	xfree(bnodes_opened);
}

void bmap_counter_reset(u_char levels, u_int *counter)
{
	setzero(counter, sizeof(u_int) * levels);
}

/* 
 * map_add_bnode: It adds a new bnode in the `bmap' and then returns its position
 * in the bmap. It also increments the `*bmap_nodes' counter. The bnode_ptr is set
 * to `bnode' and the links to `links'.
 * Note that the `bmap' argument must be an adress of a pointer.
 */
int map_add_bnode(map_bnode **bmap, u_int *bmap_nodes, u_int bnode, u_int links)
{
	map_bnode *bnode_map;
	u_int bm;
	
	bm=*bmap_nodes; 
	(*bmap_nodes)++;
	if(!bm)
		*bmap=xmalloc(sizeof(map_bnode));
	else
		*bmap=xrealloc(*bmap, sizeof(map_bnode) * *bmap_nodes);

	bnode_map=*bmap;
	setzero(bnode_map, sizeof(map_bnode));
	bnode_map[bm].bnode_ptr=bnode;
	bnode_map[bm].links=links;
	return bm;
}

/* 
 * map_bnode_del: It deletes the `bnode' in the `bmap' which has `bmap_nodes'.
 * It returns the newly rescaled `bmap'.
 * It returns 0 if the `bmap' doesn't exist anymore.*/
map_bnode *map_bnode_del(map_bnode *bmap, u_int *bmap_nodes,  map_bnode *bnode)
{
	map_node_del((map_node *)bnode);
	
	if( ((char *)bnode-(char *)bmap)/sizeof(map_bnode) != (*bmap_nodes)-1 )
		memcpy(bnode, &bmap[*bmap_nodes-1], sizeof(map_bnode));

	(*bmap_nodes)--;
	if(*bmap_nodes)
		return xrealloc(bmap, (*bmap_nodes) * sizeof(map_bnode));
	else {
		*bmap_nodes=0;
		xfree(bmap);
		return 0;
	}
}

/*
 * bmap_del_rnode_by_level: it is pretty specific, it deletes all the rnodes
 * of `bnode' which point to a gnode located in a level not equal to `level'.
 * The number of rnode deleted is returned.
 * `total_levels' must be equal to the maximum levels 
 * available (use FAMILY_LVLS).
 */
int bmap_del_rnode_by_level(map_bnode *bnode, int level, map_gnode **ext_map,
		int total_levels)
{ 
	map_gnode *gn;
	int i, ret=0, lvl;
	
	
	for(i=0; i < bnode->links; i++) {
		gn=(map_gnode *)bnode->r_node[i].r_node;
		lvl=extmap_find_level(ext_map, gn, total_levels);

		if(lvl != level) {
			rnode_del(bnode, i);
			ret++;
		}
	}

	return ret;
}

/* 
 * map_find_bnode: Find the given `node' (in the pos_from_node() format) in the
 * given map_bnode `bmap'.
 */
int map_find_bnode(map_bnode *bmap, int bmap_nodes, int node)
{
	int e;

	for(e=0; e<bmap_nodes; e++)
		if(bmap[e].bnode_ptr == node)
			return e;
	
	return -1;
}

/* 
 * map_find_bnode_rnode: Find the first bnode in the `bmap' which has a rnode
 * which points to `n'. If it is found the pos of the bnode in the `bmap' is
 * returned, otherwise -1 is the return value. 
 */
int map_find_bnode_rnode(map_bnode *bmap, int bmap_nodes, void *n)
{
	int e;

	for(e=0; e<bmap_nodes; e++)
		if(rnode_find((map_node *)&bmap[e], (map_node *)n) != -1)
			return e;

	return -1;
}

/*
 * map_count_bnode_rnode: counts how many bnode which have a rnode which
 * points to `n' there are in `bmap'.
 */
int map_count_bnode_rnode(map_bnode *bmap, int bmap_nodes, void *n)
{
	int e, i;

	for(i=0, e=0; i<bmap_nodes; i++)
		if(rnode_find((map_node *)&bmap[i], (map_node *)n) != -1)
			e++;

	return e;
}

/*
 * bmaps_count_bnode_rnode: applies map_count_bnode_rnode() to each level of
 * `bmap' and returns the sum of the results.
 * `levels' are the total levels of `bmap'.
 */
int bmaps_count_bnode_rnode(map_bnode **bmap, int *bmap_nodes, int levels, void *n)
{
	int i, e;

	for(i=0, e=0; i<levels; i++)
		e+=map_count_bnode_rnode(bmap[i], bmap_nodes[i], n);

	return e;
}

/*
 * map_del_bnode_rnode: deletes all the rnodes of the bnode, present in `bmap',
 * which points to `n' and deletes the bnodes remained empty.
 * `bmap' is the address of the pointer to the bmap.
 * It returns the number of rnodes deleted.
 */
int map_del_bnode_rnode(map_bnode **bmap, int *bmap_nodes, void *n)
{
	map_bnode *bm;
	int e, p, ret=0;

	bm=*bmap;
	for(e=0; e < *bmap_nodes; e++) {
		if((p=rnode_find((map_node *)&bm[e], (map_node *)n)) != -1) {
			rnode_del(&bm[e], p);

			if(!bm[e].links) {
				*bmap=map_bnode_del(*bmap,(u_int*)bmap_nodes, &bm[e]);
				bm=*bmap;
			}
			ret++;
		}
	}

	return ret;
}

/*
 * bmaps_del_bnode_rnode: applies map_del_bnode_rnode() to each level of
 * `bmap'.
 * `levels' are the total levels of `bmap'.
 * It returns the total number of rnodes deleted
 */
int bmaps_del_bnode_rnode(map_bnode **bmap, int *bmap_nodes, int levels, void *n)
{
	int i, e;

	for(i=0, e=0; i<levels; i++)
		e+=map_del_bnode_rnode(&bmap[i], &bmap_nodes[i], n);

	return e;
}

/*
 * map_set_bnode_flag: sets the `flags' to all the `bmap_nodes'# present in
 * `bmap'.
 */
void map_set_bnode_flag(map_bnode *bmap, int bmap_nodes, int flags)
{
	int e;
	for(e=0; e<bmap_nodes; e++)
		bmap[e].flags|=flags;
}

/*
 * bmaps_set_bnode_flag: sets the `flags' to all the bnodes present in the
 * `levels'#  `bmap'.
 */
void bmaps_set_bnode_flag(map_bnode **bmap, int *bmap_nodes, int levels, int flags)
{
	int i;		
	
	for(i=0; i<levels; i++)
		map_set_bnode_flag(bmap[i], bmap_nodes[i], flags);
}

/* 
 * pack_all_bmaps: It creates the block of all the `bmaps' which have
 * `bmap_nodes' nodes. `ext_map' and `quadg' are the structs referring
 * to the external map. In `pack_sz' is stored the size of the block.
 * The address pointing to the block is returned otherwise 0 is given.
 * The package will be in network order.
 */
char *
pack_all_bmaps(map_bnode **bmaps,  u_int *bmap_nodes, map_gnode **ext_map,
		quadro_group quadg, size_t *pack_sz)
{
	struct bnode_maps_hdr bmaps_hdr;
	size_t sz, tmp_sz[BMAP_LEVELS(quadg.levels)];
	char *pack[BMAP_LEVELS(quadg.levels)], *final_pack, *buf;
	u_char level;

	*pack_sz=0;

	for(level=0; level < BMAP_LEVELS(quadg.levels); level++) {
		pack[level]=pack_map((map_node *)bmaps[level], (int *)ext_map[_EL(level+1)], 
				bmap_nodes[level], 0, &sz);
		tmp_sz[level]=sz;
		(*pack_sz)+=sz;
	}

	bmaps_hdr.levels=BMAP_LEVELS(quadg.levels);
	bmaps_hdr.bmaps_block_sz=*pack_sz;
	(*pack_sz)+=sizeof(struct bnode_maps_hdr);
	
	final_pack=xmalloc((*pack_sz));
	memcpy(final_pack, &bmaps_hdr, sizeof(struct bnode_maps_hdr));
	ints_host_to_network(final_pack, bnode_maps_hdr_iinfo);
	
	buf=final_pack+sizeof(struct bnode_maps_hdr);
	for(level=0; level < BMAP_LEVELS(quadg.levels); level++) {
		memcpy(buf, pack[level], tmp_sz[level]);
		buf+=tmp_sz[level];
		xfree(pack[level]);
	}

	return final_pack;
}

/*
 * unpack_all_bmaps: Given a block `pack' of size `pack_sz' containing `levels'
 * it unpacks each bnode map it finds in it. 
 * `ext_map' is the external map used by the new bmaps.  
 * In `bmap_nodes' unpack_all_bmaps stores the address of the newly xmallocated 
 * array of u_int. Each bmap_nodes[x] contains the number of nodes of the bmap 
 * of level x.  
 * `maxbnodes' is the maximum number of nodes each bmap can contain,
 * while `maxbnode_rnodeblock' is the maximum number of rnodes each node can
 * contain.
 * On error 0 is returned.
 * Note: `pack' will be modified during the unpacking.
 */ 
map_bnode **
unpack_all_bmaps(char *pack, u_char max_levels, map_gnode **ext_map, 
		u_int **bmap_nodes, int maxbnodes, int maxbnode_rnodeblock)
{
	struct bnode_maps_hdr *bmaps_hdr;
	struct bnode_map_hdr *bmap_hdr;
	map_bnode **bmap, *unpacked_bmap;
	size_t bblock_sz, pack_sz;
	int i,e=0;
	char *bblock, *buf;
	u_char levels;
	
	bmaps_hdr=(struct bnode_maps_hdr *)pack;
	ints_network_to_host(bmaps_hdr, bnode_maps_hdr_iinfo);

	levels=bmaps_hdr->levels;
	pack_sz=bmaps_hdr->bmaps_block_sz;
	
	if(levels > max_levels || pack_sz < sizeof(struct bnode_maps_hdr))
		return 0;

	bmap_levels_init(levels, &bmap, bmap_nodes);

	buf=pack+sizeof(struct bnode_maps_hdr);
	for(i=0; i<levels; i++) {
		bmap_hdr=(struct bnode_map_hdr *)buf;
		if(!bmap_hdr->bnode_map_sz) {
			buf+=sizeof(struct bnode_map_hdr);
			continue;
		}
		
		/*Extracting the map...*/
		bblock=(char *)bmap_hdr;
		unpacked_bmap=unpack_map(bblock, (int *)ext_map[_EL(i+1)], 0,	
				maxbnodes, maxbnode_rnodeblock);
		if(!unpacked_bmap) {
			error("Cannot unpack the bnode_map at level %d ! Skipping...", i);
			e++;
			continue;
		}

		(*bmap_nodes)[i]=bmap_hdr->bnode_map_sz/MAP_BNODE_PACK_SZ;
		bblock_sz=INT_MAP_BLOCK_SZ(bmap_hdr->bnode_map_sz, bmap_hdr->rblock_sz);

		bmap[i]=unpacked_bmap;

		buf+=bblock_sz;
	}
	
	if(e == levels)
		/* Not a single map was restored */
		return 0;

	return bmap;
}

/* * *  save/load bnode_map * * */

/* 
 * save_bmap: It saves the bnode maps `bmaps' in `file'. The each `bmaps[x]' has
 * `bmap_nodes[x]' nodes. `ext_map' is the pointer to the external map the bmap is
 * referring to.
 */
int save_bmap(map_bnode **bmaps, u_int *bmap_nodes, map_gnode **ext_map, 
		quadro_group quadg, char *file)
{
	FILE *fd;
	char *pack;
	size_t pack_sz;
	
	
	pack=pack_all_bmaps(bmaps, bmap_nodes, ext_map, quadg, &pack_sz);
	if(!pack_sz || !pack)
		return 0;

	if((fd=fopen(file, "w"))==NULL) {
		error("Cannot save the bnode_map in %s: %s", file, strerror(errno));
		return -1;
	}
	fwrite(pack, pack_sz, 1, fd);

	xfree(pack);
	fclose(fd);
	return 0;
}

/*
 * load_bmap: It loads all the bnode maps from `file' and returns the address
 * of the array of pointer to the loaded bmaps. `ext_map' is the external maps
 * the bmap shall refer to. In `bmap_nodes' the address of the u_int array, used
 * to count the nodes in each bmaps, is stored. On error 0 is returned.
 */
map_bnode **load_bmap(char *file, map_gnode **ext_map, u_char max_levels, u_int **bmap_nodes)
{
	map_bnode **bmap=0;
	FILE *fd;
	struct bnode_maps_hdr bmaps_hdr;
	size_t pack_sz;
	u_char levels;
	char *pack=0;
	
	if((fd=fopen(file, "r"))==NULL) {
		error("Cannot load the bmap from %s: %s", file, strerror(errno));
		return 0;
	}
	
	if(!fread(&bmaps_hdr, sizeof(struct bnode_maps_hdr), 1, fd))
		goto finish;
		
	ints_network_to_host(&bmaps_hdr, bnode_maps_hdr_iinfo);
	levels=bmaps_hdr.levels;
	pack_sz=bmaps_hdr.bmaps_block_sz;
	if(levels > max_levels || pack_sz < sizeof(struct bnode_maps_hdr))
		goto finish;

	/* Extracting the map... */
	rewind(fd);
	pack=xmalloc(pack_sz);
	if(!fread(pack, pack_sz, 1, fd))
		goto finish;
	
	bmap=unpack_all_bmaps(pack, max_levels, ext_map, bmap_nodes, 
			MAXGROUPNODE, MAXBNODE_RNODEBLOCK);
	
finish:
	fclose(fd);
	if(pack)
		xfree(pack);
	if(!bmap)
		error("Malformed bmap file. Cannot load the bnode maps.");
	return bmap;
}