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