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