- Delete strsav() which was replaced
[privoxy.git] / miscutil.c
1 const char miscutil_rcs[] = "$Id: miscutil.c,v 1.48 2007/04/09 17:48:51 fabiankeil Exp $";
2 /*********************************************************************
3  *
4  * File        :  $Source: /cvsroot/ijbswa/current/miscutil.c,v $
5  *
6  * Purpose     :  zalloc, hash_string, safe_strerror, strcmpic,
7  *                strncmpic, 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-2007
13  *                the SourceForge Privoxy team. http://www.privoxy.org/
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  *                The timegm replacement function was taken from GnuPG,
20  *                Copyright (C) 2004 Free Software Foundation, Inc.
21  *
22  *                The snprintf replacement function is written by
23  *                Mark Martinec who also holds the copyright. It can be
24  *                used under the terms of the GPL or the terms of the
25  *                "Frontier Artistic License".
26  *
27  *                This program is free software; you can redistribute it 
28  *                and/or modify it under the terms of the GNU General
29  *                Public License as published by the Free Software
30  *                Foundation; either version 2 of the License, or (at
31  *                your option) any later version.
32  *
33  *                This program is distributed in the hope that it will
34  *                be useful, but WITHOUT ANY WARRANTY; without even the
35  *                implied warranty of MERCHANTABILITY or FITNESS FOR A
36  *                PARTICULAR PURPOSE.  See the GNU General Public
37  *                License for more details.
38  *
39  *                The GNU General Public License should be included with
40  *                this file.  If not, you can view it at
41  *                http://www.gnu.org/copyleft/gpl.html
42  *                or write to the Free Software Foundation, Inc., 59
43  *                Temple Place - Suite 330, Boston, MA  02111-1307, USA.
44  *
45  * Revisions   :
46  *    $Log: miscutil.c,v $
47  *    Revision 1.48  2007/04/09 17:48:51  fabiankeil
48  *    Check for HAVE_SNPRINTF instead of __OS2__
49  *    before including the portable snprintf() code.
50  *
51  *    Revision 1.47  2007/03/17 11:52:15  fabiankeil
52  *    - Use snprintf instead of sprintf.
53  *    - Mention copyright for the replacement
54  *      functions in the copyright header.
55  *
56  *    Revision 1.46  2007/01/18 15:03:20  fabiankeil
57  *    Don't include replacement timegm() if
58  *    putenv() or tzset() isn't available.
59  *
60  *    Revision 1.45  2006/12/26 17:31:41  fabiankeil
61  *    Mutex protect rand() if POSIX threading
62  *    is used, warn the user if that's not possible
63  *    and stop using it on _WIN32 where it could
64  *    cause crashes.
65  *
66  *    Revision 1.44  2006/11/07 12:46:43  fabiankeil
67  *    Silence compiler warning on NetBSD 3.1.
68  *
69  *    Revision 1.43  2006/09/23 13:26:38  roro
70  *    Replace TABs by spaces in source code.
71  *
72  *    Revision 1.42  2006/09/09 14:01:45  fabiankeil
73  *    Integrated Oliver Yeoh's domain pattern fix
74  *    to make sure *x matches xx. Closes Patch 1217393
75  *    and Bug 1170767.
76  *
77  *    Revision 1.41  2006/08/18 16:03:17  david__schmidt
78  *    Tweak for OS/2 build happiness.
79  *
80  *    Revision 1.40  2006/08/17 17:15:10  fabiankeil
81  *    - Back to timegm() using GnuPG's replacement if necessary.
82  *      Using mktime() and localtime() could add a on hour offset if
83  *      the randomize factor was big enough to lead to a summer/wintertime
84  *      switch.
85  *
86  *    - Removed now-useless Privoxy 3.0.3 compatibility glue.
87  *
88  *    - Moved randomization code into pick_from_range().
89  *
90  *    - Changed parse_header_time definition.
91  *      time_t isn't guaranteed to be signed and
92  *      if it isn't, -1 isn't available as error code.
93  *      Changed some variable types in client_if_modified_since()
94  *      because of the same reason.
95  *
96  *    Revision 1.39  2006/07/18 14:48:46  david__schmidt
97  *    Reorganizing the repository: swapping out what was HEAD (the old 3.1 branch)
98  *    with what was really the latest development (the v_3_0_branch branch)
99  *
100  *    Revision 1.37.2.4  2003/12/01 14:45:14  oes
101  *    Fixed two more problems with wildcarding in simplematch()
102  *
103  *    Revision 1.37.2.3  2003/11/20 11:39:24  oes
104  *    Bugfix: The "?" wildcard for domain names had never been implemented. Ooops\!
105  *
106  *    Revision 1.37.2.2  2002/11/12 14:28:18  oes
107  *    Proper backtracking in simplematch; fixes bug #632888
108  *
109  *    Revision 1.37.2.1  2002/09/25 12:58:51  oes
110  *    Made strcmpic and strncmpic safe against NULL arguments
111  *    (which are now treated as empty strings).
112  *
113  *    Revision 1.37  2002/04/26 18:29:43  jongfoster
114  *    Fixing this Visual C++ warning:
115  *    miscutil.c(710) : warning C4090: '=' : different 'const' qualifiers
116  *
117  *    Revision 1.36  2002/04/26 12:55:38  oes
118  *    New function string_toupper
119  *
120  *    Revision 1.35  2002/03/26 22:29:55  swa
121  *    we have a new homepage!
122  *
123  *    Revision 1.34  2002/03/24 13:25:43  swa
124  *    name change related issues
125  *
126  *    Revision 1.33  2002/03/07 03:46:53  oes
127  *    Fixed compiler warnings etc
128  *
129  *    Revision 1.32  2002/03/06 23:02:57  jongfoster
130  *    Removing tabs
131  *
132  *    Revision 1.31  2002/03/05 04:52:42  oes
133  *    Deleted non-errlog debugging code
134  *
135  *    Revision 1.30  2002/03/04 18:27:42  oes
136  *    - Deleted deletePidFile
137  *    - Made write_pid_file use the --pidfile option value
138  *      (or no PID file, if the option was absent)
139  *    - Played styleguide police
140  *
141  *    Revision 1.29  2002/03/04 02:08:02  david__schmidt
142  *    Enable web editing of actions file on OS/2 (it had been broken all this time!)
143  *
144  *    Revision 1.28  2002/03/03 09:18:03  joergs
145  *    Made jumbjuster work on AmigaOS again.
146  *
147  *    Revision 1.27  2002/01/21 00:52:32  jongfoster
148  *    Adding string_join()
149  *
150  *    Revision 1.26  2001/12/30 14:07:32  steudten
151  *    - Add signal handling (unix)
152  *    - Add SIGHUP handler (unix)
153  *    - Add creation of pidfile (unix)
154  *    - Add action 'top' in rc file (RH)
155  *    - Add entry 'SIGNALS' to manpage
156  *    - Add exit message to logfile (unix)
157  *
158  *    Revision 1.25  2001/11/13 00:16:38  jongfoster
159  *    Replacing references to malloc.h with the standard stdlib.h
160  *    (See ANSI or K&R 2nd Ed)
161  *
162  *    Revision 1.24  2001/11/05 21:41:43  steudten
163  *    Add changes to be a real daemon just for unix os.
164  *    (change cwd to /, detach from controlling tty, set
165  *    process group and session leader to the own process.
166  *    Add DBG() Macro.
167  *    Add some fatal-error log message for failed malloc().
168  *    Add '-d' if compiled with 'configure --with-debug' to
169  *    enable debug output.
170  *
171  *    Revision 1.23  2001/10/29 03:48:10  david__schmidt
172  *    OS/2 native needed a snprintf() routine.  Added one to miscutil, brackedted
173  *    by and __OS2__ ifdef.
174  *
175  *    Revision 1.22  2001/10/26 17:39:38  oes
176  *    Moved ijb_isspace and ijb_tolower to project.h
177  *
178  *    Revision 1.21  2001/10/23 21:27:50  jongfoster
179  *    Standardising error codes in string_append
180  *    make_path() no longer adds '\\' if the dir already ends in '\\' (this
181  *    is just copying a UNIX-specific fix to the Windows-specific part)
182  *
183  *    Revision 1.20  2001/10/22 15:33:56  david__schmidt
184  *    Special-cased OS/2 out of the Netscape-abort-on-404-in-js problem in
185  *    filters.c.  Added a FIXME in front of the offending code.  I'll gladly
186  *    put in a better/more robust fix for all parties if one is presented...
187  *    It seems that just returning 200 instead of 404 would pretty much fix
188  *    it for everyone, but I don't know all the history of the problem.
189  *
190  *    Revision 1.19  2001/10/14 22:02:57  jongfoster
191  *    New function string_append() which is like strsav(), but running
192  *    out of memory isn't automatically FATAL.
193  *
194  *    Revision 1.18  2001/09/20 13:33:43  steudten
195  *
196  *    change long to int as return value in hash_string(). Remember the wraparound
197  *    for int = long = sizeof(4) - thats maybe not what we want.
198  *
199  *    Revision 1.17  2001/09/13 20:51:29  jongfoster
200  *    Fixing potential problems with characters >=128 in simplematch()
201  *    This was also a compiler warning.
202  *
203  *    Revision 1.16  2001/09/10 10:56:59  oes
204  *    Silenced compiler warnings
205  *
206  *    Revision 1.15  2001/07/13 14:02:24  oes
207  *    Removed vim-settings
208  *
209  *    Revision 1.14  2001/06/29 21:45:41  oes
210  *    Indentation, CRLF->LF, Tab-> Space
211  *
212  *    Revision 1.13  2001/06/29 13:32:14  oes
213  *    Removed logentry from cancelled commit
214  *
215  *    Revision 1.12  2001/06/09 10:55:28  jongfoster
216  *    Changing BUFSIZ ==> BUFFER_SIZE
217  *
218  *    Revision 1.11  2001/06/07 23:09:19  jongfoster
219  *    Cosmetic indentation changes.
220  *
221  *    Revision 1.10  2001/06/07 14:51:38  joergs
222  *    make_path() no longer adds '/' if the dir already ends in '/'.
223  *
224  *    Revision 1.9  2001/06/07 14:43:17  swa
225  *    slight mistake in make_path, unix path style is /.
226  *
227  *    Revision 1.8  2001/06/05 22:32:01  jongfoster
228  *    New function make_path() to splice directory and file names together.
229  *
230  *    Revision 1.7  2001/06/03 19:12:30  oes
231  *    introduced bindup()
232  *
233  *    Revision 1.6  2001/06/01 18:14:49  jongfoster
234  *    Changing the calls to strerr() to check HAVE_STRERR (which is defined
235  *    in config.h if appropriate) rather than the NO_STRERR macro.
236  *
237  *    Revision 1.5  2001/06/01 10:31:51  oes
238  *    Added character class matching to trivimatch; renamed to simplematch
239  *
240  *    Revision 1.4  2001/05/31 17:32:31  oes
241  *
242  *     - Enhanced domain part globbing with infix and prefix asterisk
243  *       matching and optional unanchored operation
244  *
245  *    Revision 1.3  2001/05/29 23:10:09  oes
246  *
247  *
248  *     - Introduced chomp()
249  *     - Moved strsav() from showargs to miscutil
250  *
251  *    Revision 1.2  2001/05/29 09:50:24  jongfoster
252  *    Unified blocklist/imagelist/permissionslist.
253  *    File format is still under discussion, but the internal changes
254  *    are (mostly) done.
255  *
256  *    Also modified interceptor behaviour:
257  *    - We now intercept all URLs beginning with one of the following
258  *      prefixes (and *only* these prefixes):
259  *        * http://i.j.b/
260  *        * http://ijbswa.sf.net/config/
261  *        * http://ijbswa.sourceforge.net/config/
262  *    - New interceptors "home page" - go to http://i.j.b/ to see it.
263  *    - Internal changes so that intercepted and fast redirect pages
264  *      are not replaced with an image.
265  *    - Interceptors now have the option to send a binary page direct
266  *      to the client. (i.e. ijb-send-banner uses this)
267  *    - Implemented show-url-info interceptor.  (Which is why I needed
268  *      the above interceptors changes - a typical URL is
269  *      "http://i.j.b/show-url-info?url=www.somesite.com/banner.gif".
270  *      The previous mechanism would not have intercepted that, and
271  *      if it had been intercepted then it then it would have replaced
272  *      it with an image.)
273  *
274  *    Revision 1.1.1.1  2001/05/15 13:59:00  oes
275  *    Initial import of version 2.9.3 source tree
276  *
277  *
278  *********************************************************************/
279 \f
280
281 #include "config.h"
282
283 #include <stdio.h>
284 #include <sys/types.h>
285 #include <stdlib.h>
286 #if !defined(_WIN32) && !defined(__OS2__)
287 #include <unistd.h>
288 #endif /* #if !defined(_WIN32) && !defined(__OS2__) */
289 #include <string.h>
290 #include <ctype.h>
291 #include <assert.h>
292
293 #if !defined(HAVE_TIMEGM) && defined(HAVE_TZSET) && defined(HAVE_PUTENV)
294 #include <time.h>
295 #endif /* !defined(HAVE_TIMEGM) && defined(HAVE_TZSET) && defined(HAVE_PUTENV) */
296
297 #include "project.h"
298 #include "miscutil.h"
299 #include "errlog.h"
300 #include "jcc.h"
301
302 const char miscutil_h_rcs[] = MISCUTIL_H_VERSION;
303
304 /*********************************************************************
305  *
306  * Function    :  zalloc
307  *
308  * Description :  Malloc some memory and set it to '\0'.
309  *                The way calloc() ought to be -acjc
310  *
311  * Parameters  :
312  *          1  :  size = Size of memory chunk to return.
313  *
314  * Returns     :  Pointer to newly malloc'd memory chunk.
315  *
316  *********************************************************************/
317 void *zalloc(size_t size)
318 {
319    void * ret;
320
321    if ((ret = (void *)malloc(size)) != NULL)
322    {
323       memset(ret, 0, size);
324    }
325
326    return(ret);
327
328 }
329
330
331 #if defined(unix)
332 /*********************************************************************
333  *
334  * Function    :  write_pid_file 
335  *
336  * Description :  Writes a pid file with the pid of the main process 
337  *
338  * Parameters  :  None
339  *
340  * Returns     :  N/A 
341  *
342  *********************************************************************/
343 void write_pid_file(void)
344 {
345    FILE   *fp;
346    
347    /*
348     * If no --pidfile option was given,
349     * we can live without one.
350     */
351    if (pidfile == NULL) return;
352
353    if ((fp = fopen(pidfile, "w")) == NULL)
354    {
355       log_error(LOG_LEVEL_INFO, "can't open pidfile '%s': %E", pidfile);
356    }
357    else
358    {
359       fprintf(fp, "%u\n", (unsigned int) getpid());
360       fclose (fp);
361    }
362    return;
363
364 }
365 #endif /* def unix */
366
367
368 /*********************************************************************
369  *
370  * Function    :  hash_string
371  *
372  * Description :  Take a string and compute a (hopefuly) unique numeric
373  *                integer value.  This has several uses, but being able
374  *                to "switch" a string the one of my favorites.
375  *
376  * Parameters  :
377  *          1  :  s : string to be hashed.
378  *
379  * Returns     :  an unsigned long variable with the hashed value.
380  *
381  *********************************************************************/
382 unsigned int hash_string( const char* s )
383 {
384    unsigned int h = 0; 
385
386    for ( ; *s; ++s )
387    {
388       h = 5 * h + (unsigned int)*s;
389    }
390
391    return (h);
392
393 }
394
395
396 #ifdef __MINGW32__
397 /*********************************************************************
398  *
399  * Function    :  strdup
400  *
401  * Description :  For some reason (which is beyond me), gcc and WIN32
402  *                don't like strdup.  When a "free" is executed on a
403  *                strdup'd ptr, it can at times freez up!  So I just
404  *                replaced it and problem was solved.
405  *
406  * Parameters  :
407  *          1  :  s = string to duplicate
408  *
409  * Returns     :  Pointer to newly malloc'ed copy of the string.
410  *
411  *********************************************************************/
412 char *strdup( const char *s )
413 {
414    char * result = (char *)malloc( strlen(s)+1 );
415
416    if (result != NULL)
417    {
418       strcpy( result, s );
419    }
420
421    return( result );
422 }
423
424 #endif /* def __MINGW32__ */
425
426
427
428 /*********************************************************************
429  *
430  * Function    :  safe_strerror
431  *
432  * Description :  Variant of the library routine strerror() which will
433  *                work on systems without the library routine, and
434  *                which should never return NULL.
435  *
436  * Parameters  :
437  *          1  :  err = the `errno' of the last operation.
438  *
439  * Returns     :  An "English" string of the last `errno'.  Allocated
440  *                with strdup(), so caller frees.  May be NULL if the
441  *                system is out of memory.
442  *
443  *********************************************************************/
444 char *safe_strerror(int err)
445 {
446    char *s = NULL;
447    char buf[BUFFER_SIZE];
448
449
450 #ifdef HAVE_STRERROR
451    s = strerror(err);
452 #endif /* HAVE_STRERROR */
453
454    if (s == NULL)
455    {
456       snprintf(buf, sizeof(buf), "(errno = %d)", err);
457       s = buf;
458    }
459
460    return(strdup(s));
461
462 }
463
464
465 /*********************************************************************
466  *
467  * Function    :  strcmpic
468  *
469  * Description :  Case insensitive string comparison
470  *
471  * Parameters  :
472  *          1  :  s1 = string 1 to compare
473  *          2  :  s2 = string 2 to compare
474  *
475  * Returns     :  0 if s1==s2, Negative if s1<s2, Positive if s1>s2
476  *
477  *********************************************************************/
478 int strcmpic(const char *s1, const char *s2)
479 {
480    if (!s1) s1 = "";
481    if (!s2) s2 = "";
482
483    while (*s1 && *s2)
484    {
485       if ( ( *s1 != *s2 ) && ( ijb_tolower(*s1) != ijb_tolower(*s2) ) )
486       {
487          break;
488       }
489       s1++, s2++;
490    }
491    return(ijb_tolower(*s1) - ijb_tolower(*s2));
492
493 }
494
495
496 /*********************************************************************
497  *
498  * Function    :  strncmpic
499  *
500  * Description :  Case insensitive string comparison (upto n characters)
501  *
502  * Parameters  :
503  *          1  :  s1 = string 1 to compare
504  *          2  :  s2 = string 2 to compare
505  *          3  :  n = maximum characters to compare
506  *
507  * Returns     :  0 if s1==s2, Negative if s1<s2, Positive if s1>s2
508  *
509  *********************************************************************/
510 int strncmpic(const char *s1, const char *s2, size_t n)
511 {
512    if (n <= 0) return(0);
513    if (!s1) s1 = "";
514    if (!s2) s2 = "";
515    
516    while (*s1 && *s2)
517    {
518       if ( ( *s1 != *s2 ) && ( ijb_tolower(*s1) != ijb_tolower(*s2) ) )
519       {
520          break;
521       }
522
523       if (--n <= 0) break;
524
525       s1++, s2++;
526    }
527    return(ijb_tolower(*s1) - ijb_tolower(*s2));
528
529 }
530
531
532 /*********************************************************************
533  *
534  * Function    :  chomp
535  *
536  * Description :  In-situ-eliminate all leading and trailing whitespace
537  *                from a string.
538  *
539  * Parameters  :
540  *          1  :  s : string to be chomped.
541  *
542  * Returns     :  chomped string
543  *
544  *********************************************************************/
545 char *chomp(char *string)
546 {
547    char *p, *q, *r;
548
549    /* 
550     * strip trailing whitespace
551     */
552    p = string + strlen(string);
553    while (p > string && ijb_isspace(*(p-1)))
554    {
555       p--;
556    }
557    *p = '\0';
558
559    /* 
560     * find end of leading whitespace 
561     */
562    q = r = string;
563    while (*q && ijb_isspace(*q))
564    {
565       q++;
566    }
567
568    /*
569     * if there was any, move the rest forwards
570     */
571    if (q != string)
572    {
573       while (q <= p)
574       {
575          *r++ = *q++;
576       }
577    }
578
579    return(string);
580
581 }
582
583
584 /*********************************************************************
585  *
586  * Function    :  string_append
587  *
588  * Description :  Reallocate target_string and append text to it.  
589  *                This makes it easier to append to malloc'd strings.
590  *                This is similar to the (removed) strsav(), but
591  *                running out of memory isn't catastrophic.
592  *
593  *                Programming style:
594  *
595  *                The following style provides sufficient error
596  *                checking for this routine, with minimal clutter
597  *                in the source code.  It is recommended if you
598  *                have many calls to this function:
599  *
600  *                char * s = strdup(...); // don't check for error
601  *                string_append(&s, ...);  // don't check for error
602  *                string_append(&s, ...);  // don't check for error
603  *                string_append(&s, ...);  // don't check for error
604  *                if (NULL == s) { ... handle error ... }
605  *
606  *                OR, equivalently:
607  *
608  *                char * s = strdup(...); // don't check for error
609  *                string_append(&s, ...);  // don't check for error
610  *                string_append(&s, ...);  // don't check for error
611  *                if (string_append(&s, ...)) {... handle error ...}
612  *
613  * Parameters  :
614  *          1  :  target_string = Pointer to old text that is to be
615  *                extended.  *target_string will be free()d by this
616  *                routine.  target_string must be non-NULL.
617  *                If *target_string is NULL, this routine will
618  *                do nothing and return with an error - this allows
619  *                you to make many calls to this routine and only
620  *                check for errors after the last one.
621  *          2  :  text_to_append = Text to be appended to old.
622  *                Must not be NULL.
623  *
624  * Returns     :  JB_ERR_OK on success, and sets *target_string
625  *                   to newly malloc'ed appended string.  Caller
626  *                   must free(*target_string).
627  *                JB_ERR_MEMORY on out-of-memory.  (And free()s
628  *                   *target_string and sets it to NULL).
629  *                JB_ERR_MEMORY if *target_string is NULL.
630  *
631  *********************************************************************/
632 jb_err string_append(char **target_string, const char *text_to_append)
633 {
634    size_t old_len;
635    char *new_string;
636    size_t new_size;
637
638    assert(target_string);
639    assert(text_to_append);
640
641    if (*target_string == NULL)
642    {
643       return JB_ERR_MEMORY;
644    }
645
646    if (*text_to_append == '\0')
647    {
648       return JB_ERR_OK;
649    }
650
651    old_len = strlen(*target_string);
652
653    new_size = strlen(text_to_append) + old_len + 1;
654
655    if (NULL == (new_string = realloc(*target_string, new_size)))
656    {
657       free(*target_string);
658
659       *target_string = NULL;
660       return JB_ERR_MEMORY;
661    }
662
663    strlcpy(new_string + old_len, text_to_append, new_size - old_len);
664
665    *target_string = new_string;
666    return JB_ERR_OK;
667 }
668
669
670 /*********************************************************************
671  *
672  * Function    :  string_join
673  *
674  * Description :  Join two strings together.  Frees BOTH the original
675  *                strings.  If either or both input strings are NULL,
676  *                fails as if it had run out of memory.
677  *
678  *                For comparison, string_append requires that the
679  *                second string is non-NULL, and doesn't free it.
680  *
681  *                Rationale: Too often, we want to do
682  *                string_append(s, html_encode(s2)).  That assert()s
683  *                if s2 is NULL or if html_encode() runs out of memory.
684  *                It also leaks memory.  Proper checking is cumbersome.
685  *                The solution: string_join(s, html_encode(s2)) is safe,
686  *                and will free the memory allocated by html_encode().
687  *
688  * Parameters  :
689  *          1  :  target_string = Pointer to old text that is to be
690  *                extended.  *target_string will be free()d by this
691  *                routine.  target_string must be non-NULL.
692  *          2  :  text_to_append = Text to be appended to old.
693  *
694  * Returns     :  JB_ERR_OK on success, and sets *target_string
695  *                   to newly malloc'ed appended string.  Caller
696  *                   must free(*target_string).
697  *                JB_ERR_MEMORY on out-of-memory, or if
698  *                   *target_string or text_to_append is NULL.  (In
699  *                   this case, frees *target_string and text_to_append,
700  *                   sets *target_string to NULL).
701  *
702  *********************************************************************/
703 jb_err string_join(char **target_string, char *text_to_append)
704 {
705    jb_err err;
706
707    assert(target_string);
708
709    if (text_to_append == NULL)
710    {
711       freez(*target_string);
712       return JB_ERR_MEMORY;
713    }
714
715    err = string_append(target_string, text_to_append);
716
717    free(text_to_append);
718
719    return err;
720 }
721
722
723 /*********************************************************************
724  *
725  * Function    :  string_toupper
726  *
727  * Description :  Produce a copy of string with all convertible
728  *                characters converted to uppercase.
729  *
730  * Parameters  :
731  *          1  :  string = string to convert
732  *
733  * Returns     :  Uppercase copy of string if possible, 
734  *                NULL on out-of-memory or if string was NULL.
735  *
736  *********************************************************************/
737 char *string_toupper(const char *string)
738 {
739    char *result, *p;
740    const char *q;
741
742    if (!string || ((result = (char *) zalloc(strlen(string) + 1)) == NULL))
743    {
744       return NULL;
745    }
746    
747    q = string;
748    p = result;
749
750    while (*q != '\0')
751    {
752       *p++ = toupper((int) *q++);
753    }
754
755    return result;
756
757 }
758
759
760 /*********************************************************************
761  *
762  * Function    :  simplematch
763  *
764  * Description :  String matching, with a (greedy) '*' wildcard that
765  *                stands for zero or more arbitrary characters and
766  *                character classes in [], which take both enumerations
767  *                and ranges.
768  *
769  * Parameters  :
770  *          1  :  pattern = pattern for matching
771  *          2  :  text    = text to be matched
772  *
773  * Returns     :  0 if match, else nonzero
774  *
775  *********************************************************************/
776 int simplematch(char *pattern, char *text)
777 {
778    unsigned char *pat = (unsigned char *) pattern;
779    unsigned char *txt = (unsigned char *) text;
780    unsigned char *fallback = pat; 
781    int wildcard = 0;
782   
783    unsigned char lastchar = 'a';
784    unsigned i;
785    unsigned char charmap[32];
786   
787    while (*txt)
788    {
789
790       /* EOF pattern but !EOF text? */
791       if (*pat == '\0')
792       {
793          if (wildcard)
794          {
795             pat = fallback;
796          }
797          else
798          {
799             return 1;
800          }
801       }
802
803       /* '*' in the pattern?  */
804       if (*pat == '*') 
805       {
806      
807          /* The pattern ends afterwards? Speed up the return. */
808          if (*++pat == '\0')
809          {
810             return 0;
811          }
812      
813          /* Else, set wildcard mode and remember position after '*' */
814          wildcard = 1;
815          fallback = pat;
816       }
817
818       /* Character range specification? */
819       if (*pat == '[')
820       {
821          memset(charmap, '\0', sizeof(charmap));
822
823          while (*++pat != ']')
824          {
825             if (!*pat)
826             { 
827                return 1;
828             }
829             else if (*pat == '-')
830             {
831                if ((*++pat == ']') || *pat == '\0')
832                {
833                   return(1);
834                }
835                for(i = lastchar; i <= *pat; i++)
836                {
837                   charmap[i / 8] |= (1 << (i % 8));
838                } 
839             }
840             else
841             {
842                charmap[*pat / 8] |= (1 << (*pat % 8));
843                lastchar = *pat;
844             }
845          }
846       } /* -END- if Character range specification */
847
848
849       /* 
850        * Char match, or char range match? 
851        */
852       if ( (*pat == *txt)
853       ||   (*pat == '?')
854       ||   ((*pat == ']') && (charmap[*txt / 8] & (1 << (*txt % 8)))) )
855       {
856          /* 
857           * Sucess: Go ahead
858           */
859          pat++;
860       }
861       else if (!wildcard)
862       {
863          /* 
864           * No match && no wildcard: No luck
865           */
866          return 1;
867       }
868       else if (pat != fallback)
869       {
870          /*
871           * Increment text pointer if in char range matching
872           */
873          if (*pat == ']')
874          {
875             txt++;
876          }
877          /*
878           * Wildcard mode && nonmatch beyond fallback: Rewind pattern
879           */
880          pat = fallback;
881          /*
882           * Restart matching from current text pointer
883           */
884          continue;
885       }
886       txt++;
887    }
888
889    /* Cut off extra '*'s */
890    if(*pat == '*')  pat++;
891
892    /* If this is the pattern's end, fine! */
893    return(*pat);
894
895 }
896
897
898 /*********************************************************************
899  *
900  * Function    :  bindup
901  *
902  * Description :  Duplicate the first n characters of a string that may
903  *                contain '\0' characters.
904  *
905  * Parameters  :
906  *          1  :  string = string to be duplicated
907  *          2  :  len = number of bytes to duplicate
908  *
909  * Returns     :  pointer to copy, or NULL if failiure
910  *
911  *********************************************************************/
912 char *bindup(const char *string, size_t len)
913 {
914    char *duplicate;
915
916    if (NULL == (duplicate = (char *)malloc(len)))
917    {
918       return NULL;
919    }
920    else
921    {
922      memcpy(duplicate, string, len);
923    }
924
925    return duplicate;
926
927 }
928
929
930 /*********************************************************************
931  *
932  * Function    :  make_path
933  *
934  * Description :  Takes a directory name and a file name, returns 
935  *                the complete path.  Handles windows/unix differences.
936  *                If the file name is already an absolute path, or if
937  *                the directory name is NULL or empty, it returns 
938  *                the filename. 
939  *
940  * Parameters  :
941  *          1  :  dir: Name of directory or NULL for none.
942  *          2  :  file: Name of file.  Should not be NULL or empty.
943  *
944  * Returns     :  "dir/file" (Or on windows, "dir\file").
945  *                It allocates the string on the heap.  Caller frees.
946  *                Returns NULL in error (i.e. NULL file or out of
947  *                memory) 
948  *
949  *********************************************************************/
950 char * make_path(const char * dir, const char * file)
951 {
952 #ifdef AMIGA
953    char path[512];
954
955    if(dir)
956    {
957       if(dir[0] == '.')
958       {
959          if(dir[1] == '/')
960          {
961             strncpy(path,dir+2,512);
962          }
963          else
964          {
965             strncpy(path,dir+1,512);
966          }
967       }
968       else
969       {
970          strncpy(path,dir,512);
971       }
972       path[511]=0;
973    }
974    else
975    {
976       path[0]=0;
977    }
978    if(AddPart(path,file,512))
979    {
980       return strdup(path);
981    }
982    else
983    {
984       return NULL;
985    }
986 #else /* ndef AMIGA */
987
988    if ((file == NULL) || (*file == '\0'))
989    {
990       return NULL; /* Error */
991    }
992
993    if ((dir == NULL) || (*dir == '\0') /* No directory specified */
994 #if defined(_WIN32) || defined(__OS2__)
995       || (*file == '\\') || (file[1] == ':') /* Absolute path (DOS) */
996 #else /* ifndef _WIN32 || __OS2__ */
997       || (*file == '/') /* Absolute path (U*ix) */
998 #endif /* ifndef _WIN32 || __OS2__  */
999       )
1000    {
1001       return strdup(file);
1002    }
1003    else
1004    {
1005       char * path;
1006       size_t path_size = strlen(dir) + strlen(file) + 2; /* +2 for trailing (back)slash and \0 */
1007
1008 #if defined(unix)
1009       if ( *dir != '/' && basedir && *basedir )
1010       {
1011          /*
1012           * Relative path, so start with the base directory.
1013           */
1014          path_size += strlen(basedir) + 1; /* +1 for the slash */
1015          path = malloc(path_size);
1016          if (!path ) log_error(LOG_LEVEL_FATAL, "malloc failed!");
1017          strlcpy(path, basedir, path_size);
1018          strlcat(path, "/", path_size);
1019          strlcat(path, dir, path_size);
1020       }
1021       else
1022 #endif /* defined unix */
1023       {
1024          path = malloc(path_size);
1025          if (!path ) log_error(LOG_LEVEL_FATAL, "malloc failed!");
1026          strlcpy(path, dir, path_size);
1027       }
1028
1029 #if defined(_WIN32) || defined(__OS2__)
1030       if(path[strlen(path)-1] != '\\')
1031       {
1032          strlcat(path, "\\", path_size);
1033       }
1034 #else /* ifndef _WIN32 || __OS2__ */
1035       if(path[strlen(path)-1] != '/')
1036       {
1037          strlcat(path, "/", path_size);
1038       }
1039 #endif /* ifndef _WIN32 || __OS2__ */
1040       strlcat(path, file, path_size);
1041
1042       return path;
1043    }
1044 #endif /* ndef AMIGA */
1045 }
1046
1047
1048 /*********************************************************************
1049  *
1050  * Function    :  pick_from_range
1051  *
1052  * Description :  Pick a positive number out of a given range.
1053  *                Should only be used if randomness would be nice,
1054  *                but isn't really necessary.
1055  *
1056  * Parameters  :
1057  *          1  :  range: Highest possible number to pick.
1058  *
1059  * Returns     :  Picked number. 
1060  *
1061  *********************************************************************/
1062 long int pick_from_range(long int range)
1063 {
1064    long int number;
1065 #ifdef HAVE_RANDOM
1066    number = random() % range + 1; 
1067 #elif defined(FEATURE_PTHREAD)
1068    pthread_mutex_lock(&rand_mutex);
1069    number = rand() % (long int)(range + 1);
1070    pthread_mutex_unlock(&rand_mutex);
1071 #else
1072 #ifdef _WIN32
1073    /*
1074     * On Windows and mingw32 srand() has to be called in every
1075     * rand()-using thread, but can cause crashes if it's not
1076     * mutex protected.
1077     *
1078     * Currently we don't have mutexes for mingw32, and for
1079     * our purpose this cludge is probably preferable to crashes.
1080     */
1081    log_error(LOG_LEVEL_INFO, "No thread-safe PRNG available? Using weak \'randomization\' factor.");
1082    number = (range + GetCurrentThreadId() % range) / 2;
1083 #else
1084    /*
1085     * XXX: Which platforms reach this and are there
1086     * better options than just using rand() and hoping
1087     * that it's safe?
1088     */
1089    log_error(LOG_LEVEL_INFO, "No thread-safe PRNG available? Header time randomization might cause "
1090       "crashes, predictable results or even combine these fine options.");
1091    number = rand() % (long int)(range + 1);
1092 #endif /* def _WIN32 */ 
1093
1094 #endif /* (def HAVE_RANDOM) */
1095
1096    return (number);
1097 }
1098
1099
1100 #ifndef HAVE_STRLCAT
1101 /*********************************************************************
1102  *
1103  * Function    :  privoxy_strlcat
1104  *
1105  * Description :  strlcat(3) look-alike for those without decent libc.
1106  *
1107  * Parameters  :
1108  *          1  :  destination: C string.
1109  *          2  :  source: String to copy.
1110  *          3  :  size: Size of destination buffer.
1111  *
1112  * Returns     :  The length of the string that strlcat tried to create.
1113  *
1114  *********************************************************************/
1115 size_t privoxy_strlcat(char *destination, const char *source, const size_t size)
1116 {
1117    const size_t old_length = strlen(destination);
1118    return old_length + strlcpy(destination + old_length, source, size - old_length);
1119 }
1120 #endif /* ndef HAVE_STRLCAT */
1121
1122
1123 #if !defined(HAVE_TIMEGM) && defined(HAVE_TZSET) && defined(HAVE_PUTENV)
1124 /*********************************************************************
1125  *
1126  * Function    :  timegm
1127  *
1128  * Description :  libc replacement function for the inverse of gmtime()
1129  *                Copyright (C) 2004 Free Software Foundation, Inc.
1130  *                Code copied from GnuPG with minor style changes.
1131  *
1132  * Parameters  :
1133  *          1  :  tm: Broken-down time struct.
1134  *
1135  * Returns     :  tm converted into time_t seconds. 
1136  *
1137  *********************************************************************/
1138 time_t timegm(struct tm *tm)
1139 {
1140    time_t answer;
1141    char *zone;
1142
1143    zone=getenv("TZ");
1144    putenv("TZ=UTC");
1145    tzset();
1146    answer=mktime(tm);
1147    if(zone)
1148    {
1149       char *old_zone;
1150
1151       old_zone=malloc(3+strlen(zone)+1);
1152       if(old_zone)
1153       {
1154          strcpy(old_zone,"TZ=");
1155          strcat(old_zone,zone);
1156          putenv(old_zone);
1157       }
1158    }
1159    else
1160    {
1161 #ifdef HAVE_UNSETENV
1162       unsetenv("TZ");
1163 #else
1164       putenv("TZ");
1165 #endif
1166    }
1167    tzset();
1168    return answer;
1169 }
1170 #endif /* !defined(HAVE_TIMEGM) && defined(HAVE_TZSET) && defined(HAVE_PUTENV) */
1171
1172
1173 #ifndef HAVE_SNPRINTF
1174 /*
1175  * What follows is a portable snprintf routine, written by Mark Martinec.
1176  * See: http://www.ijs.si/software/snprintf/
1177
1178                                   snprintf.c
1179                    - a portable implementation of snprintf,
1180        including vsnprintf.c, asnprintf, vasnprintf, asprintf, vasprintf
1181                                        
1182    snprintf is a routine to convert numeric and string arguments to
1183    formatted strings. It is similar to sprintf(3) provided in a system's
1184    C library, yet it requires an additional argument - the buffer size -
1185    and it guarantees never to store anything beyond the given buffer,
1186    regardless of the format or arguments to be formatted. Some newer
1187    operating systems do provide snprintf in their C library, but many do
1188    not or do provide an inadequate (slow or idiosyncratic) version, which
1189    calls for a portable implementation of this routine.
1190
1191 Author
1192
1193    Mark Martinec <mark.martinec@ijs.si>, April 1999, June 2000
1194    Copyright Â© 1999, Mark Martinec
1195
1196  */
1197
1198 #define PORTABLE_SNPRINTF_VERSION_MAJOR 2
1199 #define PORTABLE_SNPRINTF_VERSION_MINOR 2
1200
1201 #if defined(NEED_ASPRINTF) || defined(NEED_ASNPRINTF) || defined(NEED_VASPRINTF) || defined(NEED_VASNPRINTF)
1202 # if defined(NEED_SNPRINTF_ONLY)
1203 # undef NEED_SNPRINTF_ONLY
1204 # endif
1205 # if !defined(PREFER_PORTABLE_SNPRINTF)
1206 # define PREFER_PORTABLE_SNPRINTF
1207 # endif
1208 #endif
1209
1210 #if defined(SOLARIS_BUG_COMPATIBLE) && !defined(SOLARIS_COMPATIBLE)
1211 #define SOLARIS_COMPATIBLE
1212 #endif
1213
1214 #if defined(HPUX_BUG_COMPATIBLE) && !defined(HPUX_COMPATIBLE)
1215 #define HPUX_COMPATIBLE
1216 #endif
1217
1218 #if defined(DIGITAL_UNIX_BUG_COMPATIBLE) && !defined(DIGITAL_UNIX_COMPATIBLE)
1219 #define DIGITAL_UNIX_COMPATIBLE
1220 #endif
1221
1222 #if defined(PERL_BUG_COMPATIBLE) && !defined(PERL_COMPATIBLE)
1223 #define PERL_COMPATIBLE
1224 #endif
1225
1226 #if defined(LINUX_BUG_COMPATIBLE) && !defined(LINUX_COMPATIBLE)
1227 #define LINUX_COMPATIBLE
1228 #endif
1229
1230 #include <sys/types.h>
1231 #include <string.h>
1232 #include <stdlib.h>
1233 #include <stdio.h>
1234 #include <stdarg.h>
1235 #include <assert.h>
1236 #include <errno.h>
1237
1238 #ifdef isdigit
1239 #undef isdigit
1240 #endif
1241 #define isdigit(c) ((c) >= '0' && (c) <= '9')
1242
1243 /* For copying strings longer or equal to 'breakeven_point'
1244  * it is more efficient to call memcpy() than to do it inline.
1245  * The value depends mostly on the processor architecture,
1246  * but also on the compiler and its optimization capabilities.
1247  * The value is not critical, some small value greater than zero
1248  * will be just fine if you don't care to squeeze every drop
1249  * of performance out of the code.
1250  *
1251  * Small values favor memcpy, large values favor inline code.
1252  */
1253 #if defined(__alpha__) || defined(__alpha)
1254 #  define breakeven_point   2    /* AXP (DEC Alpha)     - gcc or cc or egcs */
1255 #endif
1256 #if defined(__i386__)  || defined(__i386)
1257 #  define breakeven_point  12    /* Intel Pentium/Linux - gcc 2.96 */
1258 #endif
1259 #if defined(__hppa)
1260 #  define breakeven_point  10    /* HP-PA               - gcc */
1261 #endif
1262 #if defined(__sparc__) || defined(__sparc)
1263 #  define breakeven_point  33    /* Sun Sparc 5         - gcc 2.8.1 */
1264 #endif
1265
1266 /* some other values of possible interest: */
1267 /* #define breakeven_point  8 */ /* VAX 4000          - vaxc */
1268 /* #define breakeven_point 19 */ /* VAX 4000          - gcc 2.7.0 */
1269
1270 #ifndef breakeven_point
1271 #  define breakeven_point   6    /* some reasonable one-size-fits-all value */
1272 #endif
1273
1274 #define fast_memcpy(d,s,n) \
1275   { register size_t nn = (size_t)(n); \
1276     if (nn >= breakeven_point) memcpy((d), (s), nn); \
1277     else if (nn > 0) { /* proc call overhead is worth only for large strings*/\
1278       register char *dd; register const char *ss; \
1279       for (ss=(s), dd=(d); nn>0; nn--) *dd++ = *ss++; } }
1280
1281 #define fast_memset(d,c,n) \
1282   { register size_t nn = (size_t)(n); \
1283     if (nn >= breakeven_point) memset((d), (int)(c), nn); \
1284     else if (nn > 0) { /* proc call overhead is worth only for large strings*/\
1285       register char *dd; register const int cc=(int)(c); \
1286       for (dd=(d); nn>0; nn--) *dd++ = cc; } }
1287
1288 /* prototypes */
1289
1290 #if defined(NEED_ASPRINTF)
1291 int asprintf   (char **ptr, const char *fmt, /*args*/ ...);
1292 #endif
1293 #if defined(NEED_VASPRINTF)
1294 int vasprintf  (char **ptr, const char *fmt, va_list ap);
1295 #endif
1296 #if defined(NEED_ASNPRINTF)
1297 int asnprintf  (char **ptr, size_t str_m, const char *fmt, /*args*/ ...);
1298 #endif
1299 #if defined(NEED_VASNPRINTF)
1300 int vasnprintf (char **ptr, size_t str_m, const char *fmt, va_list ap);
1301 #endif
1302
1303 #if defined(HAVE_SNPRINTF)
1304 /* declare our portable snprintf  routine under name portable_snprintf  */
1305 /* declare our portable vsnprintf routine under name portable_vsnprintf */
1306 #else
1307 /* declare our portable routines under names snprintf and vsnprintf */
1308 #define portable_snprintf snprintf
1309 #if !defined(NEED_SNPRINTF_ONLY)
1310 #define portable_vsnprintf vsnprintf
1311 #endif
1312 #endif
1313
1314 #if !defined(HAVE_SNPRINTF) || defined(PREFER_PORTABLE_SNPRINTF)
1315 int portable_snprintf(char *str, size_t str_m, const char *fmt, /*args*/ ...);
1316 #if !defined(NEED_SNPRINTF_ONLY)
1317 int portable_vsnprintf(char *str, size_t str_m, const char *fmt, va_list ap);
1318 #endif
1319 #endif
1320
1321 /* declarations */
1322
1323 static char credits[] = "\n\
1324 @(#)snprintf.c, v2.2: Mark Martinec, <mark.martinec@ijs.si>\n\
1325 @(#)snprintf.c, v2.2: Copyright 1999, Mark Martinec. Frontier Artistic License applies.\n\
1326 @(#)snprintf.c, v2.2: http://www.ijs.si/software/snprintf/\n";
1327
1328 #if defined(NEED_ASPRINTF)
1329 int asprintf(char **ptr, const char *fmt, /*args*/ ...) {
1330   va_list ap;
1331   size_t str_m;
1332   int str_l;
1333
1334   *ptr = NULL;
1335   va_start(ap, fmt);                            /* measure the required size */
1336   str_l = portable_vsnprintf(NULL, (size_t)0, fmt, ap);
1337   va_end(ap);
1338   assert(str_l >= 0);        /* possible integer overflow if str_m > INT_MAX */
1339   *ptr = (char *) malloc(str_m = (size_t)str_l + 1);
1340   if (*ptr == NULL) { errno = ENOMEM; str_l = -1; }
1341   else {
1342     int str_l2;
1343     va_start(ap, fmt);
1344     str_l2 = portable_vsnprintf(*ptr, str_m, fmt, ap);
1345     va_end(ap);
1346     assert(str_l2 == str_l);
1347   }
1348   return str_l;
1349 }
1350 #endif
1351
1352 #if defined(NEED_VASPRINTF)
1353 int vasprintf(char **ptr, const char *fmt, va_list ap) {
1354   size_t str_m;
1355   int str_l;
1356
1357   *ptr = NULL;
1358   { va_list ap2;
1359     va_copy(ap2, ap);  /* don't consume the original ap, we'll need it again */
1360     str_l = portable_vsnprintf(NULL, (size_t)0, fmt, ap2);/*get required size*/
1361     va_end(ap2);
1362   }
1363   assert(str_l >= 0);        /* possible integer overflow if str_m > INT_MAX */
1364   *ptr = (char *) malloc(str_m = (size_t)str_l + 1);
1365   if (*ptr == NULL) { errno = ENOMEM; str_l = -1; }
1366   else {
1367     int str_l2 = portable_vsnprintf(*ptr, str_m, fmt, ap);
1368     assert(str_l2 == str_l);
1369   }
1370   return str_l;
1371 }
1372 #endif
1373
1374 #if defined(NEED_ASNPRINTF)
1375 int asnprintf (char **ptr, size_t str_m, const char *fmt, /*args*/ ...) {
1376   va_list ap;
1377   int str_l;
1378
1379   *ptr = NULL;
1380   va_start(ap, fmt);                            /* measure the required size */
1381   str_l = portable_vsnprintf(NULL, (size_t)0, fmt, ap);
1382   va_end(ap);
1383   assert(str_l >= 0);        /* possible integer overflow if str_m > INT_MAX */
1384   if ((size_t)str_l + 1 < str_m) str_m = (size_t)str_l + 1;      /* truncate */
1385   /* if str_m is 0, no buffer is allocated, just set *ptr to NULL */
1386   if (str_m == 0) {  /* not interested in resulting string, just return size */
1387   } else {
1388     *ptr = (char *) malloc(str_m);
1389     if (*ptr == NULL) { errno = ENOMEM; str_l = -1; }
1390     else {
1391       int str_l2;
1392       va_start(ap, fmt);
1393       str_l2 = portable_vsnprintf(*ptr, str_m, fmt, ap);
1394       va_end(ap);
1395       assert(str_l2 == str_l);
1396     }
1397   }
1398   return str_l;
1399 }
1400 #endif
1401
1402 #if defined(NEED_VASNPRINTF)
1403 int vasnprintf (char **ptr, size_t str_m, const char *fmt, va_list ap) {
1404   int str_l;
1405
1406   *ptr = NULL;
1407   { va_list ap2;
1408     va_copy(ap2, ap);  /* don't consume the original ap, we'll need it again */
1409     str_l = portable_vsnprintf(NULL, (size_t)0, fmt, ap2);/*get required size*/
1410     va_end(ap2);
1411   }
1412   assert(str_l >= 0);        /* possible integer overflow if str_m > INT_MAX */
1413   if ((size_t)str_l + 1 < str_m) str_m = (size_t)str_l + 1;      /* truncate */
1414   /* if str_m is 0, no buffer is allocated, just set *ptr to NULL */
1415   if (str_m == 0) {  /* not interested in resulting string, just return size */
1416   } else {
1417     *ptr = (char *) malloc(str_m);
1418     if (*ptr == NULL) { errno = ENOMEM; str_l = -1; }
1419     else {
1420       int str_l2 = portable_vsnprintf(*ptr, str_m, fmt, ap);
1421       assert(str_l2 == str_l);
1422     }
1423   }
1424   return str_l;
1425 }
1426 #endif
1427
1428 /*
1429  * If the system does have snprintf and the portable routine is not
1430  * specifically required, this module produces no code for snprintf/vsnprintf.
1431  */
1432 #if !defined(HAVE_SNPRINTF) || defined(PREFER_PORTABLE_SNPRINTF)
1433
1434 #if !defined(NEED_SNPRINTF_ONLY)
1435 int portable_snprintf(char *str, size_t str_m, const char *fmt, /*args*/ ...) {
1436   va_list ap;
1437   int str_l;
1438
1439   va_start(ap, fmt);
1440   str_l = portable_vsnprintf(str, str_m, fmt, ap);
1441   va_end(ap);
1442   return str_l;
1443 }
1444 #endif
1445
1446 #if defined(NEED_SNPRINTF_ONLY)
1447 int portable_snprintf(char *str, size_t str_m, const char *fmt, /*args*/ ...) {
1448 #else
1449 int portable_vsnprintf(char *str, size_t str_m, const char *fmt, va_list ap) {
1450 #endif
1451
1452 #if defined(NEED_SNPRINTF_ONLY)
1453   va_list ap;
1454 #endif
1455   size_t str_l = 0;
1456   const char *p = fmt;
1457
1458 /* In contrast with POSIX, the ISO C99 now says
1459  * that str can be NULL and str_m can be 0.
1460  * This is more useful than the old:  if (str_m < 1) return -1; */
1461
1462 #if defined(NEED_SNPRINTF_ONLY)
1463   va_start(ap, fmt);
1464 #endif
1465   if (!p) p = "";
1466   while (*p) {
1467     if (*p != '%') {
1468    /* if (str_l < str_m) str[str_l++] = *p++;    -- this would be sufficient */
1469    /* but the following code achieves better performance for cases
1470     * where format string is long and contains few conversions */
1471       const char *q = strchr(p+1,'%');
1472       size_t n = !q ? strlen(p) : (q-p);
1473       if (str_l < str_m) {
1474         size_t avail = str_m-str_l;
1475         fast_memcpy(str+str_l, p, (n>avail?avail:n));
1476       }
1477       p += n; str_l += n;
1478     } else {
1479       const char *starting_p;
1480       size_t min_field_width = 0, precision = 0;
1481       int zero_padding = 0, precision_specified = 0, justify_left = 0;
1482       int alternate_form = 0, force_sign = 0;
1483       int space_for_positive = 1; /* If both the ' ' and '+' flags appear,
1484                                      the ' ' flag should be ignored. */
1485       char length_modifier = '\0';            /* allowed values: \0, h, l, L */
1486       char tmp[32];/* temporary buffer for simple numeric->string conversion */
1487
1488       const char *str_arg;      /* string address in case of string argument */
1489       size_t str_arg_l;         /* natural field width of arg without padding
1490                                    and sign */
1491       unsigned char uchar_arg;
1492         /* unsigned char argument value - only defined for c conversion.
1493            N.B. standard explicitly states the char argument for
1494            the c conversion is unsigned */
1495
1496       size_t number_of_zeros_to_pad = 0;
1497         /* number of zeros to be inserted for numeric conversions
1498            as required by the precision or minimal field width */
1499
1500       size_t zero_padding_insertion_ind = 0;
1501         /* index into tmp where zero padding is to be inserted */
1502
1503       char fmt_spec = '\0';
1504         /* current conversion specifier character */
1505
1506       str_arg = credits;/* just to make compiler happy (defined but not used)*/
1507       str_arg = NULL;
1508       starting_p = p; p++;  /* skip '%' */
1509    /* parse flags */
1510       while (*p == '0' || *p == '-' || *p == '+' ||
1511              *p == ' ' || *p == '#' || *p == '\'') {
1512         switch (*p) {
1513         case '0': zero_padding = 1; break;
1514         case '-': justify_left = 1; break;
1515         case '+': force_sign = 1; space_for_positive = 0; break;
1516         case ' ': force_sign = 1;
1517      /* If both the ' ' and '+' flags appear, the ' ' flag should be ignored */
1518 #ifdef PERL_COMPATIBLE
1519      /* ... but in Perl the last of ' ' and '+' applies */
1520                   space_for_positive = 1;
1521 #endif
1522                   break;
1523         case '#': alternate_form = 1; break;
1524         case '\'': break;
1525         }
1526         p++;
1527       }
1528    /* If the '0' and '-' flags both appear, the '0' flag should be ignored. */
1529
1530    /* parse field width */
1531       if (*p == '*') {
1532         int j;
1533         p++; j = va_arg(ap, int);
1534         if (j >= 0) min_field_width = j;
1535         else { min_field_width = -j; justify_left = 1; }
1536       } else if (isdigit((int)(*p))) {
1537         /* size_t could be wider than unsigned int;
1538            make sure we treat argument like common implementations do */
1539         unsigned int uj = *p++ - '0';
1540         while (isdigit((int)(*p))) uj = 10*uj + (unsigned int)(*p++ - '0');
1541         min_field_width = uj;
1542       }
1543    /* parse precision */
1544       if (*p == '.') {
1545         p++; precision_specified = 1;
1546         if (*p == '*') {
1547           int j = va_arg(ap, int);
1548           p++;
1549           if (j >= 0) precision = j;
1550           else {
1551             precision_specified = 0; precision = 0;
1552          /* NOTE:
1553           *   Solaris 2.6 man page claims that in this case the precision
1554           *   should be set to 0.  Digital Unix 4.0, HPUX 10 and BSD man page
1555           *   claim that this case should be treated as unspecified precision,
1556           *   which is what we do here.
1557           */
1558           }
1559         } else if (isdigit((int)(*p))) {
1560           /* size_t could be wider than unsigned int;
1561              make sure we treat argument like common implementations do */
1562           unsigned int uj = *p++ - '0';
1563           while (isdigit((int)(*p))) uj = 10*uj + (unsigned int)(*p++ - '0');
1564           precision = uj;
1565         }
1566       }
1567    /* parse 'h', 'l' and 'll' length modifiers */
1568       if (*p == 'h' || *p == 'l') {
1569         length_modifier = *p; p++;
1570         if (length_modifier == 'l' && *p == 'l') {   /* double l = long long */
1571 #ifdef SNPRINTF_LONGLONG_SUPPORT
1572           length_modifier = '2';                  /* double l encoded as '2' */
1573 #else
1574           length_modifier = 'l';                 /* treat it as a single 'l' */
1575 #endif
1576           p++;
1577         }
1578       }
1579       fmt_spec = *p;
1580    /* common synonyms: */
1581       switch (fmt_spec) {
1582       case 'i': fmt_spec = 'd'; break;
1583       case 'D': fmt_spec = 'd'; length_modifier = 'l'; break;
1584       case 'U': fmt_spec = 'u'; length_modifier = 'l'; break;
1585       case 'O': fmt_spec = 'o'; length_modifier = 'l'; break;
1586       default: break;
1587       }
1588    /* get parameter value, do initial processing */
1589       switch (fmt_spec) {
1590       case '%': /* % behaves similar to 's' regarding flags and field widths */
1591       case 'c': /* c behaves similar to 's' regarding flags and field widths */
1592       case 's':
1593         length_modifier = '\0';          /* wint_t and wchar_t not supported */
1594      /* the result of zero padding flag with non-numeric conversion specifier*/
1595      /* is undefined. Solaris and HPUX 10 does zero padding in this case,    */
1596      /* Digital Unix and Linux does not. */
1597 #if !defined(SOLARIS_COMPATIBLE) && !defined(HPUX_COMPATIBLE)
1598         zero_padding = 0;    /* turn zero padding off for string conversions */
1599 #endif
1600         str_arg_l = 1;
1601         switch (fmt_spec) {
1602         case '%':
1603           str_arg = p; break;
1604         case 'c': {
1605           int j = va_arg(ap, int);
1606           uchar_arg = (unsigned char) j;   /* standard demands unsigned char */
1607           str_arg = (const char *) &uchar_arg;
1608           break;
1609         }
1610         case 's':
1611           str_arg = va_arg(ap, const char *);
1612           if (!str_arg) str_arg_l = 0;
1613        /* make sure not to address string beyond the specified precision !!! */
1614           else if (!precision_specified) str_arg_l = strlen(str_arg);
1615        /* truncate string if necessary as requested by precision */
1616           else if (precision == 0) str_arg_l = 0;
1617           else {
1618        /* memchr on HP does not like n > 2^31  !!! */
1619             const char *q = memchr(str_arg, '\0',
1620                              precision <= 0x7fffffff ? precision : 0x7fffffff);
1621             str_arg_l = !q ? precision : (q-str_arg);
1622           }
1623           break;
1624         default: break;
1625         }
1626         break;
1627       case 'd': case 'u': case 'o': case 'x': case 'X': case 'p': {
1628         /* NOTE: the u, o, x, X and p conversion specifiers imply
1629                  the value is unsigned;  d implies a signed value */
1630
1631         int arg_sign = 0;
1632           /* 0 if numeric argument is zero (or if pointer is NULL for 'p'),
1633             +1 if greater than zero (or nonzero for unsigned arguments),
1634             -1 if negative (unsigned argument is never negative) */
1635
1636         int int_arg = 0;  unsigned int uint_arg = 0;
1637           /* only defined for length modifier h, or for no length modifiers */
1638
1639         long int long_arg = 0;  unsigned long int ulong_arg = 0;
1640           /* only defined for length modifier l */
1641
1642         void *ptr_arg = NULL;
1643           /* pointer argument value -only defined for p conversion */
1644
1645 #ifdef SNPRINTF_LONGLONG_SUPPORT
1646         long long int long_long_arg = 0;
1647         unsigned long long int ulong_long_arg = 0;
1648           /* only defined for length modifier ll */
1649 #endif
1650         if (fmt_spec == 'p') {
1651         /* HPUX 10: An l, h, ll or L before any other conversion character
1652          *   (other than d, i, u, o, x, or X) is ignored.
1653          * Digital Unix:
1654          *   not specified, but seems to behave as HPUX does.
1655          * Solaris: If an h, l, or L appears before any other conversion
1656          *   specifier (other than d, i, u, o, x, or X), the behavior
1657          *   is undefined. (Actually %hp converts only 16-bits of address
1658          *   and %llp treats address as 64-bit data which is incompatible
1659          *   with (void *) argument on a 32-bit system).
1660          */
1661 #ifdef SOLARIS_COMPATIBLE
1662 #  ifdef SOLARIS_BUG_COMPATIBLE
1663           /* keep length modifiers even if it represents 'll' */
1664 #  else
1665           if (length_modifier == '2') length_modifier = '\0';
1666 #  endif
1667 #else
1668           length_modifier = '\0';
1669 #endif
1670           ptr_arg = va_arg(ap, void *);
1671           if (ptr_arg != NULL) arg_sign = 1;
1672         } else if (fmt_spec == 'd') {  /* signed */
1673           switch (length_modifier) {
1674           case '\0':
1675           case 'h':
1676          /* It is non-portable to specify a second argument of char or short
1677           * to va_arg, because arguments seen by the called function
1678           * are not char or short.  C converts char and short arguments
1679           * to int before passing them to a function.
1680           */
1681             int_arg = va_arg(ap, int);
1682             if      (int_arg > 0) arg_sign =  1;
1683             else if (int_arg < 0) arg_sign = -1;
1684             break;
1685           case 'l':
1686             long_arg = va_arg(ap, long int);
1687             if      (long_arg > 0) arg_sign =  1;
1688             else if (long_arg < 0) arg_sign = -1;
1689             break;
1690 #ifdef SNPRINTF_LONGLONG_SUPPORT
1691           case '2':
1692             long_long_arg = va_arg(ap, long long int);
1693             if      (long_long_arg > 0) arg_sign =  1;
1694             else if (long_long_arg < 0) arg_sign = -1;
1695             break;
1696 #endif
1697           }
1698         } else {  /* unsigned */
1699           switch (length_modifier) {
1700           case '\0':
1701           case 'h':
1702             uint_arg = va_arg(ap, unsigned int);
1703             if (uint_arg) arg_sign = 1;
1704             break;
1705           case 'l':
1706             ulong_arg = va_arg(ap, unsigned long int);
1707             if (ulong_arg) arg_sign = 1;
1708             break;
1709 #ifdef SNPRINTF_LONGLONG_SUPPORT
1710           case '2':
1711             ulong_long_arg = va_arg(ap, unsigned long long int);
1712             if (ulong_long_arg) arg_sign = 1;
1713             break;
1714 #endif
1715           }
1716         }
1717         str_arg = tmp; str_arg_l = 0;
1718      /* NOTE:
1719       *   For d, i, u, o, x, and X conversions, if precision is specified,
1720       *   the '0' flag should be ignored. This is so with Solaris 2.6,
1721       *   Digital UNIX 4.0, HPUX 10, Linux, FreeBSD, NetBSD; but not with Perl.
1722       */
1723 #ifndef PERL_COMPATIBLE
1724         if (precision_specified) zero_padding = 0;
1725 #endif
1726         if (fmt_spec == 'd') {
1727           if (force_sign && arg_sign >= 0)
1728             tmp[str_arg_l++] = space_for_positive ? ' ' : '+';
1729          /* leave negative numbers for sprintf to handle,
1730             to avoid handling tricky cases like (short int)(-32768) */
1731 #ifdef LINUX_COMPATIBLE
1732         } else if (fmt_spec == 'p' && force_sign && arg_sign > 0) {
1733           tmp[str_arg_l++] = space_for_positive ? ' ' : '+';
1734 #endif
1735         } else if (alternate_form) {
1736           if (arg_sign != 0 && (fmt_spec == 'x' || fmt_spec == 'X') )
1737             { tmp[str_arg_l++] = '0'; tmp[str_arg_l++] = fmt_spec; }
1738          /* alternate form should have no effect for p conversion, but ... */
1739 #ifdef HPUX_COMPATIBLE
1740           else if (fmt_spec == 'p'
1741          /* HPUX 10: for an alternate form of p conversion,
1742           *          a nonzero result is prefixed by 0x. */
1743 #ifndef HPUX_BUG_COMPATIBLE
1744          /* Actually it uses 0x prefix even for a zero value. */
1745                    && arg_sign != 0
1746 #endif
1747                   ) { tmp[str_arg_l++] = '0'; tmp[str_arg_l++] = 'x'; }
1748 #endif
1749         }
1750         zero_padding_insertion_ind = str_arg_l;
1751         if (!precision_specified) precision = 1;   /* default precision is 1 */
1752         if (precision == 0 && arg_sign == 0
1753 #if defined(HPUX_BUG_COMPATIBLE) || defined(LINUX_COMPATIBLE)
1754             && fmt_spec != 'p'
1755          /* HPUX 10 man page claims: With conversion character p the result of
1756           * converting a zero value with a precision of zero is a null string.
1757           * Actually HP returns all zeroes, and Linux returns "(nil)". */
1758 #endif
1759         ) {
1760          /* converted to null string */
1761          /* When zero value is formatted with an explicit precision 0,
1762             the resulting formatted string is empty (d, i, u, o, x, X, p).   */
1763         } else {
1764           char f[5]; int f_l = 0;
1765           f[f_l++] = '%';    /* construct a simple format string for sprintf */
1766           if (!length_modifier) { }
1767           else if (length_modifier=='2') { f[f_l++] = 'l'; f[f_l++] = 'l'; }
1768           else f[f_l++] = length_modifier;
1769           f[f_l++] = fmt_spec; f[f_l++] = '\0';
1770           if (fmt_spec == 'p') str_arg_l += sprintf(tmp+str_arg_l, f, ptr_arg);
1771           else if (fmt_spec == 'd') {  /* signed */
1772             switch (length_modifier) {
1773             case '\0':
1774             case 'h': str_arg_l+=sprintf(tmp+str_arg_l, f, int_arg);  break;
1775             case 'l': str_arg_l+=sprintf(tmp+str_arg_l, f, long_arg); break;
1776 #ifdef SNPRINTF_LONGLONG_SUPPORT
1777             case '2': str_arg_l+=sprintf(tmp+str_arg_l,f,long_long_arg); break;
1778 #endif
1779             }
1780           } else {  /* unsigned */
1781             switch (length_modifier) {
1782             case '\0':
1783             case 'h': str_arg_l+=sprintf(tmp+str_arg_l, f, uint_arg);  break;
1784             case 'l': str_arg_l+=sprintf(tmp+str_arg_l, f, ulong_arg); break;
1785 #ifdef SNPRINTF_LONGLONG_SUPPORT
1786             case '2': str_arg_l+=sprintf(tmp+str_arg_l,f,ulong_long_arg);break;
1787 #endif
1788             }
1789           }
1790          /* include the optional minus sign and possible "0x"
1791             in the region before the zero padding insertion point */
1792           if (zero_padding_insertion_ind < str_arg_l &&
1793               tmp[zero_padding_insertion_ind] == '-') {
1794             zero_padding_insertion_ind++;
1795           }
1796           if (zero_padding_insertion_ind+1 < str_arg_l &&
1797               tmp[zero_padding_insertion_ind]   == '0' &&
1798              (tmp[zero_padding_insertion_ind+1] == 'x' ||
1799               tmp[zero_padding_insertion_ind+1] == 'X') ) {
1800             zero_padding_insertion_ind += 2;
1801           }
1802         }
1803         { size_t num_of_digits = str_arg_l - zero_padding_insertion_ind;
1804           if (alternate_form && fmt_spec == 'o'
1805 #ifdef HPUX_COMPATIBLE                                  /* ("%#.o",0) -> ""  */
1806               && (str_arg_l > 0)
1807 #endif
1808 #ifdef DIGITAL_UNIX_BUG_COMPATIBLE                      /* ("%#o",0) -> "00" */
1809 #else
1810               /* unless zero is already the first character */
1811               && !(zero_padding_insertion_ind < str_arg_l
1812                    && tmp[zero_padding_insertion_ind] == '0')
1813 #endif
1814           ) {        /* assure leading zero for alternate-form octal numbers */
1815             if (!precision_specified || precision < num_of_digits+1) {
1816              /* precision is increased to force the first character to be zero,
1817                 except if a zero value is formatted with an explicit precision
1818                 of zero */
1819               precision = num_of_digits+1; precision_specified = 1;
1820             }
1821           }
1822        /* zero padding to specified precision? */
1823           if (num_of_digits < precision) 
1824             number_of_zeros_to_pad = precision - num_of_digits;
1825         }
1826      /* zero padding to specified minimal field width? */
1827         if (!justify_left && zero_padding) {
1828           int n = min_field_width - (str_arg_l+number_of_zeros_to_pad);
1829           if (n > 0) number_of_zeros_to_pad += n;
1830         }
1831         break;
1832       }
1833       default: /* unrecognized conversion specifier, keep format string as-is*/
1834         zero_padding = 0;  /* turn zero padding off for non-numeric convers. */
1835 #ifndef DIGITAL_UNIX_COMPATIBLE
1836         justify_left = 1; min_field_width = 0;                /* reset flags */
1837 #endif
1838 #if defined(PERL_COMPATIBLE) || defined(LINUX_COMPATIBLE)
1839      /* keep the entire format string unchanged */
1840         str_arg = starting_p; str_arg_l = p - starting_p;
1841      /* well, not exactly so for Linux, which does something inbetween,
1842       * and I don't feel an urge to imitate it: "%+++++hy" -> "%+y"  */
1843 #else
1844      /* discard the unrecognized conversion, just keep *
1845       * the unrecognized conversion character          */
1846         str_arg = p; str_arg_l = 0;
1847 #endif
1848         if (*p) str_arg_l++;  /* include invalid conversion specifier unchanged
1849                                  if not at end-of-string */
1850         break;
1851       }
1852       if (*p) p++;      /* step over the just processed conversion specifier */
1853    /* insert padding to the left as requested by min_field_width;
1854       this does not include the zero padding in case of numerical conversions*/
1855       if (!justify_left) {                /* left padding with blank or zero */
1856         int n = min_field_width - (str_arg_l+number_of_zeros_to_pad);
1857         if (n > 0) {
1858           if (str_l < str_m) {
1859             size_t avail = str_m-str_l;
1860             fast_memset(str+str_l, (zero_padding?'0':' '), (n>avail?avail:n));
1861           }
1862           str_l += n;
1863         }
1864       }
1865    /* zero padding as requested by the precision or by the minimal field width
1866     * for numeric conversions required? */
1867       if (number_of_zeros_to_pad <= 0) {
1868      /* will not copy first part of numeric right now, *
1869       * force it to be copied later in its entirety    */
1870         zero_padding_insertion_ind = 0;
1871       } else {
1872      /* insert first part of numerics (sign or '0x') before zero padding */
1873         int n = zero_padding_insertion_ind;
1874         if (n > 0) {
1875           if (str_l < str_m) {
1876             size_t avail = str_m-str_l;
1877             fast_memcpy(str+str_l, str_arg, (n>avail?avail:n));
1878           }
1879           str_l += n;
1880         }
1881      /* insert zero padding as requested by the precision or min field width */
1882         n = number_of_zeros_to_pad;
1883         if (n > 0) {
1884           if (str_l < str_m) {
1885             size_t avail = str_m-str_l;
1886             fast_memset(str+str_l, '0', (n>avail?avail:n));
1887           }
1888           str_l += n;
1889         }
1890       }
1891    /* insert formatted string
1892     * (or as-is conversion specifier for unknown conversions) */
1893       { int n = str_arg_l - zero_padding_insertion_ind;
1894         if (n > 0) {
1895           if (str_l < str_m) {
1896             size_t avail = str_m-str_l;
1897             fast_memcpy(str+str_l, str_arg+zero_padding_insertion_ind,
1898                         (n>avail?avail:n));
1899           }
1900           str_l += n;
1901         }
1902       }
1903    /* insert right padding */
1904       if (justify_left) {          /* right blank padding to the field width */
1905         int n = min_field_width - (str_arg_l+number_of_zeros_to_pad);
1906         if (n > 0) {
1907           if (str_l < str_m) {
1908             size_t avail = str_m-str_l;
1909             fast_memset(str+str_l, ' ', (n>avail?avail:n));
1910           }
1911           str_l += n;
1912         }
1913       }
1914     }
1915   }
1916 #if defined(NEED_SNPRINTF_ONLY)
1917   va_end(ap);
1918 #endif
1919   if (str_m > 0) { /* make sure the string is null-terminated
1920                       even at the expense of overwriting the last character
1921                       (shouldn't happen, but just in case) */
1922     str[str_l <= str_m-1 ? str_l : str_m-1] = '\0';
1923   }
1924   /* Return the number of characters formatted (excluding trailing null
1925    * character), that is, the number of characters that would have been
1926    * written to the buffer if it were large enough.
1927    *
1928    * The value of str_l should be returned, but str_l is of unsigned type
1929    * size_t, and snprintf is int, possibly leading to an undetected
1930    * integer overflow, resulting in a negative return value, which is illegal.
1931    * Both XSH5 and ISO C99 (at least the draft) are silent on this issue.
1932    * Should errno be set to EOVERFLOW and EOF returned in this case???
1933    */
1934   return (int) str_l;
1935 }
1936 #endif
1937 #endif /* ndef HAVE_SNPRINTF */
1938 /*
1939   Local Variables:
1940   tab-width: 3
1941   end:
1942 */