reg.c File Reference

#include <stdarg.h>
#include <string.h>
#include "windef.h"
#include "winbase.h"
#include "winuser.h"
#include "winreg.h"
#include "wine/debug.h"
#include "shlwapi.h"
#include "wine/unicode.h"

Include dependency graph for reg.c:

Go to the source code of this file.

Classes
struct	SHUSKEY

Macros
#define	NO_SHLWAPI_STREAM
#define	REG_HKCU   TRUE
#define	REG_HKLM   FALSE
#define	szClassIdKeyLen   (sizeof(szClassIdKey)/sizeof(WCHAR))

Typedefs
typedef struct SHUSKEY *	LPSHUSKEY

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (shell)
INT WINAPI	SHStringFromGUIDW (REFGUID, LPWSTR, INT)
HRESULT WINAPI	SHRegGetCLSIDKeyW (REFGUID, LPCWSTR, BOOL, BOOL, PHKEY)
static HKEY	REG_GetHKEYFromHUSKEY (HUSKEY hUSKey, BOOL which)
LONG WINAPI	SHRegOpenUSKeyA (LPCSTR Path, REGSAM AccessType, HUSKEY hRelativeUSKey, PHUSKEY phNewUSKey, BOOL fIgnoreHKCU)
LONG WINAPI	SHRegOpenUSKeyW (LPCWSTR Path, REGSAM AccessType, HUSKEY hRelativeUSKey, PHUSKEY phNewUSKey, BOOL fIgnoreHKCU)
LONG WINAPI	SHRegCloseUSKey (HUSKEY hUSKey)
LONG WINAPI	SHRegCreateUSKeyA (LPCSTR path, REGSAM samDesired, HUSKEY relative_key, PHUSKEY new_uskey, DWORD flags)
LONG WINAPI	SHRegCreateUSKeyW (LPCWSTR path, REGSAM samDesired, HUSKEY relative_key, PHUSKEY new_uskey, DWORD flags)
LONG WINAPI	SHRegDeleteEmptyUSKeyA (HUSKEY hUSKey, LPCSTR pszValue, SHREGDEL_FLAGS delRegFlags)
LONG WINAPI	SHRegDeleteEmptyUSKeyW (HUSKEY hUSKey, LPCWSTR pszValue, SHREGDEL_FLAGS delRegFlags)
LONG WINAPI	SHRegDeleteUSValueA (HUSKEY hUSKey, LPCSTR pszValue, SHREGDEL_FLAGS delRegFlags)
LONG WINAPI	SHRegDeleteUSValueW (HUSKEY hUSKey, LPCWSTR pszValue, SHREGDEL_FLAGS delRegFlags)
LONG WINAPI	SHRegEnumUSValueA (HUSKEY hUSKey, DWORD dwIndex, LPSTR pszValueName, LPDWORD pcchValueNameLen, LPDWORD pdwType, LPVOID pvData, LPDWORD pcbData, SHREGENUM_FLAGS enumRegFlags)
LONG WINAPI	SHRegEnumUSValueW (HUSKEY hUSKey, DWORD dwIndex, LPWSTR pszValueName, LPDWORD pcchValueNameLen, LPDWORD pdwType, LPVOID pvData, LPDWORD pcbData, SHREGENUM_FLAGS enumRegFlags)
LONG WINAPI	SHRegQueryUSValueA (HUSKEY hUSKey, LPCSTR pszValue, LPDWORD pdwType, LPVOID pvData, LPDWORD pcbData, BOOL fIgnoreHKCU, LPVOID pvDefaultData, DWORD dwDefaultDataSize)
LONG WINAPI	SHRegQueryUSValueW (HUSKEY hUSKey, LPCWSTR pszValue, LPDWORD pdwType, LPVOID pvData, LPDWORD pcbData, BOOL fIgnoreHKCU, LPVOID pvDefaultData, DWORD dwDefaultDataSize)
LONG WINAPI	SHRegGetUSValueA (LPCSTR pSubKey, LPCSTR pValue, LPDWORD pwType, LPVOID pvData, LPDWORD pcbData, BOOL flagIgnoreHKCU, LPVOID pDefaultData, DWORD wDefaultDataSize)
LONG WINAPI	SHRegGetUSValueW (LPCWSTR pSubKey, LPCWSTR pValue, LPDWORD pwType, LPVOID pvData, LPDWORD pcbData, BOOL flagIgnoreHKCU, LPVOID pDefaultData, DWORD wDefaultDataSize)
LONG WINAPI	SHRegSetUSValueA (LPCSTR pszSubKey, LPCSTR pszValue, DWORD dwType, LPVOID pvData, DWORD cbData, DWORD dwFlags)
LONG WINAPI	SHRegSetUSValueW (LPCWSTR pszSubKey, LPCWSTR pszValue, DWORD dwType, LPVOID pvData, DWORD cbData, DWORD dwFlags)
BOOL WINAPI	SHRegGetBoolUSValueA (LPCSTR pszSubKey, LPCSTR pszValue, BOOL fIgnoreHKCU, BOOL fDefault)
BOOL WINAPI	SHRegGetBoolUSValueW (LPCWSTR pszSubKey, LPCWSTR pszValue, BOOL fIgnoreHKCU, BOOL fDefault)
LONG WINAPI	SHRegQueryInfoUSKeyA (HUSKEY hUSKey, LPDWORD pcSubKeys, LPDWORD pcchMaxSubKeyLen, LPDWORD pcValues, LPDWORD pcchMaxValueNameLen, SHREGENUM_FLAGS enumRegFlags)
LONG WINAPI	SHRegQueryInfoUSKeyW (HUSKEY hUSKey, LPDWORD pcSubKeys, LPDWORD pcchMaxSubKeyLen, LPDWORD pcValues, LPDWORD pcchMaxValueNameLen, SHREGENUM_FLAGS enumRegFlags)
LONG WINAPI	SHRegEnumUSKeyA (HUSKEY hUSKey, DWORD dwIndex, LPSTR pszName, LPDWORD pcchValueNameLen, SHREGENUM_FLAGS enumRegFlags)
LONG WINAPI	SHRegEnumUSKeyW (HUSKEY hUSKey, DWORD dwIndex, LPWSTR pszName, LPDWORD pcchValueNameLen, SHREGENUM_FLAGS enumRegFlags)
LONG WINAPI	SHRegWriteUSValueA (HUSKEY hUSKey, LPCSTR pszValue, DWORD dwType, LPVOID pvData, DWORD cbData, DWORD dwFlags)
LONG WINAPI	SHRegWriteUSValueW (HUSKEY hUSKey, LPCWSTR pszValue, DWORD dwType, LPVOID pvData, DWORD cbData, DWORD dwFlags)
DWORD WINAPI	SHRegGetPathA (HKEY hKey, LPCSTR lpszSubKey, LPCSTR lpszValue, LPSTR lpszPath, DWORD dwFlags)
DWORD WINAPI	SHRegGetPathW (HKEY hKey, LPCWSTR lpszSubKey, LPCWSTR lpszValue, LPWSTR lpszPath, DWORD dwFlags)
DWORD WINAPI	SHRegSetPathA (HKEY hKey, LPCSTR lpszSubKey, LPCSTR lpszValue, LPCSTR lpszPath, DWORD dwFlags)
DWORD WINAPI	SHRegSetPathW (HKEY hKey, LPCWSTR lpszSubKey, LPCWSTR lpszValue, LPCWSTR lpszPath, DWORD dwFlags)
DWORD WINAPI	SHGetValueA (HKEY hKey, LPCSTR lpszSubKey, LPCSTR lpszValue, LPDWORD pwType, LPVOID pvData, LPDWORD pcbData)
DWORD WINAPI	SHGetValueW (HKEY hKey, LPCWSTR lpszSubKey, LPCWSTR lpszValue, LPDWORD pwType, LPVOID pvData, LPDWORD pcbData)
DWORD WINAPI	SHSetValueA (HKEY hKey, LPCSTR lpszSubKey, LPCSTR lpszValue, DWORD dwType, LPCVOID pvData, DWORD cbData)
DWORD WINAPI	SHSetValueW (HKEY hKey, LPCWSTR lpszSubKey, LPCWSTR lpszValue, DWORD dwType, LPCVOID pvData, DWORD cbData)
LONG WINAPI	SHQueryInfoKeyA (HKEY hKey, LPDWORD pwSubKeys, LPDWORD pwSubKeyMax, LPDWORD pwValues, LPDWORD pwValueMax)
LONG WINAPI	SHQueryInfoKeyW (HKEY hKey, LPDWORD pwSubKeys, LPDWORD pwSubKeyMax, LPDWORD pwValues, LPDWORD pwValueMax)
DWORD WINAPI	SHQueryValueExA (HKEY hKey, LPCSTR lpszValue, LPDWORD lpReserved, LPDWORD pwType, LPVOID pvData, LPDWORD pcbData)
DWORD WINAPI	SHQueryValueExW (HKEY hKey, LPCWSTR lpszValue, LPDWORD lpReserved, LPDWORD pwType, LPVOID pvData, LPDWORD pcbData)
DWORD WINAPI	SHDeleteKeyA (HKEY hKey, LPCSTR lpszSubKey)
DWORD WINAPI	SHDeleteKeyW (HKEY hKey, LPCWSTR lpszSubKey)
DWORD WINAPI	SHDeleteEmptyKeyA (HKEY hKey, LPCSTR lpszSubKey)
DWORD WINAPI	SHDeleteEmptyKeyW (HKEY hKey, LPCWSTR lpszSubKey)
DWORD WINAPI	SHDeleteOrphanKeyA (HKEY hKey, LPCSTR lpszSubKey)
DWORD WINAPI	SHDeleteOrphanKeyW (HKEY hKey, LPCWSTR lpszSubKey)
DWORD WINAPI	SHDeleteValueA (HKEY hKey, LPCSTR lpszSubKey, LPCSTR lpszValue)
DWORD WINAPI	SHDeleteValueW (HKEY hKey, LPCWSTR lpszSubKey, LPCWSTR lpszValue)
LONG WINAPI	SHEnumKeyExA (HKEY hKey, DWORD dwIndex, LPSTR lpszSubKey, LPDWORD pwLen)
LONG WINAPI	SHEnumKeyExW (HKEY hKey, DWORD dwIndex, LPWSTR lpszSubKey, LPDWORD pwLen)
LONG WINAPI	SHEnumValueA (HKEY hKey, DWORD dwIndex, LPSTR lpszValue, LPDWORD pwLen, LPDWORD pwType, LPVOID pvData, LPDWORD pcbData)
LONG WINAPI	SHEnumValueW (HKEY hKey, DWORD dwIndex, LPWSTR lpszValue, LPDWORD pwLen, LPDWORD pwType, LPVOID pvData, LPDWORD pcbData)
DWORD WINAPI	SHGetValueGoodBootA (HKEY hkey, LPCSTR pSubKey, LPCSTR pValue, LPDWORD pwType, LPVOID pvData, LPDWORD pbData)
DWORD WINAPI	SHGetValueGoodBootW (HKEY hkey, LPCWSTR pSubKey, LPCWSTR pValue, LPDWORD pwType, LPVOID pvData, LPDWORD pbData)
BOOL WINAPI	RegisterMIMETypeForExtensionA (LPCSTR lpszSubKey, LPCSTR lpszValue)
BOOL WINAPI	RegisterMIMETypeForExtensionW (LPCWSTR lpszSubKey, LPCWSTR lpszValue)
BOOL WINAPI	UnregisterMIMETypeForExtensionA (LPCSTR lpszSubKey)
BOOL WINAPI	UnregisterMIMETypeForExtensionW (LPCWSTR lpszSubKey)
BOOL WINAPI	GetMIMETypeSubKeyA (LPCSTR lpszType, LPSTR lpszBuffer, DWORD dwLen)
BOOL WINAPI	GetMIMETypeSubKeyW (LPCWSTR lpszType, LPWSTR lpszBuffer, DWORD dwLen)
BOOL WINAPI	MIME_GetExtensionA (LPCSTR lpszType, LPSTR lpExt, INT iLen)
BOOL WINAPI	MIME_GetExtensionW (LPCWSTR lpszType, LPWSTR lpExt, INT iLen)
BOOL WINAPI	RegisterExtensionForMIMETypeA (LPCSTR lpszExt, LPCSTR lpszType)
BOOL WINAPI	RegisterExtensionForMIMETypeW (LPCWSTR lpszExt, LPCWSTR lpszType)
BOOL WINAPI	UnregisterExtensionForMIMETypeA (LPCSTR lpszType)
BOOL WINAPI	UnregisterExtensionForMIMETypeW (LPCWSTR lpszType)
HKEY WINAPI	SHRegDuplicateHKey (HKEY hKey)
DWORD WINAPI	SHCopyKeyA (HKEY hKeySrc, LPCSTR lpszSrcSubKey, HKEY hKeyDst, DWORD dwReserved)
DWORD WINAPI	SHCopyKeyW (HKEY hKeySrc, LPCWSTR lpszSrcSubKey, HKEY hKeyDst, DWORD dwReserved)
int WINAPI	SHRegGetIntW (HKEY hKey, LPCWSTR lpszValue, int iDefault)
HRESULT WINAPI	SHRegGetCLSIDKeyA (REFGUID guid, LPCSTR lpszValue, BOOL bUseHKCU, BOOL bCreate, PHKEY phKey)
HRESULT WINAPI	SHRegisterValidateTemplate (LPCWSTR filename, BOOL unknown)

Variables
static const char	lpszContentTypeA [] = "Content Type"
static const WCHAR	lpszContentTypeW [] = { 'C','o','n','t','e','n','t',' ','T','y','p','e','\0'}
static const char	szMimeDbContentA [] = "MIME\\Database\\Content Type\\"
static const WCHAR	szMimeDbContentW []
static const DWORD	dwLenMimeDbContent = 27
static const char	szExtensionA [] = "Extension"
static const WCHAR	szExtensionW [] = { 'E', 'x', 't','e','n','s','i','o','n','\0' }

Macro Definition Documentation

NO_SHLWAPI_STREAM

#define NO_SHLWAPI_STREAM

Definition at line 29 of file reg.c.

REG_HKCU

#define REG_HKCU   TRUE

Definition at line 61 of file reg.c.

REG_HKLM

#define REG_HKLM   FALSE

Definition at line 62 of file reg.c.

szClassIdKeyLen

#define szClassIdKeyLen   (sizeof(szClassIdKey)/sizeof(WCHAR))

Typedef Documentation

LPSHUSKEY

typedef struct SHUSKEY * LPSHUSKEY

Function Documentation

GetMIMETypeSubKeyA()

BOOL WINAPI GetMIMETypeSubKeyA	(	LPCSTR	lpszType,
		LPSTR	lpszBuffer,
		DWORD	dwLen
	)

Definition at line 2026 of file reg.c.

{
  TRACE("(%s,%p,%d)\n", debugstr_a(lpszType), lpszBuffer, dwLen);
 
  if (dwLen > dwLenMimeDbContent && lpszType && lpszBuffer)
  {
    size_t dwStrLen = strlen(lpszType);
 
    if (dwStrLen < dwLen - dwLenMimeDbContent)
    {
      memcpy(lpszBuffer, szMimeDbContentA, dwLenMimeDbContent);
      memcpy(lpszBuffer + dwLenMimeDbContent, lpszType, dwStrLen + 1);
      return TRUE;
    }
  }
  return FALSE;
}

Referenced by MIME_GetExtensionA(), RegisterExtensionForMIMETypeA(), and UnregisterExtensionForMIMETypeA().

GetMIMETypeSubKeyW()

BOOL WINAPI GetMIMETypeSubKeyW	(	LPCWSTR	lpszType,
		LPWSTR	lpszBuffer,
		DWORD	dwLen
	)

Definition at line 2049 of file reg.c.

{
  TRACE("(%s,%p,%d)\n", debugstr_w(lpszType), lpszBuffer, dwLen);
 
  if (dwLen > dwLenMimeDbContent && lpszType && lpszBuffer)
  {
    DWORD dwStrLen = strlenW(lpszType);
 
    if (dwStrLen < dwLen - dwLenMimeDbContent)
    {
      memcpy(lpszBuffer, szMimeDbContentW, dwLenMimeDbContent * sizeof(WCHAR));
      memcpy(lpszBuffer + dwLenMimeDbContent, lpszType, (dwStrLen + 1) * sizeof(WCHAR));
      return TRUE;
    }
  }
  return FALSE;
}

Referenced by MIME_GetExtensionW(), RegisterExtensionForMIMETypeW(), and UnregisterExtensionForMIMETypeW().

MIME_GetExtensionA()

BOOL WINAPI MIME_GetExtensionA	(	LPCSTR	lpszType,
		LPSTR	lpExt,
		INT	iLen
	)

Definition at line 2087 of file reg.c.

{
  char szSubKey[MAX_PATH];
  DWORD dwlen = iLen - 1, dwType;
  BOOL bRet = FALSE;
 
  if (iLen > 0 && lpExt)
    *lpExt = '\0';
 
  if (lpszType && lpExt && iLen > 2 &&
      GetMIMETypeSubKeyA(lpszType, szSubKey, MAX_PATH) &&
      !SHGetValueA(HKEY_CLASSES_ROOT, szSubKey, szExtensionA, &dwType, lpExt + 1, &dwlen) &&
      lpExt[1])
  {
    if (lpExt[1] == '.')
      memmove(lpExt, lpExt + 1, strlen(lpExt + 1) + 1);
    else
      *lpExt = '.'; /* Supply a '.' */
    bRet = TRUE;
  }
  return bRet;
}

MIME_GetExtensionW()

BOOL WINAPI MIME_GetExtensionW	(	LPCWSTR	lpszType,
		LPWSTR	lpExt,
		INT	iLen
	)

Definition at line 2115 of file reg.c.

{
  WCHAR szSubKey[MAX_PATH];
  DWORD dwlen = iLen - 1, dwType;
  BOOL bRet = FALSE;
 
  if (iLen > 0 && lpExt)
    *lpExt = '\0';
 
  if (lpszType && lpExt && iLen > 2 &&
      GetMIMETypeSubKeyW(lpszType, szSubKey, MAX_PATH) &&
      !SHGetValueW(HKEY_CLASSES_ROOT, szSubKey, szExtensionW, &dwType, lpExt + 1, &dwlen) &&
      lpExt[1])
  {
    if (lpExt[1] == '.')
      memmove(lpExt, lpExt + 1, (strlenW(lpExt + 1) + 1) * sizeof(WCHAR));
    else
      *lpExt = '.'; /* Supply a '.' */
    bRet = TRUE;
  }
  return bRet;
}

REG_GetHKEYFromHUSKEY()

static HKEY REG_GetHKEYFromHUSKEY ( HUSKEY  hUSKey, BOOL  which  )

static

Definition at line 69 of file reg.c.

{
        HKEY test = hUSKey;
        LPSHUSKEY mihk = hUSKey;
 
    if ((test == HKEY_CLASSES_ROOT)        ||
        (test == HKEY_CURRENT_CONFIG)      ||
        (test == HKEY_CURRENT_USER)        ||
        (test == HKEY_DYN_DATA)            ||
        (test == HKEY_LOCAL_MACHINE)       ||
        (test == HKEY_PERFORMANCE_DATA)    ||
/* FIXME:  need to define for Win2k, ME, XP
 *      (test == HKEY_PERFORMANCE_TEXT)    ||
 *      (test == HKEY_PERFORMANCE_NLSTEXT) ||
 */
        (test == HKEY_USERS)) return test;
    if (which == REG_HKCU) return mihk->HKCUkey;
    return mihk->HKLMkey;
}

Referenced by SHRegCreateUSKeyW(), SHRegEnumUSKeyA(), SHRegEnumUSKeyW(), SHRegEnumUSValueA(), SHRegEnumUSValueW(), SHRegOpenUSKeyW(), SHRegQueryInfoUSKeyA(), SHRegQueryInfoUSKeyW(), SHRegQueryUSValueA(), and SHRegQueryUSValueW().

RegisterExtensionForMIMETypeA()

BOOL WINAPI RegisterExtensionForMIMETypeA	(	LPCSTR	lpszExt,
		LPCSTR	lpszType
	)

Definition at line 2151 of file reg.c.

{
  DWORD dwLen;
  char szKey[MAX_PATH];
 
  TRACE("(%s,%s)\n", debugstr_a(lpszExt), debugstr_a(lpszType));
 
  if (!GetMIMETypeSubKeyA(lpszType, szKey, MAX_PATH)) /* Get full path to the key */
    return FALSE;
 
  dwLen = strlen(lpszExt) + 1;
 
  if (SHSetValueA(HKEY_CLASSES_ROOT, szKey, szExtensionA, REG_SZ, lpszExt, dwLen))
    return FALSE;
  return TRUE;
}

RegisterExtensionForMIMETypeW()

BOOL WINAPI RegisterExtensionForMIMETypeW	(	LPCWSTR	lpszExt,
		LPCWSTR	lpszType
	)

Definition at line 2173 of file reg.c.

{
  DWORD dwLen;
  WCHAR szKey[MAX_PATH];
 
  TRACE("(%s,%s)\n", debugstr_w(lpszExt), debugstr_w(lpszType));
 
  /* Get the full path to the key */
  if (!GetMIMETypeSubKeyW(lpszType, szKey, MAX_PATH)) /* Get full path to the key */
    return FALSE;
 
  dwLen = (lstrlenW(lpszExt) + 1) * sizeof(WCHAR);
 
  if (SHSetValueW(HKEY_CLASSES_ROOT, szKey, szExtensionW, REG_SZ, lpszExt, dwLen))
    return FALSE;
  return TRUE;
}

RegisterMIMETypeForExtensionA()

BOOL WINAPI RegisterMIMETypeForExtensionA	(	LPCSTR	lpszSubKey,
		LPCSTR	lpszValue
	)

Definition at line 1953 of file reg.c.

{
  if (!lpszValue)
  {
    WARN("Invalid lpszValue would crash under Win32!\n");
    return FALSE;
  }
 
  return !SHSetValueA(HKEY_CLASSES_ROOT, lpszSubKey, lpszContentTypeA,
                      REG_SZ, lpszValue, strlen(lpszValue));
}

RegisterMIMETypeForExtensionW()

BOOL WINAPI RegisterMIMETypeForExtensionW	(	LPCWSTR	lpszSubKey,
		LPCWSTR	lpszValue
	)

Definition at line 1970 of file reg.c.

{
  if (!lpszValue)
  {
    WARN("Invalid lpszValue would crash under Win32!\n");
    return FALSE;
  }
 
  return !SHSetValueW(HKEY_CLASSES_ROOT, lpszSubKey, lpszContentTypeW,
                      REG_SZ, lpszValue, strlenW(lpszValue));
}

SHCopyKeyA()

DWORD WINAPI SHCopyKeyA	(	HKEY	hKeySrc,
		LPCSTR	lpszSrcSubKey,
		HKEY	hKeyDst,
		DWORD	dwReserved
	)

Definition at line 2286 of file reg.c.

{
  WCHAR szSubKeyW[MAX_PATH];
 
  TRACE("(hkey=%p,%s,%p08x,%d)\n", hKeySrc, debugstr_a(lpszSrcSubKey), hKeyDst, dwReserved);
 
  if (lpszSrcSubKey)
    MultiByteToWideChar(CP_ACP, 0, lpszSrcSubKey, -1, szSubKeyW, MAX_PATH);
 
  return SHCopyKeyW(hKeySrc, lpszSrcSubKey ? szSubKeyW : NULL, hKeyDst, dwReserved);
}

SHCopyKeyW()

DWORD WINAPI SHCopyKeyW	(	HKEY	hKeySrc,
		LPCWSTR	lpszSrcSubKey,
		HKEY	hKeyDst,
		DWORD	dwReserved
	)

Definition at line 2303 of file reg.c.

{
  DWORD dwKeyCount = 0, dwValueCount = 0, dwMaxKeyLen = 0;
  DWORD  dwMaxValueLen = 0, dwMaxDataLen = 0, i;
  BYTE buff[1024];
  LPVOID lpBuff = buff;
  WCHAR szName[MAX_PATH], *lpszName = szName;
  DWORD dwRet = S_OK;
 
  TRACE("hkey=%p,%s,%p08x,%d)\n", hKeySrc, debugstr_w(lpszSrcSubKey), hKeyDst, dwReserved);
 
  if(!hKeyDst || !hKeySrc)
    dwRet = ERROR_INVALID_PARAMETER;
  else
  {
    /* Open source key */
    if(lpszSrcSubKey)
      dwRet = RegOpenKeyExW(hKeySrc, lpszSrcSubKey, 0, KEY_ALL_ACCESS, &hKeySrc);
 
    if(dwRet)
      hKeyDst = NULL; /* Don't close this key since we didn't open it */
    else
    {
      /* Get details about sub keys and values */
      dwRet = RegQueryInfoKeyW(hKeySrc, NULL, NULL, NULL, &dwKeyCount, &dwMaxKeyLen,
                               NULL, &dwValueCount, &dwMaxValueLen, &dwMaxDataLen,
                               NULL, NULL);
      if(!dwRet)
      {
        if (dwMaxValueLen > dwMaxKeyLen)
          dwMaxKeyLen = dwMaxValueLen; /* Get max size for key/value names */
 
        if (dwMaxKeyLen++ > MAX_PATH - 1)
          lpszName = HeapAlloc(GetProcessHeap(), 0, dwMaxKeyLen * sizeof(WCHAR));
 
        if (dwMaxDataLen > sizeof(buff))
          lpBuff = HeapAlloc(GetProcessHeap(), 0, dwMaxDataLen);
 
        if (!lpszName || !lpBuff)
          dwRet = ERROR_NOT_ENOUGH_MEMORY;
      }
    }
  }
 
  /* Copy all the sub keys */
  for(i = 0; i < dwKeyCount && !dwRet; i++)
  {
    HKEY hSubKeySrc, hSubKeyDst;
    DWORD dwSize = dwMaxKeyLen;
 
    dwRet = RegEnumKeyExW(hKeySrc, i, lpszName, &dwSize, NULL, NULL, NULL, NULL);
 
    if(!dwRet)
    {
      /* Open source sub key */
      dwRet = RegOpenKeyExW(hKeySrc, lpszName, 0, KEY_READ, &hSubKeySrc);
 
      if(!dwRet)
      {
        /* Create destination sub key */
        dwRet = RegCreateKeyW(hKeyDst, lpszName, &hSubKeyDst);
 
        if(!dwRet)
        {
          /* Recursively copy keys and values from the sub key */
          dwRet = SHCopyKeyW(hSubKeySrc, NULL, hSubKeyDst, 0);
          RegCloseKey(hSubKeyDst);
        }
      }
      RegCloseKey(hSubKeySrc);
    }
  }
 
  /* Copy all the values in this key */
  for (i = 0; i < dwValueCount && !dwRet; i++)
  {
    DWORD dwNameSize = dwMaxKeyLen, dwType, dwLen = dwMaxDataLen;
 
    dwRet = RegEnumValueW(hKeySrc, i, lpszName, &dwNameSize, NULL, &dwType, lpBuff, &dwLen);
 
    if (!dwRet)
      dwRet = SHSetValueW(hKeyDst, NULL, lpszName, dwType, lpBuff, dwLen);
  }
 
  /* Free buffers if allocated */
  if (lpszName != szName)
    HeapFree(GetProcessHeap(), 0, lpszName);
  if (lpBuff != buff)
    HeapFree(GetProcessHeap(), 0, lpBuff);
 
  if (lpszSrcSubKey && hKeyDst)
    RegCloseKey(hKeyDst);
  return dwRet;
}

Referenced by COpenWithList::SetDefaultHandler(), SHCopyKeyA(), and SHCopyKeyW().

SHDeleteEmptyKeyA()

DWORD WINAPI SHDeleteEmptyKeyA	(	HKEY	hKey,
		LPCSTR	lpszSubKey
	)

Definition at line 1650 of file reg.c.

{
  DWORD dwRet, dwKeyCount = 0;
  HKEY hSubKey = 0;
 
  TRACE("(hkey=%p,%s)\n", hKey, debugstr_a(lpszSubKey));
 
  dwRet = RegOpenKeyExA(hKey, lpszSubKey, 0, KEY_READ, &hSubKey);
  if(!dwRet)
  {
    dwRet = RegQueryInfoKeyA(hSubKey, NULL, NULL, NULL, &dwKeyCount,
                             NULL, NULL, NULL, NULL, NULL, NULL, NULL);
    RegCloseKey(hSubKey);
    if(!dwRet)
    {
      if (!dwKeyCount)
        dwRet = RegDeleteKeyA(hKey, lpszSubKey);
      else
        dwRet = ERROR_KEY_HAS_CHILDREN;
    }
  }
  return dwRet;
}

SHDeleteEmptyKeyW()

DWORD WINAPI SHDeleteEmptyKeyW	(	HKEY	hKey,
		LPCWSTR	lpszSubKey
	)

Definition at line 1679 of file reg.c.

{
  DWORD dwRet, dwKeyCount = 0;
  HKEY hSubKey = 0;
 
  TRACE("(hkey=%p, %s)\n", hKey, debugstr_w(lpszSubKey));
 
  dwRet = RegOpenKeyExW(hKey, lpszSubKey, 0, KEY_READ, &hSubKey);
  if(!dwRet)
  {
    dwRet = RegQueryInfoKeyW(hSubKey, NULL, NULL, NULL, &dwKeyCount,
                             NULL, NULL, NULL, NULL, NULL, NULL, NULL);
    RegCloseKey(hSubKey);
    if(!dwRet)
    {
      if (!dwKeyCount)
        dwRet = RegDeleteKeyW(hKey, lpszSubKey);
      else
        dwRet = ERROR_KEY_HAS_CHILDREN;
    }
  }
  return dwRet;
}

SHDeleteKeyA()

DWORD WINAPI SHDeleteKeyA	(	HKEY	hKey,
		LPCSTR	lpszSubKey
	)

Definition at line 1575 of file reg.c.

{
  WCHAR subkeyW[MAX_PATH];
 
  MultiByteToWideChar (CP_ACP, 0, lpszSubKey, -1, subkeyW, sizeof(subkeyW)/sizeof(WCHAR));
  return SHDeleteKeyW(hKey, subkeyW);
}

Referenced by delete_key(), test_getstring_no_extra(), test_SHCopyKey(), test_SHDeleteKey(), and testRegStore().

SHDeleteKeyW()

DWORD WINAPI SHDeleteKeyW	(	HKEY	hKey,
		LPCWSTR	lpszSubKey
	)

Definition at line 1588 of file reg.c.

{
  DWORD dwRet, dwMaxSubkeyLen = 0, dwSize;
  WCHAR szNameBuf[MAX_PATH], *lpszName = szNameBuf;
  HKEY hSubKey = 0;
 
  TRACE("(hkey=%p,%s)\n", hKey, debugstr_w(lpszSubKey));
 
  dwRet = RegOpenKeyExW(hKey, lpszSubKey, 0, KEY_READ, &hSubKey);
  if(!dwRet)
  {
    /* Find the maximum subkey length so that we can allocate a buffer */
    dwRet = RegQueryInfoKeyW(hSubKey, NULL, NULL, NULL, NULL,
                             &dwMaxSubkeyLen, NULL, NULL, NULL, NULL, NULL, NULL);
    if(!dwRet)
    {
      dwMaxSubkeyLen++;
      if (dwMaxSubkeyLen > sizeof(szNameBuf)/sizeof(WCHAR))
        /* Name too big: alloc a buffer for it */
        lpszName = HeapAlloc(GetProcessHeap(), 0, dwMaxSubkeyLen*sizeof(WCHAR));
 
      if(!lpszName)
        dwRet = ERROR_NOT_ENOUGH_MEMORY;
      else
      {
        while (dwRet == ERROR_SUCCESS)
        {
          dwSize = dwMaxSubkeyLen;
          dwRet = RegEnumKeyExW(hSubKey, 0, lpszName, &dwSize, NULL, NULL, NULL, NULL);
          if (dwRet == ERROR_SUCCESS || dwRet == ERROR_MORE_DATA)
            dwRet = SHDeleteKeyW(hSubKey, lpszName);
        }
        if (dwRet == ERROR_NO_MORE_ITEMS)
          dwRet = ERROR_SUCCESS;
    
        if (lpszName != szNameBuf)
          HeapFree(GetProcessHeap(), 0, lpszName); /* Free buffer if allocated */
      }
    }
 
    RegCloseKey(hSubKey);
    if(!dwRet)
      dwRet = RegDeleteKeyW(hKey, lpszSubKey);
  }
  return dwRet;
}

Referenced by CMruNode::_DeleteValue(), DeleteExt(), EditTypeDlg_WriteClass(), HandleMruData(), MRUList_DataList(), MRUList_PidlList(), PNP_DeleteClassKey(), SHAddToRecentDocs(), SHDeleteKeyA(), and SHDeleteKeyW().

SHDeleteOrphanKeyA()

DWORD WINAPI SHDeleteOrphanKeyA	(	HKEY	hKey,
		LPCSTR	lpszSubKey
	)

Definition at line 1716 of file reg.c.

{
  HKEY hSubKey;
  DWORD dwKeyCount = 0, dwValueCount = 0, dwRet;
 
  TRACE("(hkey=%p,%s)\n", hKey, debugstr_a(lpszSubKey));
 
  dwRet = RegOpenKeyExA(hKey, lpszSubKey, 0, KEY_READ, &hSubKey);
 
  if(!dwRet)
  {
    /* Get subkey and value count */
    dwRet = RegQueryInfoKeyA(hSubKey, NULL, NULL, NULL, &dwKeyCount,
                             NULL, NULL, &dwValueCount, NULL, NULL, NULL, NULL);
 
    if(!dwRet && !dwKeyCount && !dwValueCount)
    {
      dwRet = RegDeleteKeyA(hKey, lpszSubKey);
    }
    RegCloseKey(hSubKey);
  }
  return dwRet;
}

Referenced by UnregisterExtensionForMIMETypeA().

SHDeleteOrphanKeyW()

DWORD WINAPI SHDeleteOrphanKeyW	(	HKEY	hKey,
		LPCWSTR	lpszSubKey
	)

Definition at line 1745 of file reg.c.

{
  HKEY hSubKey;
  DWORD dwKeyCount = 0, dwValueCount = 0, dwRet;
 
  TRACE("(hkey=%p,%s)\n", hKey, debugstr_w(lpszSubKey));
 
  dwRet = RegOpenKeyExW(hKey, lpszSubKey, 0, KEY_READ, &hSubKey);
 
  if(!dwRet)
  {
    /* Get subkey and value count */
    dwRet = RegQueryInfoKeyW(hSubKey, NULL, NULL, NULL, &dwKeyCount,
                             NULL, NULL, &dwValueCount, NULL, NULL, NULL, NULL);
 
    if(!dwRet && !dwKeyCount && !dwValueCount)
    {
      dwRet = RegDeleteKeyW(hKey, lpszSubKey);
    }
    RegCloseKey(hSubKey);
  }
  return dwRet;
}

Referenced by UnregisterExtensionForMIMETypeW().

SHDeleteValueA()

DWORD WINAPI SHDeleteValueA	(	HKEY	hKey,
		LPCSTR	lpszSubKey,
		LPCSTR	lpszValue
	)

Definition at line 1783 of file reg.c.

{
  DWORD dwRet;
  HKEY hSubKey;
 
  TRACE("(hkey=%p,%s,%s)\n", hKey, debugstr_a(lpszSubKey), debugstr_a(lpszValue));
 
  dwRet = RegOpenKeyExA(hKey, lpszSubKey, 0, KEY_SET_VALUE, &hSubKey);
  if (!dwRet)
  {
    dwRet = RegDeleteValueA(hSubKey, lpszValue);
    RegCloseKey(hSubKey);
  }
  return dwRet;
}

Referenced by test_objecttag(), UnregisterExtensionForMIMETypeA(), and UnregisterMIMETypeForExtensionA().

SHDeleteValueW()

DWORD WINAPI SHDeleteValueW	(	HKEY	hKey,
		LPCWSTR	lpszSubKey,
		LPCWSTR	lpszValue
	)

Definition at line 1804 of file reg.c.

{
  DWORD dwRet;
  HKEY hSubKey;
 
  TRACE("(hkey=%p,%s,%s)\n", hKey, debugstr_w(lpszSubKey), debugstr_w(lpszValue));
 
  dwRet = RegOpenKeyExW(hKey, lpszSubKey, 0, KEY_SET_VALUE, &hSubKey);
  if (!dwRet)
  {
    dwRet = RegDeleteValueW(hSubKey, lpszValue);
    RegCloseKey(hSubKey);
  }
  return dwRet;
}

Referenced by CMruBase::_DeleteValue(), CMruLongList::_ImportShortList(), MRUList_DataList(), CGlobalFolderSettings::Save(), CRegFolder::SetNameOf(), UnregisterExtensionForMIMETypeW(), UnregisterMIMETypeForExtensionW(), and CRegPropertyBag::Write().

SHEnumKeyExA()

LONG WINAPI SHEnumKeyExA	(	HKEY	hKey,
		DWORD	dwIndex,
		LPSTR	lpszSubKey,
		LPDWORD	pwLen
	)

Definition at line 1835 of file reg.c.

{
  TRACE("(hkey=%p,%d,%s,%p)\n", hKey, dwIndex, debugstr_a(lpszSubKey), pwLen);
 
  return RegEnumKeyExA(hKey, dwIndex, lpszSubKey, pwLen, NULL, NULL, NULL, NULL);
}

SHEnumKeyExW()

LONG WINAPI SHEnumKeyExW	(	HKEY	hKey,
		DWORD	dwIndex,
		LPWSTR	lpszSubKey,
		LPDWORD	pwLen
	)

Definition at line 1848 of file reg.c.

{
  TRACE("(hkey=%p,%d,%s,%p)\n", hKey, dwIndex, debugstr_w(lpszSubKey), pwLen);
 
  return RegEnumKeyExW(hKey, dwIndex, lpszSubKey, pwLen, NULL, NULL, NULL, NULL);
}

SHEnumValueA()

LONG WINAPI SHEnumValueA	(	HKEY	hKey,
		DWORD	dwIndex,
		LPSTR	lpszValue,
		LPDWORD	pwLen,
		LPDWORD	pwType,
		LPVOID	pvData,
		LPDWORD	pcbData
	)

Definition at line 1874 of file reg.c.

{
  TRACE("(hkey=%p,%d,%s,%p,%p,%p,%p)\n", hKey, dwIndex,
        debugstr_a(lpszValue), pwLen, pwType, pvData, pcbData);
 
  return RegEnumValueA(hKey, dwIndex, lpszValue, pwLen, NULL,
                       pwType, pvData, pcbData);
}

SHEnumValueW()

LONG WINAPI SHEnumValueW	(	HKEY	hKey,
		DWORD	dwIndex,
		LPWSTR	lpszValue,
		LPDWORD	pwLen,
		LPDWORD	pwType,
		LPVOID	pvData,
		LPDWORD	pcbData
	)

Definition at line 1890 of file reg.c.

{
  TRACE("(hkey=%p,%d,%s,%p,%p,%p,%p)\n", hKey, dwIndex,
        debugstr_w(lpszValue), pwLen, pwType, pvData, pcbData);
 
  return RegEnumValueW(hKey, dwIndex, lpszValue, pwLen, NULL,
                       pwType, pvData, pcbData);
}

SHGetValueA()

DWORD WINAPI SHGetValueA	(	HKEY	hKey,
		LPCSTR	lpszSubKey,
		LPCSTR	lpszValue,
		LPDWORD	pwType,
		LPVOID	pvData,
		LPDWORD	pcbData
	)

Definition at line 1249 of file reg.c.

{
  DWORD dwRet = 0;
  HKEY hSubKey = 0;
 
  TRACE("(hkey=%p,%s,%s,%p,%p,%p)\n", hKey, debugstr_a(lpszSubKey),
        debugstr_a(lpszValue), pwType, pvData, pcbData);
 
  /*   lpszSubKey can be 0. In this case the value is taken from the
   *   current key.
   */
  if(lpszSubKey)
    dwRet = RegOpenKeyExA(hKey, lpszSubKey, 0, KEY_QUERY_VALUE, &hSubKey);
 
  if (! dwRet)
  {
    /* SHQueryValueEx expands Environment strings */
    dwRet = SHQueryValueExA(hSubKey ? hSubKey : hKey, lpszValue, 0, pwType, pvData, pcbData);
    if (hSubKey) RegCloseKey(hSubKey);
  }
  return dwRet;
}

Referenced by getregdw(), MIME_GetExtensionA(), PathIsContentTypeA(), SHGetValueGoodBootA(), SHLWAPI_GetMappedFlags(), SHLWAPI_GetRegistryCompatFlags(), SHLWAPI_UseSystemForSystemFolders(), SHRegGetPathA(), and test_SHGetValue().

SHGetValueGoodBootA()

DWORD WINAPI SHGetValueGoodBootA	(	HKEY	hkey,
		LPCSTR	pSubKey,
		LPCSTR	pValue,
		LPDWORD	pwType,
		LPVOID	pvData,
		LPDWORD	pbData
	)

Definition at line 1919 of file reg.c.

{
  if (GetSystemMetrics(SM_CLEANBOOT))
    return ERROR_INVALID_FUNCTION;
  return SHGetValueA(hkey, pSubKey, pValue, pwType, pvData, pbData);
}

SHGetValueGoodBootW()

DWORD WINAPI SHGetValueGoodBootW	(	HKEY	hkey,
		LPCWSTR	pSubKey,
		LPCWSTR	pValue,
		LPDWORD	pwType,
		LPVOID	pvData,
		LPDWORD	pbData
	)

Definition at line 1932 of file reg.c.

{
  if (GetSystemMetrics(SM_CLEANBOOT))
    return ERROR_INVALID_FUNCTION;
  return SHGetValueW(hkey, pSubKey, pValue, pwType, pvData, pbData);
}

SHGetValueW()

DWORD WINAPI SHGetValueW	(	HKEY	hKey,
		LPCWSTR	lpszSubKey,
		LPCWSTR	lpszValue,
		LPDWORD	pwType,
		LPVOID	pvData,
		LPDWORD	pcbData
	)

Definition at line 1278 of file reg.c.

{
  DWORD dwRet = 0;
  HKEY hSubKey = 0;
 
  TRACE("(hkey=%p,%s,%s,%p,%p,%p)\n", hKey, debugstr_w(lpszSubKey),
        debugstr_w(lpszValue), pwType, pvData, pcbData);
 
  if(lpszSubKey)
    dwRet = RegOpenKeyExW(hKey, lpszSubKey, 0, KEY_QUERY_VALUE, &hSubKey);
 
  if (! dwRet)
  {
    dwRet = SHQueryValueExW(hSubKey ? hSubKey : hKey, lpszValue, 0, pwType, pvData, pcbData);
    if (hSubKey) RegCloseKey(hSubKey);
  }
  return dwRet;
}

Referenced by CDesktopUpgradePropertyBag::_AlreadyUpgraded(), CBandSiteMenu::_CreateMenuPart(), CViewStatePropertyBag::_GetMRUSize(), CMruShortList::_InitSlots(), CMruLongList::_InitSlots(), CMruBase::_LoadItem(), CMruPidlList::_LoadNodeSlots(), CRegPropertyBag::_ReadBinary(), CRegPropertyBag::_ReadDword(), CDesktopUpgradePropertyBag::_ReadFlags(), CRegPropertyBag::_ReadString(), Candidate_SHGetRestriction(), GetAssocClass(), CRegFolder::GetDisplayNameOf(), CMruNode::GetNodeSlot(), GetZipCodePage(), HCR_GetExecuteCommandW(), InitializeServerAdminUI(), TaskbarSettings::Load(), MIME_GetExtensionW(), MRUList_Check(), MRUList_DataList(), MRUList_PidlList_0(), PathIsContentTypeW(), CRegPropertyBag::Read(), SHAboutInfoW(), SHCreatePropSheetExtArrayEx(), SHELL32_ReadRegShellState(), SHELL_GetCachedComputerDescription(), SHGetRestriction(), SHGetValueGoodBootW(), SHRegGetPathW(), SIC_GetMetricsValue(), and CDefView::UpdateListColors().

SHQueryInfoKeyA()

LONG WINAPI SHQueryInfoKeyA	(	HKEY	hKey,
		LPDWORD	pwSubKeys,
		LPDWORD	pwSubKeyMax,
		LPDWORD	pwValues,
		LPDWORD	pwValueMax
	)

Definition at line 1379 of file reg.c.

{
  TRACE("(hkey=%p,%p,%p,%p,%p)\n", hKey, pwSubKeys, pwSubKeyMax,
        pwValues, pwValueMax);
  return RegQueryInfoKeyA(hKey, NULL, NULL, NULL, pwSubKeys, pwSubKeyMax,
                          NULL, pwValues, pwValueMax, NULL, NULL, NULL);
}

SHQueryInfoKeyW()

LONG WINAPI SHQueryInfoKeyW	(	HKEY	hKey,
		LPDWORD	pwSubKeys,
		LPDWORD	pwSubKeyMax,
		LPDWORD	pwValues,
		LPDWORD	pwValueMax
	)

Definition at line 1393 of file reg.c.

{
  TRACE("(hkey=%p,%p,%p,%p,%p)\n", hKey, pwSubKeys, pwSubKeyMax,
        pwValues, pwValueMax);
  return RegQueryInfoKeyW(hKey, NULL, NULL, NULL, pwSubKeys, pwSubKeyMax,
                          NULL, pwValues, pwValueMax, NULL, NULL, NULL);
}

SHQueryValueExA()

DWORD WINAPI SHQueryValueExA	(	HKEY	hKey,
		LPCSTR	lpszValue,
		LPDWORD	lpReserved,
		LPDWORD	pwType,
		LPVOID	pvData,
		LPDWORD	pcbData
	)

Definition at line 1444 of file reg.c.

{
  DWORD dwRet, dwType, dwUnExpDataLen = 0, dwExpDataLen;
 
  TRACE("(hkey=%p,%s,%p,%p,%p,%p=%d)\n", hKey, debugstr_a(lpszValue),
        lpReserved, pwType, pvData, pcbData, pcbData ? *pcbData : 0);
 
  if (pcbData) dwUnExpDataLen = *pcbData;
 
  dwRet = RegQueryValueExA(hKey, lpszValue, lpReserved, &dwType, pvData, &dwUnExpDataLen);
 
  if (pcbData && (dwType == REG_EXPAND_SZ))
  {
    DWORD nBytesToAlloc;
 
    /* Expand type REG_EXPAND_SZ into REG_SZ */
    LPSTR szData;
 
    /* If the caller didn't supply a buffer or the buffer is too small we have
     * to allocate our own
     */
    if ((!pvData) || (dwRet == ERROR_MORE_DATA) )
    {
      char cNull = '\0';
      nBytesToAlloc = dwUnExpDataLen;
 
      szData = LocalAlloc(LMEM_ZEROINIT, nBytesToAlloc);
      RegQueryValueExA (hKey, lpszValue, lpReserved, NULL, (LPBYTE)szData, &nBytesToAlloc);
      dwExpDataLen = ExpandEnvironmentStringsA(szData, &cNull, 1);
      dwUnExpDataLen = max(nBytesToAlloc, dwExpDataLen);
      LocalFree(szData);
    }
    else
    {
      nBytesToAlloc = (lstrlenA(pvData)+1) * sizeof (CHAR);
      szData = LocalAlloc(LMEM_ZEROINIT, nBytesToAlloc);
      lstrcpyA(szData, pvData);
      dwExpDataLen = ExpandEnvironmentStringsA(szData, pvData, *pcbData / sizeof(CHAR));
      if (dwExpDataLen > *pcbData) dwRet = ERROR_MORE_DATA;
      dwUnExpDataLen = max(nBytesToAlloc, dwExpDataLen);
      LocalFree(szData);
    }
  }
 
  /* Update the type and data size if the caller wanted them */
  if ( dwType == REG_EXPAND_SZ ) dwType = REG_SZ;
  if ( pwType ) *pwType = dwType;
  if ( pcbData ) *pcbData = dwUnExpDataLen;
  return dwRet;
}

Referenced by SHADD_get_policy(), SHGetValueA(), SHRegQueryValueExA(), test_SHCopyKey(), and test_SHQueryValueEx().

SHQueryValueExW()

DWORD WINAPI SHQueryValueExW	(	HKEY	hKey,
		LPCWSTR	lpszValue,
		LPDWORD	lpReserved,
		LPDWORD	pwType,
		LPVOID	pvData,
		LPDWORD	pcbData
	)

Definition at line 1503 of file reg.c.

{
  DWORD dwRet, dwType, dwUnExpDataLen = 0, dwExpDataLen;
 
  TRACE("(hkey=%p,%s,%p,%p,%p,%p=%d)\n", hKey, debugstr_w(lpszValue),
        lpReserved, pwType, pvData, pcbData, pcbData ? *pcbData : 0);
 
  if (pcbData) dwUnExpDataLen = *pcbData;
 
  dwRet = RegQueryValueExW(hKey, lpszValue, lpReserved, &dwType, pvData, &dwUnExpDataLen);
  if (dwRet!=ERROR_SUCCESS && dwRet!=ERROR_MORE_DATA)
      return dwRet;
 
  if (pcbData && (dwType == REG_EXPAND_SZ))
  {
    DWORD nBytesToAlloc;
 
    /* Expand type REG_EXPAND_SZ into REG_SZ */
    LPWSTR szData;
 
    /* If the caller didn't supply a buffer or the buffer is too small we have
     * to allocate our own
     */
    if ((!pvData) || (dwRet == ERROR_MORE_DATA) )
    {
      WCHAR cNull = '\0';
      nBytesToAlloc = dwUnExpDataLen;
 
      szData = LocalAlloc(LMEM_ZEROINIT, nBytesToAlloc);
      RegQueryValueExW (hKey, lpszValue, lpReserved, NULL, (LPBYTE)szData, &nBytesToAlloc);
      dwExpDataLen = ExpandEnvironmentStringsW(szData, &cNull, 1);
      dwUnExpDataLen = max(nBytesToAlloc, dwExpDataLen);
      LocalFree(szData);
    }
    else
    {
      nBytesToAlloc = (lstrlenW(pvData) + 1) * sizeof(WCHAR);
      szData = LocalAlloc(LMEM_ZEROINIT, nBytesToAlloc);
      lstrcpyW(szData, pvData);
      dwExpDataLen = ExpandEnvironmentStringsW(szData, pvData, *pcbData/sizeof(WCHAR) );
      if (dwExpDataLen > *pcbData) dwRet = ERROR_MORE_DATA;
      dwUnExpDataLen = max(nBytesToAlloc, dwExpDataLen);
      LocalFree(szData);
    }
  }
 
  /* Update the type and data size if the caller wanted them */
  if ( dwType == REG_EXPAND_SZ ) dwType = REG_SZ;
  if ( pwType ) *pwType = dwType;
  if ( pcbData ) *pcbData = dwUnExpDataLen;
  return dwRet;
}

Referenced by CFSExtractIcon_CreateInstance(), CQueryAssociations::GetValue(), IsOS(), read_advanced_key(), SH32_CoCreateInstance(), SHELL_ReadSingleUnreadMailCount(), SHGetValueW(), SHRegGetIntW(), SHRegQueryValueExW(), SKAllocValueW(), and SKGetValueW().

SHRegCloseUSKey()

LONG WINAPI SHRegCloseUSKey

(

HUSKEY

hUSKey

)

Definition at line 190 of file reg.c.

{
    LPSHUSKEY hKey = hUSKey;
    LONG ret = ERROR_SUCCESS;
 
    if (!hKey)
        return ERROR_INVALID_PARAMETER;
 
    if (hKey->HKCUkey)
        ret = RegCloseKey(hKey->HKCUkey);
    if (hKey->HKCUstart && hKey->HKCUstart != HKEY_CURRENT_USER)
        ret = RegCloseKey(hKey->HKCUstart);
    if (hKey->HKLMkey)
        ret = RegCloseKey(hKey->HKLMkey);
    if (hKey->HKLMstart && hKey->HKLMstart != HKEY_LOCAL_MACHINE)
        ret = RegCloseKey(hKey->HKLMstart);
 
    HeapFree(GetProcessHeap(), 0, hKey);
    return ret;
}

Referenced by SHRegGetUSValueA(), SHRegGetUSValueW(), SHRegOpenUSKeyW(), SHRegSetUSValueA(), and SHRegSetUSValueW().

SHRegCreateUSKeyA()

LONG WINAPI SHRegCreateUSKeyA	(	LPCSTR	path,
		REGSAM	samDesired,
		HUSKEY	relative_key,
		PHUSKEY	new_uskey,
		DWORD	flags
	)

Definition at line 217 of file reg.c.

{
    WCHAR *pathW;
    LONG ret;
 
    TRACE("(%s, 0x%08x, %p, %p, 0x%08x)\n", debugstr_a(path), samDesired, relative_key,
        new_uskey, flags);
 
    if (path)
    {
        INT len = MultiByteToWideChar(CP_ACP, 0, path, -1, NULL, 0);
        pathW = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
        if (!pathW)
            return ERROR_NOT_ENOUGH_MEMORY;
        MultiByteToWideChar(CP_ACP, 0, path, -1, pathW, len);
    }
    else
        pathW = NULL;
 
    ret = SHRegCreateUSKeyW(pathW, samDesired, relative_key, new_uskey, flags);
    HeapFree(GetProcessHeap(), 0, pathW);
    return ret;
}

SHRegCreateUSKeyW()

LONG WINAPI SHRegCreateUSKeyW	(	LPCWSTR	path,
		REGSAM	samDesired,
		HUSKEY	relative_key,
		PHUSKEY	new_uskey,
		DWORD	flags
	)

Definition at line 258 of file reg.c.

{
    LONG ret = ERROR_CALL_NOT_IMPLEMENTED;
    SHUSKEY *ret_key;
 
    TRACE("(%s, 0x%08x, %p, %p, 0x%08x)\n", debugstr_w(path), samDesired,
          relative_key, new_uskey, flags);
 
    if (!new_uskey) return ERROR_INVALID_PARAMETER;
 
    *new_uskey = NULL;
 
    if (flags & ~SHREGSET_FORCE_HKCU)
    {
        FIXME("unsupported flags 0x%08x\n", flags);
        return ERROR_SUCCESS;
    }
 
    ret_key = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*ret_key));
    lstrcpynW(ret_key->lpszPath, path, sizeof(ret_key->lpszPath)/sizeof(WCHAR));
 
    if (relative_key)
    {
        ret_key->HKCUstart = SHRegDuplicateHKey(REG_GetHKEYFromHUSKEY(relative_key, REG_HKCU));
        ret_key->HKLMstart = SHRegDuplicateHKey(REG_GetHKEYFromHUSKEY(relative_key, REG_HKLM));
    }
    else
    {
        ret_key->HKCUstart = HKEY_CURRENT_USER;
        ret_key->HKLMstart = HKEY_LOCAL_MACHINE;
    }
 
    if (flags & SHREGSET_FORCE_HKCU)
    {
        ret = RegCreateKeyExW(ret_key->HKCUstart, path, 0, NULL, 0, samDesired, NULL, &ret_key->HKCUkey, NULL);
        if (ret == ERROR_SUCCESS)
            *new_uskey = ret_key;
        else
            HeapFree(GetProcessHeap(), 0, ret_key);
    }
 
    return ret;
}

Referenced by SHRegCreateUSKeyA().

SHRegDeleteEmptyUSKeyA()

LONG WINAPI SHRegDeleteEmptyUSKeyA	(	HUSKEY	hUSKey,
		LPCSTR	pszValue,
		SHREGDEL_FLAGS	delRegFlags
	)

Definition at line 318 of file reg.c.

{
    FIXME("(%p, %s, 0x%08x) stub\n", hUSKey, debugstr_a(pszValue), delRegFlags);
    return ERROR_SUCCESS;
}

SHRegDeleteEmptyUSKeyW()

LONG WINAPI SHRegDeleteEmptyUSKeyW	(	HUSKEY	hUSKey,
		LPCWSTR	pszValue,
		SHREGDEL_FLAGS	delRegFlags
	)

Definition at line 329 of file reg.c.

{
    FIXME("(%p, %s, 0x%08x) stub\n", hUSKey, debugstr_w(pszValue), delRegFlags);
    return ERROR_SUCCESS;
}

SHRegDeleteUSValueA()

LONG WINAPI SHRegDeleteUSValueA	(	HUSKEY	hUSKey,
		LPCSTR	pszValue,
		SHREGDEL_FLAGS	delRegFlags
	)

Definition at line 350 of file reg.c.

{
    FIXME("(%p, %s, 0x%08x) stub\n", hUSKey, debugstr_a(pszValue), delRegFlags);
    return ERROR_SUCCESS;
}

SHRegDeleteUSValueW()

LONG WINAPI SHRegDeleteUSValueW	(	HUSKEY	hUSKey,
		LPCWSTR	pszValue,
		SHREGDEL_FLAGS	delRegFlags
	)

Definition at line 361 of file reg.c.

{
    FIXME("(%p, %s, 0x%08x) stub\n", hUSKey, debugstr_w(pszValue), delRegFlags);
    return ERROR_SUCCESS;
}

SHRegDuplicateHKey()

HKEY WINAPI SHRegDuplicateHKey

(

HKEY

hKey

)

Definition at line 2256 of file reg.c.

{
    HKEY newKey = 0;
 
    RegOpenKeyExA(hKey, 0, 0, MAXIMUM_ALLOWED, &newKey);
    TRACE("new key is %p\n", newKey);
    return newKey;
}

Referenced by CMruBase::InitData(), CDefaultContextMenu::Initialize(), SHRegCreateUSKeyW(), and SHRegOpenUSKeyW().

SHRegEnumUSKeyA()

LONG WINAPI SHRegEnumUSKeyA	(	HUSKEY	hUSKey,
		DWORD	dwIndex,
		LPSTR	pszName,
		LPDWORD	pcchValueNameLen,
		SHREGENUM_FLAGS	enumRegFlags
	)

Definition at line 920 of file reg.c.

{
    HKEY dokey;
 
    TRACE("(%p,%d,%p,%p(%d),%d)\n",
          hUSKey, dwIndex, pszName, pcchValueNameLen,
          *pcchValueNameLen, enumRegFlags);
 
    if (((enumRegFlags == SHREGENUM_HKCU) ||
         (enumRegFlags == SHREGENUM_DEFAULT)) &&
        (dokey = REG_GetHKEYFromHUSKEY(hUSKey,REG_HKCU))) {
        return RegEnumKeyExA(dokey, dwIndex, pszName, pcchValueNameLen,
                0, 0, 0, 0);
    }
 
    if (((enumRegFlags == SHREGENUM_HKLM) ||
         (enumRegFlags == SHREGENUM_DEFAULT)) &&
        (dokey = REG_GetHKEYFromHUSKEY(hUSKey,REG_HKLM))) {
        return RegEnumKeyExA(dokey, dwIndex, pszName, pcchValueNameLen,
                0, 0, 0, 0);
    }
    FIXME("no support for SHREGENUM_BOTH\n");
    return ERROR_INVALID_FUNCTION;
}

SHRegEnumUSKeyW()

LONG WINAPI SHRegEnumUSKeyW	(	HUSKEY	hUSKey,
		DWORD	dwIndex,
		LPWSTR	pszName,
		LPDWORD	pcchValueNameLen,
		SHREGENUM_FLAGS	enumRegFlags
	)

Definition at line 955 of file reg.c.

{
    HKEY dokey;
 
    TRACE("(%p,%d,%p,%p(%d),%d)\n",
          hUSKey, dwIndex, pszName, pcchValueNameLen,
          *pcchValueNameLen, enumRegFlags);
 
    if (((enumRegFlags == SHREGENUM_HKCU) ||
         (enumRegFlags == SHREGENUM_DEFAULT)) &&
        (dokey = REG_GetHKEYFromHUSKEY(hUSKey,REG_HKCU))) {
        return RegEnumKeyExW(dokey, dwIndex, pszName, pcchValueNameLen,
                0, 0, 0, 0);
    }
 
    if (((enumRegFlags == SHREGENUM_HKLM) ||
         (enumRegFlags == SHREGENUM_DEFAULT)) &&
        (dokey = REG_GetHKEYFromHUSKEY(hUSKey,REG_HKLM))) {
        return RegEnumKeyExW(dokey, dwIndex, pszName, pcchValueNameLen,
                0, 0, 0, 0);
    }
    FIXME("no support for SHREGENUM_BOTH\n");
    return ERROR_INVALID_FUNCTION;
}

SHRegEnumUSValueA()

LONG WINAPI SHRegEnumUSValueA	(	HUSKEY	hUSKey,
		DWORD	dwIndex,
		LPSTR	pszValueName,
		LPDWORD	pcchValueNameLen,
		LPDWORD	pdwType,
		LPVOID	pvData,
		LPDWORD	pcbData,
		SHREGENUM_FLAGS	enumRegFlags
	)

Definition at line 387 of file reg.c.

{
    HKEY dokey;
 
    TRACE("(%p, 0x%08x, %p, %p, %p, %p, %p, 0x%08x)\n", hUSKey, dwIndex,
          pszValueName, pcchValueNameLen, pdwType, pvData, pcbData, enumRegFlags);
 
    if (((enumRegFlags == SHREGENUM_HKCU) ||
         (enumRegFlags == SHREGENUM_DEFAULT)) &&
        (dokey = REG_GetHKEYFromHUSKEY(hUSKey,REG_HKCU))) {
        return RegEnumValueA(dokey, dwIndex, pszValueName, pcchValueNameLen,
                             NULL, pdwType, pvData, pcbData);
    }
 
    if (((enumRegFlags == SHREGENUM_HKLM) ||
         (enumRegFlags == SHREGENUM_DEFAULT)) &&
        (dokey = REG_GetHKEYFromHUSKEY(hUSKey,REG_HKLM))) {
        return RegEnumValueA(dokey, dwIndex, pszValueName, pcchValueNameLen,
                             NULL, pdwType, pvData, pcbData);
    }
    FIXME("no support for SHREGENUM_BOTH\n");
    return ERROR_INVALID_FUNCTION;
}

SHRegEnumUSValueW()

LONG WINAPI SHRegEnumUSValueW	(	HUSKEY	hUSKey,
		DWORD	dwIndex,
		LPWSTR	pszValueName,
		LPDWORD	pcchValueNameLen,
		LPDWORD	pdwType,
		LPVOID	pvData,
		LPDWORD	pcbData,
		SHREGENUM_FLAGS	enumRegFlags
	)

Definition at line 418 of file reg.c.

{
    HKEY dokey;
 
    TRACE("(%p, 0x%08x, %p, %p, %p, %p, %p, 0x%08x)\n", hUSKey, dwIndex,
          pszValueName, pcchValueNameLen, pdwType, pvData, pcbData, enumRegFlags);
 
    if (((enumRegFlags == SHREGENUM_HKCU) ||
         (enumRegFlags == SHREGENUM_DEFAULT)) &&
        (dokey = REG_GetHKEYFromHUSKEY(hUSKey,REG_HKCU))) {
        return RegEnumValueW(dokey, dwIndex, pszValueName, pcchValueNameLen,
                             NULL, pdwType, pvData, pcbData);
    }
 
    if (((enumRegFlags == SHREGENUM_HKLM) ||
         (enumRegFlags == SHREGENUM_DEFAULT)) &&
        (dokey = REG_GetHKEYFromHUSKEY(hUSKey,REG_HKLM))) {
        return RegEnumValueW(dokey, dwIndex, pszValueName, pcchValueNameLen,
                             NULL, pdwType, pvData, pcbData);
    }
    FIXME("no support for SHREGENUM_BOTH\n");
    return ERROR_INVALID_FUNCTION;
}

SHRegGetBoolUSValueA()

BOOL WINAPI SHRegGetBoolUSValueA	(	LPCSTR	pszSubKey,
		LPCSTR	pszValue,
		BOOL	fIgnoreHKCU,
		BOOL	fDefault
	)

Definition at line 714 of file reg.c.

{
    DWORD type, datalen, work;
    BOOL ret = fDefault;
    CHAR data[10];
 
    TRACE("key '%s', value '%s', %s\n",
          debugstr_a(pszSubKey), debugstr_a(pszValue),
          (fIgnoreHKCU) ? "Ignoring HKCU" : "Tries HKCU then HKLM");
 
    datalen = sizeof(data)-1;
    if (!SHRegGetUSValueA( pszSubKey, pszValue, &type,
                   data, &datalen,
                   fIgnoreHKCU, 0, 0)) {
        /* process returned data via type into bool */
        switch (type) {
        case REG_SZ:
        data[9] = '\0';     /* set end of string */
        if (lstrcmpiA(data, "YES") == 0) ret = TRUE;
        if (lstrcmpiA(data, "TRUE") == 0) ret = TRUE;
        if (lstrcmpiA(data, "NO") == 0) ret = FALSE;
        if (lstrcmpiA(data, "FALSE") == 0) ret = FALSE;
        break;
        case REG_DWORD:
        work = *(LPDWORD)data;
        ret = (work != 0);
        break;
        case REG_BINARY:
        if (datalen == 1) {
            ret = (data[0] != '\0');
            break;
        }
        default:
        FIXME("Unsupported registry data type %d\n", type);
        ret = FALSE;
        }
        TRACE("got value (type=%d), returning <%s>\n", type,
          (ret) ? "TRUE" : "FALSE");
    }
    else {
        ret = fDefault;
        TRACE("returning default data <%s>\n",
          (ret) ? "TRUE" : "FALSE");
    }
    return ret;
}

SHRegGetBoolUSValueW()

BOOL WINAPI SHRegGetBoolUSValueW	(	LPCWSTR	pszSubKey,
		LPCWSTR	pszValue,
		BOOL	fIgnoreHKCU,
		BOOL	fDefault
	)

Definition at line 770 of file reg.c.

{
    static const WCHAR wYES[]=  {'Y','E','S','\0'};
    static const WCHAR wTRUE[]= {'T','R','U','E','\0'};
    static const WCHAR wNO[]=   {'N','O','\0'};
    static const WCHAR wFALSE[]={'F','A','L','S','E','\0'};
    DWORD type, datalen, work;
    BOOL ret = fDefault;
    WCHAR data[10];
 
    TRACE("key '%s', value '%s', %s\n",
          debugstr_w(pszSubKey), debugstr_w(pszValue),
          (fIgnoreHKCU) ? "Ignoring HKCU" : "Tries HKCU then HKLM");
 
    datalen = (sizeof(data)-1) * sizeof(WCHAR);
    if (!SHRegGetUSValueW( pszSubKey, pszValue, &type,
                   data, &datalen,
                   fIgnoreHKCU, 0, 0)) {
        /* process returned data via type into bool */
        switch (type) {
        case REG_SZ:
        data[9] = '\0';     /* set end of string */
        if (lstrcmpiW(data, wYES)==0 || lstrcmpiW(data, wTRUE)==0)
            ret = TRUE;
        else if (lstrcmpiW(data, wNO)==0 || lstrcmpiW(data, wFALSE)==0)
            ret = FALSE;
        break;
        case REG_DWORD:
        work = *(LPDWORD)data;
        ret = (work != 0);
        break;
        case REG_BINARY:
        if (datalen == 1) {
            ret = (data[0] != '\0');
            break;
        }
        default:
        FIXME("Unsupported registry data type %d\n", type);
        ret = FALSE;
        }
        TRACE("got value (type=%d), returning <%s>\n", type,
          (ret) ? "TRUE" : "FALSE");
    }
    else {
        ret = fDefault;
        TRACE("returning default data <%s>\n",
          (ret) ? "TRUE" : "FALSE");
    }
    return ret;
}

SHRegGetCLSIDKeyA()

HRESULT WINAPI SHRegGetCLSIDKeyA	(	REFGUID	guid,
		LPCSTR	lpszValue,
		BOOL	bUseHKCU,
		BOOL	bCreate,
		PHKEY	phKey
	)

Definition at line 2449 of file reg.c.

{
  WCHAR szValue[MAX_PATH];
 
  if (lpszValue)
    MultiByteToWideChar(CP_ACP, 0, lpszValue, -1, szValue, sizeof(szValue)/sizeof(WCHAR));
 
  return SHRegGetCLSIDKeyW(guid, lpszValue ? szValue : NULL, bUseHKCU, bCreate, phKey);
}

SHRegGetCLSIDKeyW()

HRESULT WINAPI SHRegGetCLSIDKeyW	(	REFGUID	guid,
		LPCWSTR	lpszValue,
		BOOL	bUseHKCU,
		BOOL	bCreate,
		PHKEY	phKey
	)

Definition at line 2464 of file reg.c.

{
#ifndef __REACTOS__
  static const WCHAR szClassIdKey[] = { 'S','o','f','t','w','a','r','e','\\',
    'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\',
    'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
    'E','x','p','l','o','r','e','r','\\','C','L','S','I','D','\\' };
#endif
#define szClassIdKeyLen (sizeof(szClassIdKey)/sizeof(WCHAR))
  WCHAR szKey[MAX_PATH];
  DWORD dwRet;
  HKEY hkey;
 
  /* Create the key string */
#ifdef __REACTOS__
  // https://www.geoffchappell.com/studies/windows/shell/shlwapi/api/reg/reggetclsidkey.htm
  WCHAR* ptr;
 
  wcscpy(szKey, bUseHKCU ? L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\CLSID\\" : L"CLSID\\");
  ptr = szKey + wcslen(szKey);
  SHStringFromGUIDW(guid, ptr, 39); /* Append guid */
  if (lpszValue)
  {
      ptr = szKey + wcslen(szKey);
      wcscat(ptr, L"\\");
      wcscat(++ptr, lpszValue);
  }
#else
  memcpy(szKey, szClassIdKey, sizeof(szClassIdKey));
  SHStringFromGUIDW(guid, szKey + szClassIdKeyLen, 39); /* Append guid */
 
  if(lpszValue)
  {
    szKey[szClassIdKeyLen + 39] = '\\';
    strcpyW(szKey + szClassIdKeyLen + 40, lpszValue); /* Append value name */
  }
#endif
 
  hkey = bUseHKCU ? HKEY_CURRENT_USER : HKEY_CLASSES_ROOT;
 
  if(bCreate)
    dwRet = RegCreateKeyW(hkey, szKey, phKey);
  else
    dwRet = RegOpenKeyExW(hkey, szKey, 0, KEY_READ, phKey);
 
  return dwRet ? HRESULT_FROM_WIN32(dwRet) : S_OK;
}

Referenced by CFileSysEnum::_AddFindResult(), SHELL32_GetFSItemAttributes(), and SHRegGetCLSIDKeyA().

SHRegGetIntW()

int WINAPI SHRegGetIntW	(	HKEY	hKey,
		LPCWSTR	lpszValue,
		int	iDefault
	)

Definition at line 2416 of file reg.c.

{
  TRACE("(%p,%s,%d)\n", hKey, debugstr_w(lpszValue), iDefault);
 
  if (hKey)
  {
    WCHAR szBuff[32];
    DWORD dwSize = sizeof(szBuff);
    szBuff[0] = '\0';
    SHQueryValueExW(hKey, lpszValue, 0, 0, szBuff, &dwSize);
 
    if(*szBuff >= '0' && *szBuff <= '9')
      return StrToIntW(szBuff);
  }
  return iDefault;
}

Referenced by LoadCurrentScheme(), and LoadSchemeFromReg().

SHRegGetPathA()

DWORD WINAPI SHRegGetPathA	(	HKEY	hKey,
		LPCSTR	lpszSubKey,
		LPCSTR	lpszValue,
		LPSTR	lpszPath,
		DWORD	dwFlags
	)

Definition at line 1109 of file reg.c.

{
  DWORD dwSize = MAX_PATH;
 
  TRACE("(hkey=%p,%s,%s,%p,%d)\n", hKey, debugstr_a(lpszSubKey),
        debugstr_a(lpszValue), lpszPath, dwFlags);
 
  return SHGetValueA(hKey, lpszSubKey, lpszValue, 0, lpszPath, &dwSize);
}

SHRegGetPathW()

DWORD WINAPI SHRegGetPathW	(	HKEY	hKey,
		LPCWSTR	lpszSubKey,
		LPCWSTR	lpszValue,
		LPWSTR	lpszPath,
		DWORD	dwFlags
	)

Definition at line 1125 of file reg.c.

{
  DWORD dwSize = MAX_PATH;
 
  TRACE("(hkey=%p,%s,%s,%p,%d)\n", hKey, debugstr_w(lpszSubKey),
        debugstr_w(lpszValue), lpszPath, dwFlags);
 
  return SHGetValueW(hKey, lpszSubKey, lpszValue, 0, lpszPath, &dwSize);
}

SHRegGetUSValueA()

LONG WINAPI SHRegGetUSValueA	(	LPCSTR	pSubKey,
		LPCSTR	pValue,
		LPDWORD	pwType,
		LPVOID	pvData,
		LPDWORD	pcbData,
		BOOL	flagIgnoreHKCU,
		LPVOID	pDefaultData,
		DWORD	wDefaultDataSize
	)

Definition at line 561 of file reg.c.

{
    HUSKEY myhuskey;
    LONG ret;
 
    if (!pvData || !pcbData) return ERROR_INVALID_FUNCTION; /* FIXME:wrong*/
    TRACE("key '%s', value '%s', datalen %d,  %s\n",
          debugstr_a(pSubKey), debugstr_a(pValue), *pcbData,
          (flagIgnoreHKCU) ? "Ignoring HKCU" : "Tries HKCU then HKLM");
 
    ret = SHRegOpenUSKeyA(pSubKey, 0x1, 0, &myhuskey, flagIgnoreHKCU);
    if (ret == ERROR_SUCCESS) {
        ret = SHRegQueryUSValueA(myhuskey, pValue, pwType, pvData,
                     pcbData, flagIgnoreHKCU, pDefaultData,
                     wDefaultDataSize);
        SHRegCloseUSKey(myhuskey);
    }
    return ret;
}

Referenced by SHRegGetBoolUSValueA().

SHRegGetUSValueW()

LONG WINAPI SHRegGetUSValueW	(	LPCWSTR	pSubKey,
		LPCWSTR	pValue,
		LPDWORD	pwType,
		LPVOID	pvData,
		LPDWORD	pcbData,
		BOOL	flagIgnoreHKCU,
		LPVOID	pDefaultData,
		DWORD	wDefaultDataSize
	)

Definition at line 594 of file reg.c.

{
    HUSKEY myhuskey;
    LONG ret;
 
    if (!pvData || !pcbData) return ERROR_INVALID_FUNCTION; /* FIXME:wrong*/
    TRACE("key '%s', value '%s', datalen %d,  %s\n",
          debugstr_w(pSubKey), debugstr_w(pValue), *pcbData,
          (flagIgnoreHKCU) ? "Ignoring HKCU" : "Tries HKCU then HKLM");
 
    ret = SHRegOpenUSKeyW(pSubKey, 0x1, 0, &myhuskey, flagIgnoreHKCU);
    if (ret == ERROR_SUCCESS) {
        ret = SHRegQueryUSValueW(myhuskey, pValue, pwType, pvData,
                     pcbData, flagIgnoreHKCU, pDefaultData,
                     wDefaultDataSize);
        SHRegCloseUSKey(myhuskey);
    }
    return ret;
}

Referenced by SHRegGetBoolUSValueW().

SHRegisterValidateTemplate()

HRESULT WINAPI SHRegisterValidateTemplate	(	LPCWSTR	filename,
		BOOL	unknown
	)

Definition at line 2531 of file reg.c.

{
/* static const WCHAR szTemplateKey[] = { 'S','o','f','t','w','a','r','e','\\',
 *  'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\',
 *  'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
 *  'E','x','p','l','o','r','e','r','\\',
 *  'T','e','m','p','l','a','t','e','R','e','g','i','s','t','r','y',0 };
 */
  FIXME("stub: %s, %08x\n", debugstr_w(filename), unknown);
 
  return S_OK;
}

SHRegOpenUSKeyA()

LONG WINAPI SHRegOpenUSKeyA	(	LPCSTR	Path,
		REGSAM	AccessType,
		HUSKEY	hRelativeUSKey,
		PHUSKEY	phNewUSKey,
		BOOL	fIgnoreHKCU
	)

Definition at line 106 of file reg.c.

{
    WCHAR szPath[MAX_PATH];
 
    if (Path)
      MultiByteToWideChar(CP_ACP, 0, Path, -1, szPath, MAX_PATH);
 
    return SHRegOpenUSKeyW(Path ? szPath : NULL, AccessType, hRelativeUSKey,
                           phNewUSKey, fIgnoreHKCU);
}

Referenced by SHRegGetUSValueA(), and SHRegSetUSValueA().

SHRegOpenUSKeyW()

LONG WINAPI SHRegOpenUSKeyW	(	LPCWSTR	Path,
		REGSAM	AccessType,
		HUSKEY	hRelativeUSKey,
		PHUSKEY	phNewUSKey,
		BOOL	fIgnoreHKCU
	)

Definition at line 123 of file reg.c.

{
    LONG ret2, ret1 = ~ERROR_SUCCESS;
    LPSHUSKEY hKey;
 
    TRACE("(%s,0x%x,%p,%p,%d)\n", debugstr_w(Path),(LONG)AccessType,
          hRelativeUSKey, phNewUSKey, fIgnoreHKCU);
 
    if (phNewUSKey)
        *phNewUSKey = NULL;
 
    /* Create internal HUSKEY */
    hKey = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*hKey));
    lstrcpynW(hKey->lpszPath, Path, sizeof(hKey->lpszPath)/sizeof(WCHAR));
 
    if (hRelativeUSKey)
    {
        hKey->HKCUstart = SHRegDuplicateHKey(REG_GetHKEYFromHUSKEY(hRelativeUSKey, REG_HKCU));
        hKey->HKLMstart = SHRegDuplicateHKey(REG_GetHKEYFromHUSKEY(hRelativeUSKey, REG_HKLM));
 
        /* FIXME: if either of these keys is NULL, create the start key from
         *        the relative keys start+path
         */
    }
    else
    {
        hKey->HKCUstart = HKEY_CURRENT_USER;
        hKey->HKLMstart = HKEY_LOCAL_MACHINE;
    }
 
    if (!fIgnoreHKCU)
    {
        ret1 = RegOpenKeyExW(hKey->HKCUstart, hKey->lpszPath, 0, AccessType, &hKey->HKCUkey);
        if (ret1)
            hKey->HKCUkey = 0;
    }
 
    ret2 = RegOpenKeyExW(hKey->HKLMstart, hKey->lpszPath, 0, AccessType, &hKey->HKLMkey);
    if (ret2)
        hKey->HKLMkey = 0;
 
    if (ret1 || ret2)
        TRACE("one or more opens failed: HKCU=%d HKLM=%d\n", ret1, ret2);
 
    if (ret1 && ret2)
    {
        /* Neither open succeeded: fail */
        SHRegCloseUSKey(hKey);
        return ret2;
    }
 
    TRACE("HUSKEY=%p\n", hKey);
    if (phNewUSKey)
        *phNewUSKey = hKey;
    return ERROR_SUCCESS;
}

Referenced by SHRegGetUSValueW(), SHRegOpenUSKeyA(), and SHRegSetUSValueW().

SHRegQueryInfoUSKeyA()

LONG WINAPI SHRegQueryInfoUSKeyA	(	HUSKEY	hUSKey,
		LPDWORD	pcSubKeys,
		LPDWORD	pcchMaxSubKeyLen,
		LPDWORD	pcValues,
		LPDWORD	pcchMaxValueNameLen,
		SHREGENUM_FLAGS	enumRegFlags
	)

Definition at line 834 of file reg.c.

{
    HKEY dokey;
    LONG ret;
 
    TRACE("(%p,%p,%p,%p,%p,%d)\n",
          hUSKey,pcSubKeys,pcchMaxSubKeyLen,pcValues,
          pcchMaxValueNameLen,enumRegFlags);
 
    /* if user wants HKCU, and it exists, then try it */
    if (((enumRegFlags == SHREGENUM_HKCU) ||
         (enumRegFlags == SHREGENUM_DEFAULT)) &&
        (dokey = REG_GetHKEYFromHUSKEY(hUSKey,REG_HKCU))) {
        ret = RegQueryInfoKeyA(dokey, 0, 0, 0,
                   pcSubKeys, pcchMaxSubKeyLen, 0,
                   pcValues, pcchMaxValueNameLen, 0, 0, 0);
        if ((ret == ERROR_SUCCESS) ||
        (enumRegFlags == SHREGENUM_HKCU))
        return ret;
    }
    if (((enumRegFlags == SHREGENUM_HKLM) ||
         (enumRegFlags == SHREGENUM_DEFAULT)) &&
        (dokey = REG_GetHKEYFromHUSKEY(hUSKey,REG_HKLM))) {
        return RegQueryInfoKeyA(dokey, 0, 0, 0,
                    pcSubKeys, pcchMaxSubKeyLen, 0,
                    pcValues, pcchMaxValueNameLen, 0, 0, 0);
    }
    return ERROR_INVALID_FUNCTION;
}

SHRegQueryInfoUSKeyW()

LONG WINAPI SHRegQueryInfoUSKeyW	(	HUSKEY	hUSKey,
		LPDWORD	pcSubKeys,
		LPDWORD	pcchMaxSubKeyLen,
		LPDWORD	pcValues,
		LPDWORD	pcchMaxValueNameLen,
		SHREGENUM_FLAGS	enumRegFlags
	)

Definition at line 875 of file reg.c.

{
    HKEY dokey;
    LONG ret;
 
    TRACE("(%p,%p,%p,%p,%p,%d)\n",
          hUSKey,pcSubKeys,pcchMaxSubKeyLen,pcValues,
          pcchMaxValueNameLen,enumRegFlags);
 
    /* if user wants HKCU, and it exists, then try it */
    if (((enumRegFlags == SHREGENUM_HKCU) ||
         (enumRegFlags == SHREGENUM_DEFAULT)) &&
        (dokey = REG_GetHKEYFromHUSKEY(hUSKey,REG_HKCU))) {
        ret = RegQueryInfoKeyW(dokey, 0, 0, 0,
                   pcSubKeys, pcchMaxSubKeyLen, 0,
                   pcValues, pcchMaxValueNameLen, 0, 0, 0);
        if ((ret == ERROR_SUCCESS) ||
        (enumRegFlags == SHREGENUM_HKCU))
        return ret;
    }
    if (((enumRegFlags == SHREGENUM_HKLM) ||
         (enumRegFlags == SHREGENUM_DEFAULT)) &&
        (dokey = REG_GetHKEYFromHUSKEY(hUSKey,REG_HKLM))) {
        return RegQueryInfoKeyW(dokey, 0, 0, 0,
                    pcSubKeys, pcchMaxSubKeyLen, 0,
                    pcValues, pcchMaxValueNameLen, 0, 0, 0);
    }
    return ERROR_INVALID_FUNCTION;
}

SHRegQueryUSValueA()

LONG WINAPI SHRegQueryUSValueA	(	HUSKEY	hUSKey,
		LPCSTR	pszValue,
		LPDWORD	pdwType,
		LPVOID	pvData,
		LPDWORD	pcbData,
		BOOL	fIgnoreHKCU,
		LPVOID	pvDefaultData,
		DWORD	dwDefaultDataSize
	)

Definition at line 453 of file reg.c.

{
    LONG ret = ~ERROR_SUCCESS;
    LONG i, maxmove;
    HKEY dokey;
    CHAR *src, *dst;
 
    /* if user wants HKCU, and it exists, then try it */
    if (!fIgnoreHKCU && (dokey = REG_GetHKEYFromHUSKEY(hUSKey,REG_HKCU))) {
        ret = RegQueryValueExA(dokey,
                   pszValue, 0, pdwType, pvData, pcbData);
        TRACE("HKCU RegQueryValue returned %08x\n", ret);
    }
 
    /* if HKCU did not work and HKLM exists, then try it */
    if ((ret != ERROR_SUCCESS) &&
        (dokey = REG_GetHKEYFromHUSKEY(hUSKey,REG_HKLM))) {
        ret = RegQueryValueExA(dokey,
                   pszValue, 0, pdwType, pvData, pcbData);
        TRACE("HKLM RegQueryValue returned %08x\n", ret);
    }
 
    /* if neither worked, and default data exists, then use it */
    if (ret != ERROR_SUCCESS) {
        if (pvDefaultData && (dwDefaultDataSize != 0)) {
        maxmove = (dwDefaultDataSize >= *pcbData) ? *pcbData : dwDefaultDataSize;
                src = pvDefaultData;
                dst = pvData;
        for(i=0; i<maxmove; i++) *dst++ = *src++;
        *pcbData = maxmove;
        TRACE("setting default data\n");
        ret = ERROR_SUCCESS;
        }
    }
    return ret;
}

Referenced by SHRegGetUSValueA().

SHRegQueryUSValueW()

LONG WINAPI SHRegQueryUSValueW	(	HUSKEY	hUSKey,
		LPCWSTR	pszValue,
		LPDWORD	pdwType,
		LPVOID	pvData,
		LPDWORD	pcbData,
		BOOL	fIgnoreHKCU,
		LPVOID	pvDefaultData,
		DWORD	dwDefaultDataSize
	)

Definition at line 504 of file reg.c.

{
    LONG ret = ~ERROR_SUCCESS;
    LONG i, maxmove;
    HKEY dokey;
    CHAR *src, *dst;
 
    /* if user wants HKCU, and it exists, then try it */
    if (!fIgnoreHKCU && (dokey = REG_GetHKEYFromHUSKEY(hUSKey,REG_HKCU))) {
        ret = RegQueryValueExW(dokey,
                   pszValue, 0, pdwType, pvData, pcbData);
        TRACE("HKCU RegQueryValue returned %08x\n", ret);
    }
 
    /* if HKCU did not work and HKLM exists, then try it */
    if ((ret != ERROR_SUCCESS) &&
        (dokey = REG_GetHKEYFromHUSKEY(hUSKey,REG_HKLM))) {
        ret = RegQueryValueExW(dokey,
                   pszValue, 0, pdwType, pvData, pcbData);
        TRACE("HKLM RegQueryValue returned %08x\n", ret);
    }
 
    /* if neither worked, and default data exists, then use it */
    if (ret != ERROR_SUCCESS) {
        if (pvDefaultData && (dwDefaultDataSize != 0)) {
        maxmove = (dwDefaultDataSize >= *pcbData) ? *pcbData : dwDefaultDataSize;
                src = pvDefaultData;
                dst = pvData;
        for(i=0; i<maxmove; i++) *dst++ = *src++;
        *pcbData = maxmove;
        TRACE("setting default data\n");
        ret = ERROR_SUCCESS;
        }
    }
    return ret;
}

Referenced by SHRegGetUSValueW().

SHRegSetPathA()

DWORD WINAPI SHRegSetPathA	(	HKEY	hKey,
		LPCSTR	lpszSubKey,
		LPCSTR	lpszValue,
		LPCSTR	lpszPath,
		DWORD	dwFlags
	)

Definition at line 1153 of file reg.c.

{
  char szBuff[MAX_PATH];
#ifdef __REACTOS__
  DWORD dwType;
  LPCSTR pszData;
  INT cch;
 
  UNREFERENCED_PARAMETER(dwFlags);
 
  if (PathUnExpandEnvStringsA(lpszPath, szBuff, _countof(szBuff)))
  {
    dwType  = REG_EXPAND_SZ;
    pszData = szBuff;
  }
  else
  {
    dwType  = REG_SZ;
    pszData = lpszPath;
  }
 
  cch = lstrlenA(pszData);
  return SHSetValueA(hKey, lpszSubKey, lpszValue, dwType, pszData, (cch + 1) * sizeof(CHAR));
#else
  FIXME("(hkey=%p,%s,%s,%p,%d) - semi-stub\n",hKey, debugstr_a(lpszSubKey),
        debugstr_a(lpszValue), lpszPath, dwFlags);
 
  lstrcpyA(szBuff, lpszPath);
 
  /* FIXME: PathUnExpandEnvStringsA(szBuff); */
 
  return SHSetValueA(hKey,lpszSubKey, lpszValue, REG_SZ, szBuff,
                     lstrlenA(szBuff));
#endif
}

SHRegSetPathW()

DWORD WINAPI SHRegSetPathW	(	HKEY	hKey,
		LPCWSTR	lpszSubKey,
		LPCWSTR	lpszValue,
		LPCWSTR	lpszPath,
		DWORD	dwFlags
	)

Definition at line 1195 of file reg.c.

{
  WCHAR szBuff[MAX_PATH];
#ifdef __REACTOS__
  DWORD dwType;
  LPCWSTR pszData;
  INT cch;
 
  UNREFERENCED_PARAMETER(dwFlags);
 
  if (PathUnExpandEnvStringsW(lpszPath, szBuff, _countof(szBuff)))
  {
    dwType  = REG_EXPAND_SZ;
    pszData = szBuff;
  }
  else
  {
    dwType  = REG_SZ;
    pszData = lpszPath;
  }
 
  cch = lstrlenW(pszData);
  return SHSetValueW(hKey, lpszSubKey, lpszValue, dwType, pszData, (cch + 1) * sizeof(WCHAR));
#else
  FIXME("(hkey=%p,%s,%s,%p,%d) - semi-stub\n",hKey, debugstr_w(lpszSubKey),
        debugstr_w(lpszValue), lpszPath, dwFlags);
 
  lstrcpyW(szBuff, lpszPath);
 
  /* FIXME: PathUnExpandEnvStringsW(szBuff); */
 
  return SHSetValueW(hKey,lpszSubKey, lpszValue, REG_SZ, szBuff,
                     lstrlenW(szBuff));
#endif
}

SHRegSetUSValueA()

LONG WINAPI SHRegSetUSValueA	(	LPCSTR	pszSubKey,
		LPCSTR	pszValue,
		DWORD	dwType,
		LPVOID	pvData,
		DWORD	cbData,
		DWORD	dwFlags
	)

Definition at line 643 of file reg.c.

{
  BOOL ignoreHKCU = TRUE;
  HUSKEY hkey;
  LONG ret;
 
  TRACE("(%s,%s,%d,%p,%d,0x%08x\n", debugstr_a(pszSubKey), debugstr_a(pszValue),
        dwType, pvData, cbData, dwFlags);
 
  if (!pvData)
    return ERROR_INVALID_FUNCTION;
 
  if (dwFlags & SHREGSET_HKCU || dwFlags & SHREGSET_FORCE_HKCU)
    ignoreHKCU = FALSE;
 
  ret = SHRegOpenUSKeyA(pszSubKey, KEY_ALL_ACCESS, 0, &hkey, ignoreHKCU);
  if (ret == ERROR_SUCCESS)
  {
    ret = SHRegWriteUSValueA(hkey, pszValue, dwType, pvData, cbData, dwFlags);
    SHRegCloseUSKey(hkey);
  }
  return ret;
}

SHRegSetUSValueW()

LONG WINAPI SHRegSetUSValueW	(	LPCWSTR	pszSubKey,
		LPCWSTR	pszValue,
		DWORD	dwType,
		LPVOID	pvData,
		DWORD	cbData,
		DWORD	dwFlags
	)

Definition at line 673 of file reg.c.

{
  BOOL ignoreHKCU = TRUE;
  HUSKEY hkey;
  LONG ret;
 
  TRACE("(%s,%s,%d,%p,%d,0x%08x\n", debugstr_w(pszSubKey), debugstr_w(pszValue),
        dwType, pvData, cbData, dwFlags);
 
  if (!pvData)
    return ERROR_INVALID_FUNCTION;
 
  if (dwFlags & SHREGSET_HKCU || dwFlags & SHREGSET_FORCE_HKCU)
    ignoreHKCU = FALSE;
 
  ret = SHRegOpenUSKeyW(pszSubKey, KEY_ALL_ACCESS, 0, &hkey, ignoreHKCU);
  if (ret == ERROR_SUCCESS)
  {
    ret = SHRegWriteUSValueW(hkey, pszValue, dwType, pvData, cbData, dwFlags);
    SHRegCloseUSKey(hkey);
  }
  return ret;
}

SHRegWriteUSValueA()

LONG WINAPI SHRegWriteUSValueA	(	HUSKEY	hUSKey,
		LPCSTR	pszValue,
		DWORD	dwType,
		LPVOID	pvData,
		DWORD	cbData,
		DWORD	dwFlags
	)

Definition at line 1007 of file reg.c.

{
    WCHAR szValue[MAX_PATH];
 
    if (pszValue)
      MultiByteToWideChar(CP_ACP, 0, pszValue, -1, szValue, MAX_PATH);
 
    return SHRegWriteUSValueW(hUSKey, pszValue ? szValue : NULL, dwType,
                               pvData, cbData, dwFlags);
}

Referenced by SHRegSetUSValueA().

SHRegWriteUSValueW()

LONG WINAPI SHRegWriteUSValueW	(	HUSKEY	hUSKey,
		LPCWSTR	pszValue,
		DWORD	dwType,
		LPVOID	pvData,
		DWORD	cbData,
		DWORD	dwFlags
	)

Definition at line 1024 of file reg.c.

{
    DWORD dummy;
    LPSHUSKEY hKey = hUSKey;
    LONG ret = ERROR_SUCCESS;
 
    TRACE("(%p,%s,%d,%p,%d,%d)\n", hUSKey, debugstr_w(pszValue),
          dwType, pvData, cbData, dwFlags);
 
    if (!hUSKey || IsBadWritePtr(hUSKey, sizeof(SHUSKEY)) ||
        !(dwFlags & (SHREGSET_FORCE_HKCU|SHREGSET_FORCE_HKLM)))
        return ERROR_INVALID_PARAMETER;
 
    if (dwFlags & (SHREGSET_FORCE_HKCU|SHREGSET_HKCU))
    {
        if (!hKey->HKCUkey)
        {
            /* Create the key */
            ret = RegCreateKeyW(hKey->HKCUstart, hKey->lpszPath, &hKey->HKCUkey);
            TRACE("Creating HKCU key, ret = %d\n", ret);
            if (ret && (dwFlags & (SHREGSET_FORCE_HKCU)))
            {
                hKey->HKCUkey = 0;
                return ret;
            }
        }
 
        if (!ret)
        {
            if ((dwFlags & SHREGSET_FORCE_HKCU) ||
                RegQueryValueExW(hKey->HKCUkey, pszValue, NULL, NULL, NULL, &dummy))
            {
                /* Doesn't exist or we are forcing: Write value */
                ret = RegSetValueExW(hKey->HKCUkey, pszValue, 0, dwType, pvData, cbData);
                TRACE("Writing HKCU value, ret = %d\n", ret);
            }
        }
    }
 
    if (dwFlags & (SHREGSET_FORCE_HKLM|SHREGSET_HKLM))
    {
        if (!hKey->HKLMkey)
        {
            /* Create the key */
            ret = RegCreateKeyW(hKey->HKLMstart, hKey->lpszPath, &hKey->HKLMkey);
            TRACE("Creating HKLM key, ret = %d\n", ret);
            if (ret && (dwFlags & (SHREGSET_FORCE_HKLM)))
            {
                hKey->HKLMkey = 0;
                return ret;
            }
        }
 
        if (!ret)
        {
            if ((dwFlags & SHREGSET_FORCE_HKLM) ||
                RegQueryValueExW(hKey->HKLMkey, pszValue, NULL, NULL, NULL, &dummy))
            {
                /* Doesn't exist or we are forcing: Write value */
                ret = RegSetValueExW(hKey->HKLMkey, pszValue, 0, dwType, pvData, cbData);
                TRACE("Writing HKLM value, ret = %d\n", ret);
            }
        }
    }
 
    return ret;
}

Referenced by SHRegSetUSValueW(), and SHRegWriteUSValueA().

SHSetValueA()

DWORD WINAPI SHSetValueA	(	HKEY	hKey,
		LPCSTR	lpszSubKey,
		LPCSTR	lpszValue,
		DWORD	dwType,
		LPCVOID	pvData,
		DWORD	cbData
	)

Definition at line 1320 of file reg.c.

{
  DWORD dwRet = ERROR_SUCCESS, dwDummy;
  HKEY  hSubKey;
 
  TRACE("(hkey=%p,%s,%s,%d,%p,%d)\n", hKey, debugstr_a(lpszSubKey),
          debugstr_a(lpszValue), dwType, pvData, cbData);
 
  if (lpszSubKey && *lpszSubKey)
    dwRet = RegCreateKeyExA(hKey, lpszSubKey, 0, NULL,
                            0, KEY_SET_VALUE, NULL, &hSubKey, &dwDummy);
  else
    hSubKey = hKey;
  if (!dwRet)
  {
    dwRet = RegSetValueExA(hSubKey, lpszValue, 0, dwType, pvData, cbData);
    if (hSubKey != hKey)
      RegCloseKey(hSubKey);
  }
  return dwRet;
}

Referenced by RegisterExtensionForMIMETypeA(), RegisterMIMETypeForExtensionA(), and SHRegSetPathA().

SHSetValueW()

DWORD WINAPI SHSetValueW	(	HKEY	hKey,
		LPCWSTR	lpszSubKey,
		LPCWSTR	lpszValue,
		DWORD	dwType,
		LPCVOID	pvData,
		DWORD	cbData
	)

Definition at line 1348 of file reg.c.

{
  DWORD dwRet = ERROR_SUCCESS, dwDummy;
  HKEY  hSubKey;
 
  TRACE("(hkey=%p,%s,%s,%d,%p,%d)\n", hKey, debugstr_w(lpszSubKey),
        debugstr_w(lpszValue), dwType, pvData, cbData);
 
  if (lpszSubKey && *lpszSubKey)
    dwRet = RegCreateKeyExW(hKey, lpszSubKey, 0, NULL,
                            0, KEY_SET_VALUE, NULL, &hSubKey, &dwDummy);
  else
    hSubKey = hKey;
  if (!dwRet)
  {
    dwRet = RegSetValueExW(hSubKey, lpszValue, 0, dwType, pvData, cbData);
    if (hSubKey != hKey)
      RegCloseKey(hSubKey);
  }
  return dwRet;
}

Referenced by CMruBase::_AddItem(), CDesktopUpgradePropertyBag::_MarkAsUpgraded(), CMruPidlList::_SaveNodeSlots(), CMruShortList::_SaveSlots(), CMruLongList::_SaveSlots(), CRegPropertyBag::_WriteStream(), ApplyScheme(), CRegTreeOptions::GetSetState(), InitializeServerAdminUI(), MRUList_DataList(), RegisterExtensionForMIMETypeW(), RegisterMIMETypeForExtensionW(), TaskbarSettings::Save(), CGlobalFolderSettings::Save(), CRegFolder::SetNameOf(), CMruNode::SetNodeSlot(), SetUnreadMailInfo(), SHCopyKeyW(), SHELL32_WriteRegShellState(), SHELL_CacheComputerDescription(), SHGetSetSettings(), SHRegSetPathW(), and CRegPropertyBag::Write().

SHStringFromGUIDW()

INT WINAPI SHStringFromGUIDW	(	REFGUID	guid,
		LPWSTR	lpszDest,
		INT	cchMax
	)

Definition at line 661 of file ordinal.c.

{
  WCHAR xguid[40];
  INT iLen;
  static const WCHAR wszFormat[] = {'{','%','0','8','l','X','-','%','0','4','X','-','%','0','4','X','-',
      '%','0','2','X','%','0','2','X','-','%','0','2','X','%','0','2','X','%','0','2','X','%','0','2',
      'X','%','0','2','X','%','0','2','X','}',0};
 
  TRACE("(%s,%p,%d)\n", debugstr_guid(guid), lpszDest, cchMax);
 
  sprintfW(xguid, wszFormat, guid->Data1, guid->Data2, guid->Data3,
          guid->Data4[0], guid->Data4[1], guid->Data4[2], guid->Data4[3],
          guid->Data4[4], guid->Data4[5], guid->Data4[6], guid->Data4[7]);
 
  iLen = strlenW(xguid) + 1;
 
  if (iLen > cchMax)
    return 0;
  memcpy(lpszDest, xguid, iLen*sizeof(WCHAR));
  return iLen;
}

Referenced by SHRegGetCLSIDKeyW().

UnregisterExtensionForMIMETypeA()

BOOL WINAPI UnregisterExtensionForMIMETypeA

(

LPCSTR

lpszType

)

Definition at line 2206 of file reg.c.

{
  char szKey[MAX_PATH];
 
  TRACE("(%s)\n", debugstr_a(lpszType));
 
  if (!GetMIMETypeSubKeyA(lpszType, szKey, MAX_PATH)) /* Get full path to the key */
    return FALSE;
 
  if (!SHDeleteValueA(HKEY_CLASSES_ROOT, szKey, szExtensionA))
    return FALSE;
 
  if (!SHDeleteOrphanKeyA(HKEY_CLASSES_ROOT, szKey))
    return FALSE;
  return TRUE;
}

UnregisterExtensionForMIMETypeW()

BOOL WINAPI UnregisterExtensionForMIMETypeW

(

LPCWSTR

lpszType

)

Definition at line 2228 of file reg.c.

{
  WCHAR szKey[MAX_PATH];
 
  TRACE("(%s)\n", debugstr_w(lpszType));
 
  if (!GetMIMETypeSubKeyW(lpszType, szKey, MAX_PATH)) /* Get full path to the key */
    return FALSE;
 
  if (!SHDeleteValueW(HKEY_CLASSES_ROOT, szKey, szExtensionW))
    return FALSE;
 
  if (!SHDeleteOrphanKeyW(HKEY_CLASSES_ROOT, szKey))
    return FALSE;
  return TRUE;
}

UnregisterMIMETypeForExtensionA()

BOOL WINAPI UnregisterMIMETypeForExtensionA

(

LPCSTR

lpszSubKey

)

Definition at line 1994 of file reg.c.

{
  return !SHDeleteValueA(HKEY_CLASSES_ROOT, lpszSubKey, lpszContentTypeA);
}

UnregisterMIMETypeForExtensionW()

BOOL WINAPI UnregisterMIMETypeForExtensionW

(

LPCWSTR

lpszSubKey

)

Definition at line 2004 of file reg.c.

{
  return !SHDeleteValueW(HKEY_CLASSES_ROOT, lpszSubKey, lpszContentTypeW);
}

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

shell

)

Variable Documentation

dwLenMimeDbContent

const DWORD dwLenMimeDbContent = 27

static

Definition at line 43 of file reg.c.

Referenced by GetMIMETypeSubKeyA(), and GetMIMETypeSubKeyW().

lpszContentTypeA

const char lpszContentTypeA[] = "Content Type"

static

Definition at line 36 of file reg.c.

Referenced by RegisterMIMETypeForExtensionA(), and UnregisterMIMETypeForExtensionA().

lpszContentTypeW

const WCHAR lpszContentTypeW[] = { 'C','o','n','t','e','n','t',' ','T','y','p','e','\0'}

static

Definition at line 37 of file reg.c.

Referenced by RegisterMIMETypeForExtensionW(), and UnregisterMIMETypeForExtensionW().

szExtensionA

const char szExtensionA[] = "Extension"

static

Definition at line 45 of file reg.c.

Referenced by MIME_GetExtensionA(), RegisterExtensionForMIMETypeA(), and UnregisterExtensionForMIMETypeA().

szExtensionW

const WCHAR szExtensionW[] = { 'E', 'x', 't','e','n','s','i','o','n','\0' }

static

Definition at line 46 of file reg.c.

Referenced by MIME_GetExtensionW(), RegisterExtensionForMIMETypeW(), and UnregisterExtensionForMIMETypeW().

szMimeDbContentA

const char szMimeDbContentA[] = "MIME\\Database\\Content Type\\"

static

Definition at line 39 of file reg.c.

Referenced by GetMIMETypeSubKeyA().

szMimeDbContentW

const WCHAR szMimeDbContentW[]

static

Initial value:

= { 'M', 'I', 'M','E','\\',
  'D','a','t','a','b','a','s','e','\\','C','o','n','t','e','n','t',
  ' ','T','y','p','e','\\', 0 }

Definition at line 40 of file reg.c.

Referenced by GetMIMETypeSubKeyW().