Synchronize with trunk revision 59636 (just before Alex's CreateProcess revamp).
[reactos.git] / dll / win32 / kernel32 / client / file / find.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS system libraries
4 * FILE: dll/win32/kernel32/client/file/find.c
5 * PURPOSE: Find functions
6 * PROGRAMMERS: Ariadne (ariadne@xs4all.nl)
7 * Pierre Schweitzer (pierre.schweitzer@reactos.org)
8 * Hermes BELUSCA - MAITO (hermes.belusca@sfr.fr)
9 */
10
11 /* INCLUDES *******************************************************************/
12
13 #include <k32.h>
14 #define NDEBUG
15 #include <debug.h>
16 DEBUG_CHANNEL(kernel32file);
17
18
19 /* TYPES **********************************************************************/
20
21 #define FIND_DATA_SIZE 0x4000
22 #define FIND_DEVICE_HANDLE ((HANDLE)0x1)
23
24 typedef enum _FIND_DATA_TYPE
25 {
26 FindFile = 1,
27 FindStream = 2
28 } FIND_DATA_TYPE;
29
30 /*
31 * FILE_FULL_DIR_INFORMATION and FILE_BOTH_DIR_INFORMATION structures layout.
32 *
33 *
34 * struct FILE_FULL_DIR_INFORMATION | struct FILE_BOTH_DIR_INFORMATION
35 * ------------------------------------+---------------------------------------
36 * ULONG NextEntryOffset; | ULONG NextEntryOffset;
37 * ULONG FileIndex; | ULONG FileIndex;
38 * LARGE_INTEGER CreationTime; | LARGE_INTEGER CreationTime;
39 * LARGE_INTEGER LastAccessTime; | LARGE_INTEGER LastAccessTime;
40 * LARGE_INTEGER LastWriteTime; | LARGE_INTEGER LastWriteTime;
41 * LARGE_INTEGER ChangeTime; | LARGE_INTEGER ChangeTime;
42 * LARGE_INTEGER EndOfFile; | LARGE_INTEGER EndOfFile;
43 * LARGE_INTEGER AllocationSize; | LARGE_INTEGER AllocationSize;
44 * ULONG FileAttributes; | ULONG FileAttributes;
45 * ULONG FileNameLength; | ULONG FileNameLength;
46 * ULONG EaSize; | ULONG EaSize;
47 * ------------------------------------+---------------------------------------
48 * WCHAR FileName[1]; | CCHAR ShortNameLength;
49 * | WCHAR ShortName[12];
50 * | WCHAR FileName[1];
51 *
52 * Therefore we can use pointers to FILE_FULL_DIR_INFORMATION when one doesn't
53 * want to refer to the ShortName* fields and FileName (useful for implementing
54 * the FindExInfoBasic functionality for FindFirstFileEx), however a cast to
55 * FILE_BOTH_DIR_INFORMATION is required when one wants to use FileName and
56 * ShortName* fields (needed for the FindExInfoStandard functionality).
57 *
58 */
59 typedef union _DIR_INFORMATION
60 {
61 PVOID DirInfo;
62 PFILE_FULL_DIR_INFORMATION FullDirInfo;
63 PFILE_BOTH_DIR_INFORMATION BothDirInfo;
64 } DIR_INFORMATION;
65
66 typedef struct _FIND_FILE_DATA
67 {
68 HANDLE Handle;
69 FINDEX_INFO_LEVELS InfoLevel;
70 FINDEX_SEARCH_OPS SearchOp;
71
72 /*
73 * For handling STATUS_BUFFER_OVERFLOW errors emitted by
74 * NtQueryDirectoryFile in the FildNextFile function.
75 */
76 BOOLEAN HasMoreData;
77
78 /*
79 * "Pointer" to the next file info structure in the buffer.
80 * The type is defined by the 'InfoLevel' parameter.
81 */
82 DIR_INFORMATION NextDirInfo;
83
84 BYTE Buffer[FIND_DATA_SIZE];
85 } FIND_FILE_DATA, *PFIND_FILE_DATA;
86
87 typedef struct _FIND_STREAM_DATA
88 {
89 STREAM_INFO_LEVELS InfoLevel;
90 PFILE_STREAM_INFORMATION FileStreamInfo;
91 PFILE_STREAM_INFORMATION CurrentInfo;
92 } FIND_STREAM_DATA, *PFIND_STREAM_DATA;
93
94 typedef struct _FIND_DATA_HANDLE
95 {
96 FIND_DATA_TYPE Type;
97 RTL_CRITICAL_SECTION Lock;
98
99 /*
100 * Pointer to the following finding data, located at
101 * (this + 1). The type is defined by the 'Type' parameter.
102 */
103 union
104 {
105 PFIND_FILE_DATA FindFileData;
106 PFIND_STREAM_DATA FindStreamData;
107 } u;
108
109 } FIND_DATA_HANDLE, *PFIND_DATA_HANDLE;
110
111
112 /* PRIVATE FUNCTIONS **********************************************************/
113
114 static VOID
115 CopyDeviceFindData(OUT LPWIN32_FIND_DATAW lpFindFileData,
116 IN LPCWSTR lpFileName,
117 IN ULONG DeviceNameInfo)
118 {
119 LPCWSTR DeviceName;
120 SIZE_T Length;
121
122 _SEH2_TRY
123 {
124 /* DeviceNameInfo == { USHORT Offset; USHORT Length } */
125 Length = (SIZE_T)(DeviceNameInfo & 0xFFFF);
126 DeviceName = (LPCWSTR)((ULONG_PTR)lpFileName + ((DeviceNameInfo >> 16) & 0xFFFF));
127
128 /* Return the data */
129 RtlZeroMemory(lpFindFileData, sizeof(*lpFindFileData));
130 lpFindFileData->dwFileAttributes = FILE_ATTRIBUTE_ARCHIVE;
131 RtlCopyMemory(lpFindFileData->cFileName,
132 DeviceName,
133 Length);
134 }
135 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
136 {
137 }
138 _SEH2_END;
139
140 return;
141 }
142
143 static VOID
144 CopyFindData(OUT LPWIN32_FIND_DATAW lpFindFileData,
145 IN FINDEX_INFO_LEVELS fInfoLevelId,
146 IN DIR_INFORMATION DirInfo)
147 {
148 #define ULARGE_INTEGER_2_FILETIME(ft, ul) \
149 do { \
150 (ft).dwHighDateTime = (ul).u.HighPart; \
151 (ft).dwLowDateTime = (ul).u.LowPart ; \
152 } while(0)
153
154 _SEH2_TRY
155 {
156 RtlZeroMemory(lpFindFileData, sizeof(*lpFindFileData));
157
158 lpFindFileData->dwFileAttributes = DirInfo.FullDirInfo->FileAttributes;
159
160 ULARGE_INTEGER_2_FILETIME(lpFindFileData->ftCreationTime, DirInfo.FullDirInfo->CreationTime);
161 ULARGE_INTEGER_2_FILETIME(lpFindFileData->ftLastAccessTime, DirInfo.FullDirInfo->LastAccessTime);
162 ULARGE_INTEGER_2_FILETIME(lpFindFileData->ftLastWriteTime, DirInfo.FullDirInfo->LastWriteTime);
163
164 lpFindFileData->nFileSizeHigh = DirInfo.FullDirInfo->EndOfFile.u.HighPart;
165 lpFindFileData->nFileSizeLow = DirInfo.FullDirInfo->EndOfFile.u.LowPart;
166
167 /* dwReserved0 contains the NTFS reparse point tag, if any. */
168 if (DirInfo.FullDirInfo->FileAttributes & FILE_ATTRIBUTE_REPARSE_POINT)
169 lpFindFileData->dwReserved0 = DirInfo.FullDirInfo->EaSize;
170 else
171 lpFindFileData->dwReserved0 = 0;
172
173 /* Unused dwReserved1 field */
174 lpFindFileData->dwReserved1 = 0;
175
176 if (fInfoLevelId == FindExInfoStandard)
177 {
178 RtlCopyMemory(lpFindFileData->cFileName,
179 DirInfo.BothDirInfo->FileName,
180 DirInfo.BothDirInfo->FileNameLength);
181 lpFindFileData->cFileName[DirInfo.BothDirInfo->FileNameLength / sizeof(WCHAR)] = UNICODE_NULL;
182
183 RtlCopyMemory(lpFindFileData->cAlternateFileName,
184 DirInfo.BothDirInfo->ShortName,
185 DirInfo.BothDirInfo->ShortNameLength);
186 lpFindFileData->cAlternateFileName[DirInfo.BothDirInfo->ShortNameLength / sizeof(WCHAR)] = UNICODE_NULL;
187 }
188 else if (fInfoLevelId == FindExInfoBasic)
189 {
190 RtlCopyMemory(lpFindFileData->cFileName,
191 DirInfo.FullDirInfo->FileName,
192 DirInfo.FullDirInfo->FileNameLength);
193 lpFindFileData->cFileName[DirInfo.FullDirInfo->FileNameLength / sizeof(WCHAR)] = UNICODE_NULL;
194
195 lpFindFileData->cAlternateFileName[0] = UNICODE_NULL;
196 }
197 else
198 {
199 /* Invalid InfoLevelId */
200 ASSERT(FALSE);
201 }
202 }
203 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
204 {
205 }
206 _SEH2_END;
207
208 return;
209 }
210
211 static VOID
212 CopyStreamData(IN OUT PFIND_STREAM_DATA FindStreamData,
213 OUT PWIN32_FIND_STREAM_DATA lpFindStreamData)
214 {
215 _SEH2_TRY
216 {
217 ASSERT(FindStreamData->CurrentInfo);
218
219 switch (FindStreamData->InfoLevel)
220 {
221 case FindStreamInfoStandard:
222 {
223 ULONG StreamNameLen = min(FindStreamData->CurrentInfo->StreamNameLength,
224 sizeof(lpFindStreamData->cStreamName) - sizeof(WCHAR));
225
226 RtlZeroMemory(lpFindStreamData, sizeof(*lpFindStreamData));
227
228 lpFindStreamData->StreamSize.QuadPart = FindStreamData->CurrentInfo->StreamSize.QuadPart;
229 RtlCopyMemory(lpFindStreamData->cStreamName,
230 FindStreamData->CurrentInfo->StreamName,
231 StreamNameLen);
232 lpFindStreamData->cStreamName[StreamNameLen / sizeof(WCHAR)] = UNICODE_NULL;
233
234 break;
235 }
236
237 default:
238 {
239 /* Invalid InfoLevel */
240 ASSERT(FALSE);
241 break;
242 }
243 }
244 }
245 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
246 {
247 }
248 _SEH2_END;
249
250 return;
251 }
252
253
254 /* PUBLIC FUNCTIONS ***********************************************************/
255
256 /*
257 * @implemented
258 */
259 HANDLE
260 WINAPI
261 FindFirstFileA(IN LPCSTR lpFileName,
262 OUT LPWIN32_FIND_DATAA lpFindFileData)
263 {
264 HANDLE hSearch;
265 NTSTATUS Status;
266 ANSI_STRING Ansi;
267 UNICODE_STRING UTF8;
268 PUNICODE_STRING lpFileNameW;
269 WIN32_FIND_DATAW FindFileDataW;
270
271 lpFileNameW = Basep8BitStringToStaticUnicodeString(lpFileName);
272 if (!lpFileNameW) return INVALID_HANDLE_VALUE;
273
274 hSearch = FindFirstFileExW(lpFileNameW->Buffer,
275 FindExInfoStandard,
276 &FindFileDataW,
277 FindExSearchNameMatch,
278 NULL, 0);
279 if (hSearch == INVALID_HANDLE_VALUE) return INVALID_HANDLE_VALUE;
280
281 RtlCopyMemory(lpFindFileData,
282 &FindFileDataW,
283 FIELD_OFFSET(WIN32_FIND_DATAA, cFileName));
284
285 RtlInitUnicodeString(&UTF8, FindFileDataW.cFileName);
286 Ansi.Buffer = lpFindFileData->cFileName;
287 Ansi.Length = 0;
288 Ansi.MaximumLength = sizeof(lpFindFileData->cFileName);
289 Status = BasepUnicodeStringTo8BitString(&Ansi, &UTF8, FALSE);
290 if (!NT_SUCCESS(Status))
291 {
292 FindClose(hSearch);
293 BaseSetLastNTError(Status);
294 return INVALID_HANDLE_VALUE;
295 }
296
297 RtlInitUnicodeString(&UTF8, FindFileDataW.cAlternateFileName);
298 Ansi.Buffer = lpFindFileData->cAlternateFileName;
299 Ansi.Length = 0;
300 Ansi.MaximumLength = sizeof(lpFindFileData->cAlternateFileName);
301 Status = BasepUnicodeStringTo8BitString(&Ansi, &UTF8, FALSE);
302 if (!NT_SUCCESS(Status))
303 {
304 FindClose(hSearch);
305 BaseSetLastNTError(Status);
306 return INVALID_HANDLE_VALUE;
307 }
308
309 return hSearch;
310 }
311
312
313 /*
314 * @implemented
315 */
316 HANDLE
317 WINAPI
318 FindFirstFileW(IN LPCWSTR lpFileName,
319 OUT LPWIN32_FIND_DATAW lpFindFileData)
320 {
321 return FindFirstFileExW(lpFileName,
322 FindExInfoStandard,
323 lpFindFileData,
324 FindExSearchNameMatch,
325 NULL, 0);
326 }
327
328
329 /*
330 * @implemented
331 */
332 BOOL
333 WINAPI
334 FindNextFileA(IN HANDLE hFindFile,
335 OUT LPWIN32_FIND_DATAA lpFindFileData)
336 {
337 NTSTATUS Status;
338 ANSI_STRING Ansi;
339 UNICODE_STRING UTF8;
340 WIN32_FIND_DATAW FindFileDataW;
341
342 if (!FindNextFileW(hFindFile, &FindFileDataW))
343 return FALSE;
344
345 RtlCopyMemory(lpFindFileData,
346 &FindFileDataW,
347 FIELD_OFFSET(WIN32_FIND_DATAA, cFileName));
348
349 RtlInitUnicodeString(&UTF8, FindFileDataW.cFileName);
350 Ansi.Buffer = lpFindFileData->cFileName;
351 Ansi.Length = 0;
352 Ansi.MaximumLength = sizeof(lpFindFileData->cFileName);
353 Status = BasepUnicodeStringTo8BitString(&Ansi, &UTF8, FALSE);
354 if (!NT_SUCCESS(Status))
355 {
356 BaseSetLastNTError(Status);
357 return FALSE;
358 }
359
360 RtlInitUnicodeString(&UTF8, FindFileDataW.cAlternateFileName);
361 Ansi.Buffer = lpFindFileData->cAlternateFileName;
362 Ansi.Length = 0;
363 Ansi.MaximumLength = sizeof(lpFindFileData->cAlternateFileName);
364 Status = BasepUnicodeStringTo8BitString(&Ansi, &UTF8, FALSE);
365 if (!NT_SUCCESS(Status))
366 {
367 BaseSetLastNTError(Status);
368 return FALSE;
369 }
370
371 return TRUE;
372 }
373
374
375 /*
376 * @implemented
377 */
378 BOOL
379 WINAPI
380 FindNextFileW(IN HANDLE hFindFile,
381 OUT LPWIN32_FIND_DATAW lpFindFileData)
382 {
383 NTSTATUS Status = STATUS_SUCCESS;
384 DIR_INFORMATION FoundFile = {NULL};
385
386 TRACE("FindNextFileW(%lx, 0x%p)\n", hFindFile, lpFindFileData);
387
388 if (hFindFile != FIND_DEVICE_HANDLE)
389 {
390 PFIND_DATA_HANDLE FindDataHandle = (PFIND_DATA_HANDLE)hFindFile;
391 PFIND_FILE_DATA FindFileData;
392 FINDEX_INFO_LEVELS InfoLevel;
393 IO_STATUS_BLOCK IoStatusBlock;
394 DIR_INFORMATION DirInfo = {NULL}, NextDirInfo = {NULL};
395
396 if (hFindFile == NULL || hFindFile == INVALID_HANDLE_VALUE ||
397 FindDataHandle->Type != FindFile)
398 {
399 SetLastError(ERROR_INVALID_HANDLE);
400 return FALSE;
401 }
402
403 RtlEnterCriticalSection(&FindDataHandle->Lock);
404
405 FindFileData = FindDataHandle->u.FindFileData;
406 InfoLevel = FindFileData->InfoLevel;
407
408 do
409 {
410 if (FindFileData->NextDirInfo.DirInfo == NULL)
411 {
412 Status = NtQueryDirectoryFile(FindFileData->Handle,
413 NULL, NULL, NULL,
414 &IoStatusBlock,
415 &FindFileData->Buffer,
416 sizeof(FindFileData->Buffer),
417 (InfoLevel == FindExInfoStandard
418 ? FileBothDirectoryInformation
419 : FileFullDirectoryInformation),
420 FALSE,
421 NULL, /* Use the file pattern from the first call */
422 FALSE);
423 if (Status == STATUS_BUFFER_OVERFLOW)
424 {
425 FindFileData->HasMoreData = TRUE;
426 Status = STATUS_SUCCESS;
427 }
428 else
429 {
430 if (!NT_SUCCESS(Status)) break;
431 FindFileData->HasMoreData = FALSE;
432 }
433
434 FindFileData->NextDirInfo.DirInfo = &FindFileData->Buffer;
435 }
436
437 DirInfo = FindFileData->NextDirInfo;
438
439 if (DirInfo.FullDirInfo->NextEntryOffset != 0)
440 {
441 ULONG_PTR BufferEnd = (ULONG_PTR)&FindFileData->Buffer + sizeof(FindFileData->Buffer);
442 PWSTR pFileName;
443
444 NextDirInfo.DirInfo = FindFileData->NextDirInfo.DirInfo =
445 (PVOID)((ULONG_PTR)DirInfo.DirInfo + DirInfo.FullDirInfo->NextEntryOffset);
446
447 pFileName = (InfoLevel == FindExInfoStandard
448 ? NextDirInfo.BothDirInfo->FileName
449 : NextDirInfo.FullDirInfo->FileName);
450
451 /* Be paranoid and make sure that the next entry is completely there */
452 if (BufferEnd < (ULONG_PTR)NextDirInfo.DirInfo ||
453 BufferEnd < (ULONG_PTR)&NextDirInfo.FullDirInfo->FileNameLength + sizeof(NextDirInfo.FullDirInfo->FileNameLength) ||
454 BufferEnd <= (ULONG_PTR)((ULONG_PTR)pFileName + NextDirInfo.FullDirInfo->FileNameLength))
455 {
456 FindFileData->NextDirInfo.DirInfo = NULL;
457 }
458 }
459 else
460 {
461 FindFileData->NextDirInfo.DirInfo = NULL;
462 }
463
464 if ((FindFileData->SearchOp != FindExSearchLimitToDirectories) ||
465 (DirInfo.FullDirInfo->FileAttributes & FILE_ATTRIBUTE_DIRECTORY))
466 {
467 FoundFile = DirInfo;
468 }
469 } while ( FoundFile.DirInfo == NULL && (FindFileData->NextDirInfo.DirInfo || FindFileData->HasMoreData) );
470
471 if (FoundFile.DirInfo != NULL)
472 {
473 /* Return the information */
474 CopyFindData(lpFindFileData, InfoLevel, FoundFile);
475 }
476
477 RtlLeaveCriticalSection(&FindDataHandle->Lock);
478 }
479
480 if (!NT_SUCCESS(Status))
481 {
482 BaseSetLastNTError(Status);
483 return FALSE;
484 }
485 else if (FoundFile.DirInfo == NULL)
486 {
487 SetLastError(ERROR_NO_MORE_FILES);
488 return FALSE;
489 }
490
491 return TRUE;
492 }
493
494
495 /*
496 * @implemented
497 */
498 BOOL
499 WINAPI
500 FindClose(HANDLE hFindFile)
501 {
502 TRACE("FindClose(hFindFile %x)\n", hFindFile);
503
504 if (hFindFile == FIND_DEVICE_HANDLE)
505 return TRUE;
506
507 if (!hFindFile || hFindFile == INVALID_HANDLE_VALUE)
508 {
509 SetLastError(ERROR_INVALID_HANDLE);
510 return FALSE;
511 }
512
513 /* Protect with SEH against closing attempts on invalid handles. */
514 _SEH2_TRY
515 {
516 PFIND_DATA_HANDLE FindDataHandle = (PFIND_DATA_HANDLE)hFindFile;
517
518 switch (FindDataHandle->Type)
519 {
520 case FindFile:
521 {
522 RtlEnterCriticalSection(&FindDataHandle->Lock);
523 NtClose(FindDataHandle->u.FindFileData->Handle);
524 RtlLeaveCriticalSection(&FindDataHandle->Lock);
525 RtlDeleteCriticalSection(&FindDataHandle->Lock);
526 break;
527 }
528
529 case FindStream:
530 {
531 RtlEnterCriticalSection(&FindDataHandle->Lock);
532 if (FindDataHandle->u.FindStreamData->FileStreamInfo != NULL)
533 {
534 RtlFreeHeap(RtlGetProcessHeap(), 0,
535 FindDataHandle->u.FindStreamData->FileStreamInfo);
536 }
537 RtlLeaveCriticalSection(&FindDataHandle->Lock);
538 RtlDeleteCriticalSection(&FindDataHandle->Lock);
539 break;
540 }
541
542 default:
543 {
544 SetLastError(ERROR_INVALID_HANDLE);
545 _SEH2_YIELD(return FALSE);
546 }
547 }
548
549 RtlFreeHeap(RtlGetProcessHeap(), 0, FindDataHandle);
550 }
551 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
552 {
553 BaseSetLastNTError(_SEH2_GetExceptionCode());
554 _SEH2_YIELD(return FALSE);
555 }
556 _SEH2_END;
557 return TRUE;
558 }
559
560
561 /*
562 * @unimplemented
563 */
564 HANDLE
565 WINAPI
566 FindFirstFileExA(IN LPCSTR lpFileName,
567 IN FINDEX_INFO_LEVELS fInfoLevelId,
568 OUT LPVOID lpFindFileData,
569 IN FINDEX_SEARCH_OPS fSearchOp,
570 LPVOID lpSearchFilter,
571 IN DWORD dwAdditionalFlags)
572 {
573 HANDLE hSearch;
574 NTSTATUS Status;
575 ANSI_STRING Ansi;
576 UNICODE_STRING UTF8;
577 PUNICODE_STRING lpFileNameW;
578 WIN32_FIND_DATAW FindFileDataW;
579 LPWIN32_FIND_DATAA lpFindFileDataA = (LPWIN32_FIND_DATAA)lpFindFileData;
580
581 if ((fInfoLevelId != FindExInfoStandard && fInfoLevelId != FindExInfoBasic) ||
582 fSearchOp == FindExSearchLimitToDevices ||
583 dwAdditionalFlags & ~FIND_FIRST_EX_CASE_SENSITIVE /* only supported flag for now */)
584 {
585 SetLastError(fSearchOp == FindExSearchLimitToDevices
586 ? ERROR_NOT_SUPPORTED
587 : ERROR_INVALID_PARAMETER);
588 return INVALID_HANDLE_VALUE;
589 }
590
591 lpFileNameW = Basep8BitStringToStaticUnicodeString(lpFileName);
592 if (!lpFileNameW) return INVALID_HANDLE_VALUE;
593
594 hSearch = FindFirstFileExW(lpFileNameW->Buffer,
595 fInfoLevelId,
596 &FindFileDataW,
597 fSearchOp,
598 lpSearchFilter,
599 dwAdditionalFlags);
600 if (hSearch == INVALID_HANDLE_VALUE) return INVALID_HANDLE_VALUE;
601
602 RtlCopyMemory(lpFindFileDataA,
603 &FindFileDataW,
604 FIELD_OFFSET(WIN32_FIND_DATAA, cFileName));
605
606 RtlInitUnicodeString(&UTF8, FindFileDataW.cFileName);
607 Ansi.Buffer = lpFindFileDataA->cFileName;
608 Ansi.Length = 0;
609 Ansi.MaximumLength = sizeof(lpFindFileDataA->cFileName);
610 Status = BasepUnicodeStringTo8BitString(&Ansi, &UTF8, FALSE);
611 if (!NT_SUCCESS(Status))
612 {
613 FindClose(hSearch);
614 BaseSetLastNTError(Status);
615 return INVALID_HANDLE_VALUE;
616 }
617
618 if (fInfoLevelId != FindExInfoBasic)
619 {
620 RtlInitUnicodeString(&UTF8, FindFileDataW.cAlternateFileName);
621 Ansi.Buffer = lpFindFileDataA->cAlternateFileName;
622 Ansi.Length = 0;
623 Ansi.MaximumLength = sizeof(lpFindFileDataA->cAlternateFileName);
624 Status = BasepUnicodeStringTo8BitString(&Ansi, &UTF8, FALSE);
625 if (!NT_SUCCESS(Status))
626 {
627 FindClose(hSearch);
628 BaseSetLastNTError(Status);
629 return INVALID_HANDLE_VALUE;
630 }
631 }
632 else
633 {
634 lpFindFileDataA->cAlternateFileName[0] = ANSI_NULL;
635 }
636
637 return hSearch;
638 }
639
640
641 /*
642 * @unimplemented
643 */
644 HANDLE
645 WINAPI
646 FindFirstFileExW(IN LPCWSTR lpFileName,
647 IN FINDEX_INFO_LEVELS fInfoLevelId,
648 OUT LPVOID lpFindFileData,
649 IN FINDEX_SEARCH_OPS fSearchOp,
650 LPVOID lpSearchFilter,
651 IN DWORD dwAdditionalFlags)
652 {
653 TRACE("FindFirstFileExW(lpFileName %S)\n", lpFileName);
654
655 if ((fInfoLevelId != FindExInfoStandard && fInfoLevelId != FindExInfoBasic) ||
656 fSearchOp == FindExSearchLimitToDevices ||
657 dwAdditionalFlags & ~FIND_FIRST_EX_CASE_SENSITIVE /* only supported flag for now */)
658 {
659 SetLastError(fSearchOp == FindExSearchLimitToDevices
660 ? ERROR_NOT_SUPPORTED
661 : ERROR_INVALID_PARAMETER);
662 return INVALID_HANDLE_VALUE;
663 }
664
665 if (fSearchOp == FindExSearchNameMatch ||
666 fSearchOp == FindExSearchLimitToDirectories)
667 {
668 LPWIN32_FIND_DATAW Win32FindData = (LPWIN32_FIND_DATAW)lpFindFileData;
669 PFIND_DATA_HANDLE FindDataHandle;
670 PFIND_FILE_DATA FindFileData;
671
672 UNICODE_STRING NtPath, FilePattern, FileName;
673 PWSTR NtPathBuffer;
674 RTL_RELATIVE_NAME_U RelativePath;
675 ULONG DeviceNameInfo = 0;
676
677 NTSTATUS Status;
678 OBJECT_ATTRIBUTES ObjectAttributes;
679 IO_STATUS_BLOCK IoStatusBlock;
680 HANDLE hDirectory = NULL;
681
682 BOOLEAN HadADot = FALSE;
683
684 /*
685 * May represent many FILE_BOTH_DIR_INFORMATION
686 * or many FILE_FULL_DIR_INFORMATION structures.
687 */
688 BYTE DirectoryInfo[FIND_DATA_SIZE];
689 DIR_INFORMATION DirInfo = {&DirectoryInfo};
690
691 /* The search filter is always unused */
692 if (lpSearchFilter)
693 {
694 SetLastError(ERROR_INVALID_PARAMETER);
695 return INVALID_HANDLE_VALUE;
696 }
697
698 RtlInitUnicodeString(&FileName, lpFileName);
699 if (FileName.Length != 0 && FileName.Buffer[FileName.Length / sizeof(WCHAR) - 1] == L'.')
700 {
701 HadADot = TRUE;
702 }
703
704 if (!RtlDosPathNameToNtPathName_U(lpFileName,
705 &NtPath,
706 (PCWSTR*)&FilePattern.Buffer,
707 &RelativePath))
708 {
709 SetLastError(ERROR_PATH_NOT_FOUND);
710 return INVALID_HANDLE_VALUE;
711 }
712
713 DPRINT("lpFileName = '%S'\n", lpFileName);
714 DPRINT("FilePattern.Buffer = '%S'\n", FilePattern.Buffer);
715 DPRINT("RelativePath.RelativeName = '%wZ'\n", &RelativePath.RelativeName);
716 DPRINT("NtPath.Buffer = '%S'\n", NtPath.Buffer);
717 DPRINT("NtPath - Before = '%wZ'\n", &NtPath);
718
719 /* Save the buffer pointer for later, we need to free it! */
720 NtPathBuffer = NtPath.Buffer;
721
722 /*
723 * Contrary to what Windows does, check NOW whether or not
724 * lpFileName is a DOS driver. Therefore we don't have to
725 * write broken code to check that.
726 */
727 if (!FilePattern.Buffer || !*FilePattern.Buffer)
728 {
729 /* No file pattern specified, or DOS device */
730
731 DeviceNameInfo = RtlIsDosDeviceName_U(lpFileName);
732 if (DeviceNameInfo != 0)
733 {
734 RtlFreeHeap(RtlGetProcessHeap(), 0, NtPathBuffer);
735
736 /* OK, it's really a DOS device */
737 CopyDeviceFindData(Win32FindData, lpFileName, DeviceNameInfo);
738 return FIND_DEVICE_HANDLE;
739 }
740 }
741
742 /* A file pattern was specified, or it was not a DOS device */
743
744 /* If there is a file pattern then determine its length */
745 if (FilePattern.Buffer != NULL)
746 {
747 FilePattern.Length = NtPath.Length -
748 (USHORT)((ULONG_PTR)FilePattern.Buffer - (ULONG_PTR)NtPath.Buffer);
749 }
750 else
751 {
752 FilePattern.Length = 0;
753 }
754 FilePattern.MaximumLength = FilePattern.Length;
755
756 if (RelativePath.RelativeName.Length != 0 &&
757 RelativePath.RelativeName.Buffer != FilePattern.Buffer)
758 {
759 if (FilePattern.Buffer != NULL)
760 {
761 /* This is a relative path to RelativePath.ContainingDirectory, adjust NtPath! */
762 NtPath.Length = NtPath.MaximumLength =
763 (USHORT)((ULONG_PTR)FilePattern.Buffer - (ULONG_PTR)RelativePath.RelativeName.Buffer);
764 NtPath.Buffer = RelativePath.RelativeName.Buffer;
765 }
766 }
767 else
768 {
769 /* This is an absolute path, NtPath receives the full path */
770 RelativePath.ContainingDirectory = NULL;
771 if (FilePattern.Buffer != NULL)
772 {
773 NtPath.Length = NtPath.MaximumLength =
774 (USHORT)((ULONG_PTR)FilePattern.Buffer - (ULONG_PTR)NtPath.Buffer);
775 }
776 }
777
778 DPRINT("NtPath - After = '%wZ'\n", &NtPath);
779 DPRINT("FilePattern = '%wZ'\n", &FilePattern);
780 DPRINT("RelativeTo = 0x%p\n", RelativePath.ContainingDirectory);
781
782 InitializeObjectAttributes(&ObjectAttributes,
783 &NtPath,
784 (dwAdditionalFlags & FIND_FIRST_EX_CASE_SENSITIVE) ? 0 : OBJ_CASE_INSENSITIVE,
785 RelativePath.ContainingDirectory,
786 NULL);
787
788 Status = NtOpenFile(&hDirectory,
789 FILE_LIST_DIRECTORY | SYNCHRONIZE,
790 &ObjectAttributes,
791 &IoStatusBlock,
792 FILE_SHARE_READ | FILE_SHARE_WRITE,
793 FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT);
794
795 if (!NT_SUCCESS(Status))
796 {
797 RtlFreeHeap(RtlGetProcessHeap(), 0, NtPathBuffer);
798
799 /* Adjust the last error codes */
800 if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
801 Status = STATUS_OBJECT_PATH_NOT_FOUND;
802 else if (Status == STATUS_OBJECT_TYPE_MISMATCH)
803 Status = STATUS_OBJECT_PATH_NOT_FOUND;
804
805 BaseSetLastNTError(Status);
806 return INVALID_HANDLE_VALUE;
807 }
808
809 /*
810 * Fail if there is not any file pattern,
811 * since we are not looking for a device.
812 */
813 if (FilePattern.Length == 0)
814 {
815 NtClose(hDirectory);
816 RtlFreeHeap(RtlGetProcessHeap(), 0, NtPathBuffer);
817
818 SetLastError(ERROR_FILE_NOT_FOUND);
819 return INVALID_HANDLE_VALUE;
820 }
821
822 /* Change pattern: "*.*" --> "*" */
823 if (FilePattern.Length == 6 &&
824 RtlCompareMemory(FilePattern.Buffer, L"*.*", 6) == 6)
825 {
826 FilePattern.Length = 2;
827 }
828 else
829 {
830 /* Translate wildcard from "real" world to DOS world for lower interpretation */
831 USHORT PatternIndex = 0;
832 while (PatternIndex < FilePattern.Length / sizeof(WCHAR))
833 {
834 if (PatternIndex > 0)
835 {
836 if (FilePattern.Buffer[PatternIndex] == L'.' &&
837 FilePattern.Buffer[PatternIndex - 1] == L'*')
838 {
839 FilePattern.Buffer[PatternIndex - 1] = L'<';
840 }
841 }
842
843 if (FilePattern.Buffer[PatternIndex] == L'?')
844 {
845 FilePattern.Buffer[PatternIndex] = L'>';
846 if (PatternIndex > 0)
847 {
848 if (FilePattern.Buffer[PatternIndex - 1] == L'.')
849 {
850 FilePattern.Buffer[PatternIndex - 1] = L'\"';
851 }
852 }
853 }
854 else if (FilePattern.Buffer[PatternIndex] == L'*')
855 {
856 if (PatternIndex > 0)
857 {
858 if (FilePattern.Buffer[PatternIndex - 1] == L'.')
859 {
860 FilePattern.Buffer[PatternIndex - 1] = L'\"';
861 }
862 }
863 }
864
865 PatternIndex++;
866 }
867
868 /* Handle partial wc if our last dot was eaten */
869 if (HadADot)
870 {
871 if (FilePattern.Buffer[FilePattern.Length / sizeof(WCHAR) - 1] == L'*')
872 {
873 FilePattern.Buffer[FilePattern.Length / sizeof(WCHAR) - 1] = L'<';
874 }
875 }
876 }
877
878 Status = NtQueryDirectoryFile(hDirectory,
879 NULL, NULL, NULL,
880 &IoStatusBlock,
881 DirInfo.DirInfo, // == &DirectoryInfo
882 sizeof(DirectoryInfo),
883 (fInfoLevelId == FindExInfoStandard
884 ? FileBothDirectoryInformation
885 : FileFullDirectoryInformation),
886 TRUE, /* Return a single entry */
887 &FilePattern,
888 TRUE);
889
890 RtlFreeHeap(RtlGetProcessHeap(), 0, NtPathBuffer);
891
892 if (!NT_SUCCESS(Status))
893 {
894 NtClose(hDirectory);
895 BaseSetLastNTError(Status);
896 return INVALID_HANDLE_VALUE;
897 }
898
899 ASSERT(DirInfo.FullDirInfo->NextEntryOffset == 0);
900
901 /* Return the information */
902 CopyFindData(Win32FindData, fInfoLevelId, DirInfo);
903
904 /*
905 * Initialization of the search handle.
906 */
907 FindDataHandle = RtlAllocateHeap(RtlGetProcessHeap(),
908 HEAP_ZERO_MEMORY,
909 sizeof(FIND_DATA_HANDLE) +
910 sizeof(FIND_FILE_DATA));
911 if (!FindDataHandle)
912 {
913 NtClose(hDirectory);
914 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
915 return INVALID_HANDLE_VALUE;
916 }
917
918 FindDataHandle->Type = FindFile;
919 FindDataHandle->u.FindFileData = (PFIND_FILE_DATA)(FindDataHandle + 1);
920 FindFileData = FindDataHandle->u.FindFileData;
921
922 FindFileData->Handle = hDirectory;
923 FindFileData->InfoLevel = fInfoLevelId;
924 FindFileData->SearchOp = fSearchOp;
925 FindFileData->HasMoreData = FALSE;
926 FindFileData->NextDirInfo.DirInfo = NULL;
927
928 /* The critical section must always be initialized */
929 Status = RtlInitializeCriticalSection(&FindDataHandle->Lock);
930 if (!NT_SUCCESS(Status))
931 {
932 NtClose(hDirectory);
933 RtlFreeHeap(RtlGetProcessHeap(), 0, FindDataHandle);
934
935 BaseSetLastNTError(Status);
936 return INVALID_HANDLE_VALUE;
937 }
938
939 return (HANDLE)FindDataHandle;
940 }
941 else
942 {
943 SetLastError(ERROR_NOT_SUPPORTED);
944 return INVALID_HANDLE_VALUE;
945 }
946 }
947
948
949 /*
950 * @implemented
951 */
952 HANDLE
953 WINAPI
954 FindFirstStreamW(IN LPCWSTR lpFileName,
955 IN STREAM_INFO_LEVELS InfoLevel,
956 OUT LPVOID lpFindStreamData,
957 IN DWORD dwFlags)
958 {
959 PFIND_DATA_HANDLE FindDataHandle = NULL;
960 PFIND_STREAM_DATA FindStreamData;
961 OBJECT_ATTRIBUTES ObjectAttributes;
962 IO_STATUS_BLOCK IoStatusBlock;
963 UNICODE_STRING NtFilePath;
964 HANDLE FileHandle = NULL;
965 NTSTATUS Status;
966 ULONG BufferSize = 0;
967
968 if (dwFlags != 0 || InfoLevel != FindStreamInfoStandard ||
969 lpFindStreamData == NULL)
970 {
971 SetLastError(ERROR_INVALID_PARAMETER);
972 return INVALID_HANDLE_VALUE;
973 }
974
975 /* Validate and translate the filename */
976 if (!RtlDosPathNameToNtPathName_U(lpFileName,
977 &NtFilePath,
978 NULL, NULL))
979 {
980 SetLastError(ERROR_PATH_NOT_FOUND);
981 return INVALID_HANDLE_VALUE;
982 }
983
984 /* Open the file */
985 InitializeObjectAttributes(&ObjectAttributes,
986 &NtFilePath,
987 OBJ_CASE_INSENSITIVE,
988 NULL,
989 NULL);
990
991 Status = NtCreateFile(&FileHandle,
992 0,
993 &ObjectAttributes,
994 &IoStatusBlock,
995 NULL, 0,
996 FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE,
997 FILE_OPEN,
998 0, NULL, 0);
999 if (!NT_SUCCESS(Status)) goto Cleanup;
1000
1001 /*
1002 * Initialization of the search handle.
1003 */
1004 FindDataHandle = RtlAllocateHeap(RtlGetProcessHeap(),
1005 HEAP_ZERO_MEMORY,
1006 sizeof(FIND_DATA_HANDLE) +
1007 sizeof(FIND_STREAM_DATA));
1008 if (!FindDataHandle)
1009 {
1010 Status = STATUS_NO_MEMORY;
1011 goto Cleanup;
1012 }
1013
1014 FindDataHandle->Type = FindStream;
1015 FindDataHandle->u.FindStreamData = (PFIND_STREAM_DATA)(FindDataHandle + 1);
1016 FindStreamData = FindDataHandle->u.FindStreamData;
1017
1018 FindStreamData->InfoLevel = InfoLevel;
1019 FindStreamData->FileStreamInfo = NULL;
1020 FindStreamData->CurrentInfo = NULL;
1021
1022 /* The critical section must always be initialized */
1023 Status = RtlInitializeCriticalSection(&FindDataHandle->Lock);
1024 if (!NT_SUCCESS(Status))
1025 {
1026 RtlFreeHeap(RtlGetProcessHeap(), 0, FindDataHandle);
1027 goto Cleanup;
1028 }
1029
1030 /* Capture all information about the streams */
1031 do
1032 {
1033 BufferSize += 0x1000;
1034
1035 if (FindStreamData->FileStreamInfo == NULL)
1036 {
1037 FindStreamData->FileStreamInfo = RtlAllocateHeap(RtlGetProcessHeap(),
1038 HEAP_ZERO_MEMORY,
1039 BufferSize);
1040 if (FindStreamData->FileStreamInfo == NULL)
1041 {
1042 Status = STATUS_NO_MEMORY;
1043 break;
1044 }
1045 }
1046 else
1047 {
1048 PFILE_STREAM_INFORMATION pfsi;
1049
1050 pfsi = RtlReAllocateHeap(RtlGetProcessHeap(),
1051 0, // HEAP_ZERO_MEMORY,
1052 FindStreamData->FileStreamInfo,
1053 BufferSize);
1054 if (pfsi == NULL)
1055 {
1056 Status = STATUS_NO_MEMORY;
1057 break;
1058 }
1059
1060 FindStreamData->FileStreamInfo = pfsi;
1061 }
1062
1063 Status = NtQueryInformationFile(FileHandle,
1064 &IoStatusBlock,
1065 FindStreamData->FileStreamInfo,
1066 BufferSize,
1067 FileStreamInformation);
1068
1069 } while (Status == STATUS_BUFFER_TOO_SMALL);
1070
1071 if (NT_SUCCESS(Status))
1072 {
1073 /* Select the first stream and return the information */
1074 FindStreamData->CurrentInfo = FindStreamData->FileStreamInfo;
1075 CopyStreamData(FindStreamData, lpFindStreamData);
1076
1077 /* All done */
1078 Status = STATUS_SUCCESS;
1079 }
1080 else
1081 {
1082 if (FindStreamData->FileStreamInfo)
1083 {
1084 RtlFreeHeap(RtlGetProcessHeap(), 0, FindStreamData->FileStreamInfo);
1085 }
1086
1087 RtlFreeHeap(RtlGetProcessHeap(), 0, FindDataHandle);
1088 }
1089
1090 Cleanup:
1091 if (FileHandle) NtClose(FileHandle);
1092
1093 RtlFreeHeap(RtlGetProcessHeap(), 0, NtFilePath.Buffer);
1094
1095 if (NT_SUCCESS(Status))
1096 {
1097 return (HANDLE)FindDataHandle;
1098 }
1099 else
1100 {
1101 BaseSetLastNTError(Status);
1102 return INVALID_HANDLE_VALUE;
1103 }
1104 }
1105
1106
1107 /*
1108 * @implemented
1109 */
1110 BOOL
1111 WINAPI
1112 FindNextStreamW(IN HANDLE hFindStream,
1113 OUT LPVOID lpFindStreamData)
1114 {
1115 PFIND_DATA_HANDLE FindDataHandle = (PFIND_DATA_HANDLE)hFindStream;
1116 PFIND_STREAM_DATA FindStreamData;
1117
1118 if (hFindStream == NULL || hFindStream == INVALID_HANDLE_VALUE ||
1119 FindDataHandle->Type != FindStream)
1120 {
1121 SetLastError(ERROR_INVALID_HANDLE);
1122 return FALSE;
1123 }
1124
1125 RtlEnterCriticalSection(&FindDataHandle->Lock);
1126
1127 FindStreamData = FindDataHandle->u.FindStreamData;
1128
1129 /* Select next stream if possible */
1130 if (FindStreamData->CurrentInfo->NextEntryOffset != 0)
1131 {
1132 FindStreamData->CurrentInfo = (PFILE_STREAM_INFORMATION)((ULONG_PTR)FindStreamData->FileStreamInfo +
1133 FindStreamData->CurrentInfo->NextEntryOffset);
1134
1135 /* Return the information */
1136 CopyStreamData(FindStreamData, lpFindStreamData);
1137
1138 RtlLeaveCriticalSection(&FindDataHandle->Lock);
1139 return TRUE;
1140 }
1141 else
1142 {
1143 RtlLeaveCriticalSection(&FindDataHandle->Lock);
1144
1145 SetLastError(ERROR_HANDLE_EOF);
1146 return FALSE;
1147 }
1148 }
1149
1150 /* EOF */