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); }
/** * sort_objects_by_source: * @k1: the first seahorse object * @k2: The second seahorse object * * Sorts the seahorse objects by their source * * Returns: if source of k1<k2 it returns -1, * 1 will be returned if k1>k2. If the sources are equal it returns 0 */ static gint sort_objects_by_source (SeahorseObject *k1, SeahorseObject *k2) { SeahorseSource *sk1, *sk2; g_assert (SEAHORSE_IS_OBJECT (k1)); g_assert (SEAHORSE_IS_OBJECT (k2)); sk1 = seahorse_object_get_source (k1); sk2 = seahorse_object_get_source (k2); if (sk1 == sk2) return 0; return sk1 < sk2 ? -1 : 1; }
/** * seahorse_util_objects_splice: * @objects: A #GList of #SeahorseObject. Must be sorted * * Splices the list at the source disconuity * * Returns: The second part of the list. */ GList* seahorse_util_objects_splice (GList *objects) { SeahorseSource *psk = NULL; SeahorseSource *sk; GList *prev = NULL; /* Note that the objects must be sorted */ for ( ; objects; objects = g_list_next (objects)) { g_return_val_if_fail (SEAHORSE_IS_OBJECT (objects->data), NULL); sk = seahorse_object_get_source (SEAHORSE_OBJECT (objects->data)); /* Found a disconuity */ if (psk && sk != psk) { g_assert (prev != NULL); /* Break the list */ prev->next = NULL; /* And return the new list */ return objects; } psk = sk; prev = objects; } return NULL; }
/** * seahorse_context_take_object: * @sctx: The #SeahorseContext context to add an object to * @sobj: The #SeahorseObject object to add * * Adds @sobj to @sctx. If a similar object exists, it will be overwritten. * Emits the "added" signal. */ void seahorse_context_take_object (SeahorseContext *sctx, SeahorseObject *sobj) { gpointer ks; if (!sctx) sctx = seahorse_context_for_app (); g_return_if_fail (SEAHORSE_IS_CONTEXT (sctx)); g_return_if_fail (SEAHORSE_IS_OBJECT (sobj)); g_return_if_fail (seahorse_object_get_id (sobj) != 0); ks = hashkey_by_source (seahorse_object_get_source (sobj), seahorse_object_get_id (sobj)); g_return_if_fail (!g_hash_table_lookup (sctx->pv->objects_by_source, ks)); g_object_ref (sobj); g_object_set (sobj, "context", sctx, NULL); g_hash_table_replace (sctx->pv->objects_by_source, ks, sobj); setup_objects_by_type (sctx, sobj, TRUE); g_signal_emit (sctx, signals[ADDED], 0, sobj); g_object_unref (sobj); g_signal_connect (sobj, "notify", G_CALLBACK (object_notify), sctx); }
/** * seahorse_context_remove_object: * @sctx: The #SeahorseContext (can be NULL) * @sobj: The #SeahorseObject to remove * * Removes the object from the context * */ void seahorse_context_remove_object (SeahorseContext *sctx, SeahorseObject *sobj) { gconstpointer k; if (!sctx) sctx = seahorse_context_for_app (); g_return_if_fail (SEAHORSE_IS_CONTEXT (sctx)); g_return_if_fail (SEAHORSE_IS_OBJECT (sobj)); g_return_if_fail (seahorse_object_get_id (sobj) != 0); k = hashkey_by_source (seahorse_object_get_source (sobj), seahorse_object_get_id (sobj)); if (g_hash_table_lookup (sctx->pv->objects_by_source, k)) { g_return_if_fail (seahorse_object_get_context (sobj) == sctx); g_object_ref (sobj); g_signal_handlers_disconnect_by_func (sobj, object_notify, sctx); g_object_set (sobj, "context", NULL, NULL); g_hash_table_remove (sctx->pv->objects_by_source, k); setup_objects_by_type (sctx, sobj, FALSE); g_signal_emit (sctx, signals[REMOVED], 0, sobj); g_object_unref (sobj); } }
/** * seahorse_object_get_property: * @obj: The object to get the property for * @prop_id: The property requested * @value: out - the value as #GValue * @pspec: a #GParamSpec for the warning * * Returns: The property of the object @obj defined by the id @prop_id in @value. * */ static void seahorse_object_get_property (GObject *obj, guint prop_id, GValue *value, GParamSpec *pspec) { SeahorseObject *self = SEAHORSE_OBJECT (obj); switch (prop_id) { case PROP_CONTEXT: g_value_set_object (value, seahorse_object_get_context (self)); break; case PROP_SOURCE: g_value_set_object (value, seahorse_object_get_source (self)); break; case PROP_PREFERRED: g_value_set_object (value, seahorse_object_get_preferred (self)); break; case PROP_PARENT: g_value_set_object (value, seahorse_object_get_parent (self)); break; case PROP_ID: g_value_set_uint (value, seahorse_object_get_id (self)); break; case PROP_TAG: g_value_set_uint (value, seahorse_object_get_tag (self)); break; case PROP_LABEL: g_value_set_string (value, seahorse_object_get_label (self)); break; case PROP_NICKNAME: g_value_set_string (value, seahorse_object_get_nickname (self)); break; case PROP_MARKUP: g_value_set_string (value, seahorse_object_get_markup (self)); break; case PROP_DESCRIPTION: g_value_set_string (value, seahorse_object_get_description (self)); break; case PROP_ICON: g_value_set_string (value, seahorse_object_get_icon (self)); break; case PROP_IDENTIFIER: g_value_set_string (value, seahorse_object_get_identifier (self)); break; case PROP_LOCATION: g_value_set_enum (value, seahorse_object_get_location (self)); break; case PROP_USAGE: g_value_set_enum (value, seahorse_object_get_usage (self)); break; case PROP_FLAGS: g_value_set_uint (value, seahorse_object_get_flags (self)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, prop_id, pspec); break; } }
/** * key: a pointer to a key to verify (hashkey) * value: a seahorse object * user_data: ignored * * Asserts that the @key is the same as the one stored in @value * **/ static void verify_each_object (gpointer key, gpointer value, gpointer user_data) { gpointer k; g_assert (SEAHORSE_IS_OBJECT (value)); k = hashkey_by_source (seahorse_object_get_source (value), seahorse_object_get_id (value)); g_assert (k == key); }
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); }
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); }
/** * seahorse_context_transfer_objects: * @sctx: The #SeahorseContext (can be NULL) * @objects: the objects to import * @to: a source to import to (can be NULL) * * * * Returns: A transfer operation */ SeahorseOperation* seahorse_context_transfer_objects (SeahorseContext *sctx, GList *objects, SeahorseSource *to) { SeahorseSource *from; SeahorseOperation *op = NULL; SeahorseMultiOperation *mop = NULL; SeahorseObject *sobj; GSList *ids = NULL; GList *next, *l; GQuark ktype; if (!sctx) sctx = seahorse_context_for_app (); g_return_val_if_fail (SEAHORSE_IS_CONTEXT (sctx), NULL); objects = g_list_copy (objects); /* Sort by key source */ objects = seahorse_util_objects_sort (objects); while (objects) { /* break off one set (same keysource) */ next = seahorse_util_objects_splice (objects); g_assert (SEAHORSE_IS_OBJECT (objects->data)); sobj = SEAHORSE_OBJECT (objects->data); /* Export from this key source */ from = seahorse_object_get_source (sobj); g_return_val_if_fail (from != NULL, FALSE); ktype = seahorse_source_get_tag (from); /* Find a local keysource to import to */ if (!to) { to = seahorse_context_find_source (sctx, ktype, SEAHORSE_LOCATION_LOCAL); if (!to) { /* TODO: How can we warn caller about this. Do we need to? */ g_warning ("couldn't find a local source for: %s", g_quark_to_string (ktype)); } } /* Make sure it's the same type */ if (ktype != seahorse_source_get_tag (to)) { /* TODO: How can we warn caller about this. Do we need to? */ g_warning ("destination is not of type: %s", g_quark_to_string (ktype)); } if (to != NULL && from != to) { if (op != NULL) { if (mop == NULL) mop = seahorse_multi_operation_new (); seahorse_multi_operation_take (mop, op); } /* Build id list */ for (l = objects; l; l = g_list_next (l)) ids = g_slist_prepend (ids, GUINT_TO_POINTER (seahorse_object_get_id (l->data))); ids = g_slist_reverse (ids); /* Start a new transfer operation between the two sources */ op = seahorse_transfer_operation_new (NULL, from, to, ids); g_return_val_if_fail (op != NULL, FALSE); g_slist_free (ids); ids = NULL; } g_list_free (objects); objects = next; } /* No objects done, just return success */ if (!mop && !op) { g_warning ("no valid objects to transfer found"); return seahorse_operation_new_complete (NULL); } return mop ? SEAHORSE_OPERATION (mop) : op; }