static gboolean hkp_message_propagate_error (SeahorseHKPSource *self, SoupMessage *message, GError **error) { gchar *server; g_autofree gchar *text = NULL; if (!SOUP_MESSAGE_IS_ERROR (message)) return FALSE; if (message->status_code == SOUP_STATUS_CANCELLED) { g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_CANCELLED, _("The operation was cancelled")); return TRUE; } g_object_get (self, "key-server", &server, NULL); /* Make the body lower case, and no tags */ text = g_strndup (message->response_body->data, message->response_body->length); if (text != NULL) { dehtmlize (text); seahorse_util_string_lower (text); } if (text && strstr (text, "no keys")) return FALSE; /* not found is not an error */ if (text && strstr (text, "too many")) { g_set_error (error, HKP_ERROR_DOMAIN, 0, _("Search was not specific enough. Server “%s” found too many keys."), server); } else { g_set_error (error, HKP_ERROR_DOMAIN, message->status_code, _("Couldn’t communicate with server “%s”: %s"), server, message->reason_phrase); } return TRUE; }
/** * response: The server response * * Parses the response and extracts an error message * * Free the error message with g_free after usage * * Returns NULL if there was no error. The error message else **/ static gchar* get_send_result (const gchar *response) { gchar **lines, **l; gchar *t; gchar *last = NULL; gboolean is_error = FALSE; if (!*response) return g_strdup (""); lines = g_strsplit (response, "\n", 0); for (l = lines; *l; l++) { dehtmlize (*l); g_strstrip (*l); if (!(*l)[0]) continue; t = g_ascii_strdown (*l, -1); /* Look for the word 'error' */ if (strstr (t, "error")) is_error = TRUE; g_free (t); if ((*l)[0]) last = *l; } /* Use last line as the message */ last = is_error ? g_strdup (last) : NULL; g_strfreev (lines); return last; }
/* Cancels operation and marks the HKP operation as failed */ static void fail_hkp_operation (SeahorseHKPOperation *hop, SoupMessage *msg, const gchar *text) { gchar *t, *server; GError *error = NULL; if (!seahorse_operation_is_running (SEAHORSE_OPERATION (hop))) return; g_object_get (hop->hsrc, "key-server", &server, NULL); if (text) { error = g_error_new (HKP_ERROR_DOMAIN, msg ? msg->status_code : 0, "%s", text); } else if (msg) { /* Make the body lower case, and no tags */ t = g_strndup (msg->response_body->data, msg->response_body->length); if (t != NULL) { dehtmlize (t); seahorse_util_string_lower (t); } if (t && strstr (t, "no keys")) error = NULL; /* not found is not an error */ else if (t && strstr (t, "too many")) error = g_error_new (HKP_ERROR_DOMAIN, 0, _("Search was not specific enough. Server '%s' found too many keys."), server); else error = g_error_new (HKP_ERROR_DOMAIN, msg->status_code, _("Couldn't communicate with server '%s': %s"), server, msg->reason_phrase); g_free (t); } else { /* We should always have msg or text */ g_assert (FALSE); } seahorse_operation_mark_done (SEAHORSE_OPERATION (hop), FALSE, error); g_free (server); }
/** * 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>> */ g_auto(GStrv) lines = NULL; gchar **l; SeahorsePgpKey *key = NULL; SeahorsePgpSubkey *subkey_with_id = NULL; GList *keys = NULL; GList *subkeys = NULL; GList *uids = NULL; SeahorseFlags flags; lines = g_strsplit (response, "\n", 0); for (l = lines; *l; l++) { gchar *line, *t; line = *l; dehtmlize (line); g_debug ("%s", line); /* Start a new key */ if (g_ascii_strncasecmp (line, "pub ", 4) == 0) { g_auto(GStrv) v = NULL; gchar *fingerprint, *fpr = NULL; const gchar *algo; gboolean has_uid = TRUE; SeahorsePgpSubkey *subkey; 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); continue; } 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); g_list_free_full (uids, g_object_unref); seahorse_pgp_key_set_subkeys (SEAHORSE_PGP_KEY (key), subkeys); g_list_free_full (subkeys, g_object_unref); 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); } /* 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; g_autofree gchar *pretty_fingerprint = NULL; fingerprint_str = get_fingerprint_string (line); if (fingerprint_str == NULL) continue; 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); } } if (key) { seahorse_pgp_key_set_uids (SEAHORSE_PGP_KEY (key), g_list_reverse (uids)); g_list_free_full (uids, g_object_unref); seahorse_pgp_key_set_subkeys (SEAHORSE_PGP_KEY (key), g_list_reverse (subkeys)); g_list_free_full (subkeys, g_object_unref); seahorse_pgp_key_realize (SEAHORSE_PGP_KEY (key)); } return 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; 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); #if DEBUG_HKP_ENABLE fprintf(stderr,"%s\n", line); #endif /* 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_warning ("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_warning ("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); uids = subkeys = NULL; key = NULL; } key = seahorse_pgp_key_new (); keys = g_list_prepend (keys, key); g_object_set (key, "location", SEAHORSE_LOCATION_REMOTE, "flags", flags, NULL); /* Add all the info to the key */ 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_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 (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 (line); uids = g_list_prepend (uids, uid); /* Signatures */ } else if (key && g_ascii_strncasecmp (line, "sig ", 4) == 0) { /* TODO: Implement signatures */ } } 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); } return keys; }