agent: Stop scdaemon after reload when disable_scdaemon.
[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  * Copyright (C) 2013 Werner Koch
5  *
6  * This file is part of GnuPG.
7  *
8  * GnuPG is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 3 of the License, or
11  * (at your option) any later version.
12  *
13  * GnuPG is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, see <https://www.gnu.org/licenses/>.
20  */
21
22 #include <config.h>
23 #include <errno.h>
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #include <ctype.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 <npth.h>
38
39 #include "agent.h"
40 #include <assuan.h>
41 #include "../common/strlist.h"
42
43 #ifdef _POSIX_OPEN_MAX
44 #define MAX_OPEN_FDS _POSIX_OPEN_MAX
45 #else
46 #define MAX_OPEN_FDS 20
47 #endif
48
49 /* Definition of module local data of the CTRL structure.  */
50 struct scd_local_s
51 {
52   /* We keep a list of all allocated context with an anchor at
53      SCD_LOCAL_LIST (see below). */
54   struct scd_local_s *next_local;
55
56   assuan_context_t ctx;   /* NULL or session context for the SCdaemon
57                              used with this connection. */
58   unsigned int in_use: 1; /* CTX is in use.  */
59   unsigned int invalid:1; /* CTX is invalid, should be released.  */
60 };
61
62
63 /* Callback parameter for learn card */
64 struct learn_parm_s
65 {
66   void (*kpinfo_cb)(void*, const char *);
67   void *kpinfo_cb_arg;
68   void (*certinfo_cb)(void*, const char *);
69   void *certinfo_cb_arg;
70   void (*sinfo_cb)(void*, const char *, size_t, const char *);
71   void *sinfo_cb_arg;
72 };
73
74
75 /* Callback parameter used by inq_getpin and inq_writekey_parms.  */
76 struct inq_needpin_parm_s
77 {
78   assuan_context_t ctx;
79   int (*getpin_cb)(void *, const char *, const char *, char*, size_t);
80   void *getpin_cb_arg;
81   const char *getpin_cb_desc;
82   assuan_context_t passthru;  /* If not NULL, pass unknown inquiries
83                                  up to the caller.  */
84
85   /* The next fields are used by inq_writekey_parm.  */
86   const unsigned char *keydata;
87   size_t keydatalen;
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 npth_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
116
117
118 \f
119 /* This function must be called once to initialize this module.  This
120    has to be done before a second thread is spawned.  We can't do the
121    static initialization because NPth emulation code might not be able
122    to do a static init; in particular, it is not possible for W32. */
123 void
124 initialize_module_call_scd (void)
125 {
126   static int initialized;
127   int err;
128
129   if (!initialized)
130     {
131       err = npth_mutex_init (&start_scd_lock, NULL);
132       if (err)
133         log_fatal ("error initializing mutex: %s\n", strerror (err));
134       initialized = 1;
135     }
136 }
137
138
139 /* This function may be called to print information pertaining to the
140    current state of this module to the log. */
141 void
142 agent_scd_dump_state (void)
143 {
144   log_info ("agent_scd_dump_state: primary_scd_ctx=%p pid=%ld reusable=%d\n",
145             primary_scd_ctx,
146             (long)assuan_get_pid (primary_scd_ctx),
147             primary_scd_ctx_reusable);
148   if (socket_name)
149     log_info ("agent_scd_dump_state: socket='%s'\n", socket_name);
150 }
151
152
153 /* The unlock_scd function shall be called after having accessed the
154    SCD.  It is currently not very useful but gives an opportunity to
155    keep track of connections currently calling SCD.  Note that the
156    "lock" operation is done by the start_scd() function which must be
157    called and error checked before any SCD operation.  CTRL is the
158    usual connection context and RC the error code to be passed trhough
159    the function. */
160 static int
161 unlock_scd (ctrl_t ctrl, int rc)
162 {
163   int err;
164
165   if (ctrl->scd_local->in_use == 0)
166     {
167       log_error ("unlock_scd: CTX is not in use\n");
168       if (!rc)
169         rc = gpg_error (GPG_ERR_INTERNAL);
170     }
171   err = npth_mutex_lock (&start_scd_lock);
172   if (err)
173     {
174       log_error ("failed to acquire the start_scd lock: %s\n", strerror (err));
175       return gpg_error (GPG_ERR_INTERNAL);
176     }
177   ctrl->scd_local->in_use = 0;
178   if (ctrl->scd_local->invalid)
179     {
180       assuan_release (ctrl->scd_local->ctx);
181       ctrl->scd_local->ctx = NULL;
182       ctrl->scd_local->invalid = 0;
183     }
184   err = npth_mutex_unlock (&start_scd_lock);
185   if (err)
186     {
187       log_error ("failed to release the start_scd lock: %s\n", strerror (err));
188       return gpg_error (GPG_ERR_INTERNAL);
189     }
190   return rc;
191 }
192
193 /* To make sure we leave no secrets in our image after forking of the
194    scdaemon, we use this callback. */
195 static void
196 atfork_cb (void *opaque, int where)
197 {
198   (void)opaque;
199
200   if (!where)
201     gcry_control (GCRYCTL_TERM_SECMEM);
202 }
203
204
205 static void *
206 wait_child_thread (void *arg)
207 {
208   int err;
209   struct scd_local_s *sl;
210
211 #ifdef HAVE_W32_SYSTEM
212   HANDLE pid = (HANDLE)arg;
213
214   npth_unprotect ();
215   WaitForSingleObject ((HANDLE)pid, INFINITE);
216   npth_protect ();
217   log_info ("scdaemon finished\n");
218 #else
219   int wstatus;
220   pid_t pid = (pid_t)(uintptr_t)arg;
221
222  again:
223   npth_unprotect ();
224   err = waitpid (pid, &wstatus, 0);
225   npth_protect ();
226
227   if (err < 0)
228     {
229       if (errno == EINTR)
230         goto again;
231       log_error ("waitpid failed: %s\n", strerror (errno));
232       return NULL;
233     }
234   else
235     {
236       if (WIFEXITED (wstatus))
237         log_info ("scdaemon finished (status %d)\n", WEXITSTATUS (wstatus));
238       else if (WIFSIGNALED (wstatus))
239         log_info ("scdaemon killed by signal %d\n", WTERMSIG (wstatus));
240       else
241         {
242           if (WIFSTOPPED (wstatus))
243             log_info ("scdaemon stopped by signal %d\n", WSTOPSIG (wstatus));
244           goto again;
245         }
246     }
247 #endif
248
249   err = npth_mutex_lock (&start_scd_lock);
250   if (err)
251     {
252       log_error ("failed to acquire the start_scd lock: %s\n",
253                  strerror (err));
254     }
255   else
256     {
257       assuan_set_flag (primary_scd_ctx, ASSUAN_NO_WAITPID, 1);
258
259       for (sl = scd_local_list; sl; sl = sl->next_local)
260         {
261           sl->invalid = 1;
262           if (!sl->in_use && sl->ctx)
263             {
264               assuan_release (sl->ctx);
265               sl->ctx = NULL;
266             }
267         }
268
269       primary_scd_ctx = NULL;
270       primary_scd_ctx_reusable = 0;
271
272       xfree (socket_name);
273       socket_name = NULL;
274
275       err = npth_mutex_unlock (&start_scd_lock);
276       if (err)
277         log_error ("failed to release the start_scd lock after waitpid: %s\n",
278                    strerror (err));
279     }
280
281   return NULL;
282 }
283
284
285 /* Fork off the SCdaemon if this has not already been done.  Lock the
286    daemon and make sure that a proper context has been setup in CTRL.
287    This function might also lock the daemon, which means that the
288    caller must call unlock_scd after this function has returned
289    success and the actual Assuan transaction been done. */
290 static int
291 start_scd (ctrl_t ctrl)
292 {
293   gpg_error_t err = 0;
294   const char *pgmname;
295   assuan_context_t ctx = NULL;
296   const char *argv[5];
297   assuan_fd_t no_close_list[3];
298   int i;
299   int rc;
300   char *abs_homedir = NULL;
301
302   if (opt.disable_scdaemon)
303     return gpg_error (GPG_ERR_NOT_SUPPORTED);
304
305   if (ctrl->scd_local && ctrl->scd_local->ctx)
306     {
307       ctrl->scd_local->in_use = 1;
308       return 0; /* Okay, the context is fine.  */
309     }
310
311   if (ctrl->scd_local && ctrl->scd_local->in_use)
312     {
313       log_error ("start_scd: CTX is in use\n");
314       return gpg_error (GPG_ERR_INTERNAL);
315     }
316
317   /* We need to serialize the access to scd_local_list and primary_scd_ctx. */
318   rc = npth_mutex_lock (&start_scd_lock);
319   if (rc)
320     {
321       log_error ("failed to acquire the start_scd lock: %s\n",
322                  strerror (rc));
323       return gpg_error (GPG_ERR_INTERNAL);
324     }
325
326   /* If this is the first call for this session, setup the local data
327      structure. */
328   if (!ctrl->scd_local)
329     {
330       ctrl->scd_local = xtrycalloc (1, sizeof *ctrl->scd_local);
331       if (!ctrl->scd_local)
332         {
333           err = gpg_error_from_syserror ();
334           rc = npth_mutex_unlock (&start_scd_lock);
335           if (rc)
336             log_error ("failed to release the start_scd lock: %s\n", strerror (rc));
337           return err;
338         }
339       ctrl->scd_local->next_local = scd_local_list;
340       scd_local_list = ctrl->scd_local;
341     }
342
343   ctrl->scd_local->in_use = 1;
344
345   /* Check whether the pipe server has already been started and in
346      this case either reuse a lingering pipe connection or establish a
347      new socket based one. */
348   if (primary_scd_ctx && primary_scd_ctx_reusable)
349     {
350       ctx = primary_scd_ctx;
351       primary_scd_ctx_reusable = 0;
352       if (opt.verbose)
353         log_info ("new connection to SCdaemon established (reusing)\n");
354       goto leave;
355     }
356
357   rc = assuan_new (&ctx);
358   if (rc)
359     {
360       log_error ("can't allocate assuan context: %s\n", gpg_strerror (rc));
361       err = rc;
362       goto leave;
363     }
364
365   if (socket_name)
366     {
367       rc = assuan_socket_connect (ctx, socket_name, 0, 0);
368       if (rc)
369         {
370           log_error ("can't connect to socket '%s': %s\n",
371                      socket_name, gpg_strerror (rc));
372           err = gpg_error (GPG_ERR_NO_SCDAEMON);
373           goto leave;
374         }
375
376       if (opt.verbose)
377         log_info ("new connection to SCdaemon established\n");
378       goto leave;
379     }
380
381   if (primary_scd_ctx)
382     {
383       log_info ("SCdaemon is running but won't accept further connections\n");
384       err = gpg_error (GPG_ERR_NO_SCDAEMON);
385       goto leave;
386     }
387
388   /* Nope, it has not been started.  Fire it up now. */
389   if (opt.verbose)
390     log_info ("no running SCdaemon - starting it\n");
391
392   if (fflush (NULL))
393     {
394 #ifndef HAVE_W32_SYSTEM
395       err = gpg_error_from_syserror ();
396 #endif
397       log_error ("error flushing pending output: %s\n", strerror (errno));
398       /* At least Windows XP fails here with EBADF.  According to docs
399          and Wine an fflush(NULL) is the same as _flushall.  However
400          the Wime implementation does not flush stdin,stdout and stderr
401          - see above.  Lets try to ignore the error. */
402 #ifndef HAVE_W32_SYSTEM
403       goto leave;
404 #endif
405     }
406
407   if (!opt.scdaemon_program || !*opt.scdaemon_program)
408     opt.scdaemon_program = gnupg_module_name (GNUPG_MODULE_NAME_SCDAEMON);
409   if ( !(pgmname = strrchr (opt.scdaemon_program, '/')))
410     pgmname = opt.scdaemon_program;
411   else
412     pgmname++;
413
414   argv[0] = pgmname;
415   argv[1] = "--multi-server";
416   if (gnupg_default_homedir_p ())
417     argv[2] = NULL;
418   else
419     {
420       abs_homedir = make_absfilename_try (gnupg_homedir (), NULL);
421       if (!abs_homedir)
422         {
423           log_error ("error building filename: %s\n",
424                      gpg_strerror (gpg_error_from_syserror ()));
425           goto leave;
426         }
427
428       argv[2] = "--homedir";
429       argv[3] = abs_homedir;
430       argv[4] = NULL;
431     }
432
433   i=0;
434   if (!opt.running_detached)
435     {
436       if (log_get_fd () != -1)
437         no_close_list[i++] = assuan_fd_from_posix_fd (log_get_fd ());
438       no_close_list[i++] = assuan_fd_from_posix_fd (fileno (stderr));
439     }
440   no_close_list[i] = ASSUAN_INVALID_FD;
441
442   /* Connect to the scdaemon and perform initial handshaking.  Use
443      detached flag so that under Windows SCDAEMON does not show up a
444      new window.  */
445   rc = assuan_pipe_connect (ctx, opt.scdaemon_program, argv,
446                             no_close_list, atfork_cb, NULL,
447                             ASSUAN_PIPE_CONNECT_DETACHED);
448   if (rc)
449     {
450       log_error ("can't connect to the SCdaemon: %s\n",
451                  gpg_strerror (rc));
452       err = gpg_error (GPG_ERR_NO_SCDAEMON);
453       goto leave;
454     }
455
456   if (opt.verbose)
457     log_debug ("first connection to SCdaemon established\n");
458
459
460   /* Get the name of the additional socket opened by scdaemon. */
461   {
462     membuf_t data;
463     unsigned char *databuf;
464     size_t datalen;
465
466     xfree (socket_name);
467     socket_name = NULL;
468     init_membuf (&data, 256);
469     assuan_transact (ctx, "GETINFO socket_name",
470                      put_membuf_cb, &data, NULL, NULL, NULL, NULL);
471
472     databuf = get_membuf (&data, &datalen);
473     if (databuf && datalen)
474       {
475         socket_name = xtrymalloc (datalen + 1);
476         if (!socket_name)
477           log_error ("warning: can't store socket name: %s\n",
478                      strerror (errno));
479         else
480           {
481             memcpy (socket_name, databuf, datalen);
482             socket_name[datalen] = 0;
483             if (DBG_IPC)
484               log_debug ("additional connections at '%s'\n", socket_name);
485           }
486       }
487     xfree (databuf);
488   }
489
490   /* Tell the scdaemon we want him to send us an event signal.  We
491      don't support this for W32CE.  */
492 #ifndef HAVE_W32CE_SYSTEM
493   if (opt.sigusr2_enabled)
494     {
495       char buf[100];
496
497 #ifdef HAVE_W32_SYSTEM
498       snprintf (buf, sizeof buf, "OPTION event-signal=%p",
499                 get_agent_scd_notify_event ());
500 #else
501       snprintf (buf, sizeof buf, "OPTION event-signal=%d", SIGUSR2);
502 #endif
503       assuan_transact (ctx, buf, NULL, NULL, NULL, NULL, NULL, NULL);
504     }
505 #endif /*HAVE_W32CE_SYSTEM*/
506
507   primary_scd_ctx = ctx;
508   primary_scd_ctx_reusable = 0;
509
510   {
511     npth_t thread;
512     npth_attr_t tattr;
513     pid_t pid;
514
515     pid = assuan_get_pid (primary_scd_ctx);
516     err = npth_attr_init (&tattr);
517     if (!err)
518       {
519         npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
520         err = npth_create (&thread, &tattr, wait_child_thread,
521                            (void *)(uintptr_t)pid);
522         if (err)
523           log_error ("error spawning wait_child_thread: %s\n", strerror (err));
524         npth_attr_destroy (&tattr);
525       }
526   }
527
528  leave:
529   rc = npth_mutex_unlock (&start_scd_lock);
530   if (rc)
531     log_error ("failed to release the start_scd lock: %s\n", strerror (rc));
532
533   xfree (abs_homedir);
534   if (err)
535     {
536       unlock_scd (ctrl, err);
537       if (ctx)
538         assuan_release (ctx);
539     }
540   else
541     {
542       ctrl->scd_local->invalid = 0;
543       ctrl->scd_local->ctx = ctx;
544     }
545   return err;
546 }
547
548
549 /* Check whether the SCdaemon is active.  This is a fast check without
550    any locking and might give a wrong result if another thread is about
551    to start the daemon or the daemon is about to be stopped.. */
552 int
553 agent_scd_check_running (void)
554 {
555   return !!primary_scd_ctx;
556 }
557
558
559 /* Reset the SCD if it has been used.  Actually it is not a reset but
560    a cleanup of resources used by the current connection. */
561 int
562 agent_reset_scd (ctrl_t ctrl)
563 {
564   int err = npth_mutex_lock (&start_scd_lock);
565
566   if (err)
567     {
568       log_error ("failed to acquire the start_scd lock: %s\n",
569                  strerror (err));
570     }
571   else
572     {
573       if (ctrl->scd_local)
574         {
575           if (ctrl->scd_local->ctx)
576             {
577               /* We send a reset and keep that connection for reuse. */
578               if (ctrl->scd_local->ctx == primary_scd_ctx)
579                 {
580                   /* Send a RESTART to the SCD.  This is required for the
581                      primary connection as a kind of virtual EOF; we don't
582                      have another way to tell it that the next command
583                      should be viewed as if a new connection has been
584                      made.  For the non-primary connections this is not
585                      needed as we simply close the socket.  We don't check
586                      for an error here because the RESTART may fail for
587                      example if the scdaemon has already been terminated.
588                      Anyway, we need to set the reusable flag to make sure
589                      that the aliveness check can clean it up. */
590                   assuan_transact (primary_scd_ctx, "RESTART",
591                                    NULL, NULL, NULL, NULL, NULL, NULL);
592                   primary_scd_ctx_reusable = 1;
593                 }
594               else
595                 assuan_release (ctrl->scd_local->ctx);
596               ctrl->scd_local->ctx = NULL;
597             }
598
599           /* Remove the local context from our list and release it. */
600           if (!scd_local_list)
601             BUG ();
602           else if (scd_local_list == ctrl->scd_local)
603             scd_local_list = ctrl->scd_local->next_local;
604           else
605             {
606               struct scd_local_s *sl;
607
608               for (sl=scd_local_list; sl->next_local; sl = sl->next_local)
609                 if (sl->next_local == ctrl->scd_local)
610                   break;
611               if (!sl->next_local)
612                 BUG ();
613               sl->next_local = ctrl->scd_local->next_local;
614             }
615           xfree (ctrl->scd_local);
616           ctrl->scd_local = NULL;
617         }
618
619       err = npth_mutex_unlock (&start_scd_lock);
620       if (err)
621         log_error ("failed to release the start_scd lock: %s\n", strerror (err));
622     }
623
624   return 0;
625 }
626
627
628 \f
629 static gpg_error_t
630 learn_status_cb (void *opaque, const char *line)
631 {
632   struct learn_parm_s *parm = opaque;
633   const char *keyword = line;
634   int keywordlen;
635
636   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
637     ;
638   while (spacep (line))
639     line++;
640   if (keywordlen == 8 && !memcmp (keyword, "CERTINFO", keywordlen))
641     {
642       parm->certinfo_cb (parm->certinfo_cb_arg, line);
643     }
644   else if (keywordlen == 11 && !memcmp (keyword, "KEYPAIRINFO", keywordlen))
645     {
646       parm->kpinfo_cb (parm->kpinfo_cb_arg, line);
647     }
648   else if (keywordlen && *line)
649     {
650       parm->sinfo_cb (parm->sinfo_cb_arg, keyword, keywordlen, line);
651     }
652
653   return 0;
654 }
655
656 /* Perform the LEARN command and return a list of all private keys
657    stored on the card. */
658 int
659 agent_card_learn (ctrl_t ctrl,
660                   void (*kpinfo_cb)(void*, const char *),
661                   void *kpinfo_cb_arg,
662                   void (*certinfo_cb)(void*, const char *),
663                   void *certinfo_cb_arg,
664                   void (*sinfo_cb)(void*, const char *, size_t, const char *),
665                   void *sinfo_cb_arg)
666 {
667   int rc;
668   struct learn_parm_s parm;
669
670   rc = start_scd (ctrl);
671   if (rc)
672     return rc;
673
674   memset (&parm, 0, sizeof parm);
675   parm.kpinfo_cb = kpinfo_cb;
676   parm.kpinfo_cb_arg = kpinfo_cb_arg;
677   parm.certinfo_cb = certinfo_cb;
678   parm.certinfo_cb_arg = certinfo_cb_arg;
679   parm.sinfo_cb = sinfo_cb;
680   parm.sinfo_cb_arg = sinfo_cb_arg;
681   rc = assuan_transact (ctrl->scd_local->ctx, "LEARN --force",
682                         NULL, NULL, NULL, NULL,
683                         learn_status_cb, &parm);
684   if (rc)
685     return unlock_scd (ctrl, rc);
686
687   return unlock_scd (ctrl, 0);
688 }
689
690
691 \f
692 static gpg_error_t
693 get_serialno_cb (void *opaque, const char *line)
694 {
695   char **serialno = opaque;
696   const char *keyword = line;
697   const char *s;
698   int keywordlen, n;
699
700   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
701     ;
702   while (spacep (line))
703     line++;
704
705   if (keywordlen == 8 && !memcmp (keyword, "SERIALNO", keywordlen))
706     {
707       if (*serialno)
708         return gpg_error (GPG_ERR_CONFLICT); /* Unexpected status line. */
709       for (n=0,s=line; hexdigitp (s); s++, n++)
710         ;
711       if (!n || (n&1)|| !(spacep (s) || !*s) )
712         return gpg_error (GPG_ERR_ASS_PARAMETER);
713       *serialno = xtrymalloc (n+1);
714       if (!*serialno)
715         return out_of_core ();
716       memcpy (*serialno, line, n);
717       (*serialno)[n] = 0;
718     }
719
720   return 0;
721 }
722
723 /* Return the serial number of the card or an appropriate error.  The
724    serial number is returned as a hexstring. */
725 int
726 agent_card_serialno (ctrl_t ctrl, char **r_serialno, const char *demand)
727 {
728   int rc;
729   char *serialno = NULL;
730   char line[ASSUAN_LINELENGTH];
731
732   rc = start_scd (ctrl);
733   if (rc)
734     return rc;
735
736   if (!demand)
737     strcpy (line, "SERIALNO");
738   else
739     snprintf (line, DIM(line), "SERIALNO --demand=%s", demand);
740
741   rc = assuan_transact (ctrl->scd_local->ctx, line,
742                         NULL, NULL, NULL, NULL,
743                         get_serialno_cb, &serialno);
744   if (rc)
745     {
746       xfree (serialno);
747       return unlock_scd (ctrl, rc);
748     }
749   *r_serialno = serialno;
750   return unlock_scd (ctrl, 0);
751 }
752
753
754
755 \f
756 /* Handle the NEEDPIN inquiry. */
757 static gpg_error_t
758 inq_needpin (void *opaque, const char *line)
759 {
760   struct inq_needpin_parm_s *parm = opaque;
761   const char *s;
762   char *pin;
763   size_t pinlen;
764   int rc;
765
766   if ((s = has_leading_keyword (line, "NEEDPIN")))
767     {
768       line = s;
769       pinlen = 90;
770       pin = gcry_malloc_secure (pinlen);
771       if (!pin)
772         return out_of_core ();
773
774       rc = parm->getpin_cb (parm->getpin_cb_arg, parm->getpin_cb_desc,
775                             line, pin, pinlen);
776       if (!rc)
777         rc = assuan_send_data (parm->ctx, pin, pinlen);
778       xfree (pin);
779     }
780   else if ((s = has_leading_keyword (line, "POPUPPINPADPROMPT")))
781     {
782       rc = parm->getpin_cb (parm->getpin_cb_arg, parm->getpin_cb_desc,
783                             s, NULL, 1);
784     }
785   else if ((s = has_leading_keyword (line, "DISMISSPINPADPROMPT")))
786     {
787       rc = parm->getpin_cb (parm->getpin_cb_arg, parm->getpin_cb_desc,
788                             "", NULL, 0);
789     }
790   else if (parm->passthru)
791     {
792       unsigned char *value;
793       size_t valuelen;
794       int rest;
795       int needrest = !strncmp (line, "KEYDATA", 8);
796
797       /* Pass the inquiry up to our caller.  We limit the maximum
798          amount to an arbitrary value.  As we know that the KEYDATA
799          enquiry is pretty sensitive we disable logging then */
800       if ((rest = (needrest
801                    && !assuan_get_flag (parm->passthru, ASSUAN_CONFIDENTIAL))))
802         assuan_begin_confidential (parm->passthru);
803       rc = assuan_inquire (parm->passthru, line, &value, &valuelen, 8096);
804       if (rest)
805         assuan_end_confidential (parm->passthru);
806       if (!rc)
807         {
808           if ((rest = (needrest
809                        && !assuan_get_flag (parm->ctx, ASSUAN_CONFIDENTIAL))))
810             assuan_begin_confidential (parm->ctx);
811           rc = assuan_send_data (parm->ctx, value, valuelen);
812           if (rest)
813             assuan_end_confidential (parm->ctx);
814           xfree (value);
815         }
816       else
817         log_error ("error forwarding inquiry '%s': %s\n",
818                    line, gpg_strerror (rc));
819     }
820   else
821     {
822       log_error ("unsupported inquiry '%s'\n", line);
823       rc = gpg_error (GPG_ERR_ASS_UNKNOWN_INQUIRE);
824     }
825
826   return rc;
827 }
828
829
830 /* Helper returning a command option to describe the used hash
831    algorithm.  See scd/command.c:cmd_pksign.  */
832 static const char *
833 hash_algo_option (int algo)
834 {
835   switch (algo)
836     {
837     case GCRY_MD_MD5   : return "--hash=md5";
838     case GCRY_MD_RMD160: return "--hash=rmd160";
839     case GCRY_MD_SHA1  : return "--hash=sha1";
840     case GCRY_MD_SHA224: return "--hash=sha224";
841     case GCRY_MD_SHA256: return "--hash=sha256";
842     case GCRY_MD_SHA384: return "--hash=sha384";
843     case GCRY_MD_SHA512: return "--hash=sha512";
844     default:             return "";
845     }
846 }
847
848
849 /* Create a signature using the current card.  MDALGO is either 0 or
850  * gives the digest algorithm.  DESC_TEXT is an additional parameter
851  * passed to GETPIN_CB. */
852 int
853 agent_card_pksign (ctrl_t ctrl,
854                    const char *keyid,
855                    int (*getpin_cb)(void *, const char *,
856                                     const char *, char*, size_t),
857                    void *getpin_cb_arg,
858                    const char *desc_text,
859                    int mdalgo,
860                    const unsigned char *indata, size_t indatalen,
861                    unsigned char **r_buf, size_t *r_buflen)
862 {
863   int rc;
864   char line[ASSUAN_LINELENGTH];
865   membuf_t data;
866   struct inq_needpin_parm_s inqparm;
867
868   *r_buf = NULL;
869   rc = start_scd (ctrl);
870   if (rc)
871     return rc;
872
873   if (indatalen*2 + 50 > DIM(line))
874     return unlock_scd (ctrl, gpg_error (GPG_ERR_GENERAL));
875
876   bin2hex (indata, indatalen, stpcpy (line, "SETDATA "));
877
878   rc = assuan_transact (ctrl->scd_local->ctx, line,
879                         NULL, NULL, NULL, NULL, NULL, NULL);
880   if (rc)
881     return unlock_scd (ctrl, rc);
882
883   init_membuf (&data, 1024);
884   inqparm.ctx = ctrl->scd_local->ctx;
885   inqparm.getpin_cb = getpin_cb;
886   inqparm.getpin_cb_arg = getpin_cb_arg;
887   inqparm.getpin_cb_desc = desc_text;
888   inqparm.passthru = 0;
889   inqparm.keydata = NULL;
890   inqparm.keydatalen = 0;
891
892   if (ctrl->use_auth_call)
893     snprintf (line, sizeof line, "PKAUTH %s", keyid);
894   else
895     snprintf (line, sizeof line, "PKSIGN %s %s",
896               hash_algo_option (mdalgo), keyid);
897   rc = assuan_transact (ctrl->scd_local->ctx, line,
898                         put_membuf_cb, &data,
899                         inq_needpin, &inqparm,
900                         NULL, NULL);
901
902   if (rc)
903     {
904       size_t len;
905
906       xfree (get_membuf (&data, &len));
907       return unlock_scd (ctrl, rc);
908     }
909
910   *r_buf = get_membuf (&data, r_buflen);
911   return unlock_scd (ctrl, 0);
912 }
913
914
915
916 \f
917 /* Check whether there is any padding info from scdaemon.  */
918 static gpg_error_t
919 padding_info_cb (void *opaque, const char *line)
920 {
921   int *r_padding = opaque;
922   const char *s;
923
924   if ((s=has_leading_keyword (line, "PADDING")))
925     {
926       *r_padding = atoi (s);
927     }
928
929   return 0;
930 }
931
932
933 /* Decipher INDATA using the current card.  Note that the returned
934  * value is not an s-expression but the raw data as returned by
935  * scdaemon.  The padding information is stored at R_PADDING with -1
936  * for not known.  DESC_TEXT is an additional parameter passed to
937  * GETPIN_CB.  */
938 int
939 agent_card_pkdecrypt (ctrl_t ctrl,
940                       const char *keyid,
941                       int (*getpin_cb)(void *, const char *,
942                                        const char *, char*, size_t),
943                       void *getpin_cb_arg,
944                       const char *desc_text,
945                       const unsigned char *indata, size_t indatalen,
946                       char **r_buf, size_t *r_buflen, int *r_padding)
947 {
948   int rc, i;
949   char *p, line[ASSUAN_LINELENGTH];
950   membuf_t data;
951   struct inq_needpin_parm_s inqparm;
952   size_t len;
953
954   *r_buf = NULL;
955   *r_padding = -1; /* Unknown.  */
956   rc = start_scd (ctrl);
957   if (rc)
958     return rc;
959
960   /* FIXME: use secure memory where appropriate */
961
962   for (len = 0; len < indatalen;)
963     {
964       p = stpcpy (line, "SETDATA ");
965       if (len)
966         p = stpcpy (p, "--append ");
967       for (i=0; len < indatalen && (i*2 < DIM(line)-50); i++, len++)
968         {
969           sprintf (p, "%02X", indata[len]);
970           p += 2;
971         }
972       rc = assuan_transact (ctrl->scd_local->ctx, line,
973                             NULL, NULL, NULL, NULL, NULL, NULL);
974       if (rc)
975         return unlock_scd (ctrl, rc);
976     }
977
978   init_membuf (&data, 1024);
979   inqparm.ctx = ctrl->scd_local->ctx;
980   inqparm.getpin_cb = getpin_cb;
981   inqparm.getpin_cb_arg = getpin_cb_arg;
982   inqparm.getpin_cb_desc = desc_text;
983   inqparm.passthru = 0;
984   inqparm.keydata = NULL;
985   inqparm.keydatalen = 0;
986   snprintf (line, DIM(line), "PKDECRYPT %s", keyid);
987   rc = assuan_transact (ctrl->scd_local->ctx, line,
988                         put_membuf_cb, &data,
989                         inq_needpin, &inqparm,
990                         padding_info_cb, r_padding);
991
992   if (rc)
993     {
994       xfree (get_membuf (&data, &len));
995       return unlock_scd (ctrl, rc);
996     }
997   *r_buf = get_membuf (&data, r_buflen);
998   if (!*r_buf)
999     return unlock_scd (ctrl, gpg_error (GPG_ERR_ENOMEM));
1000
1001   return unlock_scd (ctrl, 0);
1002 }
1003
1004
1005 \f
1006 /* Read a certificate with ID into R_BUF and R_BUFLEN. */
1007 int
1008 agent_card_readcert (ctrl_t ctrl,
1009                      const char *id, char **r_buf, size_t *r_buflen)
1010 {
1011   int rc;
1012   char line[ASSUAN_LINELENGTH];
1013   membuf_t data;
1014   size_t len;
1015
1016   *r_buf = NULL;
1017   rc = start_scd (ctrl);
1018   if (rc)
1019     return rc;
1020
1021   init_membuf (&data, 1024);
1022   snprintf (line, DIM(line), "READCERT %s", id);
1023   rc = assuan_transact (ctrl->scd_local->ctx, line,
1024                         put_membuf_cb, &data,
1025                         NULL, NULL,
1026                         NULL, NULL);
1027   if (rc)
1028     {
1029       xfree (get_membuf (&data, &len));
1030       return unlock_scd (ctrl, rc);
1031     }
1032   *r_buf = get_membuf (&data, r_buflen);
1033   if (!*r_buf)
1034     return unlock_scd (ctrl, gpg_error (GPG_ERR_ENOMEM));
1035
1036   return unlock_scd (ctrl, 0);
1037 }
1038
1039
1040 \f
1041 /* Read a key with ID and return it in an allocate buffer pointed to
1042    by r_BUF as a valid S-expression. */
1043 int
1044 agent_card_readkey (ctrl_t ctrl, const char *id, unsigned char **r_buf)
1045 {
1046   int rc;
1047   char line[ASSUAN_LINELENGTH];
1048   membuf_t data;
1049   size_t len, buflen;
1050
1051   *r_buf = NULL;
1052   rc = start_scd (ctrl);
1053   if (rc)
1054     return rc;
1055
1056   init_membuf (&data, 1024);
1057   snprintf (line, DIM(line), "READKEY %s", id);
1058   rc = assuan_transact (ctrl->scd_local->ctx, line,
1059                         put_membuf_cb, &data,
1060                         NULL, NULL,
1061                         NULL, NULL);
1062   if (rc)
1063     {
1064       xfree (get_membuf (&data, &len));
1065       return unlock_scd (ctrl, rc);
1066     }
1067   *r_buf = get_membuf (&data, &buflen);
1068   if (!*r_buf)
1069     return unlock_scd (ctrl, gpg_error (GPG_ERR_ENOMEM));
1070
1071   if (!gcry_sexp_canon_len (*r_buf, buflen, NULL, NULL))
1072     {
1073       xfree (*r_buf); *r_buf = NULL;
1074       return unlock_scd (ctrl, gpg_error (GPG_ERR_INV_VALUE));
1075     }
1076
1077   return unlock_scd (ctrl, 0);
1078 }
1079
1080
1081 /* Handle a KEYDATA inquiry.  Note, we only send the data,
1082    assuan_transact takes care of flushing and writing the end */
1083 static gpg_error_t
1084 inq_writekey_parms (void *opaque, const char *line)
1085 {
1086   struct inq_needpin_parm_s *parm = opaque;
1087
1088   if (has_leading_keyword (line, "KEYDATA"))
1089     return assuan_send_data (parm->ctx, parm->keydata, parm->keydatalen);
1090   else
1091     return inq_needpin (opaque, line);
1092 }
1093
1094
1095 /* Call scd to write a key to a card under the id KEYREF.  */
1096 gpg_error_t
1097 agent_card_writekey (ctrl_t ctrl,  int force, const char *serialno,
1098                      const char *keyref,
1099                      const char *keydata, size_t keydatalen,
1100                      int (*getpin_cb)(void *, const char *,
1101                                       const char *, char*, size_t),
1102                      void *getpin_cb_arg)
1103 {
1104   gpg_error_t err;
1105   char line[ASSUAN_LINELENGTH];
1106   struct inq_needpin_parm_s parms;
1107
1108   (void)serialno; /* NULL or a number to check for the correct card.
1109                    * But is is not implemented.  */
1110
1111   err = start_scd (ctrl);
1112   if (err)
1113     return err;
1114
1115   snprintf (line, DIM(line), "WRITEKEY %s%s", force ? "--force " : "", keyref);
1116   parms.ctx = ctrl->scd_local->ctx;
1117   parms.getpin_cb = getpin_cb;
1118   parms.getpin_cb_arg = getpin_cb_arg;
1119   parms.getpin_cb_desc= NULL;
1120   parms.passthru = 0;
1121   parms.keydata = keydata;
1122   parms.keydatalen = keydatalen;
1123
1124   err = assuan_transact (ctrl->scd_local->ctx, line, NULL, NULL,
1125                          inq_writekey_parms, &parms, NULL, NULL);
1126   return unlock_scd (ctrl, err);
1127 }
1128
1129
1130 \f
1131 /* Type used with the card_getattr_cb.  */
1132 struct card_getattr_parm_s {
1133   const char *keyword;  /* Keyword to look for.  */
1134   size_t keywordlen;    /* strlen of KEYWORD.  */
1135   char *data;           /* Malloced and unescaped data.  */
1136   int error;            /* ERRNO value or 0 on success. */
1137 };
1138
1139 /* Callback function for agent_card_getattr.  */
1140 static gpg_error_t
1141 card_getattr_cb (void *opaque, const char *line)
1142 {
1143   struct card_getattr_parm_s *parm = opaque;
1144   const char *keyword = line;
1145   int keywordlen;
1146
1147   if (parm->data)
1148     return 0; /* We want only the first occurrence.  */
1149
1150   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
1151     ;
1152   while (spacep (line))
1153     line++;
1154
1155   if (keywordlen == parm->keywordlen
1156       && !memcmp (keyword, parm->keyword, keywordlen))
1157     {
1158       parm->data = percent_plus_unescape ((const unsigned char*)line, 0xff);
1159       if (!parm->data)
1160         parm->error = errno;
1161     }
1162
1163   return 0;
1164 }
1165
1166
1167 /* Call the agent to retrieve a single line data object. On success
1168    the object is malloced and stored at RESULT; it is guaranteed that
1169    NULL is never stored in this case.  On error an error code is
1170    returned and NULL stored at RESULT. */
1171 gpg_error_t
1172 agent_card_getattr (ctrl_t ctrl, const char *name, char **result)
1173 {
1174   int err;
1175   struct card_getattr_parm_s parm;
1176   char line[ASSUAN_LINELENGTH];
1177
1178   *result = NULL;
1179
1180   if (!*name)
1181     return gpg_error (GPG_ERR_INV_VALUE);
1182
1183   memset (&parm, 0, sizeof parm);
1184   parm.keyword = name;
1185   parm.keywordlen = strlen (name);
1186
1187   /* We assume that NAME does not need escaping. */
1188   if (8 + strlen (name) > DIM(line)-1)
1189     return gpg_error (GPG_ERR_TOO_LARGE);
1190   stpcpy (stpcpy (line, "GETATTR "), name);
1191
1192   err = start_scd (ctrl);
1193   if (err)
1194     return err;
1195
1196   err = assuan_transact (ctrl->scd_local->ctx, line,
1197                          NULL, NULL, NULL, NULL,
1198                          card_getattr_cb, &parm);
1199   if (!err && parm.error)
1200     err = gpg_error_from_errno (parm.error);
1201
1202   if (!err && !parm.data)
1203     err = gpg_error (GPG_ERR_NO_DATA);
1204
1205   if (!err)
1206     *result = parm.data;
1207   else
1208     xfree (parm.data);
1209
1210   return unlock_scd (ctrl, err);
1211 }
1212
1213
1214 \f
1215 struct card_cardlist_parm_s {
1216   int error;
1217   strlist_t list;
1218 };
1219
1220 /* Callback function for agent_card_cardlist.  */
1221 static gpg_error_t
1222 card_cardlist_cb (void *opaque, const char *line)
1223 {
1224   struct card_cardlist_parm_s *parm = opaque;
1225   const char *keyword = line;
1226   int keywordlen;
1227
1228   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
1229     ;
1230   while (spacep (line))
1231     line++;
1232
1233   if (keywordlen == 8 && !memcmp (keyword, "SERIALNO", keywordlen))
1234     {
1235       const char *s;
1236       int n;
1237
1238       for (n=0,s=line; hexdigitp (s); s++, n++)
1239         ;
1240
1241       if (!n || (n&1) || *s)
1242         parm->error = gpg_error (GPG_ERR_ASS_PARAMETER);
1243       else
1244         add_to_strlist (&parm->list, line);
1245     }
1246
1247   return 0;
1248 }
1249
1250 /* Call the scdaemon to retrieve list of available cards. On success
1251    the allocated strlist is stored at RESULT.  On error an error code is
1252    returned and NULL stored at RESULT. */
1253 gpg_error_t
1254 agent_card_cardlist (ctrl_t ctrl, strlist_t *result)
1255 {
1256   int err;
1257   struct card_cardlist_parm_s parm;
1258   char line[ASSUAN_LINELENGTH];
1259
1260   *result = NULL;
1261
1262   memset (&parm, 0, sizeof parm);
1263   strcpy (line, "GETINFO card_list");
1264
1265   err = start_scd (ctrl);
1266   if (err)
1267     return err;
1268
1269   err = assuan_transact (ctrl->scd_local->ctx, line,
1270                          NULL, NULL, NULL, NULL,
1271                          card_cardlist_cb, &parm);
1272   if (!err && parm.error)
1273     err = parm.error;
1274
1275   if (!err)
1276     *result = parm.list;
1277   else
1278     free_strlist (parm.list);
1279
1280   return unlock_scd (ctrl, err);
1281 }
1282
1283
1284 struct card_keyinfo_parm_s {
1285   int error;
1286   struct card_key_info_s *list;
1287 };
1288
1289 /* Callback function for agent_card_keylist.  */
1290 static gpg_error_t
1291 card_keyinfo_cb (void *opaque, const char *line)
1292 {
1293   struct card_keyinfo_parm_s *parm = opaque;
1294   const char *keyword = line;
1295   int keywordlen;
1296
1297   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
1298     ;
1299   while (spacep (line))
1300     line++;
1301
1302   if (keywordlen == 7 && !memcmp (keyword, "KEYINFO", keywordlen))
1303     {
1304       const char *s;
1305       int n;
1306       struct card_key_info_s *keyinfo;
1307       struct card_key_info_s **l_p = &parm->list;
1308
1309       while ((*l_p))
1310         l_p = &(*l_p)->next;
1311
1312       keyinfo = xtrycalloc (1, sizeof *keyinfo);
1313       if (!keyinfo)
1314         {
1315         alloc_error:
1316           if (!parm->error)
1317             parm->error = gpg_error_from_syserror ();
1318           return 0;
1319         }
1320
1321       for (n=0,s=line; hexdigitp (s); s++, n++)
1322         ;
1323
1324       if (n != 40)
1325         {
1326         parm_error:
1327           if (!parm->error)
1328             parm->error = gpg_error (GPG_ERR_ASS_PARAMETER);
1329           return 0;
1330         }
1331
1332       memcpy (keyinfo->keygrip, line, 40);
1333
1334       line = s;
1335
1336       if (!*line)
1337         goto parm_error;
1338
1339       while (spacep (line))
1340         line++;
1341
1342       if (*line++ != 'T')
1343         goto parm_error;
1344
1345       if (!*line)
1346         goto parm_error;
1347
1348       while (spacep (line))
1349         line++;
1350
1351       for (n=0,s=line; hexdigitp (s); s++, n++)
1352         ;
1353
1354       if (!n)
1355         goto parm_error;
1356
1357       keyinfo->serialno = xtrymalloc (n+1);
1358       if (!keyinfo->serialno)
1359         goto alloc_error;
1360
1361       memcpy (keyinfo->serialno, line, n);
1362       keyinfo->serialno[n] = 0;
1363
1364       line = s;
1365
1366       if (!*line)
1367         goto parm_error;
1368
1369       while (spacep (line))
1370         line++;
1371
1372       if (!*line)
1373         goto parm_error;
1374
1375       keyinfo->idstr = xtrystrdup (line);
1376       if (!keyinfo->idstr)
1377         goto alloc_error;
1378
1379       *l_p = keyinfo;
1380     }
1381
1382   return 0;
1383 }
1384
1385
1386 void
1387 agent_card_free_keyinfo (struct card_key_info_s *l)
1388 {
1389   struct card_key_info_s *l_next;
1390
1391   for (; l; l = l_next)
1392     {
1393       l_next = l->next;
1394       free (l->serialno);
1395       free (l->idstr);
1396       free (l);
1397     }
1398 }
1399
1400 /* Call the scdaemon to check if a key of KEYGRIP is available, or
1401    retrieve list of available keys on cards. On success the allocated
1402    structure is stored at RESULT.  On error an error code is returned
1403    and NULL is stored at RESULT.  */
1404 gpg_error_t
1405 agent_card_keyinfo (ctrl_t ctrl, const char *keygrip,
1406                     struct card_key_info_s **result)
1407 {
1408   int err;
1409   struct card_keyinfo_parm_s parm;
1410   char line[ASSUAN_LINELENGTH];
1411
1412   *result = NULL;
1413
1414   memset (&parm, 0, sizeof parm);
1415   snprintf (line, sizeof line, "KEYINFO %s", keygrip ? keygrip : "--list");
1416
1417   err = start_scd (ctrl);
1418   if (err)
1419     return err;
1420
1421   err = assuan_transact (ctrl->scd_local->ctx, line,
1422                          NULL, NULL, NULL, NULL,
1423                          card_keyinfo_cb, &parm);
1424   if (!err && parm.error)
1425     err = parm.error;
1426
1427   if (!err)
1428     *result = parm.list;
1429   else
1430     agent_card_free_keyinfo (parm.list);
1431
1432   return unlock_scd (ctrl, err);
1433 }
1434 \f
1435 static gpg_error_t
1436 pass_status_thru (void *opaque, const char *line)
1437 {
1438   assuan_context_t ctx = opaque;
1439   char keyword[200];
1440   int i;
1441
1442   if (line[0] == '#' && (!line[1] || spacep (line+1)))
1443     {
1444       /* We are called in convey comments mode.  Now, if we see a
1445          comment marker as keyword we forward the line verbatim to the
1446          the caller.  This way the comment lines from scdaemon won't
1447          appear as status lines with keyword '#'.  */
1448       assuan_write_line (ctx, line);
1449     }
1450   else
1451     {
1452       for (i=0; *line && !spacep (line) && i < DIM(keyword)-1; line++, i++)
1453         keyword[i] = *line;
1454       keyword[i] = 0;
1455
1456       /* Truncate any remaining keyword stuff.  */
1457       for (; *line && !spacep (line); line++)
1458         ;
1459       while (spacep (line))
1460         line++;
1461
1462       assuan_write_status (ctx, keyword, line);
1463     }
1464   return 0;
1465 }
1466
1467 static gpg_error_t
1468 pass_data_thru (void *opaque, const void *buffer, size_t length)
1469 {
1470   assuan_context_t ctx = opaque;
1471
1472   assuan_send_data (ctx, buffer, length);
1473   return 0;
1474 }
1475
1476
1477 /* Send the line CMDLINE with command for the SCDdaemon to it and send
1478    all status messages back.  This command is used as a general quoting
1479    mechanism to pass everything verbatim to SCDAEMON.  The PIN
1480    inquiry is handled inside gpg-agent.  */
1481 int
1482 agent_card_scd (ctrl_t ctrl, const char *cmdline,
1483                 int (*getpin_cb)(void *, const char *,
1484                                  const char *, char*, size_t),
1485                 void *getpin_cb_arg, void *assuan_context)
1486 {
1487   int rc;
1488   struct inq_needpin_parm_s inqparm;
1489   int saveflag;
1490
1491   rc = start_scd (ctrl);
1492   if (rc)
1493     return rc;
1494
1495   inqparm.ctx = ctrl->scd_local->ctx;
1496   inqparm.getpin_cb = getpin_cb;
1497   inqparm.getpin_cb_arg = getpin_cb_arg;
1498   inqparm.getpin_cb_desc = NULL;
1499   inqparm.passthru = assuan_context;
1500   inqparm.keydata = NULL;
1501   inqparm.keydatalen = 0;
1502
1503   saveflag = assuan_get_flag (ctrl->scd_local->ctx, ASSUAN_CONVEY_COMMENTS);
1504   assuan_set_flag (ctrl->scd_local->ctx, ASSUAN_CONVEY_COMMENTS, 1);
1505   rc = assuan_transact (ctrl->scd_local->ctx, cmdline,
1506                         pass_data_thru, assuan_context,
1507                         inq_needpin, &inqparm,
1508                         pass_status_thru, assuan_context);
1509
1510   assuan_set_flag (ctrl->scd_local->ctx, ASSUAN_CONVEY_COMMENTS, saveflag);
1511   if (rc)
1512     {
1513       return unlock_scd (ctrl, rc);
1514     }
1515
1516   return unlock_scd (ctrl, 0);
1517 }
1518
1519 void
1520 agent_card_killscd (void)
1521 {
1522   if (primary_scd_ctx == NULL)
1523     return;
1524   assuan_transact (primary_scd_ctx, "KILLSCD",
1525                    NULL, NULL, NULL, NULL, NULL, NULL);
1526 }