Add plugin library.

1 files changed, 250 insertions, 0 deletions

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;
+    }
+  }
+}