cpp/iedriver/RegistryUtilities.cpp

// Licensed to the Software Freedom Conservancy (SFC) under one
// or more contributor license agreements. See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership. The SFC licenses this file
// to you under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include "RegistryUtilities.h"

#include <vector>

#include "logging.h"

namespace webdriver {

RegistryUtilities::RegistryUtilities(void) {
}

RegistryUtilities::~RegistryUtilities(void) {
}

bool RegistryUtilities::GetRegistryValue(const HKEY root_key,
                                         const std::wstring& subkey,
                                         const std::wstring& value_name,
                                         std::wstring *value) {
  return GetRegistryValue(root_key, subkey, value_name, false, value);
}

bool RegistryUtilities::GetRegistryValue(const HKEY root_key,
                                         const std::wstring& subkey,
                                         const std::wstring& value_name,
                                         const bool bypass_registry_redirection,
                                         std::wstring *value) {
  std::string root_key_description = "HKEY_CURRENT_USER";
  if (root_key == HKEY_CLASSES_ROOT) {
    root_key_description = "HKEY_CLASSES_ROOT";
  } else if (root_key == HKEY_LOCAL_MACHINE) {
    root_key_description = "HKEY_LOCAL_MACHINE";
  }
  LOG(TRACE) << "Attempting to get registry value " << LOGWSTRING(value_name)
             << " from " << LOGWSTRING(root_key_description) << "\\"
             << LOGWSTRING(subkey);
  bool value_retrieved = false;
  DWORD required_buffer_size;
  DWORD value_type;
  HKEY key_handle;
  REGSAM desired_security_mask = KEY_QUERY_VALUE;
  if (Is64BitWindows() && bypass_registry_redirection) {
    desired_security_mask |= KEY_WOW64_64KEY;
  }
  long registry_call_result = ::RegOpenKeyEx(root_key,
                                             subkey.c_str(),
                                             0,
                                             desired_security_mask,
                                             &key_handle);
  if (ERROR_SUCCESS == registry_call_result) {
    registry_call_result = ::RegQueryValueEx(key_handle,
                                             value_name.c_str(),
                                             NULL,
                                             &value_type,
                                             NULL,
                                             &required_buffer_size);
    if (ERROR_SUCCESS == registry_call_result) {
      if (value_type == REG_SZ || value_type == REG_EXPAND_SZ || value_type == REG_MULTI_SZ) {
        std::vector<wchar_t> value_buffer(required_buffer_size);
        registry_call_result = ::RegQueryValueEx(key_handle,
                                                value_name.c_str(),
                                                NULL,
                                                &value_type,
                                                reinterpret_cast<LPBYTE>(&value_buffer[0]),
                                                &required_buffer_size);
        if (ERROR_SUCCESS == registry_call_result) {
          *value = &value_buffer[0];
          value_retrieved = true;
        }
      } else if (value_type == REG_DWORD) {
        DWORD numeric_value = 0;
        registry_call_result = ::RegQueryValueEx(key_handle,
                                                 value_name.c_str(),
                                                 NULL,
                                                 &value_type,
                                                 reinterpret_cast<LPBYTE>(&numeric_value),
                                                 &required_buffer_size);
        if (ERROR_SUCCESS == registry_call_result) {
          // Coerce the numeric value to a string to return back.
          // Assume 10 characters will be enough to hold the size
          // of the value.
          std::vector<wchar_t> numeric_value_buffer(10);
          _ltow_s(numeric_value, &numeric_value_buffer[0], numeric_value_buffer.size(), 10);
          *value = &numeric_value_buffer[0];
          value_retrieved = true;
        }
      } else {
        LOG(WARN) << "Unexpected value type of " << value_type
                  << " for RegQueryValueEx was found for value with name "
                  << LOGWSTRING(value_name) << " in subkey "
                  << LOGWSTRING(subkey) << " in hive "
                  << root_key_description;
      }
      if (ERROR_SUCCESS != registry_call_result) {
        LOG(WARN) << "RegQueryValueEx failed with error code "
                  << registry_call_result << " retrieving value with name "
                  << LOGWSTRING(value_name) << " in subkey "
                  << LOGWSTRING(subkey) << "in hive "
                  << root_key_description;
      }
    } else {
      LOG(WARN) << "RegQueryValueEx failed with error code "
                << registry_call_result
                << " retrieving required buffer size for value with name "
                << LOGWSTRING(value_name) << " in subkey "
                << LOGWSTRING(subkey) << " in hive "
                << root_key_description;
    }
    ::RegCloseKey(key_handle);
  } else {
    LOG(WARN) << "RegOpenKeyEx failed with error code "
              << registry_call_result <<  " attempting to open subkey "
              << LOGWSTRING(subkey) << " in hive "
              << root_key_description;

  }
  if (value_retrieved) {
    LOG(TRACE) << "Retrieved value " << LOGWSTRING(*value);
  }
  return value_retrieved;
}

bool RegistryUtilities::RegistryKeyExists(HKEY root_key,
                                          const std::wstring& subkey) {
  HKEY key_handle;
  long registry_call_result = ::RegOpenKeyEx(root_key,
                                             subkey.c_str(),
                                             0,
                                             KEY_QUERY_VALUE,
                                             &key_handle);
  bool result = (ERROR_SUCCESS == registry_call_result);
  if (result) {
    ::RegCloseKey(key_handle);
  }
  return result;
}

bool RegistryUtilities::Is64BitWindows() {
  SYSTEM_INFO system_info;
  ::GetNativeSystemInfo(&system_info);
  if (system_info.wProcessorArchitecture == 0) {
    // wProcessorArchitecture == 0 means processor architecture
    // is "x86", and therefore 32-bit. Note that we don't check
    // for specific processor flavors because we don't support
    // the driver running on any architecture other than x86 or
    // x64 (AMD or Intel).
    return false;
  }
  return true;
}

} // namespace webdriver