mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-17 11:21:39 -10:00
Modulo the GUID in the assembly and the GUID embedded in some field initializers that use the assembly GUID for their name, the assemblies are idential before and after the patch.
628 lines
17 KiB
C#
628 lines
17 KiB
C#
//
|
|
// System.IO.Inotify.cs: interface with inotify
|
|
//
|
|
// Authors:
|
|
// Gonzalo Paniagua ([email protected])
|
|
// Anders Rune Jensen ([email protected])
|
|
//
|
|
// (c) 2006 Novell, Inc. (http://www.novell.com)
|
|
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining
|
|
// a copy of this software and associated documentation files (the
|
|
// "Software"), to deal in the Software without restriction, including
|
|
// without limitation the rights to use, copy, modify, merge, publish,
|
|
// distribute, sublicense, and/or sell copies of the Software, and to
|
|
// permit persons to whom the Software is furnished to do so, subject to
|
|
// the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be
|
|
// included in all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
|
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
|
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
|
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
//
|
|
|
|
using System;
|
|
using System.Collections;
|
|
using System.ComponentModel;
|
|
using System.Runtime.CompilerServices;
|
|
using System.Runtime.InteropServices;
|
|
using System.Text;
|
|
using System.Threading;
|
|
|
|
namespace System.IO {
|
|
|
|
[Flags]
|
|
enum InotifyMask : uint {
|
|
Access = 1 << 0,
|
|
Modify = 1 << 1,
|
|
Attrib = 1 << 2,
|
|
CloseWrite = 1 << 3,
|
|
CloseNoWrite = 1 << 4,
|
|
Open = 1 << 5,
|
|
MovedFrom = 1 << 6,
|
|
MovedTo = 1 << 7,
|
|
Create = 1 << 8,
|
|
Delete = 1 << 9,
|
|
DeleteSelf = 1 << 10,
|
|
MoveSelf = 1 << 11,
|
|
BaseEvents = 0x00000fff,
|
|
// Can be sent at any time
|
|
Umount = 0x0002000,
|
|
Overflow = 0x0004000,
|
|
Ignored = 0x0008000,
|
|
|
|
// Special flags.
|
|
OnlyDir = 0x01000000,
|
|
DontFollow = 0x02000000,
|
|
AddMask = 0x20000000,
|
|
Directory = 0x40000000,
|
|
OneShot = 0x80000000
|
|
}
|
|
|
|
struct InotifyEvent { // Our internal representation for the data returned by the kernel
|
|
public static readonly InotifyEvent Default = new InotifyEvent ();
|
|
public int WatchDescriptor;
|
|
public InotifyMask Mask;
|
|
public string Name;
|
|
|
|
public override string ToString ()
|
|
{
|
|
return String.Format ("[Descriptor: {0} Mask: {1} Name: {2}]", WatchDescriptor, Mask, Name);
|
|
}
|
|
}
|
|
|
|
class ParentInotifyData
|
|
{
|
|
public bool IncludeSubdirs;
|
|
public bool Enabled;
|
|
public ArrayList children; // InotifyData
|
|
public InotifyData data;
|
|
}
|
|
|
|
class InotifyData {
|
|
public FileSystemWatcher FSW;
|
|
public string Directory;
|
|
public int Watch;
|
|
}
|
|
|
|
class InotifyWatcher : IFileWatcher
|
|
{
|
|
static bool failed;
|
|
static InotifyWatcher instance;
|
|
static Hashtable watches; // FSW to ParentInotifyData
|
|
static Hashtable requests; // FSW to InotifyData
|
|
static IntPtr FD;
|
|
static Thread thread;
|
|
static bool stop;
|
|
|
|
private InotifyWatcher ()
|
|
{
|
|
}
|
|
|
|
// Locked by caller
|
|
public static bool GetInstance (out IFileWatcher watcher, bool gamin)
|
|
{
|
|
if (failed == true) {
|
|
watcher = null;
|
|
return false;
|
|
}
|
|
|
|
if (instance != null) {
|
|
watcher = instance;
|
|
return true;
|
|
}
|
|
|
|
FD = GetInotifyInstance ();
|
|
if ((long) FD == -1) {
|
|
failed = true;
|
|
watcher = null;
|
|
return false;
|
|
}
|
|
|
|
watches = Hashtable.Synchronized (new Hashtable ());
|
|
requests = Hashtable.Synchronized (new Hashtable ());
|
|
instance = new InotifyWatcher ();
|
|
watcher = instance;
|
|
return true;
|
|
}
|
|
|
|
public void StartDispatching (FileSystemWatcher fsw)
|
|
{
|
|
ParentInotifyData parent;
|
|
lock (this) {
|
|
if ((long) FD == -1)
|
|
FD = GetInotifyInstance ();
|
|
|
|
if (thread == null) {
|
|
thread = new Thread (new ThreadStart (Monitor));
|
|
thread.IsBackground = true;
|
|
thread.Start ();
|
|
}
|
|
|
|
parent = (ParentInotifyData) watches [fsw];
|
|
}
|
|
|
|
if (parent == null) {
|
|
InotifyData data = new InotifyData ();
|
|
data.FSW = fsw;
|
|
data.Directory = fsw.FullPath;
|
|
|
|
parent = new ParentInotifyData();
|
|
parent.IncludeSubdirs = fsw.IncludeSubdirectories;
|
|
parent.Enabled = true;
|
|
parent.children = new ArrayList();
|
|
parent.data = data;
|
|
|
|
watches [fsw] = parent;
|
|
|
|
try {
|
|
StartMonitoringDirectory (data, false);
|
|
lock (this) {
|
|
AppendRequestData (data);
|
|
stop = false;
|
|
}
|
|
} catch {} // ignore the directory if StartMonitoringDirectory fails.
|
|
}
|
|
}
|
|
|
|
static void AppendRequestData (InotifyData data)
|
|
{
|
|
int wd = data.Watch;
|
|
|
|
object obj = requests [wd];
|
|
ArrayList list = null;
|
|
if (obj == null) {
|
|
requests [data.Watch] = data;
|
|
} else if (obj is InotifyData) {
|
|
list = new ArrayList ();
|
|
list.Add (obj);
|
|
list.Add (data);
|
|
requests [data.Watch] = list;
|
|
} else {
|
|
list = (ArrayList) obj;
|
|
list.Add (data);
|
|
}
|
|
}
|
|
|
|
static bool RemoveRequestData (InotifyData data)
|
|
{
|
|
int wd = data.Watch;
|
|
object obj = requests [wd];
|
|
if (obj == null)
|
|
return true;
|
|
|
|
if (obj is InotifyData) {
|
|
if (obj == data) {
|
|
requests.Remove (wd);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
ArrayList list = (ArrayList) obj;
|
|
list.Remove (data);
|
|
if (list.Count == 0) {
|
|
requests.Remove (wd);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Attempt to match MS and linux behavior.
|
|
static InotifyMask GetMaskFromFilters (NotifyFilters filters)
|
|
{
|
|
InotifyMask mask = InotifyMask.Create | InotifyMask.Delete | InotifyMask.DeleteSelf | InotifyMask.AddMask;
|
|
if ((filters & NotifyFilters.Attributes) != 0)
|
|
mask |= InotifyMask.Attrib;
|
|
|
|
if ((filters & NotifyFilters.Security) != 0)
|
|
mask |= InotifyMask.Attrib;
|
|
|
|
if ((filters & NotifyFilters.Size) != 0) {
|
|
mask |= InotifyMask.Attrib;
|
|
mask |= InotifyMask.Modify;
|
|
}
|
|
|
|
if ((filters & NotifyFilters.LastAccess) != 0) {
|
|
mask |= InotifyMask.Attrib;
|
|
mask |= InotifyMask.Access;
|
|
mask |= InotifyMask.Modify;
|
|
}
|
|
|
|
if ((filters & NotifyFilters.LastWrite) != 0) {
|
|
mask |= InotifyMask.Attrib;
|
|
mask |= InotifyMask.Modify;
|
|
}
|
|
|
|
if ((filters & NotifyFilters.FileName) != 0) {
|
|
mask |= InotifyMask.MovedFrom;
|
|
mask |= InotifyMask.MovedTo;
|
|
}
|
|
|
|
if ((filters & NotifyFilters.DirectoryName) != 0) {
|
|
mask |= InotifyMask.MovedFrom;
|
|
mask |= InotifyMask.MovedTo;
|
|
}
|
|
|
|
return mask;
|
|
}
|
|
|
|
static void StartMonitoringDirectory (InotifyData data, bool justcreated)
|
|
{
|
|
InotifyMask mask = GetMaskFromFilters (data.FSW.NotifyFilter);
|
|
int wd = AddDirectoryWatch (FD, data.Directory, mask);
|
|
if (wd == -1) {
|
|
int error = Marshal.GetLastWin32Error ();
|
|
if (error == 4) { // Too many open watches
|
|
string nr_watches = "(unknown)";
|
|
try {
|
|
using (StreamReader reader = new StreamReader ("/proc/sys/fs/inotify/max_user_watches")) {
|
|
nr_watches = reader.ReadLine ();
|
|
}
|
|
} catch {}
|
|
|
|
string msg = String.Format ("The per-user inotify watches limit of {0} has been reached. " +
|
|
"If you're experiencing problems with your application, increase that limit " +
|
|
"in /proc/sys/fs/inotify/max_user_watches.", nr_watches);
|
|
|
|
throw new Win32Exception (error, msg);
|
|
}
|
|
throw new Win32Exception (error);
|
|
}
|
|
|
|
FileSystemWatcher fsw = data.FSW;
|
|
data.Watch = wd;
|
|
|
|
ParentInotifyData parent = (ParentInotifyData) watches[fsw];
|
|
|
|
if (parent.IncludeSubdirs) {
|
|
foreach (string directory in Directory.GetDirectories (data.Directory)) {
|
|
InotifyData fd = new InotifyData ();
|
|
fd.FSW = fsw;
|
|
fd.Directory = directory;
|
|
|
|
if (justcreated) {
|
|
lock (fsw) {
|
|
RenamedEventArgs renamed = null;
|
|
if (fsw.Pattern.IsMatch (directory)) {
|
|
fsw.DispatchEvents (FileAction.Added, directory, ref renamed);
|
|
if (fsw.Waiting) {
|
|
fsw.Waiting = false;
|
|
System.Threading.Monitor.PulseAll (fsw);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
try {
|
|
StartMonitoringDirectory (fd, justcreated);
|
|
AppendRequestData (fd);
|
|
parent.children.Add(fd);
|
|
} catch {} // ignore errors and don't add directory.
|
|
}
|
|
}
|
|
|
|
if (justcreated) {
|
|
foreach (string filename in Directory.GetFiles (data.Directory)) {
|
|
lock (fsw) {
|
|
RenamedEventArgs renamed = null;
|
|
if (fsw.Pattern.IsMatch (filename)) {
|
|
fsw.DispatchEvents (FileAction.Added, filename, ref renamed);
|
|
/* If a file has been created, then it has been written to */
|
|
fsw.DispatchEvents (FileAction.Modified, filename, ref renamed);
|
|
|
|
if (fsw.Waiting) {
|
|
fsw.Waiting = false;
|
|
System.Threading.Monitor.PulseAll(fsw);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void StopDispatching (FileSystemWatcher fsw)
|
|
{
|
|
ParentInotifyData parent;
|
|
lock (this) {
|
|
parent = (ParentInotifyData) watches [fsw];
|
|
if (parent == null)
|
|
return;
|
|
|
|
if (RemoveRequestData (parent.data)) {
|
|
StopMonitoringDirectory (parent.data);
|
|
}
|
|
watches.Remove (fsw);
|
|
if (watches.Count == 0) {
|
|
stop = true;
|
|
IntPtr fd = FD;
|
|
FD = (IntPtr) (-1);
|
|
Close (fd);
|
|
}
|
|
|
|
if (!parent.IncludeSubdirs)
|
|
return;
|
|
|
|
foreach (InotifyData idata in parent.children)
|
|
{
|
|
if (RemoveRequestData (idata)) {
|
|
StopMonitoringDirectory (idata);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void StopMonitoringDirectory (InotifyData data)
|
|
{
|
|
RemoveWatch (FD, data.Watch);
|
|
}
|
|
|
|
void Monitor ()
|
|
{
|
|
byte [] buffer = new byte [4096];
|
|
int nread;
|
|
while (!stop) {
|
|
nread = ReadFromFD (FD, buffer, (IntPtr) buffer.Length);
|
|
if (nread == -1)
|
|
continue;
|
|
|
|
lock (this) {
|
|
ProcessEvents (buffer, nread);
|
|
|
|
}
|
|
}
|
|
|
|
lock (this) {
|
|
thread = null;
|
|
stop = false;
|
|
}
|
|
}
|
|
/*
|
|
struct inotify_event {
|
|
__s32 wd;
|
|
__u32 mask;
|
|
__u32 cookie;
|
|
__u32 len; // Includes any trailing null in 'name'
|
|
char name[0];
|
|
};
|
|
*/
|
|
|
|
static int ReadEvent (byte [] source, int off, int size, out InotifyEvent evt)
|
|
{
|
|
evt = new InotifyEvent ();
|
|
if (size <= 0 || off > size - 16) {
|
|
return -1;
|
|
}
|
|
|
|
int len;
|
|
if (BitConverter.IsLittleEndian) {
|
|
evt.WatchDescriptor = source [off] + (source [off + 1] << 8) +
|
|
(source [off + 2] << 16) + (source [off + 3] << 24);
|
|
evt.Mask = (InotifyMask) (source [off + 4] + (source [off + 5] << 8) +
|
|
(source [off + 6] << 16) + (source [off + 7] << 24));
|
|
// Ignore Cookie -> +4
|
|
len = source [off + 12] + (source [off + 13] << 8) +
|
|
(source [off + 14] << 16) + (source [off + 15] << 24);
|
|
} else {
|
|
evt.WatchDescriptor = source [off + 3] + (source [off + 2] << 8) +
|
|
(source [off + 1] << 16) + (source [off] << 24);
|
|
evt.Mask = (InotifyMask) (source [off + 7] + (source [off + 6] << 8) +
|
|
(source [off + 5] << 16) + (source [off + 4] << 24));
|
|
// Ignore Cookie -> +4
|
|
len = source [off + 15] + (source [off + 14] << 8) +
|
|
(source [off + 13] << 16) + (source [off + 12] << 24);
|
|
}
|
|
|
|
if (len > 0) {
|
|
if (off > size - 16 - len)
|
|
return -1;
|
|
string name = Encoding.UTF8.GetString (source, off + 16, len);
|
|
evt.Name = name.Trim ('\0');
|
|
} else {
|
|
evt.Name = null;
|
|
}
|
|
|
|
return 16 + len;
|
|
}
|
|
|
|
static IEnumerable GetEnumerator (object source)
|
|
{
|
|
if (source == null)
|
|
yield break;
|
|
|
|
if (source is InotifyData)
|
|
yield return source;
|
|
|
|
if (source is ArrayList) {
|
|
ArrayList list = (ArrayList) source;
|
|
for (int i = 0; i < list.Count; i++)
|
|
yield return list [i];
|
|
}
|
|
}
|
|
|
|
/* Interesting events:
|
|
* Modify
|
|
* Attrib
|
|
* MovedFrom
|
|
* MovedTo
|
|
* Create
|
|
* Delete
|
|
* DeleteSelf
|
|
*/
|
|
static InotifyMask Interesting = InotifyMask.Modify | InotifyMask.Attrib | InotifyMask.MovedFrom |
|
|
InotifyMask.MovedTo | InotifyMask.Create | InotifyMask.Delete |
|
|
InotifyMask.DeleteSelf;
|
|
|
|
void ProcessEvents (byte [] buffer, int length)
|
|
{
|
|
ArrayList newdirs = null;
|
|
InotifyEvent evt;
|
|
int nread = 0;
|
|
RenamedEventArgs renamed = null;
|
|
while (length > nread) {
|
|
int bytes_read = ReadEvent (buffer, nread, length, out evt);
|
|
if (bytes_read <= 0)
|
|
break;
|
|
|
|
nread += bytes_read;
|
|
|
|
InotifyMask mask = evt.Mask;
|
|
bool is_directory = (mask & InotifyMask.Directory) != 0;
|
|
mask = (mask & Interesting); // Clear out all the bits that we don't need
|
|
if (mask == 0)
|
|
continue;
|
|
|
|
foreach (InotifyData data in GetEnumerator (requests [evt.WatchDescriptor])) {
|
|
ParentInotifyData parent = (ParentInotifyData) watches[data.FSW];
|
|
|
|
if (data == null || parent.Enabled == false)
|
|
continue;
|
|
|
|
string directory = data.Directory;
|
|
string filename = evt.Name;
|
|
if (filename == null)
|
|
filename = directory;
|
|
|
|
FileSystemWatcher fsw = data.FSW;
|
|
FileAction action = 0;
|
|
if ((mask & (InotifyMask.Modify | InotifyMask.Attrib)) != 0) {
|
|
action = FileAction.Modified;
|
|
} else if ((mask & InotifyMask.Create) != 0) {
|
|
action = FileAction.Added;
|
|
} else if ((mask & InotifyMask.Delete) != 0) {
|
|
action = FileAction.Removed;
|
|
} else if ((mask & InotifyMask.DeleteSelf) != 0) {
|
|
if (data.Watch != parent.data.Watch) {
|
|
// To avoid duplicate events handle DeleteSelf only for the top level directory.
|
|
continue;
|
|
}
|
|
action = FileAction.Removed;
|
|
} else if ((mask & InotifyMask.MoveSelf) != 0) {
|
|
//action = FileAction.Removed;
|
|
continue; // Ignore this one
|
|
} else if ((mask & InotifyMask.MovedFrom) != 0) {
|
|
InotifyEvent to;
|
|
int i = ReadEvent (buffer, nread, length, out to);
|
|
if (i == -1 || (to.Mask & InotifyMask.MovedTo) == 0 || evt.WatchDescriptor != to.WatchDescriptor) {
|
|
action = FileAction.Removed;
|
|
} else {
|
|
nread += i;
|
|
action = FileAction.RenamedNewName;
|
|
renamed = new RenamedEventArgs (WatcherChangeTypes.Renamed, data.Directory, to.Name, evt.Name);
|
|
if (evt.Name != data.Directory && !fsw.Pattern.IsMatch (evt.Name))
|
|
filename = to.Name;
|
|
}
|
|
} else if ((mask & InotifyMask.MovedTo) != 0) {
|
|
action = FileAction.Added;
|
|
}
|
|
if (fsw.IncludeSubdirectories) {
|
|
string full = fsw.FullPath;
|
|
string datadir = data.Directory;
|
|
if (datadir != full) {
|
|
int len = full.Length;
|
|
int slash = 1;
|
|
if (len > 1 && full [len - 1] == Path.DirectorySeparatorChar)
|
|
slash = 0;
|
|
string reldir = datadir.Substring (full.Length + slash);
|
|
datadir = Path.Combine (datadir, filename);
|
|
filename = Path.Combine (reldir, filename);
|
|
} else {
|
|
datadir = Path.Combine (full, filename);
|
|
}
|
|
|
|
if (action == FileAction.Added && is_directory) {
|
|
if (newdirs == null)
|
|
newdirs = new ArrayList (2);
|
|
|
|
InotifyData fd = new InotifyData ();
|
|
fd.FSW = fsw;
|
|
fd.Directory = datadir;
|
|
newdirs.Add (fd);
|
|
}
|
|
|
|
if (action == FileAction.RenamedNewName && is_directory) {
|
|
string renamedOldFullPath = renamed.OldFullPath;
|
|
string renamedFullPath = renamed.FullPath;
|
|
int renamedOldFullPathLength = renamedOldFullPath.Length;
|
|
|
|
foreach (InotifyData child in parent.children) {
|
|
|
|
if (child.Directory.StartsWith (renamedOldFullPath
|
|
, StringComparison.Ordinal
|
|
)) {
|
|
child.Directory = renamedFullPath +
|
|
child.Directory.Substring (renamedOldFullPathLength);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (action == FileAction.Removed && filename == data.Directory) {
|
|
int idx = parent.children.IndexOf (data);
|
|
if (idx != -1) {
|
|
parent.children.RemoveAt (idx);
|
|
if (!fsw.Pattern.IsMatch (Path.GetFileName (filename))) {
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (filename != data.Directory && !fsw.Pattern.IsMatch (Path.GetFileName (filename))) {
|
|
continue;
|
|
}
|
|
|
|
lock (fsw) {
|
|
fsw.DispatchEvents (action, filename, ref renamed);
|
|
if (action == FileAction.RenamedNewName)
|
|
renamed = null;
|
|
if (fsw.Waiting) {
|
|
fsw.Waiting = false;
|
|
System.Threading.Monitor.PulseAll (fsw);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (newdirs != null) {
|
|
foreach (InotifyData newdir in newdirs) {
|
|
try {
|
|
StartMonitoringDirectory (newdir, true);
|
|
AppendRequestData (newdir);
|
|
((ParentInotifyData) watches[newdir.FSW]).children.Add(newdir);
|
|
} catch {} // ignore the given directory
|
|
}
|
|
newdirs.Clear ();
|
|
}
|
|
}
|
|
|
|
static int AddDirectoryWatch (IntPtr fd, string directory, InotifyMask mask)
|
|
{
|
|
mask |= InotifyMask.Directory;
|
|
return AddWatch (fd, directory, mask);
|
|
}
|
|
|
|
[DllImport ("libc", EntryPoint="close")]
|
|
internal extern static int Close (IntPtr fd);
|
|
|
|
[DllImport ("libc", EntryPoint = "read")]
|
|
extern static int ReadFromFD (IntPtr fd, byte [] buffer, IntPtr length);
|
|
|
|
[MethodImplAttribute(MethodImplOptions.InternalCall)]
|
|
extern static IntPtr GetInotifyInstance ();
|
|
|
|
[MethodImplAttribute(MethodImplOptions.InternalCall)]
|
|
extern static int AddWatch (IntPtr fd, string name, InotifyMask mask);
|
|
|
|
[MethodImplAttribute(MethodImplOptions.InternalCall)]
|
|
extern static IntPtr RemoveWatch (IntPtr fd, int wd);
|
|
}
|
|
}
|
|
|