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;
}
