private void CommonInit()
{
Contract.Assert(searchCriteria != null && searchData != null, "searchCriteria and searchData should be initialized");
// Execute searchCriteria against the current directory
String searchPath = Path.InternalCombine(searchData.fullPath, searchCriteria);
Win32Native.WIN32_FIND_DATA data = new Win32Native.WIN32_FIND_DATA();
// Open a Find handle
#if MONO
int error;
_hnd = new SafeFindHandle(MonoIO.FindFirstFile(searchPath, out data.cFileName, out data.dwFileAttributes, out error));
#else
_hnd = Win32Native.FindFirstFile(searchPath, data);
#endif
if (_hnd.IsInvalid)
{
#if MONO
int hr = error;
#else
int hr = Marshal.GetLastWin32Error();
#endif
if (hr != Win32Native.ERROR_FILE_NOT_FOUND && hr != Win32Native.ERROR_NO_MORE_FILES)
{
HandleError(hr, searchData.fullPath);
}
else
{
// flag this as empty only if we're searching just top directory
// Used in fast path for top directory only
empty = searchData.searchOption == SearchOption.TopDirectoryOnly;
}
}
// fast path for TopDirectoryOnly. If we have a result, go ahead and set it to
// current. If empty, dispose handle.
if (searchData.searchOption == SearchOption.TopDirectoryOnly)
{
if (empty)
{
_hnd.Dispose();
}
else
{
SearchResult searchResult = CreateSearchResult(searchData, data);
if (_resultHandler.IsResultIncluded(searchResult))
{
current = _resultHandler.CreateObject(searchResult);
}
}
}
// for AllDirectories, we first recurse into dirs, so cleanup and add searchData
// to the stack
else
{
_hnd.Dispose();
searchStack.Add(searchData);
}
}
public void Dispose()
{
if (_hndFile != null)
{
_hndFile.Dispose();
_hndFile = null;
}
}
public void Dispose()
{
if (hndFile != null)
{
hndFile.Dispose();
hndFile = null;
}
}
private void CommonInit()
{
Debug.Assert(_searchCriteria != null, "searchCriteria should be initialized");
// Execute searchCriteria against the current directory
PathHelpers.ThrowIfEmptyOrRootedPath(_searchCriteria);
string searchPath = Path.Combine(_searchData.FullPath, _searchCriteria);
Interop.Kernel32.WIN32_FIND_DATA data = new Interop.Kernel32.WIN32_FIND_DATA();
using (new DisableMediaInsertionPrompt())
{
// Open a Find handle
_hnd = Interop.Kernel32.FindFirstFile(searchPath, ref data);
if (_hnd.IsInvalid)
{
int errorCode = Marshal.GetLastWin32Error();
if (errorCode != Interop.Errors.ERROR_FILE_NOT_FOUND && errorCode != Interop.Errors.ERROR_NO_MORE_FILES)
{
throw HandleError(errorCode, _searchData.FullPath);
}
else
{
// flag this as empty only if we're searching just top directory
// Used in fast path for top directory only
_empty = _searchOption == SearchOption.TopDirectoryOnly;
}
}
}
if (_searchOption == SearchOption.TopDirectoryOnly)
{
// fast path for TopDirectoryOnly. If we have a result, go ahead and set it to
// current. If empty, dispose handle.
if (_empty)
{
_hnd.Dispose();
}
else
{
TSource result;
if (IsResultIncluded(ref data, out result))
{
current = result;
}
}
}
else
{
// for AllDirectories, we first recurse into dirs, so cleanup and add searchData
// to the list
_hnd.Dispose();
_searchList = new List <PathPair>();
_searchList.Add(_searchData);
}
}
private void CommonInit()
{
Contract.Assert(_searchCriteria != null && _searchData != null, "searchCriteria and searchData should be initialized");
// Execute searchCriteria against the current directory
PathHelpers.ThrowIfEmptyOrRootedPath(_searchCriteria);
String searchPath = Path.Combine(_searchData.fullPath, _searchCriteria);
Interop.WIN32_FIND_DATA data = new Interop.WIN32_FIND_DATA();
// Open a Find handle
_hnd = Interop.mincore.FindFirstFile(searchPath, ref data);
if (_hnd.IsInvalid)
{
int errorCode = Marshal.GetLastWin32Error();
if (errorCode != Interop.ERROR_FILE_NOT_FOUND && errorCode != Interop.ERROR_NO_MORE_FILES)
{
HandleError(errorCode, _searchData.fullPath);
}
else
{
// flag this as empty only if we're searching just top directory
// Used in fast path for top directory only
_empty = _searchData.searchOption == SearchOption.TopDirectoryOnly;
}
}
// fast path for TopDirectoryOnly. If we have a result, go ahead and set it to
// current. If empty, dispose handle.
if (_searchData.searchOption == SearchOption.TopDirectoryOnly)
{
if (_empty)
{
_hnd.Dispose();
}
else
{
SearchResult searchResult = CreateSearchResult(_searchData, data);
if (_resultHandler.IsResultIncluded(searchResult))
{
current = _resultHandler.CreateObject(searchResult);
}
}
}
// for AllDirectories, we first recurse into dirs, so cleanup and add searchData
// to the stack
else
{
_hnd.Dispose();
_searchStack.Add(_searchData);
}
}
private void Init()
{
WIN32_FIND_DATAW findData = new WIN32_FIND_DATAW();
string searchPath = Path.Combine(searchData.path, "*");
handle = UnsafeNativeMethods.FindFirstFileExW(
searchPath,
infoLevel,
findData,
NativeEnums.FindExSearchOp.NameMatch,
IntPtr.Zero,
additionalFlags);
if (handle.IsInvalid)
{
handle.Dispose();
handle = null;
state = STATE_FINISH;
}
else
{
state = STATE_INIT;
if (FirstFileIncluded(findData))
{
current = CreateFilePath(findData);
}
}
}
/// <summary>
/// Performs application-defined tasks associated with freeing, releasing,
/// or resetting unmanaged resources.
/// </summary>
public void Dispose()
{
if (!m_hndFindFile.IsClosed)
{
m_hndFindFile.Dispose();
}
}
/// <summary>
/// Performs application-defined tasks associated with freeing, releasing,
/// or resetting unmanaged resources.
/// </summary>
public void Dispose()
{
if (m_hndFindFile != null)
{
m_hndFindFile.Dispose();
}
}
[System.Security.SecurityCritical] // auto-generated
private void AddSearchableDirsToStack(Directory.SearchData localSearchData)
{
Contract.Requires(localSearchData != null);
String searchPath = Path.Combine(localSearchData.fullPath, "*");
SafeFindHandle hnd = null;
Interop.WIN32_FIND_DATA data = new Interop.WIN32_FIND_DATA();
try
{
// Get all files and dirs
hnd = Interop.mincore.FindFirstFile(searchPath, ref data);
if (hnd.IsInvalid)
{
int errorCode = Marshal.GetLastWin32Error();
// This could happen if the dir doesn't contain any files.
// Continue with the recursive search though, eventually
// searchStack will become empty
if (errorCode == Interop.ERROR_FILE_NOT_FOUND || errorCode == Interop.ERROR_NO_MORE_FILES || errorCode == Interop.ERROR_PATH_NOT_FOUND)
{
return;
}
HandleError(errorCode, localSearchData.fullPath);
}
// Add subdirs to searchStack. Exempt ReparsePoints as appropriate
int incr = 0;
do
{
if (Win32FileSystemEnumerableHelpers.IsDir(data))
{
Contract.Assert(data.cFileName.Length != 0 && !Path.IsPathRooted(data.cFileName),
"Expected file system enumeration to not have empty file/directory name and not have rooted name");
String tempFullPath = Path.Combine(localSearchData.fullPath, data.cFileName);
String tempUserPath = Path.Combine(localSearchData.userPath, data.cFileName);
SearchOption option = localSearchData.searchOption;
// Setup search data for the sub directory and push it into the stack
Directory.SearchData searchDataSubDir = new Directory.SearchData(tempFullPath, tempUserPath, option);
_searchStack.Insert(incr++, searchDataSubDir);
}
} while (Interop.mincore.FindNextFile(hnd, ref data));
// We don't care about errors here
}
finally
{
if (hnd != null)
{
hnd.Dispose();
}
}
}
protected override void Dispose(bool disposing)
{
try
{
_hnd?.Dispose();
}
finally
{
base.Dispose(disposing);
}
}
/// <summary>
/// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
/// </summary>
public void Dispose()
{
if (!disposed)
{
disposed = true;
if (handle != null)
{
handle.Dispose();
handle = null;
}
if (shellLink != null)
{
shellLink.Dispose();
shellLink = null;
}
current = null;
state = -1;
SetErrorModeWrapper(oldErrorMode);
}
}
private void AddSearchableDirsToStack(Directory.SearchData localSearchData)
{
string fileName = Path.InternalCombine(localSearchData.fullPath, "*");
SafeFindHandle hndFindFile = (SafeFindHandle)null;
Win32Native.WIN32_FIND_DATA wiN32FindData = new Win32Native.WIN32_FIND_DATA();
try
{
hndFindFile = Win32Native.FindFirstFile(fileName, wiN32FindData);
if (hndFindFile.IsInvalid)
{
int lastWin32Error = Marshal.GetLastWin32Error();
switch (lastWin32Error)
{
case 2:
return;
case 18:
return;
case 3:
return;
default:
this.HandleError(lastWin32Error, localSearchData.fullPath);
break;
}
}
int num1 = 0;
do
{
if (FileSystemEnumerableHelpers.IsDir(wiN32FindData))
{
string fullPath = Path.InternalCombine(localSearchData.fullPath, wiN32FindData.cFileName);
string str = Path.InternalCombine(localSearchData.userPath, wiN32FindData.cFileName);
SearchOption searchOption = localSearchData.searchOption;
string userPath = str;
int num2 = (int)searchOption;
Directory.SearchData searchData = new Directory.SearchData(fullPath, userPath, (SearchOption)num2);
this.searchStack.Insert(num1++, searchData);
}
}while (Win32Native.FindNextFile(hndFindFile, wiN32FindData));
}
finally
{
if (hndFindFile != null)
{
hndFindFile.Dispose();
}
}
}
protected override void Dispose(bool disposing)
{
try
{
if (_hnd != null)
{
_hnd.Dispose();
}
}
finally
{
Win32Native.SetErrorMode(oldMode);
base.Dispose(disposing);
}
}
protected override void Dispose(bool disposing)
{
try
{
if (_hnd != null)
{
_hnd.Dispose();
}
}
finally
{
Interop.mincore.SetErrorMode(_oldMode);
base.Dispose(disposing);
}
}
protected override void Dispose(bool disposing)
{
try
{
if (_hnd != null)
{
_hnd.Dispose();
}
}
finally
{
#if !MONO // TODO: check if we need this on Windows
Win32Native.SetErrorMode(oldMode);
#endif
base.Dispose(disposing);
}
}
internal static List <AlternateStreamData> GetStreams(string path)
{
if (path == null)
{
throw new ArgumentNullException("path");
}
List <AlternateStreamData> list = new List <AlternateStreamData>();
AlternateStreamNativeData lpFindStreamData = new AlternateStreamNativeData();
SafeFindHandle hndFindFile = NativeMethods.FindFirstStreamW(path, NativeMethods.StreamInfoLevels.FindStreamInfoStandard, lpFindStreamData, 0);
if (hndFindFile.IsInvalid)
{
throw new Win32Exception();
}
try
{
do
{
AlternateStreamData data2;
lpFindStreamData.Name = lpFindStreamData.Name.Substring(1);
string b = ":$DATA";
if (!string.Equals(lpFindStreamData.Name, b, StringComparison.OrdinalIgnoreCase))
{
lpFindStreamData.Name = lpFindStreamData.Name.Replace(b, "");
}
data2 = new AlternateStreamData {
Stream = lpFindStreamData.Name,
Length = lpFindStreamData.Length,
};
data2.FileName = path.Replace(data2.Stream, "");
data2.FileName = data2.FileName.Trim(new char[] { ':' });
list.Add(data2);
lpFindStreamData = new AlternateStreamNativeData();
}while (NativeMethods.FindNextStreamW(hndFindFile, lpFindStreamData));
int error = Marshal.GetLastWin32Error();
if (error != 0x26)
{
throw new Win32Exception(error);
}
}
finally
{
hndFindFile.Dispose();
}
return(list);
}
protected override void Dispose(bool disposing)
{
try
{
if (_hnd != null)
{
_hnd.Dispose();
}
}
finally
{
if (_setBackOldMode)
{
uint _ignore;
Interop.Kernel32.SetThreadErrorMode(_oldMode, out _ignore);
}
base.Dispose(disposing);
}
}
private void AddSearchableDirsToStack(Directory.SearchData localSearchData)
{
string fileName = Path.InternalCombine(localSearchData.fullPath, "*");
SafeFindHandle safeFindHandle = null;
Win32Native.WIN32_FIND_DATA win32_FIND_DATA = default(Win32Native.WIN32_FIND_DATA);
try
{
safeFindHandle = Win32Native.FindFirstFile(fileName, ref win32_FIND_DATA);
if (safeFindHandle.IsInvalid)
{
int lastWin32Error = Marshal.GetLastWin32Error();
if (lastWin32Error == 2 || lastWin32Error == 18 || lastWin32Error == 3)
{
return;
}
this.HandleError(lastWin32Error, localSearchData.fullPath);
}
int num = 0;
do
{
if (win32_FIND_DATA.IsNormalDirectory)
{
string cFileName = win32_FIND_DATA.cFileName;
string text = Path.CombineNoChecks(localSearchData.fullPath, cFileName);
string text2 = Path.CombineNoChecks(localSearchData.userPath, cFileName);
SearchOption searchOption = localSearchData.searchOption;
Directory.SearchData item = new Directory.SearchData(text, text2, searchOption);
this.searchStack.Insert(num++, item);
}
}while (Win32Native.FindNextFile(safeFindHandle, ref win32_FIND_DATA));
}
finally
{
if (safeFindHandle != null)
{
safeFindHandle.Dispose();
}
}
}
[System.Security.SecurityCritical] // auto-generated
private void AddSearchableDirsToStack(Directory.SearchData localSearchData)
{
Contract.Requires(localSearchData != null);
String searchPath = Path.InternalCombine(localSearchData.fullPath, "*");
SafeFindHandle hnd = null;
Win32Native.WIN32_FIND_DATA data = new Win32Native.WIN32_FIND_DATA();
try
{
// Get all files and dirs
hnd = Win32Native.FindFirstFile(searchPath, data);
if (hnd.IsInvalid)
{
int hr = Marshal.GetLastWin32Error();
// This could happen if the dir doesn't contain any files.
// Continue with the recursive search though, eventually
// searchStack will become empty
if (hr == Win32Native.ERROR_FILE_NOT_FOUND || hr == Win32Native.ERROR_NO_MORE_FILES || hr == Win32Native.ERROR_PATH_NOT_FOUND)
{
return;
}
HandleError(hr, localSearchData.fullPath);
}
// Add subdirs to searchStack. Exempt ReparsePoints as appropriate
int incr = 0;
do
{
if (FileSystemEnumerableHelpers.IsDir(data))
{
String tempFullPath = Path.InternalCombine(localSearchData.fullPath, data.cFileName);
String tempUserPath = Path.InternalCombine(localSearchData.userPath, data.cFileName);
SearchOption option = localSearchData.searchOption;
#if EXCLUDE_REPARSEPOINTS
// Traverse reparse points depending on the searchoption specified
if ((searchDataSubDir.searchOption == SearchOption.AllDirectories) && (0 != (data.dwFileAttributes & Win32Native.FILE_ATTRIBUTE_REPARSE_POINT)))
{
option = SearchOption.TopDirectoryOnly;
}
#endif
// Setup search data for the sub directory and push it into the stack
Directory.SearchData searchDataSubDir = new Directory.SearchData(tempFullPath, tempUserPath, option);
searchStack.Insert(incr++, searchDataSubDir);
}
} while (Win32Native.FindNextFile(hnd, data));
// We don't care about errors here
}
finally
{
if (hnd != null)
{
hnd.Dispose();
}
}
}
public override bool MoveNext()
{
Win32Native.WIN32_FIND_DATA data = new Win32Native.WIN32_FIND_DATA();
switch (state)
{
case STATE_INIT:
{
if (empty)
{
state = STATE_FINISH;
goto case STATE_FINISH;
}
if (searchData.searchOption == SearchOption.TopDirectoryOnly)
{
state = STATE_FIND_NEXT_FILE;
if (current != null)
{
return(true);
}
else
{
goto case STATE_FIND_NEXT_FILE;
}
}
else
{
state = STATE_SEARCH_NEXT_DIR;
goto case STATE_SEARCH_NEXT_DIR;
}
}
case STATE_SEARCH_NEXT_DIR:
{
Contract.Assert(searchData.searchOption != SearchOption.TopDirectoryOnly, "should not reach this code path if searchOption == TopDirectoryOnly");
// Traverse directory structure. We need to get '*'
while (searchStack.Count > 0)
{
searchData = searchStack[0];
Contract.Assert((searchData.fullPath != null), "fullpath can't be null!");
searchStack.RemoveAt(0);
// Traverse the subdirs
AddSearchableDirsToStack(searchData);
// Execute searchCriteria against the current directory
String searchPath = Path.InternalCombine(searchData.fullPath, searchCriteria);
// Open a Find handle
_hnd = Win32Native.FindFirstFile(searchPath, data);
if (_hnd.IsInvalid)
{
int hr = Marshal.GetLastWin32Error();
if (hr == Win32Native.ERROR_FILE_NOT_FOUND || hr == Win32Native.ERROR_NO_MORE_FILES || hr == Win32Native.ERROR_PATH_NOT_FOUND)
{
continue;
}
_hnd.Dispose();
HandleError(hr, searchData.fullPath);
}
state = STATE_FIND_NEXT_FILE;
needsParentPathDiscoveryDemand = true;
SearchResult searchResult = CreateSearchResult(searchData, data);
if (_resultHandler.IsResultIncluded(searchResult))
{
if (needsParentPathDiscoveryDemand)
{
DoDemand(searchData.fullPath);
needsParentPathDiscoveryDemand = false;
}
current = _resultHandler.CreateObject(searchResult);
return(true);
}
else
{
goto case STATE_FIND_NEXT_FILE;
}
}
state = STATE_FINISH;
goto case STATE_FINISH;
}
case STATE_FIND_NEXT_FILE:
{
if (searchData != null && _hnd != null)
{
// Keep asking for more matching files/dirs, add it to the list
while (Win32Native.FindNextFile(_hnd, data))
{
SearchResult searchResult = CreateSearchResult(searchData, data);
if (_resultHandler.IsResultIncluded(searchResult))
{
if (needsParentPathDiscoveryDemand)
{
DoDemand(searchData.fullPath);
needsParentPathDiscoveryDemand = false;
}
current = _resultHandler.CreateObject(searchResult);
return(true);
}
}
// Make sure we quit with a sensible error.
int hr = Marshal.GetLastWin32Error();
if (_hnd != null)
{
_hnd.Dispose();
}
// ERROR_FILE_NOT_FOUND is valid here because if the top level
// dir doen't contain any subdirs and matching files then
// we will get here with this errorcode from the searchStack walk
if ((hr != 0) && (hr != Win32Native.ERROR_NO_MORE_FILES) &&
(hr != Win32Native.ERROR_FILE_NOT_FOUND))
{
HandleError(hr, searchData.fullPath);
}
}
if (searchData.searchOption == SearchOption.TopDirectoryOnly)
{
state = STATE_FINISH;
goto case STATE_FINISH;
}
else
{
state = STATE_SEARCH_NEXT_DIR;
goto case STATE_SEARCH_NEXT_DIR;
}
}
case STATE_FINISH:
{
Dispose();
break;
}
}
return(false);
}
[SecurityCritical] // auto-generated
private void AddSearchableDirsToList(PathPair localSearchData)
{
string searchPath = Path.Combine(localSearchData.FullPath, "*");
SafeFindHandle hnd = null;
Interop.mincore.WIN32_FIND_DATA data = new Interop.mincore.WIN32_FIND_DATA();
try
{
// Get all files and dirs
hnd = Interop.mincore.FindFirstFile(searchPath, ref data);
if (hnd.IsInvalid)
{
int errorCode = Marshal.GetLastWin32Error();
// This could happen if the dir doesn't contain any files.
// Continue with the recursive search though, eventually
// _searchList will become empty
if (errorCode == Interop.mincore.Errors.ERROR_FILE_NOT_FOUND || errorCode == Interop.mincore.Errors.ERROR_NO_MORE_FILES || errorCode == Interop.mincore.Errors.ERROR_PATH_NOT_FOUND)
{
return;
}
HandleError(errorCode, localSearchData.FullPath);
}
// Add subdirs to _searchList. Exempt ReparsePoints as appropriate
int initialCount = _searchList.Count;
do
{
if (Win32FileSystemEnumerableHelpers.IsDir(ref data))
{
Debug.Assert(data.cFileName.Length != 0 && !Path.IsPathRooted(data.cFileName),
"Expected file system enumeration to not have empty file/directory name and not have rooted name");
string tempFullPath = Path.Combine(localSearchData.FullPath, data.cFileName);
string tempUserPath = Path.Combine(localSearchData.UserPath, data.cFileName);
// Setup search data for the sub directory and push it into the list
PathPair searchDataSubDir = new PathPair(tempUserPath, tempFullPath);
Debug.Assert(_searchList != null, "_searchList should not be null");
_searchList.Add(searchDataSubDir);
}
} while (Interop.mincore.FindNextFile(hnd, ref data));
// Reverse the items just added to maintain FIFO order
if (_searchList.Count > initialCount)
{
_searchList.Reverse(initialCount, _searchList.Count - initialCount);
}
// We don't care about errors here
}
finally
{
if (hnd != null)
{
hnd.Dispose();
}
}
}
public override bool MoveNext()
{
Interop.mincore.WIN32_FIND_DATA data = new Interop.mincore.WIN32_FIND_DATA();
switch (state)
{
case STATE_INIT:
{
if (_empty)
{
state = STATE_FINISH;
goto case STATE_FINISH;
}
if (_searchOption == SearchOption.TopDirectoryOnly)
{
state = STATE_FIND_NEXT_FILE;
if (current != null)
{
return(true);
}
else
{
goto case STATE_FIND_NEXT_FILE;
}
}
else
{
state = STATE_SEARCH_NEXT_DIR;
goto case STATE_SEARCH_NEXT_DIR;
}
}
case STATE_SEARCH_NEXT_DIR:
{
Debug.Assert(_searchOption != SearchOption.TopDirectoryOnly, "should not reach this code path if searchOption == TopDirectoryOnly");
Debug.Assert(_searchList != null, "_searchList should not be null");
// Traverse directory structure. We need to get '*'
while (_searchList.Count > 0)
{
int index = _searchList.Count - 1;
_searchData = _searchList[index];
Debug.Assert((_searchData.FullPath != null), "fullpath can't be null!");
_searchList.RemoveAt(index);
// Traverse the subdirs
AddSearchableDirsToList(_searchData);
// Execute searchCriteria against the current directory
string searchPath = Path.Combine(_searchData.FullPath, _searchCriteria);
// Open a Find handle
_hnd = Interop.mincore.FindFirstFile(searchPath, ref data);
if (_hnd.IsInvalid)
{
int errorCode = Marshal.GetLastWin32Error();
if (errorCode == Interop.mincore.Errors.ERROR_FILE_NOT_FOUND || errorCode == Interop.mincore.Errors.ERROR_NO_MORE_FILES || errorCode == Interop.mincore.Errors.ERROR_PATH_NOT_FOUND)
{
continue;
}
_hnd.Dispose();
HandleError(errorCode, _searchData.FullPath);
}
state = STATE_FIND_NEXT_FILE;
TSource result;
if (IsResultIncluded(ref data, out result))
{
current = result;
return(true);
}
else
{
goto case STATE_FIND_NEXT_FILE;
}
}
state = STATE_FINISH;
goto case STATE_FINISH;
}
case STATE_FIND_NEXT_FILE:
{
if (_hnd != null)
{
// Keep asking for more matching files/dirs, add it to the list
while (Interop.mincore.FindNextFile(_hnd, ref data))
{
TSource result;
if (IsResultIncluded(ref data, out result))
{
current = result;
return(true);
}
}
// Make sure we quit with a sensible error.
int errorCode = Marshal.GetLastWin32Error();
if (_hnd != null)
{
_hnd.Dispose();
}
// ERROR_FILE_NOT_FOUND is valid here because if the top level
// dir doesn't contain any subdirs and matching files then
// we will get here with this errorcode from the _searchList walk
if ((errorCode != 0) && (errorCode != Interop.mincore.Errors.ERROR_NO_MORE_FILES) &&
(errorCode != Interop.mincore.Errors.ERROR_FILE_NOT_FOUND))
{
HandleError(errorCode, _searchData.FullPath);
}
}
if (_searchOption == SearchOption.TopDirectoryOnly)
{
state = STATE_FINISH;
goto case STATE_FINISH;
}
else
{
state = STATE_SEARCH_NEXT_DIR;
goto case STATE_SEARCH_NEXT_DIR;
}
}
case STATE_FINISH:
{
Dispose();
break;
}
}
return(false);
}
/// <summary>
/// Performs application-defined tasks associated with freeing, releasing,
/// or resetting unmanaged resources.
/// </summary>
public void Dispose()
{
_mHndFindFile?.Dispose();
}
public static IEnumerable <DirEntry> Entries(string startDir, Action <int, string> DirErrorHandler, int maxDepth, Predicate <string> EnterDir, bool FollowJunctions)
{
// expand directory to "unicode" convention
StringBuilder dir = new StringBuilder(Long.GetLongFilenameNotation(startDir));
int baseDirLength = dir.Length;
SafeFindHandle SearchHandle = null;
Stack <Internal_DirInfo> dirStack = new Stack <Internal_DirInfo>();
int depth = 0;
Spi.Native.Win32.WIN32_FIND_DATA find_data;
bool findFirstFile = true;
do
{
if (findFirstFile)
{
findFirstFile = false;
dir.Append("\\*");
SearchHandle = Win32.FindFirstFile(dir.ToString(), out find_data);
dir.Length -= 2; // remove \* added before
if (SearchHandle.IsInvalid)
{
if (DirErrorHandler != null)
{
DirErrorHandler(Marshal.GetLastWin32Error(), dir.ToString());
}
StepBack(ref dir, ref dirStack, out SearchHandle, ref depth);
continue;
}
}
else
{
if (!Spi.Native.Win32.FindNextFile(SearchHandle, out find_data))
{
SearchHandle.Dispose();
StepBack(ref dir, ref dirStack, out SearchHandle, ref depth);
continue;
}
}
if (IsDirectoryFlagSet(find_data.dwFileAttributes)) // is a dir
{
if (IsDotOrDotDotDirectory(find_data.cFileName))
{
continue;
}
if (WalkIntoDir(ref find_data, EnterDir, FollowJunctions))
{
yield return(new DirEntry(dir, find_data, baseDirLength));
//
// go down if depth is ok
//
if (maxDepth == -1 || depth < maxDepth)
{
depth++;
dirStack.Push(new Internal_DirInfo()
{
DirnameLength = find_data.cFileName.Length, handle = SearchHandle
});
dir.Append("\\").Append(find_data.cFileName);
findFirstFile = true;
}
}
}
else
{
yield return(new DirEntry(dir, find_data, baseDirLength));
}
} while (SearchHandle != null);
}
/// <summary>
/// Advances the enumerator to the next element of the collection.
/// </summary>
/// <returns>
/// true if the enumerator was successfully advanced to the next element; false if the enumerator has passed the end of the collection.
/// </returns>
public bool MoveNext()
{
WIN32_FIND_DATAW findData = new WIN32_FIND_DATAW();
switch (state)
{
case STATE_INIT:
state = STATE_FIND_FILES;
if (current != null)
{
return true;
}
else
{
goto case STATE_FIND_FILES;
}
case STATE_FIND_FILES:
do
{
if (handle == null)
{
searchData = searchDirectories.Dequeue();
string searchPath = Path.Combine(searchData.path, "*");
handle = UnsafeNativeMethods.FindFirstFileExW(
searchPath,
infoLevel,
findData,
NativeEnums.FindExSearchOp.NameMatch,
IntPtr.Zero,
additionalFlags);
if (handle.IsInvalid)
{
handle.Dispose();
handle = null;
if (searchDirectories.Count > 0)
{
continue;
}
else
{
state = STATE_FINISH;
goto case STATE_FINISH;
}
}
needPathDiscoveryDemand = true;
if (FirstFileIncluded(findData))
{
current = CreateFilePath(findData);
return true;
}
}
while (UnsafeNativeMethods.FindNextFileW(handle, findData))
{
if ((findData.dwFileAttributes & NativeConstants.FILE_ATTRIBUTE_DIRECTORY) == 0)
{
if (IsFileIncluded(findData))
{
current = CreateFilePath(findData);
return true;
}
}
else if (searchOption == SearchOption.AllDirectories && !findData.cFileName.Equals(".") && !findData.cFileName.Equals(".."))
{
searchDirectories.Enqueue(new SearchData(searchData, findData.cFileName));
}
}
handle.Dispose();
handle = null;
} while (searchDirectories.Count > 0);
state = STATE_FINISH;
goto case STATE_FINISH;
case STATE_FINISH:
Dispose();
break;
}
return false;
}
/// <summary>
/// Gets the files.
/// </summary>
/// <param name="dir">The dir.</param>
/// <param name="pattern">The pattern.</param>
/// <param name="searchOption">The search option.</param>
/// <returns></returns>
public static IEnumerable <FileInfo> GetFiles(DirectoryInfo dir, string pattern, SearchOption searchOption)
{
// We suppressed this demand for each p/invoke call, so demand it upfront once
new SecurityPermission(SecurityPermissionFlag.UnmanagedCode).Demand();
// Validate parameters
if (dir == null)
{
throw new ArgumentNullException("dir");
}
if (pattern == null)
{
throw new ArgumentNullException("pattern");
}
// Setup
WIN32_FIND_DATA findData = new WIN32_FIND_DATA();
Stack <DirectoryInfo> directories = new Stack <DirectoryInfo>();
directories.Push(dir);
// Process each directory
ErrorModes origErrorMode = SetErrorMode(ErrorModes.FailCriticalErrors);
try
{
while (directories.Count > 0)
{
// Get the name of the next directory and the corresponding search pattern
dir = directories.Pop();
string dirPath = dir.FullName.Trim();
if (dirPath.Length == 0)
{
continue;
}
char lastChar = dirPath[dirPath.Length - 1];
if (lastChar != Path.DirectorySeparatorChar && lastChar != Path.AltDirectorySeparatorChar)
{
dirPath += Path.DirectorySeparatorChar;
}
// Process all files in that directory
SafeFindHandle handle = FindFirstFile(dirPath + pattern, findData);
if (handle.IsInvalid)
{
int error = Marshal.GetLastWin32Error();
if (error == ERROR_ACCESS_DENIED)
{
continue;
}
else if (error != ERROR_FILE_NOT_FOUND)
{
throw new Win32Exception(error);
}
}
else
{
try
{
do
{
if ((findData.dwFileAttributes & FileAttributes.Directory) == 0)
{
yield return(new FileInfo(dirPath + findData.cFileName));
}
}while (FindNextFile(handle, findData));
int error = Marshal.GetLastWin32Error();
if (error != ERROR_NO_MORE_FILES)
{
throw new Win32Exception(error);
}
}
finally { handle.Dispose(); }
}
// Add all child directories if that's what the user wants
if (searchOption == SearchOption.AllDirectories)
{
foreach (DirectoryInfo childDir in dir.GetDirectories())
{
if ((File.GetAttributes(childDir.FullName) & FileAttributes.ReparsePoint) == 0)
{
directories.Push(childDir);
}
}
}
}
}
finally { SetErrorMode(origErrorMode); }
}
public static IEnumerable <FileSystemInfo> GetFileSystemInfos(DirectoryInfo dir, string pattern, SearchOption searchOption, bool includeDirectories, bool includeFiles)
{
// We suppressed this demand for each p/invoke call, so demand it upfront once
new SecurityPermission(SecurityPermissionFlag.UnmanagedCode).Demand();
// Validate parameters
if (dir == null)
{
throw new ArgumentNullException("dir");
}
if (pattern == null)
{
throw new ArgumentNullException("pattern");
}
// Setup
WIN32_FIND_DATA findData = new WIN32_FIND_DATA();
Stack <DirectoryInfo> directories = new Stack <DirectoryInfo>();
directories.Push(dir);
// Process each directory
ErrorModes origErrorMode = SetErrorMode(ErrorModes.FailCriticalErrors);
try
{
while (directories.Count > 0)
{
// Get the name of the next directory and the corresponding search pattern
dir = directories.Pop();
string dirPath = dir.FullName.Trim();
if (dirPath.Length == 0)
{
continue;
}
char lastChar = dirPath[dirPath.Length - 1];
if (lastChar != Path.DirectorySeparatorChar && lastChar != Path.AltDirectorySeparatorChar)
{
dirPath += Path.DirectorySeparatorChar;
}
// Process all files in that directory
SafeFindHandle handle = FindFirstFile(dirPath + pattern, findData);
if (handle.IsInvalid)
{
int error = Marshal.GetLastWin32Error();
if (error == ERROR_ACCESS_DENIED ||
error == ERROR_FILE_NOT_FOUND)
{
continue;
}
else
{
throw new Win32Exception(error);
}
}
else
{
try
{
do
{
if ((findData.dwFileAttributes & FileAttributes.Directory) == 0)
{
if (includeFiles)
{
yield return(new FileInfo(dirPath + findData.cFileName));
}
}
else
{
if (includeDirectories && findData.cFileName != "." && findData.cFileName != "..")
{
yield return(new DirectoryInfo(dirPath + findData.cFileName));
}
}
}while (FindNextFile(handle, findData));
int error = Marshal.GetLastWin32Error();
if (error != ERROR_NO_MORE_FILES)
{
throw new Win32Exception(error);
}
}
finally { handle.Dispose(); }
}
// Add all child directories if that's what the user wants
if (searchOption == SearchOption.AllDirectories)
{
try
{
foreach (DirectoryInfo childDir in GetDirectories(dir, "*", SearchOption.TopDirectoryOnly)) //Top only, as we're all ready handling recursion here.
{
try
{
if ((File.GetAttributes(childDir.FullName) & FileAttributes.ReparsePoint) == 0)
{
directories.Push(childDir);
}
}
catch (Exception childDirEx)
{
//Can't get subfolders
System.Diagnostics.Trace.WriteLine("Can't search inside: " + childDir.Name);
System.Diagnostics.Trace.Indent();
System.Diagnostics.Trace.WriteLine(childDirEx.Message);
System.Diagnostics.Trace.Unindent();
}
}
}
catch (Exception e)
{
//Can't get subfolders
System.Diagnostics.Trace.WriteLine("Can't search inside: " + dirPath);
System.Diagnostics.Trace.Indent();
System.Diagnostics.Trace.WriteLine(e.Message);
System.Diagnostics.Trace.Unindent();
}
}
}
}
finally { SetErrorMode(origErrorMode); }
}
/// <summary> /// Performs application-defined tasks associated with freeing, releasing, /// or resetting unmanaged resources. /// </summary> public void Dispose() => _hndFindFile?.Dispose();
[System.Security.SecurityCritical] // auto-generated
internal static int FillAttributeInfo(String path, ref Interop.mincore.WIN32_FILE_ATTRIBUTE_DATA data, bool tryagain, bool returnErrorOnNotFound)
{
int errorCode = 0;
if (tryagain) // someone has a handle to the file open, or other error
{
Interop.mincore.WIN32_FIND_DATA findData;
findData = new Interop.mincore.WIN32_FIND_DATA();
// Remove trialing slash since this can cause grief to FindFirstFile. You will get an invalid argument error
String tempPath = path.TrimEnd(PathHelpers.DirectorySeparatorChars);
// For floppy drives, normally the OS will pop up a dialog saying
// there is no disk in drive A:, please insert one. We don't want that.
// SetErrorMode will let us disable this, but we should set the error
// mode back, since this may have wide-ranging effects.
uint oldMode = Interop.mincore.SetErrorMode(Interop.mincore.SEM_FAILCRITICALERRORS);
try
{
bool error = false;
SafeFindHandle handle = Interop.mincore.FindFirstFile(tempPath, ref findData);
try
{
if (handle.IsInvalid)
{
error = true;
errorCode = Marshal.GetLastWin32Error();
if (errorCode == Interop.mincore.Errors.ERROR_FILE_NOT_FOUND ||
errorCode == Interop.mincore.Errors.ERROR_PATH_NOT_FOUND ||
errorCode == Interop.mincore.Errors.ERROR_NOT_READY) // floppy device not ready
{
if (!returnErrorOnNotFound)
{
// Return default value for backward compatibility
errorCode = 0;
data.fileAttributes = -1;
}
}
return(errorCode);
}
}
finally
{
// Close the Win32 handle
try
{
handle.Dispose();
}
catch
{
// if we're already returning an error, don't throw another one.
if (!error)
{
throw Win32Marshal.GetExceptionForLastWin32Error();
}
}
}
}
finally
{
Interop.mincore.SetErrorMode(oldMode);
}
// Copy the information to data
data.PopulateFrom(ref findData);
}
else
{
// For floppy drives, normally the OS will pop up a dialog saying
// there is no disk in drive A:, please insert one. We don't want that.
// SetErrorMode will let us disable this, but we should set the error
// mode back, since this may have wide-ranging effects.
bool success = false;
uint oldMode = Interop.mincore.SetErrorMode(Interop.mincore.SEM_FAILCRITICALERRORS);
try
{
success = Interop.mincore.GetFileAttributesEx(path, Interop.mincore.GET_FILEEX_INFO_LEVELS.GetFileExInfoStandard, ref data);
}
finally
{
Interop.mincore.SetErrorMode(oldMode);
}
if (!success)
{
errorCode = Marshal.GetLastWin32Error();
if (errorCode != Interop.mincore.Errors.ERROR_FILE_NOT_FOUND &&
errorCode != Interop.mincore.Errors.ERROR_PATH_NOT_FOUND &&
errorCode != Interop.mincore.Errors.ERROR_NOT_READY) // floppy device not ready
{
// In case someone latched onto the file. Take the perf hit only for failure
return(FillAttributeInfo(path, ref data, true, returnErrorOnNotFound));
}
else
{
if (!returnErrorOnNotFound)
{
// Return default value for backward compatibility
errorCode = 0;
data.fileAttributes = -1;
}
}
}
}
return(errorCode);
}
static internal IEnumerable <FileSystemInfo> EnumerateFileSystemInfos(string basePath, string searchPattern, SearchOption searchOption)
{
Path.Validate(basePath);
SafeFindHandle findHandle = null;
try {
string filePath;
int nativeAttrs;
string basePathWithPattern = Path.Combine(basePath, searchPattern);
int nativeError;
try {} finally {
findHandle = new SafeFindHandle(MonoIO.FindFirstFile(basePathWithPattern, out filePath, out nativeAttrs, out nativeError));
}
if (findHandle.IsInvalid)
{
MonoIOError error = (MonoIOError)nativeError;
if (error != MonoIOError.ERROR_FILE_NOT_FOUND)
{
throw MonoIO.GetException(Path.GetDirectoryName(basePathWithPattern), error);
}
yield break;
}
do
{
if (filePath == null)
{
yield break;
}
if (filePath == "." || filePath == "..")
{
continue;
}
FileAttributes attrs = (FileAttributes)nativeAttrs;
string fullPath = Path.Combine(basePath, filePath);
if ((attrs & FileAttributes.ReparsePoint) == 0)
{
if ((attrs & FileAttributes.Directory) != 0)
{
yield return(new DirectoryInfo(fullPath));
}
else
{
yield return(new FileInfo(fullPath));
}
}
if ((attrs & FileAttributes.Directory) != 0 && searchOption == SearchOption.AllDirectories)
{
foreach (FileSystemInfo child in EnumerateFileSystemInfos(fullPath, searchPattern, searchOption))
{
yield return(child);
}
}
} while (MonoIO.FindNextFile(findHandle.DangerousGetHandle(), out filePath, out nativeAttrs, out int _));
} finally {
if (findHandle != null)
{
findHandle.Dispose();
}
}
}
