Merge pull request #2256 from MediaBrowser/dev

Dev

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;
+        }
+    }
+}