Fixed the card removed with cached app bug. (Famous last fix).
[gnupg.git] / scd / command.c
1 /* command.c - SCdaemon command handler
2  * Copyright (C) 2001, 2002, 2003, 2004, 2005,
3  *               2007, 2008  Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <errno.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <ctype.h>
27 #include <unistd.h>
28 #include <signal.h>
29 #ifdef USE_GNU_PTH
30 # include <pth.h>
31 #endif
32
33 #include <assuan.h>
34
35 #include "scdaemon.h"
36 #include <ksba.h>
37 #include "app-common.h"
38 #include "apdu.h" /* Required for apdu_*_reader (). */
39 #include "exechelp.h"
40 #ifdef HAVE_LIBUSB
41 #include "ccid-driver.h"
42 #endif
43
44 /* Maximum length allowed as a PIN; used for INQUIRE NEEDPIN */
45 #define MAXLEN_PIN 100
46
47 /* Maximum allowed size of key data as used in inquiries. */
48 #define MAXLEN_KEYDATA 4096
49
50 /* Maximum allowed size of certificate data as used in inquiries. */
51 #define MAXLEN_CERTDATA 16384
52
53
54 #define set_error(e,t) assuan_set_error (ctx, gpg_error (e), (t))
55
56
57 /* Macro to flag a removed card.  */
58 #define TEST_CARD_REMOVAL(c,r)                              \
59        do {                                                 \
60           int _r = (r);                                     \
61           if (gpg_err_code (_r) == GPG_ERR_CARD_NOT_PRESENT \
62               || gpg_err_code (_r) == GPG_ERR_CARD_REMOVED) \
63             update_card_removed ((c)->reader_slot, 1);      \
64        } while (0)
65
66 #define IS_LOCKED(c)                                                     \
67      (locked_session && locked_session != (c)->server_local              \
68       && (c)->reader_slot != -1 && locked_session->ctrl_backlink         \
69       && (c)->reader_slot == locked_session->ctrl_backlink->reader_slot)
70
71
72 /* This structure is used to keep track of open readers (slots). */
73 struct slot_status_s 
74 {
75   int valid;  /* True if the other objects are valid. */
76   int slot;   /* Slot number of the reader or -1 if not open. */
77
78   int reset_failed; /* A reset failed. */
79
80   int any;    /* Flag indicating whether any status check has been
81                  done.  This is set once to indicate that the status
82                  tracking for the slot has been initialized.  */
83   unsigned int status;  /* Last status of the slot. */
84   unsigned int changed; /* Last change counter of the slot. */
85 };
86
87
88 /* Data used to associate an Assuan context with local server data.
89    This object describes the local properties of one session.  */
90 struct server_local_s 
91 {
92   /* We keep a list of all active sessions with the anchor at
93      SESSION_LIST (see below).  This field is used for linking. */
94   struct server_local_s *next_session; 
95
96   /* This object is usually assigned to a CTRL object (which is
97      globally visible).  While enumerating all sessions we sometimes
98      need to access data of the CTRL object; thus we keep a
99      backpointer here. */
100   ctrl_t ctrl_backlink;
101
102   /* The Assuan context used by this session/server. */
103   assuan_context_t assuan_ctx;
104
105 #ifdef HAVE_W32_SYSTEM
106   unsigned long event_signal;   /* Or 0 if not used. */
107 #else
108   int event_signal;             /* Or 0 if not used. */
109 #endif
110   
111   /* True if the card has been removed and a reset is required to
112      continue operation. */
113   int card_removed;        
114 };
115
116
117 /* The table with information on all used slots.  FIXME: This is a
118    different slot number than the one used by the APDU layer, and
119    should be renamed.  */
120 static struct slot_status_s slot_table[10];
121
122
123 /* To keep track of all running sessions, we link all active server
124    contexts and the anchor in this variable.  */
125 static struct server_local_s *session_list;
126
127 /* If a session has been locked we store a link to its server object
128    in this variable. */
129 static struct server_local_s *locked_session;
130
131 /* While doing a reset we need to make sure that the ticker does not
132    call scd_update_reader_status_file while we are using it. */
133 static pth_mutex_t status_file_update_lock;
134
135 \f
136 /*-- Local prototypes --*/
137 static void update_reader_status_file (int set_card_removed_flag);
138
139
140 \f
141
142 /* This function must be called once to initialize this module.  This
143    has to be done before a second thread is spawned.  We can't do the
144    static initialization because Pth emulation code might not be able
145    to do a static init; in particular, it is not possible for W32. */
146 void
147 initialize_module_command (void)
148 {
149   static int initialized;
150
151   if (!initialized)
152     {
153       if (pth_mutex_init (&status_file_update_lock))
154         initialized = 1;
155     }
156 }
157
158
159 /* Update the CARD_REMOVED element of all sessions using the reader
160    given by SLOT to VALUE  */
161 static void
162 update_card_removed (int slot, int value)
163 {
164   struct server_local_s *sl;
165
166   for (sl=session_list; sl; sl = sl->next_session)
167     if (sl->ctrl_backlink
168         && sl->ctrl_backlink->reader_slot == slot)
169       {
170         sl->card_removed = value;
171       }
172   /* Let the card application layer know about the removal.  */
173   if (value)
174     application_notify_card_reset (slot);
175 }
176
177
178
179 /* Check whether the option NAME appears in LINE */
180 static int
181 has_option (const char *line, const char *name)
182 {
183   const char *s;
184   int n = strlen (name);
185
186   s = strstr (line, name);
187   return (s && (s == line || spacep (s-1)) && (!s[n] || spacep (s+n)));
188 }
189
190 /* Same as has_option but does only test for the name of the option
191    and ignores an argument, i.e. with NAME being "--hash" it would
192    return a pointer for "--hash" as well as for "--hash=foo".  If
193    thhere is no such option NULL is returned.  The pointer returned
194    points right behind the option name, this may be an equal sign, Nul
195    or a space.  */
196 static const char *
197 has_option_name (const char *line, const char *name)
198 {
199   const char *s;
200   int n = strlen (name);
201
202   s = strstr (line, name);
203   return (s && (s == line || spacep (s-1))
204           && (!s[n] || spacep (s+n) || s[n] == '=')) ? (s+n) : NULL;
205 }
206
207
208 /* Skip over options.  It is assumed that leading spaces have been
209    removed (this is the case for lines passed to a handler from
210    assuan).  Blanks after the options are also removed. */
211 static char *
212 skip_options (char *line)
213 {
214   while ( *line == '-' && line[1] == '-' )
215     {
216       while (*line && !spacep (line))
217         line++;
218       while (spacep (line))
219         line++;
220     }
221   return line;
222 }
223
224
225
226 /* Convert the STRING into a newly allocated buffer while translating
227    the hex numbers.  Stops at the first invalid character.  Blanks and
228    colons are allowed to separate the hex digits.  Returns NULL on
229    error or a newly malloced buffer and its length in LENGTH.  */
230 static unsigned char *
231 hex_to_buffer (const char *string, size_t *r_length)
232 {
233   unsigned char *buffer;
234   const char *s;
235   size_t n;
236
237   buffer = xtrymalloc (strlen (string)+1);
238   if (!buffer)
239     return NULL;
240   for (s=string, n=0; *s; s++)
241     {
242       if (spacep (s) || *s == ':') 
243         continue;
244       if (hexdigitp (s) && hexdigitp (s+1))
245         {
246           buffer[n++] = xtoi_2 (s);
247           s++;
248         }
249       else
250         break;
251     }
252   *r_length = n;
253   return buffer;
254 }
255
256
257
258 /* Reset the card and free the application context.  With SEND_RESET
259    set to true actually send a RESET to the reader; this is the normal
260    way of calling the function.  */
261 static void
262 do_reset (ctrl_t ctrl, int send_reset)
263 {
264   int slot = ctrl->reader_slot;
265
266   if (!(slot == -1 || (slot >= 0 && slot < DIM(slot_table))))
267     BUG ();
268
269   /* If there is an active application, release it. */
270   if (ctrl->app_ctx)
271     {
272       release_application (ctrl->app_ctx);
273       ctrl->app_ctx = NULL;
274     }
275
276   /* If we want a real reset for the card, send the reset APDU and
277      tell the application layer about it.  */
278   if (slot != -1 && send_reset && !IS_LOCKED (ctrl) )
279     {
280       if (apdu_reset (slot)) 
281         {
282           slot_table[slot].reset_failed = 1;
283         }
284       application_notify_card_reset (slot);
285     }
286
287   /* If we hold a lock, unlock now. */
288   if (locked_session && ctrl->server_local == locked_session)
289     {
290       locked_session = NULL;
291       log_info ("implicitly unlocking due to RESET\n");
292     }
293
294   /* Reset the card removed flag for the current reader.  We need to
295      take the lock here so that the ticker thread won't concurrently
296      try to update the file.  Calling update_reader_status_file is
297      required to get hold of the new status of the card in the slot
298      table.  */
299   if (!pth_mutex_acquire (&status_file_update_lock, 0, NULL))
300     {
301       log_error ("failed to acquire status_fle_update lock\n");
302       ctrl->reader_slot = -1;
303       return;
304     }
305   update_reader_status_file (0);  /* Update slot status table.  */
306   update_card_removed (slot, 0);  /* Clear card_removed flag.  */
307   if (!pth_mutex_release (&status_file_update_lock))
308     log_error ("failed to release status_file_update lock\n");
309
310   /* Do this last, so that the update_card_removed above does its job.  */
311   ctrl->reader_slot = -1;
312 }
313
314 \f
315 static void
316 reset_notify (assuan_context_t ctx)
317 {
318   ctrl_t ctrl = assuan_get_pointer (ctx); 
319
320   do_reset (ctrl, 1);
321 }
322
323
324 static int
325 option_handler (assuan_context_t ctx, const char *key, const char *value)
326 {
327   ctrl_t ctrl = assuan_get_pointer (ctx);
328
329   if (!strcmp (key, "event-signal"))
330     {
331       /* A value of 0 is allowed to reset the event signal. */
332 #ifdef HAVE_W32_SYSTEM
333       if (!*value)
334         return gpg_error (GPG_ERR_ASS_PARAMETER);
335       ctrl->server_local->event_signal = strtoul (value, NULL, 16);
336 #else
337       int i = *value? atoi (value) : -1;
338       if (i < 0)
339         return gpg_error (GPG_ERR_ASS_PARAMETER);
340       ctrl->server_local->event_signal = i;
341 #endif
342     }
343
344  return 0;
345 }
346
347
348 /* Return the slot of the current reader or open the reader if no
349    other sessions are using a reader.  Note, that we currently support
350    only one reader but most of the code (except for this function)
351    should be able to cope with several readers.  */
352 static int
353 get_reader_slot (void)
354 {
355   struct slot_status_s *ss;
356
357   ss = &slot_table[0]; /* One reader for now. */
358
359   /* Initialize the item if needed. */
360   if (!ss->valid)
361     {
362       ss->slot = -1;
363       ss->valid = 1;
364     }
365
366   /* Try to open the reader. */
367   if (ss->slot == -1)
368     ss->slot = apdu_open_reader (opt.reader_port);
369
370   /* Return the slot_table index.  */
371   return 0;
372 }
373
374 /* If the card has not yet been opened, do it.  Note that this
375    function returns an Assuan error, so don't map the error a second
376    time.  */
377 static assuan_error_t
378 open_card (ctrl_t ctrl, const char *apptype)
379 {
380   gpg_error_t err;
381   int slot;
382
383   /* If we ever got a card not present error code, return that.  Only
384      the SERIALNO command and a reset are able to clear from that
385      state. */
386   if (ctrl->server_local->card_removed)
387     return gpg_error (GPG_ERR_CARD_REMOVED);
388
389   if ( IS_LOCKED (ctrl) )
390     return gpg_error (GPG_ERR_LOCKED);
391
392   if (ctrl->app_ctx)
393     {
394       /* Already initialized for one specific application.  Need to
395          check that the client didn't requested a specific application
396          different from the one in use. */
397       return check_application_conflict (ctrl, apptype);
398     }
399
400   if (ctrl->reader_slot != -1)
401     slot = ctrl->reader_slot;
402   else
403     slot = get_reader_slot ();
404   ctrl->reader_slot = slot;
405   if (slot == -1)
406     err = gpg_error (GPG_ERR_CARD);
407   else
408     {
409       /* Fixme: We should move the apdu_connect call to
410          select_application.  */
411       int sw = apdu_connect (slot);
412       if (sw && sw != SW_HOST_ALREADY_CONNECTED)
413         {
414           if (sw == SW_HOST_NO_CARD)
415             err = gpg_error (GPG_ERR_CARD_NOT_PRESENT);
416           else
417             err = gpg_error (GPG_ERR_CARD);
418         }
419       else
420         err = select_application (ctrl, slot, apptype, &ctrl->app_ctx);
421     }
422
423   TEST_CARD_REMOVAL (ctrl, err);
424   return err;
425 }
426
427
428 /* Do the percent and plus/space unescaping in place and return the
429    length of the valid buffer. */
430 static size_t
431 percent_plus_unescape (unsigned char *string)
432 {
433   unsigned char *p = string;
434   size_t n = 0;
435
436   while (*string)
437     {
438       if (*string == '%' && string[1] && string[2])
439         { 
440           string++;
441           *p++ = xtoi_2 (string);
442           n++;
443           string+= 2;
444         }
445       else if (*string == '+')
446         {
447           *p++ = ' ';
448           n++;
449           string++;
450         }
451       else
452         {
453           *p++ = *string++;
454           n++;
455         }
456     }
457
458   return n;
459 }
460
461
462
463 /* SERIALNO [APPTYPE] 
464
465    Return the serial number of the card using a status reponse.  This
466    functon should be used to check for the presence of a card.
467
468    If APPTYPE is given, an application of that type is selected and an
469    error is returned if the application is not supported or available.
470    The default is to auto-select the application using a hardwired
471    preference system.  Note, that a future extension to this function
472    may allow to specify a list and order of applications to try.
473
474    This function is special in that it can be used to reset the card.
475    Most other functions will return an error when a card change has
476    been detected and the use of this function is therefore required.
477
478    Background: We want to keep the client clear of handling card
479    changes between operations; i.e. the client can assume that all
480    operations are done on the same card unless he calls this function.
481  */
482 static int
483 cmd_serialno (assuan_context_t ctx, char *line)
484 {
485   ctrl_t ctrl = assuan_get_pointer (ctx);
486   int rc = 0;
487   char *serial_and_stamp;
488   char *serial;
489   time_t stamp;
490
491   /* Clear the remove flag so that the open_card is able to reread it.  */
492   if (ctrl->server_local->card_removed)
493     {
494       if ( IS_LOCKED (ctrl) )
495         return gpg_error (GPG_ERR_LOCKED);
496       do_reset (ctrl, 1);
497     }
498
499   if ((rc = open_card (ctrl, *line? line:NULL)))
500     return rc;
501
502   rc = app_get_serial_and_stamp (ctrl->app_ctx, &serial, &stamp);
503   if (rc)
504     return rc;
505
506   rc = estream_asprintf (&serial_and_stamp, "%s %lu",
507                          serial, (unsigned long)stamp);
508   xfree (serial);
509   if (rc < 0)
510     return out_of_core ();
511   rc = 0;
512   assuan_write_status (ctx, "SERIALNO", serial_and_stamp);
513   xfree (serial_and_stamp);
514   return 0;
515 }
516
517
518
519
520 /* LEARN [--force]
521
522    Learn all useful information of the currently inserted card.  When
523    used without the force options, the command might do an INQUIRE
524    like this:
525
526       INQUIRE KNOWNCARDP <hexstring_with_serialNumber> <timestamp>
527
528    The client should just send an "END" if the processing should go on
529    or a "CANCEL" to force the function to terminate with a Cancel
530    error message.  The response of this command is a list of status
531    lines formatted as this:
532
533      S APPTYPE <apptype>
534
535    This returns the type of the application, currently the strings:
536
537        P15     = PKCS-15 structure used
538        DINSIG  = DIN SIG
539        OPENPGP = OpenPGP card
540  
541    are implemented.  These strings are aliases for the AID
542
543      S KEYPAIRINFO <hexstring_with_keygrip> <hexstring_with_id>
544
545    If there is no certificate yet stored on the card a single "X" is
546    returned as the keygrip.  In addition to the keypair info, information
547    about all certificates stored on the card is also returned:
548
549      S CERTINFO <certtype> <hexstring_with_id>
550
551    Where CERTTYPE is a number indicating the type of certificate:
552       0   := Unknown
553       100 := Regular X.509 cert
554       101 := Trusted X.509 cert
555       102 := Useful X.509 cert
556       110 := Root CA cert (DINSIG)
557
558    For certain cards, more information will be returned:
559
560      S KEY-FPR <no> <hexstring>
561
562    For OpenPGP cards this returns the stored fingerprints of the
563    keys. This can be used check whether a key is available on the
564    card.  NO may be 1, 2 or 3.
565
566      S CA-FPR <no> <hexstring>
567
568    Similar to above, these are the fingerprints of keys assumed to be
569    ultimately trusted.
570
571      S DISP-NAME <name_of_card_holder>
572
573    The name of the card holder as stored on the card; percent
574    escaping takes place, spaces are encoded as '+'
575
576      S PUBKEY-URL <url>
577
578    The URL to be used for locating the entire public key.
579      
580    Note, that this function may be even be used on a locked card.
581 */
582 static int
583 cmd_learn (assuan_context_t ctx, char *line)
584 {
585   ctrl_t ctrl = assuan_get_pointer (ctx);
586   int rc = 0;
587
588   if ((rc = open_card (ctrl, NULL)))
589     return rc;
590
591   /* Unless the force option is used we try a shortcut by identifying
592      the card using a serial number and inquiring the client with
593      that. The client may choose to cancel the operation if he already
594      knows about this card */
595   {
596     char *serial_and_stamp;
597     char *serial;
598     time_t stamp;
599
600     rc = app_get_serial_and_stamp (ctrl->app_ctx, &serial, &stamp);
601     if (rc)
602       return rc;
603     rc = estream_asprintf (&serial_and_stamp, "%s %lu", serial, (unsigned long)stamp);
604     xfree (serial);
605     if (rc < 0)
606       return out_of_core ();
607     rc = 0;
608     assuan_write_status (ctx, "SERIALNO", serial_and_stamp);
609
610     if (!has_option (line, "--force"))
611       {
612         char *command;
613
614         rc = estream_asprintf (&command, "KNOWNCARDP %s", serial_and_stamp);
615         if (rc < 0)
616           {
617             xfree (serial_and_stamp);
618             return out_of_core ();
619           }
620         rc = 0;
621         rc = assuan_inquire (ctx, command, NULL, NULL, 0); 
622         xfree (command);
623         if (rc)
624           {
625             if (gpg_err_code (rc) != GPG_ERR_ASS_CANCELED)
626               log_error ("inquire KNOWNCARDP failed: %s\n",
627                          gpg_strerror (rc));
628             xfree (serial_and_stamp);
629             return rc; 
630           }
631         /* not canceled, so we have to proceeed */
632       }
633     xfree (serial_and_stamp);
634   }
635
636   /* Let the application print out its collection of useful status
637      information. */
638   if (!rc)
639     rc = app_write_learn_status (ctrl->app_ctx, ctrl);
640
641   TEST_CARD_REMOVAL (ctrl, rc);
642   return rc;
643 }
644
645
646 \f
647 /* READCERT <hexified_certid>|<keyid>
648
649    Note, that this function may even be used on a locked card.
650  */
651 static int
652 cmd_readcert (assuan_context_t ctx, char *line)
653 {
654   ctrl_t ctrl = assuan_get_pointer (ctx);
655   int rc;
656   unsigned char *cert;
657   size_t ncert;
658
659   if ((rc = open_card (ctrl, NULL)))
660     return rc;
661
662   line = xstrdup (line); /* Need a copy of the line. */
663   rc = app_readcert (ctrl->app_ctx, line, &cert, &ncert);
664   if (rc)
665     log_error ("app_readcert failed: %s\n", gpg_strerror (rc));
666   xfree (line);
667   line = NULL;
668   if (!rc)
669     {
670       rc = assuan_send_data (ctx, cert, ncert);
671       xfree (cert);
672       if (rc)
673         return rc;
674     }
675
676   TEST_CARD_REMOVAL (ctrl, rc);
677   return rc;
678 }
679
680
681 /* READKEY <keyid>
682
683    Return the public key for the given cert or key ID as an standard
684    S-Expression.
685
686    Note, that this function may even be used on a locked card.
687   */
688 static int
689 cmd_readkey (assuan_context_t ctx, char *line)
690 {
691   ctrl_t ctrl = assuan_get_pointer (ctx);
692   int rc;
693   unsigned char *cert = NULL;
694   size_t ncert, n;
695   ksba_cert_t kc = NULL;
696   ksba_sexp_t p;
697   unsigned char *pk;
698   size_t pklen;
699
700   if ((rc = open_card (ctrl, NULL)))
701     return rc;
702
703   line = xstrdup (line); /* Need a copy of the line. */
704   /* If the application supports the READKEY function we use that.
705      Otherwise we use the old way by extracting it from the
706      certificate.  */
707   rc = app_readkey (ctrl->app_ctx, line, &pk, &pklen);
708   if (!rc)
709     { /* Yeah, got that key - send it back.  */
710       rc = assuan_send_data (ctx, pk, pklen);
711       xfree (pk);
712       xfree (line);
713       line = NULL;
714       goto leave;
715     }
716
717   if (gpg_err_code (rc) != GPG_ERR_UNSUPPORTED_OPERATION)
718     log_error ("app_readkey failed: %s\n", gpg_strerror (rc));
719   else  
720     {
721       rc = app_readcert (ctrl->app_ctx, line, &cert, &ncert);
722       if (rc)
723         log_error ("app_readcert failed: %s\n", gpg_strerror (rc));
724     }
725   xfree (line);
726   line = NULL;
727   if (rc)
728     goto leave;
729       
730   rc = ksba_cert_new (&kc);
731   if (rc)
732     {
733       xfree (cert);
734       goto leave;
735     }
736   rc = ksba_cert_init_from_mem (kc, cert, ncert);
737   if (rc)
738     {
739       log_error ("failed to parse the certificate: %s\n", gpg_strerror (rc));
740       goto leave;
741     }
742
743   p = ksba_cert_get_public_key (kc);
744   if (!p)
745     {
746       rc = gpg_error (GPG_ERR_NO_PUBKEY);
747       goto leave;
748     }
749
750   n = gcry_sexp_canon_len (p, 0, NULL, NULL);
751   rc = assuan_send_data (ctx, p, n);
752   xfree (p);
753
754
755  leave:
756   ksba_cert_release (kc);
757   xfree (cert);
758   TEST_CARD_REMOVAL (ctrl, rc);
759   return rc;
760 }
761
762
763 \f
764
765 /* SETDATA <hexstring> 
766
767    The client should use this command to tell us the data he want to
768    sign.  */
769 static int
770 cmd_setdata (assuan_context_t ctx, char *line)
771 {
772   ctrl_t ctrl = assuan_get_pointer (ctx);
773   int n;
774   char *p;
775   unsigned char *buf;
776
777   if (locked_session && locked_session != ctrl->server_local)
778     return gpg_error (GPG_ERR_LOCKED);
779
780   /* Parse the hexstring. */
781   for (p=line,n=0; hexdigitp (p); p++, n++)
782     ;
783   if (*p)
784     return set_error (GPG_ERR_ASS_PARAMETER, "invalid hexstring");
785   if (!n)
786     return set_error (GPG_ERR_ASS_PARAMETER, "no data given");
787   if ((n&1))
788     return set_error (GPG_ERR_ASS_PARAMETER, "odd number of digits");
789   n /= 2;
790   buf = xtrymalloc (n);
791   if (!buf)
792     return out_of_core ();
793
794   ctrl->in_data.value = buf;
795   ctrl->in_data.valuelen = n;
796   for (p=line, n=0; n < ctrl->in_data.valuelen; p += 2, n++)
797     buf[n] = xtoi_2 (p);
798   return 0;
799 }
800
801
802
803 static gpg_error_t 
804 pin_cb (void *opaque, const char *info, char **retstr)
805 {
806   assuan_context_t ctx = opaque;
807   char *command;
808   int rc;
809   unsigned char *value;
810   size_t valuelen;
811
812   if (!retstr)
813     {
814       /* We prompt for keypad entry.  To make sure that the popup has
815          been show we use an inquire and not just a status message.
816          We ignore any value returned.  */
817       if (info)
818         {
819           log_debug ("prompting for keypad entry '%s'\n", info);
820           rc = estream_asprintf (&command, "POPUPKEYPADPROMPT %s", info);
821           if (rc < 0)
822             return gpg_error (gpg_err_code_from_errno (errno));
823           rc = assuan_inquire (ctx, command, &value, &valuelen, MAXLEN_PIN); 
824           xfree (command);  
825         }
826       else
827         {
828           log_debug ("dismiss keypad entry prompt\n");
829           rc = assuan_inquire (ctx, "DISMISSKEYPADPROMPT",
830                                &value, &valuelen, MAXLEN_PIN); 
831         }
832       if (!rc)
833         xfree (value);
834       return rc;
835     }
836
837   *retstr = NULL;
838   log_debug ("asking for PIN '%s'\n", info);
839
840   rc = estream_asprintf (&command, "NEEDPIN %s", info);
841   if (rc < 0)
842     return gpg_error (gpg_err_code_from_errno (errno));
843
844   /* Fixme: Write an inquire function which returns the result in
845      secure memory and check all further handling of the PIN. */
846   rc = assuan_inquire (ctx, command, &value, &valuelen, MAXLEN_PIN); 
847   xfree (command);  
848   if (rc)
849     return rc;
850
851   if (!valuelen || value[valuelen-1])
852     {
853       /* We require that the returned value is an UTF-8 string */
854       xfree (value);
855       return gpg_error (GPG_ERR_INV_RESPONSE);
856     }
857   *retstr = (char*)value;
858   return 0;
859 }
860
861
862 /* PKSIGN [--hash=[rmd160|sha1|md5]] <hexified_id>
863
864    The --hash option is optional; the default is SHA1.
865
866  */
867 static int
868 cmd_pksign (assuan_context_t ctx, char *line)
869 {
870   ctrl_t ctrl = assuan_get_pointer (ctx);
871   int rc;
872   unsigned char *outdata;
873   size_t outdatalen;
874   char *keyidstr;
875   int hash_algo;
876
877   if (has_option (line, "--hash=rmd160"))
878     hash_algo = GCRY_MD_RMD160;
879   else if (has_option (line, "--hash=sha1"))
880     hash_algo = GCRY_MD_SHA1;
881   else if (has_option (line, "--hash=md5"))
882     hash_algo = GCRY_MD_MD5;
883   else if (!strstr (line, "--"))
884     hash_algo = GCRY_MD_SHA1; 
885   else
886     return set_error (GPG_ERR_ASS_PARAMETER, "invalid hash algorithm");
887
888   line = skip_options (line);
889
890   if ( IS_LOCKED (ctrl) )
891     return gpg_error (GPG_ERR_LOCKED);
892
893   if ((rc = open_card (ctrl, NULL)))
894     return rc;
895
896   /* We have to use a copy of the key ID because the function may use
897      the pin_cb which in turn uses the assuan line buffer and thus
898      overwriting the original line with the keyid */
899   keyidstr = xtrystrdup (line);
900   if (!keyidstr)
901     return out_of_core ();
902   
903   rc = app_sign (ctrl->app_ctx,
904                  keyidstr, hash_algo,
905                  pin_cb, ctx,
906                  ctrl->in_data.value, ctrl->in_data.valuelen,
907                  &outdata, &outdatalen);
908
909   xfree (keyidstr);
910   if (rc)
911     {
912       log_error ("card_sign failed: %s\n", gpg_strerror (rc));
913     }
914   else
915     {
916       rc = assuan_send_data (ctx, outdata, outdatalen);
917       xfree (outdata);
918       if (rc)
919         return rc; /* that is already an assuan error code */
920     }
921
922   TEST_CARD_REMOVAL (ctrl, rc);
923   return rc;
924 }
925
926 /* PKAUTH <hexified_id>
927
928  */
929 static int
930 cmd_pkauth (assuan_context_t ctx, char *line)
931 {
932   ctrl_t ctrl = assuan_get_pointer (ctx);
933   int rc;
934   unsigned char *outdata;
935   size_t outdatalen;
936   char *keyidstr;
937
938   if ( IS_LOCKED (ctrl) )
939     return gpg_error (GPG_ERR_LOCKED);
940
941   if ((rc = open_card (ctrl, NULL)))
942     return rc;
943
944   if (!ctrl->app_ctx)
945     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
946
947  /* We have to use a copy of the key ID because the function may use
948      the pin_cb which in turn uses the assuan line buffer and thus
949      overwriting the original line with the keyid */
950   keyidstr = xtrystrdup (line);
951   if (!keyidstr)
952     return out_of_core ();
953   
954   rc = app_auth (ctrl->app_ctx,
955                  keyidstr,
956                  pin_cb, ctx,
957                  ctrl->in_data.value, ctrl->in_data.valuelen,
958                  &outdata, &outdatalen);
959   xfree (keyidstr);
960   if (rc)
961     {
962       log_error ("app_auth_sign failed: %s\n", gpg_strerror (rc));
963     }
964   else
965     {
966       rc = assuan_send_data (ctx, outdata, outdatalen);
967       xfree (outdata);
968       if (rc)
969         return rc; /* that is already an assuan error code */
970     }
971
972   TEST_CARD_REMOVAL (ctrl, rc);
973   return rc;
974 }
975
976 /* PKDECRYPT <hexified_id>
977
978  */
979 static int
980 cmd_pkdecrypt (assuan_context_t ctx, char *line)
981 {
982   ctrl_t ctrl = assuan_get_pointer (ctx);
983   int rc;
984   unsigned char *outdata;
985   size_t outdatalen;
986   char *keyidstr;
987
988   if ( IS_LOCKED (ctrl) )
989     return gpg_error (GPG_ERR_LOCKED);
990
991   if ((rc = open_card (ctrl, NULL)))
992     return rc;
993
994   keyidstr = xtrystrdup (line);
995   if (!keyidstr)
996     return out_of_core ();
997   rc = app_decipher (ctrl->app_ctx,
998                      keyidstr, 
999                      pin_cb, ctx,
1000                      ctrl->in_data.value, ctrl->in_data.valuelen,
1001                      &outdata, &outdatalen);
1002
1003   xfree (keyidstr);
1004   if (rc)
1005     {
1006       log_error ("card_create_signature failed: %s\n", gpg_strerror (rc));
1007     }
1008   else
1009     {
1010       rc = assuan_send_data (ctx, outdata, outdatalen);
1011       xfree (outdata);
1012       if (rc)
1013         return rc; /* that is already an assuan error code */
1014     }
1015
1016   TEST_CARD_REMOVAL (ctrl, rc);
1017   return rc;
1018 }
1019
1020
1021 /* GETATTR <name>
1022
1023    This command is used to retrieve data from a smartcard.  The
1024    allowed names depend on the currently selected smartcard
1025    application.  NAME must be percent and '+' escaped.  The value is
1026    returned through status message, see the LEARN command for details.
1027
1028    However, the current implementation assumes that Name is not escaped;
1029    this works as long as noone uses arbitrary escaping. 
1030  
1031    Note, that this function may even be used on a locked card.
1032 */
1033 static int
1034 cmd_getattr (assuan_context_t ctx, char *line)
1035 {
1036   ctrl_t ctrl = assuan_get_pointer (ctx);
1037   int rc;
1038   const char *keyword;
1039
1040   if ((rc = open_card (ctrl, NULL)))
1041     return rc;
1042
1043   keyword = line;
1044   for (; *line && !spacep (line); line++)
1045     ;
1046   if (*line)
1047       *line++ = 0;
1048
1049   /* (We ignore any garbage for now.) */
1050
1051   /* FIXME: Applications should not return sensitive data if the card
1052      is locked.  */
1053   rc = app_getattr (ctrl->app_ctx, ctrl, keyword);
1054
1055   TEST_CARD_REMOVAL (ctrl, rc);
1056   return rc;
1057 }
1058
1059
1060 /* SETATTR <name> <value> 
1061
1062    This command is used to store data on a a smartcard.  The allowed
1063    names and values are depend on the currently selected smartcard
1064    application.  NAME and VALUE must be percent and '+' escaped.
1065
1066    However, the current implementation assumes that NAME is not
1067    escaped; this works as long as noone uses arbitrary escaping.
1068  
1069    A PIN will be requested for most NAMEs.  See the corresponding
1070    setattr function of the actually used application (app-*.c) for
1071    details.  */
1072 static int
1073 cmd_setattr (assuan_context_t ctx, char *orig_line)
1074 {
1075   ctrl_t ctrl = assuan_get_pointer (ctx);
1076   int rc;
1077   char *keyword;
1078   int keywordlen;
1079   size_t nbytes;
1080   char *line, *linebuf;
1081
1082   if ( IS_LOCKED (ctrl) )
1083     return gpg_error (GPG_ERR_LOCKED);
1084
1085   if ((rc = open_card (ctrl, NULL)))
1086     return rc;
1087
1088   /* We need to use a copy of LINE, because PIN_CB uses the same
1089      context and thus reuses the Assuan provided LINE. */
1090   line = linebuf = xtrystrdup (orig_line);
1091   if (!line)
1092     return out_of_core ();
1093
1094   keyword = line;
1095   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
1096     ;
1097   if (*line)
1098       *line++ = 0;
1099   while (spacep (line))
1100     line++;
1101   nbytes = percent_plus_unescape ((unsigned char*)line);
1102
1103   rc = app_setattr (ctrl->app_ctx, keyword, pin_cb, ctx,
1104                     (const unsigned char*)line, nbytes);
1105   xfree (linebuf);
1106
1107   TEST_CARD_REMOVAL (ctrl, rc);
1108   return rc;
1109 }
1110
1111
1112
1113 /* WRITECERT <hexified_certid>
1114
1115    This command is used to store a certifciate on a smartcard.  The
1116    allowed certids depend on the currently selected smartcard
1117    application. The actual certifciate is requested using the inquiry
1118    "CERTDATA" and needs to be provided in its raw (e.g. DER) form.
1119
1120    In almost all cases a a PIN will be requested.  See the related
1121    writecert function of the actually used application (app-*.c) for
1122    details.  */
1123 static int
1124 cmd_writecert (assuan_context_t ctx, char *line)
1125 {
1126   ctrl_t ctrl = assuan_get_pointer (ctx);
1127   int rc;
1128   char *certid;
1129   unsigned char *certdata;
1130   size_t certdatalen;
1131
1132   if ( IS_LOCKED (ctrl) )
1133     return gpg_error (GPG_ERR_LOCKED);
1134
1135   line = skip_options (line);
1136
1137   if (!*line)
1138     return set_error (GPG_ERR_ASS_PARAMETER, "no certid given");
1139   certid = line;
1140   while (*line && !spacep (line))
1141     line++;
1142   *line = 0;
1143
1144   if ((rc = open_card (ctrl, NULL)))
1145     return rc;
1146
1147   if (!ctrl->app_ctx)
1148     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
1149
1150   certid = xtrystrdup (certid);
1151   if (!certid)
1152     return out_of_core ();
1153
1154   /* Now get the actual keydata. */
1155   rc = assuan_inquire (ctx, "CERTDATA",
1156                        &certdata, &certdatalen, MAXLEN_CERTDATA);
1157   if (rc)
1158     {
1159       xfree (certid);
1160       return rc;
1161     }
1162
1163   /* Write the certificate to the card. */
1164   rc = app_writecert (ctrl->app_ctx, ctrl, certid, 
1165                       pin_cb, ctx, certdata, certdatalen);
1166   xfree (certid);
1167   xfree (certdata);
1168
1169   TEST_CARD_REMOVAL (ctrl, rc);
1170   return rc;
1171 }
1172
1173
1174
1175 /* WRITEKEY [--force] <keyid> 
1176
1177    This command is used to store a secret key on a a smartcard.  The
1178    allowed keyids depend on the currently selected smartcard
1179    application. The actual keydata is requested using the inquiry
1180    "KEYDATA" and need to be provided without any protection.  With
1181    --force set an existing key under this KEYID will get overwritten.
1182    The keydata is expected to be the usual canonical encoded
1183    S-expression.
1184
1185    A PIN will be requested for most NAMEs.  See the corresponding
1186    writekey function of the actually used application (app-*.c) for
1187    details.  */
1188 static int
1189 cmd_writekey (assuan_context_t ctx, char *line)
1190 {
1191   ctrl_t ctrl = assuan_get_pointer (ctx);
1192   int rc;
1193   char *keyid;
1194   int force = has_option (line, "--force");
1195   unsigned char *keydata;
1196   size_t keydatalen;
1197
1198   if ( IS_LOCKED (ctrl) )
1199     return gpg_error (GPG_ERR_LOCKED);
1200
1201   line = skip_options (line);
1202
1203   if (!*line)
1204     return set_error (GPG_ERR_ASS_PARAMETER, "no keyid given");
1205   keyid = line;
1206   while (*line && !spacep (line))
1207     line++;
1208   *line = 0;
1209
1210   if ((rc = open_card (ctrl, NULL)))
1211     return rc;
1212
1213   if (!ctrl->app_ctx)
1214     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
1215
1216   keyid = xtrystrdup (keyid);
1217   if (!keyid)
1218     return out_of_core ();
1219
1220   /* Now get the actual keydata. */
1221   assuan_begin_confidential (ctx);
1222   rc = assuan_inquire (ctx, "KEYDATA", &keydata, &keydatalen, MAXLEN_KEYDATA);
1223   assuan_end_confidential (ctx);
1224   if (rc)
1225     {
1226       xfree (keyid);
1227       return rc;
1228     }
1229
1230   /* Write the key to the card. */
1231   rc = app_writekey (ctrl->app_ctx, ctrl, keyid, force? 1:0,
1232                      pin_cb, ctx, keydata, keydatalen);
1233   xfree (keyid);
1234   xfree (keydata);
1235
1236   TEST_CARD_REMOVAL (ctrl, rc);
1237   return rc;
1238 }
1239
1240
1241
1242 /* GENKEY [--force] [--timestamp=<isodate>] <no>
1243
1244    Generate a key on-card identified by NO, which is application
1245    specific.  Return values are application specific.  For OpenPGP
1246    cards 2 status lines are returned:
1247
1248      S KEY-FPR  <hexstring>
1249      S KEY-CREATED-AT <seconds_since_epoch>
1250      S KEY-DATA [p|n] <hexdata>
1251      
1252    --force is required to overwrite an already existing key.  The
1253    KEY-CREATED-AT is required for further processing because it is
1254    part of the hashed key material for the fingerprint.
1255
1256    If --timestamp is given an OpenPGP key will be created using this
1257    value.  The value needs to be in ISO Format; e.g.
1258    "--timestamp=20030316T120000" and after 1970-01-01 00:00:00.
1259
1260    The public part of the key can also later be retrieved using the
1261    READKEY command.
1262
1263  */
1264 static int
1265 cmd_genkey (assuan_context_t ctx, char *line)
1266 {
1267   ctrl_t ctrl = assuan_get_pointer (ctx);
1268   int rc;
1269   char *keyno;
1270   int force;
1271   const char *s;
1272   time_t timestamp;
1273
1274   if ( IS_LOCKED (ctrl) )
1275     return gpg_error (GPG_ERR_LOCKED);
1276
1277   force = has_option (line, "--force");
1278
1279   if ((s=has_option_name (line, "--timestamp")))
1280     {
1281       if (*s != '=')
1282         return set_error (GPG_ERR_ASS_PARAMETER, "missing value for option");
1283       timestamp = isotime2epoch (s+1);
1284       if (timestamp < 1)
1285         return set_error (GPG_ERR_ASS_PARAMETER, "invalid time value");
1286     }
1287   else
1288     timestamp = 0;
1289
1290
1291   line = skip_options (line);
1292   if (!*line)
1293     return set_error (GPG_ERR_ASS_PARAMETER, "no key number given");
1294   keyno = line;
1295   while (*line && !spacep (line))
1296     line++;
1297   *line = 0;
1298
1299   if ((rc = open_card (ctrl, NULL)))
1300     return rc;
1301
1302   if (!ctrl->app_ctx)
1303     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
1304
1305   keyno = xtrystrdup (keyno);
1306   if (!keyno)
1307     return out_of_core ();
1308   rc = app_genkey (ctrl->app_ctx, ctrl, keyno, force? 1:0,
1309                    timestamp, pin_cb, ctx);
1310   xfree (keyno);
1311
1312   TEST_CARD_REMOVAL (ctrl, rc);
1313   return rc;
1314 }
1315
1316
1317 /* RANDOM <nbytes>
1318
1319    Get NBYTES of random from the card and send them back as data. 
1320
1321    Note, that this function may be even be used on a locked card.
1322 */
1323 static int
1324 cmd_random (assuan_context_t ctx, char *line)
1325 {
1326   ctrl_t ctrl = assuan_get_pointer (ctx);
1327   int rc;
1328   size_t nbytes;
1329   unsigned char *buffer;
1330
1331   if (!*line)
1332     return set_error (GPG_ERR_ASS_PARAMETER, "number of requested bytes missing");
1333   nbytes = strtoul (line, NULL, 0);
1334
1335   if ((rc = open_card (ctrl, NULL)))
1336     return rc;
1337
1338   if (!ctrl->app_ctx)
1339     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
1340
1341   buffer = xtrymalloc (nbytes);
1342   if (!buffer)
1343     return out_of_core ();
1344
1345   rc = app_get_challenge (ctrl->app_ctx, nbytes, buffer);
1346   if (!rc)
1347     {
1348       rc = assuan_send_data (ctx, buffer, nbytes);
1349       xfree (buffer);
1350       return rc; /* that is already an assuan error code */
1351     }
1352   xfree (buffer);
1353
1354   TEST_CARD_REMOVAL (ctrl, rc);
1355   return rc;
1356 }
1357
1358 \f
1359 /* PASSWD [--reset] [--nullpin] <chvno>
1360   
1361    Change the PIN or reset the retry counter of the card holder
1362    verfication vector CHVNO.  The option --nullpin is used for TCOS
1363    cards to set the initial PIN. */
1364 static int
1365 cmd_passwd (assuan_context_t ctx, char *line)
1366 {
1367   ctrl_t ctrl = assuan_get_pointer (ctx);
1368   int rc;
1369   char *chvnostr;
1370   unsigned int flags = 0;
1371
1372   if (has_option (line, "--reset"))
1373     flags |= APP_CHANGE_FLAG_RESET;
1374   if (has_option (line, "--nullpin"))
1375     flags |= APP_CHANGE_FLAG_NULLPIN;
1376
1377   if ( IS_LOCKED (ctrl) )
1378     return gpg_error (GPG_ERR_LOCKED);
1379
1380   line = skip_options (line);
1381
1382   if (!*line)
1383     return set_error (GPG_ERR_ASS_PARAMETER, "no CHV number given");
1384   chvnostr = line;
1385   while (*line && !spacep (line))
1386     line++;
1387   *line = 0;
1388
1389   if ((rc = open_card (ctrl, NULL)))
1390     return rc;
1391
1392   if (!ctrl->app_ctx)
1393     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
1394   
1395   chvnostr = xtrystrdup (chvnostr);
1396   if (!chvnostr)
1397     return out_of_core ();
1398   rc = app_change_pin (ctrl->app_ctx, ctrl, chvnostr, flags, pin_cb, ctx);
1399   if (rc)
1400     log_error ("command passwd failed: %s\n", gpg_strerror (rc));
1401   xfree (chvnostr);
1402
1403   TEST_CARD_REMOVAL (ctrl, rc);
1404   return rc;
1405 }
1406
1407
1408 /* CHECKPIN <idstr>
1409
1410    Perform a VERIFY operation without doing anything else.  This may
1411    be used to initialize a the PIN cache earlier to long lasting
1412    operations.  Its use is highly application dependent.
1413
1414    For OpenPGP:
1415
1416       Perform a simple verify operation for CHV1 and CHV2, so that
1417       further operations won't ask for CHV2 and it is possible to do a
1418       cheap check on the PIN: If there is something wrong with the PIN
1419       entry system, only the regular CHV will get blocked and not the
1420       dangerous CHV3.  IDSTR is the usual card's serial number in hex
1421       notation; an optional fingerprint part will get ignored.  There
1422       is however a special mode if the IDSTR is sffixed with the
1423       literal string "[CHV3]": In this case the Admin PIN is checked
1424       if and only if the retry counter is still at 3.
1425
1426  */
1427 static int
1428 cmd_checkpin (assuan_context_t ctx, char *line)
1429 {
1430   ctrl_t ctrl = assuan_get_pointer (ctx);
1431   int rc;
1432   char *keyidstr;
1433
1434   if ( IS_LOCKED (ctrl) )
1435     return gpg_error (GPG_ERR_LOCKED);
1436
1437   if ((rc = open_card (ctrl, NULL)))
1438     return rc;
1439
1440   if (!ctrl->app_ctx)
1441     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
1442
1443   /* We have to use a copy of the key ID because the function may use
1444      the pin_cb which in turn uses the assuan line buffer and thus
1445      overwriting the original line with the keyid. */
1446   keyidstr = xtrystrdup (line);
1447   if (!keyidstr)
1448     return out_of_core ();
1449   
1450   rc = app_check_pin (ctrl->app_ctx,
1451                       keyidstr,
1452                       pin_cb, ctx);
1453   xfree (keyidstr);
1454   if (rc)
1455     log_error ("app_check_pin failed: %s\n", gpg_strerror (rc));
1456
1457   TEST_CARD_REMOVAL (ctrl, rc);
1458   return rc;
1459 }
1460
1461
1462 /* LOCK [--wait]
1463
1464    Grant exclusive card access to this session.  Note that there is
1465    no lock counter used and a second lock from the same session will
1466    be ignored.  A single unlock (or RESET) unlocks the session.
1467    Return GPG_ERR_LOCKED if another session has locked the reader.
1468
1469    If the option --wait is given the command will wait until a
1470    lock has been released.
1471  */
1472 static int
1473 cmd_lock (assuan_context_t ctx, char *line)
1474 {
1475   ctrl_t ctrl = assuan_get_pointer (ctx);
1476   int rc = 0;
1477
1478  retry:
1479   if (locked_session)
1480     {
1481       if (locked_session != ctrl->server_local)
1482         rc = gpg_error (GPG_ERR_LOCKED);
1483     }
1484   else
1485     locked_session = ctrl->server_local;
1486
1487 #ifdef USE_GNU_PTH
1488   if (rc && has_option (line, "--wait"))
1489     {
1490       rc = 0;
1491       pth_sleep (1); /* Better implement an event mechanism. However,
1492                         for card operations this should be
1493                         sufficient. */
1494       /* FIXME: Need to check that the connection is still alive.
1495          This can be done by issuing status messages. */
1496       goto retry;
1497     }
1498 #endif /*USE_GNU_PTH*/
1499   
1500   if (rc)
1501     log_error ("cmd_lock failed: %s\n", gpg_strerror (rc));
1502   return rc;
1503 }
1504
1505
1506 /* UNLOCK
1507
1508    Release exclusive card access.
1509  */
1510 static int
1511 cmd_unlock (assuan_context_t ctx, char *line)
1512 {
1513   ctrl_t ctrl = assuan_get_pointer (ctx);
1514   int rc = 0;
1515
1516   (void)line;
1517
1518   if (locked_session)
1519     {
1520       if (locked_session != ctrl->server_local)
1521         rc = gpg_error (GPG_ERR_LOCKED);
1522       else
1523         locked_session = NULL;
1524     }
1525   else
1526     rc = gpg_error (GPG_ERR_NOT_LOCKED);
1527
1528   if (rc)
1529     log_error ("cmd_unlock failed: %s\n", gpg_strerror (rc));
1530   return rc;
1531 }
1532
1533
1534 /* GETINFO <what>
1535
1536    Multi purpose command to return certain information.  
1537    Supported values of WHAT are:
1538
1539    version     - Return the version of the program.
1540    pid         - Return the process id of the server.
1541
1542    socket_name - Return the name of the socket.
1543
1544    status - Return the status of the current slot (in the future, may
1545    also return the status of all slots).  The status is a list of
1546    one-character flags.  The following flags are currently defined:
1547      'u'  Usable card present.  This is the normal state during operation.
1548      'r'  Card removed.  A reset is necessary.
1549    These flags are exclusive.
1550
1551    reader_list - Return a list of detected card readers.  Does
1552                  currently only work with the internal CCID driver.
1553 */
1554
1555 static int
1556 cmd_getinfo (assuan_context_t ctx, char *line)
1557 {
1558   int rc = 0;
1559
1560   if (!strcmp (line, "version"))
1561     {
1562       const char *s = VERSION;
1563       rc = assuan_send_data (ctx, s, strlen (s));
1564     }
1565   else if (!strcmp (line, "pid"))
1566     {
1567       char numbuf[50];
1568
1569       snprintf (numbuf, sizeof numbuf, "%lu", (unsigned long)getpid ());
1570       rc = assuan_send_data (ctx, numbuf, strlen (numbuf));
1571     }
1572   else if (!strcmp (line, "socket_name"))
1573     {
1574       const char *s = scd_get_socket_name ();
1575
1576       if (s)
1577         rc = assuan_send_data (ctx, s, strlen (s));
1578       else
1579         rc = gpg_error (GPG_ERR_NO_DATA);
1580     }
1581   else if (!strcmp (line, "status"))
1582     {
1583       ctrl_t ctrl = assuan_get_pointer (ctx);
1584       int slot = ctrl->reader_slot;
1585       char flag = 'r';
1586
1587       if (!ctrl->server_local->card_removed && slot != -1)
1588         {
1589           struct slot_status_s *ss;
1590           
1591           if (!(slot >= 0 && slot < DIM(slot_table)))
1592             BUG ();
1593
1594           ss = &slot_table[slot];
1595
1596           if (!ss->valid)
1597             BUG ();
1598
1599           if (ss->any && (ss->status & 1))
1600             flag = 'u';
1601         }
1602       rc = assuan_send_data (ctx, &flag, 1);
1603     }
1604   else if (!strcmp (line, "reader_list"))
1605     {
1606 #ifdef HAVE_LIBUSB
1607       char *s = ccid_get_reader_list ();
1608 #else
1609       char *s = NULL;
1610 #endif
1611       
1612       if (s)
1613         rc = assuan_send_data (ctx, s, strlen (s));
1614       else
1615         rc = gpg_error (GPG_ERR_NO_DATA);
1616       xfree (s);
1617     }
1618   else
1619     rc = set_error (GPG_ERR_ASS_PARAMETER, "unknown value for WHAT");
1620   return rc;
1621 }
1622
1623
1624 /* RESTART
1625
1626    Restart the current connection; this is a kind of warm reset.  It
1627    deletes the context used by this connection but does not send a
1628    RESET to the card.  Thus the card itself won't get reset. 
1629
1630    This is used by gpg-agent to reuse a primary pipe connection and
1631    may be used by clients to backup from a conflict in the serial
1632    command; i.e. to select another application. 
1633 */
1634
1635 static int
1636 cmd_restart (assuan_context_t ctx, char *line)
1637 {
1638   ctrl_t ctrl = assuan_get_pointer (ctx);
1639
1640   (void)line;
1641
1642   if (ctrl->app_ctx)
1643     {
1644       release_application (ctrl->app_ctx);
1645       ctrl->app_ctx = NULL;
1646     }
1647   if (locked_session && ctrl->server_local == locked_session)
1648     {
1649       locked_session = NULL;
1650       log_info ("implicitly unlocking due to RESTART\n");
1651     }
1652   return 0;
1653 }
1654
1655
1656 /* DISCONNECT
1657
1658    TBD
1659
1660 */
1661 static int
1662 cmd_disconnect (assuan_context_t ctx, char *line)
1663 {
1664   (void)ctx;
1665   (void)line;
1666   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1667 }
1668
1669
1670
1671 /* APDU [--atr] [--more] [hexstring]
1672
1673    Send an APDU to the current reader.  This command bypasses the high
1674    level functions and sends the data directly to the card.  HEXSTRING
1675    is expected to be a proper APDU.  If HEXSTRING is not given no
1676    commands are set to the card but the command will implictly check
1677    whether the card is ready for use. 
1678
1679    Using the option "--atr" returns the ATR of the card as a status
1680    message before any data like this:
1681      S CARD-ATR 3BFA1300FF813180450031C173C00100009000B1
1682
1683    Using the option --more handles the card status word MORE_DATA
1684    (61xx) and concatenate all reponses to one block.
1685
1686  */
1687 static int
1688 cmd_apdu (assuan_context_t ctx, char *line)
1689 {
1690   ctrl_t ctrl = assuan_get_pointer (ctx);
1691   int rc;
1692   unsigned char *apdu;
1693   size_t apdulen;
1694   int with_atr;
1695   int handle_more;
1696
1697   with_atr = has_option (line, "--atr");
1698   handle_more = has_option (line, "--more");
1699
1700   line = skip_options (line);
1701
1702   if ( IS_LOCKED (ctrl) )
1703     return gpg_error (GPG_ERR_LOCKED);
1704
1705   if ((rc = open_card (ctrl, NULL)))
1706     return rc;
1707
1708   if (with_atr)
1709     {
1710       unsigned char *atr;
1711       size_t atrlen;
1712       char hexbuf[400];
1713       
1714       atr = apdu_get_atr (ctrl->reader_slot, &atrlen);
1715       if (!atr || atrlen > sizeof hexbuf - 2 )
1716         {
1717           rc = gpg_error (GPG_ERR_INV_CARD);
1718           goto leave;
1719         }
1720       bin2hex (atr, atrlen, hexbuf);
1721       xfree (atr);
1722       send_status_info (ctrl, "CARD-ATR", hexbuf, strlen (hexbuf), NULL, 0);
1723     }
1724
1725   apdu = hex_to_buffer (line, &apdulen);
1726   if (!apdu)
1727     {
1728       rc = gpg_error_from_syserror ();
1729       goto leave;
1730     }
1731   if (apdulen)
1732     {
1733       unsigned char *result = NULL;
1734       size_t resultlen;
1735
1736       rc = apdu_send_direct (ctrl->reader_slot, apdu, apdulen, handle_more,
1737                              &result, &resultlen);
1738       if (rc)
1739         log_error ("apdu_send_direct failed: %s\n", gpg_strerror (rc));
1740       else
1741         {
1742           rc = assuan_send_data (ctx, result, resultlen);
1743           xfree (result);
1744         }
1745     }
1746   xfree (apdu);
1747
1748  leave:
1749   TEST_CARD_REMOVAL (ctrl, rc);
1750   return rc;
1751 }
1752
1753
1754
1755
1756 \f
1757 /* Tell the assuan library about our commands */
1758 static int
1759 register_commands (assuan_context_t ctx)
1760 {
1761   static struct {
1762     const char *name;
1763     int (*handler)(assuan_context_t, char *line);
1764   } table[] = {
1765     { "SERIALNO",     cmd_serialno },
1766     { "LEARN",        cmd_learn },
1767     { "READCERT",     cmd_readcert },
1768     { "READKEY",      cmd_readkey },
1769     { "SETDATA",      cmd_setdata },
1770     { "PKSIGN",       cmd_pksign },
1771     { "PKAUTH",       cmd_pkauth },
1772     { "PKDECRYPT",    cmd_pkdecrypt },
1773     { "INPUT",        NULL }, 
1774     { "OUTPUT",       NULL }, 
1775     { "GETATTR",      cmd_getattr },
1776     { "SETATTR",      cmd_setattr },
1777     { "WRITECERT",    cmd_writecert },
1778     { "WRITEKEY",     cmd_writekey },
1779     { "GENKEY",       cmd_genkey },
1780     { "RANDOM",       cmd_random },
1781     { "PASSWD",       cmd_passwd },
1782     { "CHECKPIN",     cmd_checkpin },
1783     { "LOCK",         cmd_lock },
1784     { "UNLOCK",       cmd_unlock },
1785     { "GETINFO",      cmd_getinfo },
1786     { "RESTART",      cmd_restart },
1787     { "DISCONNECT",   cmd_disconnect },
1788     { "APDU",         cmd_apdu },
1789     { NULL }
1790   };
1791   int i, rc;
1792
1793   for (i=0; table[i].name; i++)
1794     {
1795       rc = assuan_register_command (ctx, table[i].name, table[i].handler);
1796       if (rc)
1797         return rc;
1798     } 
1799   assuan_set_hello_line (ctx, "GNU Privacy Guard's Smartcard server ready");
1800
1801   assuan_register_reset_notify (ctx, reset_notify);
1802   assuan_register_option_handler (ctx, option_handler);
1803   return 0;
1804 }
1805
1806
1807 /* Startup the server.  If FD is given as -1 this is simple pipe
1808    server, otherwise it is a regular server.  Returns true if there
1809    are no more active asessions.  */
1810 int
1811 scd_command_handler (ctrl_t ctrl, int fd)
1812 {
1813   int rc;
1814   assuan_context_t ctx;
1815   
1816   if (fd == -1)
1817     {
1818       int filedes[2];
1819
1820       filedes[0] = 0;
1821       filedes[1] = 1;
1822       rc = assuan_init_pipe_server (&ctx, filedes);
1823     }
1824   else
1825     {
1826       rc = assuan_init_socket_server_ext (&ctx, INT2FD(fd), 2);
1827     }
1828   if (rc)
1829     {
1830       log_error ("failed to initialize the server: %s\n",
1831                  gpg_strerror(rc));
1832       scd_exit (2);
1833     }
1834   rc = register_commands (ctx);
1835   if (rc)
1836     {
1837       log_error ("failed to register commands with Assuan: %s\n",
1838                  gpg_strerror(rc));
1839       scd_exit (2);
1840     }
1841   assuan_set_pointer (ctx, ctrl);
1842
1843   /* Allocate and initialize the server object.  Put it into the list
1844      of active sessions. */
1845   ctrl->server_local = xcalloc (1, sizeof *ctrl->server_local);
1846   ctrl->server_local->next_session = session_list;
1847   session_list = ctrl->server_local;
1848   ctrl->server_local->ctrl_backlink = ctrl;
1849   ctrl->server_local->assuan_ctx = ctx;
1850
1851   if (DBG_ASSUAN)
1852     assuan_set_log_stream (ctx, log_get_stream ());
1853
1854   /* We open the reader right at startup so that the ticker is able to
1855      update the status file. */
1856   if (ctrl->reader_slot == -1)
1857     {
1858       ctrl->reader_slot = get_reader_slot ();
1859     }
1860
1861   /* Command processing loop. */
1862   for (;;)
1863     {
1864       rc = assuan_accept (ctx);
1865       if (rc == -1)
1866         {
1867           break;
1868         }
1869       else if (rc)
1870         {
1871           log_info ("Assuan accept problem: %s\n", gpg_strerror (rc));
1872           break;
1873         }
1874       
1875       rc = assuan_process (ctx);
1876       if (rc)
1877         {
1878           log_info ("Assuan processing failed: %s\n", gpg_strerror (rc));
1879           continue;
1880         }
1881     }
1882
1883   /* Cleanup.  We don't send an explicit reset to the card.  */
1884   do_reset (ctrl, 0); 
1885
1886   /* Release the server object.  */
1887   if (session_list == ctrl->server_local)
1888     session_list = ctrl->server_local->next_session;
1889   else
1890     {
1891       struct server_local_s *sl;
1892       
1893       for (sl=session_list; sl->next_session; sl = sl->next_session)
1894         if (sl->next_session == ctrl->server_local)
1895           break;
1896       if (!sl->next_session)
1897           BUG ();
1898       sl->next_session = ctrl->server_local->next_session;
1899     }
1900   xfree (ctrl->server_local);
1901   ctrl->server_local = NULL;
1902
1903   /* Release the Assuan context.  */
1904   assuan_deinit_server (ctx);
1905
1906   /* If there are no more sessions return true.  */
1907   return !session_list;
1908 }
1909
1910
1911 /* Send a line with status information via assuan and escape all given
1912    buffers. The variable elements are pairs of (char *, size_t),
1913    terminated with a (NULL, 0). */
1914 void
1915 send_status_info (ctrl_t ctrl, const char *keyword, ...)
1916 {
1917   va_list arg_ptr;
1918   const unsigned char *value;
1919   size_t valuelen;
1920   char buf[950], *p;
1921   size_t n;
1922   assuan_context_t ctx = ctrl->server_local->assuan_ctx;
1923   
1924   va_start (arg_ptr, keyword);
1925
1926   p = buf; 
1927   n = 0;
1928   while ( (value = va_arg (arg_ptr, const unsigned char *)) )
1929     {
1930       valuelen = va_arg (arg_ptr, size_t);
1931       if (!valuelen)
1932         continue; /* empty buffer */
1933       if (n)
1934         {
1935           *p++ = ' ';
1936           n++;
1937         }
1938       for ( ; valuelen && n < DIM (buf)-2; n++, valuelen--, value++)
1939         {
1940           if (*value < ' ' || *value == '+')
1941             {
1942               sprintf (p, "%%%02X", *value);
1943               p += 3;
1944             }
1945           else if (*value == ' ')
1946             *p++ = '+';
1947           else
1948             *p++ = *value;
1949         }
1950     }
1951   *p = 0;
1952   assuan_write_status (ctx, keyword, buf);
1953
1954   va_end (arg_ptr);
1955 }
1956
1957
1958 /* This is the core of scd_update_reader_status_file but the caller
1959    needs to take care of the locking.  */
1960 static void
1961 update_reader_status_file (int set_card_removed_flag)
1962 {
1963   int idx;
1964   unsigned int status, changed;
1965
1966   /* Make sure that the reader has been opened.  Like get_reader_slot,
1967      this part of the code assumes that there is only one reader.  */
1968   if (!slot_table[0].valid)
1969     (void)get_reader_slot ();
1970
1971   /* Note, that we only try to get the status, because it does not
1972      make sense to wait here for a operation to complete.  If we are
1973      busy working with a card, delays in the status file update should
1974      be acceptable. */
1975   for (idx=0; idx < DIM(slot_table); idx++)
1976     {
1977       struct slot_status_s *ss = slot_table + idx;
1978
1979       if (!ss->valid || ss->slot == -1)
1980         continue; /* Not valid or reader not yet open. */
1981       
1982       if ( apdu_get_status (ss->slot, 0, &status, &changed) )
1983         continue; /* Get status failed. */
1984
1985       if (!ss->any || ss->status != status || ss->changed != changed )
1986         {
1987           char *fname;
1988           char templ[50];
1989           FILE *fp;
1990           struct server_local_s *sl;
1991
1992           log_info ("updating status of slot %d to 0x%04X\n",
1993                     ss->slot, status);
1994
1995           /* FIXME: Should this be IDX instead of ss->slot?  This
1996              depends on how client sessions will associate the reader
1997              status with their session.  */
1998           snprintf (templ, sizeof templ, "reader_%d.status", ss->slot);
1999           fname = make_filename (opt.homedir, templ, NULL );
2000           fp = fopen (fname, "w");
2001           if (fp)
2002             {
2003               fprintf (fp, "%s\n",
2004                        (status & 1)? "USABLE":
2005                        (status & 4)? "ACTIVE":
2006                        (status & 2)? "PRESENT": "NOCARD");
2007               fclose (fp);
2008             }
2009           xfree (fname);
2010             
2011           /* If a status script is executable, run it. */
2012           {
2013             const char *args[9], *envs[2];
2014             char numbuf1[30], numbuf2[30], numbuf3[30];
2015             char *homestr, *envstr;
2016             gpg_error_t err;
2017             
2018             homestr = make_filename (opt.homedir, NULL);
2019             if (estream_asprintf (&envstr, "GNUPGHOME=%s", homestr) < 0)
2020               log_error ("out of core while building environment\n");
2021             else
2022               {
2023                 envs[0] = envstr;
2024                 envs[1] = NULL;
2025
2026                 sprintf (numbuf1, "%d", ss->slot);
2027                 sprintf (numbuf2, "0x%04X", ss->status);
2028                 sprintf (numbuf3, "0x%04X", status);
2029                 args[0] = "--reader-port";
2030                 args[1] = numbuf1; 
2031                 args[2] = "--old-code";
2032                 args[3] = numbuf2;  
2033                 args[4] = "--new-code";
2034                 args[5] = numbuf3; 
2035                 args[6] = "--status";
2036                 args[7] = ((status & 1)? "USABLE":
2037                            (status & 4)? "ACTIVE":
2038                            (status & 2)? "PRESENT": "NOCARD");
2039                 args[8] = NULL;  
2040
2041                 fname = make_filename (opt.homedir, "scd-event", NULL);
2042                 err = gnupg_spawn_process_detached (fname, args, envs);
2043                 if (err && gpg_err_code (err) != GPG_ERR_ENOENT)
2044                   log_error ("failed to run event handler `%s': %s\n",
2045                              fname, gpg_strerror (err));
2046                 xfree (fname);
2047                 xfree (envstr);
2048               }
2049             xfree (homestr);
2050           }
2051
2052           /* Set the card removed flag for all current sessions.  We
2053              will set this on any card change because a reset or
2054              SERIALNO request must be done in any case.  */
2055           if (ss->any && set_card_removed_flag)
2056             update_card_removed (idx, 1);
2057           
2058           ss->any = 1;
2059           ss->status = status;
2060           ss->changed = changed;
2061
2062           /* Send a signal to all clients who applied for it.  */
2063           for (sl=session_list; sl; sl = sl->next_session)
2064             if (sl->event_signal && sl->assuan_ctx)
2065               {
2066                 pid_t pid = assuan_get_pid (sl->assuan_ctx);
2067
2068 #ifdef HAVE_W32_SYSTEM
2069                 HANDLE handle = (void *)sl->event_signal;
2070                 
2071                 log_info ("client pid is %d, triggering event %lx (%p)\n",
2072                           pid, sl->event_signal, handle);
2073                 if (!SetEvent (handle))
2074                   log_error ("SetEvent(%lx) failed: %s\n",
2075                              sl->event_signal, w32_strerror (-1));
2076 #else
2077                 int signo = sl->event_signal;
2078                 
2079                 log_info ("client pid is %d, sending signal %d\n",
2080                           pid, signo);
2081                 if (pid != (pid_t)(-1) && pid && signo > 0)
2082                   kill (pid, signo);
2083 #endif
2084               }
2085
2086         }
2087     }
2088 }
2089
2090 /* This function is called by the ticker thread to check for changes
2091    of the reader stati.  It updates the reader status files and if
2092    requested by the caller also send a signal to the caller.  */
2093 void
2094 scd_update_reader_status_file (void)
2095 {
2096   if (!pth_mutex_acquire (&status_file_update_lock, 1, NULL))
2097     return; /* locked - give up. */
2098   update_reader_status_file (1);
2099   if (!pth_mutex_release (&status_file_update_lock))
2100     log_error ("failed to release status_file_update lock\n");
2101 }