Add offline mode support for CMS keylisting
[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 /* Enable offline mode for this context. In offline mode dirmngr
476   will be disabled. */
477 void
478 gpgme_set_offline (gpgme_ctx_t ctx, int offline)
479 {
480   TRACE2 (DEBUG_CTX, "gpgme_set_offline", ctx, "offline=%i (%s)",
481           offline, offline ? "yes" : "no");
482
483   if (!ctx)
484     return;
485
486   ctx->offline = offline;
487 }
488
489 /* Return the state of the offline flag.  */
490 int
491 gpgme_get_offline (gpgme_ctx_t ctx)
492 {
493   TRACE2 (DEBUG_CTX, "gpgme_get_offline", ctx, "ctx->offline=%i (%s)",
494           ctx->offline, ctx->offline ? "yes" : "no");
495   return ctx->offline;
496 }
497
498
499 /* Set the number of certifications to include in an S/MIME message.
500    The default is GPGME_INCLUDE_CERTS_DEFAULT.  -1 means all certs,
501    and -2 means all certs except the root cert.  */
502 void
503 gpgme_set_include_certs (gpgme_ctx_t ctx, int nr_of_certs)
504 {
505   if (!ctx)
506     return;
507
508   if (nr_of_certs == GPGME_INCLUDE_CERTS_DEFAULT)
509     ctx->include_certs = GPGME_INCLUDE_CERTS_DEFAULT;
510   else if (nr_of_certs < -2)
511     ctx->include_certs = -2;
512   else
513     ctx->include_certs = nr_of_certs;
514
515   TRACE2 (DEBUG_CTX, "gpgme_set_include_certs", ctx, "nr_of_certs=%i%s",
516           nr_of_certs, nr_of_certs == ctx->include_certs ? "" : " (-2)");
517 }
518
519
520 /* Get the number of certifications to include in an S/MIME
521    message.  */
522 int
523 gpgme_get_include_certs (gpgme_ctx_t ctx)
524 {
525   TRACE1 (DEBUG_CTX, "gpgme_get_include_certs", ctx, "ctx->include_certs=%i",
526           ctx->include_certs);
527   return ctx->include_certs;
528 }
529
530
531 /* This function changes the default behaviour of the keylisting
532    functions.  MODE is a bitwise-OR of the GPGME_KEYLIST_* flags.  The
533    default mode is GPGME_KEYLIST_MODE_LOCAL.  */
534 gpgme_error_t
535 gpgme_set_keylist_mode (gpgme_ctx_t ctx, gpgme_keylist_mode_t mode)
536 {
537   TRACE1 (DEBUG_CTX, "gpgme_set_keylist_mode", ctx, "keylist_mode=0x%x",
538           mode);
539
540   if (!ctx)
541     return gpg_error (GPG_ERR_INV_VALUE);
542
543   ctx->keylist_mode = mode;
544   return 0;
545 }
546
547 /* This function returns the default behaviour of the keylisting
548    functions.  */
549 gpgme_keylist_mode_t
550 gpgme_get_keylist_mode (gpgme_ctx_t ctx)
551 {
552   TRACE1 (DEBUG_CTX, "gpgme_get_keylist_mode", ctx,
553           "ctx->keylist_mode=0x%x", ctx->keylist_mode);
554   return ctx->keylist_mode;
555 }
556
557
558 /* Set the pinentry mode for CTX to MODE. */
559 gpgme_error_t
560 gpgme_set_pinentry_mode (gpgme_ctx_t ctx, gpgme_pinentry_mode_t mode)
561 {
562   TRACE1 (DEBUG_CTX, "gpgme_set_pinentry_mode", ctx, "pinentry_mode=%u",
563           (unsigned int)mode);
564
565   if (!ctx)
566     return gpg_error (GPG_ERR_INV_VALUE);
567
568   switch (mode)
569     {
570     case GPGME_PINENTRY_MODE_DEFAULT:
571     case GPGME_PINENTRY_MODE_ASK:
572     case GPGME_PINENTRY_MODE_CANCEL:
573     case GPGME_PINENTRY_MODE_ERROR:
574     case GPGME_PINENTRY_MODE_LOOPBACK:
575       break;
576     default:
577       return gpg_error (GPG_ERR_INV_VALUE);
578     }
579
580   ctx->pinentry_mode = mode;
581   return 0;
582 }
583
584
585 /* Get the pinentry mode of CTX.  */
586 gpgme_pinentry_mode_t
587 gpgme_get_pinentry_mode (gpgme_ctx_t ctx)
588 {
589   TRACE1 (DEBUG_CTX, "gpgme_get_pinentry_mode", ctx,
590           "ctx->pinentry_mode=%u", (unsigned int)ctx->pinentry_mode);
591   return ctx->pinentry_mode;
592 }
593
594
595 /* This function sets a callback function to be used to pass a
596    passphrase to gpg.  */
597 void
598 gpgme_set_passphrase_cb (gpgme_ctx_t ctx, gpgme_passphrase_cb_t cb,
599                          void *cb_value)
600 {
601   TRACE2 (DEBUG_CTX, "gpgme_set_passphrase_cb", ctx,
602           "passphrase_cb=%p/%p", cb, cb_value);
603
604   if (!ctx)
605     return;
606
607   ctx->passphrase_cb = cb;
608   ctx->passphrase_cb_value = cb_value;
609 }
610
611
612 /* This function returns the callback function to be used to pass a
613    passphrase to the crypto engine.  */
614 void
615 gpgme_get_passphrase_cb (gpgme_ctx_t ctx, gpgme_passphrase_cb_t *r_cb,
616                          void **r_cb_value)
617 {
618   TRACE2 (DEBUG_CTX, "gpgme_get_passphrase_cb", ctx,
619           "ctx->passphrase_cb=%p/%p",
620           ctx->passphrase_cb, ctx->passphrase_cb_value);
621   if (r_cb)
622     *r_cb = ctx->passphrase_cb;
623   if (r_cb_value)
624     *r_cb_value = ctx->passphrase_cb_value;
625 }
626
627
628 /* This function sets a callback function to be used as a progress
629    indicator.  */
630 void
631 gpgme_set_progress_cb (gpgme_ctx_t ctx, gpgme_progress_cb_t cb, void *cb_value)
632 {
633   TRACE2 (DEBUG_CTX, "gpgme_set_progress_cb", ctx, "progress_cb=%p/%p",
634           cb, cb_value);
635
636   if (!ctx)
637     return;
638
639   ctx->progress_cb = cb;
640   ctx->progress_cb_value = cb_value;
641 }
642
643
644 /* This function returns the callback function to be used as a
645    progress indicator.  */
646 void
647 gpgme_get_progress_cb (gpgme_ctx_t ctx, gpgme_progress_cb_t *r_cb,
648                        void **r_cb_value)
649 {
650   TRACE2 (DEBUG_CTX, "gpgme_get_progress_cb", ctx, "ctx->progress_cb=%p/%p",
651           ctx->progress_cb, ctx->progress_cb_value);
652   if (r_cb)
653     *r_cb = ctx->progress_cb;
654   if (r_cb_value)
655     *r_cb_value = ctx->progress_cb_value;
656 }
657
658
659 /* Set the I/O callback functions for CTX to IO_CBS.  */
660 void
661 gpgme_set_io_cbs (gpgme_ctx_t ctx, gpgme_io_cbs_t io_cbs)
662 {
663   if (!ctx)
664     return;
665
666   if (io_cbs)
667     {
668       TRACE6 (DEBUG_CTX, "gpgme_set_io_cbs", ctx,
669               "io_cbs=%p (add=%p/%p, remove=%p, event=%p/%p",
670               io_cbs, io_cbs->add, io_cbs->add_priv, io_cbs->remove,
671               io_cbs->event, io_cbs->event_priv);
672       ctx->io_cbs = *io_cbs;
673     }
674   else
675     {
676       TRACE1 (DEBUG_CTX, "gpgme_set_io_cbs", ctx,
677               "io_cbs=%p (default)", io_cbs);
678       ctx->io_cbs.add = NULL;
679       ctx->io_cbs.add_priv = NULL;
680       ctx->io_cbs.remove = NULL;
681       ctx->io_cbs.event = NULL;
682       ctx->io_cbs.event_priv = NULL;
683     }
684 }
685
686
687 /* This function provides access to the internal read function; it is
688    normally not used.  */
689 gpgme_ssize_t
690 gpgme_io_read (int fd, void *buffer, size_t count)
691 {
692   int ret;
693   TRACE_BEG2 (DEBUG_GLOBAL, "gpgme_io_read", fd,
694               "buffer=%p, count=%u", buffer, count);
695
696   ret = _gpgme_io_read (fd, buffer, count);
697
698   return TRACE_SYSRES (ret);
699 }
700
701
702 /* This function provides access to the internal write function.  It
703    is to be used by user callbacks to return data to gpgme.  See
704    gpgme_passphrase_cb_t and gpgme_edit_cb_t.  */
705 gpgme_ssize_t
706 gpgme_io_write (int fd, const void *buffer, size_t count)
707 {
708   int ret;
709   TRACE_BEG2 (DEBUG_GLOBAL, "gpgme_io_write", fd,
710               "buffer=%p, count=%u", buffer, count);
711
712   ret = _gpgme_io_write (fd, buffer, count);
713
714   return TRACE_SYSRES (ret);
715 }
716
717 /* This function provides access to the internal write function.  It
718    is to be used by user callbacks to return data to gpgme.  See
719    gpgme_passphrase_cb_t and gpgme_edit_cb_t.  Note that this is a
720    variant of gpgme_io_write which guarantees that all COUNT bytes are
721    written or an error is return.  Returns: 0 on success or -1 on
722    error and the sets errno. */
723 int
724 gpgme_io_writen (int fd, const void *buffer_arg, size_t count)
725 {
726   const char *buffer = buffer_arg;
727   int ret = 0;
728   TRACE_BEG2 (DEBUG_GLOBAL, "gpgme_io_writen", fd,
729               "buffer=%p, count=%u", buffer, count);
730   while (count)
731     {
732       ret = _gpgme_io_write (fd, buffer, count);
733       if (ret < 0)
734         break;
735       buffer += ret;
736       count -= ret;
737       ret = 0;
738     }
739   return TRACE_SYSRES (ret);
740 }
741
742
743 /* This function returns the callback function for I/O.  */
744 void
745 gpgme_get_io_cbs (gpgme_ctx_t ctx, gpgme_io_cbs_t io_cbs)
746 {
747   TRACE6 (DEBUG_CTX, "gpgme_get_io_cbs", ctx,
748           "io_cbs=%p, ctx->io_cbs.add=%p/%p, .remove=%p, .event=%p/%p",
749           io_cbs, io_cbs->add, io_cbs->add_priv, io_cbs->remove,
750           io_cbs->event, io_cbs->event_priv);
751
752   *io_cbs = ctx->io_cbs;
753 }
754
755 \f
756 /* This function sets the locale for the context CTX, or the default
757    locale if CTX is a null pointer.  */
758 gpgme_error_t
759 gpgme_set_locale (gpgme_ctx_t ctx, int category, const char *value)
760 {
761   int failed = 0;
762   char *new_lc_ctype = NULL;
763   char *new_lc_messages = NULL;
764
765   TRACE_BEG2 (DEBUG_CTX, "gpgme_set_locale", ctx,
766                "category=%i, value=%s", category, value ? value : "(null)");
767
768 #define PREPARE_ONE_LOCALE(lcat, ucat)                          \
769   if (!failed && value                                          \
770       && (category == LC_ALL || category == LC_ ## ucat))       \
771     {                                                           \
772       new_lc_ ## lcat = strdup (value);                         \
773       if (!new_lc_ ## lcat)                                     \
774         failed = 1;                                             \
775     }
776
777 #ifdef LC_CTYPE
778   PREPARE_ONE_LOCALE (ctype, CTYPE);
779 #endif
780 #ifdef LC_MESSAGES
781   PREPARE_ONE_LOCALE (messages, MESSAGES);
782 #endif
783
784   if (failed)
785     {
786       int saved_err = gpg_error_from_syserror ();
787
788       if (new_lc_ctype)
789         free (new_lc_ctype);
790       if (new_lc_messages)
791         free (new_lc_messages);
792
793       return TRACE_ERR (saved_err);
794     }
795
796 #define SET_ONE_LOCALE(lcat, ucat)                      \
797   if (category == LC_ALL || category == LC_ ## ucat)    \
798     {                                                   \
799       if (ctx)                                          \
800         {                                               \
801           if (ctx->lc_ ## lcat)                         \
802             free (ctx->lc_ ## lcat);                    \
803           ctx->lc_ ## lcat = new_lc_ ## lcat;           \
804         }                                               \
805       else                                              \
806         {                                               \
807           if (def_lc_ ## lcat)                          \
808             free (def_lc_ ## lcat);                     \
809           def_lc_ ## lcat = new_lc_ ## lcat;            \
810         }                                               \
811     }
812
813   if (!ctx)
814     LOCK (def_lc_lock);
815 #ifdef LC_CTYPE
816   SET_ONE_LOCALE (ctype, CTYPE);
817 #endif
818 #ifdef LC_MESSAGES
819   SET_ONE_LOCALE (messages, MESSAGES);
820 #endif
821   if (!ctx)
822     UNLOCK (def_lc_lock);
823
824   return TRACE_ERR (0);
825 }
826
827 \f
828 /* Get the information about the configured engines.  A pointer to the
829    first engine in the statically allocated linked list is returned.
830    The returned data is valid until the next gpgme_ctx_set_engine_info.  */
831 gpgme_engine_info_t
832 gpgme_ctx_get_engine_info (gpgme_ctx_t ctx)
833 {
834   TRACE1 (DEBUG_CTX, "gpgme_ctx_get_engine_info", ctx,
835           "ctx->engine_info=%p", ctx->engine_info);
836   return ctx->engine_info;
837 }
838
839
840 /* Set the engine info for the context CTX, protocol PROTO, to the
841    file name FILE_NAME and the home directory HOME_DIR.  */
842 gpgme_error_t
843 gpgme_ctx_set_engine_info (gpgme_ctx_t ctx, gpgme_protocol_t proto,
844                            const char *file_name, const char *home_dir)
845 {
846   gpgme_error_t err;
847   TRACE_BEG4 (DEBUG_CTX, "gpgme_ctx_set_engine_info", ctx,
848               "protocol=%i (%s), file_name=%s, home_dir=%s",
849               proto, gpgme_get_protocol_name (proto)
850               ? gpgme_get_protocol_name (proto) : "unknown",
851               file_name ? file_name : "(default)",
852               home_dir ? home_dir : "(default)");
853
854   if (!ctx)
855     return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
856
857   /* Shut down the engine when changing engine info.  */
858   if (ctx->engine)
859     {
860       TRACE_LOG1 ("releasing ctx->engine=%p", ctx->engine);
861       _gpgme_engine_release (ctx->engine);
862       ctx->engine = NULL;
863     }
864   err = _gpgme_set_engine_info (ctx->engine_info, proto,
865                                 file_name, home_dir);
866   return TRACE_ERR (err);
867 }
868
869 \f
870 /* Clear all notation data from the context.  */
871 void
872 _gpgme_sig_notation_clear (gpgme_ctx_t ctx)
873 {
874   gpgme_sig_notation_t notation;
875
876   if (!ctx)
877     return;
878
879   notation = ctx->sig_notations;
880   while (notation)
881     {
882       gpgme_sig_notation_t next_notation = notation->next;
883       _gpgme_sig_notation_free (notation);
884       notation = next_notation;
885     }
886   ctx->sig_notations = NULL;
887 }
888
889 void
890 gpgme_sig_notation_clear (gpgme_ctx_t ctx)
891 {
892   TRACE (DEBUG_CTX, "gpgme_sig_notation_clear", ctx);
893
894   if (!ctx)
895     return;
896
897   _gpgme_sig_notation_clear (ctx);
898 }
899
900
901 /* Add the human-readable notation data with name NAME and value VALUE
902    to the context CTX, using the flags FLAGS.  If NAME is NULL, then
903    VALUE should be a policy URL.  The flag
904    GPGME_SIG_NOTATION_HUMAN_READABLE is forced to be true for notation
905    data, and false for policy URLs.  */
906 gpgme_error_t
907 gpgme_sig_notation_add (gpgme_ctx_t ctx, const char *name,
908                         const char *value, gpgme_sig_notation_flags_t flags)
909 {
910   gpgme_error_t err;
911   gpgme_sig_notation_t notation;
912   gpgme_sig_notation_t *lastp;
913
914   TRACE_BEG3 (DEBUG_CTX, "gpgme_sig_notation_add", ctx,
915               "name=%s, value=%s, flags=0x%x",
916               name ? name : "(null)", value ? value : "(null)",
917               flags);
918
919   if (!ctx)
920     return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
921
922   if (name)
923     flags |= GPGME_SIG_NOTATION_HUMAN_READABLE;
924   else
925     flags &= ~GPGME_SIG_NOTATION_HUMAN_READABLE;
926
927   err = _gpgme_sig_notation_create (&notation, name, name ? strlen (name) : 0,
928                                     value, value ? strlen (value) : 0, flags);
929   if (err)
930     return TRACE_ERR (err);
931
932   lastp = &ctx->sig_notations;
933   while (*lastp)
934     lastp = &(*lastp)->next;
935
936   *lastp = notation;
937   return TRACE_ERR (0);
938 }
939
940
941 /* Get the sig notations for this context.  */
942 gpgme_sig_notation_t
943 gpgme_sig_notation_get (gpgme_ctx_t ctx)
944 {
945   if (!ctx)
946     {
947       TRACE (DEBUG_CTX, "gpgme_sig_notation_get", ctx);
948       return NULL;
949     }
950   TRACE1 (DEBUG_CTX, "gpgme_sig_notation_get", ctx,
951           "ctx->sig_notations=%p", ctx->sig_notations);
952
953   return ctx->sig_notations;
954 }
955
956 \f
957 const char *
958 gpgme_pubkey_algo_name (gpgme_pubkey_algo_t algo)
959 {
960   switch (algo)
961     {
962     case GPGME_PK_RSA:
963       return "RSA";
964
965     case GPGME_PK_RSA_E:
966       return "RSA-E";
967
968     case GPGME_PK_RSA_S:
969       return "RSA-S";
970
971     case GPGME_PK_ELG_E:
972       return "ELG-E";
973
974     case GPGME_PK_DSA:
975       return "DSA";
976
977     case GPGME_PK_ECC:
978       return "ECC";
979
980     case GPGME_PK_ELG:
981       return "ELG";
982
983     case GPGME_PK_ECDSA:
984       return "ECDSA";
985
986     case GPGME_PK_ECDH:
987       return "ECDH";
988
989     default:
990       return NULL;
991     }
992 }
993
994
995 const char *
996 gpgme_hash_algo_name (gpgme_hash_algo_t algo)
997 {
998   switch (algo)
999     {
1000     case GPGME_MD_MD5:
1001       return "MD5";
1002
1003     case GPGME_MD_SHA1:
1004       return "SHA1";
1005
1006     case GPGME_MD_RMD160:
1007       return "RIPEMD160";
1008
1009     case GPGME_MD_MD2:
1010       return "MD2";
1011
1012     case GPGME_MD_TIGER:
1013       return "TIGER192";
1014
1015     case GPGME_MD_HAVAL:
1016       return "HAVAL";
1017
1018     case GPGME_MD_SHA256:
1019       return "SHA256";
1020
1021     case GPGME_MD_SHA384:
1022       return "SHA384";
1023
1024     case GPGME_MD_SHA512:
1025       return "SHA512";
1026
1027     case GPGME_MD_SHA224:
1028       return "SHA224";
1029
1030     case GPGME_MD_MD4:
1031       return "MD4";
1032
1033     case GPGME_MD_CRC32:
1034       return "CRC32";
1035
1036     case GPGME_MD_CRC32_RFC1510:
1037       return "CRC32RFC1510";
1038
1039     case GPGME_MD_CRC24_RFC2440:
1040       return "CRC24RFC2440";
1041
1042     default:
1043       return NULL;
1044     }
1045 }