2003-10-02 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 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 General Public License as published by
9    the Free Software Foundation; either version 2 of the License, or
10    (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    General Public License for more details.
16  
17    You should have received a copy of the GNU General Public License
18    along with GPGME; if not, write to the Free Software Foundation,
19    Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
20
21 #if HAVE_CONFIG_H
22 #include <config.h>
23 #endif
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #include <assert.h>
28 #include <errno.h>
29 #include <locale.h>
30
31 #include "util.h"
32 #include "context.h"
33 #include "ops.h"
34 #include "wait.h"
35
36 \f
37 /* The default locale.  */
38 DEFINE_STATIC_LOCK (def_lc_lock);
39 static char *def_lc_ctype;
40 static char *def_lc_messages;
41
42 \f
43 /* Create a new context as an environment for GPGME crypto
44    operations.  */
45 gpgme_error_t
46 gpgme_new (gpgme_ctx_t *r_ctx)
47 {
48   gpgme_ctx_t ctx;
49
50   ctx = calloc (1, sizeof *ctx);
51   if (!ctx)
52     return gpg_error_from_errno (errno);
53   ctx->keylist_mode = GPGME_KEYLIST_MODE_LOCAL;
54   ctx->include_certs = 1;
55   ctx->protocol = GPGME_PROTOCOL_OpenPGP;
56   _gpgme_fd_table_init (&ctx->fdt);
57
58   LOCK (def_lc_lock);
59   if (def_lc_ctype)
60     {
61       ctx->lc_ctype = strdup (def_lc_ctype);
62       if (!ctx->lc_ctype)
63         {
64           UNLOCK (def_lc_lock);
65           free (ctx);
66           return gpg_error_from_errno (errno);
67         }
68     }
69   else
70     def_lc_ctype = NULL;
71
72   if (def_lc_messages)
73     {
74       ctx->lc_messages = strdup (def_lc_messages);
75       if (!ctx->lc_messages)
76         {
77           UNLOCK (def_lc_lock);
78           if (ctx->lc_ctype)
79             free (ctx->lc_ctype);
80           free (ctx);
81           return gpg_error_from_errno (errno);
82         }
83     }
84   else
85     def_lc_messages = NULL;
86   UNLOCK (def_lc_lock);
87
88   *r_ctx = ctx;
89   return 0;
90 }
91
92
93 /* Release all resources associated with the given context.  */
94 void
95 gpgme_release (gpgme_ctx_t ctx)
96 {
97   _gpgme_engine_release (ctx->engine);
98   _gpgme_fd_table_deinit (&ctx->fdt);
99   _gpgme_release_result (ctx);
100   gpgme_signers_clear (ctx);
101   if (ctx->signers)
102     free (ctx->signers);
103   if (ctx->lc_ctype)
104     free (ctx->lc_ctype);
105   if (ctx->lc_messages)
106     free (ctx->lc_messages);
107   free (ctx);
108 }
109
110
111 void
112 _gpgme_release_result (gpgme_ctx_t ctx)
113 {
114   struct ctx_op_data *data = ctx->op_data;
115
116   while (data)
117     {
118       struct ctx_op_data *next_data = data->next;
119       if (data->cleanup)
120         (*data->cleanup) (data->hook);
121       free (data);
122       data = next_data;
123     }
124   ctx->op_data = NULL;
125 }
126
127
128 gpgme_error_t
129 gpgme_set_protocol (gpgme_ctx_t ctx, gpgme_protocol_t protocol)
130 {
131   if (protocol != GPGME_PROTOCOL_OpenPGP && protocol != GPGME_PROTOCOL_CMS)
132     return gpg_error (GPG_ERR_INV_VALUE);
133
134   ctx->protocol = protocol;
135   return 0;
136 }
137
138
139 gpgme_protocol_t
140 gpgme_get_protocol (gpgme_ctx_t ctx)
141 {
142   return ctx->protocol;
143 }
144
145
146 const char *
147 gpgme_get_protocol_name (gpgme_protocol_t protocol)
148 {
149   switch (protocol)
150     {
151     case GPGME_PROTOCOL_OpenPGP:
152       return "OpenPGP";
153
154     case GPGME_PROTOCOL_CMS:
155       return "CMS";
156
157     default:
158       return NULL;
159     }
160 }
161
162 /* Enable or disable the use of an ascii armor for all output.  */
163 void
164 gpgme_set_armor (gpgme_ctx_t ctx, int yes)
165 {
166   ctx->use_armor = yes;
167 }
168
169
170 /* Return the state of the armor flag.  */
171 int
172 gpgme_get_armor (gpgme_ctx_t ctx)
173 {
174   return ctx->use_armor;
175 }
176
177
178 /* Enable or disable the use of the special textmode.  Textmode is for
179   example used for the RFC2015 signatures; note that the updated RFC
180   3156 mandates that the MUA does some preparations so that textmode
181   is not needed anymore.  */
182 void
183 gpgme_set_textmode (gpgme_ctx_t ctx, int yes)
184 {
185   ctx->use_textmode = yes;
186 }
187
188 /* Return the state of the textmode flag.  */
189 int
190 gpgme_get_textmode (gpgme_ctx_t ctx)
191 {
192   return ctx->use_textmode;
193 }
194
195
196 /* Set the number of certifications to include in an S/MIME message.
197    The default is 1 (only the cert of the sender).  -1 means all
198    certs, and -2 means all certs except the root cert.  */
199 void
200 gpgme_set_include_certs (gpgme_ctx_t ctx, int nr_of_certs)
201 {
202   if (nr_of_certs < -2)
203     ctx->include_certs = -2;
204   else
205     ctx->include_certs = nr_of_certs;
206 }
207
208
209 /* Get the number of certifications to include in an S/MIME
210    message.  */
211 int
212 gpgme_get_include_certs (gpgme_ctx_t ctx)
213 {
214   return ctx->include_certs;
215 }
216
217
218 /* This function changes the default behaviour of the keylisting
219    functions.  MODE is a bitwise-OR of the GPGME_KEYLIST_* flags.  The
220    default mode is GPGME_KEYLIST_MODE_LOCAL.  */
221 gpgme_error_t
222 gpgme_set_keylist_mode (gpgme_ctx_t ctx, gpgme_keylist_mode_t mode)
223 {
224   if (!((mode & GPGME_KEYLIST_MODE_LOCAL)
225         || (mode & GPGME_KEYLIST_MODE_EXTERN)
226         || (mode & GPGME_KEYLIST_MODE_SIGS)))
227     return gpg_error (GPG_ERR_INV_VALUE);
228
229   ctx->keylist_mode = mode;
230   return 0;
231 }
232
233 /* This function returns the default behaviour of the keylisting
234    functions.  */
235 gpgme_keylist_mode_t
236 gpgme_get_keylist_mode (gpgme_ctx_t ctx)
237 {
238   return ctx->keylist_mode;
239 }
240
241
242 /* This function sets a callback function to be used to pass a
243    passphrase to gpg.  */
244 void
245 gpgme_set_passphrase_cb (gpgme_ctx_t ctx, gpgme_passphrase_cb_t cb,
246                          void *cb_value)
247 {
248   ctx->passphrase_cb = cb;
249   ctx->passphrase_cb_value = cb_value;
250 }
251
252
253 /* This function returns the callback function to be used to pass a
254    passphrase to the crypto engine.  */
255 void
256 gpgme_get_passphrase_cb (gpgme_ctx_t ctx, gpgme_passphrase_cb_t *r_cb,
257                          void **r_cb_value)
258 {
259   if (r_cb)
260     *r_cb = ctx->passphrase_cb;
261   if (r_cb_value)
262     *r_cb_value = ctx->passphrase_cb_value;
263 }
264
265
266 /* This function sets a callback function to be used as a progress
267    indicator.  */
268 void
269 gpgme_set_progress_cb (gpgme_ctx_t ctx, gpgme_progress_cb_t cb, void *cb_value)
270 {
271   ctx->progress_cb = cb;
272   ctx->progress_cb_value = cb_value;
273 }
274
275
276 /* This function returns the callback function to be used as a
277    progress indicator.  */
278 void
279 gpgme_get_progress_cb (gpgme_ctx_t ctx, gpgme_progress_cb_t *r_cb,
280                        void **r_cb_value)
281 {
282   if (r_cb)
283     *r_cb = ctx->progress_cb;
284   if (r_cb_value)
285     *r_cb_value = ctx->progress_cb_value;
286 }
287
288
289 /* Set the I/O callback functions for CTX to IO_CBS.  */
290 void
291 gpgme_set_io_cbs (gpgme_ctx_t ctx, gpgme_io_cbs_t io_cbs)
292 {
293   if (io_cbs)
294     ctx->io_cbs = *io_cbs;
295   else
296     {
297       ctx->io_cbs.add = NULL;
298       ctx->io_cbs.add_priv = NULL;
299       ctx->io_cbs.remove = NULL;
300       ctx->io_cbs.event = NULL;
301       ctx->io_cbs.event_priv = NULL;
302     }
303 }
304
305
306 /* This function returns the callback function for I/O.  */
307 void
308 gpgme_get_io_cbs (gpgme_ctx_t ctx, gpgme_io_cbs_t io_cbs)
309 {
310   *io_cbs = ctx->io_cbs;
311 }
312
313 \f
314 /* This function sets the locale for the context CTX, or the default
315    locale if CTX is a null pointer.  */
316 gpgme_error_t
317 gpgme_set_locale (gpgme_ctx_t ctx, int category, const char *value)
318 {
319   int failed = 0;
320   char *new_lc_ctype;
321   char *new_lc_messages;
322
323 #define PREPARE_ONE_LOCALE(lcat, ucat)                          \
324   if (!failed && value                                          \
325       && (category == LC_ALL || category == LC_ ## ucat))       \
326     {                                                           \
327       new_lc_ ## lcat = strdup (value);                         \
328       if (!new_lc_ ## lcat)                                     \
329         failed = 1;                                             \
330     }                                                           \
331   else                                                          \
332     new_lc_ ## lcat = NULL;
333
334   PREPARE_ONE_LOCALE (ctype, CTYPE);
335   PREPARE_ONE_LOCALE (messages, MESSAGES);
336
337   if (failed)
338     {
339       int saved_errno = errno;
340
341       if (new_lc_ctype)
342         free (new_lc_ctype);
343       if (new_lc_messages)
344         free (new_lc_messages);
345
346       return gpg_error_from_errno (saved_errno);
347     }
348
349 #define SET_ONE_LOCALE(lcat, ucat)                      \
350   if (category == LC_ALL || category == LC_ ## ucat)    \
351     {                                                   \
352       if (ctx)                                          \
353         {                                               \
354           if (ctx->lc_ ## lcat)                         \
355             free (ctx->lc_ ## lcat);                    \
356           ctx->lc_ ## lcat = new_lc_ ## lcat;           \
357         }                                               \
358       else                                              \
359         {                                               \
360           if (def_lc_ ## lcat)                          \
361             free (def_lc_ ## lcat);                     \
362           def_lc_ ## lcat = new_lc_ ## lcat;            \
363         }                                               \
364     }
365
366   if (!ctx)
367     LOCK (def_lc_lock);
368   SET_ONE_LOCALE (ctype, CTYPE);
369   SET_ONE_LOCALE (messages, MESSAGES);
370   if (!ctx)
371     UNLOCK (def_lc_lock);
372
373   return 0;
374 }
375
376 \f
377 const char *
378 gpgme_pubkey_algo_name (gpgme_pubkey_algo_t algo)
379 {
380   switch (algo)
381     {
382     case GPGME_PK_RSA:
383       return "RSA";
384
385     case GPGME_PK_RSA_E:
386       return "RSA-E";
387
388     case GPGME_PK_RSA_S:
389       return "RSA-S";
390
391     case GPGME_PK_ELG_E:
392       return "ELG-E";
393
394     case GPGME_PK_DSA:
395       return "DSA";
396
397     case GPGME_PK_ELG:
398       return "ELG";
399
400     default:
401       return NULL;
402     }
403 }
404
405
406 const char *
407 gpgme_hash_algo_name (gpgme_hash_algo_t algo)
408 {
409   switch (algo)
410     {
411     case GPGME_MD_MD5:
412       return "MD5";
413
414     case GPGME_MD_SHA1:
415       return "SHA1";
416
417     case GPGME_MD_RMD160:
418       return "RIPEMD160";
419
420     case GPGME_MD_MD2:
421       return "MD2";
422
423     case GPGME_MD_TIGER:
424       return "TIGER192";
425
426     case GPGME_MD_HAVAL:
427       return "HAVAL";
428
429     case GPGME_MD_SHA256:
430       return "SHA256";
431
432     case GPGME_MD_SHA384:
433       return "SHA384";
434
435     case GPGME_MD_SHA512:
436       return "SHA512";
437
438     case GPGME_MD_MD4:
439       return "MD4";
440
441     case GPGME_MD_CRC32:
442       return "CRC32";
443
444     case GPGME_MD_CRC32_RFC1510:
445       return "CRC32RFC1510";
446
447     case GPGME_MD_CRC24_RFC2440:
448       return "CRC24RFC2440";
449
450     default:
451       return NULL;
452     }
453 }