LCOV - code coverage report
Current view: top level - src - gpgme.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 266 519 51.3 %
Date: 2018-11-14 16:53:58 Functions: 33 51 64.7 %

          Line data    Source code
       1             : /* gpgme.c - GnuPG Made Easy.
       2             :    Copyright (C) 2000 Werner Koch (dd9jn)
       3             :    Copyright (C) 2001, 2002, 2003, 2004, 2005, 2007, 2012,
       4             :                  2014, 2015 g10 Code GmbH
       5             : 
       6             :    This file is part of GPGME.
       7             : 
       8             :    GPGME is free software; you can redistribute it and/or modify it
       9             :    under the terms of the GNU Lesser General Public License as
      10             :    published by the Free Software Foundation; either version 2.1 of
      11             :    the License, or (at your option) any later version.
      12             : 
      13             :    GPGME is distributed in the hope that it will be useful, but
      14             :    WITHOUT ANY WARRANTY; without even the implied warranty of
      15             :    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      16             :    Lesser General Public License for more details.
      17             : 
      18             :    You should have received a copy of the GNU Lesser General Public
      19             :    License along with this program; if not, see <https://www.gnu.org/licenses/>.
      20             :  */
      21             : 
      22             : #if HAVE_CONFIG_H
      23             : #include <config.h>
      24             : #endif
      25             : #include <stdio.h>
      26             : #include <stdlib.h>
      27             : #include <string.h>
      28             : #include <assert.h>
      29             : #include <errno.h>
      30             : #ifdef HAVE_LOCALE_H
      31             : #include <locale.h>
      32             : #endif
      33             : 
      34             : #include "util.h"
      35             : #include "context.h"
      36             : #include "ops.h"
      37             : #include "wait.h"
      38             : #include "debug.h"
      39             : #include "priv-io.h"
      40             : #include "sys-util.h"
      41             : #include "mbox-util.h"
      42             : 
      43             : 
      44             : /* The default locale.  */
      45             : DEFINE_STATIC_LOCK (def_lc_lock);
      46             : static char *def_lc_ctype;
      47             : static char *def_lc_messages;
      48             : 
      49             : 
      50             : gpgme_error_t _gpgme_selftest = GPG_ERR_NOT_OPERATIONAL;
      51             : 
      52             : /* Protects all reference counters in result structures.  All other
      53             :    accesses to a result structure are read only.  */
      54             : DEFINE_STATIC_LOCK (result_ref_lock);
      55             : 
      56             : 
      57             : /* Set the global flag NAME to VALUE.  Return 0 on success.  Note that
      58             :    this function does not use gpgme_error and thus a non-zero return
      59             :    value merely means "error".  Certain flags may be set before
      60             :    gpgme_check_version is called.  See the manual for a description of
      61             :    supported flags.  The caller must assure that this function is
      62             :    called only by one thread at a time.  */
      63             : int
      64           0 : gpgme_set_global_flag (const char *name, const char *value)
      65             : {
      66           0 :   if (!name || !value)
      67           0 :     return -1;
      68           0 :   else if (!strcmp (name, "debug"))
      69           0 :     return _gpgme_debug_set_debug_envvar (value);
      70           0 :   else if (!strcmp (name, "disable-gpgconf"))
      71             :     {
      72           0 :       _gpgme_dirinfo_disable_gpgconf ();
      73           0 :       return 0;
      74             :     }
      75           0 :   else if (!strcmp (name, "require-gnupg"))
      76           0 :     return _gpgme_set_engine_minimal_version (value);
      77           0 :   else if (!strcmp (name, "gpgconf-name"))
      78           0 :     return _gpgme_set_default_gpgconf_name (value);
      79           0 :   else if (!strcmp (name, "gpg-name"))
      80           0 :     return _gpgme_set_default_gpg_name (value);
      81           0 :   else if (!strcmp (name, "w32-inst-dir"))
      82           0 :     return _gpgme_set_override_inst_dir (value);
      83             :   else
      84           0 :     return -1;
      85             : }
      86             : 
      87             : 
      88             : 
      89             : /* Create a new context as an environment for GPGME crypto
      90             :    operations.  */
      91             : gpgme_error_t
      92         716 : gpgme_new (gpgme_ctx_t *r_ctx)
      93             : {
      94             :   gpgme_error_t err;
      95             :   gpgme_ctx_t ctx;
      96         716 :   TRACE_BEG (DEBUG_CTX, "gpgme_new", r_ctx);
      97             : 
      98         715 :   if (_gpgme_selftest)
      99           0 :     return TRACE_ERR (_gpgme_selftest);
     100             : 
     101         715 :   if (!r_ctx)
     102           0 :     return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
     103             : 
     104         715 :   ctx = calloc (1, sizeof *ctx);
     105         715 :   if (!ctx)
     106           0 :     return TRACE_ERR (gpg_error_from_syserror ());
     107             : 
     108         715 :   INIT_LOCK (ctx->lock);
     109             : 
     110         715 :   err = _gpgme_engine_info_copy (&ctx->engine_info);
     111         715 :   if (!err && !ctx->engine_info)
     112           0 :     err = gpg_error (GPG_ERR_NO_ENGINE);
     113         715 :   if (err)
     114             :     {
     115           0 :       free (ctx);
     116           0 :       return TRACE_ERR (err);
     117             :     }
     118             : 
     119         715 :   ctx->keylist_mode = GPGME_KEYLIST_MODE_LOCAL;
     120         715 :   ctx->include_certs = GPGME_INCLUDE_CERTS_DEFAULT;
     121         715 :   ctx->protocol = GPGME_PROTOCOL_OpenPGP;
     122         715 :   ctx->sub_protocol = GPGME_PROTOCOL_DEFAULT;
     123         715 :   _gpgme_fd_table_init (&ctx->fdt);
     124             : 
     125         715 :   LOCK (def_lc_lock);
     126         715 :   if (def_lc_ctype)
     127             :     {
     128         138 :       ctx->lc_ctype = strdup (def_lc_ctype);
     129         138 :       if (!ctx->lc_ctype)
     130             :         {
     131           0 :           int saved_err = gpg_error_from_syserror ();
     132           0 :           UNLOCK (def_lc_lock);
     133           0 :           _gpgme_engine_info_release (ctx->engine_info);
     134           0 :           free (ctx);
     135           0 :           return TRACE_ERR (saved_err);
     136             :         }
     137             :     }
     138             :   else
     139         577 :     def_lc_ctype = NULL;
     140             : 
     141         715 :   if (def_lc_messages)
     142             :     {
     143         138 :       ctx->lc_messages = strdup (def_lc_messages);
     144         138 :       if (!ctx->lc_messages)
     145             :         {
     146           0 :           int saved_err = gpg_error_from_syserror ();
     147           0 :           UNLOCK (def_lc_lock);
     148           0 :           if (ctx->lc_ctype)
     149           0 :             free (ctx->lc_ctype);
     150           0 :           _gpgme_engine_info_release (ctx->engine_info);
     151           0 :           free (ctx);
     152           0 :           return TRACE_ERR (saved_err);
     153             :         }
     154             :     }
     155             :   else
     156         577 :     def_lc_messages = NULL;
     157         715 :   UNLOCK (def_lc_lock);
     158             : 
     159         715 :   *r_ctx = ctx;
     160             : 
     161         715 :   return TRACE_SUC1 ("ctx=%p", ctx);
     162             : }
     163             : 
     164             : 
     165             : gpgme_error_t
     166          32 : _gpgme_cancel_with_err (gpgme_ctx_t ctx, gpg_error_t ctx_err,
     167             :                         gpg_error_t op_err)
     168             : {
     169             :   gpgme_error_t err;
     170             :   struct gpgme_io_event_done_data data;
     171             : 
     172          32 :   TRACE_BEG2 (DEBUG_CTX, "_gpgme_cancel_with_err", ctx, "ctx_err=%i, op_err=%i",
     173             :               ctx_err, op_err);
     174             : 
     175          32 :   if (ctx_err)
     176             :     {
     177          30 :       err = _gpgme_engine_cancel (ctx->engine);
     178          30 :       if (err)
     179           0 :         return TRACE_ERR (err);
     180             :     }
     181             :   else
     182             :     {
     183           2 :       err = _gpgme_engine_cancel_op (ctx->engine);
     184           2 :       if (err)
     185           0 :         return TRACE_ERR (err);
     186             :     }
     187             : 
     188          32 :   data.err = ctx_err;
     189          32 :   data.op_err = op_err;
     190             : 
     191          32 :   _gpgme_engine_io_event (ctx->engine, GPGME_EVENT_DONE, &data);
     192             : 
     193          32 :   return TRACE_ERR (0);
     194             : }
     195             : 
     196             : 
     197             : /* Cancel a pending asynchronous operation.  */
     198             : gpgme_error_t
     199           0 : gpgme_cancel (gpgme_ctx_t ctx)
     200             : {
     201             :   gpg_error_t err;
     202             : 
     203           0 :   TRACE_BEG (DEBUG_CTX, "gpgme_cancel", ctx);
     204             : 
     205           0 :   if (!ctx)
     206           0 :     return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
     207             : 
     208           0 :   err = _gpgme_cancel_with_err (ctx, gpg_error (GPG_ERR_CANCELED), 0);
     209             : 
     210           0 :   return TRACE_ERR (err);
     211             : }
     212             : 
     213             : 
     214             : /* Cancel a pending operation asynchronously.  */
     215             : gpgme_error_t
     216          17 : gpgme_cancel_async (gpgme_ctx_t ctx)
     217             : {
     218          17 :   TRACE_BEG (DEBUG_CTX, "gpgme_cancel_async", ctx);
     219             : 
     220          17 :   if (!ctx)
     221           0 :     return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
     222             : 
     223          17 :   LOCK (ctx->lock);
     224          17 :   ctx->canceled = 1;
     225          17 :   UNLOCK (ctx->lock);
     226             : 
     227          17 :   return TRACE_ERR (0);
     228             : }
     229             : 
     230             : 
     231             : /* Release all resources associated with the given context.  */
     232             : void
     233         701 : gpgme_release (gpgme_ctx_t ctx)
     234             : {
     235         701 :   TRACE (DEBUG_CTX, "gpgme_release", ctx);
     236             : 
     237         701 :   if (!ctx)
     238           0 :     return;
     239             : 
     240         701 :   _gpgme_engine_release (ctx->engine);
     241         701 :   ctx->engine = NULL;
     242         701 :   _gpgme_fd_table_deinit (&ctx->fdt);
     243         701 :   _gpgme_release_result (ctx);
     244         701 :   _gpgme_signers_clear (ctx);
     245         701 :   _gpgme_sig_notation_clear (ctx);
     246         701 :   free (ctx->sender);
     247         701 :   free (ctx->signers);
     248         701 :   free (ctx->lc_ctype);
     249         701 :   free (ctx->lc_messages);
     250         701 :   free (ctx->override_session_key);
     251         701 :   free (ctx->request_origin);
     252         701 :   free (ctx->auto_key_locate);
     253         701 :   free (ctx->trust_model);
     254         701 :   _gpgme_engine_info_release (ctx->engine_info);
     255         701 :   ctx->engine_info = NULL;
     256         701 :   DESTROY_LOCK (ctx->lock);
     257         701 :   free (ctx);
     258             : }
     259             : 
     260             : 
     261             : void
     262           0 : gpgme_result_ref (void *result)
     263             : {
     264             :   struct ctx_op_data *data;
     265             : 
     266           0 :   if (! result)
     267           0 :     return;
     268             : 
     269           0 :   data = (void*)((char*)result - sizeof (struct ctx_op_data));
     270             : 
     271           0 :   assert (data->magic == CTX_OP_DATA_MAGIC);
     272             : 
     273           0 :   LOCK (result_ref_lock);
     274           0 :   data->references++;
     275           0 :   UNLOCK (result_ref_lock);
     276             : }
     277             : 
     278             : 
     279             : void
     280         919 : gpgme_result_unref (void *result)
     281             : {
     282             :   struct ctx_op_data *data;
     283             : 
     284         919 :   if (! result)
     285           0 :     return;
     286             : 
     287         919 :   data = (void*)((char*)result - sizeof (struct ctx_op_data));
     288             : 
     289         919 :   assert (data->magic == CTX_OP_DATA_MAGIC);
     290             : 
     291         919 :   LOCK (result_ref_lock);
     292         919 :   if (--data->references)
     293             :     {
     294           0 :       UNLOCK (result_ref_lock);
     295           0 :       return;
     296             :     }
     297         919 :   UNLOCK (result_ref_lock);
     298             : 
     299         919 :   if (data->cleanup)
     300         875 :     (*data->cleanup) (data->hook);
     301         919 :   free (data);
     302             : }
     303             : 
     304             : 
     305             : void
     306        1664 : _gpgme_release_result (gpgme_ctx_t ctx)
     307             : {
     308        1664 :   struct ctx_op_data *data = ctx->op_data;
     309             : 
     310        4247 :   while (data)
     311             :     {
     312         919 :       struct ctx_op_data *next_data = data->next;
     313         919 :       data->next = NULL;
     314         919 :       gpgme_result_unref (data->hook);
     315         919 :       data = next_data;
     316             :     }
     317        1664 :   ctx->op_data = NULL;
     318        1664 : }
     319             : 
     320             : 
     321             : gpgme_error_t
     322         493 : gpgme_set_protocol (gpgme_ctx_t ctx, gpgme_protocol_t protocol)
     323             : {
     324         493 :   TRACE_BEG2 (DEBUG_CTX, "gpgme_set_protocol", ctx, "protocol=%i (%s)",
     325             :               protocol, gpgme_get_protocol_name (protocol)
     326             :               ? gpgme_get_protocol_name (protocol) : "invalid");
     327             : 
     328         493 :   if (protocol != GPGME_PROTOCOL_OpenPGP
     329          22 :       && protocol != GPGME_PROTOCOL_CMS
     330          14 :       && protocol != GPGME_PROTOCOL_GPGCONF
     331          14 :       && protocol != GPGME_PROTOCOL_ASSUAN
     332           0 :       && protocol != GPGME_PROTOCOL_G13
     333           0 :       && protocol != GPGME_PROTOCOL_UISERVER
     334           0 :       && protocol != GPGME_PROTOCOL_SPAWN)
     335           0 :     return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
     336             : 
     337         493 :   if (!ctx)
     338           0 :     return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
     339             : 
     340         493 :   if (ctx->protocol != protocol)
     341             :     {
     342             :       /* Shut down the engine when switching protocols.  */
     343          22 :       if (ctx->engine)
     344             :         {
     345          12 :           TRACE_LOG1 ("releasing ctx->engine=%p", ctx->engine);
     346          12 :           _gpgme_engine_release (ctx->engine);
     347          12 :           ctx->engine = NULL;
     348             :         }
     349             : 
     350          22 :       ctx->protocol = protocol;
     351             :     }
     352         493 :   return TRACE_ERR (0);
     353             : }
     354             : 
     355             : 
     356             : gpgme_protocol_t
     357         538 : gpgme_get_protocol (gpgme_ctx_t ctx)
     358             : {
     359         538 :   TRACE2 (DEBUG_CTX, "gpgme_get_protocol", ctx,
     360             :           "ctx->protocol=%i (%s)", ctx->protocol,
     361             :           gpgme_get_protocol_name (ctx->protocol)
     362             :           ? gpgme_get_protocol_name (ctx->protocol) : "invalid");
     363             : 
     364         538 :   return ctx->protocol;
     365             : }
     366             : 
     367             : 
     368             : gpgme_error_t
     369           0 : gpgme_set_sub_protocol (gpgme_ctx_t ctx, gpgme_protocol_t protocol)
     370             : {
     371           0 :   TRACE2 (DEBUG_CTX, "gpgme_set_sub_protocol", ctx, "protocol=%i (%s)",
     372             :           protocol, gpgme_get_protocol_name (protocol)
     373             :           ? gpgme_get_protocol_name (protocol) : "invalid");
     374             : 
     375           0 :   if (!ctx)
     376           0 :     return gpg_error (GPG_ERR_INV_VALUE);
     377             : 
     378           0 :   ctx->sub_protocol = protocol;
     379           0 :   return 0;
     380             : }
     381             : 
     382             : 
     383             : gpgme_protocol_t
     384           0 : gpgme_get_sub_protocol (gpgme_ctx_t ctx)
     385             : {
     386           0 :   TRACE2 (DEBUG_CTX, "gpgme_get_sub_protocol", ctx,
     387             :           "ctx->sub_protocol=%i (%s)", ctx->sub_protocol,
     388             :           gpgme_get_protocol_name (ctx->sub_protocol)
     389             :           ? gpgme_get_protocol_name (ctx->sub_protocol) : "invalid");
     390             : 
     391           0 :   return ctx->sub_protocol;
     392             : }
     393             : 
     394             : 
     395             : const char *
     396        2916 : gpgme_get_protocol_name (gpgme_protocol_t protocol)
     397             : {
     398        2916 :   switch (protocol)
     399             :     {
     400             :     case GPGME_PROTOCOL_OpenPGP:
     401        2808 :       return "OpenPGP";
     402             : 
     403             :     case GPGME_PROTOCOL_CMS:
     404          20 :       return "CMS";
     405             : 
     406             :     case GPGME_PROTOCOL_GPGCONF:
     407           4 :       return "GPGCONF";
     408             : 
     409             :     case GPGME_PROTOCOL_ASSUAN:
     410          84 :       return "Assuan";
     411             : 
     412             :     case GPGME_PROTOCOL_G13:
     413           0 :       return "G13";
     414             : 
     415             :     case GPGME_PROTOCOL_UISERVER:
     416           0 :       return "UIServer";
     417             : 
     418             :     case GPGME_PROTOCOL_SPAWN:
     419           0 :       return "Spawn";
     420             : 
     421             :     case GPGME_PROTOCOL_DEFAULT:
     422           0 :       return "default";
     423             : 
     424             :     case GPGME_PROTOCOL_UNKNOWN:
     425           0 :       return "unknown";
     426             : 
     427             :     default:
     428           0 :       return NULL;
     429             :     }
     430             : }
     431             : 
     432             : 
     433             : /* Store the sender's address in the context.  ADDRESS is addr-spec of
     434             :  * mailbox but my also be a complete mailbox, in which case this
     435             :  * function extracts the addr-spec from it.  Returns 0 on success or
     436             :  * an error code if no valid addr-spec could be extracted from
     437             :  * ADDRESS.  */
     438             : gpgme_error_t
     439           5 : gpgme_set_sender (gpgme_ctx_t ctx, const char *address)
     440             : {
     441           5 :   char *p = NULL;
     442             : 
     443           5 :   TRACE_BEG1 (DEBUG_CTX, "gpgme_set_sender", ctx, "sender='%s'",
     444             :               address?address:"(null)");
     445             : 
     446           5 :   if (!ctx || (address && !(p = _gpgme_mailbox_from_userid (address))))
     447           1 :     return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
     448             : 
     449           4 :   free (ctx->sender);
     450           4 :   ctx->sender = p;
     451           4 :   return TRACE_ERR (0);
     452             : }
     453             : 
     454             : 
     455             : /* Return the sender's address (addr-spec part) from the context or
     456             :  * NULL if none was set.  The returned value is valid as long as the
     457             :  * CTX is valid and gpgme_set_sender has not been used.  */
     458             : const char *
     459           4 : gpgme_get_sender (gpgme_ctx_t ctx)
     460             : {
     461           4 :   TRACE1 (DEBUG_CTX, "gpgme_get_sender", ctx, "sender='%s'",
     462             :           ctx?ctx->sender:"");
     463             : 
     464           4 :   return ctx->sender;
     465             : }
     466             : 
     467             : 
     468             : /* Enable or disable the use of an ascii armor for all output.  */
     469             : void
     470         238 : gpgme_set_armor (gpgme_ctx_t ctx, int use_armor)
     471             : {
     472         238 :   TRACE2 (DEBUG_CTX, "gpgme_set_armor", ctx, "use_armor=%i (%s)",
     473             :           use_armor, use_armor ? "yes" : "no");
     474             : 
     475         238 :   if (!ctx)
     476           0 :     return;
     477             : 
     478         238 :   ctx->use_armor = !!use_armor;
     479             : }
     480             : 
     481             : 
     482             : /* Return the state of the armor flag.  */
     483             : int
     484           0 : gpgme_get_armor (gpgme_ctx_t ctx)
     485             : {
     486           0 :   TRACE2 (DEBUG_CTX, "gpgme_get_armor", ctx, "ctx->use_armor=%i (%s)",
     487             :           ctx->use_armor, ctx->use_armor ? "yes" : "no");
     488           0 :   return ctx->use_armor;
     489             : }
     490             : 
     491             : 
     492             : /* Set the flag NAME for CTX to VALUE.  Please consult the manual for
     493             :  * a description of the flags.
     494             :  */
     495             : gpgme_error_t
     496           4 : gpgme_set_ctx_flag (gpgme_ctx_t ctx, const char *name, const char *value)
     497             : {
     498           4 :   gpgme_error_t err = 0;
     499             :   int abool;
     500             : 
     501           4 :   TRACE2 (DEBUG_CTX, "gpgme_set_ctx_flag", ctx,
     502             :           "name='%s' value='%s'",
     503             :           name? name:"(null)", value?value:"(null)");
     504             : 
     505           4 :   abool = (value && *value)? !!atoi (value) : 0;
     506             : 
     507           4 :   if (!ctx || !name || !value)
     508           0 :     err = gpg_error (GPG_ERR_INV_VALUE);
     509           4 :   else if (!strcmp (name, "redraw"))
     510             :     {
     511           0 :       ctx->redraw_suggested = abool;
     512             :     }
     513           4 :   else if (!strcmp (name, "full-status"))
     514             :     {
     515           4 :       ctx->full_status = abool;
     516             :     }
     517           0 :   else if (!strcmp (name, "raw-description"))
     518             :     {
     519           0 :       ctx->raw_description = abool;
     520             :     }
     521           0 :   else if (!strcmp (name, "export-session-key"))
     522             :     {
     523           0 :       ctx->export_session_keys = abool;
     524             :     }
     525           0 :   else if (!strcmp (name, "override-session-key"))
     526             :     {
     527           0 :       free (ctx->override_session_key);
     528           0 :       ctx->override_session_key = strdup (value);
     529           0 :       if (!ctx->override_session_key)
     530           0 :         err = gpg_error_from_syserror ();
     531             :     }
     532           0 :   else if (!strcmp (name, "auto-key-retrieve"))
     533             :     {
     534           0 :       ctx->auto_key_retrieve = abool;
     535             :     }
     536           0 :   else if (!strcmp (name, "request-origin"))
     537             :     {
     538           0 :       free (ctx->request_origin);
     539           0 :       ctx->request_origin = strdup (value);
     540           0 :       if (!ctx->request_origin)
     541           0 :         err = gpg_error_from_syserror ();
     542             :     }
     543           0 :   else if (!strcmp (name, "no-symkey-cache"))
     544             :     {
     545           0 :       ctx->no_symkey_cache = abool;
     546             :     }
     547           0 :   else if (!strcmp (name, "ignore-mdc-error"))
     548             :     {
     549           0 :       ctx->ignore_mdc_error = abool;
     550             :     }
     551           0 :   else if (!strcmp (name, "auto-key-locate"))
     552             :     {
     553           0 :       free (ctx->auto_key_locate);
     554           0 :       ctx->auto_key_locate = strdup (value);
     555           0 :       if (!ctx->auto_key_locate)
     556           0 :         err = gpg_error_from_syserror ();
     557             :     }
     558           0 :   else if (!strcmp (name, "trust-model"))
     559             :     {
     560           0 :       free (ctx->trust_model);
     561           0 :       ctx->trust_model = strdup (value);
     562           0 :       if (!ctx->trust_model)
     563           0 :         err = gpg_error_from_syserror ();
     564             :     }
     565             :   else
     566           0 :     err = gpg_error (GPG_ERR_UNKNOWN_NAME);
     567             : 
     568           4 :   return err;
     569             : }
     570             : 
     571             : 
     572             : /* Get the context flag named NAME.  See gpgme_set_ctx_flag for a list
     573             :  * of valid names.  If the NAME is unknown NULL is returned.  For a
     574             :  * boolean flag an empty string is returned for False and the string
     575             :  * "1" for True; thus either atoi or a simple string test can be
     576             :  * used.  */
     577             : const char *
     578           0 : gpgme_get_ctx_flag (gpgme_ctx_t ctx, const char *name)
     579             : {
     580           0 :   if (!ctx || !name)
     581           0 :     return NULL;
     582           0 :   else if (!strcmp (name, "redraw"))
     583             :     {
     584           0 :       return ctx->redraw_suggested? "1":"";
     585             :     }
     586           0 :   else if (!strcmp (name, "full-status"))
     587             :     {
     588           0 :       return ctx->full_status? "1":"";
     589             :     }
     590           0 :   else if (!strcmp (name, "raw-description"))
     591             :     {
     592           0 :       return ctx->raw_description? "1":"";
     593             :     }
     594           0 :   else if (!strcmp (name, "export-session-key"))
     595             :     {
     596           0 :       return ctx->export_session_keys? "1":"";
     597             :     }
     598           0 :   else if (!strcmp (name, "override-session-key"))
     599             :     {
     600           0 :       return ctx->override_session_key? ctx->override_session_key : "";
     601             :     }
     602           0 :   else if (!strcmp (name, "auto-key-retrieve"))
     603             :     {
     604           0 :       return ctx->auto_key_retrieve? "1":"";
     605             :     }
     606           0 :   else if (!strcmp (name, "request-origin"))
     607             :     {
     608           0 :       return ctx->request_origin? ctx->request_origin : "";
     609             :     }
     610           0 :   else if (!strcmp (name, "no-symkey-cache"))
     611             :     {
     612           0 :       return ctx->no_symkey_cache? "1":"";
     613             :     }
     614           0 :   else if (!strcmp (name, "ignore-mdc-error"))
     615             :     {
     616           0 :       return ctx->ignore_mdc_error? "1":"";
     617             :     }
     618           0 :   else if (!strcmp (name, "auto-key-locate"))
     619             :     {
     620           0 :       return ctx->auto_key_locate? ctx->auto_key_locate : "";
     621             :     }
     622             :   else
     623           0 :     return NULL;
     624             : }
     625             : 
     626             : 
     627             : /* Enable or disable the use of the special textmode.  Textmode is for
     628             :   example used for the RFC2015 signatures; note that the updated RFC
     629             :   3156 mandates that the MUA does some preparations so that textmode
     630             :   is not needed anymore.  */
     631             : void
     632         199 : gpgme_set_textmode (gpgme_ctx_t ctx, int use_textmode)
     633             : {
     634         199 :   TRACE2 (DEBUG_CTX, "gpgme_set_textmode", ctx, "use_textmode=%i (%s)",
     635             :           use_textmode, use_textmode ? "yes" : "no");
     636             : 
     637         199 :   if (!ctx)
     638           0 :     return;
     639             : 
     640         199 :   ctx->use_textmode = !!use_textmode;
     641             : }
     642             : 
     643             : /* Return the state of the textmode flag.  */
     644             : int
     645           0 : gpgme_get_textmode (gpgme_ctx_t ctx)
     646             : {
     647           0 :   TRACE2 (DEBUG_CTX, "gpgme_get_textmode", ctx, "ctx->use_textmode=%i (%s)",
     648             :           ctx->use_textmode, ctx->use_textmode ? "yes" : "no");
     649           0 :   return ctx->use_textmode;
     650             : }
     651             : 
     652             : 
     653             : /* Enable offline mode for this context. In offline mode dirmngr
     654             :   will be disabled. */
     655             : void
     656         167 : gpgme_set_offline (gpgme_ctx_t ctx, int offline)
     657             : {
     658         167 :   TRACE2 (DEBUG_CTX, "gpgme_set_offline", ctx, "offline=%i (%s)",
     659             :           offline, offline ? "yes" : "no");
     660             : 
     661         167 :   if (!ctx)
     662           0 :     return;
     663             : 
     664         167 :   ctx->offline = !!offline;
     665             : }
     666             : 
     667             : /* Return the state of the offline flag.  */
     668             : int
     669           0 : gpgme_get_offline (gpgme_ctx_t ctx)
     670             : {
     671           0 :   TRACE2 (DEBUG_CTX, "gpgme_get_offline", ctx, "ctx->offline=%i (%s)",
     672             :           ctx->offline, ctx->offline ? "yes" : "no");
     673           0 :   return ctx->offline;
     674             : }
     675             : 
     676             : 
     677             : /* Set the number of certifications to include in an S/MIME message.
     678             :    The default is GPGME_INCLUDE_CERTS_DEFAULT.  -1 means all certs,
     679             :    and -2 means all certs except the root cert.  */
     680             : void
     681           0 : gpgme_set_include_certs (gpgme_ctx_t ctx, int nr_of_certs)
     682             : {
     683           0 :   if (!ctx)
     684           0 :     return;
     685             : 
     686           0 :   if (nr_of_certs == GPGME_INCLUDE_CERTS_DEFAULT)
     687           0 :     ctx->include_certs = GPGME_INCLUDE_CERTS_DEFAULT;
     688           0 :   else if (nr_of_certs < -2)
     689           0 :     ctx->include_certs = -2;
     690             :   else
     691           0 :     ctx->include_certs = nr_of_certs;
     692             : 
     693           0 :   TRACE2 (DEBUG_CTX, "gpgme_set_include_certs", ctx, "nr_of_certs=%i%s",
     694             :           nr_of_certs, nr_of_certs == ctx->include_certs ? "" : " (-2)");
     695             : }
     696             : 
     697             : 
     698             : /* Get the number of certifications to include in an S/MIME
     699             :    message.  */
     700             : int
     701           0 : gpgme_get_include_certs (gpgme_ctx_t ctx)
     702             : {
     703           0 :   TRACE1 (DEBUG_CTX, "gpgme_get_include_certs", ctx, "ctx->include_certs=%i",
     704             :           ctx->include_certs);
     705           0 :   return ctx->include_certs;
     706             : }
     707             : 
     708             : 
     709             : /* This function changes the default behaviour of the keylisting
     710             :    functions.  MODE is a bitwise-OR of the GPGME_KEYLIST_* flags.  The
     711             :    default mode is GPGME_KEYLIST_MODE_LOCAL.  */
     712             : gpgme_error_t
     713         308 : gpgme_set_keylist_mode (gpgme_ctx_t ctx, gpgme_keylist_mode_t mode)
     714             : {
     715         308 :   TRACE1 (DEBUG_CTX, "gpgme_set_keylist_mode", ctx, "keylist_mode=0x%x",
     716             :           mode);
     717             : 
     718         308 :   if (!ctx)
     719           0 :     return gpg_error (GPG_ERR_INV_VALUE);
     720             : 
     721         308 :   ctx->keylist_mode = mode;
     722         308 :   return 0;
     723             : }
     724             : 
     725             : /* This function returns the default behaviour of the keylisting
     726             :    functions.  */
     727             : gpgme_keylist_mode_t
     728         265 : gpgme_get_keylist_mode (gpgme_ctx_t ctx)
     729             : {
     730         265 :   TRACE1 (DEBUG_CTX, "gpgme_get_keylist_mode", ctx,
     731             :           "ctx->keylist_mode=0x%x", ctx->keylist_mode);
     732         265 :   return ctx->keylist_mode;
     733             : }
     734             : 
     735             : 
     736             : /* Set the pinentry mode for CTX to MODE. */
     737             : gpgme_error_t
     738         223 : gpgme_set_pinentry_mode (gpgme_ctx_t ctx, gpgme_pinentry_mode_t mode)
     739             : {
     740         223 :   TRACE1 (DEBUG_CTX, "gpgme_set_pinentry_mode", ctx, "pinentry_mode=%u",
     741             :           (unsigned int)mode);
     742             : 
     743         223 :   if (!ctx)
     744           0 :     return gpg_error (GPG_ERR_INV_VALUE);
     745             : 
     746         223 :   switch (mode)
     747             :     {
     748             :     case GPGME_PINENTRY_MODE_DEFAULT:
     749             :     case GPGME_PINENTRY_MODE_ASK:
     750             :     case GPGME_PINENTRY_MODE_CANCEL:
     751             :     case GPGME_PINENTRY_MODE_ERROR:
     752             :     case GPGME_PINENTRY_MODE_LOOPBACK:
     753         223 :       break;
     754             :     default:
     755           0 :       return gpg_error (GPG_ERR_INV_VALUE);
     756             :     }
     757             : 
     758         223 :   ctx->pinentry_mode = mode;
     759         223 :   return 0;
     760             : }
     761             : 
     762             : 
     763             : /* Get the pinentry mode of CTX.  */
     764             : gpgme_pinentry_mode_t
     765          12 : gpgme_get_pinentry_mode (gpgme_ctx_t ctx)
     766             : {
     767          12 :   TRACE1 (DEBUG_CTX, "gpgme_get_pinentry_mode", ctx,
     768             :           "ctx->pinentry_mode=%u", (unsigned int)ctx->pinentry_mode);
     769          12 :   return ctx->pinentry_mode;
     770             : }
     771             : 
     772             : 
     773             : /* This function sets a callback function to be used to pass a
     774             :    passphrase to gpg.  */
     775             : void
     776         250 : gpgme_set_passphrase_cb (gpgme_ctx_t ctx, gpgme_passphrase_cb_t cb,
     777             :                          void *cb_value)
     778             : {
     779         250 :   TRACE2 (DEBUG_CTX, "gpgme_set_passphrase_cb", ctx,
     780             :           "passphrase_cb=%p/%p", cb, cb_value);
     781             : 
     782         250 :   if (!ctx)
     783           0 :     return;
     784             : 
     785         250 :   ctx->passphrase_cb = cb;
     786         250 :   ctx->passphrase_cb_value = cb_value;
     787             : }
     788             : 
     789             : 
     790             : /* This function returns the callback function to be used to pass a
     791             :    passphrase to the crypto engine.  */
     792             : void
     793           0 : gpgme_get_passphrase_cb (gpgme_ctx_t ctx, gpgme_passphrase_cb_t *r_cb,
     794             :                          void **r_cb_value)
     795             : {
     796           0 :   TRACE2 (DEBUG_CTX, "gpgme_get_passphrase_cb", ctx,
     797             :           "ctx->passphrase_cb=%p/%p",
     798             :           ctx->passphrase_cb, ctx->passphrase_cb_value);
     799           0 :   if (r_cb)
     800           0 :     *r_cb = ctx->passphrase_cb;
     801           0 :   if (r_cb_value)
     802           0 :     *r_cb_value = ctx->passphrase_cb_value;
     803           0 : }
     804             : 
     805             : 
     806             : /* This function sets a callback function to be used as a progress
     807             :    indicator.  */
     808             : void
     809         210 : gpgme_set_progress_cb (gpgme_ctx_t ctx, gpgme_progress_cb_t cb, void *cb_value)
     810             : {
     811         210 :   TRACE2 (DEBUG_CTX, "gpgme_set_progress_cb", ctx, "progress_cb=%p/%p",
     812             :           cb, cb_value);
     813             : 
     814         210 :   if (!ctx)
     815           0 :     return;
     816             : 
     817         210 :   ctx->progress_cb = cb;
     818         210 :   ctx->progress_cb_value = cb_value;
     819             : }
     820             : 
     821             : 
     822             : /* This function returns the callback function to be used as a
     823             :    progress indicator.  */
     824             : void
     825           0 : gpgme_get_progress_cb (gpgme_ctx_t ctx, gpgme_progress_cb_t *r_cb,
     826             :                        void **r_cb_value)
     827             : {
     828           0 :   TRACE2 (DEBUG_CTX, "gpgme_get_progress_cb", ctx, "ctx->progress_cb=%p/%p",
     829             :           ctx->progress_cb, ctx->progress_cb_value);
     830           0 :   if (r_cb)
     831           0 :     *r_cb = ctx->progress_cb;
     832           0 :   if (r_cb_value)
     833           0 :     *r_cb_value = ctx->progress_cb_value;
     834           0 : }
     835             : 
     836             : 
     837             : /* This function sets a callback function to be used as a status
     838             :    message forwarder.  */
     839             : void
     840         163 : gpgme_set_status_cb (gpgme_ctx_t ctx, gpgme_status_cb_t cb, void *cb_value)
     841             : {
     842         163 :   TRACE2 (DEBUG_CTX, "gpgme_set_status_cb", ctx, "status_cb=%p/%p",
     843             :           cb, cb_value);
     844             : 
     845         163 :   if (!ctx)
     846           0 :     return;
     847             : 
     848         163 :   ctx->status_cb = cb;
     849         163 :   ctx->status_cb_value = cb_value;
     850             : }
     851             : 
     852             : 
     853             : /* This function returns the callback function to be used as a
     854             :    status message forwarder.  */
     855             : void
     856           0 : gpgme_get_status_cb (gpgme_ctx_t ctx, gpgme_status_cb_t *r_cb,
     857             :                        void **r_cb_value)
     858             : {
     859           0 :   TRACE2 (DEBUG_CTX, "gpgme_get_status_cb", ctx, "ctx->status_cb=%p/%p",
     860             :           ctx ? ctx->status_cb : NULL, ctx ? ctx->status_cb_value : NULL);
     861             : 
     862           0 :   if (r_cb)
     863           0 :     *r_cb = NULL;
     864             : 
     865           0 :   if (r_cb_value)
     866           0 :     *r_cb_value = NULL;
     867             : 
     868           0 :   if (!ctx || !ctx->status_cb)
     869           0 :     return;
     870             : 
     871           0 :   if (r_cb)
     872           0 :     *r_cb = ctx->status_cb;
     873           0 :   if (r_cb_value)
     874           0 :     *r_cb_value = ctx->status_cb_value;
     875             : }
     876             : 
     877             : 
     878             : /* Set the I/O callback functions for CTX to IO_CBS.  */
     879             : void
     880           1 : gpgme_set_io_cbs (gpgme_ctx_t ctx, gpgme_io_cbs_t io_cbs)
     881             : {
     882           1 :   if (!ctx)
     883           0 :     return;
     884             : 
     885           1 :   if (io_cbs)
     886             :     {
     887           1 :       TRACE6 (DEBUG_CTX, "gpgme_set_io_cbs", ctx,
     888             :               "io_cbs=%p (add=%p/%p, remove=%p, event=%p/%p",
     889             :               io_cbs, io_cbs->add, io_cbs->add_priv, io_cbs->remove,
     890             :               io_cbs->event, io_cbs->event_priv);
     891           1 :       ctx->io_cbs = *io_cbs;
     892             :     }
     893             :   else
     894             :     {
     895           0 :       TRACE1 (DEBUG_CTX, "gpgme_set_io_cbs", ctx,
     896             :               "io_cbs=%p (default)", io_cbs);
     897           0 :       ctx->io_cbs.add = NULL;
     898           0 :       ctx->io_cbs.add_priv = NULL;
     899           0 :       ctx->io_cbs.remove = NULL;
     900           0 :       ctx->io_cbs.event = NULL;
     901           0 :       ctx->io_cbs.event_priv = NULL;
     902             :     }
     903             : }
     904             : 
     905             : 
     906             : /* This function provides access to the internal read function; it is
     907             :    normally not used.  */
     908             : gpgme_ssize_t
     909           0 : gpgme_io_read (int fd, void *buffer, size_t count)
     910             : {
     911             :   int ret;
     912           0 :   TRACE_BEG2 (DEBUG_GLOBAL, "gpgme_io_read", fd,
     913             :               "buffer=%p, count=%u", buffer, count);
     914             : 
     915           0 :   ret = _gpgme_io_read (fd, buffer, count);
     916             : 
     917           0 :   return TRACE_SYSRES (ret);
     918             : }
     919             : 
     920             : 
     921             : /* This function provides access to the internal write function.  It
     922             :    is to be used by user callbacks to return data to gpgme.  See
     923             :    gpgme_passphrase_cb_t and gpgme_edit_cb_t.  */
     924             : gpgme_ssize_t
     925          26 : gpgme_io_write (int fd, const void *buffer, size_t count)
     926             : {
     927             :   int ret;
     928          26 :   TRACE_BEG2 (DEBUG_GLOBAL, "gpgme_io_write", fd,
     929             :               "buffer=%p, count=%u", buffer, count);
     930             : 
     931          26 :   ret = _gpgme_io_write (fd, buffer, count);
     932             : 
     933          26 :   return TRACE_SYSRES (ret);
     934             : }
     935             : 
     936             : /* This function provides access to the internal write function.  It
     937             :    is to be used by user callbacks to return data to gpgme.  See
     938             :    gpgme_passphrase_cb_t and gpgme_edit_cb_t.  Note that this is a
     939             :    variant of gpgme_io_write which guarantees that all COUNT bytes are
     940             :    written or an error is return.  Returns: 0 on success or -1 on
     941             :    error and the sets errno. */
     942             : int
     943          14 : gpgme_io_writen (int fd, const void *buffer_arg, size_t count)
     944             : {
     945          14 :   const char *buffer = buffer_arg;
     946          14 :   int ret = 0;
     947          14 :   TRACE_BEG2 (DEBUG_GLOBAL, "gpgme_io_writen", fd,
     948             :               "buffer=%p, count=%u", buffer, count);
     949          42 :   while (count)
     950             :     {
     951          14 :       ret = _gpgme_io_write (fd, buffer, count);
     952          14 :       if (ret < 0)
     953           0 :         break;
     954          14 :       buffer += ret;
     955          14 :       count -= ret;
     956          14 :       ret = 0;
     957             :     }
     958          14 :   return TRACE_SYSRES (ret);
     959             : }
     960             : 
     961             : 
     962             : /* This function returns the callback function for I/O.  */
     963             : void
     964           0 : gpgme_get_io_cbs (gpgme_ctx_t ctx, gpgme_io_cbs_t io_cbs)
     965             : {
     966           0 :   TRACE6 (DEBUG_CTX, "gpgme_get_io_cbs", ctx,
     967             :           "io_cbs=%p, ctx->io_cbs.add=%p/%p, .remove=%p, .event=%p/%p",
     968             :           io_cbs, io_cbs->add, io_cbs->add_priv, io_cbs->remove,
     969             :           io_cbs->event, io_cbs->event_priv);
     970             : 
     971           0 :   *io_cbs = ctx->io_cbs;
     972           0 : }
     973             : 
     974             : 
     975             : /* This function sets the locale for the context CTX, or the default
     976             :    locale if CTX is a null pointer.  */
     977             : gpgme_error_t
     978          98 : gpgme_set_locale (gpgme_ctx_t ctx, int category, const char *value)
     979             : {
     980          98 :   int failed = 0;
     981          98 :   char *new_lc_ctype = NULL;
     982          98 :   char *new_lc_messages = NULL;
     983             : 
     984          98 :   TRACE_BEG2 (DEBUG_CTX, "gpgme_set_locale", ctx,
     985             :                "category=%i, value=%s", category, value ? value : "(null)");
     986             : 
     987             : #define PREPARE_ONE_LOCALE(lcat, ucat)                          \
     988             :   if (!failed && value                                          \
     989             :       && (category == LC_ALL || category == LC_ ## ucat))       \
     990             :     {                                                           \
     991             :       new_lc_ ## lcat = strdup (value);                         \
     992             :       if (!new_lc_ ## lcat)                                     \
     993             :         failed = 1;                                             \
     994             :     }
     995             : 
     996             : #ifdef LC_CTYPE
     997          98 :   PREPARE_ONE_LOCALE (ctype, CTYPE);
     998             : #endif
     999             : #ifdef LC_MESSAGES
    1000          98 :   PREPARE_ONE_LOCALE (messages, MESSAGES);
    1001             : #endif
    1002             : 
    1003          98 :   if (failed)
    1004             :     {
    1005           0 :       int saved_err = gpg_error_from_syserror ();
    1006             : 
    1007           0 :       if (new_lc_ctype)
    1008           0 :         free (new_lc_ctype);
    1009           0 :       if (new_lc_messages)
    1010           0 :         free (new_lc_messages);
    1011             : 
    1012           0 :       return TRACE_ERR (saved_err);
    1013             :     }
    1014             : 
    1015             : #define SET_ONE_LOCALE(lcat, ucat)                      \
    1016             :   if (category == LC_ALL || category == LC_ ## ucat)    \
    1017             :     {                                                   \
    1018             :       if (ctx)                                          \
    1019             :         {                                               \
    1020             :           if (ctx->lc_ ## lcat)                              \
    1021             :             free (ctx->lc_ ## lcat);                 \
    1022             :           ctx->lc_ ## lcat = new_lc_ ## lcat;                \
    1023             :         }                                               \
    1024             :       else                                              \
    1025             :         {                                               \
    1026             :           if (def_lc_ ## lcat)                          \
    1027             :             free (def_lc_ ## lcat);                     \
    1028             :           def_lc_ ## lcat = new_lc_ ## lcat;            \
    1029             :         }                                               \
    1030             :     }
    1031             : 
    1032          98 :   if (!ctx)
    1033          98 :     LOCK (def_lc_lock);
    1034             : #ifdef LC_CTYPE
    1035          98 :   SET_ONE_LOCALE (ctype, CTYPE);
    1036             : #endif
    1037             : #ifdef LC_MESSAGES
    1038          98 :   SET_ONE_LOCALE (messages, MESSAGES);
    1039             : #endif
    1040          98 :   if (!ctx)
    1041          98 :     UNLOCK (def_lc_lock);
    1042             : 
    1043          98 :   return TRACE_ERR (0);
    1044             : }
    1045             : 
    1046             : 
    1047             : /* Get the information about the configured engines.  A pointer to the
    1048             :    first engine in the statically allocated linked list is returned.
    1049             :    The returned data is valid until the next gpgme_ctx_set_engine_info.  */
    1050             : gpgme_engine_info_t
    1051         318 : gpgme_ctx_get_engine_info (gpgme_ctx_t ctx)
    1052             : {
    1053         318 :   TRACE1 (DEBUG_CTX, "gpgme_ctx_get_engine_info", ctx,
    1054             :           "ctx->engine_info=%p", ctx->engine_info);
    1055         318 :   return ctx->engine_info;
    1056             : }
    1057             : 
    1058             : 
    1059             : /* Set the engine info for the context CTX, protocol PROTO, to the
    1060             :    file name FILE_NAME and the home directory HOME_DIR.  */
    1061             : gpgme_error_t
    1062         427 : gpgme_ctx_set_engine_info (gpgme_ctx_t ctx, gpgme_protocol_t proto,
    1063             :                            const char *file_name, const char *home_dir)
    1064             : {
    1065             :   gpgme_error_t err;
    1066         427 :   TRACE_BEG4 (DEBUG_CTX, "gpgme_ctx_set_engine_info", ctx,
    1067             :               "protocol=%i (%s), file_name=%s, home_dir=%s",
    1068             :               proto, gpgme_get_protocol_name (proto)
    1069             :               ? gpgme_get_protocol_name (proto) : "unknown",
    1070             :               file_name ? file_name : "(default)",
    1071             :               home_dir ? home_dir : "(default)");
    1072             : 
    1073         427 :   if (!ctx)
    1074           0 :     return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
    1075             : 
    1076             :   /* Shut down the engine when changing engine info.  */
    1077         427 :   if (ctx->engine)
    1078             :     {
    1079           1 :       TRACE_LOG1 ("releasing ctx->engine=%p", ctx->engine);
    1080           1 :       _gpgme_engine_release (ctx->engine);
    1081           1 :       ctx->engine = NULL;
    1082             :     }
    1083         427 :   err = _gpgme_set_engine_info (ctx->engine_info, proto,
    1084             :                                 file_name, home_dir);
    1085         428 :   return TRACE_ERR (err);
    1086             : }
    1087             : 
    1088             : 
    1089             : /* Clear all notation data from the context.  */
    1090             : void
    1091         701 : _gpgme_sig_notation_clear (gpgme_ctx_t ctx)
    1092             : {
    1093             :   gpgme_sig_notation_t notation;
    1094             : 
    1095         701 :   if (!ctx)
    1096           0 :     return;
    1097             : 
    1098         701 :   notation = ctx->sig_notations;
    1099        1411 :   while (notation)
    1100             :     {
    1101           9 :       gpgme_sig_notation_t next_notation = notation->next;
    1102           9 :       _gpgme_sig_notation_free (notation);
    1103           9 :       notation = next_notation;
    1104             :     }
    1105         701 :   ctx->sig_notations = NULL;
    1106             : }
    1107             : 
    1108             : void
    1109           0 : gpgme_sig_notation_clear (gpgme_ctx_t ctx)
    1110             : {
    1111           0 :   TRACE (DEBUG_CTX, "gpgme_sig_notation_clear", ctx);
    1112             : 
    1113           0 :   if (!ctx)
    1114           0 :     return;
    1115             : 
    1116           0 :   _gpgme_sig_notation_clear (ctx);
    1117             : }
    1118             : 
    1119             : 
    1120             : /* Add the human-readable notation data with name NAME and value VALUE
    1121             :    to the context CTX, using the flags FLAGS.  If NAME is NULL, then
    1122             :    VALUE should be a policy URL.  The flag
    1123             :    GPGME_SIG_NOTATION_HUMAN_READABLE is forced to be true for notation
    1124             :    data, and false for policy URLs.  */
    1125             : gpgme_error_t
    1126           9 : gpgme_sig_notation_add (gpgme_ctx_t ctx, const char *name,
    1127             :                         const char *value, gpgme_sig_notation_flags_t flags)
    1128             : {
    1129             :   gpgme_error_t err;
    1130             :   gpgme_sig_notation_t notation;
    1131             :   gpgme_sig_notation_t *lastp;
    1132             : 
    1133           9 :   TRACE_BEG3 (DEBUG_CTX, "gpgme_sig_notation_add", ctx,
    1134             :               "name=%s, value=%s, flags=0x%x",
    1135             :               name ? name : "(null)", value ? value : "(null)",
    1136             :               flags);
    1137             : 
    1138           9 :   if (!ctx)
    1139           0 :     return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
    1140             : 
    1141           9 :   if (name)
    1142           6 :     flags |= GPGME_SIG_NOTATION_HUMAN_READABLE;
    1143             :   else
    1144           3 :     flags &= ~GPGME_SIG_NOTATION_HUMAN_READABLE;
    1145             : 
    1146          18 :   err = _gpgme_sig_notation_create (&notation, name, name ? strlen (name) : 0,
    1147           9 :                                     value, value ? strlen (value) : 0, flags);
    1148           9 :   if (err)
    1149           0 :     return TRACE_ERR (err);
    1150             : 
    1151           9 :   lastp = &ctx->sig_notations;
    1152          27 :   while (*lastp)
    1153           9 :     lastp = &(*lastp)->next;
    1154             : 
    1155           9 :   *lastp = notation;
    1156           9 :   return TRACE_ERR (0);
    1157             : }
    1158             : 
    1159             : 
    1160             : /* Get the sig notations for this context.  */
    1161             : gpgme_sig_notation_t
    1162          63 : gpgme_sig_notation_get (gpgme_ctx_t ctx)
    1163             : {
    1164          63 :   if (!ctx)
    1165             :     {
    1166           0 :       TRACE (DEBUG_CTX, "gpgme_sig_notation_get", ctx);
    1167           0 :       return NULL;
    1168             :     }
    1169          63 :   TRACE1 (DEBUG_CTX, "gpgme_sig_notation_get", ctx,
    1170             :           "ctx->sig_notations=%p", ctx->sig_notations);
    1171             : 
    1172          63 :   return ctx->sig_notations;
    1173             : }
    1174             : 
    1175             : 
    1176             : 
    1177             : /* Return a public key algorithm string made of the algorithm and size
    1178             :    or the curve name.  May return NULL on error.  Caller must free the
    1179             :    result using gpgme_free.  */
    1180             : char *
    1181           0 : gpgme_pubkey_algo_string (gpgme_subkey_t subkey)
    1182             : {
    1183           0 :   const char *prefix = NULL;
    1184             :   char *result;
    1185             : 
    1186           0 :   if (!subkey)
    1187             :     {
    1188           0 :       gpg_err_set_errno (EINVAL);
    1189           0 :       return NULL;
    1190             :     }
    1191             : 
    1192           0 :   switch (subkey->pubkey_algo)
    1193             :     {
    1194             :     case GPGME_PK_RSA:
    1195             :     case GPGME_PK_RSA_E:
    1196           0 :     case GPGME_PK_RSA_S: prefix = "rsa"; break;
    1197           0 :     case GPGME_PK_ELG_E: prefix = "elg"; break;
    1198           0 :     case GPGME_PK_DSA:   prefix = "dsa"; break;
    1199           0 :     case GPGME_PK_ELG:   prefix = "xxx"; break;
    1200             :     case GPGME_PK_ECC:
    1201             :     case GPGME_PK_ECDH:
    1202             :     case GPGME_PK_ECDSA:
    1203           0 :     case GPGME_PK_EDDSA: prefix = "";    break;
    1204             :     }
    1205             : 
    1206           0 :   if (prefix && *prefix)
    1207           0 :     {
    1208             :       char buffer[40];
    1209           0 :       snprintf (buffer, sizeof buffer, "%s%u", prefix, subkey->length);
    1210           0 :       result = strdup (buffer);
    1211             :     }
    1212           0 :   else if (prefix && subkey->curve && *subkey->curve)
    1213           0 :     result = strdup (subkey->curve);
    1214           0 :   else if (prefix)
    1215           0 :     result =  strdup ("E_error");
    1216             :   else
    1217           0 :     result = strdup  ("unknown");
    1218             : 
    1219           0 :   return result;
    1220             : }
    1221             : 
    1222             : 
    1223             : const char *
    1224          70 : gpgme_pubkey_algo_name (gpgme_pubkey_algo_t algo)
    1225             : {
    1226          70 :   switch (algo)
    1227             :     {
    1228           6 :     case GPGME_PK_RSA:   return "RSA";
    1229           1 :     case GPGME_PK_RSA_E: return "RSA-E";
    1230           1 :     case GPGME_PK_RSA_S: return "RSA-S";
    1231           1 :     case GPGME_PK_ELG_E: return "ELG-E";
    1232          47 :     case GPGME_PK_DSA:   return "DSA";
    1233           1 :     case GPGME_PK_ECC:   return "ECC";
    1234           1 :     case GPGME_PK_ELG:   return "ELG";
    1235           1 :     case GPGME_PK_ECDSA: return "ECDSA";
    1236           1 :     case GPGME_PK_ECDH:  return "ECDH";
    1237           4 :     case GPGME_PK_EDDSA: return "EdDSA";
    1238           6 :     default:             return NULL;
    1239             :     }
    1240             : }
    1241             : 
    1242             : 
    1243             : const char *
    1244          60 : gpgme_hash_algo_name (gpgme_hash_algo_t algo)
    1245             : {
    1246          60 :   switch (algo)
    1247             :     {
    1248             :     case GPGME_MD_MD5:
    1249           0 :       return "MD5";
    1250             : 
    1251             :     case GPGME_MD_SHA1:
    1252          39 :       return "SHA1";
    1253             : 
    1254             :     case GPGME_MD_RMD160:
    1255           8 :       return "RIPEMD160";
    1256             : 
    1257             :     case GPGME_MD_MD2:
    1258           0 :       return "MD2";
    1259             : 
    1260             :     case GPGME_MD_TIGER:
    1261           0 :       return "TIGER192";
    1262             : 
    1263             :     case GPGME_MD_HAVAL:
    1264           0 :       return "HAVAL";
    1265             : 
    1266             :     case GPGME_MD_SHA256:
    1267           3 :       return "SHA256";
    1268             : 
    1269             :     case GPGME_MD_SHA384:
    1270           0 :       return "SHA384";
    1271             : 
    1272             :     case GPGME_MD_SHA512:
    1273           4 :       return "SHA512";
    1274             : 
    1275             :     case GPGME_MD_SHA224:
    1276           0 :       return "SHA224";
    1277             : 
    1278             :     case GPGME_MD_MD4:
    1279           0 :       return "MD4";
    1280             : 
    1281             :     case GPGME_MD_CRC32:
    1282           0 :       return "CRC32";
    1283             : 
    1284             :     case GPGME_MD_CRC32_RFC1510:
    1285           0 :       return "CRC32RFC1510";
    1286             : 
    1287             :     case GPGME_MD_CRC24_RFC2440:
    1288           0 :       return "CRC24RFC2440";
    1289             : 
    1290             :     default:
    1291           6 :       return NULL;
    1292             :     }
    1293             : }

Generated by: LCOV version 1.13