-const char pcrs_rcs[] = "$Id: pcrs.c,v 1.36 2011/03/03 14:49:08 fabiankeil Exp $";
/*********************************************************************
*
* File : $Source: /cvsroot/ijbswa/current/pcrs.c,v $
*
* Copyright (C) 2006, 2007 Fabian Keil <fk@fabiankeil.de>
*
- * This program is free software; you can redistribute it
+ * This program is free software; you can redistribute it
* and/or modify it under the terms of the GNU Lesser
* General Public License (LGPL), version 2.1, which should
* be included in this distribution (see LICENSE.txt), with
#include "pcrs.h"
-const char pcrs_h_rcs[] = PCRS_H_VERSION;
-
/*
* Internal prototypes
*/
* Function : pcrs_strerror
*
* Description : Return a string describing a given error code.
- *
+ *
* Parameters :
* 1 : error = the error code
*
*********************************************************************/
const char *pcrs_strerror(const int error)
{
+ static char buf[100];
+
if (error != 0)
{
switch (error)
case PCRE_ERROR_UNKNOWN_NODE: return "(pcre:) Bad node in pattern";
/* Can't happen / not passed: */
- case PCRE_ERROR_NOSUBSTRING: return "(pcre:) Fire in power supply";
+ case PCRE_ERROR_NOSUBSTRING: return "(pcre:) Fire in power supply";
case PCRE_ERROR_NOMATCH: return "(pcre:) Water in power supply";
#ifdef PCRE_ERROR_MATCHLIMIT
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: return "Unknown error. Privoxy out of sync with PCRE?";
+ default:
+ snprintf(buf, sizeof(buf),
+ "Error code %d. For details, check the pcre documentation.",
+ error);
+ return buf;
}
}
/* error >= 0: No error */
* 'T' (trivial) options but pcrs needs them, the corresponding
* flags are set if 'g'or 'T' is encountered.
* Note: The 'T' and 'U' options do not conform to Perl.
- *
+ *
* Parameters :
* 1 : optstring = string with options in perl syntax
* 2 : flags = see description
*
- * Returns : option integer suitable for pcre
+ * Returns : option integer suitable for pcre
*
*********************************************************************/
static int pcrs_parse_perl_options(const char *optstring, int *flags)
}
+#ifdef FUZZ
+/*********************************************************************
+ *
+ * Function : pcrs_compile_fuzzed_replacement
+ *
+ * Description : Wrapper around pcrs_compile_replacement() for
+ * fuzzing purposes.
+ *
+ * Parameters :
+ * 1 : replacement = replacement part of s/// operator
+ * in perl syntax
+ * 2 : errptr = pointer to an integer in which error
+ * conditions can be returned.
+ *
+ * Returns : pcrs_substitute data structure, or NULL if an
+ * error is encountered. In that case, *errptr has
+ * the reason.
+ *
+ *********************************************************************/
+extern pcrs_substitute *pcrs_compile_fuzzed_replacement(const char *replacement, int *errptr)
+{
+ int capturecount = PCRS_MAX_SUBMATCHES; /* XXX: fuzzworthy? */
+ int trivial_flag = 0; /* We don't want to fuzz strncpy() */
+
+ *errptr = 0; /* XXX: Should pcrs_compile_replacement() do this? */
+
+ return pcrs_compile_replacement(replacement, trivial_flag, capturecount, errptr);
+
+}
+#endif
+
+
/*********************************************************************
*
* Function : pcrs_compile_replacement
static pcrs_substitute *pcrs_compile_replacement(const char *replacement, int trivialflag, int capturecount, int *errptr)
{
int i, k, l, quoted;
- size_t length;
char *text;
pcrs_substitute *r;
-
+#ifndef FUZZ
+ size_t length;
+#else
+ static size_t length;
+#endif
i = k = l = quoted = 0;
/*
return NULL;
}
memset(text, '\0', length + 1);
-
+
/*
* In trivial mode, just copy the substitute text
*/
const int ascii_value = xtoi(&replacement[i+2]);
- assert(ascii_value > 0);
+ assert(ascii_value >= 0);
assert(ascii_value < 256);
text[k++] = (char)ascii_value;
i += 4;
- }
+ }
else
{
quoted = 1;
if (replacement[i] == '$' && !quoted && i < (int)(length - 1))
{
char *symbol, symbols[] = "'`+&";
+ if (l >= PCRS_MAX_SUBMATCHES)
+ {
+ freez(text);
+ freez(r);
+ *errptr = PCRS_WARN_BADREF;
+ return NULL;
+ }
r->block_length[l] = (size_t)(k - r->block_offset[l]);
/* Numerical backreferences */
}
if (r->backref[l] > capturecount)
{
+ freez(text);
+ freez(r);
*errptr = PCRS_WARN_BADREF;
+ return NULL;
}
}
/* Symbolic backreferences: */
else if (NULL != (symbol = strchr(symbols, replacement[i + 1])))
{
-
+
if (symbol - symbols == 2) /* $+ */
{
r->backref[l] = capturecount;
goto plainchar;
}
+ assert(r->backref[l] < PCRS_MAX_SUBMATCHES + 2);
/* Valid and in range? -> record */
- if (r->backref[l] < PCRS_MAX_SUBMATCHES + 2)
+ if ((0 <= r->backref[l]) &&
+ (r->backref[l] < PCRS_MAX_SUBMATCHES + 2) &&
+ (l < PCRS_MAX_SUBMATCHES - 1))
{
r->backref_count[r->backref[l]] += 1;
r->block_offset[++l] = k;
}
else
{
+ freez(text);
+ freez(r);
*errptr = PCRS_WARN_BADREF;
- }
+ return NULL;
+ }
continue;
}
-
+
plainchar:
/* Plain chars are copied */
text[k++] = replacement[i++];
* 1 : job = pointer to the pcrs_job structure to be freed
*
* Returns : a pointer to the next job, if there was any, or
- * NULL otherwise.
+ * NULL otherwise.
*
*********************************************************************/
pcrs_job *pcrs_free_job(pcrs_job *job)
*********************************************************************/
void pcrs_free_joblist(pcrs_job *joblist)
{
- while ( NULL != (joblist = pcrs_free_job(joblist)) ) {};
+ while (NULL != (joblist = pcrs_free_job(joblist))) {};
return;
*
* Function : pcrs_compile_command
*
- * Description : Parses a string with a Perl-style s/// command,
+ * Description : Parses a string with a Perl-style s/// command,
* calls pcrs_compile, and returns a corresponding
* pcrs_job, or NULL if parsing or compiling the job
* fails.
int i, k, l, quoted = FALSE;
size_t limit;
char delimiter;
- char *tokens[4];
+ char *tokens[4];
pcrs_job *newjob;
-
+
k = l = 0;
-
+
/*
* Tokenize the perl command
*/
for (i = 0; i <= (int)limit; i++)
{
-
+
if (command[i] == delimiter && !quoted)
{
if (l == 3)
tokens[++l] = tokens[0] + k;
continue;
}
-
+
else if (command[i] == '\\' && !quoted)
{
quoted = TRUE;
free(tokens[0]);
return NULL;
}
-
+
newjob = pcrs_compile(tokens[1], tokens[2], tokens[3], errptr);
free(tokens[0]);
return newjob;
-
+
}
*errptr = 0;
- /*
+ /*
* Handle NULL arguments
*/
if (pattern == NULL) pattern = "";
if (substitute == NULL) substitute = "";
- /*
+ /*
* Get and init memory
*/
if (NULL == (newjob = (pcrs_job *)malloc(sizeof(pcrs_job))))
pcrs_free_job(newjob);
return NULL;
}
-
- /*
- * Determine the number of capturing subpatterns.
+
+ /*
+ * Determine the number of capturing subpatterns.
* This is needed for handling $+ in the substitute.
*/
if (0 > (*errptr = pcre_fullinfo(newjob->pattern, newjob->hints, PCRE_INFO_CAPTURECOUNT, &capturecount)))
pcrs_free_job(newjob);
return NULL;
}
-
+
/*
* Compile the substitute
pcrs_free_job(newjob);
return NULL;
}
-
+
return newjob;
}
* the joblist to the subject.
* The subject itself is left untouched, memory for the result
* is malloc()ed and it is the caller's responsibility to free
- * the result when it's no longer needed.
+ * the result when it's no longer needed.
*
* Note: For convenient string handling, a null byte is
* appended to the result. It does not count towards the
* Parameters :
* 1 : joblist = the chained list of pcrs_jobs to be executed
* 2 : subject = the subject string
- * 3 : subject_length = the subject's length
- * 4 : result = char** for returning the result
+ * 3 : subject_length = the subject's length
+ * 4 : result = char** for returning the result
* 5 : result_length = size_t* for returning the result's length
*
* Returns : On success, the number of substitutions that were made.
pcrs_job *job;
char *old, *new = NULL;
int hits, total_hits;
-
+
old = subject;
*result_length = subject_length;
total_hits = 0;
* Parameters :
* 1 : job = the pcrs_job to be executed
* 2 : subject = the subject (== original) string
- * 3 : subject_length = the subject's length
- * 4 : result = char** for returning the result
+ * 3 : subject_length = the subject's length
+ * 4 : result = char** for returning the result (NULL on error)
* 5 : result_length = size_t* for returning the result's length
*
* Returns : On success, the number of substitutions that were made.
char *result_offset;
offset = i = 0;
+ *result = NULL;
- /*
+ /*
* Sanity check & memory allocation
*/
if (job == NULL || job->pattern == NULL || job->substitute == NULL || NULL == subject)
{
- *result = NULL;
return(PCRS_ERR_BADJOB);
}
if (NULL == (matches = (pcrs_match *)malloc((size_t)max_matches * sizeof(pcrs_match))))
{
- *result = NULL;
return(PCRS_ERR_NOMEM);
}
memset(matches, '\0', (size_t)max_matches * sizeof(pcrs_match));
matches[i].submatch_offset[k] = 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]);
+ matches[i].submatch_length[k] = (size_t)(offsets[2 * k + 1] - offsets[2 * k]);
/* reserve mem for each submatch as often as it is ref'd */
newsize += matches[i].submatch_length[k] * (size_t)job->substitute->backref_count[k];
}
/* plus replacement text size minus match text size */
- newsize += job->substitute->length - matches[i].submatch_length[0];
+ newsize += job->substitute->length - matches[i].submatch_length[0];
/* chunk before match */
matches[i].submatch_offset[PCRS_MAX_SUBMATCHES] = 0;
if (NULL == (dummy = (pcrs_match *)realloc(matches, (size_t)max_matches * sizeof(pcrs_match))))
{
free(matches);
- *result = NULL;
return(PCRS_ERR_NOMEM);
}
matches = dummy;
else
offset = offsets[1];
}
- /* Pass pcre error through if (bad) failiure */
+ /* Pass pcre error through if (bad) failure */
if (submatches < PCRE_ERROR_NOMATCH)
{
free(matches);
- return submatches;
+ return submatches;
}
matches_found = i;
- /*
+ /*
* Get memory for the result (must be freed by caller!)
* and append terminating null byte.
*/
}
- /*
+ /*
* Replace
*/
offset = 0;
for (i = 0; i < matches_found; i++)
{
/* copy the chunk preceding the match */
- memcpy(result_offset, subject + offset, (size_t)(matches[i].submatch_offset[0] - offset));
+ memcpy(result_offset, subject + offset, (size_t)(matches[i].submatch_offset[0] - offset));
result_offset += matches[i].submatch_offset[0] - offset;
/* For every segment of the substitute.. */
* Parameters :
* 1 : string = The string to search in
*
- * Returns : A safe delimiter if one was found, otherwise '\0'.
+ * Returns : A safe delimiter if one was found, otherwise '\0'.
*
*********************************************************************/
char pcrs_get_delimiter(const char *string)
* Some characters that are unlikely to
* be part of pcrs replacement strings.
*/
- char delimiters[] = "><§#+*~%^°-:;µ!@";
- char *d = delimiters;
+ static const char delimiters[] = "><#+*~%^-:;!@";
+ const char *d = delimiters;
/* Take the first delimiter that isn't part of the string */
while (*d && NULL != strchr(string, *d))
*
* Parameters :
* 1 : subject = the subject (== original) string
- * 2 : pcrs_command = the pcrs command as string (s@foo@bar@)
- * 3 : hits = int* for returning the number of modifications
+ * 2 : pcrs_command = the pcrs command as string (s@foo@bar@)
+ * 3 : hits = int* for returning the number of modifications
*
* Returns : NULL in case of errors, otherwise the
- * result of the pcrs command.
+ * result of the pcrs command.
*
*********************************************************************/
char *pcrs_execute_single_command(const char *subject, const char *pcrs_command, int *hits)
* 3 : error = pcrs error code
*
* Returns : NULL in case of hard errors, otherwise the
- * compiled pcrs job.
+ * compiled pcrs job.
*
*********************************************************************/
pcrs_job *pcrs_compile_dynamic_command(char *pcrs_command, const struct pcrs_variable v[], int *error)
{
/* No proper delimiter found */
*error = PCRS_ERR_CMDSYNTAX;
+ freez(pcrs_command_tmp);
return NULL;
}
projects / privoxy.git / blobdiff