2 * Copyright Patrick Powell 1995
4 * This code is based on code written by Patrick Powell
5 * (papowell@astart.com) It may be used for any purpose as long
6 * as this notice remains intact on all source code distributions.
8 * Adapted for Bacula -- note there were lots of bugs in
9 * the original code: %lld and %s were seriously broken, and
10 * with FP turned off %f seg faulted.
12 * Kern Sibbald, November MMV
17 Bacula® - The Network Backup Solution
19 Copyright (C) 2005-2006 Free Software Foundation Europe e.V.
21 The main author of Bacula is Kern Sibbald, with contributions from
22 many others, a complete list can be found in the file AUTHORS.
23 This program is Free Software; you can redistribute it and/or
24 modify it under the terms of version two of the GNU General Public
25 License as published by the Free Software Foundation plus additions
26 that are listed in the file LICENSE.
28 This program is distributed in the hope that it will be useful, but
29 WITHOUT ANY WARRANTY; without even the implied warranty of
30 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
31 General Public License for more details.
33 You should have received a copy of the GNU General Public License
34 along with this program; if not, write to the Free Software
35 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
38 Bacula® is a registered trademark of John Walker.
39 The licensor of Bacula is the Free Software Foundation Europe
40 (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
41 Switzerland, email:ftf@fsfeurope.org.
47 #define FP_OUTPUT 1 /* Bacula uses floating point */
48 /* Define the following if you want all the features of
49 * normal printf, but with all the security problems.
50 * For Bacula we turn this off, and it silently ignores
51 * formats that could pose a security problem.
53 #undef SECURITY_PROBLEM
57 #ifdef HAVE_LONG_DOUBLE
58 #define LDOUBLE long double
60 #define LDOUBLE double
63 int bvsnprintf(char *buffer, int32_t maxlen, const char *format, va_list args);
64 static int32_t fmtstr(char *buffer, int32_t currlen, int32_t maxlen,
65 char *value, int flags, int min, int max);
66 static int32_t fmtint(char *buffer, int32_t currlen, int32_t maxlen,
67 int64_t value, int base, int min, int max, int flags);
73 static int32_t fmtfp(char *buffer, int32_t currlen, int32_t maxlen,
74 LDOUBLE fvalue, int min, int max, int flags);
76 #define fmtfp(b, c, m, f, min, max, fl) currlen
79 #define outch(c) {int len=currlen; if (currlen++ < maxlen) { buffer[len] = (c);}}
82 /* format read states */
83 #define DP_S_DEFAULT 0
92 /* format flags - Bits */
93 #define DP_F_MINUS (1 << 0)
94 #define DP_F_PLUS (1 << 1)
95 #define DP_F_SPACE (1 << 2)
96 #define DP_F_NUM (1 << 3)
97 #define DP_F_ZERO (1 << 4)
98 #define DP_F_UP (1 << 5)
99 #define DP_F_UNSIGNED (1 << 6)
100 #define DP_F_DOT (1 << 7)
102 /* Conversion Flags */
105 #define DP_C_LDOUBLE 3
108 #define char_to_int(p) ((p)- '0')
110 #define MAX(p,q) (((p) >= (q)) ? (p) : (q))
113 You might ask why does Bacula have it's own printf routine? Well,
114 There are two reasons: 1. Here (as opposed to library routines), we
115 define %d and %ld to be 32 bit; %lld and %q to be 64 bit. 2. We
116 disable %n for security reasons.
119 int bsnprintf(char *str, int32_t size, const char *fmt, ...)
124 va_start(arg_ptr, fmt);
125 len = bvsnprintf(str, size, fmt, arg_ptr);
131 int bvsnprintf(char *buffer, int32_t maxlen, const char *format, va_list args)
147 state = DP_S_DEFAULT;
148 currlen = flags = cflags = min = 0;
153 while (state != DP_S_DONE) {
154 if ((ch == '\0') || (currlen >= maxlen))
194 if (isdigit((unsigned char)ch)) {
195 min = 10 * min + char_to_int(ch);
197 } else if (ch == '*') {
198 min = va_arg(args, int);
213 if (isdigit((unsigned char)ch)) {
216 max = 10 * max + char_to_int(ch);
218 } else if (ch == '*') {
219 max = va_arg(args, int);
234 if (ch == 'l') { /* It's a long long */
240 cflags = DP_C_LDOUBLE;
243 case 'q': /* same as long long */
256 if (cflags == DP_C_INT16) {
257 value = va_arg(args, int32_t);
258 } else if (cflags == DP_C_INT32) {
259 value = va_arg(args, int32_t);
260 } else if (cflags == DP_C_INT64) {
261 value = va_arg(args, int64_t);
263 value = va_arg(args, int);
265 currlen = fmtint(buffer, currlen, maxlen, value, 10, min, max, flags);
273 } else if (ch == 'x') {
275 } else if (ch == 'X') {
281 flags |= DP_F_UNSIGNED;
282 if (cflags == DP_C_INT16) {
283 value = va_arg(args, uint32_t);
284 } else if (cflags == DP_C_INT32) {
285 value = va_arg(args, uint32_t);
286 } else if (cflags == DP_C_INT64) {
287 value = va_arg(args, uint64_t);
289 value = va_arg(args, unsigned int);
291 currlen = fmtint(buffer, currlen, maxlen, value, base, min, max, flags);
294 if (cflags == DP_C_LDOUBLE) {
295 fvalue = va_arg(args, LDOUBLE);
297 fvalue = va_arg(args, double);
299 currlen = fmtfp(buffer, currlen, maxlen, fvalue, min, max, flags);
304 if (cflags == DP_C_LDOUBLE) {
305 fvalue = va_arg(args, LDOUBLE);
307 fvalue = va_arg(args, double);
309 currlen = fmtfp(buffer, currlen, maxlen, fvalue, min, max, flags);
314 if (cflags == DP_C_LDOUBLE) {
315 fvalue = va_arg(args, LDOUBLE);
317 fvalue = va_arg(args, double);
319 currlen = fmtfp(buffer, currlen, maxlen, fvalue, min, max, flags);
322 outch(va_arg(args, int));
325 strvalue = va_arg(args, char *);
326 currlen = fmtstr(buffer, currlen, maxlen, strvalue, flags, min, max);
329 flags |= DP_F_UNSIGNED;
330 strvalue = va_arg(args, char *);
331 currlen = fmtint(buffer, currlen, maxlen, (long)strvalue, 16, min, max, flags);
334 if (cflags == DP_C_INT16) {
336 num = va_arg(args, int16_t *);
337 #ifdef SECURITY_PROBLEM
340 } else if (cflags == DP_C_INT32) {
342 num = va_arg(args, int32_t *);
343 #ifdef SECURITY_PROBLEM
344 *num = (int32_t)currlen;
346 } else if (cflags == DP_C_INT64) {
348 num = va_arg(args, int64_t *);
349 #ifdef SECURITY_PROBLEM
350 *num = (int64_t)currlen;
354 num = va_arg(args, int32_t *);
355 #ifdef SECURITY_PROBLEM
356 *num = (int32_t)currlen;
364 /* not supported yet, treat as next char */
372 state = DP_S_DEFAULT;
373 flags = cflags = min = 0;
380 break; /* some picky compilers need this */
383 if (currlen < maxlen - 1) {
384 buffer[currlen] = '\0';
386 buffer[maxlen - 1] = '\0';
391 static int32_t fmtstr(char *buffer, int32_t currlen, int32_t maxlen,
392 char *value, int flags, int min, int max)
394 int padlen, strln; /* amount to pad */
401 if (flags & DP_F_DOT && max < 0) { /* Max not specified */
403 } else if (max < 0) {
406 strln = strlen(value);
408 strln = max; /* truncate to max */
410 padlen = min - strln;
414 if (flags & DP_F_MINUS) {
415 padlen = -padlen; /* Left Justify */
422 while (*value && (cnt < max)) {
433 /* Have to handle DP_F_NUM (ie 0x and 0 alternates) */
435 static int32_t fmtint(char *buffer, int32_t currlen, int32_t maxlen,
436 int64_t value, int base, int min, int max, int flags)
442 int spadlen = 0; /* amount to space pad */
443 int zpadlen = 0; /* amount to zero pad */
452 if (!(flags & DP_F_UNSIGNED)) {
456 } else if (flags & DP_F_PLUS) { /* Do a sign (+/i) */
458 } else if (flags & DP_F_SPACE) {
463 if (flags & DP_F_UP) {
464 caps = 1; /* Should characters be upper case? */
468 convert[place++] = (caps ? "0123456789ABCDEF" : "0123456789abcdef")
469 [uvalue % (unsigned)base];
470 uvalue = (uvalue / (unsigned)base);
471 } while (uvalue && (place < 20));
477 zpadlen = max - place;
478 spadlen = min - MAX(max, place) - (signvalue ? 1 : 0);
483 if (flags & DP_F_ZERO) {
484 zpadlen = MAX(zpadlen, spadlen);
487 if (flags & DP_F_MINUS)
488 spadlen = -spadlen; /* Left Justifty */
490 #ifdef DEBUG_SNPRINTF
491 printf("zpad: %d, spad: %d, min: %d, max: %d, place: %d\n",
492 zpadlen, spadlen, min, max, place);
496 while (spadlen > 0) {
508 while (zpadlen > 0) {
516 outch(convert[--place]);
519 /* Left Justified spaces */
520 while (spadlen < 0) {
529 static LDOUBLE abs_val(LDOUBLE value)
531 LDOUBLE result = value;
539 static LDOUBLE pow10(int exp)
551 static long round(LDOUBLE value)
555 intpart = (long)value;
556 value = value - intpart;
563 static int32_t fmtfp(char *buffer, int32_t currlen, int32_t maxlen,
564 LDOUBLE fvalue, int min, int max, int flags)
577 extern char *fcvt(double value, int ndigit, int *decpt, int *sign);
581 int padlen = 0; /* amount to pad */
588 * AIX manpage says the default is 0, but Solaris says the default
589 * is 6, and sprintf on AIX defaults to 6
594 ufvalue = abs_val(fvalue);
598 else if (flags & DP_F_PLUS) /* Do a sign (+/i) */
600 else if (flags & DP_F_SPACE)
605 caps = 1; /* Should characters be upper case? */
609 intpart = (long)ufvalue;
612 * Sorry, we only support 9 digits past the decimal because of our
618 /* We "cheat" by converting the fractional part to integer by
619 * multiplying by a factor of 10
621 fracpart = round((pow10(max)) * (ufvalue - intpart));
623 if (fracpart >= pow10(max)) {
625 fracpart -= (int64_t)pow10(max);
627 #ifdef DEBUG_SNPRINTF
628 printf("fmtfp: %g %d.%d min=%d max=%d\n",
629 (double)fvalue, intpart, fracpart, min, max);
632 /* Convert integer part */
635 (caps ? "0123456789ABCDEF" : "0123456789abcdef")[intpart % 10];
636 intpart = (intpart / 10);
637 } while (intpart && (iplace < 20));
640 iconvert[iplace] = 0;
642 /* Convert fractional part */
645 (caps ? "0123456789ABCDEF" : "0123456789abcdef")[fracpart % 10];
646 fracpart = (fracpart / 10);
647 } while (fracpart && (fplace < 20));
650 fconvert[fplace] = 0;
651 #else /* use fcvt() */
655 result = fcvtl(ufvalue, max, &dec_pt, &sig);
657 result = fcvt(ufvalue, max, &dec_pt, &sig);
660 r_length = strlen(result);
663 * Fix broken fcvt implementation returns..
672 if (r_length < dec_pt)
683 fconvert[fplace++] = result[--r_length];
685 while ((dec_pt < 0) && (fplace < max)) {
686 fconvert[fplace++] = '0';
693 for (c = dec_pt; c; iconvert[iplace++] = result[--c]);
694 iconvert[iplace] = '\0';
699 for (c = (r_length - dec_pt); c; fconvert[fplace++] = result[--c]);
701 #endif /* HAVE_FCVT */
703 /* -1 for decimal point, another -1 if we are printing a sign */
704 padlen = min - iplace - max - 1 - ((signvalue) ? 1 : 0);
705 zpadlen = max - fplace;
712 if (flags & DP_F_MINUS) {
713 padlen = -padlen; /* Left Justifty */
716 if ((flags & DP_F_ZERO) && (padlen > 0)) {
736 outch(iconvert[--iplace]);
740 #ifdef DEBUG_SNPRINTF
741 printf("fmtfp: fplace=%d zpadlen=%d\n", fplace, zpadlen);
745 * Decimal point. This should probably use locale to find the correct
751 outch(fconvert[--fplace]);
755 while (zpadlen > 0) {
766 #endif /* FP_OUTPUT */
772 #define LONG_STRING 1024
776 char buf1[LONG_STRING];
777 char buf2[LONG_STRING];
796 double fp_nums[] = { -1.5, 134.21, 91340.2, 341.1234, 0203.9, 0.96, 0.996,
797 0.9996, 1.996, 4.136, 6442452944.1234, 0
821 long int_nums[] = { -1, 134, 91340, 341, 0203, 0 };
835 int64_t ll_nums[] = { -1976, 789134567890LL, 91340, 34123, 0203, 0 };
853 char *s_nums[] = { "abc", "def", "ghi", "123", "4567", "a", "bb", "ccccccc", NULL};
860 printf("Testing snprintf format codes against system sprintf...\n");
863 for (x = 0; fp_fmt[x] != NULL; x++)
864 for (y = 0; fp_nums[y] != 0; y++) {
865 bsnprintf(buf1, sizeof(buf1), fp_fmt[x], fp_nums[y]);
866 sprintf(buf2, fp_fmt[x], fp_nums[y]);
867 if (strcmp(buf1, buf2)) {
869 ("snprintf doesn't match Format: %s\n\tsnprintf = %s\n\tsprintf = %s\n",
870 fp_fmt[x], buf1, buf2);
877 for (x = 0; int_fmt[x] != NULL; x++)
878 for (y = 0; int_nums[y] != 0; y++) {
880 bcount = bsnprintf(buf1, sizeof(buf1), int_fmt[x], int_nums[y]);
881 printf("%s\n", buf1);
882 pcount = sprintf(buf2, int_fmt[x], int_nums[y]);
883 if (bcount != pcount) {
884 printf("bsnprintf count %d doesn't match sprintf count %d\n",
887 if (strcmp(buf1, buf2)) {
889 ("bsnprintf doesn't match Format: %s\n\tsnprintf = %s\n\tsprintf = %s\n",
890 int_fmt[x], buf1, buf2);
896 for (x = 0; ll_fmt[x] != NULL; x++) {
897 for (y = 0; ll_nums[y] != 0; y++) {
899 bcount = bsnprintf(buf1, sizeof(buf1), ll_fmt[x], ll_nums[y]);
900 printf("%s\n", buf1);
901 pcount = sprintf(buf2, ll_fmt[x], ll_nums[y]);
902 if (bcount != pcount) {
903 printf("bsnprintf count %d doesn't match sprintf count %d\n",
906 if (strcmp(buf1, buf2)) {
908 ("bsnprintf doesn't match Format: %s\n\tsnprintf = %s\n\tsprintf = %s\n",
909 ll_fmt[x], buf1, buf2);
916 for (x = 0; s_fmt[x] != NULL; x++) {
917 for (y = 0; s_nums[y] != 0; y++) {
919 bcount = bsnprintf(buf1, sizeof(buf1), s_fmt[x], s_nums[y]);
920 printf("%s\n", buf1);
921 pcount = sprintf(buf2, s_fmt[x], s_nums[y]);
922 if (bcount != pcount) {
923 printf("bsnprintf count %d doesn't match sprintf count %d\n",
926 if (strcmp(buf1, buf2)) {
928 ("bsnprintf doesn't match Format: %s\n\tsnprintf = %s\n\tsprintf = %s\n",
929 s_fmt[x], buf1, buf2);
937 printf("%d tests failed out of %d.\n", fail, num);
939 #endif /* TEST_PROGRAM */
941 #endif /* USE_BSNPRINTF */