* configure.ac: Removed OpenSC detection and options.
[gnupg.git] / scd / scdaemon.c
1 /* scdaemon.c  -  The GnuPG Smartcard Daemon
2  *      Copyright (C) 2001, 2002, 2004 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 #ifdef USE_GNU_PTH
39 # include <pth.h>
40 #endif
41
42 #define JNLIB_NEED_LOG_LOGV
43 #include "scdaemon.h"
44 #include <ksba.h>
45 #include <gcrypt.h>
46
47 #include <assuan.h> /* malloc hooks */
48
49 #include "i18n.h"
50 #include "sysutils.h"
51 #include "app-common.h"
52 #ifdef HAVE_W32_SYSTEM
53 #include "../jnlib/w32-afunix.h"
54 #endif
55
56
57 enum cmd_and_opt_values 
58 { aNull = 0,
59   oCsh            = 'c',
60   oQuiet          = 'q',
61   oSh             = 's',
62   oVerbose        = 'v',
63   
64   oNoVerbose = 500,
65   aGPGConfList,
66   oOptions,
67   oDebug,
68   oDebugAll,
69   oDebugLevel,
70   oDebugWait,
71   oDebugSC,
72   oNoGreeting,
73   oNoOptions,
74   oHomedir,
75   oNoDetach,
76   oNoGrab,
77   oLogFile,
78   oServer,
79   oDaemon,
80   oBatch,
81   oReaderPort,
82   octapiDriver,
83   opcscDriver,
84   oDisableCCID,
85   oDisableOpenSC,
86   oAllowAdmin,
87   oDenyAdmin,
88   oDisableApplication,
89
90 aTest };
91
92
93
94 static ARGPARSE_OPTS opts[] = {
95
96   { aGPGConfList, "gpgconf-list", 256, "@" },
97   
98   { 301, NULL, 0, N_("@Options:\n ") },
99
100   { oServer,   "server",     0, N_("run in server mode (foreground)") },
101   { oDaemon,   "daemon",     0, N_("run in daemon mode (background)") },
102   { oVerbose, "verbose",   0, N_("verbose") },
103   { oQuiet,     "quiet",     0, N_("be somewhat more quiet") },
104   { oSh,        "sh",        0, N_("sh-style command output") },
105   { oCsh,       "csh",       0, N_("csh-style command output") },
106   { oOptions, "options"  , 2, N_("read options from file")},
107   { oDebug,     "debug"     ,4|16, "@"},
108   { oDebugAll, "debug-all"     ,0, "@"},
109   { oDebugLevel, "debug-level" ,2, "@"},
110   { oDebugWait,"debug-wait",1, "@"},
111   { oNoDetach, "no-detach" ,0, N_("do not detach from the console")},
112   { oLogFile,  "log-file"   ,2, N_("use a log file for the server")},
113   { oReaderPort, "reader-port", 2, N_("|N|connect to reader at port N")},
114   { octapiDriver, "ctapi-driver", 2, N_("|NAME|use NAME as ct-API driver")},
115   { opcscDriver, "pcsc-driver", 2, N_("|NAME|use NAME as PC/SC driver")},
116   { oDisableCCID, "disable-ccid", 0,
117 #ifdef HAVE_LIBUSB
118                                     N_("do not use the internal CCID driver")
119 #else
120                                     "@"
121 #endif
122                                          /* end --disable-ccid */},
123   { oAllowAdmin, "allow-admin", 0, N_("allow the use of admin card commands")},
124   { oDenyAdmin,  "deny-admin",  0, "@" },  
125   { oDisableApplication, "disable-application", 2, "@"},
126
127   /* Dummy options to be removed at some point. */
128   { oDebugSC,  "debug-sc",  1, "@" },
129   { oDisableOpenSC, "disable-opensc", 0, "@" },
130
131   {0}
132 };
133
134
135 /* The card dirver we use by default for PC/SC.  */
136 #ifdef HAVE_W32_SYSTEM
137 #define DEFAULT_PCSC_DRIVER "winscard.dll"
138 #else
139 #define DEFAULT_PCSC_DRIVER "libpcsclite.so"
140 #endif
141
142
143 static volatile int caught_fatal_sig = 0;
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[128];
153
154
155 #ifdef USE_GNU_PTH
156 /* Pth wrapper function definitions. */
157 GCRY_THREAD_OPTION_PTH_IMPL;
158
159 static void *ticker_thread (void *arg);
160 #endif /*USE_GNU_PTH*/
161
162 static const char *
163 my_strusage (int level)
164 {
165   const char *p;
166   switch (level)
167     {
168     case 11: p = "scdaemon (GnuPG)";
169       break;
170     case 13: p = VERSION; break;
171     case 17: p = PRINTABLE_OS_NAME; break;
172     case 19: p = _("Please report bugs to <" PACKAGE_BUGREPORT ">.\n");
173       break;
174     case 1:
175     case 40: p =  _("Usage: scdaemon [options] (-h for help)");
176       break;
177     case 41: p =  _("Syntax: scdaemon [options] [command [args]]\n"
178                     "Smartcard daemon for GnuPG\n");
179     break;
180     
181     default: p = NULL;
182     }
183   return p;
184 }
185
186
187
188 static void
189 i18n_init (void)
190 {
191 #ifdef USE_SIMPLE_GETTEXT
192     set_gettext_file( PACKAGE_GT );
193 #else
194 #ifdef ENABLE_NLS
195     setlocale (LC_ALL, "");
196     bindtextdomain (PACKAGE_GT, LOCALEDIR);
197     textdomain (PACKAGE_GT);
198 #endif
199 #endif
200 }
201
202
203
204 /* Used by gcry for logging */
205 static void
206 my_gcry_logger (void *dummy, int level, const char *fmt, va_list arg_ptr)
207 {
208   /* translate the log levels */
209   switch (level)
210     {
211     case GCRY_LOG_CONT: level = JNLIB_LOG_CONT; break;
212     case GCRY_LOG_INFO: level = JNLIB_LOG_INFO; break;
213     case GCRY_LOG_WARN: level = JNLIB_LOG_WARN; break;
214     case GCRY_LOG_ERROR:level = JNLIB_LOG_ERROR; break;
215     case GCRY_LOG_FATAL:level = JNLIB_LOG_FATAL; break;
216     case GCRY_LOG_BUG:  level = JNLIB_LOG_BUG; break;
217     case GCRY_LOG_DEBUG:level = JNLIB_LOG_DEBUG; break;
218     default:            level = JNLIB_LOG_ERROR; break;  
219     }
220   log_logv (level, fmt, arg_ptr);
221 }
222
223
224 /* Setup the debugging.  With a LEVEL of NULL only the active debug
225    flags are propagated to the subsystems.  With LEVEL set, a specific
226    set of debug flags is set; thus overriding all flags already
227    set. */
228 static void
229 set_debug (const char *level)
230 {
231   if (!level)
232     ;
233   else if (!strcmp (level, "none"))
234     opt.debug = 0;
235   else if (!strcmp (level, "basic"))
236     opt.debug = DBG_ASSUAN_VALUE;
237   else if (!strcmp (level, "advanced"))
238     opt.debug = DBG_ASSUAN_VALUE|DBG_COMMAND_VALUE;
239   else if (!strcmp (level, "expert"))
240     opt.debug = (DBG_ASSUAN_VALUE|DBG_COMMAND_VALUE
241                  |DBG_CACHE_VALUE|DBG_CARD_IO_VALUE);
242   else if (!strcmp (level, "guru"))
243     opt.debug = ~0;
244   else
245     {
246       log_error (_("invalid debug-level `%s' given\n"), level);
247       scd_exit(2);
248     }
249
250
251   if (opt.debug && !opt.verbose)
252     opt.verbose = 1;
253   if (opt.debug && opt.quiet)
254     opt.quiet = 0;
255
256   if (opt.debug & DBG_MPI_VALUE)
257     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 2);
258   if (opt.debug & DBG_CRYPTO_VALUE )
259     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1);
260   gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
261 }
262  
263
264
265 static void
266 cleanup (void)
267 {
268   if (*socket_name)
269     {
270       char *p;
271
272       remove (socket_name);
273       p = strrchr (socket_name, '/');
274       if (p)
275         {
276           *p = 0;
277           rmdir (socket_name);
278           *p = '/';
279         }
280       *socket_name = 0;
281     }
282 }
283
284
285 static RETSIGTYPE
286 cleanup_sh (int sig)
287 {
288   if (caught_fatal_sig)
289     raise (sig);
290   caught_fatal_sig = 1;
291
292   /* gcry_control( GCRYCTL_TERM_SECMEM );*/
293   cleanup ();
294
295 #ifndef HAVE_DOSISH_SYSTEM
296   {     /* reset action to default action and raise signal again */
297     struct sigaction nact;
298     nact.sa_handler = SIG_DFL;
299     sigemptyset( &nact.sa_mask );
300     nact.sa_flags = 0;
301     sigaction( sig, &nact, NULL);
302   }
303 #endif
304   raise( sig );
305 }
306
307 int
308 main (int argc, char **argv )
309 {
310   ARGPARSE_ARGS pargs;
311   int orig_argc;
312   gpg_error_t err;
313   int may_coredump;
314   char **orig_argv;
315   FILE *configfp = NULL;
316   char *configname = NULL;
317   const char *shell;
318   unsigned configlineno;
319   int parse_debug = 0;
320   const char *debug_level = NULL;
321   int default_config =1;
322   int greeting = 0;
323   int nogreeting = 0;
324   int pipe_server = 0;
325   int is_daemon = 0;
326   int nodetach = 0;
327   int csh_style = 0;
328   char *logfile = NULL;
329   int debug_wait = 0;
330   int gpgconf_list = 0;
331   const char *config_filename = NULL;
332
333   set_strusage (my_strusage);
334   gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
335   /* Please note that we may running SUID(ROOT), so be very CAREFUL
336      when adding any stuff between here and the call to INIT_SECMEM()
337      somewhere after the option parsing */
338   log_set_prefix ("scdaemon", 1|4); 
339   /* Try to auto set the character set.  */
340   set_native_charset (NULL); 
341
342   i18n_init ();
343
344   /* Libgcrypt requires us to register the threading model first.
345      Note that this will also do the pth_init. */
346 #ifdef USE_GNU_PTH
347   err = gcry_control (GCRYCTL_SET_THREAD_CBS, &gcry_threads_pth);
348   if (err)
349     {
350       log_fatal ("can't register GNU Pth with Libgcrypt: %s\n",
351                  gpg_strerror (err));
352     }
353 #endif /*USE_GNU_PTH*/
354
355   /* Check that the libraries are suitable.  Do it here because
356      the option parsing may need services of the library */
357   if (!gcry_check_version (NEED_LIBGCRYPT_VERSION) )
358     {
359       log_fatal( _("libgcrypt is too old (need %s, have %s)\n"),
360                  NEED_LIBGCRYPT_VERSION, gcry_check_version (NULL) );
361     }
362
363   ksba_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
364
365   assuan_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
366   assuan_set_assuan_log_stream (log_get_stream ());
367   assuan_set_assuan_log_prefix (log_get_prefix (NULL));
368
369   gcry_set_log_handler (my_gcry_logger, NULL);
370   gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
371
372   may_coredump = disable_core_dumps ();
373
374   /* Set default options. */
375   opt.pcsc_driver = DEFAULT_PCSC_DRIVER; 
376
377
378   shell = getenv ("SHELL");
379   if (shell && strlen (shell) >= 3 && !strcmp (shell+strlen (shell)-3, "csh") )
380     csh_style = 1;
381   
382   opt.homedir = default_homedir ();
383
384   /* Check whether we have a config file on the commandline */
385   orig_argc = argc;
386   orig_argv = argv;
387   pargs.argc = &argc;
388   pargs.argv = &argv;
389   pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
390   while (arg_parse( &pargs, opts))
391     {
392       if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll)
393         parse_debug++;
394       else if (pargs.r_opt == oOptions)
395         { /* yes there is one, so we do not try the default one, but
396              read the option file when it is encountered at the
397              commandline */
398           default_config = 0;
399         }
400         else if (pargs.r_opt == oNoOptions)
401           default_config = 0; /* --no-options */
402         else if (pargs.r_opt == oHomedir)
403           opt.homedir = pargs.r.ret_str;
404     }
405
406   /* initialize the secure memory. */
407   gcry_control (GCRYCTL_INIT_SECMEM, 16384, 0);
408   maybe_setuid = 0;
409
410   /* 
411      Now we are working under our real uid 
412   */
413
414
415   if (default_config)
416     configname = make_filename (opt.homedir, "scdaemon.conf", NULL );
417
418   
419   argc = orig_argc;
420   argv = orig_argv;
421   pargs.argc = &argc;
422   pargs.argv = &argv;
423   pargs.flags=  1;  /* do not remove the args */
424  next_pass:
425   if (configname)
426     {
427       configlineno = 0;
428       configfp = fopen (configname, "r");
429       if (!configfp)
430         {
431           if (default_config)
432             {
433               if( parse_debug )
434                 log_info (_("NOTE: no default option file `%s'\n"),
435                           configname );
436             }
437           else
438             {
439               log_error (_("option file `%s': %s\n"),
440                          configname, strerror(errno) );
441               exit(2);
442             }
443           xfree (configname); 
444           configname = NULL;
445         }
446       if (parse_debug && configname )
447         log_info (_("reading options from `%s'\n"), configname );
448       default_config = 0;
449     }
450
451   while (optfile_parse( configfp, configname, &configlineno, &pargs, opts) )
452     {
453       switch (pargs.r_opt)
454         {
455         case aGPGConfList: gpgconf_list = 1; break;
456         case oQuiet: opt.quiet = 1; break;
457         case oVerbose: opt.verbose++; break;
458         case oBatch: opt.batch=1; break;
459
460         case oDebug: opt.debug |= pargs.r.ret_ulong; break;
461         case oDebugAll: opt.debug = ~0; break;
462         case oDebugLevel: debug_level = pargs.r.ret_str; break;
463         case oDebugWait: debug_wait = pargs.r.ret_int; break;
464         case oDebugSC: break;
465
466         case oOptions:
467           /* config files may not be nested (silently ignore them) */
468           if (!configfp)
469             {
470                 xfree(configname);
471                 configname = xstrdup(pargs.r.ret_str);
472                 goto next_pass;
473             }
474           break;
475         case oNoGreeting: nogreeting = 1; break;
476         case oNoVerbose: opt.verbose = 0; break;
477         case oNoOptions: break; /* no-options */
478         case oHomedir: opt.homedir = pargs.r.ret_str; break;
479         case oNoDetach: nodetach = 1; break;
480         case oLogFile: logfile = pargs.r.ret_str; break;
481         case oCsh: csh_style = 1; break;
482         case oSh: csh_style = 0; break;
483         case oServer: pipe_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
602   if (pipe_server)
603     { /* This is the simple pipe based server */
604 #ifdef USE_GNU_PTH
605       pth_attr_t tattr;
606  
607       tattr = pth_attr_new();
608       pth_attr_set (tattr, PTH_ATTR_JOINABLE, 0);
609       pth_attr_set (tattr, PTH_ATTR_STACK_SIZE, 512*1024);
610       pth_attr_set (tattr, PTH_ATTR_NAME, "ticker");
611
612       if (!pth_spawn (tattr, ticker_thread, NULL))
613         {
614           log_error ("error spawning ticker thread: %s\n", strerror (errno));
615           scd_exit (2);
616         }
617 #endif /*USE_GNU_PTH*/
618       scd_command_handler (-1);
619     }
620   else if (!is_daemon)
621     {
622       log_info (_("please use the option `--daemon'"
623                   " to run the program in the background\n"));
624     }
625   else
626     { /* regular server mode */
627       int fd;
628       pid_t pid;
629       int i;
630       int len;
631       struct sockaddr_un serv_addr;
632       char *p;
633
634       /* fixme: if there is already a running gpg-agent we should
635          share the same directory - and vice versa */
636       *socket_name = 0;
637       snprintf (socket_name, DIM(socket_name)-1,
638                 "/tmp/gpg-XXXXXX/S.scdaemon");
639       socket_name[DIM(socket_name)-1] = 0;
640       p = strrchr (socket_name, '/');
641       if (!p)
642         BUG ();
643       *p = 0;;
644
645 #ifndef HAVE_W32_SYSTEM
646       if (!mkdtemp(socket_name))
647         {
648           log_error ("can't create directory `%s': %s\n",
649                      socket_name, strerror(errno) );
650           exit (1);
651         }
652 #endif
653       *p = '/';
654
655       if (strchr (socket_name, ':') )
656         {
657           log_error ("colons are not allowed in the socket name\n");
658           exit (1);
659         }
660       if (strlen (socket_name)+1 >= sizeof serv_addr.sun_path ) 
661         {
662           log_error ("name of socket to long\n");
663           exit (1);
664         }
665    
666
667 #ifdef HAVE_W32_SYSTEM
668       fd = _w32_sock_new (AF_UNIX, SOCK_STREAM, 0);
669 #else
670       fd = socket (AF_UNIX, SOCK_STREAM, 0);
671 #endif
672       if (fd == -1)
673         {
674           log_error ("can't create socket: %s\n", strerror(errno) );
675           exit (1);
676         }
677
678       memset (&serv_addr, 0, sizeof serv_addr);
679       serv_addr.sun_family = AF_UNIX;
680       strcpy (serv_addr.sun_path, socket_name);
681       len = (offsetof (struct sockaddr_un, sun_path)
682              + strlen(serv_addr.sun_path) + 1);
683
684       if (
685 #ifdef HAVE_W32_SYSTEM
686           _w32_sock_bind
687 #else
688           bind 
689 #endif
690           (fd, (struct sockaddr*)&serv_addr, len) == -1)
691         {
692           log_error ("error binding socket to `%s': %s\n",
693                      serv_addr.sun_path, strerror (errno) );
694           close (fd);
695           exit (1);
696         }
697   
698       if (listen (fd, 5 ) == -1)
699         {
700           log_error ("listen() failed: %s\n", strerror (errno));
701           close (fd);
702           exit (1);
703         }
704
705       if (opt.verbose)
706         log_info ("listening on socket `%s'\n", socket_name );
707
708
709       fflush (NULL);
710 #ifndef HAVE_W32_SYSTEM
711       pid = fork ();
712       if (pid == (pid_t)-1) 
713         {
714           log_fatal ("fork failed: %s\n", strerror (errno) );
715           exit (1);
716         }
717       else if (pid) 
718         { /* we are the parent */
719           char *infostr;
720           
721           close (fd);
722           
723           /* create the info string: <name>:<pid>:<protocol_version> */
724           if (asprintf (&infostr, "SCDAEMON_INFO=%s:%lu:1",
725                         socket_name, (ulong)pid ) < 0)
726             {
727               log_error ("out of core\n");
728               kill (pid, SIGTERM);
729               exit (1);
730             }
731           *socket_name = 0; /* don't let cleanup() remove the socket -
732                                the child should do this from now on */
733           if (argc) 
734             { /* run the program given on the commandline */
735               if (putenv (infostr))
736                 {
737                   log_error ("failed to set environment: %s\n",
738                              strerror (errno) );
739                   kill (pid, SIGTERM );
740                   exit (1);
741                 }
742               execvp (argv[0], argv);
743               log_error ("failed to run the command: %s\n", strerror (errno));
744               kill (pid, SIGTERM);
745               exit (1);
746             }
747           else
748             {
749               /* print the environment string, so that the caller can use
750                  shell's eval to set it */
751               if (csh_style)
752                 {
753                   *strchr (infostr, '=') = ' ';
754                   printf ( "setenv %s\n", infostr);
755                 }
756               else
757                 {
758                   printf ( "%s; export SCDAEMON_INFO;\n", infostr);
759                 }
760               free (infostr);
761               exit (0); 
762             }
763           /* NOTREACHED */
764         } /* end parent */
765       
766       /* this is the child */
767
768       /* detach from tty and put process into a new session */
769       if (!nodetach )
770         {  /* close stdin, stdout and stderr unless it is the log stream */
771           for (i=0; i <= 2; i++) 
772             {
773               if ( log_get_fd () != i)
774                 close (i);
775             }
776           if (setsid() == -1)
777             {
778               log_error ("setsid() failed: %s\n", strerror(errno) );
779               cleanup ();
780               exit (1);
781             }
782         }
783
784       /* setup signals */
785       {
786         struct sigaction oact, nact;
787         
788         nact.sa_handler = cleanup_sh;
789         sigemptyset (&nact.sa_mask);
790         nact.sa_flags = 0;
791         
792         sigaction (SIGHUP, NULL, &oact);
793         if (oact.sa_handler != SIG_IGN)
794           sigaction (SIGHUP, &nact, NULL);
795         sigaction( SIGTERM, NULL, &oact );
796         if (oact.sa_handler != SIG_IGN)
797           sigaction (SIGTERM, &nact, NULL);
798         nact.sa_handler = SIG_IGN;
799         sigaction (SIGPIPE, &nact, NULL);
800         sigaction (SIGINT, &nact, NULL);
801       }
802
803       if (chdir("/"))
804         {
805           log_error ("chdir to / failed: %s\n", strerror (errno));
806           exit (1);
807         }
808
809 #endif /*!HAVE_W32_SYSTEM*/
810
811       scd_command_handler (fd);
812
813       close (fd);
814     }
815   
816   return 0;
817 }
818
819 void
820 scd_exit (int rc)
821 {
822 #if 0
823 #warning no update_random_seed_file
824   update_random_seed_file();
825 #endif
826 #if 0
827   /* at this time a bit annoying */
828   if (opt.debug & DBG_MEMSTAT_VALUE)
829     {
830       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
831       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
832     }
833   if (opt.debug)
834     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
835 #endif
836   gcry_control (GCRYCTL_TERM_SECMEM );
837   rc = rc? rc : log_get_errorcount(0)? 2 : 0;
838   exit (rc);
839 }
840
841
842 void
843 scd_init_default_ctrl (CTRL ctrl)
844 {
845   ctrl->reader_slot = -1;
846 }
847
848
849 #ifdef USE_GNU_PTH
850
851 static void
852 handle_signal (int signo)
853 {
854   switch (signo)
855     {
856 #ifndef HAVE_W32_SYSTEM
857     case SIGHUP:
858       log_info ("SIGHUP received - "
859                 "re-reading configuration and resetting cards\n");
860 /*       reread_configuration (); */
861       break;
862       
863     case SIGUSR1:
864       log_info ("SIGUSR1 received - no action defined\n");
865       break;
866
867     case SIGUSR2:
868       log_info ("SIGUSR2 received - no action defined\n");
869       break;
870
871     case SIGTERM:
872       if (!shutdown_pending)
873         log_info ("SIGTERM received - shutting down ...\n");
874       else
875         log_info ("SIGTERM received - still %ld running threads\n",
876                   pth_ctrl( PTH_CTRL_GETTHREADS ));
877       shutdown_pending++;
878       if (shutdown_pending > 2)
879         {
880           log_info ("shutdown forced\n");
881           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
882           cleanup ();
883           scd_exit (0);
884         }
885       break;
886         
887     case SIGINT:
888       log_info ("SIGINT received - immediate shutdown\n");
889       log_info( "%s %s stopped\n", strusage(11), strusage(13));
890       cleanup ();
891       scd_exit (0);
892       break;
893 #endif /*!HAVE_W32_SYSTEM*/
894
895     default:
896       log_info ("signal %d received - no action defined\n", signo);
897     }
898 }
899
900 static void
901 handle_tick (void)
902 {
903   scd_update_reader_status_file ();
904 }
905
906 static void *
907 ticker_thread (void *dummy_arg)
908 {
909   pth_event_t sigs_ev, time_ev = NULL;
910   sigset_t sigs;
911   int signo;
912
913 #ifndef HAVE_W32_SYSTEM /* fixme */
914   sigemptyset (&sigs );
915   sigaddset (&sigs, SIGHUP);
916   sigaddset (&sigs, SIGUSR1);
917   sigaddset (&sigs, SIGUSR2);
918   sigaddset (&sigs, SIGINT);
919   sigaddset (&sigs, SIGTERM);
920   sigs_ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
921 #else
922   sigs_ev = NULL;
923 #endif
924   
925   while (!shutdown_pending)
926     {
927       if (!time_ev)
928         {
929           time_ev = pth_event (PTH_EVENT_TIME, pth_timeout (2, 0));
930           if (time_ev)
931             pth_event_concat (sigs_ev, time_ev, NULL);
932         }
933
934       if (pth_wait (sigs_ev) < 1)
935         continue;
936
937       if (
938 #ifdef PTH_STATUS_OCCURRED     /* This is Pth 2 */
939           pth_event_status (sigs_ev) == PTH_STATUS_OCCURRED
940 #else
941           pth_event_occurred (sigs_ev)
942 #endif
943           )
944         handle_signal (signo);
945
946       /* Always run the ticker. */
947       if (!shutdown_pending)
948         {
949           pth_event_isolate (sigs_ev);
950           pth_event_free (time_ev, PTH_FREE_ALL);
951           time_ev = NULL;
952           handle_tick ();
953         }
954     }
955
956   pth_event_free (sigs_ev, PTH_FREE_ALL);
957   return NULL;
958 }
959 #endif /*USE_GNU_PTH*/