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