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