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