Add file watcher API and Linux implementation

Author: meyraud705

include/SDL3/SDL_events.h

@@ -259,6 +259,10 @@ typedef enum SDL_EventType
     SDL_EVENT_CAMERA_DEVICE_APPROVED,        /**< A camera device has been approved for use by the user. */
     SDL_EVENT_CAMERA_DEVICE_DENIED,          /**< A camera device has been denied for use by the user. */
 
+    /* File watch events */
+    SDL_EVENT_FILE_WATCH_ERROR = 0x1500, /**< Watched files may have been modified, but the events are lost. */
+    SDL_EVENT_FILE_CHANGED,              /**< A watched file was written. */
+
     /* Render events */
     SDL_EVENT_RENDER_TARGETS_RESET = 0x2000, /**< The render targets have been reset and their contents need to be updated */
     SDL_EVENT_RENDER_DEVICE_RESET, /**< The device has been reset and all textures need to be recreated */
@@ -970,6 +974,17 @@ typedef struct SDL_SensorEvent
     Uint64 sensor_timestamp; /**< The timestamp of the sensor reading in nanoseconds, not necessarily synchronized with the system clock */
 } SDL_SensorEvent;
 
+/**
+ * File watch event structure (event.file_watch.*)
+ */
+typedef struct SDL_FileWatchEvent
+{
+    SDL_EventType type; /**< SDL_EVENT_FILE_WATCH_ERROR or SDL_EVENT_FILE_CHANGED */
+    Uint32 reserved;
+    Uint64 timestamp;   /**< In nanoseconds, populated using SDL_GetTicksNS() */
+    const char* path;   /**< Path of the modified file for SDL_EVENT_FILE_CHANGED, NULL for SDL_EVENT_FILE_WATCH_ERROR */
+} SDL_FileWatchEvent;
+
 /**
  * The "quit requested" event
  *
@@ -1054,6 +1069,7 @@ typedef union SDL_Event
     SDL_RenderEvent render;                 /**< Render event data */
     SDL_DropEvent drop;                     /**< Drag and drop event data */
     SDL_ClipboardEvent clipboard;           /**< Clipboard event data */
+    SDL_FileWatchEvent file_watch;          /**< File watch event data */
 
     /* This is necessary for ABI compatibility between Visual C++ and GCC.
        Visual C++ will respect the push pack pragma and use 52 bytes (size of

src/events/SDL_events.c

@@ -28,6 +28,7 @@
 #include "../SDL_hints_c.h"
 #include "../audio/SDL_audio_c.h"
 #include "../camera/SDL_camera_c.h"
+#include "../filesystem/SDL_filesystem_c.h"
 #include "../timer/SDL_timer_c.h"
 #include "../core/linux/SDL_udev.h"
 #ifndef SDL_JOYSTICK_DISABLED
@@ -1458,6 +1459,8 @@ bool SDL_RunOnMainThread(SDL_MainThreadCallback callback, void *userdata, bool w
 
 void SDL_PumpEventMaintenance(void)
 {
+    SDL_UpdateFileWatch();
+
 #ifdef SDL_USE_LIBUDEV
     SDL_UDEV_Poll();
 #endif

src/filesystem/SDL_filesystem.c

@@ -142,6 +142,19 @@ bool SDL_GetPathInfo(const char *path, SDL_PathInfo *info)
     return SDL_SYS_GetPathInfo(path, info);
 }
 
+bool SDL_WatchFileForChanges(const char *path)
+{
+    CHECK_PARAM(!path) {
+        return SDL_InvalidParamError("path");
+    }
+    return SDL_SYS_WatchFileForChanges(path);
+}
+
+void SDL_UpdateFileWatch(void)
+{
+    SDL_SYS_UpdateFileWatch();
+}
+
 static bool EverythingMatch(const char *pattern, const char *str, bool *matched_to_dir)
 {
     SDL_assert(pattern == NULL);
@@ -547,5 +560,6 @@ void SDL_QuitFilesystem(void)
             CachedUserFolders[i] = NULL;
         }
     }
+    SDL_SYS_QuitFileWatch();
 }
 

src/filesystem/SDL_filesystem_c.h

@@ -25,5 +25,6 @@
 extern void SDL_InitFilesystem(void);
 extern void SDL_QuitFilesystem(void);
 
+extern void SDL_UpdateFileWatch(void);
 #endif
 

src/filesystem/SDL_sysfilesystem.h

@@ -35,6 +35,10 @@ extern bool SDL_SYS_CopyFile(const char *oldpath, const char *newpath);
 extern bool SDL_SYS_CreateDirectory(const char *path);
 extern bool SDL_SYS_GetPathInfo(const char *path, SDL_PathInfo *info);
 
+extern bool SDL_SYS_WatchFileForChanges(const char *path);
+extern void SDL_SYS_UpdateFileWatch(void);
+extern void SDL_SYS_QuitFileWatch(void);
+
 typedef bool (*SDL_GlobEnumeratorFunc)(const char *path, SDL_EnumerateDirectoryCallback cb, void *cbuserdata, void *userdata);
 typedef bool (*SDL_GlobGetPathInfoFunc)(const char *path, SDL_PathInfo *info, void *userdata);
 extern char **SDL_InternalGlobDirectory(const char *path, const char *pattern, SDL_GlobFlags flags, int *count, SDL_GlobEnumeratorFunc enumerator, SDL_GlobGetPathInfoFunc getpathinfo, void *userdata);

src/filesystem/dummy/SDL_sysfsops.c

@@ -58,5 +58,18 @@ bool SDL_SYS_GetPathInfo(const char *path, SDL_PathInfo *info)
     return SDL_Unsupported();
 }
 
+bool SDL_SYS_WatchFileForChanges(const char *path)
+{
+    return SDL_Unsupported();
+}
+
+void SDL_SYS_UpdateFileWatch(void)
+{
+}
+
+void SDL_SYS_QuitFileWatch(void)
+{
+}
+
 #endif // SDL_FSOPS_DUMMY
 

src/filesystem/posix/SDL_sysfsops.c

@@ -27,6 +27,8 @@
 // System dependent filesystem routines
 
 #include "../SDL_sysfilesystem.h"
+#include "../../SDL_hashtable.h"
+#include "../../events/SDL_events_c.h"
 
 #include <stdio.h>
 #include <string.h>
@@ -39,6 +41,10 @@
 #include "../../core/android/SDL_android.h"
 #endif
 
+#ifdef HAVE_INOTIFY
+#include <sys/inotify.h>
+#include <linux/limits.h>
+#endif
 
 bool SDL_SYS_EnumerateDirectory(const char *path, SDL_EnumerateDirectoryCallback cb, void *userdata)
 {
@@ -410,6 +416,161 @@ bool SDL_SYS_GetPathInfo(const char *path, SDL_PathInfo *info)
     return true;
 }
 
+#ifdef HAVE_INOTIFY
+static int inotify_fd = -1;
+static SDL_HashTable *watch_descriptor_table = NULL; // stores directory or file path for a watch descriptor
+static SDL_Mutex *file_watch_lock = NULL;
+
+#ifdef HAVE_INOTIFY_INIT1
+static int SDL_inotify_init1(void)
+{
+    return inotify_init1(IN_NONBLOCK | IN_CLOEXEC);
+}
+#else
+static int SDL_inotify_init1(void)
+{
+    int fd = inotify_init();
+    if (fd < 0) {
+        return -1;
+    }
+    fcntl(fd, F_SETFL, O_NONBLOCK);
+    fcntl(fd, F_SETFD, FD_CLOEXEC);
+    return fd;
+}
+#endif // HAVE_INOTIFY_INIT1
+#endif // HAVE_INOTIFY
+
+bool SDL_SYS_WatchFileForChanges(const char *path)
+{
+#ifdef HAVE_INOTIFY
+    if (!watch_descriptor_table) {
+        watch_descriptor_table = SDL_CreateHashTable(0, false, SDL_HashID, SDL_KeyMatchID, SDL_DestroyHashValue, NULL);
+        if (!watch_descriptor_table) {
+            return false;
+        }
+        inotify_fd = SDL_inotify_init1();
+        if (inotify_fd == -1) {
+            SDL_DestroyHashTable(watch_descriptor_table);
+            watch_descriptor_table = NULL;
+            return SDL_SetError("Could not initialize inotify: %s", strerror(errno));
+        }
+        file_watch_lock = SDL_CreateMutex();
+        if (!file_watch_lock) {
+            SDL_DestroyHashTable(watch_descriptor_table);
+            watch_descriptor_table = NULL;
+            close(inotify_fd);
+            inotify_fd = -1;
+            return false;
+        }
+    }
+
+    char *p = SDL_strdup(path);
+    if (!p) {
+        return false;
+    }
+    // remove separator at the end of the path
+    const size_t slen = SDL_strlen(p);
+    if (p[slen - 1] == '/') {
+        p[slen - 1] = '\0';
+    }
+
+    SDL_LockMutex(file_watch_lock);
+    int wd = inotify_add_watch(inotify_fd, p, IN_MODIFY);
+    if (wd == -1) {
+        SDL_UnlockMutex(file_watch_lock);
+        SDL_free(p);
+        return SDL_SetError("inotify_add_watch failed: %s", strerror(errno));
+    }
+    if (!SDL_InsertIntoHashTable(watch_descriptor_table, (void *)(intptr_t)wd, p, false)) {
+        inotify_rm_watch(inotify_fd, wd);
+        SDL_UnlockMutex(file_watch_lock);
+        SDL_free(p);
+        return false;
+    }
+    SDL_UnlockMutex(file_watch_lock);
+    return true;
+#else
+    return SDL_Unsupported();
+#endif // HAVE_INOTIFY
+}
+
+void SDL_SYS_UpdateFileWatch(void)
+{
+#ifdef HAVE_INOTIFY
+    if (inotify_fd >= 0) {
+        SDL_LockMutex(file_watch_lock);
+        union
+        {
+            struct inotify_event event;
+            char storage[4096];
+            char enough_for_inotify[sizeof(struct inotify_event) + NAME_MAX + 1];
+        } buf;
+        ssize_t bytes;
+        size_t remain = 0;
+        size_t len;
+        char path[PATH_MAX];
+
+        bytes = read(inotify_fd, &buf, sizeof(buf));
+
+        if (bytes > 0) {
+            remain = (size_t)bytes;
+        }
+
+        while (remain > 0) {
+            const char *watched_path;
+            if (SDL_FindInHashTable(watch_descriptor_table, (void *)(intptr_t)buf.event.wd, (const void **)&watched_path)) {
+                const char *path_tmp;
+                SDL_EventType event_type;
+                bool post_event = true;
+                if (buf.event.mask & IN_Q_OVERFLOW) {
+                    event_type = SDL_EVENT_FILE_WATCH_ERROR;
+                    path_tmp = NULL;
+                } else if (buf.event.len != 0) {
+                    (void)SDL_snprintf(path, SDL_arraysize(path), "%s/%s", watched_path, buf.event.name);
+                    event_type = SDL_EVENT_FILE_CHANGED;
+                    path_tmp = SDL_CreateTemporaryString(path);
+                    post_event = (path_tmp != NULL);
+                } else {
+                    event_type = SDL_EVENT_FILE_CHANGED;
+                    path_tmp = SDL_CreateTemporaryString(watched_path);
+                    post_event = (path_tmp != NULL);
+                }
+                if (post_event && SDL_EventEnabled(event_type)) {
+                    SDL_Event event;
+                    SDL_zero(event);
+                    event.type = event_type;
+                    event.common.timestamp = 0;
+                    event.file_watch.path = path_tmp;
+                    SDL_PushEvent(&event);
+                }
+            }
+
+            len = sizeof(struct inotify_event) + buf.event.len;
+            remain -= len;
+
+            if (remain != 0) {
+                SDL_memmove(&buf.storage[0], &buf.storage[len], remain);
+            }
+        }
+        SDL_UnlockMutex(file_watch_lock);
+    }
+#endif // HAVE_INOTIFY
+}
+
+void SDL_SYS_QuitFileWatch(void)
+{
+#ifdef HAVE_INOTIFY
+    if (inotify_fd >= 0) {
+        close(inotify_fd);
+        inotify_fd = -1;
+        SDL_DestroyMutex(file_watch_lock);
+        file_watch_lock = NULL;
+        SDL_DestroyHashTable(watch_descriptor_table);
+        watch_descriptor_table = NULL;
+    }
+#endif // HAVE_INOTIFY
+}
+
 // Note that this is actually part of filesystem, not fsops, but everything that uses posix fsops uses this implementation, even with separate filesystem code.
 char *SDL_SYS_GetCurrentDirectory(void)
 {

src/filesystem/windows/SDL_sysfsops.c

@@ -231,5 +231,18 @@ bool SDL_SYS_GetPathInfo(const char *path, SDL_PathInfo *info)
     return true;
 }
 
+bool SDL_SYS_WatchFileForChanges(const char *path)
+{
+    return SDL_Unsupported();
+}
+
+void SDL_SYS_UpdateFileWatch(void)
+{
+}
+
+void SDL_SYS_QuitFileWatch(void)
+{
+}
+
 #endif // SDL_FSOPS_WINDOWS