2007-09-14 Marcus Brinkmann <marcus@g10code.de>
[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   int standard_socket = 0;
314
315   set_strusage (my_strusage);
316   gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
317   /* Please note that we may running SUID(ROOT), so be very CAREFUL
318      when adding any stuff between here and the call to INIT_SECMEM()
319      somewhere after the option parsing */
320   log_set_prefix ("scdaemon", 1|4); 
321
322   /* Make sure that our subsystems are ready.  */
323   init_common_subsystems ();
324
325   i18n_init ();
326
327   /* Libgcrypt requires us to register the threading model first.
328      Note that this will also do the pth_init. */
329   gcry_threads_pth.init = fixed_gcry_pth_init;
330   err = gcry_control (GCRYCTL_SET_THREAD_CBS, &gcry_threads_pth);
331   if (err)
332     {
333       log_fatal ("can't register GNU Pth with Libgcrypt: %s\n",
334                  gpg_strerror (err));
335     }
336
337   /* Check that the libraries are suitable.  Do it here because
338      the option parsing may need services of the library */
339   if (!gcry_check_version (NEED_LIBGCRYPT_VERSION) )
340     {
341       log_fatal (_("%s is too old (need %s, have %s)\n"), "libgcrypt",
342                  NEED_LIBGCRYPT_VERSION, gcry_check_version (NULL) );
343     }
344
345   ksba_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
346
347   assuan_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
348   assuan_set_assuan_log_stream (log_get_stream ());
349   assuan_set_assuan_log_prefix (log_get_prefix (NULL));
350   assuan_set_assuan_err_source (GPG_ERR_SOURCE_DEFAULT);
351
352   setup_libgcrypt_logging ();
353   gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
354
355   may_coredump = disable_core_dumps ();
356
357   /* Set default options. */
358   opt.pcsc_driver = DEFAULT_PCSC_DRIVER; 
359
360 #ifdef HAVE_W32_SYSTEM
361   standard_socket = 1;  /* Under Windows we always use a standard
362                            socket.  */
363 #endif
364
365
366   shell = getenv ("SHELL");
367   if (shell && strlen (shell) >= 3 && !strcmp (shell+strlen (shell)-3, "csh") )
368     csh_style = 1;
369   
370   opt.homedir = default_homedir ();
371
372   /* Check whether we have a config file on the commandline */
373   orig_argc = argc;
374   orig_argv = argv;
375   pargs.argc = &argc;
376   pargs.argv = &argv;
377   pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
378   while (arg_parse( &pargs, opts))
379     {
380       if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll)
381         parse_debug++;
382       else if (pargs.r_opt == oOptions)
383         { /* yes there is one, so we do not try the default one, but
384              read the option file when it is encountered at the
385              commandline */
386           default_config = 0;
387         }
388         else if (pargs.r_opt == oNoOptions)
389           default_config = 0; /* --no-options */
390         else if (pargs.r_opt == oHomedir)
391           opt.homedir = pargs.r.ret_str;
392     }
393
394   /* initialize the secure memory. */
395   gcry_control (GCRYCTL_INIT_SECMEM, 16384, 0);
396   maybe_setuid = 0;
397
398   /* 
399      Now we are working under our real uid 
400   */
401
402
403   if (default_config)
404     configname = make_filename (opt.homedir, "scdaemon.conf", NULL );
405
406   
407   argc = orig_argc;
408   argv = orig_argv;
409   pargs.argc = &argc;
410   pargs.argv = &argv;
411   pargs.flags=  1;  /* do not remove the args */
412  next_pass:
413   if (configname)
414     {
415       configlineno = 0;
416       configfp = fopen (configname, "r");
417       if (!configfp)
418         {
419           if (default_config)
420             {
421               if( parse_debug )
422                 log_info (_("NOTE: no default option file `%s'\n"),
423                           configname );
424             }
425           else
426             {
427               log_error (_("option file `%s': %s\n"),
428                          configname, strerror(errno) );
429               exit(2);
430             }
431           xfree (configname); 
432           configname = NULL;
433         }
434       if (parse_debug && configname )
435         log_info (_("reading options from `%s'\n"), configname );
436       default_config = 0;
437     }
438
439   while (optfile_parse( configfp, configname, &configlineno, &pargs, opts) )
440     {
441       switch (pargs.r_opt)
442         {
443         case aGPGConfList: gpgconf_list = 1; break;
444         case aGPGConfTest: gpgconf_list = 2; break;
445         case oQuiet: opt.quiet = 1; break;
446         case oVerbose: opt.verbose++; break;
447         case oBatch: opt.batch=1; break;
448
449         case oDebug: opt.debug |= pargs.r.ret_ulong; break;
450         case oDebugAll: opt.debug = ~0; break;
451         case oDebugLevel: debug_level = pargs.r.ret_str; break;
452         case oDebugWait: debug_wait = pargs.r.ret_int; break;
453         case oDebugAllowCoreDump:
454           enable_core_dumps ();
455           allow_coredump = 1;
456           break;
457         case oDebugCCIDDriver: 
458 #ifdef HAVE_LIBUSB
459           ccid_set_debug_level (ccid_set_debug_level (-1)+1);
460 #endif /*HAVE_LIBUSB*/
461           break;
462         case oDebugDisableTicker: ticker_disabled = 1; break;
463
464         case oOptions:
465           /* config files may not be nested (silently ignore them) */
466           if (!configfp)
467             {
468                 xfree(configname);
469                 configname = xstrdup(pargs.r.ret_str);
470                 goto next_pass;
471             }
472           break;
473         case oNoGreeting: nogreeting = 1; break;
474         case oNoVerbose: opt.verbose = 0; break;
475         case oNoOptions: break; /* no-options */
476         case oHomedir: opt.homedir = pargs.r.ret_str; break;
477         case oNoDetach: nodetach = 1; break;
478         case oLogFile: logfile = pargs.r.ret_str; break;
479         case oCsh: csh_style = 1; break;
480         case oSh: csh_style = 0; break;
481         case oServer: pipe_server = 1; break;
482         case oMultiServer: pipe_server = 1; multi_server = 1; break;
483         case oDaemon: is_daemon = 1; break;
484
485         case oReaderPort: opt.reader_port = pargs.r.ret_str; break;
486         case octapiDriver: opt.ctapi_driver = pargs.r.ret_str; break;
487         case opcscDriver: opt.pcsc_driver = pargs.r.ret_str; break;
488         case oDisableCCID: opt.disable_ccid = 1; break;
489         case oDisableOpenSC: break;
490
491         case oDisableKeypad: opt.disable_keypad = 1; break;
492
493         case oAllowAdmin: opt.allow_admin = 1; break;
494         case oDenyAdmin: opt.allow_admin = 0; break;
495
496         case oDisableApplication:
497           add_to_strlist (&opt.disabled_applications, pargs.r.ret_str); 
498           break;
499
500         default : pargs.err = configfp? 1:2; break;
501         }
502     }
503   if (configfp)
504     {
505       fclose( configfp );
506       configfp = NULL;
507       /* Keep a copy of the config name for use by --gpgconf-list. */
508       config_filename = configname;
509       configname = NULL;
510       goto next_pass;
511     }
512   xfree (configname);
513   configname = NULL;
514   if (log_get_errorcount(0))
515     exit(2);
516   if (nogreeting )
517     greeting = 0;
518
519   if (greeting)
520     {
521       fprintf (stderr, "%s %s; %s\n",
522                  strusage(11), strusage(13), strusage(14) );
523       fprintf (stderr, "%s\n", strusage(15) );
524     }
525 #ifdef IS_DEVELOPMENT_VERSION
526   log_info ("NOTE: this is a development version!\n");
527 #endif
528
529  
530   if (atexit (cleanup))
531     {
532       log_error ("atexit failed\n");
533       cleanup ();
534       exit (1);
535     }
536
537   set_debug (debug_level);
538
539   if (debug_wait && pipe_server)
540     {
541       log_debug ("waiting for debugger - my pid is %u .....\n",
542                  (unsigned int)getpid());
543       gnupg_sleep (debug_wait);
544       log_debug ("... okay\n");
545     }
546   
547   initialize_module_command ();
548
549   if (gpgconf_list == 2)
550     scd_exit (0);
551   if (gpgconf_list)
552     {
553       /* List options and default values in the GPG Conf format.  */
554       char *filename = NULL;
555       char *filename_esc;
556
557       if (!config_filename)
558         filename = make_filename (opt.homedir, "scdaemon.conf", NULL );
559       filename_esc = percent_escape (filename, NULL);
560
561       printf ("gpgconf-scdaemon.conf:%lu:\"%s\n",
562               GC_OPT_FLAG_DEFAULT, filename_esc);
563       xfree (filename_esc);
564       xfree (filename);
565
566       printf ("verbose:%lu:\n"
567               "quiet:%lu:\n"
568               "debug-level:%lu:\"none:\n"
569               "log-file:%lu:\n",
570               GC_OPT_FLAG_NONE,
571               GC_OPT_FLAG_NONE,
572               GC_OPT_FLAG_DEFAULT,
573               GC_OPT_FLAG_NONE );
574
575       printf ("reader-port:%lu:\n", GC_OPT_FLAG_NONE );
576       printf ("ctapi-driver:%lu:\n", GC_OPT_FLAG_NONE );
577       printf ("pcsc-driver:%lu:\"%s:\n",
578               GC_OPT_FLAG_DEFAULT, DEFAULT_PCSC_DRIVER );
579 #ifdef HAVE_LIBUSB
580       printf ("disable-ccid:%lu:\n", GC_OPT_FLAG_NONE );
581 #endif
582       printf ("allow-admin:%lu:\n", GC_OPT_FLAG_NONE );
583       printf ("disable-keypad:%lu:\n", GC_OPT_FLAG_NONE );
584
585       scd_exit (0);
586     }
587
588   /* now start with logging to a file if this is desired */
589   if (logfile)
590     {
591       log_set_file (logfile);
592       log_set_prefix (NULL, 1|2|4);
593     }
594
595   if (pipe_server)
596     { 
597       /* This is the simple pipe based server */
598       ctrl_t ctrl;
599       pth_attr_t tattr;
600       int fd = -1;
601
602 #ifndef HAVE_W32_SYSTEM
603       {
604         struct sigaction sa;
605         
606         sa.sa_handler = SIG_IGN;
607         sigemptyset (&sa.sa_mask);
608         sa.sa_flags = 0;
609         sigaction (SIGPIPE, &sa, NULL);
610       }
611 #endif
612
613       /* If --debug-allow-core-dump has been given we also need to
614          switch the working directory to a place where we can actually
615          write. */
616       if (allow_coredump)
617         {
618           if (chdir("/tmp"))
619             log_debug ("chdir to `/tmp' failed: %s\n", strerror (errno));
620           else
621             log_debug ("changed working directory to `/tmp'\n");
622         }
623
624       /* In multi server mode we need to listen on an additional
625          socket.  Create that socket now before starting the handler
626          for the pipe connection.  This allows that handler to send
627          back the name of that socket. */
628       if (multi_server)
629         {
630           socket_name = create_socket_name (standard_socket,
631                                             "S.scdaemon",
632                                             "/tmp/gpg-XXXXXX/S.scdaemon");
633           
634           fd = create_server_socket (0, socket_name);
635         }
636
637       tattr = pth_attr_new();
638       pth_attr_set (tattr, PTH_ATTR_JOINABLE, 0);
639       pth_attr_set (tattr, PTH_ATTR_STACK_SIZE, 512*1024);
640       pth_attr_set (tattr, PTH_ATTR_NAME, "pipe-connection");
641
642       ctrl = xtrycalloc (1, sizeof *ctrl);
643       if ( !ctrl )
644         {
645           log_error ("error allocating connection control data: %s\n",
646                      strerror (errno) );
647           scd_exit (2);
648         }
649       ctrl->thread_startup.fd = -1;
650       if ( !pth_spawn (tattr, start_connection_thread, ctrl) )
651         {
652           log_error ("error spawning pipe connection handler: %s\n",
653                      strerror (errno) );
654           xfree (ctrl);
655           scd_exit (2);
656         }
657
658       handle_connections (fd);
659       if (fd != -1)
660         close (fd);
661     }
662   else if (!is_daemon)
663     {
664       log_info (_("please use the option `--daemon'"
665                   " to run the program in the background\n"));
666     }
667   else
668     { /* Regular server mode */
669       int fd;
670       pid_t pid;
671       int i;
672
673       /* Create the socket.  */
674       socket_name = create_socket_name (standard_socket,
675                                         "S.scdaemon",
676                                         "/tmp/gpg-XXXXXX/S.scdaemon");
677
678       fd = create_server_socket (0, socket_name);
679
680
681       fflush (NULL);
682 #ifndef HAVE_W32_SYSTEM
683       pid = fork ();
684       if (pid == (pid_t)-1) 
685         {
686           log_fatal ("fork failed: %s\n", strerror (errno) );
687           exit (1);
688         }
689       else if (pid) 
690         { /* we are the parent */
691           char *infostr;
692           
693           close (fd);
694           
695           /* create the info string: <name>:<pid>:<protocol_version> */
696           if (asprintf (&infostr, "SCDAEMON_INFO=%s:%lu:1",
697                         socket_name, (ulong)pid ) < 0)
698             {
699               log_error ("out of core\n");
700               kill (pid, SIGTERM);
701               exit (1);
702             }
703           *socket_name = 0; /* don't let cleanup() remove the socket -
704                                the child should do this from now on */
705           if (argc) 
706             { /* run the program given on the commandline */
707               if (putenv (infostr))
708                 {
709                   log_error ("failed to set environment: %s\n",
710                              strerror (errno) );
711                   kill (pid, SIGTERM );
712                   exit (1);
713                 }
714               execvp (argv[0], argv);
715               log_error ("failed to run the command: %s\n", strerror (errno));
716               kill (pid, SIGTERM);
717               exit (1);
718             }
719           else
720             {
721               /* Print the environment string, so that the caller can use
722                  shell's eval to set it */
723               if (csh_style)
724                 {
725                   *strchr (infostr, '=') = ' ';
726                   printf ( "setenv %s\n", infostr);
727                 }
728               else
729                 {
730                   printf ( "%s; export SCDAEMON_INFO;\n", infostr);
731                 }
732               free (infostr);
733               exit (0); 
734             }
735           /* NOTREACHED */
736         } /* end parent */
737       
738       /* This is the child. */
739
740       /* Detach from tty and put process into a new session. */
741       if (!nodetach )
742         {  
743           /* Close stdin, stdout and stderr unless it is the log stream. */
744           for (i=0; i <= 2; i++) 
745             {
746               if ( log_test_fd (i) && i != fd)
747                 close (i);
748             }
749           if (setsid() == -1)
750             {
751               log_error ("setsid() failed: %s\n", strerror(errno) );
752               cleanup ();
753               exit (1);
754             }
755         }
756
757       {
758         struct sigaction sa;
759         
760         sa.sa_handler = SIG_IGN;
761         sigemptyset (&sa.sa_mask);
762         sa.sa_flags = 0;
763         sigaction (SIGPIPE, &sa, NULL);
764       }
765
766       if (chdir("/"))
767         {
768           log_error ("chdir to / failed: %s\n", strerror (errno));
769           exit (1);
770         }
771
772 #endif /*!HAVE_W32_SYSTEM*/
773
774       handle_connections (fd);
775
776       close (fd);
777     }
778   
779   return 0;
780 }
781
782 void
783 scd_exit (int rc)
784 {
785 #if 0
786 #warning no update_random_seed_file
787   update_random_seed_file();
788 #endif
789 #if 0
790   /* at this time a bit annoying */
791   if (opt.debug & DBG_MEMSTAT_VALUE)
792     {
793       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
794       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
795     }
796   if (opt.debug)
797     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
798 #endif
799   gcry_control (GCRYCTL_TERM_SECMEM );
800   rc = rc? rc : log_get_errorcount(0)? 2 : 0;
801   exit (rc);
802 }
803
804
805 static void
806 scd_init_default_ctrl (ctrl_t ctrl)
807 {
808   ctrl->reader_slot = -1;
809 }
810
811 static void
812 scd_deinit_default_ctrl (ctrl_t ctrl)
813 {
814
815 }
816
817
818 /* Return the name of the socket to be used to connect to this
819    process.  If no socket is available, return NULL. */
820 const char *
821 scd_get_socket_name ()
822 {
823   if (socket_name && *socket_name)
824     return socket_name;
825   return NULL;
826 }
827
828
829 static void
830 handle_signal (int signo)
831 {
832   switch (signo)
833     {
834 #ifndef HAVE_W32_SYSTEM
835     case SIGHUP:
836       log_info ("SIGHUP received - "
837                 "re-reading configuration and resetting cards\n");
838 /*       reread_configuration (); */
839       break;
840       
841     case SIGUSR1:
842       log_info ("SIGUSR1 received - printing internal information:\n");
843       pth_ctrl (PTH_CTRL_DUMPSTATE, log_get_stream ());
844       app_dump_state ();
845       break;
846
847     case SIGUSR2:
848       log_info ("SIGUSR2 received - no action defined\n");
849       break;
850
851     case SIGTERM:
852       if (!shutdown_pending)
853         log_info ("SIGTERM received - shutting down ...\n");
854       else
855         log_info ("SIGTERM received - still %ld running threads\n",
856                   pth_ctrl( PTH_CTRL_GETTHREADS ));
857       shutdown_pending++;
858       if (shutdown_pending > 2)
859         {
860           log_info ("shutdown forced\n");
861           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
862           cleanup ();
863           scd_exit (0);
864         }
865       break;
866         
867     case SIGINT:
868       log_info ("SIGINT received - immediate shutdown\n");
869       log_info( "%s %s stopped\n", strusage(11), strusage(13));
870       cleanup ();
871       scd_exit (0);
872       break;
873 #endif /*!HAVE_W32_SYSTEM*/
874
875     default:
876       log_info ("signal %d received - no action defined\n", signo);
877     }
878 }
879
880
881 static void
882 handle_tick (void)
883 {
884   if (!ticker_disabled)
885     scd_update_reader_status_file ();
886 }
887
888
889 /* Create a name for the socket.  With USE_STANDARD_SOCKET given as
890    true using STANDARD_NAME in the home directory or if given has
891    false from the mkdir type name TEMPLATE.  In the latter case a
892    unique name in a unique new directory will be created.  In both
893    cases check for valid characters as well as against a maximum
894    allowed length for a unix domain socket is done.  The function
895    terminates the process in case of an error.  Retunrs: Pointer to an
896    allcoated string with the absolute name of the socket used.  */
897 static char *
898 create_socket_name (int use_standard_socket,
899                     char *standard_name, char *template)
900 {
901   char *name, *p;
902
903   if (use_standard_socket)
904     name = make_filename (opt.homedir, standard_name, NULL);
905   else
906     {
907       name = xstrdup (template);
908       p = strrchr (name, '/');
909       if (!p)
910         BUG ();
911       *p = 0;
912       if (!mkdtemp (name))
913         {
914           log_error (_("can't create directory `%s': %s\n"),
915                      name, strerror (errno));
916           scd_exit (2);
917         }
918       *p = '/';
919     }
920
921   if (strchr (name, PATHSEP_C))
922     {
923       log_error (("`%s' are not allowed in the socket name\n"), PATHSEP_S);
924       scd_exit (2);
925     }
926   if (strlen (name) + 1 >= DIMof (struct sockaddr_un, sun_path) )
927     {
928       log_error (_("name of socket too long\n"));
929       scd_exit (2);
930     }
931   return name;
932 }
933
934
935
936 /* Create a Unix domain socket with NAME.  IS_STANDARD_NAME indicates
937    whether a non-random socket is used.  Returns the file descriptor
938    or terminates the process in case of an error. */
939 static int
940 create_server_socket (int is_standard_name, const char *name)
941 {
942   struct sockaddr_un *serv_addr;
943   socklen_t len;
944   int fd;
945   int rc;
946
947 #ifdef HAVE_W32_SYSTEM
948   fd = _w32_sock_new (AF_UNIX, SOCK_STREAM, 0);
949 #else
950   fd = socket (AF_UNIX, SOCK_STREAM, 0);
951 #endif
952   if (fd == -1)
953     {
954       log_error (_("can't create socket: %s\n"), strerror (errno));
955       scd_exit (2);
956     }
957
958   serv_addr = xmalloc (sizeof (*serv_addr)); 
959   memset (serv_addr, 0, sizeof *serv_addr);
960   serv_addr->sun_family = AF_UNIX;
961   assert (strlen (name) + 1 < sizeof (serv_addr->sun_path));
962   strcpy (serv_addr->sun_path, name);
963   len = (offsetof (struct sockaddr_un, sun_path)
964          + strlen (serv_addr->sun_path) + 1);
965
966 #ifdef HAVE_W32_SYSTEM
967   rc = _w32_sock_bind (fd, (struct sockaddr*) serv_addr, len);
968   if (is_standard_name && rc == -1 )
969     {
970       remove (name);
971       rc = bind (fd, (struct sockaddr*) serv_addr, len);
972     }
973 #else
974   rc = bind (fd, (struct sockaddr*) serv_addr, len);
975   if (is_standard_name && rc == -1 && errno == EADDRINUSE)
976     {
977       remove (name);
978       rc = bind (fd, (struct sockaddr*) serv_addr, len);
979     }
980 #endif
981   if (rc == -1)
982     {
983       log_error (_("error binding socket to `%s': %s\n"),
984                  serv_addr->sun_path, strerror (errno));
985       close (fd);
986       scd_exit (2);
987     }
988
989   if (listen (fd, 5 ) == -1)
990     {
991       log_error (_("listen() failed: %s\n"), strerror (errno));
992       close (fd);
993       scd_exit (2);
994     }
995           
996   if (opt.verbose)
997     log_info (_("listening on socket `%s'\n"), serv_addr->sun_path);
998
999   return fd;
1000 }
1001
1002
1003
1004 /* This is the standard connection thread's main function.  */
1005 static void *
1006 start_connection_thread (void *arg)
1007 {
1008   ctrl_t ctrl = arg;
1009
1010   scd_init_default_ctrl (ctrl);
1011   if (opt.verbose)
1012     log_info (_("handler for fd %d started\n"), ctrl->thread_startup.fd);
1013
1014   scd_command_handler (ctrl, ctrl->thread_startup.fd);
1015
1016   if (opt.verbose)
1017     log_info (_("handler for fd %d terminated\n"), ctrl->thread_startup.fd);
1018
1019   /* If this thread is the pipe connection thread, flag that a
1020      shutdown is required.  With the next ticker event and given that
1021      no other connections are running the shutdown will then
1022      happen. */
1023   if (ctrl->thread_startup.fd == -1)
1024     shutdown_pending = 1;
1025   
1026   scd_deinit_default_ctrl (ctrl);
1027   xfree (ctrl);
1028   return NULL;
1029 }
1030
1031
1032 /* Connection handler loop.  Wait for connection requests and spawn a
1033    thread after accepting a connection.  LISTEN_FD is allowed to be -1
1034    in which case this code will only do regular timeouts and handle
1035    signals. */
1036 static void
1037 handle_connections (int listen_fd)
1038 {
1039   pth_attr_t tattr;
1040   pth_event_t ev, time_ev;
1041   sigset_t sigs;
1042   int signo;
1043   struct sockaddr_un paddr;
1044   socklen_t plen;
1045   fd_set fdset, read_fdset;
1046   int ret;
1047   int fd;
1048   int nfd;
1049
1050   tattr = pth_attr_new();
1051   pth_attr_set (tattr, PTH_ATTR_JOINABLE, 0);
1052   pth_attr_set (tattr, PTH_ATTR_STACK_SIZE, 512*1024);
1053
1054 #ifndef HAVE_W32_SYSTEM /* fixme */
1055   sigemptyset (&sigs );
1056   sigaddset (&sigs, SIGHUP);
1057   sigaddset (&sigs, SIGUSR1);
1058   sigaddset (&sigs, SIGUSR2);
1059   sigaddset (&sigs, SIGINT);
1060   sigaddset (&sigs, SIGTERM);
1061   pth_sigmask (SIG_UNBLOCK, &sigs, NULL);
1062   ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
1063 #else
1064   sigs = 0;
1065   ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
1066 #endif
1067   time_ev = NULL;
1068
1069   FD_ZERO (&fdset);
1070   nfd = 0;
1071   if (listen_fd != -1)
1072     {
1073       FD_SET (listen_fd, &fdset);
1074       nfd = listen_fd;
1075     }
1076
1077   for (;;)
1078     {
1079       sigset_t oldsigs;
1080       
1081       if (shutdown_pending)
1082         {
1083           if (pth_ctrl (PTH_CTRL_GETTHREADS) == 1)
1084             break; /* ready */
1085
1086           /* Do not accept anymore connections but wait for existing
1087              connections to terminate. We do this by clearing out all
1088              file descriptors to wait for, so that the select will be
1089              used to just wait on a signal or timeout event. */
1090           FD_ZERO (&fdset);
1091         }
1092
1093       /* Create a timeout event if needed. */
1094       if (!time_ev)
1095         time_ev = pth_event (PTH_EVENT_TIME,
1096                              pth_timeout (TIMERTICK_INTERVAL, 0));
1097
1098       /* POSIX says that fd_set should be implemented as a structure,
1099          thus a simple assignment is fine to copy the entire set.  */
1100       read_fdset = fdset;
1101
1102       if (time_ev)
1103         pth_event_concat (ev, time_ev, NULL);
1104       ret = pth_select_ev (nfd+1, &read_fdset, NULL, NULL, NULL, ev);
1105       if (time_ev)
1106         pth_event_isolate (time_ev);
1107
1108       if (ret == -1)
1109         {
1110           if (pth_event_occurred (ev)
1111               || (time_ev && pth_event_occurred (time_ev)))
1112             {
1113               if (pth_event_occurred (ev))
1114                 handle_signal (signo);
1115               if (time_ev && pth_event_occurred (time_ev))
1116                 {
1117                   pth_event_free (time_ev, PTH_FREE_ALL);
1118                   time_ev = NULL;
1119                   handle_tick ();
1120                 }
1121               continue;
1122             }
1123           log_error (_("pth_select failed: %s - waiting 1s\n"),
1124                      strerror (errno));
1125           pth_sleep (1);
1126           continue;
1127         }
1128
1129       if (pth_event_occurred (ev))
1130         {
1131           handle_signal (signo);
1132         }
1133
1134       if (time_ev && pth_event_occurred (time_ev))
1135         {
1136           pth_event_free (time_ev, PTH_FREE_ALL);
1137           time_ev = NULL;
1138           handle_tick ();
1139         }
1140
1141       /* We now might create new threads and because we don't want any
1142          signals - we are handling here - to be delivered to a new
1143          thread. Thus we need to block those signals. */
1144       pth_sigmask (SIG_BLOCK, &sigs, &oldsigs);
1145
1146       if (listen_fd != -1 && FD_ISSET (listen_fd, &read_fdset))
1147         {
1148           ctrl_t ctrl;
1149
1150           plen = sizeof paddr;
1151           fd = pth_accept (listen_fd, (struct sockaddr *)&paddr, &plen);
1152           if (fd == -1)
1153             {
1154               log_error ("accept failed: %s\n", strerror (errno));
1155             }
1156           else if ( !(ctrl = xtrycalloc (1, sizeof *ctrl)) )
1157             {
1158               log_error ("error allocating connection control data: %s\n",
1159                          strerror (errno) );
1160               close (fd);
1161             }
1162           else
1163             {
1164               char threadname[50];
1165
1166               snprintf (threadname, sizeof threadname-1, "conn fd=%d", fd);
1167               threadname[sizeof threadname -1] = 0;
1168               pth_attr_set (tattr, PTH_ATTR_NAME, threadname);
1169               ctrl->thread_startup.fd = fd;
1170               if (!pth_spawn (tattr, start_connection_thread, ctrl))
1171                 {
1172                   log_error ("error spawning connection handler: %s\n",
1173                              strerror (errno) );
1174                   xfree (ctrl);
1175                   close (fd);
1176                 }
1177             }
1178           fd = -1;
1179         }
1180
1181       /* Restore the signal mask. */
1182       pth_sigmask (SIG_SETMASK, &oldsigs, NULL);
1183
1184     }
1185
1186   pth_event_free (ev, PTH_FREE_ALL);
1187   if (time_ev)
1188     pth_event_free (time_ev, PTH_FREE_ALL);
1189   cleanup ();
1190   log_info (_("%s %s stopped\n"), strusage(11), strusage(13));
1191 }
1192
1193