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