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

   1 /*
   2  * SHLWAPI registry functions
   3  *
   4  * Copyright 1998 Juergen Schmied
   5  * Copyright 2001 Guy Albertelli
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21
  22 #include <stdarg.h>
  23 #include <string.h>
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "winuser.h"
  27 #include "winreg.h"
  28 #include "wine/debug.h"
  29 #define NO_SHLWAPI_STREAM
  30 #include "shlwapi.h"
  31 #include "wine/unicode.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(shell);
  34
  35 /* Key/Value names for MIME content types */
  36 static const char *lpszContentTypeA = "Content Type";
  37 static const WCHAR lpszContentTypeW[] = { 'C','o','n','t','e','n','t',' ','T','y','p','e','\0'};
  38
  39 static const char *szMimeDbContentA = "MIME\\Database\\Content Type\\";
  40 static const WCHAR szMimeDbContentW[] = { 'M', 'I', 'M','E','\\',
  41   'D','a','t','a','b','a','s','e','\\','C','o','n','t','e','n','t',
  42   ' ','T','y','p','e','\\', 0 };
  43 static const DWORD dwLenMimeDbContent = 27; /* strlen of szMimeDbContentA/W */
  44
  45 static const char *szExtensionA = "Extension";
  46 static const WCHAR szExtensionW[] = { 'E', 'x', 't','e','n','s','i','o','n','\0' };
  47
  48 /* internal structure of what the HUSKEY points to */
  49 typedef struct {
  50     HKEY     HKCUstart; /* Start key in CU hive */
  51     HKEY     HKCUkey;   /* Opened key in CU hive */
  52     HKEY     HKLMstart; /* Start key in LM hive */
  53     HKEY     HKLMkey;   /* Opened key in LM hive */
  54     WCHAR    lpszPath[MAX_PATH];
  55 } SHUSKEY, *LPSHUSKEY;
  56
  57 DWORD   WINAPI SHStringFromGUIDW(REFGUID,LPWSTR,INT);
  58 HRESULT WINAPI SHRegGetCLSIDKeyW(REFGUID,LPCWSTR,BOOL,BOOL,PHKEY);
  59
  60
  61 #define REG_HKCU  TRUE
  62 #define REG_HKLM  FALSE
  63 /*************************************************************************
  64  * REG_GetHKEYFromHUSKEY
  65  *
  66  * Function:  Return the proper registry key from the HUSKEY structure
  67  *            also allow special predefined values.
  68  */
  69 static HKEY WINAPI REG_GetHKEYFromHUSKEY(HUSKEY hUSKey, BOOL which)
  70 {
  71         HKEY test = (HKEY) hUSKey;
  72         LPSHUSKEY mihk = (LPSHUSKEY) hUSKey;
  73
  74         if ((test == HKEY_CLASSES_ROOT)        ||
  75             (test == HKEY_CURRENT_CONFIG)      ||
  76             (test == HKEY_CURRENT_USER)        ||
  77             (test == HKEY_DYN_DATA)            ||
  78             (test == HKEY_LOCAL_MACHINE)       ||
  79             (test == HKEY_PERFORMANCE_DATA)    ||
  80 /* FIXME:  need to define for Win2k, ME, XP
  81  *          (test == HKEY_PERFORMANCE_TEXT)    ||
  82  *          (test == HKEY_PERFORMANCE_NLSTEXT) ||
  83  */
  84             (test == HKEY_USERS)) return test;
  85         if (which == REG_HKCU) return mihk->HKCUkey;
  86         return mihk->HKLMkey;
  87 }
  88
  89
  90 /*************************************************************************
  91  * SHRegOpenUSKeyA      [SHLWAPI.@]
  92  *
  93  * Open a user-specific registry key.
  94  *
  95  * PARAMS
  96  *  Path           [I] Key name to open
  97  *  AccessType     [I] Access type
  98  *  hRelativeUSKey [I] Relative user key
  99  *  phNewUSKey     [O] Destination for created key
 100  *  fIgnoreHKCU    [I] TRUE=Don't check HKEY_CURRENT_USER
 101  *
 102  * RETURNS
 103  *  Success: ERROR_SUCCESS
 104  *  Failure: An error code from RegOpenKeyExA().
 105  */
 106 LONG WINAPI SHRegOpenUSKeyA(LPCSTR Path, REGSAM AccessType, HUSKEY hRelativeUSKey,
 107                             PHUSKEY phNewUSKey, BOOL fIgnoreHKCU)
 108 {
 109     WCHAR szPath[MAX_PATH];
 110
 111     if (Path)
 112       MultiByteToWideChar(CP_ACP, 0, Path, -1, szPath, MAX_PATH);
 113
 114     return SHRegOpenUSKeyW(Path ? szPath : NULL, AccessType, hRelativeUSKey,
 115                            phNewUSKey, fIgnoreHKCU);
 116 }
 117
 118 /*************************************************************************
 119  * SHRegOpenUSKeyW      [SHLWAPI.@]
 120  *
 121  * See SHRegOpenUSKeyA.
 122  */
 123 LONG WINAPI SHRegOpenUSKeyW(LPCWSTR Path, REGSAM AccessType, HUSKEY hRelativeUSKey,
 124                             PHUSKEY phNewUSKey, BOOL fIgnoreHKCU)
 125 {
 126     LONG ret2, ret1 = ~ERROR_SUCCESS;
 127     LPSHUSKEY hKey;
 128
 129     TRACE("(%s,0x%lx,%p,%p,%d)\n", debugstr_w(Path),(LONG)AccessType,
 130           hRelativeUSKey, phNewUSKey, fIgnoreHKCU);
 131
 132     if (phNewUSKey)
 133         *phNewUSKey = NULL;
 134
 135     /* Create internal HUSKEY */
 136     hKey = (LPSHUSKEY)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*hKey));
 137     lstrcpynW(hKey->lpszPath, Path, sizeof(hKey->lpszPath));
 138
 139     if (hRelativeUSKey)
 140     {
 141         hKey->HKCUstart = SHRegDuplicateHKey(REG_GetHKEYFromHUSKEY(hRelativeUSKey, REG_HKCU));
 142         hKey->HKLMstart = SHRegDuplicateHKey(REG_GetHKEYFromHUSKEY(hRelativeUSKey, REG_HKLM));
 143
 144         /* FIXME: if either of these keys is NULL, create the start key from
 145          *        the relative keys start+path
 146          */
 147     }
 148     else
 149     {
 150         hKey->HKCUstart = HKEY_CURRENT_USER;
 151         hKey->HKLMstart = HKEY_LOCAL_MACHINE;
 152     }
 153
 154     if (!fIgnoreHKCU)
 155     {
 156         ret1 = RegOpenKeyExW(hKey->HKCUstart, hKey->lpszPath, 0, AccessType, &hKey->HKCUkey);
 157         if (ret1)
 158             hKey->HKCUkey = 0;
 159     }
 160
 161     ret2 = RegOpenKeyExW(hKey->HKLMstart, hKey->lpszPath, 0, AccessType, &hKey->HKLMkey);
 162     if (ret2)
 163         hKey->HKLMkey = 0;
 164
 165     if (ret1 || ret2)
 166         TRACE("one or more opens failed: HKCU=%ld HKLM=%ld\n", ret1, ret2);
 167
 168     if (ret1 && ret2)
 169     {
 170         /* Neither open succeeded: fail */
 171         SHRegCloseUSKey(hKey);
 172         return ret2;
 173     }
 174
 175     TRACE("HUSKEY=%p\n", hKey);
 176     if (phNewUSKey)
 177         *phNewUSKey = (HUSKEY)hKey;
 178     return ERROR_SUCCESS;
 179 }
 180
 181 /*************************************************************************
 182  * SHRegCloseUSKey      [SHLWAPI.@]
 183  *
 184  * Close a user-specific registry key
 185  *
 186  * RETURNS
 187  *  Success: ERROR_SUCCESS
 188  *  Failure: An error code from RegCloseKey().
 189  */
 190 LONG WINAPI SHRegCloseUSKey(
 191         HUSKEY hUSKey) /* [I] Key to close */
 192 {
 193     LPSHUSKEY hKey = (LPSHUSKEY)hUSKey;
 194     LONG ret = ERROR_SUCCESS;
 195
 196     if (hKey->HKCUkey)
 197         ret = RegCloseKey(hKey->HKCUkey);
 198     if (hKey->HKCUstart && hKey->HKCUstart != HKEY_CURRENT_USER)
 199         ret = RegCloseKey(hKey->HKCUstart);
 200     if (hKey->HKLMkey)
 201         ret = RegCloseKey(hKey->HKLMkey);
 202     if (hKey->HKLMstart && hKey->HKLMstart != HKEY_LOCAL_MACHINE)
 203         ret = RegCloseKey(hKey->HKCUstart);
 204
 205     HeapFree(GetProcessHeap(), 0, hKey);
 206     return ret;
 207 }
 208
 209 /*************************************************************************
 210  *      SHRegQueryUSValueA      [SHLWAPI.@]
 211  *
 212  * Query a user-specific registry value.
 213  *
 214  * RETURNS
 215  *  Success: ERROR_SUCCESS
 216  *  Failure: An error code from RegQueryValueExA().
 217  */
 218 LONG WINAPI SHRegQueryUSValueA(
 219         HUSKEY hUSKey, /* [I] Key to query */
 220         LPCSTR pszValue, /* [I] Value name under hUSKey */
 221         LPDWORD pdwType, /* [O] Destination for value type */
 222         LPVOID pvData, /* [O] Destination for value data */
 223         LPDWORD pcbData, /* [O] Destination for value length */
 224         BOOL fIgnoreHKCU,  /* [I] TRUE=Don't check HKEY_CURRENT_USER */
 225         LPVOID pvDefaultData, /* [I] Default data if pszValue does not exist */
 226         DWORD dwDefaultDataSize) /* [I] Length of pvDefaultData */
 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  * See SHRegQueryUSValueA.
 268  */
 269 LONG WINAPI SHRegQueryUSValueW(
 270         HUSKEY hUSKey,
 271         LPCWSTR pszValue,
 272         LPDWORD pdwType,
 273         LPVOID pvData,
 274         LPDWORD pcbData,
 275         BOOL fIgnoreHKCU,
 276         LPVOID pvDefaultData,
 277         DWORD dwDefaultDataSize)
 278 {
 279         LONG ret = ~ERROR_SUCCESS;
 280         LONG i, maxmove;
 281         HKEY dokey;
 282         CHAR *src, *dst;
 283
 284         /* if user wants HKCU, and it exists, then try it */
 285         if (!fIgnoreHKCU && (dokey = REG_GetHKEYFromHUSKEY(hUSKey,REG_HKCU))) {
 286             ret = RegQueryValueExW(dokey,
 287                                    pszValue, 0, pdwType, pvData, pcbData);
 288             TRACE("HKCU RegQueryValue returned %08lx\n", ret);
 289         }
 290
 291         /* if HKCU did not work and HKLM exists, then try it */
 292         if ((ret != ERROR_SUCCESS) &&
 293             (dokey = REG_GetHKEYFromHUSKEY(hUSKey,REG_HKLM))) {
 294             ret = RegQueryValueExW(dokey,
 295                                    pszValue, 0, pdwType, pvData, pcbData);
 296             TRACE("HKLM RegQueryValue returned %08lx\n", ret);
 297         }
 298
 299         /* if neither worked, and default data exists, then use it */
 300         if (ret != ERROR_SUCCESS) {
 301             if (pvDefaultData && (dwDefaultDataSize != 0)) {
 302                 maxmove = (dwDefaultDataSize >= *pcbData) ? *pcbData : dwDefaultDataSize;
 303                 src = (CHAR*)pvDefaultData;
 304                 dst = (CHAR*)pvData;
 305                 for(i=0; i<maxmove; i++) *dst++ = *src++;
 306                 *pcbData = maxmove;
 307                 TRACE("setting default data\n");
 308                 ret = ERROR_SUCCESS;
 309             }
 310         }
 311         return ret;
 312 }
 313
 314 /*************************************************************************
 315  * SHRegGetUSValueA     [SHLWAPI.@]
 316  *
 317  * Get a user-specific registry value.
 318  *
 319  * RETURNS
 320  *  Success: ERROR_SUCCESS
 321  *  Failure: An error code from SHRegOpenUSKeyA() or SHRegQueryUSValueA().
 322  *
 323  * NOTES
 324  *   This function opens pSubKey, queries the value, and then closes the key.
 325  */
 326 LONG WINAPI SHRegGetUSValueA(
 327         LPCSTR   pSubKey, /* [I] Key name to open */
 328         LPCSTR   pValue, /* [I] Value name to open */
 329         LPDWORD  pwType, /* [O] Destination for the type of the value */
 330         LPVOID   pvData, /* [O] Destination for the value */
 331         LPDWORD  pcbData, /* [I] Destination for the length of the value **/
 332         BOOL     flagIgnoreHKCU, /* [I] TRUE=Don't check HKEY_CURRENT_USER */
 333         LPVOID   pDefaultData, /* [I] Default value if it doesn't exist */
 334         DWORD    wDefaultDataSize) /* [I] Length of pDefaultData */
 335 {
 336         HUSKEY myhuskey;
 337         LONG ret;
 338
 339         if (!pvData || !pcbData) return ERROR_INVALID_FUNCTION; /* FIXME:wrong*/
 340         TRACE("key '%s', value '%s', datalen %ld,  %s\n",
 341               debugstr_a(pSubKey), debugstr_a(pValue), *pcbData,
 342               (flagIgnoreHKCU) ? "Ignoring HKCU" : "Tries HKCU then HKLM");
 343
 344         ret = SHRegOpenUSKeyA(pSubKey, 0x1, 0, &myhuskey, flagIgnoreHKCU);
 345         if (ret == ERROR_SUCCESS) {
 346             ret = SHRegQueryUSValueA(myhuskey, pValue, pwType, pvData,
 347                                      pcbData, flagIgnoreHKCU, pDefaultData,
 348                                      wDefaultDataSize);
 349             SHRegCloseUSKey(myhuskey);
 350         }
 351         return ret;
 352 }
 353
 354 /*************************************************************************
 355  * SHRegGetUSValueW     [SHLWAPI.@]
 356  *
 357  * See SHRegGetUSValueA.
 358  */
 359 LONG WINAPI SHRegGetUSValueW(
 360         LPCWSTR  pSubKey,
 361         LPCWSTR  pValue,
 362         LPDWORD  pwType,
 363         LPVOID   pvData,
 364         LPDWORD  pcbData,
 365         BOOL     flagIgnoreHKCU,
 366         LPVOID   pDefaultData,
 367         DWORD    wDefaultDataSize)
 368 {
 369         HUSKEY myhuskey;
 370         LONG ret;
 371
 372         if (!pvData || !pcbData) return ERROR_INVALID_FUNCTION; /* FIXME:wrong*/
 373         TRACE("key '%s', value '%s', datalen %ld,  %s\n",
 374               debugstr_w(pSubKey), debugstr_w(pValue), *pcbData,
 375               (flagIgnoreHKCU) ? "Ignoring HKCU" : "Tries HKCU then HKLM");
 376
 377         ret = SHRegOpenUSKeyW(pSubKey, 0x1, 0, &myhuskey, flagIgnoreHKCU);
 378         if (ret == ERROR_SUCCESS) {
 379             ret = SHRegQueryUSValueW(myhuskey, pValue, pwType, pvData,
 380                                      pcbData, flagIgnoreHKCU, pDefaultData,
 381                                      wDefaultDataSize);
 382             SHRegCloseUSKey(myhuskey);
 383         }
 384         return ret;
 385 }
 386
 387 /*************************************************************************
 388  * SHRegSetUSValueA   [SHLWAPI.@]
 389  *
 390  * Set a user-specific registry value.
 391  *
 392  * PARAMS
 393  *  pszSubKey [I] Name of key to set the value in
 394  *  pszValue  [I] Name of value under pszSubKey to set the value in
 395  *  dwType    [I] Type of the value
 396  *  pvData    [I] Data to set as the value
 397  *  cbData    [I] length of pvData
 398  *  dwFlags   [I] SHREGSET_ flags from "shlwapi.h"
 399  *
 400  * RETURNS
 401  *  Success: ERROR_SUCCESS
 402  *  Failure: An error code from SHRegOpenUSKeyA() or SHRegWriteUSValueA(), or
 403  *           ERROR_INVALID_FUNCTION if pvData is NULL.
 404  *
 405  * NOTES
 406  *   This function opens pszSubKey, sets the value, and then closes the key.
 407  */
 408 LONG WINAPI SHRegSetUSValueA(LPCSTR pszSubKey, LPCSTR pszValue, DWORD dwType,
 409                              LPVOID pvData, DWORD cbData, DWORD dwFlags)
 410 {
 411   BOOL ignoreHKCU = TRUE;
 412   HUSKEY hkey;
 413   LONG ret;
 414
 415   TRACE("(%s,%s,%ld,%p,%ld,0x%08lx\n", debugstr_a(pszSubKey), debugstr_a(pszValue),
 416         dwType, pvData, cbData, dwFlags);
 417
 418   if (!pvData)
 419     return ERROR_INVALID_FUNCTION;
 420
 421   if (dwFlags & SHREGSET_HKCU || dwFlags & SHREGSET_FORCE_HKCU)
 422     ignoreHKCU = FALSE;
 423
 424   ret = SHRegOpenUSKeyA(pszSubKey, KEY_ALL_ACCESS, 0, &hkey, ignoreHKCU);
 425   if (ret == ERROR_SUCCESS)
 426   {
 427     ret = SHRegWriteUSValueA(hkey, pszValue, dwType, pvData, cbData, dwFlags);
 428     SHRegCloseUSKey(hkey);
 429   }
 430   return ret;
 431 }
 432
 433 /*************************************************************************
 434  * SHRegSetUSValueW   [SHLWAPI.@]
 435  *
 436  * See SHRegSetUSValueA.
 437  */
 438 LONG WINAPI SHRegSetUSValueW(LPCWSTR pszSubKey, LPCWSTR pszValue, DWORD dwType,
 439                              LPVOID pvData, DWORD cbData, DWORD dwFlags)
 440 {
 441   BOOL ignoreHKCU = TRUE;
 442   HUSKEY hkey;
 443   LONG ret;
 444
 445   TRACE("(%s,%s,%ld,%p,%ld,0x%08lx\n", debugstr_w(pszSubKey), debugstr_w(pszValue),
 446         dwType, pvData, cbData, dwFlags);
 447
 448   if (!pvData)
 449     return ERROR_INVALID_FUNCTION;
 450
 451   if (dwFlags & SHREGSET_HKCU || dwFlags & SHREGSET_FORCE_HKCU)
 452     ignoreHKCU = FALSE;
 453
 454   ret = SHRegOpenUSKeyW(pszSubKey, KEY_ALL_ACCESS, 0, &hkey, ignoreHKCU);
 455   if (ret == ERROR_SUCCESS)
 456   {
 457     ret = SHRegWriteUSValueW(hkey, pszValue, dwType, pvData, cbData, dwFlags);
 458     SHRegCloseUSKey(hkey);
 459   }
 460   return ret;
 461 }
 462
 463 /*************************************************************************
 464  * SHRegGetBoolUSValueA   [SHLWAPI.@]
 465  *
 466  * Get a user-specific registry boolean value.
 467  *
 468  * RETURNS
 469  *  Success: ERROR_SUCCESS
 470  *  Failure: An error code from SHRegOpenUSKeyA() or SHRegQueryUSValueA().
 471  *
 472  * NOTES
 473  *   This function opens pszSubKey, queries the value, and then closes the key.
 474  *
 475  *   Boolean values are one of the following:
 476  *   True: YES,TRUE,non-zero
 477  *   False: NO,FALSE,0
 478  */
 479 BOOL WINAPI SHRegGetBoolUSValueA(
 480         LPCSTR pszSubKey, /* [I] Key name to open */
 481         LPCSTR pszValue, /* [I] Value name to open */
 482         BOOL fIgnoreHKCU, /* [I] TRUE=Don't check HKEY_CURRENT_USER */
 483         BOOL fDefault) /* [I] Default value to use if pszValue is not present */
 484 {
 485         LONG retvalue;
 486         DWORD type, datalen, work;
 487         BOOL ret = fDefault;
 488         CHAR data[10];
 489
 490         TRACE("key '%s', value '%s', %s\n",
 491               debugstr_a(pszSubKey), debugstr_a(pszValue),
 492               (fIgnoreHKCU) ? "Ignoring HKCU" : "Tries HKCU then HKLM");
 493
 494         datalen = sizeof(data)-1;
 495         if (!(retvalue = SHRegGetUSValueA( pszSubKey, pszValue, &type,
 496                                            data, &datalen,
 497                                            fIgnoreHKCU, 0, 0))) {
 498             /* process returned data via type into bool */
 499             switch (type) {
 500             case REG_SZ:
 501                 data[9] = '\0';     /* set end of string */
 502                 if (lstrcmpiA(data, "YES") == 0) ret = TRUE;
 503                 if (lstrcmpiA(data, "TRUE") == 0) ret = TRUE;
 504                 if (lstrcmpiA(data, "NO") == 0) ret = FALSE;
 505                 if (lstrcmpiA(data, "FALSE") == 0) ret = FALSE;
 506                 break;
 507             case REG_DWORD:
 508                 work = *(LPDWORD)data;
 509                 ret = (work != 0);
 510                 break;
 511             case REG_BINARY:
 512                 if (datalen == 1) {
 513                     ret = (data[0] != '\0');
 514                     break;
 515                 }
 516             default:
 517                 FIXME("Unsupported registry data type %ld\n", type);
 518                 ret = FALSE;
 519             }
 520             TRACE("got value (type=%ld), returing <%s>\n", type,
 521                   (ret) ? "TRUE" : "FALSE");
 522         }
 523         else {
 524             ret = fDefault;
 525             TRACE("returning default data <%s>\n",
 526                   (ret) ? "TRUE" : "FALSE");
 527         }
 528         return ret;
 529 }
 530
 531 /*************************************************************************
 532  * SHRegGetBoolUSValueW   [SHLWAPI.@]
 533  *
 534  * See SHRegGetBoolUSValueA.
 535  */
 536 BOOL WINAPI SHRegGetBoolUSValueW(
 537         LPCWSTR pszSubKey,
 538         LPCWSTR pszValue,
 539         BOOL fIgnoreHKCU,
 540         BOOL fDefault)
 541 {
 542         static const WCHAR wYES[]=  {'Y','E','S','\0'};
 543         static const WCHAR wTRUE[]= {'T','R','U','E','\0'};
 544         static const WCHAR wNO[]=   {'N','O','\0'};
 545         static const WCHAR wFALSE[]={'F','A','L','S','E','\0'};
 546         LONG retvalue;
 547         DWORD type, datalen, work;
 548         BOOL ret = fDefault;
 549         WCHAR data[10];
 550
 551         TRACE("key '%s', value '%s', %s\n",
 552               debugstr_w(pszSubKey), debugstr_w(pszValue),
 553               (fIgnoreHKCU) ? "Ignoring HKCU" : "Tries HKCU then HKLM");
 554
 555         datalen = (sizeof(data)-1) * sizeof(WCHAR);
 556         if (!(retvalue = SHRegGetUSValueW( pszSubKey, pszValue, &type,
 557                                            data, &datalen,
 558                                            fIgnoreHKCU, 0, 0))) {
 559             /* process returned data via type into bool */
 560             switch (type) {
 561             case REG_SZ:
 562                 data[9] = L'\0';     /* set end of string */
 563                 if (lstrcmpiW(data, wYES)==0 || lstrcmpiW(data, wTRUE)==0)
 564                     ret = TRUE;
 565                 else if (lstrcmpiW(data, wNO)==0 || lstrcmpiW(data, wFALSE)==0)
 566                     ret = FALSE;
 567                 break;
 568             case REG_DWORD:
 569                 work = *(LPDWORD)data;
 570                 ret = (work != 0);
 571                 break;
 572             case REG_BINARY:
 573                 if (datalen == 1) {
 574                     ret = (data[0] != L'\0');
 575                     break;
 576                 }
 577             default:
 578                 FIXME("Unsupported registry data type %ld\n", type);
 579                 ret = FALSE;
 580             }
 581             TRACE("got value (type=%ld), returing <%s>\n", type,
 582                   (ret) ? "TRUE" : "FALSE");
 583         }
 584         else {
 585             ret = fDefault;
 586             TRACE("returning default data <%s>\n",
 587                   (ret) ? "TRUE" : "FALSE");
 588         }
 589         return ret;
 590 }
 591
 592 /*************************************************************************
 593  *      SHRegQueryInfoUSKeyA    [SHLWAPI.@]
 594  *
 595  * Get information about a user-specific registry key.
 596  *
 597  * RETURNS
 598  *  Success: ERROR_SUCCESS
 599  *  Failure: An error code from RegQueryInfoKeyA().
 600  */
 601 LONG WINAPI SHRegQueryInfoUSKeyA(
 602         HUSKEY hUSKey, /* [I] Key to query */
 603         LPDWORD pcSubKeys, /* [O] Destination for number of sub keys */
 604         LPDWORD pcchMaxSubKeyLen, /* [O] Destination for the length of the biggest sub key name */
 605         LPDWORD pcValues, /* [O] Destination for number of values */
 606         LPDWORD pcchMaxValueNameLen,/* [O] Destination for the length of the biggest value */
 607         SHREGENUM_FLAGS enumRegFlags)  /* [in] SHREGENUM_ flags from "shlwapi.h" */
 608 {
 609         HKEY dokey;
 610         LONG ret;
 611
 612         TRACE("(%p,%p,%p,%p,%p,%d)\n",
 613               hUSKey,pcSubKeys,pcchMaxSubKeyLen,pcValues,
 614               pcchMaxValueNameLen,enumRegFlags);
 615
 616         /* if user wants HKCU, and it exists, then try it */
 617         if (((enumRegFlags == SHREGENUM_HKCU) ||
 618              (enumRegFlags == SHREGENUM_DEFAULT)) &&
 619             (dokey = REG_GetHKEYFromHUSKEY(hUSKey,REG_HKCU))) {
 620             ret = RegQueryInfoKeyA(dokey, 0, 0, 0,
 621                                    pcSubKeys, pcchMaxSubKeyLen, 0,
 622                                    pcValues, pcchMaxValueNameLen, 0, 0, 0);
 623             if ((ret == ERROR_SUCCESS) ||
 624                 (enumRegFlags == SHREGENUM_HKCU))
 625                 return ret;
 626         }
 627         if (((enumRegFlags == SHREGENUM_HKLM) ||
 628              (enumRegFlags == SHREGENUM_DEFAULT)) &&
 629             (dokey = REG_GetHKEYFromHUSKEY(hUSKey,REG_HKLM))) {
 630             return RegQueryInfoKeyA(dokey, 0, 0, 0,
 631                                     pcSubKeys, pcchMaxSubKeyLen, 0,
 632                                     pcValues, pcchMaxValueNameLen, 0, 0, 0);
 633         }
 634         return ERROR_INVALID_FUNCTION;
 635 }
 636
 637 /*************************************************************************
 638  *      SHRegQueryInfoUSKeyW    [SHLWAPI.@]
 639  *
 640  * See SHRegQueryInfoUSKeyA.
 641  */
 642 LONG WINAPI SHRegQueryInfoUSKeyW(
 643         HUSKEY hUSKey,
 644         LPDWORD pcSubKeys,
 645         LPDWORD pcchMaxSubKeyLen,
 646         LPDWORD pcValues,
 647         LPDWORD pcchMaxValueNameLen,
 648         SHREGENUM_FLAGS enumRegFlags)
 649 {
 650         HKEY dokey;
 651         LONG ret;
 652
 653         TRACE("(%p,%p,%p,%p,%p,%d)\n",
 654               hUSKey,pcSubKeys,pcchMaxSubKeyLen,pcValues,
 655               pcchMaxValueNameLen,enumRegFlags);
 656
 657         /* if user wants HKCU, and it exists, then try it */
 658         if (((enumRegFlags == SHREGENUM_HKCU) ||
 659              (enumRegFlags == SHREGENUM_DEFAULT)) &&
 660             (dokey = REG_GetHKEYFromHUSKEY(hUSKey,REG_HKCU))) {
 661             ret = RegQueryInfoKeyW(dokey, 0, 0, 0,
 662                                    pcSubKeys, pcchMaxSubKeyLen, 0,
 663                                    pcValues, pcchMaxValueNameLen, 0, 0, 0);
 664             if ((ret == ERROR_SUCCESS) ||
 665                 (enumRegFlags == SHREGENUM_HKCU))
 666                 return ret;
 667         }
 668         if (((enumRegFlags == SHREGENUM_HKLM) ||
 669              (enumRegFlags == SHREGENUM_DEFAULT)) &&
 670             (dokey = REG_GetHKEYFromHUSKEY(hUSKey,REG_HKLM))) {
 671             return RegQueryInfoKeyW(dokey, 0, 0, 0,
 672                                     pcSubKeys, pcchMaxSubKeyLen, 0,
 673                                     pcValues, pcchMaxValueNameLen, 0, 0, 0);
 674         }
 675         return ERROR_INVALID_FUNCTION;
 676 }
 677
 678 /*************************************************************************
 679  *      SHRegEnumUSKeyA         [SHLWAPI.@]
 680  *
 681  * Enumerate a user-specific registry key.
 682  *
 683  * RETURNS
 684  *  Success: ERROR_SUCCESS
 685  *  Failure: An error code from RegEnumKeyExA().
 686  */
 687 LONG WINAPI SHRegEnumUSKeyA(
 688         HUSKEY hUSKey,                 /* [in] Key to enumerate */
 689         DWORD dwIndex,                 /* [in] Index within hUSKey */
 690         LPSTR pszName,                 /* [out] Name of the enumerated value */
 691         LPDWORD pcchValueNameLen,      /* [in/out] Length of pszName */
 692         SHREGENUM_FLAGS enumRegFlags)  /* [in] SHREGENUM_ flags from "shlwapi.h" */
 693 {
 694         HKEY dokey;
 695
 696         TRACE("(%p,%ld,%p,%p(%ld),%d)\n",
 697               hUSKey, dwIndex, pszName, pcchValueNameLen,
 698               *pcchValueNameLen, enumRegFlags);
 699
 700         if (((enumRegFlags == SHREGENUM_HKCU) ||
 701              (enumRegFlags == SHREGENUM_DEFAULT)) &&
 702             (dokey = REG_GetHKEYFromHUSKEY(hUSKey,REG_HKCU))) {
 703             return RegEnumKeyExA(dokey, dwIndex, pszName, pcchValueNameLen,
 704                                 0, 0, 0, 0);
 705         }
 706
 707         if (((enumRegFlags == SHREGENUM_HKLM) ||
 708              (enumRegFlags == SHREGENUM_DEFAULT)) &&
 709             (dokey = REG_GetHKEYFromHUSKEY(hUSKey,REG_HKLM))) {
 710             return RegEnumKeyExA(dokey, dwIndex, pszName, pcchValueNameLen,
 711                                 0, 0, 0, 0);
 712         }
 713         FIXME("no support for SHREGENUM_BOTH\n");
 714         return ERROR_INVALID_FUNCTION;
 715 }
 716
 717 /*************************************************************************
 718  *      SHRegEnumUSKeyW         [SHLWAPI.@]
 719  *
 720  * See SHRegEnumUSKeyA.
 721  */
 722 LONG WINAPI SHRegEnumUSKeyW(
 723         HUSKEY hUSKey,
 724         DWORD dwIndex,
 725         LPWSTR pszName,
 726         LPDWORD pcchValueNameLen,
 727         SHREGENUM_FLAGS enumRegFlags)
 728 {
 729         HKEY dokey;
 730
 731         TRACE("(%p,%ld,%p,%p(%ld),%d)\n",
 732               hUSKey, dwIndex, pszName, pcchValueNameLen,
 733               *pcchValueNameLen, enumRegFlags);
 734
 735         if (((enumRegFlags == SHREGENUM_HKCU) ||
 736              (enumRegFlags == SHREGENUM_DEFAULT)) &&
 737             (dokey = REG_GetHKEYFromHUSKEY(hUSKey,REG_HKCU))) {
 738             return RegEnumKeyExW(dokey, dwIndex, pszName, pcchValueNameLen,
 739                                 0, 0, 0, 0);
 740         }
 741
 742         if (((enumRegFlags == SHREGENUM_HKLM) ||
 743              (enumRegFlags == SHREGENUM_DEFAULT)) &&
 744             (dokey = REG_GetHKEYFromHUSKEY(hUSKey,REG_HKLM))) {
 745             return RegEnumKeyExW(dokey, dwIndex, pszName, pcchValueNameLen,
 746                                 0, 0, 0, 0);
 747         }
 748         FIXME("no support for SHREGENUM_BOTH\n");
 749         return ERROR_INVALID_FUNCTION;
 750 }
 751
 752
 753 /*************************************************************************
 754  *      SHRegWriteUSValueA      [SHLWAPI.@]
 755  *
 756  * Write a user-specific registry value.
 757  *
 758  * PARAMS
 759  *  hUSKey   [I] Key to write the value to
 760  *  pszValue [I] Name of value under hUSKey to write the value as
 761  *  dwType   [I] Type of the value
 762  *  pvData   [I] Data to set as the value
 763  *  cbData   [I] length of pvData
 764  *  dwFlags  [I] SHREGSET_ flags from "shlwapi.h"
 765  *
 766  * RETURNS
 767  *  Success: ERROR_SUCCESS.
 768  *  Failure: ERROR_INVALID_PARAMETER, if any parameter is invalid, otherwise
 769  *           an error code from RegSetValueExA().
 770  *
 771  * NOTES
 772  *  dwFlags must have at least SHREGSET_FORCE_HKCU or SHREGSET_FORCE_HKLM set.
 773  */
 774 LONG  WINAPI SHRegWriteUSValueA(HUSKEY hUSKey, LPCSTR pszValue, DWORD dwType,
 775                                 LPVOID pvData, DWORD cbData, DWORD dwFlags)
 776 {
 777     WCHAR szValue[MAX_PATH];
 778
 779     if (pszValue)
 780       MultiByteToWideChar(CP_ACP, 0, pszValue, -1, szValue, MAX_PATH);
 781
 782     return SHRegWriteUSValueW(hUSKey, pszValue ? szValue : NULL, dwType,
 783                                pvData, cbData, dwFlags);
 784 }
 785
 786 /*************************************************************************
 787  *      SHRegWriteUSValueW      [SHLWAPI.@]
 788  *
 789  * See SHRegWriteUSValueA.
 790  */
 791 LONG  WINAPI SHRegWriteUSValueW(HUSKEY hUSKey, LPCWSTR pszValue, DWORD dwType,
 792                                 LPVOID pvData, DWORD cbData, DWORD dwFlags)
 793 {
 794     LONG dummy;
 795     LPSHUSKEY hKey = (LPSHUSKEY)hUSKey;
 796     LONG ret = ERROR_SUCCESS;
 797
 798     TRACE("(%p,%s,%ld,%p,%ld,%ld)\n", hUSKey, debugstr_w(pszValue),
 799           dwType, pvData, cbData, dwFlags);
 800
 801     if (!hUSKey || IsBadWritePtr(hUSKey, sizeof(SHUSKEY)) ||
 802         !(dwFlags & (SHREGSET_FORCE_HKCU|SHREGSET_FORCE_HKLM)))
 803         return ERROR_INVALID_PARAMETER;
 804
 805     if (dwFlags & (SHREGSET_FORCE_HKCU|SHREGSET_HKCU))
 806     {
 807         if (!hKey->HKCUkey)
 808         {
 809             /* Create the key */
 810             ret = RegCreateKeyW(hKey->HKCUstart, hKey->lpszPath, &hKey->HKCUkey);
 811             TRACE("Creating HKCU key, ret = %ld\n", ret);
 812             if (ret && (dwFlags & (SHREGSET_FORCE_HKCU)))
 813             {
 814                 hKey->HKCUkey = 0;
 815                 return ret;
 816             }
 817         }
 818
 819         if (!ret)
 820         {
 821             if ((dwFlags & SHREGSET_FORCE_HKCU) ||
 822                 RegQueryValueExW(hKey->HKCUkey, pszValue, NULL, NULL, NULL, &dummy))
 823             {
 824                 /* Doesn't exist or we are forcing: Write value */
 825                 ret = RegSetValueExW(hKey->HKCUkey, pszValue, 0, dwType, pvData, cbData);
 826                 TRACE("Writing HKCU value, ret = %ld\n", ret);
 827             }
 828         }
 829     }
 830
 831     if (dwFlags & (SHREGSET_FORCE_HKLM|SHREGSET_HKLM))
 832     {
 833         if (!hKey->HKLMkey)
 834         {
 835             /* Create the key */
 836             ret = RegCreateKeyW(hKey->HKLMstart, hKey->lpszPath, &hKey->HKLMkey);
 837             TRACE("Creating HKLM key, ret = %ld\n", ret);
 838             if (ret && (dwFlags & (SHREGSET_FORCE_HKLM)))
 839             {
 840                 hKey->HKLMkey = 0;
 841                 return ret;
 842             }
 843         }
 844
 845         if (!ret)
 846         {
 847             if ((dwFlags & SHREGSET_FORCE_HKLM) ||
 848                 RegQueryValueExW(hKey->HKLMkey, pszValue, NULL, NULL, NULL, &dummy))
 849             {
 850                 /* Doesn't exist or we are forcing: Write value */
 851                 ret = RegSetValueExW(hKey->HKLMkey, pszValue, 0, dwType, pvData, cbData);
 852                 TRACE("Writing HKLM value, ret = %ld\n", ret);
 853             }
 854         }
 855     }
 856
 857     return ret;
 858 }
 859
 860 /*************************************************************************
 861  * SHRegGetPathA   [SHLWAPI.@]
 862  *
 863  * Get a path from the registry.
 864  *
 865  * PARAMS
 866  *   hKey       [I] Handle to registry key
 867  *   lpszSubKey [I] Name of sub key containing path to get
 868  *   lpszValue  [I] Name of value containing path to get
 869  *   lpszPath   [O] Buffer for returned path
 870  *   dwFlags    [I] Reserved
 871  *
 872  * RETURNS
 873  *   Success: ERROR_SUCCESS. lpszPath contains the path.
 874  *   Failure: An error code from RegOpenKeyExA() or SHQueryValueExA().
 875  */
 876 DWORD WINAPI SHRegGetPathA(HKEY hKey, LPCSTR lpszSubKey, LPCSTR lpszValue,
 877                            LPSTR lpszPath, DWORD dwFlags)
 878 {
 879   DWORD dwSize = MAX_PATH;
 880
 881   TRACE("(hkey=%p,%s,%s,%p,%ld)\n", hKey, debugstr_a(lpszSubKey),
 882         debugstr_a(lpszValue), lpszPath, dwFlags);
 883
 884   return SHGetValueA(hKey, lpszSubKey, lpszValue, 0, lpszPath, &dwSize);
 885 }
 886
 887 /*************************************************************************
 888  * SHRegGetPathW   [SHLWAPI.@]
 889  *
 890  * See SHRegGetPathA.
 891  */
 892 DWORD WINAPI SHRegGetPathW(HKEY hKey, LPCWSTR lpszSubKey, LPCWSTR lpszValue,
 893                            LPWSTR lpszPath, DWORD dwFlags)
 894 {
 895   DWORD dwSize = MAX_PATH;
 896
 897   TRACE("(hkey=%p,%s,%s,%p,%ld)\n", hKey, debugstr_w(lpszSubKey),
 898         debugstr_w(lpszValue), lpszPath, dwFlags);
 899
 900   return SHGetValueW(hKey, lpszSubKey, lpszValue, 0, lpszPath, &dwSize);
 901 }
 902
 903
 904 /*************************************************************************
 905  * SHRegSetPathA   [SHLWAPI.@]
 906  *
 907  * Write a path to the registry.
 908  *
 909  * PARAMS
 910  *   hKey       [I] Handle to registry key
 911  *   lpszSubKey [I] Name of sub key containing path to set
 912  *   lpszValue  [I] Name of value containing path to set
 913  *   lpszPath   [O] Path to write
 914  *   dwFlags    [I] Reserved, must be 0.
 915  *
 916  * RETURNS
 917  *   Success: ERROR_SUCCESS.
 918  *   Failure: An error code from SHSetValueA().
 919  */
 920 DWORD WINAPI SHRegSetPathA(HKEY hKey, LPCSTR lpszSubKey, LPCSTR lpszValue,
 921                            LPCSTR lpszPath, DWORD dwFlags)
 922 {
 923   char szBuff[MAX_PATH];
 924
 925   FIXME("(hkey=%p,%s,%s,%p,%ld) - semi-stub\n",hKey, debugstr_a(lpszSubKey),
 926         debugstr_a(lpszValue), lpszPath, dwFlags);
 927
 928   lstrcpyA(szBuff, lpszPath);
 929
 930   /* FIXME: PathUnExpandEnvStringsA(szBuff); */
 931
 932   return SHSetValueA(hKey,lpszSubKey, lpszValue, REG_SZ, szBuff,
 933                      lstrlenA(szBuff));
 934 }
 935
 936 /*************************************************************************
 937  * SHRegSetPathW   [SHLWAPI.@]
 938  *
 939  * See SHRegSetPathA.
 940  */
 941 DWORD WINAPI SHRegSetPathW(HKEY hKey, LPCWSTR lpszSubKey, LPCWSTR lpszValue,
 942                            LPCWSTR lpszPath, DWORD dwFlags)
 943 {
 944   WCHAR szBuff[MAX_PATH];
 945
 946   FIXME("(hkey=%p,%s,%s,%p,%ld) - semi-stub\n",hKey, debugstr_w(lpszSubKey),
 947         debugstr_w(lpszValue), lpszPath, dwFlags);
 948
 949   lstrcpyW(szBuff, lpszPath);
 950
 951   /* FIXME: PathUnExpandEnvStringsW(szBuff); */
 952
 953   return SHSetValueW(hKey,lpszSubKey, lpszValue, REG_SZ, szBuff,
 954                      lstrlenW(szBuff));
 955 }
 956
 957 /*************************************************************************
 958  * SHGetValueA   [SHLWAPI.@]
 959  *
 960  * Get a value from the registry.
 961  *
 962  * PARAMS
 963  *   hKey       [I] Handle to registry key
 964  *   lpszSubKey [I] Name of sub key containing value to get
 965  *   lpszValue  [I] Name of value to get
 966  *   pwType     [O] Pointer to the values type
 967  *   pvData     [O] Pointer to the values data
 968  *   pcbData    [O] Pointer to the values size
 969  *
 970  * RETURNS
 971  *   Success: ERROR_SUCCESS. Output parameters contain the details read.
 972  *   Failure: An error code from RegOpenKeyExA() or SHQueryValueExA().
 973  */
 974 DWORD WINAPI SHGetValueA(HKEY hKey, LPCSTR lpszSubKey, LPCSTR lpszValue,
 975                          LPDWORD pwType, LPVOID pvData, LPDWORD pcbData)
 976 {
 977   DWORD dwRet = 0;
 978   HKEY hSubKey = 0;
 979
 980   TRACE("(hkey=%p,%s,%s,%p,%p,%p)\n", hKey, debugstr_a(lpszSubKey),
 981         debugstr_a(lpszValue), pwType, pvData, pcbData);
 982
 983   /*   lpszSubKey can be 0. In this case the value is taken from the
 984    *   current key.
 985    */
 986   if(lpszSubKey)
 987     dwRet = RegOpenKeyExA(hKey, lpszSubKey, 0, KEY_QUERY_VALUE, &hSubKey);
 988
 989   if (! dwRet)
 990   {
 991     /* SHQueryValueEx expands Environment strings */
 992     dwRet = SHQueryValueExA(hSubKey ? hSubKey : hKey, lpszValue, 0, pwType, pvData, pcbData);
 993     if (hSubKey) RegCloseKey(hSubKey);
 994   }
 995   return dwRet;
 996 }
 997
 998 /*************************************************************************
 999  * SHGetValueW   [SHLWAPI.@]
1000  *
1001  * See SHGetValueA.
1002  */
1003 DWORD WINAPI SHGetValueW(HKEY hKey, LPCWSTR lpszSubKey, LPCWSTR lpszValue,
1004                          LPDWORD pwType, LPVOID pvData, LPDWORD pcbData)
1005 {
1006   DWORD dwRet = 0;
1007   HKEY hSubKey = 0;
1008
1009   TRACE("(hkey=%p,%s,%s,%p,%p,%p)\n", hKey, debugstr_w(lpszSubKey),
1010         debugstr_w(lpszValue), pwType, pvData, pcbData);
1011
1012   if(lpszSubKey)
1013     dwRet = RegOpenKeyExW(hKey, lpszSubKey, 0, KEY_QUERY_VALUE, &hSubKey);
1014
1015   if (! dwRet)
1016   {
1017     dwRet = SHQueryValueExW(hSubKey ? hSubKey : hKey, lpszValue, 0, pwType, pvData, pcbData);
1018     if (hSubKey) RegCloseKey(hSubKey);
1019   }
1020   return dwRet;
1021 }
1022
1023 /*************************************************************************
1024  * SHSetValueA   [SHLWAPI.@]
1025  *
1026  * Set a value in the registry.
1027  *
1028  * PARAMS
1029  *   hKey       [I] Handle to registry key
1030  *   lpszSubKey [I] Name of sub key under hKey
1031  *   lpszValue  [I] Name of value to set
1032  *   dwType     [I] Type of the value
1033  *   pvData     [I] Data of the value
1034  *   cbData     [I] Size of the value
1035  *
1036  * RETURNS
1037  *   Success: ERROR_SUCCESS. The value is set with the data given.
1038  *   Failure: An error code from RegCreateKeyExA() or RegSetValueExA()
1039  *
1040  * NOTES
1041  *   If lpszSubKey does not exist, it is created before the value is set. If
1042  *   lpszSubKey is NULL or an empty string, then the value is added directly
1043  *   to hKey instead.
1044  */
1045 DWORD WINAPI SHSetValueA(HKEY hKey, LPCSTR lpszSubKey, LPCSTR lpszValue,
1046                          DWORD dwType, LPCVOID pvData, DWORD cbData)
1047 {
1048   DWORD dwRet = ERROR_SUCCESS, dwDummy;
1049   HKEY  hSubKey;
1050   static const char  szEmpty[] = { '\0' };
1051
1052   TRACE("(hkey=%p,%s,%s,%ld,%p,%ld)\n", hKey, debugstr_a(lpszSubKey),
1053           debugstr_a(lpszValue), dwType, pvData, cbData);
1054
1055   if (lpszSubKey && *lpszSubKey)
1056     dwRet = RegCreateKeyExA(hKey, lpszSubKey, 0, szEmpty,
1057                             0, KEY_SET_VALUE, NULL, &hSubKey, &dwDummy);
1058   else
1059     hSubKey = hKey;
1060   if (!dwRet)
1061   {
1062     dwRet = RegSetValueExA(hSubKey, lpszValue, 0, dwType, pvData, cbData);
1063     if (hSubKey != hKey)
1064       RegCloseKey(hSubKey);
1065   }
1066   return dwRet;
1067 }
1068
1069 /*************************************************************************
1070  * SHSetValueW   [SHLWAPI.@]
1071  *
1072  * See SHSetValueA.
1073  */
1074 DWORD WINAPI SHSetValueW(HKEY hKey, LPCWSTR lpszSubKey, LPCWSTR lpszValue,
1075                          DWORD dwType, LPCVOID pvData, DWORD cbData)
1076 {
1077   DWORD dwRet = ERROR_SUCCESS, dwDummy;
1078   HKEY  hSubKey;
1079   static const WCHAR szEmpty[] = { '\0' };
1080
1081   TRACE("(hkey=%p,%s,%s,%ld,%p,%ld)\n", hKey, debugstr_w(lpszSubKey),
1082         debugstr_w(lpszValue), dwType, pvData, cbData);
1083
1084   if (lpszSubKey && *lpszSubKey)
1085     dwRet = RegCreateKeyExW(hKey, lpszSubKey, 0, szEmpty,
1086                             0, KEY_SET_VALUE, NULL, &hSubKey, &dwDummy);
1087   else
1088     hSubKey = hKey;
1089   if (!dwRet)
1090   {
1091     dwRet = RegSetValueExW(hSubKey, lpszValue, 0, dwType, pvData, cbData);
1092     if (hSubKey != hKey)
1093       RegCloseKey(hSubKey);
1094   }
1095   return dwRet;
1096 }
1097
1098 /*************************************************************************
1099  * SHQueryInfoKeyA   [SHLWAPI.@]
1100  *
1101  * Get information about a registry key. See RegQueryInfoKeyA().
1102  *
1103  * RETURNS
1104  *  The result of calling RegQueryInfoKeyA().
1105  */
1106 LONG WINAPI SHQueryInfoKeyA(HKEY hKey, LPDWORD pwSubKeys, LPDWORD pwSubKeyMax,
1107                             LPDWORD pwValues, LPDWORD pwValueMax)
1108 {
1109   TRACE("(hkey=%p,%p,%p,%p,%p)\n", hKey, pwSubKeys, pwSubKeyMax,
1110         pwValues, pwValueMax);
1111   return RegQueryInfoKeyA(hKey, NULL, NULL, NULL, pwSubKeys, pwSubKeyMax,
1112                           NULL, pwValues, pwValueMax, NULL, NULL, NULL);
1113 }
1114
1115 /*************************************************************************
1116  * SHQueryInfoKeyW   [SHLWAPI.@]
1117  *
1118  * See SHQueryInfoKeyA.
1119  */
1120 LONG WINAPI SHQueryInfoKeyW(HKEY hKey, LPDWORD pwSubKeys, LPDWORD pwSubKeyMax,
1121                             LPDWORD pwValues, LPDWORD pwValueMax)
1122 {
1123   TRACE("(hkey=%p,%p,%p,%p,%p)\n", hKey, pwSubKeys, pwSubKeyMax,
1124         pwValues, pwValueMax);
1125   return RegQueryInfoKeyW(hKey, NULL, NULL, NULL, pwSubKeys, pwSubKeyMax,
1126                           NULL, pwValues, pwValueMax, NULL, NULL, NULL);
1127 }
1128
1129 /*************************************************************************
1130  * SHQueryValueExA   [SHLWAPI.@]
1131  *
1132  * Get a value from the registry, expanding environment variable strings.
1133  *
1134  * PARAMS
1135  *   hKey       [I] Handle to registry key
1136  *   lpszValue  [I] Name of value to query
1137  *   lpReserved [O] Reserved for future use; must be NULL
1138  *   pwType     [O] Optional pointer updated with the values type
1139  *   pvData     [O] Optional pointer updated with the values data
1140  *   pcbData    [O] Optional pointer updated with the values size
1141  *
1142  * RETURNS
1143  *   Success: ERROR_SUCCESS. Any non NULL output parameters are updated with
1144  *            information about the value.
1145  *   Failure: ERROR_OUTOFMEMORY if memory allocation fails, or the type of the
1146  *            data is REG_EXPAND_SZ and pcbData is NULL. Otherwise an error
1147  *            code from RegQueryValueExA() or ExpandEnvironmentStringsA().
1148  *
1149  * NOTES
1150  *   Either pwType, pvData or pcbData may be NULL if the caller doesn't want
1151  *   the type, data or size information for the value.
1152  *
1153  *   If the type of the data is REG_EXPAND_SZ, it is expanded to REG_SZ. The
1154  *   value returned will be truncated if it is of type REG_SZ and bigger than
1155  *   the buffer given to store it.
1156  *
1157  *   REG_EXPAND_SZ:
1158  *     case-1: the unexpanded string is smaller than the expanded one
1159  *       subcase-1: the buffer is to small to hold the unexpanded string:
1160  *          function fails and returns the size of the unexpanded string.
1161  *
1162  *       subcase-2: buffer is to small to hold the expanded string:
1163  *          the function return success (!!) and the result is truncated
1164  *          *** This is clearly a error in the native implementation. ***
1165  *
1166  *     case-2: the unexpanded string is bigger than the expanded one
1167  *       The buffer must have enough space to hold the unexpanded
1168  *       string even if the result is smaller.
1169  *
1170  */
1171 DWORD WINAPI SHQueryValueExA( HKEY hKey, LPCSTR lpszValue,
1172                               LPDWORD lpReserved, LPDWORD pwType,
1173                               LPVOID pvData, LPDWORD pcbData)
1174 {
1175   DWORD dwRet, dwType, dwUnExpDataLen = 0, dwExpDataLen;
1176
1177   TRACE("(hkey=%p,%s,%p,%p,%p,%p=%ld)\n", hKey, debugstr_a(lpszValue),
1178         lpReserved, pwType, pvData, pcbData, pcbData ? *pcbData : 0);
1179
1180   if (pcbData) dwUnExpDataLen = *pcbData;
1181
1182   dwRet = RegQueryValueExA(hKey, lpszValue, lpReserved, &dwType, pvData, &dwUnExpDataLen);
1183
1184   if (pcbData && (dwType == REG_EXPAND_SZ))
1185   {
1186     DWORD nBytesToAlloc;
1187
1188     /* Expand type REG_EXPAND_SZ into REG_SZ */
1189     LPSTR szData;
1190
1191     /* If the caller didn't supply a buffer or the buffer is to small we have
1192      * to allocate our own
1193      */
1194     if ((!pvData) || (dwRet == ERROR_MORE_DATA) )
1195     {
1196       char cNull = '\0';
1197       nBytesToAlloc = (!pvData || (dwRet == ERROR_MORE_DATA)) ? dwUnExpDataLen : *pcbData;
1198
1199       szData = (LPSTR) LocalAlloc(GMEM_ZEROINIT, nBytesToAlloc);
1200       RegQueryValueExA (hKey, lpszValue, lpReserved, NULL, (LPBYTE)szData, &nBytesToAlloc);
1201       dwExpDataLen = ExpandEnvironmentStringsA(szData, &cNull, 1);
1202       dwUnExpDataLen = max(nBytesToAlloc, dwExpDataLen);
1203       LocalFree((HLOCAL) szData);
1204     }
1205     else
1206     {
1207       nBytesToAlloc = (lstrlenA(pvData)+1) * sizeof (CHAR);
1208       szData = (LPSTR) LocalAlloc(GMEM_ZEROINIT, nBytesToAlloc );
1209       lstrcpyA(szData, pvData);
1210       dwExpDataLen = ExpandEnvironmentStringsA(szData, pvData, *pcbData / sizeof(CHAR));
1211       if (dwExpDataLen > *pcbData) dwRet = ERROR_MORE_DATA;
1212       dwUnExpDataLen = max(nBytesToAlloc, dwExpDataLen);
1213       LocalFree((HLOCAL) szData);
1214     }
1215   }
1216
1217   /* Update the type and data size if the caller wanted them */
1218   if ( dwType == REG_EXPAND_SZ ) dwType = REG_SZ;
1219   if ( pwType ) *pwType = dwType;
1220   if ( pcbData ) *pcbData = dwUnExpDataLen;
1221   return dwRet;
1222 }
1223
1224
1225 /*************************************************************************
1226  * SHQueryValueExW   [SHLWAPI.@]
1227  *
1228  * See SHQueryValueExA.
1229  */
1230 DWORD WINAPI SHQueryValueExW(HKEY hKey, LPCWSTR lpszValue,
1231                              LPDWORD lpReserved, LPDWORD pwType,
1232                              LPVOID pvData, LPDWORD pcbData)
1233 {
1234   DWORD dwRet, dwType, dwUnExpDataLen = 0, dwExpDataLen;
1235
1236   TRACE("(hkey=%p,%s,%p,%p,%p,%p=%ld)\n", hKey, debugstr_w(lpszValue),
1237         lpReserved, pwType, pvData, pcbData, pcbData ? *pcbData : 0);
1238
1239   if (pcbData) dwUnExpDataLen = *pcbData;
1240
1241   dwRet = RegQueryValueExW(hKey, lpszValue, lpReserved, &dwType, pvData, &dwUnExpDataLen);
1242   if (dwRet!=ERROR_SUCCESS && dwRet!=ERROR_MORE_DATA)
1243       return dwRet;
1244
1245   if (pcbData && (dwType == REG_EXPAND_SZ))
1246   {
1247     DWORD nBytesToAlloc;
1248
1249     /* Expand type REG_EXPAND_SZ into REG_SZ */
1250     LPWSTR szData;
1251
1252     /* If the caller didn't supply a buffer or the buffer is too small we have
1253      * to allocate our own
1254      */
1255     if ((!pvData) || (dwRet == ERROR_MORE_DATA) )
1256     {
1257       WCHAR cNull = '\0';
1258       nBytesToAlloc = (!pvData || (dwRet == ERROR_MORE_DATA)) ? dwUnExpDataLen : *pcbData;
1259
1260       szData = (LPWSTR) LocalAlloc(GMEM_ZEROINIT, nBytesToAlloc);
1261       RegQueryValueExW (hKey, lpszValue, lpReserved, NULL, (LPBYTE)szData, &nBytesToAlloc);
1262       dwExpDataLen = ExpandEnvironmentStringsW(szData, &cNull, 1);
1263       dwUnExpDataLen = max(nBytesToAlloc, dwExpDataLen);
1264       LocalFree((HLOCAL) szData);
1265     }
1266     else
1267     {
1268       nBytesToAlloc = (lstrlenW(pvData) + 1) * sizeof(WCHAR);
1269       szData = (LPWSTR) LocalAlloc(GMEM_ZEROINIT, nBytesToAlloc );
1270       lstrcpyW(szData, pvData);
1271       dwExpDataLen = ExpandEnvironmentStringsW(szData, pvData, *pcbData/sizeof(WCHAR) );
1272       if (dwExpDataLen > *pcbData) dwRet = ERROR_MORE_DATA;
1273       dwUnExpDataLen = max(nBytesToAlloc, dwExpDataLen);
1274       LocalFree((HLOCAL) szData);
1275     }
1276   }
1277
1278   /* Update the type and data size if the caller wanted them */
1279   if ( dwType == REG_EXPAND_SZ ) dwType = REG_SZ;
1280   if ( pwType ) *pwType = dwType;
1281   if ( pcbData ) *pcbData = dwUnExpDataLen;
1282   return dwRet;
1283 }
1284
1285 /*************************************************************************
1286  * SHDeleteKeyA   [SHLWAPI.@]
1287  *
1288  * Delete a registry key and any sub keys/values present
1289  *
1290  * PARAMS
1291  *   hKey       [I] Handle to registry key
1292  *   lpszSubKey [I] Name of sub key to delete
1293  *
1294  * RETURNS
1295  *   Success: ERROR_SUCCESS. The key is deleted.
1296  *   Failure: An error code from RegOpenKeyExA(), RegQueryInfoKeyA(),
1297  *            RegEnumKeyExA() or RegDeleteKeyA().
1298  */
1299 DWORD WINAPI SHDeleteKeyA(HKEY hKey, LPCSTR lpszSubKey)
1300 {
1301   DWORD dwRet, dwMaxSubkeyLen = 0, dwSize;
1302   CHAR szNameBuf[MAX_PATH], *lpszName = szNameBuf;
1303   HKEY hSubKey = 0;
1304
1305   TRACE("(hkey=%p,%s)\n", hKey, debugstr_a(lpszSubKey));
1306
1307   dwRet = RegOpenKeyExA(hKey, lpszSubKey, 0, KEY_READ, &hSubKey);
1308   if(!dwRet)
1309   {
1310     /* Find the maximum subkey length so that we can allocate a buffer */
1311     dwRet = RegQueryInfoKeyA(hSubKey, NULL, NULL, NULL, NULL,
1312                              &dwMaxSubkeyLen, NULL, NULL, NULL, NULL, NULL, NULL);
1313     if(!dwRet)
1314     {
1315       dwMaxSubkeyLen++;
1316       if (dwMaxSubkeyLen > sizeof(szNameBuf))
1317         /* Name too big: alloc a buffer for it */
1318         lpszName = HeapAlloc(GetProcessHeap(), 0, dwMaxSubkeyLen*sizeof(CHAR));
1319
1320       if(!lpszName)
1321         dwRet = ERROR_NOT_ENOUGH_MEMORY;
1322       else
1323       {
1324         while (dwRet == ERROR_SUCCESS)
1325         {
1326           dwSize = dwMaxSubkeyLen;
1327           dwRet = RegEnumKeyExA(hSubKey, 0, lpszName, &dwSize, NULL, NULL, NULL, NULL);
1328           if (dwRet == ERROR_SUCCESS || dwRet == ERROR_MORE_DATA)
1329             dwRet = SHDeleteKeyA(hSubKey, lpszName);
1330         }
1331         if (dwRet == ERROR_NO_MORE_ITEMS)
1332           dwRet = ERROR_SUCCESS;
1333         if (lpszName != szNameBuf)
1334           HeapFree(GetProcessHeap(), 0, lpszName); /* Free buffer if allocated */
1335       }
1336     }
1337
1338     RegCloseKey(hSubKey);
1339     if(!dwRet)
1340       dwRet = RegDeleteKeyA(hKey, lpszSubKey);
1341   }
1342   return dwRet;
1343 }
1344
1345 /*************************************************************************
1346  * SHDeleteKeyW   [SHLWAPI.@]
1347  *
1348  * See SHDeleteKeyA.
1349  */
1350 DWORD WINAPI SHDeleteKeyW(HKEY hKey, LPCWSTR lpszSubKey)
1351 {
1352   DWORD dwRet, dwKeyCount = 0, dwMaxSubkeyLen = 0, dwSize, i;
1353   WCHAR szNameBuf[MAX_PATH], *lpszName = szNameBuf;
1354   HKEY hSubKey = 0;
1355
1356   TRACE("(hkey=%p,%s)\n", hKey, debugstr_w(lpszSubKey));
1357
1358   dwRet = RegOpenKeyExW(hKey, lpszSubKey, 0, KEY_READ, &hSubKey);
1359   if(!dwRet)
1360   {
1361     /* Find how many subkeys there are */
1362     dwRet = RegQueryInfoKeyW(hSubKey, NULL, NULL, NULL, &dwKeyCount,
1363                              &dwMaxSubkeyLen, NULL, NULL, NULL, NULL, NULL, NULL);
1364     if(!dwRet)
1365     {
1366       dwMaxSubkeyLen++;
1367       if (dwMaxSubkeyLen > sizeof(szNameBuf)/sizeof(WCHAR))
1368         /* Name too big: alloc a buffer for it */
1369         lpszName = HeapAlloc(GetProcessHeap(), 0, dwMaxSubkeyLen*sizeof(WCHAR));
1370
1371       if(!lpszName)
1372         dwRet = ERROR_NOT_ENOUGH_MEMORY;
1373       else
1374       {
1375         /* Recursively delete all the subkeys */
1376         for(i = 0; i < dwKeyCount && !dwRet; i++)
1377         {
1378           dwSize = dwMaxSubkeyLen;
1379           dwRet = RegEnumKeyExW(hSubKey, i, lpszName, &dwSize, NULL, NULL, NULL, NULL);
1380           if(!dwRet)
1381             dwRet = SHDeleteKeyW(hSubKey, lpszName);
1382         }
1383
1384         if (lpszName != szNameBuf)
1385           HeapFree(GetProcessHeap(), 0, lpszName); /* Free buffer if allocated */
1386       }
1387     }
1388
1389     RegCloseKey(hSubKey);
1390     if(!dwRet)
1391       dwRet = RegDeleteKeyW(hKey, lpszSubKey);
1392   }
1393   return dwRet;
1394 }
1395
1396 /*************************************************************************
1397  * SHDeleteEmptyKeyA   [SHLWAPI.@]
1398  *
1399  * Delete a registry key with no sub keys.
1400  *
1401  * PARAMS
1402  *   hKey       [I] Handle to registry key
1403  *   lpszSubKey [I] Name of sub key to delete
1404  *
1405  * RETURNS
1406  *   Success: ERROR_SUCCESS. The key is deleted.
1407  *   Failure: If the key is not empty, returns ERROR_KEY_HAS_CHILDREN. Otherwise
1408  *            returns an error code from RegOpenKeyExA(), RegQueryInfoKeyA() or
1409  *            RegDeleteKeyA().
1410  */
1411 DWORD WINAPI SHDeleteEmptyKeyA(HKEY hKey, LPCSTR lpszSubKey)
1412 {
1413   DWORD dwRet, dwKeyCount = 0;
1414   HKEY hSubKey = 0;
1415
1416   TRACE("(hkey=%p,%s)\n", hKey, debugstr_a(lpszSubKey));
1417
1418   dwRet = RegOpenKeyExA(hKey, lpszSubKey, 0, KEY_READ, &hSubKey);
1419   if(!dwRet)
1420   {
1421     dwRet = RegQueryInfoKeyA(hSubKey, NULL, NULL, NULL, &dwKeyCount,
1422                              NULL, NULL, NULL, NULL, NULL, NULL, NULL);
1423     RegCloseKey(hSubKey);
1424     if(!dwRet)
1425     {
1426       if (!dwKeyCount)
1427         dwRet = RegDeleteKeyA(hKey, lpszSubKey);
1428       else
1429         dwRet = ERROR_KEY_HAS_CHILDREN;
1430     }
1431   }
1432   return dwRet;
1433 }
1434
1435 /*************************************************************************
1436  * SHDeleteEmptyKeyW   [SHLWAPI.@]
1437  *
1438  * See SHDeleteEmptyKeyA.
1439  */
1440 DWORD WINAPI SHDeleteEmptyKeyW(HKEY hKey, LPCWSTR lpszSubKey)
1441 {
1442   DWORD dwRet, dwKeyCount = 0;
1443   HKEY hSubKey = 0;
1444
1445   TRACE("(hkey=%p, %s)\n", hKey, debugstr_w(lpszSubKey));
1446
1447   dwRet = RegOpenKeyExW(hKey, lpszSubKey, 0, KEY_READ, &hSubKey);
1448   if(!dwRet)
1449   {
1450     dwRet = RegQueryInfoKeyW(hSubKey, NULL, NULL, NULL, &dwKeyCount,
1451                              NULL, NULL, NULL, NULL, NULL, NULL, NULL);
1452     RegCloseKey(hSubKey);
1453     if(!dwRet)
1454     {
1455       if (!dwKeyCount)
1456         dwRet = RegDeleteKeyW(hKey, lpszSubKey);
1457       else
1458         dwRet = ERROR_KEY_HAS_CHILDREN;
1459     }
1460   }
1461   return dwRet;
1462 }
1463
1464 /*************************************************************************
1465  * SHDeleteOrphanKeyA   [SHLWAPI.@]
1466  *
1467  * Delete a registry key with no sub keys or values.
1468  *
1469  * PARAMS
1470  *   hKey       [I] Handle to registry key
1471  *   lpszSubKey [I] Name of sub key to possibly delete
1472  *
1473  * RETURNS
1474  *   Success: ERROR_SUCCESS. The key has been deleted if it was an orphan.
1475  *   Failure: An error from RegOpenKeyExA(), RegQueryValueExA(), or RegDeleteKeyA().
1476  */
1477 DWORD WINAPI SHDeleteOrphanKeyA(HKEY hKey, LPCSTR lpszSubKey)
1478 {
1479   HKEY hSubKey;
1480   DWORD dwKeyCount = 0, dwValueCount = 0, dwRet;
1481
1482   TRACE("(hkey=%p,%s)\n", hKey, debugstr_a(lpszSubKey));
1483
1484   dwRet = RegOpenKeyExA(hKey, lpszSubKey, 0, KEY_READ, &hSubKey);
1485
1486   if(!dwRet)
1487   {
1488     /* Get subkey and value count */
1489     dwRet = RegQueryInfoKeyA(hSubKey, NULL, NULL, NULL, &dwKeyCount,
1490                              NULL, NULL, &dwValueCount, NULL, NULL, NULL, NULL);
1491
1492     if(!dwRet && !dwKeyCount && !dwValueCount)
1493     {
1494       dwRet = RegDeleteKeyA(hKey, lpszSubKey);
1495     }
1496     RegCloseKey(hSubKey);
1497   }
1498   return dwRet;
1499 }
1500
1501 /*************************************************************************
1502  * SHDeleteOrphanKeyW   [SHLWAPI.@]
1503  *
1504  * See SHDeleteOrphanKeyA.
1505  */
1506 DWORD WINAPI SHDeleteOrphanKeyW(HKEY hKey, LPCWSTR lpszSubKey)
1507 {
1508   HKEY hSubKey;
1509   DWORD dwKeyCount = 0, dwValueCount = 0, dwRet;
1510
1511   TRACE("(hkey=%p,%s)\n", hKey, debugstr_w(lpszSubKey));
1512
1513   dwRet = RegOpenKeyExW(hKey, lpszSubKey, 0, KEY_READ, &hSubKey);
1514
1515   if(!dwRet)
1516   {
1517     /* Get subkey and value count */
1518     dwRet = RegQueryInfoKeyW(hSubKey, NULL, NULL, NULL, &dwKeyCount,
1519                              NULL, NULL, &dwValueCount, NULL, NULL, NULL, NULL);
1520
1521     if(!dwRet && !dwKeyCount && !dwValueCount)
1522     {
1523       dwRet = RegDeleteKeyW(hKey, lpszSubKey);
1524     }
1525     RegCloseKey(hSubKey);
1526   }
1527   return dwRet;
1528 }
1529
1530 /*************************************************************************
1531  * SHDeleteValueA   [SHLWAPI.@]
1532  *
1533  * Delete a value from the registry.
1534  *
1535  * PARAMS
1536  *   hKey       [I] Handle to registry key
1537  *   lpszSubKey [I] Name of sub key containing value to delete
1538  *   lpszValue  [I] Name of value to delete
1539  *
1540  * RETURNS
1541  *   Success: ERROR_SUCCESS. The value is deleted.
1542  *   Failure: An error code from RegOpenKeyExA() or RegDeleteValueA().
1543  */
1544 DWORD WINAPI SHDeleteValueA(HKEY hKey, LPCSTR lpszSubKey, LPCSTR lpszValue)
1545 {
1546   DWORD dwRet;
1547   HKEY hSubKey;
1548
1549   TRACE("(hkey=%p,%s,%s)\n", hKey, debugstr_a(lpszSubKey), debugstr_a(lpszValue));
1550
1551   dwRet = RegOpenKeyExA(hKey, lpszSubKey, 0, KEY_SET_VALUE, &hSubKey);
1552   if (!dwRet)
1553   {
1554     dwRet = RegDeleteValueA(hSubKey, lpszValue);
1555     RegCloseKey(hSubKey);
1556   }
1557   return dwRet;
1558 }
1559
1560 /*************************************************************************
1561  * SHDeleteValueW   [SHLWAPI.@]
1562  *
1563  * See SHDeleteValueA.
1564  */
1565 DWORD WINAPI SHDeleteValueW(HKEY hKey, LPCWSTR lpszSubKey, LPCWSTR lpszValue)
1566 {
1567   DWORD dwRet;
1568   HKEY hSubKey;
1569
1570   TRACE("(hkey=%p,%s,%s)\n", hKey, debugstr_w(lpszSubKey), debugstr_w(lpszValue));
1571
1572   dwRet = RegOpenKeyExW(hKey, lpszSubKey, 0, KEY_SET_VALUE, &hSubKey);
1573   if (!dwRet)
1574   {
1575     dwRet = RegDeleteValueW(hSubKey, lpszValue);
1576     RegCloseKey(hSubKey);
1577   }
1578   return dwRet;
1579 }
1580
1581 /*************************************************************************
1582  * SHEnumKeyExA   [SHLWAPI.@]
1583  *
1584  * Enumerate sub keys in a registry key.
1585  *
1586  * PARAMS
1587  *   hKey       [I] Handle to registry key
1588  *   dwIndex    [I] Index of key to enumerate
1589  *   lpszSubKey [O] Pointer updated with the subkey name
1590  *   pwLen      [O] Pointer updated with the subkey length
1591  *
1592  * RETURNS
1593  *   Success: ERROR_SUCCESS. lpszSubKey and pwLen are updated.
1594  *   Failure: An error code from RegEnumKeyExA().
1595  */
1596 LONG WINAPI SHEnumKeyExA(HKEY hKey, DWORD dwIndex, LPSTR lpszSubKey,
1597                          LPDWORD pwLen)
1598 {
1599   TRACE("(hkey=%p,%ld,%s,%p)\n", hKey, dwIndex, debugstr_a(lpszSubKey), pwLen);
1600
1601   return RegEnumKeyExA(hKey, dwIndex, lpszSubKey, pwLen, NULL, NULL, NULL, NULL);
1602 }
1603
1604 /*************************************************************************
1605  * SHEnumKeyExW   [SHLWAPI.@]
1606  *
1607  * See SHEnumKeyExA.
1608  */
1609 LONG WINAPI SHEnumKeyExW(HKEY hKey, DWORD dwIndex, LPWSTR lpszSubKey,
1610                          LPDWORD pwLen)
1611 {
1612   TRACE("(hkey=%p,%ld,%s,%p)\n", hKey, dwIndex, debugstr_w(lpszSubKey), pwLen);
1613
1614   return RegEnumKeyExW(hKey, dwIndex, lpszSubKey, pwLen, NULL, NULL, NULL, NULL);
1615 }
1616
1617 /*************************************************************************
1618  * SHEnumValueA   [SHLWAPI.@]
1619  *
1620  * Enumerate values in a registry key.
1621  *
1622  * PARAMS
1623  *   hKey      [I] Handle to registry key
1624  *   dwIndex   [I] Index of key to enumerate
1625  *   lpszValue [O] Pointer updated with the values name
1626  *   pwLen     [O] Pointer updated with the values length
1627  *   pwType    [O] Pointer updated with the values type
1628  *   pvData    [O] Pointer updated with the values data
1629  *   pcbData   [O] Pointer updated with the values size
1630  *
1631  * RETURNS
1632  *   Success: ERROR_SUCCESS. Output parameters are updated.
1633  *   Failure: An error code from RegEnumValueA().
1634  */
1635 LONG WINAPI SHEnumValueA(HKEY hKey, DWORD dwIndex, LPSTR lpszValue,
1636                          LPDWORD pwLen, LPDWORD pwType,
1637                          LPVOID pvData, LPDWORD pcbData)
1638 {
1639   TRACE("(hkey=%p,%ld,%s,%p,%p,%p,%p)\n", hKey, dwIndex,
1640         debugstr_a(lpszValue), pwLen, pwType, pvData, pcbData);
1641
1642   return RegEnumValueA(hKey, dwIndex, lpszValue, pwLen, NULL,
1643                        pwType, pvData, pcbData);
1644 }
1645
1646 /*************************************************************************
1647  * SHEnumValueW   [SHLWAPI.@]
1648  *
1649  * See SHEnumValueA.
1650  */
1651 LONG WINAPI SHEnumValueW(HKEY hKey, DWORD dwIndex, LPWSTR lpszValue,
1652                          LPDWORD pwLen, LPDWORD pwType,
1653                          LPVOID pvData, LPDWORD pcbData)
1654 {
1655   TRACE("(hkey=%p,%ld,%s,%p,%p,%p,%p)\n", hKey, dwIndex,
1656         debugstr_w(lpszValue), pwLen, pwType, pvData, pcbData);
1657
1658   return RegEnumValueW(hKey, dwIndex, lpszValue, pwLen, NULL,
1659                        pwType, pvData, pcbData);
1660 }
1661
1662 /*************************************************************************
1663  * @   [SHLWAPI.205]
1664  *
1665  * Get a value from the registry.
1666  *
1667  * PARAMS
1668  *   hKey    [I] Handle to registry key
1669  *   pSubKey [I] Name of sub key containing value to get
1670  *   pValue  [I] Name of value to get
1671  *   pwType  [O] Destination for the values type
1672  *   pvData  [O] Destination for the values data
1673  *   pbData  [O] Destination for the values size
1674  *
1675  * RETURNS
1676  *   Success: ERROR_SUCCESS. Output parameters contain the details read.
1677  *   Failure: An error code from RegOpenKeyExA() or SHQueryValueExA(),
1678  *            or ERROR_INVALID_FUNCTION in the machine is in safe mode.
1679  */
1680 DWORD WINAPI SHGetValueGoodBootA(HKEY hkey, LPCSTR pSubKey, LPCSTR pValue,
1681                          LPDWORD pwType, LPVOID pvData, LPDWORD pbData)
1682 {
1683   if (GetSystemMetrics(SM_CLEANBOOT))
1684     return ERROR_INVALID_FUNCTION;
1685   return SHGetValueA(hkey, pSubKey, pValue, pwType, pvData, pbData);
1686 }
1687
1688 /*************************************************************************
1689  * @   [SHLWAPI.206]
1690  *
1691  * Unicode version of SHGetValueGoodBootW.
1692  */
1693 DWORD WINAPI SHGetValueGoodBootW(HKEY hkey, LPCWSTR pSubKey, LPCWSTR pValue,
1694                          LPDWORD pwType, LPVOID pvData, LPDWORD pbData)
1695 {
1696   if (GetSystemMetrics(SM_CLEANBOOT))
1697     return ERROR_INVALID_FUNCTION;
1698   return SHGetValueW(hkey, pSubKey, pValue, pwType, pvData, pbData);
1699 }
1700
1701 /*************************************************************************
1702  * @   [SHLWAPI.320]
1703  *
1704  * Set a MIME content type in the registry.
1705  *
1706  * PARAMS
1707  *   lpszSubKey [I] Name of key under HKEY_CLASSES_ROOT.
1708  *   lpszValue  [I] Value to set
1709  *
1710  * RETURNS
1711  *   Success: TRUE
1712  *   Failure: FALSE
1713  */
1714 BOOL WINAPI RegisterMIMETypeForExtensionA(LPCSTR lpszSubKey, LPCSTR lpszValue)
1715 {
1716   DWORD dwRet;
1717
1718   if (!lpszValue)
1719   {
1720     WARN("Invalid lpszValue would crash under Win32!\n");
1721     return FALSE;
1722   }
1723
1724   dwRet = SHSetValueA(HKEY_CLASSES_ROOT, lpszSubKey, lpszContentTypeA,
1725                       REG_SZ, lpszValue, strlen(lpszValue));
1726   return dwRet ? FALSE : TRUE;
1727 }
1728
1729 /*************************************************************************
1730  * @   [SHLWAPI.321]
1731  *
1732  * Unicode version of RegisterMIMETypeForExtensionA.
1733  */
1734 BOOL WINAPI RegisterMIMETypeForExtensionW(LPCWSTR lpszSubKey, LPCWSTR lpszValue)
1735 {
1736   DWORD dwRet;
1737
1738   if (!lpszValue)
1739   {
1740     WARN("Invalid lpszValue would crash under Win32!\n");
1741     return FALSE;
1742   }
1743
1744   dwRet = SHSetValueW(HKEY_CLASSES_ROOT, lpszSubKey, lpszContentTypeW,
1745                       REG_SZ, lpszValue, strlenW(lpszValue));
1746   return dwRet ? FALSE : TRUE;
1747 }
1748
1749 /*************************************************************************
1750  * @   [SHLWAPI.322]
1751  *
1752  * Delete a MIME content type from the registry.
1753  *
1754  * PARAMS
1755  *   lpszSubKey [I] Name of sub key
1756  *
1757  * RETURNS
1758  *   Success: TRUE
1759  *   Failure: FALSE
1760  */
1761 BOOL WINAPI UnregisterMIMETypeForExtensionA(LPCSTR lpszSubKey)
1762 {
1763   HRESULT ret = SHDeleteValueA(HKEY_CLASSES_ROOT, lpszSubKey, lpszContentTypeA);
1764   return ret ? FALSE : TRUE;
1765 }
1766
1767 /*************************************************************************
1768  * @   [SHLWAPI.323]
1769  *
1770  * Unicode version of UnregisterMIMETypeForExtensionA.
1771  */
1772 BOOL WINAPI UnregisterMIMETypeForExtensionW(LPCWSTR lpszSubKey)
1773 {
1774   HRESULT ret = SHDeleteValueW(HKEY_CLASSES_ROOT, lpszSubKey, lpszContentTypeW);
1775   return ret ? FALSE : TRUE;
1776 }
1777
1778 /*************************************************************************
1779  * @   [SHLWAPI.328]
1780  *
1781  * Get the registry path to a MIME content key.
1782  *
1783  * PARAMS
1784  *   lpszType   [I] Content type to get the path for
1785  *   lpszBuffer [O] Destination for path
1786  *   dwLen      [I] Length of lpszBuffer
1787  *
1788  * RETURNS
1789  *   Success: TRUE. lpszBuffer contains the full path.
1790  *   Failure: FALSE.
1791  *
1792  * NOTES
1793  *   The base path for the key is "MIME\Database\Content Type\"
1794  */
1795 BOOL WINAPI GetMIMETypeSubKeyA(LPCSTR lpszType, LPSTR lpszBuffer, DWORD dwLen)
1796 {
1797   TRACE("(%s,%p,%ld)\n", debugstr_a(lpszType), lpszBuffer, dwLen);
1798
1799   if (dwLen > dwLenMimeDbContent && lpszType && lpszBuffer)
1800   {
1801     size_t dwStrLen = strlen(lpszType);
1802
1803     if (dwStrLen < dwLen - dwLenMimeDbContent)
1804     {
1805       memcpy(lpszBuffer, szMimeDbContentA, dwLenMimeDbContent);
1806       memcpy(lpszBuffer + dwLenMimeDbContent, lpszType, dwStrLen + 1);
1807       return TRUE;
1808     }
1809   }
1810   return FALSE;
1811 }
1812
1813 /*************************************************************************
1814  * @   [SHLWAPI.329]
1815  *
1816  * Unicode version of GetMIMETypeSubKeyA.
1817  */
1818 BOOL WINAPI GetMIMETypeSubKeyW(LPCWSTR lpszType, LPWSTR lpszBuffer, DWORD dwLen)
1819 {
1820   TRACE("(%s,%p,%ld)\n", debugstr_w(lpszType), lpszBuffer, dwLen);
1821
1822   if (dwLen > dwLenMimeDbContent && lpszType && lpszBuffer)
1823   {
1824     DWORD dwStrLen = strlenW(lpszType);
1825
1826     if (dwStrLen < dwLen - dwLenMimeDbContent)
1827     {
1828       memcpy(lpszBuffer, szMimeDbContentW, dwLenMimeDbContent * sizeof(WCHAR));
1829       memcpy(lpszBuffer + dwLenMimeDbContent, lpszType, (dwStrLen + 1) * sizeof(WCHAR));
1830       return TRUE;
1831     }
1832   }
1833   return FALSE;
1834 }
1835
1836 /*************************************************************************
1837  * @   [SHLWAPI.330]
1838  *
1839  * Get the file extension for a given Mime type.
1840  *
1841  * PARAMS
1842  *  lpszType [I] Mime type to get the file extension for
1843  *  lpExt    [O] Destination for the resulting extension
1844  *  iLen     [I] Length of lpExt in characters
1845  *
1846  * RETURNS
1847  *  Success: TRUE. lpExt contains the file extension.
1848  *  Failure: FALSE, if any parameter is invalid or the extension cannot be
1849  *           retrieved. If iLen > 0, lpExt is set to an empty string.
1850  *
1851  * NOTES
1852  *  - The extension returned in lpExt always has a leading '.' character, even
1853  *  if the registry Mime database entry does not.
1854  *  - iLen must be long enough for the file extension for this function to succeed.
1855  */
1856 BOOL WINAPI MIME_GetExtensionA(LPCSTR lpszType, LPSTR lpExt, INT iLen)
1857 {
1858   char szSubKey[MAX_PATH];
1859   DWORD dwlen = iLen - 1, dwType;
1860   BOOL bRet = FALSE;
1861
1862   if (iLen > 0 && lpExt)
1863     *lpExt = '\0';
1864
1865   if (lpszType && lpExt && iLen > 2 &&
1866       GetMIMETypeSubKeyA(lpszType, szSubKey, MAX_PATH) &&
1867       !SHGetValueA(HKEY_CLASSES_ROOT, szSubKey, szExtensionA, &dwType, lpExt + 1, &dwlen) &&
1868       lpExt[1])
1869   {
1870     if (lpExt[1] == '.')
1871       memmove(lpExt, lpExt + 1, strlen(lpExt + 1) + 1);
1872     else
1873       *lpExt = '.'; /* Supply a '.' */
1874     bRet = TRUE;
1875   }
1876   return bRet;
1877 }
1878
1879 /*************************************************************************
1880  * @   [SHLWAPI.331]
1881  *
1882  * Unicode version of MIME_GetExtensionA.
1883  */
1884 BOOL WINAPI MIME_GetExtensionW(LPCWSTR lpszType, LPWSTR lpExt, INT iLen)
1885 {
1886   WCHAR szSubKey[MAX_PATH];
1887   DWORD dwlen = iLen - 1, dwType;
1888   BOOL bRet = FALSE;
1889
1890   if (iLen > 0 && lpExt)
1891     *lpExt = '\0';
1892
1893   if (lpszType && lpExt && iLen > 2 &&
1894       GetMIMETypeSubKeyW(lpszType, szSubKey, MAX_PATH) &&
1895       !SHGetValueW(HKEY_CLASSES_ROOT, szSubKey, szExtensionW, &dwType, lpExt + 1, &dwlen) &&
1896       lpExt[1])
1897   {
1898     if (lpExt[1] == '.')
1899       memmove(lpExt, lpExt + 1, (strlenW(lpExt + 1) + 1) * sizeof(WCHAR));
1900     else
1901       *lpExt = '.'; /* Supply a '.' */
1902     bRet = TRUE;
1903   }
1904   return bRet;
1905 }
1906
1907 /*************************************************************************
1908  * @   [SHLWAPI.324]
1909  *
1910  * Set the file extension for a MIME content key.
1911  *
1912  * PARAMS
1913  *   lpszExt  [I] File extension to set
1914  *   lpszType [I] Content type to set the extension for
1915  *
1916  * RETURNS
1917  *   Success: TRUE. The file extension is set in the registry.
1918  *   Failure: FALSE.
1919  */
1920 BOOL WINAPI RegisterExtensionForMIMETypeA(LPCSTR lpszExt, LPCSTR lpszType)
1921 {
1922   DWORD dwLen;
1923   char szKey[MAX_PATH];
1924
1925   TRACE("(%s,%s)\n", debugstr_a(lpszExt), debugstr_a(lpszType));
1926
1927   if (!GetMIMETypeSubKeyA(lpszType, szKey, MAX_PATH)) /* Get full path to the key */
1928     return FALSE;
1929
1930   dwLen = strlen(lpszExt) + 1;
1931
1932   if (SHSetValueA(HKEY_CLASSES_ROOT, szKey, szExtensionA, REG_SZ, lpszExt, dwLen))
1933     return FALSE;
1934   return TRUE;
1935 }
1936
1937 /*************************************************************************
1938  * @   [SHLWAPI.325]
1939  *
1940  * Unicode version of RegisterExtensionForMIMETypeA.
1941  */
1942 BOOL WINAPI RegisterExtensionForMIMETypeW(LPCWSTR lpszExt, LPCWSTR lpszType)
1943 {
1944   DWORD dwLen;
1945   WCHAR szKey[MAX_PATH];
1946
1947   TRACE("(%s,%s)\n", debugstr_w(lpszExt), debugstr_w(lpszType));
1948
1949   /* Get the full path to the key */
1950   if (!GetMIMETypeSubKeyW(lpszType, szKey, MAX_PATH)) /* Get full path to the key */
1951     return FALSE;
1952
1953   dwLen = (lstrlenW(lpszExt) + 1) * sizeof(WCHAR);
1954
1955   if (SHSetValueW(HKEY_CLASSES_ROOT, szKey, szExtensionW, REG_SZ, lpszExt, dwLen))
1956     return FALSE;
1957   return TRUE;
1958 }
1959
1960 /*************************************************************************
1961  * @   [SHLWAPI.326]
1962  *
1963  * Delete a file extension from a MIME content type.
1964  *
1965  * PARAMS
1966  *   lpszType [I] Content type to delete the extension for
1967  *
1968  * RETURNS
1969  *   Success: TRUE. The file extension is deleted from the registry.
1970  *   Failure: FALSE. The extension may have been removed but the key remains.
1971  *
1972  * NOTES
1973  *   If deleting the extension leaves an orphan key, the key is removed also.
1974  */
1975 BOOL WINAPI UnregisterExtensionForMIMETypeA(LPCSTR lpszType)
1976 {
1977   char szKey[MAX_PATH];
1978
1979   TRACE("(%s)\n", debugstr_a(lpszType));
1980
1981   if (!GetMIMETypeSubKeyA(lpszType, szKey, MAX_PATH)) /* Get full path to the key */
1982     return FALSE;
1983
1984   if (!SHDeleteValueA(HKEY_CLASSES_ROOT, szKey, szExtensionA))
1985     return FALSE;
1986
1987   if (!SHDeleteOrphanKeyA(HKEY_CLASSES_ROOT, szKey))
1988     return FALSE;
1989   return TRUE;
1990 }
1991
1992 /*************************************************************************
1993  * @   [SHLWAPI.327]
1994  *
1995  * Unicode version of UnregisterExtensionForMIMETypeA.
1996  */
1997 BOOL WINAPI UnregisterExtensionForMIMETypeW(LPCWSTR lpszType)
1998 {
1999   WCHAR szKey[MAX_PATH];
2000
2001   TRACE("(%s)\n", debugstr_w(lpszType));
2002
2003   if (!GetMIMETypeSubKeyW(lpszType, szKey, MAX_PATH)) /* Get full path to the key */
2004     return FALSE;
2005
2006   if (!SHDeleteValueW(HKEY_CLASSES_ROOT, szKey, szExtensionW))
2007     return FALSE;
2008
2009   if (!SHDeleteOrphanKeyW(HKEY_CLASSES_ROOT, szKey))
2010     return FALSE;
2011   return TRUE;
2012 }
2013
2014 /*************************************************************************
2015  * SHRegDuplicateHKey   [SHLWAPI.@]
2016  *
2017  * Create a duplicate of a registry handle.
2018  *
2019  * PARAMS
2020  *  hKey [I] key to duplicate.
2021  *
2022  * RETURNS
2023  *  A new handle pointing to the same key as hKey.
2024  */
2025 HKEY WINAPI SHRegDuplicateHKey(HKEY hKey)
2026 {
2027     HKEY newKey = 0;
2028
2029     RegOpenKeyExA(hKey, 0, 0, MAXIMUM_ALLOWED, &newKey);
2030     TRACE("new key is %p\n", newKey);
2031     return newKey;
2032 }
2033
2034
2035 /*************************************************************************
2036  * SHCopyKeyA   [SHLWAPI.@]
2037  *
2038  * Copy a key and its values/sub keys to another location.
2039  *
2040  * PARAMS
2041  *  hKeyDst    [I] Destination key
2042  *  lpszSubKey [I] Sub key under hKeyDst, or NULL to use hKeyDst directly
2043  *  hKeySrc    [I] Source key to copy from
2044  *  dwReserved [I] Reserved, must be 0
2045  *
2046  * RETURNS
2047  *  Success: ERROR_SUCCESS. The key is copied to the destination key.
2048  *  Failure: A standard windows error code.
2049  *
2050  * NOTES
2051  *  If hKeyDst is a key under hKeySrc, this function will misbehave
2052  *  (It will loop until out of stack, or the registry is full). This
2053  *  bug is present in Win32 also.
2054  */
2055 DWORD WINAPI SHCopyKeyA(HKEY hKeyDst, LPCSTR lpszSubKey, HKEY hKeySrc, DWORD dwReserved)
2056 {
2057   WCHAR szSubKeyW[MAX_PATH];
2058
2059   TRACE("(hkey=%p,%s,%p08x,%ld)\n", hKeyDst, debugstr_a(lpszSubKey), hKeySrc, dwReserved);
2060
2061   if (lpszSubKey)
2062     MultiByteToWideChar(0, 0, lpszSubKey, -1, szSubKeyW, MAX_PATH);
2063
2064   return SHCopyKeyW(hKeyDst, lpszSubKey ? szSubKeyW : NULL, hKeySrc, dwReserved);
2065 }
2066
2067 /*************************************************************************
2068  * SHCopyKeyW   [SHLWAPI.@]
2069  *
2070  * See SHCopyKeyA.
2071  */
2072 DWORD WINAPI SHCopyKeyW(HKEY hKeyDst, LPCWSTR lpszSubKey, HKEY hKeySrc, DWORD dwReserved)
2073 {
2074   DWORD dwKeyCount = 0, dwValueCount = 0, dwMaxKeyLen = 0;
2075   DWORD  dwMaxValueLen = 0, dwMaxDataLen = 0, i;
2076   BYTE buff[1024];
2077   LPVOID lpBuff = (LPVOID)buff;
2078   WCHAR szName[MAX_PATH], *lpszName = szName;
2079   DWORD dwRet = S_OK;
2080
2081   TRACE("hkey=%p,%s,%p08x,%ld)\n", hKeyDst, debugstr_w(lpszSubKey), hKeySrc, dwReserved);
2082
2083   if(!hKeyDst || !hKeySrc)
2084     dwRet = ERROR_INVALID_PARAMETER;
2085   else
2086   {
2087     /* Open destination key */
2088     if(lpszSubKey)
2089       dwRet = RegOpenKeyExW(hKeyDst, lpszSubKey, 0, KEY_ALL_ACCESS, &hKeyDst);
2090
2091     if(dwRet)
2092       hKeyDst = 0; /* Don't close this key since we didn't open it */
2093     else
2094     {
2095       /* Get details about sub keys and values */
2096       dwRet = RegQueryInfoKeyW(hKeySrc, NULL, NULL, NULL, &dwKeyCount, &dwMaxKeyLen,
2097                                NULL, &dwValueCount, &dwMaxValueLen, &dwMaxDataLen,
2098                                NULL, NULL);
2099       if(!dwRet)
2100       {
2101         if (dwMaxValueLen > dwMaxKeyLen)
2102           dwMaxKeyLen = dwMaxValueLen; /* Get max size for key/value names */
2103
2104         if (dwMaxKeyLen++ > MAX_PATH - 1)
2105           lpszName = HeapAlloc(GetProcessHeap(), 0, dwMaxKeyLen * sizeof(WCHAR));
2106
2107         if (dwMaxDataLen > sizeof(buff))
2108           lpBuff = HeapAlloc(GetProcessHeap(), 0, dwMaxDataLen);
2109
2110         if (!lpszName || !lpBuff)
2111           dwRet = ERROR_NOT_ENOUGH_MEMORY;
2112       }
2113     }
2114   }
2115
2116   /* Copy all the sub keys */
2117   for(i = 0; i < dwKeyCount && !dwRet; i++)
2118   {
2119     HKEY hSubKeySrc, hSubKeyDst;
2120     DWORD dwSize = dwMaxKeyLen;
2121
2122     dwRet = RegEnumKeyExW(hKeySrc, i, lpszName, &dwSize, NULL, NULL, NULL, NULL);
2123
2124     if(!dwRet)
2125     {
2126       /* Open source sub key */
2127       dwRet = RegOpenKeyExW(hKeySrc, lpszName, 0, KEY_READ, &hSubKeySrc);
2128
2129       if(!dwRet)
2130       {
2131         /* Create destination sub key */
2132         dwRet = RegCreateKeyW(hKeyDst, lpszName, &hSubKeyDst);
2133
2134         if(!dwRet)
2135         {
2136           /* Recursively copy keys and values from the sub key */
2137           dwRet = SHCopyKeyW(hSubKeyDst, NULL, hSubKeySrc, 0);
2138           RegCloseKey(hSubKeyDst);
2139         }
2140       }
2141       RegCloseKey(hSubKeySrc);
2142     }
2143   }
2144
2145   /* Copy all the values in this key */
2146   for (i = 0; i < dwValueCount && !dwRet; i++)
2147   {
2148     DWORD dwNameSize = dwMaxKeyLen, dwType, dwLen = dwMaxDataLen;
2149
2150     dwRet = RegEnumValueW(hKeySrc, i, lpszName, &dwNameSize, NULL, &dwType, buff, &dwLen);
2151
2152     if (!dwRet)
2153       dwRet = SHSetValueW(hKeyDst, NULL, lpszName, dwType, lpBuff, dwLen);
2154   }
2155
2156   /* Free buffers if allocated */
2157   if (lpszName != szName)
2158     HeapFree(GetProcessHeap(), 0, lpszName);
2159   if (lpBuff != buff)
2160     HeapFree(GetProcessHeap(), 0, lpBuff);
2161
2162   if (lpszSubKey && hKeyDst)
2163     RegCloseKey(hKeyDst);
2164   return dwRet;
2165 }
2166
2167 /*
2168  * The following functions are ORDINAL ONLY:
2169  */
2170
2171 /*************************************************************************
2172  *      @     [SHLWAPI.280]
2173  *
2174  * Read an integer value from the registry, falling back to a default.
2175  *
2176  * PARAMS
2177  *  hKey      [I] Registry key to read from
2178  *  lpszValue [I] Value name to read
2179  *  iDefault  [I] Default value to return
2180  *
2181  * RETURNS
2182  *  The value contained in the given registry value if present, otherwise
2183  *  iDefault.
2184  */
2185 int WINAPI SHRegGetIntW(HKEY hKey, LPCWSTR lpszValue, int iDefault)
2186 {
2187   TRACE("(%p,%s,%d)\n", hKey, debugstr_w(lpszValue), iDefault);
2188
2189   if (hKey)
2190   {
2191     WCHAR szBuff[32];
2192     DWORD dwSize = sizeof(szBuff);
2193     szBuff[0] = '\0';
2194     SHQueryValueExW(hKey, lpszValue, 0, 0, szBuff, &dwSize);
2195
2196     if(*szBuff >= '0' && *szBuff <= '9')
2197       return StrToIntW(szBuff);
2198   }
2199   return iDefault;
2200 }
2201
2202 /*************************************************************************
2203  *      @       [SHLWAPI.343]
2204  *
2205  * Create or open an explorer ClassId Key.
2206  *
2207  * PARAMS
2208  *  guid      [I] Explorer ClassId key to open
2209  *  lpszValue [I] Value name under the ClassId Key
2210  *  bUseHKCU  [I] TRUE=Use HKEY_CURRENT_USER, FALSE=Use HKEY_CLASSES_ROOT
2211  *  bCreate   [I] TRUE=Create the key if it doesn't exist, FALSE=Don't
2212  *  phKey     [O] Destination for the resulting key handle
2213  *
2214  * RETURNS
2215  *  Success: S_OK. phKey contains the resulting registry handle.
2216  *  Failure: An HRESULT error code indicating the problem.
2217  */
2218 HRESULT WINAPI SHRegGetCLSIDKeyA(REFGUID guid, LPCSTR lpszValue, BOOL bUseHKCU, BOOL bCreate, PHKEY phKey)
2219 {
2220   WCHAR szValue[MAX_PATH];
2221
2222   if (lpszValue)
2223     MultiByteToWideChar(CP_ACP, 0, lpszValue, -1, szValue, sizeof(szValue)/sizeof(WCHAR));
2224
2225   return SHRegGetCLSIDKeyW(guid, lpszValue ? szValue : NULL, bUseHKCU, bCreate, phKey);
2226 }
2227
2228 /*************************************************************************
2229  *      @       [SHLWAPI.344]
2230  *
2231  * Unicode version of SHRegGetCLSIDKeyA.
2232  */
2233 HRESULT WINAPI SHRegGetCLSIDKeyW(REFGUID guid, LPCWSTR lpszValue, BOOL bUseHKCU,
2234                            BOOL bCreate, PHKEY phKey)
2235 {
2236   static const WCHAR szClassIdKey[] = { 'S','o','f','t','w','a','r','e','\\',
2237     'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\',
2238     'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
2239     'E','x','p','l','o','r','e','r','\\','C','L','S','I','D','\\' };
2240 #define szClassIdKeyLen (sizeof(szClassIdKey)/sizeof(WCHAR))
2241   WCHAR szKey[MAX_PATH];
2242   DWORD dwRet;
2243   HKEY hkey;
2244
2245   /* Create the key string */
2246   memcpy(szKey, szClassIdKey, sizeof(szClassIdKey));
2247   SHStringFromGUIDW(guid, szKey + szClassIdKeyLen, 39); /* Append guid */
2248
2249   if(lpszValue)
2250   {
2251     szKey[szClassIdKeyLen + 39] = '\\';
2252     strcpyW(szKey + szClassIdKeyLen + 40, lpszValue); /* Append value name */
2253   }
2254
2255   hkey = bUseHKCU ? HKEY_CURRENT_USER : HKEY_CLASSES_ROOT;
2256
2257   if(bCreate)
2258     dwRet = RegCreateKeyW(hkey, szKey, phKey);
2259   else
2260     dwRet = RegOpenKeyExW(hkey, szKey, 0, KEY_READ, phKey);
2261
2262   return dwRet ? HRESULT_FROM_WIN32(dwRet) : S_OK;
2263 }
2264
2265 /*************************************************************************
2266  * SHRegisterValidateTemplate   [SHLWAPI.@]
2267  *
2268  * observed from the ie 5.5 installer:
2269  *  - allocates a buffer with the size of the given file
2270  *  - read the file content into the buffer
2271  *  - creates the key szTemplateKey
2272  *  - sets "205523652929647911071668590831910975402"=dword:00002e37 at
2273  *    the key
2274  *
2275  * PARAMS
2276  *  filename [I] An existing file its content is read into an allocated
2277  *               buffer
2278  *  unknown  [I]
2279  *
2280  * RETURNS
2281  *  Success: ERROR_SUCCESS.
2282  */
2283 HRESULT WINAPI SHRegisterValidateTemplate(LPCWSTR filename, BOOL unknown)
2284 {
2285 /* static const WCHAR szTemplateKey[] = { 'S','o','f','t','w','a','r','e','\\',
2286  *  'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\',
2287  *  'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
2288  *  'E','x','p','l','o','r','e','r','\\',
2289  *  'T','e','m','p','l','a','t','e','R','e','g','i','s','t','r','y',0 };
2290  */
2291   FIXME("stub: %s, %08x\n", debugstr_w(filename), unknown);
2292
2293   return S_OK;
2294 }