483 lines
18 KiB
C#
483 lines
18 KiB
C#
// Decompiled with JetBrains decompiler
|
|
// Type: Rei.Fs.IO.FileSystem
|
|
// Assembly: Rei.Fs, Version=1.13.2.8796, Culture=neutral, PublicKeyToken=null
|
|
// MVID: D8B08A8B-697C-4439-9CFF-1BE4EE46F7B0
|
|
// Assembly location: F:\Eigene Dateien\Dropbox\portable Collection\Progs\CarotDAV\Rei.Fs.dll
|
|
|
|
using Microsoft.VisualBasic.CompilerServices;
|
|
using Microsoft.Win32.SafeHandles;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel;
|
|
using System.IO;
|
|
using System.Runtime.InteropServices;
|
|
using System.Text;
|
|
|
|
namespace Rei.Fs.IO
|
|
{
|
|
[StandardModule]
|
|
public sealed class FileSystem
|
|
{
|
|
private static DateTime win32timeorigin = new DateTime(1601, 1, 1, 0, 0, 0, DateTimeKind.Utc);
|
|
|
|
public static string CombinePath(string path1, string path2)
|
|
{
|
|
if (path1.EndsWith("\\"))
|
|
{
|
|
if (path2.StartsWith("\\"))
|
|
return path1 + path2.Substring(1);
|
|
return path1 + path2;
|
|
}
|
|
if (path2.StartsWith("\\"))
|
|
return path1 + path2;
|
|
return path1 + "\\" + path2;
|
|
}
|
|
|
|
public static string GetFilename(string path)
|
|
{
|
|
while (path.EndsWith("\\"))
|
|
path = path.Substring(0, checked (path.Length - 1));
|
|
int num = path.LastIndexOf("\\");
|
|
if (num < 0)
|
|
return path;
|
|
return path.Substring(checked (num + 1));
|
|
}
|
|
|
|
public static string GetDirectoryName(string path)
|
|
{
|
|
while (path.EndsWith("\\"))
|
|
path = path.Substring(0, checked (path.Length - 1));
|
|
int length = path.LastIndexOf("\\");
|
|
if (length < 0)
|
|
return path;
|
|
return path.Substring(0, length);
|
|
}
|
|
|
|
public static string NormalizePath(string path)
|
|
{
|
|
if (path.StartsWith("\\\\?\\"))
|
|
return path;
|
|
string str1 = path;
|
|
if (str1.Length >= 248)
|
|
;
|
|
string str2 = str1.Replace("/", "\\");
|
|
if (str2.StartsWith("\\\\"))
|
|
path = "\\\\?\\UNC\\" + str2.Substring(1);
|
|
else if (path.Length > 3 && Operators.CompareString(Conversions.ToString(path[1]), ":", false) == 0 && Operators.CompareString(Conversions.ToString(path[2]), "\\", false) == 0)
|
|
path = "\\\\?\\" + str2.Replace("/", "\\");
|
|
else if (Operators.CompareString(Conversions.ToString(path[0]), "\\", false) == 0)
|
|
path = "\\\\?\\" + str2.Replace("/", "\\");
|
|
return path;
|
|
}
|
|
|
|
public static System.Runtime.InteropServices.ComTypes.FILETIME ToFileTime(DateTime time)
|
|
{
|
|
byte[] bytes = BitConverter.GetBytes(DateTime.Compare(time, FileSystem.win32timeorigin) >= 0 ? time.ToFileTime() : 0L);
|
|
System.Runtime.InteropServices.ComTypes.FILETIME filetime;
|
|
filetime.dwHighDateTime = BitConverter.ToInt32(bytes, 4);
|
|
filetime.dwLowDateTime = BitConverter.ToInt32(bytes, 0);
|
|
return filetime;
|
|
}
|
|
|
|
private static void RaiseError(string path)
|
|
{
|
|
FileSystem.RaiseError(path, Marshal.GetLastWin32Error());
|
|
}
|
|
|
|
private static void RaiseError(string path, int code)
|
|
{
|
|
switch (code)
|
|
{
|
|
case 2:
|
|
throw new FileNotFoundException();
|
|
case 3:
|
|
throw new DirectoryNotFoundException();
|
|
case 5:
|
|
throw new UnauthorizedAccessException();
|
|
case 15:
|
|
throw new DriveNotFoundException();
|
|
default:
|
|
throw new IOException(new Win32Exception(code).Message);
|
|
}
|
|
}
|
|
|
|
public static FileInfo GetFileInfo(string path)
|
|
{
|
|
FileInfo info = (FileInfo) null;
|
|
if (!FileSystem.TryGetFileInfo(path, ref info))
|
|
FileSystem.RaiseError(path);
|
|
return info;
|
|
}
|
|
|
|
public static bool TryGetFileInfo(string path, ref FileInfo info)
|
|
{
|
|
string path1 = FileSystem.NormalizePath(path);
|
|
Win32Native.WIN32_FILE_ATTRIBUTE_DATA fileData=new Win32Native.WIN32_FILE_ATTRIBUTE_DATA();
|
|
if (!Win32Native.GetFileAttributesEx(FileSystem.NormalizePath(path), Win32Native.GET_FILEEX_INFO_LEVELS.GetFileExInfoStandard, ref fileData))
|
|
{
|
|
switch (Marshal.GetLastWin32Error())
|
|
{
|
|
case 2:
|
|
case 3:
|
|
case 50:
|
|
case 67:
|
|
return false;
|
|
default:
|
|
throw new ArgumentOutOfRangeException("TryGetFileInfo error path:" + path + " error:" + Conversions.ToString(Marshal.GetLastWin32Error()));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
info = new FileInfo(path1, fileData);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
public static bool FileOrDirectoryExists(string path, ref bool isdirectory)
|
|
{
|
|
Win32Native.ErrorModeType uMode = Win32Native.SetErrorMode(Win32Native.ErrorModeType.SEM_FAILCRITICALERRORS);
|
|
Win32Native.WIN32_FILE_ATTRIBUTE_DATA fileData = new Win32Native.WIN32_FILE_ATTRIBUTE_DATA();
|
|
bool fileAttributesEx;
|
|
try
|
|
{
|
|
fileAttributesEx = Win32Native.GetFileAttributesEx(FileSystem.NormalizePath(path), Win32Native.GET_FILEEX_INFO_LEVELS.GetFileExInfoStandard, ref fileData);
|
|
}
|
|
finally
|
|
{
|
|
int num = (int) Win32Native.SetErrorMode(uMode);
|
|
}
|
|
if (!fileAttributesEx)
|
|
{
|
|
int lastWin32Error = Marshal.GetLastWin32Error();
|
|
switch (lastWin32Error)
|
|
{
|
|
case 2:
|
|
case 3:
|
|
break;
|
|
default:
|
|
throw new ArgumentOutOfRangeException(path + " " + lastWin32Error.ToString());
|
|
}
|
|
}
|
|
else
|
|
isdirectory = (fileData.dwFileAttributes & FileAttributes.Directory) != (FileAttributes) 0;
|
|
return fileAttributesEx;
|
|
}
|
|
|
|
public static bool FileExists(string path)
|
|
{
|
|
Win32Native.ErrorModeType uMode = Win32Native.SetErrorMode(Win32Native.ErrorModeType.SEM_FAILCRITICALERRORS);
|
|
Win32Native.WIN32_FILE_ATTRIBUTE_DATA fileData = new Win32Native.WIN32_FILE_ATTRIBUTE_DATA();
|
|
bool fileAttributesEx;
|
|
try
|
|
{
|
|
fileAttributesEx = Win32Native.GetFileAttributesEx(FileSystem.NormalizePath(path), Win32Native.GET_FILEEX_INFO_LEVELS.GetFileExInfoStandard, ref fileData);
|
|
}
|
|
finally
|
|
{
|
|
int num = (int) Win32Native.SetErrorMode(uMode);
|
|
}
|
|
if (!fileAttributesEx)
|
|
{
|
|
switch (Marshal.GetLastWin32Error())
|
|
{
|
|
case 2:
|
|
case 3:
|
|
break;
|
|
default:
|
|
throw new ArgumentOutOfRangeException(path);
|
|
}
|
|
}
|
|
return fileAttributesEx && (fileData.dwFileAttributes & FileAttributes.Directory) == (FileAttributes) 0;
|
|
}
|
|
|
|
public static bool DirectoryExists(string path)
|
|
{
|
|
Win32Native.ErrorModeType uMode = Win32Native.SetErrorMode(Win32Native.ErrorModeType.SEM_FAILCRITICALERRORS);
|
|
Win32Native.WIN32_FILE_ATTRIBUTE_DATA fileData = new Win32Native.WIN32_FILE_ATTRIBUTE_DATA();
|
|
bool fileAttributesEx;
|
|
try
|
|
{
|
|
fileAttributesEx = Win32Native.GetFileAttributesEx(FileSystem.NormalizePath(path), Win32Native.GET_FILEEX_INFO_LEVELS.GetFileExInfoStandard, ref fileData);
|
|
}
|
|
finally
|
|
{
|
|
int num = (int) Win32Native.SetErrorMode(uMode);
|
|
}
|
|
if (!fileAttributesEx)
|
|
{
|
|
switch (Marshal.GetLastWin32Error())
|
|
{
|
|
case 2:
|
|
case 3:
|
|
break;
|
|
default:
|
|
throw new ArgumentOutOfRangeException(path);
|
|
}
|
|
}
|
|
return fileAttributesEx && (fileData.dwFileAttributes & FileAttributes.Directory) != (FileAttributes) 0;
|
|
}
|
|
|
|
public static string[] GetNetworkShare(string host)
|
|
{
|
|
List<string> stringList = new List<string>();
|
|
int entriesread = 0;
|
|
int totalentries = 0;
|
|
int resume_handle = 0;
|
|
int num1 = Marshal.SizeOf(typeof (Win32Native.SHARE_INFO_0));
|
|
IntPtr zero = IntPtr.Zero;
|
|
int hresult = Win32Native.NetShareEnum(new StringBuilder(host), 0, ref zero, uint.MaxValue, ref entriesread, ref totalentries, ref resume_handle);
|
|
if (hresult != 0)
|
|
throw new IOException("unknown error", hresult);
|
|
try
|
|
{
|
|
IntPtr ptr = zero;
|
|
int num2 = 0;
|
|
int num3 = checked (entriesread - 1);
|
|
int num4 = num2;
|
|
while (num4 <= num3)
|
|
{
|
|
object structure = Marshal.PtrToStructure(ptr, typeof (Win32Native.SHARE_INFO_0));
|
|
Win32Native.SHARE_INFO_0 shareInfo0_1=new Win32Native.SHARE_INFO_0();
|
|
Win32Native.SHARE_INFO_0 shareInfo0_2 = structure != null ? (Win32Native.SHARE_INFO_0) structure : shareInfo0_1;
|
|
stringList.Add(shareInfo0_2.shi0_netname);
|
|
ptr = new IntPtr(checked (ptr.ToInt32() + num1));
|
|
checked { ++num4; }
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
Win32Native.NetApiBufferFree(zero);
|
|
}
|
|
return stringList.ToArray();
|
|
}
|
|
|
|
public static SafeFileHandle CreateFile(string path, FileAccess access, FileShare share, FileMode mode)
|
|
{
|
|
return FileSystem.CreateFile(path, access, share, mode, 128U);
|
|
}
|
|
|
|
public static SafeFileHandle CreateFile(string path, FileAccess access, FileShare share, FileMode mode, uint dwFlagsAndAttributes)
|
|
{
|
|
SafeFileHandle file;
|
|
if (mode == FileMode.Append)
|
|
{
|
|
file = Win32Native.CreateFile(FileSystem.NormalizePath(path), checked ((uint) access), checked ((uint) share), IntPtr.Zero, 4U, dwFlagsAndAttributes | 268435456U, IntPtr.Zero);
|
|
if (!file.IsInvalid)
|
|
{
|
|
int num = (int) Win32Native.SetFilePointer(file, 0, IntPtr.Zero, Win32Native.MoveMethodType.FILE_END);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
uint dwDesiredAccess=0;
|
|
if (access == FileAccess.Read)
|
|
dwDesiredAccess = 2147483648U;
|
|
else if (access == FileAccess.Write)
|
|
dwDesiredAccess = 1073741824U;
|
|
else if (access == FileAccess.ReadWrite)
|
|
dwDesiredAccess = 268435456U;
|
|
file = Win32Native.CreateFile(FileSystem.NormalizePath(path), dwDesiredAccess, checked ((uint) share), IntPtr.Zero, checked ((uint) mode), dwFlagsAndAttributes, IntPtr.Zero);
|
|
}
|
|
if (file.IsInvalid)
|
|
FileSystem.RaiseError(path);
|
|
return file;
|
|
}
|
|
|
|
public static Stream OpenRead(string path)
|
|
{
|
|
return (Stream) new FileStream(FileSystem.CreateFile(path, FileAccess.Read, FileShare.Read, FileMode.Open), FileAccess.Read);
|
|
}
|
|
|
|
public static void SetFileTime(string path, DateTime creationtime, DateTime accesstime, DateTime writetime)
|
|
{
|
|
if (DateTime.Compare(creationtime, DateTime.MinValue) == 0 && DateTime.Compare(accesstime, DateTime.MinValue) == 0 && DateTime.Compare(writetime, DateTime.MinValue) == 0)
|
|
return;
|
|
while (path.EndsWith("\\"))
|
|
path = path.Substring(0, checked (path.Length - 1));
|
|
using (SafeFileHandle file = Win32Native.CreateFile(FileSystem.NormalizePath(path), 256U, 0U, IntPtr.Zero, 3U, 33554432U, IntPtr.Zero))
|
|
{
|
|
if (file.IsInvalid)
|
|
FileSystem.RaiseError(path);
|
|
System.Runtime.InteropServices.ComTypes.FILETIME lpCreationTime = new System.Runtime.InteropServices.ComTypes.FILETIME();
|
|
System.Runtime.InteropServices.ComTypes.FILETIME lpLastAccessTime = new System.Runtime.InteropServices.ComTypes.FILETIME();
|
|
System.Runtime.InteropServices.ComTypes.FILETIME lpLastWriteTime = new System.Runtime.InteropServices.ComTypes.FILETIME();
|
|
if (DateTime.Compare(creationtime, DateTime.MinValue) > 0)
|
|
lpCreationTime = FileSystem.ToFileTime(creationtime);
|
|
if (DateTime.Compare(accesstime, DateTime.MinValue) > 0)
|
|
lpLastAccessTime = FileSystem.ToFileTime(accesstime);
|
|
if (DateTime.Compare(writetime, DateTime.MinValue) > 0)
|
|
lpLastWriteTime = FileSystem.ToFileTime(writetime);
|
|
if (Win32Native.SetFileTime(file, ref lpCreationTime, ref lpLastAccessTime, ref lpLastWriteTime))
|
|
return;
|
|
FileSystem.RaiseError(path);
|
|
}
|
|
}
|
|
|
|
public static FileInfo[] ListDirectoryEntries(string directorypath)
|
|
{
|
|
if (string.IsNullOrEmpty(directorypath))
|
|
throw new ArgumentNullException();
|
|
directorypath = directorypath.EndsWith("\\") || directorypath.EndsWith("/") ? FileSystem.CombinePath(directorypath, "*") : FileSystem.CombinePath(directorypath, "\\*");
|
|
return FileSystem.FindFiles(directorypath);
|
|
}
|
|
|
|
public static FileInfo[] FindFiles(string path)
|
|
{
|
|
List<FileInfo> fileInfoList = new List<FileInfo>();
|
|
Win32Native.WIN32_FIND_DATA lpFindFileData = new Win32Native.WIN32_FIND_DATA();
|
|
int length = path.LastIndexOf("\\");
|
|
int num = path.LastIndexOf("/");
|
|
if (num > length)
|
|
length = num;
|
|
string path1 = length >= 0 ? path.Substring(0, length) : Environment.CurrentDirectory;
|
|
using (SafeFindHandle firstFile = Win32Native.FindFirstFile(FileSystem.NormalizePath(path), out lpFindFileData))
|
|
{
|
|
if (firstFile.IsInvalid)
|
|
FileSystem.RaiseError(path);
|
|
do
|
|
{
|
|
if (Operators.CompareString(lpFindFileData.cFileName, ".", false) != 0 && Operators.CompareString(lpFindFileData.cFileName, "..", false) != 0)
|
|
fileInfoList.Add(new FileInfo(FileSystem.CombinePath(path1, lpFindFileData.cFileName), lpFindFileData));
|
|
}
|
|
while (Win32Native.FindNextFile(firstFile, out lpFindFileData));
|
|
int lastWin32Error = Marshal.GetLastWin32Error();
|
|
if (lastWin32Error != 18)
|
|
FileSystem.RaiseError(path, lastWin32Error);
|
|
}
|
|
return fileInfoList.ToArray();
|
|
}
|
|
|
|
public static void CreateDirectory(string path)
|
|
{
|
|
if (Win32Native.CreateDirectory(FileSystem.NormalizePath(path), IntPtr.Zero))
|
|
return;
|
|
FileSystem.RaiseError(path);
|
|
}
|
|
|
|
public static void DeleteFile(string path, bool recursive)
|
|
{
|
|
string str1 = FileSystem.NormalizePath(path);
|
|
bool isdirectory=false;
|
|
if (!FileSystem.FileOrDirectoryExists(str1, ref isdirectory))
|
|
throw new FileNotFoundException();
|
|
if (!isdirectory)
|
|
{
|
|
if (Win32Native.DeleteFile(str1))
|
|
return;
|
|
FileSystem.RaiseError(str1);
|
|
}
|
|
else if (!recursive)
|
|
{
|
|
if (Win32Native.RemoveDirectory(str1))
|
|
return;
|
|
FileSystem.RaiseError(str1);
|
|
}
|
|
else
|
|
{
|
|
List<string> stringList = new List<string>();
|
|
stringList.Add(str1);
|
|
while (stringList.Count > 0)
|
|
{
|
|
string str2 = stringList[checked (stringList.Count - 1)];
|
|
FileInfo[] fileInfoArray = FileSystem.ListDirectoryEntries(str2);
|
|
if (fileInfoArray.Length == 0)
|
|
{
|
|
if (!Win32Native.RemoveDirectory(str2))
|
|
FileSystem.RaiseError(str2);
|
|
stringList.RemoveAt(checked (stringList.Count - 1));
|
|
}
|
|
else
|
|
{
|
|
int num1 = 0;
|
|
int num2 = checked (fileInfoArray.Length - 1);
|
|
int index = num1;
|
|
while (index <= num2)
|
|
{
|
|
if (fileInfoArray[index].IsDirectory)
|
|
stringList.Add(FileSystem.NormalizePath(FileSystem.CombinePath(str2, fileInfoArray[index].FileName)));
|
|
else if (!Win32Native.DeleteFile(FileSystem.NormalizePath(FileSystem.CombinePath(str2, fileInfoArray[index].FileName))))
|
|
FileSystem.RaiseError(str2);
|
|
checked { ++index; }
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void MoveFile(string path1, string path2, bool overwrite)
|
|
{
|
|
if (!overwrite ? Win32Native.MoveFileEx(FileSystem.NormalizePath(path1), FileSystem.NormalizePath(path2), Win32Native.MoveFileFlagType.MOVEFILE_COPY_ALLOWED) : Win32Native.MoveFileEx(FileSystem.NormalizePath(path1), FileSystem.NormalizePath(path2), Win32Native.MoveFileFlagType.MOVEFILE_REPLACE_EXISTING | Win32Native.MoveFileFlagType.MOVEFILE_COPY_ALLOWED))
|
|
return;
|
|
int lastWin32Error = Marshal.GetLastWin32Error();
|
|
FileSystem.RaiseError(path1, lastWin32Error);
|
|
}
|
|
|
|
public static void CopyFile(string path1, string path2, bool overwrite)
|
|
{
|
|
string str1 = FileSystem.NormalizePath(path1);
|
|
string str2 = FileSystem.NormalizePath(path2);
|
|
bool isdirectory1 = false;
|
|
if (!FileSystem.FileOrDirectoryExists(str1, ref isdirectory1))
|
|
throw new FileNotFoundException();
|
|
bool isdirectory2 = false;
|
|
if (!overwrite && FileSystem.FileOrDirectoryExists(str2, ref isdirectory2))
|
|
FileSystem.RaiseError(str2, 183);
|
|
if (!isdirectory1)
|
|
{
|
|
if (Win32Native.CopyFile(str1, str2, !overwrite))
|
|
return;
|
|
FileSystem.RaiseError(str1);
|
|
}
|
|
else
|
|
{
|
|
List<string[]> strArrayList = new List<string[]>();
|
|
strArrayList.Add(new string[3]{ str1, str2, "d" });
|
|
int index1 = 0;
|
|
while (index1 < strArrayList.Count)
|
|
{
|
|
string[] strArray = strArrayList[index1];
|
|
if (Operators.CompareString(strArray[2], "d", false) == 0)
|
|
{
|
|
FileInfo[] fileInfoArray = FileSystem.ListDirectoryEntries(strArray[0]);
|
|
int num1 = 0;
|
|
int num2 = checked (fileInfoArray.Length - 1);
|
|
int index2 = num1;
|
|
while (index2 <= num2)
|
|
{
|
|
if (fileInfoArray[index2].IsDirectory)
|
|
strArrayList.Add(new string[3]
|
|
{
|
|
FileSystem.NormalizePath(FileSystem.CombinePath(strArray[0], fileInfoArray[index2].FileName)),
|
|
FileSystem.NormalizePath(FileSystem.CombinePath(strArray[1], fileInfoArray[index2].FileName)),
|
|
"d"
|
|
});
|
|
else
|
|
strArrayList.Add(new string[3]
|
|
{
|
|
FileSystem.NormalizePath(FileSystem.CombinePath(strArray[0], fileInfoArray[index2].FileName)),
|
|
FileSystem.NormalizePath(FileSystem.CombinePath(strArray[1], fileInfoArray[index2].FileName)),
|
|
"f"
|
|
});
|
|
checked { ++index2; }
|
|
}
|
|
}
|
|
checked { ++index1; }
|
|
}
|
|
int index3 = 0;
|
|
while (index3 < strArrayList.Count)
|
|
{
|
|
string[] strArray = strArrayList[index3];
|
|
if (Operators.CompareString(strArray[2], "d", false) == 0)
|
|
{
|
|
if (!Win32Native.CreateDirectory(strArray[1], IntPtr.Zero))
|
|
FileSystem.RaiseError(strArray[1]);
|
|
}
|
|
else if (!Win32Native.CopyFile(strArray[0], strArray[1], !overwrite))
|
|
FileSystem.RaiseError(strArray[0]);
|
|
checked { ++index3; }
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|