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