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