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