static void
refresh_callback (SoupSession *session, SoupMessage *msg, SeahorseHKPOperation *hop)
{
GList *keys, *k;
if (hop->cancelling)
return;
if (SOUP_MESSAGE_IS_ERROR (msg)) {
fail_hkp_operation (hop, msg, NULL);
return;
}
keys = parse_hkp_index (msg->response_body->data);
for (k = keys; k; k = g_list_next (k))
add_key (hop->hsrc, SEAHORSE_PGP_KEY (k->data));
seahorse_object_list_free (keys);
if (--hop->requests <= 0)
seahorse_operation_mark_done (SEAHORSE_OPERATION (hop), FALSE, NULL);
else
seahorse_operation_mark_progress_full (SEAHORSE_OPERATION (hop), _("Searching for keys..."),
hop->requests, hop->total);
}
void
seahorse_pgp_uid_set_signatures (SeahorsePgpUid *self, GList *signatures)
{
g_return_if_fail (SEAHORSE_IS_PGP_UID (self));
seahorse_object_list_free (self->pv->signatures);
self->pv->signatures = seahorse_object_list_copy (signatures);
g_object_notify (G_OBJECT (self), "signatures");
}
static void
seahorse_pgp_uid_object_finalize (GObject *gobject)
{
SeahorsePgpUid *self = SEAHORSE_PGP_UID (gobject);
seahorse_object_list_free (self->pv->signatures);
self->pv->signatures = NULL;
g_free (self->pv->name);
self->pv->name = NULL;
g_free (self->pv->email);
self->pv->email = NULL;
g_free (self->pv->comment);
self->pv->comment = NULL;
G_OBJECT_CLASS (seahorse_pgp_uid_parent_class)->finalize (gobject);
}
static void
realize_signatures (SeahorseGpgmeUid *self)
{
gpgme_key_sig_t gsig;
SeahorsePgpSignature *sig;
GList *sigs = NULL;
guint flags;
g_return_if_fail (self->pv->pubkey);
g_return_if_fail (self->pv->userid);
/* If this key was loaded without signatures, then leave them as is */
if ((self->pv->pubkey->keylist_mode & GPGME_KEYLIST_MODE_SIGS) == 0)
return;
for (gsig = self->pv->userid->signatures; gsig; gsig = gsig->next) {
sig = seahorse_pgp_signature_new (gsig->keyid);
/* Order of parsing these flags is important */
flags = 0;
if (gsig->revoked)
flags |= SEAHORSE_FLAG_REVOKED;
if (gsig->expired)
flags |= SEAHORSE_FLAG_EXPIRED;
if (flags == 0 && !gsig->invalid)
flags = SEAHORSE_FLAG_IS_VALID;
if (gsig->exportable)
flags |= SEAHORSE_FLAG_EXPORTABLE;
seahorse_pgp_signature_set_flags (sig, flags);
sigs = g_list_prepend (sigs, sig);
}
seahorse_pgp_uid_set_signatures (SEAHORSE_PGP_UID (self), sigs);
seahorse_object_list_free (sigs);
}
/**
* response: The HKP server response to parse
*
* Extracts the key data from the HKP server response
*
* Returns A GList of keys
**/
static GList*
parse_hkp_index (const gchar *response)
{
/*
* Luckily enough, both the HKP server and NAI HKP interface to their
* LDAP server are close enough in output so the same function can
* parse them both.
*/
/* pub 2048/<a href="/pks/lookup?op=get&search=0x3CB3B415">3CB3B415</a> 1998/04/03 David M. Shaw <<a href="/pks/lookup?op=get&search=0x3CB3B415">[email protected]</a>> */
gchar **lines, **l;
gchar **v;
gchar *line, *t;
SeahorsePgpKey *key = NULL;
SeahorsePgpSubkey *subkey_with_id = NULL;
GList *keys = NULL;
GList *subkeys = NULL;
GList *uids = NULL;
guint flags;
lines = g_strsplit (response, "\n", 0);
for (l = lines; *l; l++) {
line = *l;
dehtmlize (line);
g_debug ("%s", line);
/* Start a new key */
if (g_ascii_strncasecmp (line, "pub ", 4) == 0) {
t = line + 4;
while (*t && g_ascii_isspace (*t))
t++;
v = g_strsplit_set (t, " ", 3);
if (!v[0] || !v[1] || !v[2]) {
g_message ("Invalid key line from server: %s", line);
} else {
gchar *fingerprint, *fpr = NULL;
const gchar *algo;
gboolean has_uid = TRUE;
SeahorsePgpSubkey *subkey;
flags = SEAHORSE_FLAG_EXPORTABLE;
/* Cut the length and fingerprint */
fpr = strchr (v[0], '/');
if (fpr == NULL) {
g_message ("couldn't find key fingerprint in line from server: %s", line);
fpr = "";
} else {
*(fpr++) = 0;
}
/* Check out the key type */
switch (g_ascii_toupper (v[0][strlen(v[0]) - 1])) {
case 'D':
algo = "DSA";
break;
case 'R':
algo = "RSA";
break;
default:
algo = "";
break;
};
/* Format the date for our parse function */
g_strdelimit (v[1], "/", '-');
/* Cleanup the UID */
g_strstrip (v[2]);
if (g_ascii_strcasecmp (v[2], "*** KEY REVOKED ***") == 0) {
flags |= SEAHORSE_FLAG_REVOKED;
has_uid = FALSE;
}
if (key) {
seahorse_pgp_key_set_uids (SEAHORSE_PGP_KEY (key), uids);
seahorse_object_list_free (uids);
seahorse_pgp_key_set_subkeys (SEAHORSE_PGP_KEY (key), subkeys);
seahorse_object_list_free (subkeys);
seahorse_pgp_key_realize (SEAHORSE_PGP_KEY (key));
uids = subkeys = NULL;
subkey_with_id = NULL;
key = NULL;
}
key = seahorse_pgp_key_new ();
keys = g_list_prepend (keys, key);
g_object_set (key, "object-flags", flags, NULL);
/* Add all the info to the key */
subkey = seahorse_pgp_subkey_new ();
seahorse_pgp_subkey_set_keyid (subkey, fpr);
subkey_with_id = subkey;
fingerprint = seahorse_pgp_subkey_calc_fingerprint (fpr);
seahorse_pgp_subkey_set_fingerprint (subkey, fingerprint);
g_free (fingerprint);
seahorse_pgp_subkey_set_flags (subkey, flags);
seahorse_pgp_subkey_set_created (subkey, parse_hkp_date (v[1]));
seahorse_pgp_subkey_set_length (subkey, strtol (v[0], NULL, 10));
seahorse_pgp_subkey_set_algorithm (subkey, algo);
subkeys = g_list_prepend (subkeys, subkey);
/* And the UID if one was found */
if (has_uid) {
SeahorsePgpUid *uid = seahorse_pgp_uid_new (key, v[2]);
uids = g_list_prepend (uids, uid);
}
}
g_strfreev (v);
/* A UID for the key */
} else if (key && g_ascii_strncasecmp (line, " ", 4) == 0) {
SeahorsePgpUid *uid;
g_strstrip (line);
uid = seahorse_pgp_uid_new (key, line);
uids = g_list_prepend (uids, uid);
/* Signatures */
} else if (key && g_ascii_strncasecmp (line, "sig ", 4) == 0) {
/* TODO: Implement signatures */
} else if (key && subkey_with_id) {
const char *fingerprint_str;
fingerprint_str = get_fingerprint_string (line);
if (fingerprint_str != NULL) {
char *pretty_fingerprint;
pretty_fingerprint = seahorse_pgp_subkey_calc_fingerprint (fingerprint_str);
/* FIXME: we don't check that the fingerprint actually matches the key's ID.
* We also don't validate the fingerprint at all; the keyserver may have returned
* some garbage and we don't notice.
*/
if (pretty_fingerprint[0] != 0)
seahorse_pgp_subkey_set_fingerprint (subkey_with_id, pretty_fingerprint);
g_free (pretty_fingerprint);
}
}
}
g_strfreev (lines);
if (key) {
seahorse_pgp_key_set_uids (SEAHORSE_PGP_KEY (key), g_list_reverse (uids));
seahorse_object_list_free (uids);
seahorse_pgp_key_set_subkeys (SEAHORSE_PGP_KEY (key), g_list_reverse (subkeys));
seahorse_object_list_free (subkeys);
seahorse_pgp_key_realize (SEAHORSE_PGP_KEY (key));
}
return keys;
}
/* Add a key to the key source from an LDAP entry */
static void
search_parse_key_from_ldap_entry (SeahorseLDAPSource *self,
GcrSimpleCollection *results,
LDAP *ldap,
LDAPMessage *res)
{
const gchar *algo;
long int timestamp;
long int expires;
gchar *fpr, *fingerprint;
gchar *uidstr;
gboolean revoked;
gboolean disabled;
int length;
g_return_if_fail (ldap_msgtype (res) == LDAP_RES_SEARCH_ENTRY);
fpr = get_string_attribute (ldap, res, "pgpcertid");
uidstr = get_string_attribute (ldap, res, "pgpuserid");
revoked = get_boolean_attribute (ldap, res, "pgprevoked");
disabled = get_boolean_attribute (ldap, res, "pgpdisabled");
timestamp = get_date_attribute (ldap, res, "pgpkeycreatetime");
expires = get_date_attribute (ldap, res, "pgpkeyexpiretime");
algo = get_algo_attribute (ldap, res, "pgpkeytype");
length = get_int_attribute (ldap, res, "pgpkeysize");
if (fpr && uidstr) {
SeahorsePgpSubkey *subkey;
SeahorsePgpKey *key;
SeahorsePgpUid *uid;
GList *list;
guint flags;
/* Build up a subkey */
subkey = seahorse_pgp_subkey_new ();
seahorse_pgp_subkey_set_keyid (subkey, fpr);
fingerprint = seahorse_pgp_subkey_calc_fingerprint (fpr);
seahorse_pgp_subkey_set_fingerprint (subkey, fingerprint);
g_free (fingerprint);
seahorse_pgp_subkey_set_created (subkey, timestamp);
seahorse_pgp_subkey_set_expires (subkey, expires);
seahorse_pgp_subkey_set_algorithm (subkey, algo);
seahorse_pgp_subkey_set_length (subkey, length);
flags = SEAHORSE_FLAG_EXPORTABLE;
if (revoked)
flags |= SEAHORSE_FLAG_REVOKED;
if (disabled)
flags |= SEAHORSE_FLAG_DISABLED;
seahorse_pgp_subkey_set_flags (subkey, flags);
key = seahorse_pgp_key_new ();
/* Build up a uid */
uid = seahorse_pgp_uid_new (key, uidstr);
if (revoked)
seahorse_pgp_uid_set_validity (uid, SEAHORSE_VALIDITY_REVOKED);
/* Now build them into a key */
list = g_list_prepend (NULL, uid);
seahorse_pgp_key_set_uids (key, list);
seahorse_object_list_free (list);
list = g_list_prepend (NULL, subkey);
seahorse_pgp_key_set_subkeys (key, list);
seahorse_object_list_free (list);
g_object_set (key,
"object-flags", flags,
"place", self,
NULL);
seahorse_pgp_key_realize (key);
gcr_simple_collection_add (results, G_OBJECT (key));
g_object_unref (key);
}
g_free (fpr);
g_free (uidstr);
}
