ReactOS 0.4.15-dev-5672-gf73ac17
find.c File Reference
#include <k32.h>
#include <ntstrsafe.h>
#include <debug.h>
Include dependency graph for find.c:

Go to the source code of this file.

Classes

union  _DIR_INFORMATION
 
struct  _FIND_FILE_DATA
 
struct  _FIND_STREAM_DATA
 
struct  _FIND_DATA_HANDLE
 

Macros

#define NDEBUG
 
#define FIND_DATA_SIZE   0x4000
 
#define FIND_DEVICE_HANDLE   ((HANDLE)0x1)
 
#define ULARGE_INTEGER_2_FILETIME(ft, ul)
 

Typedefs

typedef enum _FIND_DATA_TYPE FIND_DATA_TYPE
 
typedef union _DIR_INFORMATION DIR_INFORMATION
 
typedef struct _FIND_FILE_DATA FIND_FILE_DATA
 
typedef struct _FIND_FILE_DATAPFIND_FILE_DATA
 
typedef struct _FIND_STREAM_DATA FIND_STREAM_DATA
 
typedef struct _FIND_STREAM_DATAPFIND_STREAM_DATA
 
typedef struct _FIND_DATA_HANDLE FIND_DATA_HANDLE
 
typedef struct _FIND_DATA_HANDLEPFIND_DATA_HANDLE
 

Enumerations

enum  _FIND_DATA_TYPE { FindFile = 1 , FindStream = 2 }
 

Functions

 DEBUG_CHANNEL (kernel32file)
 
static VOID CopyDeviceFindData (OUT LPWIN32_FIND_DATAW lpFindFileData, IN LPCWSTR lpFileName, IN ULONG DeviceNameInfo)
 
static VOID CopyFindData (OUT LPWIN32_FIND_DATAW lpFindFileData, IN FINDEX_INFO_LEVELS fInfoLevelId, IN DIR_INFORMATION DirInfo)
 
static VOID CopyStreamData (IN OUT PFIND_STREAM_DATA FindStreamData, OUT PWIN32_FIND_STREAM_DATA lpFindStreamData)
 
HANDLE WINAPI FindFirstFileA (IN LPCSTR lpFileName, OUT LPWIN32_FIND_DATAA lpFindFileData)
 
HANDLE WINAPI FindFirstFileW (IN LPCWSTR lpFileName, OUT LPWIN32_FIND_DATAW lpFindFileData)
 
BOOL WINAPI FindNextFileA (IN HANDLE hFindFile, OUT LPWIN32_FIND_DATAA lpFindFileData)
 
BOOL WINAPI FindNextFileW (IN HANDLE hFindFile, OUT LPWIN32_FIND_DATAW lpFindFileData)
 
BOOL WINAPI FindClose (HANDLE hFindFile)
 
HANDLE WINAPI FindFirstFileExA (IN LPCSTR lpFileName, IN FINDEX_INFO_LEVELS fInfoLevelId, OUT LPVOID lpFindFileData, IN FINDEX_SEARCH_OPS fSearchOp, LPVOID lpSearchFilter, IN DWORD dwAdditionalFlags)
 
HANDLE WINAPI FindFirstFileExW (IN LPCWSTR lpFileName, IN FINDEX_INFO_LEVELS fInfoLevelId, OUT LPVOID lpFindFileData, IN FINDEX_SEARCH_OPS fSearchOp, LPVOID lpSearchFilter, IN DWORD dwAdditionalFlags)
 
HANDLE WINAPI FindFirstStreamW (IN LPCWSTR lpFileName, IN STREAM_INFO_LEVELS InfoLevel, OUT LPVOID lpFindStreamData, IN DWORD dwFlags)
 
BOOL WINAPI FindNextStreamW (IN HANDLE hFindStream, OUT LPVOID lpFindStreamData)
 

Macro Definition Documentation

◆ FIND_DATA_SIZE

#define FIND_DATA_SIZE   0x4000

Definition at line 23 of file find.c.

◆ FIND_DEVICE_HANDLE

#define FIND_DEVICE_HANDLE   ((HANDLE)0x1)

Definition at line 24 of file find.c.

◆ NDEBUG

#define NDEBUG

Definition at line 16 of file find.c.

◆ ULARGE_INTEGER_2_FILETIME

#define ULARGE_INTEGER_2_FILETIME (   ft,
  ul 
)
Value:
do { \
(ft).dwHighDateTime = (ul).u.HighPart; \
(ft).dwLowDateTime = (ul).u.LowPart ; \
} while(0)

Typedef Documentation

◆ DIR_INFORMATION

◆ FIND_DATA_HANDLE

◆ FIND_DATA_TYPE

◆ FIND_FILE_DATA

◆ FIND_STREAM_DATA

◆ PFIND_DATA_HANDLE

◆ PFIND_FILE_DATA

◆ PFIND_STREAM_DATA

Enumeration Type Documentation

◆ _FIND_DATA_TYPE

Enumerator
FindFile 
FindStream 

Definition at line 26 of file find.c.

27{
28 FindFile = 1,
29 FindStream = 2
@ FindStream
Definition: find.c:29
@ FindFile
Definition: find.c:28
enum _FIND_DATA_TYPE FIND_DATA_TYPE

Function Documentation

◆ CopyDeviceFindData()

static VOID CopyDeviceFindData ( OUT LPWIN32_FIND_DATAW  lpFindFileData,
IN LPCWSTR  lpFileName,
IN ULONG  DeviceNameInfo 
)
static

Definition at line 117 of file find.c.

120{
123
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),
136 }
138 {
139 }
140 _SEH2_END;
141
142 return;
143}
#define _SEH2_END
Definition: filesup.c:22
#define _SEH2_TRY
Definition: filesup.c:19
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
#define FILE_ATTRIBUTE_ARCHIVE
Definition: nt_native.h:706
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:102
NTSTRSAFEAPI RtlStringCbCopyNW(_Out_writes_bytes_(cbDest) NTSTRSAFE_PWSTR pszDest, _In_ size_t cbDest, _In_reads_bytes_(cbToCopy) STRSAFE_LPCWSTR pszSrc, _In_ size_t cbToCopy)
Definition: ntstrsafe.h:416
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:34
ULONG_PTR SIZE_T
Definition: typedefs.h:80
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
uint32_t ULONG_PTR
Definition: typedefs.h:65
_Must_inspect_result_ _In_ PWDFDEVICE_INIT _In_opt_ PCUNICODE_STRING DeviceName
Definition: wdfdevice.h:3275
_In_ LPCSTR lpFileName
Definition: winbase.h:3058
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185

Referenced by FindFirstFileExW().

◆ CopyFindData()

static VOID CopyFindData ( OUT LPWIN32_FIND_DATAW  lpFindFileData,
IN FINDEX_INFO_LEVELS  fInfoLevelId,
IN DIR_INFORMATION  DirInfo 
)
static

Definition at line 146 of file find.c.

149{
150#define ULARGE_INTEGER_2_FILETIME(ft, ul) \
151do { \
152 (ft).dwHighDateTime = (ul).u.HighPart; \
153 (ft).dwLowDateTime = (ul).u.LowPart ; \
154} while(0)
155
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 }
206 {
207 }
208 _SEH2_END;
209
210 return;
211}
#define FALSE
Definition: types.h:117
#define ULARGE_INTEGER_2_FILETIME(ft, ul)
#define ASSERT(a)
Definition: mode.c:44
#define UNICODE_NULL
#define FILE_ATTRIBUTE_REPARSE_POINT
Definition: ntifs_ex.h:381
@ FindExInfoStandard
Definition: winbase.h:1116
@ FindExInfoBasic
Definition: winbase.h:1117

Referenced by FindFirstFileExW(), and FindNextFileW().

◆ CopyStreamData()

static VOID CopyStreamData ( IN OUT PFIND_STREAM_DATA  FindStreamData,
OUT PWIN32_FIND_STREAM_DATA  lpFindStreamData 
)
static

Definition at line 214 of file find.c.

216{
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 }
248 {
249 }
250 _SEH2_END;
251
252 return;
253}
#define min(a, b)
Definition: monoChain.cc:55
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
uint32_t ULONG
Definition: typedefs.h:59
__wchar_t WCHAR
Definition: xmlstorage.h:180

Referenced by FindFirstStreamW(), and FindNextStreamW().

◆ DEBUG_CHANNEL()

DEBUG_CHANNEL ( kernel32file  )

◆ FindClose()

BOOL WINAPI FindClose ( HANDLE  hFindFile)

Definition at line 502 of file find.c.

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 {
512 return FALSE;
513 }
514
515 /* Protect with SEH against closing attempts on invalid handles. */
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 {
547 _SEH2_YIELD(return FALSE);
548 }
549 }
550
551 RtlFreeHeap(RtlGetProcessHeap(), 0, FindDataHandle);
552 }
554 {
556 _SEH2_YIELD(return FALSE);
557 }
558 _SEH2_END;
559
560 return TRUE;
561}
BOOLEAN NTAPI RtlFreeHeap(IN PVOID HeapHandle, IN ULONG Flags, IN PVOID HeapBase)
Definition: heap.c:606
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define SetLastError(x)
Definition: compat.h:752
#define INVALID_HANDLE_VALUE
Definition: compat.h:731
#define ERROR_INVALID_HANDLE
Definition: compat.h:98
struct _FIND_DATA_HANDLE * PFIND_DATA_HANDLE
#define FIND_DEVICE_HANDLE
Definition: find.c:24
NTSYSAPI NTSTATUS NTAPI RtlDeleteCriticalSection(_In_ PRTL_CRITICAL_SECTION CriticalSection)
NTSYSAPI NTSTATUS NTAPI RtlEnterCriticalSection(_In_ PRTL_CRITICAL_SECTION CriticalSection)
NTSYSAPI NTSTATUS NTAPI RtlLeaveCriticalSection(_In_ PRTL_CRITICAL_SECTION CriticalSection)
NTSTATUS NTAPI NtClose(IN HANDLE Handle)
Definition: obhandle.c:3402
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:159
#define _SEH2_YIELD(__stmt)
Definition: pseh2_64.h:162
DWORD BaseSetLastNTError(IN NTSTATUS Status)
Definition: reactos.cpp:166
#define TRACE(s)
Definition: solgame.cpp:4
union _FIND_DATA_HANDLE::@448 u
PFIND_FILE_DATA FindFileData
Definition: find.c:107
FIND_DATA_TYPE Type
Definition: find.c:98
RTL_CRITICAL_SECTION Lock
Definition: find.c:99
PFIND_STREAM_DATA FindStreamData
Definition: find.c:108
HANDLE Handle
Definition: find.c:70
PFILE_STREAM_INFORMATION FileStreamInfo
Definition: find.c:92

Referenced by _FileOpCount(), _findclose(), _ILCreateFromPathW(), _RunRemoteTest(), add_favs_to_menu(), AddDesktopItemW(), AddItemW(), CDirectoryList::AddPathsFromDirectory(), AddUserProfile(), AddWallpapersFromDirectory(), aexpand(), apply_patch(), AutoStartupApplications(), ChangeACLsOfFiles(), ChangeACLsOfFilesInCurDir(), ChangeAttribute(), cmd_copy(), cmd_move(), cmd_rename(), cmd_type(), compat_dirclose(), CompleteFilename(), Control_DoWindow(), ConvertPathCase(), copy_file(), copy_folder(), CopyDirectory(), CFileDefExt::CountFolderAndFiles(), CControlPanelEnum::CreateCPanelEnumList(), CCabinet::CreateSimpleCabinet(), CryptCATAdminEnumCatalogFromHash(), CryptCATAdminReleaseContext(), delete_file(), delete_folder(), DeleteFiles(), DeleteFolder(), DeleteWithWildcard(), DELNODE_recurse_dirtree(), demFileFindFirst(), demFileFindNext(), DirList(), do_searchW(), DoAddFilesFromItem(), DoDeleteSpecW(), DoLoadImageFile(), DoSpecExistsW(), CAvailableApps::Enum(), enum_gac_assemblies(), enum_gac_assembly_dirs(), EnumColorProfilesA(), EnumColorProfilesW(), EnumDirs(), EnumFilesInDirectory(), EnumThemes(), ExecuteIf(), exists_path(), expand(), expect_files(), file_get_Size(), filecoll_enumvariant_Release(), filecoll_enumvariant_Reset(), filecoll_get_Count(), FileCompareOneSideWild(), FileCompareWildTitle(), FILEDLG95_InitControls(), FileExists(), FileQueryFiles(), filesys_GetAbsolutePathName(), fill_datafile(), fill_directory(), FindFirstFileA(), FindFirstFileExA(), foldercoll_enumvariant_Release(), foldercoll_enumvariant_Reset(), foldercoll_get_Count(), ForDir(), ForRecursive(), fsbd_GetFindData_valid(), get_long_path_name(), get_number_of_folders(), GetDirectoryStructure(), GetEnhancedVar(), GetLongPathNameW(), GetPathCase(), GetProfileSize(), GetShortPathNameW(), gl_local_filename_completion_proc(), HasSubFolder(), have_profile(), CFileDefExt::InitFileAttr(), CFileSysEnum::Initialize(), InitializeGlobalJobList(), InitPropertiesDlg(), IntDeleteRecursive(), LISTBOX_Directory(), LoadSoundFiles(), main(), move_files_wildcard(), msi_dialog_update_directory_list(), MyFileExists(), OnClearRecentItems(), OnSelChange(), OpenUserEventLogFile(), fff_handle::operator=(), parse_wildcard_files(), PathIsDirectoryEmptyW(), pBuildFileList(), PrintAttribute(), PrintDaclsOfFiles(), ProcessDirectory(), ShellDirectory::read_directory(), WinDirectory::read_directory(), CFontInfo::ReadAttrs(), recFindSubDirs(), recReplace(), recurse_search_directory(), RecursiveCreateDirectory(), RecursiveFind(), RecursiveRemoveDir(), remove_dir(), SaveDIBToFile(), DriveVolume::ScanDirectory(), ScanForInfFile(), SdbpBuildSignMediaId(), SearchDriverRecursive(), SearchScreenSavers(), SetupCopyOEMInfW(), SetupGetInfFileListW(), SHAddToRecentDocs(), SHELL_DeleteDirectoryW(), SHFindAttrW(), SHNotifyDeleteFileW(), start_enumeration(), START_TEST(), test__lcreat(), test_DefineDosDeviceA(), test_filemodeT(), test_FindFirstFile_wildcards(), test_FindFirstFileA(), test_FindFirstFileExA(), test_FindNextFileA(), test_GetAbsolutePathName(), test_MoveFileA(), test_request_groups(), Test_ShortTests(), testKeyboardLayouts(), CAvailableApps::UpdateAppsDB(), wexpand(), WhereSearchGeneric(), wmain(), XCOPY_DoCopy(), CWineTest::~CWineTest(), and fff_handle::~fff_handle().

◆ FindFirstFileA()

HANDLE WINAPI FindFirstFileA ( IN LPCSTR  lpFileName,
OUT LPWIN32_FIND_DATAA  lpFindFileData 
)

Definition at line 263 of file find.c.

265{
266 HANDLE hSearch;
268 ANSI_STRING Ansi;
269 UNICODE_STRING UTF8;
270 PUNICODE_STRING lpFileNameW;
271 WIN32_FIND_DATAW FindFileDataW;
272
274 if (!lpFileNameW) return INVALID_HANDLE_VALUE;
275
276 hSearch = FindFirstFileExW(lpFileNameW->Buffer,
278 &FindFileDataW,
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);
292 if (!NT_SUCCESS(Status))
293 {
294 FindClose(hSearch);
297 }
298
299 RtlInitUnicodeString(&UTF8, FindFileDataW.cAlternateFileName);
300 Ansi.Buffer = lpFindFileData->cAlternateFileName;
301 Ansi.Length = 0;
302 Ansi.MaximumLength = sizeof(lpFindFileData->cAlternateFileName);
304 if (!NT_SUCCESS(Status))
305 {
306 FindClose(hSearch);
309 }
310
311 return hSearch;
312}
LONG NTSTATUS
Definition: precomp.h:26
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
BOOL WINAPI FindClose(HANDLE hFindFile)
Definition: find.c:502
HANDLE WINAPI FindFirstFileExW(IN LPCWSTR lpFileName, IN FINDEX_INFO_LEVELS fInfoLevelId, OUT LPVOID lpFindFileData, IN FINDEX_SEARCH_OPS fSearchOp, LPVOID lpSearchFilter, IN DWORD dwAdditionalFlags)
Definition: find.c:649
PRTL_CONVERT_STRINGA BasepUnicodeStringTo8BitString
Definition: utils.c:27
PUNICODE_STRING WINAPI Basep8BitStringToStaticUnicodeString(IN LPCSTR String)
Definition: utils.c:188
Status
Definition: gdiplustypes.h:25
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
USHORT MaximumLength
Definition: env_spec_w32.h:377
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:255
@ FindExSearchNameMatch
Definition: winbase.h:1122

Referenced by aexpand(), apply_patch(), demFileFindFirst(), enum_gac_assemblies(), enum_gac_assembly_dirs(), EnumColorProfilesA(), expect_files(), get_long_path_name(), get_number_of_folders(), have_profile(), test__lcreat(), test_DefineDosDeviceA(), test_filemodeT(), test_FindFirstFile_wildcards(), test_FindFirstFileA(), test_FindNextFileA(), test_MoveFileA(), and test_request_groups().

◆ FindFirstFileExA()

HANDLE WINAPI FindFirstFileExA ( IN LPCSTR  lpFileName,
IN FINDEX_INFO_LEVELS  fInfoLevelId,
OUT LPVOID  lpFindFileData,
IN FINDEX_SEARCH_OPS  fSearchOp,
LPVOID  lpSearchFilter,
IN DWORD  dwAdditionalFlags 
)

Definition at line 569 of file find.c.

575{
576 HANDLE hSearch;
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 {
592 }
593
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);
614 if (!NT_SUCCESS(Status))
615 {
616 FindClose(hSearch);
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);
628 if (!NT_SUCCESS(Status))
629 {
630 FindClose(hSearch);
633 }
634 }
635 else
636 {
637 lpFindFileDataA->cAlternateFileName[0] = ANSI_NULL;
638 }
639
640 return hSearch;
641}
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
#define ERROR_NOT_SUPPORTED
Definition: compat.h:100
#define ANSI_NULL
CHAR cFileName[MAX_PATH]
Definition: winbase.h:935
CHAR cAlternateFileName[14]
Definition: winbase.h:936
struct _WIN32_FIND_DATAA * LPWIN32_FIND_DATAA
@ FindExSearchLimitToDevices
Definition: winbase.h:1124

◆ FindFirstFileExW()

HANDLE WINAPI FindFirstFileExW ( IN LPCWSTR  lpFileName,
IN FINDEX_INFO_LEVELS  fInfoLevelId,
OUT LPVOID  lpFindFileData,
IN FINDEX_SEARCH_OPS  fSearchOp,
LPVOID  lpSearchFilter,
IN DWORD  dwAdditionalFlags 
)

Definition at line 649 of file find.c.

655{
656 TRACE("FindFirstFileExW(lpFileName %S)\n", lpFileName);
657
658 if ((fInfoLevelId != FindExInfoStandard && fInfoLevelId != FindExInfoBasic) ||
659 fSearchOp == FindExSearchLimitToDevices ||
660 dwAdditionalFlags & ~FIND_FIRST_EX_CASE_SENSITIVE /* only supported flag for now */)
661 {
666 }
667
668 if (fSearchOp == FindExSearchNameMatch ||
670 {
671 LPWIN32_FIND_DATAW Win32FindData = (LPWIN32_FIND_DATAW)lpFindFileData;
672 PFIND_DATA_HANDLE FindDataHandle;
673 PFIND_FILE_DATA FindFileData;
674
675 UNICODE_STRING NtPath, FilePattern, FileName;
676 PWSTR NtPathBuffer;
677 RTL_RELATIVE_NAME_U RelativePath;
678 ULONG DeviceNameInfo = 0;
679
683 HANDLE hDirectory = NULL;
684
685 BOOLEAN HadADot = FALSE;
686
687 /*
688 * May represent many FILE_BOTH_DIR_INFORMATION
689 * or many FILE_FULL_DIR_INFORMATION structures.
690 * NOTE: NtQueryDirectoryFile requires the buffer to be ULONG-aligned
691 */
692 DECLSPEC_ALIGN(4) BYTE DirectoryInfo[FIND_DATA_SIZE];
693 DIR_INFORMATION DirInfo = { .DirInfo = &DirectoryInfo };
694
695 /* The search filter is always unused */
696 if (lpSearchFilter)
697 {
700 }
701
703 if (FileName.Length != 0 && FileName.Buffer[FileName.Length / sizeof(WCHAR) - 1] == L'.')
704 {
705 HadADot = TRUE;
706 }
707
709 &NtPath,
710 (PCWSTR*)&FilePattern.Buffer,
711 &RelativePath))
712 {
715 }
716
717 DPRINT("lpFileName = '%S'\n", lpFileName);
718 DPRINT("FilePattern.Buffer = '%S'\n", FilePattern.Buffer);
719 DPRINT("RelativePath.RelativeName = '%wZ'\n", &RelativePath.RelativeName);
720 DPRINT("NtPath.Buffer = '%S'\n", NtPath.Buffer);
721 DPRINT("NtPath - Before = '%wZ'\n", &NtPath);
722
723 /* Save the buffer pointer for later, we need to free it! */
724 NtPathBuffer = NtPath.Buffer;
725
726 /*
727 * Contrary to what Windows does, check NOW whether or not
728 * lpFileName is a DOS driver. Therefore we don't have to
729 * write broken code to check that.
730 */
731 if (!FilePattern.Buffer || !*FilePattern.Buffer)
732 {
733 /* No file pattern specified, or DOS device */
734
735 DeviceNameInfo = RtlIsDosDeviceName_U(lpFileName);
736 if (DeviceNameInfo != 0)
737 {
738 RtlFreeHeap(RtlGetProcessHeap(), 0, NtPathBuffer);
739
740 /* OK, it's really a DOS device */
741 CopyDeviceFindData(Win32FindData, lpFileName, DeviceNameInfo);
742 return FIND_DEVICE_HANDLE;
743 }
744 }
745
746 /* A file pattern was specified, or it was not a DOS device */
747
748 /* If there is a file pattern then determine its length */
749 if (FilePattern.Buffer != NULL)
750 {
751 FilePattern.Length = NtPath.Length -
752 (USHORT)((ULONG_PTR)FilePattern.Buffer - (ULONG_PTR)NtPath.Buffer);
753 }
754 else
755 {
756 FilePattern.Length = 0;
757 }
758 FilePattern.MaximumLength = FilePattern.Length;
759
760 if (RelativePath.RelativeName.Length != 0 &&
761 RelativePath.RelativeName.Buffer != FilePattern.Buffer)
762 {
763 if (FilePattern.Buffer != NULL)
764 {
765 /* This is a relative path to RelativePath.ContainingDirectory, adjust NtPath! */
766 NtPath.Length = NtPath.MaximumLength =
767 (USHORT)((ULONG_PTR)FilePattern.Buffer - (ULONG_PTR)RelativePath.RelativeName.Buffer);
768 NtPath.Buffer = RelativePath.RelativeName.Buffer;
769 }
770 }
771 else
772 {
773 /* This is an absolute path, NtPath receives the full path */
774 RelativePath.ContainingDirectory = NULL;
775 if (FilePattern.Buffer != NULL)
776 {
777 NtPath.Length = NtPath.MaximumLength =
778 (USHORT)((ULONG_PTR)FilePattern.Buffer - (ULONG_PTR)NtPath.Buffer);
779 }
780 }
781
782 DPRINT("NtPath - After = '%wZ'\n", &NtPath);
783 DPRINT("FilePattern = '%wZ'\n", &FilePattern);
784 DPRINT("RelativeTo = 0x%p\n", RelativePath.ContainingDirectory);
785
787 &NtPath,
788 (dwAdditionalFlags & FIND_FIRST_EX_CASE_SENSITIVE) ? 0 : OBJ_CASE_INSENSITIVE,
789 RelativePath.ContainingDirectory,
790 NULL);
791
792 Status = NtOpenFile(&hDirectory,
798
799 if (!NT_SUCCESS(Status))
800 {
801 RtlFreeHeap(RtlGetProcessHeap(), 0, NtPathBuffer);
802
803 /* Adjust the last error codes */
808
811 }
812
813 /*
814 * Fail if there is not any file pattern,
815 * since we are not looking for a device.
816 */
817 if (FilePattern.Length == 0)
818 {
819 NtClose(hDirectory);
820 RtlFreeHeap(RtlGetProcessHeap(), 0, NtPathBuffer);
821
824 }
825
826 /* Change pattern: "*.*" --> "*" */
827 if (FilePattern.Length == 6 &&
828 RtlCompareMemory(FilePattern.Buffer, L"*.*", 6) == 6)
829 {
830 FilePattern.Length = 2;
831 }
832 else
833 {
834 /* Translate wildcard from "real" world to DOS world for lower interpretation */
835 USHORT PatternIndex = 0;
836 while (PatternIndex < FilePattern.Length / sizeof(WCHAR))
837 {
838 if (PatternIndex > 0)
839 {
840 if (FilePattern.Buffer[PatternIndex] == L'.' &&
841 FilePattern.Buffer[PatternIndex - 1] == L'*')
842 {
843 FilePattern.Buffer[PatternIndex - 1] = L'<';
844 }
845 }
846
847 if (FilePattern.Buffer[PatternIndex] == L'?')
848 {
849 FilePattern.Buffer[PatternIndex] = L'>';
850 if (PatternIndex > 0)
851 {
852 if (FilePattern.Buffer[PatternIndex - 1] == L'.')
853 {
854 FilePattern.Buffer[PatternIndex - 1] = L'\"';
855 }
856 }
857 }
858 else if (FilePattern.Buffer[PatternIndex] == L'*')
859 {
860 if (PatternIndex > 0)
861 {
862 if (FilePattern.Buffer[PatternIndex - 1] == L'.')
863 {
864 FilePattern.Buffer[PatternIndex - 1] = L'\"';
865 }
866 }
867 }
868
869 PatternIndex++;
870 }
871
872 /* Handle partial wc if our last dot was eaten */
873 if (HadADot)
874 {
875 if (FilePattern.Buffer[FilePattern.Length / sizeof(WCHAR) - 1] == L'*')
876 {
877 FilePattern.Buffer[FilePattern.Length / sizeof(WCHAR) - 1] = L'<';
878 }
879 }
880 }
881
882 Status = NtQueryDirectoryFile(hDirectory,
883 NULL, NULL, NULL,
885 DirInfo.DirInfo, // == &DirectoryInfo
886 sizeof(DirectoryInfo),
887 (fInfoLevelId == FindExInfoStandard
890 TRUE, /* Return a single entry */
891 &FilePattern,
892 TRUE);
893
894 RtlFreeHeap(RtlGetProcessHeap(), 0, NtPathBuffer);
895
896 if (!NT_SUCCESS(Status))
897 {
898 NtClose(hDirectory);
901 }
902
903 ASSERT(DirInfo.FullDirInfo->NextEntryOffset == 0);
904
905 /* Return the information */
906 CopyFindData(Win32FindData, fInfoLevelId, DirInfo);
907
908 /*
909 * Initialization of the search handle.
910 */
911 FindDataHandle = RtlAllocateHeap(RtlGetProcessHeap(),
913 sizeof(FIND_DATA_HANDLE) +
914 sizeof(FIND_FILE_DATA));
915 if (!FindDataHandle)
916 {
917 NtClose(hDirectory);
920 }
921
922 FindDataHandle->Type = FindFile;
923 FindDataHandle->u.FindFileData = (PFIND_FILE_DATA)(FindDataHandle + 1);
924 FindFileData = FindDataHandle->u.FindFileData;
925
926 FindFileData->Handle = hDirectory;
927 FindFileData->InfoLevel = fInfoLevelId;
928 FindFileData->SearchOp = fSearchOp;
929 FindFileData->HasMoreData = FALSE;
930 FindFileData->NextDirInfo.DirInfo = NULL;
931
932 /* The critical section must always be initialized */
933 Status = RtlInitializeCriticalSection(&FindDataHandle->Lock);
934 if (!NT_SUCCESS(Status))
935 {
936 NtClose(hDirectory);
937 RtlFreeHeap(RtlGetProcessHeap(), 0, FindDataHandle);
938
941 }
942
943 return (HANDLE)FindDataHandle;
944 }
945 else
946 {
949 }
950}
unsigned char BOOLEAN
#define FILE_DIRECTORY_FILE
Definition: constants.h:491
PVOID NTAPI RtlAllocateHeap(IN PVOID HeapHandle, IN ULONG Flags, IN SIZE_T Size)
Definition: heap.c:588
IN PUNICODE_STRING IN POBJECT_ATTRIBUTES ObjectAttributes
Definition: conport.c:36
#define ERROR_NOT_ENOUGH_MEMORY
Definition: dderror.h:7
#define FILE_SHARE_READ
Definition: compat.h:136
#define HEAP_ZERO_MEMORY
Definition: compat.h:134
static VOID CopyDeviceFindData(OUT LPWIN32_FIND_DATAW lpFindFileData, IN LPCWSTR lpFileName, IN ULONG DeviceNameInfo)
Definition: find.c:117
struct _FIND_FILE_DATA * PFIND_FILE_DATA
static VOID CopyFindData(OUT LPWIN32_FIND_DATAW lpFindFileData, IN FINDEX_INFO_LEVELS fInfoLevelId, IN DIR_INFORMATION DirInfo)
Definition: find.c:146
#define FIND_DATA_SIZE
Definition: find.c:23
#define ULONG_PTR
Definition: config.h:101
#define RtlCompareMemory(s1, s2, l)
Definition: env_spec_w32.h:465
struct _FileName FileName
Definition: fatprocs.h:896
@ FileFullDirectoryInformation
Definition: from_kernel.h:63
@ FileBothDirectoryInformation
Definition: from_kernel.h:64
#define FILE_SYNCHRONOUS_IO_NONALERT
Definition: from_kernel.h:31
#define OBJ_CASE_INSENSITIVE
Definition: winternl.h:228
NTSTATUS NTAPI NtQueryDirectoryFile(IN HANDLE FileHandle, IN HANDLE EventHandle OPTIONAL, IN PIO_APC_ROUTINE ApcRoutine OPTIONAL, IN PVOID ApcContext OPTIONAL, OUT PIO_STATUS_BLOCK IoStatusBlock, OUT PVOID FileInformation, IN ULONG Length, IN FILE_INFORMATION_CLASS FileInformationClass, IN BOOLEAN ReturnSingleEntry, IN PUNICODE_STRING FileName OPTIONAL, IN BOOLEAN RestartScan)
Definition: iofunc.c:1994
#define ERROR_FILE_NOT_FOUND
Definition: disk.h:79
static OUT PIO_STATUS_BLOCK IoStatusBlock
Definition: pipe.c:75
#define InitializeObjectAttributes(p, n, a, r, s)
Definition: reg.c:106
NTSYSAPI ULONG NTAPI RtlIsDosDeviceName_U(_In_ PCWSTR Name)
NTSYSAPI NTSTATUS NTAPI RtlInitializeCriticalSection(_In_ PRTL_CRITICAL_SECTION CriticalSection)
NTSYSAPI BOOLEAN NTAPI RtlDosPathNameToNtPathName_U(_In_opt_z_ PCWSTR DosPathName, _Out_ PUNICODE_STRING NtPathName, _Out_opt_ PCWSTR *NtFileNamePart, _Out_opt_ PRTL_RELATIVE_NAME_U DirectoryInfo)
NTSYSAPI NTSTATUS NTAPI NtOpenFile(OUT PHANDLE phFile, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes, OUT PIO_STATUS_BLOCK pIoStatusBlock, IN ULONG ShareMode, IN ULONG OpenMode)
Definition: file.c:3952
#define FILE_SHARE_WRITE
Definition: nt_native.h:681
#define SYNCHRONIZE
Definition: nt_native.h:61
#define FILE_LIST_DIRECTORY
Definition: nt_native.h:629
#define DECLSPEC_ALIGN(x)
Definition: ntbasedef.h:251
#define STATUS_OBJECT_TYPE_MISMATCH
Definition: ntstatus.h:273
#define L(x)
Definition: ntvdm.h:50
unsigned short USHORT
Definition: pedump.c:61
#define DPRINT
Definition: sndvol32.h:71
FINDEX_INFO_LEVELS InfoLevel
Definition: find.c:71
FINDEX_SEARCH_OPS SearchOp
Definition: find.c:72
DIR_INFORMATION NextDirInfo
Definition: find.c:84
BOOLEAN HasMoreData
Definition: find.c:78
UNICODE_STRING RelativeName
Definition: rtltypes.h:1380
HANDLE ContainingDirectory
Definition: rtltypes.h:1381
USHORT MaximumLength
Definition: env_spec_w32.h:370
uint16_t * PWSTR
Definition: typedefs.h:56
const uint16_t * PCWSTR
Definition: typedefs.h:57
#define STATUS_OBJECT_PATH_NOT_FOUND
Definition: udferr_usr.h:151
#define STATUS_OBJECT_NAME_NOT_FOUND
Definition: udferr_usr.h:149
PVOID DirInfo
Definition: find.c:63
@ FindExSearchLimitToDirectories
Definition: winbase.h:1123
#define FIND_FIRST_EX_CASE_SENSITIVE
Definition: winbase.h:234
struct _WIN32_FIND_DATAW * LPWIN32_FIND_DATAW
#define ERROR_PATH_NOT_FOUND
Definition: winerror.h:106
unsigned char BYTE
Definition: xxhash.c:193

Referenced by FindFirstFileA(), FindFirstFileExA(), FindFirstFileW(), and WhereSearchGeneric().

◆ FindFirstFileW()

HANDLE WINAPI FindFirstFileW ( IN LPCWSTR  lpFileName,
OUT LPWIN32_FIND_DATAW  lpFindFileData 
)

Definition at line 320 of file find.c.

322{
325 lpFindFileData,
327 NULL, 0);
328}

Referenced by _FileOpCount(), _ILCreateFromPathW(), _RunRemoteTest(), add_favs_to_menu(), AddDesktopItemW(), AddItemW(), CDirectoryList::AddPathsFromDirectory(), AddUserProfile(), AutoStartupApplications(), ChangeAttribute(), compat_diropen(), Control_DoWindow(), copy_file(), copy_folder(), CopyDirectory(), CFileDefExt::CountFolderAndFiles(), create_snapshot(), CControlPanelEnum::CreateCPanelEnumList(), CryptCATAdminEnumCatalogFromHash(), delete_directory(), delete_file(), delete_folder(), DeleteWithWildcard(), DELNODE_recurse_dirtree(), BtrfsPropSheet::do_search(), do_searchW(), DoAddFilesFromItem(), DoDeleteSpecW(), DoSpecExistsW(), CAvailableApps::Enum(), enum_gac_assemblies(), EnumColorProfilesW(), EnumThemes(), file_get_Size(), filecoll_get_Count(), FileCompareBothWild(), FileCompareOneSideWild(), FileCompareWildTitle(), FILEDLG95_InitControls(), FileExists(), FileQueryFiles(), filesys_GetAbsolutePathName(), fill_datafile(), fill_directory(), foldercoll_get_Count(), fsbd_GetFindData_valid(), GetDirectoryStructure(), GetListOfTestExes(), GetLongPathNameW(), CWineTest::GetNextFile(), GetNumberOfExesInFolder(), GetProfileSize(), GetShortPathNameW(), HasSubFolder(), CFileDefExt::InitFileAttr(), CFileSysEnum::Initialize(), InitializeGlobalJobList(), InitPropertiesDlg(), IntDeleteRecursive(), BtrfsContextMenu::InvokeCommand(), LISTBOX_Directory(), LoadSoundFiles(), msi_dialog_update_directory_list(), msi_find_first_file(), MyFileExists(), OnClearRecentItems(), OpenUserEventLogFile(), parse_wildcard_files(), PathIsDirectoryEmptyW(), pBuildFileList(), PrintAttribute(), CFontInfo::ReadAttrs(), RecursiveFind(), RecursiveRemoveDir(), BtrfsContextMenu::reflink_copy(), reflink_copy2(), ReflinkCopyW(), DriveVolume::ScanDirectory(), ScanForInfFile(), SdbpBuildSignMediaId(), SearchDriverRecursive(), SetupCopyOEMInfW(), SetupGetInfFileListW(), SHAddToRecentDocs(), SHELL_DeleteDirectoryW(), SHFindAttrW(), SHNotifyDeleteFileW(), start_enumeration(), START_TEST(), test_GetAbsolutePathName(), Test_NtGdiAddFontResourceW(), testKeyboardLayouts(), CAvailableApps::UpdateAppsDB(), wexpand(), wmain(), and XCOPY_DoCopy().

◆ FindFirstStreamW()

HANDLE WINAPI FindFirstStreamW ( IN LPCWSTR  lpFileName,
IN STREAM_INFO_LEVELS  InfoLevel,
OUT LPVOID  lpFindStreamData,
IN DWORD  dwFlags 
)

Definition at line 958 of file find.c.

962{
963 PFIND_DATA_HANDLE FindDataHandle = NULL;
964 PFIND_STREAM_DATA FindStreamData;
967 UNICODE_STRING NtFilePath;
970 ULONG BufferSize = 0;
971
972 if (dwFlags != 0 || InfoLevel != FindStreamInfoStandard ||
973 lpFindStreamData == NULL)
974 {
977 }
978
979 /* Validate and translate the filename */
981 &NtFilePath,
982 NULL, NULL))
983 {
986 }
987
988 /* Open the file */
990 &NtFilePath,
992 NULL,
993 NULL);
994
996 0,
999 NULL, 0,
1001 FILE_OPEN,
1002 0, NULL, 0);
1003 if (!NT_SUCCESS(Status)) goto Cleanup;
1004
1005 /*
1006 * Initialization of the search handle.
1007 */
1008 FindDataHandle = RtlAllocateHeap(RtlGetProcessHeap(),
1010 sizeof(FIND_DATA_HANDLE) +
1011 sizeof(FIND_STREAM_DATA));
1012 if (!FindDataHandle)
1013 {
1015 goto Cleanup;
1016 }
1017
1018 FindDataHandle->Type = FindStream;
1019 FindDataHandle->u.FindStreamData = (PFIND_STREAM_DATA)(FindDataHandle + 1);
1020 FindStreamData = FindDataHandle->u.FindStreamData;
1021
1022 FindStreamData->InfoLevel = InfoLevel;
1023 FindStreamData->FileStreamInfo = NULL;
1024 FindStreamData->CurrentInfo = NULL;
1025
1026 /* The critical section must always be initialized */
1027 Status = RtlInitializeCriticalSection(&FindDataHandle->Lock);
1028 if (!NT_SUCCESS(Status))
1029 {
1030 RtlFreeHeap(RtlGetProcessHeap(), 0, FindDataHandle);
1031 goto Cleanup;
1032 }
1033
1034 /* Capture all information about the streams */
1035 do
1036 {
1037 BufferSize += 0x1000;
1038
1039 if (FindStreamData->FileStreamInfo == NULL)
1040 {
1041 FindStreamData->FileStreamInfo = RtlAllocateHeap(RtlGetProcessHeap(),
1043 BufferSize);
1044 if (FindStreamData->FileStreamInfo == NULL)
1045 {
1047 break;
1048 }
1049 }
1050 else
1051 {
1053
1054 pfsi = RtlReAllocateHeap(RtlGetProcessHeap(),
1055 0, // HEAP_ZERO_MEMORY,
1056 FindStreamData->FileStreamInfo,
1057 BufferSize);
1058 if (pfsi == NULL)
1059 {
1061 break;
1062 }
1063
1064 FindStreamData->FileStreamInfo = pfsi;
1065 }
1066
1069 FindStreamData->FileStreamInfo,
1070 BufferSize,
1072
1073 } while (Status == STATUS_BUFFER_TOO_SMALL);
1074
1075 if (NT_SUCCESS(Status))
1076 {
1077 /* Select the first stream and return the information */
1078 FindStreamData->CurrentInfo = FindStreamData->FileStreamInfo;
1079 CopyStreamData(FindStreamData, lpFindStreamData);
1080
1081 /* All done */
1083 }
1084 else
1085 {
1086 if (FindStreamData->FileStreamInfo)
1087 {
1088 RtlFreeHeap(RtlGetProcessHeap(), 0, FindStreamData->FileStreamInfo);
1089 }
1090
1091 RtlFreeHeap(RtlGetProcessHeap(), 0, FindDataHandle);
1092 }
1093
1094Cleanup:
1096
1097 RtlFreeHeap(RtlGetProcessHeap(), 0, NtFilePath.Buffer);
1098
1099 if (NT_SUCCESS(Status))
1100 {
1101 return (HANDLE)FindDataHandle;
1102 }
1103 else
1104 {
1106 return INVALID_HANDLE_VALUE;
1107 }
1108}
struct _FIND_STREAM_DATA * PFIND_STREAM_DATA
static VOID CopyStreamData(IN OUT PFIND_STREAM_DATA FindStreamData, OUT PWIN32_FIND_STREAM_DATA lpFindStreamData)
Definition: find.c:214
static const WCHAR Cleanup[]
Definition: register.c:80
_Must_inspect_result_ _In_opt_ PFLT_INSTANCE _Out_ PHANDLE FileHandle
Definition: fltkernel.h:1231
@ FileStreamInformation
Definition: from_kernel.h:83
#define FILE_OPEN
Definition: from_kernel.h:54
NTSYSAPI PVOID WINAPI RtlReAllocateHeap(HANDLE, ULONG, PVOID, SIZE_T)
Definition: heap.c:2667
NTSYSAPI NTSTATUS NTAPI NtQueryInformationFile(IN HANDLE hFile, OUT PIO_STATUS_BLOCK pIoStatusBlock, OUT PVOID FileInformationBuffer, IN ULONG FileInformationBufferLength, IN FILE_INFORMATION_CLASS FileInfoClass)
#define FILE_SHARE_DELETE
Definition: nt_native.h:682
NTSTATUS NTAPI NtCreateFile(OUT PHANDLE FileHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes, OUT PIO_STATUS_BLOCK IoStatusBlock, IN PLARGE_INTEGER AllocationSize OPTIONAL, IN ULONG FileAttributes, IN ULONG ShareAccess, IN ULONG CreateDisposition, IN ULONG CreateOptions, IN PVOID EaBuffer OPTIONAL, IN ULONG EaLength)
#define STATUS_NO_MEMORY
Definition: ntstatus.h:260
#define STATUS_SUCCESS
Definition: shellext.h:65
#define STATUS_BUFFER_TOO_SMALL
Definition: shellext.h:69
PFILE_STREAM_INFORMATION CurrentInfo
Definition: find.c:93
STREAM_INFO_LEVELS InfoLevel
Definition: find.c:91
_In_ WDFMEMORY _Out_opt_ size_t * BufferSize
Definition: wdfmemory.h:254
_In_ PCCERT_CONTEXT _In_ DWORD dwFlags
Definition: wincrypt.h:1176

◆ FindNextFileA()

BOOL WINAPI FindNextFileA ( IN HANDLE  hFindFile,
OUT LPWIN32_FIND_DATAA  lpFindFileData 
)

Definition at line 336 of file find.c.

338{
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);
356 if (!NT_SUCCESS(Status))
357 {
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);
367 if (!NT_SUCCESS(Status))
368 {
370 return FALSE;
371 }
372
373 return TRUE;
374}
BOOL WINAPI FindNextFileW(IN HANDLE hFindFile, OUT LPWIN32_FIND_DATAW lpFindFileData)
Definition: find.c:382

Referenced by aexpand(), demFileFindFirst(), demFileFindNext(), enum_gac_assemblies(), enum_gac_assembly_dirs(), EnumColorProfilesA(), expect_files(), get_number_of_folders(), test_FindFirstFile_wildcards(), test_FindFirstFileA(), test_FindFirstFileExA(), test_FindNextFileA(), test_MoveFileA(), and test_request_groups().

◆ FindNextFileW()

BOOL WINAPI FindNextFileW ( IN HANDLE  hFindFile,
OUT LPWIN32_FIND_DATAW  lpFindFileData 
)

Definition at line 382 of file find.c.

384{
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;
396 DIR_INFORMATION DirInfo = {NULL}, NextDirInfo = {NULL};
397
398 if (hFindFile == NULL || hFindFile == INVALID_HANDLE_VALUE ||
399 FindDataHandle->Type != FindFile)
400 {
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,
417 &FindFileData->Buffer,
418 sizeof(FindFileData->Buffer),
419 (InfoLevel == FindExInfoStandard
422 FALSE,
423 NULL, /* Use the file pattern from the first call */
424 FALSE);
426 {
427 FindFileData->HasMoreData = TRUE;
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) ||
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 {
485 return FALSE;
486 }
487 else if (FoundFile.DirInfo == NULL)
488 {
490 return FALSE;
491 }
492
493 return TRUE;
494}
#define FILE_ATTRIBUTE_DIRECTORY
Definition: nt_native.h:705
#define STATUS_BUFFER_OVERFLOW
Definition: shellext.h:66
BYTE Buffer[FIND_DATA_SIZE]
Definition: find.c:86
void * PVOID
Definition: typedefs.h:50
PFILE_FULL_DIR_INFORMATION FullDirInfo
Definition: find.c:64
_In_ PUCHAR BufferEnd
Definition: usbdlib.h:189
enum _FINDEX_INFO_LEVELS FINDEX_INFO_LEVELS
#define ERROR_NO_MORE_FILES
Definition: winerror.h:121

Referenced by _FileOpCount(), add_favs_to_menu(), CDirectoryList::AddPathsFromDirectory(), AutoStartupApplications(), ChangeAttribute(), compat_nextdir(), compat_nextfile(), Control_DoWindow(), copy_file(), copy_folder(), CopyDirectory(), CFileDefExt::CountFolderAndFiles(), CControlPanelEnum::CreateCPanelEnumList(), CryptCATAdminEnumCatalogFromHash(), delete_directory(), delete_file(), delete_folder(), DeleteWithWildcard(), DELNODE_recurse_dirtree(), BtrfsPropSheet::do_search(), do_searchW(), DoAddFilesFromItem(), DoDeleteSpecW(), CAvailableApps::Enum(), enum_gac_assemblies(), EnumColorProfilesW(), EnumThemes(), filecoll_enumvariant_Next(), filecoll_enumvariant_Skip(), filecoll_get_Count(), FileCompareBothWild(), FileCompareOneSideWild(), FileCompareWildTitle(), FileQueryFiles(), fill_datafile(), fill_directory(), FindNextFileA(), foldercoll_enumvariant_Next(), foldercoll_enumvariant_Skip(), foldercoll_get_Count(), GetDirectoryStructure(), CWineTest::GetNextFile(), HasSubFolder(), CFileSysEnum::Initialize(), InitializeGlobalJobList(), IntDeleteRecursive(), LISTBOX_Directory(), LoadSoundFiles(), msi_dialog_update_directory_list(), msi_find_next_file(), OnClearRecentItems(), parse_wildcard_files(), PathIsDirectoryEmptyW(), pBuildFileList(), PrintAttribute(), RecursiveFind(), RecursiveRemoveDir(), BtrfsContextMenu::reflink_copy(), reflink_copy2(), ReflinkCopyW(), DriveVolume::ScanDirectory(), ScanForInfFile(), SdbpBuildSignMediaId(), SearchDriverRecursive(), SetupCopyOEMInfW(), SetupGetInfFileListW(), SHELL_DeleteDirectoryW(), SHFindAttrW(), start_enumeration(), testKeyboardLayouts(), wexpand(), WhereSearchGeneric(), wmain(), and XCOPY_DoCopy().

◆ FindNextStreamW()

BOOL WINAPI FindNextStreamW ( IN HANDLE  hFindStream,
OUT LPVOID  lpFindStreamData 
)

Definition at line 1116 of file find.c.

1118{
1119 PFIND_DATA_HANDLE FindDataHandle = (PFIND_DATA_HANDLE)hFindStream;
1120 PFIND_STREAM_DATA FindStreamData;
1121
1122 if (hFindStream == NULL || hFindStream == INVALID_HANDLE_VALUE ||
1123 FindDataHandle->Type != FindStream)
1124 {
1126 return FALSE;
1127 }
1128
1129 RtlEnterCriticalSection(&FindDataHandle->Lock);
1130
1131 FindStreamData = FindDataHandle->u.FindStreamData;
1132
1133 /* Select next stream if possible */
1134 if (FindStreamData->CurrentInfo->NextEntryOffset != 0)
1135 {
1136 FindStreamData->CurrentInfo = (PFILE_STREAM_INFORMATION)((ULONG_PTR)FindStreamData->CurrentInfo +
1137 FindStreamData->CurrentInfo->NextEntryOffset);
1138
1139 /* Return the information */
1140 CopyStreamData(FindStreamData, lpFindStreamData);
1141
1142 RtlLeaveCriticalSection(&FindDataHandle->Lock);
1143 return TRUE;
1144 }
1145 else
1146 {
1147 RtlLeaveCriticalSection(&FindDataHandle->Lock);
1148
1150 return FALSE;
1151 }
1152}
struct _FILE_STREAM_INFORMATION * PFILE_STREAM_INFORMATION
#define ERROR_HANDLE_EOF
Definition: winerror.h:140