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