b8e44e7c940193afc8389d8b27427f6aa8d88b04
[gpgme.git] / src / engine-gpgsm.c
1 /* engine-gpgsm.c - GpgSM engine.
2    Copyright (C) 2000 Werner Koch (dd9jn)
3    Copyright (C) 2001, 2002, 2003, 2004, 2005, 2007, 2009,
4                  2010 g10 Code GmbH
5
6    This file is part of GPGME.
7
8    GPGME is free software; you can redistribute it and/or modify it
9    under the terms of the GNU Lesser General Public License as
10    published by the Free Software Foundation; either version 2.1 of
11    the License, or (at your option) any later version.
12
13    GPGME is distributed in the hope that it will be useful, but
14    WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16    Lesser General Public License for more details.
17
18    You should have received a copy of the GNU Lesser General Public
19    License along with this program; if not, write to the Free Software
20    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
21    02111-1307, USA.  */
22
23 #if HAVE_CONFIG_H
24 #include <config.h>
25 #endif
26
27 #include <stdlib.h>
28 #include <string.h>
29 #ifdef HAVE_SYS_TYPES_H
30 # include <sys/types.h>
31 #endif
32 #include <assert.h>
33 #ifdef HAVE_UNISTD_H
34 # include <unistd.h>
35 #endif
36 #ifdef HAVE_LOCALE_H
37 #include <locale.h>
38 #endif
39 #include <fcntl.h> /* FIXME */
40 #include <errno.h>
41
42 #include "gpgme.h"
43 #include "util.h"
44 #include "ops.h"
45 #include "wait.h"
46 #include "priv-io.h"
47 #include "sema.h"
48 #include "data.h"
49
50 #include "assuan.h"
51 #include "debug.h"
52
53 #include "engine-backend.h"
54
55 \f
56 typedef struct
57 {
58   int fd;       /* FD we talk about.  */
59   int server_fd;/* Server FD for this connection.  */
60   int dir;      /* Inbound/Outbound, maybe given implicit?  */
61   void *data;   /* Handler-specific data.  */
62   void *tag;    /* ID from the user for gpgme_remove_io_callback.  */
63   char server_fd_str[15]; /* Same as SERVER_FD but as a string.  We
64                              need this because _gpgme_io_fd2str can't
65                              be used on a closed descriptor.  */
66 } iocb_data_t;
67
68
69 struct engine_gpgsm
70 {
71   assuan_context_t assuan_ctx;
72
73   int lc_ctype_set;
74   int lc_messages_set;
75
76   iocb_data_t status_cb;
77
78   /* Input, output etc are from the servers perspective.  */
79   iocb_data_t input_cb;
80   gpgme_data_t input_helper_data;  /* Input helper data object.  */
81   void *input_helper_memory;       /* Input helper memory block.  */
82
83   iocb_data_t output_cb;
84
85   iocb_data_t message_cb;
86
87   struct
88   {
89     engine_status_handler_t fnc;
90     void *fnc_value;
91     gpgme_status_cb_t mon_cb;
92     void *mon_cb_value;
93   } status;
94
95   struct
96   {
97     engine_colon_line_handler_t fnc;
98     void *fnc_value;
99     struct
100     {
101       char *line;
102       int linesize;
103       int linelen;
104     } attic;
105     int any; /* any data line seen */
106   } colon;
107
108   gpgme_data_t inline_data;  /* Used to collect D lines.  */
109
110   char request_origin[10];
111
112   struct gpgme_io_cbs io_cbs;
113 };
114
115 typedef struct engine_gpgsm *engine_gpgsm_t;
116
117
118 static void gpgsm_io_event (void *engine,
119                             gpgme_event_io_t type, void *type_data);
120
121
122 \f
123 static char *
124 gpgsm_get_version (const char *file_name)
125 {
126   return _gpgme_get_program_version (file_name ? file_name
127                                      : _gpgme_get_default_gpgsm_name ());
128 }
129
130
131 static const char *
132 gpgsm_get_req_version (void)
133 {
134   return "2.0.4";
135 }
136
137 \f
138 static void
139 close_notify_handler (int fd, void *opaque)
140 {
141   engine_gpgsm_t gpgsm = opaque;
142
143   assert (fd != -1);
144   if (gpgsm->status_cb.fd == fd)
145     {
146       if (gpgsm->status_cb.tag)
147         (*gpgsm->io_cbs.remove) (gpgsm->status_cb.tag);
148       gpgsm->status_cb.fd = -1;
149       gpgsm->status_cb.tag = NULL;
150     }
151   else if (gpgsm->input_cb.fd == fd)
152     {
153       if (gpgsm->input_cb.tag)
154         (*gpgsm->io_cbs.remove) (gpgsm->input_cb.tag);
155       gpgsm->input_cb.fd = -1;
156       gpgsm->input_cb.tag = NULL;
157       if (gpgsm->input_helper_data)
158         {
159           gpgme_data_release (gpgsm->input_helper_data);
160           gpgsm->input_helper_data = NULL;
161         }
162       if (gpgsm->input_helper_memory)
163         {
164           free (gpgsm->input_helper_memory);
165           gpgsm->input_helper_memory = NULL;
166         }
167     }
168   else if (gpgsm->output_cb.fd == fd)
169     {
170       if (gpgsm->output_cb.tag)
171         (*gpgsm->io_cbs.remove) (gpgsm->output_cb.tag);
172       gpgsm->output_cb.fd = -1;
173       gpgsm->output_cb.tag = NULL;
174     }
175   else if (gpgsm->message_cb.fd == fd)
176     {
177       if (gpgsm->message_cb.tag)
178         (*gpgsm->io_cbs.remove) (gpgsm->message_cb.tag);
179       gpgsm->message_cb.fd = -1;
180       gpgsm->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_gpgsm_t gpgsm, const char *line)
189 {
190   (void)gpgsm;
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 gpgsm_cancel (void *engine)
203 {
204   engine_gpgsm_t gpgsm = engine;
205
206   if (!gpgsm)
207     return gpg_error (GPG_ERR_INV_VALUE);
208
209   if (gpgsm->status_cb.fd != -1)
210     _gpgme_io_close (gpgsm->status_cb.fd);
211   if (gpgsm->input_cb.fd != -1)
212     _gpgme_io_close (gpgsm->input_cb.fd);
213   if (gpgsm->output_cb.fd != -1)
214     _gpgme_io_close (gpgsm->output_cb.fd);
215   if (gpgsm->message_cb.fd != -1)
216     _gpgme_io_close (gpgsm->message_cb.fd);
217
218   if (gpgsm->assuan_ctx)
219     {
220       assuan_release (gpgsm->assuan_ctx);
221       gpgsm->assuan_ctx = NULL;
222     }
223
224   return 0;
225 }
226
227
228 static void
229 gpgsm_release (void *engine)
230 {
231   engine_gpgsm_t gpgsm = engine;
232
233   if (!gpgsm)
234     return;
235
236   gpgsm_cancel (engine);
237
238   free (gpgsm->colon.attic.line);
239   free (gpgsm);
240 }
241
242
243 static gpgme_error_t
244 gpgsm_new (void **engine, const char *file_name, const char *home_dir,
245            const char *version)
246 {
247   gpgme_error_t err = 0;
248   engine_gpgsm_t gpgsm;
249   const char *pgmname;
250   const char *argv[5];
251   int argc;
252 #if !USE_DESCRIPTOR_PASSING
253   int fds[2];
254   int child_fds[4];
255 #endif
256   char *dft_display = NULL;
257   char dft_ttyname[64];
258   char *env_tty = NULL;
259   char *dft_ttytype = NULL;
260   char *optstr;
261
262   (void)version; /* Not yet used.  */
263
264   gpgsm = calloc (1, sizeof *gpgsm);
265   if (!gpgsm)
266     return gpg_error_from_syserror ();
267
268   gpgsm->status_cb.fd = -1;
269   gpgsm->status_cb.dir = 1;
270   gpgsm->status_cb.tag = 0;
271   gpgsm->status_cb.data = gpgsm;
272
273   gpgsm->input_cb.fd = -1;
274   gpgsm->input_cb.dir = 0;
275   gpgsm->input_cb.tag = 0;
276   gpgsm->input_cb.server_fd = -1;
277   *gpgsm->input_cb.server_fd_str = 0;
278   gpgsm->output_cb.fd = -1;
279   gpgsm->output_cb.dir = 1;
280   gpgsm->output_cb.tag = 0;
281   gpgsm->output_cb.server_fd = -1;
282   *gpgsm->output_cb.server_fd_str = 0;
283   gpgsm->message_cb.fd = -1;
284   gpgsm->message_cb.dir = 0;
285   gpgsm->message_cb.tag = 0;
286   gpgsm->message_cb.server_fd = -1;
287   *gpgsm->message_cb.server_fd_str = 0;
288
289   gpgsm->status.fnc = 0;
290   gpgsm->colon.fnc = 0;
291   gpgsm->colon.attic.line = 0;
292   gpgsm->colon.attic.linesize = 0;
293   gpgsm->colon.attic.linelen = 0;
294   gpgsm->colon.any = 0;
295
296   gpgsm->inline_data = NULL;
297
298   gpgsm->io_cbs.add = NULL;
299   gpgsm->io_cbs.add_priv = NULL;
300   gpgsm->io_cbs.remove = NULL;
301   gpgsm->io_cbs.event = NULL;
302   gpgsm->io_cbs.event_priv = NULL;
303
304 #if !USE_DESCRIPTOR_PASSING
305   if (_gpgme_io_pipe (fds, 0) < 0)
306     {
307       err = gpg_error_from_syserror ();
308       goto leave;
309     }
310   gpgsm->input_cb.fd = fds[1];
311   gpgsm->input_cb.server_fd = fds[0];
312
313   if (_gpgme_io_pipe (fds, 1) < 0)
314     {
315       err = gpg_error_from_syserror ();
316       goto leave;
317     }
318   gpgsm->output_cb.fd = fds[0];
319   gpgsm->output_cb.server_fd = fds[1];
320
321   if (_gpgme_io_pipe (fds, 0) < 0)
322     {
323       err = gpg_error_from_syserror ();
324       goto leave;
325     }
326   gpgsm->message_cb.fd = fds[1];
327   gpgsm->message_cb.server_fd = fds[0];
328
329   child_fds[0] = gpgsm->input_cb.server_fd;
330   child_fds[1] = gpgsm->output_cb.server_fd;
331   child_fds[2] = gpgsm->message_cb.server_fd;
332   child_fds[3] = -1;
333 #endif
334
335   pgmname = file_name ? file_name : _gpgme_get_default_gpgsm_name ();
336
337   argc = 0;
338   argv[argc++] = _gpgme_get_basename (pgmname);
339   if (home_dir)
340     {
341       argv[argc++] = "--homedir";
342       argv[argc++] = home_dir;
343     }
344   argv[argc++] = "--server";
345   argv[argc++] = NULL;
346
347   err = assuan_new_ext (&gpgsm->assuan_ctx, GPG_ERR_SOURCE_GPGME,
348                         &_gpgme_assuan_malloc_hooks, _gpgme_assuan_log_cb,
349                         NULL);
350   if (err)
351     goto leave;
352   assuan_ctx_set_system_hooks (gpgsm->assuan_ctx, &_gpgme_assuan_system_hooks);
353
354 #if USE_DESCRIPTOR_PASSING
355   err = assuan_pipe_connect (gpgsm->assuan_ctx, pgmname, argv,
356                              NULL, NULL, NULL, ASSUAN_PIPE_CONNECT_FDPASSING);
357 #else
358   {
359     assuan_fd_t achild_fds[4];
360     int i;
361
362     /* For now... */
363     for (i = 0; i < 4; i++)
364       achild_fds[i] = (assuan_fd_t) child_fds[i];
365
366     err = assuan_pipe_connect (gpgsm->assuan_ctx, pgmname, argv,
367                                achild_fds, NULL, NULL, 0);
368
369     /* For now... */
370     for (i = 0; i < 4; i++)
371       child_fds[i] = (int) achild_fds[i];
372   }
373
374   /* On Windows, handles are inserted in the spawned process with
375      DuplicateHandle, and child_fds contains the server-local names
376      for the inserted handles when assuan_pipe_connect returns.  */
377   if (!err)
378     {
379       /* Note: We don't use _gpgme_io_fd2str here.  On W32 the
380          returned handles are real W32 system handles, not whatever
381          GPGME uses internally (which may be a system handle, a C
382          library handle or a GLib/Qt channel.  Confusing, yes, but
383          remember these are server-local names, so they are not part
384          of GPGME at all.  */
385       snprintf (gpgsm->input_cb.server_fd_str,
386                 sizeof gpgsm->input_cb.server_fd_str, "%d", child_fds[0]);
387       snprintf (gpgsm->output_cb.server_fd_str,
388                 sizeof gpgsm->output_cb.server_fd_str, "%d", child_fds[1]);
389       snprintf (gpgsm->message_cb.server_fd_str,
390                 sizeof gpgsm->message_cb.server_fd_str, "%d", child_fds[2]);
391     }
392 #endif
393   if (err)
394     goto leave;
395
396   err = _gpgme_getenv ("DISPLAY", &dft_display);
397   if (err)
398     goto leave;
399   if (dft_display)
400     {
401       if (gpgrt_asprintf (&optstr, "OPTION display=%s", dft_display) < 0)
402         {
403           free (dft_display);
404           err = gpg_error_from_syserror ();
405           goto leave;
406         }
407       free (dft_display);
408
409       err = assuan_transact (gpgsm->assuan_ctx, optstr, NULL, NULL, NULL,
410                              NULL, NULL, NULL);
411       gpgrt_free (optstr);
412       if (err)
413         goto leave;
414     }
415
416   err = _gpgme_getenv ("GPG_TTY", &env_tty);
417   if (isatty (1) || env_tty || err)
418     {
419       int rc = 0;
420
421       if (err)
422         goto leave;
423       else if (env_tty)
424         {
425           snprintf (dft_ttyname, sizeof (dft_ttyname), "%s", env_tty);
426           free (env_tty);
427         }
428       else
429         rc = ttyname_r (1, dft_ttyname, sizeof (dft_ttyname));
430
431       /* Even though isatty() returns 1, ttyname_r() may fail in many
432          ways, e.g., when /dev/pts is not accessible under chroot.  */
433       if (!rc)
434         {
435           if (gpgrt_asprintf (&optstr, "OPTION ttyname=%s", dft_ttyname) < 0)
436             {
437               err = gpg_error_from_syserror ();
438               goto leave;
439             }
440           err = assuan_transact (gpgsm->assuan_ctx, optstr, NULL, NULL, NULL,
441                                  NULL, NULL, NULL);
442           gpgrt_free (optstr);
443           if (err)
444             goto leave;
445
446           err = _gpgme_getenv ("TERM", &dft_ttytype);
447           if (err)
448             goto leave;
449           if (dft_ttytype)
450             {
451               if (gpgrt_asprintf (&optstr, "OPTION ttytype=%s", dft_ttytype)< 0)
452                 {
453                   free (dft_ttytype);
454                   err = gpg_error_from_syserror ();
455                   goto leave;
456                 }
457               free (dft_ttytype);
458
459               err = assuan_transact (gpgsm->assuan_ctx, optstr, NULL, NULL,
460                                      NULL, NULL, NULL, NULL);
461               gpgrt_free (optstr);
462               if (err)
463                 goto leave;
464             }
465         }
466     }
467
468   /* Ask gpgsm to enable the audit log support.  */
469   if (!err)
470     {
471       err = assuan_transact (gpgsm->assuan_ctx, "OPTION enable-audit-log=1",
472                              NULL, NULL, NULL, NULL, NULL, NULL);
473       if (gpg_err_code (err) == GPG_ERR_UNKNOWN_OPTION)
474         err = 0; /* This is an optional feature of gpgsm.  */
475     }
476
477
478 #ifdef HAVE_W32_SYSTEM
479   /* Under Windows we need to use AllowSetForegroundWindow.  Tell
480      gpgsm to tell us when it needs it.  */
481   if (!err)
482     {
483       err = assuan_transact (gpgsm->assuan_ctx, "OPTION allow-pinentry-notify",
484                              NULL, NULL, NULL, NULL, NULL, NULL);
485       if (gpg_err_code (err) == GPG_ERR_UNKNOWN_OPTION)
486         err = 0; /* This is a new feature of gpgsm.  */
487     }
488 #endif /*HAVE_W32_SYSTEM*/
489
490 #if !USE_DESCRIPTOR_PASSING
491   if (!err
492       && (_gpgme_io_set_close_notify (gpgsm->input_cb.fd,
493                                       close_notify_handler, gpgsm)
494           || _gpgme_io_set_close_notify (gpgsm->output_cb.fd,
495                                          close_notify_handler, gpgsm)
496           || _gpgme_io_set_close_notify (gpgsm->message_cb.fd,
497                                          close_notify_handler, gpgsm)))
498     {
499       err = gpg_error (GPG_ERR_GENERAL);
500       goto leave;
501     }
502 #endif
503
504  leave:
505   /* Close the server ends of the pipes (because of this, we must use
506      the stored server_fd_str in the function start).  Our ends are
507      closed in gpgsm_release().  */
508 #if !USE_DESCRIPTOR_PASSING
509   if (gpgsm->input_cb.server_fd != -1)
510     _gpgme_io_close (gpgsm->input_cb.server_fd);
511   if (gpgsm->output_cb.server_fd != -1)
512     _gpgme_io_close (gpgsm->output_cb.server_fd);
513   if (gpgsm->message_cb.server_fd != -1)
514     _gpgme_io_close (gpgsm->message_cb.server_fd);
515 #endif
516
517   if (err)
518     gpgsm_release (gpgsm);
519   else
520     *engine = gpgsm;
521
522   return err;
523 }
524
525
526 /* Copy flags from CTX into the engine object.  */
527 static void
528 gpgsm_set_engine_flags (void *engine, const gpgme_ctx_t ctx)
529 {
530   engine_gpgsm_t gpgsm = engine;
531
532   if (ctx->request_origin)
533     {
534       if (strlen (ctx->request_origin) + 1 > sizeof gpgsm->request_origin)
535         strcpy (gpgsm->request_origin, "xxx"); /* Too long  - force error */
536       else
537         strcpy (gpgsm->request_origin, ctx->request_origin);
538     }
539   else
540     *gpgsm->request_origin = 0;
541 }
542
543
544 static gpgme_error_t
545 gpgsm_set_locale (void *engine, int category, const char *value)
546 {
547   engine_gpgsm_t gpgsm = engine;
548   gpgme_error_t err;
549   char *optstr;
550   const char *catstr;
551
552   /* FIXME: If value is NULL, we need to reset the option to default.
553      But we can't do this.  So we error out here.  GPGSM needs support
554      for this.  */
555   if (0)
556     ;
557 #ifdef LC_CTYPE
558   else if (category == LC_CTYPE)
559     {
560       catstr = "lc-ctype";
561       if (!value && gpgsm->lc_ctype_set)
562         return gpg_error (GPG_ERR_INV_VALUE);
563       if (value)
564         gpgsm->lc_ctype_set = 1;
565     }
566 #endif
567 #ifdef LC_MESSAGES
568   else if (category == LC_MESSAGES)
569     {
570       catstr = "lc-messages";
571       if (!value && gpgsm->lc_messages_set)
572         return gpg_error (GPG_ERR_INV_VALUE);
573       if (value)
574         gpgsm->lc_messages_set = 1;
575     }
576 #endif /* LC_MESSAGES */
577   else
578     return gpg_error (GPG_ERR_INV_VALUE);
579
580   /* FIXME: Reset value to default.  */
581   if (!value)
582     return 0;
583
584   if (gpgrt_asprintf (&optstr, "OPTION %s=%s", catstr, value) < 0)
585     err = gpg_error_from_syserror ();
586   else
587     {
588       err = assuan_transact (gpgsm->assuan_ctx, optstr, NULL, NULL,
589                              NULL, NULL, NULL, NULL);
590       gpgrt_free (optstr);
591     }
592
593   return err;
594 }
595
596
597 static gpgme_error_t
598 gpgsm_assuan_simple_command (engine_gpgsm_t gpgsm, const char *cmd,
599                              engine_status_handler_t status_fnc,
600                              void *status_fnc_value)
601 {
602   assuan_context_t ctx = gpgsm->assuan_ctx;
603   gpg_error_t err, cb_err;
604   char *line;
605   size_t linelen;
606
607   err = assuan_write_line (ctx, cmd);
608   if (err)
609     return err;
610
611   cb_err = 0;
612   do
613     {
614       err = assuan_read_line (ctx, &line, &linelen);
615       if (err)
616         break;
617
618       if (*line == '#' || !linelen)
619         continue;
620
621       if (linelen >= 2
622           && line[0] == 'O' && line[1] == 'K'
623           && (line[2] == '\0' || line[2] == ' '))
624         break;
625       else if (linelen >= 4
626           && line[0] == 'E' && line[1] == 'R' && line[2] == 'R'
627           && line[3] == ' ')
628         {
629           /* We prefer a callback generated error because that one is
630              more related to gpgme and thus probably more important
631              than the error returned by the engine.  */
632           err = cb_err? cb_err : atoi (&line[4]);
633           cb_err = 0;
634         }
635       else if (linelen >= 2
636                && line[0] == 'S' && line[1] == ' ')
637         {
638           /* After an error from a status callback we skip all further
639              status lines.  */
640           if (!cb_err)
641             {
642               char *rest;
643               gpgme_status_code_t r;
644
645               rest = strchr (line + 2, ' ');
646               if (!rest)
647                 rest = line + linelen; /* set to an empty string */
648               else
649                 *(rest++) = 0;
650
651               r = _gpgme_parse_status (line + 2);
652               if (gpgsm->status.mon_cb && r != GPGME_STATUS_PROGRESS)
653                 {
654                   /* Note that we call the monitor even if we do
655                    * not know the status code (r < 0).  */
656                   cb_err = gpgsm->status.mon_cb (gpgsm->status.mon_cb_value,
657                                                  line + 2, rest);
658                 }
659
660               if (r >= 0 && status_fnc && !cb_err)
661                 cb_err = status_fnc (status_fnc_value, r, rest);
662             }
663         }
664       else
665         {
666           /* Invalid line or INQUIRY.  We can't do anything else than
667              to stop.  As with ERR we prefer a status callback
668              generated error code, though.  */
669           err = cb_err ? cb_err : gpg_error (GPG_ERR_GENERAL);
670           cb_err = 0;
671         }
672     }
673   while (!err);
674
675   /* We only want the first error from the status handler, thus we
676    * take the one saved in CB_ERR. */
677   if (!err && cb_err)
678     err = cb_err;
679
680   return err;
681 }
682
683
684 typedef enum { INPUT_FD, OUTPUT_FD, MESSAGE_FD } fd_type_t;
685
686 static void
687 gpgsm_clear_fd (engine_gpgsm_t gpgsm, fd_type_t fd_type)
688 {
689 #if !USE_DESCRIPTOR_PASSING
690   switch (fd_type)
691     {
692     case INPUT_FD:
693       _gpgme_io_close (gpgsm->input_cb.fd);
694       break;
695     case OUTPUT_FD:
696       _gpgme_io_close (gpgsm->output_cb.fd);
697       break;
698     case MESSAGE_FD:
699       _gpgme_io_close (gpgsm->message_cb.fd);
700       break;
701     }
702 #else
703   (void)gpgsm;
704   (void)fd_type;
705 #endif
706 }
707
708 #define COMMANDLINELEN 40
709 static gpgme_error_t
710 gpgsm_set_fd (engine_gpgsm_t gpgsm, fd_type_t fd_type, const char *opt)
711 {
712   gpg_error_t err = 0;
713   char line[COMMANDLINELEN];
714   const char *which;
715   iocb_data_t *iocb_data;
716 #if USE_DESCRIPTOR_PASSING
717   int dir;
718 #endif
719
720   switch (fd_type)
721     {
722     case INPUT_FD:
723       which = "INPUT";
724       iocb_data = &gpgsm->input_cb;
725       break;
726
727     case OUTPUT_FD:
728       which = "OUTPUT";
729       iocb_data = &gpgsm->output_cb;
730       break;
731
732     case MESSAGE_FD:
733       which = "MESSAGE";
734       iocb_data = &gpgsm->message_cb;
735       break;
736
737     default:
738       return gpg_error (GPG_ERR_INV_VALUE);
739     }
740
741 #if USE_DESCRIPTOR_PASSING
742   dir = iocb_data->dir;
743   /* We try to short-cut the communication by giving GPGSM direct
744      access to the file descriptor, rather than using a pipe.  */
745   iocb_data->server_fd = _gpgme_data_get_fd (iocb_data->data);
746   if (iocb_data->server_fd < 0)
747     {
748       int fds[2];
749
750       if (_gpgme_io_pipe (fds, dir) < 0)
751         return gpg_error_from_syserror ();
752
753       iocb_data->fd = dir ? fds[0] : fds[1];
754       iocb_data->server_fd = dir ? fds[1] : fds[0];
755
756       if (_gpgme_io_set_close_notify (iocb_data->fd,
757                                       close_notify_handler, gpgsm))
758         {
759           err = gpg_error (GPG_ERR_GENERAL);
760           goto leave_set_fd;
761         }
762     }
763
764   err = assuan_sendfd (gpgsm->assuan_ctx, iocb_data->server_fd);
765   if (err)
766     goto leave_set_fd;
767
768   _gpgme_io_close (iocb_data->server_fd);
769   iocb_data->server_fd = -1;
770
771   if (opt)
772     snprintf (line, COMMANDLINELEN, "%s FD %s", which, opt);
773   else
774     snprintf (line, COMMANDLINELEN, "%s FD", which);
775 #else
776   if (opt)
777     snprintf (line, COMMANDLINELEN, "%s FD=%s %s",
778               which, iocb_data->server_fd_str, opt);
779   else
780     snprintf (line, COMMANDLINELEN, "%s FD=%s",
781               which, iocb_data->server_fd_str);
782 #endif
783
784   err = gpgsm_assuan_simple_command (gpgsm, line, NULL, NULL);
785
786 #if USE_DESCRIPTOR_PASSING
787  leave_set_fd:
788   if (err)
789     {
790       _gpgme_io_close (iocb_data->fd);
791       iocb_data->fd = -1;
792       if (iocb_data->server_fd != -1)
793         {
794           _gpgme_io_close (iocb_data->server_fd);
795           iocb_data->server_fd = -1;
796         }
797     }
798 #endif
799
800   return err;
801 }
802
803
804 static const char *
805 map_data_enc (gpgme_data_t d)
806 {
807   switch (gpgme_data_get_encoding (d))
808     {
809     case GPGME_DATA_ENCODING_NONE:
810       break;
811     case GPGME_DATA_ENCODING_BINARY:
812       return "--binary";
813     case GPGME_DATA_ENCODING_BASE64:
814       return "--base64";
815     case GPGME_DATA_ENCODING_ARMOR:
816       return "--armor";
817     default:
818       break;
819     }
820   return NULL;
821 }
822
823
824 static gpgme_error_t
825 status_handler (void *opaque, int fd)
826 {
827   struct io_cb_data *data = (struct io_cb_data *) opaque;
828   engine_gpgsm_t gpgsm = (engine_gpgsm_t) data->handler_value;
829   gpgme_error_t err = 0;
830   char *line;
831   size_t linelen;
832
833   do
834     {
835       err = assuan_read_line (gpgsm->assuan_ctx, &line, &linelen);
836       if (err)
837         {
838           /* Try our best to terminate the connection friendly.  */
839           /*      assuan_write_line (gpgsm->assuan_ctx, "BYE"); */
840           TRACE3 (DEBUG_CTX, "gpgme:status_handler", gpgsm,
841                   "fd 0x%x: error from assuan (%d) getting status line : %s",
842                   fd, err, gpg_strerror (err));
843         }
844       else if (linelen >= 3
845                && line[0] == 'E' && line[1] == 'R' && line[2] == 'R'
846                && (line[3] == '\0' || line[3] == ' '))
847         {
848           if (line[3] == ' ')
849             err = atoi (&line[4]);
850           if (! err)
851             err = gpg_error (GPG_ERR_GENERAL);
852           TRACE2 (DEBUG_CTX, "gpgme:status_handler", gpgsm,
853                   "fd 0x%x: ERR line - mapped to: %s",
854                   fd, err ? gpg_strerror (err) : "ok");
855           /* Try our best to terminate the connection friendly.  */
856           /*      assuan_write_line (gpgsm->assuan_ctx, "BYE"); */
857         }
858       else if (linelen >= 2
859                && line[0] == 'O' && line[1] == 'K'
860                && (line[2] == '\0' || line[2] == ' '))
861         {
862           if (gpgsm->status.fnc)
863             {
864               char emptystring[1] = {0};
865               err = gpgsm->status.fnc (gpgsm->status.fnc_value,
866                                        GPGME_STATUS_EOF, emptystring);
867               if (gpg_err_code (err) == GPG_ERR_FALSE)
868                 err = 0; /* Drop special error code.  */
869             }
870
871           if (!err && gpgsm->colon.fnc && gpgsm->colon.any)
872             {
873               /* We must tell a colon function about the EOF. We do
874                  this only when we have seen any data lines.  Note
875                  that this inlined use of colon data lines will
876                  eventually be changed into using a regular data
877                  channel. */
878               gpgsm->colon.any = 0;
879               err = gpgsm->colon.fnc (gpgsm->colon.fnc_value, NULL);
880             }
881           TRACE2 (DEBUG_CTX, "gpgme:status_handler", gpgsm,
882                   "fd 0x%x: OK line - final status: %s",
883                   fd, err ? gpg_strerror (err) : "ok");
884           _gpgme_io_close (gpgsm->status_cb.fd);
885           return err;
886         }
887       else if (linelen > 2
888                && line[0] == 'D' && line[1] == ' '
889                && gpgsm->colon.fnc)
890         {
891           /* We are using the colon handler even for plain inline data
892              - strange name for that function but for historic reasons
893              we keep it.  */
894           /* FIXME We can't use this for binary data because we
895              assume this is a string.  For the current usage of colon
896              output it is correct.  */
897           char *src = line + 2;
898           char *end = line + linelen;
899           char *dst;
900           char **aline = &gpgsm->colon.attic.line;
901           int *alinelen = &gpgsm->colon.attic.linelen;
902
903           if (gpgsm->colon.attic.linesize < *alinelen + linelen + 1)
904             {
905               char *newline = realloc (*aline, *alinelen + linelen + 1);
906               if (!newline)
907                 err = gpg_error_from_syserror ();
908               else
909                 {
910                   *aline = newline;
911                   gpgsm->colon.attic.linesize = *alinelen + linelen + 1;
912                 }
913             }
914           if (!err)
915             {
916               dst = *aline + *alinelen;
917
918               while (!err && src < end)
919                 {
920                   if (*src == '%' && src + 2 < end)
921                     {
922                       /* Handle escaped characters.  */
923                       ++src;
924                       *dst = _gpgme_hextobyte (src);
925                       (*alinelen)++;
926                       src += 2;
927                     }
928                   else
929                     {
930                       *dst = *src++;
931                       (*alinelen)++;
932                     }
933
934                   if (*dst == '\n')
935                     {
936                       /* Terminate the pending line, pass it to the colon
937                          handler and reset it.  */
938
939                       gpgsm->colon.any = 1;
940                       if (*alinelen > 1 && *(dst - 1) == '\r')
941                         dst--;
942                       *dst = '\0';
943
944                       /* FIXME How should we handle the return code?  */
945                       err = gpgsm->colon.fnc (gpgsm->colon.fnc_value, *aline);
946                       if (!err)
947                         {
948                           dst = *aline;
949                           *alinelen = 0;
950                         }
951                     }
952                   else
953                     dst++;
954                 }
955             }
956           TRACE2 (DEBUG_CTX, "gpgme:status_handler", gpgsm,
957                   "fd 0x%x: D line; final status: %s",
958                   fd, err? gpg_strerror (err):"ok");
959         }
960       else if (linelen > 2
961                && line[0] == 'D' && line[1] == ' '
962                && gpgsm->inline_data)
963         {
964           char *src = line + 2;
965           char *end = line + linelen;
966           char *dst = src;
967           gpgme_ssize_t nwritten;
968
969           linelen = 0;
970           while (src < end)
971             {
972               if (*src == '%' && src + 2 < end)
973                 {
974                   /* Handle escaped characters.  */
975                   ++src;
976                   *dst++ = _gpgme_hextobyte (src);
977                   src += 2;
978                 }
979               else
980                 *dst++ = *src++;
981
982               linelen++;
983             }
984
985           src = line + 2;
986           while (linelen > 0)
987             {
988               nwritten = gpgme_data_write (gpgsm->inline_data, src, linelen);
989               if (!nwritten || (nwritten < 0 && errno != EINTR)
990                   || nwritten > linelen)
991                 {
992                   err = gpg_error_from_syserror ();
993                   break;
994                 }
995               src += nwritten;
996               linelen -= nwritten;
997             }
998
999           TRACE2 (DEBUG_CTX, "gpgme:status_handler", gpgsm,
1000                   "fd 0x%x: D inlinedata; final status: %s",
1001                   fd, err? gpg_strerror (err):"ok");
1002         }
1003       else if (linelen > 2
1004                && line[0] == 'S' && line[1] == ' ')
1005         {
1006           char *rest;
1007           gpgme_status_code_t r;
1008
1009           rest = strchr (line + 2, ' ');
1010           if (!rest)
1011             rest = line + linelen; /* set to an empty string */
1012           else
1013             *(rest++) = 0;
1014
1015           r = _gpgme_parse_status (line + 2);
1016
1017           if (r >= 0)
1018             {
1019               if (gpgsm->status.fnc)
1020                 {
1021                   err = gpgsm->status.fnc (gpgsm->status.fnc_value, r, rest);
1022                   if (gpg_err_code (err) == GPG_ERR_FALSE)
1023                     err = 0; /* Drop special error code.  */
1024                 }
1025             }
1026           else
1027             fprintf (stderr, "[UNKNOWN STATUS]%s %s", line + 2, rest);
1028           TRACE3 (DEBUG_CTX, "gpgme:status_handler", gpgsm,
1029                   "fd 0x%x: S line (%s) - final status: %s",
1030                   fd, line+2, err? gpg_strerror (err):"ok");
1031         }
1032       else if (linelen >= 7
1033                && line[0] == 'I' && line[1] == 'N' && line[2] == 'Q'
1034                && line[3] == 'U' && line[4] == 'I' && line[5] == 'R'
1035                && line[6] == 'E'
1036                && (line[7] == '\0' || line[7] == ' '))
1037         {
1038           char *keyword = line+7;
1039
1040           while (*keyword == ' ')
1041             keyword++;;
1042           default_inq_cb (gpgsm, keyword);
1043           assuan_write_line (gpgsm->assuan_ctx, "END");
1044         }
1045
1046     }
1047   while (!err && assuan_pending_line (gpgsm->assuan_ctx));
1048
1049   return err;
1050 }
1051
1052
1053 static gpgme_error_t
1054 add_io_cb (engine_gpgsm_t gpgsm, iocb_data_t *iocbd, gpgme_io_cb_t handler)
1055 {
1056   gpgme_error_t err;
1057
1058   TRACE_BEG2 (DEBUG_ENGINE, "engine-gpgsm:add_io_cb", gpgsm,
1059               "fd %d, dir %d", iocbd->fd, iocbd->dir);
1060   err = (*gpgsm->io_cbs.add) (gpgsm->io_cbs.add_priv,
1061                               iocbd->fd, iocbd->dir,
1062                               handler, iocbd->data, &iocbd->tag);
1063   if (err)
1064     return TRACE_ERR (err);
1065   if (!iocbd->dir)
1066     /* FIXME Kludge around poll() problem.  */
1067     err = _gpgme_io_set_nonblocking (iocbd->fd);
1068   return TRACE_ERR (err);
1069 }
1070
1071
1072 static gpgme_error_t
1073 start (engine_gpgsm_t gpgsm, const char *command)
1074 {
1075   gpgme_error_t err;
1076   assuan_fd_t afdlist[5];
1077   int fdlist[5];
1078   int nfds;
1079   int i;
1080
1081   if (*gpgsm->request_origin)
1082     {
1083       char *cmd;
1084
1085       cmd = _gpgme_strconcat ("OPTION request-origin=",
1086                               gpgsm->request_origin, NULL);
1087       if (!cmd)
1088         return gpg_error_from_syserror ();
1089       err = gpgsm_assuan_simple_command (gpgsm, cmd, NULL, NULL);
1090       free (cmd);
1091       if (err && gpg_err_code (err) != GPG_ERR_UNKNOWN_OPTION)
1092         return err;
1093     }
1094
1095   /* We need to know the fd used by assuan for reads.  We do this by
1096      using the assumption that the first returned fd from
1097      assuan_get_active_fds() is always this one.  */
1098   nfds = assuan_get_active_fds (gpgsm->assuan_ctx, 0 /* read fds */,
1099                                 afdlist, DIM (afdlist));
1100   if (nfds < 1)
1101     return gpg_error (GPG_ERR_GENERAL); /* FIXME */
1102   /* For now... */
1103   for (i = 0; i < nfds; i++)
1104     fdlist[i] = (int) afdlist[i];
1105
1106   /* We "duplicate" the file descriptor, so we can close it here (we
1107      can't close fdlist[0], as that is closed by libassuan, and
1108      closing it here might cause libassuan to close some unrelated FD
1109      later).  Alternatively, we could special case status_fd and
1110      register/unregister it manually as needed, but this increases
1111      code duplication and is more complicated as we can not use the
1112      close notifications etc.  A third alternative would be to let
1113      Assuan know that we closed the FD, but that complicates the
1114      Assuan interface.  */
1115
1116   gpgsm->status_cb.fd = _gpgme_io_dup (fdlist[0]);
1117   if (gpgsm->status_cb.fd < 0)
1118     return gpg_error_from_syserror ();
1119
1120   if (_gpgme_io_set_close_notify (gpgsm->status_cb.fd,
1121                                   close_notify_handler, gpgsm))
1122     {
1123       _gpgme_io_close (gpgsm->status_cb.fd);
1124       gpgsm->status_cb.fd = -1;
1125       return gpg_error (GPG_ERR_GENERAL);
1126     }
1127
1128   err = add_io_cb (gpgsm, &gpgsm->status_cb, status_handler);
1129   if (!err && gpgsm->input_cb.fd != -1)
1130     err = add_io_cb (gpgsm, &gpgsm->input_cb, _gpgme_data_outbound_handler);
1131   if (!err && gpgsm->output_cb.fd != -1)
1132     err = add_io_cb (gpgsm, &gpgsm->output_cb, _gpgme_data_inbound_handler);
1133   if (!err && gpgsm->message_cb.fd != -1)
1134     err = add_io_cb (gpgsm, &gpgsm->message_cb, _gpgme_data_outbound_handler);
1135
1136   if (!err)
1137     err = assuan_write_line (gpgsm->assuan_ctx, command);
1138
1139   if (!err)
1140     gpgsm_io_event (gpgsm, GPGME_EVENT_START, NULL);
1141
1142   return err;
1143 }
1144
1145
1146 #if USE_DESCRIPTOR_PASSING
1147 static gpgme_error_t
1148 gpgsm_reset (void *engine)
1149 {
1150   engine_gpgsm_t gpgsm = engine;
1151
1152   /* IF we have an active connection we must send a reset because we
1153      need to reset the list of signers.  Note that RESET does not
1154      reset OPTION commands. */
1155   return (gpgsm->assuan_ctx
1156           ? gpgsm_assuan_simple_command (gpgsm, "RESET", NULL, NULL)
1157           : 0);
1158 }
1159 #endif
1160
1161
1162
1163 static gpgme_error_t
1164 gpgsm_decrypt (void *engine,
1165                gpgme_decrypt_flags_t flags,
1166                gpgme_data_t ciph, gpgme_data_t plain,
1167                int export_session_key, const char *override_session_key,
1168                int auto_key_retrieve)
1169 {
1170   engine_gpgsm_t gpgsm = engine;
1171   gpgme_error_t err;
1172
1173   (void)flags;
1174
1175   /* gpgsm is not capable of exporting session keys right now, so we
1176    * will ignore this if requested. */
1177   (void)export_session_key;
1178   (void)override_session_key;
1179
1180   /* --auto-key-retrieve is also not supported.  */
1181   (void)auto_key_retrieve;
1182
1183   if (!gpgsm)
1184     return gpg_error (GPG_ERR_INV_VALUE);
1185
1186   gpgsm->input_cb.data = ciph;
1187   err = gpgsm_set_fd (gpgsm, INPUT_FD, map_data_enc (gpgsm->input_cb.data));
1188   if (err)
1189     return gpg_error (GPG_ERR_GENERAL); /* FIXME */
1190   gpgsm->output_cb.data = plain;
1191   err = gpgsm_set_fd (gpgsm, OUTPUT_FD, 0);
1192   if (err)
1193     return gpg_error (GPG_ERR_GENERAL); /* FIXME */
1194   gpgsm_clear_fd (gpgsm, MESSAGE_FD);
1195   gpgsm->inline_data = NULL;
1196
1197   err = start (engine, "DECRYPT");
1198   return err;
1199 }
1200
1201
1202 static gpgme_error_t
1203 gpgsm_delete (void *engine, gpgme_key_t key, unsigned int flags)
1204 {
1205   engine_gpgsm_t gpgsm = engine;
1206   gpgme_error_t err;
1207   char *fpr = key->subkeys ? key->subkeys->fpr : NULL;
1208   char *linep = fpr;
1209   char *line;
1210   int length = 8;       /* "DELKEYS " */
1211
1212   (void)flags;
1213
1214   if (!fpr)
1215     return gpg_error (GPG_ERR_INV_VALUE);
1216
1217   while (*linep)
1218     {
1219       length++;
1220       if (*linep == '%' || *linep == ' ' || *linep == '+')
1221         length += 2;
1222       linep++;
1223     }
1224   length++;
1225
1226   line = malloc (length);
1227   if (!line)
1228     return gpg_error_from_syserror ();
1229
1230   strcpy (line, "DELKEYS ");
1231   linep = &line[8];
1232
1233   while (*fpr)
1234     {
1235       switch (*fpr)
1236         {
1237         case '%':
1238           *(linep++) = '%';
1239           *(linep++) = '2';
1240           *(linep++) = '5';
1241           break;
1242         case ' ':
1243           *(linep++) = '%';
1244           *(linep++) = '2';
1245           *(linep++) = '0';
1246           break;
1247         case '+':
1248           *(linep++) = '%';
1249           *(linep++) = '2';
1250           *(linep++) = 'B';
1251           break;
1252         default:
1253           *(linep++) = *fpr;
1254           break;
1255         }
1256       fpr++;
1257     }
1258   *linep = '\0';
1259
1260   gpgsm_clear_fd (gpgsm, OUTPUT_FD);
1261   gpgsm_clear_fd (gpgsm, INPUT_FD);
1262   gpgsm_clear_fd (gpgsm, MESSAGE_FD);
1263   gpgsm->inline_data = NULL;
1264
1265   err = start (gpgsm, line);
1266   free (line);
1267
1268   return err;
1269 }
1270
1271
1272 static gpgme_error_t
1273 set_recipients (engine_gpgsm_t gpgsm, gpgme_key_t recp[])
1274 {
1275   gpgme_error_t err = 0;
1276   char *line;
1277   int linelen;
1278   int invalid_recipients = 0;
1279   int i;
1280
1281   linelen = 10 + 40 + 1;        /* "RECIPIENT " + guess + '\0'.  */
1282   line = malloc (10 + 40 + 1);
1283   if (!line)
1284     return gpg_error_from_syserror ();
1285   strcpy (line, "RECIPIENT ");
1286   for (i =0; !err && recp[i]; i++)
1287     {
1288       char *fpr;
1289       int newlen;
1290
1291       if (!recp[i]->subkeys || !recp[i]->subkeys->fpr)
1292         {
1293           invalid_recipients++;
1294           continue;
1295         }
1296       fpr = recp[i]->subkeys->fpr;
1297
1298       newlen = 11 + strlen (fpr);
1299       if (linelen < newlen)
1300         {
1301           char *newline = realloc (line, newlen);
1302           if (! newline)
1303             {
1304               int saved_err = gpg_error_from_syserror ();
1305               free (line);
1306               return saved_err;
1307             }
1308           line = newline;
1309           linelen = newlen;
1310         }
1311       strcpy (&line[10], fpr);
1312
1313       err = gpgsm_assuan_simple_command (gpgsm, line, gpgsm->status.fnc,
1314                                          gpgsm->status.fnc_value);
1315       /* FIXME: This requires more work.  */
1316       if (gpg_err_code (err) == GPG_ERR_NO_PUBKEY)
1317         invalid_recipients++;
1318       else if (err)
1319         {
1320           free (line);
1321           return err;
1322         }
1323     }
1324   free (line);
1325   return gpg_error (invalid_recipients
1326                     ? GPG_ERR_UNUSABLE_PUBKEY : GPG_ERR_NO_ERROR);
1327 }
1328
1329
1330 static gpgme_error_t
1331 gpgsm_encrypt (void *engine, gpgme_key_t recp[], gpgme_encrypt_flags_t flags,
1332                gpgme_data_t plain, gpgme_data_t ciph, int use_armor)
1333 {
1334   engine_gpgsm_t gpgsm = engine;
1335   gpgme_error_t err;
1336
1337   if (!gpgsm)
1338     return gpg_error (GPG_ERR_INV_VALUE);
1339   if (!recp)
1340     return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1341
1342   if (flags & GPGME_ENCRYPT_NO_ENCRYPT_TO)
1343     {
1344       err = gpgsm_assuan_simple_command (gpgsm,
1345                                          "OPTION no-encrypt-to", NULL, NULL);
1346       if (err)
1347         return err;
1348     }
1349
1350   gpgsm->input_cb.data = plain;
1351   err = gpgsm_set_fd (gpgsm, INPUT_FD, map_data_enc (gpgsm->input_cb.data));
1352   if (err)
1353     return err;
1354   gpgsm->output_cb.data = ciph;
1355   err = gpgsm_set_fd (gpgsm, OUTPUT_FD, use_armor ? "--armor"
1356                       : map_data_enc (gpgsm->output_cb.data));
1357   if (err)
1358     return err;
1359   gpgsm_clear_fd (gpgsm, MESSAGE_FD);
1360   gpgsm->inline_data = NULL;
1361
1362   err = set_recipients (gpgsm, recp);
1363
1364   if (!err)
1365     err = start (gpgsm, "ENCRYPT");
1366
1367   return err;
1368 }
1369
1370
1371 static gpgme_error_t
1372 gpgsm_export (void *engine, const char *pattern, gpgme_export_mode_t mode,
1373               gpgme_data_t keydata, int use_armor)
1374 {
1375   engine_gpgsm_t gpgsm = engine;
1376   gpgme_error_t err = 0;
1377   char *cmd;
1378
1379   if (!gpgsm)
1380     return gpg_error (GPG_ERR_INV_VALUE);
1381
1382   if (!pattern)
1383     pattern = "";
1384
1385   cmd = malloc (7 + 9 + 9 + strlen (pattern) + 1);
1386   if (!cmd)
1387     return gpg_error_from_syserror ();
1388
1389   strcpy (cmd, "EXPORT ");
1390   if ((mode & GPGME_EXPORT_MODE_SECRET))
1391     {
1392       strcat (cmd, "--secret ");
1393       if ((mode & GPGME_EXPORT_MODE_RAW))
1394         strcat (cmd, "--raw ");
1395       else if ((mode & GPGME_EXPORT_MODE_PKCS12))
1396         strcat (cmd, "--pkcs12 ");
1397     }
1398   strcat (cmd, pattern);
1399
1400   gpgsm->output_cb.data = keydata;
1401   err = gpgsm_set_fd (gpgsm, OUTPUT_FD, use_armor ? "--armor"
1402                       : map_data_enc (gpgsm->output_cb.data));
1403   if (err)
1404     return err;
1405   gpgsm_clear_fd (gpgsm, INPUT_FD);
1406   gpgsm_clear_fd (gpgsm, MESSAGE_FD);
1407   gpgsm->inline_data = NULL;
1408
1409   err = start (gpgsm, cmd);
1410   free (cmd);
1411   return err;
1412 }
1413
1414
1415 static gpgme_error_t
1416 gpgsm_export_ext (void *engine, const char *pattern[], gpgme_export_mode_t mode,
1417                   gpgme_data_t keydata, int use_armor)
1418 {
1419   engine_gpgsm_t gpgsm = engine;
1420   gpgme_error_t err = 0;
1421   char *line;
1422   /* Length is "EXPORT " + "--secret " + "--pkcs12 " + p + '\0'.  */
1423   int length = 7 + 9 + 9 + 1;
1424   char *linep;
1425
1426   if (!gpgsm)
1427     return gpg_error (GPG_ERR_INV_VALUE);
1428
1429   if (pattern && *pattern)
1430     {
1431       const char **pat = pattern;
1432
1433       while (*pat)
1434         {
1435           const char *patlet = *pat;
1436
1437           while (*patlet)
1438             {
1439               length++;
1440               if (*patlet == '%' || *patlet == ' ' || *patlet == '+')
1441                 length += 2;
1442               patlet++;
1443             }
1444           pat++;
1445           length++;
1446         }
1447     }
1448   line = malloc (length);
1449   if (!line)
1450     return gpg_error_from_syserror ();
1451
1452   strcpy (line, "EXPORT ");
1453   if ((mode & GPGME_EXPORT_MODE_SECRET))
1454     {
1455       strcat (line, "--secret ");
1456       if ((mode & GPGME_EXPORT_MODE_RAW))
1457         strcat (line, "--raw ");
1458       else if ((mode & GPGME_EXPORT_MODE_PKCS12))
1459         strcat (line, "--pkcs12 ");
1460     }
1461   linep = &line[strlen (line)];
1462
1463   if (pattern && *pattern)
1464     {
1465       while (*pattern)
1466         {
1467           const char *patlet = *pattern;
1468
1469           while (*patlet)
1470             {
1471               switch (*patlet)
1472                 {
1473                 case '%':
1474                   *(linep++) = '%';
1475                   *(linep++) = '2';
1476                   *(linep++) = '5';
1477                   break;
1478                 case ' ':
1479                   *(linep++) = '%';
1480                   *(linep++) = '2';
1481                   *(linep++) = '0';
1482                   break;
1483                 case '+':
1484                   *(linep++) = '%';
1485                   *(linep++) = '2';
1486                   *(linep++) = 'B';
1487                   break;
1488                 default:
1489                   *(linep++) = *patlet;
1490                   break;
1491                 }
1492               patlet++;
1493             }
1494           pattern++;
1495           if (*pattern)
1496             *linep++ = ' ';
1497         }
1498     }
1499   *linep = '\0';
1500
1501   gpgsm->output_cb.data = keydata;
1502   err = gpgsm_set_fd (gpgsm, OUTPUT_FD, use_armor ? "--armor"
1503                       : map_data_enc (gpgsm->output_cb.data));
1504   if (err)
1505     return err;
1506   gpgsm_clear_fd (gpgsm, INPUT_FD);
1507   gpgsm_clear_fd (gpgsm, MESSAGE_FD);
1508   gpgsm->inline_data = NULL;
1509
1510   err = start (gpgsm, line);
1511   free (line);
1512   return err;
1513 }
1514
1515
1516 static gpgme_error_t
1517 gpgsm_genkey (void *engine,
1518               const char *userid, const char *algo,
1519               unsigned long reserved, unsigned long expires,
1520               gpgme_key_t key, unsigned int flags,
1521               gpgme_data_t help_data, unsigned int extraflags,
1522               gpgme_data_t pubkey, gpgme_data_t seckey)
1523 {
1524   engine_gpgsm_t gpgsm = engine;
1525   gpgme_error_t err;
1526
1527   (void)reserved;
1528
1529   if (!gpgsm)
1530     return gpg_error (GPG_ERR_INV_VALUE);
1531
1532   if (help_data)
1533     {
1534       if (!pubkey || seckey)
1535         return gpg_error (GPG_ERR_INV_VALUE);
1536
1537       gpgsm->input_cb.data = help_data;
1538       err = gpgsm_set_fd (gpgsm, INPUT_FD, map_data_enc (gpgsm->input_cb.data));
1539       if (err)
1540         return err;
1541       gpgsm->output_cb.data = pubkey;
1542       err = gpgsm_set_fd (gpgsm, OUTPUT_FD,
1543                           (extraflags & GENKEY_EXTRAFLAG_ARMOR)? "--armor"
1544                           : map_data_enc (gpgsm->output_cb.data));
1545       if (err)
1546         return err;
1547       gpgsm_clear_fd (gpgsm, MESSAGE_FD);
1548       gpgsm->inline_data = NULL;
1549
1550       err = start (gpgsm, "GENKEY");
1551       return err;
1552     }
1553
1554   (void)userid;
1555   (void)algo;
1556   (void)expires;
1557   (void)key;
1558   (void)flags;
1559
1560   /* The new interface has not yet been implemented,  */
1561   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1562 }
1563
1564
1565 static gpgme_error_t
1566 gpgsm_import (void *engine, gpgme_data_t keydata, gpgme_key_t *keyarray)
1567 {
1568   engine_gpgsm_t gpgsm = engine;
1569   gpgme_error_t err;
1570   gpgme_data_encoding_t dataenc;
1571   int idx;
1572
1573   if (!gpgsm)
1574     return gpg_error (GPG_ERR_INV_VALUE);
1575
1576   if (keydata && keyarray)
1577     return gpg_error (GPG_ERR_INV_VALUE); /* Only one is allowed.  */
1578
1579   dataenc = gpgme_data_get_encoding (keydata);
1580
1581   if (keyarray)
1582     {
1583       size_t buflen;
1584       char *buffer, *p;
1585
1586       /* Fist check whether the engine already features the
1587          --re-import option.  */
1588       err = gpgsm_assuan_simple_command
1589         (gpgsm, "GETINFO cmd_has_option IMPORT re-import", NULL, NULL);
1590       if (err)
1591         return gpg_error (GPG_ERR_NOT_SUPPORTED);
1592
1593       /* Create an internal data object with a list of all
1594          fingerprints.  The data object and its memory (to avoid an
1595          extra copy by gpgme_data_new_from_mem) are stored in two
1596          variables which are released by the close_notify_handler.  */
1597       for (idx=0, buflen=0; keyarray[idx]; idx++)
1598         {
1599           if (keyarray[idx]->protocol == GPGME_PROTOCOL_CMS
1600               && keyarray[idx]->subkeys
1601               && keyarray[idx]->subkeys->fpr
1602               && *keyarray[idx]->subkeys->fpr)
1603             buflen += strlen (keyarray[idx]->subkeys->fpr) + 1;
1604         }
1605       /* Allocate a bufer with extra space for the trailing Nul
1606          introduced by the use of stpcpy.  */
1607       buffer = malloc (buflen+1);
1608       if (!buffer)
1609         return gpg_error_from_syserror ();
1610       for (idx=0, p = buffer; keyarray[idx]; idx++)
1611         {
1612           if (keyarray[idx]->protocol == GPGME_PROTOCOL_CMS
1613               && keyarray[idx]->subkeys
1614               && keyarray[idx]->subkeys->fpr
1615               && *keyarray[idx]->subkeys->fpr)
1616             p = stpcpy (stpcpy (p, keyarray[idx]->subkeys->fpr), "\n");
1617         }
1618
1619       err = gpgme_data_new_from_mem (&gpgsm->input_helper_data,
1620                                      buffer, buflen, 0);
1621       if (err)
1622         {
1623           free (buffer);
1624           return err;
1625         }
1626       gpgsm->input_helper_memory = buffer;
1627
1628       gpgsm->input_cb.data = gpgsm->input_helper_data;
1629       err = gpgsm_set_fd (gpgsm, INPUT_FD, map_data_enc (gpgsm->input_cb.data));
1630       if (err)
1631         {
1632           gpgme_data_release (gpgsm->input_helper_data);
1633           gpgsm->input_helper_data = NULL;
1634           free (gpgsm->input_helper_memory);
1635           gpgsm->input_helper_memory = NULL;
1636           return err;
1637         }
1638       gpgsm_clear_fd (gpgsm, OUTPUT_FD);
1639       gpgsm_clear_fd (gpgsm, MESSAGE_FD);
1640       gpgsm->inline_data = NULL;
1641
1642       return start (gpgsm, "IMPORT --re-import");
1643     }
1644   else if (dataenc == GPGME_DATA_ENCODING_URL
1645            || dataenc == GPGME_DATA_ENCODING_URL0
1646            || dataenc == GPGME_DATA_ENCODING_URLESC)
1647     {
1648       return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1649     }
1650   else
1651     {
1652       gpgsm->input_cb.data = keydata;
1653       err = gpgsm_set_fd (gpgsm, INPUT_FD, map_data_enc (gpgsm->input_cb.data));
1654       if (err)
1655         return err;
1656       gpgsm_clear_fd (gpgsm, OUTPUT_FD);
1657       gpgsm_clear_fd (gpgsm, MESSAGE_FD);
1658       gpgsm->inline_data = NULL;
1659
1660       return start (gpgsm, "IMPORT");
1661     }
1662 }
1663
1664
1665 static gpgme_error_t
1666 gpgsm_keylist (void *engine, const char *pattern, int secret_only,
1667                gpgme_keylist_mode_t mode, int engine_flags)
1668 {
1669   engine_gpgsm_t gpgsm = engine;
1670   char *line;
1671   gpgme_error_t err;
1672   int list_mode = 0;
1673
1674   if (mode & GPGME_KEYLIST_MODE_LOCAL)
1675     list_mode |= 1;
1676   if (mode & GPGME_KEYLIST_MODE_EXTERN)
1677     list_mode |= 2;
1678
1679   if (!pattern)
1680     pattern = "";
1681
1682   /* Hack to make sure that the agent is started.  Only if the agent
1683      has been started an application may connect to the agent via
1684      GPGME_PROTOCOL_ASSUAN - for example to look for smartcards.  We
1685      do this only if a secret key listing has been requested.  In
1686      general this is not needed because a secret key listing starts
1687      the agent.  However on a fresh installation no public keys are
1688      available and thus there is no need for gpgsm to ask the agent
1689      whether a secret key exists for the public key.  */
1690   if (secret_only || (mode & GPGME_KEYLIST_MODE_WITH_SECRET))
1691     gpgsm_assuan_simple_command (gpgsm, "GETINFO agent-check", NULL, NULL);
1692
1693   /* Always send list-mode option because RESET does not reset it.  */
1694   if (gpgrt_asprintf (&line, "OPTION list-mode=%d", (list_mode & 3)) < 0)
1695     return gpg_error_from_syserror ();
1696   err = gpgsm_assuan_simple_command (gpgsm, line, NULL, NULL);
1697   gpgrt_free (line);
1698   if (err)
1699     return err;
1700
1701
1702   /* Always send key validation because RESET does not reset it.  */
1703
1704   /* Use the validation mode if requested.  We don't check for an error
1705      yet because this is a pretty fresh gpgsm features. */
1706   gpgsm_assuan_simple_command (gpgsm,
1707                                (mode & GPGME_KEYLIST_MODE_VALIDATE)?
1708                                "OPTION with-validation=1":
1709                                "OPTION with-validation=0" ,
1710                                NULL, NULL);
1711   /* Include the ephemeral keys if requested.  We don't check for an error
1712      yet because this is a pretty fresh gpgsm features. */
1713   gpgsm_assuan_simple_command (gpgsm,
1714                                (mode & GPGME_KEYLIST_MODE_EPHEMERAL)?
1715                                "OPTION with-ephemeral-keys=1":
1716                                "OPTION with-ephemeral-keys=0" ,
1717                                NULL, NULL);
1718   gpgsm_assuan_simple_command (gpgsm,
1719                                (mode & GPGME_KEYLIST_MODE_WITH_SECRET)?
1720                                "OPTION with-secret=1":
1721                                "OPTION with-secret=0" ,
1722                                NULL, NULL);
1723   gpgsm_assuan_simple_command (gpgsm,
1724                                (engine_flags & GPGME_ENGINE_FLAG_OFFLINE)?
1725                                "OPTION offline=1":
1726                                "OPTION offline=0" ,
1727                                NULL, NULL);
1728
1729
1730   /* Length is "LISTSECRETKEYS " + p + '\0'.  */
1731   line = malloc (15 + strlen (pattern) + 1);
1732   if (!line)
1733     return gpg_error_from_syserror ();
1734   if (secret_only)
1735     {
1736       strcpy (line, "LISTSECRETKEYS ");
1737       strcpy (&line[15], pattern);
1738     }
1739   else
1740     {
1741       strcpy (line, "LISTKEYS ");
1742       strcpy (&line[9], pattern);
1743     }
1744
1745   gpgsm_clear_fd (gpgsm, INPUT_FD);
1746   gpgsm_clear_fd (gpgsm, OUTPUT_FD);
1747   gpgsm_clear_fd (gpgsm, MESSAGE_FD);
1748   gpgsm->inline_data = NULL;
1749
1750   err = start (gpgsm, line);
1751   free (line);
1752   return err;
1753 }
1754
1755
1756 static gpgme_error_t
1757 gpgsm_keylist_ext (void *engine, const char *pattern[], int secret_only,
1758                    int reserved, gpgme_keylist_mode_t mode, int engine_flags)
1759 {
1760   engine_gpgsm_t gpgsm = engine;
1761   char *line;
1762   gpgme_error_t err;
1763   /* Length is "LISTSECRETKEYS " + p + '\0'.  */
1764   int length = 15 + 1;
1765   char *linep;
1766   int any_pattern = 0;
1767   int list_mode = 0;
1768
1769   if (reserved)
1770     return gpg_error (GPG_ERR_INV_VALUE);
1771
1772   if (mode & GPGME_KEYLIST_MODE_LOCAL)
1773     list_mode |= 1;
1774   if (mode & GPGME_KEYLIST_MODE_EXTERN)
1775     list_mode |= 2;
1776
1777   /* Always send list-mode option because RESET does not reset it.  */
1778   if (gpgrt_asprintf (&line, "OPTION list-mode=%d", (list_mode & 3)) < 0)
1779     return gpg_error_from_syserror ();
1780   err = gpgsm_assuan_simple_command (gpgsm, line, NULL, NULL);
1781   gpgrt_free (line);
1782   if (err)
1783     return err;
1784
1785   /* Always send key validation because RESET does not reset it.  */
1786   /* Use the validation mode if required.  We don't check for an error
1787      yet because this is a pretty fresh gpgsm features. */
1788   gpgsm_assuan_simple_command (gpgsm,
1789                                (mode & GPGME_KEYLIST_MODE_VALIDATE)?
1790                                "OPTION with-validation=1":
1791                                "OPTION with-validation=0" ,
1792                                NULL, NULL);
1793   gpgsm_assuan_simple_command (gpgsm,
1794                                (mode & GPGME_KEYLIST_MODE_WITH_SECRET)?
1795                                "OPTION with-secret=1":
1796                                "OPTION with-secret=0" ,
1797                                NULL, NULL);
1798   gpgsm_assuan_simple_command (gpgsm,
1799                                (engine_flags & GPGME_ENGINE_FLAG_OFFLINE)?
1800                                "OPTION offline=1":
1801                                "OPTION offline=0" ,
1802                                NULL, NULL);
1803
1804   if (pattern && *pattern)
1805     {
1806       const char **pat = pattern;
1807
1808       while (*pat)
1809         {
1810           const char *patlet = *pat;
1811
1812           while (*patlet)
1813             {
1814               length++;
1815               if (*patlet == '%' || *patlet == ' ' || *patlet == '+')
1816                 length += 2;
1817               patlet++;
1818             }
1819           pat++;
1820           length++;
1821         }
1822     }
1823   line = malloc (length);
1824   if (!line)
1825     return gpg_error_from_syserror ();
1826   if (secret_only)
1827     {
1828       strcpy (line, "LISTSECRETKEYS ");
1829       linep = &line[15];
1830     }
1831   else
1832     {
1833       strcpy (line, "LISTKEYS ");
1834       linep = &line[9];
1835     }
1836
1837   if (pattern && *pattern)
1838     {
1839       while (*pattern)
1840         {
1841           const char *patlet = *pattern;
1842
1843           while (*patlet)
1844             {
1845               switch (*patlet)
1846                 {
1847                 case '%':
1848                   *(linep++) = '%';
1849                   *(linep++) = '2';
1850                   *(linep++) = '5';
1851                   break;
1852                 case ' ':
1853                   *(linep++) = '%';
1854                   *(linep++) = '2';
1855                   *(linep++) = '0';
1856                   break;
1857                 case '+':
1858                   *(linep++) = '%';
1859                   *(linep++) = '2';
1860                   *(linep++) = 'B';
1861                   break;
1862                 default:
1863                   *(linep++) = *patlet;
1864                   break;
1865                 }
1866               patlet++;
1867             }
1868           any_pattern = 1;
1869           *linep++ = ' ';
1870           pattern++;
1871         }
1872     }
1873   if (any_pattern)
1874     linep--;
1875   *linep = '\0';
1876
1877   gpgsm_clear_fd (gpgsm, INPUT_FD);
1878   gpgsm_clear_fd (gpgsm, OUTPUT_FD);
1879   gpgsm_clear_fd (gpgsm, MESSAGE_FD);
1880   gpgsm->inline_data = NULL;
1881
1882   err = start (gpgsm, line);
1883   free (line);
1884   return err;
1885 }
1886
1887
1888 static gpgme_error_t
1889 gpgsm_sign (void *engine, gpgme_data_t in, gpgme_data_t out,
1890             gpgme_sig_mode_t mode, int use_armor, int use_textmode,
1891             int include_certs, gpgme_ctx_t ctx /* FIXME */)
1892 {
1893   engine_gpgsm_t gpgsm = engine;
1894   gpgme_error_t err;
1895   char *assuan_cmd;
1896   int i;
1897   gpgme_key_t key;
1898
1899   (void)use_textmode;
1900
1901   if (!gpgsm)
1902     return gpg_error (GPG_ERR_INV_VALUE);
1903
1904   /* FIXME: This does not work as RESET does not reset it so we can't
1905      revert back to default.  */
1906   if (include_certs != GPGME_INCLUDE_CERTS_DEFAULT)
1907     {
1908       /* FIXME: Make sure that if we run multiple operations, that we
1909          can reset any previously set value in case the default is
1910          requested.  */
1911
1912       if (gpgrt_asprintf (&assuan_cmd,
1913                           "OPTION include-certs %i", include_certs) < 0)
1914         return gpg_error_from_syserror ();
1915       err = gpgsm_assuan_simple_command (gpgsm, assuan_cmd, NULL, NULL);
1916       gpgrt_free (assuan_cmd);
1917       if (err)
1918         return err;
1919     }
1920
1921   for (i = 0; (key = gpgme_signers_enum (ctx, i)); i++)
1922     {
1923       const char *s = key->subkeys ? key->subkeys->fpr : NULL;
1924       if (s && strlen (s) < 80)
1925         {
1926           char buf[100];
1927
1928           strcpy (stpcpy (buf, "SIGNER "), s);
1929           err = gpgsm_assuan_simple_command (gpgsm, buf,
1930                                              gpgsm->status.fnc,
1931                                              gpgsm->status.fnc_value);
1932         }
1933       else
1934         err = gpg_error (GPG_ERR_INV_VALUE);
1935       gpgme_key_unref (key);
1936       if (err)
1937         return err;
1938     }
1939
1940   gpgsm->input_cb.data = in;
1941   err = gpgsm_set_fd (gpgsm, INPUT_FD, map_data_enc (gpgsm->input_cb.data));
1942   if (err)
1943     return err;
1944   gpgsm->output_cb.data = out;
1945   err = gpgsm_set_fd (gpgsm, OUTPUT_FD, use_armor ? "--armor"
1946                       : map_data_enc (gpgsm->output_cb.data));
1947   if (err)
1948     return err;
1949   gpgsm_clear_fd (gpgsm, MESSAGE_FD);
1950   gpgsm->inline_data = NULL;
1951
1952   err = start (gpgsm, mode == GPGME_SIG_MODE_DETACH
1953                ? "SIGN --detached" : "SIGN");
1954   return err;
1955 }
1956
1957
1958 static gpgme_error_t
1959 gpgsm_verify (void *engine, gpgme_data_t sig, gpgme_data_t signed_text,
1960               gpgme_data_t plaintext, gpgme_ctx_t ctx)
1961 {
1962   engine_gpgsm_t gpgsm = engine;
1963   gpgme_error_t err;
1964
1965   (void)ctx;
1966
1967   if (!gpgsm)
1968     return gpg_error (GPG_ERR_INV_VALUE);
1969
1970   gpgsm->input_cb.data = sig;
1971   err = gpgsm_set_fd (gpgsm, INPUT_FD, map_data_enc (gpgsm->input_cb.data));
1972   if (err)
1973     return err;
1974   if (plaintext)
1975     {
1976       /* Normal or cleartext signature.  */
1977       gpgsm->output_cb.data = plaintext;
1978       err = gpgsm_set_fd (gpgsm, OUTPUT_FD, 0);
1979       gpgsm_clear_fd (gpgsm, MESSAGE_FD);
1980     }
1981   else
1982     {
1983       /* Detached signature.  */
1984       gpgsm->message_cb.data = signed_text;
1985       err = gpgsm_set_fd (gpgsm, MESSAGE_FD, 0);
1986       gpgsm_clear_fd (gpgsm, OUTPUT_FD);
1987     }
1988   gpgsm->inline_data = NULL;
1989
1990   if (!err)
1991     err = start (gpgsm, "VERIFY");
1992
1993   return err;
1994 }
1995
1996
1997 /* Send the GETAUDITLOG command.  The result is saved to a gpgme data
1998    object.  */
1999 static gpgme_error_t
2000 gpgsm_getauditlog (void *engine, gpgme_data_t output, unsigned int flags)
2001 {
2002   engine_gpgsm_t gpgsm = engine;
2003   gpgme_error_t err = 0;
2004
2005   if (!gpgsm || !output)
2006     return gpg_error (GPG_ERR_INV_VALUE);
2007
2008 #if USE_DESCRIPTOR_PASSING
2009   gpgsm->output_cb.data = output;
2010   err = gpgsm_set_fd (gpgsm, OUTPUT_FD, 0);
2011   if (err)
2012     return err;
2013
2014   gpgsm_clear_fd (gpgsm, INPUT_FD);
2015   gpgsm_clear_fd (gpgsm, MESSAGE_FD);
2016   gpgsm->inline_data = NULL;
2017 # define CMD  "GETAUDITLOG"
2018 #else
2019   gpgsm_clear_fd (gpgsm, OUTPUT_FD);
2020   gpgsm_clear_fd (gpgsm, INPUT_FD);
2021   gpgsm_clear_fd (gpgsm, MESSAGE_FD);
2022   gpgsm->inline_data = output;
2023 # define CMD  "GETAUDITLOG --data"
2024 #endif
2025
2026   err = start (gpgsm, (flags & GPGME_AUDITLOG_HTML)? CMD " --html" : CMD);
2027
2028   return err;
2029 }
2030
2031
2032 /* This sets a status callback for monitoring status lines before they
2033  * are passed to a caller set handler.  */
2034 static void
2035 gpgsm_set_status_cb (void *engine, gpgme_status_cb_t cb, void *cb_value)
2036 {
2037   engine_gpgsm_t gpgsm = engine;
2038
2039   gpgsm->status.mon_cb = cb;
2040   gpgsm->status.mon_cb_value = cb_value;
2041 }
2042
2043
2044 static void
2045 gpgsm_set_status_handler (void *engine, engine_status_handler_t fnc,
2046                           void *fnc_value)
2047 {
2048   engine_gpgsm_t gpgsm = engine;
2049
2050   gpgsm->status.fnc = fnc;
2051   gpgsm->status.fnc_value = fnc_value;
2052 }
2053
2054
2055 static gpgme_error_t
2056 gpgsm_set_colon_line_handler (void *engine, engine_colon_line_handler_t fnc,
2057                               void *fnc_value)
2058 {
2059   engine_gpgsm_t gpgsm = engine;
2060
2061   gpgsm->colon.fnc = fnc;
2062   gpgsm->colon.fnc_value = fnc_value;
2063   gpgsm->colon.any = 0;
2064   return 0;
2065 }
2066
2067
2068 static void
2069 gpgsm_set_io_cbs (void *engine, gpgme_io_cbs_t io_cbs)
2070 {
2071   engine_gpgsm_t gpgsm = engine;
2072   gpgsm->io_cbs = *io_cbs;
2073 }
2074
2075
2076 static void
2077 gpgsm_io_event (void *engine, gpgme_event_io_t type, void *type_data)
2078 {
2079   engine_gpgsm_t gpgsm = engine;
2080
2081   TRACE3 (DEBUG_ENGINE, "gpgme:gpgsm_io_event", gpgsm,
2082           "event %p, type %d, type_data %p",
2083           gpgsm->io_cbs.event, type, type_data);
2084   if (gpgsm->io_cbs.event)
2085     (*gpgsm->io_cbs.event) (gpgsm->io_cbs.event_priv, type, type_data);
2086 }
2087
2088
2089 static gpgme_error_t
2090 gpgsm_passwd (void *engine, gpgme_key_t key, unsigned int flags)
2091 {
2092   engine_gpgsm_t gpgsm = engine;
2093   gpgme_error_t err;
2094   char *line;
2095
2096   (void)flags;
2097
2098   if (!key || !key->subkeys || !key->subkeys->fpr)
2099     return gpg_error (GPG_ERR_INV_CERT_OBJ);
2100
2101   if (gpgrt_asprintf (&line, "PASSWD -- %s", key->subkeys->fpr) < 0)
2102     return gpg_error_from_syserror ();
2103
2104   gpgsm_clear_fd (gpgsm, OUTPUT_FD);
2105   gpgsm_clear_fd (gpgsm, INPUT_FD);
2106   gpgsm_clear_fd (gpgsm, MESSAGE_FD);
2107   gpgsm->inline_data = NULL;
2108
2109   err = start (gpgsm, line);
2110   gpgrt_free (line);
2111
2112   return err;
2113 }
2114
2115
2116
2117 struct engine_ops _gpgme_engine_ops_gpgsm =
2118   {
2119     /* Static functions.  */
2120     _gpgme_get_default_gpgsm_name,
2121     NULL,
2122     gpgsm_get_version,
2123     gpgsm_get_req_version,
2124     gpgsm_new,
2125
2126     /* Member functions.  */
2127     gpgsm_release,
2128 #if USE_DESCRIPTOR_PASSING
2129     gpgsm_reset,
2130 #else
2131     NULL,                       /* reset */
2132 #endif
2133     gpgsm_set_status_cb,
2134     gpgsm_set_status_handler,
2135     NULL,               /* set_command_handler */
2136     gpgsm_set_colon_line_handler,
2137     gpgsm_set_locale,
2138     NULL,               /* set_protocol */
2139     gpgsm_set_engine_flags,
2140     gpgsm_decrypt,
2141     gpgsm_delete,       /* decrypt_verify */
2142     NULL,               /* edit */
2143     gpgsm_encrypt,
2144     NULL,               /* encrypt_sign */
2145     gpgsm_export,
2146     gpgsm_export_ext,
2147     gpgsm_genkey,
2148     gpgsm_import,
2149     gpgsm_keylist,
2150     gpgsm_keylist_ext,
2151     NULL,               /* keylist_data */
2152     NULL,               /* keysign */
2153     NULL,               /* tofu_policy */
2154     gpgsm_sign,
2155     NULL,               /* trustlist */
2156     gpgsm_verify,
2157     gpgsm_getauditlog,
2158     NULL,               /* opassuan_transact */
2159     NULL,               /* conf_load */
2160     NULL,               /* conf_save */
2161     NULL,               /* conf_dir */
2162     NULL,               /* query_swdb */
2163     gpgsm_set_io_cbs,
2164     gpgsm_io_event,
2165     gpgsm_cancel,
2166     NULL,               /* cancel_op */
2167     gpgsm_passwd,
2168     NULL,               /* set_pinentry_mode */
2169     NULL                /* opspawn */
2170   };