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