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