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