/* 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.
 *
 * -- 
 * accept.c: This is how it works:
 *
 * When a new accept is made add_accept is called. It first updates the accept
 * table and then, if the accept_tbl isn't full add the new accept in the tbl.
 * If the accept_tbl is full the connection is dropped.
 * Each accept in the table last for free_accept_time after the close of that
 * connection, so if an host has fulled the accept_tbl has to wait 
 * free_accept_time of seconds to be able to reconnect again.
 */

#include "includes.h"

#include "request.h"
#include "inet.h"
#include "accept.h"
#include "xmalloc.h"
#include "log.h"


void
init_accept_tbl(int startups, int accepts, int time)
{
	/* TODO: activate and test it !! */
#if 0
	int i;

	max_connections = startups;
	max_accepts_per_host = accepts;
	free_accept_time = time;
	accept_idx = accept_sidx = 0;
	pthread_mutex_init(&mtx_acpt_idx, NULL);
	pthread_mutex_init(&mtx_acpt_sidx, NULL);

	accept_tbl =
		(struct accept_table *) xmalloc(sizeof(struct accept_table) *
										max_connections);
	memset(accept_tbl, '\0',
		   sizeof(struct accept_table) * max_connections);

	for (i = 0; i < max_connections; i++) {
		accept_tbl[i].pid =
			(pid_t *) xmalloc(sizeof(pid_t) * max_accepts_per_host);
		memset(accept_tbl[i].pid, '\0',
			   sizeof(pid_t) * max_accepts_per_host);

		accept_tbl[i].closed =
			(unsigned char *) xmalloc(sizeof(unsigned char) *
									  max_accepts_per_host);
		memset(accept_tbl[i].closed, '\0',
			   sizeof(unsigned char) * max_accepts_per_host);

		accept_tbl[i].acp_t =
			(time_t *) xmalloc(sizeof(time_t) * max_accepts_per_host);
		memset(accept_tbl[i].acp_t, '\0',
			   sizeof(time_t) * max_accepts_per_host);
	}
#endif
}

void
destroy_accept_tbl(void)
{
	/* TODO: activate and test it !! */
#if 0
	int i;

	if (!accept_tbl)
		return;
	for (i = 0; i < max_connections; i++) {
		xfree(accept_tbl[i].pid);
		xfree(accept_tbl[i].closed);
		xfree(accept_tbl[i].acp_t);
	}
	xfree(accept_tbl);
	accept_tbl = 0;
#endif
}


void
update_accept_tbl(void)
{
	time_t cur_t, passed_time;
	int i, e, k, ee, pid_exists;

	if (update_accept_tbl_mutex)
		return;
	else
		update_accept_tbl_mutex = 1;

	time(&cur_t);

	for (i = 0; i < max_connections; i++) {
		if (!accept_tbl[i].ip.len)
			continue;
		if (accept_tbl[i].accepts) {
			for (e = 0; e < max_accepts_per_host; e++) {
				if (!accept_tbl[i].acp_t[e])
					continue;

				if (accept_tbl[i].pid[e]) {
					k = kill(accept_tbl[i].pid[e], 0);
					pid_exists = !(k == -1 && errno == ESRCH);
				} else
					pid_exists = 0;

#if 0
				debug(DBG_NOISE, "ACPT: Updating tbl: cur_t: %d, "
					  "accept_tbl[%d].acp_t[%d]:%d+%d, "
					  "accept_tbl[i].pid[e]: %d, "
					  "kill=%d (ESRCH=%d)",
					  cur_t, i, e, accept_tbl[i].acp_t[e],
					  free_accept_time, accept_tbl[i].pid[e], k, ESRCH);
#endif

				passed_time = accept_tbl[i].acp_t[e] + free_accept_time;
				if ((accept_tbl[i].closed[e] || !pid_exists) &&
					passed_time <= cur_t) {
					ee = e;
					del_accept(i, &ee);
				}
			}
		}
	}
	update_accept_tbl_mutex = 0;
}

int
find_ip_acpt(inet_prefix ip)
{
	int i;

	for (i = 0; i < max_accepts_per_host; i++) {
		if (!memcmp(accept_tbl[i].ip.data, &ip.data, MAX_IP_SZ))
			return i;
	}

	return -1;
}

int
find_first_free(void)
{
	int i;

	for (i = 0; i < max_connections; i++)
		if (!accept_tbl[i].accepts)
			return i;
	return -1;
}

int
is_ip_acpt_free(inet_prefix ip, int *index)
{
	int idx;

	update_accept_tbl();

	if ((idx = find_ip_acpt(ip)) == -1)
		if ((idx = find_first_free()) == -1)
			return E_TOO_MANY_CONN;

	/*debug(DBG_NOISE, "ACPT: accept_tbl[%d].accepts: %d, max_acp: %d", idx,
	   accept_tbl[idx].accepts, max_accepts_per_host); */

	if (accept_tbl[idx].accepts >= max_accepts_per_host)
		return E_ACCEPT_TBL_FULL;

	*index = idx;
	return 0;
}

int
find_free_acp_t(int idx)
{
	int e;

	for (e = 0; e < max_accepts_per_host; e++) {
		if (!accept_tbl[idx].acp_t[e])
			return e;
	}

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

int
new_accept(int idx, inet_prefix ip)
{
	int cl = 0;
	/* TODO: activate and test it !! */
#if 0
	time_t cur_t;

	time(&cur_t);

	if ((cl = find_free_acp_t(idx)) == -1)
		return -1;
	accept_tbl[idx].accepts++;
	accept_tbl[idx].acp_t[cl] = cur_t;
	accept_tbl[idx].closed[cl] = 0;
	inet_copy(&accept_tbl[idx].ip, &ip);
#endif
	return cl;
}

/* 
 * add_accept: It adds a new accept of `ip'. If `replace' is not 0 the `ip's
 * accepts are not incremented and accept_sidx is set to 0.
 */
int
add_accept(inet_prefix ip, int replace)
{
	/* TODO: activate and test it !! */
#if 0
	int err, idx, cl;

	if ((err = is_ip_acpt_free(ip, &idx)))
		return err;

	if (!replace || !accept_tbl[idx].accepts) {
		cl = new_accept(idx, ip);
		if (cl < 0)
			return -1;
	} else
		cl = 0;

	/*This global var will be given to the thread */
	pthread_mutex_lock(&mtx_acpt_idx);
	accept_idx = idx;
	pthread_mutex_unlock(&mtx_acpt_idx);

	pthread_mutex_lock(&mtx_acpt_sidx);
	accept_sidx = cl;
	pthread_mutex_unlock(&mtx_acpt_sidx);
#endif
	return 0;
}

void
del_accept(int idx, int *sidx)
{
#if 0
	if (!accept_tbl[idx].accepts)
		return;

	if (accept_tbl[idx].acp_t[*sidx]) {
		accept_tbl[idx].accepts--;
		accept_tbl[idx].acp_t[*sidx] = 0;
		accept_tbl[idx].closed[*sidx] = 0;
		if (!accept_tbl[idx].accepts)
			memset(&accept_tbl[idx].ip, '\0', sizeof(inet_prefix));
		(*sidx)--;
	}
#endif
}

int
close_accept(int idx, int sidx)
{
#if 0
	if (!accept_tbl[idx].accepts)
		return -1;

	accept_tbl[idx].closed[sidx] = 1;
#endif
	return 0;
}

void
add_accept_pid(pid_t pid, int idx, int sidx)
{
	/* TODO: activate and test it !! */
#if 0
	accept_tbl[idx].pid[sidx] = pid;
/*	debug(DBG_NOISE, "ACPT: Added pig %d in accept_tbl[%d].pid[%d]", 
			accept_tbl[idx].pid[sidx], idx, sidx);
*/
#endif
}