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