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