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