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