Port Windows code to NPTH.
[gnupg.git] / g13 / g13.c
1 /* g13.c - Disk Key management with GnuPG
2  * Copyright (C) 2009 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 3 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, see <http://www.gnu.org/licenses/>.
18  */
19
20 #include <config.h>
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include <errno.h>
25 #include <ctype.h>
26 #include <unistd.h>
27 #include <fcntl.h>
28 #include <npth.h>
29
30 #include "g13.h"
31
32 #include <gcrypt.h>
33 #include <assuan.h>
34
35 #include "i18n.h"
36 #include "sysutils.h"
37 #include "gc-opt-flags.h"
38 #include "asshelp.h"
39 #include "keyblob.h"
40 #include "server.h"
41 #include "runner.h"
42 #include "create.h"
43 #include "mount.h"
44 #include "mountinfo.h"
45
46
47 enum cmd_and_opt_values {
48   aNull = 0,
49   oQuiet        = 'q',
50   oVerbose      = 'v',
51   oRecipient    = 'r',
52
53   aGPGConfList  = 500,
54   aGPGConfTest,
55   aCreate,
56   aMount,
57   aUmount,
58   aServer,
59
60   oOptions,
61   oDebug,
62   oDebugLevel,
63   oDebugAll,
64   oDebugNone,
65   oDebugWait,
66   oDebugAllowCoreDump,
67   oLogFile,
68   oNoLogFile,
69   oAuditLog,
70
71   oOutput,
72
73   oAgentProgram,
74   oGpgProgram,
75
76   oDisplay,
77   oTTYname,
78   oTTYtype,
79   oLCctype,
80   oLCmessages,
81   oXauthority,
82
83   oStatusFD,
84   oLoggerFD,
85
86   oNoVerbose,
87   oNoSecmemWarn,
88   oNoGreeting,
89   oNoTTY,
90   oNoOptions,
91   oHomedir,
92   oWithColons,
93   oDryRun,
94   oNoDetach,
95
96   oNoRandomSeedFile,
97   oFakedSystemTime
98  };
99
100
101 static ARGPARSE_OPTS opts[] = {
102
103   ARGPARSE_group (300, N_("@Commands:\n ")),
104
105   ARGPARSE_c (aCreate, "create", N_("Create a new file system container")),
106   ARGPARSE_c (aMount,  "mount",  N_("Mount a file system container") ),
107   ARGPARSE_c (aUmount, "umount", N_("Unmount a file system container") ),
108   ARGPARSE_c (aServer, "server", N_("Run in server mode")),
109
110   ARGPARSE_c (aGPGConfList, "gpgconf-list", "@"),
111   ARGPARSE_c (aGPGConfTest, "gpgconf-test", "@"),
112
113   ARGPARSE_group (301, N_("@\nOptions:\n ")),
114
115   ARGPARSE_s_s (oRecipient, "recipient", N_("|USER-ID|encrypt for USER-ID")),
116
117   ARGPARSE_s_s (oOutput, "output", N_("|FILE|write output to FILE")),
118   ARGPARSE_s_n (oVerbose, "verbose", N_("verbose")),
119   ARGPARSE_s_n (oQuiet, "quiet",  N_("be somewhat more quiet")),
120   ARGPARSE_s_n (oNoTTY, "no-tty", N_("don't use the terminal at all")),
121   ARGPARSE_s_n (oNoDetach, "no-detach", N_("do not detach from the console")),
122   ARGPARSE_s_s (oLogFile, "log-file",  N_("|FILE|write log output to FILE")),
123   ARGPARSE_s_n (oNoLogFile, "no-log-file", "@"),
124   ARGPARSE_s_i (oLoggerFD, "logger-fd", "@"),
125
126   ARGPARSE_s_n (oDryRun, "dry-run", N_("do not make any changes")),
127
128   ARGPARSE_s_s (oOptions, "options", N_("|FILE|read options from FILE")),
129
130   ARGPARSE_p_u (oDebug, "debug", "@"),
131   ARGPARSE_s_s (oDebugLevel, "debug-level",
132                 N_("|LEVEL|set the debugging level to LEVEL")),
133   ARGPARSE_s_n (oDebugAll, "debug-all", "@"),
134   ARGPARSE_s_n (oDebugNone, "debug-none", "@"),
135   ARGPARSE_s_i (oDebugWait, "debug-wait", "@"),
136   ARGPARSE_s_n (oDebugAllowCoreDump, "debug-allow-core-dump", "@"),
137
138   ARGPARSE_s_i (oStatusFD, "status-fd",
139                 N_("|FD|write status info to this FD")),
140
141   ARGPARSE_group (302, N_(
142   "@\n(See the man page for a complete listing of all commands and options)\n"
143   )),
144
145   ARGPARSE_group (303, N_("@\nExamples:\n\n"
146     " blurb\n"
147                           " blurb\n")),
148
149   /* Hidden options. */
150   ARGPARSE_s_n (oNoVerbose, "no-verbose", "@"),
151   ARGPARSE_s_n (oNoSecmemWarn, "no-secmem-warning", "@"),
152   ARGPARSE_s_n (oNoGreeting, "no-greeting", "@"),
153   ARGPARSE_s_n (oNoOptions, "no-options", "@"),
154   ARGPARSE_s_s (oHomedir, "homedir", "@"),
155   ARGPARSE_s_s (oAgentProgram, "agent-program", "@"),
156   ARGPARSE_s_s (oGpgProgram, "gpg-program", "@"),
157   ARGPARSE_s_s (oDisplay,    "display", "@"),
158   ARGPARSE_s_s (oTTYname,    "ttyname", "@"),
159   ARGPARSE_s_s (oTTYtype,    "ttytype", "@"),
160   ARGPARSE_s_s (oLCctype,    "lc-ctype", "@"),
161   ARGPARSE_s_s (oLCmessages, "lc-messages", "@"),
162   ARGPARSE_s_s (oXauthority, "xauthority", "@"),
163   ARGPARSE_s_s (oFakedSystemTime, "faked-system-time", "@"),
164   ARGPARSE_s_n (oWithColons, "with-colons", "@"),
165   ARGPARSE_s_n (oNoRandomSeedFile,  "no-random-seed-file", "@"),
166
167   /* Command aliases.  */
168
169   ARGPARSE_end ()
170 };
171
172
173 /* The timer tick interval used by the idle task.  */
174 #define TIMERTICK_INTERVAL_SEC     (1)
175
176
177 /* Global variable to keep an error count. */
178 int g13_errors_seen = 0;
179
180 /* It is possible that we are currently running under setuid permissions.  */
181 static int maybe_setuid = 1;
182
183 /* Helper to implement --debug-level and --debug.  */
184 static const char *debug_level;
185 static unsigned int debug_value;
186
187 /* Flag to indicate that a shutdown was requested.  */
188 static int shutdown_pending;
189
190 /* The thread id of the idle task.  */
191 static npth_t idle_task_thread;
192
193
194 \f
195 static void set_cmd (enum cmd_and_opt_values *ret_cmd,
196                      enum cmd_and_opt_values new_cmd );
197
198 static void emergency_cleanup (void);
199 static void start_idle_task (void);
200 static void join_idle_task (void);
201
202 \f
203 /* Begin NPth wrapper functions. */
204 ASSUAN_SYSTEM_NPTH_IMPL;
205
206 \f
207 static const char *
208 my_strusage( int level )
209 {
210   const char *p;
211
212   switch (level)
213     {
214     case 11: p = "g13 (GnuPG)";
215       break;
216     case 13: p = VERSION; break;
217     case 17: p = PRINTABLE_OS_NAME; break;
218     case 19: p = _("Please report bugs to <" PACKAGE_BUGREPORT ">.\n");
219       break;
220     case 1:
221     case 40: p = _("Usage: g13 [options] [files] (-h for help)");
222       break;
223     case 41:
224       p = _("Syntax: g13 [options] [files]\n"
225             "Create, mount or unmount an encrypted file system container\n");
226       break;
227
228     case 31: p = "\nHome: "; break;
229     case 32: p = opt.homedir; break;
230
231     default: p = NULL; break;
232     }
233   return p;
234 }
235
236
237 static void
238 wrong_args (const char *text)
239 {
240   fputs (_("usage: g13 [options] "), stderr);
241   fputs (text, stderr);
242   putc ('\n', stderr);
243   g13_exit (2);
244 }
245
246
247 /* Setup the debugging.  With a DEBUG_LEVEL of NULL only the active
248    debug flags are propagated to the subsystems.  With DEBUG_LEVEL
249    set, a specific set of debug flags is set; and individual debugging
250    flags will be added on top.  */
251 static void
252 set_debug (void)
253 {
254   int numok = (debug_level && digitp (debug_level));
255   int numlvl = numok? atoi (debug_level) : 0;
256
257   if (!debug_level)
258     ;
259   else if (!strcmp (debug_level, "none") || (numok && numlvl < 1))
260     opt.debug = 0;
261   else if (!strcmp (debug_level, "basic") || (numok && numlvl <= 2))
262     opt.debug = DBG_ASSUAN_VALUE|DBG_MOUNT_VALUE;
263   else if (!strcmp (debug_level, "advanced") || (numok && numlvl <= 5))
264     opt.debug = DBG_ASSUAN_VALUE|DBG_MOUNT_VALUE;
265   else if (!strcmp (debug_level, "expert") || (numok && numlvl <= 8))
266     opt.debug = (DBG_ASSUAN_VALUE|DBG_MOUNT_VALUE|DBG_CRYPTO_VALUE);
267   else if (!strcmp (debug_level, "guru") || numok)
268     {
269       opt.debug = ~0;
270       /* if (numok) */
271       /*   opt.debug &= ~(DBG_HASHING_VALUE); */
272     }
273   else
274     {
275       log_error (_("invalid debug-level `%s' given\n"), debug_level);
276       g13_exit(2);
277     }
278
279   opt.debug |= debug_value;
280
281   if (opt.debug && !opt.verbose)
282     opt.verbose = 1;
283   if (opt.debug)
284     opt.quiet = 0;
285
286   if (opt.debug & DBG_CRYPTO_VALUE )
287     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1);
288   gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
289
290   if (opt.debug)
291     log_info ("enabled debug flags:%s%s%s%s%s\n",
292               (opt.debug & DBG_MOUNT_VALUE  )? " mount":"",
293               (opt.debug & DBG_CRYPTO_VALUE )? " crypto":"",
294               (opt.debug & DBG_MEMORY_VALUE )? " memory":"",
295               (opt.debug & DBG_MEMSTAT_VALUE)? " memstat":"",
296               (opt.debug & DBG_ASSUAN_VALUE )? " assuan":"");
297 }
298
299
300
301 static void
302 set_cmd (enum cmd_and_opt_values *ret_cmd, enum cmd_and_opt_values new_cmd)
303 {
304   enum cmd_and_opt_values cmd = *ret_cmd;
305
306   if (!cmd || cmd == new_cmd)
307     cmd = new_cmd;
308   else
309     {
310       log_error (_("conflicting commands\n"));
311       g13_exit (2);
312     }
313
314   *ret_cmd = cmd;
315 }
316
317
318 int
319 main ( int argc, char **argv)
320 {
321   ARGPARSE_ARGS pargs;
322   int orig_argc;
323   char **orig_argv;
324   gpg_error_t err = 0;
325   const char *fname;
326   int may_coredump;
327   FILE *configfp = NULL;
328   char *configname = NULL;
329   unsigned configlineno;
330   int parse_debug = 0;
331   int no_more_options = 0;
332   int default_config =1;
333   char *logfile = NULL;
334   int greeting = 0;
335   int nogreeting = 0;
336   int debug_wait = 0;
337   int use_random_seed = 1;
338   int nodetach = 0;
339   int nokeysetup = 0;
340   enum cmd_and_opt_values cmd = 0;
341   struct server_control_s ctrl;
342   strlist_t recipients = NULL;
343
344   /*mtrace();*/
345
346   gnupg_reopen_std ("g13");
347   set_strusage (my_strusage);
348   gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
349
350   log_set_prefix ("g13", 1);
351
352   /* Make sure that our subsystems are ready.  */
353   i18n_init ();
354   init_common_subsystems (&argc, &argv);
355
356   npth_init ();
357
358   /* Check that the Libgcrypt is suitable.  */
359   if (!gcry_check_version (NEED_LIBGCRYPT_VERSION) )
360     log_fatal (_("%s is too old (need %s, have %s)\n"), "libgcrypt",
361                NEED_LIBGCRYPT_VERSION, gcry_check_version (NULL) );
362
363   /* Take extra care of the random pool.  */
364   gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
365
366   may_coredump = disable_core_dumps ();
367
368   gnupg_init_signals (0, emergency_cleanup);
369
370   dotlock_create (NULL, 0); /* Register locking cleanup.  */
371
372   opt.session_env = session_env_new ();
373   if (!opt.session_env)
374     log_fatal ("error allocating session environment block: %s\n",
375                strerror (errno));
376
377   opt.homedir = default_homedir ();
378
379   /* First check whether we have a config file on the commandline.  */
380   orig_argc = argc;
381   orig_argv = argv;
382   pargs.argc = &argc;
383   pargs.argv = &argv;
384   pargs.flags= 1|(1<<6);  /* Do not remove the args, ignore version.  */
385   while (arg_parse( &pargs, opts))
386     {
387       if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll)
388         parse_debug++;
389       else if (pargs.r_opt == oOptions)
390         { /* Yes, there is one, so we do not try the default one but
391              read the config file when it is encountered at the
392              commandline.  */
393           default_config = 0;
394         }
395       else if (pargs.r_opt == oNoOptions)
396         default_config = 0; /* --no-options */
397       else if (pargs.r_opt == oHomedir)
398         opt.homedir = pargs.r.ret_str;
399     }
400
401   /* Initialize the secure memory. */
402   gcry_control (GCRYCTL_INIT_SECMEM, 16384, 0);
403   maybe_setuid = 0;
404
405   /*
406      Now we are now working under our real uid
407   */
408
409   /* Setup malloc hooks. */
410   {
411     struct assuan_malloc_hooks malloc_hooks;
412
413     malloc_hooks.malloc = gcry_malloc;
414     malloc_hooks.realloc = gcry_realloc;
415     malloc_hooks.free = gcry_free;
416     assuan_set_malloc_hooks (&malloc_hooks);
417   }
418
419   /* Prepare libassuan.  */
420   assuan_set_gpg_err_source (GPG_ERR_SOURCE_DEFAULT);
421   assuan_set_system_hooks (ASSUAN_SYSTEM_NPTH);
422   setup_libassuan_logging (&opt.debug);
423
424   /* Setup a default control structure for command line mode.  */
425   memset (&ctrl, 0, sizeof ctrl);
426   g13_init_default_ctrl (&ctrl);
427   ctrl.no_server = 1;
428   ctrl.status_fd = -1; /* No status output. */
429
430   /* Set the default option file */
431   if (default_config )
432     configname = make_filename (opt.homedir, "g13.conf", NULL);
433
434   argc        = orig_argc;
435   argv        = orig_argv;
436   pargs.argc  = &argc;
437   pargs.argv  = &argv;
438   pargs.flags =  1;  /* Do not remove the args.  */
439
440  next_pass:
441   if (configname)
442     {
443       configlineno = 0;
444       configfp = fopen (configname, "r");
445       if (!configfp)
446         {
447           if (default_config)
448             {
449               if (parse_debug)
450                 log_info (_("NOTE: no default option file `%s'\n"), configname);
451             }
452           else
453             {
454               log_error (_("option file `%s': %s\n"),
455                          configname, strerror(errno));
456               g13_exit(2);
457             }
458           xfree (configname);
459           configname = NULL;
460         }
461       if (parse_debug && configname)
462         log_info (_("reading options from `%s'\n"), configname);
463       default_config = 0;
464     }
465
466   while (!no_more_options
467          && optfile_parse (configfp, configname, &configlineno, &pargs, opts))
468     {
469       switch (pargs.r_opt)
470         {
471         case aGPGConfList:
472         case aGPGConfTest:
473           set_cmd (&cmd, pargs.r_opt);
474           nogreeting = 1;
475           nokeysetup = 1;
476           break;
477
478         case aServer:
479         case aMount:
480         case aUmount:
481           nokeysetup = 1;
482         case aCreate:
483           set_cmd (&cmd, pargs.r_opt);
484           break;
485
486         case oOutput: opt.outfile = pargs.r.ret_str; break;
487
488         case oQuiet: opt.quiet = 1; break;
489         case oNoGreeting: nogreeting = 1; break;
490         case oNoTTY:  break;
491
492         case oDryRun: opt.dry_run = 1; break;
493
494         case oVerbose:
495           opt.verbose++;
496           gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
497           break;
498         case oNoVerbose:
499           opt.verbose = 0;
500           gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
501           break;
502
503         case oLogFile: logfile = pargs.r.ret_str; break;
504         case oNoLogFile: logfile = NULL; break;
505
506         case oNoDetach: nodetach = 1; break;
507
508         case oDebug: debug_value |= pargs.r.ret_ulong; break;
509         case oDebugAll: debug_value = ~0; break;
510         case oDebugNone: debug_value = 0; break;
511         case oDebugLevel: debug_level = pargs.r.ret_str; break;
512         case oDebugWait: debug_wait = pargs.r.ret_int; break;
513         case oDebugAllowCoreDump:
514           may_coredump = enable_core_dumps ();
515           break;
516
517         case oStatusFD: ctrl.status_fd = pargs.r.ret_int; break;
518         case oLoggerFD: log_set_fd (pargs.r.ret_int ); break;
519
520         case oNoOptions: break; /* no-options */
521         case oOptions:
522           /* Config files may not be nested (silently ignore them).  */
523           if (!configfp)
524             {
525               xfree(configname);
526               configname = xstrdup (pargs.r.ret_str);
527               goto next_pass;
528             }
529           break;
530
531         case oHomedir: opt.homedir = pargs.r.ret_str; break;
532
533         case oAgentProgram: opt.agent_program = pargs.r.ret_str;  break;
534         case oGpgProgram: opt.gpg_program = pargs.r.ret_str;  break;
535         case oDisplay: opt.display = xstrdup (pargs.r.ret_str); break;
536         case oTTYname: opt.ttyname = xstrdup (pargs.r.ret_str); break;
537         case oTTYtype: opt.ttytype = xstrdup (pargs.r.ret_str); break;
538         case oLCctype: opt.lc_ctype = xstrdup (pargs.r.ret_str); break;
539         case oLCmessages: opt.lc_messages = xstrdup (pargs.r.ret_str); break;
540         case oXauthority: opt.xauthority = xstrdup (pargs.r.ret_str); break;
541
542         case oFakedSystemTime:
543           {
544             time_t faked_time = isotime2epoch (pargs.r.ret_str);
545             if (faked_time == (time_t)(-1))
546               faked_time = (time_t)strtoul (pargs.r.ret_str, NULL, 10);
547             gnupg_set_time (faked_time, 0);
548           }
549           break;
550
551         case oNoSecmemWarn: gcry_control (GCRYCTL_DISABLE_SECMEM_WARN); break;
552
553         case oNoRandomSeedFile: use_random_seed = 0; break;
554
555         case oRecipient: /* Store the encryption key.  */
556           add_to_strlist (&recipients, pargs.r.ret_str);
557           break;
558
559
560         default:
561           pargs.err = configfp? ARGPARSE_PRINT_WARNING:ARGPARSE_PRINT_ERROR;
562           break;
563         }
564     }
565
566   if (configfp)
567     {
568       fclose (configfp);
569       configfp = NULL;
570       /* Keep a copy of the config filename. */
571       opt.config_filename = configname;
572       configname = NULL;
573       goto next_pass;
574     }
575   xfree (configname);
576   configname = NULL;
577
578   if (!opt.config_filename)
579     opt.config_filename = make_filename (opt.homedir, "g13.conf", NULL);
580
581   if (log_get_errorcount(0))
582     g13_exit(2);
583
584   /* Now that we have the options parsed we need to update the default
585      control structure.  */
586   g13_init_default_ctrl (&ctrl);
587
588   if (nogreeting)
589     greeting = 0;
590
591   if (greeting)
592     {
593       fprintf (stderr, "%s %s; %s\n",
594                strusage(11), strusage(13), strusage(14) );
595       fprintf (stderr, "%s\n", strusage(15) );
596     }
597
598   if (may_coredump && !opt.quiet)
599     log_info (_("WARNING: program may create a core file!\n"));
600
601   if (logfile)
602     {
603       log_set_file (logfile);
604       log_set_prefix (NULL, 1|2|4);
605     }
606
607   if (gnupg_faked_time_p ())
608     {
609       gnupg_isotime_t tbuf;
610
611       log_info (_("WARNING: running with faked system time: "));
612       gnupg_get_isotime (tbuf);
613       dump_isotime (tbuf);
614       log_printf ("\n");
615     }
616
617   /* Print any pending secure memory warnings.  */
618   gcry_control (GCRYCTL_RESUME_SECMEM_WARN);
619
620   /* Setup the debug flags for all subsystems.  */
621   set_debug ();
622
623   /* Install a regular exit handler to make real sure that the secure
624      memory gets wiped out.  */
625   if (atexit (emergency_cleanup))
626     {
627       log_error ("atexit failed\n");
628       g13_exit (2);
629     }
630
631   /* Terminate if we found any error until now.  */
632   if (log_get_errorcount(0))
633     g13_exit (2);
634
635   /* Set the standard GnuPG random seed file.  */
636   if (use_random_seed)
637     {
638       char *p = make_filename (opt.homedir, "random_seed", NULL);
639       gcry_control (GCRYCTL_SET_RANDOM_SEED_FILE, p);
640       xfree(p);
641     }
642
643   /* Store given filename into FNAME. */
644   fname = argc? *argv : NULL;
645
646   /* Parse all given encryption keys.  This does a lookup of the keys
647      and stops if any of the given keys was not found. */
648 #if 0 /* Currently not implemented.  */
649   if (!nokeysetup)
650     {
651       strlist_t sl;
652       int failed = 0;
653
654       for (sl = recipients; sl; sl = sl->next)
655         if (check_encryption_key ())
656           failed = 1;
657       if (failed)
658         g13_exit (1);
659     }
660 #endif /*0*/
661
662   /* Dispatch command.  */
663   err = 0;
664   switch (cmd)
665     {
666     case aGPGConfList:
667       { /* List options and default values in the GPG Conf format.  */
668         char *config_filename_esc = percent_escape (opt.config_filename, NULL);
669
670         printf ("gpgconf-g13.conf:%lu:\"%s\n",
671                 GC_OPT_FLAG_DEFAULT, config_filename_esc);
672         xfree (config_filename_esc);
673
674         printf ("verbose:%lu:\n", GC_OPT_FLAG_NONE);
675         printf ("quiet:%lu:\n", GC_OPT_FLAG_NONE);
676         printf ("debug-level:%lu:\"none:\n", GC_OPT_FLAG_DEFAULT);
677         printf ("log-file:%lu:\n", GC_OPT_FLAG_NONE);
678       }
679       break;
680     case aGPGConfTest:
681       /* This is merely a dummy command to test whether the
682          configuration file is valid.  */
683       break;
684
685     case aServer:
686       {
687         start_idle_task ();
688         ctrl.no_server = 0;
689         err = g13_server (&ctrl);
690         if (err)
691           log_error ("server exited with error: %s <%s>\n",
692                      gpg_strerror (err), gpg_strsource (err));
693         else
694           shutdown_pending++;
695       }
696       break;
697
698     case aCreate: /* Create a new container. */
699       {
700         if (argc != 1)
701           wrong_args ("--create filename");
702         start_idle_task ();
703         err = g13_create_container (&ctrl, argv[0], recipients);
704         if (err)
705           log_error ("error creating a new container: %s <%s>\n",
706                      gpg_strerror (err), gpg_strsource (err));
707         else
708           shutdown_pending++;
709       }
710       break;
711
712     case aMount: /* Mount a container. */
713       {
714         if (argc != 1 && argc != 2 )
715           wrong_args ("--mount filename [mountpoint]");
716         start_idle_task ();
717         err = g13_mount_container (&ctrl, argv[0], argc == 2?argv[1]:NULL);
718         if (err)
719           log_error ("error mounting container `%s': %s <%s>\n",
720                      *argv, gpg_strerror (err), gpg_strsource (err));
721       }
722       break;
723
724     default:
725       log_error (_("invalid command (there is no implicit command)\n"));
726       break;
727     }
728
729   if (!err)
730     join_idle_task ();
731
732   /* Cleanup.  */
733   g13_exit (0);
734   return 8; /*NOTREACHED*/
735 }
736
737
738 /* Note: This function is used by signal handlers!. */
739 static void
740 emergency_cleanup (void)
741 {
742   gcry_control (GCRYCTL_TERM_SECMEM );
743 }
744
745
746 void
747 g13_exit (int rc)
748 {
749   gcry_control (GCRYCTL_UPDATE_RANDOM_SEED_FILE);
750   if (opt.debug & DBG_MEMSTAT_VALUE)
751     {
752       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
753       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
754     }
755   if (opt.debug)
756     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
757   emergency_cleanup ();
758   rc = rc? rc : log_get_errorcount(0)? 2 : g13_errors_seen? 1 : 0;
759   exit (rc);
760 }
761
762
763 /* Store defaults into the per-connection CTRL object.  */
764 void
765 g13_init_default_ctrl (struct server_control_s *ctrl)
766 {
767   ctrl->conttype = CONTTYPE_ENCFS;
768 }
769
770
771 /* This function is called for each signal we catch.  It is run in the
772    main context or the one of a NPth thread and thus it is not
773    restricted in what it may do.  */
774 static void
775 handle_signal (int signo)
776 {
777   switch (signo)
778     {
779 #ifndef HAVE_W32_SYSTEM
780     case SIGHUP:
781       log_info ("SIGHUP received - re-reading configuration\n");
782       /* Fixme:  Not yet implemented.  */
783       break;
784
785     case SIGUSR1:
786       log_info ("SIGUSR1 received - printing internal information:\n");
787       /* Fixme: We need to see how to integrate pth dumping into our
788          logging system.  */
789       /* pth_ctrl (PTH_CTRL_DUMPSTATE, log_get_stream ()); */
790       mountinfo_dump_all ();
791       break;
792
793     case SIGUSR2:
794       log_info ("SIGUSR2 received - no action defined\n");
795       break;
796
797     case SIGTERM:
798       if (!shutdown_pending)
799         log_info ("SIGTERM received - shutting down ...\n");
800       else
801         log_info ("SIGTERM received - still %u runners active\n",
802                   runner_get_threads ());
803       shutdown_pending++;
804       if (shutdown_pending > 2)
805         {
806           log_info ("shutdown forced\n");
807           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
808           g13_exit (0);
809         }
810       break;
811
812     case SIGINT:
813       log_info ("SIGINT received - immediate shutdown\n");
814       log_info( "%s %s stopped\n", strusage(11), strusage(13));
815       g13_exit (0);
816       break;
817 #endif /*!HAVE_W32_SYSTEM*/
818
819     default:
820       log_info ("signal %d received - no action defined\n", signo);
821     }
822 }
823
824
825 /* This ticker function is called about every TIMERTICK_INTERVAL_SEC
826    seconds. */
827 static void
828 handle_tick (void)
829 {
830   /* log_debug ("TICK\n"); */
831 }
832
833
834 /* The idle task.  We use a separate thread to do idle stuff and to
835    catch signals.  */
836 static void *
837 idle_task (void *dummy_arg)
838 {
839   int signo;           /* The number of a raised signal is stored here.  */
840   int saved_errno;
841   struct timespec abstime;
842   struct timespec curtime;
843   struct timespec timeout;
844   int ret;
845
846   (void)dummy_arg;
847
848   /* Create the event to catch the signals. */
849 #ifndef HAVE_W32_SYSTEM
850   npth_sigev_init ();
851   npth_sigev_add (SIGHUP);
852   npth_sigev_add (SIGUSR1);
853   npth_sigev_add (SIGUSR2);
854   npth_sigev_add (SIGINT);
855   npth_sigev_add (SIGTERM);
856   npth_sigev_fini ();
857 #endif
858
859   npth_clock_gettime (&abstime);
860   abstime.tv_sec += TIMERTICK_INTERVAL_SEC;
861
862   for (;;)
863     {
864       /* The shutdown flag allows us to terminate the idle task.  */
865       if (shutdown_pending)
866         {
867           runner_cancel_all ();
868
869           if (!runner_get_threads ())
870             break; /* ready */
871         }
872
873       npth_clock_gettime (&curtime);
874       if (!(npth_timercmp (&curtime, &abstime, <)))
875         {
876           /* Timeout.  */
877           handle_tick ();
878           npth_clock_gettime (&abstime);
879           abstime.tv_sec += TIMERTICK_INTERVAL_SEC;
880         }
881       npth_timersub (&abstime, &curtime, &timeout);
882
883 #ifndef HAVE_W32_SYSTEM
884       ret = npth_pselect (0, NULL, NULL, NULL, &timeout, npth_sigev_sigmask());
885       saved_errno = errno;
886
887       while (npth_sigev_get_pending(&signo))
888         handle_signal (signo);
889 #else
890       ret = npth_eselect (0, NULL, NULL, NULL, &timeout, NULL, NULL);
891       saved_errno = errno;
892 #endif
893
894       if (ret == -1 && saved_errno != EINTR)
895         {
896           log_error (_("npth_pselect failed: %s - waiting 1s\n"),
897                      strerror (saved_errno));
898           npth_sleep (1);
899           continue;
900         }
901
902       if (ret <= 0)
903         /* Interrupt or timeout.  Will be handled when calculating the
904            next timeout.  */
905         continue;
906
907       /* Here one would add processing of file descriptors.  */
908     }
909
910   log_info (_("%s %s stopped\n"), strusage(11), strusage(13));
911   return NULL;
912 }
913
914
915 /* Start the idle task.   */
916 static void
917 start_idle_task (void)
918 {
919   npth_attr_t tattr;
920   npth_t thread;
921   sigset_t sigs;       /* The set of signals we want to catch.  */
922   int err;
923
924 #ifndef HAVE_W32_SYSTEM
925   /* These signals should always go to the idle task, so they need to
926      be blocked everywhere else.  We assume start_idle_task is called
927      from the main thread before any other threads are created.  */
928   sigemptyset (&sigs);
929   sigaddset (&sigs, SIGHUP);
930   sigaddset (&sigs, SIGUSR1);
931   sigaddset (&sigs, SIGUSR2);
932   sigaddset (&sigs, SIGINT);
933   sigaddset (&sigs, SIGTERM);
934   npth_sigmask (SIG_BLOCK, &sigs, NULL);
935 #endif
936
937   npth_attr_init (&tattr);
938   npth_attr_setdetachstate (&tattr, NPTH_CREATE_JOINABLE);
939
940   err = npth_create (&thread, &tattr, idle_task, NULL);
941   if (err)
942     {
943       log_fatal ("error starting idle task: %s\n", strerror (err));
944       return; /*NOTREACHED*/
945     }
946   npth_setname_np (thread, "idle-task");
947   idle_task_thread = thread;
948   npth_attr_destroy (&tattr);
949 }
950
951
952 /* Wait for the idle task to finish.  */
953 static void
954 join_idle_task (void)
955 {
956   int err;
957
958   /* FIXME: This assumes that a valid pthread_t is non-null.  That is
959      not guaranteed.  */
960   if (idle_task_thread)
961     {
962       err = npth_join (idle_task_thread, NULL);
963       if (err)
964         log_error ("waiting for idle task thread failed: %s\n",
965                    strerror (err));
966     }
967 }