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