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