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