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