miscutil.c

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