ccdb637d4eb6f56919669f2e49e1fb20427fafc6
[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   char *pin;
705   size_t pinlen;
706   int rc;
707
708   parm->any_inq_seen = 1;
709   if (!strncmp (line, "NEEDPIN", 7) && (line[7] == ' ' || !line[7]))
710     {
711       line += 7;
712       while (*line == ' ')
713         line++;
714
715       pinlen = 90;
716       pin = gcry_malloc_secure (pinlen);
717       if (!pin)
718         return out_of_core ();
719
720       rc = parm->getpin_cb (parm->getpin_cb_arg, line, pin, pinlen);
721       if (!rc)
722         rc = assuan_send_data (parm->ctx, pin, pinlen);
723       xfree (pin);
724     }
725   else if (!strncmp (line, "POPUPKEYPADPROMPT", 17)
726            && (line[17] == ' ' || !line[17]))
727     {
728       line += 17;
729       while (*line == ' ')
730         line++;
731
732       rc = parm->getpin_cb (parm->getpin_cb_arg, line, NULL, 1);
733     }
734   else if (!strncmp (line, "DISMISSKEYPADPROMPT", 19)
735            && (line[19] == ' ' || !line[19]))
736     {
737       rc = parm->getpin_cb (parm->getpin_cb_arg, "", NULL, 0);
738     }
739   else if (parm->passthru)
740     {
741       unsigned char *value;
742       size_t valuelen;
743       int rest;
744       int needrest = !strncmp (line, "KEYDATA", 8);
745
746       /* Pass the inquiry up to our caller.  We limit the maximum
747          amount to an arbitrary value.  As we know that the KEYDATA
748          enquiry is pretty sensitive we disable logging then */
749       if ((rest = (needrest
750                    && !assuan_get_flag (parm->passthru, ASSUAN_CONFIDENTIAL))))
751         assuan_begin_confidential (parm->passthru);
752       rc = assuan_inquire (parm->passthru, line, &value, &valuelen, 8096);
753       if (rest)
754         assuan_end_confidential (parm->passthru);
755       if (!rc)
756         {
757           if ((rest = (needrest
758                        && !assuan_get_flag (parm->ctx, ASSUAN_CONFIDENTIAL))))
759             assuan_begin_confidential (parm->ctx);
760           rc = assuan_send_data (parm->ctx, value, valuelen);
761           if (rest)
762             assuan_end_confidential (parm->ctx);
763           xfree (value);
764         }
765       else
766         log_error ("error forwarding inquiry `%s': %s\n",
767                    line, gpg_strerror (rc));
768     }
769   else
770     {
771       log_error ("unsupported inquiry `%s'\n", line);
772       rc = gpg_error (GPG_ERR_ASS_UNKNOWN_INQUIRE);
773     }
774
775   return rc;
776 }
777
778
779 /* Helper returning a command option to describe the used hash
780    algorithm.  See scd/command.c:cmd_pksign.  */
781 static const char *
782 hash_algo_option (int algo)
783 {
784   switch (algo)
785     {
786     case GCRY_MD_MD5   : return "--hash=md5";
787     case GCRY_MD_RMD160: return "--hash=rmd160";
788     case GCRY_MD_SHA1  : return "--hash=sha1";
789     case GCRY_MD_SHA224: return "--hash=sha224";
790     case GCRY_MD_SHA256: return "--hash=sha256";
791     case GCRY_MD_SHA384: return "--hash=sha384";
792     case GCRY_MD_SHA512: return "--hash=sha512";
793     default:             return "";
794     }
795 }
796
797
798 static gpg_error_t
799 cancel_inquire (ctrl_t ctrl, gpg_error_t rc)
800 {
801   gpg_error_t oldrc = rc;
802
803   /* The inquire callback was called and transact returned a
804      cancel error.  We assume that the inquired process sent a
805      CANCEL.  The passthrough code is not able to pass on the
806      CANCEL and thus scdaemon would stuck on this.  As a
807      workaround we send a CANCEL now.  */
808   rc = assuan_write_line (ctrl->scd_local->ctx, "CAN");
809   if (!rc) {
810     char *line;
811     size_t len;
812
813     rc = assuan_read_line (ctrl->scd_local->ctx, &line, &len);
814     if (!rc)
815       rc = oldrc;
816   }
817
818   return rc;
819 }
820
821 /* Create a signature using the current card.  MDALGO is either 0 or
822    gives the digest algorithm.  */
823 int
824 agent_card_pksign (ctrl_t ctrl,
825                    const char *keyid,
826                    int (*getpin_cb)(void *, const char *, char*, size_t),
827                    void *getpin_cb_arg,
828                    int mdalgo,
829                    const unsigned char *indata, size_t indatalen,
830                    unsigned char **r_buf, size_t *r_buflen)
831 {
832   int rc, i;
833   char *p, line[ASSUAN_LINELENGTH];
834   membuf_t data;
835   struct inq_needpin_s inqparm;
836   size_t len;
837   unsigned char *sigbuf;
838   size_t sigbuflen;
839   int prepend_nul;
840
841   *r_buf = NULL;
842   rc = start_scd (ctrl);
843   if (rc)
844     return rc;
845
846   if (indatalen*2 + 50 > DIM(line))
847     return unlock_scd (ctrl, gpg_error (GPG_ERR_GENERAL));
848
849   sprintf (line, "SETDATA ");
850   p = line + strlen (line);
851   for (i=0; i < indatalen ; i++, p += 2 )
852     sprintf (p, "%02X", indata[i]);
853   rc = assuan_transact (ctrl->scd_local->ctx, line,
854                         NULL, NULL, NULL, NULL, NULL, NULL);
855   if (rc)
856     return unlock_scd (ctrl, rc);
857
858   init_membuf (&data, 1024);
859   inqparm.ctx = ctrl->scd_local->ctx;
860   inqparm.getpin_cb = getpin_cb;
861   inqparm.getpin_cb_arg = getpin_cb_arg;
862   inqparm.passthru = 0;
863   inqparm.any_inq_seen = 0;
864   if (ctrl->use_auth_call)
865     snprintf (line, sizeof line, "PKAUTH %s", keyid);
866   else
867     snprintf (line, sizeof line, "PKSIGN %s %s",
868               hash_algo_option (mdalgo), keyid);
869   rc = assuan_transact (ctrl->scd_local->ctx, line,
870                         membuf_data_cb, &data,
871                         inq_needpin, &inqparm,
872                         NULL, NULL);
873   if (inqparm.any_inq_seen && gpg_err_code(rc) == GPG_ERR_CANCELED)
874     rc = cancel_inquire (ctrl, rc);
875
876   if (rc)
877     {
878       xfree (get_membuf (&data, &len));
879       return unlock_scd (ctrl, rc);
880     }
881   sigbuf = get_membuf (&data, &sigbuflen);
882
883   /* Create an S-expression from it which is formatted like this:
884      "(7:sig-val(3:rsa(1:sSIGBUFLEN:SIGBUF)))".  We better make sure
885      that this won't be interpreted as a negative number.  */
886   prepend_nul = (sigbuflen && (*sigbuf & 0x80));
887
888   *r_buflen = 21 + 11 + prepend_nul + sigbuflen + 4;
889   p = xtrymalloc (*r_buflen);
890   *r_buf = (unsigned char*)p;
891   if (!p)
892     return unlock_scd (ctrl, out_of_core ());
893   p = stpcpy (p, "(7:sig-val(3:rsa(1:s" );
894   sprintf (p, "%u:", (unsigned int)sigbuflen + prepend_nul);
895   p += strlen (p);
896   if (prepend_nul)
897     *p++ = 0;
898   memcpy (p, sigbuf, sigbuflen);
899   p += sigbuflen;
900   strcpy (p, ")))");
901   xfree (sigbuf);
902
903   assert (gcry_sexp_canon_len (*r_buf, *r_buflen, NULL, NULL));
904   return unlock_scd (ctrl, 0);
905 }
906
907 /* Decipher INDATA using the current card. Note that the returned value is */
908 int
909 agent_card_pkdecrypt (ctrl_t ctrl,
910                       const char *keyid,
911                       int (*getpin_cb)(void *, const char *, char*, size_t),
912                       void *getpin_cb_arg,
913                       const unsigned char *indata, size_t indatalen,
914                       char **r_buf, size_t *r_buflen)
915 {
916   int rc, i;
917   char *p, line[ASSUAN_LINELENGTH];
918   membuf_t data;
919   struct inq_needpin_s inqparm;
920   size_t len;
921
922   *r_buf = NULL;
923   rc = start_scd (ctrl);
924   if (rc)
925     return rc;
926
927   /* FIXME: use secure memory where appropriate */
928   if (indatalen*2 + 50 > DIM(line))
929     return unlock_scd (ctrl, gpg_error (GPG_ERR_GENERAL));
930
931   sprintf (line, "SETDATA ");
932   p = line + strlen (line);
933   for (i=0; i < indatalen ; i++, p += 2 )
934     sprintf (p, "%02X", indata[i]);
935   rc = assuan_transact (ctrl->scd_local->ctx, line,
936                         NULL, NULL, NULL, NULL, NULL, NULL);
937   if (rc)
938     return unlock_scd (ctrl, rc);
939
940   init_membuf (&data, 1024);
941   inqparm.ctx = ctrl->scd_local->ctx;
942   inqparm.getpin_cb = getpin_cb;
943   inqparm.getpin_cb_arg = getpin_cb_arg;
944   inqparm.passthru = 0;
945   inqparm.any_inq_seen = 0;
946   snprintf (line, DIM(line)-1, "PKDECRYPT %s", keyid);
947   line[DIM(line)-1] = 0;
948   rc = assuan_transact (ctrl->scd_local->ctx, line,
949                         membuf_data_cb, &data,
950                         inq_needpin, &inqparm,
951                         NULL, NULL);
952   if (inqparm.any_inq_seen && gpg_err_code(rc) == GPG_ERR_CANCELED)
953     rc = cancel_inquire (ctrl, rc);
954
955   if (rc)
956     {
957       xfree (get_membuf (&data, &len));
958       return unlock_scd (ctrl, rc);
959     }
960   *r_buf = get_membuf (&data, r_buflen);
961   if (!*r_buf)
962     return unlock_scd (ctrl, gpg_error (GPG_ERR_ENOMEM));
963
964   return unlock_scd (ctrl, 0);
965 }
966
967
968 \f
969 /* Read a certificate with ID into R_BUF and R_BUFLEN. */
970 int
971 agent_card_readcert (ctrl_t ctrl,
972                      const char *id, char **r_buf, size_t *r_buflen)
973 {
974   int rc;
975   char line[ASSUAN_LINELENGTH];
976   membuf_t data;
977   size_t len;
978
979   *r_buf = NULL;
980   rc = start_scd (ctrl);
981   if (rc)
982     return rc;
983
984   init_membuf (&data, 1024);
985   snprintf (line, DIM(line)-1, "READCERT %s", id);
986   line[DIM(line)-1] = 0;
987   rc = assuan_transact (ctrl->scd_local->ctx, line,
988                         membuf_data_cb, &data,
989                         NULL, NULL,
990                         NULL, NULL);
991   if (rc)
992     {
993       xfree (get_membuf (&data, &len));
994       return unlock_scd (ctrl, rc);
995     }
996   *r_buf = get_membuf (&data, r_buflen);
997   if (!*r_buf)
998     return unlock_scd (ctrl, gpg_error (GPG_ERR_ENOMEM));
999
1000   return unlock_scd (ctrl, 0);
1001 }
1002
1003
1004 \f
1005 /* Read a key with ID and return it in an allocate buffer pointed to
1006    by r_BUF as a valid S-expression. */
1007 int
1008 agent_card_readkey (ctrl_t ctrl, const char *id, unsigned char **r_buf)
1009 {
1010   int rc;
1011   char line[ASSUAN_LINELENGTH];
1012   membuf_t data;
1013   size_t len, buflen;
1014
1015   *r_buf = NULL;
1016   rc = start_scd (ctrl);
1017   if (rc)
1018     return rc;
1019
1020   init_membuf (&data, 1024);
1021   snprintf (line, DIM(line)-1, "READKEY %s", id);
1022   line[DIM(line)-1] = 0;
1023   rc = assuan_transact (ctrl->scd_local->ctx, line,
1024                         membuf_data_cb, &data,
1025                         NULL, NULL,
1026                         NULL, NULL);
1027   if (rc)
1028     {
1029       xfree (get_membuf (&data, &len));
1030       return unlock_scd (ctrl, rc);
1031     }
1032   *r_buf = get_membuf (&data, &buflen);
1033   if (!*r_buf)
1034     return unlock_scd (ctrl, gpg_error (GPG_ERR_ENOMEM));
1035
1036   if (!gcry_sexp_canon_len (*r_buf, buflen, NULL, NULL))
1037     {
1038       xfree (*r_buf); *r_buf = NULL;
1039       return unlock_scd (ctrl, gpg_error (GPG_ERR_INV_VALUE));
1040     }
1041
1042   return unlock_scd (ctrl, 0);
1043 }
1044
1045
1046 \f
1047 /* Type used with the card_getattr_cb.  */
1048 struct card_getattr_parm_s {
1049   const char *keyword;  /* Keyword to look for.  */
1050   size_t keywordlen;    /* strlen of KEYWORD.  */
1051   char *data;           /* Malloced and unescaped data.  */
1052   int error;            /* ERRNO value or 0 on success. */
1053 };
1054
1055 /* Callback function for agent_card_getattr.  */
1056 static gpg_error_t
1057 card_getattr_cb (void *opaque, const char *line)
1058 {
1059   struct card_getattr_parm_s *parm = opaque;
1060   const char *keyword = line;
1061   int keywordlen;
1062
1063   if (parm->data)
1064     return 0; /* We want only the first occurrence.  */
1065
1066   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
1067     ;
1068   while (spacep (line))
1069     line++;
1070
1071   if (keywordlen == parm->keywordlen
1072       && !memcmp (keyword, parm->keyword, keywordlen))
1073     {
1074       parm->data = percent_plus_unescape ((const unsigned char*)line, 0xff);
1075       if (!parm->data)
1076         parm->error = errno;
1077     }
1078
1079   return 0;
1080 }
1081
1082
1083 /* Call the agent to retrieve a single line data object. On success
1084    the object is malloced and stored at RESULT; it is guaranteed that
1085    NULL is never stored in this case.  On error an error code is
1086    returned and NULL stored at RESULT. */
1087 gpg_error_t
1088 agent_card_getattr (ctrl_t ctrl, const char *name, char **result)
1089 {
1090   int err;
1091   struct card_getattr_parm_s parm;
1092   char line[ASSUAN_LINELENGTH];
1093
1094   *result = NULL;
1095
1096   if (!*name)
1097     return gpg_error (GPG_ERR_INV_VALUE);
1098
1099   memset (&parm, 0, sizeof parm);
1100   parm.keyword = name;
1101   parm.keywordlen = strlen (name);
1102
1103   /* We assume that NAME does not need escaping. */
1104   if (8 + strlen (name) > DIM(line)-1)
1105     return gpg_error (GPG_ERR_TOO_LARGE);
1106   stpcpy (stpcpy (line, "GETATTR "), name);
1107
1108   err = start_scd (ctrl);
1109   if (err)
1110     return err;
1111
1112   err = assuan_transact (ctrl->scd_local->ctx, line,
1113                          NULL, NULL, NULL, NULL,
1114                          card_getattr_cb, &parm);
1115   if (!err && parm.error)
1116     err = gpg_error_from_errno (parm.error);
1117
1118   if (!err && !parm.data)
1119     err = gpg_error (GPG_ERR_NO_DATA);
1120
1121   if (!err)
1122     *result = parm.data;
1123   else
1124     xfree (parm.data);
1125
1126   return unlock_scd (ctrl, err);
1127 }
1128
1129
1130
1131 \f
1132 static gpg_error_t
1133 pass_status_thru (void *opaque, const char *line)
1134 {
1135   assuan_context_t ctx = opaque;
1136   char keyword[200];
1137   int i;
1138
1139   if (line[0] == '#' && (!line[1] || spacep (line+1)))
1140     {
1141       /* We are called in convey comments mode.  Now, if we see a
1142          comment marker as keyword we forward the line verbatim to the
1143          the caller.  This way the comment lines from scdaemon won't
1144          appear as status lines with keyword '#'.  */
1145       assuan_write_line (ctx, line);
1146     }
1147   else
1148     {
1149       for (i=0; *line && !spacep (line) && i < DIM(keyword)-1; line++, i++)
1150         keyword[i] = *line;
1151       keyword[i] = 0;
1152
1153       /* Truncate any remaining keyword stuff.  */
1154       for (; *line && !spacep (line); line++)
1155         ;
1156       while (spacep (line))
1157         line++;
1158
1159       assuan_write_status (ctx, keyword, line);
1160     }
1161   return 0;
1162 }
1163
1164 static gpg_error_t
1165 pass_data_thru (void *opaque, const void *buffer, size_t length)
1166 {
1167   assuan_context_t ctx = opaque;
1168
1169   assuan_send_data (ctx, buffer, length);
1170   return 0;
1171 }
1172
1173
1174 /* Send the line CMDLINE with command for the SCDdaemon to it and send
1175    all status messages back.  This command is used as a general quoting
1176    mechanism to pass everything verbatim to SCDAEMON.  The PIN
1177    inquiry is handled inside gpg-agent.  */
1178 int
1179 agent_card_scd (ctrl_t ctrl, const char *cmdline,
1180                 int (*getpin_cb)(void *, const char *, char*, size_t),
1181                 void *getpin_cb_arg, void *assuan_context)
1182 {
1183   int rc;
1184   struct inq_needpin_s inqparm;
1185   int saveflag;
1186
1187   rc = start_scd (ctrl);
1188   if (rc)
1189     return rc;
1190
1191   inqparm.ctx = ctrl->scd_local->ctx;
1192   inqparm.getpin_cb = getpin_cb;
1193   inqparm.getpin_cb_arg = getpin_cb_arg;
1194   inqparm.passthru = assuan_context;
1195   inqparm.any_inq_seen = 0;
1196   saveflag = assuan_get_flag (ctrl->scd_local->ctx, ASSUAN_CONVEY_COMMENTS);
1197   assuan_set_flag (ctrl->scd_local->ctx, ASSUAN_CONVEY_COMMENTS, 1);
1198   rc = assuan_transact (ctrl->scd_local->ctx, cmdline,
1199                         pass_data_thru, assuan_context,
1200                         inq_needpin, &inqparm,
1201                         pass_status_thru, assuan_context);
1202   if (inqparm.any_inq_seen && gpg_err_code(rc) == GPG_ERR_ASS_CANCELED)
1203     rc = cancel_inquire (ctrl, rc);
1204
1205   assuan_set_flag (ctrl->scd_local->ctx, ASSUAN_CONVEY_COMMENTS, saveflag);
1206   if (rc)
1207     {
1208       return unlock_scd (ctrl, rc);
1209     }
1210
1211   return unlock_scd (ctrl, 0);
1212 }