Chromoting: stopping the service if the host ID is permanently not recognized by the could.

remoting/host/remoting_me2me_host.cc

 // Copyright (c) 2012 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.
 //
 // This file implements a standalone host process for Me2Me.
 
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
 
 #include <string>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/threading/thread.h"
 #include "build/build_config.h"
 #include "crypto/nss_util.h"
 #include "net/base/network_change_notifier.h"
 #include "remoting/base/constants.h"
 #include "remoting/host/branding.h"
+#include "remoting/host/constants.h"
 #include "remoting/host/capturer.h"
 #include "remoting/host/chromoting_host.h"
 #include "remoting/host/chromoting_host_context.h"
 #include "remoting/host/desktop_environment.h"
 #include "remoting/host/event_executor.h"
 #include "remoting/host/heartbeat_sender.h"
 #include "remoting/host/host_config.h"
 #include "remoting/host/host_event_logger.h"
 #include "remoting/host/json_host_config.h"
 #include "remoting/host/log_to_server.h"
 #include "remoting/host/oauth_client.h"
 #include "remoting/host/policy_hack/nat_policy.h"
 #include "remoting/host/signaling_connector.h"
 #include "remoting/jingle_glue/xmpp_signal_strategy.h"
 #include "remoting/protocol/me2me_host_authenticator_factory.h"
 
 #if defined(OS_MACOSX)
 #include "remoting/host/sighup_listener_mac.h"
 #endif
 #if defined(TOOLKIT_GTK)
 #include "ui/gfx/gtk_util.h"
 #endif
 
 namespace {
 
-const int kSuccessExitCode = 0;
-const int kInvalidHostConfigurationExitCode = 1;
-
 // This is used for tagging system event logs.
 const char kApplicationName[] = "chromoting";
 
 // These are used for parsing the config-file locations from the command line,
 // and for defining the default locations if the switches are not present.
 const char kAuthConfigSwitchName[] = "auth-config";
 const char kHostConfigSwitchName[] = "host-config";
 
 const FilePath::CharType kDefaultAuthConfigFile[] =
     FILE_PATH_LITERAL("auth.json");
 const FilePath::CharType kDefaultHostConfigFile[] =
     FILE_PATH_LITERAL("host.json");
 
 const int kMinPortNumber = 12400;
 const int kMaxPortNumber = 12409;
 
 }  // namespace
 
 namespace remoting {
 
-class HostProcess : public OAuthClient::Delegate {
+class HostProcess
+    : public OAuthClient::Delegate,
+      public HeartbeatSender::Delegate {
  public:
   HostProcess()
       : message_loop_(MessageLoop::TYPE_UI),
         file_io_thread_("FileIO"),
         allow_nat_traversal_(true),
-        restarting_(false) {
+        restarting_(false),
+        exit_code_(kSuccessExitCode) {
     file_io_thread_.StartWithOptions(
         base::Thread::Options(MessageLoop::TYPE_IO, 0));
 
     context_.reset(new ChromotingHostContext(
                            file_io_thread_.message_loop_proxy(),
                            message_loop_.message_loop_proxy()));
     context_->Start();
     network_change_notifier_.reset(net::NetworkChangeNotifier::Create());
   }
 
@@ skipping 64 matching lines @@
     }
 
 #if defined(OS_MACOSX)
     file_io_thread_.message_loop_proxy()->PostTask(
         FROM_HERE,
         base::Bind(&HostProcess::ListenForConfigChanges,
                    base::Unretained(this)));
 #endif
     message_loop_.Run();
 
-    return kSuccessExitCode;
+    return exit_code_;
   }
 
   // Overridden from OAuthClient::Delegate
   virtual void OnRefreshTokenResponse(const std::string& access_token,
                                       int expires) OVERRIDE {
     xmpp_auth_token_ = access_token;
     // If there's already a signal strategy object, update it ready for the
     // next time it calls Connect. If not, then this is the initial token
     // exchange, so proceed to the next stage of connection.
     if (signal_strategy_.get()) {
       context_->network_message_loop()->PostTask(
           FROM_HERE, base::Bind(
               &XmppSignalStrategy::SetAuthInfo,
               base::Unretained(signal_strategy_.get()),
               xmpp_login_, xmpp_auth_token_, xmpp_auth_service_));
     } else {
       StartWatchingNatPolicy();
     }
   }
 
   virtual void OnOAuthError() OVERRIDE {
     LOG(ERROR) << "OAuth: invalid credentials.";
+    Shutdown(kInvalidOauthCredentialsExitCode);
+  }
+
+  // Overridden from HeartbeatSender::Delegate
+  virtual void OnUnknownHostIdError() OVERRIDE {
+    LOG(ERROR) << "Host ID not found.";
+    Shutdown(kInvalidHostIdExitCode);
   }
 
  private:
   void StartWatchingNatPolicy() {
     nat_policy_.reset(
         policy_hack::NatPolicy::Create(file_io_thread_.message_loop_proxy()));
     nat_policy_->StartWatching(
         base::Bind(&HostProcess::OnNatPolicyUpdate, base::Unretained(this)));
   }
 
@@ skipping 99 matching lines @@
     protocol::NetworkSettings network_settings(allow_nat_traversal_);
     if (!allow_nat_traversal_) {
       network_settings.min_port = kMinPortNumber;
       network_settings.max_port = kMaxPortNumber;
     }
 
     host_ = new ChromotingHost(
         context_.get(), signal_strategy_.get(), desktop_environment_.get(),
         network_settings);
 
-    heartbeat_sender_.reset(
-        new HeartbeatSender(host_id_, signal_strategy_.get(), &key_pair_));
+    heartbeat_sender_.reset(new HeartbeatSender(
+        this, host_id_, signal_strategy_.get(), &key_pair_));
 
     log_to_server_.reset(
         new LogToServer(host_, ServerLogEntry::ME2ME, signal_strategy_.get()));
     host_event_logger_ = HostEventLogger::Create(host_, kApplicationName);
 
     host_->Start();
 
     CreateAuthenticatorFactory();
   }
 
@@ skipping 14 matching lines @@
     restarting_ = false;
 
     host_ = NULL;
     log_to_server_.reset();
     host_event_logger_.reset();
     heartbeat_sender_.reset();
 
     StartHost();
   }
 
+  void Shutdown(int exit_code) {
+    exit_code_ = exit_code;
+    message_loop_.PostTask(FROM_HERE, MessageLoop::QuitClosure());
+  }
+
   MessageLoop message_loop_;
   base::Thread file_io_thread_;
   scoped_ptr<ChromotingHostContext> context_;
   scoped_ptr<net::NetworkChangeNotifier> network_change_notifier_;
 
   FilePath auth_config_path_;
   FilePath host_config_path_;
 
   std::string host_id_;
   HostKeyPair key_pair_;
@@ skipping 10 matching lines @@
 
   bool restarting_;
 
   scoped_ptr<XmppSignalStrategy> signal_strategy_;
   scoped_ptr<SignalingConnector> signaling_connector_;
   scoped_ptr<DesktopEnvironment> desktop_environment_;
   scoped_ptr<HeartbeatSender> heartbeat_sender_;
   scoped_ptr<LogToServer> log_to_server_;
   scoped_ptr<HostEventLogger> host_event_logger_;
   scoped_refptr<ChromotingHost> host_;
+
+  int exit_code_;
 };
 
 }  // namespace remoting
 
 int main(int argc, char** argv) {
   CommandLine::Init(argc, argv);
 
   // This object instance is required by Chrome code (for example,
   // LazyInstance, MessageLoop).
   base::AtExitManager exit_manager;
@@ skipping 29 matching lines @@
 int CALLBACK WinMain(HINSTANCE instance,
                      HINSTANCE previous_instance,
                      LPSTR command_line,
                      int show_command) {
   // CommandLine::Init() ignores the passed |argc| and |argv| on Windows getting
   // the command line from GetCommandLineW(), so we can safely pass NULL here.
   return main(0, NULL);
 }
 
 #endif