src/plugin.c

   1 /* plugin.c -- generic plugin routines for vlock,
   2  *             the VT locking program for linux
   3  *
   4  * This program is copyright (C) 2007 Frank Benkstein, and is free
   5  * software which is freely distributable under the terms of the
   6  * GNU General Public License version 2, included as the file COPYING in this
   7  * distribution.  It is NOT public domain software, and any
   8  * redistribution not permitted by the GNU General Public License is
   9  * expressly forbidden without prior written permission from
  10  * the author.
  11  *
  12  */
  13
  14 #include <stdlib.h>
  15 #include <string.h>
  16 #include <errno.h>
  17
  18 #include <glib.h>
  19
  20 #include "plugin.h"
  21 #include "util.h"
  22
  23 /* Allocate a new plugin struct. */
  24 struct plugin *new_plugin(const char *name, struct plugin_type *type)
  25 {
  26   struct plugin *p = malloc(sizeof *p);
  27   char *last_slash;
  28
  29   if (p == NULL)
  30     return NULL;
  31
  32   /* For security plugin names must not contain a slash. */
  33   last_slash = strrchr(name, '/');
  34
  35   if (last_slash != NULL)
  36     name = last_slash+1;
  37
  38   p->name = strdup(name);
  39
  40   if (p->name == NULL) {
  41     free(p);
  42     return NULL;
  43   }
  44
  45   p->context = NULL;
  46   p->save_disabled = false;
  47
  48   for (size_t i = 0; i < nr_dependencies; i++)
  49     p->dependencies[i] = NULL;
  50
  51   p->type = type;
  52
  53   if (p->type->init(p)) {
  54     return p;
  55   } else {
  56     destroy_plugin(p);
  57     return NULL;
  58   }
  59 }
  60
  61 /* Destroy the given plugin. */
  62 void destroy_plugin(struct plugin *p)
  63 {
  64   /* Call destroy method. */
  65   p->type->destroy(p);
  66
  67   /* Destroy dependency lists. */
  68   for (size_t i = 0; i < nr_dependencies; i++) {
  69     while (p->dependencies[i] != NULL) {
  70       free(p->dependencies[i]->data);
  71       p->dependencies[i] = g_list_delete_link(p->dependencies[i], p->dependencies[i]);
  72     }
  73   }
  74
  75   free(p->name);
  76   free(p);
  77 }
  78
  79 bool call_hook(struct plugin *p, const char *hook_name)
  80 {
  81   return p->type->call_hook(p, hook_name);
  82 }
  83
  84 GQuark vlock_plugin_error_quark(void)
  85 {
  86   return g_quark_from_static_string("vlock-plugin-error-quark");
  87 }
  88
  89 G_DEFINE_TYPE(VlockPlugin, vlock_plugin, G_TYPE_OBJECT)
  90
  91 /* Initialize plugin to default values. */
  92 static void vlock_plugin_init(VlockPlugin *self)
  93 {
  94   self->name = NULL;
  95 }
  96
  97 /* Create new plugin object. */
  98 static GObject *vlock_plugin_constructor(
  99     GType gtype,
 100     guint n_properties,
 101     GObjectConstructParam *properties)
 102 {
 103   GObjectClass *parent_class = G_OBJECT_CLASS(vlock_plugin_parent_class);
 104   GObject *object = parent_class->constructor(gtype, n_properties, properties);
 105   VlockPlugin *self = VLOCK_PLUGIN(object);
 106
 107   g_return_val_if_fail(self->name != NULL, NULL);
 108
 109   return object;
 110 }
 111
 112 /* Destroy plugin object. */
 113 static void vlock_plugin_finalize(GObject *object)
 114 {
 115   VlockPlugin *self = VLOCK_PLUGIN(object);
 116   g_free(self->name);
 117   self->name = NULL;
 118
 119   G_OBJECT_CLASS(vlock_plugin_parent_class)->finalize(object);
 120 }
 121
 122 /* Properties. */
 123 enum {
 124   PROP_VLOCK_PLUGIN_0,
 125   PROP_VLOCK_PLUGIN_NAME
 126 };
 127
 128 /* Set properties. */
 129 static void vlock_plugin_set_property(
 130     GObject *object,
 131     guint property_id,
 132     const GValue *value,
 133     GParamSpec *pspec)
 134 {
 135   VlockPlugin *self = VLOCK_PLUGIN(object);
 136
 137   switch (property_id)
 138   {
 139     case PROP_VLOCK_PLUGIN_NAME:
 140       g_free(self->name);
 141       self->name = g_value_dup_string(value);
 142       break;
 143     default:
 144       G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
 145       break;
 146   }
 147 }
 148
 149 /* Get properties. */
 150 static void vlock_plugin_get_property(
 151     GObject *object,
 152     guint property_id,
 153     GValue *value,
 154     GParamSpec *pspec)
 155 {
 156   VlockPlugin *self = VLOCK_PLUGIN(object);
 157
 158   switch (property_id)
 159   {
 160     case PROP_VLOCK_PLUGIN_NAME:
 161       g_value_set_string(value, self->name);
 162       break;
 163     default:
 164       G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
 165       break;
 166   }
 167 }
 168
 169 /* Initialize plugin class. */
 170 static void vlock_plugin_class_init(VlockPluginClass *klass)
 171 {
 172   GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
 173   GParamSpec *vlock_plugin_param_spec;
 174
 175   /* Virtual methods. */
 176   klass->open = NULL;
 177
 178   /* Install overridden methods. */
 179   gobject_class->constructor = vlock_plugin_constructor;
 180   gobject_class->finalize = vlock_plugin_finalize;
 181   gobject_class->set_property = vlock_plugin_set_property;
 182   gobject_class->get_property = vlock_plugin_get_property;
 183
 184   /* Install properties. */
 185   vlock_plugin_param_spec = g_param_spec_string(
 186       "name",
 187       "plugin name",
 188       "Set the plugin's name",
 189       NULL,
 190       G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE
 191   );
 192
 193   g_object_class_install_property(
 194       gobject_class,
 195       PROP_VLOCK_PLUGIN_NAME,
 196       vlock_plugin_param_spec
 197   );
 198 }
 199
 200 bool vlock_plugin_open(VlockPlugin *self, GError **error)
 201 {
 202   VlockPluginClass *klass = VLOCK_PLUGIN_GET_CLASS(self);
 203   g_assert(klass->open != NULL);
 204   return klass->open(self, error);
 205 }