1 files changed, 1028 insertions, 0 deletions
diff --git a/src/fr-process.c b/src/fr-process.c
new file mode 100644
index 0000000..4750f59
--- /dev/null
+++ b/src/fr-process.c
@@ -0,0 +1,1028 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+
+/*
+ * File-Roller
+ *
+ * Copyright (C) 2001, 2003, 2008 Free Software Foundation, Inc.
+ *
+ * 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 Street #330, Boston, MA 02111-1307, USA.
+ */
+
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <signal.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <unistd.h>
+#include <glib.h>
+#include "fr-process.h"
+#include "fr-marshal.h"
+#include "glib-utils.h"
+
+#define REFRESH_RATE 20
+#define BUFFER_SIZE 16384
+
+enum {
+ START,
+ DONE,
+ STICKY_ONLY,
+ LAST_SIGNAL
+};
+
+static GObjectClass *parent_class;
+static guint fr_process_signals[LAST_SIGNAL] = { 0 };
+
+static void fr_process_class_init (FrProcessClass *class);
+static void fr_process_init (FrProcess *process);
+static void fr_process_finalize (GObject *object);
+
+
+typedef struct {
+ GList *args; /* command to execute */
+ char *dir; /* working directory */
+ guint sticky : 1; /* whether the command must be
+ * executed even if a previous
+ * command has failed. */
+ guint ignore_error : 1; /* whether to continue to execute
+ * other commands if this command
+ * fails. */
+ ContinueFunc continue_func;
+ gpointer continue_data;
+ ProcFunc begin_func;
+ gpointer begin_data;
+ ProcFunc end_func;
+ gpointer end_data;
+} FrCommandInfo;
+
+
+static FrCommandInfo *
+fr_command_info_new (void)
+{
+ FrCommandInfo *info;
+
+ info = g_new0 (FrCommandInfo, 1);
+ info->args = NULL;
+ info->dir = NULL;
+ info->sticky = FALSE;
+ info->ignore_error = FALSE;
+
+ return info;
+}
+
+
+static void
+fr_command_info_free (FrCommandInfo *info)
+{
+ if (info == NULL)
+ return;
+
+ if (info->args != NULL) {
+ g_list_foreach (info->args, (GFunc) g_free, NULL);
+ g_list_free (info->args);
+ info->args = NULL;
+ }
+
+ if (info->dir != NULL) {
+ g_free (info->dir);
+ info->dir = NULL;
+ }
+
+ g_free (info);
+}
+
+
+static void
+fr_channel_data_init (FrChannelData *channel)
+{
+ channel->source = NULL;
+ channel->raw = NULL;
+ channel->status = G_IO_STATUS_NORMAL;
+ channel->error = NULL;
+}
+
+
+static void
+fr_channel_data_close_source (FrChannelData *channel)
+{
+ if (channel->source != NULL) {
+ g_io_channel_shutdown (channel->source, FALSE, NULL);
+ g_io_channel_unref (channel->source);
+ channel->source = NULL;
+ }
+}
+
+
+static GIOStatus
+fr_channel_data_read (FrChannelData *channel)
+{
+ char *line;
+ gsize length;
+ gsize terminator_pos;
+
+ channel->status = G_IO_STATUS_NORMAL;
+ g_clear_error (&channel->error);
+
+ while ((channel->status = g_io_channel_read_line (channel->source,
+ &line,
+ &length,
+ &terminator_pos,
+ &channel->error)) == G_IO_STATUS_NORMAL)
+ {
+ line[terminator_pos] = 0;
+ channel->raw = g_list_prepend (channel->raw, line);
+ if (channel->line_func != NULL)
+ (*channel->line_func) (line, channel->line_data);
+ }
+
+ return channel->status;
+}
+
+
+static GIOStatus
+fr_channel_data_flush (FrChannelData *channel)
+{
+ GIOStatus status;
+
+ while (((status = fr_channel_data_read (channel)) != G_IO_STATUS_ERROR) && (status != G_IO_STATUS_EOF))
+ /* void */;
+ fr_channel_data_close_source (channel);
+
+ return status;
+}
+
+
+static void
+fr_channel_data_reset (FrChannelData *channel)
+{
+ fr_channel_data_close_source (channel);
+
+ if (channel->raw != NULL) {
+ g_list_foreach (channel->raw, (GFunc) g_free, NULL);
+ g_list_free (channel->raw);
+ channel->raw = NULL;
+ }
+}
+
+
+static void
+fr_channel_data_free (FrChannelData *channel)
+{
+ fr_channel_data_reset (channel);
+}
+
+
+static void
+fr_channel_data_set_fd (FrChannelData *channel,
+ int fd,
+ const char *charset)
+{
+ fr_channel_data_reset (channel);
+
+ channel->source = g_io_channel_unix_new (fd);
+ g_io_channel_set_flags (channel->source, G_IO_FLAG_NONBLOCK, NULL);
+ g_io_channel_set_buffer_size (channel->source, BUFFER_SIZE);
+ if (charset != NULL)
+ g_io_channel_set_encoding (channel->source, charset, NULL);
+}
+
+
+const char *try_charsets[] = { "UTF-8", "ISO-8859-1", "WINDOW-1252" };
+int n_charsets = G_N_ELEMENTS (try_charsets);
+
+
+struct _FrProcessPrivate {
+ GPtrArray *comm; /* FrCommandInfo elements. */
+ gint n_comm; /* total number of commands */
+ gint current_comm; /* currenlty editing command. */
+
+ GPid command_pid;
+ guint check_timeout;
+
+ FrProcError first_error;
+
+ gboolean running;
+ gboolean stopping;
+ gint current_command;
+ gint error_command; /* command that coused an error. */
+
+ gboolean use_standard_locale;
+ gboolean sticky_only; /* whether to execute only sticky
+ * commands. */
+ int current_charset;
+};
+
+
+GType
+fr_process_get_type (void)
+{
+ static GType type = 0;
+
+ if (! type) {
+ GTypeInfo type_info = {
+ sizeof (FrProcessClass),
+ NULL,
+ NULL,
+ (GClassInitFunc) fr_process_class_init,
+ NULL,
+ NULL,
+ sizeof (FrProcess),
+ 0,
+ (GInstanceInitFunc) fr_process_init
+ };
+
+ type = g_type_register_static (G_TYPE_OBJECT,
+ "FRProcess",
+ &type_info,
+ 0);
+ }
+
+ return type;
+}
+
+
+static void
+fr_process_class_init (FrProcessClass *class)
+{
+ GObjectClass *gobject_class = G_OBJECT_CLASS (class);
+
+ parent_class = g_type_class_peek_parent (class);
+
+ fr_process_signals[START] =
+ g_signal_new ("start",
+ G_TYPE_FROM_CLASS (class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (FrProcessClass, start),
+ NULL, NULL,
+ fr_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
+ fr_process_signals[DONE] =
+ g_signal_new ("done",
+ G_TYPE_FROM_CLASS (class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (FrProcessClass, done),
+ NULL, NULL,
+ fr_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
+ fr_process_signals[STICKY_ONLY] =
+ g_signal_new ("sticky_only",
+ G_TYPE_FROM_CLASS (class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (FrProcessClass, sticky_only),
+ NULL, NULL,
+ fr_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
+
+ gobject_class->finalize = fr_process_finalize;
+
+ class->start = NULL;
+ class->done = NULL;
+}
+
+
+static void
+fr_process_init (FrProcess *process)
+{
+ process->priv = g_new0 (FrProcessPrivate, 1);
+
+ process->term_on_stop = TRUE;
+
+ process->priv->comm = g_ptr_array_new ();
+ process->priv->n_comm = -1;
+ process->priv->current_comm = -1;
+
+ process->priv->command_pid = 0;
+ fr_channel_data_init (&process->out);
+ fr_channel_data_init (&process->err);
+
+ process->error.gerror = NULL;
+ process->priv->first_error.gerror = NULL;
+
+ process->priv->check_timeout = 0;
+ process->priv->running = FALSE;
+ process->priv->stopping = FALSE;
+ process->restart = FALSE;
+
+ process->priv->current_charset = -1;
+
+ process->priv->use_standard_locale = FALSE;
+}
+
+
+FrProcess *
+fr_process_new (void)
+{
+ return FR_PROCESS (g_object_new (FR_TYPE_PROCESS, NULL));
+}
+
+
+static void fr_process_stop_priv (FrProcess *process, gboolean emit_signal);
+
+
+static void
+fr_process_finalize (GObject *object)
+{
+ FrProcess *process;
+
+ g_return_if_fail (object != NULL);
+ g_return_if_fail (FR_IS_PROCESS (object));
+
+ process = FR_PROCESS (object);
+
+ fr_process_stop_priv (process, FALSE);
+ fr_process_clear (process);
+
+ g_ptr_array_free (process->priv->comm, FALSE);
+
+ fr_channel_data_free (&process->out);
+ fr_channel_data_free (&process->err);
+
+ g_clear_error (&process->error.gerror);
+ g_clear_error (&process->priv->first_error.gerror);
+
+ g_free (process->priv);
+
+ /* Chain up */
+
+ if (G_OBJECT_CLASS (parent_class)->finalize)
+ G_OBJECT_CLASS (parent_class)->finalize (object);
+}
+
+
+void
+fr_process_begin_command (FrProcess *process,
+ const char *arg)
+{
+ FrCommandInfo *info;
+
+ g_return_if_fail (process != NULL);
+
+ info = fr_command_info_new ();
+ info->args = g_list_prepend (NULL, g_strdup (arg));
+
+ g_ptr_array_add (process->priv->comm, info);
+
+ process->priv->n_comm++;
+ process->priv->current_comm = process->priv->n_comm;
+}
+
+
+void
+fr_process_begin_command_at (FrProcess *process,
+ const char *arg,
+ int index)
+{
+ FrCommandInfo *info, *old_c_info;
+
+ g_return_if_fail (process != NULL);
+ g_return_if_fail (index >= 0 && index <= process->priv->n_comm);
+
+ process->priv->current_comm = index;
+
+ old_c_info = g_ptr_array_index (process->priv->comm, index);
+
+ if (old_c_info != NULL)
+ fr_command_info_free (old_c_info);
+
+ info = fr_command_info_new ();
+ info->args = g_list_prepend (NULL, g_strdup (arg));
+
+ g_ptr_array_index (process->priv->comm, index) = info;
+}
+
+
+void
+fr_process_set_working_dir (FrProcess *process,
+ const char *dir)
+{
+ FrCommandInfo *info;
+
+ g_return_if_fail (process != NULL);
+ g_return_if_fail (process->priv->current_comm >= 0);
+
+ info = g_ptr_array_index (process->priv->comm, process->priv->current_comm);
+ if (info->dir != NULL)
+ g_free (info->dir);
+ info->dir = g_strdup (dir);
+}
+
+
+void
+fr_process_set_sticky (FrProcess *process,
+ gboolean sticky)
+{
+ FrCommandInfo *info;
+
+ g_return_if_fail (process != NULL);
+ g_return_if_fail (process->priv->current_comm >= 0);
+
+ info = g_ptr_array_index (process->priv->comm, process->priv->current_comm);
+ info->sticky = sticky;
+}
+
+
+void
+fr_process_set_ignore_error (FrProcess *process,
+ gboolean ignore_error)
+{
+ FrCommandInfo *info;
+
+ g_return_if_fail (process != NULL);
+ g_return_if_fail (process->priv->current_comm >= 0);
+
+ info = g_ptr_array_index (process->priv->comm, process->priv->current_comm);
+ info->ignore_error = ignore_error;
+}
+
+
+void
+fr_process_add_arg (FrProcess *process,
+ const char *arg)
+{
+ FrCommandInfo *info;
+
+ g_return_if_fail (process != NULL);
+ g_return_if_fail (process->priv->current_comm >= 0);
+
+ info = g_ptr_array_index (process->priv->comm, process->priv->current_comm);
+ info->args = g_list_prepend (info->args, g_strdup (arg));
+}
+
+
+void
+fr_process_add_arg_concat (FrProcess *process,
+ const char *arg1,
+ ...)
+{
+ GString *arg;
+ va_list args;
+ char *s;
+
+ arg = g_string_new (arg1);
+
+ va_start (args, arg1);
+ while ((s = va_arg (args, char*)) != NULL)
+ g_string_append (arg, s);
+ va_end (args);
+
+ fr_process_add_arg (process, arg->str);
+ g_string_free (arg, TRUE);
+}
+
+
+void
+fr_process_add_arg_printf (FrProcess *fr_proc,
+ const char *format,
+ ...)
+{
+ va_list args;
+ char *arg;
+
+ va_start (args, format);
+ arg = g_strdup_vprintf (format, args);
+ va_end (args);
+
+ fr_process_add_arg (fr_proc, arg);
+
+ g_free (arg);
+}
+
+
+void
+fr_process_set_arg_at (FrProcess *process,
+ int n_comm,
+ int n_arg,
+ const char *arg_value)
+{
+ FrCommandInfo *info;
+ GList *arg;
+
+ g_return_if_fail (process != NULL);
+
+ info = g_ptr_array_index (process->priv->comm, n_comm);
+ arg = g_list_nth (info->args, n_arg);
+ g_return_if_fail (arg != NULL);
+
+ g_free (arg->data);
+ arg->data = g_strdup (arg_value);
+}
+
+
+void
+fr_process_set_begin_func (FrProcess *process,
+ ProcFunc func,
+ gpointer func_data)
+{
+ FrCommandInfo *info;
+
+ g_return_if_fail (process != NULL);
+
+ info = g_ptr_array_index (process->priv->comm, process->priv->current_comm);
+ info->begin_func = func;
+ info->begin_data = func_data;
+}
+
+
+void
+fr_process_set_end_func (FrProcess *process,
+ ProcFunc func,
+ gpointer func_data)
+{
+ FrCommandInfo *info;
+
+ g_return_if_fail (process != NULL);
+
+ info = g_ptr_array_index (process->priv->comm, process->priv->current_comm);
+ info->end_func = func;
+ info->end_data = func_data;
+}
+
+
+void
+fr_process_set_continue_func (FrProcess *process,
+ ContinueFunc func,
+ gpointer func_data)
+{
+ FrCommandInfo *info;
+
+ g_return_if_fail (process != NULL);
+
+ if (process->priv->current_comm < 0)
+ return;
+
+ info = g_ptr_array_index (process->priv->comm, process->priv->current_comm);
+ info->continue_func = func;
+ info->continue_data = func_data;
+}
+
+
+void
+fr_process_end_command (FrProcess *process)
+{
+ FrCommandInfo *info;
+
+ g_return_if_fail (process != NULL);
+
+ info = g_ptr_array_index (process->priv->comm, process->priv->current_comm);
+ info->args = g_list_reverse (info->args);
+}
+
+
+void
+fr_process_clear (FrProcess *process)
+{
+ gint i;
+
+ g_return_if_fail (process != NULL);
+
+ for (i = 0; i <= process->priv->n_comm; i++) {
+ FrCommandInfo *info;
+
+ info = g_ptr_array_index (process->priv->comm, i);
+ fr_command_info_free (info);
+ g_ptr_array_index (process->priv->comm, i) = NULL;
+ }
+
+ for (i = 0; i <= process->priv->n_comm; i++)
+ g_ptr_array_remove_index_fast (process->priv->comm, 0);
+
+ process->priv->n_comm = -1;
+ process->priv->current_comm = -1;
+}
+
+
+void
+fr_process_set_out_line_func (FrProcess *process,
+ LineFunc func,
+ gpointer data)
+{
+ g_return_if_fail (process != NULL);
+
+ process->out.line_func = func;
+ process->out.line_data = data;
+}
+
+
+void
+fr_process_set_err_line_func (FrProcess *process,
+ LineFunc func,
+ gpointer data)
+{
+ g_return_if_fail (process != NULL);
+
+ process->err.line_func = func;
+ process->err.line_data = data;
+}
+
+
+static gboolean check_child (gpointer data);
+
+
+static void
+child_setup (gpointer user_data)
+{
+ FrProcess *process = user_data;
+
+ if (process->priv->use_standard_locale)
+ putenv ("LC_MESSAGES=C");
+
+ /* detach from the tty */
+
+ setsid ();
+}
+
+
+static const char *
+fr_process_get_charset (FrProcess *process)
+{
+ const char *charset = NULL;
+
+ if (process->priv->current_charset >= 0)
+ charset = try_charsets[process->priv->current_charset];
+ else if (g_get_charset (&charset))
+ charset = NULL;
+
+ return charset;
+}
+
+
+static void
+start_current_command (FrProcess *process)
+{
+ FrCommandInfo *info;
+ GList *scan;
+ char **argv;
+ int out_fd, err_fd;
+ int i = 0;
+
+ debug (DEBUG_INFO, "%d/%d) ", process->priv->current_command, process->priv->n_comm);
+
+ info = g_ptr_array_index (process->priv->comm, process->priv->current_command);
+
+ argv = g_new (char *, g_list_length (info->args) + 1);
+ for (scan = info->args; scan; scan = scan->next)
+ argv[i++] = scan->data;
+ argv[i] = NULL;
+
+#ifdef DEBUG
+ {
+ int j;
+
+ if (process->priv->use_standard_locale)
+ g_print ("\tLC_MESSAGES=C\n");
+
+ if (info->dir != NULL)
+ g_print ("\tcd %s\n", info->dir);
+
+ g_print ("\t");
+ for (j = 0; j < i; j++)
+ g_print ("%s ", argv[j]);
+ g_print ("\n");
+ }
+#endif
+
+ if (info->begin_func != NULL)
+ (*info->begin_func) (info->begin_data);
+
+ if (! g_spawn_async_with_pipes (info->dir,
+ argv,
+ NULL,
+ (G_SPAWN_LEAVE_DESCRIPTORS_OPEN
+ | G_SPAWN_SEARCH_PATH
+ | G_SPAWN_DO_NOT_REAP_CHILD),
+ child_setup,
+ process,
+ &process->priv->command_pid,
+ NULL,
+ &out_fd,
+ &err_fd,
+ &process->error.gerror))
+ {
+ process->error.type = FR_PROC_ERROR_SPAWN;
+ g_signal_emit (G_OBJECT (process),
+ fr_process_signals[DONE],
+ 0);
+ g_free (argv);
+ return;
+ }
+
+ g_free (argv);
+
+ fr_channel_data_set_fd (&process->out, out_fd, fr_process_get_charset (process));
+ fr_channel_data_set_fd (&process->err, err_fd, fr_process_get_charset (process));
+
+ process->priv->check_timeout = g_timeout_add (REFRESH_RATE,
+ check_child,
+ process);
+}
+
+
+static gboolean
+command_is_sticky (FrProcess *process,
+ int i)
+{
+ FrCommandInfo *info;
+
+ info = g_ptr_array_index (process->priv->comm, i);
+ return info->sticky;
+}
+
+
+static void
+allow_sticky_processes_only (FrProcess *process,
+ gboolean emit_signal)
+{
+ if (! process->priv->sticky_only) {
+ /* Remember the first error. */
+ process->priv->error_command = process->priv->current_command;
+ process->priv->first_error.type = process->error.type;
+ process->priv->first_error.status = process->error.status;
+ g_clear_error (&process->priv->first_error.gerror);
+ if (process->error.gerror != NULL)
+ process->priv->first_error.gerror = g_error_copy (process->error.gerror);
+ }
+
+ process->priv->sticky_only = TRUE;
+ if (emit_signal)
+ g_signal_emit (G_OBJECT (process),
+ fr_process_signals[STICKY_ONLY],
+ 0);
+}
+
+
+static void
+fr_process_set_error (FrProcess *process,
+ FrProcErrorType type,
+ int status,
+ GError *gerror)
+{
+ process->error.type = type;
+ process->error.status = status;
+ if (gerror != process->error.gerror) {
+ g_clear_error (&process->error.gerror);
+ if (gerror != NULL)
+ process->error.gerror = g_error_copy (gerror);
+ }
+}
+
+
+static gint
+check_child (gpointer data)
+{
+ FrProcess *process = data;
+ FrCommandInfo *info;
+ pid_t pid;
+ int status;
+ gboolean continue_process;
+ gboolean channel_error = FALSE;
+
+ info = g_ptr_array_index (process->priv->comm, process->priv->current_command);
+
+ /* Remove check. */
+
+ g_source_remove (process->priv->check_timeout);
+ process->priv->check_timeout = 0;
+
+ if (fr_channel_data_read (&process->out) == G_IO_STATUS_ERROR) {
+ fr_process_set_error (process, FR_PROC_ERROR_IO_CHANNEL, 0, process->out.error);
+ channel_error = TRUE;
+ }
+ else if (fr_channel_data_read (&process->err) == G_IO_STATUS_ERROR) {
+ fr_process_set_error (process, FR_PROC_ERROR_IO_CHANNEL, 0, process->err.error);
+ channel_error = TRUE;
+ }
+ else {
+ pid = waitpid (process->priv->command_pid, &status, WNOHANG);
+ if (pid != process->priv->command_pid) {
+ /* Add check again. */
+ process->priv->check_timeout = g_timeout_add (REFRESH_RATE,
+ check_child,
+ process);
+ return FALSE;
+ }
+ }
+
+ if (info->ignore_error) {
+ process->error.type = FR_PROC_ERROR_NONE;
+ debug (DEBUG_INFO, "[ignore error]\n");
+ }
+ else if (! channel_error && (process->error.type != FR_PROC_ERROR_STOPPED)) {
+ if (WIFEXITED (status)) {
+ if (WEXITSTATUS (status) == 0)
+ process->error.type = FR_PROC_ERROR_NONE;
+ else if (WEXITSTATUS (status) == 255)
+ process->error.type = FR_PROC_ERROR_COMMAND_NOT_FOUND;
+ else {
+ process->error.type = FR_PROC_ERROR_COMMAND_ERROR;
+ process->error.status = WEXITSTATUS (status);
+ }
+ }
+ else {
+ process->error.type = FR_PROC_ERROR_EXITED_ABNORMALLY;
+ process->error.status = 255;
+ }
+ }
+
+ process->priv->command_pid = 0;
+
+ if (fr_channel_data_flush (&process->out) == G_IO_STATUS_ERROR) {
+ fr_process_set_error (process, FR_PROC_ERROR_IO_CHANNEL, 0, process->out.error);
+ channel_error = TRUE;
+ }
+ else if (fr_channel_data_flush (&process->err) == G_IO_STATUS_ERROR) {
+ fr_process_set_error (process, FR_PROC_ERROR_IO_CHANNEL, 0, process->err.error);
+ channel_error = TRUE;
+ }
+
+ if (info->end_func != NULL)
+ (*info->end_func) (info->end_data);
+
+ /**/
+
+ if (channel_error
+ && (process->error.type == FR_PROC_ERROR_IO_CHANNEL)
+ && g_error_matches (process->error.gerror, G_CONVERT_ERROR, G_CONVERT_ERROR_ILLEGAL_SEQUENCE))
+ {
+ if (process->priv->current_charset < n_charsets - 1) {
+ /* try with another charset */
+ process->priv->current_charset++;
+ process->priv->running = FALSE;
+ process->restart = TRUE;
+ fr_process_start (process);
+ return FALSE;
+ }
+ /*fr_process_set_error (process, FR_PROC_ERROR_NONE, 0, NULL);*/
+ fr_process_set_error (process, FR_PROC_ERROR_BAD_CHARSET, 0, process->error.gerror);
+ }
+
+ /* Check whether to continue or stop the process */
+
+ continue_process = TRUE;
+ if (info->continue_func != NULL)
+ continue_process = (*info->continue_func) (info->continue_data);
+
+ /* Execute next command. */
+ if (continue_process) {
+ if (process->error.type != FR_PROC_ERROR_NONE) {
+ allow_sticky_processes_only (process, TRUE);
+#ifdef DEBUG
+ {
+ GList *scan;
+
+ g_print ("** ERROR **\n");
+ for (scan = process->err.raw; scan; scan = scan->next)
+ g_print ("%s\n", (char *)scan->data);
+ }
+#endif
+ }
+
+ if (process->priv->sticky_only) {
+ do {
+ process->priv->current_command++;
+ } while ((process->priv->current_command <= process->priv->n_comm)
+ && ! command_is_sticky (process, process->priv->current_command));
+ }
+ else
+ process->priv->current_command++;
+
+ if (process->priv->current_command <= process->priv->n_comm) {
+ start_current_command (process);
+ return FALSE;
+ }
+ }
+
+ /* Done */
+
+ process->priv->current_command = -1;
+ process->priv->use_standard_locale = FALSE;
+
+ if (process->out.raw != NULL)
+ process->out.raw = g_list_reverse (process->out.raw);
+ if (process->err.raw != NULL)
+ process->err.raw = g_list_reverse (process->err.raw);
+
+ process->priv->running = FALSE;
+ process->priv->stopping = FALSE;
+
+ if (process->priv->sticky_only) {
+ /* Restore the first error. */
+ fr_process_set_error (process,
+ process->priv->first_error.type,
+ process->priv->first_error.status,
+ process->priv->first_error.gerror);
+ }
+
+ g_signal_emit (G_OBJECT (process),
+ fr_process_signals[DONE],
+ 0);
+
+ return FALSE;
+}
+
+
+void
+fr_process_use_standard_locale (FrProcess *process,
+ gboolean use_stand_locale)
+{
+ g_return_if_fail (process != NULL);
+ process->priv->use_standard_locale = use_stand_locale;
+}
+
+
+void
+fr_process_start (FrProcess *process)
+{
+ g_return_if_fail (process != NULL);
+
+ if (process->priv->running)
+ return;
+
+ fr_channel_data_reset (&process->out);
+ fr_channel_data_reset (&process->err);
+
+ process->priv->sticky_only = FALSE;
+ process->priv->current_command = 0;
+ fr_process_set_error (process, FR_PROC_ERROR_NONE, 0, NULL);
+
+ if (! process->restart) {
+ process->priv->current_charset = -1;
+ g_signal_emit (G_OBJECT (process),
+ fr_process_signals[START],
+ 0);
+ }
+
+ process->priv->stopping = FALSE;
+
+ if (process->priv->n_comm == -1) {
+ process->priv->running = FALSE;
+ g_signal_emit (G_OBJECT (process),
+ fr_process_signals[DONE],
+ 0);
+ }
+ else {
+ process->priv->running = TRUE;
+ start_current_command (process);
+ }
+}
+
+
+static void
+fr_process_stop_priv (FrProcess *process,
+ gboolean emit_signal)
+{
+ g_return_if_fail (process != NULL);
+
+ if (! process->priv->running)
+ return;
+
+ if (process->priv->stopping)
+ return;
+
+ process->priv->stopping = TRUE;
+ process->error.type = FR_PROC_ERROR_STOPPED;
+
+ if (command_is_sticky (process, process->priv->current_command))
+ allow_sticky_processes_only (process, emit_signal);
+
+ else if (process->term_on_stop && (process->priv->command_pid > 0))
+ kill (process->priv->command_pid, SIGTERM);
+
+ else {
+ if (process->priv->check_timeout != 0) {
+ g_source_remove (process->priv->check_timeout);
+ process->priv->check_timeout = 0;
+ }
+
+ process->priv->command_pid = 0;
+ fr_channel_data_close_source (&process->out);
+ fr_channel_data_close_source (&process->err);
+
+ process->priv->running = FALSE;
+
+ if (emit_signal)
+ g_signal_emit (G_OBJECT (process),
+ fr_process_signals[DONE],
+ 0);
+ }
+}
+
+
+void
+fr_process_stop (FrProcess *process)
+{
+ fr_process_stop_priv (process, TRUE);
+}