Forward host status notifications to the daemon via IPC.

When multi-process host is used the host/network process runs with low privileges (for example at low integrity level on Windows), so it might not have access to the system event log. This CL makes the network process to send host status notifications to the daemon, which in its turn can write them to the system event log.

BUG=178873


Review URL: https://chromiumcodereview.appspot.com/12378032

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@185992 0039d316-1c4b-4281-b951-d872f2087c98

7 files changed, 355 insertions, 16 deletions

diff --git a/remoting/host/chromoting_messages.h b/remoting/host/chromoting_messages.h
index 68d47a7..6b19147 100644
--- a/remoting/host/chromoting_messages.h
+++ b/remoting/host/chromoting_messages.h
@@ -7,6 +7,8 @@
 
 #include "ipc/ipc_platform_file.h"
 #include "media/video/capture/screen/mouse_cursor_shape.h"
+#include "net/base/ip_endpoint.h"
+#include "remoting/protocol/transport.h"
 #include "third_party/skia/include/core/SkPoint.h"
 #include "third_party/skia/include/core/SkRect.h"
 #include "third_party/skia/include/core/SkSize.h"
@@ -68,6 +70,39 @@ IPC_MESSAGE_CONTROL1(ChromotingNetworkHostMsg_ConnectTerminal,
 IPC_MESSAGE_CONTROL1(ChromotingNetworkHostMsg_DisconnectTerminal,
                      int /* terminal_id */)
 
+// Serialized remoting::protocol::TransportRoute structure.
+IPC_STRUCT_BEGIN(SerializedTransportRoute)
+  IPC_STRUCT_MEMBER(int, type)
+  IPC_STRUCT_MEMBER(net::IPAddressNumber, remote_address)
+  IPC_STRUCT_MEMBER(int, remote_port)
+  IPC_STRUCT_MEMBER(net::IPAddressNumber, local_address)
+  IPC_STRUCT_MEMBER(int, local_port)
+IPC_STRUCT_END()
+
+// Hosts status notifications (see HostStatusObserver interface) sent by
+// IpcHostEventLogger.
+IPC_MESSAGE_CONTROL1(ChromotingNetworkDaemonMsg_AccessDenied,
+                     std::string /* jid */)
+
+IPC_MESSAGE_CONTROL1(ChromotingNetworkDaemonMsg_ClientAuthenticated,
+                     std::string /* jid */)
+
+IPC_MESSAGE_CONTROL1(ChromotingNetworkDaemonMsg_ClientConnected,
+                     std::string /* jid */)
+
+IPC_MESSAGE_CONTROL1(ChromotingNetworkDaemonMsg_ClientDisconnected,
+                     std::string /* jid */)
+
+IPC_MESSAGE_CONTROL3(ChromotingNetworkDaemonMsg_ClientRouteChange,
+                     std::string /* jid */,
+                     std::string /* channel_name */,
+                     SerializedTransportRoute /* route */)
+
+IPC_MESSAGE_CONTROL1(ChromotingNetworkDaemonMsg_HostStarted,
+                     std::string /* xmpp_login */)
+
+IPC_MESSAGE_CONTROL0(ChromotingNetworkDaemonMsg_HostShutdown)
+
 //-----------------------------------------------------------------------------
 // Chromoting messages sent from the daemon to the desktop process.
 
diff --git a/remoting/host/daemon_process.cc b/remoting/host/daemon_process.cc
index f76838d..98c94bb 100644
--- a/remoting/host/daemon_process.cc
+++ b/remoting/host/daemon_process.cc
@@ -10,13 +10,20 @@
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/single_thread_task_runner.h"
+#include "net/base/net_util.h"
 #include "remoting/base/auto_thread_task_runner.h"
 #include "remoting/host/branding.h"
 #include "remoting/host/chromoting_messages.h"
 #include "remoting/host/desktop_session.h"
+#include "remoting/host/host_event_logger.h"
+#include "remoting/host/host_status_observer.h"
+#include "remoting/protocol/transport.h"
 
 namespace remoting {
 
+// This is used for tagging system event logs.
+const char kApplicationName[] = "chromoting";
+
 DaemonProcess::~DaemonProcess() {
   DCHECK(!config_watcher_.get());
   DCHECK(desktop_sessions_.empty());
@@ -38,6 +45,18 @@ void DaemonProcess::OnConfigWatcherError() {
   Stop();
 }
 
+void DaemonProcess::AddStatusObserver(HostStatusObserver* observer) {
+  DCHECK(caller_task_runner()->BelongsToCurrentThread());
+
+  status_observers_.AddObserver(observer);
+}
+
+void DaemonProcess::RemoveStatusObserver(HostStatusObserver* observer) {
+  DCHECK(caller_task_runner()->BelongsToCurrentThread());
+
+  status_observers_.RemoveObserver(observer);
+}
+
 void DaemonProcess::OnChannelConnected(int32 peer_pid) {
   DCHECK(caller_task_runner()->BelongsToCurrentThread());
 
@@ -63,6 +82,20 @@ bool DaemonProcess::OnMessageReceived(const IPC::Message& message) {
                         CreateDesktopSession)
     IPC_MESSAGE_HANDLER(ChromotingNetworkHostMsg_DisconnectTerminal,
                         CloseDesktopSession)
+    IPC_MESSAGE_HANDLER(ChromotingNetworkDaemonMsg_AccessDenied,
+                        OnAccessDenied)
+    IPC_MESSAGE_HANDLER(ChromotingNetworkDaemonMsg_ClientAuthenticated,
+                        OnClientAuthenticated)
+    IPC_MESSAGE_HANDLER(ChromotingNetworkDaemonMsg_ClientConnected,
+                        OnClientConnected)
+    IPC_MESSAGE_HANDLER(ChromotingNetworkDaemonMsg_ClientDisconnected,
+                        OnClientDisconnected)
+    IPC_MESSAGE_HANDLER(ChromotingNetworkDaemonMsg_ClientRouteChange,
+                        OnClientRouteChange)
+    IPC_MESSAGE_HANDLER(ChromotingNetworkDaemonMsg_HostStarted,
+                        OnHostStarted)
+    IPC_MESSAGE_HANDLER(ChromotingNetworkDaemonMsg_HostShutdown,
+                        OnHostShutdown)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
@@ -82,7 +115,6 @@ void DaemonProcess::CloseDesktopSession(int terminal_id) {
   if (!IsTerminalIdKnown(terminal_id)) {
     LOG(ERROR) << "An invalid terminal ID. terminal_id=" << terminal_id;
     CrashNetworkProcess(FROM_HERE);
-    DeleteAllDesktopSessions();
     return;
   }
 
@@ -114,14 +146,11 @@ DaemonProcess::DaemonProcess(
     : Stoppable(caller_task_runner, stopped_callback),
       caller_task_runner_(caller_task_runner),
       io_task_runner_(io_task_runner),
-      next_terminal_id_(0) {
+      next_terminal_id_(0),
+      ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
   DCHECK(caller_task_runner->BelongsToCurrentThread());
 }
 
-bool DaemonProcess::IsTerminalIdKnown(int terminal_id) {
-  return terminal_id < next_terminal_id_;
-}
-
 void DaemonProcess::CreateDesktopSession(int terminal_id) {
   DCHECK(caller_task_runner()->BelongsToCurrentThread());
 
@@ -131,7 +160,6 @@ void DaemonProcess::CreateDesktopSession(int terminal_id) {
   if (IsTerminalIdKnown(terminal_id)) {
     LOG(ERROR) << "An invalid terminal ID. terminal_id=" << terminal_id;
     CrashNetworkProcess(FROM_HERE);
-    DeleteAllDesktopSessions();
     return;
   }
 
@@ -145,6 +173,8 @@ void DaemonProcess::CrashNetworkProcess(
     const tracked_objects::Location& location) {
   SendToNetwork(new ChromotingDaemonNetworkMsg_Crash(
       location.function_name(), location.file_name(), location.line_number()));
+
+  DeleteAllDesktopSessions();
 }
 
 void DaemonProcess::Initialize() {
@@ -164,13 +194,101 @@ void DaemonProcess::Initialize() {
                                               this));
   config_watcher_->Watch(config_path);
 
+  host_event_logger_ =
+      HostEventLogger::Create(weak_factory_.GetWeakPtr(), kApplicationName);
+
   // Launch the process.
   LaunchNetworkProcess();
 }
 
+bool DaemonProcess::IsTerminalIdKnown(int terminal_id) {
+  return terminal_id < next_terminal_id_;
+}
+
+void DaemonProcess::OnAccessDenied(const std::string& jid) {
+  DCHECK(caller_task_runner()->BelongsToCurrentThread());
+
+  FOR_EACH_OBSERVER(HostStatusObserver, status_observers_, OnAccessDenied(jid));
+}
+
+void DaemonProcess::OnClientAuthenticated(const std::string& jid) {
+  DCHECK(caller_task_runner()->BelongsToCurrentThread());
+
+  FOR_EACH_OBSERVER(HostStatusObserver, status_observers_,
+                    OnClientAuthenticated(jid));
+}
+
+void DaemonProcess::OnClientConnected(const std::string& jid) {
+  DCHECK(caller_task_runner()->BelongsToCurrentThread());
+
+  FOR_EACH_OBSERVER(HostStatusObserver, status_observers_,
+                    OnClientConnected(jid));
+}
+
+void DaemonProcess::OnClientDisconnected(const std::string& jid) {
+  DCHECK(caller_task_runner()->BelongsToCurrentThread());
+
+  FOR_EACH_OBSERVER(HostStatusObserver, status_observers_,
+                    OnClientDisconnected(jid));
+}
+
+void DaemonProcess::OnClientRouteChange(const std::string& jid,
+                                        const std::string& channel_name,
+                                        const SerializedTransportRoute& route) {
+  DCHECK(caller_task_runner()->BelongsToCurrentThread());
+
+  // Validate |route|.
+  if (route.type != protocol::TransportRoute::DIRECT &&
+      route.type != protocol::TransportRoute::STUN &&
+      route.type != protocol::TransportRoute::RELAY) {
+    LOG(ERROR) << "An invalid RouteType " << route.type << " passed.";
+    CrashNetworkProcess(FROM_HERE);
+    return;
+  }
+  if (route.remote_address.size() != net::kIPv4AddressSize &&
+      route.remote_address.size() != net::kIPv6AddressSize) {
+    LOG(ERROR) << "An invalid net::IPAddressNumber size "
+               << route.remote_address.size() << " passed.";
+    CrashNetworkProcess(FROM_HERE);
+    return;
+  }
+  if (route.local_address.size() != net::kIPv4AddressSize &&
+      route.local_address.size() != net::kIPv6AddressSize) {
+    LOG(ERROR) << "An invalid net::IPAddressNumber size "
+               << route.local_address.size() << " passed.";
+    CrashNetworkProcess(FROM_HERE);
+    return;
+  }
+
+  protocol::TransportRoute parsed_route;
+  parsed_route.type =
+      static_cast<protocol::TransportRoute::RouteType>(route.type);
+  parsed_route.remote_address =
+      net::IPEndPoint(route.remote_address, route.remote_port);
+  parsed_route.local_address =
+      net::IPEndPoint(route.local_address, route.local_port);
+  FOR_EACH_OBSERVER(HostStatusObserver, status_observers_,
+                    OnClientRouteChange(jid, channel_name, parsed_route));
+}
+
+void DaemonProcess::OnHostStarted(const std::string& xmpp_login) {
+  DCHECK(caller_task_runner()->BelongsToCurrentThread());
+
+  FOR_EACH_OBSERVER(HostStatusObserver, status_observers_, OnStart(xmpp_login));
+}
+
+void DaemonProcess::OnHostShutdown() {
+  DCHECK(caller_task_runner()->BelongsToCurrentThread());
+
+  FOR_EACH_OBSERVER(HostStatusObserver, status_observers_, OnShutdown());
+}
+
 void DaemonProcess::DoStop() {
   DCHECK(caller_task_runner()->BelongsToCurrentThread());
 
+  host_event_logger_.reset();
+  weak_factory_.InvalidateWeakPtrs();
+
   config_watcher_.reset();
   DeleteAllDesktopSessions();
 
diff --git a/remoting/host/daemon_process.h b/remoting/host/daemon_process.h
index 45952bb..323573f 100644
--- a/remoting/host/daemon_process.h
+++ b/remoting/host/daemon_process.h
@@ -12,18 +12,25 @@
 #include "base/location.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/memory/weak_ptr.h"
+#include "base/observer_list.h"
 #include "base/process.h"
 #include "ipc/ipc_channel.h"
 #include "ipc/ipc_channel_proxy.h"
 #include "ipc/ipc_platform_file.h"
 #include "remoting/base/stoppable.h"
 #include "remoting/host/config_file_watcher.h"
+#include "remoting/host/host_status_monitor.h"
 #include "remoting/host/worker_process_ipc_delegate.h"
 
+struct SerializedTransportRoute;
+
 namespace remoting {
 
 class AutoThreadTaskRunner;
 class DesktopSession;
+class HostEventLogger;
+class HostStatusObserver;
 
 // This class implements core of the daemon process. It manages the networking
 // process running at lower privileges and maintains the list of desktop
@@ -31,6 +38,7 @@ class DesktopSession;
 class DaemonProcess
     : public Stoppable,
       public ConfigFileWatcher::Delegate,
+      public HostStatusMonitor,
       public WorkerProcessIpcDelegate {
  public:
   typedef std::list<DesktopSession*> DesktopSessionList;
@@ -50,6 +58,10 @@ class DaemonProcess
   virtual void OnConfigUpdated(const std::string& serialized_config) OVERRIDE;
   virtual void OnConfigWatcherError() OVERRIDE;
 
+  // HostStatusMonitor interface.
+  virtual void AddStatusObserver(HostStatusObserver* observer) OVERRIDE;
+  virtual void RemoveStatusObserver(HostStatusObserver* observer) OVERRIDE;
+
   // WorkerProcessIpcDelegate implementation.
   virtual void OnChannelConnected(int32 peer_pid) OVERRIDE;
   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
@@ -89,6 +101,18 @@ class DaemonProcess
   // less or equal to the highest ID we have seen so far.
   bool IsTerminalIdKnown(int terminal_id);
 
+  // Handlers for the host status notifications received from the network
+  // process.
+  void OnAccessDenied(const std::string& jid);
+  void OnClientAuthenticated(const std::string& jid);
+  void OnClientConnected(const std::string& jid);
+  void OnClientDisconnected(const std::string& jid);
+  void OnClientRouteChange(const std::string& jid,
+                           const std::string& channel_name,
+                           const SerializedTransportRoute& route);
+  void OnHostStarted(const std::string& xmpp_login);
+  void OnHostShutdown();
+
   // Stoppable implementation.
   virtual void DoStop() OVERRIDE;
 
@@ -134,6 +158,14 @@ class DaemonProcess
   // The highest desktop session ID that has been seen so far.
   int next_terminal_id_;
 
+  // Keeps track of observers receiving host status notifications.
+  ObserverList<HostStatusObserver> status_observers_;
+
+  // Writes host status updates to the system event log.
+  scoped_ptr<HostEventLogger> host_event_logger_;
+
+  base::WeakPtrFactory<DaemonProcess> weak_factory_;
+
   DISALLOW_COPY_AND_ASSIGN(DaemonProcess);
 };
 
diff --git a/remoting/host/ipc_host_event_logger.cc b/remoting/host/ipc_host_event_logger.cc
new file mode 100644
index 0000000..d0e9679
--- /dev/null
+++ b/remoting/host/ipc_host_event_logger.cc
@@ -0,0 +1,84 @@
+// 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 "remoting/host/ipc_host_event_logger.h"
+
+#include "base/logging.h"
+#include "ipc/ipc_sender.h"
+#include "net/base/ip_endpoint.h"
+#include "remoting/host/chromoting_messages.h"
+#include "remoting/host/host_status_monitor.h"
+#include "remoting/protocol/transport.h"
+
+namespace remoting {
+
+IpcHostEventLogger::IpcHostEventLogger(base::WeakPtr<HostStatusMonitor> monitor,
+                                       IPC::Sender* daemon_channel)
+    : daemon_channel_(daemon_channel),
+      monitor_(monitor) {
+  monitor_->AddStatusObserver(this);
+}
+
+IpcHostEventLogger::~IpcHostEventLogger() {
+  DCHECK(CalledOnValidThread());
+
+  if (monitor_)
+    monitor_->RemoveStatusObserver(this);
+}
+
+void IpcHostEventLogger::OnAccessDenied(const std::string& jid) {
+  DCHECK(CalledOnValidThread());
+
+  daemon_channel_->Send(new ChromotingNetworkDaemonMsg_AccessDenied(jid));
+}
+
+void IpcHostEventLogger::OnClientAuthenticated(const std::string& jid) {
+  DCHECK(CalledOnValidThread());
+
+  daemon_channel_->Send(
+      new ChromotingNetworkDaemonMsg_ClientAuthenticated(jid));
+}
+
+void IpcHostEventLogger::OnClientConnected(const std::string& jid) {
+  DCHECK(CalledOnValidThread());
+
+  daemon_channel_->Send(new ChromotingNetworkDaemonMsg_ClientConnected(jid));
+}
+
+void IpcHostEventLogger::OnClientDisconnected(const std::string& jid) {
+  DCHECK(CalledOnValidThread());
+
+  daemon_channel_->Send(new ChromotingNetworkDaemonMsg_ClientDisconnected(jid));
+}
+
+void IpcHostEventLogger::OnClientRouteChange(
+    const std::string& jid,
+    const std::string& channel_name,
+    const protocol::TransportRoute& route) {
+  DCHECK(CalledOnValidThread());
+
+  SerializedTransportRoute serialized_route;
+  serialized_route.type = route.type;
+  serialized_route.remote_address = route.remote_address.address();
+  serialized_route.remote_port = route.remote_address.port();
+  serialized_route.local_address = route.local_address.address();
+  serialized_route.local_port = route.local_address.port();
+
+  daemon_channel_->Send(new ChromotingNetworkDaemonMsg_ClientRouteChange(
+      jid, channel_name, serialized_route));
+}
+
+void IpcHostEventLogger::OnShutdown() {
+  DCHECK(CalledOnValidThread());
+
+  daemon_channel_->Send(new ChromotingNetworkDaemonMsg_HostShutdown());
+}
+
+void IpcHostEventLogger::OnStart(const std::string& xmpp_login) {
+  DCHECK(CalledOnValidThread());
+
+  daemon_channel_->Send(new ChromotingNetworkDaemonMsg_HostStarted(xmpp_login));
+}
+
+}  // namespace remoting
diff --git a/remoting/host/ipc_host_event_logger.h b/remoting/host/ipc_host_event_logger.h
new file mode 100644
index 0000000..069c4fa
--- /dev/null
+++ b/remoting/host/ipc_host_event_logger.h
@@ -0,0 +1,59 @@
+// 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.
+
+#ifndef REMOTING_HOST_IPC_HOST_EVENT_LOGGER_H_
+#define REMOTING_HOST_IPC_HOST_EVENT_LOGGER_H_
+
+#include <string>
+
+#include "base/basictypes.h"
+#include "base/compiler_specific.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/memory/weak_ptr.h"
+#include "base/threading/non_thread_safe.h"
+#include "remoting/host/host_event_logger.h"
+#include "remoting/host/host_status_observer.h"
+
+namespace IPC {
+class Sender;
+}  // namespace IPC
+
+namespace remoting {
+
+class HostStatusMonitor;
+
+class IpcHostEventLogger
+    : public base::NonThreadSafe,
+      public HostEventLogger,
+      public HostStatusObserver {
+ public:
+  // Initializes the logger. |daemon_channel| must outlive this object.
+  IpcHostEventLogger(base::WeakPtr<HostStatusMonitor> monitor,
+                     IPC::Sender* daemon_channel);
+  virtual ~IpcHostEventLogger();
+
+  // HostStatusObserver interface.
+  virtual void OnAccessDenied(const std::string& jid) OVERRIDE;
+  virtual void OnClientAuthenticated(const std::string& jid) OVERRIDE;
+  virtual void OnClientConnected(const std::string& jid) OVERRIDE;
+  virtual void OnClientDisconnected(const std::string& jid) OVERRIDE;
+  virtual void OnClientRouteChange(
+      const std::string& jid,
+      const std::string& channel_name,
+      const protocol::TransportRoute& route) OVERRIDE;
+  virtual void OnStart(const std::string& xmpp_login) OVERRIDE;
+  virtual void OnShutdown() OVERRIDE;
+
+ private:
+  // Used to report host status events to the daemon.
+  IPC::Sender* daemon_channel_;
+
+  base::WeakPtr<HostStatusMonitor> monitor_;
+
+  DISALLOW_COPY_AND_ASSIGN(IpcHostEventLogger);
+};
+
+}
+
+#endif  // REMOTING_HOST_IPC_HOST_EVENT_LOGGER_H_
diff --git a/remoting/host/remoting_me2me_host.cc b/remoting/host/remoting_me2me_host.cc
index 2d1a3b7..f3d48b2 100644
--- a/remoting/host/remoting_me2me_host.cc
+++ b/remoting/host/remoting_me2me_host.cc
@@ -54,6 +54,7 @@
 #include "remoting/host/host_user_interface.h"
 #include "remoting/host/ipc_constants.h"
 #include "remoting/host/ipc_desktop_environment.h"
+#include "remoting/host/ipc_host_event_logger.h"
 #include "remoting/host/json_host_config.h"
 #include "remoting/host/log_to_server.h"
 #include "remoting/host/logging.h"
@@ -937,8 +938,15 @@ void HostProcess::StartHost() {
   log_to_server_.reset(
       new LogToServer(host_->AsWeakPtr(), ServerLogEntry::ME2ME,
                       signal_strategy_.get(), directory_bot_jid_));
+
+  // Set up repoting the host status notifications.
+#if defined(REMOTING_MULTI_PROCESS)
+  host_event_logger_.reset(
+      new IpcHostEventLogger(host_->AsWeakPtr(), daemon_channel_.get()));
+#else  // !defined(REMOTING_MULTI_PROCESS)
   host_event_logger_ =
       HostEventLogger::Create(host_->AsWeakPtr(), kApplicationName);
+#endif  // !defined(REMOTING_MULTI_PROCESS)
 
   resizing_host_observer_.reset(
       new ResizingHostObserver(desktop_resizer_.get(), host_->AsWeakPtr()));
diff --git a/remoting/remoting.gyp b/remoting/remoting.gyp
index 71999b5..02430eb 100644
--- a/remoting/remoting.gyp
+++ b/remoting/remoting.gyp
@@ -373,6 +373,8 @@
             'host/ipc_desktop_environment.h',
             'host/ipc_event_executor.cc',
             'host/ipc_event_executor.h',
+            'host/ipc_host_event_logger.cc',
+            'host/ipc_host_event_logger.h',
             'host/ipc_video_frame_capturer.cc',
             'host/ipc_video_frame_capturer.h',
             'host/it2me_host_user_interface.cc',
@@ -2416,15 +2418,6 @@
       'target_name': 'remoting_unittests',
       'type': 'executable',
       'dependencies': [
-        'remoting_base',
-        'remoting_resources',
-        'remoting_breakpad',
-        'remoting_client',
-        'remoting_client_plugin',
-        'remoting_host',
-        'remoting_jingle_glue',
-        'remoting_protocol',
-        'remoting_host_setup_base',
         '../base/base.gyp:base',
         '../base/base.gyp:base_i18n',
         '../base/base.gyp:test_support_base',
@@ -2436,6 +2429,16 @@
         '../testing/gmock.gyp:gmock',
         '../testing/gtest.gyp:gtest',
         '../ui/ui.gyp:ui',
+        'remoting_base',
+        'remoting_breakpad',
+        'remoting_client',
+        'remoting_client_plugin',
+        'remoting_host',
+        'remoting_host_event_logger',
+        'remoting_host_setup_base',
+        'remoting_jingle_glue',
+        'remoting_protocol',
+        'remoting_resources',
       ],
       'defines': [
         'VERSION=<(version_full)',