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