/**
* 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);
}
/**
* sctx: The seahorse context to manipulate
* sobj: The object to add/remove
* add: TRUE if the object should be added
*
* Either adds or removes an object from sctx->pv->objects_by_type.
* The new list will be sorted by location.
*
**/
static void
setup_objects_by_type (SeahorseContext *sctx, SeahorseObject *sobj, gboolean add)
{
GList *l, *objects = NULL;
SeahorseObject *aobj, *next;
gpointer kt = GUINT_TO_POINTER (seahorse_object_get_id (sobj));
gboolean first;
/* Get current set of objects in this tag/id */
if (add)
objects = g_list_prepend (objects, sobj);
for (aobj = g_hash_table_lookup (sctx->pv->objects_by_type, kt);
aobj; aobj = seahorse_object_get_preferred (aobj))
{
if (aobj != sobj)
objects = g_list_prepend (objects, aobj);
}
/* No objects just remove */
if (!objects) {
g_hash_table_remove (sctx->pv->objects_by_type, kt);
return;
}
/* Sort and add back */
objects = g_list_sort (objects, sort_by_location);
for (l = objects, first = TRUE; l; l = g_list_next (l), first = FALSE) {
aobj = SEAHORSE_OBJECT (l->data);
/* Set first as start of list */
if (first)
g_hash_table_replace (sctx->pv->objects_by_type, kt, aobj);
/* Set next one as preferred */
else {
next = g_list_next (l) ? SEAHORSE_OBJECT (g_list_next (l)->data) : NULL;
seahorse_object_set_preferred (aobj, next);
}
}
g_list_free (objects);
}
/**
* data: optional, will be added to the title, can be NULL
* status: the gpgme status
*
* Basing on the status a notification is created an displayed
*
*/
static void
notify_signatures (const gchar* data, gpgme_verify_result_t status)
{
const gchar *icon = NULL;
SeahorseObject *object;
gchar *title, *body, *unesc_data;
gboolean sig = FALSE;
GSList *rawids;
GList *keys;
/* Discover the key in question */
rawids = g_slist_append (NULL, status->signatures->fpr);
keys = seahorse_context_discover_objects (SCTX_APP (), SEAHORSE_PGP, rawids);
g_slist_free (rawids);
g_return_if_fail (keys != NULL);
object = SEAHORSE_OBJECT (keys->data);
g_list_free (keys);
/* Figure out what to display */
switch (gpgme_err_code (status->signatures->status)) {
case GPG_ERR_KEY_EXPIRED:
/* TRANSLATORS: <key id='xxx'> is a custom markup tag, do not translate. */
body = _("Signed by <i><key id='%s'/> <b>expired</b></i> on %s.");
title = _("Invalid Signature");
icon = ICON_PREFIX "seahorse-sign-bad.png";
sig = TRUE;
break;
/* TRANSLATORS: <key id='xxx'> is a custom markup tag, do not translate. */
case GPG_ERR_SIG_EXPIRED:
body = _("Signed by <i><key id='%s'/></i> on %s <b>Expired</b>.");
title = _("Expired Signature");
icon = ICON_PREFIX "seahorse-sign-bad.png";
sig = TRUE;
break;
/* TRANSLATORS: <key id='xxx'> is a custom markup tag, do not translate. */
case GPG_ERR_CERT_REVOKED:
body = _("Signed by <i><key id='%s'/> <b>Revoked</b></i> on %s.");
title = _("Revoked Signature");
icon = ICON_PREFIX "seahorse-sign-bad.png";
sig = TRUE;
break;
case GPG_ERR_NO_ERROR:
/* TRANSLATORS: <key id='xxx'> is a custom markup tag, do not translate. */
body = _("Signed by <i><key id='%s'/></i> on %s.");
title = _("Good Signature");
icon = ICON_PREFIX "seahorse-sign-ok.png";
sig = TRUE;
break;
case GPG_ERR_NO_PUBKEY:
body = _("Signing key not in keyring.");
title = _("Unknown Signature");
icon = ICON_PREFIX "seahorse-sign-unknown.png";
break;
case GPG_ERR_BAD_SIGNATURE:
body = _("Bad or forged signature. The signed data was modified.");
title = _("Bad Signature");
icon = ICON_PREFIX "seahorse-sign-bad.png";
break;
case GPG_ERR_NO_DATA:
return;
default:
if (!GPG_IS_OK (status->signatures->status))
seahorse_gpgme_handle_error (status->signatures->status,
_("Couldn't verify signature."));
return;
};
if (sig) {
gchar *date = seahorse_util_get_display_date_string (status->signatures->timestamp);
gchar *id = seahorse_context_id_to_dbus (SCTX_APP (), seahorse_object_get_id (object));
body = g_markup_printf_escaped (body, id, date);
g_free (date);
g_free (id);
} else {
body = g_strdup (body);
}
if (data) {
data = seahorse_util_uri_get_last (data);
unesc_data = g_uri_unescape_string (data, NULL);
title = g_strdup_printf ("%s: %s", unesc_data, title);
g_free (unesc_data);
} else {
title = g_strdup (title);
}
seahorse_notification_display (title, body, !sig, icon, NULL);
g_free(title);
g_free(body);
}
/**
* seahorse_context_object_to_dbus:
* @sctx: A seahorse context
* @sobj: the object
*
* Translates an object to a string id
*
* Returns: The string id of the object. Free with #g_free
*/
gchar*
seahorse_context_object_to_dbus (SeahorseContext *sctx, SeahorseObject *sobj)
{
return seahorse_context_id_to_dbus (sctx, seahorse_object_get_id (sobj));
}
/**
* 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;
}