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