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