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