src/cloud_print/virtual_driver/win/install/setup.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 <comdef.h>
   6 #include <iomanip>
   7 #include <windows.h>
   8 #include <winspool.h>
   9 #include <setupapi.h>  // Must be included after windows.h
  10
  11 #include "base/at_exit.h"
  12 #include "base/command_line.h"
  13 #include "base/file_util.h"
  14 #include "base/file_version_info_win.h"
  15 #include "base/files/scoped_temp_dir.h"
  16 #include "base/logging.h"
  17 #include "base/path_service.h"
  18 #include "base/process/process.h"
  19 #include "base/process/launch.h"
  20 #include "base/strings/string16.h"
  21 #include "base/strings/string_util.h"
  22 #include "base/win/registry.h"
  23 #include "base/win/scoped_handle.h"
  24 #include "base/win/windows_version.h"
  25 #include "cloud_print/common/win/cloud_print_utils.h"
  26 #include "cloud_print/common/win/install_utils.h"
  27 #include "cloud_print/virtual_driver/win/virtual_driver_consts.h"
  28 #include "cloud_print/virtual_driver/win/virtual_driver_helpers.h"
  29 #include "grit/virtual_driver_setup_resources.h"
  30
  31 #include <strsafe.h>  // Must be after base headers to avoid deprecation
  32                       // warnings.
  33
  34 namespace cloud_print {
  35
  36 namespace {
  37
  38 const wchar_t kNameValue[] = L"GCP Virtual Driver";
  39 const wchar_t kUninstallId[] = L"{74AA24E0-AC50-4B28-BA46-9CF05467C9B7}";
  40 const wchar_t kInstallerName[] = L"virtual_driver_setup.exe";
  41 const wchar_t kGcpUrl[] = L"http://www.google.com/cloudprint";
  42
  43 const wchar_t kDataFileName[] = L"gcp_driver.gpd";
  44 const wchar_t kDriverName[] = L"MXDWDRV.DLL";
  45 const wchar_t kUiDriverName[] = L"UNIDRVUI.DLL";
  46 const wchar_t kHelpName[] = L"UNIDRV.HLP";
  47 const wchar_t* kDependencyList[] = {
  48   kDriverName,
  49   kHelpName,
  50   kUiDriverName,
  51   L"STDDTYPE.GDL",
  52   L"STDNAMES.GPD",
  53   L"STDSCHEM.GDL",
  54   L"STDSCHMX.GDL",
  55   L"UNIDRV.DLL",
  56   L"UNIRES.DLL",
  57   L"XPSSVCS.DLL",
  58 };
  59
  60 const char kDelete[] = "delete";
  61 const char kInstallSwitch[] = "install";
  62 const char kRegisterSwitch[] = "register";
  63 const char kUninstallSwitch[] = "uninstall";
  64 const char kUnregisterSwitch[] = "unregister";
  65
  66 base::FilePath GetSystemPath(const string16& binary) {
  67   base::FilePath path;
  68   if (!PathService::Get(base::DIR_SYSTEM, &path)) {
  69     LOG(ERROR) << "Unable to get system path.";
  70     return path;
  71   }
  72   return path.Append(binary);
  73 }
  74
  75 base::FilePath GetNativeSystemPath(const string16& binary) {
  76   if (!IsSystem64Bit())
  77     return GetSystemPath(binary);
  78   base::FilePath path;
  79   // Sysnative will bypass filesystem redirection and give us
  80   // the location of the 64bit system32 from a 32 bit process.
  81   if (!PathService::Get(base::DIR_WINDOWS, &path)) {
  82     LOG(ERROR) << "Unable to get windows path.";
  83     return path;
  84   }
  85   return path.Append(L"sysnative").Append(binary);
  86 }
  87
  88 void SpoolerServiceCommand(const char* command) {
  89   base::FilePath net_path = GetNativeSystemPath(L"net");
  90   if (net_path.empty())
  91     return;
  92   CommandLine command_line(net_path);
  93   command_line.AppendArg(command);
  94   command_line.AppendArg("spooler");
  95   command_line.AppendArg("/y");
  96
  97   base::LaunchOptions options;
  98   options.wait = true;
  99   options.start_hidden = true;
 100   LOG(INFO) << command_line.GetCommandLineString();
 101   base::LaunchProcess(command_line, options, NULL);
 102 }
 103
 104 HRESULT RegisterPortMonitor(bool install, const base::FilePath& install_path) {
 105   DCHECK(install || install_path.empty());
 106   base::FilePath target_path = GetNativeSystemPath(GetPortMonitorDllName());
 107   if (target_path.empty()) {
 108     LOG(ERROR) << "Unable to get port monitor target path.";
 109     return HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND);
 110   }
 111   if (install) {
 112     base::FilePath source_path =
 113         install_path.Append(GetPortMonitorDllName());
 114     if (!base::CopyFile(source_path, target_path)) {
 115       LOG(ERROR) << "Unable copy port monitor dll from " <<
 116           source_path.value() << " to " << target_path.value();
 117       return GetLastHResult();
 118     }
 119   } else if (!base::PathExists(target_path)) {
 120     // Already removed.  Just "succeed" silently.
 121     return S_OK;
 122   }
 123
 124   base::FilePath regsvr32_path = GetNativeSystemPath(L"regsvr32.exe");
 125   if (regsvr32_path.empty()) {
 126     LOG(ERROR) << "Can't find regsvr32.exe.";
 127     return HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND);
 128   }
 129
 130   CommandLine command_line(regsvr32_path);
 131   command_line.AppendArg("/s");
 132   if (!install) {
 133     command_line.AppendArg("/u");
 134   }
 135
 136   // Use system32 path here because otherwise ::AddMonitor would fail.
 137   command_line.AppendArgPath(GetSystemPath(GetPortMonitorDllName()));
 138
 139   base::LaunchOptions options;
 140   options.wait = true;
 141
 142   base::win::ScopedHandle regsvr32_handle;
 143   if (!base::LaunchProcess(command_line, options, regsvr32_handle.Receive())) {
 144     LOG(ERROR) << "Unable to launch regsvr32.exe.";
 145     return HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED);
 146   }
 147
 148   DWORD exit_code = S_OK;
 149   if (install) {
 150     if (!GetExitCodeProcess(regsvr32_handle, &exit_code)) {
 151       LOG(ERROR) << "Unable to get regsvr32.exe exit code.";
 152       return GetLastHResult();
 153     }
 154     if (exit_code != 0) {
 155       LOG(ERROR) << "Regsvr32.exe failed with " << exit_code;
 156       return HRESULT_FROM_WIN32(exit_code);
 157     }
 158   } else {
 159     if (!base::DeleteFile(target_path, false)) {
 160       SpoolerServiceCommand("stop");
 161       bool deleted = base::DeleteFile(target_path, false);
 162       SpoolerServiceCommand("start");
 163
 164       if(!deleted) {
 165         LOG(ERROR) << "Unable to delete " << target_path.value();
 166         return HRESULT_FROM_WIN32(ERROR_ACCESS_DENIED);
 167       }
 168     }
 169   }
 170   return S_OK;
 171 }
 172
 173 DWORDLONG GetVersionNumber() {
 174   DWORDLONG retval = 0;
 175   scoped_ptr<FileVersionInfo> version_info(
 176       FileVersionInfo::CreateFileVersionInfoForCurrentModule());
 177   if (version_info.get()) {
 178     FileVersionInfoWin* version_info_win =
 179         static_cast<FileVersionInfoWin*>(version_info.get());
 180     VS_FIXEDFILEINFO* fixed_file_info = version_info_win->fixed_file_info();
 181     retval = fixed_file_info->dwFileVersionMS;
 182     retval <<= 32;
 183     retval |= fixed_file_info->dwFileVersionLS;
 184   }
 185   return retval;
 186 }
 187
 188 UINT CALLBACK CabinetCallback(PVOID data,
 189                               UINT notification,
 190                               UINT_PTR param1,
 191                               UINT_PTR param2) {
 192   const base::FilePath* temp_path(
 193       reinterpret_cast<const base::FilePath*>(data));
 194   if (notification == SPFILENOTIFY_FILEINCABINET) {
 195     FILE_IN_CABINET_INFO* info =
 196         reinterpret_cast<FILE_IN_CABINET_INFO*>(param1);
 197     for (int i = 0; i < arraysize(kDependencyList); i++) {
 198       base::FilePath base_name(info->NameInCabinet);
 199       base_name = base_name.BaseName();
 200       if (base::FilePath::CompareEqualIgnoreCase(base_name.value().c_str(),
 201                                                  kDependencyList[i])) {
 202         StringCchCopy(info->FullTargetName, MAX_PATH,
 203                       temp_path->Append(kDependencyList[i]).value().c_str());
 204         return FILEOP_DOIT;
 205       }
 206     }
 207     return FILEOP_SKIP;
 208   }
 209   return NO_ERROR;
 210 }
 211
 212 void ReadyDriverDependencies(const base::FilePath& destination) {
 213   if (base::win::GetVersion() >= base::win::VERSION_VISTA) {
 214     // GetCorePrinterDrivers and GetPrinterDriverPackagePath only exist on
 215     // Vista and later. Winspool.drv must be delayloaded so these calls don't
 216     // create problems on XP.
 217     DWORD size = MAX_PATH;
 218     wchar_t package_path[MAX_PATH] = {0};
 219     CORE_PRINTER_DRIVER driver;
 220     GetCorePrinterDrivers(NULL, NULL, L"{D20EA372-DD35-4950-9ED8-A6335AFE79F5}",
 221                           1, &driver);
 222     GetPrinterDriverPackagePath(NULL, NULL, NULL, driver.szPackageID,
 223                                 package_path, MAX_PATH, &size);
 224     SetupIterateCabinet(package_path, 0, &CabinetCallback,
 225                         &base::FilePath(destination));
 226   } else {
 227     // Driver files are in the sp3 cab.
 228     base::FilePath package_path;
 229     PathService::Get(base::DIR_WINDOWS, &package_path);
 230     package_path = package_path.Append(L"Driver Cache\\i386\\sp3.cab");
 231     SetupIterateCabinet(package_path.value().c_str(), 0, &CabinetCallback,
 232                         &base::FilePath(destination));
 233
 234     // Copy the rest from the driver cache or system dir.
 235     base::FilePath driver_cache_path;
 236     PathService::Get(base::DIR_WINDOWS, &driver_cache_path);
 237     driver_cache_path = driver_cache_path.Append(L"Driver Cache\\i386");
 238     for (size_t i = 0; i < arraysize(kDependencyList); ++i) {
 239       base::FilePath dst_path = destination.Append(kDependencyList[i]);
 240       if (!base::PathExists(dst_path)) {
 241         base::FilePath src_path = driver_cache_path.Append(kDependencyList[i]);
 242         if (!base::PathExists(src_path))
 243           src_path = GetSystemPath(kDependencyList[i]);
 244         base::CopyFile(src_path, dst_path);
 245       }
 246     }
 247   }
 248 }
 249
 250 HRESULT InstallDriver(const base::FilePath& install_path) {
 251   base::ScopedTempDir temp_path;
 252   if (!temp_path.CreateUniqueTempDir())
 253     return HRESULT_FROM_WIN32(ERROR_CANNOT_MAKE);
 254   ReadyDriverDependencies(temp_path.path());
 255
 256   std::vector<string16> dependent_array;
 257   // Add all files. AddPrinterDriverEx will removes unnecessary.
 258   for (size_t i = 0; i < arraysize(kDependencyList); ++i) {
 259     base::FilePath file_path = temp_path.path().Append(kDependencyList[i]);
 260     if (base::PathExists(file_path))
 261       dependent_array.push_back(file_path.value());
 262     else
 263       LOG(WARNING) << "File is missing: " << file_path.BaseName().value();
 264   }
 265
 266   // Set up paths for the files we depend on.
 267   base::FilePath data_file = install_path.Append(kDataFileName);
 268   base::FilePath xps_path = temp_path.path().Append(kDriverName);
 269   base::FilePath ui_path = temp_path.path().Append(kUiDriverName);
 270   base::FilePath ui_help_path = temp_path.path().Append(kHelpName);
 271
 272   if (!base::PathExists(xps_path)) {
 273     SetGoogleUpdateError(kGoogleUpdateProductId,
 274                          LoadLocalString(IDS_ERROR_NO_XPS));
 275     return HRESULT_FROM_WIN32(ERROR_BAD_DRIVER);
 276   }
 277
 278   DRIVER_INFO_6 driver_info = {0};
 279   // Set up supported print system version.  Must be 3.
 280   driver_info.cVersion = 3;
 281
 282   // None of the print API structures likes constant strings even though they
 283   // don't modify the string.  const_casting is the cleanest option.
 284   driver_info.pDataFile = const_cast<LPWSTR>(data_file.value().c_str());
 285   driver_info.pHelpFile = const_cast<LPWSTR>(ui_help_path.value().c_str());
 286   driver_info.pDriverPath = const_cast<LPWSTR>(xps_path.value().c_str());
 287   driver_info.pConfigFile = const_cast<LPWSTR>(ui_path.value().c_str());
 288
 289   string16 dependent_files(JoinString(dependent_array, L'\n'));
 290   dependent_files.push_back(L'\n');
 291   std::replace(dependent_files.begin(), dependent_files.end(), L'\n', L'\0');
 292   driver_info.pDependentFiles = &dependent_files[0];
 293
 294   // Set up user visible strings.
 295   string16 manufacturer = LoadLocalString(IDS_GOOGLE);
 296   driver_info.pszMfgName = const_cast<LPWSTR>(manufacturer.c_str());
 297   driver_info.pszProvider = const_cast<LPWSTR>(manufacturer.c_str());
 298   driver_info.pszOEMUrl = const_cast<LPWSTR>(kGcpUrl);
 299   driver_info.dwlDriverVersion = GetVersionNumber();
 300   string16 driver_name = LoadLocalString(IDS_DRIVER_NAME);
 301   driver_info.pName = const_cast<LPWSTR>(driver_name.c_str());
 302
 303   if (!::AddPrinterDriverEx(NULL, 6, reinterpret_cast<BYTE*>(&driver_info),
 304                             APD_COPY_NEW_FILES | APD_COPY_FROM_DIRECTORY)) {
 305     LOG(ERROR) << "Unable to add printer driver";
 306     return GetLastHResult();
 307   }
 308   return S_OK;
 309 }
 310
 311 HRESULT UninstallDriver() {
 312   int tries = 3;
 313   string16 driver_name = LoadLocalString(IDS_DRIVER_NAME);
 314   while (!DeletePrinterDriverEx(NULL,
 315                                 NULL,
 316                                 const_cast<LPWSTR>(driver_name.c_str()),
 317                                 DPD_DELETE_UNUSED_FILES,
 318                                 0) && tries > 0) {
 319     if (GetLastError() == ERROR_UNKNOWN_PRINTER_DRIVER) {
 320       LOG(WARNING) << "Print driver is already uninstalled.";
 321       return S_OK;
 322     }
 323     // After deleting the printer it can take a few seconds before
 324     // the driver is free for deletion.  Retry a few times before giving up.
 325     LOG(WARNING) << "Attempt to delete printer driver failed.  Retrying.";
 326     tries--;
 327     Sleep(2000);
 328   }
 329   if (tries <= 0) {
 330     HRESULT result = GetLastHResult();
 331     LOG(ERROR) << "Unable to delete printer driver.";
 332     return result;
 333   }
 334   return S_OK;
 335 }
 336
 337 HRESULT InstallPrinter(void) {
 338   PRINTER_INFO_2 printer_info = {0};
 339
 340   // None of the print API structures likes constant strings even though they
 341   // don't modify the string.  const_casting is the cleanest option.
 342   string16 driver_name = LoadLocalString(IDS_DRIVER_NAME);
 343   printer_info.pDriverName = const_cast<LPWSTR>(driver_name.c_str());
 344   printer_info.pPrinterName = const_cast<LPWSTR>(driver_name.c_str());
 345   printer_info.pComment =  const_cast<LPWSTR>(driver_name.c_str());
 346   printer_info.pLocation = const_cast<LPWSTR>(kGcpUrl);
 347   string16 port_name;
 348   printer_info.pPortName = const_cast<LPWSTR>(kPortName);
 349   printer_info.Attributes = PRINTER_ATTRIBUTE_DIRECT|PRINTER_ATTRIBUTE_LOCAL;
 350   printer_info.pPrintProcessor = L"winprint";
 351   HANDLE handle = AddPrinter(NULL, 2, reinterpret_cast<BYTE*>(&printer_info));
 352   if (handle == NULL) {
 353     HRESULT result = GetLastHResult();
 354     LOG(ERROR) << "Unable to add printer";
 355     return result;
 356   }
 357   ClosePrinter(handle);
 358   return S_OK;
 359 }
 360
 361 HRESULT UninstallPrinter(void) {
 362   HANDLE handle = NULL;
 363   PRINTER_DEFAULTS printer_defaults = {0};
 364   printer_defaults.DesiredAccess = PRINTER_ALL_ACCESS;
 365   string16 driver_name = LoadLocalString(IDS_DRIVER_NAME);
 366   if (!OpenPrinter(const_cast<LPWSTR>(driver_name.c_str()),
 367                    &handle,
 368                    &printer_defaults)) {
 369     // If we can't open the printer, it was probably already removed.
 370     LOG(WARNING) << "Unable to open printer";
 371     return S_OK;
 372   }
 373   if (!DeletePrinter(handle)) {
 374     HRESULT result = GetLastHResult();
 375     LOG(ERROR) << "Unable to delete printer";
 376     ClosePrinter(handle);
 377     return result;
 378   }
 379   ClosePrinter(handle);
 380   return S_OK;
 381 }
 382
 383 bool IsOSSupported() {
 384   // We don't support XP service pack 2 or older.
 385   base::win::Version version = base::win::GetVersion();
 386   return (version > base::win::VERSION_XP) ||
 387       ((version == base::win::VERSION_XP) &&
 388        (base::win::OSInfo::GetInstance()->service_pack().major >= 3));
 389 }
 390
 391 HRESULT RegisterVirtualDriver(const base::FilePath& install_path) {
 392   HRESULT result = S_OK;
 393
 394   DCHECK(base::DirectoryExists(install_path));
 395   if (!IsOSSupported()) {
 396     LOG(ERROR) << "Requires XP SP3 or later.";
 397     return HRESULT_FROM_WIN32(ERROR_OLD_WIN_VERSION);
 398   }
 399
 400   result = InstallDriver(install_path);
 401   if (FAILED(result)) {
 402     LOG(ERROR) << "Unable to install driver.";
 403     return result;
 404   }
 405
 406   result = RegisterPortMonitor(true, install_path);
 407   if (FAILED(result)) {
 408     LOG(ERROR) << "Unable to register port monitor.";
 409     return result;
 410   }
 411
 412   result = InstallPrinter();
 413   if (FAILED(result) &&
 414       result != HRESULT_FROM_WIN32(ERROR_PRINTER_ALREADY_EXISTS)) {
 415     LOG(ERROR) << "Unable to install printer.";
 416     return result;
 417   }
 418   return S_OK;
 419 }
 420
 421 HRESULT TryUnregisterVirtualDriver() {
 422   HRESULT result = S_OK;
 423   result = UninstallPrinter();
 424   if (FAILED(result)) {
 425     LOG(ERROR) << "Unable to delete printer.";
 426     return result;
 427   }
 428   result = UninstallDriver();
 429   if (FAILED(result)) {
 430     LOG(ERROR) << "Unable to remove driver.";
 431     return result;
 432   }
 433   // The second argument is ignored if the first is false.
 434   result = RegisterPortMonitor(false, base::FilePath());
 435   if (FAILED(result)) {
 436     LOG(ERROR) << "Unable to remove port monitor.";
 437     return result;
 438   }
 439   return S_OK;
 440 }
 441
 442 HRESULT UnregisterVirtualDriver() {
 443   HRESULT hr = S_FALSE;
 444   for (int i = 0; i < 2; ++i) {
 445     hr = TryUnregisterVirtualDriver();
 446     if (SUCCEEDED(hr)) {
 447       break;
 448     }
 449     // Restart spooler and try again.
 450     SpoolerServiceCommand("stop");
 451     SpoolerServiceCommand("start");
 452   }
 453   return hr;
 454 }
 455
 456 HRESULT DoUninstall() {
 457   DeleteGoogleUpdateKeys(kGoogleUpdateProductId);
 458   HRESULT result = UnregisterVirtualDriver();
 459   if (FAILED(result))
 460     return result;
 461   DeleteUninstallKey(kUninstallId);
 462   DeleteProgramDir(kDelete);
 463   return S_OK;
 464 }
 465
 466 HRESULT DoUnregister() {
 467   return UnregisterVirtualDriver();
 468 }
 469
 470 HRESULT DoRegister(const base::FilePath& install_path) {
 471   HRESULT result = UnregisterVirtualDriver();
 472   if (FAILED(result))
 473     return result;
 474   return RegisterVirtualDriver(install_path);
 475 }
 476
 477 HRESULT DoDelete(const base::FilePath& install_path) {
 478   if (install_path.value().empty())
 479     return E_INVALIDARG;
 480   if (!base::DirectoryExists(install_path))
 481     return S_FALSE;
 482   Sleep(5000);  // Give parent some time to exit.
 483   return base::DeleteFile(install_path, true) ? S_OK : E_FAIL;
 484 }
 485
 486 HRESULT DoInstall(const base::FilePath& install_path) {
 487   HRESULT result = UnregisterVirtualDriver();
 488   if (FAILED(result)) {
 489     LOG(ERROR) << "Unable to unregister.";
 490     return result;
 491   }
 492   base::FilePath old_install_path = GetInstallLocation(kUninstallId);
 493   if (!old_install_path.value().empty() &&
 494       install_path != old_install_path) {
 495     if (base::DirectoryExists(old_install_path))
 496       base::DeleteFile(old_install_path, true);
 497   }
 498   CreateUninstallKey(kUninstallId, LoadLocalString(IDS_DRIVER_NAME),
 499                      kUninstallSwitch);
 500   result = RegisterVirtualDriver(install_path);
 501   if (FAILED(result))
 502     return result;
 503   SetGoogleUpdateKeys(kGoogleUpdateProductId, kNameValue);
 504   return result;
 505 }
 506
 507 HRESULT ExecuteCommands() {
 508   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
 509
 510   base::FilePath exe_path;
 511   if (FAILED(PathService::Get(base::DIR_EXE, &exe_path)) ||
 512       !base::DirectoryExists(exe_path)) {
 513     return HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND);
 514   }
 515
 516   if (command_line.HasSwitch(kDelete)) {
 517     return DoDelete(command_line.GetSwitchValuePath(kDelete));
 518   } else if (command_line.HasSwitch(kUninstallSwitch)) {
 519     return DoUninstall();
 520   } else if (command_line.HasSwitch(kInstallSwitch)) {
 521     return DoInstall(exe_path);
 522   } else if (command_line.HasSwitch(kUnregisterSwitch)) {
 523     return DoUnregister();
 524   } else if (command_line.HasSwitch(kRegisterSwitch)) {
 525     return DoRegister(exe_path);
 526   }
 527
 528   return E_INVALIDARG;
 529 }
 530
 531 }  // namespace
 532
 533 }  // namespace cloud_print
 534
 535 int WINAPI WinMain(__in  HINSTANCE hInstance,
 536                    __in  HINSTANCE hPrevInstance,
 537                    __in  LPSTR lpCmdLine,
 538                    __in  int nCmdShow) {
 539   base::AtExitManager at_exit_manager;
 540   CommandLine::Init(0, NULL);
 541   HRESULT retval = cloud_print::ExecuteCommands();
 542
 543   LOG(INFO) << _com_error(retval).ErrorMessage() << " HRESULT=0x" <<
 544                std::setbase(16) << retval;
 545
 546   // Installer is silent by default as required by Google Update.
 547   if (CommandLine::ForCurrentProcess()->HasSwitch("verbose")) {
 548     cloud_print::DisplayWindowsMessage(NULL, retval,
 549         cloud_print::LoadLocalString(IDS_DRIVER_NAME));
 550   }
 551   return retval;
 552 }