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