Factored common gpgconf constants out
[gnupg.git] / scd / scdaemon.c
1 /* scdaemon.c  -  The GnuPG Smartcard Daemon
2  * Copyright (C) 2001, 2002, 2004, 2005, 
3  *               2007 Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
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 #include "gc-opt-flags.h"
56
57
58 enum cmd_and_opt_values 
59 { aNull = 0,
60   oCsh            = 'c',
61   oQuiet          = 'q',
62   oSh             = 's',
63   oVerbose        = 'v',
64   
65   oNoVerbose = 500,
66   aGPGConfList,
67   aGPGConfTest,
68   oOptions,
69   oDebug,
70   oDebugAll,
71   oDebugLevel,
72   oDebugWait,
73   oDebugAllowCoreDump,
74   oDebugCCIDDriver,
75   oNoGreeting,
76   oNoOptions,
77   oHomedir,
78   oNoDetach,
79   oNoGrab,
80   oLogFile,
81   oServer,
82   oMultiServer,
83   oDaemon,
84   oBatch,
85   oReaderPort,
86   octapiDriver,
87   opcscDriver,
88   oDisableCCID,
89   oDisableOpenSC,
90   oDisableKeypad,
91   oAllowAdmin,
92   oDenyAdmin,
93   oDisableApplication,
94   oDebugDisableTicker
95 };
96
97
98
99 static ARGPARSE_OPTS opts[] = {
100
101   { aGPGConfList, "gpgconf-list", 256, "@" },
102   { aGPGConfTest, "gpgconf-test", 256, "@" },
103   
104   { 301, NULL, 0, N_("@Options:\n ") },
105
106   { oServer,   "server",     0, N_("run in server mode (foreground)") },
107   { oMultiServer, "multi-server", 0,
108                                 N_("run in multi server mode (foreground)") },
109   { oDaemon,   "daemon",     0, N_("run in daemon mode (background)") },
110   { oVerbose, "verbose",   0, N_("verbose") },
111   { oQuiet,     "quiet",     0, N_("be somewhat more quiet") },
112   { oSh,        "sh",        0, N_("sh-style command output") },
113   { oCsh,       "csh",       0, N_("csh-style command output") },
114   { oOptions, "options"  , 2, N_("read options from file")},
115   { oDebug,     "debug"     ,4|16, "@"},
116   { oDebugAll, "debug-all"     ,0, "@"},
117   { oDebugLevel, "debug-level" ,2, "@"},
118   { oDebugWait,"debug-wait",1, "@"},
119   { oDebugAllowCoreDump, "debug-allow-core-dump", 0, "@" },
120   { oDebugCCIDDriver, "debug-ccid-driver", 0, "@"},
121   { oDebugDisableTicker, "debug-disable-ticker", 0, "@"},
122   { oNoDetach, "no-detach" ,0, N_("do not detach from the console")},
123   { oLogFile,  "log-file"   ,2, N_("use a log file for the server")},
124   { oReaderPort, "reader-port", 2, N_("|N|connect to reader at port N")},
125   { octapiDriver, "ctapi-driver", 2, N_("|NAME|use NAME as ct-API driver")},
126   { opcscDriver, "pcsc-driver", 2, N_("|NAME|use NAME as PC/SC driver")},
127   { oDisableCCID, "disable-ccid", 0,
128 #ifdef HAVE_LIBUSB
129                                     N_("do not use the internal CCID driver")
130 #else
131                                     "@"
132 #endif
133                                          /* end --disable-ccid */},
134   { oDisableKeypad, "disable-keypad", 0, N_("do not use a reader's keypad")},
135   { oAllowAdmin, "allow-admin", 0, N_("allow the use of admin card commands")},
136   { oDenyAdmin,  "deny-admin",  0, "@" },  
137   { oDisableApplication, "disable-application", 2, "@"},
138
139   {0}
140 };
141
142
143 /* The card driver we use by default for PC/SC.  */
144 #if defined(HAVE_W32_SYSTEM) || defined(__CYGWIN__)
145 #define DEFAULT_PCSC_DRIVER "winscard.dll"
146 #elif defined(__APPLE__)
147 #define DEFAULT_PCSC_DRIVER "/System/Library/Frameworks/PCSC.framework/PCSC"
148 #elif defined(__GLIBC__)
149 #define DEFAULT_PCSC_DRIVER "libpcsclite.so.1"
150 #else
151 #define DEFAULT_PCSC_DRIVER "libpcsclite.so"
152 #endif
153
154 /* The timer tick used for housekeeping stuff.  For Windows we use a
155    longer period as the SetWaitableTimer seems to signal earlier than
156    the 2 seconds.  */
157 #ifdef HAVE_W32_SYSTEM
158 #define TIMERTICK_INTERVAL    (4)
159 #else
160 #define TIMERTICK_INTERVAL    (2)    /* Seconds.  */
161 #endif
162
163
164 /* Flag to indicate that a shutdown was requested. */
165 static int shutdown_pending;
166
167 /* It is possible that we are currently running under setuid permissions */
168 static int maybe_setuid = 1;
169
170 /* Name of the communication socket */
171 static char *socket_name;
172
173
174 /* Debug flag to disable the ticker.  The ticker is in fact not
175    disabled but it won't perform any ticker specific actions. */
176 static int ticker_disabled;
177
178
179 \f
180 static char *create_socket_name (int use_standard_socket,
181                                  char *standard_name, char *template);
182 static int create_server_socket (int is_standard_name, const char *name);
183
184 static void *start_connection_thread (void *arg);
185 static void handle_connections (int listen_fd);
186
187 /* Pth wrapper function definitions. */
188 GCRY_THREAD_OPTION_PTH_IMPL;
189 static int fixed_gcry_pth_init (void)
190 {
191   return pth_self ()? 0 : (pth_init () == FALSE) ? errno : 0;
192 }
193
194
195 \f
196 static const char *
197 my_strusage (int level)
198 {
199   const char *p;
200   switch (level)
201     {
202     case 11: p = "scdaemon (GnuPG)";
203       break;
204     case 13: p = VERSION; break;
205     case 17: p = PRINTABLE_OS_NAME; break;
206     case 19: p = _("Please report bugs to <" PACKAGE_BUGREPORT ">.\n");
207       break;
208     case 1:
209     case 40: p =  _("Usage: scdaemon [options] (-h for help)");
210       break;
211     case 41: p =  _("Syntax: scdaemon [options] [command [args]]\n"
212                     "Smartcard daemon for GnuPG\n");
213     break;
214     
215     default: p = NULL;
216     }
217   return p;
218 }
219
220
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 && *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
286 int
287 main (int argc, char **argv )
288 {
289   ARGPARSE_ARGS pargs;
290   int orig_argc;
291   gpg_error_t err;
292   int may_coredump;
293   char **orig_argv;
294   FILE *configfp = NULL;
295   char *configname = NULL;
296   const char *shell;
297   unsigned int configlineno;
298   int parse_debug = 0;
299   const char *debug_level = NULL;
300   int default_config =1;
301   int greeting = 0;
302   int nogreeting = 0;
303   int pipe_server = 0;
304   int multi_server = 0;
305   int is_daemon = 0;
306   int nodetach = 0;
307   int csh_style = 0;
308   char *logfile = NULL;
309   int debug_wait = 0;
310   int gpgconf_list = 0;
311   const char *config_filename = NULL;
312   int allow_coredump = 0;
313
314   set_strusage (my_strusage);
315   gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
316   /* Please note that we may running SUID(ROOT), so be very CAREFUL
317      when adding any stuff between here and the call to INIT_SECMEM()
318      somewhere after the option parsing */
319   log_set_prefix ("scdaemon", 1|4); 
320
321   /* Make sure that our subsystems are ready.  */
322   init_common_subsystems ();
323
324   i18n_init ();
325
326   /* Libgcrypt requires us to register the threading model first.
327      Note that this will also do the pth_init. */
328   gcry_threads_pth.init = fixed_gcry_pth_init;
329   err = gcry_control (GCRYCTL_SET_THREAD_CBS, &gcry_threads_pth);
330   if (err)
331     {
332       log_fatal ("can't register GNU Pth with Libgcrypt: %s\n",
333                  gpg_strerror (err));
334     }
335
336   /* Check that the libraries are suitable.  Do it here because
337      the option parsing may need services of the library */
338   if (!gcry_check_version (NEED_LIBGCRYPT_VERSION) )
339     {
340       log_fatal (_("%s is too old (need %s, have %s)\n"), "libgcrypt",
341                  NEED_LIBGCRYPT_VERSION, gcry_check_version (NULL) );
342     }
343
344   ksba_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
345
346   assuan_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
347   assuan_set_assuan_log_stream (log_get_stream ());
348   assuan_set_assuan_log_prefix (log_get_prefix (NULL));
349   assuan_set_assuan_err_source (GPG_ERR_SOURCE_DEFAULT);
350
351   setup_libgcrypt_logging ();
352   gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
353
354   may_coredump = disable_core_dumps ();
355
356   /* Set default options. */
357   opt.pcsc_driver = DEFAULT_PCSC_DRIVER; 
358
359
360   shell = getenv ("SHELL");
361   if (shell && strlen (shell) >= 3 && !strcmp (shell+strlen (shell)-3, "csh") )
362     csh_style = 1;
363   
364   opt.homedir = default_homedir ();
365
366   /* Check whether we have a config file on the commandline */
367   orig_argc = argc;
368   orig_argv = argv;
369   pargs.argc = &argc;
370   pargs.argv = &argv;
371   pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
372   while (arg_parse( &pargs, opts))
373     {
374       if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll)
375         parse_debug++;
376       else if (pargs.r_opt == oOptions)
377         { /* yes there is one, so we do not try the default one, but
378              read the option file when it is encountered at the
379              commandline */
380           default_config = 0;
381         }
382         else if (pargs.r_opt == oNoOptions)
383           default_config = 0; /* --no-options */
384         else if (pargs.r_opt == oHomedir)
385           opt.homedir = pargs.r.ret_str;
386     }
387
388   /* initialize the secure memory. */
389   gcry_control (GCRYCTL_INIT_SECMEM, 16384, 0);
390   maybe_setuid = 0;
391
392   /* 
393      Now we are working under our real uid 
394   */
395
396
397   if (default_config)
398     configname = make_filename (opt.homedir, "scdaemon.conf", NULL );
399
400   
401   argc = orig_argc;
402   argv = orig_argv;
403   pargs.argc = &argc;
404   pargs.argv = &argv;
405   pargs.flags=  1;  /* do not remove the args */
406  next_pass:
407   if (configname)
408     {
409       configlineno = 0;
410       configfp = fopen (configname, "r");
411       if (!configfp)
412         {
413           if (default_config)
414             {
415               if( parse_debug )
416                 log_info (_("NOTE: no default option file `%s'\n"),
417                           configname );
418             }
419           else
420             {
421               log_error (_("option file `%s': %s\n"),
422                          configname, strerror(errno) );
423               exit(2);
424             }
425           xfree (configname); 
426           configname = NULL;
427         }
428       if (parse_debug && configname )
429         log_info (_("reading options from `%s'\n"), configname );
430       default_config = 0;
431     }
432
433   while (optfile_parse( configfp, configname, &configlineno, &pargs, opts) )
434     {
435       switch (pargs.r_opt)
436         {
437         case aGPGConfList: gpgconf_list = 1; break;
438         case aGPGConfTest: gpgconf_list = 2; break;
439         case oQuiet: opt.quiet = 1; break;
440         case oVerbose: opt.verbose++; break;
441         case oBatch: opt.batch=1; break;
442
443         case oDebug: opt.debug |= pargs.r.ret_ulong; break;
444         case oDebugAll: opt.debug = ~0; break;
445         case oDebugLevel: debug_level = pargs.r.ret_str; break;
446         case oDebugWait: debug_wait = pargs.r.ret_int; break;
447         case oDebugAllowCoreDump:
448           enable_core_dumps ();
449           allow_coredump = 1;
450           break;
451         case oDebugCCIDDriver: 
452 #ifdef HAVE_LIBUSB
453           ccid_set_debug_level (ccid_set_debug_level (-1)+1);
454 #endif /*HAVE_LIBUSB*/
455           break;
456         case oDebugDisableTicker: ticker_disabled = 1; break;
457
458         case oOptions:
459           /* config files may not be nested (silently ignore them) */
460           if (!configfp)
461             {
462                 xfree(configname);
463                 configname = xstrdup(pargs.r.ret_str);
464                 goto next_pass;
465             }
466           break;
467         case oNoGreeting: nogreeting = 1; break;
468         case oNoVerbose: opt.verbose = 0; break;
469         case oNoOptions: break; /* no-options */
470         case oHomedir: opt.homedir = pargs.r.ret_str; break;
471         case oNoDetach: nodetach = 1; break;
472         case oLogFile: logfile = pargs.r.ret_str; break;
473         case oCsh: csh_style = 1; break;
474         case oSh: csh_style = 0; break;
475         case oServer: pipe_server = 1; break;
476         case oMultiServer: pipe_server = 1; multi_server = 1; break;
477         case oDaemon: is_daemon = 1; break;
478
479         case oReaderPort: opt.reader_port = pargs.r.ret_str; break;
480         case octapiDriver: opt.ctapi_driver = pargs.r.ret_str; break;
481         case opcscDriver: opt.pcsc_driver = pargs.r.ret_str; break;
482         case oDisableCCID: opt.disable_ccid = 1; break;
483         case oDisableOpenSC: break;
484
485         case oDisableKeypad: opt.disable_keypad = 1; break;
486
487         case oAllowAdmin: opt.allow_admin = 1; break;
488         case oDenyAdmin: opt.allow_admin = 0; break;
489
490         case oDisableApplication:
491           add_to_strlist (&opt.disabled_applications, pargs.r.ret_str); 
492           break;
493
494         default : pargs.err = configfp? 1:2; break;
495         }
496     }
497   if (configfp)
498     {
499       fclose( configfp );
500       configfp = NULL;
501       /* Keep a copy of the config name for use by --gpgconf-list. */
502       config_filename = configname;
503       configname = NULL;
504       goto next_pass;
505     }
506   xfree (configname);
507   configname = NULL;
508   if (log_get_errorcount(0))
509     exit(2);
510   if (nogreeting )
511     greeting = 0;
512
513   if (greeting)
514     {
515       fprintf (stderr, "%s %s; %s\n",
516                  strusage(11), strusage(13), strusage(14) );
517       fprintf (stderr, "%s\n", strusage(15) );
518     }
519 #ifdef IS_DEVELOPMENT_VERSION
520   log_info ("NOTE: this is a development version!\n");
521 #endif
522
523  
524   if (atexit (cleanup))
525     {
526       log_error ("atexit failed\n");
527       cleanup ();
528       exit (1);
529     }
530
531   set_debug (debug_level);
532
533   if (debug_wait && pipe_server)
534     {
535       log_debug ("waiting for debugger - my pid is %u .....\n",
536                  (unsigned int)getpid());
537       gnupg_sleep (debug_wait);
538       log_debug ("... okay\n");
539     }
540   
541   initialize_module_command ();
542
543   if (gpgconf_list == 2)
544     scd_exit (0);
545   if (gpgconf_list)
546     {
547       /* List options and default values in the GPG Conf format.  */
548       char *filename = NULL;
549       char *filename_esc;
550
551       if (!config_filename)
552         filename = make_filename (opt.homedir, "scdaemon.conf", NULL );
553       filename_esc = percent_escape (filename, NULL);
554
555       printf ("gpgconf-scdaemon.conf:%lu:\"%s\n",
556               GC_OPT_FLAG_DEFAULT, filename_esc);
557       xfree (filename_esc);
558       xfree (filename);
559
560       printf ("verbose:%lu:\n"
561               "quiet:%lu:\n"
562               "debug-level:%lu:\"none:\n"
563               "log-file:%lu:\n",
564               GC_OPT_FLAG_NONE,
565               GC_OPT_FLAG_NONE,
566               GC_OPT_FLAG_DEFAULT,
567               GC_OPT_FLAG_NONE );
568
569       printf ("reader-port:%lu:\n", GC_OPT_FLAG_NONE );
570       printf ("ctapi-driver:%lu:\n", GC_OPT_FLAG_NONE );
571       printf ("pcsc-driver:%lu:\"%s:\n",
572               GC_OPT_FLAG_DEFAULT, DEFAULT_PCSC_DRIVER );
573 #ifdef HAVE_LIBUSB
574       printf ("disable-ccid:%lu:\n", GC_OPT_FLAG_NONE );
575 #endif
576       printf ("allow-admin:%lu:\n", GC_OPT_FLAG_NONE );
577       printf ("disable-keypad:%lu:\n", GC_OPT_FLAG_NONE );
578
579       scd_exit (0);
580     }
581
582   /* now start with logging to a file if this is desired */
583   if (logfile)
584     {
585       log_set_file (logfile);
586       log_set_prefix (NULL, 1|2|4);
587     }
588
589   if (pipe_server)
590     { 
591       /* This is the simple pipe based server */
592       ctrl_t ctrl;
593       pth_attr_t tattr;
594       int fd = -1;
595
596 #ifndef HAVE_W32_SYSTEM
597       {
598         struct sigaction sa;
599         
600         sa.sa_handler = SIG_IGN;
601         sigemptyset (&sa.sa_mask);
602         sa.sa_flags = 0;
603         sigaction (SIGPIPE, &sa, NULL);
604       }
605 #endif
606
607       /* If --debug-allow-core-dump has been given we also need to
608          switch the working directory to a place where we can actually
609          write. */
610       if (allow_coredump)
611         {
612           if (chdir("/tmp"))
613             log_debug ("chdir to `/tmp' failed: %s\n", strerror (errno));
614           else
615             log_debug ("changed working directory to `/tmp'\n");
616         }
617
618       /* In multi server mode we need to listen on an additional
619          socket.  Create that socket now before starting the handler
620          for the pipe connection.  This allows that handler to send
621          back the name of that socket. */
622       if (multi_server)
623         {
624           socket_name = create_socket_name (0,
625                                             "S.scdaemon",
626                                             "/tmp/gpg-XXXXXX/S.scdaemon");
627           
628           fd = create_server_socket (0, socket_name);
629         }
630
631       tattr = pth_attr_new();
632       pth_attr_set (tattr, PTH_ATTR_JOINABLE, 0);
633       pth_attr_set (tattr, PTH_ATTR_STACK_SIZE, 512*1024);
634       pth_attr_set (tattr, PTH_ATTR_NAME, "pipe-connection");
635
636       ctrl = xtrycalloc (1, sizeof *ctrl);
637       if ( !ctrl )
638         {
639           log_error ("error allocating connection control data: %s\n",
640                      strerror (errno) );
641           scd_exit (2);
642         }
643       ctrl->thread_startup.fd = -1;
644       if ( !pth_spawn (tattr, start_connection_thread, ctrl) )
645         {
646           log_error ("error spawning pipe connection handler: %s\n",
647                      strerror (errno) );
648           xfree (ctrl);
649           scd_exit (2);
650         }
651
652       handle_connections (fd);
653       if (fd != -1)
654         close (fd);
655     }
656   else if (!is_daemon)
657     {
658       log_info (_("please use the option `--daemon'"
659                   " to run the program in the background\n"));
660     }
661   else
662     { /* Regular server mode */
663       int fd;
664       pid_t pid;
665       int i;
666
667       /* Create the socket.  */
668       socket_name = create_socket_name (0,
669                                         "S.scdaemon",
670                                         "/tmp/gpg-XXXXXX/S.scdaemon");
671
672       fd = create_server_socket (0, socket_name);
673
674
675       fflush (NULL);
676 #ifndef HAVE_W32_SYSTEM
677       pid = fork ();
678       if (pid == (pid_t)-1) 
679         {
680           log_fatal ("fork failed: %s\n", strerror (errno) );
681           exit (1);
682         }
683       else if (pid) 
684         { /* we are the parent */
685           char *infostr;
686           
687           close (fd);
688           
689           /* create the info string: <name>:<pid>:<protocol_version> */
690           if (asprintf (&infostr, "SCDAEMON_INFO=%s:%lu:1",
691                         socket_name, (ulong)pid ) < 0)
692             {
693               log_error ("out of core\n");
694               kill (pid, SIGTERM);
695               exit (1);
696             }
697           *socket_name = 0; /* don't let cleanup() remove the socket -
698                                the child should do this from now on */
699           if (argc) 
700             { /* run the program given on the commandline */
701               if (putenv (infostr))
702                 {
703                   log_error ("failed to set environment: %s\n",
704                              strerror (errno) );
705                   kill (pid, SIGTERM );
706                   exit (1);
707                 }
708               execvp (argv[0], argv);
709               log_error ("failed to run the command: %s\n", strerror (errno));
710               kill (pid, SIGTERM);
711               exit (1);
712             }
713           else
714             {
715               /* Print the environment string, so that the caller can use
716                  shell's eval to set it */
717               if (csh_style)
718                 {
719                   *strchr (infostr, '=') = ' ';
720                   printf ( "setenv %s\n", infostr);
721                 }
722               else
723                 {
724                   printf ( "%s; export SCDAEMON_INFO;\n", infostr);
725                 }
726               free (infostr);
727               exit (0); 
728             }
729           /* NOTREACHED */
730         } /* end parent */
731       
732       /* This is the child. */
733
734       /* Detach from tty and put process into a new session. */
735       if (!nodetach )
736         {  
737           /* Close stdin, stdout and stderr unless it is the log stream. */
738           for (i=0; i <= 2; i++) 
739             {
740               if ( log_test_fd (i) && i != fd)
741                 close (i);
742             }
743           if (setsid() == -1)
744             {
745               log_error ("setsid() failed: %s\n", strerror(errno) );
746               cleanup ();
747               exit (1);
748             }
749         }
750
751       {
752         struct sigaction sa;
753         
754         sa.sa_handler = SIG_IGN;
755         sigemptyset (&sa.sa_mask);
756         sa.sa_flags = 0;
757         sigaction (SIGPIPE, &sa, NULL);
758       }
759
760       if (chdir("/"))
761         {
762           log_error ("chdir to / failed: %s\n", strerror (errno));
763           exit (1);
764         }
765
766 #endif /*!HAVE_W32_SYSTEM*/
767
768       handle_connections (fd);
769
770       close (fd);
771     }
772   
773   return 0;
774 }
775
776 void
777 scd_exit (int rc)
778 {
779 #if 0
780 #warning no update_random_seed_file
781   update_random_seed_file();
782 #endif
783 #if 0
784   /* at this time a bit annoying */
785   if (opt.debug & DBG_MEMSTAT_VALUE)
786     {
787       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
788       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
789     }
790   if (opt.debug)
791     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
792 #endif
793   gcry_control (GCRYCTL_TERM_SECMEM );
794   rc = rc? rc : log_get_errorcount(0)? 2 : 0;
795   exit (rc);
796 }
797
798
799 static void
800 scd_init_default_ctrl (ctrl_t ctrl)
801 {
802   ctrl->reader_slot = -1;
803 }
804
805 static void
806 scd_deinit_default_ctrl (ctrl_t ctrl)
807 {
808
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   ctrl_t ctrl = arg;
1003
1004   scd_init_default_ctrl (ctrl);
1005   if (opt.verbose)
1006     log_info (_("handler for fd %d started\n"), ctrl->thread_startup.fd);
1007
1008   scd_command_handler (ctrl, ctrl->thread_startup.fd);
1009
1010   if (opt.verbose)
1011     log_info (_("handler for fd %d terminated\n"), ctrl->thread_startup.fd);
1012
1013   /* If this thread is the pipe connection thread, flag that a
1014      shutdown is required.  With the next ticker event and given that
1015      no other connections are running the shutdown will then
1016      happen. */
1017   if (ctrl->thread_startup.fd == -1)
1018     shutdown_pending = 1;
1019   
1020   scd_deinit_default_ctrl (ctrl);
1021   xfree (ctrl);
1022   return NULL;
1023 }
1024
1025
1026 /* Connection handler loop.  Wait for connection requests and spawn a
1027    thread after accepting a connection.  LISTEN_FD is allowed to be -1
1028    in which case this code will only do regular timeouts and handle
1029    signals. */
1030 static void
1031 handle_connections (int listen_fd)
1032 {
1033   pth_attr_t tattr;
1034   pth_event_t ev, time_ev;
1035   sigset_t sigs;
1036   int signo;
1037   struct sockaddr_un paddr;
1038   socklen_t plen;
1039   fd_set fdset, read_fdset;
1040   int ret;
1041   int fd;
1042   int nfd;
1043
1044   tattr = pth_attr_new();
1045   pth_attr_set (tattr, PTH_ATTR_JOINABLE, 0);
1046   pth_attr_set (tattr, PTH_ATTR_STACK_SIZE, 512*1024);
1047
1048 #ifndef HAVE_W32_SYSTEM /* fixme */
1049   sigemptyset (&sigs );
1050   sigaddset (&sigs, SIGHUP);
1051   sigaddset (&sigs, SIGUSR1);
1052   sigaddset (&sigs, SIGUSR2);
1053   sigaddset (&sigs, SIGINT);
1054   sigaddset (&sigs, SIGTERM);
1055   pth_sigmask (SIG_UNBLOCK, &sigs, NULL);
1056   ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
1057 #else
1058   sigs = 0;
1059   ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
1060 #endif
1061   time_ev = NULL;
1062
1063   FD_ZERO (&fdset);
1064   nfd = 0;
1065   if (listen_fd != -1)
1066     {
1067       FD_SET (listen_fd, &fdset);
1068       nfd = listen_fd;
1069     }
1070
1071   for (;;)
1072     {
1073       sigset_t oldsigs;
1074       
1075       if (shutdown_pending)
1076         {
1077           if (pth_ctrl (PTH_CTRL_GETTHREADS) == 1)
1078             break; /* ready */
1079
1080           /* Do not accept anymore connections but wait for existing
1081              connections to terminate. We do this by clearing out all
1082              file descriptors to wait for, so that the select will be
1083              used to just wait on a signal or timeout event. */
1084           FD_ZERO (&fdset);
1085         }
1086
1087       /* Create a timeout event if needed. */
1088       if (!time_ev)
1089         time_ev = pth_event (PTH_EVENT_TIME,
1090                              pth_timeout (TIMERTICK_INTERVAL, 0));
1091
1092       /* POSIX says that fd_set should be implemented as a structure,
1093          thus a simple assignment is fine to copy the entire set.  */
1094       read_fdset = fdset;
1095
1096       if (time_ev)
1097         pth_event_concat (ev, time_ev, NULL);
1098       ret = pth_select_ev (nfd+1, &read_fdset, NULL, NULL, NULL, ev);
1099       if (time_ev)
1100         pth_event_isolate (time_ev);
1101
1102       if (ret == -1)
1103         {
1104           if (pth_event_occurred (ev)
1105               || (time_ev && pth_event_occurred (time_ev)))
1106             {
1107               if (pth_event_occurred (ev))
1108                 handle_signal (signo);
1109               if (time_ev && pth_event_occurred (time_ev))
1110                 {
1111                   pth_event_free (time_ev, PTH_FREE_ALL);
1112                   time_ev = NULL;
1113                   handle_tick ();
1114                 }
1115               continue;
1116             }
1117           log_error (_("pth_select failed: %s - waiting 1s\n"),
1118                      strerror (errno));
1119           pth_sleep (1);
1120           continue;
1121         }
1122
1123       if (pth_event_occurred (ev))
1124         {
1125           handle_signal (signo);
1126         }
1127
1128       if (time_ev && pth_event_occurred (time_ev))
1129         {
1130           pth_event_free (time_ev, PTH_FREE_ALL);
1131           time_ev = NULL;
1132           handle_tick ();
1133         }
1134
1135       /* We now might create new threads and because we don't want any
1136          signals - we are handling here - to be delivered to a new
1137          thread. Thus we need to block those signals. */
1138       pth_sigmask (SIG_BLOCK, &sigs, &oldsigs);
1139
1140       if (listen_fd != -1 && FD_ISSET (listen_fd, &read_fdset))
1141         {
1142           ctrl_t ctrl;
1143
1144           plen = sizeof paddr;
1145           fd = pth_accept (listen_fd, (struct sockaddr *)&paddr, &plen);
1146           if (fd == -1)
1147             {
1148               log_error ("accept failed: %s\n", strerror (errno));
1149             }
1150           else if ( !(ctrl = xtrycalloc (1, sizeof *ctrl)) )
1151             {
1152               log_error ("error allocating connection control data: %s\n",
1153                          strerror (errno) );
1154               close (fd);
1155             }
1156           else
1157             {
1158               char threadname[50];
1159
1160               snprintf (threadname, sizeof threadname-1, "conn fd=%d", fd);
1161               threadname[sizeof threadname -1] = 0;
1162               pth_attr_set (tattr, PTH_ATTR_NAME, threadname);
1163               ctrl->thread_startup.fd = fd;
1164               if (!pth_spawn (tattr, start_connection_thread, ctrl))
1165                 {
1166                   log_error ("error spawning connection handler: %s\n",
1167                              strerror (errno) );
1168                   xfree (ctrl);
1169                   close (fd);
1170                 }
1171             }
1172           fd = -1;
1173         }
1174
1175       /* Restore the signal mask. */
1176       pth_sigmask (SIG_SETMASK, &oldsigs, NULL);
1177
1178     }
1179
1180   pth_event_free (ev, PTH_FREE_ALL);
1181   if (time_ev)
1182     pth_event_free (time_ev, PTH_FREE_ALL);
1183   cleanup ();
1184   log_info (_("%s %s stopped\n"), strusage(11), strusage(13));
1185 }
1186
1187