* command.c (cmd_updatestartuptty): New.
[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   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       app_dump_state ();
813       break;
814
815     case SIGUSR2:
816       log_info ("SIGUSR2 received - no action defined\n");
817       break;
818
819     case SIGTERM:
820       if (!shutdown_pending)
821         log_info ("SIGTERM received - shutting down ...\n");
822       else
823         log_info ("SIGTERM received - still %ld running threads\n",
824                   pth_ctrl( PTH_CTRL_GETTHREADS ));
825       shutdown_pending++;
826       if (shutdown_pending > 2)
827         {
828           log_info ("shutdown forced\n");
829           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
830           cleanup ();
831           scd_exit (0);
832         }
833       break;
834         
835     case SIGINT:
836       log_info ("SIGINT received - immediate shutdown\n");
837       log_info( "%s %s stopped\n", strusage(11), strusage(13));
838       cleanup ();
839       scd_exit (0);
840       break;
841 #endif /*!HAVE_W32_SYSTEM*/
842
843     default:
844       log_info ("signal %d received - no action defined\n", signo);
845     }
846 }
847
848
849 static void
850 handle_tick (void)
851 {
852   if (!ticker_disabled)
853     scd_update_reader_status_file ();
854 }
855
856
857 /* Create a name for the socket.  With USE_STANDARD_SOCKET given as
858    true using STANDARD_NAME in the home directory or if given has
859    false from the mkdir type name TEMPLATE.  In the latter case a
860    unique name in a unique new directory will be created.  In both
861    cases check for valid characters as well as against a maximum
862    allowed length for a unix domain socket is done.  The function
863    terminates the process in case of an error.  Retunrs: Pointer to an
864    allcoated string with the absolute name of the socket used.  */
865 static char *
866 create_socket_name (int use_standard_socket,
867                     char *standard_name, char *template)
868 {
869   char *name, *p;
870
871   if (use_standard_socket)
872     name = make_filename (opt.homedir, standard_name, NULL);
873   else
874     {
875       name = xstrdup (template);
876       p = strrchr (name, '/');
877       if (!p)
878         BUG ();
879       *p = 0;
880       if (!mkdtemp (name))
881         {
882           log_error (_("can't create directory `%s': %s\n"),
883                      name, strerror (errno));
884           scd_exit (2);
885         }
886       *p = '/';
887     }
888
889   if (strchr (name, PATHSEP_C))
890     {
891       log_error (("`%s' are not allowed in the socket name\n"), PATHSEP_S);
892       scd_exit (2);
893     }
894   if (strlen (name) + 1 >= DIMof (struct sockaddr_un, sun_path) )
895     {
896       log_error (_("name of socket too long\n"));
897       scd_exit (2);
898     }
899   return name;
900 }
901
902
903
904 /* Create a Unix domain socket with NAME.  IS_STANDARD_NAME indicates
905    whether a non-random socket is used.  Returns the file descriptor
906    or terminates the process in case of an error. */
907 static int
908 create_server_socket (int is_standard_name, const char *name)
909 {
910   struct sockaddr_un *serv_addr;
911   socklen_t len;
912   int fd;
913   int rc;
914
915 #ifdef HAVE_W32_SYSTEM
916   fd = _w32_sock_new (AF_UNIX, SOCK_STREAM, 0);
917 #else
918   fd = socket (AF_UNIX, SOCK_STREAM, 0);
919 #endif
920   if (fd == -1)
921     {
922       log_error (_("can't create socket: %s\n"), strerror (errno));
923       scd_exit (2);
924     }
925
926   serv_addr = xmalloc (sizeof (*serv_addr)); 
927   memset (serv_addr, 0, sizeof *serv_addr);
928   serv_addr->sun_family = AF_UNIX;
929   assert (strlen (name) + 1 < sizeof (serv_addr->sun_path));
930   strcpy (serv_addr->sun_path, name);
931   len = (offsetof (struct sockaddr_un, sun_path)
932          + strlen (serv_addr->sun_path) + 1);
933
934 #ifdef HAVE_W32_SYSTEM
935   rc = _w32_sock_bind (fd, (struct sockaddr*) serv_addr, len);
936   if (is_standard_name && rc == -1 )
937     {
938       remove (name);
939       rc = bind (fd, (struct sockaddr*) serv_addr, len);
940     }
941 #else
942   rc = bind (fd, (struct sockaddr*) serv_addr, len);
943   if (is_standard_name && rc == -1 && errno == EADDRINUSE)
944     {
945       remove (name);
946       rc = bind (fd, (struct sockaddr*) serv_addr, len);
947     }
948 #endif
949   if (rc == -1)
950     {
951       log_error (_("error binding socket to `%s': %s\n"),
952                  serv_addr->sun_path, strerror (errno));
953       close (fd);
954       scd_exit (2);
955     }
956
957   if (listen (fd, 5 ) == -1)
958     {
959       log_error (_("listen() failed: %s\n"), strerror (errno));
960       close (fd);
961       scd_exit (2);
962     }
963           
964   if (opt.verbose)
965     log_info (_("listening on socket `%s'\n"), serv_addr->sun_path);
966
967   return fd;
968 }
969
970
971
972 /* This is the standard connection thread's main function.  */
973 static void *
974 start_connection_thread (void *arg)
975 {
976   int fd = (int)arg;
977
978   if (opt.verbose)
979     log_info (_("handler for fd %d started\n"), fd);
980
981   scd_command_handler (fd);
982
983   if (opt.verbose)
984     log_info (_("handler for fd %d terminated\n"), fd);
985
986   /* If this thread is the pipe connection thread, flag that a
987      shutdown is required.  With the next ticker event and given that
988      no other connections are running the shutdown will then
989      happen. */
990   if (fd == -1)
991     shutdown_pending = 1;
992   
993   return NULL;
994 }
995
996
997 /* Connection handler loop.  Wait for connection requests and spawn a
998    thread after accepting a connection.  LISTEN_FD is allowed to be -1
999    in which case this code will only do regular timeouts and handle
1000    signals. */
1001 static void
1002 handle_connections (int listen_fd)
1003 {
1004   pth_attr_t tattr;
1005   pth_event_t ev, time_ev;
1006   sigset_t sigs;
1007   int signo;
1008   struct sockaddr_un paddr;
1009   socklen_t plen;
1010   fd_set fdset, read_fdset;
1011   int ret;
1012   int fd;
1013
1014   tattr = pth_attr_new();
1015   pth_attr_set (tattr, PTH_ATTR_JOINABLE, 0);
1016   pth_attr_set (tattr, PTH_ATTR_STACK_SIZE, 512*1024);
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   pth_sigmask (SIG_UNBLOCK, &sigs, NULL);
1026   ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
1027 #else
1028   ev = NULL;
1029 #endif
1030   time_ev = NULL;
1031
1032   FD_ZERO (&fdset);
1033   if (listen_fd != -1)
1034     FD_SET (listen_fd, &fdset);
1035
1036   for (;;)
1037     {
1038       sigset_t oldsigs;
1039       
1040       if (shutdown_pending)
1041         {
1042           if (pth_ctrl (PTH_CTRL_GETTHREADS) == 1)
1043             break; /* ready */
1044
1045           /* Do not accept anymore connections but wait for existing
1046              connections to terminate. We do this by clearing out all
1047              file descriptors to wait for, so that the select will be
1048              used to just wait on a signal or timeout event. */
1049           FD_ZERO (&fdset);
1050         }
1051
1052       /* Create a timeout event if needed. */
1053       if (!time_ev)
1054         time_ev = pth_event (PTH_EVENT_TIME, pth_timeout (2, 0));
1055
1056       /* POSIX says that fd_set should be implemented as a structure,
1057          thus a simple assignment is fine to copy the entire set.  */
1058       read_fdset = fdset;
1059
1060       if (time_ev)
1061         pth_event_concat (ev, time_ev, NULL);
1062       ret = pth_select_ev (FD_SETSIZE, &read_fdset, NULL, NULL, NULL, ev);
1063       if (time_ev)
1064         pth_event_isolate (time_ev);
1065
1066       if (ret == -1)
1067         {
1068           if (pth_event_occurred (ev)
1069               || (time_ev && pth_event_occurred (time_ev)))
1070             {
1071               if (pth_event_occurred (ev))
1072                 handle_signal (signo);
1073               if (time_ev && pth_event_occurred (time_ev))
1074                 {
1075                   pth_event_free (time_ev, PTH_FREE_ALL);
1076                   time_ev = NULL;
1077                   handle_tick ();
1078                 }
1079               continue;
1080             }
1081           log_error (_("pth_select failed: %s - waiting 1s\n"),
1082                      strerror (errno));
1083           pth_sleep (1);
1084           continue;
1085         }
1086
1087       if (pth_event_occurred (ev))
1088         {
1089           handle_signal (signo);
1090         }
1091
1092       if (time_ev && pth_event_occurred (time_ev))
1093         {
1094           pth_event_free (time_ev, PTH_FREE_ALL);
1095           time_ev = NULL;
1096           handle_tick ();
1097         }
1098
1099       /* We now might create new threads and because we don't want any
1100          signals - we are handling here - to be delivered to a new
1101          thread. Thus we need to block those signals. */
1102       pth_sigmask (SIG_BLOCK, &sigs, &oldsigs);
1103
1104       if (listen_fd != -1 && FD_ISSET (listen_fd, &read_fdset))
1105         {
1106           plen = sizeof paddr;
1107           fd = pth_accept (listen_fd, (struct sockaddr *)&paddr, &plen);
1108           if (fd == -1)
1109             {
1110               log_error ("accept failed: %s\n", strerror (errno));
1111             }
1112           else
1113             {
1114               char threadname[50];
1115               snprintf (threadname, sizeof threadname-1, "conn fd=%d", fd);
1116               threadname[sizeof threadname -1] = 0;
1117               pth_attr_set (tattr, PTH_ATTR_NAME, threadname);
1118               
1119               if (!pth_spawn (tattr, start_connection_thread, (void*)fd))
1120                 {
1121                   log_error ("error spawning connection handler: %s\n",
1122                              strerror (errno) );
1123                   close (fd);
1124                 }
1125             }
1126           fd = -1;
1127         }
1128
1129       /* Restore the signal mask. */
1130       pth_sigmask (SIG_SETMASK, &oldsigs, NULL);
1131
1132     }
1133
1134   pth_event_free (ev, PTH_FREE_ALL);
1135   if (time_ev)
1136     pth_event_free (time_ev, PTH_FREE_ALL);
1137   cleanup ();
1138   log_info (_("%s %s stopped\n"), strusage(11), strusage(13));
1139 }
1140
1141