int cli_pcre_compile(struct cli_pcre_data *pd, long long unsigned match_limit, long long unsigned match_limit_recursion, unsigned int options, int opt_override)
{
int errornum, erroffset;
pcre2_general_context *gctx;
pcre2_compile_context *cctx;
if (!pd || !pd->expression) {
cli_errmsg("cli_pcre_compile: NULL pd or NULL pd->expression\n");
return CL_ENULLARG;
}
gctx = pcre2_general_context_create(cli_pcre_malloc, cli_pcre_free, NULL);
if (!gctx) {
cli_errmsg("cli_pcre_compile: Unable to allocate memory for general context\n");
return CL_EMEM;
}
cctx = pcre2_compile_context_create(gctx);
if (!cctx) {
cli_errmsg("cli_pcre_compile: Unable to allocate memory for compile context\n");
pcre2_general_context_free(gctx);
return CL_EMEM;
}
/* compile the pcre2 regex last arg is charset, allow for options override */
if (opt_override)
pd->re = pcre2_compile(pd->expression, PCRE2_ZERO_TERMINATED, options, &errornum, &erroffset, cctx); /* pd->re handled by pcre2 -> call pcre_free() -> calls free() */
else
pd->re = pcre2_compile(pd->expression, PCRE2_ZERO_TERMINATED, pd->options, &errornum, &erroffset, cctx); /* pd->re handled by pcre2 -> call pcre_free() -> calls free() */
if (pd->re == NULL) {
PCRE2_UCHAR errmsg[256];
pcre2_get_error_message(errornum, errmsg, sizeof(errmsg));
cli_errmsg("cli_pcre_compile: PCRE2 compilation failed at offset %d: %s\n", erroffset, errmsg);
pcre2_compile_context_free(cctx);
pcre2_general_context_free(gctx);
return CL_EMALFDB;
}
/* setup matching context and set the match limits */
pd->mctx = pcre2_match_context_create(gctx);
if (!pd->mctx) {
cli_errmsg("cli_pcre_compile: Unable to allocate memory for match context\n");
pcre2_compile_context_free(cctx);
pcre2_general_context_free(gctx);
return CL_EMEM;
}
pcre2_set_match_limit(pd->mctx, match_limit);
pcre2_set_recursion_limit(pd->mctx, match_limit_recursion);
/* non-dynamic allocated fields set by caller */
pcre2_compile_context_free(cctx);
pcre2_general_context_free(gctx);
return CL_SUCCESS;
}
static void compile_pcre2_pattern(struct grep_pat *p, const struct grep_opt *opt)
{
int error;
PCRE2_UCHAR errbuf[256];
PCRE2_SIZE erroffset;
int options = PCRE2_MULTILINE;
const uint8_t *character_tables = NULL;
int jitret;
assert(opt->pcre2);
p->pcre2_compile_context = NULL;
if (opt->ignore_case) {
if (has_non_ascii(p->pattern)) {
character_tables = pcre2_maketables(NULL);
p->pcre2_compile_context = pcre2_compile_context_create(NULL);
pcre2_set_character_tables(p->pcre2_compile_context, character_tables);
}
options |= PCRE2_CASELESS;
}
if (is_utf8_locale() && has_non_ascii(p->pattern))
options |= PCRE2_UTF;
p->pcre2_pattern = pcre2_compile((PCRE2_SPTR)p->pattern,
p->patternlen, options, &error, &erroffset,
p->pcre2_compile_context);
if (p->pcre2_pattern) {
p->pcre2_match_data = pcre2_match_data_create_from_pattern(p->pcre2_pattern, NULL);
if (!p->pcre2_match_data)
die("Couldn't allocate PCRE2 match data");
} else {
pcre2_get_error_message(error, errbuf, sizeof(errbuf));
compile_regexp_failed(p, (const char *)&errbuf);
}
pcre2_config(PCRE2_CONFIG_JIT, &p->pcre2_jit_on);
if (p->pcre2_jit_on == 1) {
jitret = pcre2_jit_compile(p->pcre2_pattern, PCRE2_JIT_COMPLETE);
if (jitret)
die("Couldn't JIT the PCRE2 pattern '%s', got '%d'\n", p->pattern, jitret);
p->pcre2_jit_stack = pcre2_jit_stack_create(1, 1024 * 1024, NULL);
if (!p->pcre2_jit_stack)
die("Couldn't allocate PCRE2 JIT stack");
p->pcre2_match_context = pcre2_match_context_create(NULL);
if (!p->pcre2_match_context)
die("Couldn't allocate PCRE2 match context");
pcre2_jit_stack_assign(p->pcre2_match_context, NULL, p->pcre2_jit_stack);
} else if (p->pcre2_jit_on != 0) {
die("BUG: The pcre2_jit_on variable should be 0 or 1, not %d",
p->pcre1_jit_on);
}
}
int main (int argc, char ** argv)
{
int errornumber = 0;
size_t erroroffset = 0;
const auto * pattern = reinterpret_cast<const unsigned char *>(PATTERN);
pcre2_code * re = pcre2_compile(pattern, PCRE2_ZERO_TERMINATED, 0, &errornumber, &erroroffset, NULL);
if (!re) {
std::cerr << "compilation failed\n";
return 1;
}
pcre2_match_context * mcontext = pcre2_match_context_create(NULL);
auto match_data = pcre2_match_data_create_from_pattern(re, NULL);
benchmark(argc, argv, [&] (std::string_view line) {
return pcre2_match(re, reinterpret_cast<const unsigned char *>(line.data()), line.length(), 0, 0, match_data, mcontext) >= 0;
});
pcre2_code_free(re);
}
int LLVMFuzzerTestOneInput(const unsigned char *data, size_t size)
{
uint32_t compile_options;
uint32_t match_options;
pcre2_match_data *match_data = NULL;
pcre2_match_context *match_context = NULL;
size_t match_size;
int dfa_workspace[DFA_WORKSPACE_COUNT];
int r1, r2;
int i;
if (size < 1) return 0;
/* Limiting the length of the subject for matching stops fruitless searches
in large trees taking too much time. */
match_size = (size > MAX_MATCH_SIZE)? MAX_MATCH_SIZE : size;
/* Figure out some options to use. Initialize the random number to ensure
repeatability. Ensure that we get a 32-bit unsigned random number for testing
options. (RAND_MAX is required to be at least 32767, but is commonly
2147483647, which excludes the top bit.) */
srand((unsigned int)(data[size/2]));
r1 = rand();
r2 = rand();
/* Ensure that all undefined option bits are zero (waste of time trying them)
and also that PCRE2_NO_UTF_CHECK is unset, as there is no guarantee that the
input is UTF-8. Also unset PCRE2_NEVER_UTF and PCRE2_NEVER_UCP as there is no
reason to disallow UTF and UCP. Force PCRE2_NEVER_BACKSLASH_C to be set because
\C in random patterns is highly likely to cause a crash. */
compile_options =
((((uint32_t)r1 << 16) | ((uint32_t)r2 & 0xffff)) & ALLOWED_COMPILE_OPTIONS) |
PCRE2_NEVER_BACKSLASH_C;
match_options =
((((uint32_t)r1 << 16) | ((uint32_t)r2 & 0xffff)) & ALLOWED_MATCH_OPTIONS);
/* Discard partial matching if PCRE2_ENDANCHORED is set, because they are not
allowed together and just give an immediate error return. */
if (((compile_options|match_options) & PCRE2_ENDANCHORED) != 0)
match_options &= ~(PCRE2_PARTIAL_HARD|PCRE2_PARTIAL_SOFT);
/* Do the compile with and without the options, and after a successful compile,
likewise do the match with and without the options. */
for (i = 0; i < 2; i++)
{
uint32_t callout_count;
int errorcode;
PCRE2_SIZE erroroffset;
pcre2_code *code;
#ifdef STANDALONE
printf("Compile options %.8x never_backslash_c", compile_options);
printf("%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s\n",
((compile_options & PCRE2_ALT_BSUX) != 0)? ",alt_bsux" : "",
((compile_options & PCRE2_ALT_CIRCUMFLEX) != 0)? ",alt_circumflex" : "",
((compile_options & PCRE2_ALT_VERBNAMES) != 0)? ",alt_verbnames" : "",
((compile_options & PCRE2_ALLOW_EMPTY_CLASS) != 0)? ",allow_empty_class" : "",
((compile_options & PCRE2_ANCHORED) != 0)? ",anchored" : "",
((compile_options & PCRE2_AUTO_CALLOUT) != 0)? ",auto_callout" : "",
((compile_options & PCRE2_CASELESS) != 0)? ",caseless" : "",
((compile_options & PCRE2_DOLLAR_ENDONLY) != 0)? ",dollar_endonly" : "",
((compile_options & PCRE2_DOTALL) != 0)? ",dotall" : "",
((compile_options & PCRE2_DUPNAMES) != 0)? ",dupnames" : "",
((compile_options & PCRE2_ENDANCHORED) != 0)? ",endanchored" : "",
((compile_options & PCRE2_EXTENDED) != 0)? ",extended" : "",
((compile_options & PCRE2_FIRSTLINE) != 0)? ",firstline" : "",
((compile_options & PCRE2_MATCH_UNSET_BACKREF) != 0)? ",match_unset_backref" : "",
((compile_options & PCRE2_MULTILINE) != 0)? ",multiline" : "",
((compile_options & PCRE2_NEVER_UCP) != 0)? ",never_ucp" : "",
((compile_options & PCRE2_NEVER_UTF) != 0)? ",never_utf" : "",
((compile_options & PCRE2_NO_AUTO_CAPTURE) != 0)? ",no_auto_capture" : "",
((compile_options & PCRE2_NO_AUTO_POSSESS) != 0)? ",no_auto_possess" : "",
((compile_options & PCRE2_NO_DOTSTAR_ANCHOR) != 0)? ",no_dotstar_anchor" : "",
((compile_options & PCRE2_NO_UTF_CHECK) != 0)? ",no_utf_check" : "",
((compile_options & PCRE2_NO_START_OPTIMIZE) != 0)? ",no_start_optimize" : "",
((compile_options & PCRE2_UCP) != 0)? ",ucp" : "",
((compile_options & PCRE2_UNGREEDY) != 0)? ",ungreedy" : "",
((compile_options & PCRE2_USE_OFFSET_LIMIT) != 0)? ",use_offset_limit" : "",
((compile_options & PCRE2_UTF) != 0)? ",utf" : "");
#endif
code = pcre2_compile((PCRE2_SPTR)data, (PCRE2_SIZE)size, compile_options,
&errorcode, &erroroffset, NULL);
/* Compilation succeeded */
if (code != NULL)
{
int j;
uint32_t save_match_options = match_options;
/* Create match data and context blocks only when we first need them. Set
low match and depth limits to avoid wasting too much searching large
pattern trees. Almost all matches are going to fail. */
if (match_data == NULL)
{
match_data = pcre2_match_data_create(32, NULL);
if (match_data == NULL)
{
#ifdef STANDALONE
printf("** Failed to create match data block\n");
#endif
return 0;
}
}
if (match_context == NULL)
{
match_context = pcre2_match_context_create(NULL);
if (match_context == NULL)
{
#ifdef STANDALONE
printf("** Failed to create match context block\n");
#endif
return 0;
}
(void)pcre2_set_match_limit(match_context, 100);
(void)pcre2_set_depth_limit(match_context, 100);
(void)pcre2_set_callout(match_context, callout_function, &callout_count);
}
/* Match twice, with and without options. */
for (j = 0; j < 2; j++)
{
#ifdef STANDALONE
printf("Match options %.8x", match_options);
printf("%s%s%s%s%s%s%s%s%s%s\n",
((match_options & PCRE2_ANCHORED) != 0)? ",anchored" : "",
((match_options & PCRE2_ENDANCHORED) != 0)? ",endanchored" : "",
((match_options & PCRE2_NO_JIT) != 0)? ",no_jit" : "",
((match_options & PCRE2_NO_UTF_CHECK) != 0)? ",no_utf_check" : "",
((match_options & PCRE2_NOTBOL) != 0)? ",notbol" : "",
((match_options & PCRE2_NOTEMPTY) != 0)? ",notempty" : "",
((match_options & PCRE2_NOTEMPTY_ATSTART) != 0)? ",notempty_atstart" : "",
((match_options & PCRE2_NOTEOL) != 0)? ",noteol" : "",
((match_options & PCRE2_PARTIAL_HARD) != 0)? ",partial_hard" : "",
((match_options & PCRE2_PARTIAL_SOFT) != 0)? ",partial_soft" : "");
#endif
callout_count = 0;
errorcode = pcre2_match(code, (PCRE2_SPTR)data, (PCRE2_SIZE)match_size, 0,
match_options, match_data, match_context);
#ifdef STANDALONE
if (errorcode >= 0) printf("Match returned %d\n", errorcode); else
{
unsigned char buffer[256];
pcre2_get_error_message(errorcode, buffer, 256);
printf("Match failed: error %d: %s\n", errorcode, buffer);
}
#endif
match_options = 0; /* For second time */
}
/* Match with DFA twice, with and without options. */
match_options = save_match_options & ~PCRE2_NO_JIT; /* Not valid for DFA */
for (j = 0; j < 2; j++)
{
#ifdef STANDALONE
printf("DFA match options %.8x", match_options);
printf("%s%s%s%s%s%s%s%s%s\n",
((match_options & PCRE2_ANCHORED) != 0)? ",anchored" : "",
((match_options & PCRE2_ENDANCHORED) != 0)? ",endanchored" : "",
((match_options & PCRE2_NO_UTF_CHECK) != 0)? ",no_utf_check" : "",
((match_options & PCRE2_NOTBOL) != 0)? ",notbol" : "",
((match_options & PCRE2_NOTEMPTY) != 0)? ",notempty" : "",
((match_options & PCRE2_NOTEMPTY_ATSTART) != 0)? ",notempty_atstart" : "",
((match_options & PCRE2_NOTEOL) != 0)? ",noteol" : "",
((match_options & PCRE2_PARTIAL_HARD) != 0)? ",partial_hard" : "",
((match_options & PCRE2_PARTIAL_SOFT) != 0)? ",partial_soft" : "");
#endif
callout_count = 0;
errorcode = pcre2_dfa_match(code, (PCRE2_SPTR)data,
(PCRE2_SIZE)match_size, 0, match_options, match_data, match_context,
dfa_workspace, DFA_WORKSPACE_COUNT);
#ifdef STANDALONE
if (errorcode >= 0) printf("Match returned %d\n", errorcode); else
{
unsigned char buffer[256];
pcre2_get_error_message(errorcode, buffer, 256);
printf("Match failed: error %d: %s\n", errorcode, buffer);
}
#endif
match_options = 0; /* For second time */
}
match_options = save_match_options; /* Reset for the second compile */
pcre2_code_free(code);
}
/* Compilation failed */
else
{
unsigned char buffer[256];
pcre2_get_error_message(errorcode, buffer, 256);
#ifdef STANDALONE
printf("Error %d at offset %lu: %s\n", errorcode, erroroffset, buffer);
#else
if (strstr((const char *)buffer, "internal error") != NULL) abort();
#endif
}
compile_options = PCRE2_NEVER_BACKSLASH_C; /* For second time */
}
if (match_data != NULL) pcre2_match_data_free(match_data);
if (match_context != NULL) pcre2_match_context_free(match_context);
return 0;
}
int32 ftw_pcre_match(const pcre2_code *compiled_regex, ConstLStrH subject,
int32 startoffset, int32 *match_begin, int32 *match_end,
int32Array **submatches, CalloutAccumulator **callout)
{
struct ftw_callout_args arg;
pcre2_match_context *ctx;
pcre2_match_data *match_data;
PCRE2_SIZE subj_len;
PCRE2_SPTR subj_ptr;
PCRE2_SIZE *ovector;
uint32_t ovec_count;
int num_submatches;
MgErr lv_err;
int32 rc;
int i;
ctx = pcre2_match_context_create(NULL);
if (ctx == NULL)
return PCRE2_ERROR_INTERNAL;
/* Adjust these numbers to change characteristics of memory management. */
arg.grow_size = 100;
arg.accumulator = callout;
arg.index = 0;
rc = pcre2_set_callout(ctx, ftw_pcre_callout, &arg);
if (rc) {
pcre2_match_context_free(ctx);
return rc;
}
subj_len = LHStrLen(subject);
subj_ptr = LHStrBuf(subject);
match_data = pcre2_match_data_create_from_pattern(compiled_regex, NULL);
if (match_data == NULL) {
pcre2_match_context_free(ctx);
return PCRE2_ERROR_INTERNAL;
}
rc = pcre2_match(compiled_regex, subj_ptr, subj_len, (PCRE2_SIZE)startoffset, 0, match_data, ctx);
/* Sanity check array size. */
ftw_assert(arg.index >= 0 && (*arg.accumulator)->dimsize >= 0);
/* This should always be a trim operation, and never an increase. */
ftw_assert(arg.index <= (*arg.accumulator)->dimsize);
/* Trim callout buffer. */
lv_err = resize_CalloutAccumulator(&callout, arg.index);
if (lv_err) {
rc = PCRE2_ERROR_INTERNAL;
goto MATCH_DONE;
}
if (rc < 0) {
/* No match was found, or an error encountered. */
*match_begin = PCRE2_ERROR_NOMATCH;
*match_end = PCRE2_ERROR_NOMATCH;
goto MATCH_DONE;
}
/* Retrieve match data. */
ovec_count = pcre2_get_ovector_count(match_data);
ftw_assert(ovec_count > 0);
ovector = pcre2_get_ovector_pointer(match_data);
ftw_assert(ovector);
/* A whole match was found, but no submatches. */
*match_begin = (int32)ovector[0];
*match_end = (int32)ovector[1];
/* Resize the submatch buffer, accounting for the first ovec as the whole match. */
num_submatches = (int)ovec_count - 1;
if (num_submatches == 0)
goto MATCH_DONE;
lv_err = ftw_support_expand_int32Array(&submatches, num_submatches * 2);
if (lv_err) {
rc = PCRE2_ERROR_INTERNAL;
goto MATCH_DONE;
}
for (i = 0; i < num_submatches; i++) {
/* Advance to next submatch pair. */
ovector += 2;
(*submatches)->element[2 * i] = ovector[0];
(*submatches)->element[2 * i + 1] = ovector[1];
}
MATCH_DONE:
pcre2_match_data_free(match_data);
pcre2_match_context_free(ctx);
return rc;
}
hb_xfree( ptr );
}
#endif
HB_CALL_ON_STARTUP_BEGIN( _hb_regex_init_ )
#if defined( HB_HAS_PCRE2 )
/* detect UTF-8 support.
* In BCC builds this code also forces linking newer PCRE versions
* then the one included in BCC RTL.
*/
if( pcre2_config( PCRE2_CONFIG_UNICODE, &s_iUTF8Enabled ) != 0 )
s_iUTF8Enabled = 0;
s_re_ctxg = pcre2_general_context_create( hb_pcre2_grab, hb_pcre2_free, NULL );
s_re_ctxc = pcre2_compile_context_create( s_re_ctxg );
s_re_ctxm = pcre2_match_context_create( s_re_ctxg );
hb_vmAtExit( hb_pcre2_exit, NULL );
#elif defined( HB_HAS_PCRE )
/* detect UTF-8 support.
* In BCC builds this code also forces linking newer PCRE versions
* then the one included in BCC RTL.
*/
if( pcre_config( PCRE_CONFIG_UTF8, &s_iUTF8Enabled ) != 0 )
s_iUTF8Enabled = 0;
pcre_malloc = hb_pcre_grab;
pcre_free = hb_pcre_free;
pcre_stack_malloc = hb_pcre_grab;
pcre_stack_free = hb_pcre_free;
#endif
int regex_compile(tvh_regex_t *regex, const char *re_str, int flags, int subsys)
{
#if ENABLE_PCRE || ENABLE_PCRE2
regex->is_posix = 0;
if (flags & TVHREGEX_POSIX) {
regex->is_posix = 1;
#endif
int options = REG_EXTENDED;
if (flags & TVHREGEX_CASELESS)
options |= REG_ICASE;
if (!regcomp(®ex->re_posix_code, re_str, options))
return 0;
tvherror(subsys, "Unable to compile regex '%s'", re_str);
return -1;
#if ENABLE_PCRE || ENABLE_PCRE2
} else {
#if ENABLE_PCRE
const char *estr;
int eoff;
int options = PCRE_UTF8;
if (flags & TVHREGEX_CASELESS)
options |= PCRE_CASELESS;
#if PCRE_STUDY_JIT_COMPILE
regex->re_jit_stack = NULL;
#endif
regex->re_extra = NULL;
regex->re_code = pcre_compile(re_str, options, &estr, &eoff, NULL);
if (regex->re_code == NULL) {
tvherror(subsys, "Unable to compile PCRE '%s': %s", re_str, estr);
} else {
regex->re_extra = pcre_study(regex->re_code,
PCRE_STUDY_JIT_COMPILE, &estr);
if (regex->re_extra == NULL && estr)
tvherror(subsys, "Unable to study PCRE '%s': %s", re_str, estr);
else {
#if PCRE_STUDY_JIT_COMPILE
regex->re_jit_stack = pcre_jit_stack_alloc(32*1024, 512*1024);
if (regex->re_jit_stack)
pcre_assign_jit_stack(regex->re_extra, NULL, regex->re_jit_stack);
#endif
return 0;
}
}
return -1;
#elif ENABLE_PCRE2
PCRE2_UCHAR8 ebuf[128];
int ecode;
PCRE2_SIZE eoff;
size_t jsz;
uint32_t options;
assert(regex->re_jit_stack == NULL);
regex->re_jit_stack = NULL;
regex->re_match = NULL;
regex->re_mcontext = pcre2_match_context_create(NULL);
options = PCRE2_UTF;
if (flags & TVHREGEX_CASELESS)
options |= PCRE2_CASELESS;
regex->re_code = pcre2_compile((PCRE2_SPTR8)re_str, -1, options,
&ecode, &eoff, NULL);
if (regex->re_code == NULL) {
(void)pcre2_get_error_message(ecode, ebuf, 120);
tvherror(subsys, "Unable to compile PCRE2 '%s': %s", re_str, ebuf);
} else {
regex->re_match = pcre2_match_data_create(TVHREGEX_MAX_MATCHES, NULL);
if (re_str[0] && pcre2_jit_compile(regex->re_code, PCRE2_JIT_COMPLETE) >= 0) {
jsz = 0;
if (pcre2_pattern_info(regex->re_code, PCRE2_INFO_JITSIZE, &jsz) >= 0 && jsz > 0) {
regex->re_jit_stack = pcre2_jit_stack_create(32 * 1024, 512 * 1024, NULL);
if (regex->re_jit_stack)
pcre2_jit_stack_assign(regex->re_mcontext, NULL, regex->re_jit_stack);
}
}
return 0;
}
return -1;
#endif
}
#endif
}
static void
rspamd_regexp_post_process (rspamd_regexp_t *r)
{
if (global_re_cache == NULL) {
rspamd_regexp_library_init (NULL);
}
#if defined(WITH_PCRE2)
gsize jsz;
guint jit_flags = PCRE2_JIT_COMPLETE;
/* Create match context */
r->mcontext = pcre2_match_context_create (NULL);
if (r->re != r->raw_re) {
r->raw_mcontext = pcre2_match_context_create (NULL);
}
else {
r->raw_mcontext = r->mcontext;
}
#ifdef HAVE_PCRE_JIT
if (pcre2_jit_compile (r->re, jit_flags) < 0) {
msg_err ("jit compilation of %s is not supported: %d", r->pattern, jit_flags);
r->flags |= RSPAMD_REGEXP_FLAG_DISABLE_JIT;
}
else {
if (!(pcre2_pattern_info (r->re, PCRE2_INFO_JITSIZE, &jsz) >= 0 && jsz > 0)) {
msg_err ("jit compilation of %s is not supported", r->pattern);
r->flags |= RSPAMD_REGEXP_FLAG_DISABLE_JIT;
}
}
if (!(r->flags & RSPAMD_REGEXP_FLAG_DISABLE_JIT)) {
pcre2_jit_stack_assign (r->mcontext, NULL, global_re_cache->jstack);
}
if (r->re != r->raw_re) {
if (pcre2_jit_compile (r->raw_re, jit_flags) < 0) {
msg_debug ("jit compilation of %s is not supported", r->pattern);
r->flags |= RSPAMD_REGEXP_FLAG_DISABLE_JIT;
}
if (!(pcre2_pattern_info (r->raw_re, PCRE2_INFO_JITSIZE, &jsz) >= 0 && jsz > 0)) {
msg_debug ("jit compilation of raw %s is not supported", r->pattern);
}
else if (!(r->flags & RSPAMD_REGEXP_FLAG_DISABLE_JIT)) {
pcre2_jit_stack_assign (r->raw_mcontext, NULL, global_re_cache->jstack);
}
}
#endif
#else
const gchar *err_str = "unknown";
gboolean try_jit = TRUE, try_raw_jit = TRUE;
gint study_flags = 0;
#if defined(HAVE_PCRE_JIT)
study_flags |= PCRE_STUDY_JIT_COMPILE;
#endif
/* Pcre 1 needs study */
if (r->re) {
r->extra = pcre_study (r->re, study_flags, &err_str);
if (r->extra == NULL) {
msg_debug ("cannot optimize regexp pattern: '%s': %s",
r->pattern, err_str);
try_jit = FALSE;
r->flags |= RSPAMD_REGEXP_FLAG_DISABLE_JIT;
}
}
else {
g_assert_not_reached ();
}
if (r->raw_re && r->raw_re != r->re) {
r->raw_extra = pcre_study (r->re, study_flags, &err_str);
}
else if (r->raw_re == r->re) {
r->raw_extra = r->extra;
}
if (r->raw_extra == NULL) {
msg_debug ("cannot optimize raw regexp pattern: '%s': %s",
r->pattern, err_str);
try_raw_jit = FALSE;
}
/* JIT path */
if (try_jit) {
#ifdef HAVE_PCRE_JIT
gint jit, n;
if (can_jit) {
jit = 0;
n = pcre_fullinfo (r->re, r->extra,
PCRE_INFO_JIT, &jit);
if (n != 0 || jit != 1) {
msg_debug ("jit compilation of %s is not supported", r->pattern);
r->flags |= RSPAMD_REGEXP_FLAG_DISABLE_JIT;
}
else {
pcre_assign_jit_stack (r->extra, NULL, global_re_cache->jstack);
}
}
#endif
}
else {
msg_debug ("cannot optimize regexp pattern: '%s': %s",
r->pattern, err_str);
r->flags |= RSPAMD_REGEXP_FLAG_DISABLE_JIT;
}
if (try_raw_jit) {
#ifdef HAVE_PCRE_JIT
gint jit, n;
if (can_jit) {
if (r->raw_re != r->re) {
jit = 0;
n = pcre_fullinfo (r->raw_re, r->raw_extra,
PCRE_INFO_JIT, &jit);
if (n != 0 || jit != 1) {
msg_debug ("jit compilation of %s is not supported", r->pattern);
r->flags |= RSPAMD_REGEXP_FLAG_DISABLE_JIT;
}
else {
pcre_assign_jit_stack (r->raw_extra, NULL,
global_re_cache->jstack);
}
}
}
#endif
}
#endif /* WITH_PCRE2 */
}
