b03c7b8740c20545508b8cc385dde9445d97dd19
[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 if (!strcmp (name, "ignore-mdc-error"))
546     {
547       ctx->ignore_mdc_error = abool;
548     }
549   else
550     err = gpg_error (GPG_ERR_UNKNOWN_NAME);
551
552   return err;
553 }
554
555
556 /* Get the context flag named NAME.  See gpgme_set_ctx_flag for a list
557  * of valid names.  If the NAME is unknown NULL is returned.  For a
558  * boolean flag an empty string is returned for False and the string
559  * "1" for True; thus either atoi or a simple string test can be
560  * used.  */
561 const char *
562 gpgme_get_ctx_flag (gpgme_ctx_t ctx, const char *name)
563 {
564   if (!ctx || !name)
565     return NULL;
566   else if (!strcmp (name, "redraw"))
567     {
568       return ctx->redraw_suggested? "1":"";
569     }
570   else if (!strcmp (name, "full-status"))
571     {
572       return ctx->full_status? "1":"";
573     }
574   else if (!strcmp (name, "raw-description"))
575     {
576       return ctx->raw_description? "1":"";
577     }
578   else if (!strcmp (name, "export-session-key"))
579     {
580       return ctx->export_session_keys? "1":"";
581     }
582   else if (!strcmp (name, "override-session-key"))
583     {
584       return ctx->override_session_key? ctx->override_session_key : "";
585     }
586   else if (!strcmp (name, "auto-key-retrieve"))
587     {
588       return ctx->auto_key_retrieve? "1":"";
589     }
590   else if (!strcmp (name, "request-origin"))
591     {
592       return ctx->request_origin? ctx->request_origin : "";
593     }
594   else if (!strcmp (name, "no-symkey-cache"))
595     {
596       return ctx->no_symkey_cache? "1":"";
597     }
598   else if (!strcmp (name, "ignore-mdc-error"))
599     {
600       return ctx->ignore_mdc_error? "1":"";
601     }
602   else
603     return NULL;
604 }
605
606
607 /* Enable or disable the use of the special textmode.  Textmode is for
608   example used for the RFC2015 signatures; note that the updated RFC
609   3156 mandates that the MUA does some preparations so that textmode
610   is not needed anymore.  */
611 void
612 gpgme_set_textmode (gpgme_ctx_t ctx, int use_textmode)
613 {
614   TRACE2 (DEBUG_CTX, "gpgme_set_textmode", ctx, "use_textmode=%i (%s)",
615           use_textmode, use_textmode ? "yes" : "no");
616
617   if (!ctx)
618     return;
619
620   ctx->use_textmode = !!use_textmode;
621 }
622
623 /* Return the state of the textmode flag.  */
624 int
625 gpgme_get_textmode (gpgme_ctx_t ctx)
626 {
627   TRACE2 (DEBUG_CTX, "gpgme_get_textmode", ctx, "ctx->use_textmode=%i (%s)",
628           ctx->use_textmode, ctx->use_textmode ? "yes" : "no");
629   return ctx->use_textmode;
630 }
631
632
633 /* Enable offline mode for this context. In offline mode dirmngr
634   will be disabled. */
635 void
636 gpgme_set_offline (gpgme_ctx_t ctx, int offline)
637 {
638   TRACE2 (DEBUG_CTX, "gpgme_set_offline", ctx, "offline=%i (%s)",
639           offline, offline ? "yes" : "no");
640
641   if (!ctx)
642     return;
643
644   ctx->offline = !!offline;
645 }
646
647 /* Return the state of the offline flag.  */
648 int
649 gpgme_get_offline (gpgme_ctx_t ctx)
650 {
651   TRACE2 (DEBUG_CTX, "gpgme_get_offline", ctx, "ctx->offline=%i (%s)",
652           ctx->offline, ctx->offline ? "yes" : "no");
653   return ctx->offline;
654 }
655
656
657 /* Set the number of certifications to include in an S/MIME message.
658    The default is GPGME_INCLUDE_CERTS_DEFAULT.  -1 means all certs,
659    and -2 means all certs except the root cert.  */
660 void
661 gpgme_set_include_certs (gpgme_ctx_t ctx, int nr_of_certs)
662 {
663   if (!ctx)
664     return;
665
666   if (nr_of_certs == GPGME_INCLUDE_CERTS_DEFAULT)
667     ctx->include_certs = GPGME_INCLUDE_CERTS_DEFAULT;
668   else if (nr_of_certs < -2)
669     ctx->include_certs = -2;
670   else
671     ctx->include_certs = nr_of_certs;
672
673   TRACE2 (DEBUG_CTX, "gpgme_set_include_certs", ctx, "nr_of_certs=%i%s",
674           nr_of_certs, nr_of_certs == ctx->include_certs ? "" : " (-2)");
675 }
676
677
678 /* Get the number of certifications to include in an S/MIME
679    message.  */
680 int
681 gpgme_get_include_certs (gpgme_ctx_t ctx)
682 {
683   TRACE1 (DEBUG_CTX, "gpgme_get_include_certs", ctx, "ctx->include_certs=%i",
684           ctx->include_certs);
685   return ctx->include_certs;
686 }
687
688
689 /* This function changes the default behaviour of the keylisting
690    functions.  MODE is a bitwise-OR of the GPGME_KEYLIST_* flags.  The
691    default mode is GPGME_KEYLIST_MODE_LOCAL.  */
692 gpgme_error_t
693 gpgme_set_keylist_mode (gpgme_ctx_t ctx, gpgme_keylist_mode_t mode)
694 {
695   TRACE1 (DEBUG_CTX, "gpgme_set_keylist_mode", ctx, "keylist_mode=0x%x",
696           mode);
697
698   if (!ctx)
699     return gpg_error (GPG_ERR_INV_VALUE);
700
701   ctx->keylist_mode = mode;
702   return 0;
703 }
704
705 /* This function returns the default behaviour of the keylisting
706    functions.  */
707 gpgme_keylist_mode_t
708 gpgme_get_keylist_mode (gpgme_ctx_t ctx)
709 {
710   TRACE1 (DEBUG_CTX, "gpgme_get_keylist_mode", ctx,
711           "ctx->keylist_mode=0x%x", ctx->keylist_mode);
712   return ctx->keylist_mode;
713 }
714
715
716 /* Set the pinentry mode for CTX to MODE. */
717 gpgme_error_t
718 gpgme_set_pinentry_mode (gpgme_ctx_t ctx, gpgme_pinentry_mode_t mode)
719 {
720   TRACE1 (DEBUG_CTX, "gpgme_set_pinentry_mode", ctx, "pinentry_mode=%u",
721           (unsigned int)mode);
722
723   if (!ctx)
724     return gpg_error (GPG_ERR_INV_VALUE);
725
726   switch (mode)
727     {
728     case GPGME_PINENTRY_MODE_DEFAULT:
729     case GPGME_PINENTRY_MODE_ASK:
730     case GPGME_PINENTRY_MODE_CANCEL:
731     case GPGME_PINENTRY_MODE_ERROR:
732     case GPGME_PINENTRY_MODE_LOOPBACK:
733       break;
734     default:
735       return gpg_error (GPG_ERR_INV_VALUE);
736     }
737
738   ctx->pinentry_mode = mode;
739   return 0;
740 }
741
742
743 /* Get the pinentry mode of CTX.  */
744 gpgme_pinentry_mode_t
745 gpgme_get_pinentry_mode (gpgme_ctx_t ctx)
746 {
747   TRACE1 (DEBUG_CTX, "gpgme_get_pinentry_mode", ctx,
748           "ctx->pinentry_mode=%u", (unsigned int)ctx->pinentry_mode);
749   return ctx->pinentry_mode;
750 }
751
752
753 /* This function sets a callback function to be used to pass a
754    passphrase to gpg.  */
755 void
756 gpgme_set_passphrase_cb (gpgme_ctx_t ctx, gpgme_passphrase_cb_t cb,
757                          void *cb_value)
758 {
759   TRACE2 (DEBUG_CTX, "gpgme_set_passphrase_cb", ctx,
760           "passphrase_cb=%p/%p", cb, cb_value);
761
762   if (!ctx)
763     return;
764
765   ctx->passphrase_cb = cb;
766   ctx->passphrase_cb_value = cb_value;
767 }
768
769
770 /* This function returns the callback function to be used to pass a
771    passphrase to the crypto engine.  */
772 void
773 gpgme_get_passphrase_cb (gpgme_ctx_t ctx, gpgme_passphrase_cb_t *r_cb,
774                          void **r_cb_value)
775 {
776   TRACE2 (DEBUG_CTX, "gpgme_get_passphrase_cb", ctx,
777           "ctx->passphrase_cb=%p/%p",
778           ctx->passphrase_cb, ctx->passphrase_cb_value);
779   if (r_cb)
780     *r_cb = ctx->passphrase_cb;
781   if (r_cb_value)
782     *r_cb_value = ctx->passphrase_cb_value;
783 }
784
785
786 /* This function sets a callback function to be used as a progress
787    indicator.  */
788 void
789 gpgme_set_progress_cb (gpgme_ctx_t ctx, gpgme_progress_cb_t cb, void *cb_value)
790 {
791   TRACE2 (DEBUG_CTX, "gpgme_set_progress_cb", ctx, "progress_cb=%p/%p",
792           cb, cb_value);
793
794   if (!ctx)
795     return;
796
797   ctx->progress_cb = cb;
798   ctx->progress_cb_value = cb_value;
799 }
800
801
802 /* This function returns the callback function to be used as a
803    progress indicator.  */
804 void
805 gpgme_get_progress_cb (gpgme_ctx_t ctx, gpgme_progress_cb_t *r_cb,
806                        void **r_cb_value)
807 {
808   TRACE2 (DEBUG_CTX, "gpgme_get_progress_cb", ctx, "ctx->progress_cb=%p/%p",
809           ctx->progress_cb, ctx->progress_cb_value);
810   if (r_cb)
811     *r_cb = ctx->progress_cb;
812   if (r_cb_value)
813     *r_cb_value = ctx->progress_cb_value;
814 }
815
816
817 /* This function sets a callback function to be used as a status
818    message forwarder.  */
819 void
820 gpgme_set_status_cb (gpgme_ctx_t ctx, gpgme_status_cb_t cb, void *cb_value)
821 {
822   TRACE2 (DEBUG_CTX, "gpgme_set_status_cb", ctx, "status_cb=%p/%p",
823           cb, cb_value);
824
825   if (!ctx)
826     return;
827
828   ctx->status_cb = cb;
829   ctx->status_cb_value = cb_value;
830 }
831
832
833 /* This function returns the callback function to be used as a
834    status message forwarder.  */
835 void
836 gpgme_get_status_cb (gpgme_ctx_t ctx, gpgme_status_cb_t *r_cb,
837                        void **r_cb_value)
838 {
839   TRACE2 (DEBUG_CTX, "gpgme_get_status_cb", ctx, "ctx->status_cb=%p/%p",
840           ctx ? ctx->status_cb : NULL, ctx ? ctx->status_cb_value : NULL);
841
842   if (r_cb)
843     *r_cb = NULL;
844
845   if (r_cb_value)
846     *r_cb_value = NULL;
847
848   if (!ctx || !ctx->status_cb)
849     return;
850
851   if (r_cb)
852     *r_cb = ctx->status_cb;
853   if (r_cb_value)
854     *r_cb_value = ctx->status_cb_value;
855 }
856
857
858 /* Set the I/O callback functions for CTX to IO_CBS.  */
859 void
860 gpgme_set_io_cbs (gpgme_ctx_t ctx, gpgme_io_cbs_t io_cbs)
861 {
862   if (!ctx)
863     return;
864
865   if (io_cbs)
866     {
867       TRACE6 (DEBUG_CTX, "gpgme_set_io_cbs", ctx,
868               "io_cbs=%p (add=%p/%p, remove=%p, event=%p/%p",
869               io_cbs, io_cbs->add, io_cbs->add_priv, io_cbs->remove,
870               io_cbs->event, io_cbs->event_priv);
871       ctx->io_cbs = *io_cbs;
872     }
873   else
874     {
875       TRACE1 (DEBUG_CTX, "gpgme_set_io_cbs", ctx,
876               "io_cbs=%p (default)", io_cbs);
877       ctx->io_cbs.add = NULL;
878       ctx->io_cbs.add_priv = NULL;
879       ctx->io_cbs.remove = NULL;
880       ctx->io_cbs.event = NULL;
881       ctx->io_cbs.event_priv = NULL;
882     }
883 }
884
885
886 /* This function provides access to the internal read function; it is
887    normally not used.  */
888 gpgme_ssize_t
889 gpgme_io_read (int fd, void *buffer, size_t count)
890 {
891   int ret;
892   TRACE_BEG2 (DEBUG_GLOBAL, "gpgme_io_read", fd,
893               "buffer=%p, count=%u", buffer, count);
894
895   ret = _gpgme_io_read (fd, buffer, count);
896
897   return TRACE_SYSRES (ret);
898 }
899
900
901 /* This function provides access to the internal write function.  It
902    is to be used by user callbacks to return data to gpgme.  See
903    gpgme_passphrase_cb_t and gpgme_edit_cb_t.  */
904 gpgme_ssize_t
905 gpgme_io_write (int fd, const void *buffer, size_t count)
906 {
907   int ret;
908   TRACE_BEG2 (DEBUG_GLOBAL, "gpgme_io_write", fd,
909               "buffer=%p, count=%u", buffer, count);
910
911   ret = _gpgme_io_write (fd, buffer, count);
912
913   return TRACE_SYSRES (ret);
914 }
915
916 /* This function provides access to the internal write function.  It
917    is to be used by user callbacks to return data to gpgme.  See
918    gpgme_passphrase_cb_t and gpgme_edit_cb_t.  Note that this is a
919    variant of gpgme_io_write which guarantees that all COUNT bytes are
920    written or an error is return.  Returns: 0 on success or -1 on
921    error and the sets errno. */
922 int
923 gpgme_io_writen (int fd, const void *buffer_arg, size_t count)
924 {
925   const char *buffer = buffer_arg;
926   int ret = 0;
927   TRACE_BEG2 (DEBUG_GLOBAL, "gpgme_io_writen", fd,
928               "buffer=%p, count=%u", buffer, count);
929   while (count)
930     {
931       ret = _gpgme_io_write (fd, buffer, count);
932       if (ret < 0)
933         break;
934       buffer += ret;
935       count -= ret;
936       ret = 0;
937     }
938   return TRACE_SYSRES (ret);
939 }
940
941
942 /* This function returns the callback function for I/O.  */
943 void
944 gpgme_get_io_cbs (gpgme_ctx_t ctx, gpgme_io_cbs_t io_cbs)
945 {
946   TRACE6 (DEBUG_CTX, "gpgme_get_io_cbs", ctx,
947           "io_cbs=%p, ctx->io_cbs.add=%p/%p, .remove=%p, .event=%p/%p",
948           io_cbs, io_cbs->add, io_cbs->add_priv, io_cbs->remove,
949           io_cbs->event, io_cbs->event_priv);
950
951   *io_cbs = ctx->io_cbs;
952 }
953
954 \f
955 /* This function sets the locale for the context CTX, or the default
956    locale if CTX is a null pointer.  */
957 gpgme_error_t
958 gpgme_set_locale (gpgme_ctx_t ctx, int category, const char *value)
959 {
960   int failed = 0;
961   char *new_lc_ctype = NULL;
962   char *new_lc_messages = NULL;
963
964   TRACE_BEG2 (DEBUG_CTX, "gpgme_set_locale", ctx,
965                "category=%i, value=%s", category, value ? value : "(null)");
966
967 #define PREPARE_ONE_LOCALE(lcat, ucat)                          \
968   if (!failed && value                                          \
969       && (category == LC_ALL || category == LC_ ## ucat))       \
970     {                                                           \
971       new_lc_ ## lcat = strdup (value);                         \
972       if (!new_lc_ ## lcat)                                     \
973         failed = 1;                                             \
974     }
975
976 #ifdef LC_CTYPE
977   PREPARE_ONE_LOCALE (ctype, CTYPE);
978 #endif
979 #ifdef LC_MESSAGES
980   PREPARE_ONE_LOCALE (messages, MESSAGES);
981 #endif
982
983   if (failed)
984     {
985       int saved_err = gpg_error_from_syserror ();
986
987       if (new_lc_ctype)
988         free (new_lc_ctype);
989       if (new_lc_messages)
990         free (new_lc_messages);
991
992       return TRACE_ERR (saved_err);
993     }
994
995 #define SET_ONE_LOCALE(lcat, ucat)                      \
996   if (category == LC_ALL || category == LC_ ## ucat)    \
997     {                                                   \
998       if (ctx)                                          \
999         {                                               \
1000           if (ctx->lc_ ## lcat)                         \
1001             free (ctx->lc_ ## lcat);                    \
1002           ctx->lc_ ## lcat = new_lc_ ## lcat;           \
1003         }                                               \
1004       else                                              \
1005         {                                               \
1006           if (def_lc_ ## lcat)                          \
1007             free (def_lc_ ## lcat);                     \
1008           def_lc_ ## lcat = new_lc_ ## lcat;            \
1009         }                                               \
1010     }
1011
1012   if (!ctx)
1013     LOCK (def_lc_lock);
1014 #ifdef LC_CTYPE
1015   SET_ONE_LOCALE (ctype, CTYPE);
1016 #endif
1017 #ifdef LC_MESSAGES
1018   SET_ONE_LOCALE (messages, MESSAGES);
1019 #endif
1020   if (!ctx)
1021     UNLOCK (def_lc_lock);
1022
1023   return TRACE_ERR (0);
1024 }
1025
1026 \f
1027 /* Get the information about the configured engines.  A pointer to the
1028    first engine in the statically allocated linked list is returned.
1029    The returned data is valid until the next gpgme_ctx_set_engine_info.  */
1030 gpgme_engine_info_t
1031 gpgme_ctx_get_engine_info (gpgme_ctx_t ctx)
1032 {
1033   TRACE1 (DEBUG_CTX, "gpgme_ctx_get_engine_info", ctx,
1034           "ctx->engine_info=%p", ctx->engine_info);
1035   return ctx->engine_info;
1036 }
1037
1038
1039 /* Set the engine info for the context CTX, protocol PROTO, to the
1040    file name FILE_NAME and the home directory HOME_DIR.  */
1041 gpgme_error_t
1042 gpgme_ctx_set_engine_info (gpgme_ctx_t ctx, gpgme_protocol_t proto,
1043                            const char *file_name, const char *home_dir)
1044 {
1045   gpgme_error_t err;
1046   TRACE_BEG4 (DEBUG_CTX, "gpgme_ctx_set_engine_info", ctx,
1047               "protocol=%i (%s), file_name=%s, home_dir=%s",
1048               proto, gpgme_get_protocol_name (proto)
1049               ? gpgme_get_protocol_name (proto) : "unknown",
1050               file_name ? file_name : "(default)",
1051               home_dir ? home_dir : "(default)");
1052
1053   if (!ctx)
1054     return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
1055
1056   /* Shut down the engine when changing engine info.  */
1057   if (ctx->engine)
1058     {
1059       TRACE_LOG1 ("releasing ctx->engine=%p", ctx->engine);
1060       _gpgme_engine_release (ctx->engine);
1061       ctx->engine = NULL;
1062     }
1063   err = _gpgme_set_engine_info (ctx->engine_info, proto,
1064                                 file_name, home_dir);
1065   return TRACE_ERR (err);
1066 }
1067
1068 \f
1069 /* Clear all notation data from the context.  */
1070 void
1071 _gpgme_sig_notation_clear (gpgme_ctx_t ctx)
1072 {
1073   gpgme_sig_notation_t notation;
1074
1075   if (!ctx)
1076     return;
1077
1078   notation = ctx->sig_notations;
1079   while (notation)
1080     {
1081       gpgme_sig_notation_t next_notation = notation->next;
1082       _gpgme_sig_notation_free (notation);
1083       notation = next_notation;
1084     }
1085   ctx->sig_notations = NULL;
1086 }
1087
1088 void
1089 gpgme_sig_notation_clear (gpgme_ctx_t ctx)
1090 {
1091   TRACE (DEBUG_CTX, "gpgme_sig_notation_clear", ctx);
1092
1093   if (!ctx)
1094     return;
1095
1096   _gpgme_sig_notation_clear (ctx);
1097 }
1098
1099
1100 /* Add the human-readable notation data with name NAME and value VALUE
1101    to the context CTX, using the flags FLAGS.  If NAME is NULL, then
1102    VALUE should be a policy URL.  The flag
1103    GPGME_SIG_NOTATION_HUMAN_READABLE is forced to be true for notation
1104    data, and false for policy URLs.  */
1105 gpgme_error_t
1106 gpgme_sig_notation_add (gpgme_ctx_t ctx, const char *name,
1107                         const char *value, gpgme_sig_notation_flags_t flags)
1108 {
1109   gpgme_error_t err;
1110   gpgme_sig_notation_t notation;
1111   gpgme_sig_notation_t *lastp;
1112
1113   TRACE_BEG3 (DEBUG_CTX, "gpgme_sig_notation_add", ctx,
1114               "name=%s, value=%s, flags=0x%x",
1115               name ? name : "(null)", value ? value : "(null)",
1116               flags);
1117
1118   if (!ctx)
1119     return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
1120
1121   if (name)
1122     flags |= GPGME_SIG_NOTATION_HUMAN_READABLE;
1123   else
1124     flags &= ~GPGME_SIG_NOTATION_HUMAN_READABLE;
1125
1126   err = _gpgme_sig_notation_create (&notation, name, name ? strlen (name) : 0,
1127                                     value, value ? strlen (value) : 0, flags);
1128   if (err)
1129     return TRACE_ERR (err);
1130
1131   lastp = &ctx->sig_notations;
1132   while (*lastp)
1133     lastp = &(*lastp)->next;
1134
1135   *lastp = notation;
1136   return TRACE_ERR (0);
1137 }
1138
1139
1140 /* Get the sig notations for this context.  */
1141 gpgme_sig_notation_t
1142 gpgme_sig_notation_get (gpgme_ctx_t ctx)
1143 {
1144   if (!ctx)
1145     {
1146       TRACE (DEBUG_CTX, "gpgme_sig_notation_get", ctx);
1147       return NULL;
1148     }
1149   TRACE1 (DEBUG_CTX, "gpgme_sig_notation_get", ctx,
1150           "ctx->sig_notations=%p", ctx->sig_notations);
1151
1152   return ctx->sig_notations;
1153 }
1154
1155
1156 \f
1157 /* Return a public key algorithm string made of the algorithm and size
1158    or the curve name.  May return NULL on error.  Caller must free the
1159    result using gpgme_free.  */
1160 char *
1161 gpgme_pubkey_algo_string (gpgme_subkey_t subkey)
1162 {
1163   const char *prefix = NULL;
1164   char *result;
1165
1166   if (!subkey)
1167     {
1168       gpg_err_set_errno (EINVAL);
1169       return NULL;
1170     }
1171
1172   switch (subkey->pubkey_algo)
1173     {
1174     case GPGME_PK_RSA:
1175     case GPGME_PK_RSA_E:
1176     case GPGME_PK_RSA_S: prefix = "rsa"; break;
1177     case GPGME_PK_ELG_E: prefix = "elg"; break;
1178     case GPGME_PK_DSA:   prefix = "dsa"; break;
1179     case GPGME_PK_ELG:   prefix = "xxx"; break;
1180     case GPGME_PK_ECC:
1181     case GPGME_PK_ECDH:
1182     case GPGME_PK_ECDSA:
1183     case GPGME_PK_EDDSA: prefix = "";    break;
1184     }
1185
1186   if (prefix && *prefix)
1187     {
1188       char buffer[40];
1189       snprintf (buffer, sizeof buffer, "%s%u", prefix, subkey->length);
1190       result = strdup (buffer);
1191     }
1192   else if (prefix && subkey->curve && *subkey->curve)
1193     result = strdup (subkey->curve);
1194   else if (prefix)
1195     result =  strdup ("E_error");
1196   else
1197     result = strdup  ("unknown");
1198
1199   return result;
1200 }
1201
1202
1203 const char *
1204 gpgme_pubkey_algo_name (gpgme_pubkey_algo_t algo)
1205 {
1206   switch (algo)
1207     {
1208     case GPGME_PK_RSA:   return "RSA";
1209     case GPGME_PK_RSA_E: return "RSA-E";
1210     case GPGME_PK_RSA_S: return "RSA-S";
1211     case GPGME_PK_ELG_E: return "ELG-E";
1212     case GPGME_PK_DSA:   return "DSA";
1213     case GPGME_PK_ECC:   return "ECC";
1214     case GPGME_PK_ELG:   return "ELG";
1215     case GPGME_PK_ECDSA: return "ECDSA";
1216     case GPGME_PK_ECDH:  return "ECDH";
1217     case GPGME_PK_EDDSA: return "EdDSA";
1218     default:             return NULL;
1219     }
1220 }
1221
1222
1223 const char *
1224 gpgme_hash_algo_name (gpgme_hash_algo_t algo)
1225 {
1226   switch (algo)
1227     {
1228     case GPGME_MD_MD5:
1229       return "MD5";
1230
1231     case GPGME_MD_SHA1:
1232       return "SHA1";
1233
1234     case GPGME_MD_RMD160:
1235       return "RIPEMD160";
1236
1237     case GPGME_MD_MD2:
1238       return "MD2";
1239
1240     case GPGME_MD_TIGER:
1241       return "TIGER192";
1242
1243     case GPGME_MD_HAVAL:
1244       return "HAVAL";
1245
1246     case GPGME_MD_SHA256:
1247       return "SHA256";
1248
1249     case GPGME_MD_SHA384:
1250       return "SHA384";
1251
1252     case GPGME_MD_SHA512:
1253       return "SHA512";
1254
1255     case GPGME_MD_SHA224:
1256       return "SHA224";
1257
1258     case GPGME_MD_MD4:
1259       return "MD4";
1260
1261     case GPGME_MD_CRC32:
1262       return "CRC32";
1263
1264     case GPGME_MD_CRC32_RFC1510:
1265       return "CRC32RFC1510";
1266
1267     case GPGME_MD_CRC24_RFC2440:
1268       return "CRC24RFC2440";
1269
1270     default:
1271       return NULL;
1272     }
1273 }