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