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 strvalue = va_arg(args, char *);
330 currlen = fmtint(buffer, currlen, maxlen, (long)strvalue, 16, min, max, flags);
333 if (cflags == DP_C_INT16) {
335 num = va_arg(args, int16_t *);
336 #ifdef SECURITY_PROBLEM
339 } else if (cflags == DP_C_INT32) {
341 num = va_arg(args, int32_t *);
342 #ifdef SECURITY_PROBLEM
343 *num = (int32_t)currlen;
345 } else if (cflags == DP_C_INT64) {
347 num = va_arg(args, int64_t *);
348 #ifdef SECURITY_PROBLEM
349 *num = (int64_t)currlen;
353 num = va_arg(args, int32_t *);
354 #ifdef SECURITY_PROBLEM
355 *num = (int32_t)currlen;
363 /* not supported yet, treat as next char */
371 state = DP_S_DEFAULT;
372 flags = cflags = min = 0;
379 break; /* some picky compilers need this */
382 if (currlen < maxlen - 1) {
383 buffer[currlen] = '\0';
385 buffer[maxlen - 1] = '\0';
390 static int32_t fmtstr(char *buffer, int32_t currlen, int32_t maxlen,
391 char *value, int flags, int min, int max)
393 int padlen, strln; /* amount to pad */
400 if (flags & DP_F_DOT && max < 0) { /* Max not specified */
402 } else if (max < 0) {
405 strln = strlen(value);
407 strln = max; /* truncate to max */
409 padlen = min - strln;
413 if (flags & DP_F_MINUS) {
414 padlen = -padlen; /* Left Justify */
421 while (*value && (cnt < max)) {
432 /* Have to handle DP_F_NUM (ie 0x and 0 alternates) */
434 static int32_t fmtint(char *buffer, int32_t currlen, int32_t maxlen,
435 int64_t value, int base, int min, int max, int flags)
441 int spadlen = 0; /* amount to space pad */
442 int zpadlen = 0; /* amount to zero pad */
451 if (!(flags & DP_F_UNSIGNED)) {
455 } else if (flags & DP_F_PLUS) { /* Do a sign (+/i) */
457 } else if (flags & DP_F_SPACE) {
462 if (flags & DP_F_UP) {
463 caps = 1; /* Should characters be upper case? */
467 convert[place++] = (caps ? "0123456789ABCDEF" : "0123456789abcdef")
468 [uvalue % (unsigned)base];
469 uvalue = (uvalue / (unsigned)base);
470 } while (uvalue && (place < 20));
476 zpadlen = max - place;
477 spadlen = min - MAX(max, place) - (signvalue ? 1 : 0);
482 if (flags & DP_F_ZERO) {
483 zpadlen = MAX(zpadlen, spadlen);
486 if (flags & DP_F_MINUS)
487 spadlen = -spadlen; /* Left Justifty */
489 #ifdef DEBUG_SNPRINTF
490 printf("zpad: %d, spad: %d, min: %d, max: %d, place: %d\n",
491 zpadlen, spadlen, min, max, place);
495 while (spadlen > 0) {
507 while (zpadlen > 0) {
515 outch(convert[--place]);
518 /* Left Justified spaces */
519 while (spadlen < 0) {
528 static LDOUBLE abs_val(LDOUBLE value)
530 LDOUBLE result = value;
538 static LDOUBLE pow10(int exp)
550 static long round(LDOUBLE value)
554 intpart = (long)value;
555 value = value - intpart;
562 static int32_t fmtfp(char *buffer, int32_t currlen, int32_t maxlen,
563 LDOUBLE fvalue, int min, int max, int flags)
576 extern char *fcvt(double value, int ndigit, int *decpt, int *sign);
580 int padlen = 0; /* amount to pad */
587 * AIX manpage says the default is 0, but Solaris says the default
588 * is 6, and sprintf on AIX defaults to 6
593 ufvalue = abs_val(fvalue);
597 else if (flags & DP_F_PLUS) /* Do a sign (+/i) */
599 else if (flags & DP_F_SPACE)
604 caps = 1; /* Should characters be upper case? */
608 intpart = (long)ufvalue;
611 * Sorry, we only support 9 digits past the decimal because of our
617 /* We "cheat" by converting the fractional part to integer by
618 * multiplying by a factor of 10
620 fracpart = round((pow10(max)) * (ufvalue - intpart));
622 if (fracpart >= pow10(max)) {
624 fracpart -= (int64_t)pow10(max);
626 #ifdef DEBUG_SNPRINTF
627 printf("fmtfp: %g %d.%d min=%d max=%d\n",
628 (double)fvalue, intpart, fracpart, min, max);
631 /* Convert integer part */
634 (caps ? "0123456789ABCDEF" : "0123456789abcdef")[intpart % 10];
635 intpart = (intpart / 10);
636 } while (intpart && (iplace < 20));
639 iconvert[iplace] = 0;
641 /* Convert fractional part */
644 (caps ? "0123456789ABCDEF" : "0123456789abcdef")[fracpart % 10];
645 fracpart = (fracpart / 10);
646 } while (fracpart && (fplace < 20));
649 fconvert[fplace] = 0;
650 #else /* use fcvt() */
654 result = fcvtl(ufvalue, max, &dec_pt, &sig);
656 result = fcvt(ufvalue, max, &dec_pt, &sig);
659 r_length = strlen(result);
662 * Fix broken fcvt implementation returns..
671 if (r_length < dec_pt)
682 fconvert[fplace++] = result[--r_length];
684 while ((dec_pt < 0) && (fplace < max)) {
685 fconvert[fplace++] = '0';
692 for (c = dec_pt; c; iconvert[iplace++] = result[--c]);
693 iconvert[iplace] = '\0';
698 for (c = (r_length - dec_pt); c; fconvert[fplace++] = result[--c]);
700 #endif /* HAVE_FCVT */
702 /* -1 for decimal point, another -1 if we are printing a sign */
703 padlen = min - iplace - max - 1 - ((signvalue) ? 1 : 0);
704 zpadlen = max - fplace;
711 if (flags & DP_F_MINUS) {
712 padlen = -padlen; /* Left Justifty */
715 if ((flags & DP_F_ZERO) && (padlen > 0)) {
735 outch(iconvert[--iplace]);
739 #ifdef DEBUG_SNPRINTF
740 printf("fmtfp: fplace=%d zpadlen=%d\n", fplace, zpadlen);
744 * Decimal point. This should probably use locale to find the correct
750 outch(fconvert[--fplace]);
754 while (zpadlen > 0) {
765 #endif /* FP_OUTPUT */
771 #define LONG_STRING 1024
775 char buf1[LONG_STRING];
776 char buf2[LONG_STRING];
795 double fp_nums[] = { -1.5, 134.21, 91340.2, 341.1234, 0203.9, 0.96, 0.996,
796 0.9996, 1.996, 4.136, 6442452944.1234, 0
820 long int_nums[] = { -1, 134, 91340, 341, 0203, 0 };
834 int64_t ll_nums[] = { -1976, 789134567890LL, 91340, 34123, 0203, 0 };
852 char *s_nums[] = { "abc", "def", "ghi", "123", "4567", "a", "bb", "ccccccc", NULL};
859 printf("Testing snprintf format codes against system sprintf...\n");
862 for (x = 0; fp_fmt[x] != NULL; x++)
863 for (y = 0; fp_nums[y] != 0; y++) {
864 bsnprintf(buf1, sizeof(buf1), fp_fmt[x], fp_nums[y]);
865 sprintf(buf2, fp_fmt[x], fp_nums[y]);
866 if (strcmp(buf1, buf2)) {
868 ("snprintf doesn't match Format: %s\n\tsnprintf = %s\n\tsprintf = %s\n",
869 fp_fmt[x], buf1, buf2);
876 for (x = 0; int_fmt[x] != NULL; x++)
877 for (y = 0; int_nums[y] != 0; y++) {
879 bcount = bsnprintf(buf1, sizeof(buf1), int_fmt[x], int_nums[y]);
880 printf("%s\n", buf1);
881 pcount = sprintf(buf2, int_fmt[x], int_nums[y]);
882 if (bcount != pcount) {
883 printf("bsnprintf count %d doesn't match sprintf count %d\n",
886 if (strcmp(buf1, buf2)) {
888 ("bsnprintf doesn't match Format: %s\n\tsnprintf = %s\n\tsprintf = %s\n",
889 int_fmt[x], buf1, buf2);
895 for (x = 0; ll_fmt[x] != NULL; x++) {
896 for (y = 0; ll_nums[y] != 0; y++) {
898 bcount = bsnprintf(buf1, sizeof(buf1), ll_fmt[x], ll_nums[y]);
899 printf("%s\n", buf1);
900 pcount = sprintf(buf2, ll_fmt[x], ll_nums[y]);
901 if (bcount != pcount) {
902 printf("bsnprintf count %d doesn't match sprintf count %d\n",
905 if (strcmp(buf1, buf2)) {
907 ("bsnprintf doesn't match Format: %s\n\tsnprintf = %s\n\tsprintf = %s\n",
908 ll_fmt[x], buf1, buf2);
915 for (x = 0; s_fmt[x] != NULL; x++) {
916 for (y = 0; s_nums[y] != 0; y++) {
918 bcount = bsnprintf(buf1, sizeof(buf1), s_fmt[x], s_nums[y]);
919 printf("%s\n", buf1);
920 pcount = sprintf(buf2, s_fmt[x], s_nums[y]);
921 if (bcount != pcount) {
922 printf("bsnprintf count %d doesn't match sprintf count %d\n",
925 if (strcmp(buf1, buf2)) {
927 ("bsnprintf doesn't match Format: %s\n\tsnprintf = %s\n\tsprintf = %s\n",
928 s_fmt[x], buf1, buf2);
936 printf("%d tests failed out of %d.\n", fail, num);
938 #endif /* TEST_PROGRAM */
940 #endif /* USE_BSNPRINTF */