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