@@ -713,12 +713,12 @@ static struct gw_client *get_ip_addr(struct sockaddr_in *client_addr)
* the ip address is the first/second field in the struct */
int compare_wip(void *data1, void *data2)
{
- return ( memcmp( data1, data2, 4 ) );
+ return ( !memcmp( data1, data2, 4 ) );
}
int compare_vip(void *data1, void *data2)
{
- return ( memcmp( data1 + 4, data2 + 4, 4 ) );
+ return ( !memcmp( data1 + 4, data2 + 4, 4 ) );
}
/* hashfunction to choose an entry in a hash table of given size */
@@ -693,12 +693,12 @@ static int kernel_recvmsg(struct socket *sock, struct msghdr *msg, struct iovec
int compare_wip(void *data1, void *data2)
{
- return ( memcmp( data1, data2, 4 ) );
+ return ( !memcmp( data1, data2, 4 ) );
}
int compare_vip(void *data1, void *data2)
{
- return ( memcmp( data1 + 4, data2 + 4, 4 ) );
+ return ( !memcmp( data1 + 4, data2 + 4, 4 ) );
}
int choose_wip(void *data, int32_t size)
@@ -1,6 +1,6 @@
-/* Copyright (C) 2006 B.A.T.M.A.N. contributors:
+/*
+ * Copyright (C) 2006-2008 B.A.T.M.A.N. contributors:
* Simon Wunderlich, Marek Lindner
- *
* This program is free software; you can redistribute it and/or
* modify it under the terms of version 2 of the GNU General Public
* License as published by the Free Software Foundation.
@@ -17,294 +17,304 @@
*
*/
+
+
+
+
#include <linux/string.h> /* strlen, strstr, strncmp ... */
#include <linux/slab.h>
#include "hash.h"
+
/* clears the hash */
-void hash_init(struct hashtable_t *hash) {
+void hash_init(struct hashtable_t *hash)
+{
int i;
- hash->elements=0;
- for (i=0 ; i<hash->size ; i++) {
+
+ hash->elements = 0;
+
+ for (i = 0 ; i < hash->size; i++)
hash->table[i] = NULL;
- }
}
-
/* remove the hash structure. if hashdata_free_cb != NULL,
* this function will be called to remove the elements inside of the hash.
* if you don't remove the elements, memory might be leaked. */
-void hash_delete(struct hashtable_t *hash, hashdata_free_cb free_cb) {
+void hash_delete(struct hashtable_t *hash, hashdata_free_cb free_cb)
+{
struct element_t *bucket, *last_bucket;
int i;
- for (i=0; i<hash->size; i++) {
+ for (i = 0; i < hash->size; i++) {
+ bucket = hash->table[i];
- bucket= hash->table[i];
while (bucket != NULL) {
+ if (free_cb != NULL)
+ free_cb(bucket->data);
- if (free_cb!=NULL)
- free_cb( bucket->data );
-
- last_bucket= bucket;
- bucket= bucket->next;
+ last_bucket = bucket;
+ bucket = bucket->next;
kfree(last_bucket);
-
}
}
+
hash_destroy(hash);
}
-
-
/* free only the hashtable and the hash itself. */
-void hash_destroy(struct hashtable_t *hash) {
-
- kfree( hash->table );
- kfree( hash );
-
+void hash_destroy(struct hashtable_t *hash)
+{
+ kfree(hash->table);
+ kfree(hash);
}
-
-
-
/* iterate though the hash. first element is selected with iter_in NULL.
* use the returned iterator to access the elements until hash_it_t returns NULL. */
-struct hash_it_t *hash_iterate(struct hashtable_t *hash, struct hash_it_t *iter_in) {
+struct hash_it_t *hash_iterate(struct hashtable_t *hash, struct hash_it_t *iter_in)
+{
struct hash_it_t *iter;
if (iter_in == NULL) {
- iter= kmalloc(sizeof(struct hash_it_t), GFP_KERNEL);
- iter->index = -1;
+ iter = kmalloc(sizeof(struct hash_it_t), GFP_KERNEL);
+ iter->index = -1;
iter->bucket = NULL;
iter->prev_bucket = NULL;
- } else
+ } else {
iter= iter_in;
+ }
/* sanity checks first (if our bucket got deleted in the last iteration): */
- if (iter->bucket!=NULL) {
+ if (iter->bucket != NULL) {
if (iter->first_bucket != NULL) {
-
/* we're on the first element and it got removed after the last iteration. */
if ((*iter->first_bucket) != iter->bucket) {
-
/* there are still other elements in the list */
- if ( (*iter->first_bucket) != NULL ) {
+ if ((*iter->first_bucket) != NULL) {
iter->prev_bucket = NULL;
- iter->bucket= (*iter->first_bucket);
- iter->first_bucket = &hash->table[ iter->index ];
- return(iter);
+ iter->bucket = (*iter->first_bucket);
+ iter->first_bucket = &hash->table[iter->index];
+ return iter;
} else {
iter->bucket = NULL;
}
-
}
-
- } else if ( iter->prev_bucket != NULL ) {
-
- /* we're not on the first element, and the bucket got removed after the last iteration.
+ } else if (iter->prev_bucket != NULL) {
+ /*
+ * we're not on the first element, and the bucket got removed after the last iteration.
* the last bucket's next pointer is not pointing to our actual bucket anymore.
- * select the next. */
- if ( iter->prev_bucket->next != iter->bucket )
- iter->bucket= iter->prev_bucket;
-
+ * select the next.
+ */
+ if (iter->prev_bucket->next != iter->bucket)
+ iter->bucket = iter->prev_bucket;
}
-
}
/* now as we are sane, select the next one if there is some */
- if (iter->bucket!=NULL) {
- if (iter->bucket->next!=NULL) {
- iter->prev_bucket= iter->bucket;
- iter->bucket= iter->bucket->next;
+ if (iter->bucket != NULL) {
+ if (iter->bucket->next != NULL) {
+ iter->prev_bucket = iter->bucket;
+ iter->bucket = iter->bucket->next;
iter->first_bucket = NULL;
- return(iter);
+ return iter;
}
}
- /* if not returned yet, we've reached the last one on the index and have to search forward */
+ /* if not returned yet, we've reached the last one on the index and have to search forward */
iter->index++;
- while ( iter->index < hash->size ) { /* go through the entries of the hash table */
- if ((hash->table[ iter->index ]) != NULL){
+ /* go through the entries of the hash table */
+ while (iter->index < hash->size) {
+ if ((hash->table[iter->index]) != NULL){
iter->prev_bucket = NULL;
- iter->bucket = hash->table[ iter->index ];
- iter->first_bucket = &hash->table[ iter->index ];
- return(iter); /* if this table entry is not null, return it */
- } else
- iter->index++; /* else, go to the next */
+ iter->bucket = hash->table[iter->index];
+ iter->first_bucket = &hash->table[iter->index];
+ return iter;
+ } else {
+ iter->index++;
+ }
}
+
/* nothing to iterate over anymore */
kfree(iter);
- return(NULL);
+ return NULL;
}
-
/* allocates and clears the hash */
-struct hashtable_t *hash_new(int size, hashdata_compare_cb compare, hashdata_choose_cb choose) {
+struct hashtable_t *hash_new(int size, hashdata_compare_cb compare, hashdata_choose_cb choose)
+{
struct hashtable_t *hash;
- hash= kmalloc( sizeof(struct hashtable_t) , GFP_KERNEL);
- if ( hash == NULL ) /* could not allocate the hash control structure */
- return (NULL);
+ hash = kmalloc(sizeof(struct hashtable_t) , GFP_KERNEL);
+
+ if (hash == NULL)
+ return NULL;
- hash->size= size;
- hash->table= kmalloc( sizeof(struct element_t *) * size, GFP_KERNEL);
- if ( hash->table == NULL ) { /* could not allocate the table */
+ hash->size = size;
+ hash->table = kmalloc(sizeof(struct element_t *) * size, GFP_KERNEL);
+
+ if (hash->table == NULL) {
kfree(hash);
- return(NULL);
+ return NULL;
}
+
hash_init(hash);
- hash->compare= compare;
- hash->choose= choose;
- return(hash);
-}
+ hash->compare = compare;
+ hash->choose = choose;
+
+ return hash;
+}
/* adds data to the hashtable. returns 0 on success, -1 on error */
-int hash_add(struct hashtable_t *hash, void *data) {
+int hash_add(struct hashtable_t *hash, void *data)
+{
int index;
struct element_t *bucket, *prev_bucket = NULL;
- index = hash->choose( data, hash->size );
+ index = hash->choose(data, hash->size);
bucket = hash->table[index];
- while ( bucket!=NULL ) {
- if (0 == hash->compare( bucket->data, data ))
- return(-1);
+ while (bucket != NULL) {
+ if (hash->compare(bucket->data, data))
+ return -1;
prev_bucket = bucket;
- bucket= bucket->next;
+ bucket = bucket->next;
}
/* found the tail of the list, add new element */
- if (NULL == (bucket= kmalloc(sizeof(struct element_t),GFP_KERNEL)))
- return(-1); /* debugMalloc failed */
+ bucket = kmalloc(sizeof(struct element_t),GFP_KERNEL);
+
+ if (bucket == NULL)
+ return -1;
- bucket->data= data; /* init the new bucket */
- bucket->next= NULL;
+ bucket->data = data;
+ bucket->next = NULL;
/* and link it */
- if ( prev_bucket == NULL ) {
+ if (prev_bucket == NULL)
hash->table[index] = bucket;
- } else {
+ else
prev_bucket->next = bucket;
- }
hash->elements++;
- return(0);
-
+ return 0;
}
+
/* finds data, based on the key in keydata. returns the found data on success, or NULL on error */
-void *hash_find(struct hashtable_t *hash, void *keydata) {
+void *hash_find(struct hashtable_t *hash, void *keydata)
+{
int index;
struct element_t *bucket;
- index = hash->choose( keydata , hash->size );
+ index = hash->choose(keydata , hash->size);
bucket = hash->table[index];
- while ( bucket!=NULL ) {
- if (0 == hash->compare( bucket->data, keydata ))
- return( bucket->data );
+ while (bucket != NULL) {
+ if (hash->compare(bucket->data, keydata))
+ return bucket->data;
- bucket= bucket->next;
+ bucket = bucket->next;
}
- return(NULL);
-
+ return NULL;
}
/* remove bucket (this might be used in hash_iterate() if you already found the bucket
* you want to delete and don't need the overhead to find it again with hash_remove().
* But usually, you don't want to use this function, as it fiddles with hash-internals. */
-void *hash_remove_bucket(struct hashtable_t *hash, struct hash_it_t *hash_it_t) {
+void *hash_remove_bucket(struct hashtable_t *hash, struct hash_it_t *hash_it_t)
+{
void *data_save;
- data_save = hash_it_t->bucket->data; /* save the pointer to the data */
+ data_save = hash_it_t->bucket->data;
- if ( hash_it_t->prev_bucket != NULL ) {
+ if (hash_it_t->prev_bucket != NULL)
hash_it_t->prev_bucket->next = hash_it_t->bucket->next;
- } else if ( hash_it_t->first_bucket != NULL ) {
+ else if (hash_it_t->first_bucket != NULL)
(*hash_it_t->first_bucket) = hash_it_t->bucket->next;
- }
kfree(hash_it_t->bucket);
-
hash->elements--;
- return( data_save );
+ return data_save;
}
-
/* removes data from hash, if found. returns pointer do data on success,
* so you can remove the used structure yourself, or NULL on error .
* data could be the structure you use with just the key filled,
* we just need the key for comparing. */
-void *hash_remove(struct hashtable_t *hash, void *data) {
+void *hash_remove(struct hashtable_t *hash, void *data)
+{
struct hash_it_t hash_it_t;
- hash_it_t.index = hash->choose( data, hash->size );
+ hash_it_t.index = hash->choose(data, hash->size);
hash_it_t.bucket = hash->table[hash_it_t.index];
hash_it_t.prev_bucket = NULL;
- while ( hash_it_t.bucket!=NULL ) {
- if (0 == hash->compare( hash_it_t.bucket->data, data )) {
+ while (hash_it_t.bucket != NULL) {
+ if (hash->compare(hash_it_t.bucket->data, data)) {
hash_it_t.first_bucket = (hash_it_t.bucket == hash->table[hash_it_t.index] ? &hash->table[ hash_it_t.index ] : NULL);
- return( hash_remove_bucket(hash, &hash_it_t) );
+ return hash_remove_bucket(hash, &hash_it_t);
}
hash_it_t.prev_bucket = hash_it_t.bucket;
hash_it_t.bucket= hash_it_t.bucket->next;
}
- return(NULL);
-
+ return NULL;
}
-
/* resize the hash, returns the pointer to the new hash or NULL on error. removes the old hash on success. */
-struct hashtable_t *hash_resize(struct hashtable_t *hash, int size) {
+struct hashtable_t *hash_resize(struct hashtable_t *hash, int size)
+{
struct hashtable_t *new_hash;
struct element_t *bucket;
int i;
/* initialize a new hash with the new size */
- if (NULL == (new_hash= hash_new(size, hash->compare, hash->choose)))
- return(NULL);
+ new_hash = hash_new(size, hash->compare, hash->choose);
+
+ if (new_hash == NULL)
+ return NULL;
/* copy the elements */
- for (i=0; i<hash->size; i++) {
- bucket= hash->table[i];
+ for (i = 0; i < hash->size; i++) {
+ bucket = hash->table[i];
+
while (bucket != NULL) {
- hash_add( new_hash, bucket->data );
- bucket= bucket->next;
+ hash_add(new_hash, bucket->data);
+ bucket = bucket->next;
}
}
- hash_delete(hash, NULL); /* remove hash and eventual overflow buckets but not the content itself. */
- return( new_hash);
+ /* remove hash and eventual overflow buckets but not the content itself. */
+ hash_delete(hash, NULL);
+ return new_hash;
}
-/* print the hash table for debugging */
-void hash_debug(struct hashtable_t *hash) {
+/* print the hash table for debugging
+void hash_debug(struct hashtable_t *hash)
+{
int i;
struct element_t *bucket;
for (i=0; i<hash->size;i++) {
- printk("[%d] ",i);
+ printf("[%d] ",i);
bucket= hash->table[i];
while (bucket != NULL) {
- printk("-> [%10p] ", bucket);
+ printf("-> [%10p] ", bucket);
bucket= bucket->next;
}
- printk("\n");
+ printf("\n");
}
- printk("\n");
+ printf("\n");
}
+ */
@@ -1,6 +1,6 @@
-/* Copyright (C) 2006 B.A.T.M.A.N. contributors:
+/*
+ * Copyright (C) 2006-2008 B.A.T.M.A.N. contributors:
* Simon Wunderlich, Marek Lindner
- *
* This program is free software; you can redistribute it and/or
* modify it under the terms of version 2 of the GNU General Public
* License as published by the Free Software Foundation.
@@ -16,6 +16,11 @@
* 02110-1301, USA
*
*/
+
+
+
+
+
#ifndef _BATMAN_HASH_H
#define _BATMAN_HASH_H