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