crash-reporter: Avoid writing through symlinks.

crash_collector_test.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 <unistd.h>
 
 #include "base/file_util.h"
 #include "base/string_util.h"
 #include "crash-reporter/crash_collector.h"
 #include "crash-reporter/system_logging_mock.h"
+#include "crash-reporter/test_helpers.h"
 #include "gflags/gflags.h"
 #include "gtest/gtest.h"
 
+// This test assumes the following standard binaries are installed.
+static const char kBinBash[] = "/bin/bash";
+static const char kBinCp[] = "/bin/cp";
+static const char kBinEcho[] = "/bin/echo";
+static const char kBinFalse[] = "/bin/false";
+
 void CountCrash() {
   ADD_FAILURE();
 }
 
 bool IsMetrics() {
   ADD_FAILURE();
   return false;
 }
 
 class CrashCollectorTest : public ::testing::Test {
@@ skipping 17 matching lines @@
   CrashCollector collector_;
   FilePath test_dir_;
 };
 
 TEST_F(CrashCollectorTest, Initialize) {
   ASSERT_TRUE(CountCrash == collector_.count_crash_function_);
   ASSERT_TRUE(IsMetrics == collector_.is_feedback_allowed_function_);
   ASSERT_TRUE(&logging_ == collector_.logger_);
 }
 
+TEST_F(CrashCollectorTest, WriteNewFile) {
+  FilePath test_file = test_dir_.Append("test_new");
+  const char kBuffer[] = "buffer";
+  EXPECT_EQ(strlen(kBuffer),
+            collector_.WriteNewFile(test_file,
+                                    kBuffer,
+                                    strlen(kBuffer)));
+  EXPECT_LT(collector_.WriteNewFile(test_file,
+                                    kBuffer,
+                                    strlen(kBuffer)), 0);
+}
+
+TEST_F(CrashCollectorTest, ForkExecAndPipe) {
+  std::vector<const char *> args;
+  char output_file[] = "test/fork_out";
+
+  // Test basic call with stdout.
+  args.clear();
+  args.push_back(kBinEcho);
+  args.push_back("hello world");
+  EXPECT_EQ(0, collector_.ForkExecAndPipe(args, output_file));
+  ExpectFileEquals("hello world\n", output_file);
+  EXPECT_EQ("", logging_.log());
+
+  // Test non-zero return value
+  logging_.clear();
+  args.clear();
+  args.push_back(kBinFalse);
+  EXPECT_EQ(1, collector_.ForkExecAndPipe(args, output_file));
+  ExpectFileEquals("", output_file);
+  EXPECT_EQ("", logging_.log());
+
+  // Test bad output_file.
+  EXPECT_EQ(127, collector_.ForkExecAndPipe(args, "/bad/path"));
+
+  // Test bad executable.
+  logging_.clear();
+  args.clear();
+  args.push_back("false");
+  EXPECT_EQ(127, collector_.ForkExecAndPipe(args, output_file));
+
+  // Test stderr captured.
+  std::string contents;
+  logging_.clear();
+  args.clear();
+  args.push_back(kBinCp);
+  EXPECT_EQ(1, collector_.ForkExecAndPipe(args, output_file));
+  EXPECT_TRUE(file_util::ReadFileToString(FilePath(output_file),
+                                                   &contents));
+  EXPECT_NE(std::string::npos, contents.find("missing file operand"));
+  EXPECT_EQ("", logging_.log());
+
+  // NULL parameter.
+  logging_.clear();
+  args.clear();
+  args.push_back(NULL);
+  EXPECT_EQ(-1, collector_.ForkExecAndPipe(args, output_file));
+  EXPECT_NE(std::string::npos,
+            logging_.log().find("Bad parameter"));
+
+  // No parameters.
+  args.clear();
+  EXPECT_EQ(127, collector_.ForkExecAndPipe(args, output_file));
+
+  // Segmentation faulting process.
+  logging_.clear();
+  args.clear();
+  args.push_back(kBinBash);
+  args.push_back("-c");
+  args.push_back("kill -SEGV $$");
+  EXPECT_EQ(-1, collector_.ForkExecAndPipe(args, output_file));
+  EXPECT_NE(std::string::npos,
+            logging_.log().find("Process did not exit normally"));
+}
+
 TEST_F(CrashCollectorTest, Sanitize) {
   EXPECT_EQ("chrome", collector_.Sanitize("chrome"));
   EXPECT_EQ("CHROME", collector_.Sanitize("CHROME"));
   EXPECT_EQ("1chrome2", collector_.Sanitize("1chrome2"));
   EXPECT_EQ("chrome__deleted_", collector_.Sanitize("chrome (deleted)"));
   EXPECT_EQ("foo_bar", collector_.Sanitize("foo.bar"));
   EXPECT_EQ("", collector_.Sanitize(""));
   EXPECT_EQ("_", collector_.Sanitize(" "));
 }
 
@@ skipping 163 matching lines @@
   EXPECT_TRUE(i != dictionary.end() && i->second == "h");
   i = dictionary.find("i");
   EXPECT_TRUE(i != dictionary.end() && i->second == "j");
   i = dictionary.find("");
   EXPECT_TRUE(i != dictionary.end() && i->second == "k");
   i = dictionary.find("l");
   EXPECT_TRUE(i != dictionary.end() && i->second == "");
 }
 
 TEST_F(CrashCollectorTest, MetaData) {
-  FilePath meta_file = test_dir_.Append("generated.meta");
+  const char kMetaFileBasename[] = "generated.meta";
+  FilePath meta_file = test_dir_.Append(kMetaFileBasename);
   FilePath lsb_release = test_dir_.Append("lsb-release");
   FilePath payload_file = test_dir_.Append("payload-file");
   std::string contents;
   collector_.lsb_release_ = lsb_release.value().c_str();
   const char kLsbContents[] = "CHROMEOS_RELEASE_VERSION=version\n";
   ASSERT_TRUE(
       file_util::WriteFile(lsb_release,
                            kLsbContents, strlen(kLsbContents)));
   const char kPayload[] = "foo";
   ASSERT_TRUE(
       file_util::WriteFile(payload_file,
                            kPayload, strlen(kPayload)));
   collector_.AddCrashMetaData("foo", "bar");
   collector_.WriteCrashMetaData(meta_file, "kernel", payload_file.value());
   EXPECT_TRUE(file_util::ReadFileToString(meta_file, &contents));
-  EXPECT_EQ("foo=bar\n"
-            "exec_name=kernel\n"
-            "ver=version\n"
-            "payload=test/payload-file\n"
-            "payload_size=3\n"
-            "done=1\n", contents);
+  const char kExpectedMeta[] =
+      "foo=bar\n"
+      "exec_name=kernel\n"
+      "ver=version\n"
+      "payload=test/payload-file\n"
+      "payload_size=3\n"
+      "done=1\n";
+  EXPECT_EQ(kExpectedMeta, contents);
+
+  // Test target of symlink is not overwritten.
+  payload_file = test_dir_.Append("payload2-file");
+  ASSERT_TRUE(
+      file_util::WriteFile(payload_file,
+                           kPayload, strlen(kPayload)));
+  FilePath meta_symlink_path = test_dir_.Append("symlink.meta");
+  ASSERT_EQ(0,
+            symlink(kMetaFileBasename,
+                    meta_symlink_path.value().c_str()));
+  ASSERT_TRUE(file_util::PathExists(meta_symlink_path));
+  logging_.clear();
+  collector_.WriteCrashMetaData(meta_symlink_path,
+                                "kernel",
+                                payload_file.value());
+  // Target metadata contents sould have stayed the same.
+  contents.clear();
+  EXPECT_TRUE(file_util::ReadFileToString(meta_file, &contents));
+  EXPECT_EQ(kExpectedMeta, contents);
+  EXPECT_NE(std::string::npos, logging_.log().find("Unable to write"));
+
+  // Test target of dangling symlink is not created.
+  file_util::Delete(meta_file, false);
+  ASSERT_FALSE(file_util::PathExists(meta_file));
+  logging_.clear();
+  collector_.WriteCrashMetaData(meta_symlink_path, "kernel",
+                                payload_file.value());
+  EXPECT_FALSE(file_util::PathExists(meta_file));
+  EXPECT_NE(std::string::npos, logging_.log().find("Unable to write"));
 }
 
 int main(int argc, char **argv) {
   ::testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
 }