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