2009-04-03 13:09:17 +02:00
|
|
|
/*
|
|
|
|
* spawn.c - Lua configuration management
|
|
|
|
*
|
|
|
|
* Copyright © 2009 Julien Danjou <julien@danjou.info>
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License along
|
|
|
|
* with this program; if not, write to the Free Software Foundation, Inc.,
|
|
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2015-02-27 00:24:23 +01:00
|
|
|
/** awesome core API
|
|
|
|
*
|
|
|
|
* @author Julien Danjou <julien@danjou.info>
|
|
|
|
* @copyright 2008-2009 Julien Danjou
|
|
|
|
* @release @AWESOME_VERSION@
|
|
|
|
* @module awesome
|
|
|
|
*/
|
|
|
|
|
2016-06-04 17:39:14 +02:00
|
|
|
/** For some reason the application aborted startup
|
|
|
|
* @param arg Table which only got the "id" key set
|
|
|
|
* @signal spawn::canceled
|
|
|
|
*/
|
|
|
|
|
|
|
|
/** When one of the fields from the @{spawn::initiated} table changes
|
|
|
|
* @param arg Table which describes the spawn event
|
|
|
|
* @signal spawn::change
|
|
|
|
*/
|
|
|
|
|
|
|
|
/** An application finished starting
|
|
|
|
* @param arg Table which only got the "id" key set
|
|
|
|
* @signal spawn::completed
|
|
|
|
*/
|
|
|
|
|
|
|
|
/** When a new client is beginning to start
|
|
|
|
* @param arg Table which describes the spawn event
|
|
|
|
* @signal spawn::initiated
|
|
|
|
*/
|
|
|
|
|
|
|
|
/** An application started a spawn event but didn't start in time.
|
|
|
|
* @param arg Table which only got the "id" key set
|
|
|
|
* @signal spawn::timeout
|
|
|
|
*/
|
|
|
|
|
2014-03-30 20:07:48 +02:00
|
|
|
#include "spawn.h"
|
2009-04-03 13:09:17 +02:00
|
|
|
|
2014-03-30 20:07:48 +02:00
|
|
|
#include <unistd.h>
|
2010-10-06 20:08:24 +02:00
|
|
|
#include <glib.h>
|
2009-04-27 20:18:39 +02:00
|
|
|
|
2009-04-03 16:30:18 +02:00
|
|
|
/** 20 seconds timeout */
|
|
|
|
#define AWESOME_SPAWN_TIMEOUT 20.0
|
|
|
|
|
|
|
|
/** Wrapper for unrefing startup sequence.
|
|
|
|
*/
|
|
|
|
static inline void
|
|
|
|
a_sn_startup_sequence_unref(SnStartupSequence **sss)
|
|
|
|
{
|
|
|
|
return sn_startup_sequence_unref(*sss);
|
|
|
|
}
|
|
|
|
|
|
|
|
DO_ARRAY(SnStartupSequence *, SnStartupSequence, a_sn_startup_sequence_unref)
|
|
|
|
|
|
|
|
/** The array of startup sequence running */
|
|
|
|
SnStartupSequence_array_t sn_waits;
|
|
|
|
|
|
|
|
/** Remove a SnStartupSequence pointer from an array and forget about it.
|
|
|
|
* \param s The startup sequence to found, remove and unref.
|
2009-05-10 01:10:39 +02:00
|
|
|
* \return True if found and removed.
|
2009-04-03 16:30:18 +02:00
|
|
|
*/
|
2009-05-10 01:10:39 +02:00
|
|
|
static inline bool
|
2009-04-03 16:30:18 +02:00
|
|
|
spawn_sequence_remove(SnStartupSequence *s)
|
|
|
|
{
|
|
|
|
for(int i = 0; i < sn_waits.len; i++)
|
|
|
|
if(sn_waits.tab[i] == s)
|
|
|
|
{
|
|
|
|
SnStartupSequence_array_take(&sn_waits, i);
|
2009-05-12 08:11:35 +02:00
|
|
|
sn_startup_sequence_unref(s);
|
2009-05-10 01:10:39 +02:00
|
|
|
return true;
|
2009-04-03 16:30:18 +02:00
|
|
|
}
|
2009-05-10 01:10:39 +02:00
|
|
|
return false;
|
2009-04-03 16:30:18 +02:00
|
|
|
}
|
|
|
|
|
2012-11-21 21:01:12 +01:00
|
|
|
static gboolean
|
|
|
|
spawn_monitor_timeout(gpointer sequence)
|
2009-04-03 16:30:18 +02:00
|
|
|
{
|
2012-11-21 21:01:12 +01:00
|
|
|
if(spawn_sequence_remove(sequence))
|
2009-05-09 16:03:27 +02:00
|
|
|
{
|
2009-07-31 16:28:17 +02:00
|
|
|
signal_t *sig = signal_array_getbyid(&global_signals,
|
|
|
|
a_strhash((const unsigned char *) "spawn::timeout"));
|
|
|
|
if(sig)
|
|
|
|
{
|
|
|
|
/* send a timeout signal */
|
2014-12-06 11:56:58 +01:00
|
|
|
lua_State *L = globalconf_get_lua_State();
|
|
|
|
lua_createtable(L, 0, 2);
|
|
|
|
lua_pushstring(L, sn_startup_sequence_get_id(sequence));
|
|
|
|
lua_setfield(L, -2, "id");
|
2009-07-31 16:28:17 +02:00
|
|
|
foreach(func, sig->sigfuncs)
|
|
|
|
{
|
2014-12-06 11:56:58 +01:00
|
|
|
lua_pushvalue(L, -1);
|
|
|
|
luaA_object_push(L, (void *) *func);
|
|
|
|
luaA_dofunction(L, 1, 0);
|
2009-07-31 16:28:17 +02:00
|
|
|
}
|
2014-12-06 11:56:58 +01:00
|
|
|
lua_pop(L, 1);
|
2009-07-31 16:28:17 +02:00
|
|
|
}
|
2010-08-25 23:00:36 +02:00
|
|
|
else
|
|
|
|
warn("spawn::timeout signal is missing");
|
2009-05-09 16:03:27 +02:00
|
|
|
}
|
2012-11-21 21:01:12 +01:00
|
|
|
sn_startup_sequence_unref(sequence);
|
|
|
|
return FALSE;
|
2009-04-03 16:30:18 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
spawn_monitor_event(SnMonitorEvent *event, void *data)
|
|
|
|
{
|
2014-12-06 11:56:58 +01:00
|
|
|
lua_State *L = globalconf_get_lua_State();
|
2009-04-03 16:30:18 +02:00
|
|
|
SnStartupSequence *sequence = sn_monitor_event_get_startup_sequence(event);
|
|
|
|
SnMonitorEventType event_type = sn_monitor_event_get_type(event);
|
|
|
|
|
2014-12-06 11:56:58 +01:00
|
|
|
lua_createtable(L, 0, 2);
|
|
|
|
lua_pushstring(L, sn_startup_sequence_get_id(sequence));
|
|
|
|
lua_setfield(L, -2, "id");
|
2009-04-03 16:30:18 +02:00
|
|
|
|
2009-07-31 16:28:17 +02:00
|
|
|
const char *event_type_str = NULL;
|
|
|
|
|
2009-04-03 16:30:18 +02:00
|
|
|
switch(event_type)
|
|
|
|
{
|
|
|
|
case SN_MONITOR_EVENT_INITIATED:
|
2009-05-09 15:48:45 +02:00
|
|
|
/* ref the sequence for the array */
|
2009-04-03 16:30:18 +02:00
|
|
|
sn_startup_sequence_ref(sequence);
|
|
|
|
SnStartupSequence_array_append(&sn_waits, sequence);
|
2009-07-31 16:28:17 +02:00
|
|
|
event_type_str = "spawn::initiated";
|
2009-04-03 16:30:18 +02:00
|
|
|
|
|
|
|
/* Add a timeout function so we do not wait for this event to complete
|
|
|
|
* for ever */
|
2012-11-21 21:01:12 +01:00
|
|
|
g_timeout_add_seconds(AWESOME_SPAWN_TIMEOUT, spawn_monitor_timeout, sequence);
|
2009-05-09 15:48:45 +02:00
|
|
|
/* ref the sequence for the callback event */
|
|
|
|
sn_startup_sequence_ref(sequence);
|
2009-04-03 16:30:18 +02:00
|
|
|
break;
|
|
|
|
case SN_MONITOR_EVENT_CHANGED:
|
2009-07-31 16:28:17 +02:00
|
|
|
event_type_str = "spawn::change";
|
2009-04-03 16:30:18 +02:00
|
|
|
break;
|
|
|
|
case SN_MONITOR_EVENT_COMPLETED:
|
2009-07-31 16:28:17 +02:00
|
|
|
event_type_str = "spawn::completed";
|
2009-04-03 16:30:18 +02:00
|
|
|
break;
|
|
|
|
case SN_MONITOR_EVENT_CANCELED:
|
2009-07-31 16:28:17 +02:00
|
|
|
event_type_str = "spawn::canceled";
|
2009-04-03 16:30:18 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* common actions */
|
|
|
|
switch(event_type)
|
|
|
|
{
|
|
|
|
case SN_MONITOR_EVENT_INITIATED:
|
|
|
|
case SN_MONITOR_EVENT_CHANGED:
|
|
|
|
{
|
|
|
|
const char *s = sn_startup_sequence_get_name(sequence);
|
|
|
|
if(s)
|
|
|
|
{
|
2014-12-06 11:56:58 +01:00
|
|
|
lua_pushstring(L, s);
|
|
|
|
lua_setfield(L, -2, "name");
|
2009-04-03 16:30:18 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if((s = sn_startup_sequence_get_description(sequence)))
|
|
|
|
{
|
2014-12-06 11:56:58 +01:00
|
|
|
lua_pushstring(L, s);
|
|
|
|
lua_setfield(L, -2, "description");
|
2009-04-03 16:30:18 +02:00
|
|
|
}
|
|
|
|
|
2016-02-06 13:46:46 +01:00
|
|
|
lua_pushinteger(L, sn_startup_sequence_get_workspace(sequence));
|
2014-12-06 11:56:58 +01:00
|
|
|
lua_setfield(L, -2, "workspace");
|
2009-04-03 16:30:18 +02:00
|
|
|
|
|
|
|
if((s = sn_startup_sequence_get_binary_name(sequence)))
|
|
|
|
{
|
2014-12-06 11:56:58 +01:00
|
|
|
lua_pushstring(L, s);
|
|
|
|
lua_setfield(L, -2, "binary_name");
|
2009-04-03 16:30:18 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if((s = sn_startup_sequence_get_icon_name(sequence)))
|
|
|
|
{
|
2014-12-06 11:56:58 +01:00
|
|
|
lua_pushstring(L, s);
|
|
|
|
lua_setfield(L, -2, "icon_name");
|
2009-04-03 16:30:18 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if((s = sn_startup_sequence_get_wmclass(sequence)))
|
|
|
|
{
|
2014-12-06 11:56:58 +01:00
|
|
|
lua_pushstring(L, s);
|
|
|
|
lua_setfield(L, -2, "wmclass");
|
2009-04-03 16:30:18 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case SN_MONITOR_EVENT_COMPLETED:
|
|
|
|
case SN_MONITOR_EVENT_CANCELED:
|
|
|
|
spawn_sequence_remove(sequence);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2009-07-31 16:28:17 +02:00
|
|
|
/* send the signal */
|
|
|
|
signal_t *sig = signal_array_getbyid(&global_signals,
|
|
|
|
a_strhash((const unsigned char *) event_type_str));
|
|
|
|
|
|
|
|
if(sig)
|
|
|
|
{
|
|
|
|
foreach(func, sig->sigfuncs)
|
|
|
|
{
|
2014-12-06 11:56:58 +01:00
|
|
|
lua_pushvalue(L, -1);
|
|
|
|
luaA_object_push(L, (void *) *func);
|
|
|
|
luaA_dofunction(L, 1, 0);
|
2009-07-31 16:28:17 +02:00
|
|
|
}
|
2014-12-06 11:56:58 +01:00
|
|
|
lua_pop(L, 1);
|
2009-07-31 16:28:17 +02:00
|
|
|
}
|
2010-08-25 23:00:36 +02:00
|
|
|
else
|
|
|
|
warn("%s signal is missing", event_type_str);
|
2009-04-03 16:30:18 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/** Tell the spawn module that an app has been started.
|
|
|
|
* \param c The client that just started.
|
2009-08-24 10:16:52 +02:00
|
|
|
* \param startup_id The startup id of the started application.
|
2009-04-03 16:30:18 +02:00
|
|
|
*/
|
|
|
|
void
|
2009-08-24 10:16:52 +02:00
|
|
|
spawn_start_notify(client_t *c, const char * startup_id)
|
2009-04-03 16:30:18 +02:00
|
|
|
{
|
|
|
|
foreach(_seq, sn_waits)
|
|
|
|
{
|
|
|
|
SnStartupSequence *seq = *_seq;
|
|
|
|
bool found = false;
|
|
|
|
const char *seqid = sn_startup_sequence_get_id(seq);
|
|
|
|
|
2011-11-17 16:38:39 +01:00
|
|
|
if (A_STRNEQ(seqid, startup_id))
|
2009-04-03 16:30:18 +02:00
|
|
|
found = true;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
const char *seqclass = sn_startup_sequence_get_wmclass(seq);
|
2011-11-17 16:38:39 +01:00
|
|
|
if (A_STREQ(seqclass, c->class) || A_STREQ(seqclass, c->instance))
|
2009-04-03 16:30:18 +02:00
|
|
|
found = true;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
const char *seqbin = sn_startup_sequence_get_binary_name(seq);
|
2011-11-17 16:38:39 +01:00
|
|
|
if (A_STREQ_CASE(seqbin, c->class) || A_STREQ_CASE(seqbin, c->instance))
|
2009-04-03 16:30:18 +02:00
|
|
|
found = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if(found)
|
|
|
|
{
|
|
|
|
sn_startup_sequence_complete(seq);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/** Initialize program spawner.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
spawn_init(void)
|
|
|
|
{
|
|
|
|
globalconf.sndisplay = sn_xcb_display_new(globalconf.connection, NULL, NULL);
|
|
|
|
|
2010-08-16 13:57:31 +02:00
|
|
|
globalconf.snmonitor = sn_monitor_context_new(globalconf.sndisplay,
|
|
|
|
globalconf.default_screen,
|
|
|
|
spawn_monitor_event,
|
|
|
|
NULL, NULL);
|
2010-08-25 23:00:36 +02:00
|
|
|
|
2010-08-26 17:46:17 +02:00
|
|
|
signal_add(&global_signals, "spawn::canceled");
|
2010-08-25 23:00:36 +02:00
|
|
|
signal_add(&global_signals, "spawn::change");
|
2010-08-26 17:46:17 +02:00
|
|
|
signal_add(&global_signals, "spawn::completed");
|
2010-08-25 23:00:36 +02:00
|
|
|
signal_add(&global_signals, "spawn::initiated");
|
2010-08-26 17:46:17 +02:00
|
|
|
signal_add(&global_signals, "spawn::timeout");
|
2009-04-03 16:30:18 +02:00
|
|
|
}
|
|
|
|
|
2012-11-21 21:01:12 +01:00
|
|
|
static gboolean
|
|
|
|
spawn_launchee_timeout(gpointer context)
|
2009-04-03 16:30:18 +02:00
|
|
|
{
|
2012-11-21 21:01:12 +01:00
|
|
|
sn_launcher_context_complete(context);
|
|
|
|
sn_launcher_context_unref(context);
|
|
|
|
return FALSE;
|
2009-04-03 16:30:18 +02:00
|
|
|
}
|
2009-04-03 13:09:17 +02:00
|
|
|
|
2010-12-04 13:19:01 +01:00
|
|
|
static void
|
|
|
|
spawn_callback(gpointer user_data)
|
|
|
|
{
|
2015-11-01 17:53:53 +01:00
|
|
|
SnLauncherContext *context = (SnLauncherContext *) user_data;
|
2010-12-04 13:19:01 +01:00
|
|
|
setsid();
|
2015-11-01 17:53:53 +01:00
|
|
|
|
|
|
|
if (context)
|
|
|
|
sn_launcher_context_setup_child_process(context);
|
|
|
|
else
|
|
|
|
/* Unset in case awesome was already started with this variable set */
|
|
|
|
unsetenv("DESKTOP_STARTUP_ID");
|
2010-12-04 13:19:01 +01:00
|
|
|
}
|
|
|
|
|
2013-03-10 14:54:58 +01:00
|
|
|
/** Parse a command line.
|
|
|
|
* \param L The Lua VM state.
|
|
|
|
* \param idx The index of the argument that we should parse
|
|
|
|
* \return The argv array for the new process.
|
2009-08-25 11:05:58 +02:00
|
|
|
*/
|
2013-03-10 14:54:58 +01:00
|
|
|
static gchar **
|
2015-03-31 01:17:45 +02:00
|
|
|
parse_command(lua_State *L, int idx, GError **error)
|
2009-08-25 11:05:58 +02:00
|
|
|
{
|
2013-03-10 14:54:58 +01:00
|
|
|
gchar **argv = NULL;
|
2014-03-12 11:12:23 +01:00
|
|
|
idx = luaA_absindex(L, idx);
|
2009-08-25 11:05:58 +02:00
|
|
|
|
2013-03-10 14:54:58 +01:00
|
|
|
if (lua_isstring(L, idx))
|
|
|
|
{
|
|
|
|
const char *cmd = luaL_checkstring(L, idx);
|
2015-03-31 01:17:45 +02:00
|
|
|
if(!g_shell_parse_argv(cmd, NULL, &argv, error))
|
2013-03-10 14:54:58 +01:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
else if (lua_istable(L, idx))
|
|
|
|
{
|
|
|
|
size_t i, len = luaA_rawlen(L, idx);
|
2009-08-25 11:05:58 +02:00
|
|
|
|
2014-03-12 11:12:23 +01:00
|
|
|
/* First verify that the table is sane: All integer keys must contain
|
|
|
|
* strings. Do this by pushing them all onto the stack.
|
|
|
|
*/
|
2013-03-10 14:54:58 +01:00
|
|
|
for (i = 0; i < len; i++)
|
|
|
|
{
|
|
|
|
lua_rawgeti(L, idx, i+1);
|
2014-03-12 11:12:23 +01:00
|
|
|
if (lua_type(L, -1) != LUA_TSTRING)
|
|
|
|
luaL_error(L, "Non-string argument at table index %d", i+1);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* From this point on nothing can go wrong and so we can safely allocate
|
|
|
|
* memory.
|
|
|
|
*/
|
|
|
|
argv = g_new0(gchar *, len + 1);
|
|
|
|
for (i = 0; i < len; i++)
|
|
|
|
{
|
|
|
|
argv[len - i - 1] = g_strdup(lua_tostring(L, -1));
|
2013-03-10 14:54:58 +01:00
|
|
|
lua_pop(L, 1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
luaL_error(L, "Invalid argument to spawn(), expect string or table");
|
|
|
|
}
|
2009-08-25 11:05:58 +02:00
|
|
|
|
2013-03-10 14:54:58 +01:00
|
|
|
return argv;
|
2009-08-25 11:05:58 +02:00
|
|
|
}
|
|
|
|
|
2015-11-29 11:53:12 +01:00
|
|
|
/** Callback for when a spawned process exits. */
|
|
|
|
static void
|
|
|
|
child_exit_callback(GPid pid, gint status, gpointer user_data)
|
|
|
|
{
|
|
|
|
lua_State *L = globalconf_get_lua_State();
|
|
|
|
int exit_callback = GPOINTER_TO_INT(user_data);
|
|
|
|
|
|
|
|
/* 'Decode' the exit status */
|
|
|
|
if (WIFEXITED(status)) {
|
|
|
|
lua_pushliteral(L, "exit");
|
2016-02-06 13:46:46 +01:00
|
|
|
lua_pushinteger(L, WEXITSTATUS(status));
|
2015-11-29 11:53:12 +01:00
|
|
|
} else {
|
|
|
|
assert(WIFSIGNALED(status));
|
|
|
|
lua_pushliteral(L, "signal");
|
2016-02-06 13:46:46 +01:00
|
|
|
lua_pushinteger(L, WTERMSIG(status));
|
2015-11-29 11:53:12 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
lua_rawgeti(L, LUA_REGISTRYINDEX, exit_callback);
|
|
|
|
luaA_dofunction(L, 2, 0);
|
|
|
|
luaA_unregister(L, &exit_callback);
|
|
|
|
}
|
|
|
|
|
2009-04-03 13:09:17 +02:00
|
|
|
/** Spawn a program.
|
2015-07-24 15:20:55 +02:00
|
|
|
* The program will be started on the default screen.
|
2015-02-27 00:24:23 +01:00
|
|
|
*
|
2015-07-25 15:16:23 +02:00
|
|
|
* @tparam string|table cmd The command to launch.
|
|
|
|
* @tparam[opt=true] boolean use_sn Use startup-notification?
|
2015-08-13 09:05:52 +02:00
|
|
|
* @tparam[opt=false] boolean stdin Return a fd for stdin?
|
|
|
|
* @tparam[opt=false] boolean stdout Return a fd for stdout?
|
|
|
|
* @tparam[opt=false] boolean stderr Return a fd for stderr?
|
2015-11-29 11:53:12 +01:00
|
|
|
* @tparam[opt=nil] function exit_callback Function to call on process exit. The
|
|
|
|
* function arguments will be type of exit ("exit" or "signal") and the exit
|
|
|
|
* code / the signal number causing process termination.
|
2015-07-25 15:16:23 +02:00
|
|
|
* @treturn[1] integer Process ID if everything is OK.
|
|
|
|
* @treturn[1] string Startup-notification ID, if `use_sn` is true.
|
2015-08-13 09:05:52 +02:00
|
|
|
* @treturn[1] integer stdin, if `stdin` is true.
|
|
|
|
* @treturn[1] integer stdout, if `stdout` is true.
|
|
|
|
* @treturn[1] integer stderr, if `stderr` is true.
|
2015-07-25 15:16:23 +02:00
|
|
|
* @treturn[2] string An error string if an error occured.
|
2015-02-27 00:24:23 +01:00
|
|
|
* @function spawn
|
2009-04-03 13:09:17 +02:00
|
|
|
*/
|
|
|
|
int
|
|
|
|
luaA_spawn(lua_State *L)
|
|
|
|
{
|
2013-03-10 14:54:58 +01:00
|
|
|
gchar **argv = NULL;
|
2015-08-13 09:05:52 +02:00
|
|
|
bool use_sn = true, return_stdin = false, return_stdout = false, return_stderr = false;
|
|
|
|
int stdin_fd = -1, stdout_fd = -1, stderr_fd = -1;
|
|
|
|
int *stdin_ptr = NULL, *stdout_ptr = NULL, *stderr_ptr = NULL;
|
2015-11-29 11:53:12 +01:00
|
|
|
GSpawnFlags flags = 0;
|
2013-03-10 14:54:58 +01:00
|
|
|
gboolean retval;
|
|
|
|
GPid pid;
|
2009-04-03 13:09:17 +02:00
|
|
|
|
2009-04-03 16:30:18 +02:00
|
|
|
if(lua_gettop(L) >= 2)
|
|
|
|
use_sn = luaA_checkboolean(L, 2);
|
2015-08-13 09:05:52 +02:00
|
|
|
if(lua_gettop(L) >= 3)
|
|
|
|
return_stdin = luaA_checkboolean(L, 3);
|
|
|
|
if(lua_gettop(L) >= 4)
|
|
|
|
return_stdout = luaA_checkboolean(L, 4);
|
|
|
|
if(lua_gettop(L) >= 5)
|
|
|
|
return_stderr = luaA_checkboolean(L, 5);
|
2015-12-15 11:32:53 +01:00
|
|
|
if (!lua_isnoneornil(L, 6))
|
2015-11-29 11:53:12 +01:00
|
|
|
{
|
|
|
|
luaA_checkfunction(L, 6);
|
|
|
|
flags |= G_SPAWN_DO_NOT_REAP_CHILD;
|
|
|
|
}
|
2015-08-13 09:05:52 +02:00
|
|
|
if(return_stdin)
|
|
|
|
stdin_ptr = &stdin_fd;
|
|
|
|
if(return_stdout)
|
|
|
|
stdout_ptr = &stdout_fd;
|
|
|
|
if(return_stderr)
|
|
|
|
stderr_ptr = &stderr_fd;
|
2009-04-03 16:30:18 +02:00
|
|
|
|
2015-03-31 01:17:45 +02:00
|
|
|
GError *error = NULL;
|
|
|
|
argv = parse_command(L, 1, &error);
|
2014-03-12 11:10:48 +01:00
|
|
|
if(!argv || !argv[0])
|
|
|
|
{
|
|
|
|
g_strfreev(argv);
|
2015-12-23 14:01:10 +01:00
|
|
|
luaA_warn(L, "spawn: parse error: %s", error->message);
|
2015-03-31 01:17:45 +02:00
|
|
|
g_error_free(error);
|
|
|
|
return 1;
|
2014-03-12 11:10:48 +01:00
|
|
|
}
|
2009-04-03 13:09:17 +02:00
|
|
|
|
2009-04-27 20:18:39 +02:00
|
|
|
SnLauncherContext *context = NULL;
|
2009-04-03 16:30:18 +02:00
|
|
|
if(use_sn)
|
|
|
|
{
|
2010-08-16 13:47:40 +02:00
|
|
|
context = sn_launcher_context_new(globalconf.sndisplay, globalconf.default_screen);
|
2009-04-03 16:30:18 +02:00
|
|
|
sn_launcher_context_set_name(context, "awesome");
|
|
|
|
sn_launcher_context_set_description(context, "awesome spawn");
|
2014-03-12 11:15:40 +01:00
|
|
|
sn_launcher_context_set_binary_name(context, argv[0]);
|
|
|
|
sn_launcher_context_initiate(context, "awesome", argv[0], globalconf.timestamp);
|
2009-04-03 16:30:18 +02:00
|
|
|
|
|
|
|
/* app will have AWESOME_SPAWN_TIMEOUT seconds to complete,
|
|
|
|
* or the timeout function will terminate the launch sequence anyway */
|
2012-11-21 21:01:12 +01:00
|
|
|
g_timeout_add_seconds(AWESOME_SPAWN_TIMEOUT, spawn_launchee_timeout, context);
|
2009-04-03 16:30:18 +02:00
|
|
|
}
|
|
|
|
|
2015-11-29 11:53:12 +01:00
|
|
|
flags |= G_SPAWN_SEARCH_PATH;
|
|
|
|
retval = g_spawn_async_with_pipes(NULL, argv, NULL, flags,
|
2015-11-01 17:53:53 +01:00
|
|
|
spawn_callback, context, &pid,
|
2015-08-13 09:05:52 +02:00
|
|
|
stdin_ptr, stdout_ptr, stderr_ptr, &error);
|
2013-03-10 14:54:58 +01:00
|
|
|
g_strfreev(argv);
|
|
|
|
if(!retval)
|
2009-04-03 13:09:17 +02:00
|
|
|
{
|
2015-12-23 14:01:10 +01:00
|
|
|
luaA_warn(L, "%s", error->message);
|
2009-04-27 20:18:39 +02:00
|
|
|
g_error_free(error);
|
|
|
|
if(context)
|
|
|
|
sn_launcher_context_complete(context);
|
|
|
|
return 1;
|
2009-04-03 13:09:17 +02:00
|
|
|
}
|
|
|
|
|
2015-11-29 11:53:12 +01:00
|
|
|
if(flags & G_SPAWN_DO_NOT_REAP_CHILD)
|
|
|
|
{
|
|
|
|
int exit_callback = LUA_REFNIL;
|
|
|
|
/* Only do this down here to avoid leaks in case of errors */
|
|
|
|
luaA_registerfct(L, 6, &exit_callback);
|
|
|
|
g_child_watch_add(pid, child_exit_callback, GINT_TO_POINTER(exit_callback));
|
|
|
|
}
|
|
|
|
|
2010-04-24 11:49:57 +02:00
|
|
|
/* push pid on stack */
|
2016-02-06 13:46:46 +01:00
|
|
|
lua_pushinteger(L, pid);
|
2010-04-24 11:49:57 +02:00
|
|
|
|
2014-03-15 23:09:33 +01:00
|
|
|
/* push sn on stack */
|
|
|
|
if (context)
|
2015-08-13 09:05:52 +02:00
|
|
|
lua_pushstring(L, sn_launcher_context_get_startup_id(context));
|
|
|
|
else
|
|
|
|
lua_pushnil(L);
|
|
|
|
|
|
|
|
if(return_stdin)
|
|
|
|
lua_pushinteger(L, stdin_fd);
|
|
|
|
else
|
|
|
|
lua_pushnil(L);
|
|
|
|
if(return_stdout)
|
|
|
|
lua_pushinteger(L, stdout_fd);
|
|
|
|
else
|
|
|
|
lua_pushnil(L);
|
|
|
|
if(return_stderr)
|
|
|
|
lua_pushinteger(L, stderr_fd);
|
|
|
|
else
|
|
|
|
lua_pushnil(L);
|
2014-03-15 23:09:33 +01:00
|
|
|
|
2015-08-13 09:05:52 +02:00
|
|
|
return 5;
|
2009-04-03 13:09:17 +02:00
|
|
|
}
|
|
|
|
|
2011-09-11 16:50:01 +02:00
|
|
|
// vim: filetype=c:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:textwidth=80
|