Precision: r58138 was part 2a/3 of my changes.
[reactos.git] / reactos / dll / win32 / kernel32 / client / path.c
1 /*
2 * PROJECT: ReactOS Win32 Base API
3 * LICENSE: GPL - See COPYING in the top level directory
4 * FILE: dll/win32/kernel32/client/path.c
5 * PURPOSE: Handles path APIs
6 * PROGRAMMERS: Alex Ionescu (alex.ionescu@reactos.org)
7 */
8
9 /* INCLUDES *******************************************************************/
10
11 #include <k32.h>
12
13 #define NDEBUG
14 #include <debug.h>
15
16 /* GLOBALS ********************************************************************/
17
18 UNICODE_STRING NoDefaultCurrentDirectoryInExePath = RTL_CONSTANT_STRING(L"NoDefaultCurrentDirectoryInExePath");
19
20 UNICODE_STRING BaseWindowsSystemDirectory, BaseWindowsDirectory;
21 UNICODE_STRING BaseDefaultPathAppend, BaseDefaultPath, BaseDllDirectory;
22
23 PVOID gpTermsrvGetWindowsDirectoryA;
24 PVOID gpTermsrvGetWindowsDirectoryW;
25
26 /* This is bitmask for each illegal filename character */
27 /* If someone has time, please feel free to use 0b notation */
28 DWORD IllegalMask[4] =
29 {
30 0xFFFFFFFF, // None allowed (00 to 1F)
31 0xFC009C05, // 20, 22, 2A, 2B, 2C, 2F, 3A, 3B, 3C, 3D, 3E, 3F not allowed
32 0x38000000, // 5B, 5C, 5D not allowed
33 0x10000000 // 7C not allowed
34 };
35
36 BASE_SEARCH_PATH_TYPE BaseDllOrderCurrent[BaseCurrentDirPlacementMax][BaseSearchPathMax] =
37 {
38 {
39 BaseSearchPathApp,
40 BaseSearchPathCurrent,
41 BaseSearchPathDefault,
42 BaseSearchPathEnv,
43 BaseSearchPathInvalid
44 },
45 {
46 BaseSearchPathApp,
47 BaseSearchPathDefault,
48 BaseSearchPathCurrent,
49 BaseSearchPathEnv,
50 BaseSearchPathInvalid
51 }
52 };
53
54 BASE_SEARCH_PATH_TYPE BaseProcessOrderNoCurrent[BaseSearchPathMax] =
55 {
56 BaseSearchPathApp,
57 BaseSearchPathDefault,
58 BaseSearchPathEnv,
59 BaseSearchPathInvalid,
60 BaseSearchPathInvalid
61 };
62
63 BASE_SEARCH_PATH_TYPE BaseDllOrderNoCurrent[BaseSearchPathMax] =
64 {
65 BaseSearchPathApp,
66 BaseSearchPathDll,
67 BaseSearchPathDefault,
68 BaseSearchPathEnv,
69 BaseSearchPathInvalid
70 };
71
72 BASE_SEARCH_PATH_TYPE BaseProcessOrder[BaseSearchPathMax] =
73 {
74 BaseSearchPathApp,
75 BaseSearchPathCurrent,
76 BaseSearchPathDefault,
77 BaseSearchPathEnv,
78 BaseSearchPathInvalid
79 };
80
81 BASE_CURRENT_DIR_PLACEMENT BasepDllCurrentDirPlacement = BaseCurrentDirPlacementInvalid;
82
83 extern UNICODE_STRING BasePathVariableName;
84
85 /* PRIVATE FUNCTIONS **********************************************************/
86
87 PWCHAR
88 WINAPI
89 BasepEndOfDirName(IN PWCHAR FileName)
90 {
91 PWCHAR FileNameEnd, FileNameSeparator;
92
93 /* Find the first slash */
94 FileNameSeparator = wcschr(FileName, OBJ_NAME_PATH_SEPARATOR);
95 if (FileNameSeparator)
96 {
97 /* Find the last one */
98 FileNameEnd = wcsrchr(FileNameSeparator, OBJ_NAME_PATH_SEPARATOR);
99 ASSERT(FileNameEnd);
100
101 /* Handle the case where they are one and the same */
102 if (FileNameEnd == FileNameSeparator) FileNameEnd++;
103 }
104 else
105 {
106 /* No directory was specified */
107 FileNameEnd = NULL;
108 }
109
110 /* Return where the directory ends and the filename starts */
111 return FileNameEnd;
112 }
113
114 LPWSTR
115 WINAPI
116 BasepComputeProcessPath(IN PBASE_SEARCH_PATH_TYPE PathOrder,
117 IN LPWSTR AppName,
118 IN LPVOID Environment)
119 {
120 PWCHAR PathBuffer, Buffer, AppNameEnd, PathCurrent;
121 ULONG PathLengthInBytes;
122 NTSTATUS Status;
123 UNICODE_STRING EnvPath;
124 PBASE_SEARCH_PATH_TYPE Order;
125
126 /* Initialize state */
127 AppNameEnd = Buffer = PathBuffer = NULL;
128 Status = STATUS_SUCCESS;
129 PathLengthInBytes = 0;
130
131 /* Loop the ordering array */
132 for (Order = PathOrder; *Order != BaseSearchPathInvalid; Order++) {
133 switch (*Order)
134 {
135 /* Compute the size of the DLL path */
136 case BaseSearchPathDll:
137
138 /* This path only gets called if SetDllDirectory was called */
139 ASSERT(BaseDllDirectory.Buffer != NULL);
140
141 /* Make sure there's a DLL directory size */
142 if (BaseDllDirectory.Length)
143 {
144 /* Add it, plus the separator */
145 PathLengthInBytes += BaseDllDirectory.Length + sizeof(L';');
146 }
147 break;
148
149 /* Compute the size of the current path */
150 case BaseSearchPathCurrent:
151
152 /* Add ".;" */
153 PathLengthInBytes += (2 * sizeof(WCHAR));
154 break;
155
156 /* Compute the size of the "PATH" environment variable */
157 case BaseSearchPathEnv:
158
159 /* Grab PEB lock if one wasn't passed in */
160 if (!Environment) RtlAcquirePebLock();
161
162 /* Query the size first */
163 EnvPath.MaximumLength = 0;
164 Status = RtlQueryEnvironmentVariable_U(Environment,
165 &BasePathVariableName,
166 &EnvPath);
167 if (Status == STATUS_BUFFER_TOO_SMALL)
168 {
169 /* Compute the size we'll need for the environment */
170 EnvPath.MaximumLength = EnvPath.Length + sizeof(WCHAR);
171 if ((EnvPath.Length + sizeof(WCHAR)) > UNICODE_STRING_MAX_BYTES)
172 {
173 /* Don't let it overflow */
174 EnvPath.MaximumLength = EnvPath.Length;
175 }
176
177 /* Allocate the environment buffer */
178 Buffer = RtlAllocateHeap(RtlGetProcessHeap(),
179 0,
180 EnvPath.MaximumLength);
181 if (Buffer)
182 {
183 /* Now query the PATH environment variable */
184 EnvPath.Buffer = Buffer;
185 Status = RtlQueryEnvironmentVariable_U(Environment,
186 &BasePathVariableName,
187 &EnvPath);
188 }
189 else
190 {
191 /* Failure case */
192 Status = STATUS_NO_MEMORY;
193 }
194 }
195
196 /* Release the PEB lock from above */
197 if (!Environment) RtlReleasePebLock();
198
199 /* There might not be a PATH */
200 if (Status == STATUS_VARIABLE_NOT_FOUND)
201 {
202 /* In this case, skip this PathOrder */
203 EnvPath.Length = EnvPath.MaximumLength = 0;
204 Status = STATUS_SUCCESS;
205 }
206 else if (!NT_SUCCESS(Status))
207 {
208 /* An early failure, go to exit code */
209 goto Quickie;
210 }
211 else
212 {
213 /* Add the length of the PATH variable */
214 ASSERT(!(EnvPath.Length & 1));
215 PathLengthInBytes += (EnvPath.Length + sizeof(L';'));
216 }
217 break;
218
219 /* Compute the size of the default search path */
220 case BaseSearchPathDefault:
221
222 /* Just add it... it already has a ';' at the end */
223 ASSERT(!(BaseDefaultPath.Length & 1));
224 PathLengthInBytes += BaseDefaultPath.Length;
225 break;
226
227 /* Compute the size of the current app directory */
228 case BaseSearchPathApp:
229 /* Find out where the app name ends, to get only the directory */
230 if (AppName) AppNameEnd = BasepEndOfDirName(AppName);
231
232 /* Check if there was no application name passed in */
233 if (!(AppName) || !(AppNameEnd))
234 {
235 /* Do we have a per-thread CURDIR to use? */
236 if (NtCurrentTeb()->NtTib.SubSystemTib)
237 {
238 /* This means someone added RTL_PERTHREAD_CURDIR */
239 UNIMPLEMENTED_DBGBREAK();
240 }
241
242 /* We do not. Do we have the LDR_ENTRY for the executable? */
243 if (!BasepExeLdrEntry)
244 {
245 /* We do not. Grab it */
246 LdrEnumerateLoadedModules(0,
247 BasepLocateExeLdrEntry,
248 NtCurrentPeb()->ImageBaseAddress);
249 }
250
251 /* Now do we have it? */
252 if (BasepExeLdrEntry)
253 {
254 /* Yes, so read the name out of it */
255 AppName = BasepExeLdrEntry->FullDllName.Buffer;
256 }
257
258 /* Find out where the app name ends, to get only the directory */
259 if (AppName) AppNameEnd = BasepEndOfDirName(AppName);
260 }
261
262 /* So, do we have an application name and its directory? */
263 if ((AppName) && (AppNameEnd))
264 {
265 /* Add the size of the app's directory, plus the separator */
266 PathLengthInBytes += ((AppNameEnd - AppName) * sizeof(WCHAR)) + sizeof(L';');
267 }
268 break;
269
270 default:
271 break;
272 }
273 }
274
275 /* Bam, all done, we now have the final path size */
276 ASSERT(PathLengthInBytes > 0);
277 ASSERT(!(PathLengthInBytes & 1));
278
279 /* Allocate the buffer to hold it */
280 PathBuffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, PathLengthInBytes);
281 if (!PathBuffer)
282 {
283 /* Failure path */
284 Status = STATUS_NO_MEMORY;
285 goto Quickie;
286 }
287
288 /* Now we loop again, this time to copy the data */
289 PathCurrent = PathBuffer;
290 for (Order = PathOrder; *Order != BaseSearchPathInvalid; Order++) {
291 switch (*Order)
292 {
293 /* Add the DLL path */
294 case BaseSearchPathDll:
295 if (BaseDllDirectory.Length)
296 {
297 /* Copy it in the buffer, ASSERT there's enough space */
298 ASSERT((((PathCurrent - PathBuffer + 1) * sizeof(WCHAR)) + BaseDllDirectory.Length) <= PathLengthInBytes);
299 RtlCopyMemory(PathCurrent,
300 BaseDllDirectory.Buffer,
301 BaseDllDirectory.Length);
302
303 /* Update the current pointer, add a separator */
304 PathCurrent += (BaseDllDirectory.Length / sizeof(WCHAR));
305 *PathCurrent++ = ';';
306 }
307 break;
308
309 /* Add the current application path */
310 case BaseSearchPathApp:
311 if ((AppName) && (AppNameEnd))
312 {
313 /* Copy it in the buffer, ASSERT there's enough space */
314 ASSERT(((PathCurrent - PathBuffer + 1 + (AppNameEnd - AppName)) * sizeof(WCHAR)) <= PathLengthInBytes);
315 RtlCopyMemory(PathCurrent,
316 AppName,
317 (AppNameEnd - AppName) * sizeof(WCHAR));
318
319 /* Update the current pointer, add a separator */
320 PathCurrent += AppNameEnd - AppName;
321 *PathCurrent++ = ';';
322 }
323 break;
324
325 /* Add the default search path */
326 case BaseSearchPathDefault:
327 /* Copy it in the buffer, ASSERT there's enough space */
328 ASSERT((((PathCurrent - PathBuffer) * sizeof(WCHAR)) + BaseDefaultPath.Length) <= PathLengthInBytes);
329 RtlCopyMemory(PathCurrent, BaseDefaultPath.Buffer, BaseDefaultPath.Length);
330
331 /* Update the current pointer. The default path already has a ";" */
332 PathCurrent += (BaseDefaultPath.Length / sizeof(WCHAR));
333 break;
334
335 /* Add the path in the PATH environment variable */
336 case BaseSearchPathEnv:
337 if (EnvPath.Length)
338 {
339 /* Copy it in the buffer, ASSERT there's enough space */
340 ASSERT((((PathCurrent - PathBuffer + 1) * sizeof(WCHAR)) + EnvPath.Length) <= PathLengthInBytes);
341 RtlCopyMemory(PathCurrent, EnvPath.Buffer, EnvPath.Length);
342
343 /* Update the current pointer, add a separator */
344 PathCurrent += (EnvPath.Length / sizeof(WCHAR));
345 *PathCurrent++ = ';';
346 }
347 break;
348
349 /* Add the current dierctory */
350 case BaseSearchPathCurrent:
351
352 /* Copy it in the buffer, ASSERT there's enough space */
353 ASSERT(((PathCurrent - PathBuffer + 2) * sizeof(WCHAR)) <= PathLengthInBytes);
354 *PathCurrent++ = '.';
355
356 /* Add the path separator */
357 *PathCurrent++ = ';';
358 break;
359
360 default:
361 break;
362 }
363 }
364
365 /* Everything should've perfectly fit in there */
366 ASSERT((PathCurrent - PathBuffer) * sizeof(WCHAR) == PathLengthInBytes);
367 ASSERT(PathCurrent > PathBuffer);
368
369 /* Terminate the whole thing */
370 PathCurrent[-1] = UNICODE_NULL;
371
372 Quickie:
373 /* Exit path: free our buffers */
374 if (Buffer) RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
375 if (PathBuffer)
376 {
377 /* This only gets freed in the failure path, since caller wants it */
378 if (!NT_SUCCESS(Status))
379 {
380 RtlFreeHeap(RtlGetProcessHeap(), 0, PathBuffer);
381 PathBuffer = NULL;
382 }
383 }
384
385 /* Return the path! */
386 return PathBuffer;
387 }
388
389 LPWSTR
390 WINAPI
391 BaseComputeProcessSearchPath(VOID)
392 {
393 DPRINT("Computing Process Search path\n");
394
395 /* Compute the path using default process order */
396 return BasepComputeProcessPath(BaseProcessOrder, NULL, NULL);
397 }
398
399 LPWSTR
400 WINAPI
401 BaseComputeProcessExePath(IN LPWSTR FullPath)
402 {
403 PBASE_SEARCH_PATH_TYPE PathOrder;
404 DPRINT1("Computing EXE path: %wZ\n", FullPath);
405
406 /* Check if we should use the current directory */
407 PathOrder = NeedCurrentDirectoryForExePathW(FullPath) ?
408 BaseProcessOrder : BaseProcessOrderNoCurrent;
409
410 /* And now compute the path */
411 return BasepComputeProcessPath(PathOrder, NULL, NULL);
412 }
413
414 LPWSTR
415 WINAPI
416 BaseComputeProcessDllPath(IN LPWSTR FullPath,
417 IN PVOID Environment)
418 {
419 LPWSTR DllPath = NULL;
420 UNICODE_STRING KeyName = RTL_CONSTANT_STRING(L"\\Registry\\MACHINE\\System\\CurrentControlSet\\Control\\Session Manager");
421 UNICODE_STRING ValueName = RTL_CONSTANT_STRING(L"SafeDllSearchMode");
422 OBJECT_ATTRIBUTES ObjectAttributes = RTL_CONSTANT_OBJECT_ATTRIBUTES(&KeyName, OBJ_CASE_INSENSITIVE);
423 KEY_VALUE_PARTIAL_INFORMATION PartialInfo;
424 HANDLE KeyHandle;
425 NTSTATUS Status;
426 ULONG ResultLength;
427 BASE_CURRENT_DIR_PLACEMENT CurrentDirPlacement, OldCurrentDirPlacement;
428
429 /* Acquire DLL directory lock */
430 RtlEnterCriticalSection(&BaseDllDirectoryLock);
431
432 /* Check if we have a base dll directory */
433 if (BaseDllDirectory.Buffer)
434 {
435 /* Then compute the process path using DLL order (without curdir) */
436 DllPath = BasepComputeProcessPath(BaseDllOrderNoCurrent, FullPath, Environment);
437
438 /* Release DLL directory lock */
439 RtlLeaveCriticalSection(&BaseDllDirectoryLock);
440
441 /* Return dll path */
442 return DllPath;
443 }
444
445 /* Release DLL directory lock */
446 RtlLeaveCriticalSection(&BaseDllDirectoryLock);
447
448 /* Read the current placement */
449 CurrentDirPlacement = BasepDllCurrentDirPlacement;
450 if (CurrentDirPlacement == BaseCurrentDirPlacementInvalid)
451 {
452 /* Open the configuration key */
453 Status = NtOpenKey(&KeyHandle, KEY_QUERY_VALUE, &ObjectAttributes);
454 if (NT_SUCCESS(Status))
455 {
456 /* Query if safe search is enabled */
457 Status = NtQueryValueKey(KeyHandle,
458 &ValueName,
459 KeyValuePartialInformation,
460 &PartialInfo,
461 sizeof(PartialInfo),
462 &ResultLength);
463 if (NT_SUCCESS(Status))
464 {
465 /* Read the value if the size is OK */
466 if (ResultLength == sizeof(PartialInfo))
467 {
468 CurrentDirPlacement = *(PULONG)PartialInfo.Data;
469 }
470 }
471
472 /* Close the handle */
473 NtClose(KeyHandle);
474
475 /* Validate the registry value */
476 if ((CurrentDirPlacement <= BaseCurrentDirPlacementInvalid) ||
477 (CurrentDirPlacement >= BaseCurrentDirPlacementMax))
478 {
479 /* Default to safe search */
480 CurrentDirPlacement = BaseCurrentDirPlacementSafe;
481 }
482 }
483
484 /* Update the placement and read the old one */
485 OldCurrentDirPlacement = InterlockedCompareExchange((PLONG)&BasepDllCurrentDirPlacement,
486 CurrentDirPlacement,
487 BaseCurrentDirPlacementInvalid);
488 if (OldCurrentDirPlacement != BaseCurrentDirPlacementInvalid)
489 {
490 /* If there already was a placement, use it */
491 CurrentDirPlacement = OldCurrentDirPlacement;
492 }
493 }
494
495 /* Check if the placement is invalid or not set */
496 if ((CurrentDirPlacement <= BaseCurrentDirPlacementInvalid) ||
497 (CurrentDirPlacement >= BaseCurrentDirPlacementMax))
498 {
499 /* Default to safe search */
500 CurrentDirPlacement = BaseCurrentDirPlacementSafe;
501 }
502
503 /* Compute the process path using either normal or safe search */
504 DllPath = BasepComputeProcessPath(BaseDllOrderCurrent[CurrentDirPlacement],
505 FullPath,
506 Environment);
507
508 /* Return dll path */
509 return DllPath;
510 }
511
512 BOOLEAN
513 WINAPI
514 CheckForSameCurdir(IN PUNICODE_STRING DirName)
515 {
516 PUNICODE_STRING CurDir;
517 USHORT CurLength;
518 BOOLEAN Result;
519 UNICODE_STRING CurDirCopy;
520
521 CurDir = &NtCurrentPeb()->ProcessParameters->CurrentDirectory.DosPath;
522
523 CurLength = CurDir->Length;
524 if (CurDir->Length <= 6)
525 {
526 if (CurLength != DirName->Length) return FALSE;
527 }
528 else
529 {
530 if ((CurLength - 2) != DirName->Length) return FALSE;
531 }
532
533 RtlAcquirePebLock();
534
535 CurDirCopy = *CurDir;
536 if (CurDirCopy.Length > 6) CurDirCopy.Length -= 2;
537
538 Result = 0;
539
540 if (RtlEqualUnicodeString(&CurDirCopy, DirName, TRUE)) Result = TRUE;
541
542 RtlReleasePebLock();
543
544 return Result;
545 }
546
547 /*
548 * Why not use RtlIsNameLegalDOS8Dot3? In fact the actual algorithm body is
549 * identical (other than the Rtl can optionally check for spaces), however the
550 * Rtl will always convert to OEM, while kernel32 has two possible file modes
551 * (ANSI or OEM). Therefore we must duplicate the algorithm body to get
552 * the correct compatible results
553 */
554 BOOL
555 WINAPI
556 IsShortName_U(IN PWCHAR Name,
557 IN ULONG Length)
558 {
559 BOOLEAN HasExtension;
560 WCHAR c;
561 NTSTATUS Status;
562 UNICODE_STRING UnicodeName;
563 ANSI_STRING AnsiName;
564 ULONG i, Dots;
565 CHAR AnsiBuffer[MAX_PATH];
566 ASSERT(Name);
567
568 /* What do you think 8.3 means? */
569 if (Length > 12) return FALSE;
570
571 /* Sure, any emtpy name is a short name */
572 if (!Length) return TRUE;
573
574 /* This could be . or .. or something else */
575 if (*Name == L'.')
576 {
577 /* Which one is it */
578 if ((Length == 1) || ((Length == 2) && *(Name + 1) == L'.'))
579 {
580 /* . or .., this is good */
581 return TRUE;
582 }
583
584 /* Some other bizare dot-based name, not good */
585 return FALSE;
586 }
587
588 /* Initialize our two strings */
589 RtlInitEmptyAnsiString(&AnsiName, AnsiBuffer, MAX_PATH);
590 RtlInitEmptyUnicodeString(&UnicodeName, Name, Length * sizeof(WCHAR));
591 UnicodeName.Length = UnicodeName.MaximumLength;
592
593 /* Now do the conversion */
594 Status = BasepUnicodeStringTo8BitString(&AnsiName, &UnicodeName, FALSE);
595 if (!NT_SUCCESS(Status)) return FALSE;
596
597 /* Now we loop the name */
598 HasExtension = FALSE;
599 for (i = 0, Dots = Length - 1; i < AnsiName.Length; i++, Dots--)
600 {
601 /* Read the current byte */
602 c = AnsiName.Buffer[i];
603
604 /* Is it DBCS? */
605 if (IsDBCSLeadByte(c))
606 {
607 /* If we're near the end of the string, we can't allow a DBCS */
608 if ((!(HasExtension) && (i >= 7)) || (i == AnsiName.Length - 1))
609 {
610 return FALSE;
611 }
612
613 /* Otherwise we skip over it */
614 continue;
615 }
616
617 /* Check for illegal characters */
618 if ((c > 0x7F) || (IllegalMask[c / 32] & (1 << (c % 32))))
619 {
620 return FALSE;
621 }
622
623 /* Check if this is perhaps an extension? */
624 if (c == '.')
625 {
626 /* Unless the extension is too large or there's more than one */
627 if ((HasExtension) || (Dots > 3)) return FALSE;
628
629 /* This looks like an extension */
630 HasExtension = TRUE;
631 }
632
633 /* 8.3 length was validated, but now we must guard against 9.2 or similar */
634 if ((i >= 8) && !(HasExtension)) return FALSE;
635 }
636
637 /* You survived the loop, this is a good short name */
638 return TRUE;
639 }
640
641 BOOL
642 WINAPI
643 IsLongName_U(IN PWCHAR FileName,
644 IN ULONG Length)
645 {
646 BOOLEAN HasExtension;
647 ULONG i, Dots;
648
649 /* More than 8.3, any combination of dots, and NULL names are all long */
650 if (!(Length) || (Length > 12) || (*FileName == L'.')) return TRUE;
651
652 /* Otherwise, initialize our scanning loop */
653 HasExtension = FALSE;
654 for (i = 0, Dots = Length - 1; i < Length; i++, Dots--)
655 {
656 /* Check if this could be an extension */
657 if (FileName[i] == L'.')
658 {
659 /* Unlike the short case, we WANT more than one extension, or a long one */
660 if ((HasExtension) || (Dots > 3))
661 {
662 return TRUE;
663 }
664 HasExtension = TRUE;
665 }
666
667 /* Check if this would violate the "8" in 8.3, ie. 9.2 */
668 if ((i >= 8) && (!HasExtension)) return TRUE;
669 }
670
671 /* The name *seems* to conform to 8.3 */
672 return FALSE;
673 }
674
675 BOOL
676 WINAPI
677 FindLFNorSFN_U(IN PWCHAR Path,
678 OUT PWCHAR *First,
679 OUT PWCHAR *Last,
680 IN BOOL UseShort)
681 {
682 PWCHAR p;
683 ULONG Length;
684 BOOL Found = 0;
685 ASSERT(Path);
686
687 /* Loop while there is something in the path */
688 while (TRUE)
689 {
690 /* Loop within the path skipping slashes */
691 while ((*Path == L'\\') || (*Path == L'/')) Path++;
692
693 /* Make sure there's something after the slashes too! */
694 if (*Path == UNICODE_NULL) break;
695
696 /* Now skip past the file name until we get to the first slash */
697 p = Path + 1;
698 while ((*p) && ((*p != L'\\') && (*p != L'/'))) p++;
699
700 /* Whatever is in between those two is now the file name length */
701 Length = p - Path;
702
703 /*
704 * Check if it is valid
705 * Note that !IsShortName != IsLongName, these two functions simply help
706 * us determine if a conversion is necessary or not.
707 * "Found" really means: "Is a conversion necessary?", hence the "!"
708 */
709 Found = UseShort ? !IsShortName_U(Path, Length) : !IsLongName_U(Path, Length);
710 if (Found)
711 {
712 /* It is! did the caller request to know the markers? */
713 if ((First) && (Last))
714 {
715 /* Return them */
716 *First = Path;
717 *Last = p;
718 }
719 break;
720 }
721
722 /* Is there anything else following this sub-path/filename? */
723 if (*p == UNICODE_NULL) break;
724
725 /* Yes, keep going */
726 Path = p + 1;
727 }
728
729 /* Return if anything was found and valid */
730 return Found;
731 }
732
733 PWCHAR
734 WINAPI
735 SkipPathTypeIndicator_U(IN LPWSTR Path)
736 {
737 PWCHAR ReturnPath;
738 ULONG i;
739
740 /* Check what kind of path this is and how many slashes to skip */
741 switch (RtlDetermineDosPathNameType_U(Path))
742 {
743 case RtlPathTypeDriveAbsolute:
744 return Path + 3;
745
746 case RtlPathTypeDriveRelative:
747 return Path + 2;
748
749 case RtlPathTypeRooted:
750 return Path + 1;
751
752 case RtlPathTypeRelative:
753 return Path;
754
755 case RtlPathTypeRootLocalDevice:
756 default:
757 return NULL;
758
759 case RtlPathTypeUncAbsolute:
760 case RtlPathTypeLocalDevice:
761
762 /* Keep going until we bypass the path indicators */
763 for (ReturnPath = Path + 2, i = 2; (i > 0) && (*ReturnPath); ReturnPath++)
764 {
765 /* We look for 2 slashes, so keep at it until we find them */
766 if ((*ReturnPath == L'\\') || (*ReturnPath == L'/')) i--;
767 }
768
769 return ReturnPath;
770 }
771 }
772
773 BOOL
774 WINAPI
775 BasepIsCurDirAllowedForPlainExeNames(VOID)
776 {
777 NTSTATUS Status;
778 UNICODE_STRING EmptyString;
779
780 RtlInitEmptyUnicodeString(&EmptyString, NULL, 0);
781 Status = RtlQueryEnvironmentVariable_U(NULL,
782 &NoDefaultCurrentDirectoryInExePath,
783 &EmptyString);
784 return !NT_SUCCESS(Status) && Status != STATUS_BUFFER_TOO_SMALL;
785 }
786
787 /* PUBLIC FUNCTIONS ***********************************************************/
788
789 /*
790 * @implemented
791 */
792 BOOL
793 WINAPI
794 SetDllDirectoryW(IN LPCWSTR lpPathName)
795 {
796 UNICODE_STRING OldDirectory, DllDirectory;
797
798 if (lpPathName)
799 {
800 if (wcschr(lpPathName, L';'))
801 {
802 SetLastError(ERROR_INVALID_PARAMETER);
803 return FALSE;
804 }
805 if (!RtlCreateUnicodeString(&DllDirectory, lpPathName))
806 {
807 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
808 return FALSE;
809 }
810 }
811 else
812 {
813 RtlInitUnicodeString(&DllDirectory, NULL);
814 }
815
816 RtlEnterCriticalSection(&BaseDllDirectoryLock);
817
818 OldDirectory = BaseDllDirectory;
819 BaseDllDirectory = DllDirectory;
820
821 RtlLeaveCriticalSection(&BaseDllDirectoryLock);
822
823 RtlFreeUnicodeString(&OldDirectory);
824 return TRUE;
825 }
826
827 /*
828 * @implemented
829 */
830 BOOL
831 WINAPI
832 SetDllDirectoryA(IN LPCSTR lpPathName)
833 {
834 ANSI_STRING AnsiDllDirectory;
835 UNICODE_STRING OldDirectory, DllDirectory;
836 NTSTATUS Status;
837
838 if (lpPathName)
839 {
840 if (strchr(lpPathName, ';'))
841 {
842 SetLastError(ERROR_INVALID_PARAMETER);
843 return FALSE;
844 }
845
846 Status = RtlInitAnsiStringEx(&AnsiDllDirectory, lpPathName);
847 if (NT_SUCCESS(Status))
848 {
849 Status = Basep8BitStringToUnicodeString(&DllDirectory,
850 &AnsiDllDirectory,
851 TRUE);
852 }
853
854 if (!NT_SUCCESS(Status))
855 {
856 BaseSetLastNTError(Status);
857 return FALSE;
858 }
859 }
860 else
861 {
862 RtlInitUnicodeString(&DllDirectory, NULL);
863 }
864
865 RtlEnterCriticalSection(&BaseDllDirectoryLock);
866
867 OldDirectory = BaseDllDirectory;
868 BaseDllDirectory = DllDirectory;
869
870 RtlLeaveCriticalSection(&BaseDllDirectoryLock);
871
872 RtlFreeUnicodeString(&OldDirectory);
873 return TRUE;
874 }
875
876 /*
877 * @implemented
878 */
879 DWORD
880 WINAPI
881 GetDllDirectoryW(IN DWORD nBufferLength,
882 OUT LPWSTR lpBuffer)
883 {
884 ULONG Length;
885
886 RtlEnterCriticalSection(&BaseDllDirectoryLock);
887
888 if ((nBufferLength * sizeof(WCHAR)) > BaseDllDirectory.Length)
889 {
890 RtlCopyMemory(lpBuffer, BaseDllDirectory.Buffer, BaseDllDirectory.Length);
891 Length = BaseDllDirectory.Length / sizeof(WCHAR);
892 lpBuffer[Length] = UNICODE_NULL;
893 }
894 else
895 {
896 Length = (BaseDllDirectory.Length + sizeof(UNICODE_NULL)) / sizeof(WCHAR);
897 if (lpBuffer) *lpBuffer = UNICODE_NULL;
898 }
899
900 RtlLeaveCriticalSection(&BaseDllDirectoryLock);
901 return Length;
902 }
903
904 /*
905 * @implemented
906 */
907 DWORD
908 WINAPI
909 GetDllDirectoryA(IN DWORD nBufferLength,
910 OUT LPSTR lpBuffer)
911 {
912 NTSTATUS Status;
913 ANSI_STRING AnsiDllDirectory;
914 ULONG Length;
915
916 RtlInitEmptyAnsiString(&AnsiDllDirectory, lpBuffer, nBufferLength);
917
918 RtlEnterCriticalSection(&BaseDllDirectoryLock);
919
920 Length = BasepUnicodeStringTo8BitSize(&BaseDllDirectory);
921 if (Length > nBufferLength)
922 {
923 Status = STATUS_SUCCESS;
924 if (lpBuffer) *lpBuffer = ANSI_NULL;
925 }
926 else
927 {
928 --Length;
929 Status = BasepUnicodeStringTo8BitString(&AnsiDllDirectory,
930 &BaseDllDirectory,
931 FALSE);
932 }
933
934 RtlLeaveCriticalSection(&BaseDllDirectoryLock);
935
936 if (!NT_SUCCESS(Status))
937 {
938 BaseSetLastNTError(Status);
939 Length = 0;
940 if (lpBuffer) *lpBuffer = ANSI_NULL;
941 }
942
943 return Length;
944 }
945
946 /*
947 * @implemented
948 */
949 BOOL
950 WINAPI
951 NeedCurrentDirectoryForExePathW(IN LPCWSTR ExeName)
952 {
953 if (wcschr(ExeName, L'\\')) return TRUE;
954
955 return BasepIsCurDirAllowedForPlainExeNames();
956 }
957
958 /*
959 * @implemented
960 */
961 BOOL
962 WINAPI
963 NeedCurrentDirectoryForExePathA(IN LPCSTR ExeName)
964 {
965 if (strchr(ExeName, '\\')) return TRUE;
966
967 return BasepIsCurDirAllowedForPlainExeNames();
968 }
969
970 /*
971 * @implemented
972 *
973 * NOTE: Many of these A functions may seem to do rather complex A<->W mapping
974 * beyond what you would usually expect. There are two main reasons:
975 *
976 * First, these APIs are subject to the ANSI/OEM File API selection status that
977 * the caller has chosen, so we must use the "8BitString" internal Base APIs.
978 *
979 * Secondly, the Wide APIs (coming from the 9x world) are coded to return the
980 * length of the paths in "ANSI" by dividing their internal Wide character count
981 * by two... this is usually correct when dealing with pure-ASCII codepages but
982 * not necessarily when dealing with MBCS pre-Unicode sets, which NT supports
983 * for CJK, for example.
984 */
985 DWORD
986 WINAPI
987 GetFullPathNameA(IN LPCSTR lpFileName,
988 IN DWORD nBufferLength,
989 IN LPSTR lpBuffer,
990 IN LPSTR *lpFilePart)
991 {
992 NTSTATUS Status;
993 PWCHAR Buffer;
994 ULONG PathSize, FilePartSize;
995 ANSI_STRING AnsiString;
996 UNICODE_STRING FileNameString, UniString;
997 PWCHAR LocalFilePart;
998 PWCHAR* FilePart;
999
1000 /* If the caller wants filepart, use a local wide buffer since this is A */
1001 FilePart = lpFilePart != NULL ? &LocalFilePart : NULL;
1002
1003 /* Initialize for Quickie */
1004 FilePartSize = PathSize = 0;
1005 FileNameString.Buffer = NULL;
1006
1007 /* First get our string in Unicode */
1008 Status = Basep8BitStringToDynamicUnicodeString(&FileNameString, lpFileName);
1009 if (!NT_SUCCESS(Status)) goto Quickie;
1010
1011 /* Allocate a buffer to hold teh path name */
1012 Buffer = RtlAllocateHeap(RtlGetProcessHeap(),
1013 0,
1014 MAX_PATH * sizeof(WCHAR) + sizeof(UNICODE_NULL));
1015 if (!Buffer)
1016 {
1017 BaseSetLastNTError(STATUS_INSUFFICIENT_RESOURCES);
1018 goto Quickie;
1019 }
1020
1021 /* Call into RTL to get the full Unicode path name */
1022 PathSize = RtlGetFullPathName_U(FileNameString.Buffer,
1023 MAX_PATH * sizeof(WCHAR),
1024 Buffer,
1025 FilePart);
1026 if (PathSize <= (MAX_PATH * sizeof(WCHAR)))
1027 {
1028 /* The buffer will fit, get the real ANSI string size now */
1029 Status = RtlUnicodeToMultiByteSize(&PathSize, Buffer, PathSize);
1030 if (NT_SUCCESS(Status))
1031 {
1032 /* Now check if the user wanted file part size as well */
1033 if ((PathSize) && (lpFilePart) && (LocalFilePart))
1034 {
1035 /* Yep, so in this case get the length of the file part too */
1036 Status = RtlUnicodeToMultiByteSize(&FilePartSize,
1037 Buffer,
1038 (LocalFilePart - Buffer) *
1039 sizeof(WCHAR));
1040 if (!NT_SUCCESS(Status))
1041 {
1042 /* We failed to do that, so fail the whole call */
1043 BaseSetLastNTError(Status);
1044 PathSize = 0;
1045 }
1046 }
1047 }
1048 }
1049 else
1050 {
1051 /* Reset the path size since the buffer is not large enough */
1052 PathSize = 0;
1053 }
1054
1055 /* Either no path, or local buffer was too small, enter failure code */
1056 if (!PathSize) goto Quickie;
1057
1058 /* If the *caller's* buffer was too small, fail, but add in space for NULL */
1059 if (PathSize >= nBufferLength)
1060 {
1061 PathSize++;
1062 goto Quickie;
1063 }
1064
1065 /* So far so good, initialize a unicode string to convert back to ANSI/OEM */
1066 RtlInitUnicodeString(&UniString, Buffer);
1067 Status = BasepUnicodeStringTo8BitString(&AnsiString, &UniString, TRUE);
1068 if (!NT_SUCCESS(Status))
1069 {
1070 /* Final conversion failed, fail the call */
1071 BaseSetLastNTError(Status);
1072 PathSize = 0;
1073 }
1074 else
1075 {
1076 /* Conversion worked, now copy the ANSI/OEM buffer into the buffer */
1077 RtlCopyMemory(lpBuffer, AnsiString.Buffer, PathSize + 1);
1078 RtlFreeAnsiString(&AnsiString);
1079
1080 /* And finally, did the caller request file part information? */
1081 if (lpFilePart)
1082 {
1083 /* Use the size we computed earlier and add it to the buffer */
1084 *lpFilePart = LocalFilePart ? &lpBuffer[FilePartSize] : 0;
1085 }
1086 }
1087
1088 Quickie:
1089 /* Cleanup and return the path size */
1090 if (FileNameString.Buffer) RtlFreeUnicodeString(&FileNameString);
1091 if (Buffer) RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
1092 return PathSize;
1093 }
1094
1095 /*
1096 * @implemented
1097 */
1098 DWORD
1099 WINAPI
1100 GetFullPathNameW(IN LPCWSTR lpFileName,
1101 IN DWORD nBufferLength,
1102 IN LPWSTR lpBuffer,
1103 OUT LPWSTR *lpFilePart)
1104 {
1105 /* Call Rtl to do the work */
1106 return RtlGetFullPathName_U((LPWSTR)lpFileName,
1107 nBufferLength * sizeof(WCHAR),
1108 lpBuffer,
1109 lpFilePart) / sizeof(WCHAR);
1110 }
1111
1112 /*
1113 * @implemented
1114 */
1115 DWORD
1116 WINAPI
1117 SearchPathA(IN LPCSTR lpPath,
1118 IN LPCSTR lpFileName,
1119 IN LPCSTR lpExtension,
1120 IN DWORD nBufferLength,
1121 IN LPSTR lpBuffer,
1122 OUT LPSTR *lpFilePart)
1123 {
1124 PUNICODE_STRING FileNameString;
1125 UNICODE_STRING PathString, ExtensionString;
1126 NTSTATUS Status;
1127 ULONG PathSize, FilePartSize, AnsiLength;
1128 PWCHAR LocalFilePart, Buffer;
1129 PWCHAR* FilePart;
1130
1131 /* If the caller wants filepart, use a local wide buffer since this is A */
1132 FilePart = lpFilePart != NULL ? &LocalFilePart : NULL;
1133
1134 /* Initialize stuff for Quickie */
1135 PathSize = 0;
1136 Buffer = NULL;
1137 ExtensionString.Buffer = PathString.Buffer = NULL;
1138
1139 /* Get the UNICODE_STRING file name */
1140 FileNameString = Basep8BitStringToStaticUnicodeString(lpFileName);
1141 if (!FileNameString) return 0;
1142
1143 /* Did the caller specify an extension */
1144 if (lpExtension)
1145 {
1146 /* Yup, convert it into UNICODE_STRING */
1147 Status = Basep8BitStringToDynamicUnicodeString(&ExtensionString,
1148 lpExtension);
1149 if (!NT_SUCCESS(Status)) goto Quickie;
1150 }
1151
1152 /* Did the caller specify a path */
1153 if (lpPath)
1154 {
1155 /* Yup, convert it into UNICODE_STRING */
1156 Status = Basep8BitStringToDynamicUnicodeString(&PathString, lpPath);
1157 if (!NT_SUCCESS(Status)) goto Quickie;
1158 }
1159
1160 /* Allocate our output buffer */
1161 Buffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, nBufferLength * sizeof(WCHAR));
1162 if (!Buffer)
1163 {
1164 /* It failed, bail out */
1165 BaseSetLastNTError(STATUS_NO_MEMORY);
1166 goto Quickie;
1167 }
1168
1169 /* Now run the Wide search with the input buffer lengths */
1170 PathSize = SearchPathW(PathString.Buffer,
1171 FileNameString->Buffer,
1172 ExtensionString.Buffer,
1173 nBufferLength,
1174 Buffer,
1175 FilePart);
1176 if (PathSize <= nBufferLength)
1177 {
1178 /* It fits, but is it empty? If so, bail out */
1179 if (!PathSize) goto Quickie;
1180
1181 /* The length above is inexact, we need it in ANSI */
1182 Status = RtlUnicodeToMultiByteSize(&AnsiLength, Buffer, PathSize * sizeof(WCHAR));
1183 if (!NT_SUCCESS(Status))
1184 {
1185 /* Conversion failed, fail the call */
1186 PathSize = 0;
1187 BaseSetLastNTError(Status);
1188 goto Quickie;
1189 }
1190
1191 /* If the correct ANSI size is too big, return requird length plus a NULL */
1192 if (AnsiLength >= nBufferLength)
1193 {
1194 PathSize = AnsiLength + 1;
1195 goto Quickie;
1196 }
1197
1198 /* Now apply the final conversion to ANSI */
1199 Status = RtlUnicodeToMultiByteN(lpBuffer,
1200 nBufferLength - 1,
1201 &AnsiLength,
1202 Buffer,
1203 PathSize * sizeof(WCHAR));
1204 if (!NT_SUCCESS(Status))
1205 {
1206 /* Conversion failed, fail the whole call */
1207 PathSize = 0;
1208 BaseSetLastNTError(STATUS_NO_MEMORY);
1209 goto Quickie;
1210 }
1211
1212 /* NULL-terminate and return the real ANSI length */
1213 lpBuffer[AnsiLength] = ANSI_NULL;
1214 PathSize = AnsiLength;
1215
1216 /* Now check if the user wanted file part size as well */
1217 if (lpFilePart)
1218 {
1219 /* If we didn't get a file part, clear the caller's */
1220 if (!LocalFilePart)
1221 {
1222 *lpFilePart = NULL;
1223 }
1224 else
1225 {
1226 /* Yep, so in this case get the length of the file part too */
1227 Status = RtlUnicodeToMultiByteSize(&FilePartSize,
1228 Buffer,
1229 (LocalFilePart - Buffer) *
1230 sizeof(WCHAR));
1231 if (!NT_SUCCESS(Status))
1232 {
1233 /* We failed to do that, so fail the whole call */
1234 BaseSetLastNTError(Status);
1235 PathSize = 0;
1236 }
1237
1238 /* Return the file part buffer */
1239 *lpFilePart = lpBuffer + FilePartSize;
1240 }
1241 }
1242 }
1243 else
1244 {
1245 /* Our initial buffer guess was too small, allocate a bigger one */
1246 RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
1247 Buffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, PathSize * sizeof(WCHAR));
1248 if (!Buffer)
1249 {
1250 /* Out of memory, fail everything */
1251 BaseSetLastNTError(STATUS_NO_MEMORY);
1252 goto Quickie;
1253 }
1254
1255 /* Do the search again -- it will fail, we just want the path size */
1256 PathSize = SearchPathW(PathString.Buffer,
1257 FileNameString->Buffer,
1258 ExtensionString.Buffer,
1259 PathSize,
1260 Buffer,
1261 FilePart);
1262 if (!PathSize) goto Quickie;
1263
1264 /* Convert it to a correct size */
1265 Status = RtlUnicodeToMultiByteSize(&PathSize, Buffer, PathSize * sizeof(WCHAR));
1266 if (NT_SUCCESS(Status))
1267 {
1268 /* Make space for the NULL-char */
1269 PathSize++;
1270 }
1271 else
1272 {
1273 /* Conversion failed for some reason, fail the call */
1274 BaseSetLastNTError(Status);
1275 PathSize = 0;
1276 }
1277 }
1278
1279 Quickie:
1280 /* Cleanup/complete path */
1281 if (Buffer) RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
1282 if (ExtensionString.Buffer) RtlFreeUnicodeString(&ExtensionString);
1283 if (PathString.Buffer) RtlFreeUnicodeString(&PathString);
1284 return PathSize;
1285 }
1286
1287 /*
1288 * @implemented
1289 */
1290 DWORD
1291 WINAPI
1292 SearchPathW(IN LPCWSTR lpPath,
1293 IN LPCWSTR lpFileName,
1294 IN LPCWSTR lpExtension,
1295 IN DWORD nBufferLength,
1296 IN LPWSTR lpBuffer,
1297 OUT LPWSTR *lpFilePart)
1298 {
1299 UNICODE_STRING FileNameString, ExtensionString, PathString, CallerBuffer;
1300 ULONG Flags, LengthNeeded, FilePartSize;
1301 NTSTATUS Status;
1302 DWORD Result = 0;
1303
1304 /* Default flags for RtlDosSearchPath_Ustr */
1305 Flags = 6;
1306
1307 /* Clear file part in case we fail */
1308 if (lpFilePart) *lpFilePart = NULL;
1309
1310 /* Initialize path buffer for free later */
1311 PathString.Buffer = NULL;
1312
1313 /* Convert filename to a unicode string and eliminate trailing spaces */
1314 RtlInitUnicodeString(&FileNameString, lpFileName);
1315 while ((FileNameString.Length >= sizeof(WCHAR)) &&
1316 (FileNameString.Buffer[(FileNameString.Length / sizeof(WCHAR)) - 1] == L' '))
1317 {
1318 FileNameString.Length -= sizeof(WCHAR);
1319 }
1320
1321 /* Was it all just spaces? */
1322 if (!FileNameString.Length)
1323 {
1324 /* Fail out */
1325 BaseSetLastNTError(STATUS_INVALID_PARAMETER);
1326 goto Quickie;
1327 }
1328
1329 /* Convert extension to a unicode string */
1330 RtlInitUnicodeString(&ExtensionString, lpExtension);
1331
1332 /* Check if the user sent a path */
1333 if (lpPath)
1334 {
1335 /* Convert it to a unicode string too */
1336 Status = RtlInitUnicodeStringEx(&PathString, lpPath);
1337 if (NT_ERROR(Status))
1338 {
1339 /* Fail if it was too long */
1340 BaseSetLastNTError(Status);
1341 goto Quickie;
1342 }
1343 }
1344 else
1345 {
1346 /* A path wasn't sent, so compute it ourselves */
1347 PathString.Buffer = BaseComputeProcessSearchPath();
1348 if (!PathString.Buffer)
1349 {
1350 /* Fail if we couldn't compute it */
1351 BaseSetLastNTError(STATUS_NO_MEMORY);
1352 goto Quickie;
1353 }
1354
1355 /* See how big the computed path is */
1356 LengthNeeded = lstrlenW(PathString.Buffer);
1357 if (LengthNeeded > UNICODE_STRING_MAX_CHARS)
1358 {
1359 /* Fail if it's too long */
1360 BaseSetLastNTError(STATUS_NAME_TOO_LONG);
1361 goto Quickie;
1362 }
1363
1364 /* Set the path size now that we have it */
1365 PathString.MaximumLength = PathString.Length = LengthNeeded * sizeof(WCHAR);
1366
1367 /* Request SxS isolation from RtlDosSearchPath_Ustr */
1368 Flags |= 1;
1369 }
1370
1371 /* Create the string that describes the output buffer from the caller */
1372 CallerBuffer.Length = 0;
1373 CallerBuffer.Buffer = lpBuffer;
1374
1375 /* How much space does the caller have? */
1376 if (nBufferLength <= UNICODE_STRING_MAX_CHARS)
1377 {
1378 /* Add it into the string */
1379 CallerBuffer.MaximumLength = nBufferLength * sizeof(WCHAR);
1380 }
1381 else
1382 {
1383 /* Caller wants too much, limit it to the maximum length of a string */
1384 CallerBuffer.MaximumLength = UNICODE_STRING_MAX_BYTES;
1385 }
1386
1387 /* Call Rtl to do the work */
1388 Status = RtlDosSearchPath_Ustr(Flags,
1389 &PathString,
1390 &FileNameString,
1391 &ExtensionString,
1392 &CallerBuffer,
1393 NULL,
1394 NULL,
1395 &FilePartSize,
1396 &LengthNeeded);
1397 if (NT_ERROR(Status))
1398 {
1399 /* Check for unusual status codes */
1400 if ((Status != STATUS_NO_SUCH_FILE) && (Status != STATUS_BUFFER_TOO_SMALL))
1401 {
1402 /* Print them out since maybe an app needs fixing */
1403 DbgPrint("%s on file %wZ failed; NTSTATUS = %08lx\n",
1404 __FUNCTION__,
1405 &FileNameString,
1406 Status);
1407 DbgPrint(" Path = %wZ\n", &PathString);
1408 }
1409
1410 /* Check if the failure was due to a small buffer */
1411 if (Status == STATUS_BUFFER_TOO_SMALL)
1412 {
1413 /* Check if the length was actually too big for Rtl to work with */
1414 Result = LengthNeeded / sizeof(WCHAR);
1415 if (Result > 0xFFFFFFFF) BaseSetLastNTError(STATUS_NAME_TOO_LONG);
1416 }
1417 else
1418 {
1419 /* Some other error, set the error code */
1420 BaseSetLastNTError(Status);
1421 }
1422 }
1423 else
1424 {
1425 /* It worked! Write the file part now */
1426 if (lpFilePart) *lpFilePart = &lpBuffer[FilePartSize];
1427
1428 /* Convert the final result length */
1429 Result = CallerBuffer.Length / sizeof(WCHAR);
1430 }
1431
1432 Quickie:
1433 /* Check if there was a dynamic path stirng to free */
1434 if ((PathString.Buffer != lpPath) && (PathString.Buffer))
1435 {
1436 /* And free it */
1437 RtlFreeHeap(RtlGetProcessHeap(), 0, PathString.Buffer);
1438 }
1439
1440 /* Return the final result lenght */
1441 return Result;
1442 }
1443
1444 /*
1445 * @implemented
1446 */
1447 DWORD
1448 WINAPI
1449 GetLongPathNameW(IN LPCWSTR lpszShortPath,
1450 IN LPWSTR lpszLongPath,
1451 IN DWORD cchBuffer)
1452 {
1453 PWCHAR Path, Original, First, Last, Buffer, Src, Dst;
1454 ULONG Length;
1455 WCHAR LastChar;
1456 HANDLE FindHandle;
1457 DWORD ReturnLength;
1458 ULONG ErrorMode;
1459 BOOLEAN Found = FALSE;
1460 WIN32_FIND_DATAW FindFileData;
1461
1462 /* Initialize so Quickie knows there's nothing to do */
1463 Buffer = Original = NULL;
1464 ReturnLength = 0;
1465
1466 /* First check if the input path was obviously NULL */
1467 if (!lpszShortPath)
1468 {
1469 /* Fail the request */
1470 SetLastError(ERROR_INVALID_PARAMETER);
1471 return 0;
1472 }
1473
1474 /* We will be touching removed, removable drives -- don't warn the user */
1475 ErrorMode = SetErrorMode(SEM_NOOPENFILEERRORBOX | SEM_FAILCRITICALERRORS);
1476
1477 /* Do a simple check to see if the path exists */
1478 if (GetFileAttributesW(lpszShortPath) == INVALID_FILE_ATTRIBUTES)
1479 {
1480 /* It doesn't, so fail */
1481 ReturnLength = 0;
1482 goto Quickie;
1483 }
1484
1485 /* Now get a pointer to the actual path, skipping indicators */
1486 Path = SkipPathTypeIndicator_U((LPWSTR)lpszShortPath);
1487
1488 /* Is there any path or filename in there? */
1489 if (!(Path) ||
1490 (*Path == UNICODE_NULL) ||
1491 !(FindLFNorSFN_U(Path, &First, &Last, FALSE)))
1492 {
1493 /* There isn't, so the long path is simply the short path */
1494 ReturnLength = wcslen(lpszShortPath);
1495
1496 /* Is there space for it? */
1497 if ((cchBuffer > ReturnLength) && (lpszLongPath))
1498 {
1499 /* Make sure the pointers aren't already the same */
1500 if (lpszLongPath != lpszShortPath)
1501 {
1502 /* They're not -- copy the short path into the long path */
1503 RtlMoveMemory(lpszLongPath,
1504 lpszShortPath,
1505 ReturnLength * sizeof(WCHAR) + sizeof(UNICODE_NULL));
1506 }
1507 }
1508 else
1509 {
1510 /* Otherwise, let caller know we need a bigger buffer, include NULL */
1511 ReturnLength++;
1512 }
1513 goto Quickie;
1514 }
1515
1516 /* We are still in the game -- compute the current size */
1517 Length = wcslen(lpszShortPath) + sizeof(ANSI_NULL);
1518 Original = RtlAllocateHeap(RtlGetProcessHeap(), 0, Length * sizeof(WCHAR));
1519 if (!Original) goto ErrorQuickie;
1520
1521 /* Make a copy of it */
1522 RtlMoveMemory(Original, lpszShortPath, Length * sizeof(WCHAR));
1523
1524 /* Compute the new first and last markers */
1525 First = &Original[First - lpszShortPath];
1526 Last = &Original[Last - lpszShortPath];
1527
1528 /* Set the current destination pointer for a copy */
1529 Dst = lpszLongPath;
1530
1531 /*
1532 * Windows allows the paths to overlap -- we have to be careful with this and
1533 * see if it's same to do so, and if not, allocate our own internal buffer
1534 * that we'll return at the end.
1535 *
1536 * This is also why we use RtlMoveMemory everywhere. Don't use RtlCopyMemory!
1537 */
1538 if ((cchBuffer) && (lpszLongPath) &&
1539 (((lpszLongPath >= lpszShortPath) && (lpszLongPath < &lpszShortPath[Length])) ||
1540 ((lpszLongPath < lpszShortPath) && (&lpszLongPath[cchBuffer] >= lpszShortPath))))
1541 {
1542 Buffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, cchBuffer * sizeof(WCHAR));
1543 if (!Buffer) goto ErrorQuickie;
1544
1545 /* New destination */
1546 Dst = Buffer;
1547 }
1548
1549 /* Prepare for the loop */
1550 Src = Original;
1551 ReturnLength = 0;
1552 while (TRUE)
1553 {
1554 /* Current delta in the loop */
1555 Length = First - Src;
1556
1557 /* Update the return length by it */
1558 ReturnLength += Length;
1559
1560 /* Is there a delta? If so, is there space and buffer for it? */
1561 if ((Length) && (cchBuffer > ReturnLength) && (lpszLongPath))
1562 {
1563 RtlMoveMemory(Dst, Src, Length * sizeof(WCHAR));
1564 Dst += Length;
1565 }
1566
1567 /* "Terminate" this portion of the path's substring so we can do a find */
1568 LastChar = *Last;
1569 *Last = UNICODE_NULL;
1570 FindHandle = FindFirstFileW(Original, &FindFileData);
1571 *Last = LastChar;
1572
1573 /* This portion wasn't found, so fail */
1574 if (FindHandle == INVALID_HANDLE_VALUE)
1575 {
1576 ReturnLength = 0;
1577 break;
1578 }
1579
1580 /* Close the find handle */
1581 FindClose(FindHandle);
1582
1583 /* Now check the length of the long name */
1584 Length = wcslen(FindFileData.cFileName);
1585 if (Length)
1586 {
1587 /* This is our new first marker */
1588 First = FindFileData.cFileName;
1589 }
1590 else
1591 {
1592 /* Otherwise, the name is the delta between our current markers */
1593 Length = Last - First;
1594 }
1595
1596 /* Update the return length with the short name length, if any */
1597 ReturnLength += Length;
1598
1599 /* Once again check for appropriate space and buffer */
1600 if ((cchBuffer > ReturnLength) && (lpszLongPath))
1601 {
1602 /* And do the copy if there is */
1603 RtlMoveMemory(Dst, First, Length * sizeof(WCHAR));
1604 Dst += Length;
1605 }
1606
1607 /* Now update the source pointer */
1608 Src = Last;
1609 if (*Src == UNICODE_NULL) break;
1610
1611 /* Are there more names in there? */
1612 Found = FindLFNorSFN_U(Src, &First, &Last, FALSE);
1613 if (!Found) break;
1614 }
1615
1616 /* The loop is done, is there anything left? */
1617 if (ReturnLength)
1618 {
1619 /* Get the length of the straggling path */
1620 Length = wcslen(Src);
1621 ReturnLength += Length;
1622
1623 /* Once again check for appropriate space and buffer */
1624 if ((cchBuffer > ReturnLength) && (lpszLongPath))
1625 {
1626 /* And do the copy if there is -- accounting for NULL here */
1627 RtlMoveMemory(Dst, Src, Length * sizeof(WCHAR) + sizeof(UNICODE_NULL));
1628
1629 /* What about our buffer? */
1630 if (Buffer)
1631 {
1632 /* Copy it into the caller's long path */
1633 RtlMoveMemory(lpszLongPath,
1634 Buffer,
1635 ReturnLength * sizeof(WCHAR) + sizeof(UNICODE_NULL));
1636 }
1637 }
1638 else
1639 {
1640 /* Buffer is too small, let the caller know, making space for NULL */
1641 ReturnLength++;
1642 }
1643 }
1644
1645 /* We're all done */
1646 goto Quickie;
1647
1648 ErrorQuickie:
1649 /* This is the goto for memory failures */
1650 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1651
1652 Quickie:
1653 /* General function end: free memory, restore error mode, return length */
1654 if (Original) RtlFreeHeap(RtlGetProcessHeap(), 0, Original);
1655 if (Buffer) RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
1656 SetErrorMode(ErrorMode);
1657 return ReturnLength;
1658 }
1659
1660 /*
1661 * @implemented
1662 */
1663 DWORD
1664 WINAPI
1665 GetLongPathNameA(IN LPCSTR lpszShortPath,
1666 IN LPSTR lpszLongPath,
1667 IN DWORD cchBuffer)
1668 {
1669 ULONG Result, PathLength;
1670 PWCHAR LongPath;
1671 NTSTATUS Status;
1672 UNICODE_STRING LongPathUni, ShortPathUni;
1673 ANSI_STRING LongPathAnsi;
1674 WCHAR LongPathBuffer[MAX_PATH];
1675
1676 LongPath = NULL;
1677 LongPathAnsi.Buffer = NULL;
1678 ShortPathUni.Buffer = NULL;
1679 Result = 0;
1680
1681 if (!lpszShortPath)
1682 {
1683 SetLastError(ERROR_INVALID_PARAMETER);
1684 return 0;
1685 }
1686
1687 Status = Basep8BitStringToDynamicUnicodeString(&ShortPathUni, lpszShortPath);
1688 if (!NT_SUCCESS(Status)) goto Quickie;
1689
1690 LongPath = LongPathBuffer;
1691
1692 PathLength = GetLongPathNameW(ShortPathUni.Buffer, LongPathBuffer, MAX_PATH);
1693 if (PathLength >= MAX_PATH)
1694 {
1695 LongPath = RtlAllocateHeap(RtlGetProcessHeap(), 0, PathLength * sizeof(WCHAR));
1696 if (!LongPath)
1697 {
1698 PathLength = 0;
1699 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1700 }
1701 else
1702 {
1703 PathLength = GetLongPathNameW(ShortPathUni.Buffer, LongPath, PathLength);
1704 }
1705 }
1706
1707 if (!PathLength) goto Quickie;
1708
1709 ShortPathUni.MaximumLength = PathLength * sizeof(WCHAR) + sizeof(UNICODE_NULL);
1710 LongPathUni.Buffer = LongPath;
1711 LongPathUni.Length = PathLength * sizeof(WCHAR);
1712
1713 Status = BasepUnicodeStringTo8BitString(&LongPathAnsi, &LongPathUni, TRUE);
1714 if (!NT_SUCCESS(Status))
1715 {
1716 BaseSetLastNTError(Status);
1717 Result = 0;
1718 }
1719
1720 Result = LongPathAnsi.Length;
1721 if ((lpszLongPath) && (cchBuffer > LongPathAnsi.Length))
1722 {
1723 RtlMoveMemory(lpszLongPath, LongPathAnsi.Buffer, LongPathAnsi.Length);
1724 lpszLongPath[Result] = ANSI_NULL;
1725 }
1726 else
1727 {
1728 Result = LongPathAnsi.Length + sizeof(ANSI_NULL);
1729 }
1730
1731 Quickie:
1732 if (ShortPathUni.Buffer) RtlFreeUnicodeString(&ShortPathUni);
1733 if (LongPathAnsi.Buffer) RtlFreeAnsiString(&LongPathAnsi);
1734 if ((LongPath) && (LongPath != LongPathBuffer))
1735 {
1736 RtlFreeHeap(RtlGetProcessHeap(), 0, LongPath);
1737 }
1738 return Result;
1739 }
1740
1741 /*
1742 * @implemented
1743 */
1744 DWORD
1745 WINAPI
1746 GetShortPathNameA(IN LPCSTR lpszLongPath,
1747 IN LPSTR lpszShortPath,
1748 IN DWORD cchBuffer)
1749 {
1750 ULONG Result, PathLength;
1751 PWCHAR ShortPath;
1752 NTSTATUS Status;
1753 UNICODE_STRING LongPathUni, ShortPathUni;
1754 ANSI_STRING ShortPathAnsi;
1755 WCHAR ShortPathBuffer[MAX_PATH];
1756
1757 ShortPath = NULL;
1758 ShortPathAnsi.Buffer = NULL;
1759 LongPathUni.Buffer = NULL;
1760 Result = 0;
1761
1762 if (!lpszLongPath)
1763 {
1764 SetLastError(ERROR_INVALID_PARAMETER);
1765 return 0;
1766 }
1767
1768 Status = Basep8BitStringToDynamicUnicodeString(&LongPathUni, lpszLongPath);
1769 if (!NT_SUCCESS(Status)) goto Quickie;
1770
1771 ShortPath = ShortPathBuffer;
1772
1773 PathLength = GetShortPathNameW(LongPathUni.Buffer, ShortPathBuffer, MAX_PATH);
1774 if (PathLength >= MAX_PATH)
1775 {
1776 ShortPath = RtlAllocateHeap(RtlGetProcessHeap(), 0, PathLength * sizeof(WCHAR));
1777 if (!ShortPath)
1778 {
1779 PathLength = 0;
1780 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1781 }
1782 else
1783 {
1784 PathLength = GetShortPathNameW(LongPathUni.Buffer, ShortPath, PathLength);
1785 }
1786 }
1787
1788 if (!PathLength) goto Quickie;
1789
1790 LongPathUni.MaximumLength = PathLength * sizeof(WCHAR) + sizeof(UNICODE_NULL);
1791 ShortPathUni.Buffer = ShortPath;
1792 ShortPathUni.Length = PathLength * sizeof(WCHAR);
1793
1794 Status = BasepUnicodeStringTo8BitString(&ShortPathAnsi, &ShortPathUni, TRUE);
1795 if (!NT_SUCCESS(Status))
1796 {
1797 BaseSetLastNTError(Status);
1798 Result = 0;
1799 }
1800
1801 Result = ShortPathAnsi.Length;
1802 if ((lpszShortPath) && (cchBuffer > ShortPathAnsi.Length))
1803 {
1804 RtlMoveMemory(lpszShortPath, ShortPathAnsi.Buffer, ShortPathAnsi.Length);
1805 lpszShortPath[Result] = ANSI_NULL;
1806 }
1807 else
1808 {
1809 Result = ShortPathAnsi.Length + sizeof(ANSI_NULL);
1810 }
1811
1812 Quickie:
1813 if (LongPathUni.Buffer) RtlFreeUnicodeString(&LongPathUni);
1814 if (ShortPathAnsi.Buffer) RtlFreeAnsiString(&ShortPathAnsi);
1815 if ((ShortPath) && (ShortPath != ShortPathBuffer))
1816 {
1817 RtlFreeHeap(RtlGetProcessHeap(), 0, ShortPath);
1818 }
1819 return Result;
1820 }
1821
1822 /*
1823 * @implemented
1824 */
1825 DWORD
1826 WINAPI
1827 GetShortPathNameW(IN LPCWSTR lpszLongPath,
1828 IN LPWSTR lpszShortPath,
1829 IN DWORD cchBuffer)
1830 {
1831 PWCHAR Path, Original, First, Last, Buffer, Src, Dst;
1832 ULONG Length;
1833 WCHAR LastChar;
1834 HANDLE FindHandle;
1835 DWORD ReturnLength;
1836 ULONG ErrorMode;
1837 BOOLEAN Found = FALSE;
1838 WIN32_FIND_DATAW FindFileData;
1839
1840 /* Initialize so Quickie knows there's nothing to do */
1841 Buffer = Original = NULL;
1842 ReturnLength = 0;
1843
1844 /* First check if the input path was obviously NULL */
1845 if (!lpszLongPath)
1846 {
1847 /* Fail the request */
1848 SetLastError(ERROR_INVALID_PARAMETER);
1849 return 0;
1850 }
1851
1852 /* We will be touching removed, removable drives -- don't warn the user */
1853 ErrorMode = SetErrorMode(SEM_NOOPENFILEERRORBOX | SEM_FAILCRITICALERRORS);
1854
1855 /* Do a simple check to see if the path exists */
1856 if (GetFileAttributesW(lpszLongPath) == INVALID_FILE_ATTRIBUTES)
1857 {
1858 /* Windows checks for an application compatibility flag to allow this */
1859 if (!(NtCurrentPeb()) || !(NtCurrentPeb()->AppCompatFlags.LowPart & 1))
1860 {
1861 /* It doesn't, so fail */
1862 ReturnLength = 0;
1863 goto Quickie;
1864 }
1865 }
1866
1867 /* Now get a pointer to the actual path, skipping indicators */
1868 Path = SkipPathTypeIndicator_U((LPWSTR)lpszLongPath);
1869
1870 /* Is there any path or filename in there? */
1871 if (!(Path) ||
1872 (*Path == UNICODE_NULL) ||
1873 !(FindLFNorSFN_U(Path, &First, &Last, TRUE)))
1874 {
1875 /* There isn't, so the long path is simply the short path */
1876 ReturnLength = wcslen(lpszLongPath);
1877
1878 /* Is there space for it? */
1879 if ((cchBuffer > ReturnLength) && (lpszShortPath))
1880 {
1881 /* Make sure the pointers aren't already the same */
1882 if (lpszLongPath != lpszShortPath)
1883 {
1884 /* They're not -- copy the short path into the long path */
1885 RtlMoveMemory(lpszShortPath,
1886 lpszLongPath,
1887 ReturnLength * sizeof(WCHAR) + sizeof(UNICODE_NULL));
1888 }
1889 }
1890 else
1891 {
1892 /* Otherwise, let caller know we need a bigger buffer, include NULL */
1893 ReturnLength++;
1894 }
1895 goto Quickie;
1896 }
1897
1898 /* We are still in the game -- compute the current size */
1899 Length = wcslen(lpszLongPath) + sizeof(ANSI_NULL);
1900 Original = RtlAllocateHeap(RtlGetProcessHeap(), 0, Length * sizeof(WCHAR));
1901 if (!Original) goto ErrorQuickie;
1902
1903 /* Make a copy of it */
1904 wcsncpy(Original, lpszLongPath, Length);
1905
1906 /* Compute the new first and last markers */
1907 First = &Original[First - lpszLongPath];
1908 Last = &Original[Last - lpszLongPath];
1909
1910 /* Set the current destination pointer for a copy */
1911 Dst = lpszShortPath;
1912
1913 /*
1914 * Windows allows the paths to overlap -- we have to be careful with this and
1915 * see if it's same to do so, and if not, allocate our own internal buffer
1916 * that we'll return at the end.
1917 *
1918 * This is also why we use RtlMoveMemory everywhere. Don't use RtlCopyMemory!
1919 */
1920 if ((cchBuffer) && (lpszShortPath) &&
1921 (((lpszShortPath >= lpszLongPath) && (lpszShortPath < &lpszLongPath[Length])) ||
1922 ((lpszShortPath < lpszLongPath) && (&lpszShortPath[cchBuffer] >= lpszLongPath))))
1923 {
1924 Buffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, cchBuffer * sizeof(WCHAR));
1925 if (!Buffer) goto ErrorQuickie;
1926
1927 /* New destination */
1928 Dst = Buffer;
1929 }
1930
1931 /* Prepare for the loop */
1932 Src = Original;
1933 ReturnLength = 0;
1934 while (TRUE)
1935 {
1936 /* Current delta in the loop */
1937 Length = First - Src;
1938
1939 /* Update the return length by it */
1940 ReturnLength += Length;
1941
1942 /* Is there a delta? If so, is there space and buffer for it? */
1943 if ((Length) && (cchBuffer > ReturnLength) && (lpszShortPath))
1944 {
1945 RtlMoveMemory(Dst, Src, Length * sizeof(WCHAR));
1946 Dst += Length;
1947 }
1948
1949 /* "Terminate" this portion of the path's substring so we can do a find */
1950 LastChar = *Last;
1951 *Last = UNICODE_NULL;
1952 FindHandle = FindFirstFileW(Original, &FindFileData);
1953 *Last = LastChar;
1954
1955 /* This portion wasn't found, so fail */
1956 if (FindHandle == INVALID_HANDLE_VALUE)
1957 {
1958 ReturnLength = 0;
1959 break;
1960 }
1961
1962 /* Close the find handle */
1963 FindClose(FindHandle);
1964
1965 /* Now check the length of the short name */
1966 Length = wcslen(FindFileData.cAlternateFileName);
1967 if (Length)
1968 {
1969 /* This is our new first marker */
1970 First = FindFileData.cAlternateFileName;
1971 }
1972 else
1973 {
1974 /* Otherwise, the name is the delta between our current markers */
1975 Length = Last - First;
1976 }
1977
1978 /* Update the return length with the short name length, if any */
1979 ReturnLength += Length;
1980
1981 /* Once again check for appropriate space and buffer */
1982 if ((cchBuffer > ReturnLength) && (lpszShortPath))
1983 {
1984 /* And do the copy if there is */
1985 RtlMoveMemory(Dst, First, Length * sizeof(WCHAR));
1986 Dst += Length;
1987 }
1988
1989 /* Now update the source pointer */
1990 Src = Last;
1991 if (*Src == UNICODE_NULL) break;
1992
1993 /* Are there more names in there? */
1994 Found = FindLFNorSFN_U(Src, &First, &Last, TRUE);
1995 if (!Found) break;
1996 }
1997
1998 /* The loop is done, is there anything left? */
1999 if (ReturnLength)
2000 {
2001 /* Get the length of the straggling path */
2002 Length = wcslen(Src);
2003 ReturnLength += Length;
2004
2005 /* Once again check for appropriate space and buffer */
2006 if ((cchBuffer > ReturnLength) && (lpszShortPath))
2007 {
2008 /* And do the copy if there is -- accounting for NULL here */
2009 RtlMoveMemory(Dst, Src, Length * sizeof(WCHAR) + sizeof(UNICODE_NULL));
2010
2011 /* What about our buffer? */
2012 if (Buffer)
2013 {
2014 /* Copy it into the caller's long path */
2015 RtlMoveMemory(lpszShortPath,
2016 Buffer,
2017 ReturnLength * sizeof(WCHAR) + sizeof(UNICODE_NULL));
2018 }
2019 }
2020 else
2021 {
2022 /* Buffer is too small, let the caller know, making space for NULL */
2023 ReturnLength++;
2024 }
2025 }
2026
2027 /* We're all done */
2028 goto Quickie;
2029
2030 ErrorQuickie:
2031 /* This is the goto for memory failures */
2032 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
2033
2034 Quickie:
2035 /* General function end: free memory, restore error mode, return length */
2036 if (Original) RtlFreeHeap(RtlGetProcessHeap(), 0, Original);
2037 if (Buffer) RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
2038 SetErrorMode(ErrorMode);
2039 return ReturnLength;
2040 }
2041
2042 /*
2043 * @implemented
2044 *
2045 * NOTE: Windows returns a dos/short (8.3) path
2046 */
2047 DWORD
2048 WINAPI
2049 GetTempPathA(IN DWORD nBufferLength,
2050 IN LPSTR lpBuffer)
2051 {
2052 WCHAR BufferW[MAX_PATH];
2053 DWORD ret;
2054
2055 ret = GetTempPathW(MAX_PATH, BufferW);
2056
2057 if (!ret) return 0;
2058
2059 if (ret > MAX_PATH)
2060 {
2061 SetLastError(ERROR_FILENAME_EXCED_RANGE);
2062 return 0;
2063 }
2064
2065 return FilenameW2A_FitOrFail(lpBuffer, nBufferLength, BufferW, ret+1);
2066 }
2067
2068 /*
2069 * @implemented
2070 *
2071 * ripped from wine
2072 */
2073 DWORD
2074 WINAPI
2075 GetTempPathW(IN DWORD count,
2076 IN LPWSTR path)
2077 {
2078 static const WCHAR tmp[] = { 'T', 'M', 'P', 0 };
2079 static const WCHAR temp[] = { 'T', 'E', 'M', 'P', 0 };
2080 static const WCHAR userprofile[] = { 'U','S','E','R','P','R','O','F','I','L','E',0 };
2081 WCHAR tmp_path[MAX_PATH];
2082 UINT ret;
2083
2084 DPRINT("%u,%p\n", count, path);
2085
2086 if (!(ret = GetEnvironmentVariableW( tmp, tmp_path, MAX_PATH )) &&
2087 !(ret = GetEnvironmentVariableW( temp, tmp_path, MAX_PATH )) &&
2088 !(ret = GetEnvironmentVariableW( userprofile, tmp_path, MAX_PATH )) &&
2089 !(ret = GetWindowsDirectoryW( tmp_path, MAX_PATH )))
2090 return 0;
2091
2092 if (ret > MAX_PATH)
2093 {
2094 SetLastError(ERROR_FILENAME_EXCED_RANGE);
2095 return 0;
2096 }
2097
2098 ret = GetFullPathNameW(tmp_path, MAX_PATH, tmp_path, NULL);
2099 if (!ret) return 0;
2100
2101 if (ret > MAX_PATH - 2)
2102 {
2103 SetLastError(ERROR_FILENAME_EXCED_RANGE);
2104 return 0;
2105 }
2106
2107 if (tmp_path[ret-1] != '\\')
2108 {
2109 tmp_path[ret++] = '\\';
2110 tmp_path[ret] = '\0';
2111 }
2112
2113 ret++; /* add space for terminating 0 */
2114
2115 if (count)
2116 {
2117 lstrcpynW(path, tmp_path, count);
2118 if (count >= ret)
2119 ret--; /* return length without 0 */
2120 else if (count < 4)
2121 path[0] = 0; /* avoid returning ambiguous "X:" */
2122 }
2123
2124 DPRINT("GetTempPathW returning %u, %S\n", ret, path);
2125 return ret;
2126 }
2127
2128 /*
2129 * @implemented
2130 */
2131 DWORD
2132 WINAPI
2133 GetCurrentDirectoryA(IN DWORD nBufferLength,
2134 IN LPSTR lpBuffer)
2135 {
2136 ANSI_STRING AnsiString;
2137 NTSTATUS Status;
2138 PUNICODE_STRING StaticString;
2139 ULONG MaxLength;
2140
2141 StaticString = &NtCurrentTeb()->StaticUnicodeString;
2142
2143 MaxLength = nBufferLength;
2144 if (nBufferLength >= UNICODE_STRING_MAX_BYTES)
2145 {
2146 MaxLength = UNICODE_STRING_MAX_BYTES - 1;
2147 }
2148
2149 StaticString->Length = RtlGetCurrentDirectory_U(StaticString->MaximumLength,
2150 StaticString->Buffer);
2151 Status = RtlUnicodeToMultiByteSize(&nBufferLength,
2152 StaticString->Buffer,
2153 StaticString->Length);
2154 if (!NT_SUCCESS(Status))
2155 {
2156 BaseSetLastNTError(Status);
2157 return 0;
2158 }
2159
2160 if (MaxLength <= nBufferLength)
2161 {
2162 return nBufferLength + 1;
2163 }
2164
2165 AnsiString.Buffer = lpBuffer;
2166 AnsiString.MaximumLength = MaxLength;
2167 Status = BasepUnicodeStringTo8BitString(&AnsiString, StaticString, FALSE);
2168 if (!NT_SUCCESS(Status))
2169 {
2170 BaseSetLastNTError(Status);
2171 return 0;
2172 }
2173
2174 return AnsiString.Length;
2175 }
2176
2177 /*
2178 * @implemented
2179 */
2180 DWORD
2181 WINAPI
2182 GetCurrentDirectoryW(IN DWORD nBufferLength,
2183 IN LPWSTR lpBuffer)
2184 {
2185 return RtlGetCurrentDirectory_U(nBufferLength * sizeof(WCHAR), lpBuffer) / sizeof(WCHAR);
2186 }
2187
2188 /*
2189 * @implemented
2190 */
2191 BOOL
2192 WINAPI
2193 SetCurrentDirectoryA(IN LPCSTR lpPathName)
2194 {
2195 PUNICODE_STRING DirName;
2196 NTSTATUS Status;
2197
2198 if (!lpPathName)
2199 {
2200 BaseSetLastNTError(STATUS_INVALID_PARAMETER);
2201 return FALSE;
2202 }
2203
2204 DirName = Basep8BitStringToStaticUnicodeString(lpPathName);
2205 if (!DirName) return FALSE;
2206
2207 if (CheckForSameCurdir(DirName)) return TRUE;
2208
2209 Status = RtlSetCurrentDirectory_U(DirName);
2210 if (NT_SUCCESS(Status)) return TRUE;
2211
2212 if ((*DirName->Buffer != L'"') || (DirName->Length <= 2))
2213 {
2214 BaseSetLastNTError(Status);
2215 return 0;
2216 }
2217
2218 DirName = Basep8BitStringToStaticUnicodeString(lpPathName + 1);
2219 if (!DirName) return FALSE;
2220
2221 Status = RtlSetCurrentDirectory_U(DirName);
2222 if (!NT_SUCCESS(Status))
2223 {
2224 BaseSetLastNTError(Status);
2225 return FALSE;
2226 }
2227
2228 return TRUE;
2229 }
2230
2231 /*
2232 * @implemented
2233 */
2234 BOOL
2235 WINAPI
2236 SetCurrentDirectoryW(IN LPCWSTR lpPathName)
2237 {
2238 NTSTATUS Status;
2239 UNICODE_STRING UnicodeString;
2240
2241 if (!lpPathName)
2242 {
2243 BaseSetLastNTError(STATUS_INVALID_PARAMETER);
2244 return FALSE;
2245 }
2246
2247 Status = RtlInitUnicodeStringEx(&UnicodeString, lpPathName);
2248 if (NT_SUCCESS(Status))
2249 {
2250 if (!CheckForSameCurdir(&UnicodeString))
2251 {
2252 Status = RtlSetCurrentDirectory_U(&UnicodeString);
2253 }
2254 }
2255
2256 if (!NT_SUCCESS(Status))
2257 {
2258 BaseSetLastNTError(Status);
2259 return FALSE;
2260 }
2261
2262 return TRUE;
2263 }
2264
2265 /*
2266 * @implemented
2267 */
2268 UINT
2269 WINAPI
2270 GetSystemDirectoryA(IN LPSTR lpBuffer,
2271 IN UINT uSize)
2272 {
2273 ANSI_STRING AnsiString;
2274 NTSTATUS Status;
2275 ULONG AnsiLength;
2276
2277 /* Get the correct size of the Unicode Base directory */
2278 Status = RtlUnicodeToMultiByteSize(&AnsiLength,
2279 BaseWindowsSystemDirectory.Buffer,
2280 BaseWindowsSystemDirectory.MaximumLength);
2281 if (!NT_SUCCESS(Status)) return 0;
2282
2283 if (uSize < AnsiLength) return AnsiLength;
2284
2285 RtlInitEmptyAnsiString(&AnsiString, lpBuffer, uSize);
2286
2287 Status = BasepUnicodeStringTo8BitString(&AnsiString,
2288 &BaseWindowsSystemDirectory,
2289 FALSE);
2290 if (!NT_SUCCESS(Status)) return 0;
2291
2292 return AnsiString.Length;
2293 }
2294
2295 /*
2296 * @implemented
2297 */
2298 UINT
2299 WINAPI
2300 GetSystemDirectoryW(IN LPWSTR lpBuffer,
2301 IN UINT uSize)
2302 {
2303 ULONG ReturnLength;
2304
2305 ReturnLength = BaseWindowsSystemDirectory.MaximumLength;
2306 if ((uSize * sizeof(WCHAR)) >= ReturnLength)
2307 {
2308 RtlCopyMemory(lpBuffer,
2309 BaseWindowsSystemDirectory.Buffer,
2310 BaseWindowsSystemDirectory.Length);
2311 lpBuffer[BaseWindowsSystemDirectory.Length / sizeof(WCHAR)] = ANSI_NULL;
2312
2313 ReturnLength = BaseWindowsSystemDirectory.Length;
2314 }
2315
2316 return ReturnLength / sizeof(WCHAR);
2317 }
2318
2319 /*
2320 * @implemented
2321 */
2322 UINT
2323 WINAPI
2324 GetWindowsDirectoryA(IN LPSTR lpBuffer,
2325 IN UINT uSize)
2326 {
2327 /* Is this a TS installation? */
2328 if (gpTermsrvGetWindowsDirectoryA) UNIMPLEMENTED;
2329
2330 /* Otherwise, call the System API */
2331 return GetSystemWindowsDirectoryA(lpBuffer, uSize);
2332 }
2333
2334 /*
2335 * @implemented
2336 */
2337 UINT
2338 WINAPI
2339 GetWindowsDirectoryW(IN LPWSTR lpBuffer,
2340 IN UINT uSize)
2341 {
2342 /* Is this a TS installation? */
2343 if (gpTermsrvGetWindowsDirectoryW) UNIMPLEMENTED;
2344
2345 /* Otherwise, call the System API */
2346 return GetSystemWindowsDirectoryW(lpBuffer, uSize);
2347 }
2348
2349 /*
2350 * @implemented
2351 */
2352 UINT
2353 WINAPI
2354 GetSystemWindowsDirectoryA(IN LPSTR lpBuffer,
2355 IN UINT uSize)
2356 {
2357 ANSI_STRING AnsiString;
2358 NTSTATUS Status;
2359 ULONG AnsiLength;
2360
2361 /* Get the correct size of the Unicode Base directory */
2362 Status = RtlUnicodeToMultiByteSize(&AnsiLength,
2363 BaseWindowsDirectory.Buffer,
2364 BaseWindowsDirectory.MaximumLength);
2365 if (!NT_SUCCESS(Status)) return 0;
2366
2367 if (uSize < AnsiLength) return AnsiLength;
2368
2369 RtlInitEmptyAnsiString(&AnsiString, lpBuffer, uSize);
2370
2371 Status = BasepUnicodeStringTo8BitString(&AnsiString,
2372 &BaseWindowsDirectory,
2373 FALSE);
2374 if (!NT_SUCCESS(Status)) return 0;
2375
2376 return AnsiString.Length;
2377 }
2378
2379 /*
2380 * @implemented
2381 */
2382 UINT
2383 WINAPI
2384 GetSystemWindowsDirectoryW(IN LPWSTR lpBuffer,
2385 IN UINT uSize)
2386 {
2387 ULONG ReturnLength;
2388
2389 ReturnLength = BaseWindowsDirectory.MaximumLength;
2390 if ((uSize * sizeof(WCHAR)) >= ReturnLength)
2391 {
2392 RtlCopyMemory(lpBuffer,
2393 BaseWindowsDirectory.Buffer,
2394 BaseWindowsDirectory.Length);
2395 lpBuffer[BaseWindowsDirectory.Length / sizeof(WCHAR)] = ANSI_NULL;
2396
2397 ReturnLength = BaseWindowsDirectory.Length;
2398 }
2399
2400 return ReturnLength / sizeof(WCHAR);
2401 }
2402
2403 /*
2404 * @unimplemented
2405 */
2406 UINT
2407 WINAPI
2408 GetSystemWow64DirectoryW(IN LPWSTR lpBuffer,
2409 IN UINT uSize)
2410 {
2411 #ifdef _WIN64
2412 UNIMPLEMENTED;
2413 return 0;
2414 #else
2415 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2416 return 0;
2417 #endif
2418 }
2419
2420 /*
2421 * @unimplemented
2422 */
2423 UINT
2424 WINAPI
2425 GetSystemWow64DirectoryA(IN LPSTR lpBuffer,
2426 IN UINT uSize)
2427 {
2428 #ifdef _WIN64
2429 UNIMPLEMENTED;
2430 return 0;
2431 #else
2432 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2433 return 0;
2434 #endif
2435 }
2436
2437 /* EOF */