blob: 8b89368690b111b07dbe65a65991394bc1225c56 [file] [log] [blame]
Darin Petkovce9b3a12013-01-10 16:38:54 +01001// Copyright (c) 2013 The Chromium OS Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
Fletcher Woodruff07c28532019-01-24 11:08:53 -07005#include <grp.h>
6#include <pwd.h>
7#include <sys/types.h>
8#include <unistd.h>
mhasank80cbe4d2020-04-02 22:46:08 -07009#include <memory>
Fletcher Woodruff07c28532019-01-24 11:08:53 -070010#include <string>
11#include <vector>
12
13#include <base/files/file_path.h>
14#include <base/files/file_util.h>
15#include <base/files/scoped_temp_dir.h>
Eric Carusof9091f82017-04-28 14:18:59 -070016#include <dbus/mock_bus.h>
Darin Petkovce9b3a12013-01-10 16:38:54 +010017#include <gtest/gtest.h>
mhasankaf5251d2020-04-29 18:53:03 -070018#include <cryptohome/proto_bindings/rpc.pb.h>
19#include <cryptohome-client-test/cryptohome/dbus-proxy-mocks.h>
Darin Petkovce9b3a12013-01-10 16:38:54 +010020
Alex Vakulenko262be3f2014-07-30 15:25:50 -070021#include "debugd/src/log_tool.h"
Darin Petkovce9b3a12013-01-10 16:38:54 +010022
mhasankaf5251d2020-04-29 18:53:03 -070023using testing::_;
24using testing::Invoke;
25using testing::Return;
26using testing::WithArg;
27
Fletcher Woodruff07c28532019-01-24 11:08:53 -070028namespace {
Qijiang Fan7410a422020-08-28 15:45:44 +090029bool CreateDirectoryAndWriteFile(const base::FilePath& path,
30 const std::string& contents) {
Fletcher Woodruff07c28532019-01-24 11:08:53 -070031 return base::CreateDirectory(path.DirName()) &&
32 base::WriteFile(path, contents.c_str(), contents.length()) ==
33 contents.length();
34}
35} // namespace
36
Darin Petkovce9b3a12013-01-10 16:38:54 +010037namespace debugd {
38
mhasankaf5251d2020-04-29 18:53:03 -070039class FakeLog : public LogTool::Log {
40 public:
41 MOCK_METHOD(std::string, GetLogData, (), (const, override));
42};
43
Darin Petkovce9b3a12013-01-10 16:38:54 +010044class LogToolTest : public testing::Test {
45 protected:
mhasank80cbe4d2020-04-02 22:46:08 -070046 std::unique_ptr<LogTool> log_tool_;
47 base::ScopedTempDir temp_dir_;
Eric Carusof9091f82017-04-28 14:18:59 -070048
mhasank80cbe4d2020-04-02 22:46:08 -070049 void SetUp() override {
50 ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
51 log_tool_ = std::unique_ptr<LogTool>(new LogTool(
mhasankaf5251d2020-04-29 18:53:03 -070052 new dbus::MockBus(dbus::Bus::Options()),
53 std::make_unique<org::chromium::CryptohomeInterfaceProxyMock>(),
54 std::make_unique<FakeLog>(), temp_dir_.GetPath()));
55
56 ON_CALL(*GetFakeLog(), GetLogData).WillByDefault(Return("fake"));
57 }
58
59 FakeLog* GetFakeLog() {
60 return static_cast<FakeLog*>(log_tool_->arc_bug_report_log_.get());
61 }
62
mhasankd2b84882020-05-04 17:02:19 -070063 std::string GetArcBugReport(const std::string& username, bool* is_backup) {
64 return log_tool_->GetArcBugReport(username, is_backup);
mhasankaf5251d2020-04-29 18:53:03 -070065 }
66
67 org::chromium::CryptohomeInterfaceProxyMock* GetCryptHomeProxy() {
68 return static_cast<org::chromium::CryptohomeInterfaceProxyMock*>(
69 log_tool_->cryptohome_proxy_.get());
70 }
71
72 void SetArcBugReportBackup(const std::string& userhash) {
73 log_tool_->arc_bug_report_backups_.insert(userhash);
mhasank80cbe4d2020-04-02 22:46:08 -070074 }
Darin Petkovce9b3a12013-01-10 16:38:54 +010075};
76
mhasankaf5251d2020-04-29 18:53:03 -070077TEST_F(LogToolTest, GetArcBugReport_ReturnsContents_WhenFileExists) {
mhasank86c46c72020-08-13 15:36:29 -070078 std::string userhash = "0abcdef1230abcdef1230abcdef1230abcdef123";
mhasankaf5251d2020-04-29 18:53:03 -070079 base::FilePath logPath =
80 temp_dir_.GetPath().Append(userhash).Append("arc-bugreport.log");
Qijiang Fan7410a422020-08-28 15:45:44 +090081 EXPECT_TRUE(CreateDirectoryAndWriteFile(logPath, "test"));
mhasankaf5251d2020-04-29 18:53:03 -070082 EXPECT_TRUE(base::PathExists(logPath));
83 SetArcBugReportBackup(userhash);
84 EXPECT_CALL(*GetCryptHomeProxy(), GetSanitizedUsername("username", _, _, _))
85 .WillOnce(WithArg<1>(Invoke([&userhash](std::string* out_sanitized) {
86 *out_sanitized = userhash;
87 return true;
88 })));
89
mhasankd2b84882020-05-04 17:02:19 -070090 bool is_backup;
91 std::string report = GetArcBugReport("username", &is_backup);
92
93 EXPECT_EQ(report, "test");
94 EXPECT_TRUE(is_backup);
95}
96
97TEST_F(LogToolTest, GetArcBugReport_Succeeds_WhenIsBackupIsNull) {
mhasank86c46c72020-08-13 15:36:29 -070098 std::string userhash = "0abcdef1230abcdef1230abcdef1230abcdef123";
mhasankd2b84882020-05-04 17:02:19 -070099 base::FilePath logPath =
100 temp_dir_.GetPath().Append(userhash).Append("arc-bugreport.log");
Qijiang Fan7410a422020-08-28 15:45:44 +0900101 EXPECT_TRUE(CreateDirectoryAndWriteFile(logPath, "test"));
mhasankd2b84882020-05-04 17:02:19 -0700102 SetArcBugReportBackup(userhash);
103 EXPECT_CALL(*GetCryptHomeProxy(), GetSanitizedUsername("username", _, _, _))
104 .WillOnce(WithArg<1>(Invoke([&userhash](std::string* out_sanitized) {
105 *out_sanitized = userhash;
106 return true;
107 })));
108
109 std::string report = GetArcBugReport("username", nullptr /*is_backup*/);
mhasankaf5251d2020-04-29 18:53:03 -0700110
111 EXPECT_EQ(report, "test");
112}
113
114TEST_F(LogToolTest, GetArcBugReport_DeletesFile_WhenBackupNotSet) {
mhasank86c46c72020-08-13 15:36:29 -0700115 std::string userhash = "0abcdef1230abcdef1230abcdef1230abcdef123";
mhasankaf5251d2020-04-29 18:53:03 -0700116 base::FilePath logPath =
117 temp_dir_.GetPath().Append(userhash).Append("arc-bugreport.log");
Qijiang Fan7410a422020-08-28 15:45:44 +0900118 EXPECT_TRUE(CreateDirectoryAndWriteFile(logPath, "test"));
mhasankaf5251d2020-04-29 18:53:03 -0700119 EXPECT_TRUE(base::PathExists(logPath));
120 EXPECT_CALL(*GetFakeLog(), GetLogData);
121 EXPECT_CALL(*GetCryptHomeProxy(), GetSanitizedUsername("username", _, _, _))
122 .WillOnce(WithArg<1>(Invoke([&userhash](std::string* out_sanitized) {
123 *out_sanitized = userhash;
124 return true;
125 })));
126
mhasankd2b84882020-05-04 17:02:19 -0700127 bool is_backup;
128 std::string report = GetArcBugReport("username", &is_backup);
mhasankaf5251d2020-04-29 18:53:03 -0700129
130 EXPECT_EQ(report, "fake");
mhasankd2b84882020-05-04 17:02:19 -0700131 EXPECT_FALSE(is_backup);
mhasankaf5251d2020-04-29 18:53:03 -0700132 EXPECT_FALSE(base::PathExists(logPath));
133}
134
mhasank80cbe4d2020-04-02 22:46:08 -0700135TEST_F(LogToolTest, DeleteArcBugReportBackup) {
mhasank86c46c72020-08-13 15:36:29 -0700136 std::string userhash = "0abcdef1230abcdef1230abcdef1230abcdef123";
Tom Hughesd6c2d392020-08-24 18:12:11 -0700137 base::FilePath logPath =
138 temp_dir_.GetPath().Append(userhash).Append("arc-bugreport.log");
Qijiang Fan7410a422020-08-28 15:45:44 +0900139 EXPECT_TRUE(CreateDirectoryAndWriteFile(logPath, userhash));
mhasankaf5251d2020-04-29 18:53:03 -0700140 EXPECT_TRUE(base::PathExists(logPath));
mhasank80cbe4d2020-04-02 22:46:08 -0700141 log_tool_->DeleteArcBugReportBackup(userhash);
mhasankaf5251d2020-04-29 18:53:03 -0700142 EXPECT_FALSE(base::PathExists(logPath));
mhasank80cbe4d2020-04-02 22:46:08 -0700143}
144
Chris Morin790fd262019-04-03 20:29:36 -0700145TEST_F(LogToolTest, EncodeString) {
Luis Hector Chavezfc2566f2018-09-13 15:00:36 -0700146 // U+1F600 GRINNING FACE
147 constexpr const char kGrinningFaceUTF8[] = "\xF0\x9F\x98\x80";
148 constexpr const char kGrinningFaceBase64[] = "<base64>: 8J+YgA==";
Luis Hector Chavezfc2566f2018-09-13 15:00:36 -0700149 EXPECT_EQ(
150 kGrinningFaceUTF8,
Tom Hughesd6c2d392020-08-24 18:12:11 -0700151 LogTool::EncodeString(kGrinningFaceUTF8, LogTool::Encoding::kAutodetect));
152 EXPECT_EQ(kGrinningFaceUTF8,
153 LogTool::EncodeString(kGrinningFaceUTF8, LogTool::Encoding::kUtf8));
Luis Hector Chavezfc2566f2018-09-13 15:00:36 -0700154 EXPECT_EQ(
155 kGrinningFaceBase64,
Chris Morin790fd262019-04-03 20:29:36 -0700156 LogTool::EncodeString(kGrinningFaceUTF8, LogTool::Encoding::kBase64));
Luis Hector Chavezfc2566f2018-09-13 15:00:36 -0700157
158 // .xz Stream Header Magic Bytes
159 constexpr const char kXzStreamHeaderMagicBytes[] = "\xFD\x37\x7A\x58\x5A\x00";
160 constexpr const char kXzStreamHeaderMagicUTF8[] =
161 "\xEF\xBF\xBD"
162 "7zXZ";
163 constexpr const char kXzStreamHeaderMagicBase64[] = "<base64>: /Td6WFo=";
164 EXPECT_EQ(kXzStreamHeaderMagicBase64,
Chris Morin790fd262019-04-03 20:29:36 -0700165 LogTool::EncodeString(kXzStreamHeaderMagicBytes,
166 LogTool::Encoding::kAutodetect));
Luis Hector Chavezfc2566f2018-09-13 15:00:36 -0700167 EXPECT_EQ(kXzStreamHeaderMagicUTF8,
Chris Morin790fd262019-04-03 20:29:36 -0700168 LogTool::EncodeString(kXzStreamHeaderMagicBytes,
169 LogTool::Encoding::kUtf8));
Luis Hector Chavezfc2566f2018-09-13 15:00:36 -0700170 EXPECT_EQ(kXzStreamHeaderMagicBase64,
Chris Morin790fd262019-04-03 20:29:36 -0700171 LogTool::EncodeString(kXzStreamHeaderMagicBytes,
172 LogTool::Encoding::kBase64));
173
174 EXPECT_EQ(kXzStreamHeaderMagicBytes,
175 LogTool::EncodeString(kXzStreamHeaderMagicBytes,
176 LogTool::Encoding::kBinary));
Luis Hector Chavezfc2566f2018-09-13 15:00:36 -0700177}
178
Fletcher Woodruff07c28532019-01-24 11:08:53 -0700179class LogTest : public testing::Test {
180 protected:
181 void SetUp() override {
182 std::vector<char> buf(1024);
183
184 uid_t uid = getuid();
185 struct passwd pw_entry;
186 struct passwd* pw_result;
187 ASSERT_EQ(getpwuid_r(uid, &pw_entry, &buf[0], buf.size(), &pw_result), 0);
188 ASSERT_NE(pw_result, nullptr);
189 user_name_ = pw_entry.pw_name;
190
191 gid_t gid = getgid();
192 struct group gr_entry;
193 struct group* gr_result;
194 ASSERT_EQ(getgrgid_r(gid, &gr_entry, &buf[0], buf.size(), &gr_result), 0);
195 ASSERT_NE(gr_result, nullptr);
196 group_name_ = gr_entry.gr_name;
197 }
198
199 std::string user_name_;
200 std::string group_name_;
201};
202
203TEST_F(LogTest, GetFileLogData) {
204 base::ScopedTempDir temp;
205 ASSERT_TRUE(temp.CreateUniqueTempDir());
206
207 base::FilePath file_one = temp.GetPath().Append("test/file_one");
Qijiang Fan7410a422020-08-28 15:45:44 +0900208 ASSERT_TRUE(CreateDirectoryAndWriteFile(file_one, "test_one_contents"));
Fletcher Woodruff07c28532019-01-24 11:08:53 -0700209 const LogTool::Log log_one(LogTool::Log::kFile, "test_log_one",
210 file_one.value(), user_name_, group_name_);
Chris Morin790fd262019-04-03 20:29:36 -0700211 EXPECT_EQ(log_one.GetLogData(), "test_one_contents");
Fletcher Woodruff07c28532019-01-24 11:08:53 -0700212
213 base::FilePath file_two = temp.GetPath().Append("test/file_two");
Qijiang Fan7410a422020-08-28 15:45:44 +0900214 ASSERT_TRUE(CreateDirectoryAndWriteFile(file_two, ""));
Fletcher Woodruff07c28532019-01-24 11:08:53 -0700215 const LogTool::Log log_two(LogTool::Log::kFile, "test_log_two",
216 file_two.value(), user_name_, group_name_);
Chris Morin790fd262019-04-03 20:29:36 -0700217 EXPECT_EQ(log_two.GetLogData(), "<empty>");
Fletcher Woodruff07c28532019-01-24 11:08:53 -0700218
219 base::FilePath file_three = temp.GetPath().Append("test/file_three");
Qijiang Fan7410a422020-08-28 15:45:44 +0900220 ASSERT_TRUE(CreateDirectoryAndWriteFile(file_three, "long input value"));
Fletcher Woodruff07c28532019-01-24 11:08:53 -0700221 const LogTool::Log log_three(LogTool::Log::kFile, "test_log_three",
222 file_three.value(), user_name_, group_name_, 5);
Chris Morin790fd262019-04-03 20:29:36 -0700223 EXPECT_EQ(log_three.GetLogData(), "value");
Fletcher Woodruff07c28532019-01-24 11:08:53 -0700224}
225
226TEST_F(LogTest, GetCommandLogData) {
227 LogTool::Log log_one(LogTool::Log::kCommand, "test_log_one", "printf ''",
228 user_name_, group_name_);
229 log_one.DisableMinijailForTest();
Chris Morin790fd262019-04-03 20:29:36 -0700230 EXPECT_EQ(log_one.GetLogData(), "<empty>");
Fletcher Woodruff07c28532019-01-24 11:08:53 -0700231
232 LogTool::Log log_two(LogTool::Log::kCommand, "test_log_two",
233 "printf 'test_output'", user_name_, group_name_);
234 log_two.DisableMinijailForTest();
Chris Morin790fd262019-04-03 20:29:36 -0700235 EXPECT_EQ(log_two.GetLogData(), "test_output");
Fletcher Woodruff07c28532019-01-24 11:08:53 -0700236
237 LogTool::Log log_three(LogTool::Log::kCommand, "test_log_three",
Tom Hughesd6c2d392020-08-24 18:12:11 -0700238 "echo a,b,c | cut -d, -f2", user_name_, group_name_);
Fletcher Woodruff07c28532019-01-24 11:08:53 -0700239 log_three.DisableMinijailForTest();
Chris Morin790fd262019-04-03 20:29:36 -0700240 EXPECT_EQ(log_three.GetLogData(), "b\n");
Fletcher Woodruff07c28532019-01-24 11:08:53 -0700241}
Darin Petkovce9b3a12013-01-10 16:38:54 +0100242} // namespace debugd