void cli_pcre_free_single(struct cli_pcre_data *pd)
{
#if USING_PCRE2
if (pd->re) {
pcre2_code_free(pd->re);
pd->re = NULL;
}
if (pd->mctx) {
pcre2_match_context_free(pd->mctx);
pd->mctx = NULL;
}
#else
if (pd->re) {
pcre_free(pd->re);
pd->re = NULL;
}
if (pd->ex) {
free(pd->ex);
pd->ex = NULL;
}
#endif
if (pd->expression) {
free(pd->expression);
pd->expression = NULL;
}
}
static void free_pcre2_pattern(struct grep_pat *p)
{
pcre2_compile_context_free(p->pcre2_compile_context);
pcre2_code_free(p->pcre2_pattern);
pcre2_match_data_free(p->pcre2_match_data);
pcre2_jit_stack_free(p->pcre2_jit_stack);
pcre2_match_context_free(p->pcre2_match_context);
}
static void hb_pcre2_exit( void * cargo )
{
HB_SYMBOL_UNUSED( cargo );
pcre2_match_context_free( s_re_ctxm );
pcre2_compile_context_free( s_re_ctxc );
pcre2_general_context_free( s_re_ctxg );
}
static void
rspamd_regexp_dtor (rspamd_regexp_t *re)
{
if (re) {
if (re->raw_re && re->raw_re != re->re) {
#ifndef WITH_PCRE2
#ifdef HAVE_PCRE_JIT
if (re->raw_extra) {
pcre_free_study (re->raw_extra);
}
#endif
#else
if (re->mcontext) {
pcre2_match_context_free (re->mcontext);
}
#endif
PCRE_FREE (re->raw_re);
}
if (re->re) {
#ifndef WITH_PCRE2
#ifdef HAVE_PCRE_JIT
if (re->extra) {
pcre_free_study (re->extra);
}
#endif
#else
if (re->raw_mcontext) {
pcre2_match_context_free (re->raw_mcontext);
}
#endif
PCRE_FREE (re->re);
}
if (re->pattern) {
g_free (re->pattern);
}
g_free (re);
}
}
/*
* Regex stuff
*/
void regex_free(tvh_regex_t *regex)
{
#if ENABLE_PCRE || ENABLE_PCRE2
if (regex->is_posix) {
#endif
regfree(®ex->re_posix_code);
regex->re_posix_text = NULL;
#if ENABLE_PCRE || ENABLE_PCRE2
} else {
#if ENABLE_PCRE
#ifdef PCRE_CONFIG_JIT
#if PCRE_STUDY_JIT_COMPILE
if (regex->re_jit_stack) {
pcre_jit_stack_free(regex->re_jit_stack);
regex->re_jit_stack = NULL;
}
#endif
pcre_free_study(regex->re_extra);
#else
pcre_free(regex->re_extra);
#endif
pcre_free(regex->re_code);
regex->re_extra = NULL;
regex->re_code = NULL;
regex->re_text = NULL;
#elif ENABLE_PCRE2
pcre2_jit_stack_free(regex->re_jit_stack);
pcre2_match_data_free(regex->re_match);
pcre2_code_free(regex->re_code);
pcre2_match_context_free(regex->re_mcontext);
regex->re_match = NULL;
regex->re_code = NULL;
regex->re_mcontext = NULL;
regex->re_jit_stack = NULL;
#endif
}
#endif
}
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;
}
