aiden
/
suricata
mirror of https://github.com/OISF/suricata
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Use SigIntId as the type for storing signature IDs (Internal)

Browse Source 
Previously using uint32_t, but SigIntId is currently uint16_t, so arrays
will take less memory.
pull/1295/head
Ken Steele 12 years ago committed by Victor Julien
parent d01d3324fc
commit 736ac6a459
19 changed files with 105 additions and 103 deletions
Show Stats Download Patch File Download Diff File

4
src/detect-engine-siggroup.c
Unescape Escape View File

@ -1730,9 +1730,9 @@ int SigGroupHeadBuildNonMpmArray(DetectEngineCtx *de_ctx, SigGroupHead *sgh)
return 0;
}
sgh->non_mpm_id_array = SCMalloc(non_mpm * sizeof(uint32_t));
sgh->non_mpm_id_array = SCMalloc(non_mpm * sizeof(SigIntId));
BUG_ON(sgh->non_mpm_id_array == NULL);
memset(sgh->non_mpm_id_array, 0, non_mpm * sizeof(uint32_t));
memset(sgh->non_mpm_id_array, 0, non_mpm * sizeof(SigIntId));
for (sig = 0; sig < sgh->sig_cnt; sig++) {
s = sgh->match_array[sig];

26
src/detect.c
Unescape Escape View File

@ -781,12 +781,12 @@ end:
static inline void DetectPrefilterMergeSort(DetectEngineCtx *de_ctx,
DetectEngineThreadCtx *det_ctx, SigGroupHead *sgh)
{
uint32_t mpm = -1;
uint32_t nonmpm = -1;
SigIntId mpm = (SigIntId)-1;
SigIntId nonmpm = (SigIntId)-1;
det_ctx->match_array_cnt = 0;
uint32_t *mpm_ptr = det_ctx->pmq.rule_id_array;
uint32_t *nonmpm_ptr = sgh->non_mpm_id_array;
SigIntId *mpm_ptr = det_ctx->pmq.rule_id_array;
SigIntId *nonmpm_ptr = sgh->non_mpm_id_array;
uint32_t m_cnt = det_ctx->pmq.rule_id_array_cnt;
uint32_t n_cnt = sgh->non_mpm_id_cnt;
SCLogDebug("PMQ rule id array count %d", det_ctx->pmq.rule_id_array_cnt);
@ -797,21 +797,21 @@ static inline void DetectPrefilterMergeSort(DetectEngineCtx *de_ctx,
mpm = *(mpm_ptr++);
m_cnt--;
} else
mpm = -1;
mpm = (SigIntId)-1;
if (likely(n_cnt)) {
nonmpm = *(nonmpm_ptr++);
n_cnt--;
} else
nonmpm = -1;
nonmpm = (SigIntId)-1;
uint32_t previous_id = (uint32_t)-1;
SigIntId previous_id = (SigIntId)-1;
Signature **sig_array = de_ctx->sig_array;
Signature **match_array = det_ctx->match_array;
Signature *s;
while (1) {
uint32_t id = MIN(mpm, nonmpm);
SigIntId id = MIN(mpm, nonmpm);
if (unlikely(id == (uint32_t)-1))
if (unlikely(id == (SigIntId)-1))
break;
else {
s = sig_array[id];
@ -842,10 +842,10 @@ static inline void DetectPrefilterMergeSort(DetectEngineCtx *de_ctx,
BUG_ON((det_ctx->pmq.rule_id_array_cnt + sgh->non_mpm_id_cnt) < det_ctx->match_array_cnt);
}
static int DoSort(const void *a, const void *b)
static int DoSortSigIntId(const void *a, const void *b)
{
uint32_t x = *(uint32_t *)a;
uint32_t y = *(uint32_t *)b;
SigIntId x = *(SigIntId *)a;
SigIntId y = *(SigIntId *)b;
return x - y;
}
@ -1100,7 +1100,7 @@ static inline void DetectMpmPrefilter(DetectEngineCtx *de_ctx,
* NOTE due to merging of 'stream' pmqs we *MAY* have duplicate entries */
if (det_ctx->pmq.rule_id_array_cnt) {
qsort(det_ctx->pmq.rule_id_array, det_ctx->pmq.rule_id_array_cnt,
sizeof(uint32_t), DoSort);
sizeof(SigIntId), DoSortSigIntId);
}
}

2
src/detect.h
Unescape Escape View File

@ -993,7 +993,7 @@ typedef struct SigGroupHead_ {
* signatures to be inspected in a cache efficient way. */
SignatureHeader *head_array;
uint32_t *non_mpm_id_array;
SigIntId *non_mpm_id_array;
uint32_t non_mpm_id_cnt; // size is cnt * sizeof(uint32_t)
/* pattern matcher instances */

22
src/util-mpm-ac-bs.c
Unescape Escape View File

@ -65,9 +65,9 @@ void SCACBSInitThreadCtx(MpmCtx *, MpmThreadCtx *, uint32_t);
void SCACBSDestroyCtx(MpmCtx *);
void SCACBSDestroyThreadCtx(MpmCtx *, MpmThreadCtx *);
int SCACBSAddPatternCI(MpmCtx *, uint8_t *, uint16_t, uint16_t, uint16_t,
uint32_t, uint32_t, uint8_t);
uint32_t, SigIntId, uint8_t);
int SCACBSAddPatternCS(MpmCtx *, uint8_t *, uint16_t, uint16_t, uint16_t,
uint32_t, uint32_t, uint8_t);
uint32_t, SigIntId, uint8_t);
int SCACBSPreparePatterns(MpmCtx *mpm_ctx);
uint32_t SCACBSSearch(MpmCtx *mpm_ctx, MpmThreadCtx *mpm_thread_ctx,
PatternMatcherQueue *pmq, uint8_t *buf, uint16_t buflen);
@ -164,8 +164,8 @@ static inline uint32_t SCACBSInitHashRaw(uint8_t *pat, uint16_t patlen)
* \retval hash A 32 bit unsigned hash.
*/
static inline SCACBSPattern *SCACBSInitHashLookup(SCACBSCtx *ctx, uint8_t *pat,
uint16_t patlen, char flags,
uint32_t pid)
uint16_t patlen, char flags,
uint32_t pid)
{
uint32_t hash = SCACBSInitHashRaw(pat, patlen);
@ -290,8 +290,8 @@ static inline int SCACBSInitHashAdd(SCACBSCtx *ctx, SCACBSPattern *p)
* \retval -1 On failure.
*/
static int SCACBSAddPattern(MpmCtx *mpm_ctx, uint8_t *pat, uint16_t patlen,
uint16_t offset, uint16_t depth, uint32_t pid,
uint32_t sid, uint8_t flags)
uint16_t offset, uint16_t depth, uint32_t pid,
SigIntId sid, uint8_t flags)
{
SCACBSCtx *ctx = (SCACBSCtx *)mpm_ctx->ctx;
@ -372,7 +372,7 @@ static int SCACBSAddPattern(MpmCtx *mpm_ctx, uint8_t *pat, uint16_t patlen,
ctx->max_pat_id = pid;
p->sids_size = 1;
p->sids = SCMalloc(p->sids_size * sizeof(uint32_t));
p->sids = SCMalloc(p->sids_size * sizeof(SigIntId));
BUG_ON(p->sids == NULL);
p->sids[0] = sid;
} else {
@ -387,7 +387,7 @@ static int SCACBSAddPattern(MpmCtx *mpm_ctx, uint8_t *pat, uint16_t patlen,
}
}
if (!found) {
uint32_t *sids = SCRealloc(p->sids, (sizeof(uint32_t) * (p->sids_size + 1)));
SigIntId *sids = SCRealloc(p->sids, (sizeof(SigIntId) * (p->sids_size + 1)));
BUG_ON(sids == NULL);
p->sids = sids;
p->sids[p->sids_size] = sid;
@ -503,7 +503,7 @@ static void SCACBSSetOutputState(int32_t state, uint32_t pid, MpmCtx *mpm_ctx)
* \param mpm_ctx Pointer to the mpm context.
*/
static inline void SCACBSEnter(uint8_t *pattern, uint16_t pattern_len, uint32_t pid,
MpmCtx *mpm_ctx)
MpmCtx *mpm_ctx)
{
SCACBSCtx *ctx = (SCACBSCtx *)mpm_ctx->ctx;
int32_t state = 0;
@ -1635,7 +1635,7 @@ uint32_t SCACBSSearch(MpmCtx *mpm_ctx, MpmThreadCtx *mpm_thread_ctx,
*/
int SCACBSAddPatternCI(MpmCtx *mpm_ctx, uint8_t *pat, uint16_t patlen,
uint16_t offset, uint16_t depth, uint32_t pid,
uint32_t sid, uint8_t flags)
SigIntId sid, uint8_t flags)
{
flags |= MPM_PATTERN_FLAG_NOCASE;
return SCACBSAddPattern(mpm_ctx, pat, patlen, offset, depth, pid, sid, flags);
@ -1660,7 +1660,7 @@ int SCACBSAddPatternCI(MpmCtx *mpm_ctx, uint8_t *pat, uint16_t patlen,
*/
int SCACBSAddPatternCS(MpmCtx *mpm_ctx, uint8_t *pat, uint16_t patlen,
uint16_t offset, uint16_t depth, uint32_t pid,
uint32_t sid, uint8_t flags)
SigIntId sid, uint8_t flags)
{
return SCACBSAddPattern(mpm_ctx, pat, patlen, offset, depth, pid, sid, flags);
}

4
src/util-mpm-ac-bs.h
Unescape Escape View File

@ -41,7 +41,7 @@ typedef struct SCACBSPattern_ {
/* sid(s) for this pattern */
uint32_t sids_size;
uint32_t *sids;
SigIntId *sids;
struct SCACBSPattern_ *next;
} SCACBSPattern;
@ -52,7 +52,7 @@ typedef struct SCACBSPatternList_ {
/* sid(s) for this pattern */
uint32_t sids_size;
uint32_t *sids;
SigIntId *sids;
} SCACBSPatternList;
typedef struct SCACBSOutputTable_ {

16
src/util-mpm-ac-gfbs.c
Unescape Escape View File

@ -59,9 +59,9 @@ void SCACGfbsInitThreadCtx(MpmCtx *, MpmThreadCtx *, uint32_t);
void SCACGfbsDestroyCtx(MpmCtx *);
void SCACGfbsDestroyThreadCtx(MpmCtx *, MpmThreadCtx *);
int SCACGfbsAddPatternCI(MpmCtx *, uint8_t *, uint16_t, uint16_t, uint16_t,
uint32_t, uint32_t, uint8_t);
uint32_t, SigIntId, uint8_t);
int SCACGfbsAddPatternCS(MpmCtx *, uint8_t *, uint16_t, uint16_t, uint16_t,
uint32_t, uint32_t, uint8_t);
uint32_t, SigIntId, uint8_t);
int SCACGfbsPreparePatterns(MpmCtx *mpm_ctx);
uint32_t SCACGfbsSearch(MpmCtx *mpm_ctx, MpmThreadCtx *mpm_thread_ctx,
PatternMatcherQueue *pmq, uint8_t *buf, uint16_t buflen);
@ -284,7 +284,7 @@ static inline int SCACGfbsInitHashAdd(SCACGfbsCtx *ctx, SCACGfbsPattern *p)
*/
static int SCACGfbsAddPattern(MpmCtx *mpm_ctx, uint8_t *pat, uint16_t patlen,
uint16_t offset, uint16_t depth, uint32_t pid,
uint32_t sid, uint8_t flags)
SigIntId sid, uint8_t flags)
{
SCACGfbsCtx *ctx = (SCACGfbsCtx *)mpm_ctx->ctx;
@ -365,7 +365,7 @@ static int SCACGfbsAddPattern(MpmCtx *mpm_ctx, uint8_t *pat, uint16_t patlen,
ctx->max_pat_id = pid;
p->sids_size = 1;
p->sids = SCMalloc(p->sids_size * sizeof(uint32_t));
p->sids = SCMalloc(p->sids_size * sizeof(SigIntId));
BUG_ON(p->sids == NULL);
p->sids[0] = sid;
} else {
@ -380,7 +380,7 @@ static int SCACGfbsAddPattern(MpmCtx *mpm_ctx, uint8_t *pat, uint16_t patlen,
}
}
if (!found) {
uint32_t *sids = SCRealloc(p->sids, (sizeof(uint32_t) * (p->sids_size + 1)));
SigIntId *sids = SCRealloc(p->sids, (sizeof(SigIntId) * (p->sids_size + 1)));
BUG_ON(sids == NULL);
p->sids = sids;
p->sids[p->sids_size] = sid;
@ -496,7 +496,7 @@ static void SCACGfbsSetOutputState(int32_t state, uint32_t pid, MpmCtx *mpm_ctx)
* \param mpm_ctx Pointer to the mpm context.
*/
static inline void SCACGfbsEnter(uint8_t *pattern, uint16_t pattern_len, uint32_t pid,
MpmCtx *mpm_ctx)
MpmCtx *mpm_ctx)
{
SCACGfbsCtx *ctx = (SCACGfbsCtx *)mpm_ctx->ctx;
int32_t state = 0;
@ -1593,7 +1593,7 @@ uint32_t SCACGfbsSearch(MpmCtx *mpm_ctx, MpmThreadCtx *mpm_thread_ctx,
*/
int SCACGfbsAddPatternCI(MpmCtx *mpm_ctx, uint8_t *pat, uint16_t patlen,
uint16_t offset, uint16_t depth, uint32_t pid,
uint32_t sid, uint8_t flags)
SigIntId sid, uint8_t flags)
{
flags |= MPM_PATTERN_FLAG_NOCASE;
return SCACGfbsAddPattern(mpm_ctx, pat, patlen, offset, depth, pid, sid, flags);
@ -1618,7 +1618,7 @@ int SCACGfbsAddPatternCI(MpmCtx *mpm_ctx, uint8_t *pat, uint16_t patlen,
*/
int SCACGfbsAddPatternCS(MpmCtx *mpm_ctx, uint8_t *pat, uint16_t patlen,
uint16_t offset, uint16_t depth, uint32_t pid,
uint32_t sid, uint8_t flags)
SigIntId sid, uint8_t flags)
{
return SCACGfbsAddPattern(mpm_ctx, pat, patlen, offset, depth, pid, sid, flags);
}

4
src/util-mpm-ac-gfbs.h
Unescape Escape View File

@ -41,7 +41,7 @@ typedef struct SCACGfbsPattern_ {
/* sid(s) for this pattern */
uint32_t sids_size;
uint32_t *sids;
SigIntId *sids;
struct SCACGfbsPattern_ *next;
} SCACGfbsPattern;
@ -52,7 +52,7 @@ typedef struct SCACGfbsPatternList_ {
/* sid(s) for this pattern */
uint32_t sids_size;
uint32_t *sids;
SigIntId *sids;
} SCACGfbsPatternList;
typedef struct SCACGfbsOutputTable_ {

14
src/util-mpm-ac-tile.c
Unescape Escape View File

@ -94,9 +94,9 @@ void SCACTileInitThreadCtx(MpmCtx *, MpmThreadCtx *, uint32_t);
void SCACTileDestroyCtx(MpmCtx *);
void SCACTileDestroyThreadCtx(MpmCtx *, MpmThreadCtx *);
int SCACTileAddPatternCI(MpmCtx *, uint8_t *, uint16_t, uint16_t, uint16_t,
uint32_t, uint32_t, uint8_t);
uint32_t, SigIntId, uint8_t);
int SCACTileAddPatternCS(MpmCtx *, uint8_t *, uint16_t, uint16_t, uint16_t,
uint32_t, uint32_t, uint8_t);
uint32_t, SigIntId, uint8_t);
int SCACTilePreparePatterns(MpmCtx *mpm_ctx);
uint32_t SCACTileSearch(MpmCtx *mpm_ctx, MpmThreadCtx *mpm_thread_ctx,
PatternMatcherQueue *pmq, uint8_t *buf,
@ -512,7 +512,7 @@ static int SCACTileAddPattern(MpmCtx *mpm_ctx, uint8_t *pat, uint16_t patlen,
}
p->sids_size = 1;
p->sids = SCMalloc(p->sids_size * sizeof(uint32_t));
p->sids = SCMalloc(p->sids_size * sizeof(SigIntId));
BUG_ON(p->sids == NULL);
p->sids[0] = sid;
//SCLogInfo("MPM added %u:%u", pid, sid);
@ -528,7 +528,7 @@ static int SCACTileAddPattern(MpmCtx *mpm_ctx, uint8_t *pat, uint16_t patlen,
}
}
if (!found) {
uint32_t *sids = SCRealloc(p->sids, (sizeof(uint32_t) * (p->sids_size + 1)));
SigIntId *sids = SCRealloc(p->sids, (sizeof(SigIntId) * (p->sids_size + 1)));
BUG_ON(sids == NULL);
p->sids = sids;
p->sids[p->sids_size] = sid;
@ -1473,7 +1473,7 @@ int CheckMatch(SCACTileSearchCtx *ctx, PatternMatcherQueue *pmq,
SCACTilePatternList *pattern_list = ctx->pattern_list;
uint8_t *buf_offset = buf + i + 1; // Lift out of loop
uint32_t no_of_entries = ctx->output_table[state].no_of_entries;
uint32_t *patterns = ctx->output_table[state].patterns;
MpmPatternIndex *patterns = ctx->output_table[state].patterns;
uint8_t *pmq_bitarray = pmq->pattern_id_bitarray;
uint32_t k;
@ -1701,7 +1701,7 @@ uint32_t SCACTileSearchLarge(SCACTileSearchCtx *ctx, MpmThreadCtx *mpm_thread_ct
*/
int SCACTileAddPatternCI(MpmCtx *mpm_ctx, uint8_t *pat, uint16_t patlen,
uint16_t offset, uint16_t depth, uint32_t pid,
uint32_t sid, uint8_t flags)
SigIntId sid, uint8_t flags)
{
flags |= MPM_PATTERN_FLAG_NOCASE;
return SCACTileAddPattern(mpm_ctx, pat, patlen, offset, depth,
@ -1727,7 +1727,7 @@ int SCACTileAddPatternCI(MpmCtx *mpm_ctx, uint8_t *pat, uint16_t patlen,
*/
int SCACTileAddPatternCS(MpmCtx *mpm_ctx, uint8_t *pat, uint16_t patlen,
uint16_t offset, uint16_t depth, uint32_t pid,
uint32_t sid, uint8_t flags)
SigIntId sid, uint8_t flags)
{
return SCACTileAddPattern(mpm_ctx, pat, patlen, offset, depth,
pid, sid, flags);

4
src/util-mpm-ac-tile.h
Unescape Escape View File

@ -42,7 +42,7 @@ typedef struct SCACTilePattern_ {
/* sid(s) for this pattern */
uint32_t sids_size;
uint32_t *sids;
SigIntId *sids;
struct SCACTilePattern_ *next;
} SCACTilePattern;
@ -56,7 +56,7 @@ typedef struct SCACTilePatternList_ {
/* sid(s) for this pattern */
uint32_t sids_size;
uint32_t *sids;
SigIntId *sids;
} SCACTilePatternList;
typedef struct SCACTileOutputTable_ {

14
src/util-mpm-ac.c
Unescape Escape View File

@ -74,9 +74,9 @@ void SCACInitThreadCtx(MpmCtx *, MpmThreadCtx *, uint32_t);
void SCACDestroyCtx(MpmCtx *);
void SCACDestroyThreadCtx(MpmCtx *, MpmThreadCtx *);
int SCACAddPatternCI(MpmCtx *, uint8_t *, uint16_t, uint16_t, uint16_t,
uint32_t, uint32_t, uint8_t);
uint32_t, SigIntId, uint8_t);
int SCACAddPatternCS(MpmCtx *, uint8_t *, uint16_t, uint16_t, uint16_t,
uint32_t, uint32_t, uint8_t);
uint32_t, SigIntId, uint8_t);
int SCACPreparePatterns(MpmCtx *mpm_ctx);
uint32_t SCACSearch(MpmCtx *mpm_ctx, MpmThreadCtx *mpm_thread_ctx,
PatternMatcherQueue *pmq, uint8_t *buf, uint16_t buflen);
@ -278,7 +278,7 @@ static inline int SCACInitHashAdd(SCACCtx *ctx, SCACPattern *p)
*/
static int SCACAddPattern(MpmCtx *mpm_ctx, uint8_t *pat, uint16_t patlen,
uint16_t offset, uint16_t depth, uint32_t pid,
uint32_t sid, uint8_t flags)
SigIntId sid, uint8_t flags)
{
SCACCtx *ctx = (SCACCtx *)mpm_ctx->ctx;
@ -359,7 +359,7 @@ static int SCACAddPattern(MpmCtx *mpm_ctx, uint8_t *pat, uint16_t patlen,
ctx->max_pat_id = pid;
p->sids_size = 1;
p->sids = SCMalloc(p->sids_size * sizeof(uint32_t));
p->sids = SCMalloc(p->sids_size * sizeof(SigIntId));
BUG_ON(p->sids == NULL);
p->sids[0] = sid;
//SCLogInfo("MPM added %u:%u", pid, sid);
@ -375,7 +375,7 @@ static int SCACAddPattern(MpmCtx *mpm_ctx, uint8_t *pat, uint16_t patlen,
}
}
if (!found) {
uint32_t *sids = SCRealloc(p->sids, (sizeof(uint32_t) * (p->sids_size + 1)));
SigIntId *sids = SCRealloc(p->sids, (sizeof(SigIntId) * (p->sids_size + 1)));
BUG_ON(sids == NULL);
p->sids = sids;
p->sids[p->sids_size] = sid;
@ -1421,7 +1421,7 @@ uint32_t SCACSearch(MpmCtx *mpm_ctx, MpmThreadCtx *mpm_thread_ctx,
*/
int SCACAddPatternCI(MpmCtx *mpm_ctx, uint8_t *pat, uint16_t patlen,
uint16_t offset, uint16_t depth, uint32_t pid,
uint32_t sid, uint8_t flags)
SigIntId sid, uint8_t flags)
{
flags |= MPM_PATTERN_FLAG_NOCASE;
return SCACAddPattern(mpm_ctx, pat, patlen, offset, depth, pid, sid, flags);
@ -1446,7 +1446,7 @@ int SCACAddPatternCI(MpmCtx *mpm_ctx, uint8_t *pat, uint16_t patlen,
*/
int SCACAddPatternCS(MpmCtx *mpm_ctx, uint8_t *pat, uint16_t patlen,
uint16_t offset, uint16_t depth, uint32_t pid,
uint32_t sid, uint8_t flags)
SigIntId sid, uint8_t flags)
{
return SCACAddPattern(mpm_ctx, pat, patlen, offset, depth, pid, sid, flags);
}

4
src/util-mpm-ac.h
Unescape Escape View File

@ -54,7 +54,7 @@ typedef struct SCACPattern_ {
/* sid(s) for this pattern */
uint32_t sids_size;
uint32_t *sids;
SigIntId *sids;
struct SCACPattern_ *next;
} SCACPattern;
@ -65,7 +65,7 @@ typedef struct SCACPatternList_ {
/* sid(s) for this pattern */
uint32_t sids_size;
uint32_t *sids;
SigIntId *sids;
} SCACPatternList;
typedef struct SCACOutputTable_ {

22
src/util-mpm-b2g.c
Unescape Escape View File

@ -65,8 +65,10 @@ void B2gInitCtx (MpmCtx *);
void B2gThreadInitCtx(MpmCtx *, MpmThreadCtx *, uint32_t);
void B2gDestroyCtx(MpmCtx *);
void B2gThreadDestroyCtx(MpmCtx *, MpmThreadCtx *);
int B2gAddPatternCI(MpmCtx *, uint8_t *, uint16_t, uint16_t, uint16_t, uint32_t, uint32_t, uint8_t);
int B2gAddPatternCS(MpmCtx *, uint8_t *, uint16_t, uint16_t, uint16_t, uint32_t, uint32_t, uint8_t);
int B2gAddPatternCI(MpmCtx *mpm_ctx, uint8_t *pat, uint16_t patlen,
uint16_t offset, uint16_t depth, uint32_t pid, SigIntId sid, uint8_t flags);
int B2gAddPatternCS(MpmCtx *mpm_ctx, uint8_t *pat, uint16_t patlen,
uint16_t offset, uint16_t depth, uint32_t pid, SigIntId sid, uint8_t flags);
int B2gPreparePatterns(MpmCtx *mpm_ctx);
uint32_t B2gSearchWrap(MpmCtx *mpm_ctx, MpmThreadCtx *mpm_thread_ctx, PatternMatcherQueue *, uint8_t *buf, uint16_t buflen);
uint32_t B2gSearch1(MpmCtx *mpm_ctx, MpmThreadCtx *mpm_thread_ctx, PatternMatcherQueue *, uint8_t *buf, uint16_t buflen);
@ -285,7 +287,7 @@ void B2gFreePattern(MpmCtx *mpm_ctx, B2gPattern *p)
if (p && p->sids) {
SCFree(p->sids);
mpm_ctx->memory_cnt--;
mpm_ctx->memory_size -= p->sids_size * sizeof(uint32_t);
mpm_ctx->memory_size -= p->sids_size * sizeof(SigIntId);
}
if (p) {
@ -306,7 +308,7 @@ void B2gFreePattern(MpmCtx *mpm_ctx, B2gPattern *p)
*
* \initonly
*/
static int B2gAddPattern(MpmCtx *mpm_ctx, uint8_t *pat, uint16_t patlen, uint16_t offset, uint16_t depth, uint32_t pid, uint32_t sid, uint8_t flags)
static int B2gAddPattern(MpmCtx *mpm_ctx, uint8_t *pat, uint16_t patlen, uint16_t offset, uint16_t depth, uint32_t pid, SigIntId sid, uint8_t flags)
{
B2gCtx *ctx = (B2gCtx *)mpm_ctx->ctx;
@ -364,11 +366,11 @@ static int B2gAddPattern(MpmCtx *mpm_ctx, uint8_t *pat, uint16_t patlen, uint16_
}
p->sids_size = 1;
p->sids = SCMalloc(p->sids_size * sizeof(uint32_t));
p->sids = SCMalloc(p->sids_size * sizeof(SigIntId));
BUG_ON(p->sids == NULL);
p->sids[0] = sid;
mpm_ctx->memory_cnt++;
mpm_ctx->memory_size += sizeof(uint32_t);
mpm_ctx->memory_size += sizeof(SigIntId);
//printf("B2gAddPattern: ci \""); prt(p->ci,p->len);
//printf("\" cs \""); prt(p->cs,p->len);
@ -400,12 +402,12 @@ static int B2gAddPattern(MpmCtx *mpm_ctx, uint8_t *pat, uint16_t patlen, uint16_
}
}
if (!found) {
uint32_t *sids = SCRealloc(p->sids, (sizeof(uint32_t) * (p->sids_size + 1)));
SigIntId *sids = SCRealloc(p->sids, (sizeof(SigIntId) * (p->sids_size + 1)));
BUG_ON(sids == NULL);
p->sids = sids;
p->sids[p->sids_size] = sid;
p->sids_size++;
mpm_ctx->memory_size += sizeof(uint32_t);
mpm_ctx->memory_size += sizeof(SigIntId);
}
}
@ -417,14 +419,14 @@ error:
}
int B2gAddPatternCI(MpmCtx *mpm_ctx, uint8_t *pat, uint16_t patlen,
uint16_t offset, uint16_t depth, uint32_t pid, uint32_t sid, uint8_t flags)
uint16_t offset, uint16_t depth, uint32_t pid, SigIntId sid, uint8_t flags)
{
flags |= MPM_PATTERN_FLAG_NOCASE;
return B2gAddPattern(mpm_ctx, pat, patlen, offset, depth, pid, sid, flags);
}
int B2gAddPatternCS(MpmCtx *mpm_ctx, uint8_t *pat, uint16_t patlen,
uint16_t offset, uint16_t depth, uint32_t pid, uint32_t sid, uint8_t flags)
uint16_t offset, uint16_t depth, uint32_t pid, SigIntId sid, uint8_t flags)
{
return B2gAddPattern(mpm_ctx, pat, patlen, offset, depth, pid, sid, flags);
}

2
src/util-mpm-b2g.h
Unescape Escape View File

@ -62,7 +62,7 @@ typedef struct B2gPattern_ {
/* sid(s) for this pattern */
uint32_t sids_size;
uint32_t *sids;
SigIntId *sids;
struct B2gPattern_ *next;
} B2gPattern;

18
src/util-mpm-b3g.c
Unescape Escape View File

@ -60,8 +60,8 @@ void B3gInitCtx (MpmCtx *);
void B3gThreadInitCtx(MpmCtx *, MpmThreadCtx *, uint32_t);
void B3gDestroyCtx(MpmCtx *);
void B3gThreadDestroyCtx(MpmCtx *, MpmThreadCtx *);
int B3gAddPatternCI(MpmCtx *, uint8_t *, uint16_t, uint16_t, uint16_t, uint32_t, uint32_t, uint8_t);
int B3gAddPatternCS(MpmCtx *, uint8_t *, uint16_t, uint16_t, uint16_t, uint32_t, uint32_t, uint8_t);
int B3gAddPatternCI(MpmCtx *, uint8_t *, uint16_t, uint16_t, uint16_t, uint32_t, SigIntId, uint8_t);
int B3gAddPatternCS(MpmCtx *, uint8_t *, uint16_t, uint16_t, uint16_t, uint32_t, SigIntId, uint8_t);
int B3gPreparePatterns(MpmCtx *);
uint32_t B3gSearchWrap(MpmCtx *, MpmThreadCtx *, PatternMatcherQueue *, uint8_t *, uint16_t);
uint32_t B3gSearch1(MpmCtx *, MpmThreadCtx *, PatternMatcherQueue *, uint8_t *, uint16_t);
@ -248,7 +248,7 @@ void B3gFreePattern(MpmCtx *mpm_ctx, B3gPattern *p)
if (p && p->sids) {
SCFree(p->sids);
mpm_ctx->memory_cnt--;
mpm_ctx->memory_size -= p->sids_size * sizeof(uint32_t);
mpm_ctx->memory_size -= p->sids_size * sizeof(SigIntId);
}
if (p) {
@ -317,11 +317,11 @@ static int B3gAddPattern(MpmCtx *mpm_ctx, uint8_t *pat, uint16_t patlen, uint16_
//printf("\" prefix_ci %" PRIu32 ", prefix_cs %" PRIu32 "\n", p->prefix_ci, p->prefix_cs);
p->sids_size = 1;
p->sids = SCMalloc(p->sids_size * sizeof(uint32_t));
p->sids = SCMalloc(p->sids_size * sizeof(SigIntId));
BUG_ON(p->sids == NULL);
p->sids[0] = sid;
mpm_ctx->memory_cnt++;
mpm_ctx->memory_size += sizeof(uint32_t);
mpm_ctx->memory_size += sizeof(SigIntId);
/* put in the pattern hash */
B3gInitHashAdd(ctx, p);
@ -349,12 +349,12 @@ static int B3gAddPattern(MpmCtx *mpm_ctx, uint8_t *pat, uint16_t patlen, uint16_
}
}
if (!found) {
uint32_t *sids = SCRealloc(p->sids, (sizeof(uint32_t) * (p->sids_size + 1)));
SigIntId *sids = SCRealloc(p->sids, (sizeof(SigIntId) * (p->sids_size + 1)));
BUG_ON(sids == NULL);
p->sids = sids;
p->sids[p->sids_size] = sid;
p->sids_size++;
mpm_ctx->memory_size += sizeof(uint32_t);
mpm_ctx->memory_size += sizeof(SigIntId);
}
}
@ -366,14 +366,14 @@ error:
}
int B3gAddPatternCI(MpmCtx *mpm_ctx, uint8_t *pat, uint16_t patlen,
uint16_t offset, uint16_t depth, uint32_t pid, uint32_t sid, uint8_t flags)
uint16_t offset, uint16_t depth, uint32_t pid, SigIntId sid, uint8_t flags)
{
flags |= MPM_PATTERN_FLAG_NOCASE;
return B3gAddPattern(mpm_ctx, pat, patlen, offset, depth, pid, sid, flags);
}
int B3gAddPatternCS(MpmCtx *mpm_ctx, uint8_t *pat, uint16_t patlen,
uint16_t offset, uint16_t depth, uint32_t pid, uint32_t sid, uint8_t flags)
uint16_t offset, uint16_t depth, uint32_t pid, SigIntId sid, uint8_t flags)
{
return B3gAddPattern(mpm_ctx, pat, patlen, offset, depth, pid, sid, flags);
}

2
src/util-mpm-b3g.h
Unescape Escape View File

@ -63,7 +63,7 @@ typedef struct B3gPattern_ {
/* sid(s) for this pattern */
uint32_t sids_size;
uint32_t *sids;
SigIntId *sids;
struct B3gPattern_ *next;

14
src/util-mpm-wumanber.c
Unescape Escape View File

@ -63,8 +63,8 @@ void WmInitCtx (MpmCtx *mpm_ctx);
void WmThreadInitCtx(MpmCtx *mpm_ctx, MpmThreadCtx *mpm_thread_ctx, uint32_t);
void WmDestroyCtx(MpmCtx *mpm_ctx);
void WmThreadDestroyCtx(MpmCtx *mpm_ctx, MpmThreadCtx *mpm_thread_ctx);
int WmAddPatternCI(MpmCtx *, uint8_t *, uint16_t, uint16_t, uint16_t, uint32_t, uint32_t, uint8_t);
int WmAddPatternCS(MpmCtx *, uint8_t *, uint16_t, uint16_t, uint16_t, uint32_t, uint32_t, uint8_t);
int WmAddPatternCI(MpmCtx *, uint8_t *, uint16_t, uint16_t, uint16_t, uint32_t, SigIntId, uint8_t);
int WmAddPatternCS(MpmCtx *, uint8_t *, uint16_t, uint16_t, uint16_t, uint32_t, SigIntId, uint8_t);
int WmPreparePatterns(MpmCtx *mpm_ctx);
uint32_t WmSearch(MpmCtx *mpm_ctx, MpmThreadCtx *mpm_thread_ctx, PatternMatcherQueue *, uint8_t *buf, uint16_t buflen);
uint32_t WmSearch1(MpmCtx *mpm_ctx, MpmThreadCtx *mpm_thread_ctx, PatternMatcherQueue *, uint8_t *buf, uint16_t buflen);
@ -377,11 +377,11 @@ static int WmAddPattern(MpmCtx *mpm_ctx, uint8_t *pat, uint16_t patlen, uint16_t
else if (mpm_ctx->minlen > patlen) mpm_ctx->minlen = patlen;
p->sids_size = 1;
p->sids = SCMalloc(p->sids_size * sizeof(uint32_t));
p->sids = SCMalloc(p->sids_size * sizeof(SigIntId));
BUG_ON(p->sids == NULL);
p->sids[0] = sid;
mpm_ctx->memory_cnt++;
mpm_ctx->memory_size += sizeof(uint32_t);
mpm_ctx->memory_size += sizeof(SigIntId);
} else {
/* TODO figure out how we can be called multiple times for the same CTX with the same sid */
@ -395,7 +395,7 @@ static int WmAddPattern(MpmCtx *mpm_ctx, uint8_t *pat, uint16_t patlen, uint16_t
}
}
if (!found) {
uint32_t *sids = SCRealloc(p->sids, (sizeof(uint32_t) * (p->sids_size + 1)));
SigIntId *sids = SCRealloc(p->sids, (sizeof(SigIntId) * (p->sids_size + 1)));
BUG_ON(sids == NULL);
p->sids = sids;
p->sids[p->sids_size] = sid;
@ -412,14 +412,14 @@ error:
}
int WmAddPatternCI(MpmCtx *mpm_ctx, uint8_t *pat, uint16_t patlen,
uint16_t offset, uint16_t depth, uint32_t pid, uint32_t sid, uint8_t flags)
uint16_t offset, uint16_t depth, uint32_t pid, SigIntId sid, uint8_t flags)
{
flags |= MPM_PATTERN_FLAG_NOCASE;
return WmAddPattern(mpm_ctx, pat, patlen, offset, depth, pid, sid, flags);
}
int WmAddPatternCS(MpmCtx *mpm_ctx, uint8_t *pat, uint16_t patlen,
uint16_t offset, uint16_t depth, uint32_t pid, uint32_t sid, uint8_t flags)
uint16_t offset, uint16_t depth, uint32_t pid, SigIntId sid, uint8_t flags)
{
return WmAddPattern(mpm_ctx, pat, patlen, offset, depth, pid, sid, flags);
}

2
src/util-mpm-wumanber.h
Unescape Escape View File

@ -41,7 +41,7 @@ typedef struct WmPattern_ {
/* sid(s) for this pattern */
uint32_t sids_size;
uint32_t *sids;
SigIntId *sids;
} WmPattern;

14
src/util-mpm.c
Unescape Escape View File

@ -453,8 +453,8 @@ int PmqSetup(PatternMatcherQueue *pmq, uint32_t patmaxid)
pmq->rule_id_array_size = 128; /* Initial size, TODO: Make configure option. */
pmq->rule_id_array_cnt = 0;
uint32_t bytes = pmq->rule_id_array_size * sizeof(uint32_t);
pmq->rule_id_array = SCMalloc(bytes);
size_t bytes = pmq->rule_id_array_size * sizeof(SigIntId);
pmq->rule_id_array = (SigIntId*)SCMalloc(bytes);
if (pmq->rule_id_array == NULL) {
pmq->rule_id_array_size = 0;
SCReturnInt(-1);
@ -481,8 +481,8 @@ MpmAddSidsResize(PatternMatcherQueue *pmq, uint32_t new_size)
* larger than the old size.
*/
new_size = new_size * 2;
uint32_t *new_array = (uint32_t*)SCRealloc(pmq->rule_id_array,
new_size * sizeof(uint32_t));
SigIntId *new_array = (SigIntId*)SCRealloc(pmq->rule_id_array,
new_size * sizeof(SigIntId));
if (unlikely(new_array == NULL)) {
/* Try again just big enough. */
new_size = new_size / 2;
@ -551,7 +551,7 @@ MpmAddPidResize(PatternMatcherQueue *pmq, uint32_t new_size)
*/
int
MpmVerifyMatch(MpmThreadCtx *thread_ctx, PatternMatcherQueue *pmq, uint32_t patid,
uint8_t *bitarray, uint32_t *sids, uint32_t sids_size)
uint8_t *bitarray, SigIntId *sids, uint32_t sids_size)
{
SCEnter();
@ -737,7 +737,7 @@ uint32_t MpmGetBloomSize(const char *conf_val)
int MpmAddPatternCS(struct MpmCtx_ *mpm_ctx, uint8_t *pat, uint16_t patlen,
uint16_t offset, uint16_t depth,
uint32_t pid, uint32_t sid, uint8_t flags)
uint32_t pid, SigIntId sid, uint8_t flags)
{
return mpm_table[mpm_ctx->mpm_type].AddPattern(mpm_ctx, pat, patlen,
offset, depth,
@ -746,7 +746,7 @@ int MpmAddPatternCS(struct MpmCtx_ *mpm_ctx, uint8_t *pat, uint16_t patlen,
int MpmAddPatternCI(struct MpmCtx_ *mpm_ctx, uint8_t *pat, uint16_t patlen,
uint16_t offset, uint16_t depth,
uint32_t pid, uint32_t sid, uint8_t flags)
uint32_t pid, SigIntId sid, uint8_t flags)
{
return mpm_table[mpm_ctx->mpm_type].AddPatternNocase(mpm_ctx, pat, patlen,
offset, depth,

20
src/util-mpm.h
Unescape Escape View File

@ -112,7 +112,7 @@ typedef struct PatternMatcherQueue_ {
/* used for storing rule id's */
/* Array of rule IDs found. */
uint32_t *rule_id_array;
SigIntId *rule_id_array;
/* Number of rule IDs in the array. */
uint32_t rule_id_array_cnt;
/* The number of slots allocated for storing rule IDs */
@ -189,8 +189,8 @@ typedef struct MpmTableElmt_ {
* \param sid signature _internal_ id
* \param flags pattern flags
*/
int (*AddPattern)(struct MpmCtx_ *, uint8_t *, uint16_t, uint16_t, uint16_t, uint32_t, uint32_t, uint8_t);
int (*AddPatternNocase)(struct MpmCtx_ *, uint8_t *, uint16_t, uint16_t, uint16_t, uint32_t, uint32_t, uint8_t);
int (*AddPattern)(struct MpmCtx_ *, uint8_t *, uint16_t, uint16_t, uint16_t, uint32_t, SigIntId, uint8_t);
int (*AddPatternNocase)(struct MpmCtx_ *, uint8_t *, uint16_t, uint16_t, uint16_t, uint32_t, SigIntId, uint8_t);
int (*Prepare)(struct MpmCtx_ *);
uint32_t (*Search)(struct MpmCtx_ *, struct MpmThreadCtx_ *, PatternMatcherQueue *, uint8_t *, uint16_t);
void (*Cleanup)(struct MpmThreadCtx_ *);
@ -255,8 +255,8 @@ void PmqFree(PatternMatcherQueue *);
void MpmTableSetup(void);
void MpmRegisterTests(void);
int MpmVerifyMatch(MpmThreadCtx *, PatternMatcherQueue *, uint32_t,
uint8_t *bitarray, uint32_t *sids, uint32_t sid_size);
int MpmVerifyMatch(MpmThreadCtx *thread_ctx, PatternMatcherQueue *pmq, uint32_t patid,
uint8_t *bitarray, SigIntId *sids, uint32_t sids_size);
void MpmInitCtx(MpmCtx *mpm_ctx, uint16_t matcher);
void MpmInitThreadCtx(MpmThreadCtx *mpm_thread_ctx, uint16_t, uint32_t);
uint32_t MpmGetHashSize(const char *);
@ -264,10 +264,10 @@ uint32_t MpmGetBloomSize(const char *);
int MpmAddPatternCS(struct MpmCtx_ *mpm_ctx, uint8_t *pat, uint16_t patlen,
uint16_t offset, uint16_t depth,
uint32_t pid, uint32_t sid, uint8_t flags);
uint32_t pid, SigIntId sid, uint8_t flags);
int MpmAddPatternCI(struct MpmCtx_ *mpm_ctx, uint8_t *pat, uint16_t patlen,
uint16_t offset, uint16_t depth,
uint32_t pid, uint32_t sid, uint8_t flags);
uint32_t pid, SigIntId sid, uint8_t flags);
/* Resize Signature ID array. Only called from MpmAddSids(). */
int MpmAddSidsResize(PatternMatcherQueue *pmq, uint32_t new_size);
@ -283,7 +283,7 @@ int MpmAddSidsResize(PatternMatcherQueue *pmq, uint32_t new_size);
*
*/
static inline void
MpmAddSids(PatternMatcherQueue *pmq, uint32_t *sids, uint32_t sids_size)
MpmAddSids(PatternMatcherQueue *pmq, SigIntId *sids, uint32_t sids_size)
{
if (sids_size == 0)
return;
@ -298,8 +298,8 @@ MpmAddSids(PatternMatcherQueue *pmq, uint32_t *sids, uint32_t sids_size)
}
SCLogDebug("Adding %u sids", sids_size);
// Add SIDs for this pattern to the end of the array
uint32_t *ptr = pmq->rule_id_array + pmq->rule_id_array_cnt;
uint32_t *end = ptr + sids_size;
SigIntId *ptr = pmq->rule_id_array + pmq->rule_id_array_cnt;
SigIntId *end = ptr + sids_size;
do {
*ptr++ = *sids++;
} while (ptr != end);

Write Preview
Loading…
Cancel
Save