netsukuku/src/request.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.
 */

#include "includes.h"
#include "request.h"
#include "xmalloc.h"
#include "log.h"

const static u_char request_str[][30] = {
	{"ECHO_ME"},
	{"ECHO_REPLY"},
	{"GET_FREE_NODES"},
	{"GET_QSPN_ROUND"},

	{"GET_INTERNET_GWS"},
	{"SET_FOREIGN_ROUTE"},
	{"DEL_FOREIGN_ROUTE"},
	{"NEW_BACKROUTE"},
	{"DELAYED_BROADCAST"},
	{"SPLIT_ROUTE"},
	{"SET_NO_IDENTITY"},
	{"QSPN_CLOSE"},
	{"QSPN_OPEN"},
	{"QSPN_RFR"},
	{"GET_DNODE_BLOCK"},
	{"GET_DNODE_IP"},
	{"TRACER_PKT"},
	{"TRACER_PKT_CONNECT"},
	{"DEL_SNODE"},
	{"DEL_GNODE"},
	{"GET_INT_MAP"},
	{"GET_EXT_MAP"},
	{"GET_BNODE_MAP"},

	{"ANDNA_REGISTER_HNAME"},
	{"ANDNA_CHECK_COUNTER"},
	{"ANDNA_RESOLVE_HNAME"},
	{"ANDNA_RESOLVE_IP"},
	{"ANDNA_RESOLVE_MX"},
	{"ANDNA_GET_ANDNA_CACHE"},
	{"ANDNA_GET_SINGLE_ACACHE"},
	{"ANDNA_SPREAD_SACACHE"},
	{"ANDNA_GET_COUNT_CACHE"}

};

const static char unknown_reply[] = "Unknow reply";
const static u_char reply_str[][30] = {
	{"PUT_FREE_NODES"},
	{"PUT_QSPN_ROUND"},
	{"PUT_INTERNET_GWS"},
	{"PUT_DNODEIP"},
	{"EMPTY_REPLY_SLOT"},
	{"EMPTY_REPLY_SLOT1"},
	{"PUT_INT_MAP"},
	{"PUT_EXT_MAP"},
	{"PUT_BNODE_MAP"},
	{"ANDNA_RESOLVE_REPLY"},
	{"ANDNA_REV_RESOLVE_REPLY"},
	{"ANDNA_MX_RESOLVE_REPLY"},
	{"ANDNA_PUT_COUNT_CACHE"},
	{"ANDNA_PUT_ANDNA_CACHE"},

	{"ACK_AFFERMATIVE"},
	{"ACK_NEGATIVE"}
};

const static u_char unknown_error[] = "Unknow error";
const static u_char error_str[][40] = {
	{"Invalid request"},
	{"Accept table full"},
	{"Request table full"},
	{"Quadro Group full"},
	{"Netsukuku is full"},
	{"Invalid signature"},
	{"Cannot forward the pkt"},
	{"Invalid hash_gnode"},
	{"ANDNA cache queue full"},
	{"Hostname update too early"},
	{"Too many hostname registered"},
	{"Hname updates counter mismatch"},
	{"Inexistent host name"},
	{"Counter check failed"},
	{"Too many connection"},
};

/*Wait time*/
#define ECHO_ME_WAIT			5	/*(in seconds) */
#define ECHO_REPLY_WAIT			5
#define GET_FREE_NODES_WAIT		10
#define GET_QSPN_ROUND_WAIT		10

#define GET_INTERNET_GWS_WAIT		5
#define SET_FOREIGN_ROUTE_WAIT		5
#define DEL_FOREIGN_ROUTE_WAIT		5
#define NEW_BACKROUTE_WAIT		10
#define DELAYED_BROADCAST_WAIT		5
#define SPLIT_ROUTE_WAIT		20
#define SET_NO_IDENTITY_WAIT		20

#define QSPN_CLOSE_WAIT			0
#define QSPN_OPEN_WAIT			0
#define QSPN_RFR_WAIT			5
#define GET_DNODEBLOCK_WAIT		20
#define GET_DNODEIP_WAIT	     	5
#define TRACER_PKT_WAIT			10
#define TRACER_PKT_CONNECT_WAIT		10

#define DEL_SNODE_WAIT			10
#define DEL_GNODE_WAIT			10

#define GET_INT_MAP_WAIT		10
#define GET_EXT_MAP_WAIT		10
#define GET_BNODE_MAP_WAIT		10

#define ANDNA_REGISTER_HNAME_WAIT	5
#define ANDNA_CHECK_COUNTER_WAIT	5
#define ANDNA_RESOLVE_HNAME_WAIT	2
#define ANDNA_RESOLVE_IP_WAIT		5
#define ANDNA_RESOLVE_MX_WAIT		5
#define ANDNA_GET_ANDNA_CACHE_WAIT	10
#define ANDNA_GET_SINGLE_ACACHE_WAIT	10
#define ANDNA_SPREAD_SACACHE_WAIT	10
#define	ANDNA_GET_COUNT_CACHE_WAIT	10


/*Max simultaneous requests*/
#define ECHO_ME_MAXRQ			0	/*NO LIMITS */
#define ECHO_REPLY_MAXRQ		20
#define GET_FREE_NODES_MAXRQ		5
#define GET_QSPN_ROUND_MAXRQ		5

#define GET_INTERNET_GWS_MAXRQ		5
#define SET_FOREIGN_ROUTE_MAXRQ		30
#define DEL_FOREIGN_ROUTE_MAXRQ		30
#define NEW_BACKROUTE_MAXRQ		10
#define DELAYED_BROADCAST_MAXRQ		5
#define SPLIT_ROUTE_MAXRQ		1
#define SET_NO_IDENTITY_MAXRQ		1

#define QSPN_CLOSE_MAXRQ		0	/*NO LIMITS */
#define QSPN_OPEN_MAXRQ			0	/*NO LIMITS */
#define QSPN_RFR_MAXRQ			10
#define GET_DNODEBLOCK_MAXRQ		1
#define GET_DNODEIP_MAXRQ		10
#define TRACER_PKT_MAXRQ		20
#define TRACER_PKT_CONNECT_MAXRQ	10

#define DEL_SNODE_MAXRQ			20
#define DEL_GNODE_MAXRQ			5

#define GET_INT_MAP_MAXRQ		2
#define GET_EXT_MAP_MAXRQ		2
#define GET_BNODE_MAP_MAXRQ		2

#define ANDNA_REGISTER_HNAME_MAXRQ	30
#define ANDNA_CHECK_COUNTER_MAXRQ	0	/*NO LIMITS */
#define ANDNA_RESOLVE_HNAME_MAXRQ	80
#define ANDNA_RESOLVE_IP_MAXRQ		40
#define ANDNA_RESOLVE_MX_MAXRQ		40
#define ANDNA_GET_ANDNA_CACHE_MAXRQ	5
#define ANDNA_GET_SINGLE_ACACHE_MAXRQ	10
#define ANDNA_SPREAD_SACACHE_MAXRQ	10
#define	ANDNA_GET_COUNT_CACHE_MAXRQ	5

const static u_char unknown_request[] = "Unknow request";
const static u_char request_array[][2] = {
	{ECHO_ME_WAIT, ECHO_ME_MAXRQ},
	{ECHO_REPLY_WAIT, ECHO_REPLY_MAXRQ},
	{GET_FREE_NODES_WAIT, GET_FREE_NODES_MAXRQ},
	{GET_QSPN_ROUND_WAIT, GET_QSPN_ROUND_MAXRQ},

	{GET_INTERNET_GWS_WAIT, GET_INTERNET_GWS_MAXRQ},
	{SET_FOREIGN_ROUTE_WAIT, SET_FOREIGN_ROUTE_MAXRQ},
	{DEL_FOREIGN_ROUTE_WAIT, DEL_FOREIGN_ROUTE_MAXRQ},
	{NEW_BACKROUTE_WAIT, NEW_BACKROUTE_MAXRQ},
	{DELAYED_BROADCAST_WAIT, DELAYED_BROADCAST_MAXRQ},
	{SPLIT_ROUTE_WAIT, SPLIT_ROUTE_MAXRQ},
	{SET_NO_IDENTITY_WAIT, SET_NO_IDENTITY_MAXRQ},
	{QSPN_CLOSE_WAIT, QSPN_CLOSE_MAXRQ},
	{QSPN_OPEN_WAIT, QSPN_OPEN_MAXRQ},
	{QSPN_RFR_WAIT, QSPN_RFR_MAXRQ},
	{GET_DNODEBLOCK_WAIT, GET_DNODEBLOCK_MAXRQ},
	{GET_DNODEIP_WAIT, GET_DNODEIP_MAXRQ},
	{TRACER_PKT_WAIT, TRACER_PKT_MAXRQ},
	{TRACER_PKT_CONNECT_WAIT, TRACER_PKT_CONNECT_MAXRQ},
	{DEL_SNODE_WAIT, DEL_SNODE_MAXRQ},
	{DEL_GNODE_WAIT, DEL_GNODE_MAXRQ},
	{GET_INT_MAP_WAIT, GET_INT_MAP_MAXRQ},
	{GET_EXT_MAP_WAIT, GET_EXT_MAP_MAXRQ},
	{GET_BNODE_MAP_WAIT, GET_BNODE_MAP_MAXRQ},

	{ANDNA_REGISTER_HNAME_WAIT, ANDNA_REGISTER_HNAME_MAXRQ},
	{ANDNA_CHECK_COUNTER_WAIT, ANDNA_CHECK_COUNTER_MAXRQ},
	{ANDNA_RESOLVE_HNAME_WAIT, ANDNA_RESOLVE_HNAME_MAXRQ},
	{ANDNA_RESOLVE_IP_WAIT, ANDNA_RESOLVE_IP_MAXRQ},
	{ANDNA_RESOLVE_MX_WAIT, ANDNA_RESOLVE_MX_MAXRQ},
	{ANDNA_GET_ANDNA_CACHE_WAIT, ANDNA_GET_ANDNA_CACHE_MAXRQ},
	{ANDNA_GET_SINGLE_ACACHE_WAIT, ANDNA_GET_SINGLE_ACACHE_MAXRQ},
	{ANDNA_SPREAD_SACACHE_WAIT, ANDNA_SPREAD_SACACHE_MAXRQ},
	{ANDNA_GET_COUNT_CACHE_WAIT, ANDNA_GET_COUNT_CACHE_MAXRQ}
};

/* 
 * Request_array indexes defines:
 * ex: request_array[SET_FOREIGN_ROUTE][RQ_WAIT]
 */
#define RQ_WAIT 	0
#define RQ_MAXRQ	1

void
rq_wait_idx_init(int *rq_wait_idx)
{
	int e, idx;

	for (e = 0, idx = 0; e < TOTAL_REQUESTS; e++) {
		rq_wait_idx[e] = idx;
		idx += request_array[e][RQ_MAXRQ];
	}
}

int
op_verify(u_char op)
{
	return op >= TOTAL_OPS;
}

int
rq_verify(u_char rq)
{
	return rq >= TOTAL_REQUESTS;
}

int
re_verify(u_char re)
{
	return ((op_verify(re)) || (re < TOTAL_REQUESTS));
}

int
err_verify(u_char err)
{
	return err >= TOTAL_ERRORS;
}

const u_char *
rq_strerror(int err)
{
	if (err_verify(err))
		return unknown_error;
	return error_str[err];
}

const u_char *
rq_to_str(u_char rq)
{
	if (rq_verify(rq))
		return unknown_request;
	return request_str[rq];
}

const u_char *
re_to_str(u_char re)
{
	if (re_verify(re))
		return (const u_char *) unknown_reply;
	return reply_str[re - TOTAL_REQUESTS];
}

void
update_rq_tbl(rq_tbl * tbl)
{
	u_char i = 0, e = 0, idx = 0;
	time_t cur_t;

	if (update_rq_tbl_mutex)
		return;
	else
		update_rq_tbl_mutex = 1;

	time(&cur_t);

	for (; i < TOTAL_REQUESTS; i++) {
		for (e = 0; e < request_array[i][RQ_MAXRQ]; e++) {
			if (tbl->rq_wait[idx]
				&& (tbl->rq_wait[idx] + request_array[i][RQ_WAIT]) <=
				cur_t) {
				tbl->rq_wait[idx] = 0;
				tbl->rq[i]--;
			}
			idx++;
		}
	}

	update_rq_tbl_mutex = 0;
}

int
is_rq_full(u_char rq, rq_tbl * tbl)
{
	if (rq_verify(rq))
		return E_INVALID_REQUEST;

	update_rq_tbl(tbl);

	if (tbl->rq[rq] >= request_array[rq][RQ_MAXRQ]
		&& request_array[rq][RQ_MAXRQ])
		return E_REQUEST_TBL_FULL;
	else if (!request_array[rq][RQ_MAXRQ])
		return -1;				/* No limits */
	else
		return 0;
}



int
find_free_rq_wait(u_char rq, rq_tbl * tbl)
{
	int e, idx;

	for (e = 0; e < request_array[rq][RQ_MAXRQ]; e++) {
		idx = rq_wait_idx[rq] + e;
		if (!tbl->rq_wait[idx])
			return idx;
	}

	return -1;					/*This happens if the rq_tbl is full for the "rq" request */
}

int
add_rq(u_char rq, rq_tbl * tbl)
{
	int err;
	time_t cur_t;

	/* TODO: XXX: Activate it and test it!!! */
	return 0;
	/* TODO: XXX: Activate it and test it!!! */

	if ((err = is_rq_full(rq, tbl)) > 0)
		return err;
	else if (err < 0)
		return 0;				/* no limits */

	time(&cur_t);

	tbl->rq[rq]++;
	tbl->rq_wait[find_free_rq_wait(rq, tbl)] = cur_t;
	return 0;
}

/*
 * op_filter_reset_re: resets all the replies
 */
void
op_filter_reset_re(int bit)
{
	int i;
	for (i = TOTAL_REQUESTS; i < TOTAL_OPS; i++)
		if (bit)
			op_filter_set(i);
		else
			op_filter_clr(i);
}

/*
 * op_filter_reset_rq: resets all the requests
 */
void
op_filter_reset_rq(int bit)
{
	int i;
	for (i = 0; i < TOTAL_REQUESTS; i++)
		if (bit)
			op_filter_set(i);
		else
			op_filter_clr(i);
}