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