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