/* ncmpc (Ncurses MPD Client)
* (c) 2004-2009 The Music Player Daemon Project
* Project homepage: http://musicpd.org
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include "plugin.h"
#include <assert.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/signal.h>
#include <sys/wait.h>
struct plugin_cycle {
/** the plugin list; used for traversing to the next plugin */
struct plugin_list *list;
/** arguments passed to execv() */
char **argv;
/** caller defined callback function */
plugin_callback_t callback;
/** caller defined pointer passed to #callback */
void *callback_data;
/** the index of the next plugin which is going to be
invoked */
guint next_plugin;
/** the pid of the plugin process, or -1 if none is currently
running */
pid_t pid;
/** the pipe to the plugin process, or -1 if none is currently
open */
int fd;
/** the GLib channel of #fd */
GIOChannel *channel;
/** the GLib IO watch of #channel */
guint event_id;
/** the output of the current plugin */
GString *data;
};
static bool
register_plugin(struct plugin_list *list, char *path)
{
int ret;
struct stat st;
ret = stat(path, &st);
if (ret < 0)
return false;
g_ptr_array_add(list->plugins, path);
return true;
}
bool
plugin_list_load_directory(struct plugin_list *list, const char *path)
{
GDir *dir;
const char *name;
char *plugin;
bool ret;
dir = g_dir_open(path, 0, NULL);
if (dir == NULL)
return false;
while ((name = g_dir_read_name(dir)) != NULL) {
plugin = g_build_filename(path, name, NULL);
ret = register_plugin(list, plugin);
if (!ret)
g_free(plugin);
}
g_dir_close(dir);
return true;
}
void plugin_list_deinit(struct plugin_list *list)
{
for (guint i = 0; i < list->plugins->len; ++i)
free(g_ptr_array_index(list->plugins, i));
g_ptr_array_free(list->plugins, TRUE);
}
static void
next_plugin(struct plugin_cycle *cycle);
static void
plugin_eof(struct plugin_cycle *cycle)
{
int ret, status;
g_io_channel_unref(cycle->channel);
close(cycle->fd);
cycle->fd = -1;
ret = waitpid(cycle->pid, &status, 0);
cycle->pid = -1;
if (ret < 0 || !WIFEXITED(status) || WEXITSTATUS(status) != 0) {
/* the plugin has failed */
g_string_free(cycle->data, TRUE);
cycle->data = NULL;
next_plugin(cycle);
} else {
/* success: invoke the callback */
cycle->callback(cycle->data, cycle->callback_data);
}
}
static gboolean
plugin_data(G_GNUC_UNUSED GIOChannel *source,
G_GNUC_UNUSED GIOCondition condition, gpointer data)
{
struct plugin_cycle *cycle = data;
char buffer[256];
ssize_t nbytes;
assert(cycle != NULL);
assert(cycle->fd >= 0);
assert(cycle->pid > 0);
assert(source == cycle->channel);
nbytes = condition & G_IO_IN
? read(cycle->fd, buffer, sizeof(buffer))
: 0;
if (nbytes <= 0) {
plugin_eof(cycle);
return FALSE;
}
g_string_append_len(cycle->data, buffer, nbytes);
return TRUE;
}
/**
* This is a timer callback which calls the plugin callback "some time
* later". This solves the problem that plugin_run() may fail
* immediately, leaving its return value in an undefined state.
* Instead, install a timer which calls the plugin callback in the
* moment after.
*/
static gboolean
plugin_delayed_fail(gpointer data)
{
struct plugin_cycle *cycle = data;
assert(cycle != NULL);
assert(cycle->fd < 0);
assert(cycle->pid < 0);
assert(cycle->data == NULL);
cycle->callback(NULL, cycle->callback_data);
return FALSE;
}
static int
start_plugin(struct plugin_cycle *cycle, const char *plugin_path)
{
int ret, fds[2];
pid_t pid;
assert(cycle != NULL);
assert(cycle->pid < 0);
assert(cycle->fd < 0);
assert(cycle->data == NULL);
/* set new program name, but free the one from the previous
plugin */
g_free(cycle->argv[0]);
cycle->argv[0] = g_path_get_basename(plugin_path);
ret = pipe(fds);
if (ret < 0)
return -1;
pid = fork();
if (pid < 0) {
close(fds[0]);
close(fds[1]);
return -1;
}
if (pid == 0) {
dup2(fds[1], 1);
dup2(fds[1], 1);
close(fds[0]);
close(fds[1]);
close(0);
/* XXX close other fds? */
execv(plugin_path, cycle->argv);
_exit(1);
}
close(fds[1]);
cycle->pid = pid;
cycle->fd = fds[0];
cycle->data = g_string_new(NULL);
/* XXX CLOEXEC? */
cycle->channel = g_io_channel_unix_new(cycle->fd);
cycle->event_id = g_io_add_watch(cycle->channel, G_IO_IN|G_IO_HUP,
plugin_data, cycle);
return 0;
}
static void
next_plugin(struct plugin_cycle *cycle)
{
const char *plugin_path;
int ret = -1;
assert(cycle->pid < 0);
assert(cycle->fd < 0);
assert(cycle->data == NULL);
if (cycle->next_plugin >= cycle->list->plugins->len) {
/* no plugins left */
g_timeout_add(0, plugin_delayed_fail, cycle);
return;
}
plugin_path = g_ptr_array_index(cycle->list->plugins,
cycle->next_plugin++);
ret = start_plugin(cycle, plugin_path);
if (ret < 0) {
/* system error */
g_timeout_add(0, plugin_delayed_fail, cycle);
return;
}
}
static char **
make_argv(const char*const* args)
{
unsigned num = 0;
char **ret;
while (args[num] != NULL)
++num;
num += 2;
ret = g_new(char*, num);
/* reserve space for the program name */
*ret++ = NULL;
do {
*ret++ = g_strdup(*args++);
} while (*args != NULL);
/* end of argument vector */
*ret++ = NULL;
return ret - num;
}
struct plugin_cycle *
plugin_run(struct plugin_list *list, const char *const*args,
plugin_callback_t callback, void *callback_data)
{
struct plugin_cycle *cycle = g_new(struct plugin_cycle, 1);
assert(args != NULL);
cycle->list = list;
cycle->argv = make_argv(args);
cycle->callback = callback;
cycle->callback_data = callback_data;
cycle->next_plugin = 0;
cycle->pid = -1;
cycle->fd = -1;
cycle->data = NULL;
next_plugin(cycle);
return cycle;
}
void
plugin_stop(struct plugin_cycle *cycle)
{
if (cycle->fd >= 0) {
/* close the pipe to the plugin */
g_source_remove(cycle->event_id);
g_io_channel_unref(cycle->channel);
close(cycle->fd);
}
if (cycle->pid > 0) {
/* kill the plugin process */
int status;
kill(cycle->pid, SIGTERM);
waitpid(cycle->pid, &status, 0);
}
if (cycle->data != NULL)
/* free data that has been received */
g_string_free(cycle->data, TRUE);
/* free argument list */
for (guint i = 0; i == 0 || cycle->argv[i] != NULL; ++i)
g_free(cycle->argv[i]);
g_free(cycle->argv);
g_free(cycle);
}
