kernelbase.c File Reference

#include "windef.h"
#include "winbase.h"
#include "wininet.h"
#include "shlobj.h"
#include "winternl.h"
#include "shlwapi.h"
#include "intshcut.h"
#include "mlang.h"
#include <shlwapi_undoc.h>
#include "wine/unicode.h"
#include "wine/debug.h"

Include dependency graph for kernelbase.c:

Go to the source code of this file.

Classes
struct	SHUSKEY

Macros
#define	COBJMACROS
#define	NO_SHLWAPI_STREAM
#define	REG_HKCU   TRUE
#define	REG_HKLM   FALSE

Typedefs
typedef struct SHUSKEY *	LPSHUSKEY

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (kernelbase)
static WCHAR *	heap_strdupAtoW (LPCSTR str)
HRESULT WINAPI	GetAcceptLanguagesW (LPWSTR langbuf, LPDWORD buflen)
HRESULT WINAPI	GetAcceptLanguagesA (LPSTR langbuf, LPDWORD buflen)
BOOL WINAPI	IsCharBlankW (WCHAR wc)
BOOL WINAPI	IsCharPunctW (WCHAR wc)
BOOL WINAPI	IsCharCntrlW (WCHAR wc)
BOOL WINAPI	IsCharDigitW (WCHAR wc)
BOOL WINAPI	IsCharXDigitW (WCHAR wc)
BOOL WINAPI	IsCharSpaceA (CHAR c)
BOOL WINAPI	IsCharSpaceW (WCHAR wc)
HRESULT WINAPI	QISearch (void *base, const QITAB *table, REFIID riid, void **ppv)
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)

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 24 of file kernelbase.c.

NO_SHLWAPI_STREAM

#define NO_SHLWAPI_STREAM

Definition at line 30 of file kernelbase.c.

REG_HKCU

#define REG_HKCU   TRUE

Definition at line 349 of file kernelbase.c.

REG_HKLM

#define REG_HKLM   FALSE

Definition at line 350 of file kernelbase.c.

Typedef Documentation

LPSHUSKEY

typedef struct SHUSKEY * LPSHUSKEY

Function Documentation

GetAcceptLanguagesA()

HRESULT WINAPI GetAcceptLanguagesA	(	LPSTR	langbuf,
		LPDWORD	buflen
	)

Definition at line 130 of file kernelbase.c.

{
    WCHAR *langbufW;
    DWORD buflenW, convlen;
    HRESULT retval;
 
    TRACE("(%p, %p) *%p: %d\n", langbuf, buflen, buflen, buflen ? *buflen : -1);
 
    if(!langbuf || !buflen || !*buflen) return E_FAIL;
 
    buflenW = *buflen;
    langbufW = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR) * buflenW);
    retval = GetAcceptLanguagesW(langbufW, &buflenW);
 
    if (retval == S_OK)
    {
        convlen = WideCharToMultiByte(CP_ACP, 0, langbufW, -1, langbuf, *buflen, NULL, NULL);
        convlen--;  /* do not count the terminating 0 */
    }
    else  /* copy partial string anyway */
    {
        convlen = WideCharToMultiByte(CP_ACP, 0, langbufW, *buflen, langbuf, *buflen, NULL, NULL);
        if (convlen < *buflen)
        {
            langbuf[convlen] = 0;
            convlen--;  /* do not count the terminating 0 */
        }
        else
        {
            convlen = *buflen;
        }
    }
    *buflen = buflenW ? convlen : 0;
 
    HeapFree(GetProcessHeap(), 0, langbufW);
    return retval;
}

GetAcceptLanguagesW()

HRESULT WINAPI GetAcceptLanguagesW	(	LPWSTR	langbuf,
		LPDWORD	buflen
	)

Definition at line 71 of file kernelbase.c.

{
    static const WCHAR szkeyW[] = {
    'S','o','f','t','w','a','r','e','\\',
    'M','i','c','r','o','s','o','f','t','\\',
    'I','n','t','e','r','n','e','t',' ','E','x','p','l','o','r','e','r','\\',
    'I','n','t','e','r','n','a','t','i','o','n','a','l',0};
    static const WCHAR valueW[] = {
    'A','c','c','e','p','t','L','a','n','g','u','a','g','e',0};
    DWORD mystrlen, mytype;
    DWORD len;
    HKEY mykey;
    LCID mylcid;
    WCHAR *mystr;
    LONG lres;
 
    TRACE("(%p, %p) *%p: %d\n", langbuf, buflen, buflen, buflen ? *buflen : -1);
 
    if(!langbuf || !buflen || !*buflen)
    return E_FAIL;
 
    mystrlen = (*buflen > 20) ? *buflen : 20 ;
    len = mystrlen * sizeof(WCHAR);
    mystr = HeapAlloc(GetProcessHeap(), 0, len);
    mystr[0] = 0;
    RegOpenKeyW(HKEY_CURRENT_USER, szkeyW, &mykey);
    lres = RegQueryValueExW(mykey, valueW, 0, &mytype, (PBYTE)mystr, &len);
    RegCloseKey(mykey);
    len = lstrlenW(mystr);
 
    if (!lres && (*buflen > len)) {
        lstrcpyW(langbuf, mystr);
        *buflen = len;
        HeapFree(GetProcessHeap(), 0, mystr);
        return S_OK;
    }
 
    /* Did not find a value in the registry or the user buffer is too small */
    mylcid = GetUserDefaultLCID();
    LcidToRfc1766W(mylcid, mystr, mystrlen);
    len = lstrlenW(mystr);
 
    memcpy( langbuf, mystr, min(*buflen, len+1)*sizeof(WCHAR) );
    HeapFree(GetProcessHeap(), 0, mystr);
 
    if (*buflen > len) {
        *buflen = len;
        return S_OK;
    }
 
    *buflen = 0;
    return E_NOT_SUFFICIENT_BUFFER;
}

Referenced by GetAcceptLanguagesA().

heap_strdupAtoW()

static WCHAR * heap_strdupAtoW ( LPCSTR  str )

inlinestatic

Definition at line 40 of file kernelbase.c.

{
    WCHAR *ret = NULL;
 
    if (str)
    {
        DWORD len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
        ret = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
        if (ret)
            MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len);
    }
 
    return ret;
}

IsCharBlankW()

BOOL WINAPI IsCharBlankW

(

WCHAR

wc

)

Definition at line 181 of file kernelbase.c.

{
    WORD CharType;
 
    return GetStringTypeW(CT_CTYPE1, &wc, 1, &CharType) && (CharType & C1_BLANK);
}

IsCharCntrlW()

BOOL WINAPI IsCharCntrlW

(

WCHAR

wc

)

Definition at line 219 of file kernelbase.c.

{
    WORD CharType;
 
    return GetStringTypeW(CT_CTYPE1, &wc, 1, &CharType) && (CharType & C1_CNTRL);
}

IsCharDigitW()

BOOL WINAPI IsCharDigitW

(

WCHAR

wc

)

Definition at line 238 of file kernelbase.c.

{
    WORD CharType;
 
    return GetStringTypeW(CT_CTYPE1, &wc, 1, &CharType) && (CharType & C1_DIGIT);
}

IsCharPunctW()

BOOL WINAPI IsCharPunctW

(

WCHAR

wc

)

Definition at line 200 of file kernelbase.c.

{
    WORD CharType;
 
    return GetStringTypeW(CT_CTYPE1, &wc, 1, &CharType) && (CharType & C1_PUNCT);
}

IsCharSpaceA()

BOOL WINAPI IsCharSpaceA

(

CHAR

c

)

Definition at line 264 of file kernelbase.c.

{
    WORD CharType;
    return GetStringTypeA(GetSystemDefaultLCID(), CT_CTYPE1, &c, 1, &CharType) && (CharType & C1_SPACE);
}

IsCharSpaceW()

BOOL WINAPI IsCharSpaceW

(

WCHAR

wc

)

Definition at line 282 of file kernelbase.c.

{
    WORD CharType;
 
    return GetStringTypeW(CT_CTYPE1, &wc, 1, &CharType) && (CharType & C1_SPACE);
}

IsCharXDigitW()

BOOL WINAPI IsCharXDigitW

(

WCHAR

wc

)

Definition at line 257 of file kernelbase.c.

{
    WORD CharType;
 
    return GetStringTypeW(CT_CTYPE1, &wc, 1, &CharType) && (CharType & C1_XDIGIT);
}

QISearch()

HRESULT WINAPI QISearch	(	void *	base,
		const QITAB *	table,
		REFIID	riid,
		void **	ppv
	)

Definition at line 298 of file kernelbase.c.

{
    HRESULT ret;
    IUnknown *a_vtbl;
    const QITAB *xmove;
 
    TRACE("(%p %p %s %p)\n", base, table, debugstr_guid(riid), ppv);
    if (ppv) {
        xmove = table;
        while (xmove->piid) {
        TRACE("trying (offset %d) %s\n", xmove->dwOffset, debugstr_guid(xmove->piid));
        if (IsEqualIID(riid, xmove->piid)) {
            a_vtbl = (IUnknown*)(xmove->dwOffset + (LPBYTE)base);
            TRACE("matched, returning (%p)\n", a_vtbl);
                    *ppv = a_vtbl;
            IUnknown_AddRef(a_vtbl);
            return S_OK;
        }
        xmove++;
        }
 
        if (IsEqualIID(riid, &IID_IUnknown)) {
        a_vtbl = (IUnknown*)(table->dwOffset + (LPBYTE)base);
        TRACE("returning first for IUnknown (%p)\n", a_vtbl);
                *ppv = a_vtbl;
        IUnknown_AddRef(a_vtbl);
        return S_OK;
        }
        *ppv = 0;
        ret = E_NOINTERFACE;
    } else
        ret = E_POINTER;
 
    TRACE("-- 0x%08x\n", ret);
    return ret;
}

REG_GetHKEYFromHUSKEY()

static HKEY REG_GetHKEYFromHUSKEY ( HUSKEY  hUSKey, BOOL  which  )

static

Definition at line 357 of file kernelbase.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().

SHRegCloseUSKey()

LONG WINAPI SHRegCloseUSKey

(

HUSKEY

hUSKey

)

Definition at line 478 of file kernelbase.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 505 of file kernelbase.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 546 of file kernelbase.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 606 of file kernelbase.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 617 of file kernelbase.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 638 of file kernelbase.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 649 of file kernelbase.c.

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

SHRegEnumUSKeyA()

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

Definition at line 1208 of file kernelbase.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 1243 of file kernelbase.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 675 of file kernelbase.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 706 of file kernelbase.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 1002 of file kernelbase.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 1058 of file kernelbase.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;
}

SHRegGetUSValueA()

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

Definition at line 849 of file kernelbase.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 882 of file kernelbase.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().

SHRegOpenUSKeyA()

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

Definition at line 394 of file kernelbase.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 411 of file kernelbase.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 1122 of file kernelbase.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 1163 of file kernelbase.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 741 of file kernelbase.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 792 of file kernelbase.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().

SHRegSetUSValueA()

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

Definition at line 931 of file kernelbase.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 961 of file kernelbase.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 1295 of file kernelbase.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 1312 of file kernelbase.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().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

kernelbase

)