?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gdi32/tests: Add tests for 1bpp brushes.
[wine/multimedia.git] / dlls / shell32 / shellpath.c
blobef0564cc12eb604d493ca62bfa523bfc65b911c8
1 /*
2 * Path Functions
3 *
4 * Copyright 1998, 1999, 2000 Juergen Schmied
5 * Copyright 2004 Juan Lang
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 * NOTES:
22 *
23 * Many of these functions are in SHLWAPI.DLL also
24 *
25 */
26
27 #define COBJMACROS
28
29 #include "config.h"
30 #include "wine/port.h"
31
32 #include <stdio.h>
33 #include <stdarg.h>
34 #include <string.h>
35 #include <ctype.h>
36 #include "wine/debug.h"
37 #include "windef.h"
38 #include "winbase.h"
39 #include "winnls.h"
40 #include "winreg.h"
41 #include "wingdi.h"
42 #include "winuser.h"
43
44 #include "shlobj.h"
45 #include "shtypes.h"
46 #include "shresdef.h"
47 #include "shell32_main.h"
48 #include "undocshell.h"
49 #include "pidl.h"
50 #include "wine/unicode.h"
51 #include "shlwapi.h"
52 #include "xdg.h"
53 #include "sddl.h"
54 #define INITGUID
55 #include "knownfolders.h"
56 #include "shobjidl.h"
57
58 WINE_DEFAULT_DEBUG_CHANNEL(shell);
59
60 static const BOOL is_win64 = sizeof(void *) > sizeof(int);
61
62 /*
63 ########## Combining and Constructing paths ##########
64 */
65
66 /*************************************************************************
67 * PathAppend [SHELL32.36]
68 */
69 BOOL WINAPI PathAppendAW(
70 LPVOID lpszPath1,
71 LPCVOID lpszPath2)
72 {
73 if (SHELL_OsIsUnicode())
74 return PathAppendW(lpszPath1, lpszPath2);
75 return PathAppendA(lpszPath1, lpszPath2);
76 }
77
78 /*************************************************************************
79 * PathCombine [SHELL32.37]
80 */
81 LPVOID WINAPI PathCombineAW(
82 LPVOID szDest,
83 LPCVOID lpszDir,
84 LPCVOID lpszFile)
85 {
86 if (SHELL_OsIsUnicode())
87 return PathCombineW( szDest, lpszDir, lpszFile );
88 return PathCombineA( szDest, lpszDir, lpszFile );
89 }
90
91 /*************************************************************************
92 * PathAddBackslash [SHELL32.32]
93 */
94 LPVOID WINAPI PathAddBackslashAW(LPVOID lpszPath)
95 {
96 if(SHELL_OsIsUnicode())
97 return PathAddBackslashW(lpszPath);
98 return PathAddBackslashA(lpszPath);
99 }
100
101 /*************************************************************************
102 * PathBuildRoot [SHELL32.30]
103 */
104 LPVOID WINAPI PathBuildRootAW(LPVOID lpszPath, int drive)
105 {
106 if(SHELL_OsIsUnicode())
107 return PathBuildRootW(lpszPath, drive);
108 return PathBuildRootA(lpszPath, drive);
109 }
110
111 /*
112 Extracting Component Parts
113 */
114
115 /*************************************************************************
116 * PathFindFileName [SHELL32.34]
117 */
118 LPVOID WINAPI PathFindFileNameAW(LPCVOID lpszPath)
119 {
120 if(SHELL_OsIsUnicode())
121 return PathFindFileNameW(lpszPath);
122 return PathFindFileNameA(lpszPath);
123 }
124
125 /*************************************************************************
126 * PathFindExtension [SHELL32.31]
127 */
128 LPVOID WINAPI PathFindExtensionAW(LPCVOID lpszPath)
129 {
130 if (SHELL_OsIsUnicode())
131 return PathFindExtensionW(lpszPath);
132 return PathFindExtensionA(lpszPath);
133
134 }
135
136 /*************************************************************************
137 * PathGetExtensionA [internal]
138 *
139 * NOTES
140 * exported by ordinal
141 * return value points to the first char after the dot
142 */
143 static LPSTR PathGetExtensionA(LPCSTR lpszPath)
144 {
145 TRACE("(%s)\n",lpszPath);
146
147 lpszPath = PathFindExtensionA(lpszPath);
148 return (LPSTR)(*lpszPath?(lpszPath+1):lpszPath);
149 }
150
151 /*************************************************************************
152 * PathGetExtensionW [internal]
153 */
154 static LPWSTR PathGetExtensionW(LPCWSTR lpszPath)
155 {
156 TRACE("(%s)\n",debugstr_w(lpszPath));
157
158 lpszPath = PathFindExtensionW(lpszPath);
159 return (LPWSTR)(*lpszPath?(lpszPath+1):lpszPath);
160 }
161
162 /*************************************************************************
163 * PathGetExtension [SHELL32.158]
164 */
165 LPVOID WINAPI PathGetExtensionAW(LPCVOID lpszPath,DWORD void1, DWORD void2)
166 {
167 if (SHELL_OsIsUnicode())
168 return PathGetExtensionW(lpszPath);
169 return PathGetExtensionA(lpszPath);
170 }
171
172 /*************************************************************************
173 * PathGetArgs [SHELL32.52]
174 */
175 LPVOID WINAPI PathGetArgsAW(LPVOID lpszPath)
176 {
177 if (SHELL_OsIsUnicode())
178 return PathGetArgsW(lpszPath);
179 return PathGetArgsA(lpszPath);
180 }
181
182 /*************************************************************************
183 * PathGetDriveNumber [SHELL32.57]
184 */
185 int WINAPI PathGetDriveNumberAW(LPVOID lpszPath)
186 {
187 if (SHELL_OsIsUnicode())
188 return PathGetDriveNumberW(lpszPath);
189 return PathGetDriveNumberA(lpszPath);
190 }
191
192 /*************************************************************************
193 * PathRemoveFileSpec [SHELL32.35]
194 */
195 BOOL WINAPI PathRemoveFileSpecAW(LPVOID lpszPath)
196 {
197 if (SHELL_OsIsUnicode())
198 return PathRemoveFileSpecW(lpszPath);
199 return PathRemoveFileSpecA(lpszPath);
200 }
201
202 /*************************************************************************
203 * PathStripPath [SHELL32.38]
204 */
205 void WINAPI PathStripPathAW(LPVOID lpszPath)
206 {
207 if (SHELL_OsIsUnicode())
208 PathStripPathW(lpszPath);
209 else
210 PathStripPathA(lpszPath);
211 }
212
213 /*************************************************************************
214 * PathStripToRoot [SHELL32.50]
215 */
216 BOOL WINAPI PathStripToRootAW(LPVOID lpszPath)
217 {
218 if (SHELL_OsIsUnicode())
219 return PathStripToRootW(lpszPath);
220 return PathStripToRootA(lpszPath);
221 }
222
223 /*************************************************************************
224 * PathRemoveArgs [SHELL32.251]
225 */
226 void WINAPI PathRemoveArgsAW(LPVOID lpszPath)
227 {
228 if (SHELL_OsIsUnicode())
229 PathRemoveArgsW(lpszPath);
230 else
231 PathRemoveArgsA(lpszPath);
232 }
233
234 /*************************************************************************
235 * PathRemoveExtension [SHELL32.250]
236 */
237 void WINAPI PathRemoveExtensionAW(LPVOID lpszPath)
238 {
239 if (SHELL_OsIsUnicode())
240 PathRemoveExtensionW(lpszPath);
241 else
242 PathRemoveExtensionA(lpszPath);
243 }
244
245
246 /*
247 Path Manipulations
248 */
249
250 /*************************************************************************
251 * PathGetShortPathA [internal]
252 */
253 static void PathGetShortPathA(LPSTR pszPath)
254 {
255 CHAR path[MAX_PATH];
256
257 TRACE("%s\n", pszPath);
258
259 if (GetShortPathNameA(pszPath, path, MAX_PATH))
260 {
261 lstrcpyA(pszPath, path);
262 }
263 }
264
265 /*************************************************************************
266 * PathGetShortPathW [internal]
267 */
268 static void PathGetShortPathW(LPWSTR pszPath)
269 {
270 WCHAR path[MAX_PATH];
271
272 TRACE("%s\n", debugstr_w(pszPath));
273
274 if (GetShortPathNameW(pszPath, path, MAX_PATH))
275 {
276 lstrcpyW(pszPath, path);
277 }
278 }
279
280 /*************************************************************************
281 * PathGetShortPath [SHELL32.92]
282 */
283 VOID WINAPI PathGetShortPathAW(LPVOID pszPath)
284 {
285 if(SHELL_OsIsUnicode())
286 PathGetShortPathW(pszPath);
287 PathGetShortPathA(pszPath);
288 }
289
290 /*************************************************************************
291 * PathRemoveBlanks [SHELL32.33]
292 */
293 void WINAPI PathRemoveBlanksAW(LPVOID str)
294 {
295 if(SHELL_OsIsUnicode())
296 PathRemoveBlanksW(str);
297 else
298 PathRemoveBlanksA(str);
299 }
300
301 /*************************************************************************
302 * PathQuoteSpaces [SHELL32.55]
303 */
304 VOID WINAPI PathQuoteSpacesAW (LPVOID lpszPath)
305 {
306 if(SHELL_OsIsUnicode())
307 PathQuoteSpacesW(lpszPath);
308 else
309 PathQuoteSpacesA(lpszPath);
310 }
311
312 /*************************************************************************
313 * PathUnquoteSpaces [SHELL32.56]
314 */
315 VOID WINAPI PathUnquoteSpacesAW(LPVOID str)
316 {
317 if(SHELL_OsIsUnicode())
318 PathUnquoteSpacesW(str);
319 else
320 PathUnquoteSpacesA(str);
321 }
322
323 /*************************************************************************
324 * PathParseIconLocation [SHELL32.249]
325 */
326 int WINAPI PathParseIconLocationAW (LPVOID lpszPath)
327 {
328 if(SHELL_OsIsUnicode())
329 return PathParseIconLocationW(lpszPath);
330 return PathParseIconLocationA(lpszPath);
331 }
332
333 /*
334 ########## Path Testing ##########
335 */
336 /*************************************************************************
337 * PathIsUNC [SHELL32.39]
338 */
339 BOOL WINAPI PathIsUNCAW (LPCVOID lpszPath)
340 {
341 if (SHELL_OsIsUnicode())
342 return PathIsUNCW( lpszPath );
343 return PathIsUNCA( lpszPath );
344 }
345
346 /*************************************************************************
347 * PathIsRelative [SHELL32.40]
348 */
349 BOOL WINAPI PathIsRelativeAW (LPCVOID lpszPath)
350 {
351 if (SHELL_OsIsUnicode())
352 return PathIsRelativeW( lpszPath );
353 return PathIsRelativeA( lpszPath );
354 }
355
356 /*************************************************************************
357 * PathIsRoot [SHELL32.29]
358 */
359 BOOL WINAPI PathIsRootAW(LPCVOID lpszPath)
360 {
361 if (SHELL_OsIsUnicode())
362 return PathIsRootW(lpszPath);
363 return PathIsRootA(lpszPath);
364 }
365
366 /*************************************************************************
367 * PathIsExeA [internal]
368 */
369 static BOOL PathIsExeA (LPCSTR lpszPath)
370 {
371 LPCSTR lpszExtension = PathGetExtensionA(lpszPath);
372 int i;
373 static const char * const lpszExtensions[] =
374 {"exe", "com", "pif", "cmd", "bat", "scf", "scr", NULL };
375
376 TRACE("path=%s\n",lpszPath);
377
378 for(i=0; lpszExtensions[i]; i++)
379 if (!lstrcmpiA(lpszExtension,lpszExtensions[i])) return TRUE;
380
381 return FALSE;
382 }
383
384 /*************************************************************************
385 * PathIsExeW [internal]
386 */
387 static BOOL PathIsExeW (LPCWSTR lpszPath)
388 {
389 LPCWSTR lpszExtension = PathGetExtensionW(lpszPath);
390 int i;
391 static const WCHAR lpszExtensions[][4] =
392 {{'e','x','e','\0'}, {'c','o','m','\0'}, {'p','i','f','\0'},
393 {'c','m','d','\0'}, {'b','a','t','\0'}, {'s','c','f','\0'},
394 {'s','c','r','\0'}, {'\0'} };
395
396 TRACE("path=%s\n",debugstr_w(lpszPath));
397
398 for(i=0; lpszExtensions[i][0]; i++)
399 if (!strcmpiW(lpszExtension,lpszExtensions[i])) return TRUE;
400
401 return FALSE;
402 }
403
404 /*************************************************************************
405 * PathIsExe [SHELL32.43]
406 */
407 BOOL WINAPI PathIsExeAW (LPCVOID path)
408 {
409 if (SHELL_OsIsUnicode())
410 return PathIsExeW (path);
411 return PathIsExeA(path);
412 }
413
414 /*************************************************************************
415 * PathIsDirectory [SHELL32.159]
416 */
417 BOOL WINAPI PathIsDirectoryAW (LPCVOID lpszPath)
418 {
419 if (SHELL_OsIsUnicode())
420 return PathIsDirectoryW (lpszPath);
421 return PathIsDirectoryA (lpszPath);
422 }
423
424 /*************************************************************************
425 * PathFileExists [SHELL32.45]
426 */
427 BOOL WINAPI PathFileExistsAW (LPCVOID lpszPath)
428 {
429 if (SHELL_OsIsUnicode())
430 return PathFileExistsW (lpszPath);
431 return PathFileExistsA (lpszPath);
432 }
433
434 /*************************************************************************
435 * PathMatchSpec [SHELL32.46]
436 */
437 BOOL WINAPI PathMatchSpecAW(LPVOID name, LPVOID mask)
438 {
439 if (SHELL_OsIsUnicode())
440 return PathMatchSpecW( name, mask );
441 return PathMatchSpecA( name, mask );
442 }
443
444 /*************************************************************************
445 * PathIsSameRoot [SHELL32.650]
446 */
447 BOOL WINAPI PathIsSameRootAW(LPCVOID lpszPath1, LPCVOID lpszPath2)
448 {
449 if (SHELL_OsIsUnicode())
450 return PathIsSameRootW(lpszPath1, lpszPath2);
451 return PathIsSameRootA(lpszPath1, lpszPath2);
452 }
453
454 /*************************************************************************
455 * IsLFNDriveA [SHELL32.41]
456 */
457 BOOL WINAPI IsLFNDriveA(LPCSTR lpszPath)
458 {
459 DWORD fnlen;
460
461 if (!GetVolumeInformationA(lpszPath, NULL, 0, NULL, &fnlen, NULL, NULL, 0))
462 return FALSE;
463 return fnlen > 12;
464 }
465
466 /*************************************************************************
467 * IsLFNDriveW [SHELL32.42]
468 */
469 BOOL WINAPI IsLFNDriveW(LPCWSTR lpszPath)
470 {
471 DWORD fnlen;
472
473 if (!GetVolumeInformationW(lpszPath, NULL, 0, NULL, &fnlen, NULL, NULL, 0))
474 return FALSE;
475 return fnlen > 12;
476 }
477
478 /*************************************************************************
479 * IsLFNDrive [SHELL32.119]
480 */
481 BOOL WINAPI IsLFNDriveAW(LPCVOID lpszPath)
482 {
483 if (SHELL_OsIsUnicode())
484 return IsLFNDriveW(lpszPath);
485 return IsLFNDriveA(lpszPath);
486 }
487
488 /*
489 ########## Creating Something Unique ##########
490 */
491 /*************************************************************************
492 * PathMakeUniqueNameA [internal]
493 */
494 static BOOL PathMakeUniqueNameA(
495 LPSTR lpszBuffer,
496 DWORD dwBuffSize,
497 LPCSTR lpszShortName,
498 LPCSTR lpszLongName,
499 LPCSTR lpszPathName)
500 {
501 FIXME("%p %u %s %s %s stub\n",
502 lpszBuffer, dwBuffSize, debugstr_a(lpszShortName),
503 debugstr_a(lpszLongName), debugstr_a(lpszPathName));
504 return TRUE;
505 }
506
507 /*************************************************************************
508 * PathMakeUniqueNameW [internal]
509 */
510 static BOOL PathMakeUniqueNameW(
511 LPWSTR lpszBuffer,
512 DWORD dwBuffSize,
513 LPCWSTR lpszShortName,
514 LPCWSTR lpszLongName,
515 LPCWSTR lpszPathName)
516 {
517 FIXME("%p %u %s %s %s stub\n",
518 lpszBuffer, dwBuffSize, debugstr_w(lpszShortName),
519 debugstr_w(lpszLongName), debugstr_w(lpszPathName));
520 return TRUE;
521 }
522
523 /*************************************************************************
524 * PathMakeUniqueName [SHELL32.47]
525 */
526 BOOL WINAPI PathMakeUniqueNameAW(
527 LPVOID lpszBuffer,
528 DWORD dwBuffSize,
529 LPCVOID lpszShortName,
530 LPCVOID lpszLongName,
531 LPCVOID lpszPathName)
532 {
533 if (SHELL_OsIsUnicode())
534 return PathMakeUniqueNameW(lpszBuffer,dwBuffSize, lpszShortName,lpszLongName,lpszPathName);
535 return PathMakeUniqueNameA(lpszBuffer,dwBuffSize, lpszShortName,lpszLongName,lpszPathName);
536 }
537
538 /*************************************************************************
539 * PathYetAnotherMakeUniqueName [SHELL32.75]
540 *
541 * NOTES
542 * exported by ordinal
543 */
544 BOOL WINAPI PathYetAnotherMakeUniqueName(
545 LPWSTR lpszBuffer,
546 LPCWSTR lpszPathName,
547 LPCWSTR lpszShortName,
548 LPCWSTR lpszLongName)
549 {
550 FIXME("(%p, %s, %s ,%s):stub.\n",
551 lpszBuffer, debugstr_w(lpszPathName), debugstr_w(lpszShortName), debugstr_w(lpszLongName));
552 return TRUE;
553 }
554
555
556 /*
557 ########## cleaning and resolving paths ##########
558 */
559
560 /*************************************************************************
561 * PathFindOnPath [SHELL32.145]
562 */
563 BOOL WINAPI PathFindOnPathAW(LPVOID sFile, LPCVOID *sOtherDirs)
564 {
565 if (SHELL_OsIsUnicode())
566 return PathFindOnPathW(sFile, (LPCWSTR *)sOtherDirs);
567 return PathFindOnPathA(sFile, (LPCSTR *)sOtherDirs);
568 }
569
570 /*************************************************************************
571 * PathCleanupSpec [SHELL32.171]
572 *
573 * lpszFile is changed in place.
574 */
575 int WINAPI PathCleanupSpec( LPCWSTR lpszPathW, LPWSTR lpszFileW )
576 {
577 int i = 0;
578 DWORD rc = 0;
579 int length = 0;
580
581 if (SHELL_OsIsUnicode())
582 {
583 LPWSTR p = lpszFileW;
584
585 TRACE("Cleanup %s\n",debugstr_w(lpszFileW));
586
587 if (lpszPathW)
588 length = strlenW(lpszPathW);
589
590 while (*p)
591 {
592 int gct = PathGetCharTypeW(*p);
593 if (gct == GCT_INVALID || gct == GCT_WILD || gct == GCT_SEPARATOR)
594 {
595 lpszFileW[i]='-';
596 rc |= PCS_REPLACEDCHAR;
597 }
598 else
599 lpszFileW[i]=*p;
600 i++;
601 p++;
602 if (length + i == MAX_PATH)
603 {
604 rc |= PCS_FATAL | PCS_PATHTOOLONG;
605 break;
606 }
607 }
608 lpszFileW[i]=0;
609 }
610 else
611 {
612 LPSTR lpszFileA = (LPSTR)lpszFileW;
613 LPCSTR lpszPathA = (LPCSTR)lpszPathW;
614 LPSTR p = lpszFileA;
615
616 TRACE("Cleanup %s\n",debugstr_a(lpszFileA));
617
618 if (lpszPathA)
619 length = strlen(lpszPathA);
620
621 while (*p)
622 {
623 int gct = PathGetCharTypeA(*p);
624 if (gct == GCT_INVALID || gct == GCT_WILD || gct == GCT_SEPARATOR)
625 {
626 lpszFileA[i]='-';
627 rc |= PCS_REPLACEDCHAR;
628 }
629 else
630 lpszFileA[i]=*p;
631 i++;
632 p++;
633 if (length + i == MAX_PATH)
634 {
635 rc |= PCS_FATAL | PCS_PATHTOOLONG;
636 break;
637 }
638 }
639 lpszFileA[i]=0;
640 }
641 return rc;
642 }
643
644 /*************************************************************************
645 * PathQualifyA [SHELL32]
646 */
647 static BOOL PathQualifyA(LPCSTR pszPath)
648 {
649 FIXME("%s\n",pszPath);
650 return 0;
651 }
652
653 /*************************************************************************
654 * PathQualifyW [SHELL32]
655 */
656 static BOOL PathQualifyW(LPCWSTR pszPath)
657 {
658 FIXME("%s\n",debugstr_w(pszPath));
659 return 0;
660 }
661
662 /*************************************************************************
663 * PathQualify [SHELL32.49]
664 */
665 BOOL WINAPI PathQualifyAW(LPCVOID pszPath)
666 {
667 if (SHELL_OsIsUnicode())
668 return PathQualifyW(pszPath);
669 return PathQualifyA(pszPath);
670 }
671
672 static BOOL PathResolveA(
673 LPSTR lpszPath,
674 LPCSTR *alpszPaths,
675 DWORD dwFlags)
676 {
677 FIXME("(%s,%p,0x%08x),stub!\n",
678 lpszPath, *alpszPaths, dwFlags);
679 return 0;
680 }
681
682 static BOOL PathResolveW(
683 LPWSTR lpszPath,
684 LPCWSTR *alpszPaths,
685 DWORD dwFlags)
686 {
687 FIXME("(%s,%p,0x%08x),stub!\n",
688 debugstr_w(lpszPath), debugstr_w(*alpszPaths), dwFlags);
689 return 0;
690 }
691
692 /*************************************************************************
693 * PathResolve [SHELL32.51]
694 */
695 BOOL WINAPI PathResolveAW(
696 LPVOID lpszPath,
697 LPCVOID *alpszPaths,
698 DWORD dwFlags)
699 {
700 if (SHELL_OsIsUnicode())
701 return PathResolveW(lpszPath, (LPCWSTR*)alpszPaths, dwFlags);
702 return PathResolveA(lpszPath, (LPCSTR*)alpszPaths, dwFlags);
703 }
704
705 /*************************************************************************
706 * PathProcessCommandA
707 */
708 static LONG PathProcessCommandA (
709 LPCSTR lpszPath,
710 LPSTR lpszBuff,
711 DWORD dwBuffSize,
712 DWORD dwFlags)
713 {
714 FIXME("%s %p 0x%04x 0x%04x stub\n",
715 lpszPath, lpszBuff, dwBuffSize, dwFlags);
716 if(!lpszPath) return -1;
717 if(lpszBuff) strcpy(lpszBuff, lpszPath);
718 return strlen(lpszPath);
719 }
720
721 /*************************************************************************
722 * PathProcessCommandW
723 */
724 static LONG PathProcessCommandW (
725 LPCWSTR lpszPath,
726 LPWSTR lpszBuff,
727 DWORD dwBuffSize,
728 DWORD dwFlags)
729 {
730 FIXME("(%s, %p, 0x%04x, 0x%04x) stub\n",
731 debugstr_w(lpszPath), lpszBuff, dwBuffSize, dwFlags);
732 if(!lpszPath) return -1;
733 if(lpszBuff) strcpyW(lpszBuff, lpszPath);
734 return strlenW(lpszPath);
735 }
736
737 /*************************************************************************
738 * PathProcessCommand (SHELL32.653)
739 */
740 LONG WINAPI PathProcessCommandAW (
741 LPCVOID lpszPath,
742 LPVOID lpszBuff,
743 DWORD dwBuffSize,
744 DWORD dwFlags)
745 {
746 if (SHELL_OsIsUnicode())
747 return PathProcessCommandW(lpszPath, lpszBuff, dwBuffSize, dwFlags);
748 return PathProcessCommandA(lpszPath, lpszBuff, dwBuffSize, dwFlags);
749 }
750
751 /*
752 ########## special ##########
753 */
754
755 /*************************************************************************
756 * PathSetDlgItemPath (SHELL32.48)
757 */
758 VOID WINAPI PathSetDlgItemPathAW(HWND hDlg, int id, LPCVOID pszPath)
759 {
760 if (SHELL_OsIsUnicode())
761 PathSetDlgItemPathW(hDlg, id, pszPath);
762 else
763 PathSetDlgItemPathA(hDlg, id, pszPath);
764 }
765
766 static const WCHAR szCurrentVersion[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\0'};
767 static const WCHAR Administrative_ToolsW[] = {'A','d','m','i','n','i','s','t','r','a','t','i','v','e',' ','T','o','o','l','s','\0'};
768 static const WCHAR AppDataW[] = {'A','p','p','D','a','t','a','\0'};
769 static const WCHAR CacheW[] = {'C','a','c','h','e','\0'};
770 static const WCHAR CD_BurningW[] = {'C','D',' ','B','u','r','n','i','n','g','\0'};
771 static const WCHAR Common_Administrative_ToolsW[] = {'C','o','m','m','o','n',' ','A','d','m','i','n','i','s','t','r','a','t','i','v','e',' ','T','o','o','l','s','\0'};
772 static const WCHAR Common_AppDataW[] = {'C','o','m','m','o','n',' ','A','p','p','D','a','t','a','\0'};
773 static const WCHAR Common_DesktopW[] = {'C','o','m','m','o','n',' ','D','e','s','k','t','o','p','\0'};
774 static const WCHAR Common_DocumentsW[] = {'C','o','m','m','o','n',' ','D','o','c','u','m','e','n','t','s','\0'};
775 static const WCHAR Common_FavoritesW[] = {'C','o','m','m','o','n',' ','F','a','v','o','r','i','t','e','s','\0'};
776 static const WCHAR CommonFilesDirW[] = {'C','o','m','m','o','n','F','i','l','e','s','D','i','r','\0'};
777 static const WCHAR CommonFilesDirX86W[] = {'C','o','m','m','o','n','F','i','l','e','s','D','i','r',' ','(','x','8','6',')','\0'};
778 static const WCHAR CommonMusicW[] = {'C','o','m','m','o','n','M','u','s','i','c','\0'};
779 static const WCHAR CommonPicturesW[] = {'C','o','m','m','o','n','P','i','c','t','u','r','e','s','\0'};
780 static const WCHAR Common_ProgramsW[] = {'C','o','m','m','o','n',' ','P','r','o','g','r','a','m','s','\0'};
781 static const WCHAR Common_StartUpW[] = {'C','o','m','m','o','n',' ','S','t','a','r','t','U','p','\0'};
782 static const WCHAR Common_Start_MenuW[] = {'C','o','m','m','o','n',' ','S','t','a','r','t',' ','M','e','n','u','\0'};
783 static const WCHAR Common_TemplatesW[] = {'C','o','m','m','o','n',' ','T','e','m','p','l','a','t','e','s','\0'};
784 static const WCHAR CommonVideoW[] = {'C','o','m','m','o','n','V','i','d','e','o','\0'};
785 static const WCHAR ContactsW[] = {'C','o','n','t','a','c','t','s','\0'};
786 static const WCHAR CookiesW[] = {'C','o','o','k','i','e','s','\0'};
787 static const WCHAR DesktopW[] = {'D','e','s','k','t','o','p','\0'};
788 static const WCHAR FavoritesW[] = {'F','a','v','o','r','i','t','e','s','\0'};
789 static const WCHAR FontsW[] = {'F','o','n','t','s','\0'};
790 static const WCHAR HistoryW[] = {'H','i','s','t','o','r','y','\0'};
791 static const WCHAR Local_AppDataW[] = {'L','o','c','a','l',' ','A','p','p','D','a','t','a','\0'};
792 static const WCHAR My_MusicW[] = {'M','y',' ','M','u','s','i','c','\0'};
793 static const WCHAR My_PicturesW[] = {'M','y',' ','P','i','c','t','u','r','e','s','\0'};
794 static const WCHAR My_VideoW[] = {'M','y',' ','V','i','d','e','o','s','\0'};
795 static const WCHAR NetHoodW[] = {'N','e','t','H','o','o','d','\0'};
796 static const WCHAR PersonalW[] = {'P','e','r','s','o','n','a','l','\0'};
797 static const WCHAR PrintHoodW[] = {'P','r','i','n','t','H','o','o','d','\0'};
798 static const WCHAR ProgramFilesDirW[] = {'P','r','o','g','r','a','m','F','i','l','e','s','D','i','r','\0'};
799 static const WCHAR ProgramFilesDirX86W[] = {'P','r','o','g','r','a','m','F','i','l','e','s','D','i','r',' ','(','x','8','6',')','\0'};
800 static const WCHAR ProgramsW[] = {'P','r','o','g','r','a','m','s','\0'};
801 static const WCHAR RecentW[] = {'R','e','c','e','n','t','\0'};
802 static const WCHAR ResourcesW[] = {'R','e','s','o','u','r','c','e','s','\0'};
803 static const WCHAR SendToW[] = {'S','e','n','d','T','o','\0'};
804 static const WCHAR StartUpW[] = {'S','t','a','r','t','U','p','\0'};
805 static const WCHAR Start_MenuW[] = {'S','t','a','r','t',' ','M','e','n','u','\0'};
806 static const WCHAR TemplatesW[] = {'T','e','m','p','l','a','t','e','s','\0'};
807 static const WCHAR UsersW[] = {'U','s','e','r','s','\0'};
808 static const WCHAR UsersPublicW[] = {'U','s','e','r','s','\\','P','u','b','l','i','c','\0'};
809 static const WCHAR DefaultW[] = {'.','D','e','f','a','u','l','t','\0'};
810 static const WCHAR AllUsersProfileW[] = {'%','A','L','L','U','S','E','R','S','P','R','O','F','I','L','E','%','\0'};
811 static const WCHAR UserProfileW[] = {'%','U','S','E','R','P','R','O','F','I','L','E','%','\0'};
812 static const WCHAR SystemDriveW[] = {'%','S','y','s','t','e','m','D','r','i','v','e','%','\0'};
813 static const WCHAR ProfileListW[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s',' ','N','T','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\','P','r','o','f','i','l','e','L','i','s','t',0};
814 static const WCHAR ProfilesDirectoryW[] = {'P','r','o','f','i','l','e','s','D','i','r','e','c','t','o','r','y',0};
815 static const WCHAR AllUsersProfileValueW[] = {'A','l','l','U','s','e','r','s','P','r','o','f','i','l','e','\0'};
816 static const WCHAR szSHFolders[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\','E','x','p','l','o','r','e','r','\\','S','h','e','l','l',' ','F','o','l','d','e','r','s','\0'};
817 static const WCHAR szSHUserFolders[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\','E','x','p','l','o','r','e','r','\\','U','s','e','r',' ','S','h','e','l','l',' ','F','o','l','d','e','r','s','\0'};
818 static const WCHAR szDefaultProfileDirW[] = {'u','s','e','r','s',0};
819 static const WCHAR AllUsersW[] = {'P','u','b','l','i','c',0};
820
821 typedef enum _CSIDL_Type {
822 CSIDL_Type_User,
823 CSIDL_Type_AllUsers,
824 CSIDL_Type_CurrVer,
825 CSIDL_Type_Disallowed,
826 CSIDL_Type_NonExistent,
827 CSIDL_Type_WindowsPath,
828 CSIDL_Type_SystemPath,
829 CSIDL_Type_SystemX86Path,
830 } CSIDL_Type;
831
832 typedef struct
833 {
834 const KNOWNFOLDERID *id;
835 CSIDL_Type type;
836 LPCWSTR szValueName;
837 LPCWSTR szDefaultPath; /* fallback string or resource ID */
838 } CSIDL_DATA;
839
840 static const CSIDL_DATA CSIDL_Data[] =
841 {
842 { /* 0x00 - CSIDL_DESKTOP */
843 &FOLDERID_Desktop,
844 CSIDL_Type_User,
845 DesktopW,
846 MAKEINTRESOURCEW(IDS_DESKTOPDIRECTORY)
847 },
848 { /* 0x01 - CSIDL_INTERNET */
849 &FOLDERID_InternetFolder,
850 CSIDL_Type_Disallowed,
851 NULL,
852 NULL
853 },
854 { /* 0x02 - CSIDL_PROGRAMS */
855 &FOLDERID_Programs,
856 CSIDL_Type_User,
857 ProgramsW,
858 MAKEINTRESOURCEW(IDS_PROGRAMS)
859 },
860 { /* 0x03 - CSIDL_CONTROLS (.CPL files) */
861 &FOLDERID_ControlPanelFolder,
862 CSIDL_Type_SystemPath,
863 NULL,
864 NULL
865 },
866 { /* 0x04 - CSIDL_PRINTERS */
867 &FOLDERID_PrintersFolder,
868 CSIDL_Type_SystemPath,
869 NULL,
870 NULL
871 },
872 { /* 0x05 - CSIDL_PERSONAL */
873 &GUID_NULL,
874 CSIDL_Type_User,
875 PersonalW,
876 MAKEINTRESOURCEW(IDS_PERSONAL)
877 },
878 { /* 0x06 - CSIDL_FAVORITES */
879 &FOLDERID_Favorites,
880 CSIDL_Type_User,
881 FavoritesW,
882 MAKEINTRESOURCEW(IDS_FAVORITES)
883 },
884 { /* 0x07 - CSIDL_STARTUP */
885 &FOLDERID_Startup,
886 CSIDL_Type_User,
887 StartUpW,
888 MAKEINTRESOURCEW(IDS_STARTUP)
889 },
890 { /* 0x08 - CSIDL_RECENT */
891 &FOLDERID_Recent,
892 CSIDL_Type_User,
893 RecentW,
894 MAKEINTRESOURCEW(IDS_RECENT)
895 },
896 { /* 0x09 - CSIDL_SENDTO */
897 &FOLDERID_SendTo,
898 CSIDL_Type_User,
899 SendToW,
900 MAKEINTRESOURCEW(IDS_SENDTO)
901 },
902 { /* 0x0a - CSIDL_BITBUCKET - Recycle Bin */
903 &FOLDERID_RecycleBinFolder,
904 CSIDL_Type_Disallowed,
905 NULL,
906 NULL,
907 },
908 { /* 0x0b - CSIDL_STARTMENU */
909 &FOLDERID_StartMenu,
910 CSIDL_Type_User,
911 Start_MenuW,
912 MAKEINTRESOURCEW(IDS_STARTMENU)
913 },
914 { /* 0x0c - CSIDL_MYDOCUMENTS */
915 &GUID_NULL,
916 CSIDL_Type_Disallowed, /* matches WinXP--can't get its path */
917 NULL,
918 NULL
919 },
920 { /* 0x0d - CSIDL_MYMUSIC */
921 &FOLDERID_Music,
922 CSIDL_Type_User,
923 My_MusicW,
924 MAKEINTRESOURCEW(IDS_MYMUSIC)
925 },
926 { /* 0x0e - CSIDL_MYVIDEO */
927 &FOLDERID_Videos,
928 CSIDL_Type_User,
929 My_VideoW,
930 MAKEINTRESOURCEW(IDS_MYVIDEO)
931 },
932 { /* 0x0f - unassigned */
933 &GUID_NULL,
934 CSIDL_Type_Disallowed,
935 NULL,
936 NULL,
937 },
938 { /* 0x10 - CSIDL_DESKTOPDIRECTORY */
939 &FOLDERID_Desktop,
940 CSIDL_Type_User,
941 DesktopW,
942 MAKEINTRESOURCEW(IDS_DESKTOPDIRECTORY)
943 },
944 { /* 0x11 - CSIDL_DRIVES */
945 &FOLDERID_ComputerFolder,
946 CSIDL_Type_Disallowed,
947 NULL,
948 NULL,
949 },
950 { /* 0x12 - CSIDL_NETWORK */
951 &FOLDERID_NetworkFolder,
952 CSIDL_Type_Disallowed,
953 NULL,
954 NULL,
955 },
956 { /* 0x13 - CSIDL_NETHOOD */
957 &FOLDERID_NetHood,
958 CSIDL_Type_User,
959 NetHoodW,
960 MAKEINTRESOURCEW(IDS_NETHOOD)
961 },
962 { /* 0x14 - CSIDL_FONTS */
963 &FOLDERID_Fonts,
964 CSIDL_Type_WindowsPath,
965 FontsW,
966 FontsW
967 },
968 { /* 0x15 - CSIDL_TEMPLATES */
969 &FOLDERID_Templates,
970 CSIDL_Type_User,
971 TemplatesW,
972 MAKEINTRESOURCEW(IDS_TEMPLATES)
973 },
974 { /* 0x16 - CSIDL_COMMON_STARTMENU */
975 &FOLDERID_CommonStartMenu,
976 CSIDL_Type_AllUsers,
977 Common_Start_MenuW,
978 MAKEINTRESOURCEW(IDS_STARTMENU)
979 },
980 { /* 0x17 - CSIDL_COMMON_PROGRAMS */
981 &FOLDERID_CommonPrograms,
982 CSIDL_Type_AllUsers,
983 Common_ProgramsW,
984 MAKEINTRESOURCEW(IDS_PROGRAMS)
985 },
986 { /* 0x18 - CSIDL_COMMON_STARTUP */
987 &FOLDERID_CommonStartup,
988 CSIDL_Type_AllUsers,
989 Common_StartUpW,
990 MAKEINTRESOURCEW(IDS_STARTUP)
991 },
992 { /* 0x19 - CSIDL_COMMON_DESKTOPDIRECTORY */
993 &FOLDERID_PublicDesktop,
994 CSIDL_Type_AllUsers,
995 Common_DesktopW,
996 MAKEINTRESOURCEW(IDS_DESKTOPDIRECTORY)
997 },
998 { /* 0x1a - CSIDL_APPDATA */
999 &FOLDERID_RoamingAppData,
1000 CSIDL_Type_User,
1001 AppDataW,
1002 MAKEINTRESOURCEW(IDS_APPDATA)
1003 },
1004 { /* 0x1b - CSIDL_PRINTHOOD */
1005 &FOLDERID_PrintHood,
1006 CSIDL_Type_User,
1007 PrintHoodW,
1008 MAKEINTRESOURCEW(IDS_PRINTHOOD)
1009 },
1010 { /* 0x1c - CSIDL_LOCAL_APPDATA */
1011 &FOLDERID_LocalAppData,
1012 CSIDL_Type_User,
1013 Local_AppDataW,
1014 MAKEINTRESOURCEW(IDS_LOCAL_APPDATA)
1015 },
1016 { /* 0x1d - CSIDL_ALTSTARTUP */
1017 &GUID_NULL,
1018 CSIDL_Type_NonExistent,
1019 NULL,
1020 NULL
1021 },
1022 { /* 0x1e - CSIDL_COMMON_ALTSTARTUP */
1023 &GUID_NULL,
1024 CSIDL_Type_NonExistent,
1025 NULL,
1026 NULL
1027 },
1028 { /* 0x1f - CSIDL_COMMON_FAVORITES */
1029 &FOLDERID_Favorites,
1030 CSIDL_Type_AllUsers,
1031 Common_FavoritesW,
1032 MAKEINTRESOURCEW(IDS_FAVORITES)
1033 },
1034 { /* 0x20 - CSIDL_INTERNET_CACHE */
1035 &FOLDERID_InternetCache,
1036 CSIDL_Type_User,
1037 CacheW,
1038 MAKEINTRESOURCEW(IDS_INTERNET_CACHE)
1039 },
1040 { /* 0x21 - CSIDL_COOKIES */
1041 &FOLDERID_Cookies,
1042 CSIDL_Type_User,
1043 CookiesW,
1044 MAKEINTRESOURCEW(IDS_COOKIES)
1045 },
1046 { /* 0x22 - CSIDL_HISTORY */
1047 &FOLDERID_History,
1048 CSIDL_Type_User,
1049 HistoryW,
1050 MAKEINTRESOURCEW(IDS_HISTORY)
1051 },
1052 { /* 0x23 - CSIDL_COMMON_APPDATA */
1053 &FOLDERID_ProgramData,
1054 CSIDL_Type_AllUsers,
1055 Common_AppDataW,
1056 MAKEINTRESOURCEW(IDS_APPDATA)
1057 },
1058 { /* 0x24 - CSIDL_WINDOWS */
1059 &FOLDERID_Windows,
1060 CSIDL_Type_WindowsPath,
1061 NULL,
1062 NULL
1063 },
1064 { /* 0x25 - CSIDL_SYSTEM */
1065 &FOLDERID_System,
1066 CSIDL_Type_SystemPath,
1067 NULL,
1068 NULL
1069 },
1070 { /* 0x26 - CSIDL_PROGRAM_FILES */
1071 &FOLDERID_ProgramFiles,
1072 CSIDL_Type_CurrVer,
1073 ProgramFilesDirW,
1074 MAKEINTRESOURCEW(IDS_PROGRAM_FILES)
1075 },
1076 { /* 0x27 - CSIDL_MYPICTURES */
1077 &FOLDERID_Pictures,
1078 CSIDL_Type_User,
1079 My_PicturesW,
1080 MAKEINTRESOURCEW(IDS_MYPICTURES)
1081 },
1082 { /* 0x28 - CSIDL_PROFILE */
1083 &FOLDERID_Profile,
1084 CSIDL_Type_User,
1085 NULL,
1086 NULL
1087 },
1088 { /* 0x29 - CSIDL_SYSTEMX86 */
1089 &FOLDERID_SystemX86,
1090 CSIDL_Type_SystemX86Path,
1091 NULL,
1092 NULL
1093 },
1094 { /* 0x2a - CSIDL_PROGRAM_FILESX86 */
1095 &FOLDERID_ProgramFilesX86,
1096 CSIDL_Type_CurrVer,
1097 ProgramFilesDirX86W,
1098 MAKEINTRESOURCEW(IDS_PROGRAM_FILESX86)
1099 },
1100 { /* 0x2b - CSIDL_PROGRAM_FILES_COMMON */
1101 &FOLDERID_ProgramFilesCommon,
1102 CSIDL_Type_CurrVer,
1103 CommonFilesDirW,
1104 MAKEINTRESOURCEW(IDS_PROGRAM_FILES_COMMON)
1105 },
1106 { /* 0x2c - CSIDL_PROGRAM_FILES_COMMONX86 */
1107 &FOLDERID_ProgramFilesCommonX86,
1108 CSIDL_Type_CurrVer,
1109 CommonFilesDirX86W,
1110 MAKEINTRESOURCEW(IDS_PROGRAM_FILES_COMMONX86)
1111 },
1112 { /* 0x2d - CSIDL_COMMON_TEMPLATES */
1113 &FOLDERID_CommonTemplates,
1114 CSIDL_Type_AllUsers,
1115 Common_TemplatesW,
1116 MAKEINTRESOURCEW(IDS_TEMPLATES)
1117 },
1118 { /* 0x2e - CSIDL_COMMON_DOCUMENTS */
1119 &FOLDERID_PublicDocuments,
1120 CSIDL_Type_AllUsers,
1121 Common_DocumentsW,
1122 MAKEINTRESOURCEW(IDS_COMMON_DOCUMENTS)
1123 },
1124 { /* 0x2f - CSIDL_COMMON_ADMINTOOLS */
1125 &FOLDERID_CommonAdminTools,
1126 CSIDL_Type_AllUsers,
1127 Common_Administrative_ToolsW,
1128 MAKEINTRESOURCEW(IDS_ADMINTOOLS)
1129 },
1130 { /* 0x30 - CSIDL_ADMINTOOLS */
1131 &FOLDERID_AdminTools,
1132 CSIDL_Type_User,
1133 Administrative_ToolsW,
1134 MAKEINTRESOURCEW(IDS_ADMINTOOLS)
1135 },
1136 { /* 0x31 - CSIDL_CONNECTIONS */
1137 &FOLDERID_ConnectionsFolder,
1138 CSIDL_Type_Disallowed,
1139 NULL,
1140 NULL
1141 },
1142 { /* 0x32 - unassigned */
1143 &GUID_NULL,
1144 CSIDL_Type_Disallowed,
1145 NULL,
1146 NULL
1147 },
1148 { /* 0x33 - unassigned */
1149 &GUID_NULL,
1150 CSIDL_Type_Disallowed,
1151 NULL,
1152 NULL
1153 },
1154 { /* 0x34 - unassigned */
1155 &GUID_NULL,
1156 CSIDL_Type_Disallowed,
1157 NULL,
1158 NULL
1159 },
1160 { /* 0x35 - CSIDL_COMMON_MUSIC */
1161 &FOLDERID_PublicMusic,
1162 CSIDL_Type_AllUsers,
1163 CommonMusicW,
1164 MAKEINTRESOURCEW(IDS_COMMON_MUSIC)
1165 },
1166 { /* 0x36 - CSIDL_COMMON_PICTURES */
1167 &FOLDERID_PublicPictures,
1168 CSIDL_Type_AllUsers,
1169 CommonPicturesW,
1170 MAKEINTRESOURCEW(IDS_COMMON_PICTURES)
1171 },
1172 { /* 0x37 - CSIDL_COMMON_VIDEO */
1173 &FOLDERID_PublicVideos,
1174 CSIDL_Type_AllUsers,
1175 CommonVideoW,
1176 MAKEINTRESOURCEW(IDS_COMMON_VIDEO)
1177 },
1178 { /* 0x38 - CSIDL_RESOURCES */
1179 &FOLDERID_ResourceDir,
1180 CSIDL_Type_WindowsPath,
1181 NULL,
1182 ResourcesW
1183 },
1184 { /* 0x39 - CSIDL_RESOURCES_LOCALIZED */
1185 &FOLDERID_LocalizedResourcesDir,
1186 CSIDL_Type_NonExistent,
1187 NULL,
1188 NULL
1189 },
1190 { /* 0x3a - CSIDL_COMMON_OEM_LINKS */
1191 &FOLDERID_CommonOEMLinks,
1192 CSIDL_Type_AllUsers,
1193 NULL,
1194 MAKEINTRESOURCEW(IDS_COMMON_OEM_LINKS)
1195 },
1196 { /* 0x3b - CSIDL_CDBURN_AREA */
1197 &FOLDERID_CDBurning,
1198 CSIDL_Type_User,
1199 CD_BurningW,
1200 MAKEINTRESOURCEW(IDS_CDBURN_AREA)
1201 },
1202 { /* 0x3c unassigned */
1203 &GUID_NULL,
1204 CSIDL_Type_Disallowed,
1205 NULL,
1206 NULL
1207 },
1208 { /* 0x3d - CSIDL_COMPUTERSNEARME */
1209 &GUID_NULL,
1210 CSIDL_Type_Disallowed, /* FIXME */
1211 NULL,
1212 NULL
1213 },
1214 { /* 0x3e - CSIDL_PROFILES */
1215 &GUID_NULL,
1216 CSIDL_Type_Disallowed, /* oddly, this matches WinXP */
1217 NULL,
1218 NULL
1219 },
1220 { /* 0x3f */
1221 &FOLDERID_AddNewPrograms,
1222 CSIDL_Type_Disallowed,
1223 NULL,
1224 NULL
1225 },
1226 { /* 0x40 */
1227 &FOLDERID_AppUpdates,
1228 CSIDL_Type_Disallowed,
1229 NULL,
1230 NULL
1231 },
1232 { /* 0x41 */
1233 &FOLDERID_ChangeRemovePrograms,
1234 CSIDL_Type_Disallowed,
1235 NULL,
1236 NULL
1237 },
1238 { /* 0x42 */
1239 &FOLDERID_ConflictFolder,
1240 CSIDL_Type_Disallowed,
1241 NULL,
1242 NULL
1243 },
1244 { /* 0x43 */
1245 &FOLDERID_Contacts,
1246 CSIDL_Type_User,
1247 ContactsW,
1248 MAKEINTRESOURCEW(IDS_CONTACTS)
1249 },
1250 { /* 0x44 */
1251 &FOLDERID_DeviceMetadataStore,
1252 CSIDL_Type_Disallowed, /* FIXME */
1253 NULL,
1254 NULL
1255 },
1256 { /* 0x45 */
1257 &FOLDERID_Documents,
1258 CSIDL_Type_User,
1259 NULL,
1260 MAKEINTRESOURCEW(IDS_DOCUMENTS)
1261 },
1262 { /* 0x46 */
1263 &FOLDERID_DocumentsLibrary,
1264 CSIDL_Type_Disallowed, /* FIXME */
1265 NULL,
1266 NULL
1267 },
1268 { /* 0x47 */
1269 &FOLDERID_Downloads,
1270 CSIDL_Type_User,
1271 NULL,
1272 MAKEINTRESOURCEW(IDS_DOWNLOADS)
1273 },
1274 { /* 0x48 */
1275 &FOLDERID_Games,
1276 CSIDL_Type_Disallowed,
1277 NULL,
1278 NULL
1279 },
1280 { /* 0x49 */
1281 &FOLDERID_GameTasks,
1282 CSIDL_Type_Disallowed, /* FIXME */
1283 NULL,
1284 NULL
1285 },
1286 { /* 0x4a */
1287 &FOLDERID_HomeGroup,
1288 CSIDL_Type_Disallowed,
1289 NULL,
1290 NULL
1291 },
1292 { /* 0x4b */
1293 &FOLDERID_ImplicitAppShortcuts,
1294 CSIDL_Type_Disallowed, /* FIXME */
1295 NULL,
1296 NULL
1297 },
1298 { /* 0x4c */
1299 &FOLDERID_Libraries,
1300 CSIDL_Type_Disallowed, /* FIXME */
1301 NULL,
1302 NULL
1303 },
1304 { /* 0x4d */
1305 &FOLDERID_Links,
1306 CSIDL_Type_User,
1307 NULL,
1308 MAKEINTRESOURCEW(IDS_LINKS)
1309 },
1310 { /* 0x4e */
1311 &FOLDERID_LocalAppDataLow,
1312 CSIDL_Type_User,
1313 NULL,
1314 MAKEINTRESOURCEW(IDS_LOCAL_APPDATA_LOW)
1315 },
1316 { /* 0x4f */
1317 &FOLDERID_MusicLibrary,
1318 CSIDL_Type_Disallowed, /* FIXME */
1319 NULL,
1320 NULL
1321 },
1322 { /* 0x50 */
1323 &FOLDERID_OriginalImages,
1324 CSIDL_Type_Disallowed, /* FIXME */
1325 NULL,
1326 NULL
1327 },
1328 { /* 0x51 */
1329 &FOLDERID_PhotoAlbums,
1330 CSIDL_Type_User,
1331 NULL,
1332 MAKEINTRESOURCEW(IDS_PHOTO_ALBUMS)
1333 },
1334 { /* 0x52 */
1335 &FOLDERID_PicturesLibrary,
1336 CSIDL_Type_Disallowed, /* FIXME */
1337 NULL,
1338 NULL
1339 },
1340 { /* 0x53 */
1341 &FOLDERID_Playlists,
1342 CSIDL_Type_User,
1343 NULL,
1344 MAKEINTRESOURCEW(IDS_PLAYLISTS)
1345 },
1346 { /* 0x54 */
1347 &FOLDERID_ProgramFilesX64,
1348 CSIDL_Type_NonExistent,
1349 NULL,
1350 NULL
1351 },
1352 { /* 0x55 */
1353 &FOLDERID_ProgramFilesCommonX64,
1354 CSIDL_Type_NonExistent,
1355 NULL,
1356 NULL
1357 },
1358 { /* 0x56 */
1359 &FOLDERID_Public,
1360 CSIDL_Type_CurrVer, /* FIXME */
1361 NULL,
1362 UsersPublicW
1363 },
1364 { /* 0x57 */
1365 &FOLDERID_PublicDownloads,
1366 CSIDL_Type_AllUsers,
1367 NULL,
1368 MAKEINTRESOURCEW(IDS_PUBLIC_DOWNLOADS)
1369 },
1370 { /* 0x58 */
1371 &FOLDERID_PublicGameTasks,
1372 CSIDL_Type_AllUsers,
1373 NULL,
1374 MAKEINTRESOURCEW(IDS_PUBLIC_GAME_TASKS)
1375 },
1376 { /* 0x59 */
1377 &FOLDERID_PublicLibraries,
1378 CSIDL_Type_AllUsers,
1379 NULL,
1380 MAKEINTRESOURCEW(IDS_PUBLIC_LIBRARIES)
1381 },
1382 { /* 0x5a */
1383 &FOLDERID_PublicRingtones,
1384 CSIDL_Type_AllUsers,
1385 NULL,
1386 MAKEINTRESOURCEW(IDS_PUBLIC_RINGTONES)
1387 },
1388 { /* 0x5b */
1389 &FOLDERID_QuickLaunch,
1390 CSIDL_Type_Disallowed, /* FIXME */
1391 NULL,
1392 NULL
1393 },
1394 { /* 0x5c */
1395 &FOLDERID_RecordedTVLibrary,
1396 CSIDL_Type_Disallowed, /* FIXME */
1397 NULL,
1398 NULL
1399 },
1400 { /* 0x5d */
1401 &FOLDERID_Ringtones,
1402 CSIDL_Type_Disallowed, /* FIXME */
1403 NULL,
1404 NULL
1405 },
1406 { /* 0x5e */
1407 &FOLDERID_SampleMusic,
1408 CSIDL_Type_AllUsers,
1409 NULL,
1410 MAKEINTRESOURCEW(IDS_SAMPLE_MUSIC)
1411 },
1412 { /* 0x5f */
1413 &FOLDERID_SamplePictures,
1414 CSIDL_Type_AllUsers,
1415 NULL,
1416 MAKEINTRESOURCEW(IDS_SAMPLE_PICTURES)
1417 },
1418 { /* 0x60 */
1419 &FOLDERID_SamplePlaylists,
1420 CSIDL_Type_AllUsers,
1421 NULL,
1422 MAKEINTRESOURCEW(IDS_SAMPLE_PLAYLISTS)
1423 },
1424 { /* 0x61 */
1425 &FOLDERID_SampleVideos,
1426 CSIDL_Type_AllUsers,
1427 NULL,
1428 MAKEINTRESOURCEW(IDS_SAMPLE_VIDEOS)
1429 },
1430 { /* 0x62 */
1431 &FOLDERID_SavedGames,
1432 CSIDL_Type_User,
1433 NULL,
1434 MAKEINTRESOURCEW(IDS_SAVED_GAMES)
1435 },
1436 { /* 0x63 */
1437 &FOLDERID_SavedSearches,
1438 CSIDL_Type_User,
1439 NULL,
1440 MAKEINTRESOURCEW(IDS_SAVED_SEARCHES)
1441 },
1442 { /* 0x64 */
1443 &FOLDERID_SEARCH_CSC,
1444 CSIDL_Type_Disallowed,
1445 NULL,
1446 NULL
1447 },
1448 { /* 0x65 */
1449 &FOLDERID_SEARCH_MAPI,
1450 CSIDL_Type_Disallowed,
1451 NULL,
1452 NULL
1453 },
1454 { /* 0x66 */
1455 &FOLDERID_SearchHome,
1456 CSIDL_Type_Disallowed,
1457 NULL,
1458 NULL
1459 },
1460 { /* 0x67 */
1461 &FOLDERID_SidebarDefaultParts,
1462 CSIDL_Type_Disallowed, /* FIXME */
1463 NULL,
1464 NULL
1465 },
1466 { /* 0x68 */
1467 &FOLDERID_SidebarParts,
1468 CSIDL_Type_Disallowed, /* FIXME */
1469 NULL,
1470 NULL
1471 },
1472 { /* 0x69 */
1473 &FOLDERID_SyncManagerFolder,
1474 CSIDL_Type_Disallowed,
1475 NULL,
1476 NULL
1477 },
1478 { /* 0x6a */
1479 &FOLDERID_SyncResultsFolder,
1480 CSIDL_Type_Disallowed,
1481 NULL,
1482 NULL
1483 },
1484 { /* 0x6b */
1485 &FOLDERID_SyncSetupFolder,
1486 CSIDL_Type_Disallowed,
1487 NULL,
1488 NULL
1489 },
1490 { /* 0x6c */
1491 &FOLDERID_UserPinned,
1492 CSIDL_Type_Disallowed, /* FIXME */
1493 NULL,
1494 NULL
1495 },
1496 { /* 0x6d */
1497 &FOLDERID_UserProfiles,
1498 CSIDL_Type_CurrVer,
1499 UsersW,
1500 MAKEINTRESOURCEW(IDS_USER_PROFILES)
1501 },
1502 { /* 0x6e */
1503 &FOLDERID_UserProgramFiles,
1504 CSIDL_Type_Disallowed, /* FIXME */
1505 NULL,
1506 NULL
1507 },
1508 { /* 0x6f */
1509 &FOLDERID_UserProgramFilesCommon,
1510 CSIDL_Type_Disallowed, /* FIXME */
1511 NULL,
1512 NULL
1513 },
1514 { /* 0x70 */
1515 &FOLDERID_UsersFiles,
1516 CSIDL_Type_Disallowed,
1517 NULL,
1518 NULL
1519 },
1520 { /* 0x71 */
1521 &FOLDERID_UsersLibraries,
1522 CSIDL_Type_Disallowed,
1523 NULL,
1524 NULL
1525 },
1526 { /* 0x72 */
1527 &FOLDERID_VideosLibrary,
1528 CSIDL_Type_Disallowed, /* FIXME */
1529 NULL,
1530 NULL
1531 }
1532 };
1533
1534 static HRESULT _SHExpandEnvironmentStrings(LPCWSTR szSrc, LPWSTR szDest);
1535
1536 /* Gets the value named value from the registry key
1537 * rootKey\Software\Microsoft\Windows\CurrentVersion\Explorer\User Shell Folders
1538 * (or from rootKey\userPrefix\... if userPrefix is not NULL) into path, which
1539 * is assumed to be MAX_PATH WCHARs in length.
1540 * If it exists, expands the value and writes the expanded value to
1541 * rootKey\Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders
1542 * Returns successful error code if the value was retrieved from the registry,
1543 * and a failure otherwise.
1544 */
1545 static HRESULT _SHGetUserShellFolderPath(HKEY rootKey, LPCWSTR userPrefix,
1546 LPCWSTR value, LPWSTR path)
1547 {
1548 HRESULT hr;
1549 WCHAR shellFolderPath[MAX_PATH], userShellFolderPath[MAX_PATH];
1550 LPCWSTR pShellFolderPath, pUserShellFolderPath;
1551 DWORD dwType, dwPathLen = MAX_PATH;
1552 HKEY userShellFolderKey, shellFolderKey;
1553
1554 TRACE("%p,%s,%s,%p\n",rootKey, debugstr_w(userPrefix), debugstr_w(value),
1555 path);
1556
1557 if (userPrefix)
1558 {
1559 strcpyW(shellFolderPath, userPrefix);
1560 PathAddBackslashW(shellFolderPath);
1561 strcatW(shellFolderPath, szSHFolders);
1562 pShellFolderPath = shellFolderPath;
1563 strcpyW(userShellFolderPath, userPrefix);
1564 PathAddBackslashW(userShellFolderPath);
1565 strcatW(userShellFolderPath, szSHUserFolders);
1566 pUserShellFolderPath = userShellFolderPath;
1567 }
1568 else
1569 {
1570 pUserShellFolderPath = szSHUserFolders;
1571 pShellFolderPath = szSHFolders;
1572 }
1573
1574 if (RegCreateKeyW(rootKey, pShellFolderPath, &shellFolderKey))
1575 {
1576 TRACE("Failed to create %s\n", debugstr_w(pShellFolderPath));
1577 return E_FAIL;
1578 }
1579 if (RegCreateKeyW(rootKey, pUserShellFolderPath, &userShellFolderKey))
1580 {
1581 TRACE("Failed to create %s\n",
1582 debugstr_w(pUserShellFolderPath));
1583 RegCloseKey(shellFolderKey);
1584 return E_FAIL;
1585 }
1586
1587 if (!RegQueryValueExW(userShellFolderKey, value, NULL, &dwType,
1588 (LPBYTE)path, &dwPathLen) && (dwType == REG_EXPAND_SZ || dwType == REG_SZ))
1589 {
1590 LONG ret;
1591
1592 path[dwPathLen / sizeof(WCHAR)] = '\0';
1593 if (dwType == REG_EXPAND_SZ && path[0] == '%')
1594 {
1595 WCHAR szTemp[MAX_PATH];
1596
1597 _SHExpandEnvironmentStrings(path, szTemp);
1598 lstrcpynW(path, szTemp, MAX_PATH);
1599 }
1600 ret = RegSetValueExW(shellFolderKey, value, 0, REG_SZ, (LPBYTE)path,
1601 (strlenW(path) + 1) * sizeof(WCHAR));
1602 if (ret != ERROR_SUCCESS)
1603 hr = HRESULT_FROM_WIN32(ret);
1604 else
1605 hr = S_OK;
1606 }
1607 else
1608 hr = E_FAIL;
1609 RegCloseKey(shellFolderKey);
1610 RegCloseKey(userShellFolderKey);
1611 TRACE("returning 0x%08x\n", hr);
1612 return hr;
1613 }
1614
1615 /* Gets a 'semi-expanded' default value of the CSIDL with index folder into
1616 * pszPath, based on the entries in CSIDL_Data. By semi-expanded, I mean:
1617 * - The entry's szDefaultPath may be either a string value or an integer
1618 * resource identifier. In the latter case, the string value of the resource
1619 * is written.
1620 * - Depending on the entry's type, the path may begin with an (unexpanded)
1621 * environment variable name. The caller is responsible for expanding
1622 * environment strings if so desired.
1623 * The types that are prepended with environment variables are:
1624 * CSIDL_Type_User: %USERPROFILE%
1625 * CSIDL_Type_AllUsers: %ALLUSERSPROFILE%
1626 * CSIDL_Type_CurrVer: %SystemDrive%
1627 * (Others might make sense too, but as yet are unneeded.)
1628 */
1629 static HRESULT _SHGetDefaultValue(BYTE folder, LPWSTR pszPath)
1630 {
1631 HRESULT hr;
1632 WCHAR resourcePath[MAX_PATH];
1633 LPCWSTR pDefaultPath = NULL;
1634
1635 TRACE("0x%02x,%p\n", folder, pszPath);
1636
1637 if (folder >= sizeof(CSIDL_Data) / sizeof(CSIDL_Data[0]))
1638 return E_INVALIDARG;
1639 if (!pszPath)
1640 return E_INVALIDARG;
1641
1642 if (!is_win64)
1643 {
1644 BOOL is_wow64;
1645
1646 switch (folder)
1647 {
1648 case CSIDL_PROGRAM_FILES:
1649 case CSIDL_PROGRAM_FILESX86:
1650 IsWow64Process( GetCurrentProcess(), &is_wow64 );
1651 folder = is_wow64 ? CSIDL_PROGRAM_FILESX86 : CSIDL_PROGRAM_FILES;
1652 break;
1653 case CSIDL_PROGRAM_FILES_COMMON:
1654 case CSIDL_PROGRAM_FILES_COMMONX86:
1655 IsWow64Process( GetCurrentProcess(), &is_wow64 );
1656 folder = is_wow64 ? CSIDL_PROGRAM_FILES_COMMONX86 : CSIDL_PROGRAM_FILES_COMMON;
1657 break;
1658 }
1659 }
1660
1661 if (CSIDL_Data[folder].szDefaultPath &&
1662 IS_INTRESOURCE(CSIDL_Data[folder].szDefaultPath))
1663 {
1664 if (LoadStringW(shell32_hInstance,
1665 LOWORD(CSIDL_Data[folder].szDefaultPath), resourcePath, MAX_PATH))
1666 {
1667 hr = S_OK;
1668 pDefaultPath = resourcePath;
1669 }
1670 else
1671 {
1672 FIXME("(%d,%s), LoadString failed, missing translation?\n", folder,
1673 debugstr_w(pszPath));
1674 hr = E_FAIL;
1675 }
1676 }
1677 else
1678 {
1679 hr = S_OK;
1680 pDefaultPath = CSIDL_Data[folder].szDefaultPath;
1681 }
1682 if (SUCCEEDED(hr))
1683 {
1684 switch (CSIDL_Data[folder].type)
1685 {
1686 case CSIDL_Type_User:
1687 strcpyW(pszPath, UserProfileW);
1688 break;
1689 case CSIDL_Type_AllUsers:
1690 strcpyW(pszPath, AllUsersProfileW);
1691 break;
1692 case CSIDL_Type_CurrVer:
1693 strcpyW(pszPath, SystemDriveW);
1694 break;
1695 default:
1696 ; /* no corresponding env. var, do nothing */
1697 }
1698 if (pDefaultPath)
1699 {
1700 PathAddBackslashW(pszPath);
1701 strcatW(pszPath, pDefaultPath);
1702 }
1703 }
1704 TRACE("returning 0x%08x\n", hr);
1705 return hr;
1706 }
1707
1708 /* Gets the (unexpanded) value of the folder with index folder into pszPath.
1709 * The folder's type is assumed to be CSIDL_Type_CurrVer. Its default value
1710 * can be overridden in the HKLM\\szCurrentVersion key.
1711 * If dwFlags has SHGFP_TYPE_DEFAULT set or if the value isn't overridden in
1712 * the registry, uses _SHGetDefaultValue to get the value.
1713 */
1714 static HRESULT _SHGetCurrentVersionPath(DWORD dwFlags, BYTE folder,
1715 LPWSTR pszPath)
1716 {
1717 HRESULT hr;
1718
1719 TRACE("0x%08x,0x%02x,%p\n", dwFlags, folder, pszPath);
1720
1721 if (folder >= sizeof(CSIDL_Data) / sizeof(CSIDL_Data[0]))
1722 return E_INVALIDARG;
1723 if (CSIDL_Data[folder].type != CSIDL_Type_CurrVer)
1724 return E_INVALIDARG;
1725 if (!pszPath)
1726 return E_INVALIDARG;
1727
1728 if (dwFlags & SHGFP_TYPE_DEFAULT)
1729 hr = _SHGetDefaultValue(folder, pszPath);
1730 else
1731 {
1732 HKEY hKey;
1733
1734 if (RegCreateKeyW(HKEY_LOCAL_MACHINE, szCurrentVersion, &hKey))
1735 hr = E_FAIL;
1736 else
1737 {
1738 DWORD dwType, dwPathLen = MAX_PATH * sizeof(WCHAR);
1739
1740 if (RegQueryValueExW(hKey, CSIDL_Data[folder].szValueName, NULL,
1741 &dwType, (LPBYTE)pszPath, &dwPathLen) ||
1742 (dwType != REG_SZ && dwType != REG_EXPAND_SZ))
1743 {
1744 hr = _SHGetDefaultValue(folder, pszPath);
1745 dwType = REG_EXPAND_SZ;
1746 switch (folder)
1747 {
1748 case CSIDL_PROGRAM_FILESX86:
1749 case CSIDL_PROGRAM_FILES_COMMONX86:
1750 /* these two should never be set on 32-bit setups */
1751 if (!is_win64)
1752 {
1753 BOOL is_wow64;
1754 IsWow64Process( GetCurrentProcess(), &is_wow64 );
1755 if (!is_wow64) break;
1756 }
1757 /* fall through */
1758 default:
1759 RegSetValueExW(hKey, CSIDL_Data[folder].szValueName, 0, dwType,
1760 (LPBYTE)pszPath, (strlenW(pszPath)+1)*sizeof(WCHAR));
1761 }
1762 }
1763 else
1764 {
1765 pszPath[dwPathLen / sizeof(WCHAR)] = '\0';
1766 hr = S_OK;
1767 }
1768 RegCloseKey(hKey);
1769 }
1770 }
1771 TRACE("returning 0x%08x (output path is %s)\n", hr, debugstr_w(pszPath));
1772 return hr;
1773 }
1774
1775 static LPWSTR _GetUserSidStringFromToken(HANDLE Token)
1776 {
1777 char InfoBuffer[64];
1778 PTOKEN_USER UserInfo;
1779 DWORD InfoSize;
1780 LPWSTR SidStr;
1781
1782 UserInfo = (PTOKEN_USER) InfoBuffer;
1783 if (! GetTokenInformation(Token, TokenUser, InfoBuffer, sizeof(InfoBuffer),
1784 &InfoSize))
1785 {
1786 if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
1787 return NULL;
1788 UserInfo = HeapAlloc(GetProcessHeap(), 0, InfoSize);
1789 if (UserInfo == NULL)
1790 return NULL;
1791 if (! GetTokenInformation(Token, TokenUser, UserInfo, InfoSize,
1792 &InfoSize))
1793 {
1794 HeapFree(GetProcessHeap(), 0, UserInfo);
1795 return NULL;
1796 }
1797 }
1798
1799 if (! ConvertSidToStringSidW(UserInfo->User.Sid, &SidStr))
1800 SidStr = NULL;
1801
1802 if (UserInfo != (PTOKEN_USER) InfoBuffer)
1803 HeapFree(GetProcessHeap(), 0, UserInfo);
1804
1805 return SidStr;
1806 }
1807
1808 /* Gets the user's path (unexpanded) for the CSIDL with index folder:
1809 * If SHGFP_TYPE_DEFAULT is set, calls _SHGetDefaultValue for it. Otherwise
1810 * calls _SHGetUserShellFolderPath for it. Where it looks depends on hToken:
1811 * - if hToken is -1, looks in HKEY_USERS\.Default
1812 * - otherwise looks first in HKEY_CURRENT_USER, followed by HKEY_LOCAL_MACHINE
1813 * if HKEY_CURRENT_USER doesn't contain any entries. If both fail, finally
1814 * calls _SHGetDefaultValue for it.
1815 */
1816 static HRESULT _SHGetUserProfilePath(HANDLE hToken, DWORD dwFlags, BYTE folder,
1817 LPWSTR pszPath)
1818 {
1819 HRESULT hr;
1820
1821 TRACE("%p,0x%08x,0x%02x,%p\n", hToken, dwFlags, folder, pszPath);
1822
1823 if (folder >= sizeof(CSIDL_Data) / sizeof(CSIDL_Data[0]))
1824 return E_INVALIDARG;
1825 if (CSIDL_Data[folder].type != CSIDL_Type_User)
1826 return E_INVALIDARG;
1827 if (!pszPath)
1828 return E_INVALIDARG;
1829
1830 if (dwFlags & SHGFP_TYPE_DEFAULT)
1831 {
1832 if (hToken != NULL && hToken != (HANDLE)-1)
1833 {
1834 FIXME("unsupported for user other than current or default\n");
1835 return E_FAIL;
1836 }
1837 hr = _SHGetDefaultValue(folder, pszPath);
1838 }
1839 else
1840 {
1841 LPCWSTR userPrefix = NULL;
1842 HKEY hRootKey;
1843
1844 if (hToken == (HANDLE)-1)
1845 {
1846 hRootKey = HKEY_USERS;
1847 userPrefix = DefaultW;
1848 }
1849 else if (hToken == NULL)
1850 hRootKey = HKEY_CURRENT_USER;
1851 else
1852 {
1853 hRootKey = HKEY_USERS;
1854 userPrefix = _GetUserSidStringFromToken(hToken);
1855 if (userPrefix == NULL)
1856 {
1857 hr = E_FAIL;
1858 goto error;
1859 }
1860 }
1861 hr = _SHGetUserShellFolderPath(hRootKey, userPrefix,
1862 CSIDL_Data[folder].szValueName, pszPath);
1863 if (FAILED(hr) && hRootKey != HKEY_LOCAL_MACHINE)
1864 hr = _SHGetUserShellFolderPath(HKEY_LOCAL_MACHINE, NULL,
1865 CSIDL_Data[folder].szValueName, pszPath);
1866 if (FAILED(hr))
1867 hr = _SHGetDefaultValue(folder, pszPath);
1868 if (userPrefix != NULL && userPrefix != DefaultW)
1869 LocalFree((HLOCAL) userPrefix);
1870 }
1871 error:
1872 TRACE("returning 0x%08x (output path is %s)\n", hr, debugstr_w(pszPath));
1873 return hr;
1874 }
1875
1876 /* Gets the (unexpanded) path for the CSIDL with index folder. If dwFlags has
1877 * SHGFP_TYPE_DEFAULT set, calls _SHGetDefaultValue. Otherwise calls
1878 * _SHGetUserShellFolderPath for it, looking only in HKEY_LOCAL_MACHINE.
1879 * If this fails, falls back to _SHGetDefaultValue.
1880 */
1881 static HRESULT _SHGetAllUsersProfilePath(DWORD dwFlags, BYTE folder,
1882 LPWSTR pszPath)
1883 {
1884 HRESULT hr;
1885
1886 TRACE("0x%08x,0x%02x,%p\n", dwFlags, folder, pszPath);
1887
1888 if (folder >= sizeof(CSIDL_Data) / sizeof(CSIDL_Data[0]))
1889 return E_INVALIDARG;
1890 if (CSIDL_Data[folder].type != CSIDL_Type_AllUsers)
1891 return E_INVALIDARG;
1892 if (!pszPath)
1893 return E_INVALIDARG;
1894
1895 if (dwFlags & SHGFP_TYPE_DEFAULT)
1896 hr = _SHGetDefaultValue(folder, pszPath);
1897 else
1898 {
1899 hr = _SHGetUserShellFolderPath(HKEY_LOCAL_MACHINE, NULL,
1900 CSIDL_Data[folder].szValueName, pszPath);
1901 if (FAILED(hr))
1902 hr = _SHGetDefaultValue(folder, pszPath);
1903 }
1904 TRACE("returning 0x%08x (output path is %s)\n", hr, debugstr_w(pszPath));
1905 return hr;
1906 }
1907
1908 static HRESULT _SHOpenProfilesKey(PHKEY pKey)
1909 {
1910 LONG lRet;
1911 DWORD disp;
1912
1913 lRet = RegCreateKeyExW(HKEY_LOCAL_MACHINE, ProfileListW, 0, NULL, 0,
1914 KEY_ALL_ACCESS, NULL, pKey, &disp);
1915 return HRESULT_FROM_WIN32(lRet);
1916 }
1917
1918 /* Reads the value named szValueName from the key profilesKey (assumed to be
1919 * opened by _SHOpenProfilesKey) into szValue, which is assumed to be MAX_PATH
1920 * WCHARs in length. If it doesn't exist, returns szDefault (and saves
1921 * szDefault to the registry).
1922 */
1923 static HRESULT _SHGetProfilesValue(HKEY profilesKey, LPCWSTR szValueName,
1924 LPWSTR szValue, LPCWSTR szDefault)
1925 {
1926 HRESULT hr;
1927 DWORD type, dwPathLen = MAX_PATH * sizeof(WCHAR);
1928 LONG lRet;
1929
1930 TRACE("%p,%s,%p,%s\n", profilesKey, debugstr_w(szValueName), szValue,
1931 debugstr_w(szDefault));
1932 lRet = RegQueryValueExW(profilesKey, szValueName, NULL, &type,
1933 (LPBYTE)szValue, &dwPathLen);
1934 if (!lRet && (type == REG_SZ || type == REG_EXPAND_SZ) && dwPathLen
1935 && *szValue)
1936 {
1937 dwPathLen /= sizeof(WCHAR);
1938 szValue[dwPathLen] = '\0';
1939 hr = S_OK;
1940 }
1941 else
1942 {
1943 /* Missing or invalid value, set a default */
1944 lstrcpynW(szValue, szDefault, MAX_PATH);
1945 TRACE("Setting missing value %s to %s\n", debugstr_w(szValueName),
1946 debugstr_w(szValue));
1947 lRet = RegSetValueExW(profilesKey, szValueName, 0, REG_EXPAND_SZ,
1948 (LPBYTE)szValue,
1949 (strlenW(szValue) + 1) * sizeof(WCHAR));
1950 if (lRet)
1951 hr = HRESULT_FROM_WIN32(lRet);
1952 else
1953 hr = S_OK;
1954 }
1955 TRACE("returning 0x%08x (output value is %s)\n", hr, debugstr_w(szValue));
1956 return hr;
1957 }
1958
1959 /* Attempts to expand environment variables from szSrc into szDest, which is
1960 * assumed to be MAX_PATH characters in length. Before referring to the
1961 * environment, handles a few variables directly, because the environment
1962 * variables may not be set when this is called (as during Wine's installation
1963 * when default values are being written to the registry).
1964 * The directly handled environment variables, and their source, are:
1965 * - ALLUSERSPROFILE, USERPROFILE: reads from the registry
1966 * - SystemDrive: uses GetSystemDirectoryW and uses the drive portion of its
1967 * path
1968 * If one of the directly handled environment variables is expanded, only
1969 * expands a single variable, and only in the beginning of szSrc.
1970 */
1971 static HRESULT _SHExpandEnvironmentStrings(LPCWSTR szSrc, LPWSTR szDest)
1972 {
1973 HRESULT hr;
1974 WCHAR szTemp[MAX_PATH], szProfilesPrefix[MAX_PATH] = { 0 };
1975 HKEY key = NULL;
1976
1977 TRACE("%s, %p\n", debugstr_w(szSrc), szDest);
1978
1979 if (!szSrc || !szDest) return E_INVALIDARG;
1980
1981 /* short-circuit if there's nothing to expand */
1982 if (szSrc[0] != '%')
1983 {
1984 strcpyW(szDest, szSrc);
1985 hr = S_OK;
1986 goto end;
1987 }
1988 /* Get the profile prefix, we'll probably be needing it */
1989 hr = _SHOpenProfilesKey(&key);
1990 if (SUCCEEDED(hr))
1991 {
1992 WCHAR def_val[MAX_PATH];
1993
1994 /* get the system drive */
1995 GetSystemDirectoryW(def_val, MAX_PATH);
1996 if (def_val[1] == ':') strcpyW( def_val + 3, szDefaultProfileDirW );
1997 else FIXME("non-drive system paths unsupported\n");
1998
1999 hr = _SHGetProfilesValue(key, ProfilesDirectoryW, szProfilesPrefix, def_val );
2000 }
2001
2002 *szDest = 0;
2003 strcpyW(szTemp, szSrc);
2004 while (SUCCEEDED(hr) && szTemp[0] == '%')
2005 {
2006 if (!strncmpiW(szTemp, AllUsersProfileW, strlenW(AllUsersProfileW)))
2007 {
2008 WCHAR szAllUsers[MAX_PATH];
2009
2010 strcpyW(szDest, szProfilesPrefix);
2011 hr = _SHGetProfilesValue(key, AllUsersProfileValueW,
2012 szAllUsers, AllUsersW);
2013 PathAppendW(szDest, szAllUsers);
2014 PathAppendW(szDest, szTemp + strlenW(AllUsersProfileW));
2015 }
2016 else if (!strncmpiW(szTemp, UserProfileW, strlenW(UserProfileW)))
2017 {
2018 WCHAR userName[MAX_PATH];
2019 DWORD userLen = MAX_PATH;
2020
2021 strcpyW(szDest, szProfilesPrefix);
2022 GetUserNameW(userName, &userLen);
2023 PathAppendW(szDest, userName);
2024 PathAppendW(szDest, szTemp + strlenW(UserProfileW));
2025 }
2026 else if (!strncmpiW(szTemp, SystemDriveW, strlenW(SystemDriveW)))
2027 {
2028 GetSystemDirectoryW(szDest, MAX_PATH);
2029 if (szDest[1] != ':')
2030 {
2031 FIXME("non-drive system paths unsupported\n");
2032 hr = E_FAIL;
2033 }
2034 else
2035 {
2036 strcpyW(szDest + 3, szTemp + strlenW(SystemDriveW) + 1);
2037 hr = S_OK;
2038 }
2039 }
2040 else
2041 {
2042 DWORD ret = ExpandEnvironmentStringsW(szSrc, szDest, MAX_PATH);
2043
2044 if (ret > MAX_PATH)
2045 hr = HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
2046 else if (ret == 0)
2047 hr = HRESULT_FROM_WIN32(GetLastError());
2048 else
2049 hr = S_OK;
2050 }
2051 if (SUCCEEDED(hr) && szDest[0] == '%')
2052 strcpyW(szTemp, szDest);
2053 else
2054 {
2055 /* terminate loop */
2056 szTemp[0] = '\0';
2057 }
2058 }
2059 end:
2060 if (key)
2061 RegCloseKey(key);
2062 TRACE("returning 0x%08x (input was %s, output is %s)\n", hr,
2063 debugstr_w(szSrc), debugstr_w(szDest));
2064 return hr;
2065 }
2066
2067 /*************************************************************************
2068 * SHGetFolderPathW [SHELL32.@]
2069 *
2070 * Convert nFolder to path.
2071 *
2072 * RETURNS
2073 * Success: S_OK
2074 * Failure: standard HRESULT error codes.
2075 *
2076 * NOTES
2077 * Most values can be overridden in either
2078 * HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\User Shell Folders
2079 * or in the same location in HKLM.
2080 * The "Shell Folders" registry key was used in NT4 and earlier systems.
2081 * Beginning with Windows 2000, the "User Shell Folders" key is used, so
2082 * changes made to it are made to the former key too. This synchronization is
2083 * done on-demand: not until someone requests the value of one of these paths
2084 * (by calling one of the SHGet functions) is the value synchronized.
2085 * Furthermore, the HKCU paths take precedence over the HKLM paths.
2086 */
2087 HRESULT WINAPI SHGetFolderPathW(
2088 HWND hwndOwner, /* [I] owner window */
2089 int nFolder, /* [I] CSIDL identifying the folder */
2090 HANDLE hToken, /* [I] access token */
2091 DWORD dwFlags, /* [I] which path to return */
2092 LPWSTR pszPath) /* [O] converted path */
2093 {
2094 HRESULT hr = SHGetFolderPathAndSubDirW(hwndOwner, nFolder, hToken, dwFlags, NULL, pszPath);
2095 if(HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND) == hr)
2096 hr = HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
2097 return hr;
2098 }
2099
2100 HRESULT WINAPI SHGetFolderPathAndSubDirA(
2101 HWND hwndOwner, /* [I] owner window */
2102 int nFolder, /* [I] CSIDL identifying the folder */
2103 HANDLE hToken, /* [I] access token */
2104 DWORD dwFlags, /* [I] which path to return */
2105 LPCSTR pszSubPath, /* [I] sub directory of the specified folder */
2106 LPSTR pszPath) /* [O] converted path */
2107 {
2108 int length;
2109 HRESULT hr = S_OK;
2110 LPWSTR pszSubPathW = NULL;
2111 LPWSTR pszPathW = NULL;
2112 TRACE("%08x,%08x,%s\n",nFolder, dwFlags, debugstr_w(pszSubPathW));
2113
2114 if(pszPath) {
2115 pszPathW = HeapAlloc(GetProcessHeap(), 0, MAX_PATH * sizeof(WCHAR));
2116 if(!pszPathW) {
2117 hr = HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY);
2118 goto cleanup;
2119 }
2120 }
2121 TRACE("%08x,%08x,%s\n",nFolder, dwFlags, debugstr_w(pszSubPathW));
2122
2123 /* SHGetFolderPathAndSubDirW does not distinguish if pszSubPath isn't
2124 * set (null), or an empty string.therefore call it without the parameter set
2125 * if pszSubPath is an empty string
2126 */
2127 if (pszSubPath && pszSubPath[0]) {
2128 length = MultiByteToWideChar(CP_ACP, 0, pszSubPath, -1, NULL, 0);
2129 pszSubPathW = HeapAlloc(GetProcessHeap(), 0, length * sizeof(WCHAR));
2130 if(!pszSubPathW) {
2131 hr = HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY);
2132 goto cleanup;
2133 }
2134 MultiByteToWideChar(CP_ACP, 0, pszSubPath, -1, pszSubPathW, length);
2135 }
2136
2137 hr = SHGetFolderPathAndSubDirW(hwndOwner, nFolder, hToken, dwFlags, pszSubPathW, pszPathW);
2138
2139 if (SUCCEEDED(hr) && pszPath)
2140 WideCharToMultiByte(CP_ACP, 0, pszPathW, -1, pszPath, MAX_PATH, NULL, NULL);
2141
2142 cleanup:
2143 HeapFree(GetProcessHeap(), 0, pszPathW);
2144 HeapFree(GetProcessHeap(), 0, pszSubPathW);
2145 return hr;
2146 }
2147
2148 /*************************************************************************
2149 * SHGetFolderPathAndSubDirW [SHELL32.@]
2150 */
2151 HRESULT WINAPI SHGetFolderPathAndSubDirW(
2152 HWND hwndOwner, /* [I] owner window */
2153 int nFolder, /* [I] CSIDL identifying the folder */
2154 HANDLE hToken, /* [I] access token */
2155 DWORD dwFlags, /* [I] which path to return */
2156 LPCWSTR pszSubPath,/* [I] sub directory of the specified folder */
2157 LPWSTR pszPath) /* [O] converted path */
2158 {
2159 HRESULT hr;
2160 WCHAR szBuildPath[MAX_PATH], szTemp[MAX_PATH];
2161 DWORD folder = nFolder & CSIDL_FOLDER_MASK;
2162 CSIDL_Type type;
2163 int ret;
2164
2165 TRACE("%p,%p,nFolder=0x%04x,%s\n", hwndOwner,pszPath,nFolder,debugstr_w(pszSubPath));
2166
2167 /* Windows always NULL-terminates the resulting path regardless of success
2168 * or failure, so do so first
2169 */
2170 if (pszPath)
2171 *pszPath = '\0';
2172
2173 if (folder >= sizeof(CSIDL_Data) / sizeof(CSIDL_Data[0]))
2174 return E_INVALIDARG;
2175 if ((SHGFP_TYPE_CURRENT != dwFlags) && (SHGFP_TYPE_DEFAULT != dwFlags))
2176 return E_INVALIDARG;
2177 szTemp[0] = 0;
2178 type = CSIDL_Data[folder].type;
2179 switch (type)
2180 {
2181 case CSIDL_Type_Disallowed:
2182 hr = E_INVALIDARG;
2183 break;
2184 case CSIDL_Type_NonExistent:
2185 hr = S_FALSE;
2186 break;
2187 case CSIDL_Type_WindowsPath:
2188 GetWindowsDirectoryW(szTemp, MAX_PATH);
2189 if (CSIDL_Data[folder].szDefaultPath &&
2190 !IS_INTRESOURCE(CSIDL_Data[folder].szDefaultPath) &&
2191 *CSIDL_Data[folder].szDefaultPath)
2192 {
2193 PathAddBackslashW(szTemp);
2194 strcatW(szTemp, CSIDL_Data[folder].szDefaultPath);
2195 }
2196 hr = S_OK;
2197 break;
2198 case CSIDL_Type_SystemPath:
2199 GetSystemDirectoryW(szTemp, MAX_PATH);
2200 if (CSIDL_Data[folder].szDefaultPath &&
2201 !IS_INTRESOURCE(CSIDL_Data[folder].szDefaultPath) &&
2202 *CSIDL_Data[folder].szDefaultPath)
2203 {
2204 PathAddBackslashW(szTemp);
2205 strcatW(szTemp, CSIDL_Data[folder].szDefaultPath);
2206 }
2207 hr = S_OK;
2208 break;
2209 case CSIDL_Type_SystemX86Path:
2210 if (!GetSystemWow64DirectoryW(szTemp, MAX_PATH)) GetSystemDirectoryW(szTemp, MAX_PATH);
2211 if (CSIDL_Data[folder].szDefaultPath &&
2212 !IS_INTRESOURCE(CSIDL_Data[folder].szDefaultPath) &&
2213 *CSIDL_Data[folder].szDefaultPath)
2214 {
2215 PathAddBackslashW(szTemp);
2216 strcatW(szTemp, CSIDL_Data[folder].szDefaultPath);
2217 }
2218 hr = S_OK;
2219 break;
2220 case CSIDL_Type_CurrVer:
2221 hr = _SHGetCurrentVersionPath(dwFlags, folder, szTemp);
2222 break;
2223 case CSIDL_Type_User:
2224 hr = _SHGetUserProfilePath(hToken, dwFlags, folder, szTemp);
2225 break;
2226 case CSIDL_Type_AllUsers:
2227 hr = _SHGetAllUsersProfilePath(dwFlags, folder, szTemp);
2228 break;
2229 default:
2230 FIXME("bogus type %d, please fix\n", type);
2231 hr = E_INVALIDARG;
2232 break;
2233 }
2234
2235 /* Expand environment strings if necessary */
2236 if (*szTemp == '%')
2237 hr = _SHExpandEnvironmentStrings(szTemp, szBuildPath);
2238 else
2239 strcpyW(szBuildPath, szTemp);
2240
2241 if (FAILED(hr)) goto end;
2242
2243 if(pszSubPath) {
2244 /* make sure the new path does not exceed th bufferlength
2245 * rememebr to backslash and the termination */
2246 if(MAX_PATH < (lstrlenW(szBuildPath) + lstrlenW(pszSubPath) + 2)) {
2247 hr = HRESULT_FROM_WIN32(ERROR_FILENAME_EXCED_RANGE);
2248 goto end;
2249 }
2250 PathAppendW(szBuildPath, pszSubPath);
2251 PathRemoveBackslashW(szBuildPath);
2252 }
2253 /* Copy the path if it's available before we might return */
2254 if (SUCCEEDED(hr) && pszPath)
2255 strcpyW(pszPath, szBuildPath);
2256
2257 /* if we don't care about existing directories we are ready */
2258 if(nFolder & CSIDL_FLAG_DONT_VERIFY) goto end;
2259
2260 if (PathFileExistsW(szBuildPath)) goto end;
2261
2262 /* not existing but we are not allowed to create it. The return value
2263 * is verified against shell32 version 6.0.
2264 */
2265 if (!(nFolder & CSIDL_FLAG_CREATE))
2266 {
2267 hr = HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND);
2268 goto end;
2269 }
2270
2271 /* create directory/directories */
2272 ret = SHCreateDirectoryExW(hwndOwner, szBuildPath, NULL);
2273 if (ret && ret != ERROR_ALREADY_EXISTS)
2274 {
2275 ERR("Failed to create directory %s.\n", debugstr_w(szBuildPath));
2276 hr = E_FAIL;
2277 goto end;
2278 }
2279
2280 TRACE("Created missing system directory %s\n", debugstr_w(szBuildPath));
2281 end:
2282 TRACE("returning 0x%08x (final path is %s)\n", hr, debugstr_w(szBuildPath));
2283 return hr;
2284 }
2285
2286 /*************************************************************************
2287 * SHGetFolderPathA [SHELL32.@]
2288 *
2289 * See SHGetFolderPathW.
2290 */
2291 HRESULT WINAPI SHGetFolderPathA(
2292 HWND hwndOwner,
2293 int nFolder,
2294 HANDLE hToken,
2295 DWORD dwFlags,
2296 LPSTR pszPath)
2297 {
2298 WCHAR szTemp[MAX_PATH];
2299 HRESULT hr;
2300
2301 TRACE("%p,%p,nFolder=0x%04x\n",hwndOwner,pszPath,nFolder);
2302
2303 if (pszPath)
2304 *pszPath = '\0';
2305 hr = SHGetFolderPathW(hwndOwner, nFolder, hToken, dwFlags, szTemp);
2306 if (SUCCEEDED(hr) && pszPath)
2307 WideCharToMultiByte(CP_ACP, 0, szTemp, -1, pszPath, MAX_PATH, NULL,
2308 NULL);
2309
2310 return hr;
2311 }
2312
2313 /* For each folder in folders, if its value has not been set in the registry,
2314 * calls _SHGetUserProfilePath or _SHGetAllUsersProfilePath (depending on the
2315 * folder's type) to get the unexpanded value first.
2316 * Writes the unexpanded value to User Shell Folders, and queries it with
2317 * SHGetFolderPathW to force the creation of the directory if it doesn't
2318 * already exist. SHGetFolderPathW also returns the expanded value, which
2319 * this then writes to Shell Folders.
2320 */
2321 static HRESULT _SHRegisterFolders(HKEY hRootKey, HANDLE hToken,
2322 LPCWSTR szUserShellFolderPath, LPCWSTR szShellFolderPath, const UINT folders[],
2323 UINT foldersLen)
2324 {
2325 UINT i;
2326 WCHAR path[MAX_PATH];
2327 HRESULT hr = S_OK;
2328 HKEY hUserKey = NULL, hKey = NULL;
2329 DWORD dwType, dwPathLen;
2330 LONG ret;
2331
2332 TRACE("%p,%p,%s,%p,%u\n", hRootKey, hToken,
2333 debugstr_w(szUserShellFolderPath), folders, foldersLen);
2334
2335 ret = RegCreateKeyW(hRootKey, szUserShellFolderPath, &hUserKey);
2336 if (ret)
2337 hr = HRESULT_FROM_WIN32(ret);
2338 else
2339 {
2340 ret = RegCreateKeyW(hRootKey, szShellFolderPath, &hKey);
2341 if (ret)
2342 hr = HRESULT_FROM_WIN32(ret);
2343 }
2344 for (i = 0; SUCCEEDED(hr) && i < foldersLen; i++)
2345 {
2346 dwPathLen = MAX_PATH * sizeof(WCHAR);
2347 if (RegQueryValueExW(hUserKey, CSIDL_Data[folders[i]].szValueName, NULL,
2348 &dwType, (LPBYTE)path, &dwPathLen) || (dwType != REG_SZ &&
2349 dwType != REG_EXPAND_SZ))
2350 {
2351 *path = '\0';
2352 if (CSIDL_Data[folders[i]].type == CSIDL_Type_User)
2353 _SHGetUserProfilePath(hToken, SHGFP_TYPE_DEFAULT, folders[i],
2354 path);
2355 else if (CSIDL_Data[folders[i]].type == CSIDL_Type_AllUsers)
2356 _SHGetAllUsersProfilePath(SHGFP_TYPE_DEFAULT, folders[i], path);
2357 else if (CSIDL_Data[folders[i]].type == CSIDL_Type_WindowsPath)
2358 {
2359 GetWindowsDirectoryW(path, MAX_PATH);
2360 if (CSIDL_Data[folders[i]].szDefaultPath &&
2361 !IS_INTRESOURCE(CSIDL_Data[folders[i]].szDefaultPath))
2362 {
2363 PathAddBackslashW(path);
2364 strcatW(path, CSIDL_Data[folders[i]].szDefaultPath);
2365 }
2366 }
2367 else
2368 hr = E_FAIL;
2369 if (*path)
2370 {
2371 ret = RegSetValueExW(hUserKey,
2372 CSIDL_Data[folders[i]].szValueName, 0, REG_EXPAND_SZ,
2373 (LPBYTE)path, (strlenW(path) + 1) * sizeof(WCHAR));
2374 if (ret)
2375 hr = HRESULT_FROM_WIN32(ret);
2376 else
2377 {
2378 hr = SHGetFolderPathW(NULL, folders[i] | CSIDL_FLAG_CREATE,
2379 hToken, SHGFP_TYPE_DEFAULT, path);
2380 ret = RegSetValueExW(hKey,
2381 CSIDL_Data[folders[i]].szValueName, 0, REG_SZ,
2382 (LPBYTE)path, (strlenW(path) + 1) * sizeof(WCHAR));
2383 if (ret)
2384 hr = HRESULT_FROM_WIN32(ret);
2385 }
2386 }
2387 }
2388 }
2389 if (hUserKey)
2390 RegCloseKey(hUserKey);
2391 if (hKey)
2392 RegCloseKey(hKey);
2393
2394 TRACE("returning 0x%08x\n", hr);
2395 return hr;
2396 }
2397
2398 static HRESULT _SHRegisterUserShellFolders(BOOL bDefault)
2399 {
2400 static const UINT folders[] = {
2401 CSIDL_PROGRAMS,
2402 CSIDL_PERSONAL,
2403 CSIDL_FAVORITES,
2404 CSIDL_APPDATA,
2405 CSIDL_STARTUP,
2406 CSIDL_RECENT,
2407 CSIDL_SENDTO,
2408 CSIDL_STARTMENU,
2409 CSIDL_MYMUSIC,
2410 CSIDL_MYVIDEO,
2411 CSIDL_DESKTOPDIRECTORY,
2412 CSIDL_NETHOOD,
2413 CSIDL_TEMPLATES,
2414 CSIDL_PRINTHOOD,
2415 CSIDL_LOCAL_APPDATA,
2416 CSIDL_INTERNET_CACHE,
2417 CSIDL_COOKIES,
2418 CSIDL_HISTORY,
2419 CSIDL_MYPICTURES,
2420 CSIDL_FONTS
2421 };
2422 WCHAR userShellFolderPath[MAX_PATH], shellFolderPath[MAX_PATH];
2423 LPCWSTR pUserShellFolderPath, pShellFolderPath;
2424 HRESULT hr = S_OK;
2425 HKEY hRootKey;
2426 HANDLE hToken;
2427
2428 TRACE("%s\n", bDefault ? "TRUE" : "FALSE");
2429 if (bDefault)
2430 {
2431 hToken = (HANDLE)-1;
2432 hRootKey = HKEY_USERS;
2433 strcpyW(userShellFolderPath, DefaultW);
2434 PathAddBackslashW(userShellFolderPath);
2435 strcatW(userShellFolderPath, szSHUserFolders);
2436 pUserShellFolderPath = userShellFolderPath;
2437 strcpyW(shellFolderPath, DefaultW);
2438 PathAddBackslashW(shellFolderPath);
2439 strcatW(shellFolderPath, szSHFolders);
2440 pShellFolderPath = shellFolderPath;
2441 }
2442 else
2443 {
2444 hToken = NULL;
2445 hRootKey = HKEY_CURRENT_USER;
2446 pUserShellFolderPath = szSHUserFolders;
2447 pShellFolderPath = szSHFolders;
2448 }
2449
2450 hr = _SHRegisterFolders(hRootKey, hToken, pUserShellFolderPath,
2451 pShellFolderPath, folders, sizeof(folders) / sizeof(folders[0]));
2452 TRACE("returning 0x%08x\n", hr);
2453 return hr;
2454 }
2455
2456 static HRESULT _SHRegisterCommonShellFolders(void)
2457 {
2458 static const UINT folders[] = {
2459 CSIDL_COMMON_STARTMENU,
2460 CSIDL_COMMON_PROGRAMS,
2461 CSIDL_COMMON_STARTUP,
2462 CSIDL_COMMON_DESKTOPDIRECTORY,
2463 CSIDL_COMMON_FAVORITES,
2464 CSIDL_COMMON_APPDATA,
2465 CSIDL_COMMON_TEMPLATES,
2466 CSIDL_COMMON_DOCUMENTS,
2467 CSIDL_COMMON_ADMINTOOLS,
2468 CSIDL_COMMON_MUSIC,
2469 CSIDL_COMMON_PICTURES,
2470 CSIDL_COMMON_VIDEO,
2471 };
2472 HRESULT hr;
2473
2474 TRACE("\n");
2475 hr = _SHRegisterFolders(HKEY_LOCAL_MACHINE, NULL, szSHUserFolders,
2476 szSHFolders, folders, sizeof(folders) / sizeof(folders[0]));
2477 TRACE("returning 0x%08x\n", hr);
2478 return hr;
2479 }
2480
2481 /******************************************************************************
2482 * _SHAppendToUnixPath [Internal]
2483 *
2484 * Helper function for _SHCreateSymbolicLinks. Appends pwszSubPath (or the
2485 * corresponding resource, if IS_INTRESOURCE) to the unix base path 'szBasePath'
2486 * and replaces backslashes with slashes.
2487 *
2488 * PARAMS
2489 * szBasePath [IO] The unix base path, which will be appended to (CP_UNXICP).
2490 * pwszSubPath [I] Sub-path or resource id (use MAKEINTRESOURCEW).
2491 *
2492 * RETURNS
2493 * Success: TRUE,
2494 * Failure: FALSE
2495 */
2496 static inline BOOL _SHAppendToUnixPath(char *szBasePath, LPCWSTR pwszSubPath) {
2497 WCHAR wszSubPath[MAX_PATH];
2498 int cLen = strlen(szBasePath);
2499 char *pBackslash;
2500
2501 if (IS_INTRESOURCE(pwszSubPath)) {
2502 if (!LoadStringW(shell32_hInstance, LOWORD(pwszSubPath), wszSubPath, MAX_PATH)) {
2503 /* Fall back to hard coded defaults. */
2504 switch (LOWORD(pwszSubPath)) {
2505 case IDS_PERSONAL:
2506 lstrcpyW(wszSubPath, PersonalW);
2507 break;
2508 case IDS_MYMUSIC:
2509 lstrcpyW(wszSubPath, My_MusicW);
2510 break;
2511 case IDS_MYPICTURES:
2512 lstrcpyW(wszSubPath, My_PicturesW);
2513 break;
2514 case IDS_MYVIDEO:
2515 lstrcpyW(wszSubPath, My_VideoW);
2516 break;
2517 default:
2518 ERR("LoadString(%d) failed!\n", LOWORD(pwszSubPath));
2519 return FALSE;
2520 }
2521 }
2522 } else {
2523 lstrcpyW(wszSubPath, pwszSubPath);
2524 }
2525
2526 if (szBasePath[cLen-1] != '/') szBasePath[cLen++] = '/';
2527
2528 if (!WideCharToMultiByte(CP_UNIXCP, 0, wszSubPath, -1, szBasePath + cLen,
2529 FILENAME_MAX - cLen, NULL, NULL))
2530 {
2531 return FALSE;
2532 }
2533
2534 pBackslash = szBasePath + cLen;
2535 while ((pBackslash = strchr(pBackslash, '\\'))) *pBackslash = '/';
2536
2537 return TRUE;
2538 }
2539
2540 /******************************************************************************
2541 * _SHCreateSymbolicLinks [Internal]
2542 *
2543 * Sets up symbol links for various shell folders to point into the users home
2544 * directory. We do an educated guess about what the user would probably want:
2545 * - If there is a 'My Documents' directory in $HOME, the user probably wants
2546 * wine's 'My Documents' to point there. Furthermore, we imply that the user
2547 * is a Windows lover and has no problem with wine creating 'My Pictures',
2548 * 'My Music' and 'My Video' subfolders under '$HOME/My Documents', if those
2549 * do not already exits. We put appropriate symbolic links in place for those,
2550 * too.
2551 * - If there is no 'My Documents' directory in $HOME, we let 'My Documents'
2552 * point directly to $HOME. We assume the user to be a unix hacker who does not
2553 * want wine to create anything anywhere besides the .wine directory. So, if
2554 * there already is a 'My Music' directory in $HOME, we symlink the 'My Music'
2555 * shell folder to it. But if not, then we check XDG_MUSIC_DIR - "well known"
2556 * directory, and try to link to that. If that fails, then we symlink to
2557 * $HOME directly. The same holds fo 'My Pictures' and 'My Video'.
2558 * - The Desktop shell folder is symlinked to XDG_DESKTOP_DIR. If that does not
2559 * exist, then we try '$HOME/Desktop'. If that does not exist, then we leave
2560 * it alone.
2561 * ('My Music',... above in fact means LoadString(IDS_MYMUSIC))
2562 */
2563 static void _SHCreateSymbolicLinks(void)
2564 {
2565 UINT aidsMyStuff[] = { IDS_MYPICTURES, IDS_MYVIDEO, IDS_MYMUSIC }, i;
2566 int acsidlMyStuff[] = { CSIDL_MYPICTURES, CSIDL_MYVIDEO, CSIDL_MYMUSIC };
2567 static const char * const xdg_dirs[] = { "PICTURES", "VIDEOS", "MUSIC", "DESKTOP" };
2568 static const unsigned int num = sizeof(xdg_dirs) / sizeof(xdg_dirs[0]);
2569 WCHAR wszTempPath[MAX_PATH];
2570 char szPersonalTarget[FILENAME_MAX], *pszPersonal;
2571 char szMyStuffTarget[FILENAME_MAX], *pszMyStuff;
2572 char szDesktopTarget[FILENAME_MAX], *pszDesktop;
2573 struct stat statFolder;
2574 const char *pszHome;
2575 HRESULT hr;
2576 char ** xdg_results;
2577 char * xdg_desktop_dir;
2578
2579 /* Create all necessary profile sub-dirs up to 'My Documents' and get the unix path. */
2580 hr = SHGetFolderPathW(NULL, CSIDL_PERSONAL|CSIDL_FLAG_CREATE, NULL,
2581 SHGFP_TYPE_DEFAULT, wszTempPath);
2582 if (FAILED(hr)) return;
2583 pszPersonal = wine_get_unix_file_name(wszTempPath);
2584 if (!pszPersonal) return;
2585
2586 hr = XDG_UserDirLookup(xdg_dirs, num, &xdg_results);
2587 if (FAILED(hr)) xdg_results = NULL;
2588
2589 pszHome = getenv("HOME");
2590 if (pszHome && !stat(pszHome, &statFolder) && S_ISDIR(statFolder.st_mode)) {
2591 strcpy(szPersonalTarget, pszHome);
2592 if (_SHAppendToUnixPath(szPersonalTarget, MAKEINTRESOURCEW(IDS_PERSONAL)) &&
2593 !stat(szPersonalTarget, &statFolder) && S_ISDIR(statFolder.st_mode))
2594 {
2595 /* '$HOME/My Documents' exists. Create 'My Pictures', 'My Videos' and
2596 * 'My Music' subfolders or fail silently if they already exist. */
2597 for (i = 0; i < sizeof(aidsMyStuff)/sizeof(aidsMyStuff[0]); i++) {
2598 strcpy(szMyStuffTarget, szPersonalTarget);
2599 if (_SHAppendToUnixPath(szMyStuffTarget, MAKEINTRESOURCEW(aidsMyStuff[i])))
2600 mkdir(szMyStuffTarget, 0777);
2601 }
2602 }
2603 else
2604 {
2605 /* '$HOME/My Documents' doesn't exists, but '$HOME' does. */
2606 strcpy(szPersonalTarget, pszHome);
2607 }
2608
2609 /* Replace 'My Documents' directory with a symlink of fail silently if not empty. */
2610 rmdir(pszPersonal);
2611 symlink(szPersonalTarget, pszPersonal);
2612 }
2613 else
2614 {
2615 /* '$HOME' doesn't exist. Create 'My Pictures', 'My Videos' and 'My Music' subdirs
2616 * in '%USERPROFILE%\\My Documents' or fail silently if they already exist. */
2617 strcpy(szPersonalTarget, pszPersonal);
2618 for (i = 0; i < sizeof(aidsMyStuff)/sizeof(aidsMyStuff[0]); i++) {
2619 strcpy(szMyStuffTarget, szPersonalTarget);
2620 if (_SHAppendToUnixPath(szMyStuffTarget, MAKEINTRESOURCEW(aidsMyStuff[i])))
2621 mkdir(szMyStuffTarget, 0777);
2622 }
2623 }
2624
2625 /* Create symbolic links for 'My Pictures', 'My Video' and 'My Music'. */
2626 for (i=0; i < sizeof(aidsMyStuff)/sizeof(aidsMyStuff[0]); i++) {
2627 /* Create the current 'My Whatever' folder and get it's unix path. */
2628 hr = SHGetFolderPathW(NULL, acsidlMyStuff[i]|CSIDL_FLAG_CREATE, NULL,
2629 SHGFP_TYPE_DEFAULT, wszTempPath);
2630 if (FAILED(hr)) continue;
2631 pszMyStuff = wine_get_unix_file_name(wszTempPath);
2632 if (!pszMyStuff) continue;
2633
2634 strcpy(szMyStuffTarget, szPersonalTarget);
2635 if (_SHAppendToUnixPath(szMyStuffTarget, MAKEINTRESOURCEW(aidsMyStuff[i])) &&
2636 !stat(szMyStuffTarget, &statFolder) && S_ISDIR(statFolder.st_mode))
2637 {
2638 /* If there's a 'My Whatever' directory where 'My Documents' links to, link to it. */
2639 rmdir(pszMyStuff);
2640 symlink(szMyStuffTarget, pszMyStuff);
2641 }
2642 else
2643 {
2644 rmdir(pszMyStuff);
2645 if (xdg_results && xdg_results[i])
2646 {
2647 /* the folder specified by XDG_XXX_DIR exists, link to it. */
2648 symlink(xdg_results[i], pszMyStuff);
2649 }
2650 else
2651 {
2652 /* Else link to where 'My Documents' itself links to. */
2653 symlink(szPersonalTarget, pszMyStuff);
2654 }
2655 }
2656 HeapFree(GetProcessHeap(), 0, pszMyStuff);
2657 }
2658
2659 /* Last but not least, the Desktop folder */
2660 if (pszHome)
2661 strcpy(szDesktopTarget, pszHome);
2662 else
2663 strcpy(szDesktopTarget, pszPersonal);
2664 HeapFree(GetProcessHeap(), 0, pszPersonal);
2665
2666 xdg_desktop_dir = xdg_results ? xdg_results[num - 1] : NULL;
2667 if (xdg_desktop_dir ||
2668 (_SHAppendToUnixPath(szDesktopTarget, DesktopW) &&
2669 !stat(szDesktopTarget, &statFolder) && S_ISDIR(statFolder.st_mode)))
2670 {
2671 hr = SHGetFolderPathW(NULL, CSIDL_DESKTOPDIRECTORY|CSIDL_FLAG_CREATE, NULL,
2672 SHGFP_TYPE_DEFAULT, wszTempPath);
2673 if (SUCCEEDED(hr) && (pszDesktop = wine_get_unix_file_name(wszTempPath)))
2674 {
2675 rmdir(pszDesktop);
2676 if (xdg_desktop_dir)
2677 symlink(xdg_desktop_dir, pszDesktop);
2678 else
2679 symlink(szDesktopTarget, pszDesktop);
2680 HeapFree(GetProcessHeap(), 0, pszDesktop);
2681 }
2682 }
2683
2684 /* Free resources allocated by XDG_UserDirLookup() */
2685 if (xdg_results)
2686 {
2687 for (i = 0; i < num; i++)
2688 HeapFree(GetProcessHeap(), 0, xdg_results[i]);
2689 HeapFree(GetProcessHeap(), 0, xdg_results);
2690 }
2691 }
2692
2693 /******************************************************************************
2694 * create_extra_folders [Internal]
2695 *
2696 * Create some extra folders that don't have a standard CSIDL definition.
2697 */
2698 static HRESULT create_extra_folders(void)
2699 {
2700 static const WCHAR environW[] = {'E','n','v','i','r','o','n','m','e','n','t',0};
2701 static const WCHAR TempW[] = {'T','e','m','p',0};
2702 static const WCHAR TEMPW[] = {'T','E','M','P',0};
2703 static const WCHAR TMPW[] = {'T','M','P',0};
2704 WCHAR path[MAX_PATH+5];
2705 HRESULT hr;
2706 HKEY hkey;
2707 DWORD type, size, ret;
2708
2709 ret = RegCreateKeyW( HKEY_CURRENT_USER, environW, &hkey );
2710 if (ret) return HRESULT_FROM_WIN32( ret );
2711
2712 /* FIXME: should be under AppData, but we don't want spaces in the temp path */
2713 hr = SHGetFolderPathAndSubDirW( 0, CSIDL_PROFILE | CSIDL_FLAG_CREATE, NULL,
2714 SHGFP_TYPE_DEFAULT, TempW, path );
2715 if (SUCCEEDED(hr))
2716 {
2717 size = sizeof(path);
2718 if (RegQueryValueExW( hkey, TEMPW, NULL, &type, (LPBYTE)path, &size ))
2719 RegSetValueExW( hkey, TEMPW, 0, REG_SZ, (LPBYTE)path, (strlenW(path) + 1) * sizeof(WCHAR) );
2720 size = sizeof(path);
2721 if (RegQueryValueExW( hkey, TMPW, NULL, &type, (LPBYTE)path, &size ))
2722 RegSetValueExW( hkey, TMPW, 0, REG_SZ, (LPBYTE)path, (strlenW(path) + 1) * sizeof(WCHAR) );
2723 }
2724 RegCloseKey( hkey );
2725 return hr;
2726 }
2727
2728
2729 /******************************************************************************
2730 * set_folder_attributes
2731 *
2732 * Set the various folder attributes registry keys.
2733 */
2734 static HRESULT set_folder_attributes(void)
2735 {
2736 static const WCHAR clsidW[] = {'C','L','S','I','D','\\',0 };
2737 static const WCHAR shellfolderW[] = {'\\','S','h','e','l','l','F','o','l','d','e','r', 0 };
2738 static const WCHAR wfparsingW[] = {'W','a','n','t','s','F','O','R','P','A','R','S','I','N','G',0};
2739 static const WCHAR wfdisplayW[] = {'W','a','n','t','s','F','O','R','D','I','S','P','L','A','Y',0};
2740 static const WCHAR hideasdeleteW[] = {'H','i','d','e','A','s','D','e','l','e','t','e','P','e','r','U','s','e','r',0};
2741 static const WCHAR attributesW[] = {'A','t','t','r','i','b','u','t','e','s',0};
2742 static const WCHAR cfattributesW[] = {'C','a','l','l','F','o','r','A','t','t','r','i','b','u','t','e','s',0};
2743 static const WCHAR emptyW[] = {0};
2744
2745 static const struct
2746 {
2747 const CLSID *clsid;
2748 BOOL wfparsing : 1;
2749 BOOL wfdisplay : 1;
2750 BOOL hideasdel : 1;
2751 DWORD attr;
2752 DWORD call_for_attr;
2753 } folders[] =
2754 {
2755 { &CLSID_UnixFolder, TRUE, FALSE, FALSE },
2756 { &CLSID_UnixDosFolder, TRUE, FALSE, FALSE,
2757 SFGAO_FILESYSANCESTOR|SFGAO_FOLDER|SFGAO_HASSUBFOLDER, SFGAO_FILESYSTEM },
2758 { &CLSID_FolderShortcut, FALSE, FALSE, FALSE,
2759 SFGAO_FILESYSTEM|SFGAO_FOLDER|SFGAO_LINK,
2760 SFGAO_HASSUBFOLDER|SFGAO_FILESYSTEM|SFGAO_FOLDER|SFGAO_FILESYSANCESTOR },
2761 { &CLSID_MyDocuments, TRUE, FALSE, FALSE,
2762 SFGAO_FILESYSANCESTOR|SFGAO_FOLDER|SFGAO_HASSUBFOLDER, SFGAO_FILESYSTEM },
2763 { &CLSID_RecycleBin, FALSE, FALSE, FALSE,
2764 SFGAO_FOLDER|SFGAO_DROPTARGET|SFGAO_HASPROPSHEET },
2765 { &CLSID_ControlPanel, FALSE, TRUE, TRUE,
2766 SFGAO_FOLDER|SFGAO_HASSUBFOLDER }
2767 };
2768
2769 unsigned int i;
2770 WCHAR buffer[39 + (sizeof(clsidW) + sizeof(shellfolderW)) / sizeof(WCHAR)];
2771 LONG res;
2772 HKEY hkey;
2773
2774 for (i = 0; i < sizeof(folders)/sizeof(folders[0]); i++)
2775 {
2776 strcpyW( buffer, clsidW );
2777 StringFromGUID2( folders[i].clsid, buffer + strlenW(buffer), 39 );
2778 strcatW( buffer, shellfolderW );
2779 res = RegCreateKeyExW( HKEY_CLASSES_ROOT, buffer, 0, NULL, 0,
2780 KEY_READ | KEY_WRITE, NULL, &hkey, NULL);
2781 if (res) return HRESULT_FROM_WIN32( res );
2782 if (folders[i].wfparsing)
2783 res = RegSetValueExW( hkey, wfparsingW, 0, REG_SZ, (const BYTE *)emptyW, sizeof(emptyW) );
2784 if (folders[i].wfdisplay)
2785 res = RegSetValueExW( hkey, wfdisplayW, 0, REG_SZ, (const BYTE *)emptyW, sizeof(emptyW) );
2786 if (folders[i].hideasdel)
2787 res = RegSetValueExW( hkey, hideasdeleteW, 0, REG_SZ, (const BYTE *)emptyW, sizeof(emptyW) );
2788 if (folders[i].attr)
2789 res = RegSetValueExW( hkey, attributesW, 0, REG_DWORD,
2790 (const BYTE *)&folders[i].attr, sizeof(DWORD));
2791 if (folders[i].call_for_attr)
2792 res = RegSetValueExW( hkey, cfattributesW, 0, REG_DWORD,
2793 (const BYTE *)&folders[i].call_for_attr, sizeof(DWORD));
2794 RegCloseKey( hkey );
2795 }
2796 return S_OK;
2797 }
2798
2799
2800 /* Register the default values in the registry, as some apps seem to depend
2801 * on their presence. The set registered was taken from Windows XP.
2802 */
2803 HRESULT SHELL_RegisterShellFolders(void)
2804 {
2805 HRESULT hr;
2806
2807 /* Set up '$HOME' targeted symlinks for 'My Documents', 'My Pictures',
2808 * 'My Video', 'My Music' and 'Desktop' in advance, so that the
2809 * _SHRegister*ShellFolders() functions will find everything nice and clean
2810 * and thus will not attempt to create them in the profile directory. */
2811 _SHCreateSymbolicLinks();
2812
2813 hr = _SHRegisterUserShellFolders(TRUE);
2814 if (SUCCEEDED(hr))
2815 hr = _SHRegisterUserShellFolders(FALSE);
2816 if (SUCCEEDED(hr))
2817 hr = _SHRegisterCommonShellFolders();
2818 if (SUCCEEDED(hr))
2819 hr = create_extra_folders();
2820 if (SUCCEEDED(hr))
2821 hr = set_folder_attributes();
2822 return hr;
2823 }
2824
2825 /*************************************************************************
2826 * SHGetSpecialFolderPathA [SHELL32.@]
2827 */
2828 BOOL WINAPI SHGetSpecialFolderPathA (
2829 HWND hwndOwner,
2830 LPSTR szPath,
2831 int nFolder,
2832 BOOL bCreate)
2833 {
2834 return (SHGetFolderPathA(
2835 hwndOwner,
2836 nFolder + (bCreate ? CSIDL_FLAG_CREATE : 0),
2837 NULL,
2838 0,
2839 szPath)) == S_OK ? TRUE : FALSE;
2840 }
2841
2842 /*************************************************************************
2843 * SHGetSpecialFolderPathW
2844 */
2845 BOOL WINAPI SHGetSpecialFolderPathW (
2846 HWND hwndOwner,
2847 LPWSTR szPath,
2848 int nFolder,
2849 BOOL bCreate)
2850 {
2851 return (SHGetFolderPathW(
2852 hwndOwner,
2853 nFolder + (bCreate ? CSIDL_FLAG_CREATE : 0),
2854 NULL,
2855 0,
2856 szPath)) == S_OK ? TRUE : FALSE;
2857 }
2858
2859 /*************************************************************************
2860 * SHGetSpecialFolderPath (SHELL32.175)
2861 */
2862 BOOL WINAPI SHGetSpecialFolderPathAW (
2863 HWND hwndOwner,
2864 LPVOID szPath,
2865 int nFolder,
2866 BOOL bCreate)
2867
2868 {
2869 if (SHELL_OsIsUnicode())
2870 return SHGetSpecialFolderPathW (hwndOwner, szPath, nFolder, bCreate);
2871 return SHGetSpecialFolderPathA (hwndOwner, szPath, nFolder, bCreate);
2872 }
2873
2874 /*************************************************************************
2875 * SHGetFolderLocation [SHELL32.@]
2876 *
2877 * Gets the folder locations from the registry and creates a pidl.
2878 *
2879 * PARAMS
2880 * hwndOwner [I]
2881 * nFolder [I] CSIDL_xxxxx
2882 * hToken [I] token representing user, or NULL for current user, or -1 for
2883 * default user
2884 * dwReserved [I] must be zero
2885 * ppidl [O] PIDL of a special folder
2886 *
2887 * RETURNS
2888 * Success: S_OK
2889 * Failure: Standard OLE-defined error result, S_FALSE or E_INVALIDARG
2890 *
2891 * NOTES
2892 * Creates missing reg keys and directories.
2893 * Mostly forwards to SHGetFolderPathW, but a few values of nFolder return
2894 * virtual folders that are handled here.
2895 */
2896 HRESULT WINAPI SHGetFolderLocation(
2897 HWND hwndOwner,
2898 int nFolder,
2899 HANDLE hToken,
2900 DWORD dwReserved,
2901 LPITEMIDLIST *ppidl)
2902 {
2903 HRESULT hr = E_INVALIDARG;
2904
2905 TRACE("%p 0x%08x %p 0x%08x %p\n",
2906 hwndOwner, nFolder, hToken, dwReserved, ppidl);
2907
2908 if (!ppidl)
2909 return E_INVALIDARG;
2910 if (dwReserved)
2911 return E_INVALIDARG;
2912
2913 /* The virtual folders' locations are not user-dependent */
2914 *ppidl = NULL;
2915 switch (nFolder & CSIDL_FOLDER_MASK)
2916 {
2917 case CSIDL_DESKTOP:
2918 *ppidl = _ILCreateDesktop();
2919 break;
2920
2921 case CSIDL_PERSONAL:
2922 *ppidl = _ILCreateMyDocuments();
2923 break;
2924
2925 case CSIDL_INTERNET:
2926 *ppidl = _ILCreateIExplore();
2927 break;
2928
2929 case CSIDL_CONTROLS:
2930 *ppidl = _ILCreateControlPanel();
2931 break;
2932
2933 case CSIDL_PRINTERS:
2934 *ppidl = _ILCreatePrinters();
2935 break;
2936
2937 case CSIDL_BITBUCKET:
2938 *ppidl = _ILCreateBitBucket();
2939 break;
2940
2941 case CSIDL_DRIVES:
2942 *ppidl = _ILCreateMyComputer();
2943 break;
2944
2945 case CSIDL_NETWORK:
2946 *ppidl = _ILCreateNetwork();
2947 break;
2948
2949 default:
2950 {
2951 WCHAR szPath[MAX_PATH];
2952
2953 hr = SHGetFolderPathW(hwndOwner, nFolder, hToken,
2954 SHGFP_TYPE_CURRENT, szPath);
2955 if (SUCCEEDED(hr))
2956 {
2957 DWORD attributes=0;
2958
2959 TRACE("Value=%s\n", debugstr_w(szPath));
2960 hr = SHILCreateFromPathW(szPath, ppidl, &attributes);
2961 }
2962 else if (hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND))
2963 {
2964 /* unlike SHGetFolderPath, SHGetFolderLocation in shell32
2965 * version 6.0 returns E_FAIL for nonexistent paths
2966 */
2967 hr = E_FAIL;
2968 }
2969 }
2970 }
2971 if(*ppidl)
2972 hr = NOERROR;
2973
2974 TRACE("-- (new pidl %p)\n",*ppidl);
2975 return hr;
2976 }
2977
2978 /*************************************************************************
2979 * SHGetSpecialFolderLocation [SHELL32.@]
2980 *
2981 * NOTES
2982 * In NT5, SHGetSpecialFolderLocation needs the <winntdir>/Recent
2983 * directory.
2984 */
2985 HRESULT WINAPI SHGetSpecialFolderLocation(
2986 HWND hwndOwner,
2987 INT nFolder,
2988 LPITEMIDLIST * ppidl)
2989 {
2990 HRESULT hr = E_INVALIDARG;
2991
2992 TRACE("(%p,0x%x,%p)\n", hwndOwner,nFolder,ppidl);
2993
2994 if (!ppidl)
2995 return E_INVALIDARG;
2996
2997 hr = SHGetFolderLocation(hwndOwner, nFolder, NULL, 0, ppidl);
2998 return hr;
2999 }
3000
3001 static int csidl_from_id( const KNOWNFOLDERID *id )
3002 {
3003 int i;
3004 for (i = 0; i < sizeof(CSIDL_Data) / sizeof(CSIDL_Data[0]); i++)
3005 if (IsEqualGUID( CSIDL_Data[i].id, id )) return i;
3006 return -1;
3007 }
3008
3009 /*************************************************************************
3010 * SHGetKnownFolderPath [SHELL32.@]
3011 */
3012 HRESULT WINAPI SHGetKnownFolderPath(REFKNOWNFOLDERID rfid, DWORD flags, HANDLE token, PWSTR *path)
3013 {
3014 HRESULT hr;
3015 WCHAR folder[MAX_PATH];
3016 int index = csidl_from_id( rfid );
3017
3018 TRACE("%s, 0x%08x, %p, %p\n", debugstr_guid(rfid), flags, token, path);
3019
3020 if (index < 0)
3021 return E_INVALIDARG;
3022
3023 if (flags & KF_FLAG_CREATE)
3024 index |= CSIDL_FLAG_CREATE;
3025
3026 if (flags & KF_FLAG_DONT_VERIFY)
3027 index |= CSIDL_FLAG_DONT_VERIFY;
3028
3029 if (flags & KF_FLAG_NO_ALIAS)
3030 index |= CSIDL_FLAG_NO_ALIAS;
3031
3032 if (flags & KF_FLAG_INIT)
3033 index |= CSIDL_FLAG_PER_USER_INIT;
3034
3035 if (flags & ~(KF_FLAG_CREATE|KF_FLAG_DONT_VERIFY|KF_FLAG_NO_ALIAS|KF_FLAG_INIT))
3036 {
3037 FIXME("flags 0x%08x not supported\n", flags);
3038 return E_INVALIDARG;
3039 }
3040
3041 hr = SHGetFolderPathW( NULL, index, token, 0, folder );
3042 if (SUCCEEDED(hr))
3043 {
3044 *path = CoTaskMemAlloc( (strlenW( folder ) + 1) * sizeof(WCHAR) );
3045 if (!*path)
3046 return E_OUTOFMEMORY;
3047 strcpyW( *path, folder );
3048 }
3049 return hr;
3050 }
3051
3052 /*************************************************************************
3053 * SHGetFolderPathEx [SHELL32.@]
3054 */
3055 HRESULT WINAPI SHGetFolderPathEx(REFKNOWNFOLDERID rfid, DWORD flags, HANDLE token, LPWSTR path, DWORD len)
3056 {
3057 HRESULT hr;
3058 WCHAR *buffer;
3059
3060 TRACE("%s, 0x%08x, %p, %p, %u\n", debugstr_guid(rfid), flags, token, path, len);
3061
3062 if (!path || !len) return E_INVALIDARG;
3063
3064 hr = SHGetKnownFolderPath( rfid, flags, token, &buffer );
3065 if (SUCCEEDED( hr ))
3066 {
3067 if (strlenW( buffer ) + 1 > len)
3068 {
3069 CoTaskMemFree( buffer );
3070 return HRESULT_FROM_WIN32( ERROR_INSUFFICIENT_BUFFER );
3071 }
3072 strcpyW( path, buffer );
3073 CoTaskMemFree( buffer );
3074 }
3075 return hr;
3076 }
3077
3078 struct knownfolder
3079 {
3080 const struct IKnownFolderVtbl *vtbl;
3081 LONG refs;
3082 KNOWNFOLDERID id;
3083 };
3084
3085 static inline struct knownfolder *impl_from_IKnownFolder( IKnownFolder *iface )
3086 {
3087 return (struct knownfolder *)((char *)iface - FIELD_OFFSET( struct knownfolder, vtbl ));
3088 }
3089
3090 static ULONG WINAPI knownfolder_AddRef(
3091 IKnownFolder *iface )
3092 {
3093 struct knownfolder *knownfolder = impl_from_IKnownFolder( iface );
3094 return InterlockedIncrement( &knownfolder->refs );
3095 }
3096
3097 static ULONG WINAPI knownfolder_Release(
3098 IKnownFolder *iface )
3099 {
3100 struct knownfolder *knownfolder = impl_from_IKnownFolder( iface );
3101 LONG refs = InterlockedDecrement( &knownfolder->refs );
3102 if (!refs)
3103 {
3104 TRACE("destroying %p\n", knownfolder);
3105 HeapFree( GetProcessHeap(), 0, knownfolder );
3106 }
3107 return refs;
3108 }
3109
3110 static HRESULT WINAPI knownfolder_QueryInterface(
3111 IKnownFolder *iface,
3112 REFIID riid,
3113 void **ppv )
3114 {
3115 struct knownfolder *This = impl_from_IKnownFolder( iface );
3116
3117 TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppv );
3118
3119 if ( IsEqualGUID( riid, &IID_IKnownFolder ) ||
3120 IsEqualGUID( riid, &IID_IUnknown ) )
3121 {
3122 *ppv = iface;
3123 }
3124 else
3125 {
3126 FIXME("interface %s not implemented\n", debugstr_guid(riid));
3127 return E_NOINTERFACE;
3128 }
3129 IKnownFolder_AddRef( iface );
3130 return S_OK;
3131 }
3132
3133 static HRESULT knowfolder_set_id(
3134 IKnownFolder *iface,
3135 const KNOWNFOLDERID *kfid)
3136 {
3137 struct knownfolder *knownfolder = impl_from_IKnownFolder( iface );
3138
3139 TRACE("%s\n", debugstr_guid(kfid));
3140
3141 knownfolder->id = *kfid;
3142 return S_OK;
3143 }
3144
3145 static HRESULT WINAPI knownfolder_GetId(
3146 IKnownFolder *iface,
3147 KNOWNFOLDERID *pkfid)
3148 {
3149 struct knownfolder *knownfolder = impl_from_IKnownFolder( iface );
3150
3151 TRACE("%p\n", pkfid);
3152
3153 *pkfid = knownfolder->id;
3154 return S_OK;
3155 }
3156
3157 static HRESULT WINAPI knownfolder_GetCategory(
3158 IKnownFolder *iface,
3159 KF_CATEGORY *pCategory)
3160 {
3161 FIXME("%p\n", pCategory);
3162 return E_NOTIMPL;
3163 }
3164
3165 static HRESULT WINAPI knownfolder_GetShellItem(
3166 IKnownFolder *iface,
3167 DWORD dwFlags,
3168 REFIID riid,
3169 void **ppv)
3170 {
3171 FIXME("0x%08x, %s, %p\n", dwFlags, debugstr_guid(riid), ppv);
3172 return E_NOTIMPL;
3173 }
3174
3175 static HRESULT WINAPI knownfolder_GetPath(
3176 IKnownFolder *iface,
3177 DWORD dwFlags,
3178 LPWSTR *ppszPath)
3179 {
3180 struct knownfolder *knownfolder = impl_from_IKnownFolder( iface );
3181
3182 TRACE("0x%08x, %p\n", dwFlags, ppszPath);
3183 return SHGetKnownFolderPath( &knownfolder->id, dwFlags, NULL, ppszPath );
3184 }
3185
3186 static HRESULT WINAPI knownfolder_SetPath(
3187 IKnownFolder *iface,
3188 DWORD dwFlags,
3189 LPCWSTR pszPath)
3190 {
3191 FIXME("0x%08x, %p\n", dwFlags, debugstr_w(pszPath));
3192 return E_NOTIMPL;
3193 }
3194
3195 static HRESULT WINAPI knownfolder_GetIDList(
3196 IKnownFolder *iface,
3197 DWORD dwFlags,
3198 PIDLIST_ABSOLUTE *ppidl)
3199 {
3200 FIXME("0x%08x, %p\n", dwFlags, ppidl);
3201 return E_NOTIMPL;
3202 }
3203
3204 static HRESULT WINAPI knownfolder_GetFolderType(
3205 IKnownFolder *iface,
3206 FOLDERTYPEID *pftid)
3207 {
3208 FIXME("%p\n", pftid);
3209 return E_NOTIMPL;
3210 }
3211
3212 static HRESULT WINAPI knownfolder_GetRedirectionCapabilities(
3213 IKnownFolder *iface,
3214 KF_REDIRECTION_CAPABILITIES *pCapabilities)
3215 {
3216 FIXME("%p\n", pCapabilities);
3217 return E_NOTIMPL;
3218 }
3219
3220 static HRESULT WINAPI knownfolder_GetFolderDefinition(
3221 IKnownFolder *iface,
3222 KNOWNFOLDER_DEFINITION *pKFD)
3223 {
3224 FIXME("%p\n", pKFD);
3225 return E_NOTIMPL;
3226 }
3227
3228 static const struct IKnownFolderVtbl knownfolder_vtbl =
3229 {
3230 knownfolder_QueryInterface,
3231 knownfolder_AddRef,
3232 knownfolder_Release,
3233 knownfolder_GetId,
3234 knownfolder_GetCategory,
3235 knownfolder_GetShellItem,
3236 knownfolder_GetPath,
3237 knownfolder_SetPath,
3238 knownfolder_GetIDList,
3239 knownfolder_GetFolderType,
3240 knownfolder_GetRedirectionCapabilities,
3241 knownfolder_GetFolderDefinition
3242 };
3243
3244 static HRESULT knownfolder_create( void **ppv )
3245 {
3246 struct knownfolder *kf;
3247
3248 kf = HeapAlloc( GetProcessHeap(), 0, sizeof(*kf) );
3249 if (!kf) return E_OUTOFMEMORY;
3250
3251 kf->vtbl = &knownfolder_vtbl;
3252 kf->refs = 1;
3253 memset( &kf->id, 0, sizeof(kf->id) );
3254
3255 *ppv = &kf->vtbl;
3256
3257 TRACE("returning iface %p\n", *ppv);
3258 return S_OK;
3259 }
3260
3261 struct foldermanager
3262 {
3263 const struct IKnownFolderManagerVtbl *vtbl;
3264 LONG refs;
3265 UINT num_ids;
3266 KNOWNFOLDERID *ids;
3267 };
3268
3269 static inline struct foldermanager *impl_from_IKnownFolderManager( IKnownFolderManager *iface )
3270 {
3271 return (struct foldermanager *)((char *)iface - FIELD_OFFSET( struct foldermanager, vtbl ));
3272 }
3273
3274 static ULONG WINAPI foldermanager_AddRef(
3275 IKnownFolderManager *iface )
3276 {
3277 struct foldermanager *foldermanager = impl_from_IKnownFolderManager( iface );
3278 return InterlockedIncrement( &foldermanager->refs );
3279 }
3280
3281 static ULONG WINAPI foldermanager_Release(
3282 IKnownFolderManager *iface )
3283 {
3284 struct foldermanager *foldermanager = impl_from_IKnownFolderManager( iface );
3285 LONG refs = InterlockedDecrement( &foldermanager->refs );
3286 if (!refs)
3287 {
3288 TRACE("destroying %p\n", foldermanager);
3289 HeapFree( GetProcessHeap(), 0, foldermanager->ids );
3290 HeapFree( GetProcessHeap(), 0, foldermanager );
3291 }
3292 return refs;
3293 }
3294
3295 static HRESULT WINAPI foldermanager_QueryInterface(
3296 IKnownFolderManager *iface,
3297 REFIID riid,
3298 void **ppv )
3299 {
3300 struct foldermanager *This = impl_from_IKnownFolderManager( iface );
3301
3302 TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppv );
3303
3304 if ( IsEqualGUID( riid, &IID_IKnownFolderManager ) ||
3305 IsEqualGUID( riid, &IID_IUnknown ) )
3306 {
3307 *ppv = iface;
3308 }
3309 else
3310 {
3311 FIXME("interface %s not implemented\n", debugstr_guid(riid));
3312 return E_NOINTERFACE;
3313 }
3314 IKnownFolderManager_AddRef( iface );
3315 return S_OK;
3316 }
3317
3318 static HRESULT WINAPI foldermanager_FolderIdFromCsidl(
3319 IKnownFolderManager *iface,
3320 int nCsidl,
3321 KNOWNFOLDERID *pfid)
3322 {
3323 TRACE("%d, %p\n", nCsidl, pfid);
3324
3325 if (nCsidl >= sizeof(CSIDL_Data) / sizeof(CSIDL_Data[0]))
3326 return E_INVALIDARG;
3327 *pfid = *CSIDL_Data[nCsidl].id;
3328 return S_OK;
3329 }
3330
3331 static HRESULT WINAPI foldermanager_FolderIdToCsidl(
3332 IKnownFolderManager *iface,
3333 REFKNOWNFOLDERID rfid,
3334 int *pnCsidl)
3335 {
3336 int csidl;
3337
3338 TRACE("%s, %p\n", debugstr_guid(rfid), pnCsidl);
3339
3340 csidl = csidl_from_id( rfid );
3341 if (csidl == -1) return E_INVALIDARG;
3342 *pnCsidl = csidl;
3343 return S_OK;
3344 }
3345
3346 static HRESULT WINAPI foldermanager_GetFolderIds(
3347 IKnownFolderManager *iface,
3348 KNOWNFOLDERID **ppKFId,
3349 UINT *pCount)
3350 {
3351 struct foldermanager *fm = impl_from_IKnownFolderManager( iface );
3352
3353 TRACE("%p, %p\n", ppKFId, pCount);
3354
3355 *ppKFId = fm->ids;
3356 *pCount = fm->num_ids;
3357 return S_OK;
3358 }
3359
3360 static BOOL is_knownfolder( struct foldermanager *fm, const KNOWNFOLDERID *id )
3361 {
3362 UINT i;
3363
3364 for (i = 0; i < fm->num_ids; i++)
3365 if (IsEqualGUID( &fm->ids[i], id )) return TRUE;
3366
3367 return FALSE;
3368 }
3369
3370 static HRESULT WINAPI foldermanager_GetFolder(
3371 IKnownFolderManager *iface,
3372 REFKNOWNFOLDERID rfid,
3373 IKnownFolder **ppkf)
3374 {
3375 struct foldermanager *fm = impl_from_IKnownFolderManager( iface );
3376 HRESULT hr;
3377
3378 TRACE("%s, %p\n", debugstr_guid(rfid), ppkf);
3379
3380 if (!is_knownfolder( fm, rfid ))
3381 {
3382 WARN("unknown folder\n");
3383 return E_INVALIDARG;
3384 }
3385 hr = knownfolder_create( (void **)ppkf );
3386 if (SUCCEEDED( hr ))
3387 hr = knowfolder_set_id( *ppkf, rfid );
3388
3389 return hr;
3390 }
3391
3392 static HRESULT WINAPI foldermanager_GetFolderByName(
3393 IKnownFolderManager *iface,
3394 LPCWSTR pszCanonicalName,
3395 IKnownFolder **ppkf)
3396 {
3397 FIXME("%s, %p\n", debugstr_w(pszCanonicalName), ppkf);
3398 return E_NOTIMPL;
3399 }
3400
3401 static HRESULT WINAPI foldermanager_RegisterFolder(
3402 IKnownFolderManager *iface,
3403 REFKNOWNFOLDERID rfid,
3404 KNOWNFOLDER_DEFINITION const *pKFD)
3405 {
3406 FIXME("%p, %p\n", rfid, pKFD);
3407 return E_NOTIMPL;
3408 }
3409
3410 static HRESULT WINAPI foldermanager_UnregisterFolder(
3411 IKnownFolderManager *iface,
3412 REFKNOWNFOLDERID rfid)
3413 {
3414 FIXME("%p\n", rfid);
3415 return E_NOTIMPL;
3416 }
3417
3418 static HRESULT WINAPI foldermanager_FindFolderFromPath(
3419 IKnownFolderManager *iface,
3420 LPCWSTR pszPath,
3421 FFFP_MODE mode,
3422 IKnownFolder **ppkf)
3423 {
3424 FIXME("%s, 0x%08x, %p\n", debugstr_w(pszPath), mode, ppkf);
3425 return E_NOTIMPL;
3426 }
3427
3428 static HRESULT WINAPI foldermanager_FindFolderFromIDList(
3429 IKnownFolderManager *iface,
3430 PCIDLIST_ABSOLUTE pidl,
3431 IKnownFolder **ppkf)
3432 {
3433 FIXME("%p, %p\n", pidl, ppkf);
3434 return E_NOTIMPL;
3435 }
3436
3437 static HRESULT WINAPI foldermanager_Redirect(
3438 IKnownFolderManager *iface,
3439 REFKNOWNFOLDERID rfid,
3440 HWND hwnd,
3441 KF_REDIRECT_FLAGS flags,
3442 LPCWSTR pszTargetPath,
3443 UINT cFolders,
3444 KNOWNFOLDERID const *pExclusion,
3445 LPWSTR *ppszError)
3446 {
3447 FIXME("%p, %p, 0x%08x, %s, %u, %p, %p\n", rfid, hwnd, flags,
3448 debugstr_w(pszTargetPath), cFolders, pExclusion, ppszError);
3449 return E_NOTIMPL;
3450 }
3451
3452 static const struct IKnownFolderManagerVtbl foldermanager_vtbl =
3453 {
3454 foldermanager_QueryInterface,
3455 foldermanager_AddRef,
3456 foldermanager_Release,
3457 foldermanager_FolderIdFromCsidl,
3458 foldermanager_FolderIdToCsidl,
3459 foldermanager_GetFolderIds,
3460 foldermanager_GetFolder,
3461 foldermanager_GetFolderByName,
3462 foldermanager_RegisterFolder,
3463 foldermanager_UnregisterFolder,
3464 foldermanager_FindFolderFromPath,
3465 foldermanager_FindFolderFromIDList,
3466 foldermanager_Redirect
3467 };
3468
3469 static HRESULT foldermanager_create( void **ppv )
3470 {
3471 UINT i, j;
3472 struct foldermanager *fm;
3473
3474 fm = HeapAlloc( GetProcessHeap(), 0, sizeof(*fm) );
3475 if (!fm) return E_OUTOFMEMORY;
3476
3477 fm->vtbl = &foldermanager_vtbl;
3478 fm->refs = 1;
3479 fm->num_ids = 0;
3480
3481 for (i = 0; i < sizeof(CSIDL_Data) / sizeof(CSIDL_Data[0]); i++)
3482 {
3483 if (!IsEqualGUID( CSIDL_Data[i].id, &GUID_NULL )) fm->num_ids++;
3484 }
3485 fm->ids = HeapAlloc( GetProcessHeap(), 0, fm->num_ids * sizeof(KNOWNFOLDERID) );
3486 if (!fm->ids)
3487 {
3488 HeapFree( GetProcessHeap(), 0, fm );
3489 return E_OUTOFMEMORY;
3490 }
3491 for (i = j = 0; i < sizeof(CSIDL_Data) / sizeof(CSIDL_Data[0]); i++)
3492 {
3493 if (!IsEqualGUID( CSIDL_Data[i].id, &GUID_NULL ))
3494 {
3495 fm->ids[j] = *CSIDL_Data[i].id;
3496 j++;
3497 }
3498 }
3499 TRACE("found %u known folders\n", fm->num_ids);
3500 *ppv = &fm->vtbl;
3501
3502 TRACE("returning iface %p\n", *ppv);
3503 return S_OK;
3504 }
3505
3506 HRESULT WINAPI KnownFolderManager_Constructor( IUnknown *punk, REFIID riid, void **ppv )
3507 {
3508 TRACE("%p, %s, %p\n", punk, debugstr_guid(riid), ppv);
3509
3510 if (!ppv)
3511 return E_POINTER;
3512 if (punk)
3513 return CLASS_E_NOAGGREGATION;
3514
3515 return foldermanager_create( ppv );
3516 }
Maarten's multimedia branch