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