installation_state.cc

// Copyright 2012 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/util/installation_state.h"

#include <memory>
#include <string>
#include <string_view>

#include "base/check.h"
#include "base/strings/cstring_view.h"
#include "base/strings/string_util.h"
#include "base/strings/utf_string_conversions.h"
#include "base/version.h"
#include "base/win/registry.h"
#include "build/build_config.h"
#include "chrome/install_static/install_util.h"
#include "chrome/installer/util/app_commands.h"
#include "chrome/installer/util/google_update_constants.h"
#include "chrome/installer/util/helper.h"
#include "chrome/installer/util/install_util.h"
#include "chrome/installer/util/util_constants.h"

namespace installer {

namespace {

// Initializes |commands| from the "Commands" subkey of |version_key|. Returns
// false if there is no "Commands" subkey or on error.
bool InitializeCommands(const base::win::RegKey& clients_key,
                        AppCommands* commands) {
  static const DWORD kAccess =
      KEY_ENUMERATE_SUB_KEYS | KEY_QUERY_VALUE | KEY_WOW64_32KEY;
  base::win::RegKey commands_key;

  if (commands_key.Open(clients_key.Handle(), google_update::kRegCommandsKey,
                        kAccess) == ERROR_SUCCESS) {
    return commands->Initialize(commands_key, KEY_WOW64_32KEY);
  }
  return false;
}

}  // namespace

ProductState::ProductState()
    : uninstall_command_(base::CommandLine::NO_PROGRAM),
      eula_accepted_(0),
      usagestats_(0),
      msi_(false),
      has_eula_accepted_(false),
      has_oem_install_(false),
      has_usagestats_(false) {}

ProductState::~ProductState() = default;

bool ProductState::Initialize(bool system_install) {
  static const DWORD kAccess = KEY_QUERY_VALUE | KEY_WOW64_32KEY;
  const std::wstring clients_key(install_static::GetClientsKeyPath());
  const std::wstring state_key(install_static::GetClientStateKeyPath());
  const HKEY root_key = system_install ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
  base::win::RegKey key;

  // Clear the runway.
  Clear();

  // Read from the Clients key.
  if (key.Open(root_key, clients_key.c_str(), kAccess) == ERROR_SUCCESS) {
    std::wstring version_str;
    if (key.ReadValue(google_update::kRegVersionField, &version_str) ==
        ERROR_SUCCESS) {
      version_ =
          std::make_unique<base::Version>(base::WideToASCII(version_str));
      if (!version_->IsValid())
        version_.reset();
    }

    // Attempt to read the other values even if the "pv" version value was
    // absent. Note that ProductState instances containing these values will
    // only be accessible via InstallationState::GetNonVersionedProductState.
    if (key.ReadValue(google_update::kRegOldVersionField, &version_str) ==
        ERROR_SUCCESS) {
      old_version_ =
          std::make_unique<base::Version>(base::WideToASCII(version_str));
      if (!old_version_->IsValid())
        old_version_.reset();
    }

    if (key.ReadValue(google_update::kRegChannelField, &channel_) !=
        ERROR_SUCCESS) {
      channel_.clear();
    }

    if (!InitializeCommands(key, &commands_))
      commands_.Clear();
  }

  // Read from the ClientState key.
  if (key.Open(root_key, state_key.c_str(), kAccess) == ERROR_SUCCESS) {
    std::wstring setup_path;
    std::wstring uninstall_arguments;

    // Read in the brand code, it may be absent
    key.ReadValue(google_update::kRegBrandField, &brand_);

    key.ReadValue(kUninstallStringField, &setup_path);
    key.ReadValue(kUninstallArgumentsField, &uninstall_arguments);
    InstallUtil::ComposeCommandLine(setup_path, uninstall_arguments,
                                    &uninstall_command_);

    // "usagestats" may be absent, 0 (false), or 1 (true).  On the chance that
    // different values are permitted in the future, we'll simply hold whatever
    // we find.
    has_usagestats_ = (key.ReadValueDW(google_update::kRegUsageStatsField,
                                       &usagestats_) == ERROR_SUCCESS);
    // "oeminstall" may be present with any value or absent.
    has_oem_install_ = (key.ReadValue(google_update::kRegOemInstallField,
                                      &oem_install_) == ERROR_SUCCESS);
    // "eulaaccepted" may be absent, 0 or 1.
    has_eula_accepted_ = (key.ReadValueDW(google_update::kRegEulaAceptedField,
                                          &eula_accepted_) == ERROR_SUCCESS);
    // "msi" may be absent, 0 or 1
    DWORD dw_value = 0;
    msi_ = (key.ReadValueDW(google_update::kRegMSIField, &dw_value) ==
            ERROR_SUCCESS) &&
           (dw_value != 0);

    constexpr base::wcstring_view kEnterpriseProductPrefix(
        L"EnterpriseProduct");
    for (base::win::RegistryValueIterator iter(root_key, state_key.c_str(),
                                               KEY_WOW64_32KEY);
         iter.Valid(); ++iter) {
      std::wstring_view value_name(iter.Name());
      if (base::StartsWith(value_name, kEnterpriseProductPrefix,
                           base::CompareCase::INSENSITIVE_ASCII)) {
        product_guid_ = value_name.substr(kEnterpriseProductPrefix.size());
        break;
      }
    }
  }

  // Read from the ClientStateMedium key.  Values here override those in
  // ClientState.
  if (system_install &&
      key.Open(root_key, install_static::GetClientStateMediumKeyPath().c_str(),
               kAccess) == ERROR_SUCCESS) {
    DWORD dword_value = 0;

    if (key.ReadValueDW(google_update::kRegUsageStatsField, &dword_value) ==
        ERROR_SUCCESS) {
      has_usagestats_ = true;
      usagestats_ = dword_value;
    }

    if (key.ReadValueDW(google_update::kRegEulaAceptedField, &dword_value) ==
        ERROR_SUCCESS) {
      has_eula_accepted_ = true;
      eula_accepted_ = dword_value;
    }
  }

  if (version_.get() && uninstall_command_.GetProgram().empty()) {
    // The product has a "pv" in its Clients key, but is missing the
    // "UninstallString" value expected in its ClientState key. Manufacture the
    // expected uninstall command on the basis of what appears to be present on
    // the machine.

    // FindInstallPath returns the path to a version directory if one exists in
    // any of the standard install locations.
    if (const auto version_dir = FindInstallPath(system_install, *version_);
        !version_dir.empty()) {
      uninstall_command_ = base::CommandLine(
          version_dir.Append(kInstallerDir).Append(kSetupExe));
      uninstall_command_.AppendSwitch(switches::kUninstall);
      InstallUtil::AppendModeAndChannelSwitches(&uninstall_command_);

      // Note that `AppendModeAndChannelSwitches` will use the current process's
      // channel. When called from within a browser process, this will be
      // correct. When called from within the installer, it will not be. To
      // ensure that the browser's notion of the channel is always used, strip
      // off a value added above and explicitly add the value from the Clients
      // key.
      uninstall_command_.RemoveSwitch(switches::kChannel);
      if (!channel_.empty()) {
        uninstall_command_.AppendSwitchNative(switches::kChannel, channel_);
      }

      if (system_install) {
        uninstall_command_.AppendSwitch(switches::kSystemLevel);
      }
      uninstall_command_.AppendSwitch(switches::kVerboseLogging);
    }
  }

  if (version_.get() && system_install && (!msi_ || product_guid_.empty())) {
    // A system-level install may be missing the "msi" and/or
    // "EnterpriseProduct" values in ClientState. To repair from this, search
    // for an ARP entry under a product guid with a display name matching this
    // product.
    if (auto product_guid =
            FindProductGuid(InstallUtil::GetDisplayName(), product_guid_);
        !product_guid.empty()) {
      msi_ = true;
      product_guid_ = std::move(product_guid);
      // Add `--msi` to the uninstall args if it is missing.
      if (!uninstall_command_.HasSwitch(switches::kMsi)) {
        uninstall_command_.AppendSwitch(switches::kMsi);
      }
    }
  }

  return version_.get() != nullptr;
}

base::FilePath ProductState::GetSetupPath() const {
  return uninstall_command_.GetProgram();
}

const base::Version& ProductState::version() const {
  DCHECK(version_);
  return *version_;
}

ProductState& ProductState::CopyFrom(const ProductState& other) {
  version_.reset(other.version_.get() ? new base::Version(*other.version_)
                                      : nullptr);
  old_version_.reset(other.old_version_.get()
                         ? new base::Version(*other.old_version_)
                         : nullptr);
  channel_ = other.channel_;
  brand_ = other.brand_;
  uninstall_command_ = other.uninstall_command_;
  product_guid_ = other.product_guid_;
  oem_install_ = other.oem_install_;
  commands_.CopyFrom(other.commands_);
  eula_accepted_ = other.eula_accepted_;
  usagestats_ = other.usagestats_;
  msi_ = other.msi_;
  has_eula_accepted_ = other.has_eula_accepted_;
  has_oem_install_ = other.has_oem_install_;
  has_usagestats_ = other.has_usagestats_;

  return *this;
}

void ProductState::Clear() {
  version_.reset();
  old_version_.reset();
  channel_.clear();
  brand_.clear();
  oem_install_.clear();
  uninstall_command_ = base::CommandLine(base::CommandLine::NO_PROGRAM);
  product_guid_.clear();
  commands_.Clear();
  eula_accepted_ = 0;
  usagestats_ = 0;
  msi_ = false;
  has_eula_accepted_ = false;
  has_oem_install_ = false;
  has_usagestats_ = false;
}

bool ProductState::GetEulaAccepted(DWORD* eula_accepted) const {
  DCHECK(eula_accepted);
  if (!has_eula_accepted_)
    return false;
  *eula_accepted = eula_accepted_;
  return true;
}

bool ProductState::GetOemInstall(std::wstring* oem_install) const {
  DCHECK(oem_install);
  if (!has_oem_install_)
    return false;
  *oem_install = oem_install_;
  return true;
}

bool ProductState::GetUsageStats(DWORD* usagestats) const {
  DCHECK(usagestats);
  if (!has_usagestats_)
    return false;
  *usagestats = usagestats_;
  return true;
}

// static
std::wstring ProductState::FindProductGuid(std::wstring_view display_name,
                                           std::wstring_view hint) {
  constexpr base::wcstring_view kUninstallRootKey(
      L"Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\");
  constexpr size_t kGuidLength = 36;  // Does not include braces.
  constexpr REGSAM kViews[] = {
      0,  // The default view for this bitness.
#if defined(ARCH_CPU_64_BITS)
      KEY_WOW64_32KEY,  // 32-bit view.
#else
      KEY_WOW64_64KEY,  // 64-bit view.
#endif
  };
  // Returns true if the DisplayName value for the uninstall entry for `name` in
  // `view` of HKLM equals `display_name`.
  auto display_name_is = [&kUninstallRootKey, storage = std::wstring()](
                             REGSAM view, std::wstring_view name,
                             std::wstring_view display_name) mutable {
    return base::win::RegKey(HKEY_LOCAL_MACHINE,
                             base::StrCat({kUninstallRootKey, name}).c_str(),
                             KEY_QUERY_VALUE | view)
                   .ReadValue(kUninstallDisplayNameField, &storage) ==
               ERROR_SUCCESS &&
           storage == display_name;
  };

  // If the caller provided a hint, look first for an entry for it.
  if (!hint.empty()) {
    const std::wstring name = base::StrCat({L"{", hint, L"}"});
    for (const REGSAM view : kViews) {
      if (display_name_is(view, name, display_name)) {
        return std::wstring(hint);
      }
    }
  }

  // Otherwise, search through all subkeys named with GUIDs looking for a hit.
  for (const REGSAM view : kViews) {
    for (base::win::RegistryKeyIterator iter(HKEY_LOCAL_MACHINE,
                                             kUninstallRootKey.c_str(), view);
         iter.Valid(); ++iter) {
      const std::wstring_view key_name(iter.Name());
      // Skip this key if it doesn't plausibly look like a product guid.
      if (key_name.size() != kGuidLength + 2 || key_name.front() != L'{' ||
          key_name.back() != L'}') {
        continue;
      }
      if (display_name_is(view, key_name, display_name)) {
        return std::wstring(key_name.substr(1, kGuidLength));
      }
    }
  }

  return {};
}

InstallationState::InstallationState() = default;

void InstallationState::Initialize() {
  user_chrome_.Initialize(false);
  system_chrome_.Initialize(true);
}

const ProductState* InstallationState::GetProductState(
    bool system_install) const {
  const ProductState* product_state =
      GetNonVersionedProductState(system_install);
  return product_state->version_.get() ? product_state : nullptr;
}

const ProductState* InstallationState::GetNonVersionedProductState(
    bool system_install) const {
  return system_install ? &system_chrome_ : &user_chrome_;
}

}  // namespace installer