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