(show_key_with_all_names): Print the card S/N.
[gnupg.git] / scd / scdaemon.c
1 /* scdaemon.c  -  The GnuPG Smartcard Daemon
2  *      Copyright (C) 2001, 2002, 2004 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
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 #include <sys/socket.h>
33 #include <sys/un.h>
34 #include <unistd.h>
35 #include <signal.h>
36 #ifdef USE_GNU_PTH
37 # include <pth.h>
38 #endif
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
51
52 enum cmd_and_opt_values 
53 { aNull = 0,
54   oCsh            = 'c',
55   oQuiet          = 'q',
56   oSh             = 's',
57   oVerbose        = 'v',
58   
59   oNoVerbose = 500,
60   aGPGConfList,
61   oOptions,
62   oDebug,
63   oDebugAll,
64   oDebugLevel,
65   oDebugWait,
66   oDebugSC,
67   oNoGreeting,
68   oNoOptions,
69   oHomedir,
70   oNoDetach,
71   oNoGrab,
72   oLogFile,
73   oServer,
74   oDaemon,
75   oBatch,
76   oReaderPort,
77   octapiDriver,
78   opcscDriver,
79   oDisableCCID,
80   oDisableOpenSC,
81   oAllowAdmin,
82   oDenyAdmin,
83   oDisableApplication,
84
85 aTest };
86
87
88
89 static ARGPARSE_OPTS opts[] = {
90
91   { aGPGConfList, "gpgconf-list", 256, "@" },
92   
93   { 301, NULL, 0, N_("@Options:\n ") },
94
95   { oServer,   "server",     0, N_("run in server mode (foreground)") },
96   { oDaemon,   "daemon",     0, N_("run in daemon mode (background)") },
97   { oVerbose, "verbose",   0, N_("verbose") },
98   { oQuiet,     "quiet",     0, N_("be somewhat more quiet") },
99   { oSh,        "sh",        0, N_("sh-style command output") },
100   { oCsh,       "csh",       0, N_("csh-style command output") },
101   { oOptions, "options"  , 2, N_("read options from file")},
102   { oDebug,     "debug"     ,4|16, "@"},
103   { oDebugAll, "debug-all"     ,0, "@"},
104   { oDebugLevel, "debug-level" ,2, "@"},
105   { oDebugWait,"debug-wait",1, "@"},
106   { oDebugSC,  "debug-sc",  1, N_("|N|set OpenSC debug level to N")},
107   { oNoDetach, "no-detach" ,0, N_("do not detach from the console")},
108   { oLogFile,  "log-file"   ,2, N_("use a log file for the server")},
109   { oReaderPort, "reader-port", 2, N_("|N|connect to reader at port N")},
110   { octapiDriver, "ctapi-driver", 2, N_("|NAME|use NAME as ct-API driver")},
111   { opcscDriver, "pcsc-driver", 2, N_("|NAME|use NAME as PC/SC driver")},
112   { oDisableCCID, "disable-ccid", 0,
113 #ifdef HAVE_LIBUSB
114                                     N_("do not use the internal CCID driver")
115 #else
116                                     "@"
117 #endif
118                                          /* end --disable-ccid */},
119   { oDisableOpenSC, "disable-opensc", 0,
120 #ifdef HAVE_OPENSC
121                                     N_("do not use the OpenSC layer")
122 #else
123                                     "@"
124 #endif
125                                          /* end --disable-opensc */},
126   { oAllowAdmin, "allow-admin", 0, N_("allow the use of admin card commands")},
127   { oDenyAdmin,  "deny-admin",  0, "@" },  
128   { oDisableApplication, "disable-application", 2, "@"},
129
130   {0}
131 };
132
133
134 #define DEFAULT_PCSC_DRIVER "libpcsclite.so"
135
136
137 static volatile int caught_fatal_sig = 0;
138
139 /* Flag to indicate that a shutdown was requested. */
140 static int shutdown_pending;
141
142 /* It is possible that we are currently running under setuid permissions */
143 static int maybe_setuid = 1;
144
145 /* Name of the communication socket */
146 static char socket_name[128];
147
148
149 #ifndef HAVE_OPENSC
150 #ifdef USE_GNU_PTH
151 /* Pth wrapper function definitions. */
152 GCRY_THREAD_OPTION_PTH_IMPL;
153
154 static void *ticker_thread (void *arg);
155 #endif /*USE_GNU_PTH*/
156 #endif /*!HAVE_OPENSC*/
157
158 static const char *
159 my_strusage (int level)
160 {
161   const char *p;
162   switch (level)
163     {
164     case 11: p = "scdaemon (GnuPG)";
165       break;
166     case 13: p = VERSION; break;
167     case 17: p = PRINTABLE_OS_NAME; break;
168     case 19: p = _("Please report bugs to <" PACKAGE_BUGREPORT ">.\n");
169       break;
170     case 1:
171     case 40: p =  _("Usage: scdaemon [options] (-h for help)");
172       break;
173     case 41: p =  _("Syntax: scdaemon [options] [command [args]]\n"
174                     "Smartcard daemon for GnuPG\n");
175     break;
176     
177     default: p = NULL;
178     }
179   return p;
180 }
181
182
183
184 static void
185 i18n_init (void)
186 {
187 #ifdef USE_SIMPLE_GETTEXT
188     set_gettext_file( PACKAGE_GT );
189 #else
190 #ifdef ENABLE_NLS
191     setlocale (LC_ALL, "");
192     bindtextdomain (PACKAGE_GT, LOCALEDIR);
193     textdomain (PACKAGE_GT);
194 #endif
195 #endif
196 }
197
198
199
200 /* Used by gcry for logging */
201 static void
202 my_gcry_logger (void *dummy, int level, const char *fmt, va_list arg_ptr)
203 {
204   /* translate the log levels */
205   switch (level)
206     {
207     case GCRY_LOG_CONT: level = JNLIB_LOG_CONT; break;
208     case GCRY_LOG_INFO: level = JNLIB_LOG_INFO; break;
209     case GCRY_LOG_WARN: level = JNLIB_LOG_WARN; break;
210     case GCRY_LOG_ERROR:level = JNLIB_LOG_ERROR; break;
211     case GCRY_LOG_FATAL:level = JNLIB_LOG_FATAL; break;
212     case GCRY_LOG_BUG:  level = JNLIB_LOG_BUG; break;
213     case GCRY_LOG_DEBUG:level = JNLIB_LOG_DEBUG; break;
214     default:            level = JNLIB_LOG_ERROR; break;  
215     }
216   log_logv (level, fmt, arg_ptr);
217 }
218
219
220 /* Setup the debugging.  With a LEVEL of NULL only the active debug
221    flags are propagated to the subsystems.  With LEVEL set, a specific
222    set of debug flags is set; thus overriding all flags already
223    set. */
224 static void
225 set_debug (const char *level)
226 {
227   if (!level)
228     ;
229   else if (!strcmp (level, "none"))
230     opt.debug = 0;
231   else if (!strcmp (level, "basic"))
232     opt.debug = DBG_ASSUAN_VALUE;
233   else if (!strcmp (level, "advanced"))
234     opt.debug = DBG_ASSUAN_VALUE|DBG_COMMAND_VALUE;
235   else if (!strcmp (level, "expert"))
236     opt.debug = (DBG_ASSUAN_VALUE|DBG_COMMAND_VALUE
237                  |DBG_CACHE_VALUE|DBG_CARD_IO_VALUE);
238   else if (!strcmp (level, "guru"))
239     opt.debug = ~0;
240   else
241     {
242       log_error (_("invalid debug-level `%s' given\n"), level);
243       scd_exit(2);
244     }
245
246
247   if (opt.debug && !opt.verbose)
248     opt.verbose = 1;
249   if (opt.debug && opt.quiet)
250     opt.quiet = 0;
251
252   if (opt.debug & DBG_MPI_VALUE)
253     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 2);
254   if (opt.debug & DBG_CRYPTO_VALUE )
255     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1);
256   gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
257 }
258  
259
260
261 static void
262 cleanup (void)
263 {
264   if (*socket_name)
265     {
266       char *p;
267
268       remove (socket_name);
269       p = strrchr (socket_name, '/');
270       if (p)
271         {
272           *p = 0;
273           rmdir (socket_name);
274           *p = '/';
275         }
276       *socket_name = 0;
277     }
278 }
279
280
281 static RETSIGTYPE
282 cleanup_sh (int sig)
283 {
284   if (caught_fatal_sig)
285     raise (sig);
286   caught_fatal_sig = 1;
287
288   /* gcry_control( GCRYCTL_TERM_SECMEM );*/
289   cleanup ();
290
291 #ifndef HAVE_DOSISH_SYSTEM
292   {     /* reset action to default action and raise signal again */
293     struct sigaction nact;
294     nact.sa_handler = SIG_DFL;
295     sigemptyset( &nact.sa_mask );
296     nact.sa_flags = 0;
297     sigaction( sig, &nact, NULL);
298   }
299 #endif
300   raise( sig );
301 }
302
303 int
304 main (int argc, char **argv )
305 {
306   ARGPARSE_ARGS pargs;
307   int orig_argc;
308   gpg_error_t err;
309   int may_coredump;
310   char **orig_argv;
311   FILE *configfp = NULL;
312   char *configname = NULL;
313   const char *shell;
314   unsigned configlineno;
315   int parse_debug = 0;
316   const char *debug_level = NULL;
317   int default_config =1;
318   int greeting = 0;
319   int nogreeting = 0;
320   int pipe_server = 0;
321   int is_daemon = 0;
322   int nodetach = 0;
323   int csh_style = 0;
324   char *logfile = NULL;
325   int debug_wait = 0;
326   int gpgconf_list = 0;
327   const char *config_filename = NULL;
328
329   set_strusage (my_strusage);
330   gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
331   /* Please note that we may running SUID(ROOT), so be very CAREFUL
332      when adding any stuff between here and the call to INIT_SECMEM()
333      somewhere after the option parsing */
334   log_set_prefix ("scdaemon", 1|4); 
335   /* Try to auto set the character set.  */
336   set_native_charset (NULL); 
337
338   i18n_init ();
339
340   /* Libgcrypt requires us to register the threading model first.
341      Note that this will also do the pth_init. */
342 #ifndef HAVE_OPENSC
343 #ifdef USE_GNU_PTH
344   err = gcry_control (GCRYCTL_SET_THREAD_CBS, &gcry_threads_pth);
345   if (err)
346     {
347       log_fatal ("can't register GNU Pth with Libgcrypt: %s\n",
348                  gpg_strerror (err));
349     }
350 #endif /*USE_GNU_PTH*/
351 #endif /*!HAVE_OPENSC*/
352
353   /* Check that the libraries are suitable.  Do it here because
354      the option parsing may need services of the library */
355   if (!gcry_check_version (NEED_LIBGCRYPT_VERSION) )
356     {
357       log_fatal( _("libgcrypt is too old (need %s, have %s)\n"),
358                  NEED_LIBGCRYPT_VERSION, gcry_check_version (NULL) );
359     }
360
361   ksba_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
362
363   assuan_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
364   assuan_set_assuan_log_stream (log_get_stream ());
365   assuan_set_assuan_log_prefix (log_get_prefix (NULL));
366
367   gcry_set_log_handler (my_gcry_logger, NULL);
368   gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
369
370   may_coredump = disable_core_dumps ();
371
372   /* Set default options. */
373   opt.pcsc_driver = DEFAULT_PCSC_DRIVER; 
374
375
376   shell = getenv ("SHELL");
377   if (shell && strlen (shell) >= 3 && !strcmp (shell+strlen (shell)-3, "csh") )
378     csh_style = 1;
379   
380   /* FIXME: Using this homedir option does only make sense when not
381      running as a system service.  We might want to check for this by
382      looking at the uid or ebtter use an explict option for this */
383   opt.homedir = getenv("GNUPGHOME");
384   if (!opt.homedir || !*opt.homedir)
385     opt.homedir = GNUPG_DEFAULT_HOMEDIR;
386
387   /* check whether we have a config file on the commandline */
388   orig_argc = argc;
389   orig_argv = argv;
390   pargs.argc = &argc;
391   pargs.argv = &argv;
392   pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
393   while (arg_parse( &pargs, opts))
394     {
395       if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll)
396         parse_debug++;
397       else if (pargs.r_opt == oOptions)
398         { /* yes there is one, so we do not try the default one, but
399              read the option file when it is encountered at the
400              commandline */
401           default_config = 0;
402         }
403         else if (pargs.r_opt == oNoOptions)
404           default_config = 0; /* --no-options */
405         else if (pargs.r_opt == oHomedir)
406           opt.homedir = pargs.r.ret_str;
407     }
408
409   /* initialize the secure memory. */
410   gcry_control (GCRYCTL_INIT_SECMEM, 16384, 0);
411   maybe_setuid = 0;
412
413   /* 
414      Now we are working under our real uid 
415   */
416
417
418   if (default_config)
419     configname = make_filename (opt.homedir, "scdaemon.conf", NULL );
420
421   
422   argc = orig_argc;
423   argv = orig_argv;
424   pargs.argc = &argc;
425   pargs.argv = &argv;
426   pargs.flags=  1;  /* do not remove the args */
427  next_pass:
428   if (configname)
429     {
430       configlineno = 0;
431       configfp = fopen (configname, "r");
432       if (!configfp)
433         {
434           if (default_config)
435             {
436               if( parse_debug )
437                 log_info (_("NOTE: no default option file `%s'\n"),
438                           configname );
439             }
440           else
441             {
442               log_error (_("option file `%s': %s\n"),
443                          configname, strerror(errno) );
444               exit(2);
445             }
446           xfree (configname); 
447           configname = NULL;
448         }
449       if (parse_debug && configname )
450         log_info (_("reading options from `%s'\n"), configname );
451       default_config = 0;
452     }
453
454   while (optfile_parse( configfp, configname, &configlineno, &pargs, opts) )
455     {
456       switch (pargs.r_opt)
457         {
458         case aGPGConfList: gpgconf_list = 1; break;
459         case oQuiet: opt.quiet = 1; break;
460         case oVerbose: opt.verbose++; break;
461         case oBatch: opt.batch=1; break;
462
463         case oDebug: opt.debug |= pargs.r.ret_ulong; break;
464         case oDebugAll: opt.debug = ~0; break;
465         case oDebugLevel: debug_level = pargs.r.ret_str; break;
466         case oDebugWait: debug_wait = pargs.r.ret_int; break;
467         case oDebugSC: opt.debug_sc = pargs.r.ret_int; break;
468
469         case oOptions:
470           /* config files may not be nested (silently ignore them) */
471           if (!configfp)
472             {
473                 xfree(configname);
474                 configname = xstrdup(pargs.r.ret_str);
475                 goto next_pass;
476             }
477           break;
478         case oNoGreeting: nogreeting = 1; break;
479         case oNoVerbose: opt.verbose = 0; break;
480         case oNoOptions: break; /* no-options */
481         case oHomedir: opt.homedir = pargs.r.ret_str; break;
482         case oNoDetach: nodetach = 1; break;
483         case oLogFile: logfile = pargs.r.ret_str; break;
484         case oCsh: csh_style = 1; break;
485         case oSh: csh_style = 0; break;
486         case oServer: pipe_server = 1; break;
487         case oDaemon: is_daemon = 1; break;
488
489         case oReaderPort: opt.reader_port = pargs.r.ret_str; break;
490         case octapiDriver: opt.ctapi_driver = pargs.r.ret_str; break;
491         case opcscDriver: opt.pcsc_driver = pargs.r.ret_str; break;
492         case oDisableCCID: opt.disable_ccid = 1; break;
493         case oDisableOpenSC: opt.disable_opensc = 1; break;
494
495         case oAllowAdmin: opt.allow_admin = 1; break;
496         case oDenyAdmin: opt.allow_admin = 0; break;
497
498         case oDisableApplication:
499           add_to_strlist (&opt.disabled_applications, pargs.r.ret_str); 
500           break;
501
502         default : pargs.err = configfp? 1:2; break;
503         }
504     }
505   if (configfp)
506     {
507       fclose( configfp );
508       configfp = NULL;
509       /* Keep a copy of the config name for use by --gpgconf-list. */
510       config_filename = configname;
511       configname = NULL;
512       goto next_pass;
513     }
514   xfree (configname);
515   configname = NULL;
516   if (log_get_errorcount(0))
517     exit(2);
518   if (nogreeting )
519     greeting = 0;
520
521   if (greeting)
522     {
523       fprintf (stderr, "%s %s; %s\n",
524                  strusage(11), strusage(13), strusage(14) );
525       fprintf (stderr, "%s\n", strusage(15) );
526     }
527 #ifdef IS_DEVELOPMENT_VERSION
528   log_info ("NOTE: this is a development version!\n");
529 #endif
530
531  
532   if (atexit (cleanup))
533     {
534       log_error ("atexit failed\n");
535       cleanup ();
536       exit (1);
537     }
538
539   set_debug (debug_level);
540
541   if (debug_wait && pipe_server)
542     {
543       log_debug ("waiting for debugger - my pid is %u .....\n",
544                  (unsigned int)getpid());
545       sleep (debug_wait);
546       log_debug ("... okay\n");
547     }
548   
549   if (gpgconf_list)
550     {
551       /* List options and default values in the GPG Conf format.  */
552
553       /* The following list is taken from gnupg/tools/gpgconf-comp.c.  */
554       /* Option flags.  YOU MUST NOT CHANGE THE NUMBERS OF THE EXISTING
555          FLAGS, AS THEY ARE PART OF THE EXTERNAL INTERFACE.  */
556 #define GC_OPT_FLAG_NONE        0UL
557       /* The RUNTIME flag for an option indicates that the option can be
558          changed at runtime.  */
559 #define GC_OPT_FLAG_RUNTIME     (1UL << 3)
560       /* The DEFAULT flag for an option indicates that the option has a
561          default value.  */
562 #define GC_OPT_FLAG_DEFAULT     (1UL << 4)
563       /* The DEF_DESC flag for an option indicates that the option has a
564          default, which is described by the value of the default field.  */
565 #define GC_OPT_FLAG_DEF_DESC    (1UL << 5)
566       /* The NO_ARG_DESC flag for an option indicates that the argument has
567          a default, which is described by the value of the ARGDEF field.  */
568 #define GC_OPT_FLAG_NO_ARG_DESC (1UL << 6)
569       if (!config_filename)
570         config_filename = make_filename (opt.homedir, "scdaemon.conf", NULL );
571
572       printf ("gpgconf-scdaemon.conf:%lu:\"%s\n",
573               GC_OPT_FLAG_DEFAULT, config_filename);
574         
575       printf ("verbose:%lu:\n"
576               "quiet:%lu:\n"
577               "debug-level:%lu:\"none:\n"
578               "log-file:%lu:\n",
579               GC_OPT_FLAG_NONE,
580               GC_OPT_FLAG_NONE,
581               GC_OPT_FLAG_DEFAULT,
582               GC_OPT_FLAG_NONE );
583
584       printf ("reader-port:%lu:\n", GC_OPT_FLAG_NONE );
585       printf ("ctapi-driver:%lu:\n", GC_OPT_FLAG_NONE );
586       printf ("pcsc-driver:%lu:\"%s:\n",
587               GC_OPT_FLAG_DEFAULT, DEFAULT_PCSC_DRIVER );
588 #ifdef HAVE_LIBUSB
589       printf ("disable-ccid:%lu:\n", GC_OPT_FLAG_NONE );
590 #endif
591 #ifdef HAVE_LIBUSB
592       printf ("disable-opensc:%lu:\n", GC_OPT_FLAG_NONE );
593 #endif
594       printf ("allow-admin:%lu:\n", GC_OPT_FLAG_NONE );
595
596
597       scd_exit (0);
598     }
599
600   /* now start with logging to a file if this is desired */
601   if (logfile)
602     {
603       log_set_file (logfile);
604       log_set_prefix (NULL, 1|2|4);
605     }
606
607
608   if (pipe_server)
609     { /* This is the simple pipe based server */
610 #ifndef HAVE_OPENSC
611 #ifdef USE_GNU_PTH
612       pth_attr_t tattr;
613  
614       tattr = pth_attr_new();
615       pth_attr_set (tattr, PTH_ATTR_JOINABLE, 0);
616       pth_attr_set (tattr, PTH_ATTR_STACK_SIZE, 512*1024);
617       pth_attr_set (tattr, PTH_ATTR_NAME, "ticker");
618
619       if (!pth_spawn (tattr, ticker_thread, NULL))
620         {
621           log_error ("error spawning ticker thread: %s\n", strerror (errno));
622           scd_exit (2);
623         }
624 #endif /*USE_GNU_PTH*/
625 #endif /*!HAVE_OPENSC*/
626       scd_command_handler (-1);
627     }
628   else if (!is_daemon)
629     {
630       log_info (_("please use the option `--daemon'"
631                   " to run the program in the background\n"));
632     }
633   else
634     { /* regular server mode */
635       int fd;
636       pid_t pid;
637       int i;
638       int len;
639       struct sockaddr_un serv_addr;
640       char *p;
641
642       /* fixme: if there is already a running gpg-agent we should
643          share the same directory - and vice versa */
644       *socket_name = 0;
645       snprintf (socket_name, DIM(socket_name)-1,
646                 "/tmp/gpg-XXXXXX/S.scdaemon");
647       socket_name[DIM(socket_name)-1] = 0;
648       p = strrchr (socket_name, '/');
649       if (!p)
650         BUG ();
651       *p = 0;;
652       if (!mkdtemp(socket_name))
653         {
654           log_error ("can't create directory `%s': %s\n",
655                      socket_name, strerror(errno) );
656           exit (1);
657         }
658       *p = '/';
659
660       if (strchr (socket_name, ':') )
661         {
662           log_error ("colons are not allowed in the socket name\n");
663           exit (1);
664         }
665       if (strlen (socket_name)+1 >= sizeof serv_addr.sun_path ) 
666         {
667           log_error ("name of socket to long\n");
668           exit (1);
669         }
670    
671
672       fd = socket (AF_UNIX, SOCK_STREAM, 0);
673       if (fd == -1)
674         {
675           log_error ("can't create socket: %s\n", strerror(errno) );
676           exit (1);
677         }
678
679       memset (&serv_addr, 0, sizeof serv_addr);
680       serv_addr.sun_family = AF_UNIX;
681       strcpy (serv_addr.sun_path, socket_name);
682       len = (offsetof (struct sockaddr_un, sun_path)
683              + strlen(serv_addr.sun_path) + 1);
684
685       if (bind (fd, (struct sockaddr*)&serv_addr, len) == -1)
686         {
687           log_error ("error binding socket to `%s': %s\n",
688                      serv_addr.sun_path, strerror (errno) );
689           close (fd);
690           exit (1);
691         }
692   
693       if (listen (fd, 5 ) == -1)
694         {
695           log_error ("listen() failed: %s\n", strerror (errno));
696           close (fd);
697           exit (1);
698         }
699
700       if (opt.verbose)
701         log_info ("listening on socket `%s'\n", socket_name );
702
703
704       fflush (NULL);
705       pid = fork ();
706       if (pid == (pid_t)-1) 
707         {
708           log_fatal ("fork failed: %s\n", strerror (errno) );
709           exit (1);
710         }
711       else if (pid) 
712         { /* we are the parent */
713           char *infostr;
714           
715           close (fd);
716           
717           /* create the info string: <name>:<pid>:<protocol_version> */
718           if (asprintf (&infostr, "SCDAEMON_INFO=%s:%lu:1",
719                         socket_name, (ulong)pid ) < 0)
720             {
721               log_error ("out of core\n");
722               kill (pid, SIGTERM);
723               exit (1);
724             }
725           *socket_name = 0; /* don't let cleanup() remove the socket -
726                                the child should do this from now on */
727           if (argc) 
728             { /* run the program given on the commandline */
729               if (putenv (infostr))
730                 {
731                   log_error ("failed to set environment: %s\n",
732                              strerror (errno) );
733                   kill (pid, SIGTERM );
734                   exit (1);
735                 }
736               execvp (argv[0], argv);
737               log_error ("failed to run the command: %s\n", strerror (errno));
738               kill (pid, SIGTERM);
739               exit (1);
740             }
741           else
742             {
743               /* print the environment string, so that the caller can use
744                  shell's eval to set it */
745               if (csh_style)
746                 {
747                   *strchr (infostr, '=') = ' ';
748                   printf ( "setenv %s\n", infostr);
749                 }
750               else
751                 {
752                   printf ( "%s; export SCDAEMON_INFO;\n", infostr);
753                 }
754               free (infostr);
755               exit (0); 
756             }
757           /* NOTREACHED */
758         } /* end parent */
759       
760       /* this is the child */
761
762       /* detach from tty and put process into a new session */
763       if (!nodetach )
764         {  /* close stdin, stdout and stderr unless it is the log stream */
765           for (i=0; i <= 2; i++) 
766             {
767               if ( log_get_fd () != i)
768                 close (i);
769             }
770           if (setsid() == -1)
771             {
772               log_error ("setsid() failed: %s\n", strerror(errno) );
773               cleanup ();
774               exit (1);
775             }
776         }
777
778       /* setup signals */
779       {
780         struct sigaction oact, nact;
781         
782         nact.sa_handler = cleanup_sh;
783         sigemptyset (&nact.sa_mask);
784         nact.sa_flags = 0;
785         
786         sigaction (SIGHUP, NULL, &oact);
787         if (oact.sa_handler != SIG_IGN)
788           sigaction (SIGHUP, &nact, NULL);
789         sigaction( SIGTERM, NULL, &oact );
790         if (oact.sa_handler != SIG_IGN)
791           sigaction (SIGTERM, &nact, NULL);
792         nact.sa_handler = SIG_IGN;
793         sigaction (SIGPIPE, &nact, NULL);
794         sigaction (SIGINT, &nact, NULL);
795       }
796
797       if (chdir("/"))
798         {
799           log_error ("chdir to / failed: %s\n", strerror (errno));
800           exit (1);
801         }
802
803       scd_command_handler (fd);
804
805       close (fd);
806     }
807   
808   return 0;
809 }
810
811 void
812 scd_exit (int rc)
813 {
814 #if 0
815 #warning no update_random_seed_file
816   update_random_seed_file();
817 #endif
818 #if 0
819   /* at this time a bit annoying */
820   if (opt.debug & DBG_MEMSTAT_VALUE)
821     {
822       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
823       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
824     }
825   if (opt.debug)
826     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
827 #endif
828   gcry_control (GCRYCTL_TERM_SECMEM );
829   rc = rc? rc : log_get_errorcount(0)? 2 : 0;
830   exit (rc);
831 }
832
833
834 void
835 scd_init_default_ctrl (CTRL ctrl)
836 {
837   ctrl->reader_slot = -1;
838 }
839
840
841 #ifndef HAVE_OPENSC
842 #ifdef USE_GNU_PTH
843
844 static void
845 handle_signal (int signo)
846 {
847   switch (signo)
848     {
849     case SIGHUP:
850       log_info ("SIGHUP received - "
851                 "re-reading configuration and resetting cards\n");
852 /*       reread_configuration (); */
853       break;
854       
855     case SIGUSR1:
856       log_info ("SIGUSR1 received - no action defined\n");
857       break;
858
859     case SIGUSR2:
860       log_info ("SIGUSR2 received - no action defined\n");
861       break;
862
863     case SIGTERM:
864       if (!shutdown_pending)
865         log_info ("SIGTERM received - shutting down ...\n");
866       else
867         log_info ("SIGTERM received - still %ld running threads\n",
868                   pth_ctrl( PTH_CTRL_GETTHREADS ));
869       shutdown_pending++;
870       if (shutdown_pending > 2)
871         {
872           log_info ("shutdown forced\n");
873           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
874           cleanup ();
875           scd_exit (0);
876         }
877       break;
878         
879     case SIGINT:
880       log_info ("SIGINT received - immediate shutdown\n");
881       log_info( "%s %s stopped\n", strusage(11), strusage(13));
882       cleanup ();
883       scd_exit (0);
884       break;
885
886     default:
887       log_info ("signal %d received - no action defined\n", signo);
888     }
889 }
890
891 static void
892 handle_tick (void)
893 {
894   scd_update_reader_status_file ();
895 }
896
897 static void *
898 ticker_thread (void *dummy_arg)
899 {
900   pth_event_t sigs_ev, time_ev = NULL;
901   sigset_t sigs;
902   int signo;
903
904   sigemptyset (&sigs );
905   sigaddset (&sigs, SIGHUP);
906   sigaddset (&sigs, SIGUSR1);
907   sigaddset (&sigs, SIGUSR2);
908   sigaddset (&sigs, SIGINT);
909   sigaddset (&sigs, SIGTERM);
910   sigs_ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
911   
912   for (;;)
913     {
914       if (!time_ev)
915         {
916           time_ev = pth_event (PTH_EVENT_TIME, pth_timeout (2, 0));
917           if (time_ev)
918             pth_event_concat (sigs_ev, time_ev, NULL);
919         }
920
921       if (pth_wait (sigs_ev) < 1)
922         continue;
923
924       if (
925 #ifdef PTH_STATUS_OCCURRED     /* This is Pth 2 */
926           pth_event_status (sigs_ev) == PTH_STATUS_OCCURRED
927 #else
928           pth_event_occurred (sigs_ev)
929 #endif
930           )
931         handle_signal (signo);
932
933       /* Always run the ticker. */
934       if (!shutdown_pending)
935         {
936           pth_event_isolate (sigs_ev);
937           pth_event_free (time_ev, PTH_FREE_ALL);
938           time_ev = NULL;
939           handle_tick ();
940         }
941     }
942
943   pth_event_free (sigs_ev, PTH_FREE_ALL);
944 }
945 #endif /*USE_GNU_PTH*/
946 #endif /*!HAVE_OPENSC*/