A whole bunch of changes to allow building for W32.
[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   { oDebugSC,  "debug-sc",  1, N_("|N|set OpenSC debug level to N")},
112   { oNoDetach, "no-detach" ,0, N_("do not detach from the console")},
113   { oLogFile,  "log-file"   ,2, N_("use a log file for the server")},
114   { oReaderPort, "reader-port", 2, N_("|N|connect to reader at port N")},
115   { octapiDriver, "ctapi-driver", 2, N_("|NAME|use NAME as ct-API driver")},
116   { opcscDriver, "pcsc-driver", 2, N_("|NAME|use NAME as PC/SC driver")},
117   { oDisableCCID, "disable-ccid", 0,
118 #ifdef HAVE_LIBUSB
119                                     N_("do not use the internal CCID driver")
120 #else
121                                     "@"
122 #endif
123                                          /* end --disable-ccid */},
124   { oDisableOpenSC, "disable-opensc", 0,
125 #ifdef HAVE_OPENSC
126                                     N_("do not use the OpenSC layer")
127 #else
128                                     "@"
129 #endif
130                                          /* end --disable-opensc */},
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 #ifdef HAVE_W32_SYSTEM
141 #define DEFAULT_PCSC_DRIVER "winscard.dll"
142 #else
143 #define DEFAULT_PCSC_DRIVER "libpcsclite.so"
144 #endif
145
146
147 static volatile int caught_fatal_sig = 0;
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[128];
157
158
159 #ifndef HAVE_OPENSC
160 #ifdef USE_GNU_PTH
161 #ifndef HAVE_W32_SYSTEM
162 /* Pth wrapper function definitions. */
163 GCRY_THREAD_OPTION_PTH_IMPL;
164 #endif
165
166 static void *ticker_thread (void *arg);
167 #endif /*USE_GNU_PTH*/
168 #endif /*!HAVE_OPENSC*/
169
170 static const char *
171 my_strusage (int level)
172 {
173   const char *p;
174   switch (level)
175     {
176     case 11: p = "scdaemon (GnuPG)";
177       break;
178     case 13: p = VERSION; break;
179     case 17: p = PRINTABLE_OS_NAME; break;
180     case 19: p = _("Please report bugs to <" PACKAGE_BUGREPORT ">.\n");
181       break;
182     case 1:
183     case 40: p =  _("Usage: scdaemon [options] (-h for help)");
184       break;
185     case 41: p =  _("Syntax: scdaemon [options] [command [args]]\n"
186                     "Smartcard daemon for GnuPG\n");
187     break;
188     
189     default: p = NULL;
190     }
191   return p;
192 }
193
194
195
196 static void
197 i18n_init (void)
198 {
199 #ifdef USE_SIMPLE_GETTEXT
200     set_gettext_file( PACKAGE_GT );
201 #else
202 #ifdef ENABLE_NLS
203     setlocale (LC_ALL, "");
204     bindtextdomain (PACKAGE_GT, LOCALEDIR);
205     textdomain (PACKAGE_GT);
206 #endif
207 #endif
208 }
209
210
211
212 /* Used by gcry for logging */
213 static void
214 my_gcry_logger (void *dummy, int level, const char *fmt, va_list arg_ptr)
215 {
216   /* translate the log levels */
217   switch (level)
218     {
219     case GCRY_LOG_CONT: level = JNLIB_LOG_CONT; break;
220     case GCRY_LOG_INFO: level = JNLIB_LOG_INFO; break;
221     case GCRY_LOG_WARN: level = JNLIB_LOG_WARN; break;
222     case GCRY_LOG_ERROR:level = JNLIB_LOG_ERROR; break;
223     case GCRY_LOG_FATAL:level = JNLIB_LOG_FATAL; break;
224     case GCRY_LOG_BUG:  level = JNLIB_LOG_BUG; break;
225     case GCRY_LOG_DEBUG:level = JNLIB_LOG_DEBUG; break;
226     default:            level = JNLIB_LOG_ERROR; break;  
227     }
228   log_logv (level, fmt, arg_ptr);
229 }
230
231
232 /* Setup the debugging.  With a LEVEL of NULL only the active debug
233    flags are propagated to the subsystems.  With LEVEL set, a specific
234    set of debug flags is set; thus overriding all flags already
235    set. */
236 static void
237 set_debug (const char *level)
238 {
239   if (!level)
240     ;
241   else if (!strcmp (level, "none"))
242     opt.debug = 0;
243   else if (!strcmp (level, "basic"))
244     opt.debug = DBG_ASSUAN_VALUE;
245   else if (!strcmp (level, "advanced"))
246     opt.debug = DBG_ASSUAN_VALUE|DBG_COMMAND_VALUE;
247   else if (!strcmp (level, "expert"))
248     opt.debug = (DBG_ASSUAN_VALUE|DBG_COMMAND_VALUE
249                  |DBG_CACHE_VALUE|DBG_CARD_IO_VALUE);
250   else if (!strcmp (level, "guru"))
251     opt.debug = ~0;
252   else
253     {
254       log_error (_("invalid debug-level `%s' given\n"), level);
255       scd_exit(2);
256     }
257
258
259   if (opt.debug && !opt.verbose)
260     opt.verbose = 1;
261   if (opt.debug && opt.quiet)
262     opt.quiet = 0;
263
264   if (opt.debug & DBG_MPI_VALUE)
265     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 2);
266   if (opt.debug & DBG_CRYPTO_VALUE )
267     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1);
268   gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
269 }
270  
271
272
273 static void
274 cleanup (void)
275 {
276   if (*socket_name)
277     {
278       char *p;
279
280       remove (socket_name);
281       p = strrchr (socket_name, '/');
282       if (p)
283         {
284           *p = 0;
285           rmdir (socket_name);
286           *p = '/';
287         }
288       *socket_name = 0;
289     }
290 }
291
292
293 static RETSIGTYPE
294 cleanup_sh (int sig)
295 {
296   if (caught_fatal_sig)
297     raise (sig);
298   caught_fatal_sig = 1;
299
300   /* gcry_control( GCRYCTL_TERM_SECMEM );*/
301   cleanup ();
302
303 #ifndef HAVE_DOSISH_SYSTEM
304   {     /* reset action to default action and raise signal again */
305     struct sigaction nact;
306     nact.sa_handler = SIG_DFL;
307     sigemptyset( &nact.sa_mask );
308     nact.sa_flags = 0;
309     sigaction( sig, &nact, NULL);
310   }
311 #endif
312   raise( sig );
313 }
314
315 int
316 main (int argc, char **argv )
317 {
318   ARGPARSE_ARGS pargs;
319   int orig_argc;
320   gpg_error_t err;
321   int may_coredump;
322   char **orig_argv;
323   FILE *configfp = NULL;
324   char *configname = NULL;
325   const char *shell;
326   unsigned configlineno;
327   int parse_debug = 0;
328   const char *debug_level = NULL;
329   int default_config =1;
330   int greeting = 0;
331   int nogreeting = 0;
332   int pipe_server = 0;
333   int is_daemon = 0;
334   int nodetach = 0;
335   int csh_style = 0;
336   char *logfile = NULL;
337   int debug_wait = 0;
338   int gpgconf_list = 0;
339   const char *config_filename = NULL;
340
341   set_strusage (my_strusage);
342   gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
343   /* Please note that we may running SUID(ROOT), so be very CAREFUL
344      when adding any stuff between here and the call to INIT_SECMEM()
345      somewhere after the option parsing */
346   log_set_prefix ("scdaemon", 1|4); 
347   /* Try to auto set the character set.  */
348   set_native_charset (NULL); 
349
350   i18n_init ();
351
352   /* Libgcrypt requires us to register the threading model first.
353      Note that this will also do the pth_init. */
354 #ifndef HAVE_OPENSC
355 #ifdef USE_GNU_PTH
356 # ifdef HAVE_W32_SYSTEM
357   pth_init ();
358 # else /*!HAVE_W32_SYSTEM*/
359   err = gcry_control (GCRYCTL_SET_THREAD_CBS, &gcry_threads_pth);
360   if (err)
361     {
362       log_fatal ("can't register GNU Pth with Libgcrypt: %s\n",
363                  gpg_strerror (err));
364     }
365 # endif /*!HAVE_W32_SYSTEM*/
366 #endif /*USE_GNU_PTH*/
367 #endif /*!HAVE_OPENSC*/
368
369   /* Check that the libraries are suitable.  Do it here because
370      the option parsing may need services of the library */
371   if (!gcry_check_version (NEED_LIBGCRYPT_VERSION) )
372     {
373       log_fatal( _("libgcrypt is too old (need %s, have %s)\n"),
374                  NEED_LIBGCRYPT_VERSION, gcry_check_version (NULL) );
375     }
376
377   ksba_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
378
379   assuan_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
380   assuan_set_assuan_log_stream (log_get_stream ());
381   assuan_set_assuan_log_prefix (log_get_prefix (NULL));
382
383   gcry_set_log_handler (my_gcry_logger, NULL);
384   gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
385
386   may_coredump = disable_core_dumps ();
387
388   /* Set default options. */
389   opt.pcsc_driver = DEFAULT_PCSC_DRIVER; 
390
391
392   shell = getenv ("SHELL");
393   if (shell && strlen (shell) >= 3 && !strcmp (shell+strlen (shell)-3, "csh") )
394     csh_style = 1;
395   
396   /* FIXME: Using this homedir option does only make sense when not
397      running as a system service.  We might want to check for this by
398      looking at the uid or ebtter use an explict option for this */
399   opt.homedir = getenv("GNUPGHOME");
400   if (!opt.homedir || !*opt.homedir)
401     opt.homedir = GNUPG_DEFAULT_HOMEDIR;
402
403   /* check whether we have a config file on the commandline */
404   orig_argc = argc;
405   orig_argv = argv;
406   pargs.argc = &argc;
407   pargs.argv = &argv;
408   pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
409   while (arg_parse( &pargs, opts))
410     {
411       if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll)
412         parse_debug++;
413       else if (pargs.r_opt == oOptions)
414         { /* yes there is one, so we do not try the default one, but
415              read the option file when it is encountered at the
416              commandline */
417           default_config = 0;
418         }
419         else if (pargs.r_opt == oNoOptions)
420           default_config = 0; /* --no-options */
421         else if (pargs.r_opt == oHomedir)
422           opt.homedir = pargs.r.ret_str;
423     }
424
425   /* initialize the secure memory. */
426   gcry_control (GCRYCTL_INIT_SECMEM, 16384, 0);
427   maybe_setuid = 0;
428
429   /* 
430      Now we are working under our real uid 
431   */
432
433
434   if (default_config)
435     configname = make_filename (opt.homedir, "scdaemon.conf", NULL );
436
437   
438   argc = orig_argc;
439   argv = orig_argv;
440   pargs.argc = &argc;
441   pargs.argv = &argv;
442   pargs.flags=  1;  /* do not remove the args */
443  next_pass:
444   if (configname)
445     {
446       configlineno = 0;
447       configfp = fopen (configname, "r");
448       if (!configfp)
449         {
450           if (default_config)
451             {
452               if( parse_debug )
453                 log_info (_("NOTE: no default option file `%s'\n"),
454                           configname );
455             }
456           else
457             {
458               log_error (_("option file `%s': %s\n"),
459                          configname, strerror(errno) );
460               exit(2);
461             }
462           xfree (configname); 
463           configname = NULL;
464         }
465       if (parse_debug && configname )
466         log_info (_("reading options from `%s'\n"), configname );
467       default_config = 0;
468     }
469
470   while (optfile_parse( configfp, configname, &configlineno, &pargs, opts) )
471     {
472       switch (pargs.r_opt)
473         {
474         case aGPGConfList: gpgconf_list = 1; break;
475         case oQuiet: opt.quiet = 1; break;
476         case oVerbose: opt.verbose++; break;
477         case oBatch: opt.batch=1; break;
478
479         case oDebug: opt.debug |= pargs.r.ret_ulong; break;
480         case oDebugAll: opt.debug = ~0; break;
481         case oDebugLevel: debug_level = pargs.r.ret_str; break;
482         case oDebugWait: debug_wait = pargs.r.ret_int; break;
483         case oDebugSC: opt.debug_sc = pargs.r.ret_int; break;
484
485         case oOptions:
486           /* config files may not be nested (silently ignore them) */
487           if (!configfp)
488             {
489                 xfree(configname);
490                 configname = xstrdup(pargs.r.ret_str);
491                 goto next_pass;
492             }
493           break;
494         case oNoGreeting: nogreeting = 1; break;
495         case oNoVerbose: opt.verbose = 0; break;
496         case oNoOptions: break; /* no-options */
497         case oHomedir: opt.homedir = pargs.r.ret_str; break;
498         case oNoDetach: nodetach = 1; break;
499         case oLogFile: logfile = pargs.r.ret_str; break;
500         case oCsh: csh_style = 1; break;
501         case oSh: csh_style = 0; break;
502         case oServer: pipe_server = 1; break;
503         case oDaemon: is_daemon = 1; break;
504
505         case oReaderPort: opt.reader_port = pargs.r.ret_str; break;
506         case octapiDriver: opt.ctapi_driver = pargs.r.ret_str; break;
507         case opcscDriver: opt.pcsc_driver = pargs.r.ret_str; break;
508         case oDisableCCID: opt.disable_ccid = 1; break;
509         case oDisableOpenSC: opt.disable_opensc = 1; break;
510
511         case oAllowAdmin: opt.allow_admin = 1; break;
512         case oDenyAdmin: opt.allow_admin = 0; break;
513
514         case oDisableApplication:
515           add_to_strlist (&opt.disabled_applications, pargs.r.ret_str); 
516           break;
517
518         default : pargs.err = configfp? 1:2; break;
519         }
520     }
521   if (configfp)
522     {
523       fclose( configfp );
524       configfp = NULL;
525       /* Keep a copy of the config name for use by --gpgconf-list. */
526       config_filename = configname;
527       configname = NULL;
528       goto next_pass;
529     }
530   xfree (configname);
531   configname = NULL;
532   if (log_get_errorcount(0))
533     exit(2);
534   if (nogreeting )
535     greeting = 0;
536
537   if (greeting)
538     {
539       fprintf (stderr, "%s %s; %s\n",
540                  strusage(11), strusage(13), strusage(14) );
541       fprintf (stderr, "%s\n", strusage(15) );
542     }
543 #ifdef IS_DEVELOPMENT_VERSION
544   log_info ("NOTE: this is a development version!\n");
545 #endif
546
547  
548   if (atexit (cleanup))
549     {
550       log_error ("atexit failed\n");
551       cleanup ();
552       exit (1);
553     }
554
555   set_debug (debug_level);
556
557   if (debug_wait && pipe_server)
558     {
559       log_debug ("waiting for debugger - my pid is %u .....\n",
560                  (unsigned int)getpid());
561       sleep (debug_wait);
562       log_debug ("... okay\n");
563     }
564   
565   if (gpgconf_list)
566     {
567       /* List options and default values in the GPG Conf format.  */
568
569       /* The following list is taken from gnupg/tools/gpgconf-comp.c.  */
570       /* Option flags.  YOU MUST NOT CHANGE THE NUMBERS OF THE EXISTING
571          FLAGS, AS THEY ARE PART OF THE EXTERNAL INTERFACE.  */
572 #define GC_OPT_FLAG_NONE        0UL
573       /* The RUNTIME flag for an option indicates that the option can be
574          changed at runtime.  */
575 #define GC_OPT_FLAG_RUNTIME     (1UL << 3)
576       /* The DEFAULT flag for an option indicates that the option has a
577          default value.  */
578 #define GC_OPT_FLAG_DEFAULT     (1UL << 4)
579       /* The DEF_DESC flag for an option indicates that the option has a
580          default, which is described by the value of the default field.  */
581 #define GC_OPT_FLAG_DEF_DESC    (1UL << 5)
582       /* The NO_ARG_DESC flag for an option indicates that the argument has
583          a default, which is described by the value of the ARGDEF field.  */
584 #define GC_OPT_FLAG_NO_ARG_DESC (1UL << 6)
585       if (!config_filename)
586         config_filename = make_filename (opt.homedir, "scdaemon.conf", NULL );
587
588       printf ("gpgconf-scdaemon.conf:%lu:\"%s\n",
589               GC_OPT_FLAG_DEFAULT, config_filename);
590         
591       printf ("verbose:%lu:\n"
592               "quiet:%lu:\n"
593               "debug-level:%lu:\"none:\n"
594               "log-file:%lu:\n",
595               GC_OPT_FLAG_NONE,
596               GC_OPT_FLAG_NONE,
597               GC_OPT_FLAG_DEFAULT,
598               GC_OPT_FLAG_NONE );
599
600       printf ("reader-port:%lu:\n", GC_OPT_FLAG_NONE );
601       printf ("ctapi-driver:%lu:\n", GC_OPT_FLAG_NONE );
602       printf ("pcsc-driver:%lu:\"%s:\n",
603               GC_OPT_FLAG_DEFAULT, DEFAULT_PCSC_DRIVER );
604 #ifdef HAVE_LIBUSB
605       printf ("disable-ccid:%lu:\n", GC_OPT_FLAG_NONE );
606 #endif
607 #ifdef HAVE_LIBUSB
608       printf ("disable-opensc:%lu:\n", GC_OPT_FLAG_NONE );
609 #endif
610       printf ("allow-admin:%lu:\n", GC_OPT_FLAG_NONE );
611
612
613       scd_exit (0);
614     }
615
616   /* now start with logging to a file if this is desired */
617   if (logfile)
618     {
619       log_set_file (logfile);
620       log_set_prefix (NULL, 1|2|4);
621     }
622
623
624   if (pipe_server)
625     { /* This is the simple pipe based server */
626 #ifndef HAVE_OPENSC
627 #ifdef USE_GNU_PTH
628       pth_attr_t tattr;
629  
630       tattr = pth_attr_new();
631       pth_attr_set (tattr, PTH_ATTR_JOINABLE, 0);
632       pth_attr_set (tattr, PTH_ATTR_STACK_SIZE, 512*1024);
633       pth_attr_set (tattr, PTH_ATTR_NAME, "ticker");
634
635       if (!pth_spawn (tattr, ticker_thread, NULL))
636         {
637           log_error ("error spawning ticker thread: %s\n", strerror (errno));
638           scd_exit (2);
639         }
640 #endif /*USE_GNU_PTH*/
641 #endif /*!HAVE_OPENSC*/
642       scd_command_handler (-1);
643     }
644   else if (!is_daemon)
645     {
646       log_info (_("please use the option `--daemon'"
647                   " to run the program in the background\n"));
648     }
649   else
650     { /* regular server mode */
651       int fd;
652       pid_t pid;
653       int i;
654       int len;
655       struct sockaddr_un serv_addr;
656       char *p;
657
658       /* fixme: if there is already a running gpg-agent we should
659          share the same directory - and vice versa */
660       *socket_name = 0;
661       snprintf (socket_name, DIM(socket_name)-1,
662                 "/tmp/gpg-XXXXXX/S.scdaemon");
663       socket_name[DIM(socket_name)-1] = 0;
664       p = strrchr (socket_name, '/');
665       if (!p)
666         BUG ();
667       *p = 0;;
668
669 #ifndef HAVE_W32_SYSTEM
670       if (!mkdtemp(socket_name))
671         {
672           log_error ("can't create directory `%s': %s\n",
673                      socket_name, strerror(errno) );
674           exit (1);
675         }
676 #endif
677       *p = '/';
678
679       if (strchr (socket_name, ':') )
680         {
681           log_error ("colons are not allowed in the socket name\n");
682           exit (1);
683         }
684       if (strlen (socket_name)+1 >= sizeof serv_addr.sun_path ) 
685         {
686           log_error ("name of socket to long\n");
687           exit (1);
688         }
689    
690
691 #ifdef HAVE_W32_SYSTEM
692       fd = _w32_sock_new (AF_UNIX, SOCK_STREAM, 0);
693 #else
694       fd = socket (AF_UNIX, SOCK_STREAM, 0);
695 #endif
696       if (fd == -1)
697         {
698           log_error ("can't create socket: %s\n", strerror(errno) );
699           exit (1);
700         }
701
702       memset (&serv_addr, 0, sizeof serv_addr);
703       serv_addr.sun_family = AF_UNIX;
704       strcpy (serv_addr.sun_path, socket_name);
705       len = (offsetof (struct sockaddr_un, sun_path)
706              + strlen(serv_addr.sun_path) + 1);
707
708       if (
709 #ifdef HAVE_W32_SYSTEM
710           _w32_sock_bind
711 #else
712           bind 
713 #endif
714           (fd, (struct sockaddr*)&serv_addr, len) == -1)
715         {
716           log_error ("error binding socket to `%s': %s\n",
717                      serv_addr.sun_path, strerror (errno) );
718           close (fd);
719           exit (1);
720         }
721   
722       if (listen (fd, 5 ) == -1)
723         {
724           log_error ("listen() failed: %s\n", strerror (errno));
725           close (fd);
726           exit (1);
727         }
728
729       if (opt.verbose)
730         log_info ("listening on socket `%s'\n", socket_name );
731
732
733       fflush (NULL);
734 #ifndef HAVE_W32_SYSTEM
735       pid = fork ();
736       if (pid == (pid_t)-1) 
737         {
738           log_fatal ("fork failed: %s\n", strerror (errno) );
739           exit (1);
740         }
741       else if (pid) 
742         { /* we are the parent */
743           char *infostr;
744           
745           close (fd);
746           
747           /* create the info string: <name>:<pid>:<protocol_version> */
748           if (asprintf (&infostr, "SCDAEMON_INFO=%s:%lu:1",
749                         socket_name, (ulong)pid ) < 0)
750             {
751               log_error ("out of core\n");
752               kill (pid, SIGTERM);
753               exit (1);
754             }
755           *socket_name = 0; /* don't let cleanup() remove the socket -
756                                the child should do this from now on */
757           if (argc) 
758             { /* run the program given on the commandline */
759               if (putenv (infostr))
760                 {
761                   log_error ("failed to set environment: %s\n",
762                              strerror (errno) );
763                   kill (pid, SIGTERM );
764                   exit (1);
765                 }
766               execvp (argv[0], argv);
767               log_error ("failed to run the command: %s\n", strerror (errno));
768               kill (pid, SIGTERM);
769               exit (1);
770             }
771           else
772             {
773               /* print the environment string, so that the caller can use
774                  shell's eval to set it */
775               if (csh_style)
776                 {
777                   *strchr (infostr, '=') = ' ';
778                   printf ( "setenv %s\n", infostr);
779                 }
780               else
781                 {
782                   printf ( "%s; export SCDAEMON_INFO;\n", infostr);
783                 }
784               free (infostr);
785               exit (0); 
786             }
787           /* NOTREACHED */
788         } /* end parent */
789       
790       /* this is the child */
791
792       /* detach from tty and put process into a new session */
793       if (!nodetach )
794         {  /* close stdin, stdout and stderr unless it is the log stream */
795           for (i=0; i <= 2; i++) 
796             {
797               if ( log_get_fd () != i)
798                 close (i);
799             }
800           if (setsid() == -1)
801             {
802               log_error ("setsid() failed: %s\n", strerror(errno) );
803               cleanup ();
804               exit (1);
805             }
806         }
807
808       /* setup signals */
809       {
810         struct sigaction oact, nact;
811         
812         nact.sa_handler = cleanup_sh;
813         sigemptyset (&nact.sa_mask);
814         nact.sa_flags = 0;
815         
816         sigaction (SIGHUP, NULL, &oact);
817         if (oact.sa_handler != SIG_IGN)
818           sigaction (SIGHUP, &nact, NULL);
819         sigaction( SIGTERM, NULL, &oact );
820         if (oact.sa_handler != SIG_IGN)
821           sigaction (SIGTERM, &nact, NULL);
822         nact.sa_handler = SIG_IGN;
823         sigaction (SIGPIPE, &nact, NULL);
824         sigaction (SIGINT, &nact, NULL);
825       }
826
827       if (chdir("/"))
828         {
829           log_error ("chdir to / failed: %s\n", strerror (errno));
830           exit (1);
831         }
832
833 #endif /*!HAVE_W32_SYSTEM*/
834
835       scd_command_handler (fd);
836
837       close (fd);
838     }
839   
840   return 0;
841 }
842
843 void
844 scd_exit (int rc)
845 {
846 #if 0
847 #warning no update_random_seed_file
848   update_random_seed_file();
849 #endif
850 #if 0
851   /* at this time a bit annoying */
852   if (opt.debug & DBG_MEMSTAT_VALUE)
853     {
854       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
855       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
856     }
857   if (opt.debug)
858     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
859 #endif
860   gcry_control (GCRYCTL_TERM_SECMEM );
861   rc = rc? rc : log_get_errorcount(0)? 2 : 0;
862   exit (rc);
863 }
864
865
866 void
867 scd_init_default_ctrl (CTRL ctrl)
868 {
869   ctrl->reader_slot = -1;
870 }
871
872
873 #ifndef HAVE_OPENSC
874 #ifdef USE_GNU_PTH
875
876 static void
877 handle_signal (int signo)
878 {
879   switch (signo)
880     {
881 #ifndef HAVE_W32_SYSTEM
882     case SIGHUP:
883       log_info ("SIGHUP received - "
884                 "re-reading configuration and resetting cards\n");
885 /*       reread_configuration (); */
886       break;
887       
888     case SIGUSR1:
889       log_info ("SIGUSR1 received - no action defined\n");
890       break;
891
892     case SIGUSR2:
893       log_info ("SIGUSR2 received - no action defined\n");
894       break;
895
896     case SIGTERM:
897       if (!shutdown_pending)
898         log_info ("SIGTERM received - shutting down ...\n");
899       else
900         log_info ("SIGTERM received - still %ld running threads\n",
901                   pth_ctrl( PTH_CTRL_GETTHREADS ));
902       shutdown_pending++;
903       if (shutdown_pending > 2)
904         {
905           log_info ("shutdown forced\n");
906           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
907           cleanup ();
908           scd_exit (0);
909         }
910       break;
911         
912     case SIGINT:
913       log_info ("SIGINT received - immediate shutdown\n");
914       log_info( "%s %s stopped\n", strusage(11), strusage(13));
915       cleanup ();
916       scd_exit (0);
917       break;
918 #endif /*!HAVE_W32_SYSTEM*/
919
920     default:
921       log_info ("signal %d received - no action defined\n", signo);
922     }
923 }
924
925 static void
926 handle_tick (void)
927 {
928   scd_update_reader_status_file ();
929 }
930
931 static void *
932 ticker_thread (void *dummy_arg)
933 {
934   pth_event_t sigs_ev, time_ev = NULL;
935   sigset_t sigs;
936   int signo;
937
938 #ifndef HAVE_W32_SYSTEM /* fixme */
939   sigemptyset (&sigs );
940   sigaddset (&sigs, SIGHUP);
941   sigaddset (&sigs, SIGUSR1);
942   sigaddset (&sigs, SIGUSR2);
943   sigaddset (&sigs, SIGINT);
944   sigaddset (&sigs, SIGTERM);
945   sigs_ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
946 #else
947   sigs_ev = NULL;
948 #endif
949   
950   for (;;)
951     {
952       if (!time_ev)
953         {
954           time_ev = pth_event (PTH_EVENT_TIME, pth_timeout (2, 0));
955           if (time_ev)
956             pth_event_concat (sigs_ev, time_ev, NULL);
957         }
958
959       if (pth_wait (sigs_ev) < 1)
960         continue;
961
962       if (
963 #ifdef PTH_STATUS_OCCURRED     /* This is Pth 2 */
964           pth_event_status (sigs_ev) == PTH_STATUS_OCCURRED
965 #else
966           pth_event_occurred (sigs_ev)
967 #endif
968           )
969         handle_signal (signo);
970
971       /* Always run the ticker. */
972       if (!shutdown_pending)
973         {
974           pth_event_isolate (sigs_ev);
975           pth_event_free (time_ev, PTH_FREE_ALL);
976           time_ev = NULL;
977           handle_tick ();
978         }
979     }
980
981   pth_event_free (sigs_ev, PTH_FREE_ALL);
982 }
983 #endif /*USE_GNU_PTH*/
984 #endif /*!HAVE_OPENSC*/