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) {
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) {
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) {
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) {
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 SCLogPerf(
"Cleaning up Hyperscan global scratch");
1080 hs_free_scratch(g_scratch_proto);
1081 g_scratch_proto = NULL;
1086 if (g_db_table != NULL) {
1087 SCLogPerf(
"Clearing Hyperscan database cache");
1098 static int SCHSTest01(
void)
1105 memset(&mpm_ctx, 0,
sizeof(
MpmCtx));
1113 SCHSPreparePatterns(&mpm_ctx);
1114 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1116 const char *buf =
"abcdefghjiklmnopqrstuvwxyz";
1118 uint32_t cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1124 printf(
"1 != %" PRIu32
" ", cnt);
1126 SCHSDestroyCtx(&mpm_ctx);
1127 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1132 static int SCHSTest02(
void)
1139 memset(&mpm_ctx, 0,
sizeof(
MpmCtx));
1147 SCHSPreparePatterns(&mpm_ctx);
1148 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1150 const char *buf =
"abcdefghjiklmnopqrstuvwxyz";
1151 uint32_t cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1157 printf(
"0 != %" PRIu32
" ", cnt);
1159 SCHSDestroyCtx(&mpm_ctx);
1160 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1165 static int SCHSTest03(
void)
1172 memset(&mpm_ctx, 0x00,
sizeof(
MpmCtx));
1184 SCHSPreparePatterns(&mpm_ctx);
1185 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1187 const char *buf =
"abcdefghjiklmnopqrstuvwxyz";
1188 uint32_t cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1194 printf(
"3 != %" PRIu32
" ", cnt);
1196 SCHSDestroyCtx(&mpm_ctx);
1197 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1202 static int SCHSTest04(
void)
1209 memset(&mpm_ctx, 0,
sizeof(
MpmCtx));
1218 SCHSPreparePatterns(&mpm_ctx);
1219 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1221 const char *buf =
"abcdefghjiklmnopqrstuvwxyz";
1222 uint32_t cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1228 printf(
"1 != %" PRIu32
" ", cnt);
1230 SCHSDestroyCtx(&mpm_ctx);
1231 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1236 static int SCHSTest05(
void)
1243 memset(&mpm_ctx, 0x00,
sizeof(
MpmCtx));
1252 SCHSPreparePatterns(&mpm_ctx);
1253 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1255 const char *buf =
"abcdefghjiklmnopqrstuvwxyz";
1256 uint32_t cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1262 printf(
"3 != %" PRIu32
" ", cnt);
1264 SCHSDestroyCtx(&mpm_ctx);
1265 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1270 static int SCHSTest06(
void)
1277 memset(&mpm_ctx, 0,
sizeof(
MpmCtx));
1284 SCHSPreparePatterns(&mpm_ctx);
1285 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1287 const char *buf =
"abcd";
1288 uint32_t cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1294 printf(
"1 != %" PRIu32
" ", cnt);
1296 SCHSDestroyCtx(&mpm_ctx);
1297 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1302 static int SCHSTest07(
void)
1309 memset(&mpm_ctx, 0,
sizeof(
MpmCtx));
1322 MpmAddPatternCS(&mpm_ctx, (uint8_t *)
"AAAAAAAAAA", 10, 0, 0, 4, 0, 0);
1324 MpmAddPatternCS(&mpm_ctx, (uint8_t *)
"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", 30,
1328 SCHSPreparePatterns(&mpm_ctx);
1329 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1331 const char *buf =
"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
1332 uint32_t cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1338 printf(
"6 != %" PRIu32
" ", cnt);
1340 SCHSDestroyCtx(&mpm_ctx);
1341 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1346 static int SCHSTest08(
void)
1353 memset(&mpm_ctx, 0,
sizeof(
MpmCtx));
1361 SCHSPreparePatterns(&mpm_ctx);
1362 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1365 SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)
"a", 1);
1370 printf(
"0 != %" PRIu32
" ", cnt);
1372 SCHSDestroyCtx(&mpm_ctx);
1373 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1378 static int SCHSTest09(
void)
1385 memset(&mpm_ctx, 0,
sizeof(
MpmCtx));
1393 SCHSPreparePatterns(&mpm_ctx);
1394 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1397 SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)
"ab", 2);
1402 printf(
"1 != %" PRIu32
" ", cnt);
1404 SCHSDestroyCtx(&mpm_ctx);
1405 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1410 static int SCHSTest10(
void)
1417 memset(&mpm_ctx, 0,
sizeof(
MpmCtx));
1425 SCHSPreparePatterns(&mpm_ctx);
1426 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1428 const char *buf =
"01234567890123456789012345678901234567890123456789"
1429 "01234567890123456789012345678901234567890123456789"
1431 "01234567890123456789012345678901234567890123456789"
1432 "01234567890123456789012345678901234567890123456789";
1433 uint32_t cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1439 printf(
"1 != %" PRIu32
" ", cnt);
1441 SCHSDestroyCtx(&mpm_ctx);
1442 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1447 static int SCHSTest11(
void)
1454 memset(&mpm_ctx, 0,
sizeof(
MpmCtx));
1458 if (
MpmAddPatternCS(&mpm_ctx, (uint8_t *)
"he", 2, 0, 0, 1, 0, 0) == -1)
1460 if (
MpmAddPatternCS(&mpm_ctx, (uint8_t *)
"she", 3, 0, 0, 2, 0, 0) == -1)
1462 if (
MpmAddPatternCS(&mpm_ctx, (uint8_t *)
"his", 3, 0, 0, 3, 0, 0) == -1)
1464 if (
MpmAddPatternCS(&mpm_ctx, (uint8_t *)
"hers", 4, 0, 0, 4, 0, 0) == -1)
1468 if (SCHSPreparePatterns(&mpm_ctx) == -1)
1471 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1475 const char *buf =
"he";
1476 result &= (SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1479 result &= (SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1482 result &= (SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1485 result &= (SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1489 SCHSDestroyCtx(&mpm_ctx);
1490 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1495 static int SCHSTest12(
void)
1502 memset(&mpm_ctx, 0x00,
sizeof(
MpmCtx));
1512 SCHSPreparePatterns(&mpm_ctx);
1513 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1515 const char *buf =
"abcdefghijklmnopqrstuvwxyz";
1516 uint32_t cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1522 printf(
"2 != %" PRIu32
" ", cnt);
1524 SCHSDestroyCtx(&mpm_ctx);
1525 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1530 static int SCHSTest13(
void)
1537 memset(&mpm_ctx, 0x00,
sizeof(
MpmCtx));
1542 const char pat[] =
"abcdefghijklmnopqrstuvwxyzABCD";
1543 MpmAddPatternCS(&mpm_ctx, (uint8_t *)pat,
sizeof(pat) - 1, 0, 0, 0, 0, 0);
1546 SCHSPreparePatterns(&mpm_ctx);
1547 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1549 const char *buf =
"abcdefghijklmnopqrstuvwxyzABCD";
1550 uint32_t cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1556 printf(
"1 != %" PRIu32
" ", cnt);
1558 SCHSDestroyCtx(&mpm_ctx);
1559 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1564 static int SCHSTest14(
void)
1571 memset(&mpm_ctx, 0x00,
sizeof(
MpmCtx));
1576 const char pat[] =
"abcdefghijklmnopqrstuvwxyzABCDE";
1577 MpmAddPatternCS(&mpm_ctx, (uint8_t *)pat,
sizeof(pat) - 1, 0, 0, 0, 0, 0);
1580 SCHSPreparePatterns(&mpm_ctx);
1581 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1583 const char *buf =
"abcdefghijklmnopqrstuvwxyzABCDE";
1584 uint32_t cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1590 printf(
"1 != %" PRIu32
" ", cnt);
1592 SCHSDestroyCtx(&mpm_ctx);
1593 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1598 static int SCHSTest15(
void)
1605 memset(&mpm_ctx, 0x00,
sizeof(
MpmCtx));
1610 const char pat[] =
"abcdefghijklmnopqrstuvwxyzABCDEF";
1611 MpmAddPatternCS(&mpm_ctx, (uint8_t *)pat,
sizeof(pat) - 1, 0, 0, 0, 0, 0);
1614 SCHSPreparePatterns(&mpm_ctx);
1615 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1617 const char *buf =
"abcdefghijklmnopqrstuvwxyzABCDEF";
1618 uint32_t cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1624 printf(
"1 != %" PRIu32
" ", cnt);
1626 SCHSDestroyCtx(&mpm_ctx);
1627 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1632 static int SCHSTest16(
void)
1639 memset(&mpm_ctx, 0x00,
sizeof(
MpmCtx));
1644 const char pat[] =
"abcdefghijklmnopqrstuvwxyzABC";
1645 MpmAddPatternCS(&mpm_ctx, (uint8_t *)pat,
sizeof(pat) - 1, 0, 0, 0, 0, 0);
1648 SCHSPreparePatterns(&mpm_ctx);
1649 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1651 const char *buf =
"abcdefghijklmnopqrstuvwxyzABC";
1652 uint32_t cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1658 printf(
"1 != %" PRIu32
" ", cnt);
1660 SCHSDestroyCtx(&mpm_ctx);
1661 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1666 static int SCHSTest17(
void)
1673 memset(&mpm_ctx, 0x00,
sizeof(
MpmCtx));
1678 const char pat[] =
"abcdefghijklmnopqrstuvwxyzAB";
1679 MpmAddPatternCS(&mpm_ctx, (uint8_t *)pat,
sizeof(pat) - 1, 0, 0, 0, 0, 0);
1682 SCHSPreparePatterns(&mpm_ctx);
1683 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1685 const char *buf =
"abcdefghijklmnopqrstuvwxyzAB";
1686 uint32_t cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1692 printf(
"1 != %" PRIu32
" ", cnt);
1694 SCHSDestroyCtx(&mpm_ctx);
1695 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1700 static int SCHSTest18(
void)
1707 memset(&mpm_ctx, 0x00,
sizeof(
MpmCtx));
1712 const char pat[] =
"abcde"
1718 MpmAddPatternCS(&mpm_ctx, (uint8_t *)pat,
sizeof(pat) - 1, 0, 0, 0, 0, 0);
1721 SCHSPreparePatterns(&mpm_ctx);
1722 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1724 const char *buf =
"abcde"
1730 uint32_t cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1736 printf(
"1 != %" PRIu32
" ", cnt);
1738 SCHSDestroyCtx(&mpm_ctx);
1739 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1744 static int SCHSTest19(
void)
1751 memset(&mpm_ctx, 0x00,
sizeof(
MpmCtx));
1756 const char pat[] =
"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
1757 MpmAddPatternCS(&mpm_ctx, (uint8_t *)pat,
sizeof(pat) - 1, 0, 0, 0, 0, 0);
1760 SCHSPreparePatterns(&mpm_ctx);
1761 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1763 const char *buf =
"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
1764 uint32_t cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1770 printf(
"1 != %" PRIu32
" ", cnt);
1772 SCHSDestroyCtx(&mpm_ctx);
1773 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1778 static int SCHSTest20(
void)
1785 memset(&mpm_ctx, 0x00,
sizeof(
MpmCtx));
1790 const char pat[] =
"AAAAA"
1797 MpmAddPatternCS(&mpm_ctx, (uint8_t *)pat,
sizeof(pat) - 1, 0, 0, 0, 0, 0);
1800 SCHSPreparePatterns(&mpm_ctx);
1801 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1803 const char *buf =
"AAAAA"
1810 uint32_t cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1816 printf(
"1 != %" PRIu32
" ", cnt);
1818 SCHSDestroyCtx(&mpm_ctx);
1819 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1824 static int SCHSTest21(
void)
1831 memset(&mpm_ctx, 0x00,
sizeof(
MpmCtx));
1839 SCHSPreparePatterns(&mpm_ctx);
1840 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1843 SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)
"AA", 2);
1848 printf(
"1 != %" PRIu32
" ", cnt);
1850 SCHSDestroyCtx(&mpm_ctx);
1851 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1856 static int SCHSTest22(
void)
1863 memset(&mpm_ctx, 0x00,
sizeof(
MpmCtx));
1873 SCHSPreparePatterns(&mpm_ctx);
1874 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1876 const char *buf =
"abcdefghijklmnopqrstuvwxyz";
1877 uint32_t cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1883 printf(
"2 != %" PRIu32
" ", cnt);
1885 SCHSDestroyCtx(&mpm_ctx);
1886 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1891 static int SCHSTest23(
void)
1898 memset(&mpm_ctx, 0x00,
sizeof(
MpmCtx));
1906 SCHSPreparePatterns(&mpm_ctx);
1907 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1910 SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)
"aa", 2);
1915 printf(
"1 != %" PRIu32
" ", cnt);
1917 SCHSDestroyCtx(&mpm_ctx);
1918 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1923 static int SCHSTest24(
void)
1930 memset(&mpm_ctx, 0x00,
sizeof(
MpmCtx));
1938 SCHSPreparePatterns(&mpm_ctx);
1939 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1942 SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)
"aa", 2);
1947 printf(
"1 != %" PRIu32
" ", cnt);
1949 SCHSDestroyCtx(&mpm_ctx);
1950 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1955 static int SCHSTest25(
void)
1962 memset(&mpm_ctx, 0x00,
sizeof(
MpmCtx));
1971 SCHSPreparePatterns(&mpm_ctx);
1972 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1974 const char *buf =
"ABCDEFGHIJKLMNOPQRSTUVWXYZ";
1975 uint32_t cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
1981 printf(
"3 != %" PRIu32
" ", cnt);
1983 SCHSDestroyCtx(&mpm_ctx);
1984 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
1989 static int SCHSTest26(
void)
1996 memset(&mpm_ctx, 0x00,
sizeof(
MpmCtx));
2004 SCHSPreparePatterns(&mpm_ctx);
2005 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
2007 const char *buf =
"works";
2008 uint32_t cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
2014 printf(
"3 != %" PRIu32
" ", cnt);
2016 SCHSDestroyCtx(&mpm_ctx);
2017 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
2022 static int SCHSTest27(
void)
2029 memset(&mpm_ctx, 0,
sizeof(
MpmCtx));
2037 SCHSPreparePatterns(&mpm_ctx);
2038 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
2040 const char *buf =
"tone";
2041 uint32_t cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
2047 printf(
"0 != %" PRIu32
" ", cnt);
2049 SCHSDestroyCtx(&mpm_ctx);
2050 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
2055 static int SCHSTest28(
void)
2062 memset(&mpm_ctx, 0,
sizeof(
MpmCtx));
2070 SCHSPreparePatterns(&mpm_ctx);
2071 SCHSInitThreadCtx(&mpm_ctx, &mpm_thread_ctx);
2073 const char *buf =
"tONE";
2074 uint32_t cnt = SCHSSearch(&mpm_ctx, &mpm_thread_ctx, &pmq, (uint8_t *)buf,
2080 printf(
"0 != %" PRIu32
" ", cnt);
2082 SCHSDestroyCtx(&mpm_ctx);
2083 SCHSDestroyThreadCtx(&mpm_ctx, &mpm_thread_ctx);
2088 static int SCHSTest29(
void)
2090 uint8_t buf[] =
"onetwothreefourfivesixseveneightnine";
2091 uint16_t buflen =
sizeof(buf) - 1;
2097 memset(&th_v, 0,
sizeof(th_v));
2108 de_ctx,
"alert tcp any any -> any any "
2109 "(content:\"onetwothreefourfivesixseveneightnine\"; sid:1;)");
2114 "(content:\"onetwothreefourfivesixseveneightnine\"; "
2115 "fast_pattern:3,3; sid:2;)");
2124 printf(
"if (PacketAlertCheck(p, 1) != 1) failure\n");
2128 printf(
"if (PacketAlertCheck(p, 1) != 2) failure\n");
2148 void SCHSRegisterTests(
void)