windows-xp/Source/XPSP1/NT/multimedia/directx/applicationmanager/cominterface/registrykey.cpp

//////////////////////////////////////////////////////////////////////////////////////////////
//
// RegistryKey.cpp
// 
// Copyright (C) 1998, 1999 Microsoft Corporation. All rights reserved.
//
// Abstract :
//
//   This is the implementation of the CRegistryKey class. This class was created in order to
//   support automatic destruction of C++ object when an exception is thrown.
//
// History :
//
//   05/06/1999 luish     Created
//
//////////////////////////////////////////////////////////////////////////////////////////////

#include <windows.h>
#include <shlwapi.h>
#include "RegistryKey.h"
#include "ExceptionHandler.h"
#include "AppManDebug.h"
#include "Win32API.h"

#ifdef DBG_MODULE
#undef DBG_MODULE
#endif

#define DBG_MODULE  DBG_REGISTRY

//////////////////////////////////////////////////////////////////////////////////////////////
//
//////////////////////////////////////////////////////////////////////////////////////////////

CRegistryKey::CRegistryKey(void)
{
  FUNCTION("CRegistryKey::CRegistryKey (void)");

  m_fKeyOpen = FALSE;
}

//////////////////////////////////////////////////////////////////////////////////////////////
//
//////////////////////////////////////////////////////////////////////////////////////////////

CRegistryKey::~CRegistryKey(void)
{
  FUNCTION("CRegistryKey::~CRegistryKey (void)");

  CloseKey();
}

//////////////////////////////////////////////////////////////////////////////////////////////
//
//////////////////////////////////////////////////////////////////////////////////////////////

STDMETHODIMP CRegistryKey::EnumKeys(const DWORD dwIndex, LPSTR lpszSubKeyName, LPDWORD lpdwSubKeyNameLen)
{
  FUNCTION("CRegistryKey::EnumKeys ()");

  FILETIME  sFileTime;

  //
  // If there is no currently opened registry key, then GetValue was called unexpectedly
  //

  if (!m_fKeyOpen)
  {
    THROW(E_UNEXPECTED);
  }

  if (ERROR_SUCCESS != RegEnumKeyEx(m_hRegistryKey, dwIndex, lpszSubKeyName, lpdwSubKeyNameLen, NULL, NULL, NULL, &sFileTime))
  {
    return S_FALSE;
  }

  return S_OK;
}

//////////////////////////////////////////////////////////////////////////////////////////////
//
//////////////////////////////////////////////////////////////////////////////////////////////

STDMETHODIMP CRegistryKey::CheckForExistingKey(HKEY hKey, LPCSTR lpszSubKeyName)
{
  FUNCTION("CRegistryKey::CheckForExistingKey ()");

  HKEY    hRegistryKey;

  if (ERROR_SUCCESS != RegOpenKeyEx(hKey, lpszSubKeyName, 0, KEY_READ, &hRegistryKey))
  {
    return S_FALSE;
  }
  
  RegCloseKey(hRegistryKey);

  return S_OK;
}


//////////////////////////////////////////////////////////////////////////////////////////////
//
//////////////////////////////////////////////////////////////////////////////////////////////

STDMETHODIMP CRegistryKey::CreateKey(HKEY hKey, LPCSTR lpszSubKeyName, const DWORD dwOptions, const REGSAM samDesired, BOOL bSpecifySecurityAttributes, LPDWORD lpdwDisposition)
{
  FUNCTION("CRegistryKey::CreateKey ()");

  LONG        lReturn = ERROR_SUCCESS;
  HRESULT     hResult = S_OK;
  CWin32API   oWin32API;

  //
  // Make sure that current registry is closed before proceeding
  //

  CloseKey();

  //
  // Create the new key
  //

  if ((!(OS_VERSION_9x & oWin32API.GetOSVersion()))&&(bSpecifySecurityAttributes))
  {
    SECURITY_ATTRIBUTES   sSecurityAttributes = {0};
    SECURITY_DESCRIPTOR   sSecurityDescriptor = {0};

    sSecurityAttributes.nLength = sizeof sSecurityAttributes;
    sSecurityAttributes.lpSecurityDescriptor = &sSecurityDescriptor;

    InitializeSecurityDescriptor(&sSecurityDescriptor, SECURITY_DESCRIPTOR_REVISION);
    SetSecurityDescriptorDacl(&sSecurityDescriptor, TRUE, NULL, FALSE);

    lReturn = RegCreateKeyEx(hKey, lpszSubKeyName, 0, NULL, dwOptions, samDesired, &sSecurityAttributes, &m_hRegistryKey, lpdwDisposition);
  }
  else
  {
    lReturn = RegCreateKeyEx(hKey, lpszSubKeyName, 0, NULL, dwOptions, samDesired, NULL, &m_hRegistryKey, lpdwDisposition);
  }

  if (lReturn != ERROR_SUCCESS)
  {
    if (lReturn == ERROR_ACCESS_DENIED)
    {
      hResult = E_ACCESSDENIED;
    }
    else
    {
      hResult = E_FAIL;
    }
      
    THROW(hResult);
  }

  m_fKeyOpen = TRUE;

  return S_OK;
}

//////////////////////////////////////////////////////////////////////////////////////////////
//
//////////////////////////////////////////////////////////////////////////////////////////////

STDMETHODIMP CRegistryKey::OpenKey(HKEY hKey, LPCSTR lpszSubKeyName, const REGSAM samDesired)
{
  FUNCTION("CRegistryKey::OpenKey ()");

  //
  // Make sure that current registry is closed before proceeding
  //

  CloseKey();

  //
  // Open the existing key
  //

  if (ERROR_SUCCESS != RegOpenKeyEx(hKey, lpszSubKeyName, 0, samDesired, &m_hRegistryKey))
  {
    THROW(E_FAIL);
  }

  m_fKeyOpen = TRUE;

  return S_OK;
}

//////////////////////////////////////////////////////////////////////////////////////////////
//
//////////////////////////////////////////////////////////////////////////////////////////////

STDMETHODIMP CRegistryKey::CloseKey(void)
{
  FUNCTION("CRegistryKey::CloseKey ()");

  if (m_fKeyOpen)
  {
    RegCloseKey(m_hRegistryKey);
    m_fKeyOpen = FALSE;
  }

  return S_OK;
}

//////////////////////////////////////////////////////////////////////////////////////////////
//
//////////////////////////////////////////////////////////////////////////////////////////////

STDMETHODIMP CRegistryKey::DeleteKey(HKEY hKey, LPCSTR lpszSubKeyName)
{
  FUNCTION("CRegistryKey::DeleteKey ()");

  HRESULT   hResult = S_OK;
  DWORD     dwSubKeyNameLen;
  HKEY      hRegistryKey;
  FILETIME  sFileTime;
  CHAR      strSubKeyName[MAX_PATH];
  CHAR      strFullSubKeyName[MAX_PATH];

  //
  // Recursively delete all subkeys
  //

  if (ERROR_SUCCESS == RegOpenKeyEx(hKey, lpszSubKeyName, 0, KEY_ALL_ACCESS, &hRegistryKey))
  {
    dwSubKeyNameLen = MAX_PATH;
    while ((S_OK == hResult)&&(ERROR_SUCCESS == RegEnumKeyEx(hRegistryKey, 0, strSubKeyName, &dwSubKeyNameLen, NULL, NULL, NULL, &sFileTime)))
    {
      sprintf(strFullSubKeyName, "%s\\%s", lpszSubKeyName, strSubKeyName);
      hResult = DeleteKey(hKey, strFullSubKeyName);
      dwSubKeyNameLen = MAX_PATH;
    }

    //
    // Close the key
    //

    RegCloseKey(hRegistryKey);

    //
    // If all the subkeys were successfully deleted
    //

    if (S_OK == hResult)
    {
      //
      // Delete this subkey
      //
  
      if (ERROR_SUCCESS != RegDeleteKey(hKey, lpszSubKeyName))
      {
        hResult = E_FAIL;
      }
    }
  }

  return hResult;
}

//////////////////////////////////////////////////////////////////////////////////////////////
//
//////////////////////////////////////////////////////////////////////////////////////////////

STDMETHODIMP CRegistryKey::EnumValues(const DWORD dwIndex, LPSTR lpszValueName, LPDWORD lpdwValueNameLen, LPDWORD lpdwType, LPBYTE lpData, LPDWORD lpdwDataLen)
{
  FUNCTION("CRegistryKey::EnumValues ()");

  //
  // If there is no currently opened registry key, then GetValue was called unexpectedly
  //

  if (!m_fKeyOpen)
  {
    THROW(E_UNEXPECTED);
  }

  if (ERROR_SUCCESS != RegEnumValue(m_hRegistryKey, dwIndex, lpszValueName, lpdwValueNameLen, NULL, lpdwType, lpData, lpdwDataLen))
  {
    return S_FALSE;
  }

  return S_OK;
}

//////////////////////////////////////////////////////////////////////////////////////////////
//
//////////////////////////////////////////////////////////////////////////////////////////////

STDMETHODIMP CRegistryKey::CheckForExistingValue(LPCSTR lpszValueName)
{
  FUNCTION("CRegistryKey::CheckForExistingValue ()");

  //
  // If there is no currently opened registry key, then CheckForExistingValue was
  // called unexpectedly
  //

  if (!m_fKeyOpen)
  {
    THROW(E_UNEXPECTED);
  }

  //
  // Check to see whether we can RegQueryValueEx() on the target. If we can then the value
  // exists, othersize it does not
  //

  if (ERROR_SUCCESS != RegQueryValueEx(m_hRegistryKey, lpszValueName, NULL, NULL, NULL, NULL))
  {
    return S_FALSE;
  }

  return S_OK;
}

//////////////////////////////////////////////////////////////////////////////////////////////
//
//////////////////////////////////////////////////////////////////////////////////////////////

STDMETHODIMP CRegistryKey::GetValue(LPCSTR lpszValueName, LPDWORD lpdwType, LPBYTE lpData, LPDWORD lpdwDataLen)
{
  FUNCTION("CRegistryKey::GetValue ()");

  //
  // If there is no currently opened registry key, then GetValue was called unexpectedly
  //

  if (!m_fKeyOpen)
  {
    THROW(E_UNEXPECTED);
  }

  if (ERROR_SUCCESS != RegQueryValueEx(m_hRegistryKey, lpszValueName, NULL, lpdwType, lpData, lpdwDataLen))
  {
    THROW(E_FAIL);
  }

  return S_OK;
}

//////////////////////////////////////////////////////////////////////////////////////////////
//
//////////////////////////////////////////////////////////////////////////////////////////////

STDMETHODIMP CRegistryKey::SetValue(LPCSTR lpszValueName, const DWORD dwType, const BYTE * lpData, const DWORD dwDataLen)
{
  FUNCTION("CRegistryKey::SetValue ()");

  DWORD dwActualDataLen;

  //
  // If there is no currently opened registry key, then GetValue was called unexpectedly
  //

  if (!m_fKeyOpen)
  {
    THROW(E_UNEXPECTED);
  }

  //
  // If this value is of type REG_SZ, define the lenght of the string
  //

  if (REG_SZ == dwType)
  {
    dwActualDataLen = strlen((LPSTR)lpData) + 1;
    if (dwActualDataLen > dwDataLen)
    {
      dwActualDataLen = dwDataLen - 1;
    }
  }
  else
  {
    dwActualDataLen = dwDataLen;
  }

  //
  //
  // Set the registry value
  //

  if (ERROR_SUCCESS != RegSetValueEx(m_hRegistryKey, lpszValueName, 0, dwType, lpData, dwActualDataLen))
  {
    THROW(E_FAIL);
  }

  return S_OK;
}

//////////////////////////////////////////////////////////////////////////////////////////////
//
//////////////////////////////////////////////////////////////////////////////////////////////

STDMETHODIMP CRegistryKey::DeleteValue(LPCSTR lpszValueName)
{
  FUNCTION("CRegistryKey::DeleteValue ()");

  //
  // If there is no currently opened registry key, then GetValue was called unexpectedly
  //

  if (!m_fKeyOpen)
  {
    THROW(E_UNEXPECTED);
  }

  if (ERROR_SUCCESS != RegDeleteValue(m_hRegistryKey, lpszValueName))
  {
    THROW(E_FAIL);
  }

  return S_OK;
}