first commit

1 files changed, 567 insertions, 0 deletions

diff --git a/src/gs-job.c.orig b/src/gs-job.c.orig
new file mode 100644
index 0000000..896addc
--- /dev/null
+++ b/src/gs-job.c.orig
@@ -0,0 +1,567 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
+ *
+ * Copyright (C) 2004-2006 William Jon McCann <[email protected]>
+ *
+ * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * Authors: William Jon McCann <[email protected]>
+ *
+ */
+
+#include "config.h"
+
+#include <stdlib.h>
+#include <unistd.h>
+#include <signal.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <errno.h>
+#include <string.h>
+
+#if defined(HAVE_SETPRIORITY) && defined(PRIO_PROCESS)
+#include <sys/resource.h>
+#endif
+
+#include <glib.h>
+#include <glib/gstdio.h>
+#include <gdk/gdk.h>
+#include <gdk/gdkx.h>
+
+#include "gs-debug.h"
+#include "gs-job.h"
+
+#include "subprocs.h"
+
+static void gs_job_class_init (GSJobClass *klass);
+static void gs_job_init       (GSJob      *job);
+static void gs_job_finalize   (GObject    *object);
+
+#define GS_JOB_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GS_TYPE_JOB, GSJobPrivate))
+
+typedef enum
+{
+    GS_JOB_INVALID,
+    GS_JOB_RUNNING,
+    GS_JOB_STOPPED,
+    GS_JOB_KILLED,
+    GS_JOB_DEAD
+} GSJobStatus;
+
+struct GSJobPrivate
+{
+    GtkWidget      *widget;
+
+    GSJobStatus     status;
+    gint            pid;
+    guint           watch_id;
+
+    char           *command;
+};
+
+G_DEFINE_TYPE (GSJob, gs_job, G_TYPE_OBJECT)
+
+static char *
+widget_get_id_string (GtkWidget *widget)
+{
+    char *id = NULL;
+
+    g_return_val_if_fail (widget != NULL, NULL);
+
+    id = g_strdup_printf ("0x%X",
+                          (guint32)GDK_WINDOW_XID (widget->window));
+    return id;
+}
+
+static void
+gs_job_class_init (GSJobClass *klass)
+{
+    GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+    object_class->finalize  = gs_job_finalize;
+
+    g_type_class_add_private (klass, sizeof (GSJobPrivate));
+}
+
+static void
+gs_job_init (GSJob *job)
+{
+    job->priv = GS_JOB_GET_PRIVATE (job);
+}
+
+/* adapted from gspawn.c */
+static int
+wait_on_child (int pid)
+{
+    int status;
+
+wait_again:
+    if (waitpid (pid, &status, 0) < 0)
+    {
+        if (errno == EINTR)
+        {
+            goto wait_again;
+        }
+        else if (errno == ECHILD)
+        {
+            ; /* do nothing, child already reaped */
+        }
+        else
+        {
+            gs_debug ("waitpid () should not fail in 'GSJob'");
+        }
+    }
+
+    return status;
+}
+
+static void
+gs_job_died (GSJob *job)
+{
+    if (job->priv->pid > 0)
+    {
+        int exit_status;
+
+        gs_debug ("Waiting on process %d", job->priv->pid);
+        exit_status = wait_on_child (job->priv->pid);
+
+        job->priv->status = GS_JOB_DEAD;
+
+        if (WIFEXITED (exit_status) && (WEXITSTATUS (exit_status) != 0))
+        {
+            gs_debug ("Wait on child process failed");
+        }
+        else
+        {
+            /* exited normally */
+        }
+    }
+    g_spawn_close_pid (job->priv->pid);
+    job->priv->pid = 0;
+
+    gs_debug ("Job died");
+}
+
+static void
+gs_job_finalize (GObject *object)
+{
+    GSJob *job;
+
+    g_return_if_fail (object != NULL);
+    g_return_if_fail (GS_IS_JOB (object));
+
+    job = GS_JOB (object);
+
+    g_return_if_fail (job->priv != NULL);
+
+    if (job->priv->pid > 0)
+    {
+        signal_pid (job->priv->pid, SIGTERM);
+        gs_job_died (job);
+    }
+
+    g_free (job->priv->command);
+    job->priv->command = NULL;
+
+    G_OBJECT_CLASS (gs_job_parent_class)->finalize (object);
+}
+
+void
+gs_job_set_widget  (GSJob     *job,
+                    GtkWidget *widget)
+{
+    g_return_if_fail (job != NULL);
+    g_return_if_fail (GS_IS_JOB (job));
+
+    if (widget != job->priv->widget)
+    {
+        job->priv->widget = widget;
+
+        /* restart job */
+        if (gs_job_is_running (job))
+        {
+            gs_job_stop (job);
+            gs_job_start (job);
+        }
+    }
+}
+
+gboolean
+gs_job_set_command  (GSJob      *job,
+                     const char *command)
+{
+    g_return_val_if_fail (GS_IS_JOB (job), FALSE);
+
+    gs_debug ("Setting command for job: '%s'",
+              command != NULL ? command : "NULL");
+
+    g_free (job->priv->command);
+    job->priv->command = g_strdup (command);
+
+    return TRUE;
+}
+
+GSJob *
+gs_job_new (void)
+{
+    GObject *job;
+
+    job = g_object_new (GS_TYPE_JOB, NULL);
+
+    return GS_JOB (job);
+}
+
+GSJob *
+gs_job_new_for_widget (GtkWidget  *widget)
+{
+    GObject *job;
+
+    job = g_object_new (GS_TYPE_JOB, NULL);
+
+    gs_job_set_widget (GS_JOB (job), widget);
+
+    return GS_JOB (job);
+}
+
+static void
+nice_process (int pid,
+              int nice_level)
+{
+    g_return_if_fail (pid > 0);
+
+    if (nice_level == 0)
+    {
+        return;
+    }
+
+#if defined(HAVE_SETPRIORITY) && defined(PRIO_PROCESS)
+    gs_debug ("Setting child process priority to: %d", nice_level);
+    if (setpriority (PRIO_PROCESS, pid, nice_level) != 0)
+    {
+        gs_debug ("setpriority(PRIO_PROCESS, %lu, %d) failed",
+                  (unsigned long) pid, nice_level);
+    }
+#else
+    gs_debug ("don't know how to change process priority on this system.");
+#endif
+}
+
+static GPtrArray *
+get_env_vars (GtkWidget *widget)
+{
+    GPtrArray *env;
+    char      *str;
+    int        i;
+    static const char *allowed_env_vars [] =
+    {
+        "PATH",
+        "SESSION_MANAGER",
+        "XAUTHORITY",
+        "XAUTHLOCALHOSTNAME",
+        "LANG",
+        "LANGUAGE",
+        "DBUS_SESSION_BUS_ADDRESS"
+    };
+
+    env = g_ptr_array_new ();
+
+    str = gdk_screen_make_display_name (gtk_widget_get_screen (widget));
+    g_ptr_array_add (env, g_strdup_printf ("DISPLAY=%s", str));
+    g_free (str);
+
+    g_ptr_array_add (env, g_strdup_printf ("HOME=%s",
+                                           g_get_home_dir ()));
+
+    for (i = 0; i < G_N_ELEMENTS (allowed_env_vars); i++)
+    {
+        const char *var;
+        const char *val;
+        var = allowed_env_vars [i];
+        val = g_getenv (var);
+        if (val != NULL)
+        {
+            g_ptr_array_add (env, g_strdup_printf ("%s=%s",
+                                                   var,
+                                                   val));
+        }
+    }
+
+    str = widget_get_id_string (widget);
+    g_ptr_array_add (env, g_strdup_printf ("XSCREENSAVER_WINDOW=%s", str));
+    g_free (str);
+
+    g_ptr_array_add (env, NULL);
+
+    return env;
+}
+
+static gboolean
+spawn_on_widget (GtkWidget  *widget,
+                 const char *command,
+                 int        *pid,
+                 GIOFunc     watch_func,
+                 gpointer    user_data,
+                 guint      *watch_id)
+{
+    char      **argv;
+    GPtrArray  *env;
+    gboolean    result;
+    GIOChannel *channel;
+    GError     *error = NULL;
+    int         standard_error;
+    int         child_pid;
+    int         id;
+    int         i;
+
+    if (command == NULL)
+    {
+        return FALSE;
+    }
+
+    if (! g_shell_parse_argv (command, NULL, &argv, &error))
+    {
+        gs_debug ("Could not parse command: %s", error->message);
+        g_error_free (error);
+        return FALSE;
+    }
+
+    env = get_env_vars (widget);
+
+    error = NULL;
+    result = gdk_spawn_on_screen_with_pipes (gtk_widget_get_screen (widget),
+             NULL,
+             argv,
+             (char **)env->pdata,
+             G_SPAWN_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD,
+             NULL,
+             NULL,
+             &child_pid,
+             NULL,
+             NULL,
+             &standard_error,
+             &error);
+    for (i = 0; i < env->len; i++)
+    {
+        g_free (g_ptr_array_index (env, i));
+    }
+    g_ptr_array_free (env, TRUE);
+
+    if (! result)
+    {
+        gs_debug ("Could not start command '%s': %s", command, error->message);
+        g_error_free (error);
+        g_strfreev (argv);
+        return FALSE;
+    }
+
+    g_strfreev (argv);
+
+    nice_process (child_pid, 10);
+
+    if (pid != NULL)
+    {
+        *pid = child_pid;
+    }
+    else
+    {
+        g_spawn_close_pid (child_pid);
+    }
+
+    channel = g_io_channel_unix_new (standard_error);
+    g_io_channel_set_close_on_unref (channel, TRUE);
+    g_io_channel_set_flags (channel,
+                            g_io_channel_get_flags (channel) | G_IO_FLAG_NONBLOCK,
+                            NULL);
+    id = g_io_add_watch (channel,
+                         G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
+                         watch_func,
+                         user_data);
+    if (watch_id != NULL)
+    {
+        *watch_id = id;
+    }
+
+    g_io_channel_unref (channel);
+
+    return result;
+}
+
+static gboolean
+command_watch (GIOChannel   *source,
+               GIOCondition  condition,
+               GSJob        *job)
+{
+    GIOStatus status;
+    GError   *error = NULL;
+    gboolean  done  = FALSE;
+
+    g_return_val_if_fail (job != NULL, FALSE);
+
+    if (condition & G_IO_IN)
+    {
+        char *str;
+
+        status = g_io_channel_read_line (source, &str, NULL, NULL, &error);
+
+        if (status == G_IO_STATUS_NORMAL)
+        {
+            gs_debug ("command output: %s", str);
+
+        }
+        else if (status == G_IO_STATUS_EOF)
+        {
+            done = TRUE;
+
+        }
+        else if (error != NULL)
+        {
+            gs_debug ("command error: %s", error->message);
+            g_error_free (error);
+        }
+
+        g_free (str);
+    }
+    else if (condition & G_IO_HUP)
+    {
+        done = TRUE;
+    }
+
+    if (done)
+    {
+        gs_job_died (job);
+
+        job->priv->watch_id = 0;
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+gboolean
+gs_job_is_running (GSJob *job)
+{
+    gboolean running;
+
+    g_return_val_if_fail (GS_IS_JOB (job), FALSE);
+
+    running = (job->priv->pid > 0);
+
+    return running;
+}
+
+gboolean
+gs_job_start (GSJob *job)
+{
+    gboolean result;
+
+    g_return_val_if_fail (job != NULL, FALSE);
+    g_return_val_if_fail (GS_IS_JOB (job), FALSE);
+
+    gs_debug ("starting job");
+
+    if (job->priv->pid != 0)
+    {
+        gs_debug ("Cannot restart active job.");
+        return FALSE;
+    }
+
+    if (job->priv->widget == NULL)
+    {
+        gs_debug ("Could not start job: screensaver window is not set.");
+        return FALSE;
+    }
+
+    if (job->priv->command == NULL)
+    {
+        /* no warning here because a NULL command is interpreted
+           as a no-op job */
+        gs_debug ("No command set for job.");
+        return FALSE;
+    }
+
+    result = spawn_on_widget (job->priv->widget,
+                              job->priv->command,
+                              &job->priv->pid,
+                              (GIOFunc)command_watch,
+                              job,
+                              &job->priv->watch_id);
+
+    if (result)
+    {
+        job->priv->status = GS_JOB_RUNNING;
+    }
+
+    return result;
+}
+
+static void
+remove_command_watch (GSJob *job)
+{
+    if (job->priv->watch_id != 0)
+    {
+        g_source_remove (job->priv->watch_id);
+        job->priv->watch_id = 0;
+    }
+}
+
+gboolean
+gs_job_stop (GSJob *job)
+{
+    g_return_val_if_fail (job != NULL, FALSE);
+    g_return_val_if_fail (GS_IS_JOB (job), FALSE);
+
+    gs_debug ("stopping job");
+
+    if (job->priv->pid == 0)
+    {
+        gs_debug ("Could not stop job: pid not defined");
+        return FALSE;
+    }
+
+    if (job->priv->status == GS_JOB_STOPPED)
+    {
+        gs_job_suspend (job, FALSE);
+    }
+
+    remove_command_watch (job);
+
+    signal_pid (job->priv->pid, SIGTERM);
+
+    job->priv->status = GS_JOB_KILLED;
+
+    gs_job_died (job);
+
+    return TRUE;
+}
+
+gboolean
+gs_job_suspend (GSJob   *job,
+                gboolean suspend)
+{
+    g_return_val_if_fail (job != NULL, FALSE);
+    g_return_val_if_fail (GS_IS_JOB (job), FALSE);
+
+    gs_debug ("suspending job");
+
+    if (job->priv->pid == 0)
+    {
+        return FALSE;
+    }
+
+    signal_pid (job->priv->pid, (suspend ? SIGSTOP : SIGCONT));
+
+    job->priv->status = (suspend ? GS_JOB_STOPPED : GS_JOB_RUNNING);
+
+    return TRUE;
+}