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