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