4 files changed, 344 insertions, 0 deletions

diff --git a/plugin/CMakeLists.txt b/plugin/CMakeLists.txt
new file mode 100644
index 0000000..0cfadc1
--- /dev/null
+++ b/plugin/CMakeLists.txt
@@ -0,0 +1,16 @@
+cmake_minimum_required(VERSION 3.0)
+
+project(plugin)
+
+add_library(plugin
+  src/plugin.c)
+
+target_include_directories(plugin PUBLIC
+  include)
+
+target_link_libraries(plugin PRIVATE
+  cstring
+  list
+  log)
+
+target_compile_options(plugin PRIVATE -Wall -Wextra)
diff --git a/plugin/README.md b/plugin/README.md
new file mode 100644
index 0000000..852cfe5
--- /dev/null
+++ b/plugin/README.md
@@ -0,0 +1,12 @@
+# Plugin
+
+A library for loading plugins and watching plugin updates.
+
+The plugin engine allows the client to load plugins and call their functions.
+
+Plugins can also be associated with a state. The engine does not create the
+plugin's state because this may require other application-specific state.
+
+Plugin files are watched for updates. Upon an update, the engine reloads the
+plugin into memory and notifies the client. The client should then typically
+re-create the plugin's state.
diff --git a/plugin/include/plugin.h b/plugin/include/plugin.h
new file mode 100644
index 0000000..abca9b5
--- /dev/null
+++ b/plugin/include/plugin.h
@@ -0,0 +1,66 @@
+/*
+ * Plugin engine for loading plugins and watching plugin updates.
+ *
+ * The plugin engine allows the client to load plugins and call their functions.
+ *
+ * Plugins can also be associated with a state. The engine does not create the
+ * plugin's state because this may require other application-specific state.
+ *
+ * Plugin files are watched for updates. Upon an update, the engine reloads the
+ * plugin into memory and notifies the client. The client should then typically
+ * re-create the plugin's state.
+ */
+#pragma once
+
+#include <stdbool.h>
+
+#include <dlfcn.h>
+
+typedef struct Plugin       Plugin;
+typedef struct PluginEngine PluginEngine;
+
+/// Plugin engine creation depluginor.
+typedef struct PluginEngineDesc {
+  const char* plugins_dir;
+} PluginEngineDesc;
+
+/// Create a new plugin engine.
+PluginEngine* new_plugin_engine(const PluginEngineDesc*);
+
+/// Destroy the plugin engine.
+void delete_plugin_engine(PluginEngine**);
+
+/// Update the plugin engine.
+///
+/// This looks for any plugins that have been modified and reloads them.
+void plugin_engine_update(PluginEngine*);
+
+/// Load a plugin.
+Plugin* load_plugin(PluginEngine*, const char* filename);
+
+/// Delete the plugin.
+///
+/// This unloads the plugin from memory and removes it from the engine.
+void delete_plugin(Plugin**);
+
+/// Set the plugin's state.
+///
+/// The plugin's previous state is deleted if non-null.
+void set_plugin_state(Plugin*, void* state);
+
+/// Get the plugin's state. Return null if the plugin has no state.
+void* get_plugin_state(Plugin*);
+
+/// Return true if the plugin has been reloaded.
+///
+/// If the plugin has been reloaded, subsequent calls to this function return
+/// false until the plugin is reloaded again.
+bool plugin_reloaded(Plugin*);
+
+/// Resolve a function in the plugin.
+#define plugin_resolve(plugin, func_sig, func_name) \
+  (func_sig)(dlsym(*((void**)(plugin)), func_name))
+
+/// Call a function in the plugin.
+#define plugin_call(plugin, func_sig, func_name, ...) \
+  (*plugin_resolve(plugin, func_sig, func_name))(__VA_ARGS__)
diff --git a/plugin/src/plugin.c b/plugin/src/plugin.c
new file mode 100644
index 0000000..f65132f
--- /dev/null
+++ b/plugin/src/plugin.c
@@ -0,0 +1,250 @@
+#include "plugin.h"
+
+#include "cstring.h"
+#include "list.h"
+#include "log/log.h" // TODO: Use the error library instead. Move it to clib.
+
+#include <assert.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <errno.h>
+#include <linux/limits.h>
+#include <poll.h>
+#include <sys/inotify.h>
+#include <unistd.h>
+
+// Watching for IN_CREATE leads the plugin engine to try to reload a plugin's
+// shared library before the compiler has fully written to it.
+static const int WATCH_MASK = IN_CLOSE_WRITE;
+
+typedef struct Plugin {
+  void* handle;      // First member so that Plugin can be cast to handle.
+  void* state;       // Plugin's internal state.
+  bool  reloaded;    // Whether the plugin has been reloaded state needs to be
+                     // re-created.
+  PluginEngine* eng; // So that the public API can do stuff with just a Plugin*.
+  mstring       filename;
+} Plugin;
+
+DEF_LIST(Plugin);
+
+typedef struct PluginEngine {
+  int         inotify_instance;
+  int         dir_watch; // inotify watch on the plugins directory.
+  Plugin_list plugins;
+  mstring     plugins_dir;
+} PluginEngine;
+
+// -----------------------------------------------------------------------------
+// Plugin.
+// -----------------------------------------------------------------------------
+
+static mstring plugin_lib_name(const Plugin* plugin) {
+  return mstring_concat(
+      mstring_make("lib"), mstring_concat_cstr(plugin->filename, ".so"));
+}
+
+static mstring plugin_lib_path(const Plugin* plugin) {
+  return mstring_concat(plugin->eng->plugins_dir, plugin_lib_name(plugin));
+}
+
+static bool load_library(Plugin* plugin) {
+  assert(plugin);
+  assert(plugin->eng);
+
+  // Handle reloading a previously-loaded library.
+  if (plugin->handle) {
+    dlclose(plugin->handle);
+    plugin->handle = 0;
+  }
+
+  const mstring lib = plugin_lib_path(plugin);
+
+  // If the plugin fails to load, make sure to keep the plugin's old handle to
+  // handle the error gracefully. This handles reload failures, specifically.
+  void* handle = 0;
+  if ((handle = dlopen(mstring_cstr(&lib), RTLD_NOW))) {
+    LOGD("Plugin [%s] loaded successfully", mstring_cstr(&plugin->filename));
+    plugin->handle = handle;
+    return true;
+  } else {
+    LOGE("dlopen() failed: %s", dlerror());
+  }
+
+  return false;
+}
+
+static void destroy_plugin(Plugin* plugin) {
+  if (plugin) {
+    if (plugin->handle) {
+      dlclose(plugin->handle);
+      plugin->handle = 0;
+    }
+    if (plugin->state) {
+      free(plugin->state);
+      plugin->state = 0;
+    }
+  }
+}
+
+Plugin* load_plugin(PluginEngine* eng, const char* filename) {
+  assert(eng);
+  assert(filename);
+
+  Plugin plugin = (Plugin){.eng = eng, .filename = mstring_make(filename)};
+
+  if (!load_library(&plugin)) {
+    return 0;
+  }
+
+  list_push(eng->plugins, plugin);
+  return &eng->plugins.head->val;
+}
+
+void delete_plugin(Plugin** pPlugin) {
+  assert(pPlugin);
+  Plugin* plugin = *pPlugin;
+  if (plugin) {
+    assert(plugin->eng);
+    destroy_plugin(plugin);
+    list_remove_ptr(plugin->eng->plugins, plugin);
+    *pPlugin = 0;
+  }
+}
+
+static void delete_plugin_state(Plugin* plugin) {
+  if (plugin->state) {
+    free(plugin->state);
+    plugin->state = 0;
+  }
+}
+
+void set_plugin_state(Plugin* plugin, void* state) {
+  assert(plugin);
+  delete_plugin_state(plugin);
+  plugin->state = state;
+}
+
+void* get_plugin_state(Plugin* plugin) {
+  assert(plugin);
+  return plugin->state;
+}
+
+bool plugin_reloaded(Plugin* plugin) {
+  assert(plugin);
+  const bool reloaded = plugin->reloaded;
+  plugin->reloaded    = false;
+  return reloaded;
+}
+
+// -----------------------------------------------------------------------------
+// Plugin Engine.
+// -----------------------------------------------------------------------------
+
+PluginEngine* new_plugin_engine(const PluginEngineDesc* desc) {
+  PluginEngine* eng = 0;
+
+  if (!(eng = calloc(1, sizeof(PluginEngine)))) {
+    goto cleanup;
+  }
+  eng->plugins     = make_list(Plugin);
+  eng->plugins_dir = mstring_concat_cstr(mstring_make(desc->plugins_dir), "/");
+
+  LOGD("Watch plugins directory: %s", mstring_cstr(&eng->plugins_dir));
+
+  if ((eng->inotify_instance = inotify_init()) == -1) {
+    LOGE("Failed to create inotify instance");
+    goto cleanup;
+  }
+  if ((eng->dir_watch = inotify_add_watch(
+           eng->inotify_instance, mstring_cstr(&eng->plugins_dir),
+           WATCH_MASK)) == -1) {
+    LOGE("Failed to watch directory: %s", mstring_cstr(&eng->plugins_dir));
+    goto cleanup;
+  }
+
+  return eng;
+
+cleanup:
+  delete_plugin_engine(&eng);
+  return 0;
+}
+
+void delete_plugin_engine(PluginEngine** pEng) {
+  assert(pEng);
+  PluginEngine* eng = *pEng;
+  if (eng) {
+    list_foreach_mut(eng->plugins, { destroy_plugin(value); });
+    del_list(eng->plugins);
+    if (eng->dir_watch != -1) {
+      inotify_rm_watch(eng->dir_watch, eng->inotify_instance);
+      close(eng->dir_watch);
+      eng->dir_watch = 0;
+    }
+    if (eng->inotify_instance != -1) {
+      close(eng->inotify_instance);
+    }
+    free(eng);
+    *pEng = 0;
+  }
+}
+
+void plugin_engine_update(PluginEngine* eng) {
+  assert(eng);
+
+  struct pollfd pollfds[1] = {
+      {eng->inotify_instance, POLLIN, 0}
+  };
+
+  int ret = 0;
+  while ((ret = poll(pollfds, 1, 0)) != 0) {
+    if (ret > 0) {
+      const struct pollfd* pfd = &pollfds[0];
+      if (pfd->revents & POLLIN) {
+        // inotify instances don't like to be partially read, and the events,
+        // when watching a directory, have a variable-length file name.
+        uint8_t buf[sizeof(struct inotify_event) + NAME_MAX + 1] = {0};
+        ssize_t length = read(eng->inotify_instance, &buf, sizeof(buf));
+        if (length == -1) {
+          LOGE(
+              "read() on inotify instance failed with error [%d]: %s", errno,
+              strerror(errno));
+          break;
+        }
+        const uint8_t* next = buf;
+        const uint8_t* end  = buf + sizeof(buf);
+        while (next < end) {
+          const struct inotify_event* event = (const struct inotify_event*)next;
+          if (event->mask & WATCH_MASK) {
+            if (event->wd == eng->dir_watch) {
+              if (event->len > 0) {
+                // Name does not include directory, e.g., libfoo.so
+                const mstring file = mstring_make(event->name);
+                list_foreach_mut(eng->plugins, {
+                  Plugin* plugin = value;
+                  if (mstring_eq(file, plugin_lib_name(plugin))) {
+                    if (load_library(plugin)) {
+                      plugin->reloaded = true;
+                    }
+                    break;
+                  }
+                });
+              }
+            }
+          }
+          next += sizeof(struct inotify_event) + event->len;
+        }
+      }
+      if ((pfd->revents & POLLERR) || (pfd->revents & POLLHUP) ||
+          (pfd->revents & POLLNVAL)) {
+        LOGE("inotify instance is in a bad state");
+        break;
+      }
+    } else if (ret == -1) {
+      LOGE("poll() failed with error [%d]: %s", errno, strerror(errno));
+      break;
+    }
+  }
+}