1c070f1e6cd60962ff0b8df43831c5b106f1ad6e
[reactos.git] / reactos / lib / shlwapi / path.c
1 /*
2 * Path Functions
3 *
4 * Copyright 1999, 2000 Juergen Schmied
5 * Copyright 2001, 2002 Jon Griffiths
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 */
21
22 #include "config.h"
23 #include "wine/port.h"
24
25 #include <stdarg.h>
26 #include <string.h>
27 #include <stdlib.h>
28
29 #include "wine/unicode.h"
30 #include "windef.h"
31 #include "winbase.h"
32 #include "wingdi.h"
33 #include "winuser.h"
34 #include "winreg.h"
35 #include "winternl.h"
36 #define NO_SHLWAPI_STREAM
37 #include "shlwapi.h"
38 #include "wine/debug.h"
39
40 WINE_DEFAULT_DEBUG_CHANNEL(shell);
41
42 /* Get a function pointer from a DLL handle */
43 #define GET_FUNC(func, module, name, fail) \
44 do { \
45 if (!func) { \
46 if (!SHLWAPI_h##module && !(SHLWAPI_h##module = LoadLibraryA(#module ".dll"))) return fail; \
47 func = (fn##func)GetProcAddress(SHLWAPI_h##module, name); \
48 if (!func) return fail; \
49 } \
50 } while (0)
51
52 /* DLL handles for late bound calls */
53 extern HMODULE SHLWAPI_hshell32;
54
55 /* Function pointers for GET_FUNC macro; these need to be global because of gcc bug */
56 typedef BOOL (WINAPI *fnpIsNetDrive)(int);
57 static fnpIsNetDrive pIsNetDrive;
58
59 HRESULT WINAPI SHGetWebFolderFilePathW(LPCWSTR,LPWSTR,DWORD);
60
61 /*************************************************************************
62 * PathAppendA [SHLWAPI.@]
63 *
64 * Append one path to another.
65 *
66 * PARAMS
67 * lpszPath [I/O] Initial part of path, and destination for output
68 * lpszAppend [I] Path to append
69 *
70 * RETURNS
71 * Success: TRUE. lpszPath contains the newly created path.
72 * Failure: FALSE, if either path is NULL, or PathCombineA() fails.
73 *
74 * NOTES
75 * lpszAppend must contain at least one backslash ('\') if not NULL.
76 * Because PathCombineA() is used to join the paths, the resulting
77 * path is also canonicalized.
78 */
79 BOOL WINAPI PathAppendA (LPSTR lpszPath, LPCSTR lpszAppend)
80 {
81 TRACE("(%s,%s)\n",debugstr_a(lpszPath), debugstr_a(lpszAppend));
82
83 if (lpszPath && lpszAppend)
84 {
85 if (!PathIsUNCA(lpszAppend))
86 while (*lpszAppend == '\\')
87 lpszAppend++;
88 if (PathCombineA(lpszPath, lpszPath, lpszAppend))
89 return TRUE;
90 }
91 return FALSE;
92 }
93
94 /*************************************************************************
95 * PathAppendW [SHLWAPI.@]
96 *
97 * See PathAppendA.
98 */
99 BOOL WINAPI PathAppendW(LPWSTR lpszPath, LPCWSTR lpszAppend)
100 {
101 TRACE("(%s,%s)\n",debugstr_w(lpszPath), debugstr_w(lpszAppend));
102
103 if (lpszPath && lpszAppend)
104 {
105 if (!PathIsUNCW(lpszAppend))
106 while (*lpszAppend == '\\')
107 lpszAppend++;
108 if (PathCombineW(lpszPath, lpszPath, lpszAppend))
109 return TRUE;
110 }
111 return FALSE;
112 }
113
114 /*************************************************************************
115 * PathCombineA [SHLWAPI.@]
116 *
117 * Combine two paths together.
118 *
119 * PARAMS
120 * lpszDest [O] Destination for combined path
121 * lpszDir [I] Directory path
122 * lpszFile [I] File path
123 *
124 * RETURNS
125 * Success: The output path
126 * Failure: NULL, if inputs are invalid.
127 *
128 * NOTES
129 * lpszDest should be at least MAX_PATH in size, and may point to the same
130 * memory location as lpszDir. The combined path is canonicalised.
131 */
132 LPSTR WINAPI PathCombineA(LPSTR lpszDest, LPCSTR lpszDir, LPCSTR lpszFile)
133 {
134 TRACE("(%p,%s,%s)\n", lpszDest, debugstr_a(lpszDir), debugstr_a(lpszFile));
135
136 if (!lpszDest || (!lpszDir && !lpszFile))
137 return NULL; /* Invalid parameters */
138 else
139 {
140 WCHAR szDest[MAX_PATH];
141 WCHAR szDir[MAX_PATH];
142 WCHAR szFile[MAX_PATH];
143 if (lpszDir)
144 MultiByteToWideChar(CP_ACP,0,lpszDir,-1,szDir,MAX_PATH);
145 if (lpszFile)
146 MultiByteToWideChar(CP_ACP,0,lpszFile,-1,szFile,MAX_PATH);
147 PathCombineW(szDest, lpszDir ? szDir : NULL, lpszFile ? szFile : NULL);
148 WideCharToMultiByte(CP_ACP,0,szDest,-1,lpszDest,MAX_PATH,0,0);
149 }
150 return lpszDest;
151 }
152
153 /*************************************************************************
154 * PathCombineW [SHLWAPI.@]
155 *
156 * See PathCombineA.
157 */
158 LPWSTR WINAPI PathCombineW(LPWSTR lpszDest, LPCWSTR lpszDir, LPCWSTR lpszFile)
159 {
160 WCHAR szTemp[MAX_PATH];
161 BOOL bUseBoth = FALSE, bStrip = FALSE;
162
163 TRACE("(%p,%s,%s)\n", lpszDest, debugstr_w(lpszDir), debugstr_w(lpszFile));
164
165 if (!lpszDest || (!lpszDir && !lpszFile))
166 return lpszDest; /* Invalid parameters */
167
168 if (!lpszFile || !*lpszFile)
169 {
170 /* Use dir only */
171 strncpyW(szTemp, lpszDir, MAX_PATH);
172 }
173 else if (!lpszDir || !*lpszDir || !PathIsRelativeW(lpszFile))
174 {
175 if (!lpszDir || !*lpszDir || *lpszFile != '\\' || PathIsUNCW(lpszFile))
176 {
177 /* Use file only */
178 strncpyW(szTemp, lpszFile, MAX_PATH);
179 }
180 else
181 {
182 bUseBoth = TRUE;
183 bStrip = TRUE;
184 }
185 }
186 else
187 bUseBoth = TRUE;
188
189 if (bUseBoth)
190 {
191 strncpyW(szTemp, lpszDir, MAX_PATH);
192 if (bStrip)
193 {
194 PathStripToRootW(szTemp);
195 lpszFile++; /* Skip '\' */
196 }
197 if (!PathAddBackslashW(szTemp))
198 return NULL;
199 if (strlenW(szTemp) + strlenW(lpszFile) >= MAX_PATH)
200 return NULL;
201 strcatW(szTemp, lpszFile);
202 }
203
204 PathCanonicalizeW(lpszDest, szTemp);
205 return lpszDest;
206 }
207
208 /*************************************************************************
209 * PathAddBackslashA [SHLWAPI.@]
210 *
211 * Append a backslash ('\') to a path if one doesn't exist.
212 *
213 * PARAMS
214 * lpszPath [I/O] The path to append a backslash to.
215 *
216 * RETURNS
217 * Success: The position of the last backslash in the path.
218 * Failure: NULL, if lpszPath is NULL or the path is too large.
219 */
220 LPSTR WINAPI PathAddBackslashA(LPSTR lpszPath)
221 {
222 size_t iLen;
223
224 TRACE("(%s)\n",debugstr_a(lpszPath));
225
226 if (!lpszPath || (iLen = strlen(lpszPath)) >= MAX_PATH)
227 return NULL;
228
229 if (iLen)
230 {
231 lpszPath += iLen;
232 if (lpszPath[-1] != '\\')
233 {
234 *lpszPath++ = '\\';
235 *lpszPath = '\0';
236 }
237 }
238 return lpszPath;
239 }
240
241 /*************************************************************************
242 * PathAddBackslashW [SHLWAPI.@]
243 *
244 * See PathAddBackslashA.
245 */
246 LPWSTR WINAPI PathAddBackslashW( LPWSTR lpszPath )
247 {
248 size_t iLen;
249
250 TRACE("(%s)\n",debugstr_w(lpszPath));
251
252 if (!lpszPath || (iLen = strlenW(lpszPath)) >= MAX_PATH)
253 return NULL;
254
255 if (iLen)
256 {
257 lpszPath += iLen;
258 if (lpszPath[-1] != '\\')
259 {
260 *lpszPath++ = '\\';
261 *lpszPath = '\0';
262 }
263 }
264 return lpszPath;
265 }
266
267 /*************************************************************************
268 * PathBuildRootA [SHLWAPI.@]
269 *
270 * Create a root drive string (e.g. "A:\") from a drive number.
271 *
272 * PARAMS
273 * lpszPath [O] Destination for the drive string
274 *
275 * RETURNS
276 * lpszPath
277 *
278 * NOTES
279 * If lpszPath is NULL or drive is invalid, nothing is written to lpszPath.
280 */
281 LPSTR WINAPI PathBuildRootA(LPSTR lpszPath, int drive)
282 {
283 TRACE("(%p,%d)\n", lpszPath, drive);
284
285 if (lpszPath && drive >= 0 && drive < 26)
286 {
287 lpszPath[0] = 'A' + drive;
288 lpszPath[1] = ':';
289 lpszPath[2] = '\\';
290 lpszPath[3] = '\0';
291 }
292 return lpszPath;
293 }
294
295 /*************************************************************************
296 * PathBuildRootW [SHLWAPI.@]
297 *
298 * See PathBuildRootA.
299 */
300 LPWSTR WINAPI PathBuildRootW(LPWSTR lpszPath, int drive)
301 {
302 TRACE("(%p,%d)\n", lpszPath, drive);
303
304 if (lpszPath && drive >= 0 && drive < 26)
305 {
306 lpszPath[0] = 'A' + drive;
307 lpszPath[1] = ':';
308 lpszPath[2] = '\\';
309 lpszPath[3] = '\0';
310 }
311 return lpszPath;
312 }
313
314 /*************************************************************************
315 * PathFindFileNameA [SHLWAPI.@]
316 *
317 * Locate the start of the file name in a path
318 *
319 * PARAMS
320 * lpszPath [I] Path to search
321 *
322 * RETURNS
323 * A pointer to the first character of the file name
324 */
325 LPSTR WINAPI PathFindFileNameA(LPCSTR lpszPath)
326 {
327 LPCSTR lastSlash = lpszPath;
328
329 TRACE("(%s)\n",debugstr_a(lpszPath));
330
331 while (lpszPath && *lpszPath)
332 {
333 if ((*lpszPath == '\\' || *lpszPath == '/' || *lpszPath == ':') &&
334 lpszPath[1] && lpszPath[1] != '\\' && lpszPath[1] != '/')
335 lastSlash = lpszPath + 1;
336 lpszPath = CharNextA(lpszPath);
337 }
338 return (LPSTR)lastSlash;
339 }
340
341 /*************************************************************************
342 * PathFindFileNameW [SHLWAPI.@]
343 *
344 * See PathFindFileNameA.
345 */
346 LPWSTR WINAPI PathFindFileNameW(LPCWSTR lpszPath)
347 {
348 LPCWSTR lastSlash = lpszPath;
349
350 TRACE("(%s)\n",debugstr_w(lpszPath));
351
352 while (lpszPath && *lpszPath)
353 {
354 if ((*lpszPath == '\\' || *lpszPath == '/' || *lpszPath == ':') &&
355 lpszPath[1] && lpszPath[1] != '\\' && lpszPath[1] != '/')
356 lastSlash = lpszPath + 1;
357 lpszPath = CharNextW(lpszPath);
358 }
359 return (LPWSTR)lastSlash;
360 }
361
362 /*************************************************************************
363 * PathFindExtensionA [SHLWAPI.@]
364 *
365 * Locate the start of the file extension in a path
366 *
367 * PARAMS
368 * lpszPath [I] The path to search
369 *
370 * RETURNS
371 * A pointer to the first character of the extension, the end of
372 * the string if the path has no extension, or NULL If lpszPath is NULL
373 */
374 LPSTR WINAPI PathFindExtensionA( LPCSTR lpszPath )
375 {
376 LPCSTR lastpoint = NULL;
377
378 TRACE("(%s)\n", debugstr_a(lpszPath));
379
380 if (lpszPath)
381 {
382 while (*lpszPath)
383 {
384 if (*lpszPath == '\\' || *lpszPath==' ')
385 lastpoint = NULL;
386 else if (*lpszPath == '.')
387 lastpoint = lpszPath;
388 lpszPath = CharNextA(lpszPath);
389 }
390 }
391 return (LPSTR)(lastpoint ? lastpoint : lpszPath);
392 }
393
394 /*************************************************************************
395 * PathFindExtensionW [SHLWAPI.@]
396 *
397 * See PathFindExtensionA.
398 */
399 LPWSTR WINAPI PathFindExtensionW( LPCWSTR lpszPath )
400 {
401 LPCWSTR lastpoint = NULL;
402
403 TRACE("(%s)\n", debugstr_w(lpszPath));
404
405 if (lpszPath)
406 {
407 while (*lpszPath)
408 {
409 if (*lpszPath == '\\' || *lpszPath==' ')
410 lastpoint = NULL;
411 else if (*lpszPath == '.')
412 lastpoint = lpszPath;
413 lpszPath = CharNextW(lpszPath);
414 }
415 }
416 return (LPWSTR)(lastpoint ? lastpoint : lpszPath);
417 }
418
419 /*************************************************************************
420 * PathGetArgsA [SHLWAPI.@]
421 *
422 * Find the next argument in a string delimited by spaces.
423 *
424 * PARAMS
425 * lpszPath [I] The string to search for arguments in
426 *
427 * RETURNS
428 * The start of the next argument in lpszPath, or NULL if lpszPath is NULL
429 *
430 * NOTES
431 * Spaces in quoted strings are ignored as delimiters.
432 */
433 LPSTR WINAPI PathGetArgsA(LPCSTR lpszPath)
434 {
435 BOOL bSeenQuote = FALSE;
436
437 TRACE("(%s)\n",debugstr_a(lpszPath));
438
439 if (lpszPath)
440 {
441 while (*lpszPath)
442 {
443 if ((*lpszPath==' ') && !bSeenQuote)
444 return (LPSTR)lpszPath + 1;
445 if (*lpszPath == '"')
446 bSeenQuote = !bSeenQuote;
447 lpszPath = CharNextA(lpszPath);
448 }
449 }
450 return (LPSTR)lpszPath;
451 }
452
453 /*************************************************************************
454 * PathGetArgsW [SHLWAPI.@]
455 *
456 * See PathGetArgsA.
457 */
458 LPWSTR WINAPI PathGetArgsW(LPCWSTR lpszPath)
459 {
460 BOOL bSeenQuote = FALSE;
461
462 TRACE("(%s)\n",debugstr_w(lpszPath));
463
464 if (lpszPath)
465 {
466 while (*lpszPath)
467 {
468 if ((*lpszPath==' ') && !bSeenQuote)
469 return (LPWSTR)lpszPath + 1;
470 if (*lpszPath == '"')
471 bSeenQuote = !bSeenQuote;
472 lpszPath = CharNextW(lpszPath);
473 }
474 }
475 return (LPWSTR)lpszPath;
476 }
477
478 /*************************************************************************
479 * PathGetDriveNumberA [SHLWAPI.@]
480 *
481 * Return the drive number from a path
482 *
483 * PARAMS
484 * lpszPath [I] Path to get the drive number from
485 *
486 * RETURNS
487 * Success: The drive number corresponding to the drive in the path
488 * Failure: -1, if lpszPath contains no valid drive
489 */
490 int WINAPI PathGetDriveNumberA(LPCSTR lpszPath)
491 {
492 TRACE ("(%s)\n",debugstr_a(lpszPath));
493
494 if (lpszPath && !IsDBCSLeadByte(*lpszPath) && lpszPath[1] == ':' &&
495 tolower(*lpszPath) >= 'a' && tolower(*lpszPath) <= 'z')
496 return tolower(*lpszPath) - 'a';
497 return -1;
498 }
499
500 /*************************************************************************
501 * PathGetDriveNumberW [SHLWAPI.@]
502 *
503 * See PathGetDriveNumberA.
504 */
505 int WINAPI PathGetDriveNumberW(LPCWSTR lpszPath)
506 {
507 TRACE ("(%s)\n",debugstr_w(lpszPath));
508
509 if (lpszPath && lpszPath[1] == ':' &&
510 tolowerW(*lpszPath) >= 'a' && tolowerW(*lpszPath) <= 'z')
511 return tolowerW(*lpszPath) - 'a';
512 return -1;
513 }
514
515 /*************************************************************************
516 * PathRemoveFileSpecA [SHLWAPI.@]
517 *
518 * Remove the file specification from a path.
519 *
520 * PARAMS
521 * lpszPath [I/O] Path to remove the file spec from
522 *
523 * RETURNS
524 * TRUE If the path was valid and modified
525 * FALSE Otherwise
526 */
527 BOOL WINAPI PathRemoveFileSpecA(LPSTR lpszPath)
528 {
529 LPSTR lpszFileSpec = lpszPath;
530 BOOL bModified = FALSE;
531
532 TRACE("(%s)\n",debugstr_a(lpszPath));
533
534 if(lpszPath)
535 {
536 /* Skip directory or UNC path */
537 if (*lpszPath == '\\')
538 lpszFileSpec = ++lpszPath;
539 if (*lpszPath == '\\')
540 lpszFileSpec = ++lpszPath;
541
542 while (*lpszPath)
543 {
544 if(*lpszPath == '\\')
545 lpszFileSpec = lpszPath; /* Skip dir */
546 else if(*lpszPath == ':')
547 {
548 lpszFileSpec = ++lpszPath; /* Skip drive */
549 if (*lpszPath == '\\')
550 lpszFileSpec++;
551 }
552 if (!(lpszPath = CharNextA(lpszPath)))
553 break;
554 }
555
556 if (*lpszFileSpec)
557 {
558 *lpszFileSpec = '\0';
559 bModified = TRUE;
560 }
561 }
562 return bModified;
563 }
564
565 /*************************************************************************
566 * PathRemoveFileSpecW [SHLWAPI.@]
567 *
568 * See PathRemoveFileSpecA.
569 */
570 BOOL WINAPI PathRemoveFileSpecW(LPWSTR lpszPath)
571 {
572 LPWSTR lpszFileSpec = lpszPath;
573 BOOL bModified = FALSE;
574
575 TRACE("(%s)\n",debugstr_w(lpszPath));
576
577 if(lpszPath)
578 {
579 /* Skip directory or UNC path */
580 if (*lpszPath == '\\')
581 lpszFileSpec = ++lpszPath;
582 if (*lpszPath == '\\')
583 lpszFileSpec = ++lpszPath;
584
585 while (*lpszPath)
586 {
587 if(*lpszPath == '\\')
588 lpszFileSpec = lpszPath; /* Skip dir */
589 else if(*lpszPath == ':')
590 {
591 lpszFileSpec = ++lpszPath; /* Skip drive */
592 if (*lpszPath == '\\')
593 lpszFileSpec++;
594 }
595 if (!(lpszPath = CharNextW(lpszPath)))
596 break;
597 }
598
599 if (*lpszFileSpec)
600 {
601 *lpszFileSpec = '\0';
602 bModified = TRUE;
603 }
604 }
605 return bModified;
606 }
607
608 /*************************************************************************
609 * PathStripPathA [SHLWAPI.@]
610 *
611 * Remove the initial path from the beginning of a filename
612 *
613 * PARAMS
614 * lpszPath [I/O] Path to remove the initial path from
615 *
616 * RETURNS
617 * Nothing.
618 */
619 void WINAPI PathStripPathA(LPSTR lpszPath)
620 {
621 TRACE("(%s)\n", debugstr_a(lpszPath));
622
623 if (lpszPath)
624 {
625 LPSTR lpszFileName = PathFindFileNameA(lpszPath);
626 if(lpszFileName)
627 RtlMoveMemory(lpszPath, lpszFileName, strlen(lpszFileName)+1);
628 }
629 }
630
631 /*************************************************************************
632 * PathStripPathW [SHLWAPI.@]
633 *
634 * See PathStripPathA.
635 */
636 void WINAPI PathStripPathW(LPWSTR lpszPath)
637 {
638 LPWSTR lpszFileName;
639
640 TRACE("(%s)\n", debugstr_w(lpszPath));
641 lpszFileName = PathFindFileNameW(lpszPath);
642 if(lpszFileName)
643 RtlMoveMemory(lpszPath, lpszFileName, (strlenW(lpszFileName)+1)*sizeof(WCHAR));
644 }
645
646 /*************************************************************************
647 * PathStripToRootA [SHLWAPI.@]
648 *
649 * Reduce a path to its root.
650 *
651 * PARAMS
652 * lpszPath [I/O] the path to reduce
653 *
654 * RETURNS
655 * Success: TRUE if the stripped path is a root path
656 * Failure: FALSE if the path cannot be stripped or is NULL
657 */
658 BOOL WINAPI PathStripToRootA(LPSTR lpszPath)
659 {
660 TRACE("(%s)\n", debugstr_a(lpszPath));
661
662 if (!lpszPath)
663 return FALSE;
664 while(!PathIsRootA(lpszPath))
665 if (!PathRemoveFileSpecA(lpszPath))
666 return FALSE;
667 return TRUE;
668 }
669
670 /*************************************************************************
671 * PathStripToRootW [SHLWAPI.@]
672 *
673 * See PathStripToRootA.
674 */
675 BOOL WINAPI PathStripToRootW(LPWSTR lpszPath)
676 {
677 TRACE("(%s)\n", debugstr_w(lpszPath));
678
679 if (!lpszPath)
680 return FALSE;
681 while(!PathIsRootW(lpszPath))
682 if (!PathRemoveFileSpecW(lpszPath))
683 return FALSE;
684 return TRUE;
685 }
686
687 /*************************************************************************
688 * PathRemoveArgsA [SHLWAPI.@]
689 *
690 * Strip space separated arguments from a path.
691 *
692 * PARAMS
693 * lpszPath [I/O] Path to remove arguments from
694 *
695 * RETURNS
696 * Nothing.
697 */
698 void WINAPI PathRemoveArgsA(LPSTR lpszPath)
699 {
700 TRACE("(%s)\n",debugstr_a(lpszPath));
701
702 if(lpszPath)
703 {
704 LPSTR lpszArgs = PathGetArgsA(lpszPath);
705 if (*lpszArgs)
706 lpszArgs[-1] = '\0';
707 else
708 {
709 LPSTR lpszLastChar = CharPrevA(lpszPath, lpszArgs);
710 if(*lpszLastChar == ' ')
711 *lpszLastChar = '\0';
712 }
713 }
714 }
715
716 /*************************************************************************
717 * PathRemoveArgsW [SHLWAPI.@]
718 *
719 * See PathRemoveArgsA.
720 */
721 void WINAPI PathRemoveArgsW(LPWSTR lpszPath)
722 {
723 TRACE("(%s)\n",debugstr_w(lpszPath));
724
725 if(lpszPath)
726 {
727 LPWSTR lpszArgs = PathGetArgsW(lpszPath);
728 if (*lpszArgs)
729 lpszArgs[-1] = '\0';
730 else
731 {
732 LPWSTR lpszLastChar = CharPrevW(lpszPath, lpszArgs);
733 if(*lpszLastChar == ' ')
734 *lpszLastChar = '\0';
735 }
736 }
737 }
738
739 /*************************************************************************
740 * PathRemoveExtensionA [SHLWAPI.@]
741 *
742 * Remove the file extension from a path
743 *
744 * PARAMS
745 * lpszPath [I/O] Path to remove the extension from
746 *
747 * RETURNS
748 * Nothing.
749 */
750 void WINAPI PathRemoveExtensionA(LPSTR lpszPath)
751 {
752 TRACE("(%s)\n", debugstr_a(lpszPath));
753
754 if (lpszPath)
755 {
756 lpszPath = PathFindExtensionA(lpszPath);
757 *lpszPath = '\0';
758 }
759 }
760
761 /*************************************************************************
762 * PathRemoveExtensionW [SHLWAPI.@]
763 *
764 * See PathRemoveExtensionA.
765 */
766 void WINAPI PathRemoveExtensionW(LPWSTR lpszPath)
767 {
768 TRACE("(%s)\n", debugstr_w(lpszPath));
769
770 if (lpszPath)
771 {
772 lpszPath = PathFindExtensionW(lpszPath);
773 *lpszPath = '\0';
774 }
775 }
776
777 /*************************************************************************
778 * PathRemoveBackslashA [SHLWAPI.@]
779 *
780 * Remove a trailing backslash from a path.
781 *
782 * PARAMS
783 * lpszPath [I/O] Path to remove backslash from
784 *
785 * RETURNS
786 * Success: A pointer to the end of the path
787 * Failure: NULL, if lpszPath is NULL
788 */
789 LPSTR WINAPI PathRemoveBackslashA( LPSTR lpszPath )
790 {
791 LPSTR szTemp = NULL;
792
793 TRACE("(%s)\n", debugstr_a(lpszPath));
794
795 if(lpszPath)
796 {
797 szTemp = CharPrevA(lpszPath, lpszPath + strlen(lpszPath));
798 if (!PathIsRootA(lpszPath) && *szTemp == '\\')
799 *szTemp = '\0';
800 }
801 return szTemp;
802 }
803
804 /*************************************************************************
805 * PathRemoveBackslashW [SHLWAPI.@]
806 *
807 * See PathRemoveBackslashA.
808 */
809 LPWSTR WINAPI PathRemoveBackslashW( LPWSTR lpszPath )
810 {
811 LPWSTR szTemp = NULL;
812
813 TRACE("(%s)\n", debugstr_w(lpszPath));
814
815 if(lpszPath)
816 {
817 szTemp = CharPrevW(lpszPath, lpszPath + strlenW(lpszPath));
818 if (!PathIsRootW(lpszPath) && *szTemp == '\\')
819 *szTemp = '\0';
820 }
821 return szTemp;
822 }
823
824 /*************************************************************************
825 * PathRemoveBlanksA [SHLWAPI.@]
826 *
827 * Remove Spaces from the start and end of a path.
828 *
829 * PARAMS
830 * lpszPath [I/O] Path to strip blanks from
831 *
832 * RETURNS
833 * Nothing.
834 */
835 VOID WINAPI PathRemoveBlanksA(LPSTR lpszPath)
836 {
837 TRACE("(%s)\n", debugstr_a(lpszPath));
838
839 if(lpszPath && *lpszPath)
840 {
841 LPSTR start = lpszPath;
842
843 while (*lpszPath == ' ')
844 lpszPath = CharNextA(lpszPath);
845
846 while(*lpszPath)
847 *start++ = *lpszPath++;
848
849 if (start != lpszPath)
850 while (start[-1] == ' ')
851 start--;
852 *start = '\0';
853 }
854 }
855
856 /*************************************************************************
857 * PathRemoveBlanksW [SHLWAPI.@]
858 *
859 * See PathRemoveBlanksA.
860 */
861 VOID WINAPI PathRemoveBlanksW(LPWSTR lpszPath)
862 {
863 TRACE("(%s)\n", debugstr_w(lpszPath));
864
865 if(lpszPath && *lpszPath)
866 {
867 LPWSTR start = lpszPath;
868
869 while (*lpszPath == ' ')
870 lpszPath++;
871
872 while(*lpszPath)
873 *start++ = *lpszPath++;
874
875 if (start != lpszPath)
876 while (start[-1] == ' ')
877 start--;
878 *start = '\0';
879 }
880 }
881
882 /*************************************************************************
883 * PathQuoteSpacesA [SHLWAPI.@]
884 *
885 * Surround a path containg spaces in quotes.
886 *
887 * PARAMS
888 * lpszPath [I/O] Path to quote
889 *
890 * RETURNS
891 * Nothing.
892 *
893 * NOTES
894 * The path is not changed if it is invalid or has no spaces.
895 */
896 VOID WINAPI PathQuoteSpacesA(LPSTR lpszPath)
897 {
898 TRACE("(%s)\n", debugstr_a(lpszPath));
899
900 if(lpszPath && StrChrA(lpszPath,' '))
901 {
902 size_t iLen = strlen(lpszPath) + 1;
903
904 if (iLen + 2 < MAX_PATH)
905 {
906 memmove(lpszPath + 1, lpszPath, iLen);
907 lpszPath[0] = '"';
908 lpszPath[iLen] = '"';
909 lpszPath[iLen + 1] = '\0';
910 }
911 }
912 }
913
914 /*************************************************************************
915 * PathQuoteSpacesW [SHLWAPI.@]
916 *
917 * See PathQuoteSpacesA.
918 */
919 VOID WINAPI PathQuoteSpacesW(LPWSTR lpszPath)
920 {
921 TRACE("(%s)\n", debugstr_w(lpszPath));
922
923 if(lpszPath && StrChrW(lpszPath,' '))
924 {
925 int iLen = strlenW(lpszPath) + 1;
926
927 if (iLen + 2 < MAX_PATH)
928 {
929 memmove(lpszPath + 1, lpszPath, iLen * sizeof(WCHAR));
930 lpszPath[0] = '"';
931 lpszPath[iLen] = '"';
932 lpszPath[iLen + 1] = '\0';
933 }
934 }
935 }
936
937 /*************************************************************************
938 * PathUnquoteSpacesA [SHLWAPI.@]
939 *
940 * Remove quotes ("") from around a path, if present.
941 *
942 * PARAMS
943 * lpszPath [I/O] Path to strip quotes from
944 *
945 * RETURNS
946 * Nothing
947 *
948 * NOTES
949 * If the path contains a single quote only, an empty string will result.
950 * Otherwise quotes are only removed if they appear at the start and end
951 * of the path.
952 */
953 VOID WINAPI PathUnquoteSpacesA(LPSTR lpszPath)
954 {
955 TRACE("(%s)\n", debugstr_a(lpszPath));
956
957 if (lpszPath && *lpszPath == '"')
958 {
959 DWORD dwLen = strlen(lpszPath) - 1;
960
961 if (lpszPath[dwLen] == '"')
962 {
963 lpszPath[dwLen] = '\0';
964 for (; *lpszPath; lpszPath++)
965 *lpszPath = lpszPath[1];
966 }
967 }
968 }
969
970 /*************************************************************************
971 * PathUnquoteSpacesW [SHLWAPI.@]
972 *
973 * See PathUnquoteSpacesA.
974 */
975 VOID WINAPI PathUnquoteSpacesW(LPWSTR lpszPath)
976 {
977 TRACE("(%s)\n", debugstr_w(lpszPath));
978
979 if (lpszPath && *lpszPath == '"')
980 {
981 DWORD dwLen = strlenW(lpszPath) - 1;
982
983 if (lpszPath[dwLen] == '"')
984 {
985 lpszPath[dwLen] = '\0';
986 for (; *lpszPath; lpszPath++)
987 *lpszPath = lpszPath[1];
988 }
989 }
990 }
991
992 /*************************************************************************
993 * PathParseIconLocationA [SHLWAPI.@]
994 *
995 * Parse the location of an icon from a path.
996 *
997 * PARAMS
998 * lpszPath [I/O] The path to parse the icon location from.
999 *
1000 * RETURNS
1001 * Success: The number of the icon
1002 * Failure: 0 if the path does not contain an icon location or is NULL
1003 *
1004 * NOTES
1005 * The path has surrounding quotes and spaces removed regardless
1006 * of whether the call succeeds or not.
1007 */
1008 int WINAPI PathParseIconLocationA(LPSTR lpszPath)
1009 {
1010 int iRet = 0;
1011 LPSTR lpszComma;
1012
1013 TRACE("(%s)\n", debugstr_a(lpszPath));
1014
1015 if (lpszPath)
1016 {
1017 if ((lpszComma = strchr(lpszPath, ',')))
1018 {
1019 *lpszComma++ = '\0';
1020 iRet = StrToIntA(lpszComma);
1021 }
1022 PathUnquoteSpacesA(lpszPath);
1023 PathRemoveBlanksA(lpszPath);
1024 }
1025 return iRet;
1026 }
1027
1028 /*************************************************************************
1029 * PathParseIconLocationW [SHLWAPI.@]
1030 *
1031 * See PathParseIconLocationA.
1032 */
1033 int WINAPI PathParseIconLocationW(LPWSTR lpszPath)
1034 {
1035 int iRet = 0;
1036 LPWSTR lpszComma;
1037
1038 TRACE("(%s)\n", debugstr_w(lpszPath));
1039
1040 if (lpszPath)
1041 {
1042 if ((lpszComma = StrChrW(lpszPath, ',')))
1043 {
1044 *lpszComma++ = '\0';
1045 iRet = StrToIntW(lpszComma);
1046 }
1047 PathUnquoteSpacesW(lpszPath);
1048 PathRemoveBlanksW(lpszPath);
1049 }
1050 return iRet;
1051 }
1052
1053 /*************************************************************************
1054 * @ [SHLWAPI.4]
1055 *
1056 * Unicode version of PathFileExistsDefExtA.
1057 */
1058 BOOL WINAPI PathFileExistsDefExtW(LPWSTR lpszPath,DWORD dwWhich)
1059 {
1060 static const WCHAR pszExts[7][5] = { { '.', 'p', 'i', 'f', 0},
1061 { '.', 'c', 'o', 'm', 0},
1062 { '.', 'e', 'x', 'e', 0},
1063 { '.', 'b', 'a', 't', 0},
1064 { '.', 'l', 'n', 'k', 0},
1065 { '.', 'c', 'm', 'd', 0},
1066 { 0, 0, 0, 0, 0} };
1067
1068 TRACE("(%s,%ld)\n", debugstr_w(lpszPath), dwWhich);
1069
1070 if (!lpszPath || PathIsUNCServerW(lpszPath) || PathIsUNCServerShareW(lpszPath))
1071 return FALSE;
1072
1073 if (dwWhich)
1074 {
1075 LPCWSTR szExt = PathFindExtensionW(lpszPath);
1076 if (!*szExt || dwWhich & 0x40)
1077 {
1078 size_t iChoose = 0;
1079 int iLen = lstrlenW(lpszPath);
1080 if (iLen > (MAX_PATH - 5))
1081 return FALSE;
1082 while ( (dwWhich & 0x1) && pszExts[iChoose][0] )
1083 {
1084 lstrcpyW(lpszPath + iLen, pszExts[iChoose]);
1085 if (PathFileExistsW(lpszPath))
1086 return TRUE;
1087 iChoose++;
1088 dwWhich >>= 1;
1089 }
1090 *(lpszPath + iLen) = (WCHAR)'\0';
1091 return FALSE;
1092 }
1093 }
1094 return PathFileExistsW(lpszPath);
1095 }
1096
1097 /*************************************************************************
1098 * @ [SHLWAPI.3]
1099 *
1100 * Determine if a file exists locally and is of an executable type.
1101 *
1102 * PARAMS
1103 * lpszPath [I/O] File to search for
1104 * dwWhich [I] Type of executable to search for
1105 *
1106 * RETURNS
1107 * TRUE If the file was found. lpszPath contains the file name.
1108 * FALSE Otherwise.
1109 *
1110 * NOTES
1111 * lpszPath is modified in place and must be at least MAX_PATH in length.
1112 * If the function returns FALSE, the path is modified to its orginal state.
1113 * If the given path contains an extension or dwWhich is 0, executable
1114 * extensions are not checked.
1115 *
1116 * Ordinals 3-6 are a classic case of MS exposing limited functionality to
1117 * users (here through PathFindOnPathA()) and keeping advanced functionality for
1118 * their own developers exclusive use. Monopoly, anyone?
1119 */
1120 BOOL WINAPI PathFileExistsDefExtA(LPSTR lpszPath,DWORD dwWhich)
1121 {
1122 BOOL bRet = FALSE;
1123
1124 TRACE("(%s,%ld)\n", debugstr_a(lpszPath), dwWhich);
1125
1126 if (lpszPath)
1127 {
1128 WCHAR szPath[MAX_PATH];
1129 MultiByteToWideChar(CP_ACP,0,lpszPath,-1,szPath,MAX_PATH);
1130 bRet = PathFileExistsDefExtW(szPath, dwWhich);
1131 if (bRet)
1132 WideCharToMultiByte(CP_ACP,0,szPath,-1,lpszPath,MAX_PATH,0,0);
1133 }
1134 return bRet;
1135 }
1136
1137 /*************************************************************************
1138 * SHLWAPI_PathFindInOtherDirs
1139 *
1140 * Internal helper for SHLWAPI_PathFindOnPathExA/W.
1141 */
1142 static BOOL WINAPI SHLWAPI_PathFindInOtherDirs(LPWSTR lpszFile, DWORD dwWhich)
1143 {
1144 static const WCHAR szSystem[] = { 'S','y','s','t','e','m','\0'};
1145 static const WCHAR szPath[] = { 'P','A','T','H','\0'};
1146 DWORD dwLenPATH;
1147 LPCWSTR lpszCurr;
1148 WCHAR *lpszPATH;
1149 WCHAR buff[MAX_PATH];
1150
1151 TRACE("(%s,%08lx)\n", debugstr_w(lpszFile), dwWhich);
1152
1153 /* Try system directories */
1154 GetSystemDirectoryW(buff, MAX_PATH);
1155 if (!PathAppendW(buff, lpszFile))
1156 return FALSE;
1157 if (PathFileExistsDefExtW(buff, dwWhich))
1158 {
1159 strcpyW(lpszFile, buff);
1160 return TRUE;
1161 }
1162 GetWindowsDirectoryW(buff, MAX_PATH);
1163 if (!PathAppendW(buff, szSystem ) || !PathAppendW(buff, lpszFile))
1164 return FALSE;
1165 if (PathFileExistsDefExtW(buff, dwWhich))
1166 {
1167 strcpyW(lpszFile, buff);
1168 return TRUE;
1169 }
1170 GetWindowsDirectoryW(buff, MAX_PATH);
1171 if (!PathAppendW(buff, lpszFile))
1172 return FALSE;
1173 if (PathFileExistsDefExtW(buff, dwWhich))
1174 {
1175 strcpyW(lpszFile, buff);
1176 return TRUE;
1177 }
1178 /* Try dirs listed in %PATH% */
1179 dwLenPATH = GetEnvironmentVariableW(szPath, buff, MAX_PATH);
1180
1181 if (!dwLenPATH || !(lpszPATH = malloc((dwLenPATH + 1) * sizeof (WCHAR))))
1182 return FALSE;
1183
1184 GetEnvironmentVariableW(szPath, lpszPATH, dwLenPATH + 1);
1185 lpszCurr = lpszPATH;
1186 while (lpszCurr)
1187 {
1188 LPCWSTR lpszEnd = lpszCurr;
1189 LPWSTR pBuff = buff;
1190
1191 while (*lpszEnd == ' ')
1192 lpszEnd++;
1193 while (*lpszEnd && *lpszEnd != ';')
1194 *pBuff++ = *lpszEnd++;
1195 *pBuff = '\0';
1196
1197 if (*lpszEnd)
1198 lpszCurr = lpszEnd + 1;
1199 else
1200 lpszCurr = NULL; /* Last Path, terminate after this */
1201
1202 if (!PathAppendW(buff, lpszFile))
1203 {
1204 free(lpszPATH);
1205 return FALSE;
1206 }
1207 if (PathFileExistsDefExtW(buff, dwWhich))
1208 {
1209 strcpyW(lpszFile, buff);
1210 free(lpszPATH);
1211 return TRUE;
1212 }
1213 }
1214 free(lpszPATH);
1215 return FALSE;
1216 }
1217
1218 /*************************************************************************
1219 * @ [SHLWAPI.5]
1220 *
1221 * Search a range of paths for a specific type of executable.
1222 *
1223 * PARAMS
1224 * lpszFile [I/O] File to search for
1225 * lppszOtherDirs [I] Other directories to look in
1226 * dwWhich [I] Type of executable to search for
1227 *
1228 * RETURNS
1229 * Success: TRUE. The path to the executable is stored in lpszFile.
1230 * Failure: FALSE. The path to the executable is unchanged.
1231 */
1232 BOOL WINAPI PathFindOnPathExA(LPSTR lpszFile,LPCSTR *lppszOtherDirs,DWORD dwWhich)
1233 {
1234 WCHAR szFile[MAX_PATH];
1235 WCHAR buff[MAX_PATH];
1236
1237 TRACE("(%s,%p,%08lx)\n", debugstr_a(lpszFile), lppszOtherDirs, dwWhich);
1238
1239 if (!lpszFile || !PathIsFileSpecA(lpszFile))
1240 return FALSE;
1241
1242 MultiByteToWideChar(CP_ACP,0,lpszFile,-1,szFile,MAX_PATH);
1243
1244 /* Search provided directories first */
1245 if (lppszOtherDirs && *lppszOtherDirs)
1246 {
1247 WCHAR szOther[MAX_PATH];
1248 LPCSTR *lpszOtherPath = lppszOtherDirs;
1249
1250 while (lpszOtherPath && *lpszOtherPath && (*lpszOtherPath)[0])
1251 {
1252 MultiByteToWideChar(CP_ACP,0,*lpszOtherPath,-1,szOther,MAX_PATH);
1253 PathCombineW(buff, szOther, szFile);
1254 if (PathFileExistsDefExtW(buff, dwWhich))
1255 {
1256 WideCharToMultiByte(CP_ACP,0,buff,-1,lpszFile,MAX_PATH,0,0);
1257 return TRUE;
1258 }
1259 lpszOtherPath++;
1260 }
1261 }
1262 /* Not found, try system and path dirs */
1263 if (SHLWAPI_PathFindInOtherDirs(szFile, dwWhich))
1264 {
1265 WideCharToMultiByte(CP_ACP,0,szFile,-1,lpszFile,MAX_PATH,0,0);
1266 return TRUE;
1267 }
1268 return FALSE;
1269 }
1270
1271 /*************************************************************************
1272 * @ [SHLWAPI.6]
1273 *
1274 * Unicode version of PathFindOnPathExA.
1275 */
1276 BOOL WINAPI PathFindOnPathExW(LPWSTR lpszFile,LPCWSTR *lppszOtherDirs,DWORD dwWhich)
1277 {
1278 WCHAR buff[MAX_PATH];
1279
1280 TRACE("(%s,%p,%08lx)\n", debugstr_w(lpszFile), lppszOtherDirs, dwWhich);
1281
1282 if (!lpszFile || !PathIsFileSpecW(lpszFile))
1283 return FALSE;
1284
1285 /* Search provided directories first */
1286 if (lppszOtherDirs && *lppszOtherDirs)
1287 {
1288 LPCWSTR *lpszOtherPath = lppszOtherDirs;
1289 while (lpszOtherPath && *lpszOtherPath && (*lpszOtherPath)[0])
1290 {
1291 PathCombineW(buff, *lpszOtherPath, lpszFile);
1292 if (PathFileExistsDefExtW(buff, dwWhich))
1293 {
1294 strcpyW(lpszFile, buff);
1295 return TRUE;
1296 }
1297 lpszOtherPath++;
1298 }
1299 }
1300 /* Not found, try system and path dirs */
1301 return SHLWAPI_PathFindInOtherDirs(lpszFile, dwWhich);
1302 }
1303
1304 /*************************************************************************
1305 * PathFindOnPathA [SHLWAPI.@]
1306 *
1307 * Search a range of paths for an executable.
1308 *
1309 * PARAMS
1310 * lpszFile [I/O] File to search for
1311 * lppszOtherDirs [I] Other directories to look in
1312 *
1313 * RETURNS
1314 * Success: TRUE. The path to the executable is stored in lpszFile.
1315 * Failure: FALSE. The path to the executable is unchanged.
1316 */
1317 BOOL WINAPI PathFindOnPathA(LPSTR lpszFile, LPCSTR *lppszOtherDirs)
1318 {
1319 TRACE("(%s,%p)\n", debugstr_a(lpszFile), lppszOtherDirs);
1320 return PathFindOnPathExA(lpszFile, lppszOtherDirs, 0);
1321 }
1322
1323 /*************************************************************************
1324 * PathFindOnPathW [SHLWAPI.@]
1325 *
1326 * See PathFindOnPathA.
1327 */
1328 BOOL WINAPI PathFindOnPathW(LPWSTR lpszFile, LPCWSTR *lppszOtherDirs)
1329 {
1330 TRACE("(%s,%p)\n", debugstr_w(lpszFile), lppszOtherDirs);
1331 return PathFindOnPathExW(lpszFile,lppszOtherDirs, 0);
1332 }
1333
1334 /*************************************************************************
1335 * PathCompactPathExA [SHLWAPI.@]
1336 *
1337 * Compact a path into a given number of characters.
1338 *
1339 * PARAMS
1340 * lpszDest [O] Destination for compacted path
1341 * lpszPath [I] Source path
1342 * cchMax [I] Maximum size of compacted path
1343 * dwFlags [I] Reserved
1344 *
1345 * RETURNS
1346 * Success: TRUE. The compacted path is written to lpszDest.
1347 * Failure: FALSE. lpszPath is undefined.
1348 *
1349 * NOTES
1350 * If cchMax is given as 0, lpszDest will still be NUL terminated.
1351 *
1352 * The Win32 version of this function contains a bug: When cchMax == 7,
1353 * 8 bytes will be written to lpszDest. This bug is fixed in the Wine
1354 * implementation.
1355 *
1356 * Some relative paths will be different when cchMax == 5 or 6. This occurs
1357 * because Win32 will insert a "\" in lpszDest, even if one is
1358 * not present in the original path.
1359 */
1360 BOOL WINAPI PathCompactPathExA(LPSTR lpszDest, LPCSTR lpszPath,
1361 UINT cchMax, DWORD dwFlags)
1362 {
1363 BOOL bRet = FALSE;
1364
1365 TRACE("(%p,%s,%d,0x%08lx)\n", lpszDest, debugstr_a(lpszPath), cchMax, dwFlags);
1366
1367 if (lpszPath && lpszDest)
1368 {
1369 WCHAR szPath[MAX_PATH];
1370 WCHAR szDest[MAX_PATH];
1371
1372 MultiByteToWideChar(CP_ACP,0,lpszPath,-1,szPath,MAX_PATH);
1373 szDest[0] = '\0';
1374 bRet = PathCompactPathExW(szDest, szPath, cchMax, dwFlags);
1375 WideCharToMultiByte(CP_ACP,0,szDest,-1,lpszDest,MAX_PATH,0,0);
1376 }
1377 return bRet;
1378 }
1379
1380 /*************************************************************************
1381 * PathCompactPathExW [SHLWAPI.@]
1382 *
1383 * See PathCompactPathExA.
1384 */
1385 BOOL WINAPI PathCompactPathExW(LPWSTR lpszDest, LPCWSTR lpszPath,
1386 UINT cchMax, DWORD dwFlags)
1387 {
1388 static const WCHAR szEllipses[] = { '.', '.', '.', '\0' };
1389 LPCWSTR lpszFile;
1390 DWORD dwLen, dwFileLen = 0;
1391
1392 TRACE("(%p,%s,%d,0x%08lx)\n", lpszDest, debugstr_w(lpszPath), cchMax, dwFlags);
1393
1394 if (!lpszPath)
1395 return FALSE;
1396
1397 if (!lpszDest)
1398 {
1399 WARN("Invalid lpszDest would crash under Win32!\n");
1400 return FALSE;
1401 }
1402
1403 *lpszDest = '\0';
1404
1405 if (cchMax < 2)
1406 return TRUE;
1407
1408 dwLen = strlenW(lpszPath) + 1;
1409
1410 if (dwLen < cchMax)
1411 {
1412 /* Don't need to compact */
1413 memcpy(lpszDest, lpszPath, dwLen * sizeof(WCHAR));
1414 return TRUE;
1415 }
1416
1417 /* Path must be compacted to fit into lpszDest */
1418 lpszFile = PathFindFileNameW(lpszPath);
1419 dwFileLen = lpszPath + dwLen - lpszFile;
1420
1421 if (dwFileLen == dwLen)
1422 {
1423 /* No root in psth */
1424 if (cchMax <= 4)
1425 {
1426 while (--cchMax > 0) /* No room left for anything but ellipses */
1427 *lpszDest++ = '.';
1428 *lpszDest = '\0';
1429 return TRUE;
1430 }
1431 /* Compact the file name with ellipses at the end */
1432 cchMax -= 4;
1433 memcpy(lpszDest, lpszFile, cchMax * sizeof(WCHAR));
1434 strcpyW(lpszDest + cchMax, szEllipses);
1435 return TRUE;
1436 }
1437 /* We have a root in the path */
1438 lpszFile--; /* Start compacted filename with the path separator */
1439 dwFileLen++;
1440
1441 if (dwFileLen + 3 > cchMax)
1442 {
1443 /* Compact the file name */
1444 if (cchMax <= 4)
1445 {
1446 while (--cchMax > 0) /* No room left for anything but ellipses */
1447 *lpszDest++ = '.';
1448 *lpszDest = '\0';
1449 return TRUE;
1450 }
1451 strcpyW(lpszDest, szEllipses);
1452 lpszDest += 3;
1453 cchMax -= 4;
1454 *lpszDest++ = *lpszFile++;
1455 if (cchMax <= 4)
1456 {
1457 while (--cchMax > 0) /* No room left for anything but ellipses */
1458 *lpszDest++ = '.';
1459 *lpszDest = '\0';
1460 return TRUE;
1461 }
1462 cchMax -= 4;
1463 memcpy(lpszDest, lpszFile, cchMax * sizeof(WCHAR));
1464 strcpyW(lpszDest + cchMax, szEllipses);
1465 return TRUE;
1466 }
1467
1468 /* Only the root needs to be Compacted */
1469 dwLen = cchMax - dwFileLen - 3;
1470 memcpy(lpszDest, lpszPath, dwLen * sizeof(WCHAR));
1471 strcpyW(lpszDest + dwLen, szEllipses);
1472 strcpyW(lpszDest + dwLen + 3, lpszFile);
1473 return TRUE;
1474 }
1475
1476 /*************************************************************************
1477 * PathIsRelativeA [SHLWAPI.@]
1478 *
1479 * Determine if a path is a relative path.
1480 *
1481 * PARAMS
1482 * lpszPath [I] Path to check
1483 *
1484 * RETURNS
1485 * TRUE: The path is relative, or is invalid.
1486 * FALSE: The path is not relative.
1487 */
1488 BOOL WINAPI PathIsRelativeA (LPCSTR lpszPath)
1489 {
1490 TRACE("(%s)\n",debugstr_a(lpszPath));
1491
1492 if (!lpszPath || !*lpszPath || IsDBCSLeadByte(*lpszPath))
1493 return TRUE;
1494 if (*lpszPath == '\\' || (*lpszPath && lpszPath[1] == ':'))
1495 return FALSE;
1496 return TRUE;
1497 }
1498
1499 /*************************************************************************
1500 * PathIsRelativeW [SHLWAPI.@]
1501 *
1502 * See PathIsRelativeA.
1503 */
1504 BOOL WINAPI PathIsRelativeW (LPCWSTR lpszPath)
1505 {
1506 TRACE("(%s)\n",debugstr_w(lpszPath));
1507
1508 if (!lpszPath || !*lpszPath)
1509 return TRUE;
1510 if (*lpszPath == '\\' || (*lpszPath && lpszPath[1] == ':'))
1511 return FALSE;
1512 return TRUE;
1513 }
1514
1515 /*************************************************************************
1516 * PathIsRootA [SHLWAPI.@]
1517 *
1518 * Determine if a path is a root path.
1519 *
1520 * PARAMS
1521 * lpszPath [I] Path to check
1522 *
1523 * RETURNS
1524 * TRUE If lpszPath is valid and a root path,
1525 * FALSE Otherwise
1526 */
1527 BOOL WINAPI PathIsRootA(LPCSTR lpszPath)
1528 {
1529 TRACE("(%s)\n", debugstr_a(lpszPath));
1530
1531 if (lpszPath && *lpszPath)
1532 {
1533 if (*lpszPath == '\\')
1534 {
1535 if (!lpszPath[1])
1536 return TRUE; /* \ */
1537 else if (lpszPath[1]=='\\')
1538 {
1539 BOOL bSeenSlash = FALSE;
1540 lpszPath += 2;
1541
1542 /* Check for UNC root path */
1543 while (*lpszPath)
1544 {
1545 if (*lpszPath == '\\')
1546 {
1547 if (bSeenSlash)
1548 return FALSE;
1549 bSeenSlash = TRUE;
1550 }
1551 lpszPath = CharNextA(lpszPath);
1552 }
1553 return TRUE;
1554 }
1555 }
1556 else if (lpszPath[1] == ':' && lpszPath[2] == '\\' && lpszPath[3] == '\0')
1557 return TRUE; /* X:\ */
1558 }
1559 return FALSE;
1560 }
1561
1562 /*************************************************************************
1563 * PathIsRootW [SHLWAPI.@]
1564 *
1565 * See PathIsRootA.
1566 */
1567 BOOL WINAPI PathIsRootW(LPCWSTR lpszPath)
1568 {
1569 TRACE("(%s)\n", debugstr_w(lpszPath));
1570
1571 if (lpszPath && *lpszPath)
1572 {
1573 if (*lpszPath == '\\')
1574 {
1575 if (!lpszPath[1])
1576 return TRUE; /* \ */
1577 else if (lpszPath[1]=='\\')
1578 {
1579 BOOL bSeenSlash = FALSE;
1580 lpszPath += 2;
1581
1582 /* Check for UNC root path */
1583 while (*lpszPath)
1584 {
1585 if (*lpszPath == '\\')
1586 {
1587 if (bSeenSlash)
1588 return FALSE;
1589 bSeenSlash = TRUE;
1590 }
1591 lpszPath = CharNextW(lpszPath);
1592 }
1593 return TRUE;
1594 }
1595 }
1596 else if (lpszPath[1] == ':' && lpszPath[2] == '\\' && lpszPath[3] == '\0')
1597 return TRUE; /* X:\ */
1598 }
1599 return FALSE;
1600 }
1601
1602 /*************************************************************************
1603 * PathIsDirectoryA [SHLWAPI.@]
1604 *
1605 * Determine if a path is a valid directory
1606 *
1607 * PARAMS
1608 * lpszPath [I] Path to check.
1609 *
1610 * RETURNS
1611 * FILE_ATTRIBUTE_DIRECTORY if lpszPath exists and can be read (See Notes)
1612 * FALSE if lpszPath is invalid or not a directory.
1613 *
1614 * NOTES
1615 * Although this function is prototyped as returning a BOOL, it returns
1616 * FILE_ATTRIBUTE_DIRECTORY for success. This means that code such as:
1617 *
1618 *| if (PathIsDirectoryA("c:\\windows\\") == TRUE)
1619 *| ...
1620 *
1621 * will always fail.
1622 */
1623 BOOL WINAPI PathIsDirectoryA(LPCSTR lpszPath)
1624 {
1625 DWORD dwAttr;
1626
1627 TRACE("(%s)\n", debugstr_a(lpszPath));
1628
1629 if (!lpszPath || PathIsUNCServerA(lpszPath))
1630 return FALSE;
1631
1632 if (PathIsUNCServerShareA(lpszPath))
1633 {
1634 FIXME("UNC Server Share not yet supported - FAILING\n");
1635 return FALSE;
1636 }
1637
1638 if ((dwAttr = GetFileAttributesA(lpszPath)) == INVALID_FILE_ATTRIBUTES)
1639 return FALSE;
1640 return dwAttr & FILE_ATTRIBUTE_DIRECTORY;
1641 }
1642
1643 /*************************************************************************
1644 * PathIsDirectoryW [SHLWAPI.@]
1645 *
1646 * See PathIsDirectoryA.
1647 */
1648 BOOL WINAPI PathIsDirectoryW(LPCWSTR lpszPath)
1649 {
1650 DWORD dwAttr;
1651
1652 TRACE("(%s)\n", debugstr_w(lpszPath));
1653
1654 if (!lpszPath || PathIsUNCServerW(lpszPath))
1655 return FALSE;
1656
1657 if (PathIsUNCServerShareW(lpszPath))
1658 {
1659 FIXME("UNC Server Share not yet supported - FAILING\n");
1660 return FALSE;
1661 }
1662
1663 if ((dwAttr = GetFileAttributesW(lpszPath)) == INVALID_FILE_ATTRIBUTES)
1664 return FALSE;
1665 return dwAttr & FILE_ATTRIBUTE_DIRECTORY;
1666 }
1667
1668 /*************************************************************************
1669 * PathFileExistsA [SHLWAPI.@]
1670 *
1671 * Determine if a file exists.
1672 *
1673 * PARAMS
1674 * lpszPath [I] Path to check
1675 *
1676 * RETURNS
1677 * TRUE If the file exists and is readable
1678 * FALSE Otherwise
1679 */
1680 BOOL WINAPI PathFileExistsA(LPCSTR lpszPath)
1681 {
1682 UINT iPrevErrMode;
1683 DWORD dwAttr;
1684
1685 TRACE("(%s)\n",debugstr_a(lpszPath));
1686
1687 if (!lpszPath)
1688 return FALSE;
1689
1690 iPrevErrMode = SetErrorMode(1);
1691 dwAttr = GetFileAttributesA(lpszPath);
1692 SetErrorMode(iPrevErrMode);
1693 return dwAttr == INVALID_FILE_ATTRIBUTES ? FALSE : TRUE;
1694 }
1695
1696 /*************************************************************************
1697 * PathFileExistsW [SHLWAPI.@]
1698 *
1699 * See PathFileExistsA.
1700 */
1701 BOOL WINAPI PathFileExistsW(LPCWSTR lpszPath)
1702 {
1703 UINT iPrevErrMode;
1704 DWORD dwAttr;
1705
1706 TRACE("(%s)\n",debugstr_w(lpszPath));
1707
1708 if (!lpszPath)
1709 return FALSE;
1710
1711 iPrevErrMode = SetErrorMode(1);
1712 dwAttr = GetFileAttributesW(lpszPath);
1713 SetErrorMode(iPrevErrMode);
1714 return dwAttr == INVALID_FILE_ATTRIBUTES ? FALSE : TRUE;
1715 }
1716
1717 /*************************************************************************
1718 * PathFileExistsAndAttributesA [SHLWAPI.445]
1719 *
1720 * Determine if a file exists.
1721 *
1722 * PARAMS
1723 * lpszPath [I] Path to check
1724 * dwAttr [O] attributes of file
1725 *
1726 * RETURNS
1727 * TRUE If the file exists and is readable
1728 * FALSE Otherwise
1729 */
1730 BOOL WINAPI PathFileExistsAndAttributesA(LPCSTR lpszPath, DWORD *dwAttr)
1731 {
1732 UINT iPrevErrMode;
1733 DWORD dwVal = 0;
1734
1735 TRACE("(%s %p)\n", debugstr_a(lpszPath), dwAttr);
1736
1737 if (dwAttr)
1738 *dwAttr = INVALID_FILE_ATTRIBUTES;
1739
1740 if (!lpszPath)
1741 return FALSE;
1742
1743 iPrevErrMode = SetErrorMode(SEM_FAILCRITICALERRORS);
1744 dwVal = GetFileAttributesA(lpszPath);
1745 SetErrorMode(iPrevErrMode);
1746 if (dwAttr)
1747 *dwAttr = dwVal;
1748 return (dwVal != INVALID_FILE_ATTRIBUTES);
1749 }
1750
1751 /*************************************************************************
1752 * PathFileExistsAndAttributesW [SHLWAPI.446]
1753 *
1754 * See PathFileExistsA.
1755 */
1756 BOOL WINAPI PathFileExistsAndAttributesW(LPCWSTR lpszPath, DWORD *dwAttr)
1757 {
1758 UINT iPrevErrMode;
1759 DWORD dwVal;
1760
1761 TRACE("(%s %p)\n", debugstr_w(lpszPath), dwAttr);
1762
1763 if (!lpszPath)
1764 return FALSE;
1765
1766 iPrevErrMode = SetErrorMode(SEM_FAILCRITICALERRORS);
1767 dwVal = GetFileAttributesW(lpszPath);
1768 SetErrorMode(iPrevErrMode);
1769 if (dwAttr)
1770 *dwAttr = dwVal;
1771 return (dwVal != INVALID_FILE_ATTRIBUTES);
1772 }
1773
1774 /*************************************************************************
1775 * PathMatchSingleMaskA [internal]
1776 */
1777 static BOOL WINAPI PathMatchSingleMaskA(LPCSTR name, LPCSTR mask)
1778 {
1779 while (*name && *mask && *mask!=';')
1780 {
1781 if (*mask == '*')
1782 {
1783 do
1784 {
1785 if (PathMatchSingleMaskA(name,mask+1))
1786 return TRUE; /* try substrings */
1787 } while (*name++);
1788 return FALSE;
1789 }
1790
1791 if (toupper(*mask) != toupper(*name) && *mask != '?')
1792 return FALSE;
1793
1794 name = CharNextA(name);
1795 mask = CharNextA(mask);
1796 }
1797
1798 if (!*name)
1799 {
1800 while (*mask == '*')
1801 mask++;
1802 if (!*mask || *mask == ';')
1803 return TRUE;
1804 }
1805 return FALSE;
1806 }
1807
1808 /*************************************************************************
1809 * PathMatchSingleMaskW [internal]
1810 */
1811 static BOOL WINAPI PathMatchSingleMaskW(LPCWSTR name, LPCWSTR mask)
1812 {
1813 while (*name && *mask && *mask != ';')
1814 {
1815 if (*mask == '*')
1816 {
1817 do
1818 {
1819 if (PathMatchSingleMaskW(name,mask+1))
1820 return TRUE; /* try substrings */
1821 } while (*name++);
1822 return FALSE;
1823 }
1824
1825 if (toupperW(*mask) != toupperW(*name) && *mask != '?')
1826 return FALSE;
1827
1828 name = CharNextW(name);
1829 mask = CharNextW(mask);
1830 }
1831 if (!*name)
1832 {
1833 while (*mask == '*')
1834 mask++;
1835 if (!*mask || *mask == ';')
1836 return TRUE;
1837 }
1838 return FALSE;
1839 }
1840
1841 /*************************************************************************
1842 * PathMatchSpecA [SHLWAPI.@]
1843 *
1844 * Determine if a path matches one or more search masks.
1845 *
1846 * PARAMS
1847 * lpszPath [I] Path to check
1848 * lpszMask [I] Search mask(s)
1849 *
1850 * RETURNS
1851 * TRUE If lpszPath is valid and is matched
1852 * FALSE Otherwise
1853 *
1854 * NOTES
1855 * Multiple search masks may be given if they are separated by ";". The
1856 * pattern "*.*" is treated specially in that it matches all paths (for
1857 * backwards compatibility with DOS).
1858 */
1859 BOOL WINAPI PathMatchSpecA(LPCSTR lpszPath, LPCSTR lpszMask)
1860 {
1861 TRACE("(%s,%s)\n", lpszPath, lpszMask);
1862
1863 if (!lstrcmpA(lpszMask, "*.*"))
1864 return TRUE; /* Matches every path */
1865
1866 while (*lpszMask)
1867 {
1868 if (PathMatchSingleMaskA(lpszPath, lpszMask))
1869 return TRUE; /* Matches the current mask */
1870
1871 while (*lpszMask && *lpszMask != ';')
1872 lpszMask = CharNextA(lpszMask);
1873
1874 if (*lpszMask == ';')
1875 {
1876 lpszMask++;
1877 while (*lpszMask == ' ')
1878 lpszMask++; /* masks may be separated by "; " */
1879 }
1880 }
1881 return FALSE;
1882 }
1883
1884 /*************************************************************************
1885 * PathMatchSpecW [SHLWAPI.@]
1886 *
1887 * See PathMatchSpecA.
1888 */
1889 BOOL WINAPI PathMatchSpecW(LPCWSTR lpszPath, LPCWSTR lpszMask)
1890 {
1891 static const WCHAR szStarDotStar[] = { '*', '.', '*', '\0' };
1892
1893 TRACE("(%s,%s)\n", debugstr_w(lpszPath), debugstr_w(lpszMask));
1894
1895 if (!lstrcmpW(lpszMask, szStarDotStar))
1896 return TRUE; /* Matches every path */
1897
1898 while (*lpszMask)
1899 {
1900 if (PathMatchSingleMaskW(lpszPath, lpszMask))
1901 return TRUE; /* Matches the current path */
1902
1903 while (*lpszMask && *lpszMask != ';')
1904 lpszMask++;
1905
1906 if (*lpszMask == ';')
1907 {
1908 lpszMask++;
1909 while (*lpszMask == ' ')
1910 lpszMask++; /* Masks may be separated by "; " */
1911 }
1912 }
1913 return FALSE;
1914 }
1915
1916 /*************************************************************************
1917 * PathIsSameRootA [SHLWAPI.@]
1918 *
1919 * Determine if two paths share the same root.
1920 *
1921 * PARAMS
1922 * lpszPath1 [I] Source path
1923 * lpszPath2 [I] Path to compare with
1924 *
1925 * RETURNS
1926 * TRUE If both paths are valid and share the same root.
1927 * FALSE If either path is invalid or the paths do not share the same root.
1928 */
1929 BOOL WINAPI PathIsSameRootA(LPCSTR lpszPath1, LPCSTR lpszPath2)
1930 {
1931 LPCSTR lpszStart;
1932 int dwLen;
1933
1934 TRACE("(%s,%s)\n", debugstr_a(lpszPath1), debugstr_a(lpszPath2));
1935
1936 if (!lpszPath1 || !lpszPath2 || !(lpszStart = PathSkipRootA(lpszPath1)))
1937 return FALSE;
1938
1939 dwLen = PathCommonPrefixA(lpszPath1, lpszPath2, NULL) + 1;
1940 if (lpszStart - lpszPath1 > dwLen)
1941 return FALSE; /* Paths not common up to length of the root */
1942 return TRUE;
1943 }
1944
1945 /*************************************************************************
1946 * PathIsSameRootW [SHLWAPI.@]
1947 *
1948 * See PathIsSameRootA.
1949 */
1950 BOOL WINAPI PathIsSameRootW(LPCWSTR lpszPath1, LPCWSTR lpszPath2)
1951 {
1952 LPCWSTR lpszStart;
1953 int dwLen;
1954
1955 TRACE("(%s,%s)\n", debugstr_w(lpszPath1), debugstr_w(lpszPath2));
1956
1957 if (!lpszPath1 || !lpszPath2 || !(lpszStart = PathSkipRootW(lpszPath1)))
1958 return FALSE;
1959
1960 dwLen = PathCommonPrefixW(lpszPath1, lpszPath2, NULL) + 1;
1961 if (lpszStart - lpszPath1 > dwLen)
1962 return FALSE; /* Paths not common up to length of the root */
1963 return TRUE;
1964 }
1965
1966 /*************************************************************************
1967 * PathIsContentTypeA [SHLWAPI.@]
1968 *
1969 * Determine if a file is of a given registered content type.
1970 *
1971 * PARAMS
1972 * lpszPath [I] File to check
1973 * lpszContentType [I] Content type to check for
1974 *
1975 * RETURNS
1976 * TRUE If lpszPath is a given registered content type,
1977 * FALSE Otherwise.
1978 *
1979 * NOTES
1980 * This function looks up the registered content type for lpszPath. If
1981 * a content type is registered, it is compared (case insensitively) to
1982 * lpszContentType. Only if this matches does the function succeed.
1983 */
1984 BOOL WINAPI PathIsContentTypeA(LPCSTR lpszPath, LPCSTR lpszContentType)
1985 {
1986 LPCSTR szExt;
1987 DWORD dwDummy;
1988 char szBuff[MAX_PATH];
1989
1990 TRACE("(%s,%s)\n", debugstr_a(lpszPath), debugstr_a(lpszContentType));
1991
1992 if (lpszPath && (szExt = PathFindExtensionA(lpszPath)) && *szExt &&
1993 !SHGetValueA(HKEY_CLASSES_ROOT, szExt, "Content Type",
1994 REG_NONE, szBuff, &dwDummy) &&
1995 !strcasecmp(lpszContentType, szBuff))
1996 {
1997 return TRUE;
1998 }
1999 return FALSE;
2000 }
2001
2002 /*************************************************************************
2003 * PathIsContentTypeW [SHLWAPI.@]
2004 *
2005 * See PathIsContentTypeA.
2006 */
2007 BOOL WINAPI PathIsContentTypeW(LPCWSTR lpszPath, LPCWSTR lpszContentType)
2008 {
2009 static const WCHAR szContentType[] = { 'C','o','n','t','e','n','t',' ','T','y','p','e','\0' };
2010 LPCWSTR szExt;
2011 DWORD dwDummy;
2012 WCHAR szBuff[MAX_PATH];
2013
2014 TRACE("(%s,%s)\n", debugstr_w(lpszPath), debugstr_w(lpszContentType));
2015
2016 if (lpszPath && (szExt = PathFindExtensionW(lpszPath)) && *szExt &&
2017 !SHGetValueW(HKEY_CLASSES_ROOT, szExt, szContentType,
2018 REG_NONE, szBuff, &dwDummy) &&
2019 !strcmpiW(lpszContentType, szBuff))
2020 {
2021 return TRUE;
2022 }
2023 return FALSE;
2024 }
2025
2026 /*************************************************************************
2027 * PathIsFileSpecA [SHLWAPI.@]
2028 *
2029 * Determine if a path is a file specification.
2030 *
2031 * PARAMS
2032 * lpszPath [I] Path to chack
2033 *
2034 * RETURNS
2035 * TRUE If lpszPath is a file specification (i.e. Contains no directories).
2036 * FALSE Otherwise.
2037 */
2038 BOOL WINAPI PathIsFileSpecA(LPCSTR lpszPath)
2039 {
2040 TRACE("(%s)\n", debugstr_a(lpszPath));
2041
2042 if (!lpszPath)
2043 return FALSE;
2044
2045 while (*lpszPath)
2046 {
2047 if (*lpszPath == '\\' || *lpszPath == ':')
2048 return FALSE;
2049 lpszPath = CharNextA(lpszPath);
2050 }
2051 return TRUE;
2052 }
2053
2054 /*************************************************************************
2055 * PathIsFileSpecW [SHLWAPI.@]
2056 *
2057 * See PathIsFileSpecA.
2058 */
2059 BOOL WINAPI PathIsFileSpecW(LPCWSTR lpszPath)
2060 {
2061 TRACE("(%s)\n", debugstr_w(lpszPath));
2062
2063 if (!lpszPath)
2064 return FALSE;
2065
2066 while (*lpszPath)
2067 {
2068 if (*lpszPath == '\\' || *lpszPath == ':')
2069 return FALSE;
2070 lpszPath = CharNextW(lpszPath);
2071 }
2072 return TRUE;
2073 }
2074
2075 /*************************************************************************
2076 * PathIsPrefixA [SHLWAPI.@]
2077 *
2078 * Determine if a path is a prefix of another.
2079 *
2080 * PARAMS
2081 * lpszPrefix [I] Prefix
2082 * lpszPath [I] Path to check
2083 *
2084 * RETURNS
2085 * TRUE If lpszPath has lpszPrefix as its prefix,
2086 * FALSE If either path is NULL or lpszPrefix is not a prefix
2087 */
2088 BOOL WINAPI PathIsPrefixA (LPCSTR lpszPrefix, LPCSTR lpszPath)
2089 {
2090 TRACE("(%s,%s)\n", debugstr_a(lpszPrefix), debugstr_a(lpszPath));
2091
2092 if (lpszPrefix && lpszPath &&
2093 PathCommonPrefixA(lpszPath, lpszPrefix, NULL) == (int)strlen(lpszPrefix))
2094 return TRUE;
2095 return FALSE;
2096 }
2097
2098 /*************************************************************************
2099 * PathIsPrefixW [SHLWAPI.@]
2100 *
2101 * See PathIsPrefixA.
2102 */
2103 BOOL WINAPI PathIsPrefixW(LPCWSTR lpszPrefix, LPCWSTR lpszPath)
2104 {
2105 TRACE("(%s,%s)\n", debugstr_w(lpszPrefix), debugstr_w(lpszPath));
2106
2107 if (lpszPrefix && lpszPath &&
2108 PathCommonPrefixW(lpszPath, lpszPrefix, NULL) == (int)strlenW(lpszPrefix))
2109 return TRUE;
2110 return FALSE;
2111 }
2112
2113 /*************************************************************************
2114 * PathIsSystemFolderA [SHLWAPI.@]
2115 *
2116 * Determine if a path or file attributes are a system folder.
2117 *
2118 * PARAMS
2119 * lpszPath [I] Path to check.
2120 * dwAttrib [I] Attributes to check, if lpszPath is NULL.
2121 *
2122 * RETURNS
2123 * TRUE If lpszPath or dwAttrib are a system folder.
2124 * FALSE If GetFileAttributesA() fails or neither parameter is a system folder.
2125 */
2126 BOOL WINAPI PathIsSystemFolderA(LPCSTR lpszPath, DWORD dwAttrib)
2127 {
2128 TRACE("(%s,0x%08lx)\n", debugstr_a(lpszPath), dwAttrib);
2129
2130 if (lpszPath && *lpszPath)
2131 dwAttrib = GetFileAttributesA(lpszPath);
2132
2133 if (dwAttrib == INVALID_FILE_ATTRIBUTES || !(dwAttrib & FILE_ATTRIBUTE_DIRECTORY) ||
2134 !(dwAttrib & (FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_READONLY)))
2135 return FALSE;
2136 return TRUE;
2137 }
2138
2139 /*************************************************************************
2140 * PathIsSystemFolderW [SHLWAPI.@]
2141 *
2142 * See PathIsSystemFolderA.
2143 */
2144 BOOL WINAPI PathIsSystemFolderW(LPCWSTR lpszPath, DWORD dwAttrib)
2145 {
2146 TRACE("(%s,0x%08lx)\n", debugstr_w(lpszPath), dwAttrib);
2147
2148 if (lpszPath && *lpszPath)
2149 dwAttrib = GetFileAttributesW(lpszPath);
2150
2151 if (dwAttrib == INVALID_FILE_ATTRIBUTES || !(dwAttrib & FILE_ATTRIBUTE_DIRECTORY) ||
2152 !(dwAttrib & (FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_READONLY)))
2153 return FALSE;
2154 return TRUE;
2155 }
2156
2157 /*************************************************************************
2158 * PathIsUNCA [SHLWAPI.@]
2159 *
2160 * Determine if a path is in UNC format.
2161 *
2162 * PARAMS
2163 * lpszPath [I] Path to check
2164 *
2165 * RETURNS
2166 * TRUE: The path is UNC.
2167 * FALSE: The path is not UNC or is NULL.
2168 */
2169 BOOL WINAPI PathIsUNCA(LPCSTR lpszPath)
2170 {
2171 TRACE("(%s)\n",debugstr_a(lpszPath));
2172
2173 if (lpszPath && (lpszPath[0]=='\\') && (lpszPath[1]=='\\'))
2174 return TRUE;
2175 return FALSE;
2176 }
2177
2178 /*************************************************************************
2179 * PathIsUNCW [SHLWAPI.@]
2180 *
2181 * See PathIsUNCA.
2182 */
2183 BOOL WINAPI PathIsUNCW(LPCWSTR lpszPath)
2184 {
2185 TRACE("(%s)\n",debugstr_w(lpszPath));
2186
2187 if (lpszPath && (lpszPath[0]=='\\') && (lpszPath[1]=='\\'))
2188 return TRUE;
2189 return FALSE;
2190 }
2191
2192 /*************************************************************************
2193 * PathIsUNCServerA [SHLWAPI.@]
2194 *
2195 * Determine if a path is a UNC server name ("\\SHARENAME").
2196 *
2197 * PARAMS
2198 * lpszPath [I] Path to check.
2199 *
2200 * RETURNS
2201 * TRUE If lpszPath is a valid UNC server name.
2202 * FALSE Otherwise.
2203 *
2204 * NOTES
2205 * This routine is bug compatible with Win32: Server names with a
2206 * trailing backslash (e.g. "\\FOO\"), return FALSE incorrectly.
2207 * Fixing this bug may break other shlwapi functions!
2208 */
2209 BOOL WINAPI PathIsUNCServerA(LPCSTR lpszPath)
2210 {
2211 TRACE("(%s)\n", debugstr_a(lpszPath));
2212
2213 if (lpszPath && *lpszPath++ == '\\' && *lpszPath++ == '\\')
2214 {
2215 while (*lpszPath)
2216 {
2217 if (*lpszPath == '\\')
2218 return FALSE;
2219 lpszPath = CharNextA(lpszPath);
2220 }
2221 return TRUE;
2222 }
2223 return FALSE;
2224 }
2225
2226 /*************************************************************************
2227 * PathIsUNCServerW [SHLWAPI.@]
2228 *
2229 * See PathIsUNCServerA.
2230 */
2231 BOOL WINAPI PathIsUNCServerW(LPCWSTR lpszPath)
2232 {
2233 TRACE("(%s)\n", debugstr_w(lpszPath));
2234
2235 if (lpszPath && *lpszPath++ == '\\' && *lpszPath++ == '\\')
2236 {
2237 while (*lpszPath)
2238 {
2239 if (*lpszPath == '\\')
2240 return FALSE;
2241 lpszPath = CharNextW(lpszPath);
2242 }
2243 return TRUE;
2244 }
2245 return FALSE;
2246 }
2247
2248 /*************************************************************************
2249 * PathIsUNCServerShareA [SHLWAPI.@]
2250 *
2251 * Determine if a path is a UNC server share ("\\SHARENAME\SHARE").
2252 *
2253 * PARAMS
2254 * lpszPath [I] Path to check.
2255 *
2256 * RETURNS
2257 * TRUE If lpszPath is a valid UNC server share.
2258 * FALSE Otherwise.
2259 *
2260 * NOTES
2261 * This routine is bug compatible with Win32: Server shares with a
2262 * trailing backslash (e.g. "\\FOO\BAR\"), return FALSE incorrectly.
2263 * Fixing this bug may break other shlwapi functions!
2264 */
2265 BOOL WINAPI PathIsUNCServerShareA(LPCSTR lpszPath)
2266 {
2267 TRACE("(%s)\n", debugstr_a(lpszPath));
2268
2269 if (lpszPath && *lpszPath++ == '\\' && *lpszPath++ == '\\')
2270 {
2271 BOOL bSeenSlash = FALSE;
2272 while (*lpszPath)
2273 {
2274 if (*lpszPath == '\\')
2275 {
2276 if (bSeenSlash)
2277 return FALSE;
2278 bSeenSlash = TRUE;
2279 }
2280 lpszPath = CharNextA(lpszPath);
2281 }
2282 return bSeenSlash;
2283 }
2284 return FALSE;
2285 }
2286
2287 /*************************************************************************
2288 * PathIsUNCServerShareW [SHLWAPI.@]
2289 *
2290 * See PathIsUNCServerShareA.
2291 */
2292 BOOL WINAPI PathIsUNCServerShareW(LPCWSTR lpszPath)
2293 {
2294 TRACE("(%s)\n", debugstr_w(lpszPath));
2295
2296 if (lpszPath && *lpszPath++ == '\\' && *lpszPath++ == '\\')
2297 {
2298 BOOL bSeenSlash = FALSE;
2299 while (*lpszPath)
2300 {
2301 if (*lpszPath == '\\')
2302 {
2303 if (bSeenSlash)
2304 return FALSE;
2305 bSeenSlash = TRUE;
2306 }
2307 lpszPath = CharNextW(lpszPath);
2308 }
2309 return bSeenSlash;
2310 }
2311 return FALSE;
2312 }
2313
2314 /*************************************************************************
2315 * PathCanonicalizeA [SHLWAPI.@]
2316 *
2317 * Convert a path to its canonical form.
2318 *
2319 * PARAMS
2320 * lpszBuf [O] Output path
2321 * lpszPath [I] Path to cnonicalize
2322 *
2323 * RETURNS
2324 * Success: TRUE. lpszBuf contains the output path,
2325 * Failure: FALSE, If input path is invalid. lpszBuf is undefined
2326 */
2327 BOOL WINAPI PathCanonicalizeA(LPSTR lpszBuf, LPCSTR lpszPath)
2328 {
2329 BOOL bRet = FALSE;
2330
2331 TRACE("(%p,%s)\n", lpszBuf, debugstr_a(lpszPath));
2332
2333 if (lpszBuf)
2334 *lpszBuf = '\0';
2335
2336 if (!lpszBuf || !lpszPath)
2337 SetLastError(ERROR_INVALID_PARAMETER);
2338 else
2339 {
2340 WCHAR szPath[MAX_PATH];
2341 WCHAR szBuff[MAX_PATH];
2342 MultiByteToWideChar(CP_ACP,0,lpszPath,-1,szPath,MAX_PATH);
2343 bRet = PathCanonicalizeW(szBuff, szPath);
2344 WideCharToMultiByte(CP_ACP,0,szBuff,-1,lpszBuf,MAX_PATH,0,0);
2345 }
2346 return bRet;
2347 }
2348
2349
2350 /*************************************************************************
2351 * PathCanonicalizeW [SHLWAPI.@]
2352 *
2353 * See PathCanonicalizeA.
2354 */
2355 BOOL WINAPI PathCanonicalizeW(LPWSTR lpszBuf, LPCWSTR lpszPath)
2356 {
2357 LPWSTR lpszDst = lpszBuf;
2358 LPCWSTR lpszSrc = lpszPath;
2359
2360 TRACE("(%p,%s)\n", lpszBuf, debugstr_w(lpszPath));
2361
2362 if (lpszBuf)
2363 *lpszDst = '\0';
2364
2365 if (!lpszBuf || !lpszPath)
2366 {
2367 SetLastError(ERROR_INVALID_PARAMETER);
2368 return FALSE;
2369 }
2370
2371 if (!*lpszPath)
2372 {
2373 *lpszBuf++ = '\\';
2374 *lpszBuf = '\0';
2375 return TRUE;
2376 }
2377
2378 /* Copy path root */
2379 if (*lpszSrc == '\\')
2380 {
2381 *lpszDst++ = *lpszSrc++;
2382 }
2383 else if (*lpszSrc && lpszSrc[1] == ':')
2384 {
2385 /* X:\ */
2386 *lpszDst++ = *lpszSrc++;
2387 *lpszDst++ = *lpszSrc++;
2388 if (*lpszSrc == '\\')
2389 *lpszDst++ = *lpszSrc++;
2390 }
2391
2392 /* Canonicalize the rest of the path */
2393 while (*lpszSrc)
2394 {
2395 if (*lpszSrc == '.')
2396 {
2397 if (lpszSrc[1] == '\\' && (lpszSrc == lpszPath || lpszSrc[-1] == '\\' || lpszSrc[-1] == ':'))
2398 {
2399 lpszSrc += 2; /* Skip .\ */
2400 }
2401 else if (lpszSrc[1] == '.' && (lpszDst == lpszBuf || lpszDst[-1] == '\\'))
2402 {
2403 /* \.. backs up a directory, over the root if it has no \ following X:.
2404 * .. is ignored if it would remove a UNC server name or inital \\
2405 */
2406 if (lpszDst != lpszBuf)
2407 {
2408 *lpszDst = '\0'; /* Allow PathIsUNCServerShareA test on lpszBuf */
2409 if (lpszDst > lpszBuf+1 && lpszDst[-1] == '\\' &&
2410 (lpszDst[-2] != '\\' || lpszDst > lpszBuf+2))
2411 {
2412 if (lpszDst[-2] == ':' && (lpszDst > lpszBuf+3 || lpszDst[-3] == ':'))
2413 {
2414 lpszDst -= 2;
2415 while (lpszDst > lpszBuf && *lpszDst != '\\')
2416 lpszDst--;
2417 if (*lpszDst == '\\')
2418 lpszDst++; /* Reset to last '\' */
2419 else
2420 lpszDst = lpszBuf; /* Start path again from new root */
2421 }
2422 else if (lpszDst[-2] != ':' && !PathIsUNCServerShareW(lpszBuf))
2423 lpszDst -= 2;
2424 }
2425 while (lpszDst > lpszBuf && *lpszDst != '\\')
2426 lpszDst--;
2427 if (lpszDst == lpszBuf)
2428 {
2429 *lpszDst++ = '\\';
2430 lpszSrc++;
2431 }
2432 }
2433 lpszSrc += 2; /* Skip .. in src path */
2434 }
2435 else
2436 *lpszDst++ = *lpszSrc++;
2437 }
2438 else
2439 *lpszDst++ = *lpszSrc++;
2440 }
2441 /* Append \ to naked drive specs */
2442 if (lpszDst - lpszBuf == 2 && lpszDst[-1] == ':')
2443 *lpszDst++ = '\\';
2444 *lpszDst++ = '\0';
2445 return TRUE;
2446 }
2447
2448 /*************************************************************************
2449 * PathFindNextComponentA [SHLWAPI.@]
2450 *
2451 * Find the next component in a path.
2452 *
2453 * PARAMS
2454 * lpszPath [I] Path to find next component in
2455 *
2456 * RETURNS
2457 * Success: A pointer to the next component, or the end of the string.
2458 * Failure: NULL, If lpszPath is invalid
2459 *
2460 * NOTES
2461 * A 'component' is either a backslash character (\) or UNC marker (\\).
2462 * Because of this, relative paths (e.g "c:foo") are regarded as having
2463 * only one component.
2464 */
2465 LPSTR WINAPI PathFindNextComponentA(LPCSTR lpszPath)
2466 {
2467 LPSTR lpszSlash;
2468
2469 TRACE("(%s)\n", debugstr_a(lpszPath));
2470
2471 if(!lpszPath || !*lpszPath)
2472 return NULL;
2473
2474 if ((lpszSlash = StrChrA(lpszPath, '\\')))
2475 {
2476 if (lpszSlash[1] == '\\')
2477 lpszSlash++;
2478 return lpszSlash + 1;
2479 }
2480 return (LPSTR)lpszPath + strlen(lpszPath);
2481 }
2482
2483 /*************************************************************************
2484 * PathFindNextComponentW [SHLWAPI.@]
2485 *
2486 * See PathFindNextComponentA.
2487 */
2488 LPWSTR WINAPI PathFindNextComponentW(LPCWSTR lpszPath)
2489 {
2490 LPWSTR lpszSlash;
2491
2492 TRACE("(%s)\n", debugstr_w(lpszPath));
2493
2494 if(!lpszPath || !*lpszPath)
2495 return NULL;
2496
2497 if ((lpszSlash = StrChrW(lpszPath, '\\')))
2498 {
2499 if (lpszSlash[1] == '\\')
2500 lpszSlash++;
2501 return lpszSlash + 1;
2502 }
2503 return (LPWSTR)lpszPath + strlenW(lpszPath);
2504 }
2505
2506 /*************************************************************************
2507 * PathAddExtensionA [SHLWAPI.@]
2508 *
2509 * Add a file extension to a path
2510 *
2511 * PARAMS
2512 * lpszPath [I/O] Path to add extension to
2513 * lpszExtension [I] Extension to add to lpszPath
2514 *
2515 * RETURNS
2516 * TRUE If the path was modified,
2517 * FALSE If lpszPath or lpszExtension are invalid, lpszPath has an
2518 * extension allready, or the new path length is too big.
2519 *
2520 * FIXME
2521 * What version of shlwapi.dll adds "exe" if lpszExtension is NULL? Win2k
2522 * does not do this, so the behaviour was removed.
2523 */
2524 BOOL WINAPI PathAddExtensionA(LPSTR lpszPath, LPCSTR lpszExtension)
2525 {
2526 size_t dwLen;
2527
2528 TRACE("(%s,%s)\n", debugstr_a(lpszPath), debugstr_a(lpszExtension));
2529
2530 if (!lpszPath || !lpszExtension || *(PathFindExtensionA(lpszPath)))
2531 return FALSE;
2532
2533 dwLen = strlen(lpszPath);
2534
2535 if (dwLen + strlen(lpszExtension) >= MAX_PATH)
2536 return FALSE;
2537
2538 strcpy(lpszPath + dwLen, lpszExtension);
2539 return TRUE;
2540 }
2541
2542 /*************************************************************************
2543 * PathAddExtensionW [SHLWAPI.@]
2544 *
2545 * See PathAddExtensionA.
2546 */
2547 BOOL WINAPI PathAddExtensionW(LPWSTR lpszPath, LPCWSTR lpszExtension)
2548 {
2549 size_t dwLen;
2550
2551 TRACE("(%s,%s)\n", debugstr_w(lpszPath), debugstr_w(lpszExtension));
2552
2553 if (!lpszPath || !lpszExtension || *(PathFindExtensionW(lpszPath)))
2554 return FALSE;
2555
2556 dwLen = strlenW(lpszPath);
2557
2558 if (dwLen + strlenW(lpszExtension) >= MAX_PATH)
2559 return FALSE;
2560
2561 strcpyW(lpszPath + dwLen, lpszExtension);
2562 return TRUE;
2563 }
2564
2565 /*************************************************************************
2566 * PathMakePrettyA [SHLWAPI.@]
2567 *
2568 * Convert an uppercase DOS filename into lowercase.
2569 *
2570 * PARAMS
2571 * lpszPath [I/O] Path to convert.
2572 *
2573 * RETURNS
2574 * TRUE If the path was an uppercase DOS path and was converted,
2575 * FALSE Otherwise.
2576 */
2577 BOOL WINAPI PathMakePrettyA(LPSTR lpszPath)
2578 {
2579 LPSTR pszIter = lpszPath;
2580
2581 TRACE("(%s)\n", debugstr_a(lpszPath));
2582
2583 if (!pszIter || !*pszIter)
2584 return FALSE;
2585
2586 while (*pszIter)
2587 {
2588 if (islower(*pszIter) || IsDBCSLeadByte(*pszIter))
2589 return FALSE; /* Not DOS path */
2590 pszIter++;
2591 }
2592 pszIter = lpszPath + 1;
2593 while (*pszIter)
2594 {
2595 *pszIter = tolower(*pszIter);
2596 pszIter++;
2597 }
2598 return TRUE;
2599 }
2600
2601 /*************************************************************************
2602 * PathMakePrettyW [SHLWAPI.@]
2603 *
2604 * See PathMakePrettyA.
2605 */
2606 BOOL WINAPI PathMakePrettyW(LPWSTR lpszPath)
2607 {
2608 LPWSTR pszIter = lpszPath;
2609
2610 TRACE("(%s)\n", debugstr_w(lpszPath));
2611
2612 if (!pszIter || !*pszIter)
2613 return FALSE;
2614
2615 while (*pszIter)
2616 {
2617 if (islowerW(*pszIter))
2618 return FALSE; /* Not DOS path */
2619 pszIter++;
2620 }
2621 pszIter = lpszPath + 1;
2622 while (*pszIter)
2623 {
2624 *pszIter = tolowerW(*pszIter);
2625 pszIter++;
2626 }
2627 return TRUE;
2628 }
2629
2630 /*************************************************************************
2631 * PathCommonPrefixA [SHLWAPI.@]
2632 *
2633 * Determine the length of the common prefix between two paths.
2634 *
2635 * PARAMS
2636 * lpszFile1 [I] First path for comparison
2637 * lpszFile2 [I] Second path for comparison
2638 * achPath [O] Destination for common prefix string
2639 *
2640 * RETURNS
2641 * The length of the common prefix. This is 0 if there is no common
2642 * prefix between the paths or if any parameters are invalid. If the prefix
2643 * is non-zero and achPath is not NULL, achPath is filled with the common
2644 * part of the prefix and NUL terminated.
2645 *
2646 * NOTES
2647 * A common prefix of 2 is always returned as 3. It is thus possible for
2648 * the length returned to be invalid (i.e. Longer than one or both of the
2649 * strings given as parameters). This Win32 behaviour has been implemented
2650 * here, and cannot be changed (fixed?) without breaking other SHLWAPI calls.
2651 * To work around this when using this function, always check that the byte
2652 * at [common_prefix_len-1] is not a NUL. If it is, deduct 1 from the prefix.
2653 */
2654 int WINAPI PathCommonPrefixA(LPCSTR lpszFile1, LPCSTR lpszFile2, LPSTR achPath)
2655 {
2656 size_t iLen = 0;
2657 LPCSTR lpszIter1 = lpszFile1;
2658 LPCSTR lpszIter2 = lpszFile2;
2659
2660 TRACE("(%s,%s,%p)\n", debugstr_a(lpszFile1), debugstr_a(lpszFile2), achPath);
2661
2662 if (achPath)
2663 *achPath = '\0';
2664
2665 if (!lpszFile1 || !lpszFile2)
2666 return 0;
2667
2668 /* Handle roots first */
2669 if (PathIsUNCA(lpszFile1))
2670 {
2671 if (!PathIsUNCA(lpszFile2))
2672 return 0;
2673 lpszIter1 += 2;
2674 lpszIter2 += 2;
2675 }
2676 else if (PathIsUNCA(lpszFile2))
2677 return 0; /* Know already lpszFile1 is not UNC */
2678
2679 do
2680 {
2681 /* Update len */
2682 if ((!*lpszIter1 || *lpszIter1 == '\\') &&
2683 (!*lpszIter2 || *lpszIter2 == '\\'))
2684 iLen = lpszIter1 - lpszFile1; /* Common to this point */
2685
2686 if (!*lpszIter1 || (tolower(*lpszIter1) != tolower(*lpszIter2)))
2687 break; /* Strings differ at this point */
2688
2689 lpszIter1++;
2690 lpszIter2++;
2691 } while (1);
2692
2693 if (iLen == 2)
2694 iLen++; /* Feature/Bug compatible with Win32 */
2695
2696 if (iLen && achPath)
2697 {
2698 memcpy(achPath,lpszFile1,iLen);
2699 achPath[iLen] = '\0';
2700 }
2701 return iLen;
2702 }
2703
2704 /*************************************************************************
2705 * PathCommonPrefixW [SHLWAPI.@]
2706 *
2707 * See PathCommonPrefixA.
2708 */
2709 int WINAPI PathCommonPrefixW(LPCWSTR lpszFile1, LPCWSTR lpszFile2, LPWSTR achPath)
2710 {
2711 size_t iLen = 0;
2712 LPCWSTR lpszIter1 = lpszFile1;
2713 LPCWSTR lpszIter2 = lpszFile2;
2714
2715 TRACE("(%s,%s,%p)\n", debugstr_w(lpszFile1), debugstr_w(lpszFile2), achPath);
2716
2717 if (achPath)
2718 *achPath = '\0';
2719
2720 if (!lpszFile1 || !lpszFile2)
2721 return 0;
2722
2723 /* Handle roots first */
2724 if (PathIsUNCW(lpszFile1))
2725 {
2726 if (!PathIsUNCW(lpszFile2))
2727 return 0;
2728 lpszIter1 += 2;
2729 lpszIter2 += 2;
2730 }
2731 else if (PathIsUNCW(lpszFile2))
2732 return 0; /* Know already lpszFile1 is not UNC */
2733
2734 do
2735 {
2736 /* Update len */
2737 if ((!*lpszIter1 || *lpszIter1 == '\\') &&
2738 (!*lpszIter2 || *lpszIter2 == '\\'))
2739 iLen = lpszIter1 - lpszFile1; /* Common to this point */
2740
2741 if (!*lpszIter1 || (tolowerW(*lpszIter1) != tolowerW(*lpszIter2)))
2742 break; /* Strings differ at this point */
2743
2744 lpszIter1++;
2745 lpszIter2++;
2746 } while (1);
2747
2748 if (iLen == 2)
2749 iLen++; /* Feature/Bug compatible with Win32 */
2750
2751 if (iLen && achPath)
2752 {
2753 memcpy(achPath,lpszFile1,iLen * sizeof(WCHAR));
2754 achPath[iLen] = '\0';
2755 }
2756 return iLen;
2757 }
2758
2759 /*************************************************************************
2760 * PathCompactPathA [SHLWAPI.@]
2761 *
2762 * Make a path fit into a given width when printed to a DC.
2763 *
2764 * PARAMS
2765 * hDc [I] Destination DC
2766 * lpszPath [I/O] Path to be printed to hDc
2767 * dx [I] Desired width
2768 *
2769 * RETURNS
2770 * TRUE If the path was modified.
2771 * FALSE Otherwise.
2772 */
2773 BOOL WINAPI PathCompactPathA(HDC hDC, LPSTR lpszPath, UINT dx)
2774 {
2775 BOOL bRet = FALSE;
2776
2777 TRACE("(%p,%s,%d)\n", hDC, debugstr_a(lpszPath), dx);
2778
2779 if (lpszPath)
2780 {
2781 WCHAR szPath[MAX_PATH];
2782 MultiByteToWideChar(CP_ACP,0,lpszPath,-1,szPath,MAX_PATH);
2783 bRet = PathCompactPathW(hDC, szPath, dx);
2784 WideCharToMultiByte(CP_ACP,0,szPath,-1,lpszPath,MAX_PATH,0,0);
2785 }
2786 return bRet;
2787 }
2788
2789 /*************************************************************************
2790 * PathCompactPathW [SHLWAPI.@]
2791 *
2792 * See PathCompactPathA.
2793 */
2794 BOOL WINAPI PathCompactPathW(HDC hDC, LPWSTR lpszPath, UINT dx)
2795 {
2796 static const WCHAR szEllipses[] = { '.', '.', '.', '\0' };
2797 BOOL bRet = TRUE;
2798 HDC hdc = 0;
2799 WCHAR buff[MAX_PATH];
2800 SIZE size;
2801 DWORD dwLen;
2802
2803 TRACE("(%p,%s,%d)\n", hDC, debugstr_w(lpszPath), dx);
2804
2805 if (!lpszPath)
2806 return bRet;
2807
2808 if (!hDC)
2809 hdc = hDC = GetDC(0);
2810
2811 /* Get the length of the whole path */
2812 dwLen = strlenW(lpszPath);
2813 GetTextExtentPointW(hDC, lpszPath, dwLen, &size);
2814
2815 if ((UINT)size.cx > dx)
2816 {
2817 /* Path too big, must reduce it */
2818 LPWSTR sFile;
2819 DWORD dwEllipsesLen = 0, dwPathLen = 0;
2820
2821 sFile = PathFindFileNameW(lpszPath);
2822 if (sFile != lpszPath)
2823 sFile = CharPrevW(lpszPath, sFile);
2824
2825 /* Get the size of ellipses */
2826 GetTextExtentPointW(hDC, szEllipses, 3, &size);
2827 dwEllipsesLen = size.cx;
2828 /* Get the size of the file name */
2829 GetTextExtentPointW(hDC, sFile, strlenW(sFile), &size);
2830 dwPathLen = size.cx;
2831
2832 if (sFile != lpszPath)
2833 {
2834 LPWSTR sPath = sFile;
2835 BOOL bEllipses = FALSE;
2836
2837 /* The path includes a file name. Include as much of the path prior to
2838 * the file name as possible, allowing for the ellipses, e.g:
2839 * c:\some very long path\filename ==> c:\some v...\filename
2840 */
2841 strncpyW(buff, sFile, MAX_PATH);
2842
2843 do
2844 {
2845 DWORD dwTotalLen = bEllipses? dwPathLen + dwEllipsesLen : dwPathLen;
2846
2847 GetTextExtentPointW(hDC, lpszPath, sPath - lpszPath, &size);
2848 dwTotalLen += size.cx;
2849 if (dwTotalLen <= dx)
2850 break;
2851 sPath = CharPrevW(lpszPath, sPath);
2852 if (!bEllipses)
2853 {
2854 bEllipses = TRUE;
2855 sPath = CharPrevW(lpszPath, sPath);
2856 sPath = CharPrevW(lpszPath, sPath);
2857 }
2858 } while (sPath > lpszPath);
2859
2860 if (sPath > lpszPath)
2861 {
2862 if (bEllipses)
2863 {
2864 strcpyW(sPath, szEllipses);
2865 strcpyW(sPath+3, buff);
2866 }
2867 bRet = TRUE;
2868 goto end;
2869 }
2870 strcpyW(lpszPath, szEllipses);
2871 strcpyW(lpszPath+3, buff);
2872 bRet = FALSE;
2873 goto end;
2874 }
2875
2876 /* Trim the path by adding ellipses to the end, e.g:
2877 * A very long file name.txt ==> A very...
2878 */
2879 dwLen = strlenW(lpszPath);
2880
2881 if (dwLen > MAX_PATH - 3)
2882 dwLen = MAX_PATH - 3;
2883 strncpyW(buff, sFile, dwLen);
2884
2885 do {
2886 dwLen--;
2887 GetTextExtentPointW(hDC, buff, dwLen, &size);
2888 } while (dwLen && size.cx + dwEllipsesLen > dx);
2889
2890 if (!dwLen)
2891 {
2892 DWORD dwWritten = 0;
2893
2894 dwEllipsesLen /= 3; /* Size of a single '.' */
2895
2896 /* Write as much of the Ellipses string as possible */
2897 while (dwWritten + dwEllipsesLen < dx && dwLen < 3)
2898 {
2899 *lpszPath++ = '.';
2900 dwWritten += dwEllipsesLen;
2901 dwLen++;
2902 }
2903 *lpszPath = '\0';
2904 bRet = FALSE;
2905 }
2906 else
2907 {
2908 strcpyW(buff + dwLen, szEllipses);
2909 strcpyW(lpszPath, buff);
2910 }
2911 }
2912
2913 end:
2914 if (hdc)
2915 ReleaseDC(0, hdc);
2916
2917 return bRet;
2918 }
2919
2920 /*************************************************************************
2921 * PathGetCharTypeA [SHLWAPI.@]
2922 *
2923 * Categorise a character from a file path.
2924 *
2925 * PARAMS
2926 * ch [I] Character to get the type of
2927 *
2928 * RETURNS
2929 * A set of GCT_ bit flags (from "shlwapi.h") indicating the character type.
2930 */
2931 UINT WINAPI PathGetCharTypeA(UCHAR ch)
2932 {
2933 return PathGetCharTypeW(ch);
2934 }
2935
2936 /*************************************************************************
2937 * PathGetCharTypeW [SHLWAPI.@]
2938 *
2939 * See PathGetCharTypeA.
2940 */
2941 UINT WINAPI PathGetCharTypeW(WCHAR ch)
2942 {
2943 UINT flags = 0;
2944
2945 TRACE("(%d)\n", ch);
2946
2947 if (!ch || ch < ' ' || ch == '<' || ch == '>' ||
2948 ch == '"' || ch == '|' || ch == '/')
2949 flags = GCT_INVALID; /* Invalid */
2950 else if (ch == '*' || ch=='?')
2951 flags = GCT_WILD; /* Wildchars */
2952 else if ((ch == '\\') || (ch == ':'))
2953 return GCT_SEPARATOR; /* Path separators */
2954 else
2955 {
2956 if (ch < 126)
2957 {
2958 if ((ch & 0x1 && ch != ';') || !ch || isalnum(ch) || ch == '$' || ch == '&' || ch == '(' ||
2959 ch == '.' || ch == '@' || ch == '^' ||
2960 ch == '\'' || ch == 130 || ch == '`')
2961 flags |= GCT_SHORTCHAR; /* All these are valid for DOS */
2962 }
2963 else
2964 flags |= GCT_SHORTCHAR; /* Bug compatible with win32 */
2965 flags |= GCT_LFNCHAR; /* Valid for long file names */
2966 }
2967 return flags;
2968 }
2969
2970 /*************************************************************************
2971 * SHLWAPI_UseSystemForSystemFolders
2972 *
2973 * Internal helper for PathMakeSystemFolderW.
2974 */
2975 static BOOL WINAPI SHLWAPI_UseSystemForSystemFolders()
2976 {
2977 static BOOL bCheckedReg = FALSE;
2978 static BOOL bUseSystemForSystemFolders = FALSE;
2979
2980 if (!bCheckedReg)
2981 {
2982 bCheckedReg = TRUE;
2983
2984 /* Key tells Win what file attributes to use on system folders */
2985 if (SHGetValueA(HKEY_LOCAL_MACHINE,
2986 "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer",
2987 "UseSystemForSystemFolders", 0, 0, 0))
2988 bUseSystemForSystemFolders = TRUE;
2989 }
2990 return bUseSystemForSystemFolders;
2991 }
2992
2993 /*************************************************************************
2994 * PathMakeSystemFolderA [SHLWAPI.@]
2995 *
2996 * Set system folder attribute for a path.
2997 *
2998 * PARAMS
2999 * lpszPath [I] The path to turn into a system folder
3000 *
3001 * RETURNS
3002 * TRUE If the path was changed to/already was a system folder
3003 * FALSE If the path is invalid or SetFileAttributesA() fails
3004 */
3005 BOOL WINAPI PathMakeSystemFolderA(LPCSTR lpszPath)
3006 {
3007 BOOL bRet = FALSE;
3008
3009 TRACE("(%s)\n", debugstr_a(lpszPath));
3010
3011 if (lpszPath && *lpszPath)
3012 {
3013 WCHAR szPath[MAX_PATH];
3014 MultiByteToWideChar(CP_ACP,0,lpszPath,-1,szPath,MAX_PATH);
3015 bRet = PathMakeSystemFolderW(szPath);
3016 }
3017 return bRet;
3018 }
3019
3020 /*************************************************************************
3021 * PathMakeSystemFolderW [SHLWAPI.@]
3022 *
3023 * See PathMakeSystemFolderA.
3024 */
3025 BOOL WINAPI PathMakeSystemFolderW(LPCWSTR lpszPath)
3026 {
3027 DWORD dwDefaultAttr = FILE_ATTRIBUTE_READONLY, dwAttr;
3028 WCHAR buff[MAX_PATH];
3029
3030 TRACE("(%s)\n", debugstr_w(lpszPath));
3031
3032 if (!lpszPath || !*lpszPath)
3033 return FALSE;
3034
3035 /* If the directory is already a system directory, don't do anything */
3036 GetSystemDirectoryW(buff, MAX_PATH);
3037 if (!strcmpW(buff, lpszPath))
3038 return TRUE;
3039
3040 GetWindowsDirectoryW(buff, MAX_PATH);
3041 if (!strcmpW(buff, lpszPath))
3042 return TRUE;
3043
3044 /* "UseSystemForSystemFolders" Tells Win what attributes to use */
3045 if (SHLWAPI_UseSystemForSystemFolders())
3046 dwDefaultAttr = FILE_ATTRIBUTE_SYSTEM;
3047
3048 if ((dwAttr = GetFileAttributesW(lpszPath)) == INVALID_FILE_ATTRIBUTES)
3049 return FALSE;
3050
3051 /* Change file attributes to system attributes */
3052 dwAttr &= ~(FILE_ATTRIBUTE_SYSTEM|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_READONLY);
3053 return SetFileAttributesW(lpszPath, dwAttr | dwDefaultAttr);
3054 }
3055
3056 /*************************************************************************
3057 * PathRenameExtensionA [SHLWAPI.@]
3058 *
3059 * Swap the file extension in a path with another extension.
3060 *
3061 * PARAMS
3062 * lpszPath [I/O] Path to swap the extension in
3063 * lpszExt [I] The new extension
3064 *
3065 * RETURNS
3066 * TRUE if lpszPath was modified,
3067 * FALSE if lpszPath or lpszExt is NULL, or the new path is too long
3068 */
3069 BOOL WINAPI PathRenameExtensionA(LPSTR lpszPath, LPCSTR lpszExt)
3070 {
3071 LPSTR lpszExtension;
3072
3073 TRACE("(%s,%s)\n", debugstr_a(lpszPath), debugstr_a(lpszExt));
3074
3075 lpszExtension = PathFindExtensionA(lpszPath);
3076
3077 if (!lpszExtension || (lpszExtension - lpszPath + strlen(lpszExt) >= MAX_PATH))
3078 return FALSE;
3079
3080 strcpy(lpszExtension, lpszExt);
3081 return TRUE;
3082 }
3083
3084 /*************************************************************************
3085 * PathRenameExtensionW [SHLWAPI.@]
3086 *
3087 * See PathRenameExtensionA.
3088 */
3089 BOOL WINAPI PathRenameExtensionW(LPWSTR lpszPath, LPCWSTR lpszExt)
3090 {
3091 LPWSTR lpszExtension;
3092
3093 TRACE("(%s,%s)\n", debugstr_w(lpszPath), debugstr_w(lpszExt));
3094
3095 lpszExtension = PathFindExtensionW(lpszPath);
3096
3097 if (!lpszExtension || (lpszExtension - lpszPath + strlenW(lpszExt) >= MAX_PATH))
3098 return FALSE;
3099
3100 strcpyW(lpszExtension, lpszExt);
3101 return TRUE;
3102 }
3103
3104 /*************************************************************************
3105 * PathSearchAndQualifyA [SHLWAPI.@]
3106 *
3107 * Determine if a given path is correct and fully qualified.
3108 *
3109 * PARAMS
3110 * lpszPath [I] Path to check
3111 * lpszBuf [O] Output for correct path
3112 * cchBuf [I] Size of lpszBuf
3113 *
3114 * RETURNS
3115 * Unknown.
3116 */
3117 BOOL WINAPI PathSearchAndQualifyA(LPCSTR lpszPath, LPSTR lpszBuf, UINT cchBuf)
3118 {
3119 TRACE("(%s,%p,0x%08x)\n", debugstr_a(lpszPath), lpszBuf, cchBuf);
3120
3121 if(SearchPathA(NULL, lpszPath, NULL, cchBuf, lpszBuf, NULL))
3122 return TRUE;
3123 return !!GetFullPathNameA(lpszPath, cchBuf, lpszBuf, NULL);
3124 }
3125
3126 /*************************************************************************
3127 * PathSearchAndQualifyW [SHLWAPI.@]
3128 *
3129 * See PathSearchAndQualifyA.
3130 */
3131 BOOL WINAPI PathSearchAndQualifyW(LPCWSTR lpszPath, LPWSTR lpszBuf, UINT cchBuf)
3132 {
3133 TRACE("(%s,%p,0x%08x)\n", debugstr_w(lpszPath), lpszBuf, cchBuf);
3134
3135 if(SearchPathW(NULL, lpszPath, NULL, cchBuf, lpszBuf, NULL))
3136 return TRUE;
3137 return !!GetFullPathNameW(lpszPath, cchBuf, lpszBuf, NULL);
3138 }
3139
3140 /*************************************************************************
3141 * PathSkipRootA [SHLWAPI.@]
3142 *
3143 * Return the portion of a path following the drive letter or mount point.
3144 *
3145 * PARAMS
3146 * lpszPath [I] The path to skip on
3147 *
3148 * RETURNS
3149 * Success: A pointer to the next character after the root.
3150 * Failure: NULL, if lpszPath is invalid, has no root or is a multibyte string.
3151 */
3152 LPSTR WINAPI PathSkipRootA(LPCSTR lpszPath)
3153 {
3154 TRACE("(%s)\n", debugstr_a(lpszPath));
3155
3156 if (!lpszPath || !*lpszPath)
3157 return NULL;
3158
3159 if (*lpszPath == '\\' && lpszPath[1] == '\\')
3160 {
3161 /* Network share: skip share server and mount point */
3162 lpszPath += 2;
3163 if ((lpszPath = StrChrA(lpszPath, '\\')) &&
3164 (lpszPath = StrChrA(lpszPath + 1, '\\')))
3165 lpszPath++;
3166 return (LPSTR)lpszPath;
3167 }
3168
3169 if (IsDBCSLeadByte(*lpszPath))
3170 return NULL;
3171
3172 /* Check x:\ */
3173 if (lpszPath[0] && lpszPath[1] == ':' && lpszPath[2] == '\\')
3174 return (LPSTR)lpszPath + 3;
3175 return NULL;
3176 }
3177
3178 /*************************************************************************
3179 * PathSkipRootW [SHLWAPI.@]
3180 *
3181 * See PathSkipRootA.
3182 */
3183 LPWSTR WINAPI PathSkipRootW(LPCWSTR lpszPath)
3184 {
3185 TRACE("(%s)\n", debugstr_w(lpszPath));
3186
3187 if (!lpszPath || !*lpszPath)
3188 return NULL;
3189
3190 if (*lpszPath == '\\' && lpszPath[1] == '\\')
3191 {
3192 /* Network share: skip share server and mount point */
3193 lpszPath += 2;
3194 if ((lpszPath = StrChrW(lpszPath, '\\')) &&
3195 (lpszPath = StrChrW(lpszPath + 1, '\\')))
3196 lpszPath++;
3197 return (LPWSTR)lpszPath;
3198 }
3199
3200 /* Check x:\ */
3201 if (lpszPath[0] && lpszPath[1] == ':' && lpszPath[2] == '\\')
3202 return (LPWSTR)lpszPath + 3;
3203 return NULL;
3204 }
3205
3206 /*************************************************************************
3207 * PathCreateFromUrlA [SHLWAPI.@]
3208 *
3209 * See PathCreateFromUrlW
3210 */
3211 HRESULT WINAPI PathCreateFromUrlA(LPCSTR pszUrl, LPSTR pszPath,
3212 LPDWORD pcchPath, DWORD dwReserved)
3213 {
3214 WCHAR bufW[MAX_PATH];
3215 WCHAR *pathW = bufW;
3216 UNICODE_STRING urlW;
3217 HRESULT ret;
3218 DWORD lenW = sizeof(bufW)/sizeof(WCHAR), lenA;
3219
3220 if(!RtlCreateUnicodeStringFromAsciiz(&urlW, pszUrl))
3221 return E_INVALIDARG;
3222 if((ret = PathCreateFromUrlW(urlW.Buffer, pathW, &lenW, dwReserved)) == E_POINTER) {
3223 pathW = HeapAlloc(GetProcessHeap(), 0, lenW * sizeof(WCHAR));
3224 ret = PathCreateFromUrlW(urlW.Buffer, pathW, &lenW, dwReserved);
3225 }
3226 if(ret == S_OK) {
3227 RtlUnicodeToMultiByteSize(&lenA, pathW, lenW * sizeof(WCHAR));
3228 if(*pcchPath > lenA) {
3229 RtlUnicodeToMultiByteN(pszPath, *pcchPath - 1, &lenA, pathW, lenW * sizeof(WCHAR));
3230 pszPath[lenA] = 0;
3231 *pcchPath = lenA;
3232 } else {
3233 *pcchPath = lenA + 1;
3234 ret = E_POINTER;
3235 }
3236 }
3237 if(pathW != bufW) HeapFree(GetProcessHeap(), 0, pathW);
3238 RtlFreeUnicodeString(&urlW);
3239 return ret;
3240 }
3241
3242 /*************************************************************************
3243 * PathCreateFromUrlW [SHLWAPI.@]
3244 *
3245 * Create a path from a URL
3246 *
3247 * PARAMS
3248 * lpszUrl [I] URL to convert into a path
3249 * lpszPath [O] Output buffer for the resulting Path
3250 * pcchPath [I] Length of lpszPath
3251 * dwFlags [I] Flags controlling the conversion
3252 *
3253 * RETURNS
3254 * Success: S_OK. lpszPath contains the URL in path format,
3255 * Failure: An HRESULT error code such as E_INVALIDARG.
3256 */
3257 HRESULT WINAPI PathCreateFromUrlW(LPCWSTR pszUrl, LPWSTR pszPath,
3258 LPDWORD pcchPath, DWORD dwReserved)
3259 {
3260 static const WCHAR file_colon[] = { 'f','i','l','e',':',0 };
3261 HRESULT hr;
3262 DWORD nslashes = 0;
3263 WCHAR *ptr;
3264
3265 TRACE("(%s,%p,%p,0x%08lx)\n", debugstr_w(pszUrl), pszPath, pcchPath, dwReserved);
3266
3267 if (!pszUrl || !pszPath || !pcchPath || !*pcchPath)
3268 return E_INVALIDARG;
3269
3270
3271 if (strncmpW(pszUrl, file_colon, 5))
3272 return E_INVALIDARG;
3273 pszUrl += 5;
3274
3275 while(*pszUrl == '/' || *pszUrl == '\\') {
3276 nslashes++;
3277 pszUrl++;
3278 }
3279
3280 if(isalphaW(*pszUrl) && (pszUrl[1] == ':' || pszUrl[1] == '|') && (pszUrl[2] == '/' || pszUrl[2] == '\\'))
3281 nslashes = 0;
3282
3283 switch(nslashes) {
3284 case 2:
3285 pszUrl -= 2;
3286 break;
3287 case 0:
3288 break;
3289 default:
3290 pszUrl -= 1;
3291 break;
3292 }
3293
3294 hr = UrlUnescapeW((LPWSTR)pszUrl, pszPath, pcchPath, 0);
3295 if(hr != S_OK) return hr;
3296
3297 for(ptr = pszPath; *ptr; ptr++)
3298 if(*ptr == '/') *ptr = '\\';
3299
3300 while(*pszPath == '\\')
3301 pszPath++;
3302
3303 if(isalphaW(*pszPath) && pszPath[1] == '|' && pszPath[2] == '\\') /* c|\ -> c:\ */
3304 pszPath[1] = ':';
3305
3306 if(nslashes == 2 && (ptr = strchrW(pszPath, '\\'))) { /* \\host\c:\ -> \\hostc:\ */
3307 ptr++;
3308 if(isalphaW(*ptr) && (ptr[1] == ':' || ptr[1] == '|') && ptr[2] == '\\') {
3309 memmove(ptr - 1, ptr, (strlenW(ptr) + 1) * sizeof(WCHAR));
3310 (*pcchPath)--;
3311 }
3312 }
3313
3314 TRACE("Returning %s\n",debugstr_w(pszPath));
3315
3316 return hr;
3317 }
3318
3319 /*************************************************************************
3320 * PathRelativePathToA [SHLWAPI.@]
3321 *
3322 * Create a relative path from one path to another.
3323 *
3324 * PARAMS
3325 * lpszPath [O] Destination for relative path
3326 * lpszFrom [I] Source path
3327 * dwAttrFrom [I] File attribute of source path
3328 * lpszTo [I] Destination path
3329 * dwAttrTo [I] File attributes of destination path
3330 *
3331 * RETURNS
3332 * TRUE If a relative path can be formed. lpszPath contains the new path
3333 * FALSE If the paths are not relavtive or any parameters are invalid
3334 *
3335 * NOTES
3336 * lpszTo should be at least MAX_PATH in length.
3337 *
3338 * Calling this function with relative paths for lpszFrom or lpszTo may
3339 * give erroneous results.
3340 *
3341 * The Win32 version of this function contains a bug where the lpszTo string
3342 * may be referenced 1 byte beyond the end of the string. As a result random
3343 * garbage may be written to the output path, depending on what lies beyond
3344 * the last byte of the string. This bug occurs because of the behaviour of
3345 * PathCommonPrefix() (see notes for that function), and no workaround seems
3346 * possible with Win32.
3347 *
3348 * This bug has been fixed here, so for example the relative path from "\\"
3349 * to "\\" is correctly determined as "." in this implementation.
3350 */
3351 BOOL WINAPI PathRelativePathToA(LPSTR lpszPath, LPCSTR lpszFrom, DWORD dwAttrFrom,
3352 LPCSTR lpszTo, DWORD dwAttrTo)
3353 {
3354 BOOL bRet = FALSE;
3355
3356 TRACE("(%p,%s,0x%08lx,%s,0x%08lx)\n", lpszPath, debugstr_a(lpszFrom),
3357 dwAttrFrom, debugstr_a(lpszTo), dwAttrTo);
3358
3359 if(lpszPath && lpszFrom && lpszTo)
3360 {
3361 WCHAR szPath[MAX_PATH];
3362 WCHAR szFrom[MAX_PATH];
3363 WCHAR szTo[MAX_PATH];
3364 MultiByteToWideChar(CP_ACP,0,lpszFrom,-1,szFrom,MAX_PATH);
3365 MultiByteToWideChar(CP_ACP,0,lpszTo,-1,szTo,MAX_PATH);
3366 bRet = PathRelativePathToW(szPath,szFrom,dwAttrFrom,szTo,dwAttrTo);
3367 WideCharToMultiByte(CP_ACP,0,szPath,-1,lpszPath,MAX_PATH,0,0);
3368 }
3369 return bRet;
3370 }
3371
3372 /*************************************************************************
3373 * PathRelativePathToW [SHLWAPI.@]
3374 *
3375 * See PathRelativePathToA.
3376 */
3377 BOOL WINAPI PathRelativePathToW(LPWSTR lpszPath, LPCWSTR lpszFrom, DWORD dwAttrFrom,
3378 LPCWSTR lpszTo, DWORD dwAttrTo)
3379 {
3380 static const WCHAR szPrevDirSlash[] = { '.', '.', '\\', '\0' };
3381 static const WCHAR szPrevDir[] = { '.', '.', '\0' };
3382 WCHAR szFrom[MAX_PATH];
3383 WCHAR szTo[MAX_PATH];
3384 DWORD dwLen;
3385
3386 TRACE("(%p,%s,0x%08lx,%s,0x%08lx)\n", lpszPath, debugstr_w(lpszFrom),
3387 dwAttrFrom, debugstr_w(lpszTo), dwAttrTo);
3388
3389 if(!lpszPath || !lpszFrom || !lpszTo)
3390 return FALSE;
3391
3392 *lpszPath = '\0';
3393 strncpyW(szFrom, lpszFrom, MAX_PATH);
3394 strncpyW(szTo, lpszTo, MAX_PATH);
3395
3396 if(!(dwAttrFrom & FILE_ATTRIBUTE_DIRECTORY))
3397 PathRemoveFileSpecW(szFrom);
3398 if(!(dwAttrFrom & FILE_ATTRIBUTE_DIRECTORY))
3399 PathRemoveFileSpecW(szTo);
3400
3401 /* Paths can only be relative if they have a common root */
3402 if(!(dwLen = PathCommonPrefixW(szFrom, szTo, 0)))
3403 return FALSE;
3404
3405 /* Strip off lpszFrom components to the root, by adding "..\" */
3406 lpszFrom = szFrom + dwLen;
3407 if (!*lpszFrom)
3408 {
3409 lpszPath[0] = '.';
3410 lpszPath[1] = '\0';
3411 }
3412 if (*lpszFrom == '\\')
3413 lpszFrom++;
3414
3415 while (*lpszFrom)
3416 {
3417 lpszFrom = PathFindNextComponentW(lpszFrom);
3418 strcatW(lpszPath, *lpszFrom ? szPrevDirSlash : szPrevDir);
3419 }
3420
3421 /* From the root add the components of lpszTo */
3422 lpszTo += dwLen;
3423 /* We check lpszTo[-1] to avoid skipping end of string. See the notes for
3424 * this function.
3425 */
3426 if (*lpszTo && lpszTo[-1])
3427 {
3428 if (*lpszTo != '\\')
3429 lpszTo--;
3430 dwLen = strlenW(lpszPath);
3431 if (dwLen + strlenW(lpszTo) >= MAX_PATH)
3432 {
3433 *lpszPath = '\0';
3434 return FALSE;
3435 }
3436 strcpyW(lpszPath + dwLen, lpszTo);
3437 }
3438 return TRUE;
3439 }
3440
3441 /*************************************************************************
3442 * PathUnmakeSystemFolderA [SHLWAPI.@]
3443 *
3444 * Remove the system folder attributes from a path.
3445 *
3446 * PARAMS
3447 * lpszPath [I] The path to remove attributes from
3448 *
3449 * RETURNS
3450 * Success: TRUE.
3451 * Failure: FALSE, if lpszPath is NULL, empty, not a directory, or calling
3452 * SetFileAttributesA() fails.
3453 */
3454 BOOL WINAPI PathUnmakeSystemFolderA(LPCSTR lpszPath)
3455 {
3456 DWORD dwAttr;
3457
3458 TRACE("(%s)\n", debugstr_a(lpszPath));
3459
3460 if (!lpszPath || !*lpszPath || (dwAttr = GetFileAttributesA(lpszPath)) == INVALID_FILE_ATTRIBUTES ||
3461 !(dwAttr & FILE_ATTRIBUTE_DIRECTORY))
3462 return FALSE;
3463
3464 dwAttr &= ~(FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM);
3465 return SetFileAttributesA(lpszPath, dwAttr);
3466 }
3467
3468 /*************************************************************************
3469 * PathUnmakeSystemFolderW [SHLWAPI.@]
3470 *
3471 * See PathUnmakeSystemFolderA.
3472 */
3473 BOOL WINAPI PathUnmakeSystemFolderW(LPCWSTR lpszPath)
3474 {
3475 DWORD dwAttr;
3476
3477 TRACE("(%s)\n", debugstr_w(lpszPath));
3478
3479 if (!lpszPath || !*lpszPath || (dwAttr = GetFileAttributesW(lpszPath)) == INVALID_FILE_ATTRIBUTES ||
3480 !(dwAttr & FILE_ATTRIBUTE_DIRECTORY))
3481 return FALSE;
3482
3483 dwAttr &= ~(FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM);
3484 return SetFileAttributesW(lpszPath, dwAttr);
3485 }
3486
3487
3488 /*************************************************************************
3489 * PathSetDlgItemPathA [SHLWAPI.@]
3490 *
3491 * Set the text of a dialog item to a path, shrinking the path to fit
3492 * if it is too big for the item.
3493 *
3494 * PARAMS
3495 * hDlg [I] Dialog handle
3496 * id [I] ID of item in the dialog
3497 * lpszPath [I] Path to set as the items text
3498 *
3499 * RETURNS
3500 * Nothing.
3501 *
3502 * NOTES
3503 * If lpszPath is NULL, a blank string ("") is set (i.e. The previous
3504 * window text is erased).
3505 */
3506 VOID WINAPI PathSetDlgItemPathA(HWND hDlg, int id, LPCSTR lpszPath)
3507 {
3508 WCHAR szPath[MAX_PATH];
3509
3510 TRACE("(%p,%8x,%s)\n",hDlg, id, debugstr_a(lpszPath));
3511
3512 if (lpszPath)
3513 MultiByteToWideChar(CP_ACP,0,lpszPath,-1,szPath,MAX_PATH);
3514 else
3515 szPath[0] = '\0';
3516 PathSetDlgItemPathW(hDlg, id, szPath);
3517 }
3518
3519 /*************************************************************************
3520 * PathSetDlgItemPathW [SHLWAPI.@]
3521 *
3522 * See PathSetDlgItemPathA.
3523 */
3524 VOID WINAPI PathSetDlgItemPathW(HWND hDlg, int id, LPCWSTR lpszPath)
3525 {
3526 WCHAR path[MAX_PATH + 1];
3527 HWND hwItem;
3528 RECT rect;
3529 HDC hdc;
3530 HGDIOBJ hPrevObj;
3531
3532 TRACE("(%p,%8x,%s)\n",hDlg, id, debugstr_w(lpszPath));
3533
3534 if (!(hwItem = GetDlgItem(hDlg, id)))
3535 return;
3536
3537 if (lpszPath)
3538 lstrcpynW(path, lpszPath, sizeof(path) / sizeof(WCHAR));
3539 else
3540 path[0] = '\0';
3541
3542 GetClientRect(hwItem, &rect);
3543 hdc = GetDC(hDlg);
3544 hPrevObj = SelectObject(hdc, (HGDIOBJ)SendMessageW(hwItem,WM_GETFONT,0,0));
3545
3546 if (hPrevObj)
3547 {
3548 PathCompactPathW(hdc, path, rect.right);
3549 SelectObject(hdc, hPrevObj);
3550 }
3551
3552 ReleaseDC(hDlg, hdc);
3553 SetWindowTextW(hwItem, path);
3554 }
3555
3556 /*************************************************************************
3557 * PathIsNetworkPathA [SHLWAPI.@]
3558 *
3559 * Determine if the given path is a network path.
3560 *
3561 * PARAMS
3562 * lpszPath [I] Path to check
3563 *
3564 * RETURNS
3565 * TRUE If lpszPath is a UNC share or mapped network drive, or
3566 * FALSE If lpszPath is a local drive or cannot be determined
3567 */
3568 BOOL WINAPI PathIsNetworkPathA(LPCSTR lpszPath)
3569 {
3570 int dwDriveNum;
3571
3572 TRACE("(%s)\n",debugstr_a(lpszPath));
3573
3574 if (!lpszPath)
3575 return FALSE;
3576 if (*lpszPath == '\\' && lpszPath[1] == '\\')
3577 return TRUE;
3578 dwDriveNum = PathGetDriveNumberA(lpszPath);
3579 if (dwDriveNum == -1)
3580 return FALSE;
3581 GET_FUNC(pIsNetDrive, shell32, (LPCSTR)66, FALSE); /* ord 66 = shell32.IsNetDrive */
3582 return pIsNetDrive(dwDriveNum);
3583 }
3584
3585 /*************************************************************************
3586 * PathIsNetworkPathW [SHLWAPI.@]
3587 *
3588 * See PathIsNetworkPathA.
3589 */
3590 BOOL WINAPI PathIsNetworkPathW(LPCWSTR lpszPath)
3591 {
3592 int dwDriveNum;
3593
3594 TRACE("(%s)\n", debugstr_w(lpszPath));
3595
3596 if (!lpszPath)
3597 return FALSE;
3598 if (*lpszPath == '\\' && lpszPath[1] == '\\')
3599 return TRUE;
3600 dwDriveNum = PathGetDriveNumberW(lpszPath);
3601 if (dwDriveNum == -1)
3602 return FALSE;
3603 GET_FUNC(pIsNetDrive, shell32, (LPCSTR)66, FALSE); /* ord 66 = shell32.IsNetDrive */
3604 return pIsNetDrive(dwDriveNum);
3605 }
3606
3607 /*************************************************************************
3608 * PathIsLFNFileSpecA [SHLWAPI.@]
3609 *
3610 * Determine if the given path is a long file name
3611 *
3612 * PARAMS
3613 * lpszPath [I] Path to check
3614 *
3615 * RETURNS
3616 * TRUE If path is a long file name,
3617 * FALSE If path is a valid DOS short file name
3618 */
3619 BOOL WINAPI PathIsLFNFileSpecA(LPCSTR lpszPath)
3620 {
3621 DWORD dwNameLen = 0, dwExtLen = 0;
3622
3623 TRACE("(%s)\n",debugstr_a(lpszPath));
3624
3625 if (!lpszPath)
3626 return FALSE;
3627
3628 while (*lpszPath)
3629 {
3630 if (*lpszPath == ' ')
3631 return TRUE; /* DOS names cannot have spaces */
3632 if (*lpszPath == '.')
3633 {
3634 if (dwExtLen)
3635 return TRUE; /* DOS names have only one dot */
3636 dwExtLen = 1;
3637 }
3638 else if (dwExtLen)
3639 {
3640 dwExtLen++;
3641 if (dwExtLen > 4)
3642 return TRUE; /* DOS extensions are <= 3 chars*/
3643 }
3644 else
3645 {
3646 dwNameLen++;
3647 if (dwNameLen > 8)
3648 return TRUE; /* DOS names are <= 8 chars */
3649 }
3650 lpszPath += IsDBCSLeadByte(*lpszPath) ? 2 : 1;
3651 }
3652 return FALSE; /* Valid DOS path */
3653 }
3654
3655 /*************************************************************************
3656 * PathIsLFNFileSpecW [SHLWAPI.@]
3657 *
3658 * See PathIsLFNFileSpecA.
3659 */
3660 BOOL WINAPI PathIsLFNFileSpecW(LPCWSTR lpszPath)
3661 {
3662 DWORD dwNameLen = 0, dwExtLen = 0;
3663
3664 TRACE("(%s)\n",debugstr_w(lpszPath));
3665
3666 if (!lpszPath)
3667 return FALSE;
3668
3669 while (*lpszPath)
3670 {
3671 if (*lpszPath == ' ')
3672 return TRUE; /* DOS names cannot have spaces */
3673 if (*lpszPath == '.')
3674 {
3675 if (dwExtLen)
3676 return TRUE; /* DOS names have only one dot */
3677 dwExtLen = 1;
3678 }
3679 else if (dwExtLen)
3680 {
3681 dwExtLen++;
3682 if (dwExtLen > 4)
3683 return TRUE; /* DOS extensions are <= 3 chars*/
3684 }
3685 else
3686 {
3687 dwNameLen++;
3688 if (dwNameLen > 8)
3689 return TRUE; /* DOS names are <= 8 chars */
3690 }
3691 lpszPath++;
3692 }
3693 return FALSE; /* Valid DOS path */
3694 }
3695
3696 /*************************************************************************
3697 * PathIsDirectoryEmptyA [SHLWAPI.@]
3698 *
3699 * Determine if a given directory is empty.
3700 *
3701 * PARAMS
3702 * lpszPath [I] Directory to check
3703 *
3704 * RETURNS
3705 * TRUE If the directory exists and contains no files,
3706 * FALSE Otherwise
3707 */
3708 BOOL WINAPI PathIsDirectoryEmptyA(LPCSTR lpszPath)
3709 {
3710 BOOL bRet = FALSE;
3711
3712 TRACE("(%s)\n",debugstr_a(lpszPath));
3713
3714 if (lpszPath)
3715 {
3716 WCHAR szPath[MAX_PATH];
3717 MultiByteToWideChar(CP_ACP,0,lpszPath,-1,szPath,MAX_PATH);
3718 bRet = PathIsDirectoryEmptyW(szPath);
3719 }
3720 return bRet;
3721 }
3722
3723 /*************************************************************************
3724 * PathIsDirectoryEmptyW [SHLWAPI.@]
3725 *
3726 * See PathIsDirectoryEmptyA.
3727 */
3728 BOOL WINAPI PathIsDirectoryEmptyW(LPCWSTR lpszPath)
3729 {
3730 static const WCHAR szAllFiles[] = { '*', '.', '*', '\0' };
3731 WCHAR szSearch[MAX_PATH];
3732 DWORD dwLen;
3733 HANDLE hfind;
3734 BOOL retVal = FALSE;
3735 WIN32_FIND_DATAW find_data;
3736
3737 TRACE("(%s)\n",debugstr_w(lpszPath));
3738
3739 if (!lpszPath || !PathIsDirectoryW(lpszPath))
3740 return FALSE;
3741
3742 strncpyW(szSearch, lpszPath, MAX_PATH);
3743 PathAddBackslashW(szSearch);
3744 dwLen = strlenW(szSearch);
3745 if (dwLen > MAX_PATH - 4)
3746 return FALSE;
3747
3748 strcpyW(szSearch + dwLen, szAllFiles);
3749 hfind = FindFirstFileW(szSearch, &find_data);
3750
3751 if (hfind != INVALID_HANDLE_VALUE &&
3752 find_data.cFileName[0] == '.' &&
3753 find_data.cFileName[1] == '.')
3754 {
3755 /* The only directory entry should be the parent */
3756 if (!FindNextFileW(hfind, &find_data))
3757 retVal = TRUE;
3758 FindClose(hfind);
3759 }
3760 return retVal;
3761 }
3762
3763
3764 /*************************************************************************
3765 * PathFindSuffixArrayA [SHLWAPI.@]
3766 *
3767 * Find a suffix string in an array of suffix strings
3768 *
3769 * PARAMS
3770 * lpszSuffix [I] Suffix string to search for
3771 * lppszArray [I] Array of suffix strings to search
3772 * dwCount [I] Number of elements in lppszArray
3773 *
3774 * RETURNS
3775 * Success: The index of the position of lpszSuffix in lppszArray
3776 * Failure: 0, if any parameters are invalid or lpszSuffix is not found
3777 *
3778 * NOTES
3779 * The search is case sensitive.
3780 * The match is made against the end of the suffix string, so for example:
3781 * lpszSuffix="fooBAR" matches "BAR", but lpszSuffix="fooBARfoo" does not.
3782 */
3783 LPCSTR WINAPI PathFindSuffixArrayA(LPCSTR lpszSuffix, LPCSTR *lppszArray, int dwCount)
3784 {
3785 size_t dwLen;
3786 int dwRet = 0;
3787
3788 TRACE("(%s,%p,%d)\n",debugstr_a(lpszSuffix), lppszArray, dwCount);
3789
3790 if (lpszSuffix && lppszArray && dwCount > 0)
3791 {
3792 dwLen = strlen(lpszSuffix);
3793
3794 while (dwRet < dwCount)
3795 {
3796 size_t dwCompareLen = strlen(*lppszArray);
3797 if (dwCompareLen < dwLen)
3798 {
3799 if (!strcmp(lpszSuffix + dwLen - dwCompareLen, *lppszArray))
3800 return *lppszArray; /* Found */
3801 }
3802 dwRet++;
3803 lppszArray++;
3804 }
3805 }
3806 return NULL;
3807 }
3808
3809 /*************************************************************************
3810 * PathFindSuffixArrayW [SHLWAPI.@]
3811 *
3812 * See PathFindSuffixArrayA.
3813 */
3814 LPCWSTR WINAPI PathFindSuffixArrayW(LPCWSTR lpszSuffix, LPCWSTR *lppszArray, int dwCount)
3815 {
3816 size_t dwLen;
3817 int dwRet = 0;
3818
3819 TRACE("(%s,%p,%d)\n",debugstr_w(lpszSuffix), lppszArray, dwCount);
3820
3821 if (lpszSuffix && lppszArray && dwCount > 0)
3822 {
3823 dwLen = strlenW(lpszSuffix);
3824
3825 while (dwRet < dwCount)
3826 {
3827 size_t dwCompareLen = strlenW(*lppszArray);
3828 if (dwCompareLen < dwLen)
3829 {
3830 if (!strcmpW(lpszSuffix + dwLen - dwCompareLen, *lppszArray))
3831 return *lppszArray; /* Found */
3832 }
3833 dwRet++;
3834 lppszArray++;
3835 }
3836 }
3837 return NULL;
3838 }
3839
3840 /*************************************************************************
3841 * PathUndecorateA [SHLWAPI.@]
3842 *
3843 * Undecorate a file path
3844 *
3845 * PARAMS
3846 * lpszPath [I/O] Path to remove any decoration from
3847 *
3848 * RETURNS
3849 * Nothing
3850 *
3851 * NOTES
3852 * A decorations form is "path[n].ext" where "n" is an optional decimal number.
3853 */
3854 VOID WINAPI PathUndecorateA(LPSTR lpszPath)
3855 {
3856 TRACE("(%s)\n",debugstr_a(lpszPath));
3857
3858 if (lpszPath)
3859 {
3860 LPSTR lpszExt = PathFindExtensionA(lpszPath);
3861 if (lpszExt > lpszPath && lpszExt[-1] == ']')
3862 {
3863 LPSTR lpszSkip = lpszExt - 2;
3864 if (*lpszSkip == '[')
3865 lpszSkip++; /* [] (no number) */
3866 else
3867 while (lpszSkip > lpszPath && isdigit(lpszSkip[-1]))
3868 lpszSkip--;
3869 if (lpszSkip > lpszPath && lpszSkip[-1] == '[' && lpszSkip[-2] != '\\')
3870 {
3871 /* remove the [n] */
3872 lpszSkip--;
3873 while (*lpszExt)
3874 *lpszSkip++ = *lpszExt++;
3875 *lpszSkip = '\0';
3876 }
3877 }
3878 }
3879 }
3880
3881 /*************************************************************************
3882 * PathUndecorateW [SHLWAPI.@]
3883 *
3884 * See PathUndecorateA.
3885 */
3886 VOID WINAPI PathUndecorateW(LPWSTR lpszPath)
3887 {
3888 TRACE("(%s)\n",debugstr_w(lpszPath));
3889
3890 if (lpszPath)
3891 {
3892 LPWSTR lpszExt = PathFindExtensionW(lpszPath);
3893 if (lpszExt > lpszPath && lpszExt[-1] == ']')
3894 {
3895 LPWSTR lpszSkip = lpszExt - 2;
3896 if (*lpszSkip == '[')
3897 lpszSkip++; /* [] (no number) */
3898 else
3899 while (lpszSkip > lpszPath && isdigitW(lpszSkip[-1]))
3900 lpszSkip--;
3901 if (lpszSkip > lpszPath && lpszSkip[-1] == '[' && lpszSkip[-2] != '\\')
3902 {
3903 /* remove the [n] */
3904 lpszSkip--;
3905 while (*lpszExt)
3906 *lpszSkip++ = *lpszExt++;
3907 *lpszSkip = '\0';
3908 }
3909 }
3910 }
3911 }
3912
3913 /*************************************************************************
3914 * PathUnExpandEnvStringsA [SHLWAPI.@]
3915 *
3916 * Substitute folder names in a path with their corresponding environment
3917 * strings.
3918 *
3919 * PARAMS
3920 * pszPath [I] Buffer containing the path to unexpand.
3921 * pszBuf [O] Buffer to receive the unexpanded path.
3922 * cchBuf [I] Size of pszBuf in characters.
3923 *
3924 * RETURNS
3925 * Success: TRUE
3926 * Failure: FALSE
3927 */
3928 BOOL WINAPI PathUnExpandEnvStringsA(LPCSTR pszPath, LPSTR pszBuf, UINT cchBuf)
3929 {
3930 FIXME("(%s,%s,0x%08x)\n", debugstr_a(pszPath), debugstr_a(pszBuf), cchBuf);
3931 return FALSE;
3932 }
3933
3934 /*************************************************************************
3935 * PathUnExpandEnvStringsW [SHLWAPI.@]
3936 *
3937 * Unicode version of PathUnExpandEnvStringsA.
3938 */
3939 BOOL WINAPI PathUnExpandEnvStringsW(LPCWSTR pszPath, LPWSTR pszBuf, UINT cchBuf)
3940 {
3941 FIXME("(%s,%s,0x%08x)\n", debugstr_w(pszPath), debugstr_w(pszBuf), cchBuf);
3942 return FALSE;
3943 }
3944
3945 /*************************************************************************
3946 * @ [SHLWAPI.440]
3947 *
3948 * Find localised or default web content in "%WINDOWS%\web\".
3949 *
3950 * PARAMS
3951 * lpszFile [I] File name containing content to look for
3952 * lpszPath [O] Buffer to contain the full path to the file
3953 * dwPathLen [I] Length of lpszPath
3954 *
3955 * RETURNS
3956 * Success: S_OK. lpszPath contains the full path to the content.
3957 * Failure: E_FAIL. The content does not exist or lpszPath is too short.
3958 */
3959 HRESULT WINAPI SHGetWebFolderFilePathA(LPCSTR lpszFile, LPSTR lpszPath, DWORD dwPathLen)
3960 {
3961 WCHAR szFile[MAX_PATH], szPath[MAX_PATH];
3962 HRESULT hRet;
3963
3964 TRACE("(%s,%p,%ld)\n", lpszFile, lpszPath, dwPathLen);
3965
3966 MultiByteToWideChar(CP_ACP, 0, lpszFile, -1, szFile, MAX_PATH);
3967 szPath[0] = '\0';
3968 hRet = SHGetWebFolderFilePathW(szFile, szPath, dwPathLen);
3969 WideCharToMultiByte(CP_ACP, 0, szPath, -1, lpszPath, dwPathLen, 0, 0);
3970 return hRet;<