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_DATA *	PFIND_FILE_DATA
typedef struct _FIND_STREAM_DATA	FIND_STREAM_DATA
typedef struct _FIND_STREAM_DATA *	PFIND_STREAM_DATA
typedef struct _FIND_DATA_HANDLE	FIND_DATA_HANDLE
typedef struct _FIND_DATA_HANDLE *	PFIND_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

typedef union _DIR_INFORMATION DIR_INFORMATION

FIND_DATA_HANDLE

typedef struct _FIND_DATA_HANDLE FIND_DATA_HANDLE

FIND_DATA_TYPE

typedef enum _FIND_DATA_TYPE FIND_DATA_TYPE

FIND_FILE_DATA

typedef struct _FIND_FILE_DATA FIND_FILE_DATA

FIND_STREAM_DATA

typedef struct _FIND_STREAM_DATA FIND_STREAM_DATA

PFIND_DATA_HANDLE

typedef struct _FIND_DATA_HANDLE * PFIND_DATA_HANDLE

PFIND_FILE_DATA

typedef struct _FIND_FILE_DATA * PFIND_FILE_DATA

PFIND_STREAM_DATA

typedef struct _FIND_STREAM_DATA * PFIND_STREAM_DATA

Enumeration Type Documentation

_FIND_DATA_TYPE

enum _FIND_DATA_TYPE

Enumerator
FindFile
FindStream

Definition at line 26 of file find.c.

{
    FindFile   = 1,
    FindStream = 2
} 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.

{
    LPCWSTR DeviceName;
    SIZE_T Length;
 
    _SEH2_TRY
    {
        /* DeviceNameInfo == { USHORT Offset; USHORT Length } */
        Length     =  (SIZE_T)(DeviceNameInfo & 0xFFFF);
        DeviceName = (LPCWSTR)((ULONG_PTR)lpFileName + ((DeviceNameInfo >> 16) & 0xFFFF));
 
        /* Return the data */
        RtlZeroMemory(lpFindFileData, sizeof(*lpFindFileData));
        lpFindFileData->dwFileAttributes = FILE_ATTRIBUTE_ARCHIVE;
        RtlStringCbCopyNW(lpFindFileData->cFileName,
                          sizeof(lpFindFileData->cFileName),
                          DeviceName, Length);
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
    }
    _SEH2_END;
 
    return;
}

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.

{
#define ULARGE_INTEGER_2_FILETIME(ft, ul) \
do { \
    (ft).dwHighDateTime = (ul).u.HighPart; \
    (ft).dwLowDateTime  = (ul).u.LowPart ; \
} while(0)
 
    _SEH2_TRY
    {
        RtlZeroMemory(lpFindFileData, sizeof(*lpFindFileData));
 
        lpFindFileData->dwFileAttributes = DirInfo.FullDirInfo->FileAttributes;
 
        ULARGE_INTEGER_2_FILETIME(lpFindFileData->ftCreationTime, DirInfo.FullDirInfo->CreationTime);
        ULARGE_INTEGER_2_FILETIME(lpFindFileData->ftLastAccessTime, DirInfo.FullDirInfo->LastAccessTime);
        ULARGE_INTEGER_2_FILETIME(lpFindFileData->ftLastWriteTime, DirInfo.FullDirInfo->LastWriteTime);
 
        lpFindFileData->nFileSizeHigh = DirInfo.FullDirInfo->EndOfFile.u.HighPart;
        lpFindFileData->nFileSizeLow = DirInfo.FullDirInfo->EndOfFile.u.LowPart;
 
        /* dwReserved0 contains the NTFS reparse point tag, if any. */
        if (DirInfo.FullDirInfo->FileAttributes & FILE_ATTRIBUTE_REPARSE_POINT)
            lpFindFileData->dwReserved0 = DirInfo.FullDirInfo->EaSize;
        else
            lpFindFileData->dwReserved0 = 0;
 
        /* Unused dwReserved1 field */
        lpFindFileData->dwReserved1 = 0;
 
        if (fInfoLevelId == FindExInfoStandard)
        {
            RtlStringCbCopyNW(lpFindFileData->cFileName,
                              sizeof(lpFindFileData->cFileName),
                              DirInfo.BothDirInfo->FileName,
                              DirInfo.BothDirInfo->FileNameLength);
 
            RtlStringCbCopyNW(lpFindFileData->cAlternateFileName,
                              sizeof(lpFindFileData->cAlternateFileName),
                              DirInfo.BothDirInfo->ShortName,
                              DirInfo.BothDirInfo->ShortNameLength);
        }
        else if (fInfoLevelId == FindExInfoBasic)
        {
            RtlStringCbCopyNW(lpFindFileData->cFileName,
                              sizeof(lpFindFileData->cFileName),
                              DirInfo.FullDirInfo->FileName,
                              DirInfo.FullDirInfo->FileNameLength);
 
            lpFindFileData->cAlternateFileName[0] = UNICODE_NULL;
        }
        else
        {
            /* Invalid InfoLevelId */
            ASSERT(FALSE);
        }
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
    }
    _SEH2_END;
 
    return;
}

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.

{
    _SEH2_TRY
    {
        ASSERT(FindStreamData->CurrentInfo);
 
        switch (FindStreamData->InfoLevel)
        {
            case FindStreamInfoStandard:
            {
                ULONG StreamNameLen = min(FindStreamData->CurrentInfo->StreamNameLength,
                                          sizeof(lpFindStreamData->cStreamName) - sizeof(WCHAR));
 
                RtlZeroMemory(lpFindStreamData, sizeof(*lpFindStreamData));
 
                lpFindStreamData->StreamSize.QuadPart = FindStreamData->CurrentInfo->StreamSize.QuadPart;
                RtlCopyMemory(lpFindStreamData->cStreamName,
                              FindStreamData->CurrentInfo->StreamName,
                              StreamNameLen);
                lpFindStreamData->cStreamName[StreamNameLen / sizeof(WCHAR)] = UNICODE_NULL;
 
                break;
            }
 
            default:
            {
                /* Invalid InfoLevel */
                ASSERT(FALSE);
                break;
            }
        }
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
    }
    _SEH2_END;
 
    return;
}

Referenced by FindFirstStreamW(), and FindNextStreamW().

DEBUG_CHANNEL()

DEBUG_CHANNEL

(

kernel32file

)

FindClose()

BOOL WINAPI FindClose

(

HANDLE

hFindFile

)

Definition at line 502 of file find.c.

{
    TRACE("FindClose(hFindFile %p)\n", hFindFile);
 
    if (hFindFile == FIND_DEVICE_HANDLE)
        return TRUE;
 
    if (!hFindFile || hFindFile == INVALID_HANDLE_VALUE)
    {
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
 
    /* Protect with SEH against closing attempts on invalid handles. */
    _SEH2_TRY
    {
        PFIND_DATA_HANDLE FindDataHandle = (PFIND_DATA_HANDLE)hFindFile;
 
        switch (FindDataHandle->Type)
        {
            case FindFile:
            {
                RtlEnterCriticalSection(&FindDataHandle->Lock);
                NtClose(FindDataHandle->u.FindFileData->Handle);
                RtlLeaveCriticalSection(&FindDataHandle->Lock);
                RtlDeleteCriticalSection(&FindDataHandle->Lock);
                break;
            }
 
            case FindStream:
            {
                RtlEnterCriticalSection(&FindDataHandle->Lock);
                if (FindDataHandle->u.FindStreamData->FileStreamInfo != NULL)
                {
                    RtlFreeHeap(RtlGetProcessHeap(), 0,
                                FindDataHandle->u.FindStreamData->FileStreamInfo);
                }
                RtlLeaveCriticalSection(&FindDataHandle->Lock);
                RtlDeleteCriticalSection(&FindDataHandle->Lock);
                break;
            }
 
            default:
            {
                SetLastError(ERROR_INVALID_HANDLE);
                _SEH2_YIELD(return FALSE);
            }
        }
 
        RtlFreeHeap(RtlGetProcessHeap(), 0, FindDataHandle);
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        BaseSetLastNTError(_SEH2_GetExceptionCode());
        _SEH2_YIELD(return FALSE);
    }
    _SEH2_END;
 
    return TRUE;
}

Referenced by _FileOpCount(), _findclose(), CFSFolder::_GetFindDataFromName(), _ILCreateFromPathW(), _RunRemoteTest(), add_favs_to_menu(), AddDesktopItemW(), AddItemW(), CDirectoryList::AddPathsFromDirectory(), AddUserProfile(), AddWallpapersFromDirectory(), aexpand(), apply_patch(), AutoStartupApplications(), ChangeACLsOfFiles(), ChangeACLsOfFilesInCurDir(), 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(), dialog_update_directory_list(), DirList(), do_searchW(), DoAddFilesFromItem(), DoDeleteSpecW(), DoLoadImageFile(), DoSpecExistsW(), enum_gac_assemblies(), enum_gac_assembly_dirs(), EnumColorProfilesA(), EnumColorProfilesW(), EnumDirs(), CAppDB::EnumerateFiles(), EnumFilesInDirectory(), EnumFilesWorker(), 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(), InstallFiles(), InstallScreenSaverW(), IntDeleteRecursive(), LISTBOX_Directory(), LoadSoundFiles(), main(), move_files_wildcard(), MyFileExists(), OnSelChange(), OpenUserEventLogFile(), fff_handle::operator=(), parse_wildcard_files(), PathIsDirectoryEmptyW(), pBuildFileList(), PrintDaclsOfFiles(), ProcessDirectory(), ShellDirectory::read_directory(), WinDirectory::read_directory(), CFontInfo::ReadAttrs(), RecentHasShortcut(), recFindSubDirs(), recReplace(), recurse_search_directory(), RecursiveCreateDirectory(), RecursiveFind(), RecursiveRemoveDir(), remove_dir(), CShellLink::Save(), 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(), tinydir_close(), 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.

{
    HANDLE hSearch;
    NTSTATUS Status;
    ANSI_STRING Ansi;
    UNICODE_STRING UTF8;
    PUNICODE_STRING lpFileNameW;
    WIN32_FIND_DATAW FindFileDataW;
 
    lpFileNameW = Basep8BitStringToStaticUnicodeString(lpFileName);
    if (!lpFileNameW) return INVALID_HANDLE_VALUE;
 
    hSearch = FindFirstFileExW(lpFileNameW->Buffer,
                               FindExInfoStandard,
                               &FindFileDataW,
                               FindExSearchNameMatch,
                               NULL, 0);
    if (hSearch == INVALID_HANDLE_VALUE) return INVALID_HANDLE_VALUE;
 
    RtlCopyMemory(lpFindFileData,
                  &FindFileDataW,
                  FIELD_OFFSET(WIN32_FIND_DATAA, cFileName));
 
    RtlInitUnicodeString(&UTF8, FindFileDataW.cFileName);
    Ansi.Buffer = lpFindFileData->cFileName;
    Ansi.Length = 0;
    Ansi.MaximumLength = sizeof(lpFindFileData->cFileName);
    Status = BasepUnicodeStringTo8BitString(&Ansi, &UTF8, FALSE);
    if (!NT_SUCCESS(Status))
    {
        FindClose(hSearch);
        BaseSetLastNTError(Status);
        return INVALID_HANDLE_VALUE;
    }
 
    RtlInitUnicodeString(&UTF8, FindFileDataW.cAlternateFileName);
    Ansi.Buffer = lpFindFileData->cAlternateFileName;
    Ansi.Length = 0;
    Ansi.MaximumLength = sizeof(lpFindFileData->cAlternateFileName);
    Status = BasepUnicodeStringTo8BitString(&Ansi, &UTF8, FALSE);
    if (!NT_SUCCESS(Status))
    {
        FindClose(hSearch);
        BaseSetLastNTError(Status);
        return INVALID_HANDLE_VALUE;
    }
 
    return hSearch;
}

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.

{
    HANDLE hSearch;
    NTSTATUS Status;
    ANSI_STRING Ansi;
    UNICODE_STRING UTF8;
    PUNICODE_STRING lpFileNameW;
    WIN32_FIND_DATAW FindFileDataW;
    LPWIN32_FIND_DATAA lpFindFileDataA = (LPWIN32_FIND_DATAA)lpFindFileData;
 
    if ((fInfoLevelId != FindExInfoStandard && fInfoLevelId != FindExInfoBasic) ||
        fSearchOp == FindExSearchLimitToDevices ||
        dwAdditionalFlags & ~FIND_FIRST_EX_CASE_SENSITIVE /* only supported flag for now */)
    {
        SetLastError(fSearchOp == FindExSearchLimitToDevices
                                ? ERROR_NOT_SUPPORTED
                                : ERROR_INVALID_PARAMETER);
        return INVALID_HANDLE_VALUE;
    }
 
    lpFileNameW = Basep8BitStringToStaticUnicodeString(lpFileName);
    if (!lpFileNameW) return INVALID_HANDLE_VALUE;
 
    hSearch = FindFirstFileExW(lpFileNameW->Buffer,
                               fInfoLevelId,
                               &FindFileDataW,
                               fSearchOp,
                               lpSearchFilter,
                               dwAdditionalFlags);
    if (hSearch == INVALID_HANDLE_VALUE) return INVALID_HANDLE_VALUE;
 
    RtlCopyMemory(lpFindFileDataA,
                  &FindFileDataW,
                  FIELD_OFFSET(WIN32_FIND_DATAA, cFileName));
 
    RtlInitUnicodeString(&UTF8, FindFileDataW.cFileName);
    Ansi.Buffer = lpFindFileDataA->cFileName;
    Ansi.Length = 0;
    Ansi.MaximumLength = sizeof(lpFindFileDataA->cFileName);
    Status = BasepUnicodeStringTo8BitString(&Ansi, &UTF8, FALSE);
    if (!NT_SUCCESS(Status))
    {
        FindClose(hSearch);
        BaseSetLastNTError(Status);
        return INVALID_HANDLE_VALUE;
    }
 
    if (fInfoLevelId != FindExInfoBasic)
    {
        RtlInitUnicodeString(&UTF8, FindFileDataW.cAlternateFileName);
        Ansi.Buffer = lpFindFileDataA->cAlternateFileName;
        Ansi.Length = 0;
        Ansi.MaximumLength = sizeof(lpFindFileDataA->cAlternateFileName);
        Status = BasepUnicodeStringTo8BitString(&Ansi, &UTF8, FALSE);
        if (!NT_SUCCESS(Status))
        {
            FindClose(hSearch);
            BaseSetLastNTError(Status);
            return INVALID_HANDLE_VALUE;
        }
    }
    else
    {
        lpFindFileDataA->cAlternateFileName[0] = ANSI_NULL;
    }
 
    return hSearch;
}

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.

{
    UNREFERENCED_PARAMETER(lpSearchFilter);
 
    TRACE("FindFirstFileExW(lpFileName %S)\n", lpFileName);
 
    if ((fInfoLevelId != FindExInfoStandard && fInfoLevelId != FindExInfoBasic) ||
        fSearchOp == FindExSearchLimitToDevices ||
        dwAdditionalFlags & ~FIND_FIRST_EX_CASE_SENSITIVE /* only supported flag for now */)
    {
        SetLastError(fSearchOp == FindExSearchLimitToDevices
                                ? ERROR_NOT_SUPPORTED
                                : ERROR_INVALID_PARAMETER);
        return INVALID_HANDLE_VALUE;
    }
 
    if (fSearchOp == FindExSearchNameMatch ||
        fSearchOp == FindExSearchLimitToDirectories)
    {
        LPWIN32_FIND_DATAW Win32FindData = (LPWIN32_FIND_DATAW)lpFindFileData;
        PFIND_DATA_HANDLE FindDataHandle;
        PFIND_FILE_DATA FindFileData;
 
        UNICODE_STRING NtPath, FilePattern, FileName;
        PWSTR NtPathBuffer;
        RTL_RELATIVE_NAME_U RelativePath;
        ULONG DeviceNameInfo = 0;
 
        NTSTATUS Status;
        OBJECT_ATTRIBUTES ObjectAttributes;
        IO_STATUS_BLOCK IoStatusBlock;
        HANDLE hDirectory = NULL;
 
        BOOLEAN HadADot = FALSE;
 
        /*
         * May represent many FILE_BOTH_DIR_INFORMATION
         * or many FILE_FULL_DIR_INFORMATION structures.
         * NOTE: NtQueryDirectoryFile requires the buffer to be ULONG-aligned
         */
        DECLSPEC_ALIGN(4) BYTE DirectoryInfo[FIND_DATA_SIZE];
        DIR_INFORMATION DirInfo = { .DirInfo = &DirectoryInfo };
 
        RtlInitUnicodeString(&FileName, lpFileName);
        if (FileName.Length != 0 && FileName.Buffer[FileName.Length / sizeof(WCHAR) - 1] == L'.')
        {
            HadADot = TRUE;
        }
 
        if (!RtlDosPathNameToNtPathName_U(lpFileName,
                                          &NtPath,
                                          (PCWSTR*)&FilePattern.Buffer,
                                          &RelativePath))
        {
            SetLastError(ERROR_PATH_NOT_FOUND);
            return INVALID_HANDLE_VALUE;
        }
 
        DPRINT("lpFileName = '%S'\n", lpFileName);
        DPRINT("FilePattern.Buffer = '%S'\n", FilePattern.Buffer);
        DPRINT("RelativePath.RelativeName = '%wZ'\n", &RelativePath.RelativeName);
        DPRINT("NtPath.Buffer = '%S'\n", NtPath.Buffer);
        DPRINT("NtPath - Before = '%wZ'\n", &NtPath);
 
        /* Save the buffer pointer for later, we need to free it! */
        NtPathBuffer = NtPath.Buffer;
 
        /*
         * Contrary to what Windows does, check NOW whether or not
         * lpFileName is a DOS driver. Therefore we don't have to
         * write broken code to check that.
         */
        if (!FilePattern.Buffer || !*FilePattern.Buffer)
        {
            /* No file pattern specified, or DOS device */
 
            DeviceNameInfo = RtlIsDosDeviceName_U(lpFileName);
            if (DeviceNameInfo != 0)
            {
                RtlReleaseRelativeName(&RelativePath);
                RtlFreeHeap(RtlGetProcessHeap(), 0, NtPathBuffer);
 
                /* OK, it's really a DOS device */
                CopyDeviceFindData(Win32FindData, lpFileName, DeviceNameInfo);
                return FIND_DEVICE_HANDLE;
            }
        }
 
        /* A file pattern was specified, or it was not a DOS device */
 
        /* If there is a file pattern then determine its length */
        if (FilePattern.Buffer != NULL)
        {
            FilePattern.Length = NtPath.Length -
                (USHORT)((ULONG_PTR)FilePattern.Buffer - (ULONG_PTR)NtPath.Buffer);
        }
        else
        {
            FilePattern.Length = 0;
        }
        FilePattern.MaximumLength = FilePattern.Length;
 
        if (RelativePath.RelativeName.Length != 0 &&
            RelativePath.RelativeName.Buffer != FilePattern.Buffer)
        {
            if (FilePattern.Buffer != NULL)
            {
                /* This is a relative path to RelativePath.ContainingDirectory, adjust NtPath! */
                NtPath.Length = NtPath.MaximumLength =
                    (USHORT)((ULONG_PTR)FilePattern.Buffer - (ULONG_PTR)RelativePath.RelativeName.Buffer);
                NtPath.Buffer = RelativePath.RelativeName.Buffer;
            }
        }
        else
        {
            /* This is an absolute path, NtPath receives the full path */
            RelativePath.ContainingDirectory = NULL;
            if (FilePattern.Buffer != NULL)
            {
                NtPath.Length = NtPath.MaximumLength =
                    (USHORT)((ULONG_PTR)FilePattern.Buffer - (ULONG_PTR)NtPath.Buffer);
            }
        }
 
        DPRINT("NtPath - After = '%wZ'\n", &NtPath);
        DPRINT("FilePattern = '%wZ'\n", &FilePattern);
        DPRINT("RelativeTo = 0x%p\n", RelativePath.ContainingDirectory);
 
        InitializeObjectAttributes(&ObjectAttributes,
                                   &NtPath,
                                   (dwAdditionalFlags & FIND_FIRST_EX_CASE_SENSITIVE) ? 0 : OBJ_CASE_INSENSITIVE,
                                   RelativePath.ContainingDirectory,
                                   NULL);
 
        Status = NtOpenFile(&hDirectory,
                            FILE_LIST_DIRECTORY | SYNCHRONIZE,
                            &ObjectAttributes,
                            &IoStatusBlock,
                            FILE_SHARE_READ | FILE_SHARE_WRITE,
                            FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT);
 
        if (!NT_SUCCESS(Status))
        {
            RtlReleaseRelativeName(&RelativePath);
            RtlFreeHeap(RtlGetProcessHeap(), 0, NtPathBuffer);
 
            /* Adjust the last error codes */
            if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
                Status = STATUS_OBJECT_PATH_NOT_FOUND;
            else if (Status == STATUS_OBJECT_TYPE_MISMATCH)
                Status = STATUS_OBJECT_PATH_NOT_FOUND;
 
            BaseSetLastNTError(Status);
            return INVALID_HANDLE_VALUE;
        }
 
        /*
         * Fail if there is not any file pattern,
         * since we are not looking for a device.
         */
        if (FilePattern.Length == 0)
        {
            NtClose(hDirectory);
            RtlReleaseRelativeName(&RelativePath);
            RtlFreeHeap(RtlGetProcessHeap(), 0, NtPathBuffer);
 
            SetLastError(ERROR_FILE_NOT_FOUND);
            return INVALID_HANDLE_VALUE;
        }
 
        /* Change pattern: "*.*" --> "*" */
        if (FilePattern.Length == 6 &&
            RtlCompareMemory(FilePattern.Buffer, L"*.*", 6) == 6)
        {
            FilePattern.Length = 2;
        }
        else
        {
            /* Translate wildcard from "real" world to DOS world for lower interpretation */
            USHORT PatternIndex = 0;
            while (PatternIndex < FilePattern.Length / sizeof(WCHAR))
            {
                if (PatternIndex > 0)
                {
                    if (FilePattern.Buffer[PatternIndex] == L'.' &&
                        FilePattern.Buffer[PatternIndex - 1] == L'*')
                    {
                        FilePattern.Buffer[PatternIndex - 1] = L'<';
                    }
                }
 
                if (FilePattern.Buffer[PatternIndex] == L'?')
                {
                    FilePattern.Buffer[PatternIndex] = L'>';
                    if (PatternIndex > 0)
                    {
                        if (FilePattern.Buffer[PatternIndex - 1] == L'.')
                        {
                            FilePattern.Buffer[PatternIndex - 1] = L'\"';
                        }
                    }
                }
                else if (FilePattern.Buffer[PatternIndex] == L'*')
                {
                    if (PatternIndex > 0)
                    {
                        if (FilePattern.Buffer[PatternIndex - 1] == L'.')
                        {
                            FilePattern.Buffer[PatternIndex - 1] = L'\"';
                        }
                    }
                }
 
                PatternIndex++;
            }
 
            /* Handle partial wc if our last dot was eaten */
            if (HadADot)
            {
                if (FilePattern.Buffer[FilePattern.Length / sizeof(WCHAR) - 1] == L'*')
                {
                    FilePattern.Buffer[FilePattern.Length / sizeof(WCHAR) - 1] = L'<';
                }
            }
        }
 
        Status = NtQueryDirectoryFile(hDirectory,
                                      NULL, NULL, NULL,
                                      &IoStatusBlock,
                                      DirInfo.DirInfo, // == &DirectoryInfo
                                      sizeof(DirectoryInfo),
                                      (fInfoLevelId == FindExInfoStandard
                                                     ? FileBothDirectoryInformation
                                                     : FileFullDirectoryInformation),
                                      TRUE, /* Return a single entry */
                                      &FilePattern,
                                      TRUE);
 
        RtlReleaseRelativeName(&RelativePath);
        RtlFreeHeap(RtlGetProcessHeap(), 0, NtPathBuffer);
 
        if (!NT_SUCCESS(Status))
        {
            NtClose(hDirectory);
            BaseSetLastNTError(Status);
            return INVALID_HANDLE_VALUE;
        }
 
        ASSERT(DirInfo.FullDirInfo->NextEntryOffset == 0);
 
        /* Return the information */
        CopyFindData(Win32FindData, fInfoLevelId, DirInfo);
 
        /*
         * Initialization of the search handle.
         */
        FindDataHandle = RtlAllocateHeap(RtlGetProcessHeap(),
                                         HEAP_ZERO_MEMORY,
                                         sizeof(FIND_DATA_HANDLE) +
                                             sizeof(FIND_FILE_DATA));
        if (!FindDataHandle)
        {
            NtClose(hDirectory);
            SetLastError(ERROR_NOT_ENOUGH_MEMORY);
            return INVALID_HANDLE_VALUE;
        }
 
        FindDataHandle->Type = FindFile;
        FindDataHandle->u.FindFileData = (PFIND_FILE_DATA)(FindDataHandle + 1);
        FindFileData = FindDataHandle->u.FindFileData;
 
        FindFileData->Handle = hDirectory;
        FindFileData->InfoLevel = fInfoLevelId;
        FindFileData->SearchOp = fSearchOp;
        FindFileData->HasMoreData = FALSE;
        FindFileData->NextDirInfo.DirInfo = NULL;
 
        /* The critical section must always be initialized */
        Status = RtlInitializeCriticalSection(&FindDataHandle->Lock);
        if (!NT_SUCCESS(Status))
        {
            NtClose(hDirectory);
            RtlFreeHeap(RtlGetProcessHeap(), 0, FindDataHandle);
 
            BaseSetLastNTError(Status);
            return INVALID_HANDLE_VALUE;
        }
 
        return (HANDLE)FindDataHandle;
    }
    else
    {
        SetLastError(ERROR_NOT_SUPPORTED);
        return INVALID_HANDLE_VALUE;
    }
}

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.

{
    return FindFirstFileExW(lpFileName,
                            FindExInfoStandard,
                            lpFindFileData,
                            FindExSearchNameMatch,
                            NULL, 0);
}

Referenced by _FileOpCount(), CFSFolder::_GetFindDataFromName(), _ILCreateFromPathW(), _RunRemoteTest(), add_favs_to_menu(), AddDesktopItemW(), AddItemW(), CDirectoryList::AddPathsFromDirectory(), AddUserProfile(), AutoStartupApplications(), 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(), dialog_update_directory_list(), BtrfsPropSheet::do_search(), do_searchW(), DoAddFilesFromItem(), DoDeleteSpecW(), DoLoadImageFile(), DoSpecExistsW(), enum_gac_assemblies(), EnumColorProfilesW(), CAppDB::EnumerateFiles(), EnumFilesWorker(), 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(), InstallFiles(), IntDeleteRecursive(), BtrfsContextMenu::InvokeCommand(), LISTBOX_Directory(), LoadSoundFiles(), msi_find_first_file(), MyFileExists(), OpenUserEventLogFile(), parse_wildcard_files(), PathIsDirectoryEmptyW(), pBuildFileList(), CFontInfo::ReadAttrs(), RecentHasShortcut(), RecursiveFind(), RecursiveRemoveDir(), BtrfsContextMenu::reflink_copy(), reflink_copy2(), ReflinkCopyW(), CShellLink::Save(), SaveDIBToFile(), DriveVolume::ScanDirectory(), ScanForInfFile(), SdbpBuildSignMediaId(), SearchDriverRecursive(), SetupCopyOEMInfW(), SetupGetInfFileListW(), SHAddToRecentDocs(), SHELL_DeleteDirectoryW(), SHFindAttrW(), SHNotifyDeleteFileW(), start_enumeration(), START_TEST(), test_GetAbsolutePathName(), Test_NtGdiAddFontResourceW(), testKeyboardLayouts(), 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 957 of file find.c.

{
    PFIND_DATA_HANDLE FindDataHandle = NULL;
    PFIND_STREAM_DATA FindStreamData;
    OBJECT_ATTRIBUTES ObjectAttributes;
    IO_STATUS_BLOCK IoStatusBlock;
    UNICODE_STRING NtFilePath;
    HANDLE FileHandle = NULL;
    NTSTATUS Status;
    ULONG BufferSize = 0;
 
    if (dwFlags != 0 || InfoLevel != FindStreamInfoStandard ||
        lpFindStreamData == NULL)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return INVALID_HANDLE_VALUE;
    }
 
    /* Validate and translate the filename */
    if (!RtlDosPathNameToNtPathName_U(lpFileName,
                                      &NtFilePath,
                                      NULL, NULL))
    {
        SetLastError(ERROR_PATH_NOT_FOUND);
        return INVALID_HANDLE_VALUE;
    }
 
    /* Open the file */
    InitializeObjectAttributes(&ObjectAttributes,
                               &NtFilePath,
                               OBJ_CASE_INSENSITIVE,
                               NULL,
                               NULL);
 
    Status = NtCreateFile(&FileHandle,
                          0,
                          &ObjectAttributes,
                          &IoStatusBlock,
                          NULL, 0,
                          FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE,
                          FILE_OPEN,
                          0, NULL, 0);
    if (!NT_SUCCESS(Status)) goto Cleanup;
 
    /*
     * Initialization of the search handle.
     */
    FindDataHandle = RtlAllocateHeap(RtlGetProcessHeap(),
                                     HEAP_ZERO_MEMORY,
                                     sizeof(FIND_DATA_HANDLE) +
                                         sizeof(FIND_STREAM_DATA));
    if (!FindDataHandle)
    {
        Status = STATUS_NO_MEMORY;
        goto Cleanup;
    }
 
    FindDataHandle->Type = FindStream;
    FindDataHandle->u.FindStreamData = (PFIND_STREAM_DATA)(FindDataHandle + 1);
    FindStreamData = FindDataHandle->u.FindStreamData;
 
    FindStreamData->InfoLevel = InfoLevel;
    FindStreamData->FileStreamInfo = NULL;
    FindStreamData->CurrentInfo = NULL;
 
    /* The critical section must always be initialized */
    Status = RtlInitializeCriticalSection(&FindDataHandle->Lock);
    if (!NT_SUCCESS(Status))
    {
        RtlFreeHeap(RtlGetProcessHeap(), 0, FindDataHandle);
        goto Cleanup;
    }
 
    /* Capture all information about the streams */
    do
    {
        BufferSize += 0x1000;
 
        if (FindStreamData->FileStreamInfo == NULL)
        {
            FindStreamData->FileStreamInfo = RtlAllocateHeap(RtlGetProcessHeap(),
                                                              HEAP_ZERO_MEMORY,
                                                              BufferSize);
            if (FindStreamData->FileStreamInfo == NULL)
            {
                Status = STATUS_NO_MEMORY;
                break;
            }
        }
        else
        {
            PFILE_STREAM_INFORMATION pfsi;
 
            pfsi = RtlReAllocateHeap(RtlGetProcessHeap(),
                                     0, // HEAP_ZERO_MEMORY,
                                     FindStreamData->FileStreamInfo,
                                     BufferSize);
            if (pfsi == NULL)
            {
                Status = STATUS_NO_MEMORY;
                break;
            }
 
            FindStreamData->FileStreamInfo = pfsi;
        }
 
        Status = NtQueryInformationFile(FileHandle,
                                        &IoStatusBlock,
                                        FindStreamData->FileStreamInfo,
                                        BufferSize,
                                        FileStreamInformation);
 
    } while (Status == STATUS_BUFFER_TOO_SMALL);
 
    if (NT_SUCCESS(Status))
    {
        /* Select the first stream and return the information */
        FindStreamData->CurrentInfo = FindStreamData->FileStreamInfo;
        CopyStreamData(FindStreamData, lpFindStreamData);
 
        /* All done */
        Status = STATUS_SUCCESS;
    }
    else
    {
        if (FindStreamData->FileStreamInfo)
        {
            RtlFreeHeap(RtlGetProcessHeap(), 0, FindStreamData->FileStreamInfo);
        }
 
        RtlFreeHeap(RtlGetProcessHeap(), 0, FindDataHandle);
    }
 
Cleanup:
    if (FileHandle) NtClose(FileHandle);
 
    RtlFreeHeap(RtlGetProcessHeap(), 0, NtFilePath.Buffer);
 
    if (NT_SUCCESS(Status))
    {
        return (HANDLE)FindDataHandle;
    }
    else
    {
        BaseSetLastNTError(Status);
        return INVALID_HANDLE_VALUE;
    }
}

FindNextFileA()

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

Definition at line 336 of file find.c.

{
    NTSTATUS Status;
    ANSI_STRING Ansi;
    UNICODE_STRING UTF8;
    WIN32_FIND_DATAW FindFileDataW;
 
    if (!FindNextFileW(hFindFile, &FindFileDataW))
        return FALSE;
 
    RtlCopyMemory(lpFindFileData,
                  &FindFileDataW,
                  FIELD_OFFSET(WIN32_FIND_DATAA, cFileName));
 
    RtlInitUnicodeString(&UTF8, FindFileDataW.cFileName);
    Ansi.Buffer = lpFindFileData->cFileName;
    Ansi.Length = 0;
    Ansi.MaximumLength = sizeof(lpFindFileData->cFileName);
    Status = BasepUnicodeStringTo8BitString(&Ansi, &UTF8, FALSE);
    if (!NT_SUCCESS(Status))
    {
        BaseSetLastNTError(Status);
        return FALSE;
    }
 
    RtlInitUnicodeString(&UTF8, FindFileDataW.cAlternateFileName);
    Ansi.Buffer = lpFindFileData->cAlternateFileName;
    Ansi.Length = 0;
    Ansi.MaximumLength = sizeof(lpFindFileData->cAlternateFileName);
    Status = BasepUnicodeStringTo8BitString(&Ansi, &UTF8, FALSE);
    if (!NT_SUCCESS(Status))
    {
        BaseSetLastNTError(Status);
        return FALSE;
    }
 
    return TRUE;
}

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.

{
    NTSTATUS Status = STATUS_SUCCESS;
    DIR_INFORMATION FoundFile = {NULL};
 
    TRACE("FindNextFileW(%p, 0x%p)\n", hFindFile, lpFindFileData);
 
    if (hFindFile != FIND_DEVICE_HANDLE)
    {
        PFIND_DATA_HANDLE FindDataHandle = (PFIND_DATA_HANDLE)hFindFile;
        PFIND_FILE_DATA FindFileData;
        FINDEX_INFO_LEVELS InfoLevel;
        IO_STATUS_BLOCK IoStatusBlock;
        DIR_INFORMATION DirInfo = {NULL}, NextDirInfo = {NULL};
 
        if (hFindFile == NULL || hFindFile == INVALID_HANDLE_VALUE ||
            FindDataHandle->Type != FindFile)
        {
            SetLastError(ERROR_INVALID_HANDLE);
            return FALSE;
        }
 
        RtlEnterCriticalSection(&FindDataHandle->Lock);
 
        FindFileData = FindDataHandle->u.FindFileData;
        InfoLevel = FindFileData->InfoLevel;
 
        do
        {
            if (FindFileData->NextDirInfo.DirInfo == NULL)
            {
                Status = NtQueryDirectoryFile(FindFileData->Handle,
                                              NULL, NULL, NULL,
                                              &IoStatusBlock,
                                              &FindFileData->Buffer,
                                              sizeof(FindFileData->Buffer),
                                              (InfoLevel == FindExInfoStandard
                                                          ? FileBothDirectoryInformation
                                                          : FileFullDirectoryInformation),
                                              FALSE,
                                              NULL, /* Use the file pattern from the first call */
                                              FALSE);
                if (Status == STATUS_BUFFER_OVERFLOW)
                {
                    FindFileData->HasMoreData = TRUE;
                    Status = STATUS_SUCCESS;
                }
                else
                {
                    if (!NT_SUCCESS(Status)) break;
                    FindFileData->HasMoreData = FALSE;
                }
 
                FindFileData->NextDirInfo.DirInfo = &FindFileData->Buffer;
            }
 
            DirInfo = FindFileData->NextDirInfo;
 
            if (DirInfo.FullDirInfo->NextEntryOffset != 0)
            {
                ULONG_PTR BufferEnd = (ULONG_PTR)&FindFileData->Buffer + sizeof(FindFileData->Buffer);
                PWSTR pFileName;
 
                NextDirInfo.DirInfo = FindFileData->NextDirInfo.DirInfo =
                    (PVOID)((ULONG_PTR)DirInfo.DirInfo + DirInfo.FullDirInfo->NextEntryOffset);
 
                pFileName = (InfoLevel == FindExInfoStandard
                                        ? NextDirInfo.BothDirInfo->FileName
                                        : NextDirInfo.FullDirInfo->FileName);
 
                /* Be paranoid and make sure that the next entry is completely there */
                if (BufferEnd < (ULONG_PTR)NextDirInfo.DirInfo ||
                    BufferEnd < (ULONG_PTR)&NextDirInfo.FullDirInfo->FileNameLength + sizeof(NextDirInfo.FullDirInfo->FileNameLength) ||
                    BufferEnd <= (ULONG_PTR)((ULONG_PTR)pFileName + NextDirInfo.FullDirInfo->FileNameLength))
                {
                    FindFileData->NextDirInfo.DirInfo = NULL;
                }
            }
            else
            {
                FindFileData->NextDirInfo.DirInfo = NULL;
            }
 
            if ((FindFileData->SearchOp != FindExSearchLimitToDirectories) ||
                (DirInfo.FullDirInfo->FileAttributes & FILE_ATTRIBUTE_DIRECTORY))
            {
                FoundFile = DirInfo;
            }
        } while ( FoundFile.DirInfo == NULL && (FindFileData->NextDirInfo.DirInfo || FindFileData->HasMoreData) );
 
        if (FoundFile.DirInfo != NULL)
        {
            /* Return the information */
            CopyFindData(lpFindFileData, InfoLevel, FoundFile);
        }
 
        RtlLeaveCriticalSection(&FindDataHandle->Lock);
    }
 
    if (!NT_SUCCESS(Status))
    {
        BaseSetLastNTError(Status);
        return FALSE;
    }
    else if (FoundFile.DirInfo == NULL)
    {
        SetLastError(ERROR_NO_MORE_FILES);
        return FALSE;
    }
 
    return TRUE;
}

Referenced by _FileOpCount(), add_favs_to_menu(), CDirectoryList::AddPathsFromDirectory(), AutoStartupApplications(), 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(), dialog_update_directory_list(), BtrfsPropSheet::do_search(), do_searchW(), DoAddFilesFromItem(), DoDeleteSpecW(), enum_gac_assemblies(), EnumColorProfilesW(), CAppDB::EnumerateFiles(), EnumFilesWorker(), 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(), InstallFiles(), IntDeleteRecursive(), LISTBOX_Directory(), LoadSoundFiles(), msi_find_next_file(), parse_wildcard_files(), PathIsDirectoryEmptyW(), pBuildFileList(), 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 1115 of file find.c.

{
    PFIND_DATA_HANDLE FindDataHandle = (PFIND_DATA_HANDLE)hFindStream;
    PFIND_STREAM_DATA FindStreamData;
 
    if (hFindStream == NULL || hFindStream == INVALID_HANDLE_VALUE ||
        FindDataHandle->Type != FindStream)
    {
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
 
    RtlEnterCriticalSection(&FindDataHandle->Lock);
 
    FindStreamData = FindDataHandle->u.FindStreamData;
 
    /* Select next stream if possible */
    if (FindStreamData->CurrentInfo->NextEntryOffset != 0)
    {
        FindStreamData->CurrentInfo = (PFILE_STREAM_INFORMATION)((ULONG_PTR)FindStreamData->CurrentInfo +
                                                                 FindStreamData->CurrentInfo->NextEntryOffset);
 
        /* Return the information */
        CopyStreamData(FindStreamData, lpFindStreamData);
 
        RtlLeaveCriticalSection(&FindDataHandle->Lock);
        return TRUE;
    }
    else
    {
        RtlLeaveCriticalSection(&FindDataHandle->Lock);
 
        SetLastError(ERROR_HANDLE_EOF);
        return FALSE;
    }
}