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