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