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