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