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