struct segwrap *
seghash_get (struct segwrap **hash_table, size_t table_size, seq_t key)
{
int i;
struct segwrap *head;
struct segwrap *cur;
struct segwrap *selected;
assert (hash_table != NULL);
assert (table_size > 0);
i = hash_fun (key, table_size);
assert (i >= 0);
assert (i < table_size);
selected = NULL;
head = getHead (hash_table[i]);
if (head != NULL) {
cur = head;
do {
if (key == seg_seq (cur->sw_seg))
selected = cur;
else
cur = getNext (cur);
} while (selected == NULL && cur != getHead (hash_table[i]));
}
return selected;
}
int
hash_get(struct hash *hash,
uint32_t laddr, uint32_t raddr, uint16_t lport, uint16_t rport,
struct timeval *result)
{
struct session *session;
unsigned long port;
port = hash_fun(laddr, raddr, lport, rport) % hash->sz;
for (session = hash->sessions + port; session->next; session = session->next)
if (
session->next->raddr == laddr &&
session->next->laddr == raddr &&
session->next->rport == lport &&
session->next->lport == rport
)
{
*result = session->next->tv;
return 1;
}
return 0;
}
int
hash_get_rem(struct hash *hash,
uint32_t laddr, uint32_t raddr, uint16_t lport, uint16_t rport,
struct timeval *result)
{
struct session *session, *next;
unsigned long port;
port = hash_fun(laddr, raddr, lport, rport) % hash->sz;
for (session = hash->sessions + port; session->next; session = session->next)
if (
session->next->raddr == raddr &&
session->next->laddr == laddr &&
session->next->rport == rport &&
session->next->lport == lport
)
{
*result = session->next->tv;
// Now remove
next = session->next->next;
free(session->next);
session->next = next;
hash->count --;
return 1;
}
return 0;
}
double retrieve_value(PHASH* ph, TPAIR tp)
{
int start_idx = hash_fun(tp) % (ph -> length);
int idx = start_idx;
while(!pair_equal((ph -> p)[idx].key, tp))
idx = (idx + 1) % (ph -> length);
return (ph -> p)[idx].val;
}
static struct owner* find_by_uid(int n)
{
struct owner* p;
p = hash_table[hash_fun(n)];
while(p) {
if(p->uid == n) break;
p=p->next;
}
return p;
}
int hash_exist(struct hash *hash, uint32_t laddr, uint32_t raddr, uint16_t lport, uint16_t rport)
{
struct session *session;
unsigned long port;
port = hash_fun(laddr, raddr, lport, rport) % hash->sz;
for (session = hash->sessions + port; session->next; session = session->next){
if (session->next->raddr == raddr && session->next->laddr == laddr && session->next->rport == rport && session->next->lport == lport)
return 1;
}
return 0;
}
HASHNODE * hash_search(HASHNODE *hash_table[],char *key)
{
unsigned int index;
index = hash_fun(key);
HASHNODE *p = NULL;
p = hash_table[index];
for(;p!=NULL;p=p->next)
{
if(strcmp(p->key,key)==0)
return p;
}
return p;
}
struct segwrap *
seghash_remove (struct segwrap **hash_table, size_t table_size, seq_t key)
{
struct segwrap *selected;
selected = seghash_get (hash_table, table_size, key);
if (selected != NULL) {
int i;
i = hash_fun (key, table_size);
qremove (&hash_table[i], selected);
}
return selected;
}
struct hashtable_s* read_into_hash(const char* file_name, int *array, struct hashtable_s* hash_table) {
FILE *fp;
char *line = NULL;
size_t len = 0;
ssize_t read;
long hash;
struct entry_s *entry;
int i = 0;
fp = fopen(file_name, "r");
if (fp == NULL)
exit(EXIT_FAILURE);
//read from file
while ((read = getline(&line, &len, fp)) != -1) {
long x;
sscanf(line, "%ld\n", &x);
//printf("Original x: %lld\n", x);
array[i++] = x;
struct entry_s* data = (struct entry_s*)malloc(sizeof(struct entry_s));
data->key = x;
//printf("%lld\n", data->key);
data->value = 1;
data->next = NULL;
if (hash_table->number_of_elements >= hash_table->max) {
printf("FULL\n");
break;
}
hash = hash_fun(data->key, hash_table->max);
//printf("Hash value: %lld\n", hash);
if (hash_table->elements[hash] == NULL)
hash_table->elements[hash] = data;
else {
entry = hash_table->elements[hash];
while (entry->next != NULL && entry->key != data->key)
entry = entry->next;
if (entry->key == data->key)
entry->value++;
else
entry->next = data;
}
hash_table->number_of_elements++;
}
fclose(fp);
if (line)
free(line);
return hash_table;
}
void add_entry(PHASH* ph, HELEM elem)
{
if(ph -> num_used == ph -> length)
{
printf("The hash table is already full.\n");
exit(1);
}
int start_idx = hash_fun(elem.key) % (ph -> length);
int idx = start_idx;
while(!is_null_entry((ph -> p)[idx].key))
idx = (idx + 1) % (ph -> length);
(ph -> p)[idx] = elem;
(ph -> num_used) += 1;
}
/* Check whether data in hashtable */
int hash_count(long key, struct hashtable_s* hash_table) {
long hash;
int count = 0;
struct entry_s* entry;
hash = hash_fun(key, hash_table->max);
entry = hash_table->elements[hash];
while (entry != NULL) {
if (entry->key == key) {
count = count + entry->value;
break;
}
entry = entry->next;
}
return count;
}
void
seghash_add
(struct segwrap **hash_table, size_t table_size, struct segwrap *sw)
{
int i;
assert (hash_table != NULL);
assert (table_size > 0);
assert (sw != NULL);
i = hash_fun (seg_seq (sw->sw_seg), table_size);
assert (i >= 0);
assert (i < table_size);
qenqueue (&hash_table[i], sw);
}
static struct owner* new_owner(int n)
{
struct owner* p;
struct passwd *u;
p = (struct owner*) malloc(sizeof *p);
if (!p) allocate_error();
memset(p, 0, sizeof *p);
u = getpwuid(n);
if (!u) sprintf(p->name, "%d", n);
else {
strncpy(p->name, u->pw_name, NAME_SIZE);
p->name[NAME_SIZE] = 0;
}
p->uid = n;
list_add(hash_table[hash_fun(n)], p);
return p;
}
//way==1用于ip连接数的删除
int hash_del(HASHNODE *hash_table[],char *key,int way)
{
int tempi=0;
char tempstr[20];
//
HASHNODE *p = hash_search(hash_table,key);
if(p == NULL)
return -1;
if(way==1)//如果ip连接数大于1,只是把数量减1,不删除节点
{
tempi=atoi(p->val);
tempi-=1;
free(p->val);
sprintf(tempstr,"%d",tempi);
p->val=(char *)strdup(tempstr);
}
else
{
unsigned int index = hash_fun(key);
if(p==hash_table[index] )//如果要删除的p结点是该
{
if(p->next==NULL)//第一个并且只有一个节点
hash_table[index]=NULL;
else //是第一个结点但其后面还有节点
{
//p->next->prev=p->prev;
hash_table[index]=p->next;
}
}
else //要删除的不是第一个结点
{
p->prev->next=p->next;//不是最后一个结点
if(p->next==NULL)//删除的是最后一个结点
p->prev->next=NULL;
}
free(p);
p=NULL;
}
return 0;
}
//Return the idx of the element, -1 if not exist
int exist_in_hash(PHASH* ph, TPAIR tp)
{
int start_idx = hash_fun(tp) % (ph -> length);
int idx = start_idx;
TPAIR temp_pair;
while(1)
{
temp_pair = (ph -> p)[idx].key;
if(is_null_entry(temp_pair))
return -1;
else if(pair_equal(temp_pair, tp))
return idx;
else
{
idx = (idx + 1) % (ph -> length);
if(idx == start_idx)
return -1;
}
}
}
static int
hash_set_internal(struct session *sessions, unsigned long sz,
uint32_t laddr, uint32_t raddr, uint16_t lport, uint16_t rport,
struct timeval value)
{
struct session *session;
unsigned long port;
port = hash_fun(laddr, raddr, lport, rport) % sz;
for (session = sessions + port; session->next; session = session->next)
if (
session->next->raddr == raddr &&
session->next->laddr == laddr &&
session->next->rport == rport &&
session->next->lport == lport
)
{
session->next->tv = value;
return 0;
}
session->next = malloc(sizeof(struct session));
if (!session->next)
abort();
session->next->raddr = raddr;
session->next->laddr = laddr;
session->next->rport = rport;
session->next->lport = lport;
session->next->tv = value;
session->next->next = NULL;
return 1;
}
int hash_insert(HASHNODE *hash_table[],char *key, char *val,int way,HASH_FUN fun1)
{
HASHNODE * p=hash_search(hash_table,key);
int index,tempi=0;
char tempstr[10];
if(p==NULL)//hash表中没有该节点
{
p=(HASHNODE *)malloc(sizeof(HASHNODE));
if(p==NULL)
{
perror("malloc");
return -1 ;
}
memset(p,0,sizeof(HASHNODE));
p->key = (char *)strdup(key);
if(p->key==NULL)
{
free(p);
return -1;
}
if(way==0)//hash_conf,hash_pid_ip
{
p->val =(char *) strdup(val);//(char *)
if(p->val==NULL)
{
free(p->key);
free(p);
return -1;
}
}
else if(way==1)//hash_ip_count
{
char str[2];
sprintf(str,"%d",1);
p->val=(char *)strdup(str);
if(p->val==NULL)
{
free(p->key);
free(p);
return -1;
}
}
else if(way==2)//hash_fun
{
p->fun=fun1;//(HASH_FUN)val
}
p->next = NULL;
p->prev = NULL;
index=hash_fun(key);
if(hash_table[index]==NULL)//头节点
hash_table[index]=p;
else
{
p->next = hash_table[index];
//hash_table[index]->prev = p;
hash_table[index] = p;
}
}
else //p不为空，插入hash_ip_count时 同一IP的数量加1
{
tempi=atoi(p->val);
tempi+=1;
free(p->val);
sprintf(tempstr,"%d",tempi);
p->val=(char *)strdup(tempstr);
}
return 0;
}
unsigned int testHashFunction(const void *key)
{
Key_t *k1 = (Key_t*)key;
return hash_fun(k1->laddr, k1->raddr, k1->lport, k1->rport);
};