initial

1 files changed, 826 insertions, 0 deletions

diff --git a/src/fr-command.c b/src/fr-command.c
new file mode 100644
index 0000000..873c02d
--- /dev/null
+++ b/src/fr-command.c
@@ -0,0 +1,826 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+
+/*
+ *  File-Roller
+ *
+ *  Copyright (C) 2001 The 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 <string.h>
+#include <unistd.h>
+#include <errno.h>
+#include <glib.h>
+#include "file-data.h"
+#include "file-utils.h"
+#include "fr-command.h"
+#include "fr-enum-types.h"
+#include "fr-marshal.h"
+#include "fr-process.h"
+#include "glib-utils.h"
+
+#define INITIAL_SIZE 256
+
+
+/* Signals */
+enum {
+	START,
+	DONE,
+	PROGRESS,
+	MESSAGE,
+	WORKING_ARCHIVE,
+	LAST_SIGNAL
+};
+
+/* Properties */
+enum {
+        PROP_0,
+        PROP_FILENAME,
+        PROP_MIME_TYPE,
+        PROP_PROCESS,
+        PROP_PASSWORD,
+        PROP_ENCRYPT_HEADER,
+        PROP_COMPRESSION,
+        PROP_VOLUME_SIZE
+};
+
+static GObjectClass *parent_class = NULL;
+static guint fr_command_signals[LAST_SIGNAL] = { 0 };
+
+static void fr_command_class_init  (FrCommandClass *class);
+static void fr_command_init        (FrCommand *afile);
+static void fr_command_finalize    (GObject *object);
+
+char *action_names[] = { "NONE",
+			 "CREATING_NEW_ARCHIVE",
+			 "LOADING_ARCHIVE",
+			 "LISTING_CONTENT",
+			 "DELETING_FILES",
+			 "TESTING_ARCHIVE",
+			 "GETTING_FILE_LIST",
+			 "COPYING_FILES_FROM_REMOTE",
+			 "ADDING_FILES",
+			 "EXTRACTING_FILES",
+			 "COPYING_FILES_TO_REMOTE",
+			 "CREATING_ARCHIVE",
+			 "SAVING_REMOTE_ARCHIVE" };
+
+GType
+fr_command_get_type ()
+{
+	static GType type = 0;
+
+	if (! type) {
+		GTypeInfo type_info = {
+			sizeof (FrCommandClass),
+			NULL,
+			NULL,
+			(GClassInitFunc) fr_command_class_init,
+			NULL,
+			NULL,
+			sizeof (FrCommand),
+			0,
+			(GInstanceInitFunc) fr_command_init
+		};
+
+		type = g_type_register_static (G_TYPE_OBJECT,
+					       "FRCommand",
+					       &type_info,
+					       0);
+	}
+
+	return type;
+}
+
+
+static void
+base_fr_command_list (FrCommand  *comm)
+{
+}
+
+
+static void
+base_fr_command_add (FrCommand     *comm,
+		     const char    *from_file,
+		     GList         *file_list,
+		     const char    *base_dir,
+		     gboolean       update,
+		     gboolean       recursive)
+{
+}
+
+
+static void
+base_fr_command_delete (FrCommand  *comm,
+		        const char *from_file,
+			GList       *file_list)
+{
+}
+
+
+static void
+base_fr_command_extract (FrCommand  *comm,
+		         const char *from_file,
+			 GList      *file_list,
+			 const char *dest_dir,
+			 gboolean    overwrite,
+			 gboolean    skip_older,
+			 gboolean    junk_paths)
+{
+}
+
+
+static void
+base_fr_command_test (FrCommand *comm)
+{
+}
+
+
+static void
+base_fr_command_uncompress (FrCommand *comm)
+{
+}
+
+
+static void
+base_fr_command_recompress (FrCommand *comm)
+{
+}
+
+
+static void
+base_fr_command_handle_error (FrCommand   *comm,
+			      FrProcError *error)
+{
+}
+
+
+const char **void_mime_types = { NULL };
+
+
+const char **
+base_fr_command_get_mime_types (FrCommand *comm)
+{
+	return void_mime_types;
+}
+
+
+FrCommandCap
+base_fr_command_get_capabilities (FrCommand  *comm,
+			          const char *mime_type,
+			          gboolean    check_command)
+{
+	return FR_COMMAND_CAN_DO_NOTHING;
+}
+
+
+static void
+base_fr_command_set_mime_type (FrCommand  *comm,
+			       const char *mime_type)
+{
+	comm->mime_type = get_static_string (mime_type);
+	fr_command_update_capabilities (comm);
+}
+
+
+static const char *
+base_fr_command_get_packages (FrCommand  *comm,
+			      const char *mime_type)
+{
+	return NULL;
+}
+
+
+static void
+fr_command_start (FrProcess *process,
+		  gpointer   data)
+{
+	FrCommand *comm = FR_COMMAND (data);
+
+	g_signal_emit (G_OBJECT (comm),
+		       fr_command_signals[START],
+		       0,
+		       comm->action);
+}
+
+
+static void
+fr_command_done (FrProcess   *process,
+		 gpointer     data)
+{
+	FrCommand *comm = FR_COMMAND (data);
+
+	comm->process->restart = FALSE;
+	fr_command_handle_error (comm, &process->error);
+
+	if (comm->process->restart) {
+		fr_process_start (comm->process);
+		return;
+	}
+
+	if (comm->action == FR_ACTION_LISTING_CONTENT) {
+		/* order the list by name to speed up search */
+		g_ptr_array_sort (comm->files, file_data_compare_by_path);
+	}
+
+	g_signal_emit (G_OBJECT (comm),
+		       fr_command_signals[DONE],
+		       0,
+		       comm->action,
+		       &process->error);
+}
+
+
+static void
+fr_command_set_process (FrCommand *comm,
+		        FrProcess *process)
+{
+	if (comm->process != NULL) {
+		g_signal_handlers_disconnect_matched (G_OBJECT (comm->process),
+					      G_SIGNAL_MATCH_DATA,
+					      0,
+					      0, NULL,
+					      0,
+					      comm);
+		g_object_unref (G_OBJECT (comm->process));
+		comm->process = NULL;
+	}
+
+	if (process == NULL)
+		return;
+
+	g_object_ref (G_OBJECT (process));
+	comm->process = process;
+	g_signal_connect (G_OBJECT (comm->process),
+			  "start",
+			  G_CALLBACK (fr_command_start),
+			  comm);
+	g_signal_connect (G_OBJECT (comm->process),
+			  "done",
+			  G_CALLBACK (fr_command_done),
+			  comm);
+}
+
+
+static void
+fr_command_set_property (GObject      *object,
+			 guint         prop_id,
+			 const GValue *value,
+			 GParamSpec   *pspec)
+{
+	FrCommand *comm;
+
+	comm = FR_COMMAND (object);
+
+	switch (prop_id) {
+	case PROP_PROCESS:
+		fr_command_set_process (comm, g_value_get_object (value));
+		break;
+	case PROP_FILENAME:
+		fr_command_set_filename (comm, g_value_get_string (value));
+		break;
+	case PROP_MIME_TYPE:
+		fr_command_set_mime_type (comm, g_value_get_string (value));
+		break;
+	case PROP_PASSWORD:
+		g_free (comm->password);
+		comm->password = g_strdup (g_value_get_string (value));
+		break;
+	case PROP_ENCRYPT_HEADER:
+		comm->encrypt_header = g_value_get_boolean (value);
+		break;
+	case PROP_COMPRESSION:
+		comm->compression = g_value_get_enum (value);
+		break;
+	case PROP_VOLUME_SIZE:
+		comm->volume_size = g_value_get_uint (value);
+		break;
+	default:
+		break;
+	}
+}
+
+
+static void
+fr_command_get_property (GObject    *object,
+			 guint       prop_id,
+			 GValue     *value,
+			 GParamSpec *pspec)
+{
+	FrCommand *comm;
+
+	comm = FR_COMMAND (object);
+
+	switch (prop_id) {
+	case PROP_PROCESS:
+		g_value_set_object (value, comm->process);
+		break;
+	case PROP_FILENAME:
+		g_value_set_string (value, comm->filename);
+		break;
+	case PROP_MIME_TYPE:
+		g_value_set_static_string (value, comm->mime_type);
+		break;
+	case PROP_PASSWORD:
+		g_value_set_string (value, comm->password);
+		break;
+	case PROP_ENCRYPT_HEADER:
+		g_value_set_boolean (value, comm->encrypt_header);
+		break;
+	case PROP_COMPRESSION:
+		g_value_set_enum (value, comm->compression);
+		break;
+	case PROP_VOLUME_SIZE:
+		g_value_set_uint (value, comm->volume_size);
+		break;
+	default:
+		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+		break;
+	}
+}
+
+
+static void
+fr_command_class_init (FrCommandClass *class)
+{
+	GObjectClass *gobject_class;
+
+	parent_class = g_type_class_peek_parent (class);
+
+	gobject_class = G_OBJECT_CLASS (class);
+
+	/* virtual functions */
+
+	gobject_class->finalize = fr_command_finalize;
+	gobject_class->set_property = fr_command_set_property;
+	gobject_class->get_property = fr_command_get_property;
+
+	class->list             = base_fr_command_list;
+	class->add              = base_fr_command_add;
+	class->delete           = base_fr_command_delete;
+	class->extract          = base_fr_command_extract;
+	class->test             = base_fr_command_test;
+	class->uncompress       = base_fr_command_uncompress;
+	class->recompress       = base_fr_command_recompress;
+	class->handle_error     = base_fr_command_handle_error;
+	class->get_mime_types   = base_fr_command_get_mime_types;
+	class->get_capabilities = base_fr_command_get_capabilities;
+	class->set_mime_type    = base_fr_command_set_mime_type;
+	class->get_packages     = base_fr_command_get_packages;
+	class->start            = NULL;
+	class->done             = NULL;
+	class->progress         = NULL;
+	class->message          = NULL;
+
+	/* signals */
+
+	fr_command_signals[START] =
+		g_signal_new ("start",
+			      G_TYPE_FROM_CLASS (class),
+			      G_SIGNAL_RUN_LAST,
+			      G_STRUCT_OFFSET (FrCommandClass, start),
+			      NULL, NULL,
+			      fr_marshal_VOID__INT,
+			      G_TYPE_NONE,
+			      1, G_TYPE_INT);
+	fr_command_signals[DONE] =
+		g_signal_new ("done",
+			      G_TYPE_FROM_CLASS (class),
+			      G_SIGNAL_RUN_LAST,
+			      G_STRUCT_OFFSET (FrCommandClass, done),
+			      NULL, NULL,
+			      fr_marshal_VOID__INT_POINTER,
+			      G_TYPE_NONE, 2,
+			      G_TYPE_INT,
+			      G_TYPE_POINTER);
+	fr_command_signals[PROGRESS] =
+		g_signal_new ("progress",
+			      G_TYPE_FROM_CLASS (class),
+			      G_SIGNAL_RUN_LAST,
+			      G_STRUCT_OFFSET (FrCommandClass, progress),
+			      NULL, NULL,
+			      fr_marshal_VOID__DOUBLE,
+			      G_TYPE_NONE, 1,
+			      G_TYPE_DOUBLE);
+	fr_command_signals[MESSAGE] =
+		g_signal_new ("message",
+			      G_TYPE_FROM_CLASS (class),
+			      G_SIGNAL_RUN_LAST,
+			      G_STRUCT_OFFSET (FrCommandClass, message),
+			      NULL, NULL,
+			      fr_marshal_VOID__STRING,
+			      G_TYPE_NONE, 1,
+			      G_TYPE_STRING);
+	fr_command_signals[WORKING_ARCHIVE] =
+			g_signal_new ("working_archive",
+				      G_TYPE_FROM_CLASS (class),
+				      G_SIGNAL_RUN_LAST,
+				      G_STRUCT_OFFSET (FrCommandClass, working_archive),
+				      NULL, NULL,
+				      fr_marshal_VOID__STRING,
+				      G_TYPE_NONE, 1,
+				      G_TYPE_STRING);
+
+	/* properties */
+
+	g_object_class_install_property (gobject_class,
+					 PROP_PROCESS,
+					 g_param_spec_object ("process",
+							      "Process",
+							      "The process object used by the command",
+							      FR_TYPE_PROCESS,
+							      G_PARAM_READWRITE));
+	g_object_class_install_property (gobject_class,
+					 PROP_FILENAME,
+					 g_param_spec_string ("filename",
+							      "Filename",
+							      "The archive filename",
+							      NULL,
+							      G_PARAM_READWRITE));
+	g_object_class_install_property (gobject_class,
+					 PROP_MIME_TYPE,
+					 g_param_spec_string ("mime-type",
+							      "Mime type",
+							      "The file mime-type",
+							      NULL,
+							      G_PARAM_READWRITE));
+	g_object_class_install_property (gobject_class,
+					 PROP_PASSWORD,
+					 g_param_spec_string ("password",
+							      "Password",
+							      "The archive password",
+							      NULL,
+							      G_PARAM_READWRITE));
+	g_object_class_install_property (gobject_class,
+					 PROP_ENCRYPT_HEADER,
+					 g_param_spec_boolean ("encrypt-header",
+							       "Encrypt header",
+							       "Whether to encrypt the archive header when creating the archive",
+							       FALSE,
+							       G_PARAM_READWRITE));
+	g_object_class_install_property (gobject_class,
+					 PROP_COMPRESSION,
+					 g_param_spec_enum ("compression",
+							    "Compression type",
+							    "The compression type to use when creating the archive",
+							    FR_TYPE_COMPRESSION,
+							    FR_COMPRESSION_NORMAL,
+							    G_PARAM_READWRITE));
+	g_object_class_install_property (gobject_class,
+					 PROP_VOLUME_SIZE,
+					 g_param_spec_uint ("volume-size",
+							    "Volume size",
+							    "The size of each volume or 0 to not use volumes",
+							    0L,
+							    G_MAXUINT,
+							    0,
+							    G_PARAM_READWRITE));
+}
+
+
+static void
+fr_command_init (FrCommand *comm)
+{
+	comm->files = g_ptr_array_sized_new (INITIAL_SIZE);
+
+	comm->password = NULL;
+	comm->encrypt_header = FALSE;
+	comm->compression = FR_COMPRESSION_NORMAL;
+	comm->volume_size = 0;
+	comm->filename = NULL;
+	comm->e_filename = NULL;
+	comm->fake_load = FALSE;
+
+	comm->propAddCanUpdate = FALSE;
+	comm->propAddCanReplace = FALSE;
+	comm->propAddCanStoreFolders = FALSE;
+	comm->propExtractCanAvoidOverwrite = FALSE;
+	comm->propExtractCanSkipOlder = FALSE;
+	comm->propExtractCanJunkPaths = FALSE;
+	comm->propPassword = FALSE;
+	comm->propTest = FALSE;
+	comm->propCanExtractAll = TRUE;
+	comm->propCanDeleteNonEmptyFolders = TRUE;
+	comm->propCanExtractNonEmptyFolders = TRUE;
+	comm->propListFromFile = FALSE;
+}
+
+
+static void
+fr_command_finalize (GObject *object)
+{
+	FrCommand* comm;
+
+	g_return_if_fail (object != NULL);
+	g_return_if_fail (FR_IS_COMMAND (object));
+
+	comm = FR_COMMAND (object);
+
+	g_free (comm->filename);
+	g_free (comm->e_filename);
+	g_free (comm->password);
+	if (comm->files != NULL)
+		g_ptr_array_free_full (comm->files, (GFunc) file_data_free, NULL);
+	fr_command_set_process (comm, NULL);
+
+	/* Chain up */
+	if (G_OBJECT_CLASS (parent_class)->finalize)
+		G_OBJECT_CLASS (parent_class)->finalize (object);
+}
+
+
+void
+fr_command_set_filename (FrCommand  *comm,
+			 const char *filename)
+{
+	g_return_if_fail (FR_IS_COMMAND (comm));
+
+	if (comm->filename != NULL) {
+		g_free (comm->filename);
+		comm->filename = NULL;
+	}
+
+	if (comm->e_filename != NULL) {
+		g_free (comm->e_filename);
+		comm->e_filename = NULL;
+	}
+
+	if (filename != NULL) {
+		if (! g_path_is_absolute (filename)) {
+			char *current_dir;
+
+			current_dir = g_get_current_dir ();
+			comm->filename = g_strconcat (current_dir,
+						      "/",
+						      filename,
+						      NULL);
+			g_free (current_dir);
+		}
+		else
+			comm->filename = g_strdup (filename);
+
+		comm->e_filename = g_shell_quote (comm->filename);
+
+		debug (DEBUG_INFO, "filename : %s\n", comm->filename);
+		debug (DEBUG_INFO, "e_filename : %s\n", comm->e_filename);
+	}
+
+	fr_command_working_archive (comm, comm->filename);
+}
+
+
+void
+fr_command_set_multi_volume (FrCommand  *comm,
+			     const char *filename)
+{
+	comm->multi_volume = TRUE;
+	fr_command_set_filename (comm, filename);
+}
+
+
+void
+fr_command_list (FrCommand *comm)
+{
+	g_return_if_fail (FR_IS_COMMAND (comm));
+
+	fr_command_progress (comm, -1.0);
+
+	if (comm->files != NULL) {
+		g_ptr_array_free_full (comm->files, (GFunc) file_data_free, NULL);
+		comm->files = g_ptr_array_sized_new (INITIAL_SIZE);
+	}
+
+	comm->action = FR_ACTION_LISTING_CONTENT;
+	fr_process_set_out_line_func (comm->process, NULL, NULL);
+	fr_process_set_err_line_func (comm->process, NULL, NULL);
+	fr_process_use_standard_locale (comm->process, TRUE);
+	comm->multi_volume = FALSE;
+
+	if (! comm->fake_load)
+		FR_COMMAND_GET_CLASS (G_OBJECT (comm))->list (comm);
+	else
+		g_signal_emit (G_OBJECT (comm),
+			       fr_command_signals[DONE],
+			       0,
+			       comm->action,
+			       &comm->process->error);
+}
+
+
+void
+fr_command_add (FrCommand     *comm,
+		const char    *from_file,
+		GList         *file_list,
+		const char    *base_dir,
+		gboolean       update,
+		gboolean       recursive)
+{
+	fr_command_progress (comm, -1.0);
+
+	comm->action = FR_ACTION_ADDING_FILES;
+	fr_process_set_out_line_func (FR_COMMAND (comm)->process, NULL, NULL);
+	fr_process_set_err_line_func (FR_COMMAND (comm)->process, NULL, NULL);
+
+	FR_COMMAND_GET_CLASS (G_OBJECT (comm))->add (comm,
+						     from_file,
+						     file_list,
+						     base_dir,
+						     update,
+						     recursive);
+}
+
+
+void
+fr_command_delete (FrCommand   *comm,
+		   const char  *from_file,
+		   GList       *file_list)
+{
+	fr_command_progress (comm, -1.0);
+
+	comm->action = FR_ACTION_DELETING_FILES;
+	fr_process_set_out_line_func (FR_COMMAND (comm)->process, NULL, NULL);
+	fr_process_set_err_line_func (FR_COMMAND (comm)->process, NULL, NULL);
+
+	FR_COMMAND_GET_CLASS (G_OBJECT (comm))->delete (comm, from_file, file_list);
+}
+
+
+void
+fr_command_extract (FrCommand  *comm,
+		    const char *from_file,
+		    GList      *file_list,
+		    const char *dest_dir,
+		    gboolean    overwrite,
+		    gboolean    skip_older,
+		    gboolean    junk_paths)
+{
+	fr_command_progress (comm, -1.0);
+
+	comm->action = FR_ACTION_EXTRACTING_FILES;
+	fr_process_set_out_line_func (FR_COMMAND (comm)->process, NULL, NULL);
+	fr_process_set_err_line_func (FR_COMMAND (comm)->process, NULL, NULL);
+
+	FR_COMMAND_GET_CLASS (G_OBJECT (comm))->extract (comm,
+							 from_file,
+							 file_list,
+							 dest_dir,
+							 overwrite,
+							 skip_older,
+							 junk_paths);
+}
+
+
+void
+fr_command_test (FrCommand *comm)
+{
+	fr_command_progress (comm, -1.0);
+
+	comm->action = FR_ACTION_TESTING_ARCHIVE;
+	fr_process_set_out_line_func (FR_COMMAND (comm)->process, NULL, NULL);
+	fr_process_set_err_line_func (FR_COMMAND (comm)->process, NULL, NULL);
+
+	FR_COMMAND_GET_CLASS (G_OBJECT (comm))->test (comm);
+}
+
+
+void
+fr_command_uncompress (FrCommand *comm)
+{
+	fr_command_progress (comm, -1.0);
+	FR_COMMAND_GET_CLASS (G_OBJECT (comm))->uncompress (comm);
+}
+
+
+void
+fr_command_recompress (FrCommand *comm)
+{
+	fr_command_progress (comm, -1.0);
+	FR_COMMAND_GET_CLASS (G_OBJECT (comm))->recompress (comm);
+}
+
+
+const char **
+fr_command_get_mime_types (FrCommand *comm)
+{
+	return FR_COMMAND_GET_CLASS (G_OBJECT (comm))->get_mime_types (comm);
+}
+
+
+void
+fr_command_update_capabilities (FrCommand *comm)
+{
+	comm->capabilities = fr_command_get_capabilities (comm, comm->mime_type, TRUE);
+}
+
+
+FrCommandCap
+fr_command_get_capabilities (FrCommand  *comm,
+			     const char *mime_type,
+			     gboolean    check_command)
+{
+	return FR_COMMAND_GET_CLASS (G_OBJECT (comm))->get_capabilities (comm, mime_type, check_command);
+}
+
+
+gboolean
+fr_command_is_capable_of (FrCommand     *comm,
+			  FrCommandCaps  requested_capabilities)
+{
+	return (((comm->capabilities ^ requested_capabilities) & requested_capabilities) == 0);
+}
+
+
+const char *
+fr_command_get_packages (FrCommand  *comm,
+			 const char *mime_type)
+{
+	return FR_COMMAND_GET_CLASS (G_OBJECT (comm))->get_packages (comm, mime_type);
+}
+
+
+/* fraction == -1 means : I don't known how much time the current operation
+ *                        will take, the dialog will display this info pulsing
+ *                        the progress bar.
+ * fraction in [0.0, 1.0] means the amount of work, in percentage,
+ *                        accomplished.
+ */
+void
+fr_command_progress (FrCommand *comm,
+		     double     fraction)
+{
+	g_signal_emit (G_OBJECT (comm),
+		       fr_command_signals[PROGRESS],
+		       0,
+		       fraction);
+}
+
+
+void
+fr_command_message (FrCommand  *comm,
+		    const char *msg)
+{
+	g_signal_emit (G_OBJECT (comm),
+		       fr_command_signals[MESSAGE],
+		       0,
+		       msg);
+}
+
+
+void
+fr_command_working_archive (FrCommand  *comm,
+		            const char *archive_name)
+{
+	g_signal_emit (G_OBJECT (comm),
+		       fr_command_signals[WORKING_ARCHIVE],
+		       0,
+		       archive_name);
+}
+
+
+void
+fr_command_set_n_files (FrCommand *comm,
+			int        n_files)
+{
+	comm->n_files = n_files;
+	comm->n_file = 0;
+}
+
+
+void
+fr_command_add_file (FrCommand *comm,
+		     FileData  *fdata)
+{
+	file_data_update_content_type (fdata);
+	g_ptr_array_add (comm->files, fdata);
+	if (! fdata->dir)
+		comm->n_regular_files++;
+}
+
+
+void
+fr_command_set_mime_type (FrCommand  *comm,
+			  const char *mime_type)
+{
+	FR_COMMAND_GET_CLASS (G_OBJECT (comm))->set_mime_type (comm, mime_type);
+}
+
+
+void
+fr_command_handle_error (FrCommand   *comm,
+			 FrProcError *error)
+{
+	FR_COMMAND_GET_CLASS (G_OBJECT (comm))->handle_error (comm, error);
+}