core: Use gpgrt locking for thread safeness
[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 (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       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 (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           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 (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               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 (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       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, int verify,
963                    gpgme_data_t ciph, gpgme_data_t plain)
964 {
965   engine_uiserver_t uiserver = engine;
966   gpgme_error_t err;
967   const char *protocol;
968   char *cmd;
969
970   if (!uiserver)
971     return gpg_error (GPG_ERR_INV_VALUE);
972   if (uiserver->protocol == GPGME_PROTOCOL_DEFAULT)
973     protocol = "";
974   else if (uiserver->protocol == GPGME_PROTOCOL_OpenPGP)
975     protocol = " --protocol=OpenPGP";
976   else if (uiserver->protocol == GPGME_PROTOCOL_CMS)
977     protocol = " --protocol=CMS";
978   else
979     return gpgme_error (GPG_ERR_UNSUPPORTED_PROTOCOL);
980
981   if (asprintf (&cmd, "DECRYPT%s%s", protocol,
982                 verify ? "" : " --no-verify") < 0)
983     return gpg_error_from_syserror ();
984
985   uiserver->input_cb.data = ciph;
986   err = uiserver_set_fd (uiserver, INPUT_FD,
987                          map_data_enc (uiserver->input_cb.data));
988   if (err)
989     {
990       free (cmd);
991       return gpg_error (GPG_ERR_GENERAL);       /* FIXME */
992     }
993   uiserver->output_cb.data = plain;
994   err = uiserver_set_fd (uiserver, OUTPUT_FD, 0);
995   if (err)
996     {
997       free (cmd);
998       return gpg_error (GPG_ERR_GENERAL);       /* FIXME */
999     }
1000   uiserver->inline_data = NULL;
1001
1002   err = start (engine, cmd);
1003   free (cmd);
1004   return err;
1005 }
1006
1007
1008 static gpgme_error_t
1009 uiserver_decrypt (void *engine, gpgme_data_t ciph, gpgme_data_t plain)
1010 {
1011   return _uiserver_decrypt (engine, 0, ciph, plain);
1012 }
1013
1014
1015 static gpgme_error_t
1016 uiserver_decrypt_verify (void *engine, gpgme_data_t ciph, gpgme_data_t plain)
1017 {
1018   return _uiserver_decrypt (engine, 1, ciph, plain);
1019 }
1020
1021
1022 static gpgme_error_t
1023 set_recipients (engine_uiserver_t uiserver, gpgme_key_t recp[])
1024 {
1025   gpgme_error_t err = 0;
1026   char *line;
1027   int linelen;
1028   int invalid_recipients = 0;
1029   int i;
1030
1031   linelen = 10 + 40 + 1;        /* "RECIPIENT " + guess + '\0'.  */
1032   line = malloc (10 + 40 + 1);
1033   if (!line)
1034     return gpg_error_from_syserror ();
1035   strcpy (line, "RECIPIENT ");
1036   for (i=0; !err && recp[i]; i++)
1037     {
1038       char *uid;
1039       int newlen;
1040
1041       /* We use only the first user ID of the key.  */
1042       if (!recp[i]->uids || !(uid=recp[i]->uids->uid) || !*uid)
1043         {
1044           invalid_recipients++;
1045           continue;
1046         }
1047
1048       newlen = 11 + strlen (uid);
1049       if (linelen < newlen)
1050         {
1051           char *newline = realloc (line, newlen);
1052           if (! newline)
1053             {
1054               int saved_err = gpg_error_from_syserror ();
1055               free (line);
1056               return saved_err;
1057             }
1058           line = newline;
1059           linelen = newlen;
1060         }
1061       /* FIXME: need to do proper escaping  */
1062       strcpy (&line[10], uid);
1063
1064       err = uiserver_assuan_simple_command (uiserver, line,
1065                                             uiserver->status.fnc,
1066                                             uiserver->status.fnc_value);
1067       /* FIXME: This might requires more work.  */
1068       if (gpg_err_code (err) == GPG_ERR_NO_PUBKEY)
1069         invalid_recipients++;
1070       else if (err)
1071         {
1072           free (line);
1073           return err;
1074         }
1075     }
1076   free (line);
1077   return gpg_error (invalid_recipients
1078                     ? GPG_ERR_UNUSABLE_PUBKEY : GPG_ERR_NO_ERROR);
1079 }
1080
1081
1082 static gpgme_error_t
1083 uiserver_encrypt (void *engine, gpgme_key_t recp[], gpgme_encrypt_flags_t flags,
1084                   gpgme_data_t plain, gpgme_data_t ciph, int use_armor)
1085 {
1086   engine_uiserver_t uiserver = engine;
1087   gpgme_error_t err;
1088   const char *protocol;
1089   char *cmd;
1090
1091   if (!uiserver)
1092     return gpg_error (GPG_ERR_INV_VALUE);
1093   if (uiserver->protocol == GPGME_PROTOCOL_DEFAULT)
1094     protocol = "";
1095   else if (uiserver->protocol == GPGME_PROTOCOL_OpenPGP)
1096     protocol = " --protocol=OpenPGP";
1097   else if (uiserver->protocol == GPGME_PROTOCOL_CMS)
1098     protocol = " --protocol=CMS";
1099   else
1100     return gpgme_error (GPG_ERR_UNSUPPORTED_PROTOCOL);
1101
1102   if (flags & GPGME_ENCRYPT_PREPARE)
1103     {
1104       if (!recp || plain || ciph)
1105         return gpg_error (GPG_ERR_INV_VALUE);
1106
1107       if (asprintf (&cmd, "PREP_ENCRYPT%s%s", protocol,
1108                     (flags & GPGME_ENCRYPT_EXPECT_SIGN)
1109                     ? " --expect-sign" : "") < 0)
1110         return gpg_error_from_syserror ();
1111     }
1112   else
1113     {
1114       if (!plain || !ciph)
1115         return gpg_error (GPG_ERR_INV_VALUE);
1116
1117       if (asprintf (&cmd, "ENCRYPT%s", protocol) < 0)
1118         return gpg_error_from_syserror ();
1119     }
1120
1121   if (plain)
1122     {
1123       uiserver->input_cb.data = plain;
1124       err = uiserver_set_fd (uiserver, INPUT_FD,
1125                              map_data_enc (uiserver->input_cb.data));
1126       if (err)
1127         {
1128           free (cmd);
1129           return err;
1130         }
1131     }
1132
1133   if (ciph)
1134     {
1135       uiserver->output_cb.data = ciph;
1136       err = uiserver_set_fd (uiserver, OUTPUT_FD, use_armor ? "--armor"
1137                              : map_data_enc (uiserver->output_cb.data));
1138       if (err)
1139         {
1140           free (cmd);
1141           return err;
1142         }
1143     }
1144
1145   uiserver->inline_data = NULL;
1146
1147   if (recp)
1148     {
1149       err = set_recipients (uiserver, recp);
1150       if (err)
1151         {
1152           free (cmd);
1153           return err;
1154         }
1155     }
1156
1157   err = start (uiserver, cmd);
1158   free (cmd);
1159   return err;
1160 }
1161
1162
1163 static gpgme_error_t
1164 uiserver_sign (void *engine, gpgme_data_t in, gpgme_data_t out,
1165                gpgme_sig_mode_t mode, int use_armor, int use_textmode,
1166                int include_certs, gpgme_ctx_t ctx /* FIXME */)
1167 {
1168   engine_uiserver_t uiserver = engine;
1169   gpgme_error_t err = 0;
1170   const char *protocol;
1171   char *cmd;
1172   gpgme_key_t key;
1173
1174   (void)use_textmode;
1175   (void)include_certs;
1176
1177   if (!uiserver || !in || !out)
1178     return gpg_error (GPG_ERR_INV_VALUE);
1179   if (uiserver->protocol == GPGME_PROTOCOL_DEFAULT)
1180     protocol = "";
1181   else if (uiserver->protocol == GPGME_PROTOCOL_OpenPGP)
1182     protocol = " --protocol=OpenPGP";
1183   else if (uiserver->protocol == GPGME_PROTOCOL_CMS)
1184     protocol = " --protocol=CMS";
1185   else
1186     return gpgme_error (GPG_ERR_UNSUPPORTED_PROTOCOL);
1187
1188   if (asprintf (&cmd, "SIGN%s%s", protocol,
1189                 (mode == GPGME_SIG_MODE_DETACH) ? " --detached" : "") < 0)
1190     return gpg_error_from_syserror ();
1191
1192   key = gpgme_signers_enum (ctx, 0);
1193   if (key)
1194     {
1195       const char *s = NULL;
1196
1197       if (key && key->uids)
1198         s = key->uids->email;
1199
1200       if (s && strlen (s) < 80)
1201         {
1202           char buf[100];
1203
1204           strcpy (stpcpy (buf, "SENDER --info "), s);
1205           err = uiserver_assuan_simple_command (uiserver, buf,
1206                                                 uiserver->status.fnc,
1207                                                 uiserver->status.fnc_value);
1208         }
1209       else
1210         err = gpg_error (GPG_ERR_INV_VALUE);
1211       gpgme_key_unref (key);
1212       if (err)
1213       {
1214         free (cmd);
1215         return err;
1216       }
1217   }
1218
1219   uiserver->input_cb.data = in;
1220   err = uiserver_set_fd (uiserver, INPUT_FD,
1221                          map_data_enc (uiserver->input_cb.data));
1222   if (err)
1223     {
1224       free (cmd);
1225       return err;
1226     }
1227   uiserver->output_cb.data = out;
1228   err = uiserver_set_fd (uiserver, OUTPUT_FD, use_armor ? "--armor"
1229                          : map_data_enc (uiserver->output_cb.data));
1230   if (err)
1231     {
1232       free (cmd);
1233       return err;
1234     }
1235   uiserver->inline_data = NULL;
1236
1237   err = start (uiserver, cmd);
1238   free (cmd);
1239   return err;
1240 }
1241
1242
1243 /* FIXME: Missing a way to specify --silent.  */
1244 static gpgme_error_t
1245 uiserver_verify (void *engine, gpgme_data_t sig, gpgme_data_t signed_text,
1246                  gpgme_data_t plaintext, gpgme_ctx_t ctx)
1247 {
1248   engine_uiserver_t uiserver = engine;
1249   gpgme_error_t err;
1250   const char *protocol;
1251   char *cmd;
1252
1253   (void)ctx; /* FIXME: We should to add a --sender option to the
1254               * UISever protocol.  */
1255
1256   if (!uiserver)
1257     return gpg_error (GPG_ERR_INV_VALUE);
1258   if (uiserver->protocol == GPGME_PROTOCOL_DEFAULT)
1259     protocol = "";
1260   else if (uiserver->protocol == GPGME_PROTOCOL_OpenPGP)
1261     protocol = " --protocol=OpenPGP";
1262   else if (uiserver->protocol == GPGME_PROTOCOL_CMS)
1263     protocol = " --protocol=CMS";
1264   else
1265     return gpgme_error (GPG_ERR_UNSUPPORTED_PROTOCOL);
1266
1267   if (asprintf (&cmd, "VERIFY%s", protocol) < 0)
1268     return gpg_error_from_syserror ();
1269
1270   uiserver->input_cb.data = sig;
1271   err = uiserver_set_fd (uiserver, INPUT_FD,
1272                          map_data_enc (uiserver->input_cb.data));
1273   if (err)
1274     {
1275       free (cmd);
1276       return err;
1277     }
1278   if (plaintext)
1279     {
1280       /* Normal or cleartext signature.  */
1281       uiserver->output_cb.data = plaintext;
1282       err = uiserver_set_fd (uiserver, OUTPUT_FD, 0);
1283     }
1284   else
1285     {
1286       /* Detached signature.  */
1287       uiserver->message_cb.data = signed_text;
1288       err = uiserver_set_fd (uiserver, MESSAGE_FD, 0);
1289     }
1290   uiserver->inline_data = NULL;
1291
1292   if (!err)
1293     err = start (uiserver, cmd);
1294
1295   free (cmd);
1296   return err;
1297 }
1298
1299
1300 /* This sets a status callback for monitoring status lines before they
1301  * are passed to a caller set handler.  */
1302 static void
1303 uiserver_set_status_cb (void *engine, gpgme_status_cb_t cb, void *cb_value)
1304 {
1305   engine_uiserver_t uiserver = engine;
1306
1307   uiserver->status.mon_cb = cb;
1308   uiserver->status.mon_cb_value = cb_value;
1309 }
1310
1311
1312 static void
1313 uiserver_set_status_handler (void *engine, engine_status_handler_t fnc,
1314                           void *fnc_value)
1315 {
1316   engine_uiserver_t uiserver = engine;
1317
1318   uiserver->status.fnc = fnc;
1319   uiserver->status.fnc_value = fnc_value;
1320 }
1321
1322
1323 static gpgme_error_t
1324 uiserver_set_colon_line_handler (void *engine, engine_colon_line_handler_t fnc,
1325                               void *fnc_value)
1326 {
1327   engine_uiserver_t uiserver = engine;
1328
1329   uiserver->colon.fnc = fnc;
1330   uiserver->colon.fnc_value = fnc_value;
1331   uiserver->colon.any = 0;
1332   return 0;
1333 }
1334
1335
1336 static void
1337 uiserver_set_io_cbs (void *engine, gpgme_io_cbs_t io_cbs)
1338 {
1339   engine_uiserver_t uiserver = engine;
1340   uiserver->io_cbs = *io_cbs;
1341 }
1342
1343
1344 static void
1345 uiserver_io_event (void *engine, gpgme_event_io_t type, void *type_data)
1346 {
1347   engine_uiserver_t uiserver = engine;
1348
1349   TRACE3 (DEBUG_ENGINE, "gpgme:uiserver_io_event", uiserver,
1350           "event %p, type %d, type_data %p",
1351           uiserver->io_cbs.event, type, type_data);
1352   if (uiserver->io_cbs.event)
1353     (*uiserver->io_cbs.event) (uiserver->io_cbs.event_priv, type, type_data);
1354 }
1355
1356
1357 struct engine_ops _gpgme_engine_ops_uiserver =
1358   {
1359     /* Static functions.  */
1360     _gpgme_get_default_uisrv_socket,
1361     NULL,
1362     uiserver_get_version,
1363     uiserver_get_req_version,
1364     uiserver_new,
1365
1366     /* Member functions.  */
1367     uiserver_release,
1368     uiserver_reset,
1369     uiserver_set_status_cb,
1370     uiserver_set_status_handler,
1371     NULL,               /* set_command_handler */
1372     uiserver_set_colon_line_handler,
1373     uiserver_set_locale,
1374     uiserver_set_protocol,
1375     uiserver_decrypt,
1376     uiserver_decrypt_verify,
1377     NULL,               /* delete */
1378     NULL,               /* edit */
1379     uiserver_encrypt,
1380     NULL,               /* encrypt_sign */
1381     NULL,               /* export */
1382     NULL,               /* export_ext */
1383     NULL,               /* genkey */
1384     NULL,               /* import */
1385     NULL,               /* keylist */
1386     NULL,               /* keylist_ext */
1387     NULL,               /* keysign */
1388     NULL,               /* tofu_policy */
1389     uiserver_sign,
1390     NULL,               /* trustlist */
1391     uiserver_verify,
1392     NULL,               /* getauditlog */
1393     NULL,               /* opassuan_transact */
1394     NULL,               /* conf_load */
1395     NULL,               /* conf_save */
1396     NULL,               /* query_swdb */
1397     uiserver_set_io_cbs,
1398     uiserver_io_event,
1399     uiserver_cancel,
1400     NULL,               /* cancel_op */
1401     NULL,               /* passwd */
1402     NULL,               /* set_pinentry_mode */
1403     NULL                /* opspawn */
1404   };