2004-05-21 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 /* Cancel a pending asynchronous operation.  */
94 gpgme_error_t
95 gpgme_cancel (gpgme_ctx_t ctx)
96 {
97   gpgme_error_t err;
98
99   err = _gpgme_engine_cancel (ctx->engine);
100   if (err)
101     return err;
102
103   err = gpg_error (GPG_ERR_CANCELED);
104   _gpgme_engine_io_event (ctx->engine, GPGME_EVENT_DONE, &err);
105
106   return 0;
107 }
108
109 /* Release all resources associated with the given context.  */
110 void
111 gpgme_release (gpgme_ctx_t ctx)
112 {
113   _gpgme_engine_release (ctx->engine);
114   _gpgme_fd_table_deinit (&ctx->fdt);
115   _gpgme_release_result (ctx);
116   gpgme_signers_clear (ctx);
117   if (ctx->signers)
118     free (ctx->signers);
119   if (ctx->lc_ctype)
120     free (ctx->lc_ctype);
121   if (ctx->lc_messages)
122     free (ctx->lc_messages);
123   free (ctx);
124 }
125
126
127 void
128 _gpgme_release_result (gpgme_ctx_t ctx)
129 {
130   struct ctx_op_data *data = ctx->op_data;
131
132   while (data)
133     {
134       struct ctx_op_data *next_data = data->next;
135       if (data->cleanup)
136         (*data->cleanup) (data->hook);
137       free (data);
138       data = next_data;
139     }
140   ctx->op_data = NULL;
141 }
142
143
144 gpgme_error_t
145 gpgme_set_protocol (gpgme_ctx_t ctx, gpgme_protocol_t protocol)
146 {
147   if (protocol != GPGME_PROTOCOL_OpenPGP && protocol != GPGME_PROTOCOL_CMS)
148     return gpg_error (GPG_ERR_INV_VALUE);
149
150   ctx->protocol = protocol;
151   return 0;
152 }
153
154
155 gpgme_protocol_t
156 gpgme_get_protocol (gpgme_ctx_t ctx)
157 {
158   return ctx->protocol;
159 }
160
161
162 const char *
163 gpgme_get_protocol_name (gpgme_protocol_t protocol)
164 {
165   switch (protocol)
166     {
167     case GPGME_PROTOCOL_OpenPGP:
168       return "OpenPGP";
169
170     case GPGME_PROTOCOL_CMS:
171       return "CMS";
172
173     default:
174       return NULL;
175     }
176 }
177
178 /* Enable or disable the use of an ascii armor for all output.  */
179 void
180 gpgme_set_armor (gpgme_ctx_t ctx, int yes)
181 {
182   ctx->use_armor = yes;
183 }
184
185
186 /* Return the state of the armor flag.  */
187 int
188 gpgme_get_armor (gpgme_ctx_t ctx)
189 {
190   return ctx->use_armor;
191 }
192
193
194 /* Enable or disable the use of the special textmode.  Textmode is for
195   example used for the RFC2015 signatures; note that the updated RFC
196   3156 mandates that the MUA does some preparations so that textmode
197   is not needed anymore.  */
198 void
199 gpgme_set_textmode (gpgme_ctx_t ctx, int yes)
200 {
201   ctx->use_textmode = yes;
202 }
203
204 /* Return the state of the textmode flag.  */
205 int
206 gpgme_get_textmode (gpgme_ctx_t ctx)
207 {
208   return ctx->use_textmode;
209 }
210
211
212 /* Set the number of certifications to include in an S/MIME message.
213    The default is 1 (only the cert of the sender).  -1 means all
214    certs, and -2 means all certs except the root cert.  */
215 void
216 gpgme_set_include_certs (gpgme_ctx_t ctx, int nr_of_certs)
217 {
218   if (nr_of_certs < -2)
219     ctx->include_certs = -2;
220   else
221     ctx->include_certs = nr_of_certs;
222 }
223
224
225 /* Get the number of certifications to include in an S/MIME
226    message.  */
227 int
228 gpgme_get_include_certs (gpgme_ctx_t ctx)
229 {
230   return ctx->include_certs;
231 }
232
233
234 /* This function changes the default behaviour of the keylisting
235    functions.  MODE is a bitwise-OR of the GPGME_KEYLIST_* flags.  The
236    default mode is GPGME_KEYLIST_MODE_LOCAL.  */
237 gpgme_error_t
238 gpgme_set_keylist_mode (gpgme_ctx_t ctx, gpgme_keylist_mode_t mode)
239 {
240   if (!((mode & GPGME_KEYLIST_MODE_LOCAL)
241         || (mode & GPGME_KEYLIST_MODE_EXTERN)
242         || (mode & GPGME_KEYLIST_MODE_SIGS)))
243     return gpg_error (GPG_ERR_INV_VALUE);
244
245   ctx->keylist_mode = mode;
246   return 0;
247 }
248
249 /* This function returns the default behaviour of the keylisting
250    functions.  */
251 gpgme_keylist_mode_t
252 gpgme_get_keylist_mode (gpgme_ctx_t ctx)
253 {
254   return ctx->keylist_mode;
255 }
256
257
258 /* This function sets a callback function to be used to pass a
259    passphrase to gpg.  */
260 void
261 gpgme_set_passphrase_cb (gpgme_ctx_t ctx, gpgme_passphrase_cb_t cb,
262                          void *cb_value)
263 {
264   ctx->passphrase_cb = cb;
265   ctx->passphrase_cb_value = cb_value;
266 }
267
268
269 /* This function returns the callback function to be used to pass a
270    passphrase to the crypto engine.  */
271 void
272 gpgme_get_passphrase_cb (gpgme_ctx_t ctx, gpgme_passphrase_cb_t *r_cb,
273                          void **r_cb_value)
274 {
275   if (r_cb)
276     *r_cb = ctx->passphrase_cb;
277   if (r_cb_value)
278     *r_cb_value = ctx->passphrase_cb_value;
279 }
280
281
282 /* This function sets a callback function to be used as a progress
283    indicator.  */
284 void
285 gpgme_set_progress_cb (gpgme_ctx_t ctx, gpgme_progress_cb_t cb, void *cb_value)
286 {
287   ctx->progress_cb = cb;
288   ctx->progress_cb_value = cb_value;
289 }
290
291
292 /* This function returns the callback function to be used as a
293    progress indicator.  */
294 void
295 gpgme_get_progress_cb (gpgme_ctx_t ctx, gpgme_progress_cb_t *r_cb,
296                        void **r_cb_value)
297 {
298   if (r_cb)
299     *r_cb = ctx->progress_cb;
300   if (r_cb_value)
301     *r_cb_value = ctx->progress_cb_value;
302 }
303
304
305 /* Set the I/O callback functions for CTX to IO_CBS.  */
306 void
307 gpgme_set_io_cbs (gpgme_ctx_t ctx, gpgme_io_cbs_t io_cbs)
308 {
309   if (io_cbs)
310     ctx->io_cbs = *io_cbs;
311   else
312     {
313       ctx->io_cbs.add = NULL;
314       ctx->io_cbs.add_priv = NULL;
315       ctx->io_cbs.remove = NULL;
316       ctx->io_cbs.event = NULL;
317       ctx->io_cbs.event_priv = NULL;
318     }
319 }
320
321
322 /* This function returns the callback function for I/O.  */
323 void
324 gpgme_get_io_cbs (gpgme_ctx_t ctx, gpgme_io_cbs_t io_cbs)
325 {
326   *io_cbs = ctx->io_cbs;
327 }
328
329 \f
330 /* This function sets the locale for the context CTX, or the default
331    locale if CTX is a null pointer.  */
332 gpgme_error_t
333 gpgme_set_locale (gpgme_ctx_t ctx, int category, const char *value)
334 {
335   int failed = 0;
336   char *new_lc_ctype;
337   char *new_lc_messages;
338
339 #define PREPARE_ONE_LOCALE(lcat, ucat)                          \
340   if (!failed && value                                          \
341       && (category == LC_ALL || category == LC_ ## ucat))       \
342     {                                                           \
343       new_lc_ ## lcat = strdup (value);                         \
344       if (!new_lc_ ## lcat)                                     \
345         failed = 1;                                             \
346     }                                                           \
347   else                                                          \
348     new_lc_ ## lcat = NULL;
349
350   PREPARE_ONE_LOCALE (ctype, CTYPE);
351   PREPARE_ONE_LOCALE (messages, MESSAGES);
352
353   if (failed)
354     {
355       int saved_errno = errno;
356
357       if (new_lc_ctype)
358         free (new_lc_ctype);
359       if (new_lc_messages)
360         free (new_lc_messages);
361
362       return gpg_error_from_errno (saved_errno);
363     }
364
365 #define SET_ONE_LOCALE(lcat, ucat)                      \
366   if (category == LC_ALL || category == LC_ ## ucat)    \
367     {                                                   \
368       if (ctx)                                          \
369         {                                               \
370           if (ctx->lc_ ## lcat)                         \
371             free (ctx->lc_ ## lcat);                    \
372           ctx->lc_ ## lcat = new_lc_ ## lcat;           \
373         }                                               \
374       else                                              \
375         {                                               \
376           if (def_lc_ ## lcat)                          \
377             free (def_lc_ ## lcat);                     \
378           def_lc_ ## lcat = new_lc_ ## lcat;            \
379         }                                               \
380     }
381
382   if (!ctx)
383     LOCK (def_lc_lock);
384   SET_ONE_LOCALE (ctype, CTYPE);
385   SET_ONE_LOCALE (messages, MESSAGES);
386   if (!ctx)
387     UNLOCK (def_lc_lock);
388
389   return 0;
390 }
391
392 \f
393 const char *
394 gpgme_pubkey_algo_name (gpgme_pubkey_algo_t algo)
395 {
396   switch (algo)
397     {
398     case GPGME_PK_RSA:
399       return "RSA";
400
401     case GPGME_PK_RSA_E:
402       return "RSA-E";
403
404     case GPGME_PK_RSA_S:
405       return "RSA-S";
406
407     case GPGME_PK_ELG_E:
408       return "ELG-E";
409
410     case GPGME_PK_DSA:
411       return "DSA";
412
413     case GPGME_PK_ELG:
414       return "ELG";
415
416     default:
417       return NULL;
418     }
419 }
420
421
422 const char *
423 gpgme_hash_algo_name (gpgme_hash_algo_t algo)
424 {
425   switch (algo)
426     {
427     case GPGME_MD_MD5:
428       return "MD5";
429
430     case GPGME_MD_SHA1:
431       return "SHA1";
432
433     case GPGME_MD_RMD160:
434       return "RIPEMD160";
435
436     case GPGME_MD_MD2:
437       return "MD2";
438
439     case GPGME_MD_TIGER:
440       return "TIGER192";
441
442     case GPGME_MD_HAVAL:
443       return "HAVAL";
444
445     case GPGME_MD_SHA256:
446       return "SHA256";
447
448     case GPGME_MD_SHA384:
449       return "SHA384";
450
451     case GPGME_MD_SHA512:
452       return "SHA512";
453
454     case GPGME_MD_MD4:
455       return "MD4";
456
457     case GPGME_MD_CRC32:
458       return "CRC32";
459
460     case GPGME_MD_CRC32_RFC1510:
461       return "CRC32RFC1510";
462
463     case GPGME_MD_CRC24_RFC2440:
464       return "CRC24RFC2440";
465
466     default:
467       return NULL;
468     }
469 }