crash-reporter: Capture and send recent update_engine logs when it crashes

crash_collector.cc

 // Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "crash-reporter/crash_collector.h"
 
 #include <dirent.h>
 #include <fcntl.h>  // For file creation modes.
 #include <pwd.h>  // For struct passwd.
 #include <sys/types.h>  // for mode_t.
 #include <sys/wait.h>  // For waitpid.
 #include <unistd.h>  // For execv and fork.
 
 #include <set>
 
 #include "base/eintr_wrapper.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "crash-reporter/system_logging.h"
 
 static const char kDefaultUserName[] = "chronos";
 static const char kLsbRelease[] = "/etc/lsb-release";
+static const char kShellPath[] = "/bin/sh";
 static const char kSystemCrashPath[] = "/var/spool/crash";
 static const char kUserCrashPath[] = "/home/chronos/user/crash";
 
 // Directory mode of the user crash spool directory.
 static const mode_t kUserCrashPathMode = 0755;
 
 // Directory mode of the system crash spool directory.
 static const mode_t kSystemCrashPathMode = 01755;
 
 static const uid_t kRootOwner = 0;
@@ skipping 68 matching lines @@
   }
   argv[arguments.size()] = NULL;
 
   int pid = fork();
   if (pid < 0) {
     logger_->LogError("Fork failed: %d", errno);
     return -1;
   }
 
   if (pid == 0) {
-    int output_handle = HANDLE_EINTR(creat(output_file, 0700));
+    int output_handle = HANDLE_EINTR(creat(output_file, 0600));
     if (output_handle < 0) {
       logger_->LogError("Could not create %s: %d", output_file, errno);
       // Avoid exit() to avoid atexit handlers from parent.
       _exit(127);
     }
     dup2(output_handle, 1);
     dup2(output_handle, 2);
     execv(argv[0], &argv[0]);
     logger_->LogError("Exec failed: %d", errno);
     _exit(127);
@@ skipping 177 matching lines @@
           crash_directory.value().c_str(),
           kMaxCrashDirectorySize);
       full = true;
       break;
     }
   }
   closedir(dir);
   return !full;
 }
 
+bool CrashCollector::IsCommentLine(const std::string &line) {
+  size_t found = line.find_first_not_of(" ");
+  return found != std::string::npos && line[found] == '#';
+}
+
 bool CrashCollector::ReadKeyValueFile(
     const FilePath &path,
     const char separator,
     std::map<std::string, std::string> *dictionary) {
   std::string contents;
   if (!file_util::ReadFileToString(path, &contents)) {
     return false;
   }
   typedef std::vector<std::string> StringVector;
   StringVector lines;
   SplitString(contents, '\n', &lines);
   bool any_errors = false;
   for (StringVector::iterator line = lines.begin(); line != lines.end();
        ++line) {
     // Allow empty strings.
     if (line->empty())
       continue;
+    // Allow comment lines.
+    if (IsCommentLine(*line))
+      continue;
     StringVector sides;
     SplitString(*line, separator, &sides);
     if (sides.size() != 2) {
       any_errors = true;
       continue;
     }
     dictionary->insert(std::pair<std::string, std::string>(sides[0], sides[1]));
   }
   return !any_errors;
 }
 
+bool CrashCollector::GetLogContents(const FilePath &config_path,
+                                    const std::string &exec_name,
+                                    const FilePath &output_file) {
+  std::map<std::string, std::string> log_commands;
+  if (!ReadKeyValueFile(config_path, ':', &log_commands)) {
+    logger_->LogInfo("Unable to read log configuration file %s",
+                     config_path.value().c_str());
+    return false;
+  }
+
+  if (log_commands.find(exec_name) == log_commands.end())
+    return false;
+
+  std::vector<const char *> command;
+  command.push_back(kShellPath);
+  command.push_back("-c");
+  std::string shell_command = log_commands[exec_name];
+  command.push_back(shell_command.c_str());
+
+  int fork_result = ForkExecAndPipe(command, output_file.value().c_str());
+  if (fork_result != 0) {
+    logger_->LogInfo("Running shell command %s failed with: %d",
+                     shell_command.c_str(), fork_result);
+    return false;
+  }
+  return true;
+}
+
 void CrashCollector::AddCrashMetaData(const std::string &key,
                                       const std::string &value) {
   extra_metadata_.append(StringPrintf("%s=%s\n", key.c_str(), value.c_str()));
 }
 
 void CrashCollector::WriteCrashMetaData(const FilePath &meta_path,
                                         const std::string &exec_name,
                                         const std::string &payload_path) {
   std::map<std::string, std::string> contents;
   if (!ReadKeyValueFile(FilePath(std::string(lsb_release_)), '=', &contents)) {
@@ skipping 17 matching lines @@
                                        version.c_str(),
                                        payload_path.c_str(),
                                        payload_size);
   // We must use WriteNewFile instead of file_util::WriteFile as we
   // do not want to write with root access to a symlink that an attacker
   // might have created.
   if (WriteNewFile(meta_path, meta_data.c_str(), meta_data.size()) < 0) {
     logger_->LogError("Unable to write %s", meta_path.value().c_str());
   }
 }