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