r11797: Added OpenSSH fix for "%.*s" format crash. From Darren Tucker
[bbaumbach/samba-autobuild/.git] / source4 / lib / replace / snprintf.c
1 /*
2  * Copyright Patrick Powell 1995
3  * This code is based on code written by Patrick Powell (papowell@astart.com)
4  * It may be used for any purpose as long as this notice remains intact
5  * on all source code distributions
6  */
7
8 /**************************************************************
9  * Original:
10  * Patrick Powell Tue Apr 11 09:48:21 PDT 1995
11  * A bombproof version of doprnt (dopr) included.
12  * Sigh.  This sort of thing is always nasty do deal with.  Note that
13  * the version here does not include floating point...
14  *
15  * snprintf() is used instead of sprintf() as it does limit checks
16  * for string length.  This covers a nasty loophole.
17  *
18  * The other functions are there to prevent NULL pointers from
19  * causing nast effects.
20  *
21  * More Recently:
22  *  Brandon Long <blong@fiction.net> 9/15/96 for mutt 0.43
23  *  This was ugly.  It is still ugly.  I opted out of floating point
24  *  numbers, but the formatter understands just about everything
25  *  from the normal C string format, at least as far as I can tell from
26  *  the Solaris 2.5 printf(3S) man page.
27  *
28  *  Brandon Long <blong@fiction.net> 10/22/97 for mutt 0.87.1
29  *    Ok, added some minimal floating point support, which means this
30  *    probably requires libm on most operating systems.  Don't yet
31  *    support the exponent (e,E) and sigfig (g,G).  Also, fmtint()
32  *    was pretty badly broken, it just wasn't being exercised in ways
33  *    which showed it, so that's been fixed.  Also, formated the code
34  *    to mutt conventions, and removed dead code left over from the
35  *    original.  Also, there is now a builtin-test, just compile with:
36  *           gcc -DTEST_SNPRINTF -o snprintf snprintf.c -lm
37  *    and run snprintf for results.
38  * 
39  *  Thomas Roessler <roessler@guug.de> 01/27/98 for mutt 0.89i
40  *    The PGP code was using unsigned hexadecimal formats. 
41  *    Unfortunately, unsigned formats simply didn't work.
42  *
43  *  Michael Elkins <me@cs.hmc.edu> 03/05/98 for mutt 0.90.8
44  *    The original code assumed that both snprintf() and vsnprintf() were
45  *    missing.  Some systems only have snprintf() but not vsnprintf(), so
46  *    the code is now broken down under HAVE_SNPRINTF and HAVE_VSNPRINTF.
47  *
48  *  Andrew Tridgell (tridge@samba.org) Oct 1998
49  *    fixed handling of %.0f
50  *    added test for HAVE_LONG_DOUBLE
51  *
52  * tridge@samba.org, idra@samba.org, April 2001
53  *    got rid of fcvt code (twas buggy and made testing harder)
54  *    added C99 semantics
55  *
56  * Darren Tucker (dtucker@zip.com.au)
57  *    Fix bug allowing read overruns of the source string with "%.*s"
58  *    Usually harmless unless the read runs outside the process' allocation
59  *    (eg if your malloc does guard pages) in which case it will segfault.
60  *    From OpenSSH.  Also added test for same.
61  *
62  **************************************************************/
63
64 #ifndef NO_CONFIG_H /* for some tests */
65 #include "config.h"
66 #else
67 #define NULL 0
68 #endif
69
70 #ifdef TEST_SNPRINTF /* need math library headers for testing */
71 #include <math.h>
72 #endif
73
74 #ifdef HAVE_STRING_H
75 #include <string.h>
76 #endif
77
78 #ifdef HAVE_STRINGS_H
79 #include <strings.h>
80 #endif
81 #ifdef HAVE_CTYPE_H
82 #include <ctype.h>
83 #endif
84 #include <sys/types.h>
85 #include <stdarg.h>
86 #ifdef HAVE_STDLIB_H
87 #include <stdlib.h>
88 #endif
89
90 #ifndef VA_COPY
91 #ifdef HAVE_VA_COPY
92 #define VA_COPY(dest, src) va_copy(dest, src)
93 #elif defined(HAVE___VA_COPY)
94 #define VA_COPY(dest, src) __va_copy(dest, src)
95 #else
96 #define VA_COPY(dest, src) (dest) = (src)
97 #endif
98 #endif
99
100
101 #if defined(HAVE_SNPRINTF) && defined(HAVE_VSNPRINTF) && defined(HAVE_C99_VSNPRINTF)
102 /* only include stdio.h if we are not re-defining snprintf or vsnprintf */
103 #include <stdio.h>
104  /* make the compiler happy with an empty file */
105  void dummy_snprintf(void) {} 
106 #else
107
108 #ifdef HAVE_LONG_DOUBLE
109 #define LDOUBLE long double
110 #else
111 #define LDOUBLE double
112 #endif
113
114 #ifdef HAVE_LONG_LONG
115 #define LLONG long long
116 #else
117 #define LLONG long
118 #endif
119
120 /* free memory if the pointer is valid and zero the pointer */
121 #ifndef SAFE_FREE
122 #define SAFE_FREE(x) do { if ((x) != NULL) {free((x)); (x)=NULL;} } while(0)
123 #endif
124
125 static size_t dopr(char *buffer, size_t maxlen, const char *format, 
126                    va_list args_in);
127 static void fmtstr(char *buffer, size_t *currlen, size_t maxlen,
128                     char *value, int flags, int min, int max);
129 static void fmtint(char *buffer, size_t *currlen, size_t maxlen,
130                     long value, int base, int min, int max, int flags);
131 static void fmtfp(char *buffer, size_t *currlen, size_t maxlen,
132                    LDOUBLE fvalue, int min, int max, int flags);
133 static void dopr_outch(char *buffer, size_t *currlen, size_t maxlen, char c);
134
135 /*
136  * dopr(): poor man's version of doprintf
137  */
138
139 /* format read states */
140 #define DP_S_DEFAULT 0
141 #define DP_S_FLAGS   1
142 #define DP_S_MIN     2
143 #define DP_S_DOT     3
144 #define DP_S_MAX     4
145 #define DP_S_MOD     5
146 #define DP_S_CONV    6
147 #define DP_S_DONE    7
148
149 /* format flags - Bits */
150 #define DP_F_MINUS      (1 << 0)
151 #define DP_F_PLUS       (1 << 1)
152 #define DP_F_SPACE      (1 << 2)
153 #define DP_F_NUM        (1 << 3)
154 #define DP_F_ZERO       (1 << 4)
155 #define DP_F_UP         (1 << 5)
156 #define DP_F_UNSIGNED   (1 << 6)
157
158 /* Conversion Flags */
159 #define DP_C_SHORT   1
160 #define DP_C_LONG    2
161 #define DP_C_LDOUBLE 3
162 #define DP_C_LLONG   4
163
164 #define char_to_int(p) ((p)- '0')
165 #ifndef MAX
166 #define MAX(p,q) (((p) >= (q)) ? (p) : (q))
167 #endif
168
169 static size_t dopr(char *buffer, size_t maxlen, const char *format, va_list args_in)
170 {
171         char ch;
172         LLONG value;
173         LDOUBLE fvalue;
174         char *strvalue;
175         int min;
176         int max;
177         int state;
178         int flags;
179         int cflags;
180         size_t currlen;
181         va_list args;
182
183         VA_COPY(args, args_in);
184         
185         state = DP_S_DEFAULT;
186         currlen = flags = cflags = min = 0;
187         max = -1;
188         ch = *format++;
189         
190         while (state != DP_S_DONE) {
191                 if (ch == '\0') 
192                         state = DP_S_DONE;
193
194                 switch(state) {
195                 case DP_S_DEFAULT:
196                         if (ch == '%') 
197                                 state = DP_S_FLAGS;
198                         else 
199                                 dopr_outch (buffer, &currlen, maxlen, ch);
200                         ch = *format++;
201                         break;
202                 case DP_S_FLAGS:
203                         switch (ch) {
204                         case '-':
205                                 flags |= DP_F_MINUS;
206                                 ch = *format++;
207                                 break;
208                         case '+':
209                                 flags |= DP_F_PLUS;
210                                 ch = *format++;
211                                 break;
212                         case ' ':
213                                 flags |= DP_F_SPACE;
214                                 ch = *format++;
215                                 break;
216                         case '#':
217                                 flags |= DP_F_NUM;
218                                 ch = *format++;
219                                 break;
220                         case '0':
221                                 flags |= DP_F_ZERO;
222                                 ch = *format++;
223                                 break;
224                         default:
225                                 state = DP_S_MIN;
226                                 break;
227                         }
228                         break;
229                 case DP_S_MIN:
230                         if (isdigit((unsigned char)ch)) {
231                                 min = 10*min + char_to_int (ch);
232                                 ch = *format++;
233                         } else if (ch == '*') {
234                                 min = va_arg (args, int);
235                                 ch = *format++;
236                                 state = DP_S_DOT;
237                         } else {
238                                 state = DP_S_DOT;
239                         }
240                         break;
241                 case DP_S_DOT:
242                         if (ch == '.') {
243                                 state = DP_S_MAX;
244                                 ch = *format++;
245                         } else { 
246                                 state = DP_S_MOD;
247                         }
248                         break;
249                 case DP_S_MAX:
250                         if (isdigit((unsigned char)ch)) {
251                                 if (max < 0)
252                                         max = 0;
253                                 max = 10*max + char_to_int (ch);
254                                 ch = *format++;
255                         } else if (ch == '*') {
256                                 max = va_arg (args, int);
257                                 ch = *format++;
258                                 state = DP_S_MOD;
259                         } else {
260                                 state = DP_S_MOD;
261                         }
262                         break;
263                 case DP_S_MOD:
264                         switch (ch) {
265                         case 'h':
266                                 cflags = DP_C_SHORT;
267                                 ch = *format++;
268                                 break;
269                         case 'l':
270                                 cflags = DP_C_LONG;
271                                 ch = *format++;
272                                 if (ch == 'l') {        /* It's a long long */
273                                         cflags = DP_C_LLONG;
274                                         ch = *format++;
275                                 }
276                                 break;
277                         case 'L':
278                                 cflags = DP_C_LDOUBLE;
279                                 ch = *format++;
280                                 break;
281                         default:
282                                 break;
283                         }
284                         state = DP_S_CONV;
285                         break;
286                 case DP_S_CONV:
287                         switch (ch) {
288                         case 'd':
289                         case 'i':
290                                 if (cflags == DP_C_SHORT) 
291                                         value = va_arg (args, int);
292                                 else if (cflags == DP_C_LONG)
293                                         value = va_arg (args, long int);
294                                 else if (cflags == DP_C_LLONG)
295                                         value = va_arg (args, LLONG);
296                                 else
297                                         value = va_arg (args, int);
298                                 fmtint (buffer, &currlen, maxlen, value, 10, min, max, flags);
299                                 break;
300                         case 'o':
301                                 flags |= DP_F_UNSIGNED;
302                                 if (cflags == DP_C_SHORT)
303                                         value = va_arg (args, unsigned int);
304                                 else if (cflags == DP_C_LONG)
305                                         value = (long)va_arg (args, unsigned long int);
306                                 else if (cflags == DP_C_LLONG)
307                                         value = (long)va_arg (args, unsigned LLONG);
308                                 else
309                                         value = (long)va_arg (args, unsigned int);
310                                 fmtint (buffer, &currlen, maxlen, value, 8, min, max, flags);
311                                 break;
312                         case 'u':
313                                 flags |= DP_F_UNSIGNED;
314                                 if (cflags == DP_C_SHORT)
315                                         value = va_arg (args, unsigned int);
316                                 else if (cflags == DP_C_LONG)
317                                         value = (long)va_arg (args, unsigned long int);
318                                 else if (cflags == DP_C_LLONG)
319                                         value = (LLONG)va_arg (args, unsigned LLONG);
320                                 else
321                                         value = (long)va_arg (args, unsigned int);
322                                 fmtint (buffer, &currlen, maxlen, value, 10, min, max, flags);
323                                 break;
324                         case 'X':
325                                 flags |= DP_F_UP;
326                         case 'x':
327                                 flags |= DP_F_UNSIGNED;
328                                 if (cflags == DP_C_SHORT)
329                                         value = va_arg (args, unsigned int);
330                                 else if (cflags == DP_C_LONG)
331                                         value = (long)va_arg (args, unsigned long int);
332                                 else if (cflags == DP_C_LLONG)
333                                         value = (LLONG)va_arg (args, unsigned LLONG);
334                                 else
335                                         value = (long)va_arg (args, unsigned int);
336                                 fmtint (buffer, &currlen, maxlen, value, 16, min, max, flags);
337                                 break;
338                         case 'f':
339                                 if (cflags == DP_C_LDOUBLE)
340                                         fvalue = va_arg (args, LDOUBLE);
341                                 else
342                                         fvalue = va_arg (args, double);
343                                 /* um, floating point? */
344                                 fmtfp (buffer, &currlen, maxlen, fvalue, min, max, flags);
345                                 break;
346                         case 'E':
347                                 flags |= DP_F_UP;
348                         case 'e':
349                                 if (cflags == DP_C_LDOUBLE)
350                                         fvalue = va_arg (args, LDOUBLE);
351                                 else
352                                         fvalue = va_arg (args, double);
353                                 fmtfp (buffer, &currlen, maxlen, fvalue, min, max, flags);
354                                 break;
355                         case 'G':
356                                 flags |= DP_F_UP;
357                         case 'g':
358                                 if (cflags == DP_C_LDOUBLE)
359                                         fvalue = va_arg (args, LDOUBLE);
360                                 else
361                                         fvalue = va_arg (args, double);
362                                 fmtfp (buffer, &currlen, maxlen, fvalue, min, max, flags);
363                                 break;
364                         case 'c':
365                                 dopr_outch (buffer, &currlen, maxlen, va_arg (args, int));
366                                 break;
367                         case 's':
368                                 strvalue = va_arg (args, char *);
369                                 if (!strvalue) strvalue = "(NULL)";
370                                 if (max == -1) {
371                                         max = strlen(strvalue);
372                                 }
373                                 if (min > 0 && max >= 0 && min > max) max = min;
374                                 fmtstr (buffer, &currlen, maxlen, strvalue, flags, min, max);
375                                 break;
376                         case 'p':
377                                 strvalue = va_arg (args, void *);
378                                 fmtint (buffer, &currlen, maxlen, (long) strvalue, 16, min, max, flags);
379                                 break;
380                         case 'n':
381                                 if (cflags == DP_C_SHORT) {
382                                         short int *num;
383                                         num = va_arg (args, short int *);
384                                         *num = currlen;
385                                 } else if (cflags == DP_C_LONG) {
386                                         long int *num;
387                                         num = va_arg (args, long int *);
388                                         *num = (long int)currlen;
389                                 } else if (cflags == DP_C_LLONG) {
390                                         LLONG *num;
391                                         num = va_arg (args, LLONG *);
392                                         *num = (LLONG)currlen;
393                                 } else {
394                                         int *num;
395                                         num = va_arg (args, int *);
396                                         *num = currlen;
397                                 }
398                                 break;
399                         case '%':
400                                 dopr_outch (buffer, &currlen, maxlen, ch);
401                                 break;
402                         case 'w':
403                                 /* not supported yet, treat as next char */
404                                 ch = *format++;
405                                 break;
406                         default:
407                                 /* Unknown, skip */
408                                 break;
409                         }
410                         ch = *format++;
411                         state = DP_S_DEFAULT;
412                         flags = cflags = min = 0;
413                         max = -1;
414                         break;
415                 case DP_S_DONE:
416                         break;
417                 default:
418                         /* hmm? */
419                         break; /* some picky compilers need this */
420                 }
421         }
422         if (maxlen != 0) {
423                 if (currlen < maxlen - 1) 
424                         buffer[currlen] = '\0';
425                 else if (maxlen > 0) 
426                         buffer[maxlen - 1] = '\0';
427         }
428         
429         return currlen;
430 }
431
432 static void fmtstr(char *buffer, size_t *currlen, size_t maxlen,
433                     char *value, int flags, int min, int max)
434 {
435         int padlen, strln;     /* amount to pad */
436         int cnt = 0;
437
438 #ifdef DEBUG_SNPRINTF
439         printf("fmtstr min=%d max=%d s=[%s]\n", min, max, value);
440 #endif
441         if (value == 0) {
442                 value = "<NULL>";
443         }
444
445         for (strln = 0; strln < max && value[strln]; ++strln); /* strlen */
446         padlen = min - strln;
447         if (padlen < 0) 
448                 padlen = 0;
449         if (flags & DP_F_MINUS) 
450                 padlen = -padlen; /* Left Justify */
451         
452         while ((padlen > 0) && (cnt < max)) {
453                 dopr_outch (buffer, currlen, maxlen, ' ');
454                 --padlen;
455                 ++cnt;
456         }
457         while (*value && (cnt < max)) {
458                 dopr_outch (buffer, currlen, maxlen, *value++);
459                 ++cnt;
460         }
461         while ((padlen < 0) && (cnt < max)) {
462                 dopr_outch (buffer, currlen, maxlen, ' ');
463                 ++padlen;
464                 ++cnt;
465         }
466 }
467
468 /* Have to handle DP_F_NUM (ie 0x and 0 alternates) */
469
470 static void fmtint(char *buffer, size_t *currlen, size_t maxlen,
471                     long value, int base, int min, int max, int flags)
472 {
473         int signvalue = 0;
474         unsigned long uvalue;
475         char convert[20];
476         int place = 0;
477         int spadlen = 0; /* amount to space pad */
478         int zpadlen = 0; /* amount to zero pad */
479         int caps = 0;
480         
481         if (max < 0)
482                 max = 0;
483         
484         uvalue = value;
485         
486         if(!(flags & DP_F_UNSIGNED)) {
487                 if( value < 0 ) {
488                         signvalue = '-';
489                         uvalue = -value;
490                 } else {
491                         if (flags & DP_F_PLUS)  /* Do a sign (+/i) */
492                                 signvalue = '+';
493                         else if (flags & DP_F_SPACE)
494                                 signvalue = ' ';
495                 }
496         }
497   
498         if (flags & DP_F_UP) caps = 1; /* Should characters be upper case? */
499
500         do {
501                 convert[place++] =
502                         (caps? "0123456789ABCDEF":"0123456789abcdef")
503                         [uvalue % (unsigned)base  ];
504                 uvalue = (uvalue / (unsigned)base );
505         } while(uvalue && (place < 20));
506         if (place == 20) place--;
507         convert[place] = 0;
508
509         zpadlen = max - place;
510         spadlen = min - MAX (max, place) - (signvalue ? 1 : 0);
511         if (zpadlen < 0) zpadlen = 0;
512         if (spadlen < 0) spadlen = 0;
513         if (flags & DP_F_ZERO) {
514                 zpadlen = MAX(zpadlen, spadlen);
515                 spadlen = 0;
516         }
517         if (flags & DP_F_MINUS) 
518                 spadlen = -spadlen; /* Left Justifty */
519
520 #ifdef DEBUG_SNPRINTF
521         printf("zpad: %d, spad: %d, min: %d, max: %d, place: %d\n",
522                zpadlen, spadlen, min, max, place);
523 #endif
524
525         /* Spaces */
526         while (spadlen > 0) {
527                 dopr_outch (buffer, currlen, maxlen, ' ');
528                 --spadlen;
529         }
530
531         /* Sign */
532         if (signvalue) 
533                 dopr_outch (buffer, currlen, maxlen, signvalue);
534
535         /* Zeros */
536         if (zpadlen > 0) {
537                 while (zpadlen > 0) {
538                         dopr_outch (buffer, currlen, maxlen, '0');
539                         --zpadlen;
540                 }
541         }
542
543         /* Digits */
544         while (place > 0) 
545                 dopr_outch (buffer, currlen, maxlen, convert[--place]);
546   
547         /* Left Justified spaces */
548         while (spadlen < 0) {
549                 dopr_outch (buffer, currlen, maxlen, ' ');
550                 ++spadlen;
551         }
552 }
553
554 static LDOUBLE abs_val(LDOUBLE value)
555 {
556         LDOUBLE result = value;
557
558         if (value < 0)
559                 result = -value;
560         
561         return result;
562 }
563
564 static LDOUBLE POW10(int exp)
565 {
566         LDOUBLE result = 1;
567         
568         while (exp) {
569                 result *= 10;
570                 exp--;
571         }
572   
573         return result;
574 }
575
576 static LLONG ROUND(LDOUBLE value)
577 {
578         LLONG intpart;
579
580         intpart = (LLONG)value;
581         value = value - intpart;
582         if (value >= 0.5) intpart++;
583         
584         return intpart;
585 }
586
587 /* a replacement for modf that doesn't need the math library. Should
588    be portable, but slow */
589 static double my_modf(double x0, double *iptr)
590 {
591         int i;
592         long l;
593         double x = x0;
594         double f = 1.0;
595
596         for (i=0;i<100;i++) {
597                 l = (long)x;
598                 if (l <= (x+1) && l >= (x-1)) break;
599                 x *= 0.1;
600                 f *= 10.0;
601         }
602
603         if (i == 100) {
604                 /* yikes! the number is beyond what we can handle. What do we do? */
605                 (*iptr) = 0;
606                 return 0;
607         }
608
609         if (i != 0) {
610                 double i2;
611                 double ret;
612
613                 ret = my_modf(x0-l*f, &i2);
614                 (*iptr) = l*f + i2;
615                 return ret;
616         } 
617
618         (*iptr) = l;
619         return x - (*iptr);
620 }
621
622
623 static void fmtfp (char *buffer, size_t *currlen, size_t maxlen,
624                    LDOUBLE fvalue, int min, int max, int flags)
625 {
626         int signvalue = 0;
627         double ufvalue;
628         char iconvert[311];
629         char fconvert[311];
630         int iplace = 0;
631         int fplace = 0;
632         int padlen = 0; /* amount to pad */
633         int zpadlen = 0; 
634         int caps = 0;
635         int index;
636         double intpart;
637         double fracpart;
638         double temp;
639   
640         /* 
641          * AIX manpage says the default is 0, but Solaris says the default
642          * is 6, and sprintf on AIX defaults to 6
643          */
644         if (max < 0)
645                 max = 6;
646
647         ufvalue = abs_val (fvalue);
648
649         if (fvalue < 0) {
650                 signvalue = '-';
651         } else {
652                 if (flags & DP_F_PLUS) { /* Do a sign (+/i) */
653                         signvalue = '+';
654                 } else {
655                         if (flags & DP_F_SPACE)
656                                 signvalue = ' ';
657                 }
658         }
659
660 #if 0
661         if (flags & DP_F_UP) caps = 1; /* Should characters be upper case? */
662 #endif
663
664 #if 0
665          if (max == 0) ufvalue += 0.5; /* if max = 0 we must round */
666 #endif
667
668         /* 
669          * Sorry, we only support 16 digits past the decimal because of our 
670          * conversion method
671          */
672         if (max > 16)
673                 max = 16;
674
675         /* We "cheat" by converting the fractional part to integer by
676          * multiplying by a factor of 10
677          */
678
679         temp = ufvalue;
680         my_modf(temp, &intpart);
681
682         fracpart = ROUND((POW10(max)) * (ufvalue - intpart));
683         
684         if (fracpart >= POW10(max)) {
685                 intpart++;
686                 fracpart -= POW10(max);
687         }
688
689
690         /* Convert integer part */
691         do {
692                 temp = intpart*0.1;
693                 my_modf(temp, &intpart);
694                 index = (int) ((temp -intpart +0.05)* 10.0);
695                 /* index = (int) (((double)(temp*0.1) -intpart +0.05) *10.0); */
696                 /* printf ("%llf, %f, %x\n", temp, intpart, index); */
697                 iconvert[iplace++] =
698                         (caps? "0123456789ABCDEF":"0123456789abcdef")[index];
699         } while (intpart && (iplace < 311));
700         if (iplace == 311) iplace--;
701         iconvert[iplace] = 0;
702
703         /* Convert fractional part */
704         if (fracpart)
705         {
706                 do {
707                         temp = fracpart*0.1;
708                         my_modf(temp, &fracpart);
709                         index = (int) ((temp -fracpart +0.05)* 10.0);
710                         /* index = (int) ((((temp/10) -fracpart) +0.05) *10); */
711                         /* printf ("%lf, %lf, %ld\n", temp, fracpart, index); */
712                         fconvert[fplace++] =
713                         (caps? "0123456789ABCDEF":"0123456789abcdef")[index];
714                 } while(fracpart && (fplace < 311));
715                 if (fplace == 311) fplace--;
716         }
717         fconvert[fplace] = 0;
718   
719         /* -1 for decimal point, another -1 if we are printing a sign */
720         padlen = min - iplace - max - 1 - ((signvalue) ? 1 : 0); 
721         zpadlen = max - fplace;
722         if (zpadlen < 0) zpadlen = 0;
723         if (padlen < 0) 
724                 padlen = 0;
725         if (flags & DP_F_MINUS) 
726                 padlen = -padlen; /* Left Justifty */
727         
728         if ((flags & DP_F_ZERO) && (padlen > 0)) {
729                 if (signvalue) {
730                         dopr_outch (buffer, currlen, maxlen, signvalue);
731                         --padlen;
732                         signvalue = 0;
733                 }
734                 while (padlen > 0) {
735                         dopr_outch (buffer, currlen, maxlen, '0');
736                         --padlen;
737                 }
738         }
739         while (padlen > 0) {
740                 dopr_outch (buffer, currlen, maxlen, ' ');
741                 --padlen;
742         }
743         if (signvalue) 
744                 dopr_outch (buffer, currlen, maxlen, signvalue);
745         
746         while (iplace > 0) 
747                 dopr_outch (buffer, currlen, maxlen, iconvert[--iplace]);
748
749 #ifdef DEBUG_SNPRINTF
750         printf("fmtfp: fplace=%d zpadlen=%d\n", fplace, zpadlen);
751 #endif
752
753         /*
754          * Decimal point.  This should probably use locale to find the correct
755          * char to print out.
756          */
757         if (max > 0) {
758                 dopr_outch (buffer, currlen, maxlen, '.');
759                 
760                 while (zpadlen > 0) {
761                         dopr_outch (buffer, currlen, maxlen, '0');
762                         --zpadlen;
763                 }
764
765                 while (fplace > 0) 
766                         dopr_outch (buffer, currlen, maxlen, fconvert[--fplace]);
767         }
768
769         while (padlen < 0) {
770                 dopr_outch (buffer, currlen, maxlen, ' ');
771                 ++padlen;
772         }
773 }
774
775 static void dopr_outch(char *buffer, size_t *currlen, size_t maxlen, char c)
776 {
777         if (*currlen < maxlen) {
778                 buffer[(*currlen)] = c;
779         }
780         (*currlen)++;
781 }
782
783 /* yes this really must be a ||. Don't muck with this (tridge) */
784 #if !defined(HAVE_VSNPRINTF) || !defined(HAVE_C99_VSNPRINTF)
785  int vsnprintf (char *str, size_t count, const char *fmt, va_list args)
786 {
787         return dopr(str, count, fmt, args);
788 }
789 #endif
790
791 /* yes this really must be a ||. Don't muck wiith this (tridge)
792  *
793  * The logic for these two is that we need our own definition if the
794  * OS *either* has no definition of *sprintf, or if it does have one
795  * that doesn't work properly according to the autoconf test.  Perhaps
796  * these should really be smb_snprintf to avoid conflicts with buggy
797  * linkers? -- mbp
798  */
799 #if !defined(HAVE_SNPRINTF) || !defined(HAVE_C99_SNPRINTF)
800  int snprintf(char *str,size_t count,const char *fmt,...)
801 {
802         size_t ret;
803         va_list ap;
804     
805         va_start(ap, fmt);
806         ret = vsnprintf(str, count, fmt, ap);
807         va_end(ap);
808         return ret;
809 }
810 #endif
811
812 #endif 
813
814 #ifndef HAVE_VASPRINTF
815  int vasprintf(char **ptr, const char *format, va_list ap)
816 {
817         int ret;
818         va_list ap2;
819
820         VA_COPY(ap2, ap);
821         
822         ret = vsnprintf(NULL, 0, format, ap2);
823         if (ret <= 0) return ret;
824
825         (*ptr) = (char *)malloc(ret+1);
826         if (!*ptr) return -1;
827
828         VA_COPY(ap2, ap);
829
830         ret = vsnprintf(*ptr, ret+1, format, ap2);
831
832         return ret;
833 }
834 #endif
835
836
837 #ifndef HAVE_ASPRINTF
838  int asprintf(char **ptr, const char *format, ...)
839 {
840         va_list ap;
841         int ret;
842         
843         *ptr = NULL;
844         va_start(ap, format);
845         ret = vasprintf(ptr, format, ap);
846         va_end(ap);
847
848         return ret;
849 }
850 #endif
851
852 #ifdef TEST_SNPRINTF
853
854  int sprintf(char *str,const char *fmt,...);
855
856  int main (void)
857 {
858         char buf1[1024];
859         char buf2[1024];
860         char *buf3;
861         char *fp_fmt[] = {
862                 "%1.1f",
863                 "%-1.5f",
864                 "%1.5f",
865                 "%123.9f",
866                 "%10.5f",
867                 "% 10.5f",
868                 "%+22.9f",
869                 "%+4.9f",
870                 "%01.3f",
871                 "%4f",
872                 "%3.1f",
873                 "%3.2f",
874                 "%.0f",
875                 "%f",
876                 "-16.16f",
877                 NULL
878         };
879         double fp_nums[] = { 6442452944.1234, -1.5, 134.21, 91340.2, 341.1234, 0203.9, 0.96, 0.996, 
880                              0.9996, 1.996, 4.136, 5.030201, 0};
881         char *int_fmt[] = {
882                 "%-1.5d",
883                 "%1.5d",
884                 "%123.9d",
885                 "%5.5d",
886                 "%10.5d",
887                 "% 10.5d",
888                 "%+22.33d",
889                 "%01.3d",
890                 "%4d",
891                 "%d",
892                 NULL
893         };
894         long int_nums[] = { -1, 134, 91340, 341, 0203, 0};
895         char *str_fmt[] = {
896                 "10.5s",
897                 "5.10s",
898                 "10.1s",
899                 "0.10s",
900                 "10.0s",
901                 "1.10s",
902                 "%s",
903                 "%.1s",
904                 "%.10s",
905                 "%10s",
906                 NULL
907         };
908         char *str_vals[] = {"hello", "a", "", "a longer string", NULL};
909         int x, y;
910         int fail = 0;
911         int num = 0;
912
913         printf ("Testing snprintf format codes against system sprintf...\n");
914
915         for (x = 0; fp_fmt[x] ; x++) {
916                 for (y = 0; fp_nums[y] != 0 ; y++) {
917                         int l1 = snprintf(NULL, 0, fp_fmt[x], fp_nums[y]);
918                         int l2 = snprintf(buf1, sizeof(buf1), fp_fmt[x], fp_nums[y]);
919                         sprintf (buf2, fp_fmt[x], fp_nums[y]);
920                         if (strcmp (buf1, buf2)) {
921                                 printf("snprintf doesn't match Format: %s\n\tsnprintf = [%s]\n\t sprintf = [%s]\n", 
922                                        fp_fmt[x], buf1, buf2);
923                                 fail++;
924                         }
925                         if (l1 != l2) {
926                                 printf("snprintf l1 != l2 (%d %d) %s\n", l1, l2, fp_fmt[x]);
927                                 fail++;
928                         }
929                         num++;
930                 }
931         }
932
933         for (x = 0; int_fmt[x] ; x++) {
934                 for (y = 0; int_nums[y] != 0 ; y++) {
935                         int l1 = snprintf(NULL, 0, int_fmt[x], int_nums[y]);
936                         int l2 = snprintf(buf1, sizeof(buf1), int_fmt[x], int_nums[y]);
937                         sprintf (buf2, int_fmt[x], int_nums[y]);
938                         if (strcmp (buf1, buf2)) {
939                                 printf("snprintf doesn't match Format: %s\n\tsnprintf = [%s]\n\t sprintf = [%s]\n", 
940                                        int_fmt[x], buf1, buf2);
941                                 fail++;
942                         }
943                         if (l1 != l2) {
944                                 printf("snprintf l1 != l2 (%d %d) %s\n", l1, l2, int_fmt[x]);
945                                 fail++;
946                         }
947                         num++;
948                 }
949         }
950
951         for (x = 0; str_fmt[x] ; x++) {
952                 for (y = 0; str_vals[y] != 0 ; y++) {
953                         int l1 = snprintf(NULL, 0, str_fmt[x], str_vals[y]);
954                         int l2 = snprintf(buf1, sizeof(buf1), str_fmt[x], str_vals[y]);
955                         sprintf (buf2, str_fmt[x], str_vals[y]);
956                         if (strcmp (buf1, buf2)) {
957                                 printf("snprintf doesn't match Format: %s\n\tsnprintf = [%s]\n\t sprintf = [%s]\n", 
958                                        str_fmt[x], buf1, buf2);
959                                 fail++;
960                         }
961                         if (l1 != l2) {
962                                 printf("snprintf l1 != l2 (%d %d) %s\n", l1, l2, str_fmt[x]);
963                                 fail++;
964                         }
965                         num++;
966                 }
967         }
968
969 #define BUFSZ 2048
970
971         if ((buf3 = malloc(BUFSZ)) == NULL) {
972                 fail++;
973         } else {
974                 num++;
975                 memset(buf3, 'a', BUFSZ);
976                 snprintf(buf1, sizeof(buf1), "%.*s", 1, buf3);
977                 if (strcmp(buf1, "a") != 0) {
978                         printf("length limit buf1 '%s' expected 'a'\n", buf1);
979                         fail++;
980                 }
981         }
982
983         printf ("%d tests failed out of %d.\n", fail, num);
984
985         printf("seeing how many digits we support\n");
986         {
987                 double v0 = 0.12345678901234567890123456789012345678901;
988                 for (x=0; x<100; x++) {
989                         double p = pow(10, x); 
990                         double r = v0*p;
991                         snprintf(buf1, sizeof(buf1), "%1.1f", r);
992                         sprintf(buf2,                "%1.1f", r);
993                         if (strcmp(buf1, buf2)) {
994                                 printf("we seem to support %d digits\n", x-1);
995                                 break;
996                         }
997                 }
998         }
999
1000         return 0;
1001 }
1002 #endif /* SNPRINTF_TEST */