Started to implement the audit log feature.
[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 (standard_socket,
636                                             socket_name, &socket_nonce));
637         }
638
639       tattr = pth_attr_new();
640       pth_attr_set (tattr, PTH_ATTR_JOINABLE, 0);
641       pth_attr_set (tattr, PTH_ATTR_STACK_SIZE, 512*1024);
642       pth_attr_set (tattr, PTH_ATTR_NAME, "pipe-connection");
643
644       ctrl = xtrycalloc (1, sizeof *ctrl);
645       if ( !ctrl )
646         {
647           log_error ("error allocating connection control data: %s\n",
648                      strerror (errno) );
649           scd_exit (2);
650         }
651       ctrl->thread_startup.fd = GNUPG_INVALID_FD;
652       if ( !pth_spawn (tattr, start_connection_thread, ctrl) )
653         {
654           log_error ("error spawning pipe connection handler: %s\n",
655                      strerror (errno) );
656           xfree (ctrl);
657           scd_exit (2);
658         }
659
660       /* We run handle_connection to wait for the shutdown signal and
661          to run the ticker stuff.  */
662       handle_connections (fd);
663       if (fd != -1)
664         close (fd);
665     }
666   else if (!is_daemon)
667     {
668       log_info (_("please use the option `--daemon'"
669                   " to run the program in the background\n"));
670     }
671   else
672     { /* Regular server mode */
673       int fd;
674 #ifndef HAVE_W32_SYSTEM
675       pid_t pid;
676       int i;
677 #endif
678
679       /* Create the socket.  */
680       socket_name = create_socket_name (standard_socket,
681                                         "S.scdaemon",
682                                         "/tmp/gpg-XXXXXX/S.scdaemon");
683
684       fd = FD2INT (create_server_socket (standard_socket,
685                                          socket_name, &socket_nonce));
686
687
688       fflush (NULL);
689 #ifndef HAVE_W32_SYSTEM
690       pid = fork ();
691       if (pid == (pid_t)-1) 
692         {
693           log_fatal ("fork failed: %s\n", strerror (errno) );
694           exit (1);
695         }
696       else if (pid) 
697         { /* we are the parent */
698           char *infostr;
699           
700           close (fd);
701           
702           /* create the info string: <name>:<pid>:<protocol_version> */
703           if (asprintf (&infostr, "SCDAEMON_INFO=%s:%lu:1",
704                         socket_name, (ulong)pid ) < 0)
705             {
706               log_error ("out of core\n");
707               kill (pid, SIGTERM);
708               exit (1);
709             }
710           *socket_name = 0; /* don't let cleanup() remove the socket -
711                                the child should do this from now on */
712           if (argc) 
713             { /* run the program given on the commandline */
714               if (putenv (infostr))
715                 {
716                   log_error ("failed to set environment: %s\n",
717                              strerror (errno) );
718                   kill (pid, SIGTERM );
719                   exit (1);
720                 }
721               execvp (argv[0], argv);
722               log_error ("failed to run the command: %s\n", strerror (errno));
723               kill (pid, SIGTERM);
724               exit (1);
725             }
726           else
727             {
728               /* Print the environment string, so that the caller can use
729                  shell's eval to set it */
730               if (csh_style)
731                 {
732                   *strchr (infostr, '=') = ' ';
733                   printf ( "setenv %s\n", infostr);
734                 }
735               else
736                 {
737                   printf ( "%s; export SCDAEMON_INFO;\n", infostr);
738                 }
739               free (infostr);
740               exit (0); 
741             }
742           /* NOTREACHED */
743         } /* end parent */
744       
745       /* This is the child. */
746
747       /* Detach from tty and put process into a new session. */
748       if (!nodetach )
749         {  
750           /* Close stdin, stdout and stderr unless it is the log stream. */
751           for (i=0; i <= 2; i++) 
752             {
753               if ( log_test_fd (i) && i != fd)
754                 close (i);
755             }
756           if (setsid() == -1)
757             {
758               log_error ("setsid() failed: %s\n", strerror(errno) );
759               cleanup ();
760               exit (1);
761             }
762         }
763
764       {
765         struct sigaction sa;
766         
767         sa.sa_handler = SIG_IGN;
768         sigemptyset (&sa.sa_mask);
769         sa.sa_flags = 0;
770         sigaction (SIGPIPE, &sa, NULL);
771       }
772
773       if (chdir("/"))
774         {
775           log_error ("chdir to / failed: %s\n", strerror (errno));
776           exit (1);
777         }
778
779 #endif /*!HAVE_W32_SYSTEM*/
780
781       handle_connections (fd);
782
783       close (fd);
784     }
785   
786   return 0;
787 }
788
789 void
790 scd_exit (int rc)
791 {
792 #if 0
793 #warning no update_random_seed_file
794   update_random_seed_file();
795 #endif
796 #if 0
797   /* at this time a bit annoying */
798   if (opt.debug & DBG_MEMSTAT_VALUE)
799     {
800       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
801       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
802     }
803   if (opt.debug)
804     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
805 #endif
806   gcry_control (GCRYCTL_TERM_SECMEM );
807   rc = rc? rc : log_get_errorcount(0)? 2 : 0;
808   exit (rc);
809 }
810
811
812 static void
813 scd_init_default_ctrl (ctrl_t ctrl)
814 {
815   ctrl->reader_slot = -1;
816 }
817
818 static void
819 scd_deinit_default_ctrl (ctrl_t ctrl)
820 {
821
822 }
823
824
825 /* Return the name of the socket to be used to connect to this
826    process.  If no socket is available, return NULL. */
827 const char *
828 scd_get_socket_name ()
829 {
830   if (socket_name && *socket_name)
831     return socket_name;
832   return NULL;
833 }
834
835
836 static void
837 handle_signal (int signo)
838 {
839   switch (signo)
840     {
841 #ifndef HAVE_W32_SYSTEM
842     case SIGHUP:
843       log_info ("SIGHUP received - "
844                 "re-reading configuration and resetting cards\n");
845 /*       reread_configuration (); */
846       break;
847       
848     case SIGUSR1:
849       log_info ("SIGUSR1 received - printing internal information:\n");
850       pth_ctrl (PTH_CTRL_DUMPSTATE, log_get_stream ());
851       app_dump_state ();
852       break;
853
854     case SIGUSR2:
855       log_info ("SIGUSR2 received - no action defined\n");
856       break;
857
858     case SIGTERM:
859       if (!shutdown_pending)
860         log_info ("SIGTERM received - shutting down ...\n");
861       else
862         log_info ("SIGTERM received - still %ld running threads\n",
863                   pth_ctrl( PTH_CTRL_GETTHREADS ));
864       shutdown_pending++;
865       if (shutdown_pending > 2)
866         {
867           log_info ("shutdown forced\n");
868           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
869           cleanup ();
870           scd_exit (0);
871         }
872       break;
873         
874     case SIGINT:
875       log_info ("SIGINT received - immediate shutdown\n");
876       log_info( "%s %s stopped\n", strusage(11), strusage(13));
877       cleanup ();
878       scd_exit (0);
879       break;
880 #endif /*!HAVE_W32_SYSTEM*/
881
882     default:
883       log_info ("signal %d received - no action defined\n", signo);
884     }
885 }
886
887
888 static void
889 handle_tick (void)
890 {
891   if (!ticker_disabled)
892     scd_update_reader_status_file ();
893 }
894
895
896 /* Create a name for the socket.  With USE_STANDARD_SOCKET given as
897    true using STANDARD_NAME in the home directory or if given has
898    false from the mkdir type name TEMPLATE.  In the latter case a
899    unique name in a unique new directory will be created.  In both
900    cases check for valid characters as well as against a maximum
901    allowed length for a unix domain socket is done.  The function
902    terminates the process in case of an error.  Retunrs: Pointer to an
903    allcoated string with the absolute name of the socket used.  */
904 static char *
905 create_socket_name (int use_standard_socket,
906                     char *standard_name, char *template)
907 {
908   char *name, *p;
909
910   if (use_standard_socket)
911     name = make_filename (opt.homedir, standard_name, NULL);
912   else
913     {
914       name = xstrdup (template);
915       p = strrchr (name, '/');
916       if (!p)
917         BUG ();
918       *p = 0;
919       if (!mkdtemp (name))
920         {
921           log_error (_("can't create directory `%s': %s\n"),
922                      name, strerror (errno));
923           scd_exit (2);
924         }
925       *p = '/';
926     }
927
928   if (strchr (name, PATHSEP_C))
929     {
930       log_error (("`%s' are not allowed in the socket name\n"), PATHSEP_S);
931       scd_exit (2);
932     }
933   if (strlen (name) + 1 >= DIMof (struct sockaddr_un, sun_path) )
934     {
935       log_error (_("name of socket too long\n"));
936       scd_exit (2);
937     }
938   return name;
939 }
940
941
942
943 /* Create a Unix domain socket with NAME.  IS_STANDARD_NAME indicates
944    whether a non-random socket is used.  Returns the file descriptor
945    or terminates the process in case of an error. */
946 static gnupg_fd_t
947 create_server_socket (int is_standard_name, const char *name,
948                       assuan_sock_nonce_t *nonce)
949 {
950   struct sockaddr_un *serv_addr;
951   socklen_t len;
952   gnupg_fd_t fd;
953   int rc;
954
955   fd = assuan_sock_new (AF_UNIX, SOCK_STREAM, 0);
956   if (fd == GNUPG_INVALID_FD)
957     {
958       log_error (_("can't create socket: %s\n"), strerror (errno));
959       scd_exit (2);
960     }
961
962   serv_addr = xmalloc (sizeof (*serv_addr)); 
963   memset (serv_addr, 0, sizeof *serv_addr);
964   serv_addr->sun_family = AF_UNIX;
965   assert (strlen (name) + 1 < sizeof (serv_addr->sun_path));
966   strcpy (serv_addr->sun_path, name);
967   len = (offsetof (struct sockaddr_un, sun_path)
968          + strlen (serv_addr->sun_path) + 1);
969
970   rc = assuan_sock_bind (fd, (struct sockaddr*) serv_addr, len);
971   if (is_standard_name && rc == -1 && errno == EADDRINUSE)
972     {
973       remove (name);
974       rc = assuan_sock_bind (fd, (struct sockaddr*) serv_addr, len);
975     }
976   if (rc != -1 
977       && (rc=assuan_sock_get_nonce ((struct sockaddr*)serv_addr, len, nonce)))
978     log_error (_("error getting nonce for the socket\n"));
979  if (rc == -1)
980     {
981       log_error (_("error binding socket to `%s': %s\n"),
982                  serv_addr->sun_path,
983                  gpg_strerror (gpg_error_from_syserror ()));
984       assuan_sock_close (fd);
985       scd_exit (2);
986     }
987
988   if (listen (FD2INT(fd), 5 ) == -1)
989     {
990       log_error (_("listen() failed: %s\n"),
991                  gpg_strerror (gpg_error_from_syserror ()));
992       assuan_sock_close (fd);
993       scd_exit (2);
994     }
995           
996   if (opt.verbose)
997     log_info (_("listening on socket `%s'\n"), serv_addr->sun_path);
998
999   return fd;
1000 }
1001
1002
1003
1004 /* This is the standard connection thread's main function.  */
1005 static void *
1006 start_connection_thread (void *arg)
1007 {
1008   ctrl_t ctrl = arg;
1009
1010   if (ctrl->thread_startup.fd != GNUPG_INVALID_FD
1011       && assuan_sock_check_nonce (ctrl->thread_startup.fd, &socket_nonce))
1012     {
1013       log_info (_("error reading nonce on fd %d: %s\n"), 
1014                 FD2INT(ctrl->thread_startup.fd), strerror (errno));
1015       assuan_sock_close (ctrl->thread_startup.fd);
1016       xfree (ctrl);
1017       return NULL;
1018     }
1019
1020   scd_init_default_ctrl (ctrl);
1021   if (opt.verbose)
1022     log_info (_("handler for fd %d started\n"),
1023               FD2INT(ctrl->thread_startup.fd));
1024
1025   scd_command_handler (ctrl, FD2INT(ctrl->thread_startup.fd));
1026
1027   if (opt.verbose)
1028     log_info (_("handler for fd %d terminated\n"),
1029               FD2INT (ctrl->thread_startup.fd));
1030
1031   /* If this thread is the pipe connection thread, flag that a
1032      shutdown is required.  With the next ticker event and given that
1033      no other connections are running the shutdown will then
1034      happen. */
1035   if (ctrl->thread_startup.fd == GNUPG_INVALID_FD)
1036     shutdown_pending = 1;
1037   
1038   scd_deinit_default_ctrl (ctrl);
1039   xfree (ctrl);
1040   return NULL;
1041 }
1042
1043
1044 /* Connection handler loop.  Wait for connection requests and spawn a
1045    thread after accepting a connection.  LISTEN_FD is allowed to be -1
1046    in which case this code will only do regular timeouts and handle
1047    signals. */
1048 static void
1049 handle_connections (int listen_fd)
1050 {
1051   pth_attr_t tattr;
1052   pth_event_t ev, time_ev;
1053   sigset_t sigs;
1054   int signo;
1055   struct sockaddr_un paddr;
1056   socklen_t plen;
1057   fd_set fdset, read_fdset;
1058   int ret;
1059   int fd;
1060   int nfd;
1061
1062   tattr = pth_attr_new();
1063   pth_attr_set (tattr, PTH_ATTR_JOINABLE, 0);
1064   pth_attr_set (tattr, PTH_ATTR_STACK_SIZE, 512*1024);
1065
1066 #ifndef HAVE_W32_SYSTEM /* fixme */
1067   sigemptyset (&sigs );
1068   sigaddset (&sigs, SIGHUP);
1069   sigaddset (&sigs, SIGUSR1);
1070   sigaddset (&sigs, SIGUSR2);
1071   sigaddset (&sigs, SIGINT);
1072   sigaddset (&sigs, SIGTERM);
1073   pth_sigmask (SIG_UNBLOCK, &sigs, NULL);
1074   ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
1075 #else
1076   sigs = 0;
1077   ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
1078 #endif
1079   time_ev = NULL;
1080
1081   FD_ZERO (&fdset);
1082   nfd = 0;
1083   if (listen_fd != -1)
1084     {
1085       FD_SET (listen_fd, &fdset);
1086       nfd = listen_fd;
1087     }
1088
1089   for (;;)
1090     {
1091       sigset_t oldsigs;
1092       
1093       if (shutdown_pending)
1094         {
1095           if (pth_ctrl (PTH_CTRL_GETTHREADS) == 1)
1096             break; /* ready */
1097
1098           /* Do not accept anymore connections but wait for existing
1099              connections to terminate. We do this by clearing out all
1100              file descriptors to wait for, so that the select will be
1101              used to just wait on a signal or timeout event. */
1102           FD_ZERO (&fdset);
1103         }
1104
1105       /* Create a timeout event if needed. */
1106       if (!time_ev)
1107         time_ev = pth_event (PTH_EVENT_TIME,
1108                              pth_timeout (TIMERTICK_INTERVAL, 0));
1109
1110       /* POSIX says that fd_set should be implemented as a structure,
1111          thus a simple assignment is fine to copy the entire set.  */
1112       read_fdset = fdset;
1113
1114       if (time_ev)
1115         pth_event_concat (ev, time_ev, NULL);
1116       ret = pth_select_ev (nfd+1, &read_fdset, NULL, NULL, NULL, ev);
1117       if (time_ev)
1118         pth_event_isolate (time_ev);
1119
1120       if (ret == -1)
1121         {
1122           if (pth_event_occurred (ev)
1123               || (time_ev && pth_event_occurred (time_ev)))
1124             {
1125               if (pth_event_occurred (ev))
1126                 handle_signal (signo);
1127               if (time_ev && pth_event_occurred (time_ev))
1128                 {
1129                   pth_event_free (time_ev, PTH_FREE_ALL);
1130                   time_ev = NULL;
1131                   handle_tick ();
1132                 }
1133               continue;
1134             }
1135           log_error (_("pth_select failed: %s - waiting 1s\n"),
1136                      strerror (errno));
1137           pth_sleep (1);
1138           continue;
1139         }
1140
1141       if (pth_event_occurred (ev))
1142         {
1143           handle_signal (signo);
1144         }
1145
1146       if (time_ev && pth_event_occurred (time_ev))
1147         {
1148           pth_event_free (time_ev, PTH_FREE_ALL);
1149           time_ev = NULL;
1150           handle_tick ();
1151         }
1152
1153       /* We now might create new threads and because we don't want any
1154          signals - we are handling here - to be delivered to a new
1155          thread. Thus we need to block those signals. */
1156       pth_sigmask (SIG_BLOCK, &sigs, &oldsigs);
1157
1158       if (listen_fd != -1 && FD_ISSET (listen_fd, &read_fdset))
1159         {
1160           ctrl_t ctrl;
1161
1162           plen = sizeof paddr;
1163           fd = pth_accept (listen_fd, (struct sockaddr *)&paddr, &plen);
1164           if (fd == -1)
1165             {
1166               log_error ("accept failed: %s\n", strerror (errno));
1167             }
1168           else if ( !(ctrl = xtrycalloc (1, sizeof *ctrl)) )
1169             {
1170               log_error ("error allocating connection control data: %s\n",
1171                          strerror (errno) );
1172               close (fd);
1173             }
1174           else
1175             {
1176               char threadname[50];
1177
1178               snprintf (threadname, sizeof threadname-1, "conn fd=%d", fd);
1179               threadname[sizeof threadname -1] = 0;
1180               pth_attr_set (tattr, PTH_ATTR_NAME, threadname);
1181               ctrl->thread_startup.fd = INT2FD (fd);
1182               if (!pth_spawn (tattr, start_connection_thread, ctrl))
1183                 {
1184                   log_error ("error spawning connection handler: %s\n",
1185                              strerror (errno) );
1186                   xfree (ctrl);
1187                   close (fd);
1188                 }
1189             }
1190           fd = -1;
1191         }
1192
1193       /* Restore the signal mask. */
1194       pth_sigmask (SIG_SETMASK, &oldsigs, NULL);
1195
1196     }
1197
1198   pth_event_free (ev, PTH_FREE_ALL);
1199   if (time_ev)
1200     pth_event_free (time_ev, PTH_FREE_ALL);
1201   cleanup ();
1202   log_info (_("%s %s stopped\n"), strusage(11), strusage(13));
1203 }
1204
1205