/**
* seahorse_context_find_source:
* @sctx: A #SeahorseContext
* @ktype: A seahorse tag (SEAHORSE_TAG_INVALID is wildcard)
* @location: A location (SEAHORSE_LOCATION_INVALID is wildcard)
*
* Finds a context where @ktype and @location match
*
* Returns: The context
*/
SeahorseSource*
seahorse_context_find_source (SeahorseContext *sctx, GQuark ktype,
SeahorseLocation location)
{
SeahorseSource *ks;
GSList *l;
if (!sctx)
sctx = seahorse_context_for_app ();
g_return_val_if_fail (SEAHORSE_IS_CONTEXT (sctx), NULL);
for (l = sctx->pv->sources; l; l = g_slist_next (l)) {
ks = SEAHORSE_SOURCE (l->data);
if (ktype != SEAHORSE_TAG_INVALID &&
seahorse_source_get_tag (ks) != ktype)
continue;
if (location != SEAHORSE_LOCATION_INVALID &&
seahorse_source_get_location (ks) != location)
continue;
return ks;
}
/* If we don't have an unknown source for this type, create it */
if (location == SEAHORSE_LOCATION_MISSING && location != SEAHORSE_TAG_INVALID) {
ks = SEAHORSE_SOURCE (seahorse_unknown_source_new (ktype));
seahorse_context_add_source (sctx, ks);
return ks;
}
return NULL;
}
static GObject*
seahorse_pkcs11_refresher_constructor (GType type, guint n_props, GObjectConstructParam *props)
{
SeahorsePkcs11Refresher *self = SEAHORSE_PKCS11_REFRESHER (G_OBJECT_CLASS (seahorse_pkcs11_refresher_parent_class)->constructor(type, n_props, props));
GP11Slot *slot;
GList *objects, *l;
gulong handle;
g_return_val_if_fail (self, NULL);
g_return_val_if_fail (self->source, NULL);
objects = seahorse_context_get_objects (NULL, SEAHORSE_SOURCE (self->source));
for (l = objects; l; l = g_list_next (l)) {
if (g_object_class_find_property (G_OBJECT_GET_CLASS (l->data), "pkcs11-handle")) {
g_object_get (l->data, "pkcs11-handle", &handle, NULL);
g_hash_table_insert (self->checks, g_memdup (&handle, sizeof (handle)), g_object_ref (l->data));
}
}
g_list_free (objects);
/* Step 1. Load the session */
slot = seahorse_pkcs11_source_get_slot (self->source);
gp11_slot_open_session_async (slot, CKF_RW_SESSION, NULL, NULL, self->cancellable,
(GAsyncReadyCallback)on_open_session, self);
seahorse_operation_mark_start (SEAHORSE_OPERATION (self));
return G_OBJECT (self);
}
/* dispose of all our internal references */
static void
seahorse_server_source_dispose (GObject *gobject)
{
SeahorseServerSource *ssrc;
SeahorseSource *sksrc;
/*
* Note that after this executes the rest of the object should
* still work without a segfault. This basically nullifies the
* object, but doesn't free it.
*
* This function should also be able to run multiple times.
*/
ssrc = SEAHORSE_SERVER_SOURCE (gobject);
sksrc = SEAHORSE_SOURCE (gobject);
g_assert (ssrc->priv);
/* Clear out all the operations */
if (ssrc->priv->mop) {
if(seahorse_operation_is_running (SEAHORSE_OPERATION (ssrc->priv->mop)))
seahorse_operation_cancel (SEAHORSE_OPERATION (ssrc->priv->mop));
g_object_unref (ssrc->priv->mop);
ssrc->priv->mop = NULL;
}
G_OBJECT_CLASS (parent_class)->dispose (gobject);
}
/**
* seahorse_context_find_sources:
* @sctx: the context to work with
* @ktype: the type of the key to match. Or SEAHORSE_TAG_INVALID
* @location: the location to match. Or SEAHORSE_LOCATION_INVALID
*
* Returns: A list of seahorse sources matching @ktype and @location as #GSList. Must
* be freed with #g_slist_free
*/
GSList*
seahorse_context_find_sources (SeahorseContext *sctx, GQuark ktype,
SeahorseLocation location)
{
SeahorseSource *ks;
GSList *sources = NULL;
GSList *l;
if (!sctx)
sctx = seahorse_context_for_app ();
g_return_val_if_fail (SEAHORSE_IS_CONTEXT (sctx), NULL);
for (l = sctx->pv->sources; l; l = g_slist_next (l)) {
ks = SEAHORSE_SOURCE (l->data);
if (ktype != SEAHORSE_TAG_INVALID &&
seahorse_source_get_tag (ks) != ktype)
continue;
if (location != SEAHORSE_LOCATION_INVALID &&
seahorse_source_get_location (ks) != location)
continue;
sources = g_slist_append (sources, ks);
}
return sources;
}
/**
* seahorse_context_refresh_auto:
* @sctx: A #SeahorseContext (can be NULL)
*
* Starts a new refresh operation and emits the "refreshing" signal
*
*/
void
seahorse_context_refresh_auto (SeahorseContext *sctx)
{
SeahorseSource *ks;
SeahorseOperation *op = NULL;
GSList *l;
if (!sctx)
sctx = seahorse_context_for_app ();
g_return_if_fail (SEAHORSE_IS_CONTEXT (sctx));
if (!sctx->pv->refresh_ops)
sctx->pv->refresh_ops = seahorse_multi_operation_new ();
for (l = sctx->pv->sources; l; l = g_slist_next (l)) {
ks = SEAHORSE_SOURCE (l->data);
if (seahorse_source_get_location (ks) == SEAHORSE_LOCATION_LOCAL) {
op = seahorse_source_load (ks);
g_return_if_fail (op);
seahorse_multi_operation_take (sctx->pv->refresh_ops, op);
}
}
g_signal_emit (sctx, signals[REFRESHING], 0, sctx->pv->refresh_ops);
}
/**
* seahorse_context_remote_source:
* @sctx: the context to add the source to (can be NULL)
* @uri: An URI to add as remote source
*
* Add a remote source to the Context @sctx. If it already exists, the source
* object will be returned.
*
* Returns: The #SeahorseSource with this URI
*/
SeahorseSource*
seahorse_context_remote_source (SeahorseContext *sctx, const gchar *uri)
{
SeahorseSource *ks = NULL;
gboolean found = FALSE;
gchar *ks_uri;
GSList *l;
g_return_val_if_fail (uri && *uri, NULL);
if (!sctx)
sctx = seahorse_context_for_app ();
g_return_val_if_fail (SEAHORSE_IS_CONTEXT (sctx), NULL);
for (l = sctx->pv->sources; l; l = g_slist_next (l)) {
ks = SEAHORSE_SOURCE (l->data);
if (seahorse_source_get_location (ks) != SEAHORSE_LOCATION_REMOTE)
continue;
g_object_get (ks, "uri", &ks_uri, NULL);
if (ks_uri && g_str_equal (ks_uri, uri))
found = TRUE;
g_free (ks_uri);
if (found)
return ks;
}
/* TODO: We need to decouple this properly */
#ifdef WITH_KEYSERVER
#ifdef WITH_PGP
/* Auto generate one if possible */
if (sctx->pv->auto_sources) {
ks = SEAHORSE_SOURCE (seahorse_server_source_new (uri));
if (ks != NULL) {
seahorse_context_take_source (sctx, ks);
g_hash_table_replace (sctx->pv->auto_sources, g_strdup (uri), ks);
}
}
#endif /* WITH_PGP */
#endif /* WITH_KEYSERVER */
return ks;
}
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));
}
/**
* seahorse_context_search_remote:
* @sctx: A #SeahorseContext (can be NULL)
* @search: a keyword (name, email address...) to search for
*
* Searches for the key matching @search o the remote servers
*
* Returns: The created search operation
*/
SeahorseOperation*
seahorse_context_search_remote (SeahorseContext *sctx, const gchar *search)
{
SeahorseSource *ks;
SeahorseMultiOperation *mop = NULL;
SeahorseOperation *op = NULL;
GSList *l, *names;
GHashTable *servers = NULL;
gchar *uri;
if (!sctx)
sctx = seahorse_context_for_app ();
g_return_val_if_fail (SEAHORSE_IS_CONTEXT (sctx), NULL);
/* Get a list of all selected key servers */
names = seahorse_gconf_get_string_list (LASTSERVERS_KEY);
if (names) {
servers = g_hash_table_new (g_str_hash, g_str_equal);
for (l = names; l; l = g_slist_next (l))
g_hash_table_insert (servers, l->data, GINT_TO_POINTER (TRUE));
}
for (l = sctx->pv->sources; l; l = g_slist_next (l)) {
ks = SEAHORSE_SOURCE (l->data);
if (seahorse_source_get_location (ks) != SEAHORSE_LOCATION_REMOTE)
continue;
if (servers) {
g_object_get (ks, "uri", &uri, NULL);
if (!g_hash_table_lookup (servers, uri)) {
g_free (uri);
continue;
}
g_free (uri);
}
if (mop == NULL && op != NULL) {
mop = seahorse_multi_operation_new ();
seahorse_multi_operation_take (mop, op);
}
op = seahorse_source_search (ks, search);
if (mop != NULL)
seahorse_multi_operation_take (mop, op);
}
seahorse_util_string_slist_free (names);
return mop ? SEAHORSE_OPERATION (mop) : op;
}
/**
* client: ignored
* id: ignored
* entry: used for validation only
* sctx: The context to work with
*
* Refreshes the sources generated from the keyservers
*
**/
static void
refresh_keyservers (GConfClient *client, guint id, GConfEntry *entry,
SeahorseContext *sctx)
{
#ifdef WITH_KEYSERVER
#ifdef WITH_PGP
SeahorseServerSource *ssrc;
GSList *keyservers, *l;
GHashTable *check;
const gchar *uri;
if (!sctx->pv->auto_sources)
return;
if (entry && !g_str_equal (KEYSERVER_KEY, gconf_entry_get_key (entry)))
return;
/* Make a light copy of the auto_source table */
check = g_hash_table_new (g_str_hash, g_str_equal);
g_hash_table_foreach (sctx->pv->auto_sources, (GHFunc)auto_source_to_hash, check);
/* Load and strip names from keyserver list */
keyservers = seahorse_servers_get_uris ();
for (l = keyservers; l; l = g_slist_next (l)) {
uri = (const gchar*)(l->data);
/* If we don't have a keysource then add it */
if (!g_hash_table_lookup (sctx->pv->auto_sources, uri)) {
ssrc = seahorse_server_source_new (uri);
if (ssrc != NULL) {
seahorse_context_take_source (sctx, SEAHORSE_SOURCE (ssrc));
g_hash_table_replace (sctx->pv->auto_sources, g_strdup (uri), ssrc);
}
}
/* Mark this one as present */
g_hash_table_remove (check, uri);
}
/* Now remove any extras */
g_hash_table_foreach (check, (GHFunc)auto_source_remove, sctx);
g_hash_table_destroy (check);
seahorse_util_string_slist_free (keyservers);
#endif /* WITH_PGP */
#endif /* WITH_KEYSERVER */
}
/**
* seahorse_context_retrieve_objects:
* @sctx: A #SeahorsecContext
* @ktype: The type of the keys to transfer
* @ids: The key ids to transfer
* @to: A #SeahorseSource. If NULL, it will use @ktype to find a source
*
* Copies remote objects to a local source
*
* Returns: A #SeahorseOperation
*/
SeahorseOperation*
seahorse_context_retrieve_objects (SeahorseContext *sctx, GQuark ktype,
GSList *ids, SeahorseSource *to)
{
SeahorseMultiOperation *mop = NULL;
SeahorseOperation *op = NULL;
SeahorseSource *sksrc;
GSList *sources, *l;
if (!sctx)
sctx = seahorse_context_for_app ();
g_return_val_if_fail (SEAHORSE_IS_CONTEXT (sctx), NULL);
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));
return seahorse_operation_new_complete (NULL);
}
}
sources = seahorse_context_find_sources (sctx, ktype, SEAHORSE_LOCATION_REMOTE);
if (!sources) {
g_warning ("no sources found for type: %s", g_quark_to_string (ktype));
return seahorse_operation_new_complete (NULL);
}
for (l = sources; l; l = g_slist_next (l)) {
sksrc = SEAHORSE_SOURCE (l->data);
g_return_val_if_fail (SEAHORSE_IS_SOURCE (sksrc), NULL);
if (op != NULL) {
if (mop == NULL)
mop = seahorse_multi_operation_new ();
seahorse_multi_operation_take (mop, op);
}
/* Start a new transfer operation between the two key sources */
op = seahorse_transfer_operation_new (NULL, sksrc, to, ids);
g_return_val_if_fail (op != NULL, FALSE);
}
return mop ? SEAHORSE_OPERATION (mop) : op;
}
static void
refresh_all_keyrings (SeahorseCommands *self)
{
SeahorseOperation *op;
op = seahorse_source_load (SEAHORSE_SOURCE (seahorse_gkr_source_default ()));
/*
* HACK: Major hack alert. This whole area needs some serious refactoring,
* so for now we're just going to let any viewers listen in on this
* operation like so:
*/
g_signal_emit_by_name (seahorse_context_for_app (), "refreshing", op);
seahorse_operation_watch (op, on_refresh_done, g_object_ref (self), NULL, NULL);
g_object_unref (op);
}
/**
* gobject: the object to dispose (#SeahorseContext)
*
* release all references
*
**/
static void
seahorse_context_dispose (GObject *gobject)
{
SeahorseContext *sctx;
GSList *objects, *l;
sctx = SEAHORSE_CONTEXT (gobject);
/* Release all the objects */
objects = NULL;
g_hash_table_foreach (sctx->pv->objects_by_source, hash_to_ref_slist, &objects);
for (l = objects; l; l = g_slist_next (l)) {
seahorse_context_remove_object (sctx, l->data);
g_object_unref (G_OBJECT (l->data));
}
g_slist_free (objects);
/* Gconf notification */
if (sctx->pv->notify_id)
seahorse_gconf_unnotify (sctx->pv->notify_id);
sctx->pv->notify_id = 0;
/* Auto sources */
if (sctx->pv->auto_sources)
g_hash_table_destroy (sctx->pv->auto_sources);
sctx->pv->auto_sources = NULL;
/* DNS-SD */
if (sctx->pv->discovery)
g_object_unref (sctx->pv->discovery);
sctx->pv->discovery = NULL;
/* Release all the sources */
for (l = sctx->pv->sources; l; l = g_slist_next (l))
g_object_unref (SEAHORSE_SOURCE (l->data));
g_slist_free (sctx->pv->sources);
sctx->pv->sources = NULL;
if (sctx->pv->refresh_ops)
g_object_unref (sctx->pv->refresh_ops);
sctx->pv->refresh_ops = NULL;
G_OBJECT_CLASS (seahorse_context_parent_class)->dispose (gobject);
}
/**
* 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;
}
}
