static int HashListTableTestAdd03 (void)
{
int result = 0;
HashListTable *ht = HashListTableInit(32, HashListTableGenericHash, NULL, NULL);
if (ht == NULL)
goto end;
int r = HashListTableAdd(ht, "test", 0);
if (r != 0)
goto end;
if (ht->listhead == NULL) {
printf("ht->listhead == NULL: ");
goto end;
}
if (ht->listtail == NULL) {
printf("ht->listtail == NULL: ");
goto end;
}
/* all is good! */
result = 1;
end:
if (ht != NULL) HashListTableFree(ht);
return result;
}
static int HashListTableTestFull02 (void)
{
int result = 0;
HashListTable *ht = HashListTableInit(32, HashListTableGenericHash, NULL, NULL);
if (ht == NULL)
goto end;
int r = HashListTableAdd(ht, "test", 4);
if (r != 0)
goto end;
char *rp = HashListTableLookup(ht, "test", 4);
if (rp == NULL)
goto end;
r = HashListTableRemove(ht, "test2", 5);
if (r == 0)
goto end;
/* all is good! */
result = 1;
end:
if (ht != NULL) HashListTableFree(ht);
return result;
}
static int HashListTableTestInit04 (void)
{
HashListTable *ht = HashListTableInit(0, HashListTableGenericHash, NULL, NULL);
if (ht == NULL)
return 1;
HashListTableFree(ht);
return 0;
}
/* no hash function, so it should fail */
static int HashListTableTestInit02 (void)
{
HashListTable *ht = HashListTableInit(1024, NULL, NULL, NULL);
if (ht == NULL)
return 1;
HashListTableFree(ht);
return 0;
}
/**
* \brief Init threshold context hash tables
*
* \param de_ctx Dectection Context
*
*/
void ThresholdHashInit(DetectEngineCtx *de_ctx)
{
if (de_ctx->ths_ctx.threshold_hash_table_dst == NULL ||
de_ctx->ths_ctx.threshold_hash_table_src == NULL ||
de_ctx->ths_ctx.threshold_hash_table_src_ipv6 == NULL ||
de_ctx->ths_ctx.threshold_hash_table_dst_ipv6 == NULL) {
de_ctx->ths_ctx.threshold_hash_table_dst = HashListTableInit(THRESHOLD_HASH_SIZE, ThresholdHashFunc, ThresholdCompareFunc, ThresholdFreeFunc);
if(de_ctx->ths_ctx.threshold_hash_table_dst == NULL) {
SCLogError(SC_ERR_MEM_ALLOC,
"Threshold: Failed to initialize ipv4 dst hash table.");
exit(EXIT_FAILURE);
}
de_ctx->ths_ctx.threshold_hash_table_src = HashListTableInit(THRESHOLD_HASH_SIZE, ThresholdHashFunc, ThresholdCompareFunc, ThresholdFreeFunc);
if(de_ctx->ths_ctx.threshold_hash_table_dst == NULL) {
SCLogError(SC_ERR_MEM_ALLOC,
"Threshold: Failed to initialize ipv4 src hash table.");
exit(EXIT_FAILURE);
}
de_ctx->ths_ctx.threshold_hash_table_src_ipv6 = HashListTableInit(THRESHOLD_HASH_SIZE, ThresholdHashFunc, ThresholdCompareFunc, ThresholdFreeFunc);
if(de_ctx->ths_ctx.threshold_hash_table_dst == NULL) {
SCLogError(SC_ERR_MEM_ALLOC,
"Threshold: Failed to initialize ipv6 src hash table.");
exit(EXIT_FAILURE);
}
de_ctx->ths_ctx.threshold_hash_table_dst_ipv6 = HashListTableInit(THRESHOLD_HASH_SIZE, ThresholdHashFunc, ThresholdCompareFunc, ThresholdFreeFunc);
if(de_ctx->ths_ctx.threshold_hash_table_dst == NULL) {
SCLogError(SC_ERR_MEM_ALLOC,
"Threshold: Failed to initialize ipv6 dst hash table.");
exit(EXIT_FAILURE);
}
if (SCMutexInit(&de_ctx->ths_ctx.threshold_table_lock, NULL) != 0) {
SCLogError(SC_ERR_MEM_ALLOC,
"Threshold: Failed to initialize hash table mutex.");
exit(EXIT_FAILURE);
}
}
}
/**
* \brief Initializes the hash table in the detection engine context to hold the
* SigGroupHeads.
*
* \param de_ctx Pointer to the detection engine context.
*
* \retval 0 On success.
* \retval -1 On failure.
*/
int SigGroupHeadHashInit(DetectEngineCtx *de_ctx)
{
de_ctx->sgh_hash_table = HashListTableInit(4096, SigGroupHeadHashFunc,
SigGroupHeadCompareFunc, NULL);
if (de_ctx->sgh_hash_table == NULL)
goto error;
return 0;
error:
return -1;
}
static int HashListTableTestInit03 (void)
{
int result = 0;
HashListTable *ht = HashListTableInit(1024, HashListTableGenericHash, NULL, NULL);
if (ht == NULL)
return 0;
if (ht->Hash == HashListTableGenericHash)
result = 1;
HashListTableFree(ht);
return result;
}
/**
* \brief Initializes the MpmStore mpm hash table to be used by the detection
* engine context.
*
* \param de_ctx Pointer to the detection engine context.
*
* \retval 0 On success.
* \retval -1 On failure.
*/
int MpmStoreInit(DetectEngineCtx *de_ctx)
{
de_ctx->mpm_hash_table = HashListTableInit(4096,
MpmStoreHashFunc,
MpmStoreCompareFunc,
MpmStoreFreeFunc);
if (de_ctx->mpm_hash_table == NULL)
goto error;
return 0;
error:
return -1;
}
static int HashListTableTestAdd02 (void)
{
int result = 0;
HashListTable *ht = HashListTableInit(32, HashListTableGenericHash, NULL, NULL);
if (ht == NULL)
goto end;
int r = HashListTableAdd(ht, NULL, 4);
if (r == 0)
goto end;
/* all is good! */
result = 1;
end:
if (ht != NULL) HashListTableFree(ht);
return result;
}
static int HashListTableTestAdd04 (void)
{
int result = 0;
HashListTable *ht = HashListTableInit(32, HashListTableGenericHash, NULL, NULL);
if (ht == NULL)
goto end;
int r = HashListTableAdd(ht, "test", 4);
if (r != 0)
goto end;
char *rp = HashListTableLookup(ht, "test", 4);
if (rp == NULL)
goto end;
HashListTableBucket *htb = HashListTableGetListHead(ht);
if (htb == NULL) {
printf("htb == NULL: ");
goto end;
}
char *rp2 = HashListTableGetListData(htb);
if (rp2 == NULL) {
printf("rp2 == NULL: ");
goto end;
}
if (rp != rp2) {
printf("rp != rp2: ");
goto end;
}
/* all is good! */
result = 1;
end:
if (ht != NULL) HashListTableFree(ht);
return result;
}
static int PrefilterSetupPacketHeaderCommon(SigGroupHead *sgh, int sm_type,
void (*Set)(PrefilterPacketHeaderValue *v, void *),
_Bool (*Compare)(PrefilterPacketHeaderValue v, void *),
void (*Match)(DetectEngineThreadCtx *det_ctx,
Packet *p, const void *pectx),
_Bool u8hash)
{
Signature *s = NULL;
uint32_t sig = 0;
if (sgh == NULL)
return 0;
/* first count how many engines we will need */
HashListTable *hash_table = HashListTableInit(4096,
PrefilterPacketHeaderHashFunc,
PrefilterPacketHeaderCompareFunc,
PrefilterPacketHeaderFreeFunc);
if (hash_table == NULL)
return -1;
for (sig = 0; sig < sgh->sig_cnt; sig++) {
s = sgh->match_array[sig];
if (s == NULL)
continue;
if (s->prefilter_sm == NULL || s->prefilter_sm->type != sm_type)
continue;
PrefilterPacketHeaderHashCtx ctx;
memset(&ctx, 0, sizeof(ctx));
Set(&ctx.v1, s->prefilter_sm->ctx);
GetExtraMatch(s, &ctx.type, &ctx.value);
PrefilterPacketHeaderHashCtx *rctx = HashListTableLookup(hash_table, (void *)&ctx, 0);
if (rctx != 0) {
rctx->cnt++;
} else {
PrefilterPacketHeaderHashCtx *actx = SCCalloc(1, sizeof(*actx));
if (actx == NULL)
goto error;
Set(&actx->v1, s->prefilter_sm->ctx);
actx->cnt = 1;
actx->type = ctx.type;
actx->value = ctx.value;
int ret = HashListTableAdd(hash_table, actx, 0);
if (ret != 0) {
SCFree(actx);
goto error;
}
}
}
if (u8hash == FALSE) {
SetupSingle(hash_table, sgh, sm_type, Compare, Match);
} else {
SetupU8Hash(hash_table, sgh, sm_type, Set, Compare, Match);
}
HashListTableFree(hash_table);
return 0;
error:
HashListTableFree(hash_table);
return -1;
}
