Coverage Report

Created: 2023-06-07 07:24

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