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