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);
63 void SCHSRegisterTests(
void);
66 #define INIT_HASH_SIZE 65536
69 #define INIT_DB_HASH_SIZE 1000
74 static hs_scratch_t *g_scratch_proto = NULL;
87 static void *SCHSMalloc(
size_t size)
97 static void SCHSFree(
void *ptr)
107 static void SCHSSetAllocators(
void)
109 hs_error_t err = hs_set_allocator(SCHSMalloc, SCHSFree);
110 if (err != HS_SUCCESS) {
111 FatalError(
"Failed to set Hyperscan allocator.");
125 static inline uint32_t SCHSInitHashRaw(uint8_t *pat, uint16_t patlen)
127 uint32_t hash = patlen * pat[0];
131 return (hash % INIT_HASH_SIZE);
147 uint16_t patlen, uint16_t
offset,
148 uint16_t depth,
char flags,
151 uint32_t hash = SCHSInitHashRaw(pat, patlen);
158 for (; t != NULL; t = t->
next) {
209 if (p != NULL && p->
sids != NULL) {
220 static inline uint32_t SCHSInitHash(
SCHSPattern *p)
226 return (hash % INIT_HASH_SIZE);
231 uint32_t hash = SCHSInitHash(p);
270 static int SCHSAddPattern(
MpmCtx *mpm_ctx, uint8_t *pat, uint16_t patlen,
271 uint16_t
offset, uint16_t depth, uint32_t pid,
290 SCHSInitHashLookup(ctx, pat, patlen,
offset, depth,
flags, pid);
295 p = SCHSAllocPattern(mpm_ctx);
312 SCHSInitHashAdd(ctx, p);
323 SCLogDebug(
"%p: alas, no depth for us", mpm_ctx);
327 if (mpm_ctx->
maxlen < patlen)
330 if (mpm_ctx->
minlen == 0) {
333 if (mpm_ctx->
minlen > patlen)
347 if (p->
sids[x] == sid) {
364 SCHSFreePattern(mpm_ctx, p);
372 typedef struct SCHSCompileData_ {
377 unsigned int pattern_cnt;
380 static SCHSCompileData *SCHSAllocCompileData(
unsigned int pattern_cnt)
382 SCHSCompileData *cd =
SCMalloc(pattern_cnt *
sizeof(SCHSCompileData));
386 memset(cd, 0, pattern_cnt *
sizeof(SCHSCompileData));
388 cd->pattern_cnt = pattern_cnt;
390 cd->ids =
SCMalloc(pattern_cnt *
sizeof(
unsigned int));
391 if (cd->ids == NULL) {
394 memset(cd->ids, 0, pattern_cnt *
sizeof(
unsigned int));
396 cd->flags =
SCMalloc(pattern_cnt *
sizeof(
unsigned int));
397 if (cd->flags == NULL) {
400 memset(cd->flags, 0, pattern_cnt *
sizeof(
unsigned int));
402 cd->expressions =
SCMalloc(pattern_cnt *
sizeof(
char *));
403 if (cd->expressions == NULL) {
406 memset(cd->expressions, 0, pattern_cnt *
sizeof(
char *));
408 cd->ext =
SCMalloc(pattern_cnt *
sizeof(hs_expr_ext_t *));
409 if (cd->ext == NULL) {
412 memset(cd->ext, 0, pattern_cnt *
sizeof(hs_expr_ext_t *));
428 static void SCHSFreeCompileData(SCHSCompileData *cd)
436 if (cd->expressions) {
437 for (
unsigned int i = 0; i < cd->pattern_cnt; i++) {
438 SCFree(cd->expressions[i]);
443 for (
unsigned int i = 0; i < cd->pattern_cnt; i++) {
451 typedef struct PatternDatabase_ {
453 hs_database_t *hs_db;
454 uint32_t pattern_cnt;
460 static uint32_t SCHSPatternHash(
const SCHSPattern *p, uint32_t hash)
496 static uint32_t PatternDatabaseHash(
HashTable *ht,
void *data, uint16_t
len)
498 const PatternDatabase *pd = data;
500 hash =
hashword(&pd->pattern_cnt, 1, hash);
502 for (uint32_t i = 0; i < pd->pattern_cnt; i++) {
503 hash = SCHSPatternHash(pd->parray[i], hash);
510 static char PatternDatabaseCompare(
void *data1, uint16_t len1,
void *data2,
513 const PatternDatabase *pd1 = data1;
514 const PatternDatabase *pd2 = data2;
516 if (pd1->pattern_cnt != pd2->pattern_cnt) {
520 for (uint32_t i = 0; i < pd1->pattern_cnt; i++) {
521 if (SCHSPatternCompare(pd1->parray[i], pd2->parray[i]) == 0) {
529 static void PatternDatabaseFree(PatternDatabase *pd)
533 if (pd->parray != NULL) {
534 for (uint32_t i = 0; i < pd->pattern_cnt; i++) {
545 hs_free_database(pd->hs_db);
550 static void PatternDatabaseTableFree(
void *data)
556 static PatternDatabase *PatternDatabaseAlloc(uint32_t pattern_cnt)
558 PatternDatabase *pd =
SCMalloc(
sizeof(PatternDatabase));
562 memset(pd, 0,
sizeof(PatternDatabase));
563 pd->pattern_cnt = pattern_cnt;
570 if (pd->parray == NULL) {
574 memset(pd->parray, 0, pd->pattern_cnt *
sizeof(
SCHSPattern *));
584 int SCHSPreparePatterns(
MpmCtx *mpm_ctx)
589 SCLogDebug(
"no patterns supplied to this mpm_ctx");
594 hs_compile_error_t *compile_err = NULL;
595 SCHSCompileData *cd = NULL;
596 PatternDatabase *pd = NULL;
609 for (uint32_t i = 0, p = 0; i < INIT_HASH_SIZE; i++) {
611 while (node != NULL) {
614 pd->parray[p++] = node;
628 if (g_db_table == NULL) {
629 g_db_table =
HashTableInit(INIT_DB_HASH_SIZE, PatternDatabaseHash,
630 PatternDatabaseCompare,
631 PatternDatabaseTableFree);
632 if (g_db_table == NULL) {
642 if (pd_cached != NULL) {
643 SCLogDebug(
"Reusing cached database %p with %" PRIu32
644 " patterns (ref_cnt=%" PRIu32
")",
645 pd_cached->hs_db, pd_cached->pattern_cnt,
647 pd_cached->ref_cnt++;
650 PatternDatabaseFree(pd);
651 SCHSFreeCompileData(cd);
657 for (uint32_t i = 0; i < pd->pattern_cnt; i++) {
661 cd->
flags[i] = HS_FLAG_SINGLEMATCH;
663 cd->flags[i] |= HS_FLAG_CASELESS;
669 cd->ext[i] =
SCMalloc(
sizeof(hs_expr_ext_t));
670 if (cd->ext[i] == NULL) {
674 memset(cd->ext[i], 0,
sizeof(hs_expr_ext_t));
677 cd->ext[i]->flags |= HS_EXT_FLAG_MIN_OFFSET;
678 cd->ext[i]->min_offset = p->
offset + p->
len;
681 cd->ext[i]->flags |= HS_EXT_FLAG_MAX_OFFSET;
689 err = hs_compile_ext_multi((
const char *
const *)cd->expressions, cd->flags,
690 cd->ids, (
const hs_expr_ext_t *
const *)cd->ext,
691 cd->pattern_cnt, HS_MODE_BLOCK, NULL, &pd->hs_db,
694 if (err != HS_SUCCESS) {
695 SCLogError(
"failed to compile hyperscan database");
697 SCLogError(
"compile error: %s", compile_err->message);
699 hs_free_compile_error(compile_err);
707 err = hs_alloc_scratch(pd->hs_db, &g_scratch_proto);
709 if (err != HS_SUCCESS) {
715 err = hs_database_size(pd->hs_db, &ctx->
hs_db_size);
716 if (err != HS_SUCCESS) {
725 SCLogDebug(
"Built %" PRIu32
" patterns into a database of size %" PRIuMAX
735 SCHSFreeCompileData(cd);
740 PatternDatabaseFree(pd);
743 SCHSFreeCompileData(cd);
762 mpm_thread_ctx->
ctx = ctx;
773 if (g_scratch_proto == NULL) {
781 hs_error_t err = hs_clone_scratch(g_scratch_proto,
782 (hs_scratch_t **)&ctx->
scratch);
786 if (err != HS_SUCCESS) {
787 FatalError(
"Unable to clone scratch prototype");
791 if (err != HS_SUCCESS) {
804 void SCHSInitCtx(
MpmCtx *mpm_ctx)
806 if (mpm_ctx->
ctx != NULL)
810 if (mpm_ctx->
ctx == NULL) {
835 SCHSPrintSearchStats(mpm_thread_ctx);
837 if (mpm_thread_ctx->
ctx != NULL) {
840 if (thr_ctx->
scratch != NULL) {
841 hs_free_scratch(thr_ctx->
scratch);
847 mpm_thread_ctx->
ctx = NULL;
858 void SCHSDestroyCtx(
MpmCtx *mpm_ctx)
878 if (pd->ref_cnt == 0) {
880 PatternDatabaseFree(pd);
890 typedef struct SCHSCallbackCtx_ {
893 uint32_t match_count;
897 static int SCHSMatchEvent(
unsigned int id,
unsigned long long from,
898 unsigned long long to,
unsigned int flags,
901 SCHSCallbackCtx *cctx = ctx;
903 const PatternDatabase *pd = cctx->ctx->pattern_db;
906 SCLogDebug(
"Hyperscan Match %" PRIu32
": id=%" PRIu32
" @ %" PRIuMAX
907 " (pat id=%" PRIu32
")",
908 cctx->match_count, (uint32_t)
id, (uintmax_t)to, pat->
id);
940 SCHSCallbackCtx cctx = {.ctx = ctx, .pmq = pmq, .match_count = 0};
943 hs_scratch_t *scratch = hs_thread_ctx->scratch;
944 BUG_ON(pd->hs_db == NULL);
947 hs_error_t err = hs_scan(pd->hs_db, (
const char *)buf, buflen, 0, scratch,
948 SCHSMatchEvent, &cctx);
949 if (err != HS_SUCCESS) {
953 SCLogError(
"Hyperscan returned error %d", err);
956 ret = cctx.match_count;
979 int SCHSAddPatternCI(
MpmCtx *mpm_ctx, uint8_t *pat, uint16_t patlen,
980 uint16_t
offset, uint16_t depth, uint32_t pid,
984 return SCHSAddPattern(mpm_ctx, pat, patlen,
offset, depth, pid, sid,
flags);
1004 int SCHSAddPatternCS(
MpmCtx *mpm_ctx, uint8_t *pat, uint16_t patlen,
1005 uint16_t
offset, uint16_t depth, uint32_t pid,
1008 return SCHSAddPattern(mpm_ctx, pat, patlen,
offset, depth, pid, sid,
flags);
1011 void SCHSPrintSearchStats(
MpmThreadCtx *mpm_thread_ctx)
1016 void SCHSPrintInfo(
MpmCtx *mpm_ctx)
1020 printf(
"MPM HS Information:\n");
1021 printf(
"Memory allocs: %" PRIu32
"\n", mpm_ctx->
memory_cnt);
1022 printf(
"Memory alloced: %" PRIu32
"\n", mpm_ctx->
memory_size);
1023 printf(
" Sizeof:\n");
1024 printf(
" MpmCtx %" PRIuMAX
"\n", (uintmax_t)
sizeof(
MpmCtx));
1025 printf(
" SCHSCtx: %" PRIuMAX
"\n", (uintmax_t)
sizeof(
SCHSCtx));
1026 printf(
" SCHSPattern %" PRIuMAX
"\n", (uintmax_t)
sizeof(
SCHSPattern));
1027 printf(
"Unique Patterns: %" PRIu32
"\n", mpm_ctx->
pattern_cnt);
1028 printf(
"Smallest: %" PRIu32
"\n", mpm_ctx->
minlen);
1029 printf(
"Largest: %" PRIu32
"\n", mpm_ctx->
maxlen);
1034 char *db_info = NULL;
1035 if (hs_database_info(pd->hs_db, &db_info) == HS_SUCCESS) {
1036 printf(
"HS Database Info: %s\n", db_info);
1039 printf(
"HS Database Size: %" PRIuMAX
" bytes\n",
1067 SCHSSetAllocators();
1078 if (g_scratch_proto) {
1079 SCLogDebug(
"Cleaning up Hyperscan global scratch");
1080 hs_free_scratch(g_scratch_proto);
1081 g_scratch_proto = NULL;
1086 if (g_db_table != NULL) {
1087 SCLogDebug(
"Clearing Hyperscan database cache");
1099 static int SCHSTest01(
void)
1106 memset(&mpm_ctx, 0,
sizeof(
MpmCtx));
1114 SCHSPreparePatterns(&mpm_ctx);
1115 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1117 const char *buf =
"abcdefghjiklmnopqrstuvwxyz";
1119 uint32_t cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1125 printf(
"1 != %" PRIu32
" ", cnt);
1127 SCHSDestroyCtx(&mpm_ctx);
1128 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1133 static int SCHSTest02(
void)
1140 memset(&mpm_ctx, 0,
sizeof(
MpmCtx));
1148 SCHSPreparePatterns(&mpm_ctx);
1149 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1151 const char *buf =
"abcdefghjiklmnopqrstuvwxyz";
1152 uint32_t cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1158 printf(
"0 != %" PRIu32
" ", cnt);
1160 SCHSDestroyCtx(&mpm_ctx);
1161 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1166 static int SCHSTest03(
void)
1173 memset(&mpm_ctx, 0x00,
sizeof(
MpmCtx));
1185 SCHSPreparePatterns(&mpm_ctx);
1186 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1188 const char *buf =
"abcdefghjiklmnopqrstuvwxyz";
1189 uint32_t cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1195 printf(
"3 != %" PRIu32
" ", cnt);
1197 SCHSDestroyCtx(&mpm_ctx);
1198 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1203 static int SCHSTest04(
void)
1210 memset(&mpm_ctx, 0,
sizeof(
MpmCtx));
1219 SCHSPreparePatterns(&mpm_ctx);
1220 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1222 const char *buf =
"abcdefghjiklmnopqrstuvwxyz";
1223 uint32_t cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1229 printf(
"1 != %" PRIu32
" ", cnt);
1231 SCHSDestroyCtx(&mpm_ctx);
1232 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1237 static int SCHSTest05(
void)
1244 memset(&mpm_ctx, 0x00,
sizeof(
MpmCtx));
1253 SCHSPreparePatterns(&mpm_ctx);
1254 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1256 const char *buf =
"abcdefghjiklmnopqrstuvwxyz";
1257 uint32_t cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1263 printf(
"3 != %" PRIu32
" ", cnt);
1265 SCHSDestroyCtx(&mpm_ctx);
1266 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1271 static int SCHSTest06(
void)
1278 memset(&mpm_ctx, 0,
sizeof(
MpmCtx));
1285 SCHSPreparePatterns(&mpm_ctx);
1286 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1288 const char *buf =
"abcd";
1289 uint32_t cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1295 printf(
"1 != %" PRIu32
" ", cnt);
1297 SCHSDestroyCtx(&mpm_ctx);
1298 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1303 static int SCHSTest07(
void)
1310 memset(&mpm_ctx, 0,
sizeof(
MpmCtx));
1323 MpmAddPatternCS(&mpm_ctx, (uint8_t *)
"AAAAAAAAAA", 10, 0, 0, 4, 0, 0);
1325 MpmAddPatternCS(&mpm_ctx, (uint8_t *)
"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", 30,
1329 SCHSPreparePatterns(&mpm_ctx);
1330 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1332 const char *buf =
"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
1333 uint32_t cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1339 printf(
"6 != %" PRIu32
" ", cnt);
1341 SCHSDestroyCtx(&mpm_ctx);
1342 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1347 static int SCHSTest08(
void)
1354 memset(&mpm_ctx, 0,
sizeof(
MpmCtx));
1362 SCHSPreparePatterns(&mpm_ctx);
1363 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1366 SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)
"a", 1);
1371 printf(
"0 != %" PRIu32
" ", cnt);
1373 SCHSDestroyCtx(&mpm_ctx);
1374 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1379 static int SCHSTest09(
void)
1386 memset(&mpm_ctx, 0,
sizeof(
MpmCtx));
1394 SCHSPreparePatterns(&mpm_ctx);
1395 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1398 SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)
"ab", 2);
1403 printf(
"1 != %" PRIu32
" ", cnt);
1405 SCHSDestroyCtx(&mpm_ctx);
1406 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1411 static int SCHSTest10(
void)
1418 memset(&mpm_ctx, 0,
sizeof(
MpmCtx));
1426 SCHSPreparePatterns(&mpm_ctx);
1427 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1429 const char *buf =
"01234567890123456789012345678901234567890123456789"
1430 "01234567890123456789012345678901234567890123456789"
1432 "01234567890123456789012345678901234567890123456789"
1433 "01234567890123456789012345678901234567890123456789";
1434 uint32_t cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1440 printf(
"1 != %" PRIu32
" ", cnt);
1442 SCHSDestroyCtx(&mpm_ctx);
1443 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1448 static int SCHSTest11(
void)
1455 memset(&mpm_ctx, 0,
sizeof(
MpmCtx));
1459 if (
MpmAddPatternCS(&mpm_ctx, (uint8_t *)
"he", 2, 0, 0, 1, 0, 0) == -1)
1461 if (
MpmAddPatternCS(&mpm_ctx, (uint8_t *)
"she", 3, 0, 0, 2, 0, 0) == -1)
1463 if (
MpmAddPatternCS(&mpm_ctx, (uint8_t *)
"his", 3, 0, 0, 3, 0, 0) == -1)
1465 if (
MpmAddPatternCS(&mpm_ctx, (uint8_t *)
"hers", 4, 0, 0, 4, 0, 0) == -1)
1469 if (SCHSPreparePatterns(&mpm_ctx) == -1)
1472 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1476 const char *buf =
"he";
1477 result &= (SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1480 result &= (SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1483 result &= (SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1486 result &= (SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1490 SCHSDestroyCtx(&mpm_ctx);
1491 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1496 static int SCHSTest12(
void)
1503 memset(&mpm_ctx, 0x00,
sizeof(
MpmCtx));
1513 SCHSPreparePatterns(&mpm_ctx);
1514 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1516 const char *buf =
"abcdefghijklmnopqrstuvwxyz";
1517 uint32_t cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1523 printf(
"2 != %" PRIu32
" ", cnt);
1525 SCHSDestroyCtx(&mpm_ctx);
1526 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1531 static int SCHSTest13(
void)
1538 memset(&mpm_ctx, 0x00,
sizeof(
MpmCtx));
1543 const char pat[] =
"abcdefghijklmnopqrstuvwxyzABCD";
1544 MpmAddPatternCS(&mpm_ctx, (uint8_t *)pat,
sizeof(pat) - 1, 0, 0, 0, 0, 0);
1547 SCHSPreparePatterns(&mpm_ctx);
1548 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1550 const char *buf =
"abcdefghijklmnopqrstuvwxyzABCD";
1551 uint32_t cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1557 printf(
"1 != %" PRIu32
" ", cnt);
1559 SCHSDestroyCtx(&mpm_ctx);
1560 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1565 static int SCHSTest14(
void)
1572 memset(&mpm_ctx, 0x00,
sizeof(
MpmCtx));
1577 const char pat[] =
"abcdefghijklmnopqrstuvwxyzABCDE";
1578 MpmAddPatternCS(&mpm_ctx, (uint8_t *)pat,
sizeof(pat) - 1, 0, 0, 0, 0, 0);
1581 SCHSPreparePatterns(&mpm_ctx);
1582 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1584 const char *buf =
"abcdefghijklmnopqrstuvwxyzABCDE";
1585 uint32_t cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1591 printf(
"1 != %" PRIu32
" ", cnt);
1593 SCHSDestroyCtx(&mpm_ctx);
1594 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1599 static int SCHSTest15(
void)
1606 memset(&mpm_ctx, 0x00,
sizeof(
MpmCtx));
1611 const char pat[] =
"abcdefghijklmnopqrstuvwxyzABCDEF";
1612 MpmAddPatternCS(&mpm_ctx, (uint8_t *)pat,
sizeof(pat) - 1, 0, 0, 0, 0, 0);
1615 SCHSPreparePatterns(&mpm_ctx);
1616 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1618 const char *buf =
"abcdefghijklmnopqrstuvwxyzABCDEF";
1619 uint32_t cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1625 printf(
"1 != %" PRIu32
" ", cnt);
1627 SCHSDestroyCtx(&mpm_ctx);
1628 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1633 static int SCHSTest16(
void)
1640 memset(&mpm_ctx, 0x00,
sizeof(
MpmCtx));
1645 const char pat[] =
"abcdefghijklmnopqrstuvwxyzABC";
1646 MpmAddPatternCS(&mpm_ctx, (uint8_t *)pat,
sizeof(pat) - 1, 0, 0, 0, 0, 0);
1649 SCHSPreparePatterns(&mpm_ctx);
1650 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1652 const char *buf =
"abcdefghijklmnopqrstuvwxyzABC";
1653 uint32_t cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1659 printf(
"1 != %" PRIu32
" ", cnt);
1661 SCHSDestroyCtx(&mpm_ctx);
1662 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1667 static int SCHSTest17(
void)
1674 memset(&mpm_ctx, 0x00,
sizeof(
MpmCtx));
1679 const char pat[] =
"abcdefghijklmnopqrstuvwxyzAB";
1680 MpmAddPatternCS(&mpm_ctx, (uint8_t *)pat,
sizeof(pat) - 1, 0, 0, 0, 0, 0);
1683 SCHSPreparePatterns(&mpm_ctx);
1684 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1686 const char *buf =
"abcdefghijklmnopqrstuvwxyzAB";
1687 uint32_t cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1693 printf(
"1 != %" PRIu32
" ", cnt);
1695 SCHSDestroyCtx(&mpm_ctx);
1696 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1701 static int SCHSTest18(
void)
1708 memset(&mpm_ctx, 0x00,
sizeof(
MpmCtx));
1713 const char pat[] =
"abcde"
1719 MpmAddPatternCS(&mpm_ctx, (uint8_t *)pat,
sizeof(pat) - 1, 0, 0, 0, 0, 0);
1722 SCHSPreparePatterns(&mpm_ctx);
1723 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1725 const char *buf =
"abcde"
1731 uint32_t cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1737 printf(
"1 != %" PRIu32
" ", cnt);
1739 SCHSDestroyCtx(&mpm_ctx);
1740 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1745 static int SCHSTest19(
void)
1752 memset(&mpm_ctx, 0x00,
sizeof(
MpmCtx));
1757 const char pat[] =
"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
1758 MpmAddPatternCS(&mpm_ctx, (uint8_t *)pat,
sizeof(pat) - 1, 0, 0, 0, 0, 0);
1761 SCHSPreparePatterns(&mpm_ctx);
1762 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1764 const char *buf =
"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
1765 uint32_t cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1771 printf(
"1 != %" PRIu32
" ", cnt);
1773 SCHSDestroyCtx(&mpm_ctx);
1774 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1779 static int SCHSTest20(
void)
1786 memset(&mpm_ctx, 0x00,
sizeof(
MpmCtx));
1791 const char pat[] =
"AAAAA"
1798 MpmAddPatternCS(&mpm_ctx, (uint8_t *)pat,
sizeof(pat) - 1, 0, 0, 0, 0, 0);
1801 SCHSPreparePatterns(&mpm_ctx);
1802 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1804 const char *buf =
"AAAAA"
1811 uint32_t cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1817 printf(
"1 != %" PRIu32
" ", cnt);
1819 SCHSDestroyCtx(&mpm_ctx);
1820 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1825 static int SCHSTest21(
void)
1832 memset(&mpm_ctx, 0x00,
sizeof(
MpmCtx));
1840 SCHSPreparePatterns(&mpm_ctx);
1841 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1844 SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)
"AA", 2);
1849 printf(
"1 != %" PRIu32
" ", cnt);
1851 SCHSDestroyCtx(&mpm_ctx);
1852 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1857 static int SCHSTest22(
void)
1864 memset(&mpm_ctx, 0x00,
sizeof(
MpmCtx));
1874 SCHSPreparePatterns(&mpm_ctx);
1875 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1877 const char *buf =
"abcdefghijklmnopqrstuvwxyz";
1878 uint32_t cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1884 printf(
"2 != %" PRIu32
" ", cnt);
1886 SCHSDestroyCtx(&mpm_ctx);
1887 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1892 static int SCHSTest23(
void)
1899 memset(&mpm_ctx, 0x00,
sizeof(
MpmCtx));
1907 SCHSPreparePatterns(&mpm_ctx);
1908 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1911 SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)
"aa", 2);
1916 printf(
"1 != %" PRIu32
" ", cnt);
1918 SCHSDestroyCtx(&mpm_ctx);
1919 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1924 static int SCHSTest24(
void)
1931 memset(&mpm_ctx, 0x00,
sizeof(
MpmCtx));
1939 SCHSPreparePatterns(&mpm_ctx);
1940 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1943 SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)
"aa", 2);
1948 printf(
"1 != %" PRIu32
" ", cnt);
1950 SCHSDestroyCtx(&mpm_ctx);
1951 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1956 static int SCHSTest25(
void)
1963 memset(&mpm_ctx, 0x00,
sizeof(
MpmCtx));
1972 SCHSPreparePatterns(&mpm_ctx);
1973 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1975 const char *buf =
"ABCDEFGHIJKLMNOPQRSTUVWXYZ";
1976 uint32_t cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1982 printf(
"3 != %" PRIu32
" ", cnt);
1984 SCHSDestroyCtx(&mpm_ctx);
1985 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1990 static int SCHSTest26(
void)
1997 memset(&mpm_ctx, 0x00,
sizeof(
MpmCtx));
2005 SCHSPreparePatterns(&mpm_ctx);
2006 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
2008 const char *buf =
"works";
2009 uint32_t cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
2015 printf(
"3 != %" PRIu32
" ", cnt);
2017 SCHSDestroyCtx(&mpm_ctx);
2018 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
2023 static int SCHSTest27(
void)
2030 memset(&mpm_ctx, 0,
sizeof(
MpmCtx));
2038 SCHSPreparePatterns(&mpm_ctx);
2039 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
2041 const char *buf =
"tone";
2042 uint32_t cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
2048 printf(
"0 != %" PRIu32
" ", cnt);
2050 SCHSDestroyCtx(&mpm_ctx);
2051 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
2056 static int SCHSTest28(
void)
2063 memset(&mpm_ctx, 0,
sizeof(
MpmCtx));
2071 SCHSPreparePatterns(&mpm_ctx);
2072 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
2074 const char *buf =
"tONE";
2075 uint32_t cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
2081 printf(
"0 != %" PRIu32
" ", cnt);
2083 SCHSDestroyCtx(&mpm_ctx);
2084 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
2089 static int SCHSTest29(
void)
2091 uint8_t buf[] =
"onetwothreefourfivesixseveneightnine";
2092 uint16_t buflen =
sizeof(buf) - 1;
2098 memset(&th_v, 0,
sizeof(th_v));
2109 de_ctx,
"alert tcp any any -> any any "
2110 "(content:\"onetwothreefourfivesixseveneightnine\"; sid:1;)");
2115 "(content:\"onetwothreefourfivesixseveneightnine\"; "
2116 "fast_pattern:3,3; sid:2;)");
2125 printf(
"if (PacketAlertCheck(p, 1) != 1) failure\n");
2129 printf(
"if (PacketAlertCheck(p, 1) != 2) failure\n");
2149 void SCHSRegisterTests(
void)