chrome/common/service_process_util.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/common/service_process_util.h"
   6
   7 #include <algorithm>
   8
   9 #include "base/command_line.h"
  10 #include "base/logging.h"
  11 #include "base/memory/singleton.h"
  12 #include "base/path_service.h"
  13 #include "base/sha1.h"
  14 #include "base/strings/string16.h"
  15 #include "base/strings/string_number_conversions.h"
  16 #include "base/strings/string_util.h"
  17 #include "base/strings/utf_string_conversions.h"
  18 #include "base/version.h"
  19 #include "chrome/common/chrome_constants.h"
  20 #include "chrome/common/chrome_paths.h"
  21 #include "chrome/common/chrome_switches.h"
  22 #include "chrome/common/chrome_version_info.h"
  23 #include "components/cloud_devices/common/cloud_devices_switches.h"
  24 #include "content/public/common/content_paths.h"
  25 #include "google_apis/gaia/gaia_switches.h"
  26 #include "ui/base/ui_base_switches.h"
  27
  28 #if !defined(OS_MACOSX)
  29
  30 namespace {
  31
  32 // This should be more than enough to hold a version string assuming each part
  33 // of the version string is an int64.
  34 const uint32 kMaxVersionStringLength = 256;
  35
  36 // The structure that gets written to shared memory.
  37 struct ServiceProcessSharedData {
  38   char service_process_version[kMaxVersionStringLength];
  39   base::ProcessId service_process_pid;
  40 };
  41
  42 // Gets the name of the shared memory used by the service process to write its
  43 // version. The name is not versioned.
  44 std::string GetServiceProcessSharedMemName() {
  45   return GetServiceProcessScopedName("_service_shmem");
  46 }
  47
  48 enum ServiceProcessRunningState {
  49   SERVICE_NOT_RUNNING,
  50   SERVICE_OLDER_VERSION_RUNNING,
  51   SERVICE_SAME_VERSION_RUNNING,
  52   SERVICE_NEWER_VERSION_RUNNING,
  53 };
  54
  55 ServiceProcessRunningState GetServiceProcessRunningState(
  56     std::string* service_version_out, base::ProcessId* pid_out) {
  57   std::string version;
  58   if (!GetServiceProcessData(&version, pid_out))
  59     return SERVICE_NOT_RUNNING;
  60
  61 #if defined(OS_POSIX)
  62   // We only need to check for service running on POSIX because Windows cleans
  63   // up shared memory files when an app crashes, so there isn't a chance of
  64   // us reading bogus data from shared memory for an app that has died.
  65   if (!CheckServiceProcessReady()) {
  66     return SERVICE_NOT_RUNNING;
  67   }
  68 #endif  // defined(OS_POSIX)
  69
  70   // At this time we have a version string. Set the out param if it exists.
  71   if (service_version_out)
  72     *service_version_out = version;
  73
  74   Version service_version(version);
  75   // If the version string is invalid, treat it like an older version.
  76   if (!service_version.IsValid())
  77     return SERVICE_OLDER_VERSION_RUNNING;
  78
  79   // Get the version of the currently *running* instance of Chrome.
  80   chrome::VersionInfo version_info;
  81   if (!version_info.is_valid()) {
  82     NOTREACHED() << "Failed to get current file version";
  83     // Our own version is invalid. This is an error case. Pretend that we
  84     // are out of date.
  85     return SERVICE_NEWER_VERSION_RUNNING;
  86   }
  87   Version running_version(version_info.Version());
  88   if (!running_version.IsValid()) {
  89     NOTREACHED() << "Failed to parse version info";
  90     // Our own version is invalid. This is an error case. Pretend that we
  91     // are out of date.
  92     return SERVICE_NEWER_VERSION_RUNNING;
  93   }
  94
  95   if (running_version.CompareTo(service_version) > 0) {
  96     return SERVICE_OLDER_VERSION_RUNNING;
  97   } else if (service_version.CompareTo(running_version) > 0) {
  98     return SERVICE_NEWER_VERSION_RUNNING;
  99   }
 100   return SERVICE_SAME_VERSION_RUNNING;
 101 }
 102
 103 }  // namespace
 104
 105 // Return a name that is scoped to this instance of the service process. We
 106 // use the hash of the user-data-dir as a scoping prefix. We can't use
 107 // the user-data-dir itself as we have limits on the size of the lock names.
 108 std::string GetServiceProcessScopedName(const std::string& append_str) {
 109   base::FilePath user_data_dir;
 110   PathService::Get(chrome::DIR_USER_DATA, &user_data_dir);
 111 #if defined(OS_WIN)
 112   std::string user_data_dir_path = base::WideToUTF8(user_data_dir.value());
 113 #elif defined(OS_POSIX)
 114   std::string user_data_dir_path = user_data_dir.value();
 115 #endif  // defined(OS_WIN)
 116   std::string hash = base::SHA1HashString(user_data_dir_path);
 117   std::string hex_hash = base::HexEncode(hash.c_str(), hash.length());
 118   return hex_hash + "." + append_str;
 119 }
 120
 121 // Return a name that is scoped to this instance of the service process. We
 122 // use the user-data-dir and the version as a scoping prefix.
 123 std::string GetServiceProcessScopedVersionedName(
 124     const std::string& append_str) {
 125   std::string versioned_str;
 126   chrome::VersionInfo version_info;
 127   DCHECK(version_info.is_valid());
 128   versioned_str.append(version_info.Version());
 129   versioned_str.append(append_str);
 130   return GetServiceProcessScopedName(versioned_str);
 131 }
 132
 133 // Reads the named shared memory to get the shared data. Returns false if no
 134 // matching shared memory was found.
 135 bool GetServiceProcessData(std::string* version, base::ProcessId* pid) {
 136   scoped_ptr<base::SharedMemory> shared_mem_service_data;
 137   shared_mem_service_data.reset(new base::SharedMemory());
 138   ServiceProcessSharedData* service_data = NULL;
 139   if (shared_mem_service_data.get() &&
 140       shared_mem_service_data->Open(GetServiceProcessSharedMemName(), true) &&
 141       shared_mem_service_data->Map(sizeof(ServiceProcessSharedData))) {
 142     service_data = reinterpret_cast<ServiceProcessSharedData*>(
 143         shared_mem_service_data->memory());
 144     // Make sure the version in shared memory is null-terminated. If it is not,
 145     // treat it as invalid.
 146     if (version && memchr(service_data->service_process_version, '\0',
 147                           sizeof(service_data->service_process_version)))
 148       *version = service_data->service_process_version;
 149     if (pid)
 150       *pid = service_data->service_process_pid;
 151     return true;
 152   }
 153   return false;
 154 }
 155
 156 #endif  // !OS_MACOSX
 157
 158 scoped_ptr<base::CommandLine> CreateServiceProcessCommandLine() {
 159   base::FilePath exe_path;
 160   PathService::Get(content::CHILD_PROCESS_EXE, &exe_path);
 161   DCHECK(!exe_path.empty()) << "Unable to get service process binary name.";
 162   scoped_ptr<base::CommandLine> command_line(new base::CommandLine(exe_path));
 163   command_line->AppendSwitchASCII(switches::kProcessType,
 164                                   switches::kServiceProcess);
 165   static const char* const kSwitchesToCopy[] = {
 166     switches::kCloudPrintSetupProxy,
 167     switches::kCloudPrintURL,
 168     switches::kCloudPrintXmppEndpoint,
 169 #if defined(OS_WIN)
 170     switches::kEnableCloudPrintXps,
 171 #endif
 172     switches::kEnableLogging,
 173     switches::kIgnoreUrlFetcherCertRequests,
 174     switches::kLang,
 175     switches::kLoggingLevel,
 176     switches::kLsoUrl,
 177     switches::kNoServiceAutorun,
 178     switches::kUserDataDir,
 179     switches::kV,
 180     switches::kVModule,
 181     switches::kWaitForDebugger,
 182   };
 183
 184   command_line->CopySwitchesFrom(*base::CommandLine::ForCurrentProcess(),
 185                                  kSwitchesToCopy,
 186                                  arraysize(kSwitchesToCopy));
 187   return command_line.Pass();
 188 }
 189
 190 ServiceProcessState::ServiceProcessState() : state_(NULL) {
 191   autorun_command_line_ = CreateServiceProcessCommandLine();
 192   CreateState();
 193 }
 194
 195 ServiceProcessState::~ServiceProcessState() {
 196 #if !defined(OS_MACOSX)
 197   if (shared_mem_service_data_.get()) {
 198     shared_mem_service_data_->Delete(GetServiceProcessSharedMemName());
 199   }
 200 #endif  // !OS_MACOSX
 201   TearDownState();
 202 }
 203
 204 void ServiceProcessState::SignalStopped() {
 205   TearDownState();
 206   shared_mem_service_data_.reset();
 207 }
 208
 209 #if !defined(OS_MACOSX)
 210 bool ServiceProcessState::Initialize() {
 211   if (!TakeSingletonLock()) {
 212     return false;
 213   }
 214   // Now that we have the singleton, take care of killing an older version, if
 215   // it exists.
 216   if (!HandleOtherVersion())
 217     return false;
 218
 219   // Write the version we are using to shared memory. This can be used by a
 220   // newer service to signal us to exit.
 221   return CreateSharedData();
 222 }
 223
 224 bool ServiceProcessState::HandleOtherVersion() {
 225   std::string running_version;
 226   base::ProcessId process_id = 0;
 227   ServiceProcessRunningState state =
 228       GetServiceProcessRunningState(&running_version, &process_id);
 229   switch (state) {
 230     case SERVICE_SAME_VERSION_RUNNING:
 231     case SERVICE_NEWER_VERSION_RUNNING:
 232       return false;
 233     case SERVICE_OLDER_VERSION_RUNNING:
 234       // If an older version is running, kill it.
 235       ForceServiceProcessShutdown(running_version, process_id);
 236       break;
 237     case SERVICE_NOT_RUNNING:
 238       break;
 239   }
 240   return true;
 241 }
 242
 243 bool ServiceProcessState::CreateSharedData() {
 244   chrome::VersionInfo version_info;
 245   if (!version_info.is_valid()) {
 246     NOTREACHED() << "Failed to get current file version";
 247     return false;
 248   }
 249   if (version_info.Version().length() >= kMaxVersionStringLength) {
 250     NOTREACHED() << "Version string length is << " <<
 251         version_info.Version().length() << "which is longer than" <<
 252         kMaxVersionStringLength;
 253     return false;
 254   }
 255
 256   scoped_ptr<base::SharedMemory> shared_mem_service_data(
 257       new base::SharedMemory());
 258   if (!shared_mem_service_data.get())
 259     return false;
 260
 261   uint32 alloc_size = sizeof(ServiceProcessSharedData);
 262   // TODO(viettrungluu): Named shared memory is deprecated (crbug.com/345734).
 263   if (!shared_mem_service_data->CreateNamedDeprecated
 264           (GetServiceProcessSharedMemName(), true, alloc_size))
 265     return false;
 266
 267   if (!shared_mem_service_data->Map(alloc_size))
 268     return false;
 269
 270   memset(shared_mem_service_data->memory(), 0, alloc_size);
 271   ServiceProcessSharedData* shared_data =
 272       reinterpret_cast<ServiceProcessSharedData*>(
 273           shared_mem_service_data->memory());
 274   memcpy(shared_data->service_process_version, version_info.Version().c_str(),
 275          version_info.Version().length());
 276   shared_data->service_process_pid = base::GetCurrentProcId();
 277   shared_mem_service_data_.reset(shared_mem_service_data.release());
 278   return true;
 279 }
 280
 281 IPC::ChannelHandle ServiceProcessState::GetServiceProcessChannel() {
 282   return ::GetServiceProcessChannel();
 283 }
 284
 285 #endif  // !OS_MACOSX