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