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