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