Coverage Report

Created: 2024-11-21 07:03

/src/openssl/crypto/bio/bio_print.c
Line
Count
Source (jump to first uncovered line)
1
/*
2
 * Copyright 1995-2023 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
81.4k
# 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
354k
#define DP_S_DEFAULT    0
46
250k
#define DP_S_FLAGS      1
47
320k
#define DP_S_MIN        2
48
179k
#define DP_S_DOT        3
49
0
#define DP_S_MAX        4
50
179k
#define DP_S_MOD        5
51
179k
#define DP_S_CONV       6
52
1.16M
#define DP_S_DONE       7
53
54
/* format flags - Bits */
55
/* left-aligned padding */
56
89.9k
#define DP_F_MINUS      (1 << 0)
57
/* print an explicit '+' for a value with positive sign */
58
2.82k
#define DP_F_PLUS       (1 << 1)
59
/* print an explicit ' ' for a value with positive sign */
60
2.82k
#define DP_F_SPACE      (1 << 2)
61
/* print 0/0x prefix for octal/hex and decimal point for floating point */
62
81.4k
#define DP_F_NUM        (1 << 3)
63
/* print leading zeroes */
64
151k
#define DP_F_ZERO       (1 << 4)
65
/* print HEX in UPPERcase */
66
81.4k
#define DP_F_UP         (1 << 5)
67
/* treat value as unsigned */
68
159k
#define DP_F_UNSIGNED   (1 << 6)
69
70
/* conversion flags */
71
0
#define DP_C_SHORT      1
72
157k
#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
140k
#define char_to_int(p) (p - '0')
84
151k
#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
81.4k
{
92
81.4k
    char ch;
93
81.4k
    int64_t value;
94
81.4k
#ifndef OPENSSL_SYS_UEFI
95
81.4k
    LDOUBLE fvalue;
96
81.4k
#endif
97
81.4k
    char *strvalue;
98
81.4k
    int min;
99
81.4k
    int max;
100
81.4k
    int state;
101
81.4k
    int flags;
102
81.4k
    int cflags;
103
81.4k
    size_t currlen;
104
105
81.4k
    state = DP_S_DEFAULT;
106
81.4k
    flags = currlen = cflags = min = 0;
107
81.4k
    max = -1;
108
81.4k
    ch = *format++;
109
110
1.00M
    while (state != DP_S_DONE) {
111
924k
        if (ch == '\0' || (buffer == NULL && currlen >= *maxlen))
112
81.4k
            state = DP_S_DONE;
113
114
924k
        switch (state) {
115
183k
        case DP_S_DEFAULT:
116
183k
            if (ch == '%')
117
89.9k
                state = DP_S_FLAGS;
118
93.2k
            else
119
93.2k
                if (!doapr_outch(sbuffer, buffer, &currlen, maxlen, ch))
120
0
                    return 0;
121
183k
            ch = *format++;
122
183k
            break;
123
160k
        case DP_S_FLAGS:
124
160k
            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
70.2k
            case '0':
142
70.2k
                flags |= DP_F_ZERO;
143
70.2k
                ch = *format++;
144
70.2k
                break;
145
89.9k
            default:
146
89.9k
                state = DP_S_MIN;
147
89.9k
                break;
148
160k
            }
149
160k
            break;
150
230k
        case DP_S_MIN:
151
230k
            if (ossl_isdigit(ch)) {
152
140k
                min = 10 * min + char_to_int(ch);
153
140k
                ch = *format++;
154
140k
            } else if (ch == '*') {
155
0
                min = va_arg(args, int);
156
0
                ch = *format++;
157
0
                state = DP_S_DOT;
158
0
            } else
159
89.9k
                state = DP_S_DOT;
160
230k
            break;
161
89.9k
        case DP_S_DOT:
162
89.9k
            if (ch == '.') {
163
0
                state = DP_S_MAX;
164
0
                ch = *format++;
165
0
            } else
166
89.9k
                state = DP_S_MOD;
167
89.9k
            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
89.9k
        case DP_S_MOD:
182
89.9k
            switch (ch) {
183
0
            case 'h':
184
0
                cflags = DP_C_SHORT;
185
0
                ch = *format++;
186
0
                break;
187
78.5k
            case 'l':
188
78.5k
                if (*format == 'l') {
189
0
                    cflags = DP_C_LLONG;
190
0
                    format++;
191
0
                } else
192
78.5k
                    cflags = DP_C_LONG;
193
78.5k
                ch = *format++;
194
78.5k
                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
11.3k
            default:
209
11.3k
                break;
210
89.9k
            }
211
89.9k
            state = DP_S_CONV;
212
89.9k
            break;
213
89.9k
        case DP_S_CONV:
214
89.9k
            switch (ch) {
215
2.82k
            case 'd':
216
2.82k
            case 'i':
217
2.82k
                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
2.82k
                default:
231
2.82k
                    value = va_arg(args, int);
232
2.82k
                    break;
233
2.82k
                }
234
2.82k
                if (!fmtint(sbuffer, buffer, &currlen, maxlen, value, 10, min,
235
2.82k
                            max, flags))
236
0
                    return 0;
237
2.82k
                break;
238
2.82k
            case 'X':
239
0
                flags |= DP_F_UP;
240
                /* FALLTHROUGH */
241
0
            case 'x':
242
0
            case 'o':
243
78.5k
            case 'u':
244
78.5k
                flags |= DP_F_UNSIGNED;
245
78.5k
                switch (cflags) {
246
0
                case DP_C_SHORT:
247
0
                    value = (unsigned short int)va_arg(args, unsigned int);
248
0
                    break;
249
78.5k
                case DP_C_LONG:
250
78.5k
                    value = va_arg(args, unsigned long int);
251
78.5k
                    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
78.5k
                }
262
78.5k
                if (!fmtint(sbuffer, buffer, &currlen, maxlen, value,
263
78.5k
                            ch == 'o' ? 8 : (ch == 'u' ? 10 : 16),
264
78.5k
                            min, max, flags))
265
0
                    return 0;
266
78.5k
                break;
267
78.5k
#ifndef OPENSSL_SYS_UEFI
268
78.5k
            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
8.49k
            case 's':
317
8.49k
                strvalue = va_arg(args, char *);
318
8.49k
                if (max < 0) {
319
8.49k
                    if (buffer)
320
0
                        max = INT_MAX;
321
8.49k
                    else
322
8.49k
                        max = *maxlen;
323
8.49k
                }
324
8.49k
                if (!fmtstr(sbuffer, buffer, &currlen, maxlen, strvalue,
325
8.49k
                            flags, min, max))
326
0
                    return 0;
327
8.49k
                break;
328
8.49k
            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
89.9k
            }
353
89.9k
            ch = *format++;
354
89.9k
            state = DP_S_DEFAULT;
355
89.9k
            flags = cflags = min = 0;
356
89.9k
            max = -1;
357
89.9k
            break;
358
81.4k
        case DP_S_DONE:
359
81.4k
            break;
360
0
        default:
361
0
            break;
362
924k
        }
363
924k
    }
364
    /*
365
     * We have to truncate if there is no dynamic buffer and we have filled the
366
     * static buffer.
367
     */
368
81.4k
    if (buffer == NULL) {
369
81.4k
        *truncated = (currlen > *maxlen - 1);
370
81.4k
        if (*truncated)
371
0
            currlen = *maxlen - 1;
372
81.4k
    }
373
81.4k
    if (!doapr_outch(sbuffer, buffer, &currlen, maxlen, '\0'))
374
0
        return 0;
375
81.4k
    *retlen = currlen - 1;
376
81.4k
    return 1;
377
81.4k
}
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
8.49k
{
385
8.49k
    int padlen;
386
8.49k
    size_t strln;
387
8.49k
    int cnt = 0;
388
389
8.49k
    if (value == 0)
390
0
        value = "<NULL>";
391
392
8.49k
    strln = OPENSSL_strnlen(value, max < 0 ? SIZE_MAX : (size_t)max);
393
394
8.49k
    padlen = min - strln;
395
8.49k
    if (min < 0 || padlen < 0)
396
6.49k
        padlen = 0;
397
8.49k
    if (max >= 0) {
398
        /*
399
         * Calculate the maximum output including padding.
400
         * Make sure max doesn't overflow into negativity
401
         */
402
8.49k
        if (max < INT_MAX - padlen)
403
8.49k
            max += padlen;
404
0
        else
405
0
            max = INT_MAX;
406
8.49k
    }
407
8.49k
    if (flags & DP_F_MINUS)
408
0
        padlen = -padlen;
409
410
8.49k
    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
116k
    while (strln > 0 && (max < 0 || cnt < max)) {
417
108k
        if (!doapr_outch(sbuffer, buffer, currlen, maxlen, *value++))
418
0
            return 0;
419
108k
        --strln;
420
108k
        ++cnt;
421
108k
    }
422
8.49k
    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
8.49k
    return 1;
429
8.49k
}
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
81.4k
{
437
81.4k
    int signvalue = 0;
438
81.4k
    const char *prefix = "";
439
81.4k
    uint64_t uvalue;
440
81.4k
    char convert[DECIMAL_SIZE(value) + 3];
441
81.4k
    int place = 0;
442
81.4k
    int spadlen = 0;
443
81.4k
    int zpadlen = 0;
444
81.4k
    int caps = 0;
445
446
81.4k
    if (max < 0)
447
81.4k
        max = 0;
448
81.4k
    uvalue = value;
449
81.4k
    if (!(flags & DP_F_UNSIGNED)) {
450
2.82k
        if (value < 0) {
451
0
            signvalue = '-';
452
0
            uvalue = 0 - (uint64_t)value;
453
2.82k
        } else if (flags & DP_F_PLUS)
454
0
            signvalue = '+';
455
2.82k
        else if (flags & DP_F_SPACE)
456
0
            signvalue = ' ';
457
2.82k
    }
458
81.4k
    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
81.4k
    if (flags & DP_F_UP)
465
0
        caps = 1;
466
1.30M
    do {
467
1.30M
        convert[place++] = (caps ? "0123456789ABCDEF" : "0123456789abcdef")
468
1.30M
            [uvalue % (unsigned)base];
469
1.30M
        uvalue = (uvalue / (unsigned)base);
470
1.30M
    } while (uvalue && (place < (int)sizeof(convert)));
471
81.4k
    if (place == sizeof(convert))
472
0
        place--;
473
81.4k
    convert[place] = 0;
474
475
81.4k
    zpadlen = max - place;
476
81.4k
    spadlen =
477
81.4k
        min - OSSL_MAX(max, place) - (signvalue ? 1 : 0) - strlen(prefix);
478
81.4k
    if (zpadlen < 0)
479
81.4k
        zpadlen = 0;
480
81.4k
    if (spadlen < 0)
481
11.1k
        spadlen = 0;
482
81.4k
    if (flags & DP_F_ZERO) {
483
70.2k
        zpadlen = OSSL_MAX(zpadlen, spadlen);
484
70.2k
        spadlen = 0;
485
70.2k
    }
486
81.4k
    if (flags & DP_F_MINUS)
487
0
        spadlen = -spadlen;
488
489
    /* spaces */
490
81.4k
    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
81.4k
    if (signvalue)
498
0
        if (!doapr_outch(sbuffer, buffer, currlen, maxlen, signvalue))
499
0
            return 0;
500
501
    /* prefix */
502
81.4k
    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
81.4k
    if (zpadlen > 0) {
510
82.4k
        while (zpadlen > 0) {
511
72.0k
            if (!doapr_outch(sbuffer, buffer, currlen, maxlen, '0'))
512
0
                return 0;
513
72.0k
            --zpadlen;
514
72.0k
        }
515
10.3k
    }
516
    /* digits */
517
1.38M
    while (place > 0) {
518
1.30M
        if (!doapr_outch(sbuffer, buffer, currlen, maxlen, convert[--place]))
519
0
            return 0;
520
1.30M
    }
521
522
    /* left justified spaces */
523
81.4k
    while (spadlen < 0) {
524
0
        if (!doapr_outch(sbuffer, buffer, currlen, maxlen, ' '))
525
0
            return 0;
526
0
        ++spadlen;
527
0
    }
528
81.4k
    return 1;
529
81.4k
}
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
    fconvert[fplace] = 0;
711
712
    /* convert exponent part */
713
0
    if (realstyle == E_FORMAT) {
714
0
        int tmpexp;
715
0
        if (exp < 0)
716
0
            tmpexp = -exp;
717
0
        else
718
0
            tmpexp = exp;
719
720
0
        do {
721
0
            econvert[eplace++] = "0123456789"[tmpexp % 10];
722
0
            tmpexp = (tmpexp / 10);
723
0
        } while (tmpexp > 0 && eplace < (int)sizeof(econvert));
724
        /* Exponent is huge!! Too big to print */
725
0
        if (tmpexp > 0) {
726
0
            (void)doapr_outch(sbuffer, buffer, currlen, maxlen, '\0');
727
0
            return 0;
728
0
        }
729
        /* Add a leading 0 for single digit exponents */
730
0
        if (eplace == 1)
731
0
            econvert[eplace++] = '0';
732
0
    }
733
734
    /*
735
     * -1 for decimal point (if we have one, i.e. max > 0),
736
     * another -1 if we are printing a sign
737
     */
738
0
    padlen = min - iplace - max - (max > 0 ? 1 : 0) - ((signvalue) ? 1 : 0);
739
    /* Take some off for exponent prefix "+e" and exponent */
740
0
    if (realstyle == E_FORMAT)
741
0
        padlen -= 2 + eplace;
742
0
    zpadlen = max - fplace;
743
0
    if (zpadlen < 0)
744
0
        zpadlen = 0;
745
0
    if (padlen < 0)
746
0
        padlen = 0;
747
0
    if (flags & DP_F_MINUS)
748
0
        padlen = -padlen;
749
750
0
    if ((flags & DP_F_ZERO) && (padlen > 0)) {
751
0
        if (signvalue) {
752
0
            if (!doapr_outch(sbuffer, buffer, currlen, maxlen, signvalue))
753
0
                return 0;
754
0
            --padlen;
755
0
            signvalue = 0;
756
0
        }
757
0
        while (padlen > 0) {
758
0
            if (!doapr_outch(sbuffer, buffer, currlen, maxlen, '0'))
759
0
                return 0;
760
0
            --padlen;
761
0
        }
762
0
    }
763
0
    while (padlen > 0) {
764
0
        if (!doapr_outch(sbuffer, buffer, currlen, maxlen, ' '))
765
0
            return 0;
766
0
        --padlen;
767
0
    }
768
0
    if (signvalue && !doapr_outch(sbuffer, buffer, currlen, maxlen, signvalue))
769
0
        return 0;
770
771
0
    while (iplace > 0) {
772
0
        if (!doapr_outch(sbuffer, buffer, currlen, maxlen, iconvert[--iplace]))
773
0
            return 0;
774
0
    }
775
776
    /*
777
     * Decimal point. This should probably use locale to find the correct
778
     * char to print out.
779
     */
780
0
    if (max > 0 || (flags & DP_F_NUM)) {
781
0
        if (!doapr_outch(sbuffer, buffer, currlen, maxlen, '.'))
782
0
            return 0;
783
784
0
        while (fplace > 0) {
785
0
            if (!doapr_outch(sbuffer, buffer, currlen, maxlen,
786
0
                             fconvert[--fplace]))
787
0
                return 0;
788
0
        }
789
0
    }
790
0
    while (zpadlen > 0) {
791
0
        if (!doapr_outch(sbuffer, buffer, currlen, maxlen, '0'))
792
0
            return 0;
793
0
        --zpadlen;
794
0
    }
795
0
    if (realstyle == E_FORMAT) {
796
0
        char ech;
797
798
0
        if ((flags & DP_F_UP) == 0)
799
0
            ech = 'e';
800
0
        else
801
0
            ech = 'E';
802
0
        if (!doapr_outch(sbuffer, buffer, currlen, maxlen, ech))
803
0
                return 0;
804
0
        if (exp < 0) {
805
0
            if (!doapr_outch(sbuffer, buffer, currlen, maxlen, '-'))
806
0
                    return 0;
807
0
        } else {
808
0
            if (!doapr_outch(sbuffer, buffer, currlen, maxlen, '+'))
809
0
                    return 0;
810
0
        }
811
0
        while (eplace > 0) {
812
0
            if (!doapr_outch(sbuffer, buffer, currlen, maxlen,
813
0
                             econvert[--eplace]))
814
0
                return 0;
815
0
        }
816
0
    }
817
818
0
    while (padlen < 0) {
819
0
        if (!doapr_outch(sbuffer, buffer, currlen, maxlen, ' '))
820
0
            return 0;
821
0
        ++padlen;
822
0
    }
823
0
    return 1;
824
0
}
825
826
#endif /* OPENSSL_SYS_UEFI */
827
828
0
#define BUFFER_INC  1024
829
830
static int
831
doapr_outch(char **sbuffer,
832
            char **buffer, size_t *currlen, size_t *maxlen, int c)
833
1.66M
{
834
    /* If we haven't at least one buffer, someone has done a big booboo */
835
1.66M
    if (!ossl_assert(*sbuffer != NULL || buffer != NULL))
836
0
        return 0;
837
838
    /* |currlen| must always be <= |*maxlen| */
839
1.66M
    if (!ossl_assert(*currlen <= *maxlen))
840
0
        return 0;
841
842
1.66M
    if (buffer && *currlen == *maxlen) {
843
0
        if (*maxlen > INT_MAX - BUFFER_INC)
844
0
            return 0;
845
846
0
        *maxlen += BUFFER_INC;
847
0
        if (*buffer == NULL) {
848
0
            if ((*buffer = OPENSSL_malloc(*maxlen)) == NULL)
849
0
                return 0;
850
0
            if (*currlen > 0) {
851
0
                if (!ossl_assert(*sbuffer != NULL))
852
0
                    return 0;
853
0
                memcpy(*buffer, *sbuffer, *currlen);
854
0
            }
855
0
            *sbuffer = NULL;
856
0
        } else {
857
0
            char *tmpbuf;
858
859
0
            tmpbuf = OPENSSL_realloc(*buffer, *maxlen);
860
0
            if (tmpbuf == NULL)
861
0
                return 0;
862
0
            *buffer = tmpbuf;
863
0
        }
864
0
    }
865
866
1.66M
    if (*currlen < *maxlen) {
867
1.66M
        if (*sbuffer)
868
1.66M
            (*sbuffer)[(*currlen)++] = (char)c;
869
0
        else
870
0
            (*buffer)[(*currlen)++] = (char)c;
871
1.66M
    }
872
873
1.66M
    return 1;
874
1.66M
}
875
876
/***************************************************************************/
877
878
int BIO_printf(BIO *bio, const char *format, ...)
879
0
{
880
0
    va_list args;
881
0
    int ret;
882
883
0
    va_start(args, format);
884
885
0
    ret = BIO_vprintf(bio, format, args);
886
887
0
    va_end(args);
888
0
    return ret;
889
0
}
890
891
int BIO_vprintf(BIO *bio, const char *format, va_list args)
892
0
{
893
0
    int ret;
894
0
    size_t retlen;
895
0
    char hugebuf[1024 * 2];     /* Was previously 10k, which is unreasonable
896
                                 * in small-stack environments, like threads
897
                                 * or DOS programs. */
898
0
    char *hugebufp = hugebuf;
899
0
    size_t hugebufsize = sizeof(hugebuf);
900
0
    char *dynbuf = NULL;
901
0
    int ignored;
902
903
0
    dynbuf = NULL;
904
0
    if (!_dopr(&hugebufp, &dynbuf, &hugebufsize, &retlen, &ignored, format,
905
0
                args)) {
906
0
        OPENSSL_free(dynbuf);
907
0
        return -1;
908
0
    }
909
0
    if (dynbuf) {
910
0
        ret = BIO_write(bio, dynbuf, (int)retlen);
911
0
        OPENSSL_free(dynbuf);
912
0
    } else {
913
0
        ret = BIO_write(bio, hugebuf, (int)retlen);
914
0
    }
915
0
    return ret;
916
0
}
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
78.5k
{
926
78.5k
    va_list args;
927
78.5k
    int ret;
928
929
78.5k
    va_start(args, format);
930
931
78.5k
    ret = BIO_vsnprintf(buf, n, format, args);
932
933
78.5k
    va_end(args);
934
78.5k
    return ret;
935
78.5k
}
936
937
int BIO_vsnprintf(char *buf, size_t n, const char *format, va_list args)
938
81.4k
{
939
81.4k
    size_t retlen;
940
81.4k
    int truncated;
941
942
81.4k
    if (!_dopr(&buf, NULL, &n, &retlen, &truncated, format, args))
943
0
        return -1;
944
945
81.4k
    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
0
        return -1;
953
81.4k
    return (retlen <= INT_MAX) ? (int)retlen : -1;
954
81.4k
}