trunk/src/rc-plugin.c

/*
   librc-plugin.c 
   Simple plugin handler
   Copyright 2007 Gentoo Foundation
   Released under the GPLv2
   */

#include <dlfcn.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "einfo.h"
#include "rc.h"
#include "rc-misc.h"
#include "rc-plugin.h"
#include "strlist.h"

typedef struct plugin
{
  char *name;
  void *handle;
  int (*hook) (rc_hook_t hook, const char *name);
  struct plugin *next;
} plugin_t;

static plugin_t *plugins = NULL;

void rc_plugin_load (void)
{
  char **files;
  char *file;
  int i;
  plugin_t *plugin = plugins;

  /* Ensure some sanity here */
  rc_plugin_unload ();

  if (! rc_exists (RC_PLUGINDIR))
    return;

  files = rc_ls_dir (NULL, RC_PLUGINDIR, 0);
  STRLIST_FOREACH (files, file, i)
    {
      char *p = rc_strcatpaths (RC_PLUGINDIR, file, NULL);
      void *h = dlopen (p, RTLD_LAZY);
      char *func;
      void *f;
      int len;

      if (! h)
        {
          eerror ("dlopen `%s': %s", p, dlerror ());
          free (p);
          continue;
        }

      func = file;
      file = strsep (&func, ".");
      len = strlen (file) + 7;
      func = rc_xmalloc (sizeof (char *) * len);
      snprintf (func, len, "_%s_hook", file);

      f = dlsym (h, func);
      if (! f)
        {
          eerror ("`%s' does not expose the symbol `%s'", p, func);
          dlclose (h);
        }
      else
        {
          if (plugin)
            {
              plugin->next = rc_xmalloc (sizeof (plugin_t));
              plugin = plugin->next;
            }
          else
            plugin = plugins = rc_xmalloc (sizeof (plugin_t));

          memset (plugin, 0, sizeof (plugin_t));
          plugin->name = strdup (file);
          plugin->handle = h;
          plugin->hook = f;
        }

      free (func);
      free (p);
    }

  rc_strlist_free (files);
}

void rc_plugin_run (rc_hook_t hook, const char *value)
{
  plugin_t *plugin = plugins;

  while (plugin)
    {
      if (plugin->hook)
        plugin->hook (hook, value);

      plugin = plugin->next;
    }
}

void rc_plugin_unload (void)
{
  plugin_t *plugin = plugins;
  plugin_t *next;

  while (plugin)
    {
      next = plugin->next;
      dlclose (plugin->handle);
      free (plugin->name);
      free (plugin);
      plugin = next;
    }
  plugins = NULL;
}
1	/*
2	librc-plugin.c
3	Simple plugin handler
4	Copyright 2007 Gentoo Foundation
5	Released under the GPLv2
6	*/
7
8	#include <dlfcn.h>
9	#include <stdio.h>
10	#include <stdlib.h>
11	#include <string.h>
12	#include <unistd.h>
13
14	#include "einfo.h"
15	#include "rc.h"
16	#include "rc-misc.h"
17	#include "rc-plugin.h"
18	#include "strlist.h"
19
20	typedef struct plugin
21	{
22	char *name;
23	void *handle;
24	int (hook) (rc_hook_t hook, const char name);
25	struct plugin *next;
26	} plugin_t;
27
28	static plugin_t *plugins = NULL;
29
30	void rc_plugin_load (void)
31	{
32	char **files;
33	char *file;
34	int i;
35	plugin_t *plugin = plugins;
36
37	/* Ensure some sanity here */
38	rc_plugin_unload ();
39
40	if (! rc_exists (RC_PLUGINDIR))
41	return;
42
43	files = rc_ls_dir (NULL, RC_PLUGINDIR, 0);
44	STRLIST_FOREACH (files, file, i)
45	{
46	char *p = rc_strcatpaths (RC_PLUGINDIR, file, NULL);
47	void *h = dlopen (p, RTLD_LAZY);
48	char *func;
49	void *f;
50	int len;
51
52	if (! h)
53	{
54	eerror ("dlopen `%s': %s", p, dlerror ());
55	free (p);
56	continue;
57	}
58
59	func = file;
60	file = strsep (&func, ".");
61	len = strlen (file) + 7;
62	func = rc_xmalloc (sizeof (char ) len);
63	snprintf (func, len, "_%s_hook", file);
64
65	f = dlsym (h, func);
66	if (! f)
67	{
68	eerror ("`%s' does not expose the symbol `%s'", p, func);
69	dlclose (h);
70	}
71	else
72	{
73	if (plugin)
74	{
75	plugin->next = rc_xmalloc (sizeof (plugin_t));
76	plugin = plugin->next;
77	}
78	else
79	plugin = plugins = rc_xmalloc (sizeof (plugin_t));
80
81	memset (plugin, 0, sizeof (plugin_t));
82	plugin->name = strdup (file);
83	plugin->handle = h;
84	plugin->hook = f;
85	}
86
87	free (func);
88	free (p);
89	}
90
91	rc_strlist_free (files);
92	}
93
94	void rc_plugin_run (rc_hook_t hook, const char *value)
95	{
96	plugin_t *plugin = plugins;
97
98	while (plugin)
99	{
100	if (plugin->hook)
101	plugin->hook (hook, value);
102
103	plugin = plugin->next;
104	}
105	}
106
107	void rc_plugin_unload (void)
108	{
109	plugin_t *plugin = plugins;
110	plugin_t *next;
111
112	while (plugin)
113	{
114	next = plugin->next;
115	dlclose (plugin->handle);
116	free (plugin->name);
117	free (plugin);
118	plugin = next;
119	}
120	plugins = NULL;
121	}