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