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