scd: Only submit apdu_get_status when needed.
[gnupg.git] / scd / scdaemon.c
1 /* scdaemon.c  -  The GnuPG Smartcard Daemon
2  * Copyright (C) 2001-2002, 2004-2005, 2007-2009 Free Software Foundation, Inc.
3  * Copyright (C) 2001-2002, 2004-2005, 2007-2014 Werner Koch
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
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <stddef.h>
26 #include <stdarg.h>
27 #include <string.h>
28 #include <errno.h>
29 #include <assert.h>
30 #include <time.h>
31 #include <fcntl.h>
32 #ifndef HAVE_W32_SYSTEM
33 #include <sys/socket.h>
34 #include <sys/un.h>
35 #endif /*HAVE_W32_SYSTEM*/
36 #include <unistd.h>
37 #include <signal.h>
38 #include <npth.h>
39
40 #define GNUPG_COMMON_NEED_AFLOCAL
41 #include "scdaemon.h"
42 #include <ksba.h>
43 #include <gcrypt.h>
44
45 #include <assuan.h> /* malloc hooks */
46
47 #ifdef HAVE_LIBUSB
48 #include <libusb.h>
49 #endif
50
51 #include "i18n.h"
52 #include "sysutils.h"
53 #include "app-common.h"
54 #include "iso7816.h"
55 #include "apdu.h"
56 #include "ccid-driver.h"
57 #include "gc-opt-flags.h"
58 #include "asshelp.h"
59 #include "../common/init.h"
60
61 #ifndef ENAMETOOLONG
62 # define ENAMETOOLONG EINVAL
63 #endif
64
65 enum cmd_and_opt_values
66 { aNull = 0,
67   oCsh            = 'c',
68   oQuiet          = 'q',
69   oSh             = 's',
70   oVerbose        = 'v',
71
72   oNoVerbose = 500,
73   aGPGConfList,
74   aGPGConfTest,
75   oOptions,
76   oDebug,
77   oDebugAll,
78   oDebugLevel,
79   oDebugWait,
80   oDebugAllowCoreDump,
81   oDebugCCIDDriver,
82   oDebugLogTid,
83   oDebugAssuanLogCats,
84   oNoGreeting,
85   oNoOptions,
86   oHomedir,
87   oNoDetach,
88   oNoGrab,
89   oLogFile,
90   oServer,
91   oMultiServer,
92   oDaemon,
93   oBatch,
94   oReaderPort,
95   oCardTimeout,
96   octapiDriver,
97   opcscDriver,
98   oDisableCCID,
99   oDisableOpenSC,
100   oDisablePinpad,
101   oAllowAdmin,
102   oDenyAdmin,
103   oDisableApplication,
104   oEnablePinpadVarlen,
105   oDebugDisableTicker
106 };
107
108
109
110 static ARGPARSE_OPTS opts[] = {
111   ARGPARSE_c (aGPGConfList, "gpgconf-list", "@"),
112   ARGPARSE_c (aGPGConfTest, "gpgconf-test", "@"),
113
114   ARGPARSE_group (301, N_("@Options:\n ")),
115
116   ARGPARSE_s_n (oServer,"server", N_("run in server mode (foreground)")),
117   ARGPARSE_s_n (oMultiServer, "multi-server",
118                 N_("run in multi server mode (foreground)")),
119   ARGPARSE_s_n (oDaemon, "daemon", N_("run in daemon mode (background)")),
120   ARGPARSE_s_n (oVerbose, "verbose", N_("verbose")),
121   ARGPARSE_s_n (oQuiet, "quiet", N_("be somewhat more quiet")),
122   ARGPARSE_s_n (oSh,    "sh", N_("sh-style command output")),
123   ARGPARSE_s_n (oCsh,   "csh", N_("csh-style command output")),
124   ARGPARSE_s_s (oOptions, "options", N_("|FILE|read options from FILE")),
125   ARGPARSE_s_s (oDebug, "debug", "@"),
126   ARGPARSE_s_n (oDebugAll, "debug-all", "@"),
127   ARGPARSE_s_s (oDebugLevel, "debug-level" ,
128                 N_("|LEVEL|set the debugging level to LEVEL")),
129   ARGPARSE_s_i (oDebugWait, "debug-wait", "@"),
130   ARGPARSE_s_n (oDebugAllowCoreDump, "debug-allow-core-dump", "@"),
131   ARGPARSE_s_n (oDebugCCIDDriver, "debug-ccid-driver", "@"),
132   ARGPARSE_s_n (oDebugDisableTicker, "debug-disable-ticker", "@"),
133   ARGPARSE_s_n (oDebugLogTid, "debug-log-tid", "@"),
134   ARGPARSE_p_u (oDebugAssuanLogCats, "debug-assuan-log-cats", "@"),
135   ARGPARSE_s_n (oNoDetach, "no-detach", N_("do not detach from the console")),
136   ARGPARSE_s_s (oLogFile,  "log-file", N_("|FILE|write a log to FILE")),
137   ARGPARSE_s_s (oReaderPort, "reader-port",
138                 N_("|N|connect to reader at port N")),
139   ARGPARSE_s_s (octapiDriver, "ctapi-driver",
140                 N_("|NAME|use NAME as ct-API driver")),
141   ARGPARSE_s_s (opcscDriver, "pcsc-driver",
142                 N_("|NAME|use NAME as PC/SC driver")),
143   ARGPARSE_s_n (oDisableCCID, "disable-ccid",
144 #ifdef HAVE_LIBUSB
145                                     N_("do not use the internal CCID driver")
146 #else
147                                     "@"
148 #endif
149                 /* end --disable-ccid */),
150   ARGPARSE_s_u (oCardTimeout, "card-timeout",
151                 N_("|N|disconnect the card after N seconds of inactivity")),
152
153   ARGPARSE_s_n (oDisablePinpad, "disable-pinpad",
154                 N_("do not use a reader's pinpad")),
155   ARGPARSE_ignore (300, "disable-keypad"),
156
157   ARGPARSE_s_n (oAllowAdmin, "allow-admin", "@"),
158   ARGPARSE_s_n (oDenyAdmin, "deny-admin",
159                 N_("deny the use of admin card commands")),
160   ARGPARSE_s_s (oDisableApplication, "disable-application", "@"),
161   ARGPARSE_s_n (oEnablePinpadVarlen, "enable-pinpad-varlen",
162                 N_("use variable length input for pinpad")),
163   ARGPARSE_s_s (oHomedir,    "homedir",      "@"),
164
165   ARGPARSE_end ()
166 };
167
168
169 /* The list of supported debug flags.  */
170 static struct debug_flags_s debug_flags [] =
171   {
172     { DBG_MPI_VALUE    , "mpi"     },
173     { DBG_CRYPTO_VALUE , "crypto"  },
174     { DBG_MEMORY_VALUE , "memory"  },
175     { DBG_CACHE_VALUE  , "cache"   },
176     { DBG_MEMSTAT_VALUE, "memstat" },
177     { DBG_HASHING_VALUE, "hashing" },
178     { DBG_IPC_VALUE    , "ipc"     },
179     { DBG_CARD_IO_VALUE, "cardio"  },
180     { DBG_READER_VALUE , "reader"  },
181     { 0, NULL }
182   };
183
184
185 /* The card driver we use by default for PC/SC.  */
186 #if defined(HAVE_W32_SYSTEM) || defined(__CYGWIN__)
187 #define DEFAULT_PCSC_DRIVER "winscard.dll"
188 #elif defined(__APPLE__)
189 #define DEFAULT_PCSC_DRIVER "/System/Library/Frameworks/PCSC.framework/PCSC"
190 #elif defined(__GLIBC__)
191 #define DEFAULT_PCSC_DRIVER "libpcsclite.so.1"
192 #else
193 #define DEFAULT_PCSC_DRIVER "libpcsclite.so"
194 #endif
195
196 /* The timer tick used for housekeeping stuff.  We poll every 500ms to
197    let the user immediately know a status change.
198
199    This is not too good for power saving but given that there is no
200    easy way to block on card status changes it is the best we can do.
201    For PC/SC we could in theory use an extra thread to wait for status
202    changes but that requires a native thread because there is no way
203    to make the underlying PC/SC card change function block using a Npth
204    mechanism.  Given that a native thread could only be used under W32
205    we don't do that at all.  */
206 #define TIMERTICK_INTERVAL_SEC     (0)
207 #define TIMERTICK_INTERVAL_USEC    (500000)
208
209 /* Flag to indicate that a shutdown was requested. */
210 static int shutdown_pending;
211
212 /* It is possible that we are currently running under setuid permissions */
213 static int maybe_setuid = 1;
214
215 /* Flag telling whether we are running as a pipe server.  */
216 static int pipe_server;
217
218 /* Name of the communication socket */
219 static char *socket_name;
220 /* Name of the redirected socket or NULL.  */
221 static char *redir_socket_name;
222
223 /* We need to keep track of the server's nonces (these are dummies for
224    POSIX systems). */
225 static assuan_sock_nonce_t socket_nonce;
226
227 /* Debug flag to disable the ticker.  The ticker is in fact not
228    disabled but it won't perform any ticker specific actions. */
229 static int ticker_disabled;
230
231 /* Set of FD to select.  */
232 static fd_set fdset;
233
234 /* Max FD to select.  */
235 static int nfd;
236
237 /* Set if all usb devices have INTERRUPT endpoints.  */
238 static int usb_all_have_intr_endp;
239
240 /* FD to listen incomming connections.  */
241 static int listen_fd;
242 \f
243 static char *create_socket_name (char *standard_name);
244 static gnupg_fd_t create_server_socket (const char *name,
245                                         char **r_redir_name,
246                                         assuan_sock_nonce_t *nonce);
247
248 static void *start_connection_thread (void *arg);
249 static void handle_connections (void);
250
251 /* Pth wrapper function definitions. */
252 ASSUAN_SYSTEM_NPTH_IMPL;
253
254 static int active_connections;
255
256 \f
257 static char *
258 make_libversion (const char *libname, const char *(*getfnc)(const char*))
259 {
260   const char *s;
261   char *result;
262
263   if (maybe_setuid)
264     {
265       gcry_control (GCRYCTL_INIT_SECMEM, 0, 0);  /* Drop setuid. */
266       maybe_setuid = 0;
267     }
268   s = getfnc (NULL);
269   result = xmalloc (strlen (libname) + 1 + strlen (s) + 1);
270   strcpy (stpcpy (stpcpy (result, libname), " "), s);
271   return result;
272 }
273
274
275 static const char *
276 my_strusage (int level)
277 {
278   static char *ver_gcry, *ver_ksba;
279   const char *p;
280
281   switch (level)
282     {
283     case 11: p = "@SCDAEMON@ (@GNUPG@)";
284       break;
285     case 13: p = VERSION; break;
286     case 17: p = PRINTABLE_OS_NAME; break;
287     case 19: p = _("Please report bugs to <@EMAIL@>.\n"); break;
288
289     case 20:
290       if (!ver_gcry)
291         ver_gcry = make_libversion ("libgcrypt", gcry_check_version);
292       p = ver_gcry;
293       break;
294     case 21:
295       if (!ver_ksba)
296         ver_ksba = make_libversion ("libksba", ksba_check_version);
297       p = ver_ksba;
298       break;
299     case 1:
300     case 40: p =  _("Usage: @SCDAEMON@ [options] (-h for help)");
301       break;
302     case 41: p =  _("Syntax: scdaemon [options] [command [args]]\n"
303                     "Smartcard daemon for @GNUPG@\n");
304     break;
305
306     default: p = NULL;
307     }
308   return p;
309 }
310
311
312 static int
313 tid_log_callback (unsigned long *rvalue)
314 {
315   int len = sizeof (*rvalue);
316   npth_t thread;
317
318   thread = npth_self ();
319   if (sizeof (thread) < len)
320     len = sizeof (thread);
321   memcpy (rvalue, &thread, len);
322
323   return 2; /* Use use hex representation.  */
324 }
325
326
327 /* Setup the debugging.  With a LEVEL of NULL only the active debug
328    flags are propagated to the subsystems.  With LEVEL set, a specific
329    set of debug flags is set; thus overriding all flags already
330    set. */
331 static void
332 set_debug (const char *level)
333 {
334   int numok = (level && digitp (level));
335   int numlvl = numok? atoi (level) : 0;
336
337   if (!level)
338     ;
339   else if (!strcmp (level, "none") || (numok && numlvl < 1))
340     opt.debug = 0;
341   else if (!strcmp (level, "basic") || (numok && numlvl <= 2))
342     opt.debug = DBG_IPC_VALUE;
343   else if (!strcmp (level, "advanced") || (numok && numlvl <= 5))
344     opt.debug = DBG_IPC_VALUE;
345   else if (!strcmp (level, "expert") || (numok && numlvl <= 8))
346     opt.debug = (DBG_IPC_VALUE|DBG_CACHE_VALUE|DBG_CARD_IO_VALUE);
347   else if (!strcmp (level, "guru") || numok)
348     {
349       opt.debug = ~0;
350       /* Unless the "guru" string has been used we don't want to allow
351          hashing debugging.  The rationale is that people tend to
352          select the highest debug value and would then clutter their
353          disk with debug files which may reveal confidential data.  */
354       if (numok)
355         opt.debug &= ~(DBG_HASHING_VALUE);
356     }
357   else
358     {
359       log_error (_("invalid debug-level '%s' given\n"), level);
360       scd_exit(2);
361     }
362
363
364   if (opt.debug && !opt.verbose)
365     opt.verbose = 1;
366   if (opt.debug && opt.quiet)
367     opt.quiet = 0;
368
369   if (opt.debug & DBG_MPI_VALUE)
370     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 2);
371   if (opt.debug & DBG_CRYPTO_VALUE )
372     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1);
373   gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
374
375   if (opt.debug)
376     parse_debug_flag (NULL, &opt.debug, debug_flags);
377 }
378
379
380
381 static void
382 cleanup (void)
383 {
384   if (socket_name && *socket_name)
385     {
386       char *name;
387
388       name = redir_socket_name? redir_socket_name : socket_name;
389
390       gnupg_remove (name);
391       *socket_name = 0;
392     }
393 }
394
395
396
397 int
398 main (int argc, char **argv )
399 {
400   ARGPARSE_ARGS pargs;
401   int orig_argc;
402   char **orig_argv;
403   FILE *configfp = NULL;
404   char *configname = NULL;
405   const char *shell;
406   unsigned int configlineno;
407   int parse_debug = 0;
408   const char *debug_level = NULL;
409   int default_config =1;
410   int greeting = 0;
411   int nogreeting = 0;
412   int multi_server = 0;
413   int is_daemon = 0;
414   int nodetach = 0;
415   int csh_style = 0;
416   char *logfile = NULL;
417   int debug_wait = 0;
418   int gpgconf_list = 0;
419   const char *config_filename = NULL;
420   int allow_coredump = 0;
421   struct assuan_malloc_hooks malloc_hooks;
422   int res;
423   npth_t pipecon_handler;
424
425   early_system_init ();
426   set_strusage (my_strusage);
427   gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
428   /* Please note that we may running SUID(ROOT), so be very CAREFUL
429      when adding any stuff between here and the call to INIT_SECMEM()
430      somewhere after the option parsing */
431   log_set_prefix ("scdaemon", GPGRT_LOG_WITH_PREFIX | GPGRT_LOG_WITH_PID);
432
433   /* Make sure that our subsystems are ready.  */
434   i18n_init ();
435   init_common_subsystems (&argc, &argv);
436
437   ksba_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
438
439   malloc_hooks.malloc = gcry_malloc;
440   malloc_hooks.realloc = gcry_realloc;
441   malloc_hooks.free = gcry_free;
442   assuan_set_malloc_hooks (&malloc_hooks);
443   assuan_set_gpg_err_source (GPG_ERR_SOURCE_DEFAULT);
444   assuan_set_system_hooks (ASSUAN_SYSTEM_NPTH);
445   assuan_sock_init ();
446   setup_libassuan_logging (&opt.debug, NULL);
447
448   setup_libgcrypt_logging ();
449   gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
450
451   disable_core_dumps ();
452
453   /* Set default options. */
454   opt.allow_admin = 1;
455   opt.pcsc_driver = DEFAULT_PCSC_DRIVER;
456
457   shell = getenv ("SHELL");
458   if (shell && strlen (shell) >= 3 && !strcmp (shell+strlen (shell)-3, "csh") )
459     csh_style = 1;
460
461   /* Check whether we have a config file on the commandline */
462   orig_argc = argc;
463   orig_argv = argv;
464   pargs.argc = &argc;
465   pargs.argv = &argv;
466   pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
467   while (arg_parse( &pargs, opts))
468     {
469       if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll)
470         parse_debug++;
471       else if (pargs.r_opt == oOptions)
472         { /* yes there is one, so we do not try the default one, but
473              read the option file when it is encountered at the
474              commandline */
475           default_config = 0;
476         }
477         else if (pargs.r_opt == oNoOptions)
478           default_config = 0; /* --no-options */
479         else if (pargs.r_opt == oHomedir)
480           gnupg_set_homedir (pargs.r.ret_str);
481     }
482
483   /* initialize the secure memory. */
484   gcry_control (GCRYCTL_INIT_SECMEM, 16384, 0);
485   maybe_setuid = 0;
486
487   /*
488      Now we are working under our real uid
489   */
490
491
492   if (default_config)
493     configname = make_filename (gnupg_homedir (), SCDAEMON_NAME EXTSEP_S "conf",
494                                 NULL );
495
496
497   argc = orig_argc;
498   argv = orig_argv;
499   pargs.argc = &argc;
500   pargs.argv = &argv;
501   pargs.flags=  1;  /* do not remove the args */
502  next_pass:
503   if (configname)
504     {
505       configlineno = 0;
506       configfp = fopen (configname, "r");
507       if (!configfp)
508         {
509           if (default_config)
510             {
511               if( parse_debug )
512                 log_info (_("Note: no default option file '%s'\n"),
513                           configname );
514             }
515           else
516             {
517               log_error (_("option file '%s': %s\n"),
518                          configname, strerror(errno) );
519               exit(2);
520             }
521           xfree (configname);
522           configname = NULL;
523         }
524       if (parse_debug && configname )
525         log_info (_("reading options from '%s'\n"), configname );
526       default_config = 0;
527     }
528
529   while (optfile_parse( configfp, configname, &configlineno, &pargs, opts) )
530     {
531       switch (pargs.r_opt)
532         {
533         case aGPGConfList: gpgconf_list = 1; break;
534         case aGPGConfTest: gpgconf_list = 2; break;
535         case oQuiet: opt.quiet = 1; break;
536         case oVerbose: opt.verbose++; break;
537         case oBatch: opt.batch=1; break;
538
539         case oDebug:
540           if (parse_debug_flag (pargs.r.ret_str, &opt.debug, debug_flags))
541             {
542               pargs.r_opt = ARGPARSE_INVALID_ARG;
543               pargs.err = ARGPARSE_PRINT_ERROR;
544             }
545           break;
546         case oDebugAll: opt.debug = ~0; break;
547         case oDebugLevel: debug_level = pargs.r.ret_str; break;
548         case oDebugWait: debug_wait = pargs.r.ret_int; break;
549         case oDebugAllowCoreDump:
550           enable_core_dumps ();
551           allow_coredump = 1;
552           break;
553         case oDebugCCIDDriver:
554 #ifdef HAVE_LIBUSB
555           ccid_set_debug_level (ccid_set_debug_level (-1)+1);
556 #endif /*HAVE_LIBUSB*/
557           break;
558         case oDebugDisableTicker: ticker_disabled = 1; break;
559         case oDebugLogTid:
560           log_set_pid_suffix_cb (tid_log_callback);
561           break;
562         case oDebugAssuanLogCats:
563           set_libassuan_log_cats (pargs.r.ret_ulong);
564           break;
565
566         case oOptions:
567           /* config files may not be nested (silently ignore them) */
568           if (!configfp)
569             {
570                 xfree(configname);
571                 configname = xstrdup(pargs.r.ret_str);
572                 goto next_pass;
573             }
574           break;
575         case oNoGreeting: nogreeting = 1; break;
576         case oNoVerbose: opt.verbose = 0; break;
577         case oNoOptions: break; /* no-options */
578         case oHomedir: gnupg_set_homedir (pargs.r.ret_str); break;
579         case oNoDetach: nodetach = 1; break;
580         case oLogFile: logfile = pargs.r.ret_str; break;
581         case oCsh: csh_style = 1; break;
582         case oSh: csh_style = 0; break;
583         case oServer: pipe_server = 1; break;
584         case oMultiServer: pipe_server = 1; multi_server = 1; break;
585         case oDaemon: is_daemon = 1; break;
586
587         case oReaderPort: opt.reader_port = pargs.r.ret_str; break;
588         case octapiDriver: opt.ctapi_driver = pargs.r.ret_str; break;
589         case opcscDriver: opt.pcsc_driver = pargs.r.ret_str; break;
590         case oDisableCCID: opt.disable_ccid = 1; break;
591         case oDisableOpenSC: break;
592
593         case oDisablePinpad: opt.disable_pinpad = 1; break;
594
595         case oAllowAdmin: /* Dummy because allow is now the default.  */
596           break;
597         case oDenyAdmin: opt.allow_admin = 0; break;
598
599         case oCardTimeout: opt.card_timeout = pargs.r.ret_ulong; break;
600
601         case oDisableApplication:
602           add_to_strlist (&opt.disabled_applications, pargs.r.ret_str);
603           break;
604
605         case oEnablePinpadVarlen: opt.enable_pinpad_varlen = 1; break;
606
607         default:
608           pargs.err = configfp? ARGPARSE_PRINT_WARNING:ARGPARSE_PRINT_ERROR;
609           break;
610         }
611     }
612   if (configfp)
613     {
614       fclose( configfp );
615       configfp = NULL;
616       /* Keep a copy of the config name for use by --gpgconf-list. */
617       config_filename = configname;
618       configname = NULL;
619       goto next_pass;
620     }
621   xfree (configname);
622   configname = NULL;
623   if (log_get_errorcount(0))
624     exit(2);
625   if (nogreeting )
626     greeting = 0;
627
628   if (greeting)
629     {
630       es_fprintf (es_stderr, "%s %s; %s\n",
631                   strusage(11), strusage(13), strusage(14) );
632       es_fprintf (es_stderr, "%s\n", strusage(15) );
633     }
634 #ifdef IS_DEVELOPMENT_VERSION
635   log_info ("NOTE: this is a development version!\n");
636 #endif
637
638   /* Print a warning if an argument looks like an option.  */
639   if (!opt.quiet && !(pargs.flags & ARGPARSE_FLAG_STOP_SEEN))
640     {
641       int i;
642
643       for (i=0; i < argc; i++)
644         if (argv[i][0] == '-' && argv[i][1] == '-')
645           log_info (_("Note: '%s' is not considered an option\n"), argv[i]);
646     }
647
648   if (atexit (cleanup))
649     {
650       log_error ("atexit failed\n");
651       cleanup ();
652       exit (1);
653     }
654
655   set_debug (debug_level);
656
657   if (initialize_module_command ())
658     {
659       log_error ("initialization failed\n");
660       cleanup ();
661       exit (1);
662     }
663
664   if (gpgconf_list == 2)
665     scd_exit (0);
666   if (gpgconf_list)
667     {
668       /* List options and default values in the GPG Conf format.  */
669       char *filename = NULL;
670       char *filename_esc;
671
672       if (config_filename)
673         filename = xstrdup (config_filename);
674       else
675         filename = make_filename (gnupg_homedir (),
676                                   SCDAEMON_NAME EXTSEP_S "conf", NULL);
677       filename_esc = percent_escape (filename, NULL);
678
679       es_printf ("%s-%s.conf:%lu:\"%s\n",
680                  GPGCONF_NAME, SCDAEMON_NAME,
681                  GC_OPT_FLAG_DEFAULT, filename_esc);
682       xfree (filename_esc);
683       xfree (filename);
684
685       es_printf ("verbose:%lu:\n"
686                  "quiet:%lu:\n"
687                  "debug-level:%lu:\"none:\n"
688                  "log-file:%lu:\n",
689                  GC_OPT_FLAG_NONE,
690                  GC_OPT_FLAG_NONE,
691                  GC_OPT_FLAG_DEFAULT,
692                  GC_OPT_FLAG_NONE );
693
694       es_printf ("reader-port:%lu:\n", GC_OPT_FLAG_NONE );
695       es_printf ("ctapi-driver:%lu:\n", GC_OPT_FLAG_NONE );
696       es_printf ("pcsc-driver:%lu:\"%s:\n",
697               GC_OPT_FLAG_DEFAULT, DEFAULT_PCSC_DRIVER );
698 #ifdef HAVE_LIBUSB
699       es_printf ("disable-ccid:%lu:\n", GC_OPT_FLAG_NONE );
700 #endif
701       es_printf ("deny-admin:%lu:\n", GC_OPT_FLAG_NONE );
702       es_printf ("disable-pinpad:%lu:\n", GC_OPT_FLAG_NONE );
703       es_printf ("card-timeout:%lu:%d:\n", GC_OPT_FLAG_DEFAULT, 0);
704       es_printf ("enable-pinpad-varlen:%lu:\n", GC_OPT_FLAG_NONE );
705
706       scd_exit (0);
707     }
708
709   /* Now start with logging to a file if this is desired.  */
710   if (logfile)
711     {
712       log_set_file (logfile);
713       log_set_prefix (NULL, GPGRT_LOG_WITH_PREFIX | GPGRT_LOG_WITH_TIME | GPGRT_LOG_WITH_PID);
714     }
715
716   if (debug_wait && pipe_server)
717     {
718       log_debug ("waiting for debugger - my pid is %u .....\n",
719                  (unsigned int)getpid());
720       gnupg_sleep (debug_wait);
721       log_debug ("... okay\n");
722     }
723
724   if (pipe_server)
725     {
726       /* This is the simple pipe based server */
727       ctrl_t ctrl;
728       npth_attr_t tattr;
729       int fd = -1;
730
731 #ifndef HAVE_W32_SYSTEM
732       {
733         struct sigaction sa;
734
735         sa.sa_handler = SIG_IGN;
736         sigemptyset (&sa.sa_mask);
737         sa.sa_flags = 0;
738         sigaction (SIGPIPE, &sa, NULL);
739       }
740 #endif
741
742       npth_init ();
743       gpgrt_set_syscall_clamp (npth_unprotect, npth_protect);
744
745       /* If --debug-allow-core-dump has been given we also need to
746          switch the working directory to a place where we can actually
747          write. */
748       if (allow_coredump)
749         {
750           if (chdir("/tmp"))
751             log_debug ("chdir to '/tmp' failed: %s\n", strerror (errno));
752           else
753             log_debug ("changed working directory to '/tmp'\n");
754         }
755
756       /* In multi server mode we need to listen on an additional
757          socket.  Create that socket now before starting the handler
758          for the pipe connection.  This allows that handler to send
759          back the name of that socket. */
760       if (multi_server)
761         {
762           socket_name = create_socket_name (SCDAEMON_SOCK_NAME);
763           fd = FD2INT(create_server_socket (socket_name,
764                                             &redir_socket_name, &socket_nonce));
765         }
766
767       res = npth_attr_init (&tattr);
768       if (res)
769         {
770           log_error ("error allocating thread attributes: %s\n",
771                      strerror (res));
772           scd_exit (2);
773         }
774       npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
775
776       ctrl = xtrycalloc (1, sizeof *ctrl);
777       if ( !ctrl )
778         {
779           log_error ("error allocating connection control data: %s\n",
780                      strerror (errno) );
781           scd_exit (2);
782         }
783       ctrl->thread_startup.fd = GNUPG_INVALID_FD;
784       res = npth_create (&pipecon_handler, &tattr, start_connection_thread, ctrl);
785       if (res)
786         {
787           log_error ("error spawning pipe connection handler: %s\n",
788                      strerror (res) );
789           xfree (ctrl);
790           scd_exit (2);
791         }
792       npth_setname_np (pipecon_handler, "pipe-connection");
793       npth_attr_destroy (&tattr);
794
795       /* We run handle_connection to wait for the shutdown signal and
796          to run the ticker stuff.  */
797       listen_fd = fd;
798       handle_connections ();
799       if (fd != -1)
800         close (fd);
801     }
802   else if (!is_daemon)
803     {
804       log_info (_("please use the option '--daemon'"
805                   " to run the program in the background\n"));
806     }
807   else
808     { /* Regular server mode */
809       int fd;
810 #ifndef HAVE_W32_SYSTEM
811       pid_t pid;
812       int i;
813 #endif
814
815       /* Create the socket.  */
816       socket_name = create_socket_name (SCDAEMON_SOCK_NAME);
817       fd = FD2INT (create_server_socket (socket_name,
818                                          &redir_socket_name, &socket_nonce));
819
820
821       fflush (NULL);
822 #ifdef HAVE_W32_SYSTEM
823       (void)csh_style;
824       (void)nodetach;
825 #else
826       pid = fork ();
827       if (pid == (pid_t)-1)
828         {
829           log_fatal ("fork failed: %s\n", strerror (errno) );
830           exit (1);
831         }
832       else if (pid)
833         { /* we are the parent */
834           char *infostr;
835
836           close (fd);
837
838           /* create the info string: <name>:<pid>:<protocol_version> */
839           if (gpgrt_asprintf (&infostr, "SCDAEMON_INFO=%s:%lu:1",
840                               socket_name, (ulong) pid) < 0)
841             {
842               log_error ("out of core\n");
843               kill (pid, SIGTERM);
844               exit (1);
845             }
846           *socket_name = 0; /* don't let cleanup() remove the socket -
847                                the child should do this from now on */
848           if (argc)
849             { /* run the program given on the commandline */
850               if (putenv (infostr))
851                 {
852                   log_error ("failed to set environment: %s\n",
853                              strerror (errno) );
854                   kill (pid, SIGTERM );
855                   exit (1);
856                 }
857               execvp (argv[0], argv);
858               log_error ("failed to run the command: %s\n", strerror (errno));
859               kill (pid, SIGTERM);
860               exit (1);
861             }
862           else
863             {
864               /* Print the environment string, so that the caller can use
865                  shell's eval to set it */
866               if (csh_style)
867                 {
868                   *strchr (infostr, '=') = ' ';
869                   es_printf ( "setenv %s;\n", infostr);
870                 }
871               else
872                 {
873                   es_printf ( "%s; export SCDAEMON_INFO;\n", infostr);
874                 }
875               xfree (infostr);
876               exit (0);
877             }
878           /* NOTREACHED */
879         } /* end parent */
880
881       /* This is the child. */
882
883       npth_init ();
884       gpgrt_set_syscall_clamp (npth_unprotect, npth_protect);
885
886       /* Detach from tty and put process into a new session. */
887       if (!nodetach )
888         {
889           /* Close stdin, stdout and stderr unless it is the log stream. */
890           for (i=0; i <= 2; i++)
891             {
892               if (!log_test_fd (i) && i != fd )
893                 {
894                   if ( !close (i)
895                        && open ("/dev/null", i? O_WRONLY : O_RDONLY) == -1)
896                     {
897                       log_error ("failed to open '%s': %s\n",
898                                  "/dev/null", strerror (errno));
899                       cleanup ();
900                       exit (1);
901                     }
902                 }
903             }
904
905           if (setsid() == -1)
906             {
907               log_error ("setsid() failed: %s\n", strerror(errno) );
908               cleanup ();
909               exit (1);
910             }
911         }
912
913       {
914         struct sigaction sa;
915
916         sa.sa_handler = SIG_IGN;
917         sigemptyset (&sa.sa_mask);
918         sa.sa_flags = 0;
919         sigaction (SIGPIPE, &sa, NULL);
920       }
921
922       if (chdir("/"))
923         {
924           log_error ("chdir to / failed: %s\n", strerror (errno));
925           exit (1);
926         }
927
928 #endif /*!HAVE_W32_SYSTEM*/
929
930       listen_fd = fd;
931       handle_connections ();
932
933       close (fd);
934     }
935
936   return 0;
937 }
938
939 void
940 scd_exit (int rc)
941 {
942   apdu_prepare_exit ();
943 #if 0
944 #warning no update_random_seed_file
945   update_random_seed_file();
946 #endif
947 #if 0
948   /* at this time a bit annoying */
949   if (opt.debug & DBG_MEMSTAT_VALUE)
950     {
951       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
952       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
953     }
954   if (opt.debug)
955     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
956 #endif
957   gcry_control (GCRYCTL_TERM_SECMEM );
958   rc = rc? rc : log_get_errorcount(0)? 2 : 0;
959   exit (rc);
960 }
961
962
963 static void
964 scd_init_default_ctrl (ctrl_t ctrl)
965 {
966   (void)ctrl;
967 }
968
969 static void
970 scd_deinit_default_ctrl (ctrl_t ctrl)
971 {
972   if (!ctrl)
973     return;
974   xfree (ctrl->in_data.value);
975   ctrl->in_data.value = NULL;
976   ctrl->in_data.valuelen = 0;
977 }
978
979
980 /* Return the name of the socket to be used to connect to this
981    process.  If no socket is available, return NULL. */
982 const char *
983 scd_get_socket_name ()
984 {
985   if (socket_name && *socket_name)
986     return socket_name;
987   return NULL;
988 }
989
990
991 #ifndef HAVE_W32_SYSTEM
992 static void
993 handle_signal (int signo)
994 {
995   switch (signo)
996     {
997     case SIGHUP:
998       log_info ("SIGHUP received - "
999                 "re-reading configuration and resetting cards\n");
1000 /*       reread_configuration (); */
1001       break;
1002
1003     case SIGUSR1:
1004       log_info ("SIGUSR1 received - printing internal information:\n");
1005       /* Fixme: We need to see how to integrate pth dumping into our
1006          logging system.  */
1007       /* pth_ctrl (PTH_CTRL_DUMPSTATE, log_get_stream ()); */
1008       app_dump_state ();
1009       break;
1010
1011     case SIGUSR2:
1012       log_info ("SIGUSR2 received - no action defined\n");
1013       break;
1014
1015     case SIGTERM:
1016       if (!shutdown_pending)
1017         log_info ("SIGTERM received - shutting down ...\n");
1018       else
1019         log_info ("SIGTERM received - still %i running threads\n",
1020                   active_connections);
1021       shutdown_pending++;
1022       if (shutdown_pending > 2)
1023         {
1024           log_info ("shutdown forced\n");
1025           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
1026           cleanup ();
1027           scd_exit (0);
1028         }
1029       break;
1030
1031     case SIGINT:
1032       log_info ("SIGINT received - immediate shutdown\n");
1033       log_info( "%s %s stopped\n", strusage(11), strusage(13));
1034       cleanup ();
1035       scd_exit (0);
1036       break;
1037
1038     default:
1039       log_info ("signal %d received - no action defined\n", signo);
1040     }
1041 }
1042 #endif /*!HAVE_W32_SYSTEM*/
1043
1044
1045 static void
1046 handle_tick (void)
1047 {
1048   if (!ticker_disabled)
1049     scd_update_reader_status_file ();
1050 }
1051
1052
1053 /* Create a name for the socket.  We check for valid characters as
1054    well as against a maximum allowed length for a unix domain socket
1055    is done.  The function terminates the process in case of an error.
1056    Retunrs: Pointer to an allcoated string with the absolute name of
1057    the socket used.  */
1058 static char *
1059 create_socket_name (char *standard_name)
1060 {
1061   char *name;
1062
1063   name = make_filename (gnupg_socketdir (), standard_name, NULL);
1064   if (strchr (name, PATHSEP_C))
1065     {
1066       log_error (("'%s' are not allowed in the socket name\n"), PATHSEP_S);
1067       scd_exit (2);
1068     }
1069   return name;
1070 }
1071
1072
1073
1074 /* Create a Unix domain socket with NAME.  Returns the file descriptor
1075    or terminates the process in case of an error.  If the socket has
1076    been redirected the name of the real socket is stored as a malloced
1077    string at R_REDIR_NAME. */
1078 static gnupg_fd_t
1079 create_server_socket (const char *name, char **r_redir_name,
1080                       assuan_sock_nonce_t *nonce)
1081 {
1082   struct sockaddr *addr;
1083   struct sockaddr_un *unaddr;
1084   socklen_t len;
1085   gnupg_fd_t fd;
1086   int rc;
1087
1088   xfree (*r_redir_name);
1089   *r_redir_name = NULL;
1090
1091   fd = assuan_sock_new (AF_UNIX, SOCK_STREAM, 0);
1092   if (fd == GNUPG_INVALID_FD)
1093     {
1094       log_error (_("can't create socket: %s\n"), strerror (errno));
1095       scd_exit (2);
1096     }
1097
1098   unaddr = xmalloc (sizeof (*unaddr));
1099   addr = (struct sockaddr*)unaddr;
1100
1101   {
1102     int redirected;
1103
1104     if (assuan_sock_set_sockaddr_un (name, addr, &redirected))
1105       {
1106         if (errno == ENAMETOOLONG)
1107           log_error (_("socket name '%s' is too long\n"), name);
1108         else
1109           log_error ("error preparing socket '%s': %s\n",
1110                      name, gpg_strerror (gpg_error_from_syserror ()));
1111         scd_exit (2);
1112       }
1113     if (redirected)
1114       {
1115         *r_redir_name = xstrdup (unaddr->sun_path);
1116         if (opt.verbose)
1117           log_info ("redirecting socket '%s' to '%s'\n", name, *r_redir_name);
1118       }
1119   }
1120
1121   len = SUN_LEN (unaddr);
1122
1123   rc = assuan_sock_bind (fd, addr, len);
1124   if (rc == -1 && errno == EADDRINUSE)
1125     {
1126       gnupg_remove (unaddr->sun_path);
1127       rc = assuan_sock_bind (fd, addr, len);
1128     }
1129   if (rc != -1
1130       && (rc=assuan_sock_get_nonce (addr, len, nonce)))
1131     log_error (_("error getting nonce for the socket\n"));
1132  if (rc == -1)
1133     {
1134       log_error (_("error binding socket to '%s': %s\n"),
1135                  unaddr->sun_path,
1136                  gpg_strerror (gpg_error_from_syserror ()));
1137       assuan_sock_close (fd);
1138       scd_exit (2);
1139     }
1140
1141   if (gnupg_chmod (unaddr->sun_path, "-rwx"))
1142     log_error (_("can't set permissions of '%s': %s\n"),
1143                unaddr->sun_path, strerror (errno));
1144
1145   if (listen (FD2INT(fd), 5 ) == -1)
1146     {
1147       log_error (_("listen() failed: %s\n"),
1148                  gpg_strerror (gpg_error_from_syserror ()));
1149       assuan_sock_close (fd);
1150       scd_exit (2);
1151     }
1152
1153   if (opt.verbose)
1154     log_info (_("listening on socket '%s'\n"), unaddr->sun_path);
1155
1156   return fd;
1157 }
1158
1159
1160
1161 /* This is the standard connection thread's main function.  */
1162 static void *
1163 start_connection_thread (void *arg)
1164 {
1165   ctrl_t ctrl = arg;
1166
1167   if (ctrl->thread_startup.fd != GNUPG_INVALID_FD
1168       && assuan_sock_check_nonce (ctrl->thread_startup.fd, &socket_nonce))
1169     {
1170       log_info (_("error reading nonce on fd %d: %s\n"),
1171                 FD2INT(ctrl->thread_startup.fd), strerror (errno));
1172       assuan_sock_close (ctrl->thread_startup.fd);
1173       xfree (ctrl);
1174       return NULL;
1175     }
1176
1177   scd_init_default_ctrl (ctrl);
1178   if (opt.verbose)
1179     log_info (_("handler for fd %d started\n"),
1180               FD2INT(ctrl->thread_startup.fd));
1181
1182   /* If this is a pipe server, we request a shutdown if the command
1183      handler asked for it.  With the next ticker event and given that
1184      no other connections are running the shutdown will then
1185      happen.  */
1186   if (scd_command_handler (ctrl, FD2INT(ctrl->thread_startup.fd))
1187       && pipe_server)
1188     shutdown_pending = 1;
1189
1190   if (opt.verbose)
1191     log_info (_("handler for fd %d terminated\n"),
1192               FD2INT (ctrl->thread_startup.fd));
1193
1194   scd_deinit_default_ctrl (ctrl);
1195   xfree (ctrl);
1196   return NULL;
1197 }
1198
1199
1200 void
1201 update_fdset_for_usb (int scanned, int all_have_intr_endp)
1202 {
1203 #ifdef HAVE_LIBUSB
1204   const struct libusb_pollfd **pfd_array = libusb_get_pollfds (NULL);
1205   const struct libusb_pollfd **p;
1206 #endif
1207
1208   if (scanned)
1209     usb_all_have_intr_endp = all_have_intr_endp;
1210
1211   FD_ZERO (&fdset);
1212   nfd = 0;
1213
1214   if (listen_fd != -1)
1215     {
1216       FD_SET (listen_fd, &fdset);
1217       nfd = listen_fd;
1218     }
1219
1220 #ifdef HAVE_LIBUSB
1221   for (p = pfd_array; *p; p++)
1222     {
1223       int fd = (*p)->fd;
1224
1225       FD_SET (fd, &fdset);
1226       if (nfd < fd)
1227         nfd = fd;
1228       p++;
1229     }
1230
1231   libusb_free_pollfds (pfd_array);
1232 #endif
1233
1234   log_debug ("update_fdset_for_usb (%d, %d): %d\n",
1235              scanned, all_have_intr_endp, nfd);
1236 }
1237
1238 static int
1239 need_tick (void)
1240 {
1241   if (shutdown_pending)
1242     return 1;
1243
1244   if (listen_fd != -1 && nfd == listen_fd)
1245     return 1;
1246
1247   if (usb_all_have_intr_endp)
1248     return 0;
1249
1250   return 1;
1251 }
1252
1253 /* Connection handler loop.  Wait for connection requests and spawn a
1254    thread after accepting a connection.  LISTEN_FD is allowed to be -1
1255    in which case this code will only do regular timeouts and handle
1256    signals. */
1257 static void
1258 handle_connections (void)
1259 {
1260   npth_attr_t tattr;
1261   struct sockaddr_un paddr;
1262   socklen_t plen;
1263   fd_set read_fdset;
1264   int ret;
1265   int fd;
1266   struct timespec abstime;
1267   struct timespec curtime;
1268   struct timespec timeout;
1269   struct timespec *t;
1270   int saved_errno;
1271 #ifndef HAVE_W32_SYSTEM
1272   int signo;
1273 #endif
1274
1275   ret = npth_attr_init(&tattr);
1276   /* FIXME: Check error.  */
1277   npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
1278
1279 #ifndef HAVE_W32_SYSTEM
1280   npth_sigev_init ();
1281   npth_sigev_add (SIGHUP);
1282   npth_sigev_add (SIGUSR1);
1283   npth_sigev_add (SIGUSR2);
1284   npth_sigev_add (SIGINT);
1285   npth_sigev_add (SIGTERM);
1286   npth_sigev_fini ();
1287 #endif
1288
1289   FD_ZERO (&fdset);
1290   nfd = 0;
1291   if (listen_fd != -1)
1292     {
1293       FD_SET (listen_fd, &fdset);
1294       nfd = listen_fd;
1295     }
1296
1297   npth_clock_gettime (&curtime);
1298   timeout.tv_sec = TIMERTICK_INTERVAL_SEC;
1299   timeout.tv_nsec = TIMERTICK_INTERVAL_USEC * 1000;
1300   npth_timeradd (&curtime, &timeout, &abstime);
1301   /* We only require abstime here.  The others will be reused.  */
1302
1303   for (;;)
1304     {
1305       if (shutdown_pending)
1306         {
1307           if (active_connections == 0)
1308             break; /* ready */
1309
1310           /* Do not accept anymore connections but wait for existing
1311              connections to terminate. We do this by clearing out all
1312              file descriptors to wait for, so that the select will be
1313              used to just wait on a signal or timeout event. */
1314           FD_ZERO (&fdset);
1315           listen_fd = -1;
1316         }
1317
1318       if (need_tick ())
1319         {
1320           npth_clock_gettime (&curtime);
1321           if (!(npth_timercmp (&curtime, &abstime, <)))
1322             {
1323               /* Timeout.  */
1324               timeout.tv_sec = TIMERTICK_INTERVAL_SEC;
1325               timeout.tv_nsec = TIMERTICK_INTERVAL_USEC * 1000;
1326               npth_timeradd (&curtime, &timeout, &abstime);
1327             }
1328           npth_timersub (&abstime, &curtime, &timeout);
1329           t = &timeout;
1330         }
1331       else
1332         t = NULL;
1333
1334       handle_tick ();
1335
1336       /* POSIX says that fd_set should be implemented as a structure,
1337          thus a simple assignment is fine to copy the entire set.  */
1338       read_fdset = fdset;
1339
1340 #ifndef HAVE_W32_SYSTEM
1341       ret = npth_pselect (nfd+1, &read_fdset, NULL, NULL, t, npth_sigev_sigmask());
1342       saved_errno = errno;
1343
1344       while (npth_sigev_get_pending(&signo))
1345         handle_signal (signo);
1346 #else
1347       ret = npth_eselect (nfd+1, &read_fdset, NULL, NULL, t, NULL, NULL);
1348       saved_errno = errno;
1349 #endif
1350
1351       if (ret == -1 && saved_errno != EINTR)
1352         {
1353           log_error (_("npth_pselect failed: %s - waiting 1s\n"),
1354                      strerror (saved_errno));
1355           npth_sleep (1);
1356           continue;
1357         }
1358
1359       if (ret <= 0)
1360         /* Timeout.  Will be handled when calculating the next timeout.  */
1361         continue;
1362
1363       if (listen_fd != -1 && FD_ISSET (listen_fd, &read_fdset))
1364         {
1365           ctrl_t ctrl;
1366
1367           plen = sizeof paddr;
1368           fd = npth_accept (listen_fd, (struct sockaddr *)&paddr, &plen);
1369           if (fd == -1)
1370             {
1371               log_error ("accept failed: %s\n", strerror (errno));
1372             }
1373           else if ( !(ctrl = xtrycalloc (1, sizeof *ctrl)) )
1374             {
1375               log_error ("error allocating connection control data: %s\n",
1376                          strerror (errno) );
1377               close (fd);
1378             }
1379           else
1380             {
1381               char threadname[50];
1382               npth_t thread;
1383
1384               snprintf (threadname, sizeof threadname, "conn fd=%d", fd);
1385               ctrl->thread_startup.fd = INT2FD (fd);
1386               ret = npth_create (&thread, &tattr, start_connection_thread, ctrl);
1387               if (ret)
1388                 {
1389                   log_error ("error spawning connection handler: %s\n",
1390                              strerror (ret));
1391                   xfree (ctrl);
1392                   close (fd);
1393                 }
1394               else
1395                 npth_setname_np (thread, threadname);
1396             }
1397
1398           ret--;
1399         }
1400
1401 #ifdef HAVE_LIBUSB
1402       if (ret)
1403         {
1404           struct timeval tv = {0, 0};
1405           libusb_handle_events_timeout_completed (NULL, &tv, NULL);
1406         }
1407 #endif
1408     }
1409
1410   cleanup ();
1411   log_info (_("%s %s stopped\n"), strusage(11), strusage(13));
1412   npth_attr_destroy (&tattr);
1413 }