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