netsukuku/src/igs.h

/* 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.
 */

#ifndef IGS_H
#define IGS_H

#include "route.h"


/*
 * The IGS_MULTI_GW feature relies heavily on netfilter and the linux advanced
 * routing.
 */
#ifdef GNU_LINUX
#define IGS_MULTI_GW
#endif

/*\
 *		 	* Bandwidth notes *
 *
 * When we talk of `bandwidth' we mean the average of the download and 
 * upload bandwidth of a particular node.
 * The bandwidth of a gnode is the average of all the bandwidths of the nodes
 * belonging to that gnode.
 * 
 * Internally we save the `bandwidth' as a u_char variable using the
 * `bandwidth_in_8bit' function (see igs.c)
\*/

/* Minum bandwidth necessary to share an internet connection */
#define MIN_CONN_BANDWIDTH	3		/* 16 Kb/s */

#define MAX_INTERNET_HNAMES	10
#define MAX_INTERNET_HNAME_SZ	64
#define INET_HOST_PING_TIMEOUT	3
#define IGW_HOST_PING_TIMEOUT	10
#define INET_NEXT_PING_WAIT	10

#define IGW_BW_DELTA		1		/* If the difference between the old and the new
						   igw->bandwidth is >= IGW_BW_DELTA, then 
						   me.igws is reordered and the routing table
						   updated */
#define MAXIGWS			MAXGROUPNODE	/* max number of internet 
						   gateways in each level */

#define RTTABLE_IGW		221		/* Routing tables from 221 to 244 */
#define RTTABLE_ALISHIELD	245		/* Anti Loop multi-Igw Shield
						   (what a damn long name, read the Ntk_IGS
						   RFC) */
#define FWMARK_ALISHIELD	25

#ifdef DEBUG
#undef INET_NEXT_PING_WAIT
#define INET_NEXT_PING_WAIT	5
#endif

/* 
 * inet_gw flags
 */
#define IGW_TUNNELED		1
#define IGW_ACTIVE		(1<<1)		/* This gw is being used in the
						   routing table */
#define IGW_RTRULE		(1<<2)		/* The relative routing rule is already
						   present */

/*
 * internet_gateway
 * 
 * This struct points to a particular (g)node which is sharing its Internet 
 * connection
 */
struct internet_gateway
{
	LLIST_HDR	(struct internet_gateway);

	u_int		ip[MAX_IP_INT];
	u_char		gid;
	map_node	*node;

	char		flags;
	u_char		bandwidth;	/* Its Internet bandwidth */
};
typedef struct internet_gateway inet_gw;

/* We pack only `gid' and `bandwidth' */
#define INET_GW_PACK_SZ		(sizeof(u_char)*2 + MAX_IP_SZ)

struct inet_gw_pack_hdr
{
	int16_t		gws[MAX_LEVELS];/* Number of inet_gws there are in the
					   pack, for each level */
	u_char		levels;
}_PACKED_;
INT_INFO inet_gw_pack_hdr_iinfo = { 1, { INT_TYPE_16BIT }, { 0 }, { MAX_LEVELS } };

/* 
 * The inet_gw_pack_body is:
 * 	inet_gw_pack	igw[hdr.gws[i]]	   for all the i that goes from 0 to
 * 					   hdr.levels
 */
#define IGWS_PACK_SZ(hdr)						\
({									\
	size_t _sz; int _pi;						\
	_sz=sizeof(struct inet_gw_pack_hdr);				\
	for(_pi=0; _pi<(hdr)->levels; _pi++)				\
		_sz+=INET_GW_PACK_SZ*((hdr)->gws[_pi]);			\
	_sz;								\
})

#define MAX_IGWS_PACK_SZ(levels)	(sizeof(struct inet_gw_pack_hdr) + \
						INET_GW_PACK_SZ*MAXIGWS*(levels))


/*\
 *
 *  *  *  Multi Internet Gateways  *  *  *
 *
\*/

/*
 * igw_nexthop
 * 
 * The multigw allows the simultaneus use of multiple internet gateways.
 * The multigw requires one routing table and one tunnel for each
 * nexthop in the default multipath route. With an array of `igw_nexthop' we
 * keep track of them.
 */
struct default_inet_gw_nexthop {
	inet_prefix	nexthop;

	u_char		flags;		/* inet_gw flags */
	
	u_char		table;
	u_char		tunl;		/* `tunl' is the number of the tunnel
					   we are using to reach this igw. 
					   (tunl = 4 means we are using the 
					   "tunl4" device) */
};
typedef struct default_inet_gw_nexthop igw_nexthop;


/*\
 * 		Notes on the IGW packed in a qspn pkt
 *
 * The simplest way to tell the other nodes that we are sharing our Internet
 * connection or that in our gnode there is an available gw is to use the
 * bnode block included in the qspn packets.
 * We consider an Internet gw as a bnode connected to a virtual gnode (the
 * Internet), therefore in the relative bnode_chunk we set:
 * 	bchunk.gnode	= 0; this value has no meaning
 *	bchunk.level	= GET_LEVELS(my_family) + 1;
 *	bchunk.rtt	= the bandwidth of the internet connection of the gw.
 *			  It is in the bandwidth_in_8bit() format.
\*/

#define MAX_IGW_PER_QSPN_CHUNK		16	/* Maximum number of IGWs 
						   contained in a single 
						   QSPN chunk */


/*\
 *
 * * *  Globals  * * *
 *
\*/

int active_gws;
igw_nexthop multigw_nh[MAX_MULTIPATH_ROUTES];


/*\
 *
 * * *  Functions declaration  * * 
 *
\*/

u_char bandwidth_in_8bit(u_int x);
int str_to_inet_gw(char *str, inet_prefix *gw, char **dev);
char **parse_internet_hosts(char *str, int *hosts);
void free_internet_hosts(char **hnames, int hosts);

void init_my_igw(void);
void init_igws(inet_gw ***igws, int **igws_counter, int levels);
void reset_igws(inet_gw **igws, int *igws_counter, int levels);
void free_igws(inet_gw **igws, int *igws_counter, int levels);
void init_my_igws(inet_gw **igws, int *igws_counter,
		inet_gw ***my_new_igws, u_char my_bandwidth, 
		map_node *cur_node, quadro_group *qg);
void free_my_igws(inet_gw ***my_igs);
void init_internet_gateway_search(void);
void close_internet_gateway_search(void);
inet_gw *igw_add_node(inet_gw **igws, int *igws_counter,  int level,
		int gid, map_node *node, int ip[MAX_IP_INT], u_char bandwidth);
int igw_del(inet_gw **igws, int *igws_counter, inet_gw *igw, int level);
inet_gw *igw_find_node(inet_gw **igws, int level, map_node *node);
inet_gw *igw_find_ip(inet_gw **igws, int level, u_int ip[MAX_IP_INT]);
int igw_del_node(inet_gw **, int *,  int, map_node *);
void igw_update_gnode_bw(int *, inet_gw **, inet_gw *, int, int, int);
void igw_order(inet_gw **igws, int *igws_counter, inet_gw **my_igws, int level);

int igw_check_inet_conn(void);
void *igw_check_inet_conn_t(void *null);
void *igw_monitor_igws_t(void *null);

int igw_exec_masquerade_sh(char *script, int stop);
int igw_exec_tcshaper_sh(char *script, int stop, 
		char *dev, int upload_bw, int dnload_bw);
void reset_igw_nexthop(igw_nexthop *igwn);
void reset_igw_rules(void);
int igw_replace_def_igws(inet_gw **igws, int *igws_counter, 
		inet_gw **my_igws, int max_levels, int family);

char *igw_build_bentry(u_char level, size_t *pack_sz, int *new_bblocks);
int igw_store_bblock(bnode_hdr *bblock_hdr, bnode_chunk *bchunk, u_char level);
char *pack_igws(inet_gw **igws, int *igws_counter, int levels, int *pack_sz);
int unpack_igws(char *pack, size_t pack_sz,
		map_node *int_map, map_gnode **ext_map, int levels,
		inet_gw ***new_igws, int **new_igws_counter);

#endif /*IGS_H*/