// Copyright (c) 2010 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. #include #include #include #include #include #include "base/at_exit.h" #include "base/basictypes.h" #include "base/command_line.h" #include "base/file_util.h" #include "base/path_service.h" #include "base/process_util.h" #include "base/scoped_handle_win.h" #include "base/string_number_conversions.h" #include "base/string_util.h" #include "base/utf_string_conversions.h" #include "base/values.h" #include "base/win_util.h" #include "chrome/common/chrome_switches.h" #include "chrome/installer/setup/install.h" #include "chrome/installer/setup/setup_constants.h" #include "chrome/installer/setup/setup_util.h" #include "chrome/installer/setup/uninstall.h" #include "chrome/installer/util/browser_distribution.h" #include "chrome/installer/util/delete_after_reboot_helper.h" #include "chrome/installer/util/delete_tree_work_item.h" #include "chrome/installer/util/helper.h" #include "chrome/installer/util/html_dialog.h" #include "chrome/installer/util/install_util.h" #include "chrome/installer/util/l10n_string_util.h" #include "chrome/installer/util/logging_installer.h" #include "chrome/installer/util/lzma_util.h" #include "chrome/installer/util/google_update_settings.h" #include "chrome/installer/util/google_update_constants.h" #include "chrome/installer/util/master_preferences.h" #include "chrome/installer/util/shell_util.h" #include "chrome/installer/util/util_constants.h" #include "installer_util_strings.h" namespace { // This method unpacks and uncompresses the given archive file. For Chrome // install we are creating a uncompressed archive that contains all the files // needed for the installer. This uncompressed archive is later compressed. // // This method first uncompresses archive specified by parameter "archive" // and assumes that it will result in an uncompressed full archive file // (chrome.7z) or uncompressed archive patch file (chrome_patch.diff). If it // is patch file, it is applied to the old archive file that should be // present on the system already. As the final step the new archive file // is unpacked in the path specified by parameter "path". DWORD UnPackArchive(const std::wstring& archive, bool system_install, const installer::Version* installed_version, const std::wstring& temp_path, const std::wstring& path, bool& incremental_install) { // First uncompress the payload. This could be a differential // update (patch.7z) or full archive (chrome.7z). If this uncompress fails // return with error. std::wstring unpacked_file; int32 ret = LzmaUtil::UnPackArchive(archive, temp_path, &unpacked_file); if (ret != NO_ERROR) return ret; std::wstring uncompressed_archive(temp_path); file_util::AppendToPath(&uncompressed_archive, installer::kChromeArchive); // Check if this is differential update and if it is, patch it to the // installer archive that should already be on the machine. We assume // it is a differential installer if chrome.7z is not found. if (!file_util::PathExists(FilePath::FromWStringHack(uncompressed_archive))) { incremental_install = true; LOG(INFO) << "Differential patch found. Applying to existing archive."; if (!installed_version) { LOG(ERROR) << "Can not use differential update when Chrome is not " << "installed on the system."; return installer_util::CHROME_NOT_INSTALLED; } std::wstring existing_archive = installer::GetChromeInstallPath(system_install); file_util::AppendToPath(&existing_archive, installed_version->GetString()); file_util::AppendToPath(&existing_archive, installer_util::kInstallerDir); file_util::AppendToPath(&existing_archive, installer::kChromeArchive); if (int i = setup_util::ApplyDiffPatch(existing_archive, unpacked_file, uncompressed_archive)) { LOG(ERROR) << "Binary patching failed with error " << i; return i; } } // Unpack the uncompressed archive. return LzmaUtil::UnPackArchive(uncompressed_archive, path, &unpacked_file); } // This function is called when --rename-chrome-exe option is specified on // setup.exe command line. This function assumes an in-use update has happened // for Chrome so there should be a file called new_chrome.exe on the file // system and a key called 'opv' in the registry. This function will move // new_chrome.exe to chrome.exe and delete 'opv' key in one atomic operation. installer_util::InstallStatus RenameChromeExecutables(bool system_install) { std::wstring chrome_path(installer::GetChromeInstallPath(system_install)); std::wstring chrome_exe(chrome_path); file_util::AppendToPath(&chrome_exe, installer_util::kChromeExe); std::wstring chrome_old_exe(chrome_path); file_util::AppendToPath(&chrome_old_exe, installer_util::kChromeOldExe); std::wstring chrome_new_exe(chrome_path); file_util::AppendToPath(&chrome_new_exe, installer_util::kChromeNewExe); scoped_ptr install_list(WorkItem::CreateWorkItemList()); install_list->AddDeleteTreeWorkItem(chrome_old_exe, std::wstring()); FilePath temp_path; if (!file_util::CreateNewTempDirectory(L"chrome_", &temp_path)) { LOG(ERROR) << "Failed to create Temp directory " << temp_path.value(); return installer_util::RENAME_FAILED; } install_list->AddCopyTreeWorkItem(chrome_new_exe, chrome_exe, temp_path.ToWStringHack(), WorkItem::IF_DIFFERENT, std::wstring()); HKEY reg_root = system_install ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER; BrowserDistribution *dist = BrowserDistribution::GetDistribution(); install_list->AddDeleteRegValueWorkItem(reg_root, dist->GetVersionKey(), google_update::kRegOldVersionField, true); install_list->AddDeleteTreeWorkItem(chrome_new_exe, std::wstring()); install_list->AddDeleteRegValueWorkItem(reg_root, dist->GetVersionKey(), google_update::kRegRenameCmdField, true); installer_util::InstallStatus ret = installer_util::RENAME_SUCCESSFUL; if (!install_list->Do()) { LOG(ERROR) << "Renaming of executables failed. Rolling back any changes."; install_list->Rollback(); ret = installer_util::RENAME_FAILED; } file_util::Delete(temp_path, true); return ret; } bool CheckPreInstallConditions(const installer::Version* installed_version, bool system_install, installer_util::InstallStatus& status) { bool is_first_install = (NULL == installed_version); // Check to avoid simultaneous per-user and per-machine installs. scoped_ptr chrome_version(InstallUtil::GetChromeVersion(!system_install)); if (chrome_version.get()) { LOG(ERROR) << "Already installed version " << chrome_version->GetString() << " conflicts with the current install mode."; if (!system_install && is_first_install) { // This is user-level install and there is a system-level chrome // installation. Instruct omaha to launch the existing one. There // should be no error dialog. std::wstring chrome_exe(installer::GetChromeInstallPath(!system_install)); if (chrome_exe.empty()) { // If we failed to construct install path. Give up. status = installer_util::OS_ERROR; InstallUtil::WriteInstallerResult(system_install, status, IDS_INSTALL_OS_ERROR_BASE, NULL); return false; } else { status = installer_util::EXISTING_VERSION_LAUNCHED; file_util::AppendToPath(&chrome_exe, installer_util::kChromeExe); chrome_exe = L"\"" + chrome_exe + L"\" --" + ASCIIToWide(switches::kFirstRun); InstallUtil::WriteInstallerResult(system_install, status, 0, NULL); LOG(INFO) << "Launching existing system-level chrome instead."; base::LaunchApp(chrome_exe, false, false, NULL); return false; } } // If the following compile assert fires it means that the InstallStatus // enumeration changed which will break the contract between the old chrome // installed and the new setup.exe that is trying to upgrade. COMPILE_ASSERT(installer_util::SXS_OPTION_NOT_SUPPORTED == 33, dont_change_enum); // This is an update, not an install. Omaha should know the difference // and not show a dialog. status = system_install ? installer_util::USER_LEVEL_INSTALL_EXISTS : installer_util::SYSTEM_LEVEL_INSTALL_EXISTS; int str_id = system_install ? IDS_INSTALL_USER_LEVEL_EXISTS_BASE : IDS_INSTALL_SYSTEM_LEVEL_EXISTS_BASE; InstallUtil::WriteInstallerResult(system_install, status, str_id, NULL); return false; } // If no previous installation of Chrome, make sure installation directory // either does not exist or can be deleted (i.e. is not locked by some other // process). if (is_first_install) { FilePath install_path = FilePath::FromWStringHack( installer::GetChromeInstallPath(system_install)); if (file_util::PathExists(install_path) && !file_util::Delete(install_path, true)) { LOG(ERROR) << "Installation directory " << install_path.value() << " exists and can not be deleted."; status = installer_util::INSTALL_DIR_IN_USE; int str_id = IDS_INSTALL_DIR_IN_USE_BASE; InstallUtil::WriteInstallerResult(system_install, status, str_id, NULL); return false; } } return true; } installer_util::InstallStatus InstallChrome(const CommandLine& cmd_line, const installer::Version* installed_version, const DictionaryValue* prefs) { bool system_level = false; installer_util::GetDistroBooleanPreference(prefs, installer_util::master_preferences::kSystemLevel, &system_level); installer_util::InstallStatus install_status = installer_util::UNKNOWN_STATUS; if (!CheckPreInstallConditions(installed_version, system_level, install_status)) return install_status; // For install the default location for chrome.packed.7z is in current // folder, so get that value first. std::wstring archive = file_util::GetDirectoryFromPath(cmd_line.program()); file_util::AppendToPath(&archive, std::wstring(installer::kChromeCompressedArchive)); // If --install-archive is given, get the user specified value if (cmd_line.HasSwitch(installer_util::switches::kInstallArchive)) { archive = cmd_line.GetSwitchValueNative( installer_util::switches::kInstallArchive); } LOG(INFO) << "Archive found to install Chrome " << archive; // Create a temp folder where we will unpack Chrome archive. If it fails, // then we are doomed, so return immediately and no cleanup is required. FilePath temp_path; if (!file_util::CreateNewTempDirectory(L"chrome_", &temp_path)) { LOG(ERROR) << "Could not create temporary path."; InstallUtil::WriteInstallerResult(system_level, installer_util::TEMP_DIR_FAILED, IDS_INSTALL_TEMP_DIR_FAILED_BASE, NULL); return installer_util::TEMP_DIR_FAILED; } LOG(INFO) << "created path " << temp_path.value(); BrowserDistribution* dist = BrowserDistribution::GetDistribution(); std::wstring unpack_path(temp_path.ToWStringHack()); file_util::AppendToPath(&unpack_path, std::wstring(installer::kInstallSourceDir)); bool incremental_install = false; if (UnPackArchive(archive, system_level, installed_version, temp_path.ToWStringHack(), unpack_path, incremental_install)) { install_status = installer_util::UNCOMPRESSION_FAILED; InstallUtil::WriteInstallerResult(system_level, install_status, IDS_INSTALL_UNCOMPRESSION_FAILED_BASE, NULL); } else { LOG(INFO) << "unpacked to " << unpack_path; std::wstring src_path(unpack_path); file_util::AppendToPath(&src_path, std::wstring(installer::kInstallSourceChromeDir)); scoped_ptr installer_version(setup_util::GetVersionFromDir(src_path)); if (!installer_version.get()) { LOG(ERROR) << "Did not find any valid version in installer."; install_status = installer_util::INVALID_ARCHIVE; InstallUtil::WriteInstallerResult(system_level, install_status, IDS_INSTALL_INVALID_ARCHIVE_BASE, NULL); } else { LOG(INFO) << "version to install: " << installer_version->GetString(); if (installed_version && installed_version->IsHigherThan(installer_version.get())) { LOG(ERROR) << "Higher version is already installed."; install_status = installer_util::HIGHER_VERSION_EXISTS; InstallUtil::WriteInstallerResult(system_level, install_status, IDS_INSTALL_HIGHER_VERSION_BASE, NULL); } else { // We want to keep uncompressed archive (chrome.7z) that we get after // uncompressing and binary patching. Get the location for this file. std::wstring archive_to_copy(temp_path.ToWStringHack()); file_util::AppendToPath(&archive_to_copy, installer::kChromeArchive); std::wstring prefs_source_path = cmd_line.GetSwitchValueNative( installer_util::switches::kInstallerData); install_status = installer::InstallOrUpdateChrome( cmd_line.program(), archive_to_copy, temp_path.ToWStringHack(), prefs_source_path, prefs, *installer_version, installed_version); int install_msg_base = IDS_INSTALL_FAILED_BASE; std::wstring chrome_exe; if (install_status == installer_util::SAME_VERSION_REPAIR_FAILED) { install_msg_base = IDS_SAME_VERSION_REPAIR_FAILED_BASE; } else if (install_status != installer_util::INSTALL_FAILED) { chrome_exe = installer::GetChromeInstallPath(system_level); if (chrome_exe.empty()) { // If we failed to construct install path, it means the OS call to // get %ProgramFiles% or %AppData% failed. Report this as failure. install_msg_base = IDS_INSTALL_OS_ERROR_BASE; install_status = installer_util::OS_ERROR; } else { file_util::AppendToPath(&chrome_exe, installer_util::kChromeExe); chrome_exe = L"\"" + chrome_exe + L"\""; install_msg_base = 0; } } bool value = false; installer_util::GetDistroBooleanPreference(prefs, installer_util::master_preferences::kDoNotRegisterForUpdateLaunch, &value); bool write_chrome_launch_string = (!value) && (install_status != installer_util::IN_USE_UPDATED); InstallUtil::WriteInstallerResult(system_level, install_status, install_msg_base, write_chrome_launch_string ? &chrome_exe : NULL); if (install_status == installer_util::FIRST_INSTALL_SUCCESS) { LOG(INFO) << "First install successful."; // We never want to launch Chrome in system level install mode. bool do_not_launch_chrome = false; installer_util::GetDistroBooleanPreference(prefs, installer_util::master_preferences::kDoNotLaunchChrome, &do_not_launch_chrome); if (!system_level && !do_not_launch_chrome) installer::LaunchChrome(system_level); } else if ((install_status == installer_util::NEW_VERSION_UPDATED) || (install_status == installer_util::IN_USE_UPDATED)) { installer_setup::RemoveLegacyRegistryKeys(); } } } // There might be an experiment (for upgrade usually) that needs to happen. // An experiment's outcome can include chrome's uninstallation. If that is // the case we would not do that directly at this point but in another // instance of setup.exe // // There is another way to reach this same function if this is a system // level install. See HandleNonInstallCmdLineOptions(). dist->LaunchUserExperiment(install_status, *installer_version, system_level); } // Delete temporary files. These include install temporary directory // and master profile file if present. Note that we do not care about rollback // here and we schedule for deletion on reboot below if the deletes fail. As // such, we do not use DeleteTreeWorkItem. LOG(INFO) << "Deleting temporary directory " << temp_path.value(); bool cleanup_success = file_util::Delete(temp_path, true); if (cmd_line.HasSwitch(installer_util::switches::kInstallerData)) { std::wstring prefs_path = cmd_line.GetSwitchValueNative( installer_util::switches::kInstallerData); cleanup_success = file_util::Delete(prefs_path, true) && cleanup_success; } // The above cleanup has been observed to fail on several users machines. // Specifically, it appears that the temp folder may be locked when we try // to delete it. This is Rather Bad in the case where we have failed updates // as we end up filling users' disks with large-ish temp files. To mitigate // this, if we fail to delete the temp folders, then schedule them for // deletion at next reboot. if (!cleanup_success) { ScheduleDirectoryForDeletion(temp_path.ToWStringHack().c_str()); if (cmd_line.HasSwitch(installer_util::switches::kInstallerData)) { std::wstring prefs_path = cmd_line.GetSwitchValueNative( installer_util::switches::kInstallerData); ScheduleDirectoryForDeletion(prefs_path.c_str()); } } dist->UpdateDiffInstallStatus(system_level, incremental_install, install_status); return install_status; } installer_util::InstallStatus UninstallChrome(const CommandLine& cmd_line, const wchar_t* cmd_params, const installer::Version* version, bool system_install) { LOG(INFO) << "Uninstalling Chome"; bool force = cmd_line.HasSwitch(installer_util::switches::kForceUninstall); if (!version && !force) { LOG(ERROR) << "No Chrome installation found for uninstall."; InstallUtil::WriteInstallerResult(system_install, installer_util::CHROME_NOT_INSTALLED, IDS_UNINSTALL_FAILED_BASE, NULL); return installer_util::CHROME_NOT_INSTALLED; } bool remove_all = !cmd_line.HasSwitch( installer_util::switches::kDoNotRemoveSharedItems); return installer_setup::UninstallChrome(cmd_line.program(), system_install, remove_all, force, cmd_line, cmd_params); } installer_util::InstallStatus ShowEULADialog(const std::wstring& inner_frame) { LOG(INFO) << "About to show EULA"; std::wstring eula_path = installer_util::GetLocalizedEulaResource(); if (eula_path.empty()) { LOG(ERROR) << "No EULA path available"; return installer_util::EULA_REJECTED; } // Newer versions of the caller pass an inner frame parameter that must // be given to the html page being launched. if (!inner_frame.empty()) { eula_path += L"?innerframe="; eula_path += inner_frame; } installer::EulaHTMLDialog dlg(eula_path); installer::EulaHTMLDialog::Outcome outcome = dlg.ShowModal(); if (installer::EulaHTMLDialog::REJECTED == outcome) { LOG(ERROR) << "EULA rejected or EULA failure"; return installer_util::EULA_REJECTED; } if (installer::EulaHTMLDialog::ACCEPTED_OPT_IN == outcome) { LOG(INFO) << "EULA accepted (opt-in)"; return installer_util::EULA_ACCEPTED_OPT_IN; } LOG(INFO) << "EULA accepted (no opt-in)"; return installer_util::EULA_ACCEPTED; } // This method processes any command line options that make setup.exe do // various tasks other than installation (renaming chrome.exe, showing eula // among others). This function returns true if any such command line option // has been found and processed (so setup.exe should exit at that point). bool HandleNonInstallCmdLineOptions(const CommandLine& cmd_line, bool system_install, int& exit_code) { BrowserDistribution* dist = BrowserDistribution::GetDistribution(); if (cmd_line.HasSwitch(installer_util::switches::kUpdateSetupExe)) { installer_util::InstallStatus status = installer_util::SETUP_PATCH_FAILED; // If --update-setup-exe command line option is given, we apply the given // patch to current exe, and store the resulting binary in the path // specified by --new-setup-exe. But we need to first unpack the file // given in --update-setup-exe. FilePath temp_path; if (!file_util::CreateNewTempDirectory(L"chrome_", &temp_path)) { LOG(ERROR) << "Could not create temporary path."; } else { std::wstring setup_patch = cmd_line.GetSwitchValueNative( installer_util::switches::kUpdateSetupExe); LOG(INFO) << "Opening archive " << setup_patch; std::wstring uncompressed_patch; if (LzmaUtil::UnPackArchive(setup_patch, temp_path.ToWStringHack(), &uncompressed_patch) == NO_ERROR) { std::wstring old_setup_exe = cmd_line.program(); std::wstring new_setup_exe = cmd_line.GetSwitchValueNative( installer_util::switches::kNewSetupExe); if (!setup_util::ApplyDiffPatch(old_setup_exe, uncompressed_patch, new_setup_exe)) status = installer_util::NEW_VERSION_UPDATED; } } exit_code = dist->GetInstallReturnCode(status); if (exit_code) { LOG(WARNING) << "setup.exe patching failed."; InstallUtil::WriteInstallerResult(system_install, status, IDS_SETUP_PATCH_FAILED_BASE, NULL); } file_util::Delete(temp_path, true); return true; } else if (cmd_line.HasSwitch(installer_util::switches::kShowEula)) { // Check if we need to show the EULA. If it is passed as a command line // then the dialog is shown and regardless of the outcome setup exits here. std::wstring inner_frame = cmd_line.GetSwitchValueNative(installer_util::switches::kShowEula); exit_code = ShowEULADialog(inner_frame); if (installer_util::EULA_REJECTED != exit_code) GoogleUpdateSettings::SetEULAConsent(true); return true; } else if (cmd_line.HasSwitch( installer_util::switches::kRegisterChromeBrowser)) { // If --register-chrome-browser option is specified, register all // Chrome protocol/file associations as well as register it as a valid // browser for Start Menu->Internet shortcut. This option should only // be used when setup.exe is launched with admin rights. We do not // make any user specific changes in this option. std::wstring chrome_exe(cmd_line.GetSwitchValueNative( installer_util::switches::kRegisterChromeBrowser)); std::wstring suffix; if (cmd_line.HasSwitch( installer_util::switches::kRegisterChromeBrowserSuffix)) { suffix = cmd_line.GetSwitchValueNative( installer_util::switches::kRegisterChromeBrowserSuffix); } exit_code = ShellUtil::RegisterChromeBrowser(chrome_exe, suffix, false); return true; } else if (cmd_line.HasSwitch(installer_util::switches::kRenameChromeExe)) { // If --rename-chrome-exe is specified, we want to rename the executables // and exit. exit_code = RenameChromeExecutables(system_install); return true; } else if (cmd_line.HasSwitch( installer_util::switches::kRemoveChromeRegistration)) { // This is almost reverse of --register-chrome-browser option above. // Here we delete Chrome browser registration. This option should only // be used when setup.exe is launched with admin rights. We do not // make any user specific changes in this option. std::wstring suffix; if (cmd_line.HasSwitch( installer_util::switches::kRegisterChromeBrowserSuffix)) { suffix = cmd_line.GetSwitchValueNative( installer_util::switches::kRegisterChromeBrowserSuffix); } installer_util::InstallStatus tmp = installer_util::UNKNOWN_STATUS; installer_setup::DeleteChromeRegistrationKeys(HKEY_LOCAL_MACHINE, suffix, tmp); exit_code = tmp; return true; } else if (cmd_line.HasSwitch(installer_util::switches::kInactiveUserToast)) { // Launch the inactive user toast experiment. std::string flavor = cmd_line.GetSwitchValueASCII( installer_util::switches::kInactiveUserToast); int flavor_int; base::StringToInt(flavor, &flavor_int); dist->InactiveUserToastExperiment(flavor_int, cmd_line.HasSwitch(installer_util::switches::kSystemLevelToast)); return true; } else if (cmd_line.HasSwitch(installer_util::switches::kSystemLevelToast)) { // We started as system-level and have been re-launched as user level // to continue with the toast experiment. scoped_ptr installed_version(InstallUtil::GetChromeVersion(system_install)); dist->LaunchUserExperiment(installer_util::REENTRY_SYS_UPDATE, *installed_version, true); return true; } return false; } bool ShowRebootDialog() { // Get a token for this process. HANDLE token; if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &token)) { LOG(ERROR) << "Failed to open token."; return false; } // Use a ScopedHandle to keep track of and eventually close our handle. // TODO(robertshield): Add a Receive() method to base's ScopedHandle. ScopedHandle scoped_handle(token); // Get the LUID for the shutdown privilege. TOKEN_PRIVILEGES tkp = {0}; LookupPrivilegeValue(NULL, SE_SHUTDOWN_NAME, &tkp.Privileges[0].Luid); tkp.PrivilegeCount = 1; tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED; // Get the shutdown privilege for this process. AdjustTokenPrivileges(token, FALSE, &tkp, 0, reinterpret_cast(NULL), 0); if (GetLastError() != ERROR_SUCCESS) { LOG(ERROR) << "Unable to get shutdown privileges."; return false; } // Popup a dialog that will prompt to reboot using the default system message. // TODO(robertshield): Add a localized, more specific string to the prompt. RestartDialog(NULL, NULL, EWX_REBOOT | EWX_FORCEIFHUNG); return true; } // Class to manage COM initialization and uninitialization class AutoCom { public: AutoCom() : initialized_(false) { } ~AutoCom() { if (initialized_) CoUninitialize(); } bool Init(bool system_install) { if (CoInitializeEx(NULL, COINIT_APARTMENTTHREADED) != S_OK) { LOG(ERROR) << "COM initialization failed."; InstallUtil::WriteInstallerResult(system_install, installer_util::OS_ERROR, IDS_INSTALL_OS_ERROR_BASE, NULL); return false; } initialized_ = true; return true; } private: bool initialized_; }; } // namespace int WINAPI wWinMain(HINSTANCE instance, HINSTANCE prev_instance, wchar_t* command_line, int show_command) { // The exit manager is in charge of calling the dtors of singletons. base::AtExitManager exit_manager; CommandLine::Init(0, NULL); CommandLine* mutable_command_line = CommandLine::ForCurrentProcess(); if (mutable_command_line->HasSwitch(installer_util::switches::kChromeFrame)) { mutable_command_line->AppendSwitch( WideToASCII(installer_util::switches::kDoNotCreateShortcuts)); mutable_command_line->AppendSwitch( WideToASCII(installer_util::switches::kDoNotLaunchChrome)); mutable_command_line->AppendSwitch( WideToASCII(installer_util::switches::kDoNotRegisterForUpdateLaunch)); } const CommandLine& parsed_command_line = *CommandLine::ForCurrentProcess(); installer::InitInstallerLogging(parsed_command_line); scoped_ptr prefs(installer_util::GetInstallPreferences( parsed_command_line)); bool value = false; if (installer_util::GetDistroBooleanPreference(prefs.get(), installer_util::master_preferences::kVerboseLogging, &value) && value) logging::SetMinLogLevel(logging::LOG_INFO); LOG(INFO) << "Command Line: " << parsed_command_line.command_line_string(); bool system_install = false; installer_util::GetDistroBooleanPreference(prefs.get(), installer_util::master_preferences::kSystemLevel, &system_install); LOG(INFO) << "system install is " << system_install; // Check to make sure current system is WinXP or later. If not, log // error message and get out. if (!InstallUtil::IsOSSupported()) { LOG(ERROR) << "Chrome only supports Windows XP or later."; InstallUtil::WriteInstallerResult(system_install, installer_util::OS_NOT_SUPPORTED, IDS_INSTALL_OS_NOT_SUPPORTED_BASE, NULL); return installer_util::OS_NOT_SUPPORTED; } // Initialize COM for use later. AutoCom auto_com; if (!auto_com.Init(system_install)) { return installer_util::OS_ERROR; } // Some command line options don't work with SxS install/uninstall if (InstallUtil::IsChromeSxSProcess()) { if (system_install || parsed_command_line.HasSwitch( installer_util::switches::kForceUninstall) || parsed_command_line.HasSwitch( installer_util::switches::kMakeChromeDefault) || parsed_command_line.HasSwitch( installer_util::switches::kRegisterChromeBrowser) || parsed_command_line.HasSwitch( installer_util::switches::kRemoveChromeRegistration) || parsed_command_line.HasSwitch( installer_util::switches::kInactiveUserToast) || parsed_command_line.HasSwitch( installer_util::switches::kSystemLevelToast)) { return installer_util::SXS_OPTION_NOT_SUPPORTED; } } int exit_code = 0; if (HandleNonInstallCmdLineOptions(parsed_command_line, system_install, exit_code)) return exit_code; if (system_install && !IsUserAnAdmin()) { if (win_util::GetWinVersion() >= win_util::WINVERSION_VISTA && !parsed_command_line.HasSwitch(installer_util::switches::kRunAsAdmin)) { std::wstring exe = parsed_command_line.program(); std::wstring params(command_line); // Append --run-as-admin flag to let the new instance of setup.exe know // that we already tried to launch ourselves as admin. params.append(L" --"); params.append(installer_util::switches::kRunAsAdmin); DWORD exit_code = installer_util::UNKNOWN_STATUS; InstallUtil::ExecuteExeAsAdmin(exe, params, &exit_code); return exit_code; } else { LOG(ERROR) << "Non admin user can not install system level Chrome."; InstallUtil::WriteInstallerResult(system_install, installer_util::INSUFFICIENT_RIGHTS, IDS_INSTALL_INSUFFICIENT_RIGHTS_BASE, NULL); return installer_util::INSUFFICIENT_RIGHTS; } } // Check the existing version installed. scoped_ptr installed_version(InstallUtil::GetChromeVersion(system_install)); if (installed_version.get()) { LOG(INFO) << "version on the system: " << installed_version->GetString(); } installer_util::InstallStatus install_status = installer_util::UNKNOWN_STATUS; // If --uninstall option is given, uninstall chrome if (parsed_command_line.HasSwitch(installer_util::switches::kUninstall)) { install_status = UninstallChrome(parsed_command_line, command_line, installed_version.get(), system_install); // If --uninstall option is not specified, we assume it is install case. } else { install_status = InstallChrome(parsed_command_line, installed_version.get(), prefs.get()); } BrowserDistribution* dist = BrowserDistribution::GetDistribution(); if (InstallUtil::IsChromeFrameProcess() && !parsed_command_line.HasSwitch( installer_util::switches::kForceUninstall)) { if (install_status == installer_util::UNINSTALL_REQUIRES_REBOOT) { ShowRebootDialog(); } else if (parsed_command_line.HasSwitch( installer_util::switches::kUninstall)) { ::MessageBoxW(NULL, installer_util::GetLocalizedString( IDS_UNINSTALL_COMPLETE_BASE).c_str(), dist->GetApplicationName().c_str(), MB_OK); } } int return_code = 0; // MSI demands that custom actions always return 0 (ERROR_SUCCESS) or it will // rollback the action. If we're uninstalling we want to avoid this, so always // report success, squashing any more informative return codes. if (!(InstallUtil::IsMSIProcess(system_install) && parsed_command_line.HasSwitch(installer_util::switches::kUninstall))) { // Note that we allow the status installer_util::UNINSTALL_REQUIRES_REBOOT // to pass through, since this is only returned on uninstall which is never // invoked directly by Google Update. return_code = dist->GetInstallReturnCode(install_status); } LOG(INFO) << "Installation complete, returning: " << return_code; return return_code; }