src/gpgme.c

   1 /* gpgme.c - GnuPG Made Easy.
   2    Copyright (C) 2000 Werner Koch (dd9jn)
   3    Copyright (C) 2001, 2002, 2003, 2004, 2005, 2007 g10 Code GmbH
   4
   5    This file is part of GPGME.
   6
   7    GPGME is free software; you can redistribute it and/or modify it
   8    under the terms of the GNU Lesser General Public License as
   9    published by the Free Software Foundation; either version 2.1 of
  10    the License, or (at your option) any later version.
  11
  12    GPGME is distributed in the hope that it will be useful, but
  13    WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15    Lesser General Public License for more details.
  16
  17    You should have received a copy of the GNU Lesser General Public
  18    License along with this program; if not, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  20    02111-1307, USA.  */
  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
  41 \f
  42 /* The default locale.  */
  43 DEFINE_STATIC_LOCK (def_lc_lock);
  44 static char *def_lc_ctype;
  45 static char *def_lc_messages;
  46
  47 \f
  48 gpgme_error_t _gpgme_selftest = GPG_ERR_NOT_OPERATIONAL;
  49
  50 /* Protects all reference counters in result structures.  All other
  51    accesses to a result structure are read only.  */
  52 DEFINE_STATIC_LOCK (result_ref_lock);
  53
  54 \f
  55 /* Create a new context as an environment for GPGME crypto
  56    operations.  */
  57 gpgme_error_t
  58 gpgme_new (gpgme_ctx_t *r_ctx)
  59 {
  60   gpgme_ctx_t ctx;
  61   TRACE_BEG (DEBUG_CTX, "gpgme_new", r_ctx);
  62
  63   if (_gpgme_selftest)
  64     return TRACE_ERR (gpgme_error (_gpgme_selftest));
  65
  66   ctx = calloc (1, sizeof *ctx);
  67   if (!ctx)
  68     return TRACE_ERR (gpg_error_from_errno (errno));
  69
  70   INIT_LOCK (ctx->lock);
  71
  72   _gpgme_engine_info_copy (&ctx->engine_info);
  73   if (!ctx->engine_info)
  74     {
  75       free (ctx);
  76       return TRACE_ERR (gpg_error_from_errno (errno));
  77     }
  78
  79   ctx->keylist_mode = GPGME_KEYLIST_MODE_LOCAL;
  80   ctx->include_certs = GPGME_INCLUDE_CERTS_DEFAULT;
  81   ctx->protocol = GPGME_PROTOCOL_OpenPGP;
  82   ctx->sub_protocol = GPGME_PROTOCOL_DEFAULT;
  83   _gpgme_fd_table_init (&ctx->fdt);
  84
  85   LOCK (def_lc_lock);
  86   if (def_lc_ctype)
  87     {
  88       ctx->lc_ctype = strdup (def_lc_ctype);
  89       if (!ctx->lc_ctype)
  90         {
  91           UNLOCK (def_lc_lock);
  92           _gpgme_engine_info_release (ctx->engine_info);
  93           free (ctx);
  94           return TRACE_ERR (gpg_error_from_errno (errno));
  95         }
  96     }
  97   else
  98     def_lc_ctype = NULL;
  99
 100   if (def_lc_messages)
 101     {
 102       ctx->lc_messages = strdup (def_lc_messages);
 103       if (!ctx->lc_messages)
 104         {
 105           UNLOCK (def_lc_lock);
 106           if (ctx->lc_ctype)
 107             free (ctx->lc_ctype);
 108           _gpgme_engine_info_release (ctx->engine_info);
 109           free (ctx);
 110           return TRACE_ERR (gpg_error_from_errno (errno));
 111         }
 112     }
 113   else
 114     def_lc_messages = NULL;
 115   UNLOCK (def_lc_lock);
 116
 117   *r_ctx = ctx;
 118
 119   return TRACE_SUC1 ("ctx=%p", ctx);
 120 }
 121
 122
 123 gpgme_error_t
 124 _gpgme_cancel_with_err (gpgme_ctx_t ctx, gpg_error_t ctx_err,
 125                         gpg_error_t op_err)
 126 {
 127   gpgme_error_t err;
 128   struct gpgme_io_event_done_data data;
 129
 130   TRACE_BEG2 (DEBUG_CTX, "_gpgme_cancel_with_err", ctx, "ctx_err=%i, op_err=%i",
 131               ctx_err, op_err);
 132
 133   if (ctx_err)
 134     {
 135       err = _gpgme_engine_cancel (ctx->engine);
 136       if (err)
 137         return TRACE_ERR (err);
 138     }
 139   else
 140     {
 141       err = _gpgme_engine_cancel_op (ctx->engine);
 142       if (err)
 143         return TRACE_ERR (err);
 144     }
 145
 146   data.err = ctx_err;
 147   data.op_err = op_err;
 148
 149   _gpgme_engine_io_event (ctx->engine, GPGME_EVENT_DONE, &data);
 150
 151   return TRACE_ERR (0);
 152 }
 153
 154
 155 /* Cancel a pending asynchronous operation.  */
 156 gpgme_error_t
 157 gpgme_cancel (gpgme_ctx_t ctx)
 158 {
 159   gpg_error_t err;
 160
 161   TRACE_BEG (DEBUG_CTX, "gpgme_cancel", ctx);
 162
 163   err = _gpgme_cancel_with_err (ctx, gpg_error (GPG_ERR_CANCELED), 0);
 164
 165   return TRACE_ERR (err);
 166 }
 167
 168
 169 /* Cancel a pending operation asynchronously.  */
 170 gpgme_error_t
 171 gpgme_cancel_async (gpgme_ctx_t ctx)
 172 {
 173   TRACE_BEG (DEBUG_CTX, "gpgme_cancel_async", ctx);
 174
 175   LOCK (ctx->lock);
 176   ctx->canceled = 1;
 177   UNLOCK (ctx->lock);
 178
 179   return TRACE_ERR (0);
 180 }
 181
 182
 183 /* Release all resources associated with the given context.  */
 184 void
 185 gpgme_release (gpgme_ctx_t ctx)
 186 {
 187   TRACE (DEBUG_CTX, "gpgme_release", ctx);
 188
 189   _gpgme_engine_release (ctx->engine);
 190   _gpgme_fd_table_deinit (&ctx->fdt);
 191   _gpgme_release_result (ctx);
 192   _gpgme_signers_clear (ctx);
 193   _gpgme_sig_notation_clear (ctx);
 194   if (ctx->signers)
 195     free (ctx->signers);
 196   if (ctx->lc_ctype)
 197     free (ctx->lc_ctype);
 198   if (ctx->lc_messages)
 199     free (ctx->lc_messages);
 200   _gpgme_engine_info_release (ctx->engine_info);
 201   DESTROY_LOCK (ctx->lock);
 202   free (ctx);
 203 }
 204
 205
 206 void
 207 gpgme_result_ref (void *result)
 208 {
 209   struct ctx_op_data *data;
 210
 211   if (! result)
 212     return;
 213
 214   data = result - sizeof (struct ctx_op_data);
 215
 216   assert (data->magic == CTX_OP_DATA_MAGIC);
 217
 218   LOCK (result_ref_lock);
 219   data->references++;
 220   UNLOCK (result_ref_lock);
 221 }
 222
 223
 224 void
 225 gpgme_result_unref (void *result)
 226 {
 227   struct ctx_op_data *data;
 228
 229   if (! result)
 230     return;
 231
 232   data = result - sizeof (struct ctx_op_data);
 233
 234   assert (data->magic == CTX_OP_DATA_MAGIC);
 235
 236   LOCK (result_ref_lock);
 237   if (--data->references)
 238     {
 239       UNLOCK (result_ref_lock);
 240       return;
 241     }
 242   UNLOCK (result_ref_lock);
 243
 244   if (data->cleanup)
 245     (*data->cleanup) (data->hook);
 246   free (data);
 247 }
 248
 249
 250 void
 251 _gpgme_release_result (gpgme_ctx_t ctx)
 252 {
 253   struct ctx_op_data *data = ctx->op_data;
 254
 255   while (data)
 256     {
 257       struct ctx_op_data *next_data = data->next;
 258       data->next = NULL;
 259       gpgme_result_unref (data->hook);
 260       data = next_data;
 261     }
 262   ctx->op_data = NULL;
 263 }
 264
 265
 266 gpgme_error_t
 267 gpgme_set_protocol (gpgme_ctx_t ctx, gpgme_protocol_t protocol)
 268 {
 269   TRACE_BEG2 (DEBUG_CTX, "gpgme_set_protocol", ctx, "protocol=%i (%s)",
 270               protocol, gpgme_get_protocol_name (protocol)
 271               ? gpgme_get_protocol_name (protocol) : "invalid");
 272
 273   if (protocol != GPGME_PROTOCOL_OpenPGP
 274       && protocol != GPGME_PROTOCOL_CMS
 275       && protocol != GPGME_PROTOCOL_GPGCONF
 276       && protocol != GPGME_PROTOCOL_ASSUAN
 277       && protocol != GPGME_PROTOCOL_G13
 278       && protocol != GPGME_PROTOCOL_UISERVER)
 279     return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
 280
 281   if (ctx->protocol != protocol)
 282     {
 283       /* Shut down the engine when switching protocols.  */
 284       if (ctx->engine)
 285         {
 286           TRACE_LOG1 ("releasing ctx->engine=%p", ctx->engine);
 287           _gpgme_engine_release (ctx->engine);
 288           ctx->engine = NULL;
 289         }
 290
 291       ctx->protocol = protocol;
 292     }
 293   return TRACE_ERR (0);
 294 }
 295
 296
 297 gpgme_protocol_t
 298 gpgme_get_protocol (gpgme_ctx_t ctx)
 299 {
 300   TRACE2 (DEBUG_CTX, "gpgme_get_protocol", ctx,
 301           "ctx->protocol=%i (%s)", ctx->protocol,
 302           gpgme_get_protocol_name (ctx->protocol)
 303           ? gpgme_get_protocol_name (ctx->protocol) : "invalid");
 304   return ctx->protocol;
 305 }
 306
 307
 308 gpgme_error_t
 309 gpgme_set_sub_protocol (gpgme_ctx_t ctx, gpgme_protocol_t protocol)
 310 {
 311   TRACE2 (DEBUG_CTX, "gpgme_set_sub_protocol", ctx, "protocol=%i (%s)",
 312           protocol, gpgme_get_protocol_name (protocol)
 313           ? gpgme_get_protocol_name (protocol) : "invalid");
 314   ctx->sub_protocol = protocol;
 315   return 0;
 316 }
 317
 318
 319 gpgme_error_t
 320 gpgme_get_sub_protocol (gpgme_ctx_t ctx)
 321 {
 322   TRACE2 (DEBUG_CTX, "gpgme_get_sub_protocol", ctx,
 323           "ctx->sub_protocol=%i (%s)", ctx->sub_protocol,
 324           gpgme_get_protocol_name (ctx->sub_protocol)
 325           ? gpgme_get_protocol_name (ctx->sub_protocol) : "invalid");
 326   return ctx->sub_protocol;
 327 }
 328
 329
 330 const char *
 331 gpgme_get_protocol_name (gpgme_protocol_t protocol)
 332 {
 333   switch (protocol)
 334     {
 335     case GPGME_PROTOCOL_OpenPGP:
 336       return "OpenPGP";
 337
 338     case GPGME_PROTOCOL_CMS:
 339       return "CMS";
 340
 341     case GPGME_PROTOCOL_GPGCONF:
 342       return "GPGCONF";
 343
 344     case GPGME_PROTOCOL_ASSUAN:
 345       return "Assuan";
 346
 347     case GPGME_PROTOCOL_G13:
 348       return "G13";
 349
 350     case GPGME_PROTOCOL_UISERVER:
 351       return "UIServer";
 352
 353     case GPGME_PROTOCOL_DEFAULT:
 354       return "default";
 355
 356     case GPGME_PROTOCOL_UNKNOWN:
 357       return "unknown";
 358
 359     default:
 360       return NULL;
 361     }
 362 }
 363
 364 /* Enable or disable the use of an ascii armor for all output.  */
 365 void
 366 gpgme_set_armor (gpgme_ctx_t ctx, int use_armor)
 367 {
 368   TRACE2 (DEBUG_CTX, "gpgme_set_armor", ctx, "use_armor=%i (%s)",
 369           use_armor, use_armor ? "yes" : "no");
 370   ctx->use_armor = use_armor;
 371 }
 372
 373
 374 /* Return the state of the armor flag.  */
 375 int
 376 gpgme_get_armor (gpgme_ctx_t ctx)
 377 {
 378   TRACE2 (DEBUG_CTX, "gpgme_get_armor", ctx, "ctx->use_armor=%i (%s)",
 379           ctx->use_armor, ctx->use_armor ? "yes" : "no");
 380   return ctx->use_armor;
 381 }
 382
 383
 384 /* Enable or disable the use of the special textmode.  Textmode is for
 385   example used for the RFC2015 signatures; note that the updated RFC
 386   3156 mandates that the MUA does some preparations so that textmode
 387   is not needed anymore.  */
 388 void
 389 gpgme_set_textmode (gpgme_ctx_t ctx, int use_textmode)
 390 {
 391   TRACE2 (DEBUG_CTX, "gpgme_set_textmode", ctx, "use_textmode=%i (%s)",
 392           use_textmode, use_textmode ? "yes" : "no");
 393   ctx->use_textmode = use_textmode;
 394 }
 395
 396 /* Return the state of the textmode flag.  */
 397 int
 398 gpgme_get_textmode (gpgme_ctx_t ctx)
 399 {
 400   TRACE2 (DEBUG_CTX, "gpgme_get_textmode", ctx, "ctx->use_textmode=%i (%s)",
 401           ctx->use_textmode, ctx->use_textmode ? "yes" : "no");
 402   return ctx->use_textmode;
 403 }
 404
 405
 406 /* Set the number of certifications to include in an S/MIME message.
 407    The default is GPGME_INCLUDE_CERTS_DEFAULT.  -1 means all certs,
 408    and -2 means all certs except the root cert.  */
 409 void
 410 gpgme_set_include_certs (gpgme_ctx_t ctx, int nr_of_certs)
 411 {
 412   if (nr_of_certs == GPGME_INCLUDE_CERTS_DEFAULT)
 413     ctx->include_certs = GPGME_INCLUDE_CERTS_DEFAULT;
 414   else if (nr_of_certs < -2)
 415     ctx->include_certs = -2;
 416   else
 417     ctx->include_certs = nr_of_certs;
 418
 419   TRACE2 (DEBUG_CTX, "gpgme_set_include_certs", ctx, "nr_of_certs=%i%s",
 420           nr_of_certs, nr_of_certs == ctx->include_certs ? "" : " (-2)");
 421 }
 422
 423
 424 /* Get the number of certifications to include in an S/MIME
 425    message.  */
 426 int
 427 gpgme_get_include_certs (gpgme_ctx_t ctx)
 428 {
 429   TRACE1 (DEBUG_CTX, "gpgme_get_include_certs", ctx, "ctx->include_certs=%i",
 430           ctx->include_certs);
 431   return ctx->include_certs;
 432 }
 433
 434
 435 /* This function changes the default behaviour of the keylisting
 436    functions.  MODE is a bitwise-OR of the GPGME_KEYLIST_* flags.  The
 437    default mode is GPGME_KEYLIST_MODE_LOCAL.  */
 438 gpgme_error_t
 439 gpgme_set_keylist_mode (gpgme_ctx_t ctx, gpgme_keylist_mode_t mode)
 440 {
 441   TRACE1 (DEBUG_CTX, "gpgme_set_keylist_mode", ctx, "keylist_mode=0x%x",
 442           mode);
 443
 444   ctx->keylist_mode = mode;
 445   return 0;
 446 }
 447
 448 /* This function returns the default behaviour of the keylisting
 449    functions.  */
 450 gpgme_keylist_mode_t
 451 gpgme_get_keylist_mode (gpgme_ctx_t ctx)
 452 {
 453   TRACE1 (DEBUG_CTX, "gpgme_get_keylist_mode", ctx,
 454           "ctx->keylist_mode=0x%x", ctx->keylist_mode);
 455   return ctx->keylist_mode;
 456 }
 457
 458
 459 /* This function sets a callback function to be used to pass a
 460    passphrase to gpg.  */
 461 void
 462 gpgme_set_passphrase_cb (gpgme_ctx_t ctx, gpgme_passphrase_cb_t cb,
 463                          void *cb_value)
 464 {
 465   TRACE2 (DEBUG_CTX, "gpgme_set_passphrase_cb", ctx,
 466           "passphrase_cb=%p/%p", cb, cb_value);
 467   ctx->passphrase_cb = cb;
 468   ctx->passphrase_cb_value = cb_value;
 469 }
 470
 471
 472 /* This function returns the callback function to be used to pass a
 473    passphrase to the crypto engine.  */
 474 void
 475 gpgme_get_passphrase_cb (gpgme_ctx_t ctx, gpgme_passphrase_cb_t *r_cb,
 476                          void **r_cb_value)
 477 {
 478   TRACE2 (DEBUG_CTX, "gpgme_get_passphrase_cb", ctx,
 479           "ctx->passphrase_cb=%p/%p",
 480           ctx->passphrase_cb, ctx->passphrase_cb_value);
 481   if (r_cb)
 482     *r_cb = ctx->passphrase_cb;
 483   if (r_cb_value)
 484     *r_cb_value = ctx->passphrase_cb_value;
 485 }
 486
 487
 488 /* This function sets a callback function to be used as a progress
 489    indicator.  */
 490 void
 491 gpgme_set_progress_cb (gpgme_ctx_t ctx, gpgme_progress_cb_t cb, void *cb_value)
 492 {
 493   TRACE2 (DEBUG_CTX, "gpgme_set_progress_cb", ctx, "progress_cb=%p/%p",
 494           cb, cb_value);
 495   ctx->progress_cb = cb;
 496   ctx->progress_cb_value = cb_value;
 497 }
 498
 499
 500 /* This function returns the callback function to be used as a
 501    progress indicator.  */
 502 void
 503 gpgme_get_progress_cb (gpgme_ctx_t ctx, gpgme_progress_cb_t *r_cb,
 504                        void **r_cb_value)
 505 {
 506   TRACE2 (DEBUG_CTX, "gpgme_get_progress_cb", ctx, "ctx->progress_cb=%p/%p",
 507           ctx->progress_cb, ctx->progress_cb_value);
 508   if (r_cb)
 509     *r_cb = ctx->progress_cb;
 510   if (r_cb_value)
 511     *r_cb_value = ctx->progress_cb_value;
 512 }
 513
 514
 515 /* Set the I/O callback functions for CTX to IO_CBS.  */
 516 void
 517 gpgme_set_io_cbs (gpgme_ctx_t ctx, gpgme_io_cbs_t io_cbs)
 518 {
 519   if (io_cbs)
 520     {
 521       TRACE6 (DEBUG_CTX, "gpgme_set_io_cbs", ctx,
 522               "io_cbs=%p (add=%p/%p, remove=%p, event=%p/%p",
 523               io_cbs, io_cbs->add, io_cbs->add_priv, io_cbs->remove,
 524               io_cbs->event, io_cbs->event_priv);
 525       ctx->io_cbs = *io_cbs;
 526     }
 527   else
 528     {
 529       TRACE1 (DEBUG_CTX, "gpgme_set_io_cbs", ctx,
 530               "io_cbs=%p (default)", io_cbs);
 531       ctx->io_cbs.add = NULL;
 532       ctx->io_cbs.add_priv = NULL;
 533       ctx->io_cbs.remove = NULL;
 534       ctx->io_cbs.event = NULL;
 535       ctx->io_cbs.event_priv = NULL;
 536     }
 537 }
 538
 539
 540 /* This function provides access to the internal read function; it is
 541    normally not used.  */
 542 ssize_t
 543 gpgme_io_read (int fd, void *buffer, size_t count)
 544 {
 545   int ret;
 546   TRACE_BEG2 (DEBUG_GLOBAL, "gpgme_io_read", fd,
 547               "buffer=%p, count=%u", buffer, count);
 548
 549   ret = _gpgme_io_read (fd, buffer, count);
 550
 551   return TRACE_SYSRES (ret);
 552 }
 553
 554
 555 /* This function provides access to the internal write function.  It
 556    is to be used by user callbacks to return data to gpgme.  See
 557    gpgme_passphrase_cb_t and gpgme_edit_cb_t.  */
 558 ssize_t
 559 gpgme_io_write (int fd, const void *buffer, size_t count)
 560 {
 561   int ret;
 562   TRACE_BEG2 (DEBUG_GLOBAL, "gpgme_io_write", fd,
 563               "buffer=%p, count=%u", buffer, count);
 564
 565   ret = _gpgme_io_write (fd, buffer, count);
 566
 567   return TRACE_SYSRES (ret);
 568 }
 569
 570
 571 /* This function returns the callback function for I/O.  */
 572 void
 573 gpgme_get_io_cbs (gpgme_ctx_t ctx, gpgme_io_cbs_t io_cbs)
 574 {
 575   TRACE6 (DEBUG_CTX, "gpgme_get_io_cbs", ctx,
 576           "io_cbs=%p, ctx->io_cbs.add=%p/%p, .remove=%p, .event=%p/%p",
 577           io_cbs, io_cbs->add, io_cbs->add_priv, io_cbs->remove,
 578           io_cbs->event, io_cbs->event_priv);
 579
 580   *io_cbs = ctx->io_cbs;
 581 }
 582
 583 \f
 584 /* This function sets the locale for the context CTX, or the default
 585    locale if CTX is a null pointer.  */
 586 gpgme_error_t
 587 gpgme_set_locale (gpgme_ctx_t ctx, int category, const char *value)
 588 {
 589   int failed = 0;
 590   char *new_lc_ctype = NULL;
 591   char *new_lc_messages = NULL;
 592
 593   TRACE_BEG2 (DEBUG_CTX, "gpgme_set_locale", ctx,
 594                "category=%i, value=%s", category, value ? value : "(null)");
 595
 596 #define PREPARE_ONE_LOCALE(lcat, ucat)                          \
 597   if (!failed && value                                          \
 598       && (category == LC_ALL || category == LC_ ## ucat))       \
 599     {                                                           \
 600       new_lc_ ## lcat = strdup (value);                         \
 601       if (!new_lc_ ## lcat)                                     \
 602         failed = 1;                                             \
 603     }
 604
 605 #ifdef LC_CTYPE
 606   PREPARE_ONE_LOCALE (ctype, CTYPE);
 607 #endif
 608 #ifdef LC_MESSAGES
 609   PREPARE_ONE_LOCALE (messages, MESSAGES);
 610 #endif
 611
 612   if (failed)
 613     {
 614       int saved_errno = errno;
 615
 616       if (new_lc_ctype)
 617         free (new_lc_ctype);
 618       if (new_lc_messages)
 619         free (new_lc_messages);
 620
 621       return TRACE_ERR (gpg_error_from_errno (saved_errno));
 622     }
 623
 624 #define SET_ONE_LOCALE(lcat, ucat)                      \
 625   if (category == LC_ALL || category == LC_ ## ucat)    \
 626     {                                                   \
 627       if (ctx)                                          \
 628         {                                               \
 629           if (ctx->lc_ ## lcat)                         \
 630             free (ctx->lc_ ## lcat);                    \
 631           ctx->lc_ ## lcat = new_lc_ ## lcat;           \
 632         }                                               \
 633       else                                              \
 634         {                                               \
 635           if (def_lc_ ## lcat)                          \
 636             free (def_lc_ ## lcat);                     \
 637           def_lc_ ## lcat = new_lc_ ## lcat;            \
 638         }                                               \
 639     }
 640
 641   if (!ctx)
 642     LOCK (def_lc_lock);
 643 #ifdef LC_CTYPE
 644   SET_ONE_LOCALE (ctype, CTYPE);
 645 #endif
 646 #ifdef LC_MESSAGES
 647   SET_ONE_LOCALE (messages, MESSAGES);
 648 #endif
 649   if (!ctx)
 650     UNLOCK (def_lc_lock);
 651
 652   return TRACE_ERR (0);
 653 }
 654
 655 \f
 656 /* Get the information about the configured engines.  A pointer to the
 657    first engine in the statically allocated linked list is returned.
 658    The returned data is valid until the next gpgme_ctx_set_engine_info.  */
 659 gpgme_engine_info_t
 660 gpgme_ctx_get_engine_info (gpgme_ctx_t ctx)
 661 {
 662   TRACE1 (DEBUG_CTX, "gpgme_ctx_get_engine_info", ctx,
 663           "ctx->engine_info=%p", ctx->engine_info);
 664   return ctx->engine_info;
 665 }
 666
 667
 668 /* Set the engine info for the context CTX, protocol PROTO, to the
 669    file name FILE_NAME and the home directory HOME_DIR.  */
 670 gpgme_error_t
 671 gpgme_ctx_set_engine_info (gpgme_ctx_t ctx, gpgme_protocol_t proto,
 672                            const char *file_name, const char *home_dir)
 673 {
 674   gpgme_error_t err;
 675   TRACE_BEG4 (DEBUG_CTX, "gpgme_ctx_set_engine_info", ctx,
 676               "protocol=%i (%s), file_name=%s, home_dir=%s",
 677               proto, gpgme_get_protocol_name (proto)
 678               ? gpgme_get_protocol_name (proto) : "unknown",
 679               file_name ? file_name : "(default)",
 680               home_dir ? home_dir : "(default)");
 681
 682   /* Shut down the engine when changing engine info.  */
 683   if (ctx->engine)
 684     {
 685       TRACE_LOG1 ("releasing ctx->engine=%p", ctx->engine);
 686       _gpgme_engine_release (ctx->engine);
 687       ctx->engine = NULL;
 688     }
 689   err = _gpgme_set_engine_info (ctx->engine_info, proto,
 690                                 file_name, home_dir);
 691   return TRACE_ERR (err);
 692 }
 693
 694 \f
 695 /* Clear all notation data from the context.  */
 696 void
 697 _gpgme_sig_notation_clear (gpgme_ctx_t ctx)
 698 {
 699   gpgme_sig_notation_t notation;
 700
 701   if (!ctx)
 702     return;
 703
 704   notation = ctx->sig_notations;
 705   while (notation)
 706     {
 707       gpgme_sig_notation_t next_notation = notation->next;
 708       _gpgme_sig_notation_free (notation);
 709       notation = next_notation;
 710     }
 711   ctx->sig_notations = NULL;
 712 }
 713
 714 void
 715 gpgme_sig_notation_clear (gpgme_ctx_t ctx)
 716 {
 717   TRACE (DEBUG_CTX, "gpgme_sig_notation_clear", ctx);
 718   _gpgme_sig_notation_clear (ctx);
 719 }
 720
 721
 722 /* Add the human-readable notation data with name NAME and value VALUE
 723    to the context CTX, using the flags FLAGS.  If NAME is NULL, then
 724    VALUE should be a policy URL.  The flag
 725    GPGME_SIG_NOTATION_HUMAN_READABLE is forced to be true for notation
 726    data, and false for policy URLs.  */
 727 gpgme_error_t
 728 gpgme_sig_notation_add (gpgme_ctx_t ctx, const char *name,
 729                         const char *value, gpgme_sig_notation_flags_t flags)
 730 {
 731   gpgme_error_t err;
 732   gpgme_sig_notation_t notation;
 733   gpgme_sig_notation_t *lastp;
 734
 735   TRACE_BEG3 (DEBUG_CTX, "gpgme_sig_notation_add", ctx,
 736               "name=%s, value=%s, flags=0x%x",
 737               name ? name : "(null)", value ? value : "(null)",
 738               flags);
 739
 740   if (!ctx)
 741     return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
 742
 743   if (name)
 744     flags |= GPGME_SIG_NOTATION_HUMAN_READABLE;
 745   else
 746     flags &= ~GPGME_SIG_NOTATION_HUMAN_READABLE;
 747
 748   err = _gpgme_sig_notation_create (&notation, name, name ? strlen (name) : 0,
 749                                     value, value ? strlen (value) : 0, flags);
 750   if (err)
 751     return TRACE_ERR (err);
 752
 753   lastp = &ctx->sig_notations;
 754   while (*lastp)
 755     lastp = &(*lastp)->next;
 756
 757   *lastp = notation;
 758   return TRACE_ERR (0);
 759 }
 760
 761
 762 /* Get the sig notations for this context.  */
 763 gpgme_sig_notation_t
 764 gpgme_sig_notation_get (gpgme_ctx_t ctx)
 765 {
 766   if (!ctx)
 767     {
 768       TRACE (DEBUG_CTX, "gpgme_sig_notation_get", ctx);
 769       return NULL;
 770     }
 771   TRACE1 (DEBUG_CTX, "gpgme_sig_notation_get", ctx,
 772           "ctx->sig_notations=%p", ctx->sig_notations);
 773
 774   return ctx->sig_notations;
 775 }
 776
 777 \f
 778 const char *
 779 gpgme_pubkey_algo_name (gpgme_pubkey_algo_t algo)
 780 {
 781   switch (algo)
 782     {
 783     case GPGME_PK_RSA:
 784       return "RSA";
 785
 786     case GPGME_PK_RSA_E:
 787       return "RSA-E";
 788
 789     case GPGME_PK_RSA_S:
 790       return "RSA-S";
 791
 792     case GPGME_PK_ELG_E:
 793       return "ELG-E";
 794
 795     case GPGME_PK_DSA:
 796       return "DSA";
 797
 798     case GPGME_PK_ELG:
 799       return "ELG";
 800
 801     case GPGME_PK_ECDSA:
 802       return "ECDSA";
 803
 804     case GPGME_PK_ECDH:
 805       return "ECDH";
 806
 807     default:
 808       return NULL;
 809     }
 810 }
 811
 812
 813 const char *
 814 gpgme_hash_algo_name (gpgme_hash_algo_t algo)
 815 {
 816   switch (algo)
 817     {
 818     case GPGME_MD_MD5:
 819       return "MD5";
 820
 821     case GPGME_MD_SHA1:
 822       return "SHA1";
 823
 824     case GPGME_MD_RMD160:
 825       return "RIPEMD160";
 826
 827     case GPGME_MD_MD2:
 828       return "MD2";
 829
 830     case GPGME_MD_TIGER:
 831       return "TIGER192";
 832
 833     case GPGME_MD_HAVAL:
 834       return "HAVAL";
 835
 836     case GPGME_MD_SHA256:
 837       return "SHA256";
 838
 839     case GPGME_MD_SHA384:
 840       return "SHA384";
 841
 842     case GPGME_MD_SHA512:
 843       return "SHA512";
 844
 845     case GPGME_MD_MD4:
 846       return "MD4";
 847
 848     case GPGME_MD_CRC32:
 849       return "CRC32";
 850
 851     case GPGME_MD_CRC32_RFC1510:
 852       return "CRC32RFC1510";
 853
 854     case GPGME_MD_CRC24_RFC2440:
 855       return "CRC24RFC2440";
 856
 857     default:
 858       return NULL;
 859     }
 860 }