1/*
2 * Copyright 1995-2021 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#define OSSL_FORCE_ERR_STATE
11
12#include <stdio.h>
13#include "internal/cryptlib.h"
14#include <openssl/crypto.h>
15#include <openssl/buffer.h>
16#include <openssl/err.h>
17#include "err_local.h"
18
19#define ERR_PRINT_BUF_SIZE 4096
20void ERR_print_errors_cb(int (*cb) (const char *str, size_t len, void *u),
21                         void *u)
22{
23    CRYPTO_THREAD_ID tid = CRYPTO_THREAD_get_current_id();
24    unsigned long l;
25    const char *file, *data, *func;
26    int line, flags;
27
28    while ((l = ERR_get_error_all(&file, &line, &func, &data, &flags)) != 0) {
29        char buf[ERR_PRINT_BUF_SIZE] = "";
30        char *hex = NULL;
31        int offset;
32
33        if ((flags & ERR_TXT_STRING) == 0)
34            data = "";
35
36        hex = ossl_buf2hexstr_sep((const unsigned char *)&tid, sizeof(tid), '\0');
37        BIO_snprintf(buf, sizeof(buf), "%s:", hex == NULL ? "<null>" : hex);
38        offset = strlen(buf);
39        ossl_err_string_int(l, func, buf + offset, sizeof(buf) - offset);
40        offset += strlen(buf + offset);
41        BIO_snprintf(buf + offset, sizeof(buf) - offset, ":%s:%d:%s\n",
42                     file, line, data);
43        OPENSSL_free(hex);
44        if (cb(buf, strlen(buf), u) <= 0)
45            break;              /* abort outputting the error report */
46    }
47}
48
49/* auxiliary function for incrementally reporting texts via the error queue */
50static void put_error(int lib, const char *func, int reason,
51                      const char *file, int line)
52{
53    ERR_new();
54    ERR_set_debug(file, line, func);
55    ERR_set_error(lib, reason, NULL /* no data here, so fmt is NULL */);
56}
57
58#define TYPICAL_MAX_OUTPUT_BEFORE_DATA 100
59#define MAX_DATA_LEN (ERR_PRINT_BUF_SIZE - TYPICAL_MAX_OUTPUT_BEFORE_DATA)
60void ERR_add_error_txt(const char *separator, const char *txt)
61{
62    const char *file = NULL;
63    int line;
64    const char *func = NULL;
65    const char *data = NULL;
66    int flags;
67    unsigned long err = ERR_peek_last_error();
68
69    if (separator == NULL)
70        separator = "";
71    if (err == 0)
72        put_error(ERR_LIB_NONE, NULL, 0, "", 0);
73
74    do {
75        size_t available_len, data_len;
76        const char *curr = txt, *next = txt;
77        const char *leading_separator = separator;
78        int trailing_separator = 0;
79        char *tmp;
80
81        ERR_peek_last_error_all(&file, &line, &func, &data, &flags);
82        if ((flags & ERR_TXT_STRING) == 0) {
83            data = "";
84            leading_separator = "";
85        }
86        data_len = strlen(data);
87
88        /* workaround for limit of ERR_print_errors_cb() */
89        if (data_len >= MAX_DATA_LEN
90                || strlen(separator) >= (size_t)(MAX_DATA_LEN - data_len))
91            available_len = 0;
92        else
93            available_len = MAX_DATA_LEN - data_len - strlen(separator) - 1;
94        /* MAX_DATA_LEN > available_len >= 0 */
95
96        if (*separator == '\0') {
97            const size_t len_next = strlen(next);
98
99            if (len_next <= available_len) {
100                next += len_next;
101                curr = NULL; /* no need to split */
102            } else {
103                next += available_len;
104                curr = next; /* will split at this point */
105            }
106        } else {
107            while (*next != '\0' && (size_t)(next - txt) <= available_len) {
108                curr = next;
109                next = strstr(curr, separator);
110                if (next != NULL) {
111                    next += strlen(separator);
112                    trailing_separator = *next == '\0';
113                } else {
114                    next = curr + strlen(curr);
115                }
116            }
117            if ((size_t)(next - txt) <= available_len)
118                curr = NULL; /* the above loop implies *next == '\0' */
119        }
120        if (curr != NULL) {
121            /* split error msg at curr since error data would get too long */
122            if (curr != txt) {
123                tmp = OPENSSL_strndup(txt, curr - txt);
124                if (tmp == NULL)
125                    return;
126                ERR_add_error_data(2, separator, tmp);
127                OPENSSL_free(tmp);
128            }
129            put_error(ERR_GET_LIB(err), func, err, file, line);
130            txt = curr;
131        } else {
132            if (trailing_separator) {
133                tmp = OPENSSL_strndup(txt, next - strlen(separator) - txt);
134                if (tmp == NULL)
135                    return;
136                /* output txt without the trailing separator */
137                ERR_add_error_data(2, leading_separator, tmp);
138                OPENSSL_free(tmp);
139            } else {
140                ERR_add_error_data(2, leading_separator, txt);
141            }
142            txt = next; /* finished */
143        }
144    } while (*txt != '\0');
145}
146
147void ERR_add_error_mem_bio(const char *separator, BIO *bio)
148{
149    if (bio != NULL) {
150        char *str;
151        long len = BIO_get_mem_data(bio, &str);
152
153        if (len > 0) {
154            if (str[len - 1] != '\0') {
155                if (BIO_write(bio, "", 1) <= 0)
156                    return;
157
158                len = BIO_get_mem_data(bio, &str);
159            }
160            if (len > 1)
161                ERR_add_error_txt(separator, str);
162        }
163    }
164}
165
166static int print_bio(const char *str, size_t len, void *bp)
167{
168    return BIO_write((BIO *)bp, str, len);
169}
170
171void ERR_print_errors(BIO *bp)
172{
173    ERR_print_errors_cb(print_bio, bp);
174}
175
176#ifndef OPENSSL_NO_STDIO
177void ERR_print_errors_fp(FILE *fp)
178{
179    BIO *bio = BIO_new_fp(fp, BIO_NOCLOSE);
180    if (bio == NULL)
181        return;
182
183    ERR_print_errors_cb(print_bio, bio);
184    BIO_free(bio);
185}
186#endif
187