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