The Tcpdump Group git mirrors - tcpdump/blob - missing/snprintf.c

   1 /*
   2  * Copyright (c) 1995-1999 Kungliga Tekniska Högskolan
   3  * (Royal Institute of Technology, Stockholm, Sweden).
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  *
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * 3. Neither the name of the Institute nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  */
  33
  34 #ifdef HAVE_CONFIG_H
  35 #include <config.h>
  36 /* $Id: snprintf.c,v 1.1 2000-01-07 16:01:38 assar Exp $ */
  37 #endif
  38 #include <stdio.h>
  39 #include <stdarg.h>
  40 #include <stdlib.h>
  41 #include <string.h>
  42 #include <ctype.h>
  43
  44 #include <interface.h>
  45
  46 enum format_flags {
  47     minus_flag     =  1,
  48     plus_flag      =  2,
  49     space_flag     =  4,
  50     alternate_flag =  8,
  51     zero_flag      = 16
  52 };
  53
  54 /*
  55  * Common state
  56  */
  57
  58 struct state {
  59   unsigned char *str;
  60   unsigned char *s;
  61   unsigned char *theend;
  62   size_t sz;
  63   size_t max_sz;
  64   int (*append_char)(struct state *, unsigned char);
  65   int (*reserve)(struct state *, size_t);
  66   /* XXX - methods */
  67 };
  68
  69 #ifndef HAVE_VSNPRINTF
  70 static int
  71 sn_reserve (struct state *state, size_t n)
  72 {
  73   return state->s + n > state->theend;
  74 }
  75
  76 static int
  77 sn_append_char (struct state *state, unsigned char c)
  78 {
  79   if (sn_reserve (state, 1)) {
  80     return 1;
  81   } else {
  82     *state->s++ = c;
  83     return 0;
  84   }
  85 }
  86 #endif
  87
  88 static int
  89 as_reserve (struct state *state, size_t n)
  90 {
  91   if (state->s + n > state->theend) {
  92     int off = state->s - state->str;
  93     unsigned char *tmp;
  94
  95     if (state->max_sz && state->sz >= state->max_sz)
  96       return 1;
  97
  98     state->sz = max(state->sz * 2, state->sz + n);
  99     if (state->max_sz)
 100       state->sz = min(state->sz, state->max_sz);
 101     tmp = realloc (state->str, state->sz);
 102     if (tmp == NULL)
 103       return 1;
 104     state->str = tmp;
 105     state->s = state->str + off;
 106     state->theend = state->str + state->sz - 1;
 107   }
 108   return 0;
 109 }
 110
 111 static int
 112 as_append_char (struct state *state, unsigned char c)
 113 {
 114   if(as_reserve (state, 1))
 115     return 1;
 116   else {
 117     *state->s++ = c;
 118     return 0;
 119   }
 120 }
 121
 122 static int
 123 append_number(struct state *state,
 124               unsigned long num, unsigned base, char *rep,
 125               int width, int prec, int flags, int minusp)
 126 {
 127   int len = 0;
 128   int i;
 129
 130   /* given precision, ignore zero flag */
 131   if(prec != -1)
 132     flags &= ~zero_flag;
 133   else
 134     prec = 1;
 135   /* zero value with zero precision -> "" */
 136   if(prec == 0 && num == 0)
 137     return 0;
 138   do{
 139     if((*state->append_char)(state, rep[num % base]))
 140       return 1;
 141     len++;
 142     num /= base;
 143   }while(num);
 144   prec -= len;
 145   /* pad with prec zeros */
 146   while(prec-- > 0){
 147     if((*state->append_char)(state, '0'))
 148       return 1;
 149     len++;
 150   }
 151   /* add length of alternate prefix (added later) to len */
 152   if(flags & alternate_flag && (base == 16 || base == 8))
 153     len += base / 8;
 154   /* pad with zeros */
 155   if(flags & zero_flag){
 156     width -= len;
 157     if(minusp || (flags & space_flag) || (flags & plus_flag))
 158       width--;
 159     while(width-- > 0){
 160       if((*state->append_char)(state, '0'))
 161         return 1;
 162       len++;
 163     }
 164   }
 165   /* add alternate prefix */
 166   if(flags & alternate_flag && (base == 16 || base == 8)){
 167     if(base == 16)
 168       if((*state->append_char)(state, rep[10] + 23)) /* XXX */
 169         return 1;
 170     if((*state->append_char)(state, '0'))
 171       return 1;
 172   }
 173   /* add sign */
 174   if(minusp){
 175     if((*state->append_char)(state, '-'))
 176       return 1;
 177     len++;
 178   } else if(flags & plus_flag) {
 179     if((*state->append_char)(state, '+'))
 180       return 1;
 181     len++;
 182   } else if(flags & space_flag) {
 183     if((*state->append_char)(state, ' '))
 184       return 1;
 185     len++;
 186   }
 187   if(flags & minus_flag)
 188     /* swap before padding with spaces */
 189     for(i = 0; i < len / 2; i++){
 190       char c = state->s[-i-1];
 191       state->s[-i-1] = state->s[-len+i];
 192       state->s[-len+i] = c;
 193     }
 194   width -= len;
 195   while(width-- > 0){
 196     if((*state->append_char)(state,  ' '))
 197       return 1;
 198     len++;
 199   }
 200   if(!(flags & minus_flag))
 201     /* swap after padding with spaces */
 202     for(i = 0; i < len / 2; i++){
 203       char c = state->s[-i-1];
 204       state->s[-i-1] = state->s[-len+i];
 205       state->s[-len+i] = c;
 206     }
 207
 208   return 0;
 209 }
 210
 211 static int
 212 append_string (struct state *state,
 213                unsigned char *arg,
 214                int width,
 215                int prec,
 216                int flags)
 217 {
 218   if(prec != -1)
 219     width -= prec;
 220   else
 221     width -= strlen((char *)arg);
 222   if(!(flags & minus_flag))
 223     while(width-- > 0)
 224       if((*state->append_char) (state, ' '))
 225         return 1;
 226   if (prec != -1) {
 227     while (*arg && prec--)
 228       if ((*state->append_char) (state, *arg++))
 229         return 1;
 230   } else {
 231     while (*arg)
 232       if ((*state->append_char) (state, *arg++))
 233         return 1;
 234   }
 235   if(flags & minus_flag)
 236     while(width-- > 0)
 237       if((*state->append_char) (state, ' '))
 238         return 1;
 239   return 0;
 240 }
 241
 242 static int
 243 append_char(struct state *state,
 244             unsigned char arg,
 245             int width,
 246             int flags)
 247 {
 248   while(!(flags & minus_flag) && --width > 0)
 249     if((*state->append_char) (state, ' '))
 250       return 1;
 251
 252   if((*state->append_char) (state, arg))
 253     return 1;
 254   while((flags & minus_flag) && --width > 0)
 255     if((*state->append_char) (state, ' '))
 256       return 1;
 257
 258   return 0;
 259 }
 260
 261 /*
 262  * This can't be made into a function...
 263  */
 264
 265 #define PARSE_INT_FORMAT(res, arg, unsig) \
 266 if (long_flag) \
 267      res = (unsig long)va_arg(arg, unsig long); \
 268 else if (short_flag) \
 269      res = (unsig short)va_arg(arg, unsig short); \
 270 else \
 271      res = (unsig int)va_arg(arg, unsig int)
 272
 273 /*
 274  * zyxprintf - return 0 or -1
 275  */
 276
 277 static int
 278 xyzprintf (struct state *state, const char *char_format, va_list ap)
 279 {
 280   const unsigned char *format = (const unsigned char *)char_format;
 281   unsigned char c;
 282
 283   while((c = *format++)) {
 284     if (c == '%') {
 285       int flags      = 0;
 286       int width      = 0;
 287       int prec       = -1;
 288       int long_flag  = 0;
 289       int short_flag = 0;
 290
 291       /* flags */
 292       while((c = *format++)){
 293         if(c == '-')
 294           flags |= minus_flag;
 295         else if(c == '+')
 296           flags |= plus_flag;
 297         else if(c == ' ')
 298           flags |= space_flag;
 299         else if(c == '#')
 300           flags |= alternate_flag;
 301         else if(c == '0')
 302           flags |= zero_flag;
 303         else
 304           break;
 305       }
 306
 307       if((flags & space_flag) && (flags & plus_flag))
 308         flags ^= space_flag;
 309
 310       if((flags & minus_flag) && (flags & zero_flag))
 311         flags ^= zero_flag;
 312
 313       /* width */
 314       if (isdigit(c))
 315         do {
 316           width = width * 10 + c - '0';
 317           c = *format++;
 318         } while(isdigit(c));
 319       else if(c == '*') {
 320         width = va_arg(ap, int);
 321         c = *format++;
 322       }
 323
 324       /* precision */
 325       if (c == '.') {
 326         prec = 0;
 327         c = *format++;
 328         if (isdigit(c))
 329           do {
 330             prec = prec * 10 + c - '0';
 331             c = *format++;
 332           } while(isdigit(c));
 333         else if (c == '*') {
 334           prec = va_arg(ap, int);
 335           c = *format++;
 336         }
 337       }
 338
 339       /* size */
 340
 341       if (c == 'h') {
 342         short_flag = 1;
 343         c = *format++;
 344       } else if (c == 'l') {
 345         long_flag = 1;
 346         c = *format++;
 347       }
 348
 349       switch (c) {
 350       case 'c' :
 351         if(append_char(state, va_arg(ap, int), width, flags))
 352           return -1;
 353         break;
 354       case 's' :
 355         if (append_string(state,
 356                           va_arg(ap, unsigned char*),
 357                           width,
 358                           prec,
 359                           flags))
 360           return -1;
 361         break;
 362       case 'd' :
 363       case 'i' : {
 364         long arg;
 365         unsigned long num;
 366         int minusp = 0;
 367
 368         PARSE_INT_FORMAT(arg, ap, signed);
 369
 370         if (arg < 0) {
 371           minusp = 1;
 372           num = -arg;
 373         } else
 374           num = arg;
 375
 376         if (append_number (state, num, 10, "0123456789",
 377                            width, prec, flags, minusp))
 378           return -1;
 379         break;
 380       }
 381       case 'u' : {
 382         unsigned long arg;
 383
 384         PARSE_INT_FORMAT(arg, ap, unsigned);
 385
 386         if (append_number (state, arg, 10, "0123456789",
 387                            width, prec, flags, 0))
 388           return -1;
 389         break;
 390       }
 391       case 'o' : {
 392         unsigned long arg;
 393
 394         PARSE_INT_FORMAT(arg, ap, unsigned);
 395
 396         if (append_number (state, arg, 010, "01234567",
 397                            width, prec, flags, 0))
 398           return -1;
 399         break;
 400       }
 401       case 'x' : {
 402         unsigned long arg;
 403
 404         PARSE_INT_FORMAT(arg, ap, unsigned);
 405
 406         if (append_number (state, arg, 0x10, "0123456789abcdef",
 407                            width, prec, flags, 0))
 408           return -1;
 409         break;
 410       }
 411       case 'X' :{
 412         unsigned long arg;
 413
 414         PARSE_INT_FORMAT(arg, ap, unsigned);
 415
 416         if (append_number (state, arg, 0x10, "0123456789ABCDEF",
 417                            width, prec, flags, 0))
 418           return -1;
 419         break;
 420       }
 421       case 'p' : {
 422         unsigned long arg = (unsigned long)va_arg(ap, void*);
 423
 424         if (append_number (state, arg, 0x10, "0123456789ABCDEF",
 425                            width, prec, flags, 0))
 426           return -1;
 427         break;
 428       }
 429       case 'n' : {
 430         int *arg = va_arg(ap, int*);
 431         *arg = state->s - state->str;
 432         break;
 433       }
 434       case '\0' :
 435           --format;
 436           /* FALLTHROUGH */
 437       case '%' :
 438         if ((*state->append_char)(state, c))
 439           return -1;
 440         break;
 441       default :
 442         if (   (*state->append_char)(state, '%')
 443             || (*state->append_char)(state, c))
 444           return -1;
 445         break;
 446       }
 447     } else
 448       if ((*state->append_char) (state, c))
 449         return -1;
 450   }
 451   return 0;
 452 }
 453
 454 #ifndef HAVE_SNPRINTF
 455 int
 456 snprintf (char *str, size_t sz, const char *format, ...)
 457 {
 458   va_list args;
 459   int ret;
 460
 461   va_start(args, format);
 462   ret = vsnprintf (str, sz, format, args);
 463
 464 #ifdef PARANOIA
 465   {
 466     int ret2;
 467     char *tmp;
 468
 469     tmp = malloc (sz);
 470     if (tmp == NULL)
 471       abort ();
 472
 473     ret2 = vsprintf (tmp, format, args);
 474     if (ret != ret2 || strcmp(str, tmp))
 475       abort ();
 476     free (tmp);
 477   }
 478 #endif
 479
 480   va_end(args);
 481   return ret;
 482 }
 483 #endif
 484
 485 #ifndef HAVE_ASPRINTF
 486 int
 487 asprintf (char **ret, const char *format, ...)
 488 {
 489   va_list args;
 490   int val;
 491
 492   va_start(args, format);
 493   val = vasprintf (ret, format, args);
 494
 495 #ifdef PARANOIA
 496   {
 497     int ret2;
 498     char *tmp;
 499     tmp = malloc (val + 1);
 500     if (tmp == NULL)
 501       abort ();
 502
 503     ret2 = vsprintf (tmp, format, args);
 504     if (val != ret2 || strcmp(*ret, tmp))
 505       abort ();
 506     free (tmp);
 507   }
 508 #endif
 509
 510   va_end(args);
 511   return val;
 512 }
 513 #endif
 514
 515 #ifndef HAVE_ASNPRINTF
 516 int
 517 asnprintf (char **ret, size_t max_sz, const char *format, ...)
 518 {
 519   va_list args;
 520   int val;
 521
 522   va_start(args, format);
 523   val = vasnprintf (ret, max_sz, format, args);
 524
 525 #ifdef PARANOIA
 526   {
 527     int ret2;
 528     char *tmp;
 529     tmp = malloc (val + 1);
 530     if (tmp == NULL)
 531       abort ();
 532
 533     ret2 = vsprintf (tmp, format, args);
 534     if (val != ret2 || strcmp(*ret, tmp))
 535       abort ();
 536     free (tmp);
 537   }
 538 #endif
 539
 540   va_end(args);
 541   return val;
 542 }
 543 #endif
 544
 545 #ifndef HAVE_VASPRINTF
 546 int
 547 vasprintf (char **ret, const char *format, va_list args)
 548 {
 549   return vasnprintf (ret, 0, format, args);
 550 }
 551 #endif
 552
 553
 554 #ifndef HAVE_VASNPRINTF
 555 int
 556 vasnprintf (char **ret, size_t max_sz, const char *format, va_list args)
 557 {
 558   int st;
 559   size_t len;
 560   struct state state;
 561
 562   state.max_sz = max_sz;
 563   state.sz     = 1;
 564   state.str    = malloc(state.sz);
 565   if (state.str == NULL) {
 566     *ret = NULL;
 567     return -1;
 568   }
 569   state.s = state.str;
 570   state.theend = state.s + state.sz - 1;
 571   state.append_char = as_append_char;
 572   state.reserve     = as_reserve;
 573
 574   st = xyzprintf (&state, format, args);
 575   if (st) {
 576     free (state.str);
 577     *ret = NULL;
 578     return -1;
 579   } else {
 580     char *tmp;
 581
 582     *state.s = '\0';
 583     len = state.s - state.str;
 584     tmp = realloc (state.str, len+1);
 585     if (tmp == NULL) {
 586       free (state.str);
 587       *ret = NULL;
 588       return -1;
 589     }
 590     *ret = tmp;
 591     return len;
 592   }
 593 }
 594 #endif
 595
 596 #ifndef HAVE_VSNPRINTF
 597 int
 598 vsnprintf (char *str, size_t sz, const char *format, va_list args)
 599 {
 600   struct state state;
 601   int ret;
 602   unsigned char *ustr = (unsigned char *)str;
 603
 604   state.max_sz = 0;
 605   state.sz     = sz;
 606   state.str    = ustr;
 607   state.s      = ustr;
 608   state.theend = ustr + sz - 1;
 609   state.append_char = sn_append_char;
 610   state.reserve     = sn_reserve;
 611
 612   ret = xyzprintf (&state, format, args);
 613   *state.s = '\0';
 614   if (ret)
 615     return sz;
 616   else
 617     return state.s - state.str;
 618 }
 619 #endif
 620