cloud_print/common/win/install_utils.cc

   1 // Copyright 2013 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 "cloud_print/common/win/install_utils.h"
   6
   7 #include <windows.h>
   8
   9 #include "base/command_line.h"
  10 #include "base/file_version_info_win.h"
  11 #include "base/files/file_path.h"
  12 #include "base/files/file_util.h"
  13 #include "base/path_service.h"
  14 #include "base/process/launch.h"
  15 #include "base/win/registry.h"
  16 #include "cloud_print/common/win/cloud_print_utils.h"
  17
  18 namespace cloud_print {
  19
  20 namespace {
  21
  22 // Google Update related constants.
  23 const wchar_t kClientsKey[] = L"SOFTWARE\\Google\\Update\\Clients\\";
  24 const wchar_t kClientStateKey[] = L"SOFTWARE\\Google\\Update\\ClientState\\";
  25 const wchar_t* kUsageKey = L"dr";
  26 const wchar_t kVersionKey[] = L"pv";
  27 const wchar_t kNameKey[] = L"name";
  28
  29 enum InstallerResult {
  30   INSTALLER_RESULT_FAILED_CUSTOM_ERROR = 1,
  31   INSTALLER_RESULT_FAILED_SYSTEM_ERROR = 3,
  32 };
  33
  34 const wchar_t kRegValueInstallerResult[] = L"InstallerResult";
  35 const wchar_t kRegValueInstallerResultUIString[] = L"InstallerResultUIString";
  36 const wchar_t kRegValueInstallerError[] = L"InstallerError";
  37
  38 // Uninstall related constants.
  39 const wchar_t kUninstallKey[] =
  40     L"Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\";
  41 const wchar_t kInstallLocation[] = L"InstallLocation";
  42 const wchar_t kUninstallString[] = L"UninstallString";
  43 const wchar_t kDisplayVersion[] = L"DisplayVersion";
  44 const wchar_t kDisplayIcon[] = L"DisplayIcon";
  45 const wchar_t kDisplayName[] = L"DisplayName";
  46 const wchar_t kPublisher[] = L"Publisher";
  47 const wchar_t kNoModify[] = L"NoModify";
  48 const wchar_t kNoRepair[] = L"NoRepair";
  49
  50 }  // namespace
  51
  52
  53 void SetGoogleUpdateKeys(const base::string16& product_id,
  54                          const base::string16& product_name) {
  55   base::win::RegKey key;
  56   if (key.Create(HKEY_LOCAL_MACHINE,
  57                  (cloud_print::kClientsKey + product_id).c_str(),
  58                  KEY_SET_VALUE) != ERROR_SUCCESS) {
  59     LOG(ERROR) << "Unable to open key";
  60   }
  61
  62   // Get the version from the resource file.
  63   base::string16 version_string;
  64   scoped_ptr<FileVersionInfo> version_info(
  65       FileVersionInfo::CreateFileVersionInfoForCurrentModule());
  66
  67   if (version_info.get()) {
  68     FileVersionInfoWin* version_info_win =
  69         static_cast<FileVersionInfoWin*>(version_info.get());
  70     version_string = version_info_win->product_version();
  71   } else {
  72     LOG(ERROR) << "Unable to get version string";
  73     // Use a random version string so that Google Update has something to go by.
  74     version_string = L"0.0.0.99";
  75   }
  76
  77   if (key.WriteValue(kVersionKey, version_string.c_str()) != ERROR_SUCCESS ||
  78       key.WriteValue(kNameKey, product_name.c_str()) != ERROR_SUCCESS) {
  79     LOG(ERROR) << "Unable to set registry keys";
  80   }
  81 }
  82
  83 void SetGoogleUpdateError(const base::string16& product_id,
  84                           const base::string16& message) {
  85   LOG(ERROR) << message;
  86   base::win::RegKey key;
  87   if (key.Create(HKEY_LOCAL_MACHINE,
  88                  (cloud_print::kClientStateKey + product_id).c_str(),
  89                  KEY_SET_VALUE) != ERROR_SUCCESS) {
  90     LOG(ERROR) << "Unable to open key";
  91   }
  92
  93   if (key.WriteValue(kRegValueInstallerResult,
  94                      INSTALLER_RESULT_FAILED_CUSTOM_ERROR) != ERROR_SUCCESS ||
  95       key.WriteValue(kRegValueInstallerResultUIString,
  96                      message.c_str()) != ERROR_SUCCESS) {
  97       LOG(ERROR) << "Unable to set registry keys";
  98   }
  99 }
 100
 101 void SetGoogleUpdateError(const base::string16& product_id, HRESULT hr) {
 102   LOG(ERROR) << cloud_print::GetErrorMessage(hr);
 103   base::win::RegKey key;
 104   if (key.Create(HKEY_LOCAL_MACHINE,
 105     (cloud_print::kClientStateKey + product_id).c_str(),
 106     KEY_SET_VALUE) != ERROR_SUCCESS) {
 107     LOG(ERROR) << "Unable to open key";
 108   }
 109
 110   if (key.WriteValue(kRegValueInstallerResult,
 111                      INSTALLER_RESULT_FAILED_SYSTEM_ERROR) != ERROR_SUCCESS ||
 112       key.WriteValue(kRegValueInstallerError, hr) != ERROR_SUCCESS) {
 113     LOG(ERROR) << "Unable to set registry keys";
 114   }
 115 }
 116
 117 void DeleteGoogleUpdateKeys(const base::string16& product_id) {
 118   base::win::RegKey key;
 119   if (key.Open(HKEY_LOCAL_MACHINE,
 120                (cloud_print::kClientsKey + product_id).c_str(),
 121                DELETE) != ERROR_SUCCESS) {
 122     LOG(ERROR) << "Unable to open key to delete";
 123     return;
 124   }
 125   if (key.DeleteKey(L"") != ERROR_SUCCESS) {
 126     LOG(ERROR) << "Unable to delete key";
 127   }
 128 }
 129
 130 void CreateUninstallKey(const base::string16& uninstall_id,
 131                         const base::string16& product_name,
 132                         const std::string& uninstall_switch) {
 133   // Now write the Windows Uninstall entries
 134   // Minimal error checking here since the install can continue
 135   // if this fails.
 136   base::win::RegKey key;
 137   if (key.Create(HKEY_LOCAL_MACHINE,
 138                  (cloud_print::kUninstallKey + uninstall_id).c_str(),
 139                  KEY_SET_VALUE) != ERROR_SUCCESS) {
 140     LOG(ERROR) << "Unable to open key";
 141     return;
 142   }
 143
 144   base::FilePath unstall_binary;
 145   CHECK(PathService::Get(base::FILE_EXE, &unstall_binary));
 146
 147   base::CommandLine uninstall_command(unstall_binary);
 148   uninstall_command.AppendSwitch(uninstall_switch);
 149   key.WriteValue(kUninstallString,
 150                  uninstall_command.GetCommandLineString().c_str());
 151   key.WriteValue(kInstallLocation,
 152                  unstall_binary.DirName().value().c_str());
 153
 154   // Get the version resource.
 155   scoped_ptr<FileVersionInfo> version_info(
 156       FileVersionInfo::CreateFileVersionInfoForCurrentModule());
 157
 158   if (version_info.get()) {
 159     FileVersionInfoWin* version_info_win =
 160         static_cast<FileVersionInfoWin*>(version_info.get());
 161     key.WriteValue(kDisplayVersion,
 162                    version_info_win->file_version().c_str());
 163     key.WriteValue(kPublisher, version_info_win->company_name().c_str());
 164   } else {
 165     LOG(ERROR) << "Unable to get version string";
 166   }
 167   key.WriteValue(kDisplayName, product_name.c_str());
 168   key.WriteValue(kDisplayIcon, unstall_binary.value().c_str());
 169   key.WriteValue(kNoModify, 1);
 170   key.WriteValue(kNoRepair, 1);
 171 }
 172
 173 void DeleteUninstallKey(const base::string16& uninstall_id) {
 174   ::RegDeleteKey(HKEY_LOCAL_MACHINE,
 175                  (cloud_print::kUninstallKey + uninstall_id).c_str());
 176 }
 177
 178 base::FilePath GetInstallLocation(const base::string16& uninstall_id) {
 179   base::win::RegKey key;
 180   if (key.Open(HKEY_LOCAL_MACHINE,
 181                (cloud_print::kUninstallKey + uninstall_id).c_str(),
 182                KEY_QUERY_VALUE) != ERROR_SUCCESS) {
 183     // Not installed.
 184     return base::FilePath();
 185   }
 186   base::string16 install_path_value;
 187   key.ReadValue(kInstallLocation, &install_path_value);
 188   return base::FilePath(install_path_value);
 189 }
 190
 191 void DeleteProgramDir(const std::string& delete_switch) {
 192   base::FilePath installer_source;
 193   if (!PathService::Get(base::FILE_EXE, &installer_source))
 194     return;
 195   // Deletes only subdirs of program files.
 196   if (!IsProgramsFilesParent(installer_source))
 197     return;
 198   base::FilePath temp_path;
 199   if (!base::CreateTemporaryFile(&temp_path))
 200     return;
 201   base::CopyFile(installer_source, temp_path);
 202   base::DeleteFileAfterReboot(temp_path);
 203   base::CommandLine command_line(temp_path);
 204   command_line.AppendSwitchPath(delete_switch, installer_source.DirName());
 205   base::LaunchOptions options;
 206   if (!base::LaunchProcess(command_line, options).IsValid()) {
 207     LOG(ERROR) << "Unable to launch child uninstall.";
 208   }
 209 }
 210
 211 bool IsProgramsFilesParent(const base::FilePath& path) {
 212   base::FilePath program_files;
 213   if (!PathService::Get(base::DIR_PROGRAM_FILESX86, &program_files))
 214     return false;
 215   return program_files.IsParent(path);
 216 }
 217
 218 }  // namespace cloud_print
 219