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