Import OpenSSL-0.9.8f.
[dragonfly.git] / crypto / openssl-0.9 / crypto / bio / b_print.c
1 /* crypto/bio/b_print.c */
2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
3  * All rights reserved.
4  *
5  * This package is an SSL implementation written
6  * by Eric Young (eay@cryptsoft.com).
7  * The implementation was written so as to conform with Netscapes SSL.
8  * 
9  * This library is free for commercial and non-commercial use as long as
10  * the following conditions are aheared to.  The following conditions
11  * apply to all code found in this distribution, be it the RC4, RSA,
12  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
13  * included with this distribution is covered by the same copyright terms
14  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
15  * 
16  * Copyright remains Eric Young's, and as such any Copyright notices in
17  * the code are not to be removed.
18  * If this package is used in a product, Eric Young should be given attribution
19  * as the author of the parts of the library used.
20  * This can be in the form of a textual message at program startup or
21  * in documentation (online or textual) provided with the package.
22  * 
23  * Redistribution and use in source and binary forms, with or without
24  * modification, are permitted provided that the following conditions
25  * are met:
26  * 1. Redistributions of source code must retain the copyright
27  *    notice, this list of conditions and the following disclaimer.
28  * 2. Redistributions in binary form must reproduce the above copyright
29  *    notice, this list of conditions and the following disclaimer in the
30  *    documentation and/or other materials provided with the distribution.
31  * 3. All advertising materials mentioning features or use of this software
32  *    must display the following acknowledgement:
33  *    "This product includes cryptographic software written by
34  *     Eric Young (eay@cryptsoft.com)"
35  *    The word 'cryptographic' can be left out if the rouines from the library
36  *    being used are not cryptographic related :-).
37  * 4. If you include any Windows specific code (or a derivative thereof) from 
38  *    the apps directory (application code) you must include an acknowledgement:
39  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
40  * 
41  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
42  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
44  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
45  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
46  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
47  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
49  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
50  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
51  * SUCH DAMAGE.
52  * 
53  * The licence and distribution terms for any publically available version or
54  * derivative of this code cannot be changed.  i.e. this code cannot simply be
55  * copied and put under another distribution licence
56  * [including the GNU Public Licence.]
57  */
58
59 /* disable assert() unless BIO_DEBUG has been defined */
60 #ifndef BIO_DEBUG
61 # ifndef NDEBUG
62 #  define NDEBUG
63 # endif
64 #endif
65
66 /* 
67  * Stolen from tjh's ssl/ssl_trc.c stuff.
68  */
69
70 #include <stdio.h>
71 #include <string.h>
72 #include <ctype.h>
73 #include <assert.h>
74 #include <limits.h>
75 #include "cryptlib.h"
76 #ifndef NO_SYS_TYPES_H
77 #include <sys/types.h>
78 #endif
79 #include <openssl/bn.h>         /* To get BN_LLONG properly defined */
80 #include <openssl/bio.h>
81
82 #if defined(BN_LLONG) || defined(SIXTY_FOUR_BIT)
83 # ifndef HAVE_LONG_LONG
84 #  define HAVE_LONG_LONG 1
85 # endif
86 #endif
87
88 /***************************************************************************/
89
90 /*
91  * Copyright Patrick Powell 1995
92  * This code is based on code written by Patrick Powell <papowell@astart.com>
93  * It may be used for any purpose as long as this notice remains intact
94  * on all source code distributions.
95  */
96
97 /*
98  * This code contains numerious changes and enhancements which were
99  * made by lots of contributors over the last years to Patrick Powell's
100  * original code:
101  *
102  * o Patrick Powell <papowell@astart.com>      (1995)
103  * o Brandon Long <blong@fiction.net>          (1996, for Mutt)
104  * o Thomas Roessler <roessler@guug.de>        (1998, for Mutt)
105  * o Michael Elkins <me@cs.hmc.edu>            (1998, for Mutt)
106  * o Andrew Tridgell <tridge@samba.org>        (1998, for Samba)
107  * o Luke Mewburn <lukem@netbsd.org>           (1999, for LukemFTP)
108  * o Ralf S. Engelschall <rse@engelschall.com> (1999, for Pth)
109  * o ...                                       (for OpenSSL)
110  */
111
112 #ifdef HAVE_LONG_DOUBLE
113 #define LDOUBLE long double
114 #else
115 #define LDOUBLE double
116 #endif
117
118 #if HAVE_LONG_LONG
119 # if defined(OPENSSL_SYS_WIN32) && !defined(__GNUC__)
120 # define LLONG __int64
121 # else
122 # define LLONG long long
123 # endif
124 #else
125 #define LLONG long
126 #endif
127
128 static void fmtstr     (char **, char **, size_t *, size_t *,
129                         const char *, int, int, int);
130 static void fmtint     (char **, char **, size_t *, size_t *,
131                         LLONG, int, int, int, int);
132 static void fmtfp      (char **, char **, size_t *, size_t *,
133                         LDOUBLE, int, int, int);
134 static void doapr_outch (char **, char **, size_t *, size_t *, int);
135 static void _dopr(char **sbuffer, char **buffer,
136                   size_t *maxlen, size_t *retlen, int *truncated,
137                   const char *format, va_list args);
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 /* some handy macros */
165 #define char_to_int(p) (p - '0')
166 #define OSSL_MAX(p,q) ((p >= q) ? p : q)
167
168 static void
169 _dopr(
170     char **sbuffer,
171     char **buffer,
172     size_t *maxlen,
173     size_t *retlen,
174     int *truncated,
175     const char *format,
176     va_list args)
177 {
178     char ch;
179     LLONG value;
180     LDOUBLE fvalue;
181     char *strvalue;
182     int min;
183     int max;
184     int state;
185     int flags;
186     int cflags;
187     size_t currlen;
188
189     state = DP_S_DEFAULT;
190     flags = currlen = cflags = min = 0;
191     max = -1;
192     ch = *format++;
193
194     while (state != DP_S_DONE) {
195         if (ch == '\0' || (buffer == NULL && currlen >= *maxlen))
196             state = DP_S_DONE;
197
198         switch (state) {
199         case DP_S_DEFAULT:
200             if (ch == '%')
201                 state = DP_S_FLAGS;
202             else
203                 doapr_outch(sbuffer,buffer, &currlen, maxlen, ch);
204             ch = *format++;
205             break;
206         case DP_S_FLAGS:
207             switch (ch) {
208             case '-':
209                 flags |= DP_F_MINUS;
210                 ch = *format++;
211                 break;
212             case '+':
213                 flags |= DP_F_PLUS;
214                 ch = *format++;
215                 break;
216             case ' ':
217                 flags |= DP_F_SPACE;
218                 ch = *format++;
219                 break;
220             case '#':
221                 flags |= DP_F_NUM;
222                 ch = *format++;
223                 break;
224             case '0':
225                 flags |= DP_F_ZERO;
226                 ch = *format++;
227                 break;
228             default:
229                 state = DP_S_MIN;
230                 break;
231             }
232             break;
233         case DP_S_MIN:
234             if (isdigit((unsigned char)ch)) {
235                 min = 10 * min + char_to_int(ch);
236                 ch = *format++;
237             } else if (ch == '*') {
238                 min = va_arg(args, int);
239                 ch = *format++;
240                 state = DP_S_DOT;
241             } else
242                 state = DP_S_DOT;
243             break;
244         case DP_S_DOT:
245             if (ch == '.') {
246                 state = DP_S_MAX;
247                 ch = *format++;
248             } else
249                 state = DP_S_MOD;
250             break;
251         case DP_S_MAX:
252             if (isdigit((unsigned char)ch)) {
253                 if (max < 0)
254                     max = 0;
255                 max = 10 * max + char_to_int(ch);
256                 ch = *format++;
257             } else if (ch == '*') {
258                 max = va_arg(args, int);
259                 ch = *format++;
260                 state = DP_S_MOD;
261             } else
262                 state = DP_S_MOD;
263             break;
264         case DP_S_MOD:
265             switch (ch) {
266             case 'h':
267                 cflags = DP_C_SHORT;
268                 ch = *format++;
269                 break;
270             case 'l':
271                 if (*format == 'l') {
272                     cflags = DP_C_LLONG;
273                     format++;
274                 } else
275                     cflags = DP_C_LONG;
276                 ch = *format++;
277                 break;
278             case 'q':
279                 cflags = DP_C_LLONG;
280                 ch = *format++;
281                 break;
282             case 'L':
283                 cflags = DP_C_LDOUBLE;
284                 ch = *format++;
285                 break;
286             default:
287                 break;
288             }
289             state = DP_S_CONV;
290             break;
291         case DP_S_CONV:
292             switch (ch) {
293             case 'd':
294             case 'i':
295                 switch (cflags) {
296                 case DP_C_SHORT:
297                     value = (short int)va_arg(args, int);
298                     break;
299                 case DP_C_LONG:
300                     value = va_arg(args, long int);
301                     break;
302                 case DP_C_LLONG:
303                     value = va_arg(args, LLONG);
304                     break;
305                 default:
306                     value = va_arg(args, int);
307                     break;
308                 }
309                 fmtint(sbuffer, buffer, &currlen, maxlen,
310                        value, 10, min, max, flags);
311                 break;
312             case 'X':
313                 flags |= DP_F_UP;
314                 /* FALLTHROUGH */
315             case 'x':
316             case 'o':
317             case 'u':
318                 flags |= DP_F_UNSIGNED;
319                 switch (cflags) {
320                 case DP_C_SHORT:
321                     value = (unsigned short int)va_arg(args, unsigned int);
322                     break;
323                 case DP_C_LONG:
324                     value = (LLONG) va_arg(args,
325                         unsigned long int);
326                     break;
327                 case DP_C_LLONG:
328                     value = va_arg(args, unsigned LLONG);
329                     break;
330                 default:
331                     value = (LLONG) va_arg(args,
332                         unsigned int);
333                     break;
334                 }
335                 fmtint(sbuffer, buffer, &currlen, maxlen, value,
336                        ch == 'o' ? 8 : (ch == 'u' ? 10 : 16),
337                        min, max, flags);
338                 break;
339             case 'f':
340                 if (cflags == DP_C_LDOUBLE)
341                     fvalue = va_arg(args, LDOUBLE);
342                 else
343                     fvalue = va_arg(args, double);
344                 fmtfp(sbuffer, buffer, &currlen, maxlen,
345                       fvalue, min, max, flags);
346                 break;
347             case 'E':
348                 flags |= DP_F_UP;
349             case 'e':
350                 if (cflags == DP_C_LDOUBLE)
351                     fvalue = va_arg(args, LDOUBLE);
352                 else
353                     fvalue = va_arg(args, double);
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                 break;
363             case 'c':
364                 doapr_outch(sbuffer, buffer, &currlen, maxlen,
365                     va_arg(args, int));
366                 break;
367             case 's':
368                 strvalue = va_arg(args, char *);
369                 if (max < 0) {
370                     if (buffer)
371                         max = INT_MAX;
372                     else
373                         max = *maxlen;
374                 }
375                 fmtstr(sbuffer, buffer, &currlen, maxlen, strvalue,
376                        flags, min, max);
377                 break;
378             case 'p':
379                 value = (long)va_arg(args, void *);
380                 fmtint(sbuffer, buffer, &currlen, maxlen,
381                     value, 16, min, max, flags|DP_F_NUM);
382                 break;
383             case 'n': /* XXX */
384                 if (cflags == DP_C_SHORT) {
385                     short int *num;
386                     num = va_arg(args, short int *);
387                     *num = currlen;
388                 } else if (cflags == DP_C_LONG) { /* XXX */
389                     long int *num;
390                     num = va_arg(args, long int *);
391                     *num = (long int) currlen;
392                 } else if (cflags == DP_C_LLONG) { /* XXX */
393                     LLONG *num;
394                     num = va_arg(args, LLONG *);
395                     *num = (LLONG) currlen;
396                 } else {
397                     int    *num;
398                     num = va_arg(args, int *);
399                     *num = currlen;
400                 }
401                 break;
402             case '%':
403                 doapr_outch(sbuffer, buffer, &currlen, maxlen, ch);
404                 break;
405             case 'w':
406                 /* not supported yet, treat as next char */
407                 ch = *format++;
408                 break;
409             default:
410                 /* unknown, skip */
411                 break;
412             }
413             ch = *format++;
414             state = DP_S_DEFAULT;
415             flags = cflags = min = 0;
416             max = -1;
417             break;
418         case DP_S_DONE:
419             break;
420         default:
421             break;
422         }
423     }
424     *truncated = (currlen > *maxlen - 1);
425     if (*truncated)
426         currlen = *maxlen - 1;
427     doapr_outch(sbuffer, buffer, &currlen, maxlen, '\0');
428     *retlen = currlen - 1;
429     return;
430 }
431
432 static void
433 fmtstr(
434     char **sbuffer,
435     char **buffer,
436     size_t *currlen,
437     size_t *maxlen,
438     const char *value,
439     int flags,
440     int min,
441     int max)
442 {
443     int padlen, strln;
444     int cnt = 0;
445
446     if (value == 0)
447         value = "<NULL>";
448     for (strln = 0; value[strln]; ++strln)
449         ;
450     padlen = min - strln;
451     if (padlen < 0)
452         padlen = 0;
453     if (flags & DP_F_MINUS)
454         padlen = -padlen;
455
456     while ((padlen > 0) && (cnt < max)) {
457         doapr_outch(sbuffer, buffer, currlen, maxlen, ' ');
458         --padlen;
459         ++cnt;
460     }
461     while (*value && (cnt < max)) {
462         doapr_outch(sbuffer, buffer, currlen, maxlen, *value++);
463         ++cnt;
464     }
465     while ((padlen < 0) && (cnt < max)) {
466         doapr_outch(sbuffer, buffer, currlen, maxlen, ' ');
467         ++padlen;
468         ++cnt;
469     }
470 }
471
472 static void
473 fmtint(
474     char **sbuffer,
475     char **buffer,
476     size_t *currlen,
477     size_t *maxlen,
478     LLONG value,
479     int base,
480     int min,
481     int max,
482     int flags)
483 {
484     int signvalue = 0;
485     const char *prefix = "";
486     unsigned LLONG uvalue;
487     char convert[DECIMAL_SIZE(value)+3];
488     int place = 0;
489     int spadlen = 0;
490     int zpadlen = 0;
491     int caps = 0;
492
493     if (max < 0)
494         max = 0;
495     uvalue = value;
496     if (!(flags & DP_F_UNSIGNED)) {
497         if (value < 0) {
498             signvalue = '-';
499             uvalue = -value;
500         } else if (flags & DP_F_PLUS)
501             signvalue = '+';
502         else if (flags & DP_F_SPACE)
503             signvalue = ' ';
504     }
505     if (flags & DP_F_NUM) {
506         if (base == 8) prefix = "0";
507         if (base == 16) prefix = "0x";
508     }
509     if (flags & DP_F_UP)
510         caps = 1;
511     do {
512         convert[place++] =
513             (caps ? "0123456789ABCDEF" : "0123456789abcdef")
514             [uvalue % (unsigned) base];
515         uvalue = (uvalue / (unsigned) base);
516     } while (uvalue && (place < (int)sizeof(convert)));
517     if (place == sizeof(convert))
518         place--;
519     convert[place] = 0;
520
521     zpadlen = max - place;
522     spadlen = min - OSSL_MAX(max, place) - (signvalue ? 1 : 0) - strlen(prefix);
523     if (zpadlen < 0)
524         zpadlen = 0;
525     if (spadlen < 0)
526         spadlen = 0;
527     if (flags & DP_F_ZERO) {
528         zpadlen = OSSL_MAX(zpadlen, spadlen);
529         spadlen = 0;
530     }
531     if (flags & DP_F_MINUS)
532         spadlen = -spadlen;
533
534     /* spaces */
535     while (spadlen > 0) {
536         doapr_outch(sbuffer, buffer, currlen, maxlen, ' ');
537         --spadlen;
538     }
539
540     /* sign */
541     if (signvalue)
542         doapr_outch(sbuffer, buffer, currlen, maxlen, signvalue);
543
544     /* prefix */
545     while (*prefix) {
546         doapr_outch(sbuffer, buffer, currlen, maxlen, *prefix);
547         prefix++;
548     }
549
550     /* zeros */
551     if (zpadlen > 0) {
552         while (zpadlen > 0) {
553             doapr_outch(sbuffer, buffer, currlen, maxlen, '0');
554             --zpadlen;
555         }
556     }
557     /* digits */
558     while (place > 0)
559         doapr_outch(sbuffer, buffer, currlen, maxlen, convert[--place]);
560
561     /* left justified spaces */
562     while (spadlen < 0) {
563         doapr_outch(sbuffer, buffer, currlen, maxlen, ' ');
564         ++spadlen;
565     }
566     return;
567 }
568
569 static LDOUBLE
570 abs_val(LDOUBLE value)
571 {
572     LDOUBLE result = value;
573     if (value < 0)
574         result = -value;
575     return result;
576 }
577
578 static LDOUBLE
579 pow_10(int in_exp)
580 {
581     LDOUBLE result = 1;
582     while (in_exp) {
583         result *= 10;
584         in_exp--;
585     }
586     return result;
587 }
588
589 static long
590 roundv(LDOUBLE value)
591 {
592     long intpart;
593     intpart = (long) value;
594     value = value - intpart;
595     if (value >= 0.5)
596         intpart++;
597     return intpart;
598 }
599
600 static void
601 fmtfp(
602     char **sbuffer,
603     char **buffer,
604     size_t *currlen,
605     size_t *maxlen,
606     LDOUBLE fvalue,
607     int min,
608     int max,
609     int flags)
610 {
611     int signvalue = 0;
612     LDOUBLE ufvalue;
613     char iconvert[20];
614     char fconvert[20];
615     int iplace = 0;
616     int fplace = 0;
617     int padlen = 0;
618     int zpadlen = 0;
619     int caps = 0;
620     long intpart;
621     long fracpart;
622     long max10;
623
624     if (max < 0)
625         max = 6;
626     ufvalue = abs_val(fvalue);
627     if (fvalue < 0)
628         signvalue = '-';
629     else if (flags & DP_F_PLUS)
630         signvalue = '+';
631     else if (flags & DP_F_SPACE)
632         signvalue = ' ';
633
634     intpart = (long)ufvalue;
635
636     /* sorry, we only support 9 digits past the decimal because of our
637        conversion method */
638     if (max > 9)
639         max = 9;
640
641     /* we "cheat" by converting the fractional part to integer by
642        multiplying by a factor of 10 */
643     max10 = roundv(pow_10(max));
644     fracpart = roundv(pow_10(max) * (ufvalue - intpart));
645
646     if (fracpart >= max10) {
647         intpart++;
648         fracpart -= max10;
649     }
650
651     /* convert integer part */
652     do {
653         iconvert[iplace++] =
654             (caps ? "0123456789ABCDEF"
655               : "0123456789abcdef")[intpart % 10];
656         intpart = (intpart / 10);
657     } while (intpart && (iplace < (int)sizeof(iconvert)));
658     if (iplace == sizeof iconvert)
659         iplace--;
660     iconvert[iplace] = 0;
661
662     /* convert fractional part */
663     do {
664         fconvert[fplace++] =
665             (caps ? "0123456789ABCDEF"
666               : "0123456789abcdef")[fracpart % 10];
667         fracpart = (fracpart / 10);
668     } while (fplace < max);
669     if (fplace == sizeof fconvert)
670         fplace--;
671     fconvert[fplace] = 0;
672
673     /* -1 for decimal point, another -1 if we are printing a sign */
674     padlen = min - iplace - max - 1 - ((signvalue) ? 1 : 0);
675     zpadlen = max - fplace;
676     if (zpadlen < 0)
677         zpadlen = 0;
678     if (padlen < 0)
679         padlen = 0;
680     if (flags & DP_F_MINUS)
681         padlen = -padlen;
682
683     if ((flags & DP_F_ZERO) && (padlen > 0)) {
684         if (signvalue) {
685             doapr_outch(sbuffer, buffer, currlen, maxlen, signvalue);
686             --padlen;
687             signvalue = 0;
688         }
689         while (padlen > 0) {
690             doapr_outch(sbuffer, buffer, currlen, maxlen, '0');
691             --padlen;
692         }
693     }
694     while (padlen > 0) {
695         doapr_outch(sbuffer, buffer, currlen, maxlen, ' ');
696         --padlen;
697     }
698     if (signvalue)
699         doapr_outch(sbuffer, buffer, currlen, maxlen, signvalue);
700
701     while (iplace > 0)
702         doapr_outch(sbuffer, buffer, currlen, maxlen, iconvert[--iplace]);
703
704     /*
705      * Decimal point. This should probably use locale to find the correct
706      * char to print out.
707      */
708     if (max > 0 || (flags & DP_F_NUM)) {
709         doapr_outch(sbuffer, buffer, currlen, maxlen, '.');
710
711         while (fplace > 0)
712             doapr_outch(sbuffer, buffer, currlen, maxlen, fconvert[--fplace]);
713     }
714     while (zpadlen > 0) {
715         doapr_outch(sbuffer, buffer, currlen, maxlen, '0');
716         --zpadlen;
717     }
718
719     while (padlen < 0) {
720         doapr_outch(sbuffer, buffer, currlen, maxlen, ' ');
721         ++padlen;
722     }
723 }
724
725 static void
726 doapr_outch(
727     char **sbuffer,
728     char **buffer,
729     size_t *currlen,
730     size_t *maxlen,
731     int c)
732 {
733     /* If we haven't at least one buffer, someone has doe a big booboo */
734     assert(*sbuffer != NULL || buffer != NULL);
735
736     if (buffer) {
737         while (*currlen >= *maxlen) {
738             if (*buffer == NULL) {
739                 if (*maxlen == 0)
740                     *maxlen = 1024;
741                 *buffer = OPENSSL_malloc(*maxlen);
742                 if (*currlen > 0) {
743                     assert(*sbuffer != NULL);
744                     memcpy(*buffer, *sbuffer, *currlen);
745                 }
746                 *sbuffer = NULL;
747             } else {
748                 *maxlen += 1024;
749                 *buffer = OPENSSL_realloc(*buffer, *maxlen);
750             }
751         }
752         /* What to do if *buffer is NULL? */
753         assert(*sbuffer != NULL || *buffer != NULL);
754     }
755
756     if (*currlen < *maxlen) {
757         if (*sbuffer)
758             (*sbuffer)[(*currlen)++] = (char)c;
759         else
760             (*buffer)[(*currlen)++] = (char)c;
761     }
762
763     return;
764 }
765
766 /***************************************************************************/
767
768 int BIO_printf (BIO *bio, const char *format, ...)
769         {
770         va_list args;
771         int ret;
772
773         va_start(args, format);
774
775         ret = BIO_vprintf(bio, format, args);
776
777         va_end(args);
778         return(ret);
779         }
780
781 int BIO_vprintf (BIO *bio, const char *format, va_list args)
782         {
783         int ret;
784         size_t retlen;
785         char hugebuf[1024*2];   /* Was previously 10k, which is unreasonable
786                                    in small-stack environments, like threads
787                                    or DOS programs. */
788         char *hugebufp = hugebuf;
789         size_t hugebufsize = sizeof(hugebuf);
790         char *dynbuf = NULL;
791         int ignored;
792
793         dynbuf = NULL;
794         CRYPTO_push_info("doapr()");
795         _dopr(&hugebufp, &dynbuf, &hugebufsize,
796                 &retlen, &ignored, format, args);
797         if (dynbuf)
798                 {
799                 ret=BIO_write(bio, dynbuf, (int)retlen);
800                 OPENSSL_free(dynbuf);
801                 }
802         else
803                 {
804                 ret=BIO_write(bio, hugebuf, (int)retlen);
805                 }
806         CRYPTO_pop_info();
807         return(ret);
808         }
809
810 /* As snprintf is not available everywhere, we provide our own implementation.
811  * This function has nothing to do with BIOs, but it's closely related
812  * to BIO_printf, and we need *some* name prefix ...
813  * (XXX  the function should be renamed, but to what?) */
814 int BIO_snprintf(char *buf, size_t n, const char *format, ...)
815         {
816         va_list args;
817         int ret;
818
819         va_start(args, format);
820
821         ret = BIO_vsnprintf(buf, n, format, args);
822
823         va_end(args);
824         return(ret);
825         }
826
827 int BIO_vsnprintf(char *buf, size_t n, const char *format, va_list args)
828         {
829         size_t retlen;
830         int truncated;
831
832         _dopr(&buf, NULL, &n, &retlen, &truncated, format, args);
833
834         if (truncated)
835                 /* In case of truncation, return -1 like traditional snprintf.
836                  * (Current drafts for ISO/IEC 9899 say snprintf should return
837                  * the number of characters that would have been written,
838                  * had the buffer been large enough.) */
839                 return -1;
840         else
841                 return (retlen <= INT_MAX) ? (int)retlen : -1;
842         }