Change write_pid_file()'s prototype to take the path as argument
[privoxy.git] / miscutil.c
1 const char miscutil_rcs[] = "$Id: miscutil.c,v 1.85 2017/06/08 13:11:08 fabiankeil Exp $";
2 /*********************************************************************
3  *
4  * File        :  $Source: /cvsroot/ijbswa/current/miscutil.c,v $
5  *
6  * Purpose     :  zalloc, hash_string, strcmpic, strncmpic, and
7  *                MinGW32 strdup functions.  These are each too small
8  *                to deserve their own file but don't really fit in
9  *                any other file.
10  *
11  * Copyright   :  Written by and Copyright (C) 2001-2016 the
12  *                Privoxy team. http://www.privoxy.org/
13  *
14  *                Based on the Internet Junkbuster originally written
15  *                by and Copyright (C) 1997 Anonymous Coders and
16  *                Junkbusters Corporation.  http://www.junkbusters.com
17  *
18  *                The timegm replacement function was taken from GnuPG,
19  *                Copyright (C) 2004 Free Software Foundation, Inc.
20  *
21  *                The snprintf replacement function is written by
22  *                Mark Martinec who also holds the copyright. It can be
23  *                used under the terms of the GPL or the terms of the
24  *                "Frontier Artistic License".
25  *
26  *                This program is free software; you can redistribute it
27  *                and/or modify it under the terms of the GNU General
28  *                Public License as published by the Free Software
29  *                Foundation; either version 2 of the License, or (at
30  *                your option) any later version.
31  *
32  *                This program is distributed in the hope that it will
33  *                be useful, but WITHOUT ANY WARRANTY; without even the
34  *                implied warranty of MERCHANTABILITY or FITNESS FOR A
35  *                PARTICULAR PURPOSE.  See the GNU General Public
36  *                License for more details.
37  *
38  *                The GNU General Public License should be included with
39  *                this file.  If not, you can view it at
40  *                http://www.gnu.org/copyleft/gpl.html
41  *                or write to the Free Software Foundation, Inc., 59
42  *                Temple Place - Suite 330, Boston, MA  02111-1307, USA.
43  *
44  *********************************************************************/
45
46
47 #include "config.h"
48
49 #include <stdio.h>
50 #include <sys/types.h>
51 #include <stdlib.h>
52 #if !defined(_WIN32) && !defined(__OS2__)
53 #include <unistd.h>
54 #endif /* #if !defined(_WIN32) && !defined(__OS2__) */
55 #include <string.h>
56 #include <ctype.h>
57 #include <assert.h>
58
59 #if !defined(HAVE_TIMEGM) && defined(HAVE_TZSET) && defined(HAVE_PUTENV)
60 #include <time.h>
61 #endif /* !defined(HAVE_TIMEGM) && defined(HAVE_TZSET) && defined(HAVE_PUTENV) */
62
63 #include "project.h"
64 #include "miscutil.h"
65 #include "errlog.h"
66
67 const char miscutil_h_rcs[] = MISCUTIL_H_VERSION;
68
69 /*********************************************************************
70  *
71  * Function    :  zalloc
72  *
73  * Description :  Returns allocated memory that is initialized
74  *                with zeros.
75  *
76  * Parameters  :
77  *          1  :  size = Size of memory chunk to return.
78  *
79  * Returns     :  Pointer to newly alloc'd memory chunk.
80  *
81  *********************************************************************/
82 void *zalloc(size_t size)
83 {
84    void * ret;
85
86 #ifdef HAVE_CALLOC
87    ret = calloc(1, size);
88 #else
89 #warning calloc appears to be unavailable. Your platform will become unsupported in the future
90    if ((ret = (void *)malloc(size)) != NULL)
91    {
92       memset(ret, 0, size);
93    }
94 #endif
95
96    return(ret);
97
98 }
99
100
101 /*********************************************************************
102  *
103  * Function    :  zalloc_or_die
104  *
105  * Description :  zalloc wrapper that either succeeds or causes
106  *                program termination.
107  *
108  *                Useful in situations were the string length is
109  *                "small" and zalloc() failures couldn't be handled
110  *                better anyway. In case of debug builds, failures
111  *                trigger an assert().
112  *
113  * Parameters  :
114  *          1  :  size = Size of memory chunk to return.
115  *
116  * Returns     :  Pointer to newly malloc'd memory chunk.
117  *
118  *********************************************************************/
119 void *zalloc_or_die(size_t size)
120 {
121    void *buffer;
122
123    buffer = zalloc(size);
124    if (buffer == NULL)
125    {
126       assert(buffer != NULL);
127       log_error(LOG_LEVEL_FATAL, "Out of memory in zalloc_or_die().");
128       exit(1);
129    }
130
131    return(buffer);
132
133 }
134
135 /*********************************************************************
136  *
137  * Function    :  strdup_or_die
138  *
139  * Description :  strdup wrapper that either succeeds or causes
140  *                program termination.
141  *
142  *                Useful in situations were the string length is
143  *                "small" and strdup() failures couldn't be handled
144  *                better anyway. In case of debug builds, failures
145  *                trigger an assert().
146  *
147  * Parameters  :
148  *          1  :  str = String to duplicate
149  *
150  * Returns     :  Pointer to newly strdup'd copy of the string.
151  *
152  *********************************************************************/
153 char *strdup_or_die(const char *str)
154 {
155    char *new_str;
156
157    new_str = strdup(str);
158
159    if (new_str == NULL)
160    {
161       assert(new_str != NULL);
162       log_error(LOG_LEVEL_FATAL, "Out of memory in strdup_or_die().");
163       exit(1);
164    }
165
166    return(new_str);
167
168 }
169
170
171 /*********************************************************************
172  *
173  * Function    :  malloc_or_die
174  *
175  * Description :  malloc wrapper that either succeeds or causes
176  *                program termination.
177  *
178  *                Useful in situations were the buffer size is "small"
179  *                and malloc() failures couldn't be handled better
180  *                anyway. In case of debug builds, failures trigger
181  *                an assert().
182  *
183  * Parameters  :
184  *          1  :  buffer_size = Size of the space to allocate
185  *
186  * Returns     :  Pointer to newly malloc'd memory
187  *
188  *********************************************************************/
189 void *malloc_or_die(size_t buffer_size)
190 {
191    char *new_buf;
192
193    if (buffer_size == 0)
194    {
195       log_error(LOG_LEVEL_ERROR,
196          "malloc_or_die() called with buffer size 0");
197       assert(buffer_size != 0);
198       buffer_size = 4096;
199    }
200
201    new_buf = malloc(buffer_size);
202
203    if (new_buf == NULL)
204    {
205       assert(new_buf != NULL);
206       log_error(LOG_LEVEL_FATAL, "Out of memory in malloc_or_die().");
207       exit(1);
208    }
209
210    return(new_buf);
211
212 }
213
214
215 #if defined(unix)
216 /*********************************************************************
217  *
218  * Function    :  write_pid_file
219  *
220  * Description :  Writes a pid file with the pid of the main process.
221  *                Exits if the file can't be opened
222  *
223  * Parameters  :
224  *          1  :  pidfile = Path of the pidfile that gets created.
225  *
226  * Returns     :  N/A
227  *
228  *********************************************************************/
229 void write_pid_file(const char *pidfile)
230 {
231    FILE   *fp;
232
233    if ((fp = fopen(pidfile, "w")) == NULL)
234    {
235       log_error(LOG_LEVEL_FATAL, "can't open pidfile '%s': %E", pidfile);
236    }
237    else
238    {
239       fprintf(fp, "%u\n", (unsigned int) getpid());
240       fclose (fp);
241    }
242    return;
243
244 }
245 #endif /* def unix */
246
247
248 /*********************************************************************
249  *
250  * Function    :  hash_string
251  *
252  * Description :  Take a string and compute a (hopefuly) unique numeric
253  *                integer value. This is useful to "switch" a string.
254  *
255  * Parameters  :
256  *          1  :  s : string to be hashed.
257  *
258  * Returns     :  The string's hash
259  *
260  *********************************************************************/
261 unsigned int hash_string(const char* s)
262 {
263    unsigned int h = 0;
264
265    for (; *s; ++s)
266    {
267       h = 5 * h + (unsigned int)*s;
268    }
269
270    return (h);
271
272 }
273
274
275 /*********************************************************************
276  *
277  * Function    :  strcmpic
278  *
279  * Description :  Case insensitive string comparison
280  *
281  * Parameters  :
282  *          1  :  s1 = string 1 to compare
283  *          2  :  s2 = string 2 to compare
284  *
285  * Returns     :  0 if s1==s2, Negative if s1<s2, Positive if s1>s2
286  *
287  *********************************************************************/
288 int strcmpic(const char *s1, const char *s2)
289 {
290    if (!s1) s1 = "";
291    if (!s2) s2 = "";
292
293    while (*s1 && *s2)
294    {
295       if ((*s1 != *s2) && (privoxy_tolower(*s1) != privoxy_tolower(*s2)))
296       {
297          break;
298       }
299       s1++, s2++;
300    }
301    return(privoxy_tolower(*s1) - privoxy_tolower(*s2));
302
303 }
304
305
306 /*********************************************************************
307  *
308  * Function    :  strncmpic
309  *
310  * Description :  Case insensitive string comparison (up to n characters)
311  *
312  * Parameters  :
313  *          1  :  s1 = string 1 to compare
314  *          2  :  s2 = string 2 to compare
315  *          3  :  n = maximum characters to compare
316  *
317  * Returns     :  0 if s1==s2, Negative if s1<s2, Positive if s1>s2
318  *
319  *********************************************************************/
320 int strncmpic(const char *s1, const char *s2, size_t n)
321 {
322    if (n <= (size_t)0) return(0);
323    if (!s1) s1 = "";
324    if (!s2) s2 = "";
325
326    while (*s1 && *s2)
327    {
328       if ((*s1 != *s2) && (privoxy_tolower(*s1) != privoxy_tolower(*s2)))
329       {
330          break;
331       }
332
333       if (--n <= (size_t)0) break;
334
335       s1++, s2++;
336    }
337    return(privoxy_tolower(*s1) - privoxy_tolower(*s2));
338
339 }
340
341
342 /*********************************************************************
343  *
344  * Function    :  chomp
345  *
346  * Description :  In-situ-eliminate all leading and trailing whitespace
347  *                from a string.
348  *
349  * Parameters  :
350  *          1  :  s : string to be chomped.
351  *
352  * Returns     :  chomped string
353  *
354  *********************************************************************/
355 char *chomp(char *string)
356 {
357    char *p, *q, *r;
358
359    /*
360     * strip trailing whitespace
361     */
362    p = string + strlen(string);
363    while (p > string && privoxy_isspace(*(p-1)))
364    {
365       p--;
366    }
367    *p = '\0';
368
369    /*
370     * find end of leading whitespace
371     */
372    q = r = string;
373    while (*q && privoxy_isspace(*q))
374    {
375       q++;
376    }
377
378    /*
379     * if there was any, move the rest forwards
380     */
381    if (q != string)
382    {
383       while (q <= p)
384       {
385          *r++ = *q++;
386       }
387    }
388
389    return(string);
390
391 }
392
393
394 /*********************************************************************
395  *
396  * Function    :  string_append
397  *
398  * Description :  Reallocate target_string and append text to it.
399  *                This makes it easier to append to malloc'd strings.
400  *                This is similar to the (removed) strsav(), but
401  *                running out of memory isn't catastrophic.
402  *
403  *                Programming style:
404  *
405  *                The following style provides sufficient error
406  *                checking for this routine, with minimal clutter
407  *                in the source code.  It is recommended if you
408  *                have many calls to this function:
409  *
410  *                char * s = strdup(...); // don't check for error
411  *                string_append(&s, ...);  // don't check for error
412  *                string_append(&s, ...);  // don't check for error
413  *                string_append(&s, ...);  // don't check for error
414  *                if (NULL == s) { ... handle error ... }
415  *
416  *                OR, equivalently:
417  *
418  *                char * s = strdup(...); // don't check for error
419  *                string_append(&s, ...);  // don't check for error
420  *                string_append(&s, ...);  // don't check for error
421  *                if (string_append(&s, ...)) {... handle error ...}
422  *
423  * Parameters  :
424  *          1  :  target_string = Pointer to old text that is to be
425  *                extended.  *target_string will be free()d by this
426  *                routine.  target_string must be non-NULL.
427  *                If *target_string is NULL, this routine will
428  *                do nothing and return with an error - this allows
429  *                you to make many calls to this routine and only
430  *                check for errors after the last one.
431  *          2  :  text_to_append = Text to be appended to old.
432  *                Must not be NULL.
433  *
434  * Returns     :  JB_ERR_OK on success, and sets *target_string
435  *                   to newly malloc'ed appended string.  Caller
436  *                   must free(*target_string).
437  *                JB_ERR_MEMORY on out-of-memory.  (And free()s
438  *                   *target_string and sets it to NULL).
439  *                JB_ERR_MEMORY if *target_string is NULL.
440  *
441  *********************************************************************/
442 jb_err string_append(char **target_string, const char *text_to_append)
443 {
444    size_t old_len;
445    char *new_string;
446    size_t new_size;
447
448    assert(target_string);
449    assert(text_to_append);
450
451    if (*target_string == NULL)
452    {
453       return JB_ERR_MEMORY;
454    }
455
456    if (*text_to_append == '\0')
457    {
458       return JB_ERR_OK;
459    }
460
461    old_len = strlen(*target_string);
462
463    new_size = strlen(text_to_append) + old_len + 1;
464
465    if (NULL == (new_string = realloc(*target_string, new_size)))
466    {
467       free(*target_string);
468
469       *target_string = NULL;
470       return JB_ERR_MEMORY;
471    }
472
473    strlcpy(new_string + old_len, text_to_append, new_size - old_len);
474
475    *target_string = new_string;
476    return JB_ERR_OK;
477 }
478
479
480 /*********************************************************************
481  *
482  * Function    :  string_join
483  *
484  * Description :  Join two strings together.  Frees BOTH the original
485  *                strings.  If either or both input strings are NULL,
486  *                fails as if it had run out of memory.
487  *
488  *                For comparison, string_append requires that the
489  *                second string is non-NULL, and doesn't free it.
490  *
491  *                Rationale: Too often, we want to do
492  *                string_append(s, html_encode(s2)).  That assert()s
493  *                if s2 is NULL or if html_encode() runs out of memory.
494  *                It also leaks memory.  Proper checking is cumbersome.
495  *                The solution: string_join(s, html_encode(s2)) is safe,
496  *                and will free the memory allocated by html_encode().
497  *
498  * Parameters  :
499  *          1  :  target_string = Pointer to old text that is to be
500  *                extended.  *target_string will be free()d by this
501  *                routine.  target_string must be non-NULL.
502  *          2  :  text_to_append = Text to be appended to old.
503  *
504  * Returns     :  JB_ERR_OK on success, and sets *target_string
505  *                   to newly malloc'ed appended string.  Caller
506  *                   must free(*target_string).
507  *                JB_ERR_MEMORY on out-of-memory, or if
508  *                   *target_string or text_to_append is NULL.  (In
509  *                   this case, frees *target_string and text_to_append,
510  *                   sets *target_string to NULL).
511  *
512  *********************************************************************/
513 jb_err string_join(char **target_string, char *text_to_append)
514 {
515    jb_err err;
516
517    assert(target_string);
518
519    if (text_to_append == NULL)
520    {
521       freez(*target_string);
522       return JB_ERR_MEMORY;
523    }
524
525    err = string_append(target_string, text_to_append);
526
527    freez(text_to_append);
528
529    return err;
530 }
531
532
533 /*********************************************************************
534  *
535  * Function    :  string_toupper
536  *
537  * Description :  Produce a copy of string with all convertible
538  *                characters converted to uppercase.
539  *
540  * Parameters  :
541  *          1  :  string = string to convert
542  *
543  * Returns     :  Uppercase copy of string if possible,
544  *                NULL on out-of-memory or if string was NULL.
545  *
546  *********************************************************************/
547 char *string_toupper(const char *string)
548 {
549    char *result, *p;
550    const char *q;
551
552    if (!string || ((result = (char *) zalloc(strlen(string) + 1)) == NULL))
553    {
554       return NULL;
555    }
556
557    q = string;
558    p = result;
559
560    while (*q != '\0')
561    {
562       *p++ = (char)toupper((int) *q++);
563    }
564
565    return result;
566
567 }
568
569
570 /*********************************************************************
571  *
572  * Function    :  string_move
573  *
574  * Description :  memmove wrapper to move the last part of a string
575  *                towards the beginning, overwriting the part in
576  *                the middle. strlcpy() can't be used here as the
577  *                strings overlap.
578  *
579  * Parameters  :
580  *          1  :  dst = Destination to overwrite
581  *          2  :  src = Source to move.
582  *
583  * Returns     :  N/A
584  *
585  *********************************************************************/
586 void string_move(char *dst, char *src)
587 {
588    assert(dst < src);
589
590    /* +1 to copy the terminating nul as well. */
591    memmove(dst, src, strlen(src)+1);
592 }
593
594
595 /*********************************************************************
596  *
597  * Function    :  bindup
598  *
599  * Description :  Duplicate the first n characters of a string that may
600  *                contain '\0' characters.
601  *
602  * Parameters  :
603  *          1  :  string = string to be duplicated
604  *          2  :  len = number of bytes to duplicate
605  *
606  * Returns     :  pointer to copy, or NULL if failiure
607  *
608  *********************************************************************/
609 char *bindup(const char *string, size_t len)
610 {
611    char *duplicate;
612
613    duplicate = (char *)malloc(len);
614    if (NULL != duplicate)
615    {
616       memcpy(duplicate, string, len);
617    }
618
619    return duplicate;
620
621 }
622
623
624 /*********************************************************************
625  *
626  * Function    :  make_path
627  *
628  * Description :  Takes a directory name and a file name, returns
629  *                the complete path.  Handles windows/unix differences.
630  *                If the file name is already an absolute path, or if
631  *                the directory name is NULL or empty, it returns
632  *                the filename.
633  *
634  * Parameters  :
635  *          1  :  dir: Name of directory or NULL for none.
636  *          2  :  file: Name of file.  Should not be NULL or empty.
637  *
638  * Returns     :  "dir/file" (Or on windows, "dir\file").
639  *                It allocates the string on the heap.  Caller frees.
640  *                Returns NULL in error (i.e. NULL file or out of
641  *                memory)
642  *
643  *********************************************************************/
644 char * make_path(const char * dir, const char * file)
645 {
646 #ifdef AMIGA
647    char path[512];
648
649    if (dir)
650    {
651       if (dir[0] == '.')
652       {
653          if (dir[1] == '/')
654          {
655             strncpy(path,dir+2,512);
656          }
657          else
658          {
659             strncpy(path,dir+1,512);
660          }
661       }
662       else
663       {
664          strncpy(path,dir,512);
665       }
666       path[511]=0;
667    }
668    else
669    {
670       path[0]=0;
671    }
672    if (AddPart(path,file,512))
673    {
674       return strdup(path);
675    }
676    else
677    {
678       return NULL;
679    }
680 #else /* ndef AMIGA */
681
682    if ((file == NULL) || (*file == '\0'))
683    {
684       return NULL; /* Error */
685    }
686
687    if ((dir == NULL) || (*dir == '\0') /* No directory specified */
688 #if defined(_WIN32) || defined(__OS2__)
689       || (*file == '\\') || (file[1] == ':') /* Absolute path (DOS) */
690 #else /* ifndef _WIN32 || __OS2__ */
691       || (*file == '/') /* Absolute path (U*ix) */
692 #endif /* ifndef _WIN32 || __OS2__  */
693       )
694    {
695       return strdup(file);
696    }
697    else
698    {
699       char * path;
700       size_t path_size = strlen(dir) + strlen(file) + 2; /* +2 for trailing (back)slash and \0 */
701
702 #if defined(unix)
703       if (*dir != '/' && basedir && *basedir)
704       {
705          /*
706           * Relative path, so start with the base directory.
707           */
708          path_size += strlen(basedir) + 1; /* +1 for the slash */
709          path = malloc(path_size);
710          if (!path) log_error(LOG_LEVEL_FATAL, "malloc failed!");
711          strlcpy(path, basedir, path_size);
712          strlcat(path, "/", path_size);
713          strlcat(path, dir, path_size);
714       }
715       else
716 #endif /* defined unix */
717       {
718          path = malloc(path_size);
719          if (!path) log_error(LOG_LEVEL_FATAL, "malloc failed!");
720          strlcpy(path, dir, path_size);
721       }
722
723       assert(NULL != path);
724 #if defined(_WIN32) || defined(__OS2__)
725       if (path[strlen(path)-1] != '\\')
726       {
727          strlcat(path, "\\", path_size);
728       }
729 #else /* ifndef _WIN32 || __OS2__ */
730       if (path[strlen(path)-1] != '/')
731       {
732          strlcat(path, "/", path_size);
733       }
734 #endif /* ifndef _WIN32 || __OS2__ */
735       strlcat(path, file, path_size);
736
737       return path;
738    }
739 #endif /* ndef AMIGA */
740 }
741
742
743 /*********************************************************************
744  *
745  * Function    :  pick_from_range
746  *
747  * Description :  Pick a positive number out of a given range.
748  *                Should only be used if randomness would be nice,
749  *                but isn't really necessary.
750  *
751  * Parameters  :
752  *          1  :  range: Highest possible number to pick.
753  *
754  * Returns     :  Picked number.
755  *
756  *********************************************************************/
757 long int pick_from_range(long int range)
758 {
759    long int number;
760 #ifdef _WIN32
761    static unsigned long seed = 0;
762 #endif /* def _WIN32 */
763
764    assert(range != 0);
765    assert(range > 0);
766
767    if (range <= 0) return 0;
768
769 #ifdef HAVE_ARC4RANDOM
770    number = arc4random() % range + 1;
771 #elif defined(HAVE_RANDOM)
772    number = random() % range + 1;
773 #elif defined(MUTEX_LOCKS_AVAILABLE)
774    privoxy_mutex_lock(&rand_mutex);
775 #ifdef _WIN32
776    if (!seed)
777    {
778       seed = (unsigned long)(GetCurrentThreadId()+GetTickCount());
779    }
780    srand(seed);
781    seed = (unsigned long)((rand() << 16) + rand());
782 #endif /* def _WIN32 */
783    number = (unsigned long)((rand() << 16) + (rand())) % (unsigned long)(range + 1);
784    privoxy_mutex_unlock(&rand_mutex);
785 #else
786    /*
787     * XXX: Which platforms reach this and are there
788     * better options than just using rand() and hoping
789     * that it's safe?
790     */
791    log_error(LOG_LEVEL_INFO, "No thread-safe PRNG available? Header time randomization "
792       "might cause crashes, predictable results or even combine these fine options.");
793    number = rand() % (long int)(range + 1);
794
795 #endif /* (def HAVE_ARC4RANDOM) */
796
797    return number;
798 }
799
800
801 #ifdef USE_PRIVOXY_STRLCPY
802 /*********************************************************************
803  *
804  * Function    :  privoxy_strlcpy
805  *
806  * Description :  strlcpy(3) look-alike for those without decent libc.
807  *
808  * Parameters  :
809  *          1  :  destination: buffer to copy into.
810  *          2  :  source: String to copy.
811  *          3  :  size: Size of destination buffer.
812  *
813  * Returns     :  The length of the string that privoxy_strlcpy() tried to create.
814  *
815  *********************************************************************/
816 size_t privoxy_strlcpy(char *destination, const char *source, const size_t size)
817 {
818    if (0 < size)
819    {
820       snprintf(destination, size, "%s", source);
821       /*
822        * Platforms that lack strlcpy() also tend to have
823        * a broken snprintf implementation that doesn't
824        * guarantee nul termination.
825        *
826        * XXX: the configure script should detect and reject those.
827        */
828       destination[size-1] = '\0';
829    }
830    return strlen(source);
831 }
832 #endif /* def USE_PRIVOXY_STRLCPY */
833
834
835 #ifndef HAVE_STRLCAT
836 /*********************************************************************
837  *
838  * Function    :  privoxy_strlcat
839  *
840  * Description :  strlcat(3) look-alike for those without decent libc.
841  *
842  * Parameters  :
843  *          1  :  destination: C string.
844  *          2  :  source: String to copy.
845  *          3  :  size: Size of destination buffer.
846  *
847  * Returns     :  The length of the string that privoxy_strlcat() tried to create.
848  *
849  *********************************************************************/
850 size_t privoxy_strlcat(char *destination, const char *source, const size_t size)
851 {
852    const size_t old_length = strlen(destination);
853    return old_length + strlcpy(destination + old_length, source, size - old_length);
854 }
855 #endif /* ndef HAVE_STRLCAT */
856
857
858 #if !defined(HAVE_TIMEGM) && defined(HAVE_TZSET) && defined(HAVE_PUTENV)
859 /*********************************************************************
860  *
861  * Function    :  timegm
862  *
863  * Description :  libc replacement function for the inverse of gmtime().
864  *                Copyright (C) 2004 Free Software Foundation, Inc.
865  *
866  *                Code originally copied from GnuPG, modifications done
867  *                for Privoxy: style changed, #ifdefs for _WIN32 added
868  *                to have it work on mingw32.
869  *
870  *                XXX: It's very unlikely to happen, but if the malloc()
871  *                call fails the time zone will be permanently set to UTC.
872  *
873  * Parameters  :
874  *          1  :  tm: Broken-down time struct.
875  *
876  * Returns     :  tm converted into time_t seconds.
877  *
878  *********************************************************************/
879 time_t timegm(struct tm *tm)
880 {
881    time_t answer;
882    char *zone;
883
884    zone = getenv("TZ");
885    putenv("TZ=UTC");
886    tzset();
887    answer = mktime(tm);
888    if (zone)
889    {
890       char *old_zone;
891
892       old_zone = malloc(3 + strlen(zone) + 1);
893       if (old_zone)
894       {
895          strcpy(old_zone, "TZ=");
896          strcat(old_zone, zone);
897          putenv(old_zone);
898 #ifdef _WIN32
899          /* http://man7.org/linux/man-pages/man3/putenv.3.html
900           *   int putenv(char *string);
901           *     The string pointed to by string becomes part of the environment, so altering the
902           *     string changes the environment.
903           * In other words, the memory pointed to by *string is used until
904           *   a) another call to putenv() with the same e-var name
905           *   b) the program exits
906           *
907           * Windows e-vars don't work that way, so let's not leak memory.
908           */
909          free(old_zone);
910 #endif /* def _WIN32 */
911       }
912    }
913    else
914    {
915 #ifdef HAVE_UNSETENV
916       unsetenv("TZ");
917 #elif defined(_WIN32)
918       putenv("TZ=");
919 #else
920       putenv("TZ");
921 #endif
922    }
923    tzset();
924
925    return answer;
926 }
927 #endif /* !defined(HAVE_TIMEGM) && defined(HAVE_TZSET) && defined(HAVE_PUTENV) */
928
929
930 #ifndef HAVE_SNPRINTF
931 /*
932  * What follows is a portable snprintf routine, written by Mark Martinec.
933  * See: http://www.ijs.si/software/snprintf/
934
935                                   snprintf.c
936                    - a portable implementation of snprintf,
937        including vsnprintf.c, asnprintf, vasnprintf, asprintf, vasprintf
938
939    snprintf is a routine to convert numeric and string arguments to
940    formatted strings. It is similar to sprintf(3) provided in a system's
941    C library, yet it requires an additional argument - the buffer size -
942    and it guarantees never to store anything beyond the given buffer,
943    regardless of the format or arguments to be formatted. Some newer
944    operating systems do provide snprintf in their C library, but many do
945    not or do provide an inadequate (slow or idiosyncratic) version, which
946    calls for a portable implementation of this routine.
947
948 Author
949
950    Mark Martinec <mark.martinec@ijs.si>, April 1999, June 2000
951    Copyright © 1999, Mark Martinec
952
953  */
954
955 #define PORTABLE_SNPRINTF_VERSION_MAJOR 2
956 #define PORTABLE_SNPRINTF_VERSION_MINOR 2
957
958 #if defined(NEED_ASPRINTF) || defined(NEED_ASNPRINTF) || defined(NEED_VASPRINTF) || defined(NEED_VASNPRINTF)
959 # if defined(NEED_SNPRINTF_ONLY)
960 # undef NEED_SNPRINTF_ONLY
961 # endif
962 # if !defined(PREFER_PORTABLE_SNPRINTF)
963 # define PREFER_PORTABLE_SNPRINTF
964 # endif
965 #endif
966
967 #if defined(SOLARIS_BUG_COMPATIBLE) && !defined(SOLARIS_COMPATIBLE)
968 #define SOLARIS_COMPATIBLE
969 #endif
970
971 #if defined(HPUX_BUG_COMPATIBLE) && !defined(HPUX_COMPATIBLE)
972 #define HPUX_COMPATIBLE
973 #endif
974
975 #if defined(DIGITAL_UNIX_BUG_COMPATIBLE) && !defined(DIGITAL_UNIX_COMPATIBLE)
976 #define DIGITAL_UNIX_COMPATIBLE
977 #endif
978
979 #if defined(PERL_BUG_COMPATIBLE) && !defined(PERL_COMPATIBLE)
980 #define PERL_COMPATIBLE
981 #endif
982
983 #if defined(LINUX_BUG_COMPATIBLE) && !defined(LINUX_COMPATIBLE)
984 #define LINUX_COMPATIBLE
985 #endif
986
987 #include <sys/types.h>
988 #include <string.h>
989 #include <stdlib.h>
990 #include <stdio.h>
991 #include <stdarg.h>
992 #include <assert.h>
993 #include <errno.h>
994
995 #ifdef isdigit
996 #undef isdigit
997 #endif
998 #define isdigit(c) ((c) >= '0' && (c) <= '9')
999
1000 /* For copying strings longer or equal to 'breakeven_point'
1001  * it is more efficient to call memcpy() than to do it inline.
1002  * The value depends mostly on the processor architecture,
1003  * but also on the compiler and its optimization capabilities.
1004  * The value is not critical, some small value greater than zero
1005  * will be just fine if you don't care to squeeze every drop
1006  * of performance out of the code.
1007  *
1008  * Small values favor memcpy, large values favor inline code.
1009  */
1010 #if defined(__alpha__) || defined(__alpha)
1011 #  define breakeven_point   2    /* AXP (DEC Alpha)     - gcc or cc or egcs */
1012 #endif
1013 #if defined(__i386__)  || defined(__i386)
1014 #  define breakeven_point  12    /* Intel Pentium/Linux - gcc 2.96 */
1015 #endif
1016 #if defined(__hppa)
1017 #  define breakeven_point  10    /* HP-PA               - gcc */
1018 #endif
1019 #if defined(__sparc__) || defined(__sparc)
1020 #  define breakeven_point  33    /* Sun Sparc 5         - gcc 2.8.1 */
1021 #endif
1022
1023 /* some other values of possible interest: */
1024 /* #define breakeven_point  8 */ /* VAX 4000          - vaxc */
1025 /* #define breakeven_point 19 */ /* VAX 4000          - gcc 2.7.0 */
1026
1027 #ifndef breakeven_point
1028 #  define breakeven_point   6    /* some reasonable one-size-fits-all value */
1029 #endif
1030
1031 #define fast_memcpy(d,s,n) \
1032   { register size_t nn = (size_t)(n); \
1033     if (nn >= breakeven_point) memcpy((d), (s), nn); \
1034     else if (nn > 0) { /* proc call overhead is worth only for large strings*/\
1035       register char *dd; register const char *ss; \
1036       for (ss=(s), dd=(d); nn>0; nn--) *dd++ = *ss++; } }
1037
1038 #define fast_memset(d,c,n) \
1039   { register size_t nn = (size_t)(n); \
1040     if (nn >= breakeven_point) memset((d), (int)(c), nn); \
1041     else if (nn > 0) { /* proc call overhead is worth only for large strings*/\
1042       register char *dd; register const int cc=(int)(c); \
1043       for (dd=(d); nn>0; nn--) *dd++ = cc; } }
1044
1045 /* prototypes */
1046
1047 #if defined(NEED_ASPRINTF)
1048 int asprintf   (char **ptr, const char *fmt, /*args*/ ...);
1049 #endif
1050 #if defined(NEED_VASPRINTF)
1051 int vasprintf  (char **ptr, const char *fmt, va_list ap);
1052 #endif
1053 #if defined(NEED_ASNPRINTF)
1054 int asnprintf  (char **ptr, size_t str_m, const char *fmt, /*args*/ ...);
1055 #endif
1056 #if defined(NEED_VASNPRINTF)
1057 int vasnprintf (char **ptr, size_t str_m, const char *fmt, va_list ap);
1058 #endif
1059
1060 #if defined(HAVE_SNPRINTF)
1061 /* declare our portable snprintf  routine under name portable_snprintf  */
1062 /* declare our portable vsnprintf routine under name portable_vsnprintf */
1063 #else
1064 /* declare our portable routines under names snprintf and vsnprintf */
1065 #define portable_snprintf snprintf
1066 #if !defined(NEED_SNPRINTF_ONLY)
1067 #define portable_vsnprintf vsnprintf
1068 #endif
1069 #endif
1070
1071 #if !defined(HAVE_SNPRINTF) || defined(PREFER_PORTABLE_SNPRINTF)
1072 int portable_snprintf(char *str, size_t str_m, const char *fmt, /*args*/ ...);
1073 #if !defined(NEED_SNPRINTF_ONLY)
1074 int portable_vsnprintf(char *str, size_t str_m, const char *fmt, va_list ap);
1075 #endif
1076 #endif
1077
1078 /* declarations */
1079
1080 static char credits[] = "\n\
1081 @(#)snprintf.c, v2.2: Mark Martinec, <mark.martinec@ijs.si>\n\
1082 @(#)snprintf.c, v2.2: Copyright 1999, Mark Martinec. Frontier Artistic License applies.\n\
1083 @(#)snprintf.c, v2.2: http://www.ijs.si/software/snprintf/\n";
1084
1085 #if defined(NEED_ASPRINTF)
1086 int asprintf(char **ptr, const char *fmt, /*args*/ ...) {
1087   va_list ap;
1088   size_t str_m;
1089   int str_l;
1090
1091   *ptr = NULL;
1092   va_start(ap, fmt);                            /* measure the required size */
1093   str_l = portable_vsnprintf(NULL, (size_t)0, fmt, ap);
1094   va_end(ap);
1095   assert(str_l >= 0);        /* possible integer overflow if str_m > INT_MAX */
1096   *ptr = (char *) malloc(str_m = (size_t)str_l + 1);
1097   if (*ptr == NULL) { errno = ENOMEM; str_l = -1; }
1098   else {
1099     int str_l2;
1100     va_start(ap, fmt);
1101     str_l2 = portable_vsnprintf(*ptr, str_m, fmt, ap);
1102     va_end(ap);
1103     assert(str_l2 == str_l);
1104   }
1105   return str_l;
1106 }
1107 #endif
1108
1109 #if defined(NEED_VASPRINTF)
1110 int vasprintf(char **ptr, const char *fmt, va_list ap) {
1111   size_t str_m;
1112   int str_l;
1113
1114   *ptr = NULL;
1115   { va_list ap2;
1116     va_copy(ap2, ap);  /* don't consume the original ap, we'll need it again */
1117     str_l = portable_vsnprintf(NULL, (size_t)0, fmt, ap2);/*get required size*/
1118     va_end(ap2);
1119   }
1120   assert(str_l >= 0);        /* possible integer overflow if str_m > INT_MAX */
1121   *ptr = (char *) malloc(str_m = (size_t)str_l + 1);
1122   if (*ptr == NULL) { errno = ENOMEM; str_l = -1; }
1123   else {
1124     int str_l2 = portable_vsnprintf(*ptr, str_m, fmt, ap);
1125     assert(str_l2 == str_l);
1126   }
1127   return str_l;
1128 }
1129 #endif
1130
1131 #if defined(NEED_ASNPRINTF)
1132 int asnprintf (char **ptr, size_t str_m, const char *fmt, /*args*/ ...) {
1133   va_list ap;
1134   int str_l;
1135
1136   *ptr = NULL;
1137   va_start(ap, fmt);                            /* measure the required size */
1138   str_l = portable_vsnprintf(NULL, (size_t)0, fmt, ap);
1139   va_end(ap);
1140   assert(str_l >= 0);        /* possible integer overflow if str_m > INT_MAX */
1141   if ((size_t)str_l + 1 < str_m) str_m = (size_t)str_l + 1;      /* truncate */
1142   /* if str_m is 0, no buffer is allocated, just set *ptr to NULL */
1143   if (str_m == 0) {  /* not interested in resulting string, just return size */
1144   } else {
1145     *ptr = (char *) malloc(str_m);
1146     if (*ptr == NULL) { errno = ENOMEM; str_l = -1; }
1147     else {
1148       int str_l2;
1149       va_start(ap, fmt);
1150       str_l2 = portable_vsnprintf(*ptr, str_m, fmt, ap);
1151       va_end(ap);
1152       assert(str_l2 == str_l);
1153     }
1154   }
1155   return str_l;
1156 }
1157 #endif
1158
1159 #if defined(NEED_VASNPRINTF)
1160 int vasnprintf (char **ptr, size_t str_m, const char *fmt, va_list ap) {
1161   int str_l;
1162
1163   *ptr = NULL;
1164   { va_list ap2;
1165     va_copy(ap2, ap);  /* don't consume the original ap, we'll need it again */
1166     str_l = portable_vsnprintf(NULL, (size_t)0, fmt, ap2);/*get required size*/
1167     va_end(ap2);
1168   }
1169   assert(str_l >= 0);        /* possible integer overflow if str_m > INT_MAX */
1170   if ((size_t)str_l + 1 < str_m) str_m = (size_t)str_l + 1;      /* truncate */
1171   /* if str_m is 0, no buffer is allocated, just set *ptr to NULL */
1172   if (str_m == 0) {  /* not interested in resulting string, just return size */
1173   } else {
1174     *ptr = (char *) malloc(str_m);
1175     if (*ptr == NULL) { errno = ENOMEM; str_l = -1; }
1176     else {
1177       int str_l2 = portable_vsnprintf(*ptr, str_m, fmt, ap);
1178       assert(str_l2 == str_l);
1179     }
1180   }
1181   return str_l;
1182 }
1183 #endif
1184
1185 /*
1186  * If the system does have snprintf and the portable routine is not
1187  * specifically required, this module produces no code for snprintf/vsnprintf.
1188  */
1189 #if !defined(HAVE_SNPRINTF) || defined(PREFER_PORTABLE_SNPRINTF)
1190
1191 #if !defined(NEED_SNPRINTF_ONLY)
1192 int portable_snprintf(char *str, size_t str_m, const char *fmt, /*args*/ ...) {
1193   va_list ap;
1194   int str_l;
1195
1196   va_start(ap, fmt);
1197   str_l = portable_vsnprintf(str, str_m, fmt, ap);
1198   va_end(ap);
1199   return str_l;
1200 }
1201 #endif
1202
1203 #if defined(NEED_SNPRINTF_ONLY)
1204 int portable_snprintf(char *str, size_t str_m, const char *fmt, /*args*/ ...) {
1205 #else
1206 int portable_vsnprintf(char *str, size_t str_m, const char *fmt, va_list ap) {
1207 #endif
1208
1209 #if defined(NEED_SNPRINTF_ONLY)
1210   va_list ap;
1211 #endif
1212   size_t str_l = 0;
1213   const char *p = fmt;
1214
1215 /* In contrast with POSIX, the ISO C99 now says
1216  * that str can be NULL and str_m can be 0.
1217  * This is more useful than the old:  if (str_m < 1) return -1; */
1218
1219 #if defined(NEED_SNPRINTF_ONLY)
1220   va_start(ap, fmt);
1221 #endif
1222   if (!p) p = "";
1223   while (*p) {
1224     if (*p != '%') {
1225    /* if (str_l < str_m) str[str_l++] = *p++;    -- this would be sufficient */
1226    /* but the following code achieves better performance for cases
1227     * where format string is long and contains few conversions */
1228       const char *q = strchr(p+1,'%');
1229       size_t n = !q ? strlen(p) : (q-p);
1230       if (str_l < str_m) {
1231         size_t avail = str_m-str_l;
1232         fast_memcpy(str+str_l, p, (n>avail?avail:n));
1233       }
1234       p += n; str_l += n;
1235     } else {
1236       const char *starting_p;
1237       size_t min_field_width = 0, precision = 0;
1238       int zero_padding = 0, precision_specified = 0, justify_left = 0;
1239       int alternate_form = 0, force_sign = 0;
1240       int space_for_positive = 1; /* If both the ' ' and '+' flags appear,
1241                                      the ' ' flag should be ignored. */
1242       char length_modifier = '\0';            /* allowed values: \0, h, l, L */
1243       char tmp[32];/* temporary buffer for simple numeric->string conversion */
1244
1245       const char *str_arg;      /* string address in case of string argument */
1246       size_t str_arg_l;         /* natural field width of arg without padding
1247                                    and sign */
1248       unsigned char uchar_arg;
1249         /* unsigned char argument value - only defined for c conversion.
1250            N.B. standard explicitly states the char argument for
1251            the c conversion is unsigned */
1252
1253       size_t number_of_zeros_to_pad = 0;
1254         /* number of zeros to be inserted for numeric conversions
1255            as required by the precision or minimal field width */
1256
1257       size_t zero_padding_insertion_ind = 0;
1258         /* index into tmp where zero padding is to be inserted */
1259
1260       char fmt_spec = '\0';
1261         /* current conversion specifier character */
1262
1263       str_arg = credits;/* just to make compiler happy (defined but not used)*/
1264       str_arg = NULL;
1265       starting_p = p; p++;  /* skip '%' */
1266    /* parse flags */
1267       while (*p == '0' || *p == '-' || *p == '+' ||
1268              *p == ' ' || *p == '#' || *p == '\'') {
1269         switch (*p) {
1270         case '0': zero_padding = 1; break;
1271         case '-': justify_left = 1; break;
1272         case '+': force_sign = 1; space_for_positive = 0; break;
1273         case ' ': force_sign = 1;
1274      /* If both the ' ' and '+' flags appear, the ' ' flag should be ignored */
1275 #ifdef PERL_COMPATIBLE
1276      /* ... but in Perl the last of ' ' and '+' applies */
1277                   space_for_positive = 1;
1278 #endif
1279                   break;
1280         case '#': alternate_form = 1; break;
1281         case '\'': break;
1282         }
1283         p++;
1284       }
1285    /* If the '0' and '-' flags both appear, the '0' flag should be ignored. */
1286
1287    /* parse field width */
1288       if (*p == '*') {
1289         int j;
1290         p++; j = va_arg(ap, int);
1291         if (j >= 0) min_field_width = j;
1292         else { min_field_width = -j; justify_left = 1; }
1293       } else if (isdigit((int)(*p))) {
1294         /* size_t could be wider than unsigned int;
1295            make sure we treat argument like common implementations do */
1296         unsigned int uj = *p++ - '0';
1297         while (isdigit((int)(*p))) uj = 10*uj + (unsigned int)(*p++ - '0');
1298         min_field_width = uj;
1299       }
1300    /* parse precision */
1301       if (*p == '.') {
1302         p++; precision_specified = 1;
1303         if (*p == '*') {
1304           int j = va_arg(ap, int);
1305           p++;
1306           if (j >= 0) precision = j;
1307           else {
1308             precision_specified = 0; precision = 0;
1309          /* NOTE:
1310           *   Solaris 2.6 man page claims that in this case the precision
1311           *   should be set to 0.  Digital Unix 4.0, HPUX 10 and BSD man page
1312           *   claim that this case should be treated as unspecified precision,
1313           *   which is what we do here.
1314           */
1315           }
1316         } else if (isdigit((int)(*p))) {
1317           /* size_t could be wider than unsigned int;
1318              make sure we treat argument like common implementations do */
1319           unsigned int uj = *p++ - '0';
1320           while (isdigit((int)(*p))) uj = 10*uj + (unsigned int)(*p++ - '0');
1321           precision = uj;
1322         }
1323       }
1324    /* parse 'h', 'l' and 'll' length modifiers */
1325       if (*p == 'h' || *p == 'l') {
1326         length_modifier = *p; p++;
1327         if (length_modifier == 'l' && *p == 'l') {   /* double l = long long */
1328 #ifdef SNPRINTF_LONGLONG_SUPPORT
1329           length_modifier = '2';                  /* double l encoded as '2' */
1330 #else
1331           length_modifier = 'l';                 /* treat it as a single 'l' */
1332 #endif
1333           p++;
1334         }
1335       }
1336       fmt_spec = *p;
1337    /* common synonyms: */
1338       switch (fmt_spec) {
1339       case 'i': fmt_spec = 'd'; break;
1340       case 'D': fmt_spec = 'd'; length_modifier = 'l'; break;
1341       case 'U': fmt_spec = 'u'; length_modifier = 'l'; break;
1342       case 'O': fmt_spec = 'o'; length_modifier = 'l'; break;
1343       default: break;
1344       }
1345    /* get parameter value, do initial processing */
1346       switch (fmt_spec) {
1347       case '%': /* % behaves similar to 's' regarding flags and field widths */
1348       case 'c': /* c behaves similar to 's' regarding flags and field widths */
1349       case 's':
1350         length_modifier = '\0';          /* wint_t and wchar_t not supported */
1351      /* the result of zero padding flag with non-numeric conversion specifier*/
1352      /* is undefined. Solaris and HPUX 10 does zero padding in this case,    */
1353      /* Digital Unix and Linux does not. */
1354 #if !defined(SOLARIS_COMPATIBLE) && !defined(HPUX_COMPATIBLE)
1355         zero_padding = 0;    /* turn zero padding off for string conversions */
1356 #endif
1357         str_arg_l = 1;
1358         switch (fmt_spec) {
1359         case '%':
1360           str_arg = p; break;
1361         case 'c': {
1362           int j = va_arg(ap, int);
1363           uchar_arg = (unsigned char) j;   /* standard demands unsigned char */
1364           str_arg = (const char *) &uchar_arg;
1365           break;
1366         }
1367         case 's':
1368           str_arg = va_arg(ap, const char *);
1369           if (!str_arg) str_arg_l = 0;
1370        /* make sure not to address string beyond the specified precision !!! */
1371           else if (!precision_specified) str_arg_l = strlen(str_arg);
1372        /* truncate string if necessary as requested by precision */
1373           else if (precision == 0) str_arg_l = 0;
1374           else {
1375        /* memchr on HP does not like n > 2^31  !!! */
1376             const char *q = memchr(str_arg, '\0',
1377                              precision <= 0x7fffffff ? precision : 0x7fffffff);
1378             str_arg_l = !q ? precision : (q-str_arg);
1379           }
1380           break;
1381         default: break;
1382         }
1383         break;
1384       case 'd': case 'u': case 'o': case 'x': case 'X': case 'p': {
1385         /* NOTE: the u, o, x, X and p conversion specifiers imply
1386                  the value is unsigned;  d implies a signed value */
1387
1388         int arg_sign = 0;
1389           /* 0 if numeric argument is zero (or if pointer is NULL for 'p'),
1390             +1 if greater than zero (or nonzero for unsigned arguments),
1391             -1 if negative (unsigned argument is never negative) */
1392
1393         int int_arg = 0;  unsigned int uint_arg = 0;
1394           /* only defined for length modifier h, or for no length modifiers */
1395
1396         long int long_arg = 0;  unsigned long int ulong_arg = 0;
1397           /* only defined for length modifier l */
1398
1399         void *ptr_arg = NULL;
1400           /* pointer argument value -only defined for p conversion */
1401
1402 #ifdef SNPRINTF_LONGLONG_SUPPORT
1403         long long int long_long_arg = 0;
1404         unsigned long long int ulong_long_arg = 0;
1405           /* only defined for length modifier ll */
1406 #endif
1407         if (fmt_spec == 'p') {
1408         /* HPUX 10: An l, h, ll or L before any other conversion character
1409          *   (other than d, i, u, o, x, or X) is ignored.
1410          * Digital Unix:
1411          *   not specified, but seems to behave as HPUX does.
1412          * Solaris: If an h, l, or L appears before any other conversion
1413          *   specifier (other than d, i, u, o, x, or X), the behavior
1414          *   is undefined. (Actually %hp converts only 16-bits of address
1415          *   and %llp treats address as 64-bit data which is incompatible
1416          *   with (void *) argument on a 32-bit system).
1417          */
1418 #ifdef SOLARIS_COMPATIBLE
1419 #  ifdef SOLARIS_BUG_COMPATIBLE
1420           /* keep length modifiers even if it represents 'll' */
1421 #  else
1422           if (length_modifier == '2') length_modifier = '\0';
1423 #  endif
1424 #else
1425           length_modifier = '\0';
1426 #endif
1427           ptr_arg = va_arg(ap, void *);
1428           if (ptr_arg != NULL) arg_sign = 1;
1429         } else if (fmt_spec == 'd') {  /* signed */
1430           switch (length_modifier) {
1431           case '\0':
1432           case 'h':
1433          /* It is non-portable to specify a second argument of char or short
1434           * to va_arg, because arguments seen by the called function
1435           * are not char or short.  C converts char and short arguments
1436           * to int before passing them to a function.
1437           */
1438             int_arg = va_arg(ap, int);
1439             if      (int_arg > 0) arg_sign =  1;
1440             else if (int_arg < 0) arg_sign = -1;
1441             break;
1442           case 'l':
1443             long_arg = va_arg(ap, long int);
1444             if      (long_arg > 0) arg_sign =  1;
1445             else if (long_arg < 0) arg_sign = -1;
1446             break;
1447 #ifdef SNPRINTF_LONGLONG_SUPPORT
1448           case '2':
1449             long_long_arg = va_arg(ap, long long int);
1450             if      (long_long_arg > 0) arg_sign =  1;
1451             else if (long_long_arg < 0) arg_sign = -1;
1452             break;
1453 #endif
1454           }
1455         } else {  /* unsigned */
1456           switch (length_modifier) {
1457           case '\0':
1458           case 'h':
1459             uint_arg = va_arg(ap, unsigned int);
1460             if (uint_arg) arg_sign = 1;
1461             break;
1462           case 'l':
1463             ulong_arg = va_arg(ap, unsigned long int);
1464             if (ulong_arg) arg_sign = 1;
1465             break;
1466 #ifdef SNPRINTF_LONGLONG_SUPPORT
1467           case '2':
1468             ulong_long_arg = va_arg(ap, unsigned long long int);
1469             if (ulong_long_arg) arg_sign = 1;
1470             break;
1471 #endif
1472           }
1473         }
1474         str_arg = tmp; str_arg_l = 0;
1475      /* NOTE:
1476       *   For d, i, u, o, x, and X conversions, if precision is specified,
1477       *   the '0' flag should be ignored. This is so with Solaris 2.6,
1478       *   Digital UNIX 4.0, HPUX 10, Linux, FreeBSD, NetBSD; but not with Perl.
1479       */
1480 #ifndef PERL_COMPATIBLE
1481         if (precision_specified) zero_padding = 0;
1482 #endif
1483         if (fmt_spec == 'd') {
1484           if (force_sign && arg_sign >= 0)
1485             tmp[str_arg_l++] = space_for_positive ? ' ' : '+';
1486          /* leave negative numbers for sprintf to handle,
1487             to avoid handling tricky cases like (short int)(-32768) */
1488 #ifdef LINUX_COMPATIBLE
1489         } else if (fmt_spec == 'p' && force_sign && arg_sign > 0) {
1490           tmp[str_arg_l++] = space_for_positive ? ' ' : '+';
1491 #endif
1492         } else if (alternate_form) {
1493           if (arg_sign != 0 && (fmt_spec == 'x' || fmt_spec == 'X') )
1494             { tmp[str_arg_l++] = '0'; tmp[str_arg_l++] = fmt_spec; }
1495          /* alternate form should have no effect for p conversion, but ... */
1496 #ifdef HPUX_COMPATIBLE
1497           else if (fmt_spec == 'p'
1498          /* HPUX 10: for an alternate form of p conversion,
1499           *          a nonzero result is prefixed by 0x. */
1500 #ifndef HPUX_BUG_COMPATIBLE
1501          /* Actually it uses 0x prefix even for a zero value. */
1502                    && arg_sign != 0
1503 #endif
1504                   ) { tmp[str_arg_l++] = '0'; tmp[str_arg_l++] = 'x'; }
1505 #endif
1506         }
1507         zero_padding_insertion_ind = str_arg_l;
1508         if (!precision_specified) precision = 1;   /* default precision is 1 */
1509         if (precision == 0 && arg_sign == 0
1510 #if defined(HPUX_BUG_COMPATIBLE) || defined(LINUX_COMPATIBLE)
1511             && fmt_spec != 'p'
1512          /* HPUX 10 man page claims: With conversion character p the result of
1513           * converting a zero value with a precision of zero is a null string.
1514           * Actually HP returns all zeroes, and Linux returns "(nil)". */
1515 #endif
1516         ) {
1517          /* converted to null string */
1518          /* When zero value is formatted with an explicit precision 0,
1519             the resulting formatted string is empty (d, i, u, o, x, X, p).   */
1520         } else {
1521           char f[5]; int f_l = 0;
1522           f[f_l++] = '%';    /* construct a simple format string for sprintf */
1523           if (!length_modifier) { }
1524           else if (length_modifier=='2') { f[f_l++] = 'l'; f[f_l++] = 'l'; }
1525           else f[f_l++] = length_modifier;
1526           f[f_l++] = fmt_spec; f[f_l++] = '\0';
1527           if (fmt_spec == 'p') str_arg_l += sprintf(tmp+str_arg_l, f, ptr_arg);
1528           else if (fmt_spec == 'd') {  /* signed */
1529             switch (length_modifier) {
1530             case '\0':
1531             case 'h': str_arg_l+=sprintf(tmp+str_arg_l, f, int_arg);  break;
1532             case 'l': str_arg_l+=sprintf(tmp+str_arg_l, f, long_arg); break;
1533 #ifdef SNPRINTF_LONGLONG_SUPPORT
1534             case '2': str_arg_l+=sprintf(tmp+str_arg_l,f,long_long_arg); break;
1535 #endif
1536             }
1537           } else {  /* unsigned */
1538             switch (length_modifier) {
1539             case '\0':
1540             case 'h': str_arg_l+=sprintf(tmp+str_arg_l, f, uint_arg);  break;
1541             case 'l': str_arg_l+=sprintf(tmp+str_arg_l, f, ulong_arg); break;
1542 #ifdef SNPRINTF_LONGLONG_SUPPORT
1543             case '2': str_arg_l+=sprintf(tmp+str_arg_l,f,ulong_long_arg);break;
1544 #endif
1545             }
1546           }
1547          /* include the optional minus sign and possible "0x"
1548             in the region before the zero padding insertion point */
1549           if (zero_padding_insertion_ind < str_arg_l &&
1550               tmp[zero_padding_insertion_ind] == '-') {
1551             zero_padding_insertion_ind++;
1552           }
1553           if (zero_padding_insertion_ind+1 < str_arg_l &&
1554               tmp[zero_padding_insertion_ind]   == '0' &&
1555              (tmp[zero_padding_insertion_ind+1] == 'x' ||
1556               tmp[zero_padding_insertion_ind+1] == 'X') ) {
1557             zero_padding_insertion_ind += 2;
1558           }
1559         }
1560         { size_t num_of_digits = str_arg_l - zero_padding_insertion_ind;
1561           if (alternate_form && fmt_spec == 'o'
1562 #ifdef HPUX_COMPATIBLE                                  /* ("%#.o",0) -> ""  */
1563               && (str_arg_l > 0)
1564 #endif
1565 #ifdef DIGITAL_UNIX_BUG_COMPATIBLE                      /* ("%#o",0) -> "00" */
1566 #else
1567               /* unless zero is already the first character */
1568               && !(zero_padding_insertion_ind < str_arg_l
1569                    && tmp[zero_padding_insertion_ind] == '0')
1570 #endif
1571           ) {        /* assure leading zero for alternate-form octal numbers */
1572             if (!precision_specified || precision < num_of_digits+1) {
1573              /* precision is increased to force the first character to be zero,
1574                 except if a zero value is formatted with an explicit precision
1575                 of zero */
1576               precision = num_of_digits+1; precision_specified = 1;
1577             }
1578           }
1579        /* zero padding to specified precision? */
1580           if (num_of_digits < precision)
1581             number_of_zeros_to_pad = precision - num_of_digits;
1582         }
1583      /* zero padding to specified minimal field width? */
1584         if (!justify_left && zero_padding) {
1585           int n = min_field_width - (str_arg_l+number_of_zeros_to_pad);
1586           if (n > 0) number_of_zeros_to_pad += n;
1587         }
1588         break;
1589       }
1590       default: /* unrecognized conversion specifier, keep format string as-is*/
1591         zero_padding = 0;  /* turn zero padding off for non-numeric convers. */
1592 #ifndef DIGITAL_UNIX_COMPATIBLE
1593         justify_left = 1; min_field_width = 0;                /* reset flags */
1594 #endif
1595 #if defined(PERL_COMPATIBLE) || defined(LINUX_COMPATIBLE)
1596      /* keep the entire format string unchanged */
1597         str_arg = starting_p; str_arg_l = p - starting_p;
1598      /* well, not exactly so for Linux, which does something between,
1599       * and I don't feel an urge to imitate it: "%+++++hy" -> "%+y"  */
1600 #else
1601      /* discard the unrecognized conversion, just keep *
1602       * the unrecognized conversion character          */
1603         str_arg = p; str_arg_l = 0;
1604 #endif
1605         if (*p) str_arg_l++;  /* include invalid conversion specifier unchanged
1606                                  if not at end-of-string */
1607         break;
1608       }
1609       if (*p) p++;      /* step over the just processed conversion specifier */
1610    /* insert padding to the left as requested by min_field_width;
1611       this does not include the zero padding in case of numerical conversions*/
1612       if (!justify_left) {                /* left padding with blank or zero */
1613         int n = min_field_width - (str_arg_l+number_of_zeros_to_pad);
1614         if (n > 0) {
1615           if (str_l < str_m) {
1616             size_t avail = str_m-str_l;
1617             fast_memset(str+str_l, (zero_padding?'0':' '), (n>avail?avail:n));
1618           }
1619           str_l += n;
1620         }
1621       }
1622    /* zero padding as requested by the precision or by the minimal field width
1623     * for numeric conversions required? */
1624       if (number_of_zeros_to_pad <= 0) {
1625      /* will not copy first part of numeric right now, *
1626       * force it to be copied later in its entirety    */
1627         zero_padding_insertion_ind = 0;
1628       } else {
1629      /* insert first part of numerics (sign or '0x') before zero padding */
1630         int n = zero_padding_insertion_ind;
1631         if (n > 0) {
1632           if (str_l < str_m) {
1633             size_t avail = str_m-str_l;
1634             fast_memcpy(str+str_l, str_arg, (n>avail?avail:n));
1635           }
1636           str_l += n;
1637         }
1638      /* insert zero padding as requested by the precision or min field width */
1639         n = number_of_zeros_to_pad;
1640         if (n > 0) {
1641           if (str_l < str_m) {
1642             size_t avail = str_m-str_l;
1643             fast_memset(str+str_l, '0', (n>avail?avail:n));
1644           }
1645           str_l += n;
1646         }
1647       }
1648    /* insert formatted string
1649     * (or as-is conversion specifier for unknown conversions) */
1650       { int n = str_arg_l - zero_padding_insertion_ind;
1651         if (n > 0) {
1652           if (str_l < str_m) {
1653             size_t avail = str_m-str_l;
1654             fast_memcpy(str+str_l, str_arg+zero_padding_insertion_ind,
1655                         (n>avail?avail:n));
1656           }
1657           str_l += n;
1658         }
1659       }
1660    /* insert right padding */
1661       if (justify_left) {          /* right blank padding to the field width */
1662         int n = min_field_width - (str_arg_l+number_of_zeros_to_pad);
1663         if (n > 0) {
1664           if (str_l < str_m) {
1665             size_t avail = str_m-str_l;
1666             fast_memset(str+str_l, ' ', (n>avail?avail:n));
1667           }
1668           str_l += n;
1669         }
1670       }
1671     }
1672   }
1673 #if defined(NEED_SNPRINTF_ONLY)
1674   va_end(ap);
1675 #endif
1676   if (str_m > 0) { /* make sure the string is null-terminated
1677                       even at the expense of overwriting the last character
1678                       (shouldn't happen, but just in case) */
1679     str[str_l <= str_m-1 ? str_l : str_m-1] = '\0';
1680   }
1681   /* Return the number of characters formatted (excluding trailing null
1682    * character), that is, the number of characters that would have been
1683    * written to the buffer if it were large enough.
1684    *
1685    * The value of str_l should be returned, but str_l is of unsigned type
1686    * size_t, and snprintf is int, possibly leading to an undetected
1687    * integer overflow, resulting in a negative return value, which is illegal.
1688    * Both XSH5 and ISO C99 (at least the draft) are silent on this issue.
1689    * Should errno be set to EOVERFLOW and EOF returned in this case???
1690    */
1691   return (int) str_l;
1692 }
1693 #endif
1694 #endif /* ndef HAVE_SNPRINTF */
1695 /*
1696   Local Variables:
1697   tab-width: 3
1698   end:
1699 */