2002-10-09 Marcus Brinkmann <marcus@g10code.de>
[gpgme.git] / gpgme / engine.c
1 /* engine.c 
2    Copyright (C) 2000 Werner Koch (dd9jn)
3    Copyright (C) 2001, 2002 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 #ifdef HAVE_CONFIG_H
22 #include <config.h>
23 #endif
24 #include <time.h>
25 #include <sys/types.h>
26 #include <string.h>
27 #include <assert.h>
28
29 #include "gpgme.h"
30 #include "util.h"
31 #include "sema.h"
32 #include "io.h"
33
34 #include "engine.h"
35 #include "rungpg.h"
36 #include "engine-gpgsm.h"
37
38
39 struct engine_object_s
40   {
41     GpgmeProtocol protocol;
42
43     const char *path;
44     const char *version;
45
46     union
47       {
48         GpgObject gpg;
49         GpgsmObject gpgsm;
50       } engine;
51 };
52
53
54 /* Get the path of the engine for PROTOCOL.  */
55 const char *
56 _gpgme_engine_get_path (GpgmeProtocol proto)
57 {
58   switch (proto)
59     {
60     case GPGME_PROTOCOL_OpenPGP:
61       return _gpgme_get_gpg_path ();
62     case GPGME_PROTOCOL_CMS:
63       return _gpgme_get_gpgsm_path ();
64     default:
65       return NULL;
66     }
67 }
68
69
70 /* Get the version number of the engine for PROTOCOL.  */
71 const char *
72 _gpgme_engine_get_version (GpgmeProtocol proto)
73 {
74   switch (proto)
75     {
76     case GPGME_PROTOCOL_OpenPGP:
77       return _gpgme_gpg_get_version ();
78     case GPGME_PROTOCOL_CMS:
79       return _gpgme_gpgsm_get_version ();
80     default:
81       return NULL;
82     }
83 }
84
85
86 GpgmeError
87 gpgme_engine_check_version (GpgmeProtocol proto)
88 {
89   switch (proto)
90     {
91     case GPGME_PROTOCOL_OpenPGP:
92       return _gpgme_gpg_check_version ();
93     case GPGME_PROTOCOL_CMS:
94       return _gpgme_gpgsm_check_version ();
95     default:
96       return mk_error (Invalid_Value);
97     }
98 }
99
100
101 const char *
102 _gpgme_engine_get_info (GpgmeProtocol proto)
103 {
104   static const char fmt[] = " <engine>\n"
105     "  <protocol>%s</protocol>\n"
106     "  <version>%s</version>\n"
107     "  <path>%s</path>\n"
108     " </engine>\n";
109   static const char *const strproto[3] = { "OpenPGP", "CMS", NULL };
110   static const char *engine_info[3];  /* FIXME: MAX_PROTO + 1*/
111   DEFINE_STATIC_LOCK (engine_info_lock);
112
113   if (proto > 2 /* FIXME MAX_PROTO */ || !strproto[proto])
114     return NULL;
115
116   LOCK (engine_info_lock);
117   if (!engine_info[proto])
118     {
119       const char *path = _gpgme_engine_get_path (proto);
120       const char *version = _gpgme_engine_get_version (proto);
121
122       if (path && version)
123         {
124           char *info = malloc (strlen (fmt) + strlen (strproto[proto])
125                                    + strlen (path) + strlen (version) + 1);
126           if (!info)
127             info = " <engine>\n"
128               "  <error>Out of core</error>\n"
129               " </engine>";
130           else
131             sprintf (info, fmt, strproto[proto], version, path);
132           engine_info[proto] = info;
133         }
134     }
135   UNLOCK (engine_info_lock);
136   return engine_info[proto];
137 }
138
139
140 GpgmeError
141 _gpgme_engine_new (GpgmeProtocol proto, EngineObject *r_engine)
142 {
143   EngineObject engine;
144   GpgmeError err = 0;
145
146   engine = calloc (1, sizeof *engine);
147   if (!engine)
148     {
149       err = mk_error (Out_Of_Core);
150       goto leave;
151     }
152
153   engine->protocol = proto;
154   switch (proto)
155     {
156     case GPGME_PROTOCOL_OpenPGP:
157       err =_gpgme_gpg_new (&engine->engine.gpg);
158       break;
159     case GPGME_PROTOCOL_CMS:
160       err = _gpgme_gpgsm_new (&engine->engine.gpgsm);
161       if (err)
162         goto leave;
163       break;
164     default:
165       err = mk_error (Invalid_Value);
166     }
167   if (err)
168     goto leave;
169
170   engine->path = _gpgme_engine_get_path (proto);
171   engine->version = _gpgme_engine_get_version (proto);
172
173   if (!engine->path || !engine->version)
174     {
175       err = mk_error (Invalid_Engine);
176       goto leave;
177     }
178
179  leave:
180   if (err)
181     _gpgme_engine_release (engine);
182   else
183     *r_engine = engine;
184   
185   return err;
186 }
187
188
189 void
190 _gpgme_engine_release (EngineObject engine)
191 {
192   if (!engine)
193     return;
194
195   switch (engine->protocol)
196     {
197     case GPGME_PROTOCOL_OpenPGP:
198       _gpgme_gpg_release (engine->engine.gpg);
199       break;
200     case GPGME_PROTOCOL_CMS:
201       _gpgme_gpgsm_release (engine->engine.gpgsm);
202       break;
203     default:
204       break;
205     }
206   free (engine);
207 }
208
209
210 void
211 _gpgme_engine_set_verbosity (EngineObject engine, int verbosity)
212 {
213   if (!engine)
214     return;
215
216   switch (engine->protocol)
217     {
218     case GPGME_PROTOCOL_OpenPGP:
219       _gpgme_gpg_set_verbosity (engine->engine.gpg, verbosity);
220       break;
221     case GPGME_PROTOCOL_CMS:
222       /* FIXME */
223       break;
224     default:
225       break;
226     }
227 }
228
229 void
230 _gpgme_engine_set_status_handler (EngineObject engine,
231                                   GpgmeStatusHandler fnc, void *fnc_value)
232 {
233   if (!engine)
234     return;
235
236   switch (engine->protocol)
237     {
238     case GPGME_PROTOCOL_OpenPGP:
239       _gpgme_gpg_set_status_handler (engine->engine.gpg, fnc, fnc_value);
240       break;
241     case GPGME_PROTOCOL_CMS:
242       _gpgme_gpgsm_set_status_handler (engine->engine.gpgsm, fnc, fnc_value);
243       break;
244     default:
245       break;
246     }
247 }
248
249 GpgmeError
250 _gpgme_engine_set_command_handler (EngineObject engine,
251                                    GpgmeCommandHandler fnc, void *fnc_value,
252                                    GpgmeData linked_data)
253 {
254   if (!engine)
255     return mk_error (Invalid_Value);
256
257   switch (engine->protocol)
258     {
259     case GPGME_PROTOCOL_OpenPGP:
260       return _gpgme_gpg_set_command_handler (engine->engine.gpg,
261                                              fnc, fnc_value, linked_data);
262     case GPGME_PROTOCOL_CMS:
263       /* FIXME */
264       break;
265     default:
266       break;
267     }
268   return 0;
269 }
270
271 GpgmeError _gpgme_engine_set_colon_line_handler (EngineObject engine,
272                                                  GpgmeColonLineHandler fnc,
273                                                  void *fnc_value)
274 {
275   if (!engine)
276     return mk_error (Invalid_Value);
277
278   switch (engine->protocol)
279     {
280     case GPGME_PROTOCOL_OpenPGP:
281       return _gpgme_gpg_set_colon_line_handler (engine->engine.gpg, 
282                                                 fnc, fnc_value);
283     case GPGME_PROTOCOL_CMS:
284       _gpgme_gpgsm_set_colon_line_handler (engine->engine.gpgsm,
285                                            fnc, fnc_value);
286       break;
287
288     default:
289       break;
290     }
291   return 0;
292 }
293
294 GpgmeError
295 _gpgme_engine_op_decrypt (EngineObject engine, GpgmeData ciph, GpgmeData plain)
296 {
297   if (!engine)
298     return mk_error (Invalid_Value);
299
300   switch (engine->protocol)
301     {
302     case GPGME_PROTOCOL_OpenPGP:
303       return _gpgme_gpg_op_decrypt (engine->engine.gpg, ciph, plain);
304     case GPGME_PROTOCOL_CMS:
305       return _gpgme_gpgsm_op_decrypt (engine->engine.gpgsm, ciph, plain);
306     default:
307       break;
308     }
309   return 0;
310 }
311
312 GpgmeError
313 _gpgme_engine_op_delete (EngineObject engine, GpgmeKey key, int allow_secret)
314 {
315   if (!engine)
316     return mk_error (Invalid_Value);
317
318   switch (engine->protocol)
319     {
320     case GPGME_PROTOCOL_OpenPGP:
321       return _gpgme_gpg_op_delete (engine->engine.gpg, key, allow_secret);
322     case GPGME_PROTOCOL_CMS:
323       return _gpgme_gpgsm_op_delete (engine->engine.gpgsm, key, allow_secret);
324     default:
325       break;
326     }
327   return 0;
328 }
329
330
331 GpgmeError
332 _gpgme_engine_op_edit (EngineObject engine, GpgmeKey key, GpgmeData out,
333                        GpgmeCtx ctx /* FIXME */)
334 {
335   if (!engine)
336     return mk_error (Invalid_Value);
337
338   switch (engine->protocol)
339     {
340     case GPGME_PROTOCOL_OpenPGP:
341       return _gpgme_gpg_op_edit (engine->engine.gpg, key, out, ctx);
342     case GPGME_PROTOCOL_CMS:
343       /* FIXME */
344       return mk_error (Not_Implemented);
345     default:
346       break;
347     }
348   return 0;
349 }
350
351 GpgmeError
352 _gpgme_engine_op_encrypt (EngineObject engine, GpgmeRecipients recp,
353                           GpgmeData plain, GpgmeData ciph, int use_armor)
354 {
355   if (!engine)
356     return mk_error (Invalid_Value);
357
358   switch (engine->protocol)
359     {
360     case GPGME_PROTOCOL_OpenPGP:
361       return _gpgme_gpg_op_encrypt (engine->engine.gpg, recp, plain, ciph,
362                                     use_armor);
363     case GPGME_PROTOCOL_CMS:
364       return _gpgme_gpgsm_op_encrypt (engine->engine.gpgsm, recp, plain, ciph,
365                                       use_armor);
366     default:
367       break;
368     }
369   return 0;
370 }
371
372
373 GpgmeError
374 _gpgme_engine_op_encrypt_sign (EngineObject engine, GpgmeRecipients recp,
375                                GpgmeData plain, GpgmeData ciph, int use_armor,
376                                GpgmeCtx ctx /* FIXME */)
377 {
378   if (!engine)
379     return mk_error (Invalid_Value);
380
381   switch (engine->protocol)
382     {
383     case GPGME_PROTOCOL_OpenPGP:
384       return _gpgme_gpg_op_encrypt_sign (engine->engine.gpg, recp, plain, ciph,
385                                          use_armor, ctx);
386     case GPGME_PROTOCOL_CMS:
387       return mk_error (Not_Implemented);
388     default:
389       break;
390     }
391   return 0;
392 }
393
394
395 GpgmeError
396 _gpgme_engine_op_export (EngineObject engine, GpgmeRecipients recp,
397                          GpgmeData keydata, int use_armor)
398 {
399   if (!engine)
400     return mk_error (Invalid_Value);
401
402   switch (engine->protocol)
403     {
404     case GPGME_PROTOCOL_OpenPGP:
405       return _gpgme_gpg_op_export (engine->engine.gpg, recp, keydata,
406                                    use_armor);
407     case GPGME_PROTOCOL_CMS:
408       return _gpgme_gpgsm_op_export (engine->engine.gpgsm, recp, keydata,
409                                      use_armor);
410     default:
411       break;
412     }
413   return 0;
414 }
415
416 GpgmeError
417 _gpgme_engine_op_genkey (EngineObject engine, GpgmeData help_data,
418                          int use_armor, GpgmeData pubkey, GpgmeData seckey)
419 {
420   if (!engine)
421     return mk_error (Invalid_Value);
422
423   switch (engine->protocol)
424     {
425     case GPGME_PROTOCOL_OpenPGP:
426       return _gpgme_gpg_op_genkey (engine->engine.gpg, help_data, use_armor,
427                                    pubkey, seckey);
428     case GPGME_PROTOCOL_CMS:
429       return _gpgme_gpgsm_op_genkey (engine->engine.gpgsm, help_data, use_armor,
430                                      pubkey, seckey);
431     default:
432       break;
433     }
434   return 0;
435 }
436
437 GpgmeError
438 _gpgme_engine_op_import (EngineObject engine, GpgmeData keydata)
439 {
440   if (!engine)
441     return mk_error (Invalid_Value);
442
443   switch (engine->protocol)
444     {
445     case GPGME_PROTOCOL_OpenPGP:
446       return _gpgme_gpg_op_import (engine->engine.gpg, keydata);
447     case GPGME_PROTOCOL_CMS:
448       return _gpgme_gpgsm_op_import (engine->engine.gpgsm, keydata);
449     default:
450       break;
451     }
452   return 0;
453 }
454
455
456 GpgmeError
457 _gpgme_engine_op_keylist (EngineObject engine, const char *pattern,
458                           int secret_only, int keylist_mode)
459 {
460   if (!engine)
461     return mk_error (Invalid_Value);
462
463   switch (engine->protocol)
464     {
465     case GPGME_PROTOCOL_OpenPGP:
466       return _gpgme_gpg_op_keylist (engine->engine.gpg, pattern, secret_only,
467                                     keylist_mode);
468     case GPGME_PROTOCOL_CMS:
469       return _gpgme_gpgsm_op_keylist (engine->engine.gpgsm, pattern, secret_only,
470                                       keylist_mode);
471     default:
472       break;
473     }
474   return 0;
475 }
476
477
478 GpgmeError
479 _gpgme_engine_op_keylist_ext (EngineObject engine, const char *pattern[],
480                               int secret_only, int reserved, int keylist_mode)
481 {
482   if (!engine)
483     return mk_error (Invalid_Value);
484
485   switch (engine->protocol)
486     {
487     case GPGME_PROTOCOL_OpenPGP:
488       return _gpgme_gpg_op_keylist_ext (engine->engine.gpg, pattern,
489                                         secret_only, reserved, keylist_mode);
490     case GPGME_PROTOCOL_CMS:
491       return _gpgme_gpgsm_op_keylist_ext (engine->engine.gpgsm, pattern,
492                                           secret_only, reserved, keylist_mode);
493     default:
494       break;
495     }
496   return 0;
497 }
498
499
500 GpgmeError
501 _gpgme_engine_op_sign (EngineObject engine, GpgmeData in, GpgmeData out,
502                        GpgmeSigMode mode, int use_armor,
503                        int use_textmode, int include_certs,
504                        GpgmeCtx ctx /* FIXME */)
505 {
506   if (!engine)
507     return mk_error (Invalid_Value);
508
509   switch (engine->protocol)
510     {
511     case GPGME_PROTOCOL_OpenPGP:
512       return _gpgme_gpg_op_sign (engine->engine.gpg, in, out, mode, use_armor,
513                                  use_textmode, ctx);
514     case GPGME_PROTOCOL_CMS:
515       return _gpgme_gpgsm_op_sign (engine->engine.gpgsm, in, out, mode,
516                                    use_armor, use_textmode, include_certs, ctx);
517       break;
518     default:
519       break;
520     }
521   return 0;
522 }
523
524 GpgmeError
525 _gpgme_engine_op_trustlist (EngineObject engine, const char *pattern)
526 {
527   if (!engine)
528     return mk_error (Invalid_Value);
529
530   switch (engine->protocol)
531     {
532     case GPGME_PROTOCOL_OpenPGP:
533       return _gpgme_gpg_op_trustlist (engine->engine.gpg, pattern);
534     case GPGME_PROTOCOL_CMS:
535       return _gpgme_gpgsm_op_trustlist (engine->engine.gpgsm, pattern);
536     default:
537       break;
538     }
539   return 0;
540 }
541
542 GpgmeError
543 _gpgme_engine_op_verify (EngineObject engine, GpgmeData sig,
544                          GpgmeData signed_text, GpgmeData plaintext)
545 {
546   if (!engine)
547     return mk_error (Invalid_Value);
548
549   switch (engine->protocol)
550     {
551     case GPGME_PROTOCOL_OpenPGP:
552       return _gpgme_gpg_op_verify (engine->engine.gpg, sig,
553                                    signed_text, plaintext);
554     case GPGME_PROTOCOL_CMS:
555       return _gpgme_gpgsm_op_verify (engine->engine.gpgsm, sig,
556                                      signed_text, plaintext);
557     default:
558       break;
559     }
560   return 0;
561 }
562
563 GpgmeError
564 _gpgme_engine_start (EngineObject engine, void *opaque)
565 {
566   if (!engine)
567     return mk_error (Invalid_Value);
568
569   switch (engine->protocol)
570     {
571     case GPGME_PROTOCOL_OpenPGP:
572       return _gpgme_gpg_spawn (engine->engine.gpg, opaque);
573     case GPGME_PROTOCOL_CMS:
574       return _gpgme_gpgsm_start (engine->engine.gpgsm, opaque);
575     default:
576       break;
577     }
578   return 0;
579 }
580
581 void
582 _gpgme_engine_set_io_cbs (EngineObject engine,
583                           struct GpgmeIOCbs *io_cbs)
584 {
585   if (!engine)
586     return;
587
588   switch (engine->protocol)
589     {
590     case GPGME_PROTOCOL_OpenPGP:
591       _gpgme_gpg_set_io_cbs (engine->engine.gpg, io_cbs);
592       break;
593     case GPGME_PROTOCOL_CMS:
594       _gpgme_gpgsm_set_io_cbs (engine->engine.gpgsm, io_cbs);
595       break;
596     default:
597       break;
598     }
599 }
600
601 void
602 _gpgme_engine_io_event (EngineObject engine,
603                         GpgmeEventIO type, void *type_data)
604 {
605   if (!engine)
606     return;
607
608   switch (engine->protocol)
609     {
610     case GPGME_PROTOCOL_OpenPGP:
611       _gpgme_gpg_io_event (engine->engine.gpg, type, type_data);
612       break;
613     case GPGME_PROTOCOL_CMS:
614       _gpgme_gpgsm_io_event (engine->engine.gpgsm, type, type_data);
615       break;
616     default:
617       break;
618     }
619 }