Made scdaemon more robust on Windows.
[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   if (DBG_ASSUAN)
347     assuan_set_log_stream (ctx, log_get_stream ());
348
349   /* Get the name of the additional socket opened by scdaemon. */
350   {
351     membuf_t data;
352     unsigned char *databuf;
353     size_t datalen;
354
355     xfree (socket_name);
356     socket_name = NULL;
357     init_membuf (&data, 256);
358     assuan_transact (ctx, "GETINFO socket_name",
359                      membuf_data_cb, &data, NULL, NULL, NULL, NULL);
360
361     databuf = get_membuf (&data, &datalen);
362     if (databuf && datalen)
363       {
364         socket_name = xtrymalloc (datalen + 1);
365         if (!socket_name)
366           log_error ("warning: can't store socket name: %s\n",
367                      strerror (errno));
368         else
369           {
370             memcpy (socket_name, databuf, datalen);
371             socket_name[datalen] = 0;
372             if (DBG_ASSUAN)
373               log_debug ("additional connections at `%s'\n", socket_name);
374           }
375       }
376     xfree (databuf);
377   }
378
379   /* Tell the scdaemon we want him to send us an event signal. */
380   {
381     char buf[100];
382
383 #ifdef HAVE_W32_SYSTEM
384     /* Use estream snprintf due to a bug in mingw32 related to the l
385        modifier.  */
386     estream_snprintf (buf, sizeof buf, "OPTION event-signal=%lx", 
387                       (unsigned long)get_agent_scd_notify_event ());
388 #else
389     snprintf (buf, sizeof buf, "OPTION event-signal=%d", SIGUSR2);
390 #endif
391     assuan_transact (ctx, buf, NULL, NULL, NULL, NULL, NULL, NULL);
392   }
393
394   primary_scd_ctx = ctx;
395   primary_scd_ctx_reusable = 0;
396
397  leave:
398   if (err)
399     {
400       unlock_scd (ctrl, err);
401     } 
402   else
403     {
404       ctrl->scd_local->ctx = ctx;
405     }
406   if (!pth_mutex_release (&start_scd_lock))
407     log_error ("failed to release the start_scd lock: %s\n", strerror (errno));
408   return err;
409 }
410
411
412 /* Check whether the Scdaemon is still alive and clean it up if not. */
413 void
414 agent_scd_check_aliveness (void)
415 {
416   pth_event_t evt;
417   pid_t pid;
418 #ifdef HAVE_W32_SYSTEM
419   DWORD rc;
420 #else
421   int rc;
422 #endif
423
424   if (!primary_scd_ctx)
425     return; /* No scdaemon running. */
426
427   /* This is not a critical function so we use a short timeout while
428      acquiring the lock.  */
429   evt = pth_event (PTH_EVENT_TIME, pth_timeout (1, 0));
430   if (!pth_mutex_acquire (&start_scd_lock, 0, evt))
431     {
432       if (pth_event_occurred (evt))
433         {
434           if (opt.verbose > 1)
435             log_info ("failed to acquire the start_scd lock while"
436                       " doing an aliveness check: %s\n", "timeout");
437         }
438       else
439         log_error ("failed to acquire the start_scd lock while"
440                    " doing an aliveness check: %s\n", strerror (errno));
441       pth_event_free (evt, PTH_FREE_THIS);
442       return;
443     }
444   pth_event_free (evt, PTH_FREE_THIS);
445
446   if (primary_scd_ctx)
447     {
448       pid = assuan_get_pid (primary_scd_ctx);
449 #ifdef HAVE_W32_SYSTEM
450       /* If we have a PID we disconnect if either GetExitProcessCode
451          fails or if ir returns the exit code of the scdaemon.  259 is
452          the error code for STILL_ALIVE.  */
453       if (pid != (pid_t)(void*)(-1) && pid
454           && (!GetExitCodeProcess ((HANDLE)pid, &rc) || rc != 259))
455 #else
456       if (pid != (pid_t)(-1) && pid
457           && ((rc=waitpid (pid, NULL, WNOHANG))==-1 || (rc == pid)) )
458 #endif
459         {
460           /* Okay, scdaemon died.  Disconnect the primary connection
461              now but take care that it won't do another wait. Also
462              cleanup all other connections and release their
463              resources.  The next use will start a new daemon then.
464              Due to the use of the START_SCD_LOCAL we are sure that
465              none of these context are actually in use. */
466           struct scd_local_s *sl;
467
468           assuan_set_flag (primary_scd_ctx, ASSUAN_NO_WAITPID, 1);
469           assuan_disconnect (primary_scd_ctx);
470
471           for (sl=scd_local_list; sl; sl = sl->next_local)
472             {
473               if (sl->ctx)
474                 {
475                   if (sl->ctx != primary_scd_ctx)
476                     assuan_disconnect (sl->ctx);
477                   sl->ctx = NULL;
478                 }
479             }
480           
481           primary_scd_ctx = NULL;
482           primary_scd_ctx_reusable = 0;
483
484           xfree (socket_name);
485           socket_name = NULL;
486         }
487     }
488
489   if (!pth_mutex_release (&start_scd_lock))
490     log_error ("failed to release the start_scd lock while"
491                " doing the aliveness check: %s\n", strerror (errno));
492 }
493
494
495
496 /* Reset the SCD if it has been used.  Actually it is not a reset but
497    a cleanup of resources used by the current connection. */
498 int
499 agent_reset_scd (ctrl_t ctrl)
500 {
501   if (ctrl->scd_local)
502     {
503       if (ctrl->scd_local->ctx)
504         {
505           /* We can't disconnect the primary context because libassuan
506              does a waitpid on it and thus the system would hang.
507              Instead we send a reset and keep that connection for
508              reuse. */
509           if (ctrl->scd_local->ctx == primary_scd_ctx)
510             {
511               /* Send a RESTART to the SCD.  This is required for the
512                  primary connection as a kind of virtual EOF; we don't
513                  have another way to tell it that the next command
514                  should be viewed as if a new connection has been
515                  made.  For the non-primary connections this is not
516                  needed as we simply close the socket.  We don't check
517                  for an error here because the RESTART may fail for
518                  example if the scdaemon has already been terminated.
519                  Anyway, we need to set the reusable flag to make sure
520                  that the aliveness check can clean it up. */
521               assuan_transact (primary_scd_ctx, "RESTART",
522                                NULL, NULL, NULL, NULL, NULL, NULL);
523               primary_scd_ctx_reusable = 1;
524             }
525           else
526             assuan_disconnect (ctrl->scd_local->ctx);
527           ctrl->scd_local->ctx = NULL;
528         }
529       
530       /* Remove the local context from our list and release it. */
531       if (!scd_local_list)
532         BUG ();
533       else if (scd_local_list == ctrl->scd_local)
534         scd_local_list = ctrl->scd_local->next_local;
535       else
536         {
537           struct scd_local_s *sl;
538       
539           for (sl=scd_local_list; sl->next_local; sl = sl->next_local)
540             if (sl->next_local == ctrl->scd_local)
541               break;
542           if (!sl->next_local)
543             BUG ();
544           sl->next_local = ctrl->scd_local->next_local;
545         }
546       xfree (ctrl->scd_local);
547       ctrl->scd_local = NULL;
548     }
549
550   return 0;
551 }
552
553
554 \f
555 /* Return a new malloced string by unescaping the string S.  Escaping
556    is percent escaping and '+'/space mapping.  A binary Nul will
557    silently be replaced by a 0xFF.  Function returns NULL to indicate
558    an out of memory status. */
559 static char *
560 unescape_status_string (const unsigned char *s)
561 {
562   char *buffer, *d;
563
564   buffer = d = xtrymalloc (strlen ((const char*)s)+1);
565   if (!buffer)
566     return NULL;
567   while (*s)
568     {
569       if (*s == '%' && s[1] && s[2])
570         { 
571           s++;
572           *d = xtoi_2 (s);
573           if (!*d)
574             *d = '\xff';
575           d++;
576           s += 2;
577         }
578       else if (*s == '+')
579         {
580           *d++ = ' ';
581           s++;
582         }
583       else
584         *d++ = *s++;
585     }
586   *d = 0; 
587   return buffer;
588 }
589
590
591 \f
592 static int
593 learn_status_cb (void *opaque, const char *line)
594 {
595   struct learn_parm_s *parm = opaque;
596   const char *keyword = line;
597   int keywordlen;
598
599   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
600     ;
601   while (spacep (line))
602     line++;
603   if (keywordlen == 8 && !memcmp (keyword, "CERTINFO", keywordlen))
604     {
605       parm->certinfo_cb (parm->certinfo_cb_arg, line);
606     }
607   else if (keywordlen == 11 && !memcmp (keyword, "KEYPAIRINFO", keywordlen))
608     {
609       parm->kpinfo_cb (parm->kpinfo_cb_arg, line);
610     }
611   else if (keywordlen && *line)
612     {
613       parm->sinfo_cb (parm->sinfo_cb_arg, keyword, keywordlen, line);
614     }
615   
616   return 0;
617 }
618
619 /* Perform the LEARN command and return a list of all private keys
620    stored on the card. */
621 int
622 agent_card_learn (ctrl_t ctrl,
623                   void (*kpinfo_cb)(void*, const char *),
624                   void *kpinfo_cb_arg,
625                   void (*certinfo_cb)(void*, const char *),
626                   void *certinfo_cb_arg,
627                   void (*sinfo_cb)(void*, const char *, size_t, const char *),
628                   void *sinfo_cb_arg)
629 {
630   int rc;
631   struct learn_parm_s parm;
632
633   rc = start_scd (ctrl);
634   if (rc)
635     return rc;
636
637   memset (&parm, 0, sizeof parm);
638   parm.kpinfo_cb = kpinfo_cb;
639   parm.kpinfo_cb_arg = kpinfo_cb_arg;
640   parm.certinfo_cb = certinfo_cb;
641   parm.certinfo_cb_arg = certinfo_cb_arg;
642   parm.sinfo_cb = sinfo_cb;
643   parm.sinfo_cb_arg = sinfo_cb_arg;
644   rc = assuan_transact (ctrl->scd_local->ctx, "LEARN --force",
645                         NULL, NULL, NULL, NULL,
646                         learn_status_cb, &parm);
647   if (rc)
648     return unlock_scd (ctrl, rc);
649
650   return unlock_scd (ctrl, 0);
651 }
652
653
654 \f
655 static int
656 get_serialno_cb (void *opaque, const char *line)
657 {
658   char **serialno = opaque;
659   const char *keyword = line;
660   const char *s;
661   int keywordlen, n;
662
663   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
664     ;
665   while (spacep (line))
666     line++;
667
668   if (keywordlen == 8 && !memcmp (keyword, "SERIALNO", keywordlen))
669     {
670       if (*serialno)
671         return gpg_error (GPG_ERR_CONFLICT); /* Unexpected status line. */
672       for (n=0,s=line; hexdigitp (s); s++, n++)
673         ;
674       if (!n || (n&1)|| !(spacep (s) || !*s) )
675         return gpg_error (GPG_ERR_ASS_PARAMETER);
676       *serialno = xtrymalloc (n+1);
677       if (!*serialno)
678         return out_of_core ();
679       memcpy (*serialno, line, n);
680       (*serialno)[n] = 0;
681     }
682   
683   return 0;
684 }
685
686 /* Return the serial number of the card or an appropriate error.  The
687    serial number is returned as a hexstring. */
688 int
689 agent_card_serialno (ctrl_t ctrl, char **r_serialno)
690 {
691   int rc;
692   char *serialno = NULL;
693
694   rc = start_scd (ctrl);
695   if (rc)
696     return rc;
697
698   rc = assuan_transact (ctrl->scd_local->ctx, "SERIALNO",
699                         NULL, NULL, NULL, NULL,
700                         get_serialno_cb, &serialno);
701   if (rc)
702     {
703       xfree (serialno);
704       return unlock_scd (ctrl, rc);
705     }
706   *r_serialno = serialno;
707   return unlock_scd (ctrl, 0);
708 }
709
710
711
712 \f
713 static int
714 membuf_data_cb (void *opaque, const void *buffer, size_t length)
715 {
716   membuf_t *data = opaque;
717
718   if (buffer)
719     put_membuf (data, buffer, length);
720   return 0;
721 }
722   
723 /* Handle the NEEDPIN inquiry. */
724 static int
725 inq_needpin (void *opaque, const char *line)
726 {
727   struct inq_needpin_s *parm = opaque;
728   char *pin;
729   size_t pinlen;
730   int rc;
731
732   if (!strncmp (line, "NEEDPIN", 7) && (line[7] == ' ' || !line[7]))
733     {
734       line += 7;
735       while (*line == ' ')
736         line++;
737       
738       pinlen = 90;
739       pin = gcry_malloc_secure (pinlen);
740       if (!pin)
741         return out_of_core ();
742
743       rc = parm->getpin_cb (parm->getpin_cb_arg, line, pin, pinlen);
744       if (!rc)
745         rc = assuan_send_data (parm->ctx, pin, pinlen);
746       xfree (pin);
747     }
748   else if (!strncmp (line, "POPUPKEYPADPROMPT", 17)
749            && (line[17] == ' ' || !line[17]))
750     {
751       line += 17;
752       while (*line == ' ')
753         line++;
754       
755       rc = parm->getpin_cb (parm->getpin_cb_arg, line, NULL, 1);
756     }
757   else if (!strncmp (line, "DISMISSKEYPADPROMPT", 19)
758            && (line[19] == ' ' || !line[19]))
759     {
760       rc = parm->getpin_cb (parm->getpin_cb_arg, "", NULL, 0);
761     }
762   else if (parm->passthru)
763     {
764       unsigned char *value;
765       size_t valuelen;
766       int rest;
767       int needrest = !strncmp (line, "KEYDATA", 8);
768
769       /* Pass the inquiry up to our caller.  We limit the maximum
770          amount to an arbitrary value.  As we know that the KEYDATA
771          enquiry is pretty sensitive we disable logging then */
772       if ((rest = (needrest
773                    && !assuan_get_flag (parm->passthru, ASSUAN_CONFIDENTIAL))))
774         assuan_begin_confidential (parm->passthru);
775       rc = assuan_inquire (parm->passthru, line, &value, &valuelen, 8096);
776       if (rest)
777         assuan_end_confidential (parm->passthru);
778       if (!rc)
779         {
780           if ((rest = (needrest 
781                        && !assuan_get_flag (parm->ctx, ASSUAN_CONFIDENTIAL))))
782             assuan_begin_confidential (parm->ctx);
783           rc = assuan_send_data (parm->ctx, value, valuelen);
784           if (rest)
785             assuan_end_confidential (parm->ctx);
786           xfree (value);
787         }
788       else
789         log_error ("error forwarding inquiry `%s': %s\n", 
790                    line, gpg_strerror (rc));
791     }
792   else
793     {
794       log_error ("unsupported inquiry `%s'\n", line);
795       rc = gpg_error (GPG_ERR_ASS_UNKNOWN_INQUIRE);
796     }
797
798   return rc;
799 }
800
801
802
803 /* Create a signature using the current card */
804 int
805 agent_card_pksign (ctrl_t ctrl,
806                    const char *keyid,
807                    int (*getpin_cb)(void *, const char *, char*, size_t),
808                    void *getpin_cb_arg,
809                    const unsigned char *indata, size_t indatalen,
810                    unsigned char **r_buf, size_t *r_buflen)
811 {
812   int rc, i;
813   char *p, line[ASSUAN_LINELENGTH];
814   membuf_t data;
815   struct inq_needpin_s inqparm;
816   size_t len;
817   unsigned char *sigbuf;
818   size_t sigbuflen;
819
820   *r_buf = NULL;
821   rc = start_scd (ctrl);
822   if (rc)
823     return rc;
824
825   if (indatalen*2 + 50 > DIM(line))
826     return unlock_scd (ctrl, gpg_error (GPG_ERR_GENERAL));
827
828   sprintf (line, "SETDATA ");
829   p = line + strlen (line);
830   for (i=0; i < indatalen ; i++, p += 2 )
831     sprintf (p, "%02X", indata[i]);
832   rc = assuan_transact (ctrl->scd_local->ctx, line,
833                         NULL, NULL, NULL, NULL, NULL, NULL);
834   if (rc)
835     return unlock_scd (ctrl, rc);
836
837   init_membuf (&data, 1024);
838   inqparm.ctx = ctrl->scd_local->ctx;
839   inqparm.getpin_cb = getpin_cb;
840   inqparm.getpin_cb_arg = getpin_cb_arg;
841   inqparm.passthru = 0;
842   snprintf (line, DIM(line)-1, 
843             ctrl->use_auth_call? "PKAUTH %s":"PKSIGN %s", keyid);
844   line[DIM(line)-1] = 0;
845   rc = assuan_transact (ctrl->scd_local->ctx, line,
846                         membuf_data_cb, &data,
847                         inq_needpin, &inqparm,
848                         NULL, NULL);
849   if (rc)
850     {
851       xfree (get_membuf (&data, &len));
852       return unlock_scd (ctrl, rc);
853     }
854   sigbuf = get_membuf (&data, &sigbuflen);
855
856   /* Create an S-expression from it which is formatted like this:
857      "(7:sig-val(3:rsa(1:sSIGBUFLEN:SIGBUF)))" */
858   *r_buflen = 21 + 11 + sigbuflen + 4;
859   p = xtrymalloc (*r_buflen);
860   *r_buf = (unsigned char*)p;
861   if (!p)
862     return unlock_scd (ctrl, out_of_core ());
863   p = stpcpy (p, "(7:sig-val(3:rsa(1:s" );
864   sprintf (p, "%u:", (unsigned int)sigbuflen);
865   p += strlen (p);
866   memcpy (p, sigbuf, sigbuflen);
867   p += sigbuflen;
868   strcpy (p, ")))");
869   xfree (sigbuf);
870
871   assert (gcry_sexp_canon_len (*r_buf, *r_buflen, NULL, NULL));
872   return unlock_scd (ctrl, 0);
873 }
874
875 /* Decipher INDATA using the current card. Note that the returned value is */
876 int
877 agent_card_pkdecrypt (ctrl_t ctrl,
878                       const char *keyid,
879                       int (*getpin_cb)(void *, const char *, char*, size_t),
880                       void *getpin_cb_arg,
881                       const unsigned char *indata, size_t indatalen,
882                       char **r_buf, size_t *r_buflen)
883 {
884   int rc, i;
885   char *p, line[ASSUAN_LINELENGTH];
886   membuf_t data;
887   struct inq_needpin_s inqparm;
888   size_t len;
889
890   *r_buf = NULL;
891   rc = start_scd (ctrl);
892   if (rc)
893     return rc;
894
895   /* FIXME: use secure memory where appropriate */
896   if (indatalen*2 + 50 > DIM(line))
897     return unlock_scd (ctrl, gpg_error (GPG_ERR_GENERAL));
898
899   sprintf (line, "SETDATA ");
900   p = line + strlen (line);
901   for (i=0; i < indatalen ; i++, p += 2 )
902     sprintf (p, "%02X", indata[i]);
903   rc = assuan_transact (ctrl->scd_local->ctx, line,
904                         NULL, NULL, NULL, NULL, NULL, NULL);
905   if (rc)
906     return unlock_scd (ctrl, rc);
907
908   init_membuf (&data, 1024);
909   inqparm.ctx = ctrl->scd_local->ctx;
910   inqparm.getpin_cb = getpin_cb;
911   inqparm.getpin_cb_arg = getpin_cb_arg;
912   inqparm.passthru = 0;
913   snprintf (line, DIM(line)-1, "PKDECRYPT %s", keyid);
914   line[DIM(line)-1] = 0;
915   rc = assuan_transact (ctrl->scd_local->ctx, line,
916                         membuf_data_cb, &data,
917                         inq_needpin, &inqparm,
918                         NULL, NULL);
919   if (rc)
920     {
921       xfree (get_membuf (&data, &len));
922       return unlock_scd (ctrl, rc);
923     }
924   *r_buf = get_membuf (&data, r_buflen);
925   if (!*r_buf)
926     return unlock_scd (ctrl, gpg_error (GPG_ERR_ENOMEM));
927
928   return unlock_scd (ctrl, 0);
929 }
930
931
932 \f
933 /* Read a certificate with ID into R_BUF and R_BUFLEN. */
934 int
935 agent_card_readcert (ctrl_t ctrl,
936                      const char *id, char **r_buf, size_t *r_buflen)
937 {
938   int rc;
939   char line[ASSUAN_LINELENGTH];
940   membuf_t data;
941   size_t len;
942
943   *r_buf = NULL;
944   rc = start_scd (ctrl);
945   if (rc)
946     return rc;
947
948   init_membuf (&data, 1024);
949   snprintf (line, DIM(line)-1, "READCERT %s", id);
950   line[DIM(line)-1] = 0;
951   rc = assuan_transact (ctrl->scd_local->ctx, line,
952                         membuf_data_cb, &data,
953                         NULL, NULL,
954                         NULL, NULL);
955   if (rc)
956     {
957       xfree (get_membuf (&data, &len));
958       return unlock_scd (ctrl, rc);
959     }
960   *r_buf = get_membuf (&data, r_buflen);
961   if (!*r_buf)
962     return unlock_scd (ctrl, gpg_error (GPG_ERR_ENOMEM));
963
964   return unlock_scd (ctrl, 0);
965 }
966
967
968 \f
969 /* Read a key with ID and return it in an allocate buffer pointed to
970    by r_BUF as a valid S-expression. */
971 int
972 agent_card_readkey (ctrl_t ctrl, const char *id, unsigned char **r_buf)
973 {
974   int rc;
975   char line[ASSUAN_LINELENGTH];
976   membuf_t data;
977   size_t len, buflen;
978
979   *r_buf = NULL;
980   rc = start_scd (ctrl);
981   if (rc)
982     return rc;
983
984   init_membuf (&data, 1024);
985   snprintf (line, DIM(line)-1, "READKEY %s", id);
986   line[DIM(line)-1] = 0;
987   rc = assuan_transact (ctrl->scd_local->ctx, line,
988                         membuf_data_cb, &data,
989                         NULL, NULL,
990                         NULL, NULL);
991   if (rc)
992     {
993       xfree (get_membuf (&data, &len));
994       return unlock_scd (ctrl, rc);
995     }
996   *r_buf = get_membuf (&data, &buflen);
997   if (!*r_buf)
998     return unlock_scd (ctrl, gpg_error (GPG_ERR_ENOMEM));
999
1000   if (!gcry_sexp_canon_len (*r_buf, buflen, NULL, NULL))
1001     {
1002       xfree (*r_buf); *r_buf = NULL;
1003       return unlock_scd (ctrl, gpg_error (GPG_ERR_INV_VALUE));
1004     }
1005
1006   return unlock_scd (ctrl, 0);
1007 }
1008
1009
1010 \f
1011 /* Type used with the card_getattr_cb.  */
1012 struct card_getattr_parm_s {
1013   const char *keyword;  /* Keyword to look for.  */
1014   size_t keywordlen;    /* strlen of KEYWORD.  */
1015   char *data;           /* Malloced and unescaped data.  */
1016   int error;            /* ERRNO value or 0 on success. */
1017 };
1018
1019 /* Callback function for agent_card_getattr.  */
1020 static assuan_error_t
1021 card_getattr_cb (void *opaque, const char *line)
1022 {
1023   struct card_getattr_parm_s *parm = opaque;
1024   const char *keyword = line;
1025   int keywordlen;
1026
1027   if (parm->data)
1028     return 0; /* We want only the first occurrence.  */
1029
1030   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
1031     ;
1032   while (spacep (line))
1033     line++;
1034
1035   if (keywordlen == parm->keywordlen
1036       && !memcmp (keyword, parm->keyword, keywordlen))
1037     {
1038       parm->data = unescape_status_string ((const unsigned char*)line);
1039       if (!parm->data)
1040         parm->error = errno;
1041     }
1042   
1043   return 0;
1044 }
1045
1046
1047 /* Call the agent to retrieve a single line data object. On success
1048    the object is malloced and stored at RESULT; it is guaranteed that
1049    NULL is never stored in this case.  On error an error code is
1050    returned and NULL stored at RESULT. */
1051 gpg_error_t
1052 agent_card_getattr (ctrl_t ctrl, const char *name, char **result)
1053 {
1054   int err;
1055   struct card_getattr_parm_s parm;
1056   char line[ASSUAN_LINELENGTH];
1057
1058   *result = NULL;
1059
1060   if (!*name)
1061     return gpg_error (GPG_ERR_INV_VALUE);
1062
1063   memset (&parm, 0, sizeof parm);
1064   parm.keyword = name;
1065   parm.keywordlen = strlen (name);
1066
1067   /* We assume that NAME does not need escaping. */
1068   if (8 + strlen (name) > DIM(line)-1)
1069     return gpg_error (GPG_ERR_TOO_LARGE);
1070   stpcpy (stpcpy (line, "GETATTR "), name); 
1071
1072   err = start_scd (ctrl);
1073   if (err)
1074     return err;
1075
1076   err = assuan_transact (ctrl->scd_local->ctx, line,
1077                          NULL, NULL, NULL, NULL,
1078                          card_getattr_cb, &parm);
1079   if (!err && parm.error)
1080     err = gpg_error_from_errno (parm.error);
1081   
1082   if (!err && !parm.data)
1083     err = gpg_error (GPG_ERR_NO_DATA);
1084   
1085   if (!err)
1086     *result = parm.data;
1087   else
1088     xfree (parm.data);
1089
1090   return unlock_scd (ctrl, err);
1091 }
1092
1093
1094
1095 \f
1096 static int
1097 pass_status_thru (void *opaque, const char *line)
1098 {
1099   assuan_context_t ctx = opaque;
1100   char keyword[200];
1101   int i;
1102
1103   for (i=0; *line && !spacep (line) && i < DIM(keyword)-1; line++, i++)
1104     keyword[i] = *line;
1105   keyword[i] = 0;
1106   /* truncate any remaining keyword stuff. */
1107   for (; *line && !spacep (line); line++)
1108     ;
1109   while (spacep (line))
1110     line++;
1111
1112   assuan_write_status (ctx, keyword, line);
1113   return 0;
1114 }
1115
1116 static int
1117 pass_data_thru (void *opaque, const void *buffer, size_t length)
1118 {
1119   assuan_context_t ctx = opaque;
1120
1121   assuan_send_data (ctx, buffer, length);
1122   return 0;
1123 }
1124
1125
1126 /* Send the line CMDLINE with command for the SCDdaemon to it and send
1127    all status messages back.  This command is used as a general quoting
1128    mechanism to pass everything verbatim to SCDAEMON.  The PIN
1129    inquiry is handled inside gpg-agent.  */
1130 int
1131 agent_card_scd (ctrl_t ctrl, const char *cmdline,
1132                 int (*getpin_cb)(void *, const char *, char*, size_t),
1133                 void *getpin_cb_arg, void *assuan_context)
1134 {
1135   int rc;
1136   struct inq_needpin_s inqparm;
1137
1138   rc = start_scd (ctrl);
1139   if (rc)
1140     return rc;
1141
1142   inqparm.ctx = ctrl->scd_local->ctx;
1143   inqparm.getpin_cb = getpin_cb;
1144   inqparm.getpin_cb_arg = getpin_cb_arg;
1145   inqparm.passthru = assuan_context;
1146   rc = assuan_transact (ctrl->scd_local->ctx, cmdline,
1147                         pass_data_thru, assuan_context,
1148                         inq_needpin, &inqparm,
1149                         pass_status_thru, assuan_context);
1150   if (rc)
1151     {
1152       return unlock_scd (ctrl, rc);
1153     }
1154
1155   return unlock_scd (ctrl, 0);
1156 }
1157
1158