Add Windows FileSystemWatcher

Author: austinv900

src/IO/Windows/WindowsFileSystem.cs

@@ -0,0 +1,109 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.IO;
+using System.Runtime.InteropServices;
+using System.Text;
+using Oxide.Core;
+
+namespace Oxide.IO.Windows
+{
+    internal class WindowsFileSystem : IFileSystem
+    {
+        private const int MAX_BUFFERS = 5;
+
+        #region API
+
+        private static readonly IntPtr INVALID_HANDLE_VALUE = new IntPtr(-1);
+
+        private const uint FILE_READ_EA = 0x0008;
+        private const uint FILE_FLAG_BACKUP_SEMANTICS = 0x2000000;
+
+        [DllImport("Kernel32.dll", SetLastError = true, CharSet = CharSet.Auto)]
+        private static extern uint GetFinalPathNameByHandle(
+            IntPtr hFile,
+            [MarshalAs(UnmanagedType.LPTStr)] StringBuilder lpszFilePath,
+            uint cchFilePath,
+            uint dwFlags);
+
+        [DllImport("kernel32.dll", SetLastError = true)]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        private static extern bool CloseHandle(IntPtr hObject);
+
+        [DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
+        public static extern IntPtr CreateFile(
+            [MarshalAs(UnmanagedType.LPTStr)] string filename,
+            [MarshalAs(UnmanagedType.U4)] uint access,
+            [MarshalAs(UnmanagedType.U4)] FileShare share,
+            IntPtr securityAttributes, // optional SECURITY_ATTRIBUTES struct or IntPtr.Zero
+            [MarshalAs(UnmanagedType.U4)] FileMode creationDisposition,
+            [MarshalAs(UnmanagedType.U4)] uint flagsAndAttributes,
+            IntPtr templateFile);
+
+        #endregion
+
+        private Queue<StringBuilder> StrBuffers { get; } = new Queue<StringBuilder>();
+
+        public bool IsSymbolicLink(string path)
+        {
+            if (File.Exists(path) || Directory.Exists(path))
+            {
+                return (File.GetAttributes(path) & FileAttributes.ReparsePoint) == FileAttributes.ReparsePoint;
+            }
+
+            return false;
+        }
+
+        public string ResolvePath(string path)
+        {
+            if (!IsSymbolicLink(path))
+            {
+                path = Path.GetFullPath(path);
+                return path;
+            }
+
+            IntPtr handle = CreateFile(path, FILE_READ_EA, FileShare.ReadWrite | FileShare.Delete,
+                                       IntPtr.Zero, FileMode.Open, FILE_FLAG_BACKUP_SEMANTICS, IntPtr.Zero);
+
+            if (handle == INVALID_HANDLE_VALUE)
+            {
+                throw new Win32Exception(Marshal.GetLastWin32Error());
+            }
+
+            StringBuilder str;
+
+            lock (StrBuffers)
+            {
+                str = StrBuffers.Count == 0 ? new StringBuilder(1024) : StrBuffers.Dequeue();
+            }
+
+            str.Length = 0;
+            try
+            {
+                uint fl = GetFinalPathNameByHandle(handle, str, 1024, 0);
+
+                if (fl == 0)
+                {
+                    throw new Win32Exception(Marshal.GetLastWin32Error());
+                }
+
+                path = str.ToString().TrimStart('\\', '?');
+                Interface.Oxide.LogDebug($"Symbolic: {path}");
+                return path;
+            }
+            finally
+            {
+                CloseHandle(handle);
+
+                lock (StrBuffers)
+                {
+                    if (StrBuffers.Count < MAX_BUFFERS)
+                    {
+                        str.Length = 0;
+                        StrBuffers.Enqueue(str);
+                    }
+                }
+            }
+        }
+    }
+}

src/IO/Windows/WindowsFileSystemWatcher.cs

@@ -0,0 +1,92 @@
+using System;
+using System.IO;
+
+namespace Oxide.IO.Windows
+{
+    internal class WindowsFileSystemWatcher : CachedFileSystemWatcher
+    {
+        private readonly FileSystemWatcher watcher;
+        private int currentSub = -1;
+
+        public WindowsFileSystemWatcher(IFileSystem fs, string directory, bool subDirs, NotifyMask filter, StringComparison stringComparison = StringComparison.OrdinalIgnoreCase) : base(directory, subDirs, filter, fs, stringComparison)
+        {
+            watcher = new FileSystemWatcher(Directory, "*")
+            {
+                EnableRaisingEvents = false
+            };
+
+            watcher.IncludeSubdirectories = IncludeSubDirectories;
+            watcher.NotifyFilter = NotifyFilters.LastAccess
+                                   | NotifyFilters.LastWrite
+                                   | NotifyFilters.FileName
+                                   | NotifyFilters.DirectoryName;
+
+            watcher.Deleted += OnDeleted;
+            watcher.Changed += OnChanged;
+            watcher.Created += OnCreated;
+            watcher.Renamed += OnRenamed;
+            watcher.Error += OnError;
+        }
+
+        public override void EndInit()
+        {
+            watcher.EnableRaisingEvents = true;
+            base.EndInit();
+        }
+
+        protected override int SubscribeTo(string directory)
+        {
+            return currentSub++;
+        }
+
+        protected override bool UnsubscribeFrom(int id)
+        {
+            return true;
+        }
+
+        protected override void OnDispose()
+        {
+            watcher.Dispose();
+        }
+
+        private void OnRenamed(object sender, RenamedEventArgs args)
+        {
+            bool isDirectory = System.IO.Directory.Exists(args.FullPath);
+            CleanName(args.OldFullPath, out string directory, out string name);
+            OnFileSystemEvent(directory, name, isDirectory ? NotifyMask.OnMovedFrom | NotifyMask.DirectoryOnly : NotifyMask.OnMovedFrom);
+            CleanName(args.FullPath, out directory, out name);
+            OnFileSystemEvent(directory, name, isDirectory ? NotifyMask.OnMovedTo | NotifyMask.DirectoryOnly : NotifyMask.OnMovedTo);
+        }
+
+        private void OnDeleted(object sender, FileSystemEventArgs args)
+        {
+            bool isDirectory = args.FullPath.EndsWith(Path.DirectorySeparatorChar.ToString()) || !Path.HasExtension(args.FullPath);
+            CleanName(args.FullPath, out string directory, out string name);
+            OnFileSystemEvent(directory, name, isDirectory ? NotifyMask.OnDeleted | NotifyMask.DirectoryOnly : NotifyMask.OnDeleted);
+        }
+
+        private void OnError(object sender, ErrorEventArgs args) => OnFileSystemError(args.GetException());
+
+        private void OnCreated(object sender, FileSystemEventArgs args)
+        {
+            bool isDirectory = System.IO.Directory.Exists(args.FullPath);
+            CleanName(args.FullPath, out string directory, out string name);
+            OnFileSystemEvent(directory, name, isDirectory ? NotifyMask.OnCreated | NotifyMask.DirectoryOnly : NotifyMask.OnCreated);
+        }
+
+        private void OnChanged(object sender,  FileSystemEventArgs args)
+        {
+            bool isDirectory = System.IO.Directory.Exists(args.FullPath);
+            CleanName(args.FullPath, out string directory, out string name);
+            OnFileSystemEvent(directory, name, isDirectory ? NotifyMask.OnModified | NotifyMask.DirectoryOnly : NotifyMask.OnModified);
+        }
+
+        protected override void OnFileSystemEvent(string directory, string name, NotifyMask mask)
+        {
+            directory = FileSystem.ResolvePath(directory);
+            string fullPath = Path.Combine(directory, name);
+            CleanName(fullPath, out directory, out name);
+            base.OnFileSystemEvent(directory, name, mask);
+        }
+    }
+}