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