/* crypto/bio/b_print.c */

 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)

  * All rights reserved.

  *

  * This package is an SSL implementation written

  * by Eric Young (eay@cryptsoft.com).

  * The implementation was written so as to conform with Netscapes SSL.

  * 

  * This library is free for commercial and non-commercial use as long as

  * the following conditions are aheared to.  The following conditions

  * apply to all code found in this distribution, be it the RC4, RSA,

  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation

  * included with this distribution is covered by the same copyright terms

  * except that the holder is Tim Hudson (tjh@cryptsoft.com).

  * 

  * Copyright remains Eric Young's, and as such any Copyright notices in

  * the code are not to be removed.

  * If this package is used in a product, Eric Young should be given attribution

  * as the author of the parts of the library used.

  * This can be in the form of a textual message at program startup or

  * in documentation (online or textual) provided with the package.

  * 

  * Redistribution and use in source and binary forms, with or without

  * modification, are permitted provided that the following conditions

  * are met:

  * 1. Redistributions of source code must retain the copyright

  *    notice, this list of conditions and the following disclaimer.

  * 2. Redistributions in binary form must reproduce the above copyright

  *    notice, this list of conditions and the following disclaimer in the

  *    documentation and/or other materials provided with the distribution.

  * 3. All advertising materials mentioning features or use of this software

  *    must display the following acknowledgement:

  *    "This product includes cryptographic software written by

  *     Eric Young (eay@cryptsoft.com)"

  *    The word 'cryptographic' can be left out if the rouines from the library

  *    being used are not cryptographic related :-).

  * 4. If you include any Windows specific code (or a derivative thereof) from 

  *    the apps directory (application code) you must include an acknowledgement:

  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"

  * 

  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND

  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE

  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

  * SUCH DAMAGE.

  * 

  * The licence and distribution terms for any publically available version or

  * derivative of this code cannot be changed.  i.e. this code cannot simply be

  * copied and put under another distribution licence

  * [including the GNU Public Licence.]

  */

 /*

  © Portions copyright (c) 2006 Nokia Corporation.  All rights reserved.

  */

 /* disable assert() unless BIO_DEBUG has been defined */

 #ifndef BIO_DEBUG

 # ifndef NDEBUG

 #  define NDEBUG

 # endif

 #endif

 /* 

  * Stolen from tjh's ssl/ssl_trc.c stuff.

  */

 #include <stdio.h>

 #include <string.h>

 #include <ctype.h>

 #include <assert.h>

 #include <limits.h>

 #include "cryptlib.h"

 #ifndef NO_SYS_TYPES_H

 #include <sys/types.h>

 #endif

 #include <openssl/bn.h>         /* To get BN_LLONG properly defined */

 #include <openssl/bio.h>

 #if defined(BN_LLONG) || defined(SIXTY_FOUR_BIT)

 # ifndef HAVE_LONG_LONG

 #  define HAVE_LONG_LONG 1

 # endif

 #endif

 /***************************************************************************/

 /*

  * Copyright Patrick Powell 1995

  * This code is based on code written by Patrick Powell <papowell@astart.com>

  * It may be used for any purpose as long as this notice remains intact

  * on all source code distributions.

  */

 /*

  * This code contains numerious changes and enhancements which were

  * made by lots of contributors over the last years to Patrick Powell's

  * original code:

  *

  * o Patrick Powell <papowell@astart.com>      (1995)

  * o Brandon Long <blong@fiction.net>          (1996, for Mutt)

  * o Thomas Roessler <roessler@guug.de>        (1998, for Mutt)

  * o Michael Elkins <me@cs.hmc.edu>            (1998, for Mutt)

  * o Andrew Tridgell <tridge@samba.org>        (1998, for Samba)

  * o Luke Mewburn <lukem@netbsd.org>           (1999, for LukemFTP)

  * o Ralf S. Engelschall <rse@engelschall.com> (1999, for Pth)

  * o ...                                       (for OpenSSL)

  */

 #ifdef HAVE_LONG_DOUBLE

 #define LDOUBLE long double

 #else

 #define LDOUBLE double

 #endif

 #if HAVE_LONG_LONG

 # if defined(OPENSSL_SYS_WIN32) && !defined(__GNUC__)

 # define LLONG __int64

 # else

 # define LLONG long long

 # endif

 #else

 #define LLONG long

 #endif

 static void fmtstr     (char **, char **, size_t *, size_t *,

 			const char *, int, int, int);

 static void fmtint     (char **, char **, size_t *, size_t *,

 			LLONG, int, int, int, int);

 static void fmtfp      (char **, char **, size_t *, size_t *,

 			LDOUBLE, int, int, int);

 static void doapr_outch (char **, char **, size_t *, size_t *, int);

 static void _dopr(char **sbuffer, char **buffer,

 		  size_t *maxlen, size_t *retlen, int *truncated,

 		  const char *format, va_list args);

 /* format read states */

 #define DP_S_DEFAULT    0

 #define DP_S_FLAGS      1

 #define DP_S_MIN        2

 #define DP_S_DOT        3

 #define DP_S_MAX        4

 #define DP_S_MOD        5

 #define DP_S_CONV       6

 #define DP_S_DONE       7

 /* format flags - Bits */

 #define DP_F_MINUS      (1 << 0)

 #define DP_F_PLUS       (1 << 1)

 #define DP_F_SPACE      (1 << 2)

 #define DP_F_NUM        (1 << 3)

 #define DP_F_ZERO       (1 << 4)

 #define DP_F_UP         (1 << 5)

 #define DP_F_UNSIGNED   (1 << 6)

 /* conversion flags */

 #define DP_C_SHORT      1

 #define DP_C_LONG       2

 #define DP_C_LDOUBLE    3

 #define DP_C_LLONG      4

 /* some handy macros */

 #define char_to_int(p) (p - '0')

 #define OSSL_MAX(p,q) ((p >= q) ? p : q)

 static void

 _dopr(

     char **sbuffer,

     char **buffer,

     size_t *maxlen,

     size_t *retlen,

     int *truncated,

     const char *format,

     va_list args)

 {

     char ch;

     LLONG value;

     LDOUBLE fvalue;

     char *strvalue;

     int min;

     int max;

     int state;

     int flags;

     int cflags;

     size_t currlen;

     state = DP_S_DEFAULT;

     flags = currlen = cflags = min = 0;

     max = -1;

     ch = *format++;

     while (state != DP_S_DONE) {

         if (ch == '\0' || (buffer == NULL && currlen >= *maxlen))

             state = DP_S_DONE;

         switch (state) {

         case DP_S_DEFAULT:

             if (ch == '%')

                 state = DP_S_FLAGS;

             else

                 doapr_outch(sbuffer,buffer, &currlen, maxlen, ch);

             ch = *format++;

             break;

         case DP_S_FLAGS:

             switch (ch) {

             case '-':

                 flags |= DP_F_MINUS;

                 ch = *format++;

                 break;

             case '+':

                 flags |= DP_F_PLUS;

                 ch = *format++;

                 break;

             case ' ':

                 flags |= DP_F_SPACE;

                 ch = *format++;

                 break;

             case '#':

                 flags |= DP_F_NUM;

                 ch = *format++;

                 break;

             case '0':

                 flags |= DP_F_ZERO;

                 ch = *format++;

                 break;

             default:

                 state = DP_S_MIN;

                 break;

             }

             break;

         case DP_S_MIN:

             if (isdigit((unsigned char)ch)) {

                 min = 10 * min + char_to_int(ch);

                 ch = *format++;

             } else if (ch == '*') {

                 min = va_arg(args, int);

                 ch = *format++;

                 state = DP_S_DOT;

             } else

                 state = DP_S_DOT;

             break;

         case DP_S_DOT:

             if (ch == '.') {

                 state = DP_S_MAX;

                 ch = *format++;

             } else

                 state = DP_S_MOD;

             break;

         case DP_S_MAX:

             if (isdigit((unsigned char)ch)) {

                 if (max < 0)

                     max = 0;

                 max = 10 * max + char_to_int(ch);

                 ch = *format++;

             } else if (ch == '*') {

                 max = va_arg(args, int);

                 ch = *format++;

                 state = DP_S_MOD;

             } else

                 state = DP_S_MOD;

             break;

         case DP_S_MOD:

             switch (ch) {

             case 'h':

                 cflags = DP_C_SHORT;

                 ch = *format++;

                 break;

             case 'l':

                 if (*format == 'l') {

                     cflags = DP_C_LLONG;

                     format++;

                 } else

                     cflags = DP_C_LONG;

                 ch = *format++;

                 break;

             case 'q':

                 cflags = DP_C_LLONG;

                 ch = *format++;

                 break;

             case 'L':

                 cflags = DP_C_LDOUBLE;

                 ch = *format++;

                 break;

             default:

                 break;

             }

             state = DP_S_CONV;

             break;

         case DP_S_CONV:

             switch (ch) {

             case 'd':

             case 'i':

                 switch (cflags) {

                 case DP_C_SHORT:

                     value = (short int)va_arg(args, int);

                     break;

                 case DP_C_LONG:

                     value = va_arg(args, long int);

                     break;

                 case DP_C_LLONG:

                     value = va_arg(args, LLONG);

                     break;

                 default:

                     value = va_arg(args, int);

                     break;

                 }

                 fmtint(sbuffer, buffer, &currlen, maxlen,

                        value, 10, min, max, flags);

                 break;

             case 'X':

                 flags |= DP_F_UP;

                 /* FALLTHROUGH */

             case 'x':

             case 'o':

             case 'u':

                 flags |= DP_F_UNSIGNED;

                 switch (cflags) {

                 case DP_C_SHORT:

                     value = (unsigned short int)va_arg(args, unsigned int);

                     break;

                 case DP_C_LONG:

                     value = (LLONG) va_arg(args,

                         unsigned long int);

                     break;

                 case DP_C_LLONG:

                     value = va_arg(args, unsigned LLONG);

                     break;

                 default:

                     value = (LLONG) va_arg(args,

                         unsigned int);

                     break;

                 }

                 fmtint(sbuffer, buffer, &currlen, maxlen, value,

                        ch == 'o' ? 8 : (ch == 'u' ? 10 : 16),

                        min, max, flags);

                 break;

             case 'f':

                 if (cflags == DP_C_LDOUBLE)

                     fvalue = va_arg(args, LDOUBLE);

                 else

                     fvalue = va_arg(args, double);

                 fmtfp(sbuffer, buffer, &currlen, maxlen,

                       fvalue, min, max, flags);

                 break;

             case 'E':

                 flags |= DP_F_UP;

             case 'e':

                 if (cflags == DP_C_LDOUBLE)

                     fvalue = va_arg(args, LDOUBLE);

                 else

                     fvalue = va_arg(args, double);

                 break;

             case 'G':

                 flags |= DP_F_UP;

             case 'g':

                 if (cflags == DP_C_LDOUBLE)

                     fvalue = va_arg(args, LDOUBLE);

                 else

                     fvalue = va_arg(args, double);

                 break;

             case 'c':

                 doapr_outch(sbuffer, buffer, &currlen, maxlen,

                     va_arg(args, int));

                 break;

             case 's':

                 strvalue = va_arg(args, char *);

                 if (max < 0) {

 		    if (buffer)

 			max = INT_MAX;

 		    else

 			max = *maxlen;

 		}

                 fmtstr(sbuffer, buffer, &currlen, maxlen, strvalue,

                        flags, min, max);

                 break;

             case 'p':

                 value = (long)va_arg(args, void *);

                 fmtint(sbuffer, buffer, &currlen, maxlen,

                     value, 16, min, max, flags|DP_F_NUM);

                 break;

             case 'n': /* XXX */

                 if (cflags == DP_C_SHORT) {

                     short int *num;

                     num = va_arg(args, short int *);

                     *num = currlen;

                 } else if (cflags == DP_C_LONG) { /* XXX */

                     long int *num;

                     num = va_arg(args, long int *);

                     *num = (long int) currlen;

                 } else if (cflags == DP_C_LLONG) { /* XXX */

                     LLONG *num;

                     num = va_arg(args, LLONG *);

                     *num = (LLONG) currlen;

                 } else {

                     int    *num;

                     num = va_arg(args, int *);

                     *num = currlen;

                 }

                 break;

             case '%':

                 doapr_outch(sbuffer, buffer, &currlen, maxlen, ch);

                 break;

             case 'w':

                 /* not supported yet, treat as next char */

                 ch = *format++;

                 break;

             default:

                 /* unknown, skip */

                 break;

             }

             ch = *format++;

             state = DP_S_DEFAULT;

             flags = cflags = min = 0;

             max = -1;

             break;

         case DP_S_DONE:

             break;

         default:

             break;

         }

     }

     *truncated = (currlen > *maxlen - 1);

     if (*truncated)

         currlen = *maxlen - 1;

     doapr_outch(sbuffer, buffer, &currlen, maxlen, '\0');

     *retlen = currlen - 1;

     return;

 }

 static void

 fmtstr(

     char **sbuffer,

     char **buffer,

     size_t *currlen,

     size_t *maxlen,

     const char *value,

     int flags,

     int min,

     int max)

 {

     int padlen, strln;

     int cnt = 0;

     if (value == 0)

         value = "<NULL>";

     for (strln = 0; value[strln]; ++strln)

         ;

     padlen = min - strln;

     if (padlen < 0)

         padlen = 0;

     if (flags & DP_F_MINUS)

         padlen = -padlen;

     while ((padlen > 0) && (cnt < max)) {

         doapr_outch(sbuffer, buffer, currlen, maxlen, ' ');

         --padlen;

         ++cnt;

     }

     while (*value && (cnt < max)) {

         doapr_outch(sbuffer, buffer, currlen, maxlen, *value++);

         ++cnt;

     }

     while ((padlen < 0) && (cnt < max)) {

         doapr_outch(sbuffer, buffer, currlen, maxlen, ' ');

         ++padlen;

         ++cnt;

     }

 }

 static void

 fmtint(

     char **sbuffer,

     char **buffer,

     size_t *currlen,

     size_t *maxlen,

     LLONG value,

     int base,

     int min,

     int max,

     int flags)

 {

     int signvalue = 0;

     const char *prefix = "";

     unsigned LLONG uvalue;

     char convert[DECIMAL_SIZE(value)+3];

     int place = 0;

     int spadlen = 0;

     int zpadlen = 0;

     int caps = 0;

     if (max < 0)

         max = 0;

     uvalue = value;

     if (!(flags & DP_F_UNSIGNED)) {

         if (value < 0) {

             signvalue = '-';

             uvalue = -value;

         } else if (flags & DP_F_PLUS)

             signvalue = '+';

         else if (flags & DP_F_SPACE)

             signvalue = ' ';

     }

     if (flags & DP_F_NUM) {

 	if (base == 8) prefix = "0";

 	if (base == 16) prefix = "0x";

     }

     if (flags & DP_F_UP)

         caps = 1;

     do {

         convert[place++] =

             (caps ? "0123456789ABCDEF" : "0123456789abcdef")

             [uvalue % (unsigned) base];

         uvalue = (uvalue / (unsigned) base);

     } while (uvalue && (place < (int)sizeof(convert)));

     if (place == sizeof(convert))

         place--;

     convert[place] = 0;

     zpadlen = max - place;

     spadlen = min - OSSL_MAX(max, place) - (signvalue ? 1 : 0) - strlen(prefix);

     if (zpadlen < 0)

         zpadlen = 0;

     if (spadlen < 0)

         spadlen = 0;

     if (flags & DP_F_ZERO) {

         zpadlen = OSSL_MAX(zpadlen, spadlen);

         spadlen = 0;

     }

     if (flags & DP_F_MINUS)

         spadlen = -spadlen;

     /* spaces */

     while (spadlen > 0) {

         doapr_outch(sbuffer, buffer, currlen, maxlen, ' ');

         --spadlen;

     }

     /* sign */

     if (signvalue)

         doapr_outch(sbuffer, buffer, currlen, maxlen, signvalue);

     /* prefix */

     while (*prefix) {

 	doapr_outch(sbuffer, buffer, currlen, maxlen, *prefix);

 	prefix++;

     }

     /* zeros */

     if (zpadlen > 0) {

         while (zpadlen > 0) {

             doapr_outch(sbuffer, buffer, currlen, maxlen, '0');

             --zpadlen;

         }

     }

     /* digits */

     while (place > 0)

         doapr_outch(sbuffer, buffer, currlen, maxlen, convert[--place]);

     /* left justified spaces */

     while (spadlen < 0) {

         doapr_outch(sbuffer, buffer, currlen, maxlen, ' ');

         ++spadlen;

     }

     return;

 }

 static LDOUBLE

 abs_val(LDOUBLE value)

 {

     LDOUBLE result = value;

     if (value < 0)

         result = -value;

     return result;

 }

 static LDOUBLE

 pow_10(int in_exp)

 {

     LDOUBLE result = 1;

     while (in_exp) {

         result *= 10;

         in_exp--;

     }

     return result;

 }

 static long

 roundv(LDOUBLE value)

 {

     long intpart;

     intpart = (long) value;

     value = value - intpart;

     if (value >= 0.5)

         intpart++;

     return intpart;

 }

 static void

 fmtfp(

     char **sbuffer,

     char **buffer,

     size_t *currlen,

     size_t *maxlen,

     LDOUBLE fvalue,

     int min,

     int max,

     int flags)

 {

     int signvalue = 0;

     LDOUBLE ufvalue;

     char iconvert[20];

     char fconvert[20];

     int iplace = 0;

     int fplace = 0;

     int padlen = 0;

     int zpadlen = 0;

     int caps = 0;

     long intpart;

     long fracpart;

     long max10;

     if (max < 0)

         max = 6;

     ufvalue = abs_val(fvalue);

     if (fvalue < 0)

         signvalue = '-';

     else if (flags & DP_F_PLUS)

         signvalue = '+';

     else if (flags & DP_F_SPACE)

         signvalue = ' ';

     intpart = (long)ufvalue;

     /* sorry, we only support 9 digits past the decimal because of our

        conversion method */

     if (max > 9)

         max = 9;

     /* we "cheat" by converting the fractional part to integer by

        multiplying by a factor of 10 */

     max10 = roundv(pow_10(max));

     fracpart = roundv(pow_10(max) * (ufvalue - intpart));

     if (fracpart >= max10) {

         intpart++;

         fracpart -= max10;

     }

     /* convert integer part */

     do {

         iconvert[iplace++] =

             (caps ? "0123456789ABCDEF"

               : "0123456789abcdef")[intpart % 10];

         intpart = (intpart / 10);

     } while (intpart && (iplace < (int)sizeof(iconvert)));

     if (iplace == sizeof iconvert)

         iplace--;

     iconvert[iplace] = 0;

     /* convert fractional part */

     do {

         fconvert[fplace++] =

             (caps ? "0123456789ABCDEF"

               : "0123456789abcdef")[fracpart % 10];

         fracpart = (fracpart / 10);

     } while (fplace < max);

     if (fplace == sizeof fconvert)

         fplace--;

     fconvert[fplace] = 0;

     /* -1 for decimal point, another -1 if we are printing a sign */

     padlen = min - iplace - max - 1 - ((signvalue) ? 1 : 0);

     zpadlen = max - fplace;

     if (zpadlen < 0)

         zpadlen = 0;

     if (padlen < 0)

         padlen = 0;

     if (flags & DP_F_MINUS)

         padlen = -padlen;

     if ((flags & DP_F_ZERO) && (padlen > 0)) {

         if (signvalue) {

             doapr_outch(sbuffer, buffer, currlen, maxlen, signvalue);

             --padlen;

             signvalue = 0;

         }

         while (padlen > 0) {

             doapr_outch(sbuffer, buffer, currlen, maxlen, '0');

             --padlen;

         }

     }

     while (padlen > 0) {

         doapr_outch(sbuffer, buffer, currlen, maxlen, ' ');

         --padlen;

     }

     if (signvalue)

         doapr_outch(sbuffer, buffer, currlen, maxlen, signvalue);

     while (iplace > 0)

         doapr_outch(sbuffer, buffer, currlen, maxlen, iconvert[--iplace]);

     /*

      * Decimal point. This should probably use locale to find the correct

      * char to print out.

      */

     if (max > 0 || (flags & DP_F_NUM)) {

         doapr_outch(sbuffer, buffer, currlen, maxlen, '.');

         while (fplace > 0)

             doapr_outch(sbuffer, buffer, currlen, maxlen, fconvert[--fplace]);

     }

     while (zpadlen > 0) {

         doapr_outch(sbuffer, buffer, currlen, maxlen, '0');

         --zpadlen;

     }

     while (padlen < 0) {

         doapr_outch(sbuffer, buffer, currlen, maxlen, ' ');

         ++padlen;

     }

 }

 static void

 doapr_outch(

     char **sbuffer,

     char **buffer,

     size_t *currlen,

     size_t *maxlen,

     int c)

 {

     /* If we haven't at least one buffer, someone has doe a big booboo */

     assert(*sbuffer != NULL || buffer != NULL);

     if (buffer) {

 	while (*currlen >= *maxlen) {

 	    if (*buffer == NULL) {

 		if (*maxlen == 0)

 		    *maxlen = 1024;

 		*buffer = OPENSSL_malloc(*maxlen);

 		if (*currlen > 0) {

 		    assert(*sbuffer != NULL);

 		    memcpy(*buffer, *sbuffer, *currlen);

 		}

 		*sbuffer = NULL;

 	    } else {

 		*maxlen += 1024;

 		*buffer = OPENSSL_realloc(*buffer, *maxlen);

 	    }

 	}

 	/* What to do if *buffer is NULL? */

 	assert(*sbuffer != NULL || *buffer != NULL);

     }

     if (*currlen < *maxlen) {

 	if (*sbuffer)

 	    (*sbuffer)[(*currlen)++] = (char)c;

 	else

 	    (*buffer)[(*currlen)++] = (char)c;

     }

     return;

 }

 /***************************************************************************/

 EXPORT_C int BIO_printf (BIO *bio, const char *format, ...)

 	{

 	va_list args;

 	int ret;

 	va_start(args, format);

 	ret = BIO_vprintf(bio, format, args);

 	va_end(args);

 	return(ret);

 	}

 EXPORT_C int BIO_vprintf (BIO *bio, const char *format, va_list args)

 	{

 	int ret;

 	size_t retlen;

 	#ifndef SYMBIAN

 	char hugebuf[1024*2];	/* Was previously 10k, which is unreasonable

 				   in small-stack environments, like threads

 				   or DOS programs. */

 #else

   char hugebuf[512];

 #endif				   

 	char *hugebufp = hugebuf;

 	size_t hugebufsize = sizeof(hugebuf);

 	char *dynbuf = NULL;

 	int ignored;

 	dynbuf = NULL;

 	CRYPTO_push_info("doapr()");

 	_dopr(&hugebufp, &dynbuf, &hugebufsize,

 		&retlen, &ignored, format, args);

 	if (dynbuf)

 		{

 		ret=BIO_write(bio, dynbuf, (int)retlen);

 		OPENSSL_free(dynbuf);

 		}

 	else

 		{

 		ret=BIO_write(bio, hugebuf, (int)retlen);

 		}

 	CRYPTO_pop_info();

 	return(ret);

 	}

 /* As snprintf is not available everywhere, we provide our own implementation.

  * This function has nothing to do with BIOs, but it's closely related

  * to BIO_printf, and we need *some* name prefix ...

  * (XXX  the function should be renamed, but to what?) */

 EXPORT_C int BIO_snprintf(char *buf, size_t n, const char *format, ...)

 	{

 	va_list args;

 	int ret;

 	va_start(args, format);

 	ret = BIO_vsnprintf(buf, n, format, args);

 	va_end(args);

 	return(ret);

 	}

 EXPORT_C int BIO_vsnprintf(char *buf, size_t n, const char *format, va_list args)

 	{

 	size_t retlen;

 	int truncated;

 	_dopr(&buf, NULL, &n, &retlen, &truncated, format, args);

 	if (truncated)

 		/* In case of truncation, return -1 like traditional snprintf.

 		 * (Current drafts for ISO/IEC 9899 say snprintf should return

 		 * the number of characters that would have been written,

 		 * had the buffer been large enough.) */

 		return -1;

 	else

 		return (retlen <= INT_MAX) ? (int)retlen : -1;

 	}