static PyObject *
pygpgme_context_keylist(PyGpgmeContext *self, PyObject *args)
{
PyObject *py_pattern = Py_None;
char **patterns = NULL;
int secret_only = 0;
gpgme_error_t err;
PyGpgmeKeyIter *ret;
if (!PyArg_ParseTuple(args, "|Oi", &py_pattern, &secret_only))
return NULL;
if (parse_key_patterns(py_pattern, &patterns) < 0)
return NULL;
Py_BEGIN_ALLOW_THREADS;
err = gpgme_op_keylist_ext_start(self->ctx, (const char **)patterns,
secret_only, 0);
Py_END_ALLOW_THREADS;
if (patterns)
free_key_patterns(patterns);
if (pygpgme_check_error(err))
return NULL;
/* return a KeyIter object */
ret = PyObject_New(PyGpgmeKeyIter, &PyGpgmeKeyIter_Type);
if (!ret)
return NULL;
Py_INCREF(self);
ret->ctx = self;
return (PyObject *)ret;
}
int
main (int argc, char **argv)
{
int last_argc = -1;
gpgme_error_t err;
gpgme_ctx_t ctx;
gpgme_key_t key;
gpgme_keylist_result_t result;
gpgme_key_t keyarray[100];
int keyidx = 0;
gpgme_data_t out;
gpgme_protocol_t protocol = GPGME_PROTOCOL_OpenPGP;
gpgme_export_mode_t mode = 0;
if (argc)
{ argc--; argv++; }
while (argc && last_argc != argc )
{
last_argc = argc;
if (!strcmp (*argv, "--"))
{
argc--; argv++;
break;
}
else if (!strcmp (*argv, "--help"))
show_usage (0);
else if (!strcmp (*argv, "--verbose"))
{
verbose = 1;
argc--; argv++;
}
else if (!strcmp (*argv, "--openpgp"))
{
protocol = GPGME_PROTOCOL_OpenPGP;
argc--; argv++;
}
else if (!strcmp (*argv, "--cms"))
{
protocol = GPGME_PROTOCOL_CMS;
argc--; argv++;
}
else if (!strcmp (*argv, "--extern"))
{
mode |= GPGME_EXPORT_MODE_EXTERN;
argc--; argv++;
}
else if (!strcmp (*argv, "--secret"))
{
mode |= GPGME_EXPORT_MODE_SECRET;
argc--; argv++;
}
else if (!strcmp (*argv, "--raw"))
{
mode |= GPGME_EXPORT_MODE_RAW;
argc--; argv++;
}
else if (!strcmp (*argv, "--pkcs12"))
{
mode |= GPGME_EXPORT_MODE_PKCS12;
argc--; argv++;
}
else if (!strncmp (*argv, "--", 2))
show_usage (1);
}
if (!argc)
show_usage (1);
init_gpgme (protocol);
err = gpgme_new (&ctx);
fail_if_err (err);
gpgme_set_protocol (ctx, protocol);
/* Lookup the keys. */
err = gpgme_op_keylist_ext_start (ctx, (const char**)argv, 0, 0);
fail_if_err (err);
while (!(err = gpgme_op_keylist_next (ctx, &key)))
{
printf ("keyid: %s (fpr: %s)\n",
key->subkeys?nonnull (key->subkeys->keyid):"?",
key->subkeys?nonnull (key->subkeys->fpr):"?");
if (keyidx < DIM (keyarray)-1)
keyarray[keyidx++] = key;
else
{
fprintf (stderr, PGM": too many keys"
"- skipping this key\n");
gpgme_key_unref (key);
}
}
if (gpgme_err_code (err) != GPG_ERR_EOF)
fail_if_err (err);
err = gpgme_op_keylist_end (ctx);
fail_if_err (err);
keyarray[keyidx] = NULL;
result = gpgme_op_keylist_result (ctx);
if (result->truncated)
{
fprintf (stderr, PGM ": key listing unexpectedly truncated\n");
exit (1);
}
/* Now for the actual export. */
if ((mode & GPGME_EXPORT_MODE_EXTERN))
printf ("sending keys to keyserver\n");
if ((mode & GPGME_EXPORT_MODE_SECRET))
printf ("exporting secret keys!\n");
err = gpgme_data_new (&out);
fail_if_err (err);
gpgme_set_armor (ctx, 1);
err = gpgme_op_export_keys (ctx, keyarray, mode,
(mode & GPGME_KEYLIST_MODE_EXTERN)? NULL:out);
fail_if_err (err);
fflush (NULL);
if (!(mode & GPGME_KEYLIST_MODE_EXTERN))
{
fputs ("Begin Result:\n", stdout);
print_data (out);
fputs ("End Result.\n", stdout);
}
/* Cleanup. */
gpgme_data_release (out);
for (keyidx=0; keyarray[keyidx]; keyidx++)
gpgme_key_unref (keyarray[keyidx]);
gpgme_release (ctx);
return 0;
}
static gpgme_key_t*
prompt_recipients (gpgme_key_t *signkey)
{
gpgme_error_t gerr = 0;
CryptUIKeyset *keyset;
gpgme_ctx_t ctx;
gpgme_key_t key;
GArray *keys;
gchar **recips;
gchar *signer;
*signkey = NULL;
keyset = cryptui_keyset_new ("openpgp", TRUE);
if (cryptui_keyset_get_count (keyset) == 0) {
cryptui_need_to_get_keys ();
} else {
recips = cryptui_prompt_recipients (keyset, _("Choose Recipients"), &signer);
if (recips) {
gpgme_check_version (NULL);
gerr = gpgme_engine_check_version (GPGME_PROTOCOL_OpenPGP);
g_return_val_if_fail (gerr == 0, NULL);
gerr = gpgme_new (&ctx);
g_return_val_if_fail (gerr == 0, NULL);
if (signer) {
/* Load up the GPGME secret key */
gchar *id = cryptui_keyset_key_raw_keyid (keyset, signer);
gerr = gpgme_get_key (ctx, id, signkey, 1);
g_free (id);
/* A more descriptive error message */
if (GPG_ERR_EOF == gpgme_err_code (gerr))
gerr = gpgme_error (GPG_ERR_NOT_FOUND);
}
if (gerr == 0) {
gchar **ids;
guint num;
/* Load up the GPGME keys */
ids = cryptui_keyset_keys_raw_keyids (keyset, (const gchar**)recips);
num = g_strv_length (ids);
keys = g_array_new (TRUE, TRUE, sizeof (gpgme_key_t));
gerr = gpgme_op_keylist_ext_start (ctx, (const gchar**)ids, 0, 0);
g_free (ids);
if (gerr == 0) {
while ((gerr = gpgme_op_keylist_next (ctx, &key)) == 0)
g_array_append_val (keys, key);
gpgme_op_keylist_end (ctx);
}
/* Ignore EOF error */
if (GPG_ERR_EOF == gpgme_err_code (gerr))
gerr = 0;
if (gerr == 0 && num != keys->len)
g_warning ("couldn't load all the keys (%d/%d) from GPGME", keys->len, num);
}
gpgme_release (ctx);
}
g_object_unref (keyset);
if (!recips)
return NULL;
g_strfreev (recips);
g_free (signer);
if (gerr == 0 && keys->len)
return (gpgme_key_t*)g_array_free (keys, FALSE);
/* When failure, free all our return values */
seahorse_util_free_keys ((gpgme_key_t*)g_array_free (keys, FALSE));
if (*signkey)
gpgme_key_unref (*signkey);
seahorse_util_handle_gpgme (gerr, _("Couldn't load keys"));
}
return NULL;
}
