Dogcows Code - chaz/openbox/blob - plugins/menu/timed_menu.c

   1 #include <glib.h>
   2 #include <stdlib.h>
   3 #include <unistd.h>
   4 #include <errno.h>
   5 #include <string.h>
   6 #include <stdio.h>
   7 #include <sys/types.h>
   8 #include <sys/wait.h>
   9 #include <unistd.h>
  10 #include <sys/stat.h>
  11
  12 #include "kernel/menu.h"
  13 #include "kernel/timer.h"
  14 #include "timed_menu.h"
  15 #include "kernel/action.h"
  16 #include "kernel/event.h"
  17
  18 #define TIMED_MENU(m) ((ObMenu *)m)
  19 #define TIMED_MENU_DATA(m) ((Timed_Menu_Data *)((ObMenu *)m)->plugin_data)
  20 static char *PLUGIN_NAME = "timed_menu";
  21
  22 typedef enum {
  23     TIMED_MENU_PIPE, /* read entries from a child process' output */
  24     TIMED_MENU_STAT  /* reread entries from file when timestamp changes */
  25 } Timed_Menu_Type;
  26
  27 typedef struct {
  28     Timed_Menu_Type type;
  29     ObTimer *timer;
  30     char *command; /* for the PIPE */
  31     char *buf; /* buffer to hold partially read menu */
  32     unsigned long buflen; /* how many bytes are in the buffer */
  33     int fd; /* file descriptor to read menu from */
  34     pid_t pid; /* pid of child process in PIPE */
  35     time_t mtime; /* time of last modification */
  36 } Timed_Menu_Data;
  37
  38
  39 void plugin_setup_config() { }
  40 void plugin_startup()
  41 { }
  42 void plugin_shutdown() { }
  43
  44 void timed_menu_clean_up(ObMenu *m) {
  45     if (TIMED_MENU_DATA(m)->buf != NULL) {
  46         fprintf(stderr, "%s", TIMED_MENU_DATA(m)->buf);
  47         g_free(TIMED_MENU_DATA(m)->buf);
  48         TIMED_MENU_DATA(m)->buf = NULL;
  49     }
  50
  51     TIMED_MENU_DATA(m)->buflen = 0;
  52
  53     if (TIMED_MENU_DATA(m)->fd != -1) {
  54         event_remove_fd(TIMED_MENU_DATA(m)->fd);
  55         close(TIMED_MENU_DATA(m)->fd);
  56         TIMED_MENU_DATA(m)->fd = -1;
  57     }
  58
  59     if (TIMED_MENU_DATA(m)->pid != -1) {
  60         waitpid(TIMED_MENU_DATA(m)->pid, NULL, 0);
  61         TIMED_MENU_DATA(m)->pid = -1;
  62     }
  63
  64     TIMED_MENU_DATA(m)->mtime = 0;
  65 }
  66
  67 void timed_menu_read_pipe(int fd, void *d)
  68 {
  69     ObMenu *menu = d;
  70     char *tmpbuf = NULL;
  71     unsigned long num_read;
  72 #ifdef DEBUG
  73     /* because gdb is dumb */
  74 #if 0
  75     Timed_Menu_Data *d = TIMED_MENU_DATA(menu);
  76 #endif
  77 #endif
  78
  79     unsigned long num_realloc;
  80     /* if we have less than a quarter BUFSIZ left, allocate more */
  81     num_realloc = (BUFSIZ - (TIMED_MENU_DATA(menu)->buflen % BUFSIZ) <
  82                    BUFSIZ >> 2) ?
  83                   0 : BUFSIZ;
  84
  85     tmpbuf = g_try_realloc(TIMED_MENU_DATA(menu)->buf,
  86                            TIMED_MENU_DATA(menu)->buflen + num_realloc);
  87
  88     if (tmpbuf == NULL) {
  89         g_warning("Unable to allocate memory for read()");
  90         return;
  91     }
  92
  93     TIMED_MENU_DATA(menu)->buf = tmpbuf;
  94
  95     num_read = read(fd,
  96                     TIMED_MENU_DATA(menu)->buf + TIMED_MENU_DATA(menu)->buflen,
  97                     num_realloc);
  98     if (num_read == 0) {
  99         xmlDocPtr doc;
 100         xmlNodePtr node;
 101
 102         menu->invalid = TRUE;
 103         menu_clear(menu);
 104
 105         TIMED_MENU_DATA(menu)->buf[TIMED_MENU_DATA(menu)->buflen] = '\0';
 106
 107         doc = xmlParseMemory(TIMED_MENU_DATA(menu)->buf,
 108                                        TIMED_MENU_DATA(menu)->buflen);
 109
 110         node = xmlDocGetRootElement(doc);
 111
 112         if (!xmlStrcasecmp(node->name, (const xmlChar*) "timed_menu")) {
 113             if ((node = parse_find_node("item", node->xmlChildrenNode)))
 114                 parse_menu_full(doc, node, menu, FALSE);
 115         }
 116
 117         timed_menu_clean_up(menu);
 118     } else if (num_read > 0) {
 119         TIMED_MENU_DATA(menu)->buflen += num_read;
 120         TIMED_MENU_DATA(menu)->buf[TIMED_MENU_DATA(menu)->buflen] = '\0';
 121     } else { /* num_read < 1 */
 122         g_warning("Error on read %s", strerror(errno));
 123         timed_menu_clean_up(menu);
 124     }
 125 }
 126
 127 void timed_menu_timeout_handler(ObTimer *t, void *d)
 128 {
 129     ObMenu *data = d;
 130     if (!data->shown && TIMED_MENU_DATA(data)->fd == -1) {
 131         switch (TIMED_MENU_DATA(data)->type) {
 132             case (TIMED_MENU_PIPE): {
 133                 /* if the menu is not shown, run a process and use its output
 134                    as menu */
 135
 136                 /* I hate you glib in all your hideous forms */
 137                 char *args[4];
 138                 int child_stdout;
 139                 int child_pid;
 140                 args[0] = "/bin/sh";
 141                 args[1] = "-c";
 142                 args[2] = TIMED_MENU_DATA(data)->command;
 143                 args[3] = NULL;
 144                 if (g_spawn_async_with_pipes(
 145                         NULL,
 146                         args,
 147                         NULL,
 148                         G_SPAWN_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD,
 149                         NULL,
 150                         NULL,
 151                         &child_pid,
 152                         NULL,
 153                         &child_stdout,
 154                         NULL,
 155                         NULL)) {
 156                     event_fd_handler *h = g_new(event_fd_handler, 1);
 157                     TIMED_MENU_DATA(data)->fd = h->fd = child_stdout;
 158                     TIMED_MENU_DATA(data)->pid = child_pid;
 159                     h->handler = timed_menu_read_pipe;
 160                     h->data = data;
 161                     event_add_fd_handler(h);
 162                 } else {
 163                     g_warning("unable to spawn child");
 164                 }
 165                 break;
 166             }
 167
 168             case (TIMED_MENU_STAT): {
 169                 struct stat stat_buf;
 170
 171                 if (stat(TIMED_MENU_DATA(data)->command, &stat_buf) == -1) {
 172                     g_warning("Unable to stat %s: %s",
 173                               TIMED_MENU_DATA(data)->command,
 174                               strerror(errno));
 175                     break;
 176                 }
 177
 178                 if (stat_buf.st_mtime > TIMED_MENU_DATA(data)->mtime) {
 179                     g_warning("file changed");
 180                     TIMED_MENU_DATA(data)->mtime = stat_buf.st_mtime;
 181                     /* TODO: parse */
 182                 }
 183             }
 184         }
 185     }
 186 }
 187
 188 void *plugin_create(PluginMenuCreateData *data)
 189 {
 190     char *id;
 191     char *label;
 192     char *timeout;
 193     Timed_Menu_Data *d;
 194     ObMenu *m;
 195
 196     parse_attr_string("id", data->node, &id);
 197     parse_attr_string("label", data->node, &label);
 198
 199     d = g_new(Timed_Menu_Data, 1);
 200
 201     m = menu_new( (label != NULL ? label : ""),
 202                   (id != NULL ? id : PLUGIN_NAME),
 203                   data->parent);
 204
 205     m->plugin = PLUGIN_NAME;
 206
 207     if (data->parent)
 208         menu_add_entry(data->parent, menu_entry_new_submenu(
 209                            (label != NULL ? label : ""),
 210                            m));
 211
 212     if (!parse_attr_string("command", data->node, &d->command)) {
 213         d->command = g_strdup("");
 214     }
 215
 216     if (parse_attr_string("timeout", data->node, &timeout)) {
 217         char *endptr;
 218         gdouble timeout_val = g_strtod(timeout, &endptr);
 219         g_free(timeout);
 220         d->timer = timer_start(timeout_val * 1000000,
 221                                &timed_menu_timeout_handler, m);
 222     } else
 223         d->timer = timer_start(600 * 1000000, &timed_menu_timeout_handler, m);
 224
 225     d->type = TIMED_MENU_PIPE;
 226     d->buf = NULL;
 227     d->buflen = 0;
 228     d->fd = -1;
 229     d->pid = -1;
 230     d->mtime = 0;
 231
 232     m->plugin_data = (void *)d;
 233
 234     timed_menu_timeout_handler(NULL, m);
 235     return (void *)m;
 236 }
 237
 238 void plugin_destroy (void *m)
 239 {
 240     timed_menu_clean_up(m);
 241     /* this will be freed by timer_* */
 242     timer_stop( ((Timed_Menu_Data *)TIMED_MENU(m)->plugin_data)->timer);
 243
 244     g_free( TIMED_MENU(m)->plugin_data );
 245 }