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