chrome/installer/setup/downgrade_cleanup.cc

// Copyright 2021 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "chrome/installer/setup/downgrade_cleanup.h"

#include <optional>
#include <string_view>
#include <vector>

#include "base/check.h"
#include "base/command_line.h"
#include "base/files/file_path.h"
#include "base/functional/bind.h"
#include "base/logging.h"
#include "base/process/launch.h"
#include "base/process/process.h"
#include "base/strings/string_util.h"
#include "base/strings/utf_string_conversions.h"
#include "base/version.h"
#include "base/win/registry.h"
#include "chrome/install_static/install_util.h"
#include "chrome/installer/setup/installer_state.h"
#include "chrome/installer/setup/setup_constants.h"
#include "chrome/installer/util/callback_work_item.h"
#include "chrome/installer/util/google_update_constants.h"
#include "chrome/installer/util/install_util.h"
#include "chrome/installer/util/util_constants.h"
#include "chrome/installer/util/work_item_list.h"

namespace {

constexpr std::wstring_view kCleanupOperation = L"cleanup";
constexpr std::wstring_view kRevertCleaunpOperation = L"revert";

// Returns the last version of Chrome which introduced breaking changes to the
// installer, or no value if Chrome is not installed or the version installed
// predates support for this feature.
std::optional<base::Version> GetLastBreakingInstallerVersion(HKEY reg_root) {
  base::win::RegKey key;
  std::wstring last_breaking_installer_version;
  if (key.Open(reg_root, install_static::GetClientStateKeyPath().c_str(),
               KEY_QUERY_VALUE | KEY_WOW64_32KEY) != ERROR_SUCCESS ||
      key.ReadValue(google_update::kRegCleanInstallRequiredForVersionBelowField,
                    &last_breaking_installer_version) != ERROR_SUCCESS ||
      last_breaking_installer_version.empty()) {
    return std::nullopt;
  }
  base::Version version(base::WideToASCII(last_breaking_installer_version));
  if (!version.IsValid())
    return std::nullopt;
  return version;
}
// Formats `cmd_line_with_placeholders` by replacing the placeholders with
// `version` and `operation`. Returns an empty string if some placeholder
// replacements are missing.
std::wstring GetCleanupCommandLine(
    const std::wstring& cmd_line_with_placeholders,
    const base::Version& version,
    std::wstring_view operation) {
  DCHECK(version.IsValid());
  DCHECK(!cmd_line_with_placeholders.empty());
  DCHECK(operation == kCleanupOperation ||
         operation == kRevertCleaunpOperation);
  std::vector<size_t> offsets;
  std::vector<std::u16string> replacements{
      base::ASCIIToUTF16(version.GetString()), base::AsString16(operation)};
  auto cmd = base::ReplaceStringPlaceholders(
      base::AsString16(cmd_line_with_placeholders), replacements, &offsets);
  // The `offsets` size and `replacements` size should be equal. If they are
  // not, no command should be returned to avoid running an invalid command
  // line.
  if (offsets.size() != replacements.size())
    cmd.clear();
  return base::AsWString(std::move(cmd));
}

// Returns true if after a downgrade, `cmd` was run successfully to cleanup
// after a downgrade crossing a breaking installer version. `cmd` is expected to
// be a correctly formatted command line that calls the installer of the version
// we downgraded from with the right version and 'cleanup' as operation
// parameter.
bool LaunchCleanupForBreakingDowngradeProcess(
    const std::wstring& cmd,
    const CallbackWorkItem& work_item) {
  DCHECK(!cmd.empty());
  VLOG(1) << "Launching downgrade cleanup process: " << cmd;
  base::Process process = base::LaunchProcess(cmd, base::LaunchOptions());
  if (!process.IsValid()) {
    PLOG(ERROR) << "Failed to launch child process \"" << cmd << "\"";
    return false;
  }
  int exit_code = installer::DOWNGRADE_CLEANUP_SUCCESS;
  process.WaitForExit(&exit_code);

  if (exit_code == installer::DOWNGRADE_CLEANUP_SUCCESS) {
    VLOG(1) << "Downgrade cleanup process succeeded";
    return true;
  }
  LOG(ERROR) << "Downgrade cleanup process \"" << cmd
             << "\" failed with exit code " << exit_code;
  return false;
}

// Runs `cmd` to revert any cleanup done after a downgrade crossing a breaking
// installer version in the context of a CallbackWorkItem. `cmd` is expected to
// be a correctly formatted command line that calls the installer of the version
// we downgraded from with the right version and 'revert' as operation
// parameter.
void LaunchUndoCleanupForBreakingDowngradeProcess(
    const std::wstring& cmd,
    const CallbackWorkItem& work_item) {
  DCHECK(!cmd.empty());
  VLOG(1) << "Launching downgrade cleanup undo process: " << cmd;
  base::Process process = base::LaunchProcess(cmd, base::LaunchOptions());
  if (!process.IsValid()) {
    PLOG(ERROR) << "Failed to launch child process \"" << cmd << "\"";
    return;
  }

  int exit_code = installer::UNDO_DOWNGRADE_CLEANUP_SUCCESS;
  process.WaitForExit(&exit_code);

  if (exit_code == installer::UNDO_DOWNGRADE_CLEANUP_SUCCESS) {
    VLOG(1) << "Downgrade cleanup undo process succeeded";
    return;
  }

  LOG(ERROR) << "Downgrade cleanup undo process \"" << cmd
             << "\" failed with exit code " << exit_code;
}

}  // namespace

namespace installer {

InstallStatus ProcessCleanupForDowngrade(const base::Version& version,
                                         bool revert) {
  if (revert) {
    return version.IsValid() ? UNDO_DOWNGRADE_CLEANUP_SUCCESS
                             : UNDO_DOWNGRADE_CLEANUP_FAILED;
  }
  return version.IsValid() ? DOWNGRADE_CLEANUP_SUCCESS
                           : DOWNGRADE_CLEANUP_FAILED;
}

std::wstring GetDowngradeCleanupCommandWithPlaceholders(
    const base::FilePath& installer_path,
    const InstallerState& installer_state) {
  base::CommandLine downgrade_cleanup_cmd(installer_path);
  downgrade_cleanup_cmd.AppendSwitchNative(
      switches::kCleanupForDowngradeVersion, L"$1");
  downgrade_cleanup_cmd.AppendSwitchNative(
      switches::kCleanupForDowngradeOperation, L"$2");
  InstallUtil::AppendModeAndChannelSwitches(&downgrade_cleanup_cmd);
  if (installer_state.system_install())
    downgrade_cleanup_cmd.AppendSwitch(switches::kSystemLevel);
  if (installer_state.verbose_logging())
    downgrade_cleanup_cmd.AppendSwitch(switches::kVerboseLogging);
  return downgrade_cleanup_cmd.GetCommandLineString();
}

bool AddDowngradeCleanupItems(const base::Version& new_version,
                              WorkItemList* list) {
  DCHECK(new_version.IsValid());
  HKEY reg_root = install_static::IsSystemInstall() ? HKEY_LOCAL_MACHINE
                                                    : HKEY_CURRENT_USER;
  if (GetLastBreakingInstallerVersion(reg_root) <= new_version)
    return false;

  std::wstring dowgrade_cleanup_cmd;
  base::win::RegKey(reg_root, install_static::GetClientStateKeyPath().c_str(),
                    KEY_QUERY_VALUE | KEY_WOW64_32KEY)
      .ReadValue(google_update::kRegDowngradeCleanupCommandField,
                 &dowgrade_cleanup_cmd);
  if (dowgrade_cleanup_cmd.empty())
    return false;

  auto cleanup_cmd = GetCleanupCommandLine(dowgrade_cleanup_cmd, new_version,
                                           kCleanupOperation);
  if (cleanup_cmd.empty()) {
    LOG(ERROR) << "Unable to format the downgrade cleanup command \""
               << dowgrade_cleanup_cmd << "\"";
    return false;
  }

  auto revert_cmd = GetCleanupCommandLine(dowgrade_cleanup_cmd, new_version,
                                          kRevertCleaunpOperation);
  if (revert_cmd.empty()) {
    LOG(ERROR) << "Unable to format the revert downgrade cleanup command \""
               << dowgrade_cleanup_cmd << "\"";
    return false;
  }

  VLOG(1) << "Setting up cleanup for downgrade to version " << new_version;

  list->AddCallbackWorkItem(
      base::BindOnce(&LaunchCleanupForBreakingDowngradeProcess,
                     std::move(cleanup_cmd)),
      base::BindOnce(&LaunchUndoCleanupForBreakingDowngradeProcess,
                     std::move(revert_cmd)));
  return true;
}

}  // namespace installer