netsukuku/src/snsd_cache.h

/* This file is part of Netsukuku
 * (c) Copyright 2006 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 SNSD_H
#define SNSD_H

#include "inet.h"
#include "crypto.h"
#include "endianness.h"
#include "llist.c"

/*
 * SNSD definitions
 */

#define SNSD_MAX_RECORDS		256	/* Number of maximum SNSD records
									   which can be stored in an
									   andna_cache */
#define SNSD_MAX_QUEUE_RECORDS		1	/* There can be only one snsd 
										   record for the queued hnames */
#define SNSD_MAX_REC_SERV		16	/* Maximum records per service */

#define SNSD_ALL_SERVICE		(-1)	/* A service number equal to -1
										   refers to all the available
										   services */
#define SNSD_DEFAULT_SERVICE		0
#define SNSD_DEFAULT_PROTO		1	/* tcp */
#define SNSD_DEFAULT_PRIO		16
#define SNSD_DEFAULT_WEIGHT		1

#define SNSD_WEIGHT(x)			((x) & 0x7f)	/* The snsd weight has to 
												   be <= 127 */

/* Fields used in the syntax for the `snsd_nodes' file:
 * 	hostname:snsd_hostname:service:priority:weight[:pub_key_file]
 */
#define MAX_SNSD_LINE_SZ                (ANDNA_MAX_HNAME_LEN*4)
#define MAX_SNSD_FIELDS			6
#define MIN_SNSD_FIELDS			5

/* * snsd_node flags * */
#define SNSD_NODE_HNAME			1	/* A hname is associated in the 
									   snsd record */
#define SNSD_NODE_IP			(1<<1)	/* An IP is associated in the 
										   snsd record */
#define SNSD_NODE_MAIN_IP		(1<<2)	/* This is the first IP registered 
										   to the hname, it can't be
										   deleted */


/*
 * snsd_node, snsd_service, snsd_prio
 *
 * They are three linked list. They are all orthogonal to each other.
 * The snsd_node llist is inside each snsd_prio struct which is inside each
 * snsd_service struct:
 * || service X          <->   service Y          <->   service Z  <-> ... ||
 *        |		           |			    |
 *        V		           V			    V
 *    snsd_prio_1-->node       snsd_prio_1-->node          ...-->...
 *        |		           |
 *        V		           V
 *    snsd_prio_2-->node	  ...-->node
 *    	  |
 *    	  V
 *    	 ...-->node
 *
 * Using this schema, we don't have to sort them, ever. The nodes are already
 * grouped by service and in each service by priority.
 * 
 * These llist are directly embedded in the andna_cache, lcl_cache and
 * rh_cache.
 * 
 * The andna_cache keeps all the SNSD nodes associated to the registered
 * hostname. The andna_cache doesn't need `snsd_node->pubkey'.
 *
 * The rh_cache stores only records which are of the SNSD_NODE_IP type.
 *
 * When the lcl_cache is saved, its snsd llist is discarded because it is
 * loaded each time from the /etc/netsukuku/snsd_nodes file.
 */
struct snsd_node {
	LLIST_HDR(struct snsd_node);

	u_int record[MAX_IP_INT];	/* It can be the IP or the md5
								   hash of the hname of the 
								   SNSD node */
	RSA *pubkey;				/* pubkey of the snsd_node */
	char flags;					/* This will tell us what 
								   `record' is */

	u_char weight;
};
typedef struct snsd_node snsd_node;
/* In the pack of a snsd_node we don't save the `pubkey' */
#define SNSD_NODE_PACK_SZ		(MAX_IP_SZ+sizeof(char)*2)

struct snsd_prio {
	LLIST_HDR(struct snsd_prio);

	u_char prio;				/* Priority of the SNSD node */

	snsd_node *node;
};
typedef struct snsd_prio snsd_prio;
#define SNSD_PRIO_PACK_SZ		(sizeof(char))

struct snsd_service {
	LLIST_HDR(struct snsd_service);

	u_short service;			/* Service number */
	u_char proto;				/* TCP/UDP, see the `proto_str'
								   static array below */

	snsd_prio *prio;
};
typedef struct snsd_service snsd_service;
#define SNSD_SERVICE_PACK_SZ		(sizeof(u_short)+sizeof(u_char))


/*
 * 
 *  * * * snsd structs package * * *
 *  
 */

struct snsd_node_llist_hdr {
	u_short count;				/* # of snsd_node structs packed 
								   in the body */
} _PACKED_;
INT_INFO snsd_node_llist_hdr_iinfo = { 1, {INT_TYPE_16BIT}, {0}, {1} };

/*
 * the body of the pkt is:
 * 
 * struct snsd_node_pack {
 *	u_int           record[MAX_IP_INT];
 *	char            flags;
 *	u_char          weight;
 * } pack[hdr.nodes];
 */
#define SNSD_NODE_LLIST_PACK_SZ(head) 	(list_count((head))*SNSD_NODE_PACK_SZ  \
					  + sizeof(struct snsd_node_llist_hdr))

struct snsd_prio_llist_hdr {
	u_short count;				/* number of structs packed in 
								   the body */
} _PACKED_;
INT_INFO snsd_prio_llist_hdr_iinfo = { 1, {INT_TYPE_16BIT}, {0}, {1} };

/*
 * the body is:
 *
 * snsd_prio_pack {
 * 	u_char		prio;
 * 	char		snsd_node_llist_pack[SNSD_NODE_LLIST_PACK_SZ];
 * } pack[hdr.count];
 */
#define SNSD_PRIO_LLIST_PACK_SZ(head)					\
({									\
	snsd_prio *_p=(head);						\
	int _priosz=0;							\
									\
	list_for(_p) {							\
		_priosz+=SNSD_NODE_LLIST_PACK_SZ(_p->node);		\
 		_priosz+=SNSD_PRIO_PACK_SZ;				\
 	}								\
	_priosz+=sizeof(struct snsd_prio_llist_hdr);			\
	_priosz;							\
})


struct snsd_service_llist_hdr {
	u_short count;
} _PACKED_;
INT_INFO snsd_service_llist_hdr_iinfo = { 1, {INT_TYPE_16BIT}, {0}, {1} };

/*
 * the body is:
 * 	u_short		service;
 * 	u_char		proto;
 * 	char		snsd_prio_llist_pack[SNSD_PRIO_LLIST_PACK_SZ];
 */
#define SNSD_SERVICE_LLIST_PACK_SZ(head)				\
({									\
	snsd_service *_s=(head);					\
	int _srvsz=0;							\
 	if(_s) {							\
		 list_for(_s) {						\
			 _srvsz+=SNSD_PRIO_LLIST_PACK_SZ(_s->prio);	\
 			 _srvsz+=SNSD_SERVICE_PACK_SZ;			\
 		 }							\
		 _srvsz+=sizeof(struct snsd_service_llist_hdr);		\
	 }								\
	_srvsz;								\
})

#define SNSD_SERVICE_SINGLE_PACK_SZ(head)				\
({	SNSD_SERVICE_PACK_SZ +						\
		SNSD_PRIO_LLIST_PACK_SZ((head)->prio);			\
})

#define SNSD_SERVICE_MAX_PACK_SZ					\
(	( (SNSD_NODE_PACK_SZ + SNSD_PRIO_PACK_SZ) * 			\
		 	(SNSD_MAX_REC_SERV) 		) + 		\
	SNSD_SERVICE_PACK_SZ 				  +		\
	sizeof(struct snsd_prio_llist_hdr) 		  +		\
	sizeof(struct snsd_service_llist_hdr)				\
)

#define SNSD_SERVICE_MAX_LLIST_PACK_SZ					\
((	SNSD_NODE_PACK_SZ + SNSD_PRIO_PACK_SZ + SNSD_SERVICE_PACK_SZ +	\
		sizeof(struct snsd_prio_llist_hdr))*SNSD_MAX_RECORDS +  \
        sizeof(struct snsd_service_llist_hdr)				\
)


/*
 * This array is used to associate a 8bit number to a protocol name.
 * The number is the position of the protocol name in this array.
 * For example: "tcp" is in the first position so its associated number is 1,
 * while the number for "udp" is 2.
 *
 * Since we limit the proto number to an 8bit number, there can be only 255
 * protocols in this array.
 */
const static char proto_str[][5] = {
	{"tcp"},
	{"udp"},
	{0},
};



/*
 * 
 * * * Functions' declaration * * *
 *
 */

void snsd_cache_init(int family);
u_char str_to_snsd_proto(char *proto_name);
const char *snsd_proto_to_str(u_char proto);
int str_to_snsd_service(char *str, int *service, u_char * proto);
struct servent *snsd_service_to_str(int service, u_char proto,
									char **service_str, char **proto_str);

snsd_service *snsd_find_service(snsd_service * sns, u_short service,
								u_char proto);
snsd_service *snsd_add_service(snsd_service ** head, u_short service,
							   u_char proto);
snsd_prio *snsd_find_prio(snsd_prio * snp, u_char prio);
snsd_prio *snsd_add_prio(snsd_prio ** head, u_char prio);
snsd_node *snsd_find_node_by_record(snsd_node * snd,
									u_int record[MAX_IP_INT]);
snsd_node *snsd_add_node(snsd_node ** head, u_short * counter,
						 u_short max_records, u_int record[MAX_IP_INT]);
snsd_node *snsd_add_mainip(snsd_service ** head, u_short * counter,
						   u_short max_records, u_int record[MAX_IP_INT]);
void snsd_service_llist_del(snsd_service ** head);
void snsd_record_del_selected(snsd_service ** head, u_short * snd_counter,
							  snsd_service * selected);

int snsd_pack_service(char *pack, size_t free_sz, snsd_service * service);
snsd_service *snsd_unpack_service(char *pack, size_t pack_sz,
								  size_t * unpacked_sz,
								  u_short * nodes_counter);
int snsd_pack_all_services(char *pack, size_t pack_sz,
						   snsd_service * head);
snsd_service *snsd_unpack_all_service(char *pack, size_t pack_sz,
									  size_t * unpacked_sz,
									  u_short * nodes_counter);

snsd_node *snsd_choose_wrand(snsd_node * head);
snsd_prio *snsd_highest_prio(snsd_prio * head);
snsd_node *snsd_find_mainip(snsd_service * sns);
void snsd_unset_all_flags(snsd_service * sns, u_char flag);
snsd_service *snsd_service_llist_copy(snsd_service * sns, int service,
									  u_char proto);

void snsd_merge_node(snsd_node ** head, u_short * snsd_counter,
					 snsd_node * new);
void snsd_node_llist_merge(snsd_node ** dst, u_short * snsd_counter,
						   snsd_node * src);
void snsd_merge_prio(snsd_prio ** head, u_short * snsd_counter,
					 snsd_prio * new);
void snsd_prio_llist_merge(snsd_prio ** dst, u_short * snsd_counter,
						   snsd_prio * src);
void snsd_merge_service(snsd_service ** head, u_short * snsd_counter,
						snsd_service * new);
void snsd_service_llist_merge(snsd_service ** dst, u_short * snsd_counter,
							  snsd_service * src);

int snsd_count_nodes(snsd_node * head);
int snsd_count_prio_nodes(snsd_prio * head);
int snsd_count_service_nodes(snsd_service * head);
#endif							/*SNSD_H */