Require Libassuan 2.0.3
[gnupg.git] / agent / call-scd.c
1 /* call-scd.c - fork of the scdaemon to do SC operations
2  * Copyright (C) 2001, 2002, 2005, 2007, 2010,
3  *               2011 Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <errno.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <ctype.h>
27 #include <assert.h>
28 #include <unistd.h>
29 #ifdef HAVE_SIGNAL_H
30 # include <signal.h>
31 #endif
32 #include <sys/stat.h>
33 #include <sys/types.h>
34 #ifndef HAVE_W32_SYSTEM
35 #include <sys/wait.h>
36 #endif
37 #include <pth.h>
38
39 #include "agent.h"
40 #include <assuan.h>
41
42 #ifdef _POSIX_OPEN_MAX
43 #define MAX_OPEN_FDS _POSIX_OPEN_MAX
44 #else
45 #define MAX_OPEN_FDS 20
46 #endif
47
48 /* Definition of module local data of the CTRL structure.  */
49 struct scd_local_s
50 {
51   /* We keep a list of all allocated context with a an achnor at
52      SCD_LOCAL_LIST (see below). */
53   struct scd_local_s *next_local;
54
55   /* We need to get back to the ctrl object actually referencing this
56      structure.  This is really an awkward way of enumerint the lcoal
57      contects.  A much cleaner way would be to keep a global list of
58      ctrl objects to enumerate them.  */
59   ctrl_t ctrl_backlink;
60
61   assuan_context_t ctx; /* NULL or session context for the SCdaemon
62                            used with this connection. */
63   int locked;           /* This flag is used to assert proper use of
64                            start_scd and unlock_scd. */
65
66 };
67
68
69 /* Callback parameter for learn card */
70 struct learn_parm_s
71 {
72   void (*kpinfo_cb)(void*, const char *);
73   void *kpinfo_cb_arg;
74   void (*certinfo_cb)(void*, const char *);
75   void *certinfo_cb_arg;
76   void (*sinfo_cb)(void*, const char *, size_t, const char *);
77   void *sinfo_cb_arg;
78 };
79
80 struct inq_needpin_s
81 {
82   assuan_context_t ctx;
83   int (*getpin_cb)(void *, const char *, char*, size_t);
84   void *getpin_cb_arg;
85   assuan_context_t passthru;  /* If not NULL, pass unknown inquiries
86                                  up to the caller.  */
87   int any_inq_seen;
88 };
89
90
91 /* To keep track of all active SCD contexts, we keep a linked list
92    anchored at this variable. */
93 static struct scd_local_s *scd_local_list;
94
95 /* A Mutex used inside the start_scd function. */
96 static pth_mutex_t start_scd_lock;
97
98 /* A malloced string with the name of the socket to be used for
99    additional connections.  May be NULL if not provided by
100    SCdaemon. */
101 static char *socket_name;
102
103 /* The context of the primary connection.  This is also used as a flag
104    to indicate whether the scdaemon has been started. */
105 static assuan_context_t primary_scd_ctx;
106
107 /* To allow reuse of the primary connection, the following flag is set
108    to true if the primary context has been reset and is not in use by
109    any connection. */
110 static int primary_scd_ctx_reusable;
111
112
113
114 /* Local prototypes.  */
115 static gpg_error_t membuf_data_cb (void *opaque,
116                                    const void *buffer, size_t length);
117
118
119
120 \f
121 /* This function must be called once to initialize this module.  This
122    has to be done before a second thread is spawned.  We can't do the
123    static initialization because Pth emulation code might not be able
124    to do a static init; in particular, it is not possible for W32. */
125 void
126 initialize_module_call_scd (void)
127 {
128   static int initialized;
129
130   if (!initialized)
131     {
132       if (!pth_mutex_init (&start_scd_lock))
133         log_fatal ("error initializing mutex: %s\n", strerror (errno));
134       initialized = 1;
135     }
136 }
137
138
139 static void
140 dump_mutex_state (pth_mutex_t *m)
141 {
142 #ifdef _W32_PTH_H
143   (void)m;
144   log_printf ("unknown under W32");
145 #else
146   if (!(m->mx_state & PTH_MUTEX_INITIALIZED))
147     log_printf ("not_initialized");
148   else if (!(m->mx_state & PTH_MUTEX_LOCKED))
149     log_printf ("not_locked");
150   else
151     log_printf ("locked tid=0x%lx count=%lu", (long)m->mx_owner, m->mx_count);
152 #endif
153 }
154
155
156 /* This function may be called to print infromation pertaining to the
157    current state of this module to the log. */
158 void
159 agent_scd_dump_state (void)
160 {
161   log_info ("agent_scd_dump_state: scd_lock=");
162   dump_mutex_state (&start_scd_lock);
163   log_printf ("\n");
164   log_info ("agent_scd_dump_state: primary_scd_ctx=%p pid=%ld reusable=%d\n",
165             primary_scd_ctx,
166             (long)assuan_get_pid (primary_scd_ctx),
167             primary_scd_ctx_reusable);
168   if (socket_name)
169     log_info ("agent_scd_dump_state: socket=`%s'\n", socket_name);
170 }
171
172
173 /* The unlock_scd function shall be called after having accessed the
174    SCD.  It is currently not very useful but gives an opportunity to
175    keep track of connections currently calling SCD.  Note that the
176    "lock" operation is done by the start_scd() function which must be
177    called and error checked before any SCD operation.  CTRL is the
178    usual connection context and RC the error code to be passed trhough
179    the function. */
180 static int
181 unlock_scd (ctrl_t ctrl, int rc)
182 {
183   if (ctrl->scd_local->locked != 1)
184     {
185       log_error ("unlock_scd: invalid lock count (%d)\n",
186                  ctrl->scd_local->locked);
187       if (!rc)
188         rc = gpg_error (GPG_ERR_INTERNAL);
189     }
190   ctrl->scd_local->locked = 0;
191   return rc;
192 }
193
194 /* To make sure we leave no secrets in our image after forking of the
195    scdaemon, we use this callback. */
196 static void
197 atfork_cb (void *opaque, int where)
198 {
199   (void)opaque;
200
201   if (!where)
202     gcry_control (GCRYCTL_TERM_SECMEM);
203 }
204
205
206 /* Fork off the SCdaemon if this has not already been done.  Lock the
207    daemon and make sure that a proper context has been setup in CTRL.
208    This function might also lock the daemon, which means that the
209    caller must call unlock_scd after this fucntion has returned
210    success and the actual Assuan transaction been done. */
211 static int
212 start_scd (ctrl_t ctrl)
213 {
214   gpg_error_t err = 0;
215   const char *pgmname;
216   assuan_context_t ctx = NULL;
217   const char *argv[3];
218   int no_close_list[3];
219   int i;
220   int rc;
221
222   if (opt.disable_scdaemon)
223     return gpg_error (GPG_ERR_NOT_SUPPORTED);
224
225   /* If this is the first call for this session, setup the local data
226      structure. */
227   if (!ctrl->scd_local)
228     {
229       ctrl->scd_local = xtrycalloc (1, sizeof *ctrl->scd_local);
230       if (!ctrl->scd_local)
231         return gpg_error_from_syserror ();
232       ctrl->scd_local->ctrl_backlink = ctrl;
233       ctrl->scd_local->next_local = scd_local_list;
234       scd_local_list = ctrl->scd_local;
235     }
236
237
238   /* Assert that the lock count is as expected. */
239   if (ctrl->scd_local->locked)
240     {
241       log_error ("start_scd: invalid lock count (%d)\n",
242                  ctrl->scd_local->locked);
243       return gpg_error (GPG_ERR_INTERNAL);
244     }
245   ctrl->scd_local->locked++;
246
247   if (ctrl->scd_local->ctx)
248     return 0; /* Okay, the context is fine.  We used to test for an
249                  alive context here and do an disconnect.  Now that we
250                  have a ticker function to check for it, it is easier
251                  not to check here but to let the connection run on an
252                  error instead. */
253
254
255   /* We need to protect the following code. */
256   if (!pth_mutex_acquire (&start_scd_lock, 0, NULL))
257     {
258       log_error ("failed to acquire the start_scd lock: %s\n",
259                  strerror (errno));
260       return gpg_error (GPG_ERR_INTERNAL);
261     }
262
263   /* Check whether the pipe server has already been started and in
264      this case either reuse a lingering pipe connection or establish a
265      new socket based one. */
266   if (primary_scd_ctx && primary_scd_ctx_reusable)
267     {
268       ctx = primary_scd_ctx;
269       primary_scd_ctx_reusable = 0;
270       if (opt.verbose)
271         log_info ("new connection to SCdaemon established (reusing)\n");
272       goto leave;
273     }
274
275   rc = assuan_new (&ctx);
276   if (rc)
277     {
278       log_error ("can't allocate assuan context: %s\n", gpg_strerror (rc));
279       err = rc;
280       goto leave;
281     }
282
283   if (socket_name)
284     {
285       rc = assuan_socket_connect (ctx, socket_name, 0, 0);
286       if (rc)
287         {
288           log_error ("can't connect to socket `%s': %s\n",
289                      socket_name, gpg_strerror (rc));
290           err = gpg_error (GPG_ERR_NO_SCDAEMON);
291           goto leave;
292         }
293
294       if (opt.verbose)
295         log_info ("new connection to SCdaemon established\n");
296       goto leave;
297     }
298
299   if (primary_scd_ctx)
300     {
301       log_info ("SCdaemon is running but won't accept further connections\n");
302       err = gpg_error (GPG_ERR_NO_SCDAEMON);
303       goto leave;
304     }
305
306   /* Nope, it has not been started.  Fire it up now. */
307   if (opt.verbose)
308     log_info ("no running SCdaemon - starting it\n");
309
310   if (fflush (NULL))
311     {
312 #ifndef HAVE_W32_SYSTEM
313       err = gpg_error_from_syserror ();
314 #endif
315       log_error ("error flushing pending output: %s\n", strerror (errno));
316       /* At least Windows XP fails here with EBADF.  According to docs
317          and Wine an fflush(NULL) is the same as _flushall.  However
318          the Wime implementaion does not flush stdin,stdout and stderr
319          - see above.  Lets try to ignore the error. */
320 #ifndef HAVE_W32_SYSTEM
321       goto leave;
322 #endif
323     }
324
325   if (!opt.scdaemon_program || !*opt.scdaemon_program)
326     opt.scdaemon_program = gnupg_module_name (GNUPG_MODULE_NAME_SCDAEMON);
327   if ( !(pgmname = strrchr (opt.scdaemon_program, '/')))
328     pgmname = opt.scdaemon_program;
329   else
330     pgmname++;
331
332   argv[0] = pgmname;
333   argv[1] = "--multi-server";
334   argv[2] = NULL;
335
336   i=0;
337   if (!opt.running_detached)
338     {
339       if (log_get_fd () != -1)
340         no_close_list[i++] = assuan_fd_from_posix_fd (log_get_fd ());
341       no_close_list[i++] = assuan_fd_from_posix_fd (fileno (stderr));
342     }
343   no_close_list[i] = -1;
344
345   /* Connect to the pinentry and perform initial handshaking.  Use
346      detached flag (128) so that under W32 SCDAEMON does not show up a
347      new window.  */
348   rc = assuan_pipe_connect (ctx, opt.scdaemon_program, argv,
349                             no_close_list, atfork_cb, NULL, 128);
350   if (rc)
351     {
352       log_error ("can't connect to the SCdaemon: %s\n",
353                  gpg_strerror (rc));
354       err = gpg_error (GPG_ERR_NO_SCDAEMON);
355       goto leave;
356     }
357
358   if (opt.verbose)
359     log_debug ("first connection to SCdaemon established\n");
360
361
362   /* Get the name of the additional socket opened by scdaemon. */
363   {
364     membuf_t data;
365     unsigned char *databuf;
366     size_t datalen;
367
368     xfree (socket_name);
369     socket_name = NULL;
370     init_membuf (&data, 256);
371     assuan_transact (ctx, "GETINFO socket_name",
372                      membuf_data_cb, &data, NULL, NULL, NULL, NULL);
373
374     databuf = get_membuf (&data, &datalen);
375     if (databuf && datalen)
376       {
377         socket_name = xtrymalloc (datalen + 1);
378         if (!socket_name)
379           log_error ("warning: can't store socket name: %s\n",
380                      strerror (errno));
381         else
382           {
383             memcpy (socket_name, databuf, datalen);
384             socket_name[datalen] = 0;
385             if (DBG_ASSUAN)
386               log_debug ("additional connections at `%s'\n", socket_name);
387           }
388       }
389     xfree (databuf);
390   }
391
392   /* Tell the scdaemon we want him to send us an event signal.  We
393      don't support this for W32CE.  */
394 #ifndef HAVE_W32CE_SYSTEM
395   if (opt.sigusr2_enabled)
396     {
397       char buf[100];
398
399 #ifdef HAVE_W32_SYSTEM
400       snprintf (buf, sizeof buf, "OPTION event-signal=%lx",
401                 (unsigned long)get_agent_scd_notify_event ());
402 #else
403       snprintf (buf, sizeof buf, "OPTION event-signal=%d", SIGUSR2);
404 #endif
405       assuan_transact (ctx, buf, NULL, NULL, NULL, NULL, NULL, NULL);
406     }
407 #endif /*HAVE_W32CE_SYSTEM*/
408
409   primary_scd_ctx = ctx;
410   primary_scd_ctx_reusable = 0;
411
412  leave:
413   if (err)
414     {
415       unlock_scd (ctrl, err);
416       if (ctx)
417         assuan_release (ctx);
418     }
419   else
420     {
421       ctrl->scd_local->ctx = ctx;
422     }
423   if (!pth_mutex_release (&start_scd_lock))
424     log_error ("failed to release the start_scd lock: %s\n", strerror (errno));
425   return err;
426 }
427
428
429 /* Check whether the SCdaemon is active.  This is a fast check without
430    any locking and might give a wrong result if another thread is about
431    to start the daemon or the daemon is about to be stopped.. */
432 int
433 agent_scd_check_running (void)
434 {
435   return !!primary_scd_ctx;
436 }
437
438
439 /* Check whether the Scdaemon is still alive and clean it up if not. */
440 void
441 agent_scd_check_aliveness (void)
442 {
443   pth_event_t evt;
444   pid_t pid;
445 #ifdef HAVE_W32_SYSTEM
446   DWORD rc;
447 #else
448   int rc;
449 #endif
450
451   if (!primary_scd_ctx)
452     return; /* No scdaemon running. */
453
454   /* This is not a critical function so we use a short timeout while
455      acquiring the lock.  */
456   evt = pth_event (PTH_EVENT_TIME, pth_timeout (1, 0));
457   if (!pth_mutex_acquire (&start_scd_lock, 0, evt))
458     {
459       if (pth_event_occurred (evt))
460         {
461           if (opt.verbose > 1)
462             log_info ("failed to acquire the start_scd lock while"
463                       " doing an aliveness check: %s\n", "timeout");
464         }
465       else
466         log_error ("failed to acquire the start_scd lock while"
467                    " doing an aliveness check: %s\n", strerror (errno));
468       pth_event_free (evt, PTH_FREE_THIS);
469       return;
470     }
471   pth_event_free (evt, PTH_FREE_THIS);
472
473   if (primary_scd_ctx)
474     {
475       pid = assuan_get_pid (primary_scd_ctx);
476 #ifdef HAVE_W32_SYSTEM
477       /* If we have a PID we disconnect if either GetExitProcessCode
478          fails or if ir returns the exit code of the scdaemon.  259 is
479          the error code for STILL_ALIVE.  */
480       if (pid != (pid_t)(void*)(-1) && pid
481           && (!GetExitCodeProcess ((HANDLE)pid, &rc) || rc != 259))
482 #else
483       if (pid != (pid_t)(-1) && pid
484           && ((rc=waitpid (pid, NULL, WNOHANG))==-1 || (rc == pid)) )
485 #endif
486         {
487           /* Okay, scdaemon died.  Disconnect the primary connection
488              now but take care that it won't do another wait. Also
489              cleanup all other connections and release their
490              resources.  The next use will start a new daemon then.
491              Due to the use of the START_SCD_LOCAL we are sure that
492              none of these context are actually in use. */
493           struct scd_local_s *sl;
494
495           assuan_set_flag (primary_scd_ctx, ASSUAN_NO_WAITPID, 1);
496           assuan_release (primary_scd_ctx);
497
498           for (sl=scd_local_list; sl; sl = sl->next_local)
499             {
500               if (sl->ctx)
501                 {
502                   if (sl->ctx != primary_scd_ctx)
503                     assuan_release (sl->ctx);
504                   sl->ctx = NULL;
505                 }
506             }
507
508           primary_scd_ctx = NULL;
509           primary_scd_ctx_reusable = 0;
510
511           xfree (socket_name);
512           socket_name = NULL;
513         }
514     }
515
516   if (!pth_mutex_release (&start_scd_lock))
517     log_error ("failed to release the start_scd lock while"
518                " doing the aliveness check: %s\n", strerror (errno));
519 }
520
521
522
523 /* Reset the SCD if it has been used.  Actually it is not a reset but
524    a cleanup of resources used by the current connection. */
525 int
526 agent_reset_scd (ctrl_t ctrl)
527 {
528   if (ctrl->scd_local)
529     {
530       if (ctrl->scd_local->ctx)
531         {
532           /* We can't disconnect the primary context because libassuan
533              does a waitpid on it and thus the system would hang.
534              Instead we send a reset and keep that connection for
535              reuse. */
536           if (ctrl->scd_local->ctx == primary_scd_ctx)
537             {
538               /* Send a RESTART to the SCD.  This is required for the
539                  primary connection as a kind of virtual EOF; we don't
540                  have another way to tell it that the next command
541                  should be viewed as if a new connection has been
542                  made.  For the non-primary connections this is not
543                  needed as we simply close the socket.  We don't check
544                  for an error here because the RESTART may fail for
545                  example if the scdaemon has already been terminated.
546                  Anyway, we need to set the reusable flag to make sure
547                  that the aliveness check can clean it up. */
548               assuan_transact (primary_scd_ctx, "RESTART",
549                                NULL, NULL, NULL, NULL, NULL, NULL);
550               primary_scd_ctx_reusable = 1;
551             }
552           else
553             assuan_release (ctrl->scd_local->ctx);
554           ctrl->scd_local->ctx = NULL;
555         }
556
557       /* Remove the local context from our list and release it. */
558       if (!scd_local_list)
559         BUG ();
560       else if (scd_local_list == ctrl->scd_local)
561         scd_local_list = ctrl->scd_local->next_local;
562       else
563         {
564           struct scd_local_s *sl;
565
566           for (sl=scd_local_list; sl->next_local; sl = sl->next_local)
567             if (sl->next_local == ctrl->scd_local)
568               break;
569           if (!sl->next_local)
570             BUG ();
571           sl->next_local = ctrl->scd_local->next_local;
572         }
573       xfree (ctrl->scd_local);
574       ctrl->scd_local = NULL;
575     }
576
577   return 0;
578 }
579
580
581 \f
582 static gpg_error_t
583 learn_status_cb (void *opaque, const char *line)
584 {
585   struct learn_parm_s *parm = opaque;
586   const char *keyword = line;
587   int keywordlen;
588
589   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
590     ;
591   while (spacep (line))
592     line++;
593   if (keywordlen == 8 && !memcmp (keyword, "CERTINFO", keywordlen))
594     {
595       parm->certinfo_cb (parm->certinfo_cb_arg, line);
596     }
597   else if (keywordlen == 11 && !memcmp (keyword, "KEYPAIRINFO", keywordlen))
598     {
599       parm->kpinfo_cb (parm->kpinfo_cb_arg, line);
600     }
601   else if (keywordlen && *line)
602     {
603       parm->sinfo_cb (parm->sinfo_cb_arg, keyword, keywordlen, line);
604     }
605
606   return 0;
607 }
608
609 /* Perform the LEARN command and return a list of all private keys
610    stored on the card. */
611 int
612 agent_card_learn (ctrl_t ctrl,
613                   void (*kpinfo_cb)(void*, const char *),
614                   void *kpinfo_cb_arg,
615                   void (*certinfo_cb)(void*, const char *),
616                   void *certinfo_cb_arg,
617                   void (*sinfo_cb)(void*, const char *, size_t, const char *),
618                   void *sinfo_cb_arg)
619 {
620   int rc;
621   struct learn_parm_s parm;
622
623   rc = start_scd (ctrl);
624   if (rc)
625     return rc;
626
627   memset (&parm, 0, sizeof parm);
628   parm.kpinfo_cb = kpinfo_cb;
629   parm.kpinfo_cb_arg = kpinfo_cb_arg;
630   parm.certinfo_cb = certinfo_cb;
631   parm.certinfo_cb_arg = certinfo_cb_arg;
632   parm.sinfo_cb = sinfo_cb;
633   parm.sinfo_cb_arg = sinfo_cb_arg;
634   rc = assuan_transact (ctrl->scd_local->ctx, "LEARN --force",
635                         NULL, NULL, NULL, NULL,
636                         learn_status_cb, &parm);
637   if (rc)
638     return unlock_scd (ctrl, rc);
639
640   return unlock_scd (ctrl, 0);
641 }
642
643
644 \f
645 static gpg_error_t
646 get_serialno_cb (void *opaque, const char *line)
647 {
648   char **serialno = opaque;
649   const char *keyword = line;
650   const char *s;
651   int keywordlen, n;
652
653   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
654     ;
655   while (spacep (line))
656     line++;
657
658   if (keywordlen == 8 && !memcmp (keyword, "SERIALNO", keywordlen))
659     {
660       if (*serialno)
661         return gpg_error (GPG_ERR_CONFLICT); /* Unexpected status line. */
662       for (n=0,s=line; hexdigitp (s); s++, n++)
663         ;
664       if (!n || (n&1)|| !(spacep (s) || !*s) )
665         return gpg_error (GPG_ERR_ASS_PARAMETER);
666       *serialno = xtrymalloc (n+1);
667       if (!*serialno)
668         return out_of_core ();
669       memcpy (*serialno, line, n);
670       (*serialno)[n] = 0;
671     }
672
673   return 0;
674 }
675
676 /* Return the serial number of the card or an appropriate error.  The
677    serial number is returned as a hexstring. */
678 int
679 agent_card_serialno (ctrl_t ctrl, char **r_serialno)
680 {
681   int rc;
682   char *serialno = NULL;
683
684   rc = start_scd (ctrl);
685   if (rc)
686     return rc;
687
688   rc = assuan_transact (ctrl->scd_local->ctx, "SERIALNO",
689                         NULL, NULL, NULL, NULL,
690                         get_serialno_cb, &serialno);
691   if (rc)
692     {
693       xfree (serialno);
694       return unlock_scd (ctrl, rc);
695     }
696   *r_serialno = serialno;
697   return unlock_scd (ctrl, 0);
698 }
699
700
701
702 \f
703 static gpg_error_t
704 membuf_data_cb (void *opaque, const void *buffer, size_t length)
705 {
706   membuf_t *data = opaque;
707
708   if (buffer)
709     put_membuf (data, buffer, length);
710   return 0;
711 }
712
713 /* Handle the NEEDPIN inquiry. */
714 static gpg_error_t
715 inq_needpin (void *opaque, const char *line)
716 {
717   struct inq_needpin_s *parm = opaque;
718   char *pin;
719   size_t pinlen;
720   int rc;
721
722   parm->any_inq_seen = 1;
723   if (!strncmp (line, "NEEDPIN", 7) && (line[7] == ' ' || !line[7]))
724     {
725       line += 7;
726       while (*line == ' ')
727         line++;
728
729       pinlen = 90;
730       pin = gcry_malloc_secure (pinlen);
731       if (!pin)
732         return out_of_core ();
733
734       rc = parm->getpin_cb (parm->getpin_cb_arg, line, pin, pinlen);
735       if (!rc)
736         rc = assuan_send_data (parm->ctx, pin, pinlen);
737       xfree (pin);
738     }
739   else if (!strncmp (line, "POPUPKEYPADPROMPT", 17)
740            && (line[17] == ' ' || !line[17]))
741     {
742       line += 17;
743       while (*line == ' ')
744         line++;
745
746       rc = parm->getpin_cb (parm->getpin_cb_arg, line, NULL, 1);
747     }
748   else if (!strncmp (line, "DISMISSKEYPADPROMPT", 19)
749            && (line[19] == ' ' || !line[19]))
750     {
751       rc = parm->getpin_cb (parm->getpin_cb_arg, "", NULL, 0);
752     }
753   else if (parm->passthru)
754     {
755       unsigned char *value;
756       size_t valuelen;
757       int rest;
758       int needrest = !strncmp (line, "KEYDATA", 8);
759
760       /* Pass the inquiry up to our caller.  We limit the maximum
761          amount to an arbitrary value.  As we know that the KEYDATA
762          enquiry is pretty sensitive we disable logging then */
763       if ((rest = (needrest
764                    && !assuan_get_flag (parm->passthru, ASSUAN_CONFIDENTIAL))))
765         assuan_begin_confidential (parm->passthru);
766       rc = assuan_inquire (parm->passthru, line, &value, &valuelen, 8096);
767       if (rest)
768         assuan_end_confidential (parm->passthru);
769       if (!rc)
770         {
771           if ((rest = (needrest
772                        && !assuan_get_flag (parm->ctx, ASSUAN_CONFIDENTIAL))))
773             assuan_begin_confidential (parm->ctx);
774           rc = assuan_send_data (parm->ctx, value, valuelen);
775           if (rest)
776             assuan_end_confidential (parm->ctx);
777           xfree (value);
778         }
779       else
780         log_error ("error forwarding inquiry `%s': %s\n",
781                    line, gpg_strerror (rc));
782     }
783   else
784     {
785       log_error ("unsupported inquiry `%s'\n", line);
786       rc = gpg_error (GPG_ERR_ASS_UNKNOWN_INQUIRE);
787     }
788
789   return rc;
790 }
791
792
793 /* Helper returning a command option to describe the used hash
794    algorithm.  See scd/command.c:cmd_pksign.  */
795 static const char *
796 hash_algo_option (int algo)
797 {
798   switch (algo)
799     {
800     case GCRY_MD_MD5   : return "--hash=md5";
801     case GCRY_MD_RMD160: return "--hash=rmd160";
802     case GCRY_MD_SHA1  : return "--hash=sha1";
803     case GCRY_MD_SHA224: return "--hash=sha224";
804     case GCRY_MD_SHA256: return "--hash=sha256";
805     case GCRY_MD_SHA384: return "--hash=sha384";
806     case GCRY_MD_SHA512: return "--hash=sha512";
807     default:             return "";
808     }
809 }
810
811
812 /* Create a signature using the current card.  MDALGO is either 0 or
813    gives the digest algorithm.  */
814 int
815 agent_card_pksign (ctrl_t ctrl,
816                    const char *keyid,
817                    int (*getpin_cb)(void *, const char *, char*, size_t),
818                    void *getpin_cb_arg,
819                    int mdalgo,
820                    const unsigned char *indata, size_t indatalen,
821                    unsigned char **r_buf, size_t *r_buflen)
822 {
823   int rc, i;
824   char *p, line[ASSUAN_LINELENGTH];
825   membuf_t data;
826   struct inq_needpin_s inqparm;
827   size_t len;
828   unsigned char *sigbuf;
829   size_t sigbuflen;
830   int prepend_nul;
831
832   *r_buf = NULL;
833   rc = start_scd (ctrl);
834   if (rc)
835     return rc;
836
837   if (indatalen*2 + 50 > DIM(line))
838     return unlock_scd (ctrl, gpg_error (GPG_ERR_GENERAL));
839
840   sprintf (line, "SETDATA ");
841   p = line + strlen (line);
842   for (i=0; i < indatalen ; i++, p += 2 )
843     sprintf (p, "%02X", indata[i]);
844   rc = assuan_transact (ctrl->scd_local->ctx, line,
845                         NULL, NULL, NULL, NULL, NULL, NULL);
846   if (rc)
847     return unlock_scd (ctrl, rc);
848
849   init_membuf (&data, 1024);
850   inqparm.ctx = ctrl->scd_local->ctx;
851   inqparm.getpin_cb = getpin_cb;
852   inqparm.getpin_cb_arg = getpin_cb_arg;
853   inqparm.passthru = 0;
854   inqparm.any_inq_seen = 0;
855   if (ctrl->use_auth_call)
856     snprintf (line, sizeof line, "PKAUTH %s", keyid);
857   else
858     snprintf (line, sizeof line, "PKSIGN %s %s",
859               hash_algo_option (mdalgo), keyid);
860   rc = assuan_transact (ctrl->scd_local->ctx, line,
861                         membuf_data_cb, &data,
862                         inq_needpin, &inqparm,
863                         NULL, NULL);
864   if (rc)
865     {
866       xfree (get_membuf (&data, &len));
867       return unlock_scd (ctrl, rc);
868     }
869   sigbuf = get_membuf (&data, &sigbuflen);
870
871   /* Create an S-expression from it which is formatted like this:
872      "(7:sig-val(3:rsa(1:sSIGBUFLEN:SIGBUF)))".  We better make sure
873      that this won't be interpreted as a negative number.  */
874   prepend_nul = (sigbuflen && (*sigbuf & 0x80));
875
876   *r_buflen = 21 + 11 + prepend_nul + sigbuflen + 4;
877   p = xtrymalloc (*r_buflen);
878   *r_buf = (unsigned char*)p;
879   if (!p)
880     return unlock_scd (ctrl, out_of_core ());
881   p = stpcpy (p, "(7:sig-val(3:rsa(1:s" );
882   sprintf (p, "%u:", (unsigned int)sigbuflen + prepend_nul);
883   p += strlen (p);
884   if (prepend_nul)
885     *p++ = 0;
886   memcpy (p, sigbuf, sigbuflen);
887   p += sigbuflen;
888   strcpy (p, ")))");
889   xfree (sigbuf);
890
891   assert (gcry_sexp_canon_len (*r_buf, *r_buflen, NULL, NULL));
892   return unlock_scd (ctrl, 0);
893 }
894
895 /* Decipher INDATA using the current card. Note that the returned value is */
896 int
897 agent_card_pkdecrypt (ctrl_t ctrl,
898                       const char *keyid,
899                       int (*getpin_cb)(void *, const char *, char*, size_t),
900                       void *getpin_cb_arg,
901                       const unsigned char *indata, size_t indatalen,
902                       char **r_buf, size_t *r_buflen)
903 {
904   int rc, i;
905   char *p, line[ASSUAN_LINELENGTH];
906   membuf_t data;
907   struct inq_needpin_s inqparm;
908   size_t len;
909
910   *r_buf = NULL;
911   rc = start_scd (ctrl);
912   if (rc)
913     return rc;
914
915   /* FIXME: use secure memory where appropriate */
916   if (indatalen*2 + 50 > DIM(line))
917     return unlock_scd (ctrl, gpg_error (GPG_ERR_GENERAL));
918
919   sprintf (line, "SETDATA ");
920   p = line + strlen (line);
921   for (i=0; i < indatalen ; i++, p += 2 )
922     sprintf (p, "%02X", indata[i]);
923   rc = assuan_transact (ctrl->scd_local->ctx, line,
924                         NULL, NULL, NULL, NULL, NULL, NULL);
925   if (rc)
926     return unlock_scd (ctrl, rc);
927
928   init_membuf (&data, 1024);
929   inqparm.ctx = ctrl->scd_local->ctx;
930   inqparm.getpin_cb = getpin_cb;
931   inqparm.getpin_cb_arg = getpin_cb_arg;
932   inqparm.passthru = 0;
933   inqparm.any_inq_seen = 0;
934   snprintf (line, DIM(line)-1, "PKDECRYPT %s", keyid);
935   line[DIM(line)-1] = 0;
936   rc = assuan_transact (ctrl->scd_local->ctx, line,
937                         membuf_data_cb, &data,
938                         inq_needpin, &inqparm,
939                         NULL, NULL);
940   if (rc)
941     {
942       xfree (get_membuf (&data, &len));
943       return unlock_scd (ctrl, rc);
944     }
945   *r_buf = get_membuf (&data, r_buflen);
946   if (!*r_buf)
947     return unlock_scd (ctrl, gpg_error (GPG_ERR_ENOMEM));
948
949   return unlock_scd (ctrl, 0);
950 }
951
952
953 \f
954 /* Read a certificate with ID into R_BUF and R_BUFLEN. */
955 int
956 agent_card_readcert (ctrl_t ctrl,
957                      const char *id, char **r_buf, size_t *r_buflen)
958 {
959   int rc;
960   char line[ASSUAN_LINELENGTH];
961   membuf_t data;
962   size_t len;
963
964   *r_buf = NULL;
965   rc = start_scd (ctrl);
966   if (rc)
967     return rc;
968
969   init_membuf (&data, 1024);
970   snprintf (line, DIM(line)-1, "READCERT %s", id);
971   line[DIM(line)-1] = 0;
972   rc = assuan_transact (ctrl->scd_local->ctx, line,
973                         membuf_data_cb, &data,
974                         NULL, NULL,
975                         NULL, NULL);
976   if (rc)
977     {
978       xfree (get_membuf (&data, &len));
979       return unlock_scd (ctrl, rc);
980     }
981   *r_buf = get_membuf (&data, r_buflen);
982   if (!*r_buf)
983     return unlock_scd (ctrl, gpg_error (GPG_ERR_ENOMEM));
984
985   return unlock_scd (ctrl, 0);
986 }
987
988
989 \f
990 /* Read a key with ID and return it in an allocate buffer pointed to
991    by r_BUF as a valid S-expression. */
992 int
993 agent_card_readkey (ctrl_t ctrl, const char *id, unsigned char **r_buf)
994 {
995   int rc;
996   char line[ASSUAN_LINELENGTH];
997   membuf_t data;
998   size_t len, buflen;
999
1000   *r_buf = NULL;
1001   rc = start_scd (ctrl);
1002   if (rc)
1003     return rc;
1004
1005   init_membuf (&data, 1024);
1006   snprintf (line, DIM(line)-1, "READKEY %s", id);
1007   line[DIM(line)-1] = 0;
1008   rc = assuan_transact (ctrl->scd_local->ctx, line,
1009                         membuf_data_cb, &data,
1010                         NULL, NULL,
1011                         NULL, NULL);
1012   if (rc)
1013     {
1014       xfree (get_membuf (&data, &len));
1015       return unlock_scd (ctrl, rc);
1016     }
1017   *r_buf = get_membuf (&data, &buflen);
1018   if (!*r_buf)
1019     return unlock_scd (ctrl, gpg_error (GPG_ERR_ENOMEM));
1020
1021   if (!gcry_sexp_canon_len (*r_buf, buflen, NULL, NULL))
1022     {
1023       xfree (*r_buf); *r_buf = NULL;
1024       return unlock_scd (ctrl, gpg_error (GPG_ERR_INV_VALUE));
1025     }
1026
1027   return unlock_scd (ctrl, 0);
1028 }
1029
1030
1031 \f
1032 /* Type used with the card_getattr_cb.  */
1033 struct card_getattr_parm_s {
1034   const char *keyword;  /* Keyword to look for.  */
1035   size_t keywordlen;    /* strlen of KEYWORD.  */
1036   char *data;           /* Malloced and unescaped data.  */
1037   int error;            /* ERRNO value or 0 on success. */
1038 };
1039
1040 /* Callback function for agent_card_getattr.  */
1041 static gpg_error_t
1042 card_getattr_cb (void *opaque, const char *line)
1043 {
1044   struct card_getattr_parm_s *parm = opaque;
1045   const char *keyword = line;
1046   int keywordlen;
1047
1048   if (parm->data)
1049     return 0; /* We want only the first occurrence.  */
1050
1051   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
1052     ;
1053   while (spacep (line))
1054     line++;
1055
1056   if (keywordlen == parm->keywordlen
1057       && !memcmp (keyword, parm->keyword, keywordlen))
1058     {
1059       parm->data = percent_plus_unescape ((const unsigned char*)line, 0xff);
1060       if (!parm->data)
1061         parm->error = errno;
1062     }
1063
1064   return 0;
1065 }
1066
1067
1068 /* Call the agent to retrieve a single line data object. On success
1069    the object is malloced and stored at RESULT; it is guaranteed that
1070    NULL is never stored in this case.  On error an error code is
1071    returned and NULL stored at RESULT. */
1072 gpg_error_t
1073 agent_card_getattr (ctrl_t ctrl, const char *name, char **result)
1074 {
1075   int err;
1076   struct card_getattr_parm_s parm;
1077   char line[ASSUAN_LINELENGTH];
1078
1079   *result = NULL;
1080
1081   if (!*name)
1082     return gpg_error (GPG_ERR_INV_VALUE);
1083
1084   memset (&parm, 0, sizeof parm);
1085   parm.keyword = name;
1086   parm.keywordlen = strlen (name);
1087
1088   /* We assume that NAME does not need escaping. */
1089   if (8 + strlen (name) > DIM(line)-1)
1090     return gpg_error (GPG_ERR_TOO_LARGE);
1091   stpcpy (stpcpy (line, "GETATTR "), name);
1092
1093   err = start_scd (ctrl);
1094   if (err)
1095     return err;
1096
1097   err = assuan_transact (ctrl->scd_local->ctx, line,
1098                          NULL, NULL, NULL, NULL,
1099                          card_getattr_cb, &parm);
1100   if (!err && parm.error)
1101     err = gpg_error_from_errno (parm.error);
1102
1103   if (!err && !parm.data)
1104     err = gpg_error (GPG_ERR_NO_DATA);
1105
1106   if (!err)
1107     *result = parm.data;
1108   else
1109     xfree (parm.data);
1110
1111   return unlock_scd (ctrl, err);
1112 }
1113
1114
1115
1116 \f
1117 static gpg_error_t
1118 pass_status_thru (void *opaque, const char *line)
1119 {
1120   assuan_context_t ctx = opaque;
1121   char keyword[200];
1122   int i;
1123
1124   if (line[0] == '#' && (!line[1] || spacep (line+1)))
1125     {
1126       /* We are called in convey comments mode.  Now, if we see a
1127          comment marker as keyword we forward the line verbatim to the
1128          the caller.  This way the comment lines from scdaemon won't
1129          appear as status lines with keyword '#'.  */
1130       assuan_write_line (ctx, line);
1131     }
1132   else
1133     {
1134       for (i=0; *line && !spacep (line) && i < DIM(keyword)-1; line++, i++)
1135         keyword[i] = *line;
1136       keyword[i] = 0;
1137
1138       /* Truncate any remaining keyword stuff.  */
1139       for (; *line && !spacep (line); line++)
1140         ;
1141       while (spacep (line))
1142         line++;
1143
1144       assuan_write_status (ctx, keyword, line);
1145     }
1146   return 0;
1147 }
1148
1149 static gpg_error_t
1150 pass_data_thru (void *opaque, const void *buffer, size_t length)
1151 {
1152   assuan_context_t ctx = opaque;
1153
1154   assuan_send_data (ctx, buffer, length);
1155   return 0;
1156 }
1157
1158
1159 /* Send the line CMDLINE with command for the SCDdaemon to it and send
1160    all status messages back.  This command is used as a general quoting
1161    mechanism to pass everything verbatim to SCDAEMON.  The PIN
1162    inquiry is handled inside gpg-agent.  */
1163 int
1164 agent_card_scd (ctrl_t ctrl, const char *cmdline,
1165                 int (*getpin_cb)(void *, const char *, char*, size_t),
1166                 void *getpin_cb_arg, void *assuan_context)
1167 {
1168   int rc;
1169   struct inq_needpin_s inqparm;
1170   int saveflag;
1171
1172   rc = start_scd (ctrl);
1173   if (rc)
1174     return rc;
1175
1176   inqparm.ctx = ctrl->scd_local->ctx;
1177   inqparm.getpin_cb = getpin_cb;
1178   inqparm.getpin_cb_arg = getpin_cb_arg;
1179   inqparm.passthru = assuan_context;
1180   inqparm.any_inq_seen = 0;
1181   saveflag = assuan_get_flag (ctrl->scd_local->ctx, ASSUAN_CONVEY_COMMENTS);
1182   assuan_set_flag (ctrl->scd_local->ctx, ASSUAN_CONVEY_COMMENTS, 1);
1183   rc = assuan_transact (ctrl->scd_local->ctx, cmdline,
1184                         pass_data_thru, assuan_context,
1185                         inq_needpin, &inqparm,
1186                         pass_status_thru, assuan_context);
1187   if (inqparm.any_inq_seen && gpg_err_code(rc) == GPG_ERR_ASS_CANCELED)
1188     {
1189       /* The inquire callback was called and transact returned a
1190          cancel error.  We assume that the inquired process sent a
1191          CANCEL.  The passthrough code is not able to pass on the
1192          CANCEL and thus scdaemon would stuck on this.  As a
1193          workaround we send a CANCEL now.  */
1194       rc = assuan_write_line(ctrl->scd_local->ctx, "CAN");
1195       if (!rc) {
1196         char *line;
1197         size_t len;
1198
1199         rc = assuan_read_line(ctrl->scd_local->ctx, &line, &len);
1200         if (!rc)
1201           rc = gpg_error(GPG_ERR_ASS_CANCELED);
1202       }
1203     }
1204
1205   assuan_set_flag (ctrl->scd_local->ctx, ASSUAN_CONVEY_COMMENTS, saveflag);
1206   if (rc)
1207     {
1208       return unlock_scd (ctrl, rc);
1209     }
1210
1211   return unlock_scd (ctrl, 0);
1212 }