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