miscutil.c

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