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