Spawn callback

common/tokenize.list

@@ -114,3 +114,6 @@ webview
 window
 windows
 xid
+PROC_TERM_EXIT
+PROC_TERM_SIGNAL
+PROC_TERM_UNKNOWN

globalconf.h.in

@@ -23,6 +23,7 @@
 
 #define LUAKIT_INSTALL_PATH         "/usr/local/share/luakit"
 #define LUAKIT_OBJECT_REGISTRY_KEY  "luakit.object.registry"
+#define LUAKIT_CALLBACKS_REGISTRY_KEY  "luakit.callbacks.registry"
 
 #include <glib/gtypes.h>
 #include <lua.h>

lib/async_call_example.lua

@@ -0,0 +1,16 @@
+local buf = lousy.bind.buf
+local key = lousy.bind.key
+add_binds("normal",
+          {
+           key({}, "a", function (w)
+                            luakit.spawn("touch /tmp/luakit_iat_test",
+                            function(exit_type, exit_num)
+                                if exit_num == 0 then
+                                    w:warning("OK")
+                                else
+                                    w:warning("Not OK")
+                                end
+                            end)
+                        end),
+          })
+

luah.c

@@ -19,7 +19,9 @@
  *
  */
 
+#include <glib/gprintf.h>
 #include <gtk/gtk.h>
+#include <glib.h>
 #include <stdlib.h>
 #include <sys/wait.h>
 #include <webkit/webkit.h>
@@ -527,22 +529,103 @@ luaH_luakit_spawn_sync(lua_State *L)
     return 3;
 }
 
+/* Calls the Lua function defined as callback for a (async) spawned process
+ *
+ * \param pid The PID of the process that has just finished
+ * \param status status information about the spawned process. See waitpid(2)
+ * \param data pointer to the Lua VM state
+ *
+ * The called Lua function receives 2 arguments:
+ *
+ * Exit type: one of: TERM_EXIT (normal exit), TERM_SIGNAL (terminated by
+ *            signal), TERM_UNKNOWN (another reason)
+ * Exit number: When normal exit happened, the exit code of the process. When
+ *              finished by a signal, the signal number. -1 otherwise.
+ */
+void async_callback_handler(GPid pid, gint status, gpointer data) {
+    lua_State *L = (lua_State *)data;
+
+    // fetch callbacks table
+    lua_pushliteral(L, LUAKIT_CALLBACKS_REGISTRY_KEY);
+    lua_rawget(L, LUA_REGISTRYINDEX);
+
+    // get callback function for the given PID (callbacks[pid])
+    lua_pushlightuserdata(L, (void *)pid);
+    lua_rawget(L, -2);
+
+    proc_exit_status_t exit_type;
+    int exit_num = 0;
+    if (WIFEXITED(status)) {
+        exit_type = TERM_EXIT;
+        exit_num = WEXITSTATUS(status);
+    } else if (WIFSIGNALED(status)) {
+        exit_type = TERM_SIGNAL;
+        exit_num = WTERMSIG(status);
+    } else {
+        exit_type = TERM_UNKNOWN;
+        exit_num = -1;
+    }
+    lua_pushinteger(L, exit_type);
+    lua_pushinteger(L, exit_num);
+    if (lua_pcall(L, 2, 0, 0)) {
+        g_fprintf(stderr, "%s\n", lua_tostring(L, -1));
+    }
+
+    // free callbacks[pid]
+    lua_pushlightuserdata(L, (void *)pid);
+    lua_pushnil(L);
+    lua_rawset(L, -3);
+
+    // stack cleanup - remove callbacks table from it
+    lua_remove(L, -1);
+
+    g_spawn_close_pid(pid);
+}
+
 /* Spawns a command.
- * \param L The Lua VM state.
+ * \param L The Lua VM state. Contains a Lua function, the callback handler to use
+ * when the command finishes.
  * \return The number of elements pushed on stack (0).
  */
 static gint
 luaH_luakit_spawn(lua_State *L)
 {
     GError *e = NULL;
+    GPid pid = 0;
     const gchar *command = luaL_checkstring(L, 1);
-    g_spawn_command_line_async(command, &e);
+    gint argc = 0;
+    gchar **argv = NULL;
+    g_shell_parse_argv(command, &argc, &argv, &e);
+    if (e) {
+        lua_pushstring(L, e->message);
+        g_clear_error(&e);
+        g_strfreev(argv);
+        lua_error(L);
+    }
+    g_spawn_async(NULL, argv, NULL,
+            G_SPAWN_DO_NOT_REAP_CHILD|G_SPAWN_SEARCH_PATH, NULL, NULL, &pid,
+            &e);
+    g_strfreev(argv);
     if(e)
     {
         lua_pushstring(L, e->message);
         g_clear_error(&e);
         lua_error(L);
     }
+    int CB_FUNC_IDX = 2;
+
+    int cb_type = lua_type(L, CB_FUNC_IDX);
+    if (cb_type == LUA_TNONE) return 0;
+
+    if (cb_type != LUA_TFUNCTION)
+        luaL_typerror(L, CB_FUNC_IDX, lua_typename(L, LUA_TFUNCTION));
+
+    lua_pushliteral(L, LUAKIT_CALLBACKS_REGISTRY_KEY);
+    lua_rawget(L, LUA_REGISTRYINDEX);
+    lua_pushlightuserdata(L, (void *)pid);
+    lua_pushvalue(L, CB_FUNC_IDX);
+    lua_rawset(L, -3);
+    g_child_watch_add(pid, async_callback_handler, L);
     return 0;
 }
 
@@ -599,6 +682,10 @@ luaH_luakit_index(lua_State *L)
       PI_CASE(WEBKIT_USER_AGENT_MAJOR_VERSION, WEBKIT_USER_AGENT_MAJOR_VERSION)
       PI_CASE(WEBKIT_USER_AGENT_MINOR_VERSION, WEBKIT_USER_AGENT_MINOR_VERSION)
 
+      PI_CASE(PROC_TERM_EXIT, TERM_EXIT)
+      PI_CASE(PROC_TERM_SIGNAL, TERM_SIGNAL)
+      PI_CASE(PROC_TERM_UNKNOWN, TERM_UNKNOWN)
+
       case L_TK_WINDOWS:
         lua_newtable(L);
         for (guint i = 0; i < globalconf.windows->len; i++) {
@@ -723,6 +810,18 @@ luaH_dofunction_on_error(lua_State *L)
     return 1;
 }
 
+/* creates a table (with an empty metatable) in the Lua registry to store the
+ * Lua callback functions associtated to processes spawned via
+ * luaH_luakit_spawn */
+void
+luaH_processcallbacks_setup(lua_State *L) {
+    lua_pushliteral(L, LUAKIT_CALLBACKS_REGISTRY_KEY);
+    lua_newtable(L);
+    lua_newtable(L);
+    lua_setmetatable(L, -2);
+    lua_rawset(L, LUA_REGISTRYINDEX);
+}
+
 void
 luaH_init(void)
 {
@@ -752,6 +851,7 @@ luaH_init(void)
     luaH_fixups(L);
 
     luaH_object_setup(L);
+    luaH_processcallbacks_setup(L);
 
     /* Export luakit lib */
     luaH_openlib(L, "luakit", luakit_lib, luakit_lib);

luah.h

@@ -27,6 +27,12 @@
 #include "common/luaobject.h"
 #include "common/lualib.h"
 
+typedef enum {
+    TERM_EXIT = 1,
+    TERM_SIGNAL,
+    TERM_UNKNOWN
+} proc_exit_status_t;
+
 #define luaH_deprecate(L, repl) \
     do { \
         luaH_warn(L, "%s: This function is deprecated and will be removed, see %s", \