src/lyrics.c

   1 /* ncmpc
   2  * Copyright (C) 2008 Max Kellermann <max@duempel.org>
   3  * This project's homepage is: http://www.musicpd.org
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19 #include "lyrics.h"
  20 #include "gcc.h"
  21
  22 #include <assert.h>
  23 #include <stdlib.h>
  24 #include <unistd.h>
  25 #include <string.h>
  26 #include <sys/stat.h>
  27 #include <sys/signal.h>
  28 #include <sys/wait.h>
  29
  30 static GPtrArray *plugins;
  31
  32 struct lyrics_loader {
  33         char *artist, *title;
  34
  35         enum lyrics_loader_result result;
  36
  37         guint next_plugin;
  38
  39         pid_t pid;
  40         int fd;
  41         GIOChannel *channel;
  42         guint event_id;
  43
  44         GString *data;
  45 };
  46
  47 static int lyrics_register_plugin(const char *path0)
  48 {
  49         int ret;
  50         struct stat st;
  51         char *path;
  52
  53         ret = stat(path0, &st);
  54         if (ret < 0)
  55                 return -1;
  56
  57         path = g_strdup(path0);
  58         g_ptr_array_add(plugins, path);
  59         return 0;
  60 }
  61
  62 void lyrics_init(void)
  63 {
  64         plugins = g_ptr_array_new();
  65
  66         /* XXX configurable paths */
  67         lyrics_register_plugin("./lyrics/hd.py");
  68         lyrics_register_plugin("./lyrics/leoslyrics.py");
  69         lyrics_register_plugin("./lyrics/lyricswiki.rb");
  70 }
  71
  72 void lyrics_deinit(void)
  73 {
  74         guint i;
  75
  76         for (i = 0; i < plugins->len; ++i)
  77                 free(g_ptr_array_index(plugins, i));
  78         g_ptr_array_free(plugins, TRUE);
  79 }
  80
  81 static void
  82 lyrics_next_plugin(struct lyrics_loader *loader);
  83
  84 static void
  85 lyrics_eof(struct lyrics_loader *loader)
  86 {
  87         int ret, status;
  88
  89         g_io_channel_unref(loader->channel);
  90         close(loader->fd);
  91         loader->fd = -1;
  92
  93         ret = waitpid(loader->pid, &status, 0);
  94         loader->pid = -1;
  95
  96         if (ret < 0 || !WIFEXITED(status) || WEXITSTATUS(status) != 0) {
  97                 g_string_free(loader->data, TRUE);
  98                 loader->data = NULL;
  99
 100                 lyrics_next_plugin(loader);
 101         } else {
 102                 loader->result = LYRICS_SUCCESS;
 103         }
 104 }
 105
 106 static gboolean
 107 lyrics_data(mpd_unused GIOChannel *source,
 108             mpd_unused GIOCondition condition, gpointer data)
 109 {
 110         struct lyrics_loader *loader = data;
 111         char buffer[256];
 112         ssize_t nbytes;
 113
 114         assert(loader != NULL);
 115         assert(loader->result = LYRICS_BUSY);
 116         assert(loader->fd >= 0);
 117         assert(loader->pid > 0);
 118         assert(source == loader->channel);
 119
 120         if ((condition & G_IO_IN) == 0) {
 121                 lyrics_eof(loader);
 122                 return FALSE;
 123         }
 124
 125         nbytes = condition & G_IO_IN
 126                 ? read(loader->fd, buffer, sizeof(buffer))
 127                 : 0;
 128         if (nbytes <= 0) {
 129                 lyrics_eof(loader);
 130                 return FALSE;
 131         }
 132
 133         g_string_append_len(loader->data, buffer, nbytes);
 134         return TRUE;
 135 }
 136
 137 static int
 138 lyrics_start_plugin(struct lyrics_loader *loader, const char *plugin_path)
 139 {
 140         int ret, fds[2];
 141         pid_t pid;
 142
 143         assert(loader != NULL);
 144         assert(loader->result == LYRICS_BUSY);
 145         assert(loader->pid < 0);
 146         assert(loader->fd < 0);
 147         assert(loader->data == NULL);
 148
 149         ret = pipe(fds);
 150         if (ret < 0)
 151                 return -1;
 152
 153         pid = fork();
 154
 155         if (pid < 0) {
 156                 close(fds[0]);
 157                 close(fds[1]);
 158                 return -1;
 159         }
 160
 161         if (pid == 0) {
 162                 dup2(fds[1], 1);
 163                 dup2(fds[1], 1);
 164                 close(fds[0]);
 165                 close(fds[1]);
 166                 close(0);
 167                 /* XXX close other fds? */
 168
 169                 execl(plugin_path, plugin_path,
 170                       loader->artist, loader->title, NULL);
 171                 _exit(1);
 172         }
 173
 174         close(fds[1]);
 175
 176         loader->pid = pid;
 177         loader->fd = fds[0];
 178         loader->data = g_string_new(NULL);
 179
 180         /* XXX CLOEXEC? */
 181
 182         loader->channel = g_io_channel_unix_new(loader->fd);
 183         loader->event_id = g_io_add_watch(loader->channel, G_IO_IN|G_IO_HUP,
 184                                           lyrics_data, loader);
 185
 186         return 0;
 187 }
 188
 189 static void
 190 lyrics_next_plugin(struct lyrics_loader *loader)
 191 {
 192         const char *plugin_path;
 193         int ret = -1;
 194
 195         assert(loader->pid < 0);
 196         assert(loader->fd < 0);
 197         assert(loader->data == NULL);
 198
 199         if (loader->next_plugin >= plugins->len) {
 200                 /* no plugins left */
 201                 loader->result = LYRICS_FAILED;
 202                 return;
 203         }
 204
 205         plugin_path = g_ptr_array_index(plugins, loader->next_plugin++);
 206         ret = lyrics_start_plugin(loader, plugin_path);
 207         if (ret < 0) {
 208                 /* system error */
 209                 loader->result = LYRICS_FAILED;
 210                 return;
 211         }
 212 }
 213
 214 struct lyrics_loader *
 215 lyrics_load(const char *artist, const char *title)
 216 {
 217         struct lyrics_loader *loader = g_new(struct lyrics_loader, 1);
 218
 219         assert(artist != NULL);
 220         assert(title != NULL);
 221
 222         if (loader == NULL)
 223                 return NULL;
 224
 225         loader->artist = g_strdup(artist);
 226         loader->title = g_strdup(title);
 227         loader->result = LYRICS_BUSY;
 228         loader->next_plugin = 0;
 229         loader->pid = -1;
 230         loader->fd = -1;
 231         loader->data = NULL;
 232
 233         lyrics_next_plugin(loader);
 234
 235         return loader;
 236 }
 237
 238 void
 239 lyrics_free(struct lyrics_loader *loader)
 240 {
 241         if (loader->fd >= 0) {
 242                 g_source_remove(loader->event_id);
 243                 g_io_channel_unref(loader->channel);
 244                 close(loader->fd);
 245         }
 246
 247         if (loader->pid > 0) {
 248                 int status;
 249
 250                 kill(loader->pid, SIGTERM);
 251                 waitpid(loader->pid, &status, 0);
 252         }
 253
 254         if (loader->data != NULL)
 255                 g_string_free(loader->data, TRUE);
 256 }
 257
 258 enum lyrics_loader_result
 259 lyrics_result(struct lyrics_loader *loader)
 260 {
 261         return loader->result;
 262 }
 263
 264 const GString *
 265 lyrics_get(struct lyrics_loader *loader)
 266 {
 267         assert(loader->result == LYRICS_SUCCESS);
 268         assert(loader->pid < 0);
 269         assert(loader->data != NULL);
 270
 271         return loader->data;
 272 }