Deleted config.h and pcrs/chartables.h because they are auto
[privoxy.git] / pcrs.c
1 const char pcrs_rcs[] = "$Id: pcrs.c,v 1.1.1.1 2001/05/15 13:59:02 oes Exp $";
2
3 /*********************************************************************
4  *
5  * File        :  $Source: /cvsroot/ijbswa/current/pcrs.c,v $
6  *
7  * Purpose     :  This is the alpha release of libpcrs. It is only published
8  *                at this early stage of development, because it is
9  *                needed for a new feature in JunkBuster.
10  *
11  *                While no inconsistencies, memory leaks or functional bugs
12  *                are known at this time, there *could* be plenty ;-). Also,
13  *                Many pcre-specific options are not yet supported, and
14  *                error handling needs improvement.
15  *
16  *                pcrs is a supplement to the brilliant pcre library by Philip
17  *                Hazel (ph10@cam.ac.uk) and adds Perl-style substitution. That
18  *                is, it mimics Perl's 's' operator.
19  *
20  *                Currently, there's no documentation besides comments and the
21  *                source itself ;-)
22  *
23  * Copyright   :  Written and Copyright (C) 2000 by Andreas Oesterhelt
24  *                <andreas@oesterhelt.org>
25  *
26  *                This program is free software; you can redistribute it 
27  *                and/or modify it under the terms of the GNU General
28  *                Public License as published by the Free Software
29  *                Foundation; either version 2 of the License, or (at
30  *                your option) any later version.
31  *
32  *                This program is distributed in the hope that it will
33  *                be useful, but WITHOUT ANY WARRANTY; without even the
34  *                implied warranty of MERCHANTABILITY or FITNESS FOR A
35  *                PARTICULAR PURPOSE.  See the GNU General Public
36  *                License for more details.
37  *
38  *                The GNU General Public License should be included with
39  *                this file.  If not, you can view it at
40  *                http://www.gnu.org/copyleft/gpl.html
41  *                or write to the Free Software Foundation, Inc., 59
42  *                Temple Place - Suite 330, Boston, MA  02111-1307, USA.
43  *
44  * Revisions   :
45  *    $Log: pcrs.c,v $
46  *    Revision 1.1.1.1  2001/05/15 13:59:02  oes
47  *    Initial import of version 2.9.3 source tree
48  *
49  *
50  *********************************************************************/
51 \f
52
53 #include <pcre.h>
54 #include <string.h>
55 #include "pcrs.h"
56 const char pcrs_h_rcs[] = PCRS_H_VERSION;
57
58
59 /*********************************************************************
60  *
61  * Function    :  my_strsep
62  *
63  * Description :  Convenience function. It acts like strsep, except that
64  *                it respects quoting of the delimiter character with the
65  *                quote character. (And, of course, quoting the quote char
66  *                with itself.)  Called from `pcrs_make_job'.
67  *
68  * Parameters  :
69  *          1  :  token = current token
70  *          2  :  text = string to tokenize
71  *          3  :  delimiter = single character deliminter
72  *          4  :  quote_char = character to cause quoting
73  *
74  * Returns     :  -1 => failure, else the length of the token found.
75  *                In the latter case, *text is the token's start.
76  *
77  *********************************************************************/
78 int my_strsep(char *token, char **text, char delimiter, char quote_char)
79 {
80    int i, k=0, limit, quoted = FALSE;
81
82    limit = strlen(*text);
83    if ( 0 == limit )
84    {
85       return -1;
86    }
87
88    token[0] = '\0';
89
90    for (i=0; i < limit; i++)
91    {
92       if (text[0][i] == delimiter && !quoted)
93       {
94          *text += 1;
95          break;
96       }
97       else if (text[0][i] == quote_char && !quoted && i+1 < limit && text[0][i+1] == delimiter)
98       {
99          quoted = TRUE;
100          continue;
101       }
102       token[k++] = text[0][i];
103       quoted = FALSE;
104    }
105    token[k] = '\0';
106    *text += i;
107    return k;
108
109 }
110
111
112 /*********************************************************************
113  *
114  * Function    :  pcrs_compile_perl_options
115  *
116  * Description :  This function parses a string containing the options to
117  *                Perl's s/// operator. It returns an integer that is the
118  *                pcre equivalent of the symbolic optstring.
119  *                Since pcre doesn't know about Perl's 'g' (global) option,
120  *                but pcrs needs it, the globalflag integer is set if 'g'
121  *                is encountered.
122  *
123  * Parameters  :
124  *          1  :  optstring = string with options in perl syntax
125  *          2  :  globalflag = see description
126  *
127  * Returns     :  option integer suitable for pcre 
128  *
129  *********************************************************************/
130 int pcrs_compile_perl_options(char *optstring, int *globalflag)
131 {
132    int i, rc = 0;
133    *globalflag = 0;
134    for (i=0; i < strlen(optstring); i++)
135    {
136       switch(optstring[i])
137       {
138          case 'e': break;
139          case 'g': *globalflag = 1; break;
140          case 'i': rc |= PCRE_CASELESS; break;
141          case 'm': rc |= PCRE_MULTILINE; break;
142          case 'o': break;
143          case 's': rc |= PCRE_DOTALL; break;
144          case 'x': rc |= PCRE_EXTENDED; break;
145          case 'U': rc |= PCRE_UNGREEDY; break;
146          default:  break;
147       }
148    }
149    return rc;
150
151 }
152
153
154 /*********************************************************************
155  *
156  * Function    :  pcrs_compile_replacement
157  *
158  * Description :  This function takes a Perl-style replacement (2nd argument
159  *                to the s/// operator and returns a compiled pcrs_substitute,
160  *                or NULL if memory allocation for the substitute structure
161  *                fails.
162  *
163  * Parameters  :
164  *          1  :  replacement = replacement part of s/// operator
165  *                              in perl syntax
166  *          2  :  errptr = pointer to an integer in which error
167  *                         conditions can be returned.
168  *
169  * Returns     :  pcrs_substitute data structure, or NULL if an
170  *                error is encountered. In that case, *errptr has
171  *                the reason.
172  *
173  *********************************************************************/
174 pcrs_substitute *pcrs_compile_replacement(char *replacement, int *errptr)
175 {
176    int length, i, k = 0, l = 0, quoted = 0, idx;
177    char *text, *num_ptr, *numbers = "0123456789";
178    pcrs_substitute *r;
179
180    r = (pcrs_substitute *)malloc(sizeof(pcrs_substitute));
181    if (r == NULL) return NULL;
182    memset(r, '\0', sizeof(pcrs_substitute));
183
184    text = strdup(replacement);      /* must be free()d by caller */
185    if (text  == NULL)
186    {
187       *errptr = PCRS_ERR_NOMEM;
188       free(r);
189       return NULL;
190    }
191
192    length = strlen(replacement);
193
194    for (i=0; i < length; i++)
195    {
196       /* Backslash treatment */
197       if (replacement[i] == '\\')
198       {
199          if (quoted)
200          {
201             text[k++] = replacement[i];
202             quoted = 0;
203          }
204          else
205          {
206             quoted = 1;
207          }
208          continue;
209       }
210
211       /* Dollar treatment */
212       if (replacement[i] == '$' && !quoted && i < length - 1)
213       {
214          if (strchr("0123456789&", replacement[i + 1]) == NULL)
215          {
216             text[k++] = replacement[i];
217          }
218          else
219          {
220             r->block_length[l] = k - r->block_offset[l];
221             r->backref[l] = 0;
222             if (replacement[i + 1] != '&')
223             {
224                while ((num_ptr = strchr(numbers, replacement[++i])) != NULL && i < length)
225                {
226                   idx = num_ptr - numbers;
227                   r->backref[l] = r->backref[l] * 10 + idx;
228                }
229                i--;
230             }
231             else
232                i++;
233             if (r->backref[l] < PCRS_MAX_SUBMATCHES)
234                r->backref_count[r->backref[l]] += 1;
235             l++;
236             r->block_offset[l] = k;
237          }
238          continue;
239       }
240
241       /* Plain char treatment */
242       text[k++] = replacement[i];
243       quoted = 0;
244    }
245
246    text[k] = '\0';
247    r->text = text;
248    r->backrefs = l;
249    r->block_length[l] = k - r->block_offset[l];
250    return r;
251
252 }
253
254
255 /*********************************************************************
256  *
257  * Function    :  pcrs_free_job
258  *
259  * Description :  Frees the memory used by a pcrs_job struct and its
260  *                dependant structures. Returns a pointer to the next
261  *                job, if there was any, or NULL otherwise.
262  *
263  * Parameters  :
264  *          1  :  job = pointer to the pcrs_job structure to be freed
265  *
266  * Returns     : a pointer to the next job, if there was any, or
267  *               NULL otherwise. 
268  *
269  *********************************************************************/
270 pcrs_job *pcrs_free_job(pcrs_job *job)
271 {
272    pcrs_job *next;
273
274    if (job == NULL)
275    {
276       return NULL;
277    }
278    else
279    {
280       next = job->next;
281       if (job->pattern != NULL) free(job->pattern);
282       if (job->hints != NULL) free(job->hints);
283       if (job->substitute != NULL)
284       {
285          if (job->substitute->text != NULL) free(job->substitute->text);
286          free(job->substitute);
287       }
288       free(job);
289    }
290    return next;
291
292 }
293
294
295 /*********************************************************************
296  *
297  * Function    :  pcrs_make_job
298  *
299  * Description :  Main entry point. Takes a string with a Perl-style
300  *                s/// command and returns a corresponding pcrs_job,
301  *                or NULL if compiling the job fails at any stage.
302  *                Diagnostics could obviously be improved.
303  *
304  * Parameters  :
305  *          1  :  command = string with perl-style s/// command
306  *          2  :  errptr = pointer to an integer in which error
307  *                         conditions can be returned.
308  *
309  * Returns     :  a corresponding pcrs_job data structure, or NULL
310  *                if an error was encountered. In that case, *errptr
311  *                has the reason.
312  *
313  *********************************************************************/
314 pcrs_job *pcrs_make_job(char *command, int *errptr)
315 {
316    char *dummy, *token, delimiter;
317    const char *error;
318    int i = 0, globalflag;
319    pcrs_job *newjob;
320
321    /* Get and init memory */
322    if ((newjob = (pcrs_job *)malloc(sizeof(pcrs_job))) == NULL)
323    {
324       *errptr = PCRS_ERR_NOMEM;
325       return NULL;
326    }
327    memset(newjob, '\0', sizeof(pcrs_job));
328
329    /* Command too short? */
330    if (strlen(command) < 4)
331    {
332       *errptr = PCRS_ERR_CMDSYNTAX;
333       pcrs_free_job(newjob);
334       return NULL;
335    }
336
337    /* Split command into tokens and handle them */
338    delimiter = command[1];
339    token = (char *)malloc(strlen(command)); /* current token */
340    dummy = (char *)malloc(strlen(command)); /* must store pattern, since we can't */
341                                             /* use it until the options are known */
342    while (my_strsep(token, &command, delimiter, '\\') >= 0)
343    {
344       switch (i)
345       {
346   /* We don't care about the command and assume 's' */
347          case 0:
348             break;
349
350          /* The pattern */
351          case 1:
352             strcpy(dummy, token);
353             break;
354
355          /* The substitute */
356          case 2:
357             newjob->substitute = pcrs_compile_replacement(token, errptr);
358             if (newjob->substitute == NULL)
359             {
360                pcrs_free_job(newjob);
361                return NULL;
362             }
363             break;
364
365          /* The options */
366          case 3:
367             newjob->options = pcrs_compile_perl_options(token, &globalflag);
368             newjob->globalflag = globalflag;
369             break;
370
371          /* There shouldn't be anything else! */
372          default:
373             *errptr = PCRS_ERR_CMDSYNTAX;
374             pcrs_free_job(newjob);
375             return NULL;
376       }
377       i++;
378    }
379    free(token);
380
381    /* Compile the pattern */
382    newjob->pattern = pcre_compile(dummy, newjob->options, &error, errptr, NULL);
383    if (newjob->pattern == NULL)
384    {
385       pcrs_free_job(newjob);
386       return NULL;
387    }
388    free(dummy);
389
390    /*
391     * Generate hints. This has little overhead, since the
392     * hints will be NULL for a boring pattern anyway.
393     */
394    newjob->hints = pcre_study(newjob->pattern, 0, &error);
395    if (error != NULL)
396    {
397       *errptr = PCRS_ERR_STUDY;
398       pcrs_free_job(newjob);
399       return NULL;
400    }
401
402    return newjob;
403
404 }
405
406
407 /*********************************************************************
408  *
409  * Function    :  create_pcrs_job
410  *
411  * Description :  Create a job from all its components, if you don't
412  *                have a Perl command to start from. Rather boring.
413  *
414  * Parameters  :
415  *          1  :  pattern = pointer to pcre pattern
416  *          2  :  hints = pointer to pcre hints
417  *          3  :  options = options in pcre format
418  *          4  :  globalflag = flag that indicates if global matching is desired
419  *          5  :  substitute = pointer to pcrs_substitute data structure
420  *          2  :  errptr = pointer to an integer in which error
421  *                         conditions can be returned.
422  *
423  * Returns     :  pcrs_job structure, or NULL if an error was encountered.
424  *                In that case, *errptr has the reason why.
425  *
426  *********************************************************************/
427 pcrs_job *create_pcrs_job(pcre *pattern, pcre_extra *hints, int options, int globalflag, pcrs_substitute *substitute, int *errptr)
428 {
429    pcrs_job *newjob;
430
431    if ((newjob = (pcrs_job *)malloc(sizeof(pcrs_job))) == NULL)
432    {
433       *errptr = PCRS_ERR_NOMEM;
434       return NULL;
435    }
436    memset(newjob, '\0', sizeof(pcrs_job));
437
438    newjob->pattern = pattern;
439    newjob->hints = hints;
440    newjob->options = options;
441    newjob->globalflag = globalflag;
442    newjob->substitute = substitute;
443
444    return(newjob);
445
446 }
447
448
449 /*********************************************************************
450  *
451  * Function    :  pcrs_exec_substitution
452  *
453  * Description :  Modify the subject by executing the regular substitution
454  *                defined by the job. Since the result may be longer than
455  *                the subject, its space requirements are precalculated in
456  *                the matching phase and new memory is allocated accordingly.
457  *                It is the caller's responsibility to free the result when
458  *                it's no longer needed.
459  *
460  * Parameters  :
461  *          1  :  job = the pcrs_job to be executed
462  *          2  :  subject = the subject (== original) string
463  *          3  :  subject_length = the subject's length
464  *          4  :  result = char** for returning  the result 
465  *          5  :  result_length = int* for returning the result's length
466  *
467  * Returns     :  the number of substitutions that were made. May be > 1
468  *                if job->globalflag was set
469  *
470  *********************************************************************/
471 int pcrs_exec_substitution(pcrs_job *job, char *subject, int subject_length, char **result, int *result_length)
472 {
473    int offsets[3 * PCRS_MAX_SUBMATCHES],
474       offset = 0, i=0, k, matches_found, newsize, submatches;
475    pcrs_match matches[PCRS_MAX_MATCHES];
476    char *result_offset;
477
478    newsize=subject_length;
479
480    /* Find.. */
481    while ((submatches = pcre_exec(job->pattern, job->hints, subject, subject_length, offset, 0, offsets, 99)) > 0)
482    {
483       matches[i].submatches = submatches;
484       for (k=0; k < submatches; k++)
485       {
486          matches[i].submatch_offset[k] = offsets[2 * k];
487          matches[i].submatch_length[k] = offsets[2 * k + 1] - offsets[2 * k]; /* Non-found optional submatches have length -1-(-1)==0 */
488          newsize += matches[i].submatch_length[k] * job->substitute->backref_count[k]; /* reserve mem for each submatch as often as it is ref'd */
489       }
490       newsize += strlen(job->substitute->text) - matches[i].submatch_length[0]; /* plus replacement text size minus match text size */
491
492       /* Non-global search or limit reached? */
493       if (++i >= PCRS_MAX_MATCHES || !job->globalflag ) break;
494
495       /* Don't loop on empty matches */
496       if (offsets[1] == offset)
497          if (offset < subject_length)
498             offset++;
499          else
500             break;
501       /* Go find the next one */
502       else
503          offset = offsets[1];
504    }
505    if (submatches < -1) return submatches;   /* Pass pcre error through */
506    matches_found = i;
507
508    /* ..get memory ..*/
509    if ((*result = (char *)malloc(newsize)) == NULL)   /* must be free()d by caller */
510    {
511       return PCRS_ERR_NOMEM;
512    }
513
514    /* ..and replace */
515    offset = 0;
516    result_offset = *result;
517
518    for (i=0; i < matches_found; i++)
519    {
520       memcpy(result_offset, subject + offset, matches[i].submatch_offset[0] - offset); /* copy the chunk preceding the match */
521       result_offset += matches[i].submatch_offset[0] - offset;
522
523       /* For every segment of the substitute.. */
524       for (k=0; k <= job->substitute->backrefs; k++)
525       {
526          /* ...copy its text.. */
527          memcpy(result_offset, job->substitute->text + job->substitute->block_offset[k], job->substitute->block_length[k]);
528          result_offset += job->substitute->block_length[k];
529
530          /* ..plus, if it's not the last chunk (i.e.: There IS a backref).. */
531          if (k != job->substitute->backrefs
532              /* ..and a nonempty match.. */
533              && matches[i].submatch_length[job->substitute->backref[k]] > 0
534              /* ..and in legal range, ... */
535              && job->substitute->backref[k] <= PCRS_MAX_SUBMATCHES)
536          {
537             /* copy the submatch that is ref'd. */
538             memcpy(
539                result_offset,
540                subject + matches[i].submatch_offset[job->substitute->backref[k]],
541                matches[i].submatch_length[job->substitute->backref[k]]
542             );
543             result_offset += matches[i].submatch_length[job->substitute->backref[k]];
544          }
545       }
546       offset =  matches[i].submatch_offset[0] + matches[i].submatch_length[0];
547    }
548
549    /* Copy the rest. */
550    memcpy(result_offset, subject + offset, subject_length - offset);
551
552    *result_length = newsize;
553    return matches_found;
554
555 }
556
557
558 /*
559   Local Variables:
560   tab-width: 3
561   end:
562 */