Moved ijb_isspace and ijb_tolower to project.h
[privoxy.git] / miscutil.c
1 const char miscutil_rcs[] = "$Id: miscutil.c,v 1.21 2001/10/23 21:27:50 jongfoster 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.21  2001/10/23 21:27:50  jongfoster
40  *    Standardising error codes in string_append
41  *    make_path() no longer adds '\\' if the dir already ends in '\\' (this
42  *    is just copying a UNIX-specific fix to the Windows-specific part)
43  *
44  *    Revision 1.20  2001/10/22 15:33:56  david__schmidt
45  *    Special-cased OS/2 out of the Netscape-abort-on-404-in-js problem in
46  *    filters.c.  Added a FIXME in front of the offending code.  I'll gladly
47  *    put in a better/more robust fix for all parties if one is presented...
48  *    It seems that just returning 200 instead of 404 would pretty much fix
49  *    it for everyone, but I don't know all the history of the problem.
50  *
51  *    Revision 1.19  2001/10/14 22:02:57  jongfoster
52  *    New function string_append() which is like strsav(), but running
53  *    out of memory isn't automatically FATAL.
54  *
55  *    Revision 1.18  2001/09/20 13:33:43  steudten
56  *
57  *    change long to int as return value in hash_string(). Remember the wraparound
58  *    for int = long = sizeof(4) - thats maybe not what we want.
59  *
60  *    Revision 1.17  2001/09/13 20:51:29  jongfoster
61  *    Fixing potential problems with characters >=128 in simplematch()
62  *    This was also a compiler warning.
63  *
64  *    Revision 1.16  2001/09/10 10:56:59  oes
65  *    Silenced compiler warnings
66  *
67  *    Revision 1.15  2001/07/13 14:02:24  oes
68  *    Removed vim-settings
69  *
70  *    Revision 1.14  2001/06/29 21:45:41  oes
71  *    Indentation, CRLF->LF, Tab-> Space
72  *
73  *    Revision 1.13  2001/06/29 13:32:14  oes
74  *    Removed logentry from cancelled commit
75  *
76  *    Revision 1.12  2001/06/09 10:55:28  jongfoster
77  *    Changing BUFSIZ ==> BUFFER_SIZE
78  *
79  *    Revision 1.11  2001/06/07 23:09:19  jongfoster
80  *    Cosmetic indentation changes.
81  *
82  *    Revision 1.10  2001/06/07 14:51:38  joergs
83  *    make_path() no longer adds '/' if the dir already ends in '/'.
84  *
85  *    Revision 1.9  2001/06/07 14:43:17  swa
86  *    slight mistake in make_path, unix path style is /.
87  *
88  *    Revision 1.8  2001/06/05 22:32:01  jongfoster
89  *    New function make_path() to splice directory and file names together.
90  *
91  *    Revision 1.7  2001/06/03 19:12:30  oes
92  *    introduced bindup()
93  *
94  *    Revision 1.6  2001/06/01 18:14:49  jongfoster
95  *    Changing the calls to strerr() to check HAVE_STRERR (which is defined
96  *    in config.h if appropriate) rather than the NO_STRERR macro.
97  *
98  *    Revision 1.5  2001/06/01 10:31:51  oes
99  *    Added character class matching to trivimatch; renamed to simplematch
100  *
101  *    Revision 1.4  2001/05/31 17:32:31  oes
102  *
103  *     - Enhanced domain part globbing with infix and prefix asterisk
104  *       matching and optional unanchored operation
105  *
106  *    Revision 1.3  2001/05/29 23:10:09  oes
107  *
108  *
109  *     - Introduced chomp()
110  *     - Moved strsav() from showargs to miscutil
111  *
112  *    Revision 1.2  2001/05/29 09:50:24  jongfoster
113  *    Unified blocklist/imagelist/permissionslist.
114  *    File format is still under discussion, but the internal changes
115  *    are (mostly) done.
116  *
117  *    Also modified interceptor behaviour:
118  *    - We now intercept all URLs beginning with one of the following
119  *      prefixes (and *only* these prefixes):
120  *        * http://i.j.b/
121  *        * http://ijbswa.sf.net/config/
122  *        * http://ijbswa.sourceforge.net/config/
123  *    - New interceptors "home page" - go to http://i.j.b/ to see it.
124  *    - Internal changes so that intercepted and fast redirect pages
125  *      are not replaced with an image.
126  *    - Interceptors now have the option to send a binary page direct
127  *      to the client. (i.e. ijb-send-banner uses this)
128  *    - Implemented show-url-info interceptor.  (Which is why I needed
129  *      the above interceptors changes - a typical URL is
130  *      "http://i.j.b/show-url-info?url=www.somesite.com/banner.gif".
131  *      The previous mechanism would not have intercepted that, and
132  *      if it had been intercepted then it then it would have replaced
133  *      it with an image.)
134  *
135  *    Revision 1.1.1.1  2001/05/15 13:59:00  oes
136  *    Initial import of version 2.9.3 source tree
137  *
138  *
139  *********************************************************************/
140 \f
141
142 #include "config.h"
143
144 #include <stdio.h>
145 #include <stdlib.h>
146 #include <string.h>
147 #include <malloc.h>
148 #include <ctype.h>
149 #include <assert.h>
150
151 #include "project.h"
152 #include "miscutil.h"
153 #include "errlog.h"
154
155 const char miscutil_h_rcs[] = MISCUTIL_H_VERSION;
156
157 /*********************************************************************
158  *
159  * Function    :  zalloc
160  *
161  * Description :  Malloc some memory and set it to '\0'.
162  *                The way calloc() ought to be -acjc
163  *
164  * Parameters  :
165  *          1  :  size = Size of memory chunk to return.
166  *
167  * Returns     :  Pointer to newly malloc'd memory chunk.
168  *
169  *********************************************************************/
170 void *zalloc(int size)
171 {
172    void * ret;
173
174    if ((ret = (void *)malloc(size)) != NULL)
175    {
176       memset(ret, 0, size);
177    }
178
179    return(ret);
180 }
181
182
183 /*********************************************************************
184  *
185  * Function    :  hash_string
186  *
187  * Description :  Take a string and compute a (hopefuly) unique numeric
188  *                integer value.  This has several uses, but being able
189  *                to "switch" a string the one of my favorites.
190  *
191  * Parameters  :
192  *          1  :  s : string to be hashed.
193  *
194  * Returns     :  an unsigned long variable with the hashed value.
195  *
196  *********************************************************************/
197 unsigned int hash_string( const char* s )
198 {
199    unsigned int h = 0; 
200
201    for ( ; *s; ++s )
202    {
203       h = 5 * h + *s;
204    }
205
206    return (h);
207
208 }
209
210
211 #ifdef __MINGW32__
212 /*********************************************************************
213  *
214  * Function    :  strdup
215  *
216  * Description :  For some reason (which is beyond me), gcc and WIN32
217  *                don't like strdup.  When a "free" is executed on a
218  *                strdup'd ptr, it can at times freez up!  So I just
219  *                replaced it and problem was solved.
220  *
221  * Parameters  :
222  *          1  :  s = string to duplicate
223  *
224  * Returns     :  Pointer to newly malloc'ed copy of the string.
225  *
226  *********************************************************************/
227 char *strdup( const char *s )
228 {
229    char * result = (char *)malloc( strlen(s)+1 );
230
231    if (result != NULL)
232    {
233       strcpy( result, s );
234    }
235
236    return( result );
237 }
238
239 #endif /* def __MINGW32__ */
240
241
242
243 /*********************************************************************
244  *
245  * Function    :  safe_strerror
246  *
247  * Description :  Variant of the library routine strerror() which will
248  *                work on systems without the library routine, and
249  *                which should never return NULL.
250  *
251  * Parameters  :
252  *          1  :  err = the `errno' of the last operation.
253  *
254  * Returns     :  An "English" string of the last `errno'.  Allocated
255  *                with strdup(), so caller frees.  May be NULL if the
256  *                system is out of memory.
257  *
258  *********************************************************************/
259 char *safe_strerror(int err)
260 {
261    char *s = NULL;
262    char buf[BUFFER_SIZE];
263
264
265 #ifdef HAVE_STRERROR
266    s = strerror(err);
267 #endif /* HAVE_STRERROR */
268
269    if (s == NULL)
270    {
271       sprintf(buf, "(errno = %d)", err);
272       s = buf;
273    }
274
275    return(strdup(s));
276
277 }
278
279
280 /*********************************************************************
281  *
282  * Function    :  strcmpic
283  *
284  * Description :  Case insensitive string comparison
285  *
286  * Parameters  :
287  *          1  :  s1 = string 1 to compare
288  *          2  :  s2 = string 2 to compare
289  *
290  * Returns     :  0 if s1==s2, Negative if s1<s2, Positive if s1>s2
291  *
292  *********************************************************************/
293 int strcmpic(const char *s1, const char *s2)
294 {
295    while (*s1 && *s2)
296    {
297       if ( ( *s1 != *s2 ) && ( ijb_tolower(*s1) != ijb_tolower(*s2) ) )
298       {
299          break;
300       }
301       s1++, s2++;
302    }
303    return(ijb_tolower(*s1) - ijb_tolower(*s2));
304
305 }
306
307
308 /*********************************************************************
309  *
310  * Function    :  strncmpic
311  *
312  * Description :  Case insensitive string comparison (upto n characters)
313  *
314  * Parameters  :
315  *          1  :  s1 = string 1 to compare
316  *          2  :  s2 = string 2 to compare
317  *          3  :  n = maximum characters to compare
318  *
319  * Returns     :  0 if s1==s2, Negative if s1<s2, Positive if s1>s2
320  *
321  *********************************************************************/
322 int strncmpic(const char *s1, const char *s2, size_t n)
323 {
324    if (n <= 0) return(0);
325
326    while (*s1 && *s2)
327    {
328       if ( ( *s1 != *s2 ) && ( ijb_tolower(*s1) != ijb_tolower(*s2) ) )
329       {
330          break;
331       }
332
333       if (--n <= 0) break;
334
335       s1++, s2++;
336    }
337    return(ijb_tolower(*s1) - ijb_tolower(*s2));
338
339 }
340
341
342 /*********************************************************************
343  *
344  * Function    :  chomp
345  *
346  * Description :  In-situ-eliminate all leading and trailing whitespace
347  *                from a string.
348  *
349  * Parameters  :
350  *          1  :  s : string to be chomped.
351  *
352  * Returns     :  chomped string
353  *
354  *********************************************************************/
355 char *chomp(char *string)
356 {
357    char *p, *q, *r;
358
359    /* 
360     * strip trailing whitespace
361     */
362    p = string + strlen(string);
363    while (p > string && ijb_isspace(*(p-1)))
364    {
365       p--;
366    }
367    *p = '\0';
368
369    /* 
370     * find end of leading whitespace 
371     */
372    q = r = string;
373    while (*q && ijb_isspace(*q))
374    {
375       q++;
376    }
377
378    /*
379     * if there was any, move the rest forwards
380     */
381    if (q != string)
382    {
383       while (q <= p)
384       {
385          *r++ = *q++;
386       }
387    }
388
389    return(string);
390
391 }
392
393
394 /*********************************************************************
395  *
396  * Function    :  strsav
397  *
398  * Description :  Reallocate "old" and append text to it.  This makes
399  *                it easier to append to malloc'd strings.
400  *                Running out of memory is a FATAL error.
401  *
402  * Parameters  :
403  *          1  :  old = Old text that is to be extended.  Will be
404  *                free()d by this routine.  May be NULL.
405  *          2  :  text_to_append = Text to be appended to old.
406  *                May be NULL.
407  *
408  * Returns     :  Pointer to newly malloc'ed appended string.
409  *                If there is no text to append, return old.  Caller
410  *                must free().
411  *
412  *********************************************************************/
413 char *strsav(char *old, const char *text_to_append)
414 {
415    int old_len, new_len = 0;
416    char *p;
417
418    if (( text_to_append == NULL) || (*text_to_append == '\0'))
419    {
420       return(old);
421    }
422
423    if (NULL == old)
424    {
425       if ((p = strdup(text_to_append)) == NULL)
426       {
427          log_error(LOG_LEVEL_FATAL, "strdup() failed!", new_len);
428          /* Never get here - LOG_LEVEL_FATAL causes program exit */
429       }
430       return p;
431    }
432
433    old_len = strlen(old);
434    new_len = old_len + strlen(text_to_append) + 1;
435
436    if ((p = realloc(old, new_len)) == NULL)
437    {
438       log_error(LOG_LEVEL_FATAL, "realloc(%d) bytes failed!", new_len);
439       /* Never get here - LOG_LEVEL_FATAL causes program exit */
440    }
441
442    strcpy(p + old_len, text_to_append);
443    return(p);
444 }
445
446
447 /*********************************************************************
448  *
449  * Function    :  string_append
450  *
451  * Description :  Reallocate target_string and append text to it.  
452  *                This makes it easier to append to malloc'd strings.
453  *                This is similar to strsav(), but running out of
454  *                memory isn't catastrophic.
455  *
456  *                Programming style:
457  *
458  *                The following style provides sufficient error
459  *                checking for this routine, with minimal clutter
460  *                in the source code.  It is recommended if you
461  *                have many calls to this function:
462  *
463  *                char * s = strdup(...); // don't check for error
464  *                string_append(&s, ...);  // don't check for error
465  *                string_append(&s, ...);  // don't check for error
466  *                string_append(&s, ...);  // don't check for error
467  *                if (NULL == s) { ... handle error ... }
468  *
469  *                OR, equivalently:
470  *
471  *                char * s = strdup(...); // don't check for error
472  *                string_append(&s, ...);  // don't check for error
473  *                string_append(&s, ...);  // don't check for error
474  *                if (string_append(&s, ...)) {... handle error ...}
475  *
476  * Parameters  :
477  *          1  :  target_string = Pointer to old text that is to be
478  *                extended.  *target_string will be free()d by this
479  *                routine.  target_string must be non-NULL.
480  *                If *target_string is NULL, this routine will
481  *                do nothing and return with an error - this allows
482  *                you to make many calls to this routine and only
483  *                check for errors after the last one.
484  *          2  :  text_to_append = Text to be appended to old.
485  *                Must not be NULL.
486  *
487  * Returns     :  JB_ERR_OK on success, and sets *target_string
488  *                   to newly malloc'ed appended string.  Caller
489  *                   must free(*target_string).
490  *                JB_ERR_MEMORY on out-of-memory.  (And free()s
491  *                   *target_string and sets it to NULL).
492  *                JB_ERR_MEMORY if *target_string is NULL.
493  *
494  *********************************************************************/
495 jb_err string_append(char **target_string, const char *text_to_append)
496 {
497    size_t old_len;
498    char *new_string;
499
500    assert(target_string);
501    assert(text_to_append);
502
503    if (*target_string == NULL)
504    {
505       return JB_ERR_MEMORY;
506    }
507
508    if (*text_to_append == '\0')
509    {
510       return JB_ERR_OK;
511    }
512
513    old_len = strlen(*target_string);
514
515    if (NULL == (new_string = realloc(*target_string,
516           strlen(text_to_append) + old_len + 1)))
517    {
518       free(*target_string);
519
520       *target_string = NULL;
521       return JB_ERR_MEMORY;
522    }
523
524    strcpy(new_string + old_len, text_to_append);
525
526    *target_string = new_string;
527    return JB_ERR_OK;
528 }
529
530
531 /*********************************************************************
532  *
533  * Function    :  simplematch
534  *
535  * Description :  String matching, with a (greedy) '*' wildcard that
536  *                stands for zero or more arbitrary characters and
537  *                character classes in [], which take both enumerations
538  *                and ranges.
539  *
540  * Parameters  :
541  *          1  :  pattern = pattern for matching
542  *          2  :  text    = text to be matched
543  *
544  * Returns     :  0 if match, else nonzero
545  *
546  *********************************************************************/
547 int simplematch(char *pattern, char *text)
548 {
549    unsigned char *pat = (unsigned char *) pattern;
550    unsigned char *txt = (unsigned char *) text;
551    unsigned char *fallback = pat; 
552    int wildcard = 0;
553   
554    unsigned char lastchar = 'a';
555    unsigned i;
556    unsigned char charmap[32];
557   
558   
559    while (*txt)
560    {
561
562       /* EOF pattern but !EOF text? */
563       if (*pat == '\0')
564       {
565          return 1;
566       }
567
568       /* '*' in the pattern?  */
569       if (*pat == '*') 
570       {
571      
572          /* The pattern ends afterwards? Speed up the return. */
573          if (*++pat == '\0')
574          {
575             return 0;
576          }
577      
578          /* Else, set wildcard mode and remember position after '*' */
579          wildcard = 1;
580          fallback = pat;
581       }
582
583       /* Character range specification? */
584       if (*pat == '[')
585       {
586          memset(charmap, '\0', sizeof(charmap));
587
588          while (*++pat != ']')
589          {
590             if (!*pat)
591             { 
592                return 1;
593             }
594             else if (*pat == '-')
595             {
596                if ((*++pat == ']') || *pat == '\0')
597                {
598                   return(1);
599                }
600                for(i = lastchar; i <= *pat; i++)
601                {
602                   charmap[i / 8] |= (1 << (i % 8));
603                } 
604             }
605             else
606             {
607                charmap[*pat / 8] |= (1 << (*pat % 8));
608                lastchar = *pat;
609             }
610          }
611       } /* -END- if Character range specification */
612
613
614       /* Compare: Char match, or char range match*/
615       if ((*pat == *txt)  
616       || ((*pat == ']') && (charmap[*txt / 8] & (1 << (*txt % 8)))) )
617       {
618          /* Sucess, go ahead */
619          pat++;
620       }
621       else
622       {
623          /* In wildcard mode, just try again after failiure */
624          if(wildcard)
625          {
626             pat = fallback;
627          }
628
629          /* Else, bad luck */
630          else
631          {
632             return 1;
633          }
634       }
635       txt++;
636    }
637
638    /* Cut off extra '*'s */
639    if(*pat == '*')  pat++;
640
641    /* If this is the pattern's end, fine! */
642    return(*pat);
643
644 }
645
646
647 /*********************************************************************
648  *
649  * Function    :  bindup
650  *
651  * Description :  Duplicate the first n characters of a string that may
652  *                contain '\0' characters.
653  *
654  * Parameters  :
655  *          1  :  string = string to be duplicated
656  *          2  :  n = number of bytes to duplicate
657  *
658  * Returns     :  pointer to copy, or NULL if failiure
659  *
660  *********************************************************************/
661 char *bindup(const char *string, int n)
662 {
663    char *dup;
664
665    if (NULL == (dup = (char *)malloc(n)))
666    {
667       return NULL;
668    }
669    else
670    {
671      memcpy(dup, string, n);
672    }
673
674    return dup;
675
676 }
677
678
679 /*********************************************************************
680  *
681  * Function    :  make_path
682  *
683  * Description :  Takes a directory name and a file name, returns 
684  *                the complete path.  Handles windows/unix differences.
685  *                If the file name is already an absolute path, or if
686  *                the directory name is NULL or empty, it returns 
687  *                the filename. 
688  *
689  * Parameters  :
690  *          1  :  dir: Name of directory or NULL for none.
691  *          2  :  file: Name of file.  Should not be NULL or empty.
692  *
693  * Returns     :  "dir/file" (Or on windows, "dir\file").
694  *                It allocates the string on the heap.  Caller frees.
695  *                Returns NULL in error (i.e. NULL file or out of
696  *                memory) 
697  *
698  *********************************************************************/
699 char * make_path(const char * dir, const char * file)
700 {
701 #ifdef AMIGA
702    char path[512];
703
704    if(dir)
705    {
706       strncpy(path,dir,512);
707       path[511]=0;
708    } else {
709       path[0]=0;
710    }
711    if(AddPart(path,file,512))
712    {
713       return strdup(path);
714    } else {
715       return NULL;
716    }
717 #else /* ndef AMIGA */
718
719    if ((file == NULL) || (*file == '\0'))
720    {
721       return NULL; /* Error */
722    }
723
724    if ((dir == NULL) || (*dir == '\0') /* No directory specified */
725 #ifdef _WIN32
726       || (*file == '\\') || (file[1] == ':') /* Absolute path (DOS) */
727 #else /* ifndef _WIN32 */
728       || (*file == '/') /* Absolute path (U*ix) */
729 #endif /* ifndef _WIN32 */
730       )
731    {
732       return strdup(file);
733    }
734    else
735    {
736       char * path = malloc(strlen(dir) + strlen(file) + 2);
737       strcpy(path, dir);
738 #ifdef _WIN32
739       if(path[strlen(path)-1] != '\\')
740       {
741          strcat(path, "\\");
742       }
743 #else /* ifndef _WIN32 */
744       if(path[strlen(path)-1] != '/')
745       {
746          strcat(path, "/");
747       }
748 #endif /* ifndef _WIN32 */
749       strcat(path, file);
750
751       return path;
752    }
753 #endif /* ndef AMIGA */
754 }
755
756
757 /*
758   Local Variables:
759   tab-width: 3
760   end:
761 */