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