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