process.c File Reference

#include <glib.h>
#include <signal.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <hal/libhal.h>
#include <liberkeyb/erkeyb-client.h>
#include "log.h"
#include "busy.h"
#include "conf.h"
#include "connections.h"
#include "display.h"
#include "ipc.h"
#include "hal.h"
#include "process.h"
#include "tasks.h"
#include "xwindow.h"

Include dependency graph for process.c:

Go to the source code of this file.

Functions
static void	check_start_next (void)
static void	on_process_exit (GPid pid, gint status, gpointer data)
static gboolean	on_startup_completed_timeout (gpointer data)
static gboolean	start_process (proc_t *proc)
static void	check_respawn (proc_t *proc)
static void	on_reply_error (eripc_context_t *context, const eripc_event_info_t *info, void *user_data)
static void	post_process_startup (proc_t *proc, const char *application, gint window)
static proc_t *	create_process (const char *command, const char *working_dir, GCallback startup_callback, GCallback exit_callback, gint flags)
static void	destroy_process (proc_t *proc)
gboolean	process_add (const char *command, const char *working_dir, GCallback startup_callback, GCallback exit_callback, gint flags)
	Add a process to the queue. The queue is served First In First Out.
proc_t *	process_start (const char *command, const char *working_dir, GCallback startup_callback, GCallback exit_callback, gint flags)
	Start a process without queuing.
void	process_stop (proc_t *proc)
	Stop a running process.
gboolean	process_activate (const char *application)
	Activate a running process (set to top).
gboolean	process_activate_ctb ()
	Activate content browser (set to top).
gboolean	process_startup_complete (const char *application, gint pid, gboolean is_multidoc, const char *ipc_service, gint window)
	Call when application has finished starting.
proc_t *	process_get_by_pid (GPid pid)
void	print_process_list ()
proc_t *	process_get_by_name (const char *application)
Variables
static const gint	TIMEOUT_STARTUP_COMPLETED = 30
static GSList *	g_proclist = NULL
static gint	g_process_pending_source = 0

---

Function Documentation

static void check_respawn

(

proc_t *

proc

)

[static]

Definition at line 492 of file process.c.

References check_start_next(), proc_t::command, destroy_process(), proc_t::exit_callback, proc_t::flags, proc_t::ipc_service, LOGPRINTF, proc_t::pid, PS_RESPAWN, proc_t::startup_callback, proc_t::state, STATE_DEVICE_STOPPING, STATE_IDLE, sys_get_device_state(), and WARNPRINTF.

Referenced by on_process_exit(), and on_reply_error().

{
    GPid pid = proc->pid;
    
    if (proc->flags & PS_RESPAWN)
    {
        LOGPRINTF("should respawn, new state STATE_IDLE");
        WARNPRINTF("respawn application %s", proc->command);
        // reset to initial values
        proc->state = STATE_IDLE;
        proc->pid   = 0;
        g_free(proc->ipc_service);
        proc->ipc_service = NULL;
        // don't use callbacks when respawning
        proc->startup_callback = NULL;
        proc->exit_callback = NULL;
    }
    else
    {
        LOGPRINTF("no respawn, remove from list");
        destroy_process(proc);
        proc = NULL;
    }
    
    // graciously close pid
    g_spawn_close_pid(pid);
    
    if (sys_get_device_state() != STATE_DEVICE_STOPPING)
    {
        // start next process
        check_start_next();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void check_start_next

(

void

)

[static]

Definition at line 547 of file process.c.

References proc_t::command, proc_t::flags, g_proclist, LOGPRINTF, proc_t::pid, PS_WAIT_EXIT, PS_WAIT_STARTED, start_process(), proc_t::state, STATE_DEVICE_STOPPING, STATE_IDLE, STATE_RUNNING, STATE_STARTING, sys_get_device_state(), and WARNPRINTF.

Referenced by check_respawn(), on_startup_completed_timeout(), process_add(), process_startup_complete(), and start_process().

{
    LOGPRINTF("entry");
    
    proc_t *cur_proc = NULL;
    GSList *proc_ptr = g_proclist;
    gboolean is_ready = TRUE;
    
    if (sys_get_device_state() == STATE_DEVICE_STOPPING)
    {
        WARNPRINTF("device is shutting down, process not started");
        return;
    }
    
    while (proc_ptr)
    {
        cur_proc = (proc_t *) proc_ptr->data;
        
        if (((cur_proc->state == STATE_STARTING) && (cur_proc->flags & PS_WAIT_STARTED)) ||
            ((cur_proc->state == STATE_RUNNING) && (cur_proc->flags & PS_WAIT_EXIT)))
        {
            LOGPRINTF("wait for process %d to complete", cur_proc->pid);
            is_ready = FALSE;
            break;
        }
            
        proc_ptr = proc_ptr->next;
    }
    
    if (is_ready)
    {
        proc_ptr = g_proclist;
        
        while (proc_ptr)
        {
            cur_proc = (proc_t *) proc_ptr->data;
            
            if (cur_proc->state == STATE_IDLE)
            {
                LOGPRINTF("start next process: %s", cur_proc->command);
                start_process(cur_proc);
                return;
            }
                
            proc_ptr = proc_ptr->next;
        }
    }
    return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static proc_t * create_process	(	const char *	command,
		const char *	working_dir,
		GCallback	startup_callback,
		GCallback	exit_callback,
		gint	flags
	)			[static]

Definition at line 326 of file process.c.

References proc_t::command, ERRORPRINTF, proc_t::exit_callback, proc_t::flags, g_proclist, proc_t::ipc_service, proc_t::is_multidoc, LOGPRINTF, proc_t::pid, proc_t::startup_callback, proc_t::state, STATE_IDLE, and proc_t::working_dir.

Referenced by process_add(), and process_start().

{
    LOGPRINTF("entry: %s, %d", command, flags);
    
    proc_t *proc = g_new0 (proc_t, 1);
    if (!proc)
    {
        ERRORPRINTF("mem alloc failed");
        return NULL;
    }
    
    // init defaults
    //
    proc->command           = g_strdup(command);
    proc->working_dir       = NULL;
    if (working_dir)
    {
        proc->working_dir   = g_strdup(working_dir);
    }
    proc->ipc_service       = NULL;
    proc->pid               = 0;
    proc->is_multidoc       = FALSE;
    proc->flags             = flags;
    proc->startup_callback  = startup_callback;
    proc->exit_callback     = exit_callback;
    proc->state             = STATE_IDLE;
    
    // add to list
    g_proclist = g_slist_append(g_proclist, proc);
    
    return proc;
}

Here is the caller graph for this function:

static void destroy_process

(

proc_t *

proc

)

[static]

Definition at line 360 of file process.c.

References proc_t::command, g_proclist, proc_t::ipc_service, and proc_t::working_dir.

Referenced by check_respawn(), and process_start().

{
    // remove from list
    g_proclist = g_slist_remove(g_proclist, proc);

    // free memory
    g_free(proc->command);
    g_free(proc->ipc_service);
    g_free(proc->working_dir);
    g_free(proc);
    proc = NULL;
}    

Here is the caller graph for this function:

static void on_process_exit	(	GPid	pid,
		gint	status,
		gpointer	data
	)			[static]

Definition at line 374 of file process.c.

References busy_reset_pid(), check_respawn(), proc_t::command, conn_disconnect(), display_cleanup_pid(), erkeyb_client_hide(), ERRORPRINTF, proc_t::exit_callback, proc_t::flags, g_process_pending_source, ipc_refresh_ctb(), proc_t::ipc_service, ipc_show_message(), LOGPRINTF, on_reply_error(), proc_t::pid, PS_RESPAWN, proc_t::state, STATE_CARD_INDEXING, STATE_STARTING, sys_get_card(), task_cleanup_pid(), and WARNPRINTF.

Referenced by start_process().

{
    LOGPRINTF("entry");
    
#if (WARNING_ON)
    // see signal.h and man 3 waitpid
    const char *status_text[]  = { "", "SIGHUP", "SIGINT", "SIGQUIT", "SIGILL",
                                   "SIGTRAP", "SIGABRT", "SIGBUS", "SIGFPE",
                                   "SIGKILL", "SIGUSR1", "SIGSEGV", "SIGUSR2", "SIGPIPE",
                                   "SIGALRM", "SIGTERM", "SIGSTKFLT", "SIGCHLD", 0};
    if (WIFSIGNALED(status))
   {
        WARNPRINTF("pid %d was terminated by signal %d [%s]", pid, WTERMSIG(status), 
            WTERMSIG(status) <= 17 ? status_text[WTERMSIG(status)] : "");
    }
    else if (WIFEXITED(status))
    {
        WARNPRINTF("pid %d has exited with status %d", pid, WEXITSTATUS(status));
    }
    else
    {
        // it's not likely this will ever be reached, but just to be sure
        WARNPRINTF("pid %d is gone, status %d", pid, status);
    }
#endif

    proc_t *proc = data;
    gboolean try_respawn = TRUE;
    
    g_return_if_fail(proc != NULL);
    g_return_if_fail(proc->pid == pid);
    gchar *proc_app = g_path_get_basename(proc->command);

    if (proc->state == STATE_STARTING)
    {
        // stop pending timeout
        if (g_process_pending_source)
        { 
            g_source_remove(g_process_pending_source);
            g_process_pending_source = 0;
        }
        
        // clear respawn bit
        // when application crashes while starting, it makes 
        // no sense to retry this over and over again.
        proc->flags &= ~(PS_RESPAWN);
        
        ERRORPRINTF("application [%s] exited", proc->command);
    }
    
    // Check if app is adobe-fulfill or downloadmgr
    // and notify ctb. Needed because these apps are Dialogs, so
    // ctb does not get a WindowActivated/Deactivated call
    if (proc_app && 
        ((strcmp(proc_app, "downloadmgr") == 0) || (strcmp(proc_app, "adobe-fulfill") == 0)))
    {
        ipc_refresh_ctb();
    }

    // remove tasks for this process
    task_cleanup_pid(pid);

    // remove busy for this process
    busy_reset_pid(pid);
    
    // remove display info for this process
    display_cleanup_pid(pid);
    
    // remove connection when process died
    if ((status !=0) && proc->ipc_service)
    {
        conn_disconnect(proc->ipc_service);
    }
    
    // call post exit callback
    if (proc->exit_callback)
    {
        (proc->exit_callback)();
    }

    if (((WIFEXITED(status) && WEXITSTATUS(status) == 1) ||
         (WIFSIGNALED(status) && 
         (WTERMSIG(status) == SIGFPE || WTERMSIG(status) == SIGABRT || WTERMSIG(status) == SIGSEGV))) &&
          proc_app)
    {
        // unexpected error ocurred
        if (strcmp(proc_app, "uds") == 0)
        {
            if (sys_get_card() == STATE_CARD_INDEXING)
            {
                // indexer caused UDS to fail, terminate it to prevent more errors
                system("killall mdbindex");
                ipc_show_message("indexerror", on_reply_error, proc);
                // delay respawning UDS until user confirmed error dialog
                try_respawn = FALSE;
            }
            else
            {
                ipc_show_message("udserror", on_reply_error, proc);
                // delay respawning UDS until user confirmed error dialog
                try_respawn = FALSE;
            }
        }
        else if (strcmp(proc_app, "erbrowser") == 0)
        {
            erkeyb_client_hide();
            ipc_show_message("browsererror", NULL, NULL);
        }
    }
    
    if (try_respawn)
    {
        check_respawn(proc);
    }
    g_free(proc_app);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void on_reply_error	(	eripc_context_t *	context,
		const eripc_event_info_t *	info,
		void *	user_data
	)			[static]

Definition at line 687 of file process.c.

References eripc_event_info_t::args, check_respawn(), ERIPC_EVENT_REPLY, ERIPC_TYPE_BOOL, eripc_event_info_t::event_type, LOGPRINTF, and WARNPRINTF.

Referenced by on_process_exit().

{
    LOGPRINTF("entry");
    
    const eripc_arg_t *arg_array = info->args;
    
    if (info->event_type != ERIPC_EVENT_REPLY)
    {
        WARNPRINTF("invalid event: %d", info->event_type);
    }
    else if ((arg_array == NULL) || (arg_array[0].type != ERIPC_TYPE_BOOL))
    {
        WARNPRINTF("invalid arguments in reply");
    }
    else 
    {
        LOGPRINTF("User clicked ok");
        proc_t *proc = user_data;
        check_respawn(proc);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static gboolean on_startup_completed_timeout

(

gpointer

data

)

[static]

Definition at line 527 of file process.c.

References check_start_next(), proc_t::command, g_process_pending_source, LOGPRINTF, proc_t::state, and STATE_RUNNING.

Referenced by start_process().

{
    proc_t *proc = data;
    
    LOGPRINTF("entry");
    LOGPRINTF("timeout waiting for startupComplete (%s), new state STATE_RUNNING", proc->command);
    
    // callback startupComplete not received, assume it is running 
    proc->state = STATE_RUNNING;
    
    // start next process
    check_start_next();
    
    g_process_pending_source = 0;
    
    // stop and destroy this timer
    return FALSE; 
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void post_process_startup	(	proc_t *	proc,
		const char *	application,
		gint	window
	)			[static]

Definition at line 665 of file process.c.

References ipc_send_changed_locale(), ipc_send_volume_mounted_to(), proc_t::ipc_service, LOGPRINTF, MOUNTPOINT_CARD, STATE_CARD_MOUNTED, sys_get_card(), and task_startup_completed().

Referenced by process_startup_complete().

{
    LOGPRINTF("entry");

    // inform tasks of new window
    task_startup_completed(proc, window);

    // report mountpoint when card is available
    if (sys_get_card() == STATE_CARD_MOUNTED)
    {
        ipc_send_volume_mounted_to(proc->ipc_service, MOUNTPOINT_CARD);
    }
    
    // report current language as it may have changed during startup
    const char *locale = g_getenv("LANG");
    if (locale)
    {
        ipc_send_changed_locale(locale);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void print_process_list

(

)

Definition at line 272 of file process.c.

References proc_t::command, g_proclist, proc_t::ipc_service, proc_t::is_multidoc, and proc_t::pid.

Referenced by testing_list_tasks().

{
    GSList *proc_ptr    = g_proclist;

    printf("%s() PROCESS LIST:\n", __func__);
    int i = 0;
    while (proc_ptr)
    {
        proc_t *cur = (proc_t *) proc_ptr->data;
        printf("  [%d] cmd=%s  ipc=%s  multi=%d  pid=%d\n", i,
            cur->command, cur->ipc_service, cur->is_multidoc, cur->pid);

        proc_ptr = proc_ptr->next;
        i++;
    }
}

Here is the caller graph for this function:

gboolean process_activate

(

const char *

application

)

Activate a running process (set to top).

---------------------------------------------------------------------------

Name : process_activate

Parameters:

application

Full path of the application

Returns:

Returns TRUE on success, FALSE on failure

--------------------------------------------------------------------------

Definition at line 149 of file process.c.

References get_application_window(), LOGPRINTF, WARNPRINTF, and window_activate().

Referenced by cb_menu_item_activated(), and process_activate_ctb().

{
    LOGPRINTF("entry");
    
    gboolean result = FALSE;
    Window win_found;
    
    win_found = get_application_window(application);
    
    if (win_found != None)
    {
        window_activate(win_found);
        result = TRUE;
    }
    else
    {
        WARNPRINTF("No window found for: %s", application);
    }

    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

gboolean process_activate_ctb

(

void

)

Activate content browser (set to top).

---------------------------------------------------------------------------

Name : process_activate_ctb

Parameters:

--

Returns:

Returns TRUE on success, FALSE on failure

--------------------------------------------------------------------------

Definition at line 172 of file process.c.

References display_get_active_window(), LOGPRINTF, process_activate(), STATE_DEVICE_STOPPING, and sys_get_device_state().

Referenced by task_activate_by_xid(), task_cleanup_pid(), and task_cleanup_window().

{
    LOGPRINTF("entry");
    
    gboolean retval = TRUE;

    if (sys_get_device_state() == STATE_DEVICE_STOPPING)
    {
        // don't activate CTB when device is shutting down
        return FALSE;
    }
    
    // set to top when not already active
    gchar *app_active = display_get_active_window();
    if (app_active && strcmp(app_active, "ctb") != 0 )
    {
        retval = process_activate("ctb");
    }
    
    return retval;
}

Here is the call graph for this function:

Here is the caller graph for this function:

gboolean process_add	(	const char *	command,
		const char *	working_dir,
		GCallback	startup_callback,
		GCallback	exit_callback,
		gint	flags
	)

Add a process to the queue. The queue is served First In First Out.

---------------------------------------------------------------------------

Name : process_add

Parameters:

	application	Full path of the application
	working_dir	Working directory, or NULL to inherit parent's
	startup_callback	Callback function when received startupCopmlete, or NULL
	exit_callback	Callback function when processes was terminated, or NULL
	flags	Bit field PS_WAIT_STARTED | PS_WAIT_EXIT | PS_RESPAWN

Returns:

Returns TRUE on success, FALSE on failure

--------------------------------------------------------------------------

Definition at line 97 of file process.c.

References check_start_next(), create_process(), and LOGPRINTF.

Referenced by main(), start_phase_2(), and start_phase_3().

{
    LOGPRINTF("entry: %s, %d", command, flags);
    
    proc_t *proc = create_process(command, working_dir, startup_callback, exit_callback, flags);
    if (proc == NULL)
    {
        return FALSE;
    }
    
    check_start_next();
    
    return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

proc_t* process_get_by_name

(

const char *

application

)

Definition at line 290 of file process.c.

References proc_t::command, g_proclist, and LOGPRINTF.

Referenced by parse_wm_messages(), and task_start().

{
    LOGPRINTF("entry [%s]", application);
    
    GSList *proc_ptr    = g_proclist;

    while (proc_ptr)
    {
        proc_t *cur_proc = (proc_t *) proc_ptr->data;

        gint   argc         = 0;
        char   **argv_ptr   = NULL;
        if (g_shell_parse_argv(cur_proc->command, &argc, &argv_ptr, NULL))
        {
            gchar  *proc_app = g_path_get_basename(argv_ptr[0]);
//            LOGPRINTF("check [%s]", proc_app);
            if (application && proc_app && (strcmp(proc_app, application) == 0))
            {
//                LOGPRINTF("match [%s] pid [%d]", proc_app, cur_proc->pid);
                g_free(proc_app);
                return cur_proc;
            }
            g_free(proc_app);
            g_strfreev(argv_ptr);
        }
        proc_ptr = proc_ptr->next;
    }
    
    return NULL;
}

Here is the caller graph for this function:

proc_t* process_get_by_pid

(

GPid

pid

)

Definition at line 248 of file process.c.

References proc_t::command, g_proclist, proc_t::ipc_service, LOGPRINTF, and proc_t::pid.

Referenced by process_startup_complete(), and task_add().

{
    LOGPRINTF("entry  pid [%d]", pid);
    
    GSList *proc_ptr = g_proclist;
    proc_t *cur_proc = NULL;
    
    while (proc_ptr)
    {
        cur_proc = (proc_t *) proc_ptr->data;
        
        if (cur_proc->pid == pid)
        {
            LOGPRINTF("found [%p] command [%s] ipc service [%s]", cur_proc, cur_proc->command, cur_proc->ipc_service);
            return cur_proc;
        }
            
        proc_ptr = proc_ptr->next;
    }
    
    return NULL;
}

Here is the caller graph for this function:

proc_t* process_start	(	const char *	command,
		const char *	working_dir,
		GCallback	startup_callback,
		GCallback	exit_callback,
		gint	flags
	)

Start a process without queuing.

---------------------------------------------------------------------------

Name : process_start

Parameters:

	application	Full path of the application
	working_dir	Working directory, or NULL to inherit parent's
	startup_callback	Callback function when received startupCopmlete, or NULL
	exit_callback	Callback function when processes was terminated, or NULL
	flags	Bit field PS_WAIT_STARTED | PS_RESPAWN

Returns:

Process created and started, or NULL on error.

--------------------------------------------------------------------------

Definition at line 113 of file process.c.

References create_process(), destroy_process(), LOGPRINTF, and start_process().

Referenced by child_new(), and start_medium().

{
    LOGPRINTF("entry: %s, %d", command, flags);
    
    gboolean result = FALSE;
    
    proc_t *proc = create_process(command, working_dir, startup_callback, exit_callback, flags);
    if (proc == NULL)
    {
        return NULL;
    }
    
    result = start_process(proc);
    if (result == FALSE)
    {
        LOGPRINTF("failed to spawn, remove from list");
        destroy_process(proc);
        proc = NULL;
    }
    
    return proc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

gboolean process_startup_complete	(	const char *	application,
		gint	pid,
		gboolean	is_multidoc,
		const char *	ipc_service,
		gint	window
	)

Call when application has finished starting.

---------------------------------------------------------------------------

Name : process_startup_complete

Parameters:

	application	Full path of the application
	pid	Process ud
	is_multidoc	TRUE if multiple documents are supported, FALSE otherwise
	ipc_service	IPC service
	window	Window id

Returns:

Returns TRUE on success, FALSE on failure

--------------------------------------------------------------------------

Definition at line 195 of file process.c.

References check_start_next(), display_set_ctb_window(), g_process_pending_source, proc_t::ipc_service, proc_t::is_multidoc, LOGPRINTF, post_process_startup(), process_get_by_pid(), proc_t::startup_callback, proc_t::state, STATE_RUNNING, STATE_STARTING, and WARNPRINTF.

Referenced by cb_startup_complete().

{
    LOGPRINTF("entry");
    gboolean retval = FALSE;
    
    // find proc by pid
    proc_t *proc = process_get_by_pid(pid);

    if (proc == NULL)
    {
        WARNPRINTF("%s (pid %d) is not started sysd", application, pid);
    }
    else if (proc->state != STATE_STARTING)
    {
        WARNPRINTF("unexpected startupComplete received from %s (pid %d), state [%d]", application, pid, proc->state);
    }
    else
    {
        // stop pending timeout
        if (g_process_pending_source)
        { 
            g_source_remove(g_process_pending_source);
            g_process_pending_source = 0;
        }

        LOGPRINTF("received startupComplete from %s (pid %d, window %d), new state STATE_RUNNING", application, pid, window);
        if (strcmp(application, "ctb") == 0) {
            display_set_ctb_window(window);
        }
        
        // update process info
        proc->state = STATE_RUNNING;
        proc->is_multidoc = is_multidoc;
        proc->ipc_service = g_strdup(ipc_service);

        // do post startup actions
        post_process_startup(proc, application, window);
        
        // call post startup callback
        if (proc->startup_callback)
        {
            (proc->startup_callback)();
        }

        // start next process
        check_start_next();
        
        retval = TRUE;
    }
    return retval;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void process_stop

(

proc_t *

proc

)

Stop a running process.

---------------------------------------------------------------------------

Name : process_stop

Parameters:

process

The process to be stopped

Returns:

--

--------------------------------------------------------------------------

Definition at line 137 of file process.c.

References proc_t::command, LOGPRINTF, and proc_t::pid.

Referenced by stop_medium().

{
    g_assert(proc);
    LOGPRINTF("entry: %s, %d", proc->command, proc->pid);
    
    if (proc && proc->pid > 0)
    {
        kill(proc->pid, SIGTERM);
    }
}

Here is the caller graph for this function:

static gboolean start_process

(

proc_t *

proc

)

[static]

Definition at line 598 of file process.c.

References check_start_next(), proc_t::command, proc_t::flags, g_process_pending_source, LOGPRINTF, on_process_exit(), on_startup_completed_timeout(), proc_t::pid, PS_WAIT_EXIT, PS_WAIT_STARTED, proc_t::state, STATE_RUNNING, STATE_STARTING, TIMEOUT_STARTUP_COMPLETED, WARNPRINTF, and proc_t::working_dir.

Referenced by check_start_next(), and process_start().

{
    LOGPRINTF("entry");
    
    GPid child_pid   = 0;
    gint argc        = 0;
    char **argv_ptr  = NULL;
    gboolean retval  = FALSE;
    GError *error    = NULL;

    LOGPRINTF("Starting: %s", proc->command);

    retval = g_shell_parse_argv(proc->command, &argc, &argv_ptr, &error);
    if (error)
    {
        WARNPRINTF("Error parsing command '%s' failed with error: %s", proc->command, error->message);
        g_error_free(error);
        return FALSE;
    }
    
    retval = g_spawn_async(proc->working_dir, argv_ptr, NULL, G_SPAWN_DO_NOT_REAP_CHILD, NULL, NULL, &child_pid, &error);
    if (error)
    {
        WARNPRINTF("Execution of '%s' failed with error: %s", proc->command, error->message);
        g_error_free(error);
        if (argv_ptr) g_strfreev(argv_ptr);
        return FALSE;
    }
    
    if (proc->flags & PS_WAIT_STARTED)
    {
        if (g_process_pending_source)
        { 
            g_source_remove(g_process_pending_source);
            WARNPRINTF("A process is started while a previous one was still pending. Previous pending timer stopped.");
        }
        
        // set maximum time to wait for startupComplete
        g_process_pending_source = g_timeout_add_seconds(TIMEOUT_STARTUP_COMPLETED, on_startup_completed_timeout, proc);
        
        // update process entry
        LOGPRINTF("wait for startupComplete (pid %d), new state STATE_STARTING", child_pid);
        proc->state = STATE_STARTING;
        proc->pid = child_pid;
    }
    else
    {
        // update process entry
        LOGPRINTF("don't wait for startup, new state STATE_RUNNING");
        proc->state = STATE_RUNNING;
        proc->pid = child_pid;
        
        if (!(proc->flags & PS_WAIT_EXIT))
        {
            // start next process
            check_start_next();
        }
    }
    
    // watch child lifetime
    g_child_watch_add(child_pid, on_process_exit, proc);
    
    g_strfreev(argv_ptr);
    return TRUE;    
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

Variable Documentation

gint g_process_pending_source = 0 [static]

Definition at line 75 of file process.c.

Referenced by on_process_exit(), on_startup_completed_timeout(), process_startup_complete(), and start_process().

GSList* g_proclist = NULL [static]

Definition at line 74 of file process.c.

Referenced by check_start_next(), create_process(), destroy_process(), print_process_list(), process_get_by_name(), and process_get_by_pid().

const gint TIMEOUT_STARTUP_COMPLETED = 30 [static]

Copyright (C) 2008 iRex Technologies B.V. All rights reserved.

Definition at line 67 of file process.c.

Referenced by start_process().