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