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

Previously using uint32_t, but SigIntId is currently uint16_t, so arrays
will take less memory.

diff --git a/src/detect-engine-siggroup.c b/src/detect-engine-siggroup.c
index f5397baa26f9fc47236f517faf55432b5e280f38..bd867dc0b702e48e86bd46a009539fb3d7996e0c 100644 (file)
--- a/src/detect-engine-siggroup.c
+++ b/src/detect-engine-siggroup.c
@@ -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];

diff --git a/src/detect.c b/src/detect.c
index 3eea3268bad48d1e6f5ce2a35fdca803a9dd61fa..e3f4580335910cd2ec7c8cd87cc54c7356ea7cdc 100644 (file)
--- a/src/detect.c
+++ b/src/detect.c
@@ -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);
     }
 }
 

diff --git a/src/detect.h b/src/detect.h
index 786297fdab263cfada65ec837bf670f8d860a720..3a31af255d1c19a6d37d729bac850c29eb8c1e48 100644 (file)
--- a/src/detect.h
+++ b/src/detect.h
@@ -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 */

diff --git a/src/util-mpm-ac-bs.c b/src/util-mpm-ac-bs.c
index c706c0982192209e1ab6b1343fc55dd508a489e2..d6c4e78502cdb661a5fe430db7436ef8ddae0c10 100644 (file)
--- a/src/util-mpm-ac-bs.c
+++ b/src/util-mpm-ac-bs.c
@@ -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);
 }

diff --git a/src/util-mpm-ac-bs.h b/src/util-mpm-ac-bs.h
index 935bc77c27929ef388d51206b0142f2da36391ef..a66757e72a3da047be6182409fb55c5942920d01 100644 (file)
--- a/src/util-mpm-ac-bs.h
+++ b/src/util-mpm-ac-bs.h
@@ -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_ {

diff --git a/src/util-mpm-ac-gfbs.c b/src/util-mpm-ac-gfbs.c
index 523aa0ff95acc40cb9fc266b120bf4d570ef4cec..e0ace7f3e7f2f473cb58bee073e16ff80c7a95cd 100644 (file)
--- a/src/util-mpm-ac-gfbs.c
+++ b/src/util-mpm-ac-gfbs.c
@@ -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);
 }

diff --git a/src/util-mpm-ac-gfbs.h b/src/util-mpm-ac-gfbs.h
index 5f1fc7bbad04379c83f253cd09720440f29c3866..4003a5b560a58669f42978716d329d37a5ae4d37 100644 (file)
--- a/src/util-mpm-ac-gfbs.h
+++ b/src/util-mpm-ac-gfbs.h
@@ -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_ {

diff --git a/src/util-mpm-ac-tile.c b/src/util-mpm-ac-tile.c
index b1f8cd9257cda75ebcaa3305a685d0deb7ba1e71..f3a52d6e56cd6f86870f4852fc8c02aa763c36cc 100644 (file)
--- a/src/util-mpm-ac-tile.c
+++ b/src/util-mpm-ac-tile.c
@@ -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);

diff --git a/src/util-mpm-ac-tile.h b/src/util-mpm-ac-tile.h
index 33a4ceac17143340d6b79f91e1c63bd8214d5986..63d5bc95eff90568d03eaa2b53589b027bad3924 100644 (file)
--- a/src/util-mpm-ac-tile.h
+++ b/src/util-mpm-ac-tile.h
@@ -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_ {

diff --git a/src/util-mpm-ac.c b/src/util-mpm-ac.c
index 01263d177f370e4aeb97447b43c13b2fccdcfd4b..6cf05c1ffcdd98c22b57731a0293f49405611821 100644 (file)
--- a/src/util-mpm-ac.c
+++ b/src/util-mpm-ac.c
@@ -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);
 }

diff --git a/src/util-mpm-ac.h b/src/util-mpm-ac.h
index 7519fffd620f2abc96e6e5e1a4229d5de343a3ea..a837f5f015415e10051dcce69ff7c7141105bef3 100644 (file)
--- a/src/util-mpm-ac.h
+++ b/src/util-mpm-ac.h
@@ -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_ {

diff --git a/src/util-mpm-b2g.c b/src/util-mpm-b2g.c
index b4e2fcb77b26250ec8e65edc15694fde1f693889..f717283910156b1e3299d46bc8b9b2ec8cbc610b 100644 (file)
--- a/src/util-mpm-b2g.c
+++ b/src/util-mpm-b2g.c
@@ -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);
 }

diff --git a/src/util-mpm-b2g.h b/src/util-mpm-b2g.h
index 8c002b63451eb37b118d1468c47b932887d539eb..b3b59b092124d46efc647af598159477f31b82b6 100644 (file)
--- a/src/util-mpm-b2g.h
+++ b/src/util-mpm-b2g.h
@@ -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;

diff --git a/src/util-mpm-b3g.c b/src/util-mpm-b3g.c
index 03b7fd6927f7089586b987a75f7aa542c98bdd5b..bc74bc20533849b6a48636d20a008da180c18e79 100644 (file)
--- a/src/util-mpm-b3g.c
+++ b/src/util-mpm-b3g.c
@@ -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);
 }

diff --git a/src/util-mpm-b3g.h b/src/util-mpm-b3g.h
index 2d75caa335d15e7d0e11ee6ed7eabe75faa48800..d35aa0334d0204e8bb8aca8457b96529c3be32f7 100644 (file)
--- a/src/util-mpm-b3g.h
+++ b/src/util-mpm-b3g.h
@@ -63,7 +63,7 @@ typedef struct B3gPattern_ {
 
     /* sid(s) for this pattern */
     uint32_t sids_size;
-    uint32_t *sids;
+    SigIntId *sids;
 
     struct B3gPattern_ *next;
 

diff --git a/src/util-mpm-wumanber.c b/src/util-mpm-wumanber.c
index 4966821f6e5a8fd3820c2a11a4977ffbfac0f057..dc78cde260ad8aeb359eb021f7b1e44b09c09aa7 100644 (file)
--- a/src/util-mpm-wumanber.c
+++ b/src/util-mpm-wumanber.c
@@ -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);
 }

diff --git a/src/util-mpm-wumanber.h b/src/util-mpm-wumanber.h
index a8b0bdef5d6d31aa30cc4181b4506f7b09595286..ef6998145d1b9163387c64b9cf08fadb7a5b296d 100644 (file)
--- a/src/util-mpm-wumanber.h
+++ b/src/util-mpm-wumanber.h
@@ -41,7 +41,7 @@ typedef struct WmPattern_ {
 
     /* sid(s) for this pattern */
     uint32_t sids_size;
-    uint32_t *sids;
+    SigIntId *sids;
 
 } WmPattern;
 

diff --git a/src/util-mpm.c b/src/util-mpm.c
index 157eb58700b30bcae4b51144732baffd5c28d7d9..ac185e301fa387eac74850284d8e280e4dfa578c 100644 (file)
--- a/src/util-mpm.c
+++ b/src/util-mpm.c
@@ -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,

diff --git a/src/util-mpm.h b/src/util-mpm.h
index ca1fb4348a207dd55084223ddc260612984c0ab2..da650884b88f4cf113f179d2a340f63e4e9b080c 100644 (file)
--- a/src/util-mpm.h
+++ b/src/util-mpm.h
@@ -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);