scd: Fix for GNU/Linux suspend/resume.
[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
397
398 int
399 main (int argc, char **argv )
400 {
401   ARGPARSE_ARGS pargs;
402   int orig_argc;
403   char **orig_argv;
404   FILE *configfp = NULL;
405   char *configname = NULL;
406   const char *shell;
407   unsigned int configlineno;
408   int parse_debug = 0;
409   const char *debug_level = NULL;
410   int default_config =1;
411   int greeting = 0;
412   int nogreeting = 0;
413   int multi_server = 0;
414   int is_daemon = 0;
415   int nodetach = 0;
416   int csh_style = 0;
417   char *logfile = NULL;
418   int debug_wait = 0;
419   int gpgconf_list = 0;
420   const char *config_filename = NULL;
421   int allow_coredump = 0;
422   struct assuan_malloc_hooks malloc_hooks;
423   int res;
424   npth_t pipecon_handler;
425
426   early_system_init ();
427   set_strusage (my_strusage);
428   gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
429   /* Please note that we may running SUID(ROOT), so be very CAREFUL
430      when adding any stuff between here and the call to INIT_SECMEM()
431      somewhere after the option parsing */
432   log_set_prefix ("scdaemon", GPGRT_LOG_WITH_PREFIX | GPGRT_LOG_WITH_PID);
433
434   /* Make sure that our subsystems are ready.  */
435   i18n_init ();
436   init_common_subsystems (&argc, &argv);
437
438   ksba_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
439
440   malloc_hooks.malloc = gcry_malloc;
441   malloc_hooks.realloc = gcry_realloc;
442   malloc_hooks.free = gcry_free;
443   assuan_set_malloc_hooks (&malloc_hooks);
444   assuan_set_gpg_err_source (GPG_ERR_SOURCE_DEFAULT);
445   assuan_set_system_hooks (ASSUAN_SYSTEM_NPTH);
446   assuan_sock_init ();
447   setup_libassuan_logging (&opt.debug, NULL);
448
449   setup_libgcrypt_logging ();
450   gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
451
452   disable_core_dumps ();
453
454   /* Set default options. */
455   opt.allow_admin = 1;
456   opt.pcsc_driver = DEFAULT_PCSC_DRIVER;
457
458   shell = getenv ("SHELL");
459   if (shell && strlen (shell) >= 3 && !strcmp (shell+strlen (shell)-3, "csh") )
460     csh_style = 1;
461
462   /* Check whether we have a config file on the commandline */
463   orig_argc = argc;
464   orig_argv = argv;
465   pargs.argc = &argc;
466   pargs.argv = &argv;
467   pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
468   while (arg_parse( &pargs, opts))
469     {
470       if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll)
471         parse_debug++;
472       else if (pargs.r_opt == oOptions)
473         { /* yes there is one, so we do not try the default one, but
474              read the option file when it is encountered at the
475              commandline */
476           default_config = 0;
477         }
478         else if (pargs.r_opt == oNoOptions)
479           default_config = 0; /* --no-options */
480         else if (pargs.r_opt == oHomedir)
481           gnupg_set_homedir (pargs.r.ret_str);
482     }
483
484   /* initialize the secure memory. */
485   gcry_control (GCRYCTL_INIT_SECMEM, 16384, 0);
486   maybe_setuid = 0;
487
488   /*
489      Now we are working under our real uid
490   */
491
492
493   if (default_config)
494     configname = make_filename (gnupg_homedir (), SCDAEMON_NAME EXTSEP_S "conf",
495                                 NULL );
496
497
498   argc = orig_argc;
499   argv = orig_argv;
500   pargs.argc = &argc;
501   pargs.argv = &argv;
502   pargs.flags=  1;  /* do not remove the args */
503  next_pass:
504   if (configname)
505     {
506       configlineno = 0;
507       configfp = fopen (configname, "r");
508       if (!configfp)
509         {
510           if (default_config)
511             {
512               if( parse_debug )
513                 log_info (_("Note: no default option file '%s'\n"),
514                           configname );
515             }
516           else
517             {
518               log_error (_("option file '%s': %s\n"),
519                          configname, strerror(errno) );
520               exit(2);
521             }
522           xfree (configname);
523           configname = NULL;
524         }
525       if (parse_debug && configname )
526         log_info (_("reading options from '%s'\n"), configname );
527       default_config = 0;
528     }
529
530   while (optfile_parse( configfp, configname, &configlineno, &pargs, opts) )
531     {
532       switch (pargs.r_opt)
533         {
534         case aGPGConfList: gpgconf_list = 1; break;
535         case aGPGConfTest: gpgconf_list = 2; break;
536         case oQuiet: opt.quiet = 1; break;
537         case oVerbose: opt.verbose++; break;
538         case oBatch: opt.batch=1; break;
539
540         case oDebug:
541           if (parse_debug_flag (pargs.r.ret_str, &opt.debug, debug_flags))
542             {
543               pargs.r_opt = ARGPARSE_INVALID_ARG;
544               pargs.err = ARGPARSE_PRINT_ERROR;
545             }
546           break;
547         case oDebugAll: opt.debug = ~0; break;
548         case oDebugLevel: debug_level = pargs.r.ret_str; break;
549         case oDebugWait: debug_wait = pargs.r.ret_int; break;
550         case oDebugAllowCoreDump:
551           enable_core_dumps ();
552           allow_coredump = 1;
553           break;
554         case oDebugCCIDDriver:
555 #ifdef HAVE_LIBUSB
556           ccid_set_debug_level (ccid_set_debug_level (-1)+1);
557 #endif /*HAVE_LIBUSB*/
558           break;
559         case oDebugLogTid:
560           log_set_pid_suffix_cb (tid_log_callback);
561           break;
562         case oDebugAssuanLogCats:
563           set_libassuan_log_cats (pargs.r.ret_ulong);
564           break;
565
566         case oOptions:
567           /* config files may not be nested (silently ignore them) */
568           if (!configfp)
569             {
570                 xfree(configname);
571                 configname = xstrdup(pargs.r.ret_str);
572                 goto next_pass;
573             }
574           break;
575         case oNoGreeting: nogreeting = 1; break;
576         case oNoVerbose: opt.verbose = 0; break;
577         case oNoOptions: break; /* no-options */
578         case oHomedir: gnupg_set_homedir (pargs.r.ret_str); break;
579         case oNoDetach: nodetach = 1; break;
580         case oLogFile: logfile = pargs.r.ret_str; break;
581         case oCsh: csh_style = 1; break;
582         case oSh: csh_style = 0; break;
583         case oServer: pipe_server = 1; break;
584         case oMultiServer: pipe_server = 1; multi_server = 1; break;
585         case oDaemon: is_daemon = 1; break;
586
587         case oReaderPort: opt.reader_port = pargs.r.ret_str; break;
588         case octapiDriver: opt.ctapi_driver = pargs.r.ret_str; break;
589         case opcscDriver: opt.pcsc_driver = pargs.r.ret_str; break;
590         case oDisableCCID: opt.disable_ccid = 1; break;
591         case oDisableOpenSC: break;
592
593         case oDisablePinpad: opt.disable_pinpad = 1; break;
594
595         case oAllowAdmin: /* Dummy because allow is now the default.  */
596           break;
597         case oDenyAdmin: opt.allow_admin = 0; break;
598
599         case oCardTimeout: opt.card_timeout = pargs.r.ret_ulong; break;
600
601         case oDisableApplication:
602           add_to_strlist (&opt.disabled_applications, pargs.r.ret_str);
603           break;
604
605         case oEnablePinpadVarlen: opt.enable_pinpad_varlen = 1; break;
606
607         case oListenBacklog:
608           listen_backlog = pargs.r.ret_int;
609           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       handle_connections (fd);
802       if (fd != -1)
803         close (fd);
804     }
805   else if (!is_daemon)
806     {
807       log_info (_("please use the option '--daemon'"
808                   " to run the program in the background\n"));
809     }
810   else
811     { /* Regular server mode */
812       int fd;
813 #ifndef HAVE_W32_SYSTEM
814       pid_t pid;
815       int i;
816 #endif
817
818       /* Create the socket.  */
819       socket_name = create_socket_name (SCDAEMON_SOCK_NAME);
820       fd = FD2INT (create_server_socket (socket_name,
821                                          &redir_socket_name, &socket_nonce));
822
823
824       fflush (NULL);
825 #ifdef HAVE_W32_SYSTEM
826       (void)csh_style;
827       (void)nodetach;
828 #else
829       pid = fork ();
830       if (pid == (pid_t)-1)
831         {
832           log_fatal ("fork failed: %s\n", strerror (errno) );
833           exit (1);
834         }
835       else if (pid)
836         { /* we are the parent */
837           char *infostr;
838
839           close (fd);
840
841           /* create the info string: <name>:<pid>:<protocol_version> */
842           if (gpgrt_asprintf (&infostr, "SCDAEMON_INFO=%s:%lu:1",
843                               socket_name, (ulong) pid) < 0)
844             {
845               log_error ("out of core\n");
846               kill (pid, SIGTERM);
847               exit (1);
848             }
849           *socket_name = 0; /* don't let cleanup() remove the socket -
850                                the child should do this from now on */
851           if (argc)
852             { /* run the program given on the commandline */
853               if (putenv (infostr))
854                 {
855                   log_error ("failed to set environment: %s\n",
856                              strerror (errno) );
857                   kill (pid, SIGTERM );
858                   exit (1);
859                 }
860               execvp (argv[0], argv);
861               log_error ("failed to run the command: %s\n", strerror (errno));
862               kill (pid, SIGTERM);
863               exit (1);
864             }
865           else
866             {
867               /* Print the environment string, so that the caller can use
868                  shell's eval to set it */
869               if (csh_style)
870                 {
871                   *strchr (infostr, '=') = ' ';
872                   es_printf ( "setenv %s;\n", infostr);
873                 }
874               else
875                 {
876                   es_printf ( "%s; export SCDAEMON_INFO;\n", infostr);
877                 }
878               xfree (infostr);
879               exit (0);
880             }
881           /* NOTREACHED */
882         } /* end parent */
883
884       /* This is the child. */
885
886       npth_init ();
887       gpgrt_set_syscall_clamp (npth_unprotect, npth_protect);
888
889       /* Detach from tty and put process into a new session. */
890       if (!nodetach )
891         {
892           /* Close stdin, stdout and stderr unless it is the log stream. */
893           for (i=0; i <= 2; i++)
894             {
895               if (!log_test_fd (i) && i != fd )
896                 {
897                   if ( !close (i)
898                        && open ("/dev/null", i? O_WRONLY : O_RDONLY) == -1)
899                     {
900                       log_error ("failed to open '%s': %s\n",
901                                  "/dev/null", strerror (errno));
902                       cleanup ();
903                       exit (1);
904                     }
905                 }
906             }
907
908           if (setsid() == -1)
909             {
910               log_error ("setsid() failed: %s\n", strerror(errno) );
911               cleanup ();
912               exit (1);
913             }
914         }
915
916       {
917         struct sigaction sa;
918
919         sa.sa_handler = SIG_IGN;
920         sigemptyset (&sa.sa_mask);
921         sa.sa_flags = 0;
922         sigaction (SIGPIPE, &sa, NULL);
923       }
924
925 #endif /*!HAVE_W32_SYSTEM*/
926
927       if (gnupg_chdir (gnupg_daemon_rootdir ()))
928         {
929           log_error ("chdir to '%s' failed: %s\n",
930                      gnupg_daemon_rootdir (), strerror (errno));
931           exit (1);
932         }
933
934       handle_connections (fd);
935
936       close (fd);
937     }
938
939   return 0;
940 }
941
942 void
943 scd_exit (int rc)
944 {
945   apdu_prepare_exit ();
946 #if 0
947 #warning no update_random_seed_file
948   update_random_seed_file();
949 #endif
950 #if 0
951   /* at this time a bit annoying */
952   if (opt.debug & DBG_MEMSTAT_VALUE)
953     {
954       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
955       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
956     }
957   if (opt.debug)
958     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
959 #endif
960   gcry_control (GCRYCTL_TERM_SECMEM );
961   rc = rc? rc : log_get_errorcount(0)? 2 : 0;
962   exit (rc);
963 }
964
965
966 static void
967 scd_init_default_ctrl (ctrl_t ctrl)
968 {
969   (void)ctrl;
970 }
971
972 static void
973 scd_deinit_default_ctrl (ctrl_t ctrl)
974 {
975   if (!ctrl)
976     return;
977   xfree (ctrl->in_data.value);
978   ctrl->in_data.value = NULL;
979   ctrl->in_data.valuelen = 0;
980 }
981
982
983 /* Return the name of the socket to be used to connect to this
984    process.  If no socket is available, return NULL. */
985 const char *
986 scd_get_socket_name ()
987 {
988   if (socket_name && *socket_name)
989     return socket_name;
990   return NULL;
991 }
992
993
994 #ifndef HAVE_W32_SYSTEM
995 static void
996 handle_signal (int signo)
997 {
998   switch (signo)
999     {
1000     case SIGHUP:
1001       log_info ("SIGHUP received - "
1002                 "re-reading configuration and resetting cards\n");
1003 /*       reread_configuration (); */
1004       break;
1005
1006     case SIGUSR1:
1007       log_info ("SIGUSR1 received - printing internal information:\n");
1008       /* Fixme: We need to see how to integrate pth dumping into our
1009          logging system.  */
1010       /* pth_ctrl (PTH_CTRL_DUMPSTATE, log_get_stream ()); */
1011       app_dump_state ();
1012       break;
1013
1014     case SIGUSR2:
1015       log_info ("SIGUSR2 received - no action defined\n");
1016       break;
1017
1018     case SIGCONT:
1019       /* Nothing.  */
1020       log_debug ("SIGCONT received - breaking select\n");
1021       break;
1022
1023     case SIGTERM:
1024       if (!shutdown_pending)
1025         log_info ("SIGTERM received - shutting down ...\n");
1026       else
1027         log_info ("SIGTERM received - still %i running threads\n",
1028                   active_connections);
1029       shutdown_pending++;
1030       if (shutdown_pending > 2)
1031         {
1032           log_info ("shutdown forced\n");
1033           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
1034           cleanup ();
1035           scd_exit (0);
1036         }
1037       break;
1038
1039     case SIGINT:
1040       log_info ("SIGINT received - immediate shutdown\n");
1041       log_info( "%s %s stopped\n", strusage(11), strusage(13));
1042       cleanup ();
1043       scd_exit (0);
1044       break;
1045
1046     default:
1047       log_info ("signal %d received - no action defined\n", signo);
1048     }
1049 }
1050 #endif /*!HAVE_W32_SYSTEM*/
1051
1052
1053 /* Create a name for the socket.  We check for valid characters as
1054    well as against a maximum allowed length for a unix domain socket
1055    is done.  The function terminates the process in case of an error.
1056    Retunrs: Pointer to an allcoated string with the absolute name of
1057    the socket used.  */
1058 static char *
1059 create_socket_name (char *standard_name)
1060 {
1061   char *name;
1062
1063   name = make_filename (gnupg_socketdir (), standard_name, NULL);
1064   if (strchr (name, PATHSEP_C))
1065     {
1066       log_error (("'%s' are not allowed in the socket name\n"), PATHSEP_S);
1067       scd_exit (2);
1068     }
1069   return name;
1070 }
1071
1072
1073
1074 /* Create a Unix domain socket with NAME.  Returns the file descriptor
1075    or terminates the process in case of an error.  If the socket has
1076    been redirected the name of the real socket is stored as a malloced
1077    string at R_REDIR_NAME. */
1078 static gnupg_fd_t
1079 create_server_socket (const char *name, char **r_redir_name,
1080                       assuan_sock_nonce_t *nonce)
1081 {
1082   struct sockaddr *addr;
1083   struct sockaddr_un *unaddr;
1084   socklen_t len;
1085   gnupg_fd_t fd;
1086   int rc;
1087
1088   xfree (*r_redir_name);
1089   *r_redir_name = NULL;
1090
1091   fd = assuan_sock_new (AF_UNIX, SOCK_STREAM, 0);
1092   if (fd == GNUPG_INVALID_FD)
1093     {
1094       log_error (_("can't create socket: %s\n"), strerror (errno));
1095       scd_exit (2);
1096     }
1097
1098   unaddr = xmalloc (sizeof (*unaddr));
1099   addr = (struct sockaddr*)unaddr;
1100
1101   {
1102     int redirected;
1103
1104     if (assuan_sock_set_sockaddr_un (name, addr, &redirected))
1105       {
1106         if (errno == ENAMETOOLONG)
1107           log_error (_("socket name '%s' is too long\n"), name);
1108         else
1109           log_error ("error preparing socket '%s': %s\n",
1110                      name, gpg_strerror (gpg_error_from_syserror ()));
1111         scd_exit (2);
1112       }
1113     if (redirected)
1114       {
1115         *r_redir_name = xstrdup (unaddr->sun_path);
1116         if (opt.verbose)
1117           log_info ("redirecting socket '%s' to '%s'\n", name, *r_redir_name);
1118       }
1119   }
1120
1121   len = SUN_LEN (unaddr);
1122
1123   rc = assuan_sock_bind (fd, addr, len);
1124   if (rc == -1 && errno == EADDRINUSE)
1125     {
1126       gnupg_remove (unaddr->sun_path);
1127       rc = assuan_sock_bind (fd, addr, len);
1128     }
1129   if (rc != -1
1130       && (rc=assuan_sock_get_nonce (addr, len, nonce)))
1131     log_error (_("error getting nonce for the socket\n"));
1132  if (rc == -1)
1133     {
1134       log_error (_("error binding socket to '%s': %s\n"),
1135                  unaddr->sun_path,
1136                  gpg_strerror (gpg_error_from_syserror ()));
1137       assuan_sock_close (fd);
1138       scd_exit (2);
1139     }
1140
1141   if (gnupg_chmod (unaddr->sun_path, "-rwx"))
1142     log_error (_("can't set permissions of '%s': %s\n"),
1143                unaddr->sun_path, strerror (errno));
1144
1145   if (listen (FD2INT(fd), listen_backlog) == -1)
1146     {
1147       log_error ("listen(fd, %d) failed: %s\n",
1148                  listen_backlog, gpg_strerror (gpg_error_from_syserror ()));
1149       assuan_sock_close (fd);
1150       scd_exit (2);
1151     }
1152
1153   if (opt.verbose)
1154     log_info (_("listening on socket '%s'\n"), unaddr->sun_path);
1155
1156   return fd;
1157 }
1158
1159
1160
1161 /* This is the standard connection thread's main function.  */
1162 static void *
1163 start_connection_thread (void *arg)
1164 {
1165   ctrl_t ctrl = arg;
1166
1167   if (ctrl->thread_startup.fd != GNUPG_INVALID_FD
1168       && assuan_sock_check_nonce (ctrl->thread_startup.fd, &socket_nonce))
1169     {
1170       log_info (_("error reading nonce on fd %d: %s\n"),
1171                 FD2INT(ctrl->thread_startup.fd), strerror (errno));
1172       assuan_sock_close (ctrl->thread_startup.fd);
1173       xfree (ctrl);
1174       return NULL;
1175     }
1176
1177   active_connections++;
1178
1179   scd_init_default_ctrl (ctrl);
1180   if (opt.verbose)
1181     log_info (_("handler for fd %d started\n"),
1182               FD2INT(ctrl->thread_startup.fd));
1183
1184   /* If this is a pipe server, we request a shutdown if the command
1185      handler asked for it.  With the next ticker event and given that
1186      no other connections are running the shutdown will then
1187      happen.  */
1188   if (scd_command_handler (ctrl, FD2INT(ctrl->thread_startup.fd))
1189       && pipe_server)
1190     shutdown_pending = 1;
1191
1192   if (opt.verbose)
1193     log_info (_("handler for fd %d terminated\n"),
1194               FD2INT (ctrl->thread_startup.fd));
1195
1196   scd_deinit_default_ctrl (ctrl);
1197   xfree (ctrl);
1198
1199   if (--active_connections == 0)
1200     scd_kick_the_loop ();
1201
1202   return NULL;
1203 }
1204
1205
1206 void
1207 scd_kick_the_loop (void)
1208 {
1209   /* Kick the select loop.  */
1210 #ifdef HAVE_W32_SYSTEM
1211   int ret = SetEvent (the_event);
1212   if (ret == 0)
1213     log_error ("SetEvent for scd_kick_the_loop failed: %s\n",
1214                w32_strerror (-1));
1215 #elif defined(HAVE_PSELECT_NO_EINTR)
1216   write (notify_fd, "", 1);
1217 #else
1218   int ret = kill (main_thread_pid, SIGCONT);
1219   if (ret < 0)
1220     log_error ("SetEvent for scd_kick_the_loop failed: %s\n",
1221                gpg_strerror (gpg_error_from_syserror ()));
1222 #endif
1223 }
1224
1225 /* Connection handler loop.  Wait for connection requests and spawn a
1226    thread after accepting a connection.  LISTEN_FD is allowed to be -1
1227    in which case this code will only do regular timeouts and handle
1228    signals. */
1229 static void
1230 handle_connections (int listen_fd)
1231 {
1232   npth_attr_t tattr;
1233   struct sockaddr_un paddr;
1234   socklen_t plen;
1235   fd_set fdset, read_fdset;
1236   int nfd;
1237   int ret;
1238   int fd;
1239   struct timespec timeout;
1240   struct timespec *t;
1241   int saved_errno;
1242 #ifdef HAVE_W32_SYSTEM
1243   HANDLE events[2];
1244   unsigned int events_set;
1245 #else
1246   int signo;
1247 #endif
1248 #ifdef HAVE_PSELECT_NO_EINTR
1249   int pipe_fd[2];
1250
1251   ret = gnupg_create_pipe (pipe_fd);
1252   if (ret)
1253     {
1254       log_error ("pipe creation failed: %s\n", gpg_strerror (ret));
1255       return;
1256     }
1257   notify_fd = pipe_fd[1];
1258 #endif
1259
1260   ret = npth_attr_init(&tattr);
1261   if (ret)
1262     {
1263       log_error ("npth_attr_init failed: %s\n", strerror (ret));
1264       return;
1265     }
1266
1267   npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
1268
1269 #ifdef HAVE_W32_SYSTEM
1270   {
1271     HANDLE h, h2;
1272     SECURITY_ATTRIBUTES sa = { sizeof (SECURITY_ATTRIBUTES), NULL, TRUE};
1273
1274     events[0] = the_event = INVALID_HANDLE_VALUE;
1275     events[1] = INVALID_HANDLE_VALUE;
1276     h = CreateEvent (&sa, TRUE, FALSE, NULL);
1277     if (!h)
1278       log_error ("can't create scd event: %s\n", w32_strerror (-1) );
1279     else if (!DuplicateHandle (GetCurrentProcess(), h,
1280                                GetCurrentProcess(), &h2,
1281                                EVENT_MODIFY_STATE|SYNCHRONIZE, TRUE, 0))
1282       {
1283         log_error ("setting synchronize for scd_kick_the_loop failed: %s\n",
1284                    w32_strerror (-1) );
1285         CloseHandle (h);
1286       }
1287     else
1288       {
1289         CloseHandle (h);
1290         events[0] = the_event = h2;
1291       }
1292   }
1293 #else
1294   npth_sigev_init ();
1295   npth_sigev_add (SIGHUP);
1296   npth_sigev_add (SIGUSR1);
1297   npth_sigev_add (SIGUSR2);
1298   npth_sigev_add (SIGINT);
1299   npth_sigev_add (SIGCONT);
1300   npth_sigev_add (SIGTERM);
1301   npth_sigev_fini ();
1302   main_thread_pid = getpid ();
1303 #endif
1304
1305   FD_ZERO (&fdset);
1306   nfd = 0;
1307   if (listen_fd != -1)
1308     {
1309       FD_SET (listen_fd, &fdset);
1310       nfd = listen_fd;
1311     }
1312
1313   for (;;)
1314     {
1315       int periodical_check;
1316       int max_fd = nfd;
1317
1318       if (shutdown_pending)
1319         {
1320           if (active_connections == 0)
1321             break; /* ready */
1322
1323           /* Do not accept anymore connections but wait for existing
1324              connections to terminate. We do this by clearing out all
1325              file descriptors to wait for, so that the select will be
1326              used to just wait on a signal or timeout event. */
1327           FD_ZERO (&fdset);
1328           listen_fd = -1;
1329         }
1330
1331       periodical_check = scd_update_reader_status_file ();
1332
1333       timeout.tv_sec = TIMERTICK_INTERVAL_SEC;
1334       timeout.tv_nsec = TIMERTICK_INTERVAL_USEC * 1000;
1335
1336       if (shutdown_pending || periodical_check)
1337         t = &timeout;
1338       else
1339         t = NULL;
1340
1341       /* POSIX says that fd_set should be implemented as a structure,
1342          thus a simple assignment is fine to copy the entire set.  */
1343       read_fdset = fdset;
1344
1345 #ifdef HAVE_PSELECT_NO_EINTR
1346       FD_SET (pipe_fd[0], &read_fdset);
1347       if (max_fd < pipe_fd[0])
1348         max_fd = pipe_fd[0];
1349 #else
1350       (void)max_fd;
1351 #endif
1352
1353 #ifndef HAVE_W32_SYSTEM
1354       ret = npth_pselect (max_fd+1, &read_fdset, NULL, NULL, t,
1355                           npth_sigev_sigmask ());
1356       saved_errno = errno;
1357
1358       while (npth_sigev_get_pending(&signo))
1359         handle_signal (signo);
1360 #else
1361       ret = npth_eselect (nfd+1, &read_fdset, NULL, NULL, t,
1362                           events, &events_set);
1363       saved_errno = errno;
1364       if (events_set & 1)
1365         continue;
1366 #endif
1367
1368       if (ret == -1 && saved_errno != EINTR)
1369         {
1370           log_error (_("npth_pselect failed: %s - waiting 1s\n"),
1371                      strerror (saved_errno));
1372           npth_sleep (1);
1373           continue;
1374         }
1375
1376       if (ret <= 0)
1377         /* Timeout.  Will be handled when calculating the next timeout.  */
1378         continue;
1379
1380 #ifdef HAVE_PSELECT_NO_EINTR
1381       if (FD_ISSET (pipe_fd[0], &read_fdset))
1382         {
1383           char buf[256];
1384
1385           read (pipe_fd[0], buf, sizeof buf);
1386         }
1387 #endif
1388
1389       if (listen_fd != -1 && FD_ISSET (listen_fd, &read_fdset))
1390         {
1391           ctrl_t ctrl;
1392
1393           plen = sizeof paddr;
1394           fd = npth_accept (listen_fd, (struct sockaddr *)&paddr, &plen);
1395           if (fd == -1)
1396             {
1397               log_error ("accept failed: %s\n", strerror (errno));
1398             }
1399           else if ( !(ctrl = xtrycalloc (1, sizeof *ctrl)) )
1400             {
1401               log_error ("error allocating connection control data: %s\n",
1402                          strerror (errno) );
1403               close (fd);
1404             }
1405           else
1406             {
1407               char threadname[50];
1408               npth_t thread;
1409
1410               snprintf (threadname, sizeof threadname, "conn fd=%d", fd);
1411               ctrl->thread_startup.fd = INT2FD (fd);
1412               ret = npth_create (&thread, &tattr, start_connection_thread, ctrl);
1413               if (ret)
1414                 {
1415                   log_error ("error spawning connection handler: %s\n",
1416                              strerror (ret));
1417                   xfree (ctrl);
1418                   close (fd);
1419                 }
1420               else
1421                 npth_setname_np (thread, threadname);
1422             }
1423         }
1424     }
1425
1426 #ifdef HAVE_W32_SYSTEM
1427   if (the_event != INVALID_HANDLE_VALUE)
1428     CloseHandle (the_event);
1429 #endif
1430 #ifdef HAVE_PSELECT_NO_EINTR
1431   close (pipe_fd[0]);
1432   close (pipe_fd[1]);
1433 #endif
1434   cleanup ();
1435   log_info (_("%s %s stopped\n"), strusage(11), strusage(13));
1436   npth_attr_destroy (&tattr);
1437 }
1438
1439 /* Return the number of active connections. */
1440 int
1441 get_active_connection_count (void)
1442 {
1443   return active_connections;
1444 }