| // Copyright (c) 2013 The Chromium 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 "components/net_log/net_log_file_writer.h" |
| |
| #include <utility> |
| |
| #include "base/files/file_path.h" |
| #include "base/files/file_util.h" |
| #include "base/files/scoped_file.h" |
| #include "base/values.h" |
| #include "build/build_config.h" |
| #include "components/net_log/chrome_net_log.h" |
| #include "net/log/write_to_file_net_log_observer.h" |
| |
| namespace net_log { |
| |
| // Path of logs if relative to default temporary directory of |
| // base::GetTempDir(). Must be kept in sync with |
| // chrome/android/java/res/xml/file_paths.xml. Only used if |
| // not saving log file to a custom path. |
| base::FilePath::CharType kLogRelativePath[] = |
| FILE_PATH_LITERAL("net-export/chrome-net-export-log.json"); |
| |
| // Old path used by net-export. Used to delete old files. |
| // TODO(mmenke): Should remove at some point. Added in M46. |
| base::FilePath::CharType kOldLogRelativePath[] = |
| FILE_PATH_LITERAL("chrome-net-export-log.json"); |
| |
| NetLogFileWriter::~NetLogFileWriter() { |
| if (write_to_file_observer_) |
| write_to_file_observer_->StopObserving(nullptr); |
| } |
| |
| void NetLogFileWriter::ProcessCommand(Command command) { |
| DCHECK(thread_checker_.CalledOnValidThread()); |
| if (!EnsureInit()) |
| return; |
| |
| switch (command) { |
| case DO_START_LOG_BYTES: |
| StartNetLog(LOG_TYPE_LOG_BYTES); |
| break; |
| case DO_START: |
| StartNetLog(LOG_TYPE_NORMAL); |
| break; |
| case DO_START_STRIP_PRIVATE_DATA: |
| StartNetLog(LOG_TYPE_STRIP_PRIVATE_DATA); |
| break; |
| case DO_STOP: |
| StopNetLog(); |
| break; |
| default: |
| NOTREACHED(); |
| break; |
| } |
| } |
| |
| bool NetLogFileWriter::GetFilePath(base::FilePath* path) { |
| DCHECK(thread_checker_.CalledOnValidThread()); |
| if (log_type_ == LOG_TYPE_NONE || state_ == STATE_LOGGING) |
| return false; |
| |
| if (!NetExportLogExists()) |
| return false; |
| |
| DCHECK(!log_path_.empty()); |
| #if defined(OS_POSIX) |
| // Users, group and others can read, write and traverse. |
| int mode = base::FILE_PERMISSION_MASK; |
| base::SetPosixFilePermissions(log_path_, mode); |
| #endif // defined(OS_POSIX) |
| |
| *path = log_path_; |
| return true; |
| } |
| |
| base::DictionaryValue* NetLogFileWriter::GetState() { |
| DCHECK(thread_checker_.CalledOnValidThread()); |
| base::DictionaryValue* dict = new base::DictionaryValue; |
| |
| EnsureInit(); |
| |
| #ifndef NDEBUG |
| dict->SetString("file", log_path_.LossyDisplayName()); |
| #endif // NDEBUG |
| |
| switch (state_) { |
| case STATE_NOT_LOGGING: |
| dict->SetString("state", "NOT_LOGGING"); |
| break; |
| case STATE_LOGGING: |
| dict->SetString("state", "LOGGING"); |
| break; |
| case STATE_UNINITIALIZED: |
| dict->SetString("state", "UNINITIALIZED"); |
| break; |
| } |
| |
| switch (log_type_) { |
| case LOG_TYPE_NONE: |
| dict->SetString("logType", "NONE"); |
| break; |
| case LOG_TYPE_UNKNOWN: |
| dict->SetString("logType", "UNKNOWN"); |
| break; |
| case LOG_TYPE_LOG_BYTES: |
| dict->SetString("logType", "LOG_BYTES"); |
| break; |
| case LOG_TYPE_NORMAL: |
| dict->SetString("logType", "NORMAL"); |
| break; |
| case LOG_TYPE_STRIP_PRIVATE_DATA: |
| dict->SetString("logType", "STRIP_PRIVATE_DATA"); |
| break; |
| } |
| |
| return dict; |
| } |
| |
| NetLogFileWriter::NetLogFileWriter( |
| ChromeNetLog* chrome_net_log, |
| const base::CommandLine::StringType& command_line_string, |
| const std::string& channel_string) |
| : state_(STATE_UNINITIALIZED), |
| log_type_(LOG_TYPE_NONE), |
| chrome_net_log_(chrome_net_log), |
| command_line_string_(command_line_string), |
| channel_string_(channel_string) { |
| // NetLogFileWriter can be created on one thread and used on another. |
| thread_checker_.DetachFromThread(); |
| } |
| |
| bool NetLogFileWriter::GetNetExportLogBaseDirectory( |
| base::FilePath* path) const { |
| DCHECK(thread_checker_.CalledOnValidThread()); |
| return base::GetTempDir(path); |
| } |
| |
| net::NetLogCaptureMode NetLogFileWriter::GetCaptureModeForLogType( |
| LogType log_type) { |
| switch (log_type) { |
| case LOG_TYPE_LOG_BYTES: |
| return net::NetLogCaptureMode::IncludeSocketBytes(); |
| case LOG_TYPE_NORMAL: |
| return net::NetLogCaptureMode::IncludeCookiesAndCredentials(); |
| case LOG_TYPE_STRIP_PRIVATE_DATA: |
| return net::NetLogCaptureMode::Default(); |
| case LOG_TYPE_NONE: |
| case LOG_TYPE_UNKNOWN: |
| NOTREACHED(); |
| } |
| return net::NetLogCaptureMode::Default(); |
| } |
| |
| bool NetLogFileWriter::EnsureInit() { |
| DCHECK(thread_checker_.CalledOnValidThread()); |
| if (state_ != STATE_UNINITIALIZED) |
| return true; |
| |
| if (log_path_.empty() && !SetUpDefaultNetExportLogPath()) |
| return false; |
| |
| state_ = STATE_NOT_LOGGING; |
| if (NetExportLogExists()) |
| log_type_ = LOG_TYPE_UNKNOWN; |
| else |
| log_type_ = LOG_TYPE_NONE; |
| |
| return true; |
| } |
| |
| void NetLogFileWriter::StartNetLog(LogType log_type) { |
| DCHECK(thread_checker_.CalledOnValidThread()); |
| if (state_ == STATE_LOGGING) |
| return; |
| |
| DCHECK_NE(STATE_UNINITIALIZED, state_); |
| DCHECK(!log_path_.empty()); |
| |
| // Try to make sure we can create the file. |
| // TODO(rtenneti): Find a better for doing the following. Surface some error |
| // to the user if we couldn't create the file. |
| base::ScopedFILE file(base::OpenFile(log_path_, "w")); |
| if (!file) |
| return; |
| |
| log_type_ = log_type; |
| state_ = STATE_LOGGING; |
| |
| std::unique_ptr<base::Value> constants( |
| ChromeNetLog::GetConstants(command_line_string_, channel_string_)); |
| write_to_file_observer_.reset(new net::WriteToFileNetLogObserver()); |
| write_to_file_observer_->set_capture_mode(GetCaptureModeForLogType(log_type)); |
| write_to_file_observer_->StartObserving(chrome_net_log_, std::move(file), |
| constants.get(), nullptr); |
| } |
| |
| void NetLogFileWriter::StopNetLog() { |
| DCHECK(thread_checker_.CalledOnValidThread()); |
| if (state_ != STATE_LOGGING) |
| return; |
| |
| write_to_file_observer_->StopObserving(nullptr); |
| write_to_file_observer_.reset(); |
| state_ = STATE_NOT_LOGGING; |
| } |
| |
| void NetLogFileWriter::SetUpNetExportLogPath( |
| const base::FilePath& custom_path) { |
| DCHECK(thread_checker_.CalledOnValidThread()); |
| |
| // The directory should always exist because the custom path |
| // is taken from a file selector dialog window. |
| DCHECK(base::PathExists(custom_path.DirName())); |
| |
| log_path_ = custom_path; |
| } |
| |
| bool NetLogFileWriter::SetUpDefaultNetExportLogPath() { |
| DCHECK(thread_checker_.CalledOnValidThread()); |
| base::FilePath temp_dir; |
| if (!GetNetExportLogBaseDirectory(&temp_dir)) |
| return false; |
| |
| // Delete log file at old location, if present. |
| DeleteFile(temp_dir.Append(kOldLogRelativePath), false); |
| |
| base::FilePath log_path = temp_dir.Append(kLogRelativePath); |
| |
| if (!base::CreateDirectoryAndGetError(log_path.DirName(), nullptr)) { |
| return false; |
| } |
| |
| log_path_ = log_path; |
| return true; |
| } |
| |
| bool NetLogFileWriter::NetExportLogExists() const { |
| DCHECK(thread_checker_.CalledOnValidThread()); |
| DCHECK(!log_path_.empty()); |
| return base::PathExists(log_path_); |
| } |
| |
| } // namespace net_log |