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