Fix Windows port (spawn and assuan engine).
[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 g10 Code GmbH
4
5    This file is part of GPGME.
6  
7    GPGME is free software; you can redistribute it and/or modify it
8    under the terms of the GNU Lesser General Public License as
9    published by the Free Software Foundation; either version 2.1 of
10    the License, or (at your option) any later version.
11    
12    GPGME is distributed in the hope that it will be useful, but
13    WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15    Lesser General Public License for more details.
16    
17    You should have received a copy of the GNU Lesser General Public
18    License along with this program; if not, write to the Free Software
19    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
20    02111-1307, USA.  */
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
41 \f
42 /* The default locale.  */
43 DEFINE_STATIC_LOCK (def_lc_lock);
44 static char *def_lc_ctype;
45 static char *def_lc_messages;
46
47 \f
48 gpgme_error_t _gpgme_selftest = GPG_ERR_NOT_OPERATIONAL;
49
50 /* Protects all reference counters in result structures.  All other
51    accesses to a result structure are read only.  */
52 DEFINE_STATIC_LOCK (result_ref_lock);
53
54 \f
55 /* Create a new context as an environment for GPGME crypto
56    operations.  */
57 gpgme_error_t
58 gpgme_new (gpgme_ctx_t *r_ctx)
59 {
60   gpgme_ctx_t ctx;
61   TRACE_BEG (DEBUG_CTX, "gpgme_new", r_ctx);
62
63   if (_gpgme_selftest)
64     return TRACE_ERR (gpgme_error (_gpgme_selftest));
65
66   ctx = calloc (1, sizeof *ctx);
67   if (!ctx)
68     return TRACE_ERR (gpg_error_from_errno (errno));
69
70   INIT_LOCK (ctx->lock);
71   
72   _gpgme_engine_info_copy (&ctx->engine_info);
73   if (!ctx->engine_info)
74     {
75       free (ctx);
76       return TRACE_ERR (gpg_error_from_errno (errno));
77     }
78
79   ctx->keylist_mode = GPGME_KEYLIST_MODE_LOCAL;
80   ctx->include_certs = GPGME_INCLUDE_CERTS_DEFAULT;
81   ctx->protocol = GPGME_PROTOCOL_OpenPGP;
82   ctx->sub_protocol = GPGME_PROTOCOL_DEFAULT;
83   _gpgme_fd_table_init (&ctx->fdt);
84
85   LOCK (def_lc_lock);
86   if (def_lc_ctype)
87     {
88       ctx->lc_ctype = strdup (def_lc_ctype);
89       if (!ctx->lc_ctype)
90         {
91           UNLOCK (def_lc_lock);
92           _gpgme_engine_info_release (ctx->engine_info);
93           free (ctx);
94           return TRACE_ERR (gpg_error_from_errno (errno));
95         }
96     }
97   else
98     def_lc_ctype = NULL;
99
100   if (def_lc_messages)
101     {
102       ctx->lc_messages = strdup (def_lc_messages);
103       if (!ctx->lc_messages)
104         {
105           UNLOCK (def_lc_lock);
106           if (ctx->lc_ctype)
107             free (ctx->lc_ctype);
108           _gpgme_engine_info_release (ctx->engine_info);
109           free (ctx);
110           return TRACE_ERR (gpg_error_from_errno (errno));
111         }
112     }
113   else
114     def_lc_messages = NULL;
115   UNLOCK (def_lc_lock);
116
117   *r_ctx = ctx;
118
119   return TRACE_SUC1 ("ctx=%p", ctx);
120 }
121
122
123 gpgme_error_t
124 _gpgme_cancel_with_err (gpgme_ctx_t ctx, gpg_error_t ctx_err,
125                         gpg_error_t op_err)
126 {
127   gpgme_error_t err;
128   struct gpgme_io_event_done_data data;
129
130   TRACE_BEG2 (DEBUG_CTX, "_gpgme_cancel_with_err", ctx, "ctx_err=%i, op_err=%i",
131               ctx_err, op_err);
132
133   if (ctx_err)
134     {
135       err = _gpgme_engine_cancel (ctx->engine);
136       if (err)
137         return TRACE_ERR (err);
138     }
139   else
140     {
141       err = _gpgme_engine_cancel_op (ctx->engine);
142       if (err)
143         return TRACE_ERR (err);
144     }
145
146   data.err = ctx_err;
147   data.op_err = op_err;
148
149   _gpgme_engine_io_event (ctx->engine, GPGME_EVENT_DONE, &data);
150
151   return TRACE_ERR (0);
152 }
153
154
155 /* Cancel a pending asynchronous operation.  */
156 gpgme_error_t
157 gpgme_cancel (gpgme_ctx_t ctx)
158 {
159   gpg_error_t err;
160
161   TRACE_BEG (DEBUG_CTX, "gpgme_cancel", ctx);
162
163   err = _gpgme_cancel_with_err (ctx, gpg_error (GPG_ERR_CANCELED), 0);
164
165   return TRACE_ERR (err);
166 }
167
168
169 /* Cancel a pending operation asynchronously.  */
170 gpgme_error_t
171 gpgme_cancel_async (gpgme_ctx_t ctx)
172 {
173   TRACE_BEG (DEBUG_CTX, "gpgme_cancel_async", ctx);
174
175   LOCK (ctx->lock);
176   ctx->canceled = 1;
177   UNLOCK (ctx->lock);
178
179   return TRACE_ERR (0);
180 }
181
182
183 /* Release all resources associated with the given context.  */
184 void
185 gpgme_release (gpgme_ctx_t ctx)
186 {
187   TRACE (DEBUG_CTX, "gpgme_release", ctx);
188
189   _gpgme_engine_release (ctx->engine);
190   _gpgme_fd_table_deinit (&ctx->fdt);
191   _gpgme_release_result (ctx);
192   _gpgme_signers_clear (ctx);
193   _gpgme_sig_notation_clear (ctx);
194   if (ctx->signers)
195     free (ctx->signers);
196   if (ctx->lc_ctype)
197     free (ctx->lc_ctype);
198   if (ctx->lc_messages)
199     free (ctx->lc_messages);
200   _gpgme_engine_info_release (ctx->engine_info);
201   DESTROY_LOCK (ctx->lock);
202   free (ctx);
203 }
204
205
206 void
207 gpgme_result_ref (void *result)
208 {
209   struct ctx_op_data *data;
210
211   if (! result)
212     return;
213
214   data = (void*)((char*)result - sizeof (struct ctx_op_data));
215
216   assert (data->magic == CTX_OP_DATA_MAGIC);
217
218   LOCK (result_ref_lock);
219   data->references++;
220   UNLOCK (result_ref_lock);
221 }
222
223
224 void
225 gpgme_result_unref (void *result)
226 {
227   struct ctx_op_data *data;
228
229   if (! result)
230     return;
231
232   data = (void*)((char*)result - sizeof (struct ctx_op_data));
233
234   assert (data->magic == CTX_OP_DATA_MAGIC);
235
236   LOCK (result_ref_lock);
237   if (--data->references)
238     {
239       UNLOCK (result_ref_lock);
240       return;
241     }
242   UNLOCK (result_ref_lock);
243
244   if (data->cleanup)
245     (*data->cleanup) (data->hook);
246   free (data);
247 }
248
249
250 void
251 _gpgme_release_result (gpgme_ctx_t ctx)
252 {
253   struct ctx_op_data *data = ctx->op_data;
254
255   while (data)
256     {
257       struct ctx_op_data *next_data = data->next;
258       data->next = NULL;
259       gpgme_result_unref (data->hook);
260       data = next_data;
261     }
262   ctx->op_data = NULL;
263 }
264
265
266 gpgme_error_t
267 gpgme_set_protocol (gpgme_ctx_t ctx, gpgme_protocol_t protocol)
268 {
269   TRACE_BEG2 (DEBUG_CTX, "gpgme_set_protocol", ctx, "protocol=%i (%s)",
270               protocol, gpgme_get_protocol_name (protocol)
271               ? gpgme_get_protocol_name (protocol) : "invalid");
272
273   if (protocol != GPGME_PROTOCOL_OpenPGP
274       && protocol != GPGME_PROTOCOL_CMS
275       && protocol != GPGME_PROTOCOL_GPGCONF
276       && protocol != GPGME_PROTOCOL_ASSUAN
277       && protocol != GPGME_PROTOCOL_G13
278       && protocol != GPGME_PROTOCOL_UISERVER)
279     return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
280
281   if (ctx->protocol != protocol)
282     {
283       /* Shut down the engine when switching protocols.  */
284       if (ctx->engine)
285         {
286           TRACE_LOG1 ("releasing ctx->engine=%p", ctx->engine);
287           _gpgme_engine_release (ctx->engine);
288           ctx->engine = NULL;
289         }
290
291       ctx->protocol = protocol;
292     }
293   return TRACE_ERR (0);
294 }
295
296
297 gpgme_protocol_t
298 gpgme_get_protocol (gpgme_ctx_t ctx)
299 {
300   TRACE2 (DEBUG_CTX, "gpgme_get_protocol", ctx,
301           "ctx->protocol=%i (%s)", ctx->protocol,
302           gpgme_get_protocol_name (ctx->protocol)
303           ? gpgme_get_protocol_name (ctx->protocol) : "invalid");
304   return ctx->protocol;
305 }
306
307
308 gpgme_error_t
309 gpgme_set_sub_protocol (gpgme_ctx_t ctx, gpgme_protocol_t protocol)
310 {
311   TRACE2 (DEBUG_CTX, "gpgme_set_sub_protocol", ctx, "protocol=%i (%s)",
312           protocol, gpgme_get_protocol_name (protocol)
313           ? gpgme_get_protocol_name (protocol) : "invalid");
314   ctx->sub_protocol = protocol;
315   return 0;
316 }
317
318
319 gpgme_error_t
320 gpgme_get_sub_protocol (gpgme_ctx_t ctx)
321 {
322   TRACE2 (DEBUG_CTX, "gpgme_get_sub_protocol", ctx,
323           "ctx->sub_protocol=%i (%s)", ctx->sub_protocol,
324           gpgme_get_protocol_name (ctx->sub_protocol)
325           ? gpgme_get_protocol_name (ctx->sub_protocol) : "invalid");
326   return ctx->sub_protocol;
327 }
328
329
330 const char *
331 gpgme_get_protocol_name (gpgme_protocol_t protocol)
332 {
333   switch (protocol)
334     {
335     case GPGME_PROTOCOL_OpenPGP:
336       return "OpenPGP";
337
338     case GPGME_PROTOCOL_CMS:
339       return "CMS";
340
341     case GPGME_PROTOCOL_GPGCONF:
342       return "GPGCONF";
343
344     case GPGME_PROTOCOL_ASSUAN:
345       return "Assuan";
346
347     case GPGME_PROTOCOL_G13:
348       return "G13";
349
350     case GPGME_PROTOCOL_UISERVER:
351       return "UIServer";
352
353     case GPGME_PROTOCOL_DEFAULT:
354       return "default";
355
356     case GPGME_PROTOCOL_UNKNOWN:
357       return "unknown";
358
359     default:
360       return NULL;
361     }
362 }
363
364 /* Enable or disable the use of an ascii armor for all output.  */
365 void
366 gpgme_set_armor (gpgme_ctx_t ctx, int use_armor)
367 {
368   TRACE2 (DEBUG_CTX, "gpgme_set_armor", ctx, "use_armor=%i (%s)",
369           use_armor, use_armor ? "yes" : "no");
370   ctx->use_armor = use_armor;
371 }
372
373
374 /* Return the state of the armor flag.  */
375 int
376 gpgme_get_armor (gpgme_ctx_t ctx)
377 {
378   TRACE2 (DEBUG_CTX, "gpgme_get_armor", ctx, "ctx->use_armor=%i (%s)",
379           ctx->use_armor, ctx->use_armor ? "yes" : "no");
380   return ctx->use_armor;
381 }
382
383
384 /* Enable or disable the use of the special textmode.  Textmode is for
385   example used for the RFC2015 signatures; note that the updated RFC
386   3156 mandates that the MUA does some preparations so that textmode
387   is not needed anymore.  */
388 void
389 gpgme_set_textmode (gpgme_ctx_t ctx, int use_textmode)
390 {
391   TRACE2 (DEBUG_CTX, "gpgme_set_textmode", ctx, "use_textmode=%i (%s)",
392           use_textmode, use_textmode ? "yes" : "no");
393   ctx->use_textmode = use_textmode;
394 }
395
396 /* Return the state of the textmode flag.  */
397 int
398 gpgme_get_textmode (gpgme_ctx_t ctx)
399 {
400   TRACE2 (DEBUG_CTX, "gpgme_get_textmode", ctx, "ctx->use_textmode=%i (%s)",
401           ctx->use_textmode, ctx->use_textmode ? "yes" : "no");
402   return ctx->use_textmode;
403 }
404
405
406 /* Set the number of certifications to include in an S/MIME message.
407    The default is GPGME_INCLUDE_CERTS_DEFAULT.  -1 means all certs,
408    and -2 means all certs except the root cert.  */
409 void
410 gpgme_set_include_certs (gpgme_ctx_t ctx, int nr_of_certs)
411 {
412   if (nr_of_certs == GPGME_INCLUDE_CERTS_DEFAULT)
413     ctx->include_certs = GPGME_INCLUDE_CERTS_DEFAULT;
414   else if (nr_of_certs < -2)
415     ctx->include_certs = -2;
416   else
417     ctx->include_certs = nr_of_certs;
418
419   TRACE2 (DEBUG_CTX, "gpgme_set_include_certs", ctx, "nr_of_certs=%i%s",
420           nr_of_certs, nr_of_certs == ctx->include_certs ? "" : " (-2)");
421 }
422
423
424 /* Get the number of certifications to include in an S/MIME
425    message.  */
426 int
427 gpgme_get_include_certs (gpgme_ctx_t ctx)
428 {
429   TRACE1 (DEBUG_CTX, "gpgme_get_include_certs", ctx, "ctx->include_certs=%i",
430           ctx->include_certs);
431   return ctx->include_certs;
432 }
433
434
435 /* This function changes the default behaviour of the keylisting
436    functions.  MODE is a bitwise-OR of the GPGME_KEYLIST_* flags.  The
437    default mode is GPGME_KEYLIST_MODE_LOCAL.  */
438 gpgme_error_t
439 gpgme_set_keylist_mode (gpgme_ctx_t ctx, gpgme_keylist_mode_t mode)
440 {
441   TRACE1 (DEBUG_CTX, "gpgme_set_keylist_mode", ctx, "keylist_mode=0x%x",
442           mode);
443
444   ctx->keylist_mode = mode;
445   return 0;
446 }
447
448 /* This function returns the default behaviour of the keylisting
449    functions.  */
450 gpgme_keylist_mode_t
451 gpgme_get_keylist_mode (gpgme_ctx_t ctx)
452 {
453   TRACE1 (DEBUG_CTX, "gpgme_get_keylist_mode", ctx,
454           "ctx->keylist_mode=0x%x", ctx->keylist_mode);
455   return ctx->keylist_mode;
456 }
457
458
459 /* This function sets a callback function to be used to pass a
460    passphrase to gpg.  */
461 void
462 gpgme_set_passphrase_cb (gpgme_ctx_t ctx, gpgme_passphrase_cb_t cb,
463                          void *cb_value)
464 {
465   TRACE2 (DEBUG_CTX, "gpgme_set_passphrase_cb", ctx,
466           "passphrase_cb=%p/%p", cb, cb_value);
467   ctx->passphrase_cb = cb;
468   ctx->passphrase_cb_value = cb_value;
469 }
470
471
472 /* This function returns the callback function to be used to pass a
473    passphrase to the crypto engine.  */
474 void
475 gpgme_get_passphrase_cb (gpgme_ctx_t ctx, gpgme_passphrase_cb_t *r_cb,
476                          void **r_cb_value)
477 {
478   TRACE2 (DEBUG_CTX, "gpgme_get_passphrase_cb", ctx,
479           "ctx->passphrase_cb=%p/%p",
480           ctx->passphrase_cb, ctx->passphrase_cb_value);
481   if (r_cb)
482     *r_cb = ctx->passphrase_cb;
483   if (r_cb_value)
484     *r_cb_value = ctx->passphrase_cb_value;
485 }
486
487
488 /* This function sets a callback function to be used as a progress
489    indicator.  */
490 void
491 gpgme_set_progress_cb (gpgme_ctx_t ctx, gpgme_progress_cb_t cb, void *cb_value)
492 {
493   TRACE2 (DEBUG_CTX, "gpgme_set_progress_cb", ctx, "progress_cb=%p/%p",
494           cb, cb_value);
495   ctx->progress_cb = cb;
496   ctx->progress_cb_value = cb_value;
497 }
498
499
500 /* This function returns the callback function to be used as a
501    progress indicator.  */
502 void
503 gpgme_get_progress_cb (gpgme_ctx_t ctx, gpgme_progress_cb_t *r_cb,
504                        void **r_cb_value)
505 {
506   TRACE2 (DEBUG_CTX, "gpgme_get_progress_cb", ctx, "ctx->progress_cb=%p/%p",
507           ctx->progress_cb, ctx->progress_cb_value);
508   if (r_cb)
509     *r_cb = ctx->progress_cb;
510   if (r_cb_value)
511     *r_cb_value = ctx->progress_cb_value;
512 }
513
514
515 /* Set the I/O callback functions for CTX to IO_CBS.  */
516 void
517 gpgme_set_io_cbs (gpgme_ctx_t ctx, gpgme_io_cbs_t io_cbs)
518 {
519   if (io_cbs)
520     {
521       TRACE6 (DEBUG_CTX, "gpgme_set_io_cbs", ctx,
522               "io_cbs=%p (add=%p/%p, remove=%p, event=%p/%p",
523               io_cbs, io_cbs->add, io_cbs->add_priv, io_cbs->remove,
524               io_cbs->event, io_cbs->event_priv);
525       ctx->io_cbs = *io_cbs;
526     }
527   else
528     {
529       TRACE1 (DEBUG_CTX, "gpgme_set_io_cbs", ctx,
530               "io_cbs=%p (default)", io_cbs);
531       ctx->io_cbs.add = NULL;
532       ctx->io_cbs.add_priv = NULL;
533       ctx->io_cbs.remove = NULL;
534       ctx->io_cbs.event = NULL;
535       ctx->io_cbs.event_priv = NULL;
536     }
537 }
538
539
540 /* This function provides access to the internal read function; it is
541    normally not used.  */
542 ssize_t
543 gpgme_io_read (int fd, void *buffer, size_t count)
544 {
545   int ret;
546   TRACE_BEG2 (DEBUG_GLOBAL, "gpgme_io_read", fd,
547               "buffer=%p, count=%u", buffer, count);
548
549   ret = _gpgme_io_read (fd, buffer, count);
550
551   return TRACE_SYSRES (ret);
552 }
553
554
555 /* This function provides access to the internal write function.  It
556    is to be used by user callbacks to return data to gpgme.  See
557    gpgme_passphrase_cb_t and gpgme_edit_cb_t.  */
558 ssize_t
559 gpgme_io_write (int fd, const void *buffer, size_t count)
560 {
561   int ret;
562   TRACE_BEG2 (DEBUG_GLOBAL, "gpgme_io_write", fd,
563               "buffer=%p, count=%u", buffer, count);
564
565   ret = _gpgme_io_write (fd, buffer, count);
566
567   return TRACE_SYSRES (ret);
568 }
569
570
571 /* This function returns the callback function for I/O.  */
572 void
573 gpgme_get_io_cbs (gpgme_ctx_t ctx, gpgme_io_cbs_t io_cbs)
574 {
575   TRACE6 (DEBUG_CTX, "gpgme_get_io_cbs", ctx,
576           "io_cbs=%p, ctx->io_cbs.add=%p/%p, .remove=%p, .event=%p/%p",
577           io_cbs, io_cbs->add, io_cbs->add_priv, io_cbs->remove,
578           io_cbs->event, io_cbs->event_priv);
579
580   *io_cbs = ctx->io_cbs;
581 }
582
583 \f
584 /* This function sets the locale for the context CTX, or the default
585    locale if CTX is a null pointer.  */
586 gpgme_error_t
587 gpgme_set_locale (gpgme_ctx_t ctx, int category, const char *value)
588 {
589   int failed = 0;
590   char *new_lc_ctype = NULL;
591   char *new_lc_messages = NULL;
592
593   TRACE_BEG2 (DEBUG_CTX, "gpgme_set_locale", ctx,
594                "category=%i, value=%s", category, value ? value : "(null)");
595
596 #define PREPARE_ONE_LOCALE(lcat, ucat)                          \
597   if (!failed && value                                          \
598       && (category == LC_ALL || category == LC_ ## ucat))       \
599     {                                                           \
600       new_lc_ ## lcat = strdup (value);                         \
601       if (!new_lc_ ## lcat)                                     \
602         failed = 1;                                             \
603     }
604
605 #ifdef LC_CTYPE
606   PREPARE_ONE_LOCALE (ctype, CTYPE);
607 #endif
608 #ifdef LC_MESSAGES
609   PREPARE_ONE_LOCALE (messages, MESSAGES);
610 #endif
611
612   if (failed)
613     {
614       int saved_errno = errno;
615
616       if (new_lc_ctype)
617         free (new_lc_ctype);
618       if (new_lc_messages)
619         free (new_lc_messages);
620
621       return TRACE_ERR (gpg_error_from_errno (saved_errno));
622     }
623
624 #define SET_ONE_LOCALE(lcat, ucat)                      \
625   if (category == LC_ALL || category == LC_ ## ucat)    \
626     {                                                   \
627       if (ctx)                                          \
628         {                                               \
629           if (ctx->lc_ ## lcat)                         \
630             free (ctx->lc_ ## lcat);                    \
631           ctx->lc_ ## lcat = new_lc_ ## lcat;           \
632         }                                               \
633       else                                              \
634         {                                               \
635           if (def_lc_ ## lcat)                          \
636             free (def_lc_ ## lcat);                     \
637           def_lc_ ## lcat = new_lc_ ## lcat;            \
638         }                                               \
639     }
640
641   if (!ctx)
642     LOCK (def_lc_lock);
643 #ifdef LC_CTYPE
644   SET_ONE_LOCALE (ctype, CTYPE);
645 #endif
646 #ifdef LC_MESSAGES
647   SET_ONE_LOCALE (messages, MESSAGES);
648 #endif
649   if (!ctx)
650     UNLOCK (def_lc_lock);
651
652   return TRACE_ERR (0);
653 }
654
655 \f
656 /* Get the information about the configured engines.  A pointer to the
657    first engine in the statically allocated linked list is returned.
658    The returned data is valid until the next gpgme_ctx_set_engine_info.  */
659 gpgme_engine_info_t
660 gpgme_ctx_get_engine_info (gpgme_ctx_t ctx)
661 {
662   TRACE1 (DEBUG_CTX, "gpgme_ctx_get_engine_info", ctx,
663           "ctx->engine_info=%p", ctx->engine_info);
664   return ctx->engine_info;
665 }
666
667
668 /* Set the engine info for the context CTX, protocol PROTO, to the
669    file name FILE_NAME and the home directory HOME_DIR.  */
670 gpgme_error_t
671 gpgme_ctx_set_engine_info (gpgme_ctx_t ctx, gpgme_protocol_t proto,
672                            const char *file_name, const char *home_dir)
673 {
674   gpgme_error_t err;
675   TRACE_BEG4 (DEBUG_CTX, "gpgme_ctx_set_engine_info", ctx,
676               "protocol=%i (%s), file_name=%s, home_dir=%s",
677               proto, gpgme_get_protocol_name (proto)
678               ? gpgme_get_protocol_name (proto) : "unknown",
679               file_name ? file_name : "(default)",
680               home_dir ? home_dir : "(default)");
681               
682   /* Shut down the engine when changing engine info.  */
683   if (ctx->engine)
684     {
685       TRACE_LOG1 ("releasing ctx->engine=%p", ctx->engine);
686       _gpgme_engine_release (ctx->engine);
687       ctx->engine = NULL;
688     }
689   err = _gpgme_set_engine_info (ctx->engine_info, proto,
690                                 file_name, home_dir);
691   return TRACE_ERR (err);
692 }
693
694 \f
695 /* Clear all notation data from the context.  */
696 void
697 _gpgme_sig_notation_clear (gpgme_ctx_t ctx)
698 {
699   gpgme_sig_notation_t notation;
700
701   if (!ctx)
702     return;
703
704   notation = ctx->sig_notations;
705   while (notation)
706     {
707       gpgme_sig_notation_t next_notation = notation->next;
708       _gpgme_sig_notation_free (notation);
709       notation = next_notation;
710     }
711   ctx->sig_notations = NULL;
712 }
713
714 void
715 gpgme_sig_notation_clear (gpgme_ctx_t ctx)
716 {
717   TRACE (DEBUG_CTX, "gpgme_sig_notation_clear", ctx);
718   _gpgme_sig_notation_clear (ctx);
719 }
720
721
722 /* Add the human-readable notation data with name NAME and value VALUE
723    to the context CTX, using the flags FLAGS.  If NAME is NULL, then
724    VALUE should be a policy URL.  The flag
725    GPGME_SIG_NOTATION_HUMAN_READABLE is forced to be true for notation
726    data, and false for policy URLs.  */
727 gpgme_error_t
728 gpgme_sig_notation_add (gpgme_ctx_t ctx, const char *name,
729                         const char *value, gpgme_sig_notation_flags_t flags)
730 {
731   gpgme_error_t err;
732   gpgme_sig_notation_t notation;
733   gpgme_sig_notation_t *lastp;
734
735   TRACE_BEG3 (DEBUG_CTX, "gpgme_sig_notation_add", ctx,
736               "name=%s, value=%s, flags=0x%x",
737               name ? name : "(null)", value ? value : "(null)",
738               flags);
739   
740   if (!ctx)
741     return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
742
743   if (name)
744     flags |= GPGME_SIG_NOTATION_HUMAN_READABLE;
745   else
746     flags &= ~GPGME_SIG_NOTATION_HUMAN_READABLE;
747
748   err = _gpgme_sig_notation_create (&notation, name, name ? strlen (name) : 0,
749                                     value, value ? strlen (value) : 0, flags);
750   if (err)
751     return TRACE_ERR (err);
752
753   lastp = &ctx->sig_notations;
754   while (*lastp)
755     lastp = &(*lastp)->next;
756
757   *lastp = notation;
758   return TRACE_ERR (0);
759 }
760
761
762 /* Get the sig notations for this context.  */
763 gpgme_sig_notation_t
764 gpgme_sig_notation_get (gpgme_ctx_t ctx)
765 {
766   if (!ctx)
767     {
768       TRACE (DEBUG_CTX, "gpgme_sig_notation_get", ctx);
769       return NULL;
770     }
771   TRACE1 (DEBUG_CTX, "gpgme_sig_notation_get", ctx,
772           "ctx->sig_notations=%p", ctx->sig_notations);
773
774   return ctx->sig_notations;
775 }
776   
777 \f
778 const char *
779 gpgme_pubkey_algo_name (gpgme_pubkey_algo_t algo)
780 {
781   switch (algo)
782     {
783     case GPGME_PK_RSA:
784       return "RSA";
785
786     case GPGME_PK_RSA_E:
787       return "RSA-E";
788
789     case GPGME_PK_RSA_S:
790       return "RSA-S";
791
792     case GPGME_PK_ELG_E:
793       return "ELG-E";
794
795     case GPGME_PK_DSA:
796       return "DSA";
797
798     case GPGME_PK_ELG:
799       return "ELG";
800
801     case GPGME_PK_ECDSA:
802       return "ECDSA";
803
804     case GPGME_PK_ECDH:
805       return "ECDH";
806
807     default:
808       return NULL;
809     }
810 }
811
812
813 const char *
814 gpgme_hash_algo_name (gpgme_hash_algo_t algo)
815 {
816   switch (algo)
817     {
818     case GPGME_MD_MD5:
819       return "MD5";
820
821     case GPGME_MD_SHA1:
822       return "SHA1";
823
824     case GPGME_MD_RMD160:
825       return "RIPEMD160";
826
827     case GPGME_MD_MD2:
828       return "MD2";
829
830     case GPGME_MD_TIGER:
831       return "TIGER192";
832
833     case GPGME_MD_HAVAL:
834       return "HAVAL";
835
836     case GPGME_MD_SHA256:
837       return "SHA256";
838
839     case GPGME_MD_SHA384:
840       return "SHA384";
841
842     case GPGME_MD_SHA512:
843       return "SHA512";
844
845     case GPGME_MD_MD4:
846       return "MD4";
847
848     case GPGME_MD_CRC32:
849       return "CRC32";
850
851     case GPGME_MD_CRC32_RFC1510:
852       return "CRC32RFC1510";
853
854     case GPGME_MD_CRC24_RFC2440:
855       return "CRC24RFC2440";
856
857     default:
858       return NULL;
859     }
860 }