46 #ifdef BUILD_HYPERSCAN
50 void SCHSInitCtx(
MpmCtx *);
52 void SCHSDestroyCtx(
MpmCtx *);
54 int SCHSAddPatternCI(
MpmCtx *, uint8_t *, uint16_t, uint16_t, uint16_t,
56 int SCHSAddPatternCS(
MpmCtx *, uint8_t *, uint16_t, uint16_t, uint16_t,
58 int SCHSPreparePatterns(
MpmCtx *mpm_ctx);
61 void SCHSPrintInfo(
MpmCtx *mpm_ctx);
64 static void SCHSRegisterTests(
void);
68 #define INIT_HASH_SIZE 65536
71 #define INIT_DB_HASH_SIZE 1000
76 static hs_scratch_t *g_scratch_proto = NULL;
89 static void *SCHSMalloc(
size_t size)
99 static void SCHSFree(
void *ptr)
109 static void SCHSSetAllocators(
void)
111 hs_error_t err = hs_set_allocator(SCHSMalloc, SCHSFree);
112 if (err != HS_SUCCESS) {
113 FatalError(
"Failed to set Hyperscan allocator.");
127 static inline uint32_t SCHSInitHashRaw(uint8_t *pat, uint16_t patlen)
129 uint32_t hash = patlen * pat[0];
133 return (hash % INIT_HASH_SIZE);
149 uint16_t patlen, uint16_t
offset,
150 uint16_t depth,
char flags,
153 uint32_t hash = SCHSInitHashRaw(pat, patlen);
160 for (; t != NULL; t = t->
next) {
210 if (p != NULL && p->
sids != NULL) {
221 static inline uint32_t SCHSInitHash(
SCHSPattern *p)
227 return (hash % INIT_HASH_SIZE);
232 uint32_t hash = SCHSInitHash(p);
271 static int SCHSAddPattern(
MpmCtx *mpm_ctx, uint8_t *pat, uint16_t patlen,
272 uint16_t
offset, uint16_t depth, uint32_t pid,
291 SCHSInitHashLookup(ctx, pat, patlen,
offset, depth,
flags, pid);
296 p = SCHSAllocPattern(mpm_ctx);
313 if (SCHSInitHashAdd(ctx, p) != 0)
325 SCLogDebug(
"%p: alas, no depth for us", mpm_ctx);
329 if (mpm_ctx->
maxlen < patlen)
332 if (mpm_ctx->
minlen == 0) {
335 if (mpm_ctx->
minlen > patlen)
349 if (p->
sids[x] == sid) {
366 SCHSFreePattern(mpm_ctx, p);
374 typedef struct SCHSCompileData_ {
379 unsigned int pattern_cnt;
382 static SCHSCompileData *SCHSAllocCompileData(
unsigned int pattern_cnt)
384 SCHSCompileData *cd =
SCCalloc(pattern_cnt,
sizeof(SCHSCompileData));
389 cd->pattern_cnt = pattern_cnt;
391 cd->ids =
SCCalloc(pattern_cnt,
sizeof(
unsigned int));
392 if (cd->ids == NULL) {
396 cd->flags =
SCCalloc(pattern_cnt,
sizeof(
unsigned int));
397 if (cd->flags == NULL) {
401 cd->expressions =
SCCalloc(pattern_cnt,
sizeof(
char *));
402 if (cd->expressions == NULL) {
406 cd->ext =
SCCalloc(pattern_cnt,
sizeof(hs_expr_ext_t *));
407 if (cd->ext == NULL) {
425 static void SCHSFreeCompileData(SCHSCompileData *cd)
433 if (cd->expressions) {
434 for (
unsigned int i = 0; i < cd->pattern_cnt; i++) {
435 SCFree(cd->expressions[i]);
440 for (
unsigned int i = 0; i < cd->pattern_cnt; i++) {
448 typedef struct PatternDatabase_ {
450 hs_database_t *hs_db;
451 uint32_t pattern_cnt;
457 static uint32_t SCHSPatternHash(
const SCHSPattern *p, uint32_t hash)
493 static uint32_t PatternDatabaseHash(
HashTable *ht,
void *data, uint16_t
len)
495 const PatternDatabase *pd = data;
497 hash =
hashword(&pd->pattern_cnt, 1, hash);
499 for (uint32_t i = 0; i < pd->pattern_cnt; i++) {
500 hash = SCHSPatternHash(pd->parray[i], hash);
507 static char PatternDatabaseCompare(
void *data1, uint16_t len1,
void *data2,
510 const PatternDatabase *pd1 = data1;
511 const PatternDatabase *pd2 = data2;
513 if (pd1->pattern_cnt != pd2->pattern_cnt) {
517 for (uint32_t i = 0; i < pd1->pattern_cnt; i++) {
518 if (SCHSPatternCompare(pd1->parray[i], pd2->parray[i]) == 0) {
526 static void PatternDatabaseFree(PatternDatabase *pd)
530 if (pd->parray != NULL) {
531 for (uint32_t i = 0; i < pd->pattern_cnt; i++) {
542 hs_free_database(pd->hs_db);
547 static void PatternDatabaseTableFree(
void *data)
553 static PatternDatabase *PatternDatabaseAlloc(uint32_t pattern_cnt)
555 PatternDatabase *pd =
SCCalloc(1,
sizeof(PatternDatabase));
559 pd->pattern_cnt = pattern_cnt;
565 if (pd->parray == NULL) {
578 int SCHSPreparePatterns(
MpmCtx *mpm_ctx)
583 SCLogDebug(
"no patterns supplied to this mpm_ctx");
588 hs_compile_error_t *compile_err = NULL;
589 SCHSCompileData *cd = NULL;
590 PatternDatabase *pd = NULL;
603 for (uint32_t i = 0, p = 0; i < INIT_HASH_SIZE; i++) {
605 while (node != NULL) {
608 pd->parray[p++] = node;
622 if (g_db_table == NULL) {
623 g_db_table =
HashTableInit(INIT_DB_HASH_SIZE, PatternDatabaseHash,
624 PatternDatabaseCompare,
625 PatternDatabaseTableFree);
626 if (g_db_table == NULL) {
636 if (pd_cached != NULL) {
637 SCLogDebug(
"Reusing cached database %p with %" PRIu32
638 " patterns (ref_cnt=%" PRIu32
")",
639 pd_cached->hs_db, pd_cached->pattern_cnt,
641 pd_cached->ref_cnt++;
644 PatternDatabaseFree(pd);
645 SCHSFreeCompileData(cd);
651 for (uint32_t i = 0; i < pd->pattern_cnt; i++) {
655 cd->
flags[i] = HS_FLAG_SINGLEMATCH;
657 cd->flags[i] |= HS_FLAG_CASELESS;
663 cd->ext[i] =
SCCalloc(1,
sizeof(hs_expr_ext_t));
664 if (cd->ext[i] == NULL) {
670 cd->ext[i]->flags |= HS_EXT_FLAG_MIN_OFFSET;
671 cd->ext[i]->min_offset = p->
offset + p->
len;
674 cd->ext[i]->flags |= HS_EXT_FLAG_MAX_OFFSET;
682 err = hs_compile_ext_multi((
const char *
const *)cd->expressions, cd->flags,
683 cd->ids, (
const hs_expr_ext_t *
const *)cd->ext,
684 cd->pattern_cnt, HS_MODE_BLOCK, NULL, &pd->hs_db,
687 if (err != HS_SUCCESS) {
688 SCLogError(
"failed to compile hyperscan database");
690 SCLogError(
"compile error: %s", compile_err->message);
692 hs_free_compile_error(compile_err);
700 err = hs_alloc_scratch(pd->hs_db, &g_scratch_proto);
702 if (err != HS_SUCCESS) {
708 err = hs_database_size(pd->hs_db, &ctx->
hs_db_size);
709 if (err != HS_SUCCESS) {
718 SCLogDebug(
"Built %" PRIu32
" patterns into a database of size %" PRIuMAX
728 SCHSFreeCompileData(cd);
733 PatternDatabaseFree(pd);
736 SCHSFreeCompileData(cd);
755 mpm_thread_ctx->
ctx = ctx;
765 if (g_scratch_proto == NULL) {
773 hs_error_t err = hs_clone_scratch(g_scratch_proto,
774 (hs_scratch_t **)&ctx->
scratch);
778 if (err != HS_SUCCESS) {
779 FatalError(
"Unable to clone scratch prototype");
783 if (err != HS_SUCCESS) {
796 void SCHSInitCtx(
MpmCtx *mpm_ctx)
798 if (mpm_ctx->
ctx != NULL)
802 if (mpm_ctx->
ctx == NULL) {
825 SCHSPrintSearchStats(mpm_thread_ctx);
827 if (mpm_thread_ctx->
ctx != NULL) {
830 if (thr_ctx->
scratch != NULL) {
831 hs_free_scratch(thr_ctx->
scratch);
837 mpm_thread_ctx->
ctx = NULL;
848 void SCHSDestroyCtx(
MpmCtx *mpm_ctx)
868 if (pd->ref_cnt == 0) {
870 PatternDatabaseFree(pd);
881 typedef struct SCHSCallbackCtx_ {
884 uint32_t match_count;
888 static int SCHSMatchEvent(
unsigned int id,
unsigned long long from,
889 unsigned long long to,
unsigned int flags,
892 SCHSCallbackCtx *cctx = ctx;
894 const PatternDatabase *pd = cctx->ctx->pattern_db;
897 SCLogDebug(
"Hyperscan Match %" PRIu32
": id=%" PRIu32
" @ %" PRIuMAX
898 " (pat id=%" PRIu32
")",
899 cctx->match_count, (uint32_t)
id, (uintmax_t)to, pat->
id);
931 SCHSCallbackCtx cctx = {.ctx = ctx, .pmq = pmq, .match_count = 0};
934 hs_scratch_t *scratch = hs_thread_ctx->scratch;
935 BUG_ON(pd->hs_db == NULL);
938 hs_error_t err = hs_scan(pd->hs_db, (
const char *)buf, buflen, 0, scratch,
939 SCHSMatchEvent, &cctx);
940 if (err != HS_SUCCESS) {
944 SCLogError(
"Hyperscan returned error %d", err);
947 ret = cctx.match_count;
970 int SCHSAddPatternCI(
MpmCtx *mpm_ctx, uint8_t *pat, uint16_t patlen,
971 uint16_t
offset, uint16_t depth, uint32_t pid,
975 return SCHSAddPattern(mpm_ctx, pat, patlen,
offset, depth, pid, sid,
flags);
995 int SCHSAddPatternCS(
MpmCtx *mpm_ctx, uint8_t *pat, uint16_t patlen,
996 uint16_t
offset, uint16_t depth, uint32_t pid,
999 return SCHSAddPattern(mpm_ctx, pat, patlen,
offset, depth, pid, sid,
flags);
1002 void SCHSPrintSearchStats(
MpmThreadCtx *mpm_thread_ctx)
1007 void SCHSPrintInfo(
MpmCtx *mpm_ctx)
1011 printf(
"MPM HS Information:\n");
1012 printf(
"Memory allocs: %" PRIu32
"\n", mpm_ctx->
memory_cnt);
1013 printf(
"Memory alloced: %" PRIu32
"\n", mpm_ctx->
memory_size);
1014 printf(
" Sizeof:\n");
1015 printf(
" MpmCtx %" PRIuMAX
"\n", (uintmax_t)
sizeof(
MpmCtx));
1016 printf(
" SCHSCtx: %" PRIuMAX
"\n", (uintmax_t)
sizeof(
SCHSCtx));
1017 printf(
" SCHSPattern %" PRIuMAX
"\n", (uintmax_t)
sizeof(
SCHSPattern));
1018 printf(
"Unique Patterns: %" PRIu32
"\n", mpm_ctx->
pattern_cnt);
1019 printf(
"Smallest: %" PRIu32
"\n", mpm_ctx->
minlen);
1020 printf(
"Largest: %" PRIu32
"\n", mpm_ctx->
maxlen);
1025 char *db_info = NULL;
1026 if (hs_database_info(pd->hs_db, &db_info) == HS_SUCCESS) {
1027 printf(
"HS Database Info: %s\n", db_info);
1030 printf(
"HS Database Size: %" PRIuMAX
" bytes\n",
1060 SCHSSetAllocators();
1071 if (g_scratch_proto) {
1072 SCLogDebug(
"Cleaning up Hyperscan global scratch");
1073 hs_free_scratch(g_scratch_proto);
1074 g_scratch_proto = NULL;
1079 if (g_db_table != NULL) {
1080 SCLogDebug(
"Clearing Hyperscan database cache");
1092 static int SCHSTest01(
void)
1099 memset(&mpm_ctx, 0,
sizeof(
MpmCtx));
1107 SCHSPreparePatterns(&mpm_ctx);
1108 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1110 const char *buf =
"abcdefghjiklmnopqrstuvwxyz";
1112 uint32_t
cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1118 printf(
"1 != %" PRIu32
" ",
cnt);
1120 SCHSDestroyCtx(&mpm_ctx);
1121 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1126 static int SCHSTest02(
void)
1133 memset(&mpm_ctx, 0,
sizeof(
MpmCtx));
1141 SCHSPreparePatterns(&mpm_ctx);
1142 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1144 const char *buf =
"abcdefghjiklmnopqrstuvwxyz";
1145 uint32_t
cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1151 printf(
"0 != %" PRIu32
" ",
cnt);
1153 SCHSDestroyCtx(&mpm_ctx);
1154 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1159 static int SCHSTest03(
void)
1166 memset(&mpm_ctx, 0x00,
sizeof(
MpmCtx));
1178 SCHSPreparePatterns(&mpm_ctx);
1179 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1181 const char *buf =
"abcdefghjiklmnopqrstuvwxyz";
1182 uint32_t
cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1188 printf(
"3 != %" PRIu32
" ",
cnt);
1190 SCHSDestroyCtx(&mpm_ctx);
1191 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1196 static int SCHSTest04(
void)
1203 memset(&mpm_ctx, 0,
sizeof(
MpmCtx));
1212 SCHSPreparePatterns(&mpm_ctx);
1213 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1215 const char *buf =
"abcdefghjiklmnopqrstuvwxyz";
1216 uint32_t
cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1222 printf(
"1 != %" PRIu32
" ",
cnt);
1224 SCHSDestroyCtx(&mpm_ctx);
1225 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1230 static int SCHSTest05(
void)
1237 memset(&mpm_ctx, 0x00,
sizeof(
MpmCtx));
1246 SCHSPreparePatterns(&mpm_ctx);
1247 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1249 const char *buf =
"abcdefghjiklmnopqrstuvwxyz";
1250 uint32_t
cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1256 printf(
"3 != %" PRIu32
" ",
cnt);
1258 SCHSDestroyCtx(&mpm_ctx);
1259 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1264 static int SCHSTest06(
void)
1271 memset(&mpm_ctx, 0,
sizeof(
MpmCtx));
1278 SCHSPreparePatterns(&mpm_ctx);
1279 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1281 const char *buf =
"abcd";
1282 uint32_t
cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1288 printf(
"1 != %" PRIu32
" ",
cnt);
1290 SCHSDestroyCtx(&mpm_ctx);
1291 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1296 static int SCHSTest07(
void)
1303 memset(&mpm_ctx, 0,
sizeof(
MpmCtx));
1316 MpmAddPatternCS(&mpm_ctx, (uint8_t *)
"AAAAAAAAAA", 10, 0, 0, 4, 0, 0);
1318 MpmAddPatternCS(&mpm_ctx, (uint8_t *)
"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", 30,
1322 SCHSPreparePatterns(&mpm_ctx);
1323 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1325 const char *buf =
"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
1326 uint32_t
cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1332 printf(
"6 != %" PRIu32
" ",
cnt);
1334 SCHSDestroyCtx(&mpm_ctx);
1335 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1340 static int SCHSTest08(
void)
1347 memset(&mpm_ctx, 0,
sizeof(
MpmCtx));
1355 SCHSPreparePatterns(&mpm_ctx);
1356 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1359 SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)
"a", 1);
1364 printf(
"0 != %" PRIu32
" ",
cnt);
1366 SCHSDestroyCtx(&mpm_ctx);
1367 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1372 static int SCHSTest09(
void)
1379 memset(&mpm_ctx, 0,
sizeof(
MpmCtx));
1387 SCHSPreparePatterns(&mpm_ctx);
1388 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1391 SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)
"ab", 2);
1396 printf(
"1 != %" PRIu32
" ",
cnt);
1398 SCHSDestroyCtx(&mpm_ctx);
1399 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1404 static int SCHSTest10(
void)
1411 memset(&mpm_ctx, 0,
sizeof(
MpmCtx));
1419 SCHSPreparePatterns(&mpm_ctx);
1420 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1422 const char *buf =
"01234567890123456789012345678901234567890123456789"
1423 "01234567890123456789012345678901234567890123456789"
1425 "01234567890123456789012345678901234567890123456789"
1426 "01234567890123456789012345678901234567890123456789";
1427 uint32_t
cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1433 printf(
"1 != %" PRIu32
" ",
cnt);
1435 SCHSDestroyCtx(&mpm_ctx);
1436 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1441 static int SCHSTest11(
void)
1448 memset(&mpm_ctx, 0,
sizeof(
MpmCtx));
1452 if (
MpmAddPatternCS(&mpm_ctx, (uint8_t *)
"he", 2, 0, 0, 1, 0, 0) == -1)
1454 if (
MpmAddPatternCS(&mpm_ctx, (uint8_t *)
"she", 3, 0, 0, 2, 0, 0) == -1)
1456 if (
MpmAddPatternCS(&mpm_ctx, (uint8_t *)
"his", 3, 0, 0, 3, 0, 0) == -1)
1458 if (
MpmAddPatternCS(&mpm_ctx, (uint8_t *)
"hers", 4, 0, 0, 4, 0, 0) == -1)
1462 if (SCHSPreparePatterns(&mpm_ctx) == -1)
1465 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1469 const char *buf =
"he";
1470 result &= (SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1473 result &= (SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1476 result &= (SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1479 result &= (SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1483 SCHSDestroyCtx(&mpm_ctx);
1484 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1489 static int SCHSTest12(
void)
1496 memset(&mpm_ctx, 0x00,
sizeof(
MpmCtx));
1506 SCHSPreparePatterns(&mpm_ctx);
1507 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1509 const char *buf =
"abcdefghijklmnopqrstuvwxyz";
1510 uint32_t
cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1516 printf(
"2 != %" PRIu32
" ",
cnt);
1518 SCHSDestroyCtx(&mpm_ctx);
1519 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1524 static int SCHSTest13(
void)
1531 memset(&mpm_ctx, 0x00,
sizeof(
MpmCtx));
1536 const char pat[] =
"abcdefghijklmnopqrstuvwxyzABCD";
1537 MpmAddPatternCS(&mpm_ctx, (uint8_t *)pat,
sizeof(pat) - 1, 0, 0, 0, 0, 0);
1540 SCHSPreparePatterns(&mpm_ctx);
1541 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1543 const char *buf =
"abcdefghijklmnopqrstuvwxyzABCD";
1544 uint32_t
cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1550 printf(
"1 != %" PRIu32
" ",
cnt);
1552 SCHSDestroyCtx(&mpm_ctx);
1553 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1558 static int SCHSTest14(
void)
1565 memset(&mpm_ctx, 0x00,
sizeof(
MpmCtx));
1570 const char pat[] =
"abcdefghijklmnopqrstuvwxyzABCDE";
1571 MpmAddPatternCS(&mpm_ctx, (uint8_t *)pat,
sizeof(pat) - 1, 0, 0, 0, 0, 0);
1574 SCHSPreparePatterns(&mpm_ctx);
1575 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1577 const char *buf =
"abcdefghijklmnopqrstuvwxyzABCDE";
1578 uint32_t
cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1584 printf(
"1 != %" PRIu32
" ",
cnt);
1586 SCHSDestroyCtx(&mpm_ctx);
1587 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1592 static int SCHSTest15(
void)
1599 memset(&mpm_ctx, 0x00,
sizeof(
MpmCtx));
1604 const char pat[] =
"abcdefghijklmnopqrstuvwxyzABCDEF";
1605 MpmAddPatternCS(&mpm_ctx, (uint8_t *)pat,
sizeof(pat) - 1, 0, 0, 0, 0, 0);
1608 SCHSPreparePatterns(&mpm_ctx);
1609 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1611 const char *buf =
"abcdefghijklmnopqrstuvwxyzABCDEF";
1612 uint32_t
cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1618 printf(
"1 != %" PRIu32
" ",
cnt);
1620 SCHSDestroyCtx(&mpm_ctx);
1621 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1626 static int SCHSTest16(
void)
1633 memset(&mpm_ctx, 0x00,
sizeof(
MpmCtx));
1638 const char pat[] =
"abcdefghijklmnopqrstuvwxyzABC";
1639 MpmAddPatternCS(&mpm_ctx, (uint8_t *)pat,
sizeof(pat) - 1, 0, 0, 0, 0, 0);
1642 SCHSPreparePatterns(&mpm_ctx);
1643 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1645 const char *buf =
"abcdefghijklmnopqrstuvwxyzABC";
1646 uint32_t
cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1652 printf(
"1 != %" PRIu32
" ",
cnt);
1654 SCHSDestroyCtx(&mpm_ctx);
1655 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1660 static int SCHSTest17(
void)
1667 memset(&mpm_ctx, 0x00,
sizeof(
MpmCtx));
1672 const char pat[] =
"abcdefghijklmnopqrstuvwxyzAB";
1673 MpmAddPatternCS(&mpm_ctx, (uint8_t *)pat,
sizeof(pat) - 1, 0, 0, 0, 0, 0);
1676 SCHSPreparePatterns(&mpm_ctx);
1677 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1679 const char *buf =
"abcdefghijklmnopqrstuvwxyzAB";
1680 uint32_t
cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1686 printf(
"1 != %" PRIu32
" ",
cnt);
1688 SCHSDestroyCtx(&mpm_ctx);
1689 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1694 static int SCHSTest18(
void)
1701 memset(&mpm_ctx, 0x00,
sizeof(
MpmCtx));
1706 const char pat[] =
"abcde"
1712 MpmAddPatternCS(&mpm_ctx, (uint8_t *)pat,
sizeof(pat) - 1, 0, 0, 0, 0, 0);
1715 SCHSPreparePatterns(&mpm_ctx);
1716 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1718 const char *buf =
"abcde"
1724 uint32_t
cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1730 printf(
"1 != %" PRIu32
" ",
cnt);
1732 SCHSDestroyCtx(&mpm_ctx);
1733 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1738 static int SCHSTest19(
void)
1745 memset(&mpm_ctx, 0x00,
sizeof(
MpmCtx));
1750 const char pat[] =
"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
1751 MpmAddPatternCS(&mpm_ctx, (uint8_t *)pat,
sizeof(pat) - 1, 0, 0, 0, 0, 0);
1754 SCHSPreparePatterns(&mpm_ctx);
1755 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1757 const char *buf =
"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
1758 uint32_t
cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1764 printf(
"1 != %" PRIu32
" ",
cnt);
1766 SCHSDestroyCtx(&mpm_ctx);
1767 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1772 static int SCHSTest20(
void)
1779 memset(&mpm_ctx, 0x00,
sizeof(
MpmCtx));
1784 const char pat[] =
"AAAAA"
1791 MpmAddPatternCS(&mpm_ctx, (uint8_t *)pat,
sizeof(pat) - 1, 0, 0, 0, 0, 0);
1794 SCHSPreparePatterns(&mpm_ctx);
1795 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1797 const char *buf =
"AAAAA"
1804 uint32_t
cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1810 printf(
"1 != %" PRIu32
" ",
cnt);
1812 SCHSDestroyCtx(&mpm_ctx);
1813 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1818 static int SCHSTest21(
void)
1825 memset(&mpm_ctx, 0x00,
sizeof(
MpmCtx));
1833 SCHSPreparePatterns(&mpm_ctx);
1834 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1837 SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)
"AA", 2);
1842 printf(
"1 != %" PRIu32
" ",
cnt);
1844 SCHSDestroyCtx(&mpm_ctx);
1845 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1850 static int SCHSTest22(
void)
1857 memset(&mpm_ctx, 0x00,
sizeof(
MpmCtx));
1867 SCHSPreparePatterns(&mpm_ctx);
1868 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1870 const char *buf =
"abcdefghijklmnopqrstuvwxyz";
1871 uint32_t
cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1877 printf(
"2 != %" PRIu32
" ",
cnt);
1879 SCHSDestroyCtx(&mpm_ctx);
1880 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1885 static int SCHSTest23(
void)
1892 memset(&mpm_ctx, 0x00,
sizeof(
MpmCtx));
1900 SCHSPreparePatterns(&mpm_ctx);
1901 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1904 SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)
"aa", 2);
1909 printf(
"1 != %" PRIu32
" ",
cnt);
1911 SCHSDestroyCtx(&mpm_ctx);
1912 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1917 static int SCHSTest24(
void)
1924 memset(&mpm_ctx, 0x00,
sizeof(
MpmCtx));
1932 SCHSPreparePatterns(&mpm_ctx);
1933 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1936 SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)
"aa", 2);
1941 printf(
"1 != %" PRIu32
" ",
cnt);
1943 SCHSDestroyCtx(&mpm_ctx);
1944 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1949 static int SCHSTest25(
void)
1956 memset(&mpm_ctx, 0x00,
sizeof(
MpmCtx));
1965 SCHSPreparePatterns(&mpm_ctx);
1966 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1968 const char *buf =
"ABCDEFGHIJKLMNOPQRSTUVWXYZ";
1969 uint32_t
cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1975 printf(
"3 != %" PRIu32
" ",
cnt);
1977 SCHSDestroyCtx(&mpm_ctx);
1978 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1983 static int SCHSTest26(
void)
1990 memset(&mpm_ctx, 0x00,
sizeof(
MpmCtx));
1998 SCHSPreparePatterns(&mpm_ctx);
1999 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
2001 const char *buf =
"works";
2002 uint32_t
cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
2008 printf(
"3 != %" PRIu32
" ",
cnt);
2010 SCHSDestroyCtx(&mpm_ctx);
2011 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
2016 static int SCHSTest27(
void)
2023 memset(&mpm_ctx, 0,
sizeof(
MpmCtx));
2031 SCHSPreparePatterns(&mpm_ctx);
2032 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
2034 const char *buf =
"tone";
2035 uint32_t
cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
2041 printf(
"0 != %" PRIu32
" ",
cnt);
2043 SCHSDestroyCtx(&mpm_ctx);
2044 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
2049 static int SCHSTest28(
void)
2056 memset(&mpm_ctx, 0,
sizeof(
MpmCtx));
2064 SCHSPreparePatterns(&mpm_ctx);
2065 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
2067 const char *buf =
"tONE";
2068 uint32_t
cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
2074 printf(
"0 != %" PRIu32
" ",
cnt);
2076 SCHSDestroyCtx(&mpm_ctx);
2077 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
2082 static int SCHSTest29(
void)
2084 uint8_t buf[] =
"onetwothreefourfivesixseveneightnine";
2085 uint16_t buflen =
sizeof(buf) - 1;
2091 memset(&th_v, 0,
sizeof(th_v));
2102 de_ctx,
"alert tcp any any -> any any "
2103 "(content:\"onetwothreefourfivesixseveneightnine\"; sid:1;)");
2108 "(content:\"onetwothreefourfivesixseveneightnine\"; "
2109 "fast_pattern:3,3; sid:2;)");
2118 printf(
"if (PacketAlertCheck(p, 1) != 1) failure\n");
2122 printf(
"if (PacketAlertCheck(p, 1) != 2) failure\n");
2140 static void SCHSRegisterTests(
void)