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