/* * SHLWAPI registry functions * * Copyright 1998 Juergen Schmied * Copyright 2001 Guy Albertelli * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ #include <stdarg.h> #include <string.h> #include "windef.h" #include "winbase.h" #include "winuser.h" #include "winreg.h" #include "wine/debug.h" #define NO_SHLWAPI_STREAM #include "shlwapi.h" #include "wine/unicode.h" WINE_DEFAULT_DEBUG_CHANNEL(shell); /* Key/Value names for MIME content types */ 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[] = { 'M', 'I', 'M','E','\\', 'D','a','t','a','b','a','s','e','\\','C','o','n','t','e','n','t', ' ','T','y','p','e','\\', 0 }; static const DWORD dwLenMimeDbContent = 27; /* strlen of szMimeDbContentA/W */ static const char szExtensionA[] = "Extension"; static const WCHAR szExtensionW[] = { 'E', 'x', 't','e','n','s','i','o','n','\0' }; /* internal structure of what the HUSKEY points to */ typedef struct { HKEY HKCUstart; /* Start key in CU hive */ HKEY HKCUkey; /* Opened key in CU hive */ HKEY HKLMstart; /* Start key in LM hive */ HKEY HKLMkey; /* Opened key in LM hive */ WCHAR lpszPath[MAX_PATH]; } SHUSKEY, *LPSHUSKEY; INT WINAPI SHStringFromGUIDW(REFGUID,LPWSTR,INT); HRESULT WINAPI SHRegGetCLSIDKeyW(REFGUID,LPCWSTR,BOOL,BOOL,PHKEY); #define REG_HKCU TRUE #define REG_HKLM FALSE /************************************************************************* * REG_GetHKEYFromHUSKEY * * Function: Return the proper registry key from the HUSKEY structure * also allow special predefined values. */ static HKEY REG_GetHKEYFromHUSKEY(HUSKEY hUSKey, BOOL which) { 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; } /************************************************************************* * SHRegOpenUSKeyA [SHLWAPI.@] * * Open a user-specific registry key. * * PARAMS * Path [I] Key name to open * AccessType [I] Access type * hRelativeUSKey [I] Relative user key * phNewUSKey [O] Destination for created key * fIgnoreHKCU [I] TRUE=Don't check HKEY_CURRENT_USER * * RETURNS * Success: ERROR_SUCCESS * Failure: An error code from RegOpenKeyExA(). */ LONG WINAPI SHRegOpenUSKeyA(LPCSTR Path, REGSAM AccessType, HUSKEY hRelativeUSKey, PHUSKEY phNewUSKey, BOOL fIgnoreHKCU) { WCHAR szPath[MAX_PATH]; if (Path) MultiByteToWideChar(CP_ACP, 0, Path, -1, szPath, MAX_PATH); return SHRegOpenUSKeyW(Path ? szPath : NULL, AccessType, hRelativeUSKey, phNewUSKey, fIgnoreHKCU); } /************************************************************************* * SHRegOpenUSKeyW [SHLWAPI.@] * * See SHRegOpenUSKeyA. */ LONG WINAPI SHRegOpenUSKeyW(LPCWSTR Path, REGSAM AccessType, HUSKEY hRelativeUSKey, PHUSKEY phNewUSKey, BOOL fIgnoreHKCU) { 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; } /************************************************************************* * SHRegCloseUSKey [SHLWAPI.@] * * Close a user-specific registry key * * RETURNS * Success: ERROR_SUCCESS * Failure: An error code from RegCloseKey(). */ LONG WINAPI SHRegCloseUSKey( HUSKEY hUSKey) /* [I] Key to close */ { LPSHUSKEY hKey = hUSKey; LONG ret = ERROR_SUCCESS; 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->HKCUstart); HeapFree(GetProcessHeap(), 0, hKey); return ret; } /************************************************************************* * SHRegCreateUSKeyA [SHLWAPI.@] * * Create or open a user-specific registry key. * * PARAMS * pszPath [I] Key name to create or open. * samDesired [I] Wanted security access. * hRelativeUSKey [I] Base path if pszPath is relative. NULL otherwise. * phNewUSKey [O] Receives a handle to the new or opened key. * dwFlags [I] Base key under which the key should be opened. * * RETURNS * Success: ERROR_SUCCESS * Failure: Nonzero error code from winerror.h */ LONG WINAPI SHRegCreateUSKeyA(LPCSTR pszPath, REGSAM samDesired, HUSKEY hRelativeUSKey, PHUSKEY phNewUSKey, DWORD dwFlags) { FIXME("(%s, 0x%08x, %p, %p, 0x%08x) stub\n", debugstr_a(pszPath), samDesired, hRelativeUSKey, phNewUSKey, dwFlags); return ERROR_SUCCESS; } /************************************************************************* * SHRegCreateUSKeyW [SHLWAPI.@] * * See SHRegCreateUSKeyA. */ LONG WINAPI SHRegCreateUSKeyW(LPCWSTR pszPath, REGSAM samDesired, HUSKEY hRelativeUSKey, PHUSKEY phNewUSKey, DWORD dwFlags) { FIXME("(%s, 0x%08x, %p, %p, 0x%08x) stub\n", debugstr_w(pszPath), samDesired, hRelativeUSKey, phNewUSKey, dwFlags); return ERROR_SUCCESS; } /************************************************************************* * SHRegDeleteEmptyUSKeyA [SHLWAPI.@] * * Delete an empty user-specific registry key. * * PARAMS * hUSKey [I] Handle to an open registry key. * pszValue [I] Empty key name. * delRegFlags [I] Flag that specifies the base from which to delete * the key. * * RETURNS * Success: ERROR_SUCCESS * Failure: Nonzero error code from winerror.h */ LONG WINAPI SHRegDeleteEmptyUSKeyA(HUSKEY hUSKey, LPCSTR pszValue, SHREGDEL_FLAGS delRegFlags) { FIXME("(%p, %s, 0x%08x) stub\n", hUSKey, debugstr_a(pszValue), delRegFlags); return ERROR_SUCCESS; } /************************************************************************* * SHRegDeleteEmptyUSKeyW [SHLWAPI.@] * * See SHRegDeleteEmptyUSKeyA. */ LONG WINAPI SHRegDeleteEmptyUSKeyW(HUSKEY hUSKey, LPCWSTR pszValue, SHREGDEL_FLAGS delRegFlags) { FIXME("(%p, %s, 0x%08x) stub\n", hUSKey, debugstr_w(pszValue), delRegFlags); return ERROR_SUCCESS; } /************************************************************************* * SHRegDeleteUSValueA [SHLWAPI.@] * * Delete a user-specific registry value. * * PARAMS * hUSKey [I] Handle to an open registry key. * pszValue [I] Specifies the value to delete. * delRegFlags [I] Flag that specifies the base of the key from which to * delete the value. * * RETURNS * Success: ERROR_SUCCESS * Failure: Nonzero error code from winerror.h */ LONG WINAPI SHRegDeleteUSValueA(HUSKEY hUSKey, LPCSTR pszValue, SHREGDEL_FLAGS delRegFlags) { FIXME("(%p, %s, 0x%08x) stub\n", hUSKey, debugstr_a(pszValue), delRegFlags); return ERROR_SUCCESS; } /************************************************************************* * SHRegDeleteUSValueW [SHLWAPI.@] * * See SHRegDeleteUSValueA. */ LONG WINAPI SHRegDeleteUSValueW(HUSKEY hUSKey, LPCWSTR pszValue, SHREGDEL_FLAGS delRegFlags) { FIXME("(%p, %s, 0x%08x) stub\n", hUSKey, debugstr_w(pszValue), delRegFlags); return ERROR_SUCCESS; } /************************************************************************* * SHRegEnumUSValueA [SHLWAPI.@] * * Enumerate values of a specified registry key. * * PARAMS * hUSKey [I] Handle to an open registry key. * dwIndex [I] Index of the value to be retrieved. * pszValueName [O] Buffer to receive the value name. * pcchValueNameLen [I] Size of pszValueName in characters. * pdwType [O] Receives data type of the value. * pvData [O] Receives value data. May be NULL. * pcbData [I/O] Size of pvData in bytes. * enumRegFlags [I] Flag that specifies the base key under which to * enumerate values. * * RETURNS * Success: ERROR_SUCCESS * Failure: Nonzero error code from winerror.h */ LONG WINAPI SHRegEnumUSValueA(HUSKEY hUSKey, DWORD dwIndex, LPSTR pszValueName, LPDWORD pcchValueNameLen, LPDWORD pdwType, LPVOID pvData, LPDWORD pcbData, SHREGENUM_FLAGS enumRegFlags) { FIXME("(%p, 0x%08x, %s, %p, %p, %p, %p, 0x%08x) stub\n", hUSKey, dwIndex, debugstr_a(pszValueName), pcchValueNameLen, pdwType, pvData, pcbData, enumRegFlags); return ERROR_INVALID_FUNCTION; } /************************************************************************* * SHRegEnumUSValueW [SHLWAPI.@] * * See SHRegEnumUSValueA. */ LONG WINAPI SHRegEnumUSValueW(HUSKEY hUSKey, DWORD dwIndex, LPWSTR pszValueName, LPDWORD pcchValueNameLen, LPDWORD pdwType, LPVOID pvData, LPDWORD pcbData, SHREGENUM_FLAGS enumRegFlags) { FIXME("(%p, 0x%08x, %s, %p, %p, %p, %p, 0x%08x) stub\n", hUSKey, dwIndex, debugstr_w(pszValueName), pcchValueNameLen, pdwType, pvData, pcbData, enumRegFlags); return ERROR_INVALID_FUNCTION; } /************************************************************************* * SHRegQueryUSValueA [SHLWAPI.@] * * Query a user-specific registry value. * * RETURNS * Success: ERROR_SUCCESS * Failure: An error code from RegQueryValueExA(). */ LONG WINAPI SHRegQueryUSValueA( HUSKEY hUSKey, /* [I] Key to query */ LPCSTR pszValue, /* [I] Value name under hUSKey */ LPDWORD pdwType, /* [O] Destination for value type */ LPVOID pvData, /* [O] Destination for value data */ LPDWORD pcbData, /* [O] Destination for value length */ BOOL fIgnoreHKCU, /* [I] TRUE=Don't check HKEY_CURRENT_USER */ LPVOID pvDefaultData, /* [I] Default data if pszValue does not exist */ DWORD dwDefaultDataSize) /* [I] Length of pvDefaultData */ { 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; } /************************************************************************* * SHRegQueryUSValueW [SHLWAPI.@] * * See SHRegQueryUSValueA. */ LONG WINAPI SHRegQueryUSValueW( HUSKEY hUSKey, LPCWSTR pszValue, LPDWORD pdwType, LPVOID pvData, LPDWORD pcbData, BOOL fIgnoreHKCU, LPVOID pvDefaultData, DWORD dwDefaultDataSize) { 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; } /************************************************************************* * SHRegGetUSValueA [SHLWAPI.@] * * Get a user-specific registry value. * * RETURNS * Success: ERROR_SUCCESS * Failure: An error code from SHRegOpenUSKeyA() or SHRegQueryUSValueA(). * * NOTES * This function opens pSubKey, queries the value, and then closes the key. */ LONG WINAPI SHRegGetUSValueA( LPCSTR pSubKey, /* [I] Key name to open */ LPCSTR pValue, /* [I] Value name to open */ LPDWORD pwType, /* [O] Destination for the type of the value */ LPVOID pvData, /* [O] Destination for the value */ LPDWORD pcbData, /* [I] Destination for the length of the value **/ BOOL flagIgnoreHKCU, /* [I] TRUE=Don't check HKEY_CURRENT_USER */ LPVOID pDefaultData, /* [I] Default value if it doesn't exist */ DWORD wDefaultDataSize) /* [I] Length of pDefaultData */ { 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; } /************************************************************************* * SHRegGetUSValueW [SHLWAPI.@] * * See SHRegGetUSValueA. */ LONG WINAPI SHRegGetUSValueW( LPCWSTR pSubKey, LPCWSTR pValue, LPDWORD pwType, LPVOID pvData, LPDWORD pcbData, BOOL flagIgnoreHKCU, LPVOID pDefaultData, DWORD wDefaultDataSize) { 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; } /************************************************************************* * SHRegSetUSValueA [SHLWAPI.@] * * Set a user-specific registry value. * * PARAMS * pszSubKey [I] Name of key to set the value in * pszValue [I] Name of value under pszSubKey to set the value in * dwType [I] Type of the value * pvData [I] Data to set as the value * cbData [I] length of pvData * dwFlags [I] SHREGSET_ flags from "shlwapi.h" * * RETURNS * Success: ERROR_SUCCESS * Failure: An error code from SHRegOpenUSKeyA() or SHRegWriteUSValueA(), or * ERROR_INVALID_FUNCTION if pvData is NULL. * * NOTES * This function opens pszSubKey, sets the value, and then closes the key. */ LONG WINAPI SHRegSetUSValueA(LPCSTR pszSubKey, LPCSTR pszValue, DWORD dwType, LPVOID pvData, DWORD cbData, DWORD dwFlags) { 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 [SHLWAPI.@] * * See SHRegSetUSValueA. */ LONG WINAPI SHRegSetUSValueW(LPCWSTR pszSubKey, LPCWSTR pszValue, DWORD dwType, LPVOID pvData, DWORD cbData, DWORD dwFlags) { 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; } /************************************************************************* * SHRegGetBoolUSValueA [SHLWAPI.@] * * Get a user-specific registry boolean value. * * RETURNS * Success: ERROR_SUCCESS * Failure: An error code from SHRegOpenUSKeyA() or SHRegQueryUSValueA(). * * NOTES * This function opens pszSubKey, queries the value, and then closes the key. * * Boolean values are one of the following: * True: YES,TRUE,non-zero * False: NO,FALSE,0 */ BOOL WINAPI SHRegGetBoolUSValueA( LPCSTR pszSubKey, /* [I] Key name to open */ LPCSTR pszValue, /* [I] Value name to open */ BOOL fIgnoreHKCU, /* [I] TRUE=Don't check HKEY_CURRENT_USER */ BOOL fDefault) /* [I] Default value to use if pszValue is not present */ { 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 [SHLWAPI.@] * * See SHRegGetBoolUSValueA. */ BOOL WINAPI SHRegGetBoolUSValueW( LPCWSTR pszSubKey, LPCWSTR pszValue, BOOL fIgnoreHKCU, BOOL fDefault) { 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; } /************************************************************************* * SHRegQueryInfoUSKeyA [SHLWAPI.@] * * Get information about a user-specific registry key. * * RETURNS * Success: ERROR_SUCCESS * Failure: An error code from RegQueryInfoKeyA(). */ LONG WINAPI SHRegQueryInfoUSKeyA( HUSKEY hUSKey, /* [I] Key to query */ LPDWORD pcSubKeys, /* [O] Destination for number of sub keys */ LPDWORD pcchMaxSubKeyLen, /* [O] Destination for the length of the biggest sub key name */ LPDWORD pcValues, /* [O] Destination for number of values */ LPDWORD pcchMaxValueNameLen,/* [O] Destination for the length of the biggest value */ SHREGENUM_FLAGS enumRegFlags) /* [in] SHREGENUM_ flags from "shlwapi.h" */ { 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 [SHLWAPI.@] * * See SHRegQueryInfoUSKeyA. */ LONG WINAPI SHRegQueryInfoUSKeyW( HUSKEY hUSKey, LPDWORD pcSubKeys, LPDWORD pcchMaxSubKeyLen, LPDWORD pcValues, LPDWORD pcchMaxValueNameLen, SHREGENUM_FLAGS enumRegFlags) { 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; } /************************************************************************* * SHRegEnumUSKeyA [SHLWAPI.@] * * Enumerate a user-specific registry key. * * RETURNS * Success: ERROR_SUCCESS * Failure: An error code from RegEnumKeyExA(). */ LONG WINAPI SHRegEnumUSKeyA( HUSKEY hUSKey, /* [in] Key to enumerate */ DWORD dwIndex, /* [in] Index within hUSKey */ LPSTR pszName, /* [out] Name of the enumerated value */ LPDWORD pcchValueNameLen, /* [in/out] Length of pszName */ SHREGENUM_FLAGS enumRegFlags) /* [in] SHREGENUM_ flags from "shlwapi.h" */ { 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 [SHLWAPI.@] * * See SHRegEnumUSKeyA. */ LONG WINAPI SHRegEnumUSKeyW( HUSKEY hUSKey, DWORD dwIndex, LPWSTR pszName, LPDWORD pcchValueNameLen, SHREGENUM_FLAGS enumRegFlags) { 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; } /************************************************************************* * SHRegWriteUSValueA [SHLWAPI.@] * * Write a user-specific registry value. * * PARAMS * hUSKey [I] Key to write the value to * pszValue [I] Name of value under hUSKey to write the value as * dwType [I] Type of the value * pvData [I] Data to set as the value * cbData [I] length of pvData * dwFlags [I] SHREGSET_ flags from "shlwapi.h" * * RETURNS * Success: ERROR_SUCCESS. * Failure: ERROR_INVALID_PARAMETER, if any parameter is invalid, otherwise * an error code from RegSetValueExA(). * * NOTES * dwFlags must have at least SHREGSET_FORCE_HKCU or SHREGSET_FORCE_HKLM set. */ LONG WINAPI SHRegWriteUSValueA(HUSKEY hUSKey, LPCSTR pszValue, DWORD dwType, LPVOID pvData, DWORD cbData, DWORD dwFlags) { 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); } /************************************************************************* * SHRegWriteUSValueW [SHLWAPI.@] * * See SHRegWriteUSValueA. */ LONG WINAPI SHRegWriteUSValueW(HUSKEY hUSKey, LPCWSTR pszValue, DWORD dwType, LPVOID pvData, DWORD cbData, DWORD dwFlags) { 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; } /************************************************************************* * SHRegGetPathA [SHLWAPI.@] * * Get a path from the registry. * * PARAMS * hKey [I] Handle to registry key * lpszSubKey [I] Name of sub key containing path to get * lpszValue [I] Name of value containing path to get * lpszPath [O] Buffer for returned path * dwFlags [I] Reserved * * RETURNS * Success: ERROR_SUCCESS. lpszPath contains the path. * Failure: An error code from RegOpenKeyExA() or SHQueryValueExA(). */ DWORD WINAPI SHRegGetPathA(HKEY hKey, LPCSTR lpszSubKey, LPCSTR lpszValue, LPSTR lpszPath, DWORD dwFlags) { 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 [SHLWAPI.@] * * See SHRegGetPathA. */ DWORD WINAPI SHRegGetPathW(HKEY hKey, LPCWSTR lpszSubKey, LPCWSTR lpszValue, LPWSTR lpszPath, DWORD dwFlags) { 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); } /************************************************************************* * SHRegSetPathA [SHLWAPI.@] * * Write a path to the registry. * * PARAMS * hKey [I] Handle to registry key * lpszSubKey [I] Name of sub key containing path to set * lpszValue [I] Name of value containing path to set * lpszPath [O] Path to write * dwFlags [I] Reserved, must be 0. * * RETURNS * Success: ERROR_SUCCESS. * Failure: An error code from SHSetValueA(). */ DWORD WINAPI SHRegSetPathA(HKEY hKey, LPCSTR lpszSubKey, LPCSTR lpszValue, LPCSTR lpszPath, DWORD dwFlags) { char szBuff[MAX_PATH]; 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)); } /************************************************************************* * SHRegSetPathW [SHLWAPI.@] * * See SHRegSetPathA. */ DWORD WINAPI SHRegSetPathW(HKEY hKey, LPCWSTR lpszSubKey, LPCWSTR lpszValue, LPCWSTR lpszPath, DWORD dwFlags) { WCHAR szBuff[MAX_PATH]; 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)); } /************************************************************************* * SHGetValueA [SHLWAPI.@] * * Get a value from the registry. * * PARAMS * hKey [I] Handle to registry key * lpszSubKey [I] Name of sub key containing value to get * lpszValue [I] Name of value to get * pwType [O] Pointer to the values type * pvData [O] Pointer to the values data * pcbData [O] Pointer to the values size * * RETURNS * Success: ERROR_SUCCESS. Output parameters contain the details read. * Failure: An error code from RegOpenKeyExA() or SHQueryValueExA(). */ DWORD WINAPI SHGetValueA(HKEY hKey, LPCSTR lpszSubKey, LPCSTR lpszValue, LPDWORD pwType, LPVOID pvData, LPDWORD pcbData) { 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; } /************************************************************************* * SHRegGetValueA [SHLWAPI.@] * * Get a value from the registry. * * PARAMS * hKey [I] Handle to registry key * lpszSubKey [I] Name of sub key containing value to get * lpszValue [I] Name of value to get * srrf [I] Flags for restricting returned data * pwType [O] Pointer to the values type * pvData [O] Pointer to the values data * pcbData [O] Pointer to the values size * * RETURNS * Success: ERROR_SUCCESS. Output parameters contain the details read. * Failure: An error code from RegOpenKeyExA() or SHQueryValueExA(). */ DWORD WINAPI SHRegGetValueA(HKEY hKey, LPCSTR lpszSubKey, LPCSTR lpszValue, DWORD srrfFlags, LPDWORD pwType, LPVOID pvData, LPDWORD pcbData) { 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); FIXME("Semi-Stub: Find meaning and implement handling of SRFF Flags 0x%08x\n", srrfFlags); dwRet = RegOpenKeyExA(hKey, lpszSubKey, 0, KEY_QUERY_VALUE, &hSubKey); if (! dwRet) { /* SHQueryValueEx expands Environment strings */ dwRet = SHQueryValueExA(hSubKey, lpszValue, 0, pwType, pvData, pcbData); RegCloseKey(hSubKey); } return dwRet; } /************************************************************************* * SHReg GetRegValueW [SHLWAPI.@] * * See SHGetValueA. */ DWORD WINAPI SHRegGetValueW(HKEY hKey, LPCWSTR lpszSubKey, LPCWSTR lpszValue, DWORD srrfFlags, LPDWORD pwType, LPVOID pvData, LPDWORD pcbData) { DWORD dwRet = 0; HKEY hSubKey = 0; TRACE("(hkey=%p,%s,%s,0x%08x, %p,%p,%p)\n", hKey, debugstr_w(lpszSubKey), debugstr_w(lpszValue), srrfFlags,pwType, pvData, pcbData); FIXME("Semi-Stub: Find meaning and implement handling of SRFF Flags 0x%08x\n", srrfFlags); dwRet = RegOpenKeyExW(hKey, lpszSubKey, 0, KEY_QUERY_VALUE, &hSubKey); if (! dwRet) { dwRet = SHQueryValueExW(hSubKey, lpszValue, 0, pwType, pvData, pcbData); RegCloseKey(hSubKey); } return dwRet; } /************************************************************************* * SHGetValueW [SHLWAPI.@] * * See SHGetValueA. */ DWORD WINAPI SHGetValueW(HKEY hKey, LPCWSTR lpszSubKey, LPCWSTR lpszValue, LPDWORD pwType, LPVOID pvData, LPDWORD pcbData) { 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; } /************************************************************************* * SHSetValueA [SHLWAPI.@] * * Set a value in the registry. * * PARAMS * hKey [I] Handle to registry key * lpszSubKey [I] Name of sub key under hKey * lpszValue [I] Name of value to set * dwType [I] Type of the value * pvData [I] Data of the value * cbData [I] Size of the value * * RETURNS * Success: ERROR_SUCCESS. The value is set with the data given. * Failure: An error code from RegCreateKeyExA() or RegSetValueExA() * * NOTES * If lpszSubKey does not exist, it is created before the value is set. If * lpszSubKey is NULL or an empty string, then the value is added directly * to hKey instead. */ DWORD WINAPI SHSetValueA(HKEY hKey, LPCSTR lpszSubKey, LPCSTR lpszValue, DWORD dwType, LPCVOID pvData, DWORD cbData) { 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; } /************************************************************************* * SHSetValueW [SHLWAPI.@] * * See SHSetValueA. */ DWORD WINAPI SHSetValueW(HKEY hKey, LPCWSTR lpszSubKey, LPCWSTR lpszValue, DWORD dwType, LPCVOID pvData, DWORD cbData) { 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; } /************************************************************************* * SHQueryInfoKeyA [SHLWAPI.@] * * Get information about a registry key. See RegQueryInfoKeyA(). * * RETURNS * The result of calling RegQueryInfoKeyA(). */ LONG WINAPI SHQueryInfoKeyA(HKEY hKey, LPDWORD pwSubKeys, LPDWORD pwSubKeyMax, LPDWORD pwValues, LPDWORD pwValueMax) { 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 [SHLWAPI.@] * * See SHQueryInfoKeyA. */ LONG WINAPI SHQueryInfoKeyW(HKEY hKey, LPDWORD pwSubKeys, LPDWORD pwSubKeyMax, LPDWORD pwValues, LPDWORD pwValueMax) { 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 [SHLWAPI.@] * * Get a value from the registry, expanding environment variable strings. * * PARAMS * hKey [I] Handle to registry key * lpszValue [I] Name of value to query * lpReserved [O] Reserved for future use; must be NULL * pwType [O] Optional pointer updated with the values type * pvData [O] Optional pointer updated with the values data * pcbData [O] Optional pointer updated with the values size * * RETURNS * Success: ERROR_SUCCESS. Any non NULL output parameters are updated with * information about the value. * Failure: ERROR_OUTOFMEMORY if memory allocation fails, or the type of the * data is REG_EXPAND_SZ and pcbData is NULL. Otherwise an error * code from RegQueryValueExA() or ExpandEnvironmentStringsA(). * * NOTES * Either pwType, pvData or pcbData may be NULL if the caller doesn't want * the type, data or size information for the value. * * If the type of the data is REG_EXPAND_SZ, it is expanded to REG_SZ. The * value returned will be truncated if it is of type REG_SZ and bigger than * the buffer given to store it. * * REG_EXPAND_SZ: * case-1: the unexpanded string is smaller than the expanded one * subcase-1: the buffer is too small to hold the unexpanded string: * function fails and returns the size of the unexpanded string. * * subcase-2: buffer is too small to hold the expanded string: * the function return success (!!) and the result is truncated * *** This is clearly an error in the native implementation. *** * * case-2: the unexpanded string is bigger than the expanded one * The buffer must have enough space to hold the unexpanded * string even if the result is smaller. * */ DWORD WINAPI SHQueryValueExA( HKEY hKey, LPCSTR lpszValue, LPDWORD lpReserved, LPDWORD pwType, LPVOID pvData, LPDWORD pcbData) { 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; } /************************************************************************* * SHQueryValueExW [SHLWAPI.@] * * See SHQueryValueExA. */ DWORD WINAPI SHQueryValueExW(HKEY hKey, LPCWSTR lpszValue, LPDWORD lpReserved, LPDWORD pwType, LPVOID pvData, LPDWORD pcbData) { 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; } /************************************************************************* * SHDeleteKeyA [SHLWAPI.@] * * Delete a registry key and any sub keys/values present * * This function forwards to the unicode version directly, to avoid * handling subkeys that are not representable in ASCII. * * PARAMS * hKey [I] Handle to registry key * lpszSubKey [I] Name of sub key to delete * * RETURNS * Success: ERROR_SUCCESS. The key is deleted. * Failure: An error code from RegOpenKeyExA(), RegQueryInfoKeyA(), * RegEnumKeyExA() or RegDeleteKeyA(). */ DWORD WINAPI SHDeleteKeyA(HKEY hKey, LPCSTR lpszSubKey) { WCHAR subkeyW[MAX_PATH]; MultiByteToWideChar (CP_ACP, 0, lpszSubKey, -1, subkeyW, sizeof(subkeyW)/sizeof(WCHAR)); return SHDeleteKeyW(hKey, subkeyW); } /************************************************************************* * SHDeleteKeyW [SHLWAPI.@] * * See SHDeleteKeyA. */ DWORD WINAPI SHDeleteKeyW(HKEY hKey, LPCWSTR lpszSubKey) { 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; } /************************************************************************* * SHDeleteEmptyKeyA [SHLWAPI.@] * * Delete a registry key with no sub keys. * * PARAMS * hKey [I] Handle to registry key * lpszSubKey [I] Name of sub key to delete * * RETURNS * Success: ERROR_SUCCESS. The key is deleted. * Failure: If the key is not empty, returns ERROR_KEY_HAS_CHILDREN. Otherwise * returns an error code from RegOpenKeyExA(), RegQueryInfoKeyA() or * RegDeleteKeyA(). */ DWORD WINAPI SHDeleteEmptyKeyA(HKEY hKey, LPCSTR lpszSubKey) { 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 [SHLWAPI.@] * * See SHDeleteEmptyKeyA. */ DWORD WINAPI SHDeleteEmptyKeyW(HKEY hKey, LPCWSTR lpszSubKey) { 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; } /************************************************************************* * SHDeleteOrphanKeyA [SHLWAPI.@] * * Delete a registry key with no sub keys or values. * * PARAMS * hKey [I] Handle to registry key * lpszSubKey [I] Name of sub key to possibly delete * * RETURNS * Success: ERROR_SUCCESS. The key has been deleted if it was an orphan. * Failure: An error from RegOpenKeyExA(), RegQueryValueExA(), or RegDeleteKeyA(). */ DWORD WINAPI SHDeleteOrphanKeyA(HKEY hKey, LPCSTR lpszSubKey) { 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; } /************************************************************************* * SHDeleteOrphanKeyW [SHLWAPI.@] * * See SHDeleteOrphanKeyA. */ DWORD WINAPI SHDeleteOrphanKeyW(HKEY hKey, LPCWSTR lpszSubKey) { 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; } /************************************************************************* * SHDeleteValueA [SHLWAPI.@] * * Delete a value from the registry. * * PARAMS * hKey [I] Handle to registry key * lpszSubKey [I] Name of sub key containing value to delete * lpszValue [I] Name of value to delete * * RETURNS * Success: ERROR_SUCCESS. The value is deleted. * Failure: An error code from RegOpenKeyExA() or RegDeleteValueA(). */ DWORD WINAPI SHDeleteValueA(HKEY hKey, LPCSTR lpszSubKey, LPCSTR lpszValue) { 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; } /************************************************************************* * SHDeleteValueW [SHLWAPI.@] * * See SHDeleteValueA. */ DWORD WINAPI SHDeleteValueW(HKEY hKey, LPCWSTR lpszSubKey, LPCWSTR lpszValue) { 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; } /************************************************************************* * SHEnumKeyExA [SHLWAPI.@] * * Enumerate sub keys in a registry key. * * PARAMS * hKey [I] Handle to registry key * dwIndex [I] Index of key to enumerate * lpszSubKey [O] Pointer updated with the subkey name * pwLen [O] Pointer updated with the subkey length * * RETURNS * Success: ERROR_SUCCESS. lpszSubKey and pwLen are updated. * Failure: An error code from RegEnumKeyExA(). */ LONG WINAPI SHEnumKeyExA(HKEY hKey, DWORD dwIndex, LPSTR lpszSubKey, LPDWORD pwLen) { TRACE("(hkey=%p,%d,%s,%p)\n", hKey, dwIndex, debugstr_a(lpszSubKey), pwLen); return RegEnumKeyExA(hKey, dwIndex, lpszSubKey, pwLen, NULL, NULL, NULL, NULL); } /************************************************************************* * SHEnumKeyExW [SHLWAPI.@] * * See SHEnumKeyExA. */ LONG WINAPI SHEnumKeyExW(HKEY hKey, DWORD dwIndex, LPWSTR lpszSubKey, LPDWORD pwLen) { TRACE("(hkey=%p,%d,%s,%p)\n", hKey, dwIndex, debugstr_w(lpszSubKey), pwLen); return RegEnumKeyExW(hKey, dwIndex, lpszSubKey, pwLen, NULL, NULL, NULL, NULL); } /************************************************************************* * SHEnumValueA [SHLWAPI.@] * * Enumerate values in a registry key. * * PARAMS * hKey [I] Handle to registry key * dwIndex [I] Index of key to enumerate * lpszValue [O] Pointer updated with the values name * pwLen [O] Pointer updated with the values length * pwType [O] Pointer updated with the values type * pvData [O] Pointer updated with the values data * pcbData [O] Pointer updated with the values size * * RETURNS * Success: ERROR_SUCCESS. Output parameters are updated. * Failure: An error code from RegEnumValueA(). */ LONG WINAPI SHEnumValueA(HKEY hKey, DWORD dwIndex, LPSTR lpszValue, LPDWORD pwLen, LPDWORD pwType, LPVOID pvData, LPDWORD pcbData) { 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 [SHLWAPI.@] * * See SHEnumValueA. */ LONG WINAPI SHEnumValueW(HKEY hKey, DWORD dwIndex, LPWSTR lpszValue, LPDWORD pwLen, LPDWORD pwType, LPVOID pvData, LPDWORD pcbData) { 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); } /************************************************************************* * @ [SHLWAPI.205] * * Get a value from the registry. * * PARAMS * hKey [I] Handle to registry key * pSubKey [I] Name of sub key containing value to get * pValue [I] Name of value to get * pwType [O] Destination for the values type * pvData [O] Destination for the values data * pbData [O] Destination for the values size * * RETURNS * Success: ERROR_SUCCESS. Output parameters contain the details read. * Failure: An error code from RegOpenKeyExA() or SHQueryValueExA(), * or ERROR_INVALID_FUNCTION in the machine is in safe mode. */ DWORD WINAPI SHGetValueGoodBootA(HKEY hkey, LPCSTR pSubKey, LPCSTR pValue, LPDWORD pwType, LPVOID pvData, LPDWORD pbData) { if (GetSystemMetrics(SM_CLEANBOOT)) return ERROR_INVALID_FUNCTION; return SHGetValueA(hkey, pSubKey, pValue, pwType, pvData, pbData); } /************************************************************************* * @ [SHLWAPI.206] * * Unicode version of SHGetValueGoodBootW. */ DWORD WINAPI SHGetValueGoodBootW(HKEY hkey, LPCWSTR pSubKey, LPCWSTR pValue, LPDWORD pwType, LPVOID pvData, LPDWORD pbData) { if (GetSystemMetrics(SM_CLEANBOOT)) return ERROR_INVALID_FUNCTION; return SHGetValueW(hkey, pSubKey, pValue, pwType, pvData, pbData); } /************************************************************************* * @ [SHLWAPI.320] * * Set a MIME content type in the registry. * * PARAMS * lpszSubKey [I] Name of key under HKEY_CLASSES_ROOT. * lpszValue [I] Value to set * * RETURNS * Success: TRUE * Failure: FALSE */ BOOL WINAPI RegisterMIMETypeForExtensionA(LPCSTR lpszSubKey, LPCSTR lpszValue) { DWORD dwRet; if (!lpszValue) { WARN("Invalid lpszValue would crash under Win32!\n"); return FALSE; } dwRet = SHSetValueA(HKEY_CLASSES_ROOT, lpszSubKey, lpszContentTypeA, REG_SZ, lpszValue, strlen(lpszValue)); return dwRet ? FALSE : TRUE; } /************************************************************************* * @ [SHLWAPI.321] * * Unicode version of RegisterMIMETypeForExtensionA. */ BOOL WINAPI RegisterMIMETypeForExtensionW(LPCWSTR lpszSubKey, LPCWSTR lpszValue) { DWORD dwRet; if (!lpszValue) { WARN("Invalid lpszValue would crash under Win32!\n"); return FALSE; } dwRet = SHSetValueW(HKEY_CLASSES_ROOT, lpszSubKey, lpszContentTypeW, REG_SZ, lpszValue, strlenW(lpszValue)); return dwRet ? FALSE : TRUE; } /************************************************************************* * @ [SHLWAPI.322] * * Delete a MIME content type from the registry. * * PARAMS * lpszSubKey [I] Name of sub key * * RETURNS * Success: TRUE * Failure: FALSE */ BOOL WINAPI UnregisterMIMETypeForExtensionA(LPCSTR lpszSubKey) { HRESULT ret = SHDeleteValueA(HKEY_CLASSES_ROOT, lpszSubKey, lpszContentTypeA); return ret ? FALSE : TRUE; } /************************************************************************* * @ [SHLWAPI.323] * * Unicode version of UnregisterMIMETypeForExtensionA. */ BOOL WINAPI UnregisterMIMETypeForExtensionW(LPCWSTR lpszSubKey) { HRESULT ret = SHDeleteValueW(HKEY_CLASSES_ROOT, lpszSubKey, lpszContentTypeW); return ret ? FALSE : TRUE; } /************************************************************************* * @ [SHLWAPI.328] * * Get the registry path to a MIME content key. * * PARAMS * lpszType [I] Content type to get the path for * lpszBuffer [O] Destination for path * dwLen [I] Length of lpszBuffer * * RETURNS * Success: TRUE. lpszBuffer contains the full path. * Failure: FALSE. * * NOTES * The base path for the key is "MIME\Database\Content Type\" */ BOOL WINAPI GetMIMETypeSubKeyA(LPCSTR lpszType, LPSTR lpszBuffer, DWORD dwLen) { 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; } /************************************************************************* * @ [SHLWAPI.329] * * Unicode version of GetMIMETypeSubKeyA. */ BOOL WINAPI GetMIMETypeSubKeyW(LPCWSTR lpszType, LPWSTR lpszBuffer, DWORD dwLen) { 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; } /************************************************************************* * @ [SHLWAPI.330] * * Get the file extension for a given Mime type. * * PARAMS * lpszType [I] Mime type to get the file extension for * lpExt [O] Destination for the resulting extension * iLen [I] Length of lpExt in characters * * RETURNS * Success: TRUE. lpExt contains the file extension. * Failure: FALSE, if any parameter is invalid or the extension cannot be * retrieved. If iLen > 0, lpExt is set to an empty string. * * NOTES * - The extension returned in lpExt always has a leading '.' character, even * if the registry Mime database entry does not. * - iLen must be long enough for the file extension for this function to succeed. */ BOOL WINAPI MIME_GetExtensionA(LPCSTR lpszType, LPSTR lpExt, INT iLen) { 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; } /************************************************************************* * @ [SHLWAPI.331] * * Unicode version of MIME_GetExtensionA. */ BOOL WINAPI MIME_GetExtensionW(LPCWSTR lpszType, LPWSTR lpExt, INT iLen) { 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; } /************************************************************************* * @ [SHLWAPI.324] * * Set the file extension for a MIME content key. * * PARAMS * lpszExt [I] File extension to set * lpszType [I] Content type to set the extension for * * RETURNS * Success: TRUE. The file extension is set in the registry. * Failure: FALSE. */ BOOL WINAPI RegisterExtensionForMIMETypeA(LPCSTR lpszExt, LPCSTR lpszType) { 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; } /************************************************************************* * @ [SHLWAPI.325] * * Unicode version of RegisterExtensionForMIMETypeA. */ BOOL WINAPI RegisterExtensionForMIMETypeW(LPCWSTR lpszExt, LPCWSTR lpszType) { 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; } /************************************************************************* * @ [SHLWAPI.326] * * Delete a file extension from a MIME content type. * * PARAMS * lpszType [I] Content type to delete the extension for * * RETURNS * Success: TRUE. The file extension is deleted from the registry. * Failure: FALSE. The extension may have been removed but the key remains. * * NOTES * If deleting the extension leaves an orphan key, the key is removed also. */ BOOL WINAPI UnregisterExtensionForMIMETypeA(LPCSTR lpszType) { 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; } /************************************************************************* * @ [SHLWAPI.327] * * Unicode version of UnregisterExtensionForMIMETypeA. */ BOOL WINAPI UnregisterExtensionForMIMETypeW(LPCWSTR lpszType) { 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; } /************************************************************************* * SHRegDuplicateHKey [SHLWAPI.@] * * Create a duplicate of a registry handle. * * PARAMS * hKey [I] key to duplicate. * * RETURNS * A new handle pointing to the same key as hKey. */ HKEY WINAPI SHRegDuplicateHKey(HKEY hKey) { HKEY newKey = 0; RegOpenKeyExA(hKey, 0, 0, MAXIMUM_ALLOWED, &newKey); TRACE("new key is %p\n", newKey); return newKey; } /************************************************************************* * SHCopyKeyA [SHLWAPI.@] * * Copy a key and its values/sub keys to another location. * * PARAMS * hKeySrc [I] Source key to copy from * lpszSrcSubKey [I] Sub key under hKeySrc, or NULL to use hKeySrc directly * hKeyDst [I] Destination key * dwReserved [I] Reserved, must be 0 * * RETURNS * Success: ERROR_SUCCESS. The key is copied to the destination key. * Failure: A standard windows error code. * * NOTES * If hKeyDst is a key under hKeySrc, this function will misbehave * (It will loop until out of stack, or the registry is full). This * bug is present in Win32 also. */ DWORD WINAPI SHCopyKeyA(HKEY hKeySrc, LPCSTR lpszSrcSubKey, HKEY hKeyDst, DWORD dwReserved) { WCHAR szSubKeyW[MAX_PATH]; TRACE("(hkey=%p,%s,%p08x,%d)\n", hKeySrc, debugstr_a(lpszSrcSubKey), hKeyDst, dwReserved); if (lpszSrcSubKey) MultiByteToWideChar(0, 0, lpszSrcSubKey, -1, szSubKeyW, MAX_PATH); return SHCopyKeyW(hKeySrc, lpszSrcSubKey ? szSubKeyW : NULL, hKeyDst, dwReserved); } /************************************************************************* * SHCopyKeyW [SHLWAPI.@] * * See SHCopyKeyA. */ DWORD WINAPI SHCopyKeyW(HKEY hKeySrc, LPCWSTR lpszSrcSubKey, HKEY hKeyDst, DWORD dwReserved) { 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; } /* * The following functions are ORDINAL ONLY: */ /************************************************************************* * @ [SHLWAPI.280] * * Read an integer value from the registry, falling back to a default. * * PARAMS * hKey [I] Registry key to read from * lpszValue [I] Value name to read * iDefault [I] Default value to return * * RETURNS * The value contained in the given registry value if present, otherwise * iDefault. */ int WINAPI SHRegGetIntW(HKEY hKey, LPCWSTR lpszValue, int iDefault) { 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; } /************************************************************************* * @ [SHLWAPI.343] * * Create or open an explorer ClassId Key. * * PARAMS * guid [I] Explorer ClassId key to open * lpszValue [I] Value name under the ClassId Key * bUseHKCU [I] TRUE=Use HKEY_CURRENT_USER, FALSE=Use HKEY_CLASSES_ROOT * bCreate [I] TRUE=Create the key if it doesn't exist, FALSE=Don't * phKey [O] Destination for the resulting key handle * * RETURNS * Success: S_OK. phKey contains the resulting registry handle. * Failure: An HRESULT error code indicating the problem. */ HRESULT WINAPI SHRegGetCLSIDKeyA(REFGUID guid, LPCSTR lpszValue, BOOL bUseHKCU, BOOL bCreate, PHKEY phKey) { 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); } /************************************************************************* * @ [SHLWAPI.344] * * Unicode version of SHRegGetCLSIDKeyA. */ HRESULT WINAPI SHRegGetCLSIDKeyW(REFGUID guid, LPCWSTR lpszValue, BOOL bUseHKCU, BOOL bCreate, PHKEY phKey) { 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','\\' }; #define szClassIdKeyLen (sizeof(szClassIdKey)/sizeof(WCHAR)) WCHAR szKey[MAX_PATH]; DWORD dwRet; HKEY hkey; /* Create the key string */ 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 */ } 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; } /************************************************************************* * SHRegisterValidateTemplate [SHLWAPI.@] * * observed from the ie 5.5 installer: * - allocates a buffer with the size of the given file * - read the file content into the buffer * - creates the key szTemplateKey * - sets "205523652929647911071668590831910975402"=dword:00002e37 at * the key * * PARAMS * filename [I] An existing file its content is read into an allocated * buffer * unknown [I] * * RETURNS * Success: ERROR_SUCCESS. */ HRESULT WINAPI SHRegisterValidateTemplate(LPCWSTR filename, BOOL unknown) { /* 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; }