2 * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved.
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
10 /* TODO: When ERR_STATE becomes opaque, this musts be removed */
11 #define OSSL_FORCE_ERR_STATE
14 #include "internal/cryptlib.h"
15 #include <openssl/crypto.h>
16 #include <openssl/buffer.h>
17 #include <openssl/err.h>
18 #include "err_local.h"
20 #define ERR_PRINT_BUF_SIZE 4096
21 void ERR_print_errors_cb(int (*cb) (const char *str, size_t len, void *u),
24 CRYPTO_THREAD_ID tid = CRYPTO_THREAD_get_current_id();
26 const char *file, *data, *func;
29 while ((l = ERR_get_error_all(&file, &line, &func, &data, &flags)) != 0) {
30 char buf[ERR_PRINT_BUF_SIZE], *hex;
31 const char *lib, *reason = NULL;
33 unsigned long r = ERR_GET_REASON(l);
35 lib = ERR_lib_error_string(l);
38 * ERR_reason_error_string() can't safely return system error strings,
39 * since it would call openssl_strerror_r(), which needs a buffer for
40 * thread safety. So for system errors, we call openssl_strerror_r()
43 if (ERR_SYSTEM_ERROR(l)) {
44 if (openssl_strerror_r(r, rsbuf, sizeof(rsbuf)))
47 reason = ERR_reason_error_string(l);
51 func = "unknown function";
53 BIO_snprintf(rsbuf, sizeof(rsbuf), "reason(%lu)", r);
56 if ((flags & ERR_TXT_STRING) == 0)
58 hex = openssl_buf2hexstr_sep((const unsigned char *)&tid, sizeof(tid),
60 BIO_snprintf(buf, sizeof(buf), "%s:error::%s:%s:%s:%s:%d:%s\n",
61 hex == NULL ? "<null>" : hex, lib, func, reason, file,
64 if (cb(buf, strlen(buf), u) <= 0)
65 break; /* abort outputting the error report */
69 /* auxiliary function for incrementally reporting texts via the error queue */
70 static void put_error(int lib, const char *func, int reason,
71 const char *file, int line)
74 ERR_set_debug(file, line, func);
75 ERR_set_error(lib, reason, NULL /* no data here, so fmt is NULL */);
78 #define TYPICAL_MAX_OUTPUT_BEFORE_DATA 100
79 #define MAX_DATA_LEN (ERR_PRINT_BUF_SIZE - TYPICAL_MAX_OUTPUT_BEFORE_DATA)
80 void ERR_add_error_txt(const char *separator, const char *txt)
82 const char *file = NULL;
84 const char *func = NULL;
85 const char *data = NULL;
87 unsigned long err = ERR_peek_last_error();
89 if (separator == NULL)
92 put_error(ERR_LIB_NONE, NULL, 0, "", 0);
95 size_t available_len, data_len;
96 const char *curr = txt, *next = txt;
97 const char *leading_separator = separator;
98 int trailing_separator = 0;
101 ERR_peek_last_error_all(&file, &line, &func, &data, &flags);
102 if ((flags & ERR_TXT_STRING) == 0) {
104 leading_separator = "";
106 data_len = strlen(data);
108 /* workaround for limit of ERR_print_errors_cb() */
109 if (data_len >= MAX_DATA_LEN
110 || strlen(separator) >= (size_t)(MAX_DATA_LEN - data_len))
113 available_len = MAX_DATA_LEN - data_len - strlen(separator) - 1;
114 /* MAX_DATA_LEN > available_len >= 0 */
116 if (*separator == '\0') {
117 const size_t len_next = strlen(next);
119 if (len_next <= available_len) {
121 curr = NULL; /* no need to split */
123 next += available_len;
124 curr = next; /* will split at this point */
127 while (*next != '\0' && (size_t)(next - txt) <= available_len) {
129 next = strstr(curr, separator);
131 next += strlen(separator);
132 trailing_separator = *next == '\0';
134 next = curr + strlen(curr);
137 if ((size_t)(next - txt) <= available_len)
138 curr = NULL; /* the above loop implies *next == '\0' */
141 /* split error msg at curr since error data would get too long */
143 tmp = OPENSSL_strndup(txt, curr - txt);
146 ERR_add_error_data(2, separator, tmp);
149 put_error(ERR_GET_LIB(err), func, err, file, line);
152 if (trailing_separator) {
153 tmp = OPENSSL_strndup(txt, next - strlen(separator) - txt);
156 /* output txt without the trailing separator */
157 ERR_add_error_data(2, leading_separator, tmp);
160 ERR_add_error_data(2, leading_separator, txt);
162 txt = next; /* finished */
164 } while (*txt != '\0');
167 void ERR_add_error_mem_bio(const char *separator, BIO *bio)
171 long len = BIO_get_mem_data(bio, &str);
174 if (str[len - 1] != '\0') {
175 if (BIO_write(bio, "", 1) <= 0)
178 len = BIO_get_mem_data(bio, &str);
181 ERR_add_error_txt(separator, str);
186 static int print_bio(const char *str, size_t len, void *bp)
188 return BIO_write((BIO *)bp, str, len);
191 void ERR_print_errors(BIO *bp)
193 ERR_print_errors_cb(print_bio, bp);
196 #ifndef OPENSSL_NO_STDIO
197 void ERR_print_errors_fp(FILE *fp)
199 BIO *bio = BIO_new_fp(fp, BIO_NOCLOSE);
203 ERR_print_errors_cb(print_bio, bio);