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