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