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