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