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