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