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