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