OLD | NEW |
| (Empty) |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #include "third_party/libjingle/overrides/talk/base/logging.h" | |
6 | |
7 #if defined(OS_MACOSX) && !defined(OS_IOS) | |
8 #include <CoreServices/CoreServices.h> | |
9 #endif // OS_MACOSX | |
10 | |
11 #include <iomanip> | |
12 | |
13 #include "base/atomicops.h" | |
14 #include "base/strings/string_util.h" | |
15 #include "base/threading/platform_thread.h" | |
16 #include "third_party/libjingle/source/talk/base/ipaddress.h" | |
17 #include "third_party/libjingle/source/talk/base/stream.h" | |
18 #include "third_party/libjingle/source/talk/base/stringencode.h" | |
19 #include "third_party/libjingle/source/talk/base/stringutils.h" | |
20 #include "third_party/libjingle/source/talk/base/timeutils.h" | |
21 | |
22 // From this file we can't use VLOG since it expands into usage of the __FILE__ | |
23 // macro (for correct filtering). The actual logging call from DIAGNOSTIC_LOG in | |
24 // ~DiagnosticLogMessage. Note that the second parameter to the LAZY_STREAM | |
25 // macro is true since the filter check has already been done for | |
26 // DIAGNOSTIC_LOG. | |
27 #define LOG_LAZY_STREAM_DIRECT(file_name, line_number, sev) \ | |
28 LAZY_STREAM(logging::LogMessage(file_name, line_number, \ | |
29 -sev).stream(), true) | |
30 | |
31 namespace talk_base { | |
32 | |
33 void (*g_logging_delegate_function)(const std::string&) = NULL; | |
34 void (*g_extra_logging_init_function)( | |
35 void (*logging_delegate_function)(const std::string&)) = NULL; | |
36 #ifndef NDEBUG | |
37 COMPILE_ASSERT(sizeof(base::subtle::Atomic32) == sizeof(base::PlatformThreadId), | |
38 atomic32_not_same_size_as_platformthreadid); | |
39 base::subtle::Atomic32 g_init_logging_delegate_thread_id = 0; | |
40 #endif | |
41 | |
42 ///////////////////////////////////////////////////////////////////////////// | |
43 // Constant Labels | |
44 ///////////////////////////////////////////////////////////////////////////// | |
45 | |
46 const char* FindLabel(int value, const ConstantLabel entries[]) { | |
47 for (int i = 0; entries[i].label; ++i) { | |
48 if (value == entries[i].value) return entries[i].label; | |
49 } | |
50 return 0; | |
51 } | |
52 | |
53 std::string ErrorName(int err, const ConstantLabel* err_table) { | |
54 if (err == 0) | |
55 return "No error"; | |
56 | |
57 if (err_table != 0) { | |
58 if (const char * value = FindLabel(err, err_table)) | |
59 return value; | |
60 } | |
61 | |
62 char buffer[16]; | |
63 base::snprintf(buffer, sizeof(buffer), "0x%08x", err); | |
64 return buffer; | |
65 } | |
66 | |
67 ///////////////////////////////////////////////////////////////////////////// | |
68 // Log helper functions | |
69 ///////////////////////////////////////////////////////////////////////////// | |
70 | |
71 // Generates extra information for LOG_E. | |
72 static std::string GenerateExtra(LogErrorContext err_ctx, | |
73 int err, | |
74 const char* module) { | |
75 if (err_ctx != ERRCTX_NONE) { | |
76 std::ostringstream tmp; | |
77 tmp << ": "; | |
78 tmp << "[0x" << std::setfill('0') << std::hex << std::setw(8) << err << "]"; | |
79 switch (err_ctx) { | |
80 case ERRCTX_ERRNO: | |
81 tmp << " " << strerror(err); | |
82 break; | |
83 #if defined(OS_WIN) | |
84 case ERRCTX_HRESULT: { | |
85 char msgbuf[256]; | |
86 DWORD flags = FORMAT_MESSAGE_FROM_SYSTEM; | |
87 HMODULE hmod = GetModuleHandleA(module); | |
88 if (hmod) | |
89 flags |= FORMAT_MESSAGE_FROM_HMODULE; | |
90 if (DWORD len = FormatMessageA( | |
91 flags, hmod, err, | |
92 MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), | |
93 msgbuf, sizeof(msgbuf) / sizeof(msgbuf[0]), NULL)) { | |
94 while ((len > 0) && | |
95 isspace(static_cast<unsigned char>(msgbuf[len-1]))) { | |
96 msgbuf[--len] = 0; | |
97 } | |
98 tmp << " " << msgbuf; | |
99 } | |
100 break; | |
101 } | |
102 #endif // OS_WIN | |
103 #if defined(OS_IOS) | |
104 case ERRCTX_OSSTATUS: | |
105 tmp << " " << "Unknown LibJingle error: " << err; | |
106 break; | |
107 #elif defined(OS_MACOSX) | |
108 case ERRCTX_OSSTATUS: { | |
109 tmp << " " << nonnull(GetMacOSStatusErrorString(err), "Unknown error"); | |
110 if (const char* desc = GetMacOSStatusCommentString(err)) { | |
111 tmp << ": " << desc; | |
112 } | |
113 break; | |
114 } | |
115 #endif // OS_MACOSX | |
116 default: | |
117 break; | |
118 } | |
119 return tmp.str(); | |
120 } | |
121 return ""; | |
122 } | |
123 | |
124 DiagnosticLogMessage::DiagnosticLogMessage(const char* file, | |
125 int line, | |
126 LoggingSeverity severity, | |
127 bool log_to_chrome, | |
128 LogErrorContext err_ctx, | |
129 int err) | |
130 : file_name_(file), | |
131 line_(line), | |
132 severity_(severity), | |
133 log_to_chrome_(log_to_chrome) { | |
134 extra_ = GenerateExtra(err_ctx, err, NULL); | |
135 } | |
136 | |
137 DiagnosticLogMessage::DiagnosticLogMessage(const char* file, | |
138 int line, | |
139 LoggingSeverity severity, | |
140 bool log_to_chrome, | |
141 LogErrorContext err_ctx, | |
142 int err, | |
143 const char* module) | |
144 : file_name_(file), | |
145 line_(line), | |
146 severity_(severity), | |
147 log_to_chrome_(log_to_chrome) { | |
148 extra_ = GenerateExtra(err_ctx, err, module); | |
149 } | |
150 | |
151 DiagnosticLogMessage::~DiagnosticLogMessage() { | |
152 print_stream_ << extra_; | |
153 const std::string& str = print_stream_.str(); | |
154 if (log_to_chrome_) | |
155 LOG_LAZY_STREAM_DIRECT(file_name_, line_, severity_) << str; | |
156 if (g_logging_delegate_function && severity_ <= LS_INFO) { | |
157 g_logging_delegate_function(str); | |
158 } | |
159 } | |
160 | |
161 // Note: this function is a copy from the overriden libjingle implementation. | |
162 void LogMultiline(LoggingSeverity level, const char* label, bool input, | |
163 const void* data, size_t len, bool hex_mode, | |
164 LogMultilineState* state) { | |
165 if (!LOG_CHECK_LEVEL_V(level)) | |
166 return; | |
167 | |
168 const char * direction = (input ? " << " : " >> "); | |
169 | |
170 // NULL data means to flush our count of unprintable characters. | |
171 if (!data) { | |
172 if (state && state->unprintable_count_[input]) { | |
173 LOG_V(level) << label << direction << "## " | |
174 << state->unprintable_count_[input] | |
175 << " consecutive unprintable ##"; | |
176 state->unprintable_count_[input] = 0; | |
177 } | |
178 return; | |
179 } | |
180 | |
181 // The ctype classification functions want unsigned chars. | |
182 const unsigned char* udata = static_cast<const unsigned char*>(data); | |
183 | |
184 if (hex_mode) { | |
185 const size_t LINE_SIZE = 24; | |
186 char hex_line[LINE_SIZE * 9 / 4 + 2], asc_line[LINE_SIZE + 1]; | |
187 while (len > 0) { | |
188 memset(asc_line, ' ', sizeof(asc_line)); | |
189 memset(hex_line, ' ', sizeof(hex_line)); | |
190 size_t line_len = _min(len, LINE_SIZE); | |
191 for (size_t i = 0; i < line_len; ++i) { | |
192 unsigned char ch = udata[i]; | |
193 asc_line[i] = isprint(ch) ? ch : '.'; | |
194 hex_line[i*2 + i/4] = hex_encode(ch >> 4); | |
195 hex_line[i*2 + i/4 + 1] = hex_encode(ch & 0xf); | |
196 } | |
197 asc_line[sizeof(asc_line)-1] = 0; | |
198 hex_line[sizeof(hex_line)-1] = 0; | |
199 LOG_V(level) << label << direction | |
200 << asc_line << " " << hex_line << " "; | |
201 udata += line_len; | |
202 len -= line_len; | |
203 } | |
204 return; | |
205 } | |
206 | |
207 size_t consecutive_unprintable = state ? state->unprintable_count_[input] : 0; | |
208 | |
209 const unsigned char* end = udata + len; | |
210 while (udata < end) { | |
211 const unsigned char* line = udata; | |
212 const unsigned char* end_of_line = strchrn<unsigned char>(udata, | |
213 end - udata, | |
214 '\n'); | |
215 if (!end_of_line) { | |
216 udata = end_of_line = end; | |
217 } else { | |
218 udata = end_of_line + 1; | |
219 } | |
220 | |
221 bool is_printable = true; | |
222 | |
223 // If we are in unprintable mode, we need to see a line of at least | |
224 // kMinPrintableLine characters before we'll switch back. | |
225 const ptrdiff_t kMinPrintableLine = 4; | |
226 if (consecutive_unprintable && ((end_of_line - line) < kMinPrintableLine)) { | |
227 is_printable = false; | |
228 } else { | |
229 // Determine if the line contains only whitespace and printable | |
230 // characters. | |
231 bool is_entirely_whitespace = true; | |
232 for (const unsigned char* pos = line; pos < end_of_line; ++pos) { | |
233 if (isspace(*pos)) | |
234 continue; | |
235 is_entirely_whitespace = false; | |
236 if (!isprint(*pos)) { | |
237 is_printable = false; | |
238 break; | |
239 } | |
240 } | |
241 // Treat an empty line following unprintable data as unprintable. | |
242 if (consecutive_unprintable && is_entirely_whitespace) { | |
243 is_printable = false; | |
244 } | |
245 } | |
246 if (!is_printable) { | |
247 consecutive_unprintable += (udata - line); | |
248 continue; | |
249 } | |
250 // Print out the current line, but prefix with a count of prior unprintable | |
251 // characters. | |
252 if (consecutive_unprintable) { | |
253 LOG_V(level) << label << direction << "## " << consecutive_unprintable | |
254 << " consecutive unprintable ##"; | |
255 consecutive_unprintable = 0; | |
256 } | |
257 // Strip off trailing whitespace. | |
258 while ((end_of_line > line) && isspace(*(end_of_line-1))) { | |
259 --end_of_line; | |
260 } | |
261 // Filter out any private data | |
262 std::string substr(reinterpret_cast<const char*>(line), end_of_line - line); | |
263 std::string::size_type pos_private = substr.find("Email"); | |
264 if (pos_private == std::string::npos) { | |
265 pos_private = substr.find("Passwd"); | |
266 } | |
267 if (pos_private == std::string::npos) { | |
268 LOG_V(level) << label << direction << substr; | |
269 } else { | |
270 LOG_V(level) << label << direction << "## omitted for privacy ##"; | |
271 } | |
272 } | |
273 | |
274 if (state) { | |
275 state->unprintable_count_[input] = consecutive_unprintable; | |
276 } | |
277 } | |
278 | |
279 void InitDiagnosticLoggingDelegateFunction( | |
280 void (*delegate)(const std::string&)) { | |
281 #ifndef NDEBUG | |
282 // Ensure that this function is always called from the same thread. | |
283 base::subtle::NoBarrier_CompareAndSwap(&g_init_logging_delegate_thread_id, 0, | |
284 static_cast<base::subtle::Atomic32>(base::PlatformThread::CurrentId())); | |
285 DCHECK_EQ(g_init_logging_delegate_thread_id, | |
286 base::PlatformThread::CurrentId()); | |
287 #endif | |
288 CHECK(delegate); | |
289 // This function may be called with the same argument several times if the | |
290 // page is reloaded or there are several PeerConnections on one page with | |
291 // logging enabled. This is OK, we simply don't have to do anything. | |
292 if (delegate == g_logging_delegate_function) | |
293 return; | |
294 CHECK(!g_logging_delegate_function); | |
295 #ifdef NDEBUG | |
296 IPAddress::set_strip_sensitive(true); | |
297 #endif | |
298 g_logging_delegate_function = delegate; | |
299 | |
300 if (g_extra_logging_init_function) | |
301 g_extra_logging_init_function(delegate); | |
302 } | |
303 | |
304 void SetExtraLoggingInit( | |
305 void (*function)(void (*delegate)(const std::string&))) { | |
306 CHECK(function); | |
307 CHECK(!g_extra_logging_init_function); | |
308 g_extra_logging_init_function = function; | |
309 } | |
310 | |
311 } // namespace talk_base | |
OLD | NEW |