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