git.oblomov.eu Git - wine/blob - dlls/shlwapi/reg.c

   1 /*
   2  * SHLWAPI registry functions
   3  */
   4
   5 #include <string.h>
   6 #include "windef.h"
   7 #include "winbase.h"
   8 #include "wingdi.h"
   9 #include "winuser.h"
  10 #include "winerror.h"
  11 #include "winnls.h"
  12 #include "winreg.h"
  13 #include "debugtools.h"
  14 #define NO_SHLWAPI_STREAM
  15 #include "shlwapi.h"
  16 #include "wine/unicode.h"
  17
  18 DEFAULT_DEBUG_CHANNEL(shell);
  19
  20 typedef DWORD (WINAPI *RegQueryFn)(HKEY,LPCVOID,LPDWORD,LPDWORD,LPBYTE,LPDWORD);
  21
  22 static const char *lpszContentTypeA = "Content Type";
  23 static const WCHAR lpszContentTypeW[] = { 'C','o','n','t','e','n','t',' ','T','y','p','e','\0'};
  24
  25 /* internal structure of what the HUSKEY points to */
  26 typedef struct {
  27     HKEY     HKCUkey;                  /* HKEY of opened HKCU key      */
  28     HKEY     HKLMkey;                  /* HKEY of opened HKLM key      */
  29     HKEY     start;                    /* HKEY of where to start       */
  30     WCHAR    key_string[MAX_PATH];     /* additional path from 'start' */
  31 } Internal_HUSKEY, *LPInternal_HUSKEY;
  32
  33
  34 #define REG_HKCU  TRUE
  35 #define REG_HKLM  FALSE
  36 /*************************************************************************
  37  * REG_GetHKEYFromHUSKEY
  38  *
  39  * Function:  Return the proper registry key from the HUSKEY structure
  40  *            also allow special predefined values.
  41  */
  42 HKEY REG_GetHKEYFromHUSKEY(HUSKEY hUSKey, BOOL which)
  43 {
  44         HKEY test = (HKEY) hUSKey;
  45         LPInternal_HUSKEY mihk = (LPInternal_HUSKEY) hUSKey;
  46
  47         if ((test == HKEY_CLASSES_ROOT)        ||
  48             (test == HKEY_CURRENT_CONFIG)      ||
  49             (test == HKEY_CURRENT_USER)        ||
  50             (test == HKEY_DYN_DATA)            ||
  51             (test == HKEY_LOCAL_MACHINE)       ||
  52             (test == HKEY_PERFORMANCE_DATA)    ||
  53 /* FIXME:  need to define for Win2k, ME, XP
  54  *          (test == HKEY_PERFORMANCE_TEXT)    ||
  55  *          (test == HKEY_PERFORMANCE_NLSTEXT) ||
  56  */
  57             (test == HKEY_USERS)) return test;
  58         if (which == REG_HKCU) return mihk->HKCUkey;
  59         return mihk->HKLMkey;
  60 }
  61
  62
  63 /*************************************************************************
  64  * SHRegOpenUSKeyA      [SHLWAPI.@]
  65  *
  66  * Opens a user-specific registry key
  67  */
  68 LONG WINAPI SHRegOpenUSKeyA(
  69         LPCSTR Path,
  70         REGSAM AccessType,
  71         HUSKEY hRelativeUSKey,
  72         PHUSKEY phNewUSKey,
  73         BOOL fIgnoreHKCU)
  74 {
  75     HKEY openHKCUkey=0;
  76     HKEY openHKLMkey=0;
  77     LONG ret2, ret1 = ~ERROR_SUCCESS;
  78     LPInternal_HUSKEY ihky;
  79
  80     TRACE("(%s, 0x%lx, 0x%lx, %p, %s)\n", debugstr_a(Path),
  81           (LONG)AccessType, (LONG)hRelativeUSKey, phNewUSKey,
  82           (fIgnoreHKCU) ? "Ignoring HKCU" : "Process HKCU then HKLM");
  83
  84     /* now create the internal version of HUSKEY */
  85     ihky = (LPInternal_HUSKEY)HeapAlloc(GetProcessHeap(), 0 ,
  86                                         sizeof(Internal_HUSKEY));
  87     MultiByteToWideChar(0, 0, Path, -1, ihky->key_string,
  88                         sizeof(ihky->key_string)-1);
  89
  90     if (hRelativeUSKey) {
  91         openHKCUkey = ((LPInternal_HUSKEY)hRelativeUSKey)->HKCUkey;
  92         openHKLMkey = ((LPInternal_HUSKEY)hRelativeUSKey)->HKLMkey;
  93     }
  94     else {
  95         openHKCUkey = HKEY_CURRENT_USER;
  96         openHKLMkey = HKEY_LOCAL_MACHINE;
  97     }
  98
  99     ihky->HKCUkey = 0;
 100     ihky->HKLMkey = 0;
 101     if (!fIgnoreHKCU) {
 102         ret1 = RegOpenKeyExA(openHKCUkey, Path,
 103                              0, AccessType, &ihky->HKCUkey);
 104         /* if successful, then save real starting point */
 105         if (ret1 != ERROR_SUCCESS)
 106             ihky->HKCUkey = 0;
 107     }
 108     ret2 = RegOpenKeyExA(openHKLMkey, Path,
 109                          0, AccessType, &ihky->HKLMkey);
 110     if (ret2 != ERROR_SUCCESS)
 111         ihky->HKLMkey = 0;
 112
 113     if ((ret1 != ERROR_SUCCESS) || (ret2 != ERROR_SUCCESS))
 114         TRACE("one or more opens failed: HKCU=%ld HKLM=%ld\n", ret1, ret2);
 115
 116     /* if all attempts have failed then bail */
 117     if ((ret1 != ERROR_SUCCESS) && (ret2 != ERROR_SUCCESS)) {
 118         HeapFree(GetProcessHeap(), 0, ihky);
 119         if (phNewUSKey)
 120             *phNewUSKey = (HUSKEY)0;
 121         return ret2;
 122     }
 123
 124     TRACE("HUSKEY=0x%08lx\n", (LONG)ihky);
 125     if (phNewUSKey)
 126         *phNewUSKey = (HUSKEY)ihky;
 127     return ERROR_SUCCESS;
 128 }
 129
 130 /*************************************************************************
 131  * SHRegOpenUSKeyW      [SHLWAPI.@]
 132  *
 133  * Opens a user-specific registry key
 134  */
 135 LONG WINAPI SHRegOpenUSKeyW(
 136         LPCWSTR Path,
 137         REGSAM AccessType,
 138         HUSKEY hRelativeUSKey,
 139         PHUSKEY phNewUSKey,
 140         BOOL fIgnoreHKCU)
 141 {
 142     HKEY openHKCUkey=0;
 143     HKEY openHKLMkey=0;
 144     LONG ret2, ret1 = ~ERROR_SUCCESS;
 145     LPInternal_HUSKEY ihky;
 146
 147     TRACE("(%s, 0x%lx, 0x%lx, %p, %s)\n", debugstr_w(Path),
 148           (LONG)AccessType, (LONG)hRelativeUSKey, phNewUSKey,
 149           (fIgnoreHKCU) ? "Ignoring HKCU" : "Process HKCU then HKLM");
 150
 151     /* now create the internal version of HUSKEY */
 152     ihky = (LPInternal_HUSKEY)HeapAlloc(GetProcessHeap(), 0 ,
 153                                         sizeof(Internal_HUSKEY));
 154     lstrcpynW(ihky->key_string, Path, sizeof(ihky->key_string));
 155
 156     if (hRelativeUSKey) {
 157         openHKCUkey = ((LPInternal_HUSKEY)hRelativeUSKey)->HKCUkey;
 158         openHKLMkey = ((LPInternal_HUSKEY)hRelativeUSKey)->HKLMkey;
 159     }
 160     else {
 161         openHKCUkey = HKEY_CURRENT_USER;
 162         openHKLMkey = HKEY_LOCAL_MACHINE;
 163     }
 164
 165     ihky->HKCUkey = 0;
 166     ihky->HKLMkey = 0;
 167     if (!fIgnoreHKCU) {
 168         ret1 = RegOpenKeyExW(openHKCUkey, Path,
 169                             0, AccessType, &ihky->HKCUkey);
 170         /* if successful, then save real starting point */
 171         if (ret1 != ERROR_SUCCESS)
 172             ihky->HKCUkey = 0;
 173     }
 174     ret2 = RegOpenKeyExW(openHKLMkey, Path,
 175                         0, AccessType, &ihky->HKLMkey);
 176     if (ret2 != ERROR_SUCCESS)
 177         ihky->HKLMkey = 0;
 178
 179     if ((ret1 != ERROR_SUCCESS) || (ret2 != ERROR_SUCCESS))
 180         TRACE("one or more opens failed: HKCU=%ld HKLM=%ld\n", ret1, ret2);
 181
 182     /* if all attempts have failed then bail */
 183     if ((ret1 != ERROR_SUCCESS) && (ret2 != ERROR_SUCCESS)) {
 184         HeapFree(GetProcessHeap(), 0, ihky);
 185         if (phNewUSKey)
 186             *phNewUSKey = (HUSKEY)0;
 187         return ret2;
 188     }
 189
 190     TRACE("HUSKEY=0x%08lx\n", (LONG)ihky);
 191     if (phNewUSKey)
 192         *phNewUSKey = (HUSKEY)ihky;
 193     return ERROR_SUCCESS;
 194 }
 195
 196 /*************************************************************************
 197  * SHRegCloseUSKey      [SHLWAPI.@]
 198  *
 199  * Closes a user-specific registry key
 200  */
 201 LONG WINAPI SHRegCloseUSKey(
 202         HUSKEY hUSKey)
 203 {
 204     LPInternal_HUSKEY mihk = (LPInternal_HUSKEY)hUSKey;
 205     LONG ret = ERROR_SUCCESS;
 206
 207     if (mihk->HKCUkey)
 208         ret = RegCloseKey(mihk->HKCUkey);
 209     if (mihk->HKLMkey)
 210         ret = RegCloseKey(mihk->HKLMkey);
 211     HeapFree(GetProcessHeap(), 0, mihk);
 212     return ret;
 213 }
 214
 215 /*************************************************************************
 216  *      SHRegQueryUSValueA      [SHLWAPI.@]
 217  */
 218 LONG WINAPI SHRegQueryUSValueA(
 219         HUSKEY hUSKey,             /* [in]  */
 220         LPCSTR pszValue,
 221         LPDWORD pdwType,
 222         LPVOID pvData,
 223         LPDWORD pcbData,
 224         BOOL fIgnoreHKCU,
 225         LPVOID pvDefaultData,
 226         DWORD dwDefaultDataSize)
 227 {
 228         LONG ret = ~ERROR_SUCCESS;
 229         LONG i, maxmove;
 230         HKEY dokey;
 231         CHAR *src, *dst;
 232
 233         /* if user wants HKCU, and it exists, then try it */
 234         if (!fIgnoreHKCU && (dokey = REG_GetHKEYFromHUSKEY(hUSKey,REG_HKCU))) {
 235             ret = RegQueryValueExA(dokey,
 236                                    pszValue, 0, pdwType, pvData, pcbData);
 237             TRACE("HKCU RegQueryValue returned %08lx\n", ret);
 238         }
 239
 240         /* if HKCU did not work and HKLM exists, then try it */
 241         if ((ret != ERROR_SUCCESS) &&
 242             (dokey = REG_GetHKEYFromHUSKEY(hUSKey,REG_HKLM))) {
 243             ret = RegQueryValueExA(dokey,
 244                                    pszValue, 0, pdwType, pvData, pcbData);
 245             TRACE("HKLM RegQueryValue returned %08lx\n", ret);
 246         }
 247
 248         /* if neither worked, and default data exists, then use it */
 249         if (ret != ERROR_SUCCESS) {
 250             if (pvDefaultData && (dwDefaultDataSize != 0)) {
 251                 maxmove = (dwDefaultDataSize >= *pcbData) ? *pcbData : dwDefaultDataSize;
 252                 src = (CHAR*)pvDefaultData;
 253                 dst = (CHAR*)pvData;
 254                 for(i=0; i<maxmove; i++) *dst++ = *src++;
 255                 *pcbData = maxmove;
 256                 TRACE("setting default data\n");
 257                 ret = ERROR_SUCCESS;
 258             }
 259         }
 260         return ret;
 261 }
 262
 263
 264 /*************************************************************************
 265  *      SHRegQueryUSValueW      [SHLWAPI.@]
 266  */
 267 LONG WINAPI SHRegQueryUSValueW(
 268         HUSKEY hUSKey,             /* [in]  */
 269         LPCWSTR pszValue,
 270         LPDWORD pdwType,
 271         LPVOID pvData,
 272         LPDWORD pcbData,
 273         BOOL fIgnoreHKCU,
 274         LPVOID pvDefaultData,
 275         DWORD dwDefaultDataSize)
 276 {
 277         LONG ret = ~ERROR_SUCCESS;
 278         LONG i, maxmove;
 279         HKEY dokey;
 280         CHAR *src, *dst;
 281
 282         /* if user wants HKCU, and it exists, then try it */
 283         if (!fIgnoreHKCU && (dokey = REG_GetHKEYFromHUSKEY(hUSKey,REG_HKCU))) {
 284             ret = RegQueryValueExW(dokey,
 285                                    pszValue, 0, pdwType, pvData, pcbData);
 286             TRACE("HKCU RegQueryValue returned %08lx\n", ret);
 287         }
 288
 289         /* if HKCU did not work and HKLM exists, then try it */
 290         if ((ret != ERROR_SUCCESS) &&
 291             (dokey = REG_GetHKEYFromHUSKEY(hUSKey,REG_HKLM))) {
 292             ret = RegQueryValueExW(dokey,
 293                                    pszValue, 0, pdwType, pvData, pcbData);
 294             TRACE("HKLM RegQueryValue returned %08lx\n", ret);
 295         }
 296
 297         /* if neither worked, and default data exists, then use it */
 298         if (ret != ERROR_SUCCESS) {
 299             if (pvDefaultData && (dwDefaultDataSize != 0)) {
 300                 maxmove = (dwDefaultDataSize >= *pcbData) ? *pcbData : dwDefaultDataSize;
 301                 src = (CHAR*)pvDefaultData;
 302                 dst = (CHAR*)pvData;
 303                 for(i=0; i<maxmove; i++) *dst++ = *src++;
 304                 *pcbData = maxmove;
 305                 TRACE("setting default data\n");
 306                 ret = ERROR_SUCCESS;
 307             }
 308         }
 309         return ret;
 310 }
 311
 312 /*************************************************************************
 313  * SHRegGetUSValueA     [SHLWAPI.@]
 314  *
 315  * Gets a user-specific registry value
 316  *   Will open the key, query the value, and close the key
 317  */
 318 LONG WINAPI SHRegGetUSValueA(
 319         LPCSTR   pSubKey,
 320         LPCSTR   pValue,
 321         LPDWORD  pwType,
 322         LPVOID   pvData,
 323         LPDWORD  pcbData,
 324         BOOL     flagIgnoreHKCU,
 325         LPVOID   pDefaultData,
 326         DWORD    wDefaultDataSize)
 327 {
 328         HUSKEY myhuskey;
 329         LONG ret;
 330
 331         if (!pvData || !pcbData) return ERROR_INVALID_FUNCTION; /* FIXME:wrong*/
 332         TRACE("key '%s', value '%s', datalen %ld,  %s\n",
 333               debugstr_a(pSubKey), debugstr_a(pValue), *pcbData,
 334               (flagIgnoreHKCU) ? "Ignoring HKCU" : "Tries HKCU then HKLM");
 335
 336         ret = SHRegOpenUSKeyA(pSubKey, 0x1, 0, &myhuskey, flagIgnoreHKCU);
 337         if (ret == ERROR_SUCCESS) {
 338             ret = SHRegQueryUSValueA(myhuskey, pValue, pwType, pvData,
 339                                      pcbData, flagIgnoreHKCU, pDefaultData,
 340                                      wDefaultDataSize);
 341             SHRegCloseUSKey(myhuskey);
 342         }
 343         return ret;
 344 }
 345
 346 /*************************************************************************
 347  * SHRegGetUSValueW     [SHLWAPI.@]
 348  *
 349  * Gets a user-specific registry value
 350  *   Will open the key, query the value, and close the key
 351  */
 352 LONG WINAPI SHRegGetUSValueW(
 353         LPCWSTR  pSubKey,
 354         LPCWSTR  pValue,
 355         LPDWORD  pwType,
 356         LPVOID   pvData,
 357         LPDWORD  pcbData,
 358         BOOL     flagIgnoreHKCU,
 359         LPVOID   pDefaultData,
 360         DWORD    wDefaultDataSize)
 361 {
 362         HUSKEY myhuskey;
 363         LONG ret;
 364
 365         if (!pvData || !pcbData) return ERROR_INVALID_FUNCTION; /* FIXME:wrong*/
 366         TRACE("key '%s', value '%s', datalen %ld,  %s\n",
 367               debugstr_w(pSubKey), debugstr_w(pValue), *pcbData,
 368               (flagIgnoreHKCU) ? "Ignoring HKCU" : "Tries HKCU then HKLM");
 369
 370         ret = SHRegOpenUSKeyW(pSubKey, 0x1, 0, &myhuskey, flagIgnoreHKCU);
 371         if (ret == ERROR_SUCCESS) {
 372             ret = SHRegQueryUSValueW(myhuskey, pValue, pwType, pvData,
 373                                      pcbData, flagIgnoreHKCU, pDefaultData,
 374                                      wDefaultDataSize);
 375             SHRegCloseUSKey(myhuskey);
 376         }
 377         return ret;
 378 }
 379
 380 /*************************************************************************
 381  * SHRegGetBoolUSValueA   [SHLWAPI.@]
 382  */
 383 BOOL WINAPI SHRegGetBoolUSValueA(
 384         LPCSTR pszSubKey,
 385         LPCSTR pszValue,
 386         BOOL fIgnoreHKCU,
 387         BOOL fDefault)
 388 {
 389         LONG retvalue;
 390         DWORD type, datalen, work;
 391         BOOL ret = fDefault;
 392         CHAR data[10];
 393
 394         TRACE("key '%s', value '%s', %s\n",
 395               debugstr_a(pszSubKey), debugstr_a(pszValue),
 396               (fIgnoreHKCU) ? "Ignoring HKCU" : "Tries HKCU then HKLM");
 397
 398         datalen = sizeof(data)-1;
 399         if (!(retvalue = SHRegGetUSValueA( pszSubKey, pszValue, &type,
 400                                            data, &datalen,
 401                                            fIgnoreHKCU, 0, 0))) {
 402             /* process returned data via type into bool */
 403             switch (type) {
 404             case REG_SZ:
 405                 data[9] = '\0';     /* set end of string */
 406                 if (lstrcmpiA(data, "YES") == 0) ret = TRUE;
 407                 if (lstrcmpiA(data, "TRUE") == 0) ret = TRUE;
 408                 if (lstrcmpiA(data, "NO") == 0) ret = FALSE;
 409                 if (lstrcmpiA(data, "FALSE") == 0) ret = FALSE;
 410                 break;
 411             case REG_DWORD:
 412                 work = *(LPDWORD)data;
 413                 ret = (work != 0);
 414                 break;
 415             case REG_BINARY:
 416                 if (datalen == 1) {
 417                     ret = (data[0] != '\0');
 418                     break;
 419                 }
 420             default:
 421                 FIXME("Unsupported registry data type %ld\n", type);
 422                 ret = FALSE;
 423             }
 424             TRACE("got value (type=%ld), returing <%s>\n", type,
 425                   (ret) ? "TRUE" : "FALSE");
 426         }
 427         else {
 428             ret = fDefault;
 429             TRACE("returning default data <%s>\n",
 430                   (ret) ? "TRUE" : "FALSE");
 431         }
 432         return ret;
 433 }
 434
 435 /*************************************************************************
 436  * SHRegGetBoolUSValueW   [SHLWAPI.@]
 437  */
 438 BOOL WINAPI SHRegGetBoolUSValueW(
 439         LPCWSTR pszSubKey,
 440         LPCWSTR pszValue,
 441         BOOL fIgnoreHKCU,
 442         BOOL fDefault)
 443 {
 444         static const WCHAR wYES[]=  {'Y','E','S','\0'};
 445         static const WCHAR wTRUE[]= {'T','R','U','E','\0'};
 446         static const WCHAR wNO[]=   {'N','O','\0'};
 447         static const WCHAR wFALSE[]={'F','A','L','S','E','\0'};
 448         LONG retvalue;
 449         DWORD type, datalen, work;
 450         BOOL ret = fDefault;
 451         WCHAR data[10];
 452
 453         TRACE("key '%s', value '%s', %s\n",
 454               debugstr_w(pszSubKey), debugstr_w(pszValue),
 455               (fIgnoreHKCU) ? "Ignoring HKCU" : "Tries HKCU then HKLM");
 456
 457         datalen = (sizeof(data)-1) * sizeof(WCHAR);
 458         if (!(retvalue = SHRegGetUSValueW( pszSubKey, pszValue, &type,
 459                                            data, &datalen,
 460                                            fIgnoreHKCU, 0, 0))) {
 461             /* process returned data via type into bool */
 462             switch (type) {
 463             case REG_SZ:
 464                 data[9] = L'\0';     /* set end of string */
 465                 if (lstrcmpiW(data, wYES)==0 || lstrcmpiW(data, wTRUE)==0)
 466                     ret = TRUE;
 467                 else if (lstrcmpiW(data, wNO)==0 || lstrcmpiW(data, wFALSE)==0)
 468                     ret = FALSE;
 469                 break;
 470             case REG_DWORD:
 471                 work = *(LPDWORD)data;
 472                 ret = (work != 0);
 473                 break;
 474             case REG_BINARY:
 475                 if (datalen == 1) {
 476                     ret = (data[0] != L'\0');
 477                     break;
 478                 }
 479             default:
 480                 FIXME("Unsupported registry data type %ld\n", type);
 481                 ret = FALSE;
 482             }
 483             TRACE("got value (type=%ld), returing <%s>\n", type,
 484                   (ret) ? "TRUE" : "FALSE");
 485         }
 486         else {
 487             ret = fDefault;
 488             TRACE("returning default data <%s>\n",
 489                   (ret) ? "TRUE" : "FALSE");
 490         }
 491         return ret;
 492 }
 493
 494 /*************************************************************************
 495  *      SHRegQueryInfoUSKeyA    [SHLWAPI.@]
 496  */
 497 LONG WINAPI SHRegQueryInfoUSKeyA(
 498         HUSKEY hUSKey,             /* [in]  */
 499         LPDWORD pcSubKeys,
 500         LPDWORD pcchMaxSubKeyLen,
 501         LPDWORD pcValues,
 502         LPDWORD pcchMaxValueNameLen,
 503         SHREGENUM_FLAGS enumRegFlags)
 504 {
 505         HKEY dokey;
 506         LONG ret;
 507
 508         TRACE("(0x%lx,%p,%p,%p,%p,%d)\n",
 509               (LONG)hUSKey,pcSubKeys,pcchMaxSubKeyLen,pcValues,
 510               pcchMaxValueNameLen,enumRegFlags);
 511
 512         /* if user wants HKCU, and it exists, then try it */
 513         if (((enumRegFlags == SHREGENUM_HKCU) ||
 514              (enumRegFlags == SHREGENUM_DEFAULT)) &&
 515             (dokey = REG_GetHKEYFromHUSKEY(hUSKey,REG_HKCU))) {
 516             ret = RegQueryInfoKeyA(dokey, 0, 0, 0,
 517                                    pcSubKeys, pcchMaxSubKeyLen, 0,
 518                                    pcValues, pcchMaxValueNameLen, 0, 0, 0);
 519             if ((ret == ERROR_SUCCESS) ||
 520                 (enumRegFlags == SHREGENUM_HKCU))
 521                 return ret;
 522         }
 523         if (((enumRegFlags == SHREGENUM_HKLM) ||
 524              (enumRegFlags == SHREGENUM_DEFAULT)) &&
 525             (dokey = REG_GetHKEYFromHUSKEY(hUSKey,REG_HKLM))) {
 526             return RegQueryInfoKeyA(dokey, 0, 0, 0,
 527                                     pcSubKeys, pcchMaxSubKeyLen, 0,
 528                                     pcValues, pcchMaxValueNameLen, 0, 0, 0);
 529         }
 530         return ERROR_INVALID_FUNCTION;
 531 }
 532
 533 /*************************************************************************
 534  *      SHRegQueryInfoUSKeyW    [SHLWAPI.@]
 535  */
 536 LONG WINAPI SHRegQueryInfoUSKeyW(
 537         HUSKEY hUSKey,             /* [in]  */
 538         LPDWORD pcSubKeys,
 539         LPDWORD pcchMaxSubKeyLen,
 540         LPDWORD pcValues,
 541         LPDWORD pcchMaxValueNameLen,
 542         SHREGENUM_FLAGS enumRegFlags)
 543 {
 544         HKEY dokey;
 545         LONG ret;
 546
 547         TRACE("(0x%lx,%p,%p,%p,%p,%d)\n",
 548               (LONG)hUSKey,pcSubKeys,pcchMaxSubKeyLen,pcValues,
 549               pcchMaxValueNameLen,enumRegFlags);
 550
 551         /* if user wants HKCU, and it exists, then try it */
 552         if (((enumRegFlags == SHREGENUM_HKCU) ||
 553              (enumRegFlags == SHREGENUM_DEFAULT)) &&
 554             (dokey = REG_GetHKEYFromHUSKEY(hUSKey,REG_HKCU))) {
 555             ret = RegQueryInfoKeyW(dokey, 0, 0, 0,
 556                                    pcSubKeys, pcchMaxSubKeyLen, 0,
 557                                    pcValues, pcchMaxValueNameLen, 0, 0, 0);
 558             if ((ret == ERROR_SUCCESS) ||
 559                 (enumRegFlags == SHREGENUM_HKCU))
 560                 return ret;
 561         }
 562         if (((enumRegFlags == SHREGENUM_HKLM) ||
 563              (enumRegFlags == SHREGENUM_DEFAULT)) &&
 564             (dokey = REG_GetHKEYFromHUSKEY(hUSKey,REG_HKLM))) {
 565             return RegQueryInfoKeyW(dokey, 0, 0, 0,
 566                                     pcSubKeys, pcchMaxSubKeyLen, 0,
 567                                     pcValues, pcchMaxValueNameLen, 0, 0, 0);
 568         }
 569         return ERROR_INVALID_FUNCTION;
 570 }
 571
 572 /*************************************************************************
 573  *      SHRegEnumUSKeyA         [SHLWAPI.@]
 574  */
 575 LONG WINAPI SHRegEnumUSKeyA(
 576         HUSKEY hUSKey,                 /* [in]  */
 577         DWORD dwIndex,                 /* [in]  */
 578         LPSTR pszName,                 /* [out] */
 579         LPDWORD pcchValueNameLen,      /* [in/out] */
 580         SHREGENUM_FLAGS enumRegFlags)  /* [in]  */
 581 {
 582         HKEY dokey;
 583
 584         TRACE("(0x%lx,%ld,%p,%p(%ld),%d)\n",
 585               (LONG)hUSKey, dwIndex, pszName, pcchValueNameLen,
 586               *pcchValueNameLen, enumRegFlags);
 587
 588         if (((enumRegFlags == SHREGENUM_HKCU) ||
 589              (enumRegFlags == SHREGENUM_DEFAULT)) &&
 590             (dokey = REG_GetHKEYFromHUSKEY(hUSKey,REG_HKCU))) {
 591             return RegEnumKeyExA(dokey, dwIndex, pszName, pcchValueNameLen,
 592                                 0, 0, 0, 0);
 593         }
 594
 595         if (((enumRegFlags == SHREGENUM_HKLM) ||
 596              (enumRegFlags == SHREGENUM_DEFAULT)) &&
 597             (dokey = REG_GetHKEYFromHUSKEY(hUSKey,REG_HKLM))) {
 598             return RegEnumKeyExA(dokey, dwIndex, pszName, pcchValueNameLen,
 599                                 0, 0, 0, 0);
 600         }
 601         FIXME("no support for SHREGNUM_BOTH\n");
 602         return ERROR_INVALID_FUNCTION;
 603 }
 604
 605 /*************************************************************************
 606  *      SHRegEnumUSKeyW         [SHLWAPI.@]
 607  */
 608 LONG WINAPI SHRegEnumUSKeyW(
 609         HUSKEY hUSKey,                 /* [in]  */
 610         DWORD dwIndex,                 /* [in]  */
 611         LPWSTR pszName,                /* [out] */
 612         LPDWORD pcchValueNameLen,      /* [in/out] */
 613         SHREGENUM_FLAGS enumRegFlags)  /* [in]  */
 614 {
 615         HKEY dokey;
 616
 617         TRACE("(0x%lx,%ld,%p,%p(%ld),%d)\n",
 618               (LONG)hUSKey, dwIndex, pszName, pcchValueNameLen,
 619               *pcchValueNameLen, enumRegFlags);
 620
 621         if (((enumRegFlags == SHREGENUM_HKCU) ||
 622              (enumRegFlags == SHREGENUM_DEFAULT)) &&
 623             (dokey = REG_GetHKEYFromHUSKEY(hUSKey,REG_HKCU))) {
 624             return RegEnumKeyExW(dokey, dwIndex, pszName, pcchValueNameLen,
 625                                 0, 0, 0, 0);
 626         }
 627
 628         if (((enumRegFlags == SHREGENUM_HKLM) ||
 629              (enumRegFlags == SHREGENUM_DEFAULT)) &&
 630             (dokey = REG_GetHKEYFromHUSKEY(hUSKey,REG_HKLM))) {
 631             return RegEnumKeyExW(dokey, dwIndex, pszName, pcchValueNameLen,
 632                                 0, 0, 0, 0);
 633         }
 634         FIXME("no support for SHREGNUM_BOTH\n");
 635         return ERROR_INVALID_FUNCTION;
 636 }
 637
 638 /*************************************************************************
 639  *      SHRegWriteUSValueA      [SHLWAPI.@]
 640  */
 641 LONG  WINAPI SHRegWriteUSValueA(HUSKEY hUSKey, LPCSTR pszValue, DWORD dwType,
 642                                 LPVOID pvData, DWORD cbData, DWORD dwFlags)
 643 {
 644     FIXME("(0x%lx,%s,%ld,%p,%ld,%ld): stub\n",
 645           (LONG)hUSKey, debugstr_a(pszValue), dwType, pvData, cbData, dwFlags);
 646     return ERROR_SUCCESS;
 647 }
 648
 649 /*************************************************************************
 650  *      SHRegWriteUSValueW      [SHLWAPI.@]
 651  */
 652 LONG  WINAPI SHRegWriteUSValueW(HUSKEY hUSKey, LPCWSTR pszValue, DWORD dwType,
 653                                 LPVOID pvData, DWORD cbData, DWORD dwFlags)
 654 {
 655     FIXME("(0x%lx,%s,%ld,%p,%ld,%ld): stub\n",
 656           (LONG)hUSKey, debugstr_w(pszValue), dwType, pvData, cbData, dwFlags);
 657     return ERROR_SUCCESS;
 658 }
 659
 660 /*************************************************************************
 661  * SHRegGetPathA   [SHLWAPI.@]
 662  *
 663  * Get a path from the registry.
 664  *
 665  * PARAMS
 666  *   hKey       [I] Handle to registry key
 667  *   lpszSubKey [I] Name of sub key containing path to get
 668  *   lpszValue  [I] Name of value containing path to get
 669  *   lpszPath   [O] Buffer for returned path
 670  *   dwFlags    [I] Reserved
 671  *
 672  * RETURNS
 673  *   Success: ERROR_SUCCESS. lpszPath contains the path.
 674  *   Failure: An error code from RegOpenKeyExA or SHQueryValueExA.
 675  */
 676 DWORD WINAPI SHRegGetPathA(HKEY hKey, LPCSTR lpszSubKey, LPCSTR lpszValue,
 677                            LPSTR lpszPath, DWORD dwFlags)
 678 {
 679   HKEY hSubKey;
 680   DWORD dwType = REG_SZ, dwSize = MAX_PATH, dwRet = ERROR_SUCCESS;
 681
 682   TRACE("(hkey=0x%08x,%s,%s,%p,%ld)\n", hKey, debugstr_a(lpszSubKey),
 683         debugstr_a(lpszValue), lpszPath, dwFlags);
 684
 685   if (lpszSubKey && *lpszSubKey)
 686     dwRet = RegOpenKeyExA(hKey, lpszSubKey, 0, KEY_READ, &hSubKey);
 687   else
 688     hSubKey = hKey;
 689
 690   if (!dwRet)
 691     dwRet = SHQueryValueExA(hSubKey, lpszValue, NULL, &dwType, lpszPath, &dwSize);
 692
 693   if (hSubKey != hKey)
 694     RegCloseKey(hSubKey);
 695
 696   return dwRet;
 697 }
 698
 699 /*************************************************************************
 700  * SHRegGetPathW   [SHLWAPI.@]
 701  *
 702  * See SHRegGetPathA.
 703  */
 704 DWORD WINAPI SHRegGetPathW(HKEY hKey, LPCWSTR lpszSubKey, LPCWSTR lpszValue,
 705                            LPWSTR lpszPath, DWORD dwFlags)
 706 {
 707   HKEY hSubKey;
 708   DWORD dwType = REG_SZ, dwSize = MAX_PATH, dwRet = ERROR_SUCCESS;
 709
 710   TRACE("(hkey=0x%08x,%s,%s,%p,%ld)\n", hKey, debugstr_w(lpszSubKey),
 711         debugstr_w(lpszValue), lpszPath, dwFlags);
 712
 713   if (lpszSubKey && *lpszSubKey)
 714     dwRet = RegOpenKeyExW(hKey, lpszSubKey, 0, KEY_READ, &hSubKey);
 715   else
 716     hSubKey = hKey;
 717
 718   if (!dwRet)
 719     dwRet = SHQueryValueExW(hSubKey, lpszValue, NULL, &dwType, lpszPath, &dwSize);
 720
 721   if (hSubKey != hKey)
 722     RegCloseKey(hSubKey);
 723
 724   return dwRet;
 725 }
 726
 727
 728 /*************************************************************************
 729  * SHRegSetPathA   [SHLWAPI.@]
 730  *
 731  * Write a path to the registry.
 732  *
 733  * PARAMS
 734  *   hKey       [I] Handle to registry key
 735  *   lpszSubKey [I] Name of sub key containing path to set
 736  *   lpszValue  [I] Name of value containing path to set
 737  *   lpszPath   [O] Path to write
 738  *   dwFlags    [I] Reserved
 739  *
 740  * RETURNS
 741  *   Success: ERROR_SUCCESS.
 742  *   Failure: An error code from SHSetValueA.
 743  */
 744 DWORD WINAPI SHRegSetPathA(HKEY hKey, LPCSTR lpszSubKey, LPCSTR lpszValue,
 745                            LPCSTR lpszPath, DWORD dwFlags)
 746 {
 747   char szBuff[MAX_PATH];
 748
 749   FIXME("(hkey=0x%08x,%s,%s,%p,%ld) - semi-stub",hKey, debugstr_a(lpszSubKey),
 750         debugstr_a(lpszValue), lpszPath, dwFlags);
 751
 752   lstrcpyA(szBuff, lpszPath);
 753
 754   /* FIXME: PathUnExpandEnvStringsA(szBuff); */
 755
 756   return SHSetValueA(hKey,lpszSubKey, lpszValue, REG_SZ, szBuff,
 757                      lstrlenA(szBuff));
 758 }
 759
 760 /*************************************************************************
 761  * SHRegSetPathW   [SHLWAPI.@]
 762  *
 763  * See SHRegSetPathA.
 764  */
 765 DWORD WINAPI SHRegSetPathW(HKEY hKey, LPCWSTR lpszSubKey, LPCWSTR lpszValue,
 766                            LPCWSTR lpszPath, DWORD dwFlags)
 767 {
 768   WCHAR szBuff[MAX_PATH];
 769
 770   FIXME("(hkey=0x%08x,%s,%s,%p,%ld) - semi-stub",hKey, debugstr_w(lpszSubKey),
 771         debugstr_w(lpszValue), lpszPath, dwFlags);
 772
 773   lstrcpyW(szBuff, lpszPath);
 774
 775   /* FIXME: PathUnExpandEnvStringsW(szBuff); */
 776
 777   return SHSetValueW(hKey,lpszSubKey, lpszValue, REG_SZ, szBuff,
 778                      lstrlenW(szBuff));
 779 }
 780
 781 /*************************************************************************
 782  * SHGetValueA   [SHLWAPI.@]
 783  *
 784  * Get a value from the registry.
 785  *
 786  * PARAMS
 787  *   hKey       [I] Handle to registry key
 788  *   lpszSubKey [I] Name of sub key containing value to get
 789  *   lpszValue  [I] Name of value to get
 790  *   pwType     [O] Pointer to the values type
 791  *   pvData     [O] Pointer to the values data
 792  *   pcbData    [O] Pointer to the values size
 793  *
 794  * RETURNS
 795  *   Success: ERROR_SUCCESS. Output parameters contain the details read.
 796  *   Failure: An error code from RegOpenKeyExA or RegQueryValueExA.
 797  */
 798 DWORD WINAPI SHGetValueA(HKEY hKey, LPCSTR lpszSubKey, LPCSTR lpszValue,
 799                          LPDWORD pwType, LPVOID pvData, LPDWORD pcbData)
 800 {
 801   DWORD dwRet;
 802   HKEY hSubKey;
 803
 804   TRACE("(hkey=0x%08x,%s,%s,%p,%p,%p)\n", hKey, debugstr_a(lpszSubKey),
 805         debugstr_a(lpszValue), pwType, pvData, pcbData);
 806
 807   dwRet = RegOpenKeyExA(hKey, lpszSubKey, 0, KEY_QUERY_VALUE, &hSubKey);
 808   if (!dwRet)
 809   {
 810     dwRet = RegQueryValueExA(hSubKey, lpszValue, 0, pwType, pvData, pcbData);
 811     RegCloseKey(hSubKey);
 812   }
 813   return dwRet;
 814 }
 815
 816 /*************************************************************************
 817  * SHGetValueW   [SHLWAPI.@]
 818  *
 819  * See SHGetValueA.
 820  */
 821 DWORD WINAPI SHGetValueW(HKEY hKey, LPCWSTR lpszSubKey, LPCWSTR lpszValue,
 822                          LPDWORD pwType, LPVOID pvData, LPDWORD pcbData)
 823 {
 824   DWORD dwRet;
 825   HKEY hSubKey;
 826
 827   TRACE("(hkey=0x%08x,%s,%s,%p,%p,%p)\n", hKey, debugstr_w(lpszSubKey),
 828         debugstr_w(lpszValue), pwType, pvData, pcbData);
 829
 830   dwRet = RegOpenKeyExW(hKey, lpszSubKey, 0, KEY_QUERY_VALUE, &hSubKey);
 831   if (!dwRet)
 832   {
 833     dwRet = RegQueryValueExW(hSubKey, lpszValue, 0, pwType, pvData, pcbData);
 834     RegCloseKey(hSubKey);
 835   }
 836   return dwRet;
 837 }
 838
 839 /*************************************************************************
 840  * SHSetValueA   [SHLWAPI.@]
 841  *
 842  * Set a value in the registry.
 843  *
 844  * PARAMS
 845  *   hKey       [I] Handle to registry key
 846  *   lpszSubKey [I] Name of sub key under hKey
 847  *   lpszValue  [I] Name of value to set
 848  *   dwType     [I] Type of the value
 849  *   pvData     [I] Data of the value
 850  *   cbData     [I] Size of the value
 851  *
 852  * RETURNS
 853  *   Success: ERROR_SUCCESS. The value is set with the data given.
 854  *   Failure: An error code from RegCreateKeyExA or RegSetValueExA
 855  *
 856  * NOTES
 857  *   If the sub key does not exist, it is created before the value is set. If
 858  *   The sub key is NULL or an empty string, then the value is added directly
 859  *   to hKey instead.
 860  */
 861 DWORD WINAPI SHSetValueA(HKEY hKey, LPCSTR lpszSubKey, LPCSTR lpszValue,
 862                          DWORD dwType, LPCVOID pvData, DWORD cbData)
 863 {
 864   DWORD dwRet = ERROR_SUCCESS, dwDummy;
 865   HKEY  hSubKey;
 866   LPSTR szEmpty = "";
 867
 868   TRACE("(hkey=0x%08x,%s,%s,%ld,%p,%ld)\n", hKey, debugstr_a(lpszSubKey),
 869           debugstr_a(lpszValue), dwType, pvData, cbData);
 870
 871   if (lpszSubKey && *lpszSubKey)
 872     dwRet = RegCreateKeyExA(hKey, lpszSubKey, 0, szEmpty,
 873                             0, KEY_SET_VALUE, NULL, &hSubKey, &dwDummy);
 874   else
 875     hSubKey = hKey;
 876   if (!dwRet)
 877   {
 878     dwRet = RegSetValueExA(hSubKey, lpszValue, 0, dwType, pvData, cbData);
 879     if (hSubKey != hKey)
 880       RegCloseKey(hSubKey);
 881   }
 882   return dwRet;
 883 }
 884
 885 /*************************************************************************
 886  * SHSetValueW   [SHLWAPI.@]
 887  *
 888  * See SHSetValueA.
 889  */
 890 DWORD WINAPI SHSetValueW(HKEY hKey, LPCWSTR lpszSubKey, LPCWSTR lpszValue,
 891                          DWORD dwType, LPCVOID pvData, DWORD cbData)
 892 {
 893   DWORD dwRet = ERROR_SUCCESS, dwDummy;
 894   HKEY  hSubKey;
 895   WCHAR szEmpty[] = { '\0' };
 896
 897   TRACE("(hkey=0x%08x,%s,%s,%ld,%p,%ld)\n", hKey, debugstr_w(lpszSubKey),
 898         debugstr_w(lpszValue), dwType, pvData, cbData);
 899
 900   if (lpszSubKey && *lpszSubKey)
 901     dwRet = RegCreateKeyExW(hKey, lpszSubKey, 0, szEmpty,
 902                             0, KEY_SET_VALUE, NULL, &hSubKey, &dwDummy);
 903   else
 904     hSubKey = hKey;
 905   if (!dwRet)
 906   {
 907     dwRet = RegSetValueExW(hSubKey, lpszValue, 0, dwType, pvData, cbData);
 908     if (hSubKey != hKey)
 909       RegCloseKey(hSubKey);
 910   }
 911   return dwRet;
 912 }
 913
 914 /*************************************************************************
 915  * SHQueryInfoKeyA   [SHLWAPI.@]
 916  *
 917  * Get information about a registry key. See RegQueryInfoKeyA.
 918  */
 919 LONG WINAPI SHQueryInfoKeyA(HKEY hKey, LPDWORD pwSubKeys, LPDWORD pwSubKeyMax,
 920                             LPDWORD pwValues, LPDWORD pwValueMax)
 921 {
 922   TRACE("(hkey=0x%08x,%p,%p,%p,%p)\n", hKey, pwSubKeys, pwSubKeyMax,
 923         pwValues, pwValueMax);
 924   return RegQueryInfoKeyA(hKey, NULL, NULL, NULL, pwSubKeys, pwSubKeyMax,
 925                           NULL, pwValues, pwValueMax, NULL, NULL, NULL);
 926 }
 927
 928 /*************************************************************************
 929  * SHQueryInfoKeyW   [SHLWAPI.@]
 930  *
 931  * See SHQueryInfoKeyA
 932  */
 933 LONG WINAPI SHQueryInfoKeyW(HKEY hKey, LPDWORD pwSubKeys, LPDWORD pwSubKeyMax,
 934                             LPDWORD pwValues, LPDWORD pwValueMax)
 935 {
 936   TRACE("(hkey=0x%08x,%p,%p,%p,%p)\n", hKey, pwSubKeys, pwSubKeyMax,
 937         pwValues, pwValueMax);
 938   return RegQueryInfoKeyW(hKey, NULL, NULL, NULL, pwSubKeys, pwSubKeyMax,
 939                           NULL, pwValues, pwValueMax, NULL, NULL, NULL);
 940 }
 941
 942 /*************************************************************************
 943  * SHQueryValueExAW
 944  *
 945  * Internal implementation of SHQueryValueExA/SHQueryValueExW.
 946  */
 947 static DWORD WINAPI SHQueryValueExAW(RegQueryFn pfn,
 948                                      HKEY hKey, LPCVOID lpszValue,
 949                                      LPDWORD lpReserved, LPDWORD pwType,
 950                                      LPBYTE pvData, LPDWORD pcbData)
 951 {
 952   DWORD dwRet, dwType, dwDataLen;
 953
 954   if (pcbData)
 955     dwDataLen = *pcbData;
 956
 957   dwRet = pfn(hKey, lpszValue, lpReserved, &dwType, pvData, &dwDataLen);
 958   if (!dwRet)
 959   {
 960     if (dwType == REG_EXPAND_SZ)
 961     {
 962       /* Expand type REG_EXPAND_SZ into REG_SZ */
 963       LPSTR szExpand;
 964       LPBYTE pData = pvData;
 965
 966       if (!pData)
 967       {
 968         /* Create a buffer to hold the data, to get the size */
 969         if (!pcbData ||
 970             !(pData = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, *pcbData)))
 971           return ERROR_OUTOFMEMORY;
 972         /* Read the data in to the buffer */
 973         if ((dwRet = pfn(hKey, lpszValue, lpReserved, &dwType,
 974                          pData, &dwDataLen)))
 975           return dwRet;
 976       }
 977
 978       if (!pcbData && pData != pvData)
 979       {
 980         /* Note: In this case the caller will crash under Win32 */
 981         WARN("Invalid pcbData would crash under Win32!");
 982         return ERROR_OUTOFMEMORY;
 983       }
 984
 985       szExpand = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, *pcbData);
 986       if (!szExpand)
 987       {
 988         if (pData != pvData)
 989           HeapFree(GetProcessHeap(), 0, pData);
 990         return ERROR_OUTOFMEMORY;
 991       }
 992       if ((ExpandEnvironmentStringsA(pvData, szExpand, *pcbData) <= 0))
 993       {
 994         dwDataLen = strlen(szExpand) + 1;
 995         strncpy(pvData, szExpand, *pcbData);
 996       }
 997       else
 998       {
 999         if (pData != pvData)
1000           HeapFree(GetProcessHeap(), 0, pData);
1001         HeapFree(GetProcessHeap(), 0, szExpand);
1002         return GetLastError();
1003       }
1004       if (pData != pvData)
1005         HeapFree(GetProcessHeap(), 0, pData);
1006       HeapFree(GetProcessHeap(), 0, szExpand);
1007       dwType = REG_SZ;
1008     }
1009     if (dwType == REG_SZ && pvData && pcbData && dwDataLen >= *pcbData)
1010     {
1011       /* String type too long: truncate it */
1012       pvData[*pcbData] = '\0';
1013     }
1014   }
1015   /* Update the type and data size if the caller wanted them */
1016   if (pwType)
1017     *pwType = dwType;
1018   if (pcbData)
1019     *pcbData  = dwDataLen;
1020   return dwRet;
1021 }
1022
1023 /*************************************************************************
1024  * SHQueryValueExA   [SHLWAPI.@]
1025  *
1026  * Get a value from the registry, expanding environment variable strings.
1027  *
1028  * PARAMS
1029  *   hKey       [I] Handle to registry key
1030  *   lpszValue  [I] Name of value to delete
1031  *   lpReserved [O] Reserved for future use; must be NULL
1032  *   pwType     [O] Optional pointer updated with the values type
1033  *   pvData     [O] Optional pointer updated with the values data
1034  *   pcbData    [O] Optional pointer updated with the values size
1035  *
1036  * RETURNS
1037  *   Success: ERROR_SUCCESS. Any non-NULL output parameters are updated with
1038  *            information about the value.
1039  *   Failure: ERROR_OUTOFMEMORY if memory allocation fails, or the type of the
1040  *            data is REG_EXPAND_SZ and pcbData is NULL. Otherwise an error
1041  *            code from RegQueryValueExA or ExpandEnvironmentStringsA.
1042  *
1043  * NOTES
1044  *   Either pwType, pvData or pcbData may be NULL if the caller doesn't want
1045  *   the type, data or size information for the value.
1046  *
1047  *   If the type of the data is REG_EXPAND_SZ, it is expanded to REG_SZ. The
1048  *   value returned will be truncated if it is of type REG_SZ and bigger than
1049  *   the buffer given to store it.
1050  */
1051 DWORD WINAPI SHQueryValueExA(HKEY hKey, LPCSTR lpszValue,
1052                              LPDWORD lpReserved, LPDWORD pwType,
1053                              LPVOID pvData, LPDWORD pcbData)
1054 {
1055   TRACE("(hkey=0x%08x,%s,%p,%p,%p,%p=%ld)\n", hKey, debugstr_a(lpszValue),
1056         lpReserved, pwType, pvData, pcbData, pcbData ? *pcbData : 0);
1057
1058   return SHQueryValueExAW((RegQueryFn)RegQueryValueExA, hKey, lpszValue,
1059                           lpReserved, pwType, pvData, pcbData);
1060 }
1061
1062 /*************************************************************************
1063  * SHQueryValueExW   [SHLWAPI.@]
1064  *
1065  * See SHQueryValueExA.
1066  */
1067 DWORD WINAPI SHQueryValueExW(HKEY hKey, LPCWSTR lpszValue,
1068                              LPDWORD lpReserved, LPDWORD pwType,
1069                              LPVOID pvData, LPDWORD pcbData)
1070 {
1071   TRACE("(hkey=0x%08x,%s,%p,%p,%p,%p=%ld)\n", hKey, debugstr_w(lpszValue),
1072         lpReserved, pwType, pvData, pcbData, pcbData ? *pcbData : 0);
1073
1074   return SHQueryValueExAW((RegQueryFn)RegQueryValueExW, hKey, lpszValue,
1075                           lpReserved, pwType, pvData, pcbData);
1076 }
1077
1078 /*************************************************************************
1079  * SHDeleteKeyA   [SHLWAPI.@]
1080  *
1081  * Delete a registry key and any sub keys/values present
1082  *
1083  * PARAMS
1084  *   hKey       [I] Handle to registry key
1085  *   lpszSubKey [I] Name of sub key to delete
1086  *
1087  * RETURNS
1088  *   Success: ERROR_SUCCESS. The key is deleted.
1089  *   Failure: An error code from RegOpenKeyExA, RegQueryInfoKeyA,
1090  *          RegEnumKeyExA or RegDeleteKeyA.
1091  */
1092 DWORD WINAPI SHDeleteKeyA(HKEY hKey, LPCSTR lpszSubKey)
1093 {
1094   DWORD dwRet, dwKeyCount = 0, dwMaxSubkeyLen = 0, dwSize, i;
1095   CHAR szNameBuf[MAX_PATH], *lpszName = szNameBuf;
1096   HKEY hSubKey = 0;
1097
1098   TRACE("(hkey=0x%08x,%s)\n", hKey, debugstr_a(lpszSubKey));
1099
1100   dwRet = RegOpenKeyExA(hKey, lpszSubKey, 0, KEY_READ, &hSubKey);
1101   if(!dwRet)
1102   {
1103     /* Find how many subkeys there are */
1104     dwRet = RegQueryInfoKeyA(hSubKey, NULL, NULL, NULL, &dwKeyCount,
1105                              &dwMaxSubkeyLen, NULL, NULL, NULL, NULL, NULL, NULL);
1106     if(!dwRet)
1107     {
1108       dwMaxSubkeyLen++;
1109       if (dwMaxSubkeyLen > sizeof(szNameBuf))
1110         /* Name too big: alloc a buffer for it */
1111         lpszName = HeapAlloc(GetProcessHeap(), 0, dwMaxSubkeyLen*sizeof(CHAR));
1112
1113       if(!lpszName)
1114         dwRet = ERROR_NOT_ENOUGH_MEMORY;
1115       else
1116       {
1117         /* Recursively delete all the subkeys */
1118         for(i = 0; i < dwKeyCount && !dwRet; i++)
1119         {
1120           dwSize = dwMaxSubkeyLen;
1121           dwRet = RegEnumKeyExA(hSubKey, i, lpszName, &dwSize, NULL, NULL, NULL, NULL);
1122           if(!dwRet)
1123             dwRet = SHDeleteKeyA(hSubKey, lpszName);
1124         }
1125         if (lpszName != szNameBuf)
1126           HeapFree(GetProcessHeap(), 0, lpszName); /* Free buffer if allocated */
1127       }
1128     }
1129
1130     RegCloseKey(hSubKey);
1131     if(!dwRet)
1132       dwRet = RegDeleteKeyA(hKey, lpszSubKey);
1133   }
1134   return dwRet;
1135 }
1136
1137 /*************************************************************************
1138  * SHDeleteKeyW   [SHLWAPI.@]
1139  *
1140  * See SHDeleteKeyA.
1141  */
1142 DWORD WINAPI SHDeleteKeyW(HKEY hKey, LPCWSTR lpszSubKey)
1143 {
1144   DWORD dwRet, dwKeyCount = 0, dwMaxSubkeyLen = 0, dwSize, i;
1145   WCHAR szNameBuf[MAX_PATH], *lpszName = szNameBuf;
1146   HKEY hSubKey = 0;
1147
1148   TRACE("(hkey=0x%08x,%s)\n", hKey, debugstr_w(lpszSubKey));
1149
1150   dwRet = RegOpenKeyExW(hKey, lpszSubKey, 0, KEY_READ, &hSubKey);
1151   if(!dwRet)
1152   {
1153     /* Find how many subkeys there are */
1154     dwRet = RegQueryInfoKeyW(hSubKey, NULL, NULL, NULL, &dwKeyCount,
1155                              &dwMaxSubkeyLen, NULL, NULL, NULL, NULL, NULL, NULL);
1156     if(!dwRet)
1157     {
1158       dwMaxSubkeyLen++;
1159       if (dwMaxSubkeyLen > sizeof(szNameBuf)/sizeof(WCHAR))
1160         /* Name too big: alloc a buffer for it */
1161         lpszName = HeapAlloc(GetProcessHeap(), 0, dwMaxSubkeyLen*sizeof(WCHAR));
1162
1163       if(!lpszName)
1164         dwRet = ERROR_NOT_ENOUGH_MEMORY;
1165       else
1166       {
1167         /* Recursively delete all the subkeys */
1168         for(i = 0; i < dwKeyCount && !dwRet; i++)
1169         {
1170           dwSize = dwMaxSubkeyLen;
1171           dwRet = RegEnumKeyExW(hSubKey, i, lpszName, &dwSize, NULL, NULL, NULL, NULL);
1172           if(!dwRet)
1173             dwRet = SHDeleteKeyW(hSubKey, lpszName);
1174         }
1175
1176         if (lpszName != szNameBuf)
1177           HeapFree(GetProcessHeap(), 0, lpszName); /* Free buffer if allocated */
1178       }
1179     }
1180
1181     RegCloseKey(hSubKey);
1182     if(!dwRet)
1183       dwRet = RegDeleteKeyW(hKey, lpszSubKey);
1184   }
1185   return dwRet;
1186 }
1187
1188 /*************************************************************************
1189  * SHDeleteEmptyKeyA   [SHLWAPI.@]
1190  *
1191  * Delete a registry key with no sub keys.
1192  *
1193  * PARAMS
1194  *   hKey       [I] Handle to registry key
1195  *   lpszSubKey [I] Name of sub key to delete
1196  *
1197  * RETURNS
1198  *   Success: ERROR_SUCCESS. The key is deleted.
1199  *   Failure: If the key is not empty, returns ERROR_KEY_HAS_CHILDREN. Otherwise
1200  *          returns an error code from RegOpenKeyExA, RegQueryInfoKeyA or
1201  *          RegDeleteKeyA.
1202  */
1203 DWORD WINAPI SHDeleteEmptyKeyA(HKEY hKey, LPCSTR lpszSubKey)
1204 {
1205   DWORD dwRet, dwKeyCount = 0;
1206   HKEY hSubKey = 0;
1207
1208   TRACE("(hkey=0x%08x,%s)\n", hKey, debugstr_a(lpszSubKey));
1209
1210   dwRet = RegOpenKeyExA(hKey, lpszSubKey, 0, KEY_READ, &hSubKey);
1211   if(!dwRet)
1212   {
1213     dwRet = RegQueryInfoKeyA(hSubKey, NULL, NULL, NULL, &dwKeyCount,
1214                              NULL, NULL, NULL, NULL, NULL, NULL, NULL);
1215     RegCloseKey(hSubKey);
1216     if(!dwRet)
1217     {
1218       if (!dwKeyCount)
1219         dwRet = RegDeleteKeyA(hKey, lpszSubKey);
1220       else
1221         dwRet = ERROR_KEY_HAS_CHILDREN;
1222     }
1223   }
1224   return dwRet;
1225 }
1226
1227 /*************************************************************************
1228  * SHDeleteEmptyKeyW   [SHLWAPI.@]
1229  *
1230  * See SHDeleteEmptyKeyA.
1231  */
1232 DWORD WINAPI SHDeleteEmptyKeyW(HKEY hKey, LPCWSTR lpszSubKey)
1233 {
1234   DWORD dwRet, dwKeyCount = 0;
1235   HKEY hSubKey = 0;
1236
1237   TRACE("(hkey=0x%08x, %s)\n", hKey, debugstr_w(lpszSubKey));
1238
1239   dwRet = RegOpenKeyExW(hKey, lpszSubKey, 0, KEY_READ, &hSubKey);
1240   if(!dwRet)
1241   {
1242     dwRet = RegQueryInfoKeyW(hSubKey, NULL, NULL, NULL, &dwKeyCount,
1243                              NULL, NULL, NULL, NULL, NULL, NULL, NULL);
1244     RegCloseKey(hSubKey);
1245     if(!dwRet)
1246     {
1247       if (!dwKeyCount)
1248         dwRet = RegDeleteKeyW(hKey, lpszSubKey);
1249       else
1250         dwRet = ERROR_KEY_HAS_CHILDREN;
1251     }
1252   }
1253   return dwRet;
1254 }
1255
1256 /*************************************************************************
1257  * SHDeleteOrphanKeyA   [SHLWAPI.@]
1258  *
1259  * Delete a registry key with no sub keys or values.
1260  *
1261  * PARAMS
1262  *   hKey       [I] Handle to registry key
1263  *   lpszSubKey [I] Name of sub key to possibly delete
1264  *
1265  * RETURNS
1266  *   Success: ERROR_SUCCESS. The key has been deleted if it was an orphan.
1267  *   Failure: An error from RegOpenKeyExA, RegQueryValueExA, or RegDeleteKeyA.
1268  */
1269 DWORD WINAPI SHDeleteOrphanKeyA(HKEY hKey, LPCSTR lpszSubKey)
1270 {
1271   HKEY hSubKey;
1272   DWORD dwKeyCount = 0, dwValueCount = 0, dwRet;
1273
1274   TRACE("(hkey=0x%08x,%s)", hKey, debugstr_a(lpszSubKey));
1275
1276   dwRet = RegOpenKeyExA(hKey, lpszSubKey, 0, KEY_READ, &hSubKey);
1277
1278   if(!dwRet)
1279   {
1280     /* Get subkey and value count */
1281     dwRet = RegQueryInfoKeyA(hSubKey, NULL, NULL, NULL, &dwKeyCount,
1282                              NULL, NULL, &dwValueCount, NULL, NULL, NULL, NULL);
1283
1284     if(!dwRet && !dwKeyCount && !dwValueCount)
1285     {
1286       dwRet = RegDeleteKeyA(hKey, lpszSubKey);
1287     }
1288     RegCloseKey(hSubKey);
1289   }
1290   return dwRet;
1291 }
1292
1293 /*************************************************************************
1294  * SHDeleteOrphanKeyW   [SHLWAPI.@]
1295  *
1296  * See SHDeleteOrphanKeyA.
1297  */
1298 DWORD WINAPI SHDeleteOrphanKeyW(HKEY hKey, LPCWSTR lpszSubKey)
1299 {
1300   HKEY hSubKey;
1301   DWORD dwKeyCount = 0, dwValueCount = 0, dwRet;
1302
1303   TRACE("(hkey=0x%08x,%s)", hKey, debugstr_w(lpszSubKey));
1304
1305   dwRet = RegOpenKeyExW(hKey, lpszSubKey, 0, KEY_READ, &hSubKey);
1306
1307   if(!dwRet)
1308   {
1309     /* Get subkey and value count */
1310     dwRet = RegQueryInfoKeyW(hSubKey, NULL, NULL, NULL, &dwKeyCount,
1311                              NULL, NULL, &dwValueCount, NULL, NULL, NULL, NULL);
1312
1313     if(!dwRet && !dwKeyCount && !dwValueCount)
1314     {
1315       dwRet = RegDeleteKeyW(hKey, lpszSubKey);
1316     }
1317     RegCloseKey(hSubKey);
1318   }
1319   return dwRet;
1320 }
1321
1322 /*************************************************************************
1323  * SHDeleteValueA   [SHLWAPI.@]
1324  *
1325  * Delete a value from the registry.
1326  *
1327  * PARAMS
1328  *   hKey       [I] Handle to registry key
1329  *   lpszSubKey [I] Name of sub key containing value to delete
1330  *   lpszValue  [I] Name of value to delete
1331  *
1332  * RETURNS
1333  *   Success: ERROR_SUCCESS. The value is deleted.
1334  *   Failure: An error code from RegOpenKeyExA or RegDeleteValueA.
1335  */
1336 DWORD WINAPI SHDeleteValueA(HKEY hKey, LPCSTR lpszSubKey, LPCSTR lpszValue)
1337 {
1338   DWORD dwRet;
1339   HKEY hSubKey;
1340
1341   TRACE("(hkey=0x%08x,%s,%s)\n", hKey, debugstr_a(lpszSubKey), debugstr_a(lpszValue));
1342
1343   dwRet = RegOpenKeyExA(hKey, lpszSubKey, 0, KEY_SET_VALUE, &hSubKey);
1344   if (!dwRet)
1345   {
1346     dwRet = RegDeleteValueA(hSubKey, lpszValue);
1347     RegCloseKey(hSubKey);
1348   }
1349   return dwRet;
1350 }
1351
1352 /*************************************************************************
1353  * SHDeleteValueW   [SHLWAPI.@]
1354  *
1355  * See SHDeleteValueA.
1356  */
1357 DWORD WINAPI SHDeleteValueW(HKEY hKey, LPCWSTR lpszSubKey, LPCWSTR lpszValue)
1358 {
1359   DWORD dwRet;
1360   HKEY hSubKey;
1361
1362   TRACE("(hkey=0x%08x,%s,%s)\n", hKey, debugstr_w(lpszSubKey), debugstr_w(lpszValue));
1363
1364   dwRet = RegOpenKeyExW(hKey, lpszSubKey, 0, KEY_SET_VALUE, &hSubKey);
1365   if (!dwRet)
1366   {
1367     dwRet = RegDeleteValueW(hSubKey, lpszValue);
1368     RegCloseKey(hSubKey);
1369   }
1370   return dwRet;
1371 }
1372
1373 /*************************************************************************
1374  * SHEnumKeyExA   [SHLWAPI.@]
1375  *
1376  * Enumerate sub keys in a registry key.
1377  *
1378  * PARAMS
1379  *   hKey       [I] Handle to registry key
1380  *   dwIndex    [I] Index of key to enumerate
1381  *   lpszSubKey [O] Pointer updated with the subkey name
1382  *   pwLen      [O] Pointer updated with the subkey length
1383  *
1384  * RETURN
1385  *   Success: ERROR_SUCCESS. lpszSubKey and pwLen are updated.
1386  *   Failure: An error code from RegEnumKeyExA.
1387  */
1388 LONG WINAPI SHEnumKeyExA(HKEY hKey, DWORD dwIndex, LPSTR lpszSubKey,
1389                          LPDWORD pwLen)
1390 {
1391   TRACE("(hkey=0x%08x,%ld,%s,%p)\n", hKey, dwIndex, debugstr_a(lpszSubKey), pwLen);
1392
1393   return RegEnumKeyExA(hKey, dwIndex, lpszSubKey, pwLen, NULL, NULL, NULL, NULL);
1394 }
1395
1396 /*************************************************************************
1397  * SHEnumKeyExW   [SHLWAPI.@]
1398  *
1399  * See SHEnumKeyExA.
1400  */
1401 LONG WINAPI SHEnumKeyExW(HKEY hKey, DWORD dwIndex, LPWSTR lpszSubKey,
1402                          LPDWORD pwLen)
1403 {
1404   TRACE("(hkey=0x%08x,%ld,%s,%p)\n", hKey, dwIndex, debugstr_w(lpszSubKey), pwLen);
1405
1406   return RegEnumKeyExW(hKey, dwIndex, lpszSubKey, pwLen, NULL, NULL, NULL, NULL);
1407 }
1408
1409 /*************************************************************************
1410  * SHEnumValueA   [SHLWAPI.@]
1411  *
1412  * Enumerate values in a registry key.
1413  *
1414  * PARAMS
1415  *   hKey      [I] Handle to registry key
1416  *   dwIndex   [I] Index of key to enumerate
1417  *   lpszValue [O] Pointer updated with the values name
1418  *   pwLen     [O] Pointer updated with the values length
1419  *   pwType    [O] Pointer updated with the values type
1420  *   pvData    [O] Pointer updated with the values data
1421  *   pcbData   [O] Pointer updated with the values size
1422  *
1423  * RETURNS
1424  *   Success: ERROR_SUCCESS. Output parameters are updated.
1425  *   Failure: An error code from RegEnumValueExA.
1426  */
1427 LONG WINAPI SHEnumValueA(HKEY hKey, DWORD dwIndex, LPSTR lpszValue,
1428                          LPDWORD pwLen, LPDWORD pwType,
1429                          LPVOID pvData, LPDWORD pcbData)
1430 {
1431   TRACE("(hkey=0x%08x,%ld,%s,%p,%p,%p,%p)\n", hKey, dwIndex,
1432         debugstr_a(lpszValue), pwLen, pwType, pvData, pcbData);
1433
1434  return RegEnumValueA(hKey, dwIndex, lpszValue, pwLen, NULL,
1435                       pwType, pvData, pcbData);
1436 }
1437
1438 /*************************************************************************
1439  * SHEnumValueW   [SHLWAPI.@]
1440  *
1441  * See SHEnumValueA.
1442  */
1443 LONG WINAPI SHEnumValueW(HKEY hKey, DWORD dwIndex, LPWSTR lpszValue,
1444                          LPDWORD pwLen, LPDWORD pwType,
1445                          LPVOID pvData, LPDWORD pcbData)
1446 {
1447   TRACE("(hkey=0x%08x,%ld,%s,%p,%p,%p,%p)\n", hKey, dwIndex,
1448         debugstr_w(lpszValue), pwLen, pwType, pvData, pcbData);
1449
1450   return RegEnumValueW(hKey, dwIndex, lpszValue, pwLen, NULL,
1451                        pwType, pvData, pcbData);
1452 }
1453
1454 /*************************************************************************
1455  * @   [SHLWAPI.205]
1456  *
1457  * Wrapper for SHGetValueA in case machine is in safe mode.
1458  */
1459 DWORD WINAPI SHLWAPI_205(HKEY hkey, LPCSTR pSubKey, LPCSTR pValue,
1460                          LPDWORD pwType, LPVOID pvData, LPDWORD pbData)
1461 {
1462   if (GetSystemMetrics(SM_CLEANBOOT))
1463     return ERROR_INVALID_FUNCTION;
1464   return SHGetValueA(hkey, pSubKey, pValue, pwType, pvData, pbData);
1465 }
1466
1467 /*************************************************************************
1468  * @   [SHLWAPI.206]
1469  *
1470  * Unicode version of SHLWAPI_205.
1471  */
1472 DWORD WINAPI SHLWAPI_206(HKEY hkey, LPCWSTR pSubKey, LPCWSTR pValue,
1473                          LPDWORD pwType, LPVOID pvData, LPDWORD pbData)
1474 {
1475   if (GetSystemMetrics(SM_CLEANBOOT))
1476     return ERROR_INVALID_FUNCTION;
1477   return SHGetValueW(hkey, pSubKey, pValue, pwType, pvData, pbData);
1478 }
1479
1480 /*************************************************************************
1481  * @   [SHLWAPI.320]
1482  *
1483  * Set a content type in the registry.
1484  *
1485  * PARAMS
1486  *   hKey       [I] Handle to registry key
1487  *   lpszSubKey [I] Name of sub key under hKey
1488  *   lpszValue  [I] Value to set
1489  *
1490  * RETURNS
1491  *   Success: TRUE
1492  *   Failure: FALSE
1493  */
1494 BOOL WINAPI SHLWAPI_320(LPCSTR lpszSubKey, LPCSTR lpszValue)
1495 {
1496   DWORD dwRet;
1497
1498   if (!lpszValue)
1499   {
1500     WARN("Invalid lpszValue would crash under Win32!");
1501     return FALSE;
1502   }
1503
1504   dwRet = SHSetValueA(HKEY_CLASSES_ROOT, lpszSubKey, lpszContentTypeA,
1505                       REG_SZ, lpszValue, strlen(lpszValue));
1506   return dwRet ? FALSE : TRUE;
1507 }
1508
1509 /*************************************************************************
1510  * @   [SHLWAPI.321]
1511  *
1512  * Unicode version of SHLWAPI_320.
1513  */
1514 BOOL WINAPI SHLWAPI_321(LPCWSTR lpszSubKey, LPCWSTR lpszValue)
1515 {
1516   DWORD dwRet;
1517
1518   if (!lpszValue)
1519   {
1520     WARN("Invalid lpszValue would crash under Win32!");
1521     return FALSE;
1522   }
1523
1524   dwRet = SHSetValueW(HKEY_CLASSES_ROOT, lpszSubKey, lpszContentTypeW,
1525                       REG_SZ, lpszValue, strlenW(lpszValue));
1526   return dwRet ? FALSE : TRUE;
1527 }
1528
1529 /*************************************************************************
1530  * @   [SHLWAPI.322]
1531  *
1532  * Delete a content type from the registry.
1533  *
1534  * PARAMS
1535  *   lpszSubKey [I] Name of sub key
1536  *
1537  * RETURNS
1538  *   Success: TRUE
1539  *   Failure: FALSE
1540  */
1541 BOOL WINAPI SHLWAPI_322(LPCSTR lpszSubKey)
1542 {
1543   HRESULT ret = SHDeleteValueA(HKEY_CLASSES_ROOT, lpszSubKey, lpszContentTypeA);
1544   return ret ? FALSE : TRUE;
1545 }
1546
1547 /*************************************************************************
1548  * @   [SHLWAPI.323]
1549  *
1550  * Unicode version of SHLWAPI_322.
1551  */
1552 BOOL WINAPI SHLWAPI_323(LPCWSTR lpszSubKey)
1553 {
1554   HRESULT ret = SHDeleteValueW(HKEY_CLASSES_ROOT, lpszSubKey, lpszContentTypeW);
1555   return ret ? FALSE : TRUE;
1556 }
1557
1558
1559 /*************************************************************************
1560  * SHRegDuplicateHKey   [SHLWAPI.@]
1561  */
1562 HKEY WINAPI SHRegDuplicateHKey(HKEY hKey)
1563 {
1564     HKEY newKey = 0;
1565
1566     RegOpenKeyExA(hKey, 0, 0, MAXIMUM_ALLOWED, &newKey);
1567     TRACE("new key is %08x\n", newKey);
1568     return newKey;
1569 }