LCOV - code coverage report
Current view: top level - scd - scdaemon.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 0 523 0.0 %
Date: 2016-09-12 12:29:17 Functions: 0 23 0.0 %

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

Generated by: LCOV version 1.11