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