开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > Telnet服务器 > 查看源码
snprintf.c
资源名称：nessus-libraries_2.2.10.orig.tar.gz　[点击查看]
上传用户：tjescc
上传日期：2021-02-23
资源大小：419k
文件大小：13k
源码类别：

Telnet服务器

开发平台：

Unix_Linux

snprintf.c：源码内容
  2. /* taken from nmap -rd */
  4. /* Note -- this file was obtained from tcpdump-2000-9-17 CVS snapshot
  5.    ( www.tcpdump.org).  It has been modified slightly for compatability
  6.    with libnbase.  Modification etails may be in the nbase CHANGELOG 
  7.     - fyodor@insecure.org
  8.  */
  11. /*
  12.  * Copyright (c) 1995-1999 Kungliga Tekniska H鰃skolan
  13.  * (Royal Institute of Technology, Stockholm, Sweden).
  14.  * All rights reserved.
  15.  * 
  16.  * Redistribution and use in source and binary forms, with or without
  17.  * modification, are permitted provided that the following conditions
  18.  * are met:
  19.  * 
  20.  * 1. Redistributions of source code must retain the above copyright
  21.  *    notice, this list of conditions and the following disclaimer.
  22.  * 
  23.  * 2. Redistributions in binary form must reproduce the above copyright
  24.  *    notice, this list of conditions and the following disclaimer in the
  25.  *    documentation and/or other materials provided with the distribution.
  26.  * 
  27.  * 3. Neither the name of the Institute nor the names of its contributors
  28.  *    may be used to endorse or promote products derived from this software
  29.  *    without specific prior written permission.
  30.  * 
  31.  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
  32.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  33.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  34.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
  35.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  36.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  37.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  38.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  39.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  40.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  41.  * SUCH DAMAGE.
  42.  */
  44. /* $Id: snprintf.c,v 1.1 2003/01/27 10:49:59 renaud Exp $ */
  46. #include <includes.h>
  47. #ifndef HAVE_SNPRINTF
  49. #ifndef min
  50. #define min(a,b) ((a)>(b)?(b):(a))
  51. #endif
  52. #ifndef max
  53. #define max(a,b) ((b)>(a)?(b):(a))
  54. #endif
  56. enum format_flags {
  57.     minus_flag     =  1,
  58.     plus_flag      =  2,
  59.     space_flag     =  4,
  60.     alternate_flag =  8,
  61.     zero_flag      = 16
  62. };
  64. /*
  65.  * Common state
  66.  */
  68. struct state {
  69.   unsigned char *str;
  70.   unsigned char *s;
  71.   unsigned char *theend;
  72.   size_t sz;
  73.   size_t max_sz;
  74.   int (*append_char)(struct state *, unsigned char);
  75.   int (*reserve)(struct state *, size_t);
  76.   /* XXX - methods */
  77. };
  79. #ifndef HAVE_VSNPRINTF
  80. static int
  81. sn_reserve (struct state *state, size_t n)
  82. {
  83.   return state->s + n > state->theend;
  84. }
  86. static int
  87. sn_append_char (struct state *state, unsigned char c)
  88. {
  89.   if (sn_reserve (state, 1)) {
  90.     return 1;
  91.   } else {
  92.     *state->s++ = c;
  93.     return 0;
  94.   }
  95. }
  96. #endif
  98. static int
  99. as_reserve (struct state *state, size_t n)
  100. {
  101.   if (state->s + n > state->theend) {
  102.     int off = state->s - state->str;
  103.     unsigned char *tmp;
  105.     if (state->max_sz && state->sz >= state->max_sz)
  106.       return 1;
  108.     state->sz = max(state->sz * 2, state->sz + n);
  109.     if (state->max_sz)
  110.       state->sz = min(state->sz, state->max_sz);
  111.     tmp = realloc (state->str, state->sz);
  112.     if (tmp == NULL)
  113.       return 1;
  114.     state->str = tmp;
  115.     state->s = state->str + off;
  116.     state->theend = state->str + state->sz - 1;
  117.   }
  118.   return 0;
  119. }
  121. static int
  122. as_append_char (struct state *state, unsigned char c)
  123. {
  124.   if(as_reserve (state, 1))
  125.     return 1;
  126.   else {
  127.     *state->s++ = c;
  128.     return 0;
  129.   }
  130. }
  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;
  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. }
  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. }
  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. }
  271. /*
  272.  * This can't be made into a function...
  273.  */
  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)
  283. /*
  284.  * zyxprintf - return 0 or -1
  285.  */
  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;
  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;
  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;
  320.       if((flags & minus_flag) && (flags & zero_flag))
  321. flags ^= zero_flag;
  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.       }
  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.       }
  349.       /* size */
  351.       if (c == 'h') {
  352. short_flag = 1;
  353. c = *format++;
  354.       } else if (c == 'l') {
  355. long_flag = 1;
  356. c = *format++;
  357.       }
  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;
  378. PARSE_INT_FORMAT(arg, ap, signed);
  380. if (arg < 0) {
  381.   minusp = 1;
  382.   num = -arg;
  383. } else
  384.   num = arg;
  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;
  394. PARSE_INT_FORMAT(arg, ap, unsigned);
  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;
  404. PARSE_INT_FORMAT(arg, ap, unsigned);
  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;
  414. PARSE_INT_FORMAT(arg, ap, unsigned);
  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;
  424. PARSE_INT_FORMAT(arg, ap, unsigned);
  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*);
  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 '' :
  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. }
  464. #ifndef HAVE_SNPRINTF
  465. int
  466. snprintf (char *str, size_t sz, const char *format, ...)
  467. {
  468.   va_list args;
  469.   int ret;
  471.   va_start(args, format);
  472.   ret = vsnprintf (str, sz, format, args);
  474. #ifdef PARANOIA
  475.   {
  476.     int ret2;
  477.     char *tmp;
  479.     tmp = malloc (sz);
  480.     if (tmp == NULL)
  481.       abort ();
  483.     ret2 = vsprintf (tmp, format, args);
  484.     if (ret != ret2 || strcmp(str, tmp))
  485.       abort ();
  486.     free (tmp);
  487.   }
  488. #endif
  490.   va_end(args);
  491.   return ret;
  492. }
  493. #endif
  496. #ifndef HAVE_VASNPRINTF
  497. int
  498. vasnprintf (char **ret, size_t max_sz, const char *format, va_list args)
  499. {
  500.   int st;
  501.   size_t len;
  502.   struct state state;
  504.   state.max_sz = max_sz;
  505.   state.sz     = 1;
  506.   state.str    = malloc(state.sz);
  507.   if (state.str == NULL) {
  508.     *ret = NULL;
  509.     return -1;
  510.   }
  511.   state.s = state.str;
  512.   state.theend = state.s + state.sz - 1;
  513.   state.append_char = as_append_char;
  514.   state.reserve     = as_reserve;
  516.   st = xyzprintf (&state, format, args);
  517.   if (st) {
  518.     free (state.str);
  519.     *ret = NULL;
  520.     return -1;
  521.   } else {
  522.     char *tmp;
  524.     *state.s = '';
  525.     len = state.s - state.str;
  526.     tmp = realloc (state.str, len+1);
  527.     if (tmp == NULL) {
  528.       free (state.str);
  529.       *ret = NULL;
  530.       return -1;
  531.     }
  532.     *ret = tmp;
  533.     return len;
  534.   }
  535. }
  536. #endif
  538. #ifndef HAVE_VASPRINTF
  539. int
  540. vasprintf (char **ret, const char *format, va_list args)
  541. {
  542.   return vasnprintf (ret, 0, format, args);
  543. }
  544. #endif
  546. #ifndef HAVE_ASPRINTF
  547. int
  548. asprintf (char **ret, const char *format, ...)
  549. {
  550.   va_list args;
  551.   int val;
  553.   va_start(args, format);
  554.   val = vasprintf (ret, format, args);
  556. #ifdef PARANOIA
  557.   {
  558.     int ret2;
  559.     char *tmp;
  560.     tmp = malloc (val + 1);
  561.     if (tmp == NULL)
  562.       abort ();
  564.     ret2 = vsprintf (tmp, format, args);
  565.     if (val != ret2 || strcmp(*ret, tmp))
  566.       abort ();
  567.     free (tmp);
  568.   }
  569. #endif
  571.   va_end(args);
  572.   return val;
  573. }
  574. #endif
  576. #ifndef HAVE_ASNPRINTF
  577. int
  578. asnprintf (char **ret, size_t max_sz, const char *format, ...)
  579. {
  580.   va_list args;
  581.   int val;
  583.   va_start(args, format);
  584.   val = vasnprintf (ret, max_sz, format, args);
  586. #ifdef PARANOIA
  587.   {
  588.     int ret2;
  589.     char *tmp;
  590.     tmp = malloc (val + 1);
  591.     if (tmp == NULL)
  592.       abort ();
  594.     ret2 = vsprintf (tmp, format, args);
  595.     if (val != ret2 || strcmp(*ret, tmp))
  596.       abort ();
  597.     free (tmp);
  598.   }
  599. #endif
  601.   va_end(args);
  602.   return val;
  603. }
  604. #endif
  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;
  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;
  624.   ret = xyzprintf (&state, format, args);
  625.   *state.s = '';
  626.   if (ret)
  627.     return sz;
  628.   else
  629.     return state.s - state.str;
  630. }
  631. #endif
  632. #endif