[Chromoting] Adding uiAccess='true' to the remoting_me2me_host.exe's manifest as it is required to …

remoting/host/win/host_service.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/win/host_service.h"
 
 #include <windows.h>
+#include <shellapi.h>
 #include <wtsapi32.h>
-#include <stdio.h>
 
 #include "base/at_exit.h"
 #include "base/base_paths.h"
+#include "base/base_switches.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stringprintf.h"
 #include "base/threading/thread.h"
 #include "base/utf_string_conversions.h"
 #include "base/win/wrapped_window_proc.h"
@@ skipping 20 matching lines @@
 
 // Session id that does not represent any session.
 const uint32 kInvalidSessionId = 0xffffffffu;
 
 const char kIoThreadName[] = "I/O thread";
 
 // A window class for the session change notifications window.
 const wchar_t kSessionNotificationWindowClass[] =
   L"Chromoting_SessionNotificationWindow";
 
-// Command line actions and switches:
-// "run" sumply runs the service as usual.
-const wchar_t kRunActionName[] = L"run";
+// Command line switches:
 
 // "--console" runs the service interactively for debugging purposes.
 const char kConsoleSwitchName[] = "console";
 
+// "--elevate=<binary>" requests <binary> to be launched elevated, presenting
+// a UAC prompt if necessary.
+const char kElevateSwitchName[] = "elevate";
+
 // "--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 (default if no action was specified).\n"
-  "\n"
-  "Options:\n"
-  "  --console     - Run the service interactively for debugging purposes.\n"
-  "  --help, --?   - Print this message.\n";
+const wchar_t kUsageMessage[] =
+  L"\n"
+  L"Usage: %ls [options]\n"
+  L"\n"
+  L"Options:\n"
+  L"  --console       - Run the service interactively for debugging purposes.\n"
+  L"  --elevate=<...> - Run <...> elevated.\n"
+  L"  --help, --?     - Print this message.\n";
+
+// The command line parameters that should be copied from the service's command
+// line when launching an elevated child.
+const char* kCopiedSwitchNames[] = {
+    "auth-config", "host-config", "chromoting-ipc", switches::kV,
+    switches::kVModule };
 
 // 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);
+void usage(const FilePath& program_name) {
+  LOG(INFO) << StringPrintf(kUsageMessage,
+                            UTF16ToWide(program_name.value()).c_str());
 }
 
 }  // namespace
 
 namespace remoting {
 
 HostService::HostService() :
   console_session_id_(kInvalidSessionId),
   run_routine_(&HostService::RunAsService),
   service_status_handle_(0),
@@ skipping 62 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.
+  // Check if launch with elevation was requested.
+  if (command_line->HasSwitch(kElevateSwitchName)) {
+    run_routine_ = &HostService::Elevate;
+    return true;
+  }
+
   if (!args.empty()) {
-    if (args.size() > 1) {
-      LOG(ERROR) << "Invalid command line: more than one action requested.";
-      return false;
-    }
-    if (args[0] != kRunActionName) {
-      LOG(ERROR) << "Invalid command line: invalid action specified: "
-                 << args[0];
-      return false;
-    }
+    LOG(ERROR) << "No positional parameters expected.";
+    return false;
   }
 
   // Run interactively if needed.
   if (run_routine_ == &HostService::RunAsService &&
       command_line->HasSwitch(kConsoleSwitchName)) {
     run_routine_ = &HostService::RunInConsole;
   }
 
   return true;
 }
@@ skipping 30 matching lines @@
 
 #endif  // !defined(REMOTING_MULTI_PROCESS)
 
   // Run the service.
   message_loop->Run();
 
   // Release the control handler.
   stopped_event_.Signal();
 }
 
+int HostService::Elevate() {
+  // Get the name of the binary to launch.
+  FilePath binary =
+      CommandLine::ForCurrentProcess()->GetSwitchValuePath(kElevateSwitchName);
+
+  // Create the child process command line by copying known switches from our
+  // command line.
+  CommandLine command_line(CommandLine::NO_PROGRAM);
+  command_line.CopySwitchesFrom(*CommandLine::ForCurrentProcess(),
+                                kCopiedSwitchNames,
+                                _countof(kCopiedSwitchNames));
+  CommandLine::StringType parameters = command_line.GetCommandLineString();
+
+  // Launch the child process requesting elevation.
+  SHELLEXECUTEINFO info;
+  memset(&info, 0, sizeof(info));
+  info.cbSize = sizeof(info);
+  info.lpVerb = L"runas";
+  info.lpFile = binary.value().c_str();
+  info.lpParameters = parameters.c_str();
+  info.nShow = SW_SHOWNORMAL;
+
+  if (!ShellExecuteEx(&info)) {
+    return GetLastError();
+  }
+
+  return kSuccessExitCode;
+}
+
 int HostService::RunAsService() {
   SERVICE_TABLE_ENTRYW dispatch_table[] = {
     { const_cast<LPWSTR>(kWindowsServiceName), &HostService::ServiceMain },
     { NULL, NULL }
   };
 
   if (!StartServiceCtrlDispatcherW(dispatch_table)) {
     LOG_GETLASTERROR(ERROR)
         << "Failed to connect to the service control manager";
     return kErrorExitCode;
@@ skipping 164 matching lines @@
       return 0;
     }
 
     default:
       return DefWindowProc(hwnd, message, wparam, lparam);
   }
 }
 
 } // namespace remoting
 
-int main(int argc, char** argv) {
+int CALLBACK WinMain(HINSTANCE instance,
+                     HINSTANCE previous_instance,
+                     LPSTR raw_command_line,
+                     int show_command) {
 #ifdef OFFICIAL_BUILD
   if (remoting::IsUsageStatsAllowed()) {
     remoting::InitializeCrashReporting();
   }
 #endif  // OFFICIAL_BUILD
 
-  CommandLine::Init(argc, argv);
+  // CommandLine::Init() ignores the passed |argc| and |argv| on Windows getting
+  // the command line from GetCommandLineW(), so we can safely pass NULL here.
+  CommandLine::Init(0, NULL);
 
   // This object instance is required by Chrome code (for example,
   // FilePath, LazyInstance, MessageLoop).
   base::AtExitManager exit_manager;
 
   // Write logs to the application profile directory.
   FilePath debug_log = remoting::GetConfigDir().
       Append(FILE_PATH_LITERAL("debug.log"));
   InitLogging(debug_log.value().c_str(),
               logging::LOG_ONLY_TO_FILE,
               logging::DONT_LOCK_LOG_FILE,
               logging::APPEND_TO_OLD_LOG_FILE,
               logging::DISABLE_DCHECK_FOR_NON_OFFICIAL_RELEASE_BUILDS);
 
   const CommandLine* command_line = CommandLine::ForCurrentProcess();
-
   if (command_line->HasSwitch(kHelpSwitchName) ||
       command_line->HasSwitch(kQuestionSwitchName)) {
-    usage(argv[0]);
+    usage(command_line->GetProgram());
     return kSuccessExitCode;
   }
 
   remoting::HostService* service = remoting::HostService::GetInstance();
   if (!service->InitWithCommandLine(command_line)) {
-    usage(argv[0]);
+    usage(command_line->GetProgram());
     return kUsageExitCode;
   }
 
   return service->Run();
 }