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