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