using System; using System.Collections.Generic; using System.Diagnostics; using System.IO; using System.Linq; using System.Text; using MediaBrowser.Model.IO; using MediaBrowser.Model.System; using Microsoft.Extensions.Logging; namespace Emby.Server.Implementations.IO { /// /// Class ManagedFileSystem /// public class ManagedFileSystem : IFileSystem { protected ILogger Logger; private readonly bool _supportsAsyncFileStreams; private char[] _invalidFileNameChars; private readonly List _shortcutHandlers = new List(); private bool EnableSeparateFileAndDirectoryQueries; private string _tempPath; private IEnvironmentInfo _environmentInfo; private bool _isEnvironmentCaseInsensitive; private string _defaultDirectory; public ManagedFileSystem(ILogger logger, IEnvironmentInfo environmentInfo, string defaultDirectory, string tempPath, bool enableSeparateFileAndDirectoryQueries) { Logger = logger; _supportsAsyncFileStreams = true; _tempPath = tempPath; _environmentInfo = environmentInfo; _defaultDirectory = defaultDirectory; // On Linux with mono, this needs to be true or symbolic links are ignored EnableSeparateFileAndDirectoryQueries = enableSeparateFileAndDirectoryQueries; SetInvalidFileNameChars(environmentInfo.OperatingSystem == MediaBrowser.Model.System.OperatingSystem.Windows); _isEnvironmentCaseInsensitive = environmentInfo.OperatingSystem == MediaBrowser.Model.System.OperatingSystem.Windows; } public string DefaultDirectory { get { var value = _defaultDirectory; if (!string.IsNullOrEmpty(value)) { try { if (DirectoryExists(value)) { return value; } } catch { } } return null; } } public void AddShortcutHandler(IShortcutHandler handler) { _shortcutHandlers.Add(handler); } protected void SetInvalidFileNameChars(bool enableManagedInvalidFileNameChars) { if (enableManagedInvalidFileNameChars) { _invalidFileNameChars = Path.GetInvalidFileNameChars(); } else { // Be consistent across platforms because the windows server will fail to query network shares that don't follow windows conventions // https://referencesource.microsoft.com/#mscorlib/system/io/path.cs _invalidFileNameChars = new char[] { '\"', '<', '>', '|', '\0', (char)1, (char)2, (char)3, (char)4, (char)5, (char)6, (char)7, (char)8, (char)9, (char)10, (char)11, (char)12, (char)13, (char)14, (char)15, (char)16, (char)17, (char)18, (char)19, (char)20, (char)21, (char)22, (char)23, (char)24, (char)25, (char)26, (char)27, (char)28, (char)29, (char)30, (char)31, ':', '*', '?', '\\', '/' }; } } public char DirectorySeparatorChar => Path.DirectorySeparatorChar; public string GetFullPath(string path) { return Path.GetFullPath(path); } /// /// Determines whether the specified filename is shortcut. /// /// The filename. /// true if the specified filename is shortcut; otherwise, false. /// filename public virtual bool IsShortcut(string filename) { if (string.IsNullOrEmpty(filename)) { throw new ArgumentNullException(nameof(filename)); } var extension = Path.GetExtension(filename); return _shortcutHandlers.Any(i => string.Equals(extension, i.Extension, StringComparison.OrdinalIgnoreCase)); } /// /// Resolves the shortcut. /// /// The filename. /// System.String. /// filename public virtual string ResolveShortcut(string filename) { if (string.IsNullOrEmpty(filename)) { throw new ArgumentNullException(nameof(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; } public string MakeAbsolutePath(string folderPath, string filePath) { if (string.IsNullOrWhiteSpace(filePath)) return filePath; if (filePath.Contains(@"://")) return filePath; //stream if (filePath.Length > 3 && filePath[1] == ':' && filePath[2] == '/') return filePath; //absolute local path // unc path if (filePath.StartsWith("\\\\")) { return filePath; } var firstChar = filePath[0]; if (firstChar == '/') { // For this we don't really know. return filePath; } if (firstChar == '\\') //relative path { filePath = filePath.Substring(1); } try { string path = System.IO.Path.Combine(folderPath, filePath); path = System.IO.Path.GetFullPath(path); return path; } catch (ArgumentException) { return filePath; } catch (PathTooLongException) { return filePath; } catch (NotSupportedException) { return filePath; } } /// /// Creates the shortcut. /// /// The shortcut path. /// The target. /// /// shortcutPath /// or /// target /// public void CreateShortcut(string shortcutPath, string target) { if (string.IsNullOrEmpty(shortcutPath)) { throw new ArgumentNullException(nameof(shortcutPath)); } if (string.IsNullOrEmpty(target)) { throw new ArgumentNullException(nameof(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(); } } /// /// Returns a object for the specified file or directory path. /// /// A path to a file or directory. /// A object. /// If the specified path points to a directory, the returned object's /// property will be set to true and all other properties will reflect the properties of the directory. public FileSystemMetadata GetFileSystemInfo(string 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)); } } /// /// Returns a object for the specified file path. /// /// A path to a file. /// A object. /// If the specified path points to a directory, the returned object's /// property and the property will both be set to false. /// For automatic handling of files and directories, use . public FileSystemMetadata GetFileInfo(string path) { var fileInfo = new FileInfo(path); return GetFileSystemMetadata(fileInfo); } /// /// Returns a object for the specified directory path. /// /// A path to a directory. /// A object. /// If the specified path points to a file, the returned object's /// property will be set to true and the property will be set to false. /// For automatic handling of files and directories, use . public FileSystemMetadata GetDirectoryInfo(string 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) { result.IsDirectory = info is DirectoryInfo || (info.Attributes & FileAttributes.Directory) == FileAttributes.Directory; //if (!result.IsDirectory) //{ // result.IsHidden = (info.Attributes & FileAttributes.Hidden) == FileAttributes.Hidden; //} 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; } private static ExtendedFileSystemInfo GetExtendedFileSystemInfo(string path) { var result = new ExtendedFileSystemInfo(); var info = new FileInfo(path); if (info.Exists) { result.Exists = true; var attributes = info.Attributes; result.IsHidden = (attributes & FileAttributes.Hidden) == FileAttributes.Hidden; result.IsReadOnly = (attributes & FileAttributes.ReadOnly) == FileAttributes.ReadOnly; } return result; } /// /// The space char /// private const char SpaceChar = ' '; /// /// Takes a filename and removes invalid characters /// /// The filename. /// System.String. /// filename public string GetValidFilename(string filename) { var builder = new StringBuilder(filename); foreach (var c in _invalidFileNameChars) { builder = builder.Replace(c, SpaceChar); } return builder.ToString(); } /// /// Gets the creation time UTC. /// /// The info. /// DateTime. 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.LogError(ex, "Error determining CreationTimeUtc for {FullName}", info.FullName); return DateTime.MinValue; } } /// /// Gets the creation time UTC. /// /// The path. /// DateTime. 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; } /// /// Gets the creation time UTC. /// /// The info. /// DateTime. 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.LogError(ex, "Error determining LastAccessTimeUtc for {FullName}", info.FullName); return DateTime.MinValue; } } /// /// Gets the last write time UTC. /// /// The path. /// DateTime. public DateTime GetLastWriteTimeUtc(string path) { return GetLastWriteTimeUtc(GetFileSystemInfo(path)); } /// /// Gets the file stream. /// /// The path. /// The mode. /// The access. /// The share. /// if set to true [is asynchronous]. /// FileStream. public Stream GetFileStream(string path, FileOpenMode mode, FileAccessMode access, FileShareMode share, bool isAsync = false) { if (_supportsAsyncFileStreams && isAsync) { return GetFileStream(path, mode, access, share, FileOpenOptions.Asynchronous); } return GetFileStream(path, mode, access, share, FileOpenOptions.None); } public Stream GetFileStream(string path, FileOpenMode mode, FileAccessMode access, FileShareMode share, FileOpenOptions fileOpenOptions) { var defaultBufferSize = 4096; return new FileStream(path, GetFileMode(mode), GetFileAccess(access), GetFileShare(share), defaultBufferSize, GetFileOptions(fileOpenOptions)); } private static FileOptions GetFileOptions(FileOpenOptions mode) { var val = (int)mode; return (FileOptions)val; } private static 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 static FileAccess GetFileAccess(FileAccessMode mode) { switch (mode) { //case FileAccessMode.ReadWrite: // return FileAccess.ReadWrite; case FileAccessMode.Write: return FileAccess.Write; case FileAccessMode.Read: return FileAccess.Read; default: throw new Exception("Unrecognized FileAccessMode"); } } private static FileShare GetFileShare(FileShareMode mode) { switch (mode) { case FileShareMode.ReadWrite: return FileShare.ReadWrite; case FileShareMode.Write: return FileShare.Write; case FileShareMode.Read: return FileShare.Read; case FileShareMode.None: return FileShare.None; default: throw new Exception("Unrecognized FileShareMode"); } } public void SetHidden(string path, bool isHidden) { if (_environmentInfo.OperatingSystem != MediaBrowser.Model.System.OperatingSystem.Windows) { return; } var info = GetExtendedFileSystemInfo(path); if (info.Exists && info.IsHidden != isHidden) { if (isHidden) { File.SetAttributes(path, File.GetAttributes(path) | FileAttributes.Hidden); } else { var attributes = File.GetAttributes(path); attributes = RemoveAttribute(attributes, FileAttributes.Hidden); File.SetAttributes(path, attributes); } } } public void SetReadOnly(string path, bool isReadOnly) { if (_environmentInfo.OperatingSystem != MediaBrowser.Model.System.OperatingSystem.Windows) { return; } var info = GetExtendedFileSystemInfo(path); if (info.Exists && info.IsReadOnly != isReadOnly) { if (isReadOnly) { File.SetAttributes(path, File.GetAttributes(path) | FileAttributes.ReadOnly); } else { var attributes = File.GetAttributes(path); attributes = RemoveAttribute(attributes, FileAttributes.ReadOnly); File.SetAttributes(path, attributes); } } } public void SetAttributes(string path, bool isHidden, bool isReadOnly) { if (_environmentInfo.OperatingSystem != MediaBrowser.Model.System.OperatingSystem.Windows) { return; } var info = GetExtendedFileSystemInfo(path); if (!info.Exists) { return; } if (info.IsReadOnly == isReadOnly && info.IsHidden == isHidden) { return; } var attributes = File.GetAttributes(path); if (isReadOnly) { attributes = attributes | FileAttributes.ReadOnly; } else { attributes = RemoveAttribute(attributes, FileAttributes.ReadOnly); } if (isHidden) { attributes = attributes | FileAttributes.Hidden; } else { attributes = RemoveAttribute(attributes, FileAttributes.Hidden); } File.SetAttributes(path, attributes); } private static FileAttributes RemoveAttribute(FileAttributes attributes, FileAttributes attributesToRemove) { return attributes & ~attributesToRemove; } /// /// Swaps the files. /// /// The file1. /// The file2. public void SwapFiles(string file1, string file2) { if (string.IsNullOrEmpty(file1)) { throw new ArgumentNullException(nameof(file1)); } if (string.IsNullOrEmpty(file2)) { throw new ArgumentNullException(nameof(file2)); } var temp1 = Path.Combine(_tempPath, Guid.NewGuid().ToString("N")); // Copying over will fail against hidden files SetHidden(file1, false); SetHidden(file2, false); Directory.CreateDirectory(_tempPath); CopyFile(file1, temp1, true); CopyFile(file2, file1, true); CopyFile(temp1, file2, true); } private static char GetDirectorySeparatorChar(string path) { return Path.DirectorySeparatorChar; } public bool ContainsSubPath(string parentPath, string path) { if (string.IsNullOrEmpty(parentPath)) { throw new ArgumentNullException(nameof(parentPath)); } if (string.IsNullOrEmpty(path)) { throw new ArgumentNullException(nameof(path)); } var separatorChar = GetDirectorySeparatorChar(parentPath); return path.IndexOf(parentPath.TrimEnd(separatorChar) + separatorChar, StringComparison.OrdinalIgnoreCase) != -1; } public bool IsRootPath(string path) { if (string.IsNullOrEmpty(path)) { throw new ArgumentNullException(nameof(path)); } var parent = GetDirectoryName(path); if (!string.IsNullOrEmpty(parent)) { return false; } return true; } public string GetDirectoryName(string path) { return Path.GetDirectoryName(path); } public string NormalizePath(string path) { if (string.IsNullOrEmpty(path)) { throw new ArgumentNullException(nameof(path)); } if (path.EndsWith(":\\", StringComparison.OrdinalIgnoreCase)) { return path; } return path.TrimEnd(GetDirectorySeparatorChar(path)); } public bool AreEqual(string path1, string path2) { if (path1 == null && path2 == null) { return true; } if (path1 == null || path2 == null) { return false; } return string.Equals(NormalizePath(path1), NormalizePath(path2), StringComparison.OrdinalIgnoreCase); } 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) { // 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) { SetAttributes(path, false, false); File.Delete(path); } public void DeleteDirectory(string path, bool recursive) { Directory.Delete(path, recursive); } public void CreateDirectory(string path) { Directory.CreateDirectory(path); } public List GetDrives() { // Only include drives in the ready state or this method could end up being very slow, waiting for drives to timeout return DriveInfo.GetDrives().Where(d => d.IsReady).Select(d => new FileSystemMetadata { Name = GetName(d), FullName = d.RootDirectory.FullName, IsDirectory = true }).ToList(); } private static string GetName(DriveInfo drive) { return drive.Name; } public IEnumerable GetDirectories(string path, bool recursive = false) { var searchOption = recursive ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly; return ToMetadata(new DirectoryInfo(path).EnumerateDirectories("*", searchOption)); } public IEnumerable GetFiles(string path, bool recursive = false) { return GetFiles(path, null, false, recursive); } public IEnumerable GetFiles(string path, string[] extensions, bool enableCaseSensitiveExtensions, bool recursive = false) { var searchOption = recursive ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly; // On linux and osx the search pattern is case sensitive // If we're OK with case-sensitivity, and we're only filtering for one extension, then use the native method if ((enableCaseSensitiveExtensions || _isEnvironmentCaseInsensitive) && extensions != null && extensions.Length == 1) { return ToMetadata(new DirectoryInfo(path).EnumerateFiles("*" + extensions[0], searchOption)); } var files = new DirectoryInfo(path).EnumerateFiles("*", searchOption); if (extensions != null && extensions.Length > 0) { files = files.Where(i => { var ext = i.Extension; if (ext == null) { return false; } return extensions.Contains(ext, StringComparer.OrdinalIgnoreCase); }); } return ToMetadata(files); } public IEnumerable GetFileSystemEntries(string path, bool recursive = false) { var directoryInfo = new DirectoryInfo(path); var searchOption = recursive ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly; if (EnableSeparateFileAndDirectoryQueries) { return ToMetadata(directoryInfo.EnumerateDirectories("*", searchOption)) .Concat(ToMetadata(directoryInfo.EnumerateFiles("*", searchOption))); } return ToMetadata(directoryInfo.EnumerateFileSystemInfos("*", searchOption)); } private IEnumerable ToMetadata(IEnumerable infos) { return infos.Select(GetFileSystemMetadata); } public string[] ReadAllLines(string path) { return File.ReadAllLines(path); } public void WriteAllLines(string path, IEnumerable lines) { File.WriteAllLines(path, lines); } public Stream OpenRead(string path) { return File.OpenRead(path); } private void CopyFileUsingStreams(string source, string target, bool overwrite) { using (var sourceStream = OpenRead(source)) { using (var targetStream = GetFileStream(target, FileOpenMode.Create, FileAccessMode.Write, FileShareMode.Read)) { sourceStream.CopyTo(targetStream); } } } 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 byte[] ReadAllBytes(string path) { return File.ReadAllBytes(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 void WriteAllBytes(string path, byte[] bytes) { File.WriteAllBytes(path, bytes); } public string ReadAllText(string path, Encoding encoding) { return File.ReadAllText(path, encoding); } public IEnumerable GetDirectoryPaths(string path, bool recursive = false) { var searchOption = recursive ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly; return Directory.EnumerateDirectories(path, "*", searchOption); } public IEnumerable GetFilePaths(string path, bool recursive = false) { return GetFilePaths(path, null, false, recursive); } public IEnumerable GetFilePaths(string path, string[] extensions, bool enableCaseSensitiveExtensions, bool recursive = false) { var searchOption = recursive ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly; // On linux and osx the search pattern is case sensitive // If we're OK with case-sensitivity, and we're only filtering for one extension, then use the native method if ((enableCaseSensitiveExtensions || _isEnvironmentCaseInsensitive) && extensions != null && extensions.Length == 1) { return Directory.EnumerateFiles(path, "*" + extensions[0], searchOption); } var files = Directory.EnumerateFiles(path, "*", searchOption); if (extensions != null && extensions.Length > 0) { files = files.Where(i => { var ext = Path.GetExtension(i); if (ext == null) { return false; } return extensions.Contains(ext, StringComparer.OrdinalIgnoreCase); }); } return files; } public IEnumerable GetFileSystemEntryPaths(string path, bool recursive = false) { var searchOption = recursive ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly; return Directory.EnumerateFileSystemEntries(path, "*", searchOption); } public virtual void SetExecutable(string path) { if (_environmentInfo.OperatingSystem == MediaBrowser.Model.System.OperatingSystem.OSX) { RunProcess("chmod", "+x \"" + path + "\"", GetDirectoryName(path)); } } private static void RunProcess(string path, string args, string workingDirectory) { using (var process = Process.Start(new ProcessStartInfo { Arguments = args, FileName = path, CreateNoWindow = true, WorkingDirectory = workingDirectory, WindowStyle = ProcessWindowStyle.Normal })) { process.WaitForExit(); } } } }