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