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