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