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