src/remoting/host/remoting_me2me_host.cc

   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 // This file implements a standalone host process for Me2Me.
   6
   7 #include <string>
   8
   9 #include "base/at_exit.h"
  10 #include "base/bind.h"
  11 #include "base/callback.h"
  12 #include "base/command_line.h"
  13 #include "base/debug/alias.h"
  14 #include "base/files/file_path.h"
  15 #include "base/files/file_util.h"
  16 #include "base/memory/scoped_ptr.h"
  17 #include "base/message_loop/message_loop.h"
  18 #include "base/single_thread_task_runner.h"
  19 #include "base/strings/string_number_conversions.h"
  20 #include "base/strings/string_util.h"
  21 #include "base/strings/utf_string_conversions.h"
  22 #include "base/synchronization/waitable_event.h"
  23 #include "base/threading/thread.h"
  24 #include "build/build_config.h"
  25 #include "crypto/nss_util.h"
  26 #include "ipc/ipc_channel.h"
  27 #include "ipc/ipc_channel_proxy.h"
  28 #include "ipc/ipc_listener.h"
  29 #include "media/base/media.h"
  30 #include "net/base/network_change_notifier.h"
  31 #include "net/socket/client_socket_factory.h"
  32 #include "net/socket/ssl_server_socket.h"
  33 #include "net/url_request/url_fetcher.h"
  34 #include "remoting/base/auto_thread_task_runner.h"
  35 #include "remoting/base/breakpad.h"
  36 #include "remoting/base/constants.h"
  37 #include "remoting/base/logging.h"
  38 #include "remoting/base/rsa_key_pair.h"
  39 #include "remoting/base/service_urls.h"
  40 #include "remoting/base/util.h"
  41 #include "remoting/host/branding.h"
  42 #include "remoting/host/chromoting_host.h"
  43 #include "remoting/host/chromoting_host_context.h"
  44 #include "remoting/host/chromoting_messages.h"
  45 #include "remoting/host/config_file_watcher.h"
  46 #include "remoting/host/config_watcher.h"
  47 #include "remoting/host/desktop_environment.h"
  48 #include "remoting/host/desktop_session_connector.h"
  49 #include "remoting/host/dns_blackhole_checker.h"
  50 #include "remoting/host/heartbeat_sender.h"
  51 #include "remoting/host/host_change_notification_listener.h"
  52 #include "remoting/host/host_config.h"
  53 #include "remoting/host/host_event_logger.h"
  54 #include "remoting/host/host_exit_codes.h"
  55 #include "remoting/host/host_main.h"
  56 #include "remoting/host/host_status_logger.h"
  57 #include "remoting/host/host_status_sender.h"
  58 #include "remoting/host/ipc_constants.h"
  59 #include "remoting/host/ipc_desktop_environment.h"
  60 #include "remoting/host/ipc_host_event_logger.h"
  61 #include "remoting/host/json_host_config.h"
  62 #include "remoting/host/logging.h"
  63 #include "remoting/host/me2me_desktop_environment.h"
  64 #include "remoting/host/pairing_registry_delegate.h"
  65 #include "remoting/host/policy_hack/policy_watcher.h"
  66 #include "remoting/host/session_manager_factory.h"
  67 #include "remoting/host/signaling_connector.h"
  68 #include "remoting/host/single_window_desktop_environment.h"
  69 #include "remoting/host/token_validator_factory_impl.h"
  70 #include "remoting/host/usage_stats_consent.h"
  71 #include "remoting/host/username.h"
  72 #include "remoting/host/video_frame_recorder_host_extension.h"
  73 #include "remoting/protocol/me2me_host_authenticator_factory.h"
  74 #include "remoting/protocol/network_settings.h"
  75 #include "remoting/protocol/pairing_registry.h"
  76 #include "remoting/protocol/token_validator.h"
  77 #include "remoting/signaling/xmpp_signal_strategy.h"
  78
  79 #if defined(OS_POSIX)
  80 #include <signal.h>
  81 #include <sys/types.h>
  82 #include <unistd.h>
  83 #include "base/file_descriptor_posix.h"
  84 #include "remoting/host/pam_authorization_factory_posix.h"
  85 #include "remoting/host/posix/signal_handler.h"
  86 #endif  // defined(OS_POSIX)
  87
  88 #if defined(OS_MACOSX)
  89 #include "base/mac/scoped_cftyperef.h"
  90 #endif  // defined(OS_MACOSX)
  91
  92 #if defined(OS_LINUX)
  93 #include <gtk/gtk.h>
  94 #include <X11/Xlib.h>
  95 #include "remoting/host/audio_capturer_linux.h"
  96 #endif  // defined(OS_LINUX)
  97
  98 #if defined(OS_WIN)
  99 #include <commctrl.h>
 100 #include "base/win/registry.h"
 101 #include "base/win/scoped_handle.h"
 102 #include "remoting/host/pairing_registry_delegate_win.h"
 103 #include "remoting/host/win/session_desktop_environment.h"
 104 #endif  // defined(OS_WIN)
 105
 106 using remoting::protocol::PairingRegistry;
 107 using remoting::protocol::NetworkSettings;
 108
 109 namespace {
 110
 111 // This is used for tagging system event logs.
 112 const char kApplicationName[] = "chromoting";
 113
 114 #if defined(OS_LINUX)
 115 // The command line switch used to pass name of the pipe to capture audio on
 116 // linux.
 117 const char kAudioPipeSwitchName[] = "audio-pipe-name";
 118
 119 // The command line switch used to pass name of the unix domain socket used to
 120 // listen for gnubby requests.
 121 const char kAuthSocknameSwitchName[] = "ssh-auth-sockname";
 122 #endif  // defined(OS_LINUX)
 123
 124 // The command line switch used by the parent to request the host to signal it
 125 // when it is successfully started.
 126 const char kSignalParentSwitchName[] = "signal-parent";
 127
 128 // Command line switch used to enable VP9 encoding.
 129 const char kEnableVp9SwitchName[] = "enable-vp9";
 130
 131 // Command line switch used to enable and configure the frame-recorder.
 132 const char kFrameRecorderBufferKbName[] = "frame-recorder-buffer-kb";
 133
 134 // Value used for --host-config option to indicate that the path must be read
 135 // from stdin.
 136 const char kStdinConfigPath[] = "-";
 137
 138 const char kWindowIdSwitchName[] = "window-id";
 139
 140 }  // namespace
 141
 142 namespace remoting {
 143
 144 class HostProcess
 145     : public ConfigWatcher::Delegate,
 146       public HeartbeatSender::Listener,
 147       public HostChangeNotificationListener::Listener,
 148       public IPC::Listener,
 149       public base::RefCountedThreadSafe<HostProcess> {
 150  public:
 151   HostProcess(scoped_ptr<ChromotingHostContext> context,
 152               int* exit_code_out);
 153
 154   // ConfigWatcher::Delegate interface.
 155   virtual void OnConfigUpdated(const std::string& serialized_config) OVERRIDE;
 156   virtual void OnConfigWatcherError() OVERRIDE;
 157
 158   // IPC::Listener implementation.
 159   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
 160   virtual void OnChannelError() OVERRIDE;
 161
 162   // HeartbeatSender::Listener overrides.
 163   virtual void OnHeartbeatSuccessful() OVERRIDE;
 164   virtual void OnUnknownHostIdError() OVERRIDE;
 165
 166   // HostChangeNotificationListener::Listener overrides.
 167   virtual void OnHostDeleted() OVERRIDE;
 168
 169   // Initializes the pairing registry on Windows.
 170   void OnInitializePairingRegistry(
 171       IPC::PlatformFileForTransit privileged_key,
 172       IPC::PlatformFileForTransit unprivileged_key);
 173
 174  private:
 175   enum HostState {
 176     // Host process has just been started. Waiting for config and policies to be
 177     // read from the disk.
 178     HOST_INITIALIZING,
 179
 180     // Host is started and running.
 181     HOST_STARTED,
 182
 183     // Host is being stopped and will need to be started again.
 184     HOST_STOPPING_TO_RESTART,
 185
 186     // Host is being stopped.
 187     HOST_STOPPING,
 188
 189     // Host has been stopped.
 190     HOST_STOPPED,
 191
 192     // Allowed state transitions:
 193     //   INITIALIZING->STARTED
 194     //   INITIALIZING->STOPPED
 195     //   STARTED->STOPPING_TO_RESTART
 196     //   STARTED->STOPPING
 197     //   STOPPING_TO_RESTART->STARTED
 198     //   STOPPING_TO_RESTART->STOPPING
 199     //   STOPPING->STOPPED
 200     //   STOPPED->STARTED
 201     //
 202     // |host_| must be NULL in INITIALIZING and STOPPED states and not-NULL in
 203     // all other states.
 204   };
 205
 206   friend class base::RefCountedThreadSafe<HostProcess>;
 207   virtual ~HostProcess();
 208
 209   void StartOnNetworkThread();
 210
 211 #if defined(OS_POSIX)
 212   // Callback passed to RegisterSignalHandler() to handle SIGTERM events.
 213   void SigTermHandler(int signal_number);
 214 #endif
 215
 216   // Called to initialize resources on the UI thread.
 217   void StartOnUiThread();
 218
 219   // Initializes IPC control channel and config file path from |cmd_line|.
 220   // Called on the UI thread.
 221   bool InitWithCommandLine(const base::CommandLine* cmd_line);
 222
 223   // Called on the UI thread to start monitoring the configuration file.
 224   void StartWatchingConfigChanges();
 225
 226   // Called on the network thread to set the host's Authenticator factory.
 227   void CreateAuthenticatorFactory();
 228
 229   // Tear down resources that run on the UI thread.
 230   void ShutdownOnUiThread();
 231
 232   // Applies the host config, returning true if successful.
 233   bool ApplyConfig(scoped_ptr<JsonHostConfig> config);
 234
 235   // Handles policy updates, by calling On*PolicyUpdate methods.
 236   void OnPolicyUpdate(scoped_ptr<base::DictionaryValue> policies);
 237   void ApplyHostDomainPolicy();
 238   void ApplyUsernamePolicy();
 239   bool OnHostDomainPolicyUpdate(base::DictionaryValue* policies);
 240   bool OnUsernamePolicyUpdate(base::DictionaryValue* policies);
 241   bool OnNatPolicyUpdate(base::DictionaryValue* policies);
 242   bool OnRelayPolicyUpdate(base::DictionaryValue* policies);
 243   bool OnUdpPortPolicyUpdate(base::DictionaryValue* policies);
 244   bool OnCurtainPolicyUpdate(base::DictionaryValue* policies);
 245   bool OnHostTalkGadgetPrefixPolicyUpdate(base::DictionaryValue* policies);
 246   bool OnHostTokenUrlPolicyUpdate(base::DictionaryValue* policies);
 247   bool OnPairingPolicyUpdate(base::DictionaryValue* policies);
 248   bool OnGnubbyAuthPolicyUpdate(base::DictionaryValue* policies);
 249
 250   void StartHost();
 251
 252   void OnAuthFailed();
 253
 254   void RestartHost();
 255
 256   // Stops the host and shuts down the process with the specified |exit_code|.
 257   void ShutdownHost(HostExitCodes exit_code);
 258
 259   void ScheduleHostShutdown();
 260
 261   void ShutdownOnNetworkThread();
 262
 263   // Crashes the process in response to a daemon's request. The daemon passes
 264   // the location of the code that detected the fatal error resulted in this
 265   // request.
 266   void OnCrash(const std::string& function_name,
 267                const std::string& file_name,
 268                const int& line_number);
 269
 270   scoped_ptr<ChromotingHostContext> context_;
 271
 272   // Created on the UI thread but used from the network thread.
 273   scoped_ptr<net::NetworkChangeNotifier> network_change_notifier_;
 274
 275   // Accessed on the UI thread.
 276   scoped_ptr<IPC::ChannelProxy> daemon_channel_;
 277
 278   // XMPP server/remoting bot configuration (initialized from the command line).
 279   XmppSignalStrategy::XmppServerConfig xmpp_server_config_;
 280   std::string directory_bot_jid_;
 281
 282   // Created on the UI thread but used from the network thread.
 283   base::FilePath host_config_path_;
 284   std::string host_config_;
 285   scoped_ptr<DesktopEnvironmentFactory> desktop_environment_factory_;
 286
 287   // Accessed on the network thread.
 288   HostState state_;
 289
 290   scoped_ptr<ConfigWatcher> config_watcher_;
 291
 292   std::string host_id_;
 293   protocol::SharedSecretHash host_secret_hash_;
 294   scoped_refptr<RsaKeyPair> key_pair_;
 295   std::string oauth_refresh_token_;
 296   std::string serialized_config_;
 297   std::string host_owner_;
 298   std::string host_owner_email_;
 299   bool use_service_account_;
 300   bool enable_vp9_;
 301   int64_t frame_recorder_buffer_size_;
 302
 303   scoped_ptr<policy_hack::PolicyWatcher> policy_watcher_;
 304   std::string host_domain_;
 305   bool host_username_match_required_;
 306   bool allow_nat_traversal_;
 307   bool allow_relay_;
 308   int min_udp_port_;
 309   int max_udp_port_;
 310   std::string talkgadget_prefix_;
 311   bool allow_pairing_;
 312
 313   bool curtain_required_;
 314   ThirdPartyAuthConfig third_party_auth_config_;
 315   bool enable_gnubby_auth_;
 316
 317   // Boolean to change flow, where ncessary, if we're
 318   // capturing a window instead of the entire desktop.
 319   bool enable_window_capture_;
 320
 321   // Used to specify which window to stream, if enabled.
 322   webrtc::WindowId window_id_;
 323
 324   scoped_ptr<OAuthTokenGetter> oauth_token_getter_;
 325   scoped_ptr<XmppSignalStrategy> signal_strategy_;
 326   scoped_ptr<SignalingConnector> signaling_connector_;
 327   scoped_ptr<HeartbeatSender> heartbeat_sender_;
 328   scoped_ptr<HostStatusSender> host_status_sender_;
 329   scoped_ptr<HostChangeNotificationListener> host_change_notification_listener_;
 330   scoped_ptr<HostStatusLogger> host_status_logger_;
 331   scoped_ptr<HostEventLogger> host_event_logger_;
 332
 333   scoped_ptr<ChromotingHost> host_;
 334
 335   // Used to keep this HostProcess alive until it is shutdown.
 336   scoped_refptr<HostProcess> self_;
 337
 338 #if defined(REMOTING_MULTI_PROCESS)
 339   DesktopSessionConnector* desktop_session_connector_;
 340 #endif  // defined(REMOTING_MULTI_PROCESS)
 341
 342   int* exit_code_out_;
 343   bool signal_parent_;
 344
 345   scoped_ptr<PairingRegistry::Delegate> pairing_registry_delegate_;
 346 };
 347
 348 HostProcess::HostProcess(scoped_ptr<ChromotingHostContext> context,
 349                          int* exit_code_out)
 350     : context_(context.Pass()),
 351       state_(HOST_INITIALIZING),
 352       use_service_account_(false),
 353       enable_vp9_(false),
 354       frame_recorder_buffer_size_(0),
 355       host_username_match_required_(false),
 356       allow_nat_traversal_(true),
 357       allow_relay_(true),
 358       min_udp_port_(0),
 359       max_udp_port_(0),
 360       allow_pairing_(true),
 361       curtain_required_(false),
 362       enable_gnubby_auth_(false),
 363       enable_window_capture_(false),
 364       window_id_(0),
 365 #if defined(REMOTING_MULTI_PROCESS)
 366       desktop_session_connector_(NULL),
 367 #endif  // defined(REMOTING_MULTI_PROCESS)
 368       self_(this),
 369       exit_code_out_(exit_code_out),
 370       signal_parent_(false) {
 371   StartOnUiThread();
 372 }
 373
 374 HostProcess::~HostProcess() {
 375   // Verify that UI components have been torn down.
 376   DCHECK(!config_watcher_);
 377   DCHECK(!daemon_channel_);
 378   DCHECK(!desktop_environment_factory_);
 379
 380   // We might be getting deleted on one of the threads the |host_context| owns,
 381   // so we need to post it back to the caller thread to safely join & delete the
 382   // threads it contains.  This will go away when we move to AutoThread.
 383   // |context_release()| will null |context_| before the method is invoked, so
 384   // we need to pull out the task-runner on which to call DeleteSoon first.
 385   scoped_refptr<base::SingleThreadTaskRunner> task_runner =
 386       context_->ui_task_runner();
 387   task_runner->DeleteSoon(FROM_HERE, context_.release());
 388 }
 389
 390 bool HostProcess::InitWithCommandLine(const base::CommandLine* cmd_line) {
 391 #if defined(REMOTING_MULTI_PROCESS)
 392   // Parse the handle value and convert it to a handle/file descriptor.
 393   std::string channel_name =
 394       cmd_line->GetSwitchValueASCII(kDaemonPipeSwitchName);
 395
 396   int pipe_handle = 0;
 397   if (channel_name.empty() ||
 398       !base::StringToInt(channel_name, &pipe_handle)) {
 399     LOG(ERROR) << "Invalid '" << kDaemonPipeSwitchName
 400                << "' value: " << channel_name;
 401     return false;
 402   }
 403
 404 #if defined(OS_WIN)
 405   base::win::ScopedHandle pipe(reinterpret_cast<HANDLE>(pipe_handle));
 406   IPC::ChannelHandle channel_handle(pipe.Get());
 407 #elif defined(OS_POSIX)
 408   base::FileDescriptor pipe(pipe_handle, true);
 409   IPC::ChannelHandle channel_handle(channel_name, pipe);
 410 #endif  // defined(OS_POSIX)
 411
 412   // Connect to the daemon process.
 413   daemon_channel_ = IPC::ChannelProxy::Create(channel_handle,
 414                                               IPC::Channel::MODE_CLIENT,
 415                                               this,
 416                                               context_->network_task_runner());
 417 #else  // !defined(REMOTING_MULTI_PROCESS)
 418   // Connect to the daemon process.
 419   std::string channel_name =
 420       cmd_line->GetSwitchValueASCII(kDaemonPipeSwitchName);
 421   if (!channel_name.empty()) {
 422     daemon_channel_ =
 423         IPC::ChannelProxy::Create(channel_name,
 424                                   IPC::Channel::MODE_CLIENT,
 425                                   this,
 426                                   context_->network_task_runner().get());
 427   }
 428
 429   if (cmd_line->HasSwitch(kHostConfigSwitchName)) {
 430     host_config_path_ = cmd_line->GetSwitchValuePath(kHostConfigSwitchName);
 431
 432     // Read config from stdin if necessary.
 433     if (host_config_path_ == base::FilePath(kStdinConfigPath)) {
 434       char buf[4096];
 435       size_t len;
 436       while ((len = fread(buf, 1, sizeof(buf), stdin)) > 0) {
 437         host_config_.append(buf, len);
 438       }
 439     }
 440   } else {
 441     base::FilePath default_config_dir = remoting::GetConfigDir();
 442     host_config_path_ = default_config_dir.Append(kDefaultHostConfigFile);
 443   }
 444
 445   if (host_config_path_ != base::FilePath(kStdinConfigPath) &&
 446       !base::PathExists(host_config_path_)) {
 447     LOG(ERROR) << "Can't find host config at " << host_config_path_.value();
 448     return false;
 449   }
 450 #endif  // !defined(REMOTING_MULTI_PROCESS)
 451
 452   // Ignore certificate requests - the host currently has no client certificate
 453   // support, so ignoring certificate requests allows connecting to servers that
 454   // request, but don't require, a certificate (optional client authentication).
 455   net::URLFetcher::SetIgnoreCertificateRequests(true);
 456
 457   ServiceUrls* service_urls = ServiceUrls::GetInstance();
 458   bool xmpp_server_valid = net::ParseHostAndPort(
 459       service_urls->xmpp_server_address(),
 460       &xmpp_server_config_.host, &xmpp_server_config_.port);
 461   if (!xmpp_server_valid) {
 462     LOG(ERROR) << "Invalid XMPP server: " <<
 463         service_urls->xmpp_server_address();
 464     return false;
 465   }
 466   xmpp_server_config_.use_tls = service_urls->xmpp_server_use_tls();
 467   directory_bot_jid_ = service_urls->directory_bot_jid();
 468
 469   signal_parent_ = cmd_line->HasSwitch(kSignalParentSwitchName);
 470
 471   enable_window_capture_ = cmd_line->HasSwitch(kWindowIdSwitchName);
 472   if (enable_window_capture_) {
 473
 474 #if defined(OS_LINUX) || defined(OS_WIN)
 475     LOG(WARNING) << "Window capturing is not fully supported on Linux or "
 476                     "Windows.";
 477 #endif  // defined(OS_LINUX) || defined(OS_WIN)
 478
 479     // uint32_t is large enough to hold window IDs on all platforms.
 480     uint32_t window_id;
 481     if (base::StringToUint(
 482             cmd_line->GetSwitchValueASCII(kWindowIdSwitchName),
 483             &window_id)) {
 484       window_id_ = static_cast<webrtc::WindowId>(window_id);
 485     } else {
 486       LOG(ERROR) << "Window with window id: " << window_id_
 487                  << " not found. Shutting down host.";
 488       return false;
 489     }
 490   }
 491   return true;
 492 }
 493
 494 void HostProcess::OnConfigUpdated(
 495     const std::string& serialized_config) {
 496   if (!context_->network_task_runner()->BelongsToCurrentThread()) {
 497     context_->network_task_runner()->PostTask(FROM_HERE,
 498         base::Bind(&HostProcess::OnConfigUpdated, this, serialized_config));
 499     return;
 500   }
 501
 502   // Filter out duplicates.
 503   if (serialized_config_ == serialized_config)
 504     return;
 505
 506   HOST_LOG << "Processing new host configuration.";
 507
 508   serialized_config_ = serialized_config;
 509   scoped_ptr<JsonHostConfig> config(new JsonHostConfig(base::FilePath()));
 510   if (!config->SetSerializedData(serialized_config)) {
 511     LOG(ERROR) << "Invalid configuration.";
 512     ShutdownHost(kInvalidHostConfigurationExitCode);
 513     return;
 514   }
 515
 516   if (!ApplyConfig(config.Pass())) {
 517     LOG(ERROR) << "Failed to apply the configuration.";
 518     ShutdownHost(kInvalidHostConfigurationExitCode);
 519     return;
 520   }
 521
 522   if (state_ == HOST_INITIALIZING) {
 523     // TODO(sergeyu): Currently OnPolicyUpdate() assumes that host config is
 524     // already loaded so PolicyWatcher has to be started here. Separate policy
 525     // loading from policy verifications and move |policy_watcher_|
 526     // initialization to StartOnNetworkThread().
 527     policy_watcher_.reset(
 528         policy_hack::PolicyWatcher::Create(context_->file_task_runner()));
 529     policy_watcher_->StartWatching(
 530         base::Bind(&HostProcess::OnPolicyUpdate, base::Unretained(this)));
 531   } else {
 532     // Reapply policies that could be affected by a new config.
 533     ApplyHostDomainPolicy();
 534     ApplyUsernamePolicy();
 535
 536     if (state_ == HOST_STARTED) {
 537       // TODO(sergeyu): Here we assume that PIN is the only part of the config
 538       // that may change while the service is running. Change ApplyConfig() to
 539       // detect other changes in the config and restart host if necessary here.
 540       CreateAuthenticatorFactory();
 541     }
 542   }
 543 }
 544
 545 void HostProcess::OnConfigWatcherError() {
 546   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
 547   ShutdownHost(kInvalidHostConfigurationExitCode);
 548 }
 549
 550 void HostProcess::StartOnNetworkThread() {
 551   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
 552
 553 #if !defined(REMOTING_MULTI_PROCESS)
 554   if (host_config_path_ == base::FilePath(kStdinConfigPath)) {
 555     // Process config we've read from stdin.
 556     OnConfigUpdated(host_config_);
 557   } else {
 558     // Start watching the host configuration file.
 559     config_watcher_.reset(new ConfigFileWatcher(context_->network_task_runner(),
 560                                                 context_->file_task_runner(),
 561                                                 host_config_path_));
 562     config_watcher_->Watch(this);
 563   }
 564 #endif  // !defined(REMOTING_MULTI_PROCESS)
 565
 566 #if defined(OS_POSIX)
 567   remoting::RegisterSignalHandler(
 568       SIGTERM,
 569       base::Bind(&HostProcess::SigTermHandler, base::Unretained(this)));
 570 #endif  // defined(OS_POSIX)
 571 }
 572
 573 #if defined(OS_POSIX)
 574 void HostProcess::SigTermHandler(int signal_number) {
 575   DCHECK(signal_number == SIGTERM);
 576   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
 577   HOST_LOG << "Caught SIGTERM: Shutting down...";
 578   ShutdownHost(kSuccessExitCode);
 579 }
 580 #endif  // OS_POSIX
 581
 582 void HostProcess::CreateAuthenticatorFactory() {
 583   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
 584
 585   if (state_ != HOST_STARTED)
 586     return;
 587
 588   std::string local_certificate = key_pair_->GenerateCertificate();
 589   if (local_certificate.empty()) {
 590     LOG(ERROR) << "Failed to generate host certificate.";
 591     ShutdownHost(kInitializationFailed);
 592     return;
 593   }
 594
 595   scoped_refptr<PairingRegistry> pairing_registry = NULL;
 596   if (allow_pairing_) {
 597     if (!pairing_registry_delegate_)
 598       pairing_registry_delegate_ = CreatePairingRegistryDelegate();
 599
 600     if (pairing_registry_delegate_) {
 601       pairing_registry = new PairingRegistry(context_->file_task_runner(),
 602                                              pairing_registry_delegate_.Pass());
 603     }
 604   }
 605
 606   scoped_ptr<protocol::AuthenticatorFactory> factory;
 607
 608   if (third_party_auth_config_.is_empty()) {
 609     factory = protocol::Me2MeHostAuthenticatorFactory::CreateWithSharedSecret(
 610         use_service_account_, host_owner_, local_certificate, key_pair_,
 611         host_secret_hash_, pairing_registry);
 612
 613   } else if (third_party_auth_config_.is_valid()) {
 614     scoped_ptr<protocol::TokenValidatorFactory> token_validator_factory(
 615         new TokenValidatorFactoryImpl(
 616             third_party_auth_config_,
 617             key_pair_, context_->url_request_context_getter()));
 618     factory = protocol::Me2MeHostAuthenticatorFactory::CreateWithThirdPartyAuth(
 619         use_service_account_, host_owner_, local_certificate, key_pair_,
 620         token_validator_factory.Pass());
 621
 622   } else {
 623     // TODO(rmsousa): If the policy is bad the host should not go online. It
 624     // should keep running, but not connected, until the policies are fixed.
 625     // Having it show up as online and then reject all clients is misleading.
 626     LOG(ERROR) << "One of the third-party token URLs is empty or invalid. "
 627                << "Host will reject all clients until policies are corrected. "
 628                << "TokenUrl: " << third_party_auth_config_.token_url << ", "
 629                << "TokenValidationUrl: "
 630                << third_party_auth_config_.token_validation_url;
 631     factory = protocol::Me2MeHostAuthenticatorFactory::CreateRejecting();
 632   }
 633
 634 #if defined(OS_POSIX)
 635   // On Linux and Mac, perform a PAM authorization step after authentication.
 636   factory.reset(new PamAuthorizationFactory(factory.Pass()));
 637 #endif
 638   host_->SetAuthenticatorFactory(factory.Pass());
 639
 640   host_->set_pairing_registry(pairing_registry);
 641 }
 642
 643 // IPC::Listener implementation.
 644 bool HostProcess::OnMessageReceived(const IPC::Message& message) {
 645   DCHECK(context_->ui_task_runner()->BelongsToCurrentThread());
 646
 647 #if defined(REMOTING_MULTI_PROCESS)
 648   bool handled = true;
 649   IPC_BEGIN_MESSAGE_MAP(HostProcess, message)
 650     IPC_MESSAGE_HANDLER(ChromotingDaemonMsg_Crash, OnCrash)
 651     IPC_MESSAGE_HANDLER(ChromotingDaemonNetworkMsg_Configuration,
 652                         OnConfigUpdated)
 653     IPC_MESSAGE_HANDLER(ChromotingDaemonNetworkMsg_InitializePairingRegistry,
 654                         OnInitializePairingRegistry)
 655     IPC_MESSAGE_FORWARD(
 656         ChromotingDaemonNetworkMsg_DesktopAttached,
 657         desktop_session_connector_,
 658         DesktopSessionConnector::OnDesktopSessionAgentAttached)
 659     IPC_MESSAGE_FORWARD(ChromotingDaemonNetworkMsg_TerminalDisconnected,
 660                         desktop_session_connector_,
 661                         DesktopSessionConnector::OnTerminalDisconnected)
 662     IPC_MESSAGE_UNHANDLED(handled = false)
 663   IPC_END_MESSAGE_MAP()
 664
 665   CHECK(handled) << "Received unexpected IPC type: " << message.type();
 666   return handled;
 667
 668 #else  // !defined(REMOTING_MULTI_PROCESS)
 669   return false;
 670 #endif  // !defined(REMOTING_MULTI_PROCESS)
 671 }
 672
 673 void HostProcess::OnChannelError() {
 674   DCHECK(context_->ui_task_runner()->BelongsToCurrentThread());
 675
 676   // Shutdown the host if the daemon process disconnects the IPC channel.
 677   context_->network_task_runner()->PostTask(
 678       FROM_HERE,
 679       base::Bind(&HostProcess::ShutdownHost, this, kSuccessExitCode));
 680 }
 681
 682 void HostProcess::StartOnUiThread() {
 683   DCHECK(context_->ui_task_runner()->BelongsToCurrentThread());
 684
 685   if (!InitWithCommandLine(base::CommandLine::ForCurrentProcess())) {
 686     // Shutdown the host if the command line is invalid.
 687     context_->network_task_runner()->PostTask(
 688         FROM_HERE, base::Bind(&HostProcess::ShutdownHost, this,
 689                               kUsageExitCode));
 690     return;
 691   }
 692
 693 #if defined(OS_LINUX)
 694   // If an audio pipe is specific on the command-line then initialize
 695   // AudioCapturerLinux to capture from it.
 696   base::FilePath audio_pipe_name = base::CommandLine::ForCurrentProcess()->
 697       GetSwitchValuePath(kAudioPipeSwitchName);
 698   if (!audio_pipe_name.empty()) {
 699     remoting::AudioCapturerLinux::InitializePipeReader(
 700         context_->audio_task_runner(), audio_pipe_name);
 701   }
 702
 703   base::FilePath gnubby_socket_name = base::CommandLine::ForCurrentProcess()->
 704       GetSwitchValuePath(kAuthSocknameSwitchName);
 705   if (!gnubby_socket_name.empty())
 706     remoting::GnubbyAuthHandler::SetGnubbySocketName(gnubby_socket_name);
 707 #endif  // defined(OS_LINUX)
 708
 709   // Create a desktop environment factory appropriate to the build type &
 710   // platform.
 711 #if defined(OS_WIN)
 712   IpcDesktopEnvironmentFactory* desktop_environment_factory =
 713       new IpcDesktopEnvironmentFactory(
 714           context_->audio_task_runner(),
 715           context_->network_task_runner(),
 716           context_->video_capture_task_runner(),
 717           context_->network_task_runner(),
 718           daemon_channel_.get());
 719   desktop_session_connector_ = desktop_environment_factory;
 720 #else  // !defined(OS_WIN)
 721   DesktopEnvironmentFactory* desktop_environment_factory;
 722   if (enable_window_capture_) {
 723     desktop_environment_factory =
 724       new SingleWindowDesktopEnvironmentFactory(
 725           context_->network_task_runner(),
 726           context_->input_task_runner(),
 727           context_->ui_task_runner(),
 728           window_id_);
 729   } else {
 730     desktop_environment_factory =
 731       new Me2MeDesktopEnvironmentFactory(
 732           context_->network_task_runner(),
 733           context_->input_task_runner(),
 734           context_->ui_task_runner());
 735   }
 736 #endif  // !defined(OS_WIN)
 737
 738   desktop_environment_factory_.reset(desktop_environment_factory);
 739   desktop_environment_factory_->SetEnableGnubbyAuth(enable_gnubby_auth_);
 740
 741   context_->network_task_runner()->PostTask(
 742       FROM_HERE,
 743       base::Bind(&HostProcess::StartOnNetworkThread, this));
 744 }
 745
 746 void HostProcess::ShutdownOnUiThread() {
 747   DCHECK(context_->ui_task_runner()->BelongsToCurrentThread());
 748
 749   // Tear down resources that need to be torn down on the UI thread.
 750   network_change_notifier_.reset();
 751   daemon_channel_.reset();
 752   desktop_environment_factory_.reset();
 753
 754   // It is now safe for the HostProcess to be deleted.
 755   self_ = NULL;
 756
 757 #if defined(OS_LINUX)
 758   // Cause the global AudioPipeReader to be freed, otherwise the audio
 759   // thread will remain in-use and prevent the process from exiting.
 760   // TODO(wez): DesktopEnvironmentFactory should own the pipe reader.
 761   // See crbug.com/161373 and crbug.com/104544.
 762   AudioCapturerLinux::InitializePipeReader(NULL, base::FilePath());
 763 #endif
 764 }
 765
 766 // Overridden from HeartbeatSender::Listener
 767 void HostProcess::OnUnknownHostIdError() {
 768   LOG(ERROR) << "Host ID not found.";
 769   ShutdownHost(kInvalidHostIdExitCode);
 770 }
 771
 772 void HostProcess::OnHeartbeatSuccessful() {
 773   HOST_LOG << "Host ready to receive connections.";
 774 #if defined(OS_POSIX)
 775   if (signal_parent_) {
 776     kill(getppid(), SIGUSR1);
 777     signal_parent_ = false;
 778   }
 779 #endif
 780 }
 781
 782 void HostProcess::OnHostDeleted() {
 783   LOG(ERROR) << "Host was deleted from the directory.";
 784   ShutdownHost(kInvalidHostIdExitCode);
 785 }
 786
 787 void HostProcess::OnInitializePairingRegistry(
 788     IPC::PlatformFileForTransit privileged_key,
 789     IPC::PlatformFileForTransit unprivileged_key) {
 790   DCHECK(!pairing_registry_delegate_);
 791
 792 #if defined(OS_WIN)
 793   // Initialize the pairing registry delegate.
 794   scoped_ptr<PairingRegistryDelegateWin> delegate(
 795       new PairingRegistryDelegateWin());
 796   bool result = delegate->SetRootKeys(
 797       reinterpret_cast<HKEY>(
 798           IPC::PlatformFileForTransitToPlatformFile(privileged_key)),
 799       reinterpret_cast<HKEY>(
 800           IPC::PlatformFileForTransitToPlatformFile(unprivileged_key)));
 801   if (!result)
 802     return;
 803
 804   pairing_registry_delegate_ = delegate.PassAs<PairingRegistry::Delegate>();
 805 #else  // !defined(OS_WIN)
 806   NOTREACHED();
 807 #endif  // !defined(OS_WIN)
 808 }
 809
 810 // Applies the host config, returning true if successful.
 811 bool HostProcess::ApplyConfig(scoped_ptr<JsonHostConfig> config) {
 812   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
 813
 814   if (!config->GetString(kHostIdConfigPath, &host_id_)) {
 815     LOG(ERROR) << "host_id is not defined in the config.";
 816     return false;
 817   }
 818
 819   std::string key_base64;
 820   if (!config->GetString(kPrivateKeyConfigPath, &key_base64)) {
 821     LOG(ERROR) << "Private key couldn't be read from the config file.";
 822     return false;
 823   }
 824
 825   key_pair_ = RsaKeyPair::FromString(key_base64);
 826   if (!key_pair_.get()) {
 827     LOG(ERROR) << "Invalid private key in the config file.";
 828     return false;
 829   }
 830
 831   std::string host_secret_hash_string;
 832   if (!config->GetString(kHostSecretHashConfigPath,
 833                          &host_secret_hash_string)) {
 834     host_secret_hash_string = "plain:";
 835   }
 836
 837   if (!host_secret_hash_.Parse(host_secret_hash_string)) {
 838     LOG(ERROR) << "Invalid host_secret_hash.";
 839     return false;
 840   }
 841
 842   // Use an XMPP connection to the Talk network for session signalling.
 843   if (!config->GetString(kXmppLoginConfigPath, &xmpp_server_config_.username) ||
 844       !(config->GetString(kXmppAuthTokenConfigPath,
 845                           &xmpp_server_config_.auth_token) ||
 846         config->GetString(kOAuthRefreshTokenConfigPath,
 847                           &oauth_refresh_token_))) {
 848     LOG(ERROR) << "XMPP credentials are not defined in the config.";
 849     return false;
 850   }
 851
 852   if (!oauth_refresh_token_.empty()) {
 853     // SignalingConnector is responsible for getting OAuth token.
 854     xmpp_server_config_.auth_token = "";
 855     xmpp_server_config_.auth_service = "oauth2";
 856   } else if (!config->GetString(kXmppAuthServiceConfigPath,
 857                                 &xmpp_server_config_.auth_service)) {
 858     // For the me2me host, we default to ClientLogin token for chromiumsync
 859     // because earlier versions of the host had no HTTP stack with which to
 860     // request an OAuth2 access token.
 861     xmpp_server_config_.auth_service = kChromotingTokenDefaultServiceName;
 862   }
 863
 864   if (config->GetString(kHostOwnerConfigPath, &host_owner_)) {
 865     // Service account configs have a host_owner, different from the xmpp_login.
 866     use_service_account_ = true;
 867   } else {
 868     // User credential configs only have an xmpp_login, which is also the owner.
 869     host_owner_ = xmpp_server_config_.username;
 870     use_service_account_ = false;
 871   }
 872
 873   // For non-Gmail Google accounts, the owner base JID differs from the email.
 874   // host_owner_ contains the base JID (used for authenticating clients), while
 875   // host_owner_email contains the account's email (used for UI and logs).
 876   if (!config->GetString(kHostOwnerEmailConfigPath, &host_owner_email_)) {
 877     host_owner_email_ = host_owner_;
 878   }
 879
 880   // Allow offering of VP9 encoding to be overridden by the command-line.
 881   if (CommandLine::ForCurrentProcess()->HasSwitch(kEnableVp9SwitchName)) {
 882     enable_vp9_ = true;
 883   } else {
 884     config->GetBoolean(kEnableVp9ConfigPath, &enable_vp9_);
 885   }
 886
 887   // Allow the command-line to override the size of the frame recorder buffer.
 888   std::string frame_recorder_buffer_kb;
 889   if (CommandLine::ForCurrentProcess()->HasSwitch(
 890           kFrameRecorderBufferKbName)) {
 891     frame_recorder_buffer_kb =
 892         CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
 893             kFrameRecorderBufferKbName);
 894   } else {
 895     config->GetString(kFrameRecorderBufferKbConfigPath,
 896                       &frame_recorder_buffer_kb);
 897   }
 898   if (!frame_recorder_buffer_kb.empty()) {
 899     int buffer_kb = 0;
 900     if (base::StringToInt(frame_recorder_buffer_kb, &buffer_kb)) {
 901       frame_recorder_buffer_size_ = 1024LL * buffer_kb;
 902     }
 903   }
 904
 905   return true;
 906 }
 907
 908 void HostProcess::OnPolicyUpdate(scoped_ptr<base::DictionaryValue> policies) {
 909   if (!context_->network_task_runner()->BelongsToCurrentThread()) {
 910     context_->network_task_runner()->PostTask(FROM_HERE, base::Bind(
 911         &HostProcess::OnPolicyUpdate, this, base::Passed(&policies)));
 912     return;
 913   }
 914
 915   bool restart_required = false;
 916   restart_required |= OnHostDomainPolicyUpdate(policies.get());
 917   restart_required |= OnCurtainPolicyUpdate(policies.get());
 918   // Note: UsernamePolicyUpdate must run after OnCurtainPolicyUpdate.
 919   restart_required |= OnUsernamePolicyUpdate(policies.get());
 920   restart_required |= OnNatPolicyUpdate(policies.get());
 921   restart_required |= OnRelayPolicyUpdate(policies.get());
 922   restart_required |= OnUdpPortPolicyUpdate(policies.get());
 923   restart_required |= OnHostTalkGadgetPrefixPolicyUpdate(policies.get());
 924   restart_required |= OnHostTokenUrlPolicyUpdate(policies.get());
 925   restart_required |= OnPairingPolicyUpdate(policies.get());
 926   restart_required |= OnGnubbyAuthPolicyUpdate(policies.get());
 927
 928   if (state_ == HOST_INITIALIZING) {
 929     StartHost();
 930   } else if (state_ == HOST_STARTED && restart_required) {
 931     RestartHost();
 932   }
 933 }
 934
 935 void HostProcess::ApplyHostDomainPolicy() {
 936   HOST_LOG << "Policy sets host domain: " << host_domain_;
 937
 938   // If the user does not have a Google email, their client JID will not be
 939   // based on their email. In that case, the username/host domain policies would
 940   // be meaningless, since there is no way to check that the JID attempting to
 941   // connect actually corresponds to the owner email in question.
 942   if (host_owner_ != host_owner_email_) {
 943     LOG(ERROR) << "The username and host domain policies cannot be enabled for "
 944                << "accounts with a non-Google email.";
 945     ShutdownHost(kInvalidHostDomainExitCode);
 946   }
 947
 948   if (!host_domain_.empty() &&
 949       !EndsWith(host_owner_, std::string("@") + host_domain_, false)) {
 950     LOG(ERROR) << "The host domain does not match the policy.";
 951     ShutdownHost(kInvalidHostDomainExitCode);
 952   }
 953 }
 954
 955 bool HostProcess::OnHostDomainPolicyUpdate(base::DictionaryValue* policies) {
 956   // Returns true if the host has to be restarted after this policy update.
 957   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
 958
 959   if (!policies->GetString(policy_hack::PolicyWatcher::kHostDomainPolicyName,
 960                           &host_domain_)) {
 961     return false;
 962   }
 963
 964   ApplyHostDomainPolicy();
 965   return false;
 966 }
 967
 968 void HostProcess::ApplyUsernamePolicy() {
 969   // See comment in ApplyHostDomainPolicy.
 970   if (host_owner_ != host_owner_email_) {
 971     LOG(ERROR) << "The username and host domain policies cannot be enabled for "
 972                << "accounts with a non-Google email.";
 973     ShutdownHost(kUsernameMismatchExitCode);
 974   }
 975
 976   if (host_username_match_required_) {
 977     HOST_LOG << "Policy requires host username match.";
 978     std::string username = GetUsername();
 979     bool shutdown = username.empty() ||
 980         !StartsWithASCII(host_owner_, username + std::string("@"),
 981                          false);
 982
 983 #if defined(OS_MACOSX)
 984     // On Mac, we run as root at the login screen, so the username won't match.
 985     // However, there's no need to enforce the policy at the login screen, as
 986     // the client will have to reconnect if a login occurs.
 987     if (shutdown && getuid() == 0) {
 988       shutdown = false;
 989     }
 990 #endif
 991
 992     // Curtain-mode on Windows presents the standard OS login prompt to the user
 993     // for each connection, removing the need for an explicit user-name matching
 994     // check.
 995 #if defined(OS_WIN) && defined(REMOTING_RDP_SESSION)
 996     if (curtain_required_)
 997       return;
 998 #endif  // defined(OS_WIN) && defined(REMOTING_RDP_SESSION)
 999
1000     // Shutdown the host if the username does not match.
1001     if (shutdown) {
1002       LOG(ERROR) << "The host username does not match.";
1003       ShutdownHost(kUsernameMismatchExitCode);
1004     }
1005   } else {
1006     HOST_LOG << "Policy does not require host username match.";
1007   }
1008 }
1009
1010 bool HostProcess::OnUsernamePolicyUpdate(base::DictionaryValue* policies) {
1011   // Returns false: never restart the host after this policy update.
1012   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
1013
1014   if (!policies->GetBoolean(
1015       policy_hack::PolicyWatcher::kHostMatchUsernamePolicyName,
1016       &host_username_match_required_)) {
1017     return false;
1018   }
1019
1020   ApplyUsernamePolicy();
1021   return false;
1022 }
1023
1024 bool HostProcess::OnNatPolicyUpdate(base::DictionaryValue* policies) {
1025   // Returns true if the host has to be restarted after this policy update.
1026   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
1027
1028   if (!policies->GetBoolean(policy_hack::PolicyWatcher::kNatPolicyName,
1029                            &allow_nat_traversal_)) {
1030     return false;
1031   }
1032
1033   if (allow_nat_traversal_) {
1034     HOST_LOG << "Policy enables NAT traversal.";
1035   } else {
1036     HOST_LOG << "Policy disables NAT traversal.";
1037   }
1038   return true;
1039 }
1040
1041 bool HostProcess::OnRelayPolicyUpdate(base::DictionaryValue* policies) {
1042   // Returns true if the host has to be restarted after this policy update.
1043   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
1044
1045   if (!policies->GetBoolean(policy_hack::PolicyWatcher::kRelayPolicyName,
1046                            &allow_relay_)) {
1047     return false;
1048   }
1049
1050   if (allow_relay_) {
1051     HOST_LOG << "Policy enables use of relay server.";
1052   } else {
1053     HOST_LOG << "Policy disables use of relay server.";
1054   }
1055   return true;
1056 }
1057
1058 bool HostProcess::OnUdpPortPolicyUpdate(base::DictionaryValue* policies) {
1059   // Returns true if the host has to be restarted after this policy update.
1060   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
1061
1062   std::string udp_port_range;
1063   if (!policies->GetString(policy_hack::PolicyWatcher::kUdpPortRangePolicyName,
1064                            &udp_port_range)) {
1065     return false;
1066   }
1067
1068   // Use default values if policy setting is empty or invalid.
1069   int min_udp_port = 0;
1070   int max_udp_port = 0;
1071   if (!udp_port_range.empty() &&
1072       !NetworkSettings::ParsePortRange(udp_port_range, &min_udp_port,
1073                                        &max_udp_port)) {
1074     LOG(WARNING) << "Invalid port range policy: \"" << udp_port_range
1075                  << "\". Using default values.";
1076   }
1077
1078   if (min_udp_port_ != min_udp_port || max_udp_port_ != max_udp_port) {
1079     if (min_udp_port != 0 && max_udp_port != 0) {
1080       HOST_LOG << "Policy restricts UDP port range to [" << min_udp_port
1081                << ", " << max_udp_port << "]";
1082     } else {
1083       HOST_LOG << "Policy does not restrict UDP port range.";
1084     }
1085     min_udp_port_ = min_udp_port;
1086     max_udp_port_ = max_udp_port;
1087     return true;
1088   }
1089   return false;
1090 }
1091
1092 bool HostProcess::OnCurtainPolicyUpdate(base::DictionaryValue* policies) {
1093   // Returns true if the host has to be restarted after this policy update.
1094   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
1095
1096   if (!policies->GetBoolean(
1097           policy_hack::PolicyWatcher::kHostRequireCurtainPolicyName,
1098           &curtain_required_)) {
1099     return false;
1100   }
1101
1102 #if defined(OS_MACOSX)
1103   if (curtain_required_) {
1104     // When curtain mode is in effect on Mac, the host process runs in the
1105     // user's switched-out session, but launchd will also run an instance at
1106     // the console login screen.  Even if no user is currently logged-on, we
1107     // can't support remote-access to the login screen because the current host
1108     // process model disconnects the client during login, which would leave
1109     // the logged in session un-curtained on the console until they reconnect.
1110     //
1111     // TODO(jamiewalch): Fix this once we have implemented the multi-process
1112     // daemon architecture (crbug.com/134894)
1113     if (getuid() == 0) {
1114       LOG(ERROR) << "Running the host in the console login session is yet not "
1115                     "supported.";
1116       ShutdownHost(kLoginScreenNotSupportedExitCode);
1117       return false;
1118     }
1119   }
1120 #endif
1121
1122   if (curtain_required_) {
1123     HOST_LOG << "Policy requires curtain-mode.";
1124   } else {
1125     HOST_LOG << "Policy does not require curtain-mode.";
1126   }
1127
1128   if (host_)
1129     host_->SetEnableCurtaining(curtain_required_);
1130   return false;
1131 }
1132
1133 bool HostProcess::OnHostTalkGadgetPrefixPolicyUpdate(
1134     base::DictionaryValue* policies) {
1135   // Returns true if the host has to be restarted after this policy update.
1136   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
1137
1138   if (!policies->GetString(
1139           policy_hack::PolicyWatcher::kHostTalkGadgetPrefixPolicyName,
1140           &talkgadget_prefix_)) {
1141     return false;
1142   }
1143
1144   HOST_LOG << "Policy sets talkgadget prefix: " << talkgadget_prefix_;
1145   return true;
1146 }
1147
1148 bool HostProcess::OnHostTokenUrlPolicyUpdate(base::DictionaryValue* policies) {
1149   // Returns true if the host has to be restarted after this policy update.
1150   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
1151
1152   bool token_policy_changed = false;
1153   std::string token_url_string;
1154   if (policies->GetString(
1155           policy_hack::PolicyWatcher::kHostTokenUrlPolicyName,
1156           &token_url_string)) {
1157     token_policy_changed = true;
1158     third_party_auth_config_.token_url = GURL(token_url_string);
1159   }
1160   std::string token_validation_url_string;
1161   if (policies->GetString(
1162           policy_hack::PolicyWatcher::kHostTokenValidationUrlPolicyName,
1163           &token_validation_url_string)) {
1164     token_policy_changed = true;
1165     third_party_auth_config_.token_validation_url =
1166         GURL(token_validation_url_string);
1167   }
1168   if (policies->GetString(
1169           policy_hack::PolicyWatcher::kHostTokenValidationCertIssuerPolicyName,
1170           &third_party_auth_config_.token_validation_cert_issuer)) {
1171     token_policy_changed = true;
1172   }
1173
1174   if (token_policy_changed) {
1175     HOST_LOG << "Policy sets third-party token URLs: "
1176              << "TokenUrl: "
1177              << third_party_auth_config_.token_url << ", "
1178              << "TokenValidationUrl: "
1179              << third_party_auth_config_.token_validation_url << ", "
1180              << "TokenValidationCertificateIssuer: "
1181              << third_party_auth_config_.token_validation_cert_issuer;
1182   }
1183   return token_policy_changed;
1184 }
1185
1186 bool HostProcess::OnPairingPolicyUpdate(base::DictionaryValue* policies) {
1187   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
1188
1189   if (!policies->GetBoolean(
1190           policy_hack::PolicyWatcher::kHostAllowClientPairing,
1191           &allow_pairing_)) {
1192     return false;
1193   }
1194
1195   if (allow_pairing_) {
1196     HOST_LOG << "Policy enables client pairing.";
1197   } else {
1198     HOST_LOG << "Policy disables client pairing.";
1199   }
1200   return true;
1201 }
1202
1203 bool HostProcess::OnGnubbyAuthPolicyUpdate(base::DictionaryValue* policies) {
1204   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
1205
1206   if (!policies->GetBoolean(
1207           policy_hack::PolicyWatcher::kHostAllowGnubbyAuthPolicyName,
1208           &enable_gnubby_auth_)) {
1209     return false;
1210   }
1211
1212   if (enable_gnubby_auth_) {
1213     HOST_LOG << "Policy enables gnubby auth.";
1214   } else {
1215     HOST_LOG << "Policy disables gnubby auth.";
1216   }
1217
1218   if (desktop_environment_factory_)
1219     desktop_environment_factory_->SetEnableGnubbyAuth(enable_gnubby_auth_);
1220
1221   return true;
1222 }
1223
1224 void HostProcess::StartHost() {
1225   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
1226   DCHECK(!host_);
1227   DCHECK(!signal_strategy_.get());
1228   DCHECK(state_ == HOST_INITIALIZING || state_ == HOST_STOPPING_TO_RESTART ||
1229          state_ == HOST_STOPPED) << state_;
1230   state_ = HOST_STARTED;
1231
1232   signal_strategy_.reset(
1233       new XmppSignalStrategy(net::ClientSocketFactory::GetDefaultFactory(),
1234                              context_->url_request_context_getter(),
1235                              xmpp_server_config_));
1236
1237   scoped_ptr<DnsBlackholeChecker> dns_blackhole_checker(
1238       new DnsBlackholeChecker(context_->url_request_context_getter(),
1239                               talkgadget_prefix_));
1240
1241   // Create a NetworkChangeNotifier for use by the signaling connector.
1242   network_change_notifier_.reset(net::NetworkChangeNotifier::Create());
1243
1244   signaling_connector_.reset(new SignalingConnector(
1245       signal_strategy_.get(),
1246       dns_blackhole_checker.Pass(),
1247       base::Bind(&HostProcess::OnAuthFailed, this)));
1248
1249   if (!oauth_refresh_token_.empty()) {
1250     scoped_ptr<OAuthTokenGetter::OAuthCredentials> oauth_credentials;
1251     oauth_credentials.reset(
1252         new OAuthTokenGetter::OAuthCredentials(
1253             xmpp_server_config_.username, oauth_refresh_token_,
1254             use_service_account_));
1255
1256     oauth_token_getter_.reset(new OAuthTokenGetter(
1257         oauth_credentials.Pass(), context_->url_request_context_getter(),
1258         false));
1259
1260     signaling_connector_->EnableOAuth(oauth_token_getter_.get());
1261   }
1262
1263   uint32 network_flags = 0;
1264   if (allow_nat_traversal_) {
1265     network_flags = NetworkSettings::NAT_TRAVERSAL_STUN |
1266                     NetworkSettings::NAT_TRAVERSAL_OUTGOING;
1267     if (allow_relay_)
1268       network_flags |= NetworkSettings::NAT_TRAVERSAL_RELAY;
1269   }
1270
1271   NetworkSettings network_settings(network_flags);
1272
1273   if (min_udp_port_ && max_udp_port_) {
1274     network_settings.min_port = min_udp_port_;
1275     network_settings.max_port = max_udp_port_;
1276   } else if (!allow_nat_traversal_) {
1277     // For legacy reasons we have to restrict the port range to a set of default
1278     // values when nat traversal is disabled, even if the port range was not
1279     // set in policy.
1280     network_settings.min_port = NetworkSettings::kDefaultMinPort;
1281     network_settings.max_port = NetworkSettings::kDefaultMaxPort;
1282   }
1283
1284   host_.reset(new ChromotingHost(
1285       signal_strategy_.get(),
1286       desktop_environment_factory_.get(),
1287       CreateHostSessionManager(signal_strategy_.get(), network_settings,
1288                                context_->url_request_context_getter()),
1289       context_->audio_task_runner(),
1290       context_->input_task_runner(),
1291       context_->video_capture_task_runner(),
1292       context_->video_encode_task_runner(),
1293       context_->network_task_runner(),
1294       context_->ui_task_runner()));
1295
1296   if (enable_vp9_) {
1297     scoped_ptr<protocol::CandidateSessionConfig> config =
1298         host_->protocol_config()->Clone();
1299     config->EnableVideoCodec(protocol::ChannelConfig::CODEC_VP9);
1300     host_->set_protocol_config(config.Pass());
1301   }
1302
1303   if (frame_recorder_buffer_size_ > 0) {
1304     scoped_ptr<VideoFrameRecorderHostExtension> frame_recorder_extension(
1305         new VideoFrameRecorderHostExtension());
1306     frame_recorder_extension->SetMaxContentBytes(frame_recorder_buffer_size_);
1307     host_->AddExtension(frame_recorder_extension.PassAs<HostExtension>());
1308   }
1309
1310   // TODO(simonmorris): Get the maximum session duration from a policy.
1311 #if defined(OS_LINUX)
1312   host_->SetMaximumSessionDuration(base::TimeDelta::FromHours(20));
1313 #endif
1314
1315   heartbeat_sender_.reset(new HeartbeatSender(
1316       this, host_id_, signal_strategy_.get(), key_pair_,
1317       directory_bot_jid_));
1318
1319   host_status_sender_.reset(new HostStatusSender(
1320       host_id_, signal_strategy_.get(), key_pair_, directory_bot_jid_));
1321
1322   host_change_notification_listener_.reset(new HostChangeNotificationListener(
1323       this, host_id_, signal_strategy_.get(), directory_bot_jid_));
1324
1325   host_status_logger_.reset(
1326       new HostStatusLogger(host_->AsWeakPtr(), ServerLogEntry::ME2ME,
1327                            signal_strategy_.get(), directory_bot_jid_));
1328
1329   // Set up reporting the host status notifications.
1330 #if defined(REMOTING_MULTI_PROCESS)
1331   host_event_logger_.reset(
1332       new IpcHostEventLogger(host_->AsWeakPtr(), daemon_channel_.get()));
1333 #else  // !defined(REMOTING_MULTI_PROCESS)
1334   host_event_logger_ =
1335       HostEventLogger::Create(host_->AsWeakPtr(), kApplicationName);
1336 #endif  // !defined(REMOTING_MULTI_PROCESS)
1337
1338   host_->SetEnableCurtaining(curtain_required_);
1339   host_->Start(host_owner_email_);
1340
1341   CreateAuthenticatorFactory();
1342 }
1343
1344 void HostProcess::OnAuthFailed() {
1345   ShutdownHost(kInvalidOauthCredentialsExitCode);
1346 }
1347
1348 void HostProcess::RestartHost() {
1349   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
1350   DCHECK_EQ(state_, HOST_STARTED);
1351
1352   state_ = HOST_STOPPING_TO_RESTART;
1353   ShutdownOnNetworkThread();
1354 }
1355
1356 void HostProcess::ShutdownHost(HostExitCodes exit_code) {
1357   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
1358
1359   *exit_code_out_ = exit_code;
1360
1361   switch (state_) {
1362     case HOST_INITIALIZING:
1363       state_ = HOST_STOPPING;
1364       ShutdownOnNetworkThread();
1365       break;
1366
1367     case HOST_STARTED:
1368       state_ = HOST_STOPPING;
1369       host_status_sender_->SendOfflineStatus(exit_code);
1370       ScheduleHostShutdown();
1371       break;
1372
1373     case HOST_STOPPING_TO_RESTART:
1374       state_ = HOST_STOPPING;
1375       break;
1376
1377     case HOST_STOPPING:
1378     case HOST_STOPPED:
1379       // Host is already stopped or being stopped. No action is required.
1380       break;
1381   }
1382 }
1383
1384 // TODO(weitaosu): shut down the host once we get an ACK for the offline status
1385 //                  XMPP message.
1386 void HostProcess::ScheduleHostShutdown() {
1387   // Delay the shutdown by 2 second to allow SendOfflineStatus to complete.
1388   context_->network_task_runner()->PostDelayedTask(
1389       FROM_HERE,
1390       base::Bind(&HostProcess::ShutdownOnNetworkThread, base::Unretained(this)),
1391       base::TimeDelta::FromSeconds(2));
1392 }
1393
1394 void HostProcess::ShutdownOnNetworkThread() {
1395   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
1396
1397   host_.reset();
1398   host_event_logger_.reset();
1399   host_status_logger_.reset();
1400   heartbeat_sender_.reset();
1401   host_status_sender_.reset();
1402   host_change_notification_listener_.reset();
1403   signaling_connector_.reset();
1404   oauth_token_getter_.reset();
1405   signal_strategy_.reset();
1406   network_change_notifier_.reset();
1407
1408   if (state_ == HOST_STOPPING_TO_RESTART) {
1409     StartHost();
1410   } else if (state_ == HOST_STOPPING) {
1411     state_ = HOST_STOPPED;
1412
1413     if (policy_watcher_.get()) {
1414       base::WaitableEvent done_event(true, false);
1415       policy_watcher_->StopWatching(&done_event);
1416       done_event.Wait();
1417       policy_watcher_.reset();
1418     }
1419
1420     config_watcher_.reset();
1421
1422     // Complete the rest of shutdown on the main thread.
1423     context_->ui_task_runner()->PostTask(
1424         FROM_HERE,
1425         base::Bind(&HostProcess::ShutdownOnUiThread, this));
1426   } else {
1427     // This method is only called in STOPPING_TO_RESTART and STOPPING states.
1428     NOTREACHED();
1429   }
1430 }
1431
1432 void HostProcess::OnCrash(const std::string& function_name,
1433                           const std::string& file_name,
1434                           const int& line_number) {
1435   char message[1024];
1436   base::snprintf(message, sizeof(message),
1437                  "Requested by %s at %s, line %d.",
1438                  function_name.c_str(), file_name.c_str(), line_number);
1439   base::debug::Alias(message);
1440
1441   // The daemon requested us to crash the process.
1442   CHECK(false) << message;
1443 }
1444
1445 int HostProcessMain() {
1446 #if defined(OS_LINUX)
1447   // Required in order for us to run multiple X11 threads.
1448   XInitThreads();
1449
1450   // Required for any calls into GTK functions, such as the Disconnect and
1451   // Continue windows, though these should not be used for the Me2Me case
1452   // (crbug.com/104377).
1453   gtk_init(NULL, NULL);
1454 #endif
1455
1456   // Enable support for SSL server sockets, which must be done while still
1457   // single-threaded.
1458   net::EnableSSLServerSockets();
1459
1460   // Ensures runtime specific CPU features are initialized.
1461   media::InitializeCPUSpecificMediaFeatures();
1462
1463   // Create the main message loop and start helper threads.
1464   base::MessageLoopForUI message_loop;
1465   scoped_ptr<ChromotingHostContext> context =
1466       ChromotingHostContext::Create(new AutoThreadTaskRunner(
1467           message_loop.message_loop_proxy(), base::MessageLoop::QuitClosure()));
1468   if (!context)
1469     return kInitializationFailed;
1470
1471   // Create & start the HostProcess using these threads.
1472   // TODO(wez): The HostProcess holds a reference to itself until Shutdown().
1473   // Remove this hack as part of the multi-process refactoring.
1474   int exit_code = kSuccessExitCode;
1475   new HostProcess(context.Pass(), &exit_code);
1476
1477   // Run the main (also UI) message loop until the host no longer needs it.
1478   message_loop.Run();
1479
1480   return exit_code;
1481 }
1482
1483 }  // namespace remoting