d52ad7cdf5befcafc832b4d1380314333177f1b8
[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 <limits.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 = strlen(value);
389     if (strln > INT_MAX)
390         strln = INT_MAX;
391
392     padlen = min - strln;
393     if (min < 0 || padlen < 0)
394         padlen = 0;
395     if (flags & DP_F_MINUS)
396         padlen = -padlen;
397
398     while ((padlen > 0) && (cnt < max)) {
399         if(!doapr_outch(sbuffer, buffer, currlen, maxlen, ' '))
400             return 0;
401         --padlen;
402         ++cnt;
403     }
404     while (*value && (cnt < max)) {
405         if(!doapr_outch(sbuffer, buffer, currlen, maxlen, *value++))
406             return 0;
407         ++cnt;
408     }
409     while ((padlen < 0) && (cnt < max)) {
410         if(!doapr_outch(sbuffer, buffer, currlen, maxlen, ' '))
411             return 0;
412         ++padlen;
413         ++cnt;
414     }
415     return 1;
416 }
417
418 static int
419 fmtint(char **sbuffer,
420        char **buffer,
421        size_t *currlen,
422        size_t *maxlen, LLONG value, int base, int min, int max, int flags)
423 {
424     int signvalue = 0;
425     const char *prefix = "";
426     unsigned LLONG uvalue;
427     char convert[DECIMAL_SIZE(value) + 3];
428     int place = 0;
429     int spadlen = 0;
430     int zpadlen = 0;
431     int caps = 0;
432
433     if (max < 0)
434         max = 0;
435     uvalue = value;
436     if (!(flags & DP_F_UNSIGNED)) {
437         if (value < 0) {
438             signvalue = '-';
439             uvalue = -value;
440         } else if (flags & DP_F_PLUS)
441             signvalue = '+';
442         else if (flags & DP_F_SPACE)
443             signvalue = ' ';
444     }
445     if (flags & DP_F_NUM) {
446         if (base == 8)
447             prefix = "0";
448         if (base == 16)
449             prefix = "0x";
450     }
451     if (flags & DP_F_UP)
452         caps = 1;
453     do {
454         convert[place++] = (caps ? "0123456789ABCDEF" : "0123456789abcdef")
455             [uvalue % (unsigned)base];
456         uvalue = (uvalue / (unsigned)base);
457     } while (uvalue && (place < (int)sizeof(convert)));
458     if (place == sizeof(convert))
459         place--;
460     convert[place] = 0;
461
462     zpadlen = max - place;
463     spadlen =
464         min - OSSL_MAX(max, place) - (signvalue ? 1 : 0) - strlen(prefix);
465     if (zpadlen < 0)
466         zpadlen = 0;
467     if (spadlen < 0)
468         spadlen = 0;
469     if (flags & DP_F_ZERO) {
470         zpadlen = OSSL_MAX(zpadlen, spadlen);
471         spadlen = 0;
472     }
473     if (flags & DP_F_MINUS)
474         spadlen = -spadlen;
475
476     /* spaces */
477     while (spadlen > 0) {
478         if(!doapr_outch(sbuffer, buffer, currlen, maxlen, ' '))
479             return 0;
480         --spadlen;
481     }
482
483     /* sign */
484     if (signvalue)
485         if(!doapr_outch(sbuffer, buffer, currlen, maxlen, signvalue))
486             return 0;
487
488     /* prefix */
489     while (*prefix) {
490         if(!doapr_outch(sbuffer, buffer, currlen, maxlen, *prefix))
491             return 0;
492         prefix++;
493     }
494
495     /* zeros */
496     if (zpadlen > 0) {
497         while (zpadlen > 0) {
498             if(!doapr_outch(sbuffer, buffer, currlen, maxlen, '0'))
499                 return 0;
500             --zpadlen;
501         }
502     }
503     /* digits */
504     while (place > 0) {
505         if (!doapr_outch(sbuffer, buffer, currlen, maxlen, convert[--place]))
506             return 0;
507     }
508
509     /* left justified spaces */
510     while (spadlen < 0) {
511         if (!doapr_outch(sbuffer, buffer, currlen, maxlen, ' '))
512             return 0;
513         ++spadlen;
514     }
515     return 1;
516 }
517
518 static LDOUBLE abs_val(LDOUBLE value)
519 {
520     LDOUBLE result = value;
521     if (value < 0)
522         result = -value;
523     return result;
524 }
525
526 static LDOUBLE pow_10(int in_exp)
527 {
528     LDOUBLE result = 1;
529     while (in_exp) {
530         result *= 10;
531         in_exp--;
532     }
533     return result;
534 }
535
536 static long roundv(LDOUBLE value)
537 {
538     long intpart;
539     intpart = (long)value;
540     value = value - intpart;
541     if (value >= 0.5)
542         intpart++;
543     return intpart;
544 }
545
546 static int
547 fmtfp(char **sbuffer,
548       char **buffer,
549       size_t *currlen,
550       size_t *maxlen, LDOUBLE fvalue, int min, int max, int flags, int style)
551 {
552     int signvalue = 0;
553     LDOUBLE ufvalue;
554     LDOUBLE tmpvalue;
555     char iconvert[20];
556     char fconvert[20];
557     char econvert[20];
558     int iplace = 0;
559     int fplace = 0;
560     int eplace = 0;
561     int padlen = 0;
562     int zpadlen = 0;
563     long exp = 0;
564     unsigned long intpart;
565     unsigned long fracpart;
566     unsigned long max10;
567     int realstyle;
568
569     if (max < 0)
570         max = 6;
571
572     if (fvalue < 0)
573         signvalue = '-';
574     else if (flags & DP_F_PLUS)
575         signvalue = '+';
576     else if (flags & DP_F_SPACE)
577         signvalue = ' ';
578
579     /*
580      * G_FORMAT sometimes prints like E_FORMAT and sometimes like F_FORMAT
581      * depending on the number to be printed. Work out which one it is and use
582      * that from here on.
583      */
584     if (style == G_FORMAT) {
585         if (fvalue == 0.0) {
586             realstyle = F_FORMAT;
587         } else if (fvalue < 0.0001) {
588             realstyle = E_FORMAT;
589         } else if ((max == 0 && fvalue >= 10)
590                     || (max > 0 && fvalue >= pow_10(max))) {
591             realstyle = E_FORMAT;
592         } else {
593             realstyle = F_FORMAT;
594         }
595     } else {
596         realstyle = style;
597     }
598
599     if (style != F_FORMAT) {
600         tmpvalue = fvalue;
601         /* Calculate the exponent */
602         if (fvalue != 0.0) {
603             while (tmpvalue < 1) {
604                 tmpvalue *= 10;
605                 exp--;
606             }
607             while (tmpvalue > 10) {
608                 tmpvalue /= 10;
609                 exp++;
610             }
611         }
612         if (style == G_FORMAT) {
613             /*
614              * In G_FORMAT the "precision" represents significant digits. We
615              * always have at least 1 significant digit.
616              */
617             if (max == 0)
618                 max = 1;
619             /* Now convert significant digits to decimal places */
620             if (realstyle == F_FORMAT) {
621                 max -= (exp + 1);
622                 if (max < 0) {
623                     /*
624                      * Should not happen. If we're in F_FORMAT then exp < max?
625                      */
626                     return 0;
627                 }
628             } else {
629                 /*
630                  * In E_FORMAT there is always one significant digit in front
631                  * of the decimal point, so:
632                  * significant digits == 1 + decimal places
633                  */
634                 max--;
635             }
636         }
637         if (realstyle == E_FORMAT)
638             fvalue = tmpvalue;
639     }
640     ufvalue = abs_val(fvalue);
641     if (ufvalue > ULONG_MAX) {
642         /* Number too big */
643         return 0;
644     }
645     intpart = (unsigned long)ufvalue;
646
647     /*
648      * sorry, we only support 9 digits past the decimal because of our
649      * conversion method
650      */
651     if (max > 9)
652         max = 9;
653
654     /*
655      * we "cheat" by converting the fractional part to integer by multiplying
656      * by a factor of 10
657      */
658     max10 = roundv(pow_10(max));
659     fracpart = roundv(pow_10(max) * (ufvalue - intpart));
660
661     if (fracpart >= max10) {
662         intpart++;
663         fracpart -= max10;
664     }
665
666     /* convert integer part */
667     do {
668         iconvert[iplace++] = "0123456789"[intpart % 10];
669         intpart = (intpart / 10);
670     } while (intpart && (iplace < (int)sizeof(iconvert)));
671     if (iplace == sizeof iconvert)
672         iplace--;
673     iconvert[iplace] = 0;
674
675     /* convert fractional part */
676     while (fplace < max) {
677         if (style == G_FORMAT && fplace == 0 && (fracpart % 10) == 0) {
678             /* We strip trailing zeros in G_FORMAT */
679             max--;
680             fracpart = fracpart / 10;
681             if (fplace < max)
682                 continue;
683             break;
684         }
685         fconvert[fplace++] = "0123456789"[fracpart % 10];
686         fracpart = (fracpart / 10);
687     }
688
689     if (fplace == sizeof fconvert)
690         fplace--;
691     fconvert[fplace] = 0;
692
693     /* convert exponent part */
694     if (realstyle == E_FORMAT) {
695         int tmpexp;
696         if (exp < 0)
697             tmpexp = -exp;
698         else
699             tmpexp = exp;
700
701         do {
702             econvert[eplace++] = "0123456789"[tmpexp % 10];
703             tmpexp = (tmpexp / 10);
704         } while (tmpexp > 0 && eplace < (int)sizeof(econvert));
705         /* Exponent is huge!! Too big to print */
706         if (tmpexp > 0)
707             return 0;
708         /* Add a leading 0 for single digit exponents */
709         if (eplace == 1)
710             econvert[eplace++] = '0';
711     }
712
713     /*
714      * -1 for decimal point (if we have one, i.e. max > 0),
715      * another -1 if we are printing a sign
716      */
717     padlen = min - iplace - max - (max > 0 ? 1 : 0) - ((signvalue) ? 1 : 0);
718     /* Take some off for exponent prefix "+e" and exponent */
719     if (realstyle == E_FORMAT)
720         padlen -= 2 + eplace;
721     zpadlen = max - fplace;
722     if (zpadlen < 0)
723         zpadlen = 0;
724     if (padlen < 0)
725         padlen = 0;
726     if (flags & DP_F_MINUS)
727         padlen = -padlen;
728
729     if ((flags & DP_F_ZERO) && (padlen > 0)) {
730         if (signvalue) {
731             if (!doapr_outch(sbuffer, buffer, currlen, maxlen, signvalue))
732                 return 0;
733             --padlen;
734             signvalue = 0;
735         }
736         while (padlen > 0) {
737             if (!doapr_outch(sbuffer, buffer, currlen, maxlen, '0'))
738                 return 0;
739             --padlen;
740         }
741     }
742     while (padlen > 0) {
743         if (!doapr_outch(sbuffer, buffer, currlen, maxlen, ' '))
744             return 0;
745         --padlen;
746     }
747     if (signvalue && !doapr_outch(sbuffer, buffer, currlen, maxlen, signvalue))
748         return 0;
749
750     while (iplace > 0) {
751         if (!doapr_outch(sbuffer, buffer, currlen, maxlen, iconvert[--iplace]))
752             return 0;
753     }
754
755     /*
756      * Decimal point. This should probably use locale to find the correct
757      * char to print out.
758      */
759     if (max > 0 || (flags & DP_F_NUM)) {
760         if (!doapr_outch(sbuffer, buffer, currlen, maxlen, '.'))
761             return 0;
762
763         while (fplace > 0) {
764             if(!doapr_outch(sbuffer, buffer, currlen, maxlen,
765                             fconvert[--fplace]))
766                 return 0;
767         }
768     }
769     while (zpadlen > 0) {
770         if (!doapr_outch(sbuffer, buffer, currlen, maxlen, '0'))
771             return 0;
772         --zpadlen;
773     }
774     if (realstyle == E_FORMAT) {
775         char ech;
776
777         if ((flags & DP_F_UP) == 0)
778             ech = 'e';
779         else
780             ech = 'E';
781         if (!doapr_outch(sbuffer, buffer, currlen, maxlen, ech))
782                 return 0;
783         if (exp < 0) {
784             if (!doapr_outch(sbuffer, buffer, currlen, maxlen, '-'))
785                     return 0;
786         } else {
787             if (!doapr_outch(sbuffer, buffer, currlen, maxlen, '+'))
788                     return 0;
789         }
790         while (eplace > 0) {
791             if (!doapr_outch(sbuffer, buffer, currlen, maxlen,
792                              econvert[--eplace]))
793                 return 0;
794         }
795     }
796
797     while (padlen < 0) {
798         if (!doapr_outch(sbuffer, buffer, currlen, maxlen, ' '))
799             return 0;
800         ++padlen;
801     }
802     return 1;
803 }
804
805 #define BUFFER_INC  1024
806
807 static int
808 doapr_outch(char **sbuffer,
809             char **buffer, size_t *currlen, size_t *maxlen, int c)
810 {
811     /* If we haven't at least one buffer, someone has doe a big booboo */
812     OPENSSL_assert(*sbuffer != NULL || buffer != NULL);
813
814     /* |currlen| must always be <= |*maxlen| */
815     OPENSSL_assert(*currlen <= *maxlen);
816
817     if (buffer && *currlen == *maxlen) {
818         if (*maxlen > INT_MAX - BUFFER_INC)
819             return 0;
820
821         *maxlen += BUFFER_INC;
822         if (*buffer == NULL) {
823             *buffer = OPENSSL_malloc(*maxlen);
824             if (*buffer == NULL)
825                 return 0;
826             if (*currlen > 0) {
827                 OPENSSL_assert(*sbuffer != NULL);
828                 memcpy(*buffer, *sbuffer, *currlen);
829             }
830             *sbuffer = NULL;
831         } else {
832             char *tmpbuf;
833             tmpbuf = OPENSSL_realloc(*buffer, *maxlen);
834             if (tmpbuf == NULL)
835                 return 0;
836             *buffer = tmpbuf;
837         }
838     }
839
840     if (*currlen < *maxlen) {
841         if (*sbuffer)
842             (*sbuffer)[(*currlen)++] = (char)c;
843         else
844             (*buffer)[(*currlen)++] = (char)c;
845     }
846
847     return 1;
848 }
849
850 /***************************************************************************/
851
852 int BIO_printf(BIO *bio, const char *format, ...)
853 {
854     va_list args;
855     int ret;
856
857     va_start(args, format);
858
859     ret = BIO_vprintf(bio, format, args);
860
861     va_end(args);
862     return (ret);
863 }
864
865 int BIO_vprintf(BIO *bio, const char *format, va_list args)
866 {
867     int ret;
868     size_t retlen;
869     char hugebuf[1024 * 2];     /* Was previously 10k, which is unreasonable
870                                  * in small-stack environments, like threads
871                                  * or DOS programs. */
872     char *hugebufp = hugebuf;
873     size_t hugebufsize = sizeof(hugebuf);
874     char *dynbuf = NULL;
875     int ignored;
876
877     dynbuf = NULL;
878     if (!_dopr(&hugebufp, &dynbuf, &hugebufsize, &retlen, &ignored, format,
879                 args)) {
880         OPENSSL_free(dynbuf);
881         return -1;
882     }
883     if (dynbuf) {
884         ret = BIO_write(bio, dynbuf, (int)retlen);
885         OPENSSL_free(dynbuf);
886     } else {
887         ret = BIO_write(bio, hugebuf, (int)retlen);
888     }
889     return (ret);
890 }
891
892 /*
893  * As snprintf is not available everywhere, we provide our own
894  * implementation. This function has nothing to do with BIOs, but it's
895  * closely related to BIO_printf, and we need *some* name prefix ... (XXX the
896  * function should be renamed, but to what?)
897  */
898 int BIO_snprintf(char *buf, size_t n, const char *format, ...)
899 {
900     va_list args;
901     int ret;
902
903     va_start(args, format);
904
905     ret = BIO_vsnprintf(buf, n, format, args);
906
907     va_end(args);
908     return (ret);
909 }
910
911 int BIO_vsnprintf(char *buf, size_t n, const char *format, va_list args)
912 {
913     size_t retlen;
914     int truncated;
915
916     if(!_dopr(&buf, NULL, &n, &retlen, &truncated, format, args))
917         return -1;
918
919     if (truncated)
920         /*
921          * In case of truncation, return -1 like traditional snprintf.
922          * (Current drafts for ISO/IEC 9899 say snprintf should return the
923          * number of characters that would have been written, had the buffer
924          * been large enough.)
925          */
926         return -1;
927     else
928         return (retlen <= INT_MAX) ? (int)retlen : -1;
929 }