176 lines
3.5 KiB
C
176 lines
3.5 KiB
C
/*
|
|
librc-plugin.c
|
|
Simple plugin handler
|
|
Copyright 2007 Gentoo Foundation
|
|
Released under the GPLv2
|
|
*/
|
|
|
|
#include <dlfcn.h>
|
|
#include <errno.h>
|
|
#include <fcntl.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", 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 = rc_xstrdup (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) {
|
|
int i;
|
|
int flags;
|
|
int pfd[2];
|
|
pid_t pid;
|
|
|
|
/* We create a pipe so that plugins can affect our environment
|
|
* vars, which in turn influence our scripts. */
|
|
if (pipe (pfd) == -1) {
|
|
eerror ("pipe: %s", strerror (errno));
|
|
return;
|
|
}
|
|
|
|
/* Stop any scripts from inheriting us.
|
|
* This is actually quite important as without this, the splash
|
|
* plugin will probably hang when running in silent mode. */
|
|
for (i = 0; i < 2; i++)
|
|
if ((flags = fcntl (pfd[i], F_GETFD, 0)) < 0 ||
|
|
fcntl (pfd[i], F_SETFD, flags | FD_CLOEXEC) < 0)
|
|
eerror ("fcntl: %s", strerror (errno));
|
|
|
|
/* We run the plugin in a new process so we never crash
|
|
* or otherwise affected by it */
|
|
if ((pid = fork ()) == -1) {
|
|
eerror ("fork: %s", strerror (errno));
|
|
return;
|
|
}
|
|
|
|
if (pid == 0) {
|
|
int retval;
|
|
|
|
close (pfd[0]);
|
|
rc_environ_fd = fdopen (pfd[1], "w");
|
|
retval = plugin->hook (hook, value);
|
|
fclose (rc_environ_fd);
|
|
rc_environ_fd = NULL;
|
|
_exit (retval);
|
|
} else {
|
|
char buffer[RC_LINEBUFFER];
|
|
char *token;
|
|
char *p;
|
|
ssize_t nr;
|
|
|
|
close (pfd[1]);
|
|
memset (buffer, 0, sizeof (buffer));
|
|
|
|
while ((nr = read (pfd[0], buffer, sizeof (buffer))) > 0) {
|
|
p = buffer;
|
|
while (*p && p - buffer < nr) {
|
|
token = strsep (&p, "=");
|
|
if (token) {
|
|
unsetenv (token);
|
|
if (*p) {
|
|
setenv (token, p, 1);
|
|
p += strlen (p) + 1;
|
|
} else
|
|
p++;
|
|
}
|
|
}
|
|
}
|
|
|
|
close (pfd[0]);
|
|
}
|
|
}
|
|
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;
|
|
}
|