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