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