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