netsukuku/src/andna_cache.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 ANDNA_CACHE_H
#define ANDNA_CACHE_H

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

/*
 * ANDNA definitions
 */

#define ANDNA_MAX_BACKUP_GNODES		2
#define ANDNA_MAX_QUEUE			5
#define ANDNA_MAX_HNAME_LEN		512	/* (null terminator included) */
#define ANDNA_MAX_HOSTNAMES		256	/* Max number of hnames per node */
#define ANDNA_MAX_RHC_HNAMES		512	/* Max number of hnames kept in
										   the resolved_hnames cache* */
#define ANDNA_EXPIRATION_TIME		259200	/* 3 days (in seconds) */
#define ANDNA_MIN_UPDATE_TIME		3600	/* The minum amount of time to
											   be waited before sending an 
											   update of the hname. */

#define ANDNA_PRIVKEY_BITS		1024
#define ANDNA_SKEY_MAX_LEN		900
#define ANDNA_PKEY_LEN			140
#define ANDNA_HASH_SZ			(MAX_IP_SZ)
#define ANDNA_SIGNATURE_LEN		128

/* Returns the number of nodes to be used in a backup_gnode */
#define ANDNA_BACKUP_NODES(seeds)	({(seeds) > 8 ? 			\
					  ((seeds)*32)/MAXGROUPNODE : (seeds);})

#ifdef DEBUG
#undef ANDNA_EXPIRATION_TIME
#define ANDNA_EXPIRATION_TIME 100
#undef ANDNA_MIN_UPDATE_TIME
#define ANDNA_MIN_UPDATE_TIME 2
#endif

/* 
 * * *  Cache stuff  * * *
 */

/* * andna_cache flags * */
#define ANDNA_BACKUP		1	/* We are a backup_node */
#define ANDNA_COUNTER		(1<<1)	/* We are a counter_node */
#define ANDNA_ROUNDED		(1<<2)	/* We are a rounded_hash_node */
#define ANDNA_FULL		(1<<3)	/* Queue full */
#define ANDNA_UPDATING		(1<<4)	/* The hname is being updated 
									   right now */

/* 
 * andna_cache_queue
 * 
 * The queue of the andna_cache. (see below).
 */
struct andna_cache_queue {
	LLIST_HDR(struct andna_cache_queue);

	time_t timestamp;
	u_short hname_updates;		/* numbers of hname's updates */
	char pubkey[ANDNA_PKEY_LEN];

	u_short snsd_counter;		/* # of `snsd' nodes */
	snsd_service *service;
};
typedef struct andna_cache_queue andna_cache_queue;

/*
 * andna_cache
 * 
 * It keeps the entries of the hostnames registered by other nodes.
 */
struct andna_cache {
	LLIST_HDR(struct andna_cache);

	u_int hash[MAX_IP_INT];		/* hostname's hash */
	char flags;

	u_short queue_counter;
	andna_cache_queue *acq;		/* The queue of the registration.
								   The first is the active one */
};
typedef struct andna_cache andna_cache;

/* part of the counter cache, see below */
struct counter_c_hashes {
	LLIST_HDR(struct counter_c_hashes);

	time_t timestamp;
	u_short hname_updates;
	int hash[MAX_IP_INT];
};
typedef struct counter_c_hashes counter_c_hashes;
INT_INFO counter_c_hashes_body_iinfo = { 2,
	{INT_TYPE_32BIT, INT_TYPE_16BIT},
	{0, sizeof(time_t)}
	,
	{1, 1}
};

/*
 * counter_c
 * Counter node's cache.
 *
 * All the infos regarding a particular register_node are stored here. For
 * example, we need to know how many hostnames he already registered.
 */
struct counter_c {
	LLIST_HDR(struct counter_c);

	char pubkey[ANDNA_PKEY_LEN];
	char flags;

	u_short hashes;				/* The number of hashes in cch */
	counter_c_hashes *cch;		/* The hashes of the hnames */
};
typedef struct counter_c counter_c;
INT_INFO counter_c_body_iinfo = { 1,
	{INT_TYPE_16BIT},
	{ANDNA_PKEY_LEN + sizeof(char)},
	{1}
};

/*
 * lcl_cache_keyring
 *
 * The lcl keyring is used to store the RSA keys used to complete some of the
 * ANDNA requests, (f.e. registering or updating a hname).
 */
typedef struct {
	u_int skey_len;
	u_int pkey_len;

	u_char *privkey;			/* secret key packed */
	u_char *pubkey;				/* pubkey packed */

	RSA *priv_rsa;				/* key pair unpacked */
} lcl_cache_keyring;


/*
 * lcl_cache
 * 
 * The Local Andna Cache keeps all the hostnames which have been register by
 * localhost (ourself).
 */
struct lcl_cache {
	LLIST_HDR(struct lcl_cache);

	char *hostname;				/* The registered hostname */
	u_int hash;					/* 32bit hash of the md5 hash 
								   of the hname */
	u_short hname_updates;		/* How many updates we've done 
								   for this hostname */
	time_t timestamp;			/* the last time when the hname
								   was updated. If it is 0, the
								   hname has still to be 
								   registered */

	u_short snsd_counter;		/* # of `snsds' */
	snsd_service *service;

	char flags;
};
typedef struct lcl_cache lcl_cache;


/*
 * resolved_hnames_cache
 *
 * This cache keeps info on the already resolved hostnames, so we won't have
 * to resolve them soon again.
 * In order to optimize the search we order the linked list by the time
 * of hname resolution. The last hname which has been searched/resolved is
 * always moved at the head of the llist, in this way, at the end of the llist
 * there is the hname which has been searched for the first time but has been
 * ignored until now.
 * When the cache is full, the hname which is at the end of the llist is
 * removed to empty new space.
 * The hname which have the `timestamp' expired are removed too.
 */
struct resolved_hnames_cache {
	LLIST_HDR(struct resolved_hnames_cache);

	u_int hash;					/* 32bit hash of the md5 hash of the
								   hname */
	char flags;

	time_t timestamp;			/* the last time when the hname
								   was updated. With this we know that
								   at timestamp+ANDNA_EXPIRATION_TIME
								   this cache will expire. */

	u_short snsd_counter;
	snsd_service *service;
};
typedef struct resolved_hnames_cache rh_cache;


/*
 *  * * *  Global vars   * * *
 */
andna_cache *andna_c;
int andna_c_counter;

counter_c *andna_counter_c;
int cc_counter;

lcl_cache_keyring lcl_keyring;
lcl_cache *andna_lcl;
int lcl_counter;

rh_cache *andna_rhc;
int rhc_counter;


/*
 * 
 *  *  *  *  Package stuff  *  *  * 
 *  
 */


/*
 *  * * * lcl cache package * * *
 */

struct lcl_keyring_pkt_hdr {
	u_int skey_len;
	u_int pkey_len;
} _PACKED_;
/* 
 * the rest of the pkt is:
 * 
 *	char		privkey[hdr.skey_len];
 *	char		pubkey[hdr.pkey_len];
 */
INT_INFO lcl_keyring_pkt_hdr_iinfo = { 2,
	{INT_TYPE_32BIT, INT_TYPE_32BIT},
	{0, sizeof(u_int)}
	,
	{1, 1}
};

#define LCL_KEYRING_HDR_PACK_SZ(khdr)	(sizeof(struct lcl_keyring_pkt_hdr) + \
					(khdr)->skey_len + (khdr)->pkey_len)

/*
 * The local cache pkt is used to pack the entire local cache to save it in a 
 * file or to send it to a node.
 */
struct lcl_cache_pkt_hdr {
	u_short tot_caches;			/* How many lcl structs there 
								   are in the pkt's body */
} _PACKED_;
INT_INFO lcl_cache_pkt_hdr_iinfo = { 1, {INT_TYPE_16BIT}, {0}, {1} };

#define LCL_CACHE_HDR_PACK_SZ		(sizeof(struct lcl_cache_pkt_hdr))

/* 
 * The body is:
 *	
 * struct lcl_cache_pkt_body {
 *	u_short		hname_updates;
 *	time_t          timestamp;
 *	char		hostname[strlen(hostname)+1];  * null terminated *
 * } body[ hdr.tot_caches ];
 * 
 */
#define LCL_CACHE_BODY_PACK_SZ(hname_len) 	((hname_len) + sizeof(u_short) \
						  + sizeof(time_t))
INT_INFO lcl_cache_pkt_body_iinfo = { 2, {INT_TYPE_16BIT, INT_TYPE_32BIT},
{0, sizeof(u_short)}
,
{1, 1}
};

/*
 *  * * * andna cache package * * *
 */

/*
 * the body of the acq_pkt is:
 * struct acq_pkt_body {
 * 	time_t		timestamp;
 * 	u_short		hname_updates;
 * 	char		pubkey[ANDNA_PKEY_LEN];
 *
 * 	u_short		snsd_counter;
 * 	char		snsd_service_pack[SNSD_SERVICE_PACK_SZ];
 * };
 */
INT_INFO acq_body_iinfo = { 3,
	{INT_TYPE_32BIT, INT_TYPE_16BIT, INT_TYPE_16BIT}
	,
	{0, sizeof(time_t),
	 sizeof(time_t) + sizeof(u_short) + ANDNA_PKEY_LEN}
	,
	{1, 1, 1}
};

#define ACQ_BODY_PACK_SZ		(sizeof(time_t) + sizeof(u_short)*2 + \
					 ANDNA_PKEY_LEN)
#define ACQ_PACK_SZ(snsd_pack_sz)	(ACQ_BODY_PACK_SZ + (snsd_pack_sz))

struct andna_cache_pkt_hdr {
	u_short tot_caches;
} _PACKED_;
INT_INFO andna_cache_pkt_hdr_iinfo = { 1, {INT_TYPE_16BIT}, {0}, {1} };

/*
 * The body is:
 * struct andna_cache_pack {
 * 	u_int		hash[MAX_IP_INT];
 * 	char		flags;
 * 	u_short		queue_counter;
 * 	char		acq_pack[ACQ_PACK_SZ*queue_counter];
 * } acache_pack[hdr.tot_caches];
 */
INT_INFO andna_cache_body_iinfo = { 1,
	{INT_TYPE_16BIT},
	{MAX_IP_SZ + sizeof(char)},
	{1}
};

#define ACACHE_BODY_PACK_SZ		(ANDNA_HASH_SZ + sizeof(char) + 	\
					   sizeof(u_short))
#define ACACHE_PACK_SZ(acq_pack_sz)	((acq_pack_sz) + ACACHE_BODY_PACK_SZ)

/*
 * If the acache pack will be sent on a network packet, the `acq->timestamp' 
 * will be the difference of the current time with the same `acq->timestamp',
 * in this way the node which receives the packet will add its current time to
 * `acq->timestamp'. This is necessary because the sending and receiving node
 * don't have the clock synced. Note that the rtt isn't considered because it
 * is generally very small and the ANDNA times don't need an accurate
 * precision, f.e. the expiration time is three days long.
 * If the pack is saved on a file, then `acq->timestamp' remains the same.
 * Problem: if the clock is changed, acq->timestamp will refer to the old
 * clock.
 */
#define ACACHE_PACK_FILE		1
#define ACACHE_PACK_PKT			2


/*
 * The counter cache pkt is similar to the andna_cache_pkt, it is completely
 * arranged in the same way.
 */
struct counter_c_pkt_hdr {
	u_short tot_caches;
} _PACKED_;
INT_INFO counter_c_pkt_hdr_iinfo = { 1, {INT_TYPE_16BIT}, {0}, {1} };

#define COUNTER_CACHE_HASHES_PACK_SZ	(sizeof(time_t) + sizeof(u_short) +	\
						ANDNA_HASH_SZ)
#define COUNTER_CACHE_BODY_PACK_SZ	(ANDNA_PKEY_LEN + sizeof(char)    + 	\
						sizeof(u_short))
#define COUNTER_CACHE_PACK_SZ(hashes)	((COUNTER_CACHE_HASHES_PACK_SZ*(hashes))\
					 + COUNTER_CACHE_BODY_PACK_SZ)

/* 
 *  * * * Resolved hostnames cache pkt. * * *
 */

struct rh_cache_pkt_hdr {
	u_short tot_caches;			/* How many lcl structs there 
								   are in the pkt's hdr */
} _PACKED_;
INT_INFO rh_cache_pkt_hdr_iinfo = { 1, {INT_TYPE_16BIT}, {0}, {1} };

/*
 * The body is:
 * struct rh_cache_pkt_body {
 *	u_int		hash;
 *	char		flags;
 *	time_t		timestamp;
 *
 * 	u_short		snsd_counter;
 * 	char		snsd_service_pack[SNSD_SERVICE_PACK_SZ];
 * } body[ hdr.tot_caches ];
 */
#define RH_CACHE_BODY_PACK_SZ(snsd_pack_sz)	(sizeof(u_int)+sizeof(char)+ \
						 sizeof(time_t)+sizeof(u_short)+\
						 (snsd_pack_sz))
INT_INFO rh_cache_pkt_body_iinfo = { 3,
	{INT_TYPE_32BIT, INT_TYPE_32BIT, INT_TYPE_16BIT},
	{0, sizeof(u_int) + sizeof(char),
	 sizeof(u_int) + sizeof(char) + sizeof(time_t)}
	,
	{1, 1, 1}
};


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

void andna_caches_init(int family);

void lcl_new_keyring(lcl_cache_keyring * keyring);
void lcl_destroy_keyring(lcl_cache_keyring * keyring);
lcl_cache *lcl_cache_new(char *hname);
void lcl_cache_free(lcl_cache * alcl);
void lcl_cache_destroy(lcl_cache * head, int *counter);
lcl_cache *lcl_cache_find_hname(lcl_cache * head, char *hname);
lcl_cache *lcl_cache_find_hash(lcl_cache * alcl, u_int hash);
lcl_cache *lcl_get_registered_hnames(lcl_cache * alcl);

andna_cache_queue *ac_queue_findpubk(andna_cache * ac, char *pubk);
andna_cache_queue *ac_queue_add(andna_cache * ac, char *pubkey);
void ac_queue_del(andna_cache * ac, andna_cache_queue * acq);
void ac_queue_del_expired(andna_cache * ac);
void ac_queue_destroy(andna_cache * ac);
andna_cache *andna_cache_findhash(int hash[MAX_IP_INT]);
andna_cache *andna_cache_gethash(int hash[MAX_IP_INT]);
andna_cache *andna_cache_addhash(int hash[MAX_IP_INT]);
int andna_cache_del_ifexpired(andna_cache * ac);
void andna_cache_del_expired(void);
void andna_cache_destroy(void);

counter_c_hashes *cc_hashes_add(counter_c * cc, int hash[MAX_IP_INT]);
void cc_hashes_del(counter_c * cc, counter_c_hashes * cch);
int counter_c_del_ifexpired(counter_c * cc);
void cc_hashes_del_expired(counter_c * cc);
void cc_hashes_destroy(counter_c * cc);
counter_c_hashes *cc_findhash(counter_c * cc, int hash[MAX_IP_INT]);
counter_c *counter_c_findpubk(char *pubk);
counter_c *counter_c_add(inet_prefix * rip, char *pubkey);
void counter_c_del_expired(void);
void counter_c_destroy(void);

rh_cache *rh_cache_new(char *hname, time_t timestamp);
rh_cache *rh_cache_add_hash(u_int hash, time_t timestamp);
rh_cache *rh_cache_add(char *hname, time_t timestamp);
rh_cache *rh_cache_find_hash(u_int hash);
rh_cache *rh_cache_find_hname(char *hname);
void rh_cache_del(rh_cache * rhc);
void rh_cache_del_expired(void);
void rh_cache_flush(void);

char *pack_lcl_keyring(lcl_cache_keyring * keyring, size_t * pack_sz);
int unpack_lcl_keyring(lcl_cache_keyring * keyring, char *pack,
					   size_t pack_sz);

char *pack_lcl_cache(lcl_cache * local_cache, size_t * pack_sz);
lcl_cache *unpack_lcl_cache(char *pack, size_t pack_sz, int *counter);

char *pack_andna_cache(andna_cache * acache, size_t * pack_sz,
					   int pack_type);
andna_cache *unpack_andna_cache(char *pack, size_t pack_sz, int *counter,
								int pack_type);

char *pack_counter_cache(counter_c * countercache, size_t * pack_sz);
counter_c *unpack_counter_cache(char *pack, size_t pack_sz, int *counter);

char *pack_rh_cache(rh_cache * rhcache, size_t * pack_sz);
rh_cache *unpack_rh_cache(char *pack, size_t pack_sz, int *counter);

int save_lcl_keyring(lcl_cache_keyring * keyring, char *file);
int load_lcl_keyring(lcl_cache_keyring * keyring, char *file);

int save_lcl_cache(lcl_cache * lcl, char *file);
lcl_cache *load_lcl_cache(char *file, int *counter);

int save_andna_cache(andna_cache * acache, char *file);
andna_cache *load_andna_cache(char *file, int *counter);

int save_counter_c(counter_c * countercache, char *file);
counter_c *load_counter_c(char *file, int *counter);

int save_rh_cache(rh_cache * rh, char *file);
rh_cache *load_rh_cache(char *file, int *counter);

int load_hostnames(char *file, lcl_cache ** old_alcl_head,
				   int *old_alcl_counter);
int load_snsd(char *file, lcl_cache * alcl_head);

int add_resolv_conf(char *hname, char *file);
int del_resolv_conf(char *hname, char *file);

#endif							/*ANDNA_CACHE_H */