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