// Copyright (c) 1999, Google Inc.

// All rights reserved.

//

// Redistribution and use in source and binary forms, with or without

// modification, are permitted provided that the following conditions are

// met:

//

// * Redistributions of source code must retain the above copyright

// notice, this list of conditions and the following disclaimer.

// * Redistributions in binary form must reproduce the above

// copyright notice, this list of conditions and the following disclaimer

// in the documentation and/or other materials provided with the

// distribution.

// * Neither the name of Google Inc. nor the names of its

// contributors may be used to endorse or promote products derived from

// this software without specific prior written permission.

//

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

#define _GNU_SOURCE 1 // needed for O_NOFOLLOW and pread()/pwrite()

#include "utilities.h"

#include <algorithm>

#include <assert.h>

#include <iomanip>

#include <string>

#ifdef HAVE_UNISTD_H

# include <unistd.h> // For _exit.

#endif

#include <climits>

#include <sys/types.h>

#include <sys/stat.h>

#ifdef HAVE_SYS_UTSNAME_H

# include <sys/utsname.h> // For uname.

#endif

#include <fcntl.h>

#include <cstdio>

#include <iostream>

#include <stdarg.h>

#include <stdlib.h>

#ifdef HAVE_PWD_H

# include <pwd.h>

#endif

#ifdef HAVE_SYSLOG_H

# include <syslog.h>

#endif

#include <vector>

#include <errno.h> // for errno

#include <sstream>

#include "base/commandlineflags.h" // to get the program name

#include "glog/logging.h"

#include "glog/raw_logging.h"

#include "base/googleinit.h"

#ifdef HAVE_STACKTRACE

# include "stacktrace.h"

#endif

using std::string;

using std::vector;

using std::setw;

using std::setfill;

using std::hex;

using std::dec;

using std::min;

using std::ostream;

using std::ostringstream;

using std::FILE;

using std::fwrite;

using std::fclose;

using std::fflush;

using std::fprintf;

using std::perror;

#ifdef __QNX__

using std::fdopen;

#endif

#ifdef _WIN32

#define fdopen _fdopen

#endif

// There is no thread annotation support.

#define EXCLUSIVE_LOCKS_REQUIRED(mu)

static bool BoolFromEnv(const char *varname, bool defval) {

const char* const valstr = getenv(varname);

if (!valstr) {

return defval;

}

return memchr("tTyY1\0", valstr[0], 6) != NULL;

}

GLOG_DEFINE_bool(logtostderr, BoolFromEnv("GOOGLE_LOGTOSTDERR", false),

"log messages go to stderr instead of logfiles");

GLOG_DEFINE_bool(alsologtostderr, BoolFromEnv("GOOGLE_ALSOLOGTOSTDERR", false),

"log messages go to stderr in addition to logfiles");

GLOG_DEFINE_bool(colorlogtostderr, false,

"color messages logged to stderr (if supported by terminal)");

#ifdef OS_LINUX

GLOG_DEFINE_bool(drop_log_memory, true, "Drop in-memory buffers of log contents. "

"Logs can grow very quickly and they are rarely read before they "

"need to be evicted from memory. Instead, drop them from memory "

"as soon as they are flushed to disk.");

#endif

// By default, errors (including fatal errors) get logged to stderr as

// well as the file.

//

// The default is ERROR instead of FATAL so that users can see problems

// when they run a program without having to look in another file.

DEFINE_int32(stderrthreshold,

GOOGLE_NAMESPACE::GLOG_ERROR,

"log messages at or above this level are copied to stderr in "

"addition to logfiles. This flag obsoletes --alsologtostderr.");

GLOG_DEFINE_string(alsologtoemail, "",

"log messages go to these email addresses "

"in addition to logfiles");

GLOG_DEFINE_bool(log_prefix, true,

"Prepend the log prefix to the start of each log line");

GLOG_DEFINE_int32(minloglevel, 0, "Messages logged at a lower level than this don't "

"actually get logged anywhere");

GLOG_DEFINE_int32(logbuflevel, 0,

"Buffer log messages logged at this level or lower"

" (-1 means don't buffer; 0 means buffer INFO only;"

" ...)");

GLOG_DEFINE_int32(logbufsecs, 30,

"Buffer log messages for at most this many seconds");

GLOG_DEFINE_int32(logemaillevel, 999,

"Email log messages logged at this level or higher"

" (0 means email all; 3 means email FATAL only;"

" ...)");

GLOG_DEFINE_string(logmailer, "/bin/mail",

"Mailer used to send logging email");

// Compute the default value for --log_dir

static const char* DefaultLogDir() {

const char* env;

env = getenv("GOOGLE_LOG_DIR");

if (env != NULL && env[0] != '\0') {

return env;

}

env = getenv("TEST_TMPDIR");

if (env != NULL && env[0] != '\0') {

return env;

}

return "";

}

GLOG_DEFINE_int32(logfile_mode, 0664, "Log file mode/permissions.");

GLOG_DEFINE_string(log_dir, DefaultLogDir(),

"If specified, logfiles are written into this directory instead "

"of the default logging directory.");

GLOG_DEFINE_string(log_link, "", "Put additional links to the log "

"files in this directory");

GLOG_DEFINE_int32(max_log_size, 1800,

"approx. maximum log file size (in MB). A value of 0 will "

"be silently overridden to 1.");

GLOG_DEFINE_bool(stop_logging_if_full_disk, false,

"Stop attempting to log to disk if the disk is full.");

GLOG_DEFINE_string(log_backtrace_at, "",

"Emit a backtrace when logging at file:linenum.");

// TODO(hamaji): consider windows

#define PATH_SEPARATOR '/'

#ifndef HAVE_PREAD

#if defined(OS_WINDOWS)

#include <BaseTsd.h>

#define ssize_t SSIZE_T

#endif

static ssize_t pread(int fd, void* buf, size_t count, off_t offset) {

off_t orig_offset = lseek(fd, 0, SEEK_CUR);

if (orig_offset == (off_t)-1)

return -1;

if (lseek(fd, offset, SEEK_CUR) == (off_t)-1)

return -1;

ssize_t len = read(fd, buf, count);

if (len < 0)

return len;

if (lseek(fd, orig_offset, SEEK_SET) == (off_t)-1)

return -1;

return len;

}

#endif // !HAVE_PREAD

#ifndef HAVE_PWRITE

static ssize_t pwrite(int fd, void* buf, size_t count, off_t offset) {

off_t orig_offset = lseek(fd, 0, SEEK_CUR);

if (orig_offset == (off_t)-1)

return -1;

if (lseek(fd, offset, SEEK_CUR) == (off_t)-1)

return -1;

ssize_t len = write(fd, buf, count);

if (len < 0)

return len;

if (lseek(fd, orig_offset, SEEK_SET) == (off_t)-1)

return -1;

return len;

}

#endif // !HAVE_PWRITE

static void GetHostName(string* hostname) {

#if defined(HAVE_SYS_UTSNAME_H)

struct utsname buf;

if (0 != uname(&buf)) {

// ensure null termination on failure

*buf.nodename = '\0';

}

*hostname = buf.nodename;

#elif defined(OS_WINDOWS)

char buf[MAX_COMPUTERNAME_LENGTH + 1];

DWORD len = MAX_COMPUTERNAME_LENGTH + 1;

if (GetComputerNameA(buf, &len)) {

*hostname = buf;

} else {

hostname->clear();

}

#else

# warning There is no way to retrieve the host name.

*hostname = "(unknown)";

#endif

}

// Returns true iff terminal supports using colors in output.

static bool TerminalSupportsColor() {

bool term_supports_color = false;

#ifdef OS_WINDOWS

// on Windows TERM variable is usually not set, but the console does

// support colors.

term_supports_color = true;

#else

// On non-Windows platforms, we rely on the TERM variable.

const char* const term = getenv("TERM");

if (term != NULL && term[0] != '\0') {

term_supports_color =

!strcmp(term, "xterm") ||

!strcmp(term, "xterm-color") ||

!strcmp(term, "xterm-256color") ||

!strcmp(term, "screen-256color") ||

!strcmp(term, "konsole") ||

!strcmp(term, "konsole-16color") ||

!strcmp(term, "konsole-256color") ||

!strcmp(term, "screen") ||

!strcmp(term, "linux") ||

!strcmp(term, "cygwin");

}

#endif

return term_supports_color;

}

_START_GOOGLE_NAMESPACE_

enum GLogColor {

COLOR_DEFAULT,

COLOR_RED,

COLOR_GREEN,

COLOR_YELLOW

};

static GLogColor SeverityToColor(LogSeverity severity) {

assert(severity >= 0 && severity < NUM_SEVERITIES);

GLogColor color = COLOR_DEFAULT;

switch (severity) {

case GLOG_INFO:

color = COLOR_DEFAULT;

break;

case GLOG_WARNING:

color = COLOR_YELLOW;

break;

case GLOG_ERROR:

case GLOG_FATAL:

color = COLOR_RED;

break;

default:

// should never get here.

assert(false);

}

return color;

}

#ifdef OS_WINDOWS

// Returns the character attribute for the given color.

static WORD GetColorAttribute(GLogColor color) {

switch (color) {

case COLOR_RED: return FOREGROUND_RED;

case COLOR_GREEN: return FOREGROUND_GREEN;

case COLOR_YELLOW: return FOREGROUND_RED | FOREGROUND_GREEN;

default: return 0;

}

}

#else

// Returns the ANSI color code for the given color.

static const char* GetAnsiColorCode(GLogColor color) {

switch (color) {

case COLOR_RED: return "1";

case COLOR_GREEN: return "2";

case COLOR_YELLOW: return "3";

case COLOR_DEFAULT: return "";

};

return NULL; // stop warning about return type.

}

#endif // OS_WINDOWS

// Safely get max_log_size, overriding to 1 if it somehow gets defined as 0

static int32 MaxLogSize() {

return (FLAGS_max_log_size > 0 ? FLAGS_max_log_size : 1);

}

// An arbitrary limit on the length of a single log message. This

// is so that streaming can be done more efficiently.

const size_t LogMessage::kMaxLogMessageLen = 30000;

struct LogMessage::LogMessageData {

LogMessageData();

int preserved_errno_; // preserved errno

// Buffer space; contains complete message text.

char message_text_[LogMessage::kMaxLogMessageLen+1];

LogStream stream_;

char severity_; // What level is this LogMessage logged at?

int line_; // line number where logging call is.

void (LogMessage::*send_method_)(); // Call this in destructor to send

union { // At most one of these is used: union to keep the size low.

LogSink* sink_; // NULL or sink to send message to

std::vector<std::string>* outvec_; // NULL or vector to push message onto

std::string* message_; // NULL or string to write message into

};

time_t timestamp_; // Time of creation of LogMessage

struct ::tm tm_time_; // Time of creation of LogMessage

size_t num_prefix_chars_; // # of chars of prefix in this message

size_t num_chars_to_log_; // # of chars of msg to send to log

size_t num_chars_to_syslog_; // # of chars of msg to send to syslog

const char* basename_; // basename of file that called LOG

const char* fullname_; // fullname of file that called LOG

bool has_been_flushed_; // false => data has not been flushed

bool first_fatal_; // true => this was first fatal msg

private:

LogMessageData(const LogMessageData&);

void operator=(const LogMessageData&);

};

// A mutex that allows only one thread to log at a time, to keep things from

// getting jumbled. Some other very uncommon logging operations (like

// changing the destination file for log messages of a given severity) also

// lock this mutex. Please be sure that anybody who might possibly need to

// lock it does so.

static Mutex log_mutex;

// Number of messages sent at each severity. Under log_mutex.

int64 LogMessage::num_messages_[NUM_SEVERITIES] = {0, 0, 0, 0};

// Globally disable log writing (if disk is full)

static bool stop_writing = false;

const char*const LogSeverityNames[NUM_SEVERITIES] = {

"INFO", "WARNING", "ERROR", "FATAL"

};

// Has the user called SetExitOnDFatal(true)?

static bool exit_on_dfatal = true;

const char* GetLogSeverityName(LogSeverity severity) {

return LogSeverityNames[severity];

}

static bool SendEmailInternal(const char*dest, const char *subject,

const char*body, bool use_logging);

base::Logger::~Logger() {

}

namespace {

// Encapsulates all file-system related state

class LogFileObject : public base::Logger {

public:

LogFileObject(LogSeverity severity, const char* base_filename);

~LogFileObject();

virtual void Write(bool force_flush, // Should we force a flush here?

time_t timestamp, // Timestamp for this entry

const char* message,

int message_len);

// Configuration options

void SetBasename(const char* basename);

void SetExtension(const char* ext);

void SetSymlinkBasename(const char* symlink_basename);

// Normal flushing routine

virtual void Flush();

// It is the actual file length for the system loggers,

// i.e., INFO, ERROR, etc.

virtual uint32 LogSize() {

MutexLock l(&lock_);

return file_length_;

}

// Internal flush routine. Exposed so that FlushLogFilesUnsafe()

// can avoid grabbing a lock. Usually Flush() calls it after

// acquiring lock_.

void FlushUnlocked();

private:

static const uint32 kRolloverAttemptFrequency = 0x20;

Mutex lock_;

bool base_filename_selected_;

string base_filename_;

string symlink_basename_;

string filename_extension_; // option users can specify (eg to add port#)

FILE* file_;

LogSeverity severity_;

uint32 bytes_since_flush_;

uint32 dropped_mem_length_;

uint32 file_length_;

unsigned int rollover_attempt_;

int64 next_flush_time_; // cycle count at which to flush log

// Actually create a logfile using the value of base_filename_ and the

// supplied argument time_pid_string

// REQUIRES: lock_ is held

bool CreateLogfile(const string& time_pid_string);

};

} // namespace

class LogDestination {

public:

friend class LogMessage;

friend void ReprintFatalMessage();

friend base::Logger* base::GetLogger(LogSeverity);

friend void base::SetLogger(LogSeverity, base::Logger*);

// These methods are just forwarded to by their global versions.

static void SetLogDestination(LogSeverity severity,

const char* base_filename);

static void SetLogSymlink(LogSeverity severity,

const char* symlink_basename);

static void AddLogSink(LogSink *destination);

static void RemoveLogSink(LogSink *destination);

static void SetLogFilenameExtension(const char* filename_extension);

static void SetStderrLogging(LogSeverity min_severity);

static void SetEmailLogging(LogSeverity min_severity, const char* addresses);

static void LogToStderr();

// Flush all log files that are at least at the given severity level

static void FlushLogFiles(int min_severity);

static void FlushLogFilesUnsafe(int min_severity);

// we set the maximum size of our packet to be 1400, the logic being

// to prevent fragmentation.

// Really this number is arbitrary.

static const int kNetworkBytes = 1400;

static const string& hostname();

static const bool& terminal_supports_color() {

return terminal_supports_color_;

}

static void DeleteLogDestinations();

private:

LogDestination(LogSeverity severity, const char* base_filename);

~LogDestination() { }

// Take a log message of a particular severity and log it to stderr

// iff it's of a high enough severity to deserve it.

static void MaybeLogToStderr(LogSeverity severity, const char* message,

size_t len);

// Take a log message of a particular severity and log it to email

// iff it's of a high enough severity to deserve it.

static void MaybeLogToEmail(LogSeverity severity, const char* message,

size_t len);

// Take a log message of a particular severity and log it to a file

// iff the base filename is not "" (which means "don't log to me")

static void MaybeLogToLogfile(LogSeverity severity,

time_t timestamp,

const char* message, size_t len);

// Take a log message of a particular severity and log it to the file

// for that severity and also for all files with severity less than

// this severity.

static void LogToAllLogfiles(LogSeverity severity,

time_t timestamp,

const char* message, size_t len);

// Send logging info to all registered sinks.

static void LogToSinks(LogSeverity severity,

const char *full_filename,

const char *base_filename,

int line,

const struct ::tm* tm_time,

const char* message,

size_t message_len);

// Wait for all registered sinks via WaitTillSent

// including the optional one in "data".

static void WaitForSinks(LogMessage::LogMessageData* data);

static LogDestination* log_destination(LogSeverity severity);

LogFileObject fileobject_;

base::Logger* logger_; // Either &fileobject_, or wrapper around it

static LogDestination* log_destinations_[NUM_SEVERITIES];

static LogSeverity email_logging_severity_;

static string addresses_;

static string hostname_;

static bool terminal_supports_color_;

// arbitrary global logging destinations.

static vector<LogSink*>* sinks_;

// Protects the vector sinks_,

// but not the LogSink objects its elements reference.

static Mutex sink_mutex_;

// Disallow

LogDestination(const LogDestination&);

LogDestination& operator=(const LogDestination&);

};

// Errors do not get logged to email by default.

LogSeverity LogDestination::email_logging_severity_ = 99999;

string LogDestination::addresses_;

string LogDestination::hostname_;

vector<LogSink*>* LogDestination::sinks_ = NULL;

Mutex LogDestination::sink_mutex_;

bool LogDestination::terminal_supports_color_ = TerminalSupportsColor();

/* static */

const string& LogDestination::hostname() {

if (hostname_.empty()) {

GetHostName(&hostname_);

if (hostname_.empty()) {

hostname_ = "(unknown)";

}

}

return hostname_;

}

LogDestination::LogDestination(LogSeverity severity,

const char* base_filename)

: fileobject_(severity, base_filename),

logger_(&fileobject_) {

}

inline void LogDestination::FlushLogFilesUnsafe(int min_severity) {

// assume we have the log_mutex or we simply don't care

// about it

for (int i = min_severity; i < NUM_SEVERITIES; i++) {

LogDestination* log = log_destinations_[i];

if (log != NULL) {

// Flush the base fileobject_ logger directly instead of going

// through any wrappers to reduce chance of deadlock.

log->fileobject_.FlushUnlocked();

}

}

}

inline void LogDestination::FlushLogFiles(int min_severity) {

// Prevent any subtle race conditions by wrapping a mutex lock around

// all this stuff.

MutexLock l(&log_mutex);

for (int i = min_severity; i < NUM_SEVERITIES; i++) {

LogDestination* log = log_destination(i);

if (log != NULL) {

log->logger_->Flush();

}

}

}

inline void LogDestination::SetLogDestination(LogSeverity severity,

const char* base_filename) {

assert(severity >= 0 && severity < NUM_SEVERITIES);

// Prevent any subtle race conditions by wrapping a mutex lock around

// all this stuff.

MutexLock l(&log_mutex);

log_destination(severity)->fileobject_.SetBasename(base_filename);

}

inline void LogDestination::SetLogSymlink(LogSeverity severity,

const char* symlink_basename) {

CHECK_GE(severity, 0);

CHECK_LT(severity, NUM_SEVERITIES);

MutexLock l(&log_mutex);

log_destination(severity)->fileobject_.SetSymlinkBasename(symlink_basename);

}

inline void LogDestination::AddLogSink(LogSink *destination) {

// Prevent any subtle race conditions by wrapping a mutex lock around

// all this stuff.

MutexLock l(&sink_mutex_);

if (!sinks_) sinks_ = new vector<LogSink*>;

sinks_->push_back(destination);

}

inline void LogDestination::RemoveLogSink(LogSink *destination) {

// Prevent any subtle race conditions by wrapping a mutex lock around

// all this stuff.

MutexLock l(&sink_mutex_);

// This doesn't keep the sinks in order, but who cares?

if (sinks_) {

for (int i = sinks_->size() - 1; i >= 0; i--) {

if ((*sinks_)[i] == destination) {

(*sinks_)[i] = (*sinks_)[sinks_->size() - 1];

sinks_->pop_back();

break;

}

}

}

}

inline void LogDestination::SetLogFilenameExtension(const char* ext) {

// Prevent any subtle race conditions by wrapping a mutex lock around

// all this stuff.

MutexLock l(&log_mutex);

for ( int severity = 0; severity < NUM_SEVERITIES; ++severity ) {

log_destination(severity)->fileobject_.SetExtension(ext);

}

}

inline void LogDestination::SetStderrLogging(LogSeverity min_severity) {

assert(min_severity >= 0 && min_severity < NUM_SEVERITIES);

// Prevent any subtle race conditions by wrapping a mutex lock around

// all this stuff.

MutexLock l(&log_mutex);

FLAGS_stderrthreshold = min_severity;

}

inline void LogDestination::LogToStderr() {

// *Don't* put this stuff in a mutex lock, since SetStderrLogging &

// SetLogDestination already do the locking!

SetStderrLogging(0); // thus everything is "also" logged to stderr

for ( int i = 0; i < NUM_SEVERITIES; ++i ) {

SetLogDestination(i, ""); // "" turns off logging to a logfile

}

}

inline void LogDestination::SetEmailLogging(LogSeverity min_severity,

const char* addresses) {

assert(min_severity >= 0 && min_severity < NUM_SEVERITIES);

// Prevent any subtle race conditions by wrapping a mutex lock around

// all this stuff.

MutexLock l(&log_mutex);

LogDestination::email_logging_severity_ = min_severity;

LogDestination::addresses_ = addresses;

}

static void ColoredWriteToStderr(LogSeverity severity,

const char* message, size_t len) {

const GLogColor color =

(LogDestination::terminal_supports_color() && FLAGS_colorlogtostderr) ?

SeverityToColor(severity) : COLOR_DEFAULT;

// Avoid using cerr from this module since we may get called during

// exit code, and cerr may be partially or fully destroyed by then.

if (COLOR_DEFAULT == color) {

fwrite(message, len, 1, stderr);

return;

}

#ifdef OS_WINDOWS

const HANDLE stderr_handle = GetStdHandle(STD_ERROR_HANDLE);

// Gets the current text color.

CONSOLE_SCREEN_BUFFER_INFO buffer_info;

GetConsoleScreenBufferInfo(stderr_handle, &buffer_info);

const WORD old_color_attrs = buffer_info.wAttributes;

// We need to flush the stream buffers into the console before each

// SetConsoleTextAttribute call lest it affect the text that is already

// printed but has not yet reached the console.

fflush(stderr);

SetConsoleTextAttribute(stderr_handle,

GetColorAttribute(color) | FOREGROUND_INTENSITY);

fwrite(message, len, 1, stderr);

fflush(stderr);

// Restores the text color.

SetConsoleTextAttribute(stderr_handle, old_color_attrs);

#else

fprintf(stderr, "\033[0;3%sm", GetAnsiColorCode(color));

fwrite(message, len, 1, stderr);

fprintf(stderr, "\033[m"); // Resets the terminal to default.

#endif // OS_WINDOWS

}

static void WriteToStderr(const char* message, size_t len) {

// Avoid using cerr from this module since we may get called during

// exit code, and cerr may be partially or fully destroyed by then.

fwrite(message, len, 1, stderr);

}

inline void LogDestination::MaybeLogToStderr(LogSeverity severity,

const char* message, size_t len) {

if ((severity >= FLAGS_stderrthreshold) || FLAGS_alsologtostderr) {

ColoredWriteToStderr(severity, message, len);

#ifdef OS_WINDOWS

// On Windows, also output to the debugger

::OutputDebugStringA(string(message,len).c_str());

#endif

}

}

inline void LogDestination::MaybeLogToEmail(LogSeverity severity,

const char* message, size_t len) {

if (severity >= email_logging_severity_ ||

severity >= FLAGS_logemaillevel) {

string to(FLAGS_alsologtoemail);

if (!addresses_.empty()) {

if (!to.empty()) {

to += ",";

}

to += addresses_;

}

const string subject(string("[LOG] ") + LogSeverityNames[severity] + ": " +

glog_internal_namespace_::ProgramInvocationShortName());

string body(hostname());

body += "\n\n";

body.append(message, len);

// should NOT use SendEmail(). The caller of this function holds the

// log_mutex and SendEmail() calls LOG/VLOG which will block trying to

// acquire the log_mutex object. Use SendEmailInternal() and set

// use_logging to false.

SendEmailInternal(to.c_str(), subject.c_str(), body.c_str(), false);

}

}

inline void LogDestination::MaybeLogToLogfile(LogSeverity severity,

time_t timestamp,

const char* message,

size_t len) {

const bool should_flush = severity > FLAGS_logbuflevel;

LogDestination* destination = log_destination(severity);

destination->logger_->Write(should_flush, timestamp, message, len);

}

inline void LogDestination::LogToAllLogfiles(LogSeverity severity,

time_t timestamp,

const char* message,

size_t len) {

if ( FLAGS_logtostderr ) { // global flag: never log to file

ColoredWriteToStderr(severity, message, len);

} else {

for (int i = severity; i >= 0; --i)

LogDestination::MaybeLogToLogfile(i, timestamp, message, len);

}

}

inline void LogDestination::LogToSinks(LogSeverity severity,

const char *full_filename,

const char *base_filename,

int line,

const struct ::tm* tm_time,

const char* message,

size_t message_len) {

ReaderMutexLock l(&sink_mutex_);

if (sinks_) {

for (int i = sinks_->size() - 1; i >= 0; i--) {

(*sinks_)[i]->send(severity, full_filename, base_filename,

line, tm_time, message, message_len);

}

}

}

inline void LogDestination::WaitForSinks(LogMessage::LogMessageData* data) {

ReaderMutexLock l(&sink_mutex_);

if (sinks_) {

for (int i = sinks_->size() - 1; i >= 0; i--) {

(*sinks_)[i]->WaitTillSent();

}

}

const bool send_to_sink =

(data->send_method_ == &LogMessage::SendToSink) ||

(data->send_method_ == &LogMessage::SendToSinkAndLog);

if (send_to_sink && data->sink_ != NULL) {

data->sink_->WaitTillSent();

}

}

LogDestination* LogDestination::log_destinations_[NUM_SEVERITIES];

inline LogDestination* LogDestination::log_destination(LogSeverity severity) {

assert(severity >=0 && severity < NUM_SEVERITIES);

if (!log_destinations_[severity]) {

log_destinations_[severity] = new LogDestination(severity, NULL);

}

return log_destinations_[severity];

}

void LogDestination::DeleteLogDestinations() {

for (int severity = 0; severity < NUM_SEVERITIES; ++severity) {

delete log_destinations_[severity];

log_destinations_[severity] = NULL;

}

MutexLock l(&sink_mutex_);

delete sinks_;

sinks_ = NULL;

}

namespace {

LogFileObject::LogFileObject(LogSeverity severity,

const char* base_filename)

: base_filename_selected_(base_filename != NULL),

base_filename_((base_filename != NULL) ? base_filename : ""),

symlink_basename_(glog_internal_namespace_::ProgramInvocationShortName()),

filename_extension_(),

file_(NULL),

severity_(severity),

bytes_since_flush_(0),

dropped_mem_length_(0),

file_length_(0),

rollover_attempt_(kRolloverAttemptFrequency-1),

next_flush_time_(0) {

assert(severity >= 0);

assert(severity < NUM_SEVERITIES);

}

LogFileObject::~LogFileObject() {

MutexLock l(&lock_);

if (file_ != NULL) {

fclose(file_);

file_ = NULL;

}

}

void LogFileObject::SetBasename(const char* basename) {

MutexLock l(&lock_);

base_filename_selected_ = true;

if (base_filename_ != basename) {

// Get rid of old log file since we are changing names

if (file_ != NULL) {

fclose(file_);

file_ = NULL;

rollover_attempt_ = kRolloverAttemptFrequency-1;

}

base_filename_ = basename;

}

}

void LogFileObject::SetExtension(const char* ext) {

MutexLock l(&lock_);

if (filename_extension_ != ext) {

// Get rid of old log file since we are changing names

if (file_ != NULL) {

fclose(file_);

file_ = NULL;

rollover_attempt_ = kRolloverAttemptFrequency-1;

}

filename_extension_ = ext;

}

}

void LogFileObject::SetSymlinkBasename(const char* symlink_basename) {

MutexLock l(&lock_);

symlink_basename_ = symlink_basename;

}

void LogFileObject::Flush() {

MutexLock l(&lock_);

FlushUnlocked();

}

void LogFileObject::FlushUnlocked(){

if (file_ != NULL) {

fflush(file_);

bytes_since_flush_ = 0;

}

// Figure out when we are due for another flush.

const int64 next = (FLAGS_logbufsecs

* static_cast<int64>(1000000)); // in usec

next_flush_time_ = CycleClock_Now() + UsecToCycles(next);

}

bool LogFileObject::CreateLogfile(const string& time_pid_string) {

string string_filename = base_filename_+filename_extension_+

time_pid_string;

const char* filename = string_filename.c_str();

int fd = open(filename, O_WRONLY | O_CREAT | O_EXCL, FLAGS_logfile_mode);

if (fd == -1) return false;

#ifdef HAVE_FCNTL

// Mark the file close-on-exec. We don't really care if this fails

fcntl(fd, F_SETFD, FD_CLOEXEC);

#endif

file_ = fdopen(fd, "a"); // Make a FILE*.

if (file_ == NULL) { // Man, we're screwed!

close(fd);

unlink(filename); // Erase the half-baked evidence: an unusable log file

return false;

}

// We try to create a symlink called <program_name>.<severity>,

// which is easier to use. (Every time we create a new logfile,

// we destroy the old symlink and create a new one, so it always

// points to the latest logfile.) If it fails, we're sad but it's

// no error.

if (!symlink_basename_.empty()) {

// take directory from filename

const char* slash = strrchr(filename, PATH_SEPARATOR);

const string linkname =

symlink_basename_ + '.' + LogSeverityNames[severity_];

string linkpath;

if ( slash ) linkpath = string(filename, slash-filename+1); // get dirname

linkpath += linkname;

unlink(linkpath.c_str()); // delete old one if it exists

#if defined(OS_WINDOWS)

// TODO(hamaji): Create lnk file on Windows?

#elif defined(HAVE_UNISTD_H)

// We must have unistd.h.

// Make the symlink be relative (in the same dir) so that if the

// entire log directory gets relocated the link is still valid.

const char *linkdest = slash ? (slash + 1) : filename;

if (symlink(linkdest, linkpath.c_str()) != 0) {

// silently ignore failures

}

// Make an additional link to the log file in a place specified by

// FLAGS_log_link, if indicated

if (!FLAGS_log_link.empty()) {

linkpath = FLAGS_log_link + "/" + linkname;

unlink(linkpath.c_str()); // delete old one if it exists

if (symlink(filename, linkpath.c_str()) != 0) {

// silently ignore failures

}

}

#endif

}

return true; // Everything worked

}

void LogFileObject::Write(bool force_flush,

time_t timestamp,

const char* message,

int message_len) {

MutexLock l(&lock_);

// We don't log if the base_name_ is "" (which means "don't write")

if (base_filename_selected_ && base_filename_.empty()) {

return;

}

if (static_cast<int>(file_length_ >> 20) >= MaxLogSize() ||

PidHasChanged()) {

if (file_ != NULL) fclose(file_);

file_ = NULL;

file_length_ = bytes_since_flush_ = dropped_mem_length_ = 0;

rollover_attempt_ = kRolloverAttemptFrequency-1;

}

// If there's no destination file, make one before outputting

if (file_ == NULL) {

// Try to rollover the log file every 32 log messages. The only time

// this could matter would be when we have trouble creating the log

// file. If that happens, we'll lose lots of log messages, of course!

if (++rollover_attempt_ != kRolloverAttemptFrequency) return;

rollover_attempt_ = 0;

struct ::tm tm_time;

localtime_r(&timestamp, &tm_time);

// The logfile's filename will have the date/time & pid in it

ostringstream time_pid_stream;

time_pid_stream.fill('0');

time_pid_stream << 1900+tm_time.tm_year

<< setw(2) << 1+tm_time.tm_mon

<< setw(2) << tm_time.tm_mday

<< '-'