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