New debugging optionhs, updates to the manual.
[gnupg.git] / scd / scdaemon.c
1 /* scdaemon.c  -  The GnuPG Smartcard Daemon
2  *      Copyright (C) 2001, 2002, 2004, 2005 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
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 <pth.h>
39
40 #define JNLIB_NEED_LOG_LOGV
41 #include "scdaemon.h"
42 #include <ksba.h>
43 #include <gcrypt.h>
44
45 #include <assuan.h> /* malloc hooks */
46
47 #include "i18n.h"
48 #include "sysutils.h"
49 #include "app-common.h"
50 #ifdef HAVE_W32_SYSTEM
51 #include "../jnlib/w32-afunix.h"
52 #endif
53 #include "ccid-driver.h"
54 #include "mkdtemp.h"
55
56 enum cmd_and_opt_values 
57 { aNull = 0,
58   oCsh            = 'c',
59   oQuiet          = 'q',
60   oSh             = 's',
61   oVerbose        = 'v',
62   
63   oNoVerbose = 500,
64   aGPGConfList,
65   oOptions,
66   oDebug,
67   oDebugAll,
68   oDebugLevel,
69   oDebugWait,
70   oDebugAllowCoreDump,
71   oDebugCCIDDriver,
72   oNoGreeting,
73   oNoOptions,
74   oHomedir,
75   oNoDetach,
76   oNoGrab,
77   oLogFile,
78   oServer,
79   oMultiServer,
80   oDaemon,
81   oBatch,
82   oReaderPort,
83   octapiDriver,
84   opcscDriver,
85   oDisableCCID,
86   oDisableOpenSC,
87   oAllowAdmin,
88   oDenyAdmin,
89   oDisableApplication,
90   oDebugDisableTicker
91 };
92
93
94
95 static ARGPARSE_OPTS opts[] = {
96
97   { aGPGConfList, "gpgconf-list", 256, "@" },
98   
99   { 301, NULL, 0, N_("@Options:\n ") },
100
101   { oServer,   "server",     0, N_("run in server mode (foreground)") },
102   { oMultiServer, "multi-server", 0,
103                                 N_("run in multi server mode (foreground)") },
104   { oDaemon,   "daemon",     0, N_("run in daemon mode (background)") },
105   { oVerbose, "verbose",   0, N_("verbose") },
106   { oQuiet,     "quiet",     0, N_("be somewhat more quiet") },
107   { oSh,        "sh",        0, N_("sh-style command output") },
108   { oCsh,       "csh",       0, N_("csh-style command output") },
109   { oOptions, "options"  , 2, N_("read options from file")},
110   { oDebug,     "debug"     ,4|16, "@"},
111   { oDebugAll, "debug-all"     ,0, "@"},
112   { oDebugLevel, "debug-level" ,2, "@"},
113   { oDebugWait,"debug-wait",1, "@"},
114   { oDebugAllowCoreDump, "debug-allow-core-dump", 0, "@" },
115   { oDebugCCIDDriver, "debug-ccid-driver", 0, "@"},
116   { oDebugDisableTicker, "debug-disable-ticker", 0, "@"},
117   { oNoDetach, "no-detach" ,0, N_("do not detach from the console")},
118   { oLogFile,  "log-file"   ,2, N_("use a log file for the server")},
119   { oReaderPort, "reader-port", 2, N_("|N|connect to reader at port N")},
120   { octapiDriver, "ctapi-driver", 2, N_("|NAME|use NAME as ct-API driver")},
121   { opcscDriver, "pcsc-driver", 2, N_("|NAME|use NAME as PC/SC driver")},
122   { oDisableCCID, "disable-ccid", 0,
123 #ifdef HAVE_LIBUSB
124                                     N_("do not use the internal CCID driver")
125 #else
126                                     "@"
127 #endif
128                                          /* end --disable-ccid */},
129   { oAllowAdmin, "allow-admin", 0, N_("allow the use of admin card commands")},
130   { oDenyAdmin,  "deny-admin",  0, "@" },  
131   { oDisableApplication, "disable-application", 2, "@"},
132
133   {0}
134 };
135
136
137 /* The card dirver we use by default for PC/SC.  */
138 #ifdef HAVE_W32_SYSTEM
139 #define DEFAULT_PCSC_DRIVER "winscard.dll"
140 #else
141 #define DEFAULT_PCSC_DRIVER "libpcsclite.so"
142 #endif
143
144
145 /* Flag to indicate that a shutdown was requested. */
146 static int shutdown_pending;
147
148 /* It is possible that we are currently running under setuid permissions */
149 static int maybe_setuid = 1;
150
151 /* Name of the communication socket */
152 static char *socket_name;
153
154
155 /* Debug flag to disable the ticker.  The ticker is in fact not
156    disabled but it won't perform any ticker specific actions. */
157 static int ticker_disabled;
158
159
160 \f
161 static char *create_socket_name (int use_standard_socket,
162                                  char *standard_name, char *template);
163 static int create_server_socket (int is_standard_name, const char *name);
164
165 static void *start_connection_thread (void *arg);
166 static void handle_connections (int listen_fd);
167
168 /* Pth wrapper function definitions. */
169 GCRY_THREAD_OPTION_PTH_IMPL;
170
171
172 \f
173 static const char *
174 my_strusage (int level)
175 {
176   const char *p;
177   switch (level)
178     {
179     case 11: p = "scdaemon (GnuPG)";
180       break;
181     case 13: p = VERSION; break;
182     case 17: p = PRINTABLE_OS_NAME; break;
183     case 19: p = _("Please report bugs to <" PACKAGE_BUGREPORT ">.\n");
184       break;
185     case 1:
186     case 40: p =  _("Usage: scdaemon [options] (-h for help)");
187       break;
188     case 41: p =  _("Syntax: scdaemon [options] [command [args]]\n"
189                     "Smartcard daemon for GnuPG\n");
190     break;
191     
192     default: p = NULL;
193     }
194   return p;
195 }
196
197
198
199 static void
200 i18n_init (void)
201 {
202 #ifdef USE_SIMPLE_GETTEXT
203     set_gettext_file( PACKAGE_GT );
204 #else
205 #ifdef ENABLE_NLS
206     setlocale (LC_ALL, "");
207     bindtextdomain (PACKAGE_GT, LOCALEDIR);
208     textdomain (PACKAGE_GT);
209 #endif
210 #endif
211 }
212
213
214
215 /* Used by gcry for logging */
216 static void
217 my_gcry_logger (void *dummy, int level, const char *fmt, va_list arg_ptr)
218 {
219   /* translate the log levels */
220   switch (level)
221     {
222     case GCRY_LOG_CONT: level = JNLIB_LOG_CONT; break;
223     case GCRY_LOG_INFO: level = JNLIB_LOG_INFO; break;
224     case GCRY_LOG_WARN: level = JNLIB_LOG_WARN; break;
225     case GCRY_LOG_ERROR:level = JNLIB_LOG_ERROR; break;
226     case GCRY_LOG_FATAL:level = JNLIB_LOG_FATAL; break;
227     case GCRY_LOG_BUG:  level = JNLIB_LOG_BUG; break;
228     case GCRY_LOG_DEBUG:level = JNLIB_LOG_DEBUG; break;
229     default:            level = JNLIB_LOG_ERROR; break;  
230     }
231   log_logv (level, fmt, arg_ptr);
232 }
233
234
235 /* Setup the debugging.  With a LEVEL of NULL only the active debug
236    flags are propagated to the subsystems.  With LEVEL set, a specific
237    set of debug flags is set; thus overriding all flags already
238    set. */
239 static void
240 set_debug (const char *level)
241 {
242   if (!level)
243     ;
244   else if (!strcmp (level, "none"))
245     opt.debug = 0;
246   else if (!strcmp (level, "basic"))
247     opt.debug = DBG_ASSUAN_VALUE;
248   else if (!strcmp (level, "advanced"))
249     opt.debug = DBG_ASSUAN_VALUE|DBG_COMMAND_VALUE;
250   else if (!strcmp (level, "expert"))
251     opt.debug = (DBG_ASSUAN_VALUE|DBG_COMMAND_VALUE
252                  |DBG_CACHE_VALUE|DBG_CARD_IO_VALUE);
253   else if (!strcmp (level, "guru"))
254     opt.debug = ~0;
255   else
256     {
257       log_error (_("invalid debug-level `%s' given\n"), level);
258       scd_exit(2);
259     }
260
261
262   if (opt.debug && !opt.verbose)
263     opt.verbose = 1;
264   if (opt.debug && opt.quiet)
265     opt.quiet = 0;
266
267   if (opt.debug & DBG_MPI_VALUE)
268     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 2);
269   if (opt.debug & DBG_CRYPTO_VALUE )
270     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1);
271   gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
272 }
273  
274
275
276 static void
277 cleanup (void)
278 {
279   if (socket_name && *socket_name)
280     {
281       char *p;
282
283       remove (socket_name);
284       p = strrchr (socket_name, '/');
285       if (p)
286         {
287           *p = 0;
288           rmdir (socket_name);
289           *p = '/';
290         }
291       *socket_name = 0;
292     }
293 }
294
295
296
297 int
298 main (int argc, char **argv )
299 {
300   ARGPARSE_ARGS pargs;
301   int orig_argc;
302   gpg_error_t err;
303   int may_coredump;
304   char **orig_argv;
305   FILE *configfp = NULL;
306   char *configname = NULL;
307   const char *shell;
308   unsigned configlineno;
309   int parse_debug = 0;
310   const char *debug_level = NULL;
311   int default_config =1;
312   int greeting = 0;
313   int nogreeting = 0;
314   int pipe_server = 0;
315   int multi_server = 0;
316   int is_daemon = 0;
317   int nodetach = 0;
318   int csh_style = 0;
319   char *logfile = NULL;
320   int debug_wait = 0;
321   int gpgconf_list = 0;
322   const char *config_filename = NULL;
323   int allow_coredump = 0;
324
325   set_strusage (my_strusage);
326   gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
327   /* Please note that we may running SUID(ROOT), so be very CAREFUL
328      when adding any stuff between here and the call to INIT_SECMEM()
329      somewhere after the option parsing */
330   log_set_prefix ("scdaemon", 1|4); 
331   /* Try to auto set the character set.  */
332   set_native_charset (NULL); 
333
334   i18n_init ();
335
336   /* Libgcrypt requires us to register the threading model first.
337      Note that this will also do the pth_init. */
338   err = gcry_control (GCRYCTL_SET_THREAD_CBS, &gcry_threads_pth);
339   if (err)
340     {
341       log_fatal ("can't register GNU Pth with Libgcrypt: %s\n",
342                  gpg_strerror (err));
343     }
344
345   /* Check that the libraries are suitable.  Do it here because
346      the option parsing may need services of the library */
347   if (!gcry_check_version (NEED_LIBGCRYPT_VERSION) )
348     {
349       log_fatal( _("libgcrypt is too old (need %s, have %s)\n"),
350                  NEED_LIBGCRYPT_VERSION, gcry_check_version (NULL) );
351     }
352
353   ksba_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
354
355   assuan_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
356   assuan_set_assuan_log_stream (log_get_stream ());
357   assuan_set_assuan_log_prefix (log_get_prefix (NULL));
358
359   gcry_set_log_handler (my_gcry_logger, NULL);
360   gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
361
362   may_coredump = disable_core_dumps ();
363
364   /* Set default options. */
365   opt.pcsc_driver = DEFAULT_PCSC_DRIVER; 
366
367
368   shell = getenv ("SHELL");
369   if (shell && strlen (shell) >= 3 && !strcmp (shell+strlen (shell)-3, "csh") )
370     csh_style = 1;
371   
372   opt.homedir = default_homedir ();
373
374   /* Check whether we have a config file on the commandline */
375   orig_argc = argc;
376   orig_argv = argv;
377   pargs.argc = &argc;
378   pargs.argv = &argv;
379   pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
380   while (arg_parse( &pargs, opts))
381     {
382       if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll)
383         parse_debug++;
384       else if (pargs.r_opt == oOptions)
385         { /* yes there is one, so we do not try the default one, but
386              read the option file when it is encountered at the
387              commandline */
388           default_config = 0;
389         }
390         else if (pargs.r_opt == oNoOptions)
391           default_config = 0; /* --no-options */
392         else if (pargs.r_opt == oHomedir)
393           opt.homedir = pargs.r.ret_str;
394     }
395
396   /* initialize the secure memory. */
397   gcry_control (GCRYCTL_INIT_SECMEM, 16384, 0);
398   maybe_setuid = 0;
399
400   /* 
401      Now we are working under our real uid 
402   */
403
404
405   if (default_config)
406     configname = make_filename (opt.homedir, "scdaemon.conf", NULL );
407
408   
409   argc = orig_argc;
410   argv = orig_argv;
411   pargs.argc = &argc;
412   pargs.argv = &argv;
413   pargs.flags=  1;  /* do not remove the args */
414  next_pass:
415   if (configname)
416     {
417       configlineno = 0;
418       configfp = fopen (configname, "r");
419       if (!configfp)
420         {
421           if (default_config)
422             {
423               if( parse_debug )
424                 log_info (_("NOTE: no default option file `%s'\n"),
425                           configname );
426             }
427           else
428             {
429               log_error (_("option file `%s': %s\n"),
430                          configname, strerror(errno) );
431               exit(2);
432             }
433           xfree (configname); 
434           configname = NULL;
435         }
436       if (parse_debug && configname )
437         log_info (_("reading options from `%s'\n"), configname );
438       default_config = 0;
439     }
440
441   while (optfile_parse( configfp, configname, &configlineno, &pargs, opts) )
442     {
443       switch (pargs.r_opt)
444         {
445         case aGPGConfList: gpgconf_list = 1; break;
446         case oQuiet: opt.quiet = 1; break;
447         case oVerbose: opt.verbose++; break;
448         case oBatch: opt.batch=1; break;
449
450         case oDebug: opt.debug |= pargs.r.ret_ulong; break;
451         case oDebugAll: opt.debug = ~0; break;
452         case oDebugLevel: debug_level = pargs.r.ret_str; break;
453         case oDebugWait: debug_wait = pargs.r.ret_int; break;
454         case oDebugAllowCoreDump:
455           enable_core_dumps ();
456           allow_coredump = 1;
457           break;
458         case oDebugCCIDDriver: 
459           ccid_set_debug_level (ccid_set_debug_level (-1)+1);
460           break;
461         case oDebugDisableTicker: ticker_disabled = 1; break;
462
463         case oOptions:
464           /* config files may not be nested (silently ignore them) */
465           if (!configfp)
466             {
467                 xfree(configname);
468                 configname = xstrdup(pargs.r.ret_str);
469                 goto next_pass;
470             }
471           break;
472         case oNoGreeting: nogreeting = 1; break;
473         case oNoVerbose: opt.verbose = 0; break;
474         case oNoOptions: break; /* no-options */
475         case oHomedir: opt.homedir = pargs.r.ret_str; break;
476         case oNoDetach: nodetach = 1; break;
477         case oLogFile: logfile = pargs.r.ret_str; break;
478         case oCsh: csh_style = 1; break;
479         case oSh: csh_style = 0; break;
480         case oServer: pipe_server = 1; break;
481         case oMultiServer: pipe_server = 1; multi_server = 1; break;
482         case oDaemon: is_daemon = 1; break;
483
484         case oReaderPort: opt.reader_port = pargs.r.ret_str; break;
485         case octapiDriver: opt.ctapi_driver = pargs.r.ret_str; break;
486         case opcscDriver: opt.pcsc_driver = pargs.r.ret_str; break;
487         case oDisableCCID: opt.disable_ccid = 1; break;
488         case oDisableOpenSC: break;
489
490         case oAllowAdmin: opt.allow_admin = 1; break;
491         case oDenyAdmin: opt.allow_admin = 0; break;
492
493         case oDisableApplication:
494           add_to_strlist (&opt.disabled_applications, pargs.r.ret_str); 
495           break;
496
497         default : pargs.err = configfp? 1:2; break;
498         }
499     }
500   if (configfp)
501     {
502       fclose( configfp );
503       configfp = NULL;
504       /* Keep a copy of the config name for use by --gpgconf-list. */
505       config_filename = configname;
506       configname = NULL;
507       goto next_pass;
508     }
509   xfree (configname);
510   configname = NULL;
511   if (log_get_errorcount(0))
512     exit(2);
513   if (nogreeting )
514     greeting = 0;
515
516   if (greeting)
517     {
518       fprintf (stderr, "%s %s; %s\n",
519                  strusage(11), strusage(13), strusage(14) );
520       fprintf (stderr, "%s\n", strusage(15) );
521     }
522 #ifdef IS_DEVELOPMENT_VERSION
523   log_info ("NOTE: this is a development version!\n");
524 #endif
525
526  
527   if (atexit (cleanup))
528     {
529       log_error ("atexit failed\n");
530       cleanup ();
531       exit (1);
532     }
533
534   set_debug (debug_level);
535
536   if (debug_wait && pipe_server)
537     {
538       log_debug ("waiting for debugger - my pid is %u .....\n",
539                  (unsigned int)getpid());
540       sleep (debug_wait);
541       log_debug ("... okay\n");
542     }
543   
544   if (gpgconf_list)
545     {
546       /* List options and default values in the GPG Conf format.  */
547
548       /* The following list is taken from gnupg/tools/gpgconf-comp.c.  */
549       /* Option flags.  YOU MUST NOT CHANGE THE NUMBERS OF THE EXISTING
550          FLAGS, AS THEY ARE PART OF THE EXTERNAL INTERFACE.  */
551 #define GC_OPT_FLAG_NONE        0UL
552       /* The RUNTIME flag for an option indicates that the option can be
553          changed at runtime.  */
554 #define GC_OPT_FLAG_RUNTIME     (1UL << 3)
555       /* The DEFAULT flag for an option indicates that the option has a
556          default value.  */
557 #define GC_OPT_FLAG_DEFAULT     (1UL << 4)
558       /* The DEF_DESC flag for an option indicates that the option has a
559          default, which is described by the value of the default field.  */
560 #define GC_OPT_FLAG_DEF_DESC    (1UL << 5)
561       /* The NO_ARG_DESC flag for an option indicates that the argument has
562          a default, which is described by the value of the ARGDEF field.  */
563 #define GC_OPT_FLAG_NO_ARG_DESC (1UL << 6)
564       if (!config_filename)
565         config_filename = make_filename (opt.homedir, "scdaemon.conf", NULL );
566
567       printf ("gpgconf-scdaemon.conf:%lu:\"%s\n",
568               GC_OPT_FLAG_DEFAULT, config_filename);
569         
570       printf ("verbose:%lu:\n"
571               "quiet:%lu:\n"
572               "debug-level:%lu:\"none:\n"
573               "log-file:%lu:\n",
574               GC_OPT_FLAG_NONE,
575               GC_OPT_FLAG_NONE,
576               GC_OPT_FLAG_DEFAULT,
577               GC_OPT_FLAG_NONE );
578
579       printf ("reader-port:%lu:\n", GC_OPT_FLAG_NONE );
580       printf ("ctapi-driver:%lu:\n", GC_OPT_FLAG_NONE );
581       printf ("pcsc-driver:%lu:\"%s:\n",
582               GC_OPT_FLAG_DEFAULT, DEFAULT_PCSC_DRIVER );
583 #ifdef HAVE_LIBUSB
584       printf ("disable-ccid:%lu:\n", GC_OPT_FLAG_NONE );
585 #endif
586       printf ("allow-admin:%lu:\n", GC_OPT_FLAG_NONE );
587
588
589       scd_exit (0);
590     }
591
592   /* now start with logging to a file if this is desired */
593   if (logfile)
594     {
595       log_set_file (logfile);
596       log_set_prefix (NULL, 1|2|4);
597     }
598
599   if (pipe_server)
600     { 
601       /* This is the simple pipe based server */
602       pth_attr_t tattr;
603       int fd = -1;
604
605       {
606         struct sigaction sa;
607         
608         sa.sa_handler = SIG_IGN;
609         sigemptyset (&sa.sa_mask);
610         sa.sa_flags = 0;
611         sigaction (SIGPIPE, &sa, NULL);
612       }
613
614       /* If --debug-allow-core-dump has been given we also need to
615          switch the working directory to a place where we can actually
616          write. */
617       if (allow_coredump)
618         {
619           if (chdir("/tmp"))
620             log_debug ("chdir to `/tmp' failed: %s\n", strerror (errno));
621           else
622             log_debug ("changed working directory to `/tmp'\n");
623         }
624
625       /* In multi server mode we need to listen on an additional
626          socket.  Create that socket now before starting the handler
627          for the pipe connection.  This allows that handler to send
628          back the name of that socket. */
629       if (multi_server)
630         {
631           socket_name = create_socket_name (0,
632                                             "S.scdaemon",
633                                             "/tmp/gpg-XXXXXX/S.scdaemon");
634           
635           fd = create_server_socket (0, socket_name);
636         }
637
638       tattr = pth_attr_new();
639       pth_attr_set (tattr, PTH_ATTR_JOINABLE, 0);
640       pth_attr_set (tattr, PTH_ATTR_STACK_SIZE, 512*1024);
641       pth_attr_set (tattr, PTH_ATTR_NAME, "pipe-connection");
642
643       if (!pth_spawn (tattr, start_connection_thread, (void*)(-1)))
644         {
645           log_error ("error spawning pipe connection handler: %s\n",
646                      strerror (errno) );
647           scd_exit (2);
648         }
649
650       handle_connections (fd);
651       if (fd != -1)
652         close (fd);
653     }
654   else if (!is_daemon)
655     {
656       log_info (_("please use the option `--daemon'"
657                   " to run the program in the background\n"));
658     }
659   else
660     { /* Regular server mode */
661       int fd;
662       pid_t pid;
663       int i;
664
665       /* Create the socket.  */
666       socket_name = create_socket_name (0,
667                                         "S.scdaemon",
668                                         "/tmp/gpg-XXXXXX/S.scdaemon");
669
670       fd = create_server_socket (0, socket_name);
671
672
673       fflush (NULL);
674 #ifndef HAVE_W32_SYSTEM
675       pid = fork ();
676       if (pid == (pid_t)-1) 
677         {
678           log_fatal ("fork failed: %s\n", strerror (errno) );
679           exit (1);
680         }
681       else if (pid) 
682         { /* we are the parent */
683           char *infostr;
684           
685           close (fd);
686           
687           /* create the info string: <name>:<pid>:<protocol_version> */
688           if (asprintf (&infostr, "SCDAEMON_INFO=%s:%lu:1",
689                         socket_name, (ulong)pid ) < 0)
690             {
691               log_error ("out of core\n");
692               kill (pid, SIGTERM);
693               exit (1);
694             }
695           *socket_name = 0; /* don't let cleanup() remove the socket -
696                                the child should do this from now on */
697           if (argc) 
698             { /* run the program given on the commandline */
699               if (putenv (infostr))
700                 {
701                   log_error ("failed to set environment: %s\n",
702                              strerror (errno) );
703                   kill (pid, SIGTERM );
704                   exit (1);
705                 }
706               execvp (argv[0], argv);
707               log_error ("failed to run the command: %s\n", strerror (errno));
708               kill (pid, SIGTERM);
709               exit (1);
710             }
711           else
712             {
713               /* Print the environment string, so that the caller can use
714                  shell's eval to set it */
715               if (csh_style)
716                 {
717                   *strchr (infostr, '=') = ' ';
718                   printf ( "setenv %s\n", infostr);
719                 }
720               else
721                 {
722                   printf ( "%s; export SCDAEMON_INFO;\n", infostr);
723                 }
724               free (infostr);
725               exit (0); 
726             }
727           /* NOTREACHED */
728         } /* end parent */
729       
730       /* This is the child. */
731
732       /* Detach from tty and put process into a new session. */
733       if (!nodetach )
734         {  
735           /* Close stdin, stdout and stderr unless it is the log stream. */
736           for (i=0; i <= 2; i++) 
737             {
738               if ( log_test_fd (i) && i != fd)
739                 close (i);
740             }
741           if (setsid() == -1)
742             {
743               log_error ("setsid() failed: %s\n", strerror(errno) );
744               cleanup ();
745               exit (1);
746             }
747         }
748
749       {
750         struct sigaction sa;
751         
752         sa.sa_handler = SIG_IGN;
753         sigemptyset (&sa.sa_mask);
754         sa.sa_flags = 0;
755         sigaction (SIGPIPE, &sa, NULL);
756       }
757
758       if (chdir("/"))
759         {
760           log_error ("chdir to / failed: %s\n", strerror (errno));
761           exit (1);
762         }
763
764 #endif /*!HAVE_W32_SYSTEM*/
765
766       handle_connections (fd);
767
768       close (fd);
769     }
770   
771   return 0;
772 }
773
774 void
775 scd_exit (int rc)
776 {
777 #if 0
778 #warning no update_random_seed_file
779   update_random_seed_file();
780 #endif
781 #if 0
782   /* at this time a bit annoying */
783   if (opt.debug & DBG_MEMSTAT_VALUE)
784     {
785       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
786       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
787     }
788   if (opt.debug)
789     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
790 #endif
791   gcry_control (GCRYCTL_TERM_SECMEM );
792   rc = rc? rc : log_get_errorcount(0)? 2 : 0;
793   exit (rc);
794 }
795
796
797 void
798 scd_init_default_ctrl (ctrl_t ctrl)
799 {
800   ctrl->reader_slot = -1;
801 }
802
803
804 /* Return the name of the socket to be used to connect to this
805    process.  If no socket is available, return NULL. */
806 const char *
807 scd_get_socket_name ()
808 {
809   if (socket_name && *socket_name)
810     return socket_name;
811   return NULL;
812 }
813
814
815 static void
816 handle_signal (int signo)
817 {
818   switch (signo)
819     {
820 #ifndef HAVE_W32_SYSTEM
821     case SIGHUP:
822       log_info ("SIGHUP received - "
823                 "re-reading configuration and resetting cards\n");
824 /*       reread_configuration (); */
825       break;
826       
827     case SIGUSR1:
828       log_info ("SIGUSR1 received - printing internal information:\n");
829       pth_ctrl (PTH_CTRL_DUMPSTATE, log_get_stream ());
830       app_dump_state ();
831       break;
832
833     case SIGUSR2:
834       log_info ("SIGUSR2 received - no action defined\n");
835       break;
836
837     case SIGTERM:
838       if (!shutdown_pending)
839         log_info ("SIGTERM received - shutting down ...\n");
840       else
841         log_info ("SIGTERM received - still %ld running threads\n",
842                   pth_ctrl( PTH_CTRL_GETTHREADS ));
843       shutdown_pending++;
844       if (shutdown_pending > 2)
845         {
846           log_info ("shutdown forced\n");
847           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
848           cleanup ();
849           scd_exit (0);
850         }
851       break;
852         
853     case SIGINT:
854       log_info ("SIGINT received - immediate shutdown\n");
855       log_info( "%s %s stopped\n", strusage(11), strusage(13));
856       cleanup ();
857       scd_exit (0);
858       break;
859 #endif /*!HAVE_W32_SYSTEM*/
860
861     default:
862       log_info ("signal %d received - no action defined\n", signo);
863     }
864 }
865
866
867 static void
868 handle_tick (void)
869 {
870   if (!ticker_disabled)
871     scd_update_reader_status_file ();
872 }
873
874
875 /* Create a name for the socket.  With USE_STANDARD_SOCKET given as
876    true using STANDARD_NAME in the home directory or if given has
877    false from the mkdir type name TEMPLATE.  In the latter case a
878    unique name in a unique new directory will be created.  In both
879    cases check for valid characters as well as against a maximum
880    allowed length for a unix domain socket is done.  The function
881    terminates the process in case of an error.  Retunrs: Pointer to an
882    allcoated string with the absolute name of the socket used.  */
883 static char *
884 create_socket_name (int use_standard_socket,
885                     char *standard_name, char *template)
886 {
887   char *name, *p;
888
889   if (use_standard_socket)
890     name = make_filename (opt.homedir, standard_name, NULL);
891   else
892     {
893       name = xstrdup (template);
894       p = strrchr (name, '/');
895       if (!p)
896         BUG ();
897       *p = 0;
898       if (!mkdtemp (name))
899         {
900           log_error (_("can't create directory `%s': %s\n"),
901                      name, strerror (errno));
902           scd_exit (2);
903         }
904       *p = '/';
905     }
906
907   if (strchr (name, PATHSEP_C))
908     {
909       log_error (("`%s' are not allowed in the socket name\n"), PATHSEP_S);
910       scd_exit (2);
911     }
912   if (strlen (name) + 1 >= DIMof (struct sockaddr_un, sun_path) )
913     {
914       log_error (_("name of socket too long\n"));
915       scd_exit (2);
916     }
917   return name;
918 }
919
920
921
922 /* Create a Unix domain socket with NAME.  IS_STANDARD_NAME indicates
923    whether a non-random socket is used.  Returns the file descriptor
924    or terminates the process in case of an error. */
925 static int
926 create_server_socket (int is_standard_name, const char *name)
927 {
928   struct sockaddr_un *serv_addr;
929   socklen_t len;
930   int fd;
931   int rc;
932
933 #ifdef HAVE_W32_SYSTEM
934   fd = _w32_sock_new (AF_UNIX, SOCK_STREAM, 0);
935 #else
936   fd = socket (AF_UNIX, SOCK_STREAM, 0);
937 #endif
938   if (fd == -1)
939     {
940       log_error (_("can't create socket: %s\n"), strerror (errno));
941       scd_exit (2);
942     }
943
944   serv_addr = xmalloc (sizeof (*serv_addr)); 
945   memset (serv_addr, 0, sizeof *serv_addr);
946   serv_addr->sun_family = AF_UNIX;
947   assert (strlen (name) + 1 < sizeof (serv_addr->sun_path));
948   strcpy (serv_addr->sun_path, name);
949   len = (offsetof (struct sockaddr_un, sun_path)
950          + strlen (serv_addr->sun_path) + 1);
951
952 #ifdef HAVE_W32_SYSTEM
953   rc = _w32_sock_bind (fd, (struct sockaddr*) serv_addr, len);
954   if (is_standard_name && rc == -1 )
955     {
956       remove (name);
957       rc = bind (fd, (struct sockaddr*) serv_addr, len);
958     }
959 #else
960   rc = bind (fd, (struct sockaddr*) serv_addr, len);
961   if (is_standard_name && rc == -1 && errno == EADDRINUSE)
962     {
963       remove (name);
964       rc = bind (fd, (struct sockaddr*) serv_addr, len);
965     }
966 #endif
967   if (rc == -1)
968     {
969       log_error (_("error binding socket to `%s': %s\n"),
970                  serv_addr->sun_path, strerror (errno));
971       close (fd);
972       scd_exit (2);
973     }
974
975   if (listen (fd, 5 ) == -1)
976     {
977       log_error (_("listen() failed: %s\n"), strerror (errno));
978       close (fd);
979       scd_exit (2);
980     }
981           
982   if (opt.verbose)
983     log_info (_("listening on socket `%s'\n"), serv_addr->sun_path);
984
985   return fd;
986 }
987
988
989
990 /* This is the standard connection thread's main function.  */
991 static void *
992 start_connection_thread (void *arg)
993 {
994   int fd = (int)arg;
995
996   if (opt.verbose)
997     log_info (_("handler for fd %d started\n"), fd);
998
999   scd_command_handler (fd);
1000
1001   if (opt.verbose)
1002     log_info (_("handler for fd %d terminated\n"), fd);
1003
1004   /* If this thread is the pipe connection thread, flag that a
1005      shutdown is required.  With the next ticker event and given that
1006      no other connections are running the shutdown will then
1007      happen. */
1008   if (fd == -1)
1009     shutdown_pending = 1;
1010   
1011   return NULL;
1012 }
1013
1014
1015 /* Connection handler loop.  Wait for connection requests and spawn a
1016    thread after accepting a connection.  LISTEN_FD is allowed to be -1
1017    in which case this code will only do regular timeouts and handle
1018    signals. */
1019 static void
1020 handle_connections (int listen_fd)
1021 {
1022   pth_attr_t tattr;
1023   pth_event_t ev, time_ev;
1024   sigset_t sigs;
1025   int signo;
1026   struct sockaddr_un paddr;
1027   socklen_t plen;
1028   fd_set fdset, read_fdset;
1029   int ret;
1030   int fd;
1031
1032   tattr = pth_attr_new();
1033   pth_attr_set (tattr, PTH_ATTR_JOINABLE, 0);
1034   pth_attr_set (tattr, PTH_ATTR_STACK_SIZE, 512*1024);
1035
1036 #ifndef HAVE_W32_SYSTEM /* fixme */
1037   sigemptyset (&sigs );
1038   sigaddset (&sigs, SIGHUP);
1039   sigaddset (&sigs, SIGUSR1);
1040   sigaddset (&sigs, SIGUSR2);
1041   sigaddset (&sigs, SIGINT);
1042   sigaddset (&sigs, SIGTERM);
1043   pth_sigmask (SIG_UNBLOCK, &sigs, NULL);
1044   ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
1045 #else
1046   ev = NULL;
1047 #endif
1048   time_ev = NULL;
1049
1050   FD_ZERO (&fdset);
1051   if (listen_fd != -1)
1052     FD_SET (listen_fd, &fdset);
1053
1054   for (;;)
1055     {
1056       sigset_t oldsigs;
1057       
1058       if (shutdown_pending)
1059         {
1060           if (pth_ctrl (PTH_CTRL_GETTHREADS) == 1)
1061             break; /* ready */
1062
1063           /* Do not accept anymore connections but wait for existing
1064              connections to terminate. We do this by clearing out all
1065              file descriptors to wait for, so that the select will be
1066              used to just wait on a signal or timeout event. */
1067           FD_ZERO (&fdset);
1068         }
1069
1070       /* Create a timeout event if needed. */
1071       if (!time_ev)
1072         time_ev = pth_event (PTH_EVENT_TIME, pth_timeout (2, 0));
1073
1074       /* POSIX says that fd_set should be implemented as a structure,
1075          thus a simple assignment is fine to copy the entire set.  */
1076       read_fdset = fdset;
1077
1078       if (time_ev)
1079         pth_event_concat (ev, time_ev, NULL);
1080       ret = pth_select_ev (FD_SETSIZE, &read_fdset, NULL, NULL, NULL, ev);
1081       if (time_ev)
1082         pth_event_isolate (time_ev);
1083
1084       if (ret == -1)
1085         {
1086           if (pth_event_occurred (ev)
1087               || (time_ev && pth_event_occurred (time_ev)))
1088             {
1089               if (pth_event_occurred (ev))
1090                 handle_signal (signo);
1091               if (time_ev && pth_event_occurred (time_ev))
1092                 {
1093                   pth_event_free (time_ev, PTH_FREE_ALL);
1094                   time_ev = NULL;
1095                   handle_tick ();
1096                 }
1097               continue;
1098             }
1099           log_error (_("pth_select failed: %s - waiting 1s\n"),
1100                      strerror (errno));
1101           pth_sleep (1);
1102           continue;
1103         }
1104
1105       if (pth_event_occurred (ev))
1106         {
1107           handle_signal (signo);
1108         }
1109
1110       if (time_ev && pth_event_occurred (time_ev))
1111         {
1112           pth_event_free (time_ev, PTH_FREE_ALL);
1113           time_ev = NULL;
1114           handle_tick ();
1115         }
1116
1117       /* We now might create new threads and because we don't want any
1118          signals - we are handling here - to be delivered to a new
1119          thread. Thus we need to block those signals. */
1120       pth_sigmask (SIG_BLOCK, &sigs, &oldsigs);
1121
1122       if (listen_fd != -1 && FD_ISSET (listen_fd, &read_fdset))
1123         {
1124           plen = sizeof paddr;
1125           fd = pth_accept (listen_fd, (struct sockaddr *)&paddr, &plen);
1126           if (fd == -1)
1127             {
1128               log_error ("accept failed: %s\n", strerror (errno));
1129             }
1130           else
1131             {
1132               char threadname[50];
1133               snprintf (threadname, sizeof threadname-1, "conn fd=%d", fd);
1134               threadname[sizeof threadname -1] = 0;
1135               pth_attr_set (tattr, PTH_ATTR_NAME, threadname);
1136               
1137               if (!pth_spawn (tattr, start_connection_thread, (void*)fd))
1138                 {
1139                   log_error ("error spawning connection handler: %s\n",
1140                              strerror (errno) );
1141                   close (fd);
1142                 }
1143             }
1144           fd = -1;
1145         }
1146
1147       /* Restore the signal mask. */
1148       pth_sigmask (SIG_SETMASK, &oldsigs, NULL);
1149
1150     }
1151
1152   pth_event_free (ev, PTH_FREE_ALL);
1153   if (time_ev)
1154     pth_event_free (time_ev, PTH_FREE_ALL);
1155   cleanup ();
1156   log_info (_("%s %s stopped\n"), strusage(11), strusage(13));
1157 }
1158
1159