internal static bool Exists(String path) { try { if (path == null) { return(false); } if (path.Length == 0) { return(false); } // Get fully qualified file name ending in \* for security check String fullPath = LongPath.NormalizePath(path); String demandPath = GetDemandDir(fullPath, true); new FileIOPermission(FileIOPermissionAccess.Read, new String[] { demandPath }, false, false).Demand(); return(InternalExists(fullPath)); } catch (ArgumentException) { } catch (NotSupportedException) { } // Security can throw this on ":" catch (SecurityException) { } catch (IOException) { } catch (UnauthorizedAccessException) { #if !FEATURE_PAL Contract.Assert(false, "Ignore this assert and file a bug to the BCL team. This assert was tracking purposes only."); #endif //!FEATURE_PAL } return(false); }
internal static string GetDirectoryName(string path) { if (path != null) { bool removed; string path1 = LongPath.TryRemoveLongPathPrefix(path, out removed); Path.CheckInvalidPathChars(path1, false); path = LongPath.NormalizePath(path1, false); int rootLength = LongPath.GetRootLength(path1); if (path1.Length > rootLength) { int length = path1.Length; if (length == rootLength) { return((string)null); } do { ; }while (length > rootLength && (int)path1[--length] != (int)Path.DirectorySeparatorChar && (int)path1[length] != (int)Path.AltDirectorySeparatorChar); string path2 = path1.Substring(0, length); if (removed) { path2 = Path.AddLongPathPrefix(path2); } return(path2); } } return((string)null); }
internal static void Delete(String path) { Contract.Requires(path != null); String fullPath = LongPath.NormalizePath(path); // For security check, path should be resolved to an absolute path. new FileIOPermission(FileIOPermissionAccess.Write, new String[] { fullPath }, false, false).Demand(); String tempPath = Path.AddLongPathPrefix(fullPath); bool r = Win32Native.DeleteFile(tempPath); if (!r) { int hr = Marshal.GetLastWin32Error(); if (hr == Win32Native.ERROR_FILE_NOT_FOUND) { return; } else { __Error.WinIOError(hr, fullPath); } } }
internal static bool Exists(string path) { try { if (path == null) { return(false); } if (path.Length == 0) { return(false); } string text = LongPath.NormalizePath(path); string demandDir = LongPathDirectory.GetDemandDir(text, true); FileIOPermission.QuickDemand(FileIOPermissionAccess.Read, demandDir, false, false); return(LongPathDirectory.InternalExists(text)); } catch (ArgumentException) { } catch (NotSupportedException) { } catch (SecurityException) { } catch (IOException) { } catch (UnauthorizedAccessException) { } return(false); }
internal static bool Exists(String path) { try { if (path == null) { return(false); } if (path.Length == 0) { return(false); } path = LongPath.NormalizePath(path); // After normalizing, check whether path ends in directory separator. // Otherwise, FillAttributeInfo removes it and we may return a false positive. // GetFullPathInternal should never return null Contract.Assert(path != null, "File.Exists: GetFullPathInternal returned null"); if (path.Length > 0 && Path.IsDirectorySeparator(path[path.Length - 1])) { return(false); } new FileIOPermission(FileIOPermissionAccess.Read, new String[] { path }, false, false).Demand(); return(InternalExists(path)); } catch (ArgumentException) {} catch (NotSupportedException) {} // Security can throw this on ":" catch (SecurityException) {} catch (IOException) {} catch (UnauthorizedAccessException) {} return(false); }
internal static string GetDirectoryName(string path) { if (path != null) { bool flag; string text = LongPath.TryRemoveLongPathPrefix(path, out flag); Path.CheckInvalidPathChars(text, false); path = LongPath.NormalizePath(text, false); int rootLength = LongPath.GetRootLength(text); int num = text.Length; if (num > rootLength) { num = text.Length; if (num == rootLength) { return(null); } while (num > rootLength && text[--num] != Path.DirectorySeparatorChar && text[num] != Path.AltDirectorySeparatorChar) { } string text2 = text.Substring(0, num); if (flag) { text2 = Path.AddLongPathPrefix(text2); } return(text2); } } return(null); }
internal static void Move(String sourceFileName, String destFileName) { Contract.Requires(sourceFileName != null); Contract.Requires(destFileName != null); Contract.Requires(sourceFileName.Length > 0); Contract.Requires(destFileName.Length > 0); String fullSourceFileName = LongPath.NormalizePath(sourceFileName); new FileIOPermission(FileIOPermissionAccess.Write | FileIOPermissionAccess.Read, new String[] { fullSourceFileName }, false, false).Demand(); String fullDestFileName = LongPath.NormalizePath(destFileName); new FileIOPermission(FileIOPermissionAccess.Write, new String[] { fullDestFileName }, false, false).Demand(); if (!LongPathFile.InternalExists(fullSourceFileName)) { __Error.WinIOError(Win32Native.ERROR_FILE_NOT_FOUND, fullSourceFileName); } String tempSourceFileName = Path.AddLongPathPrefix(fullSourceFileName); String tempDestFileName = Path.AddLongPathPrefix(fullDestFileName); if (!Win32Native.MoveFile(tempSourceFileName, tempDestFileName)) { __Error.WinIOError(); } }
internal static bool Exists(string path) { try { if (path == null) { return(false); } if (path.Length == 0) { return(false); } string fullPath = LongPath.NormalizePath(path); string demandDir = GetDemandDir(fullPath, true); new FileIOPermission(FileIOPermissionAccess.Read, new string[] { demandDir }, false, false).Demand(); return(InternalExists(fullPath)); } catch (ArgumentException) { } catch (NotSupportedException) { } catch (SecurityException) { } catch (IOException) { } catch (UnauthorizedAccessException) { } return(false); }
internal static long GetLength(string path) { string path1 = LongPath.NormalizePath(path); new FileIOPermission(FileIOPermissionAccess.Read, new string[1] { path1 }, 0 != 0, 0 != 0).Demand(); string path2 = Path.AddLongPathPrefix(path1); Win32Native.WIN32_FILE_ATTRIBUTE_DATA fileAttributeData = new Win32Native.WIN32_FILE_ATTRIBUTE_DATA(); // ISSUE: explicit reference operation // ISSUE: variable of a reference type Win32Native.WIN32_FILE_ATTRIBUTE_DATA& data = @fileAttributeData; int num1 = 0; int num2 = 1; int errorCode = File.FillAttributeInfo(path2, data, num1 != 0, num2 != 0); if (errorCode != 0) { __Error.WinIOError(errorCode, path); } if ((fileAttributeData.fileAttributes & 16) != 0) { __Error.WinIOError(2, path); } return((long)fileAttributeData.fileSizeHigh << 32 | (long)fileAttributeData.fileSizeLow & (long)uint.MaxValue); }
internal static void Move(String sourceDirName, String destDirName) { Contract.Requires(sourceDirName != null); Contract.Requires(destDirName != null); Contract.Requires(sourceDirName.Length != 0); Contract.Requires(destDirName.Length != 0); String fullsourceDirName = LongPath.NormalizePath(sourceDirName); String sourcePath = GetDemandDir(fullsourceDirName, false); if (sourcePath.Length >= Path.MaxLongPath) { throw new PathTooLongException(Environment.GetResourceString("IO.PathTooLong")); } String fulldestDirName = LongPath.NormalizePath(destDirName); String destPath = GetDemandDir(fulldestDirName, false); if (destPath.Length >= Path.MaxLongPath) { throw new PathTooLongException(Environment.GetResourceString("IO.PathTooLong")); } new FileIOPermission(FileIOPermissionAccess.Write | FileIOPermissionAccess.Read, new String[] { sourcePath }, false, false).Demand(); new FileIOPermission(FileIOPermissionAccess.Write, new String[] { destPath }, false, false).Demand(); if (String.Compare(sourcePath, destPath, StringComparison.OrdinalIgnoreCase) == 0) { throw new IOException(Environment.GetResourceString("IO.IO_SourceDestMustBeDifferent")); } String sourceRoot = LongPath.GetPathRoot(sourcePath); String destinationRoot = LongPath.GetPathRoot(destPath); if (String.Compare(sourceRoot, destinationRoot, StringComparison.OrdinalIgnoreCase) != 0) { throw new IOException(Environment.GetResourceString("IO.IO_SourceDestMustHaveSameRoot")); } String tempSourceDirName = Path.AddLongPathPrefix(sourceDirName); String tempDestDirName = Path.AddLongPathPrefix(destDirName); if (!Win32Native.MoveFile(tempSourceDirName, tempDestDirName)) { int hr = Marshal.GetLastWin32Error(); if (hr == Win32Native.ERROR_FILE_NOT_FOUND) // Source dir not found { hr = Win32Native.ERROR_PATH_NOT_FOUND; __Error.WinIOError(hr, fullsourceDirName); } // This check was originally put in for Win9x (unfortunately without special casing it to be for Win9x only). We can't change the NT codepath now for backcomp reasons. if (hr == Win32Native.ERROR_ACCESS_DENIED) // WinNT throws IOException. This check is for Win9x. We can't change it for backcomp. { throw new IOException(Environment.GetResourceString("UnauthorizedAccess_IODenied_Path", sourceDirName), Win32Native.MakeHRFromErrorCode(hr)); } __Error.WinIOError(hr, String.Empty); } }
internal static void CreateDirectory(string path) { string fullPath = LongPath.NormalizePath(path); string demandDir = LongPathDirectory.GetDemandDir(fullPath, true); FileIOPermission.QuickDemand(FileIOPermissionAccess.Read, demandDir, false, false); LongPathDirectory.InternalCreateDirectory(fullPath, path, null); }
internal static void CreateDirectory(string path) { string fullPath = LongPath.NormalizePath(path); string demandDir = GetDemandDir(fullPath, true); new FileIOPermission(FileIOPermissionAccess.Read, new string[] { demandDir }, false, false).Demand(); InternalCreateDirectory(fullPath, path, null); }
internal static void CreateDirectory(string path) { string fullPath = LongPath.NormalizePath(path); new FileIOPermission(FileIOPermissionAccess.Read, new string[1] { LongPathDirectory.GetDemandDir(fullPath, true) }, 0 != 0, 0 != 0).Demand(); LongPathDirectory.InternalCreateDirectory(fullPath, path, (object)null); }
internal static void Copy(string sourceFileName, string destFileName, bool overwrite) { string fullSourceFileName = LongPath.NormalizePath(sourceFileName); new FileIOPermission(FileIOPermissionAccess.Read, new string[] { fullSourceFileName }, false, false).Demand(); string fullDestFileName = LongPath.NormalizePath(destFileName); new FileIOPermission(FileIOPermissionAccess.Write, new string[] { fullDestFileName }, false, false).Demand(); InternalCopy(fullSourceFileName, fullDestFileName, sourceFileName, destFileName, overwrite); }
internal static void Copy(string sourceFileName, string destFileName, bool overwrite) { string text = LongPath.NormalizePath(sourceFileName); FileIOPermission.QuickDemand(FileIOPermissionAccess.Read, text, false, false); string text2 = LongPath.NormalizePath(destFileName); FileIOPermission.QuickDemand(FileIOPermissionAccess.Write, text2, false, false); LongPathFile.InternalCopy(text, text2, sourceFileName, destFileName, overwrite); }
internal static void Delete(string path) { string str = LongPath.NormalizePath(path); new FileIOPermission(FileIOPermissionAccess.Write, new string[] { str }, false, false).Demand(); if (!Win32Native.DeleteFile(Path.AddLongPathPrefix(str))) { int errorCode = Marshal.GetLastWin32Error(); if (errorCode != 2) { __Error.WinIOError(errorCode, str); } } }
internal static void Move(string sourceDirName, string destDirName) { string text = LongPath.NormalizePath(sourceDirName); string demandDir = LongPathDirectory.GetDemandDir(text, false); if (demandDir.Length >= 32767) { throw new PathTooLongException(Environment.GetResourceString("IO.PathTooLong")); } string fullPath = LongPath.NormalizePath(destDirName); string demandDir2 = LongPathDirectory.GetDemandDir(fullPath, false); if (demandDir2.Length >= 32767) { throw new PathTooLongException(Environment.GetResourceString("IO.PathTooLong")); } FileIOPermission.QuickDemand(FileIOPermissionAccess.Read | FileIOPermissionAccess.Write, demandDir, false, false); FileIOPermission.QuickDemand(FileIOPermissionAccess.Write, demandDir2, false, false); if (string.Compare(demandDir, demandDir2, StringComparison.OrdinalIgnoreCase) == 0) { throw new IOException(Environment.GetResourceString("IO.IO_SourceDestMustBeDifferent")); } string pathRoot = LongPath.GetPathRoot(demandDir); string pathRoot2 = LongPath.GetPathRoot(demandDir2); if (string.Compare(pathRoot, pathRoot2, StringComparison.OrdinalIgnoreCase) != 0) { throw new IOException(Environment.GetResourceString("IO.IO_SourceDestMustHaveSameRoot")); } string src = PathInternal.EnsureExtendedPrefix(sourceDirName); string dst = PathInternal.EnsureExtendedPrefix(destDirName); if (!Win32Native.MoveFile(src, dst)) { int num = Marshal.GetLastWin32Error(); if (num == 2) { num = 3; __Error.WinIOError(num, text); } if (num == 5) { throw new IOException(Environment.GetResourceString("UnauthorizedAccess_IODenied_Path", new object[] { sourceDirName }), Win32Native.MakeHRFromErrorCode(num)); } __Error.WinIOError(num, string.Empty); } }
internal static string GetPathRoot(string path) { if (path == null) { return((string)null); } bool removed; string path1 = LongPath.NormalizePath(LongPath.TryRemoveLongPathPrefix(path, out removed), false); string path2 = path.Substring(0, LongPath.GetRootLength(path1)); if (removed) { path2 = Path.AddLongPathPrefix(path2); } return(path2); }
internal static void Copy(String sourceFileName, String destFileName, bool overwrite) { Contract.Requires(sourceFileName != null); Contract.Requires(destFileName != null); Contract.Requires(sourceFileName.Length > 0); Contract.Requires(destFileName.Length > 0); String fullSourceFileName = LongPath.NormalizePath(sourceFileName); new FileIOPermission(FileIOPermissionAccess.Read, new String[] { fullSourceFileName }, false, false).Demand(); String fullDestFileName = LongPath.NormalizePath(destFileName); new FileIOPermission(FileIOPermissionAccess.Write, new String[] { fullDestFileName }, false, false).Demand(); InternalCopy(fullSourceFileName, fullDestFileName, sourceFileName, destFileName, overwrite); }
internal static void Move(string sourceDirName, string destDirName) { string fullPath = LongPath.NormalizePath(sourceDirName); string demandDir = GetDemandDir(fullPath, false); if (demandDir.Length >= Path.MaxLongPath) { throw new PathTooLongException(Environment.GetResourceString("IO.PathTooLong")); } string strB = GetDemandDir(LongPath.NormalizePath(destDirName), false); if (strB.Length >= Path.MaxLongPath) { throw new PathTooLongException(Environment.GetResourceString("IO.PathTooLong")); } new FileIOPermission(FileIOPermissionAccess.Write | FileIOPermissionAccess.Read, new string[] { demandDir }, false, false).Demand(); new FileIOPermission(FileIOPermissionAccess.Write, new string[] { strB }, false, false).Demand(); if (string.Compare(demandDir, strB, StringComparison.OrdinalIgnoreCase) == 0) { throw new IOException(Environment.GetResourceString("IO.IO_SourceDestMustBeDifferent")); } string pathRoot = LongPath.GetPathRoot(demandDir); string str6 = LongPath.GetPathRoot(strB); if (string.Compare(pathRoot, str6, StringComparison.OrdinalIgnoreCase) != 0) { throw new IOException(Environment.GetResourceString("IO.IO_SourceDestMustHaveSameRoot")); } string src = Path.AddLongPathPrefix(sourceDirName); string dst = Path.AddLongPathPrefix(destDirName); if (!Win32Native.MoveFile(src, dst)) { int errorCode = Marshal.GetLastWin32Error(); switch (errorCode) { case 2: errorCode = 3; __Error.WinIOError(errorCode, fullPath); break; case 5: throw new IOException(Environment.GetResourceString("UnauthorizedAccess_IODenied_Path", new object[] { sourceDirName }), Win32Native.MakeHRFromErrorCode(errorCode)); } __Error.WinIOError(errorCode, string.Empty); } }
internal static void CreateDirectory(String path) { Contract.Requires(path != null); Contract.Requires(path.Length > 0); String fullPath = LongPath.NormalizePath(path); // You need read access to the directory to be returned back and write access to all the directories // that you need to create. If we fail any security checks we will not create any directories at all. // We attempt to create directories only after all the security checks have passed. This is avoid doing // a demand at every level. String demandDir = GetDemandDir(fullPath, true); new FileIOPermission(FileIOPermissionAccess.Read, new String[] { demandDir }, false, false).Demand(); InternalCreateDirectory(fullPath, path, null); }
internal static void Delete(string path) { string text = LongPath.NormalizePath(path); FileIOPermission.QuickDemand(FileIOPermissionAccess.Write, text, false, false); string path2 = Path.AddLongPathPrefix(text); if (!Win32Native.DeleteFile(path2)) { int lastWin32Error = Marshal.GetLastWin32Error(); if (lastWin32Error == 2) { return; } __Error.WinIOError(lastWin32Error, text); } }
internal static string GetPathRoot(string path) { if (path == null) { return(null); } bool flag; string path2 = LongPath.TryRemoveLongPathPrefix(path, out flag); path2 = LongPath.NormalizePath(path2, false); string text = path.Substring(0, LongPath.GetRootLength(path2)); if (flag) { text = Path.AddLongPathPrefix(text); } return(text); }
internal static DateTimeOffset GetLastWriteTime(string path) { string text = LongPath.NormalizePath(path); FileIOPermission.QuickDemand(FileIOPermissionAccess.Read, text, false, false); string path2 = Path.AddLongPathPrefix(text); Win32Native.WIN32_FILE_ATTRIBUTE_DATA win32_FILE_ATTRIBUTE_DATA = default(Win32Native.WIN32_FILE_ATTRIBUTE_DATA); int num = File.FillAttributeInfo(path2, ref win32_FILE_ATTRIBUTE_DATA, false, false); if (num != 0) { __Error.WinIOError(num, text); } DateTime dateTime = DateTime.FromFileTimeUtc(win32_FILE_ATTRIBUTE_DATA.ftLastWriteTime.ToTicks()).ToLocalTime(); return(new DateTimeOffset(dateTime).ToLocalTime()); }
internal static DateTimeOffset GetCreationTime(string path) { string str = LongPath.NormalizePath(path); new FileIOPermission(FileIOPermissionAccess.Read, new string[] { str }, false, false).Demand(); string str2 = Path.AddLongPathPrefix(str); Win32Native.WIN32_FILE_ATTRIBUTE_DATA data = new Win32Native.WIN32_FILE_ATTRIBUTE_DATA(); int errorCode = File.FillAttributeInfo(str2, ref data, false, false); if (errorCode != 0) { __Error.WinIOError(errorCode, str); } long fileTime = (data.ftCreationTimeHigh << 0x20) | data.ftCreationTimeLow; DateTimeOffset offset = new DateTimeOffset(DateTime.FromFileTimeUtc(fileTime).ToLocalTime()); return(offset.ToLocalTime()); }
internal static void Delete(string path) { string str = LongPath.NormalizePath(path); new FileIOPermission(FileIOPermissionAccess.Write, new string[1] { str }, 0 != 0, 0 != 0).Demand(); if (Win32Native.DeleteFile(Path.AddLongPathPrefix(str))) { return; } int lastWin32Error = Marshal.GetLastWin32Error(); if (lastWin32Error == 2) { return; } __Error.WinIOError(lastWin32Error, str); }
internal static long GetLength(string path) { string str = LongPath.NormalizePath(path); new FileIOPermission(FileIOPermissionAccess.Read, new string[] { str }, false, false).Demand(); string str2 = Path.AddLongPathPrefix(str); Win32Native.WIN32_FILE_ATTRIBUTE_DATA data = new Win32Native.WIN32_FILE_ATTRIBUTE_DATA(); int errorCode = File.FillAttributeInfo(str2, ref data, false, true); if (errorCode != 0) { __Error.WinIOError(errorCode, path); } if ((data.fileAttributes & 0x10) != 0) { __Error.WinIOError(2, path); } return((data.fileSizeHigh << 0x20) | (data.fileSizeLow & ((long)0xffffffffL))); }
internal static long GetLength(string path) { string text = LongPath.NormalizePath(path); FileIOPermission.QuickDemand(FileIOPermissionAccess.Read, text, false, false); string path2 = Path.AddLongPathPrefix(text); Win32Native.WIN32_FILE_ATTRIBUTE_DATA win32_FILE_ATTRIBUTE_DATA = default(Win32Native.WIN32_FILE_ATTRIBUTE_DATA); int num = File.FillAttributeInfo(path2, ref win32_FILE_ATTRIBUTE_DATA, false, true); if (num != 0) { __Error.WinIOError(num, path); } if ((win32_FILE_ATTRIBUTE_DATA.fileAttributes & 16) != 0) { __Error.WinIOError(2, path); } return((long)win32_FILE_ATTRIBUTE_DATA.fileSizeHigh << 32 | ((long)win32_FILE_ATTRIBUTE_DATA.fileSizeLow & (long)((ulong)-1))); }
internal static void Move(string sourceFileName, string destFileName) { string path = LongPath.NormalizePath(sourceFileName); new FileIOPermission(FileIOPermissionAccess.Write | FileIOPermissionAccess.Read, new string[] { path }, false, false).Demand(); string str2 = LongPath.NormalizePath(destFileName); new FileIOPermission(FileIOPermissionAccess.Write, new string[] { str2 }, false, false).Demand(); if (!InternalExists(path)) { __Error.WinIOError(2, path); } string src = Path.AddLongPathPrefix(path); string dst = Path.AddLongPathPrefix(str2); if (!Win32Native.MoveFile(src, dst)) { __Error.WinIOError(); } }
internal static void Move(string sourceFileName, string destFileName) { string text = LongPath.NormalizePath(sourceFileName); FileIOPermission.QuickDemand(FileIOPermissionAccess.Read | FileIOPermissionAccess.Write, text, false, false); string text2 = LongPath.NormalizePath(destFileName); FileIOPermission.QuickDemand(FileIOPermissionAccess.Write, text2, false, false); if (!LongPathFile.InternalExists(text)) { __Error.WinIOError(2, text); } string src = Path.AddLongPathPrefix(text); string dst = Path.AddLongPathPrefix(text2); if (!Win32Native.MoveFile(src, dst)) { __Error.WinIOError(); } }