G_MODULE_EXPORT void
on_ssh_trust_toggled (GtkToggleButton *button, SeahorseWidget *swidget)
{
SeahorseSource *sksrc;
SeahorseOperation *op;
SeahorseObject *object;
SeahorseSSHKey *skey;
gboolean authorize;
GError *err = NULL;
object = SEAHORSE_OBJECT_WIDGET (swidget)->object;
skey = SEAHORSE_SSH_KEY (object);
sksrc = seahorse_object_get_source (object);
g_return_if_fail (SEAHORSE_IS_SSH_SOURCE (sksrc));
authorize = gtk_toggle_button_get_active (button);
gtk_widget_set_sensitive (GTK_WIDGET (button), FALSE);
op = seahorse_ssh_operation_authorize (SEAHORSE_SSH_SOURCE (sksrc), skey, authorize);
g_return_if_fail (op);
/* A very fast op, so just wait */
seahorse_operation_wait (op);
if (!seahorse_operation_is_successful (op)) {
seahorse_operation_copy_error (op, &err);
seahorse_util_handle_error (err, _("Couldn't change authorization for key."));
g_clear_error (&err);
}
gtk_widget_set_sensitive (GTK_WIDGET (button), TRUE);
}
static void
on_upload_complete (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
GError *error = NULL;
if (!seahorse_ssh_op_upload_finish (SEAHORSE_SSH_SOURCE (source), result, &error))
seahorse_util_handle_error (&error, NULL, _("Couldn't configure Secure Shell keys on remote computer."));
}
static void
on_import_complete (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
SeahorseCatalog *self = SEAHORSE_CATALOG (user_data);
GError *error = NULL;
if (!seahorse_pgp_backend_transfer_finish (SEAHORSE_PGP_BACKEND (source),
result, &error))
seahorse_util_handle_error (&error, seahorse_catalog_get_window (self),
_("Couldn't import keys"));
g_object_unref (self);
}
static void
complete_generate (SeahorsePkcs11Generate *self,
GError **error)
{
g_assert (error != NULL);
if (*error != NULL)
seahorse_util_handle_error (error, NULL, _("Couldn't generate private key"));
else
seahorse_place_load (SEAHORSE_PLACE (self->token), self->cancellable, NULL, NULL);
g_clear_object (&self->cancellable);
gck_attributes_unref (self->pub_attrs);
gck_attributes_unref (self->prv_attrs);
self->pub_attrs = self->prv_attrs = NULL;
}
static void
passphrase_done (SeahorseOperation *op, SeahorseWidget *swidget)
{
GError *err = NULL;
GtkWidget *w;
if (!seahorse_operation_is_successful (op)) {
seahorse_operation_copy_error (op, &err);
seahorse_util_handle_error (err, _("Couldn't change passphrase for key."));
g_clear_error (&err);
}
w = GTK_WIDGET (seahorse_widget_get_widget (swidget, "passphrase-button"));
g_return_if_fail (w != NULL);
gtk_widget_set_sensitive (w, TRUE);
}
G_MODULE_EXPORT void
on_ssh_export_button_clicked (GtkWidget *widget, SeahorseWidget *swidget)
{
SeahorseSource *sksrc;
SeahorseObject *object;
GFile *file;
GtkDialog *dialog;
guchar *results;
gsize n_results;
gchar* uri = NULL;
GError *err = NULL;
object = SEAHORSE_OBJECT_WIDGET (swidget)->object;
g_return_if_fail (SEAHORSE_IS_SSH_KEY (object));
sksrc = seahorse_object_get_source (object);
g_return_if_fail (SEAHORSE_IS_SSH_SOURCE (sksrc));
dialog = seahorse_util_chooser_save_new (_("Export Complete Key"),
GTK_WINDOW (seahorse_widget_get_toplevel (swidget)));
seahorse_util_chooser_show_key_files (dialog);
seahorse_util_chooser_set_filename (dialog, object);
uri = seahorse_util_chooser_save_prompt (dialog);
if (!uri)
return;
results = seahorse_ssh_source_export_private (SEAHORSE_SSH_SOURCE (sksrc),
SEAHORSE_SSH_KEY (object),
&n_results, &err);
if (results) {
g_return_if_fail (err == NULL);
file = g_file_new_for_uri (uri);
g_file_replace_contents_async (file, (gchar*)results, n_results, NULL, FALSE,
G_FILE_CREATE_PRIVATE, NULL,
(GAsyncReadyCallback)export_complete, results);
}
if (err) {
seahorse_util_handle_error (err, _("Couldn't export key."));
g_clear_error (&err);
}
g_free (uri);
}
static void
export_complete (GFile *file, GAsyncResult *result, guchar *contents)
{
GError *err = NULL;
gchar *uri, *unesc_uri;
g_free (contents);
if (!g_file_replace_contents_finish (file, result, NULL, &err)) {
uri = g_file_get_uri (file);
unesc_uri = g_uri_unescape_string (seahorse_util_uri_get_last (uri), NULL);
seahorse_util_handle_error (err, _("Couldn't export key to \"%s\""),
unesc_uri);
g_clear_error (&err);
g_free (uri);
g_free (unesc_uri);
}
}
G_MODULE_EXPORT void
on_ssh_comment_activate (GtkWidget *entry, SeahorseWidget *swidget)
{
SeahorseObject *object;
SeahorseSSHKey *skey;
SeahorseSource *sksrc;
SeahorseOperation *op;
const gchar *text;
gchar *comment;
GError *err = NULL;
object = SEAHORSE_OBJECT_WIDGET (swidget)->object;
skey = SEAHORSE_SSH_KEY (object);
sksrc = seahorse_object_get_source (object);
g_return_if_fail (SEAHORSE_IS_SSH_SOURCE (sksrc));
text = gtk_entry_get_text (GTK_ENTRY (entry));
/* Make sure not the same */
if (skey->keydata->comment && g_utf8_collate (text, skey->keydata->comment) == 0)
return;
gtk_widget_set_sensitive (entry, FALSE);
comment = g_strdup (text);
op = seahorse_ssh_operation_rename (SEAHORSE_SSH_SOURCE (sksrc), skey, comment);
g_free (comment);
/* This is usually a quick operation */
seahorse_operation_wait (op);
if (!seahorse_operation_is_successful (op)) {
seahorse_operation_copy_error (op, &err);
seahorse_util_handle_error (err, _("Couldn't rename key."));
g_clear_error (&err);
gtk_entry_set_text (GTK_ENTRY (entry), skey->keydata->comment ? skey->keydata->comment : "");
}
gtk_widget_set_sensitive (entry, TRUE);
}
int
seahorse_tool_files_process (SeahorseToolMode *mode, const gchar **uris)
{
const gchar *errdesc = NULL;
GError *err = NULL;
FilesCtx ctx;
int ret = 1;
memset (&ctx, 0, sizeof (ctx));
/* Start progress bar */
seahorse_tool_progress_start (mode->title);
if (!seahorse_tool_progress_update (-1, _("Preparing...")))
goto finally;
/*
* 1. Check all the uris, format them properly, and figure
* out what they are (ie: files, directories, size etc...)
*/
if (!step_check_uris (&ctx, uris, &err)) {
errdesc = _("Couldn't list files");
goto finally;
}
/*
* 2. Prompt user and see what they want to do
* with multiple files.
*/
if (mode->package) {
if (!step_process_multiple (&ctx, uris, &err)) {
errdesc = _("Couldn't package files");
goto finally;
}
}
if (!seahorse_tool_progress_check ())
goto finally;
/*
* 2. Expand remaining URIs, so we know what we're
* dealing with. This also gets file size info.
*/
if (!step_expand_uris (&ctx, &err)) {
errdesc = _("Couldn't list files");
goto finally;
}
if (!seahorse_tool_progress_update (0.0, NULL))
goto finally;
/*
* 3. Now execute enc operation on every file
*/
if (!step_operation (&ctx, mode, &err)) {
errdesc = mode->errmsg;
goto finally;
}
seahorse_tool_progress_update (1.0, NULL);
ret = 0;
finally:
seahorse_tool_progress_stop ();
if (err) {
seahorse_util_handle_error (err, errdesc, ctx.cur ?
g_file_info_get_display_name (ctx.cur->info) : "");
}
if (ctx.finfos) {
g_list_foreach (ctx.finfos, (GFunc)free_file_info, NULL);
g_list_free (ctx.finfos);
}
return ret;
}
/**
* 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;
}