| // Copyright (c) 2011 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 <stdio.h> |
| #include <iostream> |
| #include <string> |
| |
| #include <base/command_line.h> |
| #include <base/file_util.h> |
| #include <chromeos/syslog_logging.h> |
| |
| #include "entd/entd.h" |
| #include "entd/extensions.h" |
| #include "entd/callback_server.h" |
| #include "entd/http.h" |
| #include "entd/tpm.h" |
| #include "entd/utils.h" |
| |
| namespace switches { |
| // Path to search for extensions; can contain ~ or env variables (e.g. ${HOME}) |
| static const char kExtensionPath[] = "extension-path"; |
| |
| // User Name |
| static const char kUsername[] = "username"; |
| |
| // Policy files |
| static const char kManifest[] = "manifest"; |
| static const char kPolicy[] = "policy"; |
| static const char kUtility[] = "utility"; |
| |
| // Root CA for HTTPS requests. |
| static const char kRootCAFile[] = "root-ca-file"; |
| |
| // If specified, then self-signed server certs are ok for HTTPS |
| static const char kAllowSelfSigned[] = "allow-self-signed"; |
| |
| // If specified, then file operations are allowed (e.g. for testing) |
| static const char kAllowFileIO[] = "allow-file-io"; |
| |
| // If specified, don't watch for signals. This allows the process to exit |
| // automatically when all events have been processed. See the comment in |
| // entd.h for a little more info. |
| static const char kAllowDirtyExit[] = "allow-dirty-exit"; |
| |
| // Syslogging is enabled by default if stdout is not a tty. These flags can |
| // be used to override the default logic. |
| static const char kEnableSyslog[] = "enable-syslog"; |
| static const char kDisableSyslog[] = "disable-syslog"; |
| |
| static const char kLibcrosLocation[] = "libcros-location"; |
| |
| static const char kCallbackOrigin[] = "callback-origin"; |
| |
| static const char kSessionId[] = "session-id"; |
| |
| static const char kSetLsbRelease[] = "lsb-release"; |
| |
| } // namespace switches |
| |
| // Return values: |
| // 0: Entd completed successfully and should not be restarted. |
| // 1: Entd encountered a failure, but will probably fail again if restarted, |
| // so please don't. |
| // 2: Entd has NOT encountered a failure, but would like to be restarted. |
| // >2: Entd has encountered a failure, restarting may help. |
| // |
| // So, exit with a zero or one means leave it down, otherwise restart. |
| // |
| int main(int argc, char** argv) { |
| std::string manifest, policy, utility; |
| |
| CommandLine::Init(argc, argv); |
| CommandLine* cl = CommandLine::ForCurrentProcess(); |
| int log_flags = chromeos::kLogToStderr; |
| |
| if (cl->HasSwitch(switches::kEnableSyslog) || |
| (!isatty(STDOUT_FILENO) && !cl->HasSwitch(switches::kDisableSyslog))) { |
| // If syslog was explicitly enabled, or stdout is not a tty and syslog |
| // was not explicitly disabled, then send all LOG(...) messages to syslog. |
| log_flags |= chromeos::kLogToSyslog; |
| } |
| |
| chromeos::InitLog(log_flags); |
| |
| LOG(INFO) << "Starting entd"; |
| |
| std::string base_extension_path = |
| cl->GetSwitchValueASCII(switches::kExtensionPath); |
| std::string username = cl->GetSwitchValueASCII(switches::kUsername); |
| std::string root_ca_file = cl->GetSwitchValueASCII(switches::kRootCAFile); |
| |
| // Get file paths from a valid policy extension if it exists |
| std::string extension_path; |
| bool valid_policy = false; |
| if (!base_extension_path.empty()) { |
| valid_policy = entd::extensions::FindValidPolicy(base_extension_path, |
| &extension_path); |
| } |
| |
| if (valid_policy) { |
| FilePath path = FilePath(extension_path).Append("policy.js"); |
| if (file_util::PathExists(path)) |
| policy = path.value(); |
| |
| path = FilePath(extension_path).Append("manifest.json"); |
| if (file_util::PathExists(path)) |
| manifest = path.value(); |
| |
| path = FilePath(extension_path).Append("root-ca.pem"); |
| if (file_util::PathExists(path)) { |
| root_ca_file = path.value(); |
| } else { |
| // Backwards compatibility for old filename with underscore. |
| path = FilePath(extension_path).Append("root_ca.pem"); |
| if (file_util::PathExists(path)) |
| root_ca_file = path.value(); |
| } |
| } |
| |
| // Command line switches for policy files override extension filepaths |
| if (cl->HasSwitch(switches::kPolicy)) |
| policy = cl->GetSwitchValueASCII(switches::kPolicy); |
| if (cl->HasSwitch(switches::kManifest)) |
| manifest = cl->GetSwitchValueASCII(switches::kManifest); |
| if (cl->HasSwitch(switches::kUtility)) |
| utility = cl->GetSwitchValueASCII(switches::kUtility); |
| |
| if (cl->HasSwitch(switches::kAllowSelfSigned)) { |
| LOG(INFO) << "Allowing self-signed certs."; |
| entd::Http::allow_self_signed_certs = true; |
| } |
| |
| if (cl->HasSwitch(switches::kLibcrosLocation)) { |
| entd::Entd::libcros_location = cl->GetSwitchValueASCII( |
| switches::kLibcrosLocation); |
| LOG(INFO) << "Setting libcros location: " << entd::Entd::libcros_location; |
| } |
| |
| if (cl->HasSwitch(switches::kAllowFileIO)) { |
| LOG(INFO) << "Allowing File IO."; |
| entd::Entd::allow_file_io = true; |
| } |
| |
| if (!root_ca_file.empty()) { |
| LOG(INFO) << "Setting root CA file: " << root_ca_file; |
| entd::Http::root_ca_file = root_ca_file; |
| } |
| |
| if (cl->HasSwitch(switches::kAllowDirtyExit)) { |
| LOG(INFO) << "Allowing dirty exits."; |
| entd::Entd::allow_dirty_exit = true; |
| } |
| |
| if (cl->HasSwitch(switches::kCallbackOrigin)) { |
| entd::CallbackServer::required_origin = cl->GetSwitchValueASCII( |
| switches::kCallbackOrigin); |
| LOG(INFO) << "Setting callback origin: " << |
| entd::CallbackServer::required_origin; |
| } |
| |
| if (cl->HasSwitch(switches::kSessionId)) { |
| entd::CallbackServer::set_session_id(cl->GetSwitchValueASCII( |
| switches::kSessionId)); |
| LOG(INFO) << "Setting session id: " << |
| entd::CallbackServer::session_id(); |
| } |
| |
| entd::Entd d; |
| d.Initialize(); |
| |
| if (!username.empty()) |
| d.SetUsername(username); |
| |
| if (!utility.empty()) |
| d.SetUtilityFile(utility); |
| |
| if (!manifest.empty()) |
| d.SetManifestFile(manifest); |
| |
| if (!policy.empty()) |
| d.SetPolicyFile(policy); |
| |
| if (cl->HasSwitch(switches::kSetLsbRelease)) |
| d.SetLsbRelease(cl->GetSwitchValueASCII(switches::kSetLsbRelease)); |
| |
| uint32_t rv = d.Run(); |
| LOG(INFO) << "Exiting entd with code: " << rv; |
| return rv; |
| } |