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