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