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