return ret;
}
-static void EngineAnalysisRulesPrintFP(Signature *s)
+static void EngineAnalysisRulesPrintFP(const Signature *s)
{
DetectContentData *fp_cd = NULL;
SigMatch *mpm_sm = s->mpm_sm;
*
* \param s Pointer to the signature.
*/
-void EngineAnalysisRules(Signature *s, char *line)
+void EngineAnalysisRules(const Signature *s, const char *line)
{
uint32_t rule_bidirectional = 0;
uint32_t rule_pcre = 0;
int PerCentEncodingMatch (uint8_t *content, uint8_t content_len);
void EngineAnalysisFP(Signature *s, char *line);
-void EngineAnalysisRules(Signature *s, char *line);
+void EngineAnalysisRules(const Signature *s, const char *line);
void EngineAnalysisRulesFailure(char *line, char *file, int lineno);
#endif /* __DETECT_ENGINE_ANALYZER_H__ */
* \retval 1 true
* \retval 0 false
*/
-int SignatureHasPacketContent(Signature *s)
+int SignatureHasPacketContent(const Signature *s)
{
SCEnter();
* \retval 1 true
* \retval 0 false
*/
-int SignatureHasStreamContent(Signature *s)
+int SignatureHasStreamContent(const Signature *s)
{
SCEnter();
return;
}
-static void PopulateMpmAddPatternToMpm(DetectEngineCtx *de_ctx,
+static void PopulateMpmAddPatternToMpm(const DetectEngineCtx *de_ctx,
SigGroupHead *sgh, Signature *s,
SigMatch *mpm_sm)
{
*
* \retval 0 Always.
*/
-static int PatternMatchPreparePopulateMpm(DetectEngineCtx *de_ctx,
+static int PatternMatchPreparePopulateMpm(const DetectEngineCtx *de_ctx,
SigGroupHead *sgh)
{
uint32_t sig = 0;
* \todo do error checking
* \todo rewrite the COPY stuff
*/
-int PatternMatchPrepareGroup(DetectEngineCtx *de_ctx, SigGroupHead *sh)
+int PatternMatchPrepareGroup(const DetectEngineCtx *de_ctx, SigGroupHead *sh)
{
Signature *s = NULL;
uint32_t has_co_packet = 0; /**< our sgh has packet payload inspecting content */
void PatternMatchThreadDestroy(MpmThreadCtx *mpm_thread_ctx, uint16_t);
void PatternMatchThreadPrint(MpmThreadCtx *, uint16_t);
-int PatternMatchPrepareGroup(DetectEngineCtx *, SigGroupHead *);
+int PatternMatchPrepareGroup(const DetectEngineCtx *, SigGroupHead *);
void DetectEngineThreadCtxInfo(ThreadVars *, DetectEngineThreadCtx *);
void PatternMatchDestroyGroup(SigGroupHead *);
uint32_t MpmPatternIdStoreGetMaxId(MpmPatternIdStore *);
uint32_t DetectContentGetId(MpmPatternIdStore *, DetectContentData *);
-int SignatureHasPacketContent(Signature *);
-int SignatureHasStreamContent(Signature *);
+int SignatureHasPacketContent(const Signature *);
+int SignatureHasStreamContent(const Signature *);
SigMatch *RetrieveFPForSig(Signature *s);
SigMatch *RetrieveFPForSigV2(Signature *s);
* \param proto protocol (such as IPPROTO_TCP) to look for
* \retval 0 protocol not in the set
* \retval 1 protocol is in the set */
-int DetectProtoContainsProto(DetectProto *dp, int proto)
+int DetectProtoContainsProto(const DetectProto *dp, int proto)
{
if (dp->flags & DETECT_PROTO_ANY)
return 1;
/* prototypes */
int DetectProtoParse(DetectProto *dp, char *str);
-int DetectProtoContainsProto(DetectProto *, int);
+int DetectProtoContainsProto(const DetectProto *, int);
void DetectProtoTests(void);
* \retval sgh Pointer to the newly init SigGroupHead on success; or NULL in
* case of error.
*/
-static SigGroupHead *SigGroupHeadAlloc(DetectEngineCtx *de_ctx, uint32_t size)
+static SigGroupHead *SigGroupHeadAlloc(const DetectEngineCtx *de_ctx, uint32_t size)
{
SigGroupHead *sgh = SCMalloc(sizeof(SigGroupHead));
if (unlikely(sgh == NULL))
return;
}
-static uint16_t SignatureGetMpmPatternLen(Signature *s, int list)
+static uint16_t SignatureGetMpmPatternLen(const Signature *s, const int list)
{
if (s->sm_lists[list] != NULL && s->mpm_sm != NULL &&
SigMatchListSMBelongsTo(s, s->mpm_sm) == list)
* \retval 0 On success.
* \retval -1 On failure.
*/
-int SigGroupHeadAppendSig(DetectEngineCtx *de_ctx, SigGroupHead **sgh,
- Signature *s)
+int SigGroupHeadAppendSig(const DetectEngineCtx *de_ctx, SigGroupHead **sgh,
+ const Signature *s)
{
if (de_ctx == NULL)
return 0;
void DetectSigGroupPrintMemory(void);
-int SigGroupHeadAppendSig(DetectEngineCtx *, SigGroupHead **, Signature *);
+int SigGroupHeadAppendSig(const DetectEngineCtx *, SigGroupHead **, const Signature *);
int SigGroupHeadClearSigs(SigGroupHead *);
int SigGroupHeadCopySigs(DetectEngineCtx *, SigGroupHead *, SigGroupHead **);
return;
}
-int SigMatchListSMBelongsTo(Signature *s, SigMatch *key_sm)
+int SigMatchListSMBelongsTo(const Signature *s, const SigMatch *key_sm)
{
int list = 0;
for (list = 0; list < DETECT_SM_LIST_MAX; list++) {
- SigMatch *sm = s->sm_lists[list];
+ const SigMatch *sm = s->sm_lists[list];
while (sm != NULL) {
if (sm == key_sm)
return list;
void SigMatchAppendSMToList(Signature *, SigMatch *, int);
void SigMatchRemoveSMFromList(Signature *, SigMatch *, int);
-int SigMatchListSMBelongsTo(Signature *, SigMatch *);
+int SigMatchListSMBelongsTo(const Signature *, const SigMatch *);
int DetectParseDupSigHashInit(DetectEngineCtx *);
void DetectParseDupSigHashFree(DetectEngineCtx *);
}
}
-int32_t MpmFactoryIsMpmCtxAvailable(DetectEngineCtx *de_ctx, MpmCtx *mpm_ctx)
+int32_t MpmFactoryIsMpmCtxAvailable(const DetectEngineCtx *de_ctx, const MpmCtx *mpm_ctx)
{
if (mpm_ctx == NULL)
return 0;
}
}
-MpmCtx *MpmFactoryGetMpmCtxForProfile(DetectEngineCtx *de_ctx, int32_t id, int direction)
+MpmCtx *MpmFactoryGetMpmCtxForProfile(const DetectEngineCtx *de_ctx, int32_t id, int direction)
{
if (id == MPM_CTX_FACTORY_UNIQUE_CONTEXT) {
MpmCtx *mpm_ctx = SCMalloc(sizeof(MpmCtx));
}
}
-void MpmFactoryReClaimMpmCtx(DetectEngineCtx *de_ctx, MpmCtx *mpm_ctx)
+void MpmFactoryReClaimMpmCtx(const DetectEngineCtx *de_ctx, MpmCtx *mpm_ctx)
{
if (mpm_ctx == NULL)
return;
struct DetectEngineCtx_;
int32_t MpmFactoryRegisterMpmCtxProfile(struct DetectEngineCtx_ *, const char *, uint8_t);
-void MpmFactoryReClaimMpmCtx(struct DetectEngineCtx_ *, MpmCtx *);
-MpmCtx *MpmFactoryGetMpmCtxForProfile(struct DetectEngineCtx_ *, int32_t, int);
+void MpmFactoryReClaimMpmCtx(const struct DetectEngineCtx_ *, MpmCtx *);
+MpmCtx *MpmFactoryGetMpmCtxForProfile(const struct DetectEngineCtx_ *, int32_t, int);
void MpmFactoryDeRegisterAllMpmCtxProfiles(struct DetectEngineCtx_ *);
-int32_t MpmFactoryIsMpmCtxAvailable(struct DetectEngineCtx_ *, MpmCtx *);
+int32_t MpmFactoryIsMpmCtxAvailable(const struct DetectEngineCtx_ *, const MpmCtx *);
int PmqSetup(PatternMatcherQueue *, uint32_t);
void PmqMerge(PatternMatcherQueue *src, PatternMatcherQueue *dst);