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