1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
|
/* Copyright (c) 2003, Roger Dingledine
* Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.
* Copyright (c) 2007-2020, The Tor Project, Inc. */
/* See LICENSE for licensing information */
/**
* \file util_bug.c
**/
#include "orconfig.h"
#include "lib/log/util_bug.h"
#include "lib/log/log.h"
#include "lib/err/backtrace.h"
#include "lib/err/torerr.h"
#ifdef TOR_UNIT_TESTS
#include "lib/smartlist_core/smartlist_core.h"
#include "lib/smartlist_core/smartlist_foreach.h"
#endif
#include "lib/malloc/malloc.h"
#include "lib/string/printf.h"
#include <string.h>
#include <stdlib.h>
#ifdef TOR_UNIT_TESTS
static void (*failed_assertion_cb)(void) = NULL;
static int n_bugs_to_capture = 0;
static smartlist_t *bug_messages = NULL;
#define capturing_bugs() (bug_messages != NULL && n_bugs_to_capture)
void
tor_capture_bugs_(int n)
{
tor_end_capture_bugs_();
bug_messages = smartlist_new();
n_bugs_to_capture = n;
}
void
tor_end_capture_bugs_(void)
{
n_bugs_to_capture = 0;
if (!bug_messages)
return;
SMARTLIST_FOREACH(bug_messages, char *, cp, tor_free(cp));
smartlist_free(bug_messages);
bug_messages = NULL;
}
const smartlist_t *
tor_get_captured_bug_log_(void)
{
return bug_messages;
}
static void
add_captured_bug(const char *s)
{
--n_bugs_to_capture;
smartlist_add_strdup(bug_messages, s);
}
/** Set a callback to be invoked when we get any tor_bug_occurred_
* invocation. We use this in the unit tests so that a nonfatal
* assertion failure can also count as a test failure.
*/
void
tor_set_failed_assertion_callback(void (*fn)(void))
{
failed_assertion_cb = fn;
}
#else /* !defined(TOR_UNIT_TESTS) */
#define capturing_bugs() (0)
#define add_captured_bug(s) do { } while (0)
#endif /* defined(TOR_UNIT_TESTS) */
/** Helper for tor_assert: report the assertion failure. */
void
tor_assertion_failed_(const char *fname, unsigned int line,
const char *func, const char *expr,
const char *fmt, ...)
{
char *buf = NULL;
char *extra = NULL;
va_list ap;
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wformat-nonliteral"
#endif
if (fmt) {
va_start(ap,fmt);
tor_vasprintf(&extra, fmt, ap);
va_end(ap);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
log_err(LD_BUG, "%s:%u: %s: Assertion %s failed; aborting.",
fname, line, func, expr);
tor_asprintf(&buf, "Assertion %s failed in %s at %s:%u: %s",
expr, func, fname, line, extra ? extra : "");
tor_free(extra);
log_backtrace(LOG_ERR, LD_BUG, buf);
tor_free(buf);
}
/** Helper for tor_assert_nonfatal: report the assertion failure. */
void
tor_bug_occurred_(const char *fname, unsigned int line,
const char *func, const char *expr,
int once, const char *fmt, ...)
{
char *buf = NULL;
const char *once_str = once ?
" (Future instances of this warning will be silenced.)": "";
if (! expr) {
if (capturing_bugs()) {
add_captured_bug("This line should not have been reached.");
return;
}
log_warn(LD_BUG, "%s:%u: %s: This line should not have been reached.%s",
fname, line, func, once_str);
tor_asprintf(&buf,
"Line unexpectedly reached at %s at %s:%u",
func, fname, line);
} else {
if (capturing_bugs()) {
add_captured_bug(expr);
return;
}
va_list ap;
char *extra = NULL;
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wformat-nonliteral"
#endif
if (fmt) {
va_start(ap,fmt);
tor_vasprintf(&extra, fmt, ap);
va_end(ap);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
log_warn(LD_BUG, "%s:%u: %s: Non-fatal assertion %s failed.%s",
fname, line, func, expr, once_str);
tor_asprintf(&buf, "Non-fatal assertion %s failed in %s at %s:%u%s%s",
expr, func, fname, line, fmt ? " : " : "",
extra ? extra : "");
tor_free(extra);
}
log_backtrace(LOG_WARN, LD_BUG, buf);
tor_free(buf);
#ifdef TOR_UNIT_TESTS
if (failed_assertion_cb) {
failed_assertion_cb();
}
#endif
}
/**
* Call the tor_raw_abort_() function to close raw logs, then kill the current
* process with a fatal error. But first, close the file-based log file
* descriptors, so error messages are written before process termination.
*
* (This is a separate function so that we declare it in util_bug.h without
* including torerr.h in all the users of util_bug.h)
**/
void
tor_abort_(void)
{
logs_flush_sigsafe();
tor_raw_abort_();
}
#ifdef _WIN32
/** Take a filename and return a pointer to its final element. This
* function is called on __FILE__ to fix a MSVC nit where __FILE__
* contains the full path to the file. This is bad, because it
* confuses users to find the home directory of the person who
* compiled the binary in their warning messages.
*/
const char *
tor_fix_source_file(const char *fname)
{
const char *cp1, *cp2, *r;
cp1 = strrchr(fname, '/');
cp2 = strrchr(fname, '\\');
if (cp1 && cp2) {
r = (cp1<cp2)?(cp2+1):(cp1+1);
} else if (cp1) {
r = cp1+1;
} else if (cp2) {
r = cp2+1;
} else {
r = fname;
}
return r;
}
#endif /* defined(_WIN32) */
|
