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