Source code
Revision control
Copy as Markdown
Other Tools
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
// Based on chromium's base/logging.cc, with a lot of simplifications.
#include "base/logging.h"
#include "base/immediate_crash.h"
#include "base/posix/safe_strerror.h"
#include "base/strings/string_util.h"
#include "base/strings/stringprintf.h"
#include "base/strings/utf_string_conversions.h"
#include "build/build_config.h"
#if BUILDFLAG(IS_WIN)
#include <windows.h>
#endif
#include <cstdio>
namespace logging {
static int g_min_log_level = 0;
// A log message handler that gets notified of every log message we process.
LogMessageHandlerFunction g_log_message_handler = nullptr;
void SetLogMessageHandler(LogMessageHandlerFunction handler) {
g_log_message_handler = handler;
}
LogMessageHandlerFunction GetLogMessageHandler() {
return g_log_message_handler;
}
bool ShouldCreateLogMessage(int severity) {
return severity >= g_min_log_level;
}
#if BUILDFLAG(IS_WIN)
// This has already been defined in the header, but defining it again as DWORD
// ensures that the type used in the header is equivalent to DWORD. If not,
// the redefinition is a compile error.
typedef DWORD SystemErrorCode;
#endif
SystemErrorCode GetLastSystemErrorCode() {
#if BUILDFLAG(IS_WIN)
return ::GetLastError();
#elif BUILDFLAG(IS_POSIX) || BUILDFLAG(IS_FUCHSIA)
return errno;
#endif
}
// For LOGGING_ERROR and above, always print to stderr.
const int kAlwaysPrintErrorLevel = LOGGING_ERROR;
static bool ShouldLogToStderr(int severity) {
return severity >= kAlwaysPrintErrorLevel;
}
const char* const log_severity_names[] = {"INFO", "WARNING", "ERROR", "FATAL"};
static_assert(LOGGING_NUM_SEVERITIES == std::size(log_severity_names),
"Incorrect number of log_severity_names");
const char* log_severity_name(int severity) {
if (severity >= 0 && severity < LOGGING_NUM_SEVERITIES) {
return log_severity_names[severity];
}
return "UNKNOWN";
}
LogMessage::LogMessage(const char* file, int line, LogSeverity severity)
: severity_(severity), file_(file), line_(line) {
// Don't let actions from this method affect the system error after returning.
base::ScopedClearLastError scoped_clear_last_error;
// Most logging initializes `file` from __FILE__. This isn't true for
// base::Location::Current() which already does the stripping (and is used
// for some logging, especially CHECKs).
// Note(moz): Upstream code mitigates this with a hack, but for our mozilla
// vendoring we don't, hence the long filenames shown in logs
// except for CHECKs.
{
stream_ << "[zucchini:";
if (severity_ >= 0) {
stream_ << log_severity_name(severity_);
} else {
stream_ << "VERBOSE" << -severity_;
}
stream_ << ":" << file << ":" << line << "] ";
}
message_start_ = stream_.str().length();
}
LogMessage::~LogMessage() {
// Don't let actions from this method affect the system error after returning.
base::ScopedClearLastError scoped_clear_last_error;
// Note(moz): Contrary to upstream code, we do not add an extra newline
// before forwarding the message. This is the format expected by
// the updater's log function.
std::string str(stream_.str());
// Give any log message handler first dibs on the message.
bool handled = g_log_message_handler &&
g_log_message_handler(severity_, file_, line_, message_start_, str);
if (!handled) {
if (ShouldLogToStderr(severity_)) {
fputs(str.c_str(), stderr);
fputc('\n', stderr);
}
else {
// Contrary to fputs(), puts() already writes a newline character
puts(str.c_str());
}
}
if (severity_ == LOGGING_FATAL) {
base::ImmediateCrash();
}
}
BASE_EXPORT std::string SystemErrorCodeToString(SystemErrorCode error_code) {
#if BUILDFLAG(IS_WIN)
LPWSTR msgbuf = nullptr;
DWORD len = ::FormatMessageW(
FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_IGNORE_INSERTS,
nullptr, error_code, 0, reinterpret_cast<LPWSTR>(&msgbuf), 0, nullptr);
if (len) {
std::u16string message = base::WideToUTF16(msgbuf);
::LocalFree(msgbuf);
msgbuf = nullptr;
// Messages returned by system end with line breaks.
return base::UTF16ToUTF8(base::CollapseWhitespace(message, true)) +
base::StringPrintf(" (0x%lX)", error_code);
}
return base::StringPrintf("Error (0x%lX) while retrieving error. (0x%lX)",
GetLastError(), error_code);
#elif BUILDFLAG(IS_POSIX) || BUILDFLAG(IS_FUCHSIA)
return base::safe_strerror(error_code) +
base::StringPrintf(" (%d)", error_code);
#endif // BUILDFLAG(IS_WIN)
}
#if BUILDFLAG(IS_WIN)
Win32ErrorLogMessage::Win32ErrorLogMessage(const char* file,
int line,
LogSeverity severity,
SystemErrorCode err)
: LogMessage(file, line, severity), err_(err) {}
Win32ErrorLogMessage::~Win32ErrorLogMessage() {
// Don't let actions from this method affect the system error after returning.
base::ScopedClearLastError scoped_clear_last_error;
stream() << ": " << SystemErrorCodeToString(err_);
}
#elif BUILDFLAG(IS_POSIX)
ErrnoLogMessage::ErrnoLogMessage(const char* file,
int line,
LogSeverity severity,
SystemErrorCode err)
: LogMessage(file, line, severity), err_(err) {}
ErrnoLogMessage::~ErrnoLogMessage() {
// Don't let actions from this method affect the system error after returning.
base::ScopedClearLastError scoped_clear_last_error;
stream() << ": " << SystemErrorCodeToString(err_);
}
#endif // BUILDFLAG(IS_WIN)
} // namespace logging