Changed to GPLv3.
[gnupg.git] / scd / scdaemon.c
1 /* scdaemon.c  -  The GnuPG Smartcard Daemon
2  *      Copyright (C) 2001, 2002, 2004, 2005, 2007 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 3 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, see <http://www.gnu.org/licenses/>.
18  */
19
20 #include <config.h>
21
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <stddef.h>
25 #include <stdarg.h>
26 #include <string.h>
27 #include <errno.h>
28 #include <assert.h>
29 #include <time.h>
30 #include <fcntl.h>
31 #ifndef HAVE_W32_SYSTEM
32 #include <sys/socket.h>
33 #include <sys/un.h>
34 #endif /*HAVE_W32_SYSTEM*/
35 #include <unistd.h>
36 #include <signal.h>
37 #include <pth.h>
38
39 #define JNLIB_NEED_LOG_LOGV
40 #include "scdaemon.h"
41 #include <ksba.h>
42 #include <gcrypt.h>
43
44 #include <assuan.h> /* malloc hooks */
45
46 #include "i18n.h"
47 #include "sysutils.h"
48 #include "app-common.h"
49 #ifdef HAVE_W32_SYSTEM
50 #include "../jnlib/w32-afunix.h"
51 #endif
52 #include "ccid-driver.h"
53 #include "mkdtemp.h"
54
55 enum cmd_and_opt_values 
56 { aNull = 0,
57   oCsh            = 'c',
58   oQuiet          = 'q',
59   oSh             = 's',
60   oVerbose        = 'v',
61   
62   oNoVerbose = 500,
63   aGPGConfList,
64   aGPGConfTest,
65   oOptions,
66   oDebug,
67   oDebugAll,
68   oDebugLevel,
69   oDebugWait,
70   oDebugAllowCoreDump,
71   oDebugCCIDDriver,
72   oNoGreeting,
73   oNoOptions,
74   oHomedir,
75   oNoDetach,
76   oNoGrab,
77   oLogFile,
78   oServer,
79   oMultiServer,
80   oDaemon,
81   oBatch,
82   oReaderPort,
83   octapiDriver,
84   opcscDriver,
85   oDisableCCID,
86   oDisableOpenSC,
87   oDisableKeypad,
88   oAllowAdmin,
89   oDenyAdmin,
90   oDisableApplication,
91   oDebugDisableTicker
92 };
93
94
95
96 static ARGPARSE_OPTS opts[] = {
97
98   { aGPGConfList, "gpgconf-list", 256, "@" },
99   { aGPGConfTest, "gpgconf-test", 256, "@" },
100   
101   { 301, NULL, 0, N_("@Options:\n ") },
102
103   { oServer,   "server",     0, N_("run in server mode (foreground)") },
104   { oMultiServer, "multi-server", 0,
105                                 N_("run in multi server mode (foreground)") },
106   { oDaemon,   "daemon",     0, N_("run in daemon mode (background)") },
107   { oVerbose, "verbose",   0, N_("verbose") },
108   { oQuiet,     "quiet",     0, N_("be somewhat more quiet") },
109   { oSh,        "sh",        0, N_("sh-style command output") },
110   { oCsh,       "csh",       0, N_("csh-style command output") },
111   { oOptions, "options"  , 2, N_("read options from file")},
112   { oDebug,     "debug"     ,4|16, "@"},
113   { oDebugAll, "debug-all"     ,0, "@"},
114   { oDebugLevel, "debug-level" ,2, "@"},
115   { oDebugWait,"debug-wait",1, "@"},
116   { oDebugAllowCoreDump, "debug-allow-core-dump", 0, "@" },
117   { oDebugCCIDDriver, "debug-ccid-driver", 0, "@"},
118   { oDebugDisableTicker, "debug-disable-ticker", 0, "@"},
119   { oNoDetach, "no-detach" ,0, N_("do not detach from the console")},
120   { oLogFile,  "log-file"   ,2, N_("use a log file for the server")},
121   { oReaderPort, "reader-port", 2, N_("|N|connect to reader at port N")},
122   { octapiDriver, "ctapi-driver", 2, N_("|NAME|use NAME as ct-API driver")},
123   { opcscDriver, "pcsc-driver", 2, N_("|NAME|use NAME as PC/SC driver")},
124   { oDisableCCID, "disable-ccid", 0,
125 #ifdef HAVE_LIBUSB
126                                     N_("do not use the internal CCID driver")
127 #else
128                                     "@"
129 #endif
130                                          /* end --disable-ccid */},
131   { oDisableKeypad, "disable-keypad", 0, N_("do not use a reader's keypad")},
132   { oAllowAdmin, "allow-admin", 0, N_("allow the use of admin card commands")},
133   { oDenyAdmin,  "deny-admin",  0, "@" },  
134   { oDisableApplication, "disable-application", 2, "@"},
135
136   {0}
137 };
138
139
140 /* The card driver we use by default for PC/SC.  */
141 #if defined(HAVE_W32_SYSTEM) || defined(__CYGWIN__)
142 #define DEFAULT_PCSC_DRIVER "winscard.dll"
143 #elif defined(__APPLE__)
144 #define DEFAULT_PCSC_DRIVER "/System/Library/Frameworks/PCSC.framework/PCSC"
145 #elif defined(__GLIBC__)
146 #define DEFAULT_PCSC_DRIVER "libpcsclite.so.1"
147 #else
148 #define DEFAULT_PCSC_DRIVER "libpcsclite.so"
149 #endif
150
151 /* The timer tick used for housekeeping stuff.  For Windows we use a
152    longer period as the SetWaitableTimer seems to signal earlier than
153    the 2 seconds.  */
154 #ifdef HAVE_W32_SYSTEM
155 #define TIMERTICK_INTERVAL    (4)
156 #else
157 #define TIMERTICK_INTERVAL    (2)    /* Seconds.  */
158 #endif
159
160
161 /* Flag to indicate that a shutdown was requested. */
162 static int shutdown_pending;
163
164 /* It is possible that we are currently running under setuid permissions */
165 static int maybe_setuid = 1;
166
167 /* Name of the communication socket */
168 static char *socket_name;
169
170
171 /* Debug flag to disable the ticker.  The ticker is in fact not
172    disabled but it won't perform any ticker specific actions. */
173 static int ticker_disabled;
174
175
176 \f
177 static char *create_socket_name (int use_standard_socket,
178                                  char *standard_name, char *template);
179 static int create_server_socket (int is_standard_name, const char *name);
180
181 static void *start_connection_thread (void *arg);
182 static void handle_connections (int listen_fd);
183
184 /* Pth wrapper function definitions. */
185 GCRY_THREAD_OPTION_PTH_IMPL;
186 static int fixed_gcry_pth_init (void)
187 {
188   return pth_self ()? 0 : (pth_init () == FALSE) ? errno : 0;
189 }
190
191
192 \f
193 static const char *
194 my_strusage (int level)
195 {
196   const char *p;
197   switch (level)
198     {
199     case 11: p = "scdaemon (GnuPG)";
200       break;
201     case 13: p = VERSION; break;
202     case 17: p = PRINTABLE_OS_NAME; break;
203     case 19: p = _("Please report bugs to <" PACKAGE_BUGREPORT ">.\n");
204       break;
205     case 1:
206     case 40: p =  _("Usage: scdaemon [options] (-h for help)");
207       break;
208     case 41: p =  _("Syntax: scdaemon [options] [command [args]]\n"
209                     "Smartcard daemon for GnuPG\n");
210     break;
211     
212     default: p = NULL;
213     }
214   return p;
215 }
216
217
218
219
220
221 /* Setup the debugging.  With a LEVEL of NULL only the active debug
222    flags are propagated to the subsystems.  With LEVEL set, a specific
223    set of debug flags is set; thus overriding all flags already
224    set. */
225 static void
226 set_debug (const char *level)
227 {
228   if (!level)
229     ;
230   else if (!strcmp (level, "none"))
231     opt.debug = 0;
232   else if (!strcmp (level, "basic"))
233     opt.debug = DBG_ASSUAN_VALUE;
234   else if (!strcmp (level, "advanced"))
235     opt.debug = DBG_ASSUAN_VALUE|DBG_COMMAND_VALUE;
236   else if (!strcmp (level, "expert"))
237     opt.debug = (DBG_ASSUAN_VALUE|DBG_COMMAND_VALUE
238                  |DBG_CACHE_VALUE|DBG_CARD_IO_VALUE);
239   else if (!strcmp (level, "guru"))
240     opt.debug = ~0;
241   else
242     {
243       log_error (_("invalid debug-level `%s' given\n"), level);
244       scd_exit(2);
245     }
246
247
248   if (opt.debug && !opt.verbose)
249     opt.verbose = 1;
250   if (opt.debug && opt.quiet)
251     opt.quiet = 0;
252
253   if (opt.debug & DBG_MPI_VALUE)
254     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 2);
255   if (opt.debug & DBG_CRYPTO_VALUE )
256     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1);
257   gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
258 }
259  
260
261
262 static void
263 cleanup (void)
264 {
265   if (socket_name && *socket_name)
266     {
267       char *p;
268
269       remove (socket_name);
270       p = strrchr (socket_name, '/');
271       if (p)
272         {
273           *p = 0;
274           rmdir (socket_name);
275           *p = '/';
276         }
277       *socket_name = 0;
278     }
279 }
280
281
282
283 int
284 main (int argc, char **argv )
285 {
286   ARGPARSE_ARGS pargs;
287   int orig_argc;
288   gpg_error_t err;
289   int may_coredump;
290   char **orig_argv;
291   FILE *configfp = NULL;
292   char *configname = NULL;
293   const char *shell;
294   unsigned int configlineno;
295   int parse_debug = 0;
296   const char *debug_level = NULL;
297   int default_config =1;
298   int greeting = 0;
299   int nogreeting = 0;
300   int pipe_server = 0;
301   int multi_server = 0;
302   int is_daemon = 0;
303   int nodetach = 0;
304   int csh_style = 0;
305   char *logfile = NULL;
306   int debug_wait = 0;
307   int gpgconf_list = 0;
308   const char *config_filename = NULL;
309   int allow_coredump = 0;
310
311   set_strusage (my_strusage);
312   gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
313   /* Please note that we may running SUID(ROOT), so be very CAREFUL
314      when adding any stuff between here and the call to INIT_SECMEM()
315      somewhere after the option parsing */
316   log_set_prefix ("scdaemon", 1|4); 
317
318   /* Make sure that our subsystems are ready.  */
319   init_common_subsystems ();
320
321   i18n_init ();
322
323   /* Libgcrypt requires us to register the threading model first.
324      Note that this will also do the pth_init. */
325   gcry_threads_pth.init = fixed_gcry_pth_init;
326   err = gcry_control (GCRYCTL_SET_THREAD_CBS, &gcry_threads_pth);
327   if (err)
328     {
329       log_fatal ("can't register GNU Pth with Libgcrypt: %s\n",
330                  gpg_strerror (err));
331     }
332
333   /* Check that the libraries are suitable.  Do it here because
334      the option parsing may need services of the library */
335   if (!gcry_check_version (NEED_LIBGCRYPT_VERSION) )
336     {
337       log_fatal (_("%s is too old (need %s, have %s)\n"), "libgcrypt",
338                  NEED_LIBGCRYPT_VERSION, gcry_check_version (NULL) );
339     }
340
341   ksba_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
342
343   assuan_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
344   assuan_set_assuan_log_stream (log_get_stream ());
345   assuan_set_assuan_log_prefix (log_get_prefix (NULL));
346   assuan_set_assuan_err_source (GPG_ERR_SOURCE_DEFAULT);
347
348   setup_libgcrypt_logging ();
349   gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
350
351   may_coredump = disable_core_dumps ();
352
353   /* Set default options. */
354   opt.pcsc_driver = DEFAULT_PCSC_DRIVER; 
355
356
357   shell = getenv ("SHELL");
358   if (shell && strlen (shell) >= 3 && !strcmp (shell+strlen (shell)-3, "csh") )
359     csh_style = 1;
360   
361   opt.homedir = default_homedir ();
362
363   /* Check whether we have a config file on the commandline */
364   orig_argc = argc;
365   orig_argv = argv;
366   pargs.argc = &argc;
367   pargs.argv = &argv;
368   pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
369   while (arg_parse( &pargs, opts))
370     {
371       if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll)
372         parse_debug++;
373       else if (pargs.r_opt == oOptions)
374         { /* yes there is one, so we do not try the default one, but
375              read the option file when it is encountered at the
376              commandline */
377           default_config = 0;
378         }
379         else if (pargs.r_opt == oNoOptions)
380           default_config = 0; /* --no-options */
381         else if (pargs.r_opt == oHomedir)
382           opt.homedir = pargs.r.ret_str;
383     }
384
385   /* initialize the secure memory. */
386   gcry_control (GCRYCTL_INIT_SECMEM, 16384, 0);
387   maybe_setuid = 0;
388
389   /* 
390      Now we are working under our real uid 
391   */
392
393
394   if (default_config)
395     configname = make_filename (opt.homedir, "scdaemon.conf", NULL );
396
397   
398   argc = orig_argc;
399   argv = orig_argv;
400   pargs.argc = &argc;
401   pargs.argv = &argv;
402   pargs.flags=  1;  /* do not remove the args */
403  next_pass:
404   if (configname)
405     {
406       configlineno = 0;
407       configfp = fopen (configname, "r");
408       if (!configfp)
409         {
410           if (default_config)
411             {
412               if( parse_debug )
413                 log_info (_("NOTE: no default option file `%s'\n"),
414                           configname );
415             }
416           else
417             {
418               log_error (_("option file `%s': %s\n"),
419                          configname, strerror(errno) );
420               exit(2);
421             }
422           xfree (configname); 
423           configname = NULL;
424         }
425       if (parse_debug && configname )
426         log_info (_("reading options from `%s'\n"), configname );
427       default_config = 0;
428     }
429
430   while (optfile_parse( configfp, configname, &configlineno, &pargs, opts) )
431     {
432       switch (pargs.r_opt)
433         {
434         case aGPGConfList: gpgconf_list = 1; break;
435         case aGPGConfTest: gpgconf_list = 2; break;
436         case oQuiet: opt.quiet = 1; break;
437         case oVerbose: opt.verbose++; break;
438         case oBatch: opt.batch=1; break;
439
440         case oDebug: opt.debug |= pargs.r.ret_ulong; break;
441         case oDebugAll: opt.debug = ~0; break;
442         case oDebugLevel: debug_level = pargs.r.ret_str; break;
443         case oDebugWait: debug_wait = pargs.r.ret_int; break;
444         case oDebugAllowCoreDump:
445           enable_core_dumps ();
446           allow_coredump = 1;
447           break;
448         case oDebugCCIDDriver: 
449 #ifdef HAVE_LIBUSB
450           ccid_set_debug_level (ccid_set_debug_level (-1)+1);
451 #endif /*HAVE_LIBUSB*/
452           break;
453         case oDebugDisableTicker: ticker_disabled = 1; break;
454
455         case oOptions:
456           /* config files may not be nested (silently ignore them) */
457           if (!configfp)
458             {
459                 xfree(configname);
460                 configname = xstrdup(pargs.r.ret_str);
461                 goto next_pass;
462             }
463           break;
464         case oNoGreeting: nogreeting = 1; break;
465         case oNoVerbose: opt.verbose = 0; break;
466         case oNoOptions: break; /* no-options */
467         case oHomedir: opt.homedir = pargs.r.ret_str; break;
468         case oNoDetach: nodetach = 1; break;
469         case oLogFile: logfile = pargs.r.ret_str; break;
470         case oCsh: csh_style = 1; break;
471         case oSh: csh_style = 0; break;
472         case oServer: pipe_server = 1; break;
473         case oMultiServer: pipe_server = 1; multi_server = 1; break;
474         case oDaemon: is_daemon = 1; break;
475
476         case oReaderPort: opt.reader_port = pargs.r.ret_str; break;
477         case octapiDriver: opt.ctapi_driver = pargs.r.ret_str; break;
478         case opcscDriver: opt.pcsc_driver = pargs.r.ret_str; break;
479         case oDisableCCID: opt.disable_ccid = 1; break;
480         case oDisableOpenSC: break;
481
482         case oDisableKeypad: opt.disable_keypad = 1; break;
483
484         case oAllowAdmin: opt.allow_admin = 1; break;
485         case oDenyAdmin: opt.allow_admin = 0; break;
486
487         case oDisableApplication:
488           add_to_strlist (&opt.disabled_applications, pargs.r.ret_str); 
489           break;
490
491         default : pargs.err = configfp? 1:2; break;
492         }
493     }
494   if (configfp)
495     {
496       fclose( configfp );
497       configfp = NULL;
498       /* Keep a copy of the config name for use by --gpgconf-list. */
499       config_filename = configname;
500       configname = NULL;
501       goto next_pass;
502     }
503   xfree (configname);
504   configname = NULL;
505   if (log_get_errorcount(0))
506     exit(2);
507   if (nogreeting )
508     greeting = 0;
509
510   if (greeting)
511     {
512       fprintf (stderr, "%s %s; %s\n",
513                  strusage(11), strusage(13), strusage(14) );
514       fprintf (stderr, "%s\n", strusage(15) );
515     }
516 #ifdef IS_DEVELOPMENT_VERSION
517   log_info ("NOTE: this is a development version!\n");
518 #endif
519
520  
521   if (atexit (cleanup))
522     {
523       log_error ("atexit failed\n");
524       cleanup ();
525       exit (1);
526     }
527
528   set_debug (debug_level);
529
530   if (debug_wait && pipe_server)
531     {
532       log_debug ("waiting for debugger - my pid is %u .....\n",
533                  (unsigned int)getpid());
534       gnupg_sleep (debug_wait);
535       log_debug ("... okay\n");
536     }
537   
538   initialize_module_command ();
539
540   if (gpgconf_list == 2)
541     scd_exit (0);
542   if (gpgconf_list)
543     {
544       /* List options and default values in the GPG Conf format.  */
545       char *filename = NULL;
546       char *filename_esc;
547
548       /* The following list is taken from gnupg/tools/gpgconf-comp.c.  */
549       /* Option flags.  YOU MUST NOT CHANGE THE NUMBERS OF THE EXISTING
550          FLAGS, AS THEY ARE PART OF THE EXTERNAL INTERFACE.  */
551 #define GC_OPT_FLAG_NONE        0UL
552       /* The RUNTIME flag for an option indicates that the option can be
553          changed at runtime.  */
554 #define GC_OPT_FLAG_RUNTIME     (1UL << 3)
555       /* The DEFAULT flag for an option indicates that the option has a
556          default value.  */
557 #define GC_OPT_FLAG_DEFAULT     (1UL << 4)
558       /* The DEF_DESC flag for an option indicates that the option has a
559          default, which is described by the value of the default field.  */
560 #define GC_OPT_FLAG_DEF_DESC    (1UL << 5)
561       /* The NO_ARG_DESC flag for an option indicates that the argument has
562          a default, which is described by the value of the ARGDEF field.  */
563 #define GC_OPT_FLAG_NO_ARG_DESC (1UL << 6)
564       if (!config_filename)
565         filename = make_filename (opt.homedir, "scdaemon.conf", NULL );
566       filename_esc = percent_escape (filename, NULL);
567
568       printf ("gpgconf-scdaemon.conf:%lu:\"%s\n",
569               GC_OPT_FLAG_DEFAULT, filename_esc);
570       xfree (filename_esc);
571       xfree (filename);
572
573       printf ("verbose:%lu:\n"
574               "quiet:%lu:\n"
575               "debug-level:%lu:\"none:\n"
576               "log-file:%lu:\n",
577               GC_OPT_FLAG_NONE,
578               GC_OPT_FLAG_NONE,
579               GC_OPT_FLAG_DEFAULT,
580               GC_OPT_FLAG_NONE );
581
582       printf ("reader-port:%lu:\n", GC_OPT_FLAG_NONE );
583       printf ("ctapi-driver:%lu:\n", GC_OPT_FLAG_NONE );
584       printf ("pcsc-driver:%lu:\"%s:\n",
585               GC_OPT_FLAG_DEFAULT, DEFAULT_PCSC_DRIVER );
586 #ifdef HAVE_LIBUSB
587       printf ("disable-ccid:%lu:\n", GC_OPT_FLAG_NONE );
588 #endif
589       printf ("allow-admin:%lu:\n", GC_OPT_FLAG_NONE );
590       printf ("disable-keypad:%lu:\n", GC_OPT_FLAG_NONE );
591
592       scd_exit (0);
593     }
594
595   /* now start with logging to a file if this is desired */
596   if (logfile)
597     {
598       log_set_file (logfile);
599       log_set_prefix (NULL, 1|2|4);
600     }
601
602   if (pipe_server)
603     { 
604       /* This is the simple pipe based server */
605       ctrl_t ctrl;
606       pth_attr_t tattr;
607       int fd = -1;
608
609 #ifndef HAVE_W32_SYSTEM
610       {
611         struct sigaction sa;
612         
613         sa.sa_handler = SIG_IGN;
614         sigemptyset (&sa.sa_mask);
615         sa.sa_flags = 0;
616         sigaction (SIGPIPE, &sa, NULL);
617       }
618 #endif
619
620       /* If --debug-allow-core-dump has been given we also need to
621          switch the working directory to a place where we can actually
622          write. */
623       if (allow_coredump)
624         {
625           if (chdir("/tmp"))
626             log_debug ("chdir to `/tmp' failed: %s\n", strerror (errno));
627           else
628             log_debug ("changed working directory to `/tmp'\n");
629         }
630
631       /* In multi server mode we need to listen on an additional
632          socket.  Create that socket now before starting the handler
633          for the pipe connection.  This allows that handler to send
634          back the name of that socket. */
635       if (multi_server)
636         {
637           socket_name = create_socket_name (0,
638                                             "S.scdaemon",
639                                             "/tmp/gpg-XXXXXX/S.scdaemon");
640           
641           fd = create_server_socket (0, socket_name);
642         }
643
644       tattr = pth_attr_new();
645       pth_attr_set (tattr, PTH_ATTR_JOINABLE, 0);
646       pth_attr_set (tattr, PTH_ATTR_STACK_SIZE, 512*1024);
647       pth_attr_set (tattr, PTH_ATTR_NAME, "pipe-connection");
648
649       ctrl = xtrycalloc (1, sizeof *ctrl);
650       if ( !ctrl )
651         {
652           log_error ("error allocating connection control data: %s\n",
653                      strerror (errno) );
654           scd_exit (2);
655         }
656       ctrl->thread_startup.fd = -1;
657       if ( !pth_spawn (tattr, start_connection_thread, ctrl) )
658         {
659           log_error ("error spawning pipe connection handler: %s\n",
660                      strerror (errno) );
661           xfree (ctrl);
662           scd_exit (2);
663         }
664
665       handle_connections (fd);
666       if (fd != -1)
667         close (fd);
668     }
669   else if (!is_daemon)
670     {
671       log_info (_("please use the option `--daemon'"
672                   " to run the program in the background\n"));
673     }
674   else
675     { /* Regular server mode */
676       int fd;
677       pid_t pid;
678       int i;
679
680       /* Create the socket.  */
681       socket_name = create_socket_name (0,
682                                         "S.scdaemon",
683                                         "/tmp/gpg-XXXXXX/S.scdaemon");
684
685       fd = create_server_socket (0, socket_name);
686
687
688       fflush (NULL);
689 #ifndef HAVE_W32_SYSTEM
690       pid = fork ();
691       if (pid == (pid_t)-1) 
692         {
693           log_fatal ("fork failed: %s\n", strerror (errno) );
694           exit (1);
695         }
696       else if (pid) 
697         { /* we are the parent */
698           char *infostr;
699           
700           close (fd);
701           
702           /* create the info string: <name>:<pid>:<protocol_version> */
703           if (asprintf (&infostr, "SCDAEMON_INFO=%s:%lu:1",
704                         socket_name, (ulong)pid ) < 0)
705             {
706               log_error ("out of core\n");
707               kill (pid, SIGTERM);
708               exit (1);
709             }
710           *socket_name = 0; /* don't let cleanup() remove the socket -
711                                the child should do this from now on */
712           if (argc) 
713             { /* run the program given on the commandline */
714               if (putenv (infostr))
715                 {
716                   log_error ("failed to set environment: %s\n",
717                              strerror (errno) );
718                   kill (pid, SIGTERM );
719                   exit (1);
720                 }
721               execvp (argv[0], argv);
722               log_error ("failed to run the command: %s\n", strerror (errno));
723               kill (pid, SIGTERM);
724               exit (1);
725             }
726           else
727             {
728               /* Print the environment string, so that the caller can use
729                  shell's eval to set it */
730               if (csh_style)
731                 {
732                   *strchr (infostr, '=') = ' ';
733                   printf ( "setenv %s\n", infostr);
734                 }
735               else
736                 {
737                   printf ( "%s; export SCDAEMON_INFO;\n", infostr);
738                 }
739               free (infostr);
740               exit (0); 
741             }
742           /* NOTREACHED */
743         } /* end parent */
744       
745       /* This is the child. */
746
747       /* Detach from tty and put process into a new session. */
748       if (!nodetach )
749         {  
750           /* Close stdin, stdout and stderr unless it is the log stream. */
751           for (i=0; i <= 2; i++) 
752             {
753               if ( log_test_fd (i) && i != fd)
754                 close (i);
755             }
756           if (setsid() == -1)
757             {
758               log_error ("setsid() failed: %s\n", strerror(errno) );
759               cleanup ();
760               exit (1);
761             }
762         }
763
764       {
765         struct sigaction sa;
766         
767         sa.sa_handler = SIG_IGN;
768         sigemptyset (&sa.sa_mask);
769         sa.sa_flags = 0;
770         sigaction (SIGPIPE, &sa, NULL);
771       }
772
773       if (chdir("/"))
774         {
775           log_error ("chdir to / failed: %s\n", strerror (errno));
776           exit (1);
777         }
778
779 #endif /*!HAVE_W32_SYSTEM*/
780
781       handle_connections (fd);
782
783       close (fd);
784     }
785   
786   return 0;
787 }
788
789 void
790 scd_exit (int rc)
791 {
792 #if 0
793 #warning no update_random_seed_file
794   update_random_seed_file();
795 #endif
796 #if 0
797   /* at this time a bit annoying */
798   if (opt.debug & DBG_MEMSTAT_VALUE)
799     {
800       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
801       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
802     }
803   if (opt.debug)
804     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
805 #endif
806   gcry_control (GCRYCTL_TERM_SECMEM );
807   rc = rc? rc : log_get_errorcount(0)? 2 : 0;
808   exit (rc);
809 }
810
811
812 static void
813 scd_init_default_ctrl (ctrl_t ctrl)
814 {
815   ctrl->reader_slot = -1;
816 }
817
818 static void
819 scd_deinit_default_ctrl (ctrl_t ctrl)
820 {
821
822 }
823
824
825 /* Return the name of the socket to be used to connect to this
826    process.  If no socket is available, return NULL. */
827 const char *
828 scd_get_socket_name ()
829 {
830   if (socket_name && *socket_name)
831     return socket_name;
832   return NULL;
833 }
834
835
836 static void
837 handle_signal (int signo)
838 {
839   switch (signo)
840     {
841 #ifndef HAVE_W32_SYSTEM
842     case SIGHUP:
843       log_info ("SIGHUP received - "
844                 "re-reading configuration and resetting cards\n");
845 /*       reread_configuration (); */
846       break;
847       
848     case SIGUSR1:
849       log_info ("SIGUSR1 received - printing internal information:\n");
850       pth_ctrl (PTH_CTRL_DUMPSTATE, log_get_stream ());
851       app_dump_state ();
852       break;
853
854     case SIGUSR2:
855       log_info ("SIGUSR2 received - no action defined\n");
856       break;
857
858     case SIGTERM:
859       if (!shutdown_pending)
860         log_info ("SIGTERM received - shutting down ...\n");
861       else
862         log_info ("SIGTERM received - still %ld running threads\n",
863                   pth_ctrl( PTH_CTRL_GETTHREADS ));
864       shutdown_pending++;
865       if (shutdown_pending > 2)
866         {
867           log_info ("shutdown forced\n");
868           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
869           cleanup ();
870           scd_exit (0);
871         }
872       break;
873         
874     case SIGINT:
875       log_info ("SIGINT received - immediate shutdown\n");
876       log_info( "%s %s stopped\n", strusage(11), strusage(13));
877       cleanup ();
878       scd_exit (0);
879       break;
880 #endif /*!HAVE_W32_SYSTEM*/
881
882     default:
883       log_info ("signal %d received - no action defined\n", signo);
884     }
885 }
886
887
888 static void
889 handle_tick (void)
890 {
891   if (!ticker_disabled)
892     scd_update_reader_status_file ();
893 }
894
895
896 /* Create a name for the socket.  With USE_STANDARD_SOCKET given as
897    true using STANDARD_NAME in the home directory or if given has
898    false from the mkdir type name TEMPLATE.  In the latter case a
899    unique name in a unique new directory will be created.  In both
900    cases check for valid characters as well as against a maximum
901    allowed length for a unix domain socket is done.  The function
902    terminates the process in case of an error.  Retunrs: Pointer to an
903    allcoated string with the absolute name of the socket used.  */
904 static char *
905 create_socket_name (int use_standard_socket,
906                     char *standard_name, char *template)
907 {
908   char *name, *p;
909
910   if (use_standard_socket)
911     name = make_filename (opt.homedir, standard_name, NULL);
912   else
913     {
914       name = xstrdup (template);
915       p = strrchr (name, '/');
916       if (!p)
917         BUG ();
918       *p = 0;
919       if (!mkdtemp (name))
920         {
921           log_error (_("can't create directory `%s': %s\n"),
922                      name, strerror (errno));
923           scd_exit (2);
924         }
925       *p = '/';
926     }
927
928   if (strchr (name, PATHSEP_C))
929     {
930       log_error (("`%s' are not allowed in the socket name\n"), PATHSEP_S);
931       scd_exit (2);
932     }
933   if (strlen (name) + 1 >= DIMof (struct sockaddr_un, sun_path) )
934     {
935       log_error (_("name of socket too long\n"));
936       scd_exit (2);
937     }
938   return name;
939 }
940
941
942
943 /* Create a Unix domain socket with NAME.  IS_STANDARD_NAME indicates
944    whether a non-random socket is used.  Returns the file descriptor
945    or terminates the process in case of an error. */
946 static int
947 create_server_socket (int is_standard_name, const char *name)
948 {
949   struct sockaddr_un *serv_addr;
950   socklen_t len;
951   int fd;
952   int rc;
953
954 #ifdef HAVE_W32_SYSTEM
955   fd = _w32_sock_new (AF_UNIX, SOCK_STREAM, 0);
956 #else
957   fd = socket (AF_UNIX, SOCK_STREAM, 0);
958 #endif
959   if (fd == -1)
960     {
961       log_error (_("can't create socket: %s\n"), strerror (errno));
962       scd_exit (2);
963     }
964
965   serv_addr = xmalloc (sizeof (*serv_addr)); 
966   memset (serv_addr, 0, sizeof *serv_addr);
967   serv_addr->sun_family = AF_UNIX;
968   assert (strlen (name) + 1 < sizeof (serv_addr->sun_path));
969   strcpy (serv_addr->sun_path, name);
970   len = (offsetof (struct sockaddr_un, sun_path)
971          + strlen (serv_addr->sun_path) + 1);
972
973 #ifdef HAVE_W32_SYSTEM
974   rc = _w32_sock_bind (fd, (struct sockaddr*) serv_addr, len);
975   if (is_standard_name && rc == -1 )
976     {
977       remove (name);
978       rc = bind (fd, (struct sockaddr*) serv_addr, len);
979     }
980 #else
981   rc = bind (fd, (struct sockaddr*) serv_addr, len);
982   if (is_standard_name && rc == -1 && errno == EADDRINUSE)
983     {
984       remove (name);
985       rc = bind (fd, (struct sockaddr*) serv_addr, len);
986     }
987 #endif
988   if (rc == -1)
989     {
990       log_error (_("error binding socket to `%s': %s\n"),
991                  serv_addr->sun_path, strerror (errno));
992       close (fd);
993       scd_exit (2);
994     }
995
996   if (listen (fd, 5 ) == -1)
997     {
998       log_error (_("listen() failed: %s\n"), strerror (errno));
999       close (fd);
1000       scd_exit (2);
1001     }
1002           
1003   if (opt.verbose)
1004     log_info (_("listening on socket `%s'\n"), serv_addr->sun_path);
1005
1006   return fd;
1007 }
1008
1009
1010
1011 /* This is the standard connection thread's main function.  */
1012 static void *
1013 start_connection_thread (void *arg)
1014 {
1015   ctrl_t ctrl = arg;
1016
1017   scd_init_default_ctrl (ctrl);
1018   if (opt.verbose)
1019     log_info (_("handler for fd %d started\n"), ctrl->thread_startup.fd);
1020
1021   scd_command_handler (ctrl, ctrl->thread_startup.fd);
1022
1023   if (opt.verbose)
1024     log_info (_("handler for fd %d terminated\n"), ctrl->thread_startup.fd);
1025
1026   /* If this thread is the pipe connection thread, flag that a
1027      shutdown is required.  With the next ticker event and given that
1028      no other connections are running the shutdown will then
1029      happen. */
1030   if (ctrl->thread_startup.fd == -1)
1031     shutdown_pending = 1;
1032   
1033   scd_deinit_default_ctrl (ctrl);
1034   xfree (ctrl);
1035   return NULL;
1036 }
1037
1038
1039 /* Connection handler loop.  Wait for connection requests and spawn a
1040    thread after accepting a connection.  LISTEN_FD is allowed to be -1
1041    in which case this code will only do regular timeouts and handle
1042    signals. */
1043 static void
1044 handle_connections (int listen_fd)
1045 {
1046   pth_attr_t tattr;
1047   pth_event_t ev, time_ev;
1048   sigset_t sigs;
1049   int signo;
1050   struct sockaddr_un paddr;
1051   socklen_t plen;
1052   fd_set fdset, read_fdset;
1053   int ret;
1054   int fd;
1055   int nfd;
1056
1057   tattr = pth_attr_new();
1058   pth_attr_set (tattr, PTH_ATTR_JOINABLE, 0);
1059   pth_attr_set (tattr, PTH_ATTR_STACK_SIZE, 512*1024);
1060
1061 #ifndef HAVE_W32_SYSTEM /* fixme */
1062   sigemptyset (&sigs );
1063   sigaddset (&sigs, SIGHUP);
1064   sigaddset (&sigs, SIGUSR1);
1065   sigaddset (&sigs, SIGUSR2);
1066   sigaddset (&sigs, SIGINT);
1067   sigaddset (&sigs, SIGTERM);
1068   pth_sigmask (SIG_UNBLOCK, &sigs, NULL);
1069   ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
1070 #else
1071   sigs = 0;
1072   ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
1073 #endif
1074   time_ev = NULL;
1075
1076   FD_ZERO (&fdset);
1077   nfd = 0;
1078   if (listen_fd != -1)
1079     {
1080       FD_SET (listen_fd, &fdset);
1081       nfd = listen_fd;
1082     }
1083
1084   for (;;)
1085     {
1086       sigset_t oldsigs;
1087       
1088       if (shutdown_pending)
1089         {
1090           if (pth_ctrl (PTH_CTRL_GETTHREADS) == 1)
1091             break; /* ready */
1092
1093           /* Do not accept anymore connections but wait for existing
1094              connections to terminate. We do this by clearing out all
1095              file descriptors to wait for, so that the select will be
1096              used to just wait on a signal or timeout event. */
1097           FD_ZERO (&fdset);
1098         }
1099
1100       /* Create a timeout event if needed. */
1101       if (!time_ev)
1102         time_ev = pth_event (PTH_EVENT_TIME,
1103                              pth_timeout (TIMERTICK_INTERVAL, 0));
1104
1105       /* POSIX says that fd_set should be implemented as a structure,
1106          thus a simple assignment is fine to copy the entire set.  */
1107       read_fdset = fdset;
1108
1109       if (time_ev)
1110         pth_event_concat (ev, time_ev, NULL);
1111       ret = pth_select_ev (nfd+1, &read_fdset, NULL, NULL, NULL, ev);
1112       if (time_ev)
1113         pth_event_isolate (time_ev);
1114
1115       if (ret == -1)
1116         {
1117           if (pth_event_occurred (ev)
1118               || (time_ev && pth_event_occurred (time_ev)))
1119             {
1120               if (pth_event_occurred (ev))
1121                 handle_signal (signo);
1122               if (time_ev && pth_event_occurred (time_ev))
1123                 {
1124                   pth_event_free (time_ev, PTH_FREE_ALL);
1125                   time_ev = NULL;
1126                   handle_tick ();
1127                 }
1128               continue;
1129             }
1130           log_error (_("pth_select failed: %s - waiting 1s\n"),
1131                      strerror (errno));
1132           pth_sleep (1);
1133           continue;
1134         }
1135
1136       if (pth_event_occurred (ev))
1137         {
1138           handle_signal (signo);
1139         }
1140
1141       if (time_ev && pth_event_occurred (time_ev))
1142         {
1143           pth_event_free (time_ev, PTH_FREE_ALL);
1144           time_ev = NULL;
1145           handle_tick ();
1146         }
1147
1148       /* We now might create new threads and because we don't want any
1149          signals - we are handling here - to be delivered to a new
1150          thread. Thus we need to block those signals. */
1151       pth_sigmask (SIG_BLOCK, &sigs, &oldsigs);
1152
1153       if (listen_fd != -1 && FD_ISSET (listen_fd, &read_fdset))
1154         {
1155           ctrl_t ctrl;
1156
1157           plen = sizeof paddr;
1158           fd = pth_accept (listen_fd, (struct sockaddr *)&paddr, &plen);
1159           if (fd == -1)
1160             {
1161               log_error ("accept failed: %s\n", strerror (errno));
1162             }
1163           else if ( !(ctrl = xtrycalloc (1, sizeof *ctrl)) )
1164             {
1165               log_error ("error allocating connection control data: %s\n",
1166                          strerror (errno) );
1167               close (fd);
1168             }
1169           else
1170             {
1171               char threadname[50];
1172
1173               snprintf (threadname, sizeof threadname-1, "conn fd=%d", fd);
1174               threadname[sizeof threadname -1] = 0;
1175               pth_attr_set (tattr, PTH_ATTR_NAME, threadname);
1176               ctrl->thread_startup.fd = fd;
1177               if (!pth_spawn (tattr, start_connection_thread, ctrl))
1178                 {
1179                   log_error ("error spawning connection handler: %s\n",
1180                              strerror (errno) );
1181                   xfree (ctrl);
1182                   close (fd);
1183                 }
1184             }
1185           fd = -1;
1186         }
1187
1188       /* Restore the signal mask. */
1189       pth_sigmask (SIG_SETMASK, &oldsigs, NULL);
1190
1191     }
1192
1193   pth_event_free (ev, PTH_FREE_ALL);
1194   if (time_ev)
1195     pth_event_free (time_ev, PTH_FREE_ALL);
1196   cleanup ();
1197   log_info (_("%s %s stopped\n"), strusage(11), strusage(13));
1198 }
1199
1200