From 53748ca8ca3c893025be34dd4f104546fcbd0602 Mon Sep 17 00:00:00 2001 From: Fabian Keil Date: Sat, 17 Jun 2023 13:20:24 +0200 Subject: [PATCH] Add pcre2 support This is currently expected to cause crashes on Windows when compiled with GUI support. Closes bug #935. Initial patch submitted by: Gagan Sidhu --- acconfig.h | 6 ++ actions.c | 8 +++ cgi.c | 9 ++- client-tags.c | 5 ++ configure.in | 64 ++++++++++++++++- pcrs.c | 148 +++++++++++++++++++++++++++++---------- pcrs.h | 40 +++++++---- project.h | 54 +++++++++----- templates/show-status | 5 +- urlmatch.c | 159 ++++++++++++++++++++++++++++++++++++++++++ urlmatch.h | 4 ++ w32log.c | 3 + 12 files changed, 430 insertions(+), 75 deletions(-) --- a/acconfig.h +++ b/acconfig.h @@ -225,11 +225,17 @@ /* Define if pcre.h must be included as */ #undef PCRE_H_IN_SUBDIR +#undef PCRE2_H_IN_SUBDIR + +#undef HAVE_PCRE2 +#undef HAVE_PCRE2POSIX /* Define if pcreposix.h must be included as */ #undef PCREPOSIX_H_IN_SUBDIR +#undef PCRE2POSIX_H_IN_SUBDIR + @BOTTOM@ /* --- a/actions.c +++ b/actions.c @@ -828,8 +828,12 @@ int update_action_bits_for_tag(struct cl continue; } +#ifdef HAVE_PCRE2 + if (pcre2_pattern_matches(b->url->pattern.tag_regex, tag)) +#else /* and check if one of the tag patterns matches the tag, */ if (0 == regexec(b->url->pattern.tag_regex, tag, 0, NULL, 0)) +#endif { /* if it does, update the action bit map, */ if (merge_current_action(csp->action, b->action)) @@ -884,7 +888,11 @@ jb_err check_negative_tag_patterns(struc } for (tag = csp->tags->first; NULL != tag; tag = tag->next) { +#ifdef HAVE_PCRE2 + if (pcre2_pattern_matches(b->url->pattern.tag_regex, tag->str)) +#else if (0 == regexec(b->url->pattern.tag_regex, tag->str, 0, NULL, 0)) +#endif { /* * The pattern matches at least one tag, thus the action --- a/cgi.c +++ b/cgi.c @@ -2023,7 +2023,7 @@ jb_err template_fill(char **template_ptr char buf[BUFFER_SIZE]; char *tmp_out_buffer; char *file_buffer; - size_t size; + size_t buffer_size, new_size; int error; const char *flags; @@ -2032,7 +2032,7 @@ jb_err template_fill(char **template_ptr assert(exports); file_buffer = *template_ptr; - size = strlen(file_buffer) + 1; + buffer_size = strlen(file_buffer) + 1; /* * Assemble pcrs joblist from exports map @@ -2082,7 +2082,10 @@ jb_err template_fill(char **template_ptr } else { - error = pcrs_execute(job, file_buffer, size, &tmp_out_buffer, &size); + error = pcrs_execute(job, file_buffer, buffer_size, &tmp_out_buffer, + &new_size); + + buffer_size = new_size; pcrs_free_job(job); if (NULL == tmp_out_buffer) --- a/client-tags.c +++ b/client-tags.c @@ -43,6 +43,7 @@ #include "miscutil.h" #include "errlog.h" #include "parsers.h" +#include "urlmatch.h" struct client_specific_tag { @@ -658,7 +659,11 @@ int client_tag_match(const struct patter for (tag = tags->first; tag != NULL; tag = tag->next) { +#ifdef HAVE_PCRE2 + if (pcre2_pattern_matches(pattern->pattern.tag_regex, tag->str)) +#else if (0 == regexec(pattern->pattern.tag_regex, tag->str, 0, NULL, 0)) +#endif { log_error(LOG_LEVEL_TAGGING, "Client tag '%s' matches.", tag->str); return 1; --- a/configure.in +++ b/configure.in @@ -863,12 +863,47 @@ else ]) fi +AC_ARG_ENABLE(pcre2, +[ --disable-pcre2 Don't try to use pcre2 even if it's available], +[enableval2=$enableval], +[enableval2=yes]) +if test $enableval2 = yes; then + try_pcre2=yes +else + AC_MSG_WARN([Ignoring pcre2 even if it's available]) + try_pcre2=no +fi + +if test $try_pcre2 != no; then dnl ================================================================= dnl Checks for libraries. dnl ================================================================= dnl Note: Some systems may have the library but not the system header dnl file, so we must check for both. dnl Also check for correct version +AC_CHECK_LIB(pcre2-8, pcre2_compile_8, [ + AC_CHECK_HEADER(pcre2.h, [ + AC_EGREP_HEADER(pcre2_pattern_info, pcre2.h,[have_pcre2=yes; AC_DEFINE(HAVE_PCRE2)], [AC_MSG_WARN([[pcre2 old version installed]]); have_pcre2=no]) + ], [ + AC_CHECK_HEADER(pcre2/pcre2.h, [ + AC_EGREP_HEADER(pcre2_pattern_info, pcre2/pcre2.h, [have_pcre2=yes; AC_DEFINE(PCRE2_H_IN_SUBDIR)], [AC_MSG_WARN([[pcre2 old version installed]]); have_pcre2=no]) + ], [have_pcre2=no]) + ], [#define PCRE2_CODE_UNIT_WIDTH 8]) +], [have_pcre2=no]) + +AC_CHECK_LIB(pcre2-posix, regcomp, [ + AC_CHECK_HEADER(pcre2posix.h, [ + AC_EGREP_HEADER(pcre2_regerror, pcre2posix.h, [have_pcre2posix=yes],[AC_MSG_WARN([[pcre2posix old version installed]]); have_pcre2posix=no]) + ], [ + AC_CHECK_HEADER(pcre/pcre2posix.h, [ + AC_EGREP_HEADER(pcre2_regerror, pcre2/pcre2posix.h, [have_pcre2posix=yes; AC_DEFINE(PCRE2POSIX_H_IN_SUBDIR)],[AC_MSG_WARN([[pcre2posix old version installed]]); have_pcre2posix=no]) + ], [have_pcre2posix=no]) + ]) +], [have_pcre2posix=no], -lpcre2-8) +fi + +if test $have_pcre2 = "no"; then + AC_CHECK_LIB(pcre, pcre_compile, [ AC_CHECK_HEADER(pcre.h, [ AC_EGREP_HEADER(pcre_fullinfo, pcre.h, [have_pcre=yes], [AC_MSG_WARN([[pcre old version installed]]); have_pcre=no]) @@ -889,6 +924,7 @@ AC_CHECK_LIB(pcreposix, regcomp, [ ]) ], [have_pcreposix=no], -lpcre) +fi dnl ================================================================ dnl libpcrs is temporarily disabled. dnl @@ -1095,6 +1131,31 @@ fi # we don't need pcreposix, then link pcre dynamically; else # build it and link statically # + +#check for libpcre2 first. then regular pcre + +if test $have_pcre2 = "yes"; then + echo "using libpcre2" + STATIC_PCRE_ONLY=# + LIBS="$LIBS -lpcre2-8 -lpcre2-posix" + if test "$use_static_pcre" = "yes"; then + pcre_dyn=no + AC_DEFINE(PCRE_STATIC,1,[Define to statically link to pcre library on Windows.]) +# see /usr/i686-w64-mingw32/sys-root/mingw/include/pcre.h line 54 +# #if defined(_WIN32) && !defined(PCRE_STATIC) +# # ifndef PCRE_EXP_DECL +# # define PCRE_EXP_DECL extern __declspec(dllimport) +# # endif +# If you want to statically link a program against a PCRE library in the form of +# a non-dll .a file, you must define PCRE_STATIC before including pcre.h or +# pcrecpp.h, otherwise the pcre_malloc() and pcre_free() exported functions will +# be declared __declspec(dllimport), with unwanted results. + else + pcre_dyn=yes + AC_DEFINE(FEATURE_DYNAMIC_PCRE,1,[Define to dynamically link to pcre.]) + fi +else + if test $have_pcre = "yes"; then echo "using libpcre" STATIC_PCRE_ONLY=# @@ -1116,7 +1177,8 @@ if test $have_pcre = "yes"; then AC_DEFINE(FEATURE_DYNAMIC_PCRE,1,[Define to dynamically link to pcre.]) fi else - AC_MSG_ERROR(pcre library not detected.) + AC_MSG_ERROR(Detected neither pcre2 nor pcre library.) +fi fi AC_DEFINE(FEATURE_CONNECTION_KEEP_ALIVE) --- a/pcrs.c +++ b/pcrs.c @@ -57,7 +57,7 @@ * Internal prototypes */ -static int pcrs_parse_perl_options(const char *optstring, int *flags); +static int pcrs_parse_perl_options(const char *optstring, unsigned int *flags); static pcrs_substitute *pcrs_compile_replacement(const char *replacement, int trivialflag, int capturecount, int *errptr); static int is_hex_sequence(const char *sequence); @@ -83,25 +83,25 @@ const char *pcrs_strerror(const int erro switch (error) { /* Passed-through PCRE error: */ - case PCRE_ERROR_NOMEMORY: return "(pcre:) No memory"; + case PCREn(ERROR_NOMEMORY): return "(pcre:) No memory"; /* Shouldn't happen unless PCRE or PCRS bug, or user messed with compiled job: */ - case PCRE_ERROR_NULL: return "(pcre:) NULL code or subject or ovector"; - case PCRE_ERROR_BADOPTION: return "(pcre:) Unrecognized option bit"; - case PCRE_ERROR_BADMAGIC: return "(pcre:) Bad magic number in code"; + case PCREn(ERROR_NULL): return "(pcre:) NULL code or subject or ovector"; + case PCREn(ERROR_BADOPTION): return "(pcre:) Unrecognized option bit"; + case PCREn(ERROR_BADMAGIC): return "(pcre:) Bad magic number in code"; +#if defined(PCRE_ERROR_UNKNOWN_NODE) case PCRE_ERROR_UNKNOWN_NODE: return "(pcre:) Bad node in pattern"; - +#endif /* Can't happen / not passed: */ - case PCRE_ERROR_NOSUBSTRING: return "(pcre:) Fire in power supply"; - case PCRE_ERROR_NOMATCH: return "(pcre:) Water in power supply"; + case PCREn(ERROR_NOSUBSTRING): return "(pcre:) Fire in power supply"; + case PCREn(ERROR_NOMATCH): return "(pcre:) Water in power supply"; #ifdef PCRE_ERROR_MATCHLIMIT /* * Only reported by PCRE versions newer than our own. */ - case PCRE_ERROR_MATCHLIMIT: return "(pcre:) Match limit reached"; + case PCREn(ERROR_MATCHLIMIT): return "(pcre:) Match limit reached"; #endif /* def PCRE_ERROR_MATCHLIMIT */ - /* PCRS errors: */ case PCRS_ERR_NOMEM: return "(pcrs:) No memory"; case PCRS_ERR_CMDSYNTAX: return "(pcrs:) Syntax error while parsing command"; @@ -111,16 +111,14 @@ const char *pcrs_strerror(const int erro case PCRS_WARN_TRUNCATION: return "(pcrs:) At least one variable was too big and has been truncated before compilation"; - /* - * XXX: With the exception of PCRE_ERROR_MATCHLIMIT we - * only catch PCRE errors that can happen with our internal - * version. If Privoxy is linked against a newer - * PCRE version all bets are off ... - */ default: +#ifdef HAVE_PCRE2 + pcre2_get_error_message(error, (PCRE2_UCHAR8*)buf, sizeof(buf)); +#else snprintf(buf, sizeof(buf), "Error code %d. For details, check the pcre documentation.", error); +#endif return buf; } } @@ -149,7 +147,7 @@ const char *pcrs_strerror(const int erro * Returns : option integer suitable for pcre * *********************************************************************/ -static int pcrs_parse_perl_options(const char *optstring, int *flags) +static int pcrs_parse_perl_options(const char *optstring, unsigned int *flags) { size_t i; int rc = 0; @@ -163,13 +161,13 @@ static int pcrs_parse_perl_options(const { case 'e': break; /* ToDo ;-) */ case 'g': *flags |= PCRS_GLOBAL; break; - case 'i': rc |= PCRE_CASELESS; break; - case 'm': rc |= PCRE_MULTILINE; break; + case 'i': rc |= PCREn(CASELESS); break; + case 'm': rc |= PCREn(MULTILINE); break; case 'o': break; - case 's': rc |= PCRE_DOTALL; break; - case 'x': rc |= PCRE_EXTENDED; break; + case 's': rc |= PCREn(DOTALL); break; + case 'x': rc |= PCREn(EXTENDED); break; case 'D': *flags |= PCRS_DYNAMIC; break; - case 'U': rc |= PCRE_UNGREEDY; break; + case 'U': rc |= PCREn(UNGREEDY); break; case 'T': *flags |= PCRS_TRIVIAL; break; default: break; } @@ -471,7 +469,15 @@ pcrs_job *pcrs_free_job(pcrs_job *job) else { next = job->next; - if (job->pattern != NULL) free(job->pattern); + if (job->pattern != NULL) + { +#ifdef HAVE_PCRE2 + pcre2_code_free(job->pattern); +#else + free(job->pattern); +#endif + } +#ifndef HAVE_PCRE2 if (job->hints != NULL) { #ifdef PCRE_CONFIG_JIT @@ -480,6 +486,7 @@ pcrs_job *pcrs_free_job(pcrs_job *job) free(job->hints); #endif } +#endif if (job->substitute != NULL) { if (job->substitute->text != NULL) free(job->substitute->text); @@ -626,10 +633,14 @@ pcrs_job *pcrs_compile_command(const cha pcrs_job *pcrs_compile(const char *pattern, const char *substitute, const char *options, int *errptr) { pcrs_job *newjob; - int flags; + unsigned int flags; int capturecount; - const char *error; +#ifdef HAVE_PCRE2 + int ret; +#else int pcre_study_options = 0; + const char *error; +#endif *errptr = 0; @@ -661,25 +672,43 @@ pcrs_job *pcrs_compile(const char *patte /* * Compile the pattern */ +#ifdef HAVE_PCRE2 + PCRE2_SIZE error_offset; + newjob->pattern = pcre2_compile((const unsigned char *)pattern, + PCRE2_ZERO_TERMINATED, (unsigned)newjob->options, errptr, + &error_offset, NULL); +#else newjob->pattern = pcre_compile(pattern, newjob->options, &error, errptr, NULL); +#endif if (newjob->pattern == NULL) { pcrs_free_job(newjob); return NULL; } - -#ifdef PCRE_STUDY_JIT_COMPILE +#if defined(PCRE_STUDY_JIT_COMPILE) || defined(HAVE_PCRE2) #ifdef DISABLE_PCRE_JIT_COMPILATION #warning PCRE_STUDY_JIT_COMPILE is supported but Privoxy has been configured not to use it #else if (!(flags & PCRS_DYNAMIC)) { +#ifdef HAVE_PCRE2 + /* Try to enable JIT compilation but continue if it's unsupported. */ + if ((ret = pcre2_jit_compile(newjob->pattern, PCRE2_JIT_COMPLETE)) && + (ret != PCRE2_ERROR_JIT_BADOPTION)) + { + *errptr = ret; + pcrs_free_job(newjob); + return NULL; + } +#else pcre_study_options = PCRE_STUDY_JIT_COMPILE; +#endif } #endif #endif +#ifndef HAVE_PCRE2 /* * Generate hints. This has little overhead, since the * hints will be NULL for a boring pattern anyway. @@ -691,13 +720,17 @@ pcrs_job *pcrs_compile(const char *patte pcrs_free_job(newjob); return NULL; } - +#endif /* * Determine the number of capturing subpatterns. * This is needed for handling $+ in the substitute. */ +#ifdef HAVE_PCRE2 + if (0 > (*errptr = pcre2_pattern_info(newjob->pattern, PCRE2_INFO_CAPTURECOUNT, &capturecount))) +#else if (0 > (*errptr = pcre_fullinfo(newjob->pattern, newjob->hints, PCRE_INFO_CAPTURECOUNT, &capturecount))) +#endif { pcrs_free_job(newjob); return NULL; @@ -809,14 +842,20 @@ int pcrs_execute_list(pcrs_job *joblist, *********************************************************************/ int pcrs_execute(pcrs_job *job, const char *subject, size_t subject_length, char **result, size_t *result_length) { - int offsets[3 * PCRS_MAX_SUBMATCHES], - offset, + int offset, i, k, matches_found, submatches, max_matches = PCRS_MAX_MATCH_INIT; size_t newsize; +#ifdef HAVE_PCRE2 pcrs_match *matches, *dummy; + pcre2_match_data *pcre2_matches; + size_t *offsets; +#else + pcrs_match *matches, *dummy; + int offsets[3 * PCRS_MAX_SUBMATCHES]; +#endif char *result_offset; offset = i = 0; @@ -830,27 +869,38 @@ int pcrs_execute(pcrs_job *job, const ch return(PCRS_ERR_BADJOB); } +#ifdef HAVE_PCRE2 + if (NULL == (pcre2_matches = pcre2_match_data_create_from_pattern(job->pattern, NULL))) + { + return(PCRS_ERR_NOMEM); + } + offsets = pcre2_get_ovector_pointer(pcre2_matches); +#endif if (NULL == (matches = (pcrs_match *)malloc((size_t)max_matches * sizeof(pcrs_match)))) { return(PCRS_ERR_NOMEM); } memset(matches, '\0', (size_t)max_matches * sizeof(pcrs_match)); - /* * Find the pattern and calculate the space * requirements for the result */ newsize = subject_length; +#ifdef HAVE_PCRE2 + while ((submatches = pcre2_match(job->pattern, (const unsigned char *)subject, + subject_length, (size_t)offset, 0, pcre2_matches, NULL)) > 0) +#else while ((submatches = pcre_exec(job->pattern, job->hints, subject, (int)subject_length, offset, 0, offsets, 3 * PCRS_MAX_SUBMATCHES)) > 0) +#endif { job->flags |= PCRS_SUCCESS; matches[i].submatches = submatches; for (k = 0; k < submatches; k++) { - matches[i].submatch_offset[k] = offsets[2 * k]; + matches[i].submatch_offset[k] = (int)offsets[2 * k]; /* Note: Non-found optional submatches have length -1-(-1)==0 */ matches[i].submatch_length[k] = (size_t)(offsets[2 * k + 1] - offsets[2 * k]); @@ -867,7 +917,7 @@ int pcrs_execute(pcrs_job *job, const ch newsize += (size_t)offsets[0] * (size_t)job->substitute->backref_count[PCRS_MAX_SUBMATCHES]; /* chunk after match */ - matches[i].submatch_offset[PCRS_MAX_SUBMATCHES + 1] = offsets[1]; + matches[i].submatch_offset[PCRS_MAX_SUBMATCHES + 1] = (int)offsets[1]; matches[i].submatch_length[PCRS_MAX_SUBMATCHES + 1] = subject_length - (size_t)offsets[1] - 1; newsize += (subject_length - (size_t)offsets[1]) * (size_t)job->substitute->backref_count[PCRS_MAX_SUBMATCHES + 1]; @@ -894,12 +944,19 @@ int pcrs_execute(pcrs_job *job, const ch break; /* Go find the next one */ else - offset = offsets[1]; + offset = (int)offsets[1]; } /* Pass pcre error through if (bad) failure */ +#ifdef HAVE_PCRE2 + if (submatches < PCRE2_ERROR_NOMATCH) +#else if (submatches < PCRE_ERROR_NOMATCH) +#endif { free(matches); +#ifdef HAVE_PCRE2 + pcre2_match_data_free(pcre2_matches); +#endif return submatches; } matches_found = i; @@ -909,9 +966,19 @@ int pcrs_execute(pcrs_job *job, const ch * Get memory for the result (must be freed by caller!) * and append terminating null byte. */ - if ((*result = (char *)malloc(newsize + 1)) == NULL) + if ((*result = (char *)malloc(newsize + 1 +#ifdef HAVE_PCRE2 + /* + * Work around to prevent invalid reads in the jit code. + */ + + 16 +#endif + )) == NULL) { free(matches); +#ifdef HAVE_PCRE2 + pcre2_match_data_free(pcre2_matches); +#endif return PCRS_ERR_NOMEM; } else @@ -964,6 +1031,9 @@ int pcrs_execute(pcrs_job *job, const ch memcpy(result_offset, subject + offset, subject_length - (size_t)offset); *result_length = newsize; +#ifdef HAVE_PCRE2 + pcre2_match_data_free(pcre2_matches); +#endif free(matches); return matches_found; @@ -1101,7 +1171,7 @@ char pcrs_get_delimiter(const char *stri *********************************************************************/ char *pcrs_execute_single_command(const char *subject, const char *pcrs_command, int *hits) { - size_t size; + size_t buffer_size, new_size; char *result = NULL; pcrs_job *job; @@ -1109,12 +1179,14 @@ char *pcrs_execute_single_command(const assert(pcrs_command); *hits = 0; - size = strlen(subject); + buffer_size = strlen(subject); job = pcrs_compile_command(pcrs_command, hits); if (NULL != job) { - *hits = pcrs_execute(job, subject, size, &result, &size); + *hits = pcrs_execute(job, subject, buffer_size, &result, &new_size); + buffer_size = new_size; + if (*hits < 0) { freez(result); --- a/pcrs.h +++ b/pcrs.h @@ -33,9 +33,18 @@ *********************************************************************/ +#ifdef HAVE_PCRE2 +#define PCRE2_CODE_UNIT_WIDTH 8 +#define PCREn(x) PCRE2_ ## x +#ifndef _PCRE2_H +#include +#endif +#else +#define PCREn(x) PCRE_ ## x #ifndef _PCRE_H #include #endif +#endif /* * Constants: @@ -55,22 +64,23 @@ * They are supposed to be handled together with PCRE error * codes and have to start with an offset to prevent overlaps. * - * PCRE 6.7 uses error codes from -1 to -21, PCRS error codes - * below -100 should be safe for a while. + * PCRE 6.7 uses error codes from -1 to -21, + * PCRE2 10.42 uses error codes from -66 to 101. + * PCRS error codes below -300 should be safe for a while. */ -#define PCRS_ERR_NOMEM -100 /* Failed to acquire memory. */ -#define PCRS_ERR_CMDSYNTAX -101 /* Syntax of s///-command */ -#define PCRS_ERR_STUDY -102 /* pcre error while studying the pattern */ -#define PCRS_ERR_BADJOB -103 /* NULL job pointer, pattern or substitute */ -#define PCRS_WARN_BADREF -104 /* Backreference out of range */ -#define PCRS_WARN_TRUNCATION -105 /* At least one pcrs variable was too big, +#define PCRS_ERR_NOMEM -300 /* Failed to acquire memory. */ +#define PCRS_ERR_CMDSYNTAX -301 /* Syntax of s///-command */ +#define PCRS_ERR_STUDY -302 /* pcre error while studying the pattern */ +#define PCRS_ERR_BADJOB -303 /* NULL job pointer, pattern or substitute */ +#define PCRS_WARN_BADREF -304 /* Backreference out of range */ +#define PCRS_WARN_TRUNCATION -305 /* At least one pcrs variable was too big, * only the first part was used. */ /* Flags */ -#define PCRS_GLOBAL 1 /* Job should be applied globally, as with perl's g option */ -#define PCRS_TRIVIAL 2 /* Backreferences in the substitute are ignored */ -#define PCRS_SUCCESS 4 /* Job did previously match */ -#define PCRS_DYNAMIC 8 /* Job is dynamic (used to disable JIT compilation) */ +#define PCRS_GLOBAL 0x08000000u /* Job should be applied globally, as with perl's g option */ +#define PCRS_TRIVIAL 0x10000000u /* Backreferences in the substitute are ignored */ +#define PCRS_SUCCESS 0x20000000u /* Job did previously match */ +#define PCRS_DYNAMIC 0x40000000u /* Job is dynamic (used to disable JIT compilation) */ /* @@ -107,10 +117,14 @@ typedef struct { /* A PCRS job */ typedef struct PCRS_JOB { +#ifdef HAVE_PCRE2 + pcre2_code *pattern; +#else pcre *pattern; /* The compiled pcre pattern */ pcre_extra *hints; /* The pcre hints for the pattern */ +#endif int options; /* The pcre options (numeric) */ - int flags; /* The pcrs and user flags (see "Flags" above) */ + unsigned int flags; /* The pcrs and user flags (see "Flags" above) */ pcrs_substitute *substitute; /* The compiled pcrs substitute */ struct PCRS_JOB *next; /* Pointer for chaining jobs to joblists */ } pcrs_job; --- a/project.h +++ b/project.h @@ -94,12 +94,38 @@ */ #ifdef STATIC_PCRE +#ifdef HAVE_PCRE2 +# include "pcre2.h" +# include "pcre2posix.h" +#else # include "pcre.h" +# include "pcreposix.h" +#endif #else -# ifdef PCRE_H_IN_SUBDIR -# include +# ifdef HAVE_PCRE2 +# ifdef PCRE2_H_IN_SUBDIR +# define PCRE2_CODE_UNIT_WIDTH 8 +# include +# else +# define PCRE2_CODE_UNIT_WIDTH 8 +# include +# endif +# ifdef PCRE2POSIX_H_IN_SUBDIR +# include +# else +# include +# endif # else -# include +# ifdef PCRE_H_IN_SUBDIR +# include +# else +# include +# endif +# ifdef PCREPOSIX_H_IN_SUBDIR +# include +# else +# include +# endif # endif #endif @@ -109,16 +135,6 @@ # include #endif -#ifdef STATIC_PCRE -# include "pcreposix.h" -#else -# ifdef PCRE_H_IN_SUBDIR -# include -# else -# include -# endif -#endif - #ifdef _WIN32 /* * I don't want to have to #include all this just for the declaration @@ -404,10 +420,16 @@ struct http_response enum crunch_reason crunch_reason; /**< Why the response was generated in the first place. */ }; +#ifdef HAVE_PCRE2 +#define REGEX_TYPE pcre2_code +#else +#define REGEX_TYPE regex_t +#endif + struct url_spec { #ifdef FEATURE_PCRE_HOST_PATTERNS - regex_t *host_regex;/**< Regex for host matching */ + REGEX_TYPE *host_regex;/**< Regex for host matching */ enum host_regex_type { VANILLA_HOST_PATTERN, PCRE_HOST_PATTERN } host_regex_type; #endif /* defined FEATURE_PCRE_HOST_PATTERNS */ int dcount; /**< How many parts to this domain? (length of dvec) */ @@ -417,7 +439,7 @@ struct url_spec char *port_list; /**< List of acceptable ports, or NULL to match all ports */ - regex_t *preg; /**< Regex for matching path part */ + REGEX_TYPE *preg; /**< Regex for matching path part */ }; /** @@ -432,7 +454,7 @@ struct pattern_spec union { struct url_spec url_spec; - regex_t *tag_regex; + REGEX_TYPE *tag_regex; } pattern; unsigned int flags; /**< Bitmap with various pattern properties. */ --- a/templates/show-status +++ b/templates/show-status @@ -298,10 +298,7 @@ FEATURE_DYNAMIC_PCRE @if-FEATURE_DYNAMIC_PCRE-then@ Yes @else-not-FEATURE_DYNAMIC_PCRE@ No @endif-FEATURE_DYNAMIC_PCRE@ - Dynamically link to the PCRE library. This is set automatically - by ./configure if you do not have libpcre installed. - Dynamically linking to an external libpcre is recommended as the one that is distributed - with Privoxy itself is outdated and lacks various features and bug-fixes you may be interested in. + Dynamically link to the PCRE(2) library (recommended). FEATURE_EXTENDED_STATISTICS --- a/urlmatch.c +++ b/urlmatch.c @@ -604,6 +604,100 @@ jb_err parse_http_request(const char *re } +#ifdef HAVE_PCRE2 +/********************************************************************* + * + * Function : compile_pattern + * + * Description : Compiles a host, domain or TAG pattern. + * + * Parameters : + * 1 : pattern = The pattern to compile. + * 2 : anchoring = How the regex should be modified + * before compilation. Can be either + * one of NO_ANCHORING, LEFT_ANCHORED, + * RIGHT_ANCHORED or RIGHT_ANCHORED_HOST. + * 3 : url = In case of failures, the spec member is + * logged and the structure freed. + * 4 : regex = Where the compiled regex should be stored. + * + * Returns : JB_ERR_OK - Success + * JB_ERR_PARSE - Cannot parse regex + * + *********************************************************************/ +static jb_err compile_pattern(const char *pattern, enum regex_anchoring anchoring, + struct pattern_spec *url, pcre2_code **regex) +{ + int errcode; + const char *fmt = NULL; + char *rebuf; + size_t rebuf_size; + PCRE2_SIZE error_offset; + int ret; + + assert(pattern); + + if (pattern[0] == '\0') + { + *regex = NULL; + return JB_ERR_OK; + } + + switch (anchoring) + { + case NO_ANCHORING: + fmt = "%s"; + break; + case RIGHT_ANCHORED: + fmt = "%s$"; + break; + case RIGHT_ANCHORED_HOST: + fmt = "%s\\.?$"; + break; + case LEFT_ANCHORED: + fmt = "^%s"; + break; + default: + log_error(LOG_LEVEL_FATAL, + "Invalid anchoring in compile_pattern %d", anchoring); + } + rebuf_size = strlen(pattern) + strlen(fmt); + rebuf = malloc_or_die(rebuf_size); + + snprintf(rebuf, rebuf_size, fmt, pattern); + + *regex = pcre2_compile((const unsigned char *)pattern, + PCRE2_ZERO_TERMINATED, PCRE2_CASELESS, &errcode, + &error_offset, NULL); + if (*regex == NULL) + { + log_error(LOG_LEVEL_ERROR, "error compiling %s from %s: %s", + pattern, url->spec, rebuf); + freez(rebuf); + + return JB_ERR_PARSE; + } + +#ifndef DISABLE_PCRE_JIT_COMPILATION + /* Try to enable JIT compilation but continue if it's unsupported. */ + if ((ret = pcre2_jit_compile(*regex, PCRE2_JIT_COMPLETE)) && + (ret != PCRE2_ERROR_JIT_BADOPTION)) + { + log_error(LOG_LEVEL_ERROR, + "Unexpected error enabling JIT compilation for %s from %s: %s", + pattern, url->spec, rebuf); + freez(rebuf); + + return JB_ERR_PARSE; + } +#endif + + freez(rebuf); + + return JB_ERR_OK; + +} +#else /********************************************************************* * * Function : compile_pattern @@ -686,6 +780,7 @@ static jb_err compile_pattern(const char return JB_ERR_OK; } +#endif /********************************************************************* @@ -1051,6 +1146,49 @@ static int simplematch(const char *patte } +#ifdef HAVE_PCRE2 +/********************************************************************* + * + * Function : pcre2_pattern_matches + * + * Description : Checks if a compiled pcre2 pattern matches a string. + * + * Parameters : + * 1 : pattern = The compiled pattern + * 2 : string = The string to check + * + * Returns : TRUE for yes, FALSE otherwise. + * + *********************************************************************/ +int pcre2_pattern_matches(const pcre2_code *pattern, const char *string) +{ + PCRE2_SIZE offset; + int ret; + pcre2_match_data *pcre2_matches; + + assert(pattern != NULL); + assert(string != NULL); + + offset = 0; + + pcre2_matches = pcre2_match_data_create_from_pattern(pattern, NULL); + if (NULL == pcre2_matches) + { + log_error(LOG_LEVEL_ERROR, + "Out of memory while matching pattern against %s", string); + return FALSE; + } + + ret = pcre2_match(pattern, (const unsigned char *)string, strlen(string), + offset, 0, pcre2_matches, NULL); + + pcre2_match_data_free(pcre2_matches); + + return (ret >= 0); +} +#endif + + /********************************************************************* * * Function : simple_domaincmp @@ -1268,8 +1406,12 @@ void free_pattern_spec(struct pattern_sp { if (pattern->pattern.tag_regex) { +#ifdef HAVE_PCRE2 + pcre2_code_free(pattern->pattern.tag_regex); +#else regfree(pattern->pattern.tag_regex); freez(pattern->pattern.tag_regex); +#endif } return; } @@ -1277,8 +1419,12 @@ void free_pattern_spec(struct pattern_sp #ifdef FEATURE_PCRE_HOST_PATTERNS if (pattern->pattern.url_spec.host_regex) { +#ifdef HAVE_PCRE2 + pcre2_code_free(pattern->pattern.url_spec.host_regex); +#else regfree(pattern->pattern.url_spec.host_regex); freez(pattern->pattern.url_spec.host_regex); +#endif } #endif /* def FEATURE_PCRE_HOST_PATTERNS */ freez(pattern->pattern.url_spec.dbuffer); @@ -1287,8 +1433,12 @@ void free_pattern_spec(struct pattern_sp freez(pattern->pattern.url_spec.port_list); if (pattern->pattern.url_spec.preg) { +#ifdef HAVE_PCRE2 + pcre2_code_free(pattern->pattern.url_spec.preg); +#else regfree(pattern->pattern.url_spec.preg); freez(pattern->pattern.url_spec.preg); +#endif } } @@ -1333,8 +1483,13 @@ static int host_matches(const struct htt if (pattern->pattern.url_spec.host_regex_type == PCRE_HOST_PATTERN) { return ((NULL == pattern->pattern.url_spec.host_regex) +#ifdef HAVE_PCRE2 + || pcre2_pattern_matches(pattern->pattern.url_spec.host_regex, + http->host)); +#else || (0 == regexec(pattern->pattern.url_spec.host_regex, http->host, 0, NULL, 0))); +#endif } #endif return ((NULL == pattern->pattern.url_spec.dbuffer) || (0 == domain_match(pattern, http))); @@ -1357,7 +1512,11 @@ static int host_matches(const struct htt static int path_matches(const char *path, const struct pattern_spec *pattern) { return ((NULL == pattern->pattern.url_spec.preg) +#ifdef HAVE_PCRE2 + || (pcre2_pattern_matches(pattern->pattern.url_spec.preg, path))); +#else || (0 == regexec(pattern->pattern.url_spec.preg, path, 0, NULL, 0))); +#endif } --- a/urlmatch.h +++ b/urlmatch.h @@ -50,6 +50,10 @@ extern int url_requires_percent_encoding extern int url_match(const struct pattern_spec *pattern, const struct http_request *http); +#ifdef HAVE_PCRE2 +extern int pcre2_pattern_matches(const pcre2_code *pattern, const char *string); +#endif + extern jb_err create_pattern_spec(struct pattern_spec *url, char *buf); extern void free_pattern_spec(struct pattern_spec *url); extern int match_portlist(const char *portlist, int port); --- a/w32log.c +++ b/w32log.c @@ -316,6 +316,9 @@ void TermLogWindow(void) void LogCreatePatternMatchingBuffers(void) { int i; +#ifdef HAVE_PCRE2 +#warning The win32 build of Privoxy is expected to crash when compiled with pcre2 support. +#endif for (i = 0; patterns_to_highlight[i].str != NULL; i++) { regcomp(&patterns_to_highlight[i].buffer, patterns_to_highlight[i].str, REG_ICASE);