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