Fixing potential problems with characters >=128 in simplematch()
[privoxy.git] / miscutil.c
1 const char miscutil_rcs[] = "$Id: miscutil.c,v 1.16 2001/09/10 10:56:59 oes Exp $";
2 /*********************************************************************
3  *
4  * File        :  $Source: /cvsroot/ijbswa/current/miscutil.c,v $
5  *
6  * Purpose     :  zalloc, hash_string, safe_strerror, strcmpic,
7  *                strncmpic, strsav, chomp, and MinGW32 strdup
8  *                functions. 
9  *                These are each too small to deserve their own file
10  *                but don't really fit in any other file.
11  *
12  * Copyright   :  Written by and Copyright (C) 2001 the SourceForge
13  *                IJBSWA team.  http://ijbswa.sourceforge.net
14  *
15  *                Based on the Internet Junkbuster originally written
16  *                by and Copyright (C) 1997 Anonymous Coders and 
17  *                Junkbusters Corporation.  http://www.junkbusters.com
18  *
19  *                This program is free software; you can redistribute it 
20  *                and/or modify it under the terms of the GNU General
21  *                Public License as published by the Free Software
22  *                Foundation; either version 2 of the License, or (at
23  *                your option) any later version.
24  *
25  *                This program is distributed in the hope that it will
26  *                be useful, but WITHOUT ANY WARRANTY; without even the
27  *                implied warranty of MERCHANTABILITY or FITNESS FOR A
28  *                PARTICULAR PURPOSE.  See the GNU General Public
29  *                License for more details.
30  *
31  *                The GNU General Public License should be included with
32  *                this file.  If not, you can view it at
33  *                http://www.gnu.org/copyleft/gpl.html
34  *                or write to the Free Software Foundation, Inc., 59
35  *                Temple Place - Suite 330, Boston, MA  02111-1307, USA.
36  *
37  * Revisions   :
38  *    $Log: miscutil.c,v $
39  *    Revision 1.16  2001/09/10 10:56:59  oes
40  *    Silenced compiler warnings
41  *
42  *    Revision 1.15  2001/07/13 14:02:24  oes
43  *    Removed vim-settings
44  *
45  *    Revision 1.14  2001/06/29 21:45:41  oes
46  *    Indentation, CRLF->LF, Tab-> Space
47  *
48  *    Revision 1.13  2001/06/29 13:32:14  oes
49  *    Removed logentry from cancelled commit
50  *
51  *    Revision 1.12  2001/06/09 10:55:28  jongfoster
52  *    Changing BUFSIZ ==> BUFFER_SIZE
53  *
54  *    Revision 1.11  2001/06/07 23:09:19  jongfoster
55  *    Cosmetic indentation changes.
56  *
57  *    Revision 1.10  2001/06/07 14:51:38  joergs
58  *    make_path() no longer adds '/' if the dir already ends in '/'.
59  *
60  *    Revision 1.9  2001/06/07 14:43:17  swa
61  *    slight mistake in make_path, unix path style is /.
62  *
63  *    Revision 1.8  2001/06/05 22:32:01  jongfoster
64  *    New function make_path() to splice directory and file names together.
65  *
66  *    Revision 1.7  2001/06/03 19:12:30  oes
67  *    introduced bindup()
68  *
69  *    Revision 1.6  2001/06/01 18:14:49  jongfoster
70  *    Changing the calls to strerr() to check HAVE_STRERR (which is defined
71  *    in config.h if appropriate) rather than the NO_STRERR macro.
72  *
73  *    Revision 1.5  2001/06/01 10:31:51  oes
74  *    Added character class matching to trivimatch; renamed to simplematch
75  *
76  *    Revision 1.4  2001/05/31 17:32:31  oes
77  *
78  *     - Enhanced domain part globbing with infix and prefix asterisk
79  *       matching and optional unanchored operation
80  *
81  *    Revision 1.3  2001/05/29 23:10:09  oes
82  *
83  *
84  *     - Introduced chomp()
85  *     - Moved strsav() from showargs to miscutil
86  *
87  *    Revision 1.2  2001/05/29 09:50:24  jongfoster
88  *    Unified blocklist/imagelist/permissionslist.
89  *    File format is still under discussion, but the internal changes
90  *    are (mostly) done.
91  *
92  *    Also modified interceptor behaviour:
93  *    - We now intercept all URLs beginning with one of the following
94  *      prefixes (and *only* these prefixes):
95  *        * http://i.j.b/
96  *        * http://ijbswa.sf.net/config/
97  *        * http://ijbswa.sourceforge.net/config/
98  *    - New interceptors "home page" - go to http://i.j.b/ to see it.
99  *    - Internal changes so that intercepted and fast redirect pages
100  *      are not replaced with an image.
101  *    - Interceptors now have the option to send a binary page direct
102  *      to the client. (i.e. ijb-send-banner uses this)
103  *    - Implemented show-url-info interceptor.  (Which is why I needed
104  *      the above interceptors changes - a typical URL is
105  *      "http://i.j.b/show-url-info?url=www.somesite.com/banner.gif".
106  *      The previous mechanism would not have intercepted that, and
107  *      if it had been intercepted then it then it would have replaced
108  *      it with an image.)
109  *
110  *    Revision 1.1.1.1  2001/05/15 13:59:00  oes
111  *    Initial import of version 2.9.3 source tree
112  *
113  *
114  *********************************************************************/
115 \f
116
117 #include "config.h"
118
119 #include <stdio.h>
120 #include <stdlib.h>
121 #include <string.h>
122 #include <malloc.h>
123 #include <ctype.h>
124
125 /*
126  * FIXME: Only need project.h for BUFFER_SIZE.  It would be nice
127  * to remove this dependency.
128  */
129 #include "project.h"
130 #include "miscutil.h"
131 #include "errlog.h"
132
133 const char miscutil_h_rcs[] = MISCUTIL_H_VERSION;
134
135 /* Fix a problem with Solaris.  There should be no effect on other
136  * platforms.
137  * Solaris's isspace() is a macro which uses it's argument directly
138  * as an array index.  Therefore we need to make sure that high-bit
139  * characters generate +ve values, and ideally we also want to make
140  * the argument match the declared parameter type of "int".
141  */
142 #define ijb_tolower(__X) tolower((int)(unsigned char)(__X))
143 #define ijb_isspace(__X) isspace((int)(unsigned char)(__X))   
144
145 /*********************************************************************
146  *
147  * Function    :  zalloc
148  *
149  * Description :  Malloc some memory and set it to '\0'.
150  *                The way calloc() ought to be -acjc
151  *
152  * Parameters  :
153  *          1  :  size = Size of memory chunk to return.
154  *
155  * Returns     :  Pointer to newly malloc'd memory chunk.
156  *
157  *********************************************************************/
158 void *zalloc(int size)
159 {
160    void * ret;
161
162    if ((ret = (void *)malloc(size)) != NULL)
163    {
164       memset(ret, 0, size);
165    }
166
167    return(ret);
168 }
169
170
171 /*********************************************************************
172  *
173  * Function    :  hash_string
174  *
175  * Description :  Take a string and compute a (hopefuly) unique numeric
176  *                integer value.  This has several uses, but being able
177  *                to "switch" a string the one of my favorites.
178  *
179  * Parameters  :
180  *          1  :  s : string to be hashed.
181  *
182  * Returns     :  an unsigned long variable with the hashed value.
183  *
184  *********************************************************************/
185 unsigned long hash_string( const char* s )
186 {
187    unsigned long h = 0ul; 
188
189    for ( ; *s; ++s )
190    {
191       h = 5 * h + *s;
192    }
193
194    return (h);
195
196 }
197
198
199 #ifdef __MINGW32__
200 /*********************************************************************
201  *
202  * Function    :  strdup
203  *
204  * Description :  For some reason (which is beyond me), gcc and WIN32
205  *                don't like strdup.  When a "free" is executed on a
206  *                strdup'd ptr, it can at times freez up!  So I just
207  *                replaced it and problem was solved.
208  *
209  * Parameters  :
210  *          1  :  s = string to duplicate
211  *
212  * Returns     :  Pointer to newly malloc'ed copy of the string.
213  *
214  *********************************************************************/
215 char *strdup( const char *s )
216 {
217    char * result = (char *)malloc( strlen(s)+1 );
218
219    if (result != NULL)
220    {
221       strcpy( result, s );
222    }
223
224    return( result );
225 }
226
227 #endif /* def __MINGW32__ */
228
229
230
231 /*********************************************************************
232  *
233  * Function    :  safe_strerror
234  *
235  * Description :  Variant of the library routine strerror() which will
236  *                work on systems without the library routine, and
237  *                which should never return NULL.
238  *
239  * Parameters  :
240  *          1  :  err = the `errno' of the last operation.
241  *
242  * Returns     :  An "English" string of the last `errno'.  Allocated
243  *                with strdup(), so caller frees.  May be NULL if the
244  *                system is out of memory.
245  *
246  *********************************************************************/
247 char *safe_strerror(int err)
248 {
249    char *s = NULL;
250    char buf[BUFFER_SIZE];
251
252
253 #ifdef HAVE_STRERROR
254    s = strerror(err);
255 #endif /* HAVE_STRERROR */
256
257    if (s == NULL)
258    {
259       sprintf(buf, "(errno = %d)", err);
260       s = buf;
261    }
262
263    return(strdup(s));
264
265 }
266
267
268 /*********************************************************************
269  *
270  * Function    :  strcmpic
271  *
272  * Description :  Case insensitive string comparison
273  *
274  * Parameters  :
275  *          1  :  s1 = string 1 to compare
276  *          2  :  s2 = string 2 to compare
277  *
278  * Returns     :  0 if s1==s2, Negative if s1<s2, Positive if s1>s2
279  *
280  *********************************************************************/
281 int strcmpic(const char *s1, const char *s2)
282 {
283    while (*s1 && *s2)
284    {
285       if ( ( *s1 != *s2 ) && ( ijb_tolower(*s1) != ijb_tolower(*s2) ) )
286       {
287          break;
288       }
289       s1++, s2++;
290    }
291    return(ijb_tolower(*s1) - ijb_tolower(*s2));
292
293 }
294
295
296 /*********************************************************************
297  *
298  * Function    :  strncmpic
299  *
300  * Description :  Case insensitive string comparison (upto n characters)
301  *
302  * Parameters  :
303  *          1  :  s1 = string 1 to compare
304  *          2  :  s2 = string 2 to compare
305  *          3  :  n = maximum characters to compare
306  *
307  * Returns     :  0 if s1==s2, Negative if s1<s2, Positive if s1>s2
308  *
309  *********************************************************************/
310 int strncmpic(const char *s1, const char *s2, size_t n)
311 {
312    if (n <= 0) return(0);
313
314    while (*s1 && *s2)
315    {
316       if ( ( *s1 != *s2 ) && ( ijb_tolower(*s1) != ijb_tolower(*s2) ) )
317       {
318          break;
319       }
320
321       if (--n <= 0) break;
322
323       s1++, s2++;
324    }
325    return(ijb_tolower(*s1) - ijb_tolower(*s2));
326
327 }
328
329
330 /*********************************************************************
331  *
332  * Function    :  chomp
333  *
334  * Description :  In-situ-eliminate all leading and trailing whitespace
335  *                from a string.
336  *
337  * Parameters  :
338  *          1  :  s : string to be chomped.
339  *
340  * Returns     :  chomped string
341  *
342  *********************************************************************/
343 char *chomp(char *string)
344 {
345    char *p, *q, *r;
346
347    /* 
348     * strip trailing whitespace
349     */
350    p = string + strlen(string);
351    while (p > string && ijb_isspace(*(p-1)))
352    {
353       p--;
354    }
355    *p = '\0';
356
357    /* 
358     * find end of leading whitespace 
359     */
360    q = r = string;
361    while (*q && ijb_isspace(*q))
362    {
363       q++;
364    }
365
366    /*
367     * if there was any, move the rest forwards
368     */
369    if (q != string)
370    {
371       while (q <= p)
372       {
373          *r++ = *q++;
374       }
375    }
376
377    return(string);
378
379 }
380
381 /*********************************************************************
382  *
383  * Function    :  strsav
384  *
385  * Description :  Reallocate "old" and append text to it.  This makes
386  *                it easier to append to malloc'd strings.
387  *
388  * Parameters  :
389  *          1  :  old = Old text that is to be extended.  Will be
390  *                free()d by this routine.
391  *          2  :  text_to_append = Text to be appended to old.
392  *
393  * Returns     :  Pointer to newly malloc'ed appended string.
394  *                If there is no text to append, return old.  Caller
395  *                must free().
396  *
397  *********************************************************************/
398 char *strsav(char *old, const char *text_to_append)
399 {
400    int old_len, new_len;
401    char *p;
402
403    if (( text_to_append == NULL) || (*text_to_append == '\0'))
404    {
405       return(old);
406    }
407
408    if (NULL != old)
409    {
410       old_len = strlen(old);
411    }
412    else
413    {
414       old_len = 0;
415    }
416
417    new_len = old_len + strlen(text_to_append) + 1;
418
419    if (old)
420    {
421       if ((p = realloc(old, new_len)) == NULL)
422       {
423          log_error(LOG_LEVEL_FATAL, "realloc(%d) bytes failed!", new_len);
424          /* Never get here - LOG_LEVEL_FATAL causes program exit */
425       }
426    }
427    else
428    {
429       if ((p = (char *)malloc(new_len)) == NULL)
430       {
431          log_error(LOG_LEVEL_FATAL, "malloc(%d) bytes failed!", new_len);
432          /* Never get here - LOG_LEVEL_FATAL causes program exit */
433       }
434    }
435
436    strcpy(p + old_len, text_to_append);
437    return(p);
438
439 }
440
441
442 /*********************************************************************
443  *
444  * Function    :  simplematch
445  *
446  * Description :  String matching, with a (greedy) '*' wildcard that
447  *                stands for zero or more arbitrary characters and
448  *                character classes in [], which take both enumerations
449  *                and ranges.
450  *
451  * Parameters  :
452  *          1  :  pattern = pattern for matching
453  *          2  :  text    = text to be matched
454  *
455  * Returns     :  0 if match, else nonzero
456  *
457  *********************************************************************/
458 int simplematch(char *pattern, char *text)
459 {
460    unsigned char *pat = (unsigned char *) pattern;
461    unsigned char *txt = (unsigned char *) text;
462    unsigned char *fallback = pat; 
463    int wildcard = 0;
464   
465    unsigned char lastchar = 'a';
466    unsigned i;
467    unsigned char charmap[32];
468   
469   
470    while (*txt)
471    {
472
473       /* EOF pattern but !EOF text? */
474       if (*pat == '\0')
475       {
476          return 1;
477       }
478
479       /* '*' in the pattern?  */
480       if (*pat == '*') 
481       {
482      
483          /* The pattern ends afterwards? Speed up the return. */
484          if (*++pat == '\0')
485          {
486             return 0;
487          }
488      
489          /* Else, set wildcard mode and remember position after '*' */
490          wildcard = 1;
491          fallback = pat;
492       }
493
494       /* Character range specification? */
495       if (*pat == '[')
496       {
497          memset(charmap, '\0', sizeof(charmap));
498
499          while (*++pat != ']')
500          {
501             if (!*pat)
502             { 
503                return 1;
504             }
505             else if (*pat == '-')
506             {
507                if ((*++pat == ']') || *pat == '\0')
508                {
509                   return(1);
510                }
511                for(i = lastchar; i <= *pat; i++)
512                {
513                   charmap[i / 8] |= (1 << (i % 8));
514                } 
515             }
516             else
517             {
518                charmap[*pat / 8] |= (1 << (*pat % 8));
519                lastchar = *pat;
520             }
521          }
522       } /* -END- if Character range specification */
523
524
525       /* Compare: Char match, or char range match*/
526       if ((*pat == *txt)  
527       || ((*pat == ']') && (charmap[*txt / 8] & (1 << (*txt % 8)))) )
528       {
529          /* Sucess, go ahead */
530          pat++;
531       }
532       else
533       {
534          /* In wildcard mode, just try again after failiure */
535          if(wildcard)
536          {
537             pat = fallback;
538          }
539
540          /* Else, bad luck */
541          else
542          {
543             return 1;
544          }
545       }
546       txt++;
547    }
548
549    /* Cut off extra '*'s */
550    if(*pat == '*')  pat++;
551
552    /* If this is the pattern's end, fine! */
553    return(*pat);
554
555 }
556
557
558 /*********************************************************************
559  *
560  * Function    :  bindup
561  *
562  * Description :  Duplicate the first n characters of a string that may
563  *                contain '\0' characters.
564  *
565  * Parameters  :
566  *          1  :  string = string to be duplicated
567  *          2  :  n = number of bytes to duplicate
568  *
569  * Returns     :  pointer to copy, or NULL if failiure
570  *
571  *********************************************************************/
572 char *bindup(const char *string, int n)
573 {
574    char *dup;
575
576    if (NULL == (dup = (char *)malloc(n)))
577    {
578       return NULL;
579    }
580    else
581    {
582      memcpy(dup, string, n);
583    }
584
585    return dup;
586
587 }
588
589
590 /*********************************************************************
591  *
592  * Function    :  make_path
593  *
594  * Description :  Takes a directory name and a file name, returns 
595  *                the complete path.  Handles windows/unix differences.
596  *                If the file name is already an absolute path, or if
597  *                the directory name is NULL or empty, it returns 
598  *                the filename. 
599  *
600  * Parameters  :
601  *          1  :  dir: Name of directory or NULL for none.
602  *          2  :  file: Name of file.  Should not be NULL or empty.
603  *
604  * Returns     :  "dir/file" (Or on windows, "dir\file").
605  *                It allocates the string on the heap.  Caller frees.
606  *                Returns NULL in error (i.e. NULL file or out of
607  *                memory) 
608  *
609  *********************************************************************/
610 char * make_path(const char * dir, const char * file)
611 {
612 #ifdef AMIGA
613    char path[512];
614
615    if(dir)
616    {
617       strncpy(path,dir,512);
618       path[511]=0;
619    } else {
620       path[0]=0;
621    }
622    if(AddPart(path,file,512))
623    {
624       return strdup(path);
625    } else {
626       return NULL;
627    }
628 #else /* ndef AMIGA */
629
630    if ((file == NULL) || (*file == '\0'))
631    {
632       return NULL; /* Error */
633    }
634
635    if ((dir == NULL) || (*dir == '\0') /* No directory specified */
636 #ifdef _WIN32
637       || (*file == '\\') || (file[1] == ':') /* Absolute path (DOS) */
638 #else /* ifndef _WIN32 */
639       || (*file == '/') /* Absolute path (U*ix) */
640 #endif /* ifndef _WIN32 */
641       )
642    {
643       return strdup(file);
644    }
645    else
646    {
647       char * path = malloc(strlen(dir) + strlen(file) + 2);
648       strcpy(path, dir);
649 #ifdef _WIN32
650       strcat(path, "\\");
651 #else /* ifndef _WIN32 */
652       if(path[strlen(path)-1] != '/') strcat(path, "/");
653 #endif /* ifndef _WIN32 */
654       strcat(path, file);
655
656       return path;
657    }
658 #endif /* ndef AMIGA */
659 }
660
661
662 /*
663   Local Variables:
664   tab-width: 3
665   end:
666 */