netsukuku/src/andna.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_H
#define ANDNA_H

#include "andna_cache.h"
#include "pkts.h"

#define MY_NAMESERV		"nameserver 127.0.0.1"
#define MY_NAMESERV_IPV6	"nameserver ::1"
#define ETC_RESOLV_CONF		"/etc/resolv.conf"
#define ETC_RESOLV_CONF_BAK	"/etc/resolv.conf.bak"

/* How many different andna pkt can be flooded simultaneusly */
#define ANDNA_MAX_FLOODS	(ANDNA_MAX_QUEUE*3+1)

/* How many new hash_gnodes are supported in the andna hash_gnode mutation */
#define ANDNA_MAX_NEW_GNODES	1024

/* 
 * These arrays keeps the latest reg_pkt and counter_check IDs to drop pkts
 * alreay received during the floods. These arrays are a FIFO, so the
 * last pkt_id will be always at the 0 position, while the first one will be
 * at the last position 
 */
int last_reg_pkt_id[ANDNA_MAX_FLOODS];
int last_counter_pkt_id[ANDNA_MAX_FLOODS];
int last_spread_acache_pkt_id[ANDNA_MAX_FLOODS];

/*\
 *			   *** ANDNA hash notes ***
 * 
 * In ANDNA there are three type of hashes: MD5, 32bit, 32bit hash of a MD5
 * hash. These hashes are generally applied on hostnames.
 *
 * The andna_hash() function, defined in andna.c, is used to calculate 
 * the IP of a hash_node/hash_gnode/counter_node. It makes a MD5 digest of the
 * input data. If we are working on ipv4, then a 32bit hash is applied to the
 * previously calculated MD5 digest. The result is the IP of the hash_gnode.
 * If we are in ipv6, we'll use directly the MD5 digest as the hash_gnode IP.
 *
 * In all the other cases we'll use directly the MD5 hash of the hostname,
 * f.e. the hname hash of the registration and resolution packets is a MD5.
 * The only exceptions are the lcl_cache and the rh_cache, which use
 * internally a 32bit hash to speed up the hname lookups.
 * 
 * The general guideline for new implementation is to always use big hashes
 * (i.e. MD5) where we might get collisions (f.e in an andna_cache), and to
 * use small hashes where we are safe (f.e. in the rhc_cache).
 *
\*/


/*\
 *
 *  * * *  ANDNA requests/replies pkt stuff  * * * 
 *
\*/

#define ANDNA_HOOK_TIMEOUT		8	/* seconds */
#define ANDNA_REV_RESOLVE_RQ_TIMEOUT	60

/* * * andna pkt flags * * */
#define ANDNA_PKT_UPDATE	1	/* Update the hostname */
#define ANDNA_PKT_FORWARD	(1<<1)	/* Forward this pkt, plz */
#define ANDNA_PKT_REV_RESOLVE	(1<<2)	/* Give me your hostnames */
#define ANDNA_PKT_JUST_CHECK	(1<<3)	/* Check only, don't update
										   anything */
#define ANDNA_PKT_SNSD_DEL	(1<<4)	/* SNSD delete request */

/*
 * andna_reg_pkt
 * 
 * Andna registration request pkt used to send the registration and update
 * requests to the hash_gnode, backup_gnode and counter_gnode.
 * When the pkt is sent to a counter_gnode, a second `rip', which is the ip
 * of the hash_gnode who is contacting the counter_gnode, is appended at the
 * end of the pkt.
 *
 * When the packet is sent to a hash_gnode, at the end of the packet is 
 * included a packed snsd_service linked list. It is the list of snsd_records
 * that have to be registered. However the packet forwarded to the counter 
 * node won't keep this part.
 */
struct andna_reg_pkt {
	u_int rip[MAX_IP_INT];		/* register_node ip */
	u_int hash[MAX_IP_INT];		/* md5 hash of the host name to
								   register. */
	char pubkey[ANDNA_PKEY_LEN];	/* public key of the register
									   node. */
	u_short hname_updates;		/* number of updates already 
								   made for the hostname */

	char sign[ANDNA_SIGNATURE_LEN];	/* RSA signature of the 
									   entire pkt (excluding 
									   `sign' itself and `flags'
									 */
	char flags;

} _PACKED_;
#define ANDNA_REG_PKT_SZ	     (sizeof(struct andna_reg_pkt))
#define ANDNA_REG_SIGNED_BLOCK_SZ (ANDNA_REG_PKT_SZ - ANDNA_SIGNATURE_LEN - \
				 	sizeof(char))
INT_INFO andna_reg_pkt_iinfo = { 1,	/* `rip' and `hash' aren't considered */
	{INT_TYPE_16BIT},
	{MAX_IP_SZ * 2 + ANDNA_PKEY_LEN},
	{1},
};


/*
 *   andna_resolve_rq_pkt
 *
 * The andna resolve request pkt is used to resolve hostnames, IPs and MX
 * hostnames.
 */
struct andna_resolve_rq_pkt {
	u_int rip[MAX_IP_INT];		/* the ip of the requester node */
	char flags;

	u_int hash[MAX_IP_INT];		/* md5 hash of the hostname to
								   resolve. */
	int service;				/* the snsd service of the hname */
	u_char proto;				/* the protocol of `service' */
} _PACKED_;
#define ANDNA_RESOLVE_RQ_PKT_SZ		(sizeof(struct andna_resolve_rq_pkt))
INT_INFO andna_resolve_rq_pkt_iinfo = { 1,	/* `rip' and `hash' are ignored */
	{INT_TYPE_32BIT},
	{MAX_IP_SZ * 2 + sizeof(char)},
	{1},
};

/* 
 * The reply to the resolve request
 */
struct andna_resolve_reply_pkt {
	uint32_t timestamp;			/* the difference between the current
								   time and the last time the resolved
								   hname was updated */
	/*
	 * the rest of the pkt is a pack of one snsd_service llist:
	 * char     service[SNSD_SERVICE_LLIST_PACK_SZ(service)];
	 */
} _PACKED_;
#define ANDNA_RESOLVE_REPLY_PKT_SZ	(sizeof(struct andna_resolve_reply_pkt))
INT_INFO andna_resolve_reply_pkt_iinfo = { 1,	/* `ip' is ignored */
	{INT_TYPE_32BIT},
	{0},
	{1}
};


/* 
 * The reply to the reverse resolve request is just the packed local cache.
 */


/* 
 * single_acache
 *
 * The single_acache pkt is used to get from an old hash_gnode a single
 * andna_cache, which has the wanted `hash'. Its propagation method is similar
 * to that of andna_resolve_rq_pkt, but each new hash_gnode, which receives
 * the pkt, adds in the body pkt its ip. The added ips are used as excluded 
 * hash_gnode by find_hash_gnode(). In this way each time an old hash_gnode 
 * receives the pkt, can verify if it is, at that current time, the true old 
 * hash_gnode by excluding the hash_gnodes listed in the pkt body. If it 
 * notices that there's an hash_gnode older than it, it will append its ip in 
 * the pkt body and will forward it to that older hash_gnode. And so on, until
 * the pkt reaches a true old hash_gnode, or cannot be forwarded anymore since
 * there are no more older hash_gnodes.
 */
struct single_acache_hdr {
	u_int rip[MAX_IP_INT];		/* the ip of the requester node */
	u_int hash[MAX_IP_INT];
	u_short hgnodes;			/* Number of hgnodes in the 
								   body. */
	u_char flags;
} _PACKED_;
INT_INFO single_acache_hdr_iinfo = { 1,	/* `rip' and `hash' are ignored */
	{INT_TYPE_16BIT},
	{MAX_IP_SZ * 2},
	{1},
};

/*
 * The single_acache body is:
 * struct {
 * 	u_int		hgnode[MAX_IP_INT];
 * } body[new_hash_gnode_hdr.hgnodes];
 */
#define SINGLE_ACACHE_PKT_SZ(hgnodes)	(sizeof(struct single_acache_hdr)+\
						MAX_IP_SZ*(hgnodes))

/*
 * The single_acache_reply is just an andna_cache_pkt with a single cache.
 */


/*
 * Tell the node, which receives the pkt, to send a ANDNA_GET_SINGLE_ACACHE
 * request to fetch the andna_cache for the `hash' included in the pkt.
 */
struct spread_acache_pkt {
	u_int hash[MAX_IP_INT];
} _PACKED_;
#define SPREAD_ACACHE_PKT_SZ	(sizeof(struct spread_acache_pkt))
INT_INFO spread_acache_pkt_info = { 0, {0}, {0}, {0} };



/*\
 *
 *   * * *  Function declaration  * * *
 *
\*/

int andna_load_caches(void);
int andna_save_caches(void);

void andna_init(void);
void andna_close(void);
void andna_resolvconf_modify(void);
void andna_resolvconf_restore(void);

int andna_register_hname(lcl_cache * alcl, snsd_service * snsd_delete);
int andna_recv_reg_rq(PACKET rpkt);

int andna_check_counter(PACKET pkt);
int andna_recv_check_counter(PACKET rpkt);

snsd_service *andna_resolve_hash(u_int hname_hash[MAX_IP_INT], int service,
								 u_char proto, int *records);
snsd_service *andna_resolve_hname(char *hname, int service, u_char proto,
								  int *records);
int andna_recv_resolve_rq(PACKET rpkt);

lcl_cache *andna_reverse_resolve(inet_prefix ip);
int andna_recv_rev_resolve_rq(PACKET rpkt);

int spread_single_acache(u_int hash[MAX_IP_INT]);
int recv_spread_single_acache(PACKET rpkt);
andna_cache *get_single_andna_c(u_int hash[MAX_IP_INT],
								u_int hash_gnode[MAX_IP_INT]);
int put_single_acache(PACKET rpkt);
int put_andna_cache(PACKET rq_pkt);
int put_counter_cache(PACKET rq_pkt);

void *andna_hook(void *);
void andna_update_hnames(int only_new_hname);
void *andna_maintain_hnames_active(void *null);
void *andna_main(void *);

#endif							/*ANDNA_H */