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