SCD changes for PC/SC 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, 2005, 2007 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 3 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, see <http://www.gnu.org/licenses/>.
18  */
19
20 #include <config.h>
21 #include <errno.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <ctype.h>
26 #include <assert.h>
27 #include <unistd.h>
28 #include <signal.h>
29 #include <sys/stat.h>
30 #include <sys/types.h>
31 #ifndef HAVE_W32_SYSTEM
32 #include <sys/wait.h>
33 #endif
34 #include <pth.h>
35
36 #include "agent.h"
37 #include <assuan.h>
38
39 #ifdef _POSIX_OPEN_MAX
40 #define MAX_OPEN_FDS _POSIX_OPEN_MAX
41 #else
42 #define MAX_OPEN_FDS 20
43 #endif
44
45 /* Definition of module local data of the CTRL structure.  */
46 struct scd_local_s
47 {
48   /* We keep a list of all allocated context with a an achnor at
49      SCD_LOCAL_LIST (see below). */
50   struct scd_local_s *next_local;
51
52   /* We need to get back to the ctrl object actually referencing this
53      structure.  This is really an awkward way of enumerint the lcoal
54      contects.  A much cleaner way would be to keep a global list of
55      ctrl objects to enumerate them.  */
56   ctrl_t ctrl_backlink;
57
58   assuan_context_t ctx; /* NULL or session context for the SCdaemon
59                            used with this connection. */
60   int locked;           /* This flag is used to assert proper use of
61                            start_scd and unlock_scd. */
62
63 };
64
65
66 /* Callback parameter for learn card */
67 struct learn_parm_s
68 {
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 {
79   assuan_context_t ctx;
80   int (*getpin_cb)(void *, const char *, char*, size_t);
81   void *getpin_cb_arg;
82   assuan_context_t passthru;  /* If not NULL, pass unknown inquiries
83                                  up to the caller.  */
84 };
85
86
87 /* To keep track of all active SCD contexts, we keep a linked list
88    anchored at this variable. */
89 static struct scd_local_s *scd_local_list;
90
91 /* A Mutex used inside the start_scd function. */
92 static pth_mutex_t start_scd_lock;
93
94 /* A malloced string with the name of the socket to be used for
95    additional connections.  May be NULL if not provided by
96    SCdaemon. */
97 static char *socket_name;
98
99 /* The context of the primary connection.  This is also used as a flag
100    to indicate whether the scdaemon has been started. */
101 static assuan_context_t primary_scd_ctx;
102
103 /* To allow reuse of the primary connection, the following flag is set
104    to true if the primary context has been reset and is not in use by
105    any connection. */
106 static int primary_scd_ctx_reusable;
107
108
109
110 /* Local prototypes.  */
111 static assuan_error_t membuf_data_cb (void *opaque,
112                                       const void *buffer, size_t length);
113
114
115
116 \f
117 /* This function must be called once to initialize this module.  This
118    has to be done before a second thread is spawned.  We can't do the
119    static initialization because Pth emulation code might not be able
120    to do a static init; in particular, it is not possible for W32. */
121 void
122 initialize_module_call_scd (void)
123 {
124   static int initialized;
125
126   if (!initialized)
127     {
128       if (!pth_mutex_init (&start_scd_lock))
129         log_fatal ("error initializing mutex: %s\n", strerror (errno));
130       initialized = 1;
131     }
132 }
133
134
135 static void
136 dump_mutex_state (pth_mutex_t *m)
137 {
138 #ifdef _W32_PTH_H
139   log_printf ("unknown under W32");
140 #else
141   if (!(m->mx_state & PTH_MUTEX_INITIALIZED))
142     log_printf ("not_initialized");
143   else if (!(m->mx_state & PTH_MUTEX_LOCKED))
144     log_printf ("not_locked");
145   else
146     log_printf ("locked tid=0x%lx count=%lu", (long)m->mx_owner, m->mx_count);
147 #endif
148 }
149
150
151 /* This function may be called to print infromation pertaining to the
152    current state of this module to the log. */
153 void
154 agent_scd_dump_state (void)
155 {
156   log_info ("agent_scd_dump_state: scd_lock=");
157   dump_mutex_state (&start_scd_lock);
158   log_printf ("\n");
159   log_info ("agent_scd_dump_state: primary_scd_ctx=%p pid=%ld reusable=%d\n",
160             primary_scd_ctx, 
161             (long)assuan_get_pid (primary_scd_ctx),
162             primary_scd_ctx_reusable);
163   if (socket_name)
164     log_info ("agent_scd_dump_state: socket=`%s'\n", socket_name);
165 }
166
167
168 /* The unlock_scd function shall be called after having accessed the
169    SCD.  It is currently not very useful but gives an opportunity to
170    keep track of connections currently calling SCD.  Note that the
171    "lock" operation is done by the start_scd() function which must be
172    called and error checked before any SCD operation.  CTRL is the
173    usual connection context and RC the error code to be passed trhough
174    the function. */
175 static int 
176 unlock_scd (ctrl_t ctrl, int rc)
177 {
178   if (ctrl->scd_local->locked != 1)
179     {
180       log_error ("unlock_scd: invalid lock count (%d)\n",
181                  ctrl->scd_local->locked);
182       if (!rc)
183         rc = gpg_error (GPG_ERR_INTERNAL);
184     }
185   ctrl->scd_local->locked = 0;
186   return rc;
187 }
188
189 /* To make sure we leave no secrets in our image after forking of the
190    scdaemon, we use this callback. */
191 static void
192 atfork_cb (void *opaque, int where)
193 {
194   if (!where)
195     gcry_control (GCRYCTL_TERM_SECMEM);
196 }
197
198
199 /* Fork off the SCdaemon if this has not already been done.  Lock the
200    daemon and make sure that a proper context has been setup in CTRL.
201    This function might also lock the daemon, which means that the
202    caller must call unlock_scd after this fucntion has returned
203    success and the actual Assuan transaction been done. */
204 static int
205 start_scd (ctrl_t ctrl)
206 {
207   gpg_error_t err = 0;
208   const char *pgmname;
209   assuan_context_t ctx;
210   const char *argv[3];
211   int no_close_list[3];
212   int i;
213   int rc;
214
215   if (opt.disable_scdaemon)
216     return gpg_error (GPG_ERR_NOT_SUPPORTED);
217
218   /* If this is the first call for this session, setup the local data
219      structure. */
220   if (!ctrl->scd_local)
221     {
222       ctrl->scd_local = xtrycalloc (1, sizeof *ctrl->scd_local);
223       if (!ctrl->scd_local)
224         return gpg_error_from_syserror ();
225       ctrl->scd_local->ctrl_backlink = ctrl;
226       ctrl->scd_local->next_local = scd_local_list;
227       scd_local_list = ctrl->scd_local;
228     }
229
230
231   /* Assert that the lock count is as expected. */
232   if (ctrl->scd_local->locked)
233     {
234       log_error ("start_scd: invalid lock count (%d)\n",
235                  ctrl->scd_local->locked);
236       return gpg_error (GPG_ERR_INTERNAL);
237     }
238   ctrl->scd_local->locked++;
239
240   if (ctrl->scd_local->ctx)
241     return 0; /* Okay, the context is fine.  We used to test for an
242                  alive context here and do an disconnect.  Now that we
243                  have a ticker function to check for it, it is easier
244                  not to check here but to let the connection run on an
245                  error instead. */
246
247
248   /* We need to protect the following code. */
249   if (!pth_mutex_acquire (&start_scd_lock, 0, NULL))
250     {
251       log_error ("failed to acquire the start_scd lock: %s\n",
252                  strerror (errno));
253       return gpg_error (GPG_ERR_INTERNAL);
254     }
255
256   /* Check whether the pipe server has already been started and in
257      this case either reuse a lingering pipe connection or establish a
258      new socket based one. */
259   if (primary_scd_ctx && primary_scd_ctx_reusable)
260     {
261       ctx = primary_scd_ctx;
262       primary_scd_ctx_reusable = 0;
263       if (opt.verbose)
264         log_info ("new connection to SCdaemon established (reusing)\n");
265       goto leave;
266     }
267
268   if (socket_name)
269     {
270       rc = assuan_socket_connect (&ctx, socket_name, 0);
271       if (rc)
272         {
273           log_error ("can't connect to socket `%s': %s\n",
274                      socket_name, gpg_strerror (rc));
275           err = gpg_error (GPG_ERR_NO_SCDAEMON);
276           goto leave;
277         }
278
279       if (opt.verbose)
280         log_info ("new connection to SCdaemon established\n");
281       goto leave;
282     }
283
284   if (primary_scd_ctx)
285     {
286       log_info ("SCdaemon is running but won't accept further connections\n");
287       err = gpg_error (GPG_ERR_NO_SCDAEMON);
288       goto leave;
289     }
290
291   /* Nope, it has not been started.  Fire it up now. */
292   if (opt.verbose)
293     log_info ("no running SCdaemon - starting it\n");
294       
295   if (fflush (NULL))
296     {
297 #ifndef HAVE_W32_SYSTEM
298       err = gpg_error_from_syserror ();
299 #endif
300       log_error ("error flushing pending output: %s\n", strerror (errno));
301       /* At least Windows XP fails here with EBADF.  According to docs
302          and Wine an fflush(NULL) is the same as _flushall.  However
303          the Wime implementaion does not flush stdin,stdout and stderr
304          - see above.  Lets try to ignore the error. */
305 #ifndef HAVE_W32_SYSTEM
306       goto leave;
307 #endif
308     }
309
310   if (!opt.scdaemon_program || !*opt.scdaemon_program)
311     opt.scdaemon_program = gnupg_module_name (GNUPG_MODULE_NAME_SCDAEMON);
312   if ( !(pgmname = strrchr (opt.scdaemon_program, '/')))
313     pgmname = opt.scdaemon_program;
314   else
315     pgmname++;
316
317   argv[0] = pgmname;
318   argv[1] = "--multi-server";
319   argv[2] = NULL;
320
321   i=0;
322   if (!opt.running_detached)
323     {
324       if (log_get_fd () != -1)
325         no_close_list[i++] = log_get_fd ();
326       no_close_list[i++] = fileno (stderr);
327     }
328   no_close_list[i] = -1;
329
330   /* Connect to the pinentry and perform initial handshaking.  Use
331      detached flag (128) so that under W32 SCDAEMON does not show up a
332      new window.  */
333   rc = assuan_pipe_connect_ext (&ctx, opt.scdaemon_program, argv,
334                                 no_close_list, atfork_cb, NULL, 128);
335   if (rc)
336     {
337       log_error ("can't connect to the SCdaemon: %s\n",
338                  gpg_strerror (rc));
339       err = gpg_error (GPG_ERR_NO_SCDAEMON);
340       goto leave;
341     }
342
343   if (opt.verbose)
344     log_debug ("first connection to SCdaemon established\n");
345
346   /* Get the name of the additional socket opened by scdaemon. */
347   {
348     membuf_t data;
349     unsigned char *databuf;
350     size_t datalen;
351
352     xfree (socket_name);
353     socket_name = NULL;
354     init_membuf (&data, 256);
355     assuan_transact (ctx, "GETINFO socket_name",
356                      membuf_data_cb, &data, NULL, NULL, NULL, NULL);
357
358     databuf = get_membuf (&data, &datalen);
359     if (databuf && datalen)
360       {
361         socket_name = xtrymalloc (datalen + 1);
362         if (!socket_name)
363           log_error ("warning: can't store socket name: %s\n",
364                      strerror (errno));
365         else
366           {
367             memcpy (socket_name, databuf, datalen);
368             socket_name[datalen] = 0;
369             if (DBG_ASSUAN)
370               log_debug ("additional connections at `%s'\n", socket_name);
371           }
372       }
373     xfree (databuf);
374   }
375
376   /* Tell the scdaemon we want him to send us an event signal. */
377   {
378     char buf[100];
379
380 #ifdef HAVE_W32_SYSTEM
381     /* Use estream snprintf due to a bug in mingw32 related to the l
382        modifier.  */
383     estream_snprintf (buf, sizeof buf, "OPTION event-signal=%lx", 
384                       (unsigned long)get_agent_scd_notify_event ());
385 #else
386     snprintf (buf, sizeof buf, "OPTION event-signal=%d", SIGUSR2);
387 #endif
388     assuan_transact (ctx, buf, NULL, NULL, NULL, NULL, NULL, NULL);
389   }
390
391   primary_scd_ctx = ctx;
392   primary_scd_ctx_reusable = 0;
393
394  leave:
395   if (err)
396     {
397       unlock_scd (ctrl, err);
398     } 
399   else
400     {
401       ctrl->scd_local->ctx = ctx;
402     }
403   if (!pth_mutex_release (&start_scd_lock))
404     log_error ("failed to release the start_scd lock: %s\n", strerror (errno));
405   return err;
406 }
407
408
409 /* Check whether the Scdaemon is still alive and clean it up if not. */
410 void
411 agent_scd_check_aliveness (void)
412 {
413   pth_event_t evt;
414   pid_t pid;
415   int rc;
416 #ifdef HAVE_W32_SYSTEM
417   DWORD dummyec;
418 #endif
419
420   if (!primary_scd_ctx)
421     return; /* No scdaemon running. */
422
423   /* This is not a critical function so we use a short timeout while
424      acquiring the lock.  */
425   evt = pth_event (PTH_EVENT_TIME, pth_timeout (1, 0));
426   if (!pth_mutex_acquire (&start_scd_lock, 0, evt))
427     {
428       if (pth_event_occurred (evt))
429         {
430           if (opt.verbose > 1)
431             log_info ("failed to acquire the start_scd lock while"
432                       " doing an aliveness check: %s\n", "timeout");
433         }
434       else
435         log_error ("failed to acquire the start_scd lock while"
436                    " doing an aliveness check: %s\n", strerror (errno));
437       pth_event_free (evt, PTH_FREE_THIS);
438       return;
439     }
440   pth_event_free (evt, PTH_FREE_THIS);
441
442   if (primary_scd_ctx)
443     {
444       pid = assuan_get_pid (primary_scd_ctx);
445 #ifdef HAVE_W32_SYSTEM
446       if (pid != (pid_t)(void*)(-1) && pid
447           && !GetExitCodeProcess ((HANDLE)pid, &dummyec))
448 #else
449       if (pid != (pid_t)(-1) && pid
450           && ((rc=waitpid (pid, NULL, WNOHANG))==-1 || (rc == pid)) )
451 #endif
452         {
453           /* Okay, scdaemon died.  Disconnect the primary connection
454              now but take care that it won't do another wait. Also
455              cleanup all other connections and release their
456              resources.  The next use will start a new daemon then.
457              Due to the use of the START_SCD_LOCAL we are sure that
458              none of these context are actually in use. */
459           struct scd_local_s *sl;
460
461           assuan_set_flag (primary_scd_ctx, ASSUAN_NO_WAITPID, 1);
462           assuan_disconnect (primary_scd_ctx);
463
464           for (sl=scd_local_list; sl; sl = sl->next_local)
465             {
466               if (sl->ctx)
467                 {
468                   if (sl->ctx != primary_scd_ctx)
469                     assuan_disconnect (sl->ctx);
470                   sl->ctx = NULL;
471                 }
472             }
473           
474           primary_scd_ctx = NULL;
475           primary_scd_ctx_reusable = 0;
476
477           xfree (socket_name);
478           socket_name = NULL;
479         }
480     }
481
482   if (!pth_mutex_release (&start_scd_lock))
483     log_error ("failed to release the start_scd lock while"
484                " doing the aliveness check: %s\n", strerror (errno));
485 }
486
487
488
489 /* Reset the SCD if it has been used.  Actually it is not a reset but
490    a cleanup of resources used by the current connection. */
491 int
492 agent_reset_scd (ctrl_t ctrl)
493 {
494   if (ctrl->scd_local)
495     {
496       if (ctrl->scd_local->ctx)
497         {
498           /* We can't disconnect the primary context because libassuan
499              does a waitpid on it and thus the system would hang.
500              Instead we send a reset and keep that connection for
501              reuse. */
502           if (ctrl->scd_local->ctx == primary_scd_ctx)
503             {
504               /* Send a RESTART to the SCD.  This is required for the
505                  primary connection as a kind of virtual EOF; we don't
506                  have another way to tell it that the next command
507                  should be viewed as if a new connection has been
508                  made.  For the non-primary connections this is not
509                  needed as we simply close the socket.  We don't check
510                  for an error here because the RESTART may fail for
511                  example if the scdaemon has already been terminated.
512                  Anyway, we need to set the reusable flag to make sure
513                  that the aliveness check can clean it up. */
514               assuan_transact (primary_scd_ctx, "RESTART",
515                                NULL, NULL, NULL, NULL, NULL, NULL);
516               primary_scd_ctx_reusable = 1;
517             }
518           else
519             assuan_disconnect (ctrl->scd_local->ctx);
520           ctrl->scd_local->ctx = NULL;
521         }
522       
523       /* Remove the local context from our list and release it. */
524       if (!scd_local_list)
525         BUG ();
526       else if (scd_local_list == ctrl->scd_local)
527         scd_local_list = ctrl->scd_local->next_local;
528       else
529         {
530           struct scd_local_s *sl;
531       
532           for (sl=scd_local_list; sl->next_local; sl = sl->next_local)
533             if (sl->next_local == ctrl->scd_local)
534               break;
535           if (!sl->next_local)
536             BUG ();
537           sl->next_local = ctrl->scd_local->next_local;
538         }
539       xfree (ctrl->scd_local);
540       ctrl->scd_local = NULL;
541     }
542
543   return 0;
544 }
545
546
547 \f
548 /* Return a new malloced string by unescaping the string S.  Escaping
549    is percent escaping and '+'/space mapping.  A binary Nul will
550    silently be replaced by a 0xFF.  Function returns NULL to indicate
551    an out of memory status. */
552 static char *
553 unescape_status_string (const unsigned char *s)
554 {
555   char *buffer, *d;
556
557   buffer = d = xtrymalloc (strlen ((const char*)s)+1);
558   if (!buffer)
559     return NULL;
560   while (*s)
561     {
562       if (*s == '%' && s[1] && s[2])
563         { 
564           s++;
565           *d = xtoi_2 (s);
566           if (!*d)
567             *d = '\xff';
568           d++;
569           s += 2;
570         }
571       else if (*s == '+')
572         {
573           *d++ = ' ';
574           s++;
575         }
576       else
577         *d++ = *s++;
578     }
579   *d = 0; 
580   return buffer;
581 }
582
583
584 \f
585 static int
586 learn_status_cb (void *opaque, const char *line)
587 {
588   struct learn_parm_s *parm = opaque;
589   const char *keyword = line;
590   int keywordlen;
591
592   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
593     ;
594   while (spacep (line))
595     line++;
596   if (keywordlen == 8 && !memcmp (keyword, "CERTINFO", keywordlen))
597     {
598       parm->certinfo_cb (parm->certinfo_cb_arg, line);
599     }
600   else if (keywordlen == 11 && !memcmp (keyword, "KEYPAIRINFO", keywordlen))
601     {
602       parm->kpinfo_cb (parm->kpinfo_cb_arg, line);
603     }
604   else if (keywordlen && *line)
605     {
606       parm->sinfo_cb (parm->sinfo_cb_arg, keyword, keywordlen, line);
607     }
608   
609   return 0;
610 }
611
612 /* Perform the LEARN command and return a list of all private keys
613    stored on the card. */
614 int
615 agent_card_learn (ctrl_t ctrl,
616                   void (*kpinfo_cb)(void*, const char *),
617                   void *kpinfo_cb_arg,
618                   void (*certinfo_cb)(void*, const char *),
619                   void *certinfo_cb_arg,
620                   void (*sinfo_cb)(void*, const char *, size_t, const char *),
621                   void *sinfo_cb_arg)
622 {
623   int rc;
624   struct learn_parm_s parm;
625
626   rc = start_scd (ctrl);
627   if (rc)
628     return rc;
629
630   memset (&parm, 0, sizeof parm);
631   parm.kpinfo_cb = kpinfo_cb;
632   parm.kpinfo_cb_arg = kpinfo_cb_arg;
633   parm.certinfo_cb = certinfo_cb;
634   parm.certinfo_cb_arg = certinfo_cb_arg;
635   parm.sinfo_cb = sinfo_cb;
636   parm.sinfo_cb_arg = sinfo_cb_arg;
637   rc = assuan_transact (ctrl->scd_local->ctx, "LEARN --force",
638                         NULL, NULL, NULL, NULL,
639                         learn_status_cb, &parm);
640   if (rc)
641     return unlock_scd (ctrl, rc);
642
643   return unlock_scd (ctrl, 0);
644 }
645
646
647 \f
648 static int
649 get_serialno_cb (void *opaque, const char *line)
650 {
651   char **serialno = opaque;
652   const char *keyword = line;
653   const char *s;
654   int keywordlen, n;
655
656   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
657     ;
658   while (spacep (line))
659     line++;
660
661   if (keywordlen == 8 && !memcmp (keyword, "SERIALNO", keywordlen))
662     {
663       if (*serialno)
664         return gpg_error (GPG_ERR_CONFLICT); /* Unexpected status line. */
665       for (n=0,s=line; hexdigitp (s); s++, n++)
666         ;
667       if (!n || (n&1)|| !(spacep (s) || !*s) )
668         return gpg_error (GPG_ERR_ASS_PARAMETER);
669       *serialno = xtrymalloc (n+1);
670       if (!*serialno)
671         return out_of_core ();
672       memcpy (*serialno, line, n);
673       (*serialno)[n] = 0;
674     }
675   
676   return 0;
677 }
678
679 /* Return the serial number of the card or an appropriate error.  The
680    serial number is returned as a hexstring. */
681 int
682 agent_card_serialno (ctrl_t ctrl, char **r_serialno)
683 {
684   int rc;
685   char *serialno = NULL;
686
687   rc = start_scd (ctrl);
688   if (rc)
689     return rc;
690
691   rc = assuan_transact (ctrl->scd_local->ctx, "SERIALNO",
692                         NULL, NULL, NULL, NULL,
693                         get_serialno_cb, &serialno);
694   if (rc)
695     {
696       xfree (serialno);
697       return unlock_scd (ctrl, rc);
698     }
699   *r_serialno = serialno;
700   return unlock_scd (ctrl, 0);
701 }
702
703
704
705 \f
706 static int
707 membuf_data_cb (void *opaque, const void *buffer, size_t length)
708 {
709   membuf_t *data = opaque;
710
711   if (buffer)
712     put_membuf (data, buffer, length);
713   return 0;
714 }
715   
716 /* Handle the NEEDPIN inquiry. */
717 static int
718 inq_needpin (void *opaque, const char *line)
719 {
720   struct inq_needpin_s *parm = opaque;
721   char *pin;
722   size_t pinlen;
723   int rc;
724
725   if (!strncmp (line, "NEEDPIN", 7) && (line[7] == ' ' || !line[7]))
726     {
727       line += 7;
728       while (*line == ' ')
729         line++;
730       
731       pinlen = 90;
732       pin = gcry_malloc_secure (pinlen);
733       if (!pin)
734         return out_of_core ();
735
736       rc = parm->getpin_cb (parm->getpin_cb_arg, line, pin, pinlen);
737       if (!rc)
738         rc = assuan_send_data (parm->ctx, pin, pinlen);
739       xfree (pin);
740     }
741   else if (!strncmp (line, "POPUPKEYPADPROMPT", 17)
742            && (line[17] == ' ' || !line[17]))
743     {
744       line += 17;
745       while (*line == ' ')
746         line++;
747       
748       rc = parm->getpin_cb (parm->getpin_cb_arg, line, NULL, 1);
749     }
750   else if (!strncmp (line, "DISMISSKEYPADPROMPT", 19)
751            && (line[19] == ' ' || !line[19]))
752     {
753       rc = parm->getpin_cb (parm->getpin_cb_arg, "", NULL, 0);
754     }
755   else if (parm->passthru)
756     {
757       unsigned char *value;
758       size_t valuelen;
759       int rest;
760       int needrest = !strncmp (line, "KEYDATA", 8);
761
762       /* Pass the inquiry up to our caller.  We limit the maximum
763          amount to an arbitrary value.  As we know that the KEYDATA
764          enquiry is pretty sensitive we disable logging then */
765       if ((rest = (needrest
766                    && !assuan_get_flag (parm->passthru, ASSUAN_CONFIDENTIAL))))
767         assuan_begin_confidential (parm->passthru);
768       rc = assuan_inquire (parm->passthru, line, &value, &valuelen, 8096);
769       if (rest)
770         assuan_end_confidential (parm->passthru);
771       if (!rc)
772         {
773           if ((rest = (needrest 
774                        && !assuan_get_flag (parm->ctx, ASSUAN_CONFIDENTIAL))))
775             assuan_begin_confidential (parm->ctx);
776           rc = assuan_send_data (parm->ctx, value, valuelen);
777           if (rest)
778             assuan_end_confidential (parm->ctx);
779           xfree (value);
780         }
781       else
782         log_error ("error forwarding inquiry `%s': %s\n", 
783                    line, gpg_strerror (rc));
784     }
785   else
786     {
787       log_error ("unsupported inquiry `%s'\n", line);
788       rc = gpg_error (GPG_ERR_ASS_UNKNOWN_INQUIRE);
789     }
790
791   return rc;
792 }
793
794
795
796 /* Create a signature using the current card */
797 int
798 agent_card_pksign (ctrl_t ctrl,
799                    const char *keyid,
800                    int (*getpin_cb)(void *, const char *, char*, size_t),
801                    void *getpin_cb_arg,
802                    const unsigned char *indata, size_t indatalen,
803                    unsigned char **r_buf, size_t *r_buflen)
804 {
805   int rc, i;
806   char *p, line[ASSUAN_LINELENGTH];
807   membuf_t data;
808   struct inq_needpin_s inqparm;
809   size_t len;
810   unsigned char *sigbuf;
811   size_t sigbuflen;
812
813   *r_buf = NULL;
814   rc = start_scd (ctrl);
815   if (rc)
816     return rc;
817
818   if (indatalen*2 + 50 > DIM(line))
819     return unlock_scd (ctrl, gpg_error (GPG_ERR_GENERAL));
820
821   sprintf (line, "SETDATA ");
822   p = line + strlen (line);
823   for (i=0; i < indatalen ; i++, p += 2 )
824     sprintf (p, "%02X", indata[i]);
825   rc = assuan_transact (ctrl->scd_local->ctx, line,
826                         NULL, NULL, NULL, NULL, NULL, NULL);
827   if (rc)
828     return unlock_scd (ctrl, rc);
829
830   init_membuf (&data, 1024);
831   inqparm.ctx = ctrl->scd_local->ctx;
832   inqparm.getpin_cb = getpin_cb;
833   inqparm.getpin_cb_arg = getpin_cb_arg;
834   inqparm.passthru = 0;
835   snprintf (line, DIM(line)-1, 
836             ctrl->use_auth_call? "PKAUTH %s":"PKSIGN %s", keyid);
837   line[DIM(line)-1] = 0;
838   rc = assuan_transact (ctrl->scd_local->ctx, line,
839                         membuf_data_cb, &data,
840                         inq_needpin, &inqparm,
841                         NULL, NULL);
842   if (rc)
843     {
844       xfree (get_membuf (&data, &len));
845       return unlock_scd (ctrl, rc);
846     }
847   sigbuf = get_membuf (&data, &sigbuflen);
848
849   /* Create an S-expression from it which is formatted like this:
850      "(7:sig-val(3:rsa(1:sSIGBUFLEN:SIGBUF)))" */
851   *r_buflen = 21 + 11 + sigbuflen + 4;
852   p = xtrymalloc (*r_buflen);
853   *r_buf = (unsigned char*)p;
854   if (!p)
855     return unlock_scd (ctrl, out_of_core ());
856   p = stpcpy (p, "(7:sig-val(3:rsa(1:s" );
857   sprintf (p, "%u:", (unsigned int)sigbuflen);
858   p += strlen (p);
859   memcpy (p, sigbuf, sigbuflen);
860   p += sigbuflen;
861   strcpy (p, ")))");
862   xfree (sigbuf);
863
864   assert (gcry_sexp_canon_len (*r_buf, *r_buflen, NULL, NULL));
865   return unlock_scd (ctrl, 0);
866 }
867
868 /* Decipher INDATA using the current card. Note that the returned value is */
869 int
870 agent_card_pkdecrypt (ctrl_t ctrl,
871                       const char *keyid,
872                       int (*getpin_cb)(void *, const char *, char*, size_t),
873                       void *getpin_cb_arg,
874                       const unsigned char *indata, size_t indatalen,
875                       char **r_buf, size_t *r_buflen)
876 {
877   int rc, i;
878   char *p, line[ASSUAN_LINELENGTH];
879   membuf_t data;
880   struct inq_needpin_s inqparm;
881   size_t len;
882
883   *r_buf = NULL;
884   rc = start_scd (ctrl);
885   if (rc)
886     return rc;
887
888   /* FIXME: use secure memory where appropriate */
889   if (indatalen*2 + 50 > DIM(line))
890     return unlock_scd (ctrl, gpg_error (GPG_ERR_GENERAL));
891
892   sprintf (line, "SETDATA ");
893   p = line + strlen (line);
894   for (i=0; i < indatalen ; i++, p += 2 )
895     sprintf (p, "%02X", indata[i]);
896   rc = assuan_transact (ctrl->scd_local->ctx, line,
897                         NULL, NULL, NULL, NULL, NULL, NULL);
898   if (rc)
899     return unlock_scd (ctrl, rc);
900
901   init_membuf (&data, 1024);
902   inqparm.ctx = ctrl->scd_local->ctx;
903   inqparm.getpin_cb = getpin_cb;
904   inqparm.getpin_cb_arg = getpin_cb_arg;
905   inqparm.passthru = 0;
906   snprintf (line, DIM(line)-1, "PKDECRYPT %s", keyid);
907   line[DIM(line)-1] = 0;
908   rc = assuan_transact (ctrl->scd_local->ctx, line,
909                         membuf_data_cb, &data,
910                         inq_needpin, &inqparm,
911                         NULL, NULL);
912   if (rc)
913     {
914       xfree (get_membuf (&data, &len));
915       return unlock_scd (ctrl, rc);
916     }
917   *r_buf = get_membuf (&data, r_buflen);
918   if (!*r_buf)
919     return unlock_scd (ctrl, gpg_error (GPG_ERR_ENOMEM));
920
921   return unlock_scd (ctrl, 0);
922 }
923
924
925 \f
926 /* Read a certificate with ID into R_BUF and R_BUFLEN. */
927 int
928 agent_card_readcert (ctrl_t ctrl,
929                      const char *id, char **r_buf, size_t *r_buflen)
930 {
931   int rc;
932   char line[ASSUAN_LINELENGTH];
933   membuf_t data;
934   size_t len;
935
936   *r_buf = NULL;
937   rc = start_scd (ctrl);
938   if (rc)
939     return rc;
940
941   init_membuf (&data, 1024);
942   snprintf (line, DIM(line)-1, "READCERT %s", id);
943   line[DIM(line)-1] = 0;
944   rc = assuan_transact (ctrl->scd_local->ctx, line,
945                         membuf_data_cb, &data,
946                         NULL, NULL,
947                         NULL, NULL);
948   if (rc)
949     {
950       xfree (get_membuf (&data, &len));
951       return unlock_scd (ctrl, rc);
952     }
953   *r_buf = get_membuf (&data, r_buflen);
954   if (!*r_buf)
955     return unlock_scd (ctrl, gpg_error (GPG_ERR_ENOMEM));
956
957   return unlock_scd (ctrl, 0);
958 }
959
960
961 \f
962 /* Read a key with ID and return it in an allocate buffer pointed to
963    by r_BUF as a valid S-expression. */
964 int
965 agent_card_readkey (ctrl_t ctrl, const char *id, unsigned char **r_buf)
966 {
967   int rc;
968   char line[ASSUAN_LINELENGTH];
969   membuf_t data;
970   size_t len, buflen;
971
972   *r_buf = NULL;
973   rc = start_scd (ctrl);
974   if (rc)
975     return rc;
976
977   init_membuf (&data, 1024);
978   snprintf (line, DIM(line)-1, "READKEY %s", id);
979   line[DIM(line)-1] = 0;
980   rc = assuan_transact (ctrl->scd_local->ctx, line,
981                         membuf_data_cb, &data,
982                         NULL, NULL,
983                         NULL, NULL);
984   if (rc)
985     {
986       xfree (get_membuf (&data, &len));
987       return unlock_scd (ctrl, rc);
988     }
989   *r_buf = get_membuf (&data, &buflen);
990   if (!*r_buf)
991     return unlock_scd (ctrl, gpg_error (GPG_ERR_ENOMEM));
992
993   if (!gcry_sexp_canon_len (*r_buf, buflen, NULL, NULL))
994     {
995       xfree (*r_buf); *r_buf = NULL;
996       return unlock_scd (ctrl, gpg_error (GPG_ERR_INV_VALUE));
997     }
998
999   return unlock_scd (ctrl, 0);
1000 }
1001
1002
1003 \f
1004 /* Type used with the card_getattr_cb.  */
1005 struct card_getattr_parm_s {
1006   const char *keyword;  /* Keyword to look for.  */
1007   size_t keywordlen;    /* strlen of KEYWORD.  */
1008   char *data;           /* Malloced and unescaped data.  */
1009   int error;            /* ERRNO value or 0 on success. */
1010 };
1011
1012 /* Callback function for agent_card_getattr.  */
1013 static assuan_error_t
1014 card_getattr_cb (void *opaque, const char *line)
1015 {
1016   struct card_getattr_parm_s *parm = opaque;
1017   const char *keyword = line;
1018   int keywordlen;
1019
1020   if (parm->data)
1021     return 0; /* We want only the first occurrence.  */
1022
1023   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
1024     ;
1025   while (spacep (line))
1026     line++;
1027
1028   if (keywordlen == parm->keywordlen
1029       && !memcmp (keyword, parm->keyword, keywordlen))
1030     {
1031       parm->data = unescape_status_string ((const unsigned char*)line);
1032       if (!parm->data)
1033         parm->error = errno;
1034     }
1035   
1036   return 0;
1037 }
1038
1039
1040 /* Call the agent to retrieve a single line data object. On success
1041    the object is malloced and stored at RESULT; it is guaranteed that
1042    NULL is never stored in this case.  On error an error code is
1043    returned and NULL stored at RESULT. */
1044 gpg_error_t
1045 agent_card_getattr (ctrl_t ctrl, const char *name, char **result)
1046 {
1047   int err;
1048   struct card_getattr_parm_s parm;
1049   char line[ASSUAN_LINELENGTH];
1050
1051   *result = NULL;
1052
1053   if (!*name)
1054     return gpg_error (GPG_ERR_INV_VALUE);
1055
1056   memset (&parm, 0, sizeof parm);
1057   parm.keyword = name;
1058   parm.keywordlen = strlen (name);
1059
1060   /* We assume that NAME does not need escaping. */
1061   if (8 + strlen (name) > DIM(line)-1)
1062     return gpg_error (GPG_ERR_TOO_LARGE);
1063   stpcpy (stpcpy (line, "GETATTR "), name); 
1064
1065   err = start_scd (ctrl);
1066   if (err)
1067     return err;
1068
1069   err = assuan_transact (ctrl->scd_local->ctx, line,
1070                          NULL, NULL, NULL, NULL,
1071                          card_getattr_cb, &parm);
1072   if (!err && parm.error)
1073     err = gpg_error_from_errno (parm.error);
1074   
1075   if (!err && !parm.data)
1076     err = gpg_error (GPG_ERR_NO_DATA);
1077   
1078   if (!err)
1079     *result = parm.data;
1080   else
1081     xfree (parm.data);
1082
1083   return unlock_scd (ctrl, err);
1084 }
1085
1086
1087
1088 \f
1089 static int
1090 pass_status_thru (void *opaque, const char *line)
1091 {
1092   assuan_context_t ctx = opaque;
1093   char keyword[200];
1094   int i;
1095
1096   for (i=0; *line && !spacep (line) && i < DIM(keyword)-1; line++, i++)
1097     keyword[i] = *line;
1098   keyword[i] = 0;
1099   /* truncate any remaining keyword stuff. */
1100   for (; *line && !spacep (line); line++)
1101     ;
1102   while (spacep (line))
1103     line++;
1104
1105   assuan_write_status (ctx, keyword, line);
1106   return 0;
1107 }
1108
1109 static int
1110 pass_data_thru (void *opaque, const void *buffer, size_t length)
1111 {
1112   assuan_context_t ctx = opaque;
1113
1114   assuan_send_data (ctx, buffer, length);
1115   return 0;
1116 }
1117
1118
1119 /* Send the line CMDLINE with command for the SCDdaemon to it and send
1120    all status messages back.  This command is used as a general quoting
1121    mechanism to pass everything verbatim to SCDAEMON.  The PIN
1122    inquiry is handled inside gpg-agent.  */
1123 int
1124 agent_card_scd (ctrl_t ctrl, const char *cmdline,
1125                 int (*getpin_cb)(void *, const char *, char*, size_t),
1126                 void *getpin_cb_arg, void *assuan_context)
1127 {
1128   int rc;
1129   struct inq_needpin_s inqparm;
1130
1131   rc = start_scd (ctrl);
1132   if (rc)
1133     return rc;
1134
1135   inqparm.ctx = ctrl->scd_local->ctx;
1136   inqparm.getpin_cb = getpin_cb;
1137   inqparm.getpin_cb_arg = getpin_cb_arg;
1138   inqparm.passthru = assuan_context;
1139   rc = assuan_transact (ctrl->scd_local->ctx, cmdline,
1140                         pass_data_thru, assuan_context,
1141                         inq_needpin, &inqparm,
1142                         pass_status_thru, assuan_context);
1143   if (rc)
1144     {
1145       return unlock_scd (ctrl, rc);
1146     }
1147
1148   return unlock_scd (ctrl, 0);
1149 }
1150
1151