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