Chromoting service now launches the host process in the session the is currently attached to the ph…

remoting/host/host_service_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.
 //
 // This file implements the Windows service controlling Me2Me host processes
 // running within user sessions.
 
 #include "remoting/host/host_service_win.h"
 
 #include <windows.h>
 #include <wtsapi32.h>
 #include <stdio.h>
 
 #include "base/at_exit.h"
 #include "base/base_paths.h"
 #include "base/bind.h"
 #include "base/command_line.h"
-#include "base/file_path.h"
+#include "base/file_util.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "base/win/wrapped_window_proc.h"
 
 #include "remoting/host/host_service_resource.h"
 #include "remoting/base/scoped_sc_handle_win.h"
 #include "remoting/host/wts_console_observer_win.h"
 #include "remoting/host/wts_session_process_launcher_win.h"
 
 using base::StringPrintf;
 
 namespace {
 
 // Service name.
 const char kServiceName[] = "chromoting";
 // TODO(alexeypa): investigate and migrate this over to Chrome's i18n framework.
 const char kMuiStringFormat[] = "@%ls,-%d";
 const char kServiceDependencies[] = "";
 
+const char kServiceCommandLineFormat[] = "\"%ls\" --host-binary=\"%ls\"";
+
 const DWORD kServiceStopTimeoutMs = 30 * 1000;
 
 // Session id that does not represent any session.
 const uint32 kInvalidSession = 0xffffffff;
 
 // A window class for the session change notifications window.
 static const char kSessionNotificationWindowClass[] =
   "Chromoting_SessionNotificationWindow";
 
 // Command line actions and switches:
 // "run" sumply runs the service as usual.
 const char kRunActionName[] = "run";
 
 // "install" requests the service to be installed.
 const char kInstallActionName[] = "install";
 
 // "remove" uninstalls the service.
 const char kRemoveActionName[] = "remove";
 
 // "--console" runs the service interactively for debugging purposes.
 const char kConsoleSwitchName[] = "console";
 
+// "--host-binary" specifies the host binary to run in console session.
+const char kHostBinarySwitchName[] = "host-binary";
+
 // "--help" or "--?" prints the usage message.
 const char kHelpSwitchName[] = "help";
 const char kQuestionSwitchName[] = "?";
 
 const char kUsageMessage[] =
   "\n"
   "Usage: %s [action] [options]\n"
   "\n"
   "Actions:\n"
-  "  run         - Run the service. If no action specified 'run' is assumed.\n"
-  "  install     - Install the service.\n"
-  "  remove      - Uninstall the service.\n"
+  "  run           - Run the service (default if no action was specified).\n"
+  "  install       - Install the service.\n"
+  "  remove        - Uninstall the service.\n"
   "\n"
   "Options:\n"
-  "  --console   - Run the service interactively for debugging purposes.\n"
-  "  --help, --? - Print this message.\n";
+  "  --console     - Run the service interactively for debugging purposes.\n"
+  "  --host-binary - Specifies the host binary to run in the console session.\n"
+  "  --help, --?   - Print this message.\n";
 
 // Exit codes:
 const int kSuccessExitCode = 0;
 const int kUsageExitCode = 1;
 const int kErrorExitCode = 2;
 
 void usage(const char* program_name) {
   fprintf(stderr, kUsageMessage, program_name);
 }
 
@@ skipping 67 matching lines @@
 }
 
 HostService* HostService::GetInstance() {
   return Singleton<HostService>::get();
 }
 
 bool HostService::InitWithCommandLine(const CommandLine* command_line) {
   CommandLine::StringVector args = command_line->GetArgs();
 
   // Choose the action to perform.
+  bool host_binary_required = true;
   if (!args.empty()) {
     if (args.size() > 1) {
       LOG(ERROR) << "Invalid command line: more than one action requested.";
       return false;
     }
     if (args[0] == ASCIIToUTF16(kInstallActionName)) {
       run_routine_ = &HostService::Install;
     } else if (args[0] == ASCIIToUTF16(kRemoveActionName)) {
       run_routine_ = &HostService::Remove;
+      host_binary_required = false;
     } else if (args[0] != ASCIIToUTF16(kRunActionName)) {
       LOG(ERROR) << "Invalid command line: invalid action specified: "
                  << args[0];
       return false;
     }
   }
 
+  if (host_binary_required) {
+    if (command_line->HasSwitch(kHostBinarySwitchName)) {
+      host_binary_ = command_line->GetSwitchValuePath(kHostBinarySwitchName);
+    } else {
+      LOG(ERROR) << "Invalid command line: --" << kHostBinarySwitchName
+                 << " is required.";
+      return false;
+    }
+  }
+
   // Run interactively if needed.
   if (run_routine_ == &HostService::RunAsService &&
       command_line->HasSwitch(kConsoleSwitchName)) {
     run_routine_ = &HostService::RunInConsole;
   }
 
   return true;
 }
 
 int HostService::Install() {
   ScopedScHandle scmanager(
       OpenSCManagerW(NULL, NULL,
                      SC_MANAGER_CONNECT | SC_MANAGER_CREATE_SERVICE));
   if (!scmanager.IsValid()) {
     LOG_GETLASTERROR(ERROR)
         << "Failed to connect to the service control manager";
     return kErrorExitCode;
   }
 
   FilePath exe;
   if (!PathService::Get(base::FILE_EXE, &exe)) {
     LOG(ERROR) << "Unable to retrieve the service binary path.";
     return kErrorExitCode;
   }
 
   string16 name = StringPrintf(ASCIIToUTF16(kMuiStringFormat).c_str(),
                                exe.value().c_str(),
                                IDS_DISPLAY_SERVICE_NAME);
+
+  if (!file_util::AbsolutePath(&host_binary_) ||
+      !file_util::PathExists(host_binary_)) {
+    LOG(ERROR) << "Invalid host binary name: " << host_binary_.value();
+    return kErrorExitCode;
+  }
+
+  string16 command_line = StringPrintf(
+                              ASCIIToUTF16(kServiceCommandLineFormat).c_str(),
+                              exe.value().c_str(),
+                              host_binary_.value().c_str());
   ScopedScHandle service(
       CreateServiceW(scmanager,
                      service_name_.c_str(),
                      name.c_str(),
                      SERVICE_QUERY_STATUS | SERVICE_CHANGE_CONFIG,
                      SERVICE_WIN32_OWN_PROCESS,
                      SERVICE_DEMAND_START, SERVICE_ERROR_NORMAL,
-                     exe.value().c_str(),
+                     command_line.c_str(),
                      NULL,
                      NULL,
                      ASCIIToUTF16(kServiceDependencies).c_str(),
                      NULL,
                      NULL));
 
   if (service.IsValid()) {
     // Set the service description if the service is freshly installed.
     string16 description = StringPrintf(
                                ASCIIToUTF16(kMuiStringFormat).c_str(),
@@ skipping 87 matching lines @@
 
   printf("The service has been removed successfully.\n");
   return kSuccessExitCode;
 }
 
 int HostService::Run() {
   return (this->*run_routine_)();
 }
 
 void HostService::RunMessageLoop() {
-  WtsSessionProcessLauncher launcher(this);
+  WtsSessionProcessLauncher launcher(this, host_binary_);
 
   // Run the service.
   message_loop_->Run();
 
   // Clean up the observers by emulating detaching from the console.
   shutting_down_ = true;
   OnSessionChange();
 
   // Release the control handler.
   stopped_event_.Signal();
@@ skipping 202 matching lines @@
   }
 
   remoting::HostService* service = remoting::HostService::GetInstance();
   if (!service->InitWithCommandLine(command_line)) {
     usage(argv[0]);
     return kUsageExitCode;
   }
 
   return service->Run();
 }