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