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