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