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