2007-07-17 Marcus Brinkmann <marcus@g10code.de>
[gpgme.git] / gpgme / 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
38 \f
39 /* The default locale.  */
40 DEFINE_STATIC_LOCK (def_lc_lock);
41 static char *def_lc_ctype;
42 static char *def_lc_messages;
43
44 \f
45 /* Create a new context as an environment for GPGME crypto
46    operations.  */
47 gpgme_error_t
48 gpgme_new (gpgme_ctx_t *r_ctx)
49 {
50   gpgme_ctx_t ctx;
51   TRACE_BEG (DEBUG_CTX, "gpgme_new", r_ctx);
52
53   ctx = calloc (1, sizeof *ctx);
54   if (!ctx)
55     return TRACE_ERR (gpg_error_from_errno (errno));
56
57   _gpgme_engine_info_copy (&ctx->engine_info);
58   if (!ctx->engine_info)
59     {
60       free (ctx);
61       return TRACE_ERR (gpg_error_from_errno (errno));
62     }
63
64   ctx->keylist_mode = GPGME_KEYLIST_MODE_LOCAL;
65   ctx->include_certs = GPGME_INCLUDE_CERTS_DEFAULT;
66   ctx->protocol = GPGME_PROTOCOL_OpenPGP;
67   _gpgme_fd_table_init (&ctx->fdt);
68
69   LOCK (def_lc_lock);
70   if (def_lc_ctype)
71     {
72       ctx->lc_ctype = strdup (def_lc_ctype);
73       if (!ctx->lc_ctype)
74         {
75           UNLOCK (def_lc_lock);
76           _gpgme_engine_info_release (ctx->engine_info);
77           free (ctx);
78           return TRACE_ERR (gpg_error_from_errno (errno));
79         }
80     }
81   else
82     def_lc_ctype = NULL;
83
84   if (def_lc_messages)
85     {
86       ctx->lc_messages = strdup (def_lc_messages);
87       if (!ctx->lc_messages)
88         {
89           UNLOCK (def_lc_lock);
90           if (ctx->lc_ctype)
91             free (ctx->lc_ctype);
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_messages = NULL;
99   UNLOCK (def_lc_lock);
100
101   *r_ctx = ctx;
102
103   return TRACE_SUC1 ("ctx=%p", ctx);
104 }
105
106
107 /* Cancel a pending asynchronous operation.  */
108 gpgme_error_t
109 gpgme_cancel (gpgme_ctx_t ctx)
110 {
111   gpgme_error_t err;
112   TRACE_BEG (DEBUG_CTX, "gpgme_cancel", ctx);
113
114   err = _gpgme_engine_cancel (ctx->engine);
115   if (err)
116     return TRACE_ERR (err);
117
118   err = gpg_error (GPG_ERR_CANCELED);
119   _gpgme_engine_io_event (ctx->engine, GPGME_EVENT_DONE, &err);
120
121   return TRACE_ERR (0);
122 }
123
124 /* Release all resources associated with the given context.  */
125 void
126 gpgme_release (gpgme_ctx_t ctx)
127 {
128   TRACE (DEBUG_CTX, "gpgme_release", ctx);
129
130   _gpgme_engine_release (ctx->engine);
131   _gpgme_fd_table_deinit (&ctx->fdt);
132   _gpgme_release_result (ctx);
133   gpgme_signers_clear (ctx);
134   if (ctx->signers)
135     free (ctx->signers);
136   if (ctx->lc_ctype)
137     free (ctx->lc_ctype);
138   if (ctx->lc_messages)
139     free (ctx->lc_messages);
140   _gpgme_engine_info_release (ctx->engine_info);
141   free (ctx);
142 }
143
144
145 void
146 _gpgme_release_result (gpgme_ctx_t ctx)
147 {
148   struct ctx_op_data *data = ctx->op_data;
149
150   while (data)
151     {
152       struct ctx_op_data *next_data = data->next;
153       if (data->cleanup)
154         (*data->cleanup) (data->hook);
155       free (data);
156       data = next_data;
157     }
158   ctx->op_data = NULL;
159 }
160
161
162 gpgme_error_t
163 gpgme_set_protocol (gpgme_ctx_t ctx, gpgme_protocol_t protocol)
164 {
165   TRACE_BEG2 (DEBUG_CTX, "gpgme_set_protocol", ctx, "protocol=%i (%s)",
166               protocol, gpgme_get_protocol_name (protocol)
167               ? gpgme_get_protocol_name (protocol) : "unknown");
168
169   if (protocol != GPGME_PROTOCOL_OpenPGP && protocol != GPGME_PROTOCOL_CMS)
170     return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
171
172   if (ctx->protocol != protocol)
173     {
174       /* Shut down the engine when switching protocols.  */
175       if (ctx->engine)
176         {
177           TRACE_LOG1 ("releasing ctx->engine=%p", ctx->engine);
178           _gpgme_engine_release (ctx->engine);
179           ctx->engine = NULL;
180         }
181
182       ctx->protocol = protocol;
183     }
184   return TRACE_ERR (0);
185 }
186
187
188 gpgme_protocol_t
189 gpgme_get_protocol (gpgme_ctx_t ctx)
190 {
191   TRACE2 (DEBUG_CTX, "gpgme_get_protocol", ctx,
192           "ctx->protocol=%i (%s)", ctx->protocol,
193           gpgme_get_protocol_name (ctx->protocol)
194           ? gpgme_get_protocol_name (ctx->protocol) : "unknown");
195   return ctx->protocol;
196 }
197
198
199 const char *
200 gpgme_get_protocol_name (gpgme_protocol_t protocol)
201 {
202   switch (protocol)
203     {
204     case GPGME_PROTOCOL_OpenPGP:
205       return "OpenPGP";
206
207     case GPGME_PROTOCOL_CMS:
208       return "CMS";
209
210     default:
211       return NULL;
212     }
213 }
214
215 /* Enable or disable the use of an ascii armor for all output.  */
216 void
217 gpgme_set_armor (gpgme_ctx_t ctx, int use_armor)
218 {
219   TRACE2 (DEBUG_CTX, "gpgme_set_armor", ctx, "use_armor=%i (%s)",
220           use_armor, use_armor ? "yes" : "no");
221   ctx->use_armor = use_armor;
222 }
223
224
225 /* Return the state of the armor flag.  */
226 int
227 gpgme_get_armor (gpgme_ctx_t ctx)
228 {
229   TRACE2 (DEBUG_CTX, "gpgme_get_armor", ctx, "ctx->use_armor=%i (%s)",
230           ctx->use_armor, ctx->use_armor ? "yes" : "no");
231   return ctx->use_armor;
232 }
233
234
235 /* Enable or disable the use of the special textmode.  Textmode is for
236   example used for the RFC2015 signatures; note that the updated RFC
237   3156 mandates that the MUA does some preparations so that textmode
238   is not needed anymore.  */
239 void
240 gpgme_set_textmode (gpgme_ctx_t ctx, int use_textmode)
241 {
242   TRACE2 (DEBUG_CTX, "gpgme_set_textmode", ctx, "use_textmode=%i (%s)",
243           use_textmode, use_textmode ? "yes" : "no");
244   ctx->use_textmode = use_textmode;
245 }
246
247 /* Return the state of the textmode flag.  */
248 int
249 gpgme_get_textmode (gpgme_ctx_t ctx)
250 {
251   TRACE2 (DEBUG_CTX, "gpgme_get_textmode", ctx, "ctx->use_textmode=%i (%s)",
252           ctx->use_textmode, ctx->use_textmode ? "yes" : "no");
253   return ctx->use_textmode;
254 }
255
256
257 /* Set the number of certifications to include in an S/MIME message.
258    The default is GPGME_INCLUDE_CERTS_DEFAULT.  -1 means all certs,
259    and -2 means all certs except the root cert.  */
260 void
261 gpgme_set_include_certs (gpgme_ctx_t ctx, int nr_of_certs)
262 {
263   if (nr_of_certs == GPGME_INCLUDE_CERTS_DEFAULT)
264     ctx->include_certs = GPGME_INCLUDE_CERTS_DEFAULT;
265   else if (nr_of_certs < -2)
266     ctx->include_certs = -2;
267   else
268     ctx->include_certs = nr_of_certs;
269
270   TRACE2 (DEBUG_CTX, "gpgme_set_include_certs", ctx, "nr_of_certs=%i%s",
271           nr_of_certs, nr_of_certs == ctx->include_certs ? "" : " (-2)");
272 }
273
274
275 /* Get the number of certifications to include in an S/MIME
276    message.  */
277 int
278 gpgme_get_include_certs (gpgme_ctx_t ctx)
279 {
280   TRACE1 (DEBUG_CTX, "gpgme_get_include_certs", ctx, "ctx->include_certs=%i",
281           ctx->include_certs);
282   return ctx->include_certs;
283 }
284
285
286 /* This function changes the default behaviour of the keylisting
287    functions.  MODE is a bitwise-OR of the GPGME_KEYLIST_* flags.  The
288    default mode is GPGME_KEYLIST_MODE_LOCAL.  */
289 gpgme_error_t
290 gpgme_set_keylist_mode (gpgme_ctx_t ctx, gpgme_keylist_mode_t mode)
291 {
292   TRACE1 (DEBUG_CTX, "gpgme_set_keylist_mode", ctx, "keylist_mode=0x%x",
293           mode);
294
295   ctx->keylist_mode = mode;
296   return 0;
297 }
298
299 /* This function returns the default behaviour of the keylisting
300    functions.  */
301 gpgme_keylist_mode_t
302 gpgme_get_keylist_mode (gpgme_ctx_t ctx)
303 {
304   TRACE1 (DEBUG_CTX, "gpgme_get_keylist_mode", ctx,
305           "ctx->keylist_mode=0x%x", ctx->keylist_mode);
306   return ctx->keylist_mode;
307 }
308
309
310 /* This function sets a callback function to be used to pass a
311    passphrase to gpg.  */
312 void
313 gpgme_set_passphrase_cb (gpgme_ctx_t ctx, gpgme_passphrase_cb_t cb,
314                          void *cb_value)
315 {
316   TRACE2 (DEBUG_CTX, "gpgme_set_passphrase_cb", ctx,
317           "passphrase_cb=%p/%p", cb, cb_value);
318   ctx->passphrase_cb = cb;
319   ctx->passphrase_cb_value = cb_value;
320 }
321
322
323 /* This function returns the callback function to be used to pass a
324    passphrase to the crypto engine.  */
325 void
326 gpgme_get_passphrase_cb (gpgme_ctx_t ctx, gpgme_passphrase_cb_t *r_cb,
327                          void **r_cb_value)
328 {
329   TRACE2 (DEBUG_CTX, "gpgme_get_passphrase_cb", ctx,
330           "ctx->passphrase_cb=%p/%p",
331           ctx->passphrase_cb, ctx->passphrase_cb_value);
332   if (r_cb)
333     *r_cb = ctx->passphrase_cb;
334   if (r_cb_value)
335     *r_cb_value = ctx->passphrase_cb_value;
336 }
337
338
339 /* This function sets a callback function to be used as a progress
340    indicator.  */
341 void
342 gpgme_set_progress_cb (gpgme_ctx_t ctx, gpgme_progress_cb_t cb, void *cb_value)
343 {
344   TRACE2 (DEBUG_CTX, "gpgme_set_progress_cb", ctx, "progress_cb=%p/%p",
345           cb, cb_value);
346   ctx->progress_cb = cb;
347   ctx->progress_cb_value = cb_value;
348 }
349
350
351 /* This function returns the callback function to be used as a
352    progress indicator.  */
353 void
354 gpgme_get_progress_cb (gpgme_ctx_t ctx, gpgme_progress_cb_t *r_cb,
355                        void **r_cb_value)
356 {
357   TRACE2 (DEBUG_CTX, "gpgme_get_progress_cb", ctx, "ctx->progress_cb=%p/%p",
358           ctx->progress_cb, ctx->progress_cb_value);
359   if (r_cb)
360     *r_cb = ctx->progress_cb;
361   if (r_cb_value)
362     *r_cb_value = ctx->progress_cb_value;
363 }
364
365
366 /* Set the I/O callback functions for CTX to IO_CBS.  */
367 void
368 gpgme_set_io_cbs (gpgme_ctx_t ctx, gpgme_io_cbs_t io_cbs)
369 {
370   if (io_cbs)
371     {
372       TRACE6 (DEBUG_CTX, "gpgme_set_io_cbs", ctx,
373               "io_cbs=%p (add=%p/%p, remove=%p, event=%p/%p",
374               io_cbs, io_cbs->add, io_cbs->add_priv, io_cbs->remove,
375               io_cbs->event, io_cbs->event_priv);
376       ctx->io_cbs = *io_cbs;
377     }
378   else
379     {
380       TRACE1 (DEBUG_CTX, "gpgme_set_io_cbs", ctx,
381               "io_cbs=%p (default)", io_cbs);
382       ctx->io_cbs.add = NULL;
383       ctx->io_cbs.add_priv = NULL;
384       ctx->io_cbs.remove = NULL;
385       ctx->io_cbs.event = NULL;
386       ctx->io_cbs.event_priv = NULL;
387     }
388 }
389
390
391 /* This function returns the callback function for I/O.  */
392 void
393 gpgme_get_io_cbs (gpgme_ctx_t ctx, gpgme_io_cbs_t io_cbs)
394 {
395   TRACE6 (DEBUG_CTX, "gpgme_get_io_cbs", ctx,
396           "io_cbs=%p, ctx->io_cbs.add=%p/%p, .remove=%p, .event=%p/%p",
397           io_cbs, io_cbs->add, io_cbs->add_priv, io_cbs->remove,
398           io_cbs->event, io_cbs->event_priv);
399
400   *io_cbs = ctx->io_cbs;
401 }
402
403 \f
404 /* This function sets the locale for the context CTX, or the default
405    locale if CTX is a null pointer.  */
406 gpgme_error_t
407 gpgme_set_locale (gpgme_ctx_t ctx, int category, const char *value)
408 {
409   int failed = 0;
410   char *new_lc_ctype = NULL;
411   char *new_lc_messages = NULL;
412
413   TRACE_BEG2 (DEBUG_CTX, "gpgme_set_locale", ctx,
414                "category=%i, value=%s", category, value ? value : "(null)");
415
416 #define PREPARE_ONE_LOCALE(lcat, ucat)                          \
417   if (!failed && value                                          \
418       && (category == LC_ALL || category == LC_ ## ucat))       \
419     {                                                           \
420       new_lc_ ## lcat = strdup (value);                         \
421       if (!new_lc_ ## lcat)                                     \
422         failed = 1;                                             \
423     }
424
425   PREPARE_ONE_LOCALE (ctype, CTYPE);
426 #ifdef LC_MESSAGES
427   PREPARE_ONE_LOCALE (messages, MESSAGES);
428 #endif
429
430   if (failed)
431     {
432       int saved_errno = errno;
433
434       if (new_lc_ctype)
435         free (new_lc_ctype);
436       if (new_lc_messages)
437         free (new_lc_messages);
438
439       return TRACE_ERR (gpg_error_from_errno (saved_errno));
440     }
441
442 #define SET_ONE_LOCALE(lcat, ucat)                      \
443   if (category == LC_ALL || category == LC_ ## ucat)    \
444     {                                                   \
445       if (ctx)                                          \
446         {                                               \
447           if (ctx->lc_ ## lcat)                         \
448             free (ctx->lc_ ## lcat);                    \
449           ctx->lc_ ## lcat = new_lc_ ## lcat;           \
450         }                                               \
451       else                                              \
452         {                                               \
453           if (def_lc_ ## lcat)                          \
454             free (def_lc_ ## lcat);                     \
455           def_lc_ ## lcat = new_lc_ ## lcat;            \
456         }                                               \
457     }
458
459   if (!ctx)
460     LOCK (def_lc_lock);
461   SET_ONE_LOCALE (ctype, CTYPE);
462 #ifdef LC_MESSAGES
463   SET_ONE_LOCALE (messages, MESSAGES);
464 #endif
465   if (!ctx)
466     UNLOCK (def_lc_lock);
467
468   return TRACE_ERR (0);
469 }
470
471 \f
472 /* Get the information about the configured engines.  A pointer to the
473    first engine in the statically allocated linked list is returned.
474    The returned data is valid until the next gpgme_ctx_set_engine_info.  */
475 gpgme_engine_info_t
476 gpgme_ctx_get_engine_info (gpgme_ctx_t ctx)
477 {
478   TRACE1 (DEBUG_CTX, "gpgme_ctx_get_engine_info", ctx,
479           "ctx->engine_info=%p", ctx->engine_info);
480   return ctx->engine_info;
481 }
482
483
484 /* Set the engine info for the context CTX, protocol PROTO, to the
485    file name FILE_NAME and the home directory HOME_DIR.  */
486 gpgme_error_t
487 gpgme_ctx_set_engine_info (gpgme_ctx_t ctx, gpgme_protocol_t proto,
488                            const char *file_name, const char *home_dir)
489 {
490   gpgme_error_t err;
491   TRACE_BEG4 (DEBUG_CTX, "gpgme_ctx_set_engine_info", ctx,
492               "protocol=%i (%s), file_name=%s, home_dir=%s",
493               proto, gpgme_get_protocol_name (proto)
494               ? gpgme_get_protocol_name (proto) : "unknown",
495               file_name ? file_name : "(default)",
496               home_dir ? home_dir : "(default)");
497               
498   /* Shut down the engine when changing engine info.  */
499   if (ctx->engine)
500     {
501       TRACE_LOG1 ("releasing ctx->engine=%p", ctx->engine);
502       _gpgme_engine_release (ctx->engine);
503       ctx->engine = NULL;
504     }
505   err = _gpgme_set_engine_info (ctx->engine_info, proto,
506                                 file_name, home_dir);
507   return TRACE_ERR (err);
508 }
509
510 \f
511 /* Clear all notation data from the context.  */
512 void
513 gpgme_sig_notation_clear (gpgme_ctx_t ctx)
514 {
515   gpgme_sig_notation_t notation;
516   TRACE (DEBUG_CTX, "gpgme_sig_notation_clear", ctx);
517
518   if (!ctx)
519     return;
520
521   notation = ctx->sig_notations;
522   while (notation)
523     {
524       gpgme_sig_notation_t next_notation = notation->next;
525       _gpgme_sig_notation_free (notation);
526       notation = next_notation;
527     }
528 }
529
530
531 /* Add the human-readable notation data with name NAME and value VALUE
532    to the context CTX, using the flags FLAGS.  If NAME is NULL, then
533    VALUE should be a policy URL.  The flag
534    GPGME_SIG_NOTATION_HUMAN_READABLE is forced to be true for notation
535    data, and false for policy URLs.  */
536 gpgme_error_t
537 gpgme_sig_notation_add (gpgme_ctx_t ctx, const char *name,
538                         const char *value, gpgme_sig_notation_flags_t flags)
539 {
540   gpgme_error_t err;
541   gpgme_sig_notation_t notation;
542   gpgme_sig_notation_t *lastp;
543
544   TRACE_BEG3 (DEBUG_CTX, "gpgme_sig_notation_add", ctx,
545               "name=%s, value=%s, flags=0x%x",
546               name ? name : "(null)", value ? value : "(null)",
547               flags);
548   
549   if (!ctx)
550     return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
551
552   if (name)
553     flags |= GPGME_SIG_NOTATION_HUMAN_READABLE;
554   else
555     flags &= ~GPGME_SIG_NOTATION_HUMAN_READABLE;
556
557   err = _gpgme_sig_notation_create (&notation, name, name ? strlen (name) : 0,
558                                     value, value ? strlen (value) : 0, flags);
559   if (err)
560     return TRACE_ERR (err);
561
562   lastp = &ctx->sig_notations;
563   while (*lastp)
564     lastp = &(*lastp)->next;
565
566   *lastp = notation;
567   return TRACE_ERR (0);
568 }
569
570
571 /* Get the sig notations for this context.  */
572 gpgme_sig_notation_t
573 gpgme_sig_notation_get (gpgme_ctx_t ctx)
574 {
575   if (!ctx)
576     {
577       TRACE (DEBUG_CTX, "gpgme_sig_notation_get", ctx);
578       return NULL;
579     }
580   TRACE1 (DEBUG_CTX, "gpgme_sig_notation_get", ctx,
581           "ctx->sig_notations=%p", ctx->sig_notations);
582
583   return ctx->sig_notations;
584 }
585   
586 \f
587 const char *
588 gpgme_pubkey_algo_name (gpgme_pubkey_algo_t algo)
589 {
590   switch (algo)
591     {
592     case GPGME_PK_RSA:
593       return "RSA";
594
595     case GPGME_PK_RSA_E:
596       return "RSA-E";
597
598     case GPGME_PK_RSA_S:
599       return "RSA-S";
600
601     case GPGME_PK_ELG_E:
602       return "ELG-E";
603
604     case GPGME_PK_DSA:
605       return "DSA";
606
607     case GPGME_PK_ELG:
608       return "ELG";
609
610     default:
611       return NULL;
612     }
613 }
614
615
616 const char *
617 gpgme_hash_algo_name (gpgme_hash_algo_t algo)
618 {
619   switch (algo)
620     {
621     case GPGME_MD_MD5:
622       return "MD5";
623
624     case GPGME_MD_SHA1:
625       return "SHA1";
626
627     case GPGME_MD_RMD160:
628       return "RIPEMD160";
629
630     case GPGME_MD_MD2:
631       return "MD2";
632
633     case GPGME_MD_TIGER:
634       return "TIGER192";
635
636     case GPGME_MD_HAVAL:
637       return "HAVAL";
638
639     case GPGME_MD_SHA256:
640       return "SHA256";
641
642     case GPGME_MD_SHA384:
643       return "SHA384";
644
645     case GPGME_MD_SHA512:
646       return "SHA512";
647
648     case GPGME_MD_MD4:
649       return "MD4";
650
651     case GPGME_MD_CRC32:
652       return "CRC32";
653
654     case GPGME_MD_CRC32_RFC1510:
655       return "CRC32RFC1510";
656
657     case GPGME_MD_CRC24_RFC2440:
658       return "CRC24RFC2440";
659
660     default:
661       return NULL;
662     }
663 }