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