static void
on_collection_removed (GcrCollection *collection,
GObject *obj,
gpointer user_data)
{
ComboClosure *closure = g_object_get_data (user_data, "combo-keys-closure");
SeahorseObject *object = SEAHORSE_OBJECT (obj);
GtkComboBox *combo = GTK_COMBO_BOX (user_data);
GtkTreeModel *model;
GtkTreeIter iter;
gchar *previous;
gpointer pntr;
gboolean valid;
model = gtk_combo_box_get_model (combo);
valid = gtk_tree_model_get_iter_first (model, &iter);
while (valid) {
gtk_tree_model_get (model, &iter,
COMBO_LABEL, &previous,
COMBO_POINTER, &pntr,
-1);
if (SEAHORSE_OBJECT (pntr) == object) {
g_hash_table_remove (closure->labels, previous);
gtk_list_store_remove (GTK_LIST_STORE (model), &iter);
break;
}
g_free (previous);
valid = gtk_tree_model_iter_next (model, &iter);
}
g_signal_handlers_disconnect_by_func (object, on_label_changed, combo);
}
void
seahorse_gpgme_add_revoker_new (SeahorseGpgmeKey *pkey, GtkWindow *parent)
{
SeahorseGpgmeKey *revoker;
GtkWidget *dialog;
gint response;
gpgme_error_t err;
const gchar *userid1, *userid2;
g_return_if_fail (pkey != NULL && SEAHORSE_IS_GPGME_KEY (pkey));
revoker = SEAHORSE_GPGME_KEY (seahorse_signer_get (parent));
if (revoker == NULL)
return;
userid1 = seahorse_object_get_label (SEAHORSE_OBJECT (revoker));
userid2 = seahorse_object_get_label (SEAHORSE_OBJECT (pkey));
dialog = gtk_message_dialog_new (parent, GTK_DIALOG_MODAL,
GTK_MESSAGE_WARNING, GTK_BUTTONS_YES_NO,
_("You are about to add %s as a revoker for %s."
" This operation cannot be undone! Are you sure you want to continue?"),
userid1, userid2);
response = gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
if (response != GTK_RESPONSE_YES)
return;
err = seahorse_gpgme_key_op_add_revoker (pkey, revoker);
if (!GPG_IS_OK (err))
seahorse_gpgme_handle_error (err, _("Couldn't add revoker"));
}
/**
* a: the first #SeahorseObject
* b: the second #SeahorseObject
*
* Compares the locations of the two objects
*
* Returns 0 if a==b, -1 or 1 on difference
**/
static gint
sort_by_location (gconstpointer a, gconstpointer b)
{
guint aloc, bloc;
g_assert (SEAHORSE_IS_OBJECT (a));
g_assert (SEAHORSE_IS_OBJECT (b));
aloc = seahorse_object_get_location (SEAHORSE_OBJECT (a));
bloc = seahorse_object_get_location (SEAHORSE_OBJECT (b));
if (aloc == bloc)
return 0;
return aloc > bloc ? -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;
}
static void
on_collection_added (GcrCollection *collection,
GObject *obj,
gpointer user_data)
{
SeahorseObject *object = SEAHORSE_OBJECT (obj);
GtkComboBox *combo = GTK_COMBO_BOX (user_data);
GtkListStore *model;
GtkTreeIter iter;
const gchar *label;
gchar *markup;
model = GTK_LIST_STORE (gtk_combo_box_get_model (combo));
label = seahorse_object_get_label (object);
markup = calculate_markup_for_object (combo, label, object);
gtk_list_store_append (model, &iter);
gtk_list_store_set (model, &iter,
COMBO_LABEL, label,
COMBO_MARKUP, markup,
COMBO_POINTER, object,
-1);
g_free (markup);
g_signal_connect (object, "notify::label", G_CALLBACK (on_label_changed), combo);
}
/**
* seahorse_object_finalize:
* @obj: #SeahorseObject to finalize
*
*/
static void
seahorse_object_finalize (GObject *obj)
{
SeahorseObject *self = SEAHORSE_OBJECT (obj);
g_assert (self->pv->source == NULL);
g_assert (self->pv->preferred == NULL);
g_assert (self->pv->parent == NULL);
g_assert (self->pv->context == NULL);
g_assert (self->pv->children == NULL);
g_free (self->pv->label);
self->pv->label = NULL;
g_free (self->pv->markup);
self->pv->markup = NULL;
g_free (self->pv->nickname);
self->pv->nickname = NULL;
g_free (self->pv->description);
self->pv->description = NULL;
g_free (self->pv->icon);
self->pv->icon = NULL;
g_free (self->pv->identifier);
self->pv->identifier = NULL;
G_OBJECT_CLASS (seahorse_object_parent_class)->finalize (obj);
}
/**
* 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;
}
}
/**
* 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);
}
static void
add_key (SeahorseHKPSource *ssrc, SeahorsePgpKey *key)
{
SeahorseObject *prev;
GQuark keyid;
keyid = seahorse_pgp_key_canonize_id (seahorse_pgp_key_get_keyid (key));
prev = seahorse_context_get_object (SCTX_APP (), SEAHORSE_SOURCE (ssrc), keyid);
if (prev != NULL) {
g_return_if_fail (SEAHORSE_IS_PGP_KEY (prev));
seahorse_pgp_key_set_uids (SEAHORSE_PGP_KEY (prev), seahorse_pgp_key_get_uids (key));
seahorse_pgp_key_set_subkeys (SEAHORSE_PGP_KEY (prev), seahorse_pgp_key_get_subkeys (key));
return;
}
/* Add to context */
seahorse_object_set_source (SEAHORSE_OBJECT (key), SEAHORSE_SOURCE (ssrc));
seahorse_context_add_object (SCTX_APP (), SEAHORSE_OBJECT (key));
}
static void
on_label_changed (GObject *obj,
GParamSpec *param,
gpointer user_data)
{
SeahorseObject *object = SEAHORSE_OBJECT (obj);
GtkComboBox *combo = GTK_COMBO_BOX (user_data);
ComboClosure *closure;
GtkTreeModel *model;
GtkTreeIter iter;
gboolean valid;
gchar *previous;
gchar *markup;
gpointer pntr;
const gchar *label;
closure = g_object_get_data (G_OBJECT (combo), "combo-keys-closure");
model = gtk_combo_box_get_model (combo);
valid = gtk_tree_model_get_iter_first (model, &iter);
while (valid) {
gtk_tree_model_get (model, &iter, COMBO_POINTER, &pntr, COMBO_LABEL, &previous, -1);
if (SEAHORSE_OBJECT (pntr) == object) {
/* Remove this from label collision checks */
g_hash_table_remove (closure->labels, previous);
/* Calculate markup taking into account label collisions */
label = seahorse_object_get_label (object);
markup = calculate_markup_for_object (combo, label, object);
gtk_list_store_set (GTK_LIST_STORE (model), &iter,
COMBO_LABEL, label,
COMBO_MARKUP, markup,
-1);
g_free (markup);
break;
}
g_free (previous);
valid = gtk_tree_model_iter_next (model, &iter);
}
}
/**
* seahorse_context_get_object:
* @sctx: The #SeahorseContext to look in
* @sksrc: The source to match
* @id: the id to match
*
* Finds the object with the source @sksrc and @id in the context and returns it
*
* Returns: The matching object
*/
SeahorseObject*
seahorse_context_get_object (SeahorseContext *sctx, SeahorseSource *sksrc,
GQuark id)
{
gconstpointer k;
if (!sctx)
sctx = seahorse_context_for_app ();
g_return_val_if_fail (SEAHORSE_IS_CONTEXT (sctx), NULL);
g_return_val_if_fail (SEAHORSE_IS_SOURCE (sksrc), NULL);
k = hashkey_by_source (sksrc, id);
return SEAHORSE_OBJECT (g_hash_table_lookup (sctx->pv->objects_by_source, k));
}
/**
* seahorse_object_dispose:
* @obj: A #SeahorseObject to dispose
*
* Before this object is disposed, all it's children get new parents
*
*/
static void
seahorse_object_dispose (GObject *obj)
{
SeahorseObject *self = SEAHORSE_OBJECT (obj);
SeahorseObject *parent;
GList *l, *children;
if (self->pv->context != NULL) {
seahorse_context_remove_object (self->pv->context, self);
g_assert (self->pv->context == NULL);
}
if (self->pv->source != NULL) {
g_object_remove_weak_pointer (G_OBJECT (self->pv->source), (gpointer*)&self->pv->source);
self->pv->source = NULL;
}
if (self->pv->preferred != NULL) {
g_object_remove_weak_pointer (G_OBJECT (self->pv->source), (gpointer*)&self->pv->preferred);
self->pv->preferred = NULL;
}
/*
* When an object is destroyed, we reparent all
* children to this objects parent. If no parent
* of this object, all children become root objects.
*/
parent = self->pv->parent;
if (parent)
g_object_ref (parent);
children = g_list_copy (self->pv->children);
for (l = children; l; l = g_list_next (l)) {
g_return_if_fail (SEAHORSE_IS_OBJECT (l->data));
seahorse_object_set_parent (l->data, parent);
}
g_list_free (children);
if (parent)
g_object_unref (parent);
g_assert (self->pv->children == NULL);
/* Now remove this object from its parent */
seahorse_object_set_parent (self, NULL);
G_OBJECT_CLASS (seahorse_object_parent_class)->dispose (obj);
}
void
seahorse_pgp_uid_set_comment (SeahorsePgpUid *self, const gchar *comment)
{
GObject *obj;
g_return_if_fail (SEAHORSE_IS_PGP_UID (self));
g_free (self->pv->comment);
self->pv->comment = convert_string (comment);
obj = G_OBJECT (self);
g_object_freeze_notify (obj);
if (self->pv->realized)
seahorse_pgp_uid_realize (SEAHORSE_OBJECT (self));
g_object_notify (obj, "comment");
g_object_thaw_notify (obj);
}
/**
* find_matching_objects:
* @key: ignored
* @sobj: the object to match
* @km: an #ObjectMatcher
*
* Calls km->func for every matched object
*
* Returns: TRUE if the search terminates, FALSE if there could be another
* match or nothing was found
*/
gboolean
find_matching_objects (gpointer key, SeahorseObject *sobj, ObjectMatcher *km)
{
gboolean matched;
if (km->kp && seahorse_object_predicate_match (km->kp, SEAHORSE_OBJECT (sobj))) {
matched = TRUE;
(km->func) (sobj, km->user_data);
}
/* Terminate search */
if (!km->many && matched)
return TRUE;
/* Keep going */
return FALSE;
}
static void
on_deleted (GP11Object *object, GAsyncResult *result, SeahorsePkcs11Deleter *self)
{
GError *err = NULL;
g_return_if_fail (SEAHORSE_IS_PKCS11_DELETER (self));
if (!gp11_object_destroy_finish (object, result, &err)) {
/* Ignore objects that have gone away */
if (err->code != CKR_OBJECT_HANDLE_INVALID) {
seahorse_pkcs11_mark_complete (SEAHORSE_OPERATION (self), err);
return;
}
g_error_free (err);
}
seahorse_context_remove_object (NULL, SEAHORSE_OBJECT (self->object));
seahorse_pkcs11_mark_complete (SEAHORSE_OPERATION (self), NULL);
}
guint
seahorse_pgp_signature_get_sigtype (SeahorsePgpSignature *self)
{
SeahorseGpgmeKeyring *keyring;
SeahorseGpgmeKey *key;
SeahorseObject *obj;
g_return_val_if_fail (SEAHORSE_IS_PGP_SIGNATURE (self), 0);
keyring = seahorse_pgp_backend_get_default_keyring (NULL);
key = seahorse_gpgme_keyring_lookup (keyring, self->pv->keyid);
if (key != NULL) {
obj = SEAHORSE_OBJECT (key);
if (seahorse_object_get_usage (obj) == SEAHORSE_USAGE_PRIVATE_KEY)
return SKEY_PGPSIG_TRUSTED | SKEY_PGPSIG_PERSONAL;
if (seahorse_object_get_flags (obj) & SEAHORSE_FLAG_TRUSTED)
return SKEY_PGPSIG_TRUSTED;
}
return 0;
}
/**
* seahorse_context_remove_source:
* @sctx: Context to remove objects from
* @sksrc: The source to remove
*
* Remove all objects from source @sksrc from the #SeahorseContext @sctx
*
*/
void
seahorse_context_remove_source (SeahorseContext *sctx, SeahorseSource *sksrc)
{
GList *l, *objects;
g_return_if_fail (SEAHORSE_IS_SOURCE (sksrc));
if (!sctx)
sctx = seahorse_context_for_app ();
g_return_if_fail (SEAHORSE_IS_CONTEXT (sctx));
if (!g_slist_find (sctx->pv->sources, sksrc))
return;
/* Remove all objects from this source */
objects = seahorse_context_get_objects (sctx, sksrc);
for (l = objects; l; l = g_list_next (l))
seahorse_context_remove_object (sctx, SEAHORSE_OBJECT (l->data));
/* Remove the source itself */
sctx->pv->sources = g_slist_remove (sctx->pv->sources, sksrc);
g_object_unref (sksrc);
}
/**
* seahorse_util_filename_for_objects:
* @objects: A list of objects
*
* If the single object has a nickname, this will be returned (with .asc attached)
* If there are multiple objects, "Multiple Keys.asc" will be returned.
* Single objects default to "Key Data.asc".
* Results are internationalized
*
* Returns: NULL on error, the filename else. The returned string should be
* freed with #g_free when no longer needed.
*/
gchar*
seahorse_util_filename_for_objects (GList *objects)
{
SeahorseObject *object;
const gchar *name;
gchar *filename;
g_return_val_if_fail (g_list_length (objects) > 0, NULL);
if (g_list_length (objects) == 1) {
g_return_val_if_fail (SEAHORSE_IS_OBJECT (objects->data), NULL);
object = SEAHORSE_OBJECT (objects->data);
name = seahorse_object_get_nickname (object);
if (name == NULL)
name = _("Key Data");
} else {
name = _("Multiple Keys");
}
filename = g_strconcat (name, SEAHORSE_EXT_ASC, NULL);
g_strstrip (filename);
g_strdelimit (filename, bad_filename_chars, '_');
return filename;
}
/**
* 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;
}
/**
* seahorse_object_set_property:
* @obj: Object to set the property in
* @prop_id: the property to set
* @value: the value to set
* @pspec: To be used for warnings. #GParamSpec
*
* Sets a property in this object
*
*/
static void
seahorse_object_set_property (GObject *obj, guint prop_id, const GValue *value,
GParamSpec *pspec)
{
SeahorseObject *self = SEAHORSE_OBJECT (obj);
SeahorseLocation loc;
SeahorseUsage usage;
guint flags;
GQuark quark;
switch (prop_id) {
case PROP_CONTEXT:
if (self->pv->context)
g_object_remove_weak_pointer (G_OBJECT (self->pv->context), (gpointer*)&self->pv->context);
self->pv->context = SEAHORSE_CONTEXT (g_value_get_object (value));
if (self->pv->context != NULL)
g_object_add_weak_pointer (G_OBJECT (self->pv->context), (gpointer*)&self->pv->context);
g_object_notify (G_OBJECT (self), "context");
break;
case PROP_SOURCE:
seahorse_object_set_source (self, SEAHORSE_SOURCE (g_value_get_object (value)));
break;
case PROP_PREFERRED:
seahorse_object_set_preferred (self, SEAHORSE_OBJECT (g_value_get_object (value)));
break;
case PROP_PARENT:
seahorse_object_set_parent (self, SEAHORSE_OBJECT (g_value_get_object (value)));
break;
case PROP_ID:
quark = g_value_get_uint (value);
if (quark != self->pv->id) {
self->pv->id = quark;
g_object_freeze_notify (obj);
g_object_notify (obj, "id");
recalculate_id (self);
g_object_thaw_notify (obj);
}
break;
case PROP_TAG:
quark = g_value_get_uint (value);
if (quark != self->pv->tag) {
self->pv->tag = quark;
self->pv->tag_explicit = TRUE;
g_object_notify (obj, "tag");
}
break;
case PROP_LABEL:
if (set_string_storage (g_value_get_string (value), &self->pv->label)) {
g_object_freeze_notify (obj);
g_object_notify (obj, "label");
recalculate_label (self);
g_object_thaw_notify (obj);
}
break;
case PROP_NICKNAME:
if (set_string_storage (g_value_get_string (value), &self->pv->nickname)) {
self->pv->nickname_explicit = TRUE;
g_object_notify (obj, "nickname");
}
break;
case PROP_MARKUP:
if (set_string_storage (g_value_get_string (value), &self->pv->markup)) {
self->pv->markup_explicit = TRUE;
g_object_notify (obj, "markup");
}
break;
case PROP_DESCRIPTION:
if (set_string_storage (g_value_get_string (value), &self->pv->description)) {
self->pv->description_explicit = TRUE;
g_object_notify (obj, "description");
}
break;
case PROP_ICON:
if (set_string_storage (g_value_get_string (value), &self->pv->icon))
g_object_notify (obj, "icon");
break;
case PROP_IDENTIFIER:
if (set_string_storage (g_value_get_string (value), &self->pv->identifier)) {
self->pv->identifier_explicit = TRUE;
g_object_notify (obj, "identifier");
}
break;
case PROP_LOCATION:
loc = g_value_get_enum (value);
if (loc != self->pv->location) {
self->pv->location = loc;
g_object_notify (obj, "location");
}
break;
case PROP_USAGE:
usage = g_value_get_enum (value);
if (usage != self->pv->usage) {
self->pv->usage = usage;
g_object_freeze_notify (obj);
g_object_notify (obj, "usage");
recalculate_usage (self);
g_object_thaw_notify (obj);
}
break;
case PROP_FLAGS:
flags = g_value_get_uint (value);
flags &= ~SEAHORSE_FLAG_DELETABLE;
if (flags != self->pv->flags) {
self->pv->flags = flags;
g_object_notify (obj, "flags");
}
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, prop_id, pspec);
break;
}
}
/**
* 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);
}
void
seahorse_gpgme_add_subkey_new (SeahorseGpgmeKey *pkey, GtkWindow *parent)
{
SeahorseWidget *swidget;
GtkComboBox* combo;
GtkTreeModel *model;
GtkTreeIter iter;
GtkCellRenderer *renderer;
GtkWidget *widget, *datetime;
swidget = seahorse_object_widget_new ("add-subkey", parent, G_OBJECT (pkey));
g_return_if_fail (swidget != NULL);
gtk_window_set_title (GTK_WINDOW (seahorse_widget_get_widget (swidget, swidget->name)),
g_strdup_printf (_("Add subkey to %s"), seahorse_object_get_label (SEAHORSE_OBJECT (pkey))));
combo = GTK_COMBO_BOX (seahorse_widget_get_widget (swidget, "type"));
model = GTK_TREE_MODEL (gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_INT));
gtk_combo_box_set_model (combo, model);
gtk_cell_layout_clear (GTK_CELL_LAYOUT (combo));
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), renderer, TRUE);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (combo), renderer,
"text", COMBO_STRING);
gtk_list_store_append (GTK_LIST_STORE (model), &iter);
gtk_list_store_set (GTK_LIST_STORE (model), &iter,
COMBO_STRING, _("DSA (sign only)"),
COMBO_INT, 0,
-1);
gtk_combo_box_set_active_iter (combo, &iter);
gtk_list_store_append (GTK_LIST_STORE (model), &iter);
gtk_list_store_set (GTK_LIST_STORE (model), &iter,
COMBO_STRING, _("ElGamal (encrypt only)"),
COMBO_INT, 1,
-1);
gtk_list_store_append (GTK_LIST_STORE (model), &iter);
gtk_list_store_set (GTK_LIST_STORE (model), &iter,
COMBO_STRING, _("RSA (sign only)"),
COMBO_INT, 2,
-1);
gtk_list_store_append (GTK_LIST_STORE (model), &iter);
gtk_list_store_set (GTK_LIST_STORE (model), &iter,
COMBO_STRING, _("RSA (encrypt only)"),
COMBO_INT, 3,
-1);
widget = seahorse_widget_get_widget (swidget, "datetime-placeholder");
g_return_if_fail (widget != NULL);
datetime = egg_datetime_new ();
gtk_container_add (GTK_CONTAINER (widget), datetime);
gtk_widget_show (datetime);
gtk_widget_set_sensitive (datetime, FALSE);
g_object_set_data (G_OBJECT (swidget), "expires-datetime", datetime);
}
/**
* seahorse_object_get_nth_child:
* @self: Object
* @index: the number of the child to return
*
* Returns: the child number @index
*/
SeahorseObject*
seahorse_object_get_nth_child (SeahorseObject *self, guint index)
{
g_return_val_if_fail (SEAHORSE_IS_OBJECT (self), NULL);
return SEAHORSE_OBJECT (g_list_nth_data (self->pv->children, index));
}
/**
* crypto: the crypto service (#SeahorseServiceCrypto)
* recipients: A list of recipients (keyids "openpgp:B8098FB063E2C811")
* signer: optional, the keyid of the signer
* flags: 0, not used
* cleartext: the text to encrypt
* clearlength: Length of the cleartext
* crypttext: the encrypted text (out)
* cryptlength: the length of this text (out)
* textmode: TRUE if gpgme should use textmode
* ascii_armor: TRUE if GPGME should use ascii armor
* error: The Error
*
* Handles encryption in a generic way. Can be used by several DBus APIs
*
* Returns TRUE on success
**/
static gboolean
crypto_encrypt_generic (SeahorseServiceCrypto *crypto,
const char **recipients, const char *signer,
int flags, const char *cleartext, gsize clearlength,
char **crypttext, gsize *cryptlength, gboolean textmode,
gboolean ascii_armor, GError **error)
{
GList *recipkeys = NULL;
SeahorseGpgmeOperation *pop;
SeahorseObject *signkey = NULL;
SeahorseObject *skey;
gpgme_key_t *recips;
gpgme_data_t plain, cipher;
gpgme_error_t gerr;
gboolean ret = TRUE;
/*
* TODO: Once we support different kinds of keys that support encryption
* then all this logic will need to change.
*/
/* The signer */
if (signer && signer[0]) {
signkey = seahorse_context_object_from_dbus (SCTX_APP (), signer);
if (!signkey) {
g_set_error (error, SEAHORSE_DBUS_ERROR, SEAHORSE_DBUS_ERROR_INVALID,
_("Invalid or unrecognized signer: %s"), signer);
return FALSE;
}
if (!SEAHORSE_IS_GPGME_KEY (signkey) ||
!(seahorse_object_get_flags (signkey) & SEAHORSE_FLAG_CAN_SIGN)) {
g_set_error (error, SEAHORSE_DBUS_ERROR, SEAHORSE_DBUS_ERROR_INVALID,
_("Key is not valid for signing: %s"), signer);
return FALSE;
}
}
/* The recipients */
for( ; recipients[0]; recipients++)
{
skey = seahorse_context_object_from_dbus (SCTX_APP (), recipients[0]);
if (!skey) {
g_list_free (recipkeys);
g_set_error (error, SEAHORSE_DBUS_ERROR, SEAHORSE_DBUS_ERROR_INVALID,
_("Invalid or unrecognized recipient: %s"), recipients[0]);
return FALSE;
}
if (!SEAHORSE_IS_GPGME_KEY (skey) ||
!(seahorse_object_get_flags (skey) & SEAHORSE_FLAG_CAN_ENCRYPT)) {
g_list_free (recipkeys);
g_set_error (error, SEAHORSE_DBUS_ERROR, SEAHORSE_DBUS_ERROR_INVALID,
_("Key is not a valid recipient for encryption: %s"), recipients[0]);
return FALSE;
}
recipkeys = g_list_prepend (recipkeys, SEAHORSE_PGP_KEY (skey));
}
if (!recipkeys) {
g_set_error (error, SEAHORSE_DBUS_ERROR, SEAHORSE_DBUS_ERROR_INVALID,
_("No recipients specified"));
return FALSE;
}
pop = seahorse_gpgme_operation_new (NULL);
/* new data form text */
gerr = gpgme_data_new_from_mem (&plain, cleartext, clearlength, FALSE);
g_return_val_if_fail (GPG_IS_OK (gerr), FALSE);
gerr = gpgme_data_new (&cipher);
g_return_val_if_fail (GPG_IS_OK (gerr), FALSE);
/* encrypt with armor */
gpgme_set_textmode (pop->gctx, textmode);
gpgme_set_armor (pop->gctx, ascii_armor);
/* Add the default key if set and necessary */
if (seahorse_gconf_get_boolean (ENCRYPTSELF_KEY)) {
skey = SEAHORSE_OBJECT (seahorse_context_get_default_key (SCTX_APP ()));
if (SEAHORSE_IS_PGP_KEY (skey))
recipkeys = g_list_append (recipkeys, skey);
}
/* Make keys into the right format for GPGME */
recips = keylist_to_keys (recipkeys);
g_list_free (recipkeys);
/* Do the encryption */
if (signkey) {
gpgme_signers_add (pop->gctx, seahorse_gpgme_key_get_private (SEAHORSE_GPGME_KEY (signkey)));
gerr = gpgme_op_encrypt_sign_start (pop->gctx, recips, GPGME_ENCRYPT_ALWAYS_TRUST,
plain, cipher);
} else {
gerr = gpgme_op_encrypt_start (pop->gctx, recips, GPGME_ENCRYPT_ALWAYS_TRUST,
plain, cipher);
}
free_keys (recips);
/* Frees cipher */
ret = process_crypto_result (pop, gerr, cipher, crypttext, cryptlength, error);
g_object_unref (pop);
gpgme_data_release (plain);
return ret;
}