Fix fmtstr for BIO_printf() et al
[openssl.git] / crypto / bio / b_print.c
1 /*
2  * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the OpenSSL license (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9
10 #include <stdio.h>
11 #include <string.h>
12 #include <ctype.h>
13 #include "internal/numbers.h"
14 #include "internal/cryptlib.h"
15 #ifndef NO_SYS_TYPES_H
16 # include <sys/types.h>
17 #endif
18 #include <openssl/bn.h>         /* To get BN_LLONG properly defined */
19 #include <openssl/bio.h>
20
21 #if defined(BN_LLONG) || defined(SIXTY_FOUR_BIT)
22 # ifndef HAVE_LONG_LONG
23 #  define HAVE_LONG_LONG 1
24 # endif
25 #endif
26
27 /*
28  * Copyright Patrick Powell 1995
29  * This code is based on code written by Patrick Powell <papowell@astart.com>
30  * It may be used for any purpose as long as this notice remains intact
31  * on all source code distributions.
32  */
33
34 #ifdef HAVE_LONG_DOUBLE
35 # define LDOUBLE long double
36 #else
37 # define LDOUBLE double
38 #endif
39
40 #ifdef HAVE_LONG_LONG
41 # if defined(_WIN32) && !defined(__GNUC__)
42 #  define LLONG __int64
43 # else
44 #  define LLONG long long
45 # endif
46 #else
47 # define LLONG long
48 #endif
49
50 static int fmtstr(char **, char **, size_t *, size_t *,
51                   const char *, int, int, int);
52 static int fmtint(char **, char **, size_t *, size_t *,
53                   LLONG, int, int, int, int);
54 static int fmtfp(char **, char **, size_t *, size_t *,
55                  LDOUBLE, int, int, int, int);
56 static int doapr_outch(char **, char **, size_t *, size_t *, int);
57 static int _dopr(char **sbuffer, char **buffer,
58                  size_t *maxlen, size_t *retlen, int *truncated,
59                  const char *format, va_list args);
60
61 /* format read states */
62 #define DP_S_DEFAULT    0
63 #define DP_S_FLAGS      1
64 #define DP_S_MIN        2
65 #define DP_S_DOT        3
66 #define DP_S_MAX        4
67 #define DP_S_MOD        5
68 #define DP_S_CONV       6
69 #define DP_S_DONE       7
70
71 /* format flags - Bits */
72 /* left-aligned padding */
73 #define DP_F_MINUS      (1 << 0)
74 /* print an explicit '+' for a value with positive sign */
75 #define DP_F_PLUS       (1 << 1)
76 /* print an explicit ' ' for a value with positive sign */
77 #define DP_F_SPACE      (1 << 2)
78 /* print 0/0x prefix for octal/hex and decimal point for floating point */
79 #define DP_F_NUM        (1 << 3)
80 /* print leading zeroes */
81 #define DP_F_ZERO       (1 << 4)
82 /* print HEX in UPPPERcase */
83 #define DP_F_UP         (1 << 5)
84 /* treat value as unsigned */
85 #define DP_F_UNSIGNED   (1 << 6)
86
87 /* conversion flags */
88 #define DP_C_SHORT      1
89 #define DP_C_LONG       2
90 #define DP_C_LDOUBLE    3
91 #define DP_C_LLONG      4
92
93 /* Floating point formats */
94 #define F_FORMAT        0
95 #define E_FORMAT        1
96 #define G_FORMAT        2
97
98 /* some handy macros */
99 #define char_to_int(p) (p - '0')
100 #define OSSL_MAX(p,q) ((p >= q) ? p : q)
101
102 static int
103 _dopr(char **sbuffer,
104       char **buffer,
105       size_t *maxlen,
106       size_t *retlen, int *truncated, const char *format, va_list args)
107 {
108     char ch;
109     LLONG value;
110     LDOUBLE fvalue;
111     char *strvalue;
112     int min;
113     int max;
114     int state;
115     int flags;
116     int cflags;
117     size_t currlen;
118
119     state = DP_S_DEFAULT;
120     flags = currlen = cflags = min = 0;
121     max = -1;
122     ch = *format++;
123
124     while (state != DP_S_DONE) {
125         if (ch == '\0' || (buffer == NULL && currlen >= *maxlen))
126             state = DP_S_DONE;
127
128         switch (state) {
129         case DP_S_DEFAULT:
130             if (ch == '%')
131                 state = DP_S_FLAGS;
132             else
133                 if(!doapr_outch(sbuffer, buffer, &currlen, maxlen, ch))
134                     return 0;
135             ch = *format++;
136             break;
137         case DP_S_FLAGS:
138             switch (ch) {
139             case '-':
140                 flags |= DP_F_MINUS;
141                 ch = *format++;
142                 break;
143             case '+':
144                 flags |= DP_F_PLUS;
145                 ch = *format++;
146                 break;
147             case ' ':
148                 flags |= DP_F_SPACE;
149                 ch = *format++;
150                 break;
151             case '#':
152                 flags |= DP_F_NUM;
153                 ch = *format++;
154                 break;
155             case '0':
156                 flags |= DP_F_ZERO;
157                 ch = *format++;
158                 break;
159             default:
160                 state = DP_S_MIN;
161                 break;
162             }
163             break;
164         case DP_S_MIN:
165             if (isdigit((unsigned char)ch)) {
166                 min = 10 * min + char_to_int(ch);
167                 ch = *format++;
168             } else if (ch == '*') {
169                 min = va_arg(args, int);
170                 ch = *format++;
171                 state = DP_S_DOT;
172             } else
173                 state = DP_S_DOT;
174             break;
175         case DP_S_DOT:
176             if (ch == '.') {
177                 state = DP_S_MAX;
178                 ch = *format++;
179             } else
180                 state = DP_S_MOD;
181             break;
182         case DP_S_MAX:
183             if (isdigit((unsigned char)ch)) {
184                 if (max < 0)
185                     max = 0;
186                 max = 10 * max + char_to_int(ch);
187                 ch = *format++;
188             } else if (ch == '*') {
189                 max = va_arg(args, int);
190                 ch = *format++;
191                 state = DP_S_MOD;
192             } else
193                 state = DP_S_MOD;
194             break;
195         case DP_S_MOD:
196             switch (ch) {
197             case 'h':
198                 cflags = DP_C_SHORT;
199                 ch = *format++;
200                 break;
201             case 'l':
202                 if (*format == 'l') {
203                     cflags = DP_C_LLONG;
204                     format++;
205                 } else
206                     cflags = DP_C_LONG;
207                 ch = *format++;
208                 break;
209             case 'q':
210                 cflags = DP_C_LLONG;
211                 ch = *format++;
212                 break;
213             case 'L':
214                 cflags = DP_C_LDOUBLE;
215                 ch = *format++;
216                 break;
217             default:
218                 break;
219             }
220             state = DP_S_CONV;
221             break;
222         case DP_S_CONV:
223             switch (ch) {
224             case 'd':
225             case 'i':
226                 switch (cflags) {
227                 case DP_C_SHORT:
228                     value = (short int)va_arg(args, int);
229                     break;
230                 case DP_C_LONG:
231                     value = va_arg(args, long int);
232                     break;
233                 case DP_C_LLONG:
234                     value = va_arg(args, LLONG);
235                     break;
236                 default:
237                     value = va_arg(args, int);
238                     break;
239                 }
240                 if (!fmtint(sbuffer, buffer, &currlen, maxlen, value, 10, min,
241                             max, flags))
242                     return 0;
243                 break;
244             case 'X':
245                 flags |= DP_F_UP;
246                 /* FALLTHROUGH */
247             case 'x':
248             case 'o':
249             case 'u':
250                 flags |= DP_F_UNSIGNED;
251                 switch (cflags) {
252                 case DP_C_SHORT:
253                     value = (unsigned short int)va_arg(args, unsigned int);
254                     break;
255                 case DP_C_LONG:
256                     value = (LLONG) va_arg(args, unsigned long int);
257                     break;
258                 case DP_C_LLONG:
259                     value = va_arg(args, unsigned LLONG);
260                     break;
261                 default:
262                     value = (LLONG) va_arg(args, unsigned int);
263                     break;
264                 }
265                 if (!fmtint(sbuffer, buffer, &currlen, maxlen, value,
266                             ch == 'o' ? 8 : (ch == 'u' ? 10 : 16),
267                             min, max, flags))
268                     return 0;
269                 break;
270             case 'f':
271                 if (cflags == DP_C_LDOUBLE)
272                     fvalue = va_arg(args, LDOUBLE);
273                 else
274                     fvalue = va_arg(args, double);
275                 if (!fmtfp(sbuffer, buffer, &currlen, maxlen, fvalue, min, max,
276                            flags, F_FORMAT))
277                     return 0;
278                 break;
279             case 'E':
280                 flags |= DP_F_UP;
281             case 'e':
282                 if (cflags == DP_C_LDOUBLE)
283                     fvalue = va_arg(args, LDOUBLE);
284                 else
285                     fvalue = va_arg(args, double);
286                 if (!fmtfp(sbuffer, buffer, &currlen, maxlen, fvalue, min, max,
287                            flags, E_FORMAT))
288                     return 0;
289                 break;
290             case 'G':
291                 flags |= DP_F_UP;
292             case 'g':
293                 if (cflags == DP_C_LDOUBLE)
294                     fvalue = va_arg(args, LDOUBLE);
295                 else
296                     fvalue = va_arg(args, double);
297                 if (!fmtfp(sbuffer, buffer, &currlen, maxlen, fvalue, min, max,
298                            flags, G_FORMAT))
299                     return 0;
300                 break;
301             case 'c':
302                 if(!doapr_outch(sbuffer, buffer, &currlen, maxlen,
303                             va_arg(args, int)))
304                     return 0;
305                 break;
306             case 's':
307                 strvalue = va_arg(args, char *);
308                 if (max < 0) {
309                     if (buffer)
310                         max = INT_MAX;
311                     else
312                         max = *maxlen;
313                 }
314                 if (!fmtstr(sbuffer, buffer, &currlen, maxlen, strvalue,
315                             flags, min, max))
316                     return 0;
317                 break;
318             case 'p':
319                 value = (size_t)va_arg(args, void *);
320                 if (!fmtint(sbuffer, buffer, &currlen, maxlen,
321                             value, 16, min, max, flags | DP_F_NUM))
322                     return 0;
323                 break;
324             case 'n':          /* XXX */
325                 if (cflags == DP_C_SHORT) {
326                     short int *num;
327                     num = va_arg(args, short int *);
328                     *num = currlen;
329                 } else if (cflags == DP_C_LONG) { /* XXX */
330                     long int *num;
331                     num = va_arg(args, long int *);
332                     *num = (long int)currlen;
333                 } else if (cflags == DP_C_LLONG) { /* XXX */
334                     LLONG *num;
335                     num = va_arg(args, LLONG *);
336                     *num = (LLONG) currlen;
337                 } else {
338                     int *num;
339                     num = va_arg(args, int *);
340                     *num = currlen;
341                 }
342                 break;
343             case '%':
344                 if(!doapr_outch(sbuffer, buffer, &currlen, maxlen, ch))
345                     return 0;
346                 break;
347             case 'w':
348                 /* not supported yet, treat as next char */
349                 ch = *format++;
350                 break;
351             default:
352                 /* unknown, skip */
353                 break;
354             }
355             ch = *format++;
356             state = DP_S_DEFAULT;
357             flags = cflags = min = 0;
358             max = -1;
359             break;
360         case DP_S_DONE:
361             break;
362         default:
363             break;
364         }
365     }
366     *truncated = (currlen > *maxlen - 1);
367     if (*truncated)
368         currlen = *maxlen - 1;
369     if(!doapr_outch(sbuffer, buffer, &currlen, maxlen, '\0'))
370         return 0;
371     *retlen = currlen - 1;
372     return 1;
373 }
374
375 static int
376 fmtstr(char **sbuffer,
377        char **buffer,
378        size_t *currlen,
379        size_t *maxlen, const char *value, int flags, int min, int max)
380 {
381     int padlen;
382     size_t strln;
383     int cnt = 0;
384
385     if (value == 0)
386         value = "<NULL>";
387
388     strln = OPENSSL_strnlen(value, max < 0 ? SIZE_MAX : (size_t)max);
389
390     padlen = min - strln;
391     if (min < 0 || padlen < 0)
392         padlen = 0;
393     if (max >= 0)
394         max += padlen;      /* The maximum output including padding */
395     if (flags & DP_F_MINUS)
396         padlen = -padlen;
397
398     while ((padlen > 0) && (max < 0 || cnt < max)) {
399         if(!doapr_outch(sbuffer, buffer, currlen, maxlen, ' '))
400             return 0;
401         --padlen;
402         ++cnt;
403     }
404     while (strln > 0 && (max < 0 || cnt < max)) {
405         if(!doapr_outch(sbuffer, buffer, currlen, maxlen, *value++))
406             return 0;
407         --strln;
408         ++cnt;
409     }
410     while ((padlen < 0) && (max < 0 || cnt < max)) {
411         if(!doapr_outch(sbuffer, buffer, currlen, maxlen, ' '))
412             return 0;
413         ++padlen;
414         ++cnt;
415     }
416     return 1;
417 }
418
419 static int
420 fmtint(char **sbuffer,
421        char **buffer,
422        size_t *currlen,
423        size_t *maxlen, LLONG value, int base, int min, int max, int flags)
424 {
425     int signvalue = 0;
426     const char *prefix = "";
427     unsigned LLONG uvalue;
428     char convert[DECIMAL_SIZE(value) + 3];
429     int place = 0;
430     int spadlen = 0;
431     int zpadlen = 0;
432     int caps = 0;
433
434     if (max < 0)
435         max = 0;
436     uvalue = value;
437     if (!(flags & DP_F_UNSIGNED)) {
438         if (value < 0) {
439             signvalue = '-';
440             uvalue = -value;
441         } else if (flags & DP_F_PLUS)
442             signvalue = '+';
443         else if (flags & DP_F_SPACE)
444             signvalue = ' ';
445     }
446     if (flags & DP_F_NUM) {
447         if (base == 8)
448             prefix = "0";
449         if (base == 16)
450             prefix = "0x";
451     }
452     if (flags & DP_F_UP)
453         caps = 1;
454     do {
455         convert[place++] = (caps ? "0123456789ABCDEF" : "0123456789abcdef")
456             [uvalue % (unsigned)base];
457         uvalue = (uvalue / (unsigned)base);
458     } while (uvalue && (place < (int)sizeof(convert)));
459     if (place == sizeof(convert))
460         place--;
461     convert[place] = 0;
462
463     zpadlen = max - place;
464     spadlen =
465         min - OSSL_MAX(max, place) - (signvalue ? 1 : 0) - strlen(prefix);
466     if (zpadlen < 0)
467         zpadlen = 0;
468     if (spadlen < 0)
469         spadlen = 0;
470     if (flags & DP_F_ZERO) {
471         zpadlen = OSSL_MAX(zpadlen, spadlen);
472         spadlen = 0;
473     }
474     if (flags & DP_F_MINUS)
475         spadlen = -spadlen;
476
477     /* spaces */
478     while (spadlen > 0) {
479         if(!doapr_outch(sbuffer, buffer, currlen, maxlen, ' '))
480             return 0;
481         --spadlen;
482     }
483
484     /* sign */
485     if (signvalue)
486         if(!doapr_outch(sbuffer, buffer, currlen, maxlen, signvalue))
487             return 0;
488
489     /* prefix */
490     while (*prefix) {
491         if(!doapr_outch(sbuffer, buffer, currlen, maxlen, *prefix))
492             return 0;
493         prefix++;
494     }
495
496     /* zeros */
497     if (zpadlen > 0) {
498         while (zpadlen > 0) {
499             if(!doapr_outch(sbuffer, buffer, currlen, maxlen, '0'))
500                 return 0;
501             --zpadlen;
502         }
503     }
504     /* digits */
505     while (place > 0) {
506         if (!doapr_outch(sbuffer, buffer, currlen, maxlen, convert[--place]))
507             return 0;
508     }
509
510     /* left justified spaces */
511     while (spadlen < 0) {
512         if (!doapr_outch(sbuffer, buffer, currlen, maxlen, ' '))
513             return 0;
514         ++spadlen;
515     }
516     return 1;
517 }
518
519 static LDOUBLE abs_val(LDOUBLE value)
520 {
521     LDOUBLE result = value;
522     if (value < 0)
523         result = -value;
524     return result;
525 }
526
527 static LDOUBLE pow_10(int in_exp)
528 {
529     LDOUBLE result = 1;
530     while (in_exp) {
531         result *= 10;
532         in_exp--;
533     }
534     return result;
535 }
536
537 static long roundv(LDOUBLE value)
538 {
539     long intpart;
540     intpart = (long)value;
541     value = value - intpart;
542     if (value >= 0.5)
543         intpart++;
544     return intpart;
545 }
546
547 static int
548 fmtfp(char **sbuffer,
549       char **buffer,
550       size_t *currlen,
551       size_t *maxlen, LDOUBLE fvalue, int min, int max, int flags, int style)
552 {
553     int signvalue = 0;
554     LDOUBLE ufvalue;
555     LDOUBLE tmpvalue;
556     char iconvert[20];
557     char fconvert[20];
558     char econvert[20];
559     int iplace = 0;
560     int fplace = 0;
561     int eplace = 0;
562     int padlen = 0;
563     int zpadlen = 0;
564     long exp = 0;
565     unsigned long intpart;
566     unsigned long fracpart;
567     unsigned long max10;
568     int realstyle;
569
570     if (max < 0)
571         max = 6;
572
573     if (fvalue < 0)
574         signvalue = '-';
575     else if (flags & DP_F_PLUS)
576         signvalue = '+';
577     else if (flags & DP_F_SPACE)
578         signvalue = ' ';
579
580     /*
581      * G_FORMAT sometimes prints like E_FORMAT and sometimes like F_FORMAT
582      * depending on the number to be printed. Work out which one it is and use
583      * that from here on.
584      */
585     if (style == G_FORMAT) {
586         if (fvalue == 0.0) {
587             realstyle = F_FORMAT;
588         } else if (fvalue < 0.0001) {
589             realstyle = E_FORMAT;
590         } else if ((max == 0 && fvalue >= 10)
591                     || (max > 0 && fvalue >= pow_10(max))) {
592             realstyle = E_FORMAT;
593         } else {
594             realstyle = F_FORMAT;
595         }
596     } else {
597         realstyle = style;
598     }
599
600     if (style != F_FORMAT) {
601         tmpvalue = fvalue;
602         /* Calculate the exponent */
603         if (fvalue != 0.0) {
604             while (tmpvalue < 1) {
605                 tmpvalue *= 10;
606                 exp--;
607             }
608             while (tmpvalue > 10) {
609                 tmpvalue /= 10;
610                 exp++;
611             }
612         }
613         if (style == G_FORMAT) {
614             /*
615              * In G_FORMAT the "precision" represents significant digits. We
616              * always have at least 1 significant digit.
617              */
618             if (max == 0)
619                 max = 1;
620             /* Now convert significant digits to decimal places */
621             if (realstyle == F_FORMAT) {
622                 max -= (exp + 1);
623                 if (max < 0) {
624                     /*
625                      * Should not happen. If we're in F_FORMAT then exp < max?
626                      */
627                     return 0;
628                 }
629             } else {
630                 /*
631                  * In E_FORMAT there is always one significant digit in front
632                  * of the decimal point, so:
633                  * significant digits == 1 + decimal places
634                  */
635                 max--;
636             }
637         }
638         if (realstyle == E_FORMAT)
639             fvalue = tmpvalue;
640     }
641     ufvalue = abs_val(fvalue);
642     if (ufvalue > ULONG_MAX) {
643         /* Number too big */
644         return 0;
645     }
646     intpart = (unsigned long)ufvalue;
647
648     /*
649      * sorry, we only support 9 digits past the decimal because of our
650      * conversion method
651      */
652     if (max > 9)
653         max = 9;
654
655     /*
656      * we "cheat" by converting the fractional part to integer by multiplying
657      * by a factor of 10
658      */
659     max10 = roundv(pow_10(max));
660     fracpart = roundv(pow_10(max) * (ufvalue - intpart));
661
662     if (fracpart >= max10) {
663         intpart++;
664         fracpart -= max10;
665     }
666
667     /* convert integer part */
668     do {
669         iconvert[iplace++] = "0123456789"[intpart % 10];
670         intpart = (intpart / 10);
671     } while (intpart && (iplace < (int)sizeof(iconvert)));
672     if (iplace == sizeof iconvert)
673         iplace--;
674     iconvert[iplace] = 0;
675
676     /* convert fractional part */
677     while (fplace < max) {
678         if (style == G_FORMAT && fplace == 0 && (fracpart % 10) == 0) {
679             /* We strip trailing zeros in G_FORMAT */
680             max--;
681             fracpart = fracpart / 10;
682             if (fplace < max)
683                 continue;
684             break;
685         }
686         fconvert[fplace++] = "0123456789"[fracpart % 10];
687         fracpart = (fracpart / 10);
688     }
689
690     if (fplace == sizeof fconvert)
691         fplace--;
692     fconvert[fplace] = 0;
693
694     /* convert exponent part */
695     if (realstyle == E_FORMAT) {
696         int tmpexp;
697         if (exp < 0)
698             tmpexp = -exp;
699         else
700             tmpexp = exp;
701
702         do {
703             econvert[eplace++] = "0123456789"[tmpexp % 10];
704             tmpexp = (tmpexp / 10);
705         } while (tmpexp > 0 && eplace < (int)sizeof(econvert));
706         /* Exponent is huge!! Too big to print */
707         if (tmpexp > 0)
708             return 0;
709         /* Add a leading 0 for single digit exponents */
710         if (eplace == 1)
711             econvert[eplace++] = '0';
712     }
713
714     /*
715      * -1 for decimal point (if we have one, i.e. max > 0),
716      * another -1 if we are printing a sign
717      */
718     padlen = min - iplace - max - (max > 0 ? 1 : 0) - ((signvalue) ? 1 : 0);
719     /* Take some off for exponent prefix "+e" and exponent */
720     if (realstyle == E_FORMAT)
721         padlen -= 2 + eplace;
722     zpadlen = max - fplace;
723     if (zpadlen < 0)
724         zpadlen = 0;
725     if (padlen < 0)
726         padlen = 0;
727     if (flags & DP_F_MINUS)
728         padlen = -padlen;
729
730     if ((flags & DP_F_ZERO) && (padlen > 0)) {
731         if (signvalue) {
732             if (!doapr_outch(sbuffer, buffer, currlen, maxlen, signvalue))
733                 return 0;
734             --padlen;
735             signvalue = 0;
736         }
737         while (padlen > 0) {
738             if (!doapr_outch(sbuffer, buffer, currlen, maxlen, '0'))
739                 return 0;
740             --padlen;
741         }
742     }
743     while (padlen > 0) {
744         if (!doapr_outch(sbuffer, buffer, currlen, maxlen, ' '))
745             return 0;
746         --padlen;
747     }
748     if (signvalue && !doapr_outch(sbuffer, buffer, currlen, maxlen, signvalue))
749         return 0;
750
751     while (iplace > 0) {
752         if (!doapr_outch(sbuffer, buffer, currlen, maxlen, iconvert[--iplace]))
753             return 0;
754     }
755
756     /*
757      * Decimal point. This should probably use locale to find the correct
758      * char to print out.
759      */
760     if (max > 0 || (flags & DP_F_NUM)) {
761         if (!doapr_outch(sbuffer, buffer, currlen, maxlen, '.'))
762             return 0;
763
764         while (fplace > 0) {
765             if(!doapr_outch(sbuffer, buffer, currlen, maxlen,
766                             fconvert[--fplace]))
767                 return 0;
768         }
769     }
770     while (zpadlen > 0) {
771         if (!doapr_outch(sbuffer, buffer, currlen, maxlen, '0'))
772             return 0;
773         --zpadlen;
774     }
775     if (realstyle == E_FORMAT) {
776         char ech;
777
778         if ((flags & DP_F_UP) == 0)
779             ech = 'e';
780         else
781             ech = 'E';
782         if (!doapr_outch(sbuffer, buffer, currlen, maxlen, ech))
783                 return 0;
784         if (exp < 0) {
785             if (!doapr_outch(sbuffer, buffer, currlen, maxlen, '-'))
786                     return 0;
787         } else {
788             if (!doapr_outch(sbuffer, buffer, currlen, maxlen, '+'))
789                     return 0;
790         }
791         while (eplace > 0) {
792             if (!doapr_outch(sbuffer, buffer, currlen, maxlen,
793                              econvert[--eplace]))
794                 return 0;
795         }
796     }
797
798     while (padlen < 0) {
799         if (!doapr_outch(sbuffer, buffer, currlen, maxlen, ' '))
800             return 0;
801         ++padlen;
802     }
803     return 1;
804 }
805
806 #define BUFFER_INC  1024
807
808 static int
809 doapr_outch(char **sbuffer,
810             char **buffer, size_t *currlen, size_t *maxlen, int c)
811 {
812     /* If we haven't at least one buffer, someone has doe a big booboo */
813     OPENSSL_assert(*sbuffer != NULL || buffer != NULL);
814
815     /* |currlen| must always be <= |*maxlen| */
816     OPENSSL_assert(*currlen <= *maxlen);
817
818     if (buffer && *currlen == *maxlen) {
819         if (*maxlen > INT_MAX - BUFFER_INC)
820             return 0;
821
822         *maxlen += BUFFER_INC;
823         if (*buffer == NULL) {
824             *buffer = OPENSSL_malloc(*maxlen);
825             if (*buffer == NULL)
826                 return 0;
827             if (*currlen > 0) {
828                 OPENSSL_assert(*sbuffer != NULL);
829                 memcpy(*buffer, *sbuffer, *currlen);
830             }
831             *sbuffer = NULL;
832         } else {
833             char *tmpbuf;
834             tmpbuf = OPENSSL_realloc(*buffer, *maxlen);
835             if (tmpbuf == NULL)
836                 return 0;
837             *buffer = tmpbuf;
838         }
839     }
840
841     if (*currlen < *maxlen) {
842         if (*sbuffer)
843             (*sbuffer)[(*currlen)++] = (char)c;
844         else
845             (*buffer)[(*currlen)++] = (char)c;
846     }
847
848     return 1;
849 }
850
851 /***************************************************************************/
852
853 int BIO_printf(BIO *bio, const char *format, ...)
854 {
855     va_list args;
856     int ret;
857
858     va_start(args, format);
859
860     ret = BIO_vprintf(bio, format, args);
861
862     va_end(args);
863     return (ret);
864 }
865
866 int BIO_vprintf(BIO *bio, const char *format, va_list args)
867 {
868     int ret;
869     size_t retlen;
870     char hugebuf[1024 * 2];     /* Was previously 10k, which is unreasonable
871                                  * in small-stack environments, like threads
872                                  * or DOS programs. */
873     char *hugebufp = hugebuf;
874     size_t hugebufsize = sizeof(hugebuf);
875     char *dynbuf = NULL;
876     int ignored;
877
878     dynbuf = NULL;
879     if (!_dopr(&hugebufp, &dynbuf, &hugebufsize, &retlen, &ignored, format,
880                 args)) {
881         OPENSSL_free(dynbuf);
882         return -1;
883     }
884     if (dynbuf) {
885         ret = BIO_write(bio, dynbuf, (int)retlen);
886         OPENSSL_free(dynbuf);
887     } else {
888         ret = BIO_write(bio, hugebuf, (int)retlen);
889     }
890     return (ret);
891 }
892
893 /*
894  * As snprintf is not available everywhere, we provide our own
895  * implementation. This function has nothing to do with BIOs, but it's
896  * closely related to BIO_printf, and we need *some* name prefix ... (XXX the
897  * function should be renamed, but to what?)
898  */
899 int BIO_snprintf(char *buf, size_t n, const char *format, ...)
900 {
901     va_list args;
902     int ret;
903
904     va_start(args, format);
905
906     ret = BIO_vsnprintf(buf, n, format, args);
907
908     va_end(args);
909     return (ret);
910 }
911
912 int BIO_vsnprintf(char *buf, size_t n, const char *format, va_list args)
913 {
914     size_t retlen;
915     int truncated;
916
917     if(!_dopr(&buf, NULL, &n, &retlen, &truncated, format, args))
918         return -1;
919
920     if (truncated)
921         /*
922          * In case of truncation, return -1 like traditional snprintf.
923          * (Current drafts for ISO/IEC 9899 say snprintf should return the
924          * number of characters that would have been written, had the buffer
925          * been large enough.)
926          */
927         return -1;
928     else
929         return (retlen <= INT_MAX) ? (int)retlen : -1;
930 }