Make the inquire cancel fix a little bit more robust.
[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 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 3 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, see <http://www.gnu.org/licenses/>.
18  */
19
20 #include <config.h>
21 #include <errno.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <ctype.h>
26 #include <assert.h>
27 #include <unistd.h>
28 #ifdef HAVE_SIGNAL_H
29 # include <signal.h>
30 #endif
31 #include <sys/stat.h>
32 #include <sys/types.h>
33 #ifndef HAVE_W32_SYSTEM
34 #include <sys/wait.h>
35 #endif
36 #include <pth.h>
37
38 #include "agent.h"
39 #include <assuan.h>
40
41 #ifdef _POSIX_OPEN_MAX
42 #define MAX_OPEN_FDS _POSIX_OPEN_MAX
43 #else
44 #define MAX_OPEN_FDS 20
45 #endif
46
47 /* This Assuan flag is only available since libassuan 2.0.2.  Because
48    comments lines are comments anyway we can use a replacement which
49    might not do anything.  assuan_{g,s}et_flag don't return an error
50    thus there won't be any ABI problem.  */
51 #ifndef ASSUAN_CONVEY_COMMENTS
52 #define ASSUAN_CONVEY_COMMENTS 4
53 #endif
54
55
56 /* Definition of module local data of the CTRL structure.  */
57 struct scd_local_s
58 {
59   /* We keep a list of all allocated context with a an achnor at
60      SCD_LOCAL_LIST (see below). */
61   struct scd_local_s *next_local;
62
63   /* We need to get back to the ctrl object actually referencing this
64      structure.  This is really an awkward way of enumerint the lcoal
65      contects.  A much cleaner way would be to keep a global list of
66      ctrl objects to enumerate them.  */
67   ctrl_t ctrl_backlink;
68
69   assuan_context_t ctx; /* NULL or session context for the SCdaemon
70                            used with this connection. */
71   int locked;           /* This flag is used to assert proper use of
72                            start_scd and unlock_scd. */
73
74 };
75
76
77 /* Callback parameter for learn card */
78 struct learn_parm_s
79 {
80   void (*kpinfo_cb)(void*, const char *);
81   void *kpinfo_cb_arg;
82   void (*certinfo_cb)(void*, const char *);
83   void *certinfo_cb_arg;
84   void (*sinfo_cb)(void*, const char *, size_t, const char *);
85   void *sinfo_cb_arg;
86 };
87
88 struct inq_needpin_s
89 {
90   assuan_context_t ctx;
91   int (*getpin_cb)(void *, const char *, char*, size_t);
92   void *getpin_cb_arg;
93   assuan_context_t passthru;  /* If not NULL, pass unknown inquiries
94                                  up to the caller.  */
95   int any_inq_seen;
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 pth_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 static gpg_error_t membuf_data_cb (void *opaque,
124                                    const void *buffer, size_t length);
125
126
127
128 \f
129 /* This function must be called once to initialize this module.  This
130    has to be done before a second thread is spawned.  We can't do the
131    static initialization because Pth emulation code might not be able
132    to do a static init; in particular, it is not possible for W32. */
133 void
134 initialize_module_call_scd (void)
135 {
136   static int initialized;
137
138   if (!initialized)
139     {
140       if (!pth_mutex_init (&start_scd_lock))
141         log_fatal ("error initializing mutex: %s\n", strerror (errno));
142       initialized = 1;
143     }
144 }
145
146
147 static void
148 dump_mutex_state (pth_mutex_t *m)
149 {
150 #ifdef _W32_PTH_H
151   (void)m;
152   log_printf ("unknown under W32");
153 #else
154   if (!(m->mx_state & PTH_MUTEX_INITIALIZED))
155     log_printf ("not_initialized");
156   else if (!(m->mx_state & PTH_MUTEX_LOCKED))
157     log_printf ("not_locked");
158   else
159     log_printf ("locked tid=0x%lx count=%lu", (long)m->mx_owner, m->mx_count);
160 #endif
161 }
162
163
164 /* This function may be called to print infromation pertaining to the
165    current state of this module to the log. */
166 void
167 agent_scd_dump_state (void)
168 {
169   log_info ("agent_scd_dump_state: scd_lock=");
170   dump_mutex_state (&start_scd_lock);
171   log_printf ("\n");
172   log_info ("agent_scd_dump_state: primary_scd_ctx=%p pid=%ld reusable=%d\n",
173             primary_scd_ctx,
174             (long)assuan_get_pid (primary_scd_ctx),
175             primary_scd_ctx_reusable);
176   if (socket_name)
177     log_info ("agent_scd_dump_state: socket=`%s'\n", socket_name);
178 }
179
180
181 /* The unlock_scd function shall be called after having accessed the
182    SCD.  It is currently not very useful but gives an opportunity to
183    keep track of connections currently calling SCD.  Note that the
184    "lock" operation is done by the start_scd() function which must be
185    called and error checked before any SCD operation.  CTRL is the
186    usual connection context and RC the error code to be passed trhough
187    the function. */
188 static int
189 unlock_scd (ctrl_t ctrl, int rc)
190 {
191   if (ctrl->scd_local->locked != 1)
192     {
193       log_error ("unlock_scd: invalid lock count (%d)\n",
194                  ctrl->scd_local->locked);
195       if (!rc)
196         rc = gpg_error (GPG_ERR_INTERNAL);
197     }
198   ctrl->scd_local->locked = 0;
199   return rc;
200 }
201
202 /* To make sure we leave no secrets in our image after forking of the
203    scdaemon, we use this callback. */
204 static void
205 atfork_cb (void *opaque, int where)
206 {
207   (void)opaque;
208
209   if (!where)
210     gcry_control (GCRYCTL_TERM_SECMEM);
211 }
212
213
214 /* Fork off the SCdaemon if this has not already been done.  Lock the
215    daemon and make sure that a proper context has been setup in CTRL.
216    This function might also lock the daemon, which means that the
217    caller must call unlock_scd after this fucntion has returned
218    success and the actual Assuan transaction been done. */
219 static int
220 start_scd (ctrl_t ctrl)
221 {
222   gpg_error_t err = 0;
223   const char *pgmname;
224   assuan_context_t ctx = NULL;
225   const char *argv[3];
226   int no_close_list[3];
227   int i;
228   int rc;
229
230   if (opt.disable_scdaemon)
231     return gpg_error (GPG_ERR_NOT_SUPPORTED);
232
233   /* If this is the first call for this session, setup the local data
234      structure. */
235   if (!ctrl->scd_local)
236     {
237       ctrl->scd_local = xtrycalloc (1, sizeof *ctrl->scd_local);
238       if (!ctrl->scd_local)
239         return gpg_error_from_syserror ();
240       ctrl->scd_local->ctrl_backlink = ctrl;
241       ctrl->scd_local->next_local = scd_local_list;
242       scd_local_list = ctrl->scd_local;
243     }
244
245
246   /* Assert that the lock count is as expected. */
247   if (ctrl->scd_local->locked)
248     {
249       log_error ("start_scd: invalid lock count (%d)\n",
250                  ctrl->scd_local->locked);
251       return gpg_error (GPG_ERR_INTERNAL);
252     }
253   ctrl->scd_local->locked++;
254
255   if (ctrl->scd_local->ctx)
256     return 0; /* Okay, the context is fine.  We used to test for an
257                  alive context here and do an disconnect.  Now that we
258                  have a ticker function to check for it, it is easier
259                  not to check here but to let the connection run on an
260                  error instead. */
261
262
263   /* We need to protect the following code. */
264   if (!pth_mutex_acquire (&start_scd_lock, 0, NULL))
265     {
266       log_error ("failed to acquire the start_scd lock: %s\n",
267                  strerror (errno));
268       return gpg_error (GPG_ERR_INTERNAL);
269     }
270
271   /* Check whether the pipe server has already been started and in
272      this case either reuse a lingering pipe connection or establish a
273      new socket based one. */
274   if (primary_scd_ctx && primary_scd_ctx_reusable)
275     {
276       ctx = primary_scd_ctx;
277       primary_scd_ctx_reusable = 0;
278       if (opt.verbose)
279         log_info ("new connection to SCdaemon established (reusing)\n");
280       goto leave;
281     }
282
283   rc = assuan_new (&ctx);
284   if (rc)
285     {
286       log_error ("can't allocate assuan context: %s\n", gpg_strerror (rc));
287       err = rc;
288       goto leave;
289     }
290
291   if (socket_name)
292     {
293       rc = assuan_socket_connect (ctx, socket_name, 0, 0);
294       if (rc)
295         {
296           log_error ("can't connect to socket `%s': %s\n",
297                      socket_name, gpg_strerror (rc));
298           err = gpg_error (GPG_ERR_NO_SCDAEMON);
299           goto leave;
300         }
301
302       if (opt.verbose)
303         log_info ("new connection to SCdaemon established\n");
304       goto leave;
305     }
306
307   if (primary_scd_ctx)
308     {
309       log_info ("SCdaemon is running but won't accept further connections\n");
310       err = gpg_error (GPG_ERR_NO_SCDAEMON);
311       goto leave;
312     }
313
314   /* Nope, it has not been started.  Fire it up now. */
315   if (opt.verbose)
316     log_info ("no running SCdaemon - starting it\n");
317
318   if (fflush (NULL))
319     {
320 #ifndef HAVE_W32_SYSTEM
321       err = gpg_error_from_syserror ();
322 #endif
323       log_error ("error flushing pending output: %s\n", strerror (errno));
324       /* At least Windows XP fails here with EBADF.  According to docs
325          and Wine an fflush(NULL) is the same as _flushall.  However
326          the Wime implementaion does not flush stdin,stdout and stderr
327          - see above.  Lets try to ignore the error. */
328 #ifndef HAVE_W32_SYSTEM
329       goto leave;
330 #endif
331     }
332
333   if (!opt.scdaemon_program || !*opt.scdaemon_program)
334     opt.scdaemon_program = gnupg_module_name (GNUPG_MODULE_NAME_SCDAEMON);
335   if ( !(pgmname = strrchr (opt.scdaemon_program, '/')))
336     pgmname = opt.scdaemon_program;
337   else
338     pgmname++;
339
340   argv[0] = pgmname;
341   argv[1] = "--multi-server";
342   argv[2] = NULL;
343
344   i=0;
345   if (!opt.running_detached)
346     {
347       if (log_get_fd () != -1)
348         no_close_list[i++] = assuan_fd_from_posix_fd (log_get_fd ());
349       no_close_list[i++] = assuan_fd_from_posix_fd (fileno (stderr));
350     }
351   no_close_list[i] = -1;
352
353   /* Connect to the pinentry and perform initial handshaking.  Use
354      detached flag (128) so that under W32 SCDAEMON does not show up a
355      new window.  */
356   rc = assuan_pipe_connect (ctx, opt.scdaemon_program, argv,
357                             no_close_list, atfork_cb, NULL, 128);
358   if (rc)
359     {
360       log_error ("can't connect to the SCdaemon: %s\n",
361                  gpg_strerror (rc));
362       err = gpg_error (GPG_ERR_NO_SCDAEMON);
363       goto leave;
364     }
365
366   if (opt.verbose)
367     log_debug ("first connection to SCdaemon established\n");
368
369
370   /* Get the name of the additional socket opened by scdaemon. */
371   {
372     membuf_t data;
373     unsigned char *databuf;
374     size_t datalen;
375
376     xfree (socket_name);
377     socket_name = NULL;
378     init_membuf (&data, 256);
379     assuan_transact (ctx, "GETINFO socket_name",
380                      membuf_data_cb, &data, NULL, NULL, NULL, NULL);
381
382     databuf = get_membuf (&data, &datalen);
383     if (databuf && datalen)
384       {
385         socket_name = xtrymalloc (datalen + 1);
386         if (!socket_name)
387           log_error ("warning: can't store socket name: %s\n",
388                      strerror (errno));
389         else
390           {
391             memcpy (socket_name, databuf, datalen);
392             socket_name[datalen] = 0;
393             if (DBG_ASSUAN)
394               log_debug ("additional connections at `%s'\n", socket_name);
395           }
396       }
397     xfree (databuf);
398   }
399
400   /* Tell the scdaemon we want him to send us an event signal.  We
401      don't support this for W32CE.  */
402 #ifndef HAVE_W32CE_SYSTEM
403   if (opt.sigusr2_enabled)
404     {
405       char buf[100];
406
407 #ifdef HAVE_W32_SYSTEM
408       snprintf (buf, sizeof buf, "OPTION event-signal=%lx",
409                 (unsigned long)get_agent_scd_notify_event ());
410 #else
411       snprintf (buf, sizeof buf, "OPTION event-signal=%d", SIGUSR2);
412 #endif
413       assuan_transact (ctx, buf, NULL, NULL, NULL, NULL, NULL, NULL);
414     }
415 #endif /*HAVE_W32CE_SYSTEM*/
416
417   primary_scd_ctx = ctx;
418   primary_scd_ctx_reusable = 0;
419
420  leave:
421   if (err)
422     {
423       unlock_scd (ctrl, err);
424       if (ctx)
425         assuan_release (ctx);
426     }
427   else
428     {
429       ctrl->scd_local->ctx = ctx;
430     }
431   if (!pth_mutex_release (&start_scd_lock))
432     log_error ("failed to release the start_scd lock: %s\n", strerror (errno));
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   pth_event_t evt;
452   pid_t pid;
453 #ifdef HAVE_W32_SYSTEM
454   DWORD rc;
455 #else
456   int rc;
457 #endif
458
459   if (!primary_scd_ctx)
460     return; /* No scdaemon running. */
461
462   /* This is not a critical function so we use a short timeout while
463      acquiring the lock.  */
464   evt = pth_event (PTH_EVENT_TIME, pth_timeout (1, 0));
465   if (!pth_mutex_acquire (&start_scd_lock, 0, evt))
466     {
467       if (pth_event_occurred (evt))
468         {
469           if (opt.verbose > 1)
470             log_info ("failed to acquire the start_scd lock while"
471                       " doing an aliveness check: %s\n", "timeout");
472         }
473       else
474         log_error ("failed to acquire the start_scd lock while"
475                    " doing an aliveness check: %s\n", strerror (errno));
476       pth_event_free (evt, PTH_FREE_THIS);
477       return;
478     }
479   pth_event_free (evt, PTH_FREE_THIS);
480
481   if (primary_scd_ctx)
482     {
483       pid = assuan_get_pid (primary_scd_ctx);
484 #ifdef HAVE_W32_SYSTEM
485       /* If we have a PID we disconnect if either GetExitProcessCode
486          fails or if ir returns the exit code of the scdaemon.  259 is
487          the error code for STILL_ALIVE.  */
488       if (pid != (pid_t)(void*)(-1) && pid
489           && (!GetExitCodeProcess ((HANDLE)pid, &rc) || rc != 259))
490 #else
491       if (pid != (pid_t)(-1) && pid
492           && ((rc=waitpid (pid, NULL, WNOHANG))==-1 || (rc == pid)) )
493 #endif
494         {
495           /* Okay, scdaemon died.  Disconnect the primary connection
496              now but take care that it won't do another wait. Also
497              cleanup all other connections and release their
498              resources.  The next use will start a new daemon then.
499              Due to the use of the START_SCD_LOCAL we are sure that
500              none of these context are actually in use. */
501           struct scd_local_s *sl;
502
503           assuan_set_flag (primary_scd_ctx, ASSUAN_NO_WAITPID, 1);
504           assuan_release (primary_scd_ctx);
505
506           for (sl=scd_local_list; sl; sl = sl->next_local)
507             {
508               if (sl->ctx)
509                 {
510                   if (sl->ctx != primary_scd_ctx)
511                     assuan_release (sl->ctx);
512                   sl->ctx = NULL;
513                 }
514             }
515
516           primary_scd_ctx = NULL;
517           primary_scd_ctx_reusable = 0;
518
519           xfree (socket_name);
520           socket_name = NULL;
521         }
522     }
523
524   if (!pth_mutex_release (&start_scd_lock))
525     log_error ("failed to release the start_scd lock while"
526                " doing the aliveness check: %s\n", strerror (errno));
527 }
528
529
530
531 /* Reset the SCD if it has been used.  Actually it is not a reset but
532    a cleanup of resources used by the current connection. */
533 int
534 agent_reset_scd (ctrl_t ctrl)
535 {
536   if (ctrl->scd_local)
537     {
538       if (ctrl->scd_local->ctx)
539         {
540           /* We can't disconnect the primary context because libassuan
541              does a waitpid on it and thus the system would hang.
542              Instead we send a reset and keep that connection for
543              reuse. */
544           if (ctrl->scd_local->ctx == primary_scd_ctx)
545             {
546               /* Send a RESTART to the SCD.  This is required for the
547                  primary connection as a kind of virtual EOF; we don't
548                  have another way to tell it that the next command
549                  should be viewed as if a new connection has been
550                  made.  For the non-primary connections this is not
551                  needed as we simply close the socket.  We don't check
552                  for an error here because the RESTART may fail for
553                  example if the scdaemon has already been terminated.
554                  Anyway, we need to set the reusable flag to make sure
555                  that the aliveness check can clean it up. */
556               assuan_transact (primary_scd_ctx, "RESTART",
557                                NULL, NULL, NULL, NULL, NULL, NULL);
558               primary_scd_ctx_reusable = 1;
559             }
560           else
561             assuan_release (ctrl->scd_local->ctx);
562           ctrl->scd_local->ctx = NULL;
563         }
564
565       /* Remove the local context from our list and release it. */
566       if (!scd_local_list)
567         BUG ();
568       else if (scd_local_list == ctrl->scd_local)
569         scd_local_list = ctrl->scd_local->next_local;
570       else
571         {
572           struct scd_local_s *sl;
573
574           for (sl=scd_local_list; sl->next_local; sl = sl->next_local)
575             if (sl->next_local == ctrl->scd_local)
576               break;
577           if (!sl->next_local)
578             BUG ();
579           sl->next_local = ctrl->scd_local->next_local;
580         }
581       xfree (ctrl->scd_local);
582       ctrl->scd_local = NULL;
583     }
584
585   return 0;
586 }
587
588
589 \f
590 static gpg_error_t
591 learn_status_cb (void *opaque, const char *line)
592 {
593   struct learn_parm_s *parm = opaque;
594   const char *keyword = line;
595   int keywordlen;
596
597   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
598     ;
599   while (spacep (line))
600     line++;
601   if (keywordlen == 8 && !memcmp (keyword, "CERTINFO", keywordlen))
602     {
603       parm->certinfo_cb (parm->certinfo_cb_arg, line);
604     }
605   else if (keywordlen == 11 && !memcmp (keyword, "KEYPAIRINFO", keywordlen))
606     {
607       parm->kpinfo_cb (parm->kpinfo_cb_arg, line);
608     }
609   else if (keywordlen && *line)
610     {
611       parm->sinfo_cb (parm->sinfo_cb_arg, keyword, keywordlen, line);
612     }
613
614   return 0;
615 }
616
617 /* Perform the LEARN command and return a list of all private keys
618    stored on the card. */
619 int
620 agent_card_learn (ctrl_t ctrl,
621                   void (*kpinfo_cb)(void*, const char *),
622                   void *kpinfo_cb_arg,
623                   void (*certinfo_cb)(void*, const char *),
624                   void *certinfo_cb_arg,
625                   void (*sinfo_cb)(void*, const char *, size_t, const char *),
626                   void *sinfo_cb_arg)
627 {
628   int rc;
629   struct learn_parm_s parm;
630
631   rc = start_scd (ctrl);
632   if (rc)
633     return rc;
634
635   memset (&parm, 0, sizeof parm);
636   parm.kpinfo_cb = kpinfo_cb;
637   parm.kpinfo_cb_arg = kpinfo_cb_arg;
638   parm.certinfo_cb = certinfo_cb;
639   parm.certinfo_cb_arg = certinfo_cb_arg;
640   parm.sinfo_cb = sinfo_cb;
641   parm.sinfo_cb_arg = sinfo_cb_arg;
642   rc = assuan_transact (ctrl->scd_local->ctx, "LEARN --force",
643                         NULL, NULL, NULL, NULL,
644                         learn_status_cb, &parm);
645   if (rc)
646     return unlock_scd (ctrl, rc);
647
648   return unlock_scd (ctrl, 0);
649 }
650
651
652 \f
653 static gpg_error_t
654 get_serialno_cb (void *opaque, const char *line)
655 {
656   char **serialno = opaque;
657   const char *keyword = line;
658   const char *s;
659   int keywordlen, n;
660
661   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
662     ;
663   while (spacep (line))
664     line++;
665
666   if (keywordlen == 8 && !memcmp (keyword, "SERIALNO", keywordlen))
667     {
668       if (*serialno)
669         return gpg_error (GPG_ERR_CONFLICT); /* Unexpected status line. */
670       for (n=0,s=line; hexdigitp (s); s++, n++)
671         ;
672       if (!n || (n&1)|| !(spacep (s) || !*s) )
673         return gpg_error (GPG_ERR_ASS_PARAMETER);
674       *serialno = xtrymalloc (n+1);
675       if (!*serialno)
676         return out_of_core ();
677       memcpy (*serialno, line, n);
678       (*serialno)[n] = 0;
679     }
680
681   return 0;
682 }
683
684 /* Return the serial number of the card or an appropriate error.  The
685    serial number is returned as a hexstring. */
686 int
687 agent_card_serialno (ctrl_t ctrl, char **r_serialno)
688 {
689   int rc;
690   char *serialno = NULL;
691
692   rc = start_scd (ctrl);
693   if (rc)
694     return rc;
695
696   rc = assuan_transact (ctrl->scd_local->ctx, "SERIALNO",
697                         NULL, NULL, NULL, NULL,
698                         get_serialno_cb, &serialno);
699   if (rc)
700     {
701       xfree (serialno);
702       return unlock_scd (ctrl, rc);
703     }
704   *r_serialno = serialno;
705   return unlock_scd (ctrl, 0);
706 }
707
708
709
710 \f
711 static gpg_error_t
712 membuf_data_cb (void *opaque, const void *buffer, size_t length)
713 {
714   membuf_t *data = opaque;
715
716   if (buffer)
717     put_membuf (data, buffer, length);
718   return 0;
719 }
720
721 /* Handle the NEEDPIN inquiry. */
722 static gpg_error_t
723 inq_needpin (void *opaque, const char *line)
724 {
725   struct inq_needpin_s *parm = opaque;
726   char *pin;
727   size_t pinlen;
728   int rc;
729
730   parm->any_inq_seen = 1;
731   if (!strncmp (line, "NEEDPIN", 7) && (line[7] == ' ' || !line[7]))
732     {
733       line += 7;
734       while (*line == ' ')
735         line++;
736
737       pinlen = 90;
738       pin = gcry_malloc_secure (pinlen);
739       if (!pin)
740         return out_of_core ();
741
742       rc = parm->getpin_cb (parm->getpin_cb_arg, line, pin, pinlen);
743       if (!rc)
744         rc = assuan_send_data (parm->ctx, pin, pinlen);
745       xfree (pin);
746     }
747   else if (!strncmp (line, "POPUPKEYPADPROMPT", 17)
748            && (line[17] == ' ' || !line[17]))
749     {
750       line += 17;
751       while (*line == ' ')
752         line++;
753
754       rc = parm->getpin_cb (parm->getpin_cb_arg, line, NULL, 1);
755     }
756   else if (!strncmp (line, "DISMISSKEYPADPROMPT", 19)
757            && (line[19] == ' ' || !line[19]))
758     {
759       rc = parm->getpin_cb (parm->getpin_cb_arg, "", NULL, 0);
760     }
761   else if (parm->passthru)
762     {
763       unsigned char *value;
764       size_t valuelen;
765       int rest;
766       int needrest = !strncmp (line, "KEYDATA", 8);
767
768       /* Pass the inquiry up to our caller.  We limit the maximum
769          amount to an arbitrary value.  As we know that the KEYDATA
770          enquiry is pretty sensitive we disable logging then */
771       if ((rest = (needrest
772                    && !assuan_get_flag (parm->passthru, ASSUAN_CONFIDENTIAL))))
773         assuan_begin_confidential (parm->passthru);
774       rc = assuan_inquire (parm->passthru, line, &value, &valuelen, 8096);
775       if (rest)
776         assuan_end_confidential (parm->passthru);
777       if (!rc)
778         {
779           if ((rest = (needrest
780                        && !assuan_get_flag (parm->ctx, ASSUAN_CONFIDENTIAL))))
781             assuan_begin_confidential (parm->ctx);
782           rc = assuan_send_data (parm->ctx, value, valuelen);
783           if (rest)
784             assuan_end_confidential (parm->ctx);
785           xfree (value);
786         }
787       else
788         log_error ("error forwarding inquiry `%s': %s\n",
789                    line, gpg_strerror (rc));
790     }
791   else
792     {
793       log_error ("unsupported inquiry `%s'\n", line);
794       rc = gpg_error (GPG_ERR_ASS_UNKNOWN_INQUIRE);
795     }
796
797   return rc;
798 }
799
800
801 /* Helper returning a command option to describe the used hash
802    algorithm.  See scd/command.c:cmd_pksign.  */
803 static const char *
804 hash_algo_option (int algo)
805 {
806   switch (algo)
807     {
808     case GCRY_MD_MD5   : return "--hash=md5";
809     case GCRY_MD_RMD160: return "--hash=rmd160";
810     case GCRY_MD_SHA1  : return "--hash=sha1";
811     case GCRY_MD_SHA224: return "--hash=sha224";
812     case GCRY_MD_SHA256: return "--hash=sha256";
813     case GCRY_MD_SHA384: return "--hash=sha384";
814     case GCRY_MD_SHA512: return "--hash=sha512";
815     default:             return "";
816     }
817 }
818
819
820 /* Create a signature using the current card.  MDALGO is either 0 or
821    gives the digest algorithm.  */
822 int
823 agent_card_pksign (ctrl_t ctrl,
824                    const char *keyid,
825                    int (*getpin_cb)(void *, const char *, char*, size_t),
826                    void *getpin_cb_arg,
827                    int mdalgo,
828                    const unsigned char *indata, size_t indatalen,
829                    unsigned char **r_buf, size_t *r_buflen)
830 {
831   int rc, i;
832   char *p, line[ASSUAN_LINELENGTH];
833   membuf_t data;
834   struct inq_needpin_s inqparm;
835   size_t len;
836   unsigned char *sigbuf;
837   size_t sigbuflen;
838   int prepend_nul;
839
840   *r_buf = NULL;
841   rc = start_scd (ctrl);
842   if (rc)
843     return rc;
844
845   if (indatalen*2 + 50 > DIM(line))
846     return unlock_scd (ctrl, gpg_error (GPG_ERR_GENERAL));
847
848   sprintf (line, "SETDATA ");
849   p = line + strlen (line);
850   for (i=0; i < indatalen ; i++, p += 2 )
851     sprintf (p, "%02X", indata[i]);
852   rc = assuan_transact (ctrl->scd_local->ctx, line,
853                         NULL, NULL, NULL, NULL, NULL, NULL);
854   if (rc)
855     return unlock_scd (ctrl, rc);
856
857   init_membuf (&data, 1024);
858   inqparm.ctx = ctrl->scd_local->ctx;
859   inqparm.getpin_cb = getpin_cb;
860   inqparm.getpin_cb_arg = getpin_cb_arg;
861   inqparm.passthru = 0;
862   inqparm.any_inq_seen = 0;
863   if (ctrl->use_auth_call)
864     snprintf (line, sizeof line, "PKAUTH %s", keyid);
865   else
866     snprintf (line, sizeof line, "PKSIGN %s %s",
867               hash_algo_option (mdalgo), keyid);
868   rc = assuan_transact (ctrl->scd_local->ctx, line,
869                         membuf_data_cb, &data,
870                         inq_needpin, &inqparm,
871                         NULL, NULL);
872   if (rc)
873     {
874       xfree (get_membuf (&data, &len));
875       return unlock_scd (ctrl, rc);
876     }
877   sigbuf = get_membuf (&data, &sigbuflen);
878
879   /* Create an S-expression from it which is formatted like this:
880      "(7:sig-val(3:rsa(1:sSIGBUFLEN:SIGBUF)))".  We better make sure
881      that this won't be interpreted as a negative number.  */
882   prepend_nul = (sigbuflen && (*sigbuf & 0x80));
883
884   *r_buflen = 21 + 11 + prepend_nul + sigbuflen + 4;
885   p = xtrymalloc (*r_buflen);
886   *r_buf = (unsigned char*)p;
887   if (!p)
888     return unlock_scd (ctrl, out_of_core ());
889   p = stpcpy (p, "(7:sig-val(3:rsa(1:s" );
890   sprintf (p, "%u:", (unsigned int)sigbuflen + prepend_nul);
891   p += strlen (p);
892   if (prepend_nul)
893     *p++ = 0;
894   memcpy (p, sigbuf, sigbuflen);
895   p += sigbuflen;
896   strcpy (p, ")))");
897   xfree (sigbuf);
898
899   assert (gcry_sexp_canon_len (*r_buf, *r_buflen, NULL, NULL));
900   return unlock_scd (ctrl, 0);
901 }
902
903 /* Decipher INDATA using the current card. Note that the returned value is */
904 int
905 agent_card_pkdecrypt (ctrl_t ctrl,
906                       const char *keyid,
907                       int (*getpin_cb)(void *, const char *, char*, size_t),
908                       void *getpin_cb_arg,
909                       const unsigned char *indata, size_t indatalen,
910                       char **r_buf, size_t *r_buflen)
911 {
912   int rc, i;
913   char *p, line[ASSUAN_LINELENGTH];
914   membuf_t data;
915   struct inq_needpin_s inqparm;
916   size_t len;
917
918   *r_buf = NULL;
919   rc = start_scd (ctrl);
920   if (rc)
921     return rc;
922
923   /* FIXME: use secure memory where appropriate */
924   if (indatalen*2 + 50 > DIM(line))
925     return unlock_scd (ctrl, gpg_error (GPG_ERR_GENERAL));
926
927   sprintf (line, "SETDATA ");
928   p = line + strlen (line);
929   for (i=0; i < indatalen ; i++, p += 2 )
930     sprintf (p, "%02X", indata[i]);
931   rc = assuan_transact (ctrl->scd_local->ctx, line,
932                         NULL, NULL, NULL, NULL, NULL, NULL);
933   if (rc)
934     return unlock_scd (ctrl, rc);
935
936   init_membuf (&data, 1024);
937   inqparm.ctx = ctrl->scd_local->ctx;
938   inqparm.getpin_cb = getpin_cb;
939   inqparm.getpin_cb_arg = getpin_cb_arg;
940   inqparm.passthru = 0;
941   inqparm.any_inq_seen = 0;
942   snprintf (line, DIM(line)-1, "PKDECRYPT %s", keyid);
943   line[DIM(line)-1] = 0;
944   rc = assuan_transact (ctrl->scd_local->ctx, line,
945                         membuf_data_cb, &data,
946                         inq_needpin, &inqparm,
947                         NULL, NULL);
948   if (rc)
949     {
950       xfree (get_membuf (&data, &len));
951       return unlock_scd (ctrl, rc);
952     }
953   *r_buf = get_membuf (&data, r_buflen);
954   if (!*r_buf)
955     return unlock_scd (ctrl, gpg_error (GPG_ERR_ENOMEM));
956
957   return unlock_scd (ctrl, 0);
958 }
959
960
961 \f
962 /* Read a certificate with ID into R_BUF and R_BUFLEN. */
963 int
964 agent_card_readcert (ctrl_t ctrl,
965                      const char *id, char **r_buf, size_t *r_buflen)
966 {
967   int rc;
968   char line[ASSUAN_LINELENGTH];
969   membuf_t data;
970   size_t len;
971
972   *r_buf = NULL;
973   rc = start_scd (ctrl);
974   if (rc)
975     return rc;
976
977   init_membuf (&data, 1024);
978   snprintf (line, DIM(line)-1, "READCERT %s", id);
979   line[DIM(line)-1] = 0;
980   rc = assuan_transact (ctrl->scd_local->ctx, line,
981                         membuf_data_cb, &data,
982                         NULL, NULL,
983                         NULL, NULL);
984   if (rc)
985     {
986       xfree (get_membuf (&data, &len));
987       return unlock_scd (ctrl, rc);
988     }
989   *r_buf = get_membuf (&data, r_buflen);
990   if (!*r_buf)
991     return unlock_scd (ctrl, gpg_error (GPG_ERR_ENOMEM));
992
993   return unlock_scd (ctrl, 0);
994 }
995
996
997 \f
998 /* Read a key with ID and return it in an allocate buffer pointed to
999    by r_BUF as a valid S-expression. */
1000 int
1001 agent_card_readkey (ctrl_t ctrl, const char *id, unsigned char **r_buf)
1002 {
1003   int rc;
1004   char line[ASSUAN_LINELENGTH];
1005   membuf_t data;
1006   size_t len, buflen;
1007
1008   *r_buf = NULL;
1009   rc = start_scd (ctrl);
1010   if (rc)
1011     return rc;
1012
1013   init_membuf (&data, 1024);
1014   snprintf (line, DIM(line)-1, "READKEY %s", id);
1015   line[DIM(line)-1] = 0;
1016   rc = assuan_transact (ctrl->scd_local->ctx, line,
1017                         membuf_data_cb, &data,
1018                         NULL, NULL,
1019                         NULL, NULL);
1020   if (rc)
1021     {
1022       xfree (get_membuf (&data, &len));
1023       return unlock_scd (ctrl, rc);
1024     }
1025   *r_buf = get_membuf (&data, &buflen);
1026   if (!*r_buf)
1027     return unlock_scd (ctrl, gpg_error (GPG_ERR_ENOMEM));
1028
1029   if (!gcry_sexp_canon_len (*r_buf, buflen, NULL, NULL))
1030     {
1031       xfree (*r_buf); *r_buf = NULL;
1032       return unlock_scd (ctrl, gpg_error (GPG_ERR_INV_VALUE));
1033     }
1034
1035   return unlock_scd (ctrl, 0);
1036 }
1037
1038
1039 \f
1040 /* Type used with the card_getattr_cb.  */
1041 struct card_getattr_parm_s {
1042   const char *keyword;  /* Keyword to look for.  */
1043   size_t keywordlen;    /* strlen of KEYWORD.  */
1044   char *data;           /* Malloced and unescaped data.  */
1045   int error;            /* ERRNO value or 0 on success. */
1046 };
1047
1048 /* Callback function for agent_card_getattr.  */
1049 static gpg_error_t
1050 card_getattr_cb (void *opaque, const char *line)
1051 {
1052   struct card_getattr_parm_s *parm = opaque;
1053   const char *keyword = line;
1054   int keywordlen;
1055
1056   if (parm->data)
1057     return 0; /* We want only the first occurrence.  */
1058
1059   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
1060     ;
1061   while (spacep (line))
1062     line++;
1063
1064   if (keywordlen == parm->keywordlen
1065       && !memcmp (keyword, parm->keyword, keywordlen))
1066     {
1067       parm->data = percent_plus_unescape ((const unsigned char*)line, 0xff);
1068       if (!parm->data)
1069         parm->error = errno;
1070     }
1071
1072   return 0;
1073 }
1074
1075
1076 /* Call the agent to retrieve a single line data object. On success
1077    the object is malloced and stored at RESULT; it is guaranteed that
1078    NULL is never stored in this case.  On error an error code is
1079    returned and NULL stored at RESULT. */
1080 gpg_error_t
1081 agent_card_getattr (ctrl_t ctrl, const char *name, char **result)
1082 {
1083   int err;
1084   struct card_getattr_parm_s parm;
1085   char line[ASSUAN_LINELENGTH];
1086
1087   *result = NULL;
1088
1089   if (!*name)
1090     return gpg_error (GPG_ERR_INV_VALUE);
1091
1092   memset (&parm, 0, sizeof parm);
1093   parm.keyword = name;
1094   parm.keywordlen = strlen (name);
1095
1096   /* We assume that NAME does not need escaping. */
1097   if (8 + strlen (name) > DIM(line)-1)
1098     return gpg_error (GPG_ERR_TOO_LARGE);
1099   stpcpy (stpcpy (line, "GETATTR "), name);
1100
1101   err = start_scd (ctrl);
1102   if (err)
1103     return err;
1104
1105   err = assuan_transact (ctrl->scd_local->ctx, line,
1106                          NULL, NULL, NULL, NULL,
1107                          card_getattr_cb, &parm);
1108   if (!err && parm.error)
1109     err = gpg_error_from_errno (parm.error);
1110
1111   if (!err && !parm.data)
1112     err = gpg_error (GPG_ERR_NO_DATA);
1113
1114   if (!err)
1115     *result = parm.data;
1116   else
1117     xfree (parm.data);
1118
1119   return unlock_scd (ctrl, err);
1120 }
1121
1122
1123
1124 \f
1125 static gpg_error_t
1126 pass_status_thru (void *opaque, const char *line)
1127 {
1128   assuan_context_t ctx = opaque;
1129   char keyword[200];
1130   int i;
1131
1132   for (i=0; *line && !spacep (line) && i < DIM(keyword)-1; line++, i++)
1133     keyword[i] = *line;
1134   keyword[i] = 0;
1135   /* truncate any remaining keyword stuff. */
1136   for (; *line && !spacep (line); line++)
1137     ;
1138   while (spacep (line))
1139     line++;
1140
1141   assuan_write_status (ctx, keyword, line);
1142   return 0;
1143 }
1144
1145 static gpg_error_t
1146 pass_data_thru (void *opaque, const void *buffer, size_t length)
1147 {
1148   assuan_context_t ctx = opaque;
1149
1150   assuan_send_data (ctx, buffer, length);
1151   return 0;
1152 }
1153
1154
1155 /* Send the line CMDLINE with command for the SCDdaemon to it and send
1156    all status messages back.  This command is used as a general quoting
1157    mechanism to pass everything verbatim to SCDAEMON.  The PIN
1158    inquiry is handled inside gpg-agent.  */
1159 int
1160 agent_card_scd (ctrl_t ctrl, const char *cmdline,
1161                 int (*getpin_cb)(void *, const char *, char*, size_t),
1162                 void *getpin_cb_arg, void *assuan_context)
1163 {
1164   int rc;
1165   struct inq_needpin_s inqparm;
1166   int saveflag;
1167
1168   rc = start_scd (ctrl);
1169   if (rc)
1170     return rc;
1171
1172   inqparm.ctx = ctrl->scd_local->ctx;
1173   inqparm.getpin_cb = getpin_cb;
1174   inqparm.getpin_cb_arg = getpin_cb_arg;
1175   inqparm.passthru = assuan_context;
1176   inqparm.any_inq_seen = 0;
1177   saveflag = assuan_get_flag (ctrl->scd_local->ctx, ASSUAN_CONVEY_COMMENTS);
1178   assuan_set_flag (ctrl->scd_local->ctx, ASSUAN_CONVEY_COMMENTS, 1);
1179   rc = assuan_transact (ctrl->scd_local->ctx, cmdline,
1180                         pass_data_thru, assuan_context,
1181                         inq_needpin, &inqparm,
1182                         pass_status_thru, assuan_context);
1183   if (inqparm.any_inq_seen && gpg_err_code(rc) == GPG_ERR_ASS_CANCELED)
1184     {
1185       /* The inquire callback was called and transact returned a
1186          cancel error.  We assume that the inquired process sent a
1187          CANCEL.  The passthrough code is not able to pass on the
1188          CANCEL and thus scdaemon would stuck on this.  As a
1189          workaround we send a CANCEL now.  */
1190       rc = assuan_write_line(ctrl->scd_local->ctx, "CAN");
1191       if (!rc) {
1192         char *line;
1193         size_t len;
1194
1195         rc = assuan_read_line(ctrl->scd_local->ctx, &line, &len);
1196         if (!rc)
1197           rc = gpg_error(GPG_ERR_ASS_CANCELED);
1198       }
1199     }
1200
1201   assuan_set_flag (ctrl->scd_local->ctx, ASSUAN_CONVEY_COMMENTS, saveflag);
1202   if (rc)
1203     {
1204       return unlock_scd (ctrl, rc);
1205     }
1206
1207   return unlock_scd (ctrl, 0);
1208 }