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