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