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 #define PREPARE_ONE_LOCALE(lcat, ucat)                          \
 643   if (!failed && value                                          \
 644       && (category == LC_ALL || category == LC_ ## ucat))       \
 645     {                                                           \
 646       new_lc_ ## lcat = strdup (value);                         \
 647       if (!new_lc_ ## lcat)                                     \
 648         failed = 1;                                             \
 649     }
 650
 651 #ifdef LC_CTYPE
 652   PREPARE_ONE_LOCALE (ctype, CTYPE);
 653 #endif
 654 #ifdef LC_MESSAGES
 655   PREPARE_ONE_LOCALE (messages, MESSAGES);
 656 #endif
 657
 658   if (failed)
 659     {
 660       int saved_errno = errno;
 661
 662       if (new_lc_ctype)
 663         free (new_lc_ctype);
 664       if (new_lc_messages)
 665         free (new_lc_messages);
 666
 667       return TRACE_ERR (gpg_error_from_errno (saved_errno));
 668     }
 669
 670 #define SET_ONE_LOCALE(lcat, ucat)                      \
 671   if (category == LC_ALL || category == LC_ ## ucat)    \
 672     {                                                   \
 673       if (ctx)                                          \
 674         {                                               \
 675           if (ctx->lc_ ## lcat)                         \
 676             free (ctx->lc_ ## lcat);                    \
 677           ctx->lc_ ## lcat = new_lc_ ## lcat;           \
 678         }                                               \
 679       else                                              \
 680         {                                               \
 681           if (def_lc_ ## lcat)                          \
 682             free (def_lc_ ## lcat);                     \
 683           def_lc_ ## lcat = new_lc_ ## lcat;            \
 684         }                                               \
 685     }
 686
 687   if (!ctx)
 688     LOCK (def_lc_lock);
 689 #ifdef LC_CTYPE
 690   SET_ONE_LOCALE (ctype, CTYPE);
 691 #endif
 692 #ifdef LC_MESSAGES
 693   SET_ONE_LOCALE (messages, MESSAGES);
 694 #endif
 695   if (!ctx)
 696     UNLOCK (def_lc_lock);
 697
 698   return TRACE_ERR (0);
 699 }
 700
 701 \f
 702 /* Get the information about the configured engines.  A pointer to the
 703    first engine in the statically allocated linked list is returned.
 704    The returned data is valid until the next gpgme_ctx_set_engine_info.  */
 705 gpgme_engine_info_t
 706 gpgme_ctx_get_engine_info (gpgme_ctx_t ctx)
 707 {
 708   TRACE1 (DEBUG_CTX, "gpgme_ctx_get_engine_info", ctx,
 709           "ctx->engine_info=%p", ctx->engine_info);
 710   return ctx->engine_info;
 711 }
 712
 713
 714 /* Set the engine info for the context CTX, protocol PROTO, to the
 715    file name FILE_NAME and the home directory HOME_DIR.  */
 716 gpgme_error_t
 717 gpgme_ctx_set_engine_info (gpgme_ctx_t ctx, gpgme_protocol_t proto,
 718                            const char *file_name, const char *home_dir)
 719 {
 720   gpgme_error_t err;
 721   TRACE_BEG4 (DEBUG_CTX, "gpgme_ctx_set_engine_info", ctx,
 722               "protocol=%i (%s), file_name=%s, home_dir=%s",
 723               proto, gpgme_get_protocol_name (proto)
 724               ? gpgme_get_protocol_name (proto) : "unknown",
 725               file_name ? file_name : "(default)",
 726               home_dir ? home_dir : "(default)");
 727
 728   if (!ctx)
 729     return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
 730
 731   /* Shut down the engine when changing engine info.  */
 732   if (ctx->engine)
 733     {
 734       TRACE_LOG1 ("releasing ctx->engine=%p", ctx->engine);
 735       _gpgme_engine_release (ctx->engine);
 736       ctx->engine = NULL;
 737     }
 738   err = _gpgme_set_engine_info (ctx->engine_info, proto,
 739                                 file_name, home_dir);
 740   return TRACE_ERR (err);
 741 }
 742
 743 \f
 744 /* Clear all notation data from the context.  */
 745 void
 746 _gpgme_sig_notation_clear (gpgme_ctx_t ctx)
 747 {
 748   gpgme_sig_notation_t notation;
 749
 750   if (!ctx)
 751     return;
 752
 753   notation = ctx->sig_notations;
 754   while (notation)
 755     {
 756       gpgme_sig_notation_t next_notation = notation->next;
 757       _gpgme_sig_notation_free (notation);
 758       notation = next_notation;
 759     }
 760   ctx->sig_notations = NULL;
 761 }
 762
 763 void
 764 gpgme_sig_notation_clear (gpgme_ctx_t ctx)
 765 {
 766   TRACE (DEBUG_CTX, "gpgme_sig_notation_clear", ctx);
 767
 768   if (!ctx)
 769     return;
 770
 771   _gpgme_sig_notation_clear (ctx);
 772 }
 773
 774
 775 /* Add the human-readable notation data with name NAME and value VALUE
 776    to the context CTX, using the flags FLAGS.  If NAME is NULL, then
 777    VALUE should be a policy URL.  The flag
 778    GPGME_SIG_NOTATION_HUMAN_READABLE is forced to be true for notation
 779    data, and false for policy URLs.  */
 780 gpgme_error_t
 781 gpgme_sig_notation_add (gpgme_ctx_t ctx, const char *name,
 782                         const char *value, gpgme_sig_notation_flags_t flags)
 783 {
 784   gpgme_error_t err;
 785   gpgme_sig_notation_t notation;
 786   gpgme_sig_notation_t *lastp;
 787
 788   TRACE_BEG3 (DEBUG_CTX, "gpgme_sig_notation_add", ctx,
 789               "name=%s, value=%s, flags=0x%x",
 790               name ? name : "(null)", value ? value : "(null)",
 791               flags);
 792
 793   if (!ctx)
 794     return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
 795
 796   if (name)
 797     flags |= GPGME_SIG_NOTATION_HUMAN_READABLE;
 798   else
 799     flags &= ~GPGME_SIG_NOTATION_HUMAN_READABLE;
 800
 801   err = _gpgme_sig_notation_create (&notation, name, name ? strlen (name) : 0,
 802                                     value, value ? strlen (value) : 0, flags);
 803   if (err)
 804     return TRACE_ERR (err);
 805
 806   lastp = &ctx->sig_notations;
 807   while (*lastp)
 808     lastp = &(*lastp)->next;
 809
 810   *lastp = notation;
 811   return TRACE_ERR (0);
 812 }
 813
 814
 815 /* Get the sig notations for this context.  */
 816 gpgme_sig_notation_t
 817 gpgme_sig_notation_get (gpgme_ctx_t ctx)
 818 {
 819   if (!ctx)
 820     {
 821       TRACE (DEBUG_CTX, "gpgme_sig_notation_get", ctx);
 822       return NULL;
 823     }
 824   TRACE1 (DEBUG_CTX, "gpgme_sig_notation_get", ctx,
 825           "ctx->sig_notations=%p", ctx->sig_notations);
 826
 827   return ctx->sig_notations;
 828 }
 829
 830 \f
 831 const char *
 832 gpgme_pubkey_algo_name (gpgme_pubkey_algo_t algo)
 833 {
 834   switch (algo)
 835     {
 836     case GPGME_PK_RSA:
 837       return "RSA";
 838
 839     case GPGME_PK_RSA_E:
 840       return "RSA-E";
 841
 842     case GPGME_PK_RSA_S:
 843       return "RSA-S";
 844
 845     case GPGME_PK_ELG_E:
 846       return "ELG-E";
 847
 848     case GPGME_PK_DSA:
 849       return "DSA";
 850
 851     case GPGME_PK_ELG:
 852       return "ELG";
 853
 854     case GPGME_PK_ECDSA:
 855       return "ECDSA";
 856
 857     case GPGME_PK_ECDH:
 858       return "ECDH";
 859
 860     default:
 861       return NULL;
 862     }
 863 }
 864
 865
 866 const char *
 867 gpgme_hash_algo_name (gpgme_hash_algo_t algo)
 868 {
 869   switch (algo)
 870     {
 871     case GPGME_MD_MD5:
 872       return "MD5";
 873
 874     case GPGME_MD_SHA1:
 875       return "SHA1";
 876
 877     case GPGME_MD_RMD160:
 878       return "RIPEMD160";
 879
 880     case GPGME_MD_MD2:
 881       return "MD2";
 882
 883     case GPGME_MD_TIGER:
 884       return "TIGER192";
 885
 886     case GPGME_MD_HAVAL:
 887       return "HAVAL";
 888
 889     case GPGME_MD_SHA256:
 890       return "SHA256";
 891
 892     case GPGME_MD_SHA384:
 893       return "SHA384";
 894
 895     case GPGME_MD_SHA512:
 896       return "SHA512";
 897
 898     case GPGME_MD_MD4:
 899       return "MD4";
 900
 901     case GPGME_MD_CRC32:
 902       return "CRC32";
 903
 904     case GPGME_MD_CRC32_RFC1510:
 905       return "CRC32RFC1510";
 906
 907     case GPGME_MD_CRC24_RFC2440:
 908       return "CRC24RFC2440";
 909
 910     default:
 911       return NULL;
 912     }
 913 }