void
seahorse_util_handle_error (GError* err, const char* desc, ...)
{
gchar *t = NULL;
va_list ap;
if(!err)
return;
va_start(ap, desc);
if (desc)
t = g_strdup_vprintf (desc, ap);
va_end(ap);
/* Never show an error for 'cancelled' */
if (err->code == DBUS_GERROR_REMOTE_EXCEPTION && err->domain == DBUS_GERROR &&
strstr (dbus_g_error_get_name (err), "Cancelled"))
g_free(t);
return;
seahorse_util_show_error (NULL, t, err->message ? err->message : "");
g_free(t);
g_clear_error (&err);
}
/**
* seahorse_util_handle_gpgme:
* @err: Error value
*
* Shows an error dialog for @err.
**/
void
seahorse_util_handle_gpgme (gpgme_error_t err, const char* desc, ...)
{
gchar *t = NULL;
switch (gpgme_err_code(err)) {
case GPG_ERR_CANCELED:
case GPG_ERR_NO_ERROR:
case GPG_ERR_ECANCELED:
return;
default:
break;
}
va_list ap;
va_start(ap, desc);
if (desc)
t = g_strdup_vprintf (desc, ap);
va_end(ap);
seahorse_util_show_error (NULL, t, gpgme_strerror (err));
g_free(t);
}
/* Called when a cell has completed being edited */
static void
keyserver_cell_edited (GtkCellRendererText *cell, gchar *path, gchar *text,
GtkTreeModel *model)
{
GtkTreeIter iter;
if (!seahorse_servers_is_valid_uri (text)) {
seahorse_util_show_error (NULL, _("Not a valid Key Server address."),
_("For help contact your system administrator or the administrator of the key server." ));
return;
}
g_warn_if_fail (gtk_tree_model_get_iter_from_string (model, &iter, path));
gtk_tree_store_set (GTK_TREE_STORE (model), &iter, KEYSERVER_COLUMN, text, -1);
}
static void
on_change_password_done (GnomeKeyringResult result, gpointer user_data)
{
SeahorseCommands *self = SEAHORSE_COMMANDS (user_data);
SeahorseView *view;
if (result != GNOME_KEYRING_RESULT_OK &&
result != GNOME_KEYRING_RESULT_DENIED &&
result != GNOME_KEYRING_RESULT_CANCELLED) {
view = seahorse_commands_get_view (self);
seahorse_util_show_error (GTK_WIDGET (seahorse_view_get_window (view)),
_("Couldn't change keyring password"),
gnome_keyring_result_to_message (result));
}
refresh_all_keyrings (self);
}
static void
on_search_completed (GObject *source, GAsyncResult *result, gpointer user_data)
{
SeahorseKeyserverResults *self = SEAHORSE_KEYSERVER_RESULTS (user_data);
SeahorsePgpBackend *backend = seahorse_pgp_backend_get ();
g_autoptr(GError) error = NULL;
seahorse_pgp_backend_search_remote_finish (backend, result, &error);
if (error != NULL) {
g_dbus_error_strip_remote_error (error);
seahorse_util_show_error (GTK_WIDGET (self),
_("The search for keys failed."),
error->message);
}
g_object_unref (self);
}
G_MODULE_EXPORT void
on_gpgme_expire_ok_clicked (GtkButton *button,
gpointer user_data)
{
SeahorseWidget *swidget = SEAHORSE_WIDGET (user_data);
GtkWidget *widget;
SeahorseGpgmeSubkey *subkey;
gpgme_error_t err;
time_t expiry = 0;
struct tm when;
subkey = SEAHORSE_GPGME_SUBKEY (g_object_get_data (G_OBJECT (swidget), "subkey"));
widget = GTK_WIDGET (seahorse_widget_get_widget (swidget, "expire"));
if (!gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget))) {
memset (&when, 0, sizeof (when));
widget = GTK_WIDGET (seahorse_widget_get_widget (swidget, "calendar"));
gtk_calendar_get_date (GTK_CALENDAR (widget), (guint*)&(when.tm_year),
(guint*)&(when.tm_mon), (guint*)&(when.tm_mday));
when.tm_year -= 1900;
expiry = mktime (&when);
if (expiry <= time (NULL)) {
seahorse_util_show_error (widget, _("Invalid expiry date"),
_("The expiry date must be in the future"));
return;
}
}
widget = seahorse_widget_get_widget (swidget, "all-controls");
gtk_widget_set_sensitive (widget, FALSE);
g_object_ref (swidget);
g_object_ref (subkey);
if (expiry != (time_t)seahorse_pgp_subkey_get_expires (SEAHORSE_PGP_SUBKEY (subkey))) {
err = seahorse_gpgme_key_op_set_expires (subkey, expiry);
if (!GPG_IS_OK (err))
seahorse_gpgme_handle_error (err, _("Couldn't change expiry date"));
}
g_object_unref (subkey);
g_object_unref (swidget);
seahorse_widget_destroy (swidget);
}
static void
on_search_completed (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
SeahorseKeyserverResults *self = SEAHORSE_KEYSERVER_RESULTS (user_data);
GError *error = NULL;
GtkWindow *window;
seahorse_pgp_backend_search_remote_finish (NULL, result, &error);
if (error != NULL) {
window = seahorse_catalog_get_window (SEAHORSE_CATALOG (self));
g_dbus_error_strip_remote_error (error);
seahorse_util_show_error (GTK_WIDGET (window),
_("The search for keys failed."), error->message);
g_error_free (error);
}
g_object_unref (self);
}
/**
* seahorse_util_handle_error:
* @err: The #GError to print.
* @desc: The heading of the box
* @...: Parameters to insert into the format string desc.
*
* Displays an error box. The message is the error message.
*/
void
seahorse_util_handle_error (GError* err, const char* desc, ...)
{
gchar *t = NULL;
va_list ap;
if(!err)
return;
va_start(ap, desc);
if (desc)
t = g_strdup_vprintf (desc, ap);
va_end(ap);
seahorse_util_show_error (NULL, t, err->message ? err->message : "");
g_free(t);
}
static void
drag_end (GtkWidget *widget, GdkDragContext *context, SeahorseKeyManagerStore *skstore)
{
g_debug ("drag_end -->");
if (skstore->priv->drag_destination && !skstore->priv->drag_error)
export_to_directory (skstore, skstore->priv->drag_destination);
if (skstore->priv->drag_error) {
g_dbus_error_strip_remote_error (skstore->priv->drag_error);
seahorse_util_show_error (widget, _("Couldn't export keys"),
skstore->priv->drag_error->message);
}
g_clear_error (&skstore->priv->drag_error);
g_list_free (skstore->priv->drag_objects);
skstore->priv->drag_objects = NULL;
g_free (skstore->priv->drag_destination);
skstore->priv->drag_destination = NULL;
g_debug ("drag_end <--");
}
/**
* seahorse_util_handle_error:
* @error: The #GError to print, and clear
* @desc: The heading of the box
* @...: Parameters to insert into the format string desc.
*
* Displays an error box. The message is the error message.
* Won't display cancel errors.
*/
void
seahorse_util_handle_error (GError **error,
gpointer parent,
const char* description,
...)
{
gchar *text = NULL;
GtkWidget *widget = NULL;
va_list ap;
if (!error || !(*error) ||
g_error_matches (*error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) {
g_clear_error (error);
return;
}
va_start (ap, description);
if (description)
text = g_strdup_vprintf (description, ap);
va_end (ap);
if (parent == NULL)
widget = NULL;
else if (GTK_IS_WIDGET (parent))
widget = GTK_WIDGET (parent);
else if (GTK_IS_WINDOW (parent))
widget = GTK_WIDGET (parent);
else if (SEAHORSE_IS_WIDGET (parent))
widget = seahorse_widget_get_toplevel (parent);
else
g_warning ("unsupported 'parent' argument passed to seahorse_util_handle_error() ");
g_dbus_error_strip_remote_error (*error);
seahorse_util_show_error (widget, text,
(*error)->message ? (*error)->message : "");
g_free (text);
g_clear_error (error);
}
/**
* seahorse_util_uris_package
* @package: Package uri
* @uris: null-terminated array of uris to package
*
* Package uris into an archive. The uris must be local.
*
* Returns: Success or failure
*/
gboolean
seahorse_util_uris_package (const gchar* package, const char** uris)
{
GError* err = NULL;
gchar *out = NULL;
gint status;
gboolean r;
GString *str;
gchar *cmd;
gchar *t;
gchar *x;
GFile *file, *fpackage;
fpackage = g_file_new_for_uri (package);
t = g_file_get_path (fpackage);
x = g_shell_quote (t);
g_free (t);
/* create execution */
str = g_string_new ("");
g_string_printf (str, "file-roller --add-to=%s", x);
g_free(x);
while(*uris) {
x = g_uri_parse_scheme (*uris);
if (x)
file = g_file_new_for_uri (*uris);
else
file = g_file_new_for_path (*uris);
g_free (x);
t = g_file_get_path (file);
g_object_unref (file);
g_return_val_if_fail (t != NULL, FALSE);
x = g_shell_quote(t);
g_free(t);
g_string_append_printf (str, " %s", x);
g_free(x);
uris++;
}
/* Execute the command */
cmd = g_string_free (str, FALSE);
r = g_spawn_command_line_sync (cmd, &out, NULL, &status, &err);
g_free (cmd);
if (out) {
g_print (out, NULL);
g_free (out);
}
if (!r) {
seahorse_util_handle_error (err, _("Couldn't run file-roller"));
return FALSE;
}
if(!(WIFEXITED(status) && WEXITSTATUS(status) == 0)) {
seahorse_util_show_error(NULL, _("Couldn't package files"),
_("The file-roller process did not complete successfully"));
return FALSE;
}
t = g_file_get_path (fpackage);
if (t != NULL) {
g_chmod (t, S_IRUSR | S_IWUSR);
g_free (t);
}
return TRUE;
}
gboolean
seahorse_gpgme_photo_add (SeahorseGpgmeKey *pkey,
GtkWindow *parent,
const gchar *path)
{
gchar *filename = NULL;
gchar *tempfile = NULL;
GError *error = NULL;
gpgme_error_t gerr;
GtkWidget *chooser;
gboolean res = TRUE;
g_return_val_if_fail (SEAHORSE_IS_GPGME_KEY (pkey), FALSE);
if (NULL == path) {
chooser = gtk_file_chooser_dialog_new (_("Choose Photo to Add to Key"), parent,
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL);
gtk_dialog_set_default_response (GTK_DIALOG (chooser), GTK_RESPONSE_ACCEPT);
gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (chooser), TRUE);
add_image_files (chooser);
if (gtk_dialog_run (GTK_DIALOG (chooser)) == GTK_RESPONSE_ACCEPT)
filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (chooser));
gtk_widget_destroy (chooser);
if (!filename)
return FALSE;
} else {
filename = g_strdup (path);
}
if (!prepare_photo_id (parent, filename, &tempfile, &error)) {
seahorse_util_handle_error (&error, NULL, _("Couldn’t prepare photo"));
return FALSE;
}
gerr = seahorse_gpgme_key_op_photo_add (pkey, tempfile ? tempfile : filename);
if (!GPG_IS_OK (gerr)) {
/* A special error value set by seahorse_key_op_photoid_add to
denote an invalid format file */
if (gerr == GPG_E (GPG_ERR_USER_1))
seahorse_util_show_error (NULL, _("Couldn’t add photo"),
_("The file could not be loaded. It may be in an invalid format"));
else
seahorse_gpgme_handle_error (gerr, _("Couldn’t add photo"));
res = FALSE;
}
g_free (filename);
if (tempfile) {
unlink (tempfile);
g_free (tempfile);
}
return res;
}
