comdlg32: Unify/fix some Lithuanian translated strings.
[wine] / dlls / shlwapi / reg.c
index ffb13d0..c6fa2c7 100644 (file)
  *
  * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * 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 "wingdi.h"
 #include "winuser.h"
-#include "winerror.h"
-#include "winnls.h"
 #include "winreg.h"
 #include "wine/debug.h"
 #define NO_SHLWAPI_STREAM
 
 WINE_DEFAULT_DEBUG_CHANNEL(shell);
 
-static const char *lpszContentTypeA = "Content Type";
+/* 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     HKCUkey;                  /* HKEY of opened HKCU key      */
-    HKEY     HKLMkey;                  /* HKEY of opened HKLM key      */
-    HKEY     start;                    /* HKEY of where to start       */
-    WCHAR    key_string[MAX_PATH];     /* additional path from 'start' */
-} Internal_HUSKEY, *LPInternal_HUSKEY;
+    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
@@ -54,10 +66,10 @@ typedef struct {
  * Function:  Return the proper registry key from the HUSKEY structure
  *            also allow special predefined values.
  */
-HKEY REG_GetHKEYFromHUSKEY(HUSKEY hUSKey, BOOL which)
+static HKEY REG_GetHKEYFromHUSKEY(HUSKEY hUSKey, BOOL which)
 {
-        HKEY test = (HKEY) hUSKey;
-        LPInternal_HUSKEY mihk = (LPInternal_HUSKEY) hUSKey;
+        HKEY test = hUSKey;
+        LPSHUSKEY mihk = hUSKey;
 
        if ((test == HKEY_CLASSES_ROOT)        ||
            (test == HKEY_CURRENT_CONFIG)      ||
@@ -78,167 +90,284 @@ HKEY REG_GetHKEYFromHUSKEY(HUSKEY hUSKey, BOOL which)
 /*************************************************************************
  * SHRegOpenUSKeyA     [SHLWAPI.@]
  *
- * Opens a user-specific registry key
+ * 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)
+LONG WINAPI SHRegOpenUSKeyA(LPCSTR Path, REGSAM AccessType, HUSKEY hRelativeUSKey,
+                            PHUSKEY phNewUSKey, BOOL fIgnoreHKCU)
 {
-    HKEY openHKCUkey=0;
-    HKEY openHKLMkey=0;
-    LONG ret2, ret1 = ~ERROR_SUCCESS;
-    LPInternal_HUSKEY ihky;
+    WCHAR szPath[MAX_PATH];
 
-    TRACE("(%s, 0x%lx, 0x%lx, %p, %s)\n", debugstr_a(Path),
-         (LONG)AccessType, (LONG)hRelativeUSKey, phNewUSKey,
-         (fIgnoreHKCU) ? "Ignoring HKCU" : "Process HKCU then HKLM");
+    if (Path)
+      MultiByteToWideChar(CP_ACP, 0, Path, -1, szPath, MAX_PATH);
 
-    /* now create the internal version of HUSKEY */
-    ihky = (LPInternal_HUSKEY)HeapAlloc(GetProcessHeap(), 0 ,
-                                       sizeof(Internal_HUSKEY));
-    MultiByteToWideChar(0, 0, Path, -1, ihky->key_string,
-                       sizeof(ihky->key_string)-1);
-
-    if (hRelativeUSKey) {
-       openHKCUkey = ((LPInternal_HUSKEY)hRelativeUSKey)->HKCUkey;
-       openHKLMkey = ((LPInternal_HUSKEY)hRelativeUSKey)->HKLMkey;
-    }
-    else {
-       openHKCUkey = HKEY_CURRENT_USER;
-       openHKLMkey = HKEY_LOCAL_MACHINE;
-    }
-
-    ihky->HKCUkey = 0;
-    ihky->HKLMkey = 0;
-    if (!fIgnoreHKCU) {
-       ret1 = RegOpenKeyExA(openHKCUkey, Path,
-                            0, AccessType, &ihky->HKCUkey);
-       /* if successful, then save real starting point */
-       if (ret1 != ERROR_SUCCESS)
-           ihky->HKCUkey = 0;
-    }
-    ret2 = RegOpenKeyExA(openHKLMkey, Path,
-                        0, AccessType, &ihky->HKLMkey);
-    if (ret2 != ERROR_SUCCESS)
-       ihky->HKLMkey = 0;
-
-    if ((ret1 != ERROR_SUCCESS) || (ret2 != ERROR_SUCCESS))
-       TRACE("one or more opens failed: HKCU=%ld HKLM=%ld\n", ret1, ret2);
-
-    /* if all attempts have failed then bail */
-    if ((ret1 != ERROR_SUCCESS) && (ret2 != ERROR_SUCCESS)) {
-       HeapFree(GetProcessHeap(), 0, ihky);
-       if (phNewUSKey)
-           *phNewUSKey = (HUSKEY)0;
-       return ret2;
-    }
-
-    TRACE("HUSKEY=0x%08lx\n", (LONG)ihky);
-    if (phNewUSKey)
-       *phNewUSKey = (HUSKEY)ihky;
-    return ERROR_SUCCESS;
+    return SHRegOpenUSKeyW(Path ? szPath : NULL, AccessType, hRelativeUSKey,
+                           phNewUSKey, fIgnoreHKCU);
 }
 
 /*************************************************************************
  * SHRegOpenUSKeyW     [SHLWAPI.@]
  *
- * Opens a user-specific registry key
+ * See SHRegOpenUSKeyA.
  */
-LONG WINAPI SHRegOpenUSKeyW(
-        LPCWSTR Path,
-        REGSAM AccessType,
-        HUSKEY hRelativeUSKey,
-        PHUSKEY phNewUSKey,
-        BOOL fIgnoreHKCU)
+LONG WINAPI SHRegOpenUSKeyW(LPCWSTR Path, REGSAM AccessType, HUSKEY hRelativeUSKey,
+                            PHUSKEY phNewUSKey, BOOL fIgnoreHKCU)
 {
-    HKEY openHKCUkey=0;
-    HKEY openHKLMkey=0;
     LONG ret2, ret1 = ~ERROR_SUCCESS;
-    LPInternal_HUSKEY ihky;
+    LPSHUSKEY hKey;
+
+    TRACE("(%s,0x%x,%p,%p,%d)\n", debugstr_w(Path),(LONG)AccessType,
+          hRelativeUSKey, phNewUSKey, fIgnoreHKCU);
+
+    if (phNewUSKey)
+        *phNewUSKey = NULL;
 
-    TRACE("(%s, 0x%lx, 0x%lx, %p, %s)\n", debugstr_w(Path),
-         (LONG)AccessType, (LONG)hRelativeUSKey, phNewUSKey,
-         (fIgnoreHKCU) ? "Ignoring HKCU" : "Process HKCU then HKLM");
+    /* Create internal HUSKEY */
+    hKey = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*hKey));
+    lstrcpynW(hKey->lpszPath, Path, sizeof(hKey->lpszPath)/sizeof(WCHAR));
 
-    /* now create the internal version of HUSKEY */
-    ihky = (LPInternal_HUSKEY)HeapAlloc(GetProcessHeap(), 0 ,
-                                       sizeof(Internal_HUSKEY));
-    lstrcpynW(ihky->key_string, Path, sizeof(ihky->key_string));
+    if (hRelativeUSKey)
+    {
+        hKey->HKCUstart = SHRegDuplicateHKey(REG_GetHKEYFromHUSKEY(hRelativeUSKey, REG_HKCU));
+        hKey->HKLMstart = SHRegDuplicateHKey(REG_GetHKEYFromHUSKEY(hRelativeUSKey, REG_HKLM));
 
-    if (hRelativeUSKey) {
-       openHKCUkey = ((LPInternal_HUSKEY)hRelativeUSKey)->HKCUkey;
-       openHKLMkey = ((LPInternal_HUSKEY)hRelativeUSKey)->HKLMkey;
+        /* FIXME: if either of these keys is NULL, create the start key from
+         *        the relative keys start+path
+         */
     }
-    else {
-       openHKCUkey = HKEY_CURRENT_USER;
-       openHKLMkey = HKEY_LOCAL_MACHINE;
+    else
+    {
+        hKey->HKCUstart = HKEY_CURRENT_USER;
+        hKey->HKLMstart = HKEY_LOCAL_MACHINE;
     }
 
-    ihky->HKCUkey = 0;
-    ihky->HKLMkey = 0;
-    if (!fIgnoreHKCU) {
-       ret1 = RegOpenKeyExW(openHKCUkey, Path,
-                           0, AccessType, &ihky->HKCUkey);
-       /* if successful, then save real starting point */
-       if (ret1 != ERROR_SUCCESS)
-           ihky->HKCUkey = 0;
+    if (!fIgnoreHKCU)
+    {
+        ret1 = RegOpenKeyExW(hKey->HKCUstart, hKey->lpszPath, 0, AccessType, &hKey->HKCUkey);
+        if (ret1)
+            hKey->HKCUkey = 0;
     }
-    ret2 = RegOpenKeyExW(openHKLMkey, Path,
-                       0, AccessType, &ihky->HKLMkey);
-    if (ret2 != ERROR_SUCCESS)
-       ihky->HKLMkey = 0;
-
-    if ((ret1 != ERROR_SUCCESS) || (ret2 != ERROR_SUCCESS))
-       TRACE("one or more opens failed: HKCU=%ld HKLM=%ld\n", ret1, ret2);
-
-    /* if all attempts have failed then bail */
-    if ((ret1 != ERROR_SUCCESS) && (ret2 != ERROR_SUCCESS)) {
-       HeapFree(GetProcessHeap(), 0, ihky);
-       if (phNewUSKey)
-           *phNewUSKey = (HUSKEY)0;
-       return ret2;
+
+    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=0x%08lx\n", (LONG)ihky);
+    TRACE("HUSKEY=%p\n", hKey);
     if (phNewUSKey)
-       *phNewUSKey = (HUSKEY)ihky;
+        *phNewUSKey = hKey;
     return ERROR_SUCCESS;
 }
 
 /*************************************************************************
  * SHRegCloseUSKey     [SHLWAPI.@]
  *
- * Closes a user-specific registry key
+ * Close a user-specific registry key
+ *
+ * RETURNS
+ *  Success: ERROR_SUCCESS
+ *  Failure: An error code from RegCloseKey().
  */
 LONG WINAPI SHRegCloseUSKey(
-        HUSKEY hUSKey)
+        HUSKEY hUSKey) /* [I] Key to close */
 {
-    LPInternal_HUSKEY mihk = (LPInternal_HUSKEY)hUSKey;
+    LPSHUSKEY hKey = hUSKey;
     LONG ret = ERROR_SUCCESS;
 
-    if (mihk->HKCUkey)
-       ret = RegCloseKey(mihk->HKCUkey);
-    if (mihk->HKLMkey)
-       ret = RegCloseKey(mihk->HKLMkey);
-    HeapFree(GetProcessHeap(), 0, mihk);
+    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,             /* [in]  */
-       LPCSTR pszValue,
-       LPDWORD pdwType,
-       LPVOID pvData,
-       LPDWORD pcbData,
-       BOOL fIgnoreHKCU,
-       LPVOID pvDefaultData,
-       DWORD dwDefaultDataSize)
+       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;
@@ -249,7 +378,7 @@ LONG WINAPI SHRegQueryUSValueA(
        if (!fIgnoreHKCU && (dokey = REG_GetHKEYFromHUSKEY(hUSKey,REG_HKCU))) {
            ret = RegQueryValueExA(dokey,
                                   pszValue, 0, pdwType, pvData, pcbData);
-           TRACE("HKCU RegQueryValue returned %08lx\n", ret);
+           TRACE("HKCU RegQueryValue returned %08x\n", ret);
        }
 
        /* if HKCU did not work and HKLM exists, then try it */
@@ -257,15 +386,15 @@ LONG WINAPI SHRegQueryUSValueA(
            (dokey = REG_GetHKEYFromHUSKEY(hUSKey,REG_HKLM))) {
            ret = RegQueryValueExA(dokey,
                                   pszValue, 0, pdwType, pvData, pcbData);
-           TRACE("HKLM RegQueryValue returned %08lx\n", ret);
+           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 = (CHAR*)pvDefaultData;
-               dst = (CHAR*)pvData;
+                src = pvDefaultData;
+                dst = pvData;
                for(i=0; i<maxmove; i++) *dst++ = *src++;
                *pcbData = maxmove;
                TRACE("setting default data\n");
@@ -278,9 +407,11 @@ LONG WINAPI SHRegQueryUSValueA(
 
 /*************************************************************************
  *      SHRegQueryUSValueW     [SHLWAPI.@]
+ *
+ * See SHRegQueryUSValueA.
  */
 LONG WINAPI SHRegQueryUSValueW(
-       HUSKEY hUSKey,             /* [in]  */
+       HUSKEY hUSKey,
        LPCWSTR pszValue,
        LPDWORD pdwType,
        LPVOID pvData,
@@ -298,7 +429,7 @@ LONG WINAPI SHRegQueryUSValueW(
        if (!fIgnoreHKCU && (dokey = REG_GetHKEYFromHUSKEY(hUSKey,REG_HKCU))) {
            ret = RegQueryValueExW(dokey,
                                   pszValue, 0, pdwType, pvData, pcbData);
-           TRACE("HKCU RegQueryValue returned %08lx\n", ret);
+           TRACE("HKCU RegQueryValue returned %08x\n", ret);
        }
 
        /* if HKCU did not work and HKLM exists, then try it */
@@ -306,15 +437,15 @@ LONG WINAPI SHRegQueryUSValueW(
            (dokey = REG_GetHKEYFromHUSKEY(hUSKey,REG_HKLM))) {
            ret = RegQueryValueExW(dokey,
                                   pszValue, 0, pdwType, pvData, pcbData);
-           TRACE("HKLM RegQueryValue returned %08lx\n", ret);
+           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 = (CHAR*)pvDefaultData;
-               dst = (CHAR*)pvData;
+                src = pvDefaultData;
+                dst = pvData;
                for(i=0; i<maxmove; i++) *dst++ = *src++;
                *pcbData = maxmove;
                TRACE("setting default data\n");
@@ -327,24 +458,30 @@ LONG WINAPI SHRegQueryUSValueW(
 /*************************************************************************
  * SHRegGetUSValueA    [SHLWAPI.@]
  *
- * Gets a user-specific registry value
- *   Will open the key, query the value, and close the key
+ * 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,
-       LPCSTR   pValue,
-       LPDWORD  pwType,
-       LPVOID   pvData,
-       LPDWORD  pcbData,
-       BOOL     flagIgnoreHKCU,
-       LPVOID   pDefaultData,
-       DWORD    wDefaultDataSize)
+       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 %ld,  %s\n",
+       TRACE("key '%s', value '%s', datalen %d,  %s\n",
              debugstr_a(pSubKey), debugstr_a(pValue), *pcbData,
              (flagIgnoreHKCU) ? "Ignoring HKCU" : "Tries HKCU then HKLM");
 
@@ -361,8 +498,7 @@ LONG WINAPI SHRegGetUSValueA(
 /*************************************************************************
  * SHRegGetUSValueW    [SHLWAPI.@]
  *
- * Gets a user-specific registry value
- *   Will open the key, query the value, and close the key
+ * See SHRegGetUSValueA.
  */
 LONG WINAPI SHRegGetUSValueW(
        LPCWSTR  pSubKey,
@@ -378,7 +514,7 @@ LONG WINAPI SHRegGetUSValueW(
        LONG ret;
 
        if (!pvData || !pcbData) return ERROR_INVALID_FUNCTION; /* FIXME:wrong*/
-       TRACE("key '%s', value '%s', datalen %ld,  %s\n",
+       TRACE("key '%s', value '%s', datalen %d,  %s\n",
              debugstr_w(pSubKey), debugstr_w(pValue), *pcbData,
              (flagIgnoreHKCU) ? "Ignoring HKCU" : "Tries HKCU then HKLM");
 
@@ -392,16 +528,104 @@ LONG WINAPI SHRegGetUSValueW(
        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,
-       LPCSTR pszValue,
-       BOOL fIgnoreHKCU,
-       BOOL fDefault)
+       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 */
 {
-       LONG retvalue;
        DWORD type, datalen, work;
        BOOL ret = fDefault;
        CHAR data[10];
@@ -411,9 +635,9 @@ BOOL WINAPI SHRegGetBoolUSValueA(
              (fIgnoreHKCU) ? "Ignoring HKCU" : "Tries HKCU then HKLM");
 
        datalen = sizeof(data)-1;
-       if (!(retvalue = SHRegGetUSValueA( pszSubKey, pszValue, &type,
-                                          data, &datalen,
-                                          fIgnoreHKCU, 0, 0))) {
+       if (!SHRegGetUSValueA( pszSubKey, pszValue, &type,
+                              data, &datalen,
+                              fIgnoreHKCU, 0, 0)) {
            /* process returned data via type into bool */
            switch (type) {
            case REG_SZ:
@@ -433,10 +657,10 @@ BOOL WINAPI SHRegGetBoolUSValueA(
                    break;
                }
            default:
-               FIXME("Unsupported registry data type %ld\n", type);
+               FIXME("Unsupported registry data type %d\n", type);
                ret = FALSE;
            }
-           TRACE("got value (type=%ld), returing <%s>\n", type,
+           TRACE("got value (type=%d), returning <%s>\n", type,
                  (ret) ? "TRUE" : "FALSE");
        }
        else {
@@ -449,6 +673,8 @@ BOOL WINAPI SHRegGetBoolUSValueA(
 
 /*************************************************************************
  * SHRegGetBoolUSValueW          [SHLWAPI.@]
+ *
+ * See SHRegGetBoolUSValueA.
  */
 BOOL WINAPI SHRegGetBoolUSValueW(
        LPCWSTR pszSubKey,
@@ -460,7 +686,6 @@ BOOL WINAPI SHRegGetBoolUSValueW(
        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'};
-       LONG retvalue;
        DWORD type, datalen, work;
        BOOL ret = fDefault;
        WCHAR data[10];
@@ -470,13 +695,13 @@ BOOL WINAPI SHRegGetBoolUSValueW(
              (fIgnoreHKCU) ? "Ignoring HKCU" : "Tries HKCU then HKLM");
 
        datalen = (sizeof(data)-1) * sizeof(WCHAR);
-       if (!(retvalue = SHRegGetUSValueW( pszSubKey, pszValue, &type,
-                                          data, &datalen,
-                                          fIgnoreHKCU, 0, 0))) {
+       if (!SHRegGetUSValueW( pszSubKey, pszValue, &type,
+                              data, &datalen,
+                              fIgnoreHKCU, 0, 0)) {
            /* process returned data via type into bool */
            switch (type) {
            case REG_SZ:
-               data[9] = L'\0';     /* set end of string */
+               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)
@@ -488,14 +713,14 @@ BOOL WINAPI SHRegGetBoolUSValueW(
                break;
            case REG_BINARY:
                if (datalen == 1) {
-                   ret = (data[0] != L'\0');
+                   ret = (data[0] != '\0');
                    break;
                }
            default:
-               FIXME("Unsupported registry data type %ld\n", type);
+               FIXME("Unsupported registry data type %d\n", type);
                ret = FALSE;
            }
-           TRACE("got value (type=%ld), returing <%s>\n", type,
+           TRACE("got value (type=%d), returning <%s>\n", type,
                  (ret) ? "TRUE" : "FALSE");
        }
        else {
@@ -508,20 +733,26 @@ BOOL WINAPI SHRegGetBoolUSValueW(
 
 /*************************************************************************
  *      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,             /* [in]  */
-       LPDWORD pcSubKeys,
-       LPDWORD pcchMaxSubKeyLen,
-       LPDWORD pcValues,
-       LPDWORD pcchMaxValueNameLen,
-       SHREGENUM_FLAGS enumRegFlags)
+       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("(0x%lx,%p,%p,%p,%p,%d)\n",
-             (LONG)hUSKey,pcSubKeys,pcchMaxSubKeyLen,pcValues,
+       TRACE("(%p,%p,%p,%p,%p,%d)\n",
+             hUSKey,pcSubKeys,pcchMaxSubKeyLen,pcValues,
              pcchMaxValueNameLen,enumRegFlags);
 
        /* if user wants HKCU, and it exists, then try it */
@@ -547,9 +778,11 @@ LONG WINAPI SHRegQueryInfoUSKeyA(
 
 /*************************************************************************
  *      SHRegQueryInfoUSKeyW   [SHLWAPI.@]
+ *
+ * See SHRegQueryInfoUSKeyA.
  */
 LONG WINAPI SHRegQueryInfoUSKeyW(
-       HUSKEY hUSKey,             /* [in]  */
+       HUSKEY hUSKey,
        LPDWORD pcSubKeys,
        LPDWORD pcchMaxSubKeyLen,
        LPDWORD pcValues,
@@ -559,8 +792,8 @@ LONG WINAPI SHRegQueryInfoUSKeyW(
        HKEY dokey;
        LONG ret;
 
-       TRACE("(0x%lx,%p,%p,%p,%p,%d)\n",
-             (LONG)hUSKey,pcSubKeys,pcchMaxSubKeyLen,pcValues,
+       TRACE("(%p,%p,%p,%p,%p,%d)\n",
+             hUSKey,pcSubKeys,pcchMaxSubKeyLen,pcValues,
              pcchMaxValueNameLen,enumRegFlags);
 
        /* if user wants HKCU, and it exists, then try it */
@@ -586,18 +819,24 @@ LONG WINAPI SHRegQueryInfoUSKeyW(
 
 /*************************************************************************
  *      SHRegEnumUSKeyA        [SHLWAPI.@]
+ *
+ * Enumerate a user-specific registry key.
+ *
+ * RETURNS
+ *  Success: ERROR_SUCCESS
+ *  Failure: An error code from RegEnumKeyExA().
  */
 LONG WINAPI SHRegEnumUSKeyA(
-       HUSKEY hUSKey,                 /* [in]  */
-       DWORD dwIndex,                 /* [in]  */
-       LPSTR pszName,                 /* [out] */
-       LPDWORD pcchValueNameLen,      /* [in/out] */
-       SHREGENUM_FLAGS enumRegFlags)  /* [in]  */
+       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("(0x%lx,%ld,%p,%p(%ld),%d)\n",
-             (LONG)hUSKey, dwIndex, pszName, pcchValueNameLen,
+       TRACE("(%p,%d,%p,%p(%d),%d)\n",
+             hUSKey, dwIndex, pszName, pcchValueNameLen,
              *pcchValueNameLen, enumRegFlags);
 
        if (((enumRegFlags == SHREGENUM_HKCU) ||
@@ -613,24 +852,26 @@ LONG WINAPI SHRegEnumUSKeyA(
            return RegEnumKeyExA(dokey, dwIndex, pszName, pcchValueNameLen,
                                0, 0, 0, 0);
        }
-       FIXME("no support for SHREGNUM_BOTH\n");
+       FIXME("no support for SHREGENUM_BOTH\n");
        return ERROR_INVALID_FUNCTION;
 }
 
 /*************************************************************************
  *      SHRegEnumUSKeyW        [SHLWAPI.@]
+ *
+ * See SHRegEnumUSKeyA.
  */
 LONG WINAPI SHRegEnumUSKeyW(
-       HUSKEY hUSKey,                 /* [in]  */
-       DWORD dwIndex,                 /* [in]  */
-       LPWSTR pszName,                /* [out] */
-       LPDWORD pcchValueNameLen,      /* [in/out] */
-       SHREGENUM_FLAGS enumRegFlags)  /* [in]  */
+       HUSKEY hUSKey,
+       DWORD dwIndex,
+       LPWSTR pszName,
+       LPDWORD pcchValueNameLen,
+       SHREGENUM_FLAGS enumRegFlags)
 {
        HKEY dokey;
 
-       TRACE("(0x%lx,%ld,%p,%p(%ld),%d)\n",
-             (LONG)hUSKey, dwIndex, pszName, pcchValueNameLen,
+       TRACE("(%p,%d,%p,%p(%d),%d)\n",
+             hUSKey, dwIndex, pszName, pcchValueNameLen,
              *pcchValueNameLen, enumRegFlags);
 
        if (((enumRegFlags == SHREGENUM_HKCU) ||
@@ -646,64 +887,116 @@ LONG WINAPI SHRegEnumUSKeyW(
            return RegEnumKeyExW(dokey, dwIndex, pszName, pcchValueNameLen,
                                0, 0, 0, 0);
        }
-       FIXME("no support for SHREGNUM_BOTH\n");
+       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)
+                                LPVOID pvData, DWORD cbData, DWORD dwFlags)
 {
-    HKEY dokey;
-
-    TRACE("(0x%lx,%s,%ld,%p,%ld,%ld)\n",
-         (LONG)hUSKey, debugstr_a(pszValue), dwType, pvData, cbData, dwFlags);
-
-    if ((dwFlags & SHREGSET_FORCE_HKCU) &&
-           (dokey = REG_GetHKEYFromHUSKEY(hUSKey,REG_HKCU))) {
-       RegSetValueExA(dokey, pszValue, 0, dwType, pvData, cbData);
-    }
-
-    if ((dwFlags & SHREGSET_FORCE_HKLM) &&
-           (dokey = REG_GetHKEYFromHUSKEY(hUSKey,REG_HKLM))) {
-       RegSetValueExA(dokey, pszValue, 0, dwType, pvData, cbData);
-    }
+    WCHAR szValue[MAX_PATH];
 
-    if (dwFlags & (SHREGSET_FORCE_HKCU | SHREGSET_FORCE_HKLM))
-       return ERROR_SUCCESS;
+    if (pszValue)
+      MultiByteToWideChar(CP_ACP, 0, pszValue, -1, szValue, MAX_PATH);
 
-    FIXME("SHREGSET_HKCU or SHREGSET_HKLM not supported\n");
-    return ERROR_SUCCESS;
+    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)
+                                LPVOID pvData, DWORD cbData, DWORD dwFlags)
 {
-    HKEY dokey;
+    DWORD dummy;
+    LPSHUSKEY hKey = hUSKey;
+    LONG ret = ERROR_SUCCESS;
 
-    TRACE("(0x%lx,%s,%ld,%p,%ld,%ld)\n",
-         (LONG)hUSKey, debugstr_w(pszValue), dwType, pvData, cbData, dwFlags);
+    TRACE("(%p,%s,%d,%p,%d,%d)\n", hUSKey, debugstr_w(pszValue),
+          dwType, pvData, cbData, dwFlags);
 
-    if ((dwFlags & SHREGSET_FORCE_HKCU) &&
-           (dokey = REG_GetHKEYFromHUSKEY(hUSKey,REG_HKCU))) {
-       RegSetValueExW(dokey, pszValue, 0, dwType, pvData, cbData);
-    }
+    if (!hUSKey || IsBadWritePtr(hUSKey, sizeof(SHUSKEY)) ||
+        !(dwFlags & (SHREGSET_FORCE_HKCU|SHREGSET_FORCE_HKLM)))
+        return ERROR_INVALID_PARAMETER;
 
-    if ((dwFlags & SHREGSET_FORCE_HKLM) &&
-           (dokey = REG_GetHKEYFromHUSKEY(hUSKey,REG_HKLM))) {
-       RegSetValueExW(dokey, pszValue, 0, dwType, pvData, cbData);
+    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_HKCU | SHREGSET_FORCE_HKLM))
-       return ERROR_SUCCESS;
+    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);
+            }
+        }
+    }
 
-    FIXME("SHREGSET_HKCU or SHREGSET_HKLM not supported\n");
-    return ERROR_SUCCESS;
+    return ret;
 }
 
 /*************************************************************************
@@ -720,14 +1013,14 @@ LONG  WINAPI SHRegWriteUSValueW(HUSKEY hUSKey, LPCWSTR pszValue, DWORD dwType,
  *
  * RETURNS
  *   Success: ERROR_SUCCESS. lpszPath contains the path.
- *   Failure: An error code from RegOpenKeyExA or SHQueryValueExA.
+ *   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=0x%08x,%s,%s,%p,%ld)\n", hKey, debugstr_a(lpszSubKey),
+  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);
@@ -743,7 +1036,7 @@ DWORD WINAPI SHRegGetPathW(HKEY hKey, LPCWSTR lpszSubKey, LPCWSTR lpszValue,
 {
   DWORD dwSize = MAX_PATH;
 
-  TRACE("(hkey=0x%08x,%s,%s,%p,%ld)\n", hKey, debugstr_w(lpszSubKey),
+  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);
@@ -760,18 +1053,18 @@ DWORD WINAPI SHRegGetPathW(HKEY hKey, LPCWSTR lpszSubKey, LPCWSTR lpszValue,
  *   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
+ *   dwFlags    [I] Reserved, must be 0.
  *
  * RETURNS
  *   Success: ERROR_SUCCESS.
- *   Failure: An error code from SHSetValueA.
+ *   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=0x%08x,%s,%s,%p,%ld) - semi-stub\n",hKey, debugstr_a(lpszSubKey),
+  FIXME("(hkey=%p,%s,%s,%p,%d) - semi-stub\n",hKey, debugstr_a(lpszSubKey),
         debugstr_a(lpszValue), lpszPath, dwFlags);
 
   lstrcpyA(szBuff, lpszPath);
@@ -792,7 +1085,7 @@ DWORD WINAPI SHRegSetPathW(HKEY hKey, LPCWSTR lpszSubKey, LPCWSTR lpszValue,
 {
   WCHAR szBuff[MAX_PATH];
 
-  FIXME("(hkey=0x%08x,%s,%s,%p,%ld) - semi-stub\n",hKey, debugstr_w(lpszSubKey),
+  FIXME("(hkey=%p,%s,%s,%p,%d) - semi-stub\n",hKey, debugstr_w(lpszSubKey),
         debugstr_w(lpszValue), lpszPath, dwFlags);
 
   lstrcpyW(szBuff, lpszPath);
@@ -818,7 +1111,7 @@ DWORD WINAPI SHRegSetPathW(HKEY hKey, LPCWSTR lpszSubKey, LPCWSTR lpszValue,
  *
  * RETURNS
  *   Success: ERROR_SUCCESS. Output parameters contain the details read.
- *   Failure: An error code from RegOpenKeyExA or SHQueryValueExA.
+ *   Failure: An error code from RegOpenKeyExA() or SHQueryValueExA().
  */
 DWORD WINAPI SHGetValueA(HKEY hKey, LPCSTR lpszSubKey, LPCSTR lpszValue,
                          LPDWORD pwType, LPVOID pvData, LPDWORD pcbData)
@@ -826,7 +1119,7 @@ DWORD WINAPI SHGetValueA(HKEY hKey, LPCSTR lpszSubKey, LPCSTR lpszValue,
   DWORD dwRet = 0;
   HKEY hSubKey = 0;
 
-  TRACE("(hkey=0x%08x,%s,%s,%p,%p,%p)\n", hKey, debugstr_a(lpszSubKey),
+  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
@@ -845,64 +1138,125 @@ DWORD WINAPI SHGetValueA(HKEY hKey, LPCSTR lpszSubKey, LPCSTR lpszValue,
 }
 
 /*************************************************************************
- * SHGetValueW   [SHLWAPI.@]
+ * SHRegGetValueA   [SHLWAPI.@]
  *
- * See SHGetValueA.
+ * 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 SHGetValueW(HKEY hKey, LPCWSTR lpszSubKey, LPCWSTR lpszValue,
+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=0x%08x,%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);
+  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)
   {
-    dwRet = SHQueryValueExW(hSubKey ? hSubKey : hKey, lpszValue, 0, pwType, pvData, pcbData);
-    if (hSubKey) RegCloseKey(hSubKey);
+    /* SHQueryValueEx expands Environment strings */
+    dwRet = SHQueryValueExA(hSubKey, lpszValue, 0, pwType, pvData, pcbData);
+    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
+ * SHReg GetRegValueW   [SHLWAPI.@]
  *
- * NOTES
- *   If the sub key does not exist, it is created before the value is set. If
- *   The sub key is NULL or an empty string, then the value is added directly
- *   to hKey instead.
+ * 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;
-  LPSTR szEmpty = "";
 
-  TRACE("(hkey=0x%08x,%s,%s,%ld,%p,%ld)\n", hKey, debugstr_a(lpszSubKey),
+  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, szEmpty,
+    dwRet = RegCreateKeyExA(hKey, lpszSubKey, 0, NULL,
                             0, KEY_SET_VALUE, NULL, &hSubKey, &dwDummy);
   else
     hSubKey = hKey;
@@ -925,13 +1279,12 @@ DWORD WINAPI SHSetValueW(HKEY hKey, LPCWSTR lpszSubKey, LPCWSTR lpszValue,
 {
   DWORD dwRet = ERROR_SUCCESS, dwDummy;
   HKEY  hSubKey;
-  WCHAR szEmpty[] = { '\0' };
 
-  TRACE("(hkey=0x%08x,%s,%s,%ld,%p,%ld)\n", hKey, debugstr_w(lpszSubKey),
+  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, szEmpty,
+    dwRet = RegCreateKeyExW(hKey, lpszSubKey, 0, NULL,
                             0, KEY_SET_VALUE, NULL, &hSubKey, &dwDummy);
   else
     hSubKey = hKey;
@@ -947,12 +1300,15 @@ DWORD WINAPI SHSetValueW(HKEY hKey, LPCWSTR lpszSubKey, LPCWSTR lpszValue,
 /*************************************************************************
  * SHQueryInfoKeyA   [SHLWAPI.@]
  *
- * Get information about a registry key. See RegQueryInfoKeyA.
+ * 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=0x%08x,%p,%p,%p,%p)\n", hKey, pwSubKeys, pwSubKeyMax,
+  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);
@@ -961,79 +1317,17 @@ LONG WINAPI SHQueryInfoKeyA(HKEY hKey, LPDWORD pwSubKeys, LPDWORD pwSubKeyMax,
 /*************************************************************************
  * SHQueryInfoKeyW   [SHLWAPI.@]
  *
- * See SHQueryInfoKeyA
+ * See SHQueryInfoKeyA.
  */
 LONG WINAPI SHQueryInfoKeyW(HKEY hKey, LPDWORD pwSubKeys, LPDWORD pwSubKeyMax,
                             LPDWORD pwValues, LPDWORD pwValueMax)
 {
-  TRACE("(hkey=0x%08x,%p,%p,%p,%p)\n", hKey, pwSubKeys, pwSubKeyMax,
+  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);
 }
 
-/*
-  DWORD dwRet, dwType, dwDataLen;
-
-  FIXME("(hkey=0x%08x,%s,%p,%p,%p,%p=%ld)\n", hKey, debugstr_a(lpszValue),
-        lpReserved, pwType, pvData, pcbData, pcbData ? *pcbData : 0);
-
-  if (pcbData) dwDataLen = *pcbData;
-
-  dwRet = RegQueryValueExA(hKey, lpszValue, lpReserved, &dwType, pvData, &dwDataLen);
-  if (!dwRet)
-  {
-    if (dwType == REG_EXPAND_SZ)
-    {
-      LPSTR szExpand;
-      LPBYTE pData = pvData;
-
-      if (!pData)
-      {
-        if (!pcbData || !(pData = (LPBYTE) LocalAlloc(GMEM_ZEROINIT, *pcbData)))
-          return ERROR_OUTOFMEMORY;
-
-        if ((dwRet = RegQueryValueExA (hKey, lpszValue, lpReserved, &dwType, pData, &dwDataLen)))
-          return dwRet;
-      }
-
-      if (!pcbData && pData != pvData)
-      {
-        WARN("Invalid pcbData would crash under Win32!\n");
-        return ERROR_OUTOFMEMORY;
-      }
-
-      szExpand = (LPBYTE) LocalAlloc(GMEM_ZEROINIT, *pcbData);
-      if (!szExpand)
-      {
-        if ( pData != pvData ) LocalFree((HLOCAL)pData);
-        return ERROR_OUTOFMEMORY;
-      }
-      if ((ExpandEnvironmentStringsA(pvData, szExpand, *pcbData) > 0))
-      {
-        dwDataLen = strlen(szExpand) + 1;
-        strncpy(pvData, szExpand, *pcbData);
-      }
-      else
-      {
-        if ( pData != pvData ) LocalFree((HLOCAL)pData);
-        LocalFree((HLOCAL)szExpand);
-        return GetLastError();
-      }
-      if (pData != pvData) LocalFree((HLOCAL)pData);
-      LocalFree((HLOCAL)szExpand);
-      dwType = REG_SZ;
-    }
-    if (dwType == REG_SZ && pvData && pcbData && dwDataLen >= *pcbData)
-    {
-      ((LPBYTE) pvData)[*pcbData] = '\0';
-    }
-  }
-  if ( pwType ) *pwType = dwType;
-  if ( pcbData ) *pcbData = dwDataLen;
-  return dwRet;
-*/
-
 /*************************************************************************
  * SHQueryValueExA   [SHLWAPI.@]
  *
@@ -1048,11 +1342,11 @@ LONG WINAPI SHQueryInfoKeyW(HKEY hKey, LPDWORD pwSubKeys, LPDWORD pwSubKeyMax,
  *   pcbData    [O] Optional pointer updated with the values size
  *
  * RETURNS
- *   Success: ERROR_SUCCESS. Any non-NULL output parameters are updated with
+ *   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.
+ *            code from RegQueryValueExA() or ExpandEnvironmentStringsA().
  *
  * NOTES
  *   Either pwType, pvData or pcbData may be NULL if the caller doesn't want
@@ -1061,6 +1355,20 @@ LONG WINAPI SHQueryInfoKeyW(HKEY hKey, LPDWORD pwSubKeys, LPDWORD pwSubKeyMax,
  *   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,
@@ -1068,7 +1376,7 @@ DWORD WINAPI SHQueryValueExA( HKEY hKey, LPCSTR lpszValue,
 {
   DWORD dwRet, dwType, dwUnExpDataLen = 0, dwExpDataLen;
 
-  TRACE("(hkey=0x%08x,%s,%p,%p,%p,%p=%ld)\n", hKey, debugstr_a(lpszValue),
+  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;
@@ -1082,29 +1390,29 @@ DWORD WINAPI SHQueryValueExA( HKEY hKey, LPCSTR lpszValue,
     /* Expand type REG_EXPAND_SZ into REG_SZ */
     LPSTR szData;
 
-    /* If the caller didn't supply a buffer or the buffer is to small we have
+    /* 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 = (!pvData || (dwRet == ERROR_MORE_DATA)) ? dwUnExpDataLen : *pcbData;
+      nBytesToAlloc = dwUnExpDataLen;
 
-      szData = (LPSTR) LocalAlloc(GMEM_ZEROINIT, nBytesToAlloc);
+      szData = LocalAlloc(LMEM_ZEROINIT, nBytesToAlloc);
       RegQueryValueExA (hKey, lpszValue, lpReserved, NULL, (LPBYTE)szData, &nBytesToAlloc);
       dwExpDataLen = ExpandEnvironmentStringsA(szData, &cNull, 1);
       dwUnExpDataLen = max(nBytesToAlloc, dwExpDataLen);
-      LocalFree((HLOCAL) szData);
+      LocalFree(szData);
     }
     else
     {
-      nBytesToAlloc = lstrlenA(pvData) * sizeof (CHAR);
-      szData = (LPSTR) LocalAlloc(GMEM_ZEROINIT, nBytesToAlloc + 1);
+      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((HLOCAL) szData);
+      LocalFree(szData);
     }
   }
 
@@ -1127,12 +1435,14 @@ DWORD WINAPI SHQueryValueExW(HKEY hKey, LPCWSTR lpszValue,
 {
   DWORD dwRet, dwType, dwUnExpDataLen = 0, dwExpDataLen;
 
-  TRACE("(hkey=0x%08x,%s,%p,%p,%p,%p=%ld)\n", hKey, debugstr_w(lpszValue),
+  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))
   {
@@ -1141,29 +1451,29 @@ DWORD WINAPI SHQueryValueExW(HKEY hKey, LPCWSTR lpszValue,
     /* Expand type REG_EXPAND_SZ into REG_SZ */
     LPWSTR szData;
 
-    /* If the caller didn't supply a buffer or the buffer is to small we have
+    /* 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 = (!pvData || (dwRet == ERROR_MORE_DATA)) ? dwUnExpDataLen : *pcbData;
+      nBytesToAlloc = dwUnExpDataLen;
 
-      szData = (LPWSTR) LocalAlloc(GMEM_ZEROINIT, nBytesToAlloc);
+      szData = LocalAlloc(LMEM_ZEROINIT, nBytesToAlloc);
       RegQueryValueExW (hKey, lpszValue, lpReserved, NULL, (LPBYTE)szData, &nBytesToAlloc);
       dwExpDataLen = ExpandEnvironmentStringsW(szData, &cNull, 1);
       dwUnExpDataLen = max(nBytesToAlloc, dwExpDataLen);
-      LocalFree((HLOCAL) szData);
+      LocalFree(szData);
     }
     else
     {
-      nBytesToAlloc = lstrlenW(pvData) * sizeof(WCHAR);
-      szData = (LPWSTR) LocalAlloc(GMEM_ZEROINIT, nBytesToAlloc + 1);
+      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((HLOCAL) szData);
+      LocalFree(szData);
     }
   }
 
@@ -1179,58 +1489,24 @@ DWORD WINAPI SHQueryValueExW(HKEY hKey, LPCWSTR lpszValue,
  *
  * 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.
+ *   Failure: An error code from RegOpenKeyExA(), RegQueryInfoKeyA(),
+ *            RegEnumKeyExA() or RegDeleteKeyA().
  */
 DWORD WINAPI SHDeleteKeyA(HKEY hKey, LPCSTR lpszSubKey)
 {
-  DWORD dwRet, dwKeyCount = 0, dwMaxSubkeyLen = 0, dwSize, i;
-  CHAR szNameBuf[MAX_PATH], *lpszName = szNameBuf;
-  HKEY hSubKey = 0;
-
-  TRACE("(hkey=0x%08x,%s)\n", hKey, debugstr_a(lpszSubKey));
-
-  dwRet = RegOpenKeyExA(hKey, lpszSubKey, 0, KEY_READ, &hSubKey);
-  if(!dwRet)
-  {
-    /* Find how many subkeys there are */
-    dwRet = RegQueryInfoKeyA(hSubKey, NULL, NULL, NULL, &dwKeyCount,
-                             &dwMaxSubkeyLen, NULL, NULL, NULL, NULL, NULL, NULL);
-    if(!dwRet)
-    {
-      dwMaxSubkeyLen++;
-      if (dwMaxSubkeyLen > sizeof(szNameBuf))
-        /* Name too big: alloc a buffer for it */
-        lpszName = HeapAlloc(GetProcessHeap(), 0, dwMaxSubkeyLen*sizeof(CHAR));
+  WCHAR subkeyW[MAX_PATH];
 
-      if(!lpszName)
-        dwRet = ERROR_NOT_ENOUGH_MEMORY;
-      else
-      {
-        /* Recursively delete all the subkeys */
-        for(i = 0; i < dwKeyCount && !dwRet; i++)
-        {
-          dwSize = dwMaxSubkeyLen;
-          dwRet = RegEnumKeyExA(hSubKey, i, lpszName, &dwSize, NULL, NULL, NULL, NULL);
-          if(!dwRet)
-            dwRet = SHDeleteKeyA(hSubKey, lpszName);
-        }
-        if (lpszName != szNameBuf)
-          HeapFree(GetProcessHeap(), 0, lpszName); /* Free buffer if allocated */
-      }
-    }
-
-    RegCloseKey(hSubKey);
-    if(!dwRet)
-      dwRet = RegDeleteKeyA(hKey, lpszSubKey);
-  }
-  return dwRet;
+  MultiByteToWideChar (CP_ACP, 0, lpszSubKey, -1, subkeyW, sizeof(subkeyW)/sizeof(WCHAR));
+  return SHDeleteKeyW(hKey, subkeyW);
 }
 
 /*************************************************************************
@@ -1240,17 +1516,17 @@ DWORD WINAPI SHDeleteKeyA(HKEY hKey, LPCSTR lpszSubKey)
  */
 DWORD WINAPI SHDeleteKeyW(HKEY hKey, LPCWSTR lpszSubKey)
 {
-  DWORD dwRet, dwKeyCount = 0, dwMaxSubkeyLen = 0, dwSize, i;
+  DWORD dwRet, dwMaxSubkeyLen = 0, dwSize;
   WCHAR szNameBuf[MAX_PATH], *lpszName = szNameBuf;
   HKEY hSubKey = 0;
 
-  TRACE("(hkey=0x%08x,%s)\n", hKey, debugstr_w(lpszSubKey));
+  TRACE("(hkey=%p,%s)\n", hKey, debugstr_w(lpszSubKey));
 
   dwRet = RegOpenKeyExW(hKey, lpszSubKey, 0, KEY_READ, &hSubKey);
   if(!dwRet)
   {
-    /* Find how many subkeys there are */
-    dwRet = RegQueryInfoKeyW(hSubKey, NULL, NULL, NULL, &dwKeyCount,
+    /* 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)
     {
@@ -1263,15 +1539,16 @@ DWORD WINAPI SHDeleteKeyW(HKEY hKey, LPCWSTR lpszSubKey)
         dwRet = ERROR_NOT_ENOUGH_MEMORY;
       else
       {
-        /* Recursively delete all the subkeys */
-        for(i = 0; i < dwKeyCount && !dwRet; i++)
+        while (dwRet == ERROR_SUCCESS)
         {
           dwSize = dwMaxSubkeyLen;
-          dwRet = RegEnumKeyExW(hSubKey, i, lpszName, &dwSize, NULL, NULL, NULL, NULL);
-          if(!dwRet)
+          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 */
       }
@@ -1296,15 +1573,15 @@ DWORD WINAPI SHDeleteKeyW(HKEY hKey, LPCWSTR lpszSubKey)
  * 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.
+ *            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=0x%08x,%s)\n", hKey, debugstr_a(lpszSubKey));
+  TRACE("(hkey=%p,%s)\n", hKey, debugstr_a(lpszSubKey));
 
   dwRet = RegOpenKeyExA(hKey, lpszSubKey, 0, KEY_READ, &hSubKey);
   if(!dwRet)
@@ -1333,7 +1610,7 @@ DWORD WINAPI SHDeleteEmptyKeyW(HKEY hKey, LPCWSTR lpszSubKey)
   DWORD dwRet, dwKeyCount = 0;
   HKEY hSubKey = 0;
 
-  TRACE("(hkey=0x%08x, %s)\n", hKey, debugstr_w(lpszSubKey));
+  TRACE("(hkey=%p, %s)\n", hKey, debugstr_w(lpszSubKey));
 
   dwRet = RegOpenKeyExW(hKey, lpszSubKey, 0, KEY_READ, &hSubKey);
   if(!dwRet)
@@ -1363,14 +1640,14 @@ DWORD WINAPI SHDeleteEmptyKeyW(HKEY hKey, LPCWSTR lpszSubKey)
  *
  * RETURNS
  *   Success: ERROR_SUCCESS. The key has been deleted if it was an orphan.
- *   Failure: An error from RegOpenKeyExA, RegQueryValueExA, or RegDeleteKeyA.
+ *   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=0x%08x,%s)\n", hKey, debugstr_a(lpszSubKey));
+  TRACE("(hkey=%p,%s)\n", hKey, debugstr_a(lpszSubKey));
 
   dwRet = RegOpenKeyExA(hKey, lpszSubKey, 0, KEY_READ, &hSubKey);
 
@@ -1399,7 +1676,7 @@ DWORD WINAPI SHDeleteOrphanKeyW(HKEY hKey, LPCWSTR lpszSubKey)
   HKEY hSubKey;
   DWORD dwKeyCount = 0, dwValueCount = 0, dwRet;
 
-  TRACE("(hkey=0x%08x,%s)\n", hKey, debugstr_w(lpszSubKey));
+  TRACE("(hkey=%p,%s)\n", hKey, debugstr_w(lpszSubKey));
 
   dwRet = RegOpenKeyExW(hKey, lpszSubKey, 0, KEY_READ, &hSubKey);
 
@@ -1430,14 +1707,14 @@ DWORD WINAPI SHDeleteOrphanKeyW(HKEY hKey, LPCWSTR lpszSubKey)
  *
  * RETURNS
  *   Success: ERROR_SUCCESS. The value is deleted.
- *   Failure: An error code from RegOpenKeyExA or RegDeleteValueA.
+ *   Failure: An error code from RegOpenKeyExA() or RegDeleteValueA().
  */
 DWORD WINAPI SHDeleteValueA(HKEY hKey, LPCSTR lpszSubKey, LPCSTR lpszValue)
 {
   DWORD dwRet;
   HKEY hSubKey;
 
-  TRACE("(hkey=0x%08x,%s,%s)\n", hKey, debugstr_a(lpszSubKey), debugstr_a(lpszValue));
+  TRACE("(hkey=%p,%s,%s)\n", hKey, debugstr_a(lpszSubKey), debugstr_a(lpszValue));
 
   dwRet = RegOpenKeyExA(hKey, lpszSubKey, 0, KEY_SET_VALUE, &hSubKey);
   if (!dwRet)
@@ -1458,7 +1735,7 @@ DWORD WINAPI SHDeleteValueW(HKEY hKey, LPCWSTR lpszSubKey, LPCWSTR lpszValue)
   DWORD dwRet;
   HKEY hSubKey;
 
-  TRACE("(hkey=0x%08x,%s,%s)\n", hKey, debugstr_w(lpszSubKey), debugstr_w(lpszValue));
+  TRACE("(hkey=%p,%s,%s)\n", hKey, debugstr_w(lpszSubKey), debugstr_w(lpszValue));
 
   dwRet = RegOpenKeyExW(hKey, lpszSubKey, 0, KEY_SET_VALUE, &hSubKey);
   if (!dwRet)
@@ -1480,14 +1757,14 @@ DWORD WINAPI SHDeleteValueW(HKEY hKey, LPCWSTR lpszSubKey, LPCWSTR lpszValue)
  *   lpszSubKey [O] Pointer updated with the subkey name
  *   pwLen      [O] Pointer updated with the subkey length
  *
- * RETURN
+ * RETURNS
  *   Success: ERROR_SUCCESS. lpszSubKey and pwLen are updated.
- *   Failure: An error code from RegEnumKeyExA.
+ *   Failure: An error code from RegEnumKeyExA().
  */
 LONG WINAPI SHEnumKeyExA(HKEY hKey, DWORD dwIndex, LPSTR lpszSubKey,
                          LPDWORD pwLen)
 {
-  TRACE("(hkey=0x%08x,%ld,%s,%p)\n", hKey, dwIndex, debugstr_a(lpszSubKey), pwLen);
+  TRACE("(hkey=%p,%d,%s,%p)\n", hKey, dwIndex, debugstr_a(lpszSubKey), pwLen);
 
   return RegEnumKeyExA(hKey, dwIndex, lpszSubKey, pwLen, NULL, NULL, NULL, NULL);
 }
@@ -1500,7 +1777,7 @@ LONG WINAPI SHEnumKeyExA(HKEY hKey, DWORD dwIndex, LPSTR lpszSubKey,
 LONG WINAPI SHEnumKeyExW(HKEY hKey, DWORD dwIndex, LPWSTR lpszSubKey,
                          LPDWORD pwLen)
 {
-  TRACE("(hkey=0x%08x,%ld,%s,%p)\n", hKey, dwIndex, debugstr_w(lpszSubKey), pwLen);
+  TRACE("(hkey=%p,%d,%s,%p)\n", hKey, dwIndex, debugstr_w(lpszSubKey), pwLen);
 
   return RegEnumKeyExW(hKey, dwIndex, lpszSubKey, pwLen, NULL, NULL, NULL, NULL);
 }
@@ -1521,17 +1798,17 @@ LONG WINAPI SHEnumKeyExW(HKEY hKey, DWORD dwIndex, LPWSTR lpszSubKey,
  *
  * RETURNS
  *   Success: ERROR_SUCCESS. Output parameters are updated.
- *   Failure: An error code from RegEnumValueExA.
+ *   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=0x%08x,%ld,%s,%p,%p,%p,%p)\n", hKey, dwIndex,
+  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);
 return RegEnumValueA(hKey, dwIndex, lpszValue, pwLen, NULL,
+                       pwType, pvData, pcbData);
 }
 
 /*************************************************************************
@@ -1543,7 +1820,7 @@ LONG WINAPI SHEnumValueW(HKEY hKey, DWORD dwIndex, LPWSTR lpszValue,
                          LPDWORD pwLen, LPDWORD pwType,
                          LPVOID pvData, LPDWORD pcbData)
 {
-  TRACE("(hkey=0x%08x,%ld,%s,%p,%p,%p,%p)\n", hKey, dwIndex,
+  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,
@@ -1553,9 +1830,22 @@ LONG WINAPI SHEnumValueW(HKEY hKey, DWORD dwIndex, LPWSTR lpszValue,
 /*************************************************************************
  * @   [SHLWAPI.205]
  *
- * Wrapper for SHGetValueA in case machine is in safe mode.
+ * 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 SHLWAPI_205(HKEY hkey, LPCSTR pSubKey, LPCSTR pValue,
+DWORD WINAPI SHGetValueGoodBootA(HKEY hkey, LPCSTR pSubKey, LPCSTR pValue,
                          LPDWORD pwType, LPVOID pvData, LPDWORD pbData)
 {
   if (GetSystemMetrics(SM_CLEANBOOT))
@@ -1566,9 +1856,9 @@ DWORD WINAPI SHLWAPI_205(HKEY hkey, LPCSTR pSubKey, LPCSTR pValue,
 /*************************************************************************
  * @   [SHLWAPI.206]
  *
- * Unicode version of SHLWAPI_205.
+ * Unicode version of SHGetValueGoodBootW.
  */
-DWORD WINAPI SHLWAPI_206(HKEY hkey, LPCWSTR pSubKey, LPCWSTR pValue,
+DWORD WINAPI SHGetValueGoodBootW(HKEY hkey, LPCWSTR pSubKey, LPCWSTR pValue,
                          LPDWORD pwType, LPVOID pvData, LPDWORD pbData)
 {
   if (GetSystemMetrics(SM_CLEANBOOT))
@@ -1579,18 +1869,17 @@ DWORD WINAPI SHLWAPI_206(HKEY hkey, LPCWSTR pSubKey, LPCWSTR pValue,
 /*************************************************************************
  * @   [SHLWAPI.320]
  *
- * Set a content type in the registry.
+ * Set a MIME content type in the registry.
  *
  * PARAMS
- *   hKey       [I] Handle to registry key
- *   lpszSubKey [I] Name of sub key under hKey
+ *   lpszSubKey [I] Name of key under HKEY_CLASSES_ROOT.
  *   lpszValue  [I] Value to set
  *
  * RETURNS
  *   Success: TRUE
  *   Failure: FALSE
  */
-BOOL WINAPI SHLWAPI_320(LPCSTR lpszSubKey, LPCSTR lpszValue)
+BOOL WINAPI RegisterMIMETypeForExtensionA(LPCSTR lpszSubKey, LPCSTR lpszValue)
 {
   DWORD dwRet;
 
@@ -1608,9 +1897,9 @@ BOOL WINAPI SHLWAPI_320(LPCSTR lpszSubKey, LPCSTR lpszValue)
 /*************************************************************************
  * @   [SHLWAPI.321]
  *
- * Unicode version of SHLWAPI_320.
+ * Unicode version of RegisterMIMETypeForExtensionA.
  */
-BOOL WINAPI SHLWAPI_321(LPCWSTR lpszSubKey, LPCWSTR lpszValue)
+BOOL WINAPI RegisterMIMETypeForExtensionW(LPCWSTR lpszSubKey, LPCWSTR lpszValue)
 {
   DWORD dwRet;
 
@@ -1628,7 +1917,7 @@ BOOL WINAPI SHLWAPI_321(LPCWSTR lpszSubKey, LPCWSTR lpszValue)
 /*************************************************************************
  * @   [SHLWAPI.322]
  *
- * Delete a content type from the registry.
+ * Delete a MIME content type from the registry.
  *
  * PARAMS
  *   lpszSubKey [I] Name of sub key
@@ -1637,7 +1926,7 @@ BOOL WINAPI SHLWAPI_321(LPCWSTR lpszSubKey, LPCWSTR lpszValue)
  *   Success: TRUE
  *   Failure: FALSE
  */
-BOOL WINAPI SHLWAPI_322(LPCSTR lpszSubKey)
+BOOL WINAPI UnregisterMIMETypeForExtensionA(LPCSTR lpszSubKey)
 {
   HRESULT ret = SHDeleteValueA(HKEY_CLASSES_ROOT, lpszSubKey, lpszContentTypeA);
   return ret ? FALSE : TRUE;
@@ -1646,23 +1935,528 @@ BOOL WINAPI SHLWAPI_322(LPCSTR lpszSubKey)
 /*************************************************************************
  * @   [SHLWAPI.323]
  *
- * Unicode version of SHLWAPI_322.
+ * Unicode version of UnregisterMIMETypeForExtensionA.
  */
-BOOL WINAPI SHLWAPI_323(LPCWSTR lpszSubKey)
+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 %08x\n", 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;
+}