Aire-One
/
awesome
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
awesome/spawn.c

409 lines
12 KiB
C
Raw Blame History

/*
* 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.
*
*/
/** awesome core API
*
* @author Julien Danjou &lt;julien@danjou.info&gt;
* @copyright 2008-2009 Julien Danjou
* @release @AWESOME_VERSION@
* @module awesome
*/
#include "spawn.h"
#include <unistd.h>
#include <glib.h>
/** 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.
* \return True if found and removed.
*/
static inline bool
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);
sn_startup_sequence_unref(s);
return true;
}
return false;
}
static gboolean
spawn_monitor_timeout(gpointer sequence)
{
if(spawn_sequence_remove(sequence))
{
signal_t *sig = signal_array_getbyid(&global_signals,
a_strhash((const unsigned char *) "spawn::timeout"));
if(sig)
{
/* send a timeout signal */
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");
foreach(func, sig->sigfuncs)
{
lua_pushvalue(L, -1);
luaA_object_push(L, (void *) *func);
luaA_dofunction(L, 1, 0);
}
lua_pop(L, 1);
}
else
warn("spawn::timeout signal is missing");
}
sn_startup_sequence_unref(sequence);
return FALSE;
}
static void
spawn_monitor_event(SnMonitorEvent *event, void *data)
{
lua_State *L = globalconf_get_lua_State();
SnStartupSequence *sequence = sn_monitor_event_get_startup_sequence(event);
SnMonitorEventType event_type = sn_monitor_event_get_type(event);
lua_createtable(L, 0, 2);
lua_pushstring(L, sn_startup_sequence_get_id(sequence));
lua_setfield(L, -2, "id");
const char *event_type_str = NULL;
switch(event_type)
{
case SN_MONITOR_EVENT_INITIATED:
/* ref the sequence for the array */
sn_startup_sequence_ref(sequence);
SnStartupSequence_array_append(&sn_waits, sequence);
event_type_str = "spawn::initiated";
/* Add a timeout function so we do not wait for this event to complete
* for ever */
g_timeout_add_seconds(AWESOME_SPAWN_TIMEOUT, spawn_monitor_timeout, sequence);
/* ref the sequence for the callback event */
sn_startup_sequence_ref(sequence);
break;
case SN_MONITOR_EVENT_CHANGED:
event_type_str = "spawn::change";
break;
case SN_MONITOR_EVENT_COMPLETED:
event_type_str = "spawn::completed";
break;
case SN_MONITOR_EVENT_CANCELED:
event_type_str = "spawn::canceled";
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)
{
lua_pushstring(L, s);
lua_setfield(L, -2, "name");
}
if((s = sn_startup_sequence_get_description(sequence)))
{
lua_pushstring(L, s);
lua_setfield(L, -2, "description");
}
lua_pushnumber(L, sn_startup_sequence_get_workspace(sequence));
lua_setfield(L, -2, "workspace");
if((s = sn_startup_sequence_get_binary_name(sequence)))
{
lua_pushstring(L, s);
lua_setfield(L, -2, "binary_name");
}
if((s = sn_startup_sequence_get_icon_name(sequence)))
{
lua_pushstring(L, s);
lua_setfield(L, -2, "icon_name");
}
if((s = sn_startup_sequence_get_wmclass(sequence)))
{
lua_pushstring(L, s);
lua_setfield(L, -2, "wmclass");
}
}
break;
case SN_MONITOR_EVENT_COMPLETED:
case SN_MONITOR_EVENT_CANCELED:
spawn_sequence_remove(sequence);
break;
}
/* 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)
{
lua_pushvalue(L, -1);
luaA_object_push(L, (void *) *func);
luaA_dofunction(L, 1, 0);
}
lua_pop(L, 1);
}
else
warn("%s signal is missing", event_type_str);
}
/** Tell the spawn module that an app has been started.
* \param c The client that just started.
* \param startup_id The startup id of the started application.
*/
void
spawn_start_notify(client_t *c, const char * startup_id)
{
foreach(_seq, sn_waits)
{
SnStartupSequence *seq = *_seq;
bool found = false;
const char *seqid = sn_startup_sequence_get_id(seq);
if (A_STRNEQ(seqid, startup_id))
found = true;
else
{
const char *seqclass = sn_startup_sequence_get_wmclass(seq);
if (A_STREQ(seqclass, c->class) || A_STREQ(seqclass, c->instance))
found = true;
else
{
const char *seqbin = sn_startup_sequence_get_binary_name(seq);
if (A_STREQ_CASE(seqbin, c->class) || A_STREQ_CASE(seqbin, c->instance))
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);
globalconf.snmonitor = sn_monitor_context_new(globalconf.sndisplay,
globalconf.default_screen,
spawn_monitor_event,
NULL, NULL);
/** For some reason the application aborted startup
* @param arg Table which only got the "id" key set
* @signal spawn::canceled
*/
signal_add(&global_signals, "spawn::canceled");
/** When one of the fields from the @{spawn::initiated} table changes
* @param arg Table which describes the spawn event
* @signal spawn::change
*/
signal_add(&global_signals, "spawn::change");
/** An application finished starting
* @param arg Table which only got the "id" key set
* @signal spawn::completed
*/
signal_add(&global_signals, "spawn::completed");
/** When a new client is beginning to start
* @param arg Table which describes the spawn event
* @signal spawn::initiated
*/
signal_add(&global_signals, "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
*/
signal_add(&global_signals, "spawn::timeout");
}
static gboolean
spawn_launchee_timeout(gpointer context)
{
sn_launcher_context_complete(context);
sn_launcher_context_unref(context);
return FALSE;
}
static void
spawn_callback(gpointer user_data)
{
setsid();
}
/** 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.
*/
static gchar **
parse_command(lua_State *L, int idx, GError **error)
{
gchar **argv = NULL;
idx = luaA_absindex(L, idx);
if (lua_isstring(L, idx))
{
const char *cmd = luaL_checkstring(L, idx);
if(!g_shell_parse_argv(cmd, NULL, &argv, error))
return NULL;
}
else if (lua_istable(L, idx))
{
size_t i, len = luaA_rawlen(L, idx);
/* First verify that the table is sane: All integer keys must contain
* strings. Do this by pushing them all onto the stack.
*/
for (i = 0; i < len; i++)
{
lua_rawgeti(L, idx, i+1);
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));
lua_pop(L, 1);
}
}
else
{
luaL_error(L, "Invalid argument to spawn(), expect string or table");
}
return argv;
}
/** Spawn a program.
* The program will be started on the default screen.
*
* @param cmd The command to launch.
* @param use_sn Use startup-notification, true or false, default to true.
* @return Process ID if everything is OK, or an error string if an error occured.
* @function spawn
*/
int
luaA_spawn(lua_State *L)
{
gchar **argv = NULL;
bool use_sn = true;
gboolean retval;
GPid pid;
if(lua_gettop(L) >= 2)
use_sn = luaA_checkboolean(L, 2);
GError *error = NULL;
argv = parse_command(L, 1, &error);
if(!argv || !argv[0])
{
g_strfreev(argv);
/* push error on stack */
lua_pushfstring(L, "spawn: parse error: %s", error->message);
warn("%s", lua_tostring(L, -1));
g_error_free(error);
return 1;
}
SnLauncherContext *context = NULL;
if(use_sn)
{
context = sn_launcher_context_new(globalconf.sndisplay, globalconf.default_screen);
sn_launcher_context_set_name(context, "awesome");
sn_launcher_context_set_description(context, "awesome spawn");
sn_launcher_context_set_binary_name(context, argv[0]);
sn_launcher_context_initiate(context, "awesome", argv[0], globalconf.timestamp);
/* app will have AWESOME_SPAWN_TIMEOUT seconds to complete,
* or the timeout function will terminate the launch sequence anyway */
g_timeout_add_seconds(AWESOME_SPAWN_TIMEOUT, spawn_launchee_timeout, context);
sn_launcher_context_setup_child_process(context);
}
retval = g_spawn_async(NULL, argv, NULL, G_SPAWN_SEARCH_PATH,
spawn_callback, NULL, &pid, &error);
g_strfreev(argv);
if(!retval)
{
/* push error on stack */
lua_pushstring(L, error->message);
warn("%s", lua_tostring(L, -1));
g_error_free(error);
if(context)
sn_launcher_context_complete(context);
return 1;
}
/* push pid on stack */
lua_pushnumber(L, pid);
/* push sn on stack */
if (context)
lua_pushstring(L,sn_launcher_context_get_startup_id(context));
return (context)?2:1;
}
// vim: filetype=c:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:textwidth=80
Reference in New Issue View Git Blame Copy Permalink