Change default gpgsm cipher back to 3DES.
[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
1562 static int
1563 cmd_getinfo (assuan_context_t ctx, char *line)
1564 {
1565   int rc = 0;
1566
1567   if (!strcmp (line, "version"))
1568     {
1569       const char *s = VERSION;
1570       rc = assuan_send_data (ctx, s, strlen (s));
1571     }
1572   else if (!strcmp (line, "pid"))
1573     {
1574       char numbuf[50];
1575
1576       snprintf (numbuf, sizeof numbuf, "%lu", (unsigned long)getpid ());
1577       rc = assuan_send_data (ctx, numbuf, strlen (numbuf));
1578     }
1579   else if (!strcmp (line, "socket_name"))
1580     {
1581       const char *s = scd_get_socket_name ();
1582
1583       if (s)
1584         rc = assuan_send_data (ctx, s, strlen (s));
1585       else
1586         rc = gpg_error (GPG_ERR_NO_DATA);
1587     }
1588   else if (!strcmp (line, "status"))
1589     {
1590       ctrl_t ctrl = assuan_get_pointer (ctx);
1591       int slot = ctrl->reader_slot;
1592       char flag = 'r';
1593
1594       if (!ctrl->server_local->card_removed && slot != -1)
1595         {
1596           struct slot_status_s *ss;
1597           
1598           if (!(slot >= 0 && slot < DIM(slot_table)))
1599             BUG ();
1600
1601           ss = &slot_table[slot];
1602
1603           if (!ss->valid)
1604             BUG ();
1605
1606           if (ss->any && (ss->status & 1))
1607             flag = 'u';
1608         }
1609       rc = assuan_send_data (ctx, &flag, 1);
1610     }
1611   else if (!strcmp (line, "reader_list"))
1612     {
1613 #ifdef HAVE_LIBUSB
1614       char *s = ccid_get_reader_list ();
1615 #else
1616       char *s = NULL;
1617 #endif
1618       
1619       if (s)
1620         rc = assuan_send_data (ctx, s, strlen (s));
1621       else
1622         rc = gpg_error (GPG_ERR_NO_DATA);
1623       xfree (s);
1624     }
1625   else
1626     rc = set_error (GPG_ERR_ASS_PARAMETER, "unknown value for WHAT");
1627   return rc;
1628 }
1629
1630
1631 /* RESTART
1632
1633    Restart the current connection; this is a kind of warm reset.  It
1634    deletes the context used by this connection but does not send a
1635    RESET to the card.  Thus the card itself won't get reset. 
1636
1637    This is used by gpg-agent to reuse a primary pipe connection and
1638    may be used by clients to backup from a conflict in the serial
1639    command; i.e. to select another application. 
1640 */
1641
1642 static int
1643 cmd_restart (assuan_context_t ctx, char *line)
1644 {
1645   ctrl_t ctrl = assuan_get_pointer (ctx);
1646
1647   (void)line;
1648
1649   if (ctrl->app_ctx)
1650     {
1651       release_application (ctrl->app_ctx);
1652       ctrl->app_ctx = NULL;
1653     }
1654   if (locked_session && ctrl->server_local == locked_session)
1655     {
1656       locked_session = NULL;
1657       log_info ("implicitly unlocking due to RESTART\n");
1658     }
1659   return 0;
1660 }
1661
1662
1663 /* DISCONNECT
1664
1665    Disconnect the card if it is not any longer used by other
1666    connections and the backend supports a disconnect operation. 
1667  */
1668 static int
1669 cmd_disconnect (assuan_context_t ctx, char *line)
1670 {
1671   ctrl_t ctrl = assuan_get_pointer (ctx);
1672
1673   (void)line;
1674   
1675   ctrl->server_local->disconnect_allowed = 1;
1676   return 0;
1677 }
1678
1679
1680
1681 /* APDU [--atr] [--more] [hexstring]
1682
1683    Send an APDU to the current reader.  This command bypasses the high
1684    level functions and sends the data directly to the card.  HEXSTRING
1685    is expected to be a proper APDU.  If HEXSTRING is not given no
1686    commands are set to the card but the command will implictly check
1687    whether the card is ready for use. 
1688
1689    Using the option "--atr" returns the ATR of the card as a status
1690    message before any data like this:
1691      S CARD-ATR 3BFA1300FF813180450031C173C00100009000B1
1692
1693    Using the option --more handles the card status word MORE_DATA
1694    (61xx) and concatenate all reponses to one block.
1695
1696  */
1697 static int
1698 cmd_apdu (assuan_context_t ctx, char *line)
1699 {
1700   ctrl_t ctrl = assuan_get_pointer (ctx);
1701   int rc;
1702   unsigned char *apdu;
1703   size_t apdulen;
1704   int with_atr;
1705   int handle_more;
1706
1707   with_atr = has_option (line, "--atr");
1708   handle_more = has_option (line, "--more");
1709
1710   line = skip_options (line);
1711
1712   if ( IS_LOCKED (ctrl) )
1713     return gpg_error (GPG_ERR_LOCKED);
1714
1715   if ((rc = open_card (ctrl, NULL)))
1716     return rc;
1717
1718   if (with_atr)
1719     {
1720       unsigned char *atr;
1721       size_t atrlen;
1722       char hexbuf[400];
1723       
1724       atr = apdu_get_atr (ctrl->reader_slot, &atrlen);
1725       if (!atr || atrlen > sizeof hexbuf - 2 )
1726         {
1727           rc = gpg_error (GPG_ERR_INV_CARD);
1728           goto leave;
1729         }
1730       bin2hex (atr, atrlen, hexbuf);
1731       xfree (atr);
1732       send_status_info (ctrl, "CARD-ATR", hexbuf, strlen (hexbuf), NULL, 0);
1733     }
1734
1735   apdu = hex_to_buffer (line, &apdulen);
1736   if (!apdu)
1737     {
1738       rc = gpg_error_from_syserror ();
1739       goto leave;
1740     }
1741   if (apdulen)
1742     {
1743       unsigned char *result = NULL;
1744       size_t resultlen;
1745
1746       rc = apdu_send_direct (ctrl->reader_slot, apdu, apdulen, handle_more,
1747                              &result, &resultlen);
1748       if (rc)
1749         log_error ("apdu_send_direct failed: %s\n", gpg_strerror (rc));
1750       else
1751         {
1752           rc = assuan_send_data (ctx, result, resultlen);
1753           xfree (result);
1754         }
1755     }
1756   xfree (apdu);
1757
1758  leave:
1759   TEST_CARD_REMOVAL (ctrl, rc);
1760   return rc;
1761 }
1762
1763
1764
1765
1766 \f
1767 /* Tell the assuan library about our commands */
1768 static int
1769 register_commands (assuan_context_t ctx)
1770 {
1771   static struct {
1772     const char *name;
1773     int (*handler)(assuan_context_t, char *line);
1774   } table[] = {
1775     { "SERIALNO",     cmd_serialno },
1776     { "LEARN",        cmd_learn },
1777     { "READCERT",     cmd_readcert },
1778     { "READKEY",      cmd_readkey },
1779     { "SETDATA",      cmd_setdata },
1780     { "PKSIGN",       cmd_pksign },
1781     { "PKAUTH",       cmd_pkauth },
1782     { "PKDECRYPT",    cmd_pkdecrypt },
1783     { "INPUT",        NULL }, 
1784     { "OUTPUT",       NULL }, 
1785     { "GETATTR",      cmd_getattr },
1786     { "SETATTR",      cmd_setattr },
1787     { "WRITECERT",    cmd_writecert },
1788     { "WRITEKEY",     cmd_writekey },
1789     { "GENKEY",       cmd_genkey },
1790     { "RANDOM",       cmd_random },
1791     { "PASSWD",       cmd_passwd },
1792     { "CHECKPIN",     cmd_checkpin },
1793     { "LOCK",         cmd_lock },
1794     { "UNLOCK",       cmd_unlock },
1795     { "GETINFO",      cmd_getinfo },
1796     { "RESTART",      cmd_restart },
1797     { "DISCONNECT",   cmd_disconnect },
1798     { "APDU",         cmd_apdu },
1799     { NULL }
1800   };
1801   int i, rc;
1802
1803   for (i=0; table[i].name; i++)
1804     {
1805       rc = assuan_register_command (ctx, table[i].name, table[i].handler);
1806       if (rc)
1807         return rc;
1808     } 
1809   assuan_set_hello_line (ctx, "GNU Privacy Guard's Smartcard server ready");
1810
1811   assuan_register_reset_notify (ctx, reset_notify);
1812   assuan_register_option_handler (ctx, option_handler);
1813   return 0;
1814 }
1815
1816
1817 /* Startup the server.  If FD is given as -1 this is simple pipe
1818    server, otherwise it is a regular server.  Returns true if there
1819    are no more active asessions.  */
1820 int
1821 scd_command_handler (ctrl_t ctrl, int fd)
1822 {
1823   int rc;
1824   assuan_context_t ctx;
1825   
1826   if (fd == -1)
1827     {
1828       int filedes[2];
1829
1830       filedes[0] = 0;
1831       filedes[1] = 1;
1832       rc = assuan_init_pipe_server (&ctx, filedes);
1833     }
1834   else
1835     {
1836       rc = assuan_init_socket_server_ext (&ctx, INT2FD(fd), 2);
1837     }
1838   if (rc)
1839     {
1840       log_error ("failed to initialize the server: %s\n",
1841                  gpg_strerror(rc));
1842       scd_exit (2);
1843     }
1844   rc = register_commands (ctx);
1845   if (rc)
1846     {
1847       log_error ("failed to register commands with Assuan: %s\n",
1848                  gpg_strerror(rc));
1849       scd_exit (2);
1850     }
1851   assuan_set_pointer (ctx, ctrl);
1852
1853   /* Allocate and initialize the server object.  Put it into the list
1854      of active sessions. */
1855   ctrl->server_local = xcalloc (1, sizeof *ctrl->server_local);
1856   ctrl->server_local->next_session = session_list;
1857   session_list = ctrl->server_local;
1858   ctrl->server_local->ctrl_backlink = ctrl;
1859   ctrl->server_local->assuan_ctx = ctx;
1860
1861   if (DBG_ASSUAN)
1862     assuan_set_log_stream (ctx, log_get_stream ());
1863
1864   /* We open the reader right at startup so that the ticker is able to
1865      update the status file. */
1866   if (ctrl->reader_slot == -1)
1867     {
1868       ctrl->reader_slot = get_reader_slot ();
1869     }
1870
1871   /* Command processing loop. */
1872   for (;;)
1873     {
1874       rc = assuan_accept (ctx);
1875       if (rc == -1)
1876         {
1877           break;
1878         }
1879       else if (rc)
1880         {
1881           log_info ("Assuan accept problem: %s\n", gpg_strerror (rc));
1882           break;
1883         }
1884       
1885       rc = assuan_process (ctx);
1886       if (rc)
1887         {
1888           log_info ("Assuan processing failed: %s\n", gpg_strerror (rc));
1889           continue;
1890         }
1891     }
1892
1893   /* Cleanup.  We don't send an explicit reset to the card.  */
1894   do_reset (ctrl, 0); 
1895
1896   /* Release the server object.  */
1897   if (session_list == ctrl->server_local)
1898     session_list = ctrl->server_local->next_session;
1899   else
1900     {
1901       struct server_local_s *sl;
1902       
1903       for (sl=session_list; sl->next_session; sl = sl->next_session)
1904         if (sl->next_session == ctrl->server_local)
1905           break;
1906       if (!sl->next_session)
1907           BUG ();
1908       sl->next_session = ctrl->server_local->next_session;
1909     }
1910   xfree (ctrl->server_local);
1911   ctrl->server_local = NULL;
1912
1913   /* Release the Assuan context.  */
1914   assuan_deinit_server (ctx);
1915
1916   /* If there are no more sessions return true.  */
1917   return !session_list;
1918 }
1919
1920
1921 /* Send a line with status information via assuan and escape all given
1922    buffers. The variable elements are pairs of (char *, size_t),
1923    terminated with a (NULL, 0). */
1924 void
1925 send_status_info (ctrl_t ctrl, const char *keyword, ...)
1926 {
1927   va_list arg_ptr;
1928   const unsigned char *value;
1929   size_t valuelen;
1930   char buf[950], *p;
1931   size_t n;
1932   assuan_context_t ctx = ctrl->server_local->assuan_ctx;
1933   
1934   va_start (arg_ptr, keyword);
1935
1936   p = buf; 
1937   n = 0;
1938   while ( (value = va_arg (arg_ptr, const unsigned char *)) )
1939     {
1940       valuelen = va_arg (arg_ptr, size_t);
1941       if (!valuelen)
1942         continue; /* empty buffer */
1943       if (n)
1944         {
1945           *p++ = ' ';
1946           n++;
1947         }
1948       for ( ; valuelen && n < DIM (buf)-2; n++, valuelen--, value++)
1949         {
1950           if (*value < ' ' || *value == '+')
1951             {
1952               sprintf (p, "%%%02X", *value);
1953               p += 3;
1954             }
1955           else if (*value == ' ')
1956             *p++ = '+';
1957           else
1958             *p++ = *value;
1959         }
1960     }
1961   *p = 0;
1962   assuan_write_status (ctx, keyword, buf);
1963
1964   va_end (arg_ptr);
1965 }
1966
1967
1968
1969 /* Helper to send the clients a status change notification.  */
1970 static void
1971 send_client_notifications (void)
1972 {
1973   struct {
1974     pid_t pid; 
1975 #ifdef HAVE_W32_SYSTEM
1976     HANDLE handle;
1977 #else
1978     int signo; 
1979 #endif
1980   } killed[50];
1981   int killidx = 0;
1982   int kidx;
1983   struct server_local_s *sl;
1984   
1985   for (sl=session_list; sl; sl = sl->next_session)
1986     {
1987       if (sl->event_signal && sl->assuan_ctx)
1988         {
1989           pid_t pid = assuan_get_pid (sl->assuan_ctx);
1990 #ifdef HAVE_W32_SYSTEM
1991           HANDLE handle = (void *)sl->event_signal;
1992           
1993           for (kidx=0; kidx < killidx; kidx++)
1994             if (killed[kidx].pid == pid 
1995                 && killed[kidx].handle == handle)
1996               break;
1997           if (kidx < killidx)
1998             log_info ("event %lx (%p) already triggered for client %d\n",
1999                       sl->event_signal, handle, (int)pid);
2000           else
2001             {
2002               log_info ("triggering event %lx (%p) for client %d\n",
2003                         sl->event_signal, handle, (int)pid);
2004               if (!SetEvent (handle))
2005                 log_error ("SetEvent(%lx) failed: %s\n",
2006                            sl->event_signal, w32_strerror (-1));
2007               if (killidx < DIM (killed))
2008                 {
2009                   killed[killidx].pid = pid;
2010                   killed[killidx].handle = handle;
2011                   killidx++;
2012                 }
2013             }
2014 #else /*!HAVE_W32_SYSTEM*/
2015           int signo = sl->event_signal;
2016           
2017           if (pid != (pid_t)(-1) && pid && signo > 0)
2018             {
2019               for (kidx=0; kidx < killidx; kidx++)
2020                 if (killed[kidx].pid == pid 
2021                     && killed[kidx].signo == signo)
2022                   break;
2023               if (kidx < killidx)
2024                 log_info ("signal %d already sent to client %d\n",
2025                           signo, (int)pid);
2026               else
2027                 {
2028                   log_info ("sending signal %d to client %d\n",
2029                             signo, (int)pid);
2030                   kill (pid, signo);
2031                   if (killidx < DIM (killed))
2032                     {
2033                       killed[killidx].pid = pid;
2034                       killed[killidx].signo = signo;
2035                       killidx++;
2036                     }
2037                 }
2038             }
2039 #endif /*!HAVE_W32_SYSTEM*/
2040         }
2041     }
2042 }
2043
2044
2045
2046 /* This is the core of scd_update_reader_status_file but the caller
2047    needs to take care of the locking.  */
2048 static void
2049 update_reader_status_file (int set_card_removed_flag)
2050 {
2051   int idx;
2052   unsigned int status, changed;
2053
2054   /* Make sure that the reader has been opened.  Like get_reader_slot,
2055      this part of the code assumes that there is only one reader.  */
2056   if (!slot_table[0].valid)
2057     (void)get_reader_slot ();
2058
2059   /* Note, that we only try to get the status, because it does not
2060      make sense to wait here for a operation to complete.  If we are
2061      busy working with a card, delays in the status file update should
2062      be acceptable. */
2063   for (idx=0; idx < DIM(slot_table); idx++)
2064     {
2065       struct slot_status_s *ss = slot_table + idx;
2066       struct server_local_s *sl;
2067       int sw_apdu;
2068
2069       if (!ss->valid || ss->slot == -1)
2070         continue; /* Not valid or reader not yet open. */
2071       
2072       sw_apdu = apdu_get_status (ss->slot, 0, &status, &changed);
2073       if (sw_apdu)
2074         {
2075           /* Get status failed.  Ignore that.  */
2076           continue; 
2077         }
2078
2079       if (!ss->any || ss->status != status || ss->changed != changed )
2080         {
2081           char *fname;
2082           char templ[50];
2083           FILE *fp;
2084
2085           log_info ("updating slot %d status: 0x%04X->0x%04X (%u->%u)\n",
2086                     ss->slot, ss->status, status, ss->changed, changed);
2087           ss->status = status;
2088           ss->changed = changed;
2089
2090           /* FIXME: Should this be IDX instead of ss->slot?  This
2091              depends on how client sessions will associate the reader
2092              status with their session.  */
2093           snprintf (templ, sizeof templ, "reader_%d.status", ss->slot);
2094           fname = make_filename (opt.homedir, templ, NULL );
2095           fp = fopen (fname, "w");
2096           if (fp)
2097             {
2098               fprintf (fp, "%s\n",
2099                        (status & 1)? "USABLE":
2100                        (status & 4)? "ACTIVE":
2101                        (status & 2)? "PRESENT": "NOCARD");
2102               fclose (fp);
2103             }
2104           xfree (fname);
2105             
2106           /* If a status script is executable, run it. */
2107           {
2108             const char *args[9], *envs[2];
2109             char numbuf1[30], numbuf2[30], numbuf3[30];
2110             char *homestr, *envstr;
2111             gpg_error_t err;
2112             
2113             homestr = make_filename (opt.homedir, NULL);
2114             if (estream_asprintf (&envstr, "GNUPGHOME=%s", homestr) < 0)
2115               log_error ("out of core while building environment\n");
2116             else
2117               {
2118                 envs[0] = envstr;
2119                 envs[1] = NULL;
2120
2121                 sprintf (numbuf1, "%d", ss->slot);
2122                 sprintf (numbuf2, "0x%04X", ss->status);
2123                 sprintf (numbuf3, "0x%04X", status);
2124                 args[0] = "--reader-port";
2125                 args[1] = numbuf1; 
2126                 args[2] = "--old-code";
2127                 args[3] = numbuf2;  
2128                 args[4] = "--new-code";
2129                 args[5] = numbuf3; 
2130                 args[6] = "--status";
2131                 args[7] = ((status & 1)? "USABLE":
2132                            (status & 4)? "ACTIVE":
2133                            (status & 2)? "PRESENT": "NOCARD");
2134                 args[8] = NULL;  
2135
2136                 fname = make_filename (opt.homedir, "scd-event", NULL);
2137                 err = gnupg_spawn_process_detached (fname, args, envs);
2138                 if (err && gpg_err_code (err) != GPG_ERR_ENOENT)
2139                   log_error ("failed to run event handler `%s': %s\n",
2140                              fname, gpg_strerror (err));
2141                 xfree (fname);
2142                 xfree (envstr);
2143               }
2144             xfree (homestr);
2145           }
2146
2147           /* Set the card removed flag for all current sessions.  We
2148              will set this on any card change because a reset or
2149              SERIALNO request must be done in any case.  */
2150           if (ss->any && set_card_removed_flag)
2151             update_card_removed (idx, 1);
2152           
2153           ss->any = 1;
2154
2155           /* Send a signal to all clients who applied for it.  */
2156           send_client_notifications ();
2157         }
2158       
2159       /* Check whether a disconnect is pending.  */
2160       if (opt.card_timeout)
2161         {
2162           for (sl=session_list; sl; sl = sl->next_session)
2163             if (!sl->disconnect_allowed)
2164               break; 
2165           if (session_list && !sl)
2166             {
2167               /* FIXME: Use a real timeout.  */
2168               /* At least one connection and all allow a disconnect.  */
2169               log_info ("disconnecting card in slot %d\n", ss->slot);
2170               apdu_disconnect (ss->slot);
2171             }
2172         }
2173       
2174     }
2175 }
2176
2177 /* This function is called by the ticker thread to check for changes
2178    of the reader stati.  It updates the reader status files and if
2179    requested by the caller also send a signal to the caller.  */
2180 void
2181 scd_update_reader_status_file (void)
2182 {
2183   if (!pth_mutex_acquire (&status_file_update_lock, 1, NULL))
2184     return; /* locked - give up. */
2185   update_reader_status_file (1);
2186   if (!pth_mutex_release (&status_file_update_lock))
2187     log_error ("failed to release status_file_update lock\n");
2188 }