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