diff options
Diffstat (limited to 'MediaBrowser.Common.Implementations/IO')
3 files changed, 1109 insertions, 0 deletions
diff --git a/MediaBrowser.Common.Implementations/IO/LnkShortcutHandler.cs b/MediaBrowser.Common.Implementations/IO/LnkShortcutHandler.cs new file mode 100644 index 000000000..441e6939f --- /dev/null +++ b/MediaBrowser.Common.Implementations/IO/LnkShortcutHandler.cs @@ -0,0 +1,399 @@ +using System; +using System.IO; +using System.Runtime.InteropServices; +using System.Security; +using System.Text; +using MediaBrowser.Model.IO; + +namespace MediaBrowser.Common.Implementations.IO +{ + public class LnkShortcutHandler :IShortcutHandler + { + public string Extension + { + get { return ".lnk"; } + } + + public string Resolve(string shortcutPath) + { + var link = new ShellLink(); + ((IPersistFile)link).Load(shortcutPath, NativeMethods.STGM_READ); + // ((IShellLinkW)link).Resolve(hwnd, 0) + var sb = new StringBuilder(NativeMethods.MAX_PATH); + WIN32_FIND_DATA data; + ((IShellLinkW)link).GetPath(sb, sb.Capacity, out data, 0); + return sb.ToString(); + } + + public void Create(string shortcutPath, string targetPath) + { + throw new NotImplementedException(); + } + } + + /// <summary> + /// Class NativeMethods + /// </summary> + [SuppressUnmanagedCodeSecurity] + public static class NativeMethods + { + /// <summary> + /// The MA x_ PATH + /// </summary> + public const int MAX_PATH = 260; + /// <summary> + /// The MA x_ ALTERNATE + /// </summary> + public const int MAX_ALTERNATE = 14; + /// <summary> + /// The INVALI d_ HANDL e_ VALUE + /// </summary> + public static IntPtr INVALID_HANDLE_VALUE = new IntPtr(-1); + /// <summary> + /// The STG m_ READ + /// </summary> + public const uint STGM_READ = 0; + } + + /// <summary> + /// Struct FILETIME + /// </summary> + [StructLayout(LayoutKind.Sequential)] + public struct FILETIME + { + /// <summary> + /// The dw low date time + /// </summary> + public uint dwLowDateTime; + /// <summary> + /// The dw high date time + /// </summary> + public uint dwHighDateTime; + } + + /// <summary> + /// Struct WIN32_FIND_DATA + /// </summary> + [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)] + public struct WIN32_FIND_DATA + { + /// <summary> + /// The dw file attributes + /// </summary> + public FileAttributes dwFileAttributes; + /// <summary> + /// The ft creation time + /// </summary> + public FILETIME ftCreationTime; + /// <summary> + /// The ft last access time + /// </summary> + public FILETIME ftLastAccessTime; + /// <summary> + /// The ft last write time + /// </summary> + public FILETIME ftLastWriteTime; + /// <summary> + /// The n file size high + /// </summary> + public int nFileSizeHigh; + /// <summary> + /// The n file size low + /// </summary> + public int nFileSizeLow; + /// <summary> + /// The dw reserved0 + /// </summary> + public int dwReserved0; + /// <summary> + /// The dw reserved1 + /// </summary> + public int dwReserved1; + + /// <summary> + /// The c file name + /// </summary> + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = NativeMethods.MAX_PATH)] + public string cFileName; + + /// <summary> + /// This will always be null when FINDEX_INFO_LEVELS = basic + /// </summary> + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = NativeMethods.MAX_ALTERNATE)] + public string cAlternate; + + /// <summary> + /// Gets or sets the path. + /// </summary> + /// <value>The path.</value> + public string Path { get; set; } + + /// <summary> + /// Returns a <see cref="System.String" /> that represents this instance. + /// </summary> + /// <returns>A <see cref="System.String" /> that represents this instance.</returns> + public override string ToString() + { + return Path ?? string.Empty; + } + } + + /// <summary> + /// Enum SLGP_FLAGS + /// </summary> + [Flags] + public enum SLGP_FLAGS + { + /// <summary> + /// Retrieves the standard short (8.3 format) file name + /// </summary> + SLGP_SHORTPATH = 0x1, + /// <summary> + /// Retrieves the Universal Naming Convention (UNC) path name of the file + /// </summary> + SLGP_UNCPRIORITY = 0x2, + /// <summary> + /// Retrieves the raw path name. A raw path is something that might not exist and may include environment variables that need to be expanded + /// </summary> + SLGP_RAWPATH = 0x4 + } + /// <summary> + /// Enum SLR_FLAGS + /// </summary> + [Flags] + public enum SLR_FLAGS + { + /// <summary> + /// Do not display a dialog box if the link cannot be resolved. When SLR_NO_UI is set, + /// the high-order word of fFlags can be set to a time-out value that specifies the + /// maximum amount of time to be spent resolving the link. The function returns if the + /// link cannot be resolved within the time-out duration. If the high-order word is set + /// to zero, the time-out duration will be set to the default value of 3,000 milliseconds + /// (3 seconds). To specify a value, set the high word of fFlags to the desired time-out + /// duration, in milliseconds. + /// </summary> + SLR_NO_UI = 0x1, + /// <summary> + /// Obsolete and no longer used + /// </summary> + SLR_ANY_MATCH = 0x2, + /// <summary> + /// If the link object has changed, update its path and list of identifiers. + /// If SLR_UPDATE is set, you do not need to call IPersistFile::IsDirty to determine + /// whether or not the link object has changed. + /// </summary> + SLR_UPDATE = 0x4, + /// <summary> + /// Do not update the link information + /// </summary> + SLR_NOUPDATE = 0x8, + /// <summary> + /// Do not execute the search heuristics + /// </summary> + SLR_NOSEARCH = 0x10, + /// <summary> + /// Do not use distributed link tracking + /// </summary> + SLR_NOTRACK = 0x20, + /// <summary> + /// Disable distributed link tracking. By default, distributed link tracking tracks + /// removable media across multiple devices based on the volume name. It also uses the + /// Universal Naming Convention (UNC) path to track remote file systems whose drive letter + /// has changed. Setting SLR_NOLINKINFO disables both types of tracking. + /// </summary> + SLR_NOLINKINFO = 0x40, + /// <summary> + /// Call the Microsoft Windows Installer + /// </summary> + SLR_INVOKE_MSI = 0x80 + } + + /// <summary> + /// The IShellLink interface allows Shell links to be created, modified, and resolved + /// </summary> + [ComImport, InterfaceType(ComInterfaceType.InterfaceIsIUnknown), Guid("000214F9-0000-0000-C000-000000000046")] + public interface IShellLinkW + { + /// <summary> + /// Retrieves the path and file name of a Shell link object + /// </summary> + /// <param name="pszFile">The PSZ file.</param> + /// <param name="cchMaxPath">The CCH max path.</param> + /// <param name="pfd">The PFD.</param> + /// <param name="fFlags">The f flags.</param> + void GetPath([Out, MarshalAs(UnmanagedType.LPWStr)] StringBuilder pszFile, int cchMaxPath, out WIN32_FIND_DATA pfd, SLGP_FLAGS fFlags); + /// <summary> + /// Retrieves the list of item identifiers for a Shell link object + /// </summary> + /// <param name="ppidl">The ppidl.</param> + void GetIDList(out IntPtr ppidl); + /// <summary> + /// Sets the pointer to an item identifier list (PIDL) for a Shell link object. + /// </summary> + /// <param name="pidl">The pidl.</param> + void SetIDList(IntPtr pidl); + /// <summary> + /// Retrieves the description string for a Shell link object + /// </summary> + /// <param name="pszName">Name of the PSZ.</param> + /// <param name="cchMaxName">Name of the CCH max.</param> + void GetDescription([Out, MarshalAs(UnmanagedType.LPWStr)] StringBuilder pszName, int cchMaxName); + /// <summary> + /// Sets the description for a Shell link object. The description can be any application-defined string + /// </summary> + /// <param name="pszName">Name of the PSZ.</param> + void SetDescription([MarshalAs(UnmanagedType.LPWStr)] string pszName); + /// <summary> + /// Retrieves the name of the working directory for a Shell link object + /// </summary> + /// <param name="pszDir">The PSZ dir.</param> + /// <param name="cchMaxPath">The CCH max path.</param> + void GetWorkingDirectory([Out, MarshalAs(UnmanagedType.LPWStr)] StringBuilder pszDir, int cchMaxPath); + /// <summary> + /// Sets the name of the working directory for a Shell link object + /// </summary> + /// <param name="pszDir">The PSZ dir.</param> + void SetWorkingDirectory([MarshalAs(UnmanagedType.LPWStr)] string pszDir); + /// <summary> + /// Retrieves the command-line arguments associated with a Shell link object + /// </summary> + /// <param name="pszArgs">The PSZ args.</param> + /// <param name="cchMaxPath">The CCH max path.</param> + void GetArguments([Out, MarshalAs(UnmanagedType.LPWStr)] StringBuilder pszArgs, int cchMaxPath); + /// <summary> + /// Sets the command-line arguments for a Shell link object + /// </summary> + /// <param name="pszArgs">The PSZ args.</param> + void SetArguments([MarshalAs(UnmanagedType.LPWStr)] string pszArgs); + /// <summary> + /// Retrieves the hot key for a Shell link object + /// </summary> + /// <param name="pwHotkey">The pw hotkey.</param> + void GetHotkey(out short pwHotkey); + /// <summary> + /// Sets a hot key for a Shell link object + /// </summary> + /// <param name="wHotkey">The w hotkey.</param> + void SetHotkey(short wHotkey); + /// <summary> + /// Retrieves the show command for a Shell link object + /// </summary> + /// <param name="piShowCmd">The pi show CMD.</param> + void GetShowCmd(out int piShowCmd); + /// <summary> + /// Sets the show command for a Shell link object. The show command sets the initial show state of the window. + /// </summary> + /// <param name="iShowCmd">The i show CMD.</param> + void SetShowCmd(int iShowCmd); + /// <summary> + /// Retrieves the location (path and index) of the icon for a Shell link object + /// </summary> + /// <param name="pszIconPath">The PSZ icon path.</param> + /// <param name="cchIconPath">The CCH icon path.</param> + /// <param name="piIcon">The pi icon.</param> + void GetIconLocation([Out, MarshalAs(UnmanagedType.LPWStr)] StringBuilder pszIconPath, + int cchIconPath, out int piIcon); + /// <summary> + /// Sets the location (path and index) of the icon for a Shell link object + /// </summary> + /// <param name="pszIconPath">The PSZ icon path.</param> + /// <param name="iIcon">The i icon.</param> + void SetIconLocation([MarshalAs(UnmanagedType.LPWStr)] string pszIconPath, int iIcon); + /// <summary> + /// Sets the relative path to the Shell link object + /// </summary> + /// <param name="pszPathRel">The PSZ path rel.</param> + /// <param name="dwReserved">The dw reserved.</param> + void SetRelativePath([MarshalAs(UnmanagedType.LPWStr)] string pszPathRel, int dwReserved); + /// <summary> + /// Attempts to find the target of a Shell link, even if it has been moved or renamed + /// </summary> + /// <param name="hwnd">The HWND.</param> + /// <param name="fFlags">The f flags.</param> + void Resolve(IntPtr hwnd, SLR_FLAGS fFlags); + /// <summary> + /// Sets the path and file name of a Shell link object + /// </summary> + /// <param name="pszFile">The PSZ file.</param> + void SetPath([MarshalAs(UnmanagedType.LPWStr)] string pszFile); + + } + + /// <summary> + /// Interface IPersist + /// </summary> + [ComImport, Guid("0000010c-0000-0000-c000-000000000046"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IPersist + { + /// <summary> + /// Gets the class ID. + /// </summary> + /// <param name="pClassID">The p class ID.</param> + [PreserveSig] + void GetClassID(out Guid pClassID); + } + + /// <summary> + /// Interface IPersistFile + /// </summary> + [ComImport, Guid("0000010b-0000-0000-C000-000000000046"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IPersistFile : IPersist + { + /// <summary> + /// Gets the class ID. + /// </summary> + /// <param name="pClassID">The p class ID.</param> + new void GetClassID(out Guid pClassID); + /// <summary> + /// Determines whether this instance is dirty. + /// </summary> + [PreserveSig] + int IsDirty(); + + /// <summary> + /// Loads the specified PSZ file name. + /// </summary> + /// <param name="pszFileName">Name of the PSZ file.</param> + /// <param name="dwMode">The dw mode.</param> + [PreserveSig] + void Load([In, MarshalAs(UnmanagedType.LPWStr)] + string pszFileName, uint dwMode); + + /// <summary> + /// Saves the specified PSZ file name. + /// </summary> + /// <param name="pszFileName">Name of the PSZ file.</param> + /// <param name="remember">if set to <c>true</c> [remember].</param> + [PreserveSig] + void Save([In, MarshalAs(UnmanagedType.LPWStr)] string pszFileName, + [In, MarshalAs(UnmanagedType.Bool)] bool remember); + + /// <summary> + /// Saves the completed. + /// </summary> + /// <param name="pszFileName">Name of the PSZ file.</param> + [PreserveSig] + void SaveCompleted([In, MarshalAs(UnmanagedType.LPWStr)] string pszFileName); + + /// <summary> + /// Gets the cur file. + /// </summary> + /// <param name="ppszFileName">Name of the PPSZ file.</param> + [PreserveSig] + void GetCurFile([In, MarshalAs(UnmanagedType.LPWStr)] string ppszFileName); + } + + // CLSID_ShellLink from ShlGuid.h + /// <summary> + /// Class ShellLink + /// </summary> + [ + ComImport, + Guid("00021401-0000-0000-C000-000000000046") + ] + public class ShellLink + { + } +} diff --git a/MediaBrowser.Common.Implementations/IO/ManagedFileSystem.cs b/MediaBrowser.Common.Implementations/IO/ManagedFileSystem.cs new file mode 100644 index 000000000..ffb1e4234 --- /dev/null +++ b/MediaBrowser.Common.Implementations/IO/ManagedFileSystem.cs @@ -0,0 +1,696 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Text; +using MediaBrowser.Common.IO; +using MediaBrowser.Model.IO; +using Patterns.Logging; + +namespace MediaBrowser.Common.Implementations.IO +{ + /// <summary> + /// Class ManagedFileSystem + /// </summary> + public class ManagedFileSystem : IFileSystem + { + protected ILogger Logger; + + private readonly bool _supportsAsyncFileStreams; + private char[] _invalidFileNameChars; + private readonly List<IShortcutHandler> _shortcutHandlers = new List<IShortcutHandler>(); + protected bool EnableFileSystemRequestConcat = true; + + public ManagedFileSystem(ILogger logger, bool supportsAsyncFileStreams, bool enableManagedInvalidFileNameChars) + { + Logger = logger; + _supportsAsyncFileStreams = supportsAsyncFileStreams; + SetInvalidFileNameChars(enableManagedInvalidFileNameChars); + } + + public void AddShortcutHandler(IShortcutHandler handler) + { + _shortcutHandlers.Add(handler); + } + + protected void SetInvalidFileNameChars(bool enableManagedInvalidFileNameChars) + { + if (enableManagedInvalidFileNameChars) + { + _invalidFileNameChars = Path.GetInvalidFileNameChars(); + } + else + { + // GetInvalidFileNameChars is less restrictive in Linux/Mac than Windows, this mimic Windows behavior for mono under Linux/Mac. + _invalidFileNameChars = new char[41] { '\x00', '\x01', '\x02', '\x03', '\x04', '\x05', '\x06', '\x07', + '\x08', '\x09', '\x0A', '\x0B', '\x0C', '\x0D', '\x0E', '\x0F', '\x10', '\x11', '\x12', + '\x13', '\x14', '\x15', '\x16', '\x17', '\x18', '\x19', '\x1A', '\x1B', '\x1C', '\x1D', + '\x1E', '\x1F', '\x22', '\x3C', '\x3E', '\x7C', ':', '*', '?', '\\', '/' }; + } + } + + public char DirectorySeparatorChar + { + get + { + return Path.DirectorySeparatorChar; + } + } + + public string GetFullPath(string path) + { + return Path.GetFullPath(path); + } + + /// <summary> + /// Determines whether the specified filename is shortcut. + /// </summary> + /// <param name="filename">The filename.</param> + /// <returns><c>true</c> if the specified filename is shortcut; otherwise, <c>false</c>.</returns> + /// <exception cref="System.ArgumentNullException">filename</exception> + public virtual bool IsShortcut(string filename) + { + if (string.IsNullOrEmpty(filename)) + { + throw new ArgumentNullException("filename"); + } + + var extension = Path.GetExtension(filename); + return _shortcutHandlers.Any(i => string.Equals(extension, i.Extension, StringComparison.OrdinalIgnoreCase)); + } + + /// <summary> + /// Resolves the shortcut. + /// </summary> + /// <param name="filename">The filename.</param> + /// <returns>System.String.</returns> + /// <exception cref="System.ArgumentNullException">filename</exception> + public virtual string ResolveShortcut(string filename) + { + if (string.IsNullOrEmpty(filename)) + { + throw new ArgumentNullException("filename"); + } + + var extension = Path.GetExtension(filename); + var handler = _shortcutHandlers.FirstOrDefault(i => string.Equals(extension, i.Extension, StringComparison.OrdinalIgnoreCase)); + + if (handler != null) + { + return handler.Resolve(filename); + } + + return null; + } + + /// <summary> + /// Creates the shortcut. + /// </summary> + /// <param name="shortcutPath">The shortcut path.</param> + /// <param name="target">The target.</param> + /// <exception cref="System.ArgumentNullException"> + /// shortcutPath + /// or + /// target + /// </exception> + public void CreateShortcut(string shortcutPath, string target) + { + if (string.IsNullOrEmpty(shortcutPath)) + { + throw new ArgumentNullException("shortcutPath"); + } + + if (string.IsNullOrEmpty(target)) + { + throw new ArgumentNullException("target"); + } + + var extension = Path.GetExtension(shortcutPath); + var handler = _shortcutHandlers.FirstOrDefault(i => string.Equals(extension, i.Extension, StringComparison.OrdinalIgnoreCase)); + + if (handler != null) + { + handler.Create(shortcutPath, target); + } + else + { + throw new NotImplementedException(); + } + } + + /// <summary> + /// Returns a <see cref="FileSystemMetadata"/> object for the specified file or directory path. + /// </summary> + /// <param name="path">A path to a file or directory.</param> + /// <returns>A <see cref="FileSystemMetadata"/> object.</returns> + /// <remarks>If the specified path points to a directory, the returned <see cref="FileSystemMetadata"/> object's + /// <see cref="FileSystemMetadata.IsDirectory"/> property will be set to true and all other properties will reflect the properties of the directory.</remarks> + public FileSystemMetadata GetFileSystemInfo(string path) + { + if (string.IsNullOrEmpty(path)) + { + throw new ArgumentNullException("path"); + } + + // Take a guess to try and avoid two file system hits, but we'll double-check by calling Exists + if (Path.HasExtension(path)) + { + var fileInfo = new FileInfo(path); + + if (fileInfo.Exists) + { + return GetFileSystemMetadata(fileInfo); + } + + return GetFileSystemMetadata(new DirectoryInfo(path)); + } + else + { + var fileInfo = new DirectoryInfo(path); + + if (fileInfo.Exists) + { + return GetFileSystemMetadata(fileInfo); + } + + return GetFileSystemMetadata(new FileInfo(path)); + } + } + + /// <summary> + /// Returns a <see cref="FileSystemMetadata"/> object for the specified file path. + /// </summary> + /// <param name="path">A path to a file.</param> + /// <returns>A <see cref="FileSystemMetadata"/> object.</returns> + /// <remarks><para>If the specified path points to a directory, the returned <see cref="FileSystemMetadata"/> object's + /// <see cref="FileSystemMetadata.IsDirectory"/> property and the <see cref="FileSystemMetadata.Exists"/> property will both be set to false.</para> + /// <para>For automatic handling of files <b>and</b> directories, use <see cref="GetFileSystemInfo"/>.</para></remarks> + public FileSystemMetadata GetFileInfo(string path) + { + if (string.IsNullOrEmpty(path)) + { + throw new ArgumentNullException("path"); + } + + var fileInfo = new FileInfo(path); + + return GetFileSystemMetadata(fileInfo); + } + + /// <summary> + /// Returns a <see cref="FileSystemMetadata"/> object for the specified directory path. + /// </summary> + /// <param name="path">A path to a directory.</param> + /// <returns>A <see cref="FileSystemMetadata"/> object.</returns> + /// <remarks><para>If the specified path points to a file, the returned <see cref="FileSystemMetadata"/> object's + /// <see cref="FileSystemMetadata.IsDirectory"/> property will be set to true and the <see cref="FileSystemMetadata.Exists"/> property will be set to false.</para> + /// <para>For automatic handling of files <b>and</b> directories, use <see cref="GetFileSystemInfo"/>.</para></remarks> + public FileSystemMetadata GetDirectoryInfo(string path) + { + if (string.IsNullOrEmpty(path)) + { + throw new ArgumentNullException("path"); + } + + var fileInfo = new DirectoryInfo(path); + + return GetFileSystemMetadata(fileInfo); + } + + private FileSystemMetadata GetFileSystemMetadata(FileSystemInfo info) + { + var result = new FileSystemMetadata(); + + result.Exists = info.Exists; + result.FullName = info.FullName; + result.Extension = info.Extension; + result.Name = info.Name; + + if (result.Exists) + { + var attributes = info.Attributes; + result.IsDirectory = info is DirectoryInfo || (attributes & FileAttributes.Directory) == FileAttributes.Directory; + result.IsHidden = (attributes & FileAttributes.Hidden) == FileAttributes.Hidden; + result.IsReadOnly = (attributes & FileAttributes.ReadOnly) == FileAttributes.ReadOnly; + + var fileInfo = info as FileInfo; + if (fileInfo != null) + { + result.Length = fileInfo.Length; + result.DirectoryName = fileInfo.DirectoryName; + } + + result.CreationTimeUtc = GetCreationTimeUtc(info); + result.LastWriteTimeUtc = GetLastWriteTimeUtc(info); + } + else + { + result.IsDirectory = info is DirectoryInfo; + } + + return result; + } + + /// <summary> + /// The space char + /// </summary> + private const char SpaceChar = ' '; + + /// <summary> + /// Takes a filename and removes invalid characters + /// </summary> + /// <param name="filename">The filename.</param> + /// <returns>System.String.</returns> + /// <exception cref="System.ArgumentNullException">filename</exception> + public string GetValidFilename(string filename) + { + if (string.IsNullOrEmpty(filename)) + { + throw new ArgumentNullException("filename"); + } + + var builder = new StringBuilder(filename); + + foreach (var c in _invalidFileNameChars) + { + builder = builder.Replace(c, SpaceChar); + } + + return builder.ToString(); + } + + /// <summary> + /// Gets the creation time UTC. + /// </summary> + /// <param name="info">The info.</param> + /// <returns>DateTime.</returns> + public DateTime GetCreationTimeUtc(FileSystemInfo info) + { + // This could throw an error on some file systems that have dates out of range + try + { + return info.CreationTimeUtc; + } + catch (Exception ex) + { + Logger.ErrorException("Error determining CreationTimeUtc for {0}", ex, info.FullName); + return DateTime.MinValue; + } + } + + /// <summary> + /// Gets the creation time UTC. + /// </summary> + /// <param name="path">The path.</param> + /// <returns>DateTime.</returns> + public DateTime GetCreationTimeUtc(string path) + { + return GetCreationTimeUtc(GetFileSystemInfo(path)); + } + + public DateTime GetCreationTimeUtc(FileSystemMetadata info) + { + return info.CreationTimeUtc; + } + + public DateTime GetLastWriteTimeUtc(FileSystemMetadata info) + { + return info.LastWriteTimeUtc; + } + + /// <summary> + /// Gets the creation time UTC. + /// </summary> + /// <param name="info">The info.</param> + /// <returns>DateTime.</returns> + public DateTime GetLastWriteTimeUtc(FileSystemInfo info) + { + // This could throw an error on some file systems that have dates out of range + try + { + return info.LastWriteTimeUtc; + } + catch (Exception ex) + { + Logger.ErrorException("Error determining LastAccessTimeUtc for {0}", ex, info.FullName); + return DateTime.MinValue; + } + } + + /// <summary> + /// Gets the last write time UTC. + /// </summary> + /// <param name="path">The path.</param> + /// <returns>DateTime.</returns> + public DateTime GetLastWriteTimeUtc(string path) + { + return GetLastWriteTimeUtc(GetFileSystemInfo(path)); + } + + /// <summary> + /// Gets the file stream. + /// </summary> + /// <param name="path">The path.</param> + /// <param name="mode">The mode.</param> + /// <param name="access">The access.</param> + /// <param name="share">The share.</param> + /// <param name="isAsync">if set to <c>true</c> [is asynchronous].</param> + /// <returns>FileStream.</returns> + public Stream GetFileStream(string path, FileOpenMode mode, FileAccessMode access, FileShareMode share, bool isAsync = false) + { + if (_supportsAsyncFileStreams && isAsync) + { + return new FileStream(path, GetFileMode(mode), GetFileAccess(access), GetFileShare(share), 262144, true); + } + + return new FileStream(path, GetFileMode(mode), GetFileAccess(access), GetFileShare(share), 262144); + } + + private FileMode GetFileMode(FileOpenMode mode) + { + switch (mode) + { + case FileOpenMode.Append: + return FileMode.Append; + case FileOpenMode.Create: + return FileMode.Create; + case FileOpenMode.CreateNew: + return FileMode.CreateNew; + case FileOpenMode.Open: + return FileMode.Open; + case FileOpenMode.OpenOrCreate: + return FileMode.OpenOrCreate; + case FileOpenMode.Truncate: + return FileMode.Truncate; + default: + throw new Exception("Unrecognized FileOpenMode"); + } + } + + private FileAccess GetFileAccess(FileAccessMode mode) + { + var val = (int)mode; + + return (FileAccess)val; + } + + private FileShare GetFileShare(FileShareMode mode) + { + var val = (int)mode; + + return (FileShare)val; + } + + public void SetHidden(string path, bool isHidden) + { + var info = GetFileInfo(path); + + if (info.Exists && info.IsHidden != isHidden) + { + if (isHidden) + { + FileAttributes attributes = File.GetAttributes(path); + attributes = RemoveAttribute(attributes, FileAttributes.Hidden); + File.SetAttributes(path, attributes); + } + else + { + File.SetAttributes(path, File.GetAttributes(path) | FileAttributes.Hidden); + } + } + } + + private static FileAttributes RemoveAttribute(FileAttributes attributes, FileAttributes attributesToRemove) + { + return attributes & ~attributesToRemove; + } + + /// <summary> + /// Swaps the files. + /// </summary> + /// <param name="file1">The file1.</param> + /// <param name="file2">The file2.</param> + public void SwapFiles(string file1, string file2) + { + if (string.IsNullOrEmpty(file1)) + { + throw new ArgumentNullException("file1"); + } + + if (string.IsNullOrEmpty(file2)) + { + throw new ArgumentNullException("file2"); + } + + var temp1 = Path.GetTempFileName(); + var temp2 = Path.GetTempFileName(); + + // Copying over will fail against hidden files + RemoveHiddenAttribute(file1); + RemoveHiddenAttribute(file2); + + CopyFile(file1, temp1, true); + CopyFile(file2, temp2, true); + + CopyFile(temp1, file2, true); + CopyFile(temp2, file1, true); + + DeleteFile(temp1); + DeleteFile(temp2); + } + + /// <summary> + /// Removes the hidden attribute. + /// </summary> + /// <param name="path">The path.</param> + private void RemoveHiddenAttribute(string path) + { + if (string.IsNullOrEmpty(path)) + { + throw new ArgumentNullException("path"); + } + + var currentFile = new FileInfo(path); + + // This will fail if the file is hidden + if (currentFile.Exists) + { + if ((currentFile.Attributes & FileAttributes.Hidden) == FileAttributes.Hidden) + { + currentFile.Attributes &= ~FileAttributes.Hidden; + } + } + } + + public bool ContainsSubPath(string parentPath, string path) + { + if (string.IsNullOrEmpty(parentPath)) + { + throw new ArgumentNullException("parentPath"); + } + + if (string.IsNullOrEmpty(path)) + { + throw new ArgumentNullException("path"); + } + + return path.IndexOf(parentPath.TrimEnd(Path.DirectorySeparatorChar) + Path.DirectorySeparatorChar, StringComparison.OrdinalIgnoreCase) != -1; + } + + public bool IsRootPath(string path) + { + if (string.IsNullOrEmpty(path)) + { + throw new ArgumentNullException("path"); + } + + var parent = Path.GetDirectoryName(path); + + if (!string.IsNullOrEmpty(parent)) + { + return false; + } + + return true; + } + + public string NormalizePath(string path) + { + if (string.IsNullOrEmpty(path)) + { + throw new ArgumentNullException("path"); + } + + if (path.EndsWith(":\\", StringComparison.OrdinalIgnoreCase)) + { + return path; + } + + return path.TrimEnd(Path.DirectorySeparatorChar); + } + + public string GetFileNameWithoutExtension(FileSystemMetadata info) + { + if (info.IsDirectory) + { + return info.Name; + } + + return Path.GetFileNameWithoutExtension(info.FullName); + } + + public string GetFileNameWithoutExtension(string path) + { + return Path.GetFileNameWithoutExtension(path); + } + + public bool IsPathFile(string path) + { + if (string.IsNullOrWhiteSpace(path)) + { + throw new ArgumentNullException("path"); + } + + // Cannot use Path.IsPathRooted because it returns false under mono when using windows-based paths, e.g. C:\\ + + if (path.IndexOf("://", StringComparison.OrdinalIgnoreCase) != -1 && + !path.StartsWith("file://", StringComparison.OrdinalIgnoreCase)) + { + return false; + } + return true; + + //return Path.IsPathRooted(path); + } + + public void DeleteFile(string path) + { + File.Delete(path); + } + + public void DeleteDirectory(string path, bool recursive) + { + Directory.Delete(path, recursive); + } + + public void CreateDirectory(string path) + { + Directory.CreateDirectory(path); + } + + public IEnumerable<FileSystemMetadata> GetDirectories(string path, bool recursive = false) + { + var searchOption = recursive ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly; + + return ToMetadata(path, new DirectoryInfo(path).EnumerateDirectories("*", searchOption)); + } + + public IEnumerable<FileSystemMetadata> GetFiles(string path, bool recursive = false) + { + var searchOption = recursive ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly; + + return ToMetadata(path, new DirectoryInfo(path).EnumerateFiles("*", searchOption)); + } + + public IEnumerable<FileSystemMetadata> GetFileSystemEntries(string path, bool recursive = false) + { + var directoryInfo = new DirectoryInfo(path); + var searchOption = recursive ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly; + + if (EnableFileSystemRequestConcat) + { + return ToMetadata(path, directoryInfo.EnumerateDirectories("*", searchOption)) + .Concat(ToMetadata(path, directoryInfo.EnumerateFiles("*", searchOption))); + } + + return ToMetadata(path, directoryInfo.EnumerateFileSystemInfos("*", searchOption)); + } + + private IEnumerable<FileSystemMetadata> ToMetadata(string parentPath, IEnumerable<FileSystemInfo> infos) + { + return infos.Select(i => + { + try + { + return GetFileSystemMetadata(i); + } + catch (PathTooLongException) + { + // Can't log using the FullName because it will throw the PathTooLongExceptiona again + //Logger.Warn("Path too long: {0}", i.FullName); + Logger.Warn("File or directory path too long. Parent folder: {0}", parentPath); + return null; + } + + }).Where(i => i != null); + } + + public Stream OpenRead(string path) + { + return File.OpenRead(path); + } + + public void CopyFile(string source, string target, bool overwrite) + { + File.Copy(source, target, overwrite); + } + + public void MoveFile(string source, string target) + { + File.Move(source, target); + } + + public void MoveDirectory(string source, string target) + { + Directory.Move(source, target); + } + + public bool DirectoryExists(string path) + { + return Directory.Exists(path); + } + + public bool FileExists(string path) + { + return File.Exists(path); + } + + public string ReadAllText(string path) + { + return File.ReadAllText(path); + } + + public void WriteAllText(string path, string text, Encoding encoding) + { + File.WriteAllText(path, text, encoding); + } + + public void WriteAllText(string path, string text) + { + File.WriteAllText(path, text); + } + + public string ReadAllText(string path, Encoding encoding) + { + return File.ReadAllText(path, encoding); + } + + public IEnumerable<string> GetDirectoryPaths(string path, bool recursive = false) + { + var searchOption = recursive ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly; + return Directory.EnumerateDirectories(path, "*", searchOption); + } + + public IEnumerable<string> GetFilePaths(string path, bool recursive = false) + { + var searchOption = recursive ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly; + return Directory.EnumerateFiles(path, "*", searchOption); + } + + public IEnumerable<string> GetFileSystemEntryPaths(string path, bool recursive = false) + { + var searchOption = recursive ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly; + return Directory.EnumerateFileSystemEntries(path, "*", searchOption); + } + } +} diff --git a/MediaBrowser.Common.Implementations/IO/WindowsFileSystem.cs b/MediaBrowser.Common.Implementations/IO/WindowsFileSystem.cs new file mode 100644 index 000000000..e8f8de8ae --- /dev/null +++ b/MediaBrowser.Common.Implementations/IO/WindowsFileSystem.cs @@ -0,0 +1,14 @@ +using Patterns.Logging; + +namespace MediaBrowser.Common.Implementations.IO +{ + public class WindowsFileSystem : ManagedFileSystem + { + public WindowsFileSystem(ILogger logger) + : base(logger, true, true) + { + AddShortcutHandler(new LnkShortcutHandler()); + EnableFileSystemRequestConcat = false; + } + } +} |