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