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