VArious hacks to make it at least build under W32.
[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 = PTH_MUTEX_INIT;
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 static int 
157 unlock_scd (int rc)
158 {
159 #ifdef USE_GNU_PTH
160   if (!pth_mutex_release (&scd_lock))
161     {
162       log_error ("failed to release the SCD lock\n");
163       if (!rc)
164         rc = gpg_error (GPG_ERR_INTERNAL);
165     }
166 #endif
167   return rc;
168 }
169
170 /* To make sure we leave no secrets in our image after forking of the
171    scdaemon, we use this callback. */
172 static void
173 atfork_cb (void *opaque, int where)
174 {
175   if (!where)
176     gcry_control (GCRYCTL_TERM_SECMEM);
177 }
178
179
180 /* Fork off the SCdaemon if this has not already been done.  Note that
181    this fucntion alos locks the daemon.  */
182 static int
183 start_scd (ctrl_t ctrl)
184 {
185   int rc;
186   const char *pgmname;
187   ASSUAN_CONTEXT ctx;
188   const char *argv[3];
189   int no_close_list[3];
190   int i;
191
192 #ifdef USE_GNU_PTH
193   if (!pth_mutex_acquire (&scd_lock, 0, NULL))
194     {
195       log_error ("failed to acquire the SCD lock\n");
196       return gpg_error (GPG_ERR_INTERNAL);
197     }
198 #endif
199
200   if (scd_ctx)
201     {
202       pid_t pid;
203
204       /* If we are not the connection currently using the SCD, return
205          an error. */
206       if (!active_connection)
207         {
208           active_connection_fd = ctrl->connection_fd;
209           active_connection = 1;
210         }
211       else if (ctrl->connection_fd != active_connection_fd)
212         return unlock_scd (gpg_error (GPG_ERR_CONFLICT));
213       
214       /* Okay, we already started the scdaemon and it is used by us.*/
215
216       /* We better do a sanity check now to see whether it has
217          accidently died. */
218 #ifndef HAVE_W32_SYSTEM /* fixme */
219       pid = assuan_get_pid (scd_ctx);
220       if (pid != (pid_t)(-1) && pid
221           && ((rc=waitpid (pid, NULL, WNOHANG))==-1 || (rc == pid)) )
222         {
223           assuan_disconnect (scd_ctx);
224           scd_ctx = NULL;
225         }
226       else
227 #endif
228         return 0; 
229     }
230
231   if (opt.verbose)
232     log_info ("no running SCdaemon - starting it\n");
233       
234   if (fflush (NULL))
235     {
236       gpg_error_t tmperr = gpg_error (gpg_err_code_from_errno (errno));
237       log_error ("error flushing pending output: %s\n", strerror (errno));
238       return unlock_scd (tmperr);
239     }
240
241   if (!opt.scdaemon_program || !*opt.scdaemon_program)
242     opt.scdaemon_program = GNUPG_DEFAULT_SCDAEMON;
243   if ( !(pgmname = strrchr (opt.scdaemon_program, '/')))
244     pgmname = opt.scdaemon_program;
245   else
246     pgmname++;
247
248   argv[0] = pgmname;
249   argv[1] = "--server";
250   argv[2] = NULL;
251
252   i=0;
253   if (!opt.running_detached)
254     {
255       if (log_get_fd () != -1)
256         no_close_list[i++] = log_get_fd ();
257       no_close_list[i++] = fileno (stderr);
258     }
259   no_close_list[i] = -1;
260
261   /* Connect to the pinentry and perform initial handshaking */
262   rc = assuan_pipe_connect2 (&ctx, opt.scdaemon_program, (char**)argv,
263                              no_close_list, atfork_cb, NULL);
264   if (rc)
265     {
266       log_error ("can't connect to the SCdaemon: %s\n",
267                  assuan_strerror (rc));
268       return unlock_scd (gpg_error (GPG_ERR_NO_SCDAEMON));
269     }
270   scd_ctx = ctx;
271   active_connection_fd = ctrl->connection_fd;
272   active_connection = 1;
273
274   if (DBG_ASSUAN)
275     log_debug ("connection to SCdaemon established\n");
276
277   /* Tell the scdaemon that we want him to send us an event signal.
278      But only do this if we are running as a regular sever and not
279      simply as a pipe server. */
280   if (ctrl->connection_fd != -1)
281   {
282 #ifndef HAVE_W32_SYSTEM
283     char buf[100];
284
285     sprintf (buf, "OPTION event-signal=%d", SIGUSR2);
286     assuan_transact (scd_ctx, buf, NULL, NULL, NULL, NULL, NULL, NULL);
287 #endif
288   }
289
290   return 0;
291 }
292
293
294
295 /* Reset the SCD if it has been used. */
296 int
297 agent_reset_scd (ctrl_t ctrl)
298 {
299   int rc = 0;
300
301 #ifdef USE_GNU_PTH
302   if (!pth_mutex_acquire (&scd_lock, 0, NULL))
303     {
304       log_error ("failed to acquire the SCD lock for reset\n");
305       return gpg_error (GPG_ERR_INTERNAL);
306     }
307 #endif
308   if (active_connection && active_connection_fd == ctrl->connection_fd)
309     {
310       if (scd_ctx)
311         rc = assuan_transact (scd_ctx, "RESET", NULL, NULL,
312                               NULL, NULL, NULL, NULL);
313       active_connection_fd = -1;
314       active_connection = 0;
315     }
316
317   return unlock_scd (map_assuan_err (rc));
318 }
319
320
321
322
323 \f
324 static AssuanError
325 learn_status_cb (void *opaque, const char *line)
326 {
327   struct learn_parm_s *parm = opaque;
328   const char *keyword = line;
329   int keywordlen;
330
331   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
332     ;
333   while (spacep (line))
334     line++;
335   if (keywordlen == 8 && !memcmp (keyword, "CERTINFO", keywordlen))
336     {
337       parm->certinfo_cb (parm->certinfo_cb_arg, line);
338     }
339   else if (keywordlen == 11 && !memcmp (keyword, "KEYPAIRINFO", keywordlen))
340     {
341       parm->kpinfo_cb (parm->kpinfo_cb_arg, line);
342     }
343   else if (keywordlen && *line)
344     {
345       parm->sinfo_cb (parm->sinfo_cb_arg, keyword, keywordlen, line);
346     }
347   
348   return 0;
349 }
350
351 /* Perform the learn command and return a list of all private keys
352    stored on the card. */
353 int
354 agent_card_learn (ctrl_t ctrl,
355                   void (*kpinfo_cb)(void*, const char *),
356                   void *kpinfo_cb_arg,
357                   void (*certinfo_cb)(void*, const char *),
358                   void *certinfo_cb_arg,
359                   void (*sinfo_cb)(void*, const char *, size_t, const char *),
360                   void *sinfo_cb_arg)
361 {
362   int rc;
363   struct learn_parm_s parm;
364
365   rc = start_scd (ctrl);
366   if (rc)
367     return rc;
368
369   memset (&parm, 0, sizeof parm);
370   parm.kpinfo_cb = kpinfo_cb;
371   parm.kpinfo_cb_arg = kpinfo_cb_arg;
372   parm.certinfo_cb = certinfo_cb;
373   parm.certinfo_cb_arg = certinfo_cb_arg;
374   parm.sinfo_cb = sinfo_cb;
375   parm.sinfo_cb_arg = sinfo_cb_arg;
376   rc = assuan_transact (scd_ctx, "LEARN --force",
377                         NULL, NULL, NULL, NULL,
378                         learn_status_cb, &parm);
379   if (rc)
380     return unlock_scd (map_assuan_err (rc));
381
382   return unlock_scd (0);
383 }
384
385
386 \f
387 static AssuanError
388 get_serialno_cb (void *opaque, const char *line)
389 {
390   char **serialno = opaque;
391   const char *keyword = line;
392   const char *s;
393   int keywordlen, n;
394
395   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
396     ;
397   while (spacep (line))
398     line++;
399
400   if (keywordlen == 8 && !memcmp (keyword, "SERIALNO", keywordlen))
401     {
402       if (*serialno)
403         return ASSUAN_Unexpected_Status;
404       for (n=0,s=line; hexdigitp (s); s++, n++)
405         ;
406       if (!n || (n&1)|| !(spacep (s) || !*s) )
407         return ASSUAN_Invalid_Status;
408       *serialno = xtrymalloc (n+1);
409       if (!*serialno)
410         return ASSUAN_Out_Of_Core;
411       memcpy (*serialno, line, n);
412       (*serialno)[n] = 0;
413     }
414   
415   return 0;
416 }
417
418 /* Return the serial number of the card or an appropriate error.  The
419    serial number is returned as a hexstring. */
420 int
421 agent_card_serialno (ctrl_t ctrl, char **r_serialno)
422 {
423   int rc;
424   char *serialno = NULL;
425
426   rc = start_scd (ctrl);
427   if (rc)
428     return rc;
429
430   /* Hmm, do we really need this reset - scddaemon should do this or
431      we can do this if we for some reason figure out that the
432      operation might have failed due to a missing RESET.  Hmmm, I feel
433      this is really SCdaemon's duty */
434 /*    rc = assuan_transact (scd_ctx, "RESET", NULL, NULL, NULL, NULL, NULL, NULL); */
435 /*    if (rc) */
436 /*      return unlock_scd (map_assuan_err (rc)); */
437
438   rc = assuan_transact (scd_ctx, "SERIALNO",
439                         NULL, NULL, NULL, NULL,
440                         get_serialno_cb, &serialno);
441   if (rc)
442     {
443       xfree (serialno);
444       return unlock_scd (map_assuan_err (rc));
445     }
446   *r_serialno = serialno;
447   return unlock_scd (0);
448 }
449
450 \f
451 static AssuanError
452 membuf_data_cb (void *opaque, const void *buffer, size_t length)
453 {
454   struct membuf *data = opaque;
455
456   if (buffer)
457     put_membuf (data, buffer, length);
458   return 0;
459 }
460   
461 /* Handle the NEEDPIN inquiry. */
462 static AssuanError
463 inq_needpin (void *opaque, const char *line)
464 {
465   struct inq_needpin_s *parm = opaque;
466   char *pin;
467   size_t pinlen;
468   int rc;
469
470   if (!(!strncmp (line, "NEEDPIN", 7) && (line[7] == ' ' || !line[7])))
471     {
472       log_error ("unsupported inquiry `%s'\n", line);
473       return ASSUAN_Inquire_Unknown;
474     }
475   line += 7;
476
477   pinlen = 90;
478   pin = gcry_malloc_secure (pinlen);
479   if (!pin)
480     return ASSUAN_Out_Of_Core;
481
482   rc = parm->getpin_cb (parm->getpin_cb_arg, line, pin, pinlen);
483   if (rc)
484     rc = ASSUAN_Canceled;
485   if (!rc)
486     rc = assuan_send_data (parm->ctx, pin, pinlen);
487   xfree (pin);
488
489   return rc;
490 }
491
492
493
494 /* Create a signature using the current card */
495 int
496 agent_card_pksign (ctrl_t ctrl,
497                    const char *keyid,
498                    int (*getpin_cb)(void *, const char *, char*, size_t),
499                    void *getpin_cb_arg,
500                    const unsigned char *indata, size_t indatalen,
501                    char **r_buf, size_t *r_buflen)
502 {
503   int rc, i;
504   char *p, line[ASSUAN_LINELENGTH];
505   struct membuf data;
506   struct inq_needpin_s inqparm;
507   size_t len;
508   unsigned char *sigbuf;
509   size_t sigbuflen;
510
511   *r_buf = NULL;
512   rc = start_scd (ctrl);
513   if (rc)
514     return rc;
515
516   if (indatalen*2 + 50 > DIM(line))
517     return unlock_scd (gpg_error (GPG_ERR_GENERAL));
518
519   sprintf (line, "SETDATA ");
520   p = line + strlen (line);
521   for (i=0; i < indatalen ; i++, p += 2 )
522     sprintf (p, "%02X", indata[i]);
523   rc = assuan_transact (scd_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
524   if (rc)
525     return unlock_scd (map_assuan_err (rc));
526
527   init_membuf (&data, 1024);
528   inqparm.ctx = scd_ctx;
529   inqparm.getpin_cb = getpin_cb;
530   inqparm.getpin_cb_arg = getpin_cb_arg;
531   snprintf (line, DIM(line)-1, "PKSIGN %s", keyid);
532   line[DIM(line)-1] = 0;
533   rc = assuan_transact (scd_ctx, line,
534                         membuf_data_cb, &data,
535                         inq_needpin, &inqparm,
536                         NULL, NULL);
537   if (rc)
538     {
539       xfree (get_membuf (&data, &len));
540       return unlock_scd (map_assuan_err (rc));
541     }
542   sigbuf = get_membuf (&data, &sigbuflen);
543
544   /* create an S-expression from it which is formatted like this:
545      "(7:sig-val(3:rsa(1:sSIGBUFLEN:SIGBUF)))" */
546   *r_buflen = 21 + 11 + sigbuflen + 4;
547   *r_buf = xtrymalloc (*r_buflen);
548   if (!*r_buf)
549     {
550       gpg_error_t tmperr = out_of_core ();
551       xfree (*r_buf);
552       return unlock_scd (tmperr);
553     }
554   p = stpcpy (*r_buf, "(7:sig-val(3:rsa(1:s" );
555   sprintf (p, "%u:", (unsigned int)sigbuflen);
556   p += strlen (p);
557   memcpy (p, sigbuf, sigbuflen);
558   p += sigbuflen;
559   strcpy (p, ")))");
560   xfree (sigbuf);
561
562   assert (gcry_sexp_canon_len (*r_buf, *r_buflen, NULL, NULL));
563   return unlock_scd (0);
564 }
565
566 /* Decipher INDATA using the current card. Note that the returned value is */
567 int
568 agent_card_pkdecrypt (ctrl_t ctrl,
569                       const char *keyid,
570                       int (*getpin_cb)(void *, const char *, char*, size_t),
571                       void *getpin_cb_arg,
572                       const unsigned char *indata, size_t indatalen,
573                       char **r_buf, size_t *r_buflen)
574 {
575   int rc, i;
576   char *p, line[ASSUAN_LINELENGTH];
577   struct membuf data;
578   struct inq_needpin_s inqparm;
579   size_t len;
580
581   *r_buf = NULL;
582   rc = start_scd (ctrl);
583   if (rc)
584     return rc;
585
586   /* FIXME: use secure memory where appropriate */
587   if (indatalen*2 + 50 > DIM(line))
588     return unlock_scd (gpg_error (GPG_ERR_GENERAL));
589
590   sprintf (line, "SETDATA ");
591   p = line + strlen (line);
592   for (i=0; i < indatalen ; i++, p += 2 )
593     sprintf (p, "%02X", indata[i]);
594   rc = assuan_transact (scd_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
595   if (rc)
596     return unlock_scd (map_assuan_err (rc));
597
598   init_membuf (&data, 1024);
599   inqparm.ctx = scd_ctx;
600   inqparm.getpin_cb = getpin_cb;
601   inqparm.getpin_cb_arg = getpin_cb_arg;
602   snprintf (line, DIM(line)-1, "PKDECRYPT %s", keyid);
603   line[DIM(line)-1] = 0;
604   rc = assuan_transact (scd_ctx, line,
605                         membuf_data_cb, &data,
606                         inq_needpin, &inqparm,
607                         NULL, NULL);
608   if (rc)
609     {
610       xfree (get_membuf (&data, &len));
611       return unlock_scd (map_assuan_err (rc));
612     }
613   *r_buf = get_membuf (&data, r_buflen);
614   if (!*r_buf)
615     return unlock_scd (gpg_error (GPG_ERR_ENOMEM));
616
617   return unlock_scd (0);
618 }
619
620
621 \f
622 /* Read a certificate with ID into R_BUF and R_BUFLEN. */
623 int
624 agent_card_readcert (ctrl_t ctrl,
625                      const char *id, char **r_buf, size_t *r_buflen)
626 {
627   int rc;
628   char line[ASSUAN_LINELENGTH];
629   struct membuf data;
630   size_t len;
631
632   *r_buf = NULL;
633   rc = start_scd (ctrl);
634   if (rc)
635     return rc;
636
637   init_membuf (&data, 1024);
638   snprintf (line, DIM(line)-1, "READCERT %s", id);
639   line[DIM(line)-1] = 0;
640   rc = assuan_transact (scd_ctx, line,
641                         membuf_data_cb, &data,
642                         NULL, NULL,
643                         NULL, NULL);
644   if (rc)
645     {
646       xfree (get_membuf (&data, &len));
647       return unlock_scd (map_assuan_err (rc));
648     }
649   *r_buf = get_membuf (&data, r_buflen);
650   if (!*r_buf)
651     return unlock_scd (gpg_error (GPG_ERR_ENOMEM));
652
653   return unlock_scd (0);
654 }
655
656
657 \f
658 /* Read a key with ID and return it in an allocate buffer pointed to
659    by r_BUF as a valid S-expression. */
660 int
661 agent_card_readkey (ctrl_t ctrl, const char *id, unsigned char **r_buf)
662 {
663   int rc;
664   char line[ASSUAN_LINELENGTH];
665   struct membuf data;
666   size_t len, buflen;
667
668   *r_buf = NULL;
669   rc = start_scd (ctrl);
670   if (rc)
671     return rc;
672
673   init_membuf (&data, 1024);
674   snprintf (line, DIM(line)-1, "READKEY %s", id);
675   line[DIM(line)-1] = 0;
676   rc = assuan_transact (scd_ctx, line,
677                         membuf_data_cb, &data,
678                         NULL, NULL,
679                         NULL, NULL);
680   if (rc)
681     {
682       xfree (get_membuf (&data, &len));
683       return unlock_scd (map_assuan_err (rc));
684     }
685   *r_buf = get_membuf (&data, &buflen);
686   if (!*r_buf)
687     return unlock_scd (gpg_error (GPG_ERR_ENOMEM));
688
689   if (!gcry_sexp_canon_len (*r_buf, buflen, NULL, NULL))
690     {
691       xfree (*r_buf); *r_buf = NULL;
692       return unlock_scd (gpg_error (GPG_ERR_INV_VALUE));
693     }
694
695   return unlock_scd (0);
696 }
697
698
699
700 \f
701 static AssuanError
702 pass_status_thru (void *opaque, const char *line)
703 {
704   ASSUAN_CONTEXT ctx = opaque;
705   char keyword[200];
706   int i;
707
708   for (i=0; *line && !spacep (line) && i < DIM(keyword)-1; line++, i++)
709     keyword[i] = *line;
710   keyword[i] = 0;
711   /* truncate any remaining keyword stuff. */
712   for (; *line && !spacep (line); line++)
713     ;
714   while (spacep (line))
715     line++;
716
717   assuan_write_status (ctx, keyword, line);
718   return 0;
719 }
720
721 static AssuanError
722 pass_data_thru (void *opaque, const void *buffer, size_t length)
723 {
724   ASSUAN_CONTEXT ctx = opaque;
725
726   assuan_send_data (ctx, buffer, length);
727   return 0;
728 }
729
730
731 /* Send the line CMDLINE with command for the SCDdaemon to it and send
732    all status messages back.  This command is used as a general quoting
733    mechanism to pass everything verbatim to SCDAEMOPN.  The PIN
734    inquirey is handled inside gpg-agent. */
735 int
736 agent_card_scd (ctrl_t ctrl, const char *cmdline,
737                 int (*getpin_cb)(void *, const char *, char*, size_t),
738                 void *getpin_cb_arg, void *assuan_context)
739 {
740   int rc;
741   struct inq_needpin_s inqparm;
742
743   rc = start_scd (ctrl);
744   if (rc)
745     return rc;
746
747   inqparm.ctx = scd_ctx;
748   inqparm.getpin_cb = getpin_cb;
749   inqparm.getpin_cb_arg = getpin_cb_arg;
750   rc = assuan_transact (scd_ctx, cmdline,
751                         pass_data_thru, assuan_context,
752                         inq_needpin, &inqparm,
753                         pass_status_thru, assuan_context);
754   if (rc)
755     {
756       return unlock_scd (map_assuan_err (rc));
757     }
758
759   return unlock_scd (0);
760 }
761
762