Change the daemon start type to 'manual' if the host ID has been deleted.

remoting/host/daemon_process_win.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.
 
 #include "remoting/host/daemon_process.h"
 
 #include "base/base_switches.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/process.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time.h"
 #include "base/timer.h"
 #include "base/win/scoped_handle.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_message_macros.h"
 #include "remoting/base/auto_thread_task_runner.h"
+#include "remoting/base/scoped_sc_handle_win.h"
+#include "remoting/host/branding.h"
 #include "remoting/host/chromoting_messages.h"
 #include "remoting/host/desktop_session_win.h"
 #include "remoting/host/host_exit_codes.h"
 #include "remoting/host/host_main.h"
 #include "remoting/host/ipc_constants.h"
 #include "remoting/host/screen_resolution.h"
 #include "remoting/host/win/launch_process_with_token.h"
 #include "remoting/host/win/unprivileged_process_delegate.h"
 #include "remoting/host/win/worker_process_launcher.h"
 
@@ skipping 11 matching lines @@
 class DaemonProcessWin : public DaemonProcess {
  public:
   DaemonProcessWin(
       scoped_refptr<AutoThreadTaskRunner> caller_task_runner,
       scoped_refptr<AutoThreadTaskRunner> io_task_runner,
       const base::Closure& stopped_callback);
   virtual ~DaemonProcessWin();
 
   // WorkerProcessIpcDelegate implementation.
   virtual void OnChannelConnected(int32 peer_pid) OVERRIDE;
+  virtual void OnPermanentError(int exit_code) OVERRIDE;
 
   // DaemonProcess overrides.
   virtual void SendToNetwork(IPC::Message* message) OVERRIDE;
   virtual bool OnDesktopSessionAgentAttached(
       int terminal_id,
       base::ProcessHandle desktop_process,
       IPC::PlatformFileForTransit desktop_pipe) OVERRIDE;
 
  protected:
   // DaemonProcess implementation.
   virtual scoped_ptr<DesktopSession> DoCreateDesktopSession(
       int terminal_id,
       const ScreenResolution& resolution,
       bool virtual_terminal) OVERRIDE;
   virtual void DoCrashNetworkProcess(
       const tracked_objects::Location& location) OVERRIDE;
   virtual void LaunchNetworkProcess() OVERRIDE;
 
+  // Changes the service start type to 'manual'.
+  void DisableAutoStart();
+
  private:
   scoped_ptr<WorkerProcessLauncher> network_launcher_;
 
   // Handle of the network process.
   ScopedHandle network_process_;
 
   DISALLOW_COPY_AND_ASSIGN(DaemonProcessWin);
 };
 
 DaemonProcessWin::DaemonProcessWin(
@@ skipping 10 matching lines @@
   // Obtain the handle of the network process.
   network_process_.Set(OpenProcess(PROCESS_DUP_HANDLE, false, peer_pid));
   if (!network_process_.IsValid()) {
     CrashNetworkProcess(FROM_HERE);
     return;
   }
 
   DaemonProcess::OnChannelConnected(peer_pid);
 }
 
+void DaemonProcessWin::OnPermanentError(int exit_code) {
+  // Change the service start type to 'manual' if the host has been deleted
+  // remotely. This way the host will not be started every time the machine
+  // boots until the user re-enable it again.
+  if (exit_code == kInvalidHostIdExitCode)
+    DisableAutoStart();
+
+  DaemonProcess::OnPermanentError(exit_code);
+}
+
 void DaemonProcessWin::SendToNetwork(IPC::Message* message) {
   if (network_launcher_) {
     network_launcher_->Send(message);
   } else {
     delete message;
   }
 }
 
 bool DaemonProcessWin::OnDesktopSessionAgentAttached(
     int terminal_id,
@@ skipping 67 matching lines @@
     scoped_refptr<AutoThreadTaskRunner> caller_task_runner,
     scoped_refptr<AutoThreadTaskRunner> io_task_runner,
     const base::Closure& stopped_callback) {
   scoped_ptr<DaemonProcessWin> daemon_process(
       new DaemonProcessWin(caller_task_runner, io_task_runner,
                            stopped_callback));
   daemon_process->Initialize();
   return daemon_process.PassAs<DaemonProcess>();
 }
 
+void DaemonProcessWin::DisableAutoStart() {
+  ScopedScHandle scmanager(
+      OpenSCManager(NULL, SERVICES_ACTIVE_DATABASE,
+                    SC_MANAGER_CONNECT | SC_MANAGER_ENUMERATE_SERVICE));
+  if (!scmanager.IsValid()) {
+    LOG_GETLASTERROR(INFO)
+        << "Failed to connect to the service control manager";
+    return;
+  }
+
+  DWORD desired_access = SERVICE_CHANGE_CONFIG | SERVICE_QUERY_STATUS;
+  ScopedScHandle service(
+      OpenService(scmanager, kWindowsServiceName, desired_access));
+  if (!service.IsValid()) {
+    LOG_GETLASTERROR(INFO)
+        << "Failed to open to the '" << kWindowsServiceName << "' service";
+    return;
+  }
+
+  // Change the service start type to 'manual'. All |NULL| parameters below mean
+  // that there is no change to the corresponding service parameter.
+  if (!ChangeServiceConfig(service,
+                           SERVICE_NO_CHANGE,
+                           SERVICE_DEMAND_START,
+                           SERVICE_NO_CHANGE,
+                           NULL,
+                           NULL,
+                           NULL,
+                           NULL,
+                           NULL,
+                           NULL,
+                           NULL)) {
+    LOG_GETLASTERROR(INFO)
+        << "Failed to change the '" << kWindowsServiceName
+        << "'service start type to 'manual'";
+  }
+}
+
 }  // namespace remoting