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