d35d44efaf
* src/context.h (struct gpgme_context): New field import_filter. * src/engine-backend.h (struct engine_ops): Add arg import_filter to field 'import'. * src/engine-gpg.c (gpg_import): Add arg import_filter and pass option --import-filter with argument value to gpg. Adjust all callers. * src/engine-gpgsm.c (gpgsm_import): Add dummy arg import_filter. * src/gpgme.c (gpgme_release): Free 'import_filter'. (gpgme_set_ctx_flag, gpgme_get_ctx_flag): New flag "import-filter". * tests/run-import.c (main): Add option --import-filter. -- This makes the --import-filter option available in the GPGME API for key imports. GnuPG-bug-id: 5739
1358 lines
32 KiB
C
1358 lines
32 KiB
C
/* gpgme.c - GnuPG Made Easy.
|
||
* Copyright (C) 2000 Werner Koch (dd9jn)
|
||
* Copyright (C) 2001, 2002, 2003, 2004, 2005, 2007, 2012,
|
||
* 2014, 2015 g10 Code GmbH
|
||
*
|
||
* This file is part of GPGME.
|
||
*
|
||
* GPGME is free software; you can redistribute it and/or modify it
|
||
* under the terms of the GNU Lesser General Public License as
|
||
* published by the Free Software Foundation; either version 2.1 of
|
||
* the License, or (at your option) any later version.
|
||
*
|
||
* GPGME is distributed in the hope that it will be useful, but
|
||
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||
* Lesser General Public License for more details.
|
||
*
|
||
* You should have received a copy of the GNU Lesser General Public
|
||
* License along with this program; if not, see <https://gnu.org/licenses/>.
|
||
* SPDX-License-Identifier: LGPL-2.1-or-later
|
||
*/
|
||
|
||
#if HAVE_CONFIG_H
|
||
#include <config.h>
|
||
#endif
|
||
#include <stdio.h>
|
||
#include <stdlib.h>
|
||
#include <string.h>
|
||
#include <assert.h>
|
||
#include <errno.h>
|
||
#ifdef HAVE_LOCALE_H
|
||
#include <locale.h>
|
||
#endif
|
||
|
||
#include "util.h"
|
||
#include "context.h"
|
||
#include "ops.h"
|
||
#include "wait.h"
|
||
#include "debug.h"
|
||
#include "priv-io.h"
|
||
#include "sys-util.h"
|
||
#include "mbox-util.h"
|
||
|
||
|
||
/* The default locale. */
|
||
DEFINE_STATIC_LOCK (def_lc_lock);
|
||
static char *def_lc_ctype;
|
||
static char *def_lc_messages;
|
||
|
||
|
||
gpgme_error_t _gpgme_selftest = GPG_ERR_NOT_OPERATIONAL;
|
||
|
||
/* Protects all reference counters in result structures. All other
|
||
accesses to a result structure are read only. */
|
||
DEFINE_STATIC_LOCK (result_ref_lock);
|
||
|
||
|
||
/* Set the global flag NAME to VALUE. Return 0 on success. Note that
|
||
this function does not use gpgme_error and thus a non-zero return
|
||
value merely means "error". Certain flags may be set before
|
||
gpgme_check_version is called. See the manual for a description of
|
||
supported flags. The caller must assure that this function is
|
||
called only by one thread at a time. */
|
||
int
|
||
gpgme_set_global_flag (const char *name, const char *value)
|
||
{
|
||
if (!name || !value)
|
||
return -1;
|
||
else if (!strcmp (name, "debug"))
|
||
return _gpgme_debug_set_debug_envvar (value);
|
||
else if (!strcmp (name, "disable-gpgconf"))
|
||
{
|
||
_gpgme_dirinfo_disable_gpgconf ();
|
||
return 0;
|
||
}
|
||
else if (!strcmp (name, "require-gnupg"))
|
||
return _gpgme_set_engine_minimal_version (value);
|
||
else if (!strcmp (name, "gpgconf-name"))
|
||
return _gpgme_set_default_gpgconf_name (value);
|
||
else if (!strcmp (name, "gpg-name"))
|
||
return _gpgme_set_default_gpg_name (value);
|
||
else if (!strcmp (name, "w32-inst-dir"))
|
||
return _gpgme_set_override_inst_dir (value);
|
||
else
|
||
return -1;
|
||
}
|
||
|
||
|
||
|
||
/* Create a new context as an environment for GPGME crypto
|
||
operations. */
|
||
gpgme_error_t
|
||
gpgme_new (gpgme_ctx_t *r_ctx)
|
||
{
|
||
gpgme_error_t err;
|
||
gpgme_ctx_t ctx;
|
||
TRACE_BEG (DEBUG_CTX, "gpgme_new", r_ctx, "");
|
||
|
||
if (_gpgme_selftest)
|
||
return TRACE_ERR (_gpgme_selftest);
|
||
|
||
if (!r_ctx)
|
||
return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
|
||
|
||
ctx = calloc (1, sizeof *ctx);
|
||
if (!ctx)
|
||
return TRACE_ERR (gpg_error_from_syserror ());
|
||
|
||
INIT_LOCK (ctx->lock);
|
||
|
||
err = _gpgme_engine_info_copy (&ctx->engine_info);
|
||
if (!err && !ctx->engine_info)
|
||
err = gpg_error (GPG_ERR_NO_ENGINE);
|
||
if (err)
|
||
{
|
||
free (ctx);
|
||
return TRACE_ERR (err);
|
||
}
|
||
|
||
ctx->keylist_mode = GPGME_KEYLIST_MODE_LOCAL;
|
||
ctx->include_certs = GPGME_INCLUDE_CERTS_DEFAULT;
|
||
ctx->protocol = GPGME_PROTOCOL_OpenPGP;
|
||
ctx->sub_protocol = GPGME_PROTOCOL_DEFAULT;
|
||
_gpgme_fd_table_init (&ctx->fdt);
|
||
|
||
LOCK (def_lc_lock);
|
||
if (def_lc_ctype)
|
||
{
|
||
ctx->lc_ctype = strdup (def_lc_ctype);
|
||
if (!ctx->lc_ctype)
|
||
{
|
||
int saved_err = gpg_error_from_syserror ();
|
||
UNLOCK (def_lc_lock);
|
||
_gpgme_engine_info_release (ctx->engine_info);
|
||
free (ctx);
|
||
return TRACE_ERR (saved_err);
|
||
}
|
||
}
|
||
else
|
||
def_lc_ctype = NULL;
|
||
|
||
if (def_lc_messages)
|
||
{
|
||
ctx->lc_messages = strdup (def_lc_messages);
|
||
if (!ctx->lc_messages)
|
||
{
|
||
int saved_err = gpg_error_from_syserror ();
|
||
UNLOCK (def_lc_lock);
|
||
if (ctx->lc_ctype)
|
||
free (ctx->lc_ctype);
|
||
_gpgme_engine_info_release (ctx->engine_info);
|
||
free (ctx);
|
||
return TRACE_ERR (saved_err);
|
||
}
|
||
}
|
||
else
|
||
def_lc_messages = NULL;
|
||
UNLOCK (def_lc_lock);
|
||
|
||
*r_ctx = ctx;
|
||
|
||
TRACE_SUC ("ctx=%p", ctx);
|
||
return 0;
|
||
}
|
||
|
||
|
||
gpgme_error_t
|
||
_gpgme_cancel_with_err (gpgme_ctx_t ctx, gpg_error_t ctx_err,
|
||
gpg_error_t op_err)
|
||
{
|
||
gpgme_error_t err;
|
||
struct gpgme_io_event_done_data data;
|
||
|
||
TRACE_BEG (DEBUG_CTX, "_gpgme_cancel_with_err", ctx, "ctx_err=%i, op_err=%i",
|
||
ctx_err, op_err);
|
||
|
||
if (ctx_err)
|
||
{
|
||
err = _gpgme_engine_cancel (ctx->engine);
|
||
if (err)
|
||
return TRACE_ERR (err);
|
||
}
|
||
else
|
||
{
|
||
err = _gpgme_engine_cancel_op (ctx->engine);
|
||
if (err)
|
||
return TRACE_ERR (err);
|
||
}
|
||
|
||
data.err = ctx_err;
|
||
data.op_err = op_err;
|
||
|
||
_gpgme_engine_io_event (ctx->engine, GPGME_EVENT_DONE, &data);
|
||
|
||
return TRACE_ERR (0);
|
||
}
|
||
|
||
|
||
/* Cancel a pending asynchronous operation. */
|
||
gpgme_error_t
|
||
gpgme_cancel (gpgme_ctx_t ctx)
|
||
{
|
||
gpg_error_t err;
|
||
|
||
TRACE_BEG (DEBUG_CTX, "gpgme_cancel", ctx, "");
|
||
|
||
if (!ctx)
|
||
return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
|
||
|
||
err = _gpgme_cancel_with_err (ctx, gpg_error (GPG_ERR_CANCELED), 0);
|
||
|
||
return TRACE_ERR (err);
|
||
}
|
||
|
||
|
||
/* Cancel a pending operation asynchronously. */
|
||
gpgme_error_t
|
||
gpgme_cancel_async (gpgme_ctx_t ctx)
|
||
{
|
||
TRACE_BEG (DEBUG_CTX, "gpgme_cancel_async", ctx, "");
|
||
|
||
if (!ctx)
|
||
return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
|
||
|
||
LOCK (ctx->lock);
|
||
ctx->canceled = 1;
|
||
UNLOCK (ctx->lock);
|
||
|
||
return TRACE_ERR (0);
|
||
}
|
||
|
||
|
||
/* Release all resources associated with the given context. */
|
||
void
|
||
gpgme_release (gpgme_ctx_t ctx)
|
||
{
|
||
TRACE (DEBUG_CTX, "gpgme_release", ctx, "");
|
||
|
||
if (!ctx)
|
||
return;
|
||
|
||
_gpgme_engine_release (ctx->engine);
|
||
ctx->engine = NULL;
|
||
_gpgme_fd_table_deinit (&ctx->fdt);
|
||
_gpgme_release_result (ctx);
|
||
_gpgme_signers_clear (ctx);
|
||
_gpgme_sig_notation_clear (ctx);
|
||
free (ctx->sender);
|
||
free (ctx->signers);
|
||
free (ctx->lc_ctype);
|
||
free (ctx->lc_messages);
|
||
free (ctx->override_session_key);
|
||
free (ctx->request_origin);
|
||
free (ctx->auto_key_locate);
|
||
free (ctx->trust_model);
|
||
free (ctx->cert_expire);
|
||
free (ctx->key_origin);
|
||
free (ctx->import_filter);
|
||
_gpgme_engine_info_release (ctx->engine_info);
|
||
ctx->engine_info = NULL;
|
||
DESTROY_LOCK (ctx->lock);
|
||
free (ctx);
|
||
}
|
||
|
||
|
||
void
|
||
gpgme_result_ref (void *result)
|
||
{
|
||
struct ctx_op_data *data;
|
||
|
||
if (! result)
|
||
return;
|
||
|
||
data = (void*)((char*)result - sizeof (struct ctx_op_data));
|
||
|
||
assert (data->magic == CTX_OP_DATA_MAGIC);
|
||
|
||
LOCK (result_ref_lock);
|
||
data->references++;
|
||
UNLOCK (result_ref_lock);
|
||
}
|
||
|
||
|
||
void
|
||
gpgme_result_unref (void *result)
|
||
{
|
||
struct ctx_op_data *data;
|
||
|
||
if (! result)
|
||
return;
|
||
|
||
data = (void*)((char*)result - sizeof (struct ctx_op_data));
|
||
|
||
assert (data->magic == CTX_OP_DATA_MAGIC);
|
||
|
||
LOCK (result_ref_lock);
|
||
if (--data->references)
|
||
{
|
||
UNLOCK (result_ref_lock);
|
||
return;
|
||
}
|
||
UNLOCK (result_ref_lock);
|
||
|
||
if (data->cleanup)
|
||
(*data->cleanup) (data->hook);
|
||
free (data);
|
||
}
|
||
|
||
|
||
void
|
||
_gpgme_release_result (gpgme_ctx_t ctx)
|
||
{
|
||
struct ctx_op_data *data = ctx->op_data;
|
||
|
||
while (data)
|
||
{
|
||
struct ctx_op_data *next_data = data->next;
|
||
data->next = NULL;
|
||
gpgme_result_unref (data->hook);
|
||
data = next_data;
|
||
}
|
||
ctx->op_data = NULL;
|
||
}
|
||
|
||
|
||
/* Note that setting the protocol will intentionally not fail if the
|
||
* engine is not available. */
|
||
gpgme_error_t
|
||
gpgme_set_protocol (gpgme_ctx_t ctx, gpgme_protocol_t protocol)
|
||
{
|
||
TRACE_BEG (DEBUG_CTX, "gpgme_set_protocol", ctx, "protocol=%i (%s)",
|
||
protocol, gpgme_get_protocol_name (protocol)
|
||
? gpgme_get_protocol_name (protocol) : "invalid");
|
||
|
||
if (protocol != GPGME_PROTOCOL_OpenPGP
|
||
&& protocol != GPGME_PROTOCOL_CMS
|
||
&& protocol != GPGME_PROTOCOL_GPGCONF
|
||
&& protocol != GPGME_PROTOCOL_ASSUAN
|
||
&& protocol != GPGME_PROTOCOL_G13
|
||
&& protocol != GPGME_PROTOCOL_UISERVER
|
||
&& protocol != GPGME_PROTOCOL_SPAWN)
|
||
return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
|
||
|
||
if (!ctx)
|
||
return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
|
||
|
||
if (ctx->protocol != protocol)
|
||
{
|
||
/* Shut down the engine when switching protocols. */
|
||
if (ctx->engine)
|
||
{
|
||
TRACE_LOG ("releasing ctx->engine=%p", ctx->engine);
|
||
_gpgme_engine_release (ctx->engine);
|
||
ctx->engine = NULL;
|
||
}
|
||
|
||
ctx->protocol = protocol;
|
||
}
|
||
return TRACE_ERR (0);
|
||
}
|
||
|
||
|
||
gpgme_protocol_t
|
||
gpgme_get_protocol (gpgme_ctx_t ctx)
|
||
{
|
||
TRACE (DEBUG_CTX, "gpgme_get_protocol", ctx,
|
||
"ctx->protocol=%i (%s)", ctx->protocol,
|
||
gpgme_get_protocol_name (ctx->protocol)
|
||
? gpgme_get_protocol_name (ctx->protocol) : "invalid");
|
||
|
||
return ctx->protocol;
|
||
}
|
||
|
||
|
||
gpgme_error_t
|
||
gpgme_set_sub_protocol (gpgme_ctx_t ctx, gpgme_protocol_t protocol)
|
||
{
|
||
TRACE (DEBUG_CTX, "gpgme_set_sub_protocol", ctx, "protocol=%i (%s)",
|
||
protocol, gpgme_get_protocol_name (protocol)
|
||
? gpgme_get_protocol_name (protocol) : "invalid");
|
||
|
||
if (!ctx)
|
||
return gpg_error (GPG_ERR_INV_VALUE);
|
||
|
||
ctx->sub_protocol = protocol;
|
||
return 0;
|
||
}
|
||
|
||
|
||
gpgme_protocol_t
|
||
gpgme_get_sub_protocol (gpgme_ctx_t ctx)
|
||
{
|
||
TRACE (DEBUG_CTX, "gpgme_get_sub_protocol", ctx,
|
||
"ctx->sub_protocol=%i (%s)", ctx->sub_protocol,
|
||
gpgme_get_protocol_name (ctx->sub_protocol)
|
||
? gpgme_get_protocol_name (ctx->sub_protocol) : "invalid");
|
||
|
||
return ctx->sub_protocol;
|
||
}
|
||
|
||
|
||
const char *
|
||
gpgme_get_protocol_name (gpgme_protocol_t protocol)
|
||
{
|
||
switch (protocol)
|
||
{
|
||
case GPGME_PROTOCOL_OpenPGP:
|
||
return "OpenPGP";
|
||
|
||
case GPGME_PROTOCOL_CMS:
|
||
return "CMS";
|
||
|
||
case GPGME_PROTOCOL_GPGCONF:
|
||
return "GPGCONF";
|
||
|
||
case GPGME_PROTOCOL_ASSUAN:
|
||
return "Assuan";
|
||
|
||
case GPGME_PROTOCOL_G13:
|
||
return "G13";
|
||
|
||
case GPGME_PROTOCOL_UISERVER:
|
||
return "UIServer";
|
||
|
||
case GPGME_PROTOCOL_SPAWN:
|
||
return "Spawn";
|
||
|
||
case GPGME_PROTOCOL_DEFAULT:
|
||
return "default";
|
||
|
||
case GPGME_PROTOCOL_UNKNOWN:
|
||
return "unknown";
|
||
|
||
default:
|
||
return NULL;
|
||
}
|
||
}
|
||
|
||
|
||
/* Store the sender's address in the context. ADDRESS is addr-spec of
|
||
* mailbox but my also be a complete mailbox, in which case this
|
||
* function extracts the addr-spec from it. Returns 0 on success or
|
||
* an error code if no valid addr-spec could be extracted from
|
||
* ADDRESS. */
|
||
gpgme_error_t
|
||
gpgme_set_sender (gpgme_ctx_t ctx, const char *address)
|
||
{
|
||
char *p = NULL;
|
||
|
||
TRACE_BEG (DEBUG_CTX, "gpgme_set_sender", ctx, "sender='%s'",
|
||
address?address:"(null)");
|
||
|
||
if (!ctx || (address && !(p = _gpgme_mailbox_from_userid (address))))
|
||
return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
|
||
|
||
free (ctx->sender);
|
||
ctx->sender = p;
|
||
return TRACE_ERR (0);
|
||
}
|
||
|
||
|
||
/* Return the sender's address (addr-spec part) from the context or
|
||
* NULL if none was set. The returned value is valid as long as the
|
||
* CTX is valid and gpgme_set_sender has not been used. */
|
||
const char *
|
||
gpgme_get_sender (gpgme_ctx_t ctx)
|
||
{
|
||
TRACE (DEBUG_CTX, "gpgme_get_sender", ctx, "sender='%s'",
|
||
ctx?ctx->sender:"");
|
||
|
||
return ctx->sender;
|
||
}
|
||
|
||
|
||
/* Enable or disable the use of an ascii armor for all output. */
|
||
void
|
||
gpgme_set_armor (gpgme_ctx_t ctx, int use_armor)
|
||
{
|
||
TRACE (DEBUG_CTX, "gpgme_set_armor", ctx, "use_armor=%i (%s)",
|
||
use_armor, use_armor ? "yes" : "no");
|
||
|
||
if (!ctx)
|
||
return;
|
||
|
||
ctx->use_armor = !!use_armor;
|
||
}
|
||
|
||
|
||
/* Return the state of the armor flag. */
|
||
int
|
||
gpgme_get_armor (gpgme_ctx_t ctx)
|
||
{
|
||
TRACE (DEBUG_CTX, "gpgme_get_armor", ctx, "ctx->use_armor=%i (%s)",
|
||
ctx->use_armor, ctx->use_armor ? "yes" : "no");
|
||
return ctx->use_armor;
|
||
}
|
||
|
||
|
||
/* Set the flag NAME for CTX to VALUE. Please consult the manual for
|
||
* a description of the flags.
|
||
*/
|
||
gpgme_error_t
|
||
gpgme_set_ctx_flag (gpgme_ctx_t ctx, const char *name, const char *value)
|
||
{
|
||
gpgme_error_t err = 0;
|
||
int abool;
|
||
|
||
TRACE (DEBUG_CTX, "gpgme_set_ctx_flag", ctx,
|
||
"name='%s' value='%s'",
|
||
name? name:"(null)", value?value:"(null)");
|
||
|
||
abool = (value && *value)? !!atoi (value) : 0;
|
||
|
||
if (!ctx || !name || !value)
|
||
err = gpg_error (GPG_ERR_INV_VALUE);
|
||
else if (!strcmp (name, "redraw"))
|
||
{
|
||
ctx->redraw_suggested = abool;
|
||
}
|
||
else if (!strcmp (name, "full-status"))
|
||
{
|
||
ctx->full_status = abool;
|
||
}
|
||
else if (!strcmp (name, "raw-description"))
|
||
{
|
||
ctx->raw_description = abool;
|
||
}
|
||
else if (!strcmp (name, "export-session-key"))
|
||
{
|
||
ctx->export_session_keys = abool;
|
||
}
|
||
else if (!strcmp (name, "override-session-key"))
|
||
{
|
||
free (ctx->override_session_key);
|
||
ctx->override_session_key = strdup (value);
|
||
if (!ctx->override_session_key)
|
||
err = gpg_error_from_syserror ();
|
||
}
|
||
else if (!strcmp (name, "include-key-block"))
|
||
{
|
||
ctx->include_key_block = abool;
|
||
}
|
||
else if (!strcmp (name, "auto-key-import"))
|
||
{
|
||
ctx->auto_key_import = abool;
|
||
}
|
||
else if (!strcmp (name, "auto-key-retrieve"))
|
||
{
|
||
ctx->auto_key_retrieve = abool;
|
||
}
|
||
else if (!strcmp (name, "request-origin"))
|
||
{
|
||
free (ctx->request_origin);
|
||
ctx->request_origin = strdup (value);
|
||
if (!ctx->request_origin)
|
||
err = gpg_error_from_syserror ();
|
||
}
|
||
else if (!strcmp (name, "no-symkey-cache"))
|
||
{
|
||
ctx->no_symkey_cache = abool;
|
||
}
|
||
else if (!strcmp (name, "ignore-mdc-error"))
|
||
{
|
||
ctx->ignore_mdc_error = abool;
|
||
}
|
||
else if (!strcmp (name, "auto-key-locate"))
|
||
{
|
||
free (ctx->auto_key_locate);
|
||
ctx->auto_key_locate = strdup (value);
|
||
if (!ctx->auto_key_locate)
|
||
err = gpg_error_from_syserror ();
|
||
}
|
||
else if (!strcmp (name, "trust-model"))
|
||
{
|
||
free (ctx->trust_model);
|
||
ctx->trust_model = strdup (value);
|
||
if (!ctx->trust_model)
|
||
err = gpg_error_from_syserror ();
|
||
}
|
||
else if (!strcmp (name, "extended-edit"))
|
||
{
|
||
ctx->extended_edit = abool;
|
||
}
|
||
else if (!strcmp (name, "cert-expire"))
|
||
{
|
||
free (ctx->cert_expire);
|
||
ctx->cert_expire = strdup (value);
|
||
if (!ctx->cert_expire)
|
||
err = gpg_error_from_syserror ();
|
||
}
|
||
else if (!strcmp (name, "key-origin"))
|
||
{
|
||
free (ctx->key_origin);
|
||
ctx->key_origin = strdup (value);
|
||
if (!ctx->key_origin)
|
||
err = gpg_error_from_syserror ();
|
||
}
|
||
else if (!strcmp (name, "import-filter"))
|
||
{
|
||
free (ctx->import_filter);
|
||
ctx->import_filter = strdup (value);
|
||
if (!ctx->import_filter)
|
||
err = gpg_error_from_syserror ();
|
||
}
|
||
else
|
||
err = gpg_error (GPG_ERR_UNKNOWN_NAME);
|
||
|
||
return err;
|
||
}
|
||
|
||
|
||
/* Get the context flag named NAME. See gpgme_set_ctx_flag for a list
|
||
* of valid names. If the NAME is unknown NULL is returned. For a
|
||
* boolean flag an empty string is returned for False and the string
|
||
* "1" for True; thus either atoi or a simple string test can be
|
||
* used. */
|
||
const char *
|
||
gpgme_get_ctx_flag (gpgme_ctx_t ctx, const char *name)
|
||
{
|
||
if (!ctx || !name)
|
||
return NULL;
|
||
else if (!strcmp (name, "redraw"))
|
||
{
|
||
return ctx->redraw_suggested? "1":"";
|
||
}
|
||
else if (!strcmp (name, "full-status"))
|
||
{
|
||
return ctx->full_status? "1":"";
|
||
}
|
||
else if (!strcmp (name, "raw-description"))
|
||
{
|
||
return ctx->raw_description? "1":"";
|
||
}
|
||
else if (!strcmp (name, "export-session-key"))
|
||
{
|
||
return ctx->export_session_keys? "1":"";
|
||
}
|
||
else if (!strcmp (name, "override-session-key"))
|
||
{
|
||
return ctx->override_session_key? ctx->override_session_key : "";
|
||
}
|
||
else if (!strcmp (name, "include-key-block"))
|
||
{
|
||
return ctx->include_key_block? "1":"";
|
||
}
|
||
else if (!strcmp (name, "auto-key-import"))
|
||
{
|
||
return ctx->auto_key_import? "1":"";
|
||
}
|
||
else if (!strcmp (name, "auto-key-retrieve"))
|
||
{
|
||
return ctx->auto_key_retrieve? "1":"";
|
||
}
|
||
else if (!strcmp (name, "request-origin"))
|
||
{
|
||
return ctx->request_origin? ctx->request_origin : "";
|
||
}
|
||
else if (!strcmp (name, "no-symkey-cache"))
|
||
{
|
||
return ctx->no_symkey_cache? "1":"";
|
||
}
|
||
else if (!strcmp (name, "ignore-mdc-error"))
|
||
{
|
||
return ctx->ignore_mdc_error? "1":"";
|
||
}
|
||
else if (!strcmp (name, "auto-key-locate"))
|
||
{
|
||
return ctx->auto_key_locate? ctx->auto_key_locate : "";
|
||
}
|
||
else if (!strcmp (name, "extended-edit"))
|
||
{
|
||
return ctx->extended_edit ? "1":"";
|
||
}
|
||
else if (!strcmp (name, "cert-expire"))
|
||
{
|
||
return ctx->cert_expire? ctx->cert_expire : "";
|
||
}
|
||
else if (!strcmp (name, "key-origin"))
|
||
{
|
||
return ctx->key_origin? ctx->key_origin : "";
|
||
}
|
||
else if (!strcmp (name, "import-filter"))
|
||
{
|
||
return ctx->import_filter? ctx->import_filter : "";
|
||
}
|
||
else
|
||
return NULL;
|
||
}
|
||
|
||
|
||
/* Enable or disable the use of the special textmode. Textmode is for
|
||
example used for the RFC2015 signatures; note that the updated RFC
|
||
3156 mandates that the MUA does some preparations so that textmode
|
||
is not needed anymore. */
|
||
void
|
||
gpgme_set_textmode (gpgme_ctx_t ctx, int use_textmode)
|
||
{
|
||
TRACE (DEBUG_CTX, "gpgme_set_textmode", ctx, "use_textmode=%i (%s)",
|
||
use_textmode, use_textmode ? "yes" : "no");
|
||
|
||
if (!ctx)
|
||
return;
|
||
|
||
ctx->use_textmode = !!use_textmode;
|
||
}
|
||
|
||
/* Return the state of the textmode flag. */
|
||
int
|
||
gpgme_get_textmode (gpgme_ctx_t ctx)
|
||
{
|
||
TRACE (DEBUG_CTX, "gpgme_get_textmode", ctx, "ctx->use_textmode=%i (%s)",
|
||
ctx->use_textmode, ctx->use_textmode ? "yes" : "no");
|
||
return ctx->use_textmode;
|
||
}
|
||
|
||
|
||
/* Enable offline mode for this context. In offline mode dirmngr
|
||
will be disabled. */
|
||
void
|
||
gpgme_set_offline (gpgme_ctx_t ctx, int offline)
|
||
{
|
||
TRACE (DEBUG_CTX, "gpgme_set_offline", ctx, "offline=%i (%s)",
|
||
offline, offline ? "yes" : "no");
|
||
|
||
if (!ctx)
|
||
return;
|
||
|
||
ctx->offline = !!offline;
|
||
}
|
||
|
||
/* Return the state of the offline flag. */
|
||
int
|
||
gpgme_get_offline (gpgme_ctx_t ctx)
|
||
{
|
||
TRACE (DEBUG_CTX, "gpgme_get_offline", ctx, "ctx->offline=%i (%s)",
|
||
ctx->offline, ctx->offline ? "yes" : "no");
|
||
return ctx->offline;
|
||
}
|
||
|
||
|
||
/* Set the number of certifications to include in an S/MIME message.
|
||
The default is GPGME_INCLUDE_CERTS_DEFAULT. -1 means all certs,
|
||
and -2 means all certs except the root cert. */
|
||
void
|
||
gpgme_set_include_certs (gpgme_ctx_t ctx, int nr_of_certs)
|
||
{
|
||
if (!ctx)
|
||
return;
|
||
|
||
if (nr_of_certs == GPGME_INCLUDE_CERTS_DEFAULT)
|
||
ctx->include_certs = GPGME_INCLUDE_CERTS_DEFAULT;
|
||
else if (nr_of_certs < -2)
|
||
ctx->include_certs = -2;
|
||
else
|
||
ctx->include_certs = nr_of_certs;
|
||
|
||
TRACE (DEBUG_CTX, "gpgme_set_include_certs", ctx, "nr_of_certs=%i%s",
|
||
nr_of_certs, nr_of_certs == ctx->include_certs ? "" : " (-2)");
|
||
}
|
||
|
||
|
||
/* Get the number of certifications to include in an S/MIME
|
||
message. */
|
||
int
|
||
gpgme_get_include_certs (gpgme_ctx_t ctx)
|
||
{
|
||
TRACE (DEBUG_CTX, "gpgme_get_include_certs", ctx, "ctx->include_certs=%i",
|
||
ctx->include_certs);
|
||
return ctx->include_certs;
|
||
}
|
||
|
||
|
||
/* This function changes the default behaviour of the keylisting
|
||
functions. MODE is a bitwise-OR of the GPGME_KEYLIST_* flags. The
|
||
default mode is GPGME_KEYLIST_MODE_LOCAL. */
|
||
gpgme_error_t
|
||
gpgme_set_keylist_mode (gpgme_ctx_t ctx, gpgme_keylist_mode_t mode)
|
||
{
|
||
TRACE (DEBUG_CTX, "gpgme_set_keylist_mode", ctx, "keylist_mode=0x%x",
|
||
mode);
|
||
|
||
if (!ctx)
|
||
return gpg_error (GPG_ERR_INV_VALUE);
|
||
|
||
ctx->keylist_mode = mode;
|
||
return 0;
|
||
}
|
||
|
||
/* This function returns the default behaviour of the keylisting
|
||
functions. */
|
||
gpgme_keylist_mode_t
|
||
gpgme_get_keylist_mode (gpgme_ctx_t ctx)
|
||
{
|
||
TRACE (DEBUG_CTX, "gpgme_get_keylist_mode", ctx,
|
||
"ctx->keylist_mode=0x%x", ctx->keylist_mode);
|
||
return ctx->keylist_mode;
|
||
}
|
||
|
||
|
||
/* Set the pinentry mode for CTX to MODE. */
|
||
gpgme_error_t
|
||
gpgme_set_pinentry_mode (gpgme_ctx_t ctx, gpgme_pinentry_mode_t mode)
|
||
{
|
||
TRACE (DEBUG_CTX, "gpgme_set_pinentry_mode", ctx, "pinentry_mode=%u",
|
||
(unsigned int)mode);
|
||
|
||
if (!ctx)
|
||
return gpg_error (GPG_ERR_INV_VALUE);
|
||
|
||
switch (mode)
|
||
{
|
||
case GPGME_PINENTRY_MODE_DEFAULT:
|
||
case GPGME_PINENTRY_MODE_ASK:
|
||
case GPGME_PINENTRY_MODE_CANCEL:
|
||
case GPGME_PINENTRY_MODE_ERROR:
|
||
case GPGME_PINENTRY_MODE_LOOPBACK:
|
||
break;
|
||
default:
|
||
return gpg_error (GPG_ERR_INV_VALUE);
|
||
}
|
||
|
||
ctx->pinentry_mode = mode;
|
||
return 0;
|
||
}
|
||
|
||
|
||
/* Get the pinentry mode of CTX. */
|
||
gpgme_pinentry_mode_t
|
||
gpgme_get_pinentry_mode (gpgme_ctx_t ctx)
|
||
{
|
||
TRACE (DEBUG_CTX, "gpgme_get_pinentry_mode", ctx,
|
||
"ctx->pinentry_mode=%u", (unsigned int)ctx->pinentry_mode);
|
||
return ctx->pinentry_mode;
|
||
}
|
||
|
||
|
||
/* This function sets a callback function to be used to pass a
|
||
passphrase to gpg. */
|
||
void
|
||
gpgme_set_passphrase_cb (gpgme_ctx_t ctx, gpgme_passphrase_cb_t cb,
|
||
void *cb_value)
|
||
{
|
||
TRACE (DEBUG_CTX, "gpgme_set_passphrase_cb", ctx,
|
||
"passphrase_cb=%p/%p", cb, cb_value);
|
||
|
||
if (!ctx)
|
||
return;
|
||
|
||
ctx->passphrase_cb = cb;
|
||
ctx->passphrase_cb_value = cb_value;
|
||
}
|
||
|
||
|
||
/* This function returns the callback function to be used to pass a
|
||
passphrase to the crypto engine. */
|
||
void
|
||
gpgme_get_passphrase_cb (gpgme_ctx_t ctx, gpgme_passphrase_cb_t *r_cb,
|
||
void **r_cb_value)
|
||
{
|
||
TRACE (DEBUG_CTX, "gpgme_get_passphrase_cb", ctx,
|
||
"ctx->passphrase_cb=%p/%p",
|
||
ctx->passphrase_cb, ctx->passphrase_cb_value);
|
||
if (r_cb)
|
||
*r_cb = ctx->passphrase_cb;
|
||
if (r_cb_value)
|
||
*r_cb_value = ctx->passphrase_cb_value;
|
||
}
|
||
|
||
|
||
/* This function sets a callback function to be used as a progress
|
||
indicator. */
|
||
void
|
||
gpgme_set_progress_cb (gpgme_ctx_t ctx, gpgme_progress_cb_t cb, void *cb_value)
|
||
{
|
||
TRACE (DEBUG_CTX, "gpgme_set_progress_cb", ctx, "progress_cb=%p/%p",
|
||
cb, cb_value);
|
||
|
||
if (!ctx)
|
||
return;
|
||
|
||
ctx->progress_cb = cb;
|
||
ctx->progress_cb_value = cb_value;
|
||
}
|
||
|
||
|
||
/* This function returns the callback function to be used as a
|
||
progress indicator. */
|
||
void
|
||
gpgme_get_progress_cb (gpgme_ctx_t ctx, gpgme_progress_cb_t *r_cb,
|
||
void **r_cb_value)
|
||
{
|
||
TRACE (DEBUG_CTX, "gpgme_get_progress_cb", ctx, "ctx->progress_cb=%p/%p",
|
||
ctx->progress_cb, ctx->progress_cb_value);
|
||
if (r_cb)
|
||
*r_cb = ctx->progress_cb;
|
||
if (r_cb_value)
|
||
*r_cb_value = ctx->progress_cb_value;
|
||
}
|
||
|
||
|
||
/* This function sets a callback function to be used as a status
|
||
message forwarder. */
|
||
void
|
||
gpgme_set_status_cb (gpgme_ctx_t ctx, gpgme_status_cb_t cb, void *cb_value)
|
||
{
|
||
TRACE (DEBUG_CTX, "gpgme_set_status_cb", ctx, "status_cb=%p/%p",
|
||
cb, cb_value);
|
||
|
||
if (!ctx)
|
||
return;
|
||
|
||
ctx->status_cb = cb;
|
||
ctx->status_cb_value = cb_value;
|
||
}
|
||
|
||
|
||
/* This function returns the callback function to be used as a
|
||
status message forwarder. */
|
||
void
|
||
gpgme_get_status_cb (gpgme_ctx_t ctx, gpgme_status_cb_t *r_cb,
|
||
void **r_cb_value)
|
||
{
|
||
TRACE (DEBUG_CTX, "gpgme_get_status_cb", ctx, "ctx->status_cb=%p/%p",
|
||
ctx ? ctx->status_cb : NULL, ctx ? ctx->status_cb_value : NULL);
|
||
|
||
if (r_cb)
|
||
*r_cb = NULL;
|
||
|
||
if (r_cb_value)
|
||
*r_cb_value = NULL;
|
||
|
||
if (!ctx || !ctx->status_cb)
|
||
return;
|
||
|
||
if (r_cb)
|
||
*r_cb = ctx->status_cb;
|
||
if (r_cb_value)
|
||
*r_cb_value = ctx->status_cb_value;
|
||
}
|
||
|
||
|
||
/* Set the I/O callback functions for CTX to IO_CBS. */
|
||
void
|
||
gpgme_set_io_cbs (gpgme_ctx_t ctx, gpgme_io_cbs_t io_cbs)
|
||
{
|
||
if (!ctx)
|
||
return;
|
||
|
||
if (io_cbs)
|
||
{
|
||
TRACE (DEBUG_CTX, "gpgme_set_io_cbs", ctx,
|
||
"io_cbs=%p (add=%p/%p, remove=%p, event=%p/%p",
|
||
io_cbs, io_cbs->add, io_cbs->add_priv, io_cbs->remove,
|
||
io_cbs->event, io_cbs->event_priv);
|
||
ctx->io_cbs = *io_cbs;
|
||
}
|
||
else
|
||
{
|
||
TRACE (DEBUG_CTX, "gpgme_set_io_cbs", ctx,
|
||
"io_cbs=%p (default)", io_cbs);
|
||
ctx->io_cbs.add = NULL;
|
||
ctx->io_cbs.add_priv = NULL;
|
||
ctx->io_cbs.remove = NULL;
|
||
ctx->io_cbs.event = NULL;
|
||
ctx->io_cbs.event_priv = NULL;
|
||
}
|
||
}
|
||
|
||
|
||
/* This function provides access to the internal read function; it is
|
||
normally not used. */
|
||
gpgme_ssize_t
|
||
gpgme_io_read (int fd, void *buffer, size_t count)
|
||
{
|
||
int ret;
|
||
TRACE_BEG (DEBUG_GLOBAL, "gpgme_io_read", fd,
|
||
"buffer=%p, count=%zu", buffer, count);
|
||
|
||
ret = _gpgme_io_read (fd, buffer, count);
|
||
|
||
return TRACE_SYSRES (ret);
|
||
}
|
||
|
||
|
||
/* This function provides access to the internal write function. It
|
||
is to be used by user callbacks to return data to gpgme. See
|
||
gpgme_passphrase_cb_t and gpgme_edit_cb_t. */
|
||
gpgme_ssize_t
|
||
gpgme_io_write (int fd, const void *buffer, size_t count)
|
||
{
|
||
int ret;
|
||
TRACE_BEG (DEBUG_GLOBAL, "gpgme_io_write", fd,
|
||
"buffer=%p, count=%zu", buffer, count);
|
||
|
||
ret = _gpgme_io_write (fd, buffer, count);
|
||
|
||
return TRACE_SYSRES (ret);
|
||
}
|
||
|
||
/* This function provides access to the internal write function. It
|
||
is to be used by user callbacks to return data to gpgme. See
|
||
gpgme_passphrase_cb_t and gpgme_edit_cb_t. Note that this is a
|
||
variant of gpgme_io_write which guarantees that all COUNT bytes are
|
||
written or an error is return. Returns: 0 on success or -1 on
|
||
error and the sets errno. */
|
||
int
|
||
gpgme_io_writen (int fd, const void *buffer_arg, size_t count)
|
||
{
|
||
const char *buffer = buffer_arg;
|
||
int ret = 0;
|
||
TRACE_BEG (DEBUG_GLOBAL, "gpgme_io_writen", fd,
|
||
"buffer=%p, count=%zu", buffer, count);
|
||
while (count)
|
||
{
|
||
ret = _gpgme_io_write (fd, buffer, count);
|
||
if (ret < 0)
|
||
break;
|
||
buffer += ret;
|
||
count -= ret;
|
||
ret = 0;
|
||
}
|
||
return TRACE_SYSRES (ret);
|
||
}
|
||
|
||
|
||
/* This function returns the callback function for I/O. */
|
||
void
|
||
gpgme_get_io_cbs (gpgme_ctx_t ctx, gpgme_io_cbs_t io_cbs)
|
||
{
|
||
TRACE (DEBUG_CTX, "gpgme_get_io_cbs", ctx,
|
||
"io_cbs=%p, ctx->io_cbs.add=%p/%p, .remove=%p, .event=%p/%p",
|
||
io_cbs, io_cbs->add, io_cbs->add_priv, io_cbs->remove,
|
||
io_cbs->event, io_cbs->event_priv);
|
||
|
||
*io_cbs = ctx->io_cbs;
|
||
}
|
||
|
||
|
||
/* This function sets the locale for the context CTX, or the default
|
||
locale if CTX is a null pointer. */
|
||
gpgme_error_t
|
||
gpgme_set_locale (gpgme_ctx_t ctx, int category, const char *value)
|
||
{
|
||
int failed = 0;
|
||
char *new_lc_ctype = NULL;
|
||
char *new_lc_messages = NULL;
|
||
|
||
TRACE_BEG (DEBUG_CTX, "gpgme_set_locale", ctx,
|
||
"category=%i, value=%s", category, value ? value : "(null)");
|
||
|
||
#define PREPARE_ONE_LOCALE(lcat, ucat) \
|
||
if (!failed && value \
|
||
&& (category == LC_ALL || category == LC_ ## ucat)) \
|
||
{ \
|
||
new_lc_ ## lcat = strdup (value); \
|
||
if (!new_lc_ ## lcat) \
|
||
failed = 1; \
|
||
}
|
||
|
||
#ifdef LC_CTYPE
|
||
PREPARE_ONE_LOCALE (ctype, CTYPE);
|
||
#endif
|
||
#ifdef LC_MESSAGES
|
||
PREPARE_ONE_LOCALE (messages, MESSAGES);
|
||
#endif
|
||
|
||
if (failed)
|
||
{
|
||
int saved_err = gpg_error_from_syserror ();
|
||
|
||
if (new_lc_ctype)
|
||
free (new_lc_ctype);
|
||
if (new_lc_messages)
|
||
free (new_lc_messages);
|
||
|
||
return TRACE_ERR (saved_err);
|
||
}
|
||
|
||
#define SET_ONE_LOCALE(lcat, ucat) \
|
||
if (category == LC_ALL || category == LC_ ## ucat) \
|
||
{ \
|
||
if (ctx) \
|
||
{ \
|
||
if (ctx->lc_ ## lcat) \
|
||
free (ctx->lc_ ## lcat); \
|
||
ctx->lc_ ## lcat = new_lc_ ## lcat; \
|
||
} \
|
||
else \
|
||
{ \
|
||
if (def_lc_ ## lcat) \
|
||
free (def_lc_ ## lcat); \
|
||
def_lc_ ## lcat = new_lc_ ## lcat; \
|
||
} \
|
||
}
|
||
|
||
if (!ctx)
|
||
LOCK (def_lc_lock);
|
||
#ifdef LC_CTYPE
|
||
SET_ONE_LOCALE (ctype, CTYPE);
|
||
#endif
|
||
#ifdef LC_MESSAGES
|
||
SET_ONE_LOCALE (messages, MESSAGES);
|
||
#endif
|
||
if (!ctx)
|
||
UNLOCK (def_lc_lock);
|
||
|
||
return TRACE_ERR (0);
|
||
}
|
||
|
||
|
||
/* Get the information about the configured engines. A pointer to the
|
||
first engine in the statically allocated linked list is returned.
|
||
The returned data is valid until the next gpgme_ctx_set_engine_info. */
|
||
gpgme_engine_info_t
|
||
gpgme_ctx_get_engine_info (gpgme_ctx_t ctx)
|
||
{
|
||
TRACE (DEBUG_CTX, "gpgme_ctx_get_engine_info", ctx,
|
||
"ctx->engine_info=%p", ctx->engine_info);
|
||
return ctx->engine_info;
|
||
}
|
||
|
||
|
||
/* Set the engine info for the context CTX, protocol PROTO, to the
|
||
file name FILE_NAME and the home directory HOME_DIR. */
|
||
gpgme_error_t
|
||
gpgme_ctx_set_engine_info (gpgme_ctx_t ctx, gpgme_protocol_t proto,
|
||
const char *file_name, const char *home_dir)
|
||
{
|
||
gpgme_error_t err;
|
||
TRACE_BEG (DEBUG_CTX, "gpgme_ctx_set_engine_info", ctx,
|
||
"protocol=%i (%s), file_name=%s, home_dir=%s",
|
||
proto, gpgme_get_protocol_name (proto)
|
||
? gpgme_get_protocol_name (proto) : "unknown",
|
||
file_name ? file_name : "(default)",
|
||
home_dir ? home_dir : "(default)");
|
||
|
||
if (!ctx)
|
||
return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
|
||
|
||
/* Shut down the engine when changing engine info. */
|
||
if (ctx->engine)
|
||
{
|
||
TRACE_LOG ("releasing ctx->engine=%p", ctx->engine);
|
||
_gpgme_engine_release (ctx->engine);
|
||
ctx->engine = NULL;
|
||
}
|
||
err = _gpgme_set_engine_info (ctx->engine_info, proto,
|
||
file_name, home_dir);
|
||
return TRACE_ERR (err);
|
||
}
|
||
|
||
|
||
/* Clear all notation data from the context. */
|
||
void
|
||
_gpgme_sig_notation_clear (gpgme_ctx_t ctx)
|
||
{
|
||
gpgme_sig_notation_t notation;
|
||
|
||
if (!ctx)
|
||
return;
|
||
|
||
notation = ctx->sig_notations;
|
||
while (notation)
|
||
{
|
||
gpgme_sig_notation_t next_notation = notation->next;
|
||
_gpgme_sig_notation_free (notation);
|
||
notation = next_notation;
|
||
}
|
||
ctx->sig_notations = NULL;
|
||
}
|
||
|
||
void
|
||
gpgme_sig_notation_clear (gpgme_ctx_t ctx)
|
||
{
|
||
TRACE (DEBUG_CTX, "gpgme_sig_notation_clear", ctx, "");
|
||
|
||
if (!ctx)
|
||
return;
|
||
|
||
_gpgme_sig_notation_clear (ctx);
|
||
}
|
||
|
||
|
||
/* Add the human-readable notation data with name NAME and value VALUE
|
||
to the context CTX, using the flags FLAGS. If NAME is NULL, then
|
||
VALUE should be a policy URL. The flag
|
||
GPGME_SIG_NOTATION_HUMAN_READABLE is forced to be true for notation
|
||
data, and false for policy URLs. */
|
||
gpgme_error_t
|
||
gpgme_sig_notation_add (gpgme_ctx_t ctx, const char *name,
|
||
const char *value, gpgme_sig_notation_flags_t flags)
|
||
{
|
||
gpgme_error_t err;
|
||
gpgme_sig_notation_t notation;
|
||
gpgme_sig_notation_t *lastp;
|
||
|
||
TRACE_BEG (DEBUG_CTX, "gpgme_sig_notation_add", ctx,
|
||
"name=%s, value=%s, flags=0x%x",
|
||
name ? name : "(null)", value ? value : "(null)",
|
||
flags);
|
||
|
||
if (!ctx)
|
||
return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
|
||
|
||
if (name)
|
||
flags |= GPGME_SIG_NOTATION_HUMAN_READABLE;
|
||
else
|
||
flags &= ~GPGME_SIG_NOTATION_HUMAN_READABLE;
|
||
|
||
err = _gpgme_sig_notation_create (¬ation, name, name ? strlen (name) : 0,
|
||
value, value ? strlen (value) : 0, flags);
|
||
if (err)
|
||
return TRACE_ERR (err);
|
||
|
||
lastp = &ctx->sig_notations;
|
||
while (*lastp)
|
||
lastp = &(*lastp)->next;
|
||
|
||
*lastp = notation;
|
||
return TRACE_ERR (0);
|
||
}
|
||
|
||
|
||
/* Get the sig notations for this context. */
|
||
gpgme_sig_notation_t
|
||
gpgme_sig_notation_get (gpgme_ctx_t ctx)
|
||
{
|
||
if (!ctx)
|
||
{
|
||
TRACE (DEBUG_CTX, "gpgme_sig_notation_get", ctx, "");
|
||
return NULL;
|
||
}
|
||
TRACE (DEBUG_CTX, "gpgme_sig_notation_get", ctx,
|
||
"ctx->sig_notations=%p", ctx->sig_notations);
|
||
|
||
return ctx->sig_notations;
|
||
}
|
||
|
||
|
||
|
||
/* Return a public key algorithm string made of the algorithm and size
|
||
or the curve name. May return NULL on error. Caller must free the
|
||
result using gpgme_free. */
|
||
char *
|
||
gpgme_pubkey_algo_string (gpgme_subkey_t subkey)
|
||
{
|
||
const char *prefix = NULL;
|
||
char *result;
|
||
|
||
if (!subkey)
|
||
{
|
||
gpg_err_set_errno (EINVAL);
|
||
return NULL;
|
||
}
|
||
|
||
switch (subkey->pubkey_algo)
|
||
{
|
||
case GPGME_PK_RSA:
|
||
case GPGME_PK_RSA_E:
|
||
case GPGME_PK_RSA_S: prefix = "rsa"; break;
|
||
case GPGME_PK_ELG_E: prefix = "elg"; break;
|
||
case GPGME_PK_DSA: prefix = "dsa"; break;
|
||
case GPGME_PK_ELG: prefix = "xxx"; break;
|
||
case GPGME_PK_ECC:
|
||
case GPGME_PK_ECDH:
|
||
case GPGME_PK_ECDSA:
|
||
case GPGME_PK_EDDSA: prefix = ""; break;
|
||
}
|
||
|
||
if (prefix && *prefix)
|
||
{
|
||
char buffer[40];
|
||
snprintf (buffer, sizeof buffer, "%s%u", prefix, subkey->length);
|
||
result = strdup (buffer);
|
||
}
|
||
else if (prefix && subkey->curve && *subkey->curve)
|
||
result = strdup (subkey->curve);
|
||
else if (prefix)
|
||
result = strdup ("E_error");
|
||
else
|
||
result = strdup ("unknown");
|
||
|
||
return result;
|
||
}
|
||
|
||
|
||
const char *
|
||
gpgme_pubkey_algo_name (gpgme_pubkey_algo_t algo)
|
||
{
|
||
switch (algo)
|
||
{
|
||
case GPGME_PK_RSA: return "RSA";
|
||
case GPGME_PK_RSA_E: return "RSA-E";
|
||
case GPGME_PK_RSA_S: return "RSA-S";
|
||
case GPGME_PK_ELG_E: return "ELG-E";
|
||
case GPGME_PK_DSA: return "DSA";
|
||
case GPGME_PK_ECC: return "ECC";
|
||
case GPGME_PK_ELG: return "ELG";
|
||
case GPGME_PK_ECDSA: return "ECDSA";
|
||
case GPGME_PK_ECDH: return "ECDH";
|
||
case GPGME_PK_EDDSA: return "EdDSA";
|
||
default: return NULL;
|
||
}
|
||
}
|
||
|
||
|
||
const char *
|
||
gpgme_hash_algo_name (gpgme_hash_algo_t algo)
|
||
{
|
||
switch (algo)
|
||
{
|
||
case GPGME_MD_MD5:
|
||
return "MD5";
|
||
|
||
case GPGME_MD_SHA1:
|
||
return "SHA1";
|
||
|
||
case GPGME_MD_RMD160:
|
||
return "RIPEMD160";
|
||
|
||
case GPGME_MD_MD2:
|
||
return "MD2";
|
||
|
||
case GPGME_MD_TIGER:
|
||
return "TIGER192";
|
||
|
||
case GPGME_MD_HAVAL:
|
||
return "HAVAL";
|
||
|
||
case GPGME_MD_SHA256:
|
||
return "SHA256";
|
||
|
||
case GPGME_MD_SHA384:
|
||
return "SHA384";
|
||
|
||
case GPGME_MD_SHA512:
|
||
return "SHA512";
|
||
|
||
case GPGME_MD_SHA224:
|
||
return "SHA224";
|
||
|
||
case GPGME_MD_MD4:
|
||
return "MD4";
|
||
|
||
case GPGME_MD_CRC32:
|
||
return "CRC32";
|
||
|
||
case GPGME_MD_CRC32_RFC1510:
|
||
return "CRC32RFC1510";
|
||
|
||
case GPGME_MD_CRC24_RFC2440:
|
||
return "CRC24RFC2440";
|
||
|
||
default:
|
||
return NULL;
|
||
}
|
||
}
|