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