Started to implement the audit log feature.
[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 #ifndef HAVE_W32_SYSTEM
378   {
379     char buf[100];
380
381     sprintf (buf, "OPTION event-signal=%d", SIGUSR2);
382     assuan_transact (ctx, buf, NULL, NULL, NULL, NULL, NULL, NULL);
383   }
384 #endif
385
386   primary_scd_ctx = ctx;
387   primary_scd_ctx_reusable = 0;
388
389  leave:
390   if (err)
391     {
392       unlock_scd (ctrl, err);
393     } 
394   else
395     {
396       ctrl->scd_local->ctx = ctx;
397     }
398   if (!pth_mutex_release (&start_scd_lock))
399     log_error ("failed to release the start_scd lock: %s\n", strerror (errno));
400   return err;
401 }
402
403
404 /* Check whether the Scdaemon is still alive and clean it up if not. */
405 void
406 agent_scd_check_aliveness (void)
407 {
408   pth_event_t evt;
409   pid_t pid;
410   int rc;
411
412   if (!primary_scd_ctx)
413     return; /* No scdaemon running. */
414
415   /* This is not a critical function so we use a short timeout while
416      acquiring the lock.  */
417   evt = pth_event (PTH_EVENT_TIME, pth_timeout (1, 0));
418   if (!pth_mutex_acquire (&start_scd_lock, 0, evt))
419     {
420       if (pth_event_occurred (evt))
421         {
422           if (opt.verbose > 1)
423             log_info ("failed to acquire the start_scd lock while"
424                       " doing an aliveness check: %s\n", "timeout");
425         }
426       else
427         log_error ("failed to acquire the start_scd lock while"
428                    " doing an aliveness check: %s\n", strerror (errno));
429       pth_event_free (evt, PTH_FREE_THIS);
430       return;
431     }
432   pth_event_free (evt, PTH_FREE_THIS);
433
434   if (primary_scd_ctx)
435     {
436       pid = assuan_get_pid (primary_scd_ctx);
437 #ifdef HAVE_W32_SYSTEM
438 #warning Need to implement an alive test for scdaemon
439 #else
440       if (pid != (pid_t)(-1) && pid
441           && ((rc=waitpid (pid, NULL, WNOHANG))==-1 || (rc == pid)) )
442         {
443           /* Okay, scdaemon died.  Disconnect the primary connection
444              now but take care that it won't do another wait. Also
445              cleanup all other connections and release their
446              resources.  The next use will start a new daemon then.
447              Due to the use of the START_SCD_LOCAL we are sure that
448              none of these context are actually in use. */
449           struct scd_local_s *sl;
450
451           assuan_set_flag (primary_scd_ctx, ASSUAN_NO_WAITPID, 1);
452           assuan_disconnect (primary_scd_ctx);
453
454           for (sl=scd_local_list; sl; sl = sl->next_local)
455             {
456               if (sl->ctx)
457                 {
458                   if (sl->ctx != primary_scd_ctx)
459                     assuan_disconnect (sl->ctx);
460                   sl->ctx = NULL;
461                 }
462             }
463           
464           primary_scd_ctx = NULL;
465           primary_scd_ctx_reusable = 0;
466
467           xfree (socket_name);
468           socket_name = NULL;
469         }
470 #endif
471     }
472
473   if (!pth_mutex_release (&start_scd_lock))
474     log_error ("failed to release the start_scd lock while"
475                " doing the aliveness check: %s\n", strerror (errno));
476 }
477
478
479
480 /* Reset the SCD if it has been used.  Actually it is not a reset but
481    a cleanup of resources used by the current connection. */
482 int
483 agent_reset_scd (ctrl_t ctrl)
484 {
485   if (ctrl->scd_local)
486     {
487       if (ctrl->scd_local->ctx)
488         {
489           /* We can't disconnect the primary context because libassuan
490              does a waitpid on it and thus the system would hang.
491              Instead we send a reset and keep that connection for
492              reuse. */
493           if (ctrl->scd_local->ctx == primary_scd_ctx)
494             {
495               /* Send a RESTART to the SCD.  This is required for the
496                  primary connection as a kind of virtual EOF; we don't
497                  have another way to tell it that the next command
498                  should be viewed as if a new connection has been
499                  made.  For the non-primary connections this is not
500                  needed as we simply close the socket.  We don't check
501                  for an error here because the RESTART may fail for
502                  example if the scdaemon has already been terminated.
503                  Anyway, we need to set the reusable flag to make sure
504                  that the aliveness check can clean it up. */
505               assuan_transact (primary_scd_ctx, "RESTART",
506                                NULL, NULL, NULL, NULL, NULL, NULL);
507               primary_scd_ctx_reusable = 1;
508             }
509           else
510             assuan_disconnect (ctrl->scd_local->ctx);
511           ctrl->scd_local->ctx = NULL;
512         }
513       
514       /* Remove the local context from our list and release it. */
515       if (!scd_local_list)
516         BUG ();
517       else if (scd_local_list == ctrl->scd_local)
518         scd_local_list = ctrl->scd_local->next_local;
519       else
520         {
521           struct scd_local_s *sl;
522       
523           for (sl=scd_local_list; sl->next_local; sl = sl->next_local)
524             if (sl->next_local == ctrl->scd_local)
525               break;
526           if (!sl->next_local)
527             BUG ();
528           sl->next_local = ctrl->scd_local->next_local;
529         }
530       xfree (ctrl->scd_local);
531       ctrl->scd_local = NULL;
532     }
533
534   return 0;
535 }
536
537
538 \f
539 /* Return a new malloced string by unescaping the string S.  Escaping
540    is percent escaping and '+'/space mapping.  A binary Nul will
541    silently be replaced by a 0xFF.  Function returns NULL to indicate
542    an out of memory status. */
543 static char *
544 unescape_status_string (const unsigned char *s)
545 {
546   char *buffer, *d;
547
548   buffer = d = xtrymalloc (strlen ((const char*)s)+1);
549   if (!buffer)
550     return NULL;
551   while (*s)
552     {
553       if (*s == '%' && s[1] && s[2])
554         { 
555           s++;
556           *d = xtoi_2 (s);
557           if (!*d)
558             *d = '\xff';
559           d++;
560           s += 2;
561         }
562       else if (*s == '+')
563         {
564           *d++ = ' ';
565           s++;
566         }
567       else
568         *d++ = *s++;
569     }
570   *d = 0; 
571   return buffer;
572 }
573
574
575 \f
576 static int
577 learn_status_cb (void *opaque, const char *line)
578 {
579   struct learn_parm_s *parm = opaque;
580   const char *keyword = line;
581   int keywordlen;
582
583   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
584     ;
585   while (spacep (line))
586     line++;
587   if (keywordlen == 8 && !memcmp (keyword, "CERTINFO", keywordlen))
588     {
589       parm->certinfo_cb (parm->certinfo_cb_arg, line);
590     }
591   else if (keywordlen == 11 && !memcmp (keyword, "KEYPAIRINFO", keywordlen))
592     {
593       parm->kpinfo_cb (parm->kpinfo_cb_arg, line);
594     }
595   else if (keywordlen && *line)
596     {
597       parm->sinfo_cb (parm->sinfo_cb_arg, keyword, keywordlen, line);
598     }
599   
600   return 0;
601 }
602
603 /* Perform the LEARN command and return a list of all private keys
604    stored on the card. */
605 int
606 agent_card_learn (ctrl_t ctrl,
607                   void (*kpinfo_cb)(void*, const char *),
608                   void *kpinfo_cb_arg,
609                   void (*certinfo_cb)(void*, const char *),
610                   void *certinfo_cb_arg,
611                   void (*sinfo_cb)(void*, const char *, size_t, const char *),
612                   void *sinfo_cb_arg)
613 {
614   int rc;
615   struct learn_parm_s parm;
616
617   rc = start_scd (ctrl);
618   if (rc)
619     return rc;
620
621   memset (&parm, 0, sizeof parm);
622   parm.kpinfo_cb = kpinfo_cb;
623   parm.kpinfo_cb_arg = kpinfo_cb_arg;
624   parm.certinfo_cb = certinfo_cb;
625   parm.certinfo_cb_arg = certinfo_cb_arg;
626   parm.sinfo_cb = sinfo_cb;
627   parm.sinfo_cb_arg = sinfo_cb_arg;
628   rc = assuan_transact (ctrl->scd_local->ctx, "LEARN --force",
629                         NULL, NULL, NULL, NULL,
630                         learn_status_cb, &parm);
631   if (rc)
632     return unlock_scd (ctrl, rc);
633
634   return unlock_scd (ctrl, 0);
635 }
636
637
638 \f
639 static int
640 get_serialno_cb (void *opaque, const char *line)
641 {
642   char **serialno = opaque;
643   const char *keyword = line;
644   const char *s;
645   int keywordlen, n;
646
647   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
648     ;
649   while (spacep (line))
650     line++;
651
652   if (keywordlen == 8 && !memcmp (keyword, "SERIALNO", keywordlen))
653     {
654       if (*serialno)
655         return gpg_error (GPG_ERR_CONFLICT); /* Unexpected status line. */
656       for (n=0,s=line; hexdigitp (s); s++, n++)
657         ;
658       if (!n || (n&1)|| !(spacep (s) || !*s) )
659         return gpg_error (GPG_ERR_ASS_PARAMETER);
660       *serialno = xtrymalloc (n+1);
661       if (!*serialno)
662         return out_of_core ();
663       memcpy (*serialno, line, n);
664       (*serialno)[n] = 0;
665     }
666   
667   return 0;
668 }
669
670 /* Return the serial number of the card or an appropriate error.  The
671    serial number is returned as a hexstring. */
672 int
673 agent_card_serialno (ctrl_t ctrl, char **r_serialno)
674 {
675   int rc;
676   char *serialno = NULL;
677
678   rc = start_scd (ctrl);
679   if (rc)
680     return rc;
681
682   rc = assuan_transact (ctrl->scd_local->ctx, "SERIALNO",
683                         NULL, NULL, NULL, NULL,
684                         get_serialno_cb, &serialno);
685   if (rc)
686     {
687       xfree (serialno);
688       return unlock_scd (ctrl, rc);
689     }
690   *r_serialno = serialno;
691   return unlock_scd (ctrl, 0);
692 }
693
694
695
696 \f
697 static int
698 membuf_data_cb (void *opaque, const void *buffer, size_t length)
699 {
700   membuf_t *data = opaque;
701
702   if (buffer)
703     put_membuf (data, buffer, length);
704   return 0;
705 }
706   
707 /* Handle the NEEDPIN inquiry. */
708 static int
709 inq_needpin (void *opaque, const char *line)
710 {
711   struct inq_needpin_s *parm = opaque;
712   char *pin;
713   size_t pinlen;
714   int rc;
715
716   if (!strncmp (line, "NEEDPIN", 7) && (line[7] == ' ' || !line[7]))
717     {
718       line += 7;
719       while (*line == ' ')
720         line++;
721       
722       pinlen = 90;
723       pin = gcry_malloc_secure (pinlen);
724       if (!pin)
725         return out_of_core ();
726
727       rc = parm->getpin_cb (parm->getpin_cb_arg, line, pin, pinlen);
728       if (!rc)
729         rc = assuan_send_data (parm->ctx, pin, pinlen);
730       xfree (pin);
731     }
732   else if (!strncmp (line, "POPUPKEYPADPROMPT", 17)
733            && (line[17] == ' ' || !line[17]))
734     {
735       line += 17;
736       while (*line == ' ')
737         line++;
738       
739       rc = parm->getpin_cb (parm->getpin_cb_arg, line, NULL, 1);
740     }
741   else if (!strncmp (line, "DISMISSKEYPADPROMPT", 19)
742            && (line[19] == ' ' || !line[19]))
743     {
744       rc = parm->getpin_cb (parm->getpin_cb_arg, "", NULL, 0);
745     }
746   else if (parm->passthru)
747     {
748       unsigned char *value;
749       size_t valuelen;
750       int rest;
751       int needrest = !strncmp (line, "KEYDATA", 8);
752
753       /* Pass the inquiry up to our caller.  We limit the maximum
754          amount to an arbitrary value.  As we know that the KEYDATA
755          enquiry is pretty sensitive we disable logging then */
756       if ((rest = (needrest
757                    && !assuan_get_flag (parm->passthru, ASSUAN_CONFIDENTIAL))))
758         assuan_begin_confidential (parm->passthru);
759       rc = assuan_inquire (parm->passthru, line, &value, &valuelen, 8096);
760       if (rest)
761         assuan_end_confidential (parm->passthru);
762       if (!rc)
763         {
764           if ((rest = (needrest 
765                        && !assuan_get_flag (parm->ctx, ASSUAN_CONFIDENTIAL))))
766             assuan_begin_confidential (parm->ctx);
767           rc = assuan_send_data (parm->ctx, value, valuelen);
768           if (rest)
769             assuan_end_confidential (parm->ctx);
770           xfree (value);
771         }
772       else
773         log_error ("error forwarding inquiry `%s': %s\n", 
774                    line, gpg_strerror (rc));
775     }
776   else
777     {
778       log_error ("unsupported inquiry `%s'\n", line);
779       rc = gpg_error (GPG_ERR_ASS_UNKNOWN_INQUIRE);
780     }
781
782   return rc;
783 }
784
785
786
787 /* Create a signature using the current card */
788 int
789 agent_card_pksign (ctrl_t ctrl,
790                    const char *keyid,
791                    int (*getpin_cb)(void *, const char *, char*, size_t),
792                    void *getpin_cb_arg,
793                    const unsigned char *indata, size_t indatalen,
794                    unsigned char **r_buf, size_t *r_buflen)
795 {
796   int rc, i;
797   char *p, line[ASSUAN_LINELENGTH];
798   membuf_t data;
799   struct inq_needpin_s inqparm;
800   size_t len;
801   unsigned char *sigbuf;
802   size_t sigbuflen;
803
804   *r_buf = NULL;
805   rc = start_scd (ctrl);
806   if (rc)
807     return rc;
808
809   if (indatalen*2 + 50 > DIM(line))
810     return unlock_scd (ctrl, gpg_error (GPG_ERR_GENERAL));
811
812   sprintf (line, "SETDATA ");
813   p = line + strlen (line);
814   for (i=0; i < indatalen ; i++, p += 2 )
815     sprintf (p, "%02X", indata[i]);
816   rc = assuan_transact (ctrl->scd_local->ctx, line,
817                         NULL, NULL, NULL, NULL, NULL, NULL);
818   if (rc)
819     return unlock_scd (ctrl, rc);
820
821   init_membuf (&data, 1024);
822   inqparm.ctx = ctrl->scd_local->ctx;
823   inqparm.getpin_cb = getpin_cb;
824   inqparm.getpin_cb_arg = getpin_cb_arg;
825   inqparm.passthru = 0;
826   snprintf (line, DIM(line)-1, 
827             ctrl->use_auth_call? "PKAUTH %s":"PKSIGN %s", keyid);
828   line[DIM(line)-1] = 0;
829   rc = assuan_transact (ctrl->scd_local->ctx, line,
830                         membuf_data_cb, &data,
831                         inq_needpin, &inqparm,
832                         NULL, NULL);
833   if (rc)
834     {
835       xfree (get_membuf (&data, &len));
836       return unlock_scd (ctrl, rc);
837     }
838   sigbuf = get_membuf (&data, &sigbuflen);
839
840   /* Create an S-expression from it which is formatted like this:
841      "(7:sig-val(3:rsa(1:sSIGBUFLEN:SIGBUF)))" */
842   *r_buflen = 21 + 11 + sigbuflen + 4;
843   p = xtrymalloc (*r_buflen);
844   *r_buf = (unsigned char*)p;
845   if (!p)
846     return unlock_scd (ctrl, out_of_core ());
847   p = stpcpy (p, "(7:sig-val(3:rsa(1:s" );
848   sprintf (p, "%u:", (unsigned int)sigbuflen);
849   p += strlen (p);
850   memcpy (p, sigbuf, sigbuflen);
851   p += sigbuflen;
852   strcpy (p, ")))");
853   xfree (sigbuf);
854
855   assert (gcry_sexp_canon_len (*r_buf, *r_buflen, NULL, NULL));
856   return unlock_scd (ctrl, 0);
857 }
858
859 /* Decipher INDATA using the current card. Note that the returned value is */
860 int
861 agent_card_pkdecrypt (ctrl_t ctrl,
862                       const char *keyid,
863                       int (*getpin_cb)(void *, const char *, char*, size_t),
864                       void *getpin_cb_arg,
865                       const unsigned char *indata, size_t indatalen,
866                       char **r_buf, size_t *r_buflen)
867 {
868   int rc, i;
869   char *p, line[ASSUAN_LINELENGTH];
870   membuf_t data;
871   struct inq_needpin_s inqparm;
872   size_t len;
873
874   *r_buf = NULL;
875   rc = start_scd (ctrl);
876   if (rc)
877     return rc;
878
879   /* FIXME: use secure memory where appropriate */
880   if (indatalen*2 + 50 > DIM(line))
881     return unlock_scd (ctrl, gpg_error (GPG_ERR_GENERAL));
882
883   sprintf (line, "SETDATA ");
884   p = line + strlen (line);
885   for (i=0; i < indatalen ; i++, p += 2 )
886     sprintf (p, "%02X", indata[i]);
887   rc = assuan_transact (ctrl->scd_local->ctx, line,
888                         NULL, NULL, NULL, NULL, NULL, NULL);
889   if (rc)
890     return unlock_scd (ctrl, rc);
891
892   init_membuf (&data, 1024);
893   inqparm.ctx = ctrl->scd_local->ctx;
894   inqparm.getpin_cb = getpin_cb;
895   inqparm.getpin_cb_arg = getpin_cb_arg;
896   inqparm.passthru = 0;
897   snprintf (line, DIM(line)-1, "PKDECRYPT %s", keyid);
898   line[DIM(line)-1] = 0;
899   rc = assuan_transact (ctrl->scd_local->ctx, line,
900                         membuf_data_cb, &data,
901                         inq_needpin, &inqparm,
902                         NULL, NULL);
903   if (rc)
904     {
905       xfree (get_membuf (&data, &len));
906       return unlock_scd (ctrl, rc);
907     }
908   *r_buf = get_membuf (&data, r_buflen);
909   if (!*r_buf)
910     return unlock_scd (ctrl, gpg_error (GPG_ERR_ENOMEM));
911
912   return unlock_scd (ctrl, 0);
913 }
914
915
916 \f
917 /* Read a certificate with ID into R_BUF and R_BUFLEN. */
918 int
919 agent_card_readcert (ctrl_t ctrl,
920                      const char *id, char **r_buf, size_t *r_buflen)
921 {
922   int rc;
923   char line[ASSUAN_LINELENGTH];
924   membuf_t data;
925   size_t len;
926
927   *r_buf = NULL;
928   rc = start_scd (ctrl);
929   if (rc)
930     return rc;
931
932   init_membuf (&data, 1024);
933   snprintf (line, DIM(line)-1, "READCERT %s", id);
934   line[DIM(line)-1] = 0;
935   rc = assuan_transact (ctrl->scd_local->ctx, line,
936                         membuf_data_cb, &data,
937                         NULL, NULL,
938                         NULL, NULL);
939   if (rc)
940     {
941       xfree (get_membuf (&data, &len));
942       return unlock_scd (ctrl, rc);
943     }
944   *r_buf = get_membuf (&data, r_buflen);
945   if (!*r_buf)
946     return unlock_scd (ctrl, gpg_error (GPG_ERR_ENOMEM));
947
948   return unlock_scd (ctrl, 0);
949 }
950
951
952 \f
953 /* Read a key with ID and return it in an allocate buffer pointed to
954    by r_BUF as a valid S-expression. */
955 int
956 agent_card_readkey (ctrl_t ctrl, const char *id, unsigned char **r_buf)
957 {
958   int rc;
959   char line[ASSUAN_LINELENGTH];
960   membuf_t data;
961   size_t len, buflen;
962
963   *r_buf = NULL;
964   rc = start_scd (ctrl);
965   if (rc)
966     return rc;
967
968   init_membuf (&data, 1024);
969   snprintf (line, DIM(line)-1, "READKEY %s", id);
970   line[DIM(line)-1] = 0;
971   rc = assuan_transact (ctrl->scd_local->ctx, line,
972                         membuf_data_cb, &data,
973                         NULL, NULL,
974                         NULL, NULL);
975   if (rc)
976     {
977       xfree (get_membuf (&data, &len));
978       return unlock_scd (ctrl, rc);
979     }
980   *r_buf = get_membuf (&data, &buflen);
981   if (!*r_buf)
982     return unlock_scd (ctrl, gpg_error (GPG_ERR_ENOMEM));
983
984   if (!gcry_sexp_canon_len (*r_buf, buflen, NULL, NULL))
985     {
986       xfree (*r_buf); *r_buf = NULL;
987       return unlock_scd (ctrl, gpg_error (GPG_ERR_INV_VALUE));
988     }
989
990   return unlock_scd (ctrl, 0);
991 }
992
993
994 \f
995 /* Type used with the card_getattr_cb.  */
996 struct card_getattr_parm_s {
997   const char *keyword;  /* Keyword to look for.  */
998   size_t keywordlen;    /* strlen of KEYWORD.  */
999   char *data;           /* Malloced and unescaped data.  */
1000   int error;            /* ERRNO value or 0 on success. */
1001 };
1002
1003 /* Callback function for agent_card_getattr.  */
1004 static assuan_error_t
1005 card_getattr_cb (void *opaque, const char *line)
1006 {
1007   struct card_getattr_parm_s *parm = opaque;
1008   const char *keyword = line;
1009   int keywordlen;
1010
1011   if (parm->data)
1012     return 0; /* We want only the first occurrence.  */
1013
1014   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
1015     ;
1016   while (spacep (line))
1017     line++;
1018
1019   if (keywordlen == parm->keywordlen
1020       && !memcmp (keyword, parm->keyword, keywordlen))
1021     {
1022       parm->data = unescape_status_string ((const unsigned char*)line);
1023       if (!parm->data)
1024         parm->error = errno;
1025     }
1026   
1027   return 0;
1028 }
1029
1030
1031 /* Call the agent to retrieve a single line data object. On success
1032    the object is malloced and stored at RESULT; it is guaranteed that
1033    NULL is never stored in this case.  On error an error code is
1034    returned and NULL stored at RESULT. */
1035 gpg_error_t
1036 agent_card_getattr (ctrl_t ctrl, const char *name, char **result)
1037 {
1038   int err;
1039   struct card_getattr_parm_s parm;
1040   char line[ASSUAN_LINELENGTH];
1041
1042   *result = NULL;
1043
1044   if (!*name)
1045     return gpg_error (GPG_ERR_INV_VALUE);
1046
1047   memset (&parm, 0, sizeof parm);
1048   parm.keyword = name;
1049   parm.keywordlen = strlen (name);
1050
1051   /* We assume that NAME does not need escaping. */
1052   if (8 + strlen (name) > DIM(line)-1)
1053     return gpg_error (GPG_ERR_TOO_LARGE);
1054   stpcpy (stpcpy (line, "GETATTR "), name); 
1055
1056   err = start_scd (ctrl);
1057   if (err)
1058     return err;
1059
1060   err = assuan_transact (ctrl->scd_local->ctx, line,
1061                          NULL, NULL, NULL, NULL,
1062                          card_getattr_cb, &parm);
1063   if (!err && parm.error)
1064     err = gpg_error_from_errno (parm.error);
1065   
1066   if (!err && !parm.data)
1067     err = gpg_error (GPG_ERR_NO_DATA);
1068   
1069   if (!err)
1070     *result = parm.data;
1071   else
1072     xfree (parm.data);
1073
1074   return unlock_scd (ctrl, err);
1075 }
1076
1077
1078
1079 \f
1080 static int
1081 pass_status_thru (void *opaque, const char *line)
1082 {
1083   assuan_context_t ctx = opaque;
1084   char keyword[200];
1085   int i;
1086
1087   for (i=0; *line && !spacep (line) && i < DIM(keyword)-1; line++, i++)
1088     keyword[i] = *line;
1089   keyword[i] = 0;
1090   /* truncate any remaining keyword stuff. */
1091   for (; *line && !spacep (line); line++)
1092     ;
1093   while (spacep (line))
1094     line++;
1095
1096   assuan_write_status (ctx, keyword, line);
1097   return 0;
1098 }
1099
1100 static int
1101 pass_data_thru (void *opaque, const void *buffer, size_t length)
1102 {
1103   assuan_context_t ctx = opaque;
1104
1105   assuan_send_data (ctx, buffer, length);
1106   return 0;
1107 }
1108
1109
1110 /* Send the line CMDLINE with command for the SCDdaemon to it and send
1111    all status messages back.  This command is used as a general quoting
1112    mechanism to pass everything verbatim to SCDAEMON.  The PIN
1113    inquiry is handled inside gpg-agent.  */
1114 int
1115 agent_card_scd (ctrl_t ctrl, const char *cmdline,
1116                 int (*getpin_cb)(void *, const char *, char*, size_t),
1117                 void *getpin_cb_arg, void *assuan_context)
1118 {
1119   int rc;
1120   struct inq_needpin_s inqparm;
1121
1122   rc = start_scd (ctrl);
1123   if (rc)
1124     return rc;
1125
1126   inqparm.ctx = ctrl->scd_local->ctx;
1127   inqparm.getpin_cb = getpin_cb;
1128   inqparm.getpin_cb_arg = getpin_cb_arg;
1129   inqparm.passthru = assuan_context;
1130   rc = assuan_transact (ctrl->scd_local->ctx, cmdline,
1131                         pass_data_thru, assuan_context,
1132                         inq_needpin, &inqparm,
1133                         pass_status_thru, assuan_context);
1134   if (rc)
1135     {
1136       return unlock_scd (ctrl, rc);
1137     }
1138
1139   return unlock_scd (ctrl, 0);
1140 }
1141
1142