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