1 // Copyright 2016 The Chromium Authors
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 "base/syslog_logging.h"
6
7 #include "build/build_config.h"
8
9 #if BUILDFLAG(IS_WIN)
10 #include <windows.h>
11
12 #include <sddl.h>
13
14 #include "base/debug/stack_trace.h"
15 #include "base/strings/string_util.h"
16 #include "base/win/scoped_handle.h"
17 #include "base/win/win_util.h"
18 #elif BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS)
19 // <syslog.h> defines LOG_INFO, LOG_WARNING macros that could conflict with
20 // base::LOG_INFO, base::LOG_WARNING.
21 #include <syslog.h>
22 #undef LOG_INFO
23 #undef LOG_WARNING
24 #endif
25
26 #include <ostream>
27 #include <string>
28
29 namespace logging {
30
31 namespace {
32
33 // The syslog logging is on by default, but tests or fuzzers can disable it.
34 bool g_logging_enabled = true;
35
36 } // namespace
37
38 #if BUILDFLAG(IS_WIN)
39
40 namespace {
41
42 std::string* g_event_source_name = nullptr;
43 uint16_t g_category = 0;
44 uint32_t g_event_id = 0;
45 std::wstring* g_user_sid = nullptr;
46
47 class EventLogHandleTraits {
48 public:
49 using Handle = HANDLE;
50
51 EventLogHandleTraits() = delete;
52 EventLogHandleTraits(const EventLogHandleTraits&) = delete;
53 EventLogHandleTraits& operator=(const EventLogHandleTraits&) = delete;
54
55 // Closes the handle.
CloseHandle(HANDLE handle)56 static bool CloseHandle(HANDLE handle) {
57 return ::DeregisterEventSource(handle) != FALSE;
58 }
59
60 // Returns true if the handle value is valid.
IsHandleValid(HANDLE handle)61 static bool IsHandleValid(HANDLE handle) { return handle != nullptr; }
62
63 // Returns null handle value.
NullHandle()64 static HANDLE NullHandle() { return nullptr; }
65 };
66
67 using ScopedEventLogHandle =
68 base::win::GenericScopedHandle<EventLogHandleTraits,
69 base::win::DummyVerifierTraits>;
70
71 } // namespace
72
SetEventSource(const std::string & name,uint16_t category,uint32_t event_id)73 void SetEventSource(const std::string& name,
74 uint16_t category,
75 uint32_t event_id) {
76 DCHECK_EQ(nullptr, g_event_source_name);
77 g_event_source_name = new std::string(name);
78 g_category = category;
79 g_event_id = event_id;
80 DCHECK_EQ(nullptr, g_user_sid);
81 g_user_sid = new std::wstring();
82 base::win::GetUserSidString(g_user_sid);
83 }
84
ResetEventSourceForTesting()85 void ResetEventSourceForTesting() {
86 delete g_event_source_name;
87 g_event_source_name = nullptr;
88 delete g_user_sid;
89 g_user_sid = nullptr;
90 }
91
92 #endif // BUILDFLAG(IS_WIN)
93
EventLogMessage(const char * file,int line,LogSeverity severity)94 EventLogMessage::EventLogMessage(const char* file,
95 int line,
96 LogSeverity severity)
97 : log_message_(file, line, severity) {
98 }
99
~EventLogMessage()100 EventLogMessage::~EventLogMessage() {
101 if (!g_logging_enabled)
102 return;
103
104 #if BUILDFLAG(IS_WIN)
105 // If g_event_source_name is nullptr (which it is per default) SYSLOG will
106 // degrade gracefully to regular LOG. If you see this happening most probably
107 // you are using SYSLOG before you called SetEventSourceName.
108 if (g_event_source_name == nullptr)
109 return;
110
111 ScopedEventLogHandle event_log_handle(
112 RegisterEventSourceA(nullptr, g_event_source_name->c_str()));
113
114 if (!event_log_handle.is_valid()) {
115 stream() << " !!NOT ADDED TO EVENTLOG!!";
116 return;
117 }
118
119 std::string message(log_message_.str());
120 WORD log_type = EVENTLOG_ERROR_TYPE;
121 switch (log_message_.severity()) {
122 case LOGGING_INFO:
123 log_type = EVENTLOG_INFORMATION_TYPE;
124 break;
125 case LOGGING_WARNING:
126 log_type = EVENTLOG_WARNING_TYPE;
127 break;
128 case LOGGING_ERROR:
129 case LOGGING_FATAL:
130 // The price of getting the stack trace is not worth the hassle for
131 // non-error conditions.
132 base::debug::StackTrace trace;
133 message.append(trace.ToString());
134 log_type = EVENTLOG_ERROR_TYPE;
135 break;
136 }
137 LPCSTR strings[1] = {message.data()};
138 PSID user_sid = nullptr;
139 if (!::ConvertStringSidToSid(g_user_sid->c_str(), &user_sid)) {
140 stream() << " !!ERROR GETTING USER SID!!";
141 }
142
143 if (!ReportEventA(event_log_handle.get(), log_type, g_category, g_event_id,
144 user_sid, 1, 0, strings, nullptr)) {
145 stream() << " !!NOT ADDED TO EVENTLOG!!";
146 }
147
148 if (user_sid != nullptr)
149 ::LocalFree(user_sid);
150 #elif BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS)
151 const char kEventSource[] = "chrome";
152 openlog(kEventSource, LOG_NOWAIT | LOG_PID, LOG_USER);
153 // We can't use the defined names for the logging severity from syslog.h
154 // because they collide with the names of our own severity levels. Therefore
155 // we use the actual values which of course do not match ours.
156 // See sys/syslog.h for reference.
157 int priority = 3;
158 switch (log_message_.severity()) {
159 case LOGGING_INFO:
160 priority = 6;
161 break;
162 case LOGGING_WARNING:
163 priority = 4;
164 break;
165 case LOGGING_ERROR:
166 priority = 3;
167 break;
168 case LOGGING_FATAL:
169 priority = 2;
170 break;
171 }
172 syslog(priority, "%s", log_message_.str().c_str());
173 closelog();
174 #endif // BUILDFLAG(IS_WIN)
175 }
176
SetSyslogLoggingForTesting(bool logging_enabled)177 void SetSyslogLoggingForTesting(bool logging_enabled) {
178 g_logging_enabled = logging_enabled;
179 }
180
181 } // namespace logging
182