Move GLog/GFlags to extern/
[blender.git] / extern / glog / src / logging.cc
1 // Copyright (c) 1999, Google Inc.
2 // All rights reserved.
3 //
4 // Redistribution and use in source and binary forms, with or without
5 // modification, are permitted provided that the following conditions are
6 // met:
7 //
8 //     * Redistributions of source code must retain the above copyright
9 // notice, this list of conditions and the following disclaimer.
10 //     * Redistributions in binary form must reproduce the above
11 // copyright notice, this list of conditions and the following disclaimer
12 // in the documentation and/or other materials provided with the
13 // distribution.
14 //     * Neither the name of Google Inc. nor the names of its
15 // contributors may be used to endorse or promote products derived from
16 // this software without specific prior written permission.
17 //
18 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29
30 #define _GNU_SOURCE 1 // needed for O_NOFOLLOW and pread()/pwrite()
31
32 #include "utilities.h"
33
34 #include <algorithm>
35 #include <assert.h>
36 #include <iomanip>
37 #include <string>
38 #ifdef HAVE_UNISTD_H
39 # include <unistd.h>  // For _exit.
40 #endif
41 #include <climits>
42 #include <sys/types.h>
43 #include <sys/stat.h>
44 #ifdef HAVE_SYS_UTSNAME_H
45 # include <sys/utsname.h>  // For uname.
46 #endif
47 #include <fcntl.h>
48 #include <cstdio>
49 #include <iostream>
50 #include <stdarg.h>
51 #include <stdlib.h>
52 #ifdef HAVE_PWD_H
53 # include <pwd.h>
54 #endif
55 #ifdef HAVE_SYSLOG_H
56 # include <syslog.h>
57 #endif
58 #include <vector>
59 #include <errno.h>                   // for errno
60 #include <sstream>
61 #include "base/commandlineflags.h"        // to get the program name
62 #include "glog/logging.h"
63 #include "glog/raw_logging.h"
64 #include "base/googleinit.h"
65
66 #ifdef HAVE_STACKTRACE
67 # include "stacktrace.h"
68 #endif
69
70 using std::string;
71 using std::vector;
72 using std::setw;
73 using std::setfill;
74 using std::hex;
75 using std::dec;
76 using std::min;
77 using std::ostream;
78 using std::ostringstream;
79
80 using std::FILE;
81 using std::fwrite;
82 using std::fclose;
83 using std::fflush;
84 using std::fprintf;
85 using std::perror;
86
87 #ifdef __QNX__
88 using std::fdopen;
89 #endif
90
91 #ifdef _WIN32
92 #define fdopen _fdopen
93 #endif
94
95 // There is no thread annotation support.
96 #define EXCLUSIVE_LOCKS_REQUIRED(mu)
97
98 static bool BoolFromEnv(const char *varname, bool defval) {
99   const char* const valstr = getenv(varname);
100   if (!valstr) {
101     return defval;
102   }
103   return memchr("tTyY1\0", valstr[0], 6) != NULL;
104 }
105
106 GLOG_DEFINE_bool(logtostderr, BoolFromEnv("GOOGLE_LOGTOSTDERR", false),
107                  "log messages go to stderr instead of logfiles");
108 GLOG_DEFINE_bool(alsologtostderr, BoolFromEnv("GOOGLE_ALSOLOGTOSTDERR", false),
109                  "log messages go to stderr in addition to logfiles");
110 GLOG_DEFINE_bool(colorlogtostderr, false,
111                  "color messages logged to stderr (if supported by terminal)");
112 #ifdef OS_LINUX
113 GLOG_DEFINE_bool(drop_log_memory, true, "Drop in-memory buffers of log contents. "
114                  "Logs can grow very quickly and they are rarely read before they "
115                  "need to be evicted from memory. Instead, drop them from memory "
116                  "as soon as they are flushed to disk.");
117 _START_GOOGLE_NAMESPACE_
118 namespace logging {
119 static const int64 kPageSize = getpagesize();
120 }
121 _END_GOOGLE_NAMESPACE_
122 #endif
123
124 // By default, errors (including fatal errors) get logged to stderr as
125 // well as the file.
126 //
127 // The default is ERROR instead of FATAL so that users can see problems
128 // when they run a program without having to look in another file.
129 DEFINE_int32(stderrthreshold,
130              GOOGLE_NAMESPACE::GLOG_ERROR,
131              "log messages at or above this level are copied to stderr in "
132              "addition to logfiles.  This flag obsoletes --alsologtostderr.");
133
134 GLOG_DEFINE_string(alsologtoemail, "",
135                    "log messages go to these email addresses "
136                    "in addition to logfiles");
137 GLOG_DEFINE_bool(log_prefix, true,
138                  "Prepend the log prefix to the start of each log line");
139 GLOG_DEFINE_int32(minloglevel, 0, "Messages logged at a lower level than this don't "
140                   "actually get logged anywhere");
141 GLOG_DEFINE_int32(logbuflevel, 0,
142                   "Buffer log messages logged at this level or lower"
143                   " (-1 means don't buffer; 0 means buffer INFO only;"
144                   " ...)");
145 GLOG_DEFINE_int32(logbufsecs, 30,
146                   "Buffer log messages for at most this many seconds");
147 GLOG_DEFINE_int32(logemaillevel, 999,
148                   "Email log messages logged at this level or higher"
149                   " (0 means email all; 3 means email FATAL only;"
150                   " ...)");
151 GLOG_DEFINE_string(logmailer, "/bin/mail",
152                    "Mailer used to send logging email");
153
154 // Compute the default value for --log_dir
155 static const char* DefaultLogDir() {
156   const char* env;
157   env = getenv("GOOGLE_LOG_DIR");
158   if (env != NULL && env[0] != '\0') {
159     return env;
160   }
161   env = getenv("TEST_TMPDIR");
162   if (env != NULL && env[0] != '\0') {
163     return env;
164   }
165   return "";
166 }
167
168 GLOG_DEFINE_int32(logfile_mode, 0664, "Log file mode/permissions.");
169
170 GLOG_DEFINE_string(log_dir, DefaultLogDir(),
171                    "If specified, logfiles are written into this directory instead "
172                    "of the default logging directory.");
173 GLOG_DEFINE_string(log_link, "", "Put additional links to the log "
174                    "files in this directory");
175
176 GLOG_DEFINE_int32(max_log_size, 1800,
177                   "approx. maximum log file size (in MB). A value of 0 will "
178                   "be silently overridden to 1.");
179
180 GLOG_DEFINE_bool(stop_logging_if_full_disk, false,
181                  "Stop attempting to log to disk if the disk is full.");
182
183 GLOG_DEFINE_string(log_backtrace_at, "",
184                    "Emit a backtrace when logging at file:linenum.");
185
186 // TODO(hamaji): consider windows
187 #define PATH_SEPARATOR '/'
188
189 #ifndef HAVE_PREAD
190 #if defined(OS_WINDOWS)
191 #include <BaseTsd.h>
192 #define ssize_t SSIZE_T
193 #endif
194 static ssize_t pread(int fd, void* buf, size_t count, off_t offset) {
195   off_t orig_offset = lseek(fd, 0, SEEK_CUR);
196   if (orig_offset == (off_t)-1)
197     return -1;
198   if (lseek(fd, offset, SEEK_CUR) == (off_t)-1)
199     return -1;
200   ssize_t len = read(fd, buf, count);
201   if (len < 0)
202     return len;
203   if (lseek(fd, orig_offset, SEEK_SET) == (off_t)-1)
204     return -1;
205   return len;
206 }
207 #endif  // !HAVE_PREAD
208
209 #ifndef HAVE_PWRITE
210 static ssize_t pwrite(int fd, void* buf, size_t count, off_t offset) {
211   off_t orig_offset = lseek(fd, 0, SEEK_CUR);
212   if (orig_offset == (off_t)-1)
213     return -1;
214   if (lseek(fd, offset, SEEK_CUR) == (off_t)-1)
215     return -1;
216   ssize_t len = write(fd, buf, count);
217   if (len < 0)
218     return len;
219   if (lseek(fd, orig_offset, SEEK_SET) == (off_t)-1)
220     return -1;
221   return len;
222 }
223 #endif  // !HAVE_PWRITE
224
225 static void GetHostName(string* hostname) {
226 #if defined(HAVE_SYS_UTSNAME_H)
227   struct utsname buf;
228   if (0 != uname(&buf)) {
229     // ensure null termination on failure
230     *buf.nodename = '\0';
231   }
232   *hostname = buf.nodename;
233 #elif defined(OS_WINDOWS)
234   char buf[MAX_COMPUTERNAME_LENGTH + 1];
235   DWORD len = MAX_COMPUTERNAME_LENGTH + 1;
236   if (GetComputerNameA(buf, &len)) {
237     *hostname = buf;
238   } else {
239     hostname->clear();
240   }
241 #else
242 # warning There is no way to retrieve the host name.
243   *hostname = "(unknown)";
244 #endif
245 }
246
247 // Returns true iff terminal supports using colors in output.
248 static bool TerminalSupportsColor() {
249   bool term_supports_color = false;
250 #ifdef OS_WINDOWS
251   // on Windows TERM variable is usually not set, but the console does
252   // support colors.
253   term_supports_color = true;
254 #else
255   // On non-Windows platforms, we rely on the TERM variable.
256   const char* const term = getenv("TERM");
257   if (term != NULL && term[0] != '\0') {
258     term_supports_color =
259       !strcmp(term, "xterm") ||
260       !strcmp(term, "xterm-color") ||
261       !strcmp(term, "xterm-256color") ||
262       !strcmp(term, "screen-256color") ||
263       !strcmp(term, "screen") ||
264       !strcmp(term, "linux") ||
265       !strcmp(term, "cygwin");
266   }
267 #endif
268   return term_supports_color;
269 }
270
271 _START_GOOGLE_NAMESPACE_
272
273 enum GLogColor {
274   COLOR_DEFAULT,
275   COLOR_RED,
276   COLOR_GREEN,
277   COLOR_YELLOW
278 };
279
280 static GLogColor SeverityToColor(LogSeverity severity) {
281   assert(severity >= 0 && severity < NUM_SEVERITIES);
282   GLogColor color = COLOR_DEFAULT;
283   switch (severity) {
284   case GLOG_INFO:
285     color = COLOR_DEFAULT;
286     break;
287   case GLOG_WARNING:
288     color = COLOR_YELLOW;
289     break;
290   case GLOG_ERROR:
291   case GLOG_FATAL:
292     color = COLOR_RED;
293     break;
294   default:
295     // should never get here.
296     assert(false);
297   }
298   return color;
299 }
300
301 #ifdef OS_WINDOWS
302
303 // Returns the character attribute for the given color.
304 static WORD GetColorAttribute(GLogColor color) {
305   switch (color) {
306     case COLOR_RED:    return FOREGROUND_RED;
307     case COLOR_GREEN:  return FOREGROUND_GREEN;
308     case COLOR_YELLOW: return FOREGROUND_RED | FOREGROUND_GREEN;
309     default:           return 0;
310   }
311 }
312
313 #else
314
315 // Returns the ANSI color code for the given color.
316 static const char* GetAnsiColorCode(GLogColor color) {
317   switch (color) {
318   case COLOR_RED:     return "1";
319   case COLOR_GREEN:   return "2";
320   case COLOR_YELLOW:  return "3";
321   case COLOR_DEFAULT:  return "";
322   };
323   return NULL; // stop warning about return type.
324 }
325
326 #endif  // OS_WINDOWS
327
328 // Safely get max_log_size, overriding to 1 if it somehow gets defined as 0
329 static int32 MaxLogSize() {
330   return (FLAGS_max_log_size > 0 ? FLAGS_max_log_size : 1);
331 }
332
333 // An arbitrary limit on the length of a single log message.  This
334 // is so that streaming can be done more efficiently.
335 const size_t LogMessage::kMaxLogMessageLen = 30000;
336
337 struct LogMessage::LogMessageData  {
338   LogMessageData();
339
340   int preserved_errno_;      // preserved errno
341   // Buffer space; contains complete message text.
342   char message_text_[LogMessage::kMaxLogMessageLen+1];
343   LogStream stream_;
344   char severity_;      // What level is this LogMessage logged at?
345   int line_;                 // line number where logging call is.
346   void (LogMessage::*send_method_)();  // Call this in destructor to send
347   union {  // At most one of these is used: union to keep the size low.
348     LogSink* sink_;             // NULL or sink to send message to
349     std::vector<std::string>* outvec_; // NULL or vector to push message onto
350     std::string* message_;             // NULL or string to write message into
351   };
352   time_t timestamp_;            // Time of creation of LogMessage
353   struct ::tm tm_time_;         // Time of creation of LogMessage
354   size_t num_prefix_chars_;     // # of chars of prefix in this message
355   size_t num_chars_to_log_;     // # of chars of msg to send to log
356   size_t num_chars_to_syslog_;  // # of chars of msg to send to syslog
357   const char* basename_;        // basename of file that called LOG
358   const char* fullname_;        // fullname of file that called LOG
359   bool has_been_flushed_;       // false => data has not been flushed
360   bool first_fatal_;            // true => this was first fatal msg
361
362  private:
363   LogMessageData(const LogMessageData&);
364   void operator=(const LogMessageData&);
365 };
366
367 // A mutex that allows only one thread to log at a time, to keep things from
368 // getting jumbled.  Some other very uncommon logging operations (like
369 // changing the destination file for log messages of a given severity) also
370 // lock this mutex.  Please be sure that anybody who might possibly need to
371 // lock it does so.
372 static Mutex log_mutex;
373
374 // Number of messages sent at each severity.  Under log_mutex.
375 int64 LogMessage::num_messages_[NUM_SEVERITIES] = {0, 0, 0, 0};
376
377 // Globally disable log writing (if disk is full)
378 static bool stop_writing = false;
379
380 const char*const LogSeverityNames[NUM_SEVERITIES] = {
381   "INFO", "WARNING", "ERROR", "FATAL"
382 };
383
384 // Has the user called SetExitOnDFatal(true)?
385 static bool exit_on_dfatal = true;
386
387 const char* GetLogSeverityName(LogSeverity severity) {
388   return LogSeverityNames[severity];
389 }
390
391 static bool SendEmailInternal(const char*dest, const char *subject,
392                               const char*body, bool use_logging);
393
394 base::Logger::~Logger() {
395 }
396
397 namespace {
398
399 // Encapsulates all file-system related state
400 class LogFileObject : public base::Logger {
401  public:
402   LogFileObject(LogSeverity severity, const char* base_filename);
403   ~LogFileObject();
404
405   virtual void Write(bool force_flush, // Should we force a flush here?
406                      time_t timestamp,  // Timestamp for this entry
407                      const char* message,
408                      int message_len);
409
410   // Configuration options
411   void SetBasename(const char* basename);
412   void SetExtension(const char* ext);
413   void SetSymlinkBasename(const char* symlink_basename);
414
415   // Normal flushing routine
416   virtual void Flush();
417
418   // It is the actual file length for the system loggers,
419   // i.e., INFO, ERROR, etc.
420   virtual uint32 LogSize() {
421     MutexLock l(&lock_);
422     return file_length_;
423   }
424
425   // Internal flush routine.  Exposed so that FlushLogFilesUnsafe()
426   // can avoid grabbing a lock.  Usually Flush() calls it after
427   // acquiring lock_.
428   void FlushUnlocked();
429
430  private:
431   static const uint32 kRolloverAttemptFrequency = 0x20;
432
433   Mutex lock_;
434   bool base_filename_selected_;
435   string base_filename_;
436   string symlink_basename_;
437   string filename_extension_;     // option users can specify (eg to add port#)
438   FILE* file_;
439   LogSeverity severity_;
440   uint32 bytes_since_flush_;
441   uint32 file_length_;
442   unsigned int rollover_attempt_;
443   int64 next_flush_time_;         // cycle count at which to flush log
444
445   // Actually create a logfile using the value of base_filename_ and the
446   // supplied argument time_pid_string
447   // REQUIRES: lock_ is held
448   bool CreateLogfile(const string& time_pid_string);
449 };
450
451 }  // namespace
452
453 class LogDestination {
454  public:
455   friend class LogMessage;
456   friend void ReprintFatalMessage();
457   friend base::Logger* base::GetLogger(LogSeverity);
458   friend void base::SetLogger(LogSeverity, base::Logger*);
459
460   // These methods are just forwarded to by their global versions.
461   static void SetLogDestination(LogSeverity severity,
462                                 const char* base_filename);
463   static void SetLogSymlink(LogSeverity severity,
464                             const char* symlink_basename);
465   static void AddLogSink(LogSink *destination);
466   static void RemoveLogSink(LogSink *destination);
467   static void SetLogFilenameExtension(const char* filename_extension);
468   static void SetStderrLogging(LogSeverity min_severity);
469   static void SetEmailLogging(LogSeverity min_severity, const char* addresses);
470   static void LogToStderr();
471   // Flush all log files that are at least at the given severity level
472   static void FlushLogFiles(int min_severity);
473   static void FlushLogFilesUnsafe(int min_severity);
474
475   // we set the maximum size of our packet to be 1400, the logic being
476   // to prevent fragmentation.
477   // Really this number is arbitrary.
478   static const int kNetworkBytes = 1400;
479
480   static const string& hostname();
481   static const bool& terminal_supports_color() {
482     return terminal_supports_color_;
483   }
484
485   static void DeleteLogDestinations();
486
487  private:
488   LogDestination(LogSeverity severity, const char* base_filename);
489   ~LogDestination() { }
490
491   // Take a log message of a particular severity and log it to stderr
492   // iff it's of a high enough severity to deserve it.
493   static void MaybeLogToStderr(LogSeverity severity, const char* message,
494                                size_t len);
495
496   // Take a log message of a particular severity and log it to email
497   // iff it's of a high enough severity to deserve it.
498   static void MaybeLogToEmail(LogSeverity severity, const char* message,
499                               size_t len);
500   // Take a log message of a particular severity and log it to a file
501   // iff the base filename is not "" (which means "don't log to me")
502   static void MaybeLogToLogfile(LogSeverity severity,
503                                 time_t timestamp,
504                                 const char* message, size_t len);
505   // Take a log message of a particular severity and log it to the file
506   // for that severity and also for all files with severity less than
507   // this severity.
508   static void LogToAllLogfiles(LogSeverity severity,
509                                time_t timestamp,
510                                const char* message, size_t len);
511
512   // Send logging info to all registered sinks.
513   static void LogToSinks(LogSeverity severity,
514                          const char *full_filename,
515                          const char *base_filename,
516                          int line,
517                          const struct ::tm* tm_time,
518                          const char* message,
519                          size_t message_len);
520
521   // Wait for all registered sinks via WaitTillSent
522   // including the optional one in "data".
523   static void WaitForSinks(LogMessage::LogMessageData* data);
524
525   static LogDestination* log_destination(LogSeverity severity);
526
527   LogFileObject fileobject_;
528   base::Logger* logger_;      // Either &fileobject_, or wrapper around it
529
530   static LogDestination* log_destinations_[NUM_SEVERITIES];
531   static LogSeverity email_logging_severity_;
532   static string addresses_;
533   static string hostname_;
534   static bool terminal_supports_color_;
535
536   // arbitrary global logging destinations.
537   static vector<LogSink*>* sinks_;
538
539   // Protects the vector sinks_,
540   // but not the LogSink objects its elements reference.
541   static Mutex sink_mutex_;
542
543   // Disallow
544   LogDestination(const LogDestination&);
545   LogDestination& operator=(const LogDestination&);
546 };
547
548 // Errors do not get logged to email by default.
549 LogSeverity LogDestination::email_logging_severity_ = 99999;
550
551 string LogDestination::addresses_;
552 string LogDestination::hostname_;
553
554 vector<LogSink*>* LogDestination::sinks_ = NULL;
555 Mutex LogDestination::sink_mutex_;
556 bool LogDestination::terminal_supports_color_ = TerminalSupportsColor();
557
558 /* static */
559 const string& LogDestination::hostname() {
560   if (hostname_.empty()) {
561     GetHostName(&hostname_);
562     if (hostname_.empty()) {
563       hostname_ = "(unknown)";
564     }
565   }
566   return hostname_;
567 }
568
569 LogDestination::LogDestination(LogSeverity severity,
570                                const char* base_filename)
571   : fileobject_(severity, base_filename),
572     logger_(&fileobject_) {
573 }
574
575 inline void LogDestination::FlushLogFilesUnsafe(int min_severity) {
576   // assume we have the log_mutex or we simply don't care
577   // about it
578   for (int i = min_severity; i < NUM_SEVERITIES; i++) {
579     LogDestination* log = log_destinations_[i];
580     if (log != NULL) {
581       // Flush the base fileobject_ logger directly instead of going
582       // through any wrappers to reduce chance of deadlock.
583       log->fileobject_.FlushUnlocked();
584     }
585   }
586 }
587
588 inline void LogDestination::FlushLogFiles(int min_severity) {
589   // Prevent any subtle race conditions by wrapping a mutex lock around
590   // all this stuff.
591   MutexLock l(&log_mutex);
592   for (int i = min_severity; i < NUM_SEVERITIES; i++) {
593     LogDestination* log = log_destination(i);
594     if (log != NULL) {
595       log->logger_->Flush();
596     }
597   }
598 }
599
600 inline void LogDestination::SetLogDestination(LogSeverity severity,
601                                               const char* base_filename) {
602   assert(severity >= 0 && severity < NUM_SEVERITIES);
603   // Prevent any subtle race conditions by wrapping a mutex lock around
604   // all this stuff.
605   MutexLock l(&log_mutex);
606   log_destination(severity)->fileobject_.SetBasename(base_filename);
607 }
608
609 inline void LogDestination::SetLogSymlink(LogSeverity severity,
610                                           const char* symlink_basename) {
611   CHECK_GE(severity, 0);
612   CHECK_LT(severity, NUM_SEVERITIES);
613   MutexLock l(&log_mutex);
614   log_destination(severity)->fileobject_.SetSymlinkBasename(symlink_basename);
615 }
616
617 inline void LogDestination::AddLogSink(LogSink *destination) {
618   // Prevent any subtle race conditions by wrapping a mutex lock around
619   // all this stuff.
620   MutexLock l(&sink_mutex_);
621   if (!sinks_)  sinks_ = new vector<LogSink*>;
622   sinks_->push_back(destination);
623 }
624
625 inline void LogDestination::RemoveLogSink(LogSink *destination) {
626   // Prevent any subtle race conditions by wrapping a mutex lock around
627   // all this stuff.
628   MutexLock l(&sink_mutex_);
629   // This doesn't keep the sinks in order, but who cares?
630   if (sinks_) {
631     for (int i = sinks_->size() - 1; i >= 0; i--) {
632       if ((*sinks_)[i] == destination) {
633         (*sinks_)[i] = (*sinks_)[sinks_->size() - 1];
634         sinks_->pop_back();
635         break;
636       }
637     }
638   }
639 }
640
641 inline void LogDestination::SetLogFilenameExtension(const char* ext) {
642   // Prevent any subtle race conditions by wrapping a mutex lock around
643   // all this stuff.
644   MutexLock l(&log_mutex);
645   for ( int severity = 0; severity < NUM_SEVERITIES; ++severity ) {
646     log_destination(severity)->fileobject_.SetExtension(ext);
647   }
648 }
649
650 inline void LogDestination::SetStderrLogging(LogSeverity min_severity) {
651   assert(min_severity >= 0 && min_severity < NUM_SEVERITIES);
652   // Prevent any subtle race conditions by wrapping a mutex lock around
653   // all this stuff.
654   MutexLock l(&log_mutex);
655   FLAGS_stderrthreshold = min_severity;
656 }
657
658 inline void LogDestination::LogToStderr() {
659   // *Don't* put this stuff in a mutex lock, since SetStderrLogging &
660   // SetLogDestination already do the locking!
661   SetStderrLogging(0);            // thus everything is "also" logged to stderr
662   for ( int i = 0; i < NUM_SEVERITIES; ++i ) {
663     SetLogDestination(i, "");     // "" turns off logging to a logfile
664   }
665 }
666
667 inline void LogDestination::SetEmailLogging(LogSeverity min_severity,
668                                             const char* addresses) {
669   assert(min_severity >= 0 && min_severity < NUM_SEVERITIES);
670   // Prevent any subtle race conditions by wrapping a mutex lock around
671   // all this stuff.
672   MutexLock l(&log_mutex);
673   LogDestination::email_logging_severity_ = min_severity;
674   LogDestination::addresses_ = addresses;
675 }
676
677 static void ColoredWriteToStderr(LogSeverity severity,
678                                  const char* message, size_t len) {
679   const GLogColor color =
680       (LogDestination::terminal_supports_color() && FLAGS_colorlogtostderr) ?
681       SeverityToColor(severity) : COLOR_DEFAULT;
682
683   // Avoid using cerr from this module since we may get called during
684   // exit code, and cerr may be partially or fully destroyed by then.
685   if (COLOR_DEFAULT == color) {
686     fwrite(message, len, 1, stderr);
687     return;
688   }
689 #ifdef OS_WINDOWS
690   const HANDLE stderr_handle = GetStdHandle(STD_ERROR_HANDLE);
691
692   // Gets the current text color.
693   CONSOLE_SCREEN_BUFFER_INFO buffer_info;
694   GetConsoleScreenBufferInfo(stderr_handle, &buffer_info);
695   const WORD old_color_attrs = buffer_info.wAttributes;
696
697   // We need to flush the stream buffers into the console before each
698   // SetConsoleTextAttribute call lest it affect the text that is already
699   // printed but has not yet reached the console.
700   fflush(stderr);
701   SetConsoleTextAttribute(stderr_handle,
702                           GetColorAttribute(color) | FOREGROUND_INTENSITY);
703   fwrite(message, len, 1, stderr);
704   fflush(stderr);
705   // Restores the text color.
706   SetConsoleTextAttribute(stderr_handle, old_color_attrs);
707 #else
708   fprintf(stderr, "\033[0;3%sm", GetAnsiColorCode(color));
709   fwrite(message, len, 1, stderr);
710   fprintf(stderr, "\033[m");  // Resets the terminal to default.
711 #endif  // OS_WINDOWS
712 }
713
714 static void WriteToStderr(const char* message, size_t len) {
715   // Avoid using cerr from this module since we may get called during
716   // exit code, and cerr may be partially or fully destroyed by then.
717   fwrite(message, len, 1, stderr);
718 }
719
720 inline void LogDestination::MaybeLogToStderr(LogSeverity severity,
721                                              const char* message, size_t len) {
722   if ((severity >= FLAGS_stderrthreshold) || FLAGS_alsologtostderr) {
723     ColoredWriteToStderr(severity, message, len);
724 #ifdef OS_WINDOWS
725     // On Windows, also output to the debugger
726     ::OutputDebugStringA(string(message,len).c_str());
727 #endif
728   }
729 }
730
731
732 inline void LogDestination::MaybeLogToEmail(LogSeverity severity,
733                                             const char* message, size_t len) {
734   if (severity >= email_logging_severity_ ||
735       severity >= FLAGS_logemaillevel) {
736     string to(FLAGS_alsologtoemail);
737     if (!addresses_.empty()) {
738       if (!to.empty()) {
739         to += ",";
740       }
741       to += addresses_;
742     }
743     const string subject(string("[LOG] ") + LogSeverityNames[severity] + ": " +
744                          glog_internal_namespace_::ProgramInvocationShortName());
745     string body(hostname());
746     body += "\n\n";
747     body.append(message, len);
748
749     // should NOT use SendEmail().  The caller of this function holds the
750     // log_mutex and SendEmail() calls LOG/VLOG which will block trying to
751     // acquire the log_mutex object.  Use SendEmailInternal() and set
752     // use_logging to false.
753     SendEmailInternal(to.c_str(), subject.c_str(), body.c_str(), false);
754   }
755 }
756
757
758 inline void LogDestination::MaybeLogToLogfile(LogSeverity severity,
759                                               time_t timestamp,
760                                               const char* message,
761                                               size_t len) {
762   const bool should_flush = severity > FLAGS_logbuflevel;
763   LogDestination* destination = log_destination(severity);
764   destination->logger_->Write(should_flush, timestamp, message, len);
765 }
766
767 inline void LogDestination::LogToAllLogfiles(LogSeverity severity,
768                                              time_t timestamp,
769                                              const char* message,
770                                              size_t len) {
771
772   if ( FLAGS_logtostderr ) {           // global flag: never log to file
773     ColoredWriteToStderr(severity, message, len);
774   } else {
775     for (int i = severity; i >= 0; --i)
776       LogDestination::MaybeLogToLogfile(i, timestamp, message, len);
777   }
778 }
779
780 inline void LogDestination::LogToSinks(LogSeverity severity,
781                                        const char *full_filename,
782                                        const char *base_filename,
783                                        int line,
784                                        const struct ::tm* tm_time,
785                                        const char* message,
786                                        size_t message_len) {
787   ReaderMutexLock l(&sink_mutex_);
788   if (sinks_) {
789     for (int i = sinks_->size() - 1; i >= 0; i--) {
790       (*sinks_)[i]->send(severity, full_filename, base_filename,
791                          line, tm_time, message, message_len);
792     }
793   }
794 }
795
796 inline void LogDestination::WaitForSinks(LogMessage::LogMessageData* data) {
797   ReaderMutexLock l(&sink_mutex_);
798   if (sinks_) {
799     for (int i = sinks_->size() - 1; i >= 0; i--) {
800       (*sinks_)[i]->WaitTillSent();
801     }
802   }
803   const bool send_to_sink =
804       (data->send_method_ == &LogMessage::SendToSink) ||
805       (data->send_method_ == &LogMessage::SendToSinkAndLog);
806   if (send_to_sink && data->sink_ != NULL) {
807     data->sink_->WaitTillSent();
808   }
809 }
810
811 LogDestination* LogDestination::log_destinations_[NUM_SEVERITIES];
812
813 inline LogDestination* LogDestination::log_destination(LogSeverity severity) {
814   assert(severity >=0 && severity < NUM_SEVERITIES);
815   if (!log_destinations_[severity]) {
816     log_destinations_[severity] = new LogDestination(severity, NULL);
817   }
818   return log_destinations_[severity];
819 }
820
821 void LogDestination::DeleteLogDestinations() {
822   for (int severity = 0; severity < NUM_SEVERITIES; ++severity) {
823     delete log_destinations_[severity];
824     log_destinations_[severity] = NULL;
825   }
826   MutexLock l(&sink_mutex_);
827   delete sinks_;
828 }
829
830 namespace {
831
832 LogFileObject::LogFileObject(LogSeverity severity,
833                              const char* base_filename)
834   : base_filename_selected_(base_filename != NULL),
835     base_filename_((base_filename != NULL) ? base_filename : ""),
836     symlink_basename_(glog_internal_namespace_::ProgramInvocationShortName()),
837     filename_extension_(),
838     file_(NULL),
839     severity_(severity),
840     bytes_since_flush_(0),
841     file_length_(0),
842     rollover_attempt_(kRolloverAttemptFrequency-1),
843     next_flush_time_(0) {
844   assert(severity >= 0);
845   assert(severity < NUM_SEVERITIES);
846 }
847
848 LogFileObject::~LogFileObject() {
849   MutexLock l(&lock_);
850   if (file_ != NULL) {
851     fclose(file_);
852     file_ = NULL;
853   }
854 }
855
856 void LogFileObject::SetBasename(const char* basename) {
857   MutexLock l(&lock_);
858   base_filename_selected_ = true;
859   if (base_filename_ != basename) {
860     // Get rid of old log file since we are changing names
861     if (file_ != NULL) {
862       fclose(file_);
863       file_ = NULL;
864       rollover_attempt_ = kRolloverAttemptFrequency-1;
865     }
866     base_filename_ = basename;
867   }
868 }
869
870 void LogFileObject::SetExtension(const char* ext) {
871   MutexLock l(&lock_);
872   if (filename_extension_ != ext) {
873     // Get rid of old log file since we are changing names
874     if (file_ != NULL) {
875       fclose(file_);
876       file_ = NULL;
877       rollover_attempt_ = kRolloverAttemptFrequency-1;
878     }
879     filename_extension_ = ext;
880   }
881 }
882
883 void LogFileObject::SetSymlinkBasename(const char* symlink_basename) {
884   MutexLock l(&lock_);
885   symlink_basename_ = symlink_basename;
886 }
887
888 void LogFileObject::Flush() {
889   MutexLock l(&lock_);
890   FlushUnlocked();
891 }
892
893 void LogFileObject::FlushUnlocked(){
894   if (file_ != NULL) {
895     fflush(file_);
896     bytes_since_flush_ = 0;
897   }
898   // Figure out when we are due for another flush.
899   const int64 next = (FLAGS_logbufsecs
900                       * static_cast<int64>(1000000));  // in usec
901   next_flush_time_ = CycleClock_Now() + UsecToCycles(next);
902 }
903
904 bool LogFileObject::CreateLogfile(const string& time_pid_string) {
905   string string_filename = base_filename_+filename_extension_+
906                            time_pid_string;
907   const char* filename = string_filename.c_str();
908   int fd = open(filename, O_WRONLY | O_CREAT | O_EXCL, FLAGS_logfile_mode);
909   if (fd == -1) return false;
910 #ifdef HAVE_FCNTL
911   // Mark the file close-on-exec. We don't really care if this fails
912   fcntl(fd, F_SETFD, FD_CLOEXEC);
913 #endif
914
915   file_ = fdopen(fd, "a");  // Make a FILE*.
916   if (file_ == NULL) {  // Man, we're screwed!
917     close(fd);
918     unlink(filename);  // Erase the half-baked evidence: an unusable log file
919     return false;
920   }
921
922   // We try to create a symlink called <program_name>.<severity>,
923   // which is easier to use.  (Every time we create a new logfile,
924   // we destroy the old symlink and create a new one, so it always
925   // points to the latest logfile.)  If it fails, we're sad but it's
926   // no error.
927   if (!symlink_basename_.empty()) {
928     // take directory from filename
929     const char* slash = strrchr(filename, PATH_SEPARATOR);
930     const string linkname =
931       symlink_basename_ + '.' + LogSeverityNames[severity_];
932     string linkpath;
933     if ( slash ) linkpath = string(filename, slash-filename+1);  // get dirname
934     linkpath += linkname;
935     unlink(linkpath.c_str());                    // delete old one if it exists
936
937 #if defined(OS_WINDOWS)
938     // TODO(hamaji): Create lnk file on Windows?
939 #elif defined(HAVE_UNISTD_H)
940     // We must have unistd.h.
941     // Make the symlink be relative (in the same dir) so that if the
942     // entire log directory gets relocated the link is still valid.
943     const char *linkdest = slash ? (slash + 1) : filename;
944     if (symlink(linkdest, linkpath.c_str()) != 0) {
945       // silently ignore failures
946     }
947
948     // Make an additional link to the log file in a place specified by
949     // FLAGS_log_link, if indicated
950     if (!FLAGS_log_link.empty()) {
951       linkpath = FLAGS_log_link + "/" + linkname;
952       unlink(linkpath.c_str());                  // delete old one if it exists
953       if (symlink(filename, linkpath.c_str()) != 0) {
954         // silently ignore failures
955       }
956     }
957 #endif
958   }
959
960   return true;  // Everything worked
961 }
962
963 void LogFileObject::Write(bool force_flush,
964                           time_t timestamp,
965                           const char* message,
966                           int message_len) {
967   MutexLock l(&lock_);
968
969   // We don't log if the base_name_ is "" (which means "don't write")
970   if (base_filename_selected_ && base_filename_.empty()) {
971     return;
972   }
973
974   if (static_cast<int>(file_length_ >> 20) >= MaxLogSize() ||
975       PidHasChanged()) {
976     if (file_ != NULL) fclose(file_);
977     file_ = NULL;
978     file_length_ = bytes_since_flush_ = 0;
979     rollover_attempt_ = kRolloverAttemptFrequency-1;
980   }
981
982   // If there's no destination file, make one before outputting
983   if (file_ == NULL) {
984     // Try to rollover the log file every 32 log messages.  The only time
985     // this could matter would be when we have trouble creating the log
986     // file.  If that happens, we'll lose lots of log messages, of course!
987     if (++rollover_attempt_ != kRolloverAttemptFrequency) return;
988     rollover_attempt_ = 0;
989
990     struct ::tm tm_time;
991     localtime_r(&timestamp, &tm_time);
992
993     // The logfile's filename will have the date/time & pid in it
994     ostringstream time_pid_stream;
995     time_pid_stream.fill('0');
996     time_pid_stream << 1900+tm_time.tm_year
997                     << setw(2) << 1+tm_time.tm_mon
998                     << setw(2) << tm_time.tm_mday
999                     << '-'
1000                     << setw(2) << tm_time.tm_hour
1001                     << setw(2) << tm_time.tm_min
1002                     << setw(2) << tm_time.tm_sec
1003                     << '.'
1004                     << GetMainThreadPid();
1005     const string& time_pid_string = time_pid_stream.str();
1006
1007     if (base_filename_selected_) {
1008       if (!CreateLogfile(time_pid_string)) {
1009         perror("Could not create log file");
1010         fprintf(stderr, "COULD NOT CREATE LOGFILE '%s'!\n",
1011                 time_pid_string.c_str());
1012         return;
1013       }
1014     } else {
1015       // If no base filename for logs of this severity has been set, use a
1016       // default base filename of
1017       // "<program name>.<hostname>.<user name>.log.<severity level>.".  So
1018       // logfiles will have names like
1019       // webserver.examplehost.root.log.INFO.19990817-150000.4354, where
1020       // 19990817 is a date (1999 August 17), 150000 is a time (15:00:00),
1021       // and 4354 is the pid of the logging process.  The date & time reflect
1022       // when the file was created for output.
1023       //
1024       // Where does the file get put?  Successively try the directories
1025       // "/tmp", and "."
1026       string stripped_filename(
1027           glog_internal_namespace_::ProgramInvocationShortName());
1028       string hostname;
1029       GetHostName(&hostname);
1030
1031       string uidname = MyUserName();
1032       // We should not call CHECK() here because this function can be
1033       // called after holding on to log_mutex. We don't want to
1034       // attempt to hold on to the same mutex, and get into a
1035       // deadlock. Simply use a name like invalid-user.
1036       if (uidname.empty()) uidname = "invalid-user";
1037
1038       stripped_filename = stripped_filename+'.'+hostname+'.'
1039                           +uidname+".log."
1040                           +LogSeverityNames[severity_]+'.';
1041       // We're going to (potentially) try to put logs in several different dirs
1042       const vector<string> & log_dirs = GetLoggingDirectories();
1043
1044       // Go through the list of dirs, and try to create the log file in each
1045       // until we succeed or run out of options
1046       bool success = false;
1047       for (vector<string>::const_iterator dir = log_dirs.begin();
1048            dir != log_dirs.end();
1049            ++dir) {
1050         base_filename_ = *dir + "/" + stripped_filename;
1051         if ( CreateLogfile(time_pid_string) ) {
1052           success = true;
1053           break;
1054         }
1055       }
1056       // If we never succeeded, we have to give up
1057       if ( success == false ) {
1058         perror("Could not create logging file");
1059         fprintf(stderr, "COULD NOT CREATE A LOGGINGFILE %s!",
1060                 time_pid_string.c_str());
1061         return;
1062       }
1063     }
1064
1065     // Write a header message into the log file
1066     ostringstream file_header_stream;
1067     file_header_stream.fill('0');
1068     file_header_stream << "Log file created at: "
1069                        << 1900+tm_time.tm_year << '/'
1070                        << setw(2) << 1+tm_time.tm_mon << '/'
1071                        << setw(2) << tm_time.tm_mday
1072                        << ' '
1073                        << setw(2) << tm_time.tm_hour << ':'
1074                        << setw(2) << tm_time.tm_min << ':'
1075                        << setw(2) << tm_time.tm_sec << '\n'
1076                        << "Running on machine: "
1077                        << LogDestination::hostname() << '\n'
1078                        << "Log line format: [IWEF]mmdd hh:mm:ss.uuuuuu "
1079                        << "threadid file:line] msg" << '\n';
1080     const string& file_header_string = file_header_stream.str();
1081
1082     const int header_len = file_header_string.size();
1083     fwrite(file_header_string.data(), 1, header_len, file_);
1084     file_length_ += header_len;
1085     bytes_since_flush_ += header_len;
1086   }
1087
1088   // Write to LOG file
1089   if ( !stop_writing ) {
1090     // fwrite() doesn't return an error when the disk is full, for
1091     // messages that are less than 4096 bytes. When the disk is full,
1092     // it returns the message length for messages that are less than
1093     // 4096 bytes. fwrite() returns 4096 for message lengths that are
1094     // greater than 4096, thereby indicating an error.
1095     errno = 0;
1096     fwrite(message, 1, message_len, file_);
1097     if ( FLAGS_stop_logging_if_full_disk &&
1098          errno == ENOSPC ) {  // disk full, stop writing to disk
1099       stop_writing = true;  // until the disk is
1100       return;
1101     } else {
1102       file_length_ += message_len;
1103       bytes_since_flush_ += message_len;
1104     }
1105   } else {
1106     if ( CycleClock_Now() >= next_flush_time_ )
1107       stop_writing = false;  // check to see if disk has free space.
1108     return;  // no need to flush
1109   }
1110
1111   // See important msgs *now*.  Also, flush logs at least every 10^6 chars,
1112   // or every "FLAGS_logbufsecs" seconds.
1113   if ( force_flush ||
1114        (bytes_since_flush_ >= 1000000) ||
1115        (CycleClock_Now() >= next_flush_time_) ) {
1116     FlushUnlocked();
1117 #ifdef OS_LINUX
1118     if (FLAGS_drop_log_memory) {
1119       if (file_length_ >= logging::kPageSize) {
1120         // don't evict the most recent page
1121         uint32 len = file_length_ & ~(logging::kPageSize - 1);
1122         posix_fadvise(fileno(file_), 0, len, POSIX_FADV_DONTNEED);
1123       }
1124     }
1125 #endif
1126   }
1127 }
1128
1129 }  // namespace
1130
1131
1132 // Static log data space to avoid alloc failures in a LOG(FATAL)
1133 //
1134 // Since multiple threads may call LOG(FATAL), and we want to preserve
1135 // the data from the first call, we allocate two sets of space.  One
1136 // for exclusive use by the first thread, and one for shared use by
1137 // all other threads.
1138 static Mutex fatal_msg_lock;
1139 static CrashReason crash_reason;
1140 static bool fatal_msg_exclusive = true;
1141 static LogMessage::LogMessageData fatal_msg_data_exclusive;
1142 static LogMessage::LogMessageData fatal_msg_data_shared;
1143
1144 LogMessage::LogMessageData::LogMessageData()
1145   : stream_(message_text_, LogMessage::kMaxLogMessageLen, 0) {
1146 }
1147
1148 LogMessage::LogMessage(const char* file, int line, LogSeverity severity,
1149                        int ctr, void (LogMessage::*send_method)())
1150     : allocated_(NULL) {
1151   Init(file, line, severity, send_method);
1152   data_->stream_.set_ctr(ctr);
1153 }
1154
1155 LogMessage::LogMessage(const char* file, int line,
1156                        const CheckOpString& result)
1157     : allocated_(NULL) {
1158   Init(file, line, GLOG_FATAL, &LogMessage::SendToLog);
1159   stream() << "Check failed: " << (*result.str_) << " ";
1160 }
1161
1162 LogMessage::LogMessage(const char* file, int line)
1163     : allocated_(NULL) {
1164   Init(file, line, GLOG_INFO, &LogMessage::SendToLog);
1165 }
1166
1167 LogMessage::LogMessage(const char* file, int line, LogSeverity severity)
1168     : allocated_(NULL) {
1169   Init(file, line, severity, &LogMessage::SendToLog);
1170 }
1171
1172 LogMessage::LogMessage(const char* file, int line, LogSeverity severity,
1173                        LogSink* sink, bool also_send_to_log)
1174     : allocated_(NULL) {
1175   Init(file, line, severity, also_send_to_log ? &LogMessage::SendToSinkAndLog :
1176                                                 &LogMessage::SendToSink);
1177   data_->sink_ = sink;  // override Init()'s setting to NULL
1178 }
1179
1180 LogMessage::LogMessage(const char* file, int line, LogSeverity severity,
1181                        vector<string> *outvec)
1182     : allocated_(NULL) {
1183   Init(file, line, severity, &LogMessage::SaveOrSendToLog);
1184   data_->outvec_ = outvec; // override Init()'s setting to NULL
1185 }
1186
1187 LogMessage::LogMessage(const char* file, int line, LogSeverity severity,
1188                        string *message)
1189     : allocated_(NULL) {
1190   Init(file, line, severity, &LogMessage::WriteToStringAndLog);
1191   data_->message_ = message;  // override Init()'s setting to NULL
1192 }
1193
1194 void LogMessage::Init(const char* file,
1195                       int line,
1196                       LogSeverity severity,
1197                       void (LogMessage::*send_method)()) {
1198   allocated_ = NULL;
1199   if (severity != GLOG_FATAL || !exit_on_dfatal) {
1200     allocated_ = new LogMessageData();
1201     data_ = allocated_;
1202     data_->first_fatal_ = false;
1203   } else {
1204     MutexLock l(&fatal_msg_lock);
1205     if (fatal_msg_exclusive) {
1206       fatal_msg_exclusive = false;
1207       data_ = &fatal_msg_data_exclusive;
1208       data_->first_fatal_ = true;
1209     } else {
1210       data_ = &fatal_msg_data_shared;
1211       data_->first_fatal_ = false;
1212     }
1213   }
1214
1215   stream().fill('0');
1216   data_->preserved_errno_ = errno;
1217   data_->severity_ = severity;
1218   data_->line_ = line;
1219   data_->send_method_ = send_method;
1220   data_->sink_ = NULL;
1221   data_->outvec_ = NULL;
1222   WallTime now = WallTime_Now();
1223   data_->timestamp_ = static_cast<time_t>(now);
1224   localtime_r(&data_->timestamp_, &data_->tm_time_);
1225   int usecs = static_cast<int>((now - data_->timestamp_) * 1000000);
1226   RawLog__SetLastTime(data_->tm_time_, usecs);
1227
1228   data_->num_chars_to_log_ = 0;
1229   data_->num_chars_to_syslog_ = 0;
1230   data_->basename_ = const_basename(file);
1231   data_->fullname_ = file;
1232   data_->has_been_flushed_ = false;
1233
1234   // If specified, prepend a prefix to each line.  For example:
1235   //    I1018 160715 f5d4fbb0 logging.cc:1153]
1236   //    (log level, GMT month, date, time, thread_id, file basename, line)
1237   // We exclude the thread_id for the default thread.
1238   if (FLAGS_log_prefix && (line != kNoLogPrefix)) {
1239     stream() << LogSeverityNames[severity][0]
1240              << setw(2) << 1+data_->tm_time_.tm_mon
1241              << setw(2) << data_->tm_time_.tm_mday
1242              << ' '
1243              << setw(2) << data_->tm_time_.tm_hour  << ':'
1244              << setw(2) << data_->tm_time_.tm_min   << ':'
1245              << setw(2) << data_->tm_time_.tm_sec   << "."
1246              << setw(6) << usecs
1247              << ' '
1248              << setfill(' ') << setw(5)
1249              << static_cast<unsigned int>(GetTID()) << setfill('0')
1250              << ' '
1251              << data_->basename_ << ':' << data_->line_ << "] ";
1252   }
1253   data_->num_prefix_chars_ = data_->stream_.pcount();
1254
1255   if (!FLAGS_log_backtrace_at.empty()) {
1256     char fileline[128];
1257     snprintf(fileline, sizeof(fileline), "%s:%d", data_->basename_, line);
1258 #ifdef HAVE_STACKTRACE
1259     if (!strcmp(FLAGS_log_backtrace_at.c_str(), fileline)) {
1260       string stacktrace;
1261       DumpStackTraceToString(&stacktrace);
1262       stream() << " (stacktrace:\n" << stacktrace << ") ";
1263     }
1264 #endif
1265   }
1266 }
1267
1268 LogMessage::~LogMessage() {
1269   Flush();
1270   delete allocated_;
1271 }
1272
1273 int LogMessage::preserved_errno() const {
1274   return data_->preserved_errno_;
1275 }
1276
1277 ostream& LogMessage::stream() {
1278   return data_->stream_;
1279 }
1280
1281 // Flush buffered message, called by the destructor, or any other function
1282 // that needs to synchronize the log.
1283 void LogMessage::Flush() {
1284   if (data_->has_been_flushed_ || data_->severity_ < FLAGS_minloglevel)
1285     return;
1286
1287   data_->num_chars_to_log_ = data_->stream_.pcount();
1288   data_->num_chars_to_syslog_ =
1289     data_->num_chars_to_log_ - data_->num_prefix_chars_;
1290
1291   // Do we need to add a \n to the end of this message?
1292   bool append_newline =
1293       (data_->message_text_[data_->num_chars_to_log_-1] != '\n');
1294   char original_final_char = '\0';
1295
1296   // If we do need to add a \n, we'll do it by violating the memory of the
1297   // ostrstream buffer.  This is quick, and we'll make sure to undo our
1298   // modification before anything else is done with the ostrstream.  It
1299   // would be preferable not to do things this way, but it seems to be
1300   // the best way to deal with this.
1301   if (append_newline) {
1302     original_final_char = data_->message_text_[data_->num_chars_to_log_];
1303     data_->message_text_[data_->num_chars_to_log_++] = '\n';
1304   }
1305
1306   // Prevent any subtle race conditions by wrapping a mutex lock around
1307   // the actual logging action per se.
1308   {
1309     MutexLock l(&log_mutex);
1310     (this->*(data_->send_method_))();
1311     ++num_messages_[static_cast<int>(data_->severity_)];
1312   }
1313   LogDestination::WaitForSinks(data_);
1314
1315   if (append_newline) {
1316     // Fix the ostrstream back how it was before we screwed with it.
1317     // It's 99.44% certain that we don't need to worry about doing this.
1318     data_->message_text_[data_->num_chars_to_log_-1] = original_final_char;
1319   }
1320
1321   // If errno was already set before we enter the logging call, we'll
1322   // set it back to that value when we return from the logging call.
1323   // It happens often that we log an error message after a syscall
1324   // failure, which can potentially set the errno to some other
1325   // values.  We would like to preserve the original errno.
1326   if (data_->preserved_errno_ != 0) {
1327     errno = data_->preserved_errno_;
1328   }
1329
1330   // Note that this message is now safely logged.  If we're asked to flush
1331   // again, as a result of destruction, say, we'll do nothing on future calls.
1332   data_->has_been_flushed_ = true;
1333 }
1334
1335 // Copy of first FATAL log message so that we can print it out again
1336 // after all the stack traces.  To preserve legacy behavior, we don't
1337 // use fatal_msg_data_exclusive.
1338 static time_t fatal_time;
1339 static char fatal_message[256];
1340
1341 void ReprintFatalMessage() {
1342   if (fatal_message[0]) {
1343     const int n = strlen(fatal_message);
1344     if (!FLAGS_logtostderr) {
1345       // Also write to stderr (don't color to avoid terminal checks)
1346       WriteToStderr(fatal_message, n);
1347     }
1348     LogDestination::LogToAllLogfiles(GLOG_ERROR, fatal_time, fatal_message, n);
1349   }
1350 }
1351
1352 // L >= log_mutex (callers must hold the log_mutex).
1353 void LogMessage::SendToLog() EXCLUSIVE_LOCKS_REQUIRED(log_mutex) {
1354   static bool already_warned_before_initgoogle = false;
1355
1356   log_mutex.AssertHeld();
1357
1358   RAW_DCHECK(data_->num_chars_to_log_ > 0 &&
1359              data_->message_text_[data_->num_chars_to_log_-1] == '\n', "");
1360
1361   // Messages of a given severity get logged to lower severity logs, too
1362
1363   if (!already_warned_before_initgoogle && !IsGoogleLoggingInitialized()) {
1364     const char w[] = "WARNING: Logging before InitGoogleLogging() is "
1365                      "written to STDERR\n";
1366     WriteToStderr(w, strlen(w));
1367     already_warned_before_initgoogle = true;
1368   }
1369
1370   // global flag: never log to file if set.  Also -- don't log to a
1371   // file if we haven't parsed the command line flags to get the
1372   // program name.
1373   if (FLAGS_logtostderr || !IsGoogleLoggingInitialized()) {
1374     ColoredWriteToStderr(data_->severity_,
1375                          data_->message_text_, data_->num_chars_to_log_);
1376
1377     // this could be protected by a flag if necessary.
1378     LogDestination::LogToSinks(data_->severity_,
1379                                data_->fullname_, data_->basename_,
1380                                data_->line_, &data_->tm_time_,
1381                                data_->message_text_ + data_->num_prefix_chars_,
1382                                (data_->num_chars_to_log_ -
1383                                 data_->num_prefix_chars_ - 1));
1384   } else {
1385
1386     // log this message to all log files of severity <= severity_
1387     LogDestination::LogToAllLogfiles(data_->severity_, data_->timestamp_,
1388                                      data_->message_text_,
1389                                      data_->num_chars_to_log_);
1390
1391     LogDestination::MaybeLogToStderr(data_->severity_, data_->message_text_,
1392                                      data_->num_chars_to_log_);
1393     LogDestination::MaybeLogToEmail(data_->severity_, data_->message_text_,
1394                                     data_->num_chars_to_log_);
1395     LogDestination::LogToSinks(data_->severity_,
1396                                data_->fullname_, data_->basename_,
1397                                data_->line_, &data_->tm_time_,
1398                                data_->message_text_ + data_->num_prefix_chars_,
1399                                (data_->num_chars_to_log_
1400                                 - data_->num_prefix_chars_ - 1));
1401     // NOTE: -1 removes trailing \n
1402   }
1403
1404   // If we log a FATAL message, flush all the log destinations, then toss
1405   // a signal for others to catch. We leave the logs in a state that
1406   // someone else can use them (as long as they flush afterwards)
1407   if (data_->severity_ == GLOG_FATAL && exit_on_dfatal) {
1408     if (data_->first_fatal_) {
1409       // Store crash information so that it is accessible from within signal
1410       // handlers that may be invoked later.
1411       RecordCrashReason(&crash_reason);
1412       SetCrashReason(&crash_reason);
1413
1414       // Store shortened fatal message for other logs and GWQ status
1415       const int copy = min<int>(data_->num_chars_to_log_,
1416                                 sizeof(fatal_message)-1);
1417       memcpy(fatal_message, data_->message_text_, copy);
1418       fatal_message[copy] = '\0';
1419       fatal_time = data_->timestamp_;
1420     }
1421
1422     if (!FLAGS_logtostderr) {
1423       for (int i = 0; i < NUM_SEVERITIES; ++i) {
1424         if ( LogDestination::log_destinations_[i] )
1425           LogDestination::log_destinations_[i]->logger_->Write(true, 0, "", 0);
1426       }
1427     }
1428
1429     // release the lock that our caller (directly or indirectly)
1430     // LogMessage::~LogMessage() grabbed so that signal handlers
1431     // can use the logging facility. Alternately, we could add
1432     // an entire unsafe logging interface to bypass locking
1433     // for signal handlers but this seems simpler.
1434     log_mutex.Unlock();
1435     LogDestination::WaitForSinks(data_);
1436
1437     const char* message = "*** Check failure stack trace: ***\n";
1438     if (write(STDERR_FILENO, message, strlen(message)) < 0) {
1439       // Ignore errors.
1440     }
1441     Fail();
1442   }
1443 }
1444
1445 void LogMessage::RecordCrashReason(
1446     glog_internal_namespace_::CrashReason* reason) {
1447   reason->filename = fatal_msg_data_exclusive.fullname_;
1448   reason->line_number = fatal_msg_data_exclusive.line_;
1449   reason->message = fatal_msg_data_exclusive.message_text_ +
1450                     fatal_msg_data_exclusive.num_prefix_chars_;
1451 #ifdef HAVE_STACKTRACE
1452   // Retrieve the stack trace, omitting the logging frames that got us here.
1453   reason->depth = GetStackTrace(reason->stack, ARRAYSIZE(reason->stack), 4);
1454 #else
1455   reason->depth = 0;
1456 #endif
1457 }
1458
1459 #ifdef HAVE___ATTRIBUTE__
1460 # define ATTRIBUTE_NORETURN __attribute__((noreturn))
1461 #else
1462 # define ATTRIBUTE_NORETURN
1463 #endif
1464
1465 static void logging_fail() ATTRIBUTE_NORETURN;
1466
1467 static void logging_fail() {
1468 #if defined(_DEBUG) && defined(_MSC_VER)
1469   // When debugging on windows, avoid the obnoxious dialog and make
1470   // it possible to continue past a LOG(FATAL) in the debugger
1471   __debugbreak();
1472 #else
1473   abort();
1474 #endif
1475 }
1476
1477 typedef void (*logging_fail_func_t)() ATTRIBUTE_NORETURN;
1478
1479 GOOGLE_GLOG_DLL_DECL
1480 logging_fail_func_t g_logging_fail_func = &logging_fail;
1481
1482 void InstallFailureFunction(void (*fail_func)()) {
1483   g_logging_fail_func = (logging_fail_func_t)fail_func;
1484 }
1485
1486 void LogMessage::Fail() {
1487   g_logging_fail_func();
1488 }
1489
1490 // L >= log_mutex (callers must hold the log_mutex).
1491 void LogMessage::SendToSink() EXCLUSIVE_LOCKS_REQUIRED(log_mutex) {
1492   if (data_->sink_ != NULL) {
1493     RAW_DCHECK(data_->num_chars_to_log_ > 0 &&
1494                data_->message_text_[data_->num_chars_to_log_-1] == '\n', "");
1495     data_->sink_->send(data_->severity_, data_->fullname_, data_->basename_,
1496                        data_->line_, &data_->tm_time_,
1497                        data_->message_text_ + data_->num_prefix_chars_,
1498                        (data_->num_chars_to_log_ -
1499                         data_->num_prefix_chars_ - 1));
1500   }
1501 }
1502
1503 // L >= log_mutex (callers must hold the log_mutex).
1504 void LogMessage::SendToSinkAndLog() EXCLUSIVE_LOCKS_REQUIRED(log_mutex) {
1505   SendToSink();
1506   SendToLog();
1507 }
1508
1509 // L >= log_mutex (callers must hold the log_mutex).
1510 void LogMessage::SaveOrSendToLog() EXCLUSIVE_LOCKS_REQUIRED(log_mutex) {
1511   if (data_->outvec_ != NULL) {
1512     RAW_DCHECK(data_->num_chars_to_log_ > 0 &&
1513                data_->message_text_[data_->num_chars_to_log_-1] == '\n', "");
1514     // Omit prefix of message and trailing newline when recording in outvec_.
1515     const char *start = data_->message_text_ + data_->num_prefix_chars_;
1516     int len = data_->num_chars_to_log_ - data_->num_prefix_chars_ - 1;
1517     data_->outvec_->push_back(string(start, len));
1518   } else {
1519     SendToLog();
1520   }
1521 }
1522
1523 void LogMessage::WriteToStringAndLog() EXCLUSIVE_LOCKS_REQUIRED(log_mutex) {
1524   if (data_->message_ != NULL) {
1525     RAW_DCHECK(data_->num_chars_to_log_ > 0 &&
1526                data_->message_text_[data_->num_chars_to_log_-1] == '\n', "");
1527     // Omit prefix of message and trailing newline when writing to message_.
1528     const char *start = data_->message_text_ + data_->num_prefix_chars_;
1529     int len = data_->num_chars_to_log_ - data_->num_prefix_chars_ - 1;
1530     data_->message_->assign(start, len);
1531   }
1532   SendToLog();
1533 }
1534
1535 // L >= log_mutex (callers must hold the log_mutex).
1536 void LogMessage::SendToSyslogAndLog() {
1537 #ifdef HAVE_SYSLOG_H
1538   // Before any calls to syslog(), make a single call to openlog()
1539   static bool openlog_already_called = false;
1540   if (!openlog_already_called) {
1541     openlog(glog_internal_namespace_::ProgramInvocationShortName(),
1542             LOG_CONS | LOG_NDELAY | LOG_PID,
1543             LOG_USER);
1544     openlog_already_called = true;
1545   }
1546
1547   // This array maps Google severity levels to syslog levels
1548   const int SEVERITY_TO_LEVEL[] = { LOG_INFO, LOG_WARNING, LOG_ERR, LOG_EMERG };
1549   syslog(LOG_USER | SEVERITY_TO_LEVEL[static_cast<int>(data_->severity_)], "%.*s",
1550          int(data_->num_chars_to_syslog_),
1551          data_->message_text_ + data_->num_prefix_chars_);
1552   SendToLog();
1553 #else
1554   LOG(ERROR) << "No syslog support: message=" << data_->message_text_;
1555 #endif
1556 }
1557
1558 base::Logger* base::GetLogger(LogSeverity severity) {
1559   MutexLock l(&log_mutex);
1560   return LogDestination::log_destination(severity)->logger_;
1561 }
1562
1563 void base::SetLogger(LogSeverity severity, base::Logger* logger) {
1564   MutexLock l(&log_mutex);
1565   LogDestination::log_destination(severity)->logger_ = logger;
1566 }
1567
1568 // L < log_mutex.  Acquires and releases mutex_.
1569 int64 LogMessage::num_messages(int severity) {
1570   MutexLock l(&log_mutex);
1571   return num_messages_[severity];
1572 }
1573
1574 // Output the COUNTER value. This is only valid if ostream is a
1575 // LogStream.
1576 ostream& operator<<(ostream &os, const PRIVATE_Counter&) {
1577 #ifdef DISABLE_RTTI
1578   LogMessage::LogStream *log = static_cast<LogMessage::LogStream*>(&os);
1579 #else
1580   LogMessage::LogStream *log = dynamic_cast<LogMessage::LogStream*>(&os);
1581 #endif
1582   CHECK(log && log == log->self())
1583       << "You must not use COUNTER with non-glog ostream";
1584   os << log->ctr();
1585   return os;
1586 }
1587
1588 ErrnoLogMessage::ErrnoLogMessage(const char* file, int line,
1589                                  LogSeverity severity, int ctr,
1590                                  void (LogMessage::*send_method)())
1591     : LogMessage(file, line, severity, ctr, send_method) {
1592 }
1593
1594 ErrnoLogMessage::~ErrnoLogMessage() {
1595   // Don't access errno directly because it may have been altered
1596   // while streaming the message.
1597   stream() << ": " << StrError(preserved_errno()) << " ["
1598            << preserved_errno() << "]";
1599 }
1600
1601 void FlushLogFiles(LogSeverity min_severity) {
1602   LogDestination::FlushLogFiles(min_severity);
1603 }
1604
1605 void FlushLogFilesUnsafe(LogSeverity min_severity) {
1606   LogDestination::FlushLogFilesUnsafe(min_severity);
1607 }
1608
1609 void SetLogDestination(LogSeverity severity, const char* base_filename) {
1610   LogDestination::SetLogDestination(severity, base_filename);
1611 }
1612
1613 void SetLogSymlink(LogSeverity severity, const char* symlink_basename) {
1614   LogDestination::SetLogSymlink(severity, symlink_basename);
1615 }
1616
1617 LogSink::~LogSink() {
1618 }
1619
1620 void LogSink::WaitTillSent() {
1621   // noop default
1622 }
1623
1624 string LogSink::ToString(LogSeverity severity, const char* file, int line,
1625                          const struct ::tm* tm_time,
1626                          const char* message, size_t message_len) {
1627   ostringstream stream(string(message, message_len));
1628   stream.fill('0');
1629
1630   // FIXME(jrvb): Updating this to use the correct value for usecs
1631   // requires changing the signature for both this method and
1632   // LogSink::send().  This change needs to be done in a separate CL
1633   // so subclasses of LogSink can be updated at the same time.
1634   int usecs = 0;
1635
1636   stream << LogSeverityNames[severity][0]
1637          << setw(2) << 1+tm_time->tm_mon
1638          << setw(2) << tm_time->tm_mday
1639          << ' '
1640          << setw(2) << tm_time->tm_hour << ':'
1641          << setw(2) << tm_time->tm_min << ':'
1642          << setw(2) << tm_time->tm_sec << '.'
1643          << setw(6) << usecs
1644          << ' '
1645          << setfill(' ') << setw(5) << GetTID() << setfill('0')
1646          << ' '
1647          << file << ':' << line << "] ";
1648
1649   stream << string(message, message_len);
1650   return stream.str();
1651 }
1652
1653 void AddLogSink(LogSink *destination) {
1654   LogDestination::AddLogSink(destination);
1655 }
1656
1657 void RemoveLogSink(LogSink *destination) {
1658   LogDestination::RemoveLogSink(destination);
1659 }
1660
1661 void SetLogFilenameExtension(const char* ext) {
1662   LogDestination::SetLogFilenameExtension(ext);
1663 }
1664
1665 void SetStderrLogging(LogSeverity min_severity) {
1666   LogDestination::SetStderrLogging(min_severity);
1667 }
1668
1669 void SetEmailLogging(LogSeverity min_severity, const char* addresses) {
1670   LogDestination::SetEmailLogging(min_severity, addresses);
1671 }
1672
1673 void LogToStderr() {
1674   LogDestination::LogToStderr();
1675 }
1676
1677 namespace base {
1678 namespace internal {
1679
1680 bool GetExitOnDFatal();
1681 bool GetExitOnDFatal() {
1682   MutexLock l(&log_mutex);
1683   return exit_on_dfatal;
1684 }
1685
1686 // Determines whether we exit the program for a LOG(DFATAL) message in
1687 // debug mode.  It does this by skipping the call to Fail/FailQuietly.
1688 // This is intended for testing only.
1689 //
1690 // This can have some effects on LOG(FATAL) as well.  Failure messages
1691 // are always allocated (rather than sharing a buffer), the crash
1692 // reason is not recorded, the "gwq" status message is not updated,
1693 // and the stack trace is not recorded.  The LOG(FATAL) *will* still
1694 // exit the program.  Since this function is used only in testing,
1695 // these differences are acceptable.
1696 void SetExitOnDFatal(bool value);
1697 void SetExitOnDFatal(bool value) {
1698   MutexLock l(&log_mutex);
1699   exit_on_dfatal = value;
1700 }
1701
1702 }  // namespace internal
1703 }  // namespace base
1704
1705 // use_logging controls whether the logging functions LOG/VLOG are used
1706 // to log errors.  It should be set to false when the caller holds the
1707 // log_mutex.
1708 static bool SendEmailInternal(const char*dest, const char *subject,
1709                               const char*body, bool use_logging) {
1710   if (dest && *dest) {
1711     if ( use_logging ) {
1712       VLOG(1) << "Trying to send TITLE:" << subject
1713               << " BODY:" << body << " to " << dest;
1714     } else {
1715       fprintf(stderr, "Trying to send TITLE: %s BODY: %s to %s\n",
1716               subject, body, dest);
1717     }
1718
1719     string cmd =
1720         FLAGS_logmailer + " -s\"" + subject + "\" " + dest;
1721     FILE* pipe = popen(cmd.c_str(), "w");
1722     if (pipe != NULL) {
1723       // Add the body if we have one
1724       if (body)
1725         fwrite(body, sizeof(char), strlen(body), pipe);
1726       bool ok = pclose(pipe) != -1;
1727       if ( !ok ) {
1728         if ( use_logging ) {
1729           LOG(ERROR) << "Problems sending mail to " << dest << ": "
1730                      << StrError(errno);
1731         } else {
1732           fprintf(stderr, "Problems sending mail to %s: %s\n",
1733                   dest, StrError(errno).c_str());
1734         }
1735       }
1736       return ok;
1737     } else {
1738       if ( use_logging ) {
1739         LOG(ERROR) << "Unable to send mail to " << dest;
1740       } else {
1741         fprintf(stderr, "Unable to send mail to %s\n", dest);
1742       }
1743     }
1744   }
1745   return false;
1746 }
1747
1748 bool SendEmail(const char*dest, const char *subject, const char*body){
1749   return SendEmailInternal(dest, subject, body, true);
1750 }
1751
1752 static void GetTempDirectories(vector<string>* list) {
1753   list->clear();
1754 #ifdef OS_WINDOWS
1755   // On windows we'll try to find a directory in this order:
1756   //   C:/Documents & Settings/whomever/TEMP (or whatever GetTempPath() is)
1757   //   C:/TMP/
1758   //   C:/TEMP/
1759   //   C:/WINDOWS/ or C:/WINNT/
1760   //   .
1761   char tmp[MAX_PATH];
1762   if (GetTempPathA(MAX_PATH, tmp))
1763     list->push_back(tmp);
1764   list->push_back("C:\\tmp\\");
1765   list->push_back("C:\\temp\\");
1766 #else
1767   // Directories, in order of preference. If we find a dir that
1768   // exists, we stop adding other less-preferred dirs
1769   const char * candidates[] = {
1770     // Non-null only during unittest/regtest
1771     getenv("TEST_TMPDIR"),
1772
1773     // Explicitly-supplied temp dirs
1774     getenv("TMPDIR"), getenv("TMP"),
1775
1776     // If all else fails
1777     "/tmp",
1778   };
1779
1780   for (size_t i = 0; i < ARRAYSIZE(candidates); i++) {
1781     const char *d = candidates[i];
1782     if (!d) continue;  // Empty env var
1783
1784     // Make sure we don't surprise anyone who's expecting a '/'
1785     string dstr = d;
1786     if (dstr[dstr.size() - 1] != '/') {
1787       dstr += "/";
1788     }
1789     list->push_back(dstr);
1790
1791     struct stat statbuf;
1792     if (!stat(d, &statbuf) && S_ISDIR(statbuf.st_mode)) {
1793       // We found a dir that exists - we're done.
1794       return;
1795     }
1796   }
1797
1798 #endif
1799 }
1800
1801 static vector<string>* logging_directories_list;
1802
1803 const vector<string>& GetLoggingDirectories() {
1804   // Not strictly thread-safe but we're called early in InitGoogle().
1805   if (logging_directories_list == NULL) {
1806     logging_directories_list = new vector<string>;
1807
1808     if ( !FLAGS_log_dir.empty() ) {
1809       // A dir was specified, we should use it
1810       logging_directories_list->push_back(FLAGS_log_dir.c_str());
1811     } else {
1812       GetTempDirectories(logging_directories_list);
1813 #ifdef OS_WINDOWS
1814       char tmp[MAX_PATH];
1815       if (GetWindowsDirectoryA(tmp, MAX_PATH))
1816         logging_directories_list->push_back(tmp);
1817       logging_directories_list->push_back(".\\");
1818 #else
1819       logging_directories_list->push_back("./");
1820 #endif
1821     }
1822   }
1823   return *logging_directories_list;
1824 }
1825
1826 void TestOnly_ClearLoggingDirectoriesList() {
1827   fprintf(stderr, "TestOnly_ClearLoggingDirectoriesList should only be "
1828           "called from test code.\n");
1829   delete logging_directories_list;
1830   logging_directories_list = NULL;
1831 }
1832
1833 void GetExistingTempDirectories(vector<string>* list) {
1834   GetTempDirectories(list);
1835   vector<string>::iterator i_dir = list->begin();
1836   while( i_dir != list->end() ) {
1837     // zero arg to access means test for existence; no constant
1838     // defined on windows
1839     if ( access(i_dir->c_str(), 0) ) {
1840       i_dir = list->erase(i_dir);
1841     } else {
1842       ++i_dir;
1843     }
1844   }
1845 }
1846
1847 void TruncateLogFile(const char *path, int64 limit, int64 keep) {
1848 #ifdef HAVE_UNISTD_H
1849   struct stat statbuf;
1850   const int kCopyBlockSize = 8 << 10;
1851   char copybuf[kCopyBlockSize];
1852   int64 read_offset, write_offset;
1853   // Don't follow symlinks unless they're our own fd symlinks in /proc
1854   int flags = O_RDWR;
1855   // TODO(hamaji): Support other environments.
1856 #ifdef OS_LINUX
1857   const char *procfd_prefix = "/proc/self/fd/";
1858   if (strncmp(procfd_prefix, path, strlen(procfd_prefix))) flags |= O_NOFOLLOW;
1859 #endif
1860
1861   int fd = open(path, flags);
1862   if (fd == -1) {
1863     if (errno == EFBIG) {
1864       // The log file in question has got too big for us to open. The
1865       // real fix for this would be to compile logging.cc (or probably
1866       // all of base/...) with -D_FILE_OFFSET_BITS=64 but that's
1867       // rather scary.
1868       // Instead just truncate the file to something we can manage
1869       if (truncate(path, 0) == -1) {
1870         PLOG(ERROR) << "Unable to truncate " << path;
1871       } else {
1872         LOG(ERROR) << "Truncated " << path << " due to EFBIG error";
1873       }
1874     } else {
1875       PLOG(ERROR) << "Unable to open " << path;
1876     }
1877     return;
1878   }
1879
1880   if (fstat(fd, &statbuf) == -1) {
1881     PLOG(ERROR) << "Unable to fstat()";
1882     goto out_close_fd;
1883   }
1884
1885   // See if the path refers to a regular file bigger than the
1886   // specified limit
1887   if (!S_ISREG(statbuf.st_mode)) goto out_close_fd;
1888   if (statbuf.st_size <= limit)  goto out_close_fd;
1889   if (statbuf.st_size <= keep) goto out_close_fd;
1890
1891   // This log file is too large - we need to truncate it
1892   LOG(INFO) << "Truncating " << path << " to " << keep << " bytes";
1893
1894   // Copy the last "keep" bytes of the file to the beginning of the file
1895   read_offset = statbuf.st_size - keep;
1896   write_offset = 0;
1897   int bytesin, bytesout;
1898   while ((bytesin = pread(fd, copybuf, sizeof(copybuf), read_offset)) > 0) {
1899     bytesout = pwrite(fd, copybuf, bytesin, write_offset);
1900     if (bytesout == -1) {
1901       PLOG(ERROR) << "Unable to write to " << path;
1902       break;
1903     } else if (bytesout != bytesin) {
1904       LOG(ERROR) << "Expected to write " << bytesin << ", wrote " << bytesout;
1905     }
1906     read_offset += bytesin;
1907     write_offset += bytesout;
1908   }
1909   if (bytesin == -1) PLOG(ERROR) << "Unable to read from " << path;
1910
1911   // Truncate the remainder of the file. If someone else writes to the
1912   // end of the file after our last read() above, we lose their latest
1913   // data. Too bad ...
1914   if (ftruncate(fd, write_offset) == -1) {
1915     PLOG(ERROR) << "Unable to truncate " << path;
1916   }
1917
1918  out_close_fd:
1919   close(fd);
1920 #else
1921   LOG(ERROR) << "No log truncation support.";
1922 #endif
1923 }
1924
1925 void TruncateStdoutStderr() {
1926 #ifdef HAVE_UNISTD_H
1927   int64 limit = MaxLogSize() << 20;
1928   int64 keep = 1 << 20;
1929   TruncateLogFile("/proc/self/fd/1", limit, keep);
1930   TruncateLogFile("/proc/self/fd/2", limit, keep);
1931 #else
1932   LOG(ERROR) << "No log truncation support.";
1933 #endif
1934 }
1935
1936
1937 // Helper functions for string comparisons.
1938 #define DEFINE_CHECK_STROP_IMPL(name, func, expected)                   \
1939   string* Check##func##expected##Impl(const char* s1, const char* s2,   \
1940                                       const char* names) {              \
1941     bool equal = s1 == s2 || (s1 && s2 && !func(s1, s2));               \
1942     if (equal == expected) return NULL;                                 \
1943     else {                                                              \
1944       ostringstream ss;                                                 \
1945       if (!s1) s1 = "";                                                 \
1946       if (!s2) s2 = "";                                                 \
1947       ss << #name " failed: " << names << " (" << s1 << " vs. " << s2 << ")"; \
1948       return new string(ss.str());                                      \
1949     }                                                                   \
1950   }
1951 DEFINE_CHECK_STROP_IMPL(CHECK_STREQ, strcmp, true)
1952 DEFINE_CHECK_STROP_IMPL(CHECK_STRNE, strcmp, false)
1953 DEFINE_CHECK_STROP_IMPL(CHECK_STRCASEEQ, strcasecmp, true)
1954 DEFINE_CHECK_STROP_IMPL(CHECK_STRCASENE, strcasecmp, false)
1955 #undef DEFINE_CHECK_STROP_IMPL
1956
1957 int posix_strerror_r(int err, char *buf, size_t len) {
1958   // Sanity check input parameters
1959   if (buf == NULL || len <= 0) {
1960     errno = EINVAL;
1961     return -1;
1962   }
1963
1964   // Reset buf and errno, and try calling whatever version of strerror_r()
1965   // is implemented by glibc
1966   buf[0] = '\000';
1967   int old_errno = errno;
1968   errno = 0;
1969   char *rc = reinterpret_cast<char *>(strerror_r(err, buf, len));
1970
1971   // Both versions set errno on failure
1972   if (errno) {
1973     // Should already be there, but better safe than sorry
1974     buf[0]     = '\000';
1975     return -1;
1976   }
1977   errno = old_errno;
1978
1979   // POSIX is vague about whether the string will be terminated, although
1980   // is indirectly implies that typically ERANGE will be returned, instead
1981   // of truncating the string. This is different from the GNU implementation.
1982   // We play it safe by always terminating the string explicitly.
1983   buf[len-1] = '\000';
1984
1985   // If the function succeeded, we can use its exit code to determine the
1986   // semantics implemented by glibc
1987   if (!rc) {
1988     return 0;
1989   } else {
1990     // GNU semantics detected
1991     if (rc == buf) {
1992       return 0;
1993     } else {
1994       buf[0] = '\000';
1995 #if defined(OS_MACOSX) || defined(OS_FREEBSD) || defined(OS_OPENBSD)
1996       if (reinterpret_cast<intptr_t>(rc) < sys_nerr) {
1997         // This means an error on MacOSX or FreeBSD.
1998         return -1;
1999       }
2000 #endif
2001       strncat(buf, rc, len-1);
2002       return 0;
2003     }
2004   }
2005 }
2006
2007 string StrError(int err) {
2008   char buf[100];
2009   int rc = posix_strerror_r(err, buf, sizeof(buf));
2010   if ((rc < 0) || (buf[0] == '\000')) {
2011     snprintf(buf, sizeof(buf), "Error number %d", err);
2012   }
2013   return buf;
2014 }
2015
2016 LogMessageFatal::LogMessageFatal(const char* file, int line) :
2017     LogMessage(file, line, GLOG_FATAL) {}
2018
2019 LogMessageFatal::LogMessageFatal(const char* file, int line,
2020                                  const CheckOpString& result) :
2021     LogMessage(file, line, result) {}
2022
2023 LogMessageFatal::~LogMessageFatal() {
2024     Flush();
2025     LogMessage::Fail();
2026 }
2027
2028 namespace base {
2029
2030 CheckOpMessageBuilder::CheckOpMessageBuilder(const char *exprtext)
2031     : stream_(new ostringstream) {
2032   *stream_ << exprtext << " (";
2033 }
2034
2035 CheckOpMessageBuilder::~CheckOpMessageBuilder() {
2036   delete stream_;
2037 }
2038
2039 ostream* CheckOpMessageBuilder::ForVar2() {
2040   *stream_ << " vs. ";
2041   return stream_;
2042 }
2043
2044 string* CheckOpMessageBuilder::NewString() {
2045   *stream_ << ")";
2046   return new string(stream_->str());
2047 }
2048
2049 }  // namespace base
2050
2051 template <>
2052 void MakeCheckOpValueString(std::ostream* os, const char& v) {
2053   if (v >= 32 && v <= 126) {
2054     (*os) << "'" << v << "'";
2055   } else {
2056     (*os) << "char value " << (short)v;
2057   }
2058 }
2059
2060 template <>
2061 void MakeCheckOpValueString(std::ostream* os, const signed char& v) {
2062   if (v >= 32 && v <= 126) {
2063     (*os) << "'" << v << "'";
2064   } else {
2065     (*os) << "signed char value " << (short)v;
2066   }
2067 }
2068
2069 template <>
2070 void MakeCheckOpValueString(std::ostream* os, const unsigned char& v) {
2071   if (v >= 32 && v <= 126) {
2072     (*os) << "'" << v << "'";
2073   } else {
2074     (*os) << "unsigned char value " << (unsigned short)v;
2075   }
2076 }
2077
2078 void InitGoogleLogging(const char* argv0) {
2079   glog_internal_namespace_::InitGoogleLoggingUtilities(argv0);
2080 }
2081
2082 void ShutdownGoogleLogging() {
2083   glog_internal_namespace_::ShutdownGoogleLoggingUtilities();
2084   LogDestination::DeleteLogDestinations();
2085   delete logging_directories_list;
2086   logging_directories_list = NULL;
2087 }
2088
2089 _END_GOOGLE_NAMESPACE_