spawn.c

   1 /*
   2  * spawn.c - Lua configuration management
   3  *
   4  * Copyright © 2009 Julien Danjou <julien@danjou.info>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along
  17  * with this program; if not, write to the Free Software Foundation, Inc.,
  18  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19  *
  20  */
  21
  22 #include <unistd.h>
  23 #include <errno.h>
  24 #include <sys/types.h>
  25 #include <sys/wait.h>
  26
  27 #include <glib.h>
  28
  29 #include "spawn.h"
  30 #include "screen.h"
  31 #include "luaa.h"
  32 #include "event.h"
  33
  34 /** 20 seconds timeout */
  35 #define AWESOME_SPAWN_TIMEOUT 20.0
  36
  37 /** Wrapper for unrefing startup sequence.
  38  */
  39 static inline void
  40 a_sn_startup_sequence_unref(SnStartupSequence **sss)
  41 {
  42     return sn_startup_sequence_unref(*sss);
  43 }
  44
  45 DO_ARRAY(SnStartupSequence *, SnStartupSequence, a_sn_startup_sequence_unref)
  46
  47 /** The array of startup sequence running */
  48 SnStartupSequence_array_t sn_waits;
  49
  50 /** Remove a SnStartupSequence pointer from an array and forget about it.
  51  * \param s The startup sequence to found, remove and unref.
  52  * \return True if found and removed.
  53  */
  54 static inline bool
  55 spawn_sequence_remove(SnStartupSequence *s)
  56 {
  57     for(int i = 0; i < sn_waits.len; i++)
  58         if(sn_waits.tab[i] == s)
  59         {
  60             SnStartupSequence_array_take(&sn_waits, i);
  61             sn_startup_sequence_unref(s);
  62             return true;
  63         }
  64     return false;
  65 }
  66
  67 static gboolean
  68 spawn_monitor_timeout(gpointer sequence)
  69 {
  70     if(spawn_sequence_remove(sequence))
  71     {
  72          signal_t *sig = signal_array_getbyid(&global_signals,
  73                                               a_strhash((const unsigned char *) "spawn::timeout"));
  74          if(sig)
  75          {
  76              /* send a timeout signal */
  77              lua_createtable(globalconf.L, 0, 2);
  78              lua_pushstring(globalconf.L, sn_startup_sequence_get_id(sequence));
  79              lua_setfield(globalconf.L, -2, "id");
  80              foreach(func, sig->sigfuncs)
  81              {
  82                  lua_pushvalue(globalconf.L, -1);
  83                  luaA_object_push(globalconf.L, (void *) *func);
  84                  luaA_dofunction(globalconf.L, 1, 0);
  85              }
  86              lua_pop(globalconf.L, 1);
  87          }
  88          else
  89              warn("spawn::timeout signal is missing");
  90     }
  91     sn_startup_sequence_unref(sequence);
  92     return FALSE;
  93 }
  94
  95 static void
  96 spawn_monitor_event(SnMonitorEvent *event, void *data)
  97 {
  98     SnStartupSequence *sequence = sn_monitor_event_get_startup_sequence(event);
  99     SnMonitorEventType event_type = sn_monitor_event_get_type(event);
 100
 101     lua_createtable(globalconf.L, 0, 2);
 102     lua_pushstring(globalconf.L, sn_startup_sequence_get_id(sequence));
 103     lua_setfield(globalconf.L, -2, "id");
 104
 105     const char *event_type_str = NULL;
 106
 107     switch(event_type)
 108     {
 109       case SN_MONITOR_EVENT_INITIATED:
 110         /* ref the sequence for the array */
 111         sn_startup_sequence_ref(sequence);
 112         SnStartupSequence_array_append(&sn_waits, sequence);
 113         event_type_str = "spawn::initiated";
 114
 115         /* Add a timeout function so we do not wait for this event to complete
 116          * for ever */
 117         g_timeout_add_seconds(AWESOME_SPAWN_TIMEOUT, spawn_monitor_timeout, sequence);
 118         /* ref the sequence for the callback event */
 119         sn_startup_sequence_ref(sequence);
 120         break;
 121       case SN_MONITOR_EVENT_CHANGED:
 122         event_type_str = "spawn::change";
 123         break;
 124       case SN_MONITOR_EVENT_COMPLETED:
 125         event_type_str = "spawn::completed";
 126         break;
 127       case SN_MONITOR_EVENT_CANCELED:
 128         event_type_str = "spawn::canceled";
 129         break;
 130     }
 131
 132     /* common actions */
 133     switch(event_type)
 134     {
 135       case SN_MONITOR_EVENT_INITIATED:
 136       case SN_MONITOR_EVENT_CHANGED:
 137         {
 138             const char *s = sn_startup_sequence_get_name(sequence);
 139             if(s)
 140             {
 141                 lua_pushstring(globalconf.L, s);
 142                 lua_setfield(globalconf.L, -2, "name");
 143             }
 144
 145             if((s = sn_startup_sequence_get_description(sequence)))
 146             {
 147                 lua_pushstring(globalconf.L, s);
 148                 lua_setfield(globalconf.L, -2, "description");
 149             }
 150
 151             lua_pushnumber(globalconf.L, sn_startup_sequence_get_workspace(sequence));
 152             lua_setfield(globalconf.L, -2, "workspace");
 153
 154             if((s = sn_startup_sequence_get_binary_name(sequence)))
 155             {
 156                 lua_pushstring(globalconf.L, s);
 157                 lua_setfield(globalconf.L, -2, "binary_name");
 158             }
 159
 160             if((s = sn_startup_sequence_get_icon_name(sequence)))
 161             {
 162                 lua_pushstring(globalconf.L, s);
 163                 lua_setfield(globalconf.L, -2, "icon_name");
 164             }
 165
 166             if((s = sn_startup_sequence_get_wmclass(sequence)))
 167             {
 168                 lua_pushstring(globalconf.L, s);
 169                 lua_setfield(globalconf.L, -2, "wmclass");
 170             }
 171         }
 172         break;
 173       case SN_MONITOR_EVENT_COMPLETED:
 174       case SN_MONITOR_EVENT_CANCELED:
 175         spawn_sequence_remove(sequence);
 176         break;
 177     }
 178
 179     /* send the signal */
 180     signal_t *sig = signal_array_getbyid(&global_signals,
 181                                          a_strhash((const unsigned char *) event_type_str));
 182
 183     if(sig)
 184     {
 185         foreach(func, sig->sigfuncs)
 186         {
 187             lua_pushvalue(globalconf.L, -1);
 188             luaA_object_push(globalconf.L, (void *) *func);
 189             luaA_dofunction(globalconf.L, 1, 0);
 190         }
 191         lua_pop(globalconf.L, 1);
 192     }
 193     else
 194         warn("%s signal is missing", event_type_str);
 195 }
 196
 197 /** Tell the spawn module that an app has been started.
 198  * \param c The client that just started.
 199  * \param startup_id The startup id of the started application.
 200  */
 201 void
 202 spawn_start_notify(client_t *c, const char * startup_id)
 203 {
 204     foreach(_seq, sn_waits)
 205     {
 206         SnStartupSequence *seq = *_seq;
 207         bool found = false;
 208         const char *seqid = sn_startup_sequence_get_id(seq);
 209
 210         if (A_STRNEQ(seqid, startup_id))
 211             found = true;
 212         else
 213         {
 214             const char *seqclass = sn_startup_sequence_get_wmclass(seq);
 215             if (A_STREQ(seqclass, c->class) || A_STREQ(seqclass, c->instance))
 216                 found = true;
 217             else
 218             {
 219                 const char *seqbin = sn_startup_sequence_get_binary_name(seq);
 220                 if (A_STREQ_CASE(seqbin, c->class) || A_STREQ_CASE(seqbin, c->instance))
 221                     found = true;
 222             }
 223         }
 224
 225         if(found)
 226         {
 227             sn_startup_sequence_complete(seq);
 228             break;
 229         }
 230     }
 231 }
 232
 233 /** Initialize program spawner.
 234  */
 235 void
 236 spawn_init(void)
 237 {
 238     globalconf.sndisplay = sn_xcb_display_new(globalconf.connection, NULL, NULL);
 239
 240     globalconf.snmonitor = sn_monitor_context_new(globalconf.sndisplay,
 241                                                   globalconf.default_screen,
 242                                                   spawn_monitor_event,
 243                                                   NULL, NULL);
 244
 245     signal_add(&global_signals, "spawn::canceled");
 246     signal_add(&global_signals, "spawn::change");
 247     signal_add(&global_signals, "spawn::completed");
 248     signal_add(&global_signals, "spawn::initiated");
 249     signal_add(&global_signals, "spawn::timeout");
 250 }
 251
 252 static gboolean
 253 spawn_launchee_timeout(gpointer context)
 254 {
 255     sn_launcher_context_complete(context);
 256     sn_launcher_context_unref(context);
 257     return FALSE;
 258 }
 259
 260 static void
 261 spawn_callback(gpointer user_data)
 262 {
 263     setsid();
 264 }
 265
 266 /** Parse a command line.
 267  * \param L The Lua VM state.
 268  * \param idx The index of the argument that we should parse
 269  * \return The argv array for the new process.
 270  */
 271 static gchar **
 272 parse_command(lua_State *L, int idx)
 273 {
 274     gchar **argv = NULL;
 275     idx = luaA_absindex(L, idx);
 276
 277     if (lua_isstring(L, idx))
 278     {
 279         const char *cmd = luaL_checkstring(L, idx);
 280         if(!g_shell_parse_argv(cmd, NULL, &argv, NULL))
 281             return NULL;
 282     }
 283     else if (lua_istable(L, idx))
 284     {
 285         size_t i, len = luaA_rawlen(L, idx);
 286
 287         /* First verify that the table is sane: All integer keys must contain
 288          * strings. Do this by pushing them all onto the stack.
 289          */
 290         for (i = 0; i < len; i++)
 291         {
 292             lua_rawgeti(L, idx, i+1);
 293             if (lua_type(L, -1) != LUA_TSTRING)
 294                 luaL_error(L, "Non-string argument at table index %d", i+1);
 295         }
 296
 297         /* From this point on nothing can go wrong and so we can safely allocate
 298          * memory.
 299          */
 300         argv = g_new0(gchar *, len + 1);
 301         for (i = 0; i < len; i++)
 302         {
 303             argv[len - i - 1] = g_strdup(lua_tostring(L, -1));
 304             lua_pop(L, 1);
 305         }
 306     }
 307     else
 308     {
 309         luaL_error(L, "Invalid argument to spawn(), expect string or table");
 310     }
 311
 312     return argv;
 313 }
 314
 315 /** Spawn a program.
 316  * This function is multi-head (Zaphod) aware and will set display to
 317  * the right screen according to mouse position.
 318  * \param L The Lua VM state.
 319  * \return The number of elements pushed on stack
 320  * \luastack
 321  * \lparam The command to launch.
 322  * \lparam Use startup-notification, true or false, default to true.
 323  * \lreturn Process ID if everything is OK, or an error string if an error occured.
 324  */
 325 int
 326 luaA_spawn(lua_State *L)
 327 {
 328     gchar **argv = NULL;
 329     bool use_sn = true;
 330     gboolean retval;
 331     GPid pid;
 332
 333     if(lua_gettop(L) >= 2)
 334         use_sn = luaA_checkboolean(L, 2);
 335
 336     argv = parse_command(L, 1);
 337     if(!argv || !argv[0])
 338     {
 339         g_strfreev(argv);
 340         return 0;
 341     }
 342
 343     SnLauncherContext *context = NULL;
 344     if(use_sn)
 345     {
 346         context = sn_launcher_context_new(globalconf.sndisplay, globalconf.default_screen);
 347         sn_launcher_context_set_name(context, "awesome");
 348         sn_launcher_context_set_description(context, "awesome spawn");
 349         sn_launcher_context_set_binary_name(context, argv[0]);
 350         sn_launcher_context_initiate(context, "awesome", argv[0], globalconf.timestamp);
 351
 352         /* app will have AWESOME_SPAWN_TIMEOUT seconds to complete,
 353          * or the timeout function will terminate the launch sequence anyway */
 354         g_timeout_add_seconds(AWESOME_SPAWN_TIMEOUT, spawn_launchee_timeout, context);
 355         sn_launcher_context_setup_child_process(context);
 356     }
 357
 358     GError *error = NULL;
 359     retval = g_spawn_async(NULL, argv, NULL, G_SPAWN_SEARCH_PATH,
 360                            spawn_callback, NULL, &pid, &error);
 361     g_strfreev(argv);
 362     if(!retval)
 363     {
 364         /* push error on stack */
 365         lua_pushstring(L, error->message);
 366         g_error_free(error);
 367         if(context)
 368             sn_launcher_context_complete(context);
 369         return 1;
 370     }
 371
 372     /* push pid on stack */
 373     lua_pushnumber(L, pid);
 374
 375     return 1;
 376 }
 377
 378 // vim: filetype=c:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:textwidth=80