Home | History | Annotate | Download | only in missing
      1 /*
      2  * Copyright (c) 1995-1999 Kungliga Tekniska Hgskolan
      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 /* $Id: snprintf.c,v 1.8 2003/11/16 09:36:51 guy Exp $ */
     35 
     36 #ifdef HAVE_CONFIG_H
     37 #include <config.h>
     38 #endif
     39 
     40 #ifndef lint
     41 static const char rcsid[] _U_ =
     42      "@(#) $Header: /tcpdump/master/tcpdump/missing/snprintf.c,v 1.8 2003/11/16 09:36:51 guy Exp $";
     43 #endif
     44 
     45 #include <stdio.h>
     46 #include <stdarg.h>
     47 #include <stdlib.h>
     48 #include <string.h>
     49 #include <ctype.h>
     50 #include <sys/types.h>
     51 
     52 #include <interface.h>
     53 
     54 enum format_flags {
     55     minus_flag     =  1,
     56     plus_flag      =  2,
     57     space_flag     =  4,
     58     alternate_flag =  8,
     59     zero_flag      = 16
     60 };
     61 
     62 /*
     63  * Common state
     64  */
     65 
     66 struct state {
     67   unsigned char *str;
     68   unsigned char *s;
     69   unsigned char *theend;
     70   size_t sz;
     71   size_t max_sz;
     72   int (*append_char)(struct state *, unsigned char);
     73   int (*reserve)(struct state *, size_t);
     74   /* XXX - methods */
     75 };
     76 
     77 #ifndef HAVE_VSNPRINTF
     78 static int
     79 sn_reserve (struct state *state, size_t n)
     80 {
     81   return state->s + n > state->theend;
     82 }
     83 
     84 static int
     85 sn_append_char (struct state *state, unsigned char c)
     86 {
     87   if (sn_reserve (state, 1)) {
     88     return 1;
     89   } else {
     90     *state->s++ = c;
     91     return 0;
     92   }
     93 }
     94 #endif
     95 
     96 #if 0
     97 static int
     98 as_reserve (struct state *state, size_t n)
     99 {
    100   if (state->s + n > state->theend) {
    101     int off = state->s - state->str;
    102     unsigned char *tmp;
    103 
    104     if (state->max_sz && state->sz >= state->max_sz)
    105       return 1;
    106 
    107     state->sz = max(state->sz * 2, state->sz + n);
    108     if (state->max_sz)
    109       state->sz = min(state->sz, state->max_sz);
    110     tmp = realloc (state->str, state->sz);
    111     if (tmp == NULL)
    112       return 1;
    113     state->str = tmp;
    114     state->s = state->str + off;
    115     state->theend = state->str + state->sz - 1;
    116   }
    117   return 0;
    118 }
    119 
    120 static int
    121 as_append_char (struct state *state, unsigned char c)
    122 {
    123   if(as_reserve (state, 1))
    124     return 1;
    125   else {
    126     *state->s++ = c;
    127     return 0;
    128   }
    129 }
    130 #endif
    131 
    132 static int
    133 append_number(struct state *state,
    134 	      unsigned long num, unsigned base, char *rep,
    135 	      int width, int prec, int flags, int minusp)
    136 {
    137   int len = 0;
    138   int i;
    139 
    140   /* given precision, ignore zero flag */
    141   if(prec != -1)
    142     flags &= ~zero_flag;
    143   else
    144     prec = 1;
    145   /* zero value with zero precision -> "" */
    146   if(prec == 0 && num == 0)
    147     return 0;
    148   do{
    149     if((*state->append_char)(state, rep[num % base]))
    150       return 1;
    151     len++;
    152     num /= base;
    153   }while(num);
    154   prec -= len;
    155   /* pad with prec zeros */
    156   while(prec-- > 0){
    157     if((*state->append_char)(state, '0'))
    158       return 1;
    159     len++;
    160   }
    161   /* add length of alternate prefix (added later) to len */
    162   if(flags & alternate_flag && (base == 16 || base == 8))
    163     len += base / 8;
    164   /* pad with zeros */
    165   if(flags & zero_flag){
    166     width -= len;
    167     if(minusp || (flags & space_flag) || (flags & plus_flag))
    168       width--;
    169     while(width-- > 0){
    170       if((*state->append_char)(state, '0'))
    171 	return 1;
    172       len++;
    173     }
    174   }
    175   /* add alternate prefix */
    176   if(flags & alternate_flag && (base == 16 || base == 8)){
    177     if(base == 16)
    178       if((*state->append_char)(state, rep[10] + 23)) /* XXX */
    179 	return 1;
    180     if((*state->append_char)(state, '0'))
    181       return 1;
    182   }
    183   /* add sign */
    184   if(minusp){
    185     if((*state->append_char)(state, '-'))
    186       return 1;
    187     len++;
    188   } else if(flags & plus_flag) {
    189     if((*state->append_char)(state, '+'))
    190       return 1;
    191     len++;
    192   } else if(flags & space_flag) {
    193     if((*state->append_char)(state, ' '))
    194       return 1;
    195     len++;
    196   }
    197   if(flags & minus_flag)
    198     /* swap before padding with spaces */
    199     for(i = 0; i < len / 2; i++){
    200       char c = state->s[-i-1];
    201       state->s[-i-1] = state->s[-len+i];
    202       state->s[-len+i] = c;
    203     }
    204   width -= len;
    205   while(width-- > 0){
    206     if((*state->append_char)(state,  ' '))
    207       return 1;
    208     len++;
    209   }
    210   if(!(flags & minus_flag))
    211     /* swap after padding with spaces */
    212     for(i = 0; i < len / 2; i++){
    213       char c = state->s[-i-1];
    214       state->s[-i-1] = state->s[-len+i];
    215       state->s[-len+i] = c;
    216     }
    217 
    218   return 0;
    219 }
    220 
    221 static int
    222 append_string (struct state *state,
    223 	       unsigned char *arg,
    224 	       int width,
    225 	       int prec,
    226 	       int flags)
    227 {
    228   if(prec != -1)
    229     width -= prec;
    230   else
    231     width -= strlen((char *)arg);
    232   if(!(flags & minus_flag))
    233     while(width-- > 0)
    234       if((*state->append_char) (state, ' '))
    235 	return 1;
    236   if (prec != -1) {
    237     while (*arg && prec--)
    238       if ((*state->append_char) (state, *arg++))
    239 	return 1;
    240   } else {
    241     while (*arg)
    242       if ((*state->append_char) (state, *arg++))
    243 	return 1;
    244   }
    245   if(flags & minus_flag)
    246     while(width-- > 0)
    247       if((*state->append_char) (state, ' '))
    248 	return 1;
    249   return 0;
    250 }
    251 
    252 static int
    253 append_char(struct state *state,
    254 	    unsigned char arg,
    255 	    int width,
    256 	    int flags)
    257 {
    258   while(!(flags & minus_flag) && --width > 0)
    259     if((*state->append_char) (state, ' '))
    260       return 1;
    261 
    262   if((*state->append_char) (state, arg))
    263     return 1;
    264   while((flags & minus_flag) && --width > 0)
    265     if((*state->append_char) (state, ' '))
    266       return 1;
    267 
    268   return 0;
    269 }
    270 
    271 /*
    272  * This can't be made into a function...
    273  */
    274 
    275 #define PARSE_INT_FORMAT(res, arg, unsig) \
    276 if (long_flag) \
    277      res = (unsig long)va_arg(arg, unsig long); \
    278 else if (short_flag) \
    279      res = (unsig short)va_arg(arg, unsig int); \
    280 else \
    281      res = (unsig int)va_arg(arg, unsig int)
    282 
    283 /*
    284  * zyxprintf - return 0 or -1
    285  */
    286 
    287 static int
    288 xyzprintf (struct state *state, const char *char_format, va_list ap)
    289 {
    290   const unsigned char *format = (const unsigned char *)char_format;
    291   unsigned char c;
    292 
    293   while((c = *format++)) {
    294     if (c == '%') {
    295       int flags      = 0;
    296       int width      = 0;
    297       int prec       = -1;
    298       int long_flag  = 0;
    299       int short_flag = 0;
    300 
    301       /* flags */
    302       while((c = *format++)){
    303 	if(c == '-')
    304 	  flags |= minus_flag;
    305 	else if(c == '+')
    306 	  flags |= plus_flag;
    307 	else if(c == ' ')
    308 	  flags |= space_flag;
    309 	else if(c == '#')
    310 	  flags |= alternate_flag;
    311 	else if(c == '0')
    312 	  flags |= zero_flag;
    313 	else
    314 	  break;
    315       }
    316 
    317       if((flags & space_flag) && (flags & plus_flag))
    318 	flags ^= space_flag;
    319 
    320       if((flags & minus_flag) && (flags & zero_flag))
    321 	flags ^= zero_flag;
    322 
    323       /* width */
    324       if (isdigit(c))
    325 	do {
    326 	  width = width * 10 + c - '0';
    327 	  c = *format++;
    328 	} while(isdigit(c));
    329       else if(c == '*') {
    330 	width = va_arg(ap, int);
    331 	c = *format++;
    332       }
    333 
    334       /* precision */
    335       if (c == '.') {
    336 	prec = 0;
    337 	c = *format++;
    338 	if (isdigit(c))
    339 	  do {
    340 	    prec = prec * 10 + c - '0';
    341 	    c = *format++;
    342 	  } while(isdigit(c));
    343 	else if (c == '*') {
    344 	  prec = va_arg(ap, int);
    345 	  c = *format++;
    346 	}
    347       }
    348 
    349       /* size */
    350 
    351       if (c == 'h') {
    352 	short_flag = 1;
    353 	c = *format++;
    354       } else if (c == 'l') {
    355 	long_flag = 1;
    356 	c = *format++;
    357       }
    358 
    359       switch (c) {
    360       case 'c' :
    361 	if(append_char(state, va_arg(ap, int), width, flags))
    362 	  return -1;
    363 	break;
    364       case 's' :
    365 	if (append_string(state,
    366 			  va_arg(ap, unsigned char*),
    367 			  width,
    368 			  prec,
    369 			  flags))
    370 	  return -1;
    371 	break;
    372       case 'd' :
    373       case 'i' : {
    374 	long arg;
    375 	unsigned long num;
    376 	int minusp = 0;
    377 
    378 	PARSE_INT_FORMAT(arg, ap, signed);
    379 
    380 	if (arg < 0) {
    381 	  minusp = 1;
    382 	  num = -arg;
    383 	} else
    384 	  num = arg;
    385 
    386 	if (append_number (state, num, 10, "0123456789",
    387 			   width, prec, flags, minusp))
    388 	  return -1;
    389 	break;
    390       }
    391       case 'u' : {
    392 	unsigned long arg;
    393 
    394 	PARSE_INT_FORMAT(arg, ap, unsigned);
    395 
    396 	if (append_number (state, arg, 10, "0123456789",
    397 			   width, prec, flags, 0))
    398 	  return -1;
    399 	break;
    400       }
    401       case 'o' : {
    402 	unsigned long arg;
    403 
    404 	PARSE_INT_FORMAT(arg, ap, unsigned);
    405 
    406 	if (append_number (state, arg, 010, "01234567",
    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 'X' :{
    422 	unsigned long arg;
    423 
    424 	PARSE_INT_FORMAT(arg, ap, unsigned);
    425 
    426 	if (append_number (state, arg, 0x10, "0123456789ABCDEF",
    427 			   width, prec, flags, 0))
    428 	  return -1;
    429 	break;
    430       }
    431       case 'p' : {
    432 	unsigned long arg = (unsigned long)va_arg(ap, void*);
    433 
    434 	if (append_number (state, arg, 0x10, "0123456789ABCDEF",
    435 			   width, prec, flags, 0))
    436 	  return -1;
    437 	break;
    438       }
    439       case 'n' : {
    440 	int *arg = va_arg(ap, int*);
    441 	*arg = state->s - state->str;
    442 	break;
    443       }
    444       case '\0' :
    445 	  --format;
    446 	  /* FALLTHROUGH */
    447       case '%' :
    448 	if ((*state->append_char)(state, c))
    449 	  return -1;
    450 	break;
    451       default :
    452 	if (   (*state->append_char)(state, '%')
    453 	    || (*state->append_char)(state, c))
    454 	  return -1;
    455 	break;
    456       }
    457     } else
    458       if ((*state->append_char) (state, c))
    459 	return -1;
    460   }
    461   return 0;
    462 }
    463 
    464 #ifndef HAVE_SNPRINTF
    465 int
    466 snprintf (char *str, size_t sz, const char *format, ...)
    467 {
    468   va_list args;
    469   int ret;
    470 
    471   va_start(args, format);
    472   ret = vsnprintf (str, sz, format, args);
    473 
    474 #ifdef PARANOIA
    475   {
    476     int ret2;
    477     char *tmp;
    478 
    479     tmp = malloc (sz);
    480     if (tmp == NULL)
    481       abort ();
    482 
    483     ret2 = vsprintf (tmp, format, args);
    484     if (ret != ret2 || strcmp(str, tmp))
    485       abort ();
    486     free (tmp);
    487   }
    488 #endif
    489 
    490   va_end(args);
    491   return ret;
    492 }
    493 #endif
    494 
    495 #if 0
    496 #ifndef HAVE_ASPRINTF
    497 int
    498 asprintf (char **ret, const char *format, ...)
    499 {
    500   va_list args;
    501   int val;
    502 
    503   va_start(args, format);
    504   val = vasprintf (ret, format, args);
    505 
    506 #ifdef PARANOIA
    507   {
    508     int ret2;
    509     char *tmp;
    510     tmp = malloc (val + 1);
    511     if (tmp == NULL)
    512       abort ();
    513 
    514     ret2 = vsprintf (tmp, format, args);
    515     if (val != ret2 || strcmp(*ret, tmp))
    516       abort ();
    517     free (tmp);
    518   }
    519 #endif
    520 
    521   va_end(args);
    522   return val;
    523 }
    524 #endif
    525 
    526 #ifndef HAVE_ASNPRINTF
    527 int
    528 asnprintf (char **ret, size_t max_sz, const char *format, ...)
    529 {
    530   va_list args;
    531   int val;
    532 
    533   va_start(args, format);
    534   val = vasnprintf (ret, max_sz, format, args);
    535 
    536 #ifdef PARANOIA
    537   {
    538     int ret2;
    539     char *tmp;
    540     tmp = malloc (val + 1);
    541     if (tmp == NULL)
    542       abort ();
    543 
    544     ret2 = vsprintf (tmp, format, args);
    545     if (val != ret2 || strcmp(*ret, tmp))
    546       abort ();
    547     free (tmp);
    548   }
    549 #endif
    550 
    551   va_end(args);
    552   return val;
    553 }
    554 #endif
    555 
    556 #ifndef HAVE_VASPRINTF
    557 int
    558 vasprintf (char **ret, const char *format, va_list args)
    559 {
    560   return vasnprintf (ret, 0, format, args);
    561 }
    562 #endif
    563 
    564 
    565 #ifndef HAVE_VASNPRINTF
    566 int
    567 vasnprintf (char **ret, size_t max_sz, const char *format, va_list args)
    568 {
    569   int st;
    570   size_t len;
    571   struct state state;
    572 
    573   state.max_sz = max_sz;
    574   state.sz     = 1;
    575   state.str    = malloc(state.sz);
    576   if (state.str == NULL) {
    577     *ret = NULL;
    578     return -1;
    579   }
    580   state.s = state.str;
    581   state.theend = state.s + state.sz - 1;
    582   state.append_char = as_append_char;
    583   state.reserve     = as_reserve;
    584 
    585   st = xyzprintf (&state, format, args);
    586   if (st) {
    587     free (state.str);
    588     *ret = NULL;
    589     return -1;
    590   } else {
    591     char *tmp;
    592 
    593     *state.s = '\0';
    594     len = state.s - state.str;
    595     tmp = realloc (state.str, len+1);
    596     if (tmp == NULL) {
    597       free (state.str);
    598       *ret = NULL;
    599       return -1;
    600     }
    601     *ret = tmp;
    602     return len;
    603   }
    604 }
    605 #endif
    606 #endif
    607 
    608 #ifndef HAVE_VSNPRINTF
    609 int
    610 vsnprintf (char *str, size_t sz, const char *format, va_list args)
    611 {
    612   struct state state;
    613   int ret;
    614   unsigned char *ustr = (unsigned char *)str;
    615 
    616   state.max_sz = 0;
    617   state.sz     = sz;
    618   state.str    = ustr;
    619   state.s      = ustr;
    620   state.theend = ustr + sz - 1;
    621   state.append_char = sn_append_char;
    622   state.reserve     = sn_reserve;
    623 
    624   ret = xyzprintf (&state, format, args);
    625   *state.s = '\0';
    626   if (ret)
    627     return sz;
    628   else
    629     return state.s - state.str;
    630 }
    631 #endif
    632 
    633