- Fix build (try 3)
[reactos.git] / reactos / dll / win32 / shell32 / shellpath.c
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 #include <precomp.h>
28
29 WINE_DEFAULT_DEBUG_CHANNEL(shell);
30
31 /*
32 ########## Combining and Constructing paths ##########
33 */
34
35 /*************************************************************************
36 * PathAppend [SHELL32.36]
37 */
38 BOOL WINAPI PathAppendAW(
39 LPVOID lpszPath1,
40 LPCVOID lpszPath2)
41 {
42 if (SHELL_OsIsUnicode())
43 return PathAppendW(lpszPath1, lpszPath2);
44 return PathAppendA(lpszPath1, lpszPath2);
45 }
46
47 /*************************************************************************
48 * PathBuildRoot [SHELL32.30]
49 */
50 LPVOID WINAPI PathBuildRootAW(LPVOID lpszPath, int drive)
51 {
52 if(SHELL_OsIsUnicode())
53 return PathBuildRootW(lpszPath, drive);
54 return PathBuildRootA(lpszPath, drive);
55 }
56
57 /*************************************************************************
58 * PathGetExtensionA [internal]
59 *
60 * NOTES
61 * exported by ordinal
62 * return value points to the first char after the dot
63 */
64 static LPSTR PathGetExtensionA(LPCSTR lpszPath)
65 {
66 TRACE("(%s)\n",lpszPath);
67
68 lpszPath = PathFindExtensionA(lpszPath);
69 return (LPSTR)(*lpszPath?(lpszPath+1):lpszPath);
70 }
71
72 /*************************************************************************
73 * PathGetExtensionW [internal]
74 */
75 LPWSTR PathGetExtensionW(LPCWSTR lpszPath)
76 {
77 TRACE("(%s)\n",debugstr_w(lpszPath));
78
79 lpszPath = PathFindExtensionW(lpszPath);
80 return (LPWSTR)(*lpszPath?(lpszPath+1):lpszPath);
81 }
82
83 /*************************************************************************
84 * SHPathGetExtension [SHELL32.158]
85 */
86 LPVOID WINAPI SHPathGetExtensionW(LPCWSTR lpszPath, DWORD void1, DWORD void2)
87 {
88 return PathGetExtensionW(lpszPath);
89 }
90
91 /*************************************************************************
92 * PathRemoveFileSpec [SHELL32.35]
93 */
94 BOOL WINAPI PathRemoveFileSpecAW(LPVOID lpszPath)
95 {
96 if (SHELL_OsIsUnicode())
97 return PathRemoveFileSpecW(lpszPath);
98 return PathRemoveFileSpecA(lpszPath);
99 }
100
101 /*
102 Path Manipulations
103 */
104
105 /*************************************************************************
106 * PathGetShortPathA [internal]
107 */
108 static void PathGetShortPathA(LPSTR pszPath)
109 {
110 CHAR path[MAX_PATH];
111
112 TRACE("%s\n", pszPath);
113
114 if (GetShortPathNameA(pszPath, path, MAX_PATH))
115 {
116 lstrcpyA(pszPath, path);
117 }
118 }
119
120 /*************************************************************************
121 * PathGetShortPathW [internal]
122 */
123 static void PathGetShortPathW(LPWSTR pszPath)
124 {
125 WCHAR path[MAX_PATH];
126
127 TRACE("%s\n", debugstr_w(pszPath));
128
129 if (GetShortPathNameW(pszPath, path, MAX_PATH))
130 {
131 wcscpy(pszPath, path);
132 }
133 }
134
135 /*************************************************************************
136 * PathGetShortPath [SHELL32.92]
137 */
138 VOID WINAPI PathGetShortPathAW(LPVOID pszPath)
139 {
140 if(SHELL_OsIsUnicode())
141 PathGetShortPathW(pszPath);
142 PathGetShortPathA(pszPath);
143 }
144
145 /*
146 ########## Path Testing ##########
147 */
148
149 /*************************************************************************
150 * PathIsRoot [SHELL32.29]
151 */
152 BOOL WINAPI PathIsRootAW(LPCVOID lpszPath)
153 {
154 if (SHELL_OsIsUnicode())
155 return PathIsRootW(lpszPath);
156 return PathIsRootA(lpszPath);
157 }
158
159 /*************************************************************************
160 * PathIsExeA [internal]
161 */
162 static BOOL PathIsExeA (LPCSTR lpszPath)
163 {
164 LPCSTR lpszExtension = PathGetExtensionA(lpszPath);
165 int i;
166 static const char * const lpszExtensions[] =
167 {"exe", "com", "pif", "cmd", "bat", "scf", "scr", NULL };
168
169 TRACE("path=%s\n",lpszPath);
170
171 for(i=0; lpszExtensions[i]; i++)
172 if (!lstrcmpiA(lpszExtension,lpszExtensions[i])) return TRUE;
173
174 return FALSE;
175 }
176
177 /*************************************************************************
178 * PathIsExeW [internal]
179 */
180 static BOOL PathIsExeW (LPCWSTR lpszPath)
181 {
182 LPCWSTR lpszExtension = PathGetExtensionW(lpszPath);
183 int i;
184 static const WCHAR lpszExtensions[][4] =
185 {{'e','x','e','\0'}, {'c','o','m','\0'}, {'p','i','f','\0'},
186 {'c','m','d','\0'}, {'b','a','t','\0'}, {'s','c','f','\0'},
187 {'s','c','r','\0'}, {'\0'} };
188
189 TRACE("path=%s\n",debugstr_w(lpszPath));
190
191 for(i=0; lpszExtensions[i][0]; i++)
192 if (!strcmpiW(lpszExtension,lpszExtensions[i])) return TRUE;
193
194 return FALSE;
195 }
196
197 /*************************************************************************
198 * PathIsExe [SHELL32.43]
199 */
200 BOOL WINAPI PathIsExeAW (LPCVOID path)
201 {
202 if (SHELL_OsIsUnicode())
203 return PathIsExeW (path);
204 return PathIsExeA(path);
205 }
206
207 /*************************************************************************
208 * PathFileExists [SHELL32.45]
209 */
210 BOOL WINAPI PathFileExistsAW (LPCVOID lpszPath)
211 {
212 if (SHELL_OsIsUnicode())
213 return PathFileExistsW (lpszPath);
214 return PathFileExistsA (lpszPath);
215 }
216
217 /*************************************************************************
218 * PathIsSameRoot [SHELL32.650]
219 */
220 BOOL WINAPI PathIsSameRootAW(LPCVOID lpszPath1, LPCVOID lpszPath2)
221 {
222 if (SHELL_OsIsUnicode())
223 return PathIsSameRootW(lpszPath1, lpszPath2);
224 return PathIsSameRootA(lpszPath1, lpszPath2);
225 }
226
227 /*************************************************************************
228 * IsLFNDriveA [SHELL32.41]
229 */
230 BOOL WINAPI IsLFNDriveA(LPCSTR lpszPath)
231 {
232 DWORD fnlen;
233
234 if (!GetVolumeInformationA(lpszPath, NULL, 0, NULL, &fnlen, NULL, NULL, 0))
235 return FALSE;
236 return fnlen > 12;
237 }
238
239 /*************************************************************************
240 * IsLFNDriveW [SHELL32.42]
241 */
242 BOOL WINAPI IsLFNDriveW(LPCWSTR lpszPath)
243 {
244 DWORD fnlen;
245
246 if (!GetVolumeInformationW(lpszPath, NULL, 0, NULL, &fnlen, NULL, NULL, 0))
247 return FALSE;
248 return fnlen > 12;
249 }
250
251 /*************************************************************************
252 * IsLFNDrive [SHELL32.119]
253 */
254 BOOL WINAPI IsLFNDriveAW(LPCVOID lpszPath)
255 {
256 if (SHELL_OsIsUnicode())
257 return IsLFNDriveW(lpszPath);
258 return IsLFNDriveA(lpszPath);
259 }
260
261 /*
262 ########## Creating Something Unique ##########
263 */
264 /*************************************************************************
265 * PathMakeUniqueNameA [internal]
266 */
267 BOOL WINAPI PathMakeUniqueNameA(
268 LPSTR lpszBuffer,
269 DWORD dwBuffSize,
270 LPCSTR lpszShortName,
271 LPCSTR lpszLongName,
272 LPCSTR lpszPathName)
273 {
274 FIXME("%p %u %s %s %s stub\n",
275 lpszBuffer, dwBuffSize, debugstr_a(lpszShortName),
276 debugstr_a(lpszLongName), debugstr_a(lpszPathName));
277 return TRUE;
278 }
279
280 /*************************************************************************
281 * PathMakeUniqueNameW [internal]
282 */
283 BOOL WINAPI PathMakeUniqueNameW(
284 LPWSTR lpszBuffer,
285 DWORD dwBuffSize,
286 LPCWSTR lpszShortName,
287 LPCWSTR lpszLongName,
288 LPCWSTR lpszPathName)
289 {
290 FIXME("%p %u %s %s %s stub\n",
291 lpszBuffer, dwBuffSize, debugstr_w(lpszShortName),
292 debugstr_w(lpszLongName), debugstr_w(lpszPathName));
293 return TRUE;
294 }
295
296 /*************************************************************************
297 * PathMakeUniqueName [SHELL32.47]
298 */
299 BOOL WINAPI PathMakeUniqueNameAW(
300 LPVOID lpszBuffer,
301 DWORD dwBuffSize,
302 LPCVOID lpszShortName,
303 LPCVOID lpszLongName,
304 LPCVOID lpszPathName)
305 {
306 if (SHELL_OsIsUnicode())
307 return PathMakeUniqueNameW(lpszBuffer,dwBuffSize, lpszShortName,lpszLongName,lpszPathName);
308 return PathMakeUniqueNameA(lpszBuffer,dwBuffSize, lpszShortName,lpszLongName,lpszPathName);
309 }
310
311 /*************************************************************************
312 * PathYetAnotherMakeUniqueName [SHELL32.75]
313 *
314 * NOTES
315 * exported by ordinal
316 */
317 BOOL WINAPI PathYetAnotherMakeUniqueName(
318 LPWSTR lpszBuffer,
319 LPCWSTR lpszPathName,
320 LPCWSTR lpszShortName,
321 LPCWSTR lpszLongName)
322 {
323 FIXME("(%p, %s, %s ,%s):stub.\n",
324 lpszBuffer, debugstr_w(lpszPathName), debugstr_w(lpszShortName), debugstr_w(lpszLongName));
325 return TRUE;
326 }
327
328
329 /*
330 ########## cleaning and resolving paths ##########
331 */
332
333 /*************************************************************************
334 * PathCleanupSpec [SHELL32.171]
335 *
336 * lpszFile is changed in place.
337 */
338 int WINAPI PathCleanupSpec( LPCWSTR lpszPathW, LPWSTR lpszFileW )
339 {
340 int i = 0;
341 DWORD rc = 0;
342 int length = 0;
343
344 if (SHELL_OsIsUnicode())
345 {
346 LPWSTR p = lpszFileW;
347
348 TRACE("Cleanup %s\n",debugstr_w(lpszFileW));
349
350 if (lpszPathW)
351 length = wcslen(lpszPathW);
352
353 while (*p)
354 {
355 int gct = PathGetCharTypeW(*p);
356 if (gct == GCT_INVALID || gct == GCT_WILD || gct == GCT_SEPARATOR)
357 {
358 lpszFileW[i]='-';
359 rc |= PCS_REPLACEDCHAR;
360 }
361 else
362 lpszFileW[i]=*p;
363 i++;
364 p++;
365 if (length + i == MAX_PATH)
366 {
367 rc |= PCS_FATAL | PCS_PATHTOOLONG;
368 break;
369 }
370 }
371 lpszFileW[i]=0;
372 }
373 else
374 {
375 LPSTR lpszFileA = (LPSTR)lpszFileW;
376 LPCSTR lpszPathA = (LPCSTR)lpszPathW;
377 LPSTR p = lpszFileA;
378
379 TRACE("Cleanup %s\n",debugstr_a(lpszFileA));
380
381 if (lpszPathA)
382 length = strlen(lpszPathA);
383
384 while (*p)
385 {
386 int gct = PathGetCharTypeA(*p);
387 if (gct == GCT_INVALID || gct == GCT_WILD || gct == GCT_SEPARATOR)
388 {
389 lpszFileA[i]='-';
390 rc |= PCS_REPLACEDCHAR;
391 }
392 else
393 lpszFileA[i]=*p;
394 i++;
395 p++;
396 if (length + i == MAX_PATH)
397 {
398 rc |= PCS_FATAL | PCS_PATHTOOLONG;
399 break;
400 }
401 }
402 lpszFileA[i]=0;
403 }
404 return rc;
405 }
406
407 /*************************************************************************
408 * PathQualifyA [SHELL32]
409 */
410 BOOL WINAPI PathQualifyA(LPCSTR pszPath)
411 {
412 FIXME("%s\n",pszPath);
413 return 0;
414 }
415
416 /*************************************************************************
417 * PathQualifyW [SHELL32]
418 */
419 BOOL WINAPI PathQualifyW(LPCWSTR pszPath)
420 {
421 FIXME("%s\n",debugstr_w(pszPath));
422 return 0;
423 }
424
425 /*************************************************************************
426 * PathQualify [SHELL32.49]
427 */
428 BOOL WINAPI PathQualifyAW(LPCVOID pszPath)
429 {
430 if (SHELL_OsIsUnicode())
431 return PathQualifyW(pszPath);
432 return PathQualifyA(pszPath);
433 }
434
435 /*************************************************************************
436 * PathResolveA [SHELL32.51]
437 */
438 BOOL WINAPI PathResolveA(
439 LPSTR lpszPath,
440 LPCSTR *alpszPaths,
441 DWORD dwFlags)
442 {
443 FIXME("(%s,%p,0x%08x),stub!\n",
444 lpszPath, *alpszPaths, dwFlags);
445 return 0;
446 }
447
448 /*************************************************************************
449 * PathResolveW [SHELL32]
450 */
451 BOOL WINAPI PathResolveW(
452 LPWSTR lpszPath,
453 LPCWSTR *alpszPaths,
454 DWORD dwFlags)
455 {
456 FIXME("(%s,%p,0x%08x),stub!\n",
457 debugstr_w(lpszPath), debugstr_w(*alpszPaths), dwFlags);
458 return 0;
459 }
460
461 /*************************************************************************
462 * PathResolve [SHELL32.51]
463 */
464 BOOL WINAPI PathResolveAW(
465 LPVOID lpszPath,
466 LPCVOID *alpszPaths,
467 DWORD dwFlags)
468 {
469 if (SHELL_OsIsUnicode())
470 return PathResolveW(lpszPath, (LPCWSTR*)alpszPaths, dwFlags);
471 return PathResolveA(lpszPath, (LPCSTR*)alpszPaths, dwFlags);
472 }
473
474 /*************************************************************************
475 * PathProcessCommandA [SHELL32.653]
476 */
477 LONG WINAPI PathProcessCommandA (
478 LPCSTR lpszPath,
479 LPSTR lpszBuff,
480 DWORD dwBuffSize,
481 DWORD dwFlags)
482 {
483 FIXME("%s %p 0x%04x 0x%04x stub\n",
484 lpszPath, lpszBuff, dwBuffSize, dwFlags);
485 if(!lpszPath) return -1;
486 if(lpszBuff) strcpy(lpszBuff, lpszPath);
487 return strlen(lpszPath);
488 }
489
490 /*************************************************************************
491 * PathProcessCommandW
492 */
493 LONG WINAPI PathProcessCommandW (
494 LPCWSTR lpszPath,
495 LPWSTR lpszBuff,
496 DWORD dwBuffSize,
497 DWORD dwFlags)
498 {
499 FIXME("(%s, %p, 0x%04x, 0x%04x) stub\n",
500 debugstr_w(lpszPath), lpszBuff, dwBuffSize, dwFlags);
501 if(!lpszPath) return -1;
502 if(lpszBuff) wcscpy(lpszBuff, lpszPath);
503 return wcslen(lpszPath);
504 }
505
506 /*************************************************************************
507 * PathProcessCommand (SHELL32.653)
508 */
509 LONG WINAPI PathProcessCommandAW (
510 LPCVOID lpszPath,
511 LPVOID lpszBuff,
512 DWORD dwBuffSize,
513 DWORD dwFlags)
514 {
515 if (SHELL_OsIsUnicode())
516 return PathProcessCommandW(lpszPath, lpszBuff, dwBuffSize, dwFlags);
517 return PathProcessCommandA(lpszPath, lpszBuff, dwBuffSize, dwFlags);
518 }
519
520 /*
521 ########## special ##########
522 */
523
524 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'};
525 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'};
526 static const WCHAR AppDataW[] = {'A','p','p','D','a','t','a','\0'};
527 static const WCHAR CacheW[] = {'C','a','c','h','e','\0'};
528 static const WCHAR CD_BurningW[] = {'C','D',' ','B','u','r','n','i','n','g','\0'};
529 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'};
530 static const WCHAR Common_AppDataW[] = {'C','o','m','m','o','n',' ','A','p','p','D','a','t','a','\0'};
531 static const WCHAR Common_DesktopW[] = {'C','o','m','m','o','n',' ','D','e','s','k','t','o','p','\0'};
532 static const WCHAR Common_DocumentsW[] = {'C','o','m','m','o','n',' ','D','o','c','u','m','e','n','t','s','\0'};
533 static const WCHAR CommonFilesDirW[] = {'C','o','m','m','o','n','F','i','l','e','s','D','i','r','\0'};
534 static const WCHAR CommonMusicW[] = {'C','o','m','m','o','n','M','u','s','i','c','\0'};
535 static const WCHAR CommonPicturesW[] = {'C','o','m','m','o','n','P','i','c','t','u','r','e','s','\0'};
536 static const WCHAR Common_ProgramsW[] = {'C','o','m','m','o','n',' ','P','r','o','g','r','a','m','s','\0'};
537 static const WCHAR Common_StartUpW[] = {'C','o','m','m','o','n',' ','S','t','a','r','t','U','p','\0'};
538 static const WCHAR Common_Start_MenuW[] = {'C','o','m','m','o','n',' ','S','t','a','r','t',' ','M','e','n','u','\0'};
539 static const WCHAR Common_TemplatesW[] = {'C','o','m','m','o','n',' ','T','e','m','p','l','a','t','e','s','\0'};
540 static const WCHAR CommonVideoW[] = {'C','o','m','m','o','n','V','i','d','e','o','\0'};
541 static const WCHAR CookiesW[] = {'C','o','o','k','i','e','s','\0'};
542 static const WCHAR DesktopW[] = {'D','e','s','k','t','o','p','\0'};
543 static const WCHAR FavoritesW[] = {'F','a','v','o','r','i','t','e','s','\0'};
544 static const WCHAR FontsW[] = {'F','o','n','t','s','\0'};
545 static const WCHAR HistoryW[] = {'H','i','s','t','o','r','y','\0'};
546 static const WCHAR Local_AppDataW[] = {'L','o','c','a','l',' ','A','p','p','D','a','t','a','\0'};
547 static const WCHAR My_MusicW[] = {'M','y',' ','M','u','s','i','c','\0'};
548 static const WCHAR My_PicturesW[] = {'M','y',' ','P','i','c','t','u','r','e','s','\0'};
549 static const WCHAR My_VideoW[] = {'M','y',' ','V','i','d','e','o','\0'};
550 static const WCHAR NetHoodW[] = {'N','e','t','H','o','o','d','\0'};
551 static const WCHAR PersonalW[] = {'P','e','r','s','o','n','a','l','\0'};
552 static const WCHAR PrintHoodW[] = {'P','r','i','n','t','H','o','o','d','\0'};
553 static const WCHAR ProgramFilesDirW[] = {'P','r','o','g','r','a','m','F','i','l','e','s','D','i','r','\0'};
554 static const WCHAR ProgramsW[] = {'P','r','o','g','r','a','m','s','\0'};
555 static const WCHAR RecentW[] = {'R','e','c','e','n','t','\0'};
556 static const WCHAR ResourcesW[] = {'R','e','s','o','u','r','c','e','s','\0'};
557 static const WCHAR SendToW[] = {'S','e','n','d','T','o','\0'};
558 static const WCHAR StartUpW[] = {'S','t','a','r','t','U','p','\0'};
559 static const WCHAR Start_MenuW[] = {'S','t','a','r','t',' ','M','e','n','u','\0'};
560 static const WCHAR TemplatesW[] = {'T','e','m','p','l','a','t','e','s','\0'};
561 static const WCHAR DefaultW[] = {'.','D','e','f','a','u','l','t','\0'};
562 static const WCHAR AllUsersProfileW[] = {'%','A','L','L','U','S','E','R','S','P','R','O','F','I','L','E','%','\0'};
563 static const WCHAR UserProfileW[] = {'%','U','S','E','R','P','R','O','F','I','L','E','%','\0'};
564 static const WCHAR SystemDriveW[] = {'%','S','y','s','t','e','m','D','r','i','v','e','%','\0'};
565 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};
566 static const WCHAR ProfilesDirectoryW[] = {'P','r','o','f','i','l','e','s','D','i','r','e','c','t','o','r','y',0};
567 static const WCHAR AllUsersProfileValueW[] = {'A','l','l','U','s','e','r','s','P','r','o','f','i','l','e','\0'};
568 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'};
569 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'};
570 /* This defaults to L"Documents and Settings" on Windows 2000/XP, but we're
571 * acting more Windows 9x-like for now.
572 */
573 static const WCHAR szDefaultProfileDirW[] = {'p','r','o','f','i','l','e','s','\0'};
574 static const WCHAR AllUsersW[] = {'A','l','l',' ','U','s','e','r','s','\0'};
575
576 typedef enum _CSIDL_Type {
577 CSIDL_Type_User,
578 CSIDL_Type_AllUsers,
579 CSIDL_Type_CurrVer,
580 CSIDL_Type_Disallowed,
581 CSIDL_Type_NonExistent,
582 CSIDL_Type_WindowsPath,
583 CSIDL_Type_SystemPath,
584 } CSIDL_Type;
585
586 typedef struct
587 {
588 CSIDL_Type type;
589 LPCWSTR szValueName;
590 LPCWSTR szDefaultPath; /* fallback string or resource ID */
591 } CSIDL_DATA;
592
593 static const CSIDL_DATA CSIDL_Data[] =
594 {
595 { /* 0x00 - CSIDL_DESKTOP */
596 CSIDL_Type_User,
597 DesktopW,
598 MAKEINTRESOURCEW(IDS_DESKTOPDIRECTORY)
599 },
600 { /* 0x01 - CSIDL_INTERNET */
601 CSIDL_Type_Disallowed,
602 NULL,
603 NULL
604 },
605 { /* 0x02 - CSIDL_PROGRAMS */
606 CSIDL_Type_User,
607 ProgramsW,
608 MAKEINTRESOURCEW(IDS_PROGRAMS)
609 },
610 { /* 0x03 - CSIDL_CONTROLS (.CPL files) */
611 CSIDL_Type_SystemPath,
612 NULL,
613 NULL
614 },
615 { /* 0x04 - CSIDL_PRINTERS */
616 CSIDL_Type_SystemPath,
617 NULL,
618 NULL
619 },
620 { /* 0x05 - CSIDL_PERSONAL */
621 CSIDL_Type_User,
622 PersonalW,
623 MAKEINTRESOURCEW(IDS_PERSONAL)
624 },
625 { /* 0x06 - CSIDL_FAVORITES */
626 CSIDL_Type_User,
627 FavoritesW,
628 MAKEINTRESOURCEW(IDS_FAVORITES)
629 },
630 { /* 0x07 - CSIDL_STARTUP */
631 CSIDL_Type_User,
632 StartUpW,
633 MAKEINTRESOURCEW(IDS_STARTUP)
634 },
635 { /* 0x08 - CSIDL_RECENT */
636 CSIDL_Type_User,
637 RecentW,
638 MAKEINTRESOURCEW(IDS_RECENT)
639 },
640 { /* 0x09 - CSIDL_SENDTO */
641 CSIDL_Type_User,
642 SendToW,
643 MAKEINTRESOURCEW(IDS_SENDTO)
644 },
645 { /* 0x0a - CSIDL_BITBUCKET - Recycle Bin */
646 CSIDL_Type_Disallowed,
647 NULL,
648 NULL,
649 },
650 { /* 0x0b - CSIDL_STARTMENU */
651 CSIDL_Type_User,
652 Start_MenuW,
653 MAKEINTRESOURCEW(IDS_STARTMENU)
654 },
655 { /* 0x0c - CSIDL_MYDOCUMENTS */
656 CSIDL_Type_Disallowed, /* matches WinXP--can't get its path */
657 NULL,
658 NULL
659 },
660 { /* 0x0d - CSIDL_MYMUSIC */
661 CSIDL_Type_User,
662 My_MusicW,
663 MAKEINTRESOURCEW(IDS_MYMUSIC)
664 },
665 { /* 0x0e - CSIDL_MYVIDEO */
666 CSIDL_Type_User,
667 My_VideoW,
668 MAKEINTRESOURCEW(IDS_MYVIDEO)
669 },
670 { /* 0x0f - unassigned */
671 CSIDL_Type_Disallowed,
672 NULL,
673 NULL,
674 },
675 { /* 0x10 - CSIDL_DESKTOPDIRECTORY */
676 CSIDL_Type_User,
677 DesktopW,
678 MAKEINTRESOURCEW(IDS_DESKTOPDIRECTORY)
679 },
680 { /* 0x11 - CSIDL_DRIVES */
681 CSIDL_Type_Disallowed,
682 NULL,
683 NULL,
684 },
685 { /* 0x12 - CSIDL_NETWORK */
686 CSIDL_Type_Disallowed,
687 NULL,
688 NULL,
689 },
690 { /* 0x13 - CSIDL_NETHOOD */
691 CSIDL_Type_User,
692 NetHoodW,
693 MAKEINTRESOURCEW(IDS_NETHOOD)
694 },
695 { /* 0x14 - CSIDL_FONTS */
696 CSIDL_Type_WindowsPath,
697 FontsW,
698 FontsW
699 },
700 { /* 0x15 - CSIDL_TEMPLATES */
701 CSIDL_Type_User,
702 TemplatesW,
703 MAKEINTRESOURCEW(IDS_TEMPLATES)
704 },
705 { /* 0x16 - CSIDL_COMMON_STARTMENU */
706 CSIDL_Type_AllUsers,
707 Common_Start_MenuW,
708 MAKEINTRESOURCEW(IDS_STARTMENU)
709 },
710 { /* 0x17 - CSIDL_COMMON_PROGRAMS */
711 CSIDL_Type_AllUsers,
712 Common_ProgramsW,
713 MAKEINTRESOURCEW(IDS_PROGRAMS)
714 },
715 { /* 0x18 - CSIDL_COMMON_STARTUP */
716 CSIDL_Type_AllUsers,
717 Common_StartUpW,
718 MAKEINTRESOURCEW(IDS_STARTUP)
719 },
720 { /* 0x19 - CSIDL_COMMON_DESKTOPDIRECTORY */
721 CSIDL_Type_AllUsers,
722 Common_DesktopW,
723 MAKEINTRESOURCEW(IDS_DESKTOP)
724 },
725 { /* 0x1a - CSIDL_APPDATA */
726 CSIDL_Type_User,
727 AppDataW,
728 MAKEINTRESOURCEW(IDS_APPDATA)
729 },
730 { /* 0x1b - CSIDL_PRINTHOOD */
731 CSIDL_Type_User,
732 PrintHoodW,
733 MAKEINTRESOURCEW(IDS_PRINTHOOD)
734 },
735 { /* 0x1c - CSIDL_LOCAL_APPDATA */
736 CSIDL_Type_User,
737 Local_AppDataW,
738 MAKEINTRESOURCEW(IDS_LOCAL_APPDATA)
739 },
740 { /* 0x1d - CSIDL_ALTSTARTUP */
741 CSIDL_Type_NonExistent,
742 NULL,
743 NULL
744 },
745 { /* 0x1e - CSIDL_COMMON_ALTSTARTUP */
746 CSIDL_Type_NonExistent,
747 NULL,
748 NULL
749 },
750 { /* 0x1f - CSIDL_COMMON_FAVORITES */
751 CSIDL_Type_AllUsers,
752 FavoritesW,
753 MAKEINTRESOURCEW(IDS_FAVORITES)
754 },
755 { /* 0x20 - CSIDL_INTERNET_CACHE */
756 CSIDL_Type_User,
757 CacheW,
758 MAKEINTRESOURCEW(IDS_INTERNET_CACHE)
759 },
760 { /* 0x21 - CSIDL_COOKIES */
761 CSIDL_Type_User,
762 CookiesW,
763 MAKEINTRESOURCEW(IDS_COOKIES)
764 },
765 { /* 0x22 - CSIDL_HISTORY */
766 CSIDL_Type_User,
767 HistoryW,
768 MAKEINTRESOURCEW(IDS_HISTORY)
769 },
770 { /* 0x23 - CSIDL_COMMON_APPDATA */
771 CSIDL_Type_AllUsers,
772 Common_AppDataW,
773 MAKEINTRESOURCEW(IDS_APPDATA)
774 },
775 { /* 0x24 - CSIDL_WINDOWS */
776 CSIDL_Type_WindowsPath,
777 NULL,
778 NULL
779 },
780 { /* 0x25 - CSIDL_SYSTEM */
781 CSIDL_Type_SystemPath,
782 NULL,
783 NULL
784 },
785 { /* 0x26 - CSIDL_PROGRAM_FILES */
786 CSIDL_Type_CurrVer,
787 ProgramFilesDirW,
788 MAKEINTRESOURCEW(IDS_PROGRAM_FILES)
789 },
790 { /* 0x27 - CSIDL_MYPICTURES */
791 CSIDL_Type_User,
792 My_PicturesW,
793 MAKEINTRESOURCEW(IDS_MYPICTURES)
794 },
795 { /* 0x28 - CSIDL_PROFILE */
796 CSIDL_Type_User,
797 NULL,
798 NULL
799 },
800 { /* 0x29 - CSIDL_SYSTEMX86 */
801 CSIDL_Type_NonExistent,
802 NULL,
803 NULL
804 },
805 { /* 0x2a - CSIDL_PROGRAM_FILESX86 */
806 CSIDL_Type_NonExistent,
807 NULL,
808 NULL
809 },
810 { /* 0x2b - CSIDL_PROGRAM_FILES_COMMON */
811 CSIDL_Type_CurrVer,
812 CommonFilesDirW,
813 MAKEINTRESOURCEW(IDS_PROGRAM_FILES_COMMON)
814 },
815 { /* 0x2c - CSIDL_PROGRAM_FILES_COMMONX86 */
816 CSIDL_Type_NonExistent,
817 NULL,
818 NULL
819 },
820 { /* 0x2d - CSIDL_COMMON_TEMPLATES */
821 CSIDL_Type_AllUsers,
822 Common_TemplatesW,
823 MAKEINTRESOURCEW(IDS_TEMPLATES)
824 },
825 { /* 0x2e - CSIDL_COMMON_DOCUMENTS */
826 CSIDL_Type_AllUsers,
827 Common_DocumentsW,
828 MAKEINTRESOURCEW(IDS_COMMON_DOCUMENTS)
829 },
830 { /* 0x2f - CSIDL_COMMON_ADMINTOOLS */
831 CSIDL_Type_AllUsers,
832 Common_Administrative_ToolsW,
833 MAKEINTRESOURCEW(IDS_ADMINTOOLS)
834 },
835 { /* 0x30 - CSIDL_ADMINTOOLS */
836 CSIDL_Type_User,
837 Administrative_ToolsW,
838 MAKEINTRESOURCEW(IDS_ADMINTOOLS)
839 },
840 { /* 0x31 - CSIDL_CONNECTIONS */
841 CSIDL_Type_Disallowed,
842 NULL,
843 NULL
844 },
845 { /* 0x32 - unassigned */
846 CSIDL_Type_Disallowed,
847 NULL,
848 NULL
849 },
850 { /* 0x33 - unassigned */
851 CSIDL_Type_Disallowed,
852 NULL,
853 NULL
854 },
855 { /* 0x34 - unassigned */
856 CSIDL_Type_Disallowed,
857 NULL,
858 NULL
859 },
860 { /* 0x35 - CSIDL_COMMON_MUSIC */
861 CSIDL_Type_AllUsers,
862 CommonMusicW,
863 MAKEINTRESOURCEW(IDS_COMMON_MUSIC)
864 },
865 { /* 0x36 - CSIDL_COMMON_PICTURES */
866 CSIDL_Type_AllUsers,
867 CommonPicturesW,
868 MAKEINTRESOURCEW(IDS_COMMON_PICTURES)
869 },
870 { /* 0x37 - CSIDL_COMMON_VIDEO */
871 CSIDL_Type_AllUsers,
872 CommonVideoW,
873 MAKEINTRESOURCEW(IDS_COMMON_VIDEO)
874 },
875 { /* 0x38 - CSIDL_RESOURCES */
876 CSIDL_Type_WindowsPath,
877 NULL,
878 ResourcesW
879 },
880 { /* 0x39 - CSIDL_RESOURCES_LOCALIZED */
881 CSIDL_Type_NonExistent,
882 NULL,
883 NULL
884 },
885 { /* 0x3a - CSIDL_COMMON_OEM_LINKS */
886 CSIDL_Type_NonExistent,
887 NULL,
888 NULL
889 },
890 { /* 0x3b - CSIDL_CDBURN_AREA */
891 CSIDL_Type_User,
892 CD_BurningW,
893 MAKEINTRESOURCEW(IDS_CDBURN_AREA)
894 },
895 { /* 0x3c unassigned */
896 CSIDL_Type_Disallowed,
897 NULL,
898 NULL
899 },
900 { /* 0x3d - CSIDL_COMPUTERSNEARME */
901 CSIDL_Type_Disallowed, /* FIXME */
902 NULL,
903 NULL
904 },
905 { /* 0x3e - CSIDL_PROFILES */
906 CSIDL_Type_Disallowed, /* oddly, this matches WinXP */
907 NULL,
908 NULL
909 }
910 };
911
912 /* Gets the value named value from the registry key
913 * rootKey\Software\Microsoft\Windows\CurrentVersion\Explorer\User Shell Folders
914 * (or from rootKey\userPrefix\... if userPrefix is not NULL) into path, which
915 * is assumed to be MAX_PATH WCHARs in length.
916 * If it exists, expands the value and writes the expanded value to
917 * rootKey\Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders
918 * Returns successful error code if the value was retrieved from the registry,
919 * and a failure otherwise.
920 */
921 static HRESULT _SHGetUserShellFolderPath(HKEY rootKey, LPCWSTR userPrefix,
922 LPCWSTR value, LPWSTR path)
923 {
924 HRESULT hr;
925 WCHAR shellFolderPath[MAX_PATH], userShellFolderPath[MAX_PATH];
926 LPCWSTR pShellFolderPath, pUserShellFolderPath;
927 DWORD dwDisp, dwType, dwPathLen;
928 HKEY userShellFolderKey, shellFolderKey;
929
930 TRACE("%p,%s,%s,%p\n",rootKey, debugstr_w(userPrefix), debugstr_w(value),
931 path);
932
933 if (userPrefix)
934 {
935 wcscpy(shellFolderPath, userPrefix);
936 PathAddBackslashW(shellFolderPath);
937 wcscat(shellFolderPath, szSHFolders);
938 pShellFolderPath = shellFolderPath;
939 wcscpy(userShellFolderPath, userPrefix);
940 PathAddBackslashW(userShellFolderPath);
941 wcscat(userShellFolderPath, szSHUserFolders);
942 pUserShellFolderPath = userShellFolderPath;
943 }
944 else
945 {
946 pUserShellFolderPath = szSHUserFolders;
947 pShellFolderPath = szSHFolders;
948 }
949
950 if (RegCreateKeyExW(rootKey, pShellFolderPath, 0, NULL, 0, KEY_SET_VALUE,
951 NULL, &shellFolderKey, &dwDisp))
952 {
953 TRACE("Failed to create %s\n", debugstr_w(pShellFolderPath));
954 return E_FAIL;
955 }
956 if (RegCreateKeyExW(rootKey, pUserShellFolderPath, 0, NULL, 0,
957 KEY_QUERY_VALUE, NULL, &userShellFolderKey, &dwDisp))
958 {
959 TRACE("Failed to create %s\n",
960 debugstr_w(pUserShellFolderPath));
961 RegCloseKey(shellFolderKey);
962 return E_FAIL;
963 }
964
965 dwPathLen = MAX_PATH * sizeof(WCHAR);
966
967 if (!RegQueryValueExW(userShellFolderKey, value, NULL, &dwType,
968 (LPBYTE)path, &dwPathLen) && (dwType == REG_EXPAND_SZ || dwType == REG_SZ))
969 {
970 LONG ret;
971
972 dwPathLen /= sizeof(WCHAR);
973
974 path[dwPathLen] = '\0';
975 if (dwType == REG_EXPAND_SZ && path[0] == '%')
976 {
977 WCHAR szTemp[MAX_PATH];
978
979 dwPathLen = ExpandEnvironmentStringsW(path, szTemp, MAX_PATH);
980 lstrcpynW(path, szTemp, dwPathLen);
981 }
982
983 ret = RegSetValueExW(shellFolderKey, value, 0, REG_SZ, (LPBYTE)path, dwPathLen * sizeof(WCHAR));
984 if (ret != ERROR_SUCCESS)
985 hr = HRESULT_FROM_WIN32(ret);
986 else
987 hr = S_OK;
988 }
989 else
990 hr = E_FAIL;
991
992 RegCloseKey(shellFolderKey);
993 RegCloseKey(userShellFolderKey);
994 TRACE("returning 0x%08x\n", hr);
995 return hr;
996 }
997
998 /* Gets a 'semi-expanded' default value of the CSIDL with index folder into
999 * pszPath, based on the entries in CSIDL_Data. By semi-expanded, I mean:
1000 * - The entry's szDefaultPath may be either a string value or an integer
1001 * resource identifier. In the latter case, the string value of the resource
1002 * is written.
1003 * - Depending on the entry's type, the path may begin with an (unexpanded)
1004 * environment variable name. The caller is responsible for expanding
1005 * environment strings if so desired.
1006 * The types that are prepended with environment variables are:
1007 * CSIDL_Type_User: %USERPROFILE%
1008 * CSIDL_Type_AllUsers: %ALLUSERSPROFILE%
1009 * CSIDL_Type_CurrVer: %SystemDrive%
1010 * (Others might make sense too, but as yet are unneeded.)
1011 */
1012 static HRESULT _SHGetDefaultValue(BYTE folder, LPWSTR pszPath)
1013 {
1014 HRESULT hr;
1015 WCHAR resourcePath[MAX_PATH];
1016 LPCWSTR pDefaultPath = NULL;
1017
1018 TRACE("0x%02x,%p\n", folder, pszPath);
1019
1020 if (folder >= sizeof(CSIDL_Data) / sizeof(CSIDL_Data[0]))
1021 return E_INVALIDARG;
1022 if (!pszPath)
1023 return E_INVALIDARG;
1024
1025 if (CSIDL_Data[folder].szDefaultPath &&
1026 IS_INTRESOURCE(CSIDL_Data[folder].szDefaultPath))
1027 {
1028 if (LoadStringW(shell32_hInstance,
1029 LOWORD(CSIDL_Data[folder].szDefaultPath), resourcePath, MAX_PATH))
1030 {
1031 hr = S_OK;
1032 pDefaultPath = resourcePath;
1033 }
1034 else
1035 {
1036 FIXME("(%d,%s), LoadString failed, missing translation?\n", folder,
1037 debugstr_w(pszPath));
1038 hr = E_FAIL;
1039 }
1040 }
1041 else
1042 {
1043 hr = S_OK;
1044 pDefaultPath = CSIDL_Data[folder].szDefaultPath;
1045 }
1046 if (SUCCEEDED(hr))
1047 {
1048 switch (CSIDL_Data[folder].type)
1049 {
1050 case CSIDL_Type_User:
1051 wcscpy(pszPath, UserProfileW);
1052 break;
1053 case CSIDL_Type_AllUsers:
1054 wcscpy(pszPath, AllUsersProfileW);
1055 break;
1056 case CSIDL_Type_CurrVer:
1057 wcscpy(pszPath, SystemDriveW);
1058 break;
1059 default:
1060 ; /* no corresponding env. var, do nothing */
1061 }
1062 if (pDefaultPath)
1063 {
1064 PathAddBackslashW(pszPath);
1065 wcscat(pszPath, pDefaultPath);
1066 }
1067 }
1068 TRACE("returning 0x%08x\n", hr);
1069 return hr;
1070 }
1071
1072 /* Gets the (unexpanded) value of the folder with index folder into pszPath.
1073 * The folder's type is assumed to be CSIDL_Type_CurrVer. Its default value
1074 * can be overridden in the HKLM\\szCurrentVersion key.
1075 * If dwFlags has SHGFP_TYPE_DEFAULT set or if the value isn't overridden in
1076 * the registry, uses _SHGetDefaultValue to get the value.
1077 */
1078 static HRESULT _SHGetCurrentVersionPath(DWORD dwFlags, BYTE folder,
1079 LPWSTR pszPath)
1080 {
1081 HRESULT hr;
1082
1083 TRACE("0x%08x,0x%02x,%p\n", dwFlags, folder, pszPath);
1084
1085 if (folder >= sizeof(CSIDL_Data) / sizeof(CSIDL_Data[0]))
1086 return E_INVALIDARG;
1087 if (CSIDL_Data[folder].type != CSIDL_Type_CurrVer)
1088 return E_INVALIDARG;
1089 if (!pszPath)
1090 return E_INVALIDARG;
1091
1092 if (dwFlags & SHGFP_TYPE_DEFAULT)
1093 hr = _SHGetDefaultValue(folder, pszPath);
1094 else
1095 {
1096 HKEY hKey;
1097 DWORD dwDisp;
1098
1099 if (RegCreateKeyExW(HKEY_LOCAL_MACHINE, szCurrentVersion, 0,
1100 NULL, 0, KEY_ALL_ACCESS, NULL, &hKey, &dwDisp))
1101 hr = E_FAIL;
1102 else
1103 {
1104 DWORD dwType, dwPathLen = MAX_PATH * sizeof(WCHAR);
1105
1106 if (RegQueryValueExW(hKey, CSIDL_Data[folder].szValueName, NULL,
1107 &dwType, (LPBYTE)pszPath, &dwPathLen) ||
1108 (dwType != REG_SZ && dwType != REG_EXPAND_SZ))
1109 {
1110 hr = _SHGetDefaultValue(folder, pszPath);
1111 dwType = REG_EXPAND_SZ;
1112 RegSetValueExW(hKey, CSIDL_Data[folder].szValueName, 0, dwType,
1113 (LPBYTE)pszPath, (wcslen(pszPath)+1)*sizeof(WCHAR));
1114 }
1115 else
1116 {
1117 pszPath[dwPathLen / sizeof(WCHAR)] = '\0';
1118 hr = S_OK;
1119 }
1120 RegCloseKey(hKey);
1121 }
1122 }
1123 TRACE("returning 0x%08x (output path is %s)\n", hr, debugstr_w(pszPath));
1124 return hr;
1125 }
1126
1127 /* Gets the user's path (unexpanded) for the CSIDL with index folder:
1128 * If SHGFP_TYPE_DEFAULT is set, calls _SHGetDefaultValue for it. Otherwise
1129 * calls _SHGetUserShellFolderPath for it. Where it looks depends on hToken:
1130 * - if hToken is -1, looks in HKEY_USERS\.Default
1131 * - otherwise looks first in HKEY_CURRENT_USER, followed by HKEY_LOCAL_MACHINE
1132 * if HKEY_CURRENT_USER doesn't contain any entries. If both fail, finally
1133 * calls _SHGetDefaultValue for it.
1134 */
1135 static HRESULT _SHGetUserProfilePath(HANDLE hToken, DWORD dwFlags, BYTE folder,
1136 LPWSTR pszPath)
1137 {
1138 HRESULT hr;
1139
1140 TRACE("%p,0x%08x,0x%02x,%p\n", hToken, dwFlags, folder, pszPath);
1141
1142 if (folder >= sizeof(CSIDL_Data) / sizeof(CSIDL_Data[0]))
1143 return E_INVALIDARG;
1144
1145 if (CSIDL_Data[folder].type != CSIDL_Type_User)
1146 return E_INVALIDARG;
1147
1148 if (!pszPath)
1149 return E_INVALIDARG;
1150
1151 if (dwFlags & SHGFP_TYPE_DEFAULT)
1152 {
1153 hr = _SHGetDefaultValue(folder, pszPath);
1154 }
1155 else
1156 {
1157 LPWSTR userPrefix;
1158 HKEY hRootKey;
1159
1160 if (hToken == (HANDLE)-1)
1161 {
1162 /* Get the folder of the default user */
1163 hRootKey = HKEY_USERS;
1164 userPrefix = (LPWSTR)DefaultW;
1165 }
1166 else if(!hToken)
1167 {
1168 /* Get the folder of the current user */
1169 hRootKey = HKEY_CURRENT_USER;
1170 userPrefix = NULL;
1171 }
1172 else
1173 {
1174 /* Get the folder of the specified user */
1175 DWORD InfoLength;
1176 PTOKEN_USER UserInfo;
1177
1178 hRootKey = HKEY_USERS;
1179
1180 GetTokenInformation(hToken, TokenUser, NULL, 0, &InfoLength);
1181 UserInfo = (PTOKEN_USER)HeapAlloc(GetProcessHeap(), 0, InfoLength);
1182
1183 if(!GetTokenInformation(hToken, TokenUser, UserInfo, InfoLength, &InfoLength))
1184 {
1185 WARN("GetTokenInformation failed for %x!\n", hToken);
1186 HeapFree(GetProcessHeap(), 0, UserInfo);
1187 return E_FAIL;
1188 }
1189
1190 if(!ConvertSidToStringSidW(UserInfo->User.Sid, &userPrefix))
1191 {
1192 WARN("ConvertSidToStringSidW failed for %x!\n", hToken);
1193 HeapFree(GetProcessHeap(), 0, UserInfo);
1194 return E_FAIL;
1195 }
1196
1197 HeapFree(GetProcessHeap(), 0, UserInfo);
1198 }
1199
1200 hr = _SHGetUserShellFolderPath(hRootKey, userPrefix, CSIDL_Data[folder].szValueName, pszPath);
1201
1202 /* Free the memory allocated by ConvertSidToStringSidW */
1203 if(hToken && hToken != (HANDLE)-1)
1204 LocalFree(userPrefix);
1205
1206 if (FAILED(hr) && hRootKey != HKEY_LOCAL_MACHINE)
1207 hr = _SHGetUserShellFolderPath(HKEY_LOCAL_MACHINE, NULL, CSIDL_Data[folder].szValueName, pszPath);
1208
1209 if (FAILED(hr))
1210 hr = _SHGetDefaultValue(folder, pszPath);
1211 }
1212
1213 TRACE("returning 0x%08x (output path is %s)\n", hr, debugstr_w(pszPath));
1214 return hr;
1215 }
1216
1217 /* Gets the (unexpanded) path for the CSIDL with index folder. If dwFlags has
1218 * SHGFP_TYPE_DEFAULT set, calls _SHGetDefaultValue. Otherwise calls
1219 * _SHGetUserShellFolderPath for it, looking only in HKEY_LOCAL_MACHINE.
1220 * If this fails, falls back to _SHGetDefaultValue.
1221 */
1222 static HRESULT _SHGetAllUsersProfilePath(DWORD dwFlags, BYTE folder,
1223 LPWSTR pszPath)
1224 {
1225 HRESULT hr;
1226
1227 TRACE("0x%08x,0x%02x,%p\n", dwFlags, folder, pszPath);
1228
1229 if (folder >= sizeof(CSIDL_Data) / sizeof(CSIDL_Data[0]))
1230 return E_INVALIDARG;
1231 if (CSIDL_Data[folder].type != CSIDL_Type_AllUsers)
1232 return E_INVALIDARG;
1233 if (!pszPath)
1234 return E_INVALIDARG;
1235
1236 if (dwFlags & SHGFP_TYPE_DEFAULT)
1237 hr = _SHGetDefaultValue(folder, pszPath);
1238 else
1239 {
1240 hr = _SHGetUserShellFolderPath(HKEY_LOCAL_MACHINE, NULL,
1241 CSIDL_Data[folder].szValueName, pszPath);
1242 if (FAILED(hr))
1243 hr = _SHGetDefaultValue(folder, pszPath);
1244 }
1245 TRACE("returning 0x%08x (output path is %s)\n", hr, debugstr_w(pszPath));
1246 return hr;
1247 }
1248
1249 /*************************************************************************
1250 * SHGetFolderPathW [SHELL32.@]
1251 *
1252 * Convert nFolder to path.
1253 *
1254 * RETURNS
1255 * Success: S_OK
1256 * Failure: standard HRESULT error codes.
1257 *
1258 * NOTES
1259 * Most values can be overridden in either
1260 * HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\User Shell Folders
1261 * or in the same location in HKLM.
1262 * The "Shell Folders" registry key was used in NT4 and earlier systems.
1263 * Beginning with Windows 2000, the "User Shell Folders" key is used, so
1264 * changes made to it are made to the former key too. This synchronization is
1265 * done on-demand: not until someone requests the value of one of these paths
1266 * (by calling one of the SHGet functions) is the value synchronized.
1267 * Furthermore, the HKCU paths take precedence over the HKLM paths.
1268 */
1269 HRESULT WINAPI SHGetFolderPathW(
1270 HWND hwndOwner, /* [I] owner window */
1271 int nFolder, /* [I] CSIDL identifying the folder */
1272 HANDLE hToken, /* [I] access token */
1273 DWORD dwFlags, /* [I] which path to return */
1274 LPWSTR pszPath) /* [O] converted path */
1275 {
1276 HRESULT hr = SHGetFolderPathAndSubDirW(hwndOwner, nFolder, hToken, dwFlags, NULL, pszPath);
1277 if(HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND) == hr)
1278 hr = HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
1279 return hr;
1280 }
1281
1282 HRESULT WINAPI SHGetFolderPathAndSubDirA(
1283 HWND hwndOwner, /* [I] owner window */
1284 int nFolder, /* [I] CSIDL identifying the folder */
1285 HANDLE hToken, /* [I] access token */
1286 DWORD dwFlags, /* [I] which path to return */
1287 LPCSTR pszSubPath, /* [I] sub directory of the specified folder */
1288 LPSTR pszPath) /* [O] converted path */
1289 {
1290 int length;
1291 HRESULT hr = S_OK;
1292 LPWSTR pszSubPathW = NULL;
1293 LPWSTR pszPathW = NULL;
1294 TRACE("%08x,%08x,%s\n",nFolder, dwFlags, debugstr_w(pszSubPathW));
1295
1296 if(pszPath) {
1297 pszPathW = HeapAlloc(GetProcessHeap(), 0, MAX_PATH * sizeof(WCHAR));
1298 if(!pszPathW) {
1299 hr = HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY);
1300 goto cleanup;
1301 }
1302 }
1303 TRACE("%08x,%08x,%s\n",nFolder, dwFlags, debugstr_w(pszSubPathW));
1304
1305 /* SHGetFolderPathAndSubDirW does not distinguish if pszSubPath isn't
1306 * set (null), or an empty string.therefore call it without the parameter set
1307 * if pszSubPath is an empty string
1308 */
1309 if (pszSubPath && pszSubPath[0]) {
1310 length = MultiByteToWideChar(CP_ACP, 0, pszSubPath, -1, NULL, 0);
1311 pszSubPathW = HeapAlloc(GetProcessHeap(), 0, length * sizeof(WCHAR));
1312 if(!pszSubPathW) {
1313 hr = HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY);
1314 goto cleanup;
1315 }
1316 MultiByteToWideChar(CP_ACP, 0, pszSubPath, -1, pszSubPathW, length);
1317 }
1318
1319 hr = SHGetFolderPathAndSubDirW(hwndOwner, nFolder, hToken, dwFlags, pszSubPathW, pszPathW);
1320
1321 if (SUCCEEDED(hr) && pszPath)
1322 WideCharToMultiByte(CP_ACP, 0, pszPathW, -1, pszPath, MAX_PATH, NULL, NULL);
1323
1324 cleanup:
1325 HeapFree(GetProcessHeap(), 0, pszPathW);
1326 HeapFree(GetProcessHeap(), 0, pszSubPathW);
1327 return hr;
1328 }
1329
1330 HRESULT WINAPI SHGetFolderPathAndSubDirW(
1331 HWND hwndOwner, /* [I] owner window */
1332 int nFolder, /* [I] CSIDL identifying the folder */
1333 HANDLE hToken, /* [I] access token */
1334 DWORD dwFlags, /* [I] which path to return */
1335 LPCWSTR pszSubPath,/* [I] sub directory of the specified folder */
1336 LPWSTR pszPath) /* [O] converted path */
1337 {
1338 HRESULT hr;
1339 WCHAR szBuildPath[MAX_PATH], szTemp[MAX_PATH];
1340 DWORD folder = nFolder & CSIDL_FOLDER_MASK; //FIXME
1341 CSIDL_Type type;
1342 int ret;
1343
1344 TRACE("%p,%p,nFolder=0x%04x,%s\n", hwndOwner,pszPath,nFolder,debugstr_w(pszSubPath));
1345
1346 /* Windows always NULL-terminates the resulting path regardless of success
1347 * or failure, so do so first
1348 */
1349 if (pszPath)
1350 *pszPath = '\0';
1351
1352 if (folder >= sizeof(CSIDL_Data) / sizeof(CSIDL_Data[0]))
1353 return E_INVALIDARG;
1354 if ((SHGFP_TYPE_CURRENT != dwFlags) && (SHGFP_TYPE_DEFAULT != dwFlags))
1355 return E_INVALIDARG;
1356 szTemp[0] = 0;
1357 type = CSIDL_Data[folder].type;
1358 switch (type)
1359 {
1360 case CSIDL_Type_Disallowed:
1361 hr = E_INVALIDARG;
1362 break;
1363 case CSIDL_Type_NonExistent:
1364 hr = S_FALSE;
1365 break;
1366 case CSIDL_Type_WindowsPath:
1367 GetWindowsDirectoryW(szTemp, MAX_PATH);
1368 if (CSIDL_Data[folder].szDefaultPath &&
1369 !IS_INTRESOURCE(CSIDL_Data[folder].szDefaultPath) &&
1370 *CSIDL_Data[folder].szDefaultPath)
1371 {
1372 PathAddBackslashW(szTemp);
1373 wcscat(szTemp, CSIDL_Data[folder].szDefaultPath);
1374 }
1375 hr = S_OK;
1376 break;
1377 case CSIDL_Type_SystemPath:
1378 GetSystemDirectoryW(szTemp, MAX_PATH);
1379 if (CSIDL_Data[folder].szDefaultPath &&
1380 !IS_INTRESOURCE(CSIDL_Data[folder].szDefaultPath) &&
1381 *CSIDL_Data[folder].szDefaultPath)
1382 {
1383 PathAddBackslashW(szTemp);
1384 wcscat(szTemp, CSIDL_Data[folder].szDefaultPath);
1385 }
1386 hr = S_OK;
1387 break;
1388 case CSIDL_Type_CurrVer:
1389 hr = _SHGetCurrentVersionPath(dwFlags, folder, szTemp);
1390 break;
1391 case CSIDL_Type_User:
1392 hr = _SHGetUserProfilePath(hToken, dwFlags, folder, szTemp);
1393 break;
1394 case CSIDL_Type_AllUsers:
1395 hr = _SHGetAllUsersProfilePath(dwFlags, folder, szTemp);
1396 break;
1397 default:
1398 FIXME("bogus type %d, please fix\n", type);
1399 hr = E_INVALIDARG;
1400 break;
1401 }
1402
1403 /* Expand environment strings if necessary */
1404 if (*szTemp == '%')
1405 {
1406 DWORD ExpandRet = ExpandEnvironmentStringsW(szTemp, szBuildPath, MAX_PATH);
1407
1408 if (ExpandRet > MAX_PATH)
1409 hr = HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
1410 else if (ExpandRet == 0)
1411 hr = HRESULT_FROM_WIN32(GetLastError());
1412 else
1413 hr = S_OK;
1414 }
1415 else
1416 {
1417 wcscpy(szBuildPath, szTemp);
1418 }
1419
1420 if (FAILED(hr)) goto end;
1421
1422 if(pszSubPath) {
1423 /* make sure the new path does not exceed th bufferlength
1424 * rememebr to backslash and the termination */
1425 if(MAX_PATH < (wcslen(szBuildPath) + wcslen(pszSubPath) + 2)) {
1426 hr = HRESULT_FROM_WIN32(ERROR_FILENAME_EXCED_RANGE);
1427 goto end;
1428 }
1429 PathAppendW(szBuildPath, pszSubPath);
1430 PathRemoveBackslashW(szBuildPath);
1431 }
1432 /* Copy the path if it's available before we might return */
1433 if (SUCCEEDED(hr) && pszPath)
1434 wcscpy(pszPath, szBuildPath);
1435
1436 /* if we don't care about existing directories we are ready */
1437 if(nFolder & CSIDL_FLAG_DONT_VERIFY) goto end;
1438
1439 if (PathFileExistsW(szBuildPath)) goto end;
1440
1441 /* not existing but we are not allowed to create it. The return value
1442 * is verified against shell32 version 6.0.
1443 */
1444 if (!(nFolder & CSIDL_FLAG_CREATE))
1445 {
1446 hr = HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND);
1447 goto end;
1448 }
1449
1450 /* create directory/directories */
1451 ret = SHCreateDirectoryExW(hwndOwner, szBuildPath, NULL);
1452 if (ret && ret != ERROR_ALREADY_EXISTS)
1453 {
1454 ERR("Failed to create directory %s.\n", debugstr_w(szBuildPath));
1455 hr = E_FAIL;
1456 goto end;
1457 }
1458
1459 TRACE("Created missing system directory %s\n", debugstr_w(szBuildPath));
1460 end:
1461 TRACE("returning 0x%08x (final path is %s)\n", hr, debugstr_w(szBuildPath));
1462 return hr;
1463 }
1464
1465 /*************************************************************************
1466 * SHGetFolderPathA [SHELL32.@]
1467 *
1468 * See SHGetFolderPathW.
1469 */
1470 HRESULT WINAPI SHGetFolderPathA(
1471 HWND hwndOwner,
1472 int nFolder,
1473 HANDLE hToken,
1474 DWORD dwFlags,
1475 LPSTR pszPath)
1476 {
1477 WCHAR szTemp[MAX_PATH];
1478 HRESULT hr;
1479
1480 TRACE("%p,%p,nFolder=0x%04x\n",hwndOwner,pszPath,nFolder);
1481
1482 if (pszPath)
1483 *pszPath = '\0';
1484 hr = SHGetFolderPathW(hwndOwner, nFolder, hToken, dwFlags, szTemp);
1485 if (SUCCEEDED(hr) && pszPath)
1486 WideCharToMultiByte(CP_ACP, 0, szTemp, -1, pszPath, MAX_PATH, NULL,
1487 NULL);
1488
1489 return hr;
1490 }
1491
1492 /* For each folder in folders, if its value has not been set in the registry,
1493 * calls _SHGetUserProfilePath or _SHGetAllUsersProfilePath (depending on the
1494 * folder's type) to get the unexpanded value first.
1495 * Writes the unexpanded value to User Shell Folders, and queries it with
1496 * SHGetFolderPathW to force the creation of the directory if it doesn't
1497 * already exist. SHGetFolderPathW also returns the expanded value, which
1498 * this then writes to Shell Folders.
1499 */
1500 static HRESULT _SHRegisterFolders(HKEY hRootKey, HANDLE hToken,
1501 LPCWSTR szUserShellFolderPath, LPCWSTR szShellFolderPath, const UINT folders[],
1502 UINT foldersLen)
1503 {
1504 UINT i;
1505 WCHAR path[MAX_PATH];
1506 HRESULT hr = S_OK;
1507 HKEY hUserKey = NULL, hKey = NULL;
1508 DWORD dwDisp, dwType, dwPathLen;
1509 LONG ret;
1510
1511 TRACE("%p,%p,%s,%p,%u\n", hRootKey, hToken,
1512 debugstr_w(szUserShellFolderPath), folders, foldersLen);
1513
1514 ret = RegCreateKeyExW(hRootKey, szUserShellFolderPath, 0, NULL, 0,
1515 KEY_ALL_ACCESS, NULL, &hUserKey, &dwDisp);
1516 if (ret)
1517 hr = HRESULT_FROM_WIN32(ret);
1518 else
1519 {
1520 ret = RegCreateKeyExW(hRootKey, szShellFolderPath, 0, NULL, 0,
1521 KEY_ALL_ACCESS, NULL, &hKey, &dwDisp);
1522 if (ret)
1523 hr = HRESULT_FROM_WIN32(ret);
1524 }
1525 for (i = 0; SUCCEEDED(hr) && i < foldersLen; i++)
1526 {
1527 dwPathLen = MAX_PATH * sizeof(WCHAR);
1528 if (RegQueryValueExW(hUserKey, CSIDL_Data[folders[i]].szValueName, NULL,
1529 &dwType, (LPBYTE)path, &dwPathLen) || (dwType != REG_SZ &&
1530 dwType != REG_EXPAND_SZ))
1531 {
1532 *path = '\0';
1533 if (CSIDL_Data[folders[i]].type == CSIDL_Type_User)
1534 _SHGetUserProfilePath(hToken, SHGFP_TYPE_DEFAULT, folders[i],
1535 path);
1536 else if (CSIDL_Data[folders[i]].type == CSIDL_Type_AllUsers)
1537 _SHGetAllUsersProfilePath(SHGFP_TYPE_DEFAULT, folders[i], path);
1538 else if (CSIDL_Data[folders[i]].type == CSIDL_Type_WindowsPath)
1539 GetWindowsDirectoryW(path, MAX_PATH);
1540 else
1541 hr = E_FAIL;
1542 if (*path)
1543 {
1544 ret = RegSetValueExW(hUserKey,
1545 CSIDL_Data[folders[i]].szValueName, 0, REG_EXPAND_SZ,
1546 (LPBYTE)path, (wcslen(path) + 1) * sizeof(WCHAR));
1547 if (ret)
1548 hr = HRESULT_FROM_WIN32(ret);
1549 else
1550 {
1551 hr = SHGetFolderPathW(NULL, folders[i] | CSIDL_FLAG_CREATE,
1552 hToken, SHGFP_TYPE_DEFAULT, path);
1553 ret = RegSetValueExW(hKey,
1554 CSIDL_Data[folders[i]].szValueName, 0, REG_SZ,
1555 (LPBYTE)path, (wcslen(path) + 1) * sizeof(WCHAR));
1556 if (ret)
1557 hr = HRESULT_FROM_WIN32(ret);
1558 }
1559 }
1560 }
1561 }
1562 if (hUserKey)
1563 RegCloseKey(hUserKey);
1564 if (hKey)
1565 RegCloseKey(hKey);
1566
1567 TRACE("returning 0x%08x\n", hr);
1568 return hr;
1569 }
1570
1571 static HRESULT _SHRegisterUserShellFolders(BOOL bDefault)
1572 {
1573 static const UINT folders[] = {
1574 CSIDL_PROGRAMS,
1575 CSIDL_PERSONAL,
1576 CSIDL_FAVORITES,
1577 CSIDL_APPDATA,
1578 CSIDL_STARTUP,
1579 CSIDL_RECENT,
1580 CSIDL_SENDTO,
1581 CSIDL_STARTMENU,
1582 CSIDL_MYMUSIC,
1583 CSIDL_MYVIDEO,
1584 CSIDL_DESKTOPDIRECTORY,
1585 CSIDL_NETHOOD,
1586 CSIDL_TEMPLATES,
1587 CSIDL_PRINTHOOD,
1588 CSIDL_LOCAL_APPDATA,
1589 CSIDL_INTERNET_CACHE,
1590 CSIDL_COOKIES,
1591 CSIDL_HISTORY,
1592 CSIDL_MYPICTURES,
1593 CSIDL_FONTS
1594 };
1595 WCHAR userShellFolderPath[MAX_PATH], shellFolderPath[MAX_PATH];
1596 LPCWSTR pUserShellFolderPath, pShellFolderPath;
1597 HRESULT hr = S_OK;
1598 HKEY hRootKey;
1599 HANDLE hToken;
1600
1601 TRACE("%s\n", bDefault ? "TRUE" : "FALSE");
1602 if (bDefault)
1603 {
1604 hToken = (HANDLE)-1;
1605 hRootKey = HKEY_USERS;
1606 wcscpy(userShellFolderPath, DefaultW);
1607 PathAddBackslashW(userShellFolderPath);
1608 wcscat(userShellFolderPath, szSHUserFolders);
1609 pUserShellFolderPath = userShellFolderPath;
1610 wcscpy(shellFolderPath, DefaultW);
1611 PathAddBackslashW(shellFolderPath);
1612 wcscat(shellFolderPath, szSHFolders);
1613 pShellFolderPath = shellFolderPath;
1614 }
1615 else
1616 {
1617 hToken = NULL;
1618 hRootKey = HKEY_CURRENT_USER;
1619 pUserShellFolderPath = szSHUserFolders;
1620 pShellFolderPath = szSHFolders;
1621 }
1622
1623 hr = _SHRegisterFolders(hRootKey, hToken, pUserShellFolderPath,
1624 pShellFolderPath, folders, sizeof(folders) / sizeof(folders[0]));
1625 TRACE("returning 0x%08x\n", hr);
1626 return hr;
1627 }
1628
1629 static HRESULT _SHRegisterCommonShellFolders(void)
1630 {
1631 static const UINT folders[] = {
1632 CSIDL_COMMON_STARTMENU,
1633 CSIDL_COMMON_PROGRAMS,
1634 CSIDL_COMMON_STARTUP,
1635 CSIDL_COMMON_DESKTOPDIRECTORY,
1636 CSIDL_COMMON_FAVORITES,
1637 CSIDL_COMMON_APPDATA,
1638 CSIDL_COMMON_TEMPLATES,
1639 CSIDL_COMMON_DOCUMENTS,
1640 };
1641 HRESULT hr;
1642
1643 TRACE("\n");
1644 hr = _SHRegisterFolders(HKEY_LOCAL_MACHINE, NULL, szSHUserFolders,
1645 szSHFolders, folders, sizeof(folders) / sizeof(folders[0]));
1646 TRACE("returning 0x%08x\n", hr);
1647 return hr;
1648 }
1649
1650 /******************************************************************************
1651 * _SHAppendToUnixPath [Internal]
1652 *
1653 * Helper function for _SHCreateSymbolicLinks. Appends pwszSubPath (or the
1654 * corresponding resource, if IS_INTRESOURCE) to the unix base path 'szBasePath'
1655 * and replaces backslashes with slashes.
1656 *
1657 * PARAMS
1658 * szBasePath [IO] The unix base path, which will be appended to (CP_UNXICP).
1659 * pwszSubPath [I] Sub-path or resource id (use MAKEINTRESOURCEW).
1660 *
1661 * RETURNS
1662 * Success: TRUE,
1663 * Failure: FALSE
1664 */
1665 static BOOL __inline _SHAppendToUnixPath(char *szBasePath, LPCWSTR pwszSubPath) {
1666 WCHAR wszSubPath[MAX_PATH];
1667 int cLen = strlen(szBasePath);
1668 char *pBackslash;
1669
1670 if (IS_INTRESOURCE(pwszSubPath)) {
1671 if (!LoadStringW(shell32_hInstance, LOWORD(pwszSubPath), wszSubPath, MAX_PATH)) {
1672 /* Fall back to hard coded defaults. */
1673 switch (LOWORD(pwszSubPath)) {
1674 case IDS_PERSONAL:
1675 wcscpy(wszSubPath, PersonalW);
1676 break;
1677 case IDS_MYMUSIC:
1678 wcscpy(wszSubPath, My_MusicW);
1679 break;
1680 case IDS_MYPICTURES:
1681 wcscpy(wszSubPath, My_PicturesW);
1682 break;
1683 case IDS_MYVIDEO:
1684 wcscpy(wszSubPath, My_VideoW);
1685 break;
1686 default:
1687 ERR("LoadString(%d) failed!\n", LOWORD(pwszSubPath));
1688 return FALSE;
1689 }
1690 }
1691 } else {
1692 wcscpy(wszSubPath, pwszSubPath);
1693 }
1694
1695 if (szBasePath[cLen-1] != '/') szBasePath[cLen++] = '/';
1696
1697 if (!WideCharToMultiByte(CP_ACP, 0, wszSubPath, -1, szBasePath + cLen,
1698 FILENAME_MAX - cLen, NULL, NULL))
1699 {
1700 return FALSE;
1701 }
1702
1703 pBackslash = szBasePath + cLen;
1704 while ((pBackslash = strchr(pBackslash, '\\'))) *pBackslash = '/';
1705
1706 return TRUE;
1707 }
1708 #if 0
1709 /******************************************************************************
1710 * _SHCreateSymbolicLinks [Internal]
1711 *
1712 * Sets up symbol links for various shell folders to point into the users home
1713 * directory. We do an educated guess about what the user would probably want:
1714 * - If there is a 'My Documents' directory in $HOME, the user probably wants
1715 * wine's 'My Documents' to point there. Furthermore, we imply that the user
1716 * is a Windows lover and has no problem with wine creating 'My Pictures',
1717 * 'My Music' and 'My Video' subfolders under '$HOME/My Documents', if those
1718 * do not already exits. We put appropriate symbolic links in place for those,
1719 * too.
1720 * - If there is no 'My Documents' directory in $HOME, we let 'My Documents'
1721 * point directly to $HOME. We assume the user to be a unix hacker who does not
1722 * want wine to create anything anywhere besides the .wine directory. So, if
1723 * there already is a 'My Music' directory in $HOME, we symlink the 'My Music'
1724 * shell folder to it. But if not, we symlink it to $HOME directly. The same
1725 * holds fo 'My Pictures' and 'My Video'.
1726 * - The Desktop shell folder is symlinked to '$HOME/Desktop', if that does
1727 * exists and left alone if not.
1728 * ('My Music',... above in fact means LoadString(IDS_MYMUSIC))
1729 */
1730 static void _SHCreateSymbolicLinks(void)
1731 {
1732 UINT aidsMyStuff[] = { IDS_MYPICTURES, IDS_MYVIDEO, IDS_MYMUSIC }, i;
1733 int acsidlMyStuff[] = { CSIDL_MYPICTURES, CSIDL_MYVIDEO, CSIDL_MYMUSIC };
1734 WCHAR wszTempPath[MAX_PATH];
1735 char szPersonalTarget[FILENAME_MAX], *pszPersonal;
1736 char szMyStuffTarget[FILENAME_MAX], *pszMyStuff;
1737 char szDesktopTarget[FILENAME_MAX], *pszDesktop;
1738 struct stat statFolder;
1739 const char *pszHome;
1740 HRESULT hr;
1741
1742 /* Create all necessary profile sub-dirs up to 'My Documents' and get the unix path. */
1743 hr = SHGetFolderPathW(NULL, CSIDL_PERSONAL|CSIDL_FLAG_CREATE, NULL,
1744 SHGFP_TYPE_DEFAULT, wszTempPath);
1745 if (FAILED(hr)) return;
1746 pszPersonal = wine_get_unix_file_name(wszTempPath);
1747 if (!pszPersonal) return;
1748
1749 pszHome = getenv("HOME");
1750 if (pszHome && !stat(pszHome, &statFolder) && S_ISDIR(statFolder.st_mode)) {
1751 strcpy(szPersonalTarget, pszHome);
1752 if (_SHAppendToUnixPath(szPersonalTarget, MAKEINTRESOURCEW(IDS_PERSONAL)) &&
1753 !stat(szPersonalTarget, &statFolder) && S_ISDIR(statFolder.st_mode))
1754 {
1755 /* '$HOME/My Documents' exists. Create 'My Pictures', 'My Videos' and
1756 * 'My Music' subfolders or fail silently if they already exist. */
1757 for (i = 0; i < sizeof(aidsMyStuff)/sizeof(aidsMyStuff[0]); i++) {
1758 strcpy(szMyStuffTarget, szPersonalTarget);
1759 if (_SHAppendToUnixPath(szMyStuffTarget, MAKEINTRESOURCEW(aidsMyStuff[i])))
1760 mkdir(szMyStuffTarget);
1761 }
1762 }
1763 else
1764 {
1765 /* '$HOME/My Documents' doesn't exists, but '$HOME' does. */
1766 strcpy(szPersonalTarget, pszHome);
1767 }
1768
1769 /* Replace 'My Documents' directory with a symlink of fail silently if not empty. */
1770 rmdir(pszPersonal);
1771 symlink(szPersonalTarget, pszPersonal);
1772 }
1773 else
1774 {
1775 /* '$HOME' doesn't exist. Create 'My Pictures', 'My Videos' and 'My Music' subdirs
1776 * in '%USERPROFILE%\\My Documents' or fail silently if they already exist. */
1777 strcpy(szPersonalTarget, pszPersonal);
1778 for (i = 0; i < sizeof(aidsMyStuff)/sizeof(aidsMyStuff[0]); i++) {
1779 strcpy(szMyStuffTarget, szPersonalTarget);
1780 if (_SHAppendToUnixPath(szMyStuffTarget, MAKEINTRESOURCEW(aidsMyStuff[i])))
1781 mkdir(szMyStuffTarget);
1782 }
1783 }
1784
1785 /* Create symbolic links for 'My Pictures', 'My Video' and 'My Music'. */
1786 for (i=0; i < sizeof(aidsMyStuff)/sizeof(aidsMyStuff[0]); i++) {
1787 /* Create the current 'My Whatever' folder and get it's unix path. */
1788 hr = SHGetFolderPathW(NULL, acsidlMyStuff[i]|CSIDL_FLAG_CREATE, NULL,
1789 SHGFP_TYPE_DEFAULT, wszTempPath);
1790 if (FAILED(hr)) continue;
1791 pszMyStuff = wine_get_unix_file_name(wszTempPath);
1792 if (!pszMyStuff) continue;
1793
1794 strcpy(szMyStuffTarget, szPersonalTarget);
1795 if (_SHAppendToUnixPath(szMyStuffTarget, MAKEINTRESOURCEW(aidsMyStuff[i])) &&
1796 !stat(szMyStuffTarget, &statFolder) && S_ISDIR(statFolder.st_mode))
1797 {
1798 /* If there's a 'My Whatever' directory where 'My Documents' links to, link to it. */
1799 rmdir(pszMyStuff);
1800 symlink(szMyStuffTarget, pszMyStuff);
1801 }
1802 else
1803 {
1804 /* Else link to where 'My Documents' itself links to. */
1805 rmdir(pszMyStuff);
1806 symlink(szPersonalTarget, pszMyStuff);
1807 }
1808 HeapFree(GetProcessHeap(), 0, pszMyStuff);
1809 }
1810
1811 /* Last but not least, the Desktop folder */
1812 if (pszHome)
1813 strcpy(szDesktopTarget, pszHome);
1814 else
1815 strcpy(szDesktopTarget, pszPersonal);
1816 HeapFree(GetProcessHeap(), 0, pszPersonal);
1817
1818 if (_SHAppendToUnixPath(szDesktopTarget, DesktopW) &&
1819 !stat(szDesktopTarget, &statFolder) && S_ISDIR(statFolder.st_mode))
1820 {
1821 hr = SHGetFolderPathW(NULL, CSIDL_DESKTOPDIRECTORY|CSIDL_FLAG_CREATE, NULL,
1822 SHGFP_TYPE_DEFAULT, wszTempPath);
1823 if (SUCCEEDED(hr) && (pszDesktop = wine_get_unix_file_name(wszTempPath)))
1824 {
1825 rmdir(pszDesktop);
1826 symlink(szDesktopTarget, pszDesktop);
1827 HeapFree(GetProcessHeap(), 0, pszDesktop);
1828 }
1829 }
1830 }
1831 #endif
1832
1833 /* Register the default values in the registry, as some apps seem to depend
1834 * on their presence. The set registered was taken from Windows XP.
1835 */
1836 HRESULT SHELL_RegisterShellFolders(void)
1837 {
1838 HRESULT hr;
1839
1840 /* Set up '$HOME' targeted symlinks for 'My Documents', 'My Pictures',
1841 * 'My Video', 'My Music' and 'Desktop' in advance, so that the
1842 * _SHRegister*ShellFolders() functions will find everything nice and clean
1843 * and thus will not attempt to create them in the profile directory. */
1844 #if 0
1845 _SHCreateSymbolicLinks();
1846 #endif
1847
1848 hr = _SHRegisterUserShellFolders(TRUE);
1849 if (SUCCEEDED(hr))
1850 hr = _SHRegisterUserShellFolders(FALSE);
1851 if (SUCCEEDED(hr))
1852 hr = _SHRegisterCommonShellFolders();
1853 return hr;
1854 }
1855
1856 /*************************************************************************
1857 * SHGetSpecialFolderPathA [SHELL32.@]
1858 */
1859 BOOL WINAPI SHGetSpecialFolderPathA (
1860 HWND hwndOwner,
1861 LPSTR szPath,
1862 int nFolder,
1863 BOOL bCreate)
1864 {
1865 return (SHGetFolderPathA(
1866 hwndOwner,
1867 nFolder + (bCreate ? CSIDL_FLAG_CREATE : 0),
1868 NULL,
1869 0,
1870 szPath)) == S_OK ? TRUE : FALSE;
1871 }
1872
1873 /*************************************************************************
1874 * SHGetSpecialFolderPathW
1875 */
1876 BOOL WINAPI SHGetSpecialFolderPathW (
1877 HWND hwndOwner,
1878 LPWSTR szPath,
1879 int nFolder,
1880 BOOL bCreate)
1881 {
1882 return (SHGetFolderPathW(
1883 hwndOwner,
1884 nFolder + (bCreate ? CSIDL_FLAG_CREATE : 0),
1885 NULL,
1886 0,
1887 szPath)) == S_OK ? TRUE : FALSE;
1888 }
1889
1890 /*************************************************************************
1891 * SHGetFolderLocation [SHELL32.@]
1892 *
1893 * Gets the folder locations from the registry and creates a pidl.
1894 *
1895 * PARAMS
1896 * hwndOwner [I]
1897 * nFolder [I] CSIDL_xxxxx
1898 * hToken [I] token representing user, or NULL for current user, or -1 for
1899 * default user
1900 * dwReserved [I] must be zero
1901 * ppidl [O] PIDL of a special folder
1902 *
1903 * RETURNS
1904 * Success: S_OK
1905 * Failure: Standard OLE-defined error result, S_FALSE or E_INVALIDARG
1906 *
1907 * NOTES
1908 * Creates missing reg keys and directories.
1909 * Mostly forwards to SHGetFolderPathW, but a few values of nFolder return
1910 * virtual folders that are handled here.
1911 */
1912 HRESULT WINAPI SHGetFolderLocation(
1913 HWND hwndOwner,
1914 int nFolder,
1915 HANDLE hToken,
1916 DWORD dwReserved,
1917 LPITEMIDLIST *ppidl)
1918 {
1919 HRESULT hr = E_INVALIDARG;
1920
1921 TRACE("%p 0x%08x %p 0x%08x %p\n",
1922 hwndOwner, nFolder, hToken, dwReserved, ppidl);
1923
1924 if (!ppidl)
1925 return E_INVALIDARG;
1926 if (dwReserved)
1927 return E_INVALIDARG;
1928
1929 /* The virtual folders' locations are not user-dependent */
1930 *ppidl = NULL;
1931 switch (nFolder)
1932 {
1933 case CSIDL_DESKTOP:
1934 *ppidl = _ILCreateDesktop();
1935 break;
1936
1937 case CSIDL_PERSONAL:
1938 *ppidl = _ILCreateMyDocuments();
1939 break;
1940
1941 case CSIDL_INTERNET:
1942 *ppidl = _ILCreateIExplore();
1943 break;
1944
1945 case CSIDL_CONTROLS:
1946 *ppidl = _ILCreateControlPanel();
1947 break;
1948
1949 case CSIDL_PRINTERS:
1950 *ppidl = _ILCreatePrinters();
1951 break;
1952
1953 case CSIDL_BITBUCKET:
1954 *ppidl = _ILCreateBitBucket();
1955 break;
1956
1957 case CSIDL_DRIVES:
1958 *ppidl = _ILCreateMyComputer();
1959 break;
1960
1961 case CSIDL_NETWORK:
1962 *ppidl = _ILCreateNetwork();
1963 break;
1964
1965 default:
1966 {
1967 WCHAR szPath[MAX_PATH];
1968
1969 hr = SHGetFolderPathW(hwndOwner, nFolder, hToken,
1970 SHGFP_TYPE_CURRENT, szPath);
1971 if (SUCCEEDED(hr))
1972 {
1973 DWORD attributes=0;
1974
1975 TRACE("Value=%s\n", debugstr_w(szPath));
1976 hr = SHILCreateFromPathW(szPath, ppidl, &attributes);
1977 }
1978 else if (hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND))
1979 {
1980 /* unlike SHGetFolderPath, SHGetFolderLocation in shell32
1981 * version 6.0 returns E_FAIL for nonexistent paths
1982 */
1983 hr = E_FAIL;
1984 }
1985 }
1986 }
1987 if(*ppidl)
1988 hr = NOERROR;
1989
1990 TRACE("-- (new pidl %p)\n",*ppidl);
1991 return hr;
1992 }
1993
1994 /*************************************************************************
1995 * SHGetSpecialFolderLocation [SHELL32.@]
1996 *
1997 * NOTES
1998 * In NT5, SHGetSpecialFolderLocation needs the <winntdir>/Recent
1999 * directory.
2000 */
2001 HRESULT WINAPI SHGetSpecialFolderLocation(
2002 HWND hwndOwner,
2003 INT nFolder,
2004 LPITEMIDLIST * ppidl)
2005 {
2006 HRESULT hr = E_INVALIDARG;
2007
2008 TRACE("(%p,0x%x,%p)\n", hwndOwner,nFolder,ppidl);
2009
2010 if (!ppidl)
2011 return E_INVALIDARG;
2012
2013 hr = SHGetFolderLocation(hwndOwner, nFolder, NULL, 0, ppidl);
2014 return hr;
2015 }