1 // Copyright (c) 2012 The Chromium 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
5 #include "chrome/browser/diagnostics/recon_diagnostics.h"
6
7 #include <string>
8
9 #include "base/file_util.h"
10 #include "base/json/json_reader.h"
11 #include "base/json/json_string_value_serializer.h"
12 #include "base/path_service.h"
13 #include "base/strings/string_number_conversions.h"
14 #include "base/strings/string_util.h"
15 #include "base/strings/stringprintf.h"
16 #include "base/strings/utf_string_conversions.h"
17 #include "base/sys_info.h"
18 #include "chrome/browser/diagnostics/diagnostics_test.h"
19 #include "chrome/common/chrome_constants.h"
20 #include "chrome/common/chrome_paths.h"
21 #include "chrome/common/chrome_version_info.h"
22
23 #if defined(OS_WIN)
24 #include "base/win/windows_version.h"
25 #include "chrome/browser/enumerate_modules_model_win.h"
26 #include "chrome/installer/util/install_util.h"
27 #endif
28
29 // Reconnaissance diagnostics. These are the first and most critical
30 // diagnostic tests. Here we check for the existence of critical files.
31 // TODO(cpu): Define if it makes sense to localize strings.
32
33 // TODO(cpu): There are a few maximum file sizes hard-coded in this file
34 // that have little or no theoretical or experimental ground. Find a way
35 // to justify them.
36
37 namespace diagnostics {
38
39 namespace {
40
41 const int64 kOneKilobyte = 1024;
42 const int64 kOneMegabyte = 1024 * kOneKilobyte;
43
44 class InstallTypeTest;
45 InstallTypeTest* g_install_type = 0;
46
47 // Check if any conflicting DLLs are loaded.
48 class ConflictingDllsTest : public DiagnosticsTest {
49 public:
ConflictingDllsTest()50 ConflictingDllsTest()
51 : DiagnosticsTest(DIAGNOSTICS_CONFLICTING_DLLS_TEST) {}
52
ExecuteImpl(DiagnosticsModel::Observer * observer)53 virtual bool ExecuteImpl(DiagnosticsModel::Observer* observer) OVERRIDE {
54 #if defined(OS_WIN)
55 EnumerateModulesModel* model = EnumerateModulesModel::GetInstance();
56 model->set_limited_mode(true);
57 model->ScanNow();
58 scoped_ptr<ListValue> list(model->GetModuleList());
59 if (!model->confirmed_bad_modules_detected() &&
60 !model->suspected_bad_modules_detected()) {
61 RecordSuccess("No conflicting modules found");
62 return true;
63 }
64
65 std::string failures = "Possibly conflicting modules:";
66 DictionaryValue* dictionary;
67 for (size_t i = 0; i < list->GetSize(); ++i) {
68 if (!list->GetDictionary(i, &dictionary))
69 RecordFailure(DIAG_RECON_DICTIONARY_LOOKUP_FAILED,
70 "Dictionary lookup failed");
71 int status;
72 std::string location;
73 std::string name;
74 if (!dictionary->GetInteger("status", &status))
75 RecordFailure(DIAG_RECON_NO_STATUS_FIELD, "No 'status' field found");
76 if (status < ModuleEnumerator::SUSPECTED_BAD)
77 continue;
78
79 if (!dictionary->GetString("location", &location)) {
80 RecordFailure(DIAG_RECON_NO_LOCATION_FIELD,
81 "No 'location' field found");
82 return true;
83 }
84 if (!dictionary->GetString("name", &name)) {
85 RecordFailure(DIAG_RECON_NO_NAME_FIELD, "No 'name' field found");
86 return true;
87 }
88
89 failures += "\n" + location + name;
90 }
91 RecordFailure(DIAG_RECON_CONFLICTING_MODULES, failures);
92 return true;
93 #else
94 RecordFailure(DIAG_RECON_NOT_IMPLEMENTED, "Not implemented");
95 return true;
96 #endif // defined(OS_WIN)
97 }
98
99 private:
100 DISALLOW_COPY_AND_ASSIGN(ConflictingDllsTest);
101 };
102
103 // Check that the disk space in the volume where the user data directory
104 // normally lives is not dangerously low.
105 class DiskSpaceTest : public DiagnosticsTest {
106 public:
DiskSpaceTest()107 DiskSpaceTest() : DiagnosticsTest(DIAGNOSTICS_DISK_SPACE_TEST) {}
108
ExecuteImpl(DiagnosticsModel::Observer * observer)109 virtual bool ExecuteImpl(DiagnosticsModel::Observer* observer) OVERRIDE {
110 base::FilePath data_dir;
111 if (!PathService::Get(chrome::DIR_USER_DATA, &data_dir))
112 return false;
113 int64 disk_space = base::SysInfo::AmountOfFreeDiskSpace(data_dir);
114 if (disk_space < 0) {
115 RecordFailure(DIAG_RECON_UNABLE_TO_QUERY, "Unable to query free space");
116 return true;
117 }
118 std::string printable_size = base::Int64ToString(disk_space);
119 if (disk_space < 80 * kOneMegabyte) {
120 RecordFailure(DIAG_RECON_LOW_DISK_SPACE,
121 "Low disk space: " + printable_size);
122 return true;
123 }
124 RecordSuccess("Free space: " + printable_size);
125 return true;
126 }
127
128 private:
129 DISALLOW_COPY_AND_ASSIGN(DiskSpaceTest);
130 };
131
132 // Check if it is system install or per-user install.
133 class InstallTypeTest : public DiagnosticsTest {
134 public:
InstallTypeTest()135 InstallTypeTest()
136 : DiagnosticsTest(DIAGNOSTICS_INSTALL_TYPE_TEST), user_level_(false) {}
137
ExecuteImpl(DiagnosticsModel::Observer * observer)138 virtual bool ExecuteImpl(DiagnosticsModel::Observer* observer) OVERRIDE {
139 #if defined(OS_WIN)
140 base::FilePath chrome_exe;
141 if (!PathService::Get(base::FILE_EXE, &chrome_exe)) {
142 RecordFailure(DIAG_RECON_INSTALL_PATH_PROVIDER, "Path provider failure");
143 return false;
144 }
145 user_level_ = InstallUtil::IsPerUserInstall(chrome_exe.value().c_str());
146 const char* type = user_level_ ? "User Level" : "System Level";
147 std::string install_type(type);
148 #else
149 std::string install_type("System Level");
150 #endif // defined(OS_WIN)
151 RecordSuccess(install_type);
152 g_install_type = this;
153 return true;
154 }
155
system_level() const156 bool system_level() const { return !user_level_; }
157
158 private:
159 bool user_level_;
160 DISALLOW_COPY_AND_ASSIGN(InstallTypeTest);
161 };
162
163 // Checks that a given JSON file can be correctly parsed.
164 class JSONTest : public DiagnosticsTest {
165 public:
166 enum FileImportance {
167 NON_CRITICAL,
168 CRITICAL
169 };
170
JSONTest(const base::FilePath & path,DiagnosticsTestId id,int64 max_file_size,FileImportance importance)171 JSONTest(const base::FilePath& path,
172 DiagnosticsTestId id,
173 int64 max_file_size,
174 FileImportance importance)
175 : DiagnosticsTest(id),
176 path_(path),
177 max_file_size_(max_file_size),
178 importance_(importance) {}
179
ExecuteImpl(DiagnosticsModel::Observer * observer)180 virtual bool ExecuteImpl(DiagnosticsModel::Observer* observer) OVERRIDE {
181 if (!base::PathExists(path_)) {
182 if (importance_ == CRITICAL) {
183 RecordOutcome(DIAG_RECON_FILE_NOT_FOUND,
184 "File not found",
185 DiagnosticsModel::TEST_FAIL_CONTINUE);
186 } else {
187 RecordOutcome(DIAG_RECON_FILE_NOT_FOUND_OK,
188 "File not found (but that is OK)",
189 DiagnosticsModel::TEST_OK);
190 }
191 return true;
192 }
193 int64 file_size;
194 if (!base::GetFileSize(path_, &file_size)) {
195 RecordFailure(DIAG_RECON_CANNOT_OBTAIN_FILE_SIZE,
196 "Cannot obtain file size");
197 return true;
198 }
199
200 if (file_size > max_file_size_) {
201 RecordFailure(DIAG_RECON_FILE_TOO_BIG, "File too big");
202 return true;
203 }
204 // Being small enough, we can process it in-memory.
205 std::string json_data;
206 if (!base::ReadFileToString(path_, &json_data)) {
207 RecordFailure(DIAG_RECON_UNABLE_TO_OPEN_FILE,
208 "Could not open file. Possibly locked by another process");
209 return true;
210 }
211
212 JSONStringValueSerializer json(json_data);
213 int error_code = base::JSONReader::JSON_NO_ERROR;
214 std::string error_message;
215 scoped_ptr<Value> json_root(json.Deserialize(&error_code, &error_message));
216 if (base::JSONReader::JSON_NO_ERROR != error_code) {
217 if (error_message.empty()) {
218 error_message = "Parse error " + base::IntToString(error_code);
219 }
220 RecordFailure(DIAG_RECON_PARSE_ERROR, error_message);
221 return true;
222 }
223
224 RecordSuccess("File parsed OK");
225 return true;
226 }
227
228 private:
229 base::FilePath path_;
230 int64 max_file_size_;
231 FileImportance importance_;
232 DISALLOW_COPY_AND_ASSIGN(JSONTest);
233 };
234
235 // Check that the flavor of the operating system is supported.
236 class OperatingSystemTest : public DiagnosticsTest {
237 public:
OperatingSystemTest()238 OperatingSystemTest()
239 : DiagnosticsTest(DIAGNOSTICS_OPERATING_SYSTEM_TEST) {}
240
ExecuteImpl(DiagnosticsModel::Observer * observer)241 virtual bool ExecuteImpl(DiagnosticsModel::Observer* observer) OVERRIDE {
242 #if defined(OS_WIN)
243 base::win::Version version = base::win::GetVersion();
244 if ((version < base::win::VERSION_XP) ||
245 ((version == base::win::VERSION_XP) &&
246 (base::win::OSInfo::GetInstance()->service_pack().major < 2))) {
247 RecordFailure(DIAG_RECON_PRE_WINDOW_XP_SP2,
248 "Must have Windows XP SP2 or later");
249 return false;
250 }
251 #else
252 // TODO(port): define the OS criteria for Linux and Mac.
253 #endif // defined(OS_WIN)
254 RecordSuccess(
255 base::StringPrintf("%s %s",
256 base::SysInfo::OperatingSystemName().c_str(),
257 base::SysInfo::OperatingSystemVersion().c_str()));
258 return true;
259 }
260
261 private:
262 DISALLOW_COPY_AND_ASSIGN(OperatingSystemTest);
263 };
264
265 struct TestPathInfo {
266 DiagnosticsTestId test_id;
267 int path_id;
268 bool is_directory;
269 bool is_optional;
270 bool test_writable;
271 int64 max_size;
272 };
273
274 const TestPathInfo kPathsToTest[] = {
275 {DIAGNOSTICS_PATH_DICTIONARIES_TEST, chrome::DIR_APP_DICTIONARIES, true,
276 true, false, 0},
277 {DIAGNOSTICS_PATH_LOCAL_STATE_TEST, chrome::FILE_LOCAL_STATE, false, false,
278 true, 500 * kOneKilobyte},
279 {DIAGNOSTICS_PATH_RESOURCES_TEST, chrome::FILE_RESOURCES_PACK, false, false,
280 false, 0},
281 {DIAGNOSTICS_PATH_USER_DATA_TEST, chrome::DIR_USER_DATA, true, false, true,
282 850 * kOneMegabyte},
283 };
284
285 // Check that the user's data directory exists and the paths are writable.
286 // If it is a system-wide install some paths are not expected to be writable.
287 // This test depends on |InstallTypeTest| having run successfully.
288 class PathTest : public DiagnosticsTest {
289 public:
PathTest(const TestPathInfo & path_info)290 explicit PathTest(const TestPathInfo& path_info)
291 : DiagnosticsTest(path_info.test_id),
292 path_info_(path_info) {}
293
ExecuteImpl(DiagnosticsModel::Observer * observer)294 virtual bool ExecuteImpl(DiagnosticsModel::Observer* observer) OVERRIDE {
295 if (!g_install_type) {
296 RecordStopFailure(DIAG_RECON_DEPENDENCY, "Install dependency failure");
297 return false;
298 }
299 base::FilePath dir_or_file;
300 if (!PathService::Get(path_info_.path_id, &dir_or_file)) {
301 RecordStopFailure(DIAG_RECON_PATH_PROVIDER, "Path provider failure");
302 return false;
303 }
304 if (!base::PathExists(dir_or_file)) {
305 RecordFailure(
306 DIAG_RECON_PATH_NOT_FOUND,
307 "Path not found: " + UTF16ToUTF8(dir_or_file.LossyDisplayName()));
308 return true;
309 }
310
311 int64 dir_or_file_size = 0;
312 if (path_info_.is_directory) {
313 dir_or_file_size = base::ComputeDirectorySize(dir_or_file);
314 } else {
315 base::GetFileSize(dir_or_file, &dir_or_file_size);
316 }
317 if (!dir_or_file_size && !path_info_.is_optional) {
318 RecordFailure(DIAG_RECON_CANNOT_OBTAIN_SIZE,
319 "Cannot obtain size for: " +
320 UTF16ToUTF8(dir_or_file.LossyDisplayName()));
321 return true;
322 }
323 std::string printable_size = base::Int64ToString(dir_or_file_size);
324
325 if (path_info_.max_size > 0) {
326 if (dir_or_file_size > path_info_.max_size) {
327 RecordFailure(DIAG_RECON_FILE_TOO_LARGE,
328 "Path contents too large (" + printable_size + ") for: " +
329 UTF16ToUTF8(dir_or_file.LossyDisplayName()));
330 return true;
331 }
332 }
333 if (g_install_type->system_level() && !path_info_.test_writable) {
334 RecordSuccess("Path exists");
335 return true;
336 }
337 if (!base::PathIsWritable(dir_or_file)) {
338 RecordFailure(DIAG_RECON_NOT_WRITABLE,
339 "Path is not writable: " +
340 UTF16ToUTF8(dir_or_file.LossyDisplayName()));
341 return true;
342 }
343 RecordSuccess("Path exists and is writable: " + printable_size);
344 return true;
345 }
346
347 private:
348 TestPathInfo path_info_;
349 DISALLOW_COPY_AND_ASSIGN(PathTest);
350 };
351
352 // Check the version of Chrome.
353 class VersionTest : public DiagnosticsTest {
354 public:
VersionTest()355 VersionTest() : DiagnosticsTest(DIAGNOSTICS_VERSION_TEST) {}
356
ExecuteImpl(DiagnosticsModel::Observer * observer)357 virtual bool ExecuteImpl(DiagnosticsModel::Observer* observer) OVERRIDE {
358 chrome::VersionInfo version_info;
359 if (!version_info.is_valid()) {
360 RecordFailure(DIAG_RECON_NO_VERSION, "No Version");
361 return true;
362 }
363 std::string current_version = version_info.Version();
364 if (current_version.empty()) {
365 RecordFailure(DIAG_RECON_EMPTY_VERSION, "Empty Version");
366 return true;
367 }
368 std::string version_modifier =
369 chrome::VersionInfo::GetVersionStringModifier();
370 if (!version_modifier.empty())
371 current_version += " " + version_modifier;
372 #if defined(GOOGLE_CHROME_BUILD)
373 current_version += " GCB";
374 #endif // defined(GOOGLE_CHROME_BUILD)
375 RecordSuccess(current_version);
376 return true;
377 }
378
379 private:
380 DISALLOW_COPY_AND_ASSIGN(VersionTest);
381 };
382
383 } // namespace
384
MakeConflictingDllsTest()385 DiagnosticsTest* MakeConflictingDllsTest() { return new ConflictingDllsTest(); }
386
MakeDiskSpaceTest()387 DiagnosticsTest* MakeDiskSpaceTest() { return new DiskSpaceTest(); }
388
MakeInstallTypeTest()389 DiagnosticsTest* MakeInstallTypeTest() { return new InstallTypeTest(); }
390
MakeBookMarksTest()391 DiagnosticsTest* MakeBookMarksTest() {
392 base::FilePath path = DiagnosticsTest::GetUserDefaultProfileDir();
393 path = path.Append(chrome::kBookmarksFileName);
394 return new JSONTest(path,
395 DIAGNOSTICS_JSON_BOOKMARKS_TEST,
396 2 * kOneMegabyte,
397 JSONTest::NON_CRITICAL);
398 }
399
MakeLocalStateTest()400 DiagnosticsTest* MakeLocalStateTest() {
401 base::FilePath path;
402 PathService::Get(chrome::DIR_USER_DATA, &path);
403 path = path.Append(chrome::kLocalStateFilename);
404 return new JSONTest(path,
405 DIAGNOSTICS_JSON_LOCAL_STATE_TEST,
406 50 * kOneKilobyte,
407 JSONTest::CRITICAL);
408 }
409
MakePreferencesTest()410 DiagnosticsTest* MakePreferencesTest() {
411 base::FilePath path = DiagnosticsTest::GetUserDefaultProfileDir();
412 path = path.Append(chrome::kPreferencesFilename);
413 return new JSONTest(path,
414 DIAGNOSTICS_JSON_PREFERENCES_TEST,
415 100 * kOneKilobyte,
416 JSONTest::CRITICAL);
417 }
418
419
MakeOperatingSystemTest()420 DiagnosticsTest* MakeOperatingSystemTest() { return new OperatingSystemTest(); }
421
MakeDictonaryDirTest()422 DiagnosticsTest* MakeDictonaryDirTest() {
423 return new PathTest(kPathsToTest[0]);
424 }
425
MakeLocalStateFileTest()426 DiagnosticsTest* MakeLocalStateFileTest() {
427 return new PathTest(kPathsToTest[1]);
428 }
429
MakeResourcesFileTest()430 DiagnosticsTest* MakeResourcesFileTest() {
431 return new PathTest(kPathsToTest[2]);
432 }
433
MakeUserDirTest()434 DiagnosticsTest* MakeUserDirTest() { return new PathTest(kPathsToTest[3]); }
435
MakeVersionTest()436 DiagnosticsTest* MakeVersionTest() { return new VersionTest(); }
437
438 } // namespace diagnostics
439