Use bin2hex if possible.
[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       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       bin2hex (atr, atrlen, hexbuf);
1716       xfree (atr);
1717       send_status_info (ctrl, "CARD-ATR", hexbuf, strlen (hexbuf), NULL, 0);
1718     }
1719
1720   apdu = hex_to_buffer (line, &apdulen);
1721   if (!apdu)
1722     {
1723       rc = gpg_error_from_syserror ();
1724       goto leave;
1725     }
1726   if (apdulen)
1727     {
1728       unsigned char *result = NULL;
1729       size_t resultlen;
1730
1731       rc = apdu_send_direct (ctrl->reader_slot, apdu, apdulen, handle_more,
1732                              &result, &resultlen);
1733       if (rc)
1734         log_error ("apdu_send_direct failed: %s\n", gpg_strerror (rc));
1735       else
1736         {
1737           rc = assuan_send_data (ctx, result, resultlen);
1738           xfree (result);
1739         }
1740     }
1741   xfree (apdu);
1742
1743  leave:
1744   TEST_CARD_REMOVAL (ctrl, rc);
1745   return rc;
1746 }
1747
1748
1749
1750
1751 \f
1752 /* Tell the assuan library about our commands */
1753 static int
1754 register_commands (assuan_context_t ctx)
1755 {
1756   static struct {
1757     const char *name;
1758     int (*handler)(assuan_context_t, char *line);
1759   } table[] = {
1760     { "SERIALNO",     cmd_serialno },
1761     { "LEARN",        cmd_learn },
1762     { "READCERT",     cmd_readcert },
1763     { "READKEY",      cmd_readkey },
1764     { "SETDATA",      cmd_setdata },
1765     { "PKSIGN",       cmd_pksign },
1766     { "PKAUTH",       cmd_pkauth },
1767     { "PKDECRYPT",    cmd_pkdecrypt },
1768     { "INPUT",        NULL }, 
1769     { "OUTPUT",       NULL }, 
1770     { "GETATTR",      cmd_getattr },
1771     { "SETATTR",      cmd_setattr },
1772     { "WRITECERT",    cmd_writecert },
1773     { "WRITEKEY",     cmd_writekey },
1774     { "GENKEY",       cmd_genkey },
1775     { "RANDOM",       cmd_random },
1776     { "PASSWD",       cmd_passwd },
1777     { "CHECKPIN",     cmd_checkpin },
1778     { "LOCK",         cmd_lock },
1779     { "UNLOCK",       cmd_unlock },
1780     { "GETINFO",      cmd_getinfo },
1781     { "RESTART",      cmd_restart },
1782     { "DISCONNECT",   cmd_disconnect },
1783     { "APDU",         cmd_apdu },
1784     { NULL }
1785   };
1786   int i, rc;
1787
1788   for (i=0; table[i].name; i++)
1789     {
1790       rc = assuan_register_command (ctx, table[i].name, table[i].handler);
1791       if (rc)
1792         return rc;
1793     } 
1794   assuan_set_hello_line (ctx, "GNU Privacy Guard's Smartcard server ready");
1795
1796   assuan_register_reset_notify (ctx, reset_notify);
1797   assuan_register_option_handler (ctx, option_handler);
1798   return 0;
1799 }
1800
1801
1802 /* Startup the server.  If FD is given as -1 this is simple pipe
1803    server, otherwise it is a regular server.  Returns true if there
1804    are no more active asessions.  */
1805 int
1806 scd_command_handler (ctrl_t ctrl, int fd)
1807 {
1808   int rc;
1809   assuan_context_t ctx;
1810   
1811   if (fd == -1)
1812     {
1813       int filedes[2];
1814
1815       filedes[0] = 0;
1816       filedes[1] = 1;
1817       rc = assuan_init_pipe_server (&ctx, filedes);
1818     }
1819   else
1820     {
1821       rc = assuan_init_socket_server_ext (&ctx, INT2FD(fd), 2);
1822     }
1823   if (rc)
1824     {
1825       log_error ("failed to initialize the server: %s\n",
1826                  gpg_strerror(rc));
1827       scd_exit (2);
1828     }
1829   rc = register_commands (ctx);
1830   if (rc)
1831     {
1832       log_error ("failed to register commands with Assuan: %s\n",
1833                  gpg_strerror(rc));
1834       scd_exit (2);
1835     }
1836   assuan_set_pointer (ctx, ctrl);
1837
1838   /* Allocate and initialize the server object.  Put it into the list
1839      of active sessions. */
1840   ctrl->server_local = xcalloc (1, sizeof *ctrl->server_local);
1841   ctrl->server_local->next_session = session_list;
1842   session_list = ctrl->server_local;
1843   ctrl->server_local->ctrl_backlink = ctrl;
1844   ctrl->server_local->assuan_ctx = ctx;
1845
1846   if (DBG_ASSUAN)
1847     assuan_set_log_stream (ctx, log_get_stream ());
1848
1849   /* We open the reader right at startup so that the ticker is able to
1850      update the status file. */
1851   if (ctrl->reader_slot == -1)
1852     {
1853       ctrl->reader_slot = get_reader_slot ();
1854     }
1855
1856   /* Command processing loop. */
1857   for (;;)
1858     {
1859       rc = assuan_accept (ctx);
1860       if (rc == -1)
1861         {
1862           break;
1863         }
1864       else if (rc)
1865         {
1866           log_info ("Assuan accept problem: %s\n", gpg_strerror (rc));
1867           break;
1868         }
1869       
1870       rc = assuan_process (ctx);
1871       if (rc)
1872         {
1873           log_info ("Assuan processing failed: %s\n", gpg_strerror (rc));
1874           continue;
1875         }
1876     }
1877
1878   /* Cleanup.  */
1879   do_reset (ctrl, 0); 
1880
1881   /* Release the server object.  */
1882   if (session_list == ctrl->server_local)
1883     session_list = ctrl->server_local->next_session;
1884   else
1885     {
1886       struct server_local_s *sl;
1887       
1888       for (sl=session_list; sl->next_session; sl = sl->next_session)
1889         if (sl->next_session == ctrl->server_local)
1890           break;
1891       if (!sl->next_session)
1892           BUG ();
1893       sl->next_session = ctrl->server_local->next_session;
1894     }
1895   xfree (ctrl->server_local);
1896   ctrl->server_local = NULL;
1897
1898   /* Release the Assuan context.  */
1899   assuan_deinit_server (ctx);
1900
1901   /* If there are no more sessions return true.  */
1902   return !session_list;
1903 }
1904
1905
1906 /* Send a line with status information via assuan and escape all given
1907    buffers. The variable elements are pairs of (char *, size_t),
1908    terminated with a (NULL, 0). */
1909 void
1910 send_status_info (ctrl_t ctrl, const char *keyword, ...)
1911 {
1912   va_list arg_ptr;
1913   const unsigned char *value;
1914   size_t valuelen;
1915   char buf[950], *p;
1916   size_t n;
1917   assuan_context_t ctx = ctrl->server_local->assuan_ctx;
1918   
1919   va_start (arg_ptr, keyword);
1920
1921   p = buf; 
1922   n = 0;
1923   while ( (value = va_arg (arg_ptr, const unsigned char *)) )
1924     {
1925       valuelen = va_arg (arg_ptr, size_t);
1926       if (!valuelen)
1927         continue; /* empty buffer */
1928       if (n)
1929         {
1930           *p++ = ' ';
1931           n++;
1932         }
1933       for ( ; valuelen && n < DIM (buf)-2; n++, valuelen--, value++)
1934         {
1935           if (*value < ' ' || *value == '+')
1936             {
1937               sprintf (p, "%%%02X", *value);
1938               p += 3;
1939             }
1940           else if (*value == ' ')
1941             *p++ = '+';
1942           else
1943             *p++ = *value;
1944         }
1945     }
1946   *p = 0;
1947   assuan_write_status (ctx, keyword, buf);
1948
1949   va_end (arg_ptr);
1950 }
1951
1952
1953 /* This is the core of scd_update_reader_status_file but the caller
1954    needs to take care of the locking. */
1955 static void
1956 update_reader_status_file (void)
1957 {
1958   int idx;
1959   unsigned int status, changed;
1960
1961   /* Make sure that the reader has been opened.  Like get_reader_slot,
1962      this part of the code assumes that there is only one reader.  */
1963   if (!slot_table[0].valid)
1964     (void)get_reader_slot ();
1965
1966   /* Note, that we only try to get the status, because it does not
1967      make sense to wait here for a operation to complete.  If we are
1968      busy working with a card, delays in the status file update should
1969      be acceptable. */
1970   for (idx=0; idx < DIM(slot_table); idx++)
1971     {
1972       struct slot_status_s *ss = slot_table + idx;
1973
1974       if (!ss->valid || ss->slot == -1)
1975         continue; /* Not valid or reader not yet open. */
1976       
1977       if ( apdu_get_status (ss->slot, 0, &status, &changed) )
1978         continue; /* Get status failed. */
1979
1980       if (!ss->any || ss->status != status || ss->changed != changed )
1981         {
1982           char *fname;
1983           char templ[50];
1984           FILE *fp;
1985           struct server_local_s *sl;
1986
1987           log_info ("updating status of slot %d to 0x%04X\n",
1988                     ss->slot, status);
1989
1990           /* FIXME: Should this be IDX instead of ss->slot?  This
1991              depends on how client sessions will associate the reader
1992              status with their session.  */
1993           sprintf (templ, "reader_%d.status", ss->slot);
1994           fname = make_filename (opt.homedir, templ, NULL );
1995           fp = fopen (fname, "w");
1996           if (fp)
1997             {
1998               fprintf (fp, "%s\n",
1999                        (status & 1)? "USABLE":
2000                        (status & 4)? "ACTIVE":
2001                        (status & 2)? "PRESENT": "NOCARD");
2002               fclose (fp);
2003             }
2004           xfree (fname);
2005             
2006           /* If a status script is executable, run it. */
2007           {
2008             const char *args[9], *envs[2];
2009             char numbuf1[30], numbuf2[30], numbuf3[30];
2010             char *homestr, *envstr;
2011             gpg_error_t err;
2012             
2013             homestr = make_filename (opt.homedir, NULL);
2014             if (estream_asprintf (&envstr, "GNUPGHOME=%s", homestr) < 0)
2015               log_error ("out of core while building environment\n");
2016             else
2017               {
2018                 envs[0] = envstr;
2019                 envs[1] = NULL;
2020
2021                 sprintf (numbuf1, "%d", ss->slot);
2022                 sprintf (numbuf2, "0x%04X", ss->status);
2023                 sprintf (numbuf3, "0x%04X", status);
2024                 args[0] = "--reader-port";
2025                 args[1] = numbuf1; 
2026                 args[2] = "--old-code";
2027                 args[3] = numbuf2;  
2028                 args[4] = "--new-code";
2029                 args[5] = numbuf3; 
2030                 args[6] = "--status";
2031                 args[7] = ((status & 1)? "USABLE":
2032                            (status & 4)? "ACTIVE":
2033                            (status & 2)? "PRESENT": "NOCARD");
2034                 args[8] = NULL;  
2035
2036                 fname = make_filename (opt.homedir, "scd-event", NULL);
2037                 err = gnupg_spawn_process_detached (fname, args, envs);
2038                 if (err && gpg_err_code (err) != GPG_ERR_ENOENT)
2039                   log_error ("failed to run event handler `%s': %s\n",
2040                              fname, gpg_strerror (err));
2041                 xfree (fname);
2042                 xfree (envstr);
2043               }
2044             xfree (homestr);
2045           }
2046
2047           /* Set the card removed flag for all current sessions.  We
2048              will set this on any card change because a reset or
2049              SERIALNO request must be done in any case.  */
2050           if (ss->any)
2051             update_card_removed (idx, 1);
2052           
2053           ss->any = 1;
2054           ss->status = status;
2055           ss->changed = changed;
2056
2057           /* Send a signal to all clients who applied for it.  */
2058           for (sl=session_list; sl; sl = sl->next_session)
2059             if (sl->event_signal && sl->assuan_ctx)
2060               {
2061                 pid_t pid = assuan_get_pid (sl->assuan_ctx);
2062
2063 #ifdef HAVE_W32_SYSTEM
2064                 HANDLE handle = (void *)sl->event_signal;
2065                 
2066                 log_info ("client pid is %d, triggering event %lx (%p)\n",
2067                           pid, sl->event_signal, handle);
2068                 if (!SetEvent (handle))
2069                   log_error ("SetEvent(%lx) failed: %s\n",
2070                              sl->event_signal, w32_strerror (-1));
2071 #else
2072                 int signo = sl->event_signal;
2073                 
2074                 log_info ("client pid is %d, sending signal %d\n",
2075                           pid, signo);
2076                 if (pid != (pid_t)(-1) && pid && signo > 0)
2077                   kill (pid, signo);
2078 #endif
2079               }
2080
2081         }
2082     }
2083 }
2084
2085 /* This function is called by the ticker thread to check for changes
2086    of the reader stati.  It updates the reader status files and if
2087    requested by the caller also send a signal to the caller.  */
2088 void
2089 scd_update_reader_status_file (void)
2090 {
2091   if (!pth_mutex_acquire (&status_file_update_lock, 1, NULL))
2092     return; /* locked - give up. */
2093   update_reader_status_file ();
2094   if (!pth_mutex_release (&status_file_update_lock))
2095     log_error ("failed to release status_file_update lock\n");
2096 }