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