able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/shell/shlwapi/reg.c
CryptoAlgo Inc b3cac27891 Add source files
2020-09-26 16:20:57 +08:00

3439 lines
108 KiB
C
Raw Blame History

#include "priv.h"
#include <regapix.h>
#ifdef _X86_
#include <w95wraps.h>
#endif
// These private helper functions below call ANSI versions of the
// registry functions so they will run on Win95.
STDAPI_(DWORD)
RegData_AtoW(
IN LPCVOID pvData,
IN DWORD dwSize,
IN DWORD dwType,
/*INOUT*/ LPDWORD pcbData
)
{
DWORD dwRet = NO_ERROR;
if (REG_SZ == dwType || REG_EXPAND_SZ == dwType || REG_MULTI_SZ == dwType)
{
DWORD cbData = pcbData ? *pcbData : -1;
if (pvData)
{
// Allocate a temporary buffer to work with
int cch = MultiByteToWideChar(CP_ACP, 0, (LPSTR)pvData, cbData, NULL, 0);
LPWSTR pwszT = (LPWSTR)LocalAlloc(LPTR, CbFromCchW(cch));
if (!pwszT)
dwRet = ERROR_NOT_ENOUGH_MEMORY;
else
{
if (CbFromCchW(cch) > dwSize)
dwRet = ERROR_MORE_DATA;
else
{
// Convert it to the temporary buffer
MultiByteToWideChar(CP_ACP, 0, (LPSTR)pvData, cbData, pwszT, cch);
// Copy it back to the output buffer
// pwszT can be REG_MULTI_SZ, so we can't use StrCpyW
memcpy((LPVOID)pvData, (LPVOID)pwszT, CbFromCchW(cch));
}
LocalFree(pwszT);
}
// If string data, make room for unicode
if (pcbData)
{
(*pcbData) = cch * sizeof(WCHAR);
}
}
else if (pcbData)
{
// We don't have the data so guess (actual value may be less)
// Does this need to be exact? For now this seem sufficient. (Stevepro)
(*pcbData) *= sizeof(WCHAR);
}
}
return dwRet;
}
/*----------------------------------------------------------
Purpose: Helper function to delete a key that has no subkeys and
no values. Otherwise does nothing. Mimics what RegDeleteKey
does on NT.
Returns:
Cond: --
*/
DWORD
DeleteEmptyKey(
IN HKEY hkey,
IN LPCSTR pszSubKey)
{
DWORD dwRet;
HKEY hkeyNew;
dwRet = RegOpenKeyExA(hkey, pszSubKey, 0, KEY_READ | KEY_SET_VALUE,
&hkeyNew);
if (NO_ERROR == dwRet)
{
DWORD ckeys;
DWORD cvalues;
// Are there any subkeys or values?
dwRet = RegQueryInfoKey(hkeyNew, NULL, NULL, NULL, &ckeys,
NULL, NULL, &cvalues, NULL, NULL,
NULL, NULL);
if (NO_ERROR == dwRet &&
0 == cvalues && 0 == ckeys)
{
// No; delete the subkey
dwRet = RegDeleteKeyA(hkey, pszSubKey);
}
else
{
dwRet = ERROR_DIR_NOT_EMPTY;
}
RegCloseKey(hkeyNew);
}
return dwRet;
}
/*----------------------------------------------------------
Purpose: Recursively delete the key, including all child values
and keys. Mimics what RegDeleteKey does in Win95.
Returns:
Cond: --
*/
DWORD
DeleteKeyRecursively(
IN HKEY hkey,
IN LPCSTR pszSubKey)
{
DWORD dwRet;
HKEY hkSubKey;
// Open the subkey so we can enumerate any children
dwRet = RegOpenKeyExA(hkey, pszSubKey, 0, MAXIMUM_ALLOWED, &hkSubKey);
if (ERROR_SUCCESS == dwRet)
{
DWORD dwIndex;
CHAR szSubKeyName[MAX_PATH + 1];
DWORD cchSubKeyName = ARRAYSIZE(szSubKeyName);
// I can't just call RegEnumKey with an ever-increasing index, because
// I'm deleting the subkeys as I go, which alters the indices of the
// remaining subkeys in an implementation-dependent way. In order to
// be safe, I have to count backwards while deleting the subkeys.
// Find out how many subkeys there are
dwRet = RegQueryInfoKeyA(hkSubKey, NULL, NULL, NULL,
&dwIndex, // The # of subkeys -- all we need
NULL, NULL, NULL, NULL, NULL, NULL, NULL);
if (NO_ERROR == dwRet)
{
// dwIndex is now the count of subkeys, but it needs to be
// zero-based for RegEnumKey, so I'll pre-decrement, rather
// than post-decrement.
while (ERROR_SUCCESS == RegEnumKeyA(hkSubKey, --dwIndex, szSubKeyName, cchSubKeyName))
{
DeleteKeyRecursively(hkSubKey, szSubKeyName);
}
}
RegCloseKey(hkSubKey);
if (pszSubKey)
{
dwRet = RegDeleteKeyA(hkey, pszSubKey);
}
else
{
// we want to delete all the values by hand
cchSubKeyName = ARRAYSIZE(szSubKeyName);
while (ERROR_SUCCESS == RegEnumValueA(hkey, 0, szSubKeyName, &cchSubKeyName, NULL, NULL, NULL, NULL))
{
// avoid looping infinitely when we cant delete the value
if (RegDeleteValueA(hkey, szSubKeyName))
break;
cchSubKeyName = ARRAYSIZE(szSubKeyName);
}
}
}
return dwRet;
}
/*----------------------------------------------------------
Purpose: Gets a registry value. This opens and closes the
key in which the value resides.
Perf: if your code involves setting/getting a series
of values in the same key, it is better to open
the key once and set/get the values with the regular
Win32 registry functions, rather than using this
function repeatedly.
Returns:
Cond: --
*/
STDAPI_(DWORD)
SHGetValueA(
IN HKEY hkey,
IN LPCSTR pszSubKey, OPTIONAL
IN LPCSTR pszValue, OPTIONAL
OUT LPDWORD pdwType, OPTIONAL
OUT LPVOID pvData, OPTIONAL
OUT LPDWORD pcbData) OPTIONAL
{
DWORD dwRet = ERROR_INVALID_PARAMETER;
HKEY hkClose = NULL;
if (pvData)
{
RIPMSG(pcbData != NULL, "SHGetValueA: caller passed pvData output buffer but not size of buffer (pcbData)!");
}
if (pszSubKey && *pszSubKey)
{
dwRet = RegOpenKeyExA(hkey, pszSubKey, 0, KEY_QUERY_VALUE, &hkClose);
hkey = hkClose;
ASSERT(NO_ERROR == dwRet || !hkey);
}
if (hkey)
{
dwRet = SHQueryValueExA(hkey, pszValue, NULL, pdwType, pvData,
pcbData);
if (hkClose)
RegCloseKey(hkClose);
}
else if (pcbData)
*pcbData = 0;
return dwRet;
}
/*----------------------------------------------------------
Purpose: Gets a registry value. This opens and closes the
key in which the value resides.
On Win95, this function thunks and calls the ansi
version. On NT, this function calls the unicode
registry APIs.
Perf: if your code involves setting/getting a series
of values in the same key, it is better to open
the key once and set/get the values with the regular
Win32 registry functions, rather than using this
function repeatedly.
Returns:
Cond: --
*/
STDAPI_(DWORD)
SHGetValueW(
IN HKEY hkey,
IN LPCWSTR pwszSubKey, OPTIONAL
IN LPCWSTR pwszValue, OPTIONAL
OUT LPDWORD pdwType, OPTIONAL
OUT LPVOID pvData, OPTIONAL
OUT LPDWORD pcbData) OPTIONAL
{
DWORD dwRet = ERROR_INVALID_PARAMETER;
if (pvData)
{
RIPMSG(pcbData != NULL, "SHGetValueW: caller passed pvData output buffer but not size of buffer (pcbData)!");
}
if (g_bRunningOnNT)
{
HKEY hkClose = NULL;
if (pwszSubKey && *pwszSubKey)
{
dwRet = RegOpenKeyExW(hkey, pwszSubKey, 0, KEY_QUERY_VALUE, &hkClose);
hkey = hkClose;
ASSERT(NO_ERROR == dwRet || !hkey);
}
if (hkey)
{
dwRet = SHQueryValueExW(hkey, pwszValue, NULL, pdwType, pvData,
pcbData);
if (hkClose)
RegCloseKey(hkClose);
}
else if (pcbData)
*pcbData = 0;
}
else
{
CHAR szSubKey[MAX_PATH];
CHAR szValue[MAX_PATH];
LPSTR pszSubKey = NULL;
LPSTR pszValue = NULL;
DWORD dwType;
DWORD cbSizeSav = 0;
// Thunk the values
if (pwszSubKey)
{
WideCharToMultiByte(CP_ACP, 0, pwszSubKey, -1, szSubKey, SIZECHARS(szSubKey), NULL, NULL);
pszSubKey = szSubKey;
}
if (pwszValue)
{
WideCharToMultiByte(CP_ACP, 0, pwszValue, -1, szValue, SIZECHARS(szValue), NULL, NULL);
pszValue = szValue;
}
if (pcbData)
cbSizeSav = *pcbData; // Save this size for later
dwRet = SHGetValueA(hkey, pszSubKey, pszValue, &dwType, pvData, pcbData);
if (pdwType)
*pdwType = dwType;
if (NO_ERROR == dwRet)
{
dwRet = RegData_AtoW(pvData, cbSizeSav, dwType, pcbData); // Thunk data from ANSI->UNICODE if needed.
}
}
return dwRet;
}
/*----------------------------------------------------------
Purpose: Sets a registry value. This opens and closes the
key in which the value resides.
Perf: if your code involves setting/getting a series
of values in the same key, it is better to open
the key once and set/get the values with the regular
Win32 registry functions, rather than using this
function repeatedly.
Returns:
Cond: --
*/
STDAPI_(DWORD)
SHSetValueA(
IN HKEY hkey,
IN OPTIONAL LPCSTR pszSubKey,
IN LPCSTR pszValue,
IN DWORD dwType,
IN LPCVOID pvData,
IN DWORD cbData)
{
DWORD dwRet = NO_ERROR;
HKEY hkeyNew;
DWORD dwDisp;
if (pszSubKey && pszSubKey[0])
dwRet = RegCreateKeyExA(hkey, pszSubKey, 0, "", 0, KEY_SET_VALUE, NULL, &hkeyNew, &dwDisp);
else
hkeyNew = hkey;
if (NO_ERROR == dwRet)
{
dwRet = RegSetValueExA(hkeyNew, pszValue, 0, dwType, pvData, cbData);
if (hkeyNew != hkey)
RegCloseKey(hkeyNew);
}
return dwRet;
}
/*----------------------------------------------------------
Purpose: Sets a registry value. This opens and closes the
key in which the value resides.
On Win95, this function thunks and calls the ansi
version. On NT, this function calls the unicode
registry APIs directly.
Perf: if your code involves setting/getting a series
of values in the same key, it is better to open
the key once and set/get the values with the regular
Win32 registry functions, rather than using this
function repeatedly.
Returns:
Cond: --
*/
STDAPI_(DWORD)
SHSetValueW(
IN HKEY hkey,
IN OPTIONAL LPCWSTR pwszSubKey,
IN LPCWSTR pwszValue,
IN DWORD dwType,
IN LPCVOID pvData,
IN DWORD cbData)
{
DWORD dwRet = NO_ERROR;
HKEY hkeyNew;
DWORD dwDisp;
if (pwszSubKey && pwszSubKey[0])
{
if (g_bRunningOnNT)
{
dwRet = RegCreateKeyExW(hkey, pwszSubKey, 0, TEXTW(""), 0, KEY_SET_VALUE,
NULL, &hkeyNew, &dwDisp);
}
else
{
CHAR szSubKey[MAX_PATH];
LPSTR pszSubKey = NULL;
if (pwszSubKey)
{
WideCharToMultiByte(CP_ACP, 0, pwszSubKey, -1, szSubKey, SIZECHARS(szSubKey), NULL, NULL);
pszSubKey = szSubKey;
}
dwRet = RegCreateKeyExA(hkey, pszSubKey, 0, "", REG_OPTION_NON_VOLATILE, KEY_SET_VALUE,
NULL, &hkeyNew, &dwDisp);
}
}
else
hkeyNew = hkey;
if (NO_ERROR == dwRet)
{
// RegSetValueExW is not supported on Win95 but we have a thunking function.
dwRet = RegSetValueExW(hkeyNew, pwszValue, 0, dwType, pvData, cbData);
if (hkeyNew != hkey)
RegCloseKey(hkeyNew);
}
return dwRet;
}
/*----------------------------------------------------------
Purpose: Deletes a registry value. This opens and closes the
key in which the value resides.
Perf: if your code involves setting/getting a series
of values in the same key, it is better to open
the key once and set/get the values with the regular
Win32 registry functions, rather than using this
function repeatedly.
Returns:
Cond: --
*/
STDAPI_(DWORD)
SHDeleteValueA(
IN HKEY hkey,
IN LPCSTR pszSubKey,
IN LPCSTR pszValue)
{
DWORD dwRet;
HKEY hkeyNew;
dwRet = RegOpenKeyExA(hkey, pszSubKey, 0, KEY_SET_VALUE, &hkeyNew);
if (NO_ERROR == dwRet)
{
dwRet = RegDeleteValueA(hkeyNew, pszValue);
RegCloseKey(hkeyNew);
}
return dwRet;
}
/*----------------------------------------------------------
Purpose: Deletes a registry value. This opens and closes the
key in which the value resides.
On Win95, this function thunks and calls the ansi
version. On NT, this function calls the unicode
registry APIs directly.
Perf: if your code involves setting/getting a series
of values in the same key, it is better to open
the key once and set/get the values with the regular
Win32 registry functions, rather than using this
function repeatedly.
Returns:
Cond: --
*/
STDAPI_(DWORD)
SHDeleteValueW(
IN HKEY hkey,
IN LPCWSTR pwszSubKey,
IN LPCWSTR pwszValue)
{
DWORD dwRet;
HKEY hkeyNew;
if (g_bRunningOnNT)
{
dwRet = RegOpenKeyExW(hkey, pwszSubKey, 0, KEY_SET_VALUE, &hkeyNew);
if (NO_ERROR == dwRet)
{
dwRet = RegDeleteValueW(hkeyNew, pwszValue);
RegCloseKey(hkeyNew);
}
}
else
{
CHAR szSubKey[MAX_PATH];
CHAR szValue[MAX_PATH];
LPSTR pszSubKey = NULL;
LPSTR pszValue = NULL;
if (pwszSubKey)
{
WideCharToMultiByte(CP_ACP, 0, pwszSubKey, -1, szSubKey, SIZECHARS(szSubKey), NULL, NULL);
pszSubKey = szSubKey;
}
if (pwszValue)
{
WideCharToMultiByte(CP_ACP, 0, pwszValue, -1, szValue, SIZECHARS(szValue), NULL, NULL);
pszValue = szValue;
}
dwRet = SHDeleteValueA(hkey, pszSubKey, pszValue);
}
return dwRet;
}
// purpose: recursively copy subkeys and values of hkeySrc\pszSrcSubKey to hkeyDest
// e.g. hkeyExplorer = HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\
// SHCopyKey(HKEY_CURRENT_USER, "Software\\Classes\\", hkeyExplorer, 0)
// results in
// ...\\CurrentVersion\\Explorer\\
// Appid
// CLSID\\
// {xxxx yyyyy ...}
// Interface
// ...
// TO DO: currently we are not copying the ACL's but in the future we should do that
// upon request that's what fReserved is for
// NOTE that there is no hkeyDest, pszDestSubKey pair like src one, because in case
// pszDestSubKey did not exist we would have to create it and deal with Class name
// which would just clober the parameter list
STDAPI_(DWORD) SHCopyKeyA(HKEY hkeySrc, LPCSTR pszSrcSubKey, HKEY hkeyDest, DWORD fReserved)
{
HKEY hkeyFrom;
DWORD dwRet;
if (pszSrcSubKey)
dwRet = RegOpenKeyExA(hkeySrc, pszSrcSubKey, 0, MAXIMUM_ALLOWED, &hkeyFrom);
else if (hkeySrc)
{
dwRet = ERROR_SUCCESS;
hkeyFrom = hkeySrc;
}
else
dwRet = ERROR_INVALID_PARAMETER;
if (dwRet == ERROR_SUCCESS)
{
DWORD dwIndex;
DWORD cchValueSize;
DWORD cchClassSize;
DWORD dwType;
CHAR szValue[MAX_PATH]; //NOTE:szValue is also used to store subkey name when enumerating keys
CHAR szClass[MAX_PATH];
cchValueSize = ARRAYSIZE(szValue);
cchClassSize = ARRAYSIZE(szClass);
for (dwIndex=0;
dwRet == ERROR_SUCCESS && (dwRet = RegEnumKeyExA(hkeyFrom, dwIndex, szValue, &cchValueSize, NULL, szClass, &cchClassSize, NULL)) == ERROR_SUCCESS;
dwIndex++, cchValueSize = ARRAYSIZE(szValue), cchClassSize = ARRAYSIZE(szClass))
{
HKEY hkeyTo;
DWORD dwDisp;
// create new key
dwRet = RegCreateKeyExA(hkeyDest, szValue, 0, szClass, REG_OPTION_NON_VOLATILE, MAXIMUM_ALLOWED, NULL, &hkeyTo, &dwDisp);
if (dwRet != ERROR_SUCCESS)
break;
dwRet = SHCopyKeyA(hkeyFrom, szValue, hkeyTo, fReserved); //if not error_success we break out
RegCloseKey(hkeyTo);
}
// copied all the sub keys, now copy all the values
if (dwRet == ERROR_NO_MORE_ITEMS)
{
DWORD cb, cbBufferSize;
LPBYTE lpbyBuffer;
// get the max value size
dwRet = RegQueryInfoKey(hkeyFrom, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, &cb, NULL, NULL);
if (dwRet == ERROR_SUCCESS)
{
// allocate buffer
cb++; // add 1 just in case of a string
lpbyBuffer = (LPBYTE)LocalAlloc(LPTR, cb);
if (lpbyBuffer)
cbBufferSize = cb;
else
dwRet = ERROR_OUTOFMEMORY;
cchValueSize = ARRAYSIZE(szValue);
for (dwIndex=0;
dwRet == ERROR_SUCCESS && (dwRet = RegEnumValueA(hkeyFrom, dwIndex, szValue, &cchValueSize, NULL, &dwType, lpbyBuffer, &cb)) == ERROR_SUCCESS;
dwIndex++, cchValueSize = ARRAYSIZE(szValue), cb = cbBufferSize)
{
// cb has the size of the value so use it rather than cbBufferSize which is just max size
dwRet = RegSetValueExA(hkeyDest, szValue, 0, dwType, lpbyBuffer, cb);
if (dwRet != ERROR_SUCCESS)
break;
}
if (lpbyBuffer != NULL)
LocalFree(lpbyBuffer);
}
}
if (dwRet == ERROR_NO_MORE_ITEMS)
dwRet = ERROR_SUCCESS;
if (pszSrcSubKey)
RegCloseKey(hkeyFrom);
}
return dwRet;
}
STDAPI_(DWORD) SHCopyKeyW(HKEY hkeySrc, LPCWSTR pwszSrcSubKey, HKEY hkeyDest, DWORD fReserved)
{
CHAR sz[MAX_PATH];
if (pwszSrcSubKey)
WideCharToMultiByte(CP_ACP, 0, pwszSrcSubKey, -1, sz, SIZECHARS(sz), NULL, NULL);
return SHCopyKeyA(hkeySrc, pwszSrcSubKey ? sz : NULL, hkeyDest, fReserved);
}
/*----------------------------------------------------------
Purpose: Delete a key only if there are no subkeys or values.
It comes close to mimicking the behavior of RegDeleteKey
as it works on NT, except the NT version ignores values.
*/
STDAPI_(DWORD)
SHDeleteEmptyKeyA(
IN HKEY hkey,
IN LPCSTR pszSubKey)
{
return DeleteEmptyKey(hkey, pszSubKey);
}
/*----------------------------------------------------------
Purpose: Delete a key only if there are no subkeys or values.
It comes close to mimicking the behavior of RegDeleteKey
as it works on NT, except the NT version ignores values.
*/
STDAPI_(DWORD)
SHDeleteEmptyKeyW(
IN HKEY hkey,
IN LPCWSTR pwszSubKey)
{
CHAR sz[MAX_PATH];
WideCharToMultiByte(CP_ACP, 0, pwszSubKey, -1, sz, SIZECHARS(sz), NULL, NULL);
return DeleteEmptyKey(hkey, sz);
}
/*----------------------------------------------------------
Purpose: Recursively delete the key, including all child values
and keys.
Returns:
Cond: --
*/
STDAPI_(DWORD)
SHDeleteKeyA(
IN HKEY hkey,
IN LPCSTR pszSubKey)
{
DWORD dwRet;
if (g_bRunningOnNT || !pszSubKey)
{
dwRet = DeleteKeyRecursively(hkey, pszSubKey);
}
else
{
// On Win95, RegDeleteKey does what we want
dwRet = RegDeleteKeyA(hkey, pszSubKey);
}
return dwRet;
}
/*----------------------------------------------------------
Purpose: Recursively delete the key, including all child values
and keys.
Returns:
Cond: --
*/
STDAPI_(DWORD)
SHDeleteKeyW(
IN HKEY hkey,
IN LPCWSTR pwszSubKey)
{
DWORD dwRet;
CHAR sz[MAX_PATH];
WideCharToMultiByte(CP_ACP, 0, pwszSubKey, -1, sz, SIZECHARS(sz), NULL, NULL);
if (g_bRunningOnNT)
{
dwRet = DeleteKeyRecursively(hkey, sz);
}
else
{
// On Win95, RegDeleteKey does what we want
dwRet = RegDeleteKeyA(hkey, sz);
}
return dwRet;
}
STDAPI_(DWORD) FixupRegStringA(HKEY hk, PCSTR pszValue, BOOL fExpand, DWORD err, void *pvData, DWORD *pcbData, DWORD *pcbSize);
STDAPI_(DWORD) FixupRegStringW(HKEY hk, PCWSTR pszValue, BOOL fExpand, DWORD err, void *pvData, DWORD *pcbData, DWORD *pcbSize);
/*----------------------------------------------------------
Purpose: Behaves just like RegQueryValueEx, except if the
data type is REG_EXPAND_SZ, then this goes ahead
and expands out the string. *pdwType will always
be massaged to REG_SZ if this happens.
Returns:
Cond: --
*/
STDAPI_(DWORD)
SHQueryValueExA(
IN HKEY hkey,
IN LPCSTR pszValue,
IN LPDWORD lpReserved,
OUT LPDWORD pdwType,
OUT LPVOID pvData,
IN OUT LPDWORD pcbData)
{
DWORD dwRet;
DWORD cbSize = 0;
DWORD dwType = REG_NONE;
DWORD cbOriginal = 0;
if (pvData)
{
RIPMSG(pcbData != NULL, "SHQueryValuegExW: caller passed pvData output buffer but not size of buffer (pcbData)!");
}
// Trying to get back data
if (pcbData)
{
cbOriginal = cbSize = *pcbData; // Size of output buffer
}
dwRet = RegQueryValueExA(hkey, pszValue, lpReserved, &dwType,
pvData, &cbSize);
// Normally, we'd be done with this. But do some extra work
// if this is an expandable string (something that has system
// variables in it), or if we need to pad the buffer.
if (REG_SZ == dwType || REG_EXPAND_SZ == dwType)
{
dwRet = FixupRegStringA(hkey, pszValue, REG_EXPAND_SZ == dwType, dwRet, pvData, pcbData, &cbSize);
// Massage dwType so that callers always see REG_SZ
dwType = REG_SZ;
}
if (pdwType)
*pdwType = dwType;
if (pcbData)
*pcbData = cbSize;
return dwRet;
}
/*----------------------------------------------------------
Purpose: Behaves just like RegQueryValueEx, except if the
data type is REG_EXPAND_SZ, then this goes ahead
and expands out the string. *pdwType will always
be massaged to REG_SZ if this happens.
Returns:
Cond: --
*/
STDAPI_(DWORD)
SHQueryValueExW(
IN HKEY hkey,
IN LPCWSTR pwszValue,
IN LPDWORD lpReserved,
OUT LPDWORD pdwType,
OUT LPVOID pvData,
IN OUT LPDWORD pcbData)
{
DWORD dwRet;
DWORD cbSize = 0;
DWORD dwType = REG_NONE;
if (pvData)
{
RIPMSG(pcbData != NULL, "SHQueryValueExW: caller passed pvData output buffer but not size of buffer (pcbData)!");
}
if ( !g_bRunningOnNT )
{
CHAR szValue[MAX_PATH];
LPSTR pszValue = NULL;
DWORD dwOriginalSize = 0;
if (pvData && pcbData)
dwOriginalSize = *pcbData;
if (pwszValue)
{
WideCharToMultiByte(CP_ACP, 0, pwszValue, -1, szValue, SIZECHARS(szValue), NULL, NULL);
pszValue = szValue;
}
if (!pdwType)
pdwType = &dwType;
dwRet = SHQueryValueExA(hkey, pszValue, lpReserved, pdwType, pvData, pcbData);
if (NO_ERROR == dwRet)
dwRet = RegData_AtoW(pvData, dwOriginalSize, *pdwType, pcbData); // Thunk data from ANSI->UNICODE if needed.
}
else
{
// Running on NT
// Trying to get back data
if (pvData && pcbData)
{
cbSize = *pcbData;
}
dwRet = RegQueryValueExW(hkey, pwszValue, lpReserved, &dwType,
pvData, &cbSize);
// Normally, we'd be done with this. But do some extra work
// if this is an expandable string (something that has system
// variables in it), or if we need to pad the buffer.
if (REG_SZ == dwType || REG_EXPAND_SZ == dwType)
{
dwRet = FixupRegStringW(hkey, pwszValue, REG_EXPAND_SZ == dwType, dwRet, pvData, pcbData, &cbSize);
// Massage dwType so that callers always see REG_SZ
dwType = REG_SZ;
}
if (pdwType)
*pdwType = dwType;
if (pcbData)
*pcbData = cbSize;
}
return dwRet;
}
/*----------------------------------------------------------
Purpose: Behaves just like RegEnumKeyExA, except it does not let
you look at the class and timestamp of the sub-key. Written
to provide equivalent for SHEnumKeyExW which is useful on
Win95.
Returns:
Cond: --
*/
STDAPI_(LONG)
SHEnumKeyExA
(
IN HKEY hkey,
IN DWORD dwIndex,
OUT LPSTR pszName,
IN OUT LPDWORD pcchName
)
{
return RegEnumKeyExA(hkey, dwIndex, pszName, pcchName, NULL, NULL, NULL, NULL);
}
/*----------------------------------------------------------
Purpose: Behaves just like RegEnumKeyExW, except it does not let
you look at the class and timestamp of the sub-key.
Wide char version supported under Win95.
Returns:
Cond: --
*/
STDAPI_(LONG)
SHEnumKeyExW
(
IN HKEY hkey,
IN DWORD dwIndex,
OUT LPWSTR pszName,
IN OUT LPDWORD pcchName
)
{
LONG lRet = NO_ERROR;
if ( !g_bRunningOnNT )
{
// We are reading in sub-key names. regapix.h suggests MAXIMUM_SUB_KEY_LENGTH = 256,
// so MAX_PATH should be enough. Is this the official limit.
CHAR sz[MAX_PATH];
DWORD dwSize = sizeof(sz);
lRet = RegEnumKeyExA(hkey, dwIndex, sz, &dwSize, NULL, NULL, NULL, NULL);
if (NO_ERROR != lRet)
{
ASSERT(ERROR_MORE_DATA != lRet);
}
else
{
int cch = MultiByteToWideChar(CP_ACP, 0, sz, -1, NULL, 0);
if (NULL == pcchName)
{
lRet = ERROR_INVALID_PARAMETER;
}
else if (NULL == pszName || *pcchName < (DWORD)cch )
{
*pcchName = cch;
lRet = (NULL == pszName) ? ERROR_SUCCESS : ERROR_MORE_DATA ;
}
else
{
// Not supposed to include null terminator in count if successful.
*pcchName = cch - 1;
MultiByteToWideChar(CP_ACP, 0, sz, -1, pszName, cch);
ASSERT(NO_ERROR == lRet);
}
}
}
else
{
lRet = RegEnumKeyExW(hkey, dwIndex, pszName, pcchName, NULL, NULL, NULL, NULL);
}
return lRet;
}
/*----------------------------------------------------------
Purpose: Behaves just like RegEnumValueA. Written to provide
equivalent for SHEnumKeyExW which is useful on Win95.
Environment vars in a string are NOT expanded.
Returns:
Cond: --
*/
STDAPI_(LONG)
SHEnumValueA
(
IN HKEY hkey,
IN DWORD dwIndex,
OUT LPSTR pszValueName, OPTIONAL
IN OUT LPDWORD pcchValueName, OPTIONAL
OUT LPDWORD pdwType, OPTIONAL
OUT LPVOID pvData, OPTIONAL
IN OUT LPDWORD pcbData OPTIONAL
)
{
return RegEnumValueA(hkey, dwIndex, pszValueName, pcchValueName, NULL, pdwType, pvData, pcbData);
}
/*----------------------------------------------------------
Purpose: Behaves just like RegEnumValueW. Wide char version
works on Win95.
Environment vars in a string are NOT expanded.
Returns:
Cond: --
*/
STDAPI_(LONG)
SHEnumValueW
(
IN HKEY hkey,
IN DWORD dwIndex,
OUT LPWSTR pszValueName, OPTIONAL
IN OUT LPDWORD pcchValueName, OPTIONAL
OUT LPDWORD pdwType, OPTIONAL
OUT LPVOID pvData, OPTIONAL
IN OUT LPDWORD pcbData OPTIONAL
)
{
LONG lRet;
if ( !g_bRunningOnNT )
{
CHAR sz[MAX_PATH]; // This should be sufficient to read the value name.
DWORD dwSize = sizeof(sz);
DWORD dwType;
DWORD cbSizeSav = 0;
if (pcbData)
cbSizeSav = *pcbData;
lRet = RegEnumValueA(hkey, dwIndex, sz, &dwSize, NULL, &dwType, pvData, pcbData);
if (pdwType)
*pdwType = dwType;
if (NO_ERROR == lRet)
{
// Convert the ValueName to unicode.
if (pcchValueName)
{
int cch = MultiByteToWideChar(CP_ACP, 0, sz, -1, NULL, 0);
if (NULL == pszValueName || *pcchValueName < (DWORD)cch )
{
*pcchValueName = cch;
lRet = (NULL == pszValueName) ? ERROR_SUCCESS : ERROR_MORE_DATA ;
}
else
{
// Not supposed to include null terminator in count if returning
// back name succesfully.
*pcchValueName = cch - 1;
// cch should be sufficient
MultiByteToWideChar(CP_ACP, 0, sz, -1, pszValueName, cch);
}
}
// Next convert the data to unicode if it is a string.
if ((NOERROR == lRet) && pcbData)
lRet = RegData_AtoW(pvData, cbSizeSav, dwType, pcbData);
}
}
else
{
lRet = RegEnumValueW(hkey, dwIndex, pszValueName, pcchValueName, NULL, pdwType, pvData, pcbData);
}
return lRet;
}
/*----------------------------------------------------------
Purpose: Behaves just like RegQueryInfoKeyA. Written to provide
equivalent for W version.
Returns:
Cond: --
*/
STDAPI_(LONG)
SHQueryInfoKeyA
(
IN HKEY hkey,
OUT LPDWORD pcSubKeys, OPTIONAL
OUT LPDWORD pcchMaxSubKeyLen, OPTIONAL
OUT LPDWORD pcValues, OPTIONAL
OUT LPDWORD pcchMaxValueNameLen OPTIONAL
)
{
return RegQueryInfoKeyA(hkey, NULL, NULL, NULL, pcSubKeys, pcchMaxSubKeyLen,
NULL, pcValues, pcchMaxValueNameLen, NULL, NULL, NULL);
}
/*----------------------------------------------------------
Purpose: Behaves just like RegQueryInfoKeyW. Works on Win95.
Returns:
Cond: --
*/
STDAPI_(LONG)
SHQueryInfoKeyW
(
IN HKEY hkey,
OUT LPDWORD pcSubKeys, OPTIONAL
OUT LPDWORD pcchMaxSubKeyLen, OPTIONAL
OUT LPDWORD pcValues, OPTIONAL
OUT LPDWORD pcchMaxValueNameLen OPTIONAL
)
{
LONG lRet;
if (!g_bRunningOnNT)
{
lRet = RegQueryInfoKeyA(hkey, NULL, NULL, NULL, pcSubKeys, pcchMaxSubKeyLen,
NULL, pcValues, pcchMaxValueNameLen, NULL, NULL, NULL);
if (NO_ERROR == lRet)
{
// *pcchMaxSubKeyLen has the number of single byte chars reqd for the
// KeyName. We return back the same value which is an upper limit on
// the number of Unicode characters needed. We will ask for more
// Unicode chars than required if the string has DBCS characters.
// Without knowing the actual string this is the best guess we can take.
}
}
else
{
lRet = RegQueryInfoKeyW(hkey, NULL, NULL, NULL, pcSubKeys, pcchMaxSubKeyLen,
NULL, pcValues, pcchMaxValueNameLen, NULL, NULL, NULL);
}
return lRet;
}
/*----------------------------------------------------------*\
USER SPECIFC SETTINGS
DESCRIPTION:
These functions will be used to query User Specific settings
correctly. The installer needs to populate HKLM
with User specific settings, because that's the only part
of the registry that is shared between all users. Code will
then read values from HKCU, and if that's empty, it
will look in HKLM. The only exception is that if
TRUE is passed in for the fIgnore parameter, then the HKLM version
will be used instead of HKCU. This is the way that an admin can
specify that they doesn't want users to be able to use their
User Specific values (HKCU).
\*----------------------------------------------------------*/
typedef struct tagUSKEY
{
HKEY hkeyCurrentUser;
HKEY hkeyCurrentUserRelative;
HKEY hkeyLocalMachine;
HKEY hkeyLocalMachineRelative;
CHAR szSubPath[MAXIMUM_SUB_KEY_LENGTH];
REGSAM samDesired;
} USKEY;
typedef USKEY * PUSKEY;
typedef PUSKEY * PPUSKEY;
#define IS_HUSKEY_VALID(pUSKey) (((pUSKey) && IS_VALID_WRITE_PTR((pUSKey), USKEY) && ((pUSKey)->hkeyCurrentUser || (pUSKey)->hkeyLocalMachine)))
// Private Helper Function
// Bring the out of date key up to date.
LONG PrivFullOpen(PUSKEY pUSKey)
{
LONG lRet = ERROR_SUCCESS;
HKEY *phkey = NULL;
HKEY *phkeyRel = NULL;
ASSERT(IS_HUSKEY_VALID(pUSKey)); // Will always be true, but assert against maintainence mistakes
if (!pUSKey->hkeyCurrentUser) // Do we need to open HKCU?
{
phkey = &(pUSKey->hkeyCurrentUser);
phkeyRel = &(pUSKey->hkeyCurrentUserRelative);
}
if (!pUSKey->hkeyLocalMachine) // Do we need to open HKLM?
{
phkey = &(pUSKey->hkeyLocalMachine);
phkeyRel = &(pUSKey->hkeyLocalMachineRelative);
}
if ((phkeyRel) && (*phkeyRel))
{
ASSERT(phkey); // Will always be true, but assert against maintainence mistakes
lRet = RegOpenKeyExA(*phkeyRel, pUSKey->szSubPath, 0, pUSKey->samDesired, phkey);
// If we need to bring the out of date key, up to date, we need to free the old one.
if ((HKEY_CURRENT_USER != *phkeyRel) && (HKEY_LOCAL_MACHINE != *phkeyRel))
RegCloseKey(*phkeyRel);
*phkeyRel = NULL;
pUSKey->szSubPath[0] = '\0';
}
return lRet;
}
// Private Helper Function
// Bring the out of date key up to date.
LONG PrivFullCreate(PUSKEY pUSKey)
{
LONG lRet = ERROR_SUCCESS;
HKEY *phkey = NULL;
HKEY *phkeyRel = NULL;
ASSERT(IS_HUSKEY_VALID(pUSKey)); // Will always be true, but assert against maintainence mistakes
if (!pUSKey->hkeyCurrentUser) // Do we need to open HKCU?
{
phkey = &(pUSKey->hkeyCurrentUser);
phkeyRel = &(pUSKey->hkeyCurrentUserRelative);
}
if (!pUSKey->hkeyLocalMachine) // Do we need to open HKLM?
{
phkey = &(pUSKey->hkeyLocalMachine);
phkeyRel = &(pUSKey->hkeyLocalMachineRelative);
}
if ((phkeyRel) && (*phkeyRel))
{
ASSERT(phkey); // Will always be true, but assert against maintainence mistakes
lRet = RegCreateKeyExA(*phkeyRel, pUSKey->szSubPath, 0, NULL, REG_OPTION_NON_VOLATILE, pUSKey->samDesired, NULL, phkey, NULL);
// If we need to bring the out of date key, up to date, we need to free the old one.
if ((HKEY_CURRENT_USER != *phkeyRel) && (HKEY_LOCAL_MACHINE != *phkeyRel))
RegCloseKey(*phkeyRel);
*phkeyRel = NULL;
pUSKey->szSubPath[0] = '\0';
}
return lRet;
}
// Private Helper Function
// Create one of the keys (Called for both HKLM and HKCU)
LONG PrivCreateKey(LPHKEY lphkey, LPHKEY lphkeyRelative, LPCSTR lpSubPath, REGSAM samDesired)
{
LONG lRet = ERROR_SUCCESS;
if (*lphkeyRelative)
{
lRet = RegCreateKeyExA(*lphkeyRelative, lpSubPath, 0, NULL, REG_OPTION_NON_VOLATILE, samDesired, NULL, lphkey, NULL);
*lphkeyRelative = NULL;
}
else
{
// If the relative key == NULL, then we don't have enough of the path to
// create this key.
return(ERROR_INVALID_PARAMETER);
}
return(lRet);
}
// Private Helper Function
// Query for the specific value.
LONG PrivRegQueryValue(
IN PUSKEY pUSKey,
IN HKEY *phkey,
IN LPCWSTR pwzValue, // May have been an ANSI String type case. Use fWideChar to determine if so.
IN BOOL fWideChar,
OUT LPDWORD pdwType, OPTIONAL
OUT LPVOID pvData, OPTIONAL
OUT LPDWORD pcbData) OPTIONAL
{
LONG lRet = ERROR_SUCCESS;
ASSERT(IS_HUSKEY_VALID(pUSKey)); // Will always be true, but assert against maintainence mistakes
// It may be necessary to open the key
if (NULL == *phkey)
lRet = PrivFullOpen(pUSKey);
if ((ERROR_SUCCESS == lRet) && (*phkey))
{
if (fWideChar)
lRet = SHQueryValueExW(*phkey, pwzValue, NULL, pdwType, pvData, pcbData);
else
lRet = SHQueryValueExA(*phkey, (LPCSTR)pwzValue, NULL, pdwType, pvData, pcbData);
}
else
lRet = ERROR_INVALID_PARAMETER;
return lRet;
}
// Private Helper Function
// Query for the specific value.
LONG PrivRegWriteValue(
IN PUSKEY pUSKey,
IN HKEY *phkey,
IN LPCWSTR pwzValue, // May have been an ANSI String type case. Use fWideChar to determine if so.
IN BOOL bWideChar,
IN BOOL bForceWrite,
IN DWORD dwType, OPTIONAL
IN LPCVOID pvData, OPTIONAL
IN DWORD cbData) OPTIONAL
{
LONG lRet = ERROR_SUCCESS;
ASSERT(IS_HUSKEY_VALID(pUSKey)); // Will always be true, but assert against maintainence mistakes
// It may be necessary to open the key
if (NULL == *phkey)
lRet = PrivFullCreate(pUSKey);
// Check if the caller only want's to write value if it's empty
if (!bForceWrite)
{ // Yes we need to check before we write.
if (bWideChar)
bForceWrite = !(ERROR_SUCCESS == SHQueryValueExW(*phkey, pwzValue, NULL, NULL, NULL, NULL));
else
bForceWrite = !(ERROR_SUCCESS == SHQueryValueExA(*phkey, (LPCSTR)pwzValue, NULL, NULL, NULL, NULL));
}
if ((ERROR_SUCCESS == lRet) && (*phkey) && bForceWrite)
{
if (bWideChar)
// RegSetValueExW is not supported on Win95 but we have a thunking function.
lRet = RegSetValueExW(*phkey, pwzValue, 0, dwType, pvData, cbData);
else
lRet = RegSetValueExA(*phkey, (LPCSTR)pwzValue, 0, dwType, pvData, cbData);
}
return lRet;
}
// Private helper function
// Enum sub-keys of a key.
LONG PrivRegEnumKey(
IN PUSKEY pUSKey,
IN HKEY *phkey,
IN DWORD dwIndex,
IN LPWSTR pwzName, // May have been an ANSI String type case. Use fWideChar to determine if so.
IN BOOL fWideChar,
IN OUT LPDWORD pcchName
)
{
LONG lRet = ERROR_SUCCESS;
ASSERT(IS_HUSKEY_VALID(pUSKey));
// It may be necessary to open the key
if (NULL == *phkey)
lRet = PrivFullOpen(pUSKey);
if ((ERROR_SUCCESS == lRet) && (*phkey))
{
if (fWideChar)
lRet = SHEnumKeyExW(*phkey, dwIndex, pwzName, pcchName);
else
lRet = SHEnumKeyExA(*phkey, dwIndex, (LPSTR)pwzName, pcchName);
}
else
lRet = ERROR_INVALID_PARAMETER;
return lRet;
}
// Private helper function
// Enum values of a key.
LONG PrivRegEnumValue(
IN PUSKEY pUSKey,
IN HKEY *phkey,
IN DWORD dwIndex,
IN LPWSTR pwzValueName, // May have been an ANSI String type case. Use fWideChar to determine if so.
IN BOOL fWideChar,
IN OUT LPDWORD pcchValueName,
OUT LPDWORD pdwType, OPTIONAL
OUT LPVOID pvData, OPTIONAL
IN OUT LPDWORD pcbData OPTIONAL
)
{
LONG lRet = ERROR_SUCCESS;
ASSERT(IS_HUSKEY_VALID(pUSKey));
// It may be necessary to open the key
if (NULL == *phkey)
lRet = PrivFullOpen(pUSKey);
if ((ERROR_SUCCESS == lRet) && (*phkey))
{
if (fWideChar)
lRet = SHEnumValueW(*phkey, dwIndex, pwzValueName, pcchValueName, pdwType, pvData, pcbData);
else
lRet = SHEnumValueA(*phkey, dwIndex, (LPSTR)pwzValueName, pcchValueName, pdwType, pvData, pcbData);
}
else
lRet = ERROR_INVALID_PARAMETER;
return lRet;
}
// Query the Key information.
LONG PrivRegQueryInfoKey(
IN PUSKEY pUSKey,
IN HKEY *phkey,
IN BOOL fWideChar,
OUT LPDWORD pcSubKeys, OPTIONAL
OUT LPDWORD pcchMaxSubKeyLen, OPTIONAL
OUT LPDWORD pcValues, OPTIONAL
OUT LPDWORD pcchMaxValueNameLen OPTIONAL
)
{
LONG lRet = ERROR_SUCCESS;
ASSERT(IS_HUSKEY_VALID(pUSKey));
if (NULL == *phkey)
lRet = PrivFullOpen(pUSKey);
if ((ERROR_SUCCESS == lRet) && (*phkey))
{
if (fWideChar)
lRet = SHQueryInfoKeyW(*phkey, pcSubKeys, pcchMaxSubKeyLen, pcValues, pcchMaxValueNameLen);
else
lRet = SHQueryInfoKeyA(*phkey, pcSubKeys, pcchMaxSubKeyLen, pcValues, pcchMaxValueNameLen);
}
else
lRet = ERROR_INVALID_PARAMETER;
return lRet;
}
/*----------------------------------------------------------
Purpose: Create or open a user specifc registry key (HUSKEY).
Description: This function will:
1. Allocate a new USKEY structure.
2. Initialize the structure.
3. Create/Open HKLM if that flag is set.
4. Create/Open HKCU if that flag is set.
Note that there is no difference between FORCE and
don't force in the dwFlags parameter.
The hUSKeyRelative parameter should have also been opened by
a call to SHRegCreateUSKey. If SHRegOpenUSKey was called,
it could have returned ERROR_SUCCESS but still be invalid
for calling this function. This will occur if: 1) the parameter
fIgnoreHKCU was FALSE, 2) it was a relative open, 3) the
HKCU branch could not be opened because it didn't exist, and
4) HKLM opened successfully. This situation renders the
HUSKEY valid for reading but not writing.
Returns: LONG containing success or error code.
Cond: --
*/
STDAPI_(LONG)
SHRegCreateUSKeyA(
IN LPCSTR pszPath,
IN REGSAM samDesired, // security access mask
IN HUSKEY hUSKeyRelative, OPTIONAL
OUT PHUSKEY phUSKey,
IN DWORD dwFlags) // Indicates whether to create/open HKCU, HKLM, or both
{
PUSKEY pUSKeyRelative = (PUSKEY) hUSKeyRelative;
PPUSKEY ppUSKey = (PPUSKEY) phUSKey;
PUSKEY pUSKey;
LONG lRet = ERROR_SUCCESS;
CHAR szTempPath[MAXIMUM_SUB_KEY_LENGTH] = "\0";
LPCSTR lpszHKLMPath = szTempPath;
LPCSTR lpszHKCUPath = szTempPath;
ASSERT(ppUSKey);
// The following are invalid parameters...
// 1. ppUSKey cannot be NULL
// 2. If this is a relative open, pUSKeyRelative needs to be a valid HUSKEY.
// 3. The user needs to have specified one of the following: SHREGSET_HKCU, SHREGSET_FORCE_HKCU, SHREGSET_HKLM, SHREGSET_FORCE_HKLM.
if ((!ppUSKey) || // 1.
(pUSKeyRelative && FALSE == IS_HUSKEY_VALID(pUSKeyRelative)) || // 2.
!(dwFlags & (SHREGSET_HKCU | SHREGSET_FORCE_HKCU | SHREGSET_HKLM | SHREGSET_FORCE_HKLM))) // 3.
{
return ERROR_INVALID_PARAMETER;
}
// The temp path will be used when bringing the keys
// up todate that was out of date in the Relative key.
if (pUSKeyRelative)
{
lstrcpyA(szTempPath, pUSKeyRelative->szSubPath);
PathAddBackslashA(szTempPath);
}
StrNCatA(szTempPath, pszPath, ARRAYSIZE(szTempPath) - lstrlenA(szTempPath) - 1);
///// 1. Allocate a new USKEY structure.
pUSKey = *ppUSKey = (PUSKEY)LocalAlloc(LPTR, sizeof(USKEY));
if (!pUSKey)
return ERROR_NOT_ENOUGH_MEMORY;
///// 2. Initialize the structure.
if (!pUSKeyRelative)
{
// Init a new (non-relative) open.
pUSKey->hkeyLocalMachineRelative = HKEY_LOCAL_MACHINE;
pUSKey->hkeyCurrentUserRelative = HKEY_CURRENT_USER;
}
else
{
// Init a new (relative) open.
*pUSKey = *pUSKeyRelative;
if (pUSKey->hkeyLocalMachine)
{
pUSKey->hkeyLocalMachineRelative = pUSKey->hkeyLocalMachine;
pUSKey->hkeyLocalMachine = NULL;
lpszHKLMPath = pszPath;
// This key is up to date in the Relative Key. If the
// user doesn't want it to be up todate in the new key,
// we don't need the path from the Relative key.
if (!(dwFlags & (SHREGSET_HKLM | SHREGSET_FORCE_HKLM)))
*(pUSKey->szSubPath) = '\0';
}
// We need to copy the key if:
// 1. It will not be created in this call, and
// 2. The relative key is not HKEY_LOCAL_MACHINE.
if (!(dwFlags & (SHREGSET_HKLM | SHREGSET_FORCE_HKLM)) &&
(pUSKey->hkeyLocalMachineRelative != HKEY_LOCAL_MACHINE))
{
// Make a duplicate of this key.
lRet = RegOpenKeyExA(pUSKey->hkeyLocalMachineRelative, NULL, 0, pUSKey->samDesired, &(pUSKey->hkeyLocalMachineRelative));
}
if (pUSKey->hkeyCurrentUser)
{
pUSKey->hkeyCurrentUserRelative = pUSKey->hkeyCurrentUser;
pUSKey->hkeyCurrentUser = NULL;
lpszHKCUPath = pszPath;
// This key is up to date in the Relative Key. If the
// user doesn't want it to be up todate in the new key,
// we don't need the path from the Relative key.
if (!(dwFlags & (SHREGSET_HKCU | SHREGSET_FORCE_HKCU)))
*(pUSKey->szSubPath) = '\0';
}
// We need to copy the key if:
// 1. It will not be created in this call, and
// 2. The relative key is not HKEY_CURRENT_USER.
if (!(dwFlags & (SHREGSET_HKCU | SHREGSET_FORCE_HKCU)) &&
(pUSKey->hkeyCurrentUserRelative != HKEY_CURRENT_USER))
{
// Make a duplicate of this key.
lRet = RegOpenKeyExA(pUSKey->hkeyCurrentUserRelative, NULL, 0, pUSKey->samDesired, &(pUSKey->hkeyCurrentUserRelative));
}
}
pUSKey->samDesired = samDesired;
///// 3. Create/Open HKLM if that flag is set or fill in the structure as appropriate.
if ((ERROR_SUCCESS == lRet) && (dwFlags & (SHREGSET_HKLM | SHREGSET_FORCE_HKLM)))
lRet = PrivCreateKey(&(pUSKey->hkeyLocalMachine), &(pUSKey->hkeyLocalMachineRelative), lpszHKLMPath, pUSKey->samDesired);
///// 4. Create/Open HKCU if that flag is set or fill in the structure as appropriate.
if ((ERROR_SUCCESS == lRet) && (dwFlags & (SHREGSET_HKCU | SHREGSET_FORCE_HKCU)))
lRet = PrivCreateKey(&(pUSKey->hkeyCurrentUser), &(pUSKey->hkeyCurrentUserRelative), lpszHKCUPath, pUSKey->samDesired);
if ((dwFlags & (SHREGSET_HKCU | SHREGSET_FORCE_HKCU)) &&
(dwFlags & (SHREGSET_HKLM | SHREGSET_FORCE_HKLM)))
{
// The caller wanted both to be opened.
*(pUSKey->szSubPath) = '\0'; // Both paths are open so Delta Path is empty.
}
else
{
// One of the paths is not open so set the Delta Path in case it needs to be opened later.
if (*(pUSKey->szSubPath))
PathAddBackslashA(pUSKey->szSubPath);
StrNCatA(pUSKey->szSubPath, pszPath, ARRAYSIZE(pUSKey->szSubPath) - lstrlenA(pUSKey->szSubPath) - 1);
}
// Free the memory if we are not successful.
if (ERROR_SUCCESS != lRet)
{
if (pUSKey->hkeyCurrentUser)
RegCloseKey(pUSKey->hkeyCurrentUser);
if (pUSKey->hkeyCurrentUserRelative && pUSKey->hkeyCurrentUserRelative != HKEY_CURRENT_USER)
RegCloseKey(pUSKey->hkeyCurrentUserRelative);
if (pUSKey->hkeyLocalMachine)
RegCloseKey(pUSKey->hkeyLocalMachine);
if (pUSKey->hkeyLocalMachineRelative && pUSKey->hkeyLocalMachineRelative != HKEY_LOCAL_MACHINE)
RegCloseKey(pUSKey->hkeyLocalMachineRelative);
LocalFree((HLOCAL)pUSKey);
*ppUSKey = NULL;
}
return lRet;
}
/*----------------------------------------------------------
Purpose: Create or open a user specifc registry key (HUSKEY).
Description: This function will:
1. Allocate a new USKEY structure.
2. Initialize the structure.
3. Create/Open HKLM if that flag is set.
4. Create/Open HKCU if that flag is set.
Note that there is no difference between FORCE and
don't force in the dwFlags parameter.
The hUSKeyRelative parameter should have also been opened by
a call to SHRegCreateUSKey. If SHRegOpenUSKey was called,
it could have returned ERROR_SUCCESS but still be invalid
for calling this function. This will occur if: 1) the parameter
fIgnoreHKCU was FALSE, 2) it was a relative open, 3) the
HKCU branch could not be opened because it didn't exist, and
4) HKLM opened successfully. This situation renders the
HUSKEY valid for reading but not writing.
Returns: LONG containing success or error code.
Cond: --
*/
STDAPI_(LONG)
SHRegCreateUSKeyW(
IN LPCWSTR pwzPath,
IN REGSAM samDesired, // security access mask
IN HUSKEY hUSKeyRelative, OPTIONAL
OUT PHUSKEY phUSKey,
IN DWORD dwFlags) // Indicates whether to create/open HKCU, HKLM, or both
{
CHAR szNewPath[MAXIMUM_SUB_KEY_LENGTH];
// Thunk Path to Wide chars.
if (FALSE == WideCharToMultiByte(CP_ACP, 0, pwzPath, -1, szNewPath, sizeof(szNewPath), NULL, 0))
return GetLastError();
return SHRegCreateUSKeyA(szNewPath, samDesired, hUSKeyRelative, phUSKey, dwFlags);
}
/*----------------------------------------------------------
Purpose: Open a user specifc registry key (HUSKEY).
Description: This function will:
1. Allocate a new USKEY structure.
2. Initialize the structure.
3. Determine which key (HKLM or HKCU) will be the one brought up to date.
4. Open the key that is going to be brought up to date.
If #4 Succeeded:
5a. Copy the handle of the out of date key, so it can be opened later if needed.
If #4 Failed:
5b. The other key will now be the one brought up to date, as long as it is HKLM.
6b. Tag the out of date as INVALID. (Key == NULL; RelKey == NULL)
Returns: LONG containing success or error code.
Cond: --
*/
STDAPI_(LONG)
SHRegOpenUSKeyA(
IN LPCSTR pszPath,
IN REGSAM samDesired, // security access mask
IN HUSKEY hUSKeyRelative, OPTIONAL
OUT PHUSKEY phUSKey,
IN BOOL fIgnoreHKCU)
{
PUSKEY pUSKeyRelative = (PUSKEY) hUSKeyRelative;
PPUSKEY ppUSKey = (PPUSKEY) phUSKey;
PUSKEY pUSKey;
LONG lRet = ERROR_SUCCESS;
HKEY * phkeyMaster;
HKEY * phkeyRelMaster;
HKEY * phkeyOld;
HKEY * phkeyRelOld;
ASSERT(ppUSKey);
// The following are invalid parameters...
// 1. ppUSKey cannot be NULL
// 2. If this is a relative open, pUSKeyRelative needs to be a valid HUSKEY.
if ((!ppUSKey) || // 1.
(pUSKeyRelative && FALSE == IS_HUSKEY_VALID(pUSKeyRelative))) // 2.
{
return ERROR_INVALID_PARAMETER;
}
///// 1. Allocate a new USKEY structure.
pUSKey = *ppUSKey = (PUSKEY)LocalAlloc(LPTR, sizeof(USKEY));
if (!pUSKey)
return ERROR_NOT_ENOUGH_MEMORY;
///// 2. Initialize the structure.
if (!pUSKeyRelative)
{
// Init a new (non-relative) open.
pUSKey->hkeyLocalMachineRelative = HKEY_LOCAL_MACHINE;
pUSKey->hkeyCurrentUserRelative = HKEY_CURRENT_USER;
}
else
{
// Init a new (relative) open.
*pUSKey = *pUSKeyRelative;
}
pUSKey->samDesired = samDesired;
///// 3. Determine which key (HKLM or HKCU) will be the one brought up to date.
// The HUSKY struct will contain 4 HKEYs. HKCU, HKCU Relative, HKLM, and HKLM Relative.
// For efficiency, only one key will be up to date (HKCU or HKLM). The one that
// is out of date will be NULL to indicate out of date. The relative key for the
// out of date key, will be the last opened key. The string will be the delta between
// the last open key and the current open level.
// We will determine which key will be the new valid key (Master).
if (FALSE == fIgnoreHKCU)
{
phkeyMaster = &(pUSKey->hkeyCurrentUser);
phkeyRelMaster = &(pUSKey->hkeyCurrentUserRelative);
phkeyOld = &(pUSKey->hkeyLocalMachine);
phkeyRelOld = &(pUSKey->hkeyLocalMachineRelative);
}
else
{
phkeyMaster = &(pUSKey->hkeyLocalMachine);
phkeyRelMaster = &(pUSKey->hkeyLocalMachineRelative);
phkeyOld = &(pUSKey->hkeyCurrentUser);
phkeyRelOld = &(pUSKey->hkeyCurrentUserRelative);
}
// Add the new Path to the Total path.
if ('\0' != *(pUSKey->szSubPath))
PathAddBackslashA(pUSKey->szSubPath); // Add separator \ if reqd.
StrNCatA(pUSKey->szSubPath, pszPath, ARRAYSIZE(pUSKey->szSubPath) - lstrlenA(pUSKey->szSubPath) - 1);
///// 4. Open the key that is going to be brought up to date.
if (*phkeyMaster)
{
// Masterkey is already up to date, so just do the relative open and add the string to szSubPath
// It's safe to write write (*phkeyMaster) because it will be freed by the HUSKEY used for the
// relative open.
lRet = RegOpenKeyExA(*phkeyMaster, pszPath, 0, pUSKey->samDesired, phkeyMaster);
}
else
{
// Open Masterkey with the full path (pUSKey->szSubPath + pszPath)
if (*phkeyRelMaster)
lRet = RegOpenKeyExA(*phkeyRelMaster, pUSKey->szSubPath, 0, pUSKey->samDesired, phkeyMaster);
else
lRet = ERROR_FILE_NOT_FOUND;
lstrcpyA(pUSKey->szSubPath, pszPath);
*phkeyRelMaster = NULL;
}
///// Did #4 Succeeded?
if (ERROR_FILE_NOT_FOUND == lRet)
{
///// #4 Failed, Now we can try to open HKLM if the previous attempt was to open HKCU.
if (!fIgnoreHKCU)
{
if (*phkeyRelOld) // Can HKLM be opened?
{
ASSERT(*phkeyOld == NULL); // *phkeyOld should never have a value if *phkeyRelOld does.
///// 5b. The other key will now be the one brought up to date, as long as it is HKLM.
lRet = RegOpenKeyExA(*phkeyRelOld, pUSKey->szSubPath, 0, pUSKey->samDesired, phkeyOld);
*phkeyRelOld = NULL;
}
else if (*phkeyOld) // Can HKLM be opened?
{
///// 5b. Attempt to bring the other key up to date.
lRet = RegOpenKeyExA(*phkeyOld, pUSKey->szSubPath, 0, pUSKey->samDesired, phkeyOld);
}
}
else
{
*phkeyOld = NULL; // Tag this as INVALID
*phkeyRelOld = NULL; // Tag this as INVALID
}
///// 6b. Tag the out of date as INVALID. (Key == NULL; RelKey == NULL)
*phkeyMaster = NULL; // Tag this as INVALID
*phkeyRelMaster = NULL; // Tag this as INVALID
}
else
{
///// #4 Succeeded:
///// 5a. Does the out of date key need to be copied?
if (*phkeyOld)
{
// Copy the handle of the out of date key, so it can be opened later if needed.
// We can be assured that any NON-Relative HKEY will not be HKEY_LOCAL_MACHINE or HKEY_CURRENT_USER
ASSERT(*phkeyOld != HKEY_LOCAL_MACHINE && *phkeyOld != HKEY_CURRENT_USER); // But let's assert anyway.
RegOpenKeyExA(*phkeyOld, NULL, 0, pUSKey->samDesired, phkeyOld);
}
else
{
if ((*phkeyRelOld) && (*phkeyRelOld != HKEY_LOCAL_MACHINE) && (*phkeyRelOld != HKEY_CURRENT_USER))
{
// Copy the handle of the out of date key, so it can be opened later if needed.
lRet = RegOpenKeyExA(*phkeyRelOld, NULL, 0, pUSKey->samDesired, phkeyRelOld);
}
}
if (*phkeyOld)
{
*phkeyRelOld = *phkeyOld;
*phkeyOld = NULL; // Mark this key as being out of date.
}
}
// Free the memory if we are not successful.
if (ERROR_SUCCESS != lRet)
{
pUSKey->hkeyCurrentUser = NULL; // Mark invalid.
pUSKey->hkeyLocalMachine = NULL;
LocalFree((HLOCAL)pUSKey);
*ppUSKey = NULL;
}
return lRet;
}
/*----------------------------------------------------------
Purpose: Open a user specifc registry key (HUSKEY).
Returns: LONG containing success or error code.
Cond: --
*/
STDAPI_(LONG)
SHRegOpenUSKeyW(
IN LPCWSTR pwzPath,
IN REGSAM samDesired, // security access mask
IN HUSKEY hUSKeyRelative, OPTIONAL
OUT PHUSKEY phUSKey,
IN BOOL fIgnoreHKCU)
{
CHAR szNewPath[MAXIMUM_SUB_KEY_LENGTH];
// Thunk Path to Wide chars.
if (FALSE == WideCharToMultiByte(CP_ACP, 0, pwzPath, -1, szNewPath, sizeof(szNewPath), NULL, 0))
return GetLastError();
return SHRegOpenUSKeyA(szNewPath, samDesired, hUSKeyRelative, phUSKey, fIgnoreHKCU);
}
/*----------------------------------------------------------
Purpose: Query a user specific registry entry for it's value.
This will NOT
open and close the keys in which the value resides.
The caller needs to do this and it should be done
when several keys will be queried for a perf increase.
Callers that only call this once, will probably want
to call SHGetUSValue().
Returns: LONG containing success or error code.
Cond: --
*/
STDAPI_(LONG)
SHRegQueryUSValueA(
IN HUSKEY hUSKey,
IN LPCSTR pszValue,
OUT LPDWORD pdwType, OPTIONAL
OUT LPVOID pvData, OPTIONAL
OUT LPDWORD pcbData, OPTIONAL
IN BOOL fIgnoreHKCU,
IN LPVOID pvDefaultData, OPTIONAL
IN DWORD dwDefaultDataSize) OPTIONAL
{
PUSKEY pUSKey = (PUSKEY) hUSKey;
LONG lRet = ERROR_SUCCESS;
DWORD dwSize = (pcbData ? *pcbData : 0);
DWORD dwType = (pdwType ? *pdwType : 0); // callers responsibility to set pdwType to the type of pvDefaultData (if they care)
if (FALSE == IS_HUSKEY_VALID(pUSKey))
return ERROR_INVALID_PARAMETER;
if (!fIgnoreHKCU)
{
lRet = PrivRegQueryValue(pUSKey, &(pUSKey->hkeyCurrentUser), (LPWSTR)pszValue,
FALSE, pdwType, pvData, pcbData);
}
if (fIgnoreHKCU || ERROR_SUCCESS != lRet)
{
if (pcbData)
*pcbData = dwSize; // We may need to reset if previous open failed.
lRet = PrivRegQueryValue(pUSKey, &(pUSKey->hkeyLocalMachine), (LPWSTR)pszValue,
FALSE, pdwType, pvData, pcbData);
}
// if fail, use default value.
if ((ERROR_SUCCESS != lRet) && (pvDefaultData) && (dwDefaultDataSize) &&
(pvData) && (dwSize >= dwDefaultDataSize))
{
MoveMemory(pvData, pvDefaultData, dwDefaultDataSize);
if (pcbData)
{
*pcbData = dwDefaultDataSize;
}
if (pdwType)
{
*pdwType = dwType;
}
lRet = ERROR_SUCCESS; // Call will now use a default value.
}
return lRet;
}
/*----------------------------------------------------------
Purpose: Query a user specific registry entry for it's value.
This will NOT
open and close the keys in which the value resides.
The caller needs to do this and it should be done
when several keys will be queried for a perf increase.
Callers that only call this once, will probably want
to call SHGetUSValue().
Returns: LONG containing success or error code.
Cond: --
*/
STDAPI_(LONG)
SHRegQueryUSValueW(
IN HUSKEY hUSKey,
IN LPCWSTR pwzValue,
OUT LPDWORD pdwType, OPTIONAL
OUT LPVOID pvData, OPTIONAL
OUT LPDWORD pcbData, OPTIONAL
IN BOOL fIgnoreHKCU,
IN LPVOID pvDefaultData, OPTIONAL
IN DWORD dwDefaultDataSize) OPTIONAL
{
PUSKEY pUSKey = (PUSKEY) hUSKey;
LONG lRet;
DWORD dwSize = (pcbData ? *pcbData : 0);
DWORD dwType = (pdwType ? *pdwType : 0); // callers responsibility to set pdwType to the type of pvDefaultData (if they care)
if (FALSE == IS_HUSKEY_VALID(pUSKey))
return ERROR_INVALID_PARAMETER;
if (!fIgnoreHKCU)
{
lRet = PrivRegQueryValue(pUSKey, &(pUSKey->hkeyCurrentUser), pwzValue,
TRUE, pdwType, pvData, pcbData);
}
if (fIgnoreHKCU || ERROR_SUCCESS != lRet)
{
if (pcbData)
*pcbData = dwSize; // We may need to reset if previous open failed.
lRet = PrivRegQueryValue(pUSKey, &(pUSKey->hkeyLocalMachine), pwzValue,
TRUE, pdwType, pvData, pcbData);
}
// if fail, use default value.
if ((ERROR_SUCCESS != lRet) && (pvDefaultData) && (dwDefaultDataSize) &&
(pvData) && (dwSize >= dwDefaultDataSize))
{
MoveMemory(pvData, pvDefaultData, dwDefaultDataSize);
if (pcbData)
{
*pcbData = dwDefaultDataSize;
}
if (pdwType)
{
*pdwType = dwType;
}
lRet = ERROR_SUCCESS; // Call will now use a default value.
}
return lRet;
}
/*----------------------------------------------------------
Purpose: Write a user specific registry entry.
Parameters:
hUSKey - Needs to have been open with KEY_SET_VALUE permissions.
KEY_QUERY_VALUE also needs to have been used if this is
not a force write.
pszValue - Registry Key value to write to.
dwType - Type for the new registry key.
pvData - Pointer to data to store
cbData - Size of data to store.
dwFlags - Flags to determine if the registry entry should be written to
HKLM, HKCU, or both. Also determines if these are force or
non-force writes. (non-force means it will only write the value
if it's empty) Using FORCE is faster than non-force.
Decription:
This function will write the value to the
registry in either the HKLM or HKCU branches depending
on the flags set in the dwFlags parameter.
Returns: LONG containing success or error code.
Cond: --
*/
STDAPI_(LONG)
SHRegWriteUSValueA(
IN HUSKEY hUSKey,
IN LPCSTR pszValue,
IN DWORD dwType,
IN LPCVOID pvData,
IN DWORD cbData,
IN DWORD dwFlags)
{
PUSKEY pUSKey = (PUSKEY) hUSKey;
LONG lRet = ERROR_SUCCESS;
if (FALSE == IS_HUSKEY_VALID(pUSKey))
return ERROR_INVALID_PARAMETER;
// Assert if: 1) This is not a force open, and 2) they key was not
// opened with KEY_QUERY_VALUE permissions.
if (!(dwFlags & (SHREGSET_FORCE_HKCU|SHREGSET_FORCE_HKLM)) && !(pUSKey->samDesired & KEY_QUERY_VALUE))
{
ASSERT(NULL); // ERROR_INVALID_PARAMETER
return(ERROR_INVALID_PARAMETER);
}
if (dwFlags & (SHREGSET_HKCU | SHREGSET_FORCE_HKCU))
{
lRet = PrivRegWriteValue(pUSKey, &(pUSKey->hkeyCurrentUser), (LPWSTR)pszValue,
FALSE, dwFlags & SHREGSET_FORCE_HKCU, dwType, pvData, cbData);
}
if ((dwFlags & (SHREGSET_HKLM | SHREGSET_FORCE_HKLM)) && (ERROR_SUCCESS == lRet))
{
lRet = PrivRegWriteValue(pUSKey, &(pUSKey->hkeyLocalMachine), (LPWSTR)pszValue,
FALSE, dwFlags & SHREGSET_FORCE_HKLM, dwType, pvData, cbData);
}
return lRet;
}
/*----------------------------------------------------------
Purpose: Write a user specific registry entry.
Parameters:
hUSKey - Needs to have been open with KEY_SET_VALUE permissions.
KEY_QUERY_VALUE also needs to have been used if this is
not a force write.
pszValue - Registry Key value to write to.
dwType - Type for the new registry key.
pvData - Pointer to data to store
cbData - Size of data to store.
dwFlags - Flags to determine if the registry entry should be written to
HKLM, HKCU, or both. Also determines if these are force or
non-force writes. (non-force means it will only write the value
if it's empty) Using FORCE is faster than non-force.
Decription:
This function will write the value to the
registry in either the HKLM or HKCU branches depending
on the flags set in the dwFlags parameter.
Returns: LONG containing success or error code.
Cond: --
*/
STDAPI_(LONG)
SHRegWriteUSValueW(
IN HUSKEY hUSKey,
IN LPCWSTR pwzValue,
IN DWORD dwType,
IN LPCVOID pvData,
IN DWORD cbData,
IN DWORD dwFlags)
{
PUSKEY pUSKey = (PUSKEY) hUSKey;
LONG lRet = ERROR_SUCCESS;
if (FALSE == IS_HUSKEY_VALID(pUSKey))
return ERROR_INVALID_PARAMETER;
// Assert if: 1) This is not a force open, and 2) they key was not
// opened with access permissions.
if (!(dwFlags & (SHREGSET_FORCE_HKCU|SHREGSET_FORCE_HKLM)) && !(pUSKey->samDesired & KEY_QUERY_VALUE))
{
ASSERT(NULL); // ERROR_INVALID_PARAMETER
return(ERROR_INVALID_PARAMETER);
}
if (dwFlags & (SHREGSET_HKCU | SHREGSET_FORCE_HKCU))
{
lRet = PrivRegWriteValue(pUSKey, &(pUSKey->hkeyCurrentUser), (LPWSTR)pwzValue,
TRUE, dwFlags & SHREGSET_FORCE_HKCU, dwType, pvData, cbData);
}
if (dwFlags & (SHREGSET_HKLM | SHREGSET_FORCE_HKLM))
{
lRet = PrivRegWriteValue(pUSKey, &(pUSKey->hkeyLocalMachine), (LPWSTR)pwzValue,
TRUE, dwFlags & SHREGSET_FORCE_HKLM, dwType, pvData, cbData);
}
return lRet;
}
/*----------------------------------------------------------
Purpose: Deletes a registry value. This will delete HKLM,
HKCU, or both depending on the hkey parameter.
Returns: LONG containing success or error code.
Cond: --
*/
STDAPI_(LONG)
SHRegDeleteUSValueA(
IN HUSKEY hUSKey,
IN LPCSTR pszValue,
IN SHREGDEL_FLAGS delRegFlags) // (HKLM, HKCU, or (HKLM | HKCU))
{
PUSKEY pUSKey = (PUSKEY) hUSKey;
LONG lRet = ERROR_INVALID_PARAMETER;
if (FALSE == IS_HUSKEY_VALID(pUSKey))
return ERROR_INVALID_PARAMETER;
if (SHREGDEL_DEFAULT == delRegFlags) // Delete whatever keys are open
{
if (!pUSKey->hkeyCurrentUser) // Attempt to open HKCU if not currently open
lRet = PrivFullOpen(pUSKey);
if (pUSKey->hkeyCurrentUser)
delRegFlags = SHREGDEL_HKCU;
else
{
// We prefer to delete HKCU, but we got here, so we will delete HKLM
// if it is open.
if (pUSKey->hkeyLocalMachine)
delRegFlags = SHREGDEL_HKLM;
}
}
if (IsFlagSet(delRegFlags, SHREGDEL_HKCU)) // Check if the call wants to delete the HKLM value.
{
if (!pUSKey->hkeyCurrentUser)
PrivFullOpen(pUSKey);
if (pUSKey->hkeyCurrentUser)
{
lRet = RegDeleteValueA(pUSKey->hkeyCurrentUser, pszValue);
if (ERROR_FILE_NOT_FOUND == lRet)
delRegFlags = SHREGDEL_HKLM; // Delete the HKLM value if the HKCU value wasn't found.
}
}
if (IsFlagSet(delRegFlags, SHREGDEL_HKLM)) // Check if the call wants to delete the HKLM value.
{
if (!pUSKey->hkeyLocalMachine)
PrivFullOpen(pUSKey);
if (pUSKey->hkeyLocalMachine)
lRet = RegDeleteValueA(pUSKey->hkeyLocalMachine, pszValue);
}
return lRet;
}
/*----------------------------------------------------------
Purpose: Deletes a registry value. This will delete HKLM,
HKCU, or both depending on the hkey parameter.
Returns: LONG containing success or error code.
Cond: --
*/
STDAPI_(LONG)
SHRegDeleteUSValueW(
IN HUSKEY hUSKey,
IN LPCWSTR pwzValue,
IN SHREGDEL_FLAGS delRegFlags) // (HKLM, HKCU, or (HKLM | HKCU))
{
CHAR szNewPath[MAXIMUM_VALUE_NAME_LENGTH];
// Thunk Path to Wide chars.
if (FALSE == WideCharToMultiByte(CP_ACP, 0, pwzValue, -1, szNewPath, sizeof(szNewPath), NULL, 0))
return GetLastError();
return SHRegDeleteUSValueA(hUSKey, szNewPath, delRegFlags);
}
/*----------------------------------------------------------
Purpose: Deletes a registry sub-key if empty. This will delete HKLM,
HKCU, or both depending on the delRegFlags parameter.
Returns: LONG containing success or error code.
Cond: --
*/
STDAPI_(LONG)
SHRegDeleteEmptyUSKeyA(
IN HUSKEY hUSKey,
IN LPCSTR pszSubKey,
IN SHREGDEL_FLAGS delRegFlags) // (HKLM, HKCU, or (HKLM | HKCU))
{
PUSKEY pUSKey = (PUSKEY) hUSKey;
LONG lRet = ERROR_INVALID_PARAMETER;
if (FALSE == IS_HUSKEY_VALID(pUSKey))
return ERROR_INVALID_PARAMETER;
if (SHREGDEL_DEFAULT == delRegFlags) // Delete whatever keys are open
{
if (!pUSKey->hkeyCurrentUser) // Attempt to open HKCU if not currently open
lRet = PrivFullOpen(pUSKey);
if (pUSKey->hkeyCurrentUser)
delRegFlags = SHREGDEL_HKCU;
else
{
// We prefer to delete HKCU, but we got here, so we will delete HKLM
// if it is open.
if (pUSKey->hkeyLocalMachine)
delRegFlags = SHREGDEL_HKLM;
}
}
if (IsFlagSet(delRegFlags, SHREGDEL_HKCU)) // Check if the call wants to delete the HKLM key.
{
if (!pUSKey->hkeyCurrentUser)
PrivFullOpen(pUSKey);
if (pUSKey->hkeyCurrentUser)
{
lRet = SHDeleteEmptyKeyA(pUSKey->hkeyCurrentUser, pszSubKey);
if (ERROR_FILE_NOT_FOUND == lRet)
delRegFlags = SHREGDEL_HKLM; // Delete the HKLM key if the HKCU key wasn't found.
}
}
if (IsFlagSet(delRegFlags, SHREGDEL_HKLM)) // Check if the call wants to delete the HKLM key.
{
if (!pUSKey->hkeyLocalMachine)
PrivFullOpen(pUSKey);
if (pUSKey->hkeyLocalMachine)
lRet = SHDeleteEmptyKeyA(pUSKey->hkeyLocalMachine, pszSubKey);
}
return lRet;
}
/*----------------------------------------------------------
Purpose: Deletes a registry key if empty. This will delete HKLM,
HKCU, or both depending on the delRegFlags parameter.
Returns: LONG containing success or error code.
Cond: --
*/
STDAPI_(LONG)
SHRegDeleteEmptyUSKeyW(
IN HUSKEY hUSKey,
IN LPCWSTR pwzSubKey,
IN SHREGDEL_FLAGS delRegFlags) // (HKLM, HKCU, or (HKLM | HKCU))
{
CHAR szNewPath[MAXIMUM_SUB_KEY_LENGTH];
// Thunk Path to Wide chars.
if (FALSE == WideCharToMultiByte(CP_ACP, 0, pwzSubKey, -1, szNewPath, sizeof(szNewPath), NULL, 0))
return GetLastError();
return SHRegDeleteEmptyUSKeyA(hUSKey, szNewPath, delRegFlags);
}
/*----------------------------------------------------------
Purpose: Enumerates sub-keys under a given HUSKEY.
SHREGENUM_FLAGS specifies how to do the enumeration.
SHREGENUM_DEFAULT - Will look in HKCU followed by HKLM if not found.
SHREGENUM_HKCU - Enumerates HKCU only.
SHREGENUM_HKLM = Enumerates HKLM only.
SHREGENUM_BOTH - This is supposed to do a union of the HKLM and HKCU subkeys.
Returns: LONG containing success or error code.
Cond: --
*/
STDAPI_(LONG)
SHRegEnumUSKeyA(
IN HUSKEY hUSKey,
IN DWORD dwIndex,
OUT LPSTR pszName,
IN LPDWORD pcchName,
IN SHREGENUM_FLAGS enumRegFlags) // (HKLM, HKCU, or (HKLM | HKCU))
{
PUSKEY pUSKey = (PUSKEY) hUSKey;
LONG lRet = ERROR_INVALID_PARAMETER;
if (FALSE == IS_HUSKEY_VALID(pUSKey))
return ERROR_INVALID_PARAMETER;
if (SHREGENUM_BOTH == enumRegFlags)
{
// This is not supported yet.
ASSERT(FALSE);
return ERROR_CALL_NOT_IMPLEMENTED;
}
if (SHREGENUM_HKCU != enumRegFlags && SHREGENUM_HKLM != enumRegFlags && SHREGENUM_DEFAULT != enumRegFlags)
{
// check your arguments.
ASSERT(FALSE);
return ERROR_INVALID_PARAMETER;
}
// Default is to try HKCU first.
if (SHREGENUM_HKCU == enumRegFlags || SHREGENUM_DEFAULT == enumRegFlags)
{
lRet = PrivRegEnumKey(pUSKey, &(pUSKey->hkeyCurrentUser), dwIndex,
(LPWSTR)pszName, FALSE, pcchName);
}
if ((SHREGENUM_HKLM == enumRegFlags) ||
((SHREGENUM_DEFAULT == enumRegFlags) && ((ERROR_SUCCESS != lRet) && (ERROR_MORE_DATA != lRet) && (ERROR_NO_MORE_ITEMS != lRet))))
{
lRet = PrivRegEnumKey(pUSKey, &(pUSKey->hkeyLocalMachine), dwIndex,
(LPWSTR)pszName, FALSE, pcchName);
}
return lRet;
}
/*----------------------------------------------------------
Purpose: Enumerates sub-keys under a given HUSKEY.
SHREGENUM_FLAGS specifies how to do the enumeration.
SHREGENUM_DEFAULT - Will look in HKCU followed by HKLM if not found.
SHREGENUM_HKCU - Enumerates HKCU only.
SHREGENUM_HKLM = Enumerates HKLM only.
SHREGENUM_BOTH - This is supposed to do a union of the HKLM and HKCU subkeys.
Returns: LONG containing success or error code.
Cond: --
*/
STDAPI_(LONG)
SHRegEnumUSKeyW(
IN HUSKEY hUSKey,
IN DWORD dwIndex,
OUT LPWSTR pszName,
IN LPDWORD pcchName,
IN SHREGENUM_FLAGS enumRegFlags) // (HKLM, HKCU, or (HKLM | HKCU))
{
PUSKEY pUSKey = (PUSKEY) hUSKey;
LONG lRet = ERROR_INVALID_PARAMETER;
if (FALSE == IS_HUSKEY_VALID(pUSKey))
return ERROR_INVALID_PARAMETER;
if (SHREGENUM_BOTH == enumRegFlags)
{
// This is not supported yet.
ASSERT(FALSE);
return ERROR_CALL_NOT_IMPLEMENTED;
}
if (SHREGENUM_HKCU != enumRegFlags && SHREGENUM_HKLM != enumRegFlags && SHREGENUM_DEFAULT != enumRegFlags)
{
// check your arguments.
ASSERT(FALSE);
return ERROR_INVALID_PARAMETER;
}
// Default is to try HKCU first.
if (SHREGENUM_HKCU == enumRegFlags || SHREGENUM_DEFAULT == enumRegFlags)
{
lRet = PrivRegEnumKey(pUSKey, &(pUSKey->hkeyCurrentUser), dwIndex,
pszName, TRUE, pcchName);
}
if ((SHREGENUM_HKLM == enumRegFlags) ||
((SHREGENUM_DEFAULT == enumRegFlags) && ((ERROR_SUCCESS != lRet) && (ERROR_MORE_DATA != lRet) && (ERROR_NO_MORE_ITEMS != lRet))))
{
lRet = PrivRegEnumKey(pUSKey, &(pUSKey->hkeyLocalMachine), dwIndex,
pszName, TRUE, pcchName);
}
return lRet;
}
/*----------------------------------------------------------
Purpose: Enumerates Values under a given HUSKEY.
SHREGENUM_FLAGS specifies how to do the enumeration.
SHREGENUM_DEFAULT - Will look in HKCU followed by HKLM if not found.
SHREGENUM_HKCU - Enumerates HKCU only.
SHREGENUM_HKLM = Enumerates HKLM only.
SHREGENUM_BOTH - This is supposed to do a union of the HKLM and HKCU subkeys.
Returns: LONG containing success or error code.
Cond: --
*/
STDAPI_(LONG)
SHRegEnumUSValueA(
IN HUSKEY hUSKey,
IN DWORD dwIndex,
OUT LPSTR pszValueName,
IN LPDWORD pcchValueNameLen,
OUT LPDWORD pdwType, OPTIONAL
OUT LPVOID pvData, OPTIONAL
OUT LPDWORD pcbData, OPTIONAL
IN SHREGENUM_FLAGS enumRegFlags) // (HKLM, HKCU, or (HKLM | HKCU))
{
PUSKEY pUSKey = (PUSKEY) hUSKey;
LONG lRet = ERROR_INVALID_PARAMETER;
if (FALSE == IS_HUSKEY_VALID(pUSKey))
return ERROR_INVALID_PARAMETER;
if (SHREGENUM_BOTH == enumRegFlags)
{
// This is not supported yet.
ASSERT(FALSE);
return ERROR_CALL_NOT_IMPLEMENTED;
}
if (SHREGENUM_HKCU != enumRegFlags && SHREGENUM_HKLM != enumRegFlags && SHREGENUM_DEFAULT != enumRegFlags)
{
// check your arguments.
ASSERT(FALSE);
return ERROR_INVALID_PARAMETER;
}
// Default is to try HKCU first.
if (SHREGENUM_HKCU == enumRegFlags || SHREGENUM_DEFAULT == enumRegFlags)
{
lRet = PrivRegEnumValue(pUSKey, &(pUSKey->hkeyCurrentUser), dwIndex,
(LPWSTR)pszValueName, FALSE, pcchValueNameLen, pdwType, pvData, pcbData);
}
if ((SHREGENUM_HKLM == enumRegFlags) ||
((SHREGENUM_DEFAULT == enumRegFlags) && ((ERROR_SUCCESS != lRet) && (ERROR_MORE_DATA != lRet) && (ERROR_NO_MORE_ITEMS != lRet))))
{
lRet = PrivRegEnumValue(pUSKey, &(pUSKey->hkeyLocalMachine), dwIndex,
(LPWSTR)pszValueName, FALSE, pcchValueNameLen, pdwType, pvData, pcbData);
}
return lRet;
}
/*----------------------------------------------------------
Purpose: Enumerates Values under a given HUSKEY.
SHREGENUM_FLAGS specifies how to do the enumeration.
SHREGENUM_DEFAULT - Will look in HKCU followed by HKLM if not found.
SHREGENUM_HKCU - Enumerates HKCU only.
SHREGENUM_HKLM = Enumerates HKLM only.
SHREGENUM_BOTH - This is supposed to do a union of the HKLM and HKCU subkeys.
Returns: LONG containing success or error code.
Cond: --
*/
STDAPI_(LONG)
SHRegEnumUSValueW(
IN HUSKEY hUSKey,
IN DWORD dwIndex,
OUT LPWSTR pszValueName,
IN LPDWORD pcchValueNameLen,
OUT LPDWORD pdwType, OPTIONAL
OUT LPVOID pvData, OPTIONAL
OUT LPDWORD pcbData, OPTIONAL
IN SHREGENUM_FLAGS enumRegFlags) // (HKLM, HKCU, or (HKLM | HKCU))
{
PUSKEY pUSKey = (PUSKEY) hUSKey;
LONG lRet = ERROR_INVALID_PARAMETER;
if (FALSE == IS_HUSKEY_VALID(pUSKey))
return ERROR_INVALID_PARAMETER;
if (SHREGENUM_BOTH == enumRegFlags)
{
// This is not supported yet.
ASSERT(FALSE);
return ERROR_CALL_NOT_IMPLEMENTED;
}
if (SHREGENUM_HKCU != enumRegFlags && SHREGENUM_HKLM != enumRegFlags && SHREGENUM_DEFAULT != enumRegFlags)
{
// check your arguments.
ASSERT(FALSE);
return ERROR_INVALID_PARAMETER;
}
// Default is to try HKCU first.
if (SHREGENUM_HKCU == enumRegFlags || SHREGENUM_DEFAULT == enumRegFlags)
{
lRet = PrivRegEnumValue(pUSKey, &(pUSKey->hkeyCurrentUser), dwIndex,
pszValueName, TRUE, pcchValueNameLen, pdwType, pvData, pcbData);
}
if ((SHREGENUM_HKLM == enumRegFlags) ||
((SHREGENUM_DEFAULT == enumRegFlags) && ((ERROR_SUCCESS != lRet) && (ERROR_MORE_DATA != lRet) && (ERROR_NO_MORE_ITEMS != lRet))))
{
lRet = PrivRegEnumValue(pUSKey, &(pUSKey->hkeyLocalMachine), dwIndex,
pszValueName, TRUE, pcchValueNameLen, pdwType, pvData, pcbData);
}
return lRet;
}
/*----------------------------------------------------------
Purpose: Gets Info about a HUSKEY.
Re-uses same flags as enumeration functions.
Look at SHRegEnumKeyExA for an explanation of the flags.
Returns: LONG containing success or error code.
Cond: --
*/
STDAPI_(LONG)
SHRegQueryInfoUSKeyA
(
IN HUSKEY hUSKey,
OUT LPDWORD pcSubKeys, OPTIONAL
OUT LPDWORD pcchMaxSubKeyLen, OPTIONAL
OUT LPDWORD pcValues, OPTIONAL
OUT LPDWORD pcchMaxValueNameLen, OPTIONAL
IN SHREGENUM_FLAGS enumRegFlags
)
{
PUSKEY pUSKey = (PUSKEY) hUSKey;
LONG lRet = ERROR_INVALID_PARAMETER;
if (FALSE == IS_HUSKEY_VALID(pUSKey))
return ERROR_INVALID_PARAMETER;
if (SHREGENUM_BOTH == enumRegFlags)
{
// This is not supported yet.
ASSERT(FALSE);
return ERROR_CALL_NOT_IMPLEMENTED;
}
if (SHREGENUM_HKCU != enumRegFlags && SHREGENUM_HKLM != enumRegFlags && SHREGENUM_DEFAULT != enumRegFlags)
{
// check your arguments.
ASSERT(FALSE);
return ERROR_INVALID_PARAMETER;
}
// Default is to try HKCU first.
if (SHREGENUM_HKCU == enumRegFlags || SHREGENUM_DEFAULT == enumRegFlags)
{
lRet = PrivRegQueryInfoKey(pUSKey, &(pUSKey->hkeyCurrentUser), FALSE,
pcSubKeys, pcchMaxSubKeyLen, pcValues, pcchMaxValueNameLen);
}
if ((SHREGENUM_HKLM == enumRegFlags) ||
((SHREGENUM_DEFAULT == enumRegFlags) && ((ERROR_SUCCESS != lRet) && (ERROR_MORE_DATA != lRet))))
{
lRet = PrivRegQueryInfoKey(pUSKey, &(pUSKey->hkeyLocalMachine), FALSE,
pcSubKeys, pcchMaxSubKeyLen, pcValues, pcchMaxValueNameLen);
}
return lRet;
}
/*----------------------------------------------------------
Purpose: Gets Info about a HUSKEY.
Re-uses same flags as enumeration functions.
Look at SHRegEnumKeyExA for an explanation of the flags.
Returns: LONG containing success or error code.
Cond: --
*/
STDAPI_(LONG)
SHRegQueryInfoUSKeyW
(
IN HUSKEY hUSKey,
OUT LPDWORD pcSubKeys, OPTIONAL
OUT LPDWORD pcchMaxSubKeyLen, OPTIONAL
OUT LPDWORD pcValues, OPTIONAL
OUT LPDWORD pcchMaxValueNameLen, OPTIONAL
IN SHREGENUM_FLAGS enumRegFlags
)
{
PUSKEY pUSKey = (PUSKEY) hUSKey;
LONG lRet = ERROR_INVALID_PARAMETER;
if (FALSE == IS_HUSKEY_VALID(pUSKey))
return ERROR_INVALID_PARAMETER;
if (SHREGENUM_BOTH == enumRegFlags)
{
// This is not supported yet.
ASSERT(FALSE);
return ERROR_CALL_NOT_IMPLEMENTED;
}
if (SHREGENUM_HKCU != enumRegFlags && SHREGENUM_HKLM != enumRegFlags && SHREGENUM_DEFAULT != enumRegFlags)
{
// check your arguments.
ASSERT(FALSE);
return ERROR_INVALID_PARAMETER;
}
// Default is to try HKCU first.
if (SHREGENUM_HKCU == enumRegFlags || SHREGENUM_DEFAULT == enumRegFlags)
{
lRet = PrivRegQueryInfoKey(pUSKey, &(pUSKey->hkeyCurrentUser), TRUE,
pcSubKeys, pcchMaxSubKeyLen, pcValues, pcchMaxValueNameLen);
}
if ((SHREGENUM_HKLM == enumRegFlags) ||
((SHREGENUM_DEFAULT == enumRegFlags) && ((ERROR_SUCCESS != lRet) && (ERROR_MORE_DATA != lRet))))
{
lRet = PrivRegQueryInfoKey(pUSKey, &(pUSKey->hkeyLocalMachine), TRUE,
pcSubKeys, pcchMaxSubKeyLen, pcValues, pcchMaxValueNameLen);
}
return lRet;
}
/*----------------------------------------------------------
Purpose: Closes a HUSKEY (Handle to a User Specifc registry key).
Returns: LONG containing success or error code.
Cond: --
*/
STDAPI_(LONG)
SHRegCloseUSKey(
OUT HUSKEY hUSKey)
{
PUSKEY pUSKey = (PUSKEY) hUSKey;
LONG lRet = ERROR_SUCCESS;
ASSERT(pUSKey);
if (FALSE == IS_HUSKEY_VALID(pUSKey))
return ERROR_INVALID_PARAMETER;
if (pUSKey->hkeyLocalMachine)
{
lRet = RegCloseKey(pUSKey->hkeyLocalMachine);
pUSKey->hkeyLocalMachine = NULL; // Used to indicate that it's invalid.
}
if (pUSKey->hkeyLocalMachineRelative && HKEY_LOCAL_MACHINE != pUSKey->hkeyLocalMachineRelative)
{
lRet = RegCloseKey(pUSKey->hkeyLocalMachineRelative);
}
if (pUSKey->hkeyCurrentUser)
{
lRet = RegCloseKey(pUSKey->hkeyCurrentUser);
pUSKey->hkeyCurrentUser = NULL; // Used to indicate that it's invalid.
}
if (pUSKey->hkeyCurrentUserRelative && HKEY_CURRENT_USER != pUSKey->hkeyCurrentUserRelative)
{
lRet = RegCloseKey(pUSKey->hkeyCurrentUserRelative);
}
LocalFree((HLOCAL)pUSKey);
return lRet;
}
/*----------------------------------------------------------
Purpose: Gets a registry value that is User Specifc.
This opens and closes the key in which the value resides.
Perf: if your code involves setting/getting a series
of values in the same key, it is better to open
the key once and then call SHRegQueryUSValue
rather than using this function repeatedly.
Returns: LONG containing success or error code.
Cond: --
*/
STDAPI_(LONG)
SHRegGetUSValueA(
IN LPCSTR pszSubKey,
IN LPCSTR pszValue,
OUT LPDWORD pdwType, OPTIONAL
OUT LPVOID pvData, OPTIONAL
OUT LPDWORD pcbData, OPTIONAL
IN BOOL fIgnoreHKCU,
IN LPVOID pvDefaultData, OPTIONAL
IN DWORD dwDefaultDataSize)
{
LONG lRet;
HUSKEY hUSkeys;
DWORD dwInitialSize = (pcbData ? *pcbData : 0);
DWORD dwType = (pdwType ? *pdwType : 0); // callers responsibility to set pdwType to the type of pvDefaultData (if they care)
lRet = SHRegOpenUSKeyA(pszSubKey, KEY_QUERY_VALUE, NULL, &hUSkeys, fIgnoreHKCU);
if (ERROR_SUCCESS == lRet)
{
lRet = SHRegQueryUSValueA(hUSkeys, pszValue, pdwType, pvData, pcbData, fIgnoreHKCU, pvDefaultData, dwDefaultDataSize);
SHRegCloseUSKey(hUSkeys);
}
if (ERROR_SUCCESS != lRet)
{
// if fail on open OR on query, use default value as long as dwDefaultDataSize isn't 0. (So we return the error)
if ((pvDefaultData) && (dwDefaultDataSize) && (pvData) && (dwInitialSize >= dwDefaultDataSize))
{
MoveMemory(pvData, pvDefaultData, dwDefaultDataSize);
if (pcbData)
{
*pcbData = dwDefaultDataSize;
}
if (pdwType)
{
*pdwType = dwType;
}
lRet = ERROR_SUCCESS; // Call will now use a default value.
}
}
return lRet;
}
/*----------------------------------------------------------
Purpose: Gets a registry value that is User Specifc.
This opens and closes the key in which the value resides.
Perf: if your code involves setting/getting a series
of values in the same key, it is better to open
the key once and then call SHRegQueryUSValue
rather than using this function repeatedly.
Returns: LONG containing success or error code.
Cond: --
*/
STDAPI_(LONG)
SHRegGetUSValueW(
IN LPCWSTR pwzSubKey,
IN LPCWSTR pwzValue,
OUT LPDWORD pdwType, OPTIONAL
OUT LPVOID pvData, OPTIONAL
OUT LPDWORD pcbData, OPTIONAL
IN BOOL fIgnoreHKCU,
IN LPVOID pvDefaultData, OPTIONAL
IN DWORD dwDefaultDataSize)
{
LONG lRet;
HUSKEY hUSkeys;
DWORD dwInitialSize = (pcbData ? *pcbData : 0);
DWORD dwType = (pdwType ? *pdwType : 0); // callers responsibility to set pdwType to the type of pvDefaultData (if they care)
lRet = SHRegOpenUSKeyW(pwzSubKey, KEY_QUERY_VALUE, NULL, &hUSkeys, fIgnoreHKCU);
if (ERROR_SUCCESS == lRet)
{
lRet = SHRegQueryUSValueW(hUSkeys, pwzValue, pdwType, pvData, pcbData, fIgnoreHKCU, pvDefaultData, dwDefaultDataSize);
SHRegCloseUSKey(hUSkeys);
}
if (ERROR_SUCCESS != lRet)
{
// if fail on open OR on query, use default value as long as dwDefaultDataSize isn't 0. (So we return the error)
if ((pvDefaultData) && (dwDefaultDataSize) && (pvData) && (dwInitialSize >= dwDefaultDataSize))
{
// if fail, use default value.
MoveMemory(pvData, pvDefaultData, dwDefaultDataSize);
if (pcbData)
{
*pcbData = dwDefaultDataSize;
}
if (pdwType)
{
*pdwType = dwType;
}
lRet = ERROR_SUCCESS; // Call will now use a default value.
}
}
return lRet;
}
/*----------------------------------------------------------
Purpose: Sets a registry value that is User Specifc.
This opens and closes the key in which the value resides.
Perf: if your code involves setting a series
of values in the same key, it is better to open
the key once and then call SHRegWriteUSValue
rather than using this function repeatedly.
Returns: LONG containing success or error code.
Cond: --
*/
STDAPI_(LONG)
SHRegSetUSValueA(
IN LPCSTR pszSubKey,
IN LPCSTR pszValue,
IN DWORD dwType,
IN LPCVOID pvData, OPTIONAL
IN DWORD cbData, OPTIONAL
IN DWORD dwFlags) OPTIONAL
{
LONG lRet;
HUSKEY hUSkeys;
lRet = SHRegCreateUSKeyA(pszSubKey, KEY_QUERY_VALUE | KEY_SET_VALUE, NULL, &hUSkeys, dwFlags);
if (ERROR_SUCCESS == lRet)
{
lRet = SHRegWriteUSValueA(hUSkeys, pszValue, dwType, pvData, cbData, dwFlags);
SHRegCloseUSKey(hUSkeys);
}
return lRet;
}
/*----------------------------------------------------------
Purpose: Sets a registry value that is User Specifc.
This opens and closes the key in which the value resides.
Perf: if your code involves setting a series
of values in the same key, it is better to open
the key once and then call SHRegWriteUSValue
rather than using this function repeatedly.
Returns: LONG containing success or error code.
Cond: --
*/
STDAPI_(LONG)
SHRegSetUSValueW(
IN LPCWSTR pwzSubKey,
IN LPCWSTR pwzValue,
IN DWORD dwType, OPTIONAL
IN LPCVOID pvData, OPTIONAL
IN DWORD cbData, OPTIONAL
IN DWORD dwFlags) OPTIONAL
{
LONG lRet;
HUSKEY hUSkeys;
lRet = SHRegCreateUSKeyW(pwzSubKey, KEY_QUERY_VALUE | KEY_SET_VALUE, NULL, &hUSkeys, dwFlags);
if (ERROR_SUCCESS == lRet)
{
lRet = SHRegWriteUSValueW(hUSkeys, pwzValue, dwType, pvData, cbData, dwFlags);
SHRegCloseUSKey(hUSkeys);
}
return lRet;
}
/*----------------------------------------------------------
Purpose: Gets a BOOL Setting from the registry. The default
parameter will be used if it's not found in the registry.
Cond: --
*/
#define BOOLSETTING_BOOL_TRUE1W L"YES"
#define BOOLSETTING_BOOL_TRUE1A "YES"
#define BOOLSETTING_BOOL_TRUE2W L"TRUE"
#define BOOLSETTING_BOOL_TRUE2A "TRUE"
#define BOOLSETTING_BOOL_FALSE1W L"NO"
#define BOOLSETTING_BOOL_FALSE1A "NO"
#define BOOLSETTING_BOOL_FALSE2W L"FALSE"
#define BOOLSETTING_BOOL_FALSE2A "FALSE"
#define BOOLSETTING_BOOL_1W L"1"
#define BOOLSETTING_BOOL_1A "1"
#define BOOLSETTING_BOOL_0W L"0"
#define BOOLSETTING_BOOL_0A "0"
STDAPI_(BOOL)
SHRegGetBoolUSValueW(
IN LPCWSTR pwzSubKey,
IN LPCWSTR pwzValue,
IN BOOL fIgnoreHKCU,
IN BOOL fDefault)
{
LONG lRet;
WCHAR szData[MAX_PATH];
DWORD dwType = REG_SZ; //because the default value we pass in is a string.
DWORD dwSize = sizeof(szData);
LPCWSTR pszDefault = fDefault ? BOOLSETTING_BOOL_TRUE1W : BOOLSETTING_BOOL_FALSE1W;
DWORD dwDefaultSize = fDefault ? sizeof(BOOLSETTING_BOOL_TRUE1W) : sizeof(BOOLSETTING_BOOL_FALSE1W); // sizeof() includes terminating NULL
lRet = SHRegGetUSValueW(pwzSubKey, pwzValue, &dwType, (LPVOID) szData, &dwSize, fIgnoreHKCU, (LPVOID) pszDefault, dwDefaultSize);
if (ERROR_SUCCESS == lRet)
{
if (dwType == REG_BINARY || dwType == REG_DWORD)
{
fDefault = (*((DWORD*)szData) != 0);
}
else
{
if ((0 == lstrcmpiW(BOOLSETTING_BOOL_TRUE1W, szData)) ||
(0 == lstrcmpiW(BOOLSETTING_BOOL_TRUE2W, szData)) ||
(0 == lstrcmpiW(BOOLSETTING_BOOL_1W, szData)))
{
fDefault = TRUE; // We read TRUE from the registry.
}
else if ((0 == lstrcmpiW(BOOLSETTING_BOOL_FALSE1W, szData)) ||
(0 == lstrcmpiW(BOOLSETTING_BOOL_FALSE2W, szData)) ||
(0 == lstrcmpiW(BOOLSETTING_BOOL_0W, szData)))
{
fDefault = FALSE; // We read TRUE from the registry.
}
}
}
return fDefault;
}
/*----------------------------------------------------------
Purpose: Gets a BOOL Setting from the registry. The default
parameter will be used if it's not found in the registry.
Cond: --
*/
STDAPI_(BOOL)
SHRegGetBoolUSValueA(
IN LPCSTR pszSubKey,
IN LPCSTR pszValue,
IN BOOL fIgnoreHKCU,
IN BOOL fDefault)
{
LONG lRet;
CHAR szData[MAX_PATH];
DWORD dwType = REG_SZ; //because the default value we pass in is a string.
DWORD dwSize = sizeof(szData);
LPCSTR pszDefault = fDefault ? BOOLSETTING_BOOL_TRUE1A : BOOLSETTING_BOOL_FALSE1A;
DWORD dwDefaultSize = (fDefault ? sizeof(BOOLSETTING_BOOL_TRUE1A) : sizeof(BOOLSETTING_BOOL_FALSE1A)) + sizeof(CHAR);
lRet = SHRegGetUSValueA(pszSubKey, pszValue, &dwType, (LPVOID) szData, &dwSize, fIgnoreHKCU, (LPVOID) pszDefault, dwDefaultSize);
if (ERROR_SUCCESS == lRet)
{
if (dwType == REG_BINARY || dwType == REG_DWORD)
{
fDefault = (*((DWORD*)szData) != 0);
}
else
{
if ((0 == lstrcmpiA(BOOLSETTING_BOOL_TRUE1A, szData)) ||
(0 == lstrcmpiA(BOOLSETTING_BOOL_TRUE2A, szData)) ||
(0 == lstrcmpiA(BOOLSETTING_BOOL_1A, szData)))
{
fDefault = TRUE; // We read TRUE from the registry.
}
else if ((0 == lstrcmpiA(BOOLSETTING_BOOL_FALSE1A, szData)) ||
(0 == lstrcmpiA(BOOLSETTING_BOOL_FALSE2A, szData)) ||
(0 == lstrcmpiA(BOOLSETTING_BOOL_0A, szData)) )
{
fDefault = FALSE; // We read TRUE from the registry.
}
}
}
return fDefault;
}
STDAPI_(DWORD)
SHGetValueGoodBootA(HKEY hkeyParent, LPCSTR pcszSubKey,
LPCSTR pcszValue, PDWORD pdwValueType,
PBYTE pbyteBuf, PDWORD pdwcbBufLen)
{
if (GetSystemMetrics(SM_CLEANBOOT))
return ERROR_GEN_FAILURE;
return SHGetValueA(hkeyParent, pcszSubKey, pcszValue, pdwValueType, pbyteBuf, pdwcbBufLen);
}
STDAPI_(DWORD)
SHGetValueGoodBootW(HKEY hkeyParent, LPCWSTR pcwzSubKey,
LPCWSTR pcwzValue, PDWORD pdwValueType,
PBYTE pbyteBuf, PDWORD pdwcbBufLen)
{
if (GetSystemMetrics(SM_CLEANBOOT))
return ERROR_GEN_FAILURE;
return SHGetValueW(hkeyParent, pcwzSubKey, pcwzValue, pdwValueType, pbyteBuf, pdwcbBufLen);
}
/*----------------------------------------------------------
Purpose: Given a CLSID open and return that key from HKCR, or
the user local version.
Cond: --
*/
LWSTDAPI SHRegGetCLSIDKeyW(UNALIGNED REFGUID rguid, LPCWSTR pszSubKey, BOOL fUserSpecific, BOOL fCreate, HKEY *phkey)
{
HKEY hkeyRef;
WCHAR szThisCLSID[GUIDSTR_MAX];
WCHAR szPath[GUIDSTR_MAX+MAX_PATH+1]; // room for clsid + extra
ULONG err;
SHStringFromGUIDW(rguid, szThisCLSID, ARRAYSIZE(szThisCLSID));
if (fUserSpecific)
{
hkeyRef = HKEY_CURRENT_USER;
if (g_bRunningOnNT)
{
StrCpyW(szPath, L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\CLSID\\");
}
else
{
//
// On 9x we have to keep using the old location because Plus
// relies on that location. (Plus changes the DefaultIcon
// subkey to get custom regitem icons.)
//
StrCpyW(szPath, L"Software\\Classes\\CLSID\\");
}
}
else
{
hkeyRef = HKEY_CLASSES_ROOT;
StrCpyW(szPath, L"CLSID");
StrCatW(szPath, L"\\");
}
StrCatW(szPath, szThisCLSID);
if (pszSubKey)
{
StrCatW(szPath, L"\\");
StrCatBuffW(szPath, pszSubKey, ARRAYSIZE(szPath));
}
if (fCreate)
{
err = RegCreateKeyW(hkeyRef, szPath, phkey);
}
else
{
err = RegOpenKeyExW(hkeyRef, szPath, 0, MAXIMUM_ALLOWED, phkey);
}
return HRESULT_FROM_WIN32(err);
}
LWSTDAPI SHRegGetCLSIDKeyA(UNALIGNED REFGUID rguid, LPCSTR pszSubKey, BOOL fUserSpecific, BOOL fCreate, HKEY *phkey)
{
HKEY hkeyRef;
CHAR szThisCLSID[GUIDSTR_MAX];
CHAR szPath[GUIDSTR_MAX+MAX_PATH+1]; // room for clsid + extra
ULONG err;
SHStringFromGUIDA(rguid, szThisCLSID, ARRAYSIZE(szThisCLSID));
if (fUserSpecific)
{
hkeyRef = HKEY_CURRENT_USER;
if (g_bRunningOnNT)
{
StrCpyA(szPath, "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\CLSID\\");
}
else
{
//
// On 9x we have to keep using the old location because Plus
// relies on that location. (Plus changes the DefaultIcon
// subkey to get custom regitem icons.)
//
StrCpyA(szPath, "Software\\Classes\\CLSID\\");
}
}
else
{
hkeyRef = HKEY_CLASSES_ROOT;
StrCpyA(szPath, "CLSID\\");
}
StrCatA(szPath, szThisCLSID);
if (pszSubKey)
{
StrCatA(szPath, "\\");
StrCatBuffA(szPath, pszSubKey, ARRAYSIZE(szPath));
}
if (fCreate)
err = RegCreateKeyA(hkeyRef, szPath, phkey);
else
err = RegOpenKeyExA(hkeyRef, szPath, 0, MAXIMUM_ALLOWED, phkey);
return HRESULT_FROM_WIN32(err);
}
/*----------------------------------------------------------
Purpose: Duplicate an hkey if an object wants to keep one open
//*** Reg_DupKey -- duplicate registry key (upping refcnt)
// NOTES
// REARCHITECT gotta fix this logic (now that i understand how bogus it is).
//
// what we're trying to do is dup the handle. sounds easy. it isn't.
// here's the deal.
// 1- RegOpenKeyEx(hkey, NULL, ..., &hkey2) is spec'ed as giving back the
// same handle. on win95 it ups the refcnt (good!).
// 2- but on winNT there is no refcnt associated w/ it. so it gives back
// the same handle but now *any* close will make *all* of the 'pseudo-dup'ed
// handles invalid.
// 3- (on winNT) if we add MAXIMUM_ALLOWED, we're asking for a new SAM.
// but the SAM is associated w/ the handle, so the only (or rather, closest)
// way to do that is to give a new handle. (presumably this only works
// if we're not dup'ing a handle that's already MAXIMUM_ALLOWED).
// 4- (on winNT) but wait! if we open HKEY_CURRENT_USER, we *always* get
// back 0x80000001 (or somesuch). but closes on that are ignored, so all
// works.
//
// so what we probably should do is:
// - win95: just do #1, w/ default security. win95 will give us the same
// handle w/ an *upped* refcnt and we'll be fine.
// - winNT: do a DuplicateHandle. this will correctly give us a *new*
// handle and we'll be fine.
//
*/
HKEY SHRegDuplicateHKey(HKEY hkey)
{
HKEY hkeyDup = NULL; // in case incoming hkey is invalid
// NULL returns key to same place and ups refcnt
RegOpenKeyExA(hkey, NULL, 0, MAXIMUM_ALLOWED, &hkeyDup);
// This is a bogus assert on Win95, since they have reference counting on these hkeys...
if (g_bRunningOnNT)
{
ASSERT(hkeyDup != hkey ||
hkey == HKEY_CURRENT_USER ||
hkey == HKEY_CLASSES_ROOT ||
hkey == HKEY_LOCAL_MACHINE);
}
return hkeyDup;
}
/*----------------------------------------------------------
Purpose: Read a string value from the registry and convert it
to an integer.
*/
LWSTDAPI_(int) SHRegGetIntW(HKEY hk, LPCWSTR szKey, int nDefault)
{
DWORD cb;
WCHAR ach[20];
if (hk == NULL)
return nDefault;
ach[0] = 0;
cb = sizeof(ach);
SHQueryValueExW(hk, szKey, NULL, NULL, (LPBYTE)ach, &cb);
if (ach[0] >= L'0' && ach[0] <= L'9')
return StrToIntW(ach);
else
return nDefault;
}
// Stores a file path in the registry but looks for a match with
// certain environment variables first. This is a FIXED list.
// Parameters:
// hKey - an open HKEY or registry root key
// pszSubKey - subkey in registry or NULL/zero length string
// pszValue - value name in registry
// pszPath - Win32 file path to write
// dwFlags - unused / future expansion
// Return value:
// Returns Win32 error code from ADVAPI32.DLL function calls.
//
// Match %USERPROFILE% - x:\WINNT\Profiles\<user>
// - x:\Documents And Settings\<user>
// %ALLUSERSPROFILES% - x:\WINNT\Profiles\<user>
// - x:\Documents And Settings\<user>
// %ProgramFiles% - x:\Program Files
// %SystemRoot% - x:\WINNT
//
// %ALLUSERSPROFILE% and %ProgramFiles% are dubious and can be
// removed.
//
// WARNING: DO NOT CHANGE THE MATCH ORDER OF %USERPROFILE% AND
// %SystemRoot%
//
// If %SystemRoot% is matched first then %USERPROFILE% will
// NEVER be matched if inside x:\WINNT\
//
DWORD SHRegSetPathW (HKEY hKey, LPCWSTR pszSubKey, LPCWSTR pszValue, LPCWSTR pszPath, DWORD dwFlags)
{
DWORD dwType;
PCWSTR pszData;
WCHAR szTemp[MAX_PATH];
if (PathUnExpandEnvStringsW(pszPath, szTemp, ARRAYSIZE(szTemp)))
{
dwType = REG_EXPAND_SZ;
pszData = szTemp;
}
else
{
dwType = REG_SZ;
pszData = pszPath;
}
return SHSetValueW(hKey, pszSubKey, pszValue, dwType, pszData, (lstrlenW(pszData) + 1) * sizeof(pszData[0]));
}
DWORD SHRegSetPathA(HKEY hKey, LPCSTR pszSubKey, LPCSTR pszValue, LPCSTR pszPath, DWORD dwFlags)
{
DWORD dwType;
PCSTR pszData;
CHAR szTemp[MAX_PATH];
if (PathUnExpandEnvStringsA(pszPath, szTemp, ARRAYSIZE(szTemp)))
{
dwType = REG_EXPAND_SZ;
pszData = szTemp;
}
else
{
dwType = REG_SZ;
pszData = pszPath;
}
return SHSetValueA(hKey, pszSubKey, pszValue, dwType, pszData, (lstrlenA(pszData) + 1) * sizeof(pszData[0]));
}
// RegGetPath: Unicode implementation of function.
// Returns an expanded file path from the registry.
// Parameters:
// hKey - an open HKEY or registry root key
// pszSubKey - subkey in registry or NULL/zero length string
// pszValue - value name in registry
// pwszPath - string to place path in (assumed size of MAX_PATH chars)
// dwFlags - unused / future expansion
// Return value:
// Returns Win32 error code from ADVAPI32.DLL function calls.
DWORD SHRegGetPathA (HKEY hKey, LPCSTR pszSubKey, LPCSTR pszValue, LPSTR pszPath, DWORD dwFlags)
{
DWORD cb = MAX_PATH * sizeof(pszPath[0]);
return SHGetValueA(hKey, pszSubKey, pszValue, NULL, pszPath, &cb);
}
DWORD SHRegGetPathW (HKEY hKey, LPCWSTR pszSubKey, LPCWSTR pszValue, LPWSTR pszPath, DWORD dwFlags)
{
DWORD cb = MAX_PATH * sizeof(pszPath[0]);
return SHGetValueW(hKey, pszSubKey, pszValue, NULL, pszPath, &cb);
}
BOOL Reg_GetCommand(HKEY hkey, LPCWSTR pszKey, LPCWSTR pszValue, LPWSTR pszCommand)
{
WCHAR szKey[1024];
LONG cbSize = sizeof(szKey);
int iLen;
ASSERT(pszKey);
StrCpyNW(szKey, pszKey, ARRAYSIZE(szKey));
iLen = lstrlenW(szKey);
pszCommand[0] = 0;
// a trailing backslash means no value key
if (szKey[iLen-1] == L'\\' ||
(pszValue && !pszValue[0])) {
if (!pszValue)
szKey[iLen-1] = 0;
RegQueryValueW(hkey, szKey, pszCommand, &cbSize);
} else {
if (!pszValue)
pszValue = PathFindFileNameW(szKey);
ASSERT(pszValue);
if (!pszValue)
return FALSE;
PathRemoveFileSpecW(szKey);
SHGetValueGoodBootW(hkey, szKey, pszValue, NULL, (LPBYTE)pszCommand, (DWORD*)&cbSize);
}
if (pszCommand[0]) {
LPWSTR pszNextKey;
// see if it's a registry spec
if (!StrCmpNIW(pszCommand, L"HKCU:", 5)) {
hkey = HKEY_CURRENT_USER;
pszNextKey = pszCommand + 5;
} else if (!StrCmpNIW(pszCommand, L"HKLM:", 5)) {
hkey = HKEY_LOCAL_MACHINE;
pszNextKey = pszCommand + 5;
} else if (!StrCmpNIW(pszCommand, L"HKCR:", 5)) {
hkey = HKEY_CLASSES_ROOT;
pszNextKey = pszCommand + 5;
} else {
return (BOOL)pszCommand[0];
}
StrCpyNW(szKey, pszNextKey, ARRAYSIZE(szKey));
return (Reg_GetCommand(hkey, szKey, NULL, pszCommand));
}
return (BOOL)pszCommand[0];
}
#define FillExecInfo(_info, _hwnd, _verb, _file, _params, _dir, _show) \
(_info).hwnd = _hwnd; \
(_info).lpVerb = _verb; \
(_info).lpFile = _file; \
(_info).lpParameters = _params; \
(_info).lpDirectory = _dir; \
(_info).nShow = _show; \
(_info).fMask = 0; \
(_info).cbSize = sizeof(SHELLEXECUTEINFOW);
HRESULT RunRegCommand(HWND hwnd, HKEY hkey, LPCWSTR pszKey)
{
HRESULT hr = E_FAIL;
WCHAR szCommand[1024];
if (Reg_GetCommand(hkey, pszKey, L"", szCommand))
{
LPWSTR pszArgs;
SHELLEXECUTEINFOW ExecInfo;
WCHAR szExpCommand[1024];
SHExpandEnvironmentStringsW(szCommand, szExpCommand, ARRAYSIZE(szExpCommand));
// Long filenames _should_ be surrounded by quote marks. However, some aren't.
// This causes problems because the registry entry might be of the form
// (c:\program files\Windows Messaging\[...]) instead of
// ("c:\program files\Windows Messaging\[...]"). Compare this with
// a reg value with (rundll32 C:\progra~1\etc)
// We end up parsing attempting to run C:\program, which of course doesn't exist.
// This is a hack for the benefit OSR2, which turns szExpCommand
// into a null string, rather than letting it be, if it can't be shortened.
GetShortPathNameW(szExpCommand, szExpCommand, ARRAYSIZE(szExpCommand));
if ((*szExpCommand==L'\0') && (*szCommand!=L'\0'))
{
SHExpandEnvironmentStringsW(szCommand, szExpCommand, ARRAYSIZE(szExpCommand));
}
pszArgs = PathGetArgsW(szExpCommand);
PathRemoveArgsW(szExpCommand);
PathUnquoteSpacesW(szExpCommand);
FillExecInfo(ExecInfo, hwnd, NULL, szExpCommand, pszArgs, NULL, SW_SHOWNORMAL);
if (IsOS(OS_WHISTLERORGREATER))
{
ExecInfo.fMask |= SEE_MASK_FLAG_LOG_USAGE;
}
hr = ShellExecuteExWrapW(&ExecInfo) ? S_OK : E_FAIL;
}
return hr;
}
// NOTE! RunIndirectRegCommand logs the action as user-initiated!
HRESULT RunIndirectRegCommand(HWND hwnd, HKEY hkey, LPCWSTR pszKey, LPCWSTR pszVerb)
{
HRESULT hr = E_FAIL;
WCHAR szDefApp[80];
LONG cbSize = sizeof(szDefApp);
if (RegQueryValueW(hkey, pszKey, szDefApp, &cbSize) == ERROR_SUCCESS)
{
WCHAR szFullKey[256];
// tack on shell\%verb%\command
wnsprintfW(szFullKey, ARRAYSIZE(szFullKey), L"%s\\%s\\shell\\%s\\command", pszKey, szDefApp, pszVerb);
hr = RunRegCommand(hwnd, hkey, szFullKey);
}
return hr;
}
HRESULT SHRunIndirectRegClientCommand(HWND hwnd, LPCWSTR pszClient)
{
WCHAR szKey[80];
wnsprintfW(szKey, ARRAYSIZE(szKey), L"Software\\Clients\\%s", pszClient);
return RunIndirectRegCommand(hwnd, HKEY_LOCAL_MACHINE, szKey, L"Open");
}
Reference in a new issue View git blame Copy permalink