.
[gnupg.git] / agent / call-scd.c
1 /* call-scd.c - fork of the scdaemon to do SC operations
2  *      Copyright (C) 2001, 2002, 2005 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
86 \f
87 /* This function must be called once to initialize this module.  This
88    has to be done before a second thread is spawned.  We can't do the
89    static initialization because Pth emulation code might not be able
90    to do a static init; in particular, it is not possible for W32. */
91 void
92 initialize_module_call_scd (void)
93 {
94 #ifdef USE_GNU_PTH
95   static int initialized;
96
97   if (!initialized)
98     if (pth_mutex_init (&scd_lock))
99       initialized = 1;
100 #endif /*USE_GNU_PTH*/
101 }
102
103
104 static int 
105 unlock_scd (int rc)
106 {
107 #ifdef USE_GNU_PTH
108   if (!pth_mutex_release (&scd_lock))
109     {
110       log_error ("failed to release the SCD lock\n");
111       if (!rc)
112         rc = gpg_error (GPG_ERR_INTERNAL);
113     }
114 #endif /*USE_GNU_PTH*/
115   return rc;
116 }
117
118 /* To make sure we leave no secrets in our image after forking of the
119    scdaemon, we use this callback. */
120 static void
121 atfork_cb (void *opaque, int where)
122 {
123   if (!where)
124     gcry_control (GCRYCTL_TERM_SECMEM);
125 }
126
127
128 /* Fork off the SCdaemon if this has not already been done.  Note that
129    this fucntion alos locks the daemon.  */
130 static int
131 start_scd (ctrl_t ctrl)
132 {
133   int rc;
134   const char *pgmname;
135   ASSUAN_CONTEXT ctx;
136   const char *argv[3];
137   int no_close_list[3];
138   int i;
139
140   if (opt.disable_scdaemon)
141     return gpg_error (GPG_ERR_NOT_SUPPORTED);
142
143 #ifdef USE_GNU_PTH
144   if (!pth_mutex_acquire (&scd_lock, 0, NULL))
145     {
146       log_error ("failed to acquire the SCD lock\n");
147       return gpg_error (GPG_ERR_INTERNAL);
148     }
149 #endif
150
151   if (scd_ctx)
152     {
153       pid_t pid;
154
155       /* If we are not the connection currently using the SCD, return
156          an error. */
157       if (!active_connection)
158         {
159           active_connection_fd = ctrl->connection_fd;
160           active_connection = 1;
161         }
162       else if (ctrl->connection_fd != active_connection_fd)
163         return unlock_scd (gpg_error (GPG_ERR_CONFLICT));
164       
165       /* Okay, we already started the scdaemon and it is used by us.*/
166
167       /* We better do a sanity check now to see whether it has
168          accidently died. */
169 #ifndef HAVE_W32_SYSTEM 
170       pid = assuan_get_pid (scd_ctx);
171       if (pid != (pid_t)(-1) && pid
172           && ((rc=waitpid (pid, NULL, WNOHANG))==-1 || (rc == pid)) )
173         {
174           assuan_disconnect (scd_ctx);
175           scd_ctx = NULL;
176         }
177       else
178 #endif
179         return 0; 
180     }
181
182   if (opt.verbose)
183     log_info ("no running SCdaemon - starting it\n");
184       
185   if (fflush (NULL))
186     {
187       gpg_error_t tmperr = gpg_error (gpg_err_code_from_errno (errno));
188       log_error ("error flushing pending output: %s\n", strerror (errno));
189       return unlock_scd (tmperr);
190     }
191
192   if (!opt.scdaemon_program || !*opt.scdaemon_program)
193     opt.scdaemon_program = GNUPG_DEFAULT_SCDAEMON;
194   if ( !(pgmname = strrchr (opt.scdaemon_program, '/')))
195     pgmname = opt.scdaemon_program;
196   else
197     pgmname++;
198
199   argv[0] = pgmname;
200   argv[1] = "--server";
201   argv[2] = NULL;
202
203   i=0;
204   if (!opt.running_detached)
205     {
206       if (log_get_fd () != -1)
207         no_close_list[i++] = log_get_fd ();
208       no_close_list[i++] = fileno (stderr);
209     }
210   no_close_list[i] = -1;
211
212   /* Connect to the pinentry and perform initial handshaking */
213   rc = assuan_pipe_connect2 (&ctx, opt.scdaemon_program, (char**)argv,
214                              no_close_list, atfork_cb, NULL);
215   if (rc)
216     {
217       log_error ("can't connect to the SCdaemon: %s\n",
218                  assuan_strerror (rc));
219       return unlock_scd (gpg_error (GPG_ERR_NO_SCDAEMON));
220     }
221   scd_ctx = ctx;
222   active_connection_fd = ctrl->connection_fd;
223   active_connection = 1;
224
225   if (DBG_ASSUAN)
226     log_debug ("connection to SCdaemon established\n");
227
228   /* Tell the scdaemon that we want him to send us an event signal.
229      But only do this if we are running as a regular sever and not
230      simply as a pipe server. */
231   /* Fixme: gpg-agent does not use this signal yet.  */
232 /*   if (ctrl->connection_fd != -1) */
233 /*   { */
234 /* #ifndef HAVE_W32_SYSTEM */
235 /*     char buf[100]; */
236
237 /*     sprintf (buf, "OPTION event-signal=%d", SIGUSR2); */
238 /*     assuan_transact (scd_ctx, buf, NULL, NULL, NULL, NULL, NULL, NULL); */
239 /* #endif */
240 /*   } */
241
242   return 0;
243 }
244
245
246
247 /* Reset the SCD if it has been used. */
248 int
249 agent_reset_scd (ctrl_t ctrl)
250 {
251   int rc = 0;
252
253 #ifdef USE_GNU_PTH
254   if (!pth_mutex_acquire (&scd_lock, 0, NULL))
255     {
256       log_error ("failed to acquire the SCD lock for reset\n");
257       return gpg_error (GPG_ERR_INTERNAL);
258     }
259 #endif
260   if (active_connection && active_connection_fd == ctrl->connection_fd)
261     {
262       if (scd_ctx)
263         rc = assuan_transact (scd_ctx, "RESET", NULL, NULL,
264                               NULL, NULL, NULL, NULL);
265       active_connection_fd = -1;
266       active_connection = 0;
267     }
268
269   return unlock_scd (map_assuan_err (rc));
270 }
271
272
273 \f
274 /* Return a new malloced string by unescaping the string S.  Escaping
275    is percent escaping and '+'/space mapping.  A binary Nul will
276    silently be replaced by a 0xFF.  Function returns NULL to indicate
277    an out of memory status. */
278 static char *
279 unescape_status_string (const unsigned char *s)
280 {
281   char *buffer, *d;
282
283   buffer = d = xtrymalloc (strlen (s)+1);
284   if (!buffer)
285     return NULL;
286   while (*s)
287     {
288       if (*s == '%' && s[1] && s[2])
289         { 
290           s++;
291           *d = xtoi_2 (s);
292           if (!*d)
293             *d = '\xff';
294           d++;
295           s += 2;
296         }
297       else if (*s == '+')
298         {
299           *d++ = ' ';
300           s++;
301         }
302       else
303         *d++ = *s++;
304     }
305   *d = 0; 
306   return buffer;
307 }
308
309
310 \f
311 static AssuanError
312 learn_status_cb (void *opaque, const char *line)
313 {
314   struct learn_parm_s *parm = opaque;
315   const char *keyword = line;
316   int keywordlen;
317
318   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
319     ;
320   while (spacep (line))
321     line++;
322   if (keywordlen == 8 && !memcmp (keyword, "CERTINFO", keywordlen))
323     {
324       parm->certinfo_cb (parm->certinfo_cb_arg, line);
325     }
326   else if (keywordlen == 11 && !memcmp (keyword, "KEYPAIRINFO", keywordlen))
327     {
328       parm->kpinfo_cb (parm->kpinfo_cb_arg, line);
329     }
330   else if (keywordlen && *line)
331     {
332       parm->sinfo_cb (parm->sinfo_cb_arg, keyword, keywordlen, line);
333     }
334   
335   return 0;
336 }
337
338 /* Perform the LEARN command and return a list of all private keys
339    stored on the card. */
340 int
341 agent_card_learn (ctrl_t ctrl,
342                   void (*kpinfo_cb)(void*, const char *),
343                   void *kpinfo_cb_arg,
344                   void (*certinfo_cb)(void*, const char *),
345                   void *certinfo_cb_arg,
346                   void (*sinfo_cb)(void*, const char *, size_t, const char *),
347                   void *sinfo_cb_arg)
348 {
349   int rc;
350   struct learn_parm_s parm;
351
352   rc = start_scd (ctrl);
353   if (rc)
354     return rc;
355
356   memset (&parm, 0, sizeof parm);
357   parm.kpinfo_cb = kpinfo_cb;
358   parm.kpinfo_cb_arg = kpinfo_cb_arg;
359   parm.certinfo_cb = certinfo_cb;
360   parm.certinfo_cb_arg = certinfo_cb_arg;
361   parm.sinfo_cb = sinfo_cb;
362   parm.sinfo_cb_arg = sinfo_cb_arg;
363   rc = assuan_transact (scd_ctx, "LEARN --force",
364                         NULL, NULL, NULL, NULL,
365                         learn_status_cb, &parm);
366   if (rc)
367     return unlock_scd (map_assuan_err (rc));
368
369   return unlock_scd (0);
370 }
371
372
373 \f
374 static AssuanError
375 get_serialno_cb (void *opaque, const char *line)
376 {
377   char **serialno = opaque;
378   const char *keyword = line;
379   const char *s;
380   int keywordlen, n;
381
382   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
383     ;
384   while (spacep (line))
385     line++;
386
387   if (keywordlen == 8 && !memcmp (keyword, "SERIALNO", keywordlen))
388     {
389       if (*serialno)
390         return ASSUAN_Unexpected_Status;
391       for (n=0,s=line; hexdigitp (s); s++, n++)
392         ;
393       if (!n || (n&1)|| !(spacep (s) || !*s) )
394         return ASSUAN_Invalid_Status;
395       *serialno = xtrymalloc (n+1);
396       if (!*serialno)
397         return ASSUAN_Out_Of_Core;
398       memcpy (*serialno, line, n);
399       (*serialno)[n] = 0;
400     }
401   
402   return 0;
403 }
404
405 /* Return the serial number of the card or an appropriate error.  The
406    serial number is returned as a hexstring. */
407 int
408 agent_card_serialno (ctrl_t ctrl, char **r_serialno)
409 {
410   int rc;
411   char *serialno = NULL;
412
413   rc = start_scd (ctrl);
414   if (rc)
415     return rc;
416
417   rc = assuan_transact (scd_ctx, "SERIALNO",
418                         NULL, NULL, NULL, NULL,
419                         get_serialno_cb, &serialno);
420   if (rc)
421     {
422       xfree (serialno);
423       return unlock_scd (map_assuan_err (rc));
424     }
425   *r_serialno = serialno;
426   return unlock_scd (0);
427 }
428
429
430
431 \f
432 static AssuanError
433 membuf_data_cb (void *opaque, const void *buffer, size_t length)
434 {
435   membuf_t *data = opaque;
436
437   if (buffer)
438     put_membuf (data, buffer, length);
439   return 0;
440 }
441   
442 /* Handle the NEEDPIN inquiry. */
443 static AssuanError
444 inq_needpin (void *opaque, const char *line)
445 {
446   struct inq_needpin_s *parm = opaque;
447   char *pin;
448   size_t pinlen;
449   int rc;
450
451   if (!(!strncmp (line, "NEEDPIN", 7) && (line[7] == ' ' || !line[7])))
452     {
453       log_error ("unsupported inquiry `%s'\n", line);
454       return ASSUAN_Inquire_Unknown;
455     }
456   line += 7;
457
458   pinlen = 90;
459   pin = gcry_malloc_secure (pinlen);
460   if (!pin)
461     return ASSUAN_Out_Of_Core;
462
463   rc = parm->getpin_cb (parm->getpin_cb_arg, line, pin, pinlen);
464   if (rc)
465     rc = ASSUAN_Canceled;
466   if (!rc)
467     rc = assuan_send_data (parm->ctx, pin, pinlen);
468   xfree (pin);
469
470   return rc;
471 }
472
473
474
475 /* Create a signature using the current card */
476 int
477 agent_card_pksign (ctrl_t ctrl,
478                    const char *keyid,
479                    int (*getpin_cb)(void *, const char *, char*, size_t),
480                    void *getpin_cb_arg,
481                    const unsigned char *indata, size_t indatalen,
482                    char **r_buf, size_t *r_buflen)
483 {
484   int rc, i;
485   char *p, line[ASSUAN_LINELENGTH];
486   membuf_t data;
487   struct inq_needpin_s inqparm;
488   size_t len;
489   unsigned char *sigbuf;
490   size_t sigbuflen;
491
492   *r_buf = NULL;
493   rc = start_scd (ctrl);
494   if (rc)
495     return rc;
496
497   if (indatalen*2 + 50 > DIM(line))
498     return unlock_scd (gpg_error (GPG_ERR_GENERAL));
499
500   sprintf (line, "SETDATA ");
501   p = line + strlen (line);
502   for (i=0; i < indatalen ; i++, p += 2 )
503     sprintf (p, "%02X", indata[i]);
504   rc = assuan_transact (scd_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
505   if (rc)
506     return unlock_scd (map_assuan_err (rc));
507
508   init_membuf (&data, 1024);
509   inqparm.ctx = scd_ctx;
510   inqparm.getpin_cb = getpin_cb;
511   inqparm.getpin_cb_arg = getpin_cb_arg;
512   snprintf (line, DIM(line)-1, 
513             ctrl->use_auth_call? "PKAUTH %s":"PKSIGN %s", keyid);
514   line[DIM(line)-1] = 0;
515   rc = assuan_transact (scd_ctx, line,
516                         membuf_data_cb, &data,
517                         inq_needpin, &inqparm,
518                         NULL, NULL);
519   if (rc)
520     {
521       xfree (get_membuf (&data, &len));
522       return unlock_scd (map_assuan_err (rc));
523     }
524   sigbuf = get_membuf (&data, &sigbuflen);
525
526   /* Create an S-expression from it which is formatted like this:
527      "(7:sig-val(3:rsa(1:sSIGBUFLEN:SIGBUF)))" */
528   *r_buflen = 21 + 11 + sigbuflen + 4;
529   *r_buf = xtrymalloc (*r_buflen);
530   if (!*r_buf)
531     {
532       gpg_error_t tmperr = out_of_core ();
533       xfree (*r_buf);
534       return unlock_scd (tmperr);
535     }
536   p = stpcpy (*r_buf, "(7:sig-val(3:rsa(1:s" );
537   sprintf (p, "%u:", (unsigned int)sigbuflen);
538   p += strlen (p);
539   memcpy (p, sigbuf, sigbuflen);
540   p += sigbuflen;
541   strcpy (p, ")))");
542   xfree (sigbuf);
543
544   assert (gcry_sexp_canon_len (*r_buf, *r_buflen, NULL, NULL));
545   return unlock_scd (0);
546 }
547
548 /* Decipher INDATA using the current card. Note that the returned value is */
549 int
550 agent_card_pkdecrypt (ctrl_t ctrl,
551                       const char *keyid,
552                       int (*getpin_cb)(void *, const char *, char*, size_t),
553                       void *getpin_cb_arg,
554                       const unsigned char *indata, size_t indatalen,
555                       char **r_buf, size_t *r_buflen)
556 {
557   int rc, i;
558   char *p, line[ASSUAN_LINELENGTH];
559   membuf_t data;
560   struct inq_needpin_s inqparm;
561   size_t len;
562
563   *r_buf = NULL;
564   rc = start_scd (ctrl);
565   if (rc)
566     return rc;
567
568   /* FIXME: use secure memory where appropriate */
569   if (indatalen*2 + 50 > DIM(line))
570     return unlock_scd (gpg_error (GPG_ERR_GENERAL));
571
572   sprintf (line, "SETDATA ");
573   p = line + strlen (line);
574   for (i=0; i < indatalen ; i++, p += 2 )
575     sprintf (p, "%02X", indata[i]);
576   rc = assuan_transact (scd_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
577   if (rc)
578     return unlock_scd (map_assuan_err (rc));
579
580   init_membuf (&data, 1024);
581   inqparm.ctx = scd_ctx;
582   inqparm.getpin_cb = getpin_cb;
583   inqparm.getpin_cb_arg = getpin_cb_arg;
584   snprintf (line, DIM(line)-1, "PKDECRYPT %s", keyid);
585   line[DIM(line)-1] = 0;
586   rc = assuan_transact (scd_ctx, line,
587                         membuf_data_cb, &data,
588                         inq_needpin, &inqparm,
589                         NULL, NULL);
590   if (rc)
591     {
592       xfree (get_membuf (&data, &len));
593       return unlock_scd (map_assuan_err (rc));
594     }
595   *r_buf = get_membuf (&data, r_buflen);
596   if (!*r_buf)
597     return unlock_scd (gpg_error (GPG_ERR_ENOMEM));
598
599   return unlock_scd (0);
600 }
601
602
603 \f
604 /* Read a certificate with ID into R_BUF and R_BUFLEN. */
605 int
606 agent_card_readcert (ctrl_t ctrl,
607                      const char *id, char **r_buf, size_t *r_buflen)
608 {
609   int rc;
610   char line[ASSUAN_LINELENGTH];
611   membuf_t data;
612   size_t len;
613
614   *r_buf = NULL;
615   rc = start_scd (ctrl);
616   if (rc)
617     return rc;
618
619   init_membuf (&data, 1024);
620   snprintf (line, DIM(line)-1, "READCERT %s", id);
621   line[DIM(line)-1] = 0;
622   rc = assuan_transact (scd_ctx, line,
623                         membuf_data_cb, &data,
624                         NULL, NULL,
625                         NULL, NULL);
626   if (rc)
627     {
628       xfree (get_membuf (&data, &len));
629       return unlock_scd (map_assuan_err (rc));
630     }
631   *r_buf = get_membuf (&data, r_buflen);
632   if (!*r_buf)
633     return unlock_scd (gpg_error (GPG_ERR_ENOMEM));
634
635   return unlock_scd (0);
636 }
637
638
639 \f
640 /* Read a key with ID and return it in an allocate buffer pointed to
641    by r_BUF as a valid S-expression. */
642 int
643 agent_card_readkey (ctrl_t ctrl, const char *id, unsigned char **r_buf)
644 {
645   int rc;
646   char line[ASSUAN_LINELENGTH];
647   membuf_t data;
648   size_t len, buflen;
649
650   *r_buf = NULL;
651   rc = start_scd (ctrl);
652   if (rc)
653     return rc;
654
655   init_membuf (&data, 1024);
656   snprintf (line, DIM(line)-1, "READKEY %s", id);
657   line[DIM(line)-1] = 0;
658   rc = assuan_transact (scd_ctx, line,
659                         membuf_data_cb, &data,
660                         NULL, NULL,
661                         NULL, NULL);
662   if (rc)
663     {
664       xfree (get_membuf (&data, &len));
665       return unlock_scd (map_assuan_err (rc));
666     }
667   *r_buf = get_membuf (&data, &buflen);
668   if (!*r_buf)
669     return unlock_scd (gpg_error (GPG_ERR_ENOMEM));
670
671   if (!gcry_sexp_canon_len (*r_buf, buflen, NULL, NULL))
672     {
673       xfree (*r_buf); *r_buf = NULL;
674       return unlock_scd (gpg_error (GPG_ERR_INV_VALUE));
675     }
676
677   return unlock_scd (0);
678 }
679
680
681 \f
682 /* Type used with the card_getattr_cb.  */
683 struct card_getattr_parm_s {
684   const char *keyword;  /* Keyword to look for.  */
685   size_t keywordlen;    /* strlen of KEYWORD.  */
686   char *data;           /* Malloced and unescaped data.  */
687   int error;            /* ERRNO value or 0 on success. */
688 };
689
690 /* Callback function for agent_card_getattr.  */
691 static assuan_error_t
692 card_getattr_cb (void *opaque, const char *line)
693 {
694   struct card_getattr_parm_s *parm = opaque;
695   const char *keyword = line;
696   int keywordlen;
697
698   if (parm->data)
699     return 0; /* We want only the first occurrence.  */
700
701   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
702     ;
703   while (spacep (line))
704     line++;
705
706   if (keywordlen == parm->keywordlen
707       && !memcmp (keyword, parm->keyword, keywordlen))
708     {
709       parm->data = unescape_status_string (line);
710       if (!parm->data)
711         parm->error = errno;
712     }
713   
714   return 0;
715 }
716
717
718 /* Call the agent to retrieve a single line data object. On success
719    the object is malloced and stored at RESULT; it is guaranteed that
720    NULL is never stored in this case.  On error an error code is
721    returned and NULL stored at RESULT. */
722 gpg_error_t
723 agent_card_getattr (ctrl_t ctrl, const char *name, char **result)
724 {
725   int err;
726   struct card_getattr_parm_s parm;
727   char line[ASSUAN_LINELENGTH];
728
729   *result = NULL;
730
731   if (!*name)
732     return gpg_error (GPG_ERR_INV_VALUE);
733
734   memset (&parm, 0, sizeof parm);
735   parm.keyword = name;
736   parm.keywordlen = strlen (name);
737
738   /* We assume that NAME does not need escaping. */
739   if (8 + strlen (name) > DIM(line)-1)
740     return gpg_error (GPG_ERR_TOO_LARGE);
741   stpcpy (stpcpy (line, "GETATTR "), name); 
742
743   err = start_scd (ctrl);
744   if (err)
745     return err;
746
747   err = map_assuan_err (assuan_transact (scd_ctx, line,
748                                          NULL, NULL, NULL, NULL,
749                                          card_getattr_cb, &parm));
750   if (!err && parm.error)
751     err = gpg_error_from_errno (parm.error);
752   
753   if (!err && !parm.data)
754     err = gpg_error (GPG_ERR_NO_DATA);
755   
756   if (!err)
757     *result = parm.data;
758   else
759     xfree (parm.data);
760
761   return unlock_scd (err);
762 }
763
764
765
766 \f
767 static AssuanError
768 pass_status_thru (void *opaque, const char *line)
769 {
770   ASSUAN_CONTEXT ctx = opaque;
771   char keyword[200];
772   int i;
773
774   for (i=0; *line && !spacep (line) && i < DIM(keyword)-1; line++, i++)
775     keyword[i] = *line;
776   keyword[i] = 0;
777   /* truncate any remaining keyword stuff. */
778   for (; *line && !spacep (line); line++)
779     ;
780   while (spacep (line))
781     line++;
782
783   assuan_write_status (ctx, keyword, line);
784   return 0;
785 }
786
787 static AssuanError
788 pass_data_thru (void *opaque, const void *buffer, size_t length)
789 {
790   ASSUAN_CONTEXT ctx = opaque;
791
792   assuan_send_data (ctx, buffer, length);
793   return 0;
794 }
795
796
797 /* Send the line CMDLINE with command for the SCDdaemon to it and send
798    all status messages back.  This command is used as a general quoting
799    mechanism to pass everything verbatim to SCDAEMOPN.  The PIN
800    inquirey is handled inside gpg-agent. */
801 int
802 agent_card_scd (ctrl_t ctrl, const char *cmdline,
803                 int (*getpin_cb)(void *, const char *, char*, size_t),
804                 void *getpin_cb_arg, void *assuan_context)
805 {
806   int rc;
807   struct inq_needpin_s inqparm;
808
809   rc = start_scd (ctrl);
810   if (rc)
811     return rc;
812
813   inqparm.ctx = scd_ctx;
814   inqparm.getpin_cb = getpin_cb;
815   inqparm.getpin_cb_arg = getpin_cb_arg;
816   rc = assuan_transact (scd_ctx, cmdline,
817                         pass_data_thru, assuan_context,
818                         inq_needpin, &inqparm,
819                         pass_status_thru, assuan_context);
820   if (rc)
821     {
822       return unlock_scd (map_assuan_err (rc));
823     }
824
825   return unlock_scd (0);
826 }
827
828