dirmngr: Do a DNS lookup even if it is missing from nsswitch.conf.
[gnupg.git] / scd / scdaemon.c
1 /* scdaemon.c  -  The GnuPG Smartcard Daemon
2  * Copyright (C) 2001-2002, 2004-2005, 2007-2009 Free Software Foundation, Inc.
3  * Copyright (C) 2001-2002, 2004-2005, 2007-2014 Werner Koch
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <https://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <stddef.h>
26 #include <stdarg.h>
27 #include <string.h>
28 #include <errno.h>
29 #include <assert.h>
30 #include <time.h>
31 #include <fcntl.h>
32 #ifndef HAVE_W32_SYSTEM
33 #include <sys/socket.h>
34 #include <sys/un.h>
35 #endif /*HAVE_W32_SYSTEM*/
36 #include <unistd.h>
37 #include <signal.h>
38 #include <npth.h>
39
40 #define GNUPG_COMMON_NEED_AFLOCAL
41 #include "scdaemon.h"
42 #include <ksba.h>
43 #include <gcrypt.h>
44
45 #include <assuan.h> /* malloc hooks */
46
47 #include "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 "exechelp.h"
56 #include "../common/init.h"
57
58 #ifndef ENAMETOOLONG
59 # define ENAMETOOLONG EINVAL
60 #endif
61
62 enum cmd_and_opt_values
63 { aNull = 0,
64   oCsh            = 'c',
65   oQuiet          = 'q',
66   oSh             = 's',
67   oVerbose        = 'v',
68
69   oNoVerbose = 500,
70   aGPGConfList,
71   aGPGConfTest,
72   oOptions,
73   oDebug,
74   oDebugAll,
75   oDebugLevel,
76   oDebugWait,
77   oDebugAllowCoreDump,
78   oDebugCCIDDriver,
79   oDebugLogTid,
80   oDebugAssuanLogCats,
81   oNoGreeting,
82   oNoOptions,
83   oHomedir,
84   oNoDetach,
85   oNoGrab,
86   oLogFile,
87   oServer,
88   oMultiServer,
89   oDaemon,
90   oBatch,
91   oReaderPort,
92   oCardTimeout,
93   octapiDriver,
94   opcscDriver,
95   oDisableCCID,
96   oDisableOpenSC,
97   oDisablePinpad,
98   oAllowAdmin,
99   oDenyAdmin,
100   oDisableApplication,
101   oEnablePinpadVarlen,
102 };
103
104
105
106 static ARGPARSE_OPTS opts[] = {
107   ARGPARSE_c (aGPGConfList, "gpgconf-list", "@"),
108   ARGPARSE_c (aGPGConfTest, "gpgconf-test", "@"),
109
110   ARGPARSE_group (301, N_("@Options:\n ")),
111
112   ARGPARSE_s_n (oServer,"server", N_("run in server mode (foreground)")),
113   ARGPARSE_s_n (oMultiServer, "multi-server",
114                 N_("run in multi server mode (foreground)")),
115   ARGPARSE_s_n (oDaemon, "daemon", N_("run in daemon mode (background)")),
116   ARGPARSE_s_n (oVerbose, "verbose", N_("verbose")),
117   ARGPARSE_s_n (oQuiet, "quiet", N_("be somewhat more quiet")),
118   ARGPARSE_s_n (oSh,    "sh", N_("sh-style command output")),
119   ARGPARSE_s_n (oCsh,   "csh", N_("csh-style command output")),
120   ARGPARSE_s_s (oOptions, "options", N_("|FILE|read options from FILE")),
121   ARGPARSE_s_s (oDebug, "debug", "@"),
122   ARGPARSE_s_n (oDebugAll, "debug-all", "@"),
123   ARGPARSE_s_s (oDebugLevel, "debug-level" ,
124                 N_("|LEVEL|set the debugging level to LEVEL")),
125   ARGPARSE_s_i (oDebugWait, "debug-wait", "@"),
126   ARGPARSE_s_n (oDebugAllowCoreDump, "debug-allow-core-dump", "@"),
127   ARGPARSE_s_n (oDebugCCIDDriver, "debug-ccid-driver", "@"),
128   ARGPARSE_s_n (oDebugLogTid, "debug-log-tid", "@"),
129   ARGPARSE_p_u (oDebugAssuanLogCats, "debug-assuan-log-cats", "@"),
130   ARGPARSE_s_n (oNoDetach, "no-detach", N_("do not detach from the console")),
131   ARGPARSE_s_s (oLogFile,  "log-file", N_("|FILE|write a log to FILE")),
132   ARGPARSE_s_s (oReaderPort, "reader-port",
133                 N_("|N|connect to reader at port N")),
134   ARGPARSE_s_s (octapiDriver, "ctapi-driver",
135                 N_("|NAME|use NAME as ct-API driver")),
136   ARGPARSE_s_s (opcscDriver, "pcsc-driver",
137                 N_("|NAME|use NAME as PC/SC driver")),
138   ARGPARSE_s_n (oDisableCCID, "disable-ccid",
139 #ifdef HAVE_LIBUSB
140                                     N_("do not use the internal CCID driver")
141 #else
142                                     "@"
143 #endif
144                 /* end --disable-ccid */),
145   ARGPARSE_s_u (oCardTimeout, "card-timeout",
146                 N_("|N|disconnect the card after N seconds of inactivity")),
147
148   ARGPARSE_s_n (oDisablePinpad, "disable-pinpad",
149                 N_("do not use a reader's pinpad")),
150   ARGPARSE_ignore (300, "disable-keypad"),
151
152   ARGPARSE_s_n (oAllowAdmin, "allow-admin", "@"),
153   ARGPARSE_s_n (oDenyAdmin, "deny-admin",
154                 N_("deny the use of admin card commands")),
155   ARGPARSE_s_s (oDisableApplication, "disable-application", "@"),
156   ARGPARSE_s_n (oEnablePinpadVarlen, "enable-pinpad-varlen",
157                 N_("use variable length input for pinpad")),
158   ARGPARSE_s_s (oHomedir,    "homedir",      "@"),
159
160   ARGPARSE_end ()
161 };
162
163
164 /* The list of supported debug flags.  */
165 static struct debug_flags_s debug_flags [] =
166   {
167     { DBG_MPI_VALUE    , "mpi"     },
168     { DBG_CRYPTO_VALUE , "crypto"  },
169     { DBG_MEMORY_VALUE , "memory"  },
170     { DBG_CACHE_VALUE  , "cache"   },
171     { DBG_MEMSTAT_VALUE, "memstat" },
172     { DBG_HASHING_VALUE, "hashing" },
173     { DBG_IPC_VALUE    , "ipc"     },
174     { DBG_CARD_IO_VALUE, "cardio"  },
175     { DBG_READER_VALUE , "reader"  },
176     { 0, NULL }
177   };
178
179
180 /* The card driver we use by default for PC/SC.  */
181 #if defined(HAVE_W32_SYSTEM) || defined(__CYGWIN__)
182 #define DEFAULT_PCSC_DRIVER "winscard.dll"
183 #elif defined(__APPLE__)
184 #define DEFAULT_PCSC_DRIVER "/System/Library/Frameworks/PCSC.framework/PCSC"
185 #elif defined(__GLIBC__)
186 #define DEFAULT_PCSC_DRIVER "libpcsclite.so.1"
187 #else
188 #define DEFAULT_PCSC_DRIVER "libpcsclite.so"
189 #endif
190
191 /* The timer tick used to check card removal.
192
193    We poll every 500ms to let the user immediately know a status
194    change.
195
196    For a card reader with an interrupt endpoint, this timer is not
197    used with the internal CCID driver.
198
199    This is not too good for power saving but given that there is no
200    easy way to block on card status changes it is the best we can do.
201    For PC/SC we could in theory use an extra thread to wait for status
202    changes but that requires a native thread because there is no way
203    to make the underlying PC/SC card change function block using a Npth
204    mechanism.  Given that a native thread could only be used under W32
205    we don't do that at all.  */
206 #define TIMERTICK_INTERVAL_SEC     (0)
207 #define TIMERTICK_INTERVAL_USEC    (500000)
208
209 /* Flag to indicate that a shutdown was requested. */
210 static int shutdown_pending;
211
212 /* It is possible that we are currently running under setuid permissions */
213 static int maybe_setuid = 1;
214
215 /* Flag telling whether we are running as a pipe server.  */
216 static int pipe_server;
217
218 /* Name of the communication socket */
219 static char *socket_name;
220 /* Name of the redirected socket or NULL.  */
221 static char *redir_socket_name;
222
223 /* We need to keep track of the server's nonces (these are dummies for
224    POSIX systems). */
225 static assuan_sock_nonce_t socket_nonce;
226
227 /* FD to notify update of usb devices.  */
228 static int notify_fd;
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;
332   else if (!strcmp (level, "expert") || (numok && numlvl <= 8))
333     opt.debug = (DBG_IPC_VALUE|DBG_CACHE_VALUE|DBG_CARD_IO_VALUE);
334   else if (!strcmp (level, "guru") || numok)
335     {
336       opt.debug = ~0;
337       /* Unless the "guru" string has been used we don't want to allow
338          hashing debugging.  The rationale is that people tend to
339          select the highest debug value and would then clutter their
340          disk with debug files which may reveal confidential data.  */
341       if (numok)
342         opt.debug &= ~(DBG_HASHING_VALUE);
343     }
344   else
345     {
346       log_error (_("invalid debug-level '%s' given\n"), level);
347       scd_exit(2);
348     }
349
350
351   if (opt.debug && !opt.verbose)
352     opt.verbose = 1;
353   if (opt.debug && opt.quiet)
354     opt.quiet = 0;
355
356   if (opt.debug & DBG_MPI_VALUE)
357     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 2);
358   if (opt.debug & DBG_CRYPTO_VALUE )
359     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1);
360   gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
361
362   if (opt.debug)
363     parse_debug_flag (NULL, &opt.debug, debug_flags);
364 }
365
366
367
368 static void
369 cleanup (void)
370 {
371   if (socket_name && *socket_name)
372     {
373       char *name;
374
375       name = redir_socket_name? redir_socket_name : socket_name;
376
377       gnupg_remove (name);
378       *socket_name = 0;
379     }
380 }
381
382
383
384 int
385 main (int argc, char **argv )
386 {
387   ARGPARSE_ARGS pargs;
388   int orig_argc;
389   char **orig_argv;
390   FILE *configfp = NULL;
391   char *configname = NULL;
392   const char *shell;
393   unsigned int configlineno;
394   int parse_debug = 0;
395   const char *debug_level = NULL;
396   int default_config =1;
397   int greeting = 0;
398   int nogreeting = 0;
399   int multi_server = 0;
400   int is_daemon = 0;
401   int nodetach = 0;
402   int csh_style = 0;
403   char *logfile = NULL;
404   int debug_wait = 0;
405   int gpgconf_list = 0;
406   const char *config_filename = NULL;
407   int allow_coredump = 0;
408   struct assuan_malloc_hooks malloc_hooks;
409   int res;
410   npth_t pipecon_handler;
411
412   early_system_init ();
413   set_strusage (my_strusage);
414   gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
415   /* Please note that we may running SUID(ROOT), so be very CAREFUL
416      when adding any stuff between here and the call to INIT_SECMEM()
417      somewhere after the option parsing */
418   log_set_prefix ("scdaemon", GPGRT_LOG_WITH_PREFIX | GPGRT_LOG_WITH_PID);
419
420   /* Make sure that our subsystems are ready.  */
421   i18n_init ();
422   init_common_subsystems (&argc, &argv);
423
424   ksba_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
425
426   malloc_hooks.malloc = gcry_malloc;
427   malloc_hooks.realloc = gcry_realloc;
428   malloc_hooks.free = gcry_free;
429   assuan_set_malloc_hooks (&malloc_hooks);
430   assuan_set_gpg_err_source (GPG_ERR_SOURCE_DEFAULT);
431   assuan_set_system_hooks (ASSUAN_SYSTEM_NPTH);
432   assuan_sock_init ();
433   setup_libassuan_logging (&opt.debug, NULL);
434
435   setup_libgcrypt_logging ();
436   gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
437
438   disable_core_dumps ();
439
440   /* Set default options. */
441   opt.allow_admin = 1;
442   opt.pcsc_driver = DEFAULT_PCSC_DRIVER;
443
444   shell = getenv ("SHELL");
445   if (shell && strlen (shell) >= 3 && !strcmp (shell+strlen (shell)-3, "csh") )
446     csh_style = 1;
447
448   /* Check whether we have a config file on the commandline */
449   orig_argc = argc;
450   orig_argv = argv;
451   pargs.argc = &argc;
452   pargs.argv = &argv;
453   pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
454   while (arg_parse( &pargs, opts))
455     {
456       if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll)
457         parse_debug++;
458       else if (pargs.r_opt == oOptions)
459         { /* yes there is one, so we do not try the default one, but
460              read the option file when it is encountered at the
461              commandline */
462           default_config = 0;
463         }
464         else if (pargs.r_opt == oNoOptions)
465           default_config = 0; /* --no-options */
466         else if (pargs.r_opt == oHomedir)
467           gnupg_set_homedir (pargs.r.ret_str);
468     }
469
470   /* initialize the secure memory. */
471   gcry_control (GCRYCTL_INIT_SECMEM, 16384, 0);
472   maybe_setuid = 0;
473
474   /*
475      Now we are working under our real uid
476   */
477
478
479   if (default_config)
480     configname = make_filename (gnupg_homedir (), SCDAEMON_NAME EXTSEP_S "conf",
481                                 NULL );
482
483
484   argc = orig_argc;
485   argv = orig_argv;
486   pargs.argc = &argc;
487   pargs.argv = &argv;
488   pargs.flags=  1;  /* do not remove the args */
489  next_pass:
490   if (configname)
491     {
492       configlineno = 0;
493       configfp = fopen (configname, "r");
494       if (!configfp)
495         {
496           if (default_config)
497             {
498               if( parse_debug )
499                 log_info (_("Note: no default option file '%s'\n"),
500                           configname );
501             }
502           else
503             {
504               log_error (_("option file '%s': %s\n"),
505                          configname, strerror(errno) );
506               exit(2);
507             }
508           xfree (configname);
509           configname = NULL;
510         }
511       if (parse_debug && configname )
512         log_info (_("reading options from '%s'\n"), configname );
513       default_config = 0;
514     }
515
516   while (optfile_parse( configfp, configname, &configlineno, &pargs, opts) )
517     {
518       switch (pargs.r_opt)
519         {
520         case aGPGConfList: gpgconf_list = 1; break;
521         case aGPGConfTest: gpgconf_list = 2; break;
522         case oQuiet: opt.quiet = 1; break;
523         case oVerbose: opt.verbose++; break;
524         case oBatch: opt.batch=1; break;
525
526         case oDebug:
527           if (parse_debug_flag (pargs.r.ret_str, &opt.debug, debug_flags))
528             {
529               pargs.r_opt = ARGPARSE_INVALID_ARG;
530               pargs.err = ARGPARSE_PRINT_ERROR;
531             }
532           break;
533         case oDebugAll: opt.debug = ~0; break;
534         case oDebugLevel: debug_level = pargs.r.ret_str; break;
535         case oDebugWait: debug_wait = pargs.r.ret_int; break;
536         case oDebugAllowCoreDump:
537           enable_core_dumps ();
538           allow_coredump = 1;
539           break;
540         case oDebugCCIDDriver:
541 #ifdef HAVE_LIBUSB
542           ccid_set_debug_level (ccid_set_debug_level (-1)+1);
543 #endif /*HAVE_LIBUSB*/
544           break;
545         case oDebugLogTid:
546           log_set_pid_suffix_cb (tid_log_callback);
547           break;
548         case oDebugAssuanLogCats:
549           set_libassuan_log_cats (pargs.r.ret_ulong);
550           break;
551
552         case oOptions:
553           /* config files may not be nested (silently ignore them) */
554           if (!configfp)
555             {
556                 xfree(configname);
557                 configname = xstrdup(pargs.r.ret_str);
558                 goto next_pass;
559             }
560           break;
561         case oNoGreeting: nogreeting = 1; break;
562         case oNoVerbose: opt.verbose = 0; break;
563         case oNoOptions: break; /* no-options */
564         case oHomedir: gnupg_set_homedir (pargs.r.ret_str); break;
565         case oNoDetach: nodetach = 1; break;
566         case oLogFile: logfile = pargs.r.ret_str; break;
567         case oCsh: csh_style = 1; break;
568         case oSh: csh_style = 0; break;
569         case oServer: pipe_server = 1; break;
570         case oMultiServer: pipe_server = 1; multi_server = 1; break;
571         case oDaemon: is_daemon = 1; break;
572
573         case oReaderPort: opt.reader_port = pargs.r.ret_str; break;
574         case octapiDriver: opt.ctapi_driver = pargs.r.ret_str; break;
575         case opcscDriver: opt.pcsc_driver = pargs.r.ret_str; break;
576         case oDisableCCID: opt.disable_ccid = 1; break;
577         case oDisableOpenSC: break;
578
579         case oDisablePinpad: opt.disable_pinpad = 1; break;
580
581         case oAllowAdmin: /* Dummy because allow is now the default.  */
582           break;
583         case oDenyAdmin: opt.allow_admin = 0; break;
584
585         case oCardTimeout: opt.card_timeout = pargs.r.ret_ulong; break;
586
587         case oDisableApplication:
588           add_to_strlist (&opt.disabled_applications, pargs.r.ret_str);
589           break;
590
591         case oEnablePinpadVarlen: opt.enable_pinpad_varlen = 1; break;
592
593         default:
594           pargs.err = configfp? ARGPARSE_PRINT_WARNING:ARGPARSE_PRINT_ERROR;
595           break;
596         }
597     }
598   if (configfp)
599     {
600       fclose( configfp );
601       configfp = NULL;
602       /* Keep a copy of the config name for use by --gpgconf-list. */
603       config_filename = configname;
604       configname = NULL;
605       goto next_pass;
606     }
607   xfree (configname);
608   configname = NULL;
609   if (log_get_errorcount(0))
610     exit(2);
611   if (nogreeting )
612     greeting = 0;
613
614   if (greeting)
615     {
616       es_fprintf (es_stderr, "%s %s; %s\n",
617                   strusage(11), strusage(13), strusage(14) );
618       es_fprintf (es_stderr, "%s\n", strusage(15) );
619     }
620 #ifdef IS_DEVELOPMENT_VERSION
621   log_info ("NOTE: this is a development version!\n");
622 #endif
623
624   /* Print a warning if an argument looks like an option.  */
625   if (!opt.quiet && !(pargs.flags & ARGPARSE_FLAG_STOP_SEEN))
626     {
627       int i;
628
629       for (i=0; i < argc; i++)
630         if (argv[i][0] == '-' && argv[i][1] == '-')
631           log_info (_("Note: '%s' is not considered an option\n"), argv[i]);
632     }
633
634   if (atexit (cleanup))
635     {
636       log_error ("atexit failed\n");
637       cleanup ();
638       exit (1);
639     }
640
641   set_debug (debug_level);
642
643   if (initialize_module_command ())
644     {
645       log_error ("initialization failed\n");
646       cleanup ();
647       exit (1);
648     }
649
650   if (gpgconf_list == 2)
651     scd_exit (0);
652   if (gpgconf_list)
653     {
654       /* List options and default values in the GPG Conf format.  */
655       char *filename = NULL;
656       char *filename_esc;
657
658       if (config_filename)
659         filename = xstrdup (config_filename);
660       else
661         filename = make_filename (gnupg_homedir (),
662                                   SCDAEMON_NAME EXTSEP_S "conf", NULL);
663       filename_esc = percent_escape (filename, NULL);
664
665       es_printf ("%s-%s.conf:%lu:\"%s\n",
666                  GPGCONF_NAME, SCDAEMON_NAME,
667                  GC_OPT_FLAG_DEFAULT, filename_esc);
668       xfree (filename_esc);
669       xfree (filename);
670
671       es_printf ("verbose:%lu:\n"
672                  "quiet:%lu:\n"
673                  "debug-level:%lu:\"none:\n"
674                  "log-file:%lu:\n",
675                  GC_OPT_FLAG_NONE,
676                  GC_OPT_FLAG_NONE,
677                  GC_OPT_FLAG_DEFAULT,
678                  GC_OPT_FLAG_NONE );
679
680       es_printf ("reader-port:%lu:\n", GC_OPT_FLAG_NONE );
681       es_printf ("ctapi-driver:%lu:\n", GC_OPT_FLAG_NONE );
682       es_printf ("pcsc-driver:%lu:\"%s:\n",
683               GC_OPT_FLAG_DEFAULT, DEFAULT_PCSC_DRIVER );
684 #ifdef HAVE_LIBUSB
685       es_printf ("disable-ccid:%lu:\n", GC_OPT_FLAG_NONE );
686 #endif
687       es_printf ("deny-admin:%lu:\n", GC_OPT_FLAG_NONE );
688       es_printf ("disable-pinpad:%lu:\n", GC_OPT_FLAG_NONE );
689       es_printf ("card-timeout:%lu:%d:\n", GC_OPT_FLAG_DEFAULT, 0);
690       es_printf ("enable-pinpad-varlen:%lu:\n", GC_OPT_FLAG_NONE );
691
692       scd_exit (0);
693     }
694
695   /* Now start with logging to a file if this is desired.  */
696   if (logfile)
697     {
698       log_set_file (logfile);
699       log_set_prefix (NULL, GPGRT_LOG_WITH_PREFIX | GPGRT_LOG_WITH_TIME | GPGRT_LOG_WITH_PID);
700     }
701
702   if (debug_wait && pipe_server)
703     {
704       log_debug ("waiting for debugger - my pid is %u .....\n",
705                  (unsigned int)getpid());
706       gnupg_sleep (debug_wait);
707       log_debug ("... okay\n");
708     }
709
710   if (pipe_server)
711     {
712       /* This is the simple pipe based server */
713       ctrl_t ctrl;
714       npth_attr_t tattr;
715       int fd = -1;
716
717 #ifndef HAVE_W32_SYSTEM
718       {
719         struct sigaction sa;
720
721         sa.sa_handler = SIG_IGN;
722         sigemptyset (&sa.sa_mask);
723         sa.sa_flags = 0;
724         sigaction (SIGPIPE, &sa, NULL);
725       }
726 #endif
727
728       npth_init ();
729       gpgrt_set_syscall_clamp (npth_unprotect, npth_protect);
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       npth_init ();
869       gpgrt_set_syscall_clamp (npth_unprotect, npth_protect);
870
871       /* Detach from tty and put process into a new session. */
872       if (!nodetach )
873         {
874           /* Close stdin, stdout and stderr unless it is the log stream. */
875           for (i=0; i <= 2; i++)
876             {
877               if (!log_test_fd (i) && i != fd )
878                 {
879                   if ( !close (i)
880                        && open ("/dev/null", i? O_WRONLY : O_RDONLY) == -1)
881                     {
882                       log_error ("failed to open '%s': %s\n",
883                                  "/dev/null", strerror (errno));
884                       cleanup ();
885                       exit (1);
886                     }
887                 }
888             }
889
890           if (setsid() == -1)
891             {
892               log_error ("setsid() failed: %s\n", strerror(errno) );
893               cleanup ();
894               exit (1);
895             }
896         }
897
898       {
899         struct sigaction sa;
900
901         sa.sa_handler = SIG_IGN;
902         sigemptyset (&sa.sa_mask);
903         sa.sa_flags = 0;
904         sigaction (SIGPIPE, &sa, NULL);
905       }
906
907       if (chdir("/"))
908         {
909           log_error ("chdir to / failed: %s\n", strerror (errno));
910           exit (1);
911         }
912
913 #endif /*!HAVE_W32_SYSTEM*/
914
915       handle_connections (fd);
916
917       close (fd);
918     }
919
920   return 0;
921 }
922
923 void
924 scd_exit (int rc)
925 {
926   apdu_prepare_exit ();
927 #if 0
928 #warning no update_random_seed_file
929   update_random_seed_file();
930 #endif
931 #if 0
932   /* at this time a bit annoying */
933   if (opt.debug & DBG_MEMSTAT_VALUE)
934     {
935       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
936       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
937     }
938   if (opt.debug)
939     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
940 #endif
941   gcry_control (GCRYCTL_TERM_SECMEM );
942   rc = rc? rc : log_get_errorcount(0)? 2 : 0;
943   exit (rc);
944 }
945
946
947 static void
948 scd_init_default_ctrl (ctrl_t ctrl)
949 {
950   (void)ctrl;
951 }
952
953 static void
954 scd_deinit_default_ctrl (ctrl_t ctrl)
955 {
956   if (!ctrl)
957     return;
958   xfree (ctrl->in_data.value);
959   ctrl->in_data.value = NULL;
960   ctrl->in_data.valuelen = 0;
961 }
962
963
964 /* Return the name of the socket to be used to connect to this
965    process.  If no socket is available, return NULL. */
966 const char *
967 scd_get_socket_name ()
968 {
969   if (socket_name && *socket_name)
970     return socket_name;
971   return NULL;
972 }
973
974
975 #ifndef HAVE_W32_SYSTEM
976 static void
977 handle_signal (int signo)
978 {
979   switch (signo)
980     {
981     case SIGHUP:
982       log_info ("SIGHUP received - "
983                 "re-reading configuration and resetting cards\n");
984 /*       reread_configuration (); */
985       break;
986
987     case SIGUSR1:
988       log_info ("SIGUSR1 received - printing internal information:\n");
989       /* Fixme: We need to see how to integrate pth dumping into our
990          logging system.  */
991       /* pth_ctrl (PTH_CTRL_DUMPSTATE, log_get_stream ()); */
992       app_dump_state ();
993       break;
994
995     case SIGUSR2:
996       log_info ("SIGUSR2 received - no action defined\n");
997       break;
998
999     case SIGTERM:
1000       if (!shutdown_pending)
1001         log_info ("SIGTERM received - shutting down ...\n");
1002       else
1003         log_info ("SIGTERM received - still %i running threads\n",
1004                   active_connections);
1005       shutdown_pending++;
1006       if (shutdown_pending > 2)
1007         {
1008           log_info ("shutdown forced\n");
1009           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
1010           cleanup ();
1011           scd_exit (0);
1012         }
1013       break;
1014
1015     case SIGINT:
1016       log_info ("SIGINT received - immediate shutdown\n");
1017       log_info( "%s %s stopped\n", strusage(11), strusage(13));
1018       cleanup ();
1019       scd_exit (0);
1020       break;
1021
1022     default:
1023       log_info ("signal %d received - no action defined\n", signo);
1024     }
1025 }
1026 #endif /*!HAVE_W32_SYSTEM*/
1027
1028
1029 /* Create a name for the socket.  We check for valid characters as
1030    well as against a maximum allowed length for a unix domain socket
1031    is done.  The function terminates the process in case of an error.
1032    Retunrs: Pointer to an allcoated string with the absolute name of
1033    the socket used.  */
1034 static char *
1035 create_socket_name (char *standard_name)
1036 {
1037   char *name;
1038
1039   name = make_filename (gnupg_socketdir (), standard_name, NULL);
1040   if (strchr (name, PATHSEP_C))
1041     {
1042       log_error (("'%s' are not allowed in the socket name\n"), PATHSEP_S);
1043       scd_exit (2);
1044     }
1045   return name;
1046 }
1047
1048
1049
1050 /* Create a Unix domain socket with NAME.  Returns the file descriptor
1051    or terminates the process in case of an error.  If the socket has
1052    been redirected the name of the real socket is stored as a malloced
1053    string at R_REDIR_NAME. */
1054 static gnupg_fd_t
1055 create_server_socket (const char *name, char **r_redir_name,
1056                       assuan_sock_nonce_t *nonce)
1057 {
1058   struct sockaddr *addr;
1059   struct sockaddr_un *unaddr;
1060   socklen_t len;
1061   gnupg_fd_t fd;
1062   int rc;
1063
1064   xfree (*r_redir_name);
1065   *r_redir_name = NULL;
1066
1067   fd = assuan_sock_new (AF_UNIX, SOCK_STREAM, 0);
1068   if (fd == GNUPG_INVALID_FD)
1069     {
1070       log_error (_("can't create socket: %s\n"), strerror (errno));
1071       scd_exit (2);
1072     }
1073
1074   unaddr = xmalloc (sizeof (*unaddr));
1075   addr = (struct sockaddr*)unaddr;
1076
1077   {
1078     int redirected;
1079
1080     if (assuan_sock_set_sockaddr_un (name, addr, &redirected))
1081       {
1082         if (errno == ENAMETOOLONG)
1083           log_error (_("socket name '%s' is too long\n"), name);
1084         else
1085           log_error ("error preparing socket '%s': %s\n",
1086                      name, gpg_strerror (gpg_error_from_syserror ()));
1087         scd_exit (2);
1088       }
1089     if (redirected)
1090       {
1091         *r_redir_name = xstrdup (unaddr->sun_path);
1092         if (opt.verbose)
1093           log_info ("redirecting socket '%s' to '%s'\n", name, *r_redir_name);
1094       }
1095   }
1096
1097   len = SUN_LEN (unaddr);
1098
1099   rc = assuan_sock_bind (fd, addr, len);
1100   if (rc == -1 && errno == EADDRINUSE)
1101     {
1102       gnupg_remove (unaddr->sun_path);
1103       rc = assuan_sock_bind (fd, addr, len);
1104     }
1105   if (rc != -1
1106       && (rc=assuan_sock_get_nonce (addr, len, nonce)))
1107     log_error (_("error getting nonce for the socket\n"));
1108  if (rc == -1)
1109     {
1110       log_error (_("error binding socket to '%s': %s\n"),
1111                  unaddr->sun_path,
1112                  gpg_strerror (gpg_error_from_syserror ()));
1113       assuan_sock_close (fd);
1114       scd_exit (2);
1115     }
1116
1117   if (gnupg_chmod (unaddr->sun_path, "-rwx"))
1118     log_error (_("can't set permissions of '%s': %s\n"),
1119                unaddr->sun_path, strerror (errno));
1120
1121   if (listen (FD2INT(fd), 5 ) == -1)
1122     {
1123       log_error (_("listen() failed: %s\n"),
1124                  gpg_strerror (gpg_error_from_syserror ()));
1125       assuan_sock_close (fd);
1126       scd_exit (2);
1127     }
1128
1129   if (opt.verbose)
1130     log_info (_("listening on socket '%s'\n"), unaddr->sun_path);
1131
1132   return fd;
1133 }
1134
1135
1136
1137 /* This is the standard connection thread's main function.  */
1138 static void *
1139 start_connection_thread (void *arg)
1140 {
1141   ctrl_t ctrl = arg;
1142
1143   if (ctrl->thread_startup.fd != GNUPG_INVALID_FD
1144       && assuan_sock_check_nonce (ctrl->thread_startup.fd, &socket_nonce))
1145     {
1146       log_info (_("error reading nonce on fd %d: %s\n"),
1147                 FD2INT(ctrl->thread_startup.fd), strerror (errno));
1148       assuan_sock_close (ctrl->thread_startup.fd);
1149       xfree (ctrl);
1150       return NULL;
1151     }
1152
1153   active_connections++;
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
1175   if (--active_connections == 0)
1176     scd_kick_the_loop ();
1177
1178   return NULL;
1179 }
1180
1181
1182 void
1183 scd_kick_the_loop (void)
1184 {
1185   /* Kick the select loop.  */
1186   write (notify_fd, "", 1);
1187 }
1188
1189 /* Connection handler loop.  Wait for connection requests and spawn a
1190    thread after accepting a connection.  LISTEN_FD is allowed to be -1
1191    in which case this code will only do regular timeouts and handle
1192    signals. */
1193 static void
1194 handle_connections (int listen_fd)
1195 {
1196   npth_attr_t tattr;
1197   struct sockaddr_un paddr;
1198   socklen_t plen;
1199   fd_set fdset, read_fdset;
1200   int nfd;
1201   int ret;
1202   int fd;
1203   struct timespec timeout;
1204   struct timespec *t;
1205   int saved_errno;
1206 #ifndef HAVE_W32_SYSTEM
1207   int signo;
1208 #endif
1209   int pipe_fd[2];
1210
1211   ret = gnupg_create_pipe (pipe_fd);
1212   if (ret)
1213     {
1214       log_error ("pipe creation failed: %s\n", gpg_strerror (ret));
1215       return;
1216     }
1217   notify_fd = pipe_fd[1];
1218
1219   ret = npth_attr_init(&tattr);
1220   if (ret)
1221     {
1222       log_error ("npth_attr_init failed: %s\n", strerror (ret));
1223       return;
1224     }
1225
1226   npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
1227
1228 #ifndef HAVE_W32_SYSTEM
1229   npth_sigev_init ();
1230   npth_sigev_add (SIGHUP);
1231   npth_sigev_add (SIGUSR1);
1232   npth_sigev_add (SIGUSR2);
1233   npth_sigev_add (SIGINT);
1234   npth_sigev_add (SIGTERM);
1235   npth_sigev_fini ();
1236 #endif
1237
1238   FD_ZERO (&fdset);
1239   nfd = 0;
1240   if (listen_fd != -1)
1241     {
1242       FD_SET (listen_fd, &fdset);
1243       nfd = listen_fd;
1244     }
1245
1246   FD_SET (pipe_fd[0], &fdset);
1247   if (nfd < pipe_fd[0])
1248     nfd = pipe_fd[0];
1249
1250   for (;;)
1251     {
1252       int periodical_check;
1253
1254       if (shutdown_pending)
1255         {
1256           if (active_connections == 0)
1257             break; /* ready */
1258
1259           /* Do not accept anymore connections but wait for existing
1260              connections to terminate. We do this by clearing out all
1261              file descriptors to wait for, so that the select will be
1262              used to just wait on a signal or timeout event. */
1263           FD_ZERO (&fdset);
1264           FD_SET (pipe_fd[0], &fdset);
1265           nfd = pipe_fd[0];
1266           listen_fd = -1;
1267         }
1268
1269       periodical_check = scd_update_reader_status_file ();
1270
1271       timeout.tv_sec = TIMERTICK_INTERVAL_SEC;
1272       timeout.tv_nsec = TIMERTICK_INTERVAL_USEC * 1000;
1273
1274       if (shutdown_pending || periodical_check)
1275         t = &timeout;
1276       else
1277         t = NULL;
1278
1279       /* POSIX says that fd_set should be implemented as a structure,
1280          thus a simple assignment is fine to copy the entire set.  */
1281       read_fdset = fdset;
1282
1283 #ifndef HAVE_W32_SYSTEM
1284       ret = npth_pselect (nfd+1, &read_fdset, NULL, NULL, t,
1285                           npth_sigev_sigmask ());
1286       saved_errno = errno;
1287
1288       while (npth_sigev_get_pending(&signo))
1289         handle_signal (signo);
1290 #else
1291       ret = npth_eselect (nfd+1, &read_fdset, NULL, NULL, t, NULL, NULL);
1292       saved_errno = errno;
1293 #endif
1294
1295       if (ret == -1 && saved_errno != EINTR)
1296         {
1297           log_error (_("npth_pselect failed: %s - waiting 1s\n"),
1298                      strerror (saved_errno));
1299           npth_sleep (1);
1300           continue;
1301         }
1302
1303       if (ret <= 0)
1304         /* Timeout.  Will be handled when calculating the next timeout.  */
1305         continue;
1306
1307       if (FD_ISSET (pipe_fd[0], &read_fdset))
1308         {
1309           char buf[256];
1310
1311           read (pipe_fd[0], buf, sizeof buf);
1312           ret--;
1313         }
1314
1315       if (listen_fd != -1 && FD_ISSET (listen_fd, &read_fdset))
1316         {
1317           ctrl_t ctrl;
1318
1319           plen = sizeof paddr;
1320           fd = npth_accept (listen_fd, (struct sockaddr *)&paddr, &plen);
1321           if (fd == -1)
1322             {
1323               log_error ("accept failed: %s\n", strerror (errno));
1324             }
1325           else if ( !(ctrl = xtrycalloc (1, sizeof *ctrl)) )
1326             {
1327               log_error ("error allocating connection control data: %s\n",
1328                          strerror (errno) );
1329               close (fd);
1330             }
1331           else
1332             {
1333               char threadname[50];
1334               npth_t thread;
1335
1336               snprintf (threadname, sizeof threadname, "conn fd=%d", fd);
1337               ctrl->thread_startup.fd = INT2FD (fd);
1338               ret = npth_create (&thread, &tattr, start_connection_thread, ctrl);
1339               if (ret)
1340                 {
1341                   log_error ("error spawning connection handler: %s\n",
1342                              strerror (ret));
1343                   xfree (ctrl);
1344                   close (fd);
1345                 }
1346               else
1347                 npth_setname_np (thread, threadname);
1348             }
1349         }
1350     }
1351
1352   close (pipe_fd[0]);
1353   close (pipe_fd[1]);
1354   cleanup ();
1355   log_info (_("%s %s stopped\n"), strusage(11), strusage(13));
1356   npth_attr_destroy (&tattr);
1357 }
1358
1359 /* Return the number of active connections. */
1360 int
1361 get_active_connection_count (void)
1362 {
1363   return active_connections;
1364 }