81e0834ab62d57d9d275aa9ff906481f162f9385
[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 /* 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
816   *r_buf = NULL;
817   rc = start_scd (ctrl);
818   if (rc)
819     return rc;
820
821   if (indatalen*2 + 50 > DIM(line))
822     return unlock_scd (ctrl, gpg_error (GPG_ERR_GENERAL));
823
824   sprintf (line, "SETDATA ");
825   p = line + strlen (line);
826   for (i=0; i < indatalen ; i++, p += 2 )
827     sprintf (p, "%02X", indata[i]);
828   rc = assuan_transact (ctrl->scd_local->ctx, line,
829                         NULL, NULL, NULL, NULL, NULL, NULL);
830   if (rc)
831     return unlock_scd (ctrl, rc);
832
833   init_membuf (&data, 1024);
834   inqparm.ctx = ctrl->scd_local->ctx;
835   inqparm.getpin_cb = getpin_cb;
836   inqparm.getpin_cb_arg = getpin_cb_arg;
837   inqparm.passthru = 0;
838   snprintf (line, DIM(line)-1, 
839             ctrl->use_auth_call? "PKAUTH %s":"PKSIGN %s", keyid);
840   line[DIM(line)-1] = 0;
841   rc = assuan_transact (ctrl->scd_local->ctx, line,
842                         membuf_data_cb, &data,
843                         inq_needpin, &inqparm,
844                         NULL, NULL);
845   if (rc)
846     {
847       xfree (get_membuf (&data, &len));
848       return unlock_scd (ctrl, rc);
849     }
850   sigbuf = get_membuf (&data, &sigbuflen);
851
852   /* Create an S-expression from it which is formatted like this:
853      "(7:sig-val(3:rsa(1:sSIGBUFLEN:SIGBUF)))" */
854   *r_buflen = 21 + 11 + sigbuflen + 4;
855   p = xtrymalloc (*r_buflen);
856   *r_buf = (unsigned char*)p;
857   if (!p)
858     return unlock_scd (ctrl, out_of_core ());
859   p = stpcpy (p, "(7:sig-val(3:rsa(1:s" );
860   sprintf (p, "%u:", (unsigned int)sigbuflen);
861   p += strlen (p);
862   memcpy (p, sigbuf, sigbuflen);
863   p += sigbuflen;
864   strcpy (p, ")))");
865   xfree (sigbuf);
866
867   assert (gcry_sexp_canon_len (*r_buf, *r_buflen, NULL, NULL));
868   return unlock_scd (ctrl, 0);
869 }
870
871 /* Decipher INDATA using the current card. Note that the returned value is */
872 int
873 agent_card_pkdecrypt (ctrl_t ctrl,
874                       const char *keyid,
875                       int (*getpin_cb)(void *, const char *, char*, size_t),
876                       void *getpin_cb_arg,
877                       const unsigned char *indata, size_t indatalen,
878                       char **r_buf, size_t *r_buflen)
879 {
880   int rc, i;
881   char *p, line[ASSUAN_LINELENGTH];
882   membuf_t data;
883   struct inq_needpin_s inqparm;
884   size_t len;
885
886   *r_buf = NULL;
887   rc = start_scd (ctrl);
888   if (rc)
889     return rc;
890
891   /* FIXME: use secure memory where appropriate */
892   if (indatalen*2 + 50 > DIM(line))
893     return unlock_scd (ctrl, gpg_error (GPG_ERR_GENERAL));
894
895   sprintf (line, "SETDATA ");
896   p = line + strlen (line);
897   for (i=0; i < indatalen ; i++, p += 2 )
898     sprintf (p, "%02X", indata[i]);
899   rc = assuan_transact (ctrl->scd_local->ctx, line,
900                         NULL, NULL, NULL, NULL, NULL, NULL);
901   if (rc)
902     return unlock_scd (ctrl, rc);
903
904   init_membuf (&data, 1024);
905   inqparm.ctx = ctrl->scd_local->ctx;
906   inqparm.getpin_cb = getpin_cb;
907   inqparm.getpin_cb_arg = getpin_cb_arg;
908   inqparm.passthru = 0;
909   snprintf (line, DIM(line)-1, "PKDECRYPT %s", keyid);
910   line[DIM(line)-1] = 0;
911   rc = assuan_transact (ctrl->scd_local->ctx, line,
912                         membuf_data_cb, &data,
913                         inq_needpin, &inqparm,
914                         NULL, NULL);
915   if (rc)
916     {
917       xfree (get_membuf (&data, &len));
918       return unlock_scd (ctrl, rc);
919     }
920   *r_buf = get_membuf (&data, r_buflen);
921   if (!*r_buf)
922     return unlock_scd (ctrl, gpg_error (GPG_ERR_ENOMEM));
923
924   return unlock_scd (ctrl, 0);
925 }
926
927
928 \f
929 /* Read a certificate with ID into R_BUF and R_BUFLEN. */
930 int
931 agent_card_readcert (ctrl_t ctrl,
932                      const char *id, char **r_buf, size_t *r_buflen)
933 {
934   int rc;
935   char line[ASSUAN_LINELENGTH];
936   membuf_t data;
937   size_t len;
938
939   *r_buf = NULL;
940   rc = start_scd (ctrl);
941   if (rc)
942     return rc;
943
944   init_membuf (&data, 1024);
945   snprintf (line, DIM(line)-1, "READCERT %s", id);
946   line[DIM(line)-1] = 0;
947   rc = assuan_transact (ctrl->scd_local->ctx, line,
948                         membuf_data_cb, &data,
949                         NULL, NULL,
950                         NULL, NULL);
951   if (rc)
952     {
953       xfree (get_membuf (&data, &len));
954       return unlock_scd (ctrl, rc);
955     }
956   *r_buf = get_membuf (&data, r_buflen);
957   if (!*r_buf)
958     return unlock_scd (ctrl, gpg_error (GPG_ERR_ENOMEM));
959
960   return unlock_scd (ctrl, 0);
961 }
962
963
964 \f
965 /* Read a key with ID and return it in an allocate buffer pointed to
966    by r_BUF as a valid S-expression. */
967 int
968 agent_card_readkey (ctrl_t ctrl, const char *id, unsigned char **r_buf)
969 {
970   int rc;
971   char line[ASSUAN_LINELENGTH];
972   membuf_t data;
973   size_t len, buflen;
974
975   *r_buf = NULL;
976   rc = start_scd (ctrl);
977   if (rc)
978     return rc;
979
980   init_membuf (&data, 1024);
981   snprintf (line, DIM(line)-1, "READKEY %s", id);
982   line[DIM(line)-1] = 0;
983   rc = assuan_transact (ctrl->scd_local->ctx, line,
984                         membuf_data_cb, &data,
985                         NULL, NULL,
986                         NULL, NULL);
987   if (rc)
988     {
989       xfree (get_membuf (&data, &len));
990       return unlock_scd (ctrl, rc);
991     }
992   *r_buf = get_membuf (&data, &buflen);
993   if (!*r_buf)
994     return unlock_scd (ctrl, gpg_error (GPG_ERR_ENOMEM));
995
996   if (!gcry_sexp_canon_len (*r_buf, buflen, NULL, NULL))
997     {
998       xfree (*r_buf); *r_buf = NULL;
999       return unlock_scd (ctrl, gpg_error (GPG_ERR_INV_VALUE));
1000     }
1001
1002   return unlock_scd (ctrl, 0);
1003 }
1004
1005
1006 \f
1007 /* Type used with the card_getattr_cb.  */
1008 struct card_getattr_parm_s {
1009   const char *keyword;  /* Keyword to look for.  */
1010   size_t keywordlen;    /* strlen of KEYWORD.  */
1011   char *data;           /* Malloced and unescaped data.  */
1012   int error;            /* ERRNO value or 0 on success. */
1013 };
1014
1015 /* Callback function for agent_card_getattr.  */
1016 static gpg_error_t
1017 card_getattr_cb (void *opaque, const char *line)
1018 {
1019   struct card_getattr_parm_s *parm = opaque;
1020   const char *keyword = line;
1021   int keywordlen;
1022
1023   if (parm->data)
1024     return 0; /* We want only the first occurrence.  */
1025
1026   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
1027     ;
1028   while (spacep (line))
1029     line++;
1030
1031   if (keywordlen == parm->keywordlen
1032       && !memcmp (keyword, parm->keyword, keywordlen))
1033     {
1034       parm->data = percent_plus_unescape ((const unsigned char*)line, 0xff);
1035       if (!parm->data)
1036         parm->error = errno;
1037     }
1038   
1039   return 0;
1040 }
1041
1042
1043 /* Call the agent to retrieve a single line data object. On success
1044    the object is malloced and stored at RESULT; it is guaranteed that
1045    NULL is never stored in this case.  On error an error code is
1046    returned and NULL stored at RESULT. */
1047 gpg_error_t
1048 agent_card_getattr (ctrl_t ctrl, const char *name, char **result)
1049 {
1050   int err;
1051   struct card_getattr_parm_s parm;
1052   char line[ASSUAN_LINELENGTH];
1053
1054   *result = NULL;
1055
1056   if (!*name)
1057     return gpg_error (GPG_ERR_INV_VALUE);
1058
1059   memset (&parm, 0, sizeof parm);
1060   parm.keyword = name;
1061   parm.keywordlen = strlen (name);
1062
1063   /* We assume that NAME does not need escaping. */
1064   if (8 + strlen (name) > DIM(line)-1)
1065     return gpg_error (GPG_ERR_TOO_LARGE);
1066   stpcpy (stpcpy (line, "GETATTR "), name); 
1067
1068   err = start_scd (ctrl);
1069   if (err)
1070     return err;
1071
1072   err = assuan_transact (ctrl->scd_local->ctx, line,
1073                          NULL, NULL, NULL, NULL,
1074                          card_getattr_cb, &parm);
1075   if (!err && parm.error)
1076     err = gpg_error_from_errno (parm.error);
1077   
1078   if (!err && !parm.data)
1079     err = gpg_error (GPG_ERR_NO_DATA);
1080   
1081   if (!err)
1082     *result = parm.data;
1083   else
1084     xfree (parm.data);
1085
1086   return unlock_scd (ctrl, err);
1087 }
1088
1089
1090
1091 \f
1092 static gpg_error_t
1093 pass_status_thru (void *opaque, const char *line)
1094 {
1095   assuan_context_t ctx = opaque;
1096   char keyword[200];
1097   int i;
1098
1099   for (i=0; *line && !spacep (line) && i < DIM(keyword)-1; line++, i++)
1100     keyword[i] = *line;
1101   keyword[i] = 0;
1102   /* truncate any remaining keyword stuff. */
1103   for (; *line && !spacep (line); line++)
1104     ;
1105   while (spacep (line))
1106     line++;
1107
1108   assuan_write_status (ctx, keyword, line);
1109   return 0;
1110 }
1111
1112 static gpg_error_t
1113 pass_data_thru (void *opaque, const void *buffer, size_t length)
1114 {
1115   assuan_context_t ctx = opaque;
1116
1117   assuan_send_data (ctx, buffer, length);
1118   return 0;
1119 }
1120
1121
1122 /* Send the line CMDLINE with command for the SCDdaemon to it and send
1123    all status messages back.  This command is used as a general quoting
1124    mechanism to pass everything verbatim to SCDAEMON.  The PIN
1125    inquiry is handled inside gpg-agent.  */
1126 int
1127 agent_card_scd (ctrl_t ctrl, const char *cmdline,
1128                 int (*getpin_cb)(void *, const char *, char*, size_t),
1129                 void *getpin_cb_arg, void *assuan_context)
1130 {
1131   int rc;
1132   struct inq_needpin_s inqparm;
1133   int saveflag;
1134
1135   rc = start_scd (ctrl);
1136   if (rc)
1137     return rc;
1138
1139   inqparm.ctx = ctrl->scd_local->ctx;
1140   inqparm.getpin_cb = getpin_cb;
1141   inqparm.getpin_cb_arg = getpin_cb_arg;
1142   inqparm.passthru = assuan_context;
1143   saveflag = assuan_get_flag (ctrl->scd_local->ctx, ASSUAN_CONVEY_COMMENTS);
1144   assuan_set_flag (ctrl->scd_local->ctx, ASSUAN_CONVEY_COMMENTS, 1);
1145   rc = assuan_transact (ctrl->scd_local->ctx, cmdline,
1146                         pass_data_thru, assuan_context,
1147                         inq_needpin, &inqparm,
1148                         pass_status_thru, assuan_context);
1149   assuan_set_flag (ctrl->scd_local->ctx, ASSUAN_CONVEY_COMMENTS, saveflag);
1150   if (rc)
1151     {
1152       return unlock_scd (ctrl, rc);
1153     }
1154
1155   return unlock_scd (ctrl, 0);
1156 }
1157
1158