process.c

Go to the documentation of this file.

/*
 * File Name: process.c
 */

/*
 * This file is part of sysd.
 *
 * sysd 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.
 *
 * sysd 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, see <http://www.gnu.org/licenses/>.
 */

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

//----------------------------------------------------------------------------
// Include Files
//----------------------------------------------------------------------------

// system include files, between < >
#include <glib.h>
#include <glib.h>
#include <signal.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h> 
#include <unistd.h>

#include <hal/libhal.h>

// ereader include files, between < >
#include <liberkeyb/erkeyb-client.h>

// local include files, between " "
#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"


//----------------------------------------------------------------------------
// Type Declarations
//----------------------------------------------------------------------------


//----------------------------------------------------------------------------
// Constants
//----------------------------------------------------------------------------

static const gint TIMEOUT_STARTUP_COMPLETED = 30;


//----------------------------------------------------------------------------
// Static Variables
//----------------------------------------------------------------------------

static GSList   *g_proclist = NULL;     // element is proc_t*
static gint     g_process_pending_source = 0;


//============================================================================
// Local Function Definitions
//============================================================================

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);


//============================================================================
// Functions Implementation
//============================================================================

gboolean process_add(const char* command, const char* working_dir, GCallback startup_callback, GCallback exit_callback, gint flags)
{
    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;
}


proc_t *process_start(const char* command, const char* working_dir, GCallback startup_callback, GCallback exit_callback, gint flags)
{
    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;
}


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


gboolean process_activate(const char* application)
{
    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;
}


gboolean process_activate_ctb()
{
    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;
}


gboolean process_startup_complete(const char *application, gint pid, gboolean is_multidoc, const char *ipc_service, gint window)
{
    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;
}


proc_t *process_get_by_pid(GPid pid)
{
    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;
}

#if (TESTING_ON)
void print_process_list()
{
    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++;
    }
}
#endif

proc_t *process_get_by_name(const char *application)
{
    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;
}


//============================================================================
// Local Function Implementation
//============================================================================

static proc_t *create_process(const char* command, const char* working_dir, GCallback startup_callback, GCallback exit_callback, gint flags)
{
    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;
}


static void destroy_process(proc_t *proc)
{
    // 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;
}    


static void on_process_exit(GPid pid, gint status, gpointer data)
{
    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);
}


static void check_respawn(proc_t *proc)
{
    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();
    }
}


static gboolean on_startup_completed_timeout(gpointer data)
{
    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; 
}


static void check_start_next()
{
    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;
}


static gboolean start_process(proc_t *proc)
{
    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;    
}


static void post_process_startup(proc_t *proc, const char *application, gint window)
{
    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);
    }
}


static void on_reply_error(eripc_context_t *context,
                           const eripc_event_info_t *info,
                           void *user_data)
{
    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);
    }
}