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