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