* query.c (initialize_module_query):
[gnupg.git] / agent / call-scd.c
1 /* call-scd.c - fork of the scdaemon to do SC operations
2  *      Copyright (C) 2001, 2002 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21 /* Fixme: For now we have serialized all access to the scdaemon which
22    make sense becuase the scdaemon can't handle concurrent connections
23    right now.  We should however keep a list of connections and lock
24    just that connection - it migth make sense to implemtn parts of
25    this in Assuan.*/
26
27 #include <config.h>
28 #include <errno.h>
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <string.h>
32 #include <ctype.h>
33 #include <assert.h>
34 #include <unistd.h>
35 #include <sys/stat.h>
36 #include <sys/types.h>
37 #ifndef HAVE_W32_SYSTEM
38 #include <sys/wait.h>
39 #endif
40 #ifdef USE_GNU_PTH
41 # include <pth.h>
42 #endif
43
44 #include "agent.h"
45 #include <assuan.h>
46
47 #ifdef _POSIX_OPEN_MAX
48 #define MAX_OPEN_FDS _POSIX_OPEN_MAX
49 #else
50 #define MAX_OPEN_FDS 20
51 #endif
52
53 static ASSUAN_CONTEXT scd_ctx = NULL;
54 #ifdef USE_GNU_PTH
55 static pth_mutex_t scd_lock;
56 #endif
57 /* We need to keep track of the connection currently using the SCD.
58    For a pipe server this is all a NOP because the connection will
59    always have the connection indicator -1.  agent_reset_scd releases
60    the active connection; i.e. sets it back to -1, so that a new
61    connection can start using the SCD.  If we eventually allow
62    multiple SCD session we will either make scdaemon multi-threaded or
63    fork of a new scdaemon and let it see how it can get access to a
64    reader. 
65 */
66 static int active_connection_fd = -1;
67 static int active_connection = 0;
68
69 /* callback parameter for learn card */
70 struct learn_parm_s {
71   void (*kpinfo_cb)(void*, const char *);
72   void *kpinfo_cb_arg;
73   void (*certinfo_cb)(void*, const char *);
74   void *certinfo_cb_arg;
75   void (*sinfo_cb)(void*, const char *, size_t, const char *);
76   void *sinfo_cb_arg;
77 };
78
79 struct inq_needpin_s {
80   ASSUAN_CONTEXT ctx;
81   int (*getpin_cb)(void *, const char *, char*, size_t);
82   void *getpin_cb_arg;
83 };
84
85 struct membuf {
86   size_t len;
87   size_t size;
88   char *buf;
89   int out_of_core;
90 };
91
92
93 \f
94 /* A simple implementation of a dynamic buffer.  Use init_membuf() to
95    create a buffer, put_membuf to append bytes and get_membuf to
96    release and return the buffer.  Allocation errors are detected but
97    only returned at the final get_membuf(), this helps not to clutter
98    the code with out of core checks.  */
99
100 static void
101 init_membuf (struct membuf *mb, int initiallen)
102 {
103   mb->len = 0;
104   mb->size = initiallen;
105   mb->out_of_core = 0;
106   mb->buf = xtrymalloc (initiallen);
107   if (!mb->buf)
108       mb->out_of_core = 1;
109 }
110
111 static void
112 put_membuf (struct membuf *mb, const void *buf, size_t len)
113 {
114   if (mb->out_of_core)
115     return;
116
117   if (mb->len + len >= mb->size)
118     {
119       char *p;
120       
121       mb->size += len + 1024;
122       p = xtryrealloc (mb->buf, mb->size);
123       if (!p)
124         {
125           mb->out_of_core = 1;
126           return;
127         }
128       mb->buf = p;
129     }
130   memcpy (mb->buf + mb->len, buf, len);
131   mb->len += len;
132 }
133
134 static void *
135 get_membuf (struct membuf *mb, size_t *len)
136 {
137   char *p;
138
139   if (mb->out_of_core)
140     {
141       xfree (mb->buf);
142       mb->buf = NULL;
143       return NULL;
144     }
145
146   p = mb->buf;
147   *len = mb->len;
148   mb->buf = NULL;
149   mb->out_of_core = 1; /* don't allow a reuse */
150   return p;
151 }
152
153
154
155 \f
156 /* This function must be called once to initialize this module.  This
157    has to be done before a second thread is spawned.  We can't do the
158    static initialization because Pth emulation code might not be able
159    to do a static init; in particualr, it is not possible for W32. */
160 void
161 initialize_module_call_scd (void)
162 {
163 #ifdef USE_GNU_PTH
164   static int initialized;
165
166   if (!initialized)
167     if (pth_mutex_init (&scd_lock))
168       initialized = 1;
169 #endif /*USE_GNU_PTH*/
170 }
171
172
173 static int 
174 unlock_scd (int rc)
175 {
176 #ifdef USE_GNU_PTH
177   if (!pth_mutex_release (&scd_lock))
178     {
179       log_error ("failed to release the SCD lock\n");
180       if (!rc)
181         rc = gpg_error (GPG_ERR_INTERNAL);
182     }
183 #endif /*USE_GNU_PTH*/
184   return rc;
185 }
186
187 /* To make sure we leave no secrets in our image after forking of the
188    scdaemon, we use this callback. */
189 static void
190 atfork_cb (void *opaque, int where)
191 {
192   if (!where)
193     gcry_control (GCRYCTL_TERM_SECMEM);
194 }
195
196
197 /* Fork off the SCdaemon if this has not already been done.  Note that
198    this fucntion alos locks the daemon.  */
199 static int
200 start_scd (ctrl_t ctrl)
201 {
202   int rc;
203   const char *pgmname;
204   ASSUAN_CONTEXT ctx;
205   const char *argv[3];
206   int no_close_list[3];
207   int i;
208
209 #ifdef USE_GNU_PTH
210   if (!pth_mutex_acquire (&scd_lock, 0, NULL))
211     {
212       log_error ("failed to acquire the SCD lock\n");
213       return gpg_error (GPG_ERR_INTERNAL);
214     }
215 #endif
216
217   if (scd_ctx)
218     {
219       pid_t pid;
220
221       /* If we are not the connection currently using the SCD, return
222          an error. */
223       if (!active_connection)
224         {
225           active_connection_fd = ctrl->connection_fd;
226           active_connection = 1;
227         }
228       else if (ctrl->connection_fd != active_connection_fd)
229         return unlock_scd (gpg_error (GPG_ERR_CONFLICT));
230       
231       /* Okay, we already started the scdaemon and it is used by us.*/
232
233       /* We better do a sanity check now to see whether it has
234          accidently died. */
235 #ifndef HAVE_W32_SYSTEM 
236       pid = assuan_get_pid (scd_ctx);
237       if (pid != (pid_t)(-1) && pid
238           && ((rc=waitpid (pid, NULL, WNOHANG))==-1 || (rc == pid)) )
239         {
240           assuan_disconnect (scd_ctx);
241           scd_ctx = NULL;
242         }
243       else
244 #endif
245         return 0; 
246     }
247
248   if (opt.verbose)
249     log_info ("no running SCdaemon - starting it\n");
250       
251   if (fflush (NULL))
252     {
253       gpg_error_t tmperr = gpg_error (gpg_err_code_from_errno (errno));
254       log_error ("error flushing pending output: %s\n", strerror (errno));
255       return unlock_scd (tmperr);
256     }
257
258   if (!opt.scdaemon_program || !*opt.scdaemon_program)
259     opt.scdaemon_program = GNUPG_DEFAULT_SCDAEMON;
260   if ( !(pgmname = strrchr (opt.scdaemon_program, '/')))
261     pgmname = opt.scdaemon_program;
262   else
263     pgmname++;
264
265   argv[0] = pgmname;
266   argv[1] = "--server";
267   argv[2] = NULL;
268
269   i=0;
270   if (!opt.running_detached)
271     {
272       if (log_get_fd () != -1)
273         no_close_list[i++] = log_get_fd ();
274       no_close_list[i++] = fileno (stderr);
275     }
276   no_close_list[i] = -1;
277
278   /* Connect to the pinentry and perform initial handshaking */
279   rc = assuan_pipe_connect2 (&ctx, opt.scdaemon_program, (char**)argv,
280                              no_close_list, atfork_cb, NULL);
281   if (rc)
282     {
283       log_error ("can't connect to the SCdaemon: %s\n",
284                  assuan_strerror (rc));
285       return unlock_scd (gpg_error (GPG_ERR_NO_SCDAEMON));
286     }
287   scd_ctx = ctx;
288   active_connection_fd = ctrl->connection_fd;
289   active_connection = 1;
290
291   if (DBG_ASSUAN)
292     log_debug ("connection to SCdaemon established\n");
293
294   /* Tell the scdaemon that we want him to send us an event signal.
295      But only do this if we are running as a regular sever and not
296      simply as a pipe server. */
297   if (ctrl->connection_fd != -1)
298   {
299 #ifndef HAVE_W32_SYSTEM
300     char buf[100];
301
302     sprintf (buf, "OPTION event-signal=%d", SIGUSR2);
303     assuan_transact (scd_ctx, buf, NULL, NULL, NULL, NULL, NULL, NULL);
304 #endif
305   }
306
307   return 0;
308 }
309
310
311
312 /* Reset the SCD if it has been used. */
313 int
314 agent_reset_scd (ctrl_t ctrl)
315 {
316   int rc = 0;
317
318 #ifdef USE_GNU_PTH
319   if (!pth_mutex_acquire (&scd_lock, 0, NULL))
320     {
321       log_error ("failed to acquire the SCD lock for reset\n");
322       return gpg_error (GPG_ERR_INTERNAL);
323     }
324 #endif
325   if (active_connection && active_connection_fd == ctrl->connection_fd)
326     {
327       if (scd_ctx)
328         rc = assuan_transact (scd_ctx, "RESET", NULL, NULL,
329                               NULL, NULL, NULL, NULL);
330       active_connection_fd = -1;
331       active_connection = 0;
332     }
333
334   return unlock_scd (map_assuan_err (rc));
335 }
336
337
338
339
340 \f
341 static AssuanError
342 learn_status_cb (void *opaque, const char *line)
343 {
344   struct learn_parm_s *parm = opaque;
345   const char *keyword = line;
346   int keywordlen;
347
348   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
349     ;
350   while (spacep (line))
351     line++;
352   if (keywordlen == 8 && !memcmp (keyword, "CERTINFO", keywordlen))
353     {
354       parm->certinfo_cb (parm->certinfo_cb_arg, line);
355     }
356   else if (keywordlen == 11 && !memcmp (keyword, "KEYPAIRINFO", keywordlen))
357     {
358       parm->kpinfo_cb (parm->kpinfo_cb_arg, line);
359     }
360   else if (keywordlen && *line)
361     {
362       parm->sinfo_cb (parm->sinfo_cb_arg, keyword, keywordlen, line);
363     }
364   
365   return 0;
366 }
367
368 /* Perform the learn command and return a list of all private keys
369    stored on the card. */
370 int
371 agent_card_learn (ctrl_t ctrl,
372                   void (*kpinfo_cb)(void*, const char *),
373                   void *kpinfo_cb_arg,
374                   void (*certinfo_cb)(void*, const char *),
375                   void *certinfo_cb_arg,
376                   void (*sinfo_cb)(void*, const char *, size_t, const char *),
377                   void *sinfo_cb_arg)
378 {
379   int rc;
380   struct learn_parm_s parm;
381
382   rc = start_scd (ctrl);
383   if (rc)
384     return rc;
385
386   memset (&parm, 0, sizeof parm);
387   parm.kpinfo_cb = kpinfo_cb;
388   parm.kpinfo_cb_arg = kpinfo_cb_arg;
389   parm.certinfo_cb = certinfo_cb;
390   parm.certinfo_cb_arg = certinfo_cb_arg;
391   parm.sinfo_cb = sinfo_cb;
392   parm.sinfo_cb_arg = sinfo_cb_arg;
393   rc = assuan_transact (scd_ctx, "LEARN --force",
394                         NULL, NULL, NULL, NULL,
395                         learn_status_cb, &parm);
396   if (rc)
397     return unlock_scd (map_assuan_err (rc));
398
399   return unlock_scd (0);
400 }
401
402
403 \f
404 static AssuanError
405 get_serialno_cb (void *opaque, const char *line)
406 {
407   char **serialno = opaque;
408   const char *keyword = line;
409   const char *s;
410   int keywordlen, n;
411
412   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
413     ;
414   while (spacep (line))
415     line++;
416
417   if (keywordlen == 8 && !memcmp (keyword, "SERIALNO", keywordlen))
418     {
419       if (*serialno)
420         return ASSUAN_Unexpected_Status;
421       for (n=0,s=line; hexdigitp (s); s++, n++)
422         ;
423       if (!n || (n&1)|| !(spacep (s) || !*s) )
424         return ASSUAN_Invalid_Status;
425       *serialno = xtrymalloc (n+1);
426       if (!*serialno)
427         return ASSUAN_Out_Of_Core;
428       memcpy (*serialno, line, n);
429       (*serialno)[n] = 0;
430     }
431   
432   return 0;
433 }
434
435 /* Return the serial number of the card or an appropriate error.  The
436    serial number is returned as a hexstring. */
437 int
438 agent_card_serialno (ctrl_t ctrl, char **r_serialno)
439 {
440   int rc;
441   char *serialno = NULL;
442
443   rc = start_scd (ctrl);
444   if (rc)
445     return rc;
446
447   /* Hmm, do we really need this reset - scddaemon should do this or
448      we can do this if we for some reason figure out that the
449      operation might have failed due to a missing RESET.  Hmmm, I feel
450      this is really SCdaemon's duty */
451 /*    rc = assuan_transact (scd_ctx, "RESET", NULL, NULL, NULL, NULL, NULL, NULL); */
452 /*    if (rc) */
453 /*      return unlock_scd (map_assuan_err (rc)); */
454
455   rc = assuan_transact (scd_ctx, "SERIALNO",
456                         NULL, NULL, NULL, NULL,
457                         get_serialno_cb, &serialno);
458   if (rc)
459     {
460       xfree (serialno);
461       return unlock_scd (map_assuan_err (rc));
462     }
463   *r_serialno = serialno;
464   return unlock_scd (0);
465 }
466
467 \f
468 static AssuanError
469 membuf_data_cb (void *opaque, const void *buffer, size_t length)
470 {
471   struct membuf *data = opaque;
472
473   if (buffer)
474     put_membuf (data, buffer, length);
475   return 0;
476 }
477   
478 /* Handle the NEEDPIN inquiry. */
479 static AssuanError
480 inq_needpin (void *opaque, const char *line)
481 {
482   struct inq_needpin_s *parm = opaque;
483   char *pin;
484   size_t pinlen;
485   int rc;
486
487   if (!(!strncmp (line, "NEEDPIN", 7) && (line[7] == ' ' || !line[7])))
488     {
489       log_error ("unsupported inquiry `%s'\n", line);
490       return ASSUAN_Inquire_Unknown;
491     }
492   line += 7;
493
494   pinlen = 90;
495   pin = gcry_malloc_secure (pinlen);
496   if (!pin)
497     return ASSUAN_Out_Of_Core;
498
499   rc = parm->getpin_cb (parm->getpin_cb_arg, line, pin, pinlen);
500   if (rc)
501     rc = ASSUAN_Canceled;
502   if (!rc)
503     rc = assuan_send_data (parm->ctx, pin, pinlen);
504   xfree (pin);
505
506   return rc;
507 }
508
509
510
511 /* Create a signature using the current card */
512 int
513 agent_card_pksign (ctrl_t ctrl,
514                    const char *keyid,
515                    int (*getpin_cb)(void *, const char *, char*, size_t),
516                    void *getpin_cb_arg,
517                    const unsigned char *indata, size_t indatalen,
518                    char **r_buf, size_t *r_buflen)
519 {
520   int rc, i;
521   char *p, line[ASSUAN_LINELENGTH];
522   struct membuf data;
523   struct inq_needpin_s inqparm;
524   size_t len;
525   unsigned char *sigbuf;
526   size_t sigbuflen;
527
528   *r_buf = NULL;
529   rc = start_scd (ctrl);
530   if (rc)
531     return rc;
532
533   if (indatalen*2 + 50 > DIM(line))
534     return unlock_scd (gpg_error (GPG_ERR_GENERAL));
535
536   sprintf (line, "SETDATA ");
537   p = line + strlen (line);
538   for (i=0; i < indatalen ; i++, p += 2 )
539     sprintf (p, "%02X", indata[i]);
540   rc = assuan_transact (scd_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
541   if (rc)
542     return unlock_scd (map_assuan_err (rc));
543
544   init_membuf (&data, 1024);
545   inqparm.ctx = scd_ctx;
546   inqparm.getpin_cb = getpin_cb;
547   inqparm.getpin_cb_arg = getpin_cb_arg;
548   snprintf (line, DIM(line)-1, "PKSIGN %s", keyid);
549   line[DIM(line)-1] = 0;
550   rc = assuan_transact (scd_ctx, line,
551                         membuf_data_cb, &data,
552                         inq_needpin, &inqparm,
553                         NULL, NULL);
554   if (rc)
555     {
556       xfree (get_membuf (&data, &len));
557       return unlock_scd (map_assuan_err (rc));
558     }
559   sigbuf = get_membuf (&data, &sigbuflen);
560
561   /* create an S-expression from it which is formatted like this:
562      "(7:sig-val(3:rsa(1:sSIGBUFLEN:SIGBUF)))" */
563   *r_buflen = 21 + 11 + sigbuflen + 4;
564   *r_buf = xtrymalloc (*r_buflen);
565   if (!*r_buf)
566     {
567       gpg_error_t tmperr = out_of_core ();
568       xfree (*r_buf);
569       return unlock_scd (tmperr);
570     }
571   p = stpcpy (*r_buf, "(7:sig-val(3:rsa(1:s" );
572   sprintf (p, "%u:", (unsigned int)sigbuflen);
573   p += strlen (p);
574   memcpy (p, sigbuf, sigbuflen);
575   p += sigbuflen;
576   strcpy (p, ")))");
577   xfree (sigbuf);
578
579   assert (gcry_sexp_canon_len (*r_buf, *r_buflen, NULL, NULL));
580   return unlock_scd (0);
581 }
582
583 /* Decipher INDATA using the current card. Note that the returned value is */
584 int
585 agent_card_pkdecrypt (ctrl_t ctrl,
586                       const char *keyid,
587                       int (*getpin_cb)(void *, const char *, char*, size_t),
588                       void *getpin_cb_arg,
589                       const unsigned char *indata, size_t indatalen,
590                       char **r_buf, size_t *r_buflen)
591 {
592   int rc, i;
593   char *p, line[ASSUAN_LINELENGTH];
594   struct membuf data;
595   struct inq_needpin_s inqparm;
596   size_t len;
597
598   *r_buf = NULL;
599   rc = start_scd (ctrl);
600   if (rc)
601     return rc;
602
603   /* FIXME: use secure memory where appropriate */
604   if (indatalen*2 + 50 > DIM(line))
605     return unlock_scd (gpg_error (GPG_ERR_GENERAL));
606
607   sprintf (line, "SETDATA ");
608   p = line + strlen (line);
609   for (i=0; i < indatalen ; i++, p += 2 )
610     sprintf (p, "%02X", indata[i]);
611   rc = assuan_transact (scd_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
612   if (rc)
613     return unlock_scd (map_assuan_err (rc));
614
615   init_membuf (&data, 1024);
616   inqparm.ctx = scd_ctx;
617   inqparm.getpin_cb = getpin_cb;
618   inqparm.getpin_cb_arg = getpin_cb_arg;
619   snprintf (line, DIM(line)-1, "PKDECRYPT %s", keyid);
620   line[DIM(line)-1] = 0;
621   rc = assuan_transact (scd_ctx, line,
622                         membuf_data_cb, &data,
623                         inq_needpin, &inqparm,
624                         NULL, NULL);
625   if (rc)
626     {
627       xfree (get_membuf (&data, &len));
628       return unlock_scd (map_assuan_err (rc));
629     }
630   *r_buf = get_membuf (&data, r_buflen);
631   if (!*r_buf)
632     return unlock_scd (gpg_error (GPG_ERR_ENOMEM));
633
634   return unlock_scd (0);
635 }
636
637
638 \f
639 /* Read a certificate with ID into R_BUF and R_BUFLEN. */
640 int
641 agent_card_readcert (ctrl_t ctrl,
642                      const char *id, char **r_buf, size_t *r_buflen)
643 {
644   int rc;
645   char line[ASSUAN_LINELENGTH];
646   struct membuf data;
647   size_t len;
648
649   *r_buf = NULL;
650   rc = start_scd (ctrl);
651   if (rc)
652     return rc;
653
654   init_membuf (&data, 1024);
655   snprintf (line, DIM(line)-1, "READCERT %s", id);
656   line[DIM(line)-1] = 0;
657   rc = assuan_transact (scd_ctx, line,
658                         membuf_data_cb, &data,
659                         NULL, NULL,
660                         NULL, NULL);
661   if (rc)
662     {
663       xfree (get_membuf (&data, &len));
664       return unlock_scd (map_assuan_err (rc));
665     }
666   *r_buf = get_membuf (&data, r_buflen);
667   if (!*r_buf)
668     return unlock_scd (gpg_error (GPG_ERR_ENOMEM));
669
670   return unlock_scd (0);
671 }
672
673
674 \f
675 /* Read a key with ID and return it in an allocate buffer pointed to
676    by r_BUF as a valid S-expression. */
677 int
678 agent_card_readkey (ctrl_t ctrl, const char *id, unsigned char **r_buf)
679 {
680   int rc;
681   char line[ASSUAN_LINELENGTH];
682   struct membuf data;
683   size_t len, buflen;
684
685   *r_buf = NULL;
686   rc = start_scd (ctrl);
687   if (rc)
688     return rc;
689
690   init_membuf (&data, 1024);
691   snprintf (line, DIM(line)-1, "READKEY %s", id);
692   line[DIM(line)-1] = 0;
693   rc = assuan_transact (scd_ctx, line,
694                         membuf_data_cb, &data,
695                         NULL, NULL,
696                         NULL, NULL);
697   if (rc)
698     {
699       xfree (get_membuf (&data, &len));
700       return unlock_scd (map_assuan_err (rc));
701     }
702   *r_buf = get_membuf (&data, &buflen);
703   if (!*r_buf)
704     return unlock_scd (gpg_error (GPG_ERR_ENOMEM));
705
706   if (!gcry_sexp_canon_len (*r_buf, buflen, NULL, NULL))
707     {
708       xfree (*r_buf); *r_buf = NULL;
709       return unlock_scd (gpg_error (GPG_ERR_INV_VALUE));
710     }
711
712   return unlock_scd (0);
713 }
714
715
716
717 \f
718 static AssuanError
719 pass_status_thru (void *opaque, const char *line)
720 {
721   ASSUAN_CONTEXT ctx = opaque;
722   char keyword[200];
723   int i;
724
725   for (i=0; *line && !spacep (line) && i < DIM(keyword)-1; line++, i++)
726     keyword[i] = *line;
727   keyword[i] = 0;
728   /* truncate any remaining keyword stuff. */
729   for (; *line && !spacep (line); line++)
730     ;
731   while (spacep (line))
732     line++;
733
734   assuan_write_status (ctx, keyword, line);
735   return 0;
736 }
737
738 static AssuanError
739 pass_data_thru (void *opaque, const void *buffer, size_t length)
740 {
741   ASSUAN_CONTEXT ctx = opaque;
742
743   assuan_send_data (ctx, buffer, length);
744   return 0;
745 }
746
747
748 /* Send the line CMDLINE with command for the SCDdaemon to it and send
749    all status messages back.  This command is used as a general quoting
750    mechanism to pass everything verbatim to SCDAEMOPN.  The PIN
751    inquirey is handled inside gpg-agent. */
752 int
753 agent_card_scd (ctrl_t ctrl, const char *cmdline,
754                 int (*getpin_cb)(void *, const char *, char*, size_t),
755                 void *getpin_cb_arg, void *assuan_context)
756 {
757   int rc;
758   struct inq_needpin_s inqparm;
759
760   rc = start_scd (ctrl);
761   if (rc)
762     return rc;
763
764   inqparm.ctx = scd_ctx;
765   inqparm.getpin_cb = getpin_cb;
766   inqparm.getpin_cb_arg = getpin_cb_arg;
767   rc = assuan_transact (scd_ctx, cmdline,
768                         pass_data_thru, assuan_context,
769                         inq_needpin, &inqparm,
770                         pass_status_thru, assuan_context);
771   if (rc)
772     {
773       return unlock_scd (map_assuan_err (rc));
774     }
775
776   return unlock_scd (0);
777 }
778
779