gpgconf: Add access to --list-dirs for non-default engine.
[gpgme.git] / src / engine-uiserver.c
1 /* engine-uiserver.c - Uiserver engine.
2    Copyright (C) 2000 Werner Koch (dd9jn)
3    Copyright (C) 2001, 2002, 2003, 2004, 2005, 2007, 2009 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 /* Peculiar: Use special keys from email address for recipient and
23    signer (==sender).  Use no data objects with encryption for
24    prep_encrypt.  */
25
26 #if HAVE_CONFIG_H
27 #include <config.h>
28 #endif
29
30 #include <stdlib.h>
31 #include <string.h>
32 #ifdef HAVE_SYS_TYPES_H
33 # include <sys/types.h>
34 #endif
35 #include <assert.h>
36 #ifdef HAVE_UNISTD_H
37 # include <unistd.h>
38 #endif
39 #include <locale.h>
40 #include <fcntl.h> /* FIXME */
41 #include <errno.h>
42
43 #include "gpgme.h"
44 #include "util.h"
45 #include "ops.h"
46 #include "wait.h"
47 #include "priv-io.h"
48 #include "sema.h"
49 #include "data.h"
50
51 #include "assuan.h"
52 #include "debug.h"
53
54 #include "engine-backend.h"
55
56 \f
57 typedef struct
58 {
59   int fd;       /* FD we talk about.  */
60   int server_fd;/* Server FD for this connection.  */
61   int dir;      /* Inbound/Outbound, maybe given implicit?  */
62   void *data;   /* Handler-specific data.  */
63   void *tag;    /* ID from the user for gpgme_remove_io_callback.  */
64   char server_fd_str[15]; /* Same as SERVER_FD but as a string.  We
65                              need this because _gpgme_io_fd2str can't
66                              be used on a closed descriptor.  */
67 } iocb_data_t;
68
69
70 struct engine_uiserver
71 {
72   assuan_context_t assuan_ctx;
73
74   int lc_ctype_set;
75   int lc_messages_set;
76   gpgme_protocol_t protocol;
77
78   iocb_data_t status_cb;
79
80   /* Input, output etc are from the servers perspective.  */
81   iocb_data_t input_cb;
82   gpgme_data_t input_helper_data;  /* Input helper data object.  */
83   void *input_helper_memory;       /* Input helper memory block.  */
84
85   iocb_data_t output_cb;
86
87   iocb_data_t message_cb;
88
89   struct
90   {
91     engine_status_handler_t fnc;
92     void *fnc_value;
93     gpgme_status_cb_t mon_cb;
94     void *mon_cb_value;
95   } status;
96
97   struct
98   {
99     engine_colon_line_handler_t fnc;
100     void *fnc_value;
101     struct
102     {
103       char *line;
104       int linesize;
105       int linelen;
106     } attic;
107     int any; /* any data line seen */
108   } colon;
109
110   gpgme_data_t inline_data;  /* Used to collect D lines.  */
111
112   struct gpgme_io_cbs io_cbs;
113 };
114
115 typedef struct engine_uiserver *engine_uiserver_t;
116
117
118 static void uiserver_io_event (void *engine,
119                             gpgme_event_io_t type, void *type_data);
120
121
122 \f
123 static char *
124 uiserver_get_version (const char *file_name)
125 {
126   (void)file_name;
127   return NULL;
128 }
129
130
131 static const char *
132 uiserver_get_req_version (void)
133 {
134   return NULL;
135 }
136
137 \f
138 static void
139 close_notify_handler (int fd, void *opaque)
140 {
141   engine_uiserver_t uiserver = opaque;
142
143   assert (fd != -1);
144   if (uiserver->status_cb.fd == fd)
145     {
146       if (uiserver->status_cb.tag)
147         (*uiserver->io_cbs.remove) (uiserver->status_cb.tag);
148       uiserver->status_cb.fd = -1;
149       uiserver->status_cb.tag = NULL;
150     }
151   else if (uiserver->input_cb.fd == fd)
152     {
153       if (uiserver->input_cb.tag)
154         (*uiserver->io_cbs.remove) (uiserver->input_cb.tag);
155       uiserver->input_cb.fd = -1;
156       uiserver->input_cb.tag = NULL;
157       if (uiserver->input_helper_data)
158         {
159           gpgme_data_release (uiserver->input_helper_data);
160           uiserver->input_helper_data = NULL;
161         }
162       if (uiserver->input_helper_memory)
163         {
164           free (uiserver->input_helper_memory);
165           uiserver->input_helper_memory = NULL;
166         }
167     }
168   else if (uiserver->output_cb.fd == fd)
169     {
170       if (uiserver->output_cb.tag)
171         (*uiserver->io_cbs.remove) (uiserver->output_cb.tag);
172       uiserver->output_cb.fd = -1;
173       uiserver->output_cb.tag = NULL;
174     }
175   else if (uiserver->message_cb.fd == fd)
176     {
177       if (uiserver->message_cb.tag)
178         (*uiserver->io_cbs.remove) (uiserver->message_cb.tag);
179       uiserver->message_cb.fd = -1;
180       uiserver->message_cb.tag = NULL;
181     }
182 }
183
184
185 /* This is the default inquiry callback.  We use it to handle the
186    Pinentry notifications.  */
187 static gpgme_error_t
188 default_inq_cb (engine_uiserver_t uiserver, const char *line)
189 {
190   (void)uiserver;
191
192   if (!strncmp (line, "PINENTRY_LAUNCHED", 17) && (line[17]==' '||!line[17]))
193     {
194       _gpgme_allow_set_foreground_window ((pid_t)strtoul (line+17, NULL, 10));
195     }
196
197   return 0;
198 }
199
200
201 static gpgme_error_t
202 uiserver_cancel (void *engine)
203 {
204   engine_uiserver_t uiserver = engine;
205
206   if (!uiserver)
207     return gpg_error (GPG_ERR_INV_VALUE);
208
209   if (uiserver->status_cb.fd != -1)
210     _gpgme_io_close (uiserver->status_cb.fd);
211   if (uiserver->input_cb.fd != -1)
212     _gpgme_io_close (uiserver->input_cb.fd);
213   if (uiserver->output_cb.fd != -1)
214     _gpgme_io_close (uiserver->output_cb.fd);
215   if (uiserver->message_cb.fd != -1)
216     _gpgme_io_close (uiserver->message_cb.fd);
217
218   if (uiserver->assuan_ctx)
219     {
220       assuan_release (uiserver->assuan_ctx);
221       uiserver->assuan_ctx = NULL;
222     }
223
224   return 0;
225 }
226
227
228 static void
229 uiserver_release (void *engine)
230 {
231   engine_uiserver_t uiserver = engine;
232
233   if (!uiserver)
234     return;
235
236   uiserver_cancel (engine);
237
238   free (uiserver->colon.attic.line);
239   free (uiserver);
240 }
241
242
243 static gpgme_error_t
244 uiserver_new (void **engine, const char *file_name, const char *home_dir,
245               const char *version)
246 {
247   gpgme_error_t err = 0;
248   engine_uiserver_t uiserver;
249   char *dft_display = NULL;
250   char dft_ttyname[64];
251   char *env_tty = NULL;
252   char *dft_ttytype = NULL;
253   char *optstr;
254
255   (void)home_dir;
256   (void)version; /* Not yet used.  */
257
258   uiserver = calloc (1, sizeof *uiserver);
259   if (!uiserver)
260     return gpg_error_from_syserror ();
261
262   uiserver->protocol = GPGME_PROTOCOL_DEFAULT;
263   uiserver->status_cb.fd = -1;
264   uiserver->status_cb.dir = 1;
265   uiserver->status_cb.tag = 0;
266   uiserver->status_cb.data = uiserver;
267
268   uiserver->input_cb.fd = -1;
269   uiserver->input_cb.dir = 0;
270   uiserver->input_cb.tag = 0;
271   uiserver->input_cb.server_fd = -1;
272   *uiserver->input_cb.server_fd_str = 0;
273   uiserver->output_cb.fd = -1;
274   uiserver->output_cb.dir = 1;
275   uiserver->output_cb.tag = 0;
276   uiserver->output_cb.server_fd = -1;
277   *uiserver->output_cb.server_fd_str = 0;
278   uiserver->message_cb.fd = -1;
279   uiserver->message_cb.dir = 0;
280   uiserver->message_cb.tag = 0;
281   uiserver->message_cb.server_fd = -1;
282   *uiserver->message_cb.server_fd_str = 0;
283
284   uiserver->status.fnc = 0;
285   uiserver->colon.fnc = 0;
286   uiserver->colon.attic.line = 0;
287   uiserver->colon.attic.linesize = 0;
288   uiserver->colon.attic.linelen = 0;
289   uiserver->colon.any = 0;
290
291   uiserver->inline_data = NULL;
292
293   uiserver->io_cbs.add = NULL;
294   uiserver->io_cbs.add_priv = NULL;
295   uiserver->io_cbs.remove = NULL;
296   uiserver->io_cbs.event = NULL;
297   uiserver->io_cbs.event_priv = NULL;
298
299   err = assuan_new_ext (&uiserver->assuan_ctx, GPG_ERR_SOURCE_GPGME,
300                         &_gpgme_assuan_malloc_hooks, _gpgme_assuan_log_cb,
301                         NULL);
302   if (err)
303     goto leave;
304   assuan_ctx_set_system_hooks (uiserver->assuan_ctx,
305                                &_gpgme_assuan_system_hooks);
306
307   err = assuan_socket_connect (uiserver->assuan_ctx,
308                                file_name ?
309                                file_name : _gpgme_get_default_uisrv_socket (),
310                                0, ASSUAN_SOCKET_SERVER_FDPASSING);
311   if (err)
312     goto leave;
313
314   err = _gpgme_getenv ("DISPLAY", &dft_display);
315   if (err)
316     goto leave;
317   if (dft_display)
318     {
319       if (gpgrt_asprintf (&optstr, "OPTION display=%s", dft_display) < 0)
320         {
321           err = gpg_error_from_syserror ();
322           free (dft_display);
323           goto leave;
324         }
325       free (dft_display);
326
327       err = assuan_transact (uiserver->assuan_ctx, optstr, NULL, NULL, NULL,
328                              NULL, NULL, NULL);
329       gpgrt_free (optstr);
330       if (err)
331         goto leave;
332     }
333
334   err = _gpgme_getenv ("GPG_TTY", &env_tty);
335   if (isatty (1) || env_tty || err)
336     {
337       int rc = 0;
338
339       if (err)
340         goto leave;
341       else if (env_tty)
342         {
343           snprintf (dft_ttyname, sizeof (dft_ttyname), "%s", env_tty);
344           free (env_tty);
345         }
346       else
347         rc = ttyname_r (1, dft_ttyname, sizeof (dft_ttyname));
348
349       /* Even though isatty() returns 1, ttyname_r() may fail in many
350          ways, e.g., when /dev/pts is not accessible under chroot.  */
351       if (!rc)
352         {
353           if (gpgrt_asprintf (&optstr, "OPTION ttyname=%s", dft_ttyname) < 0)
354             {
355               err = gpg_error_from_syserror ();
356               goto leave;
357             }
358           err = assuan_transact (uiserver->assuan_ctx, optstr, NULL, NULL, NULL,
359                                  NULL, NULL, NULL);
360           gpgrt_free (optstr);
361           if (err)
362             goto leave;
363
364           err = _gpgme_getenv ("TERM", &dft_ttytype);
365           if (err)
366             goto leave;
367           if (dft_ttytype)
368             {
369               if (gpgrt_asprintf (&optstr, "OPTION ttytype=%s", dft_ttytype)< 0)
370                 {
371                   err = gpg_error_from_syserror ();
372                   free (dft_ttytype);
373                   goto leave;
374                 }
375               free (dft_ttytype);
376
377               err = assuan_transact (uiserver->assuan_ctx, optstr, NULL, NULL,
378                                      NULL, NULL, NULL, NULL);
379               gpgrt_free (optstr);
380               if (err)
381                 goto leave;
382             }
383         }
384     }
385
386 #ifdef HAVE_W32_SYSTEM
387   /* Under Windows we need to use AllowSetForegroundWindow.  Tell
388      uiserver to tell us when it needs it.  */
389   if (!err)
390     {
391       err = assuan_transact (uiserver->assuan_ctx, "OPTION allow-pinentry-notify",
392                              NULL, NULL, NULL, NULL, NULL, NULL);
393       if (gpg_err_code (err) == GPG_ERR_UNKNOWN_OPTION)
394         err = 0; /* This is a new feature of uiserver.  */
395     }
396 #endif /*HAVE_W32_SYSTEM*/
397
398  leave:
399   if (err)
400     uiserver_release (uiserver);
401   else
402     *engine = uiserver;
403
404   return err;
405 }
406
407
408 static gpgme_error_t
409 uiserver_set_locale (void *engine, int category, const char *value)
410 {
411   engine_uiserver_t uiserver = engine;
412   gpgme_error_t err;
413   char *optstr;
414   const char *catstr;
415
416   /* FIXME: If value is NULL, we need to reset the option to default.
417      But we can't do this.  So we error out here.  UISERVER needs support
418      for this.  */
419   if (category == LC_CTYPE)
420     {
421       catstr = "lc-ctype";
422       if (!value && uiserver->lc_ctype_set)
423         return gpg_error (GPG_ERR_INV_VALUE);
424       if (value)
425         uiserver->lc_ctype_set = 1;
426     }
427 #ifdef LC_MESSAGES
428   else if (category == LC_MESSAGES)
429     {
430       catstr = "lc-messages";
431       if (!value && uiserver->lc_messages_set)
432         return gpg_error (GPG_ERR_INV_VALUE);
433       if (value)
434         uiserver->lc_messages_set = 1;
435     }
436 #endif /* LC_MESSAGES */
437   else
438     return gpg_error (GPG_ERR_INV_VALUE);
439
440   /* FIXME: Reset value to default.  */
441   if (!value)
442     return 0;
443
444   if (gpgrt_asprintf (&optstr, "OPTION %s=%s", catstr, value) < 0)
445     err = gpg_error_from_syserror ();
446   else
447     {
448       err = assuan_transact (uiserver->assuan_ctx, optstr, NULL, NULL,
449                              NULL, NULL, NULL, NULL);
450       gpgrt_free (optstr);
451     }
452
453   return err;
454 }
455
456
457 static gpgme_error_t
458 uiserver_set_protocol (void *engine, gpgme_protocol_t protocol)
459 {
460   engine_uiserver_t uiserver = engine;
461
462   if (protocol != GPGME_PROTOCOL_OpenPGP
463       && protocol != GPGME_PROTOCOL_CMS
464       && protocol != GPGME_PROTOCOL_DEFAULT)
465     return gpg_error (GPG_ERR_INV_VALUE);
466
467   uiserver->protocol = protocol;
468   return 0;
469 }
470
471
472 static gpgme_error_t
473 uiserver_assuan_simple_command (engine_uiserver_t uiserver, const char *cmd,
474                                 engine_status_handler_t status_fnc,
475                                 void *status_fnc_value)
476 {
477   assuan_context_t ctx = uiserver->assuan_ctx;
478   gpg_error_t err;
479   char *line;
480   size_t linelen;
481
482   err = assuan_write_line (ctx, cmd);
483   if (err)
484     return err;
485
486   do
487     {
488       err = assuan_read_line (ctx, &line, &linelen);
489       if (err)
490         return err;
491
492       if (*line == '#' || !linelen)
493         continue;
494
495       if (linelen >= 2
496           && line[0] == 'O' && line[1] == 'K'
497           && (line[2] == '\0' || line[2] == ' '))
498         return 0;
499       else if (linelen >= 4
500           && line[0] == 'E' && line[1] == 'R' && line[2] == 'R'
501           && line[3] == ' ')
502         err = atoi (&line[4]);
503       else if (linelen >= 2
504                && line[0] == 'S' && line[1] == ' ')
505         {
506           char *rest;
507           gpgme_status_code_t r;
508
509           rest = strchr (line + 2, ' ');
510           if (!rest)
511             rest = line + linelen; /* set to an empty string */
512           else
513             *(rest++) = 0;
514
515           r = _gpgme_parse_status (line + 2);
516           if (uiserver->status.mon_cb && r != GPGME_STATUS_PROGRESS)
517             {
518               /* Note that we call the monitor even if we do
519                * not know the status code (r < 0).  */
520               err = uiserver->status.mon_cb (uiserver->status.mon_cb_value,
521                                              line + 2, rest);
522             }
523
524           if (err)
525             ;
526           else if (r >= 0 && status_fnc)
527             err = status_fnc (status_fnc_value, r, rest);
528           else
529             err = gpg_error (GPG_ERR_GENERAL);
530         }
531       else
532         err = gpg_error (GPG_ERR_GENERAL);
533     }
534   while (!err);
535
536   return err;
537 }
538
539
540 typedef enum { INPUT_FD, OUTPUT_FD, MESSAGE_FD } fd_type_t;
541
542 #define COMMANDLINELEN 40
543 static gpgme_error_t
544 uiserver_set_fd (engine_uiserver_t uiserver, fd_type_t fd_type, const char *opt)
545 {
546   gpg_error_t err = 0;
547   char line[COMMANDLINELEN];
548   const char *which;
549   iocb_data_t *iocb_data;
550   int dir;
551
552   switch (fd_type)
553     {
554     case INPUT_FD:
555       which = "INPUT";
556       iocb_data = &uiserver->input_cb;
557       break;
558
559     case OUTPUT_FD:
560       which = "OUTPUT";
561       iocb_data = &uiserver->output_cb;
562       break;
563
564     case MESSAGE_FD:
565       which = "MESSAGE";
566       iocb_data = &uiserver->message_cb;
567       break;
568
569     default:
570       return gpg_error (GPG_ERR_INV_VALUE);
571     }
572
573   dir = iocb_data->dir;
574
575   /* We try to short-cut the communication by giving UISERVER direct
576      access to the file descriptor, rather than using a pipe.  */
577   iocb_data->server_fd = _gpgme_data_get_fd (iocb_data->data);
578   if (iocb_data->server_fd < 0)
579     {
580       int fds[2];
581
582       if (_gpgme_io_pipe (fds, 0) < 0)
583         return gpg_error_from_syserror ();
584
585       iocb_data->fd = dir ? fds[0] : fds[1];
586       iocb_data->server_fd = dir ? fds[1] : fds[0];
587
588       if (_gpgme_io_set_close_notify (iocb_data->fd,
589                                       close_notify_handler, uiserver))
590         {
591           err = gpg_error (GPG_ERR_GENERAL);
592           goto leave_set_fd;
593         }
594     }
595
596   err = assuan_sendfd (uiserver->assuan_ctx, iocb_data->server_fd);
597   if (err)
598     goto leave_set_fd;
599
600   _gpgme_io_close (iocb_data->server_fd);
601   iocb_data->server_fd = -1;
602
603   if (opt)
604     snprintf (line, COMMANDLINELEN, "%s FD %s", which, opt);
605   else
606     snprintf (line, COMMANDLINELEN, "%s FD", which);
607
608   err = uiserver_assuan_simple_command (uiserver, line, NULL, NULL);
609
610  leave_set_fd:
611   if (err)
612     {
613       _gpgme_io_close (iocb_data->fd);
614       iocb_data->fd = -1;
615       if (iocb_data->server_fd != -1)
616         {
617           _gpgme_io_close (iocb_data->server_fd);
618           iocb_data->server_fd = -1;
619         }
620     }
621
622   return err;
623 }
624
625
626 static const char *
627 map_data_enc (gpgme_data_t d)
628 {
629   switch (gpgme_data_get_encoding (d))
630     {
631     case GPGME_DATA_ENCODING_NONE:
632       break;
633     case GPGME_DATA_ENCODING_BINARY:
634       return "--binary";
635     case GPGME_DATA_ENCODING_BASE64:
636       return "--base64";
637     case GPGME_DATA_ENCODING_ARMOR:
638       return "--armor";
639     default:
640       break;
641     }
642   return NULL;
643 }
644
645
646 static gpgme_error_t
647 status_handler (void *opaque, int fd)
648 {
649   struct io_cb_data *data = (struct io_cb_data *) opaque;
650   engine_uiserver_t uiserver = (engine_uiserver_t) data->handler_value;
651   gpgme_error_t err = 0;
652   char *line;
653   size_t linelen;
654
655   do
656     {
657       err = assuan_read_line (uiserver->assuan_ctx, &line, &linelen);
658       if (err)
659         {
660           /* Try our best to terminate the connection friendly.  */
661           /*      assuan_write_line (uiserver->assuan_ctx, "BYE"); */
662           TRACE3 (DEBUG_CTX, "gpgme:status_handler", uiserver,
663                   "fd 0x%x: error from assuan (%d) getting status line : %s",
664                   fd, err, gpg_strerror (err));
665         }
666       else if (linelen >= 3
667                && line[0] == 'E' && line[1] == 'R' && line[2] == 'R'
668                && (line[3] == '\0' || line[3] == ' '))
669         {
670           if (line[3] == ' ')
671             err = atoi (&line[4]);
672           if (! err)
673             err = gpg_error (GPG_ERR_GENERAL);
674           TRACE2 (DEBUG_CTX, "gpgme:status_handler", uiserver,
675                   "fd 0x%x: ERR line - mapped to: %s",
676                   fd, err ? gpg_strerror (err) : "ok");
677           /* Try our best to terminate the connection friendly.  */
678           /*      assuan_write_line (uiserver->assuan_ctx, "BYE"); */
679         }
680       else if (linelen >= 2
681                && line[0] == 'O' && line[1] == 'K'
682                && (line[2] == '\0' || line[2] == ' '))
683         {
684           if (uiserver->status.fnc)
685             {
686               char emptystring[1] = {0};
687               err = uiserver->status.fnc (uiserver->status.fnc_value,
688                                           GPGME_STATUS_EOF, emptystring);
689               if (gpg_err_code (err) == GPG_ERR_FALSE)
690                 err = 0; /* Drop special error code.  */
691             }
692
693           if (!err && uiserver->colon.fnc && uiserver->colon.any)
694             {
695               /* We must tell a colon function about the EOF. We do
696                  this only when we have seen any data lines.  Note
697                  that this inlined use of colon data lines will
698                  eventually be changed into using a regular data
699                  channel. */
700               uiserver->colon.any = 0;
701               err = uiserver->colon.fnc (uiserver->colon.fnc_value, NULL);
702             }
703           TRACE2 (DEBUG_CTX, "gpgme:status_handler", uiserver,
704                   "fd 0x%x: OK line - final status: %s",
705                   fd, err ? gpg_strerror (err) : "ok");
706           _gpgme_io_close (uiserver->status_cb.fd);
707           return err;
708         }
709       else if (linelen > 2
710                && line[0] == 'D' && line[1] == ' '
711                && uiserver->colon.fnc)
712         {
713           /* We are using the colon handler even for plain inline data
714              - strange name for that function but for historic reasons
715              we keep it.  */
716           /* FIXME We can't use this for binary data because we
717              assume this is a string.  For the current usage of colon
718              output it is correct.  */
719           char *src = line + 2;
720           char *end = line + linelen;
721           char *dst;
722           char **aline = &uiserver->colon.attic.line;
723           int *alinelen = &uiserver->colon.attic.linelen;
724
725           if (uiserver->colon.attic.linesize < *alinelen + linelen + 1)
726             {
727               char *newline = realloc (*aline, *alinelen + linelen + 1);
728               if (!newline)
729                 err = gpg_error_from_syserror ();
730               else
731                 {
732                   *aline = newline;
733                   uiserver->colon.attic.linesize = *alinelen + linelen + 1;
734                 }
735             }
736           if (!err)
737             {
738               dst = *aline + *alinelen;
739
740               while (!err && src < end)
741                 {
742                   if (*src == '%' && src + 2 < end)
743                     {
744                       /* Handle escaped characters.  */
745                       ++src;
746                       *dst = _gpgme_hextobyte (src);
747                       (*alinelen)++;
748                       src += 2;
749                     }
750                   else
751                     {
752                       *dst = *src++;
753                       (*alinelen)++;
754                     }
755
756                   if (*dst == '\n')
757                     {
758                       /* Terminate the pending line, pass it to the colon
759                          handler and reset it.  */
760
761                       uiserver->colon.any = 1;
762                       if (*alinelen > 1 && *(dst - 1) == '\r')
763                         dst--;
764                       *dst = '\0';
765
766                       /* FIXME How should we handle the return code?  */
767                       err = uiserver->colon.fnc (uiserver->colon.fnc_value, *aline);
768                       if (!err)
769                         {
770                           dst = *aline;
771                           *alinelen = 0;
772                         }
773                     }
774                   else
775                     dst++;
776                 }
777             }
778           TRACE2 (DEBUG_CTX, "gpgme:status_handler", uiserver,
779                   "fd 0x%x: D line; final status: %s",
780                   fd, err? gpg_strerror (err):"ok");
781         }
782       else if (linelen > 2
783                && line[0] == 'D' && line[1] == ' '
784                && uiserver->inline_data)
785         {
786           char *src = line + 2;
787           char *end = line + linelen;
788           char *dst = src;
789           gpgme_ssize_t nwritten;
790
791           linelen = 0;
792           while (src < end)
793             {
794               if (*src == '%' && src + 2 < end)
795                 {
796                   /* Handle escaped characters.  */
797                   ++src;
798                   *dst++ = _gpgme_hextobyte (src);
799                   src += 2;
800                 }
801               else
802                 *dst++ = *src++;
803
804               linelen++;
805             }
806
807           src = line + 2;
808           while (linelen > 0)
809             {
810               nwritten = gpgme_data_write (uiserver->inline_data, src, linelen);
811               if (!nwritten || (nwritten < 0 && errno != EINTR)
812                   || nwritten > linelen)
813                 {
814                   err = gpg_error_from_syserror ();
815                   break;
816                 }
817               src += nwritten;
818               linelen -= nwritten;
819             }
820
821           TRACE2 (DEBUG_CTX, "gpgme:status_handler", uiserver,
822                   "fd 0x%x: D inlinedata; final status: %s",
823                   fd, err? gpg_strerror (err):"ok");
824         }
825       else if (linelen > 2
826                && line[0] == 'S' && line[1] == ' ')
827         {
828           char *rest;
829           gpgme_status_code_t r;
830
831           rest = strchr (line + 2, ' ');
832           if (!rest)
833             rest = line + linelen; /* set to an empty string */
834           else
835             *(rest++) = 0;
836
837           r = _gpgme_parse_status (line + 2);
838
839           if (r >= 0)
840             {
841               if (uiserver->status.fnc)
842                 {
843                   err = uiserver->status.fnc (uiserver->status.fnc_value,
844                                               r, rest);
845                   if (gpg_err_code (err) == GPG_ERR_FALSE)
846                     err = 0; /* Drop special error code.  */
847                 }
848             }
849           else
850             fprintf (stderr, "[UNKNOWN STATUS]%s %s", line + 2, rest);
851           TRACE3 (DEBUG_CTX, "gpgme:status_handler", uiserver,
852                   "fd 0x%x: S line (%s) - final status: %s",
853                   fd, line+2, err? gpg_strerror (err):"ok");
854         }
855       else if (linelen >= 7
856                && line[0] == 'I' && line[1] == 'N' && line[2] == 'Q'
857                && line[3] == 'U' && line[4] == 'I' && line[5] == 'R'
858                && line[6] == 'E'
859                && (line[7] == '\0' || line[7] == ' '))
860         {
861           char *keyword = line+7;
862
863           while (*keyword == ' ')
864             keyword++;;
865           default_inq_cb (uiserver, keyword);
866           assuan_write_line (uiserver->assuan_ctx, "END");
867         }
868
869     }
870   while (!err && assuan_pending_line (uiserver->assuan_ctx));
871
872   return err;
873 }
874
875
876 static gpgme_error_t
877 add_io_cb (engine_uiserver_t uiserver, iocb_data_t *iocbd, gpgme_io_cb_t handler)
878 {
879   gpgme_error_t err;
880
881   TRACE_BEG2 (DEBUG_ENGINE, "engine-uiserver:add_io_cb", uiserver,
882               "fd %d, dir %d", iocbd->fd, iocbd->dir);
883   err = (*uiserver->io_cbs.add) (uiserver->io_cbs.add_priv,
884                               iocbd->fd, iocbd->dir,
885                               handler, iocbd->data, &iocbd->tag);
886   if (err)
887     return TRACE_ERR (err);
888   if (!iocbd->dir)
889     /* FIXME Kludge around poll() problem.  */
890     err = _gpgme_io_set_nonblocking (iocbd->fd);
891   return TRACE_ERR (err);
892 }
893
894
895 static gpgme_error_t
896 start (engine_uiserver_t uiserver, const char *command)
897 {
898   gpgme_error_t err;
899   int fdlist[5];
900   int nfds;
901
902   /* We need to know the fd used by assuan for reads.  We do this by
903      using the assumption that the first returned fd from
904      assuan_get_active_fds() is always this one.  */
905   nfds = assuan_get_active_fds (uiserver->assuan_ctx, 0 /* read fds */,
906                                 fdlist, DIM (fdlist));
907   if (nfds < 1)
908     return gpg_error (GPG_ERR_GENERAL); /* FIXME */
909
910   /* We "duplicate" the file descriptor, so we can close it here (we
911      can't close fdlist[0], as that is closed by libassuan, and
912      closing it here might cause libassuan to close some unrelated FD
913      later).  Alternatively, we could special case status_fd and
914      register/unregister it manually as needed, but this increases
915      code duplication and is more complicated as we can not use the
916      close notifications etc.  A third alternative would be to let
917      Assuan know that we closed the FD, but that complicates the
918      Assuan interface.  */
919
920   uiserver->status_cb.fd = _gpgme_io_dup (fdlist[0]);
921   if (uiserver->status_cb.fd < 0)
922     return gpg_error_from_syserror ();
923
924   if (_gpgme_io_set_close_notify (uiserver->status_cb.fd,
925                                   close_notify_handler, uiserver))
926     {
927       _gpgme_io_close (uiserver->status_cb.fd);
928       uiserver->status_cb.fd = -1;
929       return gpg_error (GPG_ERR_GENERAL);
930     }
931
932   err = add_io_cb (uiserver, &uiserver->status_cb, status_handler);
933   if (!err && uiserver->input_cb.fd != -1)
934     err = add_io_cb (uiserver, &uiserver->input_cb, _gpgme_data_outbound_handler);
935   if (!err && uiserver->output_cb.fd != -1)
936     err = add_io_cb (uiserver, &uiserver->output_cb, _gpgme_data_inbound_handler);
937   if (!err && uiserver->message_cb.fd != -1)
938     err = add_io_cb (uiserver, &uiserver->message_cb, _gpgme_data_outbound_handler);
939
940   if (!err)
941     err = assuan_write_line (uiserver->assuan_ctx, command);
942
943   if (!err)
944     uiserver_io_event (uiserver, GPGME_EVENT_START, NULL);
945
946   return err;
947 }
948
949
950 static gpgme_error_t
951 uiserver_reset (void *engine)
952 {
953   engine_uiserver_t uiserver = engine;
954
955   /* We must send a reset because we need to reset the list of
956      signers.  Note that RESET does not reset OPTION commands. */
957   return uiserver_assuan_simple_command (uiserver, "RESET", NULL, NULL);
958 }
959
960
961 static gpgme_error_t
962 uiserver_decrypt (void *engine,
963                   gpgme_decrypt_flags_t flags,
964                   gpgme_data_t ciph, gpgme_data_t plain,
965                   int export_session_key, const char *override_session_key)
966 {
967   engine_uiserver_t uiserver = engine;
968   gpgme_error_t err;
969   const char *protocol;
970   char *cmd;
971   int verify = !!(flags & GPGME_DECRYPT_VERIFY);
972
973   (void)override_session_key; /* Fixme: We need to see now to add this
974                                * to the UI server protocol  */
975
976   if (!uiserver)
977     return gpg_error (GPG_ERR_INV_VALUE);
978   if (uiserver->protocol == GPGME_PROTOCOL_DEFAULT)
979     protocol = "";
980   else if (uiserver->protocol == GPGME_PROTOCOL_OpenPGP)
981     protocol = " --protocol=OpenPGP";
982   else if (uiserver->protocol == GPGME_PROTOCOL_CMS)
983     protocol = " --protocol=CMS";
984   else
985     return gpgme_error (GPG_ERR_UNSUPPORTED_PROTOCOL);
986
987   if (gpgrt_asprintf (&cmd, "DECRYPT%s%s%s", protocol,
988                 verify ? "" : " --no-verify",
989                 export_session_key ? " --export-session-key" : "") < 0)
990     return gpg_error_from_syserror ();
991
992   uiserver->input_cb.data = ciph;
993   err = uiserver_set_fd (uiserver, INPUT_FD,
994                          map_data_enc (uiserver->input_cb.data));
995   if (err)
996     {
997       gpgrt_free (cmd);
998       return gpg_error (GPG_ERR_GENERAL);       /* FIXME */
999     }
1000   uiserver->output_cb.data = plain;
1001   err = uiserver_set_fd (uiserver, OUTPUT_FD, 0);
1002   if (err)
1003     {
1004       gpgrt_free (cmd);
1005       return gpg_error (GPG_ERR_GENERAL);       /* FIXME */
1006     }
1007   uiserver->inline_data = NULL;
1008
1009   err = start (engine, cmd);
1010   gpgrt_free (cmd);
1011   return err;
1012 }
1013
1014
1015 static gpgme_error_t
1016 set_recipients (engine_uiserver_t uiserver, gpgme_key_t recp[])
1017 {
1018   gpgme_error_t err = 0;
1019   char *line;
1020   int linelen;
1021   int invalid_recipients = 0;
1022   int i;
1023
1024   linelen = 10 + 40 + 1;        /* "RECIPIENT " + guess + '\0'.  */
1025   line = malloc (10 + 40 + 1);
1026   if (!line)
1027     return gpg_error_from_syserror ();
1028   strcpy (line, "RECIPIENT ");
1029   for (i=0; !err && recp[i]; i++)
1030     {
1031       char *uid;
1032       int newlen;
1033
1034       /* We use only the first user ID of the key.  */
1035       if (!recp[i]->uids || !(uid=recp[i]->uids->uid) || !*uid)
1036         {
1037           invalid_recipients++;
1038           continue;
1039         }
1040
1041       newlen = 11 + strlen (uid);
1042       if (linelen < newlen)
1043         {
1044           char *newline = realloc (line, newlen);
1045           if (! newline)
1046             {
1047               int saved_err = gpg_error_from_syserror ();
1048               free (line);
1049               return saved_err;
1050             }
1051           line = newline;
1052           linelen = newlen;
1053         }
1054       /* FIXME: need to do proper escaping  */
1055       strcpy (&line[10], uid);
1056
1057       err = uiserver_assuan_simple_command (uiserver, line,
1058                                             uiserver->status.fnc,
1059                                             uiserver->status.fnc_value);
1060       /* FIXME: This might requires more work.  */
1061       if (gpg_err_code (err) == GPG_ERR_NO_PUBKEY)
1062         invalid_recipients++;
1063       else if (err)
1064         {
1065           free (line);
1066           return err;
1067         }
1068     }
1069   free (line);
1070   return gpg_error (invalid_recipients
1071                     ? GPG_ERR_UNUSABLE_PUBKEY : GPG_ERR_NO_ERROR);
1072 }
1073
1074
1075 static gpgme_error_t
1076 uiserver_encrypt (void *engine, gpgme_key_t recp[], gpgme_encrypt_flags_t flags,
1077                   gpgme_data_t plain, gpgme_data_t ciph, int use_armor)
1078 {
1079   engine_uiserver_t uiserver = engine;
1080   gpgme_error_t err;
1081   const char *protocol;
1082   char *cmd;
1083
1084   if (!uiserver)
1085     return gpg_error (GPG_ERR_INV_VALUE);
1086   if (uiserver->protocol == GPGME_PROTOCOL_DEFAULT)
1087     protocol = "";
1088   else if (uiserver->protocol == GPGME_PROTOCOL_OpenPGP)
1089     protocol = " --protocol=OpenPGP";
1090   else if (uiserver->protocol == GPGME_PROTOCOL_CMS)
1091     protocol = " --protocol=CMS";
1092   else
1093     return gpgme_error (GPG_ERR_UNSUPPORTED_PROTOCOL);
1094
1095   if (flags & GPGME_ENCRYPT_PREPARE)
1096     {
1097       if (!recp || plain || ciph)
1098         return gpg_error (GPG_ERR_INV_VALUE);
1099
1100       if (gpgrt_asprintf (&cmd, "PREP_ENCRYPT%s%s", protocol,
1101                     (flags & GPGME_ENCRYPT_EXPECT_SIGN)
1102                     ? " --expect-sign" : "") < 0)
1103         return gpg_error_from_syserror ();
1104     }
1105   else
1106     {
1107       if (!plain || !ciph)
1108         return gpg_error (GPG_ERR_INV_VALUE);
1109
1110       if (gpgrt_asprintf (&cmd, "ENCRYPT%s", protocol) < 0)
1111         return gpg_error_from_syserror ();
1112     }
1113
1114   if (plain)
1115     {
1116       uiserver->input_cb.data = plain;
1117       err = uiserver_set_fd (uiserver, INPUT_FD,
1118                              map_data_enc (uiserver->input_cb.data));
1119       if (err)
1120         {
1121           gpgrt_free (cmd);
1122           return err;
1123         }
1124     }
1125
1126   if (ciph)
1127     {
1128       uiserver->output_cb.data = ciph;
1129       err = uiserver_set_fd (uiserver, OUTPUT_FD, use_armor ? "--armor"
1130                              : map_data_enc (uiserver->output_cb.data));
1131       if (err)
1132         {
1133           gpgrt_free (cmd);
1134           return err;
1135         }
1136     }
1137
1138   uiserver->inline_data = NULL;
1139
1140   if (recp)
1141     {
1142       err = set_recipients (uiserver, recp);
1143       if (err)
1144         {
1145           gpgrt_free (cmd);
1146           return err;
1147         }
1148     }
1149
1150   err = start (uiserver, cmd);
1151   gpgrt_free (cmd);
1152   return err;
1153 }
1154
1155
1156 static gpgme_error_t
1157 uiserver_sign (void *engine, gpgme_data_t in, gpgme_data_t out,
1158                gpgme_sig_mode_t mode, int use_armor, int use_textmode,
1159                int include_certs, gpgme_ctx_t ctx /* FIXME */)
1160 {
1161   engine_uiserver_t uiserver = engine;
1162   gpgme_error_t err = 0;
1163   const char *protocol;
1164   char *cmd;
1165   gpgme_key_t key;
1166
1167   (void)use_textmode;
1168   (void)include_certs;
1169
1170   if (!uiserver || !in || !out)
1171     return gpg_error (GPG_ERR_INV_VALUE);
1172   if (uiserver->protocol == GPGME_PROTOCOL_DEFAULT)
1173     protocol = "";
1174   else if (uiserver->protocol == GPGME_PROTOCOL_OpenPGP)
1175     protocol = " --protocol=OpenPGP";
1176   else if (uiserver->protocol == GPGME_PROTOCOL_CMS)
1177     protocol = " --protocol=CMS";
1178   else
1179     return gpgme_error (GPG_ERR_UNSUPPORTED_PROTOCOL);
1180
1181   if (gpgrt_asprintf (&cmd, "SIGN%s%s", protocol,
1182                 (mode == GPGME_SIG_MODE_DETACH) ? " --detached" : "") < 0)
1183     return gpg_error_from_syserror ();
1184
1185   key = gpgme_signers_enum (ctx, 0);
1186   if (key)
1187     {
1188       const char *s = NULL;
1189
1190       if (key && key->uids)
1191         s = key->uids->email;
1192
1193       if (s && strlen (s) < 80)
1194         {
1195           char buf[100];
1196
1197           strcpy (stpcpy (buf, "SENDER --info "), s);
1198           err = uiserver_assuan_simple_command (uiserver, buf,
1199                                                 uiserver->status.fnc,
1200                                                 uiserver->status.fnc_value);
1201         }
1202       else
1203         err = gpg_error (GPG_ERR_INV_VALUE);
1204       gpgme_key_unref (key);
1205       if (err)
1206         {
1207           gpgrt_free (cmd);
1208           return err;
1209         }
1210   }
1211
1212   uiserver->input_cb.data = in;
1213   err = uiserver_set_fd (uiserver, INPUT_FD,
1214                          map_data_enc (uiserver->input_cb.data));
1215   if (err)
1216     {
1217       gpgrt_free (cmd);
1218       return err;
1219     }
1220   uiserver->output_cb.data = out;
1221   err = uiserver_set_fd (uiserver, OUTPUT_FD, use_armor ? "--armor"
1222                          : map_data_enc (uiserver->output_cb.data));
1223   if (err)
1224     {
1225       gpgrt_free (cmd);
1226       return err;
1227     }
1228   uiserver->inline_data = NULL;
1229
1230   err = start (uiserver, cmd);
1231   gpgrt_free (cmd);
1232   return err;
1233 }
1234
1235
1236 /* FIXME: Missing a way to specify --silent.  */
1237 static gpgme_error_t
1238 uiserver_verify (void *engine, gpgme_data_t sig, gpgme_data_t signed_text,
1239                  gpgme_data_t plaintext, gpgme_ctx_t ctx)
1240 {
1241   engine_uiserver_t uiserver = engine;
1242   gpgme_error_t err;
1243   const char *protocol;
1244   char *cmd;
1245
1246   (void)ctx; /* FIXME: We should to add a --sender option to the
1247               * UISever protocol.  */
1248
1249   if (!uiserver)
1250     return gpg_error (GPG_ERR_INV_VALUE);
1251   if (uiserver->protocol == GPGME_PROTOCOL_DEFAULT)
1252     protocol = "";
1253   else if (uiserver->protocol == GPGME_PROTOCOL_OpenPGP)
1254     protocol = " --protocol=OpenPGP";
1255   else if (uiserver->protocol == GPGME_PROTOCOL_CMS)
1256     protocol = " --protocol=CMS";
1257   else
1258     return gpgme_error (GPG_ERR_UNSUPPORTED_PROTOCOL);
1259
1260   if (gpgrt_asprintf (&cmd, "VERIFY%s", protocol) < 0)
1261     return gpg_error_from_syserror ();
1262
1263   uiserver->input_cb.data = sig;
1264   err = uiserver_set_fd (uiserver, INPUT_FD,
1265                          map_data_enc (uiserver->input_cb.data));
1266   if (err)
1267     {
1268       gpgrt_free (cmd);
1269       return err;
1270     }
1271   if (plaintext)
1272     {
1273       /* Normal or cleartext signature.  */
1274       uiserver->output_cb.data = plaintext;
1275       err = uiserver_set_fd (uiserver, OUTPUT_FD, 0);
1276     }
1277   else
1278     {
1279       /* Detached signature.  */
1280       uiserver->message_cb.data = signed_text;
1281       err = uiserver_set_fd (uiserver, MESSAGE_FD, 0);
1282     }
1283   uiserver->inline_data = NULL;
1284
1285   if (!err)
1286     err = start (uiserver, cmd);
1287
1288   gpgrt_free (cmd);
1289   return err;
1290 }
1291
1292
1293 /* This sets a status callback for monitoring status lines before they
1294  * are passed to a caller set handler.  */
1295 static void
1296 uiserver_set_status_cb (void *engine, gpgme_status_cb_t cb, void *cb_value)
1297 {
1298   engine_uiserver_t uiserver = engine;
1299
1300   uiserver->status.mon_cb = cb;
1301   uiserver->status.mon_cb_value = cb_value;
1302 }
1303
1304
1305 static void
1306 uiserver_set_status_handler (void *engine, engine_status_handler_t fnc,
1307                           void *fnc_value)
1308 {
1309   engine_uiserver_t uiserver = engine;
1310
1311   uiserver->status.fnc = fnc;
1312   uiserver->status.fnc_value = fnc_value;
1313 }
1314
1315
1316 static gpgme_error_t
1317 uiserver_set_colon_line_handler (void *engine, engine_colon_line_handler_t fnc,
1318                               void *fnc_value)
1319 {
1320   engine_uiserver_t uiserver = engine;
1321
1322   uiserver->colon.fnc = fnc;
1323   uiserver->colon.fnc_value = fnc_value;
1324   uiserver->colon.any = 0;
1325   return 0;
1326 }
1327
1328
1329 static void
1330 uiserver_set_io_cbs (void *engine, gpgme_io_cbs_t io_cbs)
1331 {
1332   engine_uiserver_t uiserver = engine;
1333   uiserver->io_cbs = *io_cbs;
1334 }
1335
1336
1337 static void
1338 uiserver_io_event (void *engine, gpgme_event_io_t type, void *type_data)
1339 {
1340   engine_uiserver_t uiserver = engine;
1341
1342   TRACE3 (DEBUG_ENGINE, "gpgme:uiserver_io_event", uiserver,
1343           "event %p, type %d, type_data %p",
1344           uiserver->io_cbs.event, type, type_data);
1345   if (uiserver->io_cbs.event)
1346     (*uiserver->io_cbs.event) (uiserver->io_cbs.event_priv, type, type_data);
1347 }
1348
1349
1350 struct engine_ops _gpgme_engine_ops_uiserver =
1351   {
1352     /* Static functions.  */
1353     _gpgme_get_default_uisrv_socket,
1354     NULL,
1355     uiserver_get_version,
1356     uiserver_get_req_version,
1357     uiserver_new,
1358
1359     /* Member functions.  */
1360     uiserver_release,
1361     uiserver_reset,
1362     uiserver_set_status_cb,
1363     uiserver_set_status_handler,
1364     NULL,               /* set_command_handler */
1365     uiserver_set_colon_line_handler,
1366     uiserver_set_locale,
1367     uiserver_set_protocol,
1368     uiserver_decrypt,
1369     NULL,               /* delete */
1370     NULL,               /* edit */
1371     uiserver_encrypt,
1372     NULL,               /* encrypt_sign */
1373     NULL,               /* export */
1374     NULL,               /* export_ext */
1375     NULL,               /* genkey */
1376     NULL,               /* import */
1377     NULL,               /* keylist */
1378     NULL,               /* keylist_ext */
1379     NULL,               /* keylist_data */
1380     NULL,               /* keysign */
1381     NULL,               /* tofu_policy */
1382     uiserver_sign,
1383     NULL,               /* trustlist */
1384     uiserver_verify,
1385     NULL,               /* getauditlog */
1386     NULL,               /* opassuan_transact */
1387     NULL,               /* conf_load */
1388     NULL,               /* conf_save */
1389     NULL,               /* conf_dir */
1390     NULL,               /* query_swdb */
1391     uiserver_set_io_cbs,
1392     uiserver_io_event,
1393     uiserver_cancel,
1394     NULL,               /* cancel_op */
1395     NULL,               /* passwd */
1396     NULL,               /* set_pinentry_mode */
1397     NULL                /* opspawn */
1398   };