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