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