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