/**
 * $Id: domains.c 1808 2007-03-10 17:36:19Z bogdan_iancu $
 *
 * Copyright (C) 2001-2003 FhG Fokus
 *
 * This file is part of openser, a free SIP server.
 *
 * openser 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
 *
 * openser 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. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

 /**
  * History
  * ------- 
  * 2003-04-07: a structure for both hashes introduced (ramona)
  * 2005-01-26: double hash removed (ramona)
  *             FIFO operations are kept as a diff list (ramona)
  *             domain hash kept in share memory along with FIFO ops (ramona)
  * 2006-01-30: multidomain support added
  * 2006-03-13: use hash function from core (bogdan)
  */

#include <stdio.h>
#include <string.h>

#include "../../sr_module.h"
#include "../../parser/parse_fline.h"
#include "../../db/db.h"
#include "../../mem/shm_mem.h"
#include "../../mem/mem.h"
#include "../../dprint.h"
#include "../../hash_func.h"

#include "domains.h"
#include "utils.h"


#define pdt_compute_hash(_s)        core_case_hash(_s,0,0)
#define get_hash_entry(_h,_size)    (_h)&((_size)-1)

pd_op_t* new_pd_op(pd_t *cell, int id, int op)
{
	pd_op_t *pdo;
	
	if(cell==NULL)
	{
		LOG(L_ERR, "PDT:new_pd_op: bad parameters\n");
		return NULL;
	}
	
	pdo = (pd_op_t*)shm_malloc(sizeof(pd_op_t));
	if(pdo==NULL)
	{
		LOG(L_ERR, "PDT:new_pd_op: no more shm\n");
		return NULL;
	}
	memset(pdo, 0, sizeof(pd_op_t));
	pdo->cell = cell;
	pdo->id = id;
	pdo->op = op;

	return pdo;
}

void free_pd_op(pd_op_t *pdo)
{
	if(pdo==NULL)
		return;
	free_cell(pdo->cell);
	shm_free(pdo);
	pdo = NULL;

	return;
}

pd_t* new_cell(str* p, str *d)
{
	pd_t* cell = NULL; 
	
	if(p==NULL || p->s==NULL || d==NULL || d->s==NULL)
	{
		LOG(L_ERR, "PDT:new_cell: bad parameters\n");
		return NULL;
	}
	
	/* the cell is in share memory */
	cell = (pd_t*)shm_malloc(sizeof(pd_t));
    
	/* if there is no space return just NULL */
	if(cell==NULL)
	{
		LOG(L_ERR, "PDT:new_cell: no more shm memory.\n");
		return NULL;
	}
	memset(cell, 0, sizeof(pd_t));
	
	cell->prefix.s = (char*)shm_malloc((1+p->len)*sizeof(char));
	if(cell->prefix.s==NULL)
	{
		shm_free(cell);
		LOG(L_ERR, "PDT:new_cell: no more shm memory\n");
		return NULL;
	}
	strncpy(cell->prefix.s, p->s, p->len);
	cell->prefix.len = p->len;
	cell->prefix.s[p->len] = '\0';

	cell->domain.s = (char*)shm_malloc((1+d->len)*sizeof(char));
	if(cell->domain.s==NULL)
	{
		shm_free(cell->prefix.s);
		shm_free(cell);
		LOG(L_ERR, "PDT:new_cell: no more shm memory!\n");
		return NULL;
	}
	strncpy(cell->domain.s, d->s, d->len);
	cell->domain.len = d->len;
	cell->domain.s[d->len] = '\0';

	cell->dhash = pdt_compute_hash(&cell->domain);
    
	/* return the newly allocated in share memory cell */
	return cell;
}

void free_cell(pd_t* cell)
{
	if(cell==NULL)
		return;	
	
	if(cell->prefix.s)
		shm_free(cell->prefix.s);

	if(cell->domain.s)
		shm_free(cell->domain.s);
		
	shm_free(cell);
}

/* returns a pointer to a hashtable */
pd_t** init_hash_entries(unsigned int hash_size)
{
	pd_t **hash = NULL; 

	/* space for the hash is allocated in share memory */
	hash = (pd_t**)shm_malloc(hash_size*sizeof(pd_t*));
	if(hash == NULL)
	{
		LOG(L_ERR, "PDT:init_hash: no more shm\n");
		return NULL;
	}
	memset(hash, 0, hash_size*sizeof(pd_t*));

	/* the allocated hash */
	return hash;
}
void free_hash_entries(pd_t** hash, unsigned int hash_size)
{
    unsigned int   i;
    pd_t *tmp, *it;
    if(hash==NULL || hash_size<=0)
		return;
    
	for(i=0; i<hash_size; i++)
	{
		it = hash[i];
		while(it != NULL)
		{
	    	tmp = it->n;
			free_cell(it);
			it = tmp;
		}
    }
	shm_free(hash);
}


hash_t* init_hash(int hash_size, str *sdomain)
{
	hash_t* hash = NULL;

	/* space allocated in shared memory */
	hash = (hash_t*)shm_malloc(sizeof(hash_t));
	
	if(hash == NULL)
	{
		LOG(L_ERR, "PDT: pdt_init_hash: no more shm\n");
		return NULL;
	}
	memset(hash, 0, sizeof(hash_t));

	hash->sdomain.s = (char*)shm_malloc((sdomain->len+1)*sizeof(char));
	if(hash->sdomain.s==NULL)
	{
		LOG(L_ERR, "PDT: pdt_init_hash: no more shm\n");
		shm_free(hash);
		return NULL;
	}
	memset(hash->sdomain.s, 0, sdomain->len+1);
	memcpy(hash->sdomain.s, sdomain->s, sdomain->len);
	hash->sdomain.len = sdomain->len;
	
	if( (hash->dhash = init_hash_entries(hash_size)) == NULL )
	{
		shm_free(hash->sdomain.s);
		shm_free(hash);
		LOG(L_ERR, "PDT:pdt_init_hash: no more shm!\n");
		return NULL;
	}
	
	hash->hash_size = hash_size;

	return hash;
}

int set_hash_domain(hash_t *h, str *s)
{
	if(s==NULL || s->s==NULL || h==NULL)
	{
		LOG(L_ERR, "PDT:set_hash_domain(): wrong parameters\n");
		return -1;
	}
	h->sdomain.s = (char*)shm_malloc((s->len+1)*sizeof(char));
	if( h->sdomain.s == NULL )
	{
		LOG(L_ERR, "PDT:set_hash_domain: no more shm!\n");
		return -1;
	}
	memset(h->sdomain.s, 0, s->len+1);
	memcpy(h->sdomain.s, s->s, s->len);
	h->sdomain.len = s->len;
	return 0;
}

void free_hash(hash_t* hash)
{
	pd_op_t *op, *op_t;

	if(hash==NULL)
		return;

	free_hash_entries(hash->dhash, hash->hash_size);
	/* free the allocated sdomain */
	if(hash->sdomain.s!=NULL)
		shm_free(hash->sdomain.s);
	
	/* destroy diff list */
	for( op = hash->diff ; op ; op=op_t) {
		op_t = op->n;
		shm_free(op);
	}

	/* free next element in the list */
	free_hash(hash->next);
	shm_free(hash);
}

hash_list_t* init_hash_list(int hs_two_pow)
{
	hash_list_t* hl = NULL;
	int hash_size;

	if(hs_two_pow>MAX_HSIZE_TWO_POW || hs_two_pow<0)
		hash_size = MAX_HASH_SIZE;
	else
		hash_size = 1<<hs_two_pow;	

	/* space allocated in shared memory */
	hl = (hash_list_t*)shm_malloc(sizeof(hash_list_t));
	if(hl == NULL)
	{
		LOG(L_ERR, "PDT: init_hash_list: no more shm\n");
		return NULL;
	}
	memset(hl, 0, sizeof(hash_list_t));

	if(lock_init(&hl->hl_lock) == 0)
	{
		shm_free(hl);
		LOG(L_ERR, "PDT:init_hash_list: cannot init the hl_lock\n");
		return NULL;
	}
	hl->hash_size = hash_size;
	
	return hl;
}

void free_hash_list(hash_list_t* hl)
{
	if(hl==NULL)
		return;

	if(hl->hash!=NULL)
		free_hash(hl->hash);
	lock_destroy(&hl->hl_lock);
	shm_free(hl);
}


int add_to_hash(hash_t *hash, str *sp, str *sd, int mode)
{
	int hash_entry=0;
	unsigned int dhash;
	pd_t *it, *prev, *cell;
	pd_op_t *ito, *tmp;
	
	if(hash==NULL || sp==NULL || sp->s==NULL
			|| sd==NULL || sd->s==NULL)
	{
		LOG(L_ERR, "PDT: add_to_hash: bad parameters\n");
		return -1;
	}

	dhash = pdt_compute_hash(sd);
	
	hash_entry = get_hash_entry(dhash, hash->hash_size);

	it = hash->dhash[hash_entry];

	prev = NULL;
	while(it!=NULL && it->dhash < dhash)
	{
		prev = it;
		it = it->n;
	}

	/* we need a new entry for this cell */
	cell = new_cell(sp, sd);	
	if(cell == NULL)
		return -1;

	if(prev)
		prev->n=cell;
	else
		hash->dhash[hash_entry]= cell;
	
	cell->p=prev;
	cell->n=it;
	
	if(it)
		it->p=cell;

	if(mode == 0)
		return 0;

	/* mark the changes for the sync with pdtree */
	tmp = new_pd_op(cell, 0, PDT_ADD);
	if(tmp==NULL)
	{
		LOG(L_ERR, "PDT:add_to_hash: no more shm! Cache not synchron!!\n");
		return -1;
	}

	hash->max_id++;
	tmp->id = hash->max_id;
	if(hash->diff==NULL)
	{
		hash->diff = tmp;
		return 0;		
	}
	ito = hash->diff;
	while(ito->n!=NULL)
		ito = ito->n;

	ito->n = tmp;
	tmp->p = ito;
	
	return 0;
}


int pdt_add_to_hash(hash_list_t *hl, str* sdomain, str *sp, str *sd, int mode)
{
	hash_t *it, *prev, *ph;
	
	if(hl==NULL || sdomain==NULL || sdomain->s==NULL
			|| sp==NULL || sp->s==NULL
			|| sd==NULL || sd->s==NULL)
	{
		LOG(L_ERR, "PDT: pdt_add_to_hash: bad parameters\n");
		return -1;
	}
	lock_get(&hl->hl_lock);

	/* search the it position where to insert new domain */
	it = hl->hash; 
	prev=NULL;
	while(it!=NULL && scmp(&it->sdomain, sdomain)<0)
	{	
		prev=it;
		it=it->next;
	}

	/* add new sdomain, i.e. new entry in the hash list */
	if(it==NULL || scmp(&it->sdomain, sdomain)>0)
	{
		ph = init_hash(hl->hash_size, sdomain); /* !!!! check this hash size setting mode */
		if(ph==NULL)
		{
			LOG(L_ERR, "PDT: pdt_add_to_hash: null pointer returned\n");
			goto error1;
		}
		
		if(add_to_hash(ph, sp, sd, mode)<0)
		{
			LOG(L_ERR, "PDT: pdt_add_to_hash: could not add to hash\n");
			goto error;
		}

		if(prev==NULL)
		/* list initially empty */
			hl->hash = ph;
		else
			prev->next = ph;

		ph->next = it;
	}   
	else 
		/* it is the entry of sdomain, just add a new prefix/domain pair to its hash */
	{
		if(add_to_hash(it, sp, sd, mode)<0)
		{
			LOG(L_ERR, "PDT: pdt_add_to_hash: could not add to hash\n");
			goto error1;
		}
	}
	
	lock_release(&hl->hl_lock);
	return 0;

error:
	free_hash(ph);
error1:
	lock_release(&hl->hl_lock);
	return -1;

}

hash_t* pdt_search_hash(hash_list_t* hl, str *sd)
{
	hash_t* it;

	if(sd==NULL || sd->s==NULL || hl==NULL)
	{
		LOG(L_ERR, "PDT:pdt_search_hash: bad parameters\n");
		return NULL;
	}
	
	lock_get(&hl->hl_lock);

	/* search the it position where to insert new domain */
	it = hl->hash;
	while(it!=NULL && scmp(&it->sdomain, sd)<0)
		it = it->next;

	if(it==NULL || scmp(&it->sdomain, sd)>0)
	{
		lock_release(&hl->hl_lock);
		return NULL;
	}
	
	lock_release(&hl->hl_lock);
	return it;	
}


/* returns -1 if any error
 * returns 1 if does not exist in hash
 * returns 0 if deleted succesfully
 * */
int remove_from_hash(hash_t *hash, str *sd)
{
	int hash_entry=0;
	unsigned int dhash;
	pd_t *it, *prev;
	pd_op_t *ito, *tmp;


	if(hash==NULL || sd==NULL || sd->s==NULL)
	{
		LOG(L_ERR, "PDT:pdt_remove_from_hash: bad parameters\n");
		return -1; /* error */
	}
	
	/* find the list where the cell must be */
	dhash = pdt_compute_hash(sd);
	hash_entry = get_hash_entry(dhash, hash->hash_size);


	/* first element of the list */	
	it = hash->dhash[hash_entry];

	/* find the cell in the list */
	/* a double linked list in the hash is kept alphabetically
	* or numerical ordered */    
	prev = NULL;
	while(it!=NULL)
	{
		if( it->dhash==dhash && it->domain.len==sd->len
				&& strncasecmp(it->domain.s, sd->s, sd->len)==0)
			break;
		prev = it;
		it = it->n;
	}

	if(it==NULL)
		return 1; /* does not exist in hash, nothing to delete */
	
	/* the prefix/domain pair exists and must be deleted */
	if(prev!=NULL)
		prev->n = it->n;
	else
		hash->dhash[hash_entry] = it->n;

	if(it->n)
		it->n->p = it->p;

//	free_cell(it); no free, it will be free up by clean_cache
	/* mark the changes for sync with pdtree */
	tmp = new_pd_op(it, 0, PDT_DELETE);
	if(tmp==NULL)
	{
		LOG(L_ERR, "PDT:remove_from_hash: no more shm!Cache not synchon!\n");
		return -1; /* error */
	}
	hash->max_id++;
	tmp->id = hash->max_id;
	if(hash->diff==NULL)
	{
		hash->diff = tmp;
		return 0;
	}
	ito = hash->diff;
	while(ito->n!=NULL)
		ito = ito->n;

	ito->n = tmp;
	tmp->p = ito;

	return 0;
	
}

/* returns -1 if any error
 * returns 1 if does not exist in hash
 * returns 0 if deleted succesfully
 * */
int pdt_remove_from_hash_list(hash_list_t *hl, str* sdomain, str *sd)
{
	hash_t *it;
	int ret;

	if(hl==NULL ||
			sd==NULL || sd->s==NULL ||
			sdomain==NULL || sdomain->s==NULL)
	{
		LOG(L_ERR, "PDT: pdt_remove_from_hash: bad parameters\n");
		return -1; /* wrong parameters, error */
	}

	lock_get(&hl->hl_lock);	
	
	/* search the it position where to remove from */
	it = hl->hash;
	while(it!=NULL && scmp(&it->sdomain, sdomain)<0)
		it = it->next;
		
	/* sdomain not found, nothing to delete */
	if(it==NULL || scmp(&it->sdomain, sdomain)>0)
	{
		lock_release(&hl->hl_lock);
		return 1; /* nothing to delete */
	}
	ret = remove_from_hash(it, sd);
	
	lock_release(&hl->hl_lock);
	
	return ret;	
}
/*
int pdt_remove_hash_from_hash_list(hash_list_t *hl, str* sdomain)
{
	hash_t *it, *prev, *ph;

	if(hl==NULL ||
			sdomain==NULL || sdomain->s==NULL)
	{
		LOG(L_ERR, "PDT: pdt_remove_from_hash: bad parameters\n");
		return -1;
	}

	lock_get(&hl->hl_lock);	
	// search the it position where to remove from 
	it = hl->hash;
	prev=NULL;
	while(it!=NULL && scmp(&it->sdomain, sdomain)<0)
	{	
		prev = it;
		it = it->next;
	}

	// sdomain not found, nothing to delete 
	if(it==NULL || scmp(&it->sdomain, sdomain)>0)
	{
		lock_release(&hl->hl_lock);
		return 0;
	}
	
	if(prev!=NULL)
	{
		prev->next = it->next;
		it->next = NULL;
		lock_release(&hl->hl_lock);
		free_hash(it);
		it=NULL;
		return 0;
	}

	// remove first element 
	prev = it->next;
	it->next = NULL;
	lock_release(&hl->hl_lock);
	free_hash(it);
	it=NULL;
	return 0;
}
*/

str* get_prefix(hash_t *ph, str* sd)
{
	int hash_entry;
	unsigned int dhash;
	pd_t* it;
	
	if(ph==NULL || ph->dhash==NULL || ph->hash_size>MAX_HASH_SIZE)
	{
		LOG(L_ERR, "PDT:pdt_get_prefix: bad parameters\n");
		return NULL;
	}

	dhash = pdt_compute_hash(sd);
	hash_entry = get_hash_entry(dhash, ph->hash_size);

	it = ph->dhash[hash_entry];
	while(it!=NULL && it->dhash<=dhash)
	{
		if(it->dhash==dhash && it->domain.len==sd->len
				&& strncasecmp(it->domain.s, sd->s, sd->len)==0)
			return &it->prefix;
		it = it->n;
	}

	return NULL;
}

str* pdt_get_prefix(hash_list_t *hl, str*sdomain, str* sd)
{
	hash_t *it;
	str *d;

	if(hl==NULL ||
			sd==NULL || sd->s==NULL ||
			sdomain==NULL || sdomain->s==NULL)
	{
		LOG(L_ERR, "PDT: pdt_get_prefix: bad parameters\n");
		return NULL;
	}

	lock_get(&hl->hl_lock);
	it = pdt_search_hash(hl, sdomain);
	if(it==NULL)
	{
		lock_release(&hl->hl_lock);
		return NULL;
	}
	d = get_prefix(it, sd);	
	lock_release(&hl->hl_lock);
	return d;	
}

int check_pd(hash_t *ph, str *sp, str *sd)
{
	unsigned int i;
	unsigned int dhash;
	pd_t* it;
	
	if(ph==NULL || sp==NULL || sd==NULL)
	{
		LOG(L_ERR, "PDT:check_pd: bad parameters\n");
		return -1;
	}
	dhash = pdt_compute_hash(sd);
	
	for(i=0; i<ph->hash_size; i++)
	{
		it = ph->dhash[i];
		while(it != NULL)
		{
			if((it->domain.len==sd->len
					&& strncasecmp(it->domain.s, sd->s, sd->len)==0)
				|| (it->prefix.len==sp->len
					&& strncasecmp(it->prefix.s, sp->s, sp->len)==0))
				return 1;
			
	    	it = it->n;
		}
    }

	return 0;
}

/* returns 
 *	1 if domain already exists 
 *  0 if domain does not exist
 *  -1 if any error
 * */
int pdt_check_pd(hash_list_t *hl, str* sdomain, str *sp, str *sd)
{
	hash_t *it;
	int d;

	if(hl==NULL ||
			sd==NULL || sd->s==NULL ||
			sdomain==NULL || sdomain->s==NULL)
	{
		LOG(L_ERR, "PDT: pdt_check_pd: bad parameters\n");
		return -1;
	}
	
	lock_get(&hl->hl_lock);

	/* search the it position */
	it = hl->hash;
	while(it!=NULL && scmp(&it->sdomain, sdomain)<0)
		it = it->next;

	if(it==NULL || scmp(&it->sdomain, sdomain)>0)
	{
		lock_release(&hl->hl_lock);
		return 0;
	}
	
	d = check_pd(it, sp, sd);	
	lock_release(&hl->hl_lock);

	return d;		
}

void pdt_print_hash_list(hash_list_t* hl)
{
	unsigned int i, count;
	pd_t *it;
	hash_t *hash;
	
	hash = hl->hash;
	lock_get(&hl->hl_lock);
	while(hash!=NULL)
	{
		DBG("PDT: print_hash: SDOMAIN=%.*s\n", 
				hash->sdomain.len, hash->sdomain.s);
		for(i=0; i<hash->hash_size; i++)
		{
			it = hash->dhash[i];
			DBG(" PDT:print_hash: entry<%d>:\n", i);
			count = 0;
			while(it!=NULL)
			{
				DBG("  PDT:print_hash: |Domain: %.*s |Code: %.*s | DHash:%u \n", it->domain.len, it->domain.s, it->prefix.len, it->prefix.s, it->dhash);
				it = it->n;
				count++;
			}

			DBG(" PDT:print_hash: ---- hash entry has %d records\n\n", count);
		
		}
		hash = hash->next;
	}
	
	lock_release(&hl->hl_lock);
}