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