140 lines
3.6 KiB
C
140 lines
3.6 KiB
C
#include "hash_state.h"
|
|
#include <stdlib.h>
|
|
#include <assert.h>
|
|
#include <limits.h>
|
|
#include <string.h>
|
|
|
|
//#define DEBUG
|
|
#include "debug.h"
|
|
|
|
const char *cmph_hash_names[] = { "djb2", "fnv", "jenkins", "sdbm", NULL };
|
|
|
|
hash_state_t *hash_state_new(CMPH_HASH hashfunc, cmph_uint32 hashsize)
|
|
{
|
|
hash_state_t *state = NULL;
|
|
switch (hashfunc)
|
|
{
|
|
case CMPH_HASH_JENKINS:
|
|
DEBUGP("Jenkins function - %u\n", hashsize);
|
|
state = (hash_state_t *)jenkins_state_new(hashsize);
|
|
DEBUGP("Jenkins function created\n");
|
|
break;
|
|
case CMPH_HASH_DJB2:
|
|
state = (hash_state_t *)djb2_state_new();
|
|
break;
|
|
case CMPH_HASH_SDBM:
|
|
state = (hash_state_t *)sdbm_state_new();
|
|
break;
|
|
case CMPH_HASH_FNV:
|
|
state = (hash_state_t *)fnv_state_new();
|
|
break;
|
|
default:
|
|
assert(0);
|
|
}
|
|
state->hashfunc = hashfunc;
|
|
return state;
|
|
}
|
|
cmph_uint32 hash(hash_state_t *state, const char *key, cmph_uint32 keylen)
|
|
{
|
|
switch (state->hashfunc)
|
|
{
|
|
case CMPH_HASH_JENKINS:
|
|
return jenkins_hash((jenkins_state_t *)state, key, keylen);
|
|
case CMPH_HASH_DJB2:
|
|
return djb2_hash((djb2_state_t *)state, key, keylen);
|
|
case CMPH_HASH_SDBM:
|
|
return sdbm_hash((sdbm_state_t *)state, key, keylen);
|
|
case CMPH_HASH_FNV:
|
|
return fnv_hash((fnv_state_t *)state, key, keylen);
|
|
default:
|
|
assert(0);
|
|
}
|
|
assert(0);
|
|
return 0;
|
|
}
|
|
|
|
void hash_state_dump(hash_state_t *state, char **buf, cmph_uint32 *buflen)
|
|
{
|
|
char *algobuf;
|
|
switch (state->hashfunc)
|
|
{
|
|
case CMPH_HASH_JENKINS:
|
|
jenkins_state_dump((jenkins_state_t *)state, &algobuf, buflen);
|
|
if (*buflen == UINT_MAX) return;
|
|
break;
|
|
case CMPH_HASH_DJB2:
|
|
djb2_state_dump((djb2_state_t *)state, &algobuf, buflen);
|
|
if (*buflen == UINT_MAX) return;
|
|
break;
|
|
case CMPH_HASH_SDBM:
|
|
sdbm_state_dump((sdbm_state_t *)state, &algobuf, buflen);
|
|
if (*buflen == UINT_MAX) return;
|
|
break;
|
|
case CMPH_HASH_FNV:
|
|
fnv_state_dump((fnv_state_t *)state, &algobuf, buflen);
|
|
if (*buflen == UINT_MAX) return;
|
|
break;
|
|
default:
|
|
assert(0);
|
|
}
|
|
*buf = malloc(strlen(cmph_hash_names[state->hashfunc]) + 1 + *buflen);
|
|
memcpy(*buf, cmph_hash_names[state->hashfunc], strlen(cmph_hash_names[state->hashfunc]) + 1);
|
|
DEBUGP("Algobuf is %u\n", *(cmph_uint32 *)algobuf);
|
|
memcpy(*buf + strlen(cmph_hash_names[state->hashfunc]) + 1, algobuf, *buflen);
|
|
*buflen = (cmph_uint32)strlen(cmph_hash_names[state->hashfunc]) + 1 + *buflen;
|
|
free(algobuf);
|
|
return;
|
|
}
|
|
|
|
hash_state_t *hash_state_load(const char *buf, cmph_uint32 buflen)
|
|
{
|
|
cmph_uint32 i;
|
|
cmph_uint32 offset;
|
|
CMPH_HASH hashfunc = CMPH_HASH_COUNT;
|
|
for (i = 0; i < CMPH_HASH_COUNT; ++i)
|
|
{
|
|
if (strcmp(buf, cmph_hash_names[i]) == 0)
|
|
{
|
|
hashfunc = i;
|
|
break;
|
|
}
|
|
}
|
|
if (hashfunc == CMPH_HASH_COUNT) return NULL;
|
|
offset = (cmph_uint32)strlen(cmph_hash_names[hashfunc]) + 1;
|
|
switch (hashfunc)
|
|
{
|
|
case CMPH_HASH_JENKINS:
|
|
return (hash_state_t *)jenkins_state_load(buf + offset, buflen - offset);
|
|
case CMPH_HASH_DJB2:
|
|
return (hash_state_t *)djb2_state_load(buf + offset, buflen - offset);
|
|
case CMPH_HASH_SDBM:
|
|
return (hash_state_t *)sdbm_state_load(buf + offset, buflen - offset);
|
|
case CMPH_HASH_FNV:
|
|
return (hash_state_t *)fnv_state_load(buf + offset, buflen - offset);
|
|
default:
|
|
return NULL;
|
|
}
|
|
return NULL;
|
|
}
|
|
void hash_state_destroy(hash_state_t *state)
|
|
{
|
|
switch (state->hashfunc)
|
|
{
|
|
case CMPH_HASH_JENKINS:
|
|
jenkins_state_destroy((jenkins_state_t *)state);
|
|
break;
|
|
case CMPH_HASH_DJB2:
|
|
djb2_state_destroy((djb2_state_t *)state);
|
|
break;
|
|
case CMPH_HASH_SDBM:
|
|
sdbm_state_destroy((sdbm_state_t *)state);
|
|
break;
|
|
case CMPH_HASH_FNV:
|
|
fnv_state_destroy((fnv_state_t *)state);
|
|
break;
|
|
default:
|
|
assert(0);
|
|
}
|
|
return;
|
|
}
|