xref: /openssl/crypto/err/err_prn.c (revision 3b90a847)
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
ERR_print_errors_cb(int (* cb)(const char * str,size_t len,void * u),void * u)20 void 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 */
put_error(int lib,const char * func,int reason,const char * file,int line)50 static 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)
ERR_add_error_txt(const char * separator,const char * txt)60 void 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 
ERR_add_error_mem_bio(const char * separator,BIO * bio)147 void 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 
print_bio(const char * str,size_t len,void * bp)166 static int print_bio(const char *str, size_t len, void *bp)
167 {
168     return BIO_write((BIO *)bp, str, len);
169 }
170 
ERR_print_errors(BIO * bp)171 void ERR_print_errors(BIO *bp)
172 {
173     ERR_print_errors_cb(print_bio, bp);
174 }
175 
176 #ifndef OPENSSL_NO_STDIO
ERR_print_errors_fp(FILE * fp)177 void 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