static void test6() { mpm_re *re; int i; char * subjects1[] = { "maab", "aabb", "aa", "a", NULL }; char * subjects2[] = { "maab", "aabb", "aa", "a", "m\naa", "\r\naa", "a\ra", "\raa\n", NULL }; char * subjects3[] = { "m\xab", "\n\xab", "\xab\n", NULL }; printf("Test6: Testing multiline and ^ assertion.\n\n"); test_single_match("^aa", MPM_ADD_VERBOSE, MPM_COMPILE_VERBOSE | MPM_COMPILE_VERBOSE_STATS, subjects1); test_single_match("^aa", MPM_ADD_MULTILINE | MPM_ADD_VERBOSE, MPM_COMPILE_VERBOSE | MPM_COMPILE_VERBOSE_STATS, subjects2); test_single_match("^\\xab", MPM_ADD_MULTILINE | MPM_ADD_VERBOSE, MPM_COMPILE_VERBOSE | MPM_COMPILE_VERBOSE_STATS, subjects3); test_single_match("^[^\\xab]", MPM_ADD_MULTILINE | MPM_ADD_VERBOSE, MPM_COMPILE_VERBOSE | MPM_COMPILE_VERBOSE_STATS, subjects3); re = test_mpm_create(); if (!re) return; test_mpm_add_fail(re, "^(?:a|a*)", MPM_ADD_VERBOSE, MPM_EMPTY_PATTERN); test_mpm_add_fail(re, "^(?:a|a*)", MPM_ADD_MULTILINE | MPM_ADD_VERBOSE, MPM_EMPTY_PATTERN); test_mpm_add_fail(re, "^a|a", MPM_ADD_VERBOSE, MPM_UNSUPPORTED_PATTERN); for (i = 0; i < 32; i++) test_mpm_add(re, "A", 0); test_mpm_add_fail(re, "B", 0, MPM_PATTERN_LIMIT); mpm_free(re); }
static void test2() { mpm_re *re; printf("Test2: Testing iterators.\n\n"); re = test_mpm_create(); if (!re) return; test_mpm_add(re, "#a+?#b*#c??#d{3,6}#e{0,3}?#f{2,}#", MPM_ADD_VERBOSE); test_mpm_add(re, "#a+#b*?#c?#d{3,6}?#e{0,3}#f{2,}?#", MPM_ADD_CASELESS | MPM_ADD_VERBOSE); test_mpm_add(re, "#[^a]+?#[^b]*#[^c]??#[^d]{3,6}#[^e]{0,3}?#[^f]{2,}#", MPM_ADD_VERBOSE); test_mpm_add(re, "#[^a]+#[^b]*?#[^c]?#[^d]{3,6}?#[^e]{0,3}#[^f]{2,}?#", MPM_ADD_CASELESS | MPM_ADD_VERBOSE); test_mpm_add(re, "#\\s+?#\\w*#\\d??#\\h{3,6}#\\w{0,3}?#.{2,}#", MPM_ADD_CASELESS | MPM_ADD_VERBOSE); test_mpm_add(re, "#\\S+?#\\W*#\\D??#\\H{6,9}#\\W{0,7}?#.{6,}#", MPM_ADD_DOTALL | MPM_ADD_VERBOSE); test_mpm_add(re, "#[a-z]+?#[a-z]*#[a-z]??#[a-z]{3,6}#[a-z]{0,3}?#[a-z]{2,}#", MPM_ADD_VERBOSE); test_mpm_add(re, "aa|bb(cc(?:dd|ee)|ff)", MPM_ADD_VERBOSE); test_mpm_add(re, "a.+b*?", MPM_ADD_VERBOSE | MPM_ADD_FIXED(6)); test_mpm_add(re, "x[Bm]*Y?", MPM_ADD_VERBOSE | MPM_ADD_CASELESS | MPM_ADD_FIXED(6)); test_mpm_add_fail(re, "(ab|cd(mn|op)+|ef(gh)?)*", MPM_ADD_VERBOSE, MPM_EMPTY_PATTERN); test_mpm_add_fail(re, "a?b?", MPM_ADD_VERBOSE, MPM_EMPTY_PATTERN); test_mpm_add_fail(re, "a|b?", MPM_ADD_VERBOSE, MPM_EMPTY_PATTERN); test_mpm_add_fail(re, "", MPM_ADD_VERBOSE, MPM_EMPTY_PATTERN); test_mpm_add_fail(re, "(.)\\1", MPM_ADD_VERBOSE, MPM_UNSUPPORTED_PATTERN); test_mpm_add_fail(re, "(?", MPM_ADD_VERBOSE, MPM_INVALID_PATTERN); mpm_free(re); }
static void test7() { mpm_re *re; printf("Test7: Testing offsets.\n\n"); re = test_mpm_create(); if (!re) return; printf("\nTest1:\n"); test_mpm_add(re, "^a", MPM_ADD_MULTILINE); test_mpm_add(re, "^a", 0); test_mpm_add(re, "\\na", 0); test_mpm_compile(re, NULL, 0); test_mpm_exec(re, "a\na", 0); test_mpm_exec(re, "a\na", 2); test_mpm_exec(re, "a\na\na", 2); mpm_free(re); re = test_mpm_create(); if (!re) return; printf("\nTest2:\n"); test_mpm_add(re, "^a", 0); test_mpm_add(re, "\\na", 0); test_mpm_compile(re, NULL, 0); test_mpm_exec(re, "a\na", 0); test_mpm_exec(re, "a\na\n", 2); test_mpm_exec(re, "a\na\na", 2); mpm_free(re); re = test_mpm_create(); if (!re) return; printf("\nTest3:\n"); test_mpm_add(re, "^a", MPM_ADD_MULTILINE); test_mpm_add(re, "\\na", 0); test_mpm_compile(re, NULL, 0); test_mpm_exec(re, "a\na", 0); test_mpm_exec(re, "a\na\nb", 2); test_mpm_exec(re, "a\na\na", 2); mpm_free(re); }
static void test_multiple_match(mpm_re *re, int compile_flags, char **subject) { test_mpm_compile(re, NULL, compile_flags); while (subject[0]) { test_mpm_exec(re, subject[0], 0); subject++; } puts(""); mpm_free(re); }
void decodeSigHandler(int sig) { if (sig == SIGCHLD) { int status; if (mpm_get_id(MPM_DECODE) && mpm_get_id(MPM_DECODE) == wait3(&status, WNOHANG, NULL)) { if (WIFSIGNALED(status) && WTERMSIG(status) != SIGTERM && WTERMSIG(status) != SIGINT) { ERROR("decode process died from signal: %i\n", WTERMSIG(status)); } mpm_set_id(MPM_DECODE,0); mpm_free(MPM_DECODE); } } else if (sig == SIGTERM) { if (mpm_get_id(MPM_DECODE) > 0) kill(mpm_get_id(MPM_DECODE), SIGTERM); mpm_free(MPM_DECODE); exit(EXIT_SUCCESS); } }
static void test3() { mpm_re *re; printf("Test3: A large set.\n\n"); re = test_mpm_create(); if (!re) return; test_mpm_add(re, "\\x3Cobject[^\\x3E]+?data\\s*\\x3D\\s*\\x22\\x22", MPM_ADD_VERBOSE); test_mpm_add(re, "^[^\\s]{256}", MPM_ADD_VERBOSE); test_mpm_compile(re, NULL, MPM_COMPILE_VERBOSE | MPM_COMPILE_VERBOSE_STATS); mpm_free(re); }
static void test1() { mpm_re *re; printf("Test1: Testing character classes.\n\n"); re = test_mpm_create(); if (!re) return; test_mpm_add(re, "aB#.\\x00\\x01\\xff\\xfe", MPM_ADD_VERBOSE); test_mpm_add(re, ".[^c][^\\x00][^\\x01][^\\xfe][^\\xff]", MPM_ADD_DOTALL | MPM_ADD_VERBOSE); test_mpm_add(re, "aB[^c][^D]#[^#]", MPM_ADD_CASELESS | MPM_ADD_VERBOSE); test_mpm_add(re, " [a-z] [\\x00-\\x05y-\\xff] (?i)[c-fMX] ", MPM_ADD_EXTENDED | MPM_ADD_VERBOSE); test_mpm_add(re, " [\\x01\\x02def\\xfd\\xfe] (?i)[cd\\s] [\\vedcb \\d] ", MPM_ADD_EXTENDED | MPM_ADD_VERBOSE); test_mpm_add(re, "\\d\\D\\w\\W\\s\\S\\h\\H\\v\\V", MPM_ADD_CASELESS | MPM_ADD_VERBOSE); mpm_free(re); }
static void new_feature(void) { #if 0 mpm_re *re; re = test_mpm_create(); if (!re) return; test_mpm_add(re, "aa.b*", MPM_ADD_VERBOSE); test_mpm_add(re, "ma?", MPM_ADD_VERBOSE); test_mpm_add(re, "aa", MPM_ADD_VERBOSE | MPM_ADD_FIXED(2)); printf("Distance: %d\n", mpm_distance(re, 0, re, 1)); test_mpm_compile(re, NULL, MPM_COMPILE_VERBOSE | MPM_COMPILE_VERBOSE_STATS); test_mpm_exec(re, "mmaa bb", 0); test_mpm_exec(re, "aa", 0); test_mpm_exec(re, "aax", 0); mpm_free(re); #elif 0 mpm_re *re; int i; load_pattern_list("../../patterns3.txt"); if (!loaded_items) return; mpm_clustering(loaded_items, loaded_items_size, MPM_CLUSTERING_VERBOSE); printf("Group 0:\n %s\n", (char *)loaded_items[0].data); re = loaded_items[0].re; for (i = 1; i < loaded_items_size; i++) { if (loaded_items[i].group_id != loaded_items[i - 1].group_id) { if (mpm_compile(re, NULL, MPM_COMPILE_VERBOSE_STATS) != MPM_NO_ERROR) printf("WARNING: mpm_compile failed\n"); printf("\nGroup: %d\n", loaded_items[i].group_id); re = loaded_items[i].re; } else { if (mpm_combine(&re, loaded_items[i].re, 0) != MPM_NO_ERROR) printf("WARNING: mpm_combine failed\n"); } printf(" %s\n", (char *)loaded_items[i].data); } mpm_compile(re, NULL, MPM_COMPILE_VERBOSE_STATS); #elif 1 mpm_rule_list *rule_list; mpm_uint32 result[2] = { 0, 0 }; int error_code; mpm_compile_rules_args args = { 2, /* no_selected_patterns */ 0, /* minimum_no_new_cover */ -1.0, /* rule_strength_scale */ -1.0, /* inner_distance_scale */ -1.0, /* outer_distance_scale */ -1.0 /* length_scale */ }; mpm_rule_pattern rules[] = { { (mpm_char8 *)"ab{4,17}c*d+xyz|h", MPM_RULE_NEW }, { (mpm_char8 *)"ab{4,17}c*d+xyz", MPM_RULE_NEW }, { (mpm_char8 *)"(cccc|dddd){4,8}b{4,17}c*d+xyze{4,}", MPM_RULE_NEW }, { (mpm_char8 *)"(ccc)*(ddd)+(eee)?xyz", MPM_RULE_NEW }, #if 0 { (mpm_char8 *)"(eee)?x?y?z?abc", MPM_RULE_NEW }, { (mpm_char8 *)"(eee)?x?y?z?def", MPM_RULE_NEW }, { (mpm_char8 *)"(eee)?x?y?z?ghi", MPM_RULE_NEW }, #endif }; char *subject = "bbbbdxyz h"; error_code = mpm_compile_rules(rules, sizeof(rules) / sizeof(mpm_rule_pattern), &rule_list, NULL, &args, MPM_COMPILE_RULES_VERBOSE | MPM_COMPILE_RULES_VERBOSE_STATS); printf("mpm_compile_rules: %s\n", mpm_error_to_string(error_code)); if (rule_list) { mpm_exec_list(rule_list, (mpm_char8 *)subject, strlen(subject), 0, result); mpm_rule_list_free(rule_list); } printf("\nResult: 0x%x 0x%x\n", result[0], result[1]); #elif 0 #include "../../uri/patterns.txt" mpm_rule_list *rule_list; mpm_size consumed_memory; mpm_compile_rules_args args = { 20, /* no_selected_patterns */ 4, /* minimum_no_new_cover */ 0.2, /* rule_strength_scale */ 0.15, /* inner_distance_scale */ 0.3, /* outer_distance_scale */ 0.2 /* length_scale */ }; printf("Processing %d rules:\n", (int)(sizeof(rules_global) / sizeof(mpm_rule_pattern))); mpm_compile_rules(rules_global, sizeof(rules_global) / sizeof(mpm_rule_pattern), &rule_list, &consumed_memory, &args, 0 | MPM_COMPILE_RULES_VERBOSE | MPM_COMPILE_RULES_VERBOSE_STATS | MPM_COMPILE_RULES_IGNORE_FIXED); if (!rule_list) return; printf("MPM State machine size: %ld\n", (long)consumed_memory); mpm_rule_list_free(rule_list); #else /* Ignore this case. */ printf("No test selected!\n\n"); #endif }
static void load_pattern_list(char* file_name) { FILE *f = fopen(file_name, "rt"); char data[MAX_LINE_LENGTH]; int line, count, skipped_count, unsupported_count, flags, len; compiled_pattern *first_pattern, *last_pattern; compiled_pattern *current_pattern; mpm_re *current_re; mpm_cluster_item *loaded_item_ptr; char *ptr; if (!f) { printf("Cannot open file: %s\n", file_name); return; } line = 1; count = 0; skipped_count = 0; unsupported_count = 0; first_pattern = NULL; last_pattern = NULL; while (1) { if (!fgets(data, MAX_LINE_LENGTH, f)) break; current_re = mpm_create(); if (!current_re) { printf("WARNING: mpm_create is failed: %s\n", mpm_error_to_string(MPM_NO_MEMORY)); return; } if (memcmp(data, "regex \"/", 8) == 0 || memcmp(data, "regex !\"/", 9) == 0) { flags = process_regex(data); /* An error happened. */ if (flags == -1) continue; ptr = data + ((data[6] == '!') ? 9 : 8); flags = mpm_add(current_re, (mpm_char8*)ptr, flags | MPM_ADD_TEST_RATING); if (flags != MPM_NO_ERROR) { printf("Warning: mpm_add returned with '%s' in line:%d '%s'\n", mpm_error_to_string(flags), line, ptr); ptr = NULL; } len = strlen(data); data[len] = '/'; len += strlen(data + len); if (data[len - 1] == '\n') data[len - 1] = '\0'; } else if (memcmp(data, "pattern ", 8) == 0) { ptr = process_fixed_string(data); flags = mpm_add(current_re, (mpm_char8*)(data + 8), MPM_ADD_FIXED(ptr - (data + 8)) | MPM_ADD_TEST_RATING); if (flags != MPM_NO_ERROR) { printf("Warning: mpm_add returned with '%s' in line:%d '%s'\n", mpm_error_to_string(flags), line, data + 8); ptr = NULL; } else ptr = data + 8; } else { flags = MPM_NO_ERROR; ptr = NULL; printf("Warning: Unknown type: line:%d %s\n", line, data); } if (flags == MPM_TOO_LOW_RATING) skipped_count++; else if (flags != MPM_NO_ERROR) unsupported_count++; line++; if (!ptr) { mpm_free(current_re); continue; } ptr = data; current_pattern = (compiled_pattern *)malloc(sizeof(compiled_pattern)); if (!current_pattern) { printf("WARNING: out of memory\n"); return; } len = strlen(ptr); current_pattern->pattern = (char *)malloc(len + 1); if (!current_pattern->pattern) { printf("WARNING: out of memory\n"); return; } memcpy(current_pattern->pattern, ptr, len + 1); current_pattern->next = NULL; current_pattern->re = current_re; if (!first_pattern) first_pattern = current_pattern; else last_pattern->next = current_pattern; last_pattern = current_pattern; count++; } fclose(f); if (!count) return; loaded_items = (mpm_cluster_item *)malloc(count * sizeof(mpm_cluster_item)); if (!loaded_items) { printf("WARNING: out of memory\n"); return; } loaded_items_size = count; /* Copy the data. */ loaded_item_ptr = loaded_items; while (first_pattern) { loaded_item_ptr->re = first_pattern->re; loaded_item_ptr->data = first_pattern->pattern; loaded_item_ptr++; last_pattern = first_pattern->next; free(first_pattern); first_pattern = last_pattern; } line = count + skipped_count + unsupported_count; printf("%d patterns are processed\n %d (%d%%) successfully loaded\n" " %d (%d%%) ignored because of low rating\n %d (%d%%) ignored because they are unsupported\n\n", line, count, count * 100 / line, skipped_count, skipped_count * 100 / line, unsupported_count, unsupported_count * 100 / line); }