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