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