Fix indentation.
[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 static gpg_error_t
813 cancel_inquire (ctrl_t ctrl, gpg_error_t rc)
814 {
815   gpg_error_t oldrc = rc;
816
817   /* The inquire callback was called and transact returned a
818      cancel error.  We assume that the inquired process sent a
819      CANCEL.  The passthrough code is not able to pass on the
820      CANCEL and thus scdaemon would stuck on this.  As a
821      workaround we send a CANCEL now.  */
822   rc = assuan_write_line (ctrl->scd_local->ctx, "CAN");
823   if (!rc) {
824     char *line;
825     size_t len;
826
827     rc = assuan_read_line (ctrl->scd_local->ctx, &line, &len);
828     if (!rc)
829       rc = oldrc;
830   }
831
832   return rc;
833 }
834
835 /* Create a signature using the current card.  MDALGO is either 0 or
836    gives the digest algorithm.  */
837 int
838 agent_card_pksign (ctrl_t ctrl,
839                    const char *keyid,
840                    int (*getpin_cb)(void *, const char *, char*, size_t),
841                    void *getpin_cb_arg,
842                    int mdalgo,
843                    const unsigned char *indata, size_t indatalen,
844                    unsigned char **r_buf, size_t *r_buflen)
845 {
846   int rc, i;
847   char *p, line[ASSUAN_LINELENGTH];
848   membuf_t data;
849   struct inq_needpin_s inqparm;
850   size_t len;
851   unsigned char *sigbuf;
852   size_t sigbuflen;
853   int prepend_nul;
854
855   *r_buf = NULL;
856   rc = start_scd (ctrl);
857   if (rc)
858     return rc;
859
860   if (indatalen*2 + 50 > DIM(line))
861     return unlock_scd (ctrl, gpg_error (GPG_ERR_GENERAL));
862
863   sprintf (line, "SETDATA ");
864   p = line + strlen (line);
865   for (i=0; i < indatalen ; i++, p += 2 )
866     sprintf (p, "%02X", indata[i]);
867   rc = assuan_transact (ctrl->scd_local->ctx, line,
868                         NULL, NULL, NULL, NULL, NULL, NULL);
869   if (rc)
870     return unlock_scd (ctrl, rc);
871
872   init_membuf (&data, 1024);
873   inqparm.ctx = ctrl->scd_local->ctx;
874   inqparm.getpin_cb = getpin_cb;
875   inqparm.getpin_cb_arg = getpin_cb_arg;
876   inqparm.passthru = 0;
877   inqparm.any_inq_seen = 0;
878   if (ctrl->use_auth_call)
879     snprintf (line, sizeof line, "PKAUTH %s", keyid);
880   else
881     snprintf (line, sizeof line, "PKSIGN %s %s",
882               hash_algo_option (mdalgo), keyid);
883   rc = assuan_transact (ctrl->scd_local->ctx, line,
884                         membuf_data_cb, &data,
885                         inq_needpin, &inqparm,
886                         NULL, NULL);
887   if (inqparm.any_inq_seen && gpg_err_code(rc) == GPG_ERR_CANCELED)
888     rc = cancel_inquire (ctrl, rc);
889
890   if (rc)
891     {
892       xfree (get_membuf (&data, &len));
893       return unlock_scd (ctrl, rc);
894     }
895   sigbuf = get_membuf (&data, &sigbuflen);
896
897   /* Create an S-expression from it which is formatted like this:
898      "(7:sig-val(3:rsa(1:sSIGBUFLEN:SIGBUF)))".  We better make sure
899      that this won't be interpreted as a negative number.  */
900   prepend_nul = (sigbuflen && (*sigbuf & 0x80));
901
902   *r_buflen = 21 + 11 + prepend_nul + sigbuflen + 4;
903   p = xtrymalloc (*r_buflen);
904   *r_buf = (unsigned char*)p;
905   if (!p)
906     return unlock_scd (ctrl, out_of_core ());
907   p = stpcpy (p, "(7:sig-val(3:rsa(1:s" );
908   sprintf (p, "%u:", (unsigned int)sigbuflen + prepend_nul);
909   p += strlen (p);
910   if (prepend_nul)
911     *p++ = 0;
912   memcpy (p, sigbuf, sigbuflen);
913   p += sigbuflen;
914   strcpy (p, ")))");
915   xfree (sigbuf);
916
917   assert (gcry_sexp_canon_len (*r_buf, *r_buflen, NULL, NULL));
918   return unlock_scd (ctrl, 0);
919 }
920
921 /* Decipher INDATA using the current card. Note that the returned value is */
922 int
923 agent_card_pkdecrypt (ctrl_t ctrl,
924                       const char *keyid,
925                       int (*getpin_cb)(void *, const char *, char*, size_t),
926                       void *getpin_cb_arg,
927                       const unsigned char *indata, size_t indatalen,
928                       char **r_buf, size_t *r_buflen)
929 {
930   int rc, i;
931   char *p, line[ASSUAN_LINELENGTH];
932   membuf_t data;
933   struct inq_needpin_s inqparm;
934   size_t len;
935
936   *r_buf = NULL;
937   rc = start_scd (ctrl);
938   if (rc)
939     return rc;
940
941   /* FIXME: use secure memory where appropriate */
942   if (indatalen*2 + 50 > DIM(line))
943     return unlock_scd (ctrl, gpg_error (GPG_ERR_GENERAL));
944
945   sprintf (line, "SETDATA ");
946   p = line + strlen (line);
947   for (i=0; i < indatalen ; i++, p += 2 )
948     sprintf (p, "%02X", indata[i]);
949   rc = assuan_transact (ctrl->scd_local->ctx, line,
950                         NULL, NULL, NULL, NULL, NULL, NULL);
951   if (rc)
952     return unlock_scd (ctrl, rc);
953
954   init_membuf (&data, 1024);
955   inqparm.ctx = ctrl->scd_local->ctx;
956   inqparm.getpin_cb = getpin_cb;
957   inqparm.getpin_cb_arg = getpin_cb_arg;
958   inqparm.passthru = 0;
959   inqparm.any_inq_seen = 0;
960   snprintf (line, DIM(line)-1, "PKDECRYPT %s", keyid);
961   line[DIM(line)-1] = 0;
962   rc = assuan_transact (ctrl->scd_local->ctx, line,
963                         membuf_data_cb, &data,
964                         inq_needpin, &inqparm,
965                         NULL, NULL);
966   if (inqparm.any_inq_seen && gpg_err_code(rc) == GPG_ERR_CANCELED)
967     rc = cancel_inquire (ctrl, rc);
968
969   if (rc)
970     {
971       xfree (get_membuf (&data, &len));
972       return unlock_scd (ctrl, rc);
973     }
974   *r_buf = get_membuf (&data, r_buflen);
975   if (!*r_buf)
976     return unlock_scd (ctrl, gpg_error (GPG_ERR_ENOMEM));
977
978   return unlock_scd (ctrl, 0);
979 }
980
981
982 \f
983 /* Read a certificate with ID into R_BUF and R_BUFLEN. */
984 int
985 agent_card_readcert (ctrl_t ctrl,
986                      const char *id, char **r_buf, size_t *r_buflen)
987 {
988   int rc;
989   char line[ASSUAN_LINELENGTH];
990   membuf_t data;
991   size_t len;
992
993   *r_buf = NULL;
994   rc = start_scd (ctrl);
995   if (rc)
996     return rc;
997
998   init_membuf (&data, 1024);
999   snprintf (line, DIM(line)-1, "READCERT %s", id);
1000   line[DIM(line)-1] = 0;
1001   rc = assuan_transact (ctrl->scd_local->ctx, line,
1002                         membuf_data_cb, &data,
1003                         NULL, NULL,
1004                         NULL, NULL);
1005   if (rc)
1006     {
1007       xfree (get_membuf (&data, &len));
1008       return unlock_scd (ctrl, rc);
1009     }
1010   *r_buf = get_membuf (&data, r_buflen);
1011   if (!*r_buf)
1012     return unlock_scd (ctrl, gpg_error (GPG_ERR_ENOMEM));
1013
1014   return unlock_scd (ctrl, 0);
1015 }
1016
1017
1018 \f
1019 /* Read a key with ID and return it in an allocate buffer pointed to
1020    by r_BUF as a valid S-expression. */
1021 int
1022 agent_card_readkey (ctrl_t ctrl, const char *id, unsigned char **r_buf)
1023 {
1024   int rc;
1025   char line[ASSUAN_LINELENGTH];
1026   membuf_t data;
1027   size_t len, buflen;
1028
1029   *r_buf = NULL;
1030   rc = start_scd (ctrl);
1031   if (rc)
1032     return rc;
1033
1034   init_membuf (&data, 1024);
1035   snprintf (line, DIM(line)-1, "READKEY %s", id);
1036   line[DIM(line)-1] = 0;
1037   rc = assuan_transact (ctrl->scd_local->ctx, line,
1038                         membuf_data_cb, &data,
1039                         NULL, NULL,
1040                         NULL, NULL);
1041   if (rc)
1042     {
1043       xfree (get_membuf (&data, &len));
1044       return unlock_scd (ctrl, rc);
1045     }
1046   *r_buf = get_membuf (&data, &buflen);
1047   if (!*r_buf)
1048     return unlock_scd (ctrl, gpg_error (GPG_ERR_ENOMEM));
1049
1050   if (!gcry_sexp_canon_len (*r_buf, buflen, NULL, NULL))
1051     {
1052       xfree (*r_buf); *r_buf = NULL;
1053       return unlock_scd (ctrl, gpg_error (GPG_ERR_INV_VALUE));
1054     }
1055
1056   return unlock_scd (ctrl, 0);
1057 }
1058
1059
1060 \f
1061 /* Type used with the card_getattr_cb.  */
1062 struct card_getattr_parm_s {
1063   const char *keyword;  /* Keyword to look for.  */
1064   size_t keywordlen;    /* strlen of KEYWORD.  */
1065   char *data;           /* Malloced and unescaped data.  */
1066   int error;            /* ERRNO value or 0 on success. */
1067 };
1068
1069 /* Callback function for agent_card_getattr.  */
1070 static gpg_error_t
1071 card_getattr_cb (void *opaque, const char *line)
1072 {
1073   struct card_getattr_parm_s *parm = opaque;
1074   const char *keyword = line;
1075   int keywordlen;
1076
1077   if (parm->data)
1078     return 0; /* We want only the first occurrence.  */
1079
1080   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
1081     ;
1082   while (spacep (line))
1083     line++;
1084
1085   if (keywordlen == parm->keywordlen
1086       && !memcmp (keyword, parm->keyword, keywordlen))
1087     {
1088       parm->data = percent_plus_unescape ((const unsigned char*)line, 0xff);
1089       if (!parm->data)
1090         parm->error = errno;
1091     }
1092
1093   return 0;
1094 }
1095
1096
1097 /* Call the agent to retrieve a single line data object. On success
1098    the object is malloced and stored at RESULT; it is guaranteed that
1099    NULL is never stored in this case.  On error an error code is
1100    returned and NULL stored at RESULT. */
1101 gpg_error_t
1102 agent_card_getattr (ctrl_t ctrl, const char *name, char **result)
1103 {
1104   int err;
1105   struct card_getattr_parm_s parm;
1106   char line[ASSUAN_LINELENGTH];
1107
1108   *result = NULL;
1109
1110   if (!*name)
1111     return gpg_error (GPG_ERR_INV_VALUE);
1112
1113   memset (&parm, 0, sizeof parm);
1114   parm.keyword = name;
1115   parm.keywordlen = strlen (name);
1116
1117   /* We assume that NAME does not need escaping. */
1118   if (8 + strlen (name) > DIM(line)-1)
1119     return gpg_error (GPG_ERR_TOO_LARGE);
1120   stpcpy (stpcpy (line, "GETATTR "), name);
1121
1122   err = start_scd (ctrl);
1123   if (err)
1124     return err;
1125
1126   err = assuan_transact (ctrl->scd_local->ctx, line,
1127                          NULL, NULL, NULL, NULL,
1128                          card_getattr_cb, &parm);
1129   if (!err && parm.error)
1130     err = gpg_error_from_errno (parm.error);
1131
1132   if (!err && !parm.data)
1133     err = gpg_error (GPG_ERR_NO_DATA);
1134
1135   if (!err)
1136     *result = parm.data;
1137   else
1138     xfree (parm.data);
1139
1140   return unlock_scd (ctrl, err);
1141 }
1142
1143
1144
1145 \f
1146 static gpg_error_t
1147 pass_status_thru (void *opaque, const char *line)
1148 {
1149   assuan_context_t ctx = opaque;
1150   char keyword[200];
1151   int i;
1152
1153   if (line[0] == '#' && (!line[1] || spacep (line+1)))
1154     {
1155       /* We are called in convey comments mode.  Now, if we see a
1156          comment marker as keyword we forward the line verbatim to the
1157          the caller.  This way the comment lines from scdaemon won't
1158          appear as status lines with keyword '#'.  */
1159       assuan_write_line (ctx, line);
1160     }
1161   else
1162     {
1163       for (i=0; *line && !spacep (line) && i < DIM(keyword)-1; line++, i++)
1164         keyword[i] = *line;
1165       keyword[i] = 0;
1166
1167       /* Truncate any remaining keyword stuff.  */
1168       for (; *line && !spacep (line); line++)
1169         ;
1170       while (spacep (line))
1171         line++;
1172
1173       assuan_write_status (ctx, keyword, line);
1174     }
1175   return 0;
1176 }
1177
1178 static gpg_error_t
1179 pass_data_thru (void *opaque, const void *buffer, size_t length)
1180 {
1181   assuan_context_t ctx = opaque;
1182
1183   assuan_send_data (ctx, buffer, length);
1184   return 0;
1185 }
1186
1187
1188 /* Send the line CMDLINE with command for the SCDdaemon to it and send
1189    all status messages back.  This command is used as a general quoting
1190    mechanism to pass everything verbatim to SCDAEMON.  The PIN
1191    inquiry is handled inside gpg-agent.  */
1192 int
1193 agent_card_scd (ctrl_t ctrl, const char *cmdline,
1194                 int (*getpin_cb)(void *, const char *, char*, size_t),
1195                 void *getpin_cb_arg, void *assuan_context)
1196 {
1197   int rc;
1198   struct inq_needpin_s inqparm;
1199   int saveflag;
1200
1201   rc = start_scd (ctrl);
1202   if (rc)
1203     return rc;
1204
1205   inqparm.ctx = ctrl->scd_local->ctx;
1206   inqparm.getpin_cb = getpin_cb;
1207   inqparm.getpin_cb_arg = getpin_cb_arg;
1208   inqparm.passthru = assuan_context;
1209   inqparm.any_inq_seen = 0;
1210   saveflag = assuan_get_flag (ctrl->scd_local->ctx, ASSUAN_CONVEY_COMMENTS);
1211   assuan_set_flag (ctrl->scd_local->ctx, ASSUAN_CONVEY_COMMENTS, 1);
1212   rc = assuan_transact (ctrl->scd_local->ctx, cmdline,
1213                         pass_data_thru, assuan_context,
1214                         inq_needpin, &inqparm,
1215                         pass_status_thru, assuan_context);
1216   if (inqparm.any_inq_seen && gpg_err_code(rc) == GPG_ERR_ASS_CANCELED)
1217     rc = cancel_inquire (ctrl, rc);
1218
1219   assuan_set_flag (ctrl->scd_local->ctx, ASSUAN_CONVEY_COMMENTS, saveflag);
1220   if (rc)
1221     {
1222       return unlock_scd (ctrl, rc);
1223     }
1224
1225   return unlock_scd (ctrl, 0);
1226 }